tvips-tools-0.0.0/0000755014554002660440000000000012534366730013367 5ustar hattnejgonentvips-tools-0.0.0/tiff2smv.c0000644014554002660440000004061712534366730015303 0ustar hattnejgonen/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * @todo Estimate sample--detector distance from circular solvent * pattern? Or perhaps from the (total) magnification? * * $Id:$ */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include #include #ifdef HAVE_GETOPT_H # include #endif #include #include #include #include #include "frame.h" #include "tvips.h" #include "util.h" struct _tv_path { /* Timestamp of the file */ struct timespec tv; /* Path of the file */ const char *path; }; /* Comparison function for _tv_path structures. Returns an integer * less than, equal to, or greater than zero if the timestamp of the * structure pointed to by the first argument precedes, is identical, * or succeeds the timestamp of the structure pointed to by the second * argument. */ static int _tv_path_compar(const void *a, const void *b) { const struct timespec *ta = &(((struct _tv_path *)a)->tv); const struct timespec *tb = &(((struct _tv_path *)b)->tv); if (ta->tv_sec < tb->tv_sec) return (-1); if (ta->tv_sec > tb->tv_sec) return (+1); if (ta->tv_nsec < tb->tv_nsec) return (-1); if (ta->tv_nsec > tb->tv_nsec) return (+1); return (0); } /* Note that use of __progname is not portable. */ static void usage() { extern char *__progname; fprintf(stderr, "usage: %s " "[-d distance] " "[-g readout_geometry] " "[-k rotation] " "[-o output_template] " "[-r oscillation_speed] " "[-v] " "[-w wavelength] " "[-x beam_center_x] " "[-y beam_center_y] " "[-z timezone] " "file ...\n", __progname); fprintf(stderr, " %s -V\n", __progname); fprintf(stderr, " %s -h\n", __progname); exit(EXIT_FAILURE); } /* See the GNU coding standards for more information on this (and * opinions on how the --help option should have been implemented). */ #define xstr(s) str(s) #define str(s) #s static void version() { extern char *__progname; fprintf(stdout, "%s (TVIPS tools) " xstr(GIT_BRANCH) "." xstr(GIT_COMMIT) "\n", __progname); } int main(int argc, char *argv[]) { float beam_center[2]; FILE *stream; char *ep, *output_dir, *output_path, *path; const char *output_template, *zone; struct frame *frame; struct timespec *tvs; struct _tv_path *tv_path; struct tvips_tiff *handle; size_t j, len, nmemb; double exposure_max, exposure_min, t; float distance, exposure, tilt_rate, wavelength; int flip, g, i, k, k2, verbose; mode_t mode, mode_old; /* Default values for command line options. * * XXX Maybe beam_center should be -f (beam_center_fast) and -s * (beam_center_slow) instead of -x and -y now. And they should * really default to NAN. */ beam_center[0] = 32.1; beam_center[1] = 32.0; distance = 2640.0; g = 5; k = 1; tilt_rate = 0.09; output_template = NULL; verbose = 0; wavelength = NAN; zone = NULL; /* Use getopt_long(3) if available; the POSIX.2 fall-back * getopt(3) is assumed to always be available. optstring begins * with a colon in order to enable tracking of missing option * arguments. */ int ch; const char* optstring = ":Vd:g:hk:o:r:vw:x:y:z:"; #ifdef HAVE_GETOPT_LONG static struct option options[] = { { "version", no_argument, NULL, 'V' }, { "distance", required_argument, NULL, 'd' }, { "readout-geometry", required_argument, NULL, 'g' }, { "help", no_argument, NULL, 'h' }, { "rot90", required_argument, NULL, 'k' }, { "output-template", required_argument, NULL, 'o' }, { "rotation-speed", required_argument, NULL, 'r' }, { "verbose", no_argument, NULL, 'v' }, { "wavelength", required_argument, NULL, 'w' }, { "beam-center-x", required_argument, NULL, 'x' }, { "beam-center-y", required_argument, NULL, 'y' }, { "timezone", required_argument, NULL, 'z' }, { NULL, 0, NULL, 0 } }; #endif /* Loop through all the arguments in argv using either getopt(3) * function. This code does its own error reporting, hence opterr * is set to zero to disable getopt(3) error messages. Because * optreset is an extension to the POSIX.2 specification, it is * not used here. */ opterr = 0; #ifdef HAVE_GETOPT_LONG while ((ch = getopt_long(argc, argv, optstring, options, NULL)) != -1) { #else while ((ch = getopt(argc, argv, optstring)) != -1) { #endif switch (ch) { case 'V': version(); exit(EXIT_SUCCESS); case 'd': errno = 0; distance = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0 || !isfinite(distance)) { warnx("Illegal -d argument %s", optarg); usage(); } break; case 'g': errno = 0; g = strtol(optarg, &ep, 10); if (optarg[0] == '\0' || *ep != '\0' || errno != 0) { warnx("Illegal -g argument %s", optarg); usage(); } break; case 'h': usage(); case 'k': errno = 0; k = strtol(optarg, &ep, 10) % 4; if (optarg[0] == '\0' || *ep != '\0' || errno != 0) { warnx("Illegal -k argument %s", optarg); usage(); } break; case 'o': output_template = optarg; break; case 'r': errno = 0; tilt_rate = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0 || !isfinite(tilt_rate)) { warnx("Illegal -r argument %s", optarg); usage(); } break; case 'v': verbose++; break; case 'w': errno = 0; wavelength = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0 || !isfinite(wavelength)) { warnx("Illegal -w argument %s", optarg); usage(); } break; case 'x': errno = 0; beam_center[1] = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0 || !isfinite(beam_center[1])) { warnx("Illegal -x argument %s", optarg); usage(); } break; case 'y': errno = 0; beam_center[0] = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0 || !isfinite(beam_center[0])) { warnx("Illegal -y argument %s", optarg); usage(); } break; case 'z': zone = optarg; break; case ':': /* Missing the required argument of an option. Use the * last known option character (optopt) for error * reporting. */ #ifdef HAVE_GETOPT_LONG for (i = 0; options[i].name != NULL; i++) { if (options[i].val == optopt) { warnx("Option -%c (--%s) requires an argument", optopt, options[i].name); usage(); } } #endif warnx("Option -%c requires an argument", optopt); usage(); case '?': warnx("Unrecognized option '%s'", argv[optind - 1]); usage(); default: usage(); } } /* If requested, repeat command line options verbatim on standard * output. */ if (verbose > 1) { version(); printf("\n"); for (i = 0; i < optind; i++) { printf("%s%s", argv[i], i + 1 < optind ? " " : "\n"); } printf("\n"); } /* Since the documentation states that at least on image must be * provided exit with failure if there are none. */ if (argc <= optind) return (EXIT_FAILURE); argc -= optind; argv += optind; /* Invert any transformations applied by the camera system, then * apply additional rotations. */ if (tvips_g2fk(g, &flip, &k2) != 0) err(EXIT_FAILURE, "Unsupported ReadoutGeometry %d", g); k += k2; /* First pass to estimate the exposure time, or rather, the time * between two successive frames, in seconds. Would probably want * the standard deviation as well. This assumes frames are * chronologically ordered. */ tv_path = calloc(argc, sizeof(struct _tv_path)); if (tv_path == NULL) err(EXIT_FAILURE, NULL); nmemb = 0; for (i = 0; i < argc; i++) { stream = fopen(argv[i], "r"); if (stream == NULL) { free(tv_path); err(EXIT_FAILURE, "Failed to open %s for reading", argv[i]); } handle = tvips_open_tiff(stream); if (handle == NULL) { fclose(stream); free(tv_path); err(EXIT_FAILURE, "Failed to read %s", argv[i]); } if (tvips_ctime_tiff(handle, zone, &tv_path[i].tv) == 0) tv_path[i].path = argv[i]; else tv_path[i].path = NULL; tvips_close_tiff(handle); fclose(stream); if (tv_path[i].path == NULL) { free(tv_path); err(EXIT_FAILURE, "Failed to extract timestamp from %s", argv[i]); } nmemb += 1; /* If requested, output the canonicalized absolute pathname of * the file just read. */ if (verbose > 2) { path = realpath(argv[i], NULL); if (path != NULL) { printf("%s\n", path); free(path); } } } /* Sort the input files in ascending order by timestamp. * Calculate exposure time and, if requested, report lower and * upper bounds on the time difference between successive frames. * XXX This assumes that successive images are uniformly * distributed in time. */ qsort(tv_path, nmemb, sizeof(struct _tv_path), _tv_path_compar); tvs = calloc(nmemb, sizeof(struct timespec)); if (tvs == NULL) { free(tv_path); err(EXIT_FAILURE, NULL); } for (j = 0; j < nmemb; j++) tvs[j] = tv_path[j].tv; exposure = deltatimef(tvs, nmemb); if (verbose > 0) { exposure_max = exposure_min = 0; for (j = 1; j < nmemb; j++) { t = difftime(tvs[j].tv_sec, tvs[j - 1].tv_sec) + 1e-9 * (tvs[j].tv_nsec - tvs[j - 1].tv_nsec); if (j == 1 || t > exposure_max) exposure_max = t; if (j == 1 || t < exposure_min) exposure_min = t; } printf("Estimated exposure time: %.2f s " "(from %zd timestamp differences in the range [%.2f, %.2f] s)\n", exposure, nmemb > 0 ? nmemb - 1 : 0, exposure_min, exposure_max); } free(tvs); /* Second pass: traverse the input files in ascending order by * timestamp, apply custom alterations based on the superresolved * exposure time estimate, and output. XXX Would be nice with * some verbose printout summarizing how much was written, number * of successes and failures, and so on. */ if (output_template == NULL) return (EXIT_SUCCESS); len = strlen(output_template) + 1; output_dir = calloc(2 * len, sizeof(char)); if (output_dir == NULL) err(EXIT_FAILURE, NULL); output_path = output_dir + len; mode_old = umask(0); mode = 0777 & ~mode_old; umask(mode_old); for (i = 0; i < nmemb; i++) { stream = fopen(tv_path[i].path, "r"); if (stream == NULL) { free(output_dir); free(tv_path); err(EXIT_FAILURE, "Failed to open %s for reading", tv_path[i].path); } handle = tvips_open_tiff(stream); if (handle == NULL) { fclose(stream); free(output_dir); free(tv_path); err(EXIT_FAILURE, "Failed to read %s", tv_path[i].path); } frame = tvips_read_tiff(handle, zone); tvips_close_tiff(handle); fclose(stream); if (frame == NULL) { free(output_dir); free(tv_path); err(EXIT_FAILURE, "Failed to read %s", tv_path[i].path); } if (flip != 0 && frame_flip(frame) != 0) { frame_free(frame); free(output_dir); free(tv_path); err(EXIT_FAILURE, "Failed to flip %s", tv_path[i].path); } if (frame_rot90(frame, k) != 0) { frame_free(frame); free(output_dir); free(tv_path); err(EXIT_FAILURE, "Failed to rotate %s", tv_path[i].path); } /* The oscillation start and range is unknown for the first * frame. */ frame->beam_center[0] = beam_center[0]; frame->beam_center[1] = beam_center[1]; frame->distance = distance; frame->exposure = i == 0 ? NAN : exposure; frame->osc_range = frame->exposure * tilt_rate; frame->osc_start = i * frame->osc_range; if (isfinite(wavelength)) frame->wavelength = wavelength; /* Write the file to the path specified by the output * template, after applying "base zero" sequence number * substitutions and creating any intermediate directories. * mkpath() is always called, because the template may affect * the directories as well as terminal files. Because * dirname(3) may wreck both its input and the output of any * previous invocation, both must be backed up first. */ if (template2path(output_path, output_template, i) != 0) { frame_free(frame); free(output_dir); free(tv_path); err(EXIT_FAILURE, "Failed to create path from template"); } if (argc > 1 && errno == ERANGE && access(output_path, R_OK) != -1) warnx("Template truncated, %s will be overwritten", output_path); memmove(output_dir, dirname(strcpy(output_dir, output_path)), len * sizeof(char)); if (mkpath(output_dir, mode) != 0) { frame_free(frame); free(output_dir); free(tv_path); err(EXIT_FAILURE, "Failed to create intermediate directories"); } stream = fopen(output_path, "w"); if (stream == NULL) { frame_free(frame); free(output_dir); free(tv_path); err(EXIT_FAILURE, "Failed to open %s for writing", output_path); } if (frame_write(frame, stream) != 0) { fclose(stream); frame_free(frame); free(output_dir); free(tv_path); err(EXIT_FAILURE, "Failed to write %s", output_path); } fclose(stream); frame_free(frame); } free(output_dir); free(tv_path); return (EXIT_SUCCESS); } tvips-tools-0.0.0/util.c0000644014554002660440000000712612534366730014516 0ustar hattnejgonen/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include #include #include #include "util.h" /* This recursive implementation is preferred over the iterative * implementation of mkpath() in OpenBSD's mkdir(1) command, because * it avoids hard-coding the directory separator. */ int mkpath(const char *path, mode_t mode) { struct stat sb; char *parent, *path_bak; /* Recursively create non-existent parent directory. Need to back * up path, because dirname(3) may change it. */ path_bak = strdup(path); parent = dirname(path_bak); if (stat(parent, &sb) != 0 && mkpath(parent, mode | S_IWUSR | S_IXUSR) != 0) { free(path_bak); return (-1); } free(path_bak); if (stat(path, &sb) == 0) { if (!S_ISDIR(sb.st_mode)) { /* Path exists, but is not a directory. */ errno = ENOTDIR; return (-1); } } else { /* Create path with requested permissions. */ if (mkdir(path, mode) != 0) return (-1); } /* Ensure terminal directory has the requested file mode. */ if (mode > 0777 && chmod(path, mode) != 0) return (-1); return (0); } int template2path(char *dst, const char *src, size_t seqno) { size_t i, j; int d, ret; /* ret < 0 signifies no substitution has been attempted, ret > 0 * means at least one substitution was truncated. Unless ret == 0 * this function should set errno to ERANGE. */ ret = -1; for (i = 0; src[i] != '\0'; i++) { /* Base case: straight copy from src to dst. */ if (src[i] != '#') { dst[i] = src[i]; continue; } /* Substitution case: determine length of the template, print * a left-justified textual representation of the sequence * number, including the final '\0', into the template field. */ if (ret < 0) ret = 0; for (j = 1; src[i + j] == '#'; j++) ; d = snprintf(dst + i, j + 1, "%zd", seqno); if (d == -1) { return (-1); } else if (d > j) { /* The sequence number did not fit into the field. This * error is not fatal. */ ret = 1; } else if (d < j) { /* The sequence number did not completely fill the field. * Right-justify and zero-pad. */ memmove(dst + i + j - d, dst + i, d); for (d = i + j - d - 1; d >= i; d--) dst[d] = '0'; } i += j - 1; } if (ret != 0) errno = ERANGE; return (0); } tvips-tools-0.0.0/tvips.c0000644014554002660440000000426412534366730014706 0ustar hattnejgonen/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include "tvips.h" /* XXX Only the case g == 5 is actually tested. */ int tvips_g2fk(int g, int *f, int *k) { switch (g) { case 0: *f = 0; *k = 0; return (0); case 1: *f = 1; *k = 0; return (0); case 2: *f = 1; *k = 2; return (0); case 3: *f = 0; *k = 2; return (0); case 4: *f = 0; *k = 3; return (0); case 5: *f = 1; *k = 1; return (0); case 6: *f = 1; *k = 3; return (0); case 7: *f = 0; *k = 1; return (0); case 8: case 12: *f = 0; *k = 2; return (0); case 9: case 13: *f = 1; *k = 2; return (0); case 10: case 14: *f = 1; *k = 0; return (0); case 11: case 15: *f = 0; *k = 0; return (0); case 16: *f = 0; *k = 1; return (0); case 17: *f = 1; *k = 3; return (0); case 18: *f = 1; *k = 1; return (0); case 19: *f = 0; *k = 3; return (0); } errno = EINVAL; return (-1); } tvips-tools-0.0.0/frame.h0000644014554002660440000001451312534366730014636 0ustar hattnejgonen/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef FRAME_H #define FRAME_H 1 #ifdef __cplusplus # define FRAME_BEGIN_C_DECLS extern "C" { # define FRAME_END_C_DECLS } #else # define FRAME_BEGIN_C_DECLS # define FRAME_END_C_DECLS #endif FRAME_BEGIN_C_DECLS /** * @file frame.h * @brief XXX * * XXX */ #include #include #include /** * The frame structure consists of an image: a two-dimensional array, * or raster, of pixel intensities and associated metadata. The * raster is interpreted as row-major: the fast-changing direction is * assumed to run horizontally from left to right, while the * slow-changing direction runs vertically from top to bottom. The * content of this structure mirrors the limitations of the SMV * format. In particular, pixel intensities are represented as 16-bit * unsigned integers and pixels are assumed to be square. */ struct frame { /** * @brief Timestamp, s and ns elapsed since midnight, 1 January * 1970 UTC (Unix time) */ struct timespec tv; /** * @brief The beam center in the horizontal (fast-changing) and * vertical (slow-changing) directions in mm * * Any non-finite value indicates that the beam center in the * given direction is unknown. In MOSFLM and XDS @c BEAM_CENTER_X * and @c BEAM_CENTER_Y define the distance of beam center from * the origin in mm in the slow- and fast-changing directions, * respectively. */ float beam_center[2]; /** * @brief The pixel size in the horizontal (fast-changing) and * vertical (slow-changing) directions in mm * * XXX The SMV format really only supports a 1D-pixel size for * square pixels. */ float pixel_size[2]; /** * @brief The binning factor in the horizontal (fast-changing) and * vertical (slow-changing) directions * * XXX Should probably be one-dimensional, because pixels in SMV * must be square. */ unsigned int binning[2]; /** * @brief Detector identifier as a NULL-terminated string * * XXX This is output as @c DETECTOR_SN. But what is the * analogous item in DM4 and CBF? */ char *id; /** * @brief Image raster in row-major order * * No types other than unsigned 16-bit integers are known to be in * use for SMV. */ uint16_t *raster; /** * @brief Image dimension along the vertical (slow-changing) * direction, in pixels */ size_t height; /** * @brief Image dimension along the horizontal (fast-changing) * direction, in pixels */ size_t width; /** * @brief Sample–detector distance in mm */ float distance; /** * @brief Exposure time in s */ float exposure; /** * @brief Oscillation range in degrees */ float osc_range; /** * @brief Oscillation start in degrees */ float osc_start; /** * @brief Wavelength in Å */ float wavelength; }; /** * @brief Allocate and initialize a new frame structure * * @return A pointer the newly allocated and initialized frame * structure if successful, @c NULL otherwise. The pointer * may subsequently be used as an argument to the function * frame_free(3). */ struct frame * frame_new(); /** * @brief Free a frame structure and all its associated data * * @param frame Pointer to the frame which is to be freed */ void frame_free(struct frame *frame); /** * The frame_flip() function reverses the order of the pixels in each * column of the frame pointed to by @p frame. The transformation is * performed in place. * * @param frame Pointer to the frame whose raster is to be transformed * @return 0 if successful, -1 otherwise. If an error occurs, * the global variable @c errno is set to indicate the * error. */ int frame_flip(struct frame *frame); /** * The frame_rot90() function rotates the raster of the frame pointed * to by @p frame counterclockwise by k * 90 degrees. * The transformation is performed in place. * * @param frame Pointer to the frame whose raster is to be transformed * @param k Number of times the image is rotated by 90 degrees * counterclockwise * @return 0 if successful, -1 otherwise. If an error occurs, * the global variable @c errno is set to indicate the * error. */ int frame_rot90(struct frame *frame, int k); /** * The frame_write() function writes the frame at the location given * by @p frame to the stream pointed to by @p stream in SMV format. * Upon successful completion a value of 0 is returned. Otherwise, a * value of -1 is returned and @c errno is set to: * *
* *
@c EINVAL
The pixels are not square
* *
@c EMSGSIZE
The @c HEADER_BYTES or the @c DATE item * is longer than 512 characters
* *
@c ENOMEM
Not enough space
* *
* * Any other value of @errno is due to output or encoding errors. In * case of error, frame_write() may have changed the stream. * * @param frame Pointer to the location of the frame structure * @param stream Pointer to the output stream * @return 0 if successful, -1 otherwise. If an error occurs, * the global variable @c errno is set to indicate the * error. */ int frame_write(const struct frame *frame, FILE *stream); FRAME_END_C_DECLS #endif /* !FRAME_H */ tvips-tools-0.0.0/frame.c0000644014554002660440000003277512534366730014643 0ustar hattnejgonen/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include #include #include #include #include #include "frame.h" void frame_free(struct frame *frame) { if (frame == NULL) return; if (frame->id != NULL) free(frame->id); if (frame->raster != NULL) free(frame->raster); free(frame); } struct frame * frame_new() { struct frame *frame; frame = malloc(sizeof(struct frame)); if (frame == NULL) return (NULL); frame->tv.tv_sec = 0; frame->tv.tv_nsec = 0; frame->beam_center[0] = NAN; frame->beam_center[1] = NAN; frame->pixel_size[0] = 0; frame->pixel_size[1] = 0; frame->binning[0] = 1; frame->binning[1] = 1; frame->id = NULL; frame->raster = NULL; frame->height = 0; frame->width = 0; frame->distance = 0; frame->exposure = 0; frame->osc_range = 0; frame->osc_start = 0; frame->wavelength = 0; return (frame); } int frame_flip(struct frame *frame) { uint16_t *dst; size_t i, j; dst = calloc(frame->width * frame->height, sizeof(uint16_t)); if (dst == NULL) return (-1); for (i = 0; i < frame->height; i++) { for (j = 0; j < frame->width; j++) { dst[frame->width * (frame->height - 1 - i) + j] = frame->raster[frame->width * i + j]; } } free(frame->raster); frame->raster = dst; return (0); } int frame_rot90(struct frame *frame, int k) { uint16_t *dst; size_t i, j; ssize_t inc, ld, off; /* The row-major source array is always read from left to right, * and from top to bottom. Calculate the increment, the leading * dimension, and the offset for the destination array, just like * in the BLAS code. */ switch (k % 4) { case 0: inc = 1; ld = frame->width; off = 0; break; case -3: case +1: inc = -frame->height; ld = 1; off = frame->height * (frame->width - 1); break; case -2: case +2: inc = -1; ld = -frame->width; off = frame->width * frame->height - 1; break; case -1: case +3: inc = frame->height; ld = -1; off = frame->height - 1; break; default: /* NOTREACHED */ errno = EDOM; return (-1); } /* The copy itself cannot be performed in place, so allocate new * space for the rotated image before copying the data there. * Swap width and height unless rotating an even multiple of 90 * degrees. */ dst = calloc(frame->width * frame->height, sizeof(uint16_t)); if (dst == NULL) return (-1); for (i = 0; i < frame->height; i++) { for (j = 0; j < frame->width; j++) dst[ld * i + inc * j + off] = frame->raster[frame->width * i + j]; } free(frame->raster); frame->raster = dst; if (k % 2 != 0) { i = frame->height; frame->height = frame->width; frame->width = i; } return (0); } /** * The _asncatf() function appends a string to a dynamically allocated * string of size @p size pointed to by @p ret. The string is defined * by @p format and @p ... according to printf(3). The destination * string @p ret is dynamically grown to fit @p format, but at least * by 1024 characters. * * @param ret String to append to. If @p ret is @c NULL, it will * be dynamically allocated. * @param size Length of block allocated for @p ret. This is * ignored if @p ret is @c NULL. * @param format Format string according to printf(3) * @param ... Format arguments according to printf(3) * @return The number of characters written, not including the * trailing @c NULL used to end output to strings. If * an output or encoding error occurs, a value of -1 is * returned. */ static int _asncatf(char **ret, size_t *size, const char *format, ...) { va_list ap; void *p; size_t BLOCKSIZE = 1024, len; int d; /* If called with an empty string, i.e. if *ret is NULL, the first * iteration will allocate an initial block. Because the format * is constant throughout the iteration, the loop is guaranteed to * terminate. */ if (*ret == NULL) len = *size = 0; else len = strlen(*ret); for ( ; ; ) { /* Try to append the formatted string and exit successfully if * all of it fit. */ va_start(ap, format); d = vsnprintf(*ret + len, *size - len, format, ap); va_end(ap); if (d < 0) return (-1); if (d + 1 <= *size - len) return (d); /* Make sure BLOCKSIZE is big enough to accommodate the * overhang on the next iteration. */ if (BLOCKSIZE < d + 1 - (*size - len)) BLOCKSIZE = d + 1 - (*size - len); /* The attempted concatenation resulted in an overhang. Grow * the block and try again. */ p = realloc(*ret, *size + BLOCKSIZE); if (p == NULL) return (-1); *ret = p; *size += BLOCKSIZE; } /* NOTREACHED */ return (-1); } /* In order for the same binary representation to be recreated when * the number is read back, single and double precision real numbers * must be output with 9 and 17 significant decimal digits, * respectively (Kahan, 1997). * * XXX This, together with the corresponding read() function, is maybe * better placed in a separate smv.c file, especially once the * experimental/cbf branch is merged. */ int frame_write(const struct frame *frame, FILE *stream) { float bp[2]; char *buf, *endptr, *header; void *p; struct tm tm; size_t len, size; int d, padding, ret; buf = NULL; header = NULL; size = 0; /* Output the beam center, if known, along the orthogonal axes, * and the binning factors. */ if (isfinite(frame->beam_center[1])) { if (_asncatf(&header, &size, "BEAM_CENTER_X=%-.9g;\n", frame->beam_center[1]) <= 0) { goto exit_error; } } if (isfinite(frame->beam_center[0])) { if (_asncatf(&header, &size, "BEAM_CENTER_Y=%-.9g;\n", frame->beam_center[0]) <= 0) { goto exit_error; } } if (_asncatf(&header, &size, "BIN=%dx%d;\n", frame->binning[1], frame->binning[0]) <= 0) { goto exit_error; } /* The byte order of the output file is always the native byte * order of the host. * * XXX The code below probably only works on GCC-like compilers. * This and other instances should be fixed once the suite is * autoconfiscated. */ #ifdef __BIG_ENDIAN__ if (_asncatf(&header, &size, "BYTE_ORDER=big_endian;\n") <= 0) { goto exit_error; } #else if (_asncatf(&header, &size, "BYTE_ORDER=little_endian;\n") <= 0) { goto exit_error; } #endif /* Write the UTC construction time (again) in "standard" format. * This format is 24 characters long in the standard locale, not * counting the terminating NULL character. Because it may be * longer in different locales, grow the buffer until it fits. If * the date does not fit into a 512-character buffer, fail with * EMSGSIZE. */ if (gmtime_r(&frame->tv.tv_sec, &tm) == NULL) goto exit_error; for (len = 24 + 1; ; len += 24 + 1) { p = realloc(buf, len * sizeof(char)); if (p == NULL) goto exit_error; buf = p; if (strftime(buf, len, "%a %b %e %H:%M:%S %Y", &tm) > 0) break; if (len > 512) { errno = EMSGSIZE; goto exit_error; } } if (_asncatf(&header, &size, "DATE=%s;\n", buf) <= 0) { goto exit_error; } /* DETECTOR_SN is required for imginfo from Global Phasing's * processing tools. MOSFLM breaks if it is set to the empty * string, and iotbx requires it to be either an integer, "None", * or "unknown". */ if (frame->id != NULL && strlen(frame->id) > 0 && strtol(frame->id, &endptr, 10) > 0 && endptr[0] == '\0') { if (_asncatf(&header, &size, "DETECTOR_SN=%s;\n", frame->id) <= 0) { goto exit_error; } } else { if (_asncatf(&header, &size, "DETECTOR_SN=unknown;\n") <= 0) { goto exit_error; } } /* All images contained in a frame structure are two-dimensional. */ if (_asncatf(&header, &size, "DIM=2;\n" "DISTANCE=%-.9g;\n", frame->distance) <= 0) { goto exit_error; } /* Oscillation start and oscillation range. MOSFLM ignores * OSC_START in favor of PHI unless an OSC_AXIS is present, in * which case it reads OSC_START instead of PHI. */ if (_asncatf(&header, &size, "OSC_RANGE=%-.9g;\n" "OSC_START=%-.9g;\n" "PHI=%-.9g;\n", frame->osc_range, frame->osc_start, frame->osc_start) <= 0) { goto exit_error; } /* This at least agrees with dxtbx's idea of width, height, SIZE1 * and SIZE2. */ if (_asncatf(&header, &size, "SIZE1=%zd;\n" "SIZE2=%zd;\n", frame->width, frame->height) <= 0) { goto exit_error; } /* Pixels must be square, to within machine epsilon, or this * function will fail with EINVAL. This implementation is * inspired by Knuth (1997) "The Art of Computer Programming, * Volume 2: Seminumerical Algorithms". */ bp[0] = frame->binning[0] * frame->pixel_size[0]; bp[1] = frame->binning[1] * frame->pixel_size[1]; if (fabs(bp[0] - bp[1]) / (bp[0] < bp[1] ? bp[0] : bp[1]) > FLT_EPSILON) { errno = EINVAL; goto exit_error; } if (_asncatf(&header, &size, "PIXEL_SIZE=%-.9g;\n" "TIME=%-.9g;\n" "WAVELENGTH=%-.9g;\n", bp[0], frame->exposure, frame->wavelength) <= 0) { goto exit_error; } /* The theta-angle is fixed at zero for frame structures. In SMV * parlance, an unsigned_short is 16 bits wide--no other types are * known to be in use. */ if (_asncatf(&header, &size, "TWOTHETA=0;\n" "TYPE=unsigned_short;\n" "}\n") <= 0) { goto exit_error; } /* Construct the HEADER_BYTES item, and fail with EMSGSIZE if it * does not fit into a 512-character buffer. */ d = padding = 0; for ( ; ; ) { /* Write a tentative item and count its length. */ ret = snprintf(buf, len, "{\n" "HEADER_BYTES=%zd;\n", d + strlen(header) + padding); if (ret < 0) goto exit_error; if (ret + 1 <= len) { /* Iterate as long as the length of the output and the * HEADER_BYTES item's contribution differ. */ if (d != ret) { d = ret; continue; } /* It appears MOSFLM requires HEADER_BYTES to be an * integer multiple of 512. Pad if necessary and iterate. */ if ((d + strlen(header) + padding) % 512 != 0) { padding = 512 - (d + strlen(header)) % 512; continue; } break; } /* Grow the buffer as necessary. */ p = realloc(buf, (ret + 1) * sizeof(char)); if (p == NULL) goto exit_error; buf = p; len = ret + 1; if (len > 512) { errno = EMSGSIZE; goto exit_error; } } /* Write the whole caboodle, the HEADER_BYTES item, the header, * the padding, and the data. */ if (fprintf(stream, "%s%s", buf, header) != strlen(buf) + strlen(header)) goto exit_error; if (fprintf(stream, "%*.s", padding, "") != padding) goto exit_error; len = frame->width * frame->height; if (fwrite(frame->raster, sizeof(uint16_t), len, stream) != len) goto exit_error; ret = 0; goto exit_success; exit_error: ret = -1; exit_success: if (buf != NULL) free(buf); if (header != NULL) free(header); return (ret); } tvips-tools-0.0.0/util.h0000644014554002660440000000773512534366730014531 0ustar hattnejgonen/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef UTIL_H #define UTIL_H 1 #ifdef __cplusplus # define UTIL_BEGIN_C_DECLS extern "C" { # define UTIL_END_C_DECLS } #else # define UTIL_BEGIN_C_DECLS # define UTIL_END_C_DECLS #endif UTIL_BEGIN_C_DECLS /** * @file util.h * @brief XXX * * XXX */ #include #include /** * @brief Determine interval of successive time points * * The deltatime() function determines the time difference between the * @p nmemb elements of an array of @c timespec structures. The * elements of the array must be sorted on entry. Assuming the * elements are evenly spaced, the return value is optimal in the * least-squares sense. * * @param base Initial member of an ordered @p nmemb-long array of @c * timespec structures * @param nmemb Length of @p base * @return The time difference between successive elements of @p * base */ double deltatime(const struct timespec *base, size_t nmemb); /** * @copydoc deltatime() */ float deltatimef(const struct timespec *base, size_t nmemb); /** * @brief de Broglie wavelength of an accelerated electron * * The ht2wavelength() function calculates the de Broglie wavelength * of an electron under an accelerating electrostatic potential @p ht. * If @p ht is non-positive, ht2wavelength() returns zero and sets the * global variable @c errno to @c EDOM. * * @param ht High tension, the accelerating potential, in V * @return Wavelength, in m */ double ht2wavelength(double ht); /** * @copydoc ht2wavelength() */ float ht2wavelengthf(float ht); /** * The mkpath() function creates a directory and any intermediate * directories as required. Intermediate directories are always * created with write and search permissions for the owner. * * @param path Path of new, terminal directory * @param mode File mode of terminal directory * @return 0 if successful, -1 otherwise. If an error occurs, the * global variable @c errno is set to indicate the error. */ int mkpath(const char *path, mode_t mode); /** * @brief Copy string with template substitution * * The template2path() function copies a template string, pointed to * by @p src, to @p dst and substitutes all consecutive stretches of * number signs ('#') with a textual representation of @p seqno. If * the length of any such stretch is less than the length of the * textual representation of @p seqno the number is right-truncated. * If truncation occurs or @p src does not contain any characters to * be substituted template2path() stores @c ERANGE in @c errno before * returning successfully. * * @bug @p dst and @p src should probably be declared with the @c * restrict keyword. * * @param dst Pointer to output path string, at least as long as @p * template * @param src Pointer to template path string * @param seqno Non-negative, integer sequence number * @return 0 if successful, -1 otherwise. If an error occurs, * the global variable @c errno is set to indicate the * error. */ int template2path(char *dst, const char *src, size_t seqno); UTIL_END_C_DECLS #endif /* !UTIL_H */ tvips-tools-0.0.0/dm2smv.c0000644014554002660440000013025412534366730014750 0ustar hattnejgonen/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * http://rsb.info.nih.gov/ij/plugins/DM3Format.gj.html * * https://github.com/openmicroscopy/bioformats/blob/v5.0.2/components/formats-gpl/src/loci/formats/in/GatanReader.java */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include #include #include #include #ifdef HAVE_GETOPT_H # include #endif #include #include #include #include #include #include "frame.h" #include "util.h" /* XXX Should probably use an AutoConf macro. * * XXX This is duplication w.r.t. tvips2smv.c. */ #if defined(__linux__) # include #elif defined(__APPLE__) # include # define bswap_16(x) OSSwapInt16(x) # define bswap_32(x) OSSwapInt32(x) #elif defined(__GNUC__) # define bswap_16(x) __builtin_bswap16(x) # define bswap_32(x) __builtin_bswap32(x) #endif enum tag_type { TYPE_SHORT = 2, TYPE_LONG =3, TYPE_USHORT = 4, TYPE_ULONG = 5, TYPE_FLOAT = 6, TYPE_DOUBLE = 7, TYPE_BOOLEAN = 8, TYPE_CHAR = 9, TYPE_OCTET = 10, TYPE_UNK1 = 11, TYPE_UNK2 = 12, TYPE_STRUCT = 15, TYPE_STRING = 18, TYPE_ARRAY = 20 }; /** * The callback function must return 0 on success. The frame * structure is freed using frame_free() when the callback returns. * * XXX This is duplication w.r.t. tvipsread.c. * * @param frame Frame structure * @param counter Image counter, and one-based index that continues * through all the image set files XXX Should have been * zero-based * @param data User data * @return 0 if if successful, non-zero otherwise */ typedef int (*dm_frame_callback)( struct frame *frame, size_t counter, void *data); /* XXX Maybe more aptly named context, or perhaps handle? Could * and/or should stuff the file handle here as well. */ struct state { uint32_t endianness; uint32_t version; size_t level; int image_data_count; size_t ndim; size_t dim[3]; /* Number of pixels in the data raster. */ size_t nmemb; uint16_t *raster; int context; // XXX Should probably have been an enum, and should // probably have been called just "state" /* Pointer to user-supplied callback. */ dm_frame_callback callback; /* Pointer to user-supplied extra data passed to the user-supplied * callback. */ void *userData; }; /* XXX Need a function to free this structure. */ struct dm_entry { char *label; /* Should perhaps have been the type (as an int): 20 for group, 21 * for data. */ int is_data; union { struct dm_group *group; struct tag_aos *data; } content; }; /* XXX Need a function to free this structure. */ struct dm_group { /* The number of entries in this group. */ size_t nmemb; /* The number of entries the group can hold with reallocating the * entries array. */ size_t capacity; struct dm_entry **entries; }; /* the tag_aos structure records an array of structures--the most * general data representation in the Digital Micrograph format. * Structures along the rows. Arranged by type to avoid alignment * issues. */ struct tag_aos { enum tag_type *types; /* Alternatively, and for better typing, could have a pointer to a * list of unions of typed pointers. */ void **values; /* Number of types in the structure, or size (length) of the * structure. This can be thought of as the number of columns. */ size_t size; /* Number of structures in the array. This can be thought of as * the number of rows. */ size_t nmemb; }; /*************** * PRINT STUFF * ***************/ static void print_group(const struct dm_group *group, int indentation); /* Prints the dimension of the AOS, and outputs the data "row major". * Does not print trailing newline. Only prints the ten first * elements. */ static void print_data(const struct tag_aos *data) { size_t i, j, k; printf("%zdx%zd ", data->nmemb, data->size); for (i = 0; i < data->nmemb; i++) { printf("["); for (j = 0; j < data->size; j++) { switch (data->types[j]) { case TYPE_SHORT: printf("%d", ((int16_t *)data->values[j])[i]); break; case TYPE_LONG: printf("%d", ((int32_t *)data->values[j])[i]); break; case TYPE_USHORT: printf("%d", ((uint16_t *)data->values[j])[i]); break; case TYPE_ULONG: printf("%d", ((uint32_t *)data->values[j])[i]); break; case TYPE_FLOAT: printf("%f", ((float *)data->values[j])[i]); break; case TYPE_DOUBLE: printf("%f", ((double *)data->values[j])[i]); break; case TYPE_BOOLEAN: printf("%d", ((int8_t *)data->values[j])[i]); break; case TYPE_CHAR: printf("%c", ((char *)data->values[j])[i]); break; case TYPE_OCTET: printf("%d", ((uint8_t *)data->values[j])[i]); break; case TYPE_UNK1: printf("%d", ((int32_t *)data->values[j])[i]); break; case TYPE_UNK2: printf("%lld", (long long int)((int64_t *)data->values[j])[i]); break; case TYPE_STRUCT: printf("Big trouble in little China #1\n"); break; case TYPE_STRING: printf("Big trouble in little China #2\n"); break; case TYPE_ARRAY: printf("Big trouble in little China #3\n"); break; } if (j + 1 < data->size) printf(", "); /* Early exit if enough elements have been printed and * size of the AOS exceeds the number of elements visited. * Close row if appropriate. */ k = data->size * i + j; if (k >= 10 && data->nmemb * data->size > k) { if (j + 1 < data->size) printf("..."); else printf("], ..."); return; } } if (i + 1 < data->nmemb) printf("], "); else printf("]"); } } static void print_entry(const struct dm_entry *entry, int indentation) { size_t i; for (i = 0; i < indentation; i++) printf(" "); printf("'%s' ", entry->label); if (entry->is_data == 0) { printf("\n"); print_group(entry->content.group, indentation + 2); } else { print_data(entry->content.data); printf("\n"); } } static void print_group(const struct dm_group *group, int indentation) { size_t i; for (i = 0; i < group->nmemb; i++) print_entry(group->entries[i], indentation + 0); } static void free_aos(struct tag_aos *aos) { size_t j; if (aos == NULL) return; if (aos->types != NULL) free(aos->types); if (aos->values != NULL) { for (j = 0; j < aos->size; j++) { if (aos->values[j] != NULL) free(aos->values[j]); } free(aos->values); } free(aos); } static size_t len_of_type(enum tag_type type) { switch (type) { case TYPE_SHORT: return (sizeof(int16_t)); case TYPE_LONG: return sizeof(int32_t); case TYPE_USHORT: return (sizeof(uint16_t)); case TYPE_ULONG: return sizeof(uint32_t); case TYPE_FLOAT: return (sizeof(float)); case TYPE_DOUBLE: return (sizeof(double)); case TYPE_BOOLEAN: return (sizeof(int8_t)); case TYPE_CHAR: return (sizeof(char)); case TYPE_OCTET: return (sizeof(uint8_t)); case TYPE_UNK1: return (sizeof(uint32_t)); case TYPE_UNK2: return (sizeof(uint64_t)); case TYPE_STRUCT: printf("Big trouble in little China #1\n"); return (-1); case TYPE_STRING: printf("Big trouble in little China #2\n"); return (-1); case TYPE_ARRAY: printf("Big trouble in little China #3\n"); return (-1); default: break; } printf("Big trouble in little China #4\n"); return (-1); } /* This should be the only way to create a values structure! XXX * Should handle errno better! size == 0 and/or nmemb == 0 is valid! */ static struct tag_aos* read_value(const enum tag_type *types, size_t size, size_t nmemb, FILE *stream) { struct tag_aos *aos; size_t i, j; aos = calloc(1, sizeof(struct tag_aos)); if (aos == NULL) return (NULL); aos->size = 0; aos->nmemb = 0; aos->types = NULL; aos->values = NULL; if (size <= 0 || nmemb <= 0) return (aos); aos->types = calloc(size, sizeof(enum tag_type)); if (aos->types == NULL) { free_aos(aos); return (NULL); } aos->values = calloc(size, sizeof(void *)); if (aos->values == NULL) { free_aos(aos); return (NULL); } /* Initialize all value pointers to NULL so that free_aos() can * be used to clean up any residual on error. Then allocate space * for all the data. */ for (j = 0; j < size; j++) aos->values[j] = NULL; for (j = 0; j < size; j++) { aos->values[j] = calloc(nmemb, len_of_type(types[j])); if (aos->values[j] == NULL) { free_aos(aos); return (NULL); } } for (i = 0; i < nmemb; i++) { for (j = 0; j < size; j++) { if (fread(aos->values[j] + len_of_type(types[j]) * i, len_of_type(types[j]), 1, stream) != 1) { free_aos(aos); return (NULL); } /* XXX Probably need to deal with endianness here! */ } } /* Copy the two scalars and the array of types. */ aos->size = size; aos->nmemb = nmemb; memcpy(aos->types, types, size * sizeof(enum tag_type)); return (aos); } /* XXX Should include "type" in its name, methinks. */ static int int2enum(uint32_t type_int, enum tag_type *type_enum) { switch (type_int) { case TYPE_SHORT: *type_enum = TYPE_SHORT; return (0); case TYPE_LONG: *type_enum = TYPE_LONG; return (0); case TYPE_USHORT: *type_enum = TYPE_USHORT; return (0); case TYPE_ULONG: *type_enum = TYPE_ULONG; return (0); case TYPE_FLOAT: *type_enum = TYPE_FLOAT; return (0); case TYPE_DOUBLE: *type_enum = TYPE_DOUBLE; return (0); case TYPE_BOOLEAN: *type_enum = TYPE_BOOLEAN; return (0); case TYPE_CHAR: *type_enum = TYPE_CHAR; return (0); case TYPE_OCTET: *type_enum = TYPE_OCTET; return (0); case TYPE_UNK1: *type_enum = TYPE_UNK1; return (0); case TYPE_UNK2: *type_enum = TYPE_UNK2; return (0); case TYPE_STRUCT: *type_enum = TYPE_STRUCT; return (0); case TYPE_STRING: *type_enum = TYPE_STRING; return (0); case TYPE_ARRAY: *type_enum = TYPE_ARRAY; return (0); } return (-1); } /* Expat tXML_StartElementHandler takes another "const XML_Char * **atts" parameter. Now mixing in ideas from neon as well. * * XXX Should have been StartEntryHandler */ typedef int dm_StartGroupHandler(struct state *userData, int parent, const char *name); typedef int dm_EndGroupHandler(struct state *userData, int state, const char *name); /* Expat instead takes arguments "const XML_Char *s, int len". */ //typedef void dm_DataHandler(struct state *state, char *data, size_t len); typedef int dm_DataHandler(struct state *userData, int state, struct tag_aos *data); struct tag_aos * read_tag_type(FILE *stream, struct state *state, void *userData, dm_StartGroupHandler start, dm_DataHandler data, dm_EndGroupHandler end) { char percent[4]; struct tag_aos *aos; enum tag_type *tag_types; size_t j; enum tag_type tag_type; uint32_t len, type, numfields; /* Assert that the four percent signs are present. */ if (fread(percent, sizeof(percent), 1, stream) != 1) return (NULL); if (strncmp(percent, "%%%%", 4) != 0) return (NULL); /* For version 4, skip an additional 4 octets. */ if (fseek(stream, 0 + 4, SEEK_CUR) != 0) return (NULL); /* Determine length of definition of encoded type. */ if (fread(&len, sizeof(len), 1, stream) != 1) return (NULL); len = bswap_32(len); /* For version 4, skip an additional 4 octets. */ if (fseek(stream, 0 + 4, SEEK_CUR) != 0) return (NULL); /* XXX According to the NIH documentation, this block may be * better placed inside the switch statement below. */ if (fread(&type, sizeof(type), 1, stream) != 1) return (NULL); if (int2enum(bswap_32(type), &tag_type) != 0) return (NULL); switch (len) { case 1: /* Simple type. */ aos = read_value(&tag_type, 1, 1, stream); if (aos == NULL) return (NULL); data(state, state->context, aos); return (aos); case 2: /* String. XXX This code path is not checked! */ return (NULL); case 3: /* Array with elements of a single, simple type. */ if (tag_type != TYPE_ARRAY) return (NULL); /* Read the type of the elements in the array as well as its * length. For version 4, skip an additional 4 octets before * and after the type. */ if (fseek(stream, 0 + 4, SEEK_CUR) != 0) return (NULL); if (fread(&type, sizeof(type), 1, stream) != 1) return (NULL); if (int2enum(bswap_32(type), &tag_type) != 0) return (NULL); if (fseek(stream, 0 + 4, SEEK_CUR) != 0) return (NULL); if (fread(&len, sizeof(len), 1, stream) != 1) return (NULL); aos = read_value(&tag_type, 1, bswap_32(len), stream); if (aos == NULL) return (NULL); data(state, state->context, aos); return (aos); default: switch (tag_type) { case TYPE_STRUCT: /* Structure of simple types. This code allocates and * builds a tag_aos structure. XXX And it will leak * memory in case of error, too! It should perhaps be * rolled into its own function? */ if (fseek(stream, 4 + 8, SEEK_CUR) != 0) return (NULL); if (fread(&numfields, sizeof(numfields), 1, stream) != 1) return (NULL); numfields = bswap_32(numfields); if (3 + 2 * numfields != len) return (NULL); if (fseek(stream, 4 + 4, SEEK_CUR) != 0) return (NULL); aos = malloc(sizeof(struct tag_aos)); if (aos == NULL) return (NULL); aos->size = numfields; aos->nmemb = 1; aos->types = calloc(numfields, sizeof(enum tag_type)); if (aos->types == NULL) return (NULL); aos->values = calloc(numfields, sizeof(void *)); if (aos->values == NULL) return (NULL); if (fseek(stream, 4, SEEK_CUR) != 0) return (NULL); for (j = 0; j < numfields; j++) { if (fread(&type, sizeof(type), 1, stream) != 1) return (NULL); if (int2enum(bswap_32(type), &aos->types[j]) != 0) return (NULL); aos->values[j] = malloc(len_of_type(aos->types[j])); if (aos->values[j] == NULL) return (NULL); if (fread(aos->values[j], len_of_type(aos->types[j]), 1, stream) != 1) return (NULL); /* In version 4, entries are aligned on 16-octet * boundaries. */ if (j + 1 < numfields) { if (fseek(stream, 16 - sizeof(type) - len_of_type(aos->types[j]), SEEK_CUR) != 0) return (NULL); } } /* Skip ahead until the next tag is found. The Java * implementation empirically found skips of 4, 8, 12, 18, * 24, or 28 octets to work. The last skip, 36, is to * reach EOF. */ long int offsets[] = {0, 4, 8, 12, 18, 24, 28, 36}; for (j = 0; j < sizeof(offsets) / sizeof(offsets[0]); j++) { int c = fgetc(stream); if (c == 20 || c == 21 || c == EOF) { ungetc(c, stream); data(state, state->context, aos); return (aos); } if (j + 1 < sizeof(offsets) / sizeof(offsets[0])) fseek(stream, offsets[j + 1] - offsets[j] - 1, SEEK_CUR); } return (NULL); case TYPE_ARRAY: /* Array of structures. */ if (fseek(stream, 0 + 4, SEEK_CUR) != 0) return (NULL); if (fread(&type, sizeof(type), 1, stream) != 1) return (NULL); if (int2enum(bswap_32(type), &tag_type) != 0) return (NULL); if (tag_type != TYPE_STRUCT) return (NULL); if (fseek(stream, 4 + 8, SEEK_CUR) != 0) return (NULL); if (fread(&numfields, sizeof(numfields), 1, stream) != 1) return (NULL); numfields = bswap_32(numfields); tag_types = calloc(numfields, sizeof(enum tag_type)); if (tag_types == NULL) return (NULL); if (fseek(stream, 12, SEEK_CUR) != 0) return (NULL); for (j = 0; j < numfields; j++) { if (fread(&type, sizeof(type), 1, stream) != 1) return (NULL); if (int2enum(bswap_32(type), &tag_types[j]) != 0) return (NULL); /* In version 4, entries are aligned on 16-octet * boundaries. */ if (j + 1 < numfields) { if (fseek(stream, 16 - sizeof(type), SEEK_CUR) != 0) return (NULL); } } if (fseek(stream, 0 + 4, SEEK_CUR) != 0) return (NULL); if (fread(&len, sizeof(len), 1, stream) != 1) return (NULL); aos = read_value(tag_types, numfields, bswap_32(len), stream); if (aos == NULL) return (NULL); data(state, state->context, aos); return (aos); default: return (NULL); } } return (NULL); } /* Forward declaration due to hierarchy. */ static struct dm_group * read_tag_group(FILE *stream, struct state *state, void *userData, dm_StartGroupHandler start, dm_DataHandler data, dm_EndGroupHandler end); static struct dm_entry * read_tag_entry(FILE *stream, struct state *state, void *userData, dm_StartGroupHandler start, dm_DataHandler data, dm_EndGroupHandler end) { uint8_t type_length[1 + 2]; uint16_t label_length; struct dm_entry *entry; /* XXX This memory is leaked on failure! */ entry = malloc(sizeof(struct dm_entry)); if (entry == NULL) return (NULL); /* Determine the type of the TagEntry instance, either data or * group, as well as the length of the entry's label. */ if (fread(type_length, sizeof(type_length), 1, stream) != 1) return (NULL); label_length = bswap_16(*(uint16_t *)(type_length + 1)); /* Allocate space for the null-terminated label string, fread(3) * it, and null-terminate it. XXX This memory is leaked! */ entry->label = calloc(label_length + 1, sizeof(char)); if (entry->label == NULL) return (NULL); if (fread(entry->label, sizeof(char), label_length, stream) != label_length) return (NULL); entry->label[label_length] = '\0'; /* For version 4, skip an additional 8 octets. */ if (fseek(stream, 0 + 8, SEEK_CUR) != 0) return (NULL); /* XXX Needs thoughts and comments */ int context_old = state->context; state->context = start(state, state->context, entry->label); if (state->context < 0) { state->context = context_old; return (NULL); // XXX But this is not an error! } switch (type_length[0]) { case 20: /* Tag group */ //printf("Reading group '%s'\n", entry->label); #ifdef DEBUG printf("\n"); #endif entry->is_data = 0; entry->content.group = read_tag_group( stream, state, userData, start, data, end); if (entry->content.group == NULL) return (NULL); end(state, state->context, entry->label); state->context = context_old; // XXX Pop the state, correct? return (entry); case 21: /* Data */ //printf("Reading data '%s'\n", entry->label); entry->is_data = 1; entry->content.data = read_tag_type( stream, state, userData, start, data, end); if (entry->content.data == NULL) return (NULL); end(state, state->context, entry->label); state->context = context_old; // XXX Pop the state, correct? return (entry); default: return (NULL); // XXX NOTREACHED } return (entry); } /* Ordering like in neon, except userdata comes first */ static struct dm_group * read_tag_group(FILE *stream, struct state *state, void *userData, dm_StartGroupHandler start, dm_DataHandler data, dm_EndGroupHandler end) { struct dm_group *group; size_t level; uint32_t numentries; uint8_t sorted_open[2]; /* XXX This memory is leaked on failure! */ group = malloc(sizeof(struct dm_group)); if (group == NULL) return (NULL); /* Determine whether the group is sorted and/or open, only to * subsequently ignore it. For version 4, skip an additional 4 * octets. */ if (fread(sorted_open, sizeof(sorted_open), 1, stream) != 1) return (NULL); if (fseek(stream, 0 + 4, SEEK_CUR) != 0) return (NULL); /* Determine the number of tags in the group, then read all the * TagEntry instances in turn. */ if (fread(&numentries, sizeof(numentries), 1, stream) != 1) return (NULL); group->capacity = bswap_32(numentries); group->entries = calloc(group->capacity, sizeof(struct dm_entry *)); if (group->entries == NULL) return (NULL); level = state->level; for (group->nmemb = 0; group->nmemb < group->capacity; group->nmemb++) { state->level = level + 1; group->entries[group->nmemb] = read_tag_entry( stream, state, userData, start, data, end); state->level = level; if (group->entries[group->nmemb] == NULL) return (NULL); } return (group); } /* XXX It appears there is actually no need to pass around pointers to * these callbacks, as they are fixed. */ static int _start_group_handler(struct state *userData, int parent, const char *name) { /* XXX Should really use parent instead of userData->level and * userData->context. */ int ret; ret = parent; if (userData->level == 1 && strcmp(name, "ImageList") == 0) { fprintf(stderr, "SEE THE IMAGELIST at %zd [%d]\n", userData->level, parent); userData->context = 1; ret = 1; } else if (userData->level == 3 && userData->context == 1 && strcmp(name, "ImageData") == 0) { fprintf(stderr, "SEE THE IMAGEDATA 1 at %zd ctxt %d [%d]\n", userData->level, userData->context, parent); userData->image_data_count += 1; userData->context = 2; ret = 2; } else if (userData->level == 3 && userData->context == 2 && strcmp(name, "ImageData") == 0) { fprintf(stderr, "SEE THE IMAGEDATA 2 at %zd ctxt %d [%d]\n", userData->level, userData->context, parent); userData->context = 2; ret = 2; } else if (userData->level == 4 && userData->context == 2 && userData->image_data_count == 2 && strcmp(name, "Data") == 0) { fprintf(stderr, "SEE THE DATA at %zd ctxt %d [%d]\n", userData->level, userData->context, parent); userData->context = 3; ret = 3; } else if (userData->level == 4 && userData->context == 2 && userData->image_data_count == 2 && strcmp(name, "Dimensions") == 0) { fprintf(stderr, "SEE THE DIMENSIONS at %zd ctxt %d [%d]\n", userData->level, userData->context, parent); userData->context = 4; ret = 4; } else if (strcmp(name, "ImageList") == 0) { printf(" *** see other imagelist ***\n"); } #ifdef DEBUG size_t i; for (i = 1; i < userData->level; i++) printf(" "); printf("'%s'", name); #endif return (ret); } /* XXX Might just as well defer this until the entire file has been * read. */ static int _end_group_handler(struct state *userData, int state, const char *name) { struct frame frame; size_t k; if (strcmp(name, "ImageList") == 0 && userData->ndim >= 2 && userData->nmemb > 0 && userData->raster != NULL) { /* A single 2D image is a stack of one. */ if (userData->ndim == 2) { userData->dim[2] = 1; userData->ndim = 3; } /* XXX Assert that ndim = dim[0] * dim[1] * dim[2]? */ /* XXX This is either stupid or dangerous. Allocating space * for the raster outside the loop assumes the raster will not * be resized by the callback. It's safer, but perhaps a * little bit slower, to allocate and release the entire * contents of the frame structure inside the loop. * * This applies to the callbacks in tvips2smv as well. */ frame.raster = calloc( userData->dim[0] * userData->dim[1], sizeof(uint16_t)); if (frame.raster == NULL) ; // XXX Deal with it! for (k = 0; k < userData->dim[2]; k++) { fprintf(stderr, "Writing image %zd of %zd\n", k + 1, userData->dim[2]); memcpy(frame.raster, userData->raster + k * userData->dim[0] * userData->dim[1], userData->dim[0] * userData->dim[1] * sizeof(uint16_t)); frame.height = userData->dim[1]; frame.width = userData->dim[0]; /* XXX Unhandled stuff. */ frame.tv.tv_sec = 0; frame.tv.tv_nsec = 0; frame.binning[0] = 1; frame.binning[1] = 1; frame.pixel_size[0] = 0.005; // XXX From spec, may be bogus frame.pixel_size[1] = 0.005; if (userData->callback(&frame, k + 1, userData->userData) != 0) ; // XXX Deal with it } free(frame.raster); /* Mark the data as handled. */ free(userData->raster); userData->ndim = 0; userData->nmemb = 0; userData->raster = NULL; } #ifdef DEBUG printf("\n"); #endif return (0); } /* XXX This is a bit clumsy--converting twice, and so on. Given that * there is now knowledge of what to expect, how about parsing on * demand (and byte-skipping otherwise to keep the file pointer * intact)? */ static int _data_handler(struct state *userData, int state, struct tag_aos *aos) { size_t i; switch (userData->context) { case 3: fprintf(stderr, "Will extract the data at %zd ctxt %d [%d] no %d\n", userData->level, userData->context, state, userData->image_data_count); if (aos->size == 1) { fprintf(stderr, " have %zd values type %d\n", aos->nmemb, aos->types[0]); userData->nmemb = aos->nmemb; userData->raster = calloc(userData->nmemb, sizeof(uint16_t)); if (userData->raster == NULL) ; // XXX Error! switch (aos->types[0]) { case TYPE_SHORT: case TYPE_LONG: case TYPE_USHORT: case TYPE_ULONG: /* XXX Implement these */ break; case TYPE_FLOAT: /* Extract data, convert to unsigned 16-bit. XXX The * data (probably) isn't always in floats, and simple * rounding may not be the way! XXX May want to * return with errno set to ERANGE (see * e.g. strtod(3), or EOVERFLOW fread(3)). */ for (i = 0; i < userData->nmemb; i++) { float t = 100.0 * ((float *)aos->values[0])[i]; // XXX ARBITRARY MULTIPLIER! if (t > UINT16_MAX) warn("Overflow %f > %d", t, UINT16_MAX); else if (t < 0) warn("Underflow %f < 0", t); userData->raster[i] = (uint16_t)lrintf(t); } break; case TYPE_DOUBLE: case TYPE_BOOLEAN: case TYPE_CHAR: case TYPE_OCTET: case TYPE_UNK1: case TYPE_UNK2: case TYPE_STRUCT: case TYPE_STRING: case TYPE_ARRAY: /* XXX Implement these */ break; default: break; } } break; case 4: if (aos->size == 1 && aos->nmemb == 1 && aos->types[0] == TYPE_ULONG) { userData->dim[userData->ndim++] = ((uint32_t *)aos->values[0])[0]; fprintf(stderr, " set dim to %d\n", ((uint32_t *)aos->values[0])[0]); } break; } #ifdef DEBUG printf(" "); print_data(aos); #endif return (0); } /* XXX This should probably return some kind of "root group" that * could encapsulate stuff such as version and endianness. Then * REDESIGN: pass the structures as arguments to allow for progressive * parsing later on. */ int read_dm(FILE *stream, dm_frame_callback callback, void *userData) { struct stat sb; struct state st; uint32_t numbytes; /* Get the version number. Can only deal with version 4? Could * probably do something about version 3, if we had an example * file. */ if (fread(&st.version, sizeof(st.version), 1, stream) != 1) return (-1); st.version = bswap_32(st.version); if (st.version != 4) { printf("Unsupported version %d\n", st.version); return (-1); } /* For version 4, skip an additional 4 octets. */ if (fseek(stream, 0 + 4, SEEK_CUR) != 0) return (-1); /* According to the NIH page, this should give the "number of * bytes in the file". * * XXX Does not work for * /groups/gonen/gonenlab/EMdata/MicroED/lysozyme/Lead/K2camera/061814/movie04t30d4s.dm4: * "Empirically mismatching file sizes 1761849110 vs 6056816430". */ if (fread(&numbytes, sizeof(numbytes), 1, stream) != 1) return (-1); numbytes = bswap_32(numbytes); if (fstat(fileno(stream), &sb) != 0) return (-1); #if 0 if (sb.st_size != numbytes + 24) { printf("Empirically mismatching file sizes %d vs %ld\n", numbytes, sb.st_size); return (-1); } #endif /* NIH: Extract byte-ordering: 0 <=> big endian, 1 <=> little * endian. Except, the Java implementation says endianness == 1 * <=> big endian. */ if (fread(&st.endianness, sizeof(st.endianness), 1, stream) != 1) return (-1); st.endianness = bswap_32(st.endianness); if (st.endianness != 0 && st.endianness != 1) { printf("Unsupported endianness %d\n", st.endianness); return (-1); } printf("Extracted endianness %d\n", st.endianness); st.level = 0; st.context = 0; // STATE_ROOT or some such define? st.image_data_count = 0; st.ndim = 0; st.dim[0] = 0; st.dim[1] = 0; st.dim[2] = 0; st.callback = callback; st.userData = userData; if (read_tag_group( stream, &st, NULL, _start_group_handler, _data_handler, _end_group_handler) == NULL) return (-1); if (!feof(stream)) { printf("DIDN'T REACH EOF\n"); return (-1); } return (0); } /* XXX Both the structure and the _frame_write() function below are * copied from tvipsread.c */ struct output { const char *output_template; float beam_center[2]; float distance; double exposure; float tilt_rate; float wavelength; int k; }; static int _frame_write(struct frame *frame, size_t counter, void *data) { struct output *output = (struct output *)data; FILE *stream; char *output_dir, *output_path; mode_t mode, mode_old; /* The counter is one-based, but the arithmetic below is * zero-based. */ if (output->output_template == NULL) return (0); if (counter < 1) return (-1); /* Complete the frame structure with items that are (currently) * not extracted from the file headers but supplied on the command * line. Apply the frame rotation. */ frame->beam_center[0] = output->beam_center[0]; frame->beam_center[1] = output->beam_center[1]; frame->distance = output->distance; frame->exposure = output->exposure; frame->osc_range = output->tilt_rate * output->exposure; frame->osc_start = (counter - 1) * frame->osc_range; frame->wavelength = output->wavelength; if (frame_rot90(frame, output->k) != 0) return (-1); /* Write the file to the path specified by the output template, * after applying "base one" sequence number substitutions and * creating any intermediate directories. mkpath() is always * called, because the template may affect the directories as well * as terminal files. Because dirname(3) may wreck both its input * and the output of any previous invocation, both must be backed * up first. * * XXX This is duplication w.r.t. tiff2smv.c. */ output_dir = calloc( 2 * (strlen(output->output_template) + 1), sizeof(char)); if (output_dir == NULL) return (-1); output_path = output_dir + strlen(output->output_template) + 1; mode_old = umask(0); mode = 0777 & ~mode_old; umask(mode_old); if (template2path(output_path, output->output_template, counter) != 0) { free(output_dir); return (-1); } strcpy(output_dir, dirname(strcpy(output_dir, output_path))); if (mkpath(output_dir, mode) != 0) { free(output_dir); return (-1); } stream = fopen(output_path, "w"); if (stream == NULL) { free(output_dir); return (-1); } if (frame_write(frame, stream) != 0) { free(output_dir); fclose(stream); } fclose(stream); return (0); } /* Note that use of __progname is not portable. * * XXX This is duplication w.r.t. tiff2smv.c. */ static void usage() { extern char *__progname; fprintf(stderr, "usage: %s " "[-d distance] " "[-k rotation] " "[-o output_template] " "[-r oscillation_speed] " "[-v] " "[-x beam_center_x] " "[-y beam_center_y] " "[-z timezone] " "file ...\n", __progname); fprintf(stderr, " %s -V\n", __progname); fprintf(stderr, " %s -h\n", __progname); exit(EXIT_FAILURE); } /* See the GNU coding standards for more information on this (and * opinions on how the --help option should have been implemented). * * XXX This is duplication w.r.t. tiff2smv.c. */ #define xstr(s) str(s) #define str(s) #s static void version() { extern char *__progname; fprintf(stdout, "%s (TVIPS tools) " xstr(GIT_BRANCH) "." xstr(GIT_COMMIT) "\n", __progname); } int main(int argc, char *argv[]) { // const char *path = "/groups/gonen/gonenlab/EMdata/shid/K2-test-movie/2014-06-09_12.22.36_avg.dm4"; // const char *path = "/groups/gonen/gonenlab/EMdata/shid/K2-test-movie/2014-06-09_12.22.36.dm4"; struct output output; FILE *stream; char *ep; size_t i; int verbose; /* Default values for command line options. Beam center and * sample--detector distance in mm, tilt_rate in degrees per * second, and wavelength in Ångström. * * XXX This is duplication w.r.t. tiff2smv.c and tvipsread.c. */ output.beam_center[0] = 10.8; output.beam_center[1] = 8.2; output.distance = 540; // 700.0; output.exposure = 4.0; output.k = 3; output.tilt_rate = 0.09; output.output_template = "dm/test_###.img"; output.wavelength = 0.0191; verbose = 1; /* Use getopt_long(3) if available; the POSIX.2 fall-back * getopt(3) is assumed to always be available. optstring begins * with a colon in order to enable tracking of missing option * arguments. * * XXX Duplication w.r.t. tiff2smv.c! */ int ch; const char* optstring = ":Vd:hk:o:r:x:y:vw:z:"; #ifdef HAVE_GETOPT_LONG static struct option options[] = { { "version", no_argument, NULL, 'V' }, { "distance", required_argument, NULL, 'd' }, { "help", no_argument, NULL, 'h' }, { "rot90", required_argument, NULL, 'k' }, { "output-template", required_argument, NULL, 'o' }, { "rotation-speed", required_argument, NULL, 'r' }, { "verbose", no_argument, NULL, 'v' }, { "wavelength", required_argument, NULL, 'w' }, { "beam-center-x", required_argument, NULL, 'x' }, { "beam-center-y", required_argument, NULL, 'y' }, { "timezone", required_argument, NULL, 'z' }, { NULL, 0, NULL, 0 } }; #endif /* Loop through all the arguments in argv using either getopt(3) * function. This code does its own error reporting, hence opterr * is set to zero to disable getopt(3) error messages. Because * optreset is an extension to the POSIX.2 specification, it is * not used here. * * XXX Duplication w.r.t. tiff2smv.c! */ opterr = 0; #ifdef HAVE_GETOPT_LONG while ((ch = getopt_long(argc, argv, optstring, options, NULL)) != -1) { #else while ((ch = getopt(argc, argv, optstring)) != -1) { #endif switch (ch) { case 'V': version(); exit(EXIT_SUCCESS); case 'd': errno = 0; output.distance = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0) { warnx("Illegal -d argument %s", optarg); usage(); } break; case 'h': usage(); case 'k': errno = 0; output.k = strtol(optarg, &ep, 10) % 4; if (optarg[0] == '\0' || *ep != '\0' || errno != 0) { warnx("Illegal -k argument %s", optarg); usage(); } break; case 'o': output.output_template = optarg; break; case 'r': errno = 0; output.tilt_rate = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0) { warnx("Illegal -r argument %s", optarg); usage(); } break; case 'v': verbose++; break; case 'w': errno = 0; output.wavelength = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0) { warnx("Illegal -w argument %s", optarg); usage(); } break; case 'x': errno = 0; output.beam_center[0] = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0) { warnx("Illegal -x argument %s", optarg); usage(); } break; case 'y': errno = 0; output.beam_center[1] = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0) { warnx("Illegal -y argument %s", optarg); usage(); } break; case 'z': //zone = optarg; // XXX break; case ':': /* Missing the required argument of an option. Use the * last known option character (optopt) for error * reporting. */ #ifdef HAVE_GETOPT_LONG for (i = 0; options[i].name != NULL; i++) { if (options[i].val == optopt) { warnx("Option -%c (--%s) requires an argument", optopt, options[i].name); usage(); } } #endif warnx("Option -%c requires an argument", optopt); usage(); case '?': warnx("Unrecognized option '%s'", argv[optind - 1]); usage(); default: usage(); } } /* If requested, repeat command line options verbatim on standard * output. * * XXX This is duplication w.r.t. tiff2smv.c. */ if (verbose > 1) { version(); printf("\n"); for (i = 0; i < optind; i++) { printf("%s%s", argv[i], i + 1 < optind ? " " : "\n"); } printf("\n"); } /* Since the documentation states that at least on image must be * provided exit with failure if there are none. * * XXX Duplication w.r.t. tiff2smv.c! */ if (argc <= optind) return (EXIT_FAILURE); argc -= optind; argv += optind; /* XXX It really makes no sense to accept more than one input file * on the command line, because the frames will just overwrite * each other! * * If requested, output the canonicalized absolute pathname of the * files just read. This abuses ep. * * XXX This is duplication w.r.t. tiff2smv.c. */ for (i = 0; i < argc; i++) { stream = fopen(argv[i], "r"); if (stream == NULL) err(EXIT_FAILURE, "Failed to open %s", argv[i]); if (read_dm(stream, _frame_write, (void *)&output) != 0) { /* XXX Should have been err(EXIT_FAILURE, ...). */ warn("Failed to read %s", argv[i]); for (i = 0; i < 80; i++) printf("%3d ", fgetc(stream)); printf("\n"); fclose(stream); } fclose(stream); if (verbose > 2) { ep = realpath(argv[i], NULL); if (ep != NULL) { printf("%s\n", ep); free(ep); } } } return (EXIT_SUCCESS); } tvips-tools-0.0.0/tiff2smv.1.xml0000644014554002660440000003101412534366730016007 0ustar hattnejgonen July 28, 2011 tiff2smv 1 General commands (tools and utilities) tiff2smv tiff2smv tvips2smv convert TVIPS TIFF images and TVIPS set files to SMV format tiff2smv -d distance -g readout_geometry -k rotation -o output_template -r oscillation_speed -v -w wavelength -x beam_center_x -y beam_center_y -z timezone file tiff2smv -V tiff2smv -h tvips2smv -d distance -g readout_geometry -k rotation -o output_template -r oscillation_speed -v -w wavelength -x beam_center_x -y beam_center_y -z timezone file tvips2smv -V tvips2smv -h Description The tiff2smv and tvips2smv utilities convert sequences of related diffraction images, or sweeps, to the Super Marty View (SMV) format. tiff2smv supports TIFF images written by either EMMENU or EM_Player, as long as their pixel intensities can be losslessly represented as 16-bit unsigned integers. tvips2smv supports all TVIPS set files written by EMMENU. Output SMV images are directly suitable for further processing in suites such as MOSFLM or XDS. tiff2smv and tvips2smv proceed in two passes: the first pass approximates the exposure time from the metadata in the image sequence; the second pass outputs the corresponding SMV images with tilt angles determined from the estimated exposure time and the tilt rate. It is therefore necessary that images are recorded with constant exposure time and tilt rate (see the option below). If the option is given, tiff2smv and tvips2smv output version information and exit successfully. If the option is given, the utilities output a brief usage summary and exit with status >0. The remaining options are as follows: Set sample–detector distance to distance mm in the output files. Defaults to 2640. The value of the ReadoutGeometry parameter of the camera system used to record the images. The inverse of the transformation implied by readout_geometry is applied before any additional rotations (see the option below). readout_geometry is an integer in the interval [0, 19] with default value 5. Rotate the images counterclockwise by rotation * 90 degrees. rotation is a signed integer with default value 1. This can be used to align the tilt axis to the convention of the downstream processing suite. MOSFLM-like template for output files. Any substring composed solely of number signs ('#') is replaced with a zero-padded string representation of the sequence number of the output image. Intermediate directories are created as required. By default, neither tiff2smv nor tvips2smv output any converted images. The constant tilt rate of the stage in degrees per second. oscillation_speed is a real, signed number with default value 0.09. Verbose operation mode. This option may be repeated for increased effect. Set wavelength to wavelength Å in the output files. By default the value is extracted from the headers in the input files. Intersection point of the direct beam and the planar detector surface, in mm from the first pixel read out. beam_center_x and beam_center_y measure the distances along the slow- and fast-changing directions, respectively after any transformations implied by the and options have been applied. These parameters default to 32.1 and 32.0, respectively. Assume timestamps in input files are recorded in timezone; see the description of TZ below. This can be used to ensure that the absolute timestamp in the output files is correct, limited only by the accuracy of the clock in the device that wrote the input files. Note that timestamps in the output files are always in coordinated universal time (UTC). This option has no effect when using tvips2smv to generate SMV images from TVIPS set files. Unlike TVIPS TIFF files, the set files always record timestamps in UTC. Environment TZ The time zone to use when parsing timestamps in the input TIFF images. See date1 for more information. If the option is not specified and this variable is not set, the local time of the host is used. Exit status The tiff2smv and tvips2smv utilities exit 0 on success, and >0 if an error occurs. See also Tietz Video and Image Processing Systems Private TIFF tag for EMVector 2013 SMV file format, Authors tiff2smv and tvips2smv are developed by the MicroED team in the Gonen lab, Janelia Farm Research Campus microed@hhmi.org. tiff2smv is based on smvtool by Donald J. Olbris. Bugs Input file names must be ordered chronologically. If, as is usually the case, the lexical ordering of the image files reflects their temporal ordering, the shell's wildcard expansion can be used to ensure this is the case. tvips-tools-0.0.0/tiff.c0000644014554002660440000005736312534366730014501 0ustar hattnejgonen/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * XXX Reread all the Libtiff documentation. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include #include #include #include #include #include "tvips.h" #include "util.h" /** * Opaque structure for maintaining I/O state on an mmap(2):d TIFF * stream */ struct tvips_tiff { /* Handle to the TIFF file */ TIFF *tif; /* Location of the mapping */ void *addr; /* Pointer to the TemData structure * * The tem_data member points to read-only mmap(2):d memory, which * may not be modified. */ const uint8_t *tem_data; /* Length of the mapping, in octets * * Since the entire stream is mmap(2):d, this is identical to the * length of the stream. */ size_t len; /* File position indicator, in octets, relative to the start of * the stream */ off_t offset; }; uint32_t tvips_tiff_ftoh32(struct tvips_tiff *handle, const void *file32) { uint32_t host32 = *(uint32_t *)file32; if (TIFFIsByteSwapped(handle->tif) != 0) TIFFSwabLong(&host32); return (host32); } /* XXX This is completely untested! It assumes a complex is a 2-long * array of real numbers. Also, fix up parameter names like in * tiffio.h: *lp for ftoh32, *cp for ftohc, and *fp for ftohf. */ double complex tvips_tiff_ftohc(struct tvips_tiff *handle, const void *filec) { double complex hostc = *(double complex *)filec; if (TIFFIsByteSwapped(handle->tif) != 0) TIFFSwabArrayOfDouble((double *)&hostc, 2); return (hostc); } float tvips_tiff_ftohf(struct tvips_tiff *handle, const void *filef) { float hostf = *(float *)filef; if (TIFFIsByteSwapped(handle->tif) != 0) TIFFSwabFloat(&hostf); return (hostf); } /** * _tiff_close() is a nop: because tvips_open_tiff() does not fopen(3) * the file, it should not fclose(3) it either. */ static int _tiff_close(thandle_t handle) { return (0); } /** * _tiff_mmap() is essentially a nop: because the stream is mmap(2):d * in tvips_open_tiff(), it should also be munmap(2):d there. * _tiff_mmap() just reflects the success of mmap(2) in * tvips_open_tiff(). */ static int _tiff_mmap(thandle_t handle, tdata_t *addr, toff_t *len) { struct tvips_tiff *t = handle; *addr = t->addr; *len = t->len; if (*addr == (void *)-1 || *len <= 0) return (0); return (1); } /** * _tiff_munmap() is a nop: because the stream is mmap(2):d in * tvips_open_tiff(), it should be munmap(2):d in tvips_close_tiff(). */ static void _tiff_munmap(thandle_t handle, tdata_t addr, toff_t len) {} static tsize_t _tiff_read(thandle_t handle, tdata_t ptr, tsize_t size) { struct tvips_tiff *t = handle; if (t->len < t->offset + size) size = t->len - t->offset; if (size > 0) { memcpy(ptr, t->addr + t->offset, size); t->offset += size; } return (size); } /** * _tiff_seek() provides lseek(2)-like behavior on an mmap(2):d * stream. */ static toff_t _tiff_seek(thandle_t handle, toff_t offset, int whence) { struct tvips_tiff *t = handle; switch (whence) { case SEEK_CUR: return (t->offset += offset); case SEEK_END: return (t->offset = t->len - offset); case SEEK_SET: return (t->offset = offset); } errno = EINVAL; return (-1); } static toff_t _tiff_size(thandle_t handle) { struct tvips_tiff *t = handle; return (t->len); } /** * _tiff_write() should never be called for read-only TIFF streams. */ static tsize_t _tiff_write(thandle_t handle, tdata_t ptr, tsize_t size) { return (0); } /** * The _tiff_cpy() function copies the @p w-by-@p l array of pixels * from array @p src to array @p dst. The two buffers cannot overlap. * _tiff_cpy() will only fail if @bps is neither 8 nor 16. * * @note At the price of an increase in complexity, this function * could be enhanced to support signed integer pixels and * indexed images (i.e. images with a palette) as well. * * @param w Width of block * @param l Length of block * @param bps Bits per sample, either 8 or 16 * @param dst Pointer to destination array of 16-bit, unsigned integer * type * @param ldd Leading dimension of @p dst * @param src Pointer to source array of unsigned integer type * @param lds Leading dimension of @p src * @return The original value of @p dst if successful, @c NULL * otherwise */ static uint16_t * _tiff_cpy(uint32 w, uint32 l, uint16 bps, uint16_t *dst, int32 ldd, const void *src, uint32 lds) { uint32 i, j; switch (bps) { case 8: /* This code path is exercised by cramps.tif and * cramps-tile.tif. */ for (i = 0; i < l; i++) { for (j = 0; j < w; j++) dst[ldd * i + j] = ((const uint8 *)src)[lds * i + j]; } return (dst); case 16: /* This code path is exercised by ladoga.tif and * ladoga-tile.tif. */ for (i = 0; i < l; i++) { for (j = 0; j < w; j++) dst[ldd * i + j] = ((const uint16 *)src)[lds * i + j]; } return (dst); } return (NULL); } /** * The _tiff_raster() function asserts that image encoded in the TIFF * file pointed to by @p tif satisfies the constraints of the * implementation and returns a pointer to the decoded raster. Sets * @c errno to @c ENOTSUP if the image is not supported. Must have a * single image with one sample per pixel, either 8 or 16 unsigned * bits per pixel. This represents the subset of TVIPS TIFF images * that can be losslessly represented as SMV. * * @note EMMENU prior to version XXX (not yet released) does not set * the standard SAMPLEFORMAT TIFF tag properly. These images * have TIFFTAG_SAMPLEFORMAT == SAMPLEFORMAT_UINT even when the * raster is composed of signed integers. The data_type item in * the TVIPS dictionary appears to be correct. * * @param[in] tif Handle to the TIFF file * @param[out] w Width of the image, in pixels * @param[out] l Length of the image, in pixels * @param[out] bps Bits per sample, either 8 or 16 * @return Decoded raster, pass to free(3) */ static uint16_t * _tiff_raster(TIFF *tif, uint32 *w, uint32 *l, uint16 *bps) { uint16_t *raster; tdata_t src_data; tsize_t src_size; uint32 d, i, j, tl, tw; uint16 cfg, spp, sf, pm; raster = NULL; src_data = NULL; if (TIFFGetFieldDefaulted( tif, TIFFTAG_BITSPERSAMPLE, bps) == 0 || ( *bps != 8 && *bps != 16) || TIFFGetFieldDefaulted( tif, TIFFTAG_SAMPLEFORMAT, &sf) == 0 || ( sf != SAMPLEFORMAT_UINT && sf != SAMPLEFORMAT_VOID) || TIFFGetFieldDefaulted( tif, TIFFTAG_SAMPLESPERPIXEL, &spp) == 0 || ( spp != 1)) { errno = ENOTSUP; return (NULL); } if (TIFFGetFieldDefaulted( tif, TIFFTAG_IMAGEDEPTH, &d) == 0 || ( d != 1) || TIFFGetFieldDefaulted( tif, TIFFTAG_IMAGELENGTH, l) == 0 || TIFFGetFieldDefaulted( tif, TIFFTAG_IMAGEWIDTH, w) == 0) { errno = ENOTSUP; return (NULL); } if (TIFFGetFieldDefaulted( tif, TIFFTAG_PHOTOMETRIC, &pm) == 0 || ( pm != PHOTOMETRIC_MINISBLACK && pm != PHOTOMETRIC_MINISWHITE) || TIFFGetFieldDefaulted( tif, TIFFTAG_PLANARCONFIG, &cfg) == 0) { errno = ENOTSUP; return (NULL); } raster = calloc(*w * *l, sizeof(uint16_t)); if (raster == NULL) return (NULL); if (TIFFIsTiled(tif) == 0) { /* Striped image: read strips for sample 0 row by row, and * copy all the rows in the strip to the raster while * converting each sample on the fly. */ src_size = TIFFStripSize(tif); src_data = _TIFFmalloc(src_size); if (src_data == NULL) { free(raster); return (NULL); } for (i = 0; i < *l; i += src_size / (*bps * *w / 8)) { src_size = TIFFReadEncodedStrip( tif, TIFFComputeStrip(tif, i, 0), src_data, -1); if (src_size == -1) { _TIFFfree(src_data); free(raster); return (NULL); } _tiff_cpy( *w, src_size / (*bps * *w / 8), *bps, raster + *w * i, *w, src_data, *w); } } else { /* Tiled image: traverse the raster tile by tile and copy the * tiles while converting each sample on the fly. */ if (TIFFGetFieldDefaulted( tif, TIFFTAG_TILELENGTH, &tl) == 0 || TIFFGetFieldDefaulted( tif, TIFFTAG_TILEWIDTH, &tw) == 0) { free(raster); return (NULL); } src_size = TIFFTileSize(tif); src_data = _TIFFmalloc(src_size); if (src_data == NULL) { free(raster); return (NULL); } for (i = 0; i < *l; i += tl) { for (j = 0; j < *w; j += tw) { src_size = TIFFReadEncodedTile( tif, TIFFComputeTile(tif, j, i, 0, 0), src_data, -1); if (src_size == -1) { _TIFFfree(src_data); free(raster); return (NULL); } _tiff_cpy( tw < *w - j ? tw : *w - j, tl < *l - i ? tl : *l - i, *bps, raster + *w * i + j, *w, src_data, tw); } } } _TIFFfree(src_data); return (raster); } const uint8_t * tvips_tem_data_tiff(struct tvips_tiff *handle) { return (handle->tem_data); } /* The _tiff_utf162ascii() losslessly converts a UTF-16-string to a * null-terminated ASCII string. The function allocates sufficient * memory for a copy of the nearest ASCII-equivalent of the string * pointed to by @p s, does the conversion, and returns a a pointer to * it. The pointer may subsequently be used as an argument to the * function free(3). If insufficient memory is available, NULL is * returned. * * XXX What about wctob(3)? * * @param s Pointer to an UTF-16 string * @param len Length of @p s in octets * @return Null-terminated nearest ASCII-equivalent of @p s */ static char * _tiff_utf162ascii(const void *s, size_t len) { char *ascii; size_t i; ascii = calloc(len / 2 + 1, sizeof(char)); if (ascii == NULL) return (NULL); for (i = 0; i < len / 2; i++) ascii[i] = ((uint16_t *)s)[i] & 0x7f; ascii[len / 2] = '\0'; return (ascii); } /* Read the TemData structure and set errno to ENOMSG on failure. The * custom TVIPS tags should be automatically read by Libtiff 3.6.0 and * later. * * Stuff visible in the EM_Player software on windows, for a * TemCam-F416, 4kx4k camera (but this is configurable from EMMENU4?): * * Version 2 * Bits/Pixel 16 * HT [kV] 200 * MagTotal 2621 * Pixelsize [nm] 15600 * X Offset 0 * Y Offset 0 * X Dimension 2048 * Y Dimension 2048 * X Binning 2 * Y Binning 2 */ struct tvips_tiff * tvips_open_tiff(FILE *stream) { struct stat sb; TIFFErrorHandler error_old, warning_old; struct tvips_tiff *handle; uint32_t *offset; uint32_t count, version; int fd; /* Allocate and initialize a new tvips_tiff structure such that * tvips_close_tiff() can be called at any point from now. */ handle = malloc(sizeof(struct tvips_tiff)); if (handle == NULL) return (NULL); handle->tif = NULL; handle->addr = NULL; handle->tem_data = NULL; handle->len = 0; handle->offset = 0; /* Just like the default Unix implementation in Libtiff, mmap(2) * the entire stream. */ fd = fileno(stream); if (fstat(fd, &sb) != 0) { tvips_close_tiff(handle); return (NULL); } handle->offset = 0; handle->len = sb.st_size; handle->addr = mmap( NULL, handle->len, PROT_READ, MAP_SHARED, fd, 0); if (handle->addr == (void *)-1) { tvips_close_tiff(handle); return (NULL); } /* Disable errors and warnings while invoking TIFFClientOpen(), as * the former are communicated through errno. Passing NULL as the * file name will cause TIFFClientOpen() to crash. */ error_old = TIFFSetErrorHandler(NULL); warning_old = TIFFSetWarningHandler(NULL); handle->tif = TIFFClientOpen("", "r", handle, _tiff_read, _tiff_write, _tiff_seek, _tiff_close, _tiff_size, _tiff_mmap, _tiff_munmap); TIFFSetWarningHandler(warning_old); TIFFSetErrorHandler(error_old); if (handle->tif == NULL) { tvips_close_tiff(handle); errno = EPROTO; return (NULL); } /* Read the TemData structure using the new tag, which is provided * by EMMENU 4.0.9.25 (October 2012) and later. */ if (TIFFGetField(handle->tif, 37708, &count, &handle->tem_data) == 1) { version = tvips_tiff_ftoh32(handle, &handle->tem_data[0]); if ((version == 1 && count != 244) || (version == 2 && count != 6312)) { tvips_close_tiff(handle); errno = ENOMSG; return (NULL); } return (handle); } /* Get the value of the old tag, which is the file offset to the * TemData structure. */ if (TIFFGetField( handle->tif, 37706, &count, &offset) == 1 && count == 1) { handle->tem_data = handle->addr + *offset; return (handle); } /* Disable to test non-TVIPS TIFF images. */ tvips_close_tiff(handle); errno = ENOMSG; return (NULL); } void tvips_close_tiff(struct tvips_tiff *handle) { TIFFErrorHandler error_old, warning_old; if (handle == NULL) return; if (handle->tif != NULL) { error_old = TIFFSetErrorHandler(NULL); warning_old = TIFFSetWarningHandler(NULL); TIFFClose(handle->tif); TIFFSetWarningHandler(warning_old); TIFFSetErrorHandler(error_old); } if (handle->addr != (void *)-1 && handle->len > 0) munmap(handle->addr, handle->len); free(handle); } int tvips_ctime_tiff( struct tvips_tiff *handle, const char *zone, struct timespec *tv) { struct tm tm; const char *zone_old; time_t clock; uint32 tem_date, tem_time; int ret; /* If requested, temporarily adjust the timezone to match the zone * where the image was written. According to Peter Sparlinek, the * timestamp is nowadays always recorded in localtime. */ if (zone != NULL) { zone_old = getenv("TZ"); if (setenv("TZ", zone, 1) != 0) return (-1); tzset(); } ret = 0; switch (tvips_tiff_ftoh32(handle, &handle->tem_data[0])) { case 1: /* Round-trip the timestamp via localtime_r(3) and mktime(3) * to convert it to Unix time. This case is completely * untested. */ tem_date = tvips_tiff_ftoh32(handle, &handle->tem_data[224]); tem_time = tvips_tiff_ftoh32(handle, &handle->tem_data[228]); clock = tem_date * 60 * 60 * 24 + tem_time / 100; if (localtime_r(&clock, &tm) == NULL) { ret = -1; break; } tv->tv_sec = mktime(&tm); if (tv->tv_sec == -1) { ret = -1; break; } tv->tv_nsec = 10000000 * (tem_time - 100 * (tem_time / 100)); break; case 2: /* Note that a negative value for tm_isdst causes the * mktime(3) function to guess whether daylight savings is in * effect for the given time. */ tem_date = tvips_tiff_ftoh32(handle, &handle->tem_data[584]); tem_time = tvips_tiff_ftoh32(handle, &handle->tem_data[588]); tm.tm_year = ((tem_date >> 16) & 0xffff) - 1900; tm.tm_mon = ((tem_date >> 8) & 0xff) - 1; tm.tm_mday = tem_date & 0xff; tm.tm_hour = tem_time / (60 * 60); tm.tm_min = (tem_time - tm.tm_hour * 60 * 60) / 60; tm.tm_sec = tem_time - tm.tm_hour * 60 * 60 - tm.tm_min * 60; tm.tm_isdst = -1; tv->tv_sec = mktime(&tm); if (tv->tv_sec == -1) { ret = -1; break; } tv->tv_nsec = 0; break; default: /* NOTREACHED * * Disable to test non-TVIPS TIFF images. */ errno = ENOTSUP; ret = -1; break; } /* Reset the timezone if it was changed. */ if (zone != NULL) { if (zone_old != NULL) setenv("TZ", zone_old, 1); else unsetenv("TZ"); tzset(); } return (ret); } struct frame * tvips_read_tiff(struct tvips_tiff *handle, const char *zone) { uint32 binning[2]; TIFFErrorHandler error_old, warning_old; struct frame *frame; uint32 length, width; uint16 bps; /* Disable errors and warnings, as the former are communicated * through errno. */ error_old = TIFFSetErrorHandler(NULL); warning_old = TIFFSetWarningHandler(NULL); /* Allocate and initialize the frame structure. */ frame = frame_new(); if (frame == NULL) goto exit_error; frame->raster = _tiff_raster(handle->tif, &width, &length, &bps); if (frame->raster == NULL) goto exit_error; frame->width = width; frame->height = length; #if 0 { size_t i, j; for (i = 50; i < 150; i++) { for (j = 50; j < 50; j++) frame->raster[frame->width * i + j] = 0; } } #endif switch (tvips_tiff_ftoh32(handle, &handle->tem_data[0])) { case 1: /* Extract the binning factor, which must be a multiple of ten * thousand. Convert the exposure time in ten-thousands of ms * to s, pixel size in ten-thousands of µm to mm, high tension * in ten-thousands of kV to V, and wavelength in m to Å. * Note that the version 1 header assumes pixels are square * and equally binned in the horizontal and vertical * directions. */ binning[0] = tvips_tiff_ftoh32(handle, &handle->tem_data[180]); if (binning[0] % 10000 != 0) goto exit_error; binning[0] /= 10000; binning[1] = binning[0]; frame->exposure = 1e-7 * tvips_tiff_ftoh32(handle, &handle->tem_data[196]); frame->pixel_size[0] = 1e-7 * tvips_tiff_ftoh32(handle, &handle->tem_data[176]); frame->pixel_size[1] = frame->pixel_size[0]; frame->wavelength = 1e10 * ht2wavelengthf( 1e-1 * tvips_tiff_ftoh32(handle, &handle->tem_data[84])); break; case 2: /* Check concluding magic value. Assert that the image * dimension in the TemData structure agrees with the actual * raster. */ if (tvips_tiff_ftoh32(handle, &handle->tem_data[6308]) != 0xaaaaaaaa) goto exit_error; if (tvips_tiff_ftoh32( handle, &handle->tem_data[564]) != frame->width || tvips_tiff_ftoh32( handle, &handle->tem_data[568]) != frame->height) { goto exit_error; } /* Assert that the pixel type can be losslessly represented by * the SMV format and matches the bitwidth from the TIFF * header. */ switch (tvips_tiff_ftoh32(handle, &handle->tem_data[580])) { case 1: if (bps != 8) goto exit_error; break; case 2: if (bps != 16) goto exit_error; break; default: /* Set errno to what _tiff_raster() should have set for * unsupported data types. This may happen with images * from EMMENU < XXX, which did not set * TIFFTAG_SAMPLEFORMAT correctly, thus preventing * _tiff_raster() from catching this error. */ errno = ENOTSUP; goto exit_error; } /* Extract the camera type and convert it from UTF-16 to * ASCII. * * XXX See /groups/gonen/gonenlab/EMdata/MicroED/lysozyme/normalxtals/020414/normaldose/lmp1.tif, lets see what other strings are in that file. */ frame->id = _tiff_utf162ascii(&handle->tem_data[3768], 80); if (frame->id == NULL) goto exit_error; if (strlen(frame->id) == 0) { free(frame->id); frame->id = NULL; } /* Extract the binning factor. Convert the exposure time in * ms to s, pixel size in nm to mm, and wavelength in m to Å. */ binning[0] = tvips_tiff_ftoh32(handle, &handle->tem_data[3944]); binning[1] = tvips_tiff_ftoh32(handle, &handle->tem_data[3948]); frame->exposure = 1e3 * tvips_tiff_ftohf(handle, &handle->tem_data[3952]); frame->pixel_size[0] = 1e-6 * tvips_tiff_ftohf(handle, &handle->tem_data[3928]); frame->pixel_size[1] = 1e-6 * tvips_tiff_ftohf(handle, &handle->tem_data[3932]); frame->wavelength = 1e10 * ht2wavelengthf( tvips_tiff_ftohf(handle, &handle->tem_data[3272])); break; default: /* NOTREACHED * * Disable to test non-TVIPS TIFF images. */ errno = ENOTSUP; goto exit_error; } /* Extract the creation time in UTC. */ if (tvips_ctime_tiff(handle, zone, &frame->tv) != 0) goto exit_error; /* Convert the binning from 32-bit unsigned integer to vanilla * integer, considering the possibility for overflow. */ if (binning[0] > UINT_MAX || binning[1] > UINT_MAX) { errno = EOVERFLOW; goto exit_error; } frame->binning[0] = binning[0]; frame->binning[1] = binning[1]; /* Reset the error and warning handlers. XXX setenv(3) and * unsetenv(3) should not fail; if they do, they may prevent errno * from representing the true cause of any previous error. */ TIFFSetWarningHandler(warning_old); TIFFSetErrorHandler(error_old); return (frame); exit_error: /* XXX Is it possible that these calls will wreck the errno as * assigned above? */ TIFFSetWarningHandler(warning_old); TIFFSetErrorHandler(error_old); if (frame != NULL) frame_free(frame); return (NULL); } tvips-tools-0.0.0/tvips2smv.c0000644014554002660440000006155312534366730015522 0ustar hattnejgonen/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. * * From the "Advanced recorder settings" in EMMENU4: "Images are * stored in image sets. To avoid limitations of the file system, * image sets are only filled with a certain number of images. If * that number is reached, a new image set is created automatically. * The file size of the image set must not exceed 2 GB. Image sets * are files with the extension .tvips. Those images can be managed * using the EMPlayer [sic] application." */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include #include #include #ifdef HAVE_GETOPT_H # include #endif #include #include #include #include #include #include "frame.h" #include "tvips.h" #include "util.h" /* XXX Should probably use an AutoConf macro. */ #if defined(__linux__) # include #elif defined(__APPLE__) # include # define bswap_16(x) OSSwapInt16(x) # define bswap_32(x) OSSwapInt32(x) #elif defined(__GNUC__) # define bswap_16(x) __builtin_bswap16(x) # define bswap_32(x) __builtin_bswap32(x) #endif /** * The _tvips_ftoh32() function converts the 32-bit quantity pointed * to by @p file32 from tvips-file byte ordering to the native * ordering of the host. This is necessary because according to Peter * Sparlinek items in the TVIPS set files are always little-endian. * XXX This function probably only works on GCC-like compilers. * * @param file32 32-bit quantity in tvips-file ordering * @return @p file32 in native ordering of the host */ static int32_t _tvips_ftoh32(const void *file32) { int32_t host32 = *(int32_t *)file32; #ifdef __BIG_ENDIAN__ host32 = bswap_32(host32); #endif return (host32); } /** * The callback function must return 0 on success. The frame * structure is freed using frame_free() when the callback returns. * * @param frame Frame structure * @param counter Image counter, a zero-based index that continues * through all the image set files * @param data User data * @return 0 if if successful, non-zero otherwise */ typedef int (*tvips_frame_callback)( struct frame *frame, size_t counter, void *data); /** * The readfile() function extracts each frame from the @p pathc set * files whose names are pointed to by @p pathv and, in turn, passes * them to @p callback. Upon successful completion a value of 0 is * returned. Otherwise, a value of -1 is returned and @c errno is set * to: * *
* *
@c EPROTO
No valid series header
* *
@c ENOTSUP
Header version not supported
* *
@c EOVERFLOW
Binning factors out of range
* *
* * Any other value of @c errno is due to either failure in a function * from the standard library function or @p callback. * * @return 0 if successful, -1 otherwise */ int readfile(size_t pathc, char *pathv[], tvips_frame_callback callback, void *data) { uint8_t series_header[256]; FILE *stream; size_t i, nmemb; int32_t lBPP, lCounter, lImgHeaderBytes, lXBin, lYBin, lXDim, lYDim; float lPixelSize, lWavelength; if (pathc-- == 0) return (0); stream = fopen(*pathv++, "r"); if (stream == NULL) return (-1); /* Read the series header and check that lSize, the number of * octets in the series header structure, is 256. */ if (fread(series_header, 1, 256, stream) != 256 || _tvips_ftoh32(&series_header[0]) != 256) { fclose(stream); errno = EPROTO; return (-1); } /* Check that the version of the current file (lVersion) is * supported, and set up the number of octets in the image header * structures (lImgHeaderBytes) accordingly. */ switch (_tvips_ftoh32(&series_header[4])) { case 1: lImgHeaderBytes = 12; break; case 2: lImgHeaderBytes = _tvips_ftoh32(&series_header[48]); if (lImgHeaderBytes <= 0) { fclose(stream); errno = EPROTO; return (-1); } break; default: fclose(stream); errno = ENOTSUP; return (-1); } /* The dimensions along x (lXDim, width) and y (lYDim, height) of * all the images must be positive. */ lXDim = _tvips_ftoh32(&series_header[8]); lYDim = _tvips_ftoh32(&series_header[12]); if (lXDim <= 0 || lYDim <= 0) { fclose(stream); errno = EPROTO; return (-1); } /* The number of bits per pixel must be either 8 or 16. */ lBPP = _tvips_ftoh32(&series_header[16]); if (lBPP != 8 && lBPP != 16) { fclose(stream); errno = EPROTO; return (-1); } /* Extract the binning factor and convert it from 32-bit unsigned * integer to vanilla integer, considering the possibility for * overflow. Convert pixel size in nm to mm. */ lXBin = _tvips_ftoh32(&series_header[28]); lYBin = _tvips_ftoh32(&series_header[32]); if (lXBin > UINT_MAX || lYBin > UINT_MAX) { fclose(stream); errno = EOVERFLOW; return (-1); } lPixelSize = 1e-6 * _tvips_ftoh32(&series_header[36]); lWavelength = 1e10 * ht2wavelengthf( 1e3 * _tvips_ftoh32(&series_header[40])); /* The 32-bit integers lXOff and lYOff at offsets 20 and 24, * respectively, have no bearing on this function. XXX Other * unhandled items. */ #if 0 int32_t lMagTotal = _tvips_ftoh32(&series_header[44]); #endif /* Read the image header. */ uint8_t *image_header; image_header = calloc(lImgHeaderBytes, 1); if (image_header == NULL) return (-1); while (!feof(stream)) { nmemb = fread(image_header, 1, lImgHeaderBytes, stream); if (nmemb == 0) { /* Zero octets read. Unless an error occurred, this means * end-of-file. */ if (ferror(stream)) { free(image_header); fclose(stream); return (-1); } /* If there is at least one more file, open it in place of * the current stream. */ if (pathc-- > 0) { fclose(stream); stream = fopen(*pathv++, "r"); if (stream == NULL) { free(image_header); return (-1); } continue; } /* Reached end-of-file of the last stream. Nothing more * to do. */ break; } else if (nmemb == (size_t)lImgHeaderBytes) { /* Allocate and populate a frame structure with the image * data read from the file. According to Peter Sparlinek, * the pixel intensities are always unsigned integers, * either 8 or 16 bits wide. */ struct frame *frame; frame = frame_new(); if (frame == NULL) return (-1); nmemb = lXDim * lYDim; frame->raster = calloc(nmemb, sizeof(uint16_t)); if (frame->raster == NULL) { frame_free(frame); return (-1); } if (fread(frame->raster, lBPP / 8, nmemb, stream) != nmemb) { frame_free(frame); return (-1); } switch (lBPP) { case 8: /* Promote a raster of 8-bit unsigned integers to * 16-bit dittos. The raster need not be byteswapped. * XXX This is untested code! */ for (i = nmemb; i-- > 0; ) frame->raster[i] = (uint16_t)((uint8_t *)frame->raster)[i]; break; case 16: /* On big-endian hosts, a 16-bit raster must be * byteswapped. XXX This is untested code! This * function probably only works on GCC-like compilers. */ #ifdef __BIG_ENDIAN__ for (i = 0; i < nmemb; i++) frame->raster[i] = bswap_16(frame->raster[i]); #endif break; default: /* NOTREACHED */ frame_free(frame); errno = EPROTO; return (-1); } /* Pass the image counter along with the populated frame * structure to the caller-supplied callback and free the * latter. According to Peter Sparlinek, the TVIPS set * files give seconds (lTime) and additional milliseconds * (lMS) in UTC. */ frame->tv.tv_sec = _tvips_ftoh32(&image_header[4]); frame->tv.tv_nsec = 1000000 * _tvips_ftoh32(&image_header[8]); frame->binning[0] = lXBin; frame->binning[1] = lXBin; frame->pixel_size[0] = lPixelSize; frame->pixel_size[1] = lPixelSize; frame->width = lYDim; frame->height = lXDim; frame->wavelength = lWavelength; lCounter = _tvips_ftoh32(&image_header[0]); if (lCounter < 1) { frame_free(frame); errno = EPROTO; return (-1); } if (callback(frame, lCounter - 1, data) != 0) { frame_free(frame); return (-1); } frame_free(frame); } else { /* Unexpected object count. This always indicates an * error. */ free(image_header); fclose(stream); errno = EPROTO; return (-1); } } free(image_header); fclose(stream); return (0); } struct output { struct timespec *tvs; const char *output_template; float beam_center[2]; size_t capacity; size_t nmemb; float distance; float tilt_rate; float wavelength; int k; int flip; }; /** * @bug XXX This function should (but does not) set @c errno properly. * * @param counter Image counter, a zero-based index that continues * through all the image set files */ static int _frame_write(struct frame *frame, size_t counter, void *data) { struct output *output; FILE *stream; char *output_dir, *output_path; void *p; size_t len; double exposure, t; mode_t mode, mode_old; int ret; /* If counter does not match the number of frames actually seen, * return with EPROTO. In what follows, this function uses * output->nmemb in lieu of counter. */ output = (struct output *)data; if (output->nmemb != counter) { errno = EPROTO; return (-1); } /* Append the timestamp of the frame to the list of timestamps for * bookkeeping. The list is dynamically reallocated, if * necessary. */ if (output->nmemb >= output->capacity) { p = realloc( output->tvs, (output->capacity + 1024) * sizeof(struct timespec)); if (p == NULL) return (-1); output->tvs = p; output->capacity += 1024; } output->tvs[output->nmemb] = frame->tv; /* The oscillation start and range is unknown for the first frame. * Calculate the time since the first exposure. XXX The first * exposure is assumed to be the first frame--it is assumed that * frames are chronologically ordered. * * XXX This is duplication w.r.t. tiff2smv.c. */ if (output->nmemb == 0) { exposure = NAN; t = NAN; } else { exposure = difftime(frame->tv.tv_sec, output->tvs[output->nmemb - 1].tv_sec) + 1e-9 * (frame->tv.tv_nsec - output->tvs[output->nmemb - 1].tv_nsec); t = difftime(frame->tv.tv_sec, output->tvs[0].tv_sec) + 1e-9 * (frame->tv.tv_nsec - output->tvs[0].tv_nsec); } output->nmemb += 1; /* No further action if no output is requested. */ if (output->output_template == NULL) return (0); /* Complete the frame structure with items that are (currently) * not extracted from the file headers but supplied on the command * line. If the wavelength is supplied on the command line, it * overrides the value extracted from the file headers. Apply the * frame rotation. */ frame->beam_center[0] = output->beam_center[0]; frame->beam_center[1] = output->beam_center[1]; frame->distance = output->distance; frame->exposure = exposure; frame->osc_range = exposure * output->tilt_rate; frame->osc_start = t * output->tilt_rate; if (isfinite(output->wavelength)) frame->wavelength = output->wavelength; if (output->flip != 0 && frame_flip(frame) != 0) return (-1); if (frame_rot90(frame, output->k) != 0) return (-1); /* Write the file to the path specified by the output template, * after applying "base zero" sequence number substitutions and * creating any intermediate directories. mkpath() is always * called, because the template may affect the directories as well * as terminal files. Because dirname(3) may wreck both its input * and the output of any previous invocation, both must be backed * up first. * * XXX This is duplication w.r.t. tiff2smv.c. */ len = strlen(output->output_template) + 1; output_dir = calloc(2 * len, sizeof(char)); if (output_dir == NULL) return (-1); output_path = output_dir + len; mode_old = umask(0); mode = 0777 & ~mode_old; umask(mode_old); if (template2path( output_path, output->output_template, output->nmemb - 1) != 0) { free(output_dir); return (-1); } memmove(output_dir, dirname(strcpy(output_dir, output_path)), len * sizeof(char)); if (mkpath(output_dir, mode) != 0) { free(output_dir); return (-1); } stream = fopen(output_path, "w"); free(output_dir); if (stream == NULL) return (-1); ret = frame_write(frame, stream); fclose(stream); if (ret != 0) return (-1); return (0); } /* Note that use of __progname is not portable. * * XXX This is duplication w.r.t. tiff2smv.c. */ static void usage() { extern char *__progname; fprintf(stderr, "usage: %s " "[-d distance] " "[-g readout_geometry] " "[-k rotation] " "[-o output_template] " "[-r oscillation_speed] " "[-v] " "[-w wavelength] " "[-x beam_center_x] " "[-y beam_center_y] " "[-z timezone] " "file ...\n", __progname); fprintf(stderr, " %s -V\n", __progname); fprintf(stderr, " %s -h\n", __progname); exit(EXIT_FAILURE); } /* See the GNU coding standards for more information on this (and * opinions on how the --help option should have been implemented). * * XXX This is duplication w.r.t. tiff2smv.c. */ #define xstr(s) str(s) #define str(s) #s static void version() { extern char *__progname; fprintf(stdout, "%s (TVIPS tools) " xstr(GIT_BRANCH) "." xstr(GIT_COMMIT) "\n", __progname); } int main(int argc, char *argv[]) { #if 0 size_t i; for (i = 1; i < argc; i++) readfile(1, &argv[i], my_callback, NULL); #else struct output output; char *ep, *path; size_t j; double exposure_max, exposure_min, t; float exposure; int g, i, k, verbose; /* Default values for command line options. * * XXX This is duplication w.r.t. tiff2smv.c. */ output.tvs = NULL; output.beam_center[0] = 32.1; output.beam_center[1] = 32.0; output.nmemb = 0; output.capacity = 0; output.distance = 2640.0; output.tilt_rate = 0.09; output.output_template = NULL; output.wavelength = NAN; g = 5; k = 1; verbose = 0; /* Use getopt_long(3) if available; the POSIX.2 fall-back * getopt(3) is assumed to always be available. optstring begins * with a colon in order to enable tracking of missing option * arguments. * * XXX This is duplication w.r.t. tiff2smv.c. */ int ch; const char* optstring = ":Vd:g:hk:o:r:vw:x:y:z:"; #ifdef HAVE_GETOPT_LONG static struct option options[] = { { "version", no_argument, NULL, 'V' }, { "distance", required_argument, NULL, 'd' }, { "readout-geometry", required_argument, NULL, 'g' }, { "help", no_argument, NULL, 'h' }, { "rot90", required_argument, NULL, 'k' }, { "output-template", required_argument, NULL, 'o' }, { "rotation-speed", required_argument, NULL, 'r' }, { "verbose", no_argument, NULL, 'v' }, { "wavelength", required_argument, NULL, 'w' }, { "beam-center-x", required_argument, NULL, 'x' }, { "beam-center-y", required_argument, NULL, 'y' }, { "timezone", required_argument, NULL, 'z' }, { NULL, 0, NULL, 0 } }; #endif /* Loop through all the arguments in argv using either getopt(3) * function. This code does its own error reporting, hence opterr * is set to zero to disable getopt(3) error messages. Because * optreset is an extension to the POSIX.2 specification, it is * not used here. * * XXX This is duplication w.r.t. tiff2smv.c. */ opterr = 0; #ifdef HAVE_GETOPT_LONG while ((ch = getopt_long(argc, argv, optstring, options, NULL)) != -1) { #else while ((ch = getopt(argc, argv, optstring)) != -1) { #endif switch (ch) { case 'V': version(); exit(EXIT_SUCCESS); case 'd': errno = 0; output.distance = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0 || !isfinite(output.distance)) { warnx("Illegal -d argument %s", optarg); usage(); } break; case 'g': errno = 0; g = strtol(optarg, &ep, 10); if (optarg[0] == '\0' || *ep != '\0' || errno != 0) { warnx("Illegal -g argument %s", optarg); usage(); } break; case 'h': usage(); case 'k': errno = 0; k = strtol(optarg, &ep, 10) % 4; if (optarg[0] == '\0' || *ep != '\0' || errno != 0) { warnx("Illegal -k argument %s", optarg); usage(); } break; case 'o': output.output_template = optarg; break; case 'r': errno = 0; output.tilt_rate = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0 || !isfinite(output.tilt_rate)) { warnx("Illegal -r argument %s", optarg); usage(); } break; case 'v': verbose++; break; case 'w': errno = 0; output.wavelength = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0 || !isfinite(output.wavelength)) { warnx("Illegal -w argument %s", optarg); usage(); } break; case 'x': errno = 0; output.beam_center[1] = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0 || !isfinite(output.beam_center[1])) { warnx("Illegal -x argument %s", optarg); usage(); } break; case 'y': errno = 0; output.beam_center[0] = strtof(optarg, &ep); if (optarg[0] == '\0' || *ep != '\0' || errno != 0 || !isfinite(output.beam_center[0])) { warnx("Illegal -y argument %s", optarg); usage(); } break; case 'z': /* This is useless for .tvips because timestamps are * always in UTC. */ warnx("Timezone ignored for TVIPS set files"); break; case ':': /* Missing the required argument of an option. Use the * last known option character (optopt) for error * reporting. */ #ifdef HAVE_GETOPT_LONG for (i = 0; options[i].name != NULL; i++) { if (options[i].val == optopt) { warnx("Option -%c (--%s) requires an argument", optopt, options[i].name); usage(); } } #endif warnx("Option -%c requires an argument", optopt); usage(); case '?': warnx("Unrecognized option '%s'", argv[optind - 1]); usage(); default: usage(); } } /* If requested, repeat command line options verbatim on standard * output. * * XXX This is duplication w.r.t. tiff2smv.c. */ if (verbose > 1) { version(); printf("\n"); for (i = 0; i < optind; i++) { printf("%s%s", argv[i], i + 1 < optind ? " " : "\n"); } printf("\n"); } /* Since the documentation states that at least on image must be * provided exit with failure if there are none. * * XXX This is duplication w.r.t. tiff2smv.c. */ if (argc <= optind) return (EXIT_FAILURE); argc -= optind; argv += optind; /* Invert any transformations applied by the camera system, then * apply additional rotations. * * XXX This is duplication w.r.t. tiff2smv.c. */ if (tvips_g2fk(g, &output.flip, &output.k) != 0) err(EXIT_FAILURE, "Unsupported ReadoutGeometry %d", g); output.k += k; /* XXX Validation suggestion: sort the streams by timestamp of the * first frame in the stream. Then verify that lCounter is * continuous. */ /* Convert and output the frames. This assumes that we see the * images in chronological order. XXX Would be nice with some * verbose printout summarizing how much was written, number of * successes and failures, and so on. */ if (readfile(argc, argv, _frame_write, (void *)&output) != 0) { if (output.tvs != NULL) free(output.tvs); err(EXIT_FAILURE, "Failed to convert"); } /* If requested, output the canonicalized absolute pathname of the * files just read. * * XXX This is duplication w.r.t. tiff2smv.c. */ if (verbose > 2) { for (i = 0; i < argc; i++) { path = realpath(argv[i], NULL); if (path != NULL) { printf("%s\n", path); free(path); } } } /* Calculate exposure time and, if requested, report lower and * upper bounds on the time difference between successive frames. * * XXX This is duplication w.r.t. tiff2smv.c. */ exposure = deltatimef(output.tvs, output.nmemb); if (verbose > 0) { exposure_max = exposure_min = 0; for (j = 1; j < output.nmemb; j++) { t = difftime(output.tvs[j].tv_sec, output.tvs[j - 1].tv_sec) + 1e-9 * (output.tvs[j].tv_nsec - output.tvs[j - 1].tv_nsec); if (j == 1 || t > exposure_max) exposure_max = t; if (j == 1 || t < exposure_min) exposure_min = t; } printf("Estimated exposure time: %.2f s " "(from %zd timestamp differences in the range [%.2f, %.2f] s)\n", exposure, output.nmemb > 0 ? output.nmemb - 1 : 0, exposure_min, exposure_max); } if (output.tvs != NULL) free(output.tvs); #endif return (EXIT_SUCCESS); } tvips-tools-0.0.0/delta_t.cpp0000644014554002660440000000600312534366730015506 0ustar hattnejgonen/* -*- mode: c++; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifdef HAVE_CONFIG_H # include "config.h" #endif #include #include #include "util.h" namespace { template T _deltatime(const struct timespec *base, size_t nmemb) { size_t i; T t, sum_x, sum_xi; if (nmemb <= 1) return (T(0)); sum_x = sum_xi = 0; for (i = 1; i < nmemb; i++) { t = difftime(base[i].tv_sec, base[0].tv_sec) + 1e-9 * (base[i].tv_nsec - base[0].tv_nsec); sum_x += t; sum_xi += t * i; } t = T(6) / (nmemb * (nmemb + 1)) * (T(2) * sum_xi / (nmemb - 1) - sum_x); return (t); } } double deltatime(const struct timespec *base, size_t nmemb) { return (_deltatime(base, nmemb)); } float deltatimef(const struct timespec *base, size_t nmemb) { return (_deltatime(base, nmemb)); } namespace { template T _ht2wavelength(T ht) { /* The speed of light (e8*m/s), the elementary charge * (e-19*C), Planck constant (e-34*Js), and the electron rest * mass (e-31*kg) are from http://www.wikipedia.org. All * constants are defined by their "normalized" significand * only, because otherwise the product of e.g. m and e would * overflow the exponent of the IEEE single-precision binary * floating-point format. */ const T c = 2.99792458; const T e = 1.602176565; const T h = 6.62606957; const T m = 9.10938215; T k2, p2; if (ht <= T(0)) { errno = EDOM; return (0); } /* The classical squared momentum of an electron accelerated * by an electrostatic potential ht. */ p2 = T(2e-4) * m * e * ht; /* The relativistic correction factor to the classical squared * momentum. */ k2 = T(1) + e * ht / (T(2e4) * m * c * c); return (T(1e-11) * h / std::sqrt(p2 * k2)); } } double ht2wavelength(double ht) { return (_ht2wavelength(ht)); } float ht2wavelengthf(float ht) { return (_ht2wavelength(ht)); } tvips-tools-0.0.0/Makefile0000644014554002660440000000407412534366730015034 0ustar hattnejgonen# -*- mode: makefile -*- #- # Copyright (c) 2015, Howard Hughes Medical Institute # # Permission to use, copy, modify, and/or distribute this software for # any purpose with or without fee is hereby granted, provided that the # above copyright notice and this permission notice appear in all # copies. # # THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL # WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED # WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE # AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL # DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA # OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER # TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR # PERFORMANCE OF THIS SOFTWARE. .SUFFIXES: .fo .pdf #CPPFLAGS += -DHAVE_GETOPT_H -DHAVE_GETOPT_LONG CPPFLAGS += -DGIT_BRANCH=$(git_branch) -DGIT_COMMIT=$(git_commit) CFLAGS += -Wall CXXFLAGS += -Wall xsl_ns = http://docbook.sourceforge.net/release/xsl-ns/current # XXX The commands to generate the GIT_BRANCH and GIT_COMMIT # preprocessor definitions on a git installation and require make(1) # to be run from a local repository. Once the repository contains # some tags, see GIT-VERSION-GEN from the git sources. git_branch = "master" git_commit = "6d546f9" all: dm2smv tiff2smv tvips2smv dm2smv: delta_t.o dm2smv.o frame.o util.o $(CC) $(LDFLAGS) -o $(@) $(^) -lm $(LOADLIBES) $(LDLIBS) tiff2smv: delta_t.o frame.o tiff.o tiff2smv.o tvips.o util.o $(CC) $(LDFLAGS) -o $(@) $(^) -ltiff -lm $(LOADLIBES) $(LDLIBS) tvips2smv: delta_t.o frame.o tvips2smv.o tvips.o util.o $(CC) $(LDFLAGS) -o $(@) $(^) -lm $(LOADLIBES) $(LDLIBS) # man page rules. These are not written as suffix rules, because a # single rule may generate several targets. To view the man pages, do # something like "groff -man -T utf8 tiff2smv.1 | less". tiff2smv.1: tiff2smv.1.xml xsltproc $(xsl_ns)/manpages/docbook.xsl $(<) tiff2smv.fo: tiff2smv.1.xml xsltproc --xinclude $(xsl_ns)/fo/docbook.xsl $(<) > $(@) .fo.pdf: fop -fo $(<) -pdf $(@) tvips-tools-0.0.0/tvips.h0000644014554002660440000001424012534366730014706 0ustar hattnejgonen/* -*- mode: c; c-basic-offset: 4; indent-tabs-mode: nil; tab-width: 8 -*- */ /*- * Copyright (c) 2015, Howard Hughes Medical Institute * * Permission to use, copy, modify, and/or distribute this software * for any purpose with or without fee is hereby granted, provided * that the above copyright notice and this permission notice appear * in all copies. * * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL * WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED * WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE * AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR * CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS * OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, * NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN * CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ #ifndef TVIPS_H #define TVIPS_H 1 #ifdef __cplusplus # define TVIPS_BEGIN_C_DECLS extern "C" { # define TVIPS_END_C_DECLS } #else # define TVIPS_BEGIN_C_DECLS # define TVIPS_END_C_DECLS #endif TVIPS_BEGIN_C_DECLS /** * @file tvips.h * @brief XXX * * XXX Looks like the namespace is a tad inconsistent. */ #include #include "frame.h" /** * @brief Incomplete type declaration of the TVIPS TIFF handle */ struct tvips_tiff; /** * @brief * * @param handle Pointer to an opaque TVIPS TIFF handle */ void tvips_close_tiff(struct tvips_tiff *handle); /** * @brief * * @param[in] handle Pointer to an opaque TVIPS TIFF handle * @param[in] zone Timezone where the TIFF stream was written * @param[out] tv Timestamp, s and ns elapsed since midnight, 1 * January 1970 UTC (Unix time) * @return 0 if successful, -1 otherwise. If an error * occurs, the global variable @c errno is set to * indicate the error. */ int tvips_ctime_tiff( struct tvips_tiff *handle, const char *zone, struct timespec *tv); /** * XXX */ double complex tvips_tiff_ftohc(struct tvips_tiff *handle, const void *filec); /** * The tvips_tiff_ftohf() function converts the single-precision * floating point number pointed to by @p filef from TIFF-file byte * ordering to the native ordering of the host. This is necessary * because the TemData items are stored in TIFF-file ordering, and * they are not automagically converted by Libtiff. * * @param handle Handle to the TVIPS TIFF file * @param filef Single-precision floating point number in TIFF-file * ordering * @return @p filef in native ordering of the host */ float tvips_tiff_ftohf(struct tvips_tiff *handle, const void *filef); /** * The tvips_tiff_ftoh32() function converts the 32-bit quantity * pointed to by @p file32 from TIFF-file byte ordering to the native * ordering of the host. This is necessary because the TemData items * are stored in TIFF-file ordering, and they are not automagically * converted by Libtiff. * * @param handle Handle to the TVIPS TIFF file * @param file32 32-bit quantity in TIFF-file ordering * @return @p file32 in native ordering of the host */ uint32_t tvips_tiff_ftoh32(struct tvips_tiff *handle, const void *file32); /** * @brief * * Set errno to EPROTO in case Libtiff fails to read the file. * * @param stream Name of input TIFF file XXX * @return Pointer to an opaque TVIPS TIFF handle if successful, * @c NULL otherwise. */ struct tvips_tiff * tvips_open_tiff(FILE *stream); /** * The tvips_read_tiff() function allocates and populates an @c frame * structure with data read from the seekable TIFF stream pointed to * by @p stream. The timezone where the TIFF was written is given by * the string pointed to by @p zone. If @p zone is @c NULL, the * stream is assumed to be written in the local timezone. Upon * successful completion, tvips_read_tiff() returns a pointer to an * allocated @c frame structure. Otherwise, @c NULL is returned and * the global variable @c errno is set to indicate the error. An * allocated @c frame structure may subsequently be used as an * argument to frame_free(). * * @bug XXX Is errno actually set by Libtiff? * * @note This implementation uses the Libtiff type definitions uint16, * uint32, etc in lieu of the "standard" definitions from * stdint.h. Thus, the latter file need not be included. * * @param handle Pointer to an opaque TVIPS TIFF handle * @param zone Timezone where the TIFF stream was written * @return Allocated and populated @c frame structure */ struct frame * tvips_read_tiff(struct tvips_tiff *handle, const char *zone); /** * @brief * * The returned pointer is only valid until tvips_close_tiff() has * been called on @p handle. XXX This will require making the * ftoh32() and friends public, too! * * @param handle Pointer to an opaque TVIPS TIFF handle * @return Pointer to the read-only TemData structure */ const uint8_t * tvips_tem_data_tiff(struct tvips_tiff *handle); /** * The tvips_g2fk() function determines the column reversal and * rotation to invert the transformation applied by a camera system * configured with the given @c ReadoutGeometry parameter @p g. If @p * f is non-zero the columns should be reversed using e.g. * frame_flip() prior to @p k 90-degree counterclockwise rotations * with e.g. frame_rot90(). If @p g does not define a known @c * ReadoutGeometry the function sets @c errno to @c EINVAL. * * @note As an extension, the undocumented readout geometries 12 * through 15 are supported as well. * * @bug XXX Check this documentation block with the Tietz EMMENU * documentation for consistency. * * @param g The @c ReadoutGeometry parameter of the camera system * @param[out] f Non-zero if the columns of the image must be reversed * before rotation * @param[out] k The number counterclockwise 90-degree rotations that * must be applied after any column reversal * @return 0 if successful, -1 otherwise. If an error occurs, * the global variable @c errno is set to indicate the * error. */ int tvips_g2fk(int g, int *f, int *k); TVIPS_END_C_DECLS #endif /* !TVIPS_H */ tvips-tools-0.0.0/ChangeLog0000644014554002660440000000011212534366730015133 0ustar hattnejgonen2015-06-05 TVIPS tools v0.0.0 * Initial version