00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042 #ifndef OPENMESH_CIRCULATORS_HH
00043 #define OPENMESH_CIRCULATORS_HH
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054 #include <OpenMesh/Core/System/config.h>
00055 #include <assert.h>
00056
00057
00058
00059
00060 namespace OpenMesh {
00061 namespace Iterators {
00062
00063
00064
00065
00066
00067 template <class Mesh> class VertexVertexIterT;
00068 template <class Mesh> class VertexIHalfedgeIterT;
00069 template <class Mesh> class VertexOHalfedgeIterT;
00070 template <class Mesh> class VertexEdgeIterT;
00071 template <class Mesh> class VertexFaceIterT;
00072
00073 template <class Mesh> class ConstVertexVertexIterT;
00074 template <class Mesh> class ConstVertexIHalfedgeIterT;
00075 template <class Mesh> class ConstVertexOHalfedgeIterT;
00076 template <class Mesh> class ConstVertexEdgeIterT;
00077 template <class Mesh> class ConstVertexFaceIterT;
00078
00079 template <class Mesh> class FaceVertexIterT;
00080 template <class Mesh> class FaceHalfedgeIterT;
00081 template <class Mesh> class FaceEdgeIterT;
00082 template <class Mesh> class FaceFaceIterT;
00083
00084 template <class Mesh> class ConstFaceVertexIterT;
00085 template <class Mesh> class ConstFaceHalfedgeIterT;
00086 template <class Mesh> class ConstFaceEdgeIterT;
00087 template <class Mesh> class ConstFaceFaceIterT;
00088
00089
00090
00091
00092
00093
00098 template <class Mesh>
00099 class VertexVertexIterT
00100 {
00101 public:
00102
00103
00104
00105
00106 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00107
00108 typedef typename Mesh::Vertex value_type;
00109 typedef typename Mesh::VertexHandle value_handle;
00110
00111 #if 0
00112 typedef std::bidirectional_iterator_tag iterator_category;
00113 typedef ptrdiff_t difference_type;
00114 typedef const Mesh& mesh_ref;
00115 typedef const Mesh* mesh_ptr;
00116 typedef const typename Mesh::Vertex& reference;
00117 typedef const typename Mesh::Vertex* pointer;
00118 #else
00119 typedef std::bidirectional_iterator_tag iterator_category;
00120 typedef ptrdiff_t difference_type;
00121 typedef Mesh& mesh_ref;
00122 typedef Mesh* mesh_ptr;
00123 typedef typename Mesh::Vertex& reference;
00124 typedef typename Mesh::Vertex* pointer;
00125 #endif
00126
00127
00128
00130 VertexVertexIterT() : mesh_(0), lap_counter_(0) {}
00131
00132
00134 VertexVertexIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
00135 mesh_(&_mesh),
00136 start_(_mesh.halfedge_handle(_start)),
00137 heh_(start_),
00138 lap_counter_(_end)
00139 { ; }
00140
00141
00143 VertexVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
00144 mesh_(&_mesh),
00145 start_(_heh),
00146 heh_(_heh),
00147 lap_counter_(_end)
00148 { ; }
00149
00150
00152 VertexVertexIterT(const VertexVertexIterT& _rhs) :
00153 mesh_(_rhs.mesh_),
00154 start_(_rhs.start_),
00155 heh_(_rhs.heh_),
00156 lap_counter_(_rhs.lap_counter_)
00157 { ; }
00158
00159
00161 VertexVertexIterT& operator=(const VertexVertexIterT<Mesh>& _rhs)
00162 {
00163 mesh_ = _rhs.mesh_;
00164 start_ = _rhs.start_;
00165 heh_ = _rhs.heh_;
00166 lap_counter_ = _rhs.lap_counter_;
00167 return *this;
00168 }
00169
00170
00171 #if 0
00172
00173 VertexVertexIterT(const VertexVertexIterT<Mesh>& _rhs) :
00174 mesh_(_rhs.mesh_),
00175 start_(_rhs.start_),
00176 heh_(_rhs.heh_),
00177 lap_counter_(_rhs.lap_counter_)
00178 { ; }
00179
00180
00182 VertexVertexIterT& operator=(const VertexVertexIterT<Mesh>& _rhs)
00183 {
00184 mesh_ = _rhs.mesh_;
00185 start_ = _rhs.start_;
00186 heh_ = _rhs.heh_;
00187 lap_counter_ = _rhs.lap_counter_;
00188 return *this;
00189 }
00190 #else
00191 friend class ConstVertexVertexIterT<Mesh>;
00192 #endif
00193
00194
00196 bool operator==(const VertexVertexIterT& _rhs) const {
00197 return ((mesh_ == _rhs.mesh_) &&
00198 (start_ == _rhs.start_) &&
00199 (heh_ == _rhs.heh_) &&
00200 (lap_counter_ == _rhs.lap_counter_));
00201 }
00202
00203
00205 bool operator!=(const VertexVertexIterT& _rhs) const {
00206 return !operator==(_rhs);
00207 }
00208
00209
00211 VertexVertexIterT& operator++() {
00212 assert(mesh_);
00213 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
00214 if(heh_ == start_) lap_counter_++;
00215 return *this;
00216 }
00217
00218
00220 VertexVertexIterT& operator--() {
00221 assert(mesh_);
00222 if(heh_ == start_) lap_counter_--;
00223 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
00224 return *this;
00225 }
00226
00227
00232 HalfedgeHandle current_halfedge_handle() const {
00233 return heh_;
00234 }
00235
00236
00238 typename Mesh::VertexHandle handle() const {
00239 assert(mesh_);
00240 return mesh_->to_vertex_handle(heh_);;
00241 }
00242
00243
00245 operator typename Mesh::VertexHandle() const {
00246 assert(mesh_);
00247 return mesh_->to_vertex_handle(heh_);;
00248 }
00249
00250
00252 reference operator*() const {
00253 assert(mesh_);
00254 return mesh_->deref(handle());
00255 }
00256
00257
00259 pointer operator->() const {
00260 assert(mesh_);
00261 return &mesh_->deref(handle());
00262 }
00263
00264
00271 operator bool() const {
00272 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
00273 }
00274
00275
00276 protected:
00277
00278 mesh_ptr mesh_;
00279 HalfedgeHandle start_, heh_;
00280 int lap_counter_;
00281 };
00282
00283
00284
00285
00286
00287
00292 template <class Mesh>
00293 class ConstVertexVertexIterT
00294 {
00295 public:
00296
00297
00298
00299
00300 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00301
00302 typedef typename Mesh::Vertex value_type;
00303 typedef typename Mesh::VertexHandle value_handle;
00304
00305 #if 1
00306 typedef std::bidirectional_iterator_tag iterator_category;
00307 typedef ptrdiff_t difference_type;
00308 typedef const Mesh& mesh_ref;
00309 typedef const Mesh* mesh_ptr;
00310 typedef const typename Mesh::Vertex& reference;
00311 typedef const typename Mesh::Vertex* pointer;
00312 #else
00313 typedef std::bidirectional_iterator_tag iterator_category;
00314 typedef ptrdiff_t difference_type;
00315 typedef Mesh& mesh_ref;
00316 typedef Mesh* mesh_ptr;
00317 typedef typename Mesh::Vertex& reference;
00318 typedef typename Mesh::Vertex* pointer;
00319 #endif
00320
00321
00322
00324 ConstVertexVertexIterT() : mesh_(0), lap_counter_(0) {}
00325
00326
00328 ConstVertexVertexIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
00329 mesh_(&_mesh),
00330 start_(_mesh.halfedge_handle(_start)),
00331 heh_(start_),
00332 lap_counter_(_end)
00333 { ; }
00334
00335
00337 ConstVertexVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
00338 mesh_(&_mesh),
00339 start_(_heh),
00340 heh_(_heh),
00341 lap_counter_(_end)
00342 { ; }
00343
00344
00346 ConstVertexVertexIterT(const ConstVertexVertexIterT& _rhs) :
00347 mesh_(_rhs.mesh_),
00348 start_(_rhs.start_),
00349 heh_(_rhs.heh_),
00350 lap_counter_(_rhs.lap_counter_)
00351 { ; }
00352
00353
00355 ConstVertexVertexIterT& operator=(const ConstVertexVertexIterT<Mesh>& _rhs)
00356 {
00357 mesh_ = _rhs.mesh_;
00358 start_ = _rhs.start_;
00359 heh_ = _rhs.heh_;
00360 lap_counter_ = _rhs.lap_counter_;
00361 return *this;
00362 }
00363
00364
00365 #if 1
00366
00367 ConstVertexVertexIterT(const VertexVertexIterT<Mesh>& _rhs) :
00368 mesh_(_rhs.mesh_),
00369 start_(_rhs.start_),
00370 heh_(_rhs.heh_),
00371 lap_counter_(_rhs.lap_counter_)
00372 { ; }
00373
00374
00376 ConstVertexVertexIterT& operator=(const VertexVertexIterT<Mesh>& _rhs)
00377 {
00378 mesh_ = _rhs.mesh_;
00379 start_ = _rhs.start_;
00380 heh_ = _rhs.heh_;
00381 lap_counter_ = _rhs.lap_counter_;
00382 return *this;
00383 }
00384 #else
00385 friend class ConstVertexVertexIterT<Mesh>;
00386 #endif
00387
00388
00390 bool operator==(const ConstVertexVertexIterT& _rhs) const {
00391 return ((mesh_ == _rhs.mesh_) &&
00392 (start_ == _rhs.start_) &&
00393 (heh_ == _rhs.heh_) &&
00394 (lap_counter_ == _rhs.lap_counter_));
00395 }
00396
00397
00399 bool operator!=(const ConstVertexVertexIterT& _rhs) const {
00400 return !operator==(_rhs);
00401 }
00402
00403
00405 ConstVertexVertexIterT& operator++() {
00406 assert(mesh_);
00407 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
00408 if(heh_ == start_) lap_counter_++;
00409 return *this;
00410 }
00411
00412
00414 ConstVertexVertexIterT& operator--() {
00415 assert(mesh_);
00416 if(heh_ == start_) lap_counter_--;
00417 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
00418 return *this;
00419 }
00420
00421
00426 HalfedgeHandle current_halfedge_handle() const {
00427 return heh_;
00428 }
00429
00430
00432 typename Mesh::VertexHandle handle() const {
00433 assert(mesh_);
00434 return mesh_->to_vertex_handle(heh_);;
00435 }
00436
00437
00439 operator typename Mesh::VertexHandle() const {
00440 assert(mesh_);
00441 return mesh_->to_vertex_handle(heh_);;
00442 }
00443
00444
00446 reference operator*() const {
00447 assert(mesh_);
00448 return mesh_->deref(handle());
00449 }
00450
00451
00453 pointer operator->() const {
00454 assert(mesh_);
00455 return &mesh_->deref(handle());
00456 }
00457
00458
00465 operator bool() const {
00466 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
00467 }
00468
00469
00470 protected:
00471
00472 mesh_ptr mesh_;
00473 HalfedgeHandle start_, heh_;
00474 int lap_counter_;
00475 };
00476
00477
00478
00479
00480
00481
00486 template <class Mesh>
00487 class VertexOHalfedgeIterT
00488 {
00489 public:
00490
00491
00492
00493
00494 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00495
00496 typedef typename Mesh::Halfedge value_type;
00497 typedef typename Mesh::HalfedgeHandle value_handle;
00498
00499 #if 0
00500 typedef std::bidirectional_iterator_tag iterator_category;
00501 typedef ptrdiff_t difference_type;
00502 typedef const Mesh& mesh_ref;
00503 typedef const Mesh* mesh_ptr;
00504 typedef const typename Mesh::Halfedge& reference;
00505 typedef const typename Mesh::Halfedge* pointer;
00506 #else
00507 typedef std::bidirectional_iterator_tag iterator_category;
00508 typedef ptrdiff_t difference_type;
00509 typedef Mesh& mesh_ref;
00510 typedef Mesh* mesh_ptr;
00511 typedef typename Mesh::Halfedge& reference;
00512 typedef typename Mesh::Halfedge* pointer;
00513 #endif
00514
00515
00516
00518 VertexOHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
00519
00520
00522 VertexOHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
00523 mesh_(&_mesh),
00524 start_(_mesh.halfedge_handle(_start)),
00525 heh_(start_),
00526 lap_counter_(_end)
00527 { ; }
00528
00529
00531 VertexOHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
00532 mesh_(&_mesh),
00533 start_(_heh),
00534 heh_(_heh),
00535 lap_counter_(_end)
00536 { ; }
00537
00538
00540 VertexOHalfedgeIterT(const VertexOHalfedgeIterT& _rhs) :
00541 mesh_(_rhs.mesh_),
00542 start_(_rhs.start_),
00543 heh_(_rhs.heh_),
00544 lap_counter_(_rhs.lap_counter_)
00545 { ; }
00546
00547
00549 VertexOHalfedgeIterT& operator=(const VertexOHalfedgeIterT<Mesh>& _rhs)
00550 {
00551 mesh_ = _rhs.mesh_;
00552 start_ = _rhs.start_;
00553 heh_ = _rhs.heh_;
00554 lap_counter_ = _rhs.lap_counter_;
00555 return *this;
00556 }
00557
00558
00559 #if 0
00560
00561 VertexOHalfedgeIterT(const VertexOHalfedgeIterT<Mesh>& _rhs) :
00562 mesh_(_rhs.mesh_),
00563 start_(_rhs.start_),
00564 heh_(_rhs.heh_),
00565 lap_counter_(_rhs.lap_counter_)
00566 { ; }
00567
00568
00570 VertexOHalfedgeIterT& operator=(const VertexOHalfedgeIterT<Mesh>& _rhs)
00571 {
00572 mesh_ = _rhs.mesh_;
00573 start_ = _rhs.start_;
00574 heh_ = _rhs.heh_;
00575 lap_counter_ = _rhs.lap_counter_;
00576 return *this;
00577 }
00578 #else
00579 friend class ConstVertexOHalfedgeIterT<Mesh>;
00580 #endif
00581
00582
00584 bool operator==(const VertexOHalfedgeIterT& _rhs) const {
00585 return ((mesh_ == _rhs.mesh_) &&
00586 (start_ == _rhs.start_) &&
00587 (heh_ == _rhs.heh_) &&
00588 (lap_counter_ == _rhs.lap_counter_));
00589 }
00590
00591
00593 bool operator!=(const VertexOHalfedgeIterT& _rhs) const {
00594 return !operator==(_rhs);
00595 }
00596
00597
00599 VertexOHalfedgeIterT& operator++() {
00600 assert(mesh_);
00601 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
00602 if(heh_ == start_) lap_counter_++;
00603 return *this;
00604 }
00605
00606
00608 VertexOHalfedgeIterT& operator--() {
00609 assert(mesh_);
00610 if(heh_ == start_) lap_counter_--;
00611 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
00612 return *this;
00613 }
00614
00615
00620 HalfedgeHandle current_halfedge_handle() const {
00621 return heh_;
00622 }
00623
00624
00626 typename Mesh::HalfedgeHandle handle() const {
00627 assert(mesh_);
00628 return heh_;
00629 }
00630
00631
00633 operator typename Mesh::HalfedgeHandle() const {
00634 assert(mesh_);
00635 return heh_;
00636 }
00637
00638
00640 reference operator*() const {
00641 assert(mesh_);
00642 return mesh_->deref(handle());
00643 }
00644
00645
00647 pointer operator->() const {
00648 assert(mesh_);
00649 return &mesh_->deref(handle());
00650 }
00651
00652
00659 operator bool() const {
00660 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
00661 }
00662
00663
00664 protected:
00665
00666 mesh_ptr mesh_;
00667 HalfedgeHandle start_, heh_;
00668 int lap_counter_;
00669 };
00670
00671
00672
00673
00674
00675
00680 template <class Mesh>
00681 class ConstVertexOHalfedgeIterT
00682 {
00683 public:
00684
00685
00686
00687
00688 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00689
00690 typedef typename Mesh::Halfedge value_type;
00691 typedef typename Mesh::HalfedgeHandle value_handle;
00692
00693 #if 1
00694 typedef std::bidirectional_iterator_tag iterator_category;
00695 typedef ptrdiff_t difference_type;
00696 typedef const Mesh& mesh_ref;
00697 typedef const Mesh* mesh_ptr;
00698 typedef const typename Mesh::Halfedge& reference;
00699 typedef const typename Mesh::Halfedge* pointer;
00700 #else
00701 typedef std::bidirectional_iterator_tag iterator_category;
00702 typedef ptrdiff_t difference_type;
00703 typedef Mesh& mesh_ref;
00704 typedef Mesh* mesh_ptr;
00705 typedef typename Mesh::Halfedge& reference;
00706 typedef typename Mesh::Halfedge* pointer;
00707 #endif
00708
00709
00710
00712 ConstVertexOHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
00713
00714
00716 ConstVertexOHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
00717 mesh_(&_mesh),
00718 start_(_mesh.halfedge_handle(_start)),
00719 heh_(start_),
00720 lap_counter_(_end)
00721 { ; }
00722
00723
00725 ConstVertexOHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
00726 mesh_(&_mesh),
00727 start_(_heh),
00728 heh_(_heh),
00729 lap_counter_(_end)
00730 { ; }
00731
00732
00734 ConstVertexOHalfedgeIterT(const ConstVertexOHalfedgeIterT& _rhs) :
00735 mesh_(_rhs.mesh_),
00736 start_(_rhs.start_),
00737 heh_(_rhs.heh_),
00738 lap_counter_(_rhs.lap_counter_)
00739 { ; }
00740
00741
00743 ConstVertexOHalfedgeIterT& operator=(const ConstVertexOHalfedgeIterT<Mesh>& _rhs)
00744 {
00745 mesh_ = _rhs.mesh_;
00746 start_ = _rhs.start_;
00747 heh_ = _rhs.heh_;
00748 lap_counter_ = _rhs.lap_counter_;
00749 return *this;
00750 }
00751
00752
00753 #if 1
00754
00755 ConstVertexOHalfedgeIterT(const VertexOHalfedgeIterT<Mesh>& _rhs) :
00756 mesh_(_rhs.mesh_),
00757 start_(_rhs.start_),
00758 heh_(_rhs.heh_),
00759 lap_counter_(_rhs.lap_counter_)
00760 { ; }
00761
00762
00764 ConstVertexOHalfedgeIterT& operator=(const VertexOHalfedgeIterT<Mesh>& _rhs)
00765 {
00766 mesh_ = _rhs.mesh_;
00767 start_ = _rhs.start_;
00768 heh_ = _rhs.heh_;
00769 lap_counter_ = _rhs.lap_counter_;
00770 return *this;
00771 }
00772 #else
00773 friend class ConstVertexOHalfedgeIterT<Mesh>;
00774 #endif
00775
00776
00778 bool operator==(const ConstVertexOHalfedgeIterT& _rhs) const {
00779 return ((mesh_ == _rhs.mesh_) &&
00780 (start_ == _rhs.start_) &&
00781 (heh_ == _rhs.heh_) &&
00782 (lap_counter_ == _rhs.lap_counter_));
00783 }
00784
00785
00787 bool operator!=(const ConstVertexOHalfedgeIterT& _rhs) const {
00788 return !operator==(_rhs);
00789 }
00790
00791
00793 ConstVertexOHalfedgeIterT& operator++() {
00794 assert(mesh_);
00795 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
00796 if(heh_ == start_) lap_counter_++;
00797 return *this;
00798 }
00799
00800
00802 ConstVertexOHalfedgeIterT& operator--() {
00803 assert(mesh_);
00804 if(heh_ == start_) lap_counter_--;
00805 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
00806 return *this;
00807 }
00808
00809
00814 HalfedgeHandle current_halfedge_handle() const {
00815 return heh_;
00816 }
00817
00818
00820 typename Mesh::HalfedgeHandle handle() const {
00821 assert(mesh_);
00822 return heh_;
00823 }
00824
00825
00827 operator typename Mesh::HalfedgeHandle() const {
00828 assert(mesh_);
00829 return heh_;
00830 }
00831
00832
00834 reference operator*() const {
00835 assert(mesh_);
00836 return mesh_->deref(handle());
00837 }
00838
00839
00841 pointer operator->() const {
00842 assert(mesh_);
00843 return &mesh_->deref(handle());
00844 }
00845
00846
00853 operator bool() const {
00854 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
00855 }
00856
00857
00858 protected:
00859
00860 mesh_ptr mesh_;
00861 HalfedgeHandle start_, heh_;
00862 int lap_counter_;
00863 };
00864
00865
00866
00867
00868
00869
00874 template <class Mesh>
00875 class VertexIHalfedgeIterT
00876 {
00877 public:
00878
00879
00880
00881
00882 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00883
00884 typedef typename Mesh::Halfedge value_type;
00885 typedef typename Mesh::HalfedgeHandle value_handle;
00886
00887 #if 0
00888 typedef std::bidirectional_iterator_tag iterator_category;
00889 typedef ptrdiff_t difference_type;
00890 typedef const Mesh& mesh_ref;
00891 typedef const Mesh* mesh_ptr;
00892 typedef const typename Mesh::Halfedge& reference;
00893 typedef const typename Mesh::Halfedge* pointer;
00894 #else
00895 typedef std::bidirectional_iterator_tag iterator_category;
00896 typedef ptrdiff_t difference_type;
00897 typedef Mesh& mesh_ref;
00898 typedef Mesh* mesh_ptr;
00899 typedef typename Mesh::Halfedge& reference;
00900 typedef typename Mesh::Halfedge* pointer;
00901 #endif
00902
00903
00904
00906 VertexIHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
00907
00908
00910 VertexIHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
00911 mesh_(&_mesh),
00912 start_(_mesh.halfedge_handle(_start)),
00913 heh_(start_),
00914 lap_counter_(_end)
00915 { ; }
00916
00917
00919 VertexIHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
00920 mesh_(&_mesh),
00921 start_(_heh),
00922 heh_(_heh),
00923 lap_counter_(_end)
00924 { ; }
00925
00926
00928 VertexIHalfedgeIterT(const VertexIHalfedgeIterT& _rhs) :
00929 mesh_(_rhs.mesh_),
00930 start_(_rhs.start_),
00931 heh_(_rhs.heh_),
00932 lap_counter_(_rhs.lap_counter_)
00933 { ; }
00934
00935
00937 VertexIHalfedgeIterT& operator=(const VertexIHalfedgeIterT<Mesh>& _rhs)
00938 {
00939 mesh_ = _rhs.mesh_;
00940 start_ = _rhs.start_;
00941 heh_ = _rhs.heh_;
00942 lap_counter_ = _rhs.lap_counter_;
00943 return *this;
00944 }
00945
00946
00947 #if 0
00948
00949 VertexIHalfedgeIterT(const VertexIHalfedgeIterT<Mesh>& _rhs) :
00950 mesh_(_rhs.mesh_),
00951 start_(_rhs.start_),
00952 heh_(_rhs.heh_),
00953 lap_counter_(_rhs.lap_counter_)
00954 { ; }
00955
00956
00958 VertexIHalfedgeIterT& operator=(const VertexIHalfedgeIterT<Mesh>& _rhs)
00959 {
00960 mesh_ = _rhs.mesh_;
00961 start_ = _rhs.start_;
00962 heh_ = _rhs.heh_;
00963 lap_counter_ = _rhs.lap_counter_;
00964 return *this;
00965 }
00966 #else
00967 friend class ConstVertexIHalfedgeIterT<Mesh>;
00968 #endif
00969
00970
00972 bool operator==(const VertexIHalfedgeIterT& _rhs) const {
00973 return ((mesh_ == _rhs.mesh_) &&
00974 (start_ == _rhs.start_) &&
00975 (heh_ == _rhs.heh_) &&
00976 (lap_counter_ == _rhs.lap_counter_));
00977 }
00978
00979
00981 bool operator!=(const VertexIHalfedgeIterT& _rhs) const {
00982 return !operator==(_rhs);
00983 }
00984
00985
00987 VertexIHalfedgeIterT& operator++() {
00988 assert(mesh_);
00989 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
00990 if(heh_ == start_) lap_counter_++;
00991 return *this;
00992 }
00993
00994
00996 VertexIHalfedgeIterT& operator--() {
00997 assert(mesh_);
00998 if(heh_ == start_) lap_counter_--;
00999 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
01000 return *this;
01001 }
01002
01003
01008 HalfedgeHandle current_halfedge_handle() const {
01009 return heh_;
01010 }
01011
01012
01014 typename Mesh::HalfedgeHandle handle() const {
01015 assert(mesh_);
01016 return mesh_->opposite_halfedge_handle(heh_);
01017 }
01018
01019
01021 operator typename Mesh::HalfedgeHandle() const {
01022 assert(mesh_);
01023 return mesh_->opposite_halfedge_handle(heh_);
01024 }
01025
01026
01028 reference operator*() const {
01029 assert(mesh_);
01030 return mesh_->deref(handle());
01031 }
01032
01033
01035 pointer operator->() const {
01036 assert(mesh_);
01037 return &mesh_->deref(handle());
01038 }
01039
01040
01047 operator bool() const {
01048 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
01049 }
01050
01051
01052 protected:
01053
01054 mesh_ptr mesh_;
01055 HalfedgeHandle start_, heh_;
01056 int lap_counter_;
01057 };
01058
01059
01060
01061
01062
01063
01068 template <class Mesh>
01069 class ConstVertexIHalfedgeIterT
01070 {
01071 public:
01072
01073
01074
01075
01076 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01077
01078 typedef typename Mesh::Halfedge value_type;
01079 typedef typename Mesh::HalfedgeHandle value_handle;
01080
01081 #if 1
01082 typedef std::bidirectional_iterator_tag iterator_category;
01083 typedef ptrdiff_t difference_type;
01084 typedef const Mesh& mesh_ref;
01085 typedef const Mesh* mesh_ptr;
01086 typedef const typename Mesh::Halfedge& reference;
01087 typedef const typename Mesh::Halfedge* pointer;
01088 #else
01089 typedef std::bidirectional_iterator_tag iterator_category;
01090 typedef ptrdiff_t difference_type;
01091 typedef Mesh& mesh_ref;
01092 typedef Mesh* mesh_ptr;
01093 typedef typename Mesh::Halfedge& reference;
01094 typedef typename Mesh::Halfedge* pointer;
01095 #endif
01096
01097
01098
01100 ConstVertexIHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
01101
01102
01104 ConstVertexIHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
01105 mesh_(&_mesh),
01106 start_(_mesh.halfedge_handle(_start)),
01107 heh_(start_),
01108 lap_counter_(_end)
01109 { ; }
01110
01111
01113 ConstVertexIHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
01114 mesh_(&_mesh),
01115 start_(_heh),
01116 heh_(_heh),
01117 lap_counter_(_end)
01118 { ; }
01119
01120
01122 ConstVertexIHalfedgeIterT(const ConstVertexIHalfedgeIterT& _rhs) :
01123 mesh_(_rhs.mesh_),
01124 start_(_rhs.start_),
01125 heh_(_rhs.heh_),
01126 lap_counter_(_rhs.lap_counter_)
01127 { ; }
01128
01129
01131 ConstVertexIHalfedgeIterT& operator=(const ConstVertexIHalfedgeIterT<Mesh>& _rhs)
01132 {
01133 mesh_ = _rhs.mesh_;
01134 start_ = _rhs.start_;
01135 heh_ = _rhs.heh_;
01136 lap_counter_ = _rhs.lap_counter_;
01137 return *this;
01138 }
01139
01140
01141 #if 1
01142
01143 ConstVertexIHalfedgeIterT(const VertexIHalfedgeIterT<Mesh>& _rhs) :
01144 mesh_(_rhs.mesh_),
01145 start_(_rhs.start_),
01146 heh_(_rhs.heh_),
01147 lap_counter_(_rhs.lap_counter_)
01148 { ; }
01149
01150
01152 ConstVertexIHalfedgeIterT& operator=(const VertexIHalfedgeIterT<Mesh>& _rhs)
01153 {
01154 mesh_ = _rhs.mesh_;
01155 start_ = _rhs.start_;
01156 heh_ = _rhs.heh_;
01157 lap_counter_ = _rhs.lap_counter_;
01158 return *this;
01159 }
01160 #else
01161 friend class ConstVertexIHalfedgeIterT<Mesh>;
01162 #endif
01163
01164
01166 bool operator==(const ConstVertexIHalfedgeIterT& _rhs) const {
01167 return ((mesh_ == _rhs.mesh_) &&
01168 (start_ == _rhs.start_) &&
01169 (heh_ == _rhs.heh_) &&
01170 (lap_counter_ == _rhs.lap_counter_));
01171 }
01172
01173
01175 bool operator!=(const ConstVertexIHalfedgeIterT& _rhs) const {
01176 return !operator==(_rhs);
01177 }
01178
01179
01181 ConstVertexIHalfedgeIterT& operator++() {
01182 assert(mesh_);
01183 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
01184 if(heh_ == start_) lap_counter_++;
01185 return *this;
01186 }
01187
01188
01190 ConstVertexIHalfedgeIterT& operator--() {
01191 assert(mesh_);
01192 if(heh_ == start_) lap_counter_--;
01193 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
01194 return *this;
01195 }
01196
01197
01202 HalfedgeHandle current_halfedge_handle() const {
01203 return heh_;
01204 }
01205
01206
01208 typename Mesh::HalfedgeHandle handle() const {
01209 assert(mesh_);
01210 return mesh_->opposite_halfedge_handle(heh_);
01211 }
01212
01213
01215 operator typename Mesh::HalfedgeHandle() const {
01216 assert(mesh_);
01217 return mesh_->opposite_halfedge_handle(heh_);
01218 }
01219
01220
01222 reference operator*() const {
01223 assert(mesh_);
01224 return mesh_->deref(handle());
01225 }
01226
01227
01229 pointer operator->() const {
01230 assert(mesh_);
01231 return &mesh_->deref(handle());
01232 }
01233
01234
01241 operator bool() const {
01242 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
01243 }
01244
01245
01246 protected:
01247
01248 mesh_ptr mesh_;
01249 HalfedgeHandle start_, heh_;
01250 int lap_counter_;
01251 };
01252
01253
01254
01255
01256
01257
01262 template <class Mesh>
01263 class VertexEdgeIterT
01264 {
01265 public:
01266
01267
01268
01269
01270 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01271
01272 typedef typename Mesh::Edge value_type;
01273 typedef typename Mesh::EdgeHandle value_handle;
01274
01275 #if 0
01276 typedef std::bidirectional_iterator_tag iterator_category;
01277 typedef ptrdiff_t difference_type;
01278 typedef const Mesh& mesh_ref;
01279 typedef const Mesh* mesh_ptr;
01280 typedef const typename Mesh::Edge& reference;
01281 typedef const typename Mesh::Edge* pointer;
01282 #else
01283 typedef std::bidirectional_iterator_tag iterator_category;
01284 typedef ptrdiff_t difference_type;
01285 typedef Mesh& mesh_ref;
01286 typedef Mesh* mesh_ptr;
01287 typedef typename Mesh::Edge& reference;
01288 typedef typename Mesh::Edge* pointer;
01289 #endif
01290
01291
01292
01294 VertexEdgeIterT() : mesh_(0), lap_counter_(false) {}
01295
01296
01298 VertexEdgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
01299 mesh_(&_mesh),
01300 start_(_mesh.halfedge_handle(_start)),
01301 heh_(start_),
01302 lap_counter_(_end)
01303 { ; }
01304
01305
01307 VertexEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
01308 mesh_(&_mesh),
01309 start_(_heh),
01310 heh_(_heh),
01311 lap_counter_(_end)
01312 { ; }
01313
01314
01316 VertexEdgeIterT(const VertexEdgeIterT& _rhs) :
01317 mesh_(_rhs.mesh_),
01318 start_(_rhs.start_),
01319 heh_(_rhs.heh_),
01320 lap_counter_(_rhs.lap_counter_)
01321 { ; }
01322
01323
01325 VertexEdgeIterT& operator=(const VertexEdgeIterT<Mesh>& _rhs)
01326 {
01327 mesh_ = _rhs.mesh_;
01328 start_ = _rhs.start_;
01329 heh_ = _rhs.heh_;
01330 lap_counter_ = _rhs.lap_counter_;
01331 return *this;
01332 }
01333
01334
01335 #if 0
01336
01337 VertexEdgeIterT(const VertexEdgeIterT<Mesh>& _rhs) :
01338 mesh_(_rhs.mesh_),
01339 start_(_rhs.start_),
01340 heh_(_rhs.heh_),
01341 lap_counter_(_rhs.lap_counter_)
01342 { ; }
01343
01344
01346 VertexEdgeIterT& operator=(const VertexEdgeIterT<Mesh>& _rhs)
01347 {
01348 mesh_ = _rhs.mesh_;
01349 start_ = _rhs.start_;
01350 heh_ = _rhs.heh_;
01351 lap_counter_ = _rhs.lap_counter_;
01352 return *this;
01353 }
01354 #else
01355 friend class ConstVertexEdgeIterT<Mesh>;
01356 #endif
01357
01358
01360 bool operator==(const VertexEdgeIterT& _rhs) const {
01361 return ((mesh_ == _rhs.mesh_) &&
01362 (start_ == _rhs.start_) &&
01363 (heh_ == _rhs.heh_) &&
01364 (lap_counter_ == _rhs.lap_counter_));
01365 }
01366
01367
01369 bool operator!=(const VertexEdgeIterT& _rhs) const {
01370 return !operator==(_rhs);
01371 }
01372
01373
01375 VertexEdgeIterT& operator++() {
01376 assert(mesh_);
01377 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
01378 if(heh_ == start_) lap_counter_++;
01379 return *this;
01380 }
01381
01382
01384 VertexEdgeIterT& operator--() {
01385 assert(mesh_);
01386 if(heh_ == start_) lap_counter_--;
01387 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
01388 return *this;
01389 }
01390
01391
01396 HalfedgeHandle current_halfedge_handle() const {
01397 return heh_;
01398 }
01399
01400
01402 typename Mesh::EdgeHandle handle() const {
01403 assert(mesh_);
01404 return mesh_->edge_handle(heh_);
01405 }
01406
01407
01409 operator typename Mesh::EdgeHandle() const {
01410 assert(mesh_);
01411 return mesh_->edge_handle(heh_);
01412 }
01413
01414
01416 reference operator*() const {
01417 assert(mesh_);
01418 return mesh_->deref(handle());
01419 }
01420
01421
01423 pointer operator->() const {
01424 assert(mesh_);
01425 return &mesh_->deref(handle());
01426 }
01427
01428
01435 operator bool() const {
01436 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
01437 }
01438
01439
01440 protected:
01441
01442 mesh_ptr mesh_;
01443 HalfedgeHandle start_, heh_;
01444 int lap_counter_;
01445 };
01446
01447
01448
01449
01450
01451
01456 template <class Mesh>
01457 class ConstVertexEdgeIterT
01458 {
01459 public:
01460
01461
01462
01463
01464 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01465
01466 typedef typename Mesh::Edge value_type;
01467 typedef typename Mesh::EdgeHandle value_handle;
01468
01469 #if 1
01470 typedef std::bidirectional_iterator_tag iterator_category;
01471 typedef ptrdiff_t difference_type;
01472 typedef const Mesh& mesh_ref;
01473 typedef const Mesh* mesh_ptr;
01474 typedef const typename Mesh::Edge& reference;
01475 typedef const typename Mesh::Edge* pointer;
01476 #else
01477 typedef std::bidirectional_iterator_tag iterator_category;
01478 typedef ptrdiff_t difference_type;
01479 typedef Mesh& mesh_ref;
01480 typedef Mesh* mesh_ptr;
01481 typedef typename Mesh::Edge& reference;
01482 typedef typename Mesh::Edge* pointer;
01483 #endif
01484
01485
01486
01488 ConstVertexEdgeIterT() : mesh_(0), lap_counter_(false) {}
01489
01490
01492 ConstVertexEdgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
01493 mesh_(&_mesh),
01494 start_(_mesh.halfedge_handle(_start)),
01495 heh_(start_),
01496 lap_counter_(_end)
01497 { ; }
01498
01499
01501 ConstVertexEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
01502 mesh_(&_mesh),
01503 start_(_heh),
01504 heh_(_heh),
01505 lap_counter_(_end)
01506 { ; }
01507
01508
01510 ConstVertexEdgeIterT(const ConstVertexEdgeIterT& _rhs) :
01511 mesh_(_rhs.mesh_),
01512 start_(_rhs.start_),
01513 heh_(_rhs.heh_),
01514 lap_counter_(_rhs.lap_counter_)
01515 { ; }
01516
01517
01519 ConstVertexEdgeIterT& operator=(const ConstVertexEdgeIterT<Mesh>& _rhs)
01520 {
01521 mesh_ = _rhs.mesh_;
01522 start_ = _rhs.start_;
01523 heh_ = _rhs.heh_;
01524 lap_counter_ = _rhs.lap_counter_;
01525 return *this;
01526 }
01527
01528
01529 #if 1
01530
01531 ConstVertexEdgeIterT(const VertexEdgeIterT<Mesh>& _rhs) :
01532 mesh_(_rhs.mesh_),
01533 start_(_rhs.start_),
01534 heh_(_rhs.heh_),
01535 lap_counter_(_rhs.lap_counter_)
01536 { ; }
01537
01538
01540 ConstVertexEdgeIterT& operator=(const VertexEdgeIterT<Mesh>& _rhs)
01541 {
01542 mesh_ = _rhs.mesh_;
01543 start_ = _rhs.start_;
01544 heh_ = _rhs.heh_;
01545 lap_counter_ = _rhs.lap_counter_;
01546 return *this;
01547 }
01548 #else
01549 friend class ConstVertexEdgeIterT<Mesh>;
01550 #endif
01551
01552
01554 bool operator==(const ConstVertexEdgeIterT& _rhs) const {
01555 return ((mesh_ == _rhs.mesh_) &&
01556 (start_ == _rhs.start_) &&
01557 (heh_ == _rhs.heh_) &&
01558 (lap_counter_ == _rhs.lap_counter_));
01559 }
01560
01561
01563 bool operator!=(const ConstVertexEdgeIterT& _rhs) const {
01564 return !operator==(_rhs);
01565 }
01566
01567
01569 ConstVertexEdgeIterT& operator++() {
01570 assert(mesh_);
01571 heh_=mesh_->cw_rotated_halfedge_handle(heh_);
01572 if(heh_ == start_) lap_counter_++;
01573 return *this;
01574 }
01575
01576
01578 ConstVertexEdgeIterT& operator--() {
01579 assert(mesh_);
01580 if(heh_ == start_) lap_counter_--;
01581 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
01582 return *this;
01583 }
01584
01585
01590 HalfedgeHandle current_halfedge_handle() const {
01591 return heh_;
01592 }
01593
01594
01596 typename Mesh::EdgeHandle handle() const {
01597 assert(mesh_);
01598 return mesh_->edge_handle(heh_);
01599 }
01600
01601
01603 operator typename Mesh::EdgeHandle() const {
01604 assert(mesh_);
01605 return mesh_->edge_handle(heh_);
01606 }
01607
01608
01610 reference operator*() const {
01611 assert(mesh_);
01612 return mesh_->deref(handle());
01613 }
01614
01615
01617 pointer operator->() const {
01618 assert(mesh_);
01619 return &mesh_->deref(handle());
01620 }
01621
01622
01629 operator bool() const {
01630 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
01631 }
01632
01633
01634 protected:
01635
01636 mesh_ptr mesh_;
01637 HalfedgeHandle start_, heh_;
01638 int lap_counter_;
01639 };
01640
01641
01642
01643
01644
01645
01650 template <class Mesh>
01651 class VertexFaceIterT
01652 {
01653 public:
01654
01655
01656
01657
01658 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01659
01660 typedef typename Mesh::Face value_type;
01661 typedef typename Mesh::FaceHandle value_handle;
01662
01663 #if 0
01664 typedef std::bidirectional_iterator_tag iterator_category;
01665 typedef ptrdiff_t difference_type;
01666 typedef const Mesh& mesh_ref;
01667 typedef const Mesh* mesh_ptr;
01668 typedef const typename Mesh::Face& reference;
01669 typedef const typename Mesh::Face* pointer;
01670 #else
01671 typedef std::bidirectional_iterator_tag iterator_category;
01672 typedef ptrdiff_t difference_type;
01673 typedef Mesh& mesh_ref;
01674 typedef Mesh* mesh_ptr;
01675 typedef typename Mesh::Face& reference;
01676 typedef typename Mesh::Face* pointer;
01677 #endif
01678
01679
01680
01682 VertexFaceIterT() : mesh_(0), lap_counter_(false) {}
01683
01684
01686 VertexFaceIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
01687 mesh_(&_mesh),
01688 start_(_mesh.halfedge_handle(_start)),
01689 heh_(start_),
01690 lap_counter_(_end)
01691 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01692
01693
01695 VertexFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
01696 mesh_(&_mesh),
01697 start_(_heh),
01698 heh_(_heh),
01699 lap_counter_(_end)
01700 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01701
01702
01704 VertexFaceIterT(const VertexFaceIterT& _rhs) :
01705 mesh_(_rhs.mesh_),
01706 start_(_rhs.start_),
01707 heh_(_rhs.heh_),
01708 lap_counter_(_rhs.lap_counter_)
01709 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01710
01711
01713 VertexFaceIterT& operator=(const VertexFaceIterT<Mesh>& _rhs)
01714 {
01715 mesh_ = _rhs.mesh_;
01716 start_ = _rhs.start_;
01717 heh_ = _rhs.heh_;
01718 lap_counter_ = _rhs.lap_counter_;
01719 return *this;
01720 }
01721
01722
01723 #if 0
01724
01725 VertexFaceIterT(const VertexFaceIterT<Mesh>& _rhs) :
01726 mesh_(_rhs.mesh_),
01727 start_(_rhs.start_),
01728 heh_(_rhs.heh_),
01729 lap_counter_(_rhs.lap_counter_)
01730 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01731
01732
01734 VertexFaceIterT& operator=(const VertexFaceIterT<Mesh>& _rhs)
01735 {
01736 mesh_ = _rhs.mesh_;
01737 start_ = _rhs.start_;
01738 heh_ = _rhs.heh_;
01739 lap_counter_ = _rhs.lap_counter_;
01740 return *this;
01741 }
01742 #else
01743 friend class ConstVertexFaceIterT<Mesh>;
01744 #endif
01745
01746
01748 bool operator==(const VertexFaceIterT& _rhs) const {
01749 return ((mesh_ == _rhs.mesh_) &&
01750 (start_ == _rhs.start_) &&
01751 (heh_ == _rhs.heh_) &&
01752 (lap_counter_ == _rhs.lap_counter_));
01753 }
01754
01755
01757 bool operator!=(const VertexFaceIterT& _rhs) const {
01758 return !operator==(_rhs);
01759 }
01760
01761
01763 VertexFaceIterT& operator++() {
01764 assert(mesh_);
01765 do { heh_=mesh_->cw_rotated_halfedge_handle(heh_); if(heh_ == start_) lap_counter_++; } while ((*this) && (!handle().is_valid()));;
01766 return *this;
01767 }
01768
01769
01771 VertexFaceIterT& operator--() {
01772 assert(mesh_);
01773 do { if(heh_ == start_) lap_counter_--; heh_=mesh_->ccw_rotated_halfedge_handle(heh_); } while ((*this) && (!handle().is_valid()));;
01774 return *this;
01775 }
01776
01777
01782 HalfedgeHandle current_halfedge_handle() const {
01783 return heh_;
01784 }
01785
01786
01788 typename Mesh::FaceHandle handle() const {
01789 assert(mesh_);
01790 return mesh_->face_handle(heh_);
01791 }
01792
01793
01795 operator typename Mesh::FaceHandle() const {
01796 assert(mesh_);
01797 return mesh_->face_handle(heh_);
01798 }
01799
01800
01802 reference operator*() const {
01803 assert(mesh_);
01804 return mesh_->deref(handle());
01805 }
01806
01807
01809 pointer operator->() const {
01810 assert(mesh_);
01811 return &mesh_->deref(handle());
01812 }
01813
01814
01821 operator bool() const {
01822 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
01823 }
01824
01825
01826 protected:
01827
01828 mesh_ptr mesh_;
01829 HalfedgeHandle start_, heh_;
01830 int lap_counter_;
01831 };
01832
01833
01834
01835
01836
01837
01842 template <class Mesh>
01843 class ConstVertexFaceIterT
01844 {
01845 public:
01846
01847
01848
01849
01850 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01851
01852 typedef typename Mesh::Face value_type;
01853 typedef typename Mesh::FaceHandle value_handle;
01854
01855 #if 1
01856 typedef std::bidirectional_iterator_tag iterator_category;
01857 typedef ptrdiff_t difference_type;
01858 typedef const Mesh& mesh_ref;
01859 typedef const Mesh* mesh_ptr;
01860 typedef const typename Mesh::Face& reference;
01861 typedef const typename Mesh::Face* pointer;
01862 #else
01863 typedef std::bidirectional_iterator_tag iterator_category;
01864 typedef ptrdiff_t difference_type;
01865 typedef Mesh& mesh_ref;
01866 typedef Mesh* mesh_ptr;
01867 typedef typename Mesh::Face& reference;
01868 typedef typename Mesh::Face* pointer;
01869 #endif
01870
01871
01872
01874 ConstVertexFaceIterT() : mesh_(0), lap_counter_(false) {}
01875
01876
01878 ConstVertexFaceIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
01879 mesh_(&_mesh),
01880 start_(_mesh.halfedge_handle(_start)),
01881 heh_(start_),
01882 lap_counter_(_end)
01883 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01884
01885
01887 ConstVertexFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
01888 mesh_(&_mesh),
01889 start_(_heh),
01890 heh_(_heh),
01891 lap_counter_(_end)
01892 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01893
01894
01896 ConstVertexFaceIterT(const ConstVertexFaceIterT& _rhs) :
01897 mesh_(_rhs.mesh_),
01898 start_(_rhs.start_),
01899 heh_(_rhs.heh_),
01900 lap_counter_(_rhs.lap_counter_)
01901 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01902
01903
01905 ConstVertexFaceIterT& operator=(const ConstVertexFaceIterT<Mesh>& _rhs)
01906 {
01907 mesh_ = _rhs.mesh_;
01908 start_ = _rhs.start_;
01909 heh_ = _rhs.heh_;
01910 lap_counter_ = _rhs.lap_counter_;
01911 return *this;
01912 }
01913
01914
01915 #if 1
01916
01917 ConstVertexFaceIterT(const VertexFaceIterT<Mesh>& _rhs) :
01918 mesh_(_rhs.mesh_),
01919 start_(_rhs.start_),
01920 heh_(_rhs.heh_),
01921 lap_counter_(_rhs.lap_counter_)
01922 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01923
01924
01926 ConstVertexFaceIterT& operator=(const VertexFaceIterT<Mesh>& _rhs)
01927 {
01928 mesh_ = _rhs.mesh_;
01929 start_ = _rhs.start_;
01930 heh_ = _rhs.heh_;
01931 lap_counter_ = _rhs.lap_counter_;
01932 return *this;
01933 }
01934 #else
01935 friend class ConstVertexFaceIterT<Mesh>;
01936 #endif
01937
01938
01940 bool operator==(const ConstVertexFaceIterT& _rhs) const {
01941 return ((mesh_ == _rhs.mesh_) &&
01942 (start_ == _rhs.start_) &&
01943 (heh_ == _rhs.heh_) &&
01944 (lap_counter_ == _rhs.lap_counter_));
01945 }
01946
01947
01949 bool operator!=(const ConstVertexFaceIterT& _rhs) const {
01950 return !operator==(_rhs);
01951 }
01952
01953
01955 ConstVertexFaceIterT& operator++() {
01956 assert(mesh_);
01957 do { heh_=mesh_->cw_rotated_halfedge_handle(heh_); if(heh_ == start_) lap_counter_++; } while ((*this) && (!handle().is_valid()));;
01958 return *this;
01959 }
01960
01961
01963 ConstVertexFaceIterT& operator--() {
01964 assert(mesh_);
01965 do { if(heh_ == start_) lap_counter_--; heh_=mesh_->ccw_rotated_halfedge_handle(heh_); } while ((*this) && (!handle().is_valid()));;
01966 return *this;
01967 }
01968
01969
01974 HalfedgeHandle current_halfedge_handle() const {
01975 return heh_;
01976 }
01977
01978
01980 typename Mesh::FaceHandle handle() const {
01981 assert(mesh_);
01982 return mesh_->face_handle(heh_);
01983 }
01984
01985
01987 operator typename Mesh::FaceHandle() const {
01988 assert(mesh_);
01989 return mesh_->face_handle(heh_);
01990 }
01991
01992
01994 reference operator*() const {
01995 assert(mesh_);
01996 return mesh_->deref(handle());
01997 }
01998
01999
02001 pointer operator->() const {
02002 assert(mesh_);
02003 return &mesh_->deref(handle());
02004 }
02005
02006
02013 operator bool() const {
02014 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
02015 }
02016
02017
02018 protected:
02019
02020 mesh_ptr mesh_;
02021 HalfedgeHandle start_, heh_;
02022 int lap_counter_;
02023 };
02024
02025
02026
02027
02028
02029
02034 template <class Mesh>
02035 class FaceVertexIterT
02036 {
02037 public:
02038
02039
02040
02041
02042 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
02043
02044 typedef typename Mesh::Vertex value_type;
02045 typedef typename Mesh::VertexHandle value_handle;
02046
02047 #if 0
02048 typedef std::bidirectional_iterator_tag iterator_category;
02049 typedef ptrdiff_t difference_type;
02050 typedef const Mesh& mesh_ref;
02051 typedef const Mesh* mesh_ptr;
02052 typedef const typename Mesh::Vertex& reference;
02053 typedef const typename Mesh::Vertex* pointer;
02054 #else
02055 typedef std::bidirectional_iterator_tag iterator_category;
02056 typedef ptrdiff_t difference_type;
02057 typedef Mesh& mesh_ref;
02058 typedef Mesh* mesh_ptr;
02059 typedef typename Mesh::Vertex& reference;
02060 typedef typename Mesh::Vertex* pointer;
02061 #endif
02062
02063
02064
02066 FaceVertexIterT() : mesh_(0), lap_counter_(false) {}
02067
02068
02070 FaceVertexIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
02071 mesh_(&_mesh),
02072 start_(_mesh.halfedge_handle(_start)),
02073 heh_(start_),
02074 lap_counter_(_end)
02075 { ; }
02076
02077
02079 FaceVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
02080 mesh_(&_mesh),
02081 start_(_heh),
02082 heh_(_heh),
02083 lap_counter_(_end)
02084 { ; }
02085
02086
02088 FaceVertexIterT(const FaceVertexIterT& _rhs) :
02089 mesh_(_rhs.mesh_),
02090 start_(_rhs.start_),
02091 heh_(_rhs.heh_),
02092 lap_counter_(_rhs.lap_counter_)
02093 { ; }
02094
02095
02097 FaceVertexIterT& operator=(const FaceVertexIterT<Mesh>& _rhs)
02098 {
02099 mesh_ = _rhs.mesh_;
02100 start_ = _rhs.start_;
02101 heh_ = _rhs.heh_;
02102 lap_counter_ = _rhs.lap_counter_;
02103 return *this;
02104 }
02105
02106
02107 #if 0
02108
02109 FaceVertexIterT(const FaceVertexIterT<Mesh>& _rhs) :
02110 mesh_(_rhs.mesh_),
02111 start_(_rhs.start_),
02112 heh_(_rhs.heh_),
02113 lap_counter_(_rhs.lap_counter_)
02114 { ; }
02115
02116
02118 FaceVertexIterT& operator=(const FaceVertexIterT<Mesh>& _rhs)
02119 {
02120 mesh_ = _rhs.mesh_;
02121 start_ = _rhs.start_;
02122 heh_ = _rhs.heh_;
02123 lap_counter_ = _rhs.lap_counter_;
02124 return *this;
02125 }
02126 #else
02127 friend class ConstFaceVertexIterT<Mesh>;
02128 #endif
02129
02130
02132 bool operator==(const FaceVertexIterT& _rhs) const {
02133 return ((mesh_ == _rhs.mesh_) &&
02134 (start_ == _rhs.start_) &&
02135 (heh_ == _rhs.heh_) &&
02136 (lap_counter_ == _rhs.lap_counter_));
02137 }
02138
02139
02141 bool operator!=(const FaceVertexIterT& _rhs) const {
02142 return !operator==(_rhs);
02143 }
02144
02145
02147 FaceVertexIterT& operator++() {
02148 assert(mesh_);
02149 heh_=mesh_->next_halfedge_handle(heh_);
02150 if(heh_ == start_) lap_counter_++;
02151 return *this;
02152 }
02153
02154
02156 FaceVertexIterT& operator--() {
02157 assert(mesh_);
02158 if(heh_ == start_) lap_counter_--;
02159 heh_=mesh_->prev_halfedge_handle(heh_);
02160 return *this;
02161 }
02162
02163
02168 HalfedgeHandle current_halfedge_handle() const {
02169 return heh_;
02170 }
02171
02172
02174 typename Mesh::VertexHandle handle() const {
02175 assert(mesh_);
02176 return mesh_->to_vertex_handle(heh_);
02177 }
02178
02179
02181 operator typename Mesh::VertexHandle() const {
02182 assert(mesh_);
02183 return mesh_->to_vertex_handle(heh_);
02184 }
02185
02186
02188 reference operator*() const {
02189 assert(mesh_);
02190 return mesh_->deref(handle());
02191 }
02192
02193
02195 pointer operator->() const {
02196 assert(mesh_);
02197 return &mesh_->deref(handle());
02198 }
02199
02200
02207 operator bool() const {
02208 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
02209 }
02210
02211
02212 protected:
02213
02214 mesh_ptr mesh_;
02215 HalfedgeHandle start_, heh_;
02216 int lap_counter_;
02217 };
02218
02219
02220
02221
02222
02223
02228 template <class Mesh>
02229 class ConstFaceVertexIterT
02230 {
02231 public:
02232
02233
02234
02235
02236 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
02237
02238 typedef typename Mesh::Vertex value_type;
02239 typedef typename Mesh::VertexHandle value_handle;
02240
02241 #if 1
02242 typedef std::bidirectional_iterator_tag iterator_category;
02243 typedef ptrdiff_t difference_type;
02244 typedef const Mesh& mesh_ref;
02245 typedef const Mesh* mesh_ptr;
02246 typedef const typename Mesh::Vertex& reference;
02247 typedef const typename Mesh::Vertex* pointer;
02248 #else
02249 typedef std::bidirectional_iterator_tag iterator_category;
02250 typedef ptrdiff_t difference_type;
02251 typedef Mesh& mesh_ref;
02252 typedef Mesh* mesh_ptr;
02253 typedef typename Mesh::Vertex& reference;
02254 typedef typename Mesh::Vertex* pointer;
02255 #endif
02256
02257
02258
02260 ConstFaceVertexIterT() : mesh_(0), lap_counter_(false) {}
02261
02262
02264 ConstFaceVertexIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
02265 mesh_(&_mesh),
02266 start_(_mesh.halfedge_handle(_start)),
02267 heh_(start_),
02268 lap_counter_(_end)
02269 { ; }
02270
02271
02273 ConstFaceVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
02274 mesh_(&_mesh),
02275 start_(_heh),
02276 heh_(_heh),
02277 lap_counter_(_end)
02278 { ; }
02279
02280
02282 ConstFaceVertexIterT(const ConstFaceVertexIterT& _rhs) :
02283 mesh_(_rhs.mesh_),
02284 start_(_rhs.start_),
02285 heh_(_rhs.heh_),
02286 lap_counter_(_rhs.lap_counter_)
02287 { ; }
02288
02289
02291 ConstFaceVertexIterT& operator=(const ConstFaceVertexIterT<Mesh>& _rhs)
02292 {
02293 mesh_ = _rhs.mesh_;
02294 start_ = _rhs.start_;
02295 heh_ = _rhs.heh_;
02296 lap_counter_ = _rhs.lap_counter_;
02297 return *this;
02298 }
02299
02300
02301 #if 1
02302
02303 ConstFaceVertexIterT(const FaceVertexIterT<Mesh>& _rhs) :
02304 mesh_(_rhs.mesh_),
02305 start_(_rhs.start_),
02306 heh_(_rhs.heh_),
02307 lap_counter_(_rhs.lap_counter_)
02308 { ; }
02309
02310
02312 ConstFaceVertexIterT& operator=(const FaceVertexIterT<Mesh>& _rhs)
02313 {
02314 mesh_ = _rhs.mesh_;
02315 start_ = _rhs.start_;
02316 heh_ = _rhs.heh_;
02317 lap_counter_ = _rhs.lap_counter_;
02318 return *this;
02319 }
02320 #else
02321 friend class ConstFaceVertexIterT<Mesh>;
02322 #endif
02323
02324
02326 bool operator==(const ConstFaceVertexIterT& _rhs) const {
02327 return ((mesh_ == _rhs.mesh_) &&
02328 (start_ == _rhs.start_) &&
02329 (heh_ == _rhs.heh_) &&
02330 (lap_counter_ == _rhs.lap_counter_));
02331 }
02332
02333
02335 bool operator!=(const ConstFaceVertexIterT& _rhs) const {
02336 return !operator==(_rhs);
02337 }
02338
02339
02341 ConstFaceVertexIterT& operator++() {
02342 assert(mesh_);
02343 heh_=mesh_->next_halfedge_handle(heh_);
02344 if(heh_ == start_) lap_counter_++;
02345 return *this;
02346 }
02347
02348
02350 ConstFaceVertexIterT& operator--() {
02351 assert(mesh_);
02352 if(heh_ == start_) lap_counter_--;
02353 heh_=mesh_->prev_halfedge_handle(heh_);
02354 return *this;
02355 }
02356
02357
02362 HalfedgeHandle current_halfedge_handle() const {
02363 return heh_;
02364 }
02365
02366
02368 typename Mesh::VertexHandle handle() const {
02369 assert(mesh_);
02370 return mesh_->to_vertex_handle(heh_);
02371 }
02372
02373
02375 operator typename Mesh::VertexHandle() const {
02376 assert(mesh_);
02377 return mesh_->to_vertex_handle(heh_);
02378 }
02379
02380
02382 reference operator*() const {
02383 assert(mesh_);
02384 return mesh_->deref(handle());
02385 }
02386
02387
02389 pointer operator->() const {
02390 assert(mesh_);
02391 return &mesh_->deref(handle());
02392 }
02393
02394
02401 operator bool() const {
02402 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
02403 }
02404
02405
02406 protected:
02407
02408 mesh_ptr mesh_;
02409 HalfedgeHandle start_, heh_;
02410 int lap_counter_;
02411 };
02412
02413
02414
02415
02416
02417
02422 template <class Mesh>
02423 class FaceHalfedgeIterT
02424 {
02425 public:
02426
02427
02428
02429
02430 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
02431
02432 typedef typename Mesh::Halfedge value_type;
02433 typedef typename Mesh::HalfedgeHandle value_handle;
02434
02435 #if 0
02436 typedef std::bidirectional_iterator_tag iterator_category;
02437 typedef ptrdiff_t difference_type;
02438 typedef const Mesh& mesh_ref;
02439 typedef const Mesh* mesh_ptr;
02440 typedef const typename Mesh::Halfedge& reference;
02441 typedef const typename Mesh::Halfedge* pointer;
02442 #else
02443 typedef std::bidirectional_iterator_tag iterator_category;
02444 typedef ptrdiff_t difference_type;
02445 typedef Mesh& mesh_ref;
02446 typedef Mesh* mesh_ptr;
02447 typedef typename Mesh::Halfedge& reference;
02448 typedef typename Mesh::Halfedge* pointer;
02449 #endif
02450
02451
02452
02454 FaceHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
02455
02456
02458 FaceHalfedgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
02459 mesh_(&_mesh),
02460 start_(_mesh.halfedge_handle(_start)),
02461 heh_(start_),
02462 lap_counter_(_end)
02463 { ; }
02464
02465
02467 FaceHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
02468 mesh_(&_mesh),
02469 start_(_heh),
02470 heh_(_heh),
02471 lap_counter_(_end)
02472 { ; }
02473
02474
02476 FaceHalfedgeIterT(const FaceHalfedgeIterT& _rhs) :
02477 mesh_(_rhs.mesh_),
02478 start_(_rhs.start_),
02479 heh_(_rhs.heh_),
02480 lap_counter_(_rhs.lap_counter_)
02481 { ; }
02482
02483
02485 FaceHalfedgeIterT& operator=(const FaceHalfedgeIterT<Mesh>& _rhs)
02486 {
02487 mesh_ = _rhs.mesh_;
02488 start_ = _rhs.start_;
02489 heh_ = _rhs.heh_;
02490 lap_counter_ = _rhs.lap_counter_;
02491 return *this;
02492 }
02493
02494
02495 #if 0
02496
02497 FaceHalfedgeIterT(const FaceHalfedgeIterT<Mesh>& _rhs) :
02498 mesh_(_rhs.mesh_),
02499 start_(_rhs.start_),
02500 heh_(_rhs.heh_),
02501 lap_counter_(_rhs.lap_counter_)
02502 { ; }
02503
02504
02506 FaceHalfedgeIterT& operator=(const FaceHalfedgeIterT<Mesh>& _rhs)
02507 {
02508 mesh_ = _rhs.mesh_;
02509 start_ = _rhs.start_;
02510 heh_ = _rhs.heh_;
02511 lap_counter_ = _rhs.lap_counter_;
02512 return *this;
02513 }
02514 #else
02515 friend class ConstFaceHalfedgeIterT<Mesh>;
02516 #endif
02517
02518
02520 bool operator==(const FaceHalfedgeIterT& _rhs) const {
02521 return ((mesh_ == _rhs.mesh_) &&
02522 (start_ == _rhs.start_) &&
02523 (heh_ == _rhs.heh_) &&
02524 (lap_counter_ == _rhs.lap_counter_));
02525 }
02526
02527
02529 bool operator!=(const FaceHalfedgeIterT& _rhs) const {
02530 return !operator==(_rhs);
02531 }
02532
02533
02535 FaceHalfedgeIterT& operator++() {
02536 assert(mesh_);
02537 heh_=mesh_->next_halfedge_handle(heh_);
02538 if(heh_ == start_) lap_counter_++;
02539 return *this;
02540 }
02541
02542
02544 FaceHalfedgeIterT& operator--() {
02545 assert(mesh_);
02546 if(heh_ == start_) lap_counter_--;
02547 heh_=mesh_->prev_halfedge_handle(heh_);
02548 return *this;
02549 }
02550
02551
02556 HalfedgeHandle current_halfedge_handle() const {
02557 return heh_;
02558 }
02559
02560
02562 typename Mesh::HalfedgeHandle handle() const {
02563 assert(mesh_);
02564 return heh_;
02565 }
02566
02567
02569 operator typename Mesh::HalfedgeHandle() const {
02570 assert(mesh_);
02571 return heh_;
02572 }
02573
02574
02576 reference operator*() const {
02577 assert(mesh_);
02578 return mesh_->deref(handle());
02579 }
02580
02581
02583 pointer operator->() const {
02584 assert(mesh_);
02585 return &mesh_->deref(handle());
02586 }
02587
02588
02595 operator bool() const {
02596 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
02597 }
02598
02599
02600 protected:
02601
02602 mesh_ptr mesh_;
02603 HalfedgeHandle start_, heh_;
02604 int lap_counter_;
02605 };
02606
02607
02608
02609
02610
02611
02616 template <class Mesh>
02617 class ConstFaceHalfedgeIterT
02618 {
02619 public:
02620
02621
02622
02623
02624 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
02625
02626 typedef typename Mesh::Halfedge value_type;
02627 typedef typename Mesh::HalfedgeHandle value_handle;
02628
02629 #if 1
02630 typedef std::bidirectional_iterator_tag iterator_category;
02631 typedef ptrdiff_t difference_type;
02632 typedef const Mesh& mesh_ref;
02633 typedef const Mesh* mesh_ptr;
02634 typedef const typename Mesh::Halfedge& reference;
02635 typedef const typename Mesh::Halfedge* pointer;
02636 #else
02637 typedef std::bidirectional_iterator_tag iterator_category;
02638 typedef ptrdiff_t difference_type;
02639 typedef Mesh& mesh_ref;
02640 typedef Mesh* mesh_ptr;
02641 typedef typename Mesh::Halfedge& reference;
02642 typedef typename Mesh::Halfedge* pointer;
02643 #endif
02644
02645
02646
02648 ConstFaceHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
02649
02650
02652 ConstFaceHalfedgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
02653 mesh_(&_mesh),
02654 start_(_mesh.halfedge_handle(_start)),
02655 heh_(start_),
02656 lap_counter_(_end)
02657 { ; }
02658
02659
02661 ConstFaceHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
02662 mesh_(&_mesh),
02663 start_(_heh),
02664 heh_(_heh),
02665 lap_counter_(_end)
02666 { ; }
02667
02668
02670 ConstFaceHalfedgeIterT(const ConstFaceHalfedgeIterT& _rhs) :
02671 mesh_(_rhs.mesh_),
02672 start_(_rhs.start_),
02673 heh_(_rhs.heh_),
02674 lap_counter_(_rhs.lap_counter_)
02675 { ; }
02676
02677
02679 ConstFaceHalfedgeIterT& operator=(const ConstFaceHalfedgeIterT<Mesh>& _rhs)
02680 {
02681 mesh_ = _rhs.mesh_;
02682 start_ = _rhs.start_;
02683 heh_ = _rhs.heh_;
02684 lap_counter_ = _rhs.lap_counter_;
02685 return *this;
02686 }
02687
02688
02689 #if 1
02690
02691 ConstFaceHalfedgeIterT(const FaceHalfedgeIterT<Mesh>& _rhs) :
02692 mesh_(_rhs.mesh_),
02693 start_(_rhs.start_),
02694 heh_(_rhs.heh_),
02695 lap_counter_(_rhs.lap_counter_)
02696 { ; }
02697
02698
02700 ConstFaceHalfedgeIterT& operator=(const FaceHalfedgeIterT<Mesh>& _rhs)
02701 {
02702 mesh_ = _rhs.mesh_;
02703 start_ = _rhs.start_;
02704 heh_ = _rhs.heh_;
02705 lap_counter_ = _rhs.lap_counter_;
02706 return *this;
02707 }
02708 #else
02709 friend class ConstFaceHalfedgeIterT<Mesh>;
02710 #endif
02711
02712
02714 bool operator==(const ConstFaceHalfedgeIterT& _rhs) const {
02715 return ((mesh_ == _rhs.mesh_) &&
02716 (start_ == _rhs.start_) &&
02717 (heh_ == _rhs.heh_) &&
02718 (lap_counter_ == _rhs.lap_counter_));
02719 }
02720
02721
02723 bool operator!=(const ConstFaceHalfedgeIterT& _rhs) const {
02724 return !operator==(_rhs);
02725 }
02726
02727
02729 ConstFaceHalfedgeIterT& operator++() {
02730 assert(mesh_);
02731 heh_=mesh_->next_halfedge_handle(heh_);
02732 if(heh_ == start_) lap_counter_++;
02733 return *this;
02734 }
02735
02736
02738 ConstFaceHalfedgeIterT& operator--() {
02739 assert(mesh_);
02740 if(heh_ == start_) lap_counter_--;
02741 heh_=mesh_->prev_halfedge_handle(heh_);
02742 return *this;
02743 }
02744
02745
02750 HalfedgeHandle current_halfedge_handle() const {
02751 return heh_;
02752 }
02753
02754
02756 typename Mesh::HalfedgeHandle handle() const {
02757 assert(mesh_);
02758 return heh_;
02759 }
02760
02761
02763 operator typename Mesh::HalfedgeHandle() const {
02764 assert(mesh_);
02765 return heh_;
02766 }
02767
02768
02770 reference operator*() const {
02771 assert(mesh_);
02772 return mesh_->deref(handle());
02773 }
02774
02775
02777 pointer operator->() const {
02778 assert(mesh_);
02779 return &mesh_->deref(handle());
02780 }
02781
02782
02789 operator bool() const {
02790 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
02791 }
02792
02793
02794 protected:
02795
02796 mesh_ptr mesh_;
02797 HalfedgeHandle start_, heh_;
02798 int lap_counter_;
02799 };
02800
02801
02802
02803
02804
02805
02810 template <class Mesh>
02811 class FaceEdgeIterT
02812 {
02813 public:
02814
02815
02816
02817
02818 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
02819
02820 typedef typename Mesh::Edge value_type;
02821 typedef typename Mesh::EdgeHandle value_handle;
02822
02823 #if 0
02824 typedef std::bidirectional_iterator_tag iterator_category;
02825 typedef ptrdiff_t difference_type;
02826 typedef const Mesh& mesh_ref;
02827 typedef const Mesh* mesh_ptr;
02828 typedef const typename Mesh::Edge& reference;
02829 typedef const typename Mesh::Edge* pointer;
02830 #else
02831 typedef std::bidirectional_iterator_tag iterator_category;
02832 typedef ptrdiff_t difference_type;
02833 typedef Mesh& mesh_ref;
02834 typedef Mesh* mesh_ptr;
02835 typedef typename Mesh::Edge& reference;
02836 typedef typename Mesh::Edge* pointer;
02837 #endif
02838
02839
02840
02842 FaceEdgeIterT() : mesh_(0), lap_counter_(false) {}
02843
02844
02846 FaceEdgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
02847 mesh_(&_mesh),
02848 start_(_mesh.halfedge_handle(_start)),
02849 heh_(start_),
02850 lap_counter_(_end)
02851 { ; }
02852
02853
02855 FaceEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
02856 mesh_(&_mesh),
02857 start_(_heh),
02858 heh_(_heh),
02859 lap_counter_(_end)
02860 { ; }
02861
02862
02864 FaceEdgeIterT(const FaceEdgeIterT& _rhs) :
02865 mesh_(_rhs.mesh_),
02866 start_(_rhs.start_),
02867 heh_(_rhs.heh_),
02868 lap_counter_(_rhs.lap_counter_)
02869 { ; }
02870
02871
02873 FaceEdgeIterT& operator=(const FaceEdgeIterT<Mesh>& _rhs)
02874 {
02875 mesh_ = _rhs.mesh_;
02876 start_ = _rhs.start_;
02877 heh_ = _rhs.heh_;
02878 lap_counter_ = _rhs.lap_counter_;
02879 return *this;
02880 }
02881
02882
02883 #if 0
02884
02885 FaceEdgeIterT(const FaceEdgeIterT<Mesh>& _rhs) :
02886 mesh_(_rhs.mesh_),
02887 start_(_rhs.start_),
02888 heh_(_rhs.heh_),
02889 lap_counter_(_rhs.lap_counter_)
02890 { ; }
02891
02892
02894 FaceEdgeIterT& operator=(const FaceEdgeIterT<Mesh>& _rhs)
02895 {
02896 mesh_ = _rhs.mesh_;
02897 start_ = _rhs.start_;
02898 heh_ = _rhs.heh_;
02899 lap_counter_ = _rhs.lap_counter_;
02900 return *this;
02901 }
02902 #else
02903 friend class ConstFaceEdgeIterT<Mesh>;
02904 #endif
02905
02906
02908 bool operator==(const FaceEdgeIterT& _rhs) const {
02909 return ((mesh_ == _rhs.mesh_) &&
02910 (start_ == _rhs.start_) &&
02911 (heh_ == _rhs.heh_) &&
02912 (lap_counter_ == _rhs.lap_counter_));
02913 }
02914
02915
02917 bool operator!=(const FaceEdgeIterT& _rhs) const {
02918 return !operator==(_rhs);
02919 }
02920
02921
02923 FaceEdgeIterT& operator++() {
02924 assert(mesh_);
02925 heh_=mesh_->next_halfedge_handle(heh_);
02926 if(heh_ == start_) lap_counter_++;
02927 return *this;
02928 }
02929
02930
02932 FaceEdgeIterT& operator--() {
02933 assert(mesh_);
02934 if(heh_ == start_) lap_counter_--;
02935 heh_=mesh_->prev_halfedge_handle(heh_);
02936 return *this;
02937 }
02938
02939
02944 HalfedgeHandle current_halfedge_handle() const {
02945 return heh_;
02946 }
02947
02948
02950 typename Mesh::EdgeHandle handle() const {
02951 assert(mesh_);
02952 return mesh_->edge_handle(heh_);
02953 }
02954
02955
02957 operator typename Mesh::EdgeHandle() const {
02958 assert(mesh_);
02959 return mesh_->edge_handle(heh_);
02960 }
02961
02962
02964 reference operator*() const {
02965 assert(mesh_);
02966 return mesh_->deref(handle());
02967 }
02968
02969
02971 pointer operator->() const {
02972 assert(mesh_);
02973 return &mesh_->deref(handle());
02974 }
02975
02976
02983 operator bool() const {
02984 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
02985 }
02986
02987
02988 protected:
02989
02990 mesh_ptr mesh_;
02991 HalfedgeHandle start_, heh_;
02992 int lap_counter_;
02993 };
02994
02995
02996
02997
02998
02999
03004 template <class Mesh>
03005 class ConstFaceEdgeIterT
03006 {
03007 public:
03008
03009
03010
03011
03012 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
03013
03014 typedef typename Mesh::Edge value_type;
03015 typedef typename Mesh::EdgeHandle value_handle;
03016
03017 #if 1
03018 typedef std::bidirectional_iterator_tag iterator_category;
03019 typedef ptrdiff_t difference_type;
03020 typedef const Mesh& mesh_ref;
03021 typedef const Mesh* mesh_ptr;
03022 typedef const typename Mesh::Edge& reference;
03023 typedef const typename Mesh::Edge* pointer;
03024 #else
03025 typedef std::bidirectional_iterator_tag iterator_category;
03026 typedef ptrdiff_t difference_type;
03027 typedef Mesh& mesh_ref;
03028 typedef Mesh* mesh_ptr;
03029 typedef typename Mesh::Edge& reference;
03030 typedef typename Mesh::Edge* pointer;
03031 #endif
03032
03033
03034
03036 ConstFaceEdgeIterT() : mesh_(0), lap_counter_(false) {}
03037
03038
03040 ConstFaceEdgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
03041 mesh_(&_mesh),
03042 start_(_mesh.halfedge_handle(_start)),
03043 heh_(start_),
03044 lap_counter_(_end)
03045 { ; }
03046
03047
03049 ConstFaceEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
03050 mesh_(&_mesh),
03051 start_(_heh),
03052 heh_(_heh),
03053 lap_counter_(_end)
03054 { ; }
03055
03056
03058 ConstFaceEdgeIterT(const ConstFaceEdgeIterT& _rhs) :
03059 mesh_(_rhs.mesh_),
03060 start_(_rhs.start_),
03061 heh_(_rhs.heh_),
03062 lap_counter_(_rhs.lap_counter_)
03063 { ; }
03064
03065
03067 ConstFaceEdgeIterT& operator=(const ConstFaceEdgeIterT<Mesh>& _rhs)
03068 {
03069 mesh_ = _rhs.mesh_;
03070 start_ = _rhs.start_;
03071 heh_ = _rhs.heh_;
03072 lap_counter_ = _rhs.lap_counter_;
03073 return *this;
03074 }
03075
03076
03077 #if 1
03078
03079 ConstFaceEdgeIterT(const FaceEdgeIterT<Mesh>& _rhs) :
03080 mesh_(_rhs.mesh_),
03081 start_(_rhs.start_),
03082 heh_(_rhs.heh_),
03083 lap_counter_(_rhs.lap_counter_)
03084 { ; }
03085
03086
03088 ConstFaceEdgeIterT& operator=(const FaceEdgeIterT<Mesh>& _rhs)
03089 {
03090 mesh_ = _rhs.mesh_;
03091 start_ = _rhs.start_;
03092 heh_ = _rhs.heh_;
03093 lap_counter_ = _rhs.lap_counter_;
03094 return *this;
03095 }
03096 #else
03097 friend class ConstFaceEdgeIterT<Mesh>;
03098 #endif
03099
03100
03102 bool operator==(const ConstFaceEdgeIterT& _rhs) const {
03103 return ((mesh_ == _rhs.mesh_) &&
03104 (start_ == _rhs.start_) &&
03105 (heh_ == _rhs.heh_) &&
03106 (lap_counter_ == _rhs.lap_counter_));
03107 }
03108
03109
03111 bool operator!=(const ConstFaceEdgeIterT& _rhs) const {
03112 return !operator==(_rhs);
03113 }
03114
03115
03117 ConstFaceEdgeIterT& operator++() {
03118 assert(mesh_);
03119 heh_=mesh_->next_halfedge_handle(heh_);
03120 if(heh_ == start_) lap_counter_++;
03121 return *this;
03122 }
03123
03124
03126 ConstFaceEdgeIterT& operator--() {
03127 assert(mesh_);
03128 if(heh_ == start_) lap_counter_--;
03129 heh_=mesh_->prev_halfedge_handle(heh_);
03130 return *this;
03131 }
03132
03133
03138 HalfedgeHandle current_halfedge_handle() const {
03139 return heh_;
03140 }
03141
03142
03144 typename Mesh::EdgeHandle handle() const {
03145 assert(mesh_);
03146 return mesh_->edge_handle(heh_);
03147 }
03148
03149
03151 operator typename Mesh::EdgeHandle() const {
03152 assert(mesh_);
03153 return mesh_->edge_handle(heh_);
03154 }
03155
03156
03158 reference operator*() const {
03159 assert(mesh_);
03160 return mesh_->deref(handle());
03161 }
03162
03163
03165 pointer operator->() const {
03166 assert(mesh_);
03167 return &mesh_->deref(handle());
03168 }
03169
03170
03177 operator bool() const {
03178 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
03179 }
03180
03181
03182 protected:
03183
03184 mesh_ptr mesh_;
03185 HalfedgeHandle start_, heh_;
03186 int lap_counter_;
03187 };
03188
03189
03190
03191
03192
03193
03198 template <class Mesh>
03199 class FaceFaceIterT
03200 {
03201 public:
03202
03203
03204
03205
03206 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
03207
03208 typedef typename Mesh::Face value_type;
03209 typedef typename Mesh::FaceHandle value_handle;
03210
03211 #if 0
03212 typedef std::bidirectional_iterator_tag iterator_category;
03213 typedef ptrdiff_t difference_type;
03214 typedef const Mesh& mesh_ref;
03215 typedef const Mesh* mesh_ptr;
03216 typedef const typename Mesh::Face& reference;
03217 typedef const typename Mesh::Face* pointer;
03218 #else
03219 typedef std::bidirectional_iterator_tag iterator_category;
03220 typedef ptrdiff_t difference_type;
03221 typedef Mesh& mesh_ref;
03222 typedef Mesh* mesh_ptr;
03223 typedef typename Mesh::Face& reference;
03224 typedef typename Mesh::Face* pointer;
03225 #endif
03226
03227
03228
03230 FaceFaceIterT() : mesh_(0), lap_counter_(false) {}
03231
03232
03234 FaceFaceIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
03235 mesh_(&_mesh),
03236 start_(_mesh.halfedge_handle(_start)),
03237 heh_(start_),
03238 lap_counter_(_end)
03239 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03240
03241
03243 FaceFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
03244 mesh_(&_mesh),
03245 start_(_heh),
03246 heh_(_heh),
03247 lap_counter_(_end)
03248 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03249
03250
03252 FaceFaceIterT(const FaceFaceIterT& _rhs) :
03253 mesh_(_rhs.mesh_),
03254 start_(_rhs.start_),
03255 heh_(_rhs.heh_),
03256 lap_counter_(_rhs.lap_counter_)
03257 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03258
03259
03261 FaceFaceIterT& operator=(const FaceFaceIterT<Mesh>& _rhs)
03262 {
03263 mesh_ = _rhs.mesh_;
03264 start_ = _rhs.start_;
03265 heh_ = _rhs.heh_;
03266 lap_counter_ = _rhs.lap_counter_;
03267 return *this;
03268 }
03269
03270
03271 #if 0
03272
03273 FaceFaceIterT(const FaceFaceIterT<Mesh>& _rhs) :
03274 mesh_(_rhs.mesh_),
03275 start_(_rhs.start_),
03276 heh_(_rhs.heh_),
03277 lap_counter_(_rhs.lap_counter_)
03278 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03279
03280
03282 FaceFaceIterT& operator=(const FaceFaceIterT<Mesh>& _rhs)
03283 {
03284 mesh_ = _rhs.mesh_;
03285 start_ = _rhs.start_;
03286 heh_ = _rhs.heh_;
03287 lap_counter_ = _rhs.lap_counter_;
03288 return *this;
03289 }
03290 #else
03291 friend class ConstFaceFaceIterT<Mesh>;
03292 #endif
03293
03294
03296 bool operator==(const FaceFaceIterT& _rhs) const {
03297 return ((mesh_ == _rhs.mesh_) &&
03298 (start_ == _rhs.start_) &&
03299 (heh_ == _rhs.heh_) &&
03300 (lap_counter_ == _rhs.lap_counter_));
03301 }
03302
03303
03305 bool operator!=(const FaceFaceIterT& _rhs) const {
03306 return !operator==(_rhs);
03307 }
03308
03309
03311 FaceFaceIterT& operator++() {
03312 assert(mesh_);
03313 do { heh_=mesh_->next_halfedge_handle(heh_); if(heh_ == start_) lap_counter_++; } while ((*this) && (!handle().is_valid()));
03314 return *this;
03315 }
03316
03317
03319 FaceFaceIterT& operator--() {
03320 assert(mesh_);
03321 do { if(heh_ == start_) lap_counter_--; heh_=mesh_->prev_halfedge_handle(heh_); } while ((*this) && (!handle().is_valid()));
03322 return *this;
03323 }
03324
03325
03330 HalfedgeHandle current_halfedge_handle() const {
03331 return heh_;
03332 }
03333
03334
03336 typename Mesh::FaceHandle handle() const {
03337 assert(mesh_);
03338 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
03339 }
03340
03341
03343 operator typename Mesh::FaceHandle() const {
03344 assert(mesh_);
03345 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
03346 }
03347
03348
03350 reference operator*() const {
03351 assert(mesh_);
03352 return mesh_->deref(handle());
03353 }
03354
03355
03357 pointer operator->() const {
03358 assert(mesh_);
03359 return &mesh_->deref(handle());
03360 }
03361
03362
03369 operator bool() const {
03370 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
03371 }
03372
03373
03374 protected:
03375
03376 mesh_ptr mesh_;
03377 HalfedgeHandle start_, heh_;
03378 int lap_counter_;
03379 };
03380
03381
03382
03383
03384
03385
03390 template <class Mesh>
03391 class ConstFaceFaceIterT
03392 {
03393 public:
03394
03395
03396
03397
03398 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
03399
03400 typedef typename Mesh::Face value_type;
03401 typedef typename Mesh::FaceHandle value_handle;
03402
03403 #if 1
03404 typedef std::bidirectional_iterator_tag iterator_category;
03405 typedef ptrdiff_t difference_type;
03406 typedef const Mesh& mesh_ref;
03407 typedef const Mesh* mesh_ptr;
03408 typedef const typename Mesh::Face& reference;
03409 typedef const typename Mesh::Face* pointer;
03410 #else
03411 typedef std::bidirectional_iterator_tag iterator_category;
03412 typedef ptrdiff_t difference_type;
03413 typedef Mesh& mesh_ref;
03414 typedef Mesh* mesh_ptr;
03415 typedef typename Mesh::Face& reference;
03416 typedef typename Mesh::Face* pointer;
03417 #endif
03418
03419
03420
03422 ConstFaceFaceIterT() : mesh_(0), lap_counter_(false) {}
03423
03424
03426 ConstFaceFaceIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
03427 mesh_(&_mesh),
03428 start_(_mesh.halfedge_handle(_start)),
03429 heh_(start_),
03430 lap_counter_(_end)
03431 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03432
03433
03435 ConstFaceFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
03436 mesh_(&_mesh),
03437 start_(_heh),
03438 heh_(_heh),
03439 lap_counter_(_end)
03440 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03441
03442
03444 ConstFaceFaceIterT(const ConstFaceFaceIterT& _rhs) :
03445 mesh_(_rhs.mesh_),
03446 start_(_rhs.start_),
03447 heh_(_rhs.heh_),
03448 lap_counter_(_rhs.lap_counter_)
03449 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03450
03451
03453 ConstFaceFaceIterT& operator=(const ConstFaceFaceIterT<Mesh>& _rhs)
03454 {
03455 mesh_ = _rhs.mesh_;
03456 start_ = _rhs.start_;
03457 heh_ = _rhs.heh_;
03458 lap_counter_ = _rhs.lap_counter_;
03459 return *this;
03460 }
03461
03462
03463 #if 1
03464
03465 ConstFaceFaceIterT(const FaceFaceIterT<Mesh>& _rhs) :
03466 mesh_(_rhs.mesh_),
03467 start_(_rhs.start_),
03468 heh_(_rhs.heh_),
03469 lap_counter_(_rhs.lap_counter_)
03470 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03471
03472
03474 ConstFaceFaceIterT& operator=(const FaceFaceIterT<Mesh>& _rhs)
03475 {
03476 mesh_ = _rhs.mesh_;
03477 start_ = _rhs.start_;
03478 heh_ = _rhs.heh_;
03479 lap_counter_ = _rhs.lap_counter_;
03480 return *this;
03481 }
03482 #else
03483 friend class ConstFaceFaceIterT<Mesh>;
03484 #endif
03485
03486
03488 bool operator==(const ConstFaceFaceIterT& _rhs) const {
03489 return ((mesh_ == _rhs.mesh_) &&
03490 (start_ == _rhs.start_) &&
03491 (heh_ == _rhs.heh_) &&
03492 (lap_counter_ == _rhs.lap_counter_));
03493 }
03494
03495
03497 bool operator!=(const ConstFaceFaceIterT& _rhs) const {
03498 return !operator==(_rhs);
03499 }
03500
03501
03503 ConstFaceFaceIterT& operator++() {
03504 assert(mesh_);
03505 do { heh_=mesh_->next_halfedge_handle(heh_); if(heh_ == start_) lap_counter_++; } while ((*this) && (!handle().is_valid()));;
03506 return *this;
03507 }
03508
03509
03511 ConstFaceFaceIterT& operator--() {
03512 assert(mesh_);
03513 do { if(heh_ == start_) lap_counter_--; heh_=mesh_->prev_halfedge_handle(heh_); } while ((*this) && (!handle().is_valid()));;
03514 return *this;
03515 }
03516
03517
03522 HalfedgeHandle current_halfedge_handle() const {
03523 return heh_;
03524 }
03525
03526
03528 typename Mesh::FaceHandle handle() const {
03529 assert(mesh_);
03530 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
03531 }
03532
03533
03535 operator typename Mesh::FaceHandle() const {
03536 assert(mesh_);
03537 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
03538 }
03539
03540
03542 reference operator*() const {
03543 assert(mesh_);
03544 return mesh_->deref(handle());
03545 }
03546
03547
03549 pointer operator->() const {
03550 assert(mesh_);
03551 return &mesh_->deref(handle());
03552 }
03553
03554
03561 operator bool() const {
03562 return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
03563 }
03564
03565
03566 protected:
03567
03568 mesh_ptr mesh_;
03569 HalfedgeHandle start_, heh_;
03570 int lap_counter_;
03571 };
03572
03573
03574
03575
03576 }
03577 }
03578
03579 #endif
03580