// stl_to_dat.c  read  binary .stl  write Utah Graphics .dat
//  solid cube1.stl                           ascii version
//  facet normal 0.000000 0.000000 -1.000000
//    outer loop
//      vertex -0.500000 0.500000 0.500000
//      vertex 0.500000 0.500000 0.500000
//      vertex 0.500000 -0.500000 0.500000
//    endloop
//  endfacet
//  ...
//  endsolid

// input binary .stl
// 80 char header,  b  is a byte, 8-bit character
// b b b b  32 bit integer, number of triangles (groups)
//
// three  b b b b 32 bit float  nx, ny, nz  normals
// three  b b b b 32 but floats x1, y1, z1  point
// three  b b b b 32 but floats x2, y2, z2  point
// three  b b b b 32 but floats x3, y3, z3  point
// b b               zero bytes
// group repeated ntri times

// needs  datread.h  for type  dpts  and  datwrite
// typedef struct {float x; float y; float z;} dpts;
// int datwrite(char filename[], dpts * data_points, int num_points,
//              int * data_polys, int num_polys);

#include <stdio.h>
#include <stdlib.h>
#include "datread.h"

int main(int argc, char * argv[])
{
  union {int i; float f;} data;        
  //  data.i = 10;
  //  printf( "data.i : %d\n", data.i);
  //  data.f = 220.5;
  //  printf( "data.f : %f\n", data.f);
  char junk;
  int nvert, nv0, nv1, nv2, nv3 ;
  float nx, ny, nz; // normal
  int   nxi, nyi, nzi; // bytes

  float x1, y1, z1; // first vertex
  float x2, y2, z2; // second vertex
  float x3, y3, z3; // third vertex
  int is, ntri;
  FILE * fp;
  FILE * fpout;
  int num_points; // for datwrite
  int num_polys;  // for datwrite 
  int chk;  
  dpts data_points[10000]; // each has .x .y .z unique points
  int data_tri[10000][3]; // point index+1  x y z
  int data_polys[40000];  // 3 p1 p2 p3
  int i, p1, p2, p3;

  printf("stl_to_dat.c running \n");
  printf("reading, writing %s \n", argv[1], argv[2]);
  fp = fopen(argv[1], "rb");
  if(fp == NULL) {printf("can not open \n"); return 0;}
  printf("file opened reading 80 characters %s\n", argv[1]);
  fpout = fopen(argv[2], "w");
  if(fpout == NULL) {printf("can not open %s\n", argv[2]); return 0;}

  for(i=0; i<80; i++) junk = fgetc(fp);
  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("triangles to read %d %d %d %d \n", nv0, nv1, nv2, nv3);
  ntri = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  printf("ntri = %d \n", ntri);
  num_points = 0;
  num_polys = 0; // will be ntri

  for(is=0; is<ntri; is++) // ntri groups
  {

  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("nx bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  nx = data.f;
  printf("data.f = %f, nx = %f \n", data.f, nx); 

  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("ny bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  ny = data.f;
  printf("data.f = %f, ny = %f \n", data.f, ny); 

  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("nz bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  nz = data.f;
  printf("data.f = %f, nz = %f \n", data.f, nz); 

  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("x1 bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  x1 = data.f;
  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("y1 bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  y1 = data.f;
  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("z1 bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  z1 = data.f;

  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("x2 bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  x2 = data.f;
  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("y2 bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  y2 = data.f;
  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("z2 bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  z2 = data.f;

  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("x3 bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  x3 = data.f;
  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("y3 bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  y3 = data.f;
  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  nv2 = fgetc(fp);
  nv3 = fgetc(fp);
  printf("z3 bytes %d %d %d %d \n", nv0, nv1, nv2, nv3);
  data.i = nv3*256*256*256 + nv2*256*256 + nv1*256 +nv0;
  z3 = data.f;
  nv0 = fgetc(fp);
  nv1 = fgetc(fp);
  printf("2 bytes %d %d  \n", nv0, nv1);

  printf("facet normal %f %f %f\n", nx, ny, nx);
  printf("    vertex %f %f %f\n", x1, y1, z1);
  printf("    vertex %f %f %f\n", x2, y2, z2);
  printf("    vertex %f %f %f\n", x3, y3, z3);

  data_points[num_points].x = x1;
  data_points[num_points].y = y1;
  data_points[num_points].z = z1;
  p1 = num_points;
  num_points++;

  for(i=0; i<num_points; i++)
  {
    if(data_points[i].x == x1 &&
       data_points[i].y == y1 &&
       data_points[i].z == z1)
    {
      p1 = i;
      break;
    }
  }
  if(p1 != num_points-1) num_points--;
  printf("p1=%d  num_points=%d \n", p1, num_points);

  data_points[num_points].x = x2;
  data_points[num_points].y = y2;
  data_points[num_points].z = z2;
  p2 = num_points;
  num_points++;

  for(i=0; i<num_points; i++)
  {
    if(data_points[i].x == x2 &&
       data_points[i].y == y2 &&
       data_points[i].z == z2)
    {
      p2 = i;
      break;
    }
  }
  if(p2 != num_points-1) num_points--;
  printf("p2=%d  num_points=%d \n", p2, num_points);

  data_points[num_points].x = x3;
  data_points[num_points].y = y3;
  data_points[num_points].z = z3;
  p3 = num_points;
  num_points++;

  for(i=0; i<num_points; i++)
  {
    if(data_points[i].x == x3 &&
       data_points[i].y == y3 &&
       data_points[i].z == z3)
    {
      p3 = i;
      break;
    }
  }
  if(p3 != num_points-1) num_points--;
  printf("p3=%d  num_points=%d \n", p3, num_points);

  data_polys[num_polys++] = 3;
  data_polys[num_polys++] = p1+1;
  data_polys[num_polys++] = p2+1;
  data_polys[num_polys++] = p3+1;

  } // end is  for each triangle
  printf("finished reading\n");
  
  num_polys = num_polys/4;
  chk = datwrite(argv[2], data_points, num_points, data_polys, num_polys);
  printf("wrote %s \n", argv[2]);
  printf("stl_to_dat.c finished \n");
  return 0;
} // end stl_to_dat.c