static void
facets_analyse(GwyContainer *data, GwyRunType run)
{
FacetsArgs args;
GwyContainer *fdata;
GwyDataField *dfield, *mfield;
GQuark mquark;
gint id;
g_return_if_fail(run & FACETS_RUN_MODES);
g_return_if_fail(g_type_from_name("GwyLayerPoint"));
facets_load_args(gwy_app_settings_get(), &args);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_MASK_FIELD_KEY, &mquark,
GWY_APP_MASK_FIELD, &mfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield && mquark);
fdata = gwy_container_new();
gwy_data_field_facet_distribution(dfield, 2*args.kernel_size + 1, fdata);
args.theta0 = gwy_container_get_double_by_name(fdata, "/theta0");
args.phi0 = gwy_container_get_double_by_name(fdata, "/phi0");
if (run == GWY_RUN_IMMEDIATE) {
run_noninteractive(&args, data, fdata, dfield, mfield, mquark);
gwy_app_channel_log_add_proc(data, id, id);
}
else {
facets_dialog(&args, data, fdata, dfield, mfield, id, mquark);
}
g_object_unref(fdata);
}
static void
rotate_counterclockwise_90(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfields[3], *newfield;
GQuark quarks[3];
gint i, id;
g_return_if_fail(run & BASICOPS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, dfields + 0,
GWY_APP_MASK_FIELD, dfields + 1,
GWY_APP_SHOW_FIELD, dfields + 2,
GWY_APP_DATA_FIELD_KEY, quarks + 0,
GWY_APP_MASK_FIELD_KEY, quarks + 1,
GWY_APP_SHOW_FIELD_KEY, quarks + 2,
GWY_APP_DATA_FIELD_ID, &id,
0);
clean_quarks(G_N_ELEMENTS(quarks), quarks, dfields);
gwy_app_undo_qcheckpointv(data, G_N_ELEMENTS(quarks), quarks);
for (i = 0; i < G_N_ELEMENTS(dfields); i++) {
if (dfields[i]) {
newfield = gwy_data_field_new_alike(dfields[i], FALSE);
flip_xy(dfields[i], newfield, TRUE);
gwy_container_set_object(data, quarks[i], newfield);
g_object_unref(newfield);
}
}
gwy_app_data_clear_selections(data, id);
gwy_app_channel_log_add_proc(data, id, id);
}
static void
mask_extract(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield;
GwySIUnit *siunit;
gint oldid, newid;
g_return_if_fail(run & MASKOPS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_MASK_FIELD, &dfield,
GWY_APP_DATA_FIELD_ID, &oldid,
0);
g_return_if_fail(dfield);
dfield = gwy_data_field_duplicate(dfield);
gwy_data_field_clamp(dfield, 0.0, 1.0);
/* Other functions should set the units correctly, but do not trust them */
siunit = gwy_si_unit_new("");
gwy_data_field_set_si_unit_z(dfield, siunit);
g_object_unref(siunit);
newid = gwy_app_data_browser_add_data_field(dfield, data, TRUE);
g_object_unref(dfield);
gwy_app_set_data_field_title(data, newid, _("Mask"));
gwy_app_channel_log_add_proc(data, oldid, newid);
}
static void
psdflp(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield, *lpsdf;
PSDFLPArgs args;
gboolean ok;
gint id, newid;
g_return_if_fail(run & PSDFLP_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield);
psdflp_load_args(gwy_app_settings_get(), &args);
if (run == GWY_RUN_INTERACTIVE) {
ok = psdflp_dialog(&args);
psdflp_save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
lpsdf = gwy_data_field_new(1, 1, 1.0, 1.0, FALSE);
psdflp_do(&args, dfield, lpsdf);
newid = gwy_app_data_browser_add_data_field(lpsdf, data, TRUE);
g_object_unref(lpsdf);
gwy_app_set_data_field_title(data, newid, "Log-phi PSDF");
gwy_app_channel_log_add_proc(data, id, newid);
}
static void
rotate_180(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfields[3];
GQuark quarks[3];
gint id;
gint i;
g_return_if_fail(run & BASICOPS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, dfields + 0,
GWY_APP_MASK_FIELD, dfields + 1,
GWY_APP_SHOW_FIELD, dfields + 2,
GWY_APP_DATA_FIELD_KEY, quarks + 0,
GWY_APP_MASK_FIELD_KEY, quarks + 1,
GWY_APP_SHOW_FIELD_KEY, quarks + 2,
GWY_APP_DATA_FIELD_ID, &id,
0);
clean_quarks(G_N_ELEMENTS(quarks), quarks, dfields);
gwy_app_undo_qcheckpointv(data, G_N_ELEMENTS(quarks), quarks);
for (i = 0; i < G_N_ELEMENTS(dfields); i++) {
if (dfields[i]) {
gwy_data_field_invert(dfields[i], TRUE, TRUE, FALSE);
gwy_data_field_data_changed(dfields[i]);
}
}
gwy_app_channel_log_add_proc(data, id, id);
}
static void
level_grains(GwyContainer *data,
GwyRunType run)
{
GwyDataField *dfield;
GwyDataField *mfield;
LevelGrainsArgs args;
gboolean ok;
GQuark quark;
gint id;
g_return_if_fail(run & LEVEL_GRAINS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD_KEY, &quark,
GWY_APP_DATA_FIELD_ID, &id,
GWY_APP_DATA_FIELD, &dfield,
GWY_APP_MASK_FIELD, &mfield,
0);
g_return_if_fail(dfield && quark);
load_args(gwy_app_settings_get(), &args);
if (run != GWY_RUN_IMMEDIATE) {
ok = level_grains_dialog(&args);
save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
level_grains_do(&args, data, quark, id, dfield, mfield);
gwy_app_channel_log_add_proc(data, id, id);
}
static void
presentation_logscale(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield, *sfield;
GQuark squark;
gdouble *d;
gdouble min, max, m0;
gint xres, yres, i, zeroes, id;
g_return_if_fail(run & PRESENTATIONOPS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_SHOW_FIELD_KEY, &squark,
GWY_APP_SHOW_FIELD, &sfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield && squark);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
gwy_app_undo_qcheckpointv(data, 1, &squark);
if (!sfield) {
sfield = gwy_data_field_duplicate(dfield);
gwy_container_set_object(data, squark, sfield);
g_object_unref(sfield);
}
else {
gwy_data_field_resample(sfield, xres, yres, GWY_INTERPOLATION_NONE);
gwy_data_field_copy(dfield, sfield, FALSE);
}
d = gwy_data_field_get_data(sfield);
zeroes = 0;
max = 0;
min = G_MAXDOUBLE;
for (i = 0; i < xres*yres; i++) {
d[i] = ABS(d[i]);
if (G_UNLIKELY(d[i] > max))
max = d[i];
if (d[i] == 0.0)
zeroes++;
else if (G_UNLIKELY(d[i] < min))
min = d[i];
}
if (min == max || zeroes == xres*yres)
return;
if (!zeroes) {
for (i = 0; i < xres*yres; i++)
d[i] = log(d[i]);
}
else {
m0 = log(min) - log(max/min)/512.0;
for (i = 0; i < xres*yres; i++)
d[i] = d[i] ? log(d[i]) : m0;
}
gwy_data_field_data_changed(sfield);
gwy_app_channel_log_add_proc(data, id, id);
}
static void
laplace(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield, *mfield, *buffer;
GQuark dquark;
gdouble error, cor, maxer, lastfrac, frac, starter;
gint i, id;
gboolean cancelled = FALSE;
g_return_if_fail(run & LAPLACE_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD_KEY, &dquark,
GWY_APP_DATA_FIELD, &dfield,
GWY_APP_MASK_FIELD, &mfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield && dquark && mfield);
maxer = gwy_data_field_get_rms(dfield)/1.0e4;
gwy_app_wait_start(gwy_app_find_window_for_channel(data, id),
_("Laplace interpolation..."));
dfield = gwy_data_field_duplicate(dfield);
buffer = gwy_data_field_new_alike(dfield, TRUE);
gwy_data_field_correct_average(dfield, mfield);
cor = 0.2;
error = 0.0;
lastfrac = 0.0;
starter = 0.0;
for (i = 0; i < 5000; i++) {
gwy_data_field_correct_laplace_iteration(dfield, mfield, buffer,
cor, &error);
if (error < maxer)
break;
if (!i)
starter = error;
frac = log(error/starter)/log(maxer/starter);
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_app_undo_qcheckpointv(data, 1, &dquark);
gwy_container_set_object(data, dquark, dfield);
gwy_app_channel_log_add_proc(data, id, id);
}
g_object_unref(dfield);
g_object_unref(buffer);
}
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 void
grain_filter(GwyContainer *data, GwyRunType run)
{
GwySIUnit *siunitxy, *siunitz;
GFilterArgs args;
GwyDataField *dfield, *mfield;
GQuark mquark;
gint id;
g_return_if_fail(run & GFILTER_RUN_MODES);
gfilter_load_args(gwy_app_settings_get(), &args);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_MASK_FIELD, &mfield,
GWY_APP_MASK_FIELD_KEY, &mquark,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield && mfield);
siunitxy = gwy_data_field_get_si_unit_xy(dfield);
siunitz = gwy_data_field_get_si_unit_z(dfield);
args.units_equal = gwy_si_unit_equal(siunitxy, siunitz);
args.valuedata = calculate_all_grain_values(dfield, mfield,
&args.ngrains, &args.grains);
args.sortedvaluedata = sort_grain_values(args.valuedata,
&args.nuniqvalues,
args.ngrains);
if (run == GWY_RUN_INTERACTIVE && !args.ngrains) {
GtkWidget *dialog;
gfilter_free_args(&args);
dialog = gtk_message_dialog_new
(gwy_app_find_window_for_channel(data, id),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_ERROR,
GTK_BUTTONS_OK,
_("There are no grains to filter."));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
return;
}
if (run == GWY_RUN_IMMEDIATE) {
run_noninteractive(&args, data, mfield, mquark);
gwy_app_channel_log_add_proc(data, id, id);
}
else
gfilter_dialog(&args, data, dfield, mfield, id, mquark);
gfilter_free_args(&args);
}
static void
presentation_remove(GwyContainer *data, GwyRunType run)
{
GQuark quark;
gint id;
g_return_if_fail(run & PRESENTATIONOPS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_SHOW_FIELD_KEY, &quark,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(quark);
gwy_app_undo_qcheckpointv(data, 1, &quark);
gwy_container_remove(data, quark);
gwy_app_channel_log_add_proc(data, id, id);
}
static void
mask_remove(GwyContainer *data, GwyRunType run)
{
GQuark mquark;
gint id;
g_return_if_fail(run & MASKOPS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_MASK_FIELD_KEY, &mquark,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(mquark);
gwy_app_undo_qcheckpointv(data, 1, &mquark);
gwy_container_remove(data, mquark);
gwy_app_channel_log_add_proc(data, id, id);
}
static void
zero_mean(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_avg(dfield));
gwy_app_channel_log_add_proc(data, id, id);
gwy_data_field_data_changed(dfield);
}
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
laplace(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield, *mfield;
GQuark dquark;
gint id;
g_return_if_fail(run & LAPLACE_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD_KEY, &dquark,
GWY_APP_DATA_FIELD, &dfield,
GWY_APP_MASK_FIELD, &mfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield && dquark && mfield);
gwy_app_undo_qcheckpointv(data, 1, &dquark);
gwy_data_field_laplace_solve(dfield, mfield, -1, 1.0);
gwy_data_field_data_changed(dfield);
gwy_app_channel_log_add_proc(data, id, id);
}
static void
null_offsets(GwyContainer *data,
GwyRunType run)
{
GwyDataField *dfields[3];
GQuark quarks[3];
guint i;
gint id;
g_return_if_fail(run & BASICOPS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, dfields + 0,
GWY_APP_MASK_FIELD, dfields + 1,
GWY_APP_SHOW_FIELD, dfields + 2,
GWY_APP_DATA_FIELD_KEY, quarks + 0,
GWY_APP_MASK_FIELD_KEY, quarks + 1,
GWY_APP_SHOW_FIELD_KEY, quarks + 2,
GWY_APP_DATA_FIELD_ID, &id,
0);
clean_quarks(G_N_ELEMENTS(quarks), quarks, dfields);
for (i = 0; i < G_N_ELEMENTS(dfields); i++) {
if (dfields[i]
&& !gwy_data_field_get_xoffset(dfields[i])
&& !gwy_data_field_get_yoffset(dfields[i])) {
quarks[i] = 0;
dfields[i] = NULL;
}
}
if (!dfields[0] && !dfields[1] && !dfields[2])
return;
gwy_app_undo_qcheckpointv(data, G_N_ELEMENTS(quarks), quarks);
for (i = 0; i < G_N_ELEMENTS(dfields); i++) {
if (dfields[i]) {
gwy_data_field_set_xoffset(dfields[i], 0.0);
gwy_data_field_set_yoffset(dfields[i], 0.0);
gwy_data_field_data_changed(dfields[i]);
}
}
gwy_app_channel_log_add_proc(data, id, id);
}
static void
mask_invert(GwyContainer *data, GwyRunType run)
{
GwyDataField *mfield;
GQuark mquark;
gint id;
g_return_if_fail(run & MASKOPS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_MASK_FIELD, &mfield,
GWY_APP_MASK_FIELD_KEY, &mquark,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(mfield && mquark);
gwy_app_undo_qcheckpointv(data, 1, &mquark);
gwy_data_field_grains_invert(mfield);
gwy_data_field_data_changed(mfield);
gwy_app_channel_log_add_proc(data, id, id);
}
static void
presentation_extract(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield;
GQuark quark;
gint oldid, newid;
g_return_if_fail(run & PRESENTATIONOPS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD_ID, &oldid,
GWY_APP_SHOW_FIELD_KEY, &quark,
GWY_APP_SHOW_FIELD, &dfield,
0);
g_return_if_fail(dfield && quark);
dfield = gwy_data_field_duplicate(dfield);
newid = gwy_app_data_browser_add_data_field(dfield, data, TRUE);
g_object_unref(dfield);
gwy_app_sync_data_items(data, data, oldid, newid, FALSE,
GWY_DATA_ITEM_GRADIENT,
0);
gwy_app_set_data_field_title(data, newid, NULL);
gwy_app_channel_log_add_proc(data, oldid, newid);
}
static void
grain_edge(GwyContainer *data, GwyRunType run)
{
GEdgeArgs args;
GwyDataField *dfield;
GQuark mquark;
gint id;
g_return_if_fail(run & GEDGE_RUN_MODES);
gedge_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_KEY, &mquark,
0);
g_return_if_fail(dfield && mquark);
if (run == GWY_RUN_IMMEDIATE) {
run_noninteractive(&args, data, dfield, mquark);
gwy_app_channel_log_add_proc(data, id, id);
}
else
gedge_dialog(&args, data, dfield, id, mquark);
}
static void
rotate(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfields[3];
GQuark quark;
gint oldid, newid;
RotateArgs args;
gboolean ok;
g_return_if_fail(run & ROTATE_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, dfields + 0,
GWY_APP_MASK_FIELD, dfields + 1,
GWY_APP_SHOW_FIELD, dfields + 2,
GWY_APP_DATA_FIELD_ID, &oldid,
0);
g_return_if_fail(dfields[0]);
rotate_load_args(gwy_app_settings_get(), &args);
if (run == GWY_RUN_INTERACTIVE) {
ok = rotate_dialog(&args, data);
rotate_save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
dfields[0] = gwy_data_field_duplicate(dfields[0]);
rotate_datafield(dfields[0], &args);
if (dfields[1]) {
GwyInterpolationType interp = args.interp;
dfields[1] = gwy_data_field_duplicate(dfields[1]);
args.interp = GWY_INTERPOLATION_ROUND;
rotate_datafield(dfields[1], &args);
args.interp = interp;
}
if (dfields[2]) {
dfields[2] = gwy_data_field_duplicate(dfields[2]);
rotate_datafield(dfields[2], &args);
}
newid = gwy_app_data_browser_add_data_field(dfields[0], data, TRUE);
g_object_unref(dfields[0]);
gwy_app_sync_data_items(data, data, oldid, newid, FALSE,
GWY_DATA_ITEM_GRADIENT,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_MASK_COLOR,
0);
if (dfields[1]) {
quark = gwy_app_get_mask_key_for_id(newid);
gwy_container_set_object(data, quark, dfields[1]);
g_object_unref(dfields[1]);
}
if (dfields[2]) {
quark = gwy_app_get_show_key_for_id(newid);
gwy_container_set_object(data, quark, dfields[2]);
g_object_unref(dfields[2]);
}
gwy_app_set_data_field_title(data, newid, _("Rotated Data"));
gwy_app_channel_log_add_proc(data, oldid, newid);
}
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 gboolean
xydenoise_do(XYdenoiseArgs *args)
{
GwyContainer *data;
GwyDataField *dfieldx, *rx, *ix, *dfieldy, *ry, *iy, *result, *iresult;
gint i, newid, xres, yres;
gdouble *rxdata, *rydata, *ixdata, *iydata;
GwyWindowingType window = GWY_WINDOWING_NONE;
GwyInterpolationType interp = GWY_INTERPOLATION_LINEAR;
GQuark quark;
data = gwy_app_data_browser_get(args->op1.datano);
gwy_app_wait_start(gwy_app_find_window_for_channel(data, args->op1.id),
_("Initializing..."));
quark = gwy_app_get_data_key_for_id(args->op1.id);
dfieldx = GWY_DATA_FIELD(gwy_container_get_object(data, quark));
data = gwy_app_data_browser_get(args->op2.datano);
quark = gwy_app_get_data_key_for_id(args->op2.id);
dfieldy = GWY_DATA_FIELD(gwy_container_get_object(data, quark));
xres = gwy_data_field_get_xres(dfieldx);
yres = gwy_data_field_get_yres(dfieldy);
result = gwy_data_field_new_alike(dfieldx, TRUE);
iresult = gwy_data_field_new_alike(dfieldx, TRUE);
rx = gwy_data_field_new_alike(dfieldx, TRUE);
ix = gwy_data_field_new_alike(dfieldx, TRUE);
ry = gwy_data_field_new_alike(dfieldx, TRUE);
iy = gwy_data_field_new_alike(dfieldx, TRUE);
gwy_app_wait_set_fraction(0.1);
gwy_app_wait_set_message(_("Computing forward FFTs..."));
gwy_data_field_2dfft(dfieldx, NULL, rx, ix,
window, GWY_TRANSFORM_DIRECTION_FORWARD, interp,
FALSE, 0);
gwy_data_field_2dfft(dfieldy, NULL, ry, iy,
window, GWY_TRANSFORM_DIRECTION_FORWARD, interp,
FALSE, 0);
rxdata = gwy_data_field_get_data(rx);
rydata = gwy_data_field_get_data(ry);
ixdata = gwy_data_field_get_data(ix);
iydata = gwy_data_field_get_data(iy);
gwy_app_wait_set_fraction(0.3);
gwy_app_wait_set_message(_("Computing image..."));
for (i = 0; i < xres*yres; i++) {
gdouble xmodule = sqrt(rxdata[i]*rxdata[i] + ixdata[i]*ixdata[i]);
gdouble xphase = atan2(ixdata[i],rxdata[i]);
gdouble ymodule = sqrt(rydata[i]*rydata[i] + iydata[i]*iydata[i]);
/*gdouble yphase = atan2(iydata[i],rydata[i]);*/
rxdata[i] = MIN(xmodule, ymodule)*cos(xphase);
ixdata[i] = MIN(xmodule, ymodule)*sin(xphase);
}
gwy_app_wait_set_fraction(0.7);
gwy_app_wait_set_message(_("Computing backward FFT..."));
gwy_data_field_2dfft(rx, ix, result, iresult,
window, GWY_TRANSFORM_DIRECTION_BACKWARD, interp,
FALSE, 0);
gwy_app_wait_set_fraction(0.9);
data = gwy_app_data_browser_get(args->op1.datano);
newid = gwy_app_data_browser_add_data_field(result, data, TRUE);
gwy_app_sync_data_items(data, data, args->op1.id, newid, FALSE,
GWY_DATA_ITEM_GRADIENT, 0);
gwy_app_set_data_field_title(data, newid, _("Denoised"));
gwy_app_channel_log_add_proc(data, -1, newid);
gwy_app_wait_finish();
g_object_unref(result);
g_object_unref(iresult);
g_object_unref(rx);
g_object_unref(ix);
g_object_unref(ry);
g_object_unref(iy);
return TRUE;
}
static void
gfilter_dialog(GFilterArgs *args,
GwyContainer *data,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *vbox, *hbox, *scwin, *hbox2, *label;
GtkTreeView *treeview;
GtkTreeSelection *selection;
GFilterControls controls;
gint response, row, i;
GwySIUnit *siunit;
GwyPixmapLayer *layer;
controls.args = args;
controls.mask = mfield;
controls.in_init = TRUE;
controls.computed = FALSE;
siunit = gwy_si_unit_new(NULL);
for (i = 0; i < NQUANTITIES; i++) {
controls.vf[i]
= gwy_si_unit_get_format_with_digits(siunit,
GWY_SI_UNIT_FORMAT_VFMARKUP,
1.0, 4, NULL);
}
g_object_unref(siunit);
dialog = gtk_dialog_new_with_buttons(_("Filter Grains"),
NULL, 0, NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog),
gwy_stock_like_button_new(_("_Update"),
GTK_STOCK_EXECUTE),
RESPONSE_PREVIEW);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gtk_dialog_set_response_sensitive(GTK_DIALOG(dialog), RESPONSE_PREVIEW,
!args->update);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox, TRUE, TRUE, 4);
vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4);
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
mfield = gwy_data_field_duplicate(mfield);
gwy_container_set_object_by_name(controls.mydata, "/0/mask", mfield);
g_object_unref(mfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_REAL_SQUARE,
0);
controls.view = gwy_data_view_new(controls.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);
layer = gwy_layer_mask_new();
gwy_pixmap_layer_set_data_key(layer, "/0/mask");
gwy_layer_mask_set_color_key(GWY_LAYER_MASK(layer), "/0/mask");
gwy_data_view_set_alpha_layer(GWY_DATA_VIEW(controls.view), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 0);
controls.update = gtk_check_button_new_with_mnemonic(_("I_nstant updates"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.update),
args->update);
gtk_box_pack_start(GTK_BOX(vbox), controls.update, FALSE, FALSE, 0);
g_signal_connect_swapped(controls.update, "toggled",
G_CALLBACK(update_changed), &controls);
hbox2 = gtk_hbox_new(FALSE, 6);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
label = gtk_label_new_with_mnemonic(_("_Mask color:"));
gtk_box_pack_start(GTK_BOX(hbox2), label, FALSE, FALSE, 0);
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)));
gtk_label_set_mnemonic_widget(GTK_LABEL(label), controls.color_button);
gtk_box_pack_start(GTK_BOX(hbox2), controls.color_button, FALSE, FALSE, 0);
g_signal_connect(controls.color_button, "clicked",
G_CALLBACK(mask_color_changed), &controls);
table = gtk_table_new(10, 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, TRUE, TRUE, 4);
controls.table = table;
row = 0;
scwin = gtk_scrolled_window_new(NULL, NULL);
gtk_scrolled_window_set_policy(GTK_SCROLLED_WINDOW(scwin),
GTK_POLICY_NEVER, GTK_POLICY_AUTOMATIC);
gtk_table_attach(GTK_TABLE(table), scwin, 0, 4, row, row+1,
GTK_EXPAND | GTK_FILL, GTK_EXPAND | GTK_FILL, 0, 0);
controls.values = gwy_grain_value_tree_view_new(FALSE,
"name", "symbol_markup",
NULL);
treeview = GTK_TREE_VIEW(controls.values);
gtk_widget_set_size_request(scwin, -1, 120);
gtk_tree_view_set_headers_visible(treeview, FALSE);
selection = gtk_tree_view_get_selection(treeview);
gtk_tree_selection_set_mode(selection, GTK_SELECTION_BROWSE);
gwy_grain_value_tree_view_set_same_units(treeview, args->units_equal);
gwy_grain_value_tree_view_set_expanded_groups(treeview, args->expanded);
gtk_container_add(GTK_CONTAINER(scwin), controls.values);
row++;
hbox2 = gtk_hbox_new(FALSE, 0);
for (i = 0; i < NQUANTITIES; i++) {
gchar buf[2];
buf[0] = 'A' + i;
buf[1] = '\0';
controls.set_as[i] = gtk_button_new_with_label(buf);
gtk_box_pack_start(GTK_BOX(hbox2), controls.set_as[i], FALSE, FALSE, 0);
g_object_set_data(G_OBJECT(controls.set_as[i]),
"id", GUINT_TO_POINTER(i));
g_signal_connect_swapped(controls.set_as[i], "clicked",
G_CALLBACK(set_as_clicked), &controls);
}
gwy_table_attach_hscale(table, row++,
_("Set selected as:"), NULL,
GTK_OBJECT(hbox2), GWY_HSCALE_WIDGET_NO_EXPAND);
controls.logical_op
= gwy_enum_combo_box_newl(G_CALLBACK(logical_op_changed), &controls,
args->logical,
"A", GRAIN_LOGICAL_A,
"A ∧ B", GRAIN_LOGICAL_A_AND_B,
"A ∨ B", GRAIN_LOGICAL_A_OR_B,
"A ∧ B ∧ C", GRAIN_LOGICAL_A_AND_B_AND_C,
"A ∨ B ∨ C", GRAIN_LOGICAL_A_OR_B_OR_C,
"(A ∧ B) ∨ C", GRAIN_LOGICAL_A_AND_B_OR_C,
"(A ∨ B) ∧ C", GRAIN_LOGICAL_A_OR_B_AND_C,
NULL);
gwy_table_attach_hscale(table, row++,
_("Keep grains satisfying:"), NULL,
GTK_OBJECT(controls.logical_op),
GWY_HSCALE_WIDGET);
for (i = 0; i < NQUANTITIES; i++) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
controls.header[i] = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.header[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.header[i],
0, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
/* The values are set properly later. */
controls.lower_label[i] = gtk_label_new(_("Lower threshold:"));
gtk_misc_set_alignment(GTK_MISC(controls.lower_label[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.lower_label[i],
0, 1, row, row+1, GTK_FILL, 0, 0, 0);
controls.lower[i] = gtk_adjustment_new(0.0, 0.0, 0.0,
1.0, 10.0, 0.0);
g_object_set_data(G_OBJECT(controls.lower[i]), "id",
GUINT_TO_POINTER(i));
g_signal_connect_swapped(controls.lower[i], "value-changed",
G_CALLBACK(threshold_changed), &controls);
controls.lower_scale[i]
= gtk_hscale_new(GTK_ADJUSTMENT(controls.lower[i]));
gtk_scale_set_draw_value(GTK_SCALE(controls.lower_scale[i]), FALSE);
gtk_widget_set_size_request(controls.lower_scale[i],
GWY_HSCALE_WIDTH, -1);
gtk_table_attach(GTK_TABLE(table), controls.lower_scale[i],
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.lower_entry[i] = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(controls.lower_entry[i]), 8);
gtk_table_attach(GTK_TABLE(table), controls.lower_entry[i],
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_set_activate_on_unfocus(controls.lower_entry[i], TRUE);
g_object_set_data(G_OBJECT(controls.lower_entry[i]), "id",
GUINT_TO_POINTER(i));
g_signal_connect_swapped(controls.lower_entry[i], "activate",
G_CALLBACK(threshold_activated), &controls);
controls.lower_units[i] = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.lower_units[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.lower_units[i],
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.upper_label[i] = gtk_label_new(_("Upper threshold:"));
gtk_misc_set_alignment(GTK_MISC(controls.upper_label[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.upper_label[i],
0, 1, row, row+1, GTK_FILL, 0, 0, 0);
controls.upper[i] = gtk_adjustment_new(0.0, 0.0, 0.0,
1.0, 10.0, 0.0);
g_object_set_data(G_OBJECT(controls.upper[i]), "id",
GUINT_TO_POINTER(i | IS_UPPER));
g_signal_connect_swapped(controls.upper[i], "value-changed",
G_CALLBACK(threshold_changed), &controls);
controls.upper_scale[i]
= gtk_hscale_new(GTK_ADJUSTMENT(controls.upper[i]));
gtk_scale_set_draw_value(GTK_SCALE(controls.upper_scale[i]), FALSE);
gtk_widget_set_size_request(controls.upper_scale[i],
GWY_HSCALE_WIDTH, -1);
gtk_table_attach(GTK_TABLE(table), controls.upper_scale[i],
1, 2, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
controls.upper_entry[i] = gtk_entry_new();
gtk_entry_set_width_chars(GTK_ENTRY(controls.upper_entry[i]), 8);
gtk_table_attach(GTK_TABLE(table), controls.upper_entry[i],
2, 3, row, row+1, GTK_FILL, 0, 0, 0);
gwy_widget_set_activate_on_unfocus(controls.upper_entry[i], TRUE);
g_object_set_data(G_OBJECT(controls.upper_entry[i]), "id",
GUINT_TO_POINTER(i | IS_UPPER));
g_signal_connect_swapped(controls.upper_entry[i], "activate",
G_CALLBACK(threshold_activated), &controls);
controls.upper_units[i] = gtk_label_new(NULL);
gtk_misc_set_alignment(GTK_MISC(controls.upper_units[i]), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), controls.upper_units[i],
3, 4, row, row+1, GTK_FILL, 0, 0, 0);
row++;
}
for (i = 0; i < NQUANTITIES; i++) {
GwyInventory *inventory;
GwyGrainValue *gvalue;
inventory = gwy_grain_values();
gvalue = gwy_inventory_get_item(inventory, args->ranges[i].quantity);
set_up_quantity(&controls, gvalue, i);
}
logical_op_changed(GTK_COMBO_BOX(controls.logical_op), &controls);
/* finished initializing, allow instant updates */
controls.in_init = FALSE;
gfilter_invalidate(&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:
args->expanded = gwy_grain_value_tree_view_get_expanded_groups
(GTK_TREE_VIEW(controls.values));
for (i = 0; i < NQUANTITIES; i++)
gwy_si_unit_value_format_free(controls.vf[i]);
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
gfilter_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_PREVIEW:
preview(&controls);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
for (i = 0; i < NQUANTITIES; i++)
gwy_si_unit_value_format_free(controls.vf[i]);
args->expanded = gwy_grain_value_tree_view_get_expanded_groups
(GTK_TREE_VIEW(controls.values));
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
gfilter_save_args(gwy_app_settings_get(), args);
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, controls.mask, mquark);
}
gwy_app_channel_log_add_proc(data, id, id);
}
static void
gedge_dialog(GEdgeArgs *args,
GwyContainer *data,
GwyDataField *dfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *hbox;
GEdgeControls controls;
GwyPixmapLayer *layer;
gint row;
gint response;
gboolean temp;
controls.in_init = TRUE;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Mark Grains by Edge Detection"), NULL, 0,
NULL);
gtk_dialog_add_action_widget(GTK_DIALOG(dialog),
gwy_stock_like_button_new(_("_Update"),
GTK_STOCK_EXECUTE),
RESPONSE_PREVIEW);
gtk_dialog_add_button(GTK_DIALOG(dialog), _("_Reset"), RESPONSE_RESET);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL);
gtk_dialog_add_button(GTK_DIALOG(dialog),
GTK_STOCK_OK, GTK_RESPONSE_OK);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_REAL_SQUARE,
0);
controls.view = gwy_data_view_new(controls.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);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
table = gtk_table_new(5, 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, TRUE, TRUE, 4);
row = 0;
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Threshold")),
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
table_attach_threshold(table, &row, _("_Laplacian:"),
&controls.threshold_laplasian,
args->threshold_laplasian,
&controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
gtk_table_attach(GTK_TABLE(table), gwy_label_new_header(_("Options")),
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
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);
row++;
controls.update = gtk_check_button_new_with_mnemonic(_("I_nstant updates"));
gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.update),
args->update);
gtk_table_attach(GTK_TABLE(table), controls.update,
0, 3, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(controls.update, "toggled",
G_CALLBACK(update_change_cb), &controls);
gedge_invalidate(&controls);
/* finished initializing, allow instant updates */
controls.in_init = FALSE;
/* show initial preview if instant updates are on */
if (args->update) {
gtk_dialog_set_response_sensitive(GTK_DIALOG(controls.dialog),
RESPONSE_PREVIEW, FALSE);
preview(&controls, args);
}
gtk_widget_show_all(dialog);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gedge_dialog_update_values(&controls, args);
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
gedge_save_args(gwy_app_settings_get(), args);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
temp = args->update;
*args = gedge_defaults;
args->update = temp;
gedge_dialog_update_controls(&controls, args);
controls.in_init = TRUE;
preview(&controls, args);
controls.in_init = FALSE;
break;
case RESPONSE_PREVIEW:
gedge_dialog_update_values(&controls, args);
preview(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gedge_dialog_update_values(&controls, args);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
gedge_save_args(gwy_app_settings_get(), args);
gwy_app_channel_log_add_proc(data, id, id);
g_object_unref(controls.mydata);
run_noninteractive(args, data, dfield, mquark);
}
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
presentation_attach(GwyContainer *data,
GwyRunType run)
{
GtkWidget *dialog, *table, *label, *chooser;
GwyAppDataId target;
gint row, response;
g_return_if_fail(run & PRESENTATION_ATTACH_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_CONTAINER_ID, &target.datano,
GWY_APP_DATA_FIELD_ID, &target.id,
0);
gwy_app_data_id_verify_channel(&attach_source_id);
dialog = gtk_dialog_new_with_buttons(_("Attach Presentation"), NULL, 0,
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(1, 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(GTK_DIALOG(dialog)->vbox), table, TRUE, TRUE, 4);
row = 0;
label = gtk_label_new_with_mnemonic(_("_Data to attach:"));
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);
chooser = gwy_data_chooser_new_channels();
gwy_data_chooser_set_filter(GWY_DATA_CHOOSER(chooser),
&presentation_attach_filter, &target, NULL);
gwy_data_chooser_set_active_id(GWY_DATA_CHOOSER(chooser),
&attach_source_id);
gtk_table_attach(GTK_TABLE(table), chooser, 1, 2, row, row+1,
GTK_EXPAND | GTK_FILL, 0, 0, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), chooser);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
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;
break;
case GTK_RESPONSE_OK:
gwy_data_chooser_get_active_id(GWY_DATA_CHOOSER(chooser),
&attach_source_id);
/* The data must be always compatible at least with itself */
g_assert(attach_source_id.datano);
presentation_attach_do(&attach_source_id, &target);
gwy_app_channel_log_add_proc(data, target.id, target.id);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gtk_widget_destroy(dialog);
}
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;
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
median(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield, *background = NULL;
MedianBgArgs args;
gint oldid, newid;
GQuark dquark;
gdouble xr, yr;
gboolean ok = TRUE;
g_return_if_fail(run & MEDIANBG_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_KEY, &dquark,
GWY_APP_DATA_FIELD_ID, &oldid,
0);
g_return_if_fail(dfield && dquark);
median_load_args(gwy_app_settings_get(), &args);
/* FIXME: this is bogus for non-square pixels anyway */
xr = gwy_data_field_get_xreal(dfield)/gwy_data_field_get_xres(dfield);
yr = gwy_data_field_get_yreal(dfield)/gwy_data_field_get_yres(dfield);
args.pixelsize = hypot(xr, yr);
args.valform
= gwy_data_field_get_value_format_xy(dfield,
GWY_SI_UNIT_FORMAT_VFMARKUP, NULL);
gwy_debug("pixelsize = %g, vf = (%g, %d, %s)",
args.pixelsize, args.valform->magnitude, args.valform->precision,
args.valform->units);
if (run == GWY_RUN_INTERACTIVE) {
ok = median_dialog(&args);
median_save_args(gwy_app_settings_get(), &args);
}
gwy_si_unit_value_format_free(args.valform);
if (!ok)
return;
gwy_app_wait_start(gwy_app_find_window_for_channel(data, oldid),
_("Median-leveling..."));
background = median_background(GWY_ROUND(args.size), dfield);
gwy_app_wait_finish();
if (!background)
return;
gwy_app_undo_qcheckpointv(data, 1, &dquark);
gwy_data_field_subtract_fields(dfield, dfield, background);
gwy_data_field_data_changed(dfield);
gwy_app_channel_log_add_proc(data, oldid, oldid);
if (!args.do_extract) {
g_object_unref(background);
return;
}
newid = gwy_app_data_browser_add_data_field(background, data, TRUE);
g_object_unref(background);
gwy_app_sync_data_items(data, data, oldid, newid, FALSE,
GWY_DATA_ITEM_GRADIENT,
0);
gwy_app_set_data_field_title(data, newid, _("Background"));
gwy_app_channel_log_add(data, oldid, newid, NULL, NULL);
}
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);
}
