/* datread.c  read and write Utah Graphics ASCII data *.dat of *.det */
/*            also clean so that normals work.                       */

#include "datread.h"  // defines  dpts
                      // typedef struct {float x; float y; float z;} dpts;

#undef abs
#define abs(x) (((x)<0.0)?(-(x)):(x))

int datread(char filename[], dpts * *data_points, int *num_points,
            int * *data_polys, int *num_polys, float *size)
{
  FILE * infile;    /* input file name, parameter */
  int i, j, k, pts, pt;
  char input_line[255];
  int debug = 0;
  
  *size = 0.0;
  if(debug) printf("datread open %s for reading\n", filename);
  infile = fopen(filename, "r");
  if(infile == NULL)
  {
    printf("could not open %s for reading\n", filename);
    return 1;
  }
  fgets(input_line, 254, infile);
  if(debug) printf("first line %s \n", input_line);
  if(!strncmp("data", input_line, 4))
  {
    sscanf(input_line, "data%d %d", num_points, num_polys);
  }
  else
  {
    sscanf(input_line, "%d %d", num_points, num_polys);
  }
  if(debug) printf("num_points=%d, num_polys=%d\n", *num_points, *num_polys);
  *data_points = (dpts *)malloc(sizeof(dpts)*(*num_points));
  *data_polys  = (int *)malloc(sizeof(int)*11*((*num_polys)+12));
                /* only room polys<=10 on average */
  if(*data_points == NULL || *data_polys == NULL)
  {
    printf("datread can not allocate enough space for data\n");
    return 1;
  }
  if(debug) printf("maxk = %d, allocated for polys\n", 6*(*num_polys)+10);
  for(i=0; i<*num_points; i++)
  {
    fgets(input_line, 254, infile);
    sscanf(input_line, "%f %f %f", &((*data_points)[i].x),
           &((*data_points)[i].y), &((*data_points)[i].z));
    if(debug) printf("i=%d, x=%f, y=%f, z=%f\n", i+1, (*data_points)[i].x,
                     (*data_points)[i].y, (*data_points)[i].z);
    if(abs((*data_points)[i].x)>*size) *size = abs((*data_points)[i].x);
    if(abs((*data_points)[i].y)>*size) *size = abs((*data_points)[i].y);
    if(abs((*data_points)[i].z)>*size) *size = abs((*data_points)[i].z);
  }
  if(debug) printf("scaling  size=%g\n", *size);
  /* set size = size * 1.2;  for spinning */
  /* set position[2] = 1.2*size; for spinning */

  /* use num_polys to read in surfaces */
  k = 0;
  for(i=0; i<*num_polys; i++)
  {
    fgets(input_line, 254, infile);
    sscanf(input_line, "%d", &pts);
    (*data_polys)[k] = pts;
    k += 1;
    if(debug) printf("poly of pts=%d\n", pts);
    if(pts==2)
    {
      sscanf(input_line, "%d %d %d", &pt, &((*data_polys)[k]),
             &((*data_polys)[k+1]) );
      if(debug) printf("poly %d %d %d\n", pt, (*data_polys)[k],
                       (*data_polys)[k+1]);
      k += 2;
    }
    if(pts==3)
    {
      sscanf(input_line, "%d %d %d %d", &pt, &((*data_polys)[k]),
             &((*data_polys)[k+1]), &((*data_polys)[k+2]));
      if(debug) printf("poly %d %d %d %d\n", pt, (*data_polys)[k],
                       (*data_polys)[k+1], (*data_polys)[k+2]);
      k += 3;
    }
    if(pts==4)
    {
      sscanf(input_line, "%d %d %d %d %d", &pt, &((*data_polys)[k]),
             &((*data_polys)[k+1]), &((*data_polys)[k+2]),
             &((*data_polys)[k+3]) );
      if(debug) printf("poly %d %d %d %d %d\n", pt, (*data_polys)[k],
                       (*data_polys)[k+1], (*data_polys)[k+2],
                       (*data_polys)[k+3]);
      k += 4;
    }
    if(pts==5)
    {
      sscanf(input_line, "%d %d %d %d %d %d", &pt, &((*data_polys)[k]),
             &((*data_polys)[k+1]), &((*data_polys)[k+2]),
             &((*data_polys)[k+3]), &((*data_polys)[k+4]) );
      if(debug) printf("poly %d %d %d %d %d %d\n", pt, (*data_polys)[k],
                       (*data_polys)[k+1], (*data_polys)[k+2],
                       (*data_polys)[k+3], (*data_polys)[k+4]);
      k += 5;
    }
    if(pts==6)
    {
      sscanf(input_line, "%d %d %d %d %d %d %d", &pt, &((*data_polys)[k]),
             &((*data_polys)[k+1]), &((*data_polys)[k+2]),
             &((*data_polys)[k+3]), &((*data_polys)[k+4]),
             &((*data_polys)[k+5]) );
      if(debug) printf("poly %d %d %d %d %d %d %d\n", pt, (*data_polys)[k],
                       (*data_polys)[k+1], (*data_polys)[k+2],
                       (*data_polys)[k+3], (*data_polys)[k+4],
                       (*data_polys)[k+5]);
      k += 6;
    }
    if(pts==7)
    {
      sscanf(input_line, "%d %d %d %d %d %d %d %d", &pt, &((*data_polys)[k]),
             &((*data_polys)[k+1]), &((*data_polys)[k+2]),
             &((*data_polys)[k+3]), &((*data_polys)[k+4]),
             &((*data_polys)[k+5]), &((*data_polys)[k+6]) );
      if(debug) printf("poly %d %d %d %d %d %d %d %d\n", pt, (*data_polys)[k],
                       (*data_polys)[k+1], (*data_polys)[k+2],
                       (*data_polys)[k+3], (*data_polys)[k+4],
                       (*data_polys)[k+5], (*data_polys)[k+6]);
      k += 7;
    }
    if(pts==8)
    {
      sscanf(input_line, "%d %d %d %d %d %d %d %d %d", &pt,
	     &((*data_polys)[k]),
             &((*data_polys)[k+1]), &((*data_polys)[k+2]),
             &((*data_polys)[k+3]), &((*data_polys)[k+4]),
             &((*data_polys)[k+5]), &((*data_polys)[k+6]),
	     &((*data_polys)[k+7]) );
      if(debug) printf("poly %d %d %d %d %d %d %d %d %d\n", pt,
		       (*data_polys)[k],
                       (*data_polys)[k+1], (*data_polys)[k+2],
                       (*data_polys)[k+3], (*data_polys)[k+4],
                       (*data_polys)[k+5], (*data_polys)[k+6],
		       (*data_polys)[k+7]);
      k += 8;
    }
    if(pts==9)
    {
      sscanf(input_line, "%d %d %d %d %d %d %d %d %d %d", &pt,
	     &((*data_polys)[k]),
             &((*data_polys)[k+1]), &((*data_polys)[k+2]),
             &((*data_polys)[k+3]), &((*data_polys)[k+4]),
             &((*data_polys)[k+5]), &((*data_polys)[k+6]),
	     &((*data_polys)[k+7]), &((*data_polys)[k+8]) );
      if(debug) printf("poly %d %d %d %d %d %d %d %d %d %d\n", pt,
		       (*data_polys)[k],
                       (*data_polys)[k+1], (*data_polys)[k+2],
                       (*data_polys)[k+3], (*data_polys)[k+4],
                       (*data_polys)[k+5], (*data_polys)[k+6],
		       (*data_polys)[k+7], (*data_polys)[k+8]);
      k += 9;
    }
    if(pts==10)
    {
      sscanf(input_line, "%d %d %d %d %d %d %d %d %d %d %d", &pt,
	     &((*data_polys)[k]),
             &((*data_polys)[k+1]), &((*data_polys)[k+2]),
             &((*data_polys)[k+3]), &((*data_polys)[k+4]),
             &((*data_polys)[k+5]), &((*data_polys)[k+6]),
	     &((*data_polys)[k+7]), &((*data_polys)[k+8]),
	     &((*data_polys)[k+9]) );
      if(debug) printf("poly %d %d %d %d %d %d %d %d %d %d %d\n", pt,
		       (*data_polys)[k],
                       (*data_polys)[k+1], (*data_polys)[k+2],
                       (*data_polys)[k+3], (*data_polys)[k+4],
                       (*data_polys)[k+5], (*data_polys)[k+6],
		       (*data_polys)[k+7], (*data_polys)[k+8],
		       (*data_polys)[k+9]);
      k += 10;
    }
    if(pts>10)
    {
      printf("datread.c fails with pts>10 \n");
      return 1;
    }

  }
  fclose(infile);
  return 0;
}  /* end datread */

int datwrite(char filename[], dpts * data_points, int num_points,
             int * data_polys, int num_polys)
{
  FILE * outfile;   /* output file name, parameter */
  int i, j, k, pts, pt;
  int debug = 0;

  if(debug) printf("open %s for writing\n", filename);
  outfile = fopen(filename, "w");
  if(outfile == NULL)
  {
    printf("could not open %s for writing\n", filename);
    return 1;
  }
  fprintf(outfile, "%d %d \n", num_points, num_polys);
  for(i=0; i<num_points; i++)
  {
    fprintf(outfile, "%f %f %f \n", data_points[i].x,
            data_points[i].y, data_points[i].z);
  }

  /* use num_polys to write out surfaces */
  k = 0;
  for(i=0; i<num_polys; i++)
  {
    pts = data_polys[k++];
    fprintf(outfile, "%d ", pts);
    for(j=0; j<pts; j++)
    {
      pt = data_polys[k++];
      fprintf(outfile, "%d ", pt);
    }
    fprintf(outfile,"\n");
  }
  fflush(outfile);
  fclose(outfile);
  return 0;
}  /* end datwrite */


int datclean(dpts * *data_points, int *num_points,
              int * *data_polys,  int *num_polys, float *size)
{
  int debug = 0;
  int num_pts, num_pys, num_tri;
  int i, j, k;
  float x, y, z, dx, dy, dz;
  int dup = 0;    /* count of duplicate points */
  int del = 0;    /* running number to delete */
  float close;    /* definition of close x to x */
  float gone = 1.0e+20; /* check on code */
  int *points;
  int *cpts;   /* clean points */
  int pts, pt;
  
  close = (*size)/1000.0; /* could be a parameter */
  num_pts = *num_points;
  num_pys = *num_polys; /* unchanged */
  
  /* allocate space for point renumber */
  points = (int *)malloc(sizeof(int)*(num_pts+1));
  cpts =   (int *)malloc(sizeof(int)*(num_pts+1));
  if((points==NULL) || (cpts==NULL))
  {
    printf("datclean could not allocate enough space for points\n");
    return 1;
  }
  for(i=0; i<=num_pts; i++) {points[i] = i; cpts[i]=i;} /* same point */

  k = 0;
  for(i=0; i<num_pts-1; i++)
  {
    if(points[i]!=i) continue;
    x = (*data_points)[i].x;
    y = (*data_points)[i].y;
    z = (*data_points)[i].z;
    for(j=i+1; j<num_pts; j++)
    {
      if(points[j]!=j) continue;
      dx = (*data_points)[j].x - x;
      dy = (*data_points)[j].y - y;
      dz = (*data_points)[j].z - z;
      
      if(abs(dx)<close && abs(dy)<close && abs(dz)<close)
      {
        dup++;
        if(debug)
          printf("i=%d, j=%d, x=%f, y=%f, z=%f\ndx=%f, dy=%f, dz=%f\n",
                 i, j, x, y, z, dx, dy, dz);
        points[j]=i;
        (*data_points)[j].x = gone;
        (*data_points)[j].y = gone;
        (*data_points)[j].z = gone;
      }
    }
  }
  if(dup==0)
  {
    printf("no redundant points \n");
    return 1;
  }
  else
  {
    printf("%d redundant points removed from %d points\n",
           dup, num_pts);
    *num_points = num_pts-dup; /* send back to caller */
  }
  
  /* squeeze points */
  j = 0;
  del = 0;
  for(i=0; i<num_pts; i++)
  {
    (*data_points)[i-del] = (*data_points)[i];
    cpts[i] = i-del; /* where old data point is now */
    if(points[i]!=i) del++;
  }

  /* fix polys with index+1 */
  if(debug) for(i=0; i<num_pts; i++)
            {
              printf("i=%d, points[i]=%d, cts[i]=%d \n",
                     i, points[i], cpts[i]); 
            }

  k = 0;
  for(i=0; i<num_pys; i++)
  {
    pts = (*data_polys)[k++];
    for(j=0; j<pts; j++)
    {
      pt = (*data_polys)[k]-1;
      (*data_polys)[k] = cpts[points[pt]]+1;
      k++;
    }
  }
  
  return 0;
} /* end datclean */


int datccw(dpts * *data_points, int *num_points,
           int * *data_polys,  int *num_polys)
{
  int debug = 0;
  int num_pts, num_pys, num_tri;
  int i, j, k;
  float x, y, z, dx, dy, dz;
  int points[100]; /* assume 100 points max per polygon */
  int pts, pt;
  
  num_pts = *num_points; /* unchanged */
  num_pys = *num_polys; /* unchanged */
  
  k = 0;
  for(i=0; i<num_pys; i++)
  {
    pts = (*data_polys)[k++];
    for(j=0; j<pts; j++)
    {
      pt = (*data_polys)[k++];
      points[j] = pt;
    }
    /* k is past last point */
    for(j=0; j<pts; j++)
    {
      (*data_polys)[k-j-1] = points[j];
    }
  }
  
  return 0;
} /* end datccw */


void datprint(dpts * data_points, int num_points,
              int * data_polys, int num_polys)
{
  int i, j, k, pts;
    
  printf("number of points:   %d \n", num_points);
  printf("number of polygons: %d \n", num_polys);
  printf("subtract 1 from point number to get 'C' subscript \n\n");
  for(i=0; i<num_points; i++)
  {
      printf("point %d : %f  %f  %f\n", i+1, data_points[i].x, 
              data_points[i].y, data_points[i].z);
  } 
  printf("\n");
  k = 0;
  for(i=0; i<num_polys; i++)
  {
    pts = data_polys[k++];
    printf("poly %d : num pts = %d \n        ", i, pts);                 
    for (j=0; j<pts; j++)
    {
      printf(" %d ", data_polys[k++]);
    }
    printf("\n");
  }
} /* end datprint */