/* compute corelation */
static gboolean
get_score_iteratively(GwyDataField *data_field, GwyDataField *kernel_field,
GwyDataField *score, MergeArgs *args)
{
enum { WORK_PER_UPDATE = 50000000 };
GwyComputationState *state;
GwyContainer *data;
gboolean ok = FALSE;
int work, wpi;
work = 0;
wpi = gwy_data_field_get_xres(kernel_field)
*gwy_data_field_get_yres(kernel_field);
wpi = MIN(wpi, WORK_PER_UPDATE);
state = gwy_data_field_correlate_init(data_field, kernel_field, score);
/* FIXME */
data = gwy_app_data_browser_get(args->op1.datano);
gwy_app_wait_start(gwy_app_find_window_for_channel(data, args->op1.id),
_("Initializing..."));
gwy_data_field_correlate_iteration(state);
if (!gwy_app_wait_set_message(_("Correlating...")))
goto get_score_fail;
do {
gwy_data_field_correlate_iteration(state);
work += wpi;
if (work > WORK_PER_UPDATE) {
work -= WORK_PER_UPDATE;
if (!gwy_app_wait_set_fraction(state->fraction))
goto get_score_fail;
}
} while (state->state != GWY_COMPUTATION_STATE_FINISHED);
ok = TRUE;
get_score_fail:
gwy_data_field_correlate_finalize(state);
gwy_app_wait_finish();
return ok;
}
/**
* gwy_app_wait_switch_widget:
* @window: A window.
* @message: A mesage to show now (%NULL for keep the present one).
*
* Switches the waiting window.
*
* FIXME: This is probably both broken and nonsense.
*
* Returns: %TRUE if the operation can continue, %FALSE if user cancelled it
* meanwhile.
**/
gboolean
gwy_app_wait_switch_widget(GtkWidget *window,
const gchar *message)
{
if (!window || !silent_waiting) {
g_warning("Cannot switch between normal and silent waiting.");
return TRUE;
}
while (gtk_events_pending())
gtk_main_iteration();
if (canceled)
return FALSE;
wait_widget = window;
gtk_window_set_transient_for(GTK_WINDOW(dialog), GTK_WINDOW(window));
while (gtk_events_pending())
gtk_main_iteration();
if (message)
gwy_app_wait_set_message(message);
return !canceled;
}
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 gboolean
mask_process(GwyDataField *dfield, GwyDataField *maskfield, WshedArgs *args,
GtkWidget *wait_window)
{
gdouble max, min;
GwyWatershedStatus status;
GwyWatershedStateType oldstate = -1;
max = gwy_data_field_get_max(dfield);
min = gwy_data_field_get_min(dfield);
/*
gwy_data_field_grains_mark_watershed(dfield, maskfield,
args->locate_steps,
args->locate_thresh,
args->locate_dropsize*(max-min)/5000.0,
args->wshed_steps,
args->wshed_dropsize*(max-min)/5000.0,
FALSE, 0);
*/
status.state = GWY_WSHED_INIT;
gwy_app_wait_start(wait_window, _("Initializing"));
do {
gwy_data_field_grains_watershed_iteration(dfield, maskfield,
&status,
args->locate_steps,
args->locate_thresh,
args->locate_dropsize*(max-min)/5000.0,
args->wshed_steps,
args->wshed_dropsize*(max-min)/5000.0,
FALSE, args->inverted);
if (status.state == GWY_WSHED_MIN) {
gwy_app_wait_set_message(_("Finding minima"));
if (!gwy_app_wait_set_fraction(0.0))
break;
}
else if (status.state == GWY_WSHED_LOCATE) {
if (status.state != oldstate)
gwy_app_wait_set_message(_("Locating"));
if (!gwy_app_wait_set_fraction((gdouble)status.internal_i
/(gdouble)args->locate_steps))
break;
}
else if (status.state == GWY_WSHED_WSHED) {
if (status.state != oldstate)
gwy_app_wait_set_message(_("Watershed"));
if (!gwy_app_wait_set_fraction((gdouble)status.internal_i
/(gdouble)args->wshed_steps))
break;
}
else if (status.state == GWY_WSHED_MARK) {
gwy_app_wait_set_message(_("Marking boundaries"));
if (!gwy_app_wait_set_fraction(0.0))
break;
}
oldstate = status.state;
} while (status.state != GWY_WSHED_FINISHED);
gwy_app_wait_finish();
return status.state == GWY_WSHED_FINISHED;
}
static void
maskcor_do(MaskcorArgs *args)
{
enum { WORK_PER_UPDATE = 50000000 };
GwyDataField *dfield, *kernel, *retfield, *score;
GwyContainer *data, *kerneldata;
GwyComputationState *state;
GQuark quark;
gint newid, work, wpi;
kerneldata = gwy_app_data_browser_get(args->kernel.datano);
quark = gwy_app_get_data_key_for_id(args->kernel.id);
kernel = GWY_DATA_FIELD(gwy_container_get_object(kerneldata, quark));
data = gwy_app_data_browser_get(args->data.datano);
quark = gwy_app_get_data_key_for_id(args->data.id);
dfield = GWY_DATA_FIELD(gwy_container_get_object(data, quark));
retfield = gwy_data_field_new_alike(dfield, FALSE);
/* FIXME */
if (args->method == GWY_CORRELATION_NORMAL) {
gwy_app_wait_start(gwy_app_find_window_for_channel(data, args->data.id),
_("Initializing..."));
state = gwy_data_field_correlate_init(dfield, kernel, retfield);
gwy_app_wait_set_message(_("Correlating..."));
work = 0;
wpi = gwy_data_field_get_xres(kernel)*gwy_data_field_get_yres(kernel);
wpi = MIN(wpi, WORK_PER_UPDATE);
do {
gwy_data_field_correlate_iteration(state);
work += wpi;
if (work > WORK_PER_UPDATE) {
work -= WORK_PER_UPDATE;
if (!gwy_app_wait_set_fraction(state->fraction)) {
gwy_data_field_correlate_finalize(state);
gwy_app_wait_finish();
g_object_unref(retfield);
return;
}
}
} while (state->state != GWY_COMPUTATION_STATE_FINISHED);
gwy_data_field_correlate_finalize(state);
gwy_app_wait_finish();
}
else
gwy_data_field_correlate(dfield, kernel, retfield, args->method);
/* score - do new data with score */
if (args->result == GWY_MASKCOR_SCORE) {
score = gwy_data_field_duplicate(retfield);
newid = gwy_app_data_browser_add_data_field(score, data, TRUE);
gwy_app_sync_data_items(data, data,
args->data.id, newid, FALSE,
GWY_DATA_ITEM_GRADIENT, 0);
gwy_app_set_data_field_title(data, newid,
_("Correlation score"));
g_object_unref(score);
gwy_app_channel_log_add_proc(data, args->data.id, newid);
}
else {
/* add mask */
quark = gwy_app_get_mask_key_for_id(args->data.id);
gwy_app_undo_qcheckpointv(data, 1, &quark);
if (args->result == GWY_MASKCOR_OBJECTS)
plot_correlated(retfield,
gwy_data_field_get_xres(kernel),
gwy_data_field_get_yres(kernel),
args->threshold);
else if (args->result == GWY_MASKCOR_MAXIMA)
gwy_data_field_threshold(retfield, args->threshold, 0.0, 1.0);
gwy_container_set_object(data, quark, retfield);
gwy_app_channel_log_add_proc(data, args->data.id, args->data.id);
}
g_object_unref(retfield);
}
