static void
compute_slopes(GwyDataField *dfield,
gint kernel_size,
GwyDataField *xder,
GwyDataField *yder)
{
gint xres, yres;
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
if (kernel_size > 1) {
GwyPlaneFitQuantity quantites[] = {
GWY_PLANE_FIT_BX, GWY_PLANE_FIT_BY
};
GwyDataField *fields[2];
fields[0] = xder;
fields[1] = yder;
gwy_data_field_fit_local_planes(dfield, kernel_size,
2, quantites, fields);
}
else {
gint col, row;
gdouble *xd, *yd;
const gdouble *data;
gdouble d;
data = gwy_data_field_get_data_const(dfield);
xd = gwy_data_field_get_data(xder);
yd = gwy_data_field_get_data(yder);
for (row = 0; row < yres; row++) {
for (col = 0; col < xres; col++) {
if (!col)
d = data[row*xres + col + 1] - data[row*xres + col];
else if (col == xres-1)
d = data[row*xres + col] - data[row*xres + col - 1];
else
d = (data[row*xres + col + 1]
- data[row*xres + col - 1])/2;
*(xd++) = d;
if (!row)
d = data[row*xres + xres + col] - data[row*xres + col];
else if (row == yres-1)
d = data[row*xres + col] - data[row*xres - xres + col];
else
d = (data[row*xres + xres + col]
- data[row*xres - xres + col])/2;
*(yd++) = d;
}
}
}
gwy_data_field_multiply(xder, xres/gwy_data_field_get_xreal(dfield));
gwy_data_field_multiply(yder, yres/gwy_data_field_get_yreal(dfield));
}
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;
}
static void
line_correct_median_difference(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield;
gdouble *diffs, *row, *prev;
gint xres, yres, i, j;
gdouble median;
GQuark dquark;
g_return_if_fail(run & GWY_RUN_IMMEDIATE);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_KEY, &dquark,
0);
g_return_if_fail(dfield && dquark);
gwy_app_undo_qcheckpointv(data, 1, &dquark);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
row = gwy_data_field_get_data(dfield);
diffs = g_new(gdouble, xres);
for (i = 1; i < yres; i++) {
prev = row;
row += xres;
for (j = 0; j < xres; j++)
diffs[j] = prev[j] - row[j];
median = gwy_math_median(xres, diffs);
for (j = 0; j < xres; j++)
row[j] += median;
}
g_free(diffs);
gwy_data_field_data_changed(dfield);
}
static void
gwy_data_field_absdiff_line_correct(GwyDataField *dfield)
{
MedianLineData mldata;
gint xres, yres, i, j;
gdouble shift, csum, mindiff, maxdiff, x;
gdouble *d;
yres = gwy_data_field_get_yres(dfield);
xres = gwy_data_field_get_xres(dfield);
d = gwy_data_field_get_data(dfield);
csum = 0.0;
mldata.n = xres;
for (i = 1; i < yres; i++) {
mldata.a = d + xres*(i - 1);
mldata.b = d + xres*i;
mindiff = G_MAXDOUBLE;
maxdiff = -G_MAXDOUBLE;
for (j = 0; j < xres; j++) {
x = mldata.b[j] - mldata.a[j];
if (x < mindiff)
mindiff = x;
if (x > maxdiff)
maxdiff = x;
}
shift = find_minima_golden(sum_of_abs_diff, mindiff, maxdiff, &mldata);
gwy_data_field_area_add(dfield, 0, i, xres, 1, -shift);
csum -= shift;
}
gwy_data_field_add(dfield, -csum/(xres*yres));
}
static GwyDataField*
microprof_read_data_field(const MicroProfFile *mfile,
const guchar *buffer)
{
const guint16 *d16 = (const guint16*)buffer;
GwyDataField *dfield;
GwySIUnit *siunit;
gdouble *d;
guint xres, yres, i, j;
xres = mfile->xres;
yres = mfile->yres;
dfield = gwy_data_field_new(xres, yres,
mfile->xrange, mfile->yrange, FALSE);
d = gwy_data_field_get_data(dfield);
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++) {
d[(yres-1 - i)*xres + j] = mfile->zscale*GUINT16_FROM_LE(*d16);
d16++;
}
}
siunit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string(siunit, "m");
siunit = gwy_data_field_get_si_unit_z(dfield);
gwy_si_unit_set_from_string(siunit, "m");
return dfield;
}
static void
noise_synth_do(const NoiseSynthArgs *args,
const GwyDimensionArgs *dimsargs,
GwyDataField *dfield)
{
const NoiseSynthGenerator *generator;
PointNoiseFunc point_noise;
GwyRandGenSet *rngset;
gdouble *data;
gdouble sigma;
gint xres, yres, i;
generator = get_point_noise_generator(args->distribution);
point_noise = generator->point_noise[args->direction];
rngset = gwy_rand_gen_set_new(1);
gwy_rand_gen_set_init(rngset, args->seed);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
data = gwy_data_field_get_data(dfield);
sigma = args->sigma * pow10(dimsargs->zpow10);
for (i = 0; i < xres*yres; i++)
data[i] += point_noise(rngset, sigma);
gwy_rand_gen_set_free(rngset);
}
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
flip_xy(GwyDataField *source, GwyDataField *dest, gboolean minor)
{
gint xres, yres, i, j;
gdouble *dd;
const gdouble *sd;
xres = gwy_data_field_get_xres(source);
yres = gwy_data_field_get_yres(source);
gwy_data_field_resample(dest, yres, xres, GWY_INTERPOLATION_NONE);
sd = gwy_data_field_get_data_const(source);
dd = gwy_data_field_get_data(dest);
if (minor) {
for (i = 0; i < xres; i++) {
for (j = 0; j < yres; j++) {
dd[i*yres + j] = sd[j*xres + (xres - 1 - i)];
}
}
}
else {
for (i = 0; i < xres; i++) {
for (j = 0; j < yres; j++) {
dd[i*yres + (yres - 1 - j)] = sd[j*xres + i];
}
}
}
gwy_data_field_set_xreal(dest, gwy_data_field_get_yreal(source));
gwy_data_field_set_yreal(dest, gwy_data_field_get_xreal(source));
}
static void
gwy_data_field_mark_facets(GwyDataField *dtheta,
GwyDataField *dphi,
gdouble theta0,
gdouble phi0,
gdouble tolerance,
GwyDataField *mask)
{
gdouble cr, cth0, sth0, cro;
const gdouble *xd, *yd;
gdouble *md;
gint i;
cr = cos(tolerance);
cth0 = cos(theta0);
sth0 = sin(theta0);
xd = gwy_data_field_get_data_const(dtheta);
yd = gwy_data_field_get_data_const(dphi);
md = gwy_data_field_get_data(mask);
for (i = gwy_data_field_get_xres(dtheta)*gwy_data_field_get_yres(dtheta);
i;
i--, xd++, yd++, md++) {
cro = cth0*cos(*xd) + sth0*sin(*xd)*cos(*yd - phi0);
*md = (cro >= cr);
}
}
static GwyDataField*
make_mask_field(GwyDataField *dfield,
const guchar *data)
{
GwyDataField *mfield;
guint xres, yres, i, j, rowstride;
const guchar *datarow;
gdouble *d;
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
rowstride = xres;
/* Do not create the mask if it is all zero. */
for (i = 0; i < rowstride*yres; i++) {
if (!data[i])
break;
}
if (i == rowstride*yres)
return NULL;
mfield = gwy_data_field_new_alike(dfield, FALSE);
d = gwy_data_field_get_data(mfield);
for (i = 0; i < yres; i++) {
datarow = data + (yres-1 - i)*rowstride;
for (j = 0; j < xres; j++) {
*(d++) = datarow[j];
}
}
return mfield;
}
static gdouble
calculate_sigma2_2d(GwyDataField *xfield, GwyDataField *yfield)
{
gdouble xc = gwy_data_field_get_avg(xfield);
gdouble yc = gwy_data_field_get_avg(yfield);
const gdouble *xdata = gwy_data_field_get_data(xfield);
const gdouble *ydata = gwy_data_field_get_data(yfield);
gdouble s2 = 0.0;
guint n, i;
n = gwy_data_field_get_xres(xfield)*gwy_data_field_get_yres(xfield);
for (i = 0; i < n; i++)
s2 += (xdata[i] - xc)*(xdata[i] - xc) + (ydata[i] - yc)*(ydata[i] - yc);
return s2/n;
}
static void
line_correct_step_iter(GwyDataField *dfield,
GwyDataField *mask)
{
const gdouble threshold = 3.0;
gint xres, yres, i, j, len;
gdouble u, v, w;
const gdouble *d, *drow;
gdouble *m, *mrow;
yres = gwy_data_field_get_yres(dfield);
xres = gwy_data_field_get_xres(dfield);
d = gwy_data_field_get_data_const(dfield);
m = gwy_data_field_get_data(mask);
w = 0.0;
for (i = 0; i < yres-1; i++) {
drow = d + i*xres;
for (j = 0; j < xres; j++) {
v = drow[j + xres] - drow[j];
w += v*v;
}
}
w = w/(yres-1)/xres;
for (i = 0; i < yres-2; i++) {
drow = d + i*xres;
mrow = m + (i + 1)*xres;
for (j = 0; j < xres; j++) {
u = drow[xres + j];
v = (u - drow[j])*(u - drow[j + 2*xres]);
if (G_UNLIKELY(v > threshold*w)) {
if (2*u - drow[j] - drow[j + 2*xres] > 0)
mrow[j] = 1.0;
else
mrow[j] = -1.0;
}
}
len = 1;
for (j = 1; j < xres; j++) {
if (mrow[j] == mrow[j-1])
len++;
else {
if (mrow[j-1])
calcualte_segment_correction(drow + j-len, mrow + j-len,
xres, len);
len = 1;
}
}
if (mrow[j-1]) {
calcualte_segment_correction(drow + j-len, mrow + j-len,
xres, len);
}
}
gwy_data_field_sum_fields(dfield, dfield, mask);
}
static GwyDataField*
read_data_field(const guchar *buffer,
gint xres,
gint yres,
NetCDFType type)
{
GwyDataField *dfield;
gdouble *data;
gint i;
dfield = gwy_data_field_new(xres, yres, 1.0, 1.0, FALSE);
data = gwy_data_field_get_data(dfield);
switch (type) {
case NC_BYTE:
case NC_CHAR:
{
const gint8 *d8 = (const gint8*)buffer;
for (i = 0; i < xres*yres; i++)
data[i] = d8[i];
}
break;
case NC_SHORT:
{
const gint16 *d16 = (const gint16*)buffer;
for (i = 0; i < xres*yres; i++)
data[i] = GINT16_FROM_BE(d16[i]);
}
break;
case NC_INT:
{
const gint32 *d32 = (const gint32*)buffer;
for (i = 0; i < xres*yres; i++)
data[i] = GINT32_FROM_BE(d32[i]);
}
break;
case NC_FLOAT:
for (i = 0; i < xres*yres; i++)
data[i] = gwy_get_gfloat_be(&buffer);
break;
case NC_DOUBLE:
for (i = 0; i < xres*yres; i++)
data[i] = gwy_get_gdouble_be(&buffer);
break;
default:
g_return_val_if_reached(dfield);
break;
}
return dfield;
}
static void
presentation_logscale(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield, *sfield;
GQuark squark;
gdouble *d;
gdouble min, max, m0;
gint xres, yres, i, zeroes, id;
g_return_if_fail(run & PRESENTATIONOPS_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_SHOW_FIELD_KEY, &squark,
GWY_APP_SHOW_FIELD, &sfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield && squark);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
gwy_app_undo_qcheckpointv(data, 1, &squark);
if (!sfield) {
sfield = gwy_data_field_duplicate(dfield);
gwy_container_set_object(data, squark, sfield);
g_object_unref(sfield);
}
else {
gwy_data_field_resample(sfield, xres, yres, GWY_INTERPOLATION_NONE);
gwy_data_field_copy(dfield, sfield, FALSE);
}
d = gwy_data_field_get_data(sfield);
zeroes = 0;
max = 0;
min = G_MAXDOUBLE;
for (i = 0; i < xres*yres; i++) {
d[i] = ABS(d[i]);
if (G_UNLIKELY(d[i] > max))
max = d[i];
if (d[i] == 0.0)
zeroes++;
else if (G_UNLIKELY(d[i] < min))
min = d[i];
}
if (min == max || zeroes == xres*yres)
return;
if (!zeroes) {
for (i = 0; i < xres*yres; i++)
d[i] = log(d[i]);
}
else {
m0 = log(min) - log(max/min)/512.0;
for (i = 0; i < xres*yres; i++)
d[i] = d[i] ? log(d[i]) : m0;
}
gwy_data_field_data_changed(sfield);
gwy_app_channel_log_add_proc(data, id, id);
}
static void
fill_data_fields(APEFile *apefile,
const guchar *buffer)
{
GwyDataField *dfield;
GwySIUnit *unit;
gdouble *data;
const gchar *zunit;
guint b, n, i, j, k;
gdouble q;
apefile->data = g_new0(GwyDataField*, apefile->ndata);
for (b = apefile->channels, n = 0, k = 0; b; b = b >> 1, k++) {
if (!(b & 1))
continue;
dfield = gwy_data_field_new(apefile->res, apefile->res,
apefile->xreal, apefile->yreal, FALSE);
unit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string(unit, "m");
data = gwy_data_field_get_data(dfield);
buffer += (apefile->res + 1)*sizeof(float);
switch (k) {
case APE_HEIGHT:
case APE_HEIGHT_R:
case APE_AUX2:
case APE_AUX2_R:
q = apefile->z_piezo_factor * 1e-9;
zunit = "m";
break;
case APE_AUX1:
case APE_AUX1_R:
q = 1.0;
zunit = apefile->pg850_image ? "A" : "V";
break;
default:
q = 1.0;
zunit = "V";
break;
}
unit = gwy_data_field_get_si_unit_z(dfield);
gwy_si_unit_set_from_string(unit, zunit);
for (i = 0; i < apefile->res; i++) {
/* There is always one ignored record, do not ask me why... */
buffer += sizeof(float);
for (j = 0; j < apefile->res; j++) {
*(data++) = q*gwy_get_gfloat_le(&buffer);
}
}
apefile->data[n] = dfield;
n++;
}
}
/* This does not transform to spherical (theta,phi) but to a planar coordinate
* system with unit |J| so the entropy should be preserved. It is the same
* transformation as in facet analysis. */
static void
transform_to_sphere(GwyDataField *xder, GwyDataField *yder)
{
gdouble *xdata = gwy_data_field_get_data(xder);
gdouble *ydata = gwy_data_field_get_data(yder);
guint i, n = gwy_data_field_get_xres(xder)*gwy_data_field_get_yres(xder);
for (i = 0; i < n; i++) {
gdouble x = xdata[i], y = ydata[i];
gdouble r2 = x*x + y*y;
if (r2 > 0.0) {
gdouble s_r = G_SQRT2*sqrt((1.0 - 1.0/sqrt(1.0 + r2))/r2);
xdata[i] *= s_r;
ydata[i] *= s_r;
}
}
}
static gboolean
fill_data_fields(SurfFile *surffile,
const guchar *buffer,
GError **error)
{
GwySIUnit *siunit;
gdouble *data;
guint i, j;
surffile->dfield = gwy_data_field_new(surffile->xres,
surffile->yres,
surffile->xres*surffile->dx,
surffile->yres*surffile->dy,
FALSE);
data = gwy_data_field_get_data(surffile->dfield);
switch (surffile->pointsize) {
case 16:
{
const gint16 *row, *d16 = (const gint16*)buffer;
for (i = 0; i < surffile->xres; i++) {
row = d16 + i*surffile->yres;
for (j = 0; j < surffile->yres; j++)
*(data++) = GINT16_FROM_LE(row[j]) * surffile->dz;
}
}
break;
case 32:
{
const gint32 *row, *d32 = (const gint32*)buffer;
for (i = 0; i < surffile->xres; i++) {
row = d32 + i*surffile->yres;
for (j = 0; j < surffile->yres; j++)
*(data++) = GINT32_FROM_LE(row[j]) * surffile->dz;
}
}
break;
default:
err_BPP(error, surffile->pointsize);
return FALSE;
break;
}
siunit = gwy_si_unit_new("m");
gwy_data_field_set_si_unit_xy(surffile->dfield, siunit);
g_object_unref(siunit);
siunit = gwy_si_unit_new("m");
gwy_data_field_set_si_unit_z(surffile->dfield, siunit);
g_object_unref(siunit);
return TRUE;
}
static GwyDataField*
rhk_sm4_page_to_data_field(const RHKPage *page)
{
GwyDataField *dfield;
GwySIUnit *siunit;
const gchar *unit;
const gint32 *pdata;
gint xres, yres, i, j;
gdouble *data;
xres = page->x_size;
yres = page->y_size;
dfield = gwy_data_field_new(xres, yres,
xres*fabs(page->x_scale),
yres*fabs(page->y_scale),
FALSE);
data = gwy_data_field_get_data(dfield);
pdata = (const gint32*)page->data;
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++) {
data[i*xres + xres-1 - j] = GINT32_FROM_LE(pdata[i*xres + j])
*page->z_scale + page->z_offset;
}
}
/* XY units */
if (page->strings[RHK_STRING_X_UNITS]
&& page->strings[RHK_STRING_Y_UNITS]) {
if (!gwy_strequal(page->strings[RHK_STRING_X_UNITS],
page->strings[RHK_STRING_Y_UNITS]))
g_warning("X and Y units differ, using X");
unit = page->strings[RHK_STRING_X_UNITS];
}
else if (page->strings[RHK_STRING_X_UNITS])
unit = page->strings[RHK_STRING_X_UNITS];
else if (page->strings[RHK_STRING_Y_UNITS])
unit = page->strings[RHK_STRING_Y_UNITS];
else
unit = NULL;
siunit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string(siunit, unit);
/* Z units */
if (page->strings[RHK_STRING_Z_UNITS])
unit = page->strings[RHK_STRING_Z_UNITS];
else
unit = NULL;
/* Fix some silly units */
if (unit && gwy_strequal(unit, "N/sec"))
unit = "s^-1";
siunit = gwy_data_field_get_si_unit_z(dfield);
gwy_si_unit_set_from_string(siunit, unit);
return dfield;
}
static GwyDataField*
mif_read_data_field(const MIFImageHeader *image_header,
const MIFBlock *block,
const guchar *buffer,
gsize size,
GError **error)
{
gint xres = image_header->setup.xres;
gint yres = image_header->setup.yres;
gdouble xreal = image_header->setup.xreal;
gdouble yreal = image_header->setup.yreal;
gdouble xoff = image_header->setup.xoff;
gdouble yoff = image_header->setup.yoff;
gdouble q = image_header->configuration.scan_int_to_meter;
GwyDataField *dfield;
gdouble *data;
const gint16 *d16;
gint i, j;
if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres))
return NULL;
if (!block->size || block->offset > size || block->size > size
|| block->offset + block->size > size) {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("Image data are outside the file."));
return NULL;
}
if (err_SIZE_MISMATCH(error, xres*yres*sizeof(gint16), block->size, FALSE))
return NULL;
dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE);
gwy_data_field_set_xoffset(dfield, xoff);
gwy_data_field_set_yoffset(dfield, yoff);
data = gwy_data_field_get_data(dfield);
d16 = (const gint16*)(buffer + block->offset);
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m");
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), "m");
// FIXME: Don't know why this factor. It seems to match what MIF spmview
// profile reader shows though.
q *= 1.0e4;
for (i = 0; i < yres; i++) {
for (j = 0; j < yres; j++) {
data[(yres-1 - i)*xres + j] = q*GINT16_FROM_LE(d16[i*xres + j]);
}
}
return dfield;
}
static GwyDataField*
read_text_data(const gchar *buffer,
gint text_data_start,
GHashTable *hash,
GError **error)
{
const gchar *p;
gchar *end;
gint xres, yres, i, power10;
gdouble xreal, yreal, zscale, xoff, yoff, zoff;
GwySIUnit *unitxy, *unitz;
GwyDataField *dfield = NULL;
gdouble *d;
unitxy = gwy_si_unit_new(NULL);
unitz = gwy_si_unit_new(NULL);
if (!get_scales(hash, TRUE,
&xres, &yres, &xreal, &yreal, &xoff, &yoff, unitxy,
&zscale, &zoff, unitz, error))
goto fail;
p = g_hash_table_lookup(hash, "DATA Unit");
gwy_si_unit_set_from_string_parse(unitz, p, &power10);
zscale = pow10(power10);
dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE);
gwy_data_field_set_xoffset(dfield, xoff);
gwy_data_field_set_yoffset(dfield, yoff);
gwy_data_field_set_si_unit_xy(dfield, unitxy);
gwy_data_field_set_si_unit_z(dfield, unitz);
d = gwy_data_field_get_data(dfield);
p = (const gchar*)buffer + text_data_start;
for (i = 0; i < xres*yres; i++) {
d[i] = zscale*g_ascii_strtod(p, &end) + zoff;
if (end == p) {
g_set_error(error, GWY_MODULE_FILE_ERROR,
GWY_MODULE_FILE_ERROR_DATA,
_("Cannot parse data values after %d of %d."),
i, xres*yres);
gwy_object_unref(dfield);
goto fail;
}
p = end + (*end == ',');
}
fail:
g_object_unref(unitxy);
g_object_unref(unitz);
return dfield;
}
static GwyDataField*
rhk_sm3_page_to_data_field(const RHKPage *page)
{
GwyDataField *dfield;
GwySIUnit *siunit;
const gchar *unit;
gint xres, yres, i;
const gint32 *pdata;
gdouble *data;
xres = page->x_size;
yres = page->y_size;
dfield = gwy_data_field_new(xres, yres,
xres*fabs(page->x_scale),
yres*fabs(page->y_scale),
FALSE);
data = gwy_data_field_get_data(dfield);
pdata = (const gint32*)page->page_data;
for (i = 0; i < xres*yres; i++)
data[i] = GINT32_FROM_LE(pdata[i])*page->z_scale + page->z_offset;
if (page->strings[RHK_STRING_X_UNITS]
&& page->strings[RHK_STRING_Y_UNITS]) {
if (!gwy_strequal(page->strings[RHK_STRING_X_UNITS],
page->strings[RHK_STRING_Y_UNITS]))
g_warning("X and Y units are different, using X");
unit = page->strings[RHK_STRING_X_UNITS];
}
else if (page->strings[RHK_STRING_X_UNITS])
unit = page->strings[RHK_STRING_X_UNITS];
else if (page->strings[RHK_STRING_Y_UNITS])
unit = page->strings[RHK_STRING_Y_UNITS];
else
unit = "";
siunit = gwy_si_unit_new(unit);
gwy_data_field_set_si_unit_xy(dfield, siunit);
g_object_unref(siunit);
if (page->strings[RHK_STRING_Z_UNITS])
unit = page->strings[RHK_STRING_Z_UNITS];
else
unit = "";
/* Fix some silly units */
if (gwy_strequal(unit, "N/sec"))
unit = "s^-1";
siunit = gwy_si_unit_new(unit);
gwy_data_field_set_si_unit_z(dfield, siunit);
g_object_unref(siunit);
return dfield;
}
static GwyDataField*
rhkspm32_read_data(RHKPage *rhkpage)
{
GwyDataField *dfield;
const guint16 *p;
GwySIUnit *siunit;
gdouble *data;
const gchar *s;
gdouble q;
gint power10;
guint i, j, xres, yres;
p = (const guint16*)(rhkpage->buffer + rhkpage->data_offset);
xres = rhkpage->xres;
yres = rhkpage->yres;
// the scales are no longer gurunteed to be positive,
// so they must be "fixed" here (to enable spectra)
dfield = gwy_data_field_new(xres, yres,
xres*fabs(rhkpage->x.scale),
yres*fabs(rhkpage->y.scale),
FALSE);
data = gwy_data_field_get_data(dfield);
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++)
data[i*xres + xres-1 - j] = GINT16_FROM_LE(p[i*xres + j]);
}
siunit = gwy_data_field_get_si_unit_xy(dfield);
gwy_si_unit_set_from_string_parse(siunit, rhkpage->x.units, &power10);
if (power10) {
q = pow10(power10);
gwy_data_field_set_xreal(dfield, q*gwy_data_field_get_xreal(dfield));
gwy_data_field_set_yreal(dfield, q*gwy_data_field_get_yreal(dfield));
}
siunit = gwy_data_field_get_si_unit_z(dfield);
s = rhkpage->z.units;
/* Fix some silly units */
if (gwy_strequal(s, "N/sec"))
s = "s^-1";
gwy_si_unit_set_from_string_parse(siunit, s, &power10);
q = pow10(power10);
gwy_data_field_multiply(dfield, q*fabs(rhkpage->z.scale));
gwy_data_field_add(dfield, q*rhkpage->z.offset);
return dfield;
}
static GwyDataField*
prof_sqrt(GwyDataField *dfield)
{
gint xres, yres, i;
gdouble *data;
dfield = gwy_data_field_duplicate(dfield);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
data = gwy_data_field_get_data(dfield);
for (i = 0; i < xres*yres; i++)
data[i] = sqrt(data[i]);
return dfield;
}
static GwyDataField*
jeol_read_data_field(const guchar *buffer,
const JEOLImageHeader *header)
{
GwyDataField *dfield;
const gchar *unitstr;
gdouble q, z0;
switch (header->spm_misc_param.measurement_signal) {
case JEOL_MEASUREMENT_SIGNAL_TOPOGRAPHY:
z0 = Nanometer*header->z0;
q = (header->z255 - header->z0)/65535.0*Nanometer;
unitstr = "m";
break;
case JEOL_MEASUREMENT_SIGNAL_LINEAR_CURRENT:
z0 = Nanoampere*header->z0;
q = (header->z255 - header->z0)/65535.0*Nanoampere;
unitstr = "A";
break;
/* We just guess it's always voltage. At least sometimes it is. */
case JEOL_MEASUREMENT_SIGNAL_AUX1:
case JEOL_MEASUREMENT_SIGNAL_AUX2:
z0 = header->z0;
q = (header->z255 - header->z0)/65535.0;
unitstr = "V";
break;
default:
return NULL;
break;
}
dfield = gwy_data_field_new(header->xres, header->yres,
Nanometer*header->xreal,
Nanometer*header->yreal,
FALSE);
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m");
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), unitstr);
gwy_convert_raw_data(buffer, header->xres*header->yres, 1,
GWY_RAW_DATA_UINT16, GWY_BYTE_ORDER_LITTLE_ENDIAN,
gwy_data_field_get_data(dfield), q, z0);
return dfield;
}
static SensolyticsChannel*
create_fields(GHashTable *hash,
/* Can we obtain any useful information from this? */
G_GNUC_UNUSED gchar *line,
gint ndata,
const Dimensions *dimensions)
{
SensolyticsChannel *channels;
GString *str;
const gchar *value;
GwySIUnit *unit;
gint i, power10;
str = g_string_new(NULL);
channels = g_new0(SensolyticsChannel, ndata+1);
for (i = 0; i < ndata; i++) {
channels[i].dfield = gwy_data_field_new(dimensions->xres,
dimensions->yres,
dimensions->xreal,
dimensions->yreal,
FALSE);
channels[i].data = gwy_data_field_get_data(channels[i].dfield);
unit = gwy_si_unit_new("m");
gwy_data_field_set_si_unit_xy(channels[i].dfield, unit);
g_object_unref(unit);
g_string_printf(str, "Channel %d Unit", i+1);
channels[i].q = 1.0;
if ((value = g_hash_table_lookup(hash, str->str))) {
unit = gwy_si_unit_new_parse(value, &power10);
gwy_data_field_set_si_unit_z(channels[i].dfield, unit);
g_object_unref(unit);
channels[i].q = pow10(power10);
}
else
g_warning("Channel %d has no units", i+1);
g_string_printf(str, "Channel %d Name", i+1);
if (!(channels[i].name = g_hash_table_lookup(hash, str->str)))
g_warning("Channel %d has no name", i+1);
}
return channels;
}
static void
modify_channel_for_preview(GwyContainer *data,
gint id,
gboolean plane_level, gboolean row_level)
{
GwyDataField *field;
gdouble a, bx, by;
if (!plane_level && !row_level)
return;
if (!gwy_container_gis_object(data, gwy_app_get_data_key_for_id(id), &field)
|| !GWY_IS_DATA_FIELD(field))
return;
if (plane_level) {
gwy_data_field_fit_plane(field, &a, &bx, &by);
gwy_data_field_plane_level(field, a, bx, by);
}
if (row_level) {
guint xres = gwy_data_field_get_xres(field);
guint yres = gwy_data_field_get_yres(field);
gdouble *row = gwy_data_field_get_data(field);
gdouble *diffs = g_new(gdouble, xres);
guint i, j;
for (i = 1; i < yres; i++) {
gdouble *prev = row;
gdouble median;
row += xres;
for (j = 0; j < xres; j++)
diffs[j] = prev[j] - row[j];
median = gwy_math_median(xres, diffs);
for (j = 0; j < xres; j++)
row[j] += median;
}
g_free(diffs);
}
}
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);
}
static gboolean
fill_data_fields(SurfFile *surffile,
const guchar *buffer,
GError **error)
{
gdouble *data;
surffile->dfield = gwy_data_field_new(surffile->xres,
surffile->yres,
surffile->xres*surffile->dx,
surffile->yres*surffile->dy,
FALSE);
data = gwy_data_field_get_data(surffile->dfield);
switch (surffile->pointsize) {
case 16:
gwy_convert_raw_data(buffer, surffile->xres*surffile->yres, 1,
GWY_RAW_DATA_SINT16, GWY_BYTE_ORDER_LITTLE_ENDIAN,
data, surffile->dz, 0.0);
break;
case 32:
gwy_convert_raw_data(buffer, surffile->xres*surffile->yres, 1,
GWY_RAW_DATA_SINT32, GWY_BYTE_ORDER_LITTLE_ENDIAN,
data, surffile->dz, 0.0);
break;
default:
err_BPP(error, surffile->pointsize);
return FALSE;
break;
}
gwy_data_field_set_si_unit_xy(surffile->dfield, surffile->xyunit);
g_object_unref(surffile->xyunit);
gwy_data_field_set_si_unit_z(surffile->dfield, surffile->zunit);
g_object_unref(surffile->zunit);
return TRUE;
}
static void
read_data_field(GwyDataField *dfield,
EZDSection *section)
{
gdouble *data;
gdouble q, z0;
guint i, j;
gint xres, yres;
g_assert(section->data);
xres = section->xres;
yres = section->yres;
gwy_data_field_resample(dfield, xres, yres, GWY_INTERPOLATION_NONE);
data = gwy_data_field_get_data(dfield);
q = 1 << section->bitdepth;
z0 = q/2.0;
if (section->bitdepth == 8) {
const gchar *p = section->data;
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++)
data[i*xres + j] = (p[(yres-1 - i)*xres + j] + z0)/q;
}
}
else if (section->bitdepth == 16) {
const gint16 *p = (const gint16*)section->data;
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++) {
data[i*xres + j] = GINT16_FROM_LE(p[(yres-1 - i)*xres + j]);
data[i*xres + j] = (data[i*xres + j] + z0)/q;
}
}
}
else
g_warning("Damn! Bit depth %d is not implemented", section->bitdepth);
}
static GwyDataField*
prof_psdf(GwyDataField *dfield,
const ProfArgs *args)
{
GwyDataField *fftre, *fftim;
GwySIUnit *zunit;
const gdouble *im;
gdouble *re;
gint xres, yres, i;
fftre = gwy_data_field_new_alike(dfield, FALSE);
fftim = gwy_data_field_new_alike(dfield, FALSE);
gwy_data_field_2dfft(dfield, NULL, fftre, fftim,
args->windowing,
GWY_TRANSFORM_DIRECTION_FORWARD,
GWY_INTERPOLATION_LINEAR, /* ignored */
FALSE, 1);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
re = gwy_data_field_get_data(fftre);
im = gwy_data_field_get_data_const(fftim);
/* Put the PSDF to fftre. */
for (i = 0; i < xres*yres; i++)
re[i] = re[i]*re[i] + im[i]*im[i];
g_object_unref(fftim);
gwy_data_field_fft_postprocess(fftre, TRUE);
zunit = gwy_data_field_get_si_unit_z(fftre);
gwy_si_unit_power(gwy_data_field_get_si_unit_z(dfield), 2, zunit);
gwy_si_unit_multiply(gwy_data_field_get_si_unit_xy(dfield), zunit, zunit);
return fftre;
}
