static GwyContainer*
surffile_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
SurfFile surffile;
gint coef = 0;
GwyContainer *meta, *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize expected_size, size = 0;
GError *err = NULL;
gchar signature[12];
gint add = 0;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < SURF_HEADER_SIZE + 2) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
p = buffer;
get_CHARARRAY(signature, &p);
if (strncmp(signature, "DIGITAL SURF", 12) != 0) {
err_FILE_TYPE(error, "Surf");
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
surffile.format = gwy_get_guint16_le(&p);
surffile.nobjects = gwy_get_guint16_le(&p);
surffile.version = gwy_get_guint16_le(&p);
surffile.type = gwy_get_guint16_le(&p);
get_CHARS0(surffile.object_name, &p, 30);
get_CHARS0(surffile.operator_name, &p, 30);
surffile.material_code = gwy_get_guint16_le(&p);
surffile.acquisition = gwy_get_guint16_le(&p);
surffile.range = gwy_get_guint16_le(&p);
surffile.special_points = gwy_get_guint16_le(&p);
surffile.absolute = gwy_get_guint16_le(&p);
/*reserved*/
p += 8;
surffile.pointsize = gwy_get_guint16_le(&p);
surffile.zmin = gwy_get_gint32_le(&p);
surffile.zmax = gwy_get_gint32_le(&p);
surffile.xres = gwy_get_gint32_le(&p);
surffile.yres = gwy_get_gint32_le(&p);
surffile.nofpoints = gwy_get_guint32_le(&p);
surffile.dx = gwy_get_gfloat_le(&p);
surffile.dy = gwy_get_gfloat_le(&p);
surffile.dz = gwy_get_gfloat_le(&p);
get_CHARS0(surffile.xaxis, &p, 16);
get_CHARS0(surffile.yaxis, &p, 16);
get_CHARS0(surffile.zaxis, &p, 16);
get_CHARS0(surffile.dx_unit, &p, 16);
get_CHARS0(surffile.dy_unit, &p, 16);
get_CHARS0(surffile.dz_unit, &p, 16);
get_CHARS0(surffile.xlength_unit, &p, 16);
get_CHARS0(surffile.ylength_unit, &p, 16);
get_CHARS0(surffile.zlength_unit, &p, 16);
surffile.xunit_ratio = gwy_get_gfloat_le(&p);
surffile.yunit_ratio = gwy_get_gfloat_le(&p);
surffile.zunit_ratio = gwy_get_gfloat_le(&p);
surffile.imprint = gwy_get_guint16_le(&p);
surffile.inversion = gwy_get_guint16_le(&p);
surffile.leveling = gwy_get_guint16_le(&p);
p += 12;
surffile.seconds = gwy_get_guint16_le(&p);
surffile.minutes = gwy_get_guint16_le(&p);
surffile.hours = gwy_get_guint16_le(&p);
surffile.day = gwy_get_guint16_le(&p);
surffile.month = gwy_get_guint16_le(&p);
surffile.year = gwy_get_guint16_le(&p);
surffile.dayof = gwy_get_guint16_le(&p);
surffile.measurement_duration = gwy_get_gfloat_le(&p);
p += 10;
surffile.comment_size = gwy_get_guint16_le(&p);
surffile.private_size = gwy_get_guint16_le(&p);
get_CHARARRAY(surffile.client_zone, &p);
surffile.XOffset = gwy_get_gfloat_le(&p);
surffile.YOffset = gwy_get_gfloat_le(&p);
surffile.ZOffset = gwy_get_gfloat_le(&p);
gwy_debug("fileformat: %d, n_of_objects: %d, "
"version: %d, object_type: %d",
surffile.format, surffile.nobjects,
surffile.version, surffile.type);
gwy_debug("object name: <%s>", surffile.object_name);
gwy_debug("operator name: <%s>", surffile.operator_name);
gwy_debug("material code: %d, acquisition type: %d",
surffile.material_code, surffile.acquisition);
gwy_debug("range type: %d, special points: %d, absolute: %d",
surffile.range,
surffile.special_points, (gint)surffile.absolute);
gwy_debug("data point size: %d", surffile.pointsize);
gwy_debug("zmin: %d, zmax: %d", surffile.zmin, surffile.zmax);
gwy_debug("xres: %d, yres: %d (xres*yres = %d)",
surffile.xres, surffile.yres, (surffile.xres*surffile.yres));
gwy_debug("total number of points: %d", surffile.nofpoints);
gwy_debug("dx: %g, dy: %g, dz: %g",
surffile.dx, surffile.dy, surffile.dz);
gwy_debug("X axis name: %16s", surffile.xaxis);
gwy_debug("Y axis name: %16s", surffile.yaxis);
gwy_debug("Z axis name: %16s", surffile.zaxis);
gwy_debug("dx unit: %16s", surffile.dx_unit);
gwy_debug("dy unit: %16s", surffile.dy_unit);
gwy_debug("dz unit: %16s", surffile.dz_unit);
gwy_debug("X axis unit: %16s", surffile.xlength_unit);
gwy_debug("Y axis unit: %16s", surffile.ylength_unit);
gwy_debug("Z axis unit: %16s", surffile.zlength_unit);
gwy_debug("xunit_ratio: %g, yunit_ratio: %g, zunit_ratio: %g",
surffile.xunit_ratio, surffile.yunit_ratio, surffile.zunit_ratio);
gwy_debug("imprint: %d, inversion: %d, leveling: %d",
surffile.imprint, surffile.inversion, surffile.leveling);
gwy_debug("Time: %d:%d:%d, Date: %d.%d.%d",
surffile.hours, surffile.minutes, surffile.seconds,
surffile.day, surffile.month, surffile.year);
gwy_debug("private zone size: %d, comment size %d",
surffile.private_size, surffile.comment_size);
if (err_DIMENSION(error, surffile.xres)
|| err_DIMENSION(error, surffile.yres)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
expected_size = (SURF_HEADER_SIZE
+ surffile.pointsize/8*surffile.xres*surffile.yres);
if (expected_size != size) {
gwy_debug("Size mismatch!");
if (size > expected_size)
add = size - expected_size; /*TODO correct this !*/
else {
err_SIZE_MISMATCH(error, expected_size, size, TRUE);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
}
/* Use negated positive conditions to catch NaNs */
if (!((surffile.dx = fabs(surffile.dx)) > 0)) {
g_warning("Real x step is 0.0, fixing to 1.0");
surffile.dx = 1.0;
}
if (!((surffile.dy = fabs(surffile.dy)) > 0)) {
g_warning("Real y step is 0.0, fixing to 1.0");
surffile.dy = 1.0;
}
p = buffer + SURF_HEADER_SIZE + add;
/*units*/
coef = 0;
surffile.xyunit = gwy_si_unit_new_parse(surffile.dx_unit, &coef);
surffile.dx *= pow10(coef);
coef = 0;
surffile.xyunit = gwy_si_unit_new_parse(surffile.dy_unit, &coef);
surffile.dy *= pow10(coef);
coef = 0;
surffile.zunit = gwy_si_unit_new_parse (surffile.dz_unit, &coef);
if (!fill_data_fields(&surffile, p, error)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
switch (surffile.inversion) {
case SURF_INV_Z:
gwy_data_field_invert(surffile.dfield, FALSE, FALSE, TRUE);
break;
case SURF_FLIP_Z:
gwy_data_field_invert(surffile.dfield, FALSE, TRUE, TRUE);
break;
case SURF_FLOP_Z:
gwy_data_field_invert(surffile.dfield, TRUE, FALSE, TRUE);
break;
default:
break;
}
gwy_data_field_multiply(surffile.dfield, pow10(coef));
surffile.ZOffset *= pow10(coef);
gwy_data_field_add(surffile.dfield, surffile.ZOffset);
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", surffile.dfield);
g_object_unref(surffile.dfield);
meta = surffile_get_metadata(&surffile);
gwy_container_set_object_by_name(container, "/0/meta", meta);
g_object_unref(meta);
gwy_app_channel_check_nonsquare(container, 0);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
return container;
}
static GwyContainer*
mprofile_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
MProFile mprofile;
GwyContainer *meta, *container = NULL;
GwyDataField *dfield = NULL, *vpmask = NULL;
guchar *buffer = NULL;
gsize size = 0;
GError *err = NULL;
gsize expected;
GString *key;
const gchar *title;
guint n, i;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (!mprofile_read_header(buffer, size, &mprofile, error))
return NULL;
expected = mprofile.header_size
+ 2*mprofile.nbuckets*mprofile.intens_xres*mprofile.intens_yres
+ 4*mprofile.phase_xres*mprofile.phase_yres;
if (err_SIZE_MISMATCH(error, expected, size, TRUE)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
n = fill_data_fields(&mprofile, buffer);
gwy_file_abandon_contents(buffer, size, NULL);
if (!n) {
err_NO_DATA(error);
return NULL;
}
key = g_string_new(NULL);
container = gwy_container_new();
for (i = 0; i < n; i++) {
if (i > 0) {
dfield = mprofile.intensity_data[i-1];
vpmask = mprofile.intensity_mask[i-1];
title = "Intensity";
}
else {
dfield = mprofile.phase_data;
vpmask = mprofile.phase_mask;
title = "Phase";
}
g_string_printf(key, "/%d/data", i);
gwy_container_set_object_by_name(container, key->str, dfield);
g_string_printf(key, "/%d/data/title", i);
gwy_container_set_string_by_name(container, key->str, g_strdup(title));
if (vpmask) {
g_string_printf(key, "/%d/mask", i);
gwy_container_set_object_by_name(container, key->str, vpmask);
}
meta = mprofile_get_metadata(&mprofile);
g_string_printf(key, "/%d/meta", i);
gwy_container_set_object_by_name(container, key->str, meta);
g_object_unref(meta);
}
g_string_free(key, TRUE);
for (n = 0; n < mprofile.nbuckets; n++) {
gwy_object_unref(mprofile.intensity_data[n]);
gwy_object_unref(mprofile.intensity_mask[n]);
}
gwy_object_unref(mprofile.phase_data);
gwy_object_unref(mprofile.phase_mask);
return container;
}
static GwyContainer*
apefile_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
APEFile apefile;
GwyContainer *meta, *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
guint b, i, n;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
p = buffer;
apefile.version = *(p++);
if (size < 1294) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
apefile.spm_mode = *(p++);
p += 2; /* Skip VisualBasic VARIANT type type */
apefile.scan_date = gwy_get_gdouble_le(&p);
apefile.maxr_x = gwy_get_gfloat_le(&p);
apefile.maxr_y = gwy_get_gfloat_le(&p);
apefile.x_offset = gwy_get_guint32_le(&p);
apefile.y_offset = gwy_get_guint32_le(&p);
apefile.size_flag = gwy_get_guint16_le(&p);
apefile.res = 16 << apefile.size_flag;
if (err_DIMENSION(error, apefile.res)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
apefile.acquire_delay = gwy_get_gfloat_le(&p);
apefile.raster_delay = gwy_get_gfloat_le(&p);
apefile.tip_dist = gwy_get_gfloat_le(&p);
apefile.v_ref = gwy_get_gfloat_le(&p);
if (apefile.version == 1) {
apefile.vpmt1 = gwy_get_guint16_le(&p);
apefile.vpmt2 = gwy_get_guint16_le(&p);
}
else {
apefile.vpmt1 = gwy_get_gfloat_le(&p);
apefile.vpmt2 = gwy_get_gfloat_le(&p);
}
apefile.remark = g_strndup(p, 120);
p += 120;
apefile.x_piezo_factor = gwy_get_guint32_le(&p);
apefile.y_piezo_factor = gwy_get_guint32_le(&p);
apefile.z_piezo_factor = gwy_get_guint32_le(&p);
apefile.hv_gain = gwy_get_gfloat_le(&p);
apefile.freq_osc_tip = gwy_get_gdouble_le(&p);
apefile.rotate = gwy_get_gfloat_le(&p);
apefile.slope_x = gwy_get_gfloat_le(&p);
apefile.slope_y = gwy_get_gfloat_le(&p);
apefile.topo_means = gwy_get_guint16_le(&p);
apefile.optical_means = gwy_get_guint16_le(&p);
apefile.error_means = gwy_get_guint16_le(&p);
/*
g_printerr("%04x %04x %04x\n",
apefile.topo_means, apefile.optical_means, apefile.error_means);
*/
apefile.channels = gwy_get_guint32_le(&p);
apefile.ndata = 0;
for (b = apefile.channels; b; b = b >> 1)
apefile.ndata += (b & 1);
apefile.range_x = gwy_get_gfloat_le(&p);
apefile.range_y = gwy_get_gfloat_le(&p);
apefile.subversion = gwy_get_guint16_le(&p);
/* Read everything since the header is long enough, check the version
* later when we decide whether to use these values or not. */
/* Since 2.1 */
apefile.hv_gain_z = gwy_get_gfloat_le(&p);
/* Since 2.2 */
apefile.fast2_0 = gwy_get_gdouble_le(&p);
apefile.fast2_1 = gwy_get_gdouble_le(&p);
apefile.fast2_2 = gwy_get_gdouble_le(&p);
apefile.fast2_3 = gwy_get_gdouble_le(&p);
/* Since 2.3 */
apefile.pg850_image = !!gwy_get_guint16_le(&p);
/* Since 2.4 */
apefile.xy_hv_status = gwy_get_gint16_le(&p);
apefile.z_hv_status = gwy_get_gint16_le(&p);
/* reserved */
p += 2;
apefile.xreal = apefile.maxr_x * apefile.x_piezo_factor * apefile.range_x
* apefile.hv_gain/65535.0 * 1e-9;
apefile.yreal = apefile.maxr_y * apefile.y_piezo_factor * apefile.range_y
* apefile.hv_gain/65535.0 * 1e-9;
/* Use negated positive conditions to catch NaNs */
if (!((apefile.xreal = fabs(apefile.xreal)) > 0)) {
g_warning("Real x size is 0.0, fixing to 1.0");
apefile.xreal = 1.0;
}
if (!((apefile.yreal = fabs(apefile.yreal)) > 0)) {
g_warning("Real y size is 0.0, fixing to 1.0");
apefile.yreal = 1.0;
}
gwy_debug("version = %u.%u, spm_mode = %u",
apefile.version, apefile.subversion, apefile.spm_mode);
gwy_debug("scan_date = %f", apefile.scan_date);
gwy_debug("maxr_x = %g, maxr_y = %g", apefile.maxr_x, apefile.maxr_y);
gwy_debug("x_offset = %u, y_offset = %u",
apefile.x_offset, apefile.y_offset);
gwy_debug("size_flag = %u", apefile.size_flag);
gwy_debug("acquire_delay = %g, raster_delay = %g, tip_dist = %g",
apefile.acquire_delay, apefile.raster_delay, apefile.tip_dist);
gwy_debug("v_ref = %g, vpmt1 = %g, vpmt2 = %g",
apefile.v_ref, apefile.vpmt1, apefile.vpmt2);
gwy_debug("x_piezo_factor = %u, y_piezo_factor = %u, z_piezo_factor = %u",
apefile.x_piezo_factor, apefile.y_piezo_factor,
apefile.z_piezo_factor);
gwy_debug("hv_gain = %g, freq_osc_tip = %g, rotate = %g",
apefile.hv_gain, apefile.freq_osc_tip, apefile.rotate);
gwy_debug("slope_x = %g, slope_y = %g",
apefile.slope_x, apefile.slope_y);
gwy_debug("topo_means = %u, optical_means = %u, error_means = %u",
apefile.topo_means, apefile.optical_means, apefile.error_means);
gwy_debug("channel bitmask = %03x, ndata = %u",
apefile.channels, apefile.ndata);
gwy_debug("range_x = %g, range_y = %g",
apefile.range_x, apefile.range_y);
n = (apefile.res + 1)*(apefile.res + 1)*sizeof(float);
if (size - (p - buffer) != n*apefile.ndata) {
g_warning("Expected data size %u, but it's %u.",
n*apefile.ndata, (guint)(size - (p - buffer)));
apefile.ndata = MIN(apefile.ndata, (size - (p - buffer))/n);
}
if (!apefile.ndata) {
err_NO_DATA(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
fill_data_fields(&apefile, p);
gwy_file_abandon_contents(buffer, size, NULL);
container = gwy_container_new();
/* All metadata seems to be per-file (global) */
meta = apefile_get_metadata(&apefile);
for (b = apefile.channels, n = 0, i = 0; b; b = b >> 1, i++) {
GwyContainer *tmp;
gchar *title;
gchar key[32];
if (!(b & 1))
continue;
g_snprintf(key, sizeof(key), "/%d/data", n);
dfield = apefile.data[n];
gwy_container_set_object_by_name(container, key, dfield);
g_object_unref(apefile.data[n]);
g_snprintf(key, sizeof(key), "/%d/data/title", n);
/*
* Channel labelling based on SPM Mode
*/
switch (apefile.spm_mode) {
case SPM_MODE_SNOM:
title = gwy_enuml_to_string(i,
"Height", APE_HEIGHT,
"Height-R", APE_HEIGHT_R,
"NSOM", APE_NSOM,
"NSOM-R", APE_NSOM_R,
"Error", APE_ERROR,
"Error-R", APE_ERROR_R,
"NSOM2", APE_NSOM2,
"NSOM2-R", APE_NSOM2_R,
"Lateral", APE_AUX1,
"Z-Z0", APE_AUX2,
"Lateral-R", APE_AUX1_R,
"Z-Z0-R", APE_AUX2_R,
NULL);
break;
case SPM_MODE_AFM_NONCONTACT:
case SPM_MODE_AFM_CONTACT:
case SPM_MODE_PHASE_DETECT_AFM:
title = gwy_enuml_to_string(i,
"Height", APE_HEIGHT,
"Height-R", APE_HEIGHT_R,
"IN1", APE_NSOM,
"IN1-R", APE_NSOM_R,
"Error", APE_ERROR,
"Error-R", APE_ERROR_R,
"IN2", APE_NSOM2,
"IN2-R", APE_NSOM2_R,
"Lateral", APE_AUX1,
"Z-Z0", APE_AUX2,
"Lateral-R", APE_AUX1_R,
"Z-Z0-R", APE_AUX2_R,
NULL);
break;
default:
title = gwy_enuml_to_string(i,
"Height", APE_HEIGHT,
"Height-R", APE_HEIGHT_R,
"IN1", APE_NSOM,
"IN1-R", APE_NSOM_R,
"Error", APE_ERROR,
"Error-R", APE_ERROR_R,
"IN2", APE_NSOM2,
"IN2-R", APE_NSOM2_R,
"Aux1", APE_AUX1,
"Z-Z0", APE_AUX2,
"Aux1-R", APE_AUX1_R,
"Z-Z0-R", APE_AUX2_R,
NULL);
break;
}
if (title && *title)
gwy_container_set_string_by_name(container, key, g_strdup(title));
tmp = gwy_container_duplicate(meta);
g_snprintf(key, sizeof(key), "/%d/meta", n);
gwy_container_set_object_by_name(container, key, tmp);
g_object_unref(tmp);
gwy_file_channel_import_log_add(container, n, NULL, filename);
n++;
}
g_object_unref(meta);
g_free(apefile.remark);
return container;
}
