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 GwyDataField*
microprof_read_data_field(const MicroProfFile *mfile,
const guchar *buffer)
{
const guint16 *d16 = (const guint16*)buffer;
GwyDataField *dfield;
GwySIUnit *siunit;
gdouble *d;
guint xres, yres, i, j;
xres = mfile->xres;
yres = mfile->yres;
dfield = gwy_data_field_new(xres, yres,
mfile->xrange, mfile->yrange, FALSE);
d = gwy_data_field_get_data(dfield);
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++) {
d[(yres-1 - i)*xres + j] = mfile->zscale*GUINT16_FROM_LE(*d16);
d16++;
}
}
siunit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string(siunit, "m");
siunit = gwy_data_field_get_si_unit_z(dfield);
gwy_si_unit_set_from_string(siunit, "m");
return dfield;
}
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 gchar*
asc_format_header(GwyContainer *data, GwyDataField *dfield,
gboolean *zunit_is_nm)
{
static const gchar asc_header_template[] =
"# File Format = ASCII\n"
"# Created by Gwyddion %s\n"
"# Original file: %s\n"
"# x-pixels = %u\n"
"# y-pixels = %u\n"
"# x-length = %s\n"
"# y-length = %s\n"
"# x-offset = %s\n"
"# y-offset = %s\n"
"# Bit2nm = 1.0\n"
"%s"
"# Start of Data:\n";
GwySIUnit *zunit;
gchar *header, *zunit_str, *zunit_line;
gchar xreal_str[G_ASCII_DTOSTR_BUF_SIZE],
yreal_str[G_ASCII_DTOSTR_BUF_SIZE],
xoff_str[G_ASCII_DTOSTR_BUF_SIZE],
yoff_str[G_ASCII_DTOSTR_BUF_SIZE];
const guchar *filename = "NONE";
gdouble xreal, yreal, xoff, yoff;
/* XXX: Gwyddion can have lateral dimensions as whatever we want. But
* who knows about the SPIP ASC format... */
xreal = gwy_data_field_get_xreal(dfield)/Nanometer;
yreal = gwy_data_field_get_yreal(dfield)/Nanometer;
xoff = gwy_data_field_get_xoffset(dfield)/Nanometer;
yoff = gwy_data_field_get_yoffset(dfield)/Nanometer;
zunit = gwy_data_field_get_si_unit_z(dfield);
g_ascii_dtostr(xreal_str, G_ASCII_DTOSTR_BUF_SIZE, xreal);
g_ascii_dtostr(yreal_str, G_ASCII_DTOSTR_BUF_SIZE, yreal);
g_ascii_dtostr(xoff_str, G_ASCII_DTOSTR_BUF_SIZE, xoff);
g_ascii_dtostr(yoff_str, G_ASCII_DTOSTR_BUF_SIZE, yoff);
zunit_str = gwy_si_unit_get_string(zunit, GWY_SI_UNIT_FORMAT_PLAIN);
if ((*zunit_is_nm = gwy_strequal(zunit_str, "m")))
zunit_line = g_strdup("");
else
zunit_line = g_strdup_printf("# z-unit = %s\n", zunit_str);
gwy_container_gis_string_by_name(data, "/filename", &filename);
header = g_strdup_printf(asc_header_template,
gwy_version_string(), filename,
gwy_data_field_get_xres(dfield),
gwy_data_field_get_yres(dfield),
xreal_str, yreal_str, xoff_str, yoff_str,
zunit_line);
g_free(zunit_str);
g_free(zunit_line);
return header;
}
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
fill_data_fields(APEFile *apefile,
const guchar *buffer)
{
GwyDataField *dfield;
GwySIUnit *unit;
gdouble *data;
const gchar *zunit;
guint b, n, i, j, k;
gdouble q;
apefile->data = g_new0(GwyDataField*, apefile->ndata);
for (b = apefile->channels, n = 0, k = 0; b; b = b >> 1, k++) {
if (!(b & 1))
continue;
dfield = gwy_data_field_new(apefile->res, apefile->res,
apefile->xreal, apefile->yreal, FALSE);
unit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string(unit, "m");
data = gwy_data_field_get_data(dfield);
buffer += (apefile->res + 1)*sizeof(float);
switch (k) {
case APE_HEIGHT:
case APE_HEIGHT_R:
case APE_AUX2:
case APE_AUX2_R:
q = apefile->z_piezo_factor * 1e-9;
zunit = "m";
break;
case APE_AUX1:
case APE_AUX1_R:
q = 1.0;
zunit = apefile->pg850_image ? "A" : "V";
break;
default:
q = 1.0;
zunit = "V";
break;
}
unit = gwy_data_field_get_si_unit_z(dfield);
gwy_si_unit_set_from_string(unit, zunit);
for (i = 0; i < apefile->res; i++) {
/* There is always one ignored record, do not ask me why... */
buffer += sizeof(float);
for (j = 0; j < apefile->res; j++) {
*(data++) = q*gwy_get_gfloat_le(&buffer);
}
}
apefile->data[n] = dfield;
n++;
}
}
static void
create_merged_field(GwyContainer *data, gint id1,
GwyDataField *dfield1, GwyDataField *dfield2,
gint px1, gint py1, gint px2, gint py2,
GwyMergeBoundaryType boundary, GwyMergeDirectionType dir,
gboolean create_mask, gboolean crop_to_rectangle)
{
GwyDataField *result, *outsidemask = NULL;
gint newxres, newyres, newid;
gwy_debug("field1 %dx%d", dfield1->xres, dfield1->yres);
gwy_debug("field2 %dx%d", dfield2->xres, dfield2->yres);
gwy_debug("px1: %d, py1: %d, px2: %d, py2: %d", px1, py1, px2, py2);
result = gwy_data_field_new_alike(dfield1, FALSE);
newxres = MAX(dfield1->xres + px1, dfield2->xres + px2);
newyres = MAX(dfield1->yres + py1, dfield2->yres + py2);
gwy_data_field_resample(result, newxres, newyres, GWY_INTERPOLATION_NONE);
if (create_mask && !crop_to_rectangle) {
outsidemask = gwy_data_field_new_alike(result, FALSE);
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(outsidemask),
NULL);
}
put_fields(dfield1, dfield2, result, outsidemask,
boundary, px1, py1, px2, py2);
if (crop_to_rectangle) {
GwyOrientation orientation = GWY_ORIENTATION_HORIZONTAL;
if (dir == GWY_MERGE_DIRECTION_UP || dir == GWY_MERGE_DIRECTION_DOWN)
orientation = GWY_ORIENTATION_VERTICAL;
crop_result(result, dfield1, dfield2, orientation, px1, py1, px2, py2);
}
gwy_app_data_browser_get_current(GWY_APP_CONTAINER, &data, 0);
newid = gwy_app_data_browser_add_data_field(result, data, TRUE);
gwy_app_set_data_field_title(data, newid, _("Merged images"));
gwy_app_sync_data_items(data, data, id1, newid,
FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_RANGE,
0);
if (outsidemask) {
if (gwy_data_field_get_max(outsidemask) > 0.0) {
GQuark quark = gwy_app_get_mask_key_for_id(newid);
gwy_container_set_object(data, quark, outsidemask);
}
g_object_unref(outsidemask);
}
gwy_app_channel_log_add_proc(data, -1, newid);
g_object_unref(result);
}
static GwyDataField*
rhk_sm4_page_to_data_field(const RHKPage *page)
{
GwyDataField *dfield;
GwySIUnit *siunit;
const gchar *unit;
const gint32 *pdata;
gint xres, yres, i, j;
gdouble *data;
xres = page->x_size;
yres = page->y_size;
dfield = gwy_data_field_new(xres, yres,
xres*fabs(page->x_scale),
yres*fabs(page->y_scale),
FALSE);
data = gwy_data_field_get_data(dfield);
pdata = (const gint32*)page->data;
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++) {
data[i*xres + xres-1 - j] = GINT32_FROM_LE(pdata[i*xres + j])
*page->z_scale + page->z_offset;
}
}
/* XY units */
if (page->strings[RHK_STRING_X_UNITS]
&& page->strings[RHK_STRING_Y_UNITS]) {
if (!gwy_strequal(page->strings[RHK_STRING_X_UNITS],
page->strings[RHK_STRING_Y_UNITS]))
g_warning("X and Y units differ, using X");
unit = page->strings[RHK_STRING_X_UNITS];
}
else if (page->strings[RHK_STRING_X_UNITS])
unit = page->strings[RHK_STRING_X_UNITS];
else if (page->strings[RHK_STRING_Y_UNITS])
unit = page->strings[RHK_STRING_Y_UNITS];
else
unit = NULL;
siunit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string(siunit, unit);
/* Z units */
if (page->strings[RHK_STRING_Z_UNITS])
unit = page->strings[RHK_STRING_Z_UNITS];
else
unit = NULL;
/* Fix some silly units */
if (unit && gwy_strequal(unit, "N/sec"))
unit = "s^-1";
siunit = gwy_data_field_get_si_unit_z(dfield);
gwy_si_unit_set_from_string(siunit, unit);
return dfield;
}
static GwyDataField*
mif_read_data_field(const MIFImageHeader *image_header,
const MIFBlock *block,
const guchar *buffer,
gsize size,
GError **error)
{
gint xres = image_header->setup.xres;
gint yres = image_header->setup.yres;
gdouble xreal = image_header->setup.xreal;
gdouble yreal = image_header->setup.yreal;
gdouble xoff = image_header->setup.xoff;
gdouble yoff = image_header->setup.yoff;
gdouble q = image_header->configuration.scan_int_to_meter;
GwyDataField *dfield;
gdouble *data;
const gint16 *d16;
gint i, j;
if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres))
return NULL;
if (!block->size || block->offset > size || block->size > size
|| block->offset + block->size > size) {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("Image data are outside the file."));
return NULL;
}
if (err_SIZE_MISMATCH(error, xres*yres*sizeof(gint16), block->size, FALSE))
return NULL;
dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE);
gwy_data_field_set_xoffset(dfield, xoff);
gwy_data_field_set_yoffset(dfield, yoff);
data = gwy_data_field_get_data(dfield);
d16 = (const gint16*)(buffer + block->offset);
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m");
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), "m");
// FIXME: Don't know why this factor. It seems to match what MIF spmview
// profile reader shows though.
q *= 1.0e4;
for (i = 0; i < yres; i++) {
for (j = 0; j < yres; j++) {
data[(yres-1 - i)*xres + j] = q*GINT16_FROM_LE(d16[i*xres + j]);
}
}
return dfield;
}
static GwyDataField*
prof_psdf(GwyDataField *dfield,
const ProfArgs *args)
{
GwyDataField *fftre, *fftim;
GwySIUnit *zunit;
const gdouble *im;
gdouble *re;
gint xres, yres, i;
fftre = gwy_data_field_new_alike(dfield, FALSE);
fftim = gwy_data_field_new_alike(dfield, FALSE);
gwy_data_field_2dfft(dfield, NULL, fftre, fftim,
args->windowing,
GWY_TRANSFORM_DIRECTION_FORWARD,
GWY_INTERPOLATION_LINEAR, /* ignored */
FALSE, 1);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
re = gwy_data_field_get_data(fftre);
im = gwy_data_field_get_data_const(fftim);
/* Put the PSDF to fftre. */
for (i = 0; i < xres*yres; i++)
re[i] = re[i]*re[i] + im[i]*im[i];
g_object_unref(fftim);
gwy_data_field_fft_postprocess(fftre, TRUE);
zunit = gwy_data_field_get_si_unit_z(fftre);
gwy_si_unit_power(gwy_data_field_get_si_unit_z(dfield), 2, zunit);
gwy_si_unit_multiply(gwy_data_field_get_si_unit_xy(dfield), zunit, zunit);
return fftre;
}
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 GwyDataField*
rhkspm32_read_data(RHKPage *rhkpage)
{
GwyDataField *dfield;
const guint16 *p;
GwySIUnit *siunit;
gdouble *data;
const gchar *s;
gdouble q;
gint power10;
guint i, j, xres, yres;
p = (const guint16*)(rhkpage->buffer + rhkpage->data_offset);
xres = rhkpage->xres;
yres = rhkpage->yres;
// the scales are no longer gurunteed to be positive,
// so they must be "fixed" here (to enable spectra)
dfield = gwy_data_field_new(xres, yres,
xres*fabs(rhkpage->x.scale),
yres*fabs(rhkpage->y.scale),
FALSE);
data = gwy_data_field_get_data(dfield);
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++)
data[i*xres + xres-1 - j] = GINT16_FROM_LE(p[i*xres + j]);
}
siunit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string_parse(siunit, rhkpage->x.units, &power10);
if (power10) {
q = pow10(power10);
gwy_data_field_set_xreal(dfield, q*gwy_data_field_get_xreal(dfield));
gwy_data_field_set_yreal(dfield, q*gwy_data_field_get_yreal(dfield));
}
siunit = gwy_data_field_get_si_unit_z(dfield);
s = rhkpage->z.units;
/* Fix some silly units */
if (gwy_strequal(s, "N/sec"))
s = "s^-1";
gwy_si_unit_set_from_string_parse(siunit, s, &power10);
q = pow10(power10);
gwy_data_field_multiply(dfield, q*fabs(rhkpage->z.scale));
gwy_data_field_add(dfield, q*rhkpage->z.offset);
return dfield;
}
static void
init_graph_model_units(GwyGraphModel *gmodel,
GwyDataField *dfield)
{
GwySIUnit *unit;
unit = gwy_data_field_get_si_unit_xy(dfield);
unit = gwy_si_unit_duplicate(unit);
g_object_set(gmodel, "si-unit-x", unit, NULL);
g_object_unref(unit);
unit = gwy_data_field_get_si_unit_z(dfield);
unit = gwy_si_unit_duplicate(unit);
g_object_set(gmodel, "si-unit-y", unit, NULL);
g_object_unref(unit);
}
static GwyDataField*
jeol_read_data_field(const guchar *buffer,
const JEOLImageHeader *header)
{
GwyDataField *dfield;
const gchar *unitstr;
gdouble q, z0;
switch (header->spm_misc_param.measurement_signal) {
case JEOL_MEASUREMENT_SIGNAL_TOPOGRAPHY:
z0 = Nanometer*header->z0;
q = (header->z255 - header->z0)/65535.0*Nanometer;
unitstr = "m";
break;
case JEOL_MEASUREMENT_SIGNAL_LINEAR_CURRENT:
z0 = Nanoampere*header->z0;
q = (header->z255 - header->z0)/65535.0*Nanoampere;
unitstr = "A";
break;
/* We just guess it's always voltage. At least sometimes it is. */
case JEOL_MEASUREMENT_SIGNAL_AUX1:
case JEOL_MEASUREMENT_SIGNAL_AUX2:
z0 = header->z0;
q = (header->z255 - header->z0)/65535.0;
unitstr = "V";
break;
default:
return NULL;
break;
}
dfield = gwy_data_field_new(header->xres, header->yres,
Nanometer*header->xreal,
Nanometer*header->yreal,
FALSE);
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m");
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), unitstr);
gwy_convert_raw_data(buffer, header->xres*header->yres, 1,
GWY_RAW_DATA_UINT16, GWY_BYTE_ORDER_LITTLE_ENDIAN,
gwy_data_field_get_data(dfield), q, z0);
return dfield;
}
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);
}
static void
create_images(const X3PFile *x3pfile, GwyContainer *container)
{
gint id;
for (id = 0; id < x3pfile->zres; id++) {
GwyContainer *meta;
guint n = x3pfile->xres*x3pfile->yres, k;
GwyDataField *dfield, *mask;
const gboolean *valid = x3pfile->valid + id*n;
GQuark quark;
gchar buf[40];
dfield = gwy_data_field_new(x3pfile->xres,
x3pfile->yres,
x3pfile->xres*x3pfile->dx,
x3pfile->yres*x3pfile->dy,
FALSE);
memcpy(dfield->data, x3pfile->values + id*n, n*sizeof(gdouble));
for (k = 0; k < n; k++) {
if (!valid[k])
dfield->data[k] = NAN;
}
quark = gwy_app_get_data_key_for_id(id);
gwy_container_set_object(container, quark, dfield);
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m");
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), "m");
gwy_app_channel_title_fall_back(container, id);
gwy_app_channel_check_nonsquare(container, id);
if ((mask = gwy_app_channel_mask_of_nans(dfield, TRUE))) {
quark = gwy_app_get_mask_key_for_id(id);
gwy_container_set_object(container, quark, mask);
g_object_unref(mask);
}
g_object_unref(dfield);
if ((meta = get_meta(x3pfile))) {
g_snprintf(buf, sizeof(buf), "/%u/meta", id);
gwy_container_set_object_by_name(container, buf, meta);
g_object_unref(meta);
}
}
}
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_app_file_chooser_describe_channel(GwyContainer *container,
gint id,
GString *str)
{
GwyDataField *dfield;
GwySIUnit *siunit;
GwySIValueFormat *vf;
GQuark quark;
gint xres, yres;
gdouble xreal, yreal;
gchar *s;
g_string_truncate(str, 0);
quark = gwy_app_get_data_key_for_id(id);
dfield = GWY_DATA_FIELD(gwy_container_get_object(container, quark));
g_return_if_fail(GWY_IS_DATA_FIELD(dfield));
s = gwy_app_get_data_field_title(container, id);
g_string_append(str, s);
g_free(s);
siunit = gwy_data_field_get_si_unit_z(dfield);
s = gwy_si_unit_get_string(siunit, GWY_SI_UNIT_FORMAT_MARKUP);
g_string_append_printf(str, " [%s]\n", s);
g_free(s);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
g_string_append_printf(str, "%d×%d px\n", xres, yres);
xreal = gwy_data_field_get_xreal(dfield);
yreal = gwy_data_field_get_yreal(dfield);
siunit = gwy_data_field_get_si_unit_xy(dfield);
vf = gwy_si_unit_get_format(siunit, GWY_SI_UNIT_FORMAT_VFMARKUP,
sqrt(xreal*yreal), NULL);
g_string_append_printf(str, "%.*f×%.*f%s%s",
vf->precision, xreal/vf->magnitude,
vf->precision, yreal/vf->magnitude,
(vf->units && *vf->units) ? " " : "", vf->units);
gwy_si_unit_value_format_free(vf);
}
static void
set_up_quantity(GFilterControls *controls, GwyGrainValue *gvalue, guint id)
{
GFilterArgs *args = controls->args;
GwyInventory *inventory;
GwyDataField *dfield;
RangeRecord *rr;
const gchar *name;
const gdouble *v;
gchar *s, *t;
gdouble vmin, vmax, lower = -G_MAXDOUBLE, upper = G_MAXDOUBLE;
GwySIUnit *siunit, *siunitxy, *siunitz;
gboolean was_in_init = controls->in_init;
guint i, nuniq;
controls->in_init = TRUE;
name = gwy_resource_get_name(GWY_RESOURCE(gvalue));
args->ranges[id].quantity = name;
/* TRANSLATORS: %c is replaced with quantity label A, B or C. */
s = g_strdup_printf(_("Condition %c: %s"), 'A' + id, name);
t = g_strconcat("<b>", s, "</b>", NULL);
gtk_label_set_markup(GTK_LABEL(controls->header[id]), t);
g_free(t);
g_free(s);
rr = g_hash_table_lookup(args->ranges_history, (gpointer)name);
if (rr) {
lower = rr->lower;
upper = rr->upper;
}
inventory = gwy_grain_values();
i = gwy_inventory_get_item_position(inventory, name);
nuniq = args->nuniqvalues[i];
v = g_ptr_array_index(args->sortedvaluedata, i);
vmin = v[0];
vmax = v[nuniq-1];
lower = CLAMP(lower, vmin, vmax);
upper = CLAMP(upper, vmin, vmax);
gtk_adjustment_set_upper(GTK_ADJUSTMENT(controls->lower[id]), nuniq-1);
gtk_adjustment_set_upper(GTK_ADJUSTMENT(controls->upper[id]), nuniq-1);
dfield = gwy_container_get_object_by_name(controls->mydata, "/0/data");
siunitxy = gwy_data_field_get_si_unit_xy(dfield);
siunitz = gwy_data_field_get_si_unit_z(dfield);
siunit = gwy_si_unit_power_multiply(siunitxy,
gwy_grain_value_get_power_xy(gvalue),
siunitz,
gwy_grain_value_get_power_z(gvalue),
NULL);
gwy_si_unit_get_format_with_digits(siunit, GWY_SI_UNIT_FORMAT_VFMARKUP,
MAX(fabs(vmin), fabs(vmax)), 4,
controls->vf[id]);
g_object_unref(siunit);
/* Special-case the pixel area format. */
if (gwy_strequal(name, "Pixel area")) {
controls->vf[id]->magnitude = 1.0;
controls->vf[id]->precision = 0;
gwy_si_unit_value_format_set_units(controls->vf[id], "");
}
gtk_label_set_markup(GTK_LABEL(controls->lower_units[id]),
controls->vf[id]->units);
gtk_label_set_markup(GTK_LABEL(controls->upper_units[id]),
controls->vf[id]->units);
args->ranges[id].quantity = name;
args->ranges[id].lower = lower;
args->ranges[id].upper = upper;
set_adjustment_to_grain_value(controls, gvalue,
GTK_ADJUSTMENT(controls->lower[id]), lower);
set_adjustment_to_grain_value(controls, gvalue,
GTK_ADJUSTMENT(controls->upper[id]), upper);
s = g_strdup_printf("%.*f",
controls->vf[id]->precision,
lower/controls->vf[id]->magnitude);
gtk_entry_set_text(GTK_ENTRY(controls->lower_entry[id]), s);
g_free(s);
s = g_strdup_printf("%.*f",
controls->vf[id]->precision,
upper/controls->vf[id]->magnitude);
gtk_entry_set_text(GTK_ENTRY(controls->upper_entry[id]), s);
g_free(s);
/* XXX: We might have modified the range by CLAMP(). Store the new one
* right here? Pro: consistency. Con: the user did not do anything,
* he just may be browsing. */
controls->in_init = was_in_init;
gfilter_invalidate(controls);
}
static GwyDataField*
apedax_get_data_field(unzFile uFile,
const gchar *chFileName,
const APEScanSize *scanSize,
gchar *zUnit,
gdouble scale,
GError **error)
{
GwyDataField *dfield = NULL;
GwySIUnit *xyUnit;
GwySIUnit *zSIUnit;
gdouble *data;
guchar *buffer;
gsize size, expectedSize;
unz_file_info uFileInfo;
/*Checking the dimensions*/
if (err_DIMENSION(error, scanSize->XRes)) {
return NULL;
}
if (err_DIMENSION(error, scanSize->YRes)) {
return NULL;
}
/*If XReal it's not greater than 0 or XReal is NaN*/
if (!(fabs(scanSize->XReal) > 0)) {
err_UNSUPPORTED(error, "X scan size");
return NULL;
}
/*Same for YReal*/
if (!(fabs(scanSize->YReal) > 0)) {
err_UNSUPPORTED(error, "Y scan size");
return NULL;
}
expectedSize = scanSize->XRes * scanSize->YRes * sizeof(gdouble);
unzGoToFirstFile(uFile);
if (unzLocateFile(uFile, chFileName, 0) != UNZ_OK) {
gwy_debug("Binary file not found");
err_NO_DATA(error);
return NULL;
}
if (unzGetCurrentFileInfo(uFile,
&uFileInfo,
NULL,
0L,
NULL,
0L,
NULL,
0L) != UNZ_OK) {
err_NO_DATA(error);
return NULL;
}
buffer = apedax_get_file_content(uFile, &uFileInfo, &size, error);
if (buffer == NULL) {
err_NO_DATA(error);
return NULL;
}
if (err_SIZE_MISMATCH(error, expectedSize, size, FALSE)) {
return NULL;
}
dfield = gwy_data_field_new(scanSize->XRes, scanSize->YRes,
scanSize->XReal, scanSize->YReal,
FALSE);
data = gwy_data_field_get_data(dfield);
xyUnit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string(xyUnit, "m");
zSIUnit = gwy_data_field_get_si_unit_z(dfield);
gwy_si_unit_set_from_string(zSIUnit, zUnit);
gwy_debug("Reading RAW data");
gwy_convert_raw_data(buffer,
scanSize->XRes * scanSize->YRes,
1,
GWY_RAW_DATA_DOUBLE,
GWY_BYTE_ORDER_LITTLE_ENDIAN,
data,
scale,
0.0);
return dfield;
}
static GwyContainer*
int_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL, *meta;
GwyDataField *dfield = NULL, *mfield = NULL;
CodeVGridDataType type;
gchar *line, *p, *comment, *end, *buffer = NULL;
const gchar *unit, *title;
gchar **fields = NULL;
gsize size;
GError *err = NULL;
gdouble xreal, yreal;
gint i, xres, yres, no_data_value = 32767;
guint fi;
gdouble scale_size, wavelength, q = 1.0, x_scale = 1.0;
gboolean nearest_neighbour = FALSE;
gdouble *data, *mdata;
if (!g_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
goto fail;
}
/* Skip comments. */
p = buffer;
for (line = gwy_str_next_line(&p);
line && line[0] == '!';
line = gwy_str_next_line(&p)) {
gwy_debug("comment <%s>", line);
}
if (!line) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
/* The title. */
comment = line;
if (!(line = gwy_str_next_line(&p))) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
gwy_debug("comment <%s>", comment);
fields = split_line_in_place(line);
if (!fields
|| g_strv_length(fields) < 8
|| !gwy_strequal(fields[0], "GRD")
|| !(xres = atoi(fields[1]))
|| !(yres = atoi(fields[2]))
|| !(type = gwy_stramong(fields[3],
"SUR", "WFR", "FIL", "THV", "BIR", "CAO",
NULL))
|| !gwy_strequal(fields[4], "WVL")
|| (!(wavelength = g_ascii_strtod(fields[5], &end))
&& end == fields[5])) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
gwy_debug("type %u (%s)", type, fields[3]);
gwy_debug("xres %d, yres %d", xres, yres);
gwy_debug("wavelength %g", wavelength);
fi = 6;
if (gwy_strequal(fields[fi], "NNB")) {
nearest_neighbour = TRUE;
fi++;
}
gwy_debug("nearest_neighbour %d", nearest_neighbour);
if (!fields[fi] || !gwy_strequal(fields[fi], "SSZ")) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
fi++;
if (!(scale_size = g_ascii_strtod(fields[fi], &end)) && end == fields[fi]) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
gwy_debug("scale_size %g", scale_size);
if (!scale_size) {
g_warning("Zero SSZ, fixing to 1.0");
scale_size = 1.0;
}
fi++;
if (fields[fi] && gwy_strequal(fields[fi], "NDA")) {
fi++;
if (!fields[fi]) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
no_data_value = atoi(fields[fi]);
fi++;
}
gwy_debug("no_data_value %d", no_data_value);
if (fields[fi] && gwy_strequal(fields[fi], "XSC")) {
fi++;
if (!fields[fi]) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
if (!(x_scale = g_ascii_strtod(fields[fi], &end))
&& end == fields[fi]) {
err_FILE_TYPE(error, "Code V INT");
goto fail;
}
fi++;
}
gwy_debug("x_scale %g", x_scale);
if (!x_scale) {
g_warning("Zero XSC, fixing to 1.0");
x_scale = 1.0;
}
/* There may be more stuff but we do not know anything about it. */
if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres))
goto fail;
yreal = 1.0;
xreal = x_scale*yreal;
dfield = gwy_data_field_new(xres, yres, xreal, yreal, TRUE);
if (type == CODEV_INT_SURFACE_DEFORMATION) {
q = 1e-6*wavelength/scale_size;
unit = "m";
title = "Surface";
}
else if (type == CODEV_INT_WAVEFRONT_DEFORMATION) {
q = 1e-6*wavelength/scale_size;
unit = "m";
title = "Wavefront";
}
else {
g_warning("Don't know how to convert this grid data type to physical "
"units.");
title = fields[3];
}
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), unit);
mfield = gwy_data_field_new_alike(dfield, TRUE);
data = gwy_data_field_get_data(dfield);
mdata = gwy_data_field_get_data(mfield);
for (i = 0; i < xres*yres; i++, p = end) {
gint value = strtol(p, &end, 10);
if (value != no_data_value && (type != CODEV_INT_INTENSITY_FILTER
|| value >= 0)) {
mdata[i] = 1.0;
data[i] = q*value;
}
}
if (!gwy_app_channel_remove_bad_data(dfield, mfield))
gwy_object_unref(mfield);
container = gwy_container_new();
/*
gwy_data_field_invert(dfield, TRUE, FALSE, FALSE);
from F. Riguet : apparently no flip is needed (the raw data import module
gives the correct orientation without further flipping)
*/
gwy_container_set_object(container, gwy_app_get_data_key_for_id(0), dfield);
g_object_unref(dfield);
gwy_app_channel_check_nonsquare(container, 0);
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup(title));
if (mfield) {
/*
gwy_data_field_invert(mfield, FALSE, TRUE, FALSE);
*/
gwy_container_set_object(container, gwy_app_get_mask_key_for_id(0),
mfield);
g_object_unref(mfield);
}
meta = gwy_container_new();
gwy_container_set_string_by_name(meta, "Comment", g_strdup(comment));
gwy_container_set_string_by_name(meta, "Interpolation",
g_strdup(nearest_neighbour
? "NNB" : "Linear"));
gwy_container_set_string_by_name(meta, "Wavelength",
g_strdup_printf("%g μm", wavelength));
gwy_container_set_object_by_name(container, "/0/meta", meta);
g_object_unref(meta);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
fail:
g_free(fields);
g_free(buffer);
return container;
}
static gboolean
cnew_dialog(CNewArgs *args,
GwyDataField *dfield)
{
GtkWidget *dialog, *table, *spin, *label;
GwySIUnit *unit;
gint row;
CNewControls controls;
gint response;
controls.args = args;
controls.in_update = TRUE;
dialog = gtk_dialog_new_with_buttons(_("Simple Calibration Data"), 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);
table = gtk_table_new(4, 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(GTK_DIALOG(dialog)->vbox), table,
FALSE, FALSE, 4);
/*x from*/
row = 0;
label = gtk_label_new_with_mnemonic(_("_X from:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.xrange_from = gtk_adjustment_new(args->xrange_from/pow10(args->xyexponent),
-10000, 10000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.xrange_from), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
unit = gwy_data_field_get_si_unit_xy(dfield);
controls.xyexponent
= gwy_combo_box_metric_unit_new(G_CALLBACK(xyexponent_changed_cb),
&controls, -15, 6, unit,
args->xyexponent);
gtk_table_attach(GTK_TABLE(table), controls.xyexponent, 2, 3, row, row+2,
GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0, 0);
controls.xyunits = gtk_button_new_with_label(gwy_sgettext("verb|Change"));
g_object_set_data(G_OBJECT(controls.xyunits), "id", (gpointer)"xy");
gtk_table_attach(GTK_TABLE(table), controls.xyunits,
3, 4, row, row+2,
GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_X to:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.xrange_to = gtk_adjustment_new(args->xrange_to/pow10(args->xyexponent),
-10000, 10000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.xrange_to), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_Y from:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.yrange_from = gtk_adjustment_new(args->yrange_from/pow10(args->xyexponent),
-10000, 10000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.yrange_from), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_Y to:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.yrange_to = gtk_adjustment_new(args->yrange_to/pow10(args->xyexponent),
-10000, 10000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.yrange_to), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_Z from:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.zrange_from = gtk_adjustment_new(args->zrange_from/pow10(args->zexponent),
-10000, 10000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.zrange_from), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
unit = gwy_data_field_get_si_unit_z(dfield);
controls.zexponent
= gwy_combo_box_metric_unit_new(G_CALLBACK(zexponent_changed_cb),
&controls, -15, 6, unit,
args->zexponent);
gtk_table_attach(GTK_TABLE(table), controls.zexponent, 2, 3, row, row+2,
GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0, 0);
controls.zunits = gtk_button_new_with_label(gwy_sgettext("verb|Change"));
g_object_set_data(G_OBJECT(controls.zunits), "id", (gpointer)"z");
gtk_table_attach(GTK_TABLE(table), controls.zunits,
3, 4, row, row+2,
GTK_EXPAND | GTK_FILL | GTK_SHRINK, 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_Z to:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.zrange_to = gtk_adjustment_new(args->zrange_to/pow10(args->zexponent),
-10000, 10000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.zrange_to), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_X uncertainty:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.xunc = gtk_adjustment_new(args->xunc/pow10(args->xyuexponent),
-10000, 10000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.xunc), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
unit = gwy_data_field_get_si_unit_xy(dfield);
controls.xyuexponent
= gwy_combo_box_metric_unit_new(G_CALLBACK(xyuexponent_changed_cb),
&controls, -15, 6, unit,
args->xyuexponent);
gtk_table_attach(GTK_TABLE(table), controls.xyuexponent, 2, 3, row, row+2,
GTK_EXPAND | GTK_FILL , 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_Y uncertainty:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.yunc = gtk_adjustment_new(args->yunc/pow10(args->xyuexponent),
-10000, 10000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.yunc), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_Z uncertainty:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.zunc = gtk_adjustment_new(args->zunc/pow10(args->zuexponent),
-10000, 10000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.zunc), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
unit = gwy_data_field_get_si_unit_z(dfield);
controls.zuexponent
= gwy_combo_box_metric_unit_new(G_CALLBACK(zuexponent_changed_cb),
&controls, -15, 6, unit,
args->zuexponent);
gtk_table_attach(GTK_TABLE(table), controls.zuexponent, 2, 3, row, row+1,
GTK_EXPAND | GTK_FILL , 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_X correction factor:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.xmult = gtk_adjustment_new(args->xmult,
0, 1000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.xmult), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_Y correction factor:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.ymult = gtk_adjustment_new(args->ymult,
0, 1000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.ymult), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("_Z correction factor:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.zmult = gtk_adjustment_new(args->zmult,
0, 1000, 1, 10, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.zmult), 1, 2);
gtk_spin_button_set_numeric(GTK_SPIN_BUTTON(spin), TRUE);
gtk_table_attach(GTK_TABLE(table), spin,
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
label = gtk_label_new_with_mnemonic(_("Calibration name:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 1, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.name = GTK_ENTRY(gtk_entry_new());
gtk_entry_set_text(controls.name, args->name);
gtk_table_attach(GTK_TABLE(table), GTK_WIDGET(controls.name),
1, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect(controls.xrange_from, "value-changed",
G_CALLBACK(xfrom_changed_cb), &controls);
g_signal_connect(controls.xrange_to, "value-changed",
G_CALLBACK(xto_changed_cb), &controls);
g_signal_connect(controls.yrange_from, "value-changed",
G_CALLBACK(yfrom_changed_cb), &controls);
g_signal_connect(controls.yrange_to, "value-changed",
G_CALLBACK(yto_changed_cb), &controls);
g_signal_connect(controls.zrange_from, "value-changed",
G_CALLBACK(zfrom_changed_cb), &controls);
g_signal_connect(controls.zrange_to, "value-changed",
G_CALLBACK(zto_changed_cb), &controls);
g_signal_connect(controls.xunc, "value-changed",
G_CALLBACK(xunc_changed_cb), &controls);
g_signal_connect(controls.yunc, "value-changed",
G_CALLBACK(yunc_changed_cb), &controls);
g_signal_connect(controls.zunc, "value-changed",
G_CALLBACK(zunc_changed_cb), &controls);
g_signal_connect(controls.xmult, "value-changed",
G_CALLBACK(xmult_changed_cb), &controls);
g_signal_connect(controls.ymult, "value-changed",
G_CALLBACK(ymult_changed_cb), &controls);
g_signal_connect(controls.zmult, "value-changed",
G_CALLBACK(zmult_changed_cb), &controls);
g_signal_connect(controls.xyunits, "clicked",
G_CALLBACK(units_change_cb), &controls);
g_signal_connect(controls.zunits, "clicked",
G_CALLBACK(units_change_cb), &controls);
controls.in_update = FALSE;
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:
/*check whether this resource already exists*/
args->name = g_strdup(gtk_entry_get_text(controls.name));
if (gwy_inventory_get_item(gwy_calibrations(), args->name))
response = ask_for_overwrite(GTK_WINDOW(dialog), args);
else
args->duplicate = DUPLICATE_NONE;
break;
case RESPONSE_RESET:
*args = cnew_defaults;
cnew_dialog_update(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
return TRUE;
}
static gboolean
surffile_save(GwyContainer *data,
const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
FILE *fh;
gboolean ok = TRUE;
SurfWriter surf;
gfloat uintmax = 1073741824.0;
gdouble zmaxreal;
gdouble zminreal;
gdouble xreal;
gdouble yreal;
gchar *dxunittmp;
gchar *dyunittmp;
gchar *dzunittmp;
GwySIUnit *xysi;
GwySIUnit *zsi;
GwyContainer *current_data;
int power = 0;
int k = 0;
GwyDataField *dfield;
const gdouble *points;
gint32 *integer_values;
strncpy(surf.signature, "DIGITAL SURF", 12);
surf.format = 0;
surf.nobjects = 1;
surf.version = 1;
surf.type = 1;
strncpy(surf.object_name, "SCRATCH", 30);
strncpy(surf.operator_name, "csm", 30);
surf.material_code = 0;
surf.acquisition = 0;
surf.range = 1;
surf.special_points = 0;
surf.absolute = 1;
strncpy(surf.reserved, " ", 8);
surf.pointsize = 32;
surf.zmin = 0;
surf.zmax = 1073741824.0;
strncpy(surf.xaxis, "X", 16);
strncpy(surf.yaxis, "Y", 16);
strncpy(surf.zaxis, "Z", 16);
surf.xunit_ratio = 1;
surf.yunit_ratio = 1;
surf.zunit_ratio = 1;
surf.imprint = 1;
surf.inversion = 0;
surf.leveling = 0;
strncpy(surf.obsolete, " ", 12);
surf.seconds = 0;
surf.minutes = 0;
surf.hours = 0;
surf.day = 5;
surf.month = 1;
surf.year = 2001;
surf.dayof = 0;
surf.measurement_duration = 1.0;
strncpy(surf.obsolete2, " ", 10);
surf.comment_size = 0;
surf.private_size = 0;
strncpy(surf.client_zone," ", 128);
surf.XOffset = 0.0;
surf.YOffset = 0.0;
surf.ZOffset = 0.0;
strncpy(surf.reservedzone, " ", 34);
if (!(fh = gwy_fopen( filename, "wb"))) {
err_OPEN_WRITE(error);
return FALSE;
}
gwy_app_data_browser_get_current(GWY_APP_CONTAINER, ¤t_data, 0);
if (!current_data) {
err_NO_CHANNEL_EXPORT(error);
return FALSE;
}
if (data != current_data) {
return FALSE;
}
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield, 0);
if (!dfield) {
err_NO_CHANNEL_EXPORT(error);
return FALSE;
}
/*header values*/
xysi = gwy_data_field_get_si_unit_xy(dfield);
zsi = gwy_data_field_get_si_unit_z(dfield);
dxunittmp = gwy_si_unit_get_string(xysi, GWY_SI_UNIT_FORMAT_PLAIN);
dyunittmp = gwy_si_unit_get_string (xysi, GWY_SI_UNIT_FORMAT_PLAIN);
dzunittmp = gwy_si_unit_get_string (zsi, GWY_SI_UNIT_FORMAT_PLAIN);
strncpy(surf.dx_unit, dxunittmp, 16);
strncpy(surf.dy_unit, dyunittmp, 16);
strncpy(surf.dz_unit, dzunittmp, 16);
g_free(dxunittmp);
g_free(dyunittmp);
g_free(dzunittmp);
/*extrema*/
zmaxreal = gwy_data_field_get_max(dfield);
zminreal = gwy_data_field_get_min(dfield);
surf.xres = gwy_data_field_get_xres(dfield);
surf.yres = gwy_data_field_get_yres(dfield);
surf.nofpoints = surf.xres * surf.yres;
xreal = gwy_data_field_get_xreal(dfield);
yreal = gwy_data_field_get_yreal(dfield);
/*units*/
power = 0;
surf.dx = (gfloat)(xreal / surf.xres);
get_unit(surf.dx_unit, &power, xreal);
surf.dx *= pow10(power);
strncpy(surf.xlength_unit, surf.dx_unit, 16);
power = 0;
surf.dy = (gfloat)(yreal / surf.yres);
get_unit(surf.dy_unit, &power, yreal);
surf.dy *= pow10(power);
strncpy(surf.ylength_unit, surf.dy_unit, 16);
power = 0;
if (zmaxreal > zminreal) {
get_unit(surf.dz_unit, &power, (zmaxreal - zminreal));
}
strncpy(surf.zlength_unit, surf.dz_unit, 16);
zmaxreal *= pow10(power);
zminreal *= pow10(power);
surf.dz = (zmaxreal - zminreal) / uintmax;
surf.ZOffset = zminreal;
/*convert data into integer32*/
integer_values = g_new(gint32, surf.nofpoints);
points = gwy_data_field_get_data_const(dfield);
if (zminreal != zmaxreal) {
for (k = 0; k < surf.nofpoints; k++) { // * pow10( power ) to convert in the dz_unit
integer_values[k] = floor(uintmax * (points[k] * pow10(power) - zminreal) / (zmaxreal - zminreal));
}
}
else {
for (k = 0; k < surf.nofpoints; k++) {
integer_values[k] = 0;
}
}
/* byte order*/
surf.format = GINT16_TO_LE(surf.format);
surf.nobjects = GUINT16_TO_LE(surf.nobjects);
surf.version = GINT16_TO_LE(surf.version);
surf.type = GINT16_TO_LE(surf.type);
surf.material_code = GINT16_TO_LE(surf.material_code);
surf.acquisition = GINT16_TO_LE(surf.acquisition);
surf.range = GINT16_TO_LE(surf.range);
surf.special_points = GINT16_TO_LE(surf.special_points);
surf.absolute = GINT16_TO_LE(surf.absolute);
surf.pointsize = GINT16_TO_LE(surf.pointsize);
surf.zmin = GINT32_TO_LE(surf.zmin);
surf.zmax = GINT32_TO_LE(surf.zmax);
surf.xres = GINT32_TO_LE(surf.xres);
surf.yres = GINT32_TO_LE(surf.yres);
surf.nofpoints = GINT32_TO_LE(surf.nofpoints);
surf.dx = GFLOAT_TO_LE(surf.dx);
surf.dy = GFLOAT_TO_LE(surf.dy);
surf.dz = GFLOAT_TO_LE(surf.dz);
surf.xunit_ratio = GFLOAT_TO_LE(surf.xunit_ratio);
surf.yunit_ratio = GFLOAT_TO_LE(surf.yunit_ratio);
surf.zunit_ratio = GFLOAT_TO_LE(surf.zunit_ratio);
surf.imprint = GINT16_TO_LE(surf.imprint);
surf.inversion = GINT16_TO_LE(surf.inversion);
surf.leveling = GINT16_TO_LE(surf.leveling);
surf.seconds = GINT16_TO_LE(surf.seconds);
surf.minutes = GINT16_TO_LE(surf.minutes);
surf.hours = GINT16_TO_LE(surf.hours);
surf.day = GINT16_TO_LE(surf.day);
surf.month = GINT16_TO_LE(surf.month);
surf.year = GINT16_TO_LE(surf.year);
surf.dayof = GINT16_TO_LE(surf.dayof);
surf.measurement_duration = GFLOAT_TO_LE(surf.measurement_duration);
surf.comment_size = GINT16_TO_LE(surf.comment_size);
surf.private_size = GINT16_TO_LE(surf.private_size);
surf.XOffset = GFLOAT_TO_LE(surf.XOffset);
surf.YOffset = GFLOAT_TO_LE(surf.YOffset);
surf.ZOffset = GFLOAT_TO_LE(surf.ZOffset);
for (k = 0; k < surf.nofpoints; k++) {
integer_values[k] = GINT32_TO_LE(integer_values[k]);
}
//write
// fwrite(&surf, sizeof( SurfWriter ), 1, fh) bad struct align
if(
fwrite(&surf.signature, sizeof(char), 12, fh) != 12 ||
fwrite(&surf.format, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.nobjects, sizeof(guint16), 1, fh) != 1 ||
fwrite(&surf.version, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.type, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.object_name, sizeof(char), 30, fh) != 30 ||
fwrite(&surf.operator_name, sizeof(char), 30, fh) != 30 ||
fwrite(&surf.material_code, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.acquisition, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.range, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.special_points, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.absolute, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.reserved, sizeof(char), 8, fh) != 8 ||
fwrite(&surf.pointsize, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.zmin, sizeof(gint32), 1, fh) != 1 ||
fwrite(&surf.zmax, sizeof(gint32), 1, fh) != 1 ||
fwrite(&surf.xres, sizeof(gint32), 1, fh) != 1 ||
fwrite(&surf.yres, sizeof(gint32), 1, fh) != 1 ||
fwrite(&surf.nofpoints, sizeof(gint32), 1, fh) != 1 ||
fwrite(&surf.dx, sizeof(gfloat), 1, fh) != 1 ||
fwrite(&surf.dy, sizeof(gfloat), 1, fh) != 1 ||
fwrite(&surf.dz, sizeof(gfloat), 1, fh) != 1 ||
fwrite(&surf.xaxis, sizeof(char), 16, fh) != 16 ||
fwrite(&surf.yaxis, sizeof(char), 16, fh) != 16 ||
fwrite(&surf.zaxis, sizeof(char), 16, fh) != 16 ||
fwrite(&surf.dx_unit, sizeof(char), 16, fh) != 16 ||
fwrite(&surf.dy_unit, sizeof(char), 16, fh) != 16 ||
fwrite(&surf.dz_unit, sizeof(char), 16, fh) != 16 ||
fwrite(&surf.xlength_unit, sizeof(char), 16, fh) != 16 ||
fwrite(&surf.ylength_unit, sizeof(char), 16, fh) != 16 ||
fwrite(&surf.zlength_unit, sizeof(char), 16, fh) != 16 ||
fwrite(&surf.xunit_ratio, sizeof(gfloat), 1, fh) != 1 ||
fwrite(&surf.yunit_ratio, sizeof(gfloat), 1, fh) != 1 ||
fwrite(&surf.zunit_ratio, sizeof(gfloat), 1, fh) != 1 ||
fwrite(&surf.imprint, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.inversion, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.leveling, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.obsolete, sizeof(char), 12, fh) != 12 ||
fwrite(&surf.seconds, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.minutes, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.hours, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.day, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.month, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.year, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.dayof, sizeof(gint16),1,fh) != 1 ||
fwrite(&surf.measurement_duration, sizeof(gfloat), 1, fh) != 1 ||
fwrite(&surf.obsolete2, sizeof(char), 10, fh) != 10 ||
fwrite(&surf.comment_size, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.private_size, sizeof(gint16), 1, fh) != 1 ||
fwrite(&surf.client_zone, sizeof(char), 128, fh) != 128 ||
fwrite(&surf.XOffset, sizeof(gfloat), 1, fh) != 1 ||
fwrite(&surf.YOffset, sizeof(gfloat), 1, fh) != 1 ||
fwrite(&surf.ZOffset, sizeof(gfloat), 1, fh) != 1 ||
fwrite(&surf.reservedzone, sizeof(char), 34, fh)!= 34 ||
fwrite(integer_values, sizeof(gint32), surf.nofpoints, fh) != surf.nofpoints
) {
err_WRITE(error);
ok = FALSE;
g_unlink(filename);
}
g_free(integer_values);
fclose( fh );
return ok;
}
static GwyContainer*
amb_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gdouble *data;
guint i, j;
gsize size = 0;
GError *err = NULL;
guint xres, yres;
GwyDataField *dfield;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size <= HEADER_SIZE) {
err_TOO_SHORT(error);
goto fail;
}
/* The two bytes before are usually zeroes */
p = buffer + XRES_OFFSET;
xres = gwy_get_guint32_le(&p);
p = buffer + YRES_OFFSET;
yres = gwy_get_guint32_le(&p);
gwy_debug("xres: %u yres: %u", xres, yres);
/* The four bytes after might be a float, then there are four more bytes. */
if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres))
goto fail;
if (err_SIZE_MISMATCH(error, 4*xres*yres + HEADER_SIZE, size, TRUE))
goto fail;
dfield = gwy_data_field_new(xres, yres, 1.0, 1.0*yres/xres,
FALSE);
data = gwy_data_field_get_data(dfield);
p = buffer + HEADER_SIZE;
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++)
data[i*xres + j] = gwy_get_gfloat_le(&p);
}
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m");
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), "m");
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", dfield);
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Topography"));
g_object_unref(dfield);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
fail:
gwy_file_abandon_contents(buffer, size, NULL);
return container;
}
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 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 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 void
run_noninteractive(NoiseSynthArgs *args,
const GwyDimensionArgs *dimsargs,
GwyContainer *data,
GwyDataField *dfield,
gint oldid,
GQuark quark)
{
GwySIUnit *siunit;
gboolean replace = dimsargs->replace && dfield;
gboolean add = dimsargs->add && dfield;
gint newid;
if (args->randomize)
args->seed = g_random_int() & 0x7fffffff;
if (replace) {
/* Always take a reference so that we can always unref. */
g_object_ref(dfield);
gwy_app_undo_qcheckpointv(data, 1, &quark);
if (!add)
gwy_data_field_clear(dfield);
gwy_app_channel_log_add_proc(data, oldid, oldid);
}
else {
if (add)
dfield = gwy_data_field_duplicate(dfield);
else {
gdouble mag = pow10(dimsargs->xypow10) * dimsargs->measure;
dfield = gwy_data_field_new(dimsargs->xres, dimsargs->yres,
mag*dimsargs->xres, mag*dimsargs->yres,
TRUE);
siunit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string(siunit, dimsargs->xyunits);
siunit = gwy_data_field_get_si_unit_z(dfield);
gwy_si_unit_set_from_string(siunit, dimsargs->zunits);
}
}
noise_synth_do(args, dimsargs, dfield);
if (replace)
gwy_data_field_data_changed(dfield);
else {
if (data) {
newid = gwy_app_data_browser_add_data_field(dfield, data, TRUE);
if (oldid != -1)
gwy_app_sync_data_items(data, data, oldid, newid, FALSE,
GWY_DATA_ITEM_GRADIENT,
0);
}
else {
newid = 0;
data = gwy_container_new();
gwy_container_set_object(data, gwy_app_get_data_key_for_id(newid),
dfield);
gwy_app_data_browser_add(data);
gwy_app_data_browser_reset_visibility(data,
GWY_VISIBILITY_RESET_SHOW_ALL);
g_object_unref(data);
}
gwy_app_set_data_field_title(data, newid, _("Generated"));
gwy_app_channel_log_add_proc(data, add ? oldid : -1, newid);
}
g_object_unref(dfield);
}
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 void
cnew(G_GNUC_UNUSED GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield;
CNewArgs args;
gboolean ok;
gint oldid, i, j, k, n;
GwyCalibration *calibration;
GwyCalData *caldata = NULL, *old;
gchar *filename;
gchar *contents;
gsize len = 0;
GError *err = NULL;
gsize pos = 0;
GString *str;
gdouble *x, *y, *z, *xunc, *yunc, *zunc, *xerr, *yerr, *zerr;
FILE *fh;
g_return_if_fail(run & CNEW_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_ID, &oldid,
0);
g_return_if_fail(dfield);
cnew_load_args(gwy_app_settings_get(), &args);
if (run == GWY_RUN_INTERACTIVE) {
ok = cnew_dialog(&args, dfield);
cnew_save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
/*create the caldata*/
caldata = gwy_caldata_new(8);
x = gwy_caldata_get_x(caldata);
y = gwy_caldata_get_y(caldata);
z = gwy_caldata_get_z(caldata);
xerr = gwy_caldata_get_xerr(caldata);
yerr = gwy_caldata_get_yerr(caldata);
zerr = gwy_caldata_get_zerr(caldata);
xunc = gwy_caldata_get_xunc(caldata);
yunc = gwy_caldata_get_yunc(caldata);
zunc = gwy_caldata_get_zunc(caldata);
gwy_caldata_set_si_unit_x(caldata, gwy_data_field_get_si_unit_xy(dfield));
gwy_caldata_set_si_unit_y(caldata, gwy_data_field_get_si_unit_xy(dfield));
gwy_caldata_set_si_unit_z(caldata, gwy_data_field_get_si_unit_z(dfield));
n = 0;
for (i=0; i<2; i++)
{
for (j=0; j<2; j++)
{
for (k=0; k<2; k++)
{
if (i) x[n] = args.xrange_from;
else x[n] = args.xrange_to;
if (j) y[n] = args.yrange_from;
else y[n] = args.yrange_to;
if (k) z[n] = args.zrange_from;
else z[n] = args.zrange_to;
if (i) xerr[n] = (args.xrange_to-args.xrange_from)*(args.xmult-1);
else xerr[n] = 0;
if (j) yerr[n] = (args.yrange_to-args.yrange_from)*(args.ymult-1);
else yerr[n] = 0;
if (k) zerr[n] = (args.zrange_to-args.zrange_from)*(args.zmult-1);
else zerr[n] = 0;
xunc[n] = args.xunc;
yunc[n] = args.yunc;
zunc[n] = args.zunc;
n++;
}
}
}
if (args.duplicate == DUPLICATE_APPEND && (calibration = gwy_inventory_get_item(gwy_calibrations(), args.name)))
{
filename = g_build_filename(gwy_get_user_dir(), "caldata", calibration->filename, NULL);
if (!g_file_get_contents(filename,
&contents, &len, &err) || !len)
{
g_warning("Error loading file: %s", err->message);
g_clear_error(&err);
return;
}
else {
if (len)
old = GWY_CALDATA(gwy_serializable_deserialize(contents, len, &pos));
g_free(contents);
}
gwy_caldata_append(old, caldata);
g_object_unref(caldata);
caldata = old;
}
gwy_caldata_set_range(caldata, args.xrange_from, args.xrange_to,
args.yrange_from, args.yrange_to,
args.zrange_from, args.zrange_to);
//printf("Saving %g %g %g %g\n", args.xrange_from, args.xrange_to, args.yrange_from, args.yrange_to);
/*now create and save the resource*/
if ((calibration = GWY_CALIBRATION(gwy_inventory_get_item(gwy_calibrations(), args.name)))==NULL)
{
calibration = gwy_calibration_new(args.name, g_strconcat(args.name, ".dat", NULL));
gwy_inventory_insert_item(gwy_calibrations(), calibration);
g_object_unref(calibration);
}
calibration->caldata = caldata;
filename = gwy_resource_build_filename(GWY_RESOURCE(calibration));
if (!g_file_test(filename, G_FILE_TEST_EXISTS)) {
g_mkdir(g_build_filename(gwy_get_user_dir(), "calibrations", NULL), 0700);
}
fh = gwy_fopen(filename, "wb");
if (!fh) {
g_warning(_("Cannot save preset: %s"), filename);
g_free(filename);
return;
}
g_free(filename);
str = gwy_resource_dump(GWY_RESOURCE(calibration));
fwrite(str->str, 1, str->len, fh);
fclose(fh);
g_string_free(str, TRUE);
gwy_resource_data_saved(GWY_RESOURCE(calibration));
gwy_resource_data_changed(GWY_RESOURCE(calibration));
/*now save the calibration data*/
//gwy_caldata_debug(caldata, "Saving: ");
gwy_caldata_save_data(caldata, calibration->filename);
}
