static void
facet_view_recompute(GtkAdjustment *adj,
FacetsControls *controls)
{
GwyVectorLayer *layer;
GwyDataField *dfield;
GwySelection *selection;
const gchar *key;
controls->args->kernel_size = gwy_adjustment_get_int(adj);
gwy_app_wait_cursor_start(GTK_WINDOW(controls->dialog));
dfield = gwy_container_get_object_by_name(controls->mydata, "/0/data");
gwy_data_field_facet_distribution(dfield, 2*controls->args->kernel_size + 1,
controls->fdata);
/* XXX: Clear selections since we cannot recalculate it properly */
if (gwy_container_gis_object_by_name(controls->mydata, "/0/mask",
&dfield)) {
gwy_data_field_clear(dfield);
gwy_data_field_data_changed(dfield);
}
layer = gwy_data_view_get_top_layer(GWY_DATA_VIEW(controls->fview));
key = gwy_vector_layer_get_selection_key(layer);
selection = gwy_container_get_object_by_name(controls->fdata, key);
gwy_selection_clear(selection);
gwy_app_wait_cursor_finish(GTK_WINDOW(controls->dialog));
facets_invalidate(controls);
}
static gboolean
wshed_ok(WshedControls *controls,
WshedArgs *args,
GwyContainer *data)
{
GwyDataField *dfield;
GObject *maskfield;
if (controls->computed) {
maskfield = gwy_container_get_object_by_name(controls->mydata,
"/0/mask");
gwy_app_undo_checkpoint(data, "/0/mask", NULL);
gwy_container_set_object_by_name(data, "/0/mask", maskfield);
return TRUE;
}
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
maskfield = gwy_serializable_duplicate(G_OBJECT(dfield));
if (mask_process(dfield, GWY_DATA_FIELD(maskfield), args,
GTK_WIDGET(gwy_app_data_window_get_for_data(data)))) {
gwy_app_undo_checkpoint(data, "/0/mask", NULL);
gwy_container_set_object_by_name(data, "/0/mask", maskfield);
controls->computed = TRUE;
}
g_object_unref(maskfield);
return controls->computed;
}
static void
unrotate_dialog_update(UnrotateControls *controls,
UnrotateArgs *args)
{
gchar *lab;
GwyPlaneSymmetry symm;
GwyDataField *dfield, *rfield;
GwyContainer *data;
gdouble phi;
gwy_enum_combo_box_set_active(GTK_COMBO_BOX(controls->interp),
args->interp);
gwy_enum_combo_box_set_active(GTK_COMBO_BOX(controls->symmetry),
args->symmetry);
symm = args->symmetry ? args->symmetry : controls->guess;
phi = controls->correction[symm];
lab = g_strdup_printf("%.2f %s", 180.0/G_PI*phi, _("deg"));
gtk_label_set_text(GTK_LABEL(controls->corrlabel), lab);
g_free(lab);
data = gwy_data_view_get_data(GWY_DATA_VIEW(controls->data_view));
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
rfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/show"));
gwy_data_field_copy(dfield, rfield, FALSE);
gwy_data_field_rotate(rfield, phi, args->interp);
gwy_data_field_data_changed(rfield);
}
static void
preview(FacetsControls *controls,
FacetsArgs *args)
{
GwyDataField *dtheta, *dphi, *mask, *mfield = NULL;
GwyContainer *data, *fdata;
data = controls->mydata;
fdata = controls->fdata;
add_mask_field(GWY_DATA_VIEW(controls->view), NULL);
add_mask_field(GWY_DATA_VIEW(controls->fview), &mask_color);
mask = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/mask"));
dtheta = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/theta"));
dphi = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/phi"));
gwy_container_gis_object_by_name(fdata, "/1/mask", (GObject**)&mfield);
gwy_data_field_mark_facets(dtheta, dphi, args->theta0, args->phi0,
args->tolerance, mask);
if (mfield && args->combine) {
if (args->combine_type == GWY_MERGE_UNION)
gwy_data_field_grains_add(mask, mfield);
else if (args->combine_type == GWY_MERGE_INTERSECTION)
gwy_data_field_grains_intersect(mask, mfield);
}
gwy_data_field_data_changed(mask);
facets_mark_fdata(args, fdata);
}
static void
curvature_update_preview(CurvatureControls *controls,
CurvatureArgs *args)
{
GwyDataField *source, *mask = NULL;
GwySelection *selection;
Intersection i1[2], i2[2];
gboolean ok;
guint i;
source = gwy_container_get_object_by_name(controls->data, "/0/data");
selection = gwy_container_get_object_by_name(controls->data,
"/0/select/line");
gwy_container_gis_object_by_name(controls->data, "/0/mask", &mask);
ok = curvature_calculate(source, mask, args, controls->params, i1, i2);
for (i = 0; i < PARAM_NPARAMS; i++)
gwy_null_store_row_changed(controls->paramstore, i);
if (ok) {
curvature_set_selection(source, i1, i2, selection);
curvature_plot_graph(source, i1, i2, controls->gmodel);
gtk_label_set_text(GTK_LABEL(controls->warning), "");
}
else {
gwy_selection_clear(selection);
gwy_graph_model_remove_all_curves(controls->gmodel);
gtk_label_set_text(GTK_LABEL(controls->warning),
_("Axes are outside the image."));
}
update_target_graphs(controls);
}
static void
preview_selection_updated(GwySelection *selection,
G_GNUC_UNUSED gint id,
FacetsControls *controls)
{
GwyDataField *dfield;
gdouble theta, phi, xy[2];
gint i, j;
if (controls->in_update)
return;
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/data"));
if (!gwy_selection_get_object(selection, 0, xy))
return;
j = gwy_data_field_rtoj(dfield, xy[0]);
i = gwy_data_field_rtoi(dfield, xy[1]);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->fdata,
"/theta"));
theta = gwy_data_field_get_val(dfield, j, i);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->fdata,
"/phi"));
phi = gwy_data_field_get_val(dfield, j, i);
facet_view_select_angle(controls, theta, phi);
}
static void
run_noninteractive(FacetsArgs *args,
GwyContainer *data,
GwyContainer *fdata,
GwyDataField *dfield,
GwyDataField *mfield,
GQuark mquark)
{
GwyDataField *dtheta, *dphi, *mask;
gwy_app_undo_qcheckpointv(data, 1, &mquark);
mask = create_mask_field(dfield);
dtheta = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/theta"));
dphi = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/phi"));
gwy_data_field_mark_facets(dtheta, dphi, args->theta0, args->phi0,
args->tolerance, mask);
if (mfield && args->combine) {
if (args->combine_type == GWY_MERGE_UNION)
gwy_data_field_grains_add(mfield, mask);
else if (args->combine_type == GWY_MERGE_INTERSECTION)
gwy_data_field_grains_intersect(mfield, mask);
gwy_data_field_data_changed(mfield);
}
else if (mfield) {
gwy_data_field_copy(mask, mfield, FALSE);
gwy_data_field_data_changed(mfield);
}
else {
gwy_container_set_object(data, mquark, mask);
}
g_object_unref(mask);
}
static void
rotate_preview_draw(RotateControls *controls,
RotateArgs *args)
{
GwyDataField *dfield, *rfield;
GwyContainer *data;
data = gwy_data_view_get_data(GWY_DATA_VIEW(controls->data_view));
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
rfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/show"));
gwy_data_field_copy(dfield, rfield, FALSE);
gwy_data_field_rotate(rfield, args->angle, args->interp);
gwy_data_field_data_changed(rfield);
}
static void
facet_view_selection_updated(GwySelection *selection,
G_GNUC_UNUSED gint id,
FacetsControls *controls)
{
GwyVectorLayer *layer;
const gchar *key;
gdouble theta, phi, x, y, q, xy[2];
gchar s[24];
q = gwy_container_get_double_by_name(controls->fdata, "/q");
gwy_selection_get_object(selection, 0, xy);
x = xy[0] - G_SQRT2/q;
y = xy[1] - G_SQRT2/q;
xy_to_angles(x, y, &theta, &phi);
g_snprintf(s, sizeof(s), "%.2f deg", 180.0/G_PI*theta);
gtk_label_set_text(GTK_LABEL(controls->theta_label), s);
controls->args->theta0 = theta;
g_snprintf(s, sizeof(s), "%.2f deg", 180.0/G_PI*phi);
gtk_label_set_text(GTK_LABEL(controls->phi_label), s);
controls->args->phi0 = phi;
if (!controls->in_update) {
layer = gwy_data_view_get_top_layer(GWY_DATA_VIEW(controls->view));
key = gwy_vector_layer_get_selection_key(layer);
selection = gwy_container_get_object_by_name(controls->mydata, key);
if (gwy_selection_get_data(selection, NULL))
gwy_selection_clear(selection);
}
controls->computed = FALSE;
}
static gboolean
prewitt_vertical(GwyContainer *data, GwyRunType run)
{
GObject *shadefield;
GwyDataField *dfield;
g_assert(run & GRADIENT_RUN_MODES);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
gwy_app_undo_checkpoint(data, "/0/show", NULL);
if (gwy_container_gis_object_by_name(data, "/0/show", &shadefield)) {
gwy_data_field_resample(GWY_DATA_FIELD(shadefield),
gwy_data_field_get_xres(dfield),
gwy_data_field_get_yres(dfield),
GWY_INTERPOLATION_NONE);
}
else {
shadefield = gwy_serializable_duplicate(G_OBJECT(dfield));
gwy_container_set_object_by_name(data, "/0/show", shadefield);
g_object_unref(shadefield);
}
gwy_data_field_area_copy(dfield, GWY_DATA_FIELD(shadefield),
0, 0, gwy_data_field_get_xres(dfield),
gwy_data_field_get_yres(dfield), 0, 0);
gwy_data_field_area_filter_prewitt(GWY_DATA_FIELD(shadefield), GTK_ORIENTATION_VERTICAL,
0, 0,
gwy_data_field_get_xres(dfield),
gwy_data_field_get_yres(dfield));
return TRUE;
}
static gboolean
outliers(GwyContainer *data, GwyRunType run)
{
GObject *maskfield;
GwyDataField *dfield;
gdouble thresh;
g_assert(run & OUTLIERS_RUN_MODES);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
gwy_app_undo_checkpoint(data, "/0/mask", NULL);
if (!gwy_container_gis_object_by_name(data, "/0/mask", &maskfield)) {
maskfield = gwy_data_field_new(gwy_data_field_get_xres(dfield),
gwy_data_field_get_yres(dfield),
gwy_data_field_get_xreal(dfield),
gwy_data_field_get_yreal(dfield),
TRUE);
gwy_container_set_object_by_name(data, "/0/mask", maskfield);
g_object_unref(maskfield);
}
thresh = 3.0;
gwy_data_field_mask_outliers(dfield, GWY_DATA_FIELD(maskfield), thresh);
return TRUE;
}
static gboolean
asciiexport_save(GwyContainer *data,
const gchar *filename)
{
GwyDataField *dfield;
gint xres, yres, i, j;
gdouble *d;
FILE *fh;
if (!(fh = fopen(filename, "w")))
return FALSE;
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
d = gwy_data_field_get_data(dfield);
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++) {
if (fprintf(fh, "%g%c", d[i*xres + j],
j == xres-1 ? '\n' : '\t') < 2) {
unlink(filename);
return FALSE;
}
}
}
fclose(fh);
return TRUE;
}
static void
preview(GEdgeControls *controls,
GEdgeArgs *args)
{
GwyDataField *mask, *dfield;
GwyPixmapLayer *layer;
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/data"));
/* Set up the mask */
if (!gwy_container_gis_object_by_name(controls->mydata, "/0/mask", &mask)) {
mask = create_mask_field(dfield);
gwy_container_set_object_by_name(controls->mydata, "/0/mask", mask);
g_object_unref(mask);
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_data_field_copy(dfield, mask, FALSE);
gedge_process(dfield, mask, args);
gwy_data_field_data_changed(mask);
}
static void
preview(WshedControls *controls,
WshedArgs *args)
{
GwyDataField *maskfield, *dfield;
GwyPixmapLayer *layer;
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/data"));
/*set up the mask*/
if (gwy_container_contains_by_name(controls->mydata, "/0/mask")) {
maskfield
= GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/mask"));
gwy_data_field_resample(maskfield,
gwy_data_field_get_xres(dfield),
gwy_data_field_get_yres(dfield),
GWY_INTERPOLATION_NONE);
gwy_data_field_copy(dfield, maskfield);
if (!gwy_data_view_get_alpha_layer(GWY_DATA_VIEW(controls->view))) {
layer = GWY_PIXMAP_LAYER(gwy_layer_mask_new());
gwy_data_view_set_alpha_layer(GWY_DATA_VIEW(controls->view),
layer);
}
}
else {
maskfield
= GWY_DATA_FIELD(gwy_serializable_duplicate(G_OBJECT(dfield)));
gwy_container_set_object_by_name(controls->mydata, "/0/mask",
G_OBJECT(maskfield));
g_object_unref(maskfield);
layer = GWY_PIXMAP_LAYER(gwy_layer_mask_new());
gwy_data_view_set_alpha_layer(GWY_DATA_VIEW(controls->view),
layer);
}
wshed_dialog_update_values(controls, args);
controls->computed = mask_process(dfield, maskfield, args,
controls->dialog);
if (controls->computed)
gwy_data_view_update(GWY_DATA_VIEW(controls->view));
}
static void
fix_scales(EZDSection *section,
gint idx,
GwyContainer *container)
{
GwyDataField *dfield;
GwySIUnit *siunit;
gchar key[40];
gint power10;
gdouble r;
g_snprintf(key, sizeof(key), "/%d/data", idx);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(container, key));
/* Fix value scale */
siunit = gwy_si_unit_new_parse(section->zrange.unit, &power10);
gwy_data_field_set_si_unit_z(dfield, siunit);
g_object_unref(siunit);
r = pow10(power10);
gwy_data_field_multiply(dfield, r*section->zrange.range);
gwy_data_field_add(dfield, r*section->zrange.min);
/* Fix lateral scale */
siunit = gwy_si_unit_new_parse(section->xrange.unit, &power10);
gwy_data_field_set_si_unit_xy(dfield, siunit);
g_object_unref(siunit);
gwy_data_field_set_xreal(dfield, pow10(power10)*section->xrange.range);
siunit = gwy_si_unit_new_parse(section->yrange.unit, &power10);
gwy_data_field_set_yreal(dfield, pow10(power10)*section->yrange.range);
g_object_unref(siunit);
/* Some metadata */
if (section->zrange.name) {
const gchar *s;
switch (section->direction) {
case SCAN_FORWARD:
s = " forward";
break;
case SCAN_BACKWARD:
s = " backward";
break;
default:
s = "";
break;
}
g_snprintf(key, sizeof(key), "/%d/data/title", idx);
gwy_container_set_string_by_name(container, key,
g_strdup_printf("%s%s",
section->zrange.name,
s));
}
}
static void
preview(GFilterControls *controls)
{
GwyDataField *mfield;
mfield = gwy_container_get_object_by_name(controls->mydata, "/0/mask");
gfilter_process(mfield, controls->args);
gwy_data_field_data_changed(mfield);
controls->computed = TRUE;
}
static gboolean
height_dist(GwyContainer *data, GwyRunType run)
{
GString *lab;
GtkWidget *graph;
GwyDataWindow *data_window;
GwyGraphAutoProperties prop;
GwyDataLine *dataline;
GwyDataField *dfield;
GwyDataField *mfield;
GwySIValueFormat *units;
g_return_val_if_fail(run & DIST_RUN_MODES, FALSE);
g_return_val_if_fail(gwy_container_contains_by_name(data, "/0/mask"),
FALSE);
graph = gwy_graph_new();
gwy_graph_get_autoproperties(GWY_GRAPH(graph), &prop);
prop.is_point = 0;
prop.is_line = 1;
gwy_graph_set_autoproperties(GWY_GRAPH(graph), &prop);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
mfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/mask"));
dataline = (GwyDataLine*)gwy_data_line_new(10, 10, TRUE);
gwy_data_field_grains_get_height_distribution(dfield, mfield, dataline);
lab = g_string_new(_("Grain height histogram"));
units = gwy_si_unit_get_format(dfield->si_unit_xy, dataline->real, NULL);
gwy_graph_add_dataline_with_units(GWY_GRAPH(graph), dataline, 0, lab, NULL,
units->magnitude, 1, units->units, " ");
data_window = gwy_app_data_window_get_for_data(data);
gwy_app_graph_window_create_for_window(GWY_GRAPH(graph), data_window,
_("Grain height distribution"));
g_string_free(lab, TRUE);
g_object_unref(dataline);
g_free(units);
return FALSE;
}
static GwyContainer*
gwyfile_load(const gchar *filename)
{
GObject *object, *dfield;
GError *err = NULL;
guchar *buffer = NULL;
gsize size = 0;
gsize pos = 0;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
g_warning("Cannot read file %s", filename);
g_clear_error(&err);
return NULL;
}
if (size < MAGIC_SIZE
|| (memcmp(buffer, MAGIC, MAGIC_SIZE)
&& memcmp(buffer, MAGIC2, MAGIC_SIZE))) {
g_warning("File %s doesn't seem to be a .gwy file", filename);
if (!gwy_file_abandon_contents(buffer, size, &err)) {
g_critical("%s", err->message);
g_clear_error(&err);
}
return NULL;
}
if (!memcmp(buffer, MAGIC, MAGIC_SIZE))
object = gwy_serializable_deserialize(buffer + MAGIC_SIZE,
size - MAGIC_SIZE, &pos);
else
object = gwy_container_deserialize2(buffer + MAGIC_SIZE,
size - MAGIC_SIZE, &pos);
if (!gwy_file_abandon_contents(buffer, size, &err)) {
g_critical("%s", err->message);
g_clear_error(&err);
}
if (!object) {
g_warning("File %s deserialization failed", filename);
return NULL;
}
if (!GWY_IS_CONTAINER(object)) {
g_warning("File %s contains some strange object", filename);
g_object_unref(object);
return NULL;
}
dfield = gwy_container_get_object_by_name(GWY_CONTAINER(object), "/0/data");
if (!dfield || !GWY_IS_DATA_FIELD(dfield)) {
g_warning("File %s contains no data field", filename);
g_object_unref(object);
return NULL;
}
return (GwyContainer*)object;
}
static gboolean
tip_dilation_do(TipDilationArgs *args)
{
GtkWidget *data_window;
GwyContainer *data;
GwyDataField *dfield, *dfield1, *dfield2;
GwyDataWindow *operand1, *operand2;
operand1 = args->win1;
operand2 = args->win2;
g_return_val_if_fail(operand1 != NULL && operand2 != NULL, FALSE);
data = gwy_data_window_get_data(operand1);
dfield1 = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
data = gwy_data_window_get_data(operand2);
dfield2 = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
/*result fields - after computation result should be at dfield */
data = gwy_container_duplicate_by_prefix(data,
"/0/data",
"/0/base/palette",
"/0/select",
NULL);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
gwy_app_wait_start(GTK_WIDGET(args->win2), "Initializing...");
dfield = gwy_tip_dilation(dfield1, dfield2, dfield,
gwy_app_wait_set_fraction,
gwy_app_wait_set_message);
gwy_app_wait_finish();
/*set right output */
if (dfield) {
data_window = gwy_app_data_window_create(data);
gwy_app_data_window_set_untitled(GWY_DATA_WINDOW(data_window), NULL);
}
else
g_object_unref(data);
return TRUE;
}
static void
update_average_angle(FacetsControls *controls,
G_GNUC_UNUSED FacetsArgs *args)
{
GwyDataField *dtheta, *dphi, *mask;
gdouble theta, phi;
gchar s[24];
dtheta = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->fdata,
"/theta"));
dphi = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->fdata,
"/phi"));
mask = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/mask"));
calculate_average_angle(dtheta, dphi, mask, &theta, &phi);
g_snprintf(s, sizeof(s), "%.2f deg", 180.0/G_PI*theta);
gtk_label_set_text(GTK_LABEL(controls->mtheta_label), s);
g_snprintf(s, sizeof(s), "%.2f deg", 180.0/G_PI*phi);
gtk_label_set_text(GTK_LABEL(controls->mphi_label), s);
}
static void
run_noninteractive(FacetsArgs *args,
GwyContainer *data,
GwyContainer *fdata,
GwyDataField *dfield,
GwyDataField *mfield,
GQuark mquark)
{
GwyDataField *dtheta, *dphi;
gwy_app_undo_qcheckpointv(data, 1, &mquark);
if (!mfield) {
mfield = create_mask_field(dfield);
gwy_container_set_object(data, mquark, mfield);
g_object_unref(mfield);
}
dtheta = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/theta"));
dphi = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/phi"));
gwy_data_field_mark_facets(dtheta, dphi, args->theta0, args->phi0,
args->tolerance, mfield);
gwy_data_field_data_changed(mfield);
}
static GdkPixbuf*
gwy_layer_basic_paint(GwyPixmapLayer *layer)
{
GwyDataField *data_field;
GwyLayerBasic *basic_layer;
GwyContainer *data;
gdouble min = 0.0, max = 0.0;
gboolean fixedmin, fixedmax;
gboolean fixedrange = FALSE;
gwy_debug(" ");
g_return_val_if_fail(GWY_IS_LAYER_BASIC(layer), NULL);
basic_layer = GWY_LAYER_BASIC(layer);
data = GWY_DATA_VIEW_LAYER(layer)->data;
/* TODO Container */
if (!gwy_container_gis_object_by_name(data, "/0/show",
(GObject**)&data_field)) {
data_field
= GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
fixedrange = TRUE;
}
g_return_val_if_fail(GWY_IS_DATA_FIELD(data_field), layer->pixbuf);
if (fixedrange) {
fixedmin = gwy_container_gis_double_by_name(data, "/0/base/min", &min);
fixedmax = gwy_container_gis_double_by_name(data, "/0/base/max", &max);
if (fixedmin || fixedmax) {
if (!fixedmin)
min = gwy_data_field_get_min(data_field);
if (!fixedmax)
max = gwy_data_field_get_max(data_field);
}
else
fixedrange = FALSE;
}
/* XXX */
/*if (GWY_LAYER_BASIC(layer)->changed)*/ {
if (fixedrange)
gwy_pixbuf_draw_data_field_with_range(layer->pixbuf, data_field,
basic_layer->gradient,
min, max);
else
gwy_pixbuf_draw_data_field(layer->pixbuf, data_field,
basic_layer->gradient);
basic_layer->changed = FALSE;
}
return layer->pixbuf;
}
static void
gwy_data_view_make_pixmap(GwyDataView *data_view)
{
GtkWidget *widget;
GwyDataField *data_field;
gint width, height, scwidth, scheight, src_width, src_height;
data_field = GWY_DATA_FIELD(
gwy_container_get_object_by_name(data_view->data,
"/0/data"));
src_width = gwy_data_field_get_xres(data_field);
src_height = gwy_data_field_get_yres(data_field);
if (!data_view->base_pixbuf) {
data_view->base_pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
FALSE,
BITS_PER_SAMPLE,
src_width, src_height);
gwy_debug_objects_creation(G_OBJECT(data_view->base_pixbuf));
}
if (data_view->pixbuf) {
width = gdk_pixbuf_get_width(data_view->pixbuf);
height = gdk_pixbuf_get_height(data_view->pixbuf);
}
else
width = height = -1;
widget = GTK_WIDGET(data_view);
data_view->zoom = MIN((gdouble)widget->allocation.width/src_width,
(gdouble)widget->allocation.height/src_height);
data_view->newzoom = data_view->zoom;
scwidth = floor(src_width * data_view->zoom + 0.000001);
scheight = floor(src_height * data_view->zoom + 0.000001);
data_view->xmeasure = gwy_data_field_get_xreal(data_field)/scwidth;
data_view->ymeasure = gwy_data_field_get_yreal(data_field)/scheight;
data_view->xoff = (widget->allocation.width - scwidth)/2;
data_view->yoff = (widget->allocation.height - scheight)/2;
if (scwidth != width || scheight != height) {
gwy_object_unref(data_view->pixbuf);
data_view->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB,
FALSE,
BITS_PER_SAMPLE,
scwidth, scheight);
gwy_debug_objects_creation(G_OBJECT(data_view->pixbuf));
gdk_pixbuf_fill(data_view->pixbuf, 0x00000000);
gwy_data_view_paint(data_view);
}
}
static void
preview(FacetsControls *controls,
FacetsArgs *args)
{
GwyDataField *dtheta, *dphi, *dfield, *mfield;
GwyContainer *data, *fdata;
data = controls->mydata;
fdata = controls->fdata;
add_mask_layer(GWY_DATA_VIEW(controls->view), NULL);
add_mask_layer(GWY_DATA_VIEW(controls->fview), &mask_color);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
mfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/mask"));
dtheta = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/theta"));
dphi = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/phi"));
gwy_data_field_mark_facets(dtheta, dphi, args->theta0, args->phi0,
args->tolerance, mfield);
gwy_data_field_data_changed(mfield);
facets_mark_fdata(args, fdata);
facets_invalidate(controls);
}
static gboolean
tip_dilation_check(TipDilationArgs *args,
GtkWidget *tip_dilation_window)
{
GtkWidget *dialog;
GwyContainer *data;
GwyDataField *dfield1, *dfield2;
GwyDataWindow *operand1, *operand2;
operand1 = args->win1;
operand2 = args->win2;
g_return_val_if_fail(GWY_IS_DATA_WINDOW(operand1)
&& GWY_IS_DATA_WINDOW(operand2),
FALSE);
data = gwy_data_window_get_data(operand1);
dfield1 = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
data = gwy_data_window_get_data(operand2);
dfield2 = GWY_DATA_FIELD(gwy_container_get_object_by_name(data, "/0/data"));
if (fabs((dfield1->xreal/dfield1->xres)
/(dfield2->xreal/dfield2->xres) - 1) > 0.01
|| fabs((dfield1->yreal/dfield1->yres)
/(dfield2->yreal/dfield2->yres) - 1) > 0.01) {
dialog = gtk_message_dialog_new(GTK_WINDOW(tip_dilation_window),
GTK_DIALOG_DESTROY_WITH_PARENT,
GTK_MESSAGE_INFO,
GTK_BUTTONS_OK,
_("Tip has different range/resolution "
"ratio than image. Tip will be "
"resampled."));
gtk_dialog_run(GTK_DIALOG(dialog));
gtk_widget_destroy(dialog);
}
return TRUE;
}
static void
tip_update(TipModelControls *controls,
G_GNUC_UNUSED TipModelArgs *args)
{
GwyDataField *vtipfield, *buffer;
buffer = gwy_data_field_duplicate(controls->tip);
gwy_data_field_resample(buffer, controls->vxres, controls->vyres,
GWY_INTERPOLATION_ROUND);
vtipfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->vtip,
"/0/data"));
gwy_data_field_copy(buffer, vtipfield, FALSE);
g_object_unref(buffer);
gwy_data_field_data_changed(vtipfield);
}
static void
preview(NoiseSynthControls *controls)
{
NoiseSynthArgs *args = controls->args;
GwyDataField *dfield;
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/data"));
if (controls->dims->args->add && controls->surface)
gwy_data_field_copy(controls->surface, dfield, FALSE);
else
gwy_data_field_clear(dfield);
noise_synth_do(args, controls->dims->args, dfield);
gwy_data_field_data_changed(dfield);
}
/**
* gwy_set_data_preview_size:
* @data_view: A data view used for module preview.
* @max_size: Maximum allowed @data_view size (width and height).
*
* Sets up data view zoom to not exceed specified size.
*
* Before calling this function, data keys have be set, data fields and layers
* have to be present and physically square mode set in the container.
* Sizing of both pixel-wise square and physically square displays is performed
* correctly.
*
* Since: 2.7
**/
void
gwy_set_data_preview_size(GwyDataView *data_view,
gint max_size)
{
GwyContainer *container;
GwyDataField *data_field;
GwyPixmapLayer *layer;
gdouble zoomval, scale, xreal, yreal;
gboolean realsquare;
gint xres, yres;
const gchar *prefix;
gchar *key;
g_return_if_fail(GWY_IS_DATA_VIEW(data_view));
g_return_if_fail(max_size >= 2);
container = gwy_data_view_get_data(data_view);
g_return_if_fail(GWY_IS_CONTAINER(container));
layer = gwy_data_view_get_base_layer(data_view);
g_return_if_fail(GWY_IS_PIXMAP_LAYER(layer));
prefix = gwy_pixmap_layer_get_data_key(layer);
g_return_if_fail(prefix);
data_field = gwy_container_get_object_by_name(container, prefix);
g_return_if_fail(GWY_IS_DATA_FIELD(data_field));
prefix = gwy_data_view_get_data_prefix(data_view);
g_return_if_fail(prefix);
key = g_strconcat(prefix, "/realsquare", NULL);
realsquare = FALSE;
gwy_container_gis_boolean_by_name(container, key, &realsquare);
g_free(key);
xres = gwy_data_field_get_xres(data_field);
yres = gwy_data_field_get_yres(data_field);
if (!realsquare)
zoomval = max_size/(gdouble)MAX(xres, yres);
else {
xreal = gwy_data_field_get_xreal(data_field);
yreal = gwy_data_field_get_yreal(data_field);
scale = MAX(xres/xreal, yres/yreal);
zoomval = max_size/(scale*MAX(xreal, yreal));
}
gwy_data_view_set_zoom(data_view, zoomval);
}
static void
gwy_layer_basic_plugged(GwyDataViewLayer *layer)
{
GwyPixmapLayer *pixmap_layer;
GwyLayerBasic *basic_layer;
GwyDataField *data_field = NULL;
gint width, height;
const guchar *gradient_name;
gwy_debug(" ");
g_return_if_fail(GWY_IS_LAYER_BASIC(layer));
pixmap_layer = GWY_PIXMAP_LAYER(layer);
basic_layer = GWY_LAYER_BASIC(layer);
basic_layer->changed = TRUE;
GWY_DATA_VIEW_LAYER_CLASS(parent_class)->plugged(layer);
/* TODO Container */
/* XXX */
data_field = GWY_DATA_FIELD(gwy_container_get_object_by_name(layer->data,
"/0/data"));
gwy_container_gis_object_by_name(layer->data, "/0/show",
(GObject**)&data_field);
g_return_if_fail(data_field);
width = gwy_data_field_get_xres(data_field);
height = gwy_data_field_get_yres(data_field);
if (gwy_container_gis_string_by_name(layer->data, "/0/base/palette",
&gradient_name))
gwy_layer_basic_set_gradient((GwyLayerBasic*)layer, gradient_name);
else {
/* FIXME: this is probably wrong, it should work with unset gradient
* and use default, but things depend on the fact /0/base/palette
* is set. */
gwy_layer_basic_set_gradient((GwyLayerBasic*)layer,
GWY_GRADIENT_DEFAULT);
gwy_container_set_string_by_name(GWY_DATA_VIEW_LAYER(layer)->data,
"/0/base/palette",
g_strdup(GWY_GRADIENT_DEFAULT));
}
pixmap_layer->pixbuf = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE,
BITS_PER_SAMPLE, width, height);
gwy_debug_objects_creation(G_OBJECT(pixmap_layer->pixbuf));
}
static void
facets_mark_fdata(FacetsArgs *args,
GwyContainer *fdata)
{
GwyDataField *mask;
gdouble q, r, cr, cro, cth0, sth0, cphi0, sphi0;
gint hres, i, j;
gdouble *m;
hres = (FDATA_RES - 1)/2;
cr = cos(args->tolerance);
cth0 = cos(args->theta0);
sth0 = sin(args->theta0);
cphi0 = cos(args->phi0);
sphi0 = sin(args->phi0);
q = gwy_container_get_double_by_name(fdata, "/q");
mask = GWY_DATA_FIELD(gwy_container_get_object_by_name(fdata, "/0/mask"));
m = gwy_data_field_get_data(mask);
for (i = 0; i < FDATA_RES; i++) {
gdouble y = G_SQRT2/(q*hres)*(i - hres);
for (j = 0; j < FDATA_RES; j++) {
gdouble x = -G_SQRT2/(q*hres)*(j - hres);
/**
* Orthodromic distance computed directly from x, y:
* cos(theta) = 1 - 2*(r/2)^2
* sin(theta) = r*sqrt(1 - (r/2)^2)
* cos(phi) = x/r
* sin(phi) = y/r
* where r = hypot(x, y)
**/
r = hypot(x, y);
cro = cth0*(1.0 - r*r/2.0)
+ sth0*r*sqrt(1.0 - r*r/4.0)*(x/r*cphi0 + y/r*sphi0);
m[i*FDATA_RES + j] = (cro >= cr);
}
}
gwy_data_field_data_changed(mask);
}
