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);
}
/**
* gwy_data_field_correlate_iteration:
* @state: Correlation iterator.
*
* Performs one iteration of correlation.
*
* An iterator can be created with gwy_data_field_correlate_init().
* When iteration ends, either by finishing or being aborted,
* gwy_data_field_correlate_finalize() must be called to release allocated
* resources.
**/
void
gwy_data_field_correlate_iteration(GwyComputationState *cstate)
{
GwyCorrelationState *state = (GwyCorrelationState*)cstate;
gint xres, yres, kxres, kyres, k, xoff, yoff;
gdouble s, davg, drms;
xres = state->data_field->xres;
yres = state->data_field->yres;
kxres = state->kernel_field->xres;
kyres = state->kernel_field->yres;
xoff = (kxres - 1)/2;
yoff = (kyres - 1)/2;
if (state->cs.state == GWY_COMPUTATION_STATE_INIT) {
gwy_data_field_fill(state->score, -1);
state->kavg = gwy_data_field_get_avg(state->kernel_field);
state->krms = gwy_data_field_get_rms(state->kernel_field);
state->avg = gwy_data_field_duplicate(state->data_field);
state->rms = gwy_data_field_duplicate(state->data_field);
calculate_normalization(state->avg, state->rms, kxres, kyres);
state->cs.state = GWY_COMPUTATION_STATE_ITERATE;
state->cs.fraction = 0.0;
state->i = yoff;
state->j = xoff;
}
else if (state->cs.state == GWY_COMPUTATION_STATE_ITERATE) {
k = state->i*xres + state->j;
davg = state->avg->data[k];
drms = state->rms->data[k];
if (drms && state->krms) {
s = gwy_data_field_get_raw_correlation_score(state->data_field,
state->kernel_field,
state->j - xoff,
state->i - yoff,
0, 0,
kxres, kyres,
davg, state->kavg);
state->score->data[k] = s/(drms*state->krms);
}
else
state->score->data[k] = 0.0;
state->j++;
if (state->j + kxres - xoff > xres) {
state->j = xoff;
state->i++;
if (state->i + kyres - yoff > yres)
state->cs.state = GWY_COMPUTATION_STATE_FINISHED;
}
state->cs.fraction += 1.0/((xres - kxres + 1)*(yres - kyres + 1));
state->cs.fraction = MIN(state->cs.fraction, 1.0);
}
else if (state->cs.state == GWY_COMPUTATION_STATE_FINISHED)
return;
gwy_data_field_invalidate(state->score);
}
static GwyDataField*
sphrev_vertical(Sphrev1DArgs *args,
GwyDataField *dfield)
{
GwyDataField *rfield;
GwyDataLine *sphere;
gdouble *data, *rdata, *sphdata, *sum, *sum2, *weight, *tmp;
gdouble q;
gint i, j, k, size, xres, yres;
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);
q = gwy_data_field_get_rms(dfield)/sqrt(2.0/3.0 - G_PI/16.0);
sphere = sphrev_make_sphere(args->size, gwy_data_field_get_yres(dfield));
/* Scale-freeing.
* Data is normalized to have the same RMS as if it was composed from
* spheres of radius args->radius. Actually we normalize the sphere
* instead, but the effect is the same. */
gwy_data_line_multiply(sphere, -q);
sphdata = gwy_data_line_get_data(sphere);
size = gwy_data_line_get_res(sphere)/2;
sum = g_new(gdouble, 4*yres);
sum2 = sum + yres;
weight = sum + 2*yres;
tmp = sum + 3*yres;
/* Weights for RMS filter. The xresl-proof way is to sum 1's. */
for (j = 0; j < yres; j++)
weight[j] = 1.0;
moving_sums(yres, weight, sum, size);
memcpy(weight, sum, yres*sizeof(gdouble));
for (i = 0; i < xres; i++) {
gdouble *rcol = rdata + i;
gdouble *dcol = data + i;
/* Kill data that stick down too much */
for (j = 0; j < yres; j++)
tmp[j] = dcol[j*xres];
moving_sums(yres, tmp, sum, size);
for (j = 0; j < yres; j++) {
/* transform to avg - 2.5*rms */
sum[j] = sum[j]/weight[j];
sum2[j] = 2.5*sqrt(sum2[j]/weight[j] - sum[j]*sum[j]);
sum[j] -= sum2[j];
}
for (j = 0; j < yres; j++)
tmp[j] = MAX(dcol[j*xres], sum[j]);
/* Find the touching point */
for (j = 0; j < yres; j++) {
gdouble *col = tmp + j;
gint from, to, km;
gdouble min;
from = MAX(0, j-size) - j;
to = MIN(j+size, yres-1) - j;
min = G_MAXDOUBLE;
km = 0;
for (k = from; k <= to; k++) {
if (-(sphdata[size+k] - col[k]) < min) {
min = -(sphdata[size+k] - col[k]);
km = k;
}
}
rcol[j*xres] = min;
}
}
g_free(sum);
g_object_unref(sphere);
return rfield;
}
static gboolean
noise_synth_dialog(NoiseSynthArgs *args,
GwyDimensionArgs *dimsargs,
GwyContainer *data,
GwyDataField *dfield_template,
gint id)
{
GtkWidget *dialog, *table, *vbox, *hbox, *notebook, *label;
NoiseSynthControls controls;
GwyDataField *dfield;
GwyPixmapLayer *layer;
gboolean finished;
gint response;
gint row;
gwy_clear(&controls, 1);
controls.in_init = TRUE;
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Random Noise"),
NULL, 0,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
gwy_help_add_to_proc_dialog(GTK_DIALOG(dialog), GWY_HELP_DEFAULT);
controls.dialog = dialog;
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
vbox = gtk_vbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(hbox), vbox, FALSE, FALSE, 4);
controls.mydata = gwy_container_new();
dfield = gwy_data_field_new(PREVIEW_SIZE, PREVIEW_SIZE,
dimsargs->measure*PREVIEW_SIZE,
dimsargs->measure*PREVIEW_SIZE,
TRUE);
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
controls.noise = gwy_data_field_new_alike(dfield, FALSE);
if (dfield_template) {
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
0);
controls.surface = gwy_synth_surface_for_preview(dfield_template,
PREVIEW_SIZE);
controls.zscale = gwy_data_field_get_rms(dfield_template);
}
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",
NULL);
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
gtk_box_pack_start(GTK_BOX(vbox), controls.view, FALSE, FALSE, 0);
gtk_box_pack_start(GTK_BOX(vbox),
gwy_synth_instant_updates_new(&controls,
&controls.update_now,
&controls.update,
&args->update),
FALSE, FALSE, 0);
g_signal_connect_swapped(controls.update_now, "clicked",
G_CALLBACK(preview), &controls);
gtk_box_pack_start(GTK_BOX(vbox),
gwy_synth_random_seed_new(&controls,
&controls.seed, &args->seed),
FALSE, FALSE, 0);
controls.randomize = gwy_synth_randomize_new(&args->randomize);
gtk_box_pack_start(GTK_BOX(vbox), controls.randomize, FALSE, FALSE, 0);
notebook = gtk_notebook_new();
gtk_box_pack_start(GTK_BOX(hbox), notebook, TRUE, TRUE, 4);
g_signal_connect_swapped(notebook, "switch-page",
G_CALLBACK(page_switched), &controls);
controls.dims = gwy_dimensions_new(dimsargs, dfield_template);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook),
gwy_dimensions_get_widget(controls.dims),
gtk_label_new(_("Dimensions")));
if (controls.dims->add)
g_signal_connect_swapped(controls.dims->add, "toggled",
G_CALLBACK(noise_synth_invalidate), &controls);
table = gtk_table_new(6 + (dfield_template ? 1 : 0), 4, FALSE);
controls.table = GTK_TABLE(table);
gtk_table_set_row_spacings(controls.table, 2);
gtk_table_set_col_spacings(controls.table, 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_notebook_append_page(GTK_NOTEBOOK(notebook), table,
gtk_label_new(_("Generator")));
row = 0;
controls.distribution = distribution_selector_new(&controls);
gwy_table_attach_hscale(table, row, _("_Distribution:"), NULL,
GTK_OBJECT(controls.distribution),
GWY_HSCALE_WIDGET);
row++;
label = gtk_label_new(_("Direction:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label, 0, 1, row, row+1,
GTK_FILL, 0, 0, 0);
row++;
controls.direction
= gwy_radio_buttons_createl(G_CALLBACK(direction_type_changed),
&controls, args->direction,
_("S_ymmetrical"), NOISE_DIRECTION_BOTH,
_("One-sided _positive"), NOISE_DIRECTION_UP,
_("One-sided _negative"), NOISE_DIRECTION_DOWN,
NULL);
row = gwy_radio_buttons_attach_to_table(controls.direction,
GTK_TABLE(table), 3, row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
row = gwy_synth_attach_height(&controls, row,
&controls.sigma, &args->sigma,
_("_RMS:"), NULL, &controls.sigma_units);
if (dfield_template) {
controls.sigma_init
= gtk_button_new_with_mnemonic(_("_Like Current Channel"));
g_signal_connect_swapped(controls.sigma_init, "clicked",
G_CALLBACK(sigma_init_clicked), &controls);
gtk_table_attach(GTK_TABLE(table), controls.sigma_init,
1, 3, row, row+1, GTK_FILL, 0, 0, 0);
row++;
}
gtk_widget_show_all(dialog);
controls.in_init = FALSE;
/* Must be done when widgets are shown, see GtkNotebook docs */
gtk_notebook_set_current_page(GTK_NOTEBOOK(notebook), args->active_page);
update_values(&controls);
noise_synth_invalidate(&controls);
finished = FALSE;
while (!finished) {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
case GTK_RESPONSE_OK:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
finished = TRUE;
break;
case RESPONSE_RESET:
{
gboolean temp = args->update;
gint temp2 = args->active_page;
*args = noise_synth_defaults;
args->active_page = temp2;
args->update = temp;
}
controls.in_init = TRUE;
update_controls(&controls, args);
controls.in_init = FALSE;
if (args->update)
preview(&controls);
break;
default:
g_assert_not_reached();
break;
}
}
if (controls.sid) {
g_source_remove(controls.sid);
controls.sid = 0;
}
g_object_unref(controls.mydata);
gwy_object_unref(controls.surface);
gwy_object_unref(controls.noise);
gwy_dimensions_free(controls.dims);
return response == GTK_RESPONSE_OK;
}
/**
* gwy_data_field_correlate:
* @data_field: A data field.
* @kernel_field: Correlation kernel.
* @score: Data field to store correlation scores to.
* @method: Correlation score calculation method.
*
* Computes correlation score for all positions in a data field.
*
* Correlation score is compute for all points in data field @data_field
* and full size of correlation kernel @kernel_field.
*
* The points in @score correspond to centers of kernel. More precisely, the
* point ((@kxres-1)/2, (@kyres-1)/2) in @score corresponds to kernel field
* top left corner coincident with data field top left corner. Points outside
* the area where the kernel field fits into the data field completely are
* set to -1 for %GWY_CORRELATION_NORMAL.
**/
void
gwy_data_field_correlate(GwyDataField *data_field, GwyDataField *kernel_field,
GwyDataField *score, GwyCorrelationType method)
{
gint xres, yres, kxres, kyres, i, j, k, fftxres, fftyres;
GwyDataField *data_in_re, *data_out_re, *data_out_im;
GwyDataField *kernel_in_re, *kernel_out_re, *kernel_out_im;
gdouble norm;
g_return_if_fail(data_field != NULL && kernel_field != NULL);
xres = data_field->xres;
yres = data_field->yres;
kxres = kernel_field->xres;
kyres = kernel_field->yres;
if (kxres <= 0 || kyres <= 0) {
g_warning("Correlation kernel has nonpositive size.");
return;
}
switch (method) {
case GWY_CORRELATION_NORMAL:
gwy_data_field_fill(score, -1);
/*correlation request outside kernel */
if (kxres > xres || kyres > yres) {
return;
}
{
GwyDataField *avg, *rms;
gdouble s, davg, drms, kavg, krms;
gint xoff, yoff;
/* The number of pixels the correlation kernel extends to the
* negative direction */
xoff = (kxres - 1)/2;
yoff = (kyres - 1)/2;
kavg = gwy_data_field_get_avg(kernel_field);
krms = gwy_data_field_get_rms(kernel_field);
avg = gwy_data_field_duplicate(data_field);
rms = gwy_data_field_duplicate(data_field);
calculate_normalization(avg, rms, kxres, kyres);
for (i = yoff; i + kyres - yoff <= yres; i++) {
for (j = xoff; j + kxres - xoff <= xres; j++) {
k = i*xres + j;
davg = avg->data[k];
drms = rms->data[k];
if (!krms || !drms) {
score->data[k] = 0.0;
continue;
}
s = gwy_data_field_get_raw_correlation_score(data_field,
kernel_field,
j - xoff,
i - yoff,
0, 0,
kxres, kyres,
davg, kavg);
score->data[k] = s/(drms*krms);
}
}
g_object_unref(avg);
g_object_unref(rms);
}
break;
case GWY_CORRELATION_FFT:
case GWY_CORRELATION_POC:
fftxres = gwy_fft_find_nice_size(xres);
fftyres = gwy_fft_find_nice_size(yres);
data_in_re = gwy_data_field_new_resampled(data_field,
fftxres, fftyres,
GWY_INTERPOLATION_BILINEAR);
kernel_in_re = gwy_data_field_new_alike(data_field, TRUE);
gwy_data_field_area_copy(kernel_field, kernel_in_re,
0, 0, kernel_field->xres, kernel_field->yres,
kernel_in_re->xres/2 - kernel_field->xres/2,
kernel_in_re->yres/2 - kernel_field->yres/2);
gwy_data_field_resample(kernel_in_re, fftxres, fftyres,
GWY_INTERPOLATION_BILINEAR);
gwy_data_field_resample(score, fftxres, fftyres,
GWY_INTERPOLATION_NONE);
data_out_re = gwy_data_field_new_alike(data_in_re, TRUE);
data_out_im = gwy_data_field_new_alike(data_in_re, TRUE);
kernel_out_re = gwy_data_field_new_alike(data_in_re, TRUE);
kernel_out_im = gwy_data_field_new_alike(data_in_re, TRUE);
gwy_data_field_2dfft(data_in_re, NULL, data_out_re, data_out_im,
GWY_WINDOWING_NONE,
GWY_TRANSFORM_DIRECTION_FORWARD,
GWY_INTERPOLATION_BILINEAR, FALSE, FALSE);
gwy_data_field_2dfft(kernel_in_re, NULL, kernel_out_re, kernel_out_im,
GWY_WINDOWING_NONE,
GWY_TRANSFORM_DIRECTION_FORWARD,
GWY_INTERPOLATION_BILINEAR, FALSE, FALSE);
for (i = 0; i < fftxres*fftyres; i++) {
/*NOTE: now we construct new "complex field" from data
* and kernel fields, just to save memory*/
data_in_re->data[i] = data_out_re->data[i]*kernel_out_re->data[i]
+ data_out_im->data[i]*kernel_out_im->data[i];
kernel_in_re->data[i] = -data_out_re->data[i]*kernel_out_im->data[i]
+ data_out_im->data[i]*kernel_out_re->data[i];
if (method == GWY_CORRELATION_POC) {
norm = hypot(data_in_re->data[i], kernel_in_re->data[i]);
data_in_re->data[i] /= norm;
kernel_in_re->data[i] /= norm;
}
}
gwy_data_field_2dfft(data_in_re, kernel_in_re, score, data_out_im,
GWY_WINDOWING_NONE,
GWY_TRANSFORM_DIRECTION_BACKWARD,
GWY_INTERPOLATION_BILINEAR, FALSE, FALSE);
gwy_data_field_2dfft_humanize(score);
/*TODO compute it and put to score field*/
g_object_unref(data_in_re);
g_object_unref(data_out_re);
g_object_unref(data_out_im);
g_object_unref(kernel_in_re);
g_object_unref(kernel_out_re);
g_object_unref(kernel_out_im);
break;
}
gwy_data_field_invalidate(score);
}
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);
}