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 GwyDataField*
median_background(gint size,
GwyDataField *dfield)
{
GwyDataField *rfield;
gint *circle;
gdouble *data, *rdata, *buffer;
gint i, j, xres, yres, buflen;
data = gwy_data_field_get_data(dfield);
rfield = gwy_data_field_duplicate(dfield);
xres = gwy_data_field_get_xres(rfield);
yres = gwy_data_field_get_yres(rfield);
rdata = gwy_data_field_get_data(rfield);
buflen = 0;
circle = median_make_circle(size);
for (i = 0; i < 2*size + 1; i++)
buflen += 2*circle[i] + 1;
buffer = g_new(gdouble, buflen);
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++) {
gint n, k, from, to;
n = 0;
for (k = MAX(0, i - size); k <= MIN(yres - 1, i + size); k++) {
gdouble *row = data + k*xres;
from = MAX(0, j - circle[k - i + size]);
to = MIN(xres - 1, j + circle[k - i + size]);
memcpy(buffer + n, row + from, (to - from + 1)*sizeof(gdouble));
n += to - from + 1;
}
rdata[i*xres + j] = gwy_math_median(n, buffer);
}
if (i % 10 == 0
&& !gwy_app_wait_set_fraction((gdouble)i/yres)) {
g_free(circle);
g_object_unref(rfield);
return NULL;
}
}
g_free(circle);
return rfield;
}
/* 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;
}
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
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);
}
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);
}
