stl2sdds.c File Reference

Detailed Description

Converts STL (STereo-Lithography) files to SDDS format.

This program reads an STL (STereo-Lithography) file and converts it into the Self Describing Data Sets (SDDS) format. It supports both ASCII and binary STL files and can output in ASCII or binary SDDS formats. Additionally, it supports piping options for input and output.

Usage

stl2sdds [<inputFile>] [<outputFile>] 
         [-pipe[=in][,out]]
         [-ascii | -binary]

Options

Optional	Description
-pipe	Enables piping for input and/or output using the SDDS toolkit pipe option.
-ascii	Requests SDDS ASCII output. Default is binary.
-binary	Requests SDDS binary output.

Incompatibilities

• Only one of the following may be specified:
  • -ascii
  • -binary

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

R. Soliday

Definition in file stl2sdds.c.

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

Go to the source code of this file.

Functions
float	float_reverse_bytes (float x)
int	leqi (char *string1, char *string2)
int	main (int argc, char **argv)

Function Documentation

float_reverse_bytes()

float float_reverse_bytes

(

float

x

)

Definition at line 434 of file stl2sdds.c.

                                   {
  char c;
  union {
    float yfloat;
    char ychar[4];
  } y;
 
  y.yfloat = x;
 
  /* Swap bytes 0 and 3 */
  c = y.ychar[0];
  y.ychar[0] = y.ychar[3];
  y.ychar[3] = c;
 
  /* Swap bytes 1 and 2 */
  c = y.ychar[1];
  y.ychar[1] = y.ychar[2];
  y.ychar[2] = c;
 
  return y.yfloat;
}

leqi()

int leqi	(	char *	string1,
		char *	string2 )

Definition at line 456 of file stl2sdds.c.

                                       {
  int i;
  int nchar;
  int nchar1 = strlen(string1);
  int nchar2 = strlen(string2);
 
  nchar = (nchar1 < nchar2) ? nchar1 : nchar2;
 
  /* Compare characters case-insensitively */
  for (i = 0; i < nchar; i++) {
    if (toupper((unsigned char)string1[i]) != toupper((unsigned char)string2[i])) {
      return FALSE;
    }
  }
 
  /* Check for trailing spaces in the longer string */
  if (nchar1 > nchar) {
    for (i = nchar; i < nchar1; i++) {
      if (string1[i] != ' ') {
        return FALSE;
      }
    }
  } else if (nchar2 > nchar) {
    for (i = nchar; i < nchar2; i++) {
      if (string2[i] != ' ') {
        return FALSE;
      }
    }
  }
 
  return TRUE;
}

main()

int main	(	int	argc,
		char **	argv )

Definition at line 77 of file stl2sdds.c.

                                {
  char *inputFile = NULL, *outputFile = NULL;
  SDDS_DATASET SDDSout;
  SCANNED_ARG *scanned;
  long iArg;
  long ascii = 0;
  unsigned long pipeFlags = 0;
 
  int i, n = 0, solid = 0;
  char init[7];
  short attribute = 0;
  int32_t face_num = 0, iface;
  int32_t bigEndianMachine = 0;
  int64_t bytes_num = 0, text_num = 0;
  float *normalVector[3];
  float *vertex1[3];
  float *vertex2[3];
  float *vertex3[3];
  FILE *fd;
  char input[LINE_MAX_LEN];
  char *next;
  char token[LINE_MAX_LEN];
  int width;
 
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&scanned, argc, argv);
  if (argc < 2) {
    fprintf(stderr, "%s", USAGE);
    return EXIT_FAILURE;
  }
 
  for (iArg = 1; iArg < argc; iArg++) {
    if (scanned[iArg].arg_type == OPTION) {
      switch (match_string(scanned[iArg].list[0], option, N_OPTIONS, 0)) {
      case SET_ASCII:
        ascii = 1;
        break;
      case SET_BINARY:
        ascii = 0;
        break;
      case SET_PIPE:
        if (!processPipeOption(scanned[iArg].list + 1, scanned[iArg].n_items - 1, &pipeFlags)) {
          fprintf(stderr, "Error: Invalid -pipe syntax.\n");
          fprintf(stderr, "%s", USAGE);
          return EXIT_FAILURE;
        }
        break;
      default:
        fprintf(stderr, "Error: Invalid option detected.\n%s", USAGE);
        return EXIT_FAILURE;
      }
    } else {
      if (!inputFile)
        SDDS_CopyString(&inputFile, scanned[iArg].list[0]);
      else if (!outputFile)
        SDDS_CopyString(&outputFile, scanned[iArg].list[0]);
      else {
        fprintf(stderr, "Error: Too many filenames provided.\n%s", USAGE);
        return EXIT_FAILURE;
      }
    }
  }
 
  processFilenames("stl2sdds", &inputFile, &outputFile, pipeFlags, 0, NULL);
 
  if (inputFile) {
    if (!fexists(inputFile)) {
      fprintf(stderr, "Error: Input file '%s' not found.\n", inputFile);
      return EXIT_FAILURE;
    }
    if (!(fd = fopen(inputFile, "rb"))) {
      fprintf(stderr, "Error: Unable to open input file '%s'.\n", inputFile);
      return EXIT_FAILURE;
    }
  } else {
#if defined(_WIN32)
    if (_setmode(_fileno(stdin), _O_BINARY) == -1) {
      fprintf(stderr, "Error: Unable to set stdin to binary mode.\n");
      return EXIT_FAILURE;
    }
#endif
    fd = stdin;
  }
 
  bigEndianMachine = SDDS_IsBigEndianMachine();
 
  /* Check for ASCII or BINARY STL type */
  bytes_num += fread(&init, 1, 6, fd);
  init[6] = '\0';
  int stlascii = (strcasecmp("solid ", init) == 0) ? TRUE : FALSE;
 
  if (!stlascii) {
    /* 80 byte Header. (74 bytes remaining) */
    for (i = 0; i < 74; i++) {
      if (fgetc(fd) == EOF)
        break;
      bytes_num++;
    }
 
    /* Number of faces */
    bytes_num += fread(&face_num, 1, sizeof(int32_t), fd);
    if (bigEndianMachine) {
      SDDS_SwapLong((int32_t *)&face_num);
    }
 
    for (i = 0; i < 3; i++) {
      normalVector[i] = malloc(sizeof(*(normalVector[i])) * face_num);
      vertex1[i] = malloc(sizeof(*(vertex1[i])) * face_num);
      vertex2[i] = malloc(sizeof(*(vertex2[i])) * face_num);
      vertex3[i] = malloc(sizeof(*(vertex3[i])) * face_num);
      if (!normalVector[i] || !vertex1[i] || !vertex2[i] || !vertex3[i]) {
        fprintf(stderr, "Error: Memory allocation failed.\n");
        return EXIT_FAILURE;
      }
    }
 
    /* Read each face's data */
    for (iface = 0; iface < face_num; iface++) {
      for (i = 0; i < 3; i++) {
        if (fread(&(normalVector[i][iface]), 1, sizeof(float), fd) != sizeof(float)) {
          fprintf(stderr, "Error: Unexpected end of file while reading normals.\n");
          return EXIT_FAILURE;
        }
        bytes_num += sizeof(float);
        if (bigEndianMachine) {
          normalVector[i][iface] = float_reverse_bytes(normalVector[i][iface]);
        }
      }
      for (i = 0; i < 3; i++) {
        if (fread(&(vertex1[i][iface]), 1, sizeof(float), fd) != sizeof(float)) {
          fprintf(stderr, "Error: Unexpected end of file while reading vertex1.\n");
          return EXIT_FAILURE;
        }
        bytes_num += sizeof(float);
        if (bigEndianMachine) {
          vertex1[i][iface] = float_reverse_bytes(vertex1[i][iface]);
        }
      }
      for (i = 0; i < 3; i++) {
        if (fread(&(vertex2[i][iface]), 1, sizeof(float), fd) != sizeof(float)) {
          fprintf(stderr, "Error: Unexpected end of file while reading vertex2.\n");
          return EXIT_FAILURE;
        }
        bytes_num += sizeof(float);
        if (bigEndianMachine) {
          vertex2[i][iface] = float_reverse_bytes(vertex2[i][iface]);
        }
      }
      for (i = 0; i < 3; i++) {
        if (fread(&(vertex3[i][iface]), 1, sizeof(float), fd) != sizeof(float)) {
          fprintf(stderr, "Error: Unexpected end of file while reading vertex3.\n");
          return EXIT_FAILURE;
        }
        bytes_num += sizeof(float);
        if (bigEndianMachine) {
          vertex3[i][iface] = float_reverse_bytes(vertex3[i][iface]);
        }
      }
      if (fread(&(attribute), 1, sizeof(short int), fd) != sizeof(short int)) {
        fprintf(stderr, "Error: Unexpected end of file while reading attribute.\n");
        return EXIT_FAILURE;
      }
      bytes_num += sizeof(short int);
    }
  } else {
    for (i = 0; i < 3; i++) {
      normalVector[i] = NULL;
      vertex1[i] = NULL;
      vertex2[i] = NULL;
      vertex3[i] = NULL;
    }
    fseek(fd, 0, SEEK_SET);
    while (fgets(input, LINE_MAX_LEN, fd) != NULL) {
      text_num++;
      for (next = input; *next != '\0' && isspace((unsigned char)*next); next++) {
      }
      if (*next == '\0' || *next == '#' || *next == '!' || *next == '$') {
        continue;
      }
      sscanf(next, "%s%n", token, &width);
      next += width;
 
      if (leqi(token, "facet")) {
        if (n == 0) {
          n++;
          for (i = 0; i < 3; i++) {
            normalVector[i] = malloc(sizeof(*(normalVector[i])) * n);
            vertex1[i] = malloc(sizeof(*(vertex1[i])) * n);
            vertex2[i] = malloc(sizeof(*(vertex2[i])) * n);
            vertex3[i] = malloc(sizeof(*(vertex3[i])) * n);
            if (!normalVector[i] || !vertex1[i] || !vertex2[i] || !vertex3[i]) {
              fprintf(stderr, "Error: Memory allocation failed.\n");
              return EXIT_FAILURE;
            }
          }
        } else {
          n++;
          for (i = 0; i < 3; i++) {
            normalVector[i] = realloc(normalVector[i], sizeof(*(normalVector[i])) * n);
            vertex1[i] = realloc(vertex1[i], sizeof(*(vertex1[i])) * n);
            vertex2[i] = realloc(vertex2[i], sizeof(*(vertex2[i])) * n);
            vertex3[i] = realloc(vertex3[i], sizeof(*(vertex3[i])) * n);
            if (!normalVector[i] || !vertex1[i] || !vertex2[i] || !vertex3[i]) {
              fprintf(stderr, "Error: Memory allocation failed.\n");
              return EXIT_FAILURE;
            }
          }
        }
 
        /* Read normal vector */
        sscanf(next, "%*s %e %e %e",
               &(normalVector[0][n - 1]),
               &(normalVector[1][n - 1]),
               &(normalVector[2][n - 1]));
 
        /* Skip "outer loop" */
        if (!fgets(input, LINE_MAX_LEN, fd) || !fgets(input, LINE_MAX_LEN, fd)) {
          fprintf(stderr, "Error: Unexpected end of file while reading outer loop.\n");
          return EXIT_FAILURE;
        }
        text_num += 2;
 
        /* Read vertex1 */
        sscanf(next, "%*s %e %e %e",
               &(vertex1[0][n - 1]),
               &(vertex1[1][n - 1]),
               &(vertex1[2][n - 1]));
 
        /* Skip "vertex" */
        if (!fgets(input, LINE_MAX_LEN, fd)) {
          fprintf(stderr, "Error: Unexpected end of file while reading vertex2.\n");
          return EXIT_FAILURE;
        }
        text_num++;
 
        /* Read vertex2 */
        sscanf(next, "%*s %e %e %e",
               &(vertex2[0][n - 1]),
               &(vertex2[1][n - 1]),
               &(vertex2[2][n - 1]));
 
        /* Skip "vertex" */
        if (!fgets(input, LINE_MAX_LEN, fd)) {
          fprintf(stderr, "Error: Unexpected end of file while reading vertex3.\n");
          return EXIT_FAILURE;
        }
        text_num++;
 
        /* Read vertex3 */
        sscanf(next, "%*s %e %e %e",
               &(vertex3[0][n - 1]),
               &(vertex3[1][n - 1]),
               &(vertex3[2][n - 1]));
 
        /* Skip "endloop" and "endfacet" */
        if (!fgets(input, LINE_MAX_LEN, fd) || !fgets(input, LINE_MAX_LEN, fd)) {
          fprintf(stderr, "Error: Unexpected end of file while reading endloop/endfacet.\n");
          return EXIT_FAILURE;
        }
        text_num += 2;
      } else if (leqi(token, "color")) {
        fprintf(stderr, "Warning: Color field seen in STL file ignored.\n");
      } else if (leqi(token, "solid")) {
        solid++;
        if (solid > 1) {
          fprintf(stderr, "Error: More than one solid field seen in STL file.\n");
          return EXIT_FAILURE;
        }
      } else if (leqi(token, "endsolid")) {
        /* Do nothing */
      } else {
        fprintf(stderr, "Error: Unrecognized keyword '%s' in STL file.\n", token);
        return EXIT_FAILURE;
      }
    }
    face_num = n;
  }
 
  /* Initialize SDDS output */
  if (!SDDS_InitializeOutput(&SDDSout, ascii ? SDDS_ASCII : SDDS_BINARY, 1, NULL, NULL, outputFile)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  if (!ascii) {
    SDDSout.layout.data_mode.column_major = 1;
  }
 
  /* Define SDDS columns */
  const char *columns[] = {
    "NormalVectorX", "NormalVectorY", "NormalVectorZ",
    "Vertex1X", "Vertex1Y", "Vertex1Z",
    "Vertex2X", "Vertex2Y", "Vertex2Z",
    "Vertex3X", "Vertex3Y", "Vertex3Z"};
  for (i = 0; i < 12; i++) {
    if (!SDDS_DefineSimpleColumn(&SDDSout, columns[i], NULL, SDDS_FLOAT)) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return EXIT_FAILURE;
    }
  }
 
  /* Write SDDS layout */
  if (!SDDS_WriteLayout(&SDDSout)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  /* Start SDDS table */
  if (!SDDS_StartTable(&SDDSout, face_num)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  /* Set SDDS columns from data */
  const char *column_names[] = {
    "NormalVectorX", "NormalVectorY", "NormalVectorZ",
    "Vertex1X", "Vertex1Y", "Vertex1Z",
    "Vertex2X", "Vertex2Y", "Vertex2Z",
    "Vertex3X", "Vertex3Y", "Vertex3Z"};
  float *data_columns[12] = {
    normalVector[0], normalVector[1], normalVector[2],
    vertex1[0], vertex1[1], vertex1[2],
    vertex2[0], vertex2[1], vertex2[2],
    vertex3[0], vertex3[1], vertex3[2]};
 
  for (i = 0; i < 12; i++) {
    if (!SDDS_SetColumnFromFloats(&SDDSout, SDDS_SET_BY_NAME, data_columns[i], face_num, column_names[i])) {
      SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
      return EXIT_FAILURE;
    }
  }
 
  /* Write SDDS table */
  if (!SDDS_WriteTable(&SDDSout)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    free_scanargs(&scanned, argc);
    return EXIT_FAILURE;
  }
 
  /* Terminate SDDS output */
  if (!SDDS_Terminate(&SDDSout)) {
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors);
    return EXIT_FAILURE;
  }
 
  /* Clean up */
  free_scanargs(&scanned, argc);
  for (i = 0; i < 3; i++) {
    free(normalVector[i]);
    free(vertex1[i]);
    free(vertex2[i]);
    free(vertex3[i]);
  }
 
  return EXIT_SUCCESS;
}