static void
psdflp(GwyContainer *data, GwyRunType run)
{
GwyDataField *dfield, *lpsdf;
PSDFLPArgs args;
gboolean ok;
gint id, newid;
g_return_if_fail(run & PSDFLP_RUN_MODES);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield);
psdflp_load_args(gwy_app_settings_get(), &args);
if (run == GWY_RUN_INTERACTIVE) {
ok = psdflp_dialog(&args);
psdflp_save_args(gwy_app_settings_get(), &args);
if (!ok)
return;
}
lpsdf = gwy_data_field_new(1, 1, 1.0, 1.0, FALSE);
psdflp_do(&args, dfield, lpsdf);
newid = gwy_app_data_browser_add_data_field(lpsdf, data, TRUE);
g_object_unref(lpsdf);
gwy_app_set_data_field_title(data, newid, "Log-phi PSDF");
gwy_app_channel_log_add_proc(data, id, newid);
}
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 GwyDataField*
get_right_tip_field(GwyDataField *tip,
GwyDataField *surface,
gboolean *freetip)
{
GwyDataField *buffer;
gdouble tipxstep, tipystep;
gdouble surfxstep, surfystep;
*freetip = FALSE;
tipxstep = tip->xreal/tip->xres;
surfxstep = surface->xreal/surface->xres;
tipystep = tip->yreal/tip->yres;
surfystep = surface->yreal/surface->yres;
if (fabs(tipxstep/surfxstep - 1.0) > 0.01
|| fabs(tipystep/surfystep - 1.0) > 0.01) {
buffer = GWY_DATA_FIELD(gwy_data_field_new(tip->xres, tip->yres,
tip->xreal, tip->yreal,
FALSE));
gwy_data_field_copy(tip, buffer);
gwy_data_field_resample(buffer, tip->xres/surfxstep*tipxstep,
tip->yres/surfystep*tipystep,
GWY_INTERPOLATION_BILINEAR);
*freetip = TRUE;
return buffer;
}
else
return tip;
}
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
oldmda_read_data(OldMDAFile *mdafile, const gchar *buffer)
{
GwyBrick *brick;
GwyDataField *dfield;
GwyDataLine *cal;
gdouble *data;
gint i, j, k;
const guchar *p;
p = buffer;
brick = gwy_brick_new(mdafile->xres, mdafile->yres, mdafile->zres,
mdafile->xreal, mdafile->yreal, mdafile->zres,
TRUE);
data = gwy_brick_get_data(brick);
for (k = 0; k < mdafile->zres; k++) {
p = buffer + k * 4;
for (i = 0; i < mdafile->yres; i++)
for (j = 0; j < mdafile->xres; j++) {
*(data + k * mdafile->xres * mdafile->yres + j
+ (mdafile->yres - i - 1) * mdafile->xres)
= (gdouble)gwy_get_gint32_le(&p);
p += (mdafile->zres - 1) * 4;
}
}
gwy_brick_set_si_unit_x(brick, mdafile->siunitx);
gwy_brick_set_si_unit_y(brick, mdafile->siunity);
gwy_brick_set_si_unit_z(brick, mdafile->siunitz);
cal = gwy_data_line_new(mdafile->zres, mdafile->zres, FALSE);
data = gwy_data_line_get_data(cal);
for (k = 0; k < mdafile->zres; k++) {
*(data++) = g_array_index(mdafile->xdata, gdouble, k);
}
gwy_data_line_set_si_unit_y(cal, mdafile->siunitz);
gwy_brick_set_zcalibration(brick, cal);
g_object_unref(cal);
g_object_unref(mdafile->siunitx);
g_object_unref(mdafile->siunity);
g_object_unref(mdafile->siunitz);
dfield = gwy_data_field_new(mdafile->xres, mdafile->yres,
mdafile->xreal, mdafile->yreal,
TRUE);
gwy_container_set_object_by_name(mdafile->data, "/brick/0", brick);
gwy_container_set_string_by_name(mdafile->data, "/brick/0/title",
g_strdup("MDA data"));
gwy_brick_mean_plane(brick, dfield, 0, 0, 0,
mdafile->xres, mdafile->yres, -1, FALSE);
gwy_container_set_object_by_name(mdafile->data, "/brick/0/preview",
dfield);
g_object_unref(dfield);
g_object_unref(brick);
gwy_file_volume_import_log_add(mdafile->data, 0, NULL, mdafile->filename);
}
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
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++;
}
}
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 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*
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*
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;
}
/**
* gwy_data_field_crosscorrelate_init:
* @data_field1: A data field.
* @data_field2: A data field.
* @x_dist: A data field to store x-distances to, or %NULL.
* @y_dist: A data field to store y-distances to, or %NULL.
* @score: Data field to store correlation scores to, or %NULL.
* @search_width: Search area width.
* @search_height: Search area height.
* @window_width: Correlation window width.
* @window_height: Correlation window height.
*
* Initializes a cross-correlation iterator.
*
* This iterator reports its state as #GwyComputationStateType.
*
* Returns: A new cross-correlation iterator.
**/
GwyComputationState*
gwy_data_field_crosscorrelate_init(GwyDataField *data_field1,
GwyDataField *data_field2,
GwyDataField *x_dist,
GwyDataField *y_dist,
GwyDataField *score,
gint search_width,
gint search_height,
gint window_width,
gint window_height)
{
GwyCrossCorrelationState *state;
g_return_val_if_fail(GWY_IS_DATA_FIELD(data_field1), NULL);
g_return_val_if_fail(GWY_IS_DATA_FIELD(data_field2), NULL);
g_return_val_if_fail(data_field1->xres == data_field2->xres
&& data_field1->yres == data_field2->yres, NULL);
g_return_val_if_fail(!x_dist || GWY_IS_DATA_FIELD(x_dist), NULL);
g_return_val_if_fail(!y_dist || GWY_IS_DATA_FIELD(y_dist), NULL);
g_return_val_if_fail(!score || GWY_IS_DATA_FIELD(score), NULL);
state = g_new0(GwyCrossCorrelationState, 1);
state->cs.state = GWY_COMPUTATION_STATE_INIT;
state->cs.fraction = 0.0;
state->data_field1 = g_object_ref(data_field1);
state->data_field2 = g_object_ref(data_field2);
if (x_dist)
state->x_dist = g_object_ref(x_dist);
if (y_dist)
state->y_dist = g_object_ref(y_dist);
if (score)
state->score = g_object_ref(score);
state->search_width = search_width;
state->search_height = search_height;
state->window_width = window_width;
state->window_height = window_height;
state->weights = gwy_data_field_new(window_width, window_height,
window_width, window_height, 1);
gwy_data_field_fill(state->weights, 1);
return (GwyComputationState*)state;
}
static void
create_images(const X3PFile *x3pfile, GwyContainer *container)
{
gint id;
for (id = 0; id < x3pfile->zres; id++) {
GwyContainer *meta;
guint n = x3pfile->xres*x3pfile->yres, k;
GwyDataField *dfield, *mask;
const gboolean *valid = x3pfile->valid + id*n;
GQuark quark;
gchar buf[40];
dfield = gwy_data_field_new(x3pfile->xres,
x3pfile->yres,
x3pfile->xres*x3pfile->dx,
x3pfile->yres*x3pfile->dy,
FALSE);
memcpy(dfield->data, x3pfile->values + id*n, n*sizeof(gdouble));
for (k = 0; k < n; k++) {
if (!valid[k])
dfield->data[k] = NAN;
}
quark = gwy_app_get_data_key_for_id(id);
gwy_container_set_object(container, quark, dfield);
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");
gwy_app_channel_title_fall_back(container, id);
gwy_app_channel_check_nonsquare(container, id);
if ((mask = gwy_app_channel_mask_of_nans(dfield, TRUE))) {
quark = gwy_app_get_mask_key_for_id(id);
gwy_container_set_object(container, quark, mask);
g_object_unref(mask);
}
g_object_unref(dfield);
if ((meta = get_meta(x3pfile))) {
g_snprintf(buf, sizeof(buf), "/%u/meta", id);
gwy_container_set_object_by_name(container, buf, meta);
g_object_unref(meta);
}
}
}
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
rotate_datafield(GwyDataField *dfield,
RotateArgs *args)
{
gint xres, yres, xborder, yborder;
gdouble xreal, yreal, phi, min;
GwyDataField *df;
if (!args->expand) {
gwy_data_field_rotate(dfield, args->angle, args->interp);
return;
}
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
xreal = gwy_data_field_get_xreal(dfield);
yreal = gwy_data_field_get_yreal(dfield);
min = gwy_data_field_get_min(dfield);
phi = args->angle;
xborder = fabs(xres/2.0 * cos(phi)) + fabs(yres/2.0 * sin(phi));
xborder -= xres/2;
yborder = fabs(yres/2.0 * cos(phi)) + fabs(xres/2.0 * sin(phi));
yborder -= yres/2;
df = gwy_data_field_new(xres + fabs(2*xborder), yres + fabs(2*yborder), 1.0, 1.0,
FALSE);
gwy_data_field_fill(df, min);
gwy_data_field_area_copy(dfield, df, 0, 0, xres, yres, fabs(xborder), fabs(yborder));
gwy_data_field_rotate(df, args->angle, args->interp);
gwy_data_field_resample(dfield, xres + 2*xborder, yres + 2*yborder,
GWY_INTERPOLATION_NONE);
if (xborder <= 0)
gwy_data_field_area_copy(df, dfield, fabs(2*xborder), 0, xres + 2*xborder, yres + 2*yborder, 0, 0);
else {
if (yborder <= 0)
gwy_data_field_area_copy(df, dfield, 0, fabs(2*yborder), xres + 2*xborder, yres + 2*yborder, 0, 0);
else
gwy_data_field_area_copy(df, dfield, 0, 0, xres + 2*xborder, yres + 2*yborder, 0, 0);
}
gwy_data_field_set_xreal(dfield, xreal*(xres + 2.0*xborder)/xres);
gwy_data_field_set_yreal(dfield, yreal*(yres + 2.0*yborder)/yres);
g_object_unref(df);
}
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 GwyDataField*
fake_mask(GwyDataField *dfield, GwyDataField *mask, GwyMaskingType masking)
{
GwyDataField *masked;
gint xres = gwy_data_field_get_xres(dfield);
gint yres = gwy_data_field_get_yres(dfield);
const gdouble *d, *m;
gdouble *md;
gint i, n;
if (!mask || masking == GWY_MASK_IGNORE)
return dfield;
gwy_data_field_area_count_in_range(mask, NULL, 0, 0, xres, yres,
G_MAXDOUBLE, 1.0, NULL, &n);
if (masking == GWY_MASK_EXCLUDE)
n = xres*yres - n;
if (n == xres*yres)
return dfield;
masked = gwy_data_field_new(n, 1, n, 1.0, FALSE);
md = gwy_data_field_get_data(masked);
d = gwy_data_field_get_data_const(dfield);
m = gwy_data_field_get_data_const(mask);
n = 0;
for (i = 0; i < xres*yres; i++) {
gboolean mi = (m[i] >= 1.0);
if ((mi && masking == GWY_MASK_INCLUDE)
|| (!mi && masking == GWY_MASK_EXCLUDE))
md[n++] = d[i];
}
g_object_unref(dfield);
return masked;
}
static GwyContainer*
lif_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL;
LIFHeader *header = NULL;
LIFMemBlock *memblock = NULL;
LIFFile *file = NULL;
LIFElement *element = NULL;
LIFDimension *dimension = NULL;
LIFChannel *channel = NULL;
gsize size = 0, memblock_size = 0;
gint64 remaining = 0;
gchar *buffer;
const guchar *p;
GError *err = NULL;
GwyDataField *dfield = NULL;
GwyBrick *brick = NULL;
gdouble *data = NULL;
gint i, j, channelno = 0, volumeno = 0;
gchar *strkey, *lutname;
GMarkupParser parser = {
header_start_element,
header_end_element,
header_parse_text, NULL, NULL
};
GMarkupParseContext *context;
XMLParserData *xmldata;
gint x, xres, xstep, y, yres, ystep, z, zres, zstep, offset, res;
gdouble xreal, yreal, zreal, xoffset, yoffset, zoffset;
gdouble zscale = 1.0, wscale = 1.0;
GwySIUnit *siunitxy = NULL, *siunitz = NULL;
GwySIUnit *siunitx = NULL, *siunity = NULL, *siunitw = NULL;
gint power10xy = 1;
gint power10x = 1, power10y = 1, power10z = 1, power10w = 1;
if (!g_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
goto fail;
}
if (size < 13) { /* header too short */
err_TOO_SHORT(error);
goto fail;
}
p = buffer;
remaining = size;
header = g_new0(LIFHeader, 1);
header->magic = gwy_get_gint32_le(&p);
gwy_debug("Magic = %d", header->magic);
header->size = gwy_get_guint32_le(&p);
gwy_debug("Size = %d", header->size);
header->testcode = *(p++);
gwy_debug("Testcode = 0x%x", header->testcode);
if (header->testcode != TESTCODE) {
err_FILE_TYPE(error, "Leica LIF");
goto fail;
}
header->xmllen = gwy_get_guint32_le(&p);
gwy_debug("XML length = %d", header->xmllen);
if (size < 13 + header->xmllen * 2) {
err_TOO_SHORT(error);
goto fail;
}
remaining -= 13;
header->xmlheader = g_convert((const gchar*)p, 2 * header->xmllen,
"UTF-8", "UTF-16", NULL, NULL, NULL);
p += header->xmllen * 2;
remaining -= header->xmllen * 2;
// gwy_debug("%s", header->xmlheader);
/* Parse XML header */
xmldata = g_new0(XMLParserData, 1);
xmldata->file = g_new0(LIFFile, 1);
xmldata->file->elements = g_array_new(FALSE, TRUE,
sizeof(LIFElement));
xmldata->elements = g_ptr_array_new();
context = g_markup_parse_context_new(&parser,
G_MARKUP_TREAT_CDATA_AS_TEXT,
(gpointer)xmldata,
NULL);
if (!g_markup_parse_context_parse(context, header->xmlheader, -1, &err)
|| !g_markup_parse_context_end_parse(context, &err)) {
error = &err;
g_clear_error(&err);
}
g_markup_parse_context_free(context);
file = xmldata->file;
file->header = header;
g_ptr_array_free(xmldata->elements, TRUE);
g_free(xmldata);
/* Reading memblocks */
file->memblocks = g_hash_table_new(g_str_hash, g_str_equal);
while (remaining > 0) {
memblock = lif_read_memblock(p, &memblock_size, file->version);
if (!memblock) {
break;
}
remaining -= memblock_size;
if (remaining >= 0) {
gwy_debug("remaining = %" G_GUINT64_FORMAT "", remaining);
p += memblock_size;
g_hash_table_insert(file->memblocks, memblock->memid,
memblock);
}
}
container = gwy_container_new();
for (i = 0; i < file->elements->len; i++) {
element = &g_array_index(file->elements, LIFElement, i);
if ((element->dimensions == NULL)
|| (element->channels == NULL)) {
gwy_debug("Empty element");
continue;
}
gwy_debug("Dimensions = %d channels=%d",
element->dimensions->len,
element->channels->len);
gwy_debug("memid=%s", element->memid);
/* check if we can load this type of data into
* Gwyddion structures */
res = 0;
if ((element->dimensions->len != 2)
&& (element->dimensions->len != 3)) {
/* check for case ndim == 4 && res == 1 */
for (i = 0; i < element->dimensions->len; i++) {
dimension = &g_array_index(element->dimensions,
LIFDimension, i);
xres = dimension->res;
gwy_debug("dim[%d].res=%d", i, xres);
if (i == 2) {
res = xres;
}
}
if ((element->dimensions->len == 4) && (res == 1)) {
gwy_debug("4D volume");
}
else {
gwy_debug("not loading");
continue;
}
}
memblock = (LIFMemBlock *)g_hash_table_lookup(file->memblocks,
element->memid);
if (!memblock) {
gwy_debug("Failed to locate memblock with key %s",
element->memid);
continue;
}
p = memblock->data;
if (element->dimensions->len == 2) { /* Image */
for (j = 0; j < element->channels->len; j++) {
dimension = &g_array_index(element->dimensions,
LIFDimension, 0);
xres = dimension->res;
xreal = dimension->length;
xoffset = dimension->origin;
xstep = dimension->bytesinc;
siunitxy = gwy_si_unit_new_parse(dimension->unit,
&power10xy);
dimension = &g_array_index(element->dimensions,
LIFDimension, 1);
yres = dimension->res;
yreal = dimension->length;
yoffset = dimension->origin;
ystep = dimension->bytesinc;
if (xreal <= 0.0)
xreal = 1.0;
if (yreal <= 0.0)
yreal = 1.0;
channel = &g_array_index(element->channels,
LIFChannel, j);
offset = channel->bytesinc;
siunitz = gwy_si_unit_new_parse(channel->unit,
&power10z);
zscale = pow10(power10z);
if (offset + (xres - 1) * xstep + (yres - 1)* ystep
> memblock->memsize) {
gwy_debug("Memblock too small");
gwy_debug("%d %" G_GUINT64_FORMAT "",
offset + (xres-1)*xstep + (yres-1)*ystep,
memblock->memsize);
err_SIZE_MISMATCH(error,
memblock->memsize,
offset+(xres-1)*xstep
+(yres-1)*ystep,
FALSE);
goto fail;
}
dfield = gwy_data_field_new(xres, yres,
xreal*pow10(power10xy),
yreal*pow10(power10xy),
TRUE);
gwy_data_field_set_xoffset(dfield,
xoffset*pow10(power10xy));
gwy_data_field_set_yoffset(dfield,
yoffset*pow10(power10xy));
data = gwy_data_field_get_data(dfield);
for (y = 0; y < yres; y++)
for (x = 0; x < xres; x++) {
*(data++) = zscale
* (gdouble)*(p + offset + x*xstep + y*ystep);
}
if (siunitxy) {
gwy_data_field_set_si_unit_xy(dfield, siunitxy);
g_object_unref(siunitxy);
}
if (siunitz) {
gwy_data_field_set_si_unit_z(dfield, siunitz);
g_object_unref(siunitz);
}
strkey = g_strdup_printf("/%d/data", channelno);
gwy_container_set_object_by_name(container,
strkey,
dfield);
g_object_unref(dfield);
g_free(strkey);
if (element->name) {
strkey = g_strdup_printf("/%d/data/title",
channelno);
gwy_container_set_string_by_name(container, strkey,
g_strdup(element->name));
g_free(strkey);
}
if (element->metadata) {
strkey = g_strdup_printf("/%d/meta",
channelno);
gwy_container_set_object_by_name(container,
strkey,
element->metadata);
g_free(strkey);
}
if (channel->lut) {
lutname = NULL;
if (gwy_strequal(channel->lut, "Red"))
lutname = g_strdup_printf("RGB-Red");
else if (gwy_strequal(channel->lut, "Green"))
lutname = g_strdup_printf("RGB-Green");
else if (gwy_strequal(channel->lut, "Blue"))
lutname = g_strdup_printf("RGB-Blue");
else if (gwy_strequal(channel->lut, "Gray"))
lutname = g_strdup_printf("Gray");
if (lutname) {
strkey = g_strdup_printf("/%u/base/palette",
channelno);
gwy_container_set_string_by_name(container,
strkey,
lutname);
g_free(strkey);
}
}
gwy_file_channel_import_log_add(container, channelno,
NULL, filename);
channelno++;
}
}
else if ((element->dimensions->len == 3)
|| ((element->dimensions->len == 4) && (res == 1))) {
/* Volume */
for (j = 0; j < element->channels->len; j++) {
dimension = &g_array_index(element->dimensions,
LIFDimension, 0);
xres = dimension->res;
xreal = dimension->length;
xoffset = dimension->origin;
xstep = dimension->bytesinc;
siunitx = gwy_si_unit_new_parse(dimension->unit,
&power10x);
dimension = &g_array_index(element->dimensions,
LIFDimension, 1);
yres = dimension->res;
yreal = dimension->length;
yoffset = dimension->origin;
ystep = dimension->bytesinc;
siunity = gwy_si_unit_new_parse(dimension->unit,
&power10y);
if (element->dimensions->len == 3) {
dimension = &g_array_index(element->dimensions,
LIFDimension, 2);
}
else {
dimension = &g_array_index(element->dimensions,
LIFDimension, 3);
}
zres = dimension->res;
zreal = dimension->length;
zoffset = dimension->origin;
zstep = dimension->bytesinc;
siunitz = gwy_si_unit_new_parse(dimension->unit,
&power10z);
channel = &g_array_index(element->channels,
LIFChannel, j);
offset = channel->bytesinc;
siunitw = gwy_si_unit_new_parse(channel->unit,
&power10w);
wscale = pow10(power10w);
if (offset
+ (xres-1)*xstep + (yres-1)*ystep + (zres-1)*zstep
> memblock->memsize) {
gwy_debug("Memblock too small");
gwy_debug("%d %" G_GUINT64_FORMAT "",
offset + (xres-1)*xstep
+ (yres-1)*ystep + (zres-1)*zstep,
memblock->memsize);
err_SIZE_MISMATCH(error,
memblock->memsize,
offset + (xres-1)*xstep
+ (yres-1)*ystep + (zres-1)*zstep,
FALSE);
goto fail;
}
brick = gwy_brick_new(xres, yres, zres,
xreal*pow10(power10x),
yreal*pow10(power10y),
zreal*pow10(power10z),
TRUE);
gwy_brick_set_xoffset(brick, xoffset*pow10(power10x));
gwy_brick_set_yoffset(brick, yoffset*pow10(power10y));
gwy_brick_set_zoffset(brick, zoffset*pow10(power10z));
data = gwy_brick_get_data(brick);
for (z = 0; z < zres; z++)
for (y = 0; y < yres; y++)
for (x = 0; x < xres; x++) {
*(data++) = wscale * (gdouble)*(p + offset
+ x*xstep + y*ystep + z*zstep);
}
if (siunitx) {
gwy_brick_set_si_unit_x(brick, siunitx);
g_object_unref(siunitx);
}
if (siunity) {
gwy_brick_set_si_unit_y(brick, siunity);
g_object_unref(siunity);
}
if (siunitz) {
gwy_brick_set_si_unit_z(brick, siunitz);
g_object_unref(siunitz);
}
if (siunitw) {
gwy_brick_set_si_unit_w(brick, siunitw);
g_object_unref(siunitw);
}
strkey = g_strdup_printf("/brick/%d", volumeno);
gwy_container_set_object_by_name(container,
strkey,
brick);
g_free(strkey);
if (element->name) {
strkey = g_strdup_printf("/brick/%d/title",
volumeno);
gwy_container_set_string_by_name(container, strkey,
g_strdup(element->name));
g_free(strkey);
}
if (element->metadata) {
strkey = g_strdup_printf("/brick/%d/meta",
volumeno);
gwy_container_set_object_by_name(container,
strkey,
element->metadata);
g_free(strkey);
}
if (channel->lut) {
lutname = NULL;
if (gwy_strequal(channel->lut, "Red"))
lutname = g_strdup_printf("RGB-Red");
else if (gwy_strequal(channel->lut, "Green"))
lutname = g_strdup_printf("RGB-Green");
else if (gwy_strequal(channel->lut, "Blue"))
lutname = g_strdup_printf("RGB-Blue");
else if (gwy_strequal(channel->lut, "Gray"))
lutname = g_strdup_printf("Gray");
if (lutname) {
strkey = g_strdup_printf("/brick/%d/preview/palette",
volumeno);
gwy_container_set_string_by_name(container,
strkey,
lutname);
g_free(strkey);
}
}
dfield = gwy_data_field_new(xres, yres,
xreal, yreal, FALSE);
gwy_brick_mean_plane(brick, dfield,
0, 0, 0,
xres, yres, -1, FALSE);
strkey = g_strdup_printf("/brick/%d/preview",
volumeno);
gwy_container_set_object_by_name(container,
strkey,
dfield);
g_free(strkey);
g_object_unref(brick);
g_object_unref(dfield);
gwy_file_volume_import_log_add(container, volumeno,
NULL, filename);
volumeno++;
} /* for (channels) */
} /* if (volume) */
}
fail:
/* freeing all stuff */
if (file) {
if (file->memblocks) {
g_hash_table_foreach_remove(file->memblocks,
lif_remove_memblock,
NULL);
g_hash_table_unref(file->memblocks);
}
if (file->elements) {
for (i = 0; i < file->elements->len; i++) {
element = &g_array_index(file->elements, LIFElement, i);
if (element->dimensions) {
for (j = 0; j < element->dimensions->len; j++) {
dimension = &g_array_index(element->dimensions,
LIFDimension, j);
if (dimension->unit)
g_free(dimension->unit);
}
g_array_free(element->dimensions, TRUE);
}
if (element->channels) {
for (j = 0; j < element->channels->len; j++) {
channel = &g_array_index(element->channels,
LIFChannel, j);
if (channel->unit)
g_free(channel->unit);
if (channel->lut)
g_free(channel->lut);
}
g_array_free(element->channels, TRUE);
}
if (element->name)
g_free(element->name);
if (element->memid)
g_free(element->memid);
if (element->metadata)
g_object_unref(element->metadata);
}
g_array_free(file->elements, TRUE);
}
g_free(file);
}
if (header->xmlheader)
g_free(header->xmlheader);
if (header) {
g_free(header);
}
return container;
}
static GwyContainer*
burleigh_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;
IMGFile imgfile;
GwyDataField *dfield;
gdouble *data;
const gint16 *d;
gdouble zoom;
guint i;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < HEADER_SIZE_MIN + 2) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
gwy_clear(&imgfile, 1);
p = buffer;
imgfile.version = gwy_get_gfloat_le(&p);
imgfile.version_int = GWY_ROUND(10*imgfile.version);
if (imgfile.version_int == 21) {
d = burleigh_load_v21(&imgfile, buffer, size, error);
if (!d) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
}
else {
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("File format version %.1f is not supported."),
imgfile.version);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
zoom = burleigh_get_zoom_v21(&imgfile);
if (err_DIMENSION(error, imgfile.xres)
|| err_DIMENSION(error, imgfile.yres)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
dfield = gwy_data_field_new(imgfile.xres, imgfile.yres,
Angstrom*imgfile.xrange/zoom,
Angstrom*imgfile.yrange/zoom,
FALSE);
data = gwy_data_field_get_data(dfield);
for (i = 0; i < imgfile.xres*imgfile.yres; i++)
data[i] = GINT16_FROM_LE(d[i])*imgfile.zrange/4095.0;
gwy_file_abandon_contents(buffer, size, NULL);
unit = gwy_si_unit_new("m");
gwy_data_field_set_si_unit_xy(dfield, unit);
g_object_unref(unit);
container = gwy_container_new();
switch (imgfile.data_type) {
case BURLEIGH_CURRENT:
unit = gwy_si_unit_new("A");
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Current"));
gwy_data_field_multiply(dfield, Picoampere);
break;
case BURLEIGH_TOPOGRAPHY:
unit = gwy_si_unit_new("m");
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Topography"));
gwy_data_field_multiply(dfield, Angstrom);
break;
default:
unit = gwy_si_unit_new("m");
break;
}
gwy_data_field_set_si_unit_z(dfield, unit);
g_object_unref(unit);
gwy_container_set_object_by_name(container, "/0/data", dfield);
g_object_unref(dfield);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
return container;
}
static void
preview(DepositControls *controls,
DepositArgs *args)
{
GwyDataField *dfield, *lfield, *zlfield, *zdfield;
gint xres, yres, oxres, oyres;
gint add, i, ii, m, k;
gdouble size, width;
gint xdata[10000];
gint ydata[10000];
gdouble disizes[10000];
gdouble rdisizes[10000];
gdouble rx[10000];
gdouble ry[10000];
gdouble rz[10000];
gdouble ax[10000];
gdouble ay[10000];
gdouble az[10000];
gdouble vx[10000];
gdouble vy[10000];
gdouble vz[10000];
gdouble fx[10000];
gdouble fy[10000];
gdouble fz[10000];
gint xpos, ypos, ndata, too_close;
gdouble disize, mdisize;
gdouble xreal, yreal, oxreal, oyreal;
gdouble diff;
gdouble mass = 1;
gint presetval;
gint nloc, maxloc = 1;
gint max = 5000000;
gdouble rxv, ryv, rzv, timestep = 3e-7; //5e-7
deposit_dialog_update_values(controls, args);
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/data"));
gwy_container_set_object_by_name(controls->mydata, "/0/data", gwy_data_field_duplicate(controls->old_dfield));
dfield = GWY_DATA_FIELD(gwy_container_get_object_by_name(controls->mydata,
"/0/data"));
if (controls->in_init)
{
gwy_data_field_data_changed(dfield);
while (gtk_events_pending())
gtk_main_iteration();
return;
}
oxres = gwy_data_field_get_xres(dfield);
oyres = gwy_data_field_get_yres(dfield);
oxreal = gwy_data_field_get_xreal(dfield);
oyreal = gwy_data_field_get_yreal(dfield);
diff = oxreal/oxres/10;
size = args->size*5e-9;
// width = args->width*5e-9 + 2*size; //increased manually to fill boundaries
width = 2*size;
add = gwy_data_field_rtoi(dfield, size + width);
mdisize = gwy_data_field_rtoi(dfield, size);
xres = oxres + 2*add;
yres = oyres + 2*add;
xreal = oxreal + 2*(size+width);
yreal = oyreal + 2*(size+width);
// printf("For field of size %g and particle nominak %g, real %g (%g), the final size will change from %d to %d\n",
// gwy_data_field_get_xreal(dfield), args->size, size, disize, oxres, xres);
/*make copy of datafield, with mirrored boundaries*/
lfield = gwy_data_field_new(xres, yres,
gwy_data_field_itor(dfield, xres),
gwy_data_field_jtor(dfield, yres),
TRUE);
gwy_data_field_area_copy(dfield, lfield, 0, 0, oxres, oyres, add, add);
gwy_data_field_invert(dfield, 1, 0, 0);
gwy_data_field_area_copy(dfield, lfield, 0, oyres-add-1, oxres, add, add, 0);
gwy_data_field_area_copy(dfield, lfield, 0, 0, oxres, add, add, yres-add-1);
gwy_data_field_invert(dfield, 1, 0, 0);
gwy_data_field_invert(dfield, 0, 1, 0);
gwy_data_field_area_copy(dfield, lfield, oxres-add-1, 0, add, oyres, 0, add);
gwy_data_field_area_copy(dfield, lfield, 0, 0, add, oyres, xres-add-1, add);
gwy_data_field_invert(dfield, 0, 1, 0);
gwy_data_field_invert(dfield, 1, 1, 0);
gwy_data_field_area_copy(dfield, lfield, oxres-add-1, oyres-add-1, add, add, 0, 0);
gwy_data_field_area_copy(dfield, lfield, 0, 0, add, add, xres-add-1, yres-add-1);
gwy_data_field_area_copy(dfield, lfield, oxres-add-1, 0, add, add, 0, yres-add-1);
gwy_data_field_area_copy(dfield, lfield, 0, oyres-add-1, add, add, xres-add-1, 0);
gwy_data_field_invert(dfield, 1, 1, 0);
zlfield = gwy_data_field_duplicate(lfield);
zdfield = gwy_data_field_duplicate(dfield);
/*determine number of spheres necessary for given coverage*/
for (i=0; i<10000; i++)
{
ax[i] = ay[i] = az[i] = vx[i] = vy[i] = vz[i] = 0;
}
srand ( time(NULL) );
ndata = 0;
/* for test only */
/*
disize = mdisize;
xpos = oxres/2 - 2*disize;
ypos = oyres/2;
xdata[ndata] = xpos;
ydata[ndata] = ypos;
disizes[ndata] = disize;
rdisizes[ndata] = size;
rx[ndata] = (gdouble)xpos*oxreal/(gdouble)oxres;
ry[ndata] = (gdouble)ypos*oyreal/(gdouble)oyres;
rz[ndata] = 2.0*gwy_data_field_get_val(lfield, xpos, ypos) + rdisizes[ndata];
ndata++;
xpos = oxres/2 + 2*disize;
ypos = oyres/2;
xdata[ndata] = xpos;
ydata[ndata] = ypos;
disizes[ndata] = disize;
rdisizes[ndata] = size;
rx[ndata] = (gdouble)xpos*oxreal/(gdouble)oxres;
ry[ndata] = (gdouble)ypos*oyreal/(gdouble)oyres;
rz[ndata] = 2.0*gwy_data_field_get_val(lfield, xpos, ypos) + rdisizes[ndata];
ndata++;
*/
/*end of test*/
i = 0;
presetval = args->coverage*10;
while (ndata < presetval && i<max)
{
//disize = mdisize*(0.8+(double)(rand()%20)/40.0);
disize = mdisize;
xpos = disize+(rand()%(xres-2*(gint)(disize+1))) + 1;
ypos = disize+(rand()%(yres-2*(gint)(disize+1))) + 1;
i++;
{
too_close = 0;
/*sync real to integer positions*/
for (k=0; k<ndata; k++)
{
if (((xpos-xdata[k])*(xpos-xdata[k]) + (ypos-ydata[k])*(ypos-ydata[k]))<(4*disize*disize))
{
too_close = 1;
break;
}
}
if (too_close) continue;
if (ndata>=10000) {
break;
}
xdata[ndata] = xpos;
ydata[ndata] = ypos;
disizes[ndata] = disize;
rdisizes[ndata] = size;
rx[ndata] = (gdouble)xpos*oxreal/(gdouble)oxres;
ry[ndata] = (gdouble)ypos*oyreal/(gdouble)oyres;
//printf("surface at %g, particle size %g\n", gwy_data_field_get_val(lfield, xpos, ypos), rdisizes[ndata]);
rz[ndata] = 1.0*gwy_data_field_get_val(lfield, xpos, ypos) + rdisizes[ndata]; //2
ndata++;
}
};
// if (i==max) printf("Maximum reached, only %d particles depositd instead of %d\n", ndata, presetval);
// else printf("%d particles depositd\n", ndata);
/*refresh shown data and integer positions (necessary in md calculation)*/
gwy_data_field_copy(zlfield, lfield, 0);
showit(lfield, zdfield, rdisizes, rx, ry, rz, xdata, ydata, ndata,
oxres, oxreal, oyres, oyreal, add, xres, yres);
gwy_data_field_area_copy(lfield, dfield, add, add, oxres, oyres, 0, 0);
gwy_data_field_data_changed(dfield);
for (i=0; i<(20*args->revise); i++)
{
// printf("###### step %d of %d ##########\n", i, (gint)(20*args->revise));
/*try to add some particles if necessary, do this only for first half of molecular dynamics*/
if (ndata<presetval && i<(10*args->revise)) {
ii = 0;
nloc = 0;
while (ndata < presetval && ii<(max/1000) && nloc<maxloc)
{
disize = mdisize;
xpos = disize+(rand()%(xres-2*(gint)(disize+1))) + 1;
ypos = disize+(rand()%(yres-2*(gint)(disize+1))) + 1;
ii++;
{
too_close = 0;
rxv = ((gdouble)xpos*oxreal/(gdouble)oxres);
ryv = ((gdouble)ypos*oyreal/(gdouble)oyres);
rzv = gwy_data_field_get_val(zlfield, xpos, ypos) + 5*size;
for (k=0; k<ndata; k++)
{
if (((rxv-rx[k])*(rxv-rx[k])
+ (ryv-ry[k])*(ryv-ry[k])
+ (rzv-rz[k])*(rzv-rz[k]))<(4.0*size*size))
{
too_close = 1;
break;
}
}
if (too_close) continue;
if (ndata>=10000) {
// printf("Maximum reached!\n");
break;
}
xdata[ndata] = xpos;
ydata[ndata] = ypos;
disizes[ndata] = disize;
rdisizes[ndata] = size;
rx[ndata] = rxv;
ry[ndata] = ryv;
rz[ndata] = rzv;
vz[ndata] = -0.01;
ndata++;
nloc++;
}
};
// if (ii==(max/100)) printf("Maximum reached, only %d particles now present instead of %d\n", ndata, presetval);
// else printf("%d particles now at surface\n", ndata);
}
/*test succesive LJ steps on substrate (no relaxation)*/
for (k=0; k<ndata; k++)
{
fx[k] = fy[k] = fz[k] = 0;
/*calculate forces for all particles on substrate*/
if (gwy_data_field_rtoi(lfield, rx[k])<0
|| gwy_data_field_rtoj(lfield, ry[k])<0
|| gwy_data_field_rtoi(lfield, rx[k])>=xres
|| gwy_data_field_rtoj(lfield, ry[k])>=yres)
continue;
for (m=0; m<ndata; m++)
{
if (m==k) continue;
// printf("(%g %g %g) on (%g %g %g)\n", rx[m], ry[m], rz[m], rx[k], ry[k], rz[k]);
fx[k] -= (get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k]+diff, ry[k], rz[k], gwy_data_field_itor(dfield, disizes[k]))
-get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k]-diff, ry[k], rz[k], gwy_data_field_itor(dfield, disizes[k])))/2/diff;
fy[k] -= (get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k]+diff, rz[k], gwy_data_field_itor(dfield, disizes[k]))
-get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k]-diff, rz[k], gwy_data_field_itor(dfield, disizes[k])))/2/diff;
fz[k] -= (get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k], rz[k]+diff, gwy_data_field_itor(dfield, disizes[k]))
-get_lj_potential_spheres(rx[m], ry[m], rz[m], rx[k], ry[k], rz[k]-diff, gwy_data_field_itor(dfield, disizes[k])))/2/diff;
}
fx[k] -= (integrate_lj_substrate(zlfield, rx[k]+diff, ry[k], rz[k], rdisizes[k])
- integrate_lj_substrate(zlfield, rx[k]-diff, ry[k], rz[k], rdisizes[k]))/2/diff;
fy[k] -= (integrate_lj_substrate(zlfield, rx[k], ry[k]-diff, rz[k], rdisizes[k])
- integrate_lj_substrate(zlfield, rx[k], ry[k]+diff, rz[k], rdisizes[k]))/2/diff;
fz[k] -= (integrate_lj_substrate(zlfield, rx[k], ry[k], rz[k]+diff, rdisizes[k])
- integrate_lj_substrate(zlfield, rx[k], ry[k], rz[k]-diff, rdisizes[k]))/2/diff;
}
for (k=0; k<ndata; k++)
{
if (gwy_data_field_rtoi(lfield, rx[k])<0
|| gwy_data_field_rtoj(lfield, ry[k])<0
|| gwy_data_field_rtoi(lfield, rx[k])>=xres
|| gwy_data_field_rtoj(lfield, ry[k])>=yres)
continue;
/*move all particles*/
rx[k] += vx[k]*timestep + 0.5*ax[k]*timestep*timestep;
vx[k] += 0.5*ax[k]*timestep;
ax[k] = fx[k]/mass;
vx[k] += 0.5*ax[k]*timestep;
vx[k] *= 0.9;
if (fabs(vx[k])>0.01) vx[k] = 0; //0.2
ry[k] += vy[k]*timestep + 0.5*ay[k]*timestep*timestep;
vy[k] += 0.5*ay[k]*timestep;
ay[k] = fy[k]/mass;
vy[k] += 0.5*ay[k]*timestep;
vy[k] *= 0.9;
if (fabs(vy[k])>0.01) vy[k] = 0; //0.2
rz[k] += vz[k]*timestep + 0.5*az[k]*timestep*timestep;
vz[k] += 0.5*az[k]*timestep;
az[k] = fz[k]/mass;
vz[k] += 0.5*az[k]*timestep;
vz[k] *= 0.9;
if (fabs(vz[k])>0.01) vz[k] = 0;
if (rx[k]<=gwy_data_field_itor(dfield, disizes[k])) rx[k] = gwy_data_field_itor(dfield, disizes[k]);
if (ry[k]<=gwy_data_field_itor(dfield, disizes[k])) ry[k] = gwy_data_field_itor(dfield, disizes[k]);
if (rx[k]>=(xreal-gwy_data_field_itor(dfield, disizes[k]))) rx[k] = xreal-gwy_data_field_itor(dfield, disizes[k]);
if (ry[k]>=(yreal-gwy_data_field_itor(dfield, disizes[k]))) ry[k] = yreal-gwy_data_field_itor(dfield, disizes[k]);
}
gwy_data_field_copy(zlfield, lfield, 0);
showit(lfield, zdfield, rdisizes, rx, ry, rz, xdata, ydata, ndata,
oxres, oxreal, oyres, oyreal, add, xres, yres);
gwy_data_field_area_copy(lfield, dfield, add, add, oxres, oyres, 0, 0);
gwy_data_field_data_changed(dfield);
while (gtk_events_pending())
gtk_main_iteration();
}
gwy_data_field_area_copy(lfield, dfield, add, add, oxres, oyres, 0, 0);
gwy_data_field_data_changed(dfield);
args->computed = TRUE;
gwy_object_unref(lfield);
gwy_object_unref(zlfield);
gwy_object_unref(zdfield);
}
static GwyContainer*
burleigh_load(const gchar *filename)
{
GwySIUnit *unit;
GwyContainer *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize size = 0;
GError *err = NULL;
IMGFile imgfile;
GwyDataField *dfield;
gdouble *data;
const gint16 *d;
gdouble scale;
guint i;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
g_warning("Cannot get file contents");
g_clear_error(&err);
return NULL;
}
if (size < HEADER_SIZE_MIN + 2) {
g_warning("File is too short");
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
memset(&imgfile, 0, sizeof(imgfile));
p = buffer;
imgfile.version = get_FLOAT(&p);
imgfile.version_int = ROUND(10*imgfile.version);
if (imgfile.version_int == 21) {
d = burleigh_load_v21(&imgfile, buffer, size);
if (!d) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
}
else {
g_warning("File format version %.f is not supported", imgfile.version);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
dfield = GWY_DATA_FIELD(gwy_data_field_new(imgfile.xres, imgfile.yres,
Angstrom*imgfile.xrange,
Angstrom*imgfile.yrange,
FALSE));
data = gwy_data_field_get_data(dfield);
scale = Angstrom * imgfile.z_gain * imgfile.zrange;
for (i = 0; i < imgfile.xres*imgfile.yres; i++)
data[i] = scale * GINT16_FROM_LE(d[i]);
gwy_file_abandon_contents(buffer, size, NULL);
unit = GWY_SI_UNIT(gwy_si_unit_new("m"));
gwy_data_field_set_si_unit_xy(dfield, unit);
g_object_unref(unit);
container = GWY_CONTAINER(gwy_container_new());
switch (imgfile.data_type) {
case BURLEIGH_CURRENT:
unit = GWY_SI_UNIT(gwy_si_unit_new("A"));
gwy_container_set_string_by_name(container, "/filename/title",
g_strdup("Current"));
break;
case BURLEIGH_TOPOGRAPHY:
unit = GWY_SI_UNIT(gwy_si_unit_new("m"));
gwy_container_set_string_by_name(container, "/filename/title",
g_strdup("Topography"));
break;
default:
unit = GWY_SI_UNIT(gwy_si_unit_new("m"));
break;
}
gwy_data_field_set_si_unit_z(dfield, unit);
g_object_unref(unit);
gwy_container_set_object_by_name(container, "/0/data", (GObject*)dfield);
g_object_unref(dfield);
return container;
}
int main(int argc, char *argv[])
{
GdkPixbuf *pxb;
GError *error=NULL;
guchar *buffer;
gsize size, pos;
FILE *fh;
gint i, j;
GwyDataField *a, *b, *c, *d, *p;
GwyDataLine *k, *m, n;
GwyPalette *pal;
g_type_init();
g_message("preparing data_field...");
a = (GwyDataField *) gwy_data_field_new(512, 512, 512, 512, 1);
b = (GwyDataField *) gwy_data_field_new(512, 512, 512, 512, 1);
c = (GwyDataField *) gwy_data_field_new(512, 512, 512, 512, 1);
d = (GwyDataField *) gwy_data_field_new(512, 512, 512, 512, 1);
p = (GwyDataField *) gwy_data_field_new(512, 512, 512, 512, 1);
k = (GwyDataLine *) gwy_data_line_new(20, 20, 1);
m = (GwyDataLine *) gwy_data_line_new(500, 20, 1);
gwy_data_line_initialize(&n, 500, 20, 1);
make_test_image(a);
make_test_image(p);
make_test_line(m);
// gwy_data_line_hhcf(m, k);
gwy_data_field_get_line_stat_function(a, &n,
0, 0, 300, 300, /*GwySFOutputType*/ GWY_SF_OUTPUT_PSDF, /*GtkOrientation*/ 0,
/*interpolation*/ 1, /*GwyWindowingType*/ 1, /*nstats*/ 200);
printf("Dataline:\n");
for (i=0; i<10; i++) printf("%d %f\n", i, n.data[i]);
/*
gwy_data_field_2dfft(a, b, c, d, gwy_data_line_fft_hum, GWY_WINDOWING_RECT, 1, GWY_INTERPOLATION_BILINEAR, 0, 0);
gwy_data_field_copy(c, a);
gwy_data_field_copy(d, b);
gwy_data_field_fill(c, 0);
gwy_data_field_fill(d, 0);
gwy_data_field_2dfft(a, b, c, d, gwy_data_line_fft_hum, GWY_WINDOWING_RECT, -1, GWY_INTERPOLATION_BILINEAR, 0, 0);
*/
/* for (i=0; i<512; i++)
{
printf("%f %f\n", a->data[20 + 512*i], //sqrt(a->data[20 + 512*i]*a->data[20 + 512*i]+ b->data[20 + 512*i]*b->data[20 + 512*i]),
p->data[20 + 512*i]);
}
*/
/*
gwy_palette_def_setup_presets();
pal = (GwyPalette*) gwy_palette_new(NULL);
gwy_palette_set_by_name(pal, GWY_PALETTE_OLIVE);
pxb = gdk_pixbuf_new(GDK_COLORSPACE_RGB, FALSE, 8, a->xres, a->yres);
gwy_pixfield_do(pxb, a, pal);
gdk_pixbuf_save(pxb, "a.jpg", "jpeg", &error, "quality", "100", NULL);
gwy_pixfield_do(pxb, b, pal);
gdk_pixbuf_save(pxb, "b.jpg", "jpeg", &error, "quality", "100", NULL);
gwy_pixfield_do(pxb, c, pal);
gdk_pixbuf_save(pxb, "c.jpg", "jpeg", &error, "quality", "100", NULL);
gwy_pixfield_do(pxb, d, pal);
gdk_pixbuf_save(pxb, "d.jpg", "jpeg", &error, "quality", "100", NULL);
*/
return 0;
}
static GwyContainer*
ezdfile_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *meta, *container = NULL;
guchar *buffer = NULL;
gsize size = 0;
GError *err = NULL;
EZDSection *section = NULL;
GwyDataField *dfield = NULL;
GPtrArray *ezdfile;
guint header_size, n;
gint i;
gchar *p;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (strncmp(buffer, MAGIC, MAGIC_SIZE)
|| !(header_size = find_data_start(buffer, size))) {
err_FILE_TYPE(error, "EZD/NID");
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
ezdfile = g_ptr_array_new();
p = g_strndup(buffer, header_size - DATA_MAGIC_SIZE);
if (!file_read_header(ezdfile, p, error)) {
gwy_file_abandon_contents(buffer, size, NULL);
g_free(p);
return NULL;
}
g_free(p);
n = find_data_offsets(buffer + header_size, size - header_size, ezdfile,
error);
if (!n) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
container = gwy_container_new();
i = 0;
for (n = 0; n < ezdfile->len; n++) {
gchar key[24];
section = (EZDSection*)g_ptr_array_index(ezdfile, n);
if (!section->data)
continue;
dfield = gwy_data_field_new(section->xres, section->yres,
1.0, 1.0, FALSE);
read_data_field(dfield, section);
g_snprintf(key, sizeof(key), "/%d/data", i);
gwy_container_set_object_by_name(container, key, dfield);
g_object_unref(dfield);
fix_scales(section, i, container);
meta = ezdfile_get_metadata(ezdfile, n);
if (meta) {
g_snprintf(key, sizeof(key), "/%d/meta", i);
gwy_container_set_object_by_name(container, key, meta);
g_object_unref(meta);
}
i++;
}
gwy_file_abandon_contents(buffer, size, NULL);
ezdfile_free(ezdfile);
return container;
}
static GwyDataField*
pt3file_extract_counts(const PicoHarpFile *pt3file,
const LineTrigger *linetriggers,
const guchar *p)
{
GwyDataField *dfield;
guint xres, yres, i, lineno, pixno, n;
guint64 globaltime, globalbase, start, stop;
gdouble pix_resol;
gdouble *d;
xres = pt3file->imaging.common.xres;
yres = pt3file->imaging.common.yres;
n = pt3file->number_of_records;
if (pt3file->imaging.common.instrument == PICO_HARP_PIE710)
pix_resol = pt3file->imaging.pie710.pix_resol;
else if (pt3file->imaging.common.instrument == PICO_HARP_KDT180)
pix_resol = pt3file->imaging.kdt180.pix_resol;
else {
g_return_val_if_reached(NULL);
}
if (!(pix_resol = fabs(pix_resol))) {
g_warning("Pixel size is 0.0, fixing to 1.0");
pix_resol = 1.0;
}
pix_resol *= 1e-6;
dfield = gwy_data_field_new(xres, yres, pix_resol*xres, pix_resol*yres,
TRUE);
gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m");
d = gwy_data_field_get_data(dfield);
lineno = 0;
start = linetriggers[lineno].start;
stop = linetriggers[lineno].stop;
globaltime = globalbase = 0;
for (i = 0; i < n; i++) {
PicoHarpT3Record rec;
p = read_t3_record(&rec, p);
if (rec.channel == 15) {
if (rec.nsync == 0 && rec.time == 0)
globalbase += 0x10000;
continue;
}
globaltime = globalbase | rec.nsync;
while (lineno < yres && globaltime >= linetriggers[lineno].stop) {
lineno++;
if (lineno == yres)
break;
start = linetriggers[lineno].start;
stop = linetriggers[lineno].stop;
}
if (globaltime >= start && globaltime < stop) {
pixno = (xres*(globaltime - start)/(stop - start));
pixno = MIN(pixno, xres-1);
if (pt3file->imaging.common.bidirectional && lineno % 2)
d[xres*lineno + (xres-1 - pixno)] += 1.0;
else
d[xres*lineno + pixno] += 1.0;
}
}
return dfield;
}
static GwyContainer*
amb_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gdouble *data;
guint i, j;
gsize size = 0;
GError *err = NULL;
guint xres, yres;
GwyDataField *dfield;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size <= HEADER_SIZE) {
err_TOO_SHORT(error);
goto fail;
}
/* The two bytes before are usually zeroes */
p = buffer + XRES_OFFSET;
xres = gwy_get_guint32_le(&p);
p = buffer + YRES_OFFSET;
yres = gwy_get_guint32_le(&p);
gwy_debug("xres: %u yres: %u", xres, yres);
/* The four bytes after might be a float, then there are four more bytes. */
if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres))
goto fail;
if (err_SIZE_MISMATCH(error, 4*xres*yres + HEADER_SIZE, size, TRUE))
goto fail;
dfield = gwy_data_field_new(xres, yres, 1.0, 1.0*yres/xres,
FALSE);
data = gwy_data_field_get_data(dfield);
p = buffer + HEADER_SIZE;
for (i = 0; i < yres; i++) {
for (j = 0; j < xres; j++)
data[i*xres + j] = gwy_get_gfloat_le(&p);
}
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");
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);
fail:
gwy_file_abandon_contents(buffer, size, NULL);
return container;
}
static void
gwy_data_field_facet_distribution(GwyDataField *dfield,
gint kernel_size,
GwyContainer *container)
{
GwyDataField *dtheta, *dphi, *dist;
GwySIUnit *siunit;
gdouble *xd, *yd, *data;
const gdouble *xdc, *ydc;
gdouble q, max;
gint res, hres, i, j, mi, mj, xres, yres;
if (gwy_container_gis_object_by_name(container, "/theta", &dtheta))
g_object_ref(dtheta);
else
dtheta = gwy_data_field_new_alike(dfield, FALSE);
if (gwy_container_gis_object_by_name(container, "/phi", &dphi))
g_object_ref(dphi);
else
dphi = gwy_data_field_new_alike(dfield, FALSE);
compute_slopes(dfield, kernel_size, dtheta, dphi);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
xd = gwy_data_field_get_data(dtheta);
yd = gwy_data_field_get_data(dphi);
for (i = xres*yres; i; i--, xd++, yd++) {
gdouble theta, phi;
slopes_to_angles(*xd, *yd, &theta, &phi);
*xd = theta;
*yd = phi;
}
q = gwy_data_field_get_max(dtheta);
q = MIN(q*1.05, G_PI/2.0);
q = G_SQRT2/(2.0*sin(q/2.0));
if (gwy_container_gis_object_by_name(container, "/0/data", &dist)) {
g_object_ref(dist);
gwy_data_field_clear(dist);
gwy_data_field_set_xreal(dist, 2.0*G_SQRT2/q);
gwy_data_field_set_yreal(dist, 2.0*G_SQRT2/q);
}
else {
dist = gwy_data_field_new(FDATA_RES, FDATA_RES,
2.0*G_SQRT2/q, 2.0*G_SQRT2/q,
TRUE);
siunit = gwy_si_unit_new("");
gwy_data_field_set_si_unit_z(dist, siunit);
g_object_unref(siunit);
/* FIXME */
siunit = gwy_si_unit_new("");
gwy_data_field_set_si_unit_xy(dist, siunit);
g_object_unref(siunit);
}
res = FDATA_RES;
hres = (res - 1)/2;
data = gwy_data_field_get_data(dist);
xdc = gwy_data_field_get_data_const(dtheta);
ydc = gwy_data_field_get_data_const(dphi);
for (i = xres*yres; i; i--, xdc++, ydc++) {
gdouble x, y;
gint xx, yy;
angles_to_xy(*xdc, *ydc, &x, &y);
xx = GWY_ROUND(q*x/G_SQRT2*hres) + hres;
yy = GWY_ROUND(q*y/G_SQRT2*hres) + hres;
data[yy*res + xx] += 1.0;
}
/* Find maxima */
mi = mj = hres;
max = 0;
for (i = 1; i+1 < res; i++) {
for (j = 1; j+1 < res; j++) {
gdouble z;
z = data[i*res + j]
+ 0.3*(data[i*res + j - 1]
+ data[i*res + j + 1]
+ data[i*res - res + j]
+ data[i*res + res + j])
+ 0.1*(data[i*res - res + j - 1]
+ data[i*res - res + j + 1]
+ data[i*res + res + j - 1]
+ data[i*res + res + j + 1]);
if (G_UNLIKELY(z > max)) {
max = z;
mi = i;
mj = j;
}
}
}
for (i = res*res; i; i--, data++)
*data = pow(*data, 0.35);
gwy_container_set_double_by_name(container, "/q", q);
{
gdouble x, y, theta, phi;
x = (mj - hres)*G_SQRT2/(q*hres);
y = (mi - hres)*G_SQRT2/(q*hres);
xy_to_angles(x, y, &theta, &phi);
gwy_container_set_double_by_name(container, "/theta0", theta);
gwy_container_set_double_by_name(container, "/phi0", phi);
}
gwy_container_set_object_by_name(container, "/0/data", dist);
g_object_unref(dist);
gwy_container_set_object_by_name(container, "/theta", dtheta);
g_object_unref(dtheta);
gwy_container_set_object_by_name(container, "/phi", dphi);
g_object_unref(dphi);
gwy_container_set_string_by_name(container, "/0/base/palette",
g_strdup(FVIEW_GRADIENT));
gwy_data_field_data_changed(dist);
}
static void
fill_data_fields(SurfFile *surffile,
const guchar *buffer)
{
gdouble *data;
guint i, j;
surffile->dfield = GWY_DATA_FIELD(gwy_data_field_new(surffile->xres,
surffile->yres,
surffile->xres*surffile->dx,
surffile->yres*surffile->dy,
TRUE));
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:
g_warning("Wrong data size: %d", surffile->pointsize);
break;
}
/*
data = gwy_data_field_get_data(surffile->dfield);
for (i = 0; i < surffile->xres; i++) {
for (j = 0; j < surffile->yres; j++) {
if (surffile->pointsize == 16) {
*(data++) = (gdouble)*(gint16*)buffer*surffile->dz;
buffer += 2;
}
else {
*(data++) = ((gdouble)*(gint32*)buffer)*surffile->dz;
buffer += 4;
}
}
}
*/
if (surffile->dx > surffile->dy)
gwy_data_field_resample(surffile->dfield, (gint)((gdouble)(surffile->xres)*surffile->dx/surffile->dy),
surffile->yres, GWY_INTERPOLATION_BILINEAR);
else if (surffile->dy > surffile->dx)
gwy_data_field_resample(surffile->dfield, surffile->xres,
(gint)((gdouble)(surffile->yres)*surffile->dy/surffile->dx),
GWY_INTERPOLATION_BILINEAR);
}
