raw2sdds.c File Reference

Detailed Description

Converts a binary raw data stream to SDDS format.

This program reads a binary raw data file and converts it into the SDDS format, widely used for storing and sharing scientific data. Users can define the structure of the SDDS columns, specify the data size, and choose the major order for the output file.

Usage

raw2sdds <inputfile> <outputfile>
         -definition=<name>,<definition-entries>
        [-size=<horiz-pixels>,<vert-pixels>] 
        [-majorOrder=row|column]

Options

Required	Description
-definition	Defines the SDDS columns. Each definition entry must be in the form <keyword>=<value>.

Optional	Description
-size	Specifies the horizontal and vertical size of the data in pixels. Defaults: 484x512.
-majorOrder	Sets the major order for data storage. Defaults to row.

Incompatibilities

• -definition requires the keyword type=character. Other data types are not yet supported.

Copyright

• (c) 2002 The University of Chicago, as Operator of Argonne National Laboratory.
• (c) 2002 The Regents of the University of California, as Operator of Los Alamos National Laboratory.

License

This file is distributed under the terms of the Software License Agreement found in the file LICENSE included with this distribution.

Author

M. Borland, C. Saunders, R. Soliday, H. Shang

Definition in file raw2sdds.c.

#include "mdb.h"
#include "SDDS.h"
#include "scan.h"
#include "match_string.h"

Go to the source code of this file.

Functions
char *	process_column_definition (char **argv, long argc)
int	main (int argc, char **argv)

Function Documentation

main()

int main	(	int	argc,
		char **	argv )

Definition at line 86 of file raw2sdds.c.

                                {
  SDDS_TABLE SDDS_table;
  SCANNED_ARG *scanned;
  unsigned long majorOrderFlag;
  long i_arg;
  char *input, *output, *definition;
  long hsize, vsize;
  char *data, *data_name;
  char ts1[100], ts2[100];
  FILE *fpi;
  short columnMajorOrder = 0;
 
  argc = scanargs(&scanned, argc, argv);
  if (argc < 3) {
    fprintf(stderr, "%s", USAGE);
    return EXIT_FAILURE;
  }
 
  input = output = data_name = NULL;
  hsize = DEFAULT_HSIZE;
  vsize = DEFAULT_VSIZE;
  definition = NULL;
 
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (scanned[i_arg].arg_type == OPTION) {
      /* Process options here */
      switch (match_string(scanned[i_arg].list[0], option, N_OPTIONS, 0)) {
      case SET_MAJOR_ORDER:
        majorOrderFlag = 0;
        scanned[i_arg].n_items--;
        if (scanned[i_arg].n_items > 0 &&
            (!scanItemList(&majorOrderFlag, scanned[i_arg].list + 1, &scanned[i_arg].n_items,
                           0, "row", -1, NULL, 0, SDDS_ROW_MAJOR_ORDER,
                           "column", -1, NULL, 0, SDDS_COLUMN_MAJOR_ORDER, NULL))) {
          fprintf(stderr, "Error: Invalid -majorOrder syntax or values.\n");
          return EXIT_FAILURE;
        }
        if (majorOrderFlag & SDDS_COLUMN_MAJOR_ORDER)
          columnMajorOrder = 1;
        else if (majorOrderFlag & SDDS_ROW_MAJOR_ORDER)
          columnMajorOrder = 0;
        break;
 
      case SET_DEFINITION:
        if (scanned[i_arg].n_items < 2) {
          fprintf(stderr, "Error: -definition requires at least a name and one definition entry.\n");
          fprintf(stderr, "%s", USAGE);
          return EXIT_FAILURE;
        }
        data_name = scanned[i_arg].list[1];
        definition = process_column_definition(scanned[i_arg].list + 1, scanned[i_arg].n_items - 1);
        if (!definition) {
          fprintf(stderr, "Error: Invalid column definition.\n");
          return EXIT_FAILURE;
        }
        if (!strstr(definition, "type=character")) {
          fprintf(stderr, "Error: Data type must be 'character' for now.\n");
          return EXIT_FAILURE;
        }
        break;
 
      case SET_SIZE:
        if (scanned[i_arg].n_items != 3 ||
            sscanf(scanned[i_arg].list[1], "%ld", &hsize) != 1 || hsize <= 0 ||
            sscanf(scanned[i_arg].list[2], "%ld", &vsize) != 1 || vsize <= 0) {
          fprintf(stderr, "Error: Invalid -size syntax.\n");
          fprintf(stderr, "%s", USAGE);
          return EXIT_FAILURE;
        }
        break;
 
      default:
        fprintf(stderr, "Error: Invalid option '%s'.\n", scanned[i_arg].list[0]);
        fprintf(stderr, "%s", USAGE);
        return EXIT_FAILURE;
      }
    } else {
      if (!input)
        input = scanned[i_arg].list[0];
      else if (!output)
        output = scanned[i_arg].list[0];
      else {
        fprintf(stderr, "Error: Too many filenames provided.\n");
        fprintf(stderr, "%s", USAGE);
        return EXIT_FAILURE;
      }
    }
  }
 
  if (!input) {
    fprintf(stderr, "Error: Input file not specified.\n");
    fprintf(stderr, "%s", USAGE);
    return EXIT_FAILURE;
  }
 
  if (!output) {
    fprintf(stderr, "Error: Output file not specified.\n");
    fprintf(stderr, "%s", USAGE);
    return EXIT_FAILURE;
  }
 
  if (!definition) {
    fprintf(stderr, "Error: Column definition not specified.\n");
    fprintf(stderr, "%s", USAGE);
    return EXIT_FAILURE;
  }
 
  snprintf(ts1, sizeof(ts1), "%ld", hsize);
  snprintf(ts2, sizeof(ts2), "%ld", vsize);
 
  if (!SDDS_InitializeOutput(&SDDS_table, SDDS_BINARY, 0,
                             "Screen image from raw file", "screen image",
                             output) ||
      SDDS_ProcessColumnString(&SDDS_table, definition, 0) < 0 ||
      SDDS_DefineParameter(&SDDS_table, "NumberOfRows", NULL, NULL, "number of rows", NULL, SDDS_LONG, ts1) < 0 ||
      SDDS_DefineParameter(&SDDS_table, "NumberOfColumns", NULL, NULL, "number of columns", NULL, SDDS_LONG, ts2) < 0) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  SDDS_table.layout.data_mode.column_major = columnMajorOrder;
 
  if (!SDDS_WriteLayout(&SDDS_table) || !SDDS_StartTable(&SDDS_table, hsize * vsize)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  data = tmalloc(sizeof(*data) * hsize * vsize);
  fpi = fopen_e(input, "rb", 0);
  if (fread(data, sizeof(*data), hsize * vsize, fpi) != (size_t)(hsize * vsize)) {
    fclose(fpi);
    fprintf(stderr, "Error: Unable to read all data from input file '%s'.\n", input);
    return EXIT_FAILURE;
  }
  fclose(fpi);
 
  if (!SDDS_SetColumn(&SDDS_table, SDDS_SET_BY_NAME, data, hsize * vsize, data_name) ||
      !SDDS_WriteTable(&SDDS_table) ||
      !SDDS_Terminate(&SDDS_table)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  free(data);
  return EXIT_SUCCESS;
}

process_column_definition()

char * process_column_definition	(	char **	argv,
		long	argc )

Definition at line 233 of file raw2sdds.c.

                                                        {
  char buffer[SDDS_MAXLINE] = "&column name=";
  char *ptr;
  long i;
 
  if (argc < 1)
    return NULL;
 
  strcat(buffer, argv[0]);
  strcat(buffer, ", ");
 
  for (i = 1; i < argc; i++) {
    if (!strchr(argv[i], '=')) {
      return NULL;
    }
    strcat(buffer, argv[i]);
    strcat(buffer, ", ");
  }
 
  if (!strstr(buffer, "type=")) {
    strcat(buffer, "type=character, ");
  }
 
  strcat(buffer, "&end");
 
  cp_str(&ptr, buffer);
  return ptr;
}