$search

mesh.hh

Go to the documentation of this file.

#ifndef MESH_HH
#define MESH_HH

/*
  James R. Diebel
  Stanford University
  
  Started: 23 August 2004
  Last revised: 27 Sugust 2004

  mesh.hh - defines Mesh class that stores an arbitrary triangular mesh with
  various per-vertex, per-face, and per-edge properties; uses pointers to
  encode connectivity information.

  Depends on:
  - Vert class (vert.hh)
  -- Vec3d class (vec3d.hh)
  - Edge class (edge.hh)
  - Face class (face.hh)

  There is no functionality for resizing the mesh, although vertices and faces
  may be flagged as inactive to effectively delete them.
*/

#include <fstream>
#include <vector>
#include "region.hh"
#include "vert.hh"
#include "edge.hh"
#include "face.hh"
#include "timer.hh"
#include "uspline.hh"

namespace bmtk {

using namespace std;

class Mesh {
public:
  // Data
  char* filename; // filename associated with this mesh
  int nv,ne,nf,nr,nn;  // #'s of things
  int nd; // number of datasets with same topology
  Vert* v; // global vertex list
  Edge* e; // global edge list
  Face* f; // global face list
  Region* r; // global region list;
  int* q; // a buffer of size nf used as a flood-fill queue
  int* qv; // similarly, a queue buffer, but for vertices, not faces

  Vec3d boxMin, boxMax; // bounding box
  float box; // scale of the bounding box
  float l; // global length scale - median edge length

  float psi; // global mesh potential
  float psiVert; // only the vertex part of the global potential
  float psiEdge; // only the edge part of the global potential
  float normGradPsi; // norm of gradient over entire mesh
  float normDir; // norm of current direction vector
  float rho[2]; // scaling factors for computing conjugate directions
  int iter; // CG iteration number
  int nStepsForReset; // number of CG iterations before reset
  int wroteIter; // last iteration that was written
  int maxIter; // maximum number of iterations to run

  USpline* psiSpline; // spline representation of edge potential function

  bool ib; // include boundary regions in computations
  bool po; // print output to screen
  float gs2; // global scaling factor for vertex variance
  float gsn2; // global variance for edge potential
  float segThresh; // threshold used in segmentation algorithm

  // Tools
  ofstream foutConv;
  bool ut; // use timer or not
  Timer *tCG;
  Timer *tLS;
  Timer *tMP;
  Timer *tVG;
  Timer *tFN;
  void (*callBack)();
  int callBackExists;

  // Methods
  // constructor, destructor, destructor tool
  Mesh();
  ~Mesh();
  void cleanUp();

  // callback for refreshing GUI
  void registerCB(void (*callBack_)(void));
  void update();

  // functions to set global properties
  void setVertVar(float gs2_);
  void setNormalVar(float gsn2_);

  // general mesh properties
  void findBBox();
  void normalize();
  void findLength();
  Mesh* pruneFaces(float factor);
  void findMeshProps();
  void reset();
  void findMeshPotential();
  void findPotentials();
  void doBisectionLineSearch();
  void doNewtonLineSearch();
  void runCG();
  void anneal();
  void writeConvDetails();

  // per face properties
  void findFaceNormals();
  void findFaceCenters();
  void findFaceDistances();
  void findFaceAreas();
  void findFaceProps();
  void saveRefNormals();
  void blurFaceNormals(int num);
  void resetFaceFlags();

  // per edge properties
  void findEdgeLengths();
  void findEdgeAngles();
  void findEdgeProps();
  void findEdgePotentials();
  void resetEdgeFlags();

  // per vertex properties
  void resetVertFlags();
  void findVertNormals();
  void findVertLengths();
  void findVertProps();
  void findVertDepths();
  void findVertPotentials();
  void findLocalEdgePotentials();
  void findVertGradients();
  void findVertCurvature();
  void findNormGradPsi();
  void findSearchDirs(bool reset = false);
  void saveRefVerts();
  void moveVerts(float step);
  void moveVerts();
  void vertFaceConsistency(int num);

  // region functions
  void clearRegionProps();
  void findRegionFaceLists();
  void findRegionProps();
  void findRegionNormals();
  void findRegionSmoothNormals();
  void findRegionSmoothNormalsOld();
  void findRegionProjDist();
  void findRegionVariances();
  void renumberRegions();
  void doSegmentationStep();
  void runSegmentation();
  void swapFace(Face& fi, Region& ri, Region& rj);
  void mergeRegions(Region& ri, Region& rj, Face& fi);
  void findBoundaries();
  void markKeypoints();
  void traceBoundary(Vert* vi, Edge* ei, Face* fi, Region* ri);
  void triangulateContours();
  Mesh* genDecimatedMesh();

  // I/O functions
  void exportToPLY(char* plyfile);
  void buildFromPLY(char* plyfile);
  void buildFromMAP(char* mapfile, char* intfile);
  void buildFromGTS(char* plyfile);
  void buildFromLST(char* listfile);
  void exportToTMF(char* tmffile);
  void exportRegions(char* regfile);
  void importRegions(char* regfile);
  void buildFromTMF(char* tmffile);
  void buildFromOFF(char* offfile);
  void applyLineOfSightCovar(float sr);
  vector<int> buildFrom(float* vert, int numvert, 
                        int* faces, int numfaces);
  void fillVertsAndFaces(float* vertices, int numverts, 
                         int* faces, int numfaces);
  int findInterFaceLinks();
  int readOptions(char *filename);
  int writeOptions(char *filename);
  int writeMesh(char *filename);
  int readMesh(char *filename);

  // Equality tests
  bool operator == (const Mesh &m) const;
  bool operator != (const Mesh &m) const;
};

} // namespace bmtk

#endif

---

bmtk
Author(s): Benjamin Pitzer
autogenerated on Mon Mar 4 11:05:51 2013