static gint xmms_wave_read (xmms_xform_t *xform, xmms_sample_t *buf, gint len, xmms_error_t *error) { xmms_wave_data_t *data; gint ret; g_return_val_if_fail (xform, -1); data = xmms_xform_private_data_get (xform); g_return_val_if_fail (data, -1); ret = xmms_xform_read (xform, (gchar *) buf, len, error); if (ret <= 0) { return ret; } #if G_BYTE_ORDER == G_BIG_ENDIAN if (data->bits_per_sample == 16) { gint16 *s = (gint16 *) buf; gint i; for (i = 0; i < (ret / 2); i++) { s[i] = GINT16_FROM_LE (s[i]); } } #endif return ret; }
static inline guint16 get_short (gchar **p) { gint16 v = * (guint16 *) *p; *p += 2; return GINT16_FROM_LE (v); }
static int convert_stereo_to_mono_s16le(struct xmms_convert_buffers* buf, void **data, int length) { gint16 *output = *data, *input = *data; int i; for (i = 0; i < length / 4; i++) { gint32 tmp; gint16 stmp; tmp = GINT16_FROM_LE(*input); input++; tmp += GINT16_FROM_LE(*input); input++; stmp = tmp / 2; *output++ = GINT16_TO_LE(stmp); } return length / 2; }
static gboolean fill_data_fields(SurfFile *surffile, const guchar *buffer, GError **error) { GwySIUnit *siunit; gdouble *data; guint i, j; surffile->dfield = gwy_data_field_new(surffile->xres, surffile->yres, surffile->xres*surffile->dx, surffile->yres*surffile->dy, FALSE); data = gwy_data_field_get_data(surffile->dfield); switch (surffile->pointsize) { case 16: { const gint16 *row, *d16 = (const gint16*)buffer; for (i = 0; i < surffile->xres; i++) { row = d16 + i*surffile->yres; for (j = 0; j < surffile->yres; j++) *(data++) = GINT16_FROM_LE(row[j]) * surffile->dz; } } break; case 32: { const gint32 *row, *d32 = (const gint32*)buffer; for (i = 0; i < surffile->xres; i++) { row = d32 + i*surffile->yres; for (j = 0; j < surffile->yres; j++) *(data++) = GINT32_FROM_LE(row[j]) * surffile->dz; } } break; default: err_BPP(error, surffile->pointsize); return FALSE; break; } siunit = gwy_si_unit_new("m"); gwy_data_field_set_si_unit_xy(surffile->dfield, siunit); g_object_unref(siunit); siunit = gwy_si_unit_new("m"); gwy_data_field_set_si_unit_z(surffile->dfield, siunit); g_object_unref(siunit); return TRUE; }
static GwyDataField* mif_read_data_field(const MIFImageHeader *image_header, const MIFBlock *block, const guchar *buffer, gsize size, GError **error) { gint xres = image_header->setup.xres; gint yres = image_header->setup.yres; gdouble xreal = image_header->setup.xreal; gdouble yreal = image_header->setup.yreal; gdouble xoff = image_header->setup.xoff; gdouble yoff = image_header->setup.yoff; gdouble q = image_header->configuration.scan_int_to_meter; GwyDataField *dfield; gdouble *data; const gint16 *d16; gint i, j; if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres)) return NULL; if (!block->size || block->offset > size || block->size > size || block->offset + block->size > size) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Image data are outside the file.")); return NULL; } if (err_SIZE_MISMATCH(error, xres*yres*sizeof(gint16), block->size, FALSE)) return NULL; dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE); gwy_data_field_set_xoffset(dfield, xoff); gwy_data_field_set_yoffset(dfield, yoff); data = gwy_data_field_get_data(dfield); d16 = (const gint16*)(buffer + block->offset); gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m"); gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), "m"); // FIXME: Don't know why this factor. It seems to match what MIF spmview // profile reader shows though. q *= 1.0e4; for (i = 0; i < yres; i++) { for (j = 0; j < yres; j++) { data[(yres-1 - i)*xres + j] = q*GINT16_FROM_LE(d16[i*xres + j]); } } return dfield; }
static GwyDataField* rhkspm32_read_data(RHKPage *rhkpage) { GwyDataField *dfield; const guint16 *p; GwySIUnit *siunit; gdouble *data; const gchar *s; gdouble q; gint power10; guint i, j, xres, yres; p = (const guint16*)(rhkpage->buffer + rhkpage->data_offset); xres = rhkpage->xres; yres = rhkpage->yres; // the scales are no longer gurunteed to be positive, // so they must be "fixed" here (to enable spectra) dfield = gwy_data_field_new(xres, yres, xres*fabs(rhkpage->x.scale), yres*fabs(rhkpage->y.scale), FALSE); data = gwy_data_field_get_data(dfield); for (i = 0; i < yres; i++) { for (j = 0; j < xres; j++) data[i*xres + xres-1 - j] = GINT16_FROM_LE(p[i*xres + j]); } siunit = gwy_data_field_get_si_unit_xy(dfield); gwy_si_unit_set_from_string_parse(siunit, rhkpage->x.units, &power10); if (power10) { q = pow10(power10); gwy_data_field_set_xreal(dfield, q*gwy_data_field_get_xreal(dfield)); gwy_data_field_set_yreal(dfield, q*gwy_data_field_get_yreal(dfield)); } siunit = gwy_data_field_get_si_unit_z(dfield); s = rhkpage->z.units; /* Fix some silly units */ if (gwy_strequal(s, "N/sec")) s = "s^-1"; gwy_si_unit_set_from_string_parse(siunit, s, &power10); q = pow10(power10); gwy_data_field_multiply(dfield, q*fabs(rhkpage->z.scale)); gwy_data_field_add(dfield, q*rhkpage->z.offset); return dfield; }
static gboolean read_binary_data(guint res, gdouble *data, const guchar *buffer) { const guint16 *p = (const guint16*)buffer; guint i, j; for (i = 0; i < res*res; i++) { j = (res - 1 - (i % res))*res + i/res; data[j] = GINT16_FROM_LE(p[i]); } return TRUE; }
/* FIXME: We hope Nanoscope files always use little endian, because we only * have seen them on Intel. */ static gboolean read_binary_data(gint n, gdouble *data, gchar *buffer, gint bpp, GError **error) { gint i; gdouble q; q = 1.0/(1 << (8*bpp)); switch (bpp) { case 1: for (i = 0; i < n; i++) data[i] = q*buffer[i]; break; case 2: { gint16 *p = (gint16*)buffer; for (i = 0; i < n; i++) data[i] = q*GINT16_FROM_LE(p[i]); } break; case 4: { gint32 *p = (gint32*)buffer; for (i = 0; i < n; i++) data[i] = q*GINT32_FROM_LE(p[i]); } break; default: err_BPP(error, bpp); return FALSE; break; } return TRUE; }
/** * qmi_utils_read_gint16_from_buffer: * @buffer: a buffer with raw binary data. * @buffer_size: size of @buffer. * @endian: endianness of firmware value; swapped to host byte order if necessary * @out: return location for the read variable. * * Reads a signed 16-bit integer from the buffer. The number in the buffer is * expected to be given in the byte order specified by @endian, and this method * takes care of converting the read value to the proper host endianness. * * The user needs to make sure that at least 2 bytes are available * in the buffer. * * Also note that both @buffer and @buffer_size get updated after the 2 bytes * read. */ void qmi_utils_read_gint16_from_buffer (const guint8 **buffer, guint16 *buffer_size, QmiEndian endian, gint16 *out) { g_assert (out != NULL); g_assert (buffer != NULL); g_assert (buffer_size != NULL); g_assert (*buffer_size >= 2); memcpy (out, &((*buffer)[0]), 2); if (endian == QMI_ENDIAN_BIG) *out = GINT16_FROM_BE (*out); else *out = GINT16_FROM_LE (*out); print_read_bytes_trace ("gint16", &(*buffer)[0], out, 2); *buffer = &((*buffer)[2]); *buffer_size = (*buffer_size) - 2; }
static void read_data_field(GwyDataField *dfield, EZDSection *section) { gdouble *data; gdouble q, z0; guint i, j; gint xres, yres; g_assert(section->data); xres = section->xres; yres = section->yres; gwy_data_field_resample(dfield, xres, yres, GWY_INTERPOLATION_NONE); data = gwy_data_field_get_data(dfield); q = 1 << section->bitdepth; z0 = q/2.0; if (section->bitdepth == 8) { const gchar *p = section->data; for (i = 0; i < yres; i++) { for (j = 0; j < xres; j++) data[i*xres + j] = (p[(yres-1 - i)*xres + j] + z0)/q; } } else if (section->bitdepth == 16) { const gint16 *p = (const gint16*)section->data; for (i = 0; i < yres; i++) { for (j = 0; j < xres; j++) { data[i*xres + j] = GINT16_FROM_LE(p[(yres-1 - i)*xres + j]); data[i*xres + j] = (data[i*xres + j] + z0)/q; } } } else g_warning("Damn! Bit depth %d is not implemented", section->bitdepth); }
static GwyDataField* mif_read_data_field(const MIFImageHeader *image_header, const MIFBlock *block, const guchar *buffer, gsize size, GError **error) { const MIFScanSetup *setup = &image_header->setup; const MIFImageConfiguration *configuration = &image_header->configuration; gint xres = setup->xres; gint yres = setup->yres; gdouble xreal = setup->xreal * image_header->configuration.xcal; gdouble yreal = setup->yreal * image_header->configuration.ycal; gdouble xoff = setup->xoff; gdouble yoff = setup->yoff; gdouble q = configuration->zcal/65536.0; GwyDataField *dfield; gdouble *data, *linecorrdata = NULL; gsize datasize; const gint16 *d16; gint i, j; if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres)) return NULL; if (!block->size || block->offset > size || block->size > size || block->offset + block->size > size) { g_set_error(error, GWY_MODULE_FILE_ERROR, GWY_MODULE_FILE_ERROR_DATA, _("Image data are outside the file.")); return NULL; } datasize = xres*yres*sizeof(gint16); if (err_SIZE_MISMATCH(error, datasize, block->size, FALSE)) return NULL; if (datasize + yres*sizeof(gint16) <= block->size) { gwy_debug("There may be %u correction data after the image.", yres); linecorrdata = g_new(gdouble, yres); d16 = (const gint16*)(buffer + block->offset + datasize); for (i = 0; i < yres; i++) { linecorrdata[i] = pow(2.0, d16[i] - 13); gwy_debug("corr[%u] %g", i, linecorrdata[i]); } } dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE); gwy_data_field_set_xoffset(dfield, xoff); gwy_data_field_set_yoffset(dfield, yoff); data = gwy_data_field_get_data(dfield); d16 = (const gint16*)(buffer + block->offset); gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_xy(dfield), "m"); gwy_si_unit_set_from_string(gwy_data_field_get_si_unit_z(dfield), "m"); // XXX: Don't know why this range. A user got it from DME. Have no idea // why scan_int_to_meter does not appear here. if (!configuration->z_linearized) q *= 15e-6; else q *= 20e-6; for (i = 0; i < yres; i++) { gdouble qi = linecorrdata ? q*linecorrdata[i] : q; for (j = 0; j < yres; j++) { data[(yres-1 - i)*xres + j] = qi*GINT16_FROM_LE(d16[i*xres + j]); } } g_free(linecorrdata); return dfield; }
static GwyDataField* unisoku_read_data_field(const guchar *buffer, gsize size, UnisokuFile *ufile, GError **error) { gint i, n, power10; const gchar *unit; GwyDataField *dfield; GwySIUnit *siunit; gdouble q, pmin, pmax, rmin, rmax; gdouble *data; n = ufile->xres * ufile->yres; if (err_SIZE_MISMATCH(error, n*type_sizes[ufile->data_type], size, FALSE)) return NULL; dfield = gwy_data_field_new(ufile->xres, ufile->yres, fabs((ufile->end_x - ufile->start_x)), fabs((ufile->end_y - ufile->start_y)), FALSE); data = gwy_data_field_get_data(dfield); /* FIXME: what to do when ascii_flag is set? */ switch (ufile->data_type) { case UNISOKU_UINT8: for (i = 0; i < n; i++) data[i] = buffer[i]; break; case UNISOKU_SINT8: for (i = 0; i < n; i++) data[i] = (signed char)buffer[i]; break; case UNISOKU_UINT16: { const guint16 *pdata = (const guint16*)buffer; for (i = 0; i < n; i++) data[i] = GUINT16_FROM_LE(pdata[i]); } break; case UNISOKU_SINT16: { const gint16 *pdata = (const gint16*)buffer; for (i = 0; i < n; i++) data[i] = GINT16_FROM_LE(pdata[i]); } break; case UNISOKU_FLOAT: for (i = 0; i < n; i++) data[i] = gwy_get_gfloat_le(&buffer); break; default: g_return_val_if_reached(NULL); break; } unit = ufile->unit_x; if (!*unit) unit = "nm"; siunit = gwy_si_unit_new_parse(unit, &power10); gwy_data_field_set_si_unit_xy(dfield, siunit); q = pow10((gdouble)power10); gwy_data_field_set_xreal(dfield, q*gwy_data_field_get_xreal(dfield)); gwy_data_field_set_yreal(dfield, q*gwy_data_field_get_yreal(dfield)); g_object_unref(siunit); unit = ufile->unit_z; /* XXX: No fallback yet, just make z unitless */ siunit = gwy_si_unit_new_parse(unit, &power10); gwy_data_field_set_si_unit_z(dfield, siunit); q = pow10((gdouble)power10); pmin = q*ufile->min_z; pmax = q*ufile->max_z; rmin = ufile->min_raw_z; rmax = ufile->max_raw_z; gwy_data_field_multiply(dfield, (pmax - pmin)/(rmax - rmin)); gwy_data_field_add(dfield, (pmin*rmax - pmax*rmin)/(rmax - rmin)); g_object_unref(siunit); return dfield; }
static int convert_stereo_to_mono(void **data, int length, int fmt) { int i; switch (fmt) { case AFMT_U8: { guint8 *output = *data, *input = *data; for (i = 0; i < length / 2; i++) { guint16 tmp; tmp = *input++; tmp += *input++; *output++ = tmp / 2; } } break; case AFMT_S8: { gint8 *output = *data, *input = *data; for (i = 0; i < length / 2; i++) { gint16 tmp; tmp = *input++; tmp += *input++; *output++ = tmp / 2; } } break; case AFMT_U16_LE: { guint16 *output = *data, *input = *data; for (i = 0; i < length / 4; i++) { guint32 tmp; guint16 stmp; tmp = GUINT16_FROM_LE(*input); input++; tmp += GUINT16_FROM_LE(*input); input++; stmp = tmp / 2; *output++ = GUINT16_TO_LE(stmp); } } break; case AFMT_U16_BE: { guint16 *output = *data, *input = *data; for (i = 0; i < length / 4; i++) { guint32 tmp; guint16 stmp; tmp = GUINT16_FROM_BE(*input); input++; tmp += GUINT16_FROM_BE(*input); input++; stmp = tmp / 2; *output++ = GUINT16_TO_BE(stmp); } } break; case AFMT_S16_LE: { gint16 *output = *data, *input = *data; for (i = 0; i < length / 4; i++) { gint32 tmp; gint16 stmp; tmp = GINT16_FROM_LE(*input); input++; tmp += GINT16_FROM_LE(*input); input++; stmp = tmp / 2; *output++ = GINT16_TO_LE(stmp); } } break; case AFMT_S16_BE: { gint16 *output = *data, *input = *data; for (i = 0; i < length / 4; i++) { gint32 tmp; gint16 stmp; tmp = GINT16_FROM_BE(*input); input++; tmp += GINT16_FROM_BE(*input); input++; stmp = tmp / 2; *output++ = GINT16_TO_BE(stmp); } } break; default: g_error("unknown format"); } return length / 2; }
static int loadfile(struct sr_input *in, const char *filename) { struct sr_datafeed_packet packet; struct sr_datafeed_meta meta; struct sr_datafeed_analog analog; struct sr_config *src; struct context *ctx; float fdata[CHUNK_SIZE]; uint64_t sample; int num_samples, chunk_samples, s, c, fd, l; char buf[CHUNK_SIZE]; ctx = in->sdi->priv; /* Send header packet to the session bus. */ std_session_send_df_header(in->sdi, LOG_PREFIX); packet.type = SR_DF_META; packet.payload = &meta; src = sr_config_new(SR_CONF_SAMPLERATE, g_variant_new_uint64(ctx->samplerate)); meta.config = g_slist_append(NULL, src); sr_session_send(in->sdi, &packet); sr_config_free(src); if ((fd = open(filename, O_RDONLY)) == -1) return SR_ERR; lseek(fd, 40, SEEK_SET); l = read(fd, buf, 4); num_samples = GUINT32_FROM_LE((uint32_t)*(buf)); num_samples /= ctx->samplesize / ctx->num_channels; while (TRUE) { if ((l = read(fd, buf, CHUNK_SIZE)) < 1) break; chunk_samples = l / ctx->samplesize / ctx->num_channels; for (s = 0; s < chunk_samples; s++) { for (c = 0; c < ctx->num_channels; c++) { sample = 0; memcpy(&sample, buf + s * ctx->samplesize + c, ctx->samplesize); switch (ctx->samplesize) { case 1: /* 8-bit PCM samples are unsigned. */ fdata[s + c] = (uint8_t)sample / 255.0; break; case 2: fdata[s + c] = GINT16_FROM_LE(sample) / 32767.0; break; case 4: fdata[s + c] = GINT32_FROM_LE(sample) / 65535.0; break; } } } packet.type = SR_DF_ANALOG; packet.payload = &analog; analog.probes = in->sdi->probes; analog.num_samples = chunk_samples; analog.mq = 0; analog.unit = 0; analog.data = fdata; sr_session_send(in->sdi, &packet); } close(fd); packet.type = SR_DF_END; sr_session_send(in->sdi, &packet); return SR_OK; }
static GwyContainer* burleigh_exp_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { GwyContainer *container = NULL; gchar *buffer = NULL; BurleighExpHeader header; gsize size = 0; GError *err = NULL; GwyDataField *dfield; gdouble *data; guint i, n; if (!g_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (size < MIN_FILE_SIZE + 2) { err_TOO_SHORT(error); g_free(buffer); return NULL; } if (!burleigh_exp_read_header(&header, buffer, error)) goto fail; n = header.xres * header.yres; if (header.binary) { if (header.bpp != 16) { err_BPP(error, header.bpp); goto fail; } else if (err_SIZE_MISMATCH(error, header.length + 2*n, size, TRUE)) goto fail; } dfield = gwy_data_field_new(header.xres, header.yres, header.xscale, header.yscale, FALSE); data = gwy_data_field_get_data(dfield); if (header.binary) { const gint16 *d16 = (const gint16*)(buffer + header.length); for (i = 0; i < n; i++) data[i] = GINT16_FROM_LE(d16[i]); } else { gchar *p = buffer + header.length; for (i = 0; i < n; i++) data[i] = strtol(p, &p, 10); } gwy_data_field_multiply(dfield, header.zscale/32768.0); /* Units references released in free_header() */ gwy_data_field_set_si_unit_xy(dfield, header.xyunits); gwy_data_field_set_si_unit_z(dfield, header.zunits); container = gwy_container_new(); gwy_container_set_object(container, gwy_app_get_data_key_for_id(0), dfield); g_object_unref(dfield); gwy_app_channel_title_fall_back(container, 0); gwy_file_channel_import_log_add(container, 0, NULL, filename); fail: free_header(&header); g_free(buffer); return container; }
static GwySpectra* rhkspm32_read_spectra(RHKPage *rhkpage) { guint i, j; gdouble *data; GwySIUnit *siunit = NULL; GwyDataLine *dline; GwySpectra *spectra = NULL; GPtrArray *spectrum = NULL; // i'm leaving this alone, though it probably doesn't make sense, // and i should just create graphs straight away - but in case of // future use, i'll just convert the data later to graphs // xres stores number of data points per spectra, // yres stores the number of spectra // reading data gwy_debug("rhk-spm32: %d spectra in this page\n", rhkpage->yres); for (i = 0; i < rhkpage->yres; i++) { dline = gwy_data_line_new(rhkpage->xres, rhkpage->x.scale, FALSE); gwy_data_line_set_offset(dline, (rhkpage->x.offset)); data = gwy_data_line_get_data(dline); // store line data in physical units - which are the z values, not y if ((rhkpage->data_type) == RHK_DATA_INT16) { const guint16 *p = (const guint16*)(rhkpage->buffer + rhkpage->data_offset); for (j = 0; j < rhkpage->xres; j++) { data[j] = GINT16_FROM_LE(p[i*(rhkpage->xres) + j]) *(rhkpage->z.scale)+(rhkpage->z.offset); } } else if ((rhkpage->data_type) == RHK_DATA_SINGLE) { const guchar *p = (const guchar*)(rhkpage->buffer + rhkpage->data_offset); for (j = 0; j < rhkpage->xres; j++) { data[j] = gwy_get_gfloat_le(&p)*rhkpage->z.scale + rhkpage->z.offset; } } siunit = gwy_si_unit_new(rhkpage->x.units); gwy_data_line_set_si_unit_x(dline, siunit); g_object_unref(siunit); // the y units (and data) for a 1D graph are stored in Z in the rhk // spm32 format! /* Fix "/\xfbHz" to "/Hz". * XXX: It might be still wrong as the strange character might mean * sqrt. */ if (g_str_has_suffix(rhkpage->z.units, "/\xfbHz")) { gchar *s = gwy_strkill(g_strdup(rhkpage->z.units), "\xfb"); siunit = gwy_si_unit_new(s); g_free(s); } else siunit = gwy_si_unit_new(rhkpage->z.units); gwy_data_line_set_si_unit_y(dline, siunit); g_object_unref(siunit); if (!spectrum) spectrum = g_ptr_array_sized_new(rhkpage->yres); g_ptr_array_add(spectrum, dline); } gwy_debug("rhk-spm32: finished parsing sps data\n"); spectra = gwy_spectra_new(); for (i = 0; i < rhkpage->yres; i++) { dline = g_ptr_array_index(spectrum, i); // since RHK spm32 does not record where it took the spectra, // i'm setting these to zero gwy_spectra_add_spectrum(spectra, dline, 0, 0); g_object_unref(dline); } gwy_spectra_set_title(spectra, rhkpage->label); if (spectrum) g_ptr_array_free(spectrum, TRUE); return spectra; }
static void fill_data_fields(SurfFile *surffile, const guchar *buffer) { gdouble *data; guint i, j; surffile->dfield = GWY_DATA_FIELD(gwy_data_field_new(surffile->xres, surffile->yres, surffile->xres*surffile->dx, surffile->yres*surffile->dy, TRUE)); data = gwy_data_field_get_data(surffile->dfield); switch (surffile->pointsize) { case 16: { const gint16 *row, *d16 = (const gint16*)buffer; for (i = 0; i < surffile->xres; i++) { row = d16 + i*surffile->yres; for (j = 0; j < surffile->yres; j++) *(data++) = GINT16_FROM_LE(row[j]) * surffile->dz; } } break; case 32: { const gint32 *row, *d32 = (const gint32*)buffer; for (i = 0; i < surffile->xres; i++) { row = d32 + i*surffile->yres; for (j = 0; j < surffile->yres; j++) *(data++) = GINT32_FROM_LE(row[j]) * surffile->dz; } } break; default: g_warning("Wrong data size: %d", surffile->pointsize); break; } /* data = gwy_data_field_get_data(surffile->dfield); for (i = 0; i < surffile->xres; i++) { for (j = 0; j < surffile->yres; j++) { if (surffile->pointsize == 16) { *(data++) = (gdouble)*(gint16*)buffer*surffile->dz; buffer += 2; } else { *(data++) = ((gdouble)*(gint32*)buffer)*surffile->dz; buffer += 4; } } } */ if (surffile->dx > surffile->dy) gwy_data_field_resample(surffile->dfield, (gint)((gdouble)(surffile->xres)*surffile->dx/surffile->dy), surffile->yres, GWY_INTERPOLATION_BILINEAR); else if (surffile->dy > surffile->dx) gwy_data_field_resample(surffile->dfield, surffile->xres, (gint)((gdouble)(surffile->yres)*surffile->dy/surffile->dx), GWY_INTERPOLATION_BILINEAR); }
static GwyContainer* burleigh_load(const gchar *filename) { GwySIUnit *unit; GwyContainer *container = NULL; guchar *buffer = NULL; const guchar *p; gsize size = 0; GError *err = NULL; IMGFile imgfile; GwyDataField *dfield; gdouble *data; const gint16 *d; gdouble scale; guint i; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { g_warning("Cannot get file contents"); g_clear_error(&err); return NULL; } if (size < HEADER_SIZE_MIN + 2) { g_warning("File is too short"); gwy_file_abandon_contents(buffer, size, NULL); return NULL; } memset(&imgfile, 0, sizeof(imgfile)); p = buffer; imgfile.version = get_FLOAT(&p); imgfile.version_int = ROUND(10*imgfile.version); if (imgfile.version_int == 21) { d = burleigh_load_v21(&imgfile, buffer, size); if (!d) { gwy_file_abandon_contents(buffer, size, NULL); return NULL; } } else { g_warning("File format version %.f is not supported", imgfile.version); gwy_file_abandon_contents(buffer, size, NULL); return NULL; } dfield = GWY_DATA_FIELD(gwy_data_field_new(imgfile.xres, imgfile.yres, Angstrom*imgfile.xrange, Angstrom*imgfile.yrange, FALSE)); data = gwy_data_field_get_data(dfield); scale = Angstrom * imgfile.z_gain * imgfile.zrange; for (i = 0; i < imgfile.xres*imgfile.yres; i++) data[i] = scale * GINT16_FROM_LE(d[i]); gwy_file_abandon_contents(buffer, size, NULL); unit = GWY_SI_UNIT(gwy_si_unit_new("m")); gwy_data_field_set_si_unit_xy(dfield, unit); g_object_unref(unit); container = GWY_CONTAINER(gwy_container_new()); switch (imgfile.data_type) { case BURLEIGH_CURRENT: unit = GWY_SI_UNIT(gwy_si_unit_new("A")); gwy_container_set_string_by_name(container, "/filename/title", g_strdup("Current")); break; case BURLEIGH_TOPOGRAPHY: unit = GWY_SI_UNIT(gwy_si_unit_new("m")); gwy_container_set_string_by_name(container, "/filename/title", g_strdup("Topography")); break; default: unit = GWY_SI_UNIT(gwy_si_unit_new("m")); break; } gwy_data_field_set_si_unit_z(dfield, unit); g_object_unref(unit); gwy_container_set_object_by_name(container, "/0/data", (GObject*)dfield); g_object_unref(dfield); return container; }
static GwyContainer* pni_load(const gchar *filename, G_GNUC_UNUSED GwyRunType mode, GError **error) { static const GwyEnum titles[] = { { "Height", DATA_TYPE_HGT, }, { "Sens", DATA_TYPE_SEN, }, { "Dem", DATA_TYPE_DEM, }, { "Error", DATA_TYPE_ERR, }, { "L-R", DATA_TYPE_L_R, }, }; GwyContainer *container = NULL; guchar *buffer = NULL; gsize size = 0; GError *err = NULL; GwyDataField *dfield = NULL; const guchar *p; gint i, xres, yres; PNIDataType data_type; PNIValueType value_type; PNIDirection direction; gdouble xreal, yreal, zscale; gdouble *data; const gint16 *d16; GwySIUnit *siunit; const gchar *title; gchar *s; if (!gwy_file_get_contents(filename, &buffer, &size, &err)) { err_GET_FILE_CONTENTS(error, &err); return NULL; } if (size < DATA_START + 2) { err_TOO_SHORT(error); gwy_file_abandon_contents(buffer, size, NULL); return NULL; } p = buffer + DATA_HEADER_START + RESOLUTION_OFFSET; xres = gwy_get_guint32_le(&p); yres = gwy_get_guint32_le(&p); gwy_debug("%d %d", xres, yres); if (err_DIMENSION(error, xres) || err_DIMENSION(error, yres) || err_SIZE_MISMATCH(error, DATA_START + 2*xres*yres, size, TRUE)) { gwy_file_abandon_contents(buffer, size, NULL); return NULL; } p = buffer + DATA_HEADER_START; data_type = p[DATA_TYPE_OFFSET]; value_type = p[VALUE_TYPE_OFFSET]; direction = p[DIRECTION_OFFSET]; p = buffer + DATA_HEADER_START + REAL_SIZE_OFFSET; xreal = gwy_get_gfloat_le(&p); yreal = gwy_get_gfloat_le(&p); /* 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; } xreal *= Micrometer; yreal *= Micrometer; p = buffer + DATA_HEADER_START + VALUE_SCALE_OFFSET; zscale = gwy_get_gfloat_le(&p); dfield = gwy_data_field_new(xres, yres, xreal, yreal, FALSE); data = gwy_data_field_get_data(dfield); d16 = (const gint16*)(buffer + DATA_START); for (i = 0; i < xres*yres; i++) data[i] = zscale*GINT16_FROM_LE(d16[i])/65536.0; gwy_file_abandon_contents(buffer, size, NULL); siunit = gwy_si_unit_new("m"); gwy_data_field_set_si_unit_xy(dfield, siunit); g_object_unref(siunit); switch (value_type) { case VALUE_TYPE_NM: siunit = gwy_si_unit_new("m"); gwy_data_field_multiply(dfield, Nanometer); break; case VALUE_TYPE_MV: siunit = gwy_si_unit_new("V"); gwy_data_field_multiply(dfield, Milivolt); break; default: g_warning("Value type %d is unknown", value_type); siunit = gwy_si_unit_new(NULL); break; } 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); g_object_unref(dfield); title = gwy_enum_to_string(data_type, titles, G_N_ELEMENTS(titles)); if (title) { s = g_strdup_printf("%s (%s)", title, direction ? "Forward" : "Backward"); gwy_container_set_string_by_name(container, "/0/data/title", s); } else g_warning("Data type %d is unknown", data_type); gwy_file_channel_import_log_add(container, 0, NULL, filename); 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 GwyDataField* sdfile_read_data_bin(SDFile *sdfile) { gint i, n; GwyDataField *dfield; gdouble *data; const guchar *p; dfield = gwy_data_field_new(sdfile->xres, sdfile->yres, sdfile->xres * sdfile->xscale, sdfile->yres * sdfile->yscale, FALSE); data = gwy_data_field_get_data(dfield); n = sdfile->xres * sdfile->yres; /* We assume Intel byteorder, although the format does not specify * any order. But it was developed in PC context... */ switch (sdfile->data_type) { case SDF_UINT8: for (i = 0; i < n; i++) data[i] = sdfile->data[i]; break; case SDF_SINT8: for (i = 0; i < n; i++) data[i] = (signed char)sdfile->data[i]; break; case SDF_UINT16: { const guint16 *pdata = (const guint16*)(sdfile->data); for (i = 0; i < n; i++) data[i] = GUINT16_FROM_LE(pdata[i]); } break; case SDF_SINT16: { const gint16 *pdata = (const gint16*)(sdfile->data); for (i = 0; i < n; i++) data[i] = GINT16_FROM_LE(pdata[i]); } break; case SDF_UINT32: { const guint32 *pdata = (const guint32*)(sdfile->data); for (i = 0; i < n; i++) data[i] = GUINT32_FROM_LE(pdata[i]); } break; case SDF_SINT32: { const gint32 *pdata = (const gint32*)(sdfile->data); for (i = 0; i < n; i++) data[i] = GINT32_FROM_LE(pdata[i]); } break; case SDF_FLOAT: p = sdfile->data; for (i = 0; i < n; i++) data[i] = gwy_get_gfloat_le(&p); break; case SDF_DOUBLE: p = sdfile->data; for (i = 0; i < n; i++) data[i] = gwy_get_gdouble_le(&p); break; default: g_object_unref(dfield); g_return_val_if_reached(NULL); break; } return dfield; }