Mesh Class Reference

#include <Mesh.h>

List of all members.

---

Detailed Description

Implementation of the half edge datastructure.

Definition at line 20 of file Mesh.h.

Public Types
typedef std::multiset< Edge *, Mesh::edge_comp >	EdgeSet
typedef std::vector< Face * >	FaceSet
typedef std::vector< Vertex * >	VertexSet
Public Member Functions
	Mesh (void)
	~Mesh (void)
void	clear ()
Vertex *	addVertex (const Vector3 &p)
Face *	addFace (std::vector< int > faceVerts)
Edge *	addEdge (int i, int j)
Edge *	addEdge (Edge *e)
bool	cutAlongEdge (Edge *forward)
	Cuts the mesh along single edge while maintaining all the connectivity of the mesh.
Vertex *	vertexAt (int i)
Face *	faceAt (int i)
int	numFaces ()
int	numVertices ()
int	numEdges ()
int	numBoundary ()
void	linkBoundary ()
	Called after the mesh is created to link boundary edges.
bool	checkManifold ()
	Manifoldness check: only one disk should be adjusted on any vertex.
bool	checkVertexConection ()
	Check if all the vertices in the mesh have at least on edge coming out of them.
void	checkGaussianCurvature ()
	Compute total Gaussian curvature that cone singularities allow and check if it satisfy Gauss-Bonet theorem.
void	computeMeshInfo ()
	Computes number of connected components, number of boundary loops and genus of the mesh.
void	computeLengths ()
	Compute edge lengths based on vertex positions.
void	computeInitAngles ()
	Compute initial alpha angles in the mesh.
void	readOBJ (const char *obj_file)
	Loads mesh from obj file.
void	readCON (const char *conn_file)
	Loads mesh from con (connectivity and edge length) file.
void	readCONE_VERT (const char *vert_file)
	Reads cone singularities allowed by the user.
void	readCUT_EDGES (const char *edge_file)
	Reads edge cuts from the input file and cuts the mesh over those edges.
void	writeOBJ (const char *obj_file)
void	writeVT (const char *vt_file)
void	writeCON (const char *conn_file)
	Write out the result parameterization in "connectivity" format.
void	finishMesh ()
FaceIterator	faceIterator ()
VertexIterator	vertexIterator ()
HalfEdgeIterator	halfEdgeIterator ()
EdgeIterator	edgeIterator ()
Public Attributes
int	numBoundaryVertices
	Number of vertices (or also edges) at the boundary of the mesh.
int	numBoundaryLoops
	Number of boundary loops in the mesh.
int	numConnectedComponents
	Number of connected components.
int	numGenus
	Genus of the mesh.
Private Attributes
std::vector< Vertex * >	vertices
std::vector< Face * >	faces
std::multiset< Edge *, Mesh::edge_comp >	edges
Classes
struct	edge_comp
	Comparison functions for edge sets. More...
class	EdgeIterator
class	FaceIterator
class	HalfEdgeIterator
class	VertexIterator

---

Member Typedef Documentation

typedef std::multiset<Edge*, Mesh::edge_comp> Mesh::EdgeSet

Definition at line 63 of file Mesh.h.

typedef std::vector<Face *> Mesh::FaceSet

Definition at line 64 of file Mesh.h.

typedef std::vector<Vertex *> Mesh::VertexSet

Definition at line 65 of file Mesh.h.

---

Constructor & Destructor Documentation

Mesh::Mesh (  void   )

Definition at line 16 of file Mesh.cpp. { numBoundaryVertices = 0; }

Mesh::~Mesh (  void   )

Definition at line 21 of file Mesh.cpp. { clear(); }

---

Member Function Documentation

Edge* Mesh::addEdge (  Edge *  e  )  [inline]

Definition at line 74 of file Mesh.h. { edges.insert(e); return e; }

Edge * Mesh::addEdge (  int  i, int  j )

Definition at line 91 of file Mesh.cpp. { Edge eTmp; eTmp.vertex = vertices[i]; Edge eTmpPair; eTmpPair.vertex = vertices[j]; eTmp.pair = &eTmpPair; Mesh::EdgeSet::iterator eIn = edges.find(&eTmp); Edge * e; if (eIn != edges.end()){ e = *eIn; if (e->face != NULL) return NULL; } else { e = new Edge(); Edge * pair = new Edge(); e->vertex = vertices[i]; pair->vertex = vertices[j]; pair->pair = e; e->pair = pair; edges.insert(e); edges.insert(pair); pair->vertex->edge = pair; } return e; }

Face * Mesh::addFace (  std::vector< int >  faceVerts  )

Definition at line 53 of file Mesh.cpp. { Face * f = new Face(); f->ID = (int)faces.size(); Edge * firstEdge = NULL; Edge * last = NULL; Edge * current = NULL; unsigned int i; for (i = 0; i < faceVerts.size()-1; i++) { current = addEdge(faceVerts[i], faceVerts[i+1]); check_error (!current, "Problem while parsing mesh faces."); current->face = f; if (last) last->next = current; else firstEdge = current; last = current; } current = addEdge (faceVerts[i], faceVerts[0]); check_error (!current, "Problem while parsing mesh faces."); current->face = f; last->next = current; current->next = firstEdge; f->edge = firstEdge; faces.push_back(f); return f; }

Vertex * Mesh::addVertex (  const Vector3 &  p  )

Definition at line 45 of file Mesh.cpp. { Vertex * v = new Vertex(); v->p = _p; v->ID = (int)vertices.size(); vertices.push_back(v); return v; }

void Mesh::checkGaussianCurvature (   )

Compute total Gaussian curvature that cone singularities allow and check if it satisfy Gauss-Bonet theorem. Definition at line 711 of file Mesh.cpp. { double minConeGC = 0; double maxConeGC = 0; for (int i = 0; i < numVertices(); i++) { if (vertices[i]->constrained) { if (vertices[i]->isBoundary()) { maxConeGC += (M_PI - vertices[i]->min_cone_angle*M_PI); minConeGC += (M_PI - vertices[i]->max_cone_angle*M_PI); } else { maxConeGC += (2*M_PI - vertices[i]->min_cone_angle*M_PI); minConeGC += (2*M_PI - vertices[i]->max_cone_angle*M_PI); } } else if (vertices[i]->isBoundary()) { maxConeGC += M_PI; minConeGC += -M_PI;; } } double eNum1 = minConeGC / (2*M_PI); double eNum2 = maxConeGC / (2*M_PI); double eNumCurr = (double)(2 - 2*numGenus - numBoundaryLoops)/(double)numConnectedComponents; cout << "Checking Gauss-Bonet Theorem:" << endl; cout << "Minimum euler number for this set up is " << eNum1 << endl; cout << "Maximum euler number for this set up is " << eNum2 << endl; cout << "Euler number of the mesh is " << eNumCurr << "\n" << endl; check_warn((eNumCurr < eNum1) || (eNumCurr > eNum2), "The mesh cannot be developed with current set of cone singularities.\n"); }

bool Mesh::checkManifold (   )

Manifoldness check: only one disk should be adjusted on any vertex. Definition at line 324 of file Mesh.cpp. { Mesh::HalfEdgeIterator eIter = halfEdgeIterator(); Mesh::VertexIterator vIter = vertexIterator(); bool manifold = true; for (;!eIter.end(); eIter++) eIter.half_edge()->check = false; for (vIter.reset(); !vIter.end(); vIter++) { Vertex::EdgeAroundIterator around = vIter.vertex()->iterator(); for (;!around.end();around++) around.edge_out()->check = true; } for (eIter.reset(); !eIter.end(); eIter++) { if (!eIter.half_edge()->check) { cerr << "Mesh is not manifold - more then one disk at vertex " << eIter.half_edge()->vertex->ID << endl; manifold = false; break; } } return manifold; }

bool Mesh::checkVertexConection (   )

Check if all the vertices in the mesh have at least on edge coming out of them. Definition at line 300 of file Mesh.cpp. { Mesh::FaceIterator fIter = faceIterator(); Mesh::VertexIterator vIter = vertexIterator(); bool conectedVert = true; for (;!vIter.end(); vIter++) vIter.vertex()->check = false; for (fIter.reset(); !fIter.end(); fIter++) { Face::EdgeAroundIterator around = fIter.face()->iterator(); for (;!around.end();around++) around.vertex()->check = true; } for (vIter.reset(); !vIter.end(); vIter++) { if (!vIter.vertex()->check) { cerr << "Vertex " << vIter.vertex()->ID << " is not connected." << endl; conectedVert = false; } } return conectedVert; }

void Mesh::clear (   )

Definition at line 26 of file Mesh.cpp. { VertexIterator vIter = vertexIterator(); FaceIterator fIter = faceIterator(); HalfEdgeIterator eIter = halfEdgeIterator(); while (!vIter.end()) { delete vIter.vertex(); vIter++; } while (!fIter.end()) { delete fIter.face(); fIter++; } while (!eIter.end()) { delete eIter.half_edge(); eIter++; } }

void Mesh::computeInitAngles (   )

Compute initial alpha angles in the mesh. This function assumes that the mesh is triangular. Alpha angels are stored at each edge and correspond to an angle opposite to this edge. Definition at line 356 of file Mesh.cpp. { Mesh::HalfEdgeIterator eIter = halfEdgeIterator(); for (; !eIter.end(); eIter++) { Edge * e = eIter.half_edge(); if (e->face) { double l1 = e->length; double l2 = e->next->length; double l3 = e->next->next->length; e->alphaOposite = acos((l2*l2 + l3*l3 - l1*l1)/(2.0*l2*l3)); } else { e->alphaOposite = 0; } } for (eIter.reset(); !eIter.end(); eIter++) { Edge * e = eIter.half_edge(); e->setTheta(M_PI - e->alphaOposite - e->pair->alphaOposite); } }

void Mesh::computeLengths (   )

Compute edge lengths based on vertex positions. Definition at line 202 of file Mesh.cpp. { for (Mesh::EdgeIterator eIter = edgeIterator(); !eIter.end(); eIter++) { Edge * e = eIter.edge(); e->length = (e->vertex->p - e->next->vertex->p).abs(); e->pair->length = e->length; } }

void Mesh::computeMeshInfo (   )

Computes number of connected components, number of boundary loops and genus of the mesh. Uses variation of Euler Formula: V - E + F = 2 (c - g) Where V - number of vertices. E - number of edges. F - number of faces. c - number of connected components. Definition at line 245 of file Mesh.cpp. { cout << "Topological information about the mesh:" << endl; // Number of boundary loops Mesh::HalfEdgeIterator hIter = halfEdgeIterator(); for (; !hIter.end(); hIter++) { hIter.half_edge()->check = false; } numBoundaryLoops = 0; for (hIter.reset(); !hIter.end(); hIter++) { Edge * e = hIter.half_edge(); if (e->face) e->check = true; else if (!e->check) { Edge * beg = NULL; while (e != beg) { if (!beg) beg = e; check_error(!e, "Building the mesh failed, probem with input format."); e->check = true; e = e->next; } numBoundaryLoops++; } } cout << "Mesh has " << numBoundaryLoops << " boundary loops." << endl; // Number of connected components numConnectedComponents = 0; Mesh::FaceIterator fIter = faceIterator(); for (; !fIter.end(); fIter++) { fIter.face()->check = false; } stack<Edge *> toVisit; for (fIter.reset(); !fIter.end(); fIter++) { if (!fIter.face()->check) { numConnectedComponents++; toVisit.push(fIter.face()->edge); while (!toVisit.empty()) { Face * fIn = toVisit.top()->face; toVisit.pop(); fIn->check = true; Face::EdgeAroundIterator iter = fIn->iterator(); for (; !iter.end(); iter++) if (iter.edge()->pair->face && !iter.edge()->pair->face->check) toVisit.push(iter.edge()->pair); } } } cout << "Mesh has " << numConnectedComponents << " connected components." << endl; // Genus number check_error(numConnectedComponents == 0, "The mesh read is empty."); numGenus = (1 - (numVertices() - numEdges() + numFaces() + numBoundaryLoops ) / 2) / numConnectedComponents; cout << "Mesh is genus " << numGenus << "." << endl; }

bool Mesh::cutAlongEdge (  Edge *  forward  )

Cuts the mesh along single edge while maintaining all the connectivity of the mesh. Returns false if the mesh is boundary or NULL. Note that after the mesh the cut is done, the sorting order of edges in the set is not updated. This could be done after all the cuts are performed. Definition at line 134 of file Mesh.cpp. { if (!forward) return false; if (forward->isBoundary()) return false; Edge * backward = forward->pair; Edge * backwardPair = new Edge(); Edge * forwardPair = new Edge(); backwardPair->pair = backward; forwardPair->pair = forward; backwardPair->assignData(*backward); forwardPair->assignData(*forward); Vertex * v = forward->vertex; Vertex * endV = backward->vertex; if (v->isBoundary()) { Vertex * newV = addVertex(v->p); newV->assignData(*v); Vertex::EdgeAroundIterator aroundV = v->iterator(forward); do { aroundV++; aroundV.vertex() = newV; } while (aroundV.edge_out()->pair->face); forwardPair->next = aroundV.edge_out()->pair->next; aroundV.edge_out()->pair->next = backwardPair; backwardPair->vertex = newV; newV->edge = backwardPair; } else { forwardPair->next = backwardPair; backwardPair->vertex = v; v->edge = backwardPair; } if (endV->isBoundary()) { Vertex * newV = addVertex(endV->p); newV->assignData(*endV); Vertex::EdgeAroundIterator aroundV = endV->iterator(backward); do { aroundV++; aroundV.vertex() = newV; } while (aroundV.edge_out()->pair->face); backwardPair->next = aroundV.edge_out()->pair->next; aroundV.edge_out()->pair->next = forwardPair; forwardPair->vertex = newV; newV->edge = forwardPair; } else { backwardPair->next = forwardPair; forwardPair->vertex = endV; endV->edge = forwardPair; } forward->pair = forwardPair; backward->pair = backwardPair; return (addEdge(forwardPair) && addEdge(backwardPair)); }

EdgeIterator Mesh::edgeIterator (   )  [inline]

Definition at line 277 of file Mesh.h. {return EdgeIterator(&edges);}

Face* Mesh::faceAt (  int  i  )  [inline]

Definition at line 82 of file Mesh.h. {return faces[i];}

FaceIterator Mesh::faceIterator (   )  [inline]

Definition at line 274 of file Mesh.h. {return FaceIterator(&faces);}

void Mesh::finishMesh (   )  [inline]

Definition at line 116 of file Mesh.h. { linkBoundary(); checkManifold(); checkVertexConection(); std::cout << "*--------------------*" << std::endl; std::cout << "* Faces: " << numFaces() << std::endl; std::cout << "* Edges: " << numEdges() << std::endl; std::cout << "* Vertices: " << numVertices() << std::endl; std::cout << "*--------------------*\n" << std::endl; }

HalfEdgeIterator Mesh::halfEdgeIterator (   )  [inline]

Definition at line 276 of file Mesh.h. {return HalfEdgeIterator(&edges);}

void Mesh::linkBoundary (   )

Called after the mesh is created to link boundary edges. Definition at line 211 of file Mesh.cpp. { HalfEdgeIterator hIter = halfEdgeIterator(); for (; !hIter.end(); hIter++) { if (!hIter.half_edge()->face) hIter.half_edge()->vertex->edge = hIter.half_edge(); } VertexIterator vIter = vertexIterator(); Edge *next, *beg; while (!vIter.end()) { if (vIter.vertex()->isBoundary()) { beg = vIter.vertex()->edge; next = beg; while (beg->pair->face) beg = beg->pair->next; beg = beg->pair; beg->next = next; numBoundaryVertices++; } vIter++; } }

int Mesh::numBoundary (   )  [inline]

Definition at line 87 of file Mesh.h. { return numBoundaryVertices; }

int Mesh::numEdges (   )  [inline]

Definition at line 86 of file Mesh.h. { return (int)edges.size()/2; }

int Mesh::numFaces (   )  [inline]

Definition at line 84 of file Mesh.h. { return (int)faces.size(); }

int Mesh::numVertices (   )  [inline]

Definition at line 85 of file Mesh.h. { return (int)vertices.size(); }

void Mesh::readCON (  const char *  conn_file  )

Loads mesh from con (connectivity and edge length) file. Format for CON file is int (number of vertices) int (number of faces) f int int int double double double f int int int double double double Where first double in each line if edge length from first vertex to second one, second double is edge length from second vertex to the third one, and the third double is an edge length from third vertex to the first one. Definition at line 528 of file Mesh.cpp. { string front; string v = "v", f = "f"; Vector3 vert; vector<int> verts; int id; ifstream in(conn_file); check_error(!in, "Cannot find input obj file."); int NumFaces, NumVertices; in >> NumVertices; in >> NumFaces; for (int i = 0; i < NumVertices; i++) { addVertex(vert); } while(!in.eof() || in.peek() != EOF) { in >> ws; if (in.eof() || in.peek() == EOF) break; if (in.peek() == '#') { in.ignore(300, '\n'); } else { in >> front; if (front == f) { verts.clear(); for (int i = 0; i < 3; i++) { in >> id; check_error(id > numVertices(), "Problem with input CON file."); verts.push_back(id-1); } in.clear(in.rdstate() & ~ios::failbit); Face * f = addFace(verts); for (Face::EdgeAroundIterator e = f->iterator(); !e.end(); e++) { in >> e.edge()->length; } } else { string line; getline(in, line); cout << "Warning, line: " << line << " ignored." << endl; } } } in.close(); // Finnish building the mesh, should be called after each parse. finishMesh(); }

void Mesh::readCONE_VERT (  const char *  vert_file  )

Reads cone singularities allowed by the user. Format of the file is list of follwing lines: vertex_id min_val_for_singularity max_val_for_singularity Values for singularities are expected as multiples of Pi. Minimum and maximum values for singularities can be equal. Definition at line 684 of file Mesh.cpp. { ifstream in(vert_file); check_error(!in, "Cannot find input file for cone singularities."); int id = 0; double minC = 0, maxC = 0; while (in >> id) { in >> minC >> maxC; if ((id < 0) || (id >= numVertices())) cout << "ID of a vertex in the cone singularities file is out of bounds." << endl; else { id--; double valenceAlow = (double)vertices[id]->getValence(); check_warn ( maxC <=0, "Invalid cone angle. Cone angle read is less or equal to zero."); check_warn ( minC >= valenceAlow, "Invalid cone angle. Cone angle read is greater or equal to what valence of vertex allows."); vertices[id]->min_cone_angle = minC; vertices[id]->max_cone_angle = maxC; vertices[id]->constrained = true; } } }

void Mesh::readCUT_EDGES (  const char *  edge_file  )

Reads edge cuts from the input file and cuts the mesh over those edges. Format of the file is list of the follwing lines: vert_from_id vert__to_id face The information in the file is somewhat redundant, but as we allow for non-regular meshes, there are might be two half edges with same end points). After the mesh is cut it should be a set of developable surfaces, so that UV coordinates can be assigned properly. Definition at line 624 of file Mesh.cpp. { ifstream in(edge_file); check_error(!in, "Cannot find input file for edge cuts."); vector<Edge *> edges_to_cut; int i, j, f; while (in >> i) { in >> j >> f; if ((i < 0) || (i >= numVertices()) || (j < 0) || (j >= numVertices())) cout << "ID of a vertex in the edges to cut file is out of bounds." << endl; else { i--; j--; f--; Edge eTmp; eTmp.vertex = vertices[i]; Edge eTmpPair; eTmpPair.vertex = vertices[j]; eTmp.pair = &eTmpPair; eTmpPair.pair = &eTmp; Edge * e = NULL; Mesh::EdgeSet::iterator eIn = edges.find(&eTmp); if (eIn != edges.end()) e = *eIn; while (eIn != edges.end()) { if ((*eIn)->face && (*eIn)->face->ID == f) { e = *eIn; break; } eIn++; } if (e) edges_to_cut.push_back(e); } } while (!edges_to_cut.empty()) { Edge * e = edges_to_cut.back(); if (e) { cutAlongEdge(e); } edges_to_cut.pop_back(); } EdgeSet newedges(edges.begin(), edges.end()); edges = newedges; }

void Mesh::readOBJ (  const char *  obj_file  )

Loads mesh from obj file. Standard format for OBJ file is v double double double v double double double f int int int f int int int Files with vt tags also can be parsed Definition at line 390 of file Mesh.cpp. { string front; string v = "v", vt = "vt", f = "f"; Vector3 vert; vector<int> verts; vector<Vector3> uvVec; vector<int> uvs; char etc; int id; ifstream in(obj_file); check_error(!in, "Cannot find input obj file."); bool hasUV = false; while(!in.eof() || in.peek() != EOF) { in >> ws; if (in.eof() || in.peek() == EOF) break; if (in.peek() == '#') { in.ignore(300, '\n'); } else { in >> front; if (front == v) { in >> vert.x() >> vert.y() >> vert.z(); addVertex(vert); } else if (front == vt){ in >> vert.x() >> vert.y(); vert.z() = 0; uvVec.push_back(vert); hasUV = true; } else if (front == f) { verts.clear(); uvs.clear(); while (in >> id) { check_error(id > numVertices(), "Problem with input OBJ file."); verts.push_back(id-1); bool vtNow = true; if (in.peek() == '/'){ in >> etc; if (in.peek() != '/') { in >> id; check_warn(id > numVertices(), "Texture coordinate index is greater then number of vertices."); if (id < numVertices() && hasUV) { uvs.push_back(id-1); vtNow = false; } } } if (in.peek() == '/'){ int tmp; in >> etc; in >> tmp; } if (hasUV && vtNow) { uvs.push_back(id-1); } } in.clear(in.rdstate() & ~ios::failbit); Face * f = addFace(verts); if (hasUV && uvs.size() != 0){ int k = 0; for (Face::EdgeAroundIterator e = f->iterator(); !e.end(); e++, k++) e.vertex()->uv = uvVec[uvs[k]]; } } else { string line; getline(in, line); cout << "Warning, line: " << line << " ignored." << endl; } } } in.close(); // Finnish building the mesh, should be called after each parse. finishMesh(); }

Vertex* Mesh::vertexAt (  int  i  )  [inline]

Definition at line 81 of file Mesh.h. {return vertices[i];}

VertexIterator Mesh::vertexIterator (   )  [inline]

Definition at line 275 of file Mesh.h. {return VertexIterator(&vertices);}

void Mesh::writeCON (  const char *  conn_file  )

Write out the result parameterization in "connectivity" format. The edge lengths in the result file correspond to edge lengths of the final parameterization. Definition at line 588 of file Mesh.cpp. { ofstream out(conn_file); check_error (!out, "Cannot find output file."); out << numVertices() << endl; out << numFaces() << endl; Mesh::FaceIterator fItr = faceIterator(); for (fItr.reset(); !fItr.end(); fItr++) { Face::EdgeAroundIterator around = fItr.face()->iterator(); out << "f"; for ( ; !around.end(); around++) out << " " << (around.vertex()->ID + 1); out << endl; for (around.reset() ; !around.end(); around++) out << " " << setprecision(8) << around.edge()->length; out << endl; } out.close(); }

void Mesh::writeOBJ (  const char *  obj_file  )

Definition at line 478 of file Mesh.cpp. { ofstream out(obj_file); check_error (!out, "Cannot find output file."); Mesh::VertexIterator vItr = vertexIterator(); for (vItr.reset(); !vItr.end(); vItr++) out << "v " << vItr.vertex()->p << endl; for (vItr.reset(); !vItr.end(); vItr++) out << "vt " << vItr.vertex()->uv.x() << " " << vItr.vertex()->uv.y() << endl; Mesh::FaceIterator fItr = faceIterator(); for (fItr.reset(); !fItr.end(); fItr++) { Face::EdgeAroundIterator around = fItr.face()->iterator(); out << "f"; for ( ; !around.end(); around++) out << " " << (around.vertex()->ID + 1) << "/" << (around.vertex()->ID + 1); out << endl; } }

void Mesh::writeVT (  const char *  vt_file  )

Definition at line 500 of file Mesh.cpp. { ofstream out(vt_file); check_error (!out, "Cannot find output file."); Mesh::VertexIterator vItr = vertexIterator(); for (vItr.reset(); !vItr.end(); vItr++) out << "vt " << vItr.vertex()->uv.x() << " " << vItr.vertex()->uv.y() << endl; }

---

Member Data Documentation

std::multiset<Edge*, Mesh::edge_comp> Mesh::edges [private]

Definition at line 48 of file Mesh.h.

std::vector<Face *> Mesh::faces [private]

Definition at line 47 of file Mesh.h.

int Mesh::numBoundaryLoops

Number of boundary loops in the mesh. Definition at line 56 of file Mesh.h.

int Mesh::numBoundaryVertices

Number of vertices (or also edges) at the boundary of the mesh. Definition at line 53 of file Mesh.h.

int Mesh::numConnectedComponents

Number of connected components. Definition at line 58 of file Mesh.h.

int Mesh::numGenus

Genus of the mesh. Definition at line 61 of file Mesh.h.

std::vector<Vertex *> Mesh::vertices [private]

Definition at line 46 of file Mesh.h.

---

The documentation for this class was generated from the following files:

• Mesh.h
• Mesh.cpp

---