From f896e9bd3e174faa89f10714f420b5f25bfb04de Mon Sep 17 00:00:00 2001 From: cignoni Date: Tue, 18 Feb 2014 11:01:15 +0000 Subject: [PATCH] PolygonalMesh Debugging: corrected typo in the name of the polychord class --- .../algorithms/polygon_polycoord_collapse.h | 289 +++++++++--------- 1 file changed, 142 insertions(+), 147 deletions(-) diff --git a/vcg/complex/algorithms/polygon_polycoord_collapse.h b/vcg/complex/algorithms/polygon_polycoord_collapse.h index d7ed1b90..58f09e21 100644 --- a/vcg/complex/algorithms/polygon_polycoord_collapse.h +++ b/vcg/complex/algorithms/polygon_polycoord_collapse.h @@ -20,15 +20,10 @@ * for more details. * * * ****************************************************************************/ -#ifndef POLYGON_POLYCOORD_COLLAPSE_H -#define POLYGON_POLYCOORD_COLLAPSE_H +#ifndef POLYGON_POLYCHORD_COLLAPSE_H +#define POLYGON_POLYCHORD_COLLAPSE_H -#include #include -#include -#include -#include -#include #include #include @@ -37,27 +32,27 @@ namespace tri { /** \addtogroup trimesh */ /** -* @brief The PolycoordCollapse class provides methods to semplify a quad mesh, by collapsing the polycoords. +* @brief The PolychordCollapse class provides methods to semplify a quad mesh, by collapsing the polychords. * * This class is an implementation of a method very similar to that for mesh semplification proposed * by Daniels et al. in "Quadrilateral mesh simplification", see http://www.cs.utah.edu/~jdaniels/research/asia2008_qms.htm -* The main function is PolycoordCollapse::CollapsePolycoord() which deletes all the quadrilateral faces in a polycoord. -* The polycoords that can be collapsed in this case are those forming a closed loop (a ring) or that start and end to +* The main function is PolychordCollapse::CollapsePolychord() which deletes all the quadrilateral faces in a polychord. +* The polychords that can be collapsed in this case are those forming a closed loop (a ring) or that start and end to * mesh borders. A way to preserve the structure of the singularities is also provided. -* The convenient method PolycoordCollapse::CollapseAllPolycoords() finds and collapses all the polycoords on a mesh. +* The convenient method PolychordCollapse::CollapseAllPolychords() finds and collapses all the polychords on a mesh. * The input mesh should be polygonal, i.e. it should have the vcg::face::PolyInfo component. Even though a generic * triangle mesh can be given, actually the class does not perform any collapsing operation since it sees only triangles, * in fact it does not consider faux edges. */ template < typename PolyMeshType > -class PolycoordCollapse { +class PolychordCollapse { public: typedef typename PolyMeshType::FaceType FaceType; typedef typename PolyMeshType::VertexType VertexType; typedef typename PolyMeshType::CoordType CoordType; /** - * @brief The PC_ResultCode enum codifies the result type of a polycoord collapse operation. + * @brief The PC_ResultCode enum codifies the result type of a polychord collapse operation. */ enum PC_ResultCode { PC_SUCCESS = 0, @@ -70,14 +65,14 @@ public: }; /** - * @brief The PC_Coord struct identifies a coord of a polycoord passing through a quad. + * @brief The PC_Chord struct identifies a coord of a polychord passing through a quad. */ - struct PC_Coord { + struct PC_Chord { unsigned long mark; PC_ResultCode q; - PC_Coord * prev; - PC_Coord * next; - PC_Coord() : mark(std::numeric_limits::max()), q(PC_VOID), prev(NULL), next(NULL) { } + PC_Chord * prev; + PC_Chord * next; + PC_Chord() : mark(std::numeric_limits::max()), q(PC_VOID), prev(NULL), next(NULL) { } inline void Reset() { mark = std::numeric_limits::max(); q = PC_VOID; @@ -86,16 +81,16 @@ public: }; /** - * @brief The PC_Coords class gives efficient access to each coord (relative to a face). + * @brief The PC_Chords class gives efficient access to each coord (relative to a face). */ - class PC_Coords { + class PC_Chords { public: /** - * @brief PC_Coords constructor. - * @note Since each face corresponds to two coords, the actual size of the vector of coords is 2*mesh.face.size(). + * @brief PC_Chords constructor. + * @note Since each face corresponds to two chords, the actual size of the vector of chords is 2*mesh.face.size(). * @param mesh */ - PC_Coords (const PolyMeshType &mesh) : _coords(2*mesh.face.size()), _currentCoord(NULL) { + PC_Chords (const PolyMeshType &mesh) : _Chords(2*mesh.face.size()), _currentChord(NULL) { Reset(mesh); } @@ -103,82 +98,82 @@ public: * @brief ResetMarks */ void ResetMarks() { - typename std::vector::iterator it = _coords.begin(); - for (; it != _coords.end(); it++) + typename std::vector::iterator it = _Chords.begin(); + for (; it != _Chords.end(); it++) (*it).mark = std::numeric_limits::max(); } /** * @brief Reset rearrages the container. - * @note Since each face corresponds to two coords, the actual size of the vector of coords is 2*mesh.face.size(). + * @note Since each face corresponds to two chords, the actual size of the vector of chords is 2*mesh.face.size(). * @param mesh */ void Reset(const PolyMeshType &mesh) { - _coords.resize(2*mesh.face.size()); - for (size_t j = 0; j < _coords.size(); j++) - _coords[j].Reset(); - _currentCoord = NULL; + _Chords.resize(2*mesh.face.size()); + for (size_t j = 0; j < _Chords.size(); j++) + _Chords[j].Reset(); + _currentChord = NULL; - PC_Coord *coord = NULL; + PC_Chord *chord = NULL; long long j = 0; - for (size_t i = 0; i < _coords.size(); i++) { + for (size_t i = 0; i < _Chords.size(); i++) { // set the prev - coord = NULL; + chord = NULL; if ((long long)i-1 >= 0) { - coord = &_coords[i-1]; + chord = &_Chords[i-1]; if (vcg::tri::HasPerFaceFlags(mesh)) { j = i-1; while (j >= 0 && mesh.face[j/2].IsD()) j--; if (j >= 0) - coord = &_coords[j]; + chord = &_Chords[j]; else - coord = NULL; + chord = NULL; } } - _coords[i].prev = coord; + _Chords[i].prev = chord; // set the next - coord = NULL; - if (i+1 < _coords.size()) { - coord = &_coords[i+1]; + chord = NULL; + if (i+1 < _Chords.size()) { + chord = &_Chords[i+1]; if (vcg::tri::HasPerFaceFlags(mesh)) { j = i+1; - while (j < (long long)_coords.size() && mesh.face[j/2].IsD()) + while (j < (long long)_Chords.size() && mesh.face[j/2].IsD()) j++; - if (j < (long long)_coords.size()) - coord = &_coords[j]; + if (j < (long long)_Chords.size()) + chord = &_Chords[j]; else - coord = NULL; + chord = NULL; } } - _coords[i].next = coord; + _Chords[i].next = chord; } if (mesh.face.size() > 0) { // set the current coord (first - not deleted - face) - _currentCoord = &_coords[0]; + _currentChord = &_Chords[0]; if (vcg::tri::HasPerFaceFlags(mesh) && mesh.face[0].IsD()) - _currentCoord = _currentCoord->next; + _currentChord = _currentChord->next; } } /** - * @brief operator [], given a face index and an offset, it returns (a reference to) its corresponding PC_Coord. + * @brief operator [], given a face index and an offset, it returns (a reference to) its corresponding PC_Chord. * @param face_edge A std::pair(face_index, offset). The offset should be 0 or 1. - * @return A reference to the corresponding PC_Coord. + * @return A reference to the corresponding PC_Chord. */ - inline PC_Coord & operator[] (const std::pair &face_edge) { - assert(face_edge.first >= 0 && 2*face_edge.first+face_edge.second < _coords.size()); - return _coords[2*face_edge.first + face_edge.second]; + inline PC_Chord & operator[] (const std::pair &face_edge) { + assert(face_edge.first >= 0 && 2*face_edge.first+face_edge.second < _Chords.size()); + return _Chords[2*face_edge.first + face_edge.second]; } /** - * @brief operator [], given a face index and an offset, it returns (a const reference to) its corresponding PC_Coord. + * @brief operator [], given a face index and an offset, it returns (a const reference to) its corresponding PC_Chord. * @param face_edge A std::pair(face_index, offset). The offset should be 0 or 1. - * @return A reference to the corresponding PC_Coord. + * @return A reference to the corresponding PC_Chord. */ - inline const PC_Coord & operator[] (const std::pair &face_edge) const { - assert(face_edge.first >= 0 && 2*face_edge.first+face_edge.second < _coords.size()); - return _coords[2*face_edge.first + face_edge.second]; + inline const PC_Chord & operator[] (const std::pair &face_edge) const { + assert(face_edge.first >= 0 && 2*face_edge.first+face_edge.second < _Chords.size()); + return _Chords[2*face_edge.first + face_edge.second]; } /** @@ -186,23 +181,23 @@ public: * @param coord The coord pointer. * @return A std::pair (face_index, offset) with offset being 0 or 1. */ - inline std::pair operator[] (PC_Coord const * const coord) { - assert(coord >= &_coords[0] && coord < &_coords[0]+_coords.size()); - return std::pair((coord - &_coords[0])/2, (coord - &_coords[0])%2); + inline std::pair operator[] (PC_Chord const * const coord) { + assert(coord >= &_Chords[0] && coord < &_Chords[0]+_Chords.size()); + return std::pair((coord - &_Chords[0])/2, (coord - &_Chords[0])%2); } /** * @brief UpdateCoord updates the coord information and links. * @param coord The coord to update. - * @param mark The mark of the polycoord. - * @param resultCode The code for the type of the polycoord. + * @param mark The mark of the polychord. + * @param resultCode The code for the type of the polychord. */ - inline void UpdateCoord (PC_Coord &coord, const unsigned long mark, const PC_ResultCode resultCode) { + inline void UpdateCoord (PC_Chord &coord, const unsigned long mark, const PC_ResultCode resultCode) { // update prev and next if (coord.q == PC_VOID) { - if (coord.prev != NULL && &coord != _currentCoord) + if (coord.prev != NULL && &coord != _currentChord) coord.prev->next = coord.next; - if (coord.next != NULL && &coord != _currentCoord) + if (coord.next != NULL && &coord != _currentChord) coord.next->prev = coord.prev; coord.mark = mark; } @@ -213,8 +208,8 @@ public: * @brief Next, if it's not at the end, it goes to the next coord. */ inline void Next () { - if (_currentCoord != NULL) - _currentCoord = _currentCoord->next; + if (_currentChord != NULL) + _currentChord = _currentChord->next; } /** @@ -222,9 +217,9 @@ public: * @param face_edge A std::pair where to store the FaceType pointer and the edge index. */ inline void GetCurrent (std::pair &face_edge) { - if (_currentCoord != NULL) { - face_edge.first = (_currentCoord - &_coords[0])/2; - face_edge.second = (_currentCoord - &_coords[0])%2; + if (_currentChord != NULL) { + face_edge.first = (_currentChord - &_Chords[0])/2; + face_edge.second = (_currentChord - &_Chords[0])%2; } else { face_edge.first = std::numeric_limits::max(); face_edge.second = 0; @@ -236,16 +231,16 @@ public: * @return true if an end has been reached, false otherwise. */ inline bool End () { - return _currentCoord == NULL; + return _currentChord == NULL; } private: - std::vector _coords; - PC_Coord *_currentCoord; + std::vector _Chords; + PC_Chord *_currentChord; }; /** - * @brief The LinkCondition class provides a tool to check if a polycoord satisfies the link conditions. + * @brief The LinkCondition class provides a tool to check if a polychord satisfies the link conditions. */ class LinkConditions { private: @@ -271,12 +266,12 @@ public: } /** - * @brief CheckLinkConditions checks if collapsing the polycoord starting from startPos + * @brief CheckLinkConditions checks if collapsing the polychord starting from startPos * satisfies the link conditions. - * @warning The polycoord starts from startPos and ends to itself (if it's a loop) or to a border. In the latter case, + * @warning The polychord starts from startPos and ends to itself (if it's a loop) or to a border. In the latter case, * call this method starting from the opposite border of the strip of quads. * @param mesh The mesh for getting the vertex index. - * @param startPos The starting position of the polycoord. + * @param startPos The starting position of the polychord. * @return true if satisfied, false otherwise. */ bool CheckLinkConditions (const PolyMeshType &mesh, const vcg::face::Pos &startPos) { @@ -334,7 +329,7 @@ public: } /** - * @brief LC_ResetStars resets the stars on a polycoord. + * @brief LC_ResetStars resets the stars on a polychord. * @param mesh The mesh for getting the vertex index. * @param startPos */ @@ -390,7 +385,7 @@ public: } /** - * @brief LC_computeStars computes the stars of edges and vertices of the polycoord from the starting pos + * @brief LC_computeStars computes the stars of edges and vertices of the polychord from the starting pos * either to itself (if it's a loop) or to the border edge. * @param mesh The mesh for getting the vertex index. * @param startPos Starting position. @@ -406,7 +401,7 @@ public: vcg::face::Pos eStarPos; lcEdges.clear(); - /// compute the star of all the vertices and edges seen from the polycoord + /// compute the star of all the vertices and edges seen from the polychord runPos = startPos; do { // create a lcedge @@ -566,24 +561,24 @@ public: }; - // PolyCoordCollapse's methods begin here:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: + // PolychordCollapse's methods begin here:::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::: /** - * @brief CollapsePolycoord performs all checks and then collapses the polycoord. + * @brief CollapsePolychord performs all checks and then collapses the polychord. * * @warning This function deletes faces and vertices by calling * vcg::tri::Allocator::DeleteFace() and * vcg::tri::Allocator::DeleteVertex(). - * The object PC_Coords coords is used to track the polycoords, and it has got + * The object PC_Chords chords is used to track the polychords, and it has got * a size proportional to that of the mesh face container. If you actually * delete faces and vertices by calling vcg::tri::Allocator::CompactFaceVector() * and vcg::tri::Allocator::CompactVertexVector() after this function, - * object PC_Coords coords then is not valid any more, so you MUST rearrange it - * by calling PC_Coords.Reset(). For the same reason, you MUST rearrange LinkConditions linkConditions + * object PC_Chords chords then is not valid any more, so you MUST rearrange it + * by calling PC_Chords.Reset(). For the same reason, you MUST rearrange LinkConditions linkConditions * by calling LinkConditions.Resize(). * However, for efficiency, you SHOULD compact vertex and face containers at the end of all your - * polycoord collapsing operations, without having to rearrange coords and linkConditions. - * The function CollapseAllPolycoords() does this for you. + * polychord collapsing operations, without having to rearrange chords and linkConditions. + * The function CollapseAllPolychords() does this for you. * * @note Vertex flags, face flags, FF adjacency and FV adjacency are required. Not anything else. * Such components are automatically updated here. If the mesh has other components that may be @@ -591,17 +586,17 @@ public: * * @param mesh The polygonal mesh used for getting the face index and deleting the faces * (it SHOULD have the vcg::face::PolyInfo component). - * @param pos Position of the polycoord. - * @param mark Mark for the current polycoord. - * @param coords Vector of coords. + * @param pos Position of the polychord. + * @param mark Mark for the current polychord. + * @param chords Vector of chords. * @param linkConditions Link conditions checker. * @param checkSing true if singularities on both sides are not allowed. * @return A PC_ResultCode resulting from checks or PC_SUCCESS if the collapse has been performed. */ - static PC_ResultCode CollapsePolycoord (PolyMeshType &mesh, + static PC_ResultCode CollapsePolychord (PolyMeshType &mesh, const vcg::face::Pos &pos, const unsigned long mark, - PC_Coords &coords, + PC_Chords &chords, LinkConditions &linkConditions, const bool checkSing = true) { vcg::tri::RequirePerVertexFlags(mesh); @@ -615,52 +610,52 @@ public: vcg::face::Pos tempPos, startPos; - // check if the sequence of facets is a polycoord and find the starting coord - PC_ResultCode resultCode = CheckPolycoordFindStartPosition(pos, startPos, checkSing); + // check if the sequence of facets is a polychord and find the starting coord + PC_ResultCode resultCode = CheckPolychordFindStartPosition(pos, startPos, checkSing); // if not successful, visit the sequence for marking it and return if (resultCode != PC_SUCCESS) { - // if not manifold, visit the entire polycoord ending on the non-manifold edge + // if not manifold, visit the entire polychord ending on the non-manifold edge if (resultCode == PC_NOTMANIF) { tempPos = pos; - VisitPolycoord(mesh, tempPos, coords, mark, resultCode); + VisitPolychord(mesh, tempPos, chords, mark, resultCode); if (tempPos.IsManifold() && !tempPos.IsBorder()) { tempPos.FlipF(); - VisitPolycoord(mesh, tempPos, coords, mark, resultCode); + VisitPolychord(mesh, tempPos, chords, mark, resultCode); } return resultCode; } - // if not quad, visit all the polycoords passing through this coord + // if not quad, visit all the polychords passing through this coord if (resultCode == PC_NOTQUAD) { tempPos = startPos; do { if (!tempPos.IsBorder()) { tempPos.FlipF(); - VisitPolycoord(mesh, tempPos, coords, mark, resultCode); + VisitPolychord(mesh, tempPos, chords, mark, resultCode); tempPos.FlipF(); } tempPos.FlipV(); tempPos.FlipE(); } while (tempPos != startPos); } - VisitPolycoord(mesh, startPos, coords, mark, resultCode); + VisitPolychord(mesh, startPos, chords, mark, resultCode); return resultCode; } // check if the link conditions are satisfied bool lc = linkConditions.CheckLinkConditions(mesh, startPos); // if not satisfied, visit the sequence for marking it and return if (!lc) { - VisitPolycoord(mesh, startPos, coords, mark, PC_NOLINKCOND); + VisitPolychord(mesh, startPos, chords, mark, PC_NOLINKCOND); return PC_NOLINKCOND; } - // check if the polycoord does not intersect itself - bool si = IsPolycoordSelfIntersecting(mesh, startPos, coords, mark); - // if it self-intersects, visit the polycoord for marking it and return + // check if the polychord does not intersect itself + bool si = IsPolychordSelfIntersecting(mesh, startPos, chords, mark); + // if it self-intersects, visit the polychord for marking it and return if (si) { - VisitPolycoord(mesh, startPos, coords, mark, PC_SELFINTERSECT); + VisitPolychord(mesh, startPos, chords, mark, PC_SELFINTERSECT); return PC_SELFINTERSECT; } - // at this point the polycoord is collapsable, visit it for marking - VisitPolycoord(mesh, startPos, coords, mark, PC_SUCCESS); + // at this point the polychord is collapsable, visit it for marking + VisitPolychord(mesh, startPos, chords, mark, PC_SUCCESS); // now collapse CoordType point; @@ -838,11 +833,11 @@ public: } /** - * @brief CollapseAllPolycoords finds and collapses all the polycoords. + * @brief CollapseAllPolychords finds and collapses all the polychords. * @param mesh The input polygonal mesh (it SHOULD have the vcg::face::PolyInfo component). - * @param checkSing true if singularities on both sides of a polycoord are not allowed. + * @param checkSing true if singularities on both sides of a polychord are not allowed. */ - static void CollapseAllPolycoords (PolyMeshType &mesh, const bool checkSing = true) { + static void CollapseAllPolychords (PolyMeshType &mesh, const bool checkSing = true) { vcg::tri::RequireFFAdjacency(mesh); if (mesh.FN() == 0) @@ -853,25 +848,25 @@ public: std::pair face_edge; // construct the link conditions checker LinkConditions linkConditions(mesh.vert.size()); - // construct the vector of coords - PC_Coords coords(mesh); + // construct the vector of chords + PC_Chords chords(mesh); unsigned long mark = 0; - // iterate over all the coords - while (!coords.End()) { + // iterate over all the chords + while (!chords.End()) { // get the current coord - coords.GetCurrent(face_edge); + chords.GetCurrent(face_edge); // construct a pos on the face and edge of the current coord pos.Set(&mesh.face[face_edge.first], face_edge.second, mesh.face[face_edge.first].V(face_edge.second)); - // (try to) collapse the polycoord - resultCode = CollapsePolycoord(mesh, pos, mark, coords, linkConditions, checkSing); + // (try to) collapse the polychord + resultCode = CollapsePolychord(mesh, pos, mark, chords, linkConditions, checkSing); // go to the next coord - coords.Next(); + chords.Next(); // increment the mark mark++; if (mark == std::numeric_limits::max()) { - coords.ResetMarks(); + chords.ResetMarks(); mark = 0; } } @@ -896,13 +891,13 @@ private: } /** - * @brief CheckPolycoordFindStartPosition checks if it's a collapsable polycoord. + * @brief CheckPolychordFindStartPosition checks if it's a collapsable polychord. * @param pos Input The starting position. * @param startPos Output the new starting position (in case of borders). * @param checkSing true if singularities on both sides are not allowed. - * @return PC_SUCCESS if it's a collapsable polycoord, otherwise the code for the cause (startPos is on it). + * @return PC_SUCCESS if it's a collapsable polychord, otherwise the code for the cause (startPos is on it). */ - static PC_ResultCode CheckPolycoordFindStartPosition (const vcg::face::Pos &pos, + static PC_ResultCode CheckPolychordFindStartPosition (const vcg::face::Pos &pos, vcg::face::Pos &startPos, const bool checkSing = true) { assert(!pos.IsNull()); @@ -939,7 +934,7 @@ private: } if (valence != 4) singSideB = true; - // a 2-valence internl vertex cause a polycoord to touch itself, producing non-2manifoldness + // a 2-valence internl vertex cause a polychord to touch itself, producing non-2manifoldness // in that case, a 2-valence vertex is dealt as 2 singularities in both sides if (valence == 2 && !borderB) singSideA = true; @@ -954,7 +949,7 @@ private: } if (valence != 4) singSideA = true; - // a 2-valence internal vertex cause a polycoord to touch itself, producing non-2manifoldness + // a 2-valence internal vertex cause a polychord to touch itself, producing non-2manifoldness // in that case, a 2-valence vertex is dealt as 2 singularities in both sides if (valence == 2 && !borderA) singSideB = true; @@ -986,11 +981,11 @@ private: startPos.FlipF(); } while (startPos != pos); - // polycoord with singularities on both sides can not collapse + // polychord with singularities on both sides can not collapse if (singSideA && singSideB) return PC_SINGBOTH; - // polycoords that are rings and have borders on both sides can not collapse + // polychords that are rings and have borders on both sides can not collapse if (!polyBorderFound && borderA && borderB) return PC_SINGBOTH; @@ -998,18 +993,18 @@ private: } /** - * @brief IsPolycoordSelfIntersecting checks if the input polycoord intersects itself. - * @warning Don't call this function without being sure that it's a polycoord - * (i.e. call CheckPolycoordFindStartPoint() before calling IsPolycoordSelfIntersecting(). + * @brief IsPolychordSelfIntersecting checks if the input polychord intersects itself. + * @warning Don't call this function without being sure that it's a polychord + * (i.e. call CheckPolychordFindStartPoint() before calling IsPolychordSelfIntersecting(). * @param mesh The mesh used for getting the face index. * @param startPos The starting position. - * @param coords The vector of coords. + * @param chords The vector of chords. * @param mark The current mark, used to identify quads already visited. * @return true if it intersects itself, false otherwise. */ - static bool IsPolycoordSelfIntersecting (const PolyMeshType &mesh, + static bool IsPolychordSelfIntersecting (const PolyMeshType &mesh, const vcg::face::Pos &startPos, - const PC_Coords &coords, + const PC_Chords &chords, const unsigned long mark) { assert(!startPos.IsNull()); vcg::face::Pos runPos = startPos; @@ -1020,10 +1015,10 @@ private: // check if we've already crossed this face face_edge.first = vcg::tri::Index(mesh, runPos.F()); face_edge.second = (runPos.E()+1)%2; - if (coords[face_edge].mark == mark) + if (chords[face_edge].mark == mark) return true; - // if this coord is adjacent to another coord of the same polycoord - // i.e., this polycoord touches itself without intersecting + // if this coord is adjacent to another coord of the same polychord + // i.e., this polychord touches itself without intersecting // it might cause a wrong collapse, producing holes and non-2manifoldness tmpPos = runPos; tmpPos.FlipE(); @@ -1031,7 +1026,7 @@ private: tmpPos.FlipF(); face_edge.first = vcg::tri::Index(mesh, tmpPos.F()); face_edge.second = (tmpPos.E()+1)%2; - if (coords[face_edge].mark == mark) + if (chords[face_edge].mark == mark) return true; } tmpPos = runPos; @@ -1041,7 +1036,7 @@ private: tmpPos.FlipF(); face_edge.first = vcg::tri::Index(mesh, tmpPos.F()); face_edge.second = (tmpPos.E()+1)%2; - if (coords[face_edge].mark == mark) + if (chords[face_edge].mark == mark) return true; } runPos.FlipE(); @@ -1054,16 +1049,16 @@ private: } /** - * @brief VisitPolycoord updates the information of a polycoord. + * @brief VisitPolychord updates the information of a polychord. * @param mesh The mesh used for getting the face index. * @param startPos The starting position. - * @param coords The vector of coords. + * @param chords The vector of chords. * @param mark The mark. * @param q The visiting type. */ - static void VisitPolycoord (const PolyMeshType &mesh, + static void VisitPolychord (const PolyMeshType &mesh, const vcg::face::Pos &startPos, - PC_Coords &coords, + PC_Chords &chords, const unsigned long mark, const PC_ResultCode q) { assert(!startPos.IsNull()); @@ -1082,9 +1077,9 @@ private: // update current coord face_edge.first = vcg::tri::Index(mesh, tmpPos.F()); face_edge.second = tmpPos.E()%2; - coords.UpdateCoord(coords[face_edge], mark, q); + chords.UpdateCoord(chords[face_edge], mark, q); face_edge.second = (tmpPos.E()+1)%2; - coords.UpdateCoord(coords[face_edge], mark, q); + chords.UpdateCoord(chords[face_edge], mark, q); return; } tmpPos.FlipV(); @@ -1094,11 +1089,11 @@ private: // update current coord face_edge.first = vcg::tri::Index(mesh, runPos.F()); face_edge.second = runPos.E()%2; - coords.UpdateCoord(coords[face_edge], mark, q); - // if the polycoord has to collapse, i.e. q == PC_SUCCESS, also visit the orthogonal coord + chords.UpdateCoord(chords[face_edge], mark, q); + // if the polychord has to collapse, i.e. q == PC_SUCCESS, also visit the orthogonal coord if (q == PC_SUCCESS) { face_edge.second = (runPos.E()+1)%2; - coords.UpdateCoord(coords[face_edge], mark, q); + chords.UpdateCoord(chords[face_edge], mark, q); } runPos.FlipE(); @@ -1114,4 +1109,4 @@ private: } } -#endif // POLYGON_POLYCOORD_COLLAPSE_H +#endif // POLYGON_Polychord_COLLAPSE_H