admesh 0.1.0

data/ext/admesh/admesh/src/stlinit.c

@@ -0,0 +1,377 @@
+/*  ADMesh -- process triangulated solid meshes
+ *  Copyright (C) 1995, 1996  Anthony D. Martin <amartin@engr.csulb.edu>
+ *  Copyright (C) 2013, 2014  several contributors, see AUTHORS
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Questions, comments, suggestions, etc to
+ *           https://github.com/admesh/admesh/issues
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "stl.h"
+
+#if !defined(SEEK_SET)
+#define SEEK_SET 0
+#define SEEK_CUR 1
+#define SEEK_END 2
+#endif
+
+void
+stl_open(stl_file *stl, char *file) {
+  stl_initialize(stl);
+  stl_count_facets(stl, file);
+  stl_allocate(stl);
+  stl_read(stl, 0, 1);
+  if (!stl->error) fclose(stl->fp);
+}
+
+
+void
+stl_initialize(stl_file *stl) {
+  stl->error = 0;
+  stl->stats.backwards_edges = 0;
+  stl->stats.degenerate_facets = 0;
+  stl->stats.edges_fixed  = 0;
+  stl->stats.facets_added = 0;
+  stl->stats.facets_removed = 0;
+  stl->stats.facets_reversed = 0;
+  stl->stats.normals_fixed = 0;
+  stl->stats.number_of_parts = 0;
+  stl->stats.original_num_facets = 0;
+  stl->stats.number_of_facets = 0;
+  stl->stats.facets_malloced = 0;
+  stl->stats.volume = -1.0;
+
+  stl->neighbors_start = NULL;
+  stl->facet_start = NULL;
+  stl->v_indices = NULL;
+  stl->v_shared = NULL;
+}
+
+void
+stl_count_facets(stl_file *stl, char *file) {
+  long           file_size;
+  int            header_num_facets;
+  int            num_facets;
+  int            i, j;
+  size_t         s;
+  unsigned char  chtest[128];
+  int            num_lines = 1;
+  char           *error_msg;
+
+  if (stl->error) return;
+
+  /* Open the file in binary mode first */
+  stl->fp = fopen(file, "rb");
+  if(stl->fp == NULL) {
+    error_msg = (char*)
+                malloc(81 + strlen(file)); /* Allow 80 chars+file size for message */
+    sprintf(error_msg, "stl_initialize: Couldn't open %s for reading",
+            file);
+    perror(error_msg);
+    free(error_msg);
+    stl->error = 1;
+    return;
+  }
+  /* Find size of file */
+  fseek(stl->fp, 0, SEEK_END);
+  file_size = ftell(stl->fp);
+
+  /* Check for binary or ASCII file */
+  fseek(stl->fp, HEADER_SIZE, SEEK_SET);
+  if (!fread(chtest, sizeof(chtest), 1, stl->fp)) {
+    perror("The input is an empty file");
+    stl->error = 1;
+    return;
+  }
+  stl->stats.type = ascii;
+  for(s = 0; s < sizeof(chtest); s++) {
+    if(chtest[s] > 127) {
+      stl->stats.type = binary;
+      break;
+    }
+  }
+  rewind(stl->fp);
+
+  /* Get the header and the number of facets in the .STL file */
+  /* If the .STL file is binary, then do the following */
+  if(stl->stats.type == binary) {
+    /* Test if the STL file has the right size  */
+    if(((file_size - HEADER_SIZE) % SIZEOF_STL_FACET != 0)
+        || (file_size < STL_MIN_FILE_SIZE)) {
+      fprintf(stderr, "The file %s has the wrong size.\n", file);
+      stl->error = 1;
+      return;
+    }
+    num_facets = (file_size - HEADER_SIZE) / SIZEOF_STL_FACET;
+
+    /* Read the header */
+    if (fread(stl->stats.header, LABEL_SIZE, 1, stl->fp) > 79) {
+      stl->stats.header[80] = '\0';
+    }
+
+    /* Read the int following the header.  This should contain # of facets */
+    if((!fread(&header_num_facets, sizeof(int), 1, stl->fp)) || (num_facets != header_num_facets)) {
+      fprintf(stderr,
+              "Warning: File size doesn't match number of facets in the header\n");
+    }
+  }
+  /* Otherwise, if the .STL file is ASCII, then do the following */
+  else {
+    /* Reopen the file in text mode (for getting correct newlines on Windows) */
+    if (freopen(file, "r", stl->fp) == NULL) {
+      perror("Could not reopen the file, something went wrong");
+      stl->error = 1;
+      return;
+    }
+
+    /* Find the number of facets */
+    j = 0;
+    for(i = 0; i < file_size ; i++) {
+      j++;
+      if(getc(stl->fp) == '\n') {
+        if(j > 4) { /* don't count short lines */
+          num_lines++;
+        }
+        j = 0;
+      }
+    }
+    rewind(stl->fp);
+
+    /* Get the header */
+    for(i = 0;
+        (i < 80) && (stl->stats.header[i] = getc(stl->fp)) != '\n'; i++);
+    stl->stats.header[i] = '\0'; /* Lose the '\n' */
+    stl->stats.header[80] = '\0';
+
+    num_facets = num_lines / ASCII_LINES_PER_FACET;
+  }
+  stl->stats.number_of_facets += num_facets;
+  stl->stats.original_num_facets = stl->stats.number_of_facets;
+}
+
+void
+stl_allocate(stl_file *stl) {
+  if (stl->error) return;
+
+  /*  Allocate memory for the entire .STL file */
+  stl->facet_start = (stl_facet*)calloc(stl->stats.number_of_facets,
+                                        sizeof(stl_facet));
+  if(stl->facet_start == NULL) perror("stl_initialize");
+  stl->stats.facets_malloced = stl->stats.number_of_facets;
+
+  /* Allocate memory for the neighbors list */
+  stl->neighbors_start = (stl_neighbors*)
+                         calloc(stl->stats.number_of_facets, sizeof(stl_neighbors));
+  if(stl->facet_start == NULL) perror("stl_initialize");
+}
+
+void
+stl_open_merge(stl_file *stl, char *file_to_merge) {
+  int num_facets_so_far;
+  stl_type origStlType;
+  FILE *origFp;
+  stl_file stl_to_merge;
+
+  if (stl->error) return;
+
+  /* Record how many facets we have so far from the first file.  We will start putting
+     facets in the next position.  Since we're 0-indexed, it'l be the same position. */
+  num_facets_so_far = stl->stats.number_of_facets;
+
+  /* Record the file type we started with: */
+  origStlType=stl->stats.type;
+  /* Record the file pointer too: */
+  origFp=stl->fp;
+
+  /* Initialize the sturucture with zero stats, header info and sizes: */
+  stl_initialize(&stl_to_merge);
+  stl_count_facets(&stl_to_merge, file_to_merge);
+
+  /* Copy what we need to into stl so that we can read the file_to_merge directly into it
+     using stl_read:  Save the rest of the valuable info: */
+  stl->stats.type=stl_to_merge.stats.type;
+  stl->fp=stl_to_merge.fp;
+
+  /* Add the number of facets we already have in stl with what we we found in stl_to_merge but
+     haven't read yet. */
+  stl->stats.number_of_facets=num_facets_so_far+stl_to_merge.stats.number_of_facets;
+
+  /* Allocate enough room for stl->stats.number_of_facets facets and neighbors: */
+  stl_reallocate(stl);
+
+  /* Read the file to merge directly into stl, adding it to what we have already.
+     Start at num_facets_so_far, the index to the first unused facet.  Also say
+     that this isn't our first time so we should augment stats like min and max
+     instead of erasing them. */
+  stl_read(stl, num_facets_so_far, 0);
+
+  /* Restore the stl information we overwrote (for stl_read) so that it still accurately
+     reflects the subject part: */
+  stl->stats.type=origStlType;
+  stl->fp=origFp;
+}
+
+extern void
+stl_reallocate(stl_file *stl) {
+  if (stl->error) return;
+  /*  Reallocate more memory for the .STL file(s) */
+  stl->facet_start = (stl_facet*)realloc(stl->facet_start, stl->stats.number_of_facets *
+                                         sizeof(stl_facet));
+  if(stl->facet_start == NULL) perror("stl_initialize");
+  stl->stats.facets_malloced = stl->stats.number_of_facets;
+
+  /* Reallocate more memory for the neighbors list */
+  stl->neighbors_start = (stl_neighbors*)
+                         realloc(stl->neighbors_start, stl->stats.number_of_facets *
+                                 sizeof(stl_neighbors));
+  if(stl->facet_start == NULL) perror("stl_initialize");
+}
+
+
+/* Reads the contents of the file pointed to by stl->fp into the stl structure,
+   starting at facet first_facet.  The second argument says if it's our first
+   time running this for the stl and therefore we should reset our max and min stats. */
+void
+stl_read(stl_file *stl, int first_facet, int first) {
+  stl_facet facet;
+  int   i;
+
+  if (stl->error) return;
+
+  if(stl->stats.type == binary) {
+    fseek(stl->fp, HEADER_SIZE, SEEK_SET);
+  } else {
+    rewind(stl->fp);
+    /* Skip the first line of the file */
+    while(getc(stl->fp) != '\n');
+  }
+
+  for(i = first_facet; i < stl->stats.number_of_facets; i++) {
+    if(stl->stats.type == binary)
+      /* Read a single facet from a binary .STL file */
+    {
+      /* we assume little-endian architecture! */
+      if (fread(&facet.normal, sizeof(stl_normal), 1, stl->fp) \
+          + fread(&facet.vertex, sizeof(stl_vertex), 3, stl->fp) \
+          + fread(&facet.extra, sizeof(char), 2, stl->fp) != 6) {
+        perror("Cannot read facet");
+        stl->error = 1;
+        return;
+      }
+    } else
+      /* Read a single facet from an ASCII .STL file */
+    {
+      if((fscanf(stl->fp, "%*s %*s %f %f %f\n", &facet.normal.x, &facet.normal.y, &facet.normal.z) + \
+          fscanf(stl->fp, "%*s %*s") + \
+          fscanf(stl->fp, "%*s %f %f %f\n", &facet.vertex[0].x, &facet.vertex[0].y,  &facet.vertex[0].z) + \
+          fscanf(stl->fp, "%*s %f %f %f\n", &facet.vertex[1].x, &facet.vertex[1].y,  &facet.vertex[1].z) + \
+          fscanf(stl->fp, "%*s %f %f %f\n", &facet.vertex[2].x, &facet.vertex[2].y,  &facet.vertex[2].z) + \
+          fscanf(stl->fp, "%*s") + \
+          fscanf(stl->fp, "%*s")) != 12) {
+        perror("Something is syntactically very wrong with this ASCII STL!");
+        stl->error = 1;
+        return;
+      }
+    }
+    /* Write the facet into memory. */
+    stl->facet_start[i] = facet;
+
+    stl_facet_stats(stl, facet, first);
+    first = 0;
+  }
+  stl->stats.size.x = stl->stats.max.x - stl->stats.min.x;
+  stl->stats.size.y = stl->stats.max.y - stl->stats.min.y;
+  stl->stats.size.z = stl->stats.max.z - stl->stats.min.z;
+  stl->stats.bounding_diameter = sqrt(
+                                   stl->stats.size.x * stl->stats.size.x +
+                                   stl->stats.size.y * stl->stats.size.y +
+                                   stl->stats.size.z * stl->stats.size.z
+                                 );
+}
+
+void
+stl_facet_stats(stl_file *stl, stl_facet facet, int first) {
+  float diff_x;
+  float diff_y;
+  float diff_z;
+  float max_diff;
+
+  if (stl->error) return;
+
+  /* while we are going through all of the facets, let's find the  */
+  /* maximum and minimum values for x, y, and z  */
+
+  /* Initialize the max and min values the first time through*/
+  if (first) {
+    stl->stats.max.x = facet.vertex[0].x;
+    stl->stats.min.x = facet.vertex[0].x;
+    stl->stats.max.y = facet.vertex[0].y;
+    stl->stats.min.y = facet.vertex[0].y;
+    stl->stats.max.z = facet.vertex[0].z;
+    stl->stats.min.z = facet.vertex[0].z;
+
+    diff_x = ABS(facet.vertex[0].x - facet.vertex[1].x);
+    diff_y = ABS(facet.vertex[0].y - facet.vertex[1].y);
+    diff_z = ABS(facet.vertex[0].z - facet.vertex[1].z);
+    max_diff = STL_MAX(diff_x, diff_y);
+    max_diff = STL_MAX(diff_z, max_diff);
+    stl->stats.shortest_edge = max_diff;
+
+    first = 0;
+  }
+
+  /* now find the max and min values */
+  stl->stats.max.x = STL_MAX(stl->stats.max.x, facet.vertex[0].x);
+  stl->stats.min.x = STL_MIN(stl->stats.min.x, facet.vertex[0].x);
+  stl->stats.max.y = STL_MAX(stl->stats.max.y, facet.vertex[0].y);
+  stl->stats.min.y = STL_MIN(stl->stats.min.y, facet.vertex[0].y);
+  stl->stats.max.z = STL_MAX(stl->stats.max.z, facet.vertex[0].z);
+  stl->stats.min.z = STL_MIN(stl->stats.min.z, facet.vertex[0].z);
+
+  stl->stats.max.x = STL_MAX(stl->stats.max.x, facet.vertex[1].x);
+  stl->stats.min.x = STL_MIN(stl->stats.min.x, facet.vertex[1].x);
+  stl->stats.max.y = STL_MAX(stl->stats.max.y, facet.vertex[1].y);
+  stl->stats.min.y = STL_MIN(stl->stats.min.y, facet.vertex[1].y);
+  stl->stats.max.z = STL_MAX(stl->stats.max.z, facet.vertex[1].z);
+  stl->stats.min.z = STL_MIN(stl->stats.min.z, facet.vertex[1].z);
+
+  stl->stats.max.x = STL_MAX(stl->stats.max.x, facet.vertex[2].x);
+  stl->stats.min.x = STL_MIN(stl->stats.min.x, facet.vertex[2].x);
+  stl->stats.max.y = STL_MAX(stl->stats.max.y, facet.vertex[2].y);
+  stl->stats.min.y = STL_MIN(stl->stats.min.y, facet.vertex[2].y);
+  stl->stats.max.z = STL_MAX(stl->stats.max.z, facet.vertex[2].z);
+  stl->stats.min.z = STL_MIN(stl->stats.min.z, facet.vertex[2].z);
+}
+
+void
+stl_close(stl_file *stl) {
+  if (stl->error) return;
+
+  if(stl->neighbors_start != NULL)
+    free(stl->neighbors_start);
+  if(stl->facet_start != NULL)
+    free(stl->facet_start);
+  if(stl->v_indices != NULL)
+    free(stl->v_indices);
+  if(stl->v_shared != NULL)
+    free(stl->v_shared);
+}
+

data/ext/admesh/admesh/src/util.c

@@ -0,0 +1,557 @@
+/*  ADMesh -- process triangulated solid meshes
+ *  Copyright (C) 1995, 1996  Anthony D. Martin <amartin@engr.csulb.edu>
+ *  Copyright (C) 2013, 2014  several contributors, see AUTHORS
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation; either version 2 of the License, or
+ *  (at your option) any later version.
+
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+
+ *  You should have received a copy of the GNU General Public License along
+ *  with this program; if not, write to the Free Software Foundation, Inc.,
+ *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ *
+ *  Questions, comments, suggestions, etc to
+ *           https://github.com/admesh/admesh/issues
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+
+#include "stl.h"
+
+static void stl_rotate(float *x, float *y, float angle);
+static float get_area(stl_facet *facet);
+static float get_volume(stl_file *stl);
+
+
+void
+stl_verify_neighbors(stl_file *stl) {
+  int i;
+  int j;
+  stl_edge edge_a;
+  stl_edge edge_b;
+  int neighbor;
+  int vnot;
+
+  if (stl->error) return;
+
+  stl->stats.backwards_edges = 0;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      edge_a.p1 = stl->facet_start[i].vertex[j];
+      edge_a.p2 = stl->facet_start[i].vertex[(j + 1) % 3];
+      neighbor = stl->neighbors_start[i].neighbor[j];
+      vnot = stl->neighbors_start[i].which_vertex_not[j];
+
+      if(neighbor == -1)
+        continue;		/* this edge has no neighbor... Continue. */
+      if(vnot < 3) {
+        edge_b.p1 = stl->facet_start[neighbor].vertex[(vnot + 2) % 3];
+        edge_b.p2 = stl->facet_start[neighbor].vertex[(vnot + 1) % 3];
+      } else {
+        stl->stats.backwards_edges += 1;
+        edge_b.p1 = stl->facet_start[neighbor].vertex[(vnot + 1) % 3];
+        edge_b.p2 = stl->facet_start[neighbor].vertex[(vnot + 2) % 3];
+      }
+      if(memcmp(&edge_a, &edge_b, SIZEOF_EDGE_SORT) != 0) {
+        /* These edges should match but they don't.  Print results. */
+        printf("edge %d of facet %d doesn't match edge %d of facet %d\n",
+               j, i, vnot + 1, neighbor);
+        stl_write_facet(stl, (char*)"first facet", i);
+        stl_write_facet(stl, (char*)"second facet", neighbor);
+      }
+    }
+  }
+}
+
+void
+stl_translate(stl_file *stl, float x, float y, float z) {
+  int i;
+  int j;
+
+  if (stl->error) return;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      stl->facet_start[i].vertex[j].x -= (stl->stats.min.x - x);
+      stl->facet_start[i].vertex[j].y -= (stl->stats.min.y - y);
+      stl->facet_start[i].vertex[j].z -= (stl->stats.min.z - z);
+    }
+  }
+  stl->stats.max.x -= (stl->stats.min.x - x);
+  stl->stats.max.y -= (stl->stats.min.y - y);
+  stl->stats.max.z -= (stl->stats.min.z - z);
+  stl->stats.min.x = x;
+  stl->stats.min.y = y;
+  stl->stats.min.z = z;
+
+  stl_invalidate_shared_vertices(stl);
+}
+
+/* Translates the stl by x,y,z, relatively from wherever it is currently */
+void
+stl_translate_relative(stl_file *stl, float x, float y, float z) {
+  int i;
+  int j;
+
+  if (stl->error) return;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      stl->facet_start[i].vertex[j].x += x;
+      stl->facet_start[i].vertex[j].y += y;
+      stl->facet_start[i].vertex[j].z += z;
+    }
+  }
+  stl->stats.min.x += x;
+  stl->stats.min.y += y;
+  stl->stats.min.z += z;
+  stl->stats.max.x += x;
+  stl->stats.max.y += y;
+  stl->stats.max.z += z;
+
+  stl_invalidate_shared_vertices(stl);
+}
+
+void
+stl_scale_versor(stl_file *stl, float versor[3]) {
+  int i;
+  int j;
+
+  if (stl->error) return;
+
+  /* scale extents */
+  stl->stats.min.x *= versor[0];
+  stl->stats.min.y *= versor[1];
+  stl->stats.min.z *= versor[2];
+  stl->stats.max.x *= versor[0];
+  stl->stats.max.y *= versor[1];
+  stl->stats.max.z *= versor[2];
+
+  /* scale size */
+  stl->stats.size.x *= versor[0];
+  stl->stats.size.y *= versor[1];
+  stl->stats.size.z *= versor[2];
+
+  /* scale volume */
+  if (stl->stats.volume > 0.0) {
+    stl->stats.volume *= (versor[0] * versor[1] * versor[2]);
+  }
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      stl->facet_start[i].vertex[j].x *= versor[0];
+      stl->facet_start[i].vertex[j].y *= versor[1];
+      stl->facet_start[i].vertex[j].z *= versor[2];
+    }
+  }
+
+  stl_invalidate_shared_vertices(stl);
+}
+
+void
+stl_scale(stl_file *stl, float factor) {
+  float versor[3];
+
+  if (stl->error) return;
+
+  versor[0] = factor;
+  versor[1] = factor;
+  versor[2] = factor;
+  stl_scale_versor(stl, versor);
+}
+
+static void calculate_normals(stl_file *stl) {
+  long i;
+  float normal[3];
+
+  if (stl->error) return;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    stl_calculate_normal(normal, &stl->facet_start[i]);
+    stl_normalize_vector(normal);
+    stl->facet_start[i].normal.x = normal[0];
+    stl->facet_start[i].normal.y = normal[1];
+    stl->facet_start[i].normal.z = normal[2];
+  }
+}
+
+void
+stl_rotate_x(stl_file *stl, float angle) {
+  int i;
+  int j;
+
+  if (stl->error) return;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      stl_rotate(&stl->facet_start[i].vertex[j].y,
+                 &stl->facet_start[i].vertex[j].z, angle);
+    }
+  }
+  stl_get_size(stl);
+  calculate_normals(stl);
+}
+
+void
+stl_rotate_y(stl_file *stl, float angle) {
+  int i;
+  int j;
+
+  if (stl->error) return;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      stl_rotate(&stl->facet_start[i].vertex[j].z,
+                 &stl->facet_start[i].vertex[j].x, angle);
+    }
+  }
+  stl_get_size(stl);
+  calculate_normals(stl);
+}
+
+void
+stl_rotate_z(stl_file *stl, float angle) {
+  int i;
+  int j;
+
+  if (stl->error) return;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      stl_rotate(&stl->facet_start[i].vertex[j].x,
+                 &stl->facet_start[i].vertex[j].y, angle);
+    }
+  }
+  stl_get_size(stl);
+  calculate_normals(stl);
+}
+
+
+
+static void
+stl_rotate(float *x, float *y, float angle) {
+  double r;
+  double theta;
+  double radian_angle;
+
+  radian_angle = (angle / 180.0) * M_PI;
+
+  r = sqrt((*x **x) + (*y **y));
+  theta = atan2(*y, *x);
+  *x = r * cos(theta + radian_angle);
+  *y = r * sin(theta + radian_angle);
+}
+
+extern void
+stl_get_size(stl_file *stl) {
+  int i;
+  int j;
+
+  if (stl->error) return;
+  if (stl->stats.number_of_facets == 0) return;
+
+  stl->stats.min.x = stl->facet_start[0].vertex[0].x;
+  stl->stats.min.y = stl->facet_start[0].vertex[0].y;
+  stl->stats.min.z = stl->facet_start[0].vertex[0].z;
+  stl->stats.max.x = stl->facet_start[0].vertex[0].x;
+  stl->stats.max.y = stl->facet_start[0].vertex[0].y;
+  stl->stats.max.z = stl->facet_start[0].vertex[0].z;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      stl->stats.min.x = STL_MIN(stl->stats.min.x,
+                                 stl->facet_start[i].vertex[j].x);
+      stl->stats.min.y = STL_MIN(stl->stats.min.y,
+                                 stl->facet_start[i].vertex[j].y);
+      stl->stats.min.z = STL_MIN(stl->stats.min.z,
+                                 stl->facet_start[i].vertex[j].z);
+      stl->stats.max.x = STL_MAX(stl->stats.max.x,
+                                 stl->facet_start[i].vertex[j].x);
+      stl->stats.max.y = STL_MAX(stl->stats.max.y,
+                                 stl->facet_start[i].vertex[j].y);
+      stl->stats.max.z = STL_MAX(stl->stats.max.z,
+                                 stl->facet_start[i].vertex[j].z);
+    }
+  }
+  stl->stats.size.x = stl->stats.max.x - stl->stats.min.x;
+  stl->stats.size.y = stl->stats.max.y - stl->stats.min.y;
+  stl->stats.size.z = stl->stats.max.z - stl->stats.min.z;
+  stl->stats.bounding_diameter = sqrt(
+                                   stl->stats.size.x * stl->stats.size.x +
+                                   stl->stats.size.y * stl->stats.size.y +
+                                   stl->stats.size.z * stl->stats.size.z
+                                 );
+}
+
+void
+stl_mirror_xy(stl_file *stl) {
+  int i;
+  int j;
+  float temp_size;
+
+  if (stl->error) return;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      stl->facet_start[i].vertex[j].z *= -1.0;
+    }
+  }
+  temp_size = stl->stats.min.z;
+  stl->stats.min.z = stl->stats.max.z;
+  stl->stats.max.z = temp_size;
+  stl->stats.min.z *= -1.0;
+  stl->stats.max.z *= -1.0;
+  stl_reverse_all_facets(stl);
+  stl->stats.facets_reversed -= stl->stats.number_of_facets;  /* for not altering stats */
+}
+
+void
+stl_mirror_yz(stl_file *stl) {
+  int i;
+  int j;
+  float temp_size;
+
+  if (stl->error) return;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      stl->facet_start[i].vertex[j].x *= -1.0;
+    }
+  }
+  temp_size = stl->stats.min.x;
+  stl->stats.min.x = stl->stats.max.x;
+  stl->stats.max.x = temp_size;
+  stl->stats.min.x *= -1.0;
+  stl->stats.max.x *= -1.0;
+  stl_reverse_all_facets(stl);
+  stl->stats.facets_reversed -= stl->stats.number_of_facets;  /* for not altering stats */
+}
+
+void
+stl_mirror_xz(stl_file *stl) {
+  int i;
+  int j;
+  float temp_size;
+
+  if (stl->error) return;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    for(j = 0; j < 3; j++) {
+      stl->facet_start[i].vertex[j].y *= -1.0;
+    }
+  }
+  temp_size = stl->stats.min.y;
+  stl->stats.min.y = stl->stats.max.y;
+  stl->stats.max.y = temp_size;
+  stl->stats.min.y *= -1.0;
+  stl->stats.max.y *= -1.0;
+  stl_reverse_all_facets(stl);
+  stl->stats.facets_reversed -= stl->stats.number_of_facets;  /* for not altering stats */
+}
+
+static float get_volume(stl_file *stl) {
+  long i;
+  stl_vertex p0;
+  stl_vertex p;
+  stl_normal n;
+  float height;
+  float area;
+  float volume = 0.0;
+
+  if (stl->error) return 0;
+
+  /* Choose a point, any point as the reference */
+  p0.x = stl->facet_start[0].vertex[0].x;
+  p0.y = stl->facet_start[0].vertex[0].y;
+  p0.z = stl->facet_start[0].vertex[0].z;
+
+  for(i = 0; i < stl->stats.number_of_facets; i++) {
+    p.x = stl->facet_start[i].vertex[0].x - p0.x;
+    p.y = stl->facet_start[i].vertex[0].y - p0.y;
+    p.z = stl->facet_start[i].vertex[0].z - p0.z;
+    /* Do dot product to get distance from point to plane */
+    n = stl->facet_start[i].normal;
+    height = (n.x * p.x) + (n.y * p.y) + (n.z * p.z);
+    area = get_area(&stl->facet_start[i]);
+    volume += (area * height) / 3.0;
+  }
+  return volume;
+}
+
+void stl_calculate_volume(stl_file *stl) {
+  if (stl->error) return;
+  stl->stats.volume = get_volume(stl);
+}
+
+static float get_area(stl_facet *facet) {
+  double cross[3][3];
+  float sum[3];
+  float n[3];
+  float area;
+  int i;
+
+  /* cast to double before calculating cross product because large coordinates
+     can result in overflowing product
+    (bad area is responsible for bad volume and bad facets reversal) */
+  for(i = 0; i < 3; i++) {
+    cross[i][0]=(((double)facet->vertex[i].y * (double)facet->vertex[(i + 1) % 3].z) -
+                 ((double)facet->vertex[i].z * (double)facet->vertex[(i + 1) % 3].y));
+    cross[i][1]=(((double)facet->vertex[i].z * (double)facet->vertex[(i + 1) % 3].x) -
+                 ((double)facet->vertex[i].x * (double)facet->vertex[(i + 1) % 3].z));
+    cross[i][2]=(((double)facet->vertex[i].x * (double)facet->vertex[(i + 1) % 3].y) -
+                 ((double)facet->vertex[i].y * (double)facet->vertex[(i + 1) % 3].x));
+  }
+
+  sum[0] = cross[0][0] + cross[1][0] + cross[2][0];
+  sum[1] = cross[0][1] + cross[1][1] + cross[2][1];
+  sum[2] = cross[0][2] + cross[1][2] + cross[2][2];
+
+  /* This should already be done.  But just in case, let's do it again */
+  stl_calculate_normal(n, facet);
+  stl_normalize_vector(n);
+
+  area = 0.5 * (n[0] * sum[0] + n[1] * sum[1] + n[2] * sum[2]);
+  return area;
+}
+
+void stl_repair(stl_file *stl,
+                int fixall_flag,
+                int exact_flag,
+                int tolerance_flag,
+                float tolerance,
+                int increment_flag,
+                float increment,
+                int nearby_flag,
+                int iterations,
+                int remove_unconnected_flag,
+                int fill_holes_flag,
+                int normal_directions_flag,
+                int normal_values_flag,
+                int reverse_all_flag,
+                int verbose_flag) {
+  
+  int i;
+  int last_edges_fixed = 0;
+
+  if (stl->error) return;
+
+  if(exact_flag || fixall_flag || nearby_flag || remove_unconnected_flag
+      || fill_holes_flag || normal_directions_flag) {
+    if (verbose_flag)
+      printf("Checking exact...\n");
+    exact_flag = 1;
+    stl_check_facets_exact(stl);
+    stl->stats.facets_w_1_bad_edge =
+      (stl->stats.connected_facets_2_edge -
+       stl->stats.connected_facets_3_edge);
+    stl->stats.facets_w_2_bad_edge =
+      (stl->stats.connected_facets_1_edge -
+       stl->stats.connected_facets_2_edge);
+    stl->stats.facets_w_3_bad_edge =
+      (stl->stats.number_of_facets -
+       stl->stats.connected_facets_1_edge);
+  }
+
+  if(nearby_flag || fixall_flag) {
+    if(!tolerance_flag) {
+      tolerance = stl->stats.shortest_edge;
+    }
+    if(!increment_flag) {
+      increment = stl->stats.bounding_diameter / 10000.0;
+    }
+
+    if(stl->stats.connected_facets_3_edge < stl->stats.number_of_facets) {
+      for(i = 0; i < iterations; i++) {
+        if(stl->stats.connected_facets_3_edge <
+            stl->stats.number_of_facets) {
+          if (verbose_flag)
+            printf("\
+Checking nearby. Tolerance= %f Iteration=%d of %d...",
+                 tolerance, i + 1, iterations);
+          stl_check_facets_nearby(stl, tolerance);
+          if (verbose_flag)
+            printf("  Fixed %d edges.\n",
+                 stl->stats.edges_fixed - last_edges_fixed);
+          last_edges_fixed = stl->stats.edges_fixed;
+          tolerance += increment;
+        } else {
+          if (verbose_flag)
+            printf("\
+All facets connected.  No further nearby check necessary.\n");
+          break;
+        }
+      }
+    } else {
+      if (verbose_flag)
+        printf("All facets connected.  No nearby check necessary.\n");
+    }
+  }
+
+  if(remove_unconnected_flag || fixall_flag || fill_holes_flag) {
+    if(stl->stats.connected_facets_3_edge <  stl->stats.number_of_facets) {
+      if (verbose_flag)
+        printf("Removing unconnected facets...\n");
+      stl_remove_unconnected_facets(stl);
+    } else
+      if (verbose_flag)
+        printf("No unconnected need to be removed.\n");
+  }
+
+  if(fill_holes_flag || fixall_flag) {
+    if(stl->stats.connected_facets_3_edge <  stl->stats.number_of_facets) {
+      if (verbose_flag)
+        printf("Filling holes...\n");
+      stl_fill_holes(stl);
+    } else
+      if (verbose_flag)
+        printf("No holes need to be filled.\n");
+  }
+
+  if(reverse_all_flag) {
+    if (verbose_flag)
+      printf("Reversing all facets...\n");
+    stl_reverse_all_facets(stl);
+  }
+
+  if(normal_directions_flag || fixall_flag) {
+    if (verbose_flag)
+      printf("Checking normal directions...\n");
+    stl_fix_normal_directions(stl);
+  }
+
+  if(normal_values_flag || fixall_flag) {
+    if (verbose_flag)
+      printf("Checking normal values...\n");
+    stl_fix_normal_values(stl);
+  }
+
+  /* Always calculate the volume.  It shouldn't take too long */
+  if (verbose_flag)
+    printf("Calculating volume...\n");
+  stl_calculate_volume(stl);
+
+  if(fixall_flag) {
+    if(stl->stats.volume < 0.0) {
+      if (verbose_flag)
+        printf("Reversing all facets because volume is negative...\n");
+      stl_reverse_all_facets(stl);
+      stl->stats.volume = -stl->stats.volume;
+    }
+  }
+
+  if(exact_flag) {
+    if (verbose_flag)
+      printf("Verifying neighbors...\n");
+    stl_verify_neighbors(stl);
+  }
+}