image2sdds.c

/*************************************************************************\
 * Copyright (c) 2002 The University of Chicago, as Operator of Argonne
 * National Laboratory.
 * Copyright (c) 2002 The Regents of the University of California, as
 * Operator of Los Alamos National Laboratory.
 * This file is distributed subject to a Software License Agreement found
 * in the file LICENSE that is included with this distribution. 
\*************************************************************************/
 
/*************************************************************************
 * FILE:      image2sdds.c
 * Author:    Josh Stein
 *
 * Purpose:   Program for converting a raw binary image file
 *            to a variety of SDDS formats.
 *
 * Mods:      login mm/dd/yy: description
 *
 *          stein   02/26/97: created
 *************************************************************************/
 
#include <stdio.h>
#include <string.h>
#include <SDDS.h> /* SDDS library header */
 
#define VERSION "V1.2"
#define XDIMENSION 482 /* Default beam size in X axis */
#define YDIMENSION 512 /* Default beam size in Y axis */
 
/* Parameter defines */
#define PARM_DEBUG 1
#define PARM_XDIM 2
#define PARM_YDIM 3
#define PARM_TRANSPOSE 4
#define PARM_ASCII 5
#define PARM_HELP 6
#define PARM_QMARK 7
#define PARM_CONTOUR 8
#define PARM_2D 9
#define PARM_XMIN 10
#define PARM_YMIN 11
#define PARM_XMAX 12
#define PARM_YMAX 13
#define PARM_MULTICOLUMNMODE 14
 
int asciiOutput = 0; /* Set to 1 for ASCII sdds output, 0 for binary */
int array = 0;       /* Set to 1 for 2 dimensional array output */
int contour = 0;
int xDim = 0;
int yDim = 0;
double xMin = 0;
double yMin = 0;
double xMax = 1;
double yMax = 1;
int useXmax = 0;
int useYmax = 0;
int debug = 0;
int transpose = 0;
int multiColumnMode = 0;
 
struct parm_info {
  char *parm;
  int len;
  int id;
  char *desc;
};
 
typedef struct parm_info PARM_INFO;
 
static PARM_INFO ptable[] = {
  {"-2d", 3, PARM_2D, "2D_array"},
  {"-debug", 6, PARM_DEBUG, "Debug_flag"},
  {"-xdim", 5, PARM_XDIM, "X_Dimensions"},
  {"-ydim", 5, PARM_YDIM, "Y_Dimensions"},
  {"-transpose", 10, PARM_TRANSPOSE, "Transpose"},
  {"-ascii", 6, PARM_ASCII, "Transpose"},
  {"-contour", 8, PARM_CONTOUR, "Contour"},
  {"-help", 5, PARM_HELP, "Help"},
  {"-?", 2, PARM_QMARK, "Help"},
  {"-xmin", 5, PARM_XMIN, "X_Minimum"},
  {"-ymin", 5, PARM_YMIN, "Y_Minimum"},
  {"-xmax", 5, PARM_XMAX, "X_Maximum"},
  {"-ymax", 5, PARM_YMAX, "Y_Maximum"},
  {"-multicolumnmode", 16, PARM_MULTICOLUMNMODE, "MultiColumnMode"},
  {NULL, -1, -1}};
 
/* Prototypes */
int process_cmdline_args(int argc, char *argv[], char *infile, char *outfile);
void usage(char *name);
 
int main(int argc, char *argv[]) {
  short *image = NULL;
  short *rotimage = NULL;
  char infile[255];
  char outfile[255];
  char xDimStr[10];
  char yDimStr[10];
  int32_t dim[2];
  FILE *infilefp;
  int x, y, i, n, j;
  SDDS_TABLE table;
  double xInterval = .02;
  double yInterval = .02;
  double *indexes = NULL;
  char **columnNames = NULL;
  int32_t *data = NULL;
 
  process_cmdline_args(argc, argv, infile, outfile);
 
  /* If user didn't specify extrema */
  if (!xDim) {
    xDim = XDIMENSION;
  }
  if (!yDim) {
    yDim = YDIMENSION;
  }
 
  image = (short *)malloc(sizeof(short) * xDim * yDim);
  rotimage = (short *)malloc(sizeof(short) * xDim * yDim);
 
  /* Open input file */
  if ((infilefp = fopen(infile, "r")) == NULL) {
    fprintf(stderr, "%s: error: enable to open input file: %s\n", argv[0], infile);
    exit(1);
  }
 
  /* Read image into 1 dimensional array */
  for (x = 0; x < xDim * yDim; x++) {
    image[x] = getc(infilefp);
    if (image[x] == EOF) {
      fprintf(stderr, "%s: Unexpected EOF at index %d\n", argv[0], x);
      exit(1);
    }
  }
  fclose(infilefp);
  /* Use transpose factor here to adjust image */
  i = 0;
  for (x = 0; x < xDim; x++) {
    for (y = 0; y < yDim; y++) {
      rotimage[y * xDim + x] = image[i];
      i++;
    }
  }
 
  /* Begin SDDS specifics */
 
  if (transpose) {                /* Reverse dimensions for transposed image */
    sprintf(yDimStr, "%d", xDim); /* Dimensions of image sent to sdds */
    sprintf(xDimStr, "%d", yDim);
  } else {
    sprintf(xDimStr, "%d", xDim); /* Dimensions of image sent to sdds */
    sprintf(yDimStr, "%d", yDim);
  }
 
  if (asciiOutput) {
    if (!SDDS_InitializeOutput(&table, SDDS_ASCII, 1, "ImageArray", "Converted image data", outfile)) {
      fprintf(stderr, "%s: SDDS error: unable to initialize output file %s\n", argv[0], outfile);
      SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
    }
  } else {
    if (!SDDS_InitializeOutput(&table, SDDS_BINARY, 1, "ImageArray", "Converted image data", outfile)) {
      fprintf(stderr, "%s: SDDS error: unable to initialize output file %s\n", argv[0], outfile);
      SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
    }
  }
  if (transpose) {
    if (useXmax)
      xInterval = (xMax - xMin) / (yDim - 1);
    if (useYmax)
      yInterval = (yMax - yMin) / (xDim - 1);
  } else {
    if (useXmax)
      xInterval = (xMax - xMin) / (xDim - 1);
    if (useYmax)
      yInterval = (yMax - yMin) / (yDim - 1);
  }
  if (contour) {
    if (!multiColumnMode) {
      /* Begin setting parameters for use in sddscontour tool */
      if (SDDS_DefineParameter(&table, "Variable1Name", NULL, NULL, NULL, NULL, SDDS_STRING, "x") == -1) {
        fprintf(stderr, "%s: SDDS error: unable to define paramter 1: variable1Name\n", argv[0]);
        SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
      }
 
      if (SDDS_DefineParameter(&table, "Variable2Name", NULL, NULL, NULL, NULL, SDDS_STRING, "y") == -1) {
        fprintf(stderr, "%s: SDDS error: unable to define parameter 2: variable2Name\n", argv[0]);
        SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
      }
 
      if (SDDS_DefineParameter1(&table, "xInterval", NULL, NULL, NULL, NULL, SDDS_DOUBLE, &xInterval) == -1) {
        fprintf(stderr, "%s: SDDS error: unable to define parameter 3: xInterval\n", argv[0]);
        SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
      }
 
      if (SDDS_DefineParameter1(&table, "xMinimum", NULL, NULL, NULL, NULL, SDDS_DOUBLE, &xMin) == -1) {
        fprintf(stderr, "%s: SDDS error: unable to define paramter 4: xMinimum\n", argv[0]);
        SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
      }
 
      if (SDDS_DefineParameter(&table, "xDimension", NULL, NULL, NULL, NULL, SDDS_LONG, xDimStr) == -1) {
        fprintf(stderr, "%s: SDDS error: unable to define paramter 5: xDimension\n", argv[0]);
        SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
      }
 
      if (SDDS_DefineParameter1(&table, "yInterval", NULL, NULL, NULL, NULL, SDDS_DOUBLE, &yInterval) == -1) {
        fprintf(stderr, "%s: SDDS error: unable to define parameter 6: yInterval\n", argv[0]);
        SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
      }
 
      if (SDDS_DefineParameter1(&table, "yMinimum", NULL, NULL, NULL, NULL, SDDS_DOUBLE, &yMin) == -1) {
        fprintf(stderr, "%s: SDDS error: unable to define paramter 7: yMinimum\n", argv[0]);
        SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
      }
 
      if (SDDS_DefineParameter(&table, "yDimension", NULL, NULL, NULL, NULL, SDDS_LONG, yDimStr) == -1) {
        fprintf(stderr, "%s: SDDS error: unable to define paramter 8: yDimension\n", argv[0]);
        SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
      }
    }
  }
  /* Done setting parameters */
 
  if (array) {
    if (SDDS_DefineArray(&table, "ImageArray", NULL, NULL, "Intensity", NULL, SDDS_CHARACTER, 0, 2, NULL) == -1) {
      fprintf(stderr, "%s: SDDS error: unable to define array %s\n", argv[0], "Image");
      SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
    }
  } else {
    if (!multiColumnMode) {
      if (SDDS_DefineColumn(&table, "Image", NULL, NULL, NULL, NULL, SDDS_SHORT, 0) == -1) {
        fprintf(stderr, "%s: SDDS error: unable to define column %s\n", argv[0], "Image");
        SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
      }
    } else {
      if (SDDS_DefineSimpleColumn(&table, "Index", NULL, SDDS_DOUBLE) < 0) {
        fprintf(stderr, "Problem defining column Index.\n");
        return (1);
      }
      if (transpose) {
        dim[0] = xDim;
        dim[1] = yDim;
      } else {
        dim[0] = yDim;
        dim[1] = xDim;
      }
      indexes = malloc(sizeof(double) * dim[1]);
      columnNames = malloc(sizeof(char *) * dim[0]);
      data = malloc(sizeof(int32_t) * dim[1]);
      for (i = 0; i < dim[0]; i++) {
        columnNames[i] = malloc(sizeof(char) * 20);
        sprintf(columnNames[i], "Line%" PRId32, i);
        if (SDDS_DefineSimpleColumn(&table, columnNames[i], NULL, SDDS_SHORT) < 0) {
          fprintf(stderr, "Problem defining column %s.\n", columnNames[i]);
          return (1);
        }
      }
    }
  }
 
  if (!SDDS_WriteLayout(&table)) {
    fprintf(stderr, "%s: SDDS error: unable to write layout\n", argv[0]);
    SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
  }
 
  if (!multiColumnMode) {
    if (!SDDS_StartTable(&table, xDim * yDim)) {
      fprintf(stderr, "%s: SDDS error: unable to start table\n", argv[0]);
      SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
    }
  } else {
    if (!SDDS_StartTable(&table, dim[1])) {
      fprintf(stderr, "%s: SDDS error: unable to start table\n", argv[0]);
      SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
    }
  }
 
  if (!array) {
    if (!multiColumnMode) {
      if (transpose) {
        for (x = 0; x < xDim * yDim; x++) {
          if (!SDDS_SetRowValues(&table, (SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE), x, "Image", rotimage[x], NULL)) {
            fprintf(stderr, "%s: SDDS error: unable to write row\n", argv[0]);
            SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
          }
        }
      } else {
        for (x = 0; x < xDim * yDim; x++) {
          if (!SDDS_SetRowValues(&table, (SDDS_SET_BY_NAME | SDDS_PASS_BY_VALUE), x, "Image", image[x], NULL)) {
            fprintf(stderr, "%s: SDDS error: unable to write row\n", argv[0]);
            SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
          }
        }
      }
    } else {
      for (i = 0; i < dim[1]; i++)
        indexes[i] = xMin + xInterval * i;
      if (!SDDS_SetColumnFromDoubles(&table, SDDS_SET_BY_NAME, indexes, dim[1], "Index"))
        SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      n = 0;
 
      for (i = 0; i < dim[0]; i++) {
        for (j = 0; j < dim[1]; j++) {
          if (transpose) {
            data[j] = image[n];
          } else {
            data[j] = rotimage[n];
          }
          n++;
        }
 
        if (!SDDS_SetColumnFromLongs(&table, SDDS_SET_BY_NAME, data, dim[1], columnNames[i]))
          SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
      }
    }
  } else { /* Requesting writing of 2D array */
    if (transpose) {
      dim[0] = xDim;
      dim[1] = yDim;
      if (SDDS_SetArray(&table, "ImageArray", SDDS_CONTIGUOUS_DATA, rotimage, dim) == 0) {
        fprintf(stderr, "%s: SDDS Error - unable to stuff array\n", argv[0]);
        SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
      }
    } else {
      dim[0] = yDim;
      dim[1] = xDim;
      if (SDDS_SetArray(&table, "ImageArray", SDDS_CONTIGUOUS_DATA, image, dim) == 0) {
        fprintf(stderr, "%s: SDDS Error - unable to stuff array\n", argv[0]);
        SDDS_PrintErrors(stderr, SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors);
      }
    }
  }
 
  if (!SDDS_WriteTable(&table)) {
    fprintf(stderr, "%s: SDDS error: unable to write table\n", argv[0]);
    SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
  }
 
  if (!SDDS_Terminate(&table)) {
    fprintf(stderr, "%s: SDDS error: unable to terminate SDDS\n", argv[0]);
    SDDS_PrintErrors(stderr, (SDDS_EXIT_PrintErrors | SDDS_VERBOSE_PrintErrors));
  }
  if (image)
    free(image);
  if (rotimage)
    free(rotimage);
  if (indexes)
    free(indexes);
  if (data)
    free(data);
  if (columnNames)
    free(columnNames);
  return (0);
}
 
/*************************************************************************
 * FUNCTION : process_cmdline_args()
 * PURPOSE  : Get command line arguments and set flags appropriately.
 * ARGS in  : argc, argv - standard unix
 * ARGS out : fname - name of image file 
 * GLOBAL   : nothing
 * RETURNS  : 0
 ************************************************************************/
int process_cmdline_args(int argc, char *argv[], char *infile, char *outfile) {
  int i, j;
  int cmderror = 0;
  int scan_done = 0;
 
  *infile = '\0';
  *outfile = '\0';
 
  /* Process command line options */
  if (argc < 3)
    cmderror++;
  else {
    strcpy(infile, argv[1]);
    strcpy(outfile, argv[2]);
 
    /* Begin parsing any optional args */
    for (i = 3; i < argc && !cmderror; i++) {
      for (j = 0; !scan_done && !cmderror && ptable[j].parm; j++) {
        if (strncmp(ptable[j].parm, argv[i], ptable[j].len) == 0) {
          switch (ptable[j].id) {
 
          case PARM_DEBUG:
            if (++i > argc)
              cmderror++;
            else {
              if (argv[i][0] == '-')
                cmderror++;
              else {
                if (sscanf(argv[i], "%d", &debug) < 1)
                  cmderror++;
                else
                  scan_done = 1;
              }
            }
            break;
 
          case PARM_XDIM:
            if (++i > argc)
              cmderror++;
            else {
              if (argv[i][0] == '-')
                cmderror++;
              else {
                if (sscanf(argv[i], "%d", &xDim) < 1)
                  cmderror++;
                else
                  scan_done = 1;
              }
            }
            break;
 
          case PARM_YDIM:
            if (++i > argc)
              cmderror++;
            else {
              if (argv[i][0] == '-')
                cmderror++;
              else {
                if (sscanf(argv[i], "%d", &yDim) < 1)
                  cmderror++;
                else
                  scan_done = 1;
              }
            }
            break;
 
          case PARM_XMIN:
            if (++i > argc)
              cmderror++;
            else {
              if (argv[i][0] == '-')
                cmderror++;
              else {
                if (sscanf(argv[i], "%lf", &xMin) < 1)
                  cmderror++;
                else
                  scan_done = 1;
              }
            }
            break;
          case PARM_XMAX:
            if (++i > argc)
              cmderror++;
            else {
              if (argv[i][0] == '-')
                cmderror++;
              else {
                if (sscanf(argv[i], "%lf", &xMax) < 1)
                  cmderror++;
                else {
                  scan_done = 1;
                  useXmax = 1;
                }
              }
            }
            break;
          case PARM_YMIN:
            if (++i > argc)
              cmderror++;
            else {
              if (argv[i][0] == '-')
                cmderror++;
              else {
                if (sscanf(argv[i], "%lf", &yMin) < 1)
                  cmderror++;
                else
                  scan_done = 1;
              }
            }
            break;
          case PARM_YMAX:
            if (++i > argc)
              cmderror++;
            else {
              if (argv[i][0] == '-')
                cmderror++;
              else {
                if (sscanf(argv[i], "%lf", &yMax) < 1)
                  cmderror++;
                else {
                  scan_done = 1;
                  useYmax = 1;
                }
              }
            }
            break;
 
          case PARM_TRANSPOSE:
            transpose++;
            scan_done = 1;
            break;
          case PARM_MULTICOLUMNMODE:
            multiColumnMode = 1;
            scan_done = 1;
            break;
 
          case PARM_ASCII:
            asciiOutput++;
            scan_done = 1;
            break;
 
          case PARM_HELP | PARM_QMARK:
            usage(argv[0]);
            scan_done = 1;
            break;
 
          case PARM_CONTOUR:
            contour++;
            scan_done = 1;
            break;
 
          case PARM_2D:
            array++;
            scan_done = 1;
            break;
 
          default:
            cmderror++;
            break;
          }
        }
      }
      scan_done = 0;
    }
  }
  if (cmderror) {
    usage(argv[0]);
    exit(1);
  }
  return (0);
}
 
/*************************************************************************
 * FUNCTION : usage()
 * PURPOSE  : Describes command line options available to client.
 * ARGS in  : char *name - name of executable program
 * ARGS out : none
 * GLOBAL   : nothing
 * RETURNS  : none
 ************************************************************************/
 
#define pr fprintf
 
void usage(char *name) {
  pr(stderr, "Image conversion to SDDS utility %s\n", VERSION);
  pr(stderr, "-------------------------------------\n");
  pr(stderr, "usage: %s <IMAGE infile> <SDDS outfile> [optionlist...]\n", name);
  pr(stderr, "[-2d] output SDDS file as 2D array\n");
  pr(stderr, "[-ascii] write SDDS file as ascii (default is binary)\n");
  pr(stderr, "[-contour] generate SDDS headers for sddscontour tool \n");
  pr(stderr, "[-multicolumnmode]\n");
  pr(stderr, "[-?] or [-help] print this message\n");
  pr(stderr, "[-transpose] transpose image about diagonal\n");
  pr(stderr, "[-xdim <value>] X dimension of image (default = %d) \n", XDIMENSION);
  pr(stderr, "[-ydim <value>] Y dimension of image (default = %d) \n", YDIMENSION);
  pr(stderr, "[-xmin <value>] [-xmax <value>]\n");
  pr(stderr, "[-ymin <value>] [-ymax <value>]\n");
  pr(stderr, "\npurpose:\tReads the image data from file <infile>.\n");
  pr(stderr, "\t\tand write SDDS data to <outfile>.\n");
}