42 #ifndef OPENMESH_CIRCULATORS_HH
43 #define OPENMESH_CIRCULATORS_HH
54 #include <OpenMesh/Core/System/config.h>
68 template <
class Mesh>
class VertexVertexIterT;
69 template <
class Mesh>
class VertexIHalfedgeIterT;
70 template <
class Mesh>
class VertexOHalfedgeIterT;
71 template <
class Mesh>
class VertexEdgeIterT;
72 template <
class Mesh>
class VertexFaceIterT;
74 template <
class Mesh>
class ConstVertexVertexIterT;
75 template <
class Mesh>
class ConstVertexIHalfedgeIterT;
76 template <
class Mesh>
class ConstVertexOHalfedgeIterT;
77 template <
class Mesh>
class ConstVertexEdgeIterT;
78 template <
class Mesh>
class ConstVertexFaceIterT;
80 template <
class Mesh>
class FaceVertexIterT;
81 template <
class Mesh>
class FaceHalfedgeIterT;
82 template <
class Mesh>
class FaceEdgeIterT;
83 template <
class Mesh>
class FaceFaceIterT;
85 template <
class Mesh>
class ConstFaceVertexIterT;
86 template <
class Mesh>
class ConstFaceHalfedgeIterT;
87 template <
class Mesh>
class ConstFaceEdgeIterT;
88 template <
class Mesh>
class ConstFaceFaceIterT;
107 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
109 typedef typename Mesh::Vertex value_type;
110 typedef typename Mesh::VertexHandle value_handle;
113 typedef std::bidirectional_iterator_tag iterator_category;
114 typedef std::ptrdiff_t difference_type;
115 typedef const Mesh& mesh_ref;
116 typedef const Mesh* mesh_ptr;
117 typedef const typename Mesh::Vertex& reference;
118 typedef const typename Mesh::Vertex* pointer;
120 typedef std::bidirectional_iterator_tag iterator_category;
121 typedef std::ptrdiff_t difference_type;
122 typedef Mesh& mesh_ref;
123 typedef Mesh* mesh_ptr;
124 typedef typename Mesh::Vertex& reference;
125 typedef typename Mesh::Vertex* pointer;
137 start_(_mesh.halfedge_handle(_start)),
157 lap_counter_(_rhs.lap_counter_)
165 start_ = _rhs.start_;
167 lap_counter_ = _rhs.lap_counter_;
178 lap_counter_(_rhs.lap_counter_)
186 start_ = _rhs.start_;
188 lap_counter_ = _rhs.lap_counter_;
192 friend class ConstVertexVertexIterT<Mesh>;
198 return ((mesh_ == _rhs.mesh_) &&
199 (start_ == _rhs.start_) &&
200 (heh_ == _rhs.heh_) &&
201 (lap_counter_ == _rhs.lap_counter_));
214 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
215 if(heh_ == start_) lap_counter_++;
223 if(heh_ == start_) lap_counter_--;
224 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
239 typename Mesh::VertexHandle
handle()
const {
241 return mesh_->to_vertex_handle(heh_);;
246 operator typename Mesh::VertexHandle()
const {
248 return mesh_->to_vertex_handle(heh_);;
255 return mesh_->deref(
handle());
262 return &mesh_->deref(
handle());
272 operator bool()
const {
273 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
293 template <
class Mesh>
301 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
303 typedef typename Mesh::Vertex value_type;
304 typedef typename Mesh::VertexHandle value_handle;
307 typedef std::bidirectional_iterator_tag iterator_category;
308 typedef std::ptrdiff_t difference_type;
309 typedef const Mesh& mesh_ref;
310 typedef const Mesh* mesh_ptr;
311 typedef const typename Mesh::Vertex& reference;
312 typedef const typename Mesh::Vertex* pointer;
314 typedef std::bidirectional_iterator_tag iterator_category;
315 typedef std::ptrdiff_t difference_type;
316 typedef Mesh& mesh_ref;
317 typedef Mesh* mesh_ptr;
318 typedef typename Mesh::Vertex& reference;
319 typedef typename Mesh::Vertex* pointer;
331 start_(_mesh.halfedge_handle(_start)),
351 lap_counter_(_rhs.lap_counter_)
359 start_ = _rhs.start_;
361 lap_counter_ = _rhs.lap_counter_;
372 lap_counter_(_rhs.lap_counter_)
380 start_ = _rhs.start_;
382 lap_counter_ = _rhs.lap_counter_;
392 return ((mesh_ == _rhs.mesh_) &&
393 (start_ == _rhs.start_) &&
394 (heh_ == _rhs.heh_) &&
395 (lap_counter_ == _rhs.lap_counter_));
408 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
409 if(heh_ == start_) lap_counter_++;
417 if(heh_ == start_) lap_counter_--;
418 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
433 typename Mesh::VertexHandle
handle()
const {
435 return mesh_->to_vertex_handle(heh_);;
440 operator typename Mesh::VertexHandle()
const {
442 return mesh_->to_vertex_handle(heh_);;
449 return mesh_->deref(
handle());
456 return &mesh_->deref(
handle());
466 operator bool()
const {
467 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
487 template <
class Mesh>
495 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
497 typedef typename Mesh::Halfedge value_type;
498 typedef typename Mesh::HalfedgeHandle value_handle;
501 typedef std::bidirectional_iterator_tag iterator_category;
502 typedef std::ptrdiff_t difference_type;
503 typedef const Mesh& mesh_ref;
504 typedef const Mesh* mesh_ptr;
505 typedef const typename Mesh::Halfedge& reference;
506 typedef const typename Mesh::Halfedge* pointer;
508 typedef std::bidirectional_iterator_tag iterator_category;
509 typedef std::ptrdiff_t difference_type;
510 typedef Mesh& mesh_ref;
511 typedef Mesh* mesh_ptr;
512 typedef typename Mesh::Halfedge& reference;
513 typedef typename Mesh::Halfedge* pointer;
525 start_(_mesh.halfedge_handle(_start)),
545 lap_counter_(_rhs.lap_counter_)
553 start_ = _rhs.start_;
555 lap_counter_ = _rhs.lap_counter_;
566 lap_counter_(_rhs.lap_counter_)
574 start_ = _rhs.start_;
576 lap_counter_ = _rhs.lap_counter_;
580 friend class ConstVertexOHalfedgeIterT<Mesh>;
586 return ((mesh_ == _rhs.mesh_) &&
587 (start_ == _rhs.start_) &&
588 (heh_ == _rhs.heh_) &&
589 (lap_counter_ == _rhs.lap_counter_));
602 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
603 if(heh_ == start_) lap_counter_++;
611 if(heh_ == start_) lap_counter_--;
612 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
627 typename Mesh::HalfedgeHandle
handle()
const {
634 operator typename Mesh::HalfedgeHandle()
const {
643 return mesh_->deref(
handle());
650 return &mesh_->deref(
handle());
660 operator bool()
const {
661 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
681 template <
class Mesh>
689 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
691 typedef typename Mesh::Halfedge value_type;
692 typedef typename Mesh::HalfedgeHandle value_handle;
695 typedef std::bidirectional_iterator_tag iterator_category;
696 typedef std::ptrdiff_t difference_type;
697 typedef const Mesh& mesh_ref;
698 typedef const Mesh* mesh_ptr;
699 typedef const typename Mesh::Halfedge& reference;
700 typedef const typename Mesh::Halfedge* pointer;
702 typedef std::bidirectional_iterator_tag iterator_category;
703 typedef std::ptrdiff_t difference_type;
704 typedef Mesh& mesh_ref;
705 typedef Mesh* mesh_ptr;
706 typedef typename Mesh::Halfedge& reference;
707 typedef typename Mesh::Halfedge* pointer;
719 start_(_mesh.halfedge_handle(_start)),
739 lap_counter_(_rhs.lap_counter_)
747 start_ = _rhs.start_;
749 lap_counter_ = _rhs.lap_counter_;
760 lap_counter_(_rhs.lap_counter_)
768 start_ = _rhs.start_;
770 lap_counter_ = _rhs.lap_counter_;
780 return ((mesh_ == _rhs.mesh_) &&
781 (start_ == _rhs.start_) &&
782 (heh_ == _rhs.heh_) &&
783 (lap_counter_ == _rhs.lap_counter_));
796 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
797 if(heh_ == start_) lap_counter_++;
805 if(heh_ == start_) lap_counter_--;
806 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
821 typename Mesh::HalfedgeHandle
handle()
const {
828 operator typename Mesh::HalfedgeHandle()
const {
837 return mesh_->deref(
handle());
844 return &mesh_->deref(
handle());
854 operator bool()
const {
855 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
875 template <
class Mesh>
883 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
885 typedef typename Mesh::Halfedge value_type;
886 typedef typename Mesh::HalfedgeHandle value_handle;
889 typedef std::bidirectional_iterator_tag iterator_category;
890 typedef std::ptrdiff_t difference_type;
891 typedef const Mesh& mesh_ref;
892 typedef const Mesh* mesh_ptr;
893 typedef const typename Mesh::Halfedge& reference;
894 typedef const typename Mesh::Halfedge* pointer;
896 typedef std::bidirectional_iterator_tag iterator_category;
897 typedef std::ptrdiff_t difference_type;
898 typedef Mesh& mesh_ref;
899 typedef Mesh* mesh_ptr;
900 typedef typename Mesh::Halfedge& reference;
901 typedef typename Mesh::Halfedge* pointer;
913 start_(_mesh.halfedge_handle(_start)),
933 lap_counter_(_rhs.lap_counter_)
941 start_ = _rhs.start_;
943 lap_counter_ = _rhs.lap_counter_;
954 lap_counter_(_rhs.lap_counter_)
962 start_ = _rhs.start_;
964 lap_counter_ = _rhs.lap_counter_;
968 friend class ConstVertexIHalfedgeIterT<Mesh>;
974 return ((mesh_ == _rhs.mesh_) &&
975 (start_ == _rhs.start_) &&
976 (heh_ == _rhs.heh_) &&
977 (lap_counter_ == _rhs.lap_counter_));
990 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
991 if(heh_ == start_) lap_counter_++;
999 if(heh_ == start_) lap_counter_--;
1000 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
1015 typename Mesh::HalfedgeHandle
handle()
const {
1017 return mesh_->opposite_halfedge_handle(heh_);
1022 operator typename Mesh::HalfedgeHandle()
const {
1024 return mesh_->opposite_halfedge_handle(heh_);
1031 return mesh_->deref(
handle());
1038 return &mesh_->deref(
handle());
1048 operator bool()
const {
1049 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
1069 template <
class Mesh>
1077 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
1079 typedef typename Mesh::Halfedge value_type;
1080 typedef typename Mesh::HalfedgeHandle value_handle;
1083 typedef std::bidirectional_iterator_tag iterator_category;
1084 typedef std::ptrdiff_t difference_type;
1085 typedef const Mesh& mesh_ref;
1086 typedef const Mesh* mesh_ptr;
1087 typedef const typename Mesh::Halfedge& reference;
1088 typedef const typename Mesh::Halfedge* pointer;
1090 typedef std::bidirectional_iterator_tag iterator_category;
1091 typedef std::ptrdiff_t difference_type;
1092 typedef Mesh& mesh_ref;
1093 typedef Mesh* mesh_ptr;
1094 typedef typename Mesh::Halfedge& reference;
1095 typedef typename Mesh::Halfedge* pointer;
1107 start_(_mesh.halfedge_handle(_start)),
1125 start_(_rhs.start_),
1127 lap_counter_(_rhs.lap_counter_)
1135 start_ = _rhs.start_;
1137 lap_counter_ = _rhs.lap_counter_;
1146 start_(_rhs.start_),
1148 lap_counter_(_rhs.lap_counter_)
1156 start_ = _rhs.start_;
1158 lap_counter_ = _rhs.lap_counter_;
1168 return ((mesh_ == _rhs.mesh_) &&
1169 (start_ == _rhs.start_) &&
1170 (heh_ == _rhs.heh_) &&
1171 (lap_counter_ == _rhs.lap_counter_));
1184 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
1185 if(heh_ == start_) lap_counter_++;
1193 if(heh_ == start_) lap_counter_--;
1194 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
1209 typename Mesh::HalfedgeHandle
handle()
const {
1211 return mesh_->opposite_halfedge_handle(heh_);
1216 operator typename Mesh::HalfedgeHandle()
const {
1218 return mesh_->opposite_halfedge_handle(heh_);
1225 return mesh_->deref(
handle());
1232 return &mesh_->deref(
handle());
1242 operator bool()
const {
1243 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
1263 template <
class Mesh>
1271 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
1273 typedef typename Mesh::Edge value_type;
1274 typedef typename Mesh::EdgeHandle value_handle;
1277 typedef std::bidirectional_iterator_tag iterator_category;
1278 typedef std::ptrdiff_t difference_type;
1279 typedef const Mesh& mesh_ref;
1280 typedef const Mesh* mesh_ptr;
1281 typedef const typename Mesh::Edge& reference;
1282 typedef const typename Mesh::Edge* pointer;
1284 typedef std::bidirectional_iterator_tag iterator_category;
1285 typedef std::ptrdiff_t difference_type;
1286 typedef Mesh& mesh_ref;
1287 typedef Mesh* mesh_ptr;
1288 typedef typename Mesh::Edge& reference;
1289 typedef typename Mesh::Edge* pointer;
1301 start_(_mesh.halfedge_handle(_start)),
1319 start_(_rhs.start_),
1321 lap_counter_(_rhs.lap_counter_)
1329 start_ = _rhs.start_;
1331 lap_counter_ = _rhs.lap_counter_;
1340 start_(_rhs.start_),
1342 lap_counter_(_rhs.lap_counter_)
1350 start_ = _rhs.start_;
1352 lap_counter_ = _rhs.lap_counter_;
1356 friend class ConstVertexEdgeIterT<Mesh>;
1362 return ((mesh_ == _rhs.mesh_) &&
1363 (start_ == _rhs.start_) &&
1364 (heh_ == _rhs.heh_) &&
1365 (lap_counter_ == _rhs.lap_counter_));
1378 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
1379 if(heh_ == start_) lap_counter_++;
1387 if(heh_ == start_) lap_counter_--;
1388 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
1405 return mesh_->edge_handle(heh_);
1410 operator typename Mesh::EdgeHandle()
const {
1412 return mesh_->edge_handle(heh_);
1419 return mesh_->deref(
handle());
1426 return &mesh_->deref(
handle());
1436 operator bool()
const {
1437 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
1457 template <
class Mesh>
1465 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
1467 typedef typename Mesh::Edge value_type;
1468 typedef typename Mesh::EdgeHandle value_handle;
1471 typedef std::bidirectional_iterator_tag iterator_category;
1472 typedef std::ptrdiff_t difference_type;
1473 typedef const Mesh& mesh_ref;
1474 typedef const Mesh* mesh_ptr;
1475 typedef const typename Mesh::Edge& reference;
1476 typedef const typename Mesh::Edge* pointer;
1478 typedef std::bidirectional_iterator_tag iterator_category;
1479 typedef std::ptrdiff_t difference_type;
1480 typedef Mesh& mesh_ref;
1481 typedef Mesh* mesh_ptr;
1482 typedef typename Mesh::Edge& reference;
1483 typedef typename Mesh::Edge* pointer;
1495 start_(_mesh.halfedge_handle(_start)),
1513 start_(_rhs.start_),
1515 lap_counter_(_rhs.lap_counter_)
1523 start_ = _rhs.start_;
1525 lap_counter_ = _rhs.lap_counter_;
1534 start_(_rhs.start_),
1536 lap_counter_(_rhs.lap_counter_)
1544 start_ = _rhs.start_;
1546 lap_counter_ = _rhs.lap_counter_;
1556 return ((mesh_ == _rhs.mesh_) &&
1557 (start_ == _rhs.start_) &&
1558 (heh_ == _rhs.heh_) &&
1559 (lap_counter_ == _rhs.lap_counter_));
1572 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
1573 if(heh_ == start_) lap_counter_++;
1581 if(heh_ == start_) lap_counter_--;
1582 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
1599 return mesh_->edge_handle(heh_);
1604 operator typename Mesh::EdgeHandle()
const {
1606 return mesh_->edge_handle(heh_);
1613 return mesh_->deref(
handle());
1620 return &mesh_->deref(
handle());
1630 operator bool()
const {
1631 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
1651 template <
class Mesh>
1659 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
1661 typedef typename Mesh::Face value_type;
1662 typedef typename Mesh::FaceHandle value_handle;
1665 typedef std::bidirectional_iterator_tag iterator_category;
1666 typedef std::ptrdiff_t difference_type;
1667 typedef const Mesh& mesh_ref;
1668 typedef const Mesh* mesh_ptr;
1669 typedef const typename Mesh::Face& reference;
1670 typedef const typename Mesh::Face* pointer;
1672 typedef std::bidirectional_iterator_tag iterator_category;
1673 typedef std::ptrdiff_t difference_type;
1674 typedef Mesh& mesh_ref;
1675 typedef Mesh* mesh_ptr;
1676 typedef typename Mesh::Face& reference;
1677 typedef typename Mesh::Face* pointer;
1689 start_(_mesh.halfedge_handle(_start)),
1692 {
if (heh_.is_valid() && !
handle().is_valid() && !_end)
operator++();; }
1701 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
1707 start_(_rhs.start_),
1709 lap_counter_(_rhs.lap_counter_)
1710 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
1717 start_ = _rhs.start_;
1719 lap_counter_ = _rhs.lap_counter_;
1728 start_(_rhs.start_),
1730 lap_counter_(_rhs.lap_counter_)
1731 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
1738 start_ = _rhs.start_;
1740 lap_counter_ = _rhs.lap_counter_;
1744 friend class ConstVertexFaceIterT<Mesh>;
1750 return ((mesh_ == _rhs.mesh_) &&
1751 (start_ == _rhs.start_) &&
1752 (heh_ == _rhs.heh_) &&
1753 (lap_counter_ == _rhs.lap_counter_));
1766 do { heh_=mesh_->cw_rotated_halfedge_handle(heh_);
if(heh_ == start_) lap_counter_++; }
while ((*
this) && (!
handle().is_valid()));;
1774 do {
if(heh_ == start_) lap_counter_--; heh_=mesh_->ccw_rotated_halfedge_handle(heh_); }
while ((*
this) && (!
handle().is_valid()));;
1791 return mesh_->face_handle(heh_);
1796 operator typename Mesh::FaceHandle()
const {
1798 return mesh_->face_handle(heh_);
1805 return mesh_->deref(
handle());
1812 return &mesh_->deref(
handle());
1822 operator bool()
const {
1823 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
1843 template <
class Mesh>
1851 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
1853 typedef typename Mesh::Face value_type;
1854 typedef typename Mesh::FaceHandle value_handle;
1857 typedef std::bidirectional_iterator_tag iterator_category;
1858 typedef std::ptrdiff_t difference_type;
1859 typedef const Mesh& mesh_ref;
1860 typedef const Mesh* mesh_ptr;
1861 typedef const typename Mesh::Face& reference;
1862 typedef const typename Mesh::Face* pointer;
1864 typedef std::bidirectional_iterator_tag iterator_category;
1865 typedef std::ptrdiff_t difference_type;
1866 typedef Mesh& mesh_ref;
1867 typedef Mesh* mesh_ptr;
1868 typedef typename Mesh::Face& reference;
1869 typedef typename Mesh::Face* pointer;
1881 start_(_mesh.halfedge_handle(_start)),
1884 {
if (heh_.is_valid() && !
handle().is_valid() && !_end)
operator++();; }
1893 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
1899 start_(_rhs.start_),
1901 lap_counter_(_rhs.lap_counter_)
1902 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
1909 start_ = _rhs.start_;
1911 lap_counter_ = _rhs.lap_counter_;
1920 start_(_rhs.start_),
1922 lap_counter_(_rhs.lap_counter_)
1923 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
1930 start_ = _rhs.start_;
1932 lap_counter_ = _rhs.lap_counter_;
1942 return ((mesh_ == _rhs.mesh_) &&
1943 (start_ == _rhs.start_) &&
1944 (heh_ == _rhs.heh_) &&
1945 (lap_counter_ == _rhs.lap_counter_));
1958 do { heh_=mesh_->cw_rotated_halfedge_handle(heh_);
if(heh_ == start_) lap_counter_++; }
while ((*
this) && (!
handle().is_valid()));;
1966 do {
if(heh_ == start_) lap_counter_--; heh_=mesh_->ccw_rotated_halfedge_handle(heh_); }
while ((*
this) && (!
handle().is_valid()));;
1983 return mesh_->face_handle(heh_);
1988 operator typename Mesh::FaceHandle()
const {
1990 return mesh_->face_handle(heh_);
1997 return mesh_->deref(
handle());
2004 return &mesh_->deref(
handle());
2014 operator bool()
const {
2015 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2035 template <
class Mesh>
2043 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
2045 typedef typename Mesh::Vertex value_type;
2046 typedef typename Mesh::VertexHandle value_handle;
2049 typedef std::bidirectional_iterator_tag iterator_category;
2050 typedef std::ptrdiff_t difference_type;
2051 typedef const Mesh& mesh_ref;
2052 typedef const Mesh* mesh_ptr;
2053 typedef const typename Mesh::Vertex& reference;
2054 typedef const typename Mesh::Vertex* pointer;
2056 typedef std::bidirectional_iterator_tag iterator_category;
2057 typedef std::ptrdiff_t difference_type;
2058 typedef Mesh& mesh_ref;
2059 typedef Mesh* mesh_ptr;
2060 typedef typename Mesh::Vertex& reference;
2061 typedef typename Mesh::Vertex* pointer;
2073 start_(_mesh.halfedge_handle(_start)),
2091 start_(_rhs.start_),
2093 lap_counter_(_rhs.lap_counter_)
2101 start_ = _rhs.start_;
2103 lap_counter_ = _rhs.lap_counter_;
2112 start_(_rhs.start_),
2114 lap_counter_(_rhs.lap_counter_)
2122 start_ = _rhs.start_;
2124 lap_counter_ = _rhs.lap_counter_;
2128 friend class ConstFaceVertexIterT<Mesh>;
2134 return ((mesh_ == _rhs.mesh_) &&
2135 (start_ == _rhs.start_) &&
2136 (heh_ == _rhs.heh_) &&
2137 (lap_counter_ == _rhs.lap_counter_));
2150 heh_=mesh_->next_halfedge_handle(heh_);
2151 if(heh_ == start_) lap_counter_++;
2159 if(heh_ == start_) lap_counter_--;
2160 heh_=mesh_->prev_halfedge_handle(heh_);
2177 return mesh_->to_vertex_handle(heh_);
2182 operator typename Mesh::VertexHandle()
const {
2184 return mesh_->to_vertex_handle(heh_);
2191 return mesh_->deref(
handle());
2198 return &mesh_->deref(
handle());
2208 operator bool()
const {
2209 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2229 template <
class Mesh>
2237 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
2239 typedef typename Mesh::Vertex value_type;
2240 typedef typename Mesh::VertexHandle value_handle;
2243 typedef std::bidirectional_iterator_tag iterator_category;
2244 typedef std::ptrdiff_t difference_type;
2245 typedef const Mesh& mesh_ref;
2246 typedef const Mesh* mesh_ptr;
2247 typedef const typename Mesh::Vertex& reference;
2248 typedef const typename Mesh::Vertex* pointer;
2250 typedef std::bidirectional_iterator_tag iterator_category;
2251 typedef std::ptrdiff_t difference_type;
2252 typedef Mesh& mesh_ref;
2253 typedef Mesh* mesh_ptr;
2254 typedef typename Mesh::Vertex& reference;
2255 typedef typename Mesh::Vertex* pointer;
2267 start_(_mesh.halfedge_handle(_start)),
2285 start_(_rhs.start_),
2287 lap_counter_(_rhs.lap_counter_)
2295 start_ = _rhs.start_;
2297 lap_counter_ = _rhs.lap_counter_;
2306 start_(_rhs.start_),
2308 lap_counter_(_rhs.lap_counter_)
2316 start_ = _rhs.start_;
2318 lap_counter_ = _rhs.lap_counter_;
2328 return ((mesh_ == _rhs.mesh_) &&
2329 (start_ == _rhs.start_) &&
2330 (heh_ == _rhs.heh_) &&
2331 (lap_counter_ == _rhs.lap_counter_));
2344 heh_=mesh_->next_halfedge_handle(heh_);
2345 if(heh_ == start_) lap_counter_++;
2353 if(heh_ == start_) lap_counter_--;
2354 heh_=mesh_->prev_halfedge_handle(heh_);
2371 return mesh_->to_vertex_handle(heh_);
2376 operator typename Mesh::VertexHandle()
const {
2378 return mesh_->to_vertex_handle(heh_);
2385 return mesh_->deref(
handle());
2392 return &mesh_->deref(
handle());
2402 operator bool()
const {
2403 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2423 template <
class Mesh>
2431 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
2433 typedef typename Mesh::Halfedge value_type;
2434 typedef typename Mesh::HalfedgeHandle value_handle;
2437 typedef std::bidirectional_iterator_tag iterator_category;
2438 typedef std::ptrdiff_t difference_type;
2439 typedef const Mesh& mesh_ref;
2440 typedef const Mesh* mesh_ptr;
2441 typedef const typename Mesh::Halfedge& reference;
2442 typedef const typename Mesh::Halfedge* pointer;
2444 typedef std::bidirectional_iterator_tag iterator_category;
2445 typedef std::ptrdiff_t difference_type;
2446 typedef Mesh& mesh_ref;
2447 typedef Mesh* mesh_ptr;
2448 typedef typename Mesh::Halfedge& reference;
2449 typedef typename Mesh::Halfedge* pointer;
2461 start_(_mesh.halfedge_handle(_start)),
2479 start_(_rhs.start_),
2481 lap_counter_(_rhs.lap_counter_)
2489 start_ = _rhs.start_;
2491 lap_counter_ = _rhs.lap_counter_;
2500 start_(_rhs.start_),
2502 lap_counter_(_rhs.lap_counter_)
2510 start_ = _rhs.start_;
2512 lap_counter_ = _rhs.lap_counter_;
2516 friend class ConstFaceHalfedgeIterT<Mesh>;
2522 return ((mesh_ == _rhs.mesh_) &&
2523 (start_ == _rhs.start_) &&
2524 (heh_ == _rhs.heh_) &&
2525 (lap_counter_ == _rhs.lap_counter_));
2538 heh_=mesh_->next_halfedge_handle(heh_);
2539 if(heh_ == start_) lap_counter_++;
2547 if(heh_ == start_) lap_counter_--;
2548 heh_=mesh_->prev_halfedge_handle(heh_);
2563 typename Mesh::HalfedgeHandle
handle()
const {
2570 operator typename Mesh::HalfedgeHandle()
const {
2579 return mesh_->deref(
handle());
2586 return &mesh_->deref(
handle());
2596 operator bool()
const {
2597 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2617 template <
class Mesh>
2625 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
2627 typedef typename Mesh::Halfedge value_type;
2628 typedef typename Mesh::HalfedgeHandle value_handle;
2631 typedef std::bidirectional_iterator_tag iterator_category;
2632 typedef std::ptrdiff_t difference_type;
2633 typedef const Mesh& mesh_ref;
2634 typedef const Mesh* mesh_ptr;
2635 typedef const typename Mesh::Halfedge& reference;
2636 typedef const typename Mesh::Halfedge* pointer;
2638 typedef std::bidirectional_iterator_tag iterator_category;
2639 typedef std::ptrdiff_t difference_type;
2640 typedef Mesh& mesh_ref;
2641 typedef Mesh* mesh_ptr;
2642 typedef typename Mesh::Halfedge& reference;
2643 typedef typename Mesh::Halfedge* pointer;
2655 start_(_mesh.halfedge_handle(_start)),
2673 start_(_rhs.start_),
2675 lap_counter_(_rhs.lap_counter_)
2683 start_ = _rhs.start_;
2685 lap_counter_ = _rhs.lap_counter_;
2694 start_(_rhs.start_),
2696 lap_counter_(_rhs.lap_counter_)
2704 start_ = _rhs.start_;
2706 lap_counter_ = _rhs.lap_counter_;
2716 return ((mesh_ == _rhs.mesh_) &&
2717 (start_ == _rhs.start_) &&
2718 (heh_ == _rhs.heh_) &&
2719 (lap_counter_ == _rhs.lap_counter_));
2732 heh_=mesh_->next_halfedge_handle(heh_);
2733 if(heh_ == start_) lap_counter_++;
2741 if(heh_ == start_) lap_counter_--;
2742 heh_=mesh_->prev_halfedge_handle(heh_);
2757 typename Mesh::HalfedgeHandle
handle()
const {
2764 operator typename Mesh::HalfedgeHandle()
const {
2773 return mesh_->deref(
handle());
2780 return &mesh_->deref(
handle());
2790 operator bool()
const {
2791 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2811 template <
class Mesh>
2819 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
2821 typedef typename Mesh::Edge value_type;
2822 typedef typename Mesh::EdgeHandle value_handle;
2825 typedef std::bidirectional_iterator_tag iterator_category;
2826 typedef std::ptrdiff_t difference_type;
2827 typedef const Mesh& mesh_ref;
2828 typedef const Mesh* mesh_ptr;
2829 typedef const typename Mesh::Edge& reference;
2830 typedef const typename Mesh::Edge* pointer;
2832 typedef std::bidirectional_iterator_tag iterator_category;
2833 typedef std::ptrdiff_t difference_type;
2834 typedef Mesh& mesh_ref;
2835 typedef Mesh* mesh_ptr;
2836 typedef typename Mesh::Edge& reference;
2837 typedef typename Mesh::Edge* pointer;
2847 FaceEdgeIterT(mesh_ref _mesh,
typename Mesh::FaceHandle _start,
bool _end =
false) :
2849 start_(_mesh.halfedge_handle(_start)),
2867 start_(_rhs.start_),
2869 lap_counter_(_rhs.lap_counter_)
2877 start_ = _rhs.start_;
2879 lap_counter_ = _rhs.lap_counter_;
2888 start_(_rhs.start_),
2890 lap_counter_(_rhs.lap_counter_)
2898 start_ = _rhs.start_;
2900 lap_counter_ = _rhs.lap_counter_;
2904 friend class ConstFaceEdgeIterT<Mesh>;
2910 return ((mesh_ == _rhs.mesh_) &&
2911 (start_ == _rhs.start_) &&
2912 (heh_ == _rhs.heh_) &&
2913 (lap_counter_ == _rhs.lap_counter_));
2926 heh_=mesh_->next_halfedge_handle(heh_);
2927 if(heh_ == start_) lap_counter_++;
2935 if(heh_ == start_) lap_counter_--;
2936 heh_=mesh_->prev_halfedge_handle(heh_);
2953 return mesh_->edge_handle(heh_);
2958 operator typename Mesh::EdgeHandle()
const {
2960 return mesh_->edge_handle(heh_);
2967 return mesh_->deref(
handle());
2974 return &mesh_->deref(
handle());
2984 operator bool()
const {
2985 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
3005 template <
class Mesh>
3013 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
3015 typedef typename Mesh::Edge value_type;
3016 typedef typename Mesh::EdgeHandle value_handle;
3019 typedef std::bidirectional_iterator_tag iterator_category;
3020 typedef std::ptrdiff_t difference_type;
3021 typedef const Mesh& mesh_ref;
3022 typedef const Mesh* mesh_ptr;
3023 typedef const typename Mesh::Edge& reference;
3024 typedef const typename Mesh::Edge* pointer;
3026 typedef std::bidirectional_iterator_tag iterator_category;
3027 typedef std::ptrdiff_t difference_type;
3028 typedef Mesh& mesh_ref;
3029 typedef Mesh* mesh_ptr;
3030 typedef typename Mesh::Edge& reference;
3031 typedef typename Mesh::Edge* pointer;
3043 start_(_mesh.halfedge_handle(_start)),
3061 start_(_rhs.start_),
3063 lap_counter_(_rhs.lap_counter_)
3071 start_ = _rhs.start_;
3073 lap_counter_ = _rhs.lap_counter_;
3082 start_(_rhs.start_),
3084 lap_counter_(_rhs.lap_counter_)
3092 start_ = _rhs.start_;
3094 lap_counter_ = _rhs.lap_counter_;
3104 return ((mesh_ == _rhs.mesh_) &&
3105 (start_ == _rhs.start_) &&
3106 (heh_ == _rhs.heh_) &&
3107 (lap_counter_ == _rhs.lap_counter_));
3120 heh_=mesh_->next_halfedge_handle(heh_);
3121 if(heh_ == start_) lap_counter_++;
3129 if(heh_ == start_) lap_counter_--;
3130 heh_=mesh_->prev_halfedge_handle(heh_);
3147 return mesh_->edge_handle(heh_);
3152 operator typename Mesh::EdgeHandle()
const {
3154 return mesh_->edge_handle(heh_);
3161 return mesh_->deref(
handle());
3168 return &mesh_->deref(
handle());
3178 operator bool()
const {
3179 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
3199 template <
class Mesh>
3207 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
3209 typedef typename Mesh::Face value_type;
3210 typedef typename Mesh::FaceHandle value_handle;
3213 typedef std::bidirectional_iterator_tag iterator_category;
3214 typedef std::ptrdiff_t difference_type;
3215 typedef const Mesh& mesh_ref;
3216 typedef const Mesh* mesh_ptr;
3217 typedef const typename Mesh::Face& reference;
3218 typedef const typename Mesh::Face* pointer;
3220 typedef std::bidirectional_iterator_tag iterator_category;
3221 typedef std::ptrdiff_t difference_type;
3222 typedef Mesh& mesh_ref;
3223 typedef Mesh* mesh_ptr;
3224 typedef typename Mesh::Face& reference;
3225 typedef typename Mesh::Face* pointer;
3235 FaceFaceIterT(mesh_ref _mesh,
typename Mesh::FaceHandle _start,
bool _end =
false) :
3237 start_(_mesh.halfedge_handle(_start)),
3240 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
3249 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
3255 start_(_rhs.start_),
3257 lap_counter_(_rhs.lap_counter_)
3258 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
3265 start_ = _rhs.start_;
3267 lap_counter_ = _rhs.lap_counter_;
3276 start_(_rhs.start_),
3278 lap_counter_(_rhs.lap_counter_)
3279 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
3286 start_ = _rhs.start_;
3288 lap_counter_ = _rhs.lap_counter_;
3292 friend class ConstFaceFaceIterT<Mesh>;
3298 return ((mesh_ == _rhs.mesh_) &&
3299 (start_ == _rhs.start_) &&
3300 (heh_ == _rhs.heh_) &&
3301 (lap_counter_ == _rhs.lap_counter_));
3314 do { heh_=mesh_->next_halfedge_handle(heh_);
if(heh_ == start_) lap_counter_++; }
while ((*
this) && (!
handle().is_valid()));
3322 do {
if(heh_ == start_) lap_counter_--; heh_=mesh_->prev_halfedge_handle(heh_); }
while ((*
this) && (!
handle().is_valid()));
3339 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
3344 operator typename Mesh::FaceHandle()
const {
3346 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
3353 return mesh_->deref(
handle());
3360 return &mesh_->deref(
handle());
3370 operator bool()
const {
3371 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
3391 template <
class Mesh>
3399 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
3401 typedef typename Mesh::Face value_type;
3402 typedef typename Mesh::FaceHandle value_handle;
3405 typedef std::bidirectional_iterator_tag iterator_category;
3406 typedef std::ptrdiff_t difference_type;
3407 typedef const Mesh& mesh_ref;
3408 typedef const Mesh* mesh_ptr;
3409 typedef const typename Mesh::Face& reference;
3410 typedef const typename Mesh::Face* pointer;
3412 typedef std::bidirectional_iterator_tag iterator_category;
3413 typedef std::ptrdiff_t difference_type;
3414 typedef Mesh& mesh_ref;
3415 typedef Mesh* mesh_ptr;
3416 typedef typename Mesh::Face& reference;
3417 typedef typename Mesh::Face* pointer;
3429 start_(_mesh.halfedge_handle(_start)),
3432 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
3441 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
3447 start_(_rhs.start_),
3449 lap_counter_(_rhs.lap_counter_)
3450 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
3457 start_ = _rhs.start_;
3459 lap_counter_ = _rhs.lap_counter_;
3468 start_(_rhs.start_),
3470 lap_counter_(_rhs.lap_counter_)
3471 {
if (heh_.is_valid() && !
handle().is_valid())
operator++();; }
3478 start_ = _rhs.start_;
3480 lap_counter_ = _rhs.lap_counter_;
3490 return ((mesh_ == _rhs.mesh_) &&
3491 (start_ == _rhs.start_) &&
3492 (heh_ == _rhs.heh_) &&
3493 (lap_counter_ == _rhs.lap_counter_));
3506 do { heh_=mesh_->next_halfedge_handle(heh_);
if(heh_ == start_) lap_counter_++; }
while ((*
this) && (!
handle().is_valid()));;
3514 do {
if(heh_ == start_) lap_counter_--; heh_=mesh_->prev_halfedge_handle(heh_); }
while ((*
this) && (!
handle().is_valid()));;
3531 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
3536 operator typename Mesh::FaceHandle()
const {
3538 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
3545 return mesh_->deref(
handle());
3552 return &mesh_->deref(
handle());
3562 operator bool()
const {
3563 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));