static void
gwy_layer_basic_get_fixed_range(GwyLayerBasic *basic_layer,
GwyContainer *container,
GwyDataField *data_field,
gdouble *rmin,
gdouble *rmax)
{
const gchar *prefix;
gchar *key;
guint len;
if (!basic_layer->fixed_key) {
gwy_data_field_get_min_max(data_field, rmin, rmax);
return;
}
prefix = g_quark_to_string(basic_layer->fixed_key);
len = strlen(prefix);
key = g_newa(gchar, len + sizeof("/min"));
g_stpcpy(g_stpcpy(key, prefix), "/min");
if (!gwy_container_gis_double_by_name(container, key, rmin))
*rmin = gwy_data_field_get_min(data_field);
strcpy(key + len + 1, "max");
if (!gwy_container_gis_double_by_name(container, key, rmax))
*rmax = gwy_data_field_get_max(data_field);
}
static void
tip_process(TipModelArgs *args,
TipModelControls *controls)
{
const GwyTipModelPreset *preset;
GwyDataField *dfield;
GwyDataField *sfield;
GQuark quark;
gchar label[64];
gint xres, yres;
gdouble xstep, ystep, min, max, zrange;
gdouble params[2];
preset = gwy_tip_model_get_preset(args->type);
g_return_if_fail(preset);
tip_model_dialog_update_values(controls, args);
/* estimate x and y size */
dfield = controls->tip;
quark = gwy_app_get_data_key_for_id(args->object.id);
sfield = GWY_DATA_FIELD(gwy_container_get_object(args->object.data, quark));
gwy_data_field_set_xreal(dfield,
gwy_data_field_get_xmeasure(sfield)
*gwy_data_field_get_xres(dfield));
gwy_data_field_set_yreal(dfield,
gwy_data_field_get_ymeasure(sfield)
*gwy_data_field_get_yres(dfield));
params[0] = args->nsides;
params[1] = args->angle*G_PI/180;
gwy_data_field_get_min_max(sfield, &min, &max);
zrange = max - min;
preset->guess(sfield, zrange, args->radius, params, &xres, &yres);
/* process tip */
/* FIXME: this must be solved within guess functions */
xres = CLAMP(xres, 20, 1000);
yres = CLAMP(yres, 20, 1000);
g_snprintf(label, sizeof(label), _("Tip resolution: %d × %d pixels"),
xres, yres);
gtk_label_set_text(GTK_LABEL(controls->labsize), label);
xstep = gwy_data_field_get_xmeasure(dfield);
ystep = gwy_data_field_get_ymeasure(dfield);
gwy_data_field_resample(dfield, xres, yres, GWY_INTERPOLATION_NONE);
gwy_data_field_set_xreal(dfield, xstep*xres);
gwy_data_field_set_yreal(dfield, ystep*yres);
preset->func(dfield, zrange, args->radius, args->theta*G_PI/180, params);
tip_update(controls, args);
}
/**
* gwy_layer_basic_get_range:
* @basic_layer: A basic data view layer.
* @min: Location to store range minimum to.
* @max: Location to store range maximum to.
*
* Gets the range colors are mapped from in current mode.
*
* This function does not take presentations into account. It always returns
* ther range corresponding to the underlying data even if a presentation is
* shown instead.
**/
void
gwy_layer_basic_get_range(GwyLayerBasic *basic_layer,
gdouble *min,
gdouble *max)
{
GwyPixmapLayer *pixmap_layer;
GwyContainer *data;
GwyDataField *data_field;
gdouble rmin, rmax;
g_return_if_fail(GWY_IS_LAYER_BASIC(basic_layer));
data = GWY_DATA_VIEW_LAYER(basic_layer)->data;
pixmap_layer = GWY_PIXMAP_LAYER(basic_layer);
data_field = GWY_DATA_FIELD(pixmap_layer->data_field);
g_return_if_fail(data && data_field);
switch (gwy_layer_basic_get_range_type(basic_layer)) {
case GWY_LAYER_BASIC_RANGE_FULL:
case GWY_LAYER_BASIC_RANGE_ADAPT:
gwy_data_field_get_min_max(data_field, &rmin, &rmax);
break;
case GWY_LAYER_BASIC_RANGE_FIXED:
gwy_layer_basic_get_fixed_range(basic_layer, data, data_field,
&rmin, &rmax);
break;
case GWY_LAYER_BASIC_RANGE_AUTO:
gwy_data_field_get_autorange(data_field, &rmin, &rmax);
break;
default:
g_assert_not_reached();
break;
}
if (min)
*min = rmin;
if (max)
*max = rmax;
}
static void
copy_field_to_surface(GwyDataField *field,
GwySurface *surface,
GwyDataField *mask,
GwyMaskingType masking)
{
gdouble dx = gwy_data_field_get_xmeasure(field),
dy = gwy_data_field_get_ymeasure(field);
gdouble xoff = 0.5*dx + field->xoff, yoff = 0.5*dy + field->yoff;
Surface *priv = surface->priv;
guint xres, yres, i, j, n, k;
const gdouble *m = NULL, *d;
xres = field->xres;
yres = field->yres;
n = xres*yres;
d = field->data;
if (mask && masking == GWY_MASK_INCLUDE) {
m = mask->data;
j = 0;
for (k = 0; k < n; k++) {
if (m[k] > 0.0)
j++;
}
n = j;
}
else if (mask && masking == GWY_MASK_EXCLUDE) {
m = mask->data;
j = 0;
for (k = 0; k < n; k++) {
if (m[k] <= 0.0)
j++;
}
n = j;
}
if (surface->n != n) {
free_data(surface);
surface->n = n;
alloc_data(surface);
}
k = 0;
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++) {
if (!mask || masking == GWY_MASK_IGNORE
|| (masking == GWY_MASK_INCLUDE && m[i*xres + j] > 0.0)
|| (masking == GWY_MASK_EXCLUDE && m[i*xres + j] <= 0.0)) {
surface->data[k].x = dx*j + xoff;
surface->data[k].y = dy*i + yoff;
surface->data[k].z = d[i*xres + j];
k++;
}
}
}
gwy_data_field_copy_units_to_surface(field, surface);
gwy_surface_invalidate(surface);
if (n == xres*yres) {
priv->cached_ranges = TRUE;
priv->min.x = xoff;
priv->min.y = yoff;
priv->max.x = dx*(xres - 1) + xoff;
priv->max.y = dy*(yres - 1) + yoff;
}
gwy_data_field_get_min_max(field, &priv->min.z, &priv->max.z);
}
static gboolean
aafm_export(G_GNUC_UNUSED GwyContainer *data,
const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
union { guchar pp[4]; float f; } z;
guint16 res, r;
gint16 *x;
gint16 v;
gint i, j, xres, yres, n;
GwyDataField *dfield;
const gdouble *d;
gdouble min, max, q, z0;
FILE *fh;
gboolean ok = TRUE;
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield, 0);
if (!dfield) {
err_NO_CHANNEL_EXPORT(error);
return FALSE;
}
if (!(fh = gwy_fopen(filename, "wb"))) {
err_OPEN_WRITE(error);
return FALSE;
}
d = gwy_data_field_get_data_const(dfield);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
res = MIN(MIN(xres, yres), 32767);
n = (gint)res*(gint)res;
r = GUINT16_TO_LE(res);
fwrite(&res, 1, sizeof(r), fh);
gwy_data_field_get_min_max(dfield, &min, &max);
if (min == max) {
q = 0.0;
z0 = 0.0;
}
else {
q = 65533.0/(max - min);
z0 = -32766.5*(max + min)/(max - min);
}
z.f = MIN(gwy_data_field_get_xreal(dfield),
gwy_data_field_get_yreal(dfield))/Angstrom;
#if (G_BYTE_ORDER == G_BIG_ENDIAN)
GWY_SWAP(guchar, z.pp[0], z.pp[3]);
GWY_SWAP(guchar, z.pp[1], z.pp[2]);
#endif
fwrite(&z, 1, sizeof(z), fh);
x = g_new(gint16, n);
for (i = 0; i < res; i++) {
for (j = 0; j < res; j++) {
v = GWY_ROUND(d[(res-1 - j)*res + i]*q + z0);
x[i*res + j] = GINT16_TO_LE(v);
}
}
if (!(ok = (fwrite(x, 1, 2*n, fh) == 2*n))) {
err_WRITE(error);
g_unlink(filename);
}
else {
z.f = (max - min)/Angstrom;
#if (G_BYTE_ORDER == G_BIG_ENDIAN)
GWY_SWAP(guchar, z.pp[0], z.pp[3]);
GWY_SWAP(guchar, z.pp[1], z.pp[2]);
#endif
fwrite(&z, 1, sizeof(z), fh);
}
fclose(fh);
g_free(x);
return ok;
}
static GwyContainer*
aafm_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwySIUnit *unit;
GwyContainer *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize size = 0;
GError *err = NULL;
AFMFile afmfile;
GwyDataField *dfield;
gdouble min, max;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < 12) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
p = buffer;
afmfile.res = gwy_get_guint16_le(&p);
if (err_DIMENSION(error, afmfile.res)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
if (err_SIZE_MISMATCH(error, afmfile.res * afmfile.res + 10, size, FALSE)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
afmfile.real = Angstrom*gwy_get_gfloat_le(&p);
if (!(afmfile.real = fabs(afmfile.real))) {
g_warning("Real size is 0.0, fixing to 1.0");
afmfile.real = 1.0;
}
dfield = gwy_data_field_new(afmfile.res, afmfile.res,
afmfile.real, afmfile.real,
FALSE);
read_binary_data(afmfile.res, gwy_data_field_get_data(dfield), p);
p += 2*afmfile.res*afmfile.res;
afmfile.range = gwy_get_gfloat_le(&p);
gwy_data_field_get_min_max(dfield, &min, &max);
if (min == max)
gwy_data_field_clear(dfield);
else
gwy_data_field_multiply(dfield, afmfile.range/(max - min)*Angstrom);
unit = gwy_si_unit_new("m");
gwy_data_field_set_si_unit_xy(dfield, unit);
g_object_unref(unit);
unit = gwy_si_unit_new("m");
gwy_data_field_set_si_unit_z(dfield, unit);
g_object_unref(unit);
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", dfield);
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Topography"));
g_object_unref(dfield);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
gwy_file_abandon_contents(buffer, size, NULL);
return container;
}
