static void
entropy(G_GNUC_UNUSED GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield, *mfield;
EntropyArgs args;
gboolean ok, same_units;
g_return_if_fail(run & ENTROPY_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_MASK_FIELD, &mfield,
0);
g_return_if_fail(dfield);
load_args(gwy_app_settings_get(), &args);
same_units = gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield));
if (run == GWY_RUN_INTERACTIVE) {
if (!same_units && args.mode == ENTROPY_ANGLES)
args.mode = ENTROPY_SLOPES;
ok = entropy_dialog(&args, dfield, mfield);
save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
}
static void
grain_dist(GwyContainer *data, GwyRunType run)
{
GwySIUnit *siunitxy, *siunitz;
GrainDistArgs args;
GwyDataField *dfield;
GwyDataField *mfield;
g_return_if_fail(run & DIST_RUN_MODES);
grain_dist_load_args(gwy_app_settings_get(), &args);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_MASK_FIELD, &mfield,
0);
g_return_if_fail(dfield && mfield);
siunitxy = gwy_data_field_get_si_unit_xy(dfield);
siunitz = gwy_data_field_get_si_unit_z(dfield);
args.units_equal = gwy_si_unit_equal(siunitxy, siunitz);
args.bitmask = 0xffffffffU;
if (!args.units_equal)
args.bitmask ^= 1 << GWY_GRAIN_VALUE_SURFACE_AREA;
if (run == GWY_RUN_IMMEDIATE)
grain_dist_run(&args, data, dfield, mfield);
else {
grain_dist_dialog(&args, data, dfield, mfield);
grain_dist_save_args(gwy_app_settings_get(), &args);
}
}
static void
grain_cross(GwyContainer *data, GwyRunType run)
{
GwySIUnit *siunitxy, *siunitz;
GrainCrossArgs args;
GwyDataField *dfield;
GwyDataField *mfield;
gint id;
g_return_if_fail(run & CROSS_RUN_MODES);
grain_cross_load_args(gwy_app_settings_get(), &args);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_ID, &id,
GWY_APP_MASK_FIELD, &mfield,
0);
g_return_if_fail(dfield && mfield);
siunitxy = gwy_data_field_get_si_unit_xy(dfield);
siunitz = gwy_data_field_get_si_unit_z(dfield);
args.units_equal = gwy_si_unit_equal(siunitxy, siunitz);
if (!args.units_equal) {
GwyGrainValue *abscissa, *ordinate;
GwyGrainValueFlags aflags, oflags;
abscissa = gwy_grain_values_get_grain_value(args.abscissa);
ordinate = gwy_grain_values_get_grain_value(args.ordinate);
aflags = gwy_grain_value_get_flags(abscissa);
oflags = gwy_grain_value_get_flags(ordinate);
if ((aflags | oflags) & GWY_GRAIN_VALUE_SAME_UNITS) {
if (run == GWY_RUN_IMMEDIATE) {
require_same_units_dialog(data, id);
return;
}
if (aflags & GWY_GRAIN_VALUE_SAME_UNITS) {
args.abscissa = grain_cross_defaults.abscissa;
args.abscissa_expanded = grain_cross_defaults.abscissa_expanded;
}
if (oflags & GWY_GRAIN_VALUE_SAME_UNITS) {
args.ordinate = grain_cross_defaults.ordinate;
args.ordinate_expanded = grain_cross_defaults.ordinate_expanded;
}
}
}
args.grains = g_new0(gint, mfield->xres*mfield->yres);
args.ngrains = gwy_data_field_number_grains(mfield, args.grains);
if (run == GWY_RUN_IMMEDIATE)
grain_cross_run(&args, data, dfield);
else {
if (grain_cross_dialog(&args, dfield))
grain_cross_run(&args, data, dfield);
grain_cross_save_args(gwy_app_settings_get(), &args);
}
g_free(args.grains);
}
static void
grain_filter(GwyContainer *data, GwyRunType run)
{
GwySIUnit *siunitxy, *siunitz;
GFilterArgs args;
GwyDataField *dfield, *mfield;
GQuark mquark;
gint id;
g_return_if_fail(run & GFILTER_RUN_MODES);
gfilter_load_args(gwy_app_settings_get(), &args);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_MASK_FIELD, &mfield,
GWY_APP_MASK_FIELD_KEY, &mquark,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield && mfield);
siunitxy = gwy_data_field_get_si_unit_xy(dfield);
siunitz = gwy_data_field_get_si_unit_z(dfield);
args.units_equal = gwy_si_unit_equal(siunitxy, siunitz);
args.valuedata = calculate_all_grain_values(dfield, mfield,
&args.ngrains, &args.grains);
args.sortedvaluedata = sort_grain_values(args.valuedata,
&args.nuniqvalues,
args.ngrains);
if (run == GWY_RUN_INTERACTIVE && !args.ngrains) {
GtkWidget *dialog;
gfilter_free_args(&args);
dialog = gtk_message_dialog_new
(gwy_app_find_window_for_channel(data, id),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("There are no grains to filter."));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return;
}
if (run == GWY_RUN_IMMEDIATE) {
run_noninteractive(&args, data, mfield, mquark);
gwy_app_channel_log_add_proc(data, id, id);
}
else
gfilter_dialog(&args, data, dfield, mfield, id, mquark);
gfilter_free_args(&args);
}
static void
update_sensitivity(EntropyControls *controls)
{
GwyDataField *dfield = controls->dfield;
gboolean is_slope = (controls->args->mode != ENTROPY_VALUES);
if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield))) {
GtkWidget *button = gwy_radio_buttons_find(controls->mode,
ENTROPY_ANGLES);
gtk_widget_set_sensitive(button, FALSE);
}
gtk_widget_set_sensitive(controls->fit_plane, is_slope);
gwy_table_hscale_set_sensitive(controls->kernel_size,
is_slope && controls->args->fit_plane);
}
/**
* gwy_surface_xy_is_compatible:
* @surface: A surface.
* @othersurface: Another surface.
*
* Checks whether the XY positions of two surfaces are compatible.
*
* Compatible XY positions mean the XY units are the same and the points are
* the same. Two surfaces that have the same set of XY points but in different
* orders are <emphasis>not</emphasis> considered compatible. This is because
* the points at the same index in @data are different and thus calculations
* involving data from the two surfaces are impossible. It is necessary to
* match the points order in the two surfaces to make this possible.
*
* This information is cached.
*
* Returns: %TRUE if the surfaces are XY-position compatible, %FALSE if they
* are not.
*
* Since: 2.45
**/
gboolean
gwy_surface_xy_is_compatible(GwySurface *surface,
GwySurface *othersurface)
{
g_return_val_if_fail(GWY_IS_SURFACE(surface), FALSE);
g_return_val_if_fail(GWY_IS_SURFACE(othersurface), FALSE);
ensure_units(surface);
ensure_units(othersurface);
if (!gwy_si_unit_equal(surface->priv->si_unit_xy,
othersurface->priv->si_unit_xy))
return FALSE;
ensure_checksum(surface);
ensure_checksum(othersurface);
return !memcmp(surface->priv->checksum, othersurface->priv->checksum,
sizeof(surface->priv->checksum));
}
static void
curvature(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield, *mfield;
CurvatureArgs args;
gboolean ok;
gint id;
g_return_if_fail(run & CURVATURE_RUN_MODES);
g_return_if_fail(g_type_from_name("GwyLayerLine"));
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_MASK_FIELD, &mfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield);
if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield))) {
GtkWidget *dialog;
dialog = gtk_message_dialog_new
(gwy_app_find_window_for_channel(data, id),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("%s: Lateral dimensions and value must "
"be the same physical quantity."),
_("Curvature"));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return;
}
load_args(gwy_app_settings_get(), &args);
if (run == GWY_RUN_INTERACTIVE) {
ok = curvature_dialog(&args, data, dfield, mfield, id);
save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
curvature_do(data, dfield, mfield, id, &args);
if (args.set_selection)
gwy_app_channel_log_add_proc(data, id, id);
}
static void
gwy_si_unit_clone_real(GObject *source, GObject *copy)
{
GwySIUnit *si_unit, *clone;
g_return_if_fail(GWY_IS_SI_UNIT(source));
g_return_if_fail(GWY_IS_SI_UNIT(copy));
si_unit = GWY_SI_UNIT(source);
clone = GWY_SI_UNIT(copy);
if (gwy_si_unit_equal(si_unit, clone))
return;
g_array_set_size(clone->units, 0);
g_array_append_vals(clone->units,
si_unit->units->data, si_unit->units->len);
clone->power10 = si_unit->power10;
g_signal_emit(copy, si_unit_signals[VALUE_CHANGED], 0);
}
static void
facets_dialog(FacetsArgs *args,
GwyContainer *data,
GwyContainer *fdata,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *hbox, *hbox2, *vbox, *label, *scale, *button;
GtkWidget *spin;
FacetsControls controls;
enum {
RESPONSE_RESET = 1,
RESPONSE_PREVIEW = 2
};
gint response;
GwyPixmapLayer *layer;
GwyVectorLayer *vlayer;
GwySelection *selection;
gint row;
memset(&controls, 0, sizeof(FacetsControls));
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Mark Facets"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Mark"), RESPONSE_PREVIEW,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
controls.dialog = dialog;
/* Shallow-copy stuff to temporary container */
controls.fdata = fdata;
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
0);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.view = gwy_data_view_new(controls.mydata);
layer = gwy_layer_basic_new();
g_object_set(layer,
"data-key", "/0/data",
"gradient-key", "/0/base/palette",
"range-type-key", "/0/base/range-type",
"min-max-key", "/0/base",
NULL);
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer");
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.view), vlayer);
selection = gwy_vector_layer_ensure_selection(vlayer);
g_signal_connect(selection, "changed",
G_CALLBACK(preview_selection_updated), &controls);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
hbox2 = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
/* Slope view */
controls.fview = gwy_data_view_new(controls.fdata);
gtk_box_pack_start(GTK_BOX(hbox2), controls.fview, FALSE, FALSE, 0);
layer = gwy_layer_basic_new();
gwy_pixmap_layer_set_data_key(layer, "/0/data");
gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.fview),
layer);
vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer");
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.fview),
GWY_VECTOR_LAYER(vlayer));
selection = gwy_vector_layer_ensure_selection(vlayer);
g_signal_connect(selection, "changed",
G_CALLBACK(facet_view_selection_updated), &controls);
/* Info table */
table = gtk_table_new(7, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox2), table, TRUE, TRUE, 4);
row = 0;
label = gwy_label_new_header(gwy_sgettext("noun|Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.theta_label = add_angle_label(table, _("θ:"), &row);
controls.phi_label = add_angle_label(table, _("φ:"), &row);
button = gtk_button_new_with_mnemonic(_("_Find Maximum"));
gtk_table_attach(GTK_TABLE(table), button,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(facet_view_reset_maximum), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gwy_label_new_header(_("Mean Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.mtheta_label = add_angle_label(table, _("θ:"), &row);
controls.mphi_label = add_angle_label(table, _("φ:"), &row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new_with_mnemonic(_("Facet plane size:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.kernel_size = gtk_adjustment_new(args->kernel_size,
0.0, MAX_PLANE_SIZE, 1.0, 1.0, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.kernel_size), 0.0, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
gtk_table_attach(GTK_TABLE(table), spin,
0, 1, row, row+1, 0, 0, 0, 0);
g_signal_connect(controls.kernel_size, "value-changed",
G_CALLBACK(facet_view_recompute), &controls);
row++;
table = gtk_table_new(9, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 4);
row = 0;
controls.tolerance = gtk_adjustment_new(args->tolerance*180.0/G_PI,
0.0, 15.0, 0.01, 0.1, 0);
scale = gwy_table_attach_hscale(table, row++, _("_Tolerance:"), _("deg"),
controls.tolerance, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(scale), 3);
g_signal_connect(controls.tolerance, "value-changed",
G_CALLBACK(facets_tolerance_changed), &controls);
controls.color_button = gwy_color_button_new();
gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button),
TRUE);
load_mask_color(controls.color_button,
gwy_data_view_get_data(GWY_DATA_VIEW(controls.view)));
gwy_table_attach_hscale(table, row++, _("_Mask color:"), NULL,
GTK_OBJECT(controls.color_button),
GWY_HSCALE_WIDGET_NO_EXPAND);
g_signal_connect(controls.color_button, "clicked",
G_CALLBACK(mask_color_change_cb), &controls);
if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield))) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new(_("Warning: Lateral and value units differ. "
"Angles are not physically meaningful."));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
}
facets_invalidate(&controls);
gtk_widget_show_all(dialog);
facet_view_select_angle(&controls, args->theta0, args->phi0);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
args->tolerance = facets_defaults.tolerance;
args->kernel_size = facets_defaults.kernel_size;
facets_dialog_update_controls(&controls, args);
break;
case RESPONSE_PREVIEW:
preview(&controls, args);
update_average_angle(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
if (controls.computed) {
mfield = gwy_container_get_object_by_name(controls.mydata, "/0/mask");
gwy_app_undo_qcheckpointv(data, 1, &mquark);
gwy_container_set_object(data, mquark, mfield);
g_object_unref(controls.mydata);
}
else {
g_object_unref(controls.mydata);
run_noninteractive(args, data, fdata, dfield, mfield, mquark);
}
}
static gboolean
get_scales(GHashTable *hash,
gboolean is_text,
gint *xres, gint *yres,
gdouble *xreal, gdouble *yreal,
gdouble *xoff, gdouble *yoff,
GwySIUnit *si_unit_xy,
gdouble *zscale,
gdouble *zoff,
GwySIUnit *si_unit_z,
GError **error)
{
GwySIUnit *unit;
gint power10, zp;
gchar *p;
gboolean has_unit = FALSE;
/* Dimensions are mandatory. */
if (!require_keys(hash, error,
"SCANNING PARAMS::PixelsX",
"SCANNING PARAMS::PixelsY",
"SCANNING PARAMS::PixelsZ",
"SCANNING PARAMS::SizeX",
"SCANNING PARAMS::SizeY",
"SCANNING PARAMS::SizeZ",
NULL))
return FALSE;
*xres = atoi(g_hash_table_lookup(hash, "SCANNING PARAMS::PixelsX"));
if (err_DIMENSION(error, *xres))
return FALSE;
*yres = atoi(g_hash_table_lookup(hash, "SCANNING PARAMS::PixelsY"));
if (err_DIMENSION(error, *yres))
return FALSE;
unit = gwy_si_unit_new(NULL);
p = g_hash_table_lookup(hash, "SCANNING PARAMS::SizeX");
*xreal = fabs(g_ascii_strtod(p, &p));
if (!*xreal) {
g_warning("Real x size is 0.0, fixing to 1.0");
*xreal = 1.0;
}
gwy_si_unit_set_from_string_parse(si_unit_xy, p, &power10);
*xreal *= pow10(power10);
p = g_hash_table_lookup(hash, "SCANNING PARAMS::SizeY");
*yreal = fabs(g_ascii_strtod(p, &p));
if (!*yreal) {
g_warning("Real y size is 0.0, fixing to 1.0");
*yreal = 1.0;
}
gwy_si_unit_set_from_string_parse(unit, p, &power10);
*yreal *= pow10(power10);
if (!gwy_si_unit_equal(unit, si_unit_xy)) {
g_warning("X and Y units differ, using X");
}
zp = atoi(g_hash_table_lookup(hash, "SCANNING PARAMS::PixelsZ"));
if (!zp) {
g_warning("Z pixels is 0, fixing to 1");
zp = 1;
}
p = g_hash_table_lookup(hash, "SCANNING PARAMS::SizeZ");
*zscale = g_ascii_strtod(p, &p);
*zoff = 0.0;
gwy_si_unit_set_from_string_parse(si_unit_z, p, &power10);
*zscale *= pow10(power10)/zp;
/* XXX: Version 4 can have UNIT section that takes precedence. The Conv
* factor may not be enough. Apparently, binary phase data need
* subtracting 180 deg because data are unsinged. Bite me. */
if ((p = g_hash_table_lookup(hash, "UNIT::Unit"))) {
const gchar *s = g_hash_table_lookup(hash, "UNIT::Name");
has_unit = TRUE;
gwy_si_unit_set_from_string_parse(si_unit_z, p, &power10);
*zscale *= pow10(power10);
if ((p = g_hash_table_lookup(hash, "UNIT::Conv")))
*zscale *= g_ascii_strtod(p, NULL);
if (!is_text && gwy_strequal(s, "Phase"))
*zoff = -180.0;
}
/* Offsets are optional. */
*xoff = 0.0;
if ((p = g_hash_table_lookup(hash, "SCANNING PARAMS::OffsetX"))) {
*xoff = g_ascii_strtod(p, &p);
gwy_si_unit_set_from_string_parse(unit, p, &power10);
if (gwy_si_unit_equal(unit, si_unit_xy))
*xoff *= pow10(power10);
else {
g_warning("X offset units differ from X size units, ignoring.");
*xoff = 0.0;
}
}
*yoff = 0.0;
if ((p = g_hash_table_lookup(hash, "SCANNING PARAMS::OffsetY"))) {
*yoff = g_ascii_strtod(p, &p);
gwy_si_unit_set_from_string_parse(unit, p, &power10);
if (gwy_si_unit_equal(unit, si_unit_xy))
*yoff *= pow10(power10);
else {
g_warning("Y offset units differ from Y size units, ignoring.");
*yoff = 0.0;
}
}
// Don't know what to do with the offset when UNIT section is present.
// It seems to be always 0 in wrong units, so skip it.
if (!has_unit) {
if ((p = g_hash_table_lookup(hash, "SCANNING PARAMS::OffsetZ"))) {
*zoff = g_ascii_strtod(p, &p);
gwy_si_unit_set_from_string_parse(unit, p, &power10);
if (gwy_si_unit_equal(unit, si_unit_z))
*zoff *= pow10(power10);
else {
g_warning("Z offset units differ from Z size units, ignoring.");
*zoff = 0.0;
}
}
}
g_object_unref(unit);
return TRUE;
}
static GwyContainer*
plt_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL;
GwyDataField *dfield = NULL;
GwyTextHeaderParser parser;
GwySIUnit *xunit, *yunit, *zunit;
gchar *p, *value, *buffer = NULL;
GHashTable *hash = NULL;
gsize size;
GError *err = NULL;
G_GNUC_UNUSED gdouble xreal, yreal, zreal;
gint i, xres, yres;
gdouble *data;
if (!g_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
goto fail;
}
if (strncmp(buffer, MAGIC1, MIN(size, sizeof(MAGIC1)-1))) {
err_FILE_TYPE(error, "Nanosurf PLT");
goto fail;
}
/* Find the first line not starting with '#' */
for (p = buffer; (p - buffer) + 1 < size; p++) {
if ((p[0] == '\n' || p[0] == '\r')
&& (p[1] != '\n' && p[1] != '#')) {
break;
}
}
*p = '\0';
p++;
gwy_clear(&parser, 1);
parser.line_prefix = "#";
parser.key_value_separator = ":";
hash = gwy_text_header_parse(buffer, &parser, NULL, NULL);
if (!require_keys(hash, error,
"Channel", "Lines", "Points",
"XRange", "YRange", "ZRange",
NULL))
goto fail;
xres = atoi(g_hash_table_lookup(hash, "Points"));
yres = atoi(g_hash_table_lookup(hash, "Lines"));
if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres))
goto fail;
value = g_hash_table_lookup(hash, "XRange");
xreal = g_ascii_strtod(value, &value);
xunit = gwy_si_unit_new(value);
value = g_hash_table_lookup(hash, "YRange");
yreal = g_ascii_strtod(value, &value);
yunit = gwy_si_unit_new(value);
value = g_hash_table_lookup(hash, "ZRange");
zreal = g_ascii_strtod(value, &value);
zunit = gwy_si_unit_new(value);
/* Use negated positive conditions to catch NaNs */
if (!((xreal = fabs(xreal)) > 0)) {
g_warning("Real x size is 0.0, fixing to 1.0");
xreal = 1.0;
}
if (!((yreal = fabs(yreal)) > 0)) {
g_warning("Real y size is 0.0, fixing to 1.0");
yreal = 1.0;
}
if (!gwy_si_unit_equal(xunit, yunit))
g_warning("X and Y units differ, using X");
dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE);
gwy_data_field_set_si_unit_xy(dfield, xunit);
gwy_data_field_set_si_unit_z(dfield, zunit);
g_object_unref(xunit);
g_object_unref(yunit);
g_object_unref(zunit);
data = gwy_data_field_get_data(dfield);
value = p;
for (i = 0; i < xres*yres; i++) {
data[i] = g_ascii_strtod(value, &p);
value = p;
}
container = gwy_container_new();
gwy_container_set_object(container, gwy_app_get_data_key_for_id(0), dfield);
g_object_unref(dfield);
if ((value = g_hash_table_lookup(hash, "Channel")))
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup(value));
else
gwy_app_channel_title_fall_back(container, 0);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
fail:
g_free(buffer);
g_hash_table_destroy(hash);
return container;
}
static void
facets_dialog(FacetsArgs *args,
GwyContainer *data,
GwyContainer *fdata,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *hbox, *hbox2, *vbox, *label, *scale, *button;
GtkWidget *spin;
FacetsControls controls;
gint response;
GwySelection *selection;
gint row;
gwy_clear(&controls, 1);
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Mark Facets"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
gwy_sgettext("verb|_Mark"),
RESPONSE_PREVIEW,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
/* Shallow-copy stuff to temporary container */
controls.fdata = fdata;
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
0);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.view = create_preview(controls.mydata, 0, PREVIEW_SIZE, TRUE);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
selection = create_vector_layer(GWY_DATA_VIEW(controls.view), 0, "Point",
TRUE);
g_signal_connect(selection, "changed",
G_CALLBACK(preview_selection_updated), &controls);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
hbox2 = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
/* Slope view */
controls.fview = create_preview(controls.fdata, 0, FDATA_RES, TRUE);
gtk_box_pack_start(GTK_BOX(hbox2), controls.fview, FALSE, FALSE, 0);
selection = create_vector_layer(GWY_DATA_VIEW(controls.fview), 0, "Point",
TRUE);
g_signal_connect(selection, "changed",
G_CALLBACK(facet_view_selection_updated), &controls);
/* Info table */
table = gtk_table_new(7, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox2), table, TRUE, TRUE, 4);
row = 0;
/* TRANSLATORS: The direction or line orthogonal to something. */
label = gwy_label_new_header(_("Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.theta_label = add_angle_label(table, _("θ:"), &row);
controls.phi_label = add_angle_label(table, _("φ:"), &row);
button = gtk_button_new_with_mnemonic(_("_Find Maximum"));
gtk_table_attach(GTK_TABLE(table), button,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(facet_view_reset_maximum), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gwy_label_new_header(_("Mean Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.mtheta_label = add_angle_label(table, _("θ:"), &row);
controls.mphi_label = add_angle_label(table, _("φ:"), &row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new_with_mnemonic(_("Facet plane size:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.kernel_size = gtk_adjustment_new(args->kernel_size,
0.0, MAX_PLANE_SIZE, 1.0, 1.0, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.kernel_size), 0.0, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
gtk_table_attach(GTK_TABLE(table), spin,
0, 1, row, row+1, 0, 0, 0, 0);
g_signal_connect(controls.kernel_size, "value-changed",
G_CALLBACK(facet_view_recompute), &controls);
row++;
table = gtk_table_new(4 + 2*(!!mfield), 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 4);
row = 0;
controls.tolerance = gtk_adjustment_new(args->tolerance*180.0/G_PI,
0.0, 15.0, 0.01, 0.1, 0);
scale = gwy_table_attach_hscale(table, row++, _("_Tolerance:"), _("deg"),
controls.tolerance, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(scale), 3);
g_signal_connect(controls.tolerance, "value-changed",
G_CALLBACK(facets_tolerance_changed), &controls);
if (mfield) {
gwy_container_set_object_by_name(controls.fdata, "/1/mask", mfield);
controls.combine
= gtk_check_button_new_with_mnemonic(_("Com_bine with "
"existing mask"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.combine),
args->combine);
gtk_table_attach(GTK_TABLE(table), controls.combine,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.combine, "toggled",
G_CALLBACK(combine_changed), &controls);
row++;
controls.combine_type
= gwy_enum_combo_box_new(gwy_merge_type_get_enum(), -1,
G_CALLBACK(combine_type_changed), &controls,
args->combine_type, TRUE);
gwy_table_attach_hscale(table, row, _("Operation:"), NULL,
GTK_OBJECT(controls.combine_type),
GWY_HSCALE_WIDGET);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
}
controls.color_button = create_mask_color_button(controls.mydata, dialog,
0);
gwy_table_attach_hscale(table, row, _("_Mask color:"), NULL,
GTK_OBJECT(controls.color_button),
GWY_HSCALE_WIDGET_NO_EXPAND);
row++;
if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield))) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new(_("Warning: Lateral and value units differ. "
"Angles are not physically meaningful."));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
}
gtk_widget_show_all(dialog);
facet_view_select_angle(&controls, args->theta0, args->phi0);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
facets_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
args->tolerance = facets_defaults.tolerance;
args->kernel_size = facets_defaults.kernel_size;
facets_dialog_update_controls(&controls, args);
break;
case RESPONSE_PREVIEW:
preview(&controls, args);
update_average_angle(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
g_object_unref(controls.mydata);
run_noninteractive(args, data, fdata, dfield, mfield, mquark);
facets_save_args(gwy_app_settings_get(), args);
gwy_app_channel_log_add_proc(data, id, id);
}
static gboolean
gsf_export(GwyContainer *container,
const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
static const gchar zeroes[4] = { 0, 0, 0, 0 };
GString *header = NULL;
gfloat *dfl = NULL;
guint i, xres, yres, padding;
gint id;
GwyDataField *dfield;
const gdouble *d;
gdouble v;
gchar *s;
GwySIUnit *unit, *emptyunit;
FILE *fh;
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
if (!dfield) {
err_NO_CHANNEL_EXPORT(error);
return FALSE;
}
if (!(fh = g_fopen(filename, "wb"))) {
err_OPEN_WRITE(error);
return FALSE;
}
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
header = g_string_new(MAGIC);
g_string_append_printf(header, "XRes = %u\n", xres);
g_string_append_printf(header, "YRes = %u\n", yres);
append_num(header, "XReal", gwy_data_field_get_xreal(dfield));
append_num(header, "YReal", gwy_data_field_get_yreal(dfield));
if ((v = gwy_data_field_get_xoffset(dfield)))
append_num(header, "XOffset", v);
if ((v = gwy_data_field_get_yoffset(dfield)))
append_num(header, "YOffset", v);
emptyunit = gwy_si_unit_new(NULL);
unit = gwy_data_field_get_si_unit_xy(dfield);
if (!gwy_si_unit_equal(unit, emptyunit)) {
s = gwy_si_unit_get_string(unit, GWY_SI_UNIT_FORMAT_PLAIN);
g_string_append_printf(header, "XYUnits = %s\n", s);
g_free(s);
}
unit = gwy_data_field_get_si_unit_z(dfield);
if (!gwy_si_unit_equal(unit, emptyunit)) {
s = gwy_si_unit_get_string(unit, GWY_SI_UNIT_FORMAT_PLAIN);
g_string_append_printf(header, "ZUnits = %s\n", s);
g_free(s);
}
g_object_unref(emptyunit);
s = gwy_app_get_data_field_title(container, id);
g_string_append_printf(header, "Title = %s\n", s);
g_free(s);
if (fwrite(header->str, 1, header->len, fh) != header->len) {
err_WRITE(error);
goto fail;
}
padding = 4 - (header->len % 4);
if (fwrite(zeroes, 1, padding, fh) != padding) {
err_WRITE(error);
goto fail;
}
g_string_free(header, TRUE);
header = NULL;
dfl = g_new(gfloat, xres*yres);
d = gwy_data_field_get_data_const(dfield);
for (i = 0; i < xres*yres; i++) {
union { guchar pp[4]; float f; } z;
z.f = d[i];
#if (G_BYTE_ORDER == G_BIG_ENDIAN)
GWY_SWAP(guchar, z.pp[0], z.pp[3]);
GWY_SWAP(guchar, z.pp[1], z.pp[2]);
#endif
dfl[i] = z.f;
}
if (fwrite(dfl, sizeof(gfloat), xres*yres, fh) != xres*yres) {
err_WRITE(error);
goto fail;
}
g_free(dfl);
fclose(fh);
return TRUE;
fail:
if (fh)
fclose(fh);
g_unlink(filename);
if (header)
g_string_free(header, TRUE);
g_free(dfl);
return FALSE;
}
static gboolean
tilt_dialog(TiltArgs *args,
GwyDataField *dfield)
{
enum { RESPONSE_RESET = 1 };
GtkWidget *dialog, *spin, *table, *label;
GwySIUnit *unit;
gchar *unitstr;
TiltControls controls;
gboolean units_equal;
gint row, response;
unit = gwy_si_unit_new(NULL);
units_equal = gwy_si_unit_equal(gwy_data_field_get_si_unit_z(dfield),
gwy_data_field_get_si_unit_xy(dfield));
gwy_si_unit_divide(gwy_data_field_get_si_unit_z(dfield),
gwy_data_field_get_si_unit_xy(dfield),
unit);
unitstr = gwy_si_unit_get_string(unit, GWY_SI_UNIT_FORMAT_VFMARKUP);
g_object_unref(unit);
dialog = gtk_dialog_new_with_buttons(_("Tilt"), NULL, 0,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
controls.args = args;
controls.in_update = TRUE;
table = gtk_table_new(5 + (units_equal ? 1 : 0), 3, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_container_add(GTK_CONTAINER(GTK_DIALOG(dialog)->vbox), table);
row = 0;
/* Slopes */
label = gwy_label_new_header(_("Slopes"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.dx = gtk_adjustment_new(args->dx, -100, 100, 1e-4, 1e-2, 0);
spin = gwy_table_attach_hscale(table, row, _("_X:"), unitstr,
controls.dx, GWY_HSCALE_NO_SCALE);
gwy_widget_set_activate_on_unfocus(spin, TRUE);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 6);
g_signal_connect(controls.dx, "value-changed",
G_CALLBACK(tilt_dx_changed), &controls);
row++;
controls.dy = gtk_adjustment_new(args->dy, -100, 100, 1e-4, 1e-2, 0);
spin = gwy_table_attach_hscale(table, row, _("_Y:"), unitstr,
controls.dy, GWY_HSCALE_NO_SCALE);
gwy_widget_set_activate_on_unfocus(spin, TRUE);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 6);
g_signal_connect(controls.dy, "value-changed",
G_CALLBACK(tilt_dy_changed), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
/* Angles (adjustment values will be calculated later) */
label = gwy_label_new_header(_("Angles"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
if (units_equal) {
controls.theta = gtk_adjustment_new(0, 0, 89.6, 1e-2, 1.0, 0);
spin = gwy_table_attach_hscale(table, row, _("θ:"), _("deg"),
controls.theta, GWY_HSCALE_NO_SCALE);
gwy_widget_set_activate_on_unfocus(spin, TRUE);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 4);
g_signal_connect_swapped(controls.theta, "value-changed",
G_CALLBACK(tilt_angle_changed), &controls);
row++;
}
else
controls.theta = gtk_adjustment_new(0, 0, 90.0, 1e-2, 1.0, 0);
controls.phi = gtk_adjustment_new(0, -180, 180, 1e-2, 1.0, 0);
spin = gwy_table_attach_hscale(table, row, _("φ:"), _("deg"),
controls.phi, GWY_HSCALE_NO_SCALE);
gwy_widget_set_activate_on_unfocus(spin, TRUE);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), 4);
g_signal_connect_swapped(controls.phi, "value-changed",
G_CALLBACK(tilt_angle_changed), &controls);
row++;
controls.in_update = FALSE;
tilt_deriv_to_angles(&controls);
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
return FALSE;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
dialog_reset(&controls);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
