sdds2stl.c File Reference

Detailed Description

Converts SDDS files into binary STL (STereo-Lithography) files.

This program reads an SDDS (Self Describing Data Set) file, extracts normal vectors and vertex coordinates, and writes them into a binary STL file format suitable for 3D modeling and printing. It supports both big-endian and little-endian systems for portability and adheres to SDDS conventions for data processing.

Usage

sdds2stl [<inputFile>] [<outputFile>] [-pipe[=input]]

Options

Options	Description
-pipe	Use piped input/output for SDDS files.

Requirements

• The input SDDS file must include the following columns:
  • NormalVectorX, NormalVectorY, NormalVectorZ
  • Vertex1X, Vertex1Y, Vertex1Z
  • Vertex2X, Vertex2Y, Vertex2Z
  • Vertex3X, Vertex3Y, Vertex3Z
• The columns should be of a numeric type supported by SDDS.

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 sdds2stl.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	main (int argc, char **argv)

Function Documentation

float_reverse_bytes()

float float_reverse_bytes

(

float

x

)

Definition at line 273 of file sdds2stl.c.

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

main()

int main	(	int	argc,
		char **	argv )

Definition at line 65 of file sdds2stl.c.

                                {
  char *input = NULL, *output = NULL;
  SDDS_DATASET SDDS_dataset;
  SCANNED_ARG *scanned;
  long i_arg;
  unsigned long pipe_flags = 0;
 
  int i;
  int64_t rows = 0;
  int32_t row, bsrows;
  float *normal_vector[3];
  float *vertex1[3];
  float *vertex2[3];
  float *vertex3[3];
  short attribute = 0;
  FILE *fd;
  int32_t big_endian_machine = 0;
  float temp;
 
  SDDS_RegisterProgramName(argv[0]);
  argc = scanargs(&scanned, argc, argv);
  if (argc < 2) {
    fprintf(stderr, "%s", usage);
    return 1;
  }
 
  for (i_arg = 1; i_arg < argc; i_arg++) {
    if (scanned[i_arg].arg_type == OPTION) {
      switch (match_string(scanned[i_arg].list[0], option, N_OPTIONS, 0)) {
      case SET_PIPE:
        if (!processPipeOption(scanned[i_arg].list + 1, scanned[i_arg].n_items - 1, &pipe_flags)) {
          fprintf(stderr, "sdds2stl: invalid -pipe syntax\n");
          return 1;
        }
        break;
      default:
        fprintf(stderr, "sdds2stl: invalid option seen\n%s", usage);
        return 1;
      }
    } else {
      if (!input)
        SDDS_CopyString(&input, scanned[i_arg].list[0]);
      else if (!output)
        SDDS_CopyString(&output, scanned[i_arg].list[0]);
      else {
        fprintf(stderr, "sdds2stl: too many filenames\n%s", usage);
        return 1;
      }
    }
  }
 
  if (pipe_flags & USE_STDIN)
    processFilenames("sdds2tiff", &input, &output, USE_STDIN, 1, NULL);
 
  if (!SDDS_InitializeInput(&SDDS_dataset, input))
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "NormalVectorX", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: NormalVectorX column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "NormalVectorY", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: NormalVectorX column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "NormalVectorZ", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: NormalVectorX column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "Vertex1X", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: Vertex1X column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "Vertex1Y", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: Vertex1Y column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "Vertex1Z", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: Vertex1Z column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "Vertex2X", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: Vertex2X column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "Vertex2Y", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: Vertex2Y column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "Vertex2Z", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: Vertex2Z column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "Vertex3X", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: Vertex3X column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "Vertex3Y", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: Vertex3Y column not found.\n");
    return 1;
  }
 
  if ((SDDS_CheckColumn(&SDDS_dataset, "Vertex3Z", NULL, SDDS_ANY_NUMERIC_TYPE, NULL)) != SDDS_CHECK_OKAY) {
    fprintf(stderr, "sdds2stl: Vertex3Z column not found.\n");
    return 1;
  }
 
  if (SDDS_ReadTable(&SDDS_dataset) <= 0) {
    fprintf(stderr, "sdds2stl: Unable to read SDDS page.\n");
    return 1;
  }
 
  rows = SDDS_RowCount(&SDDS_dataset);
  if (rows > INT32_MAX) {
    fprintf(stderr, "sdds2stl: Too many rows input file for conversion to STL format\n");
    return 1;
  }
 
  for (i = 0; i < 3; i++) {
    normal_vector[i] = malloc(sizeof(*(normal_vector[i])) * rows);
    vertex1[i] = malloc(sizeof(*(vertex1[i])) * rows);
    vertex2[i] = malloc(sizeof(*(vertex2[i])) * rows);
    vertex3[i] = malloc(sizeof(*(vertex3[i])) * rows);
  }
 
  normal_vector[0] = SDDS_GetColumnInFloats(&SDDS_dataset, "NormalVectorX");
  normal_vector[1] = SDDS_GetColumnInFloats(&SDDS_dataset, "NormalVectorY");
  normal_vector[2] = SDDS_GetColumnInFloats(&SDDS_dataset, "NormalVectorZ");
  vertex1[0] = SDDS_GetColumnInFloats(&SDDS_dataset, "Vertex1X");
  vertex1[1] = SDDS_GetColumnInFloats(&SDDS_dataset, "Vertex1Y");
  vertex1[2] = SDDS_GetColumnInFloats(&SDDS_dataset, "Vertex1Z");
  vertex2[0] = SDDS_GetColumnInFloats(&SDDS_dataset, "Vertex2X");
  vertex2[1] = SDDS_GetColumnInFloats(&SDDS_dataset, "Vertex2Y");
  vertex2[2] = SDDS_GetColumnInFloats(&SDDS_dataset, "Vertex2Z");
  vertex3[0] = SDDS_GetColumnInFloats(&SDDS_dataset, "Vertex3X");
  vertex3[1] = SDDS_GetColumnInFloats(&SDDS_dataset, "Vertex3Y");
  vertex3[2] = SDDS_GetColumnInFloats(&SDDS_dataset, "Vertex3Z");
 
  if (!SDDS_Terminate(&SDDS_dataset))
    SDDS_PrintErrors(stderr, SDDS_VERBOSE_PrintErrors | SDDS_EXIT_PrintErrors);
 
  if (!output) {
#if defined(_WIN32)
    if (_setmode(_fileno(stdout), _O_BINARY) == -1) {
      fprintf(stderr, "error: unable to set stdout to binary mode\n");
      exit(1);
    }
#endif
    fd = stdout;
  } else
    fd = fopen(output, "wb");
 
  big_endian_machine = SDDS_IsBigEndianMachine();
 
  fprintf(fd, "STL BINARY FILE CREATED BY SDDS2STL --------------------------------------------");
  if (big_endian_machine) {
    bsrows = rows;
    SDDS_SwapLong((int32_t *)&bsrows);
    fwrite(&bsrows, sizeof(int32_t), 1, fd);
    for (row = 0; row < rows; row++) {
      for (i = 0; i < 3; i++) {
        temp = float_reverse_bytes(normal_vector[i][row]);
        fwrite(&temp, sizeof(float), 1, fd);
      }
      for (i = 0; i < 3; i++) {
        temp = float_reverse_bytes(vertex1[i][row]);
        fwrite(&temp, sizeof(float), 1, fd);
      }
      for (i = 0; i < 3; i++) {
        temp = float_reverse_bytes(vertex2[i][row]);
        fwrite(&temp, sizeof(float), 1, fd);
      }
      for (i = 0; i < 3; i++) {
        temp = float_reverse_bytes(vertex3[i][row]);
        fwrite(&temp, sizeof(float), 1, fd);
      }
      fwrite(&attribute, sizeof(short), 1, fd);
    }
  } else {
    fwrite(&rows, sizeof(int32_t), 1, fd);
    for (row = 0; row < rows; row++) {
      for (i = 0; i < 3; i++)
        fwrite(&(normal_vector[i][row]), sizeof(float), 1, fd);
      for (i = 0; i < 3; i++)
        fwrite(&(vertex1[i][row]), sizeof(float), 1, fd);
      for (i = 0; i < 3; i++)
        fwrite(&(vertex2[i][row]), sizeof(float), 1, fd);
      for (i = 0; i < 3; i++)
        fwrite(&(vertex3[i][row]), sizeof(float), 1, fd);
      fwrite(&attribute, sizeof(short), 1, fd);
    }
  }
 
  fclose(fd);
 
  return 1;
}