static gboolean burleigh_exp_read_header(BurleighExpHeader *header, gchar *buf, GError **error) { GwySIUnit *yunits = NULL, *dummy = NULL; gchar *p, *line; gwy_clear(header, 1); p = buf; /* Magic header */ if (!(line = gwy_str_next_line(&p)) || strncmp(line, MAGIC, MAGIC_SIZE) != 0) { err_FILE_TYPE(error, "Burleigh export"); return FALSE; } /* Skip all other lines starting with a dot */ while ((line = gwy_str_next_line(&p))) { if (sscanf(line, ".Binary Format, Header Length=%u, Integer %u bits", &header->length, &header->bpp)) header->binary = TRUE; if (!line || !p || p[0] != '.') break; } if (!line) { err_FILE_TYPE(error, "Burleigh export"); return FALSE; } if (!parse_scale(&p, "X Scale", &header->xscale, &header->xyunits, error)) return FALSE; if (!parse_dim(&p, "X Pixel", &header->xres, error)) return FALSE; if (!parse_scale(&p, "Y Scale", &header->yscale, &yunits, error)) return FALSE; /* FIXME: Check sanity */ g_object_unref(yunits); if (!parse_dim(&p, "Y Pixel", &header->yres, error)) return FALSE; if (!parse_scale(&p, "Z Scale", &header->zscale, &header->zunits, error)) return FALSE; if (!parse_scale(&p, "Z Res.(value/digital)", &header->zres, &dummy, error)) return FALSE; g_object_unref(dummy); if (!header->binary) header->length = p - buf; return TRUE; }
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 void header_end_element(G_GNUC_UNUSED GMarkupParseContext *context, const gchar *element_name, gpointer user_data, G_GNUC_UNUSED GError **error) { XMLParserData *data; LIFElement *element; data = (XMLParserData *)user_data; // gwy_debug("End name = %s", element_name); if (gwy_strequal(element_name, "Element")) { element = (LIFElement *)g_ptr_array_index(data->elements, data->elements->len - 1); if (!(element->memid)) { gwy_debug("Wrong XML: Element has no MemID"); err_FILE_TYPE(error, "Leica LIF"); } else { g_array_append_val(data->file->elements, *element); g_ptr_array_remove_index(data->elements, data->elements->len - 1); } } user_data = (gpointer)data; }
static GHashTable* hitachi_load_header(const gchar *filename, gchar **header, GError **error) { gchar *line, *p; GwyTextHeaderParser parser; GHashTable *hash = NULL; gsize size; GError *err = NULL; *header = NULL; if (!g_file_get_contents(filename, header, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } p = *header; line = gwy_str_next_line(&p); if (!gwy_strequal(line, MAGIC)) { err_FILE_TYPE(error, "Hitachi SEM"); g_free(header); *header = NULL; return NULL; } gwy_clear(&parser, 1); parser.key_value_separator = "="; gwy_debug("reading header"); hash = gwy_text_header_parse(p, &parser, NULL, NULL); gwy_debug("header %p", hash); return hash; }
static GwyContainer* dumb_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *container = NULL; gchar *buffer = NULL; GError *err = NULL; gsize size; if (!g_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (size < MAGIC_SIZE || memcmp(buffer, MAGIC, MAGIC_SIZE) != 0) { err_FILE_TYPE(error, "Gwyddion dumb dump"); goto fail; } container = text_dump_import(buffer, size, filename, error); fail: g_free(buffer); return container; }
static gboolean mif_read_header(const guchar *buffer, gsize size, MIFHeader *header, GError **error) { const guchar *p = buffer; if (size <= HEADER_SIZE) { err_TOO_SHORT(error); return FALSE; } if (memcmp(buffer, MAGIC, MAGIC_SIZE)) { err_FILE_TYPE(error, "MIF"); return FALSE; } gwy_clear(header, 1); get_CHARARRAY(header->magic, &p); header->software_version = gwy_get_guint16_be(&p); header->file_version = gwy_get_guint16_be(&p); gwy_debug("sw version: %u.%u, file version: %u.%u", header->software_version/0x100, header->software_version % 0x100, header->file_version/0x100, header->file_version % 0x100); /* Version 1.7 is the only actually implemented. Other can be added upon * request and, namely, provision of the files as each file version is * different. */ if (header->file_version != 0x107) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Loading of file version %u.%u is not implemented."), header->file_version/0x100, header->file_version % 0x100); return FALSE; } get_CHARARRAY(header->time, &p); get_CHARARRAY(header->comment, &p); header->nimages = gwy_get_guint16_le(&p); gwy_debug("n images: %u", header->nimages); header->info.offset = gwy_get_guint32_le(&p); header->info.size = gwy_get_guint32_le(&p); gwy_debug("info offset: %zu, info size: %zu", header->info.offset, header->info.size); get_CHARARRAY(header->unused, &p); if (header->info.offset < HEADER_SIZE || header->info.offset > size || header->info.size > size || header->info.offset + header->info.size > size) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("File information block is outside the file.")); return FALSE; } return TRUE; }
static GwyContainer* gwyfile_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GObject *object; GError *err = NULL; guchar *buffer = NULL; gsize size = 0; gsize pos = 0; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (size < MAGIC_SIZE || (memcmp(buffer, MAGIC, MAGIC_SIZE) && memcmp(buffer, MAGIC2, MAGIC_SIZE))) { err_FILE_TYPE(error, "Gwyddion"); gwy_file_abandon_contents(buffer, size, &err); return NULL; } if (!memcmp(buffer, MAGIC, MAGIC_SIZE)) { object = gwy_container_deserialize_old(buffer + MAGIC_SIZE, size - MAGIC_SIZE, &pos); gwyfile_remove_old_data(object); } else object = gwy_serializable_deserialize(buffer + MAGIC_SIZE, size - MAGIC_SIZE, &pos); gwy_file_abandon_contents(buffer, size, &err); if (!object) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Data deserialization failed.")); return NULL; } if (!GWY_IS_CONTAINER(object)) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Data deserialization succeeded, but resulted in " "an unexpected object %s."), g_type_name(G_TYPE_FROM_INSTANCE(object))); g_object_unref(object); return NULL; } gwyfile_pack_metadata(GWY_CONTAINER(object)); return GWY_CONTAINER(object); }
static GwyContainer* ecs_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *meta, *container = NULL; guchar *buffer = NULL; gsize size = 0; GError *err = NULL; GwyDataField *dfield = NULL; gchar *s = NULL, *s2 = NULL; GwySIUnit *siunit; const guchar *p; gdouble *data, *row; guint xres, yres, i, j; gdouble xreal, q; const gint16 *pdata; guchar c; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); g_clear_error(&err); return NULL; } if (size < HEADER_SIZE + 2) { err_TOO_SHORT(error); goto fail; } p = buffer + ECS_RESOLUTION; xres = gwy_get_guint16_le(&p); yres = gwy_get_guint16_le(&p); gwy_debug("xres: %u, yres: %u", xres, yres); if (size != HEADER_SIZE + 2*xres*yres) { err_SIZE_MISMATCH(error, HEADER_SIZE + 2*xres*yres, size); goto fail; } /* Scan size */ p = buffer + ECS_SCAN_SIZE; s = get_PASCAL_STRING(&p, HEADER_SIZE - ECS_SCAN_SIZE); if (!s) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Scan size header field overlaps with data.")); goto fail; } gwy_debug("Scan size str: <%s>", s); if (!g_str_has_prefix(s, "Scan Size: ")) { err_FILE_TYPE(error, "ECS"); goto fail; } if (sscanf(s + strlen("Scan Size: "), "%lf %lf%c", &xreal, &q, &c) != 3) { err_INVALID(error, "Scan Size"); goto fail; } g_free(s); s = NULL; gwy_debug("xreal: %g q: %g unit: %s", xreal, q, c == 0x8f ? "Angstrom" : "Nanometer"); if (c == 0x8f) { xreal *= 1e-10; q *= 1e-10; } else { xreal *= 1e-9; q *= 1e-9; } q /= 65536.0; /* This does not make much sense when xres != yres, but it is what * Snomputz does. */ dfield = gwy_data_field_new(xres, yres, xreal, xreal, FALSE); data = gwy_data_field_get_data(dfield); pdata = (const gint16*)(buffer + HEADER_SIZE); for (i = 0; i < yres; i++) { row = data + (yres-1 - i)*xres; for (j = 0; j < xres; j++) row[j] = GINT16_TO_LE(pdata[i*xres + j])*q; } siunit = gwy_si_unit_new("m"); gwy_data_field_set_si_unit_xy(dfield, siunit); g_object_unref(siunit); siunit = gwy_si_unit_new("m"); gwy_data_field_set_si_unit_z(dfield, siunit); g_object_unref(siunit); container = gwy_container_new(); gwy_container_set_object_by_name(container, "/0/data", dfield); /* Channel title */ p = buffer + ECS_CHANNEL; s = get_PASCAL_STRING(&p, HEADER_SIZE - ECS_CHANNEL); if (!s || !*s) s = g_strdup("Topography"); gwy_container_set_string_by_name(container, "/0/data/title", s); s = NULL; meta = gwy_container_new(); /* Date & time */ p = buffer + ECS_DATE; s = get_PASCAL_STRING(&p, HEADER_SIZE - ECS_DATE); if (s) { p = buffer + ECS_TIME; s2 = get_PASCAL_STRING(&p, HEADER_SIZE - ECS_TIME); if (s2) { gwy_container_set_string_by_name(meta, "Date", g_strconcat(s, " ", s2, NULL)); g_free(s2); s2 = NULL; } g_free(s); s = NULL; } /* Channel title */ p = buffer + ECS_CHANNEL; s = get_PASCAL_STRING(&p, HEADER_SIZE - ECS_CHANNEL); if (s && *s) { gwy_container_set_string_by_name(meta, "Comment", s); s = NULL; } if (gwy_container_get_n_items(meta)) gwy_container_set_object_by_name(container, "/0/meta", meta); g_object_unref(meta); fail: g_free(s); g_free(s2); gwy_object_unref(dfield); gwy_file_abandon_contents(buffer, size, NULL); return container; }
static GwyContainer* stmprg_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *meta, *container = NULL; StmprgFile stmprgfile; guchar *buffer = NULL; gsize size = 0; GError *err = NULL; GwyDataField *dfield; char *filename_ta, *ptr; gboolean ok; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (size < MAGIC_SIZE || memcmp(buffer, MAGIC_TXT, MAGIC_SIZE) != 0) { err_FILE_TYPE(error, "Omicron STMPRG"); gwy_file_abandon_contents(buffer, size, NULL); return NULL; } gwy_clear(&stmprgfile, 1); ok = read_parameters(buffer, size, &stmprgfile, error); gwy_file_abandon_contents(buffer, size, NULL); if (!ok) return NULL; filename_ta = g_strdup(filename); ptr = filename_ta + strlen(filename_ta) - 1; while (g_ascii_isdigit(*ptr) && ptr > filename_ta+1) ptr--; if (ptr == filename_ta+1) { err_DATA_PART(error, filename); g_free(filename_ta); return NULL; } /* Accept lowercase and uppercase and try the same case for data file */ if (*ptr == 'p' && *(ptr - 1) == 't') *ptr = 'a'; if (*ptr == 'P' && *(ptr - 1) == 'T') *ptr = 'A'; if (!gwy_file_get_contents(filename_ta, &buffer, &size, &err)) { g_free(filename_ta); err_GET_FILE_CONTENTS(error, &err); return NULL; } g_free(filename_ta); dfield = read_datafield(buffer, size, &stmprgfile, error); if (dfield) { container = gwy_container_new(); gwy_container_set_object_by_name(container, "/0/data", dfield); g_object_unref(dfield); /* FIXME: with documentation, we could perhaps do better */ gwy_app_channel_title_fall_back(container, 0); meta = stmprg_get_metadata(&stmprgfile); gwy_container_set_object_by_name(container, "/0/meta", meta); g_object_unref(meta); gwy_file_channel_import_log_add(container, 0, NULL, filename); } 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* 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; }
static gsize pt3file_read_header(const guchar *buffer, gsize size, PicoHarpFile *pt3file, GError **error) { const guchar* (*read_imaging_header)(PicoHarpImagingHeader *header, const guchar *p); PicoHarpInstrument instr; const guchar *p; guint i, expected_size; p = buffer; if (size < HEADER_MIN_SIZE + 2) { err_TOO_SHORT(error); return 0; } get_CHARARRAY(pt3file->ident, &p); get_CHARARRAY(pt3file->format_version, &p); get_CHARARRAY(pt3file->creator_name, &p); get_CHARARRAY(pt3file->creator_version, &p); gwy_debug("<%.*s> <%.*s> <%.*s> <%.*s>", (gint)sizeof(pt3file->ident), pt3file->ident, (gint)sizeof(pt3file->format_version), pt3file->format_version, (gint)sizeof(pt3file->creator_name), pt3file->creator_name, (gint)sizeof(pt3file->creator_version), pt3file->creator_version); get_CHARARRAY(pt3file->file_time, &p); get_CHARARRAY(pt3file->crlf, &p); get_CHARARRAY(pt3file->comment, &p); if (memcmp(pt3file->ident, MAGIC, MAGIC_SIZE) != 0 || pt3file->crlf[0] != '\r' || pt3file->crlf[1] != '\n') { err_FILE_TYPE(error, "PicoHarp"); return 0; } pt3file->number_of_curves = gwy_get_guint32_le(&p); gwy_debug("number_of_curves: %u", pt3file->number_of_curves); pt3file->bits_per_record = gwy_get_guint32_le(&p); gwy_debug("bits_per_record: %u", pt3file->bits_per_record); pt3file->routing_channels = gwy_get_guint32_le(&p); gwy_debug("routing_channels: %u", pt3file->routing_channels); pt3file->number_of_boards = gwy_get_guint32_le(&p); gwy_debug("number_of_boards: %u", pt3file->number_of_boards); if (pt3file->number_of_boards != 1) { g_warning("Number of boards is %u instead of 1. Reading one.", pt3file->number_of_boards); pt3file->number_of_boards = MAX(pt3file->number_of_boards, 1); if (size < HEADER_MIN_SIZE + BOARD_SIZE*pt3file->number_of_boards) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("File header is truncated.")); return 0; } } pt3file->active_curve = gwy_get_guint32_le(&p); pt3file->measurement_mode = gwy_get_guint32_le(&p); gwy_debug("measurement_mode: %u", pt3file->measurement_mode); pt3file->sub_mode = gwy_get_guint32_le(&p); gwy_debug("sub_mode: %u", pt3file->sub_mode); pt3file->range_no = gwy_get_guint32_le(&p); pt3file->offset = gwy_get_gint32_le(&p); pt3file->acquisition_time = gwy_get_guint32_le(&p); pt3file->stop_at = gwy_get_guint32_le(&p); pt3file->stop_on_ovfl = gwy_get_guint32_le(&p); pt3file->restart = gwy_get_guint32_le(&p); pt3file->display_lin_log = !!gwy_get_guint32_le(&p); pt3file->display_time_axis_from = gwy_get_guint32_le(&p); pt3file->display_time_axis_to = gwy_get_guint32_le(&p); pt3file->display_counts_axis_from = gwy_get_guint32_le(&p); pt3file->display_counts_axis_to = gwy_get_guint32_le(&p); for (i = 0; i < G_N_ELEMENTS(pt3file->display_curve); i++) { pt3file->display_curve[i].map_to = gwy_get_guint32_le(&p); pt3file->display_curve[i].show = gwy_get_guint32_le(&p); } for (i = 0; i < G_N_ELEMENTS(pt3file->auto_param); i++) { pt3file->auto_param[i].start = gwy_get_gfloat_le(&p); pt3file->auto_param[i].step = gwy_get_gfloat_le(&p); pt3file->auto_param[i].end = gwy_get_gfloat_le(&p); } pt3file->repeat_mode = gwy_get_guint32_le(&p); pt3file->repeats_per_curve = gwy_get_guint32_le(&p); pt3file->repeat_time = gwy_get_guint32_le(&p); pt3file->repeat_wait_time = gwy_get_guint32_le(&p); get_CHARARRAY(pt3file->script_name, &p); p = pt3file_read_board(&pt3file->board, p); p += BOARD_SIZE*(pt3file->number_of_boards - 1); pt3file->ext_devices = gwy_get_guint32_le(&p); pt3file->reserved1 = gwy_get_guint32_le(&p); pt3file->reserved2 = gwy_get_guint32_le(&p); pt3file->input0_rate = gwy_get_guint32_le(&p); pt3file->input1_rate = gwy_get_guint32_le(&p); pt3file->stop_after = gwy_get_guint32_le(&p); pt3file->stop_reason = gwy_get_guint32_le(&p); pt3file->number_of_records = gwy_get_guint32_le(&p); gwy_debug("number_of_records: %u", pt3file->number_of_records); pt3file->spec_header_length = 4*gwy_get_guint32_le(&p); gwy_debug("spec_header_length: %u", pt3file->spec_header_length); gwy_debug("now at pos 0x%0lx", (gulong)(p - buffer)); if (pt3file->measurement_mode != 2 && pt3file->measurement_mode != 3) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Measurement mode must be 2 or 3; %u is invalid."), pt3file->measurement_mode); return 0; } if (pt3file->sub_mode != PICO_HARP_IMAGE) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Only area imaging files are supported.")); return 0; } if (pt3file->bits_per_record != 32) { err_BPP(error, pt3file->bits_per_record); return 0; } pt3file->imaging.common.dimensions = gwy_get_guint32_le(&p); gwy_debug("imaging dimensions: %u", pt3file->imaging.common.dimensions); if (pt3file->imaging.common.dimensions != 3) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Only area imaging files are supported.")); return 0; } pt3file->imaging.common.instrument = instr = gwy_get_guint32_le(&p); gwy_debug("imaging instrument: %u", pt3file->imaging.common.instrument); if (instr == PICO_HARP_PIE710) { expected_size = IMAGING_PIE710_SIZE; read_imaging_header = &read_pie710_imaging_header; } else if (instr == PICO_HARP_KDT180) { expected_size = IMAGING_KDT180_SIZE; read_imaging_header = &read_kdt180_imaging_header; } else if (instr == PICO_HARP_LSM) { expected_size = IMAGING_LSM_SIZE; read_imaging_header = &read_lsm_imaging_header; } else { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Unknown instrument number %u."), instr); return 0; } if (pt3file->spec_header_length != expected_size) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Wrong imaging header size: %u instead of %u."), pt3file->spec_header_length, expected_size); return 0; } if ((p - buffer) + expected_size > size) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("File header is truncated.")); return 0; } p = read_imaging_header(&pt3file->imaging, p); gwy_debug("xres: %u", pt3file->imaging.common.xres); gwy_debug("yres: %u", pt3file->imaging.common.yres); if (err_DIMENSION(error, pt3file->imaging.common.xres) || err_DIMENSION(error, pt3file->imaging.common.xres)) return 0; return (gsize)(p - buffer); }
static GwyContainer* sly_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *container = NULL, *meta = NULL; gchar *buffer = NULL; GError *err = NULL; GHashTable *hash = NULL; gchar *p, *line, *value; guint expecting_data = 0; SensolyticsChannel *channels = NULL; Dimensions dimensions; gint ndata = 0, i; if (!g_file_get_contents(filename, &buffer, NULL, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } p = buffer; line = gwy_str_next_line(&p); g_strstrip(line); if (!gwy_strequal(line, MAGIC)) { err_FILE_TYPE(error, "Sensolytics"); goto fail; } hash = g_hash_table_new(g_str_hash, g_str_equal); for (line = gwy_str_next_line(&p); line; line = gwy_str_next_line(&p)) { if (!line[0]) continue; if (expecting_data) { expecting_data--; /* The columns are comma-separated and numbers use decimal points. * Do not tempt the number parsing functions more than necessary * and fix commas to tab characters. */ g_strdelimit(line, ",", '\t'); /* Ignore X, Y and Z, each is two values */ for (i = 0; i < 6; i++) g_ascii_strtod(line, &line); for (i = 0; i < ndata; i++) channels[i].data[expecting_data] = channels[i].q * g_ascii_strtod(line, &line); } else { g_strstrip(line); if (line[0] != '#') { g_warning("Comment line does not start with #."); continue; } do { line++; } while (g_ascii_isspace(*line)); if (g_str_has_prefix(line, "X [")) { if (channels) { g_warning("Multiple data headers!?"); continue; } if (!read_dimensions(hash, &ndata, &dimensions, error) || !(channels = create_fields(hash, line, ndata, &dimensions))) goto fail; expecting_data = dimensions.xres * dimensions.yres; continue; } value = strchr(line, ':'); if (!value) { if (!gwy_strequal(line, "ArrayScan")) g_warning("Non-parameter-like line %s", line); continue; } *value = '\0'; g_strchomp(line); do { value++; } while (g_ascii_isspace(*value)); if (gwy_strequal(line, "Warning")) continue; gwy_debug("<%s>=<%s>", line, value); g_hash_table_insert(hash, line, value); } } if (!channels) { err_NO_DATA(error); goto fail; } container = gwy_container_new(); for (i = 0; i < ndata; i++) { GQuark key = gwy_app_get_data_key_for_id(i); gwy_data_field_invert(channels[i].dfield, FALSE, TRUE, FALSE); gwy_container_set_object(container, key, channels[i].dfield); gwy_app_channel_check_nonsquare(container, i); if (channels[i].name) { gchar *s = g_strconcat(g_quark_to_string(key), "/title", NULL); gwy_container_set_string_by_name(container, s, g_strdup(channels[i].name)); g_free(s); } else gwy_app_channel_title_fall_back(container, i); gwy_file_channel_import_log_add(container, i, NULL, filename); } meta = get_meta(hash); clone_meta(container, meta, ndata); g_object_unref(meta); fail: g_free(buffer); if (hash) g_hash_table_destroy(hash); if (channels) { for (i = 0; i < ndata; i++) g_object_unref(channels[i].dfield); g_free(channels); } return container; }
static void apedax_get_channels_data(unzFile uFile, guchar *scanXmlContent, gsize contentSize, const gchar *filename, GwyContainer *container, GwyContainer *meta, const APEScanSize *scanSize, GError **error) { xmlDocPtr doc = NULL; xmlNodePtr cur = NULL; xmlXPathContextPtr context; xmlXPathObjectPtr pathObj; xmlNodeSetPtr nodeset; xmlChar *buffer = NULL; gchar key[256]; gint i; gint power10 = 0; gdouble scaleFactor = 1.0; GwySIUnit *zUnit; gchar *zUnitString = NULL; gchar *binFileName = NULL; GwyDataField *dfield; GwyContainer *tmp; if (scanXmlContent == NULL || contentSize == 0) return; gwy_clear(key, sizeof(key)); doc = xmlReadMemory(scanXmlContent, contentSize, "scan.xml", NULL, 0); if (doc == NULL) goto fail; context = xmlXPathNewContext(doc); if (context == NULL) goto fail; pathObj = xmlXPathEvalExpression("/Scan/Channels/Channel", context); if (pathObj == NULL) { xmlXPathFreeContext(context); goto fail; } /*There must be at least one channel*/ if (xmlXPathNodeSetIsEmpty(pathObj->nodesetval)) { xmlXPathFreeObject(pathObj); xmlXPathFreeContext(context); err_NO_DATA(error); return; } nodeset = pathObj->nodesetval; if (nodeset->nodeNr <= 0) goto fail; for (i = 0; i < nodeset->nodeNr; i++) { cur = nodeset->nodeTab[i]->xmlChildrenNode; while (cur) { /*Label*/ if (gwy_strequal((gchar*)cur->name, "Label")) { buffer = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); g_snprintf(key, sizeof(key), "/%d/data/title", i); gwy_container_set_string_by_name(container, key, g_strdup(buffer)); xmlFree(buffer); } /*Factor*/ if (gwy_strequal((gchar*)cur->name, "ConversionFactor")) { buffer = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); scaleFactor = g_ascii_strtod((gchar*)buffer, NULL); xmlFree(buffer); } /*Unit*/ if (gwy_strequal((gchar*)cur->name, "DataUnit")) { buffer = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); zUnitString = g_strdup((gchar*)buffer); zUnit = gwy_si_unit_new_parse(zUnitString, &power10); xmlFree(buffer); g_object_unref(zUnit); } /*Binary file name*/ if (gwy_strequal((gchar*)cur->name, "BINFile")) { buffer = xmlNodeListGetString(doc, cur->xmlChildrenNode, 1); binFileName = g_strdup((gchar*)buffer); xmlFree(buffer); } cur = cur->next; } scaleFactor *= pow(10.0, power10); dfield = apedax_get_data_field(uFile, binFileName, scanSize, zUnitString, scaleFactor, error); if (dfield) { g_snprintf(key, sizeof(key), "/%d/data", i); gwy_container_set_object_by_name(container, key, dfield); g_object_unref(dfield); gwy_file_channel_import_log_add(container, i, NULL, filename); tmp = gwy_container_duplicate(meta); g_snprintf(key, sizeof(key), "/%d/meta", i); gwy_container_set_object_by_name(container, key, tmp); g_object_unref(tmp); } } xmlXPathFreeObject(pathObj); xmlXPathFreeContext(context); xmlFreeDoc(doc); return; fail: err_FILE_TYPE(error, FILE_TYPE); if (doc) xmlFreeDoc(doc); return; }
static GwyContainer* asc_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *container = NULL; GwyDataField *dfield = NULL, *mfield = NULL; GwyTextHeaderParser parser; GwySIUnit *unit; gchar *line, *p, *value, *buffer = NULL; GHashTable *hash = NULL; gsize size; GError *err = NULL; gdouble xreal, yreal, q; gint i, xres, yres; gdouble *data; if (!g_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); goto fail; } p = buffer; line = gwy_str_next_line(&p); if (!gwy_strequal(line, MAGIC_BARE)) { err_FILE_TYPE(error, "SPIP ASCII data"); goto fail; } gwy_clear(&parser, 1); parser.line_prefix = "#"; parser.key_value_separator = "="; parser.terminator = "# Start of Data:"; parser.error = &header_error; parser.end = &header_end; if (!(hash = gwy_text_header_parse(p, &parser, &p, &err))) { g_propagate_error(error, err); goto fail; } if (!require_keys(hash, error, "x-pixels", "y-pixels", "x-length", "y-length", NULL)) goto fail; xres = atoi(g_hash_table_lookup(hash, "x-pixels")); yres = atoi(g_hash_table_lookup(hash, "y-pixels")); if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres)) goto fail; xreal = Nanometer * g_ascii_strtod(g_hash_table_lookup(hash, "x-length"), NULL); yreal = Nanometer * g_ascii_strtod(g_hash_table_lookup(hash, "y-length"), NULL); /* Use negated positive conditions to catch NaNs */ if (!((xreal = fabs(xreal)) > 0)) { g_warning("Real x size is 0.0, fixing to 1.0"); xreal = 1.0; } if (!((yreal = fabs(yreal)) > 0)) { g_warning("Real y size is 0.0, fixing to 1.0"); yreal = 1.0; } dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE); unit = gwy_si_unit_new("m"); gwy_data_field_set_si_unit_xy(dfield, unit); g_object_unref(unit); if ((value = g_hash_table_lookup(hash, "z-unit"))) { gint power10; unit = gwy_si_unit_new_parse(value, &power10); gwy_data_field_set_si_unit_z(dfield, unit); g_object_unref(unit); q = pow10(power10); } else if ((value = g_hash_table_lookup(hash, "Bit2nm"))) { q = Nanometer * g_ascii_strtod(value, NULL); unit = gwy_si_unit_new("m"); gwy_data_field_set_si_unit_z(dfield, unit); g_object_unref(unit); } else q = 1.0; data = gwy_data_field_get_data(dfield); value = p; for (i = 0; i < xres*yres; i++) { data[i] = q*g_ascii_strtod(value, &p); if (p == value && (!*p || g_ascii_isspace(*p))) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("End of file reached when reading sample #%d of %d"), i, xres*yres); goto fail; } if (p == value) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Malformed data encountered when reading sample " "#%d of %d"), i, xres*yres); goto fail; } value = p; } if ((value = g_hash_table_lookup(hash, "voidpixels")) && atoi(value)) { mfield = gwy_data_field_new_alike(dfield, FALSE); data = gwy_data_field_get_data(mfield); value = p; for (i = 0; i < xres*yres; i++) { data[i] = 1.0 - g_ascii_strtod(value, &p); value = p; } if (!gwy_app_channel_remove_bad_data(dfield, mfield)) GWY_OBJECT_UNREF(mfield); } container = gwy_container_new(); gwy_container_set_object(container, gwy_app_get_data_key_for_id(0), dfield); if (mfield) { gwy_container_set_object(container, gwy_app_get_mask_key_for_id(0), mfield); g_object_unref(mfield); } gwy_file_channel_import_log_add(container, 0, NULL, filename); fail: GWY_OBJECT_UNREF(dfield); g_free(buffer); if (hash) g_hash_table_destroy(hash); return container; }
static GwyContainer* oldmda_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *container = NULL; OldMDAFile mdafile; gchar *head, *buffer = NULL; gchar *buffer2 = NULL; gchar *dataname = NULL, *dname; GMarkupParser parser = { start_element, end_element, parse_text, NULL, NULL }; GMarkupParseContext *context; gsize size, size2; MDAXMLParams params; GError *err = NULL; if (!g_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); goto fail; } gwy_clear(&mdafile, 1); head = g_strndup(buffer, 1024); if (!check_magic(head)) { err_FILE_TYPE(error, "NTMDT old MDA"); g_free(head); goto fail; } g_free(head); params.xdata = g_array_new(FALSE, TRUE, sizeof(gdouble)); params.numaxes = 0; params.axes = g_array_new(FALSE, FALSE, sizeof(MDAAxis)); params.flag = MDA_XML_NONE; context = g_markup_parse_context_new(&parser, G_MARKUP_TREAT_CDATA_AS_TEXT, ¶ms, NULL); if (!g_markup_parse_context_parse(context, buffer, size, &err) || !g_markup_parse_context_end_parse(context, &err)) { g_clear_error(&err); g_markup_parse_context_free(context); } else { g_markup_parse_context_free(context); } if (params.axes->len != 4) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Incorrect number of axes in parameter file.")); goto fail; } oldmda_read_params(¶ms, &mdafile); dname = g_strdelimit(params.dataname, "\\/", G_DIR_SEPARATOR); if (!(dataname = oldmda_find_data_name(filename, dname))) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("No corresponding data file was found for header file.")); goto fail; } if (!g_file_get_contents(dataname, &buffer2, &size2, &err)) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_IO, _("Cannot load data file: %s"), err->message); g_clear_error(&err); goto fail; } if ((size2 != params.arraysize * params.datacellmemsize) || (params.arraysize != mdafile.xres * mdafile.yres * mdafile.zres)) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_IO, _("Data file is too short.")); g_clear_error(&err); goto fail2; } container = gwy_container_new(); mdafile.data = container; mdafile.filename = dataname; oldmda_read_data(&mdafile, buffer2); fail2: g_free(buffer2); fail: oldmda_free(¶ms); g_free(buffer); return container; }
static GwyContainer* csmfile_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *meta, *container = NULL; GHashTable *hash = NULL; guchar *d24, *buffer = NULL; gsize size = 0; GError *err = NULL; GwyDataField *dfield = NULL; guint xres, yres, bmpsize, header_size, maxval, i, j; gdouble real, zmin, zmax, q, z0; GwyTextHeaderParser parser; GwySIUnit *unit = NULL; gchar *value, *end, *header = NULL; gdouble *data; gint power10; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (size < BMP_HEADER_SIZE) { err_TOO_SHORT(error); goto fail; } if (!read_bmp_header(buffer, &xres, &yres, &bmpsize) || size <= bmpsize) { err_FILE_TYPE(error, "CSM"); goto fail; } header_size = size - bmpsize; header = g_new(gchar, header_size + 1); memcpy(header, buffer + bmpsize, header_size); header[header_size] = '\0'; gwy_clear(&parser, 1); parser.key_value_separator = "="; hash = gwy_text_header_parse(header, &parser, NULL, NULL); /* Do NOT use the fields Image width, Image height from the added footer. * Even though it is specifically added by Benyuan it can disagree with the * BMP diemsions and when they disagree the BMP diemsions are apparently * right. */ if (err_DIMENSION(error, xres)) goto fail; if (err_DIMENSION(error, yres)) goto fail; if (!(value = g_hash_table_lookup(hash, "ScanSize"))) { err_MISSING_FIELD(error, "ScanSize"); goto fail; } real = g_ascii_strtod(value, NULL); /* Use negated positive conditions to catch NaNs */ if (!((real = fabs(real)) > 0)) { g_warning("Real size is 0.0, fixing to 1.0"); real = 1.0; } if (!(value = g_hash_table_lookup(hash, "HeightScale"))) { err_MISSING_FIELD(error, "HeightScale"); goto fail; } zmax = g_ascii_strtod(value, &end); unit = gwy_si_unit_new_parse(end, &power10); /* Optional stuff for which we try to fall back. */ if (!(value = g_hash_table_lookup(hash, "StartHeightScale"))) zmin = 0.0; else zmin = g_ascii_strtod(value, NULL); if (!(value = g_hash_table_lookup(hash, "MaxValue"))) maxval = 0xffff; else maxval = MAX(atoi(value), 1); dfield = gwy_data_field_new(xres, yres, real*Nanometre, real*Nanometre, FALSE); data = gwy_data_field_get_data(dfield); d24 = buffer + BMP_HEADER_SIZE; q = pow10(power10)*(zmax - zmin)/maxval; z0 = pow10(power10)*zmin; for (i = 0; i < yres; i++) { gdouble *row = data + (yres-1 - i)*xres; for (j = 0; j < xres; j++, row++, d24 += 3) *row = (d24[0] + 256.0*d24[1])*q + z0; } gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m"); gwy_data_field_set_si_unit_z(dfield, unit); container = gwy_container_new(); gwy_container_set_object_by_name(container, "/0/data", dfield); g_object_unref(dfield); meta = gwy_container_new(); g_hash_table_foreach(hash, store_meta, meta); gwy_container_set_object_by_name(container, "/0/meta", meta); g_object_unref(meta); if ((value = g_hash_table_lookup(hash, "sTitle")) && g_utf8_validate(value, -1, NULL)) { gwy_container_set_string_by_name(container, "/0/data/title", g_strdup(value)); } else gwy_app_channel_title_fall_back(container, 0); gwy_file_channel_import_log_add(container, 0, NULL, filename); fail: gwy_file_abandon_contents(buffer, size, NULL); GWY_OBJECT_UNREF(unit); if (header) g_free(header); if (hash) g_hash_table_destroy(hash); return container; }
static GwyContainer* jeol_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { JEOLImageHeader image_header; GwyContainer *meta, *container = NULL; guchar *buffer = NULL; gsize expected_size, size = 0; GError *err = NULL; GwyDataField *dfield = NULL; const gchar *title; gchar *s; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (size < JEOL_DATA_START) { err_TOO_SHORT(error); goto fail; } if (memcmp(buffer, MAGIC, MAGIC_SIZE) != 0) { err_FILE_TYPE(error, "JEOL"); goto fail; } jeol_read_image_header(buffer, &image_header); /* Elementrary sanity */ if (image_header.bpp != 16) { err_BPP(error, image_header.bpp); goto fail; } if (err_DIMENSION(error, image_header.xres) || err_DIMENSION(error, image_header.yres)) goto fail; expected_size = image_header.bpp/8 * image_header.xres*image_header.yres; if (err_SIZE_MISMATCH(error, JEOL_DATA_START + expected_size, size, FALSE)) goto fail; if (image_header.image_type != JEOL_IMAGE || image_header.compressed) { err_NO_DATA(error); goto fail; } /* Use negated positive conditions to catch NaNs */ if (!((image_header.xreal = fabs(image_header.xreal)) > 0)) { g_warning("Real x size is 0.0, fixing to 1.0"); image_header.xreal = 1.0; } if (!((image_header.yreal = fabs(image_header.yreal)) > 0)) { g_warning("Real y size is 0.0, fixing to 1.0"); image_header.yreal = 1.0; } dfield = jeol_read_data_field(buffer + JEOL_DATA_START, &image_header); if (!dfield) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("The type of data is unknown. " "Please report it to the developers.")); goto fail; } container = gwy_container_new(); gwy_container_set_object_by_name(container, "/0/data", dfield); g_object_unref(dfield); /* Title */ s = g_convert(image_header.internal_filename, -1, "iso-8859-1", "utf-8", NULL, NULL, NULL); if (s) g_strstrip(s); if (s && *s) gwy_container_set_string_by_name(container, "/0/data/title", s); else { title = gwy_flat_enum_to_string(image_header.data_source, G_N_ELEMENTS(data_sources), data_sources, data_sources_name); if (title) gwy_container_set_string_by_name(container, "/0/data/title", g_strdup(title)); } /* Meta */ meta = jeol_get_metadata(&image_header); gwy_container_set_object_by_name(container, "/0/meta", meta); g_object_unref(meta); gwy_file_channel_import_log_add(container, 0, NULL, filename); fail: gwy_file_abandon_contents(buffer, size, NULL); return container; }
static GwyContainer* apedax_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *container = NULL; GwyContainer *meta = NULL; unzFile uFile; unz_file_info uFileInfo; guchar *buffer; gsize size = 0; gboolean apdt_flag = FALSE; gchar *lowercaseFilename; APEScanSize scanSize; scanSize.XRes = 0; scanSize.YRes = 0; scanSize.XReal = 0.0; scanSize.YReal = 0.0; lowercaseFilename = g_ascii_strdown(filename, -1); if (g_str_has_suffix(filename, APDT_EXTENSION)) { apdt_flag = TRUE; } g_free(lowercaseFilename); gwy_debug("Opening the file with MiniZIP"); uFile = gwyminizip_unzOpen(filename); if (uFile == NULL) { if (apdt_flag) { err_FILE_TYPE(error, APDT_FILE_TYPE); } else { err_FILE_TYPE(error, FILE_TYPE); } unzClose(uFile); return NULL; } gwy_debug("Locating the XML file"); if (unzLocateFile(uFile, "scan.xml", 0) != UNZ_OK) { if (apdt_flag) { err_FILE_TYPE(error, APDT_FILE_TYPE); } else { err_FILE_TYPE(error, FILE_TYPE); } unzClose(uFile); return NULL; } gwy_debug("Getting the XML file info"); if (unzGetCurrentFileInfo(uFile, &uFileInfo, NULL, 0L, NULL, 0L, NULL, 0L) != UNZ_OK) { err_OPEN_READ(error); unzClose(uFile); return NULL; } buffer = apedax_get_file_content(uFile, &uFileInfo, &size, error); container = gwy_container_new(); meta = apedax_get_meta(buffer, size, &scanSize, apdt_flag); if (meta == NULL) { gwy_debug("Metadata Container is NULL"); g_object_unref(container); g_free(buffer); err_FILE_TYPE(error, FILE_TYPE); unzClose(uFile); return NULL; } apedax_get_channels_data(uFile, buffer, size, filename, container, meta, &scanSize, error); g_free(buffer); g_object_unref(meta); unzClose(uFile); return container; }
static GwyContainer* int_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *container = NULL, *meta; GwyDataField *dfield = NULL, *mfield = NULL; CodeVGridDataType type; gchar *line, *p, *comment, *end, *buffer = NULL; const gchar *unit, *title; gchar **fields = NULL; gsize size; GError *err = NULL; gdouble xreal, yreal; gint i, xres, yres, no_data_value = 32767; guint fi; gdouble scale_size, wavelength, q = 1.0, x_scale = 1.0; gboolean nearest_neighbour = FALSE; gdouble *data, *mdata; if (!g_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); goto fail; } /* Skip comments. */ p = buffer; for (line = gwy_str_next_line(&p); line && line[0] == '!'; line = gwy_str_next_line(&p)) { gwy_debug("comment <%s>", line); } if (!line) { err_FILE_TYPE(error, "Code V INT"); goto fail; } /* The title. */ comment = line; if (!(line = gwy_str_next_line(&p))) { err_FILE_TYPE(error, "Code V INT"); goto fail; } gwy_debug("comment <%s>", comment); fields = split_line_in_place(line); if (!fields || g_strv_length(fields) < 8 || !gwy_strequal(fields[0], "GRD") || !(xres = atoi(fields[1])) || !(yres = atoi(fields[2])) || !(type = gwy_stramong(fields[3], "SUR", "WFR", "FIL", "THV", "BIR", "CAO", NULL)) || !gwy_strequal(fields[4], "WVL") || (!(wavelength = g_ascii_strtod(fields[5], &end)) && end == fields[5])) { err_FILE_TYPE(error, "Code V INT"); goto fail; } gwy_debug("type %u (%s)", type, fields[3]); gwy_debug("xres %d, yres %d", xres, yres); gwy_debug("wavelength %g", wavelength); fi = 6; if (gwy_strequal(fields[fi], "NNB")) { nearest_neighbour = TRUE; fi++; } gwy_debug("nearest_neighbour %d", nearest_neighbour); if (!fields[fi] || !gwy_strequal(fields[fi], "SSZ")) { err_FILE_TYPE(error, "Code V INT"); goto fail; } fi++; if (!(scale_size = g_ascii_strtod(fields[fi], &end)) && end == fields[fi]) { err_FILE_TYPE(error, "Code V INT"); goto fail; } gwy_debug("scale_size %g", scale_size); if (!scale_size) { g_warning("Zero SSZ, fixing to 1.0"); scale_size = 1.0; } fi++; if (fields[fi] && gwy_strequal(fields[fi], "NDA")) { fi++; if (!fields[fi]) { err_FILE_TYPE(error, "Code V INT"); goto fail; } no_data_value = atoi(fields[fi]); fi++; } gwy_debug("no_data_value %d", no_data_value); if (fields[fi] && gwy_strequal(fields[fi], "XSC")) { fi++; if (!fields[fi]) { err_FILE_TYPE(error, "Code V INT"); goto fail; } if (!(x_scale = g_ascii_strtod(fields[fi], &end)) && end == fields[fi]) { err_FILE_TYPE(error, "Code V INT"); goto fail; } fi++; } gwy_debug("x_scale %g", x_scale); if (!x_scale) { g_warning("Zero XSC, fixing to 1.0"); x_scale = 1.0; } /* There may be more stuff but we do not know anything about it. */ if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres)) goto fail; yreal = 1.0; xreal = x_scale*yreal; dfield = gwy_data_field_new(xres, yres, xreal, yreal, TRUE); if (type == CODEV_INT_SURFACE_DEFORMATION) { q = 1e-6*wavelength/scale_size; unit = "m"; title = "Surface"; } else if (type == CODEV_INT_WAVEFRONT_DEFORMATION) { q = 1e-6*wavelength/scale_size; unit = "m"; title = "Wavefront"; } else { g_warning("Don't know how to convert this grid data type to physical " "units."); title = fields[3]; } gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), unit); mfield = gwy_data_field_new_alike(dfield, TRUE); data = gwy_data_field_get_data(dfield); mdata = gwy_data_field_get_data(mfield); for (i = 0; i < xres*yres; i++, p = end) { gint value = strtol(p, &end, 10); if (value != no_data_value && (type != CODEV_INT_INTENSITY_FILTER || value >= 0)) { mdata[i] = 1.0; data[i] = q*value; } } if (!gwy_app_channel_remove_bad_data(dfield, mfield)) gwy_object_unref(mfield); container = gwy_container_new(); /* gwy_data_field_invert(dfield, TRUE, FALSE, FALSE); from F. Riguet : apparently no flip is needed (the raw data import module gives the correct orientation without further flipping) */ gwy_container_set_object(container, gwy_app_get_data_key_for_id(0), dfield); g_object_unref(dfield); gwy_app_channel_check_nonsquare(container, 0); gwy_container_set_string_by_name(container, "/0/data/title", g_strdup(title)); if (mfield) { /* gwy_data_field_invert(mfield, FALSE, TRUE, FALSE); */ gwy_container_set_object(container, gwy_app_get_mask_key_for_id(0), mfield); g_object_unref(mfield); } meta = gwy_container_new(); gwy_container_set_string_by_name(meta, "Comment", g_strdup(comment)); gwy_container_set_string_by_name(meta, "Interpolation", g_strdup(nearest_neighbour ? "NNB" : "Linear")); gwy_container_set_string_by_name(meta, "Wavelength", g_strdup_printf("%g μm", wavelength)); gwy_container_set_object_by_name(container, "/0/meta", meta); g_object_unref(meta); gwy_file_channel_import_log_add(container, 0, NULL, filename); fail: g_free(fields); g_free(buffer); return container; }
static GwyContainer* zeiss_load_tiff(const GwyTIFF *tiff, GError **error) { GwyContainer *container = NULL, *meta = NULL; GwyDataField *dfield; GwySIUnit *siunit; GwyTIFFImageReader *reader = NULL; GHashTable *hash = NULL; gint i, power10; gchar *value, *end, *comment = NULL; gdouble *data; gboolean new_file; double factor, dx; /* Comment with parameters is common for all data fields */ if (!gwy_tiff_get_string0(tiff, ZEISS_HEADER_TAG, &comment)) { err_FILE_TYPE(error, "Carl Zeiss SEM"); goto fail; } if (strstr(comment, MAGIC_COMMENT)) new_file = TRUE; else if (g_str_has_prefix(comment, SOMEWHAT_LESS_MAGIC_COMMENT)) new_file = FALSE; else { err_FILE_TYPE(error, "Carl Zeiss SEM"); goto fail; } /* Read the comment header. */ if (new_file) { hash = parse_comment(comment); if ((value = g_hash_table_lookup(hash, "Image Pixel Size"))) { gwy_debug("Using dx from Image Pixel Size: %s", value); } else if ((value = g_hash_table_lookup(hash, "Pixel Size"))) { gwy_debug("Using dx from Pixel Size: %s", value); } else { err_MISSING_FIELD(error, "Pixel Size"); goto fail; } } else { /* The first thing is the pixel size, apparently. */ value = comment + strlen(SOMEWHAT_LESS_MAGIC_COMMENT); gwy_debug("Using dx from old-style comment: %s", value); } dx = g_ascii_strtod(value, &end); /* Use negated positive conditions to catch NaNs */ if (!((dx = fabs(dx)) > 0)) { g_warning("Real pixel size is 0.0, fixing to 1.0"); dx = 1.0; } if (!new_file) end = "m"; /* Request a reader, this ensures dimensions and stuff are defined. * NB: Newer versions store the image as RGB. Not useful here; just * average the channels. */ if (!(reader = gwy_tiff_get_image_reader(tiff, 0, 3, error))) goto fail; siunit = gwy_si_unit_new_parse(end, &power10); factor = pow10(power10); dfield = gwy_data_field_new(reader->width, reader->height, reader->width * factor * dx, reader->height * factor * dx, FALSE); gwy_data_field_set_si_unit_xy(dfield, siunit); g_object_unref(siunit); data = gwy_data_field_get_data(dfield); if (reader->samples_per_pixel > 1) { gdouble *datarow = g_new(gdouble, reader->width); gint ch, j, spp = reader->samples_per_pixel; gwy_data_field_clear(dfield); for (i = 0; i < reader->height; i++) { for (ch = 0; ch < spp; ch++) { gwy_tiff_read_image_row(tiff, reader, 0, i, 1.0, 0.0, datarow); for (j = 0; j < reader->width; j++) data[i*reader->width + j] += datarow[j]; } } g_free(datarow); gwy_data_field_multiply(dfield, 1.0/spp); gwy_data_field_invalidate(dfield); } else { for (i = 0; i < reader->height; i++) gwy_tiff_read_image_row(tiff, reader, 0, i, 1.0, 0.0, data + i*reader->width); } 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("Secondary electron count")); if (new_file) { meta = gwy_container_new(); g_hash_table_foreach(hash, add_meta, meta); if (gwy_container_get_n_items(meta)) gwy_container_set_object_by_name(container, "/0/meta", meta); g_object_unref(meta); } fail: if (hash) g_hash_table_destroy(hash); g_free(comment); return container; }
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; gchar *title = NULL; gint dir; 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': case '7': dfield = read_data_field(buffer, size, buffer[2], &title, &dir, 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); if (title) gwy_container_set_string_by_name(container, "/0/data/title", title); else gwy_app_channel_title_fall_back(container, 0); gwy_file_channel_import_log_add(container, 0, NULL, filename); /* TODO: Store direction to metadata, if known */ return container; }
static GwyContainer* shimadzu_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *meta, *container = NULL; GwyDataField *dfield = NULL; GError *err = NULL; gchar *buffer = NULL; GHashTable *hash; gchar *head; gsize size = 0; gboolean ok; gint text_data_start; if (!g_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (size < HEADER_SIZE + 2) { err_TOO_SHORT(error); return NULL; } if (memcmp(buffer, MAGIC, MAGIC_SIZE) != 0 && !(memcmp(buffer, MAGIC_ASCII, MAGIC_ASCII_SIZE) == 0 && (memcmp(buffer + MAGIC_ASCII_SIZE+1, MAGIC, MAGIC_SIZE) == 0 || memcmp(buffer + MAGIC_ASCII_SIZE+2, MAGIC, MAGIC_SIZE) == 0))) { err_FILE_TYPE(error, "Shimadzu"); g_free(buffer); return NULL; } head = g_memdup(buffer, HEADER_SIZE+1); head[HEADER_SIZE] = '\0'; /* text_data_start is set to nonzero if data are text */ hash = read_hash(head, &text_data_start, error); ok = !!hash; if (ok) { if (text_data_start) dfield = read_text_data(buffer, text_data_start, hash, error); else dfield = read_binary_data(buffer, size, hash, error); ok = !!dfield; } if (ok) { GQuark quark; const gchar *title; container = gwy_container_new(); quark = gwy_app_get_data_key_for_id(0); gwy_container_set_object(container, quark, dfield); g_object_unref(dfield); meta = shimadzu_get_metadata(hash); gwy_container_set_object_by_name(container, "/0/meta", meta); g_object_unref(meta); title = g_hash_table_lookup(hash, "Channel"); if (title && *title) gwy_container_set_string_by_name(container, "/0/data/title", g_strdup(title)); else gwy_app_channel_title_fall_back(container, 0); gwy_file_channel_import_log_add(container, 0, NULL, filename); } g_free(head); g_free(buffer); g_hash_table_destroy(hash); return container; }
static GwyContainer* plt_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *container = NULL; GwyDataField *dfield = NULL; GwyTextHeaderParser parser; GwySIUnit *xunit, *yunit, *zunit; gchar *p, *value, *buffer = NULL; GHashTable *hash = NULL; gsize size; GError *err = NULL; G_GNUC_UNUSED gdouble xreal, yreal, zreal; gint i, xres, yres; gdouble *data; if (!g_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); goto fail; } if (strncmp(buffer, MAGIC1, MIN(size, sizeof(MAGIC1)-1))) { err_FILE_TYPE(error, "Nanosurf PLT"); goto fail; } /* Find the first line not starting with '#' */ for (p = buffer; (p - buffer) + 1 < size; p++) { if ((p[0] == '\n' || p[0] == '\r') && (p[1] != '\n' && p[1] != '#')) { break; } } *p = '\0'; p++; gwy_clear(&parser, 1); parser.line_prefix = "#"; parser.key_value_separator = ":"; hash = gwy_text_header_parse(buffer, &parser, NULL, NULL); if (!require_keys(hash, error, "Channel", "Lines", "Points", "XRange", "YRange", "ZRange", NULL)) goto fail; xres = atoi(g_hash_table_lookup(hash, "Points")); yres = atoi(g_hash_table_lookup(hash, "Lines")); if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres)) goto fail; value = g_hash_table_lookup(hash, "XRange"); xreal = g_ascii_strtod(value, &value); xunit = gwy_si_unit_new(value); value = g_hash_table_lookup(hash, "YRange"); yreal = g_ascii_strtod(value, &value); yunit = gwy_si_unit_new(value); value = g_hash_table_lookup(hash, "ZRange"); zreal = g_ascii_strtod(value, &value); zunit = gwy_si_unit_new(value); /* Use negated positive conditions to catch NaNs */ if (!((xreal = fabs(xreal)) > 0)) { g_warning("Real x size is 0.0, fixing to 1.0"); xreal = 1.0; } if (!((yreal = fabs(yreal)) > 0)) { g_warning("Real y size is 0.0, fixing to 1.0"); yreal = 1.0; } if (!gwy_si_unit_equal(xunit, yunit)) g_warning("X and Y units differ, using X"); dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE); gwy_data_field_set_si_unit_xy(dfield, xunit); gwy_data_field_set_si_unit_z(dfield, zunit); g_object_unref(xunit); g_object_unref(yunit); g_object_unref(zunit); data = gwy_data_field_get_data(dfield); value = p; for (i = 0; i < xres*yres; i++) { data[i] = g_ascii_strtod(value, &p); value = p; } container = gwy_container_new(); gwy_container_set_object(container, gwy_app_get_data_key_for_id(0), dfield); g_object_unref(dfield); if ((value = g_hash_table_lookup(hash, "Channel"))) gwy_container_set_string_by_name(container, "/0/data/title", g_strdup(value)); else gwy_app_channel_title_fall_back(container, 0); gwy_file_channel_import_log_add(container, 0, NULL, filename); fail: g_free(buffer); g_hash_table_destroy(hash); return container; }
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 gboolean mprofile_read_header(const guchar *buffer, gsize size, MProFile *mprofile, GError **error) { const guchar *p; guint i; p = buffer; if (size < HEADER_SIZE + 2) { err_TOO_SHORT(error); return FALSE; } get_CHARARRAY(mprofile->magic, &p); if (memcmp(mprofile->magic, MAGIC, MAGIC_SIZE) != 0) { err_FILE_TYPE(error, "MetroPro"); return FALSE; } mprofile->header_format = gwy_get_guint16_be(&p); if (mprofile->header_format != 1) { err_UNSUPPORTED(error, "FormatVersion"); return FALSE; } mprofile->header_size = gwy_get_guint32_be(&p); gwy_debug("header_format: %d, header_size: %d", mprofile->header_format, mprofile->header_size); if (mprofile->header_size < 570) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("File header is too short.")); return FALSE; } if (mprofile->header_size > size) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("File header is larger than file.")); return FALSE; } mprofile->software_type = gwy_get_guint16_be(&p); get_CHARARRAY0(mprofile->software_date, &p); gwy_debug("software_type: %d, software_date: %s", mprofile->software_type, mprofile->software_date); mprofile->version_major = gwy_get_guint16_be(&p); mprofile->version_minor = gwy_get_guint16_be(&p); mprofile->version_micro = gwy_get_guint16_be(&p); gwy_debug("version: %d.%d.%d", mprofile->version_major, mprofile->version_minor, mprofile->version_micro); mprofile->intens_xoff = gwy_get_guint16_be(&p); mprofile->intens_yoff = gwy_get_guint16_be(&p); mprofile->intens_xres = gwy_get_guint16_be(&p); mprofile->intens_yres = gwy_get_guint16_be(&p); gwy_debug("INTENS xres: %d, yres: %d, xoff: %d, yoff: %d", mprofile->intens_xres, mprofile->intens_yres, mprofile->intens_xoff, mprofile->intens_yoff); mprofile->nbuckets = gwy_get_guint16_be(&p); mprofile->intens_range = gwy_get_guint16_be(&p); mprofile->intens_nbytes = gwy_get_guint32_be(&p); gwy_debug("intens_nbytes: %d, expecting: %d", mprofile->intens_nbytes, 2*mprofile->intens_xres*mprofile->intens_yres*mprofile->nbuckets); mprofile->phase_xoff = gwy_get_guint16_be(&p); mprofile->phase_yoff = gwy_get_guint16_be(&p); mprofile->phase_xres = gwy_get_guint16_be(&p); mprofile->phase_yres = gwy_get_guint16_be(&p); gwy_debug("PHASE xres: %d, yres: %d, xoff: %d, yoff: %d", mprofile->phase_xres, mprofile->phase_yres, mprofile->phase_xoff, mprofile->phase_yoff); mprofile->phase_nbytes = gwy_get_guint32_be(&p); gwy_debug("phase_nbytes: %d, expecting: %d", mprofile->phase_nbytes, 4*mprofile->phase_xres*mprofile->phase_yres); mprofile->timestamp = gwy_get_guint32_be(&p); get_CHARARRAY0(mprofile->comment, &p); gwy_debug("comment: %s", mprofile->comment); mprofile->source = gwy_get_guint16_be(&p); mprofile->scale_factor = gwy_get_gfloat_be(&p); mprofile->wavelength_in = gwy_get_gfloat_be(&p); mprofile->numeric_aperture = gwy_get_gfloat_be(&p); mprofile->obliquity_factor = gwy_get_gfloat_be(&p); mprofile->magnification = gwy_get_gfloat_be(&p); mprofile->camera_res = gwy_get_gfloat_be(&p); mprofile->acquire_mode = gwy_get_guint16_be(&p); gwy_debug("acquire_mode: %d", mprofile->acquire_mode); mprofile->intens_avgs = gwy_get_guint16_be(&p); if (!mprofile->intens_avgs) mprofile->intens_avgs = 1; mprofile->pzt_cal = gwy_get_guint16_be(&p); mprofile->pzt_gain_tolerance = gwy_get_guint16_be(&p); mprofile->pzt_gain = gwy_get_guint16_be(&p); mprofile->part_thickness = gwy_get_gfloat_be(&p); mprofile->agc = gwy_get_guint16_be(&p); mprofile->target_range = gwy_get_gfloat_be(&p); p += 2; mprofile->min_mod = gwy_get_guint32_be(&p); mprofile->min_mod_pts = gwy_get_guint32_be(&p); mprofile->phase_res = gwy_get_guint16_be(&p); mprofile->min_area_size = gwy_get_guint32_be(&p); mprofile->discont_action = gwy_get_guint16_be(&p); mprofile->discont_filter = gwy_get_gfloat_be(&p); mprofile->connection_order = gwy_get_guint16_be(&p); mprofile->data_inverted = gwy_get_guint16_be(&p); mprofile->camera_width = gwy_get_guint16_be(&p); mprofile->camera_height = gwy_get_guint16_be(&p); mprofile->system_type = gwy_get_guint16_be(&p); mprofile->system_board = gwy_get_guint16_be(&p); mprofile->system_serial = gwy_get_guint16_be(&p); mprofile->instrument_id = gwy_get_guint16_be(&p); get_CHARARRAY0(mprofile->objective_name, &p); get_CHARARRAY0(mprofile->part_num, &p); gwy_debug("part_num: %s", mprofile->part_num); mprofile->code_vtype = gwy_get_guint16_be(&p); mprofile->phase_avgs = gwy_get_guint16_be(&p); mprofile->subtract_sys_err = gwy_get_guint16_be(&p); p += 16; get_CHARARRAY0(mprofile->part_ser_num, &p); mprofile->refactive_index = gwy_get_gfloat_be(&p); mprofile->remove_tilt_bias = gwy_get_guint16_be(&p); mprofile->remove_fringes = gwy_get_guint16_be(&p); mprofile->max_area_size = gwy_get_guint32_be(&p); mprofile->setup_type = gwy_get_guint16_be(&p); p += 2; mprofile->pre_connect_filter = gwy_get_gfloat_be(&p); mprofile->wavelength2 = gwy_get_gfloat_be(&p); mprofile->wavelength_fold = gwy_get_guint16_be(&p); mprofile->wavelength1 = gwy_get_gfloat_be(&p); mprofile->wavelength3 = gwy_get_gfloat_be(&p); mprofile->wavelength4 = gwy_get_gfloat_be(&p); get_CHARARRAY0(mprofile->wavelength_select, &p); mprofile->fda_res = gwy_get_guint16_be(&p); get_CHARARRAY0(mprofile->scan_description, &p); gwy_debug("scan_description: %s", mprofile->scan_description); mprofile->nfiducials = gwy_get_guint16_be(&p); for (i = 0; i < G_N_ELEMENTS(mprofile->fiducials); i++) mprofile->fiducials[i] = gwy_get_gfloat_be(&p); mprofile->pixel_width = gwy_get_gfloat_be(&p); mprofile->pixel_height = gwy_get_gfloat_be(&p); mprofile->exit_pupil_diam = gwy_get_gfloat_be(&p); mprofile->light_level_pct = gwy_get_gfloat_be(&p); mprofile->coords_state = gwy_get_guint32_be(&p); mprofile->xpos = gwy_get_gfloat_be(&p); mprofile->ypos = gwy_get_gfloat_be(&p); mprofile->zpos = gwy_get_gfloat_be(&p); mprofile->xrot = gwy_get_gfloat_be(&p); mprofile->yrot = gwy_get_gfloat_be(&p); mprofile->zrot = gwy_get_gfloat_be(&p); mprofile->coherence_mode = gwy_get_guint16_be(&p); mprofile->surface_filter = gwy_get_guint16_be(&p); get_CHARARRAY0(mprofile->sys_err_file, &p); get_CHARARRAY0(mprofile->zoom_desc, &p); return TRUE; }
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* gsf_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *container = NULL, *meta = NULL; GwyDataField *dfield = NULL; GwyTextHeaderParser parser; GwySIUnit *unit; guchar *p, *value, *buffer = NULL, *header = NULL; const guchar *datap; GHashTable *hash = NULL; gsize size, expected_size; GError *err = NULL; gdouble xreal, yreal, xoff, yoff; guint i, xres, yres; gdouble *d; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (size < MAGIC_SIZE || memcmp(buffer, MAGIC, MAGIC_SIZE) != 0) { err_FILE_TYPE(error, "Gwyddion Simple Field"); goto fail; } p = buffer + MAGIC_SIZE; datap = memchr(p, '\0', size - (p - buffer)); if (!datap) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("File header is truncated.")); goto fail; } header = g_strdup(p); datap += 4 - ((datap - buffer) % 4); gwy_clear(&parser, 1); parser.key_value_separator = "="; if (!(hash = gwy_text_header_parse(header, &parser, NULL, NULL))) { g_propagate_error(error, err); goto fail; } xres = read_pixel_size(hash, "XRes", error); yres = read_pixel_size(hash, "YRes", error); if (!xres || !yres) goto fail; expected_size = (datap - buffer) + sizeof(gfloat)*xres*yres; if (err_SIZE_MISMATCH(error, expected_size, size, TRUE)) goto fail; xreal = read_real_size(hash, "XReal"); yreal = read_real_size(hash, "YReal"); dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE); xoff = read_real_offset(hash, "XOffset"); yoff = read_real_offset(hash, "YOffset"); gwy_data_field_set_xoffset(dfield, xoff); gwy_data_field_set_yoffset(dfield, yoff); value = g_hash_table_lookup(hash, "XYUnits"); unit = gwy_si_unit_new(value); gwy_data_field_set_si_unit_xy(dfield, unit); g_object_unref(unit); value = g_hash_table_lookup(hash, "ZUnits"); unit = gwy_si_unit_new(value); gwy_data_field_set_si_unit_z(dfield, unit); g_object_unref(unit); d = gwy_data_field_get_data(dfield); for (i = xres*yres; i; i--) *(d++) = gwy_get_gfloat_le(&datap); container = gwy_container_new(); gwy_container_set_object(container, gwy_app_get_data_key_for_id(0), dfield); g_object_unref(dfield); if ((value = g_hash_table_lookup(hash, "Title"))) { /* FIXME: Ensure valid UTF-8 */ gwy_container_set_string_by_name(container, "/0/data/title", g_strdup(value)); } else gwy_app_channel_title_fall_back(container, 0); meta = gwy_container_new(); g_hash_table_foreach(hash, add_meta, meta); if (gwy_container_get_n_items(meta)) gwy_container_set_object_by_name(container, "/0/meta", meta); g_object_unref(meta); gwy_file_channel_import_log_add(container, 0, NULL, filename); fail: gwy_file_abandon_contents(buffer, size, NULL); if (header) g_free(header); if (hash) g_hash_table_destroy(hash); return container; }
static GwyContainer* jpkscan_load_tiff(const gchar *filename, GError **error) { GwyContainer *container = NULL; GwyContainer *meta = NULL; TIFF *tiff; gint ilen; gint jlen; gint idx = 0; gushort bps; gushort photo; gushort planar; gdouble ulen, vlen; tiff = TIFFOpen(filename, "r"); if (!tiff) { /* This can be I/O too, but it's hard to tell the difference. */ err_FILE_TYPE(error, _("JPK scan")); return NULL; } /* sanity check, grid dimensions must be present! */ if (!(tiff_get_custom_double(tiff, JPK_TIFFTAG_Grid_uLength, &ulen) && tiff_get_custom_double(tiff, JPK_TIFFTAG_Grid_vLength, &vlen))) { TIFFClose(tiff); g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("File does not contain grid dimensions.")); return NULL; } container = gwy_container_new(); meta = gwy_container_new(); /* FIXME: I'm unable to meaningfully sort out the metadata to channels, * so each one receives an identical copy of the global metadata now. */ tiff_load_meta(tiff, meta); gwy_debug("ulen: %g vlen: %g", ulen, vlen); do { if (!TIFFGetField(tiff, TIFFTAG_IMAGEWIDTH, &ilen)) { g_warning("Could not get image width, skipping"); continue; } if (!TIFFGetField(tiff, TIFFTAG_IMAGELENGTH, &jlen)) { g_warning("Could not get image length, skipping"); continue; } TIFFGetFieldDefaulted(tiff, TIFFTAG_BITSPERSAMPLE, &bps); if (!TIFFGetField(tiff, TIFFTAG_PHOTOMETRIC, &photo)) { g_warning("Could not get photometric tag, skipping"); continue; } /* we are only interested in 16bit grayscale */ switch (photo) { case PHOTOMETRIC_MINISBLACK: case PHOTOMETRIC_MINISWHITE: if (bps == 16) break; default: continue; } if (TIFFGetField(tiff, TIFFTAG_PLANARCONFIG, &planar) && planar != PLANARCONFIG_CONTIG) { g_warning("Can only handle planar data, skipping"); continue; } tiff_load_channel(tiff, container, meta, idx++, ilen, jlen, ulen, vlen); } while (TIFFReadDirectory(tiff)); TIFFClose(tiff); g_object_unref(meta); return container; }
static gboolean cdffile_load(NetCDF *cdffile, const gchar *filename, GError **error) { GError *err = NULL; const guchar *p; gwy_clear(cdffile, 1); if (!gwy_file_get_contents(filename, &cdffile->buffer, &cdffile->size, &err)) { err_GET_FILE_CONTENTS(error, &err); return FALSE; } if (cdffile->size < 32) { err_TOO_SHORT(error); gwy_file_abandon_contents(cdffile->buffer, cdffile->size, NULL); return FALSE; } p = cdffile->buffer; /* Header */ if (memcmp(p, MAGIC1, MAGIC_SIZE) == 0) cdffile->version = 1; else if (memcmp(p, MAGIC2, MAGIC_SIZE) == 0) cdffile->version = 2; else { err_FILE_TYPE(error, "NetCDF"); gwy_file_abandon_contents(cdffile->buffer, cdffile->size, NULL); return FALSE; } gwy_debug("Header: CDF v%d", (gint)cdffile->version); p += MAGIC_SIZE; /* N Records */ cdffile->nrecs = gwy_get_guint32_be(&p); gwy_debug("nrecs %d", cdffile->nrecs); /* Dimensions */ if (!cdffile_read_dim_array(&cdffile->dims, &cdffile->ndims, cdffile->buffer, cdffile->size, &p, error)) { cdffile_free(cdffile); gwy_file_abandon_contents(cdffile->buffer, cdffile->size, NULL); return FALSE; } /* Global attributes */ if (!cdffile_read_attr_array(&cdffile->attrs, &cdffile->nattrs, cdffile->buffer, cdffile->size, &p, error)) { cdffile_free(cdffile); gwy_file_abandon_contents(cdffile->buffer, cdffile->size, NULL); return FALSE; } /* Variables */ if (!cdffile_read_var_array(&cdffile->vars, &cdffile->nvars, cdffile->version, cdffile->buffer, cdffile->size, &p, error)) { cdffile_free(cdffile); gwy_file_abandon_contents(cdffile->buffer, cdffile->size, NULL); return FALSE; } cdffile->data_start = (gsize)(p - cdffile->buffer); /* Sanity check */ if (!cdffile_validate_vars(cdffile, error)) { cdffile_free(cdffile); gwy_file_abandon_contents(cdffile->buffer, cdffile->size, NULL); return FALSE; } return TRUE; }