Pixyco-XYZ/openmesh
5
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge branch 'born/edge-circulators' into 'master'

Browse Source 
Add Edge circulators

See merge request OpenMesh/OpenMesh!339
This commit is contained in:
Jan Möbius
2023-11-14 07:57:18 +00:00
parent 9c5298260d 80d39234fa
commit 42ba0a4e35
15 changed files with 828 additions and 10 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
Doc/Examples/circulator_functions.cc
View File

@@ -32,3 +32,16 @@ FaceEdgeIter OpenMesh::PolyConnectivity::fe_iter (FaceHandle _fh);
// Get the face-face circulator of face _fh
FaceFaceIter OpenMesh::PolyConnectivity::ff_iter (FaceHandle _fh);
/**************************************************
* Edge circulators
**************************************************/
// Get the edge-vertex circulator of edge _eh
EdgeVertexIter OpenMesh::PolyConnectivity::ev_iter (EdgeHandle _eh);
// Get the edge-halfedge circulator of edge _eh
EdgeHalfedgeIter OpenMesh::PolyConnectivity::eh_iter (EdgeHandle _eh);
// Get the edge-face circulator of of edge _eh
EdgeFaceIter OpenMesh::PolyConnectivity::ef_iter (EdgeHandle _eh);

2
Doc/changelog.docu
View File

@@ -19,6 +19,8 @@
<li>legacy vector min max now take const args to avoid matching std implementations</li>
<li>Fixed several warnings</li>
<li>Make Previous Halfedge Attribute optional again </li>
<li>Added edge-halfedge, edge-vertex, and edge-face circulators</li>
<li>Added default argument: mesh.halfedge_handle(eh) is now equivalent to mesh.halfedge_handle(eh, 0)</li>
</ul>
<b>Tools</b>

6
Doc/mesh.docu
View File

@@ -899,6 +899,12 @@ The circulators around a face are:
\arg \c FaceEdgeIter: iterate over the face's edges.
\arg \c FaceFaceIter: iterate over all edge-neighboring faces.
The circulators around an edge are:
\arg \c EdgeVertexIter: iterate over the edge's incident vertices.
\arg \c EdgeHalfedgeIter: iterate over the edge's halfedges.
\arg \c EdgeFaceIter: iterate over the edge's incident faces.
Other circulators:
\arg \c HalfedgeLoopIter: iterate over a sequence of Halfedges. (all Halfedges over a face or a hole)

4
src/OpenMesh/Core/Mesh/ArrayKernel.hh
View File

@@ -471,7 +471,7 @@ public:
{ return next_halfedge_handle(opposite_halfedge_handle(_heh)); }
// --- edge connectivity ---
static HalfedgeHandle s_halfedge_handle(EdgeHandle _eh, unsigned int _i)
static HalfedgeHandle s_halfedge_handle(EdgeHandle _eh, unsigned int _i = 0)
{
assert(_i<=1);
return HalfedgeHandle((_eh.idx() << 1) + _i);
@@ -480,7 +480,7 @@ public:
static EdgeHandle s_edge_handle(HalfedgeHandle _heh)
{ return EdgeHandle(_heh.idx() >> 1); }
HalfedgeHandle halfedge_handle(EdgeHandle _eh, unsigned int _i) const
HalfedgeHandle halfedge_handle(EdgeHandle _eh, unsigned int _i = 0) const
{
return s_halfedge_handle(_eh, _i);
}

23
src/OpenMesh/Core/Mesh/CirculatorsT.hh
View File

@@ -44,7 +44,7 @@
//=============================================================================
//
// Vertex and Face circulators for PolyMesh/TriMesh
// Vertex, Face, and Edge circulators for PolyMesh/TriMesh
//
//=============================================================================
@@ -98,6 +98,19 @@ class GenericCirculator_CenterEntityFnsT<Mesh, typename Mesh::FaceHandle, true>
}
};
template<class Mesh, bool CW>
class GenericCirculator_CenterEntityFnsT<Mesh, typename Mesh::EdgeHandle, CW> {
public:
inline static void increment(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, const typename Mesh::HalfedgeHandle &start, int &lap_counter) {
heh = mesh->opposite_halfedge_handle(heh);
if (heh == start) ++lap_counter;
}
inline static void decrement(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, const typename Mesh::HalfedgeHandle &start, int &lap_counter) {
if (heh == start) --lap_counter;
heh = mesh->opposite_halfedge_handle(heh);
}
};
/////////////////////////////////////////////////////////////
// CCW
@@ -150,6 +163,14 @@ class GenericCirculator_DereferenciabilityCheckT<Mesh, typename Mesh::VertexHand
}
};
template<class Mesh>
class GenericCirculator_DereferenciabilityCheckT<Mesh, typename Mesh::EdgeHandle, typename Mesh::FaceHandle> {
public:
inline static bool isDereferenciable(const Mesh *mesh, const typename Mesh::HalfedgeHandle &heh) {
return mesh->face_handle(heh).is_valid();
}
};
template<class Mesh, class CenterEntityHandle, class ValueHandle, bool CW = true>
class GenericCirculator_ValueHandleFnsT {
public:

133
src/OpenMesh/Core/Mesh/PolyConnectivity.hh
View File

@@ -379,6 +379,53 @@ public:
typedef FaceFaceCWIter ConstFaceFaceCWIter;
typedef FaceFaceCCWIter ConstFaceFaceCCWIter;
/*
* Edge-centered circulators
*/
struct EdgeVertexTraits
{
using Mesh = This;
using CenterEntityHandle = This::EdgeHandle;
using ValueHandle = This::VertexHandle;
static ValueHandle toHandle(const Mesh* const _mesh, This::HalfedgeHandle _heh) { return static_cast<const ArrayKernel*>(_mesh)->from_vertex_handle(_heh); }
};
/**
* Enumerate vertices incident to an edge.
*/
typedef Iterators::GenericCirculatorT_DEPRECATED<EdgeVertexTraits> EdgeVertexIter;
struct EdgeHalfedgeTraits
{
using Mesh = This;
using CenterEntityHandle = This::EdgeHandle;
using ValueHandle = This::HalfedgeHandle;
static ValueHandle toHandle(const Mesh* const /* _mesh */, This::HalfedgeHandle _heh) { return _heh; }
};
/**
* Enumerate the halfedges of an edge.
*/
typedef Iterators::GenericCirculatorT_DEPRECATED<EdgeHalfedgeTraits> EdgeHalfedgeIter;
struct EdgeFaceTraits
{
using Mesh = This;
using CenterEntityHandle = This::EdgeHandle;
using ValueHandle = This::FaceHandle;
static ValueHandle toHandle(const Mesh* const _mesh, This::HalfedgeHandle _heh) { return static_cast<const ArrayKernel*>(_mesh)->face_handle(_heh); }
};
/**
* Enumerate faces incident to an edge.
*/
typedef Iterators::GenericCirculatorT_DEPRECATED<EdgeFaceTraits> EdgeFaceIter;
typedef EdgeVertexIter ConstEdgeVertexIter;
typedef EdgeHalfedgeIter ConstEdgeHalfedgeIter;
typedef EdgeFaceIter ConstEdgeFaceIter;
/*
* Halfedge circulator
*/
@@ -435,6 +482,9 @@ public:
typedef FaceEdgeCWIter FECWIter;
typedef FaceEdgeCCWIter FECWWIter;
typedef FaceFaceIter FFIter;
typedef EdgeVertexIter EVIter;
typedef EdgeHalfedgeIter EHIter;
typedef EdgeFaceIter EFIter;
typedef ConstVertexVertexIter CVVIter;
typedef ConstVertexVertexCWIter CVVCWIter;
@@ -463,6 +513,9 @@ public:
typedef ConstFaceFaceIter CFFIter;
typedef ConstFaceFaceCWIter CFFCWIter;
typedef ConstFaceFaceCCWIter CFFCCWIter;
typedef ConstEdgeVertexIter CEVIter;
typedef ConstEdgeHalfedgeIter CEHIter;
typedef ConstEdgeFaceIter CEFIter;
//@}
public:
@@ -600,14 +653,14 @@ public:
using ArrayKernel::s_halfedge_handle;
using ArrayKernel::s_edge_handle;
static SmartHalfedgeHandle s_halfedge_handle(SmartEdgeHandle _eh, unsigned int _i);
static SmartHalfedgeHandle s_halfedge_handle(SmartEdgeHandle _eh, unsigned int _i = 0);
static SmartEdgeHandle s_edge_handle(SmartHalfedgeHandle _heh);
using ArrayKernel::halfedge_handle;
using ArrayKernel::edge_handle;
using ArrayKernel::face_handle;
inline SmartHalfedgeHandle halfedge_handle(SmartEdgeHandle _eh, unsigned int _i) const;
inline SmartHalfedgeHandle halfedge_handle(SmartEdgeHandle _eh, unsigned int _i = 0) const;
inline SmartHalfedgeHandle halfedge_handle(SmartFaceHandle _fh) const;
inline SmartHalfedgeHandle halfedge_handle(SmartVertexHandle _vh) const;
inline SmartEdgeHandle edge_handle(SmartHalfedgeHandle _heh) const;
@@ -688,7 +741,7 @@ public:
//--- circulators ---
/** \name Vertex and Face circulators
/** \name Vertex, Face, and Edge circulators
*/
//@{
@@ -803,6 +856,20 @@ public:
ConstFaceFaceCWIter cff_cwiter(FaceHandle _fh) const;
/// const face - face circulator
ConstFaceFaceCCWIter cff_ccwiter(FaceHandle _fh) const;
/// edge - vertex circulator
EdgeVertexIter ev_iter(EdgeHandle _eh);
/// edge - halfedge circulator
EdgeHalfedgeIter eh_iter(EdgeHandle _eh);
/// edge - face circulator
EdgeFaceIter ef_iter(EdgeHandle _eh);
/// const edge - vertex circulator
ConstEdgeVertexIter cev_iter(EdgeHandle _eh) const;
/// const edge - halfedge circulator
ConstEdgeHalfedgeIter ceh_iter(EdgeHandle _eh) const;
/// const edge - face circulator
ConstEdgeFaceIter cef_iter(EdgeHandle _eh) const;
// 'begin' circulators
@@ -930,6 +997,20 @@ public:
ConstHalfedgeLoopCWIter chl_cwbegin(HalfedgeHandle _heh) const;
/// const halfedge circulator ccw
ConstHalfedgeLoopCCWIter chl_ccwbegin(HalfedgeHandle _heh) const;
/// edge - vertex circulator
EdgeVertexIter ev_begin(EdgeHandle _eh);
/// edge - halfedge circulator
EdgeHalfedgeIter eh_begin(EdgeHandle _eh);
/// edge - face circulator
EdgeFaceIter ef_begin(EdgeHandle _eh);
/// const edge - vertex circulator
ConstEdgeVertexIter cev_begin(EdgeHandle _eh) const;
/// const edge - halfedge circulator
ConstEdgeHalfedgeIter ceh_begin(EdgeHandle _eh) const;
/// const edge - face circulator
ConstEdgeFaceIter cef_begin(EdgeHandle _eh) const;
// 'end' circulators
@@ -1056,6 +1137,21 @@ public:
ConstHalfedgeLoopCWIter chl_cwend(HalfedgeHandle _heh) const;
/// const face - face circulator ccw
ConstHalfedgeLoopCCWIter chl_ccwend(HalfedgeHandle _heh) const;
/// edge - vertex circulator
EdgeVertexIter ev_end(EdgeHandle _eh);
/// edge - halfedge circulator
EdgeHalfedgeIter eh_end(EdgeHandle _eh);
/// edge - face circulator
EdgeFaceIter ef_end(EdgeHandle _eh);
/// const edge - vertex circulator
ConstEdgeVertexIter cev_end(EdgeHandle _eh) const;
/// const edge - halfedge circulator
ConstEdgeHalfedgeIter ceh_end(EdgeHandle _eh) const;
/// const edge - face circulator
ConstEdgeFaceIter cef_end(EdgeHandle _eh) const;
//@}
/** @name Range based iterators and circulators */
@@ -1178,6 +1274,9 @@ public:
typedef CirculatorRange<CirculatorRangeTraitT<PolyConnectivity, ConstFaceHalfedgeIter , FaceHandle , HalfedgeHandle, &PolyConnectivity::cfh_begin , &PolyConnectivity::cfh_end >> ConstFaceHalfedgeRange;
typedef CirculatorRange<CirculatorRangeTraitT<PolyConnectivity, ConstFaceEdgeIter , FaceHandle , EdgeHandle , &PolyConnectivity::cfe_begin , &PolyConnectivity::cfe_end >> ConstFaceEdgeRange;
typedef CirculatorRange<CirculatorRangeTraitT<PolyConnectivity, ConstFaceFaceIter , FaceHandle , FaceHandle , &PolyConnectivity::cff_begin , &PolyConnectivity::cff_end >> ConstFaceFaceRange;
typedef CirculatorRange<CirculatorRangeTraitT<PolyConnectivity, ConstEdgeVertexIter , EdgeHandle , VertexHandle , &PolyConnectivity::cev_begin , &PolyConnectivity::cev_end >> ConstEdgeVertexRange;
typedef CirculatorRange<CirculatorRangeTraitT<PolyConnectivity, ConstEdgeHalfedgeIter , EdgeHandle , HalfedgeHandle, &PolyConnectivity::ceh_begin , &PolyConnectivity::ceh_end >> ConstEdgeHalfedgeRange;
typedef CirculatorRange<CirculatorRangeTraitT<PolyConnectivity, ConstEdgeFaceIter , EdgeHandle , FaceHandle, &PolyConnectivity::cef_begin , &PolyConnectivity::cef_end >> ConstEdgeFaceRange;
typedef CirculatorRange<CirculatorRangeTraitT<PolyConnectivity, ConstHalfedgeLoopIter , HalfedgeHandle, HalfedgeHandle, &PolyConnectivity::chl_begin , &PolyConnectivity::chl_end >> ConstHalfedgeLoopRange;
typedef CirculatorRange<CirculatorRangeTraitT<PolyConnectivity, ConstVertexVertexCWIter , VertexHandle , VertexHandle , &PolyConnectivity::cvv_cwbegin , &PolyConnectivity::cvv_cwend >> ConstVertexVertexCWRange;
@@ -1270,6 +1369,31 @@ public:
*/
ConstFaceFaceRange ff_range(FaceHandle _fh) const;
/**
* @return The vertices incident to the specified edge
* as a range object suitable for C++11 range based for loops.
*/
ConstEdgeVertexRange ev_range(EdgeHandle _eh) const;
/**
* @return The halfedges of the specified edge
* as a range object suitable for C++11 range based for loops.
*/
ConstEdgeHalfedgeRange eh_range(EdgeHandle _eh) const;
/**
* @return The halfedges of the specified edge
* as a range object suitable for C++11 range based for loops.
* Like eh_range(_heh.edge()) but starts iteration at _heh
*/
ConstEdgeHalfedgeRange eh_range(HalfedgeHandle _heh) const;
/**
* @return The faces incident to the specified edge
* as a range object suitable for C++11 range based for loops.
*/
ConstEdgeFaceRange ef_range(EdgeHandle _eh) const;
/**
* @return The halfedges in the face
* as a range object suitable for C++11 range based for loops.
@@ -1313,7 +1437,7 @@ public:
* @return The edges incident to the specified vertex
* as a range object suitable for C++11 range based for loops.
*/
ConstVertexEdgeCWRange ve_cw_range(VertexHandle _vh) const ;
ConstVertexEdgeCWRange ve_cw_range(VertexHandle _vh) const;
/**
* @return The faces incident to the specified vertex
@@ -1420,6 +1544,7 @@ public:
*/
ConstFaceFaceCCWRange ff_ccw_range(FaceHandle _fh) const;
/**
* @return The halfedges in the face
* as a range object suitable for C++11 range based for loops.

85
src/OpenMesh/Core/Mesh/PolyConnectivity_inline_impl.hh
View File

@@ -183,6 +183,22 @@ inline PolyConnectivity::ConstFaceFaceRange PolyConnectivity::ff_range(FaceHandl
return ConstFaceFaceRange(*this, _fh);
}
inline PolyConnectivity::ConstEdgeVertexRange PolyConnectivity::ev_range(EdgeHandle _eh) const {
return ConstEdgeVertexRange(*this, _eh);
}
inline PolyConnectivity::ConstEdgeHalfedgeRange PolyConnectivity::eh_range(EdgeHandle _eh) const {
return ConstEdgeHalfedgeRange(*this, _eh);
}
inline PolyConnectivity::ConstEdgeHalfedgeRange PolyConnectivity::eh_range(HalfedgeHandle _heh) const {
return ConstEdgeHalfedgeRange(*this, _heh, 1);
}
inline PolyConnectivity::ConstEdgeFaceRange PolyConnectivity::ef_range(EdgeHandle _eh) const {
return ConstEdgeFaceRange(*this, _eh);
}
inline PolyConnectivity::ConstHalfedgeLoopRange PolyConnectivity::hl_range(HalfedgeHandle _heh) const {
return ConstHalfedgeLoopRange(*this, _heh);
}
@@ -282,6 +298,7 @@ inline PolyConnectivity::ConstFaceFaceCCWRange PolyConnectivity::ff_ccw_range(Fa
return ConstFaceFaceCCWRange(*this, _fh);
}
inline PolyConnectivity::ConstHalfedgeLoopCCWRange PolyConnectivity::hl_ccw_range(HalfedgeHandle _heh) const {
return ConstHalfedgeLoopCCWRange(*this, _heh);
}
@@ -523,6 +540,24 @@ inline PolyConnectivity::ConstFaceFaceCWIter PolyConnectivity::cff_cwiter(ArrayK
inline PolyConnectivity::ConstFaceFaceCCWIter PolyConnectivity::cff_ccwiter(ArrayKernel::FaceHandle _fh) const
{ return ConstFaceFaceCCWIter(*this, _fh); }
inline PolyConnectivity::EdgeVertexIter PolyConnectivity::ev_iter(ArrayKernel::EdgeHandle _eh)
{ return EdgeVertexIter(*this, _eh); }
inline PolyConnectivity::EdgeHalfedgeIter PolyConnectivity::eh_iter(ArrayKernel::EdgeHandle _eh)
{ return EdgeHalfedgeIter(*this, _eh); }
inline PolyConnectivity::EdgeFaceIter PolyConnectivity::ef_iter(ArrayKernel::EdgeHandle _eh)
{ return EdgeFaceIter(*this, _eh); }
inline PolyConnectivity::ConstEdgeVertexIter PolyConnectivity::cev_iter(ArrayKernel::EdgeHandle _eh) const
{ return ConstEdgeVertexIter(*this, _eh); }
inline PolyConnectivity::ConstEdgeHalfedgeIter PolyConnectivity::ceh_iter(ArrayKernel::EdgeHandle _eh) const
{ return ConstEdgeHalfedgeIter(*this, _eh); }
inline PolyConnectivity::ConstEdgeFaceIter PolyConnectivity::cef_iter(ArrayKernel::EdgeHandle _eh) const
{ return ConstEdgeFaceIter(*this, _eh); }
inline PolyConnectivity::VertexVertexIter PolyConnectivity::vv_begin(VertexHandle _vh)
{ return VertexVertexIter(*this, _vh); }
@@ -707,6 +742,27 @@ inline PolyConnectivity::ConstHalfedgeLoopCWIter PolyConnectivity::chl_cwbegin(H
inline PolyConnectivity::ConstHalfedgeLoopCCWIter PolyConnectivity::chl_ccwbegin(HalfedgeHandle _heh) const
{ return ConstHalfedgeLoopCCWIter(*this, _heh); }
inline PolyConnectivity::EdgeVertexIter PolyConnectivity::ev_begin(EdgeHandle _eh)
{ return EdgeVertexIter(*this, _eh); }
inline PolyConnectivity::EdgeHalfedgeIter PolyConnectivity::eh_begin(EdgeHandle _eh)
{ return EdgeHalfedgeIter(*this, _eh); }
inline PolyConnectivity::EdgeFaceIter PolyConnectivity::ef_begin(EdgeHandle _eh)
{ return EdgeFaceIter(*this, _eh); }
inline PolyConnectivity::ConstEdgeVertexIter PolyConnectivity::cev_begin(EdgeHandle _eh) const
{ return ConstEdgeVertexIter(*this, _eh); }
inline PolyConnectivity::ConstEdgeHalfedgeIter PolyConnectivity::ceh_begin(EdgeHandle _eh) const
{ return ConstEdgeHalfedgeIter(*this, _eh); }
inline PolyConnectivity::ConstEdgeFaceIter PolyConnectivity::cef_begin(EdgeHandle _eh) const
{ return ConstEdgeFaceIter(*this, _eh); }
// 'end' circulators
inline PolyConnectivity::VertexVertexIter PolyConnectivity::vv_end(VertexHandle _vh)
@@ -893,6 +949,26 @@ inline PolyConnectivity::ConstHalfedgeLoopCCWIter PolyConnectivity::chl_ccwend(H
{ return ConstHalfedgeLoopCCWIter(*this, _heh, true); }
inline PolyConnectivity::EdgeVertexIter PolyConnectivity::ev_end(EdgeHandle _eh)
{ return EdgeVertexIter(*this, _eh, true); }
inline PolyConnectivity::EdgeHalfedgeIter PolyConnectivity::eh_end(EdgeHandle _eh)
{ return EdgeHalfedgeIter(*this, _eh, true); }
inline PolyConnectivity::EdgeFaceIter PolyConnectivity::ef_end(EdgeHandle _eh)
{ return EdgeFaceIter(*this, _eh, true); }
inline PolyConnectivity::ConstEdgeVertexIter PolyConnectivity::cev_end(EdgeHandle _eh) const
{ return ConstEdgeVertexIter(*this, _eh, true); }
inline PolyConnectivity::ConstEdgeHalfedgeIter PolyConnectivity::ceh_end(EdgeHandle _eh) const
{ return ConstEdgeHalfedgeIter(*this, _eh, true); }
inline PolyConnectivity::ConstEdgeFaceIter PolyConnectivity::cef_end(EdgeHandle _eh) const
{ return ConstEdgeFaceIter(*this, _eh, true); }
inline PolyConnectivity::ConstVertexFaceRange SmartVertexHandle::faces() const { assert(mesh() != nullptr); return mesh()->vf_range (*this); }
inline PolyConnectivity::ConstVertexFaceCWRange SmartVertexHandle::faces_cw() const { assert(mesh() != nullptr); return mesh()->vf_cw_range (*this); }
inline PolyConnectivity::ConstVertexFaceCCWRange SmartVertexHandle::faces_ccw() const { assert(mesh() != nullptr); return mesh()->vf_ccw_range(*this); }
@@ -943,4 +1019,13 @@ inline PolyConnectivity::ConstFaceFaceRange SmartFaceHandle::faces()
inline PolyConnectivity::ConstFaceFaceCWRange SmartFaceHandle::faces_cw() const { assert(mesh() != nullptr); return mesh()->ff_cw_range (*this); }
inline PolyConnectivity::ConstFaceFaceCCWRange SmartFaceHandle::faces_ccw() const { assert(mesh() != nullptr); return mesh()->ff_ccw_range(*this); }
inline PolyConnectivity::ConstEdgeVertexRange SmartEdgeHandle::vertices() const { assert(mesh() != nullptr); return mesh()->ev_range (*this); }
inline PolyConnectivity::ConstEdgeHalfedgeRange SmartEdgeHandle::halfedges() const { assert(mesh() != nullptr); return mesh()->eh_range (*this); }
inline PolyConnectivity::ConstEdgeHalfedgeRange SmartEdgeHandle::halfedges(HalfedgeHandle _heh) const { assert(mesh() != nullptr); return mesh()->eh_range (_heh); }
inline PolyConnectivity::ConstEdgeFaceRange SmartEdgeHandle::faces() const { assert(mesh() != nullptr); return mesh()->ef_range (*this); }
}//namespace OpenMesh

13
src/OpenMesh/Core/Mesh/SmartHandles.hh
View File

@@ -213,6 +213,15 @@ struct OPENMESHDLLEXPORT SmartEdgeHandle : public SmartBaseHandle, EdgeHandle, S
SmartVertexHandle v0() const;
/// Shorthand for vertex(1)
SmartVertexHandle v1() const;
/// Returns a range of vertices incident to the edge (PolyConnectivity::ev_range())
PolyConnectivity::ConstEdgeVertexRange vertices() const;
/// Returns a range of halfedges of the edge (PolyConnectivity::eh_range())
PolyConnectivity::ConstEdgeHalfedgeRange halfedges() const;
/// Returns a range of halfedges of the edge (PolyConnectivity::eh_range())
PolyConnectivity::ConstEdgeHalfedgeRange halfedges(HalfedgeHandle _heh) const;
/// Returns a range of faces incident to the edge (PolyConnectivity::ef_range())
PolyConnectivity::ConstEdgeFaceRange faces() const;
};
struct OPENMESHDLLEXPORT SmartFaceHandle : public SmartBaseHandle, FaceHandle, SmartHandleStatusPredicates<SmartFaceHandle>, SmartHandleBoundaryPredicate<SmartFaceHandle>
@@ -415,13 +424,13 @@ inline SmartFaceHandle SmartHalfedgeHandle::face() const
return make_smart(mesh()->face_handle(*this), mesh());
}
inline SmartHalfedgeHandle SmartEdgeHandle::halfedge(unsigned int _i) const
inline SmartHalfedgeHandle SmartEdgeHandle::halfedge(unsigned int _i = 0) const
{
assert(mesh() != nullptr);
return make_smart(mesh()->halfedge_handle(*this, _i), mesh());
}
inline SmartHalfedgeHandle SmartEdgeHandle::h(unsigned int _i) const
inline SmartHalfedgeHandle SmartEdgeHandle::h(unsigned int _i = 0) const
{
return halfedge(_i);
}

6
src/Unittests/CMakeLists.txt
View File

@@ -38,8 +38,11 @@ unittests_sr_binary.cc
unittests_stripifier.cc
unittests_subdivider_adaptive.cc
unittests_subdivider_uniform.cc
unittests_trimesh_circulator_current_halfedge_handle_replacement.cc
unittests_traits.cc
unittests_trimesh_circulator_current_halfedge_handle_replacement.cc
unittests_trimesh_circulator_edge_face.cc
unittests_trimesh_circulator_edge_halfedge.cc
unittests_trimesh_circulator_edge_vertex.cc
unittests_trimesh_circulator_face_edge.cc
unittests_trimesh_circulator_face_face.cc
unittests_trimesh_circulator_face_halfedge.cc
@@ -53,6 +56,7 @@ unittests_trimesh_circulator_vertex_vertex.cc
unittests_trimesh_collapse.cc
unittests_trimesh_garbage_collection.cc
unittests_trimesh_iterators.cc
unittests_trimesh_navigation.cc
unittests_trimesh_others.cc
unittests_trimesh_ranges.cc
unittests_trimesh_split.cc

4
src/Unittests/unittests_smart_handles.cc
View File

@@ -177,6 +177,10 @@ TEST_F(OpenMeshSmartHandles, SimpleNavigation)
for (auto eh : mesh_.edges())
{
EXPECT_EQ(mesh_.halfedge_handle(eh), eh.halfedge()) << "halfedge of edge does not match";
EXPECT_EQ(mesh_.halfedge_handle(eh, 0), eh.halfedge(0)) << "halfedge 0 of edge does not match";
EXPECT_EQ(mesh_.halfedge_handle(eh, 1), eh.halfedge(1)) << "halfedge 1 of edge does not match";
EXPECT_EQ(mesh_.halfedge_handle(eh), eh.h()) << "halfedge of edge does not match";
EXPECT_EQ(mesh_.halfedge_handle(eh, 0), eh.h0()) << "halfedge 0 of edge does not match";
EXPECT_EQ(mesh_.halfedge_handle(eh, 1), eh.h1()) << "halfedge 1 of edge does not match";
EXPECT_EQ(mesh_.from_vertex_handle(mesh_.halfedge_handle(eh, 0)), eh.v0()) << "first vertex of edge does not match";

62
src/Unittests/unittests_trimesh_circulator_edge.hh Normal file
View File

@@ -0,0 +1,62 @@
#include <Unittests/unittests_common.hh>
#include <vector>
namespace {
class OpenMeshTrimeshCirculatorEdge : public OpenMeshBase {
public:
using VH = OpenMesh::VertexHandle;
using FH = OpenMesh::FaceHandle;
using EH = OpenMesh::EdgeHandle;
using HEH = OpenMesh::HalfedgeHandle;
// This function is called before each test is run.
void SetUp() override {
std::vector<VH> vh;
// 3----2 5
// | /| |
// | / | |
// | / | |
// |/ | |
// 0----1 4
// A quad consisting of two triangles.
vh.push_back(mesh_.add_vertex({0.0, 0.0, 0.0})); // vh[0]
vh.push_back(mesh_.add_vertex({1.0, 0.0, 0.0})); // vh[1]
vh.push_back(mesh_.add_vertex({1.0, 1.0, 0.0})); // vh[2]
vh.push_back(mesh_.add_vertex({0.0, 1.0, 0.0})); // vh[3]
mesh_.add_face(vh[0], vh[1], vh[2]);
mesh_.add_face(vh[0], vh[2], vh[3]);
// An isolated edge.
vh.push_back(mesh_.add_vertex({2.0, 0.0, 0.0})); // vh[4]
vh.push_back(mesh_.add_vertex({2.0, 1.0, 0.0})); // vh[5]
auto heh = mesh_.new_edge(vh[4], vh[5]);
auto heh_opp = mesh_.opposite_halfedge_handle(heh);
mesh_.set_halfedge_handle(vh[4], heh);
mesh_.set_halfedge_handle(vh[5], heh_opp);
InteriorEdge = Edge(0, 2);
BoundaryEdge = Edge(0, 1);
IsolatedEdge = Edge(4, 5);
}
// Helper function to quickly retrieve edges from their endpoint vertex IDs.
EH Edge(int _vh0_idx, int _vh1_idx) {
VH vh0(_vh0_idx);
VH vh1(_vh1_idx);
HEH heh = mesh_.find_halfedge(vh0, vh1);
if (!heh.is_valid())
return EH();
return mesh_.edge_handle(heh);
}
// Handles of some interesting edges.
EH InteriorEdge;
EH BoundaryEdge;
EH IsolatedEdge;
};
}

142
src/Unittests/unittests_trimesh_circulator_edge_face.cc Normal file
View File

@@ -0,0 +1,142 @@
#include "unittests_trimesh_circulator_edge.hh"
#include <gtest/gtest.h>
#include <Unittests/unittests_common.hh>
#include <vector>
namespace {
class OpenMeshTrimeshCirculatorEdgeFace : public OpenMeshTrimeshCirculatorEdge {
public:
// Check that the _visited faces comply with the expected iteration order on _eh.
void CheckIteration(EH _eh, const std::vector<FH>& _visited) {
// Up to 2 elements, depending on whether incident faces exist.
ASSERT_TRUE(mesh_.is_valid_handle(_eh));
const auto eh = make_smart(_eh, mesh_);
std::vector<FH> expected;
for (int i = 0; i < 2; ++i) {
const auto fh = eh.halfedge(i).face();
if (fh.is_valid()) {
expected.push_back(fh);
}
}
// Elements must have been visited in the expected order.
ASSERT_EQ(_visited.size(), expected.size());
for (size_t i = 0; i < _visited.size(); ++i) {
EXPECT_EQ(_visited[i], expected[i]);
}
}
};
// Mutable mesh.
TEST_F(OpenMeshTrimeshCirculatorEdgeFace, Iter) {
for (auto eh : mesh_.edges()) {
std::vector<FH> visited;
for (auto it = mesh_.ef_iter(eh); it.is_valid(); ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeFace, BeginEnd) {
for (auto eh : mesh_.edges()) {
std::vector<FH> visited;
for (auto it = mesh_.ef_begin(eh), end = mesh_.ef_end(eh); it != end; ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeFace, Range) {
for (auto eh : mesh_.edges()) {
std::vector<FH> visited;
for (auto fh : mesh_.ef_range(eh)) {
visited.push_back(fh);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeFace, SmartHandleRange) {
for (auto eh : mesh_.edges()) {
std::vector<FH> visited;
auto smart_eh = make_smart(eh, mesh_);
for (auto fh : smart_eh.faces()) {
visited.push_back(fh);
}
CheckIteration(eh, visited);
}
}
// const mesh.
TEST_F(OpenMeshTrimeshCirculatorEdgeFace, ConstIter) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<FH> visited;
for (auto it = const_mesh.cef_iter(eh); it.is_valid(); ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeFace, ConstBeginEnd) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<FH> visited;
for (auto it = const_mesh.cef_begin(eh), end = const_mesh.cef_end(eh); it != end; ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeFace, ConstRange) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<FH> visited;
for (auto fh : const_mesh.ef_range(eh)) {
visited.push_back(fh);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeFace, ConstSmartHandleRange) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<FH> visited;
auto smart_eh = make_smart(eh, const_mesh);
for (auto fh : smart_eh.faces()) {
visited.push_back(fh);
}
CheckIteration(eh, visited);
}
}
// Expected number of faces for interior, boundary, isolated edges.
TEST_F(OpenMeshTrimeshCirculatorEdgeFace, ExpectedNumber) {
std::vector<std::pair<EH, int>> pairs = {
{ InteriorEdge, 2 },
{ BoundaryEdge, 1 },
{ IsolatedEdge, 0 },
};
for (const auto& pair : pairs) {
const auto& eh = pair.first;
const auto& expected_faces = pair.second;
int visited_faces = 0;
for (auto fh : mesh_.ef_range(eh)) {
(void)fh; // Unused
++visited_faces;
}
EXPECT_EQ(visited_faces, expected_faces);
}
}
}

184
src/Unittests/unittests_trimesh_circulator_edge_halfedge.cc Normal file
View File

@@ -0,0 +1,184 @@
#include "unittests_trimesh_circulator_edge.hh"
#include <gtest/gtest.h>
#include <Unittests/unittests_common.hh>
#include <vector>
namespace {
class OpenMeshTrimeshCirculatorEdgeHalfedge : public OpenMeshTrimeshCirculatorEdge {
public:
// Check that the _visited halfedges comply with the expected iteration order on _eh.
void CheckIteration(EH _eh, const std::vector<HEH>& _visited) {
ASSERT_TRUE(mesh_.is_valid_handle(_eh));
const auto eh = make_smart(_eh, mesh_);
std::vector<HEH> expected;
for (int i = 0; i < 2; ++i) {
expected.push_back(eh.halfedge(i));
}
// Elements must have been visited in the expected order.
ASSERT_EQ(_visited.size(), expected.size());
for (size_t i = 0; i < _visited.size(); ++i) {
EXPECT_EQ(_visited[i], expected[i]);
}
}
// Check that the _visited halfedges comply with the expected iteration order on _heh.edge(), starting at _heh.
void CheckIteration(HEH _heh, const std::vector<HEH>& _visited) {
// Always exactly 2 elements.
ASSERT_TRUE(mesh_.is_valid_handle(_heh));
std::vector<HEH> expected;
expected.push_back(_heh);
expected.push_back(mesh_.opposite_halfedge_handle(_heh));
// Elements must have been visited in the expected order.
ASSERT_EQ(_visited.size(), expected.size());
for (size_t i = 0; i < _visited.size(); ++i) {
EXPECT_EQ(_visited[i], expected[i]);
}
}
};
// Mutable mesh.
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, Iter) {
for (auto eh : mesh_.edges()) {
std::vector<HEH> visited;
for (auto it = mesh_.eh_iter(eh); it.is_valid(); ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, BeginEnd) {
for (auto eh : mesh_.edges()) {
std::vector<HEH> visited;
for (auto it = mesh_.eh_begin(eh), end = mesh_.eh_end(eh); it != end; ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, Range) {
for (auto eh : mesh_.edges()) {
std::vector<HEH> visited;
for (auto vh : mesh_.eh_range(eh)) {
visited.push_back(vh);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, SmartHandleRange) {
for (auto eh : mesh_.edges()) {
std::vector<HEH> visited;
auto smart_eh = make_smart(eh, mesh_);
for (auto vh : smart_eh.halfedges()) {
visited.push_back(vh);
}
CheckIteration(eh, visited);
}
}
// const mesh.
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, ConstIter) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<HEH> visited;
for (auto it = const_mesh.ceh_iter(eh); it.is_valid(); ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, ConstBeginEnd) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<HEH> visited;
for (auto it = const_mesh.ceh_begin(eh), end = const_mesh.ceh_end(eh); it != end; ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, ConstRange) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<HEH> visited;
for (auto vh : const_mesh.eh_range(eh)) {
visited.push_back(vh);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, ConstSmartHandleRange) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<HEH> visited;
auto smart_eh = make_smart(eh, const_mesh);
for (auto vh : smart_eh.halfedges()) {
visited.push_back(vh);
}
CheckIteration(eh, visited);
}
}
// Mutable mesh, with given start halfedge.
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, InitializedRange) {
for (auto start_heh : mesh_.halfedges()) {
std::vector<HEH> visited;
for (auto vh : mesh_.eh_range(start_heh)) {
visited.push_back(vh);
}
CheckIteration(start_heh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, InitializedSmartHandleRange) {
for (auto start_heh : mesh_.halfedges()) {
std::vector<HEH> visited;
auto smart_start_heh = make_smart(start_heh, mesh_);
auto smart_start_eh = smart_start_heh.edge();
for (auto vh : smart_start_eh.halfedges(smart_start_heh)) {
visited.push_back(vh);
}
CheckIteration(start_heh, visited);
}
}
// const mesh, with given start halfedge.
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, ConstInitializedRange) {
const auto& const_mesh = mesh_;
for (auto start_heh : const_mesh.halfedges()) {
std::vector<HEH> visited;
for (auto vh : mesh_.eh_range(start_heh)) {
visited.push_back(vh);
}
CheckIteration(start_heh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeHalfedge, ConstInitializedSmartHandleRange) {
const auto& const_mesh = mesh_;
for (auto start_heh : const_mesh.halfedges()) {
std::vector<HEH> visited;
auto smart_start_heh = make_smart(start_heh, const_mesh);
auto smart_start_eh = smart_start_heh.edge();
for (auto vh : smart_start_eh.halfedges(smart_start_heh)) {
visited.push_back(vh);
}
CheckIteration(start_heh, visited);
}
}
}

119
src/Unittests/unittests_trimesh_circulator_edge_vertex.cc Normal file
View File

@@ -0,0 +1,119 @@
#include "unittests_trimesh_circulator_edge.hh"
#include <gtest/gtest.h>
#include <Unittests/unittests_common.hh>
#include <vector>
namespace {
class OpenMeshTrimeshCirculatorEdgeVertex : public OpenMeshTrimeshCirculatorEdge {
public:
// Check that the _visited vertices comply with the expected iteration order on _eh.
void CheckIteration(EH _eh, const std::vector<VH>& _visited) {
ASSERT_TRUE(mesh_.is_valid_handle(_eh));
const auto eh = make_smart(_eh, mesh_);
std::vector<VH> expected;
for (int i = 0; i < 2; ++i) {
expected.push_back(eh.vertex(i));
}
// Elements must have been visited in the expected order.
ASSERT_EQ(_visited.size(), expected.size());
for (size_t i = 0; i < _visited.size(); ++i) {
EXPECT_EQ(_visited[i], expected[i]);
}
}
};
// Mutable mesh.
TEST_F(OpenMeshTrimeshCirculatorEdgeVertex, Iter) {
for (auto eh : mesh_.edges()) {
std::vector<VH> visited;
for (auto it = mesh_.ev_iter(eh); it.is_valid(); ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeVertex, BeginEnd) {
for (auto eh : mesh_.edges()) {
std::vector<VH> visited;
for (auto it = mesh_.ev_begin(eh), end = mesh_.ev_end(eh); it != end; ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeVertex, Range) {
for (auto eh : mesh_.edges()) {
std::vector<VH> visited;
for (auto vh : mesh_.ev_range(eh)) {
visited.push_back(vh);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeVertex, SmartHandleRange) {
for (auto eh : mesh_.edges()) {
std::vector<VH> visited;
auto smart_eh = make_smart(eh, mesh_);
for (auto vh : smart_eh.vertices()) {
visited.push_back(vh);
}
CheckIteration(eh, visited);
}
}
// const mesh.
TEST_F(OpenMeshTrimeshCirculatorEdgeVertex, ConstIter) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<VH> visited;
for (auto it = const_mesh.cev_iter(eh); it.is_valid(); ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeVertex, ConstBeginEnd) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<VH> visited;
for (auto it = const_mesh.cev_begin(eh), end = const_mesh.cev_end(eh); it != end; ++it) {
visited.push_back(*it);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeVertex, ConstRange) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<VH> visited;
for (auto vh : const_mesh.ev_range(eh)) {
visited.push_back(vh);
}
CheckIteration(eh, visited);
}
}
TEST_F(OpenMeshTrimeshCirculatorEdgeVertex, ConstSmartHandleRange) {
const auto& const_mesh = mesh_;
for (auto eh : const_mesh.edges()) {
std::vector<VH> visited;
auto smart_eh = make_smart(eh, const_mesh);
for (auto vh : smart_eh.vertices()) {
visited.push_back(vh);
}
CheckIteration(eh, visited);
}
}
}

42
src/Unittests/unittests_trimesh_navigation.cc Normal file
View File

@@ -0,0 +1,42 @@
#include <Unittests/unittests_common.hh>
#include <gtest/gtest.h>
#include <vector>
namespace {
class OpenMeshTrimeshNavigation : public OpenMeshBase {
public:
using VH = OpenMesh::VertexHandle;
using FH = OpenMesh::FaceHandle;
using EH = OpenMesh::EdgeHandle;
using HEH = OpenMesh::HalfedgeHandle;
// This function is called before each test is run.
void SetUp() override {
std::vector<VH> vh;
// 3----2
// | /|
// | / |
// | / |
// |/ |
// 0----1
vh.push_back(mesh_.add_vertex({0.0, 0.0, 0.0})); // vh[0]
vh.push_back(mesh_.add_vertex({1.0, 0.0, 0.0})); // vh[1]
vh.push_back(mesh_.add_vertex({1.0, 1.0, 0.0})); // vh[2]
vh.push_back(mesh_.add_vertex({0.0, 1.0, 0.0})); // vh[3]
mesh_.add_face(vh[0], vh[1], vh[2]);
mesh_.add_face(vh[0], vh[2], vh[3]);
}
};
TEST_F(OpenMeshTrimeshNavigation, EdgeHalfedgeDefault) {
for (EH eh : mesh_.edges()) {
EXPECT_EQ(mesh_.halfedge_handle(eh), mesh_.halfedge_handle(eh, 0));
}
}
}