Commit eb877fe9 authored by Matthias Möller's avatar Matthias Möller
Browse files

adding cw and ccw circulators

closes #2406

git-svn-id: http://www.openmesh.org/svnrepo/OpenMesh/trunk@1227 fdac6126-5c0c-442c-9429-916003d36597
parent 0f9b4c23
......@@ -845,6 +845,10 @@ All circulators provide the operations listed in
CirculatorT<Mesh>, which are basically the same as the
iterator funtions.
\note Circulators are similar to bidirectional iterators and therefore they have the bidirectional_iterator_tag.
However, the bidirectional requires that the attribute OpenMesh::Attributes::PrevHalfedge is available.
Otherwise it is just a forward iterator.
\deprecated
While it is possible to use \c operator \c bool(), which returns true, as long
as the circulator hasn't reached the end of the sequence, this function is
......@@ -855,6 +859,35 @@ to get circulators around a specified center item:
\include circulator_functions.cc
Additionally to the normal circulators there exists some for each
direction (clock-wise, counterclock-wise). Those circulators might be slower
than the normal one, but the direction of circulation is guaranteed.
You can get these types of circulators by adding the infix "ccw" or "cw" to
the function used to request the circulator of an item after the underscore.
Example:
\code
VertexVertexIter vvit = mesh.vv_iter(some_vertex_handle); // fastest (clock or counterclockwise)
VertexVertexCWIter vvcwit = mesh.vv_cwiter(some_vertex_handle); // clockwise
VertexVertexCCWIter vvccwit = mesh.vv_ccwiter(some_vertex_handle); // counter-clockwise
\endcode
It is also possible to convert a cw circulator to a ccw circulator and vice versa.
For this purpose, each circulator provides a constructor taking the other circulator as input.
If a cw circulator is converted, the ccw circulator points on the same element as
the cw circulator pointed on, but the direction for the increment and decrement changed.\n
The conversion is only valid for valid circulators. The resulting circulator from a invalid circulator is still invalid,
but might behave in a fashion not expected by normal iterators. Example:
\code
VertexVertexCWIter vvcwit = mesh.vv_cwend(some_vertex_handle);
VertexVertexCCWIter vvccwit = VertexVertexCCWIter(vvcwit); //conversion of an invalid circulator
--vvcwit; //is valid now (if the range >= 1)
++vvccwit; //can still be invalid
\endcode
CW and CCW circulators requires that OpenMesh::Attributes::PrevHalfedge is available.
\note For every circulator there also exists a constant version.
To make use of these constant circulators just add the prefix<br />
"Const" to the type specifier and add the prefix "c" to the function used to request
......
......@@ -61,7 +61,7 @@
namespace OpenMesh {
namespace Iterators {
template<class Mesh, class CenterEntityHandle>
template<class Mesh, class CenterEntityHandle, bool CW>
class GenericCirculator_CenterEntityFnsT {
public:
static void increment(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter);
......@@ -69,31 +69,61 @@ class GenericCirculator_CenterEntityFnsT {
};
template<class Mesh>
class GenericCirculator_CenterEntityFnsT<Mesh, typename Mesh::VertexHandle> {
class GenericCirculator_CenterEntityFnsT<Mesh, typename Mesh::VertexHandle, true> {
public:
inline static void increment(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
heh = mesh->cw_rotated_halfedge_handle(heh);
if (heh == start) lap_counter++;
if (heh == start) ++lap_counter;
}
inline static void decrement(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
if (heh == start) lap_counter--;
if (heh == start) --lap_counter;
heh = mesh->ccw_rotated_halfedge_handle(heh);
}
};
template<class Mesh>
class GenericCirculator_CenterEntityFnsT<Mesh, typename Mesh::FaceHandle> {
class GenericCirculator_CenterEntityFnsT<Mesh, typename Mesh::FaceHandle, true> {
public:
inline static void increment(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
heh = mesh->next_halfedge_handle(heh);
if (heh == start) lap_counter++;
if (heh == start) ++lap_counter;
}
inline static void decrement(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
if (heh == start) lap_counter--;
if (heh == start) --lap_counter;
heh = mesh->prev_halfedge_handle(heh);
}
};
/////////////////////////////////////////////////////////////
// CCW
template<class Mesh>
class GenericCirculator_CenterEntityFnsT<Mesh, typename Mesh::VertexHandle, false> {
public:
inline static void increment(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
heh = mesh->ccw_rotated_halfedge_handle(heh);
if (heh == start) ++lap_counter;
}
inline static void decrement(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
if (heh == start) --lap_counter;
heh = mesh->cw_rotated_halfedge_handle(heh);
}
};
template<class Mesh>
class GenericCirculator_CenterEntityFnsT<Mesh, typename Mesh::FaceHandle, false> {
public:
inline static void increment(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
heh = mesh->prev_halfedge_handle(heh);
if (heh == start) ++lap_counter;
}
inline static void decrement(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
if (heh == start) --lap_counter;
heh = mesh->next_halfedge_handle(heh);
}
};
/////////////////////////////////////////////////////////////
template<class Mesh, class CenterEntityHandle, class ValueHandle>
class GenericCirculator_DereferenciabilityCheckT {
public:
......@@ -116,7 +146,7 @@ class GenericCirculator_DereferenciabilityCheckT<Mesh, typename Mesh::VertexHand
}
};
template<class Mesh, class CenterEntityHandle, class ValueHandle>
template<class Mesh, class CenterEntityHandle, class ValueHandle, bool CW = true>
class GenericCirculator_ValueHandleFnsT {
public:
inline static bool is_valid(const typename Mesh::HalfedgeHandle &heh, const int lap_counter) {
......@@ -124,15 +154,15 @@ class GenericCirculator_ValueHandleFnsT {
}
inline static void init(const Mesh*, typename Mesh::HalfedgeHandle&, typename Mesh::HalfedgeHandle&, int&) {};
inline static void increment(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
GenericCirculator_CenterEntityFnsT<Mesh, CenterEntityHandle>::increment(mesh, heh, start, lap_counter);
GenericCirculator_CenterEntityFnsT<Mesh, CenterEntityHandle, CW>::increment(mesh, heh, start, lap_counter);
}
inline static void decrement(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
GenericCirculator_CenterEntityFnsT<Mesh, CenterEntityHandle>::decrement(mesh, heh, start, lap_counter);
GenericCirculator_CenterEntityFnsT<Mesh, CenterEntityHandle, CW>::decrement(mesh, heh, start, lap_counter);
}
};
template<class Mesh, class CenterEntityHandle>
class GenericCirculator_ValueHandleFnsT<Mesh, CenterEntityHandle, typename Mesh::FaceHandle> {
template<class Mesh, class CenterEntityHandle, bool CW>
class GenericCirculator_ValueHandleFnsT<Mesh, CenterEntityHandle, typename Mesh::FaceHandle, CW> {
public:
typedef GenericCirculator_DereferenciabilityCheckT<Mesh, CenterEntityHandle, typename Mesh::FaceHandle> GenericCirculator_DereferenciabilityCheck;
......@@ -145,12 +175,12 @@ class GenericCirculator_ValueHandleFnsT<Mesh, CenterEntityHandle, typename Mesh:
};
inline static void increment(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
do {
GenericCirculator_CenterEntityFnsT<Mesh, CenterEntityHandle>::increment(mesh, heh, start, lap_counter);
GenericCirculator_CenterEntityFnsT<Mesh, CenterEntityHandle, CW>::increment(mesh, heh, start, lap_counter);
} while (is_valid(heh, lap_counter) && !GenericCirculator_DereferenciabilityCheck::isDereferenciable(mesh, heh));
}
inline static void decrement(const Mesh *mesh, typename Mesh::HalfedgeHandle &heh, typename Mesh::HalfedgeHandle &start, int &lap_counter) {
do {
GenericCirculator_CenterEntityFnsT<Mesh, CenterEntityHandle>::decrement(mesh, heh, start, lap_counter);
GenericCirculator_CenterEntityFnsT<Mesh, CenterEntityHandle, CW>::decrement(mesh, heh, start, lap_counter);
} while (is_valid(heh, lap_counter) && !GenericCirculator_DereferenciabilityCheck::isDereferenciable(mesh, heh));
}
};
......@@ -217,7 +247,7 @@ class GenericCirculatorBaseT {
};
template<class Mesh, class CenterEntityHandle, class ValueHandle,
ValueHandle (GenericCirculatorBaseT<Mesh>::*Handle2Value)() const>
ValueHandle (GenericCirculatorBaseT<Mesh>::*Handle2Value)() const, bool CW = true >
class GenericCirculatorT : protected GenericCirculatorBaseT<Mesh> {
public:
typedef std::ptrdiff_t difference_type;
......@@ -228,7 +258,7 @@ class GenericCirculatorT : protected GenericCirculatorBaseT<Mesh> {
typedef typename GenericCirculatorBaseT<Mesh>::mesh_ptr mesh_ptr;
typedef typename GenericCirculatorBaseT<Mesh>::mesh_ref mesh_ref;
typedef GenericCirculator_ValueHandleFnsT<Mesh, CenterEntityHandle, ValueHandle> GenericCirculator_ValueHandleFns;
typedef GenericCirculator_ValueHandleFnsT<Mesh, CenterEntityHandle, ValueHandle, CW> GenericCirculator_ValueHandleFns;
public:
GenericCirculatorT() {}
......@@ -244,6 +274,10 @@ class GenericCirculatorT : protected GenericCirculatorBaseT<Mesh> {
}
GenericCirculatorT(const GenericCirculatorT &rhs) : GenericCirculatorBaseT<Mesh>(rhs) {}
friend class GenericCirculatorT<Mesh,CenterEntityHandle,ValueHandle,Handle2Value,!CW>;
explicit GenericCirculatorT( const GenericCirculatorT<Mesh,CenterEntityHandle,ValueHandle,Handle2Value,!CW>& rhs )
:GenericCirculatorBaseT<Mesh>(rhs){}
GenericCirculatorT& operator++() {
assert(this->mesh_);
GenericCirculator_ValueHandleFns::increment(this->mesh_, this->heh_, this->start_, this->lap_counter_);
......
......@@ -105,6 +105,14 @@ public:
typedef Iterators::GenericCirculatorT<This, This::VertexHandle, This::VertexHandle,
&Iterators::GenericCirculatorBaseT<This>::toVertexHandle>
VertexVertexIter;
typedef VertexVertexIter VertexVertexCWIter;
/**
* Enumerates 1-ring vertices in a counter clockwise fashion.
*/
typedef Iterators::GenericCirculatorT<This, This::VertexHandle, This::VertexHandle,
&Iterators::GenericCirculatorBaseT<This>::toVertexHandle, false>
VertexVertexCCWIter;
/**
* Enumerates outgoing half edges in a clockwise fashion.
......@@ -112,6 +120,14 @@ public:
typedef Iterators::GenericCirculatorT<This, This::VertexHandle, This::HalfedgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle>
VertexOHalfedgeIter;
typedef VertexOHalfedgeIter VertexOHalfedgeCWIter;
/**
* Enumerates outgoing half edges in a counter clockwise fashion.
*/
typedef Iterators::GenericCirculatorT<This, This::VertexHandle, This::HalfedgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle, false>
VertexOHalfedgeCCWIter;
/**
* Enumerates incoming half edges in a clockwise fashion.
......@@ -119,6 +135,14 @@ public:
typedef Iterators::GenericCirculatorT<This, This::VertexHandle, This::HalfedgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toOppositeHalfedgeHandle>
VertexIHalfedgeIter;
typedef VertexIHalfedgeIter VertexIHalfedgeCWIter;
/**
* Enumerates incoming half edges in a counter clockwise fashion.
*/
typedef Iterators::GenericCirculatorT<This, This::VertexHandle, This::HalfedgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toOppositeHalfedgeHandle, false>
VertexIHalfedgeCCWIter;
/**
* Enumerates incident faces in a clockwise fashion.
......@@ -126,6 +150,14 @@ public:
typedef Iterators::GenericCirculatorT<This, This::VertexHandle, This::FaceHandle,
&Iterators::GenericCirculatorBaseT<This>::toFaceHandle>
VertexFaceIter;
typedef VertexFaceIter VertexFaceCWIter;
/**
* Enumerates incident faces in a counter clockwise fashion.
*/
typedef Iterators::GenericCirculatorT<This, This::VertexHandle, This::FaceHandle,
&Iterators::GenericCirculatorBaseT<This>::toFaceHandle, false>
VertexFaceCCWIter;
/**
* Enumerates incident edges in a clockwise fashion.
......@@ -133,6 +165,13 @@ public:
typedef Iterators::GenericCirculatorT<This, This::VertexHandle, This::EdgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toEdgeHandle>
VertexEdgeIter;
typedef VertexEdgeIter VertexEdgeCWIter;
/**
* Enumerates incident edges in a counter clockwise fashion.
*/
typedef Iterators::GenericCirculatorT<This, This::VertexHandle, This::EdgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toEdgeHandle, false>
VertexEdgeCCWIter;
/**
* Identical to #FaceHalfedgeIter. God knows why this typedef exists.
......@@ -140,12 +179,29 @@ public:
typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::HalfedgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle>
HalfedgeLoopIter;
typedef VertexVertexIter ConstVertexVertexIter;
typedef VertexOHalfedgeIter ConstVertexOHalfedgeIter;
typedef VertexIHalfedgeIter ConstVertexIHalfedgeIter;
typedef VertexFaceIter ConstVertexFaceIter;
typedef VertexEdgeIter ConstVertexEdgeIter;
typedef HalfedgeLoopIter HalfedgeLoopCWIter;
/**
* Identical to #FaceHalfedgeIter. God knows why this typedef exists.
*/
typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::HalfedgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle, false>
HalfedgeLoopCCWIter;
typedef VertexVertexIter ConstVertexVertexIter;
typedef VertexVertexCWIter ConstVertexVertexCWIter;
typedef VertexVertexCCWIter ConstVertexVertexCCWIter;
typedef VertexOHalfedgeIter ConstVertexOHalfedgeIter;
typedef VertexOHalfedgeCWIter ConstVertexOHalfedgeCWIter;
typedef VertexOHalfedgeCCWIter ConstVertexOHalfedgeCCWIter;
typedef VertexIHalfedgeIter ConstVertexIHalfedgeIter;
typedef VertexIHalfedgeCWIter ConstVertexIHalfedgeCWIter;
typedef VertexIHalfedgeCCWIter ConstVertexIHalfedgeCCWIter;
typedef VertexFaceIter ConstVertexFaceIter;
typedef VertexFaceCWIter ConstVertexFaceCWIter;
typedef VertexFaceCCWIter ConstVertexFaceCCWIter;
typedef VertexEdgeIter ConstVertexEdgeIter;
typedef VertexEdgeCWIter ConstVertexEdgeCWIter;
typedef VertexEdgeCCWIter ConstVertexEdgeCCWIter;
/*
* Face-centered circulators
......@@ -157,6 +213,14 @@ public:
typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::VertexHandle,
&Iterators::GenericCirculatorBaseT<This>::toVertexHandle>
FaceVertexIter;
typedef FaceVertexIter FaceVertexCCWIter;
/**
* Enumerate incident vertices in a clockwise fashion.
*/
typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::VertexHandle,
&Iterators::GenericCirculatorBaseT<This>::toVertexHandle, false>
FaceVertexCWIter;
/**
* Enumerate incident half edges in a counter clockwise fashion.
......@@ -164,6 +228,14 @@ public:
typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::HalfedgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle>
FaceHalfedgeIter;
typedef FaceHalfedgeIter FaceHalfedgeCCWIter;
/**
* Enumerate incident half edges in a clockwise fashion.
*/
typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::HalfedgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toHalfedgeHandle, false>
FaceHalfedgeCWIter;
/**
* Enumerate incident edges in a counter clockwise fashion.
......@@ -171,6 +243,14 @@ public:
typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::EdgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toEdgeHandle>
FaceEdgeIter;
typedef FaceEdgeIter FaceEdgeCCWIter;
/**
* Enumerate incident edges in a clockwise fashion.
*/
typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::EdgeHandle,
&Iterators::GenericCirculatorBaseT<This>::toEdgeHandle, false>
FaceEdgeCWIter;
/**
* Enumerate adjacent faces in a counter clockwise fashion.
......@@ -178,16 +258,34 @@ public:
typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::FaceHandle,
&Iterators::GenericCirculatorBaseT<This>::toOppositeFaceHandle>
FaceFaceIter;
typedef FaceFaceIter FaceFaceCCWIter;
typedef FaceVertexIter ConstFaceVertexIter;
typedef FaceHalfedgeIter ConstFaceHalfedgeIter;
typedef FaceEdgeIter ConstFaceEdgeIter;
typedef FaceFaceIter ConstFaceFaceIter;
/**
* Enumerate adjacent faces in a clockwise fashion.
*/
typedef Iterators::GenericCirculatorT<This, This::FaceHandle, This::FaceHandle,
&Iterators::GenericCirculatorBaseT<This>::toOppositeFaceHandle, false>
FaceFaceCWIter;
typedef FaceVertexIter ConstFaceVertexIter;
typedef FaceVertexCWIter ConstFaceVertexCWIter;
typedef FaceVertexCCWIter ConstFaceVertexCCWIter;
typedef FaceHalfedgeIter ConstFaceHalfedgeIter;
typedef FaceHalfedgeCWIter ConstFaceHalfedgeCWIter;
typedef FaceHalfedgeCCWIter ConstFaceHalfedgeCCWIter;
typedef FaceEdgeIter ConstFaceEdgeIter;
typedef FaceEdgeCWIter ConstFaceEdgeCWIter;
typedef FaceEdgeCCWIter ConstFaceEdgeCCWIter;
typedef FaceFaceIter ConstFaceFaceIter;
typedef FaceFaceCWIter ConstFaceFaceCWIter;
typedef FaceFaceCCWIter ConstFaceFaceCCWIter;
/*
* Halfedge circulator
*/
typedef HalfedgeLoopIter ConstHalfedgeLoopIter;
typedef HalfedgeLoopIter ConstHalfedgeLoopIter;
typedef HalfedgeLoopCWIter ConstHalfedgeLoopCWIter;
typedef HalfedgeLoopCCWIter ConstHalfedgeLoopCCWIter;
//@}
......@@ -213,25 +311,59 @@ public:
typedef ConstEdgeIter CEIter;
typedef ConstFaceIter CFIter;
typedef VertexVertexIter VVIter;
typedef VertexOHalfedgeIter VOHIter;
typedef VertexIHalfedgeIter VIHIter;
typedef VertexEdgeIter VEIter;
typedef VertexFaceIter VFIter;
typedef FaceVertexIter FVIter;
typedef FaceHalfedgeIter FHIter;
typedef FaceEdgeIter FEIter;
typedef FaceFaceIter FFIter;
typedef ConstVertexVertexIter CVVIter;
typedef ConstVertexOHalfedgeIter CVOHIter;
typedef ConstVertexIHalfedgeIter CVIHIter;
typedef ConstVertexEdgeIter CVEIter;
typedef ConstVertexFaceIter CVFIter;
typedef ConstFaceVertexIter CFVIter;
typedef ConstFaceHalfedgeIter CFHIter;
typedef ConstFaceEdgeIter CFEIter;
typedef ConstFaceFaceIter CFFIter;
typedef VertexVertexIter VVIter;
typedef VertexVertexCWIter VVCWIter;
typedef VertexVertexCCWIter VVCCWIter;
typedef VertexOHalfedgeIter VOHIter;
typedef VertexOHalfedgeCWIter VOHCWIter;
typedef VertexOHalfedgeCCWIter VOHCCWIter;
typedef VertexIHalfedgeIter VIHIter;
typedef VertexIHalfedgeCWIter VIHICWter;
typedef VertexIHalfedgeCCWIter VIHICCWter;
typedef VertexEdgeIter VEIter;
typedef VertexEdgeCWIter VECWIter;
typedef VertexEdgeCCWIter VECCWIter;
typedef VertexFaceIter VFIter;
typedef VertexFaceCWIter VFCWIter;
typedef VertexFaceCCWIter VFCCWIter;
typedef FaceVertexIter FVIter;
typedef FaceVertexCWIter FVCWIter;
typedef FaceVertexCCWIter FVCCWIter;
typedef FaceHalfedgeIter FHIter;
typedef FaceHalfedgeCWIter FHCWIter;
typedef FaceHalfedgeCCWIter FHCWWIter;
typedef FaceEdgeIter FEIter;
typedef FaceEdgeCWIter FECWIter;
typedef FaceEdgeCCWIter FECWWIter;
typedef FaceFaceIter FFIter;
typedef ConstVertexVertexIter CVVIter;
typedef ConstVertexVertexCWIter CVVCWIter;
typedef ConstVertexVertexCCWIter CVVCCWIter;
typedef ConstVertexOHalfedgeIter CVOHIter;
typedef ConstVertexOHalfedgeCWIter CVOHCWIter;
typedef ConstVertexOHalfedgeCCWIter CVOHCCWIter;
typedef ConstVertexIHalfedgeIter CVIHIter;
typedef ConstVertexIHalfedgeCWIter CVIHCWIter;
typedef ConstVertexIHalfedgeCCWIter CVIHCCWIter;
typedef ConstVertexEdgeIter CVEIter;
typedef ConstVertexEdgeCWIter CVECWIter;
typedef ConstVertexEdgeCCWIter CVECCWIter;
typedef ConstVertexFaceIter CVFIter;
typedef ConstVertexFaceCWIter CVFCWIter;
typedef ConstVertexFaceCCWIter CVFCCWIter;
typedef ConstFaceVertexIter CFVIter;
typedef ConstFaceVertexCWIter CFVCWIter;
typedef ConstFaceVertexCCWIter CFVCCWIter;
typedef ConstFaceHalfedgeIter CFHIter;
typedef ConstFaceHalfedgeCWIter CFHCWIter;
typedef ConstFaceHalfedgeCCWIter CFHCCWIter;
typedef ConstFaceEdgeIter CFEIter;
typedef ConstFaceEdgeCWIter CFECWIter;
typedef ConstFaceEdgeCCWIter CFECCWIter;
typedef ConstFaceFaceIter CFFIter;
typedef ConstFaceFaceCWIter CFFCWIter;
typedef ConstFaceFaceCCWIter CFFCCWIter;
//@}
public:
......@@ -426,192 +558,541 @@ public:
/// vertex - vertex circulator
VertexVertexIter vv_iter(VertexHandle _vh)
{ return VertexVertexIter(*this, _vh); }
/// vertex - vertex circulator cw
VertexVertexCWIter vv_cwiter(VertexHandle _vh)
{ return VertexVertexCWIter(*this, _vh); }
/// vertex - vertex circulator ccw
VertexVertexCCWIter vv_ccwiter(VertexHandle _vh)
{ return VertexVertexCCWIter(*this, _vh); }
/// vertex - incoming halfedge circulator
VertexIHalfedgeIter vih_iter(VertexHandle _vh)
{ return VertexIHalfedgeIter(*this, _vh); }
/// vertex - incoming halfedge circulator cw
VertexIHalfedgeCWIter vih_cwiter(VertexHandle _vh)
{ return VertexIHalfedgeCWIter(*this, _vh); }
/// vertex - incoming halfedge circulator ccw
VertexIHalfedgeCCWIter vih_ccwiter(VertexHandle _vh)
{ return VertexIHalfedgeCCWIter(*this, _vh); }
/// vertex - outgoing halfedge circulator
VertexOHalfedgeIter voh_iter(VertexHandle _vh)
{ return VertexOHalfedgeIter(*this, _vh); }
/// vertex - outgoing halfedge circulator cw
VertexOHalfedgeCWIter voh_cwiter(VertexHandle _vh)
{ return VertexOHalfedgeCWIter(*this, _vh); }
/// vertex - outgoing halfedge circulator ccw
VertexOHalfedgeCCWIter voh_ccwiter(VertexHandle _vh)
{ return VertexOHalfedgeCCWIter(*this, _vh); }
/// vertex - edge circulator
VertexEdgeIter ve_iter(VertexHandle _vh)
{ return VertexEdgeIter(*this, _vh); }
/// vertex - edge circulator cw
VertexEdgeCWIter ve_cwiter(VertexHandle _vh)
{ return VertexEdgeCWIter(*this, _vh); }
/// vertex - edge circulator ccw
VertexEdgeCCWIter ve_ccwiter(VertexHandle _vh)
{ return VertexEdgeCCWIter(*this, _vh); }
/// vertex - face circulator
VertexFaceIter vf_iter(VertexHandle _vh)
{ return VertexFaceIter(*this, _vh); }
/// vertex - face circulator cw
VertexFaceCWIter vf_cwiter(VertexHandle _vh)
{ return VertexFaceCWIter(*this, _vh); }
/// vertex - face circulator ccw
VertexFaceCCWIter vf_ccwiter(VertexHandle _vh)
{ return VertexFaceCCWIter(*this, _vh); }
/// const vertex circulator
ConstVertexVertexIter cvv_iter(VertexHandle _vh) const
{ return ConstVertexVertexIter(*this, _vh); }
/// const vertex circulator cw
ConstVertexVertexCWIter cvv_cwiter(VertexHandle _vh) const
{ return ConstVertexVertexCWIter(*this, _vh); }
/// const vertex circulator ccw
ConstVertexVertexCCWIter cvv_ccwiter(VertexHandle _vh) const
{ return ConstVertexVertexCCWIter(*this, _vh); }
/// const vertex - incoming halfedge circulator
ConstVertexIHalfedgeIter cvih_iter(VertexHandle _vh) const
{ return ConstVertexIHalfedgeIter(*this, _vh); }
/// const vertex - incoming halfedge circulator cw
ConstVertexIHalfedgeCWIter cvih_cwiter(VertexHandle _vh) const
{ return ConstVertexIHalfedgeCWIter(*this, _vh); }
/// const vertex - incoming halfedge circulator ccw
ConstVertexIHalfedgeCCWIter cvih_ccwiter(VertexHandle _vh) const
{ return ConstVertexIHalfedgeCCWIter(*this, _vh); }
/// const vertex - outgoing halfedge circulator
ConstVertexOHalfedgeIter cvoh_iter(VertexHandle _vh) const
{ return ConstVertexOHalfedgeIter(*this, _vh); }
/// const vertex - outgoing halfedge circulator cw
ConstVertexOHalfedgeCWIter cvoh_cwiter(VertexHandle _vh) const
{ return ConstVertexOHalfedgeCWIter(*this, _vh); }
/// const vertex - outgoing halfedge circulator ccw
ConstVertexOHalfedgeCCWIter cvoh_ccwiter(VertexHandle _vh) const
{ return ConstVertexOHalfedgeCCWIter(*this, _vh); }
/// const vertex - edge circulator
ConstVertexEdgeIter cve_iter(VertexHandle _vh) const
{ return ConstVertexEdgeIter(*this, _vh); }
/// const vertex - edge circulator cw
ConstVertexEdgeCWIter cve_cwiter(VertexHandle _vh) const
{ return ConstVertexEdgeCWIter(*this, _vh); }
/// const vertex - edge circulator ccw
ConstVertexEdgeCCWIter cve_ccwiter(VertexHandle _vh) const
{ return ConstVertexEdgeCCWIter(*this, _vh); }
/// const vertex - face circulator
ConstVertexFaceIter cvf_iter(VertexHandle _vh) const
{ return ConstVertexFaceIter(*this, _vh); }
/// const vertex - face circulator cw
ConstVertexFaceCWIter cvf_cwiter(VertexHandle _vh) const
{ return ConstVertexFaceCWIter(*this, _vh); }
/// const vertex - face circulator ccw
ConstVertexFaceCCWIter cvf_ccwiter(VertexHandle _vh) const
{ return ConstVertexFaceCCWIter(*this, _vh); }
/// face - vertex circulator
FaceVertexIter fv_iter(FaceHandle _fh)
{ return FaceVertexIter(*this, _fh); }
/// face - vertex circulator cw
FaceVertexCWIter fv_cwiter(FaceHandle _fh)
{ return FaceVertexCWIter(*this, _fh); }
/// face - vertex circulator ccw
FaceVertexCCWIter fv_ccwiter(FaceHandle _fh)
{ return FaceVertexCCWIter(*this, _fh); }
/// face - halfedge circulator
FaceHalfedgeIter fh_iter(FaceHandle _fh)
{ return FaceHalfedgeIter(*this, _fh); }
/// face - halfedge circulator cw
FaceHalfedgeCWIter fh_cwiter(FaceHandle _fh)
{ return FaceHalfedgeCWIter(*this, _fh); }
/// face - halfedge circulator ccw
FaceHalfedgeCCWIter fh_ccwiter(FaceHandle _fh)
{ return FaceHalfedgeCCWIter(*this, _fh); }
/// face - edge circulator
FaceEdgeIter fe_iter(FaceHandle _fh)
{ return FaceEdgeIter(*this, _fh); }
/// face - edge circulator cw
FaceEdgeCWIter fe_cwiter(FaceHandle _fh)
{ return FaceEdgeCWIter(*this, _fh); }
/// face - edge circulator ccw
FaceEdgeCCWIter fe_ccwiter(FaceHandle _fh)
{ return FaceEdgeCCWIter(*this, _fh); }
/// face - face circulator
FaceFaceIter ff_iter(FaceHandle _fh)
{ return FaceFaceIter(*this, _fh); }
/// face - face circulator cw
FaceFaceCWIter ff_cwiter(FaceHandle _fh)
{ return FaceFaceCWIter(*this, _fh); }
/// face - face circulator ccw
FaceFaceCCWIter ff_ccwiter(FaceHandle _fh)
{ return FaceFaceCCWIter(*this, _fh); }
/// const face - vertex circulator
ConstFaceVertexIter cfv_iter(FaceHandle _fh) const
{ return ConstFaceVertexIter(*this, _fh); }