static void
gwy_data_field_absdiff_line_correct(GwyDataField *dfield)
{
MedianLineData mldata;
gint xres, yres, i, j;
gdouble shift, csum, mindiff, maxdiff, x;
gdouble *d;
yres = gwy_data_field_get_yres(dfield);
xres = gwy_data_field_get_xres(dfield);
d = gwy_data_field_get_data(dfield);
csum = 0.0;
mldata.n = xres;
for (i = 1; i < yres; i++) {
mldata.a = d + xres*(i - 1);
mldata.b = d + xres*i;
mindiff = G_MAXDOUBLE;
maxdiff = -G_MAXDOUBLE;
for (j = 0; j < xres; j++) {
x = mldata.b[j] - mldata.a[j];
if (x < mindiff)
mindiff = x;
if (x > maxdiff)
maxdiff = x;
}
shift = find_minima_golden(sum_of_abs_diff, mindiff, maxdiff, &mldata);
gwy_data_field_area_add(dfield, 0, i, xres, 1, -shift);
csum -= shift;
}
gwy_data_field_add(dfield, -csum/(xres*yres));
}
static void
dwt(GwyContainer *data, GwyRunType run)
{
GtkWidget *dialog;
GwyDataField *dfield;
GwyDataLine *wtcoefs;
DWTArgs args;
gboolean ok;
gint xsize, ysize, newsize, newid, oldid, i;
g_return_if_fail(run & DWT_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);
xsize = gwy_data_field_get_xres(dfield);
ysize = gwy_data_field_get_yres(dfield);
if (xsize != ysize) {
dialog = gtk_message_dialog_new
(gwy_app_find_window_for_channel(data, oldid),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("%s: Data must be square."), "DWT");
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return;
}
for (newsize = 1, i = xsize-1; i; i >>= 1, newsize <<= 1)
;
dwt_load_args(gwy_app_settings_get(), &args);
if (run == GWY_RUN_INTERACTIVE) {
ok = dwt_dialog(&args, xsize, newsize);
dwt_save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
dfield = gwy_data_field_new_resampled(dfield, newsize, newsize,
args.interp);
gwy_data_field_add(dfield, -gwy_data_field_get_avg(dfield));
wtcoefs = GWY_DATA_LINE(gwy_data_line_new(10, 10, TRUE));
wtcoefs = gwy_dwt_set_coefficients(wtcoefs, args.wavelet);
gwy_data_field_dwt(dfield, wtcoefs, 1, 4);
newid = gwy_app_data_browser_add_data_field(dfield, data, TRUE);
g_object_unref(dfield);
gwy_app_set_data_field_title(data, newid, _("DWT"));
gwy_app_sync_data_items(data, data, oldid, newid, FALSE,
GWY_DATA_ITEM_PALETTE, 0);
g_object_unref(wtcoefs);
}
static void
fix_scales(EZDSection *section,
gint idx,
GwyContainer *container)
{
GwyDataField *dfield;
GwySIUnit *siunit;
gchar key[40];
gint power10;
gdouble r;
g_snprintf(key, sizeof(key), "/%d/data", idx);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(container, key));
/* Fix value scale */
siunit = gwy_si_unit_new_parse(section->zrange.unit, &power10);
gwy_data_field_set_si_unit_z(dfield, siunit);
g_object_unref(siunit);
r = pow10(power10);
gwy_data_field_multiply(dfield, r*section->zrange.range);
gwy_data_field_add(dfield, r*section->zrange.min);
/* Fix lateral scale */
siunit = gwy_si_unit_new_parse(section->xrange.unit, &power10);
gwy_data_field_set_si_unit_xy(dfield, siunit);
g_object_unref(siunit);
gwy_data_field_set_xreal(dfield, pow10(power10)*section->xrange.range);
siunit = gwy_si_unit_new_parse(section->yrange.unit, &power10);
gwy_data_field_set_yreal(dfield, pow10(power10)*section->yrange.range);
g_object_unref(siunit);
/* Some metadata */
if (section->zrange.name) {
const gchar *s;
switch (section->direction) {
case SCAN_FORWARD:
s = " forward";
break;
case SCAN_BACKWARD:
s = " backward";
break;
default:
s = "";
break;
}
g_snprintf(key, sizeof(key), "/%d/data/title", idx);
gwy_container_set_string_by_name(container, key,
g_strdup_printf("%s%s",
section->zrange.name,
s));
}
}
/**
* gwy_tip_estimate_partial:
* @tip: Tip data to be refined (allocated).
* @surface: Surface data.
* @threshold: Threshold for noise supression.
* @use_edges: Whether use also edges of image.
* @count: Where to store the number of places that produced refinements to.
* @set_fraction: Function that sets fraction to output (or %NULL).
* @set_message: Function that sets message to output (or %NULL).
*
* Performs partial blind estimation algorithm published by Villarrubia. This
* function converts all fields into form requested by "morph_lib.c" library,
* that is almost identical with original Villarubia's library. Note that the
* threshold value must be chosen sufficently high value to supress small
* fluctulations due to noise (that would lead to very sharp tip) but
* sufficiently low value to put algorithm at work. A value similar to 1/10000
* of surface range can be good. Otherwise we recommend to start with zero
* threshold and increase it slowly to observe changes and choose right value.
*
* Returns: Estimated tip. May return %NULL if aborted.
**/
GwyDataField*
gwy_tip_estimate_partial(GwyDataField *tip,
GwyDataField *surface,
gdouble threshold,
gboolean use_edges,
gint *count,
GwySetFractionFunc set_fraction,
GwySetMessageFunc set_message)
{
gint **ftip;
gint **fsurface;
gdouble tipmin, surfacemin, step;
gint cnt;
if (set_message && !set_message(N_("Converting fields")))
return NULL;
tipmin = gwy_data_field_get_min(tip);
surfacemin = gwy_data_field_get_min(surface);
step = (gwy_data_field_get_max(surface)-surfacemin)/10000;
ftip = i_datafield_to_field(tip, TRUE, tipmin, step);
fsurface = i_datafield_to_field(surface, FALSE, surfacemin, step);
if (set_message && !set_message(N_("Starting partial estimation"))) {
_gwy_morph_lib_ifreematrix(ftip, tip->xres);
_gwy_morph_lib_ifreematrix(fsurface, surface->xres);
return NULL;
}
cnt = _gwy_morph_lib_itip_estimate0(fsurface, surface->yres, surface->xres,
tip->yres, tip->xres,
tip->yres/2, tip->xres/2,
ftip, threshold/step, use_edges,
set_fraction, set_message);
if (cnt == -1 || (set_fraction && !set_fraction(0.0))) {
_gwy_morph_lib_ifreematrix(ftip, tip->xres);
_gwy_morph_lib_ifreematrix(fsurface, surface->xres);
return NULL;
}
gwy_debug("Converting fields");
if (set_message)
set_message(N_("Converting fields"));
tip = i_field_to_datafield(ftip, tip, tipmin, step);
gwy_data_field_add(tip, -gwy_data_field_get_min(tip));
_gwy_morph_lib_ifreematrix(ftip, tip->xres);
_gwy_morph_lib_ifreematrix(fsurface, surface->xres);
if (count)
*count = cnt;
return tip;
}
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
zero_mean(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield;
GQuark quark;
g_return_if_fail(run & LEVEL_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD_KEY, &quark,
GWY_APP_DATA_FIELD, &dfield,
0);
g_return_if_fail(dfield && quark);
gwy_app_undo_qcheckpoint(data, quark, NULL);
gwy_data_field_add(dfield, -gwy_data_field_get_avg(dfield));
gwy_data_field_data_changed(dfield);
}
static void
fix_zero(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield;
GQuark quark;
gint id;
g_return_if_fail(run & LEVEL_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD_KEY, &quark,
GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield && quark);
gwy_app_undo_qcheckpoint(data, quark, NULL);
gwy_data_field_add(dfield, -gwy_data_field_get_min(dfield));
gwy_app_channel_log_add_proc(data, id, id);
gwy_data_field_data_changed(dfield);
}
static void
line_correct_match(GwyContainer *data,
GwyRunType run)
{
GwyDataField *dfield;
GwyDataLine *shifts;
gint xres, yres, i;
gdouble *d, *s;
GQuark dquark;
g_return_if_fail(run & LINECORR_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_KEY, &dquark,
0);
g_return_if_fail(dfield && dquark);
gwy_app_undo_qcheckpointv(data, 1, &dquark);
yres = gwy_data_field_get_yres(dfield);
xres = gwy_data_field_get_xres(dfield);
d = gwy_data_field_get_data(dfield);
shifts = gwy_data_line_new(yres, 1.0, TRUE);
s = gwy_data_line_get_data(shifts);
s[0] = 0.0;
for (i = 1; i < yres; i++) {
s[i] = find_shift(xres, d + i*xres, d + (i - 1)*xres);
g_printerr("%d %g\n", i, s[i]);
}
gwy_data_line_cumulate(shifts);
for (i = 1; i < yres; i++)
gwy_data_field_area_add(dfield, 0, i, xres, 1, s[i]);
gwy_data_field_add(dfield, -s[yres-1]/(xres*yres));
g_object_unref(shifts);
gwy_data_field_data_changed(dfield);
}
static GwyContainer*
surffile_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
SurfFile surffile;
GwyContainer *meta, *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize expected_size, size = 0;
GError *err = NULL;
gchar signature[12];
gdouble max, min;
gint add = 0;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
g_clear_error(&err);
return NULL;
}
if (size < SURF_HEADER_SIZE + 2) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
p = buffer;
get_CHARARRAY(signature, &p);
if (strncmp(signature, "DIGITAL SURF", 12) != 0) {
err_FILE_TYPE(error, "Surf");
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
surffile.format = gwy_get_guint16_le(&p);
surffile.nobjects = gwy_get_guint16_le(&p);
surffile.version = gwy_get_guint16_le(&p);
surffile.type = gwy_get_guint16_le(&p);
get_CHARS0(surffile.object_name, &p, 30);
get_CHARS0(surffile.operator_name, &p, 30);
surffile.material_code = gwy_get_guint16_le(&p);
surffile.acquisition = gwy_get_guint16_le(&p);
surffile.range = gwy_get_guint16_le(&p);
surffile.special_points = gwy_get_guint16_le(&p);
surffile.absolute = gwy_get_guint16_le(&p);
/*reserved*/
p += 8;
surffile.pointsize = gwy_get_guint16_le(&p);
surffile.zmin = gwy_get_gint32_le(&p);
surffile.zmax = gwy_get_gint32_le(&p);
surffile.xres = gwy_get_gint32_le(&p);
surffile.yres = gwy_get_gint32_le(&p);
surffile.nofpoints = gwy_get_guint32_le(&p);
surffile.dx = gwy_get_gfloat_le(&p);
surffile.dy = gwy_get_gfloat_le(&p);
surffile.dz = gwy_get_gfloat_le(&p);
get_CHARS0(surffile.xaxis, &p, 16);
get_CHARS0(surffile.yaxis, &p, 16);
get_CHARS0(surffile.zaxis, &p, 16);
get_CHARS0(surffile.dx_unit, &p, 16);
get_CHARS0(surffile.dy_unit, &p, 16);
get_CHARS0(surffile.dz_unit, &p, 16);
get_CHARS0(surffile.xlength_unit, &p, 16);
get_CHARS0(surffile.ylength_unit, &p, 16);
get_CHARS0(surffile.zlength_unit, &p, 16);
surffile.xunit_ratio = gwy_get_gfloat_le(&p);
surffile.yunit_ratio = gwy_get_gfloat_le(&p);
surffile.zunit_ratio = gwy_get_gfloat_le(&p);
surffile.imprint = gwy_get_guint16_le(&p);
surffile.inversion = gwy_get_guint16_le(&p);
surffile.leveling = gwy_get_guint16_le(&p);
p += 12;
surffile.seconds = gwy_get_guint16_le(&p);
surffile.minutes = gwy_get_guint16_le(&p);
surffile.hours = gwy_get_guint16_le(&p);
surffile.day = gwy_get_guint16_le(&p);
surffile.month = gwy_get_guint16_le(&p);
surffile.year = gwy_get_guint16_le(&p);
surffile.measurement_duration = gwy_get_guint16_le(&p);
surffile.comment_size = gwy_get_guint16_le(&p);
surffile.private_size = gwy_get_guint16_le(&p);
get_CHARARRAY(surffile.client_zone, &p);
surffile.XOffset = gwy_get_gfloat_le(&p);
surffile.YOffset = gwy_get_gfloat_le(&p);
surffile.ZOffset = gwy_get_gfloat_le(&p);
gwy_debug("fileformat: %d, n_of_objects: %d, "
"version: %d, object_type: %d",
surffile.format, surffile.nobjects,
surffile.version, surffile.type);
gwy_debug("object name: <%s>", surffile.object_name);
gwy_debug("operator name: <%s>", surffile.operator_name);
gwy_debug("material code: %d, acquisition type: %d",
surffile.material_code, surffile.acquisition);
gwy_debug("range type: %d, special points: %d, absolute: %d",
surffile.range,
surffile.special_points, (gint)surffile.absolute);
gwy_debug("data point size: %d", surffile.pointsize);
gwy_debug("zmin: %d, zmax: %d", surffile.zmin, surffile.zmax);
gwy_debug("xres: %d, yres: %d (xres*yres = %d)",
surffile.xres, surffile.yres, (surffile.xres*surffile.yres));
gwy_debug("total number of points: %d", surffile.nofpoints);
gwy_debug("dx: %g, dy: %g, dz: %g",
surffile.dx, surffile.dy, surffile.dz);
gwy_debug("X axis name: %16s", surffile.xaxis);
gwy_debug("Y axis name: %16s", surffile.yaxis);
gwy_debug("Z axis name: %16s", surffile.zaxis);
gwy_debug("dx unit: %16s", surffile.dx_unit);
gwy_debug("dy unit: %16s", surffile.dy_unit);
gwy_debug("dz unit: %16s", surffile.dz_unit);
gwy_debug("X axis unit: %16s", surffile.xlength_unit);
gwy_debug("Y axis unit: %16s", surffile.ylength_unit);
gwy_debug("Z axis unit: %16s", surffile.zlength_unit);
gwy_debug("xunit_ratio: %g, yunit_ratio: %g, zunit_ratio: %g",
surffile.xunit_ratio, surffile.yunit_ratio, surffile.zunit_ratio);
gwy_debug("imprint: %d, inversion: %d, leveling: %d",
surffile.imprint, surffile.inversion, surffile.leveling);
gwy_debug("Time: %d:%d:%d, Date: %d.%d.%d",
surffile.hours, surffile.minutes, surffile.seconds,
surffile.day, surffile.month, surffile.year);
gwy_debug("private zone size: %d, comment size %d",
surffile.private_size, surffile.comment_size);
expected_size = (SURF_HEADER_SIZE
+ surffile.pointsize/8*surffile.xres*surffile.yres);
if (expected_size != size) {
gwy_debug("Size mismatch!");
if (size > expected_size) add = size - expected_size; /*TODO correct this !*/
else {
err_SIZE_MISMATCH(error, expected_size, size);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
}
p = buffer + SURF_HEADER_SIZE + add;
if (!fill_data_fields(&surffile, p, error)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
if (!surffile.absolute) {
max = gwy_data_field_get_max(surffile.dfield);
min = gwy_data_field_get_min(surffile.dfield);
gwy_data_field_add(surffile.dfield, -min);
gwy_data_field_multiply(surffile.dfield,
(surffile.zmax - surffile.zmin)/(max-min));
}
switch (surffile.inversion) {
case SURF_INV_Z:
gwy_data_field_invert(surffile.dfield, FALSE, FALSE, TRUE);
break;
case SURF_FLIP_Z:
gwy_data_field_invert(surffile.dfield, FALSE, TRUE, TRUE);
break;
case SURF_FLOP_Z:
gwy_data_field_invert(surffile.dfield, TRUE, FALSE, TRUE);
break;
default:
break;
}
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", surffile.dfield);
g_object_unref(surffile.dfield);
meta = surffile_get_metadata(&surffile);
gwy_container_set_object_by_name(container, "/0/meta", meta);
g_object_unref(meta);
gwy_app_channel_check_nonsquare(container, 0);
return container;
}
static GwyContainer*
surffile_load(const gchar *filename)
{
SurfFile surffile;
GObject *object = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize size = 0;
gsize estsize;
GError *err = NULL;
gchar signature[12];
gdouble max, min;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
g_warning("Cannot read file %s", filename);
g_clear_error(&err);
return NULL;
}
p = buffer;
get_CHARARRAY(signature, &p);
if (strncmp(signature, "DIGITAL SURF", 12) != 0) {
g_warning("File %s is not a Surf file", filename);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
if (size < 500) {
g_warning("File %s is too short to be Surf file", filename);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
surffile.format = get_WORD_LE(&p);
surffile.nobjects = get_WORD_LE(&p);
surffile.version = get_WORD_LE(&p);
surffile.type = get_WORD_LE(&p);
get_CHARS0(surffile.object_name, &p, 30);
get_CHARS0(surffile.operator_name, &p, 30);
surffile.material_code = get_WORD_LE(&p);
surffile.acquisition = get_WORD_LE(&p);
surffile.range = get_WORD_LE(&p);
surffile.special_points = get_WORD_LE(&p);
surffile.absolute = get_WORD_LE(&p);
/*reserved*/
p += 8;
surffile.pointsize = get_WORD_LE(&p);
surffile.zmin = get_DWORD(&p);
surffile.zmax = get_DWORD(&p);
surffile.xres = get_DWORD(&p);
surffile.yres = get_DWORD(&p);
surffile.nofpoints = get_DWORD(&p);
//surffile.xres = 200; surffile.yres = 200;
surffile.dx = get_FLOAT_LE(&p);
surffile.dy = get_FLOAT_LE(&p);
surffile.dz = get_FLOAT_LE(&p);
get_CHARS0(surffile.xaxis, &p, 16);
get_CHARS0(surffile.yaxis, &p, 16);
get_CHARS0(surffile.zaxis, &p, 16);
get_CHARS0(surffile.dx_unit, &p, 16);
get_CHARS0(surffile.dy_unit, &p, 16);
get_CHARS0(surffile.dz_unit, &p, 16);
get_CHARS0(surffile.xlength_unit, &p, 16);
get_CHARS0(surffile.ylength_unit, &p, 16);
get_CHARS0(surffile.zlength_unit, &p, 16);
surffile.xunit_ratio = get_FLOAT_LE(&p);
surffile.yunit_ratio = get_FLOAT_LE(&p);
surffile.zunit_ratio = get_FLOAT_LE(&p);
surffile.imprint = get_WORD_LE(&p);
surffile.inversion = get_WORD_LE(&p);
surffile.leveling = get_WORD_LE(&p);
p += 12;
surffile.seconds = get_WORD_LE(&p);
surffile.minutes = get_WORD_LE(&p);
surffile.hours = get_WORD_LE(&p);
surffile.day = get_WORD_LE(&p);
surffile.month = get_WORD_LE(&p);
surffile.year = get_WORD_LE(&p);
surffile.measurement_duration = get_WORD_LE(&p);
surffile.comment_size = get_WORD_LE(&p);
surffile.private_size = get_WORD_LE(&p);
get_CHARARRAY(surffile.client_zone, &p);
surffile.XOffset = get_FLOAT_LE(&p);
surffile.YOffset = get_FLOAT_LE(&p);
surffile.ZOffset = get_FLOAT_LE(&p);
gwy_debug("fileformat: %d, n_of_objects: %d, version: %d, object_type: %d",
surffile.format, surffile.nobjects, surffile.version, surffile.type);
gwy_debug("object name: %s", surffile.object_name);
gwy_debug("operator name: %s", surffile.operator_name);
gwy_debug("material code: %d, acquisition type: %d", surffile.material_code, surffile.acquisition);
gwy_debug("range type: %d, special points: %d, absolute: %d", surffile.range,
surffile.special_points, (gint)surffile.absolute);
gwy_debug("data point size: %d", surffile.pointsize);
gwy_debug("zmin: %d, zmax: %d", surffile.zmin, surffile.zmax);
gwy_debug("xres: %d, yres: %d (xres*yres = %d)", surffile.xres, surffile.yres, (surffile.xres*surffile.yres));
gwy_debug("total number of points: %d", surffile.nofpoints);
gwy_debug("dx: %g, dy: %g, dz: %g", surffile.dx, surffile.dy, surffile.dz);
gwy_debug("X axis name: %16s", surffile.xaxis);
gwy_debug("Y axis name: %16s", surffile.yaxis);
gwy_debug("Z axis name: %16s", surffile.zaxis);
gwy_debug("dx unit: %16s", surffile.dx_unit);
gwy_debug("dy unit: %16s", surffile.dy_unit);
gwy_debug("dz unit: %16s", surffile.dz_unit);
gwy_debug("X axis unit: %16s", surffile.xlength_unit);
gwy_debug("Y axis unit: %16s", surffile.ylength_unit);
gwy_debug("Z axis unit: %16s", surffile.zlength_unit);
gwy_debug("xunit_ratio: %g, yunit_ratio: %g, zunit_ratio: %g", surffile.xunit_ratio, surffile.yunit_ratio, surffile.zunit_ratio);
gwy_debug("imprint: %d, inversion: %d, leveling: %d", surffile.imprint, surffile.inversion, surffile.leveling);
gwy_debug("Time: %d:%d:%d, Date: %d.%d.%d", surffile.hours, surffile.minutes, surffile.seconds,
surffile.day, surffile.month, surffile.year);
p = buffer + 512;
estsize = 512 + surffile.pointsize*surffile.xres*surffile.yres/8;
if (size < estsize) {
g_warning("File %s is too short to contain Surf data %d %d", filename, (int)size, (int)estsize);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
fill_data_fields(&surffile, p);
gwy_file_abandon_contents(buffer, size, NULL);
if (surffile.absolute == 0)
{
max = gwy_data_field_get_max(surffile.dfield);
min = gwy_data_field_get_min(surffile.dfield);
gwy_data_field_add(surffile.dfield, -min);
gwy_data_field_multiply(surffile.dfield,
(surffile.zmax - surffile.zmin)/(max-min));
}
if (surffile.inversion == 1)
gwy_data_field_invert(surffile.dfield, FALSE, FALSE, TRUE);
if (surffile.inversion == 2)
gwy_data_field_invert(surffile.dfield, FALSE, TRUE, TRUE);
if (surffile.inversion == 3)
gwy_data_field_invert(surffile.dfield, TRUE, FALSE, TRUE);
if (surffile.dfield) {
object = gwy_container_new();
gwy_container_set_object_by_name(GWY_CONTAINER(object), "/0/data",
G_OBJECT(surffile.dfield));
store_metadata(&surffile, GWY_CONTAINER(object));
}
return (GwyContainer*)object;
return NULL;
}
static void
dwt_anisotropy(GwyContainer *data, GwyRunType run)
{
GtkWidget *dialog;
GwyDataField *dfield, *mask;
GQuark dquark, mquark;
GwyDataLine *wtcoefs;
DWTAnisotropyArgs args;
gboolean ok;
gint xsize, ysize, newsize, limit, id, i;
g_return_if_fail(run & DWT_ANISOTROPY_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD_KEY, &dquark,
GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_ID, &id,
GWY_APP_MASK_FIELD_KEY, &mquark,
GWY_APP_MASK_FIELD, &mask,
0);
g_return_if_fail(dfield && dquark);
xsize = gwy_data_field_get_xres(dfield);
ysize = gwy_data_field_get_yres(dfield);
if (xsize != ysize) {
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: Data must be square."), _("DWT Anisotropy"));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return;
}
dwt_anisotropy_load_args(gwy_app_settings_get(), &args);
if (run == GWY_RUN_INTERACTIVE) {
ok = dwt_anisotropy_dialog(&args);
dwt_anisotropy_save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
for (newsize = 1, i = xsize-1; i; i >>= 1, newsize <<= 1)
;
dfield = gwy_data_field_new_resampled(dfield, newsize, newsize,
args.interp);
gwy_data_field_add(dfield, -gwy_data_field_get_avg(dfield));
gwy_app_undo_qcheckpoint(data, dquark, mquark, 0);
if (!mask) {
mask = gwy_data_field_new_alike(dfield, FALSE);
gwy_container_set_object(data, mquark, mask);
g_object_unref(mask);
}
gwy_data_field_resample(mask, newsize, newsize, GWY_INTERPOLATION_NONE);
wtcoefs = gwy_data_line_new(10, 10, TRUE);
wtcoefs = gwy_dwt_set_coefficients(wtcoefs, args.wavelet);
/*justo for sure clamp the lowlimit again*/
limit = pow(2, CLAMP(args.lowlimit, 1, 20));
gwy_data_field_dwt_mark_anisotropy(dfield, mask, wtcoefs, args.ratio,
limit);
gwy_data_field_resample(mask, xsize, ysize, GWY_INTERPOLATION_ROUND);
g_object_unref(wtcoefs);
g_object_unref(dfield);
gwy_data_field_data_changed(mask);
gwy_app_channel_log_add_proc(data, id, id);
}
static void
immerse_do(ImmerseArgs *args)
{
GwyDataField *resampled, *image, *detail, *result;
GwyContainer *data;
gint newid;
gint kxres, kyres;
gint x, y, w, h;
gdouble iavg, davg;
GQuark quark;
data = gwy_app_data_browser_get(args->image.datano);
quark = gwy_app_get_data_key_for_id(args->image.id);
image = GWY_DATA_FIELD(gwy_container_get_object(data, quark));
data = gwy_app_data_browser_get(args->detail.datano);
quark = gwy_app_get_data_key_for_id(args->detail.id);
detail = GWY_DATA_FIELD(gwy_container_get_object(data, quark));
davg = gwy_data_field_get_avg(detail);
kxres = gwy_data_field_get_xres(detail);
kyres = gwy_data_field_get_yres(detail);
switch (args->sampling) {
case GWY_IMMERSE_SAMPLING_DOWN:
result = gwy_data_field_duplicate(image);
x = gwy_data_field_rtoj(image, args->xpos);
y = gwy_data_field_rtoi(image, args->ypos);
w = GWY_ROUND(gwy_data_field_get_xreal(detail)
/gwy_data_field_get_xmeasure(image));
h = GWY_ROUND(gwy_data_field_get_yreal(detail)
/gwy_data_field_get_ymeasure(image));
w = MAX(w, 1);
h = MAX(h, 1);
gwy_debug("w: %d, h: %d", w, h);
resampled = gwy_data_field_new_resampled(detail, w, h,
GWY_INTERPOLATION_LINEAR);
if (args->leveling == GWY_IMMERSE_LEVEL_MEAN) {
iavg = gwy_data_field_area_get_avg(result, NULL, x, y, w, h);
gwy_data_field_add(resampled, iavg - davg);
}
gwy_data_field_area_copy(resampled, result, 0, 0, w, h, x, y);
g_object_unref(resampled);
break;
case GWY_IMMERSE_SAMPLING_UP:
w = GWY_ROUND(gwy_data_field_get_xreal(image)
/gwy_data_field_get_xmeasure(detail));
h = GWY_ROUND(gwy_data_field_get_yreal(image)
/gwy_data_field_get_ymeasure(detail));
gwy_debug("w: %d, h: %d", w, h);
result = gwy_data_field_new_resampled(image, w, h,
GWY_INTERPOLATION_LINEAR);
x = gwy_data_field_rtoj(result, args->xpos);
y = gwy_data_field_rtoi(result, args->ypos);
if (args->leveling == GWY_IMMERSE_LEVEL_MEAN) {
iavg = gwy_data_field_area_get_avg(result, NULL,
x, y, kxres, kyres);
gwy_data_field_area_copy(detail, result, 0, 0, kxres, kyres, x, y);
gwy_data_field_area_add(result, x, y, kxres, kyres, iavg - davg);
}
else
gwy_data_field_area_copy(detail, result, 0, 0, kxres, kyres, x, y);
break;
default:
g_return_if_reached();
break;
}
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, _("Immersed detail"));
g_object_unref(result);
gwy_app_channel_log_add_proc(data, args->image.id, newid);
}
static GwyDataField*
unisoku_read_data_field(const guchar *buffer,
gsize size,
UnisokuFile *ufile,
GError **error)
{
gint i, n, power10;
const gchar *unit;
GwyDataField *dfield;
GwySIUnit *siunit;
gdouble q, pmin, pmax, rmin, rmax;
gdouble *data;
n = ufile->xres * ufile->yres;
if (err_SIZE_MISMATCH(error, n*type_sizes[ufile->data_type], size, FALSE))
return NULL;
dfield = gwy_data_field_new(ufile->xres, ufile->yres,
fabs((ufile->end_x - ufile->start_x)),
fabs((ufile->end_y - ufile->start_y)),
FALSE);
data = gwy_data_field_get_data(dfield);
/* FIXME: what to do when ascii_flag is set? */
switch (ufile->data_type) {
case UNISOKU_UINT8:
for (i = 0; i < n; i++)
data[i] = buffer[i];
break;
case UNISOKU_SINT8:
for (i = 0; i < n; i++)
data[i] = (signed char)buffer[i];
break;
case UNISOKU_UINT16:
{
const guint16 *pdata = (const guint16*)buffer;
for (i = 0; i < n; i++)
data[i] = GUINT16_FROM_LE(pdata[i]);
}
break;
case UNISOKU_SINT16:
{
const gint16 *pdata = (const gint16*)buffer;
for (i = 0; i < n; i++)
data[i] = GINT16_FROM_LE(pdata[i]);
}
break;
case UNISOKU_FLOAT:
for (i = 0; i < n; i++)
data[i] = gwy_get_gfloat_le(&buffer);
break;
default:
g_return_val_if_reached(NULL);
break;
}
unit = ufile->unit_x;
if (!*unit)
unit = "nm";
siunit = gwy_si_unit_new_parse(unit, &power10);
gwy_data_field_set_si_unit_xy(dfield, siunit);
q = pow10((gdouble)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));
g_object_unref(siunit);
unit = ufile->unit_z;
/* XXX: No fallback yet, just make z unitless */
siunit = gwy_si_unit_new_parse(unit, &power10);
gwy_data_field_set_si_unit_z(dfield, siunit);
q = pow10((gdouble)power10);
pmin = q*ufile->min_z;
pmax = q*ufile->max_z;
rmin = ufile->min_raw_z;
rmax = ufile->max_raw_z;
gwy_data_field_multiply(dfield, (pmax - pmin)/(rmax - rmin));
gwy_data_field_add(dfield, (pmin*rmax - pmax*rmin)/(rmax - rmin));
g_object_unref(siunit);
return dfield;
}
static void
line_correct_match(GwyContainer *data,
GwyRunType run)
{
GwyDataField *dfield;
GwyDataLine *shifts;
gint xres, yres, i, j;
gdouble m, wsum, lambda, x;
gdouble *d, *s, *w;
const gdouble *a, *b;
GQuark dquark;
g_return_if_fail(run & LINECORR_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_KEY, &dquark,
0);
g_return_if_fail(dfield && dquark);
gwy_app_undo_qcheckpointv(data, 1, &dquark);
yres = gwy_data_field_get_yres(dfield);
xres = gwy_data_field_get_xres(dfield);
d = gwy_data_field_get_data(dfield);
shifts = gwy_data_line_new(yres, 1.0, TRUE);
s = gwy_data_line_get_data(shifts);
w = g_new(gdouble, xres-1);
for (i = 1; i < yres; i++) {
a = d + xres*(i - 1);
b = d + xres*i;
/* Diffnorm */
wsum = 0.0;
for (j = 0; j < xres-1; j++) {
x = a[j+1] - a[j] - b[j+1] + b[j];
wsum += fabs(x);
}
if (wsum == 0)
continue;
m = wsum/(xres-1);
/* Weights */
wsum = 0.0;
for (j = 0; j < xres-1; j++) {
x = a[j+1] - a[j] - b[j+1] + b[j];
w[j] = exp(-(x*x/(2.0*m)));
wsum += w[j];
}
/* Correction */
lambda = (a[0] - b[0])*w[0];
for (j = 1; j < xres-1; j++)
lambda += (a[j] - b[j])*(w[j-1] + w[j]);
lambda += (a[xres-1] - b[xres-1])*w[xres-2];
lambda /= 2.0*wsum;
gwy_debug("%g %g %g", m, wsum, lambda);
s[i] = lambda;
}
gwy_data_line_cumulate(shifts);
for (i = 1; i < yres; i++)
gwy_data_field_area_add(dfield, 0, i, xres, 1, s[i]);
gwy_data_field_add(dfield, -s[yres-1]/(xres*yres));
g_object_unref(shifts);
g_free(w);
gwy_data_field_data_changed(dfield);
}
static void
dwt_denoise(GwyContainer *data, GwyRunType run)
{
GtkWidget *dialog;
GwyDataField *dfield;
GwyDataLine *wtcoefs;
DWTDenoiseArgs args;
gboolean ok;
gint xsize, ysize, newsize;
gint oldid, newid;
g_return_if_fail(run & DWT_DENOISE_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);
xsize = gwy_data_field_get_xres(dfield);
ysize = gwy_data_field_get_yres(dfield);
if (xsize != ysize) {
dialog = gtk_message_dialog_new
(GTK_WINDOW(gwy_app_data_window_get_current()),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("%s: Data must be square."), _("DWT Denoise"));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return;
}
dwt_denoise_load_args(gwy_app_settings_get(), &args);
if (run == GWY_RUN_INTERACTIVE) {
ok = dwt_denoise_dialog(&args);
dwt_denoise_save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
dfield = gwy_data_field_duplicate(dfield);
newsize = gwy_fft_find_nice_size(xsize);
gwy_data_field_add(dfield, -gwy_data_field_get_avg(dfield));
gwy_data_field_resample(dfield, newsize, newsize,
GWY_INTERPOLATION_BILINEAR);
wtcoefs = gwy_data_line_new(10, 10, TRUE);
wtcoefs = gwy_dwt_set_coefficients(wtcoefs, args.wavelet);
gwy_data_field_dwt_denoise(dfield, wtcoefs, TRUE, 20, args.method);
if (args.preserve)
gwy_data_field_resample(dfield, xsize, ysize, args.interp);
newid = gwy_app_data_browser_add_data_field(dfield, data, TRUE);
gwy_app_copy_data_items(data, data, oldid, newid,
GWY_DATA_ITEM_GRADIENT,
GWY_DATA_ITEM_MASK_COLOR,
0);
g_object_unref(dfield);
gwy_app_set_data_field_title(data, newid, _("DWT denoised"));
g_object_unref(wtcoefs);
}
static void
do_level(GwyContainer *data,
GwyRunType run,
LevelMethod level_type,
const gchar *dialog_title)
{
GwyDataField *dfield;
GwyDataField *mfield;
LevelArgs args;
gdouble c, bx, by;
GQuark quark;
gint id;
g_return_if_fail(run & LEVEL_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD_KEY, &quark,
GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_ID, &id,
GWY_APP_MASK_FIELD, &mfield,
0);
g_return_if_fail(dfield && quark);
load_args(gwy_app_settings_get(), &args);
if (run != GWY_RUN_IMMEDIATE && mfield) {
gboolean ok = level_dialog(&args, dialog_title);
save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
if (args.masking == GWY_MASK_IGNORE)
mfield = NULL;
if (mfield) {
if (args.masking == GWY_MASK_EXCLUDE) {
mfield = gwy_data_field_duplicate(mfield);
gwy_data_field_multiply(mfield, -1.0);
gwy_data_field_add(mfield, 1.0);
}
else
g_object_ref(mfield);
}
gwy_app_undo_qcheckpoint(data, quark, NULL);
if (mfield)
gwy_data_field_area_fit_plane(dfield, mfield, 0, 0,
gwy_data_field_get_xres(dfield),
gwy_data_field_get_yres(dfield),
&c, &bx, &by);
else
gwy_data_field_fit_plane(dfield, &c, &bx, &by);
switch (level_type) {
case LEVEL_SUBTRACT:
c = -0.5*(bx*gwy_data_field_get_xres(dfield)
+ by*gwy_data_field_get_yres(dfield));
gwy_data_field_plane_level(dfield, c, bx, by);
break;
case LEVEL_ROTATE:
bx = gwy_data_field_rtoj(dfield, bx);
by = gwy_data_field_rtoi(dfield, by);
gwy_data_field_plane_rotate(dfield, atan2(bx, 1), atan2(by, 1),
GWY_INTERPOLATION_LINEAR);
gwy_debug("b = %g, alpha = %g deg, c = %g, beta = %g deg",
bx, 180/G_PI*atan2(bx, 1), by, 180/G_PI*atan2(by, 1));
break;
default:
g_assert_not_reached();
break;
}
gwy_app_channel_log_add_proc(data, id, id);
gwy_data_field_data_changed(dfield);
gwy_object_unref(mfield);
}
static void
selection_finished_cb(GwyUnitoolState *state)
{
GwyContainer *data;
GObject *dfield;
GwyDataField *mask = NULL;
GwyDataViewLayer *layer;
ToolControls *controls;
GwySIUnit *siunit;
gint isel[4];
controls = (ToolControls*)state->user_data;
layer = GWY_DATA_VIEW_LAYER(state->layer);
data = gwy_data_view_get_data(GWY_DATA_VIEW(layer->parent));
dfield = gwy_container_get_object_by_name(data, "/0/data");
gwy_container_gis_object_by_name(data, "/0/mask", (GObject**)&mask);
gwy_unitool_rect_info_table_fill(state, &controls->labels, NULL, isel);
switch (controls->mode) {
case MASK_EDIT_SET:
gwy_app_undo_checkpoint(data, "/0/mask", NULL);
if (!mask) {
mask = GWY_DATA_FIELD(gwy_serializable_duplicate(dfield));
siunit = GWY_SI_UNIT(gwy_si_unit_new(""));
gwy_data_field_set_si_unit_z(mask, siunit);
g_object_unref(siunit);
gwy_container_set_object_by_name(data, "/0/mask", (GObject*)mask);
g_object_unref(mask);
}
gwy_data_field_fill(mask, 0.0);
gwy_data_field_area_fill(mask, isel[0], isel[1], isel[2], isel[3],
1.0);
break;
case MASK_EDIT_ADD:
gwy_app_undo_checkpoint(data, "/0/mask", NULL);
if (!mask) {
mask = GWY_DATA_FIELD(gwy_serializable_duplicate(dfield));
siunit = GWY_SI_UNIT(gwy_si_unit_new(""));
gwy_data_field_set_si_unit_z(mask, siunit);
g_object_unref(siunit);
gwy_container_set_object_by_name(data, "/0/mask", (GObject*)mask);
g_object_unref(mask);
gwy_data_field_fill(mask, 0.0);
}
gwy_data_field_area_fill(mask, isel[0], isel[1], isel[2], isel[3],
1.0);
break;
case MASK_EDIT_REMOVE:
if (mask) {
gwy_app_undo_checkpoint(data, "/0/mask", NULL);
gwy_data_field_area_fill(mask, isel[0], isel[1], isel[2], isel[3],
0.0);
}
break;
case MASK_EDIT_INTERSECT:
if (mask) {
gwy_app_undo_checkpoint(data, "/0/mask", NULL);
gwy_data_field_clamp(mask, 0.0, 1.0);
gwy_data_field_area_add(mask, isel[0], isel[1], isel[2], isel[3],
1.0);
gwy_data_field_add(mask, -1.0);
gwy_data_field_clamp(mask, 0.0, 1.0);
}
break;
default:
break;
}
gwy_vector_layer_unselect(GWY_VECTOR_LAYER(layer));
gwy_app_data_view_update(layer->parent);
}
static void
level_grains_do(const LevelGrainsArgs *args,
GwyContainer *data, GQuark dquark, gint id,
GwyDataField *dfield, GwyDataField *mfield)
{
GwyDataField *buffer, *background, *invmask;
gdouble error, cor, maxerr, lastfrac, frac, starterr;
gdouble *heights, *bgdata;
gint *grains;
gboolean cancelled = FALSE;
gint i, xres, yres, ngrains;
xres = gwy_data_field_get_xres(mfield);
yres = gwy_data_field_get_yres(mfield);
grains = g_new0(gint, xres*yres);
ngrains = gwy_data_field_number_grains(mfield, grains);
if (!ngrains) {
g_free(grains);
return;
}
heights = g_new(gdouble, ngrains+1);
gwy_data_field_grains_get_values(dfield, heights, ngrains, grains,
args->base);
heights[0] = 0.0;
background = gwy_data_field_new_alike(dfield, FALSE);
bgdata = gwy_data_field_get_data(background);
for (i = 0; i < xres*yres; i++)
bgdata[i] = -heights[grains[i]];
invmask = gwy_data_field_duplicate(mfield);
gwy_data_field_multiply(invmask, -1.0);
gwy_data_field_add(invmask, 1.0);
maxerr = gwy_data_field_get_rms(dfield)/1.0e4;
gwy_app_wait_start(gwy_app_find_window_for_channel(data, id),
_("Laplace interpolation..."));
g_free(heights);
g_free(grains);
buffer = gwy_data_field_new_alike(background, TRUE);
gwy_data_field_correct_average(background, invmask);
cor = 0.2;
error = 0.0;
lastfrac = 0.0;
starterr = 0.0;
for (i = 0; i < 5000; i++) {
gwy_data_field_correct_laplace_iteration(background, invmask, buffer,
cor, &error);
if (error < maxerr)
break;
if (!i)
starterr = error;
frac = log(error/starterr)/log(maxerr/starterr);
if ((i/(gdouble)(5000)) > frac)
frac = i/(gdouble)(5000);
if (lastfrac > frac)
frac = lastfrac;
if (!gwy_app_wait_set_fraction(frac)) {
cancelled = TRUE;
break;
}
lastfrac = frac;
}
gwy_app_wait_finish();
if (!cancelled) {
gwy_data_field_invert(background, FALSE, FALSE, TRUE);
gwy_app_undo_qcheckpointv(data, 1, &dquark);
gwy_data_field_subtract_fields(dfield, dfield, background);
gwy_data_field_data_changed(dfield);
if (args->do_extract) {
gint newid;
newid = gwy_app_data_browser_add_data_field(background, data, TRUE);
gwy_app_sync_data_items(data, data, id, newid, FALSE,
GWY_DATA_ITEM_GRADIENT,
0);
gwy_app_set_data_field_title(data, newid, _("Background"));
}
}
g_object_unref(buffer);
g_object_unref(invmask);
g_object_unref(background);
}
