$search

trimesh.h

Go to the documentation of this file.

#ifndef TRIMESH_H
#define TRIMESH_H

/*
  Szymon Rusinkiewicz
  Stanford Graphics Lab

  trimesh.h
  A triangle mesh, including various properties...

  Note that most of this stuff is not allocated when the object is first created,
  so if you want to use anything besides vertices and faces, you need to call
  need_normals() or whatever...
*/

#include "triutil.h"
#include <vector>
using std::vector;

namespace trimesh {

// Miscellaneous data types
typedef unsigned char color[3];
typedef float conf;
typedef float point[3];
typedef float vec[3];
typedef int face[3];
typedef float quat[4];
typedef int edge[2];

// The TriMesh class
class TriMesh {
 public:
  // Vertices and per-vertex properties
  int numvertices;
  point *vertices;
  point *verticesorig;
  point *verticesref;
  color *colors;
  conf *confidences;
  vec *normals;
  float *localpotentials;
  vec *planeparams;
  vec *facemeans;
  vec *planeparamsorig;
  int *faceregions;
  int numfaceregions;
  int *faceregionredirect;
  int *faceregionpopulations;
  vec *faceregionnormals;
  float *faceregionprojdist;
  float *faceregionsumdev2;
  float *areas;
  float minarea,maxarea,meanarea;

  // Faces and tstrips
  int numfaces;
  face *faces;
  vec *facenormals;
  vec *facenormalsorig;
  vec *facenormalsref;
  typedef float *facekappalist;
  facekappalist *facekappas;
  typedef int *facecenterlist;
  facecenterlist *facecenters;

  int tstripdatalen;
  int *tstrips;

  // Bounding box and sphere
  struct BBox {
    float xmin, xmax, ymin, ymax, zmin, zmax;
    float xlen, ylen, zlen;
  };
  BBox *bbox;

  struct BSphere {
    point center;
    float r;
  };
  BSphere *bsphere;

  // Connectivity information - neighbors and vertex->face mappings
  typedef int *neighborlist;
  neighborlist *neighbors;
  int *numneighbors;
  int *onedge;
  int *outlier;
  int numoutliers;
  point zero_point;
  int minneighbors;
  int maxneighbors;

  typedef int *adjacentfacelist;
  adjacentfacelist *adjacentfaces;
  typedef int *neighboringfacelist;
  neighboringfacelist *neighboringfaces;
  typedef edge *neighboringedgelist;
  neighboringedgelist *neighboringedges;
  typedef float *neighboringedgelengthlist;
  neighboringedgelengthlist *neighboringedgelengths;
        
  int *numneighboringfaces;
  int *numadjacentfaces;
  int minadjacentfaces;
  int maxadjacentfaces;

  // Edge lengths
  void transform(double M[4][4]);
  void scale(double sx, double sy, double sz);
  float minedgelength();
  float maxedgelength();
  float rmsedgelength(bool random_sample = true);
  float meanedgelength(bool random_sample = true);
  float medianedgelength(bool random_sample = true);
  float percentileedgelength(float percentile = 0.5, bool random_sample = true);


  // Smooth per-vertex normals
  void SmoothNormals(float smooth);

  // Remove vertices and/or faces
  void RemoveVertices(const vector<bool> &toremove);
  void RemoveUnusedVertices();
  void RemoveFaces(const vector<bool> &toremove);

  // .ply file input and output
  static bool IsPlyFile(const char *plyfile);
  static TriMesh *ReadPly(const char *plyfile);
  void WritePly(const char *plyfile); 

 private:
  // Private functions to compute various stuff
  void FindBBox();
  void FindBSphere();
  void FindTStrips();
  void UnpackTStrips();
  int Tstrip_Next_Tri(int tri, int v1, int v2, bool flip);
  int Tstrip_Next_Vert(int next, int vlast1, int vlast2);
  void Tstrip_Crawl(int v1, int v2, int v3, int next);
  void Tstrip_Bootstrap(int tri);

 public:
  // The public interface to the above:  checks whether
  // the needed info already exists and computes it if it doesn't
  void FindNormals();
  void FindAreas();
  void FindNeighbors();
  void FindAdjacentFaces();
  void need_faces() { if (!faces && tstrips) UnpackTStrips(); }
  void need_normals() { if (!normals) FindNormals(); }
  void need_neighbors() { if (!neighbors) FindNeighbors(); }
  void need_adjacentfaces() { if (!adjacentfaces) FindAdjacentFaces(); }
  void need_bbox() { if (!bbox) FindBBox(); }
  void need_bsphere() { if (!bsphere) FindBSphere(); }
  void need_tstrips() { if (!tstrips) FindTStrips(); }
  void need_colors() { if (!colors && numvertices) colors = new color[numvertices]; }
  void need_confidences() { if (!confidences && numvertices) confidences = new conf[numvertices]; }

  // The counterparts to the above - free the storage associated with
  // various quantities
  void free_confidences() { if (confidences) { delete [] confidences; confidences = NULL; } }
  void free_colors() { if (colors) { delete [] colors; colors = NULL; } }
  void free_tstrips()
    {
      if (tstrips) {
        delete [] tstrips;
        tstrips = NULL;
      }
      tstripdatalen = 0;
    }
  void free_bsphere() { if (bsphere) { delete bsphere; bsphere = NULL; } }
  void free_bbox() { if (bbox) { delete bbox; bbox = NULL; } }
  void free_adjacentfaces()
    {
      int i;
      if (adjacentfaces) {
        for (i=0; i < numvertices; i++)
          delete [] adjacentfaces[i];
        delete [] adjacentfaces;
        for (i=0;i<numfaces;i++) {
          delete [] neighboringfaces[i];
          delete [] facekappas[i];
          delete [] facecenters[i];
          delete [] neighboringedges[i];
          delete [] neighboringedgelengths[i];
        }
        delete [] facekappas;
        delete [] facecenters;
        delete [] neighboringfaces;
        delete [] neighboringedges;
        delete [] neighboringedgelengths;
        delete [] numadjacentfaces;
        delete [] numneighboringfaces;
        adjacentfaces = NULL;
      }
      minadjacentfaces = maxadjacentfaces = 0;
    }
  void free_neighbors()
    {
      if (neighbors) {
        for (int i=0; i < numvertices; i++) {
          delete [] neighbors[i];
        }
        delete [] neighbors;
        delete [] numneighbors;
        delete [] onedge;
        delete [] outlier;
        neighbors = NULL;
      }
      minneighbors = maxneighbors = 0;
    }
  void free_normals() { 
    if (normals) { 
      delete [] normals; 
      normals = NULL;
      delete [] areas;
      delete [] planeparams; 
      planeparams = NULL; 
      delete [] planeparamsorig; 
      planeparamsorig = NULL; 
      delete [] facenormals;
      facenormals = NULL;
      delete [] facenormalsorig;
      facenormalsorig = NULL;
      delete [] facemeans;
      facemeans = NULL;
      delete [] facenormalsref;
      delete [] faceregions;
      delete [] faceregionredirect;
      delete [] faceregionnormals;
      delete [] faceregionprojdist;
      delete [] faceregionpopulations;
      delete [] faceregionsumdev2;
    }
  }
  void free_faces()
    {
      if (faces) {
        delete [] faces;
        faces = NULL;
      }
      numfaces = 0;
    }
  void free_vertices()
    {
      if (vertices) {
        delete [] vertices;
        delete [] verticesorig;
        delete [] verticesref;
        delete [] localpotentials;
        vertices = NULL;
      }
      numvertices = 0;
    }

  // Constructor and destructor
  TriMesh(int _numvertices = 0, int _numfaces = 0) :
    numvertices(_numvertices), vertices(NULL),
    numfaces(_numfaces), faces(NULL),
    normals(NULL),
    neighbors(NULL), numneighbors(NULL),
    minneighbors(0), maxneighbors(0),
    adjacentfaces(NULL), numadjacentfaces(NULL),
    minadjacentfaces(0), maxadjacentfaces(0),
    bbox(NULL), bsphere(NULL),
    tstrips(NULL), tstripdatalen(0),
    colors(NULL), confidences(NULL)
    {
      zero_point[0]=0;zero_point[1]=0;zero_point[2]=0;
      if (numvertices) {
        vertices = new point[numvertices];
        verticesorig = new point[numvertices];
        verticesref = new point[numvertices];
        localpotentials = new float[numvertices];
      }
      if (numfaces) {
        faces = new face[numfaces];
      }
    }

  ~TriMesh()
    {
      free_confidences();
      free_colors();
      free_tstrips();
      free_bsphere();
      free_bbox();
      free_adjacentfaces();
      free_neighbors();
      free_normals();
      free_faces();
      free_vertices();
    }
};

} // namespace trimesh

#endif

---

trimesh
Author(s): Benjamin Pitzer
autogenerated on Mon Mar 4 11:05:50 2013