static void
curvature_do(GwyContainer *data,
GwyDataField *dfield,
GwyDataField *mfield,
gint oldid,
const CurvatureArgs *args)
{
gdouble params[PARAM_NPARAMS];
Intersection i1[2], i2[2];
gchar *key;
if (!curvature_calculate(dfield, mfield, args, params, i1, i2))
return;
if (args->set_selection) {
GwySelection *selection;
selection = g_object_new(g_type_from_name("GwySelectionLine"),
"max-objects", 1024,
NULL);
curvature_set_selection(dfield, i1, i2, selection);
key = g_strdup_printf("/%d/select/line", oldid);
gwy_container_set_object_by_name(data, key, selection);
g_object_unref(selection);
}
if (args->plot_graph) {
GwyGraphModel *gmodel;
gmodel = gwy_graph_model_new();
curvature_plot_graph(dfield, i1, i2, gmodel);
gwy_app_add_graph_or_curves(gmodel, data, &args->target_graph, 1);
g_object_unref(gmodel);
}
}
static GwyGraphModel*
rhk_sm4_page_to_graph_model(const RHKPage *page)
{
GwyGraphModel *gmodel;
GwyGraphCurveModel *gcmodel;
GwySIUnit *siunit;
const gint32 *pdata;
const gchar *name;
gint res, ncurves, i, j;
gdouble *xdata, *ydata;
res = page->x_size;
ncurves = page->y_size;
gmodel = gwy_graph_model_new();
pdata = (const gint32*)page->data;
xdata = g_new(gdouble, res);
ydata = g_new(gdouble, res);
name = page->strings[RHK_STRING_LABEL];
for (i = 0; i < ncurves; i++) {
gcmodel = gwy_graph_curve_model_new();
for (j = 0; j < res; j++) {
xdata[j] = j*page->x_scale + page->x_offset;
ydata[j] = (GINT32_FROM_LE(pdata[i*res + j])*page->z_scale
+ page->z_offset);
}
gwy_graph_curve_model_set_data(gcmodel, xdata, ydata, res);
g_object_set(gcmodel,
"mode", GWY_GRAPH_CURVE_LINE,
"color", gwy_graph_get_preset_color(i),
NULL);
if (name)
g_object_set(gcmodel, "description", name, NULL);
gwy_graph_model_add_curve(gmodel, gcmodel);
g_object_unref(gcmodel);
}
g_free(ydata);
g_free(xdata);
/* Units */
siunit = gwy_si_unit_new(page->strings[RHK_STRING_X_UNITS]);
g_object_set(gmodel, "si-unit-x", siunit, NULL);
g_object_unref(siunit);
siunit = gwy_si_unit_new(page->strings[RHK_STRING_Z_UNITS]);
g_object_set(gmodel, "si-unit-y", siunit, NULL);
g_object_unref(siunit);
if (name)
g_object_set(gmodel, "title", name, NULL);
return gmodel;
}
static GwyGraphModel*
spectra_to_graph(GwySpectra *spectra)
{
GwyGraphModel *gmodel;
const gchar* graph_title;
GwyGraphCurveModel *cmodel;
gchar *curve_title = NULL;
guint j, k, n_spectra, n_points;
GwyDataLine *dline;
gdouble *data, *xdata, *ydata, x_offset, x_realsize;
GwySIUnit *x_si_unit, *y_si_unit;
if (!(n_spectra = gwy_spectra_get_n_spectra(spectra))) {
gwy_debug("rhk-spm32: no spectra in rhkpage - something is odd\n");
return NULL;
}
dline = gwy_spectra_get_spectrum(spectra, 0);
n_points = gwy_data_line_get_res(dline);
x_si_unit = gwy_data_line_get_si_unit_x(dline);
y_si_unit = gwy_data_line_get_si_unit_y(dline);
xdata = g_new0(gdouble, n_points);
ydata = g_new0(gdouble, n_points);
x_offset = gwy_data_line_get_offset(dline);
x_realsize = gwy_data_line_get_real(dline);
for (j = 0; j < n_points; j++)
xdata[j] = x_offset+j*x_realsize;
gmodel = gwy_graph_model_new();
g_object_set(gmodel, "si-unit-x", x_si_unit, "si-unit-y", y_si_unit, NULL);
graph_title = gwy_spectra_get_title(spectra);
g_object_set(gmodel, "title", graph_title, NULL);
// tends to obstruct the curves - if there are more than a few - not
// good - makes it hard to grab curves?
//g_object_set(gmodel, "label-visible", FALSE, NULL);
for (k = 1; k <= n_spectra; k++) {
dline = gwy_spectra_get_spectrum(spectra, k-1);
data = gwy_data_line_get_data(dline);
for (j = 0; j < n_points; j++)
ydata[j] = data[j];
cmodel = gwy_graph_curve_model_new();
gwy_graph_model_add_curve(gmodel, cmodel);
g_object_unref(cmodel);
curve_title = g_strdup_printf("%s %d", graph_title, k);
g_object_set(cmodel, "description", curve_title,
"mode", GWY_GRAPH_CURVE_LINE,
"color", gwy_graph_get_preset_color(k),
NULL);
gwy_graph_curve_model_set_data(cmodel, xdata, ydata, n_points);
}
g_free(ydata);
g_free(xdata);
return gmodel;
}
static void
reset(TipBlindControls *controls, TipBlindArgs *args)
{
GwyGraphModel *gmodel;
gwy_data_field_clear(controls->tip);
if (args->stripetips) {
guint i;
for (i = 0; i < controls->oldnstripes; i++)
gwy_data_field_clear(args->stripetips[i]);
}
controls->good_tip = FALSE;
gmodel = gwy_graph_model_new();
gwy_graph_set_model(GWY_GRAPH(controls->graph), gmodel);
g_object_unref(gmodel);
gtk_dialog_set_response_sensitive(GTK_DIALOG(controls->dialog),
GTK_RESPONSE_OK, controls->good_tip);
tip_update(controls);
}
static GwyGraphModel*
create_graph_model(const GwyXY *points,
const gdouble *xdata, gdouble *ydata, guint n,
gboolean x, gboolean y)
{
GwyGraphModel *gmodel = gwy_graph_model_new();
GwyGraphCurveModel *gcmodel;
guint i;
if (!x && !y)
return NULL;
if (x) {
gcmodel = gwy_graph_curve_model_new();
for (i = 0; i < n; i++)
ydata[i] = points[i].x;
gwy_graph_curve_model_set_data(gcmodel, xdata, ydata, n);
g_object_set(gcmodel,
"description", "X",
"mode", GWY_GRAPH_CURVE_LINE,
"color", gwy_graph_get_preset_color(0),
NULL);
gwy_graph_model_add_curve(gmodel, gcmodel);
g_object_unref(gcmodel);
}
if (y) {
gcmodel = gwy_graph_curve_model_new();
for (i = 0; i < n; i++)
ydata[i] = points[i].y;
gwy_graph_curve_model_set_data(gcmodel, xdata, ydata, n);
g_object_set(gcmodel,
"description", "Y",
"mode", GWY_GRAPH_CURVE_LINE,
"color", gwy_graph_get_preset_color(1),
NULL);
gwy_graph_model_add_curve(gmodel, gcmodel);
g_object_unref(gcmodel);
}
return gmodel;
}
static void
tip_blind_dialog(TipBlindArgs *args)
{
GtkWidget *dialog, *table, *hbox, *vbox, *label;
GwyContainer *data;
GwyGraphModel *gmodel;
GwyGraphArea *area;
TipBlindControls controls;
GwyPixmapLayer *layer;
GwyDataField *dfield;
GQuark quark;
GwySIUnit *unit;
gint response, row;
dialog = gtk_dialog_new_with_buttons(_("Blind Tip Estimation"), NULL, 0,
_("Run _Partial"), RESPONSE_ESTIMATE,
_("Run _Full"), RESPONSE_REFINE,
_("_Reset Tip"), 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.args = args;
controls.in_update = TRUE;
controls.good_tip = FALSE;
controls.dialog = dialog;
gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), GTK_RESPONSE_OK,
controls.good_tip);
hbox = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.vxres = 240;
controls.vyres = 240;
controls.oldnstripes = args->nstripes;
/* set initial tip properties */
data = gwy_app_data_browser_get(args->source.datano);
quark = gwy_app_get_data_key_for_id(args->source.id);
dfield = GWY_DATA_FIELD(gwy_container_get_object(data, quark));
controls.tip = gwy_data_field_new_alike(dfield, TRUE);
gwy_data_field_resample(controls.tip, args->xres, args->yres,
GWY_INTERPOLATION_NONE);
gwy_data_field_clear(controls.tip);
/* set up data of rescaled image of the tip */
controls.vtip = gwy_container_new();
gwy_app_sync_data_items(data, controls.vtip,
args->source.id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
0);
dfield = gwy_data_field_new_alike(controls.tip, TRUE);
gwy_data_field_resample(dfield, controls.vxres, controls.vyres,
GWY_INTERPOLATION_ROUND);
gwy_container_set_object_by_name(controls.vtip, "/0/data", dfield);
g_object_unref(dfield);
/* set up rescaled image of the tip */
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4);
controls.view = gwy_data_view_new(controls.vtip);
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.view), layer);
/* set up tip estimation controls */
gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 0);
gmodel = gwy_graph_model_new();
controls.graph = gwy_graph_new(gmodel);
g_object_unref(gmodel);
gwy_axis_set_visible(gwy_graph_get_axis(GWY_GRAPH(controls.graph),
GTK_POS_LEFT),
FALSE);
gwy_axis_set_visible(gwy_graph_get_axis(GWY_GRAPH(controls.graph),
GTK_POS_BOTTOM),
FALSE);
area = GWY_GRAPH_AREA(gwy_graph_get_area(GWY_GRAPH(controls.graph)));
gtk_widget_set_no_show_all(gwy_graph_area_get_label(area), TRUE);
g_signal_connect_after(gwy_graph_area_get_label(area), "map",
G_CALLBACK(gtk_widget_hide), NULL);
gtk_box_pack_start(GTK_BOX(vbox), controls.graph, TRUE, TRUE, 0);
table = gtk_table_new(13, 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(hbox), table, FALSE, FALSE, 4);
row = 0;
controls.data = gwy_data_chooser_new_channels();
gwy_data_chooser_set_filter(GWY_DATA_CHOOSER(controls.data),
tip_blind_source_filter, &args->orig, NULL);
gwy_data_chooser_set_active_id(GWY_DATA_CHOOSER(controls.data),
&args->source);
g_signal_connect(controls.data, "changed",
G_CALLBACK(data_changed), &args->source);
gwy_table_attach_hscale(table, row, _("Related _data:"), NULL,
GTK_OBJECT(controls.data), GWY_HSCALE_WIDGET);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gtk_label_new(_("Estimated Tip Size"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.xres = gtk_adjustment_new(args->xres, MIN_RES, MAX_RES, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Width:"), "px", controls.xres, 0);
g_object_set_data(G_OBJECT(controls.xres), "controls", &controls);
g_signal_connect(controls.xres, "value-changed",
G_CALLBACK(width_changed), &controls);
row++;
controls.yres = gtk_adjustment_new(args->yres, MIN_RES, MAX_RES, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Height:"), "px", controls.yres, 0);
g_object_set_data(G_OBJECT(controls.yres), "controls", &controls);
g_signal_connect(controls.yres, "value-changed",
G_CALLBACK(height_changed), &controls);
row++;
controls.same_resolution
= gtk_check_button_new_with_mnemonic(_("_Same resolution"));
gtk_table_attach(GTK_TABLE(table), controls.same_resolution,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.same_resolution),
args->same_resolution);
g_signal_connect(controls.same_resolution, "toggled",
G_CALLBACK(same_resolution_changed), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Options")),
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.threshold = gtk_adjustment_new(1.0, 0.01, 1000.0, 0.01, 1.0, 0.0);
controls.threshold_spin
= gtk_spin_button_new(GTK_ADJUSTMENT(controls.threshold), 0.1, 2);
gtk_table_attach(GTK_TABLE(table), controls.threshold_spin,
2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new_with_mnemonic(_("Noise suppression t_hreshold:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.threshold_spin);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
unit = gwy_data_field_get_si_unit_z(dfield);
controls.threshold_unit
= gwy_combo_box_metric_unit_new(G_CALLBACK(thresh_changed),
&controls,
-12, -3, unit, -9);
gtk_table_attach(GTK_TABLE(table), controls.threshold_unit,
3, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.threshold, "value-changed",
G_CALLBACK(thresh_changed), &controls);
sci_entry_set_value(GTK_ADJUSTMENT(controls.threshold),
GTK_COMBO_BOX(controls.threshold_unit),
args->thresh);
row++;
controls.boundaries
= gtk_check_button_new_with_mnemonic(_("Use _boundaries"));
gtk_table_attach(GTK_TABLE(table), controls.boundaries,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.boundaries),
args->use_boundaries);
g_signal_connect(controls.boundaries, "toggled",
G_CALLBACK(bound_changed), args);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Stripes")),
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.nstripes = gtk_adjustment_new(args->nstripes,
MIN_STRIPES, MAX_STRIPES, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Split to stripes:"), NULL,
controls.nstripes, GWY_HSCALE_CHECK);
controls.split_to_stripes = gwy_table_hscale_get_check(controls.nstripes);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.split_to_stripes),
!args->split_to_stripes);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.split_to_stripes),
args->split_to_stripes);
g_signal_connect(controls.split_to_stripes, "toggled",
G_CALLBACK(split_to_stripes_changed), &controls);
g_signal_connect(controls.nstripes, "value-changed",
G_CALLBACK(nstripes_changed), &controls);
row++;
controls.stripeno = gtk_adjustment_new(1, 1, args->nstripes, 1, 10, 0);
gwy_table_attach_hscale(table, row, _("_Preview stripe:"), NULL,
controls.stripeno, GWY_HSCALE_DEFAULT);
g_signal_connect(controls.stripeno, "value-changed",
G_CALLBACK(stripeno_changed), &controls);
row++;
controls.plot_size_graph
= gtk_check_button_new_with_mnemonic(_("Plot size _graph"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.plot_size_graph),
args->plot_size_graph);
gtk_table_attach(GTK_TABLE(table), controls.plot_size_graph,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.plot_size_graph, "toggled",
G_CALLBACK(plot_size_graph_changed), &controls);
row++;
controls.create_images
= gtk_check_button_new_with_mnemonic(_("Create tip i_mages"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.create_images),
args->create_images);
gtk_table_attach(GTK_TABLE(table), controls.create_images,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.create_images, "toggled",
G_CALLBACK(create_images_changed), &controls);
row++;
controls.tipdone = FALSE;
controls.in_update = FALSE;
split_to_stripes_changed(GTK_TOGGLE_BUTTON(controls.split_to_stripes),
&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:
tip_blind_dialog_abandon(&controls);
tip_blind_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
tip_blind_save_args(gwy_app_settings_get(), args);
tip_blind_do(&controls, args);
break;
case RESPONSE_RESET:
reset(&controls, args);
break;
case RESPONSE_ESTIMATE:
tip_blind_run(&controls, args, FALSE);
break;
case RESPONSE_REFINE:
tip_blind_run(&controls, args, TRUE);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
tip_blind_dialog_abandon(&controls);
return;
}
static GwyGraphModel*
pt3file_extract_decay(const PicoHarpFile *pt3file,
const guchar *buf)
{
GwyGraphModel *gmodel;
GwyGraphCurveModel *gcmodel;
GwySIUnit *siunit;
gdouble *xdata, *ydata;
guint maxtime, n, i;
const guchar *p;
n = pt3file->number_of_records;
maxtime = 0;
p = buf;
for (i = 0; i < n; i++) {
PicoHarpT3Record rec;
p = read_t3_record(&rec, p);
if (rec.channel != 15 && rec.time > maxtime)
maxtime = rec.time;
}
xdata = g_new(gdouble, maxtime+1);
for (i = 0; i <= maxtime; i++)
xdata[i] = 1e-9*i*pt3file->board.resolution;
ydata = g_new0(gdouble, maxtime+1);
p = buf;
for (i = 0; i < n; i++) {
PicoHarpT3Record rec;
p = read_t3_record(&rec, p);
if (rec.channel != 15)
ydata[rec.time] += 1.0;
}
gcmodel = gwy_graph_curve_model_new();
g_object_set(gcmodel,
"mode", GWY_GRAPH_CURVE_LINE,
"description", "Fluorescence decay",
NULL);
gwy_graph_curve_model_set_data(gcmodel, xdata, ydata, maxtime+1);
g_free(ydata);
g_free(xdata);
siunit = gwy_si_unit_new("s");
gmodel = gwy_graph_model_new();
g_object_set(gmodel,
"title", "Fluorescence decay",
"si-unit-x", siunit,
"axis-label-bottom", "time",
"axis-label-left", "count",
NULL);
gwy_graph_model_add_curve(gmodel, gcmodel);
g_object_unref(gcmodel);
g_object_unref(siunit);
return gmodel;
}
static void
prof_dialog(ProfArgs *args,
GwyContainer *data,
GwyDataField *dfield,
gint id)
{
GtkWidget *hbox, *hbox2, *vbox, *label;
GwyDataChooser *chooser;
GtkTable *table;
GtkDialog *dialog;
GwyGraph *graph;
GwyGraphArea *area;
ProfControls controls;
gint response;
gint row;
controls.args = args;
controls.psdffield = prof_psdf(dfield, args);
controls.modfield = prof_sqrt(controls.psdffield);
controls.hx = gwy_data_field_get_xmeasure(dfield)/(2*G_PI);
controls.hy = gwy_data_field_get_xmeasure(dfield)/(2*G_PI);
controls.dialog = gtk_dialog_new_with_buttons(_("Radial PSDF Section"),
NULL, 0,
GTK_STOCK_CLEAR,
RESPONSE_CLEAR,
GTK_STOCK_CANCEL,
GTK_RESPONSE_CANCEL,
GTK_STOCK_OK,
GTK_RESPONSE_OK,
NULL);
dialog = GTK_DIALOG(controls.dialog);
gtk_dialog_set_default_response(dialog, GTK_RESPONSE_OK);
gtk_dialog_set_response_sensitive(dialog, GTK_RESPONSE_OK, FALSE);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data",
controls.modfield);
g_object_unref(controls.modfield);
gwy_container_set_string_by_name(controls.mydata, "/0/base/palette",
g_strdup("DFit"));
gwy_container_set_enum_by_name(controls.mydata, "/0/base/range-type",
GWY_LAYER_BASIC_RANGE_AUTO);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_REAL_SQUARE,
0);
controls.view = create_preview(controls.mydata, 0, PREVIEW_SIZE, FALSE);
controls.selection = create_vector_layer(GWY_DATA_VIEW(controls.view), 0,
"Point", TRUE);
gwy_selection_set_max_objects(controls.selection, NLINES);
g_object_set(gwy_data_view_get_top_layer(GWY_DATA_VIEW(controls.view)),
"draw-as-vector", TRUE,
NULL);
g_signal_connect_swapped(controls.selection, "changed",
G_CALLBACK(prof_selection_changed), &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, 4);
controls.gmodel = gwy_graph_model_new();
g_object_set(controls.gmodel,
"title", _("PSDF Section"),
"axis-label-bottom", "k",
"axis-label-left", "W",
NULL);
init_graph_model_units(controls.gmodel, controls.psdffield);
controls.line = gwy_data_line_new(1, 1.0, FALSE);
controls.graph = gwy_graph_new(controls.gmodel);
graph = GWY_GRAPH(controls.graph);
gtk_widget_set_size_request(controls.graph, GRAPH_WIDTH, -1);
gwy_graph_set_axis_visible(graph, GTK_POS_LEFT, FALSE);
gwy_graph_set_axis_visible(graph, GTK_POS_RIGHT, FALSE);
gwy_graph_set_axis_visible(graph, GTK_POS_TOP, FALSE);
gwy_graph_set_axis_visible(graph, GTK_POS_BOTTOM, FALSE);
gwy_graph_enable_user_input(graph, FALSE);
area = GWY_GRAPH_AREA(gwy_graph_get_area(graph));
gwy_graph_area_enable_user_input(area, FALSE);
gtk_box_pack_start(GTK_BOX(vbox), controls.graph, TRUE, TRUE, 0);
table = GTK_TABLE(gtk_table_new(4, 4, FALSE));
gtk_table_set_row_spacings(table, 2);
gtk_table_set_col_spacings(table, 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(vbox), GTK_WIDGET(table), FALSE, FALSE, 0);
row = 0;
controls.resolution = gtk_adjustment_new(controls.args->resolution,
MIN_RESOLUTION, MAX_RESOLUTION,
1, 10, 0);
gwy_table_attach_hscale(GTK_WIDGET(table), row, _("_Fix res.:"), NULL,
controls.resolution,
GWY_HSCALE_CHECK | GWY_HSCALE_SQRT);
g_signal_connect_swapped(controls.resolution, "value-changed",
G_CALLBACK(prof_resolution_changed), &controls);
controls.fixres = gwy_table_hscale_get_check(controls.resolution);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.fixres),
controls.args->fixres);
g_signal_connect_swapped(controls.fixres, "toggled",
G_CALLBACK(prof_fixres_changed), &controls);
gwy_table_hscale_set_sensitive(controls.resolution, controls.args->fixres);
row++;
controls.separate = gtk_check_button_new_with_mnemonic(_("_Separate curves"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.separate),
args->separate);
gtk_table_attach(table, controls.separate,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.separate, "toggled",
G_CALLBACK(prof_separate_changed), &controls);
row++;
hbox2 = gtk_hbox_new(FALSE, 6);
gtk_table_attach(table, hbox2,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new_with_mnemonic(_("_Interpolation type:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.interpolation
= gwy_enum_combo_box_new(gwy_interpolation_type_get_enum(), -1,
G_CALLBACK(prof_interpolation_changed),
&controls,
controls.args->interpolation, TRUE);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.interpolation);
gtk_box_pack_end(GTK_BOX(hbox2), controls.interpolation, FALSE, FALSE, 0);
row++;
controls.target_hbox = hbox2 = gtk_hbox_new(FALSE, 6);
gtk_widget_set_sensitive(hbox2, !args->separate);
gtk_table_attach(GTK_TABLE(table), hbox2,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new_with_mnemonic(_("Target _graph:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.target_graph = gwy_data_chooser_new_graphs();
chooser = GWY_DATA_CHOOSER(controls.target_graph);
gwy_data_chooser_set_none(chooser, _("New graph"));
gwy_data_chooser_set_active(chooser, NULL, -1);
gwy_data_chooser_set_filter(chooser, filter_target_graphs, &controls, NULL);
gwy_data_chooser_set_active_id(chooser, &args->target_graph);
gwy_data_chooser_get_active_id(chooser, &args->target_graph);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.target_graph);
gtk_box_pack_end(GTK_BOX(hbox2), controls.target_graph, FALSE, FALSE, 0);
g_signal_connect_swapped(controls.target_graph, "changed",
G_CALLBACK(target_graph_changed), &controls);
row++;
gtk_widget_show_all(controls.dialog);
do {
response = gtk_dialog_run(dialog);
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(controls.dialog);
case GTK_RESPONSE_NONE:
goto finalize;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_CLEAR:
gwy_selection_clear(controls.selection);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(controls.dialog);
prof_execute(&controls, data);
finalize:
g_object_unref(controls.psdffield);
g_object_unref(controls.mydata);
g_object_unref(controls.gmodel);
g_object_unref(controls.line);
}
static gboolean
entropy_dialog(EntropyArgs *args, GwyDataField *dfield, GwyDataField *mfield)
{
GtkWidget *dialog, *table, *label, *hbox;
GwyGraphModel *gmodel;
EntropyControls controls;
gint response;
gint row;
controls.args = args;
controls.dfield = dfield;
controls.mfield = mfield;
dialog = gtk_dialog_new_with_buttons(_("Entropy"), NULL, 0,
NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog),
gwy_stock_like_button_new(_("_Update"),
GTK_STOCK_EXECUTE),
RESPONSE_PREVIEW);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_OK, GTK_RESPONSE_OK);
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;
hbox = gtk_hbox_new(FALSE, 12);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
TRUE, TRUE, 0);
table = gtk_table_new(8 + 4*(!!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(hbox), table, FALSE, FALSE, 0);
row = 0;
controls.mode
= gwy_radio_buttons_createl(G_CALLBACK(mode_changed), &controls,
args->mode,
_("Value distribution"),
ENTROPY_VALUES,
_("Slope derivative distribution"),
ENTROPY_SLOPES,
_("Slope angle distribution"),
ENTROPY_ANGLES,
NULL);
row = gwy_radio_buttons_attach_to_table(controls.mode,
GTK_TABLE(table), 3, row);
if (mfield) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gwy_label_new_header(_("Masking Mode"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.masking
= gwy_radio_buttons_create(gwy_masking_type_get_enum(), -1,
G_CALLBACK(masking_changed), &controls,
args->masking);
row = gwy_radio_buttons_attach_to_table(controls.masking,
GTK_TABLE(table), 3, row);
}
else
controls.masking = NULL;
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
controls.fit_plane
= gtk_check_button_new_with_mnemonic(_("Use local plane _fitting"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.fit_plane),
args->fit_plane);
gtk_table_attach(GTK_TABLE(table), controls.fit_plane,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.fit_plane, "toggled",
G_CALLBACK(fit_plane_changed), &controls);
row++;
controls.kernel_size = gtk_adjustment_new(args->kernel_size,
2, 16, 1, 4, 0);
gwy_table_attach_hscale(table, row, _("_Plane size:"), "px",
controls.kernel_size, 0);
g_signal_connect_swapped(controls.kernel_size, "value-changed",
G_CALLBACK(kernel_size_changed), &controls);
row++;
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
controls.zoom_in
= gtk_check_button_new_with_mnemonic(_("_Zoom graph around estimate"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.zoom_in),
args->zoom_in);
gtk_table_attach(GTK_TABLE(table), controls.zoom_in,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.zoom_in, "toggled",
G_CALLBACK(zoom_in_changed), &controls);
row++;
label = gtk_label_new(_("Entropy:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.entropy = label;
row++;
label = gtk_label_new(_("Entropy deficit:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new("");
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
2, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.entropydef = label;
row++;
update_sensitivity(&controls);
gmodel = gwy_graph_model_new();
controls.graph = gwy_graph_new(gmodel);
g_object_unref(gmodel);
gtk_widget_set_size_request(controls.graph, 400, 320);
gtk_box_pack_start(GTK_BOX(hbox), controls.graph, TRUE, TRUE, 0);
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_PREVIEW:
preview(&controls);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
static gboolean
read_aist_curve(const guchar **p, gsize *size, AistContext *context)
{
AistCurve curve;
GwyGraphModel *gmodel;
GwyGraphCurveModel *gcmodel;
GwySIUnit *xunit, *yunit;
gboolean ok = FALSE;
guint len, viewlen, i;
const guchar *data, *viewdata;
const gdouble *xdata, *ydata;
gdouble *xdatacal, *ydatacal;
gdouble *must_free = NULL;
gdouble qx, qy;
GQuark quark;
gwy_clear(&curve, 1);
gwy_debug("reading common");
if (!read_aist_common(p, size, &curve.common))
goto fail;
gwy_debug("reading curve");
if (!read_qt_int(p, size, &curve.res))
goto fail;
if (!read_qt_byte_array(p, size, &len, &data))
goto fail;
if (len != 2*curve.res*sizeof(gdouble))
goto fail;
/* Again something called view data. Skip it. The units follow. */
if (!read_qt_byte_array(p, size, &viewlen, &viewdata))
goto fail;
if (!read_qt_string(p, size, &curve.xunits)
|| !read_qt_string(p, size, &curve.yunits))
goto fail;
xunit = extract_units(curve.xunits, &qx);
yunit = extract_units(curve.yunits, &qy);
/* The data are already stored as doubles in the correct order, so save
* work if also the endianess matches. */
if (G_BYTE_ORDER == G_BIG_ENDIAN) {
must_free = g_new(gdouble, 2*curve.res);
xdata = must_free;
ydata = xdata + curve.res;
gwy_memcpy_byte_swap(data, (guchar*)must_free, 8, 2*curve.res, 7);
}
else if (G_BYTE_ORDER == G_LITTLE_ENDIAN) {
xdata = (const gdouble *)data;
ydata = xdata + curve.res;
}
xdatacal = g_new(gdouble, curve.res);
ydatacal = g_new(gdouble, curve.res);
for (i = 0; i < curve.res; i++) {
xdatacal[i] = xdata[i]*qx;
ydatacal[i] = ydata[i]*qy;
}
gcmodel = gwy_graph_curve_model_new();
gwy_graph_curve_model_set_data(gcmodel, xdatacal, ydatacal, curve.res);
g_object_set(gcmodel,
"mode", GWY_GRAPH_CURVE_LINE,
"description", curve.common.description,
NULL);
g_free(must_free);
g_free(xdatacal);
g_free(ydatacal);
gmodel = gwy_graph_model_new();
gwy_graph_model_add_curve(gmodel, gcmodel);
g_object_unref(gcmodel);
g_object_set(gmodel,
"title", curve.common.name,
"si-unit-x", xunit,
"si-unit-y", yunit,
NULL);
g_object_unref(xunit);
g_object_unref(yunit);
quark = gwy_app_get_graph_key_for_id(context->graph_id+1);
gwy_container_set_object(context->container, quark, gmodel);
g_object_unref(gmodel);
context->graph_id++;
ok = TRUE;
fail:
free_aist_common(&curve.common);
g_free(curve.xunits);
g_free(curve.yunits);
return ok;
}
static void
create_profiles(const X3PFile *x3pfile,
GwyContainer *container)
{
GwyGraphModel *gmodel;
GwySIUnit *siunitx, *siunity;
GArray *validx, *validy;
GQuark quark;
gint id;
gmodel = gwy_graph_model_new();
siunitx = gwy_si_unit_new("m");
siunity = gwy_si_unit_new("m");
g_object_set(gmodel,
"title", "Profiles",
"si-unit-x", siunitx,
"si-unit-y", siunity,
NULL);
g_object_unref(siunity);
g_object_unref(siunitx);
validx = g_array_new(FALSE, FALSE, sizeof(gdouble));
validy = g_array_new(FALSE, FALSE, sizeof(gdouble));
for (id = 0; id < x3pfile->zres; id++) {
guint n = x3pfile->xres;
GwyGraphCurveModel *gcmodel;
gchar *title;
guint j;
g_array_set_size(validx, 0);
g_array_set_size(validy, 0);
for (j = 0; j < x3pfile->xres; j++) {
gdouble v = x3pfile->values[id*n + j];
if (gwy_isnan(v) || gwy_isinf(v) || !x3pfile->valid[id*n + j])
continue;
g_array_append_val(validy, v);
v = j*x3pfile->dx;
g_array_append_val(validx, v);
}
if (!validx->len)
continue;
gcmodel = gwy_graph_curve_model_new();
title = g_strdup_printf("Profile %u", id+1);
g_object_set(gcmodel,
"mode", GWY_GRAPH_CURVE_LINE,
"description", title,
"color", gwy_graph_get_preset_color(id),
NULL);
g_free(title);
gwy_graph_curve_model_set_data(gcmodel,
(gdouble*)validx->data,
(gdouble*)validy->data,
validx->len);
gwy_graph_model_add_curve(gmodel, gcmodel);
g_object_unref(gcmodel);
}
g_array_free(validy, TRUE);
g_array_free(validx, TRUE);
quark = gwy_app_get_graph_key_for_id(0);
gwy_container_set_object(container, quark, gmodel);
g_object_unref(gmodel);
}
static GwyGraphModel*
create_corr_graph(GrainCrossArgs *args,
GwyDataField *dfield)
{
GwyGraphCurveModel *cmodel;
GwyGraphModel *gmodel;
GwyGrainValue *gvalues[2];
gdouble *xdata, *ydata, *bothdata, *rdata[2];
GwySIUnit *siunitxy, *siunitz, *siunitx, *siunity;
const gchar *title;
gint i;
gvalues[0] = gwy_grain_values_get_grain_value(args->abscissa);
gvalues[1] = gwy_grain_values_get_grain_value(args->ordinate);
bothdata = g_new(gdouble, 4*args->ngrains + 2);
rdata[0] = xdata = bothdata + 2*args->ngrains;
rdata[1] = ydata = bothdata + 3*args->ngrains + 1;
gwy_grain_values_calculate(2, gvalues, rdata, dfield,
args->ngrains, args->grains);
for (i = 0; i < args->ngrains; i++) {
bothdata[2*i + 0] = xdata[i+1];
bothdata[2*i + 1] = ydata[i+1];
}
qsort(bothdata, args->ngrains, 2*sizeof(gdouble), compare_doubles);
for (i = 0; i < args->ngrains; i++) {
xdata[i] = bothdata[2*i + 0];
ydata[i] = bothdata[2*i + 1];
}
gmodel = gwy_graph_model_new();
cmodel = gwy_graph_curve_model_new();
gwy_graph_model_add_curve(gmodel, cmodel);
g_object_unref(cmodel);
siunitxy = gwy_data_field_get_si_unit_xy(dfield);
siunitz = gwy_data_field_get_si_unit_z(dfield);
siunitx = gwy_si_unit_power_multiply
(siunitxy, gwy_grain_value_get_power_xy(gvalues[0]),
siunitz, gwy_grain_value_get_power_z(gvalues[0]),
NULL);
siunity = gwy_si_unit_power_multiply
(siunitxy, gwy_grain_value_get_power_xy(gvalues[1]),
siunitz, gwy_grain_value_get_power_z(gvalues[1]),
NULL);
/* FIXME */
title = gettext(gwy_resource_get_name(GWY_RESOURCE(gvalues[1])));
g_object_set
(gmodel,
"title", title,
"axis-label-left", gwy_grain_value_get_symbol_markup(gvalues[1]),
"axis-label-bottom", gwy_grain_value_get_symbol_markup(gvalues[0]),
"si-unit-x", siunitx,
"si-unit-y", siunity,
NULL);
g_object_unref(siunitx);
g_object_unref(siunity);
g_object_set(cmodel,
"description", title,
"mode", GWY_GRAPH_CURVE_POINTS,
NULL);
gwy_graph_curve_model_set_data(cmodel, xdata, ydata, args->ngrains);
g_free(bothdata);
return gmodel;
}
static GwyGraphModel*
sensofar_read_profile(SensofarDataDesc *data_desc,
const guchar **p,
gsize size,
GError **error)
{
GwyGraphModel *gmodel;
GwyGraphCurveModel *gcmodel;
guint xres, yres, j, n;
GwySIUnit *units = NULL;
gdouble *xdata, *ydata;
gdouble dx;
yres = gwy_get_guint32_le(p);
if (yres != 1)
g_warning("ysize is not 1 for profile");
xres = gwy_get_guint32_le(p);
gwy_debug("Data size: %dx%d", xres, yres);
if (err_SIZE_MISMATCH(error, xres*yres*sizeof(gfloat),
size - 2*sizeof(guint32), FALSE))
return NULL;
if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres))
return NULL;
if (!((data_desc->axes_config.mppx
= fabs(data_desc->axes_config.mppx)) > 0)) {
g_warning("Real x size is 0.0, fixing to 1.0");
data_desc->axes_config.mppx = 1.0;
}
xdata = g_new(gdouble, xres);
ydata = g_new(gdouble, xres);
dx = data_desc->axes_config.mppx * Micrometer;
for (j = n = 0; j < xres; j++) {
gdouble v = gwy_get_gfloat_le(p);
if (v != 1000001.0) {
xdata[n] = dx*j;
ydata[n] = v*Micrometer;
n++;
}
}
if (!n) {
g_free(xdata);
g_free(ydata);
err_NO_DATA(error);
return NULL;
}
gmodel = gwy_graph_model_new();
g_object_set(gmodel, "title", _("Profile"), NULL);
units = gwy_si_unit_new("m"); // values are in um only
g_object_set(gmodel, "si-unit-x", units, NULL);
g_object_unref(units);
units = gwy_si_unit_new("m"); // values are in um only
g_object_set(gmodel, "si-unit-y", units, NULL);
g_object_unref(units);
gcmodel = gwy_graph_curve_model_new();
gwy_graph_curve_model_set_data(gcmodel, xdata, ydata, n);
g_object_set(gcmodel,
"mode", GWY_GRAPH_CURVE_LINE,
"description", _("Profile"),
NULL);
gwy_graph_model_add_curve(gmodel, gcmodel);
g_object_unref(gcmodel);
return gmodel;
}
static gboolean
curvature_dialog(CurvatureArgs *args,
GwyContainer *data,
GwyDataField *dfield,
GwyDataField *mfield,
gint id)
{
enum { RESPONSE_RESET = 1 };
GtkWidget *dialog, *table, *label, *hbox, *vbox, *treeview, *button, *hbox2;
GwyDataChooser *chooser;
GtkTreeSelection *selection;
GtkTreeViewColumn *column;
GtkCellRenderer *renderer;
GwyPixmapLayer *player;
GwyVectorLayer *vlayer;
CurvatureControls controls;
gint response;
gint row;
controls.args = args;
controls.unit = gwy_data_field_get_si_unit_xy(dfield);
gwy_clear(controls.params, PARAM_NPARAMS);
controls.gmodel = gwy_graph_model_new();
init_graph_model_units(controls.gmodel, dfield);
dialog = gtk_dialog_new_with_buttons(_("Curvature"),
NULL, 0,
_("_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;
hbox = gtk_hbox_new(FALSE, 8);
gtk_container_set_border_width(GTK_CONTAINER(hbox), 4);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 0);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 0);
controls.data = gwy_container_new();
gwy_container_set_object_by_name(controls.data, "/0/data", dfield);
if (mfield)
gwy_container_set_object_by_name(controls.data, "/0/mask", mfield);
gwy_app_sync_data_items(data, controls.data, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_REAL_SQUARE,
0);
controls.view = gwy_data_view_new(controls.data);
player = gwy_layer_basic_new();
g_object_set(player,
"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), player);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
vlayer = g_object_new(g_type_from_name("GwyLayerLine"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/line");
gwy_vector_layer_set_editable(vlayer, FALSE);
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.view),
GWY_VECTOR_LAYER(vlayer));
controls.selection = gwy_vector_layer_ensure_selection(vlayer);
g_object_set(controls.selection, "max-objects", 2, NULL);
gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 4);
table = gtk_table_new(5 + (mfield ? 4 : 0), 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, 0);
row = 0;
label = gwy_label_new_header(_("Output Type"));
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++;
controls.set_selection
= gtk_check_button_new_with_mnemonic(_("_Set selection"));
gtk_table_attach(GTK_TABLE(table), controls.set_selection,
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.set_selection),
args->set_selection);
g_signal_connect(controls.set_selection, "toggled",
G_CALLBACK(curvature_set_selection_changed), &controls);
row++;
controls.plot_graph
= gtk_check_button_new_with_mnemonic(_("_Plot graph"));
gtk_table_attach(GTK_TABLE(table), controls.plot_graph,
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.plot_graph),
args->plot_graph);
g_signal_connect(controls.plot_graph, "toggled",
G_CALLBACK(curvature_plot_graph_changed), &controls);
row++;
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
controls.target_hbox = hbox2 = gtk_hbox_new(FALSE, 6);
gtk_widget_set_sensitive(controls.target_hbox, args->plot_graph);
gtk_table_attach(GTK_TABLE(table), hbox2,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
label = gtk_label_new_with_mnemonic(_("Target _graph:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
controls.target_graph = gwy_data_chooser_new_graphs();
chooser = GWY_DATA_CHOOSER(controls.target_graph);
gwy_data_chooser_set_none(chooser, _("New graph"));
gwy_data_chooser_set_active(chooser, NULL, -1);
gwy_data_chooser_set_filter(chooser, filter_target_graphs, &controls, NULL);
gwy_data_chooser_set_active_id(chooser, &args->target_graph);
gwy_data_chooser_get_active_id(chooser, &args->target_graph);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.target_graph);
gtk_box_pack_end(GTK_BOX(hbox2), controls.target_graph, FALSE, FALSE, 0);
g_signal_connect_swapped(controls.target_graph, "changed",
G_CALLBACK(target_graph_changed), &controls);
row++;
if (mfield) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gwy_label_new_header(_("Masking Mode"));
gtk_table_attach(GTK_TABLE(table), label,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
controls.masking_group
= gwy_radio_buttons_create(gwy_masking_type_get_enum(), -1,
G_CALLBACK(curvature_masking_changed),
&controls, args->masking);
row = gwy_radio_buttons_attach_to_table(controls.masking_group,
GTK_TABLE(table), 3, row);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
}
else
controls.masking_group = NULL;
controls.warning = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.warning), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.warning,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
controls.graph = gwy_graph_new(controls.gmodel);
gtk_widget_set_size_request(controls.graph, 320, 260);
g_object_unref(controls.gmodel);
gtk_box_pack_start(GTK_BOX(vbox), controls.graph, TRUE, TRUE, 4);
controls.paramstore = gwy_null_store_new(PARAM_NPARAMS);
treeview
= gtk_tree_view_new_with_model(GTK_TREE_MODEL(controls.paramstore));
g_object_unref(controls.paramstore);
gtk_tree_view_set_headers_visible(GTK_TREE_VIEW(treeview), FALSE);
gtk_box_pack_start(GTK_BOX(vbox), treeview, FALSE, FALSE, 4);
selection = gtk_tree_view_get_selection(GTK_TREE_VIEW(treeview));
gtk_tree_selection_set_mode(selection, GTK_SELECTION_NONE);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Parameter"), renderer,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
render_name, param_names, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
column = gtk_tree_view_column_new_with_attributes(_("Symbol"), renderer,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
render_symbol, param_symbols, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
renderer = gtk_cell_renderer_text_new();
g_object_set(renderer, "xalign", 1.0, NULL);
column = gtk_tree_view_column_new_with_attributes(_("Value"), renderer,
NULL);
gtk_tree_view_column_set_cell_data_func(column, renderer,
render_value, &controls, NULL);
gtk_tree_view_column_set_expand(column, TRUE);
gtk_tree_view_append_column(GTK_TREE_VIEW(treeview), column);
hbox = gtk_hbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox), hbox, FALSE, FALSE, 0);
button = curvature_add_aux_button(hbox, GTK_STOCK_SAVE,
_("Save table to a file"));
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(curvature_save), &controls);
button = curvature_add_aux_button(hbox, GTK_STOCK_COPY,
_("Copy table to clipboard"));
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(curvature_copy), &controls);
curvature_update_preview(&controls, args);
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:
*args = curvature_defaults;
curvature_dialog_update(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
static void
add_one_distribution(GwyContainer *container,
GwyDataField *dfield,
gint ngrains,
const gint *grains,
GwyGrainQuantity quantity,
gint resolution)
{
static const GwyEnum titles[] = {
{ N_("Grain Projected Area Histogram"),
GWY_GRAIN_VALUE_PROJECTED_AREA, },
{ N_("Grain Equivalent Square Side Histogram"),
GWY_GRAIN_VALUE_EQUIV_SQUARE_SIDE, },
{ N_("Grain Equivalent Disc Radius Histogram"),
GWY_GRAIN_VALUE_EQUIV_DISC_RADIUS, },
{ N_("Grain Surface Area Histogram"),
GWY_GRAIN_VALUE_SURFACE_AREA, },
{ N_("Grain Maximum Value Histogram"),
GWY_GRAIN_VALUE_MAXIMUM, },
{ N_("Grain Minimum Value Histogram"),
GWY_GRAIN_VALUE_MINIMUM, },
{ N_("Grain Mean Value Histogram"),
GWY_GRAIN_VALUE_MEAN, },
{ N_("Grain Median Value Histogram"),
GWY_GRAIN_VALUE_MEDIAN, },
{ N_("Grain Projected Boundary Length Histogram"),
GWY_GRAIN_VALUE_FLAT_BOUNDARY_LENGTH, },
{ N_("Grain Minimum Bounding Size Histogram"),
GWY_GRAIN_VALUE_MINIMUM_BOUND_SIZE, },
{ N_("Grain Minimum Bounding Direction Histogram"),
GWY_GRAIN_VALUE_MINIMUM_BOUND_ANGLE, },
{ N_("Grain Maximum Bounding Size Histogram"),
GWY_GRAIN_VALUE_MAXIMUM_BOUND_SIZE, },
{ N_("Grain Maximum Bounding Direction Histogram"),
GWY_GRAIN_VALUE_MAXIMUM_BOUND_ANGLE, },
{ N_("Grain Volume (Zero) Histogram"),
GWY_GRAIN_VALUE_VOLUME_0, },
{ N_("Grain Volume (Minimum) Histogram"),
GWY_GRAIN_VALUE_VOLUME_MIN, },
{ N_("Grain Volume (Laplacian) Histogram"),
GWY_GRAIN_VALUE_VOLUME_LAPLACE, },
};
static const GwyEnum descriptions[] = {
{ N_("Grain proj. areas"),
GWY_GRAIN_VALUE_PROJECTED_AREA, },
{ N_("Grain equiv. square sides"),
GWY_GRAIN_VALUE_EQUIV_SQUARE_SIDE, },
{ N_("Grain equiv. disc radii"),
GWY_GRAIN_VALUE_EQUIV_DISC_RADIUS, },
{ N_("Grain surf. areas"),
GWY_GRAIN_VALUE_SURFACE_AREA, },
{ N_("Grain max. values"),
GWY_GRAIN_VALUE_MAXIMUM, },
{ N_("Grain min. values"),
GWY_GRAIN_VALUE_MINIMUM, },
{ N_("Grain mean values"),
GWY_GRAIN_VALUE_MEAN, },
{ N_("Grain median values"),
GWY_GRAIN_VALUE_MEDIAN, },
{ N_("Grain proj. boundary lengths"),
GWY_GRAIN_VALUE_FLAT_BOUNDARY_LENGTH, },
{ N_("Grain min. bound. sizes"),
GWY_GRAIN_VALUE_MINIMUM_BOUND_SIZE, },
{ N_("Grain min. bound. directions"),
GWY_GRAIN_VALUE_MINIMUM_BOUND_ANGLE, },
{ N_("Grain max. bound. sizes"),
GWY_GRAIN_VALUE_MAXIMUM_BOUND_SIZE, },
{ N_("Grain max. bound. directions"),
GWY_GRAIN_VALUE_MAXIMUM_BOUND_ANGLE, },
{ N_("Grain volumes (zero)"),
GWY_GRAIN_VALUE_VOLUME_0, },
{ N_("Grain volumes (minimum)"),
GWY_GRAIN_VALUE_VOLUME_MIN, },
{ N_("Grain volumes (laplacian)"),
GWY_GRAIN_VALUE_VOLUME_LAPLACE, },
};
GwyGraphCurveModel *cmodel;
GwyGraphModel *gmodel;
GwyDataLine *dataline;
const gchar *s;
dataline = gwy_data_field_grains_get_distribution(dfield, NULL, NULL,
ngrains, grains, quantity,
resolution);
gmodel = gwy_graph_model_new();
cmodel = gwy_graph_curve_model_new();
gwy_graph_model_add_curve(gmodel, cmodel);
g_object_unref(cmodel);
s = gwy_enum_to_string(quantity, titles, G_N_ELEMENTS(titles));
g_object_set(gmodel,
"title", _(s),
"axis-label-left", _("count"),
NULL);
gwy_graph_model_set_units_from_data_line(gmodel, dataline);
s = gwy_enum_to_string(quantity, descriptions, G_N_ELEMENTS(descriptions));
g_object_set(cmodel, "description", s, NULL);
gwy_graph_curve_model_set_data_from_dataline(cmodel, dataline, 0, 0);
g_object_unref(dataline);
gwy_app_data_browser_add_graph_model(gmodel, container, TRUE);
g_object_unref(gmodel);
}