static void
facets_analyse(GwyContainer *data, GwyRunType run)
{
FacetsArgs args;
GwyContainer *fdata;
GwyDataField *dfield, *mfield;
GQuark mquark;
gint id;
g_return_if_fail(run & FACETS_RUN_MODES);
g_return_if_fail(g_type_from_name("GwyLayerPoint"));
facets_load_args(gwy_app_settings_get(), &args);
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_MASK_FIELD_KEY, &mquark,
GWY_APP_MASK_FIELD, &mfield,
GWY_APP_DATA_FIELD_ID, &id,
0);
g_return_if_fail(dfield && mquark);
fdata = gwy_container_new();
gwy_data_field_facet_distribution(dfield, 2*args.kernel_size + 1, fdata);
args.theta0 = gwy_container_get_double_by_name(fdata, "/theta0");
args.phi0 = gwy_container_get_double_by_name(fdata, "/phi0");
if (run == GWY_RUN_IMMEDIATE)
run_noninteractive(&args, data, fdata, dfield, mfield, mquark);
else {
facets_dialog(&args, data, fdata, dfield, mfield, id, mquark);
facets_save_args(gwy_app_settings_get(), &args);
}
g_object_unref(fdata);
}
static GwyContainer*
shimadzu_get_metadata(GHashTable *hash)
{
GwyContainer *meta = gwy_container_new();
g_hash_table_foreach(hash, add_metadata, meta);
return meta;
}
/* FIXME: This is a bit simplistic */
static GwyContainer*
nanoscope_get_metadata(GHashTable *hash,
GList *list)
{
static const gchar *hashes[] = {
"File list", "Scanner list", "Equipment list", "Ciao scan list",
};
GwyContainer *meta;
GList *l;
guint i;
meta = gwy_container_new();
for (l = list; l; l = g_list_next(l)) {
GHashTable *h = ((NanoscopeData*)l->data)->hash;
for (i = 0; i < G_N_ELEMENTS(hashes); i++) {
if (gwy_strequal(g_hash_table_lookup(h, "#self"), hashes[i])) {
g_hash_table_foreach(h, add_metadata, meta);
break;
}
}
}
g_hash_table_foreach(hash, add_metadata, meta);
return meta;
}
/* create a smaller copy of data */
static GwyContainer*
create_preview_data(GwyContainer *data,
GwyDataField *dfield,
gint id)
{
GwyContainer *pdata;
GwyDataField *pfield;
gint xres, yres;
gdouble zoomval;
pdata = gwy_container_new();
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
zoomval = (gdouble)PREVIEW_SIZE/MAX(xres, yres);
xres = MAX(xres*zoomval, 3);
yres = MAX(yres*zoomval, 3);
pfield = gwy_data_field_new_resampled(dfield, xres, yres,
GWY_INTERPOLATION_ROUND);
gwy_container_set_object_by_name(pdata, "/0/data", pfield);
g_object_unref(pfield);
pfield = gwy_data_field_new_alike(pfield, FALSE);
gwy_container_set_object_by_name(pdata, "/0/show", pfield);
g_object_unref(pfield);
gwy_app_sync_data_items(data, pdata, id, 0, FALSE,
GWY_DATA_ITEM_GRADIENT,
0);
return pdata;
}
static GwyContainer*
apefile_get_metadata(APEFile *apefile)
{
GwyContainer *meta;
gchar *p;
meta = gwy_container_new();
HASH_STORE("Version", "%u", version);
HASH_STORE("Tip oscilation frequency", "%g Hz", freq_osc_tip);
HASH_STORE("Acquire delay", "%.6f s", acquire_delay);
HASH_STORE("Raster delay", "%.6f s", raster_delay);
HASH_STORE("Tip distance", "%g nm", tip_dist);
if (apefile->remark && *apefile->remark
&& (p = g_convert(apefile->remark, strlen(apefile->remark),
"UTF-8", "ISO-8859-1", NULL, NULL, NULL)))
gwy_container_set_string_by_name(meta, "Comment", p);
gwy_container_set_string_by_name
(meta, "SPM mode",
g_strdup(gwy_enum_to_string(apefile->spm_mode, spm_modes,
G_N_ELEMENTS(spm_modes))));
p = format_vt_date(apefile->scan_date);
if (p)
gwy_container_set_string_by_name(meta, "Date", p);
return meta;
}
static GwyContainer*
spmlab_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL;
guchar *buffer = NULL;
gsize size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
const gchar *title;
gint type;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
/* 2048 is wrong. moreover it differs for r5 and r4, kasigra uses 5752 for
* r5 */
if (size < 2048) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
if (buffer[0] != '#' || buffer[1] != 'R') {
err_FILE_TYPE(error, "Thermicroscopes SpmLab");
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
switch (buffer[2]) {
case '3':
case '4':
case '5':
case '6':
dfield = read_data_field(buffer, size, buffer[2], &type, error);
break;
default:
g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA,
_("Unknown format version %c."), buffer[2]);
break;
}
gwy_file_abandon_contents(buffer, size, NULL);
if (!dfield)
return NULL;
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", dfield);
g_object_unref(dfield);
title = gwy_enum_to_string(type,
spmlab_channel_types,
G_N_ELEMENTS(spmlab_channel_types));
if (*title)
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup(title));
return container;
}
static GwyContainer*
rhk_sm3_load(const gchar *filename)
{
GPtrArray *rhkfile;
RHKPage *rhkpage;
GwyContainer *container = NULL;
guchar *buffer = NULL;
gsize size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
const guchar *p;
guint i, count;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
g_warning("Cannot read file %s", filename);
g_clear_error(&err);
return NULL;
}
if (size < HEADER_SIZE) {
g_warning("File %s is not a RHK SM3 file", filename);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
rhkfile = g_ptr_array_new();
p = buffer;
count = 0;
gwy_debug("position %04x", p - buffer);
while ((rhkpage = rhk_sm3_read_page(&p, &size))) {
gwy_debug("Page #%u read OK", count);
count++;
rhkpage->pageno = count;
gwy_debug("position %04x", p - buffer);
if (rhkpage->type != RHK_TYPE_IMAGE) {
gwy_debug("Page is not IMAGE, skipping");
rhk_sm3_page_free(rhkpage);
continue;
}
g_ptr_array_add(rhkfile, rhkpage);
}
i = select_which_data(rhkfile);
if (i != (guint)-1) {
rhkpage = g_ptr_array_index(rhkfile, i);
container = GWY_CONTAINER(gwy_container_new());
dfield = rhk_sm3_page_to_data_field(rhkpage);
gwy_container_set_object_by_name(container, "/0/data",
(GObject*)dfield);
g_object_unref(dfield);
rhk_sm3_store_metadata(rhkpage, container);
}
gwy_file_abandon_contents(buffer, size, NULL);
for (i = 0; i < rhkfile->len; i++)
rhk_sm3_page_free(g_ptr_array_index(rhkfile, i));
g_ptr_array_free(rhkfile, TRUE);
return container;
}
static GwyContainer*
aist_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
AistContext context;
guchar *buffer = NULL;
const guchar *p;
gsize remaining, size = 0;
GError *err = NULL;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
p = buffer;
remaining = size;
context.container = gwy_container_new();
context.filename = filename;
context.channel_id = 0;
context.graph_id = 0;
read_aist_tree(&p, &remaining, &context);
gwy_file_abandon_contents(buffer, size, NULL);
if ((context.channel_id == 0) && (context.graph_id == 0)) {
g_object_unref(context.container);
context.container = NULL;
err_NO_DATA(error);
}
return context.container;
}
static GwyContainer*
hitachi_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error,
const gchar *name)
{
GwyContainer *container = NULL;
guchar *buffer = NULL;
gsize size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
GwyDataField *(*do_load)(const guchar*, guint, GError**);
guint header_size;
if (gwy_strequal(name, "hitachi-afm")) {
do_load = &read_data_field;
header_size = HEADER_SIZE;
}
else if (gwy_strequal(name, "hitachi-afm-old")) {
do_load = &read_data_field_old;
header_size = HEADER_SIZE_OLD;
}
else {
g_set_error(error, GWY_MODULE_FILE_ERROR,
GWY_MODULE_FILE_ERROR_UNIMPLEMENTED,
_("Hitachi-AFM has not registered file type `%s'."), name);
return NULL;
}
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
if (size < header_size + 2) {
err_TOO_SHORT(error);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
dfield = do_load(buffer, size, error);
gwy_file_abandon_contents(buffer, size, NULL);
if (!dfield)
return NULL;
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", dfield);
g_object_unref(dfield);
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Topography"));
gwy_app_channel_check_nonsquare(container, 0);
gwy_file_channel_import_log_add(container, 0, NULL, filename);
return container;
}
static GwyContainer*
get_meta(const X3PFile *x3pfile)
{
GwyContainer *meta = gwy_container_new();
g_hash_table_foreach(x3pfile->hash, add_meta_record, meta);
if (gwy_container_get_n_items(meta))
return meta;
g_object_unref(meta);
return NULL;
}
static GwyContainer*
omicron_make_meta(OmicronFile *ofile)
{
GwyContainer *meta = gwy_container_new();
g_hash_table_foreach(ofile->meta, add_meta, meta);
if (gwy_container_get_n_items(meta))
return meta;
g_object_unref(meta);
return NULL;
}
static GwyContainer*
x3p_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
GwyContainer *container = NULL;
X3PFile x3pfile;
unzFile zipfile;
zipfile = gwyminizip_unzOpen(filename);
if (!zipfile) {
g_set_error(error, GWY_MODULE_FILE_ERROR,
GWY_MODULE_FILE_ERROR_SPECIFIC,
_("Minizip cannot open the file as a ZIP file."));
return NULL;
}
gwy_clear(&x3pfile, 1);
if (!x3p_parse_main(zipfile, &x3pfile, error))
goto fail;
if (!x3pfile.ndata) {
err_NO_DATA(error);
goto fail;
}
if (!x3pfile.datapos) {
if (!read_binary_data(&x3pfile, zipfile, error))
goto fail;
}
container = gwy_container_new();
if (x3pfile.feature_type == X3P_FEATURE_SUR)
create_images(&x3pfile, container);
else if (x3pfile.feature_type == X3P_FEATURE_PRF)
create_profiles(&x3pfile, container);
else {
g_assert_not_reached();
}
fail:
gwy_debug("calling unzClose()");
unzClose(zipfile);
x3p_file_free(&x3pfile);
return container;
}
static GwyContainer*
get_meta(GHashTable *hash)
{
static const gchar *keys[] = {
"Mode", "max. Speed", "Waiting Time", "Scan started", "Scan ended",
};
GwyContainer *meta = gwy_container_new();
const gchar *value;
guint i;
for (i = 0; i < G_N_ELEMENTS(keys); i++) {
if (!(value = g_hash_table_lookup(hash, keys[i])))
continue;
gwy_container_set_string_by_name(meta, keys[i], g_strdup(value));
}
return meta;
}
static GwyContainer*
sdfile_load_text(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
SDFile sdfile;
GwyContainer *container = NULL;
gchar *p, *buffer = NULL;
gsize len, size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
if (!g_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
len = size;
p = buffer;
if (sdfile_read_header_text(&p, &len, &sdfile, error)) {
if (check_params(&sdfile, len, error))
dfield = sdfile_read_data_text(&sdfile, error);
}
if (!dfield) {
g_free(buffer);
return NULL;
}
sdfile_set_units(&sdfile, dfield);
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", dfield);
g_object_unref(dfield);
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Topography"));
g_free(buffer);
if (sdfile.extras)
g_hash_table_destroy(sdfile.extras);
return container;
}
static GwyContainer*
igor_get_metadata(IgorFile *igorfile,
G_GNUC_UNUSED guint id)
{
static const gchar *ignore_prefixes[] = {
"Channel", "ColorMap", "Display", "Flatten", "PlaneFit", "Planefit",
NULL
};
if (!igorfile->meta)
return NULL;
if (!igorfile->ignore_prefixes)
igorfile->ignore_prefixes = ignore_prefixes;
igorfile->channelmeta = gwy_container_new();
g_hash_table_foreach(igorfile->meta, gather_channel_meta, igorfile);
return igorfile->channelmeta;
}
/**
* gwyfile_pack_metadata:
* @data: A data container.
*
* Pack scattered metadata under "/meta" to a container at "/0/meta" and
* metadata scattered under "/0/data/meta" to a container at "/0/meta".
**/
static void
gwyfile_pack_metadata(GwyContainer *data)
{
GwyContainer *meta;
meta = gwy_container_new();
/* Mindlessly run one packing after another. Losing some metadata is not
* a tragedy and the file has to be borken in the first place to have
* metadata conflicts. */
gwy_container_foreach(data, "/meta", &gwyfile_gather_meta, meta);
gwy_container_foreach(data, "/0/data/meta", &gwyfile_gather_0_data_meta,
meta);
if (gwy_container_get_n_items(meta)) {
gwy_container_remove_by_prefix(data, "/meta");
gwy_container_remove_by_prefix(data, "/0/data/meta");
gwy_container_set_object_by_name(data, "/0/meta", meta);
}
g_object_unref(meta);
}
static GwyContainer*
stmprg_get_metadata(const StmprgFile *stmprgfile)
{
GwyContainer *meta;
gchar *value;
meta = gwy_container_new();
HASH_STORE_F("inc_x", mainfield.inc_x);
HASH_STORE_F("inc_y", mainfield.inc_y);
HASH_STORE_F("angle", mainfield.angle);
HASH_STORE_F("sol_z", mainfield.sol_z);
HASH_STORE_F("voltage", control.voltage);
HASH_STORE_F("current", control.current);
HASH_STORE_I("point_time", control.point_time);
HASH_STORE_S("date", other_control.date);
HASH_STORE_S("comment", other_control.comment);
HASH_STORE_S("username", other_control.username);
return meta;
}
static GwyContainer*
rhkspm32_get_metadata(RHKPage *rhkpage)
{
GwyContainer *meta;
const gchar *s;
meta = gwy_container_new();
gwy_container_set_string_by_name(meta, "Tunneling voltage",
g_strdup_printf("%g mV",
1e3*rhkpage->iv.offset));
gwy_container_set_string_by_name(meta, "Current",
g_strdup_printf("%g nA",
1e9*rhkpage->iv.scale));
if (rhkpage->id)
gwy_container_set_string_by_name(meta, "Id",
g_strdup_printf("%u", rhkpage->id));
if (rhkpage->date && *rhkpage->date)
gwy_container_set_string_by_name(meta, "Date", g_strdup(rhkpage->date));
if (rhkpage->comment && *rhkpage->comment)
gwy_container_set_string_by_name(meta, "Comment",
g_strdup(rhkpage->comment));
if (rhkpage->label && *rhkpage->label)
gwy_container_set_string_by_name(meta, "Label",
g_strdup(rhkpage->label));
s = gwy_enum_to_string(rhkpage->page_type,
scan_directions, G_N_ELEMENTS(scan_directions));
if (s && *s)
gwy_container_set_string_by_name(meta, "Image type", g_strdup(s));
// FIXME - seems one can read 0 for spectra as well, but maybe it's not
// that important - it should be clear that this is a nonsense value
if (rhkpage->e_alpha)
gwy_container_set_string_by_name(meta, "Angle",
g_strdup_printf("%g deg",
rhkpage->alpha));
return meta;
}
static GwyContainer*
unisoku_get_metadata(UnisokuFile *ufile)
{
GwyContainer *meta;
meta = gwy_container_new();
gwy_container_set_string_by_name(meta, "Date",
g_strconcat(ufile->date, " ",
ufile->time, NULL));
if (*ufile->remark)
gwy_container_set_string_by_name(meta, "Remark",
g_strdup(ufile->remark));
if (*ufile->sample_name)
gwy_container_set_string_by_name(meta, "Sample name",
g_strdup(ufile->sample_name));
if (*ufile->ad_name)
gwy_container_set_string_by_name(meta, "AD name",
g_strdup(ufile->ad_name));
return meta;
}
static GwyContainer*
sdfile_load_bin(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
SDFile sdfile;
GwyContainer *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize len, size = 0;
GError *err = NULL;
GwyDataField *dfield = NULL;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
return NULL;
}
len = size;
p = buffer;
if (sdfile_read_header_bin(&p, &len, &sdfile, error)) {
if (check_params(&sdfile, len, error))
dfield = sdfile_read_data_bin(&sdfile);
}
gwy_file_abandon_contents(buffer, size, NULL);
if (!dfield)
return NULL;
sdfile_set_units(&sdfile, dfield);
container = gwy_container_new();
gwy_container_set_object_by_name(container, "/0/data", dfield);
g_object_unref(dfield);
gwy_container_set_string_by_name(container, "/0/data/title",
g_strdup("Topography"));
return container;
}
static GwyContainer*
surffile_get_metadata(SurfFile *surffile)
{
GwyContainer *meta;
char date[40];
meta = gwy_container_new();
g_snprintf(date, sizeof(date), "%d. %d. %d",
surffile->day, surffile->month, surffile->year);
HASH_STORE("Version", "%u", version);
HASH_STORE("Operator name", "%s", operator_name);
HASH_STORE("Object name", "%s", object_name);
gwy_container_set_string_by_name(meta, "Date", g_strdup(date));
gwy_container_set_string_by_name
(meta, "Acquisition type",
g_strdup(gwy_enum_to_string(surffile->acquisition, acq_modes,
G_N_ELEMENTS(acq_modes))));
return meta;
}
static GwyContainer*
ezdfile_get_metadata(GPtrArray *ezdfile,
G_GNUC_UNUSED gint idx)
{
EZDSection *section;
GwyContainer *meta;
guint i;
meta = gwy_container_new();
for (i = 0; i < ezdfile->len; i++) {
section = (EZDSection*)g_ptr_array_index(ezdfile, i);
if (gwy_strequal(section->name, "DataSet-Info"))
g_hash_table_foreach(section->meta, store_meta, meta);
}
if (!gwy_container_get_n_items(meta)) {
g_object_unref(meta);
meta = NULL;
}
return meta;
}
/* create a smaller copy of data */
static GwyContainer*
create_preview_data(GwyContainer *data)
{
GwyContainer *preview;
GwyDataField *dfield, *dfield_show;
gint oldid;
gint xres, yres;
gdouble zoomval;
preview = gwy_container_new();
gwy_app_data_browser_get_current(GWY_APP_DATA_FIELD, &dfield,
GWY_APP_DATA_FIELD_ID, &oldid,
0);
dfield = gwy_data_field_duplicate(dfield);
dfield_show = gwy_data_field_duplicate(dfield);
xres = gwy_data_field_get_xres(dfield);
yres = gwy_data_field_get_yres(dfield);
zoomval = (gdouble)PREVIEW_SIZE/MAX(xres, yres);
gwy_data_field_resample(dfield, xres*zoomval, yres*zoomval,
GWY_INTERPOLATION_LINEAR);
dfield_show = gwy_data_field_duplicate(dfield);
gwy_container_set_object_by_name(preview, "/0/data", dfield);
g_object_unref(dfield);
gwy_container_set_object_by_name(preview, "/0/show", dfield_show);
g_object_unref(dfield_show);
gwy_app_sync_data_items(data, preview, oldid, 0, FALSE,
GWY_DATA_ITEM_GRADIENT,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_MASK_COLOR,
0);
return preview;
}
static GwyContainer*
pt3file_get_metadata(PicoHarpFile *pt3file)
{
GwyContainer *meta;
meta = gwy_container_new();
add_meta_str("Format Version", format_version);
add_meta_str("Creator Name", creator_name);
add_meta_str("Creator Version", creator_version);
add_meta_str("Date", file_time);
add_meta_str("Comment", comment);
add_meta_str("Hardware", board.hardware_ident);
add_meta_str("Hardware Version", board.hardware_version);
gwy_container_set_string_by_name
(meta, "Measurement Mode",
g_strdup_printf("%u", pt3file->measurement_mode));
gwy_container_set_string_by_name
(meta, "Offset", g_strdup_printf("%d ns", pt3file->offset));
gwy_container_set_string_by_name
(meta, "Acquisition Time",
g_strdup_printf("%d ms", pt3file->acquisition_time));
gwy_container_set_string_by_name
(meta, "Hardware Serial Number",
g_strdup_printf("%u", pt3file->board.hardware_serial));
gwy_container_set_string_by_name
(meta, "Imaging Device",
g_strdup(gwy_enuml_to_string(pt3file->imaging.common.instrument,
"PI E710", 1,
"KDT180-100-Im", 2,
"LSM", 3,
NULL)));
return meta;
}
static void
facets_dialog(FacetsArgs *args,
GwyContainer *data,
GwyContainer *fdata,
GwyDataField *dfield,
GwyDataField *mfield,
gint id,
GQuark mquark)
{
GtkWidget *dialog, *table, *hbox, *hbox2, *vbox, *label, *scale, *button;
GtkWidget *spin;
FacetsControls controls;
enum {
RESPONSE_RESET = 1,
RESPONSE_PREVIEW = 2
};
gint response;
GwyPixmapLayer *layer;
GwyVectorLayer *vlayer;
GwySelection *selection;
gint row;
memset(&controls, 0, sizeof(FacetsControls));
controls.args = args;
dialog = gtk_dialog_new_with_buttons(_("Mark Facets"),
NULL,
GTK_DIALOG_DESTROY_WITH_PARENT,
_("_Mark"), RESPONSE_PREVIEW,
_("_Reset"), RESPONSE_RESET,
GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL,
GTK_STOCK_OK, GTK_RESPONSE_OK,
NULL);
gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE);
gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK);
controls.dialog = dialog;
/* Shallow-copy stuff to temporary container */
controls.fdata = fdata;
controls.mydata = gwy_container_new();
gwy_container_set_object_by_name(controls.mydata, "/0/data", dfield);
gwy_app_sync_data_items(data, controls.mydata, id, 0, FALSE,
GWY_DATA_ITEM_PALETTE,
GWY_DATA_ITEM_RANGE,
GWY_DATA_ITEM_MASK_COLOR,
GWY_DATA_ITEM_REAL_SQUARE,
0);
hbox = gtk_hbox_new(FALSE, 2);
gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), hbox,
FALSE, FALSE, 4);
controls.view = gwy_data_view_new(controls.mydata);
layer = gwy_layer_basic_new();
g_object_set(layer,
"data-key", "/0/data",
"gradient-key", "/0/base/palette",
"range-type-key", "/0/base/range-type",
"min-max-key", "/0/base",
NULL);
gwy_data_view_set_data_prefix(GWY_DATA_VIEW(controls.view), "/0/data");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.view), layer);
gwy_set_data_preview_size(GWY_DATA_VIEW(controls.view), PREVIEW_SIZE);
vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer");
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.view), vlayer);
selection = gwy_vector_layer_ensure_selection(vlayer);
g_signal_connect(selection, "changed",
G_CALLBACK(preview_selection_updated), &controls);
gtk_box_pack_start(GTK_BOX(hbox), controls.view, FALSE, FALSE, 4);
vbox = gtk_vbox_new(FALSE, 0);
gtk_box_pack_start(GTK_BOX(hbox), vbox, TRUE, TRUE, 0);
hbox2 = gtk_hbox_new(FALSE, 4);
gtk_box_pack_start(GTK_BOX(vbox), hbox2, FALSE, FALSE, 0);
/* Slope view */
controls.fview = gwy_data_view_new(controls.fdata);
gtk_box_pack_start(GTK_BOX(hbox2), controls.fview, FALSE, FALSE, 0);
layer = gwy_layer_basic_new();
gwy_pixmap_layer_set_data_key(layer, "/0/data");
gwy_layer_basic_set_gradient_key(GWY_LAYER_BASIC(layer), "/0/base/palette");
gwy_data_view_set_base_layer(GWY_DATA_VIEW(controls.fview),
layer);
vlayer = g_object_new(g_type_from_name("GwyLayerPoint"), NULL);
gwy_vector_layer_set_selection_key(vlayer, "/0/select/pointer");
gwy_data_view_set_top_layer(GWY_DATA_VIEW(controls.fview),
GWY_VECTOR_LAYER(vlayer));
selection = gwy_vector_layer_ensure_selection(vlayer);
g_signal_connect(selection, "changed",
G_CALLBACK(facet_view_selection_updated), &controls);
/* Info table */
table = gtk_table_new(7, 2, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(hbox2), table, TRUE, TRUE, 4);
row = 0;
label = gwy_label_new_header(gwy_sgettext("noun|Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.theta_label = add_angle_label(table, _("θ:"), &row);
controls.phi_label = add_angle_label(table, _("φ:"), &row);
button = gtk_button_new_with_mnemonic(_("_Find Maximum"));
gtk_table_attach(GTK_TABLE(table), button,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
g_signal_connect_swapped(button, "clicked",
G_CALLBACK(facet_view_reset_maximum), &controls);
gtk_table_set_row_spacing(GTK_TABLE(table), row, 8);
row++;
label = gwy_label_new_header(_("Mean Normal"));
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.mtheta_label = add_angle_label(table, _("θ:"), &row);
controls.mphi_label = add_angle_label(table, _("φ:"), &row);
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new_with_mnemonic(_("Facet plane size:"));
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 2, row, row+1, GTK_FILL, 0, 0, 0);
row++;
controls.kernel_size = gtk_adjustment_new(args->kernel_size,
0.0, MAX_PLANE_SIZE, 1.0, 1.0, 0);
spin = gtk_spin_button_new(GTK_ADJUSTMENT(controls.kernel_size), 0.0, 0);
gtk_label_set_mnemonic_widget(GTK_LABEL(label), spin);
gtk_table_attach(GTK_TABLE(table), spin,
0, 1, row, row+1, 0, 0, 0, 0);
g_signal_connect(controls.kernel_size, "value-changed",
G_CALLBACK(facet_view_recompute), &controls);
row++;
table = gtk_table_new(9, 4, FALSE);
gtk_table_set_row_spacings(GTK_TABLE(table), 2);
gtk_table_set_col_spacings(GTK_TABLE(table), 6);
gtk_container_set_border_width(GTK_CONTAINER(table), 4);
gtk_box_pack_start(GTK_BOX(vbox), table, TRUE, TRUE, 4);
row = 0;
controls.tolerance = gtk_adjustment_new(args->tolerance*180.0/G_PI,
0.0, 15.0, 0.01, 0.1, 0);
scale = gwy_table_attach_hscale(table, row++, _("_Tolerance:"), _("deg"),
controls.tolerance, 0);
gtk_spin_button_set_digits(GTK_SPIN_BUTTON(scale), 3);
g_signal_connect(controls.tolerance, "value-changed",
G_CALLBACK(facets_tolerance_changed), &controls);
controls.color_button = gwy_color_button_new();
gwy_color_button_set_use_alpha(GWY_COLOR_BUTTON(controls.color_button),
TRUE);
load_mask_color(controls.color_button,
gwy_data_view_get_data(GWY_DATA_VIEW(controls.view)));
gwy_table_attach_hscale(table, row++, _("_Mask color:"), NULL,
GTK_OBJECT(controls.color_button),
GWY_HSCALE_WIDGET_NO_EXPAND);
g_signal_connect(controls.color_button, "clicked",
G_CALLBACK(mask_color_change_cb), &controls);
if (!gwy_si_unit_equal(gwy_data_field_get_si_unit_xy(dfield),
gwy_data_field_get_si_unit_z(dfield))) {
gtk_table_set_row_spacing(GTK_TABLE(table), row-1, 8);
label = gtk_label_new(_("Warning: Lateral and value units differ. "
"Angles are not physically meaningful."));
gtk_label_set_line_wrap(GTK_LABEL(label), TRUE);
gtk_misc_set_alignment(GTK_MISC(label), 0.0, 0.5);
gtk_table_attach(GTK_TABLE(table), label,
0, 4, row, row+1, GTK_EXPAND | GTK_FILL, 0, 0, 0);
row++;
}
facets_invalidate(&controls);
gtk_widget_show_all(dialog);
facet_view_select_angle(&controls, args->theta0, args->phi0);
do {
response = gtk_dialog_run(GTK_DIALOG(dialog));
switch (response) {
case GTK_RESPONSE_CANCEL:
case GTK_RESPONSE_DELETE_EVENT:
gtk_widget_destroy(dialog);
case GTK_RESPONSE_NONE:
g_object_unref(controls.mydata);
return;
break;
case GTK_RESPONSE_OK:
break;
case RESPONSE_RESET:
args->tolerance = facets_defaults.tolerance;
args->kernel_size = facets_defaults.kernel_size;
facets_dialog_update_controls(&controls, args);
break;
case RESPONSE_PREVIEW:
preview(&controls, args);
update_average_angle(&controls, args);
break;
default:
g_assert_not_reached();
break;
}
} while (response != GTK_RESPONSE_OK);
gwy_app_sync_data_items(controls.mydata, data, 0, id, FALSE,
GWY_DATA_ITEM_MASK_COLOR,
0);
gtk_widget_destroy(dialog);
if (controls.computed) {
mfield = gwy_container_get_object_by_name(controls.mydata, "/0/mask");
gwy_app_undo_qcheckpointv(data, 1, &mquark);
gwy_container_set_object(data, mquark, mfield);
g_object_unref(controls.mydata);
}
else {
g_object_unref(controls.mydata);
run_noninteractive(args, data, fdata, dfield, mfield, mquark);
}
}
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
header_start_element(G_GNUC_UNUSED GMarkupParseContext *context,
const gchar *element_name,
const gchar **attribute_names,
const gchar **attribute_values,
gpointer user_data,
GError **error)
{
const gchar **name_cursor = attribute_names;
const gchar **value_cursor = attribute_values;
gchar *name, *value;
XMLParserData *data;
LIFElement *element;
data = (XMLParserData *)user_data;
// gwy_debug("Name = %s", element_name);
if (gwy_strequal(element_name, "LMSDataContainerHeader")) {
while (*name_cursor) {
if (gwy_strequal(*name_cursor, "Version")) {
data->file->version = atoi(*value_cursor);
}
name_cursor++;
value_cursor++;
}
}
else if (gwy_strequal(element_name, "Element")) {
element = g_new0(LIFElement, 1);
while (*name_cursor) {
if (gwy_strequal(*name_cursor, "Name")) {
element->name = g_strdup(*value_cursor);
}
name_cursor++;
value_cursor++;
}
g_ptr_array_add(data->elements, (gpointer)element);
}
else if (gwy_strequal(element_name, "Memory")) {
if (!(data->elements->len)) {
gwy_debug("Wrong XML Memory block");
err_FILE_TYPE(error, "Leica LIF");
goto fail_xml;
}
element = (LIFElement *)g_ptr_array_index(data->elements,
data->elements->len - 1);
while (*name_cursor) {
if (gwy_strequal(*name_cursor, "Size")) {
element->memsize
= g_ascii_strtoull(*value_cursor, NULL, 10);
}
else if (gwy_strequal(*name_cursor, "MemoryBlockID")) {
element->memid = g_strdup(*value_cursor);
}
name_cursor++;
value_cursor++;
}
if (!(element->memid)) {
gwy_debug("Wrong XML: Element has no MemID");
err_FILE_TYPE(error, "Leica LIF");
}
}
else if (gwy_strequal(element_name, "ChannelDescription")) {
LIFChannel *channel = NULL;
if (!(data->elements->len)) {
gwy_debug("Wrong XML ChannelDescription block");
err_FILE_TYPE(error, "Leica LIF");
goto fail_xml;
}
element = (LIFElement *)g_ptr_array_index(data->elements,
data->elements->len - 1);
channel = g_new0(LIFChannel, 1);
while (*name_cursor) {
if (gwy_strequal(*name_cursor, "Resolution")) {
channel->res = atoi(*value_cursor);
}
else if (gwy_strequal(*name_cursor, "Min")) {
channel->min = g_ascii_strtod(*value_cursor, NULL);
}
else if (gwy_strequal(*name_cursor, "Max")) {
channel->max = g_ascii_strtod(*value_cursor, NULL);
}
else if (gwy_strequal(*name_cursor, "Unit")) {
channel->unit = g_strdup(*value_cursor);
}
else if (gwy_strequal(*name_cursor, "LUTName")) {
channel->lut = g_strdup(*value_cursor);
}
else if (gwy_strequal(*name_cursor, "BytesInc")) {
channel->bytesinc = g_ascii_strtoull(*value_cursor,
NULL, 10);
}
name_cursor++;
value_cursor++;
}
if (!(element->channels)) {
element->channels = g_array_new(FALSE, TRUE,
sizeof(LIFChannel));
}
g_array_append_val(element->channels, *channel);
}
else if (gwy_strequal(element_name, "DimensionDescription")) {
LIFDimension *dimension = NULL;
if (!(data->elements->len)) {
gwy_debug("Wrong XML DimensionDescription block");
err_FILE_TYPE(error, "Leica LIF");
goto fail_xml;
}
element = (LIFElement *)g_ptr_array_index(data->elements,
data->elements->len - 1);
dimension = g_new0(LIFDimension, 1);
while (*name_cursor) {
if (gwy_strequal(*name_cursor, "DimID")) {
dimension->dimid = atoi(*value_cursor);
}
else if (gwy_strequal(*name_cursor, "NumberOfElements")) {
dimension->res = atoi(*value_cursor);
}
else if (gwy_strequal(*name_cursor, "Origin")) {
dimension->origin = g_ascii_strtod(*value_cursor, NULL);
}
else if (gwy_strequal(*name_cursor, "Length")) {
dimension->length = g_ascii_strtod(*value_cursor, NULL);
}
else if (gwy_strequal(*name_cursor, "Unit")) {
dimension->unit = g_strdup(*value_cursor);
}
else if (gwy_strequal(*name_cursor, "BytesInc")) {
dimension->bytesinc = g_ascii_strtoull(*value_cursor,
NULL, 10);
}
name_cursor++;
value_cursor++;
}
if (!(element->dimensions)) {
element->dimensions
= g_array_new(FALSE, TRUE, sizeof(LIFDimension));
}
g_array_append_val(element->dimensions, *dimension);
}
else if (gwy_strequal(element_name,
"ATLConfocalSettingDefinition")) {
if (!(data->elements->len)) {
gwy_debug("Wrong XML ATLConfocalSettingDefinition block");
err_FILE_TYPE(error, "Leica LIF");
goto fail_xml;
}
element = (LIFElement *)g_ptr_array_index(data->elements,
data->elements->len - 1);
if (!(element->metadata)) {
element->metadata = gwy_container_new();
}
while (*name_cursor) {
name = g_strdup(*name_cursor);
value = g_strdup(*value_cursor);
gwy_container_set_string_by_name(element->metadata,
name, value);
g_free(name);
name_cursor++;
value_cursor++;
}
}
fail_xml:
user_data = (gpointer)data;
return;
}
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 GwyContainer*
surffile_load(const gchar *filename,
G_GNUC_UNUSED GwyRunType mode,
GError **error)
{
SurfFile surffile;
GwyContainer *meta, *container = NULL;
guchar *buffer = NULL;
const guchar *p;
gsize expected_size, size = 0;
GError *err = NULL;
gchar signature[12];
gdouble max, min;
gint add = 0;
if (!gwy_file_get_contents(filename, &buffer, &size, &err)) {
err_GET_FILE_CONTENTS(error, &err);
g_clear_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.measurement_duration = gwy_get_guint16_le(&p);
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);
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);
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
}
p = buffer + SURF_HEADER_SIZE + add;
if (!fill_data_fields(&surffile, p, error)) {
gwy_file_abandon_contents(buffer, size, NULL);
return NULL;
}
if (!surffile.absolute) {
max = gwy_data_field_get_max(surffile.dfield);
min = gwy_data_field_get_min(surffile.dfield);
gwy_data_field_add(surffile.dfield, -min);
gwy_data_field_multiply(surffile.dfield,
(surffile.zmax - surffile.zmin)/(max-min));
}
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;
}
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);
return container;
}
