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 #ifndef OPENMESH_CIRCULATORS_HH
00026 #define OPENMESH_CIRCULATORS_HH
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037 #include <OpenMesh/Core/System/config.hh>
00038 #include <assert.h>
00039
00040
00041
00042
00043 namespace OpenMesh {
00044 namespace Iterators {
00045
00046
00047
00048
00049
00050 template <class Mesh> class VertexVertexIterT;
00051 template <class Mesh> class VertexIHalfedgeIterT;
00052 template <class Mesh> class VertexOHalfedgeIterT;
00053 template <class Mesh> class VertexEdgeIterT;
00054 template <class Mesh> class VertexFaceIterT;
00055
00056 template <class Mesh> class ConstVertexVertexIterT;
00057 template <class Mesh> class ConstVertexIHalfedgeIterT;
00058 template <class Mesh> class ConstVertexOHalfedgeIterT;
00059 template <class Mesh> class ConstVertexEdgeIterT;
00060 template <class Mesh> class ConstVertexFaceIterT;
00061
00062 template <class Mesh> class FaceVertexIterT;
00063 template <class Mesh> class FaceHalfedgeIterT;
00064 template <class Mesh> class FaceEdgeIterT;
00065 template <class Mesh> class FaceFaceIterT;
00066
00067 template <class Mesh> class ConstFaceVertexIterT;
00068 template <class Mesh> class ConstFaceHalfedgeIterT;
00069 template <class Mesh> class ConstFaceEdgeIterT;
00070 template <class Mesh> class ConstFaceFaceIterT;
00071
00072
00073
00074
00075
00076
00081 template <class Mesh>
00082 class VertexVertexIterT
00083 {
00084 public:
00085
00086
00087
00088
00089 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00090
00091 typedef typename Mesh::Vertex value_type;
00092 typedef typename Mesh::VertexHandle value_handle;
00093
00094 #if 0
00095 typedef const Mesh& mesh_ref;
00096 typedef const Mesh* mesh_ptr;
00097 typedef const typename Mesh::Vertex& reference;
00098 typedef const typename Mesh::Vertex* pointer;
00099 #else
00100 typedef Mesh& mesh_ref;
00101 typedef Mesh* mesh_ptr;
00102 typedef typename Mesh::Vertex& reference;
00103 typedef typename Mesh::Vertex* pointer;
00104 #endif
00105
00106
00107
00109 VertexVertexIterT() : mesh_(0), active_(false) {}
00110
00111
00113 VertexVertexIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start) :
00114 mesh_(&_mesh),
00115 start_(_mesh.halfedge_handle(_start)),
00116 heh_(start_),
00117 active_(false)
00118 { ; }
00119
00120
00122 VertexVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
00123 mesh_(&_mesh),
00124 start_(_heh),
00125 heh_(_heh),
00126 active_(false)
00127 { ; }
00128
00129
00131 VertexVertexIterT(const VertexVertexIterT& _rhs) :
00132 mesh_(_rhs.mesh_),
00133 start_(_rhs.start_),
00134 heh_(_rhs.heh_),
00135 active_(_rhs.active_)
00136 { ; }
00137
00138
00140 VertexVertexIterT& operator=(const VertexVertexIterT<Mesh>& _rhs)
00141 {
00142 mesh_ = _rhs.mesh_;
00143 start_ = _rhs.start_;
00144 heh_ = _rhs.heh_;
00145 active_ = _rhs.active_;
00146 return *this;
00147 }
00148
00149
00150 #if 0
00151
00152 VertexVertexIterT(const VertexVertexIterT<Mesh>& _rhs) :
00153 mesh_(_rhs.mesh_),
00154 start_(_rhs.start_),
00155 heh_(_rhs.heh_),
00156 active_(_rhs.active_)
00157 { ; }
00158
00159
00161 VertexVertexIterT& operator=(const VertexVertexIterT<Mesh>& _rhs)
00162 {
00163 mesh_ = _rhs.mesh_;
00164 start_ = _rhs.start_;
00165 heh_ = _rhs.heh_;
00166 active_ = _rhs.active_;
00167 return *this;
00168 }
00169 #else
00170 friend class ConstVertexVertexIterT<Mesh>;
00171 #endif
00172
00173
00175 bool operator==(const VertexVertexIterT& _rhs) const {
00176 return ((mesh_ == _rhs.mesh_) &&
00177 (start_ == _rhs.start_) &&
00178 (heh_ == _rhs.heh_) &&
00179 (active_ == _rhs.active_));
00180 }
00181
00182
00184 bool operator!=(const VertexVertexIterT& _rhs) const {
00185 return !operator==(_rhs);
00186 }
00187
00188
00190 VertexVertexIterT& operator++() {
00191 assert(mesh_);
00192 active_ = true;
00193 heh_=mesh_->cw_rotated_halfedge_handle(heh_);;
00194 return *this;
00195 }
00196
00197
00199 VertexVertexIterT& operator--() {
00200 assert(mesh_);
00201 active_ = true;
00202 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);;
00203 return *this;
00204 }
00205
00206
00211 HalfedgeHandle current_halfedge_handle() const {
00212 return heh_;
00213 }
00214
00215
00217 typename Mesh::VertexHandle handle() const {
00218 assert(mesh_);
00219 return mesh_->to_vertex_handle(heh_);;
00220 }
00221
00222
00224 operator typename Mesh::VertexHandle() const {
00225 assert(mesh_);
00226 return mesh_->to_vertex_handle(heh_);;
00227 }
00228
00229
00231 reference operator*() const {
00232 assert(mesh_);
00233 return mesh_->deref(handle());
00234 }
00235
00236
00238 pointer operator->() const {
00239 assert(mesh_);
00240 return &mesh_->deref(handle());
00241 }
00242
00243
00250 operator bool() const {
00251 return heh_.is_valid() && ((start_ != heh_) || (!active_));
00252 }
00253
00254
00255 private:
00256
00257 mesh_ptr mesh_;
00258 HalfedgeHandle start_, heh_;
00259 bool active_;
00260 };
00261
00262
00263
00264
00265
00266
00271 template <class Mesh>
00272 class ConstVertexVertexIterT
00273 {
00274 public:
00275
00276
00277
00278
00279 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00280
00281 typedef typename Mesh::Vertex value_type;
00282 typedef typename Mesh::VertexHandle value_handle;
00283
00284 #if 1
00285 typedef const Mesh& mesh_ref;
00286 typedef const Mesh* mesh_ptr;
00287 typedef const typename Mesh::Vertex& reference;
00288 typedef const typename Mesh::Vertex* pointer;
00289 #else
00290 typedef Mesh& mesh_ref;
00291 typedef Mesh* mesh_ptr;
00292 typedef typename Mesh::Vertex& reference;
00293 typedef typename Mesh::Vertex* pointer;
00294 #endif
00295
00296
00297
00299 ConstVertexVertexIterT() : mesh_(0), active_(false) {}
00300
00301
00303 ConstVertexVertexIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start) :
00304 mesh_(&_mesh),
00305 start_(_mesh.halfedge_handle(_start)),
00306 heh_(start_),
00307 active_(false)
00308 { ; }
00309
00310
00312 ConstVertexVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
00313 mesh_(&_mesh),
00314 start_(_heh),
00315 heh_(_heh),
00316 active_(false)
00317 { ; }
00318
00319
00321 ConstVertexVertexIterT(const ConstVertexVertexIterT& _rhs) :
00322 mesh_(_rhs.mesh_),
00323 start_(_rhs.start_),
00324 heh_(_rhs.heh_),
00325 active_(_rhs.active_)
00326 { ; }
00327
00328
00330 ConstVertexVertexIterT& operator=(const ConstVertexVertexIterT<Mesh>& _rhs)
00331 {
00332 mesh_ = _rhs.mesh_;
00333 start_ = _rhs.start_;
00334 heh_ = _rhs.heh_;
00335 active_ = _rhs.active_;
00336 return *this;
00337 }
00338
00339
00340 #if 1
00341
00342 ConstVertexVertexIterT(const VertexVertexIterT<Mesh>& _rhs) :
00343 mesh_(_rhs.mesh_),
00344 start_(_rhs.start_),
00345 heh_(_rhs.heh_),
00346 active_(_rhs.active_)
00347 { ; }
00348
00349
00351 ConstVertexVertexIterT& operator=(const VertexVertexIterT<Mesh>& _rhs)
00352 {
00353 mesh_ = _rhs.mesh_;
00354 start_ = _rhs.start_;
00355 heh_ = _rhs.heh_;
00356 active_ = _rhs.active_;
00357 return *this;
00358 }
00359 #else
00360 friend class ConstVertexVertexIterT<Mesh>;
00361 #endif
00362
00363
00365 bool operator==(const ConstVertexVertexIterT& _rhs) const {
00366 return ((mesh_ == _rhs.mesh_) &&
00367 (start_ == _rhs.start_) &&
00368 (heh_ == _rhs.heh_) &&
00369 (active_ == _rhs.active_));
00370 }
00371
00372
00374 bool operator!=(const ConstVertexVertexIterT& _rhs) const {
00375 return !operator==(_rhs);
00376 }
00377
00378
00380 ConstVertexVertexIterT& operator++() {
00381 assert(mesh_);
00382 active_ = true;
00383 heh_=mesh_->cw_rotated_halfedge_handle(heh_);;
00384 return *this;
00385 }
00386
00387
00389 ConstVertexVertexIterT& operator--() {
00390 assert(mesh_);
00391 active_ = true;
00392 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);;
00393 return *this;
00394 }
00395
00396
00401 HalfedgeHandle current_halfedge_handle() const {
00402 return heh_;
00403 }
00404
00405
00407 typename Mesh::VertexHandle handle() const {
00408 assert(mesh_);
00409 return mesh_->to_vertex_handle(heh_);;
00410 }
00411
00412
00414 operator typename Mesh::VertexHandle() const {
00415 assert(mesh_);
00416 return mesh_->to_vertex_handle(heh_);;
00417 }
00418
00419
00421 reference operator*() const {
00422 assert(mesh_);
00423 return mesh_->deref(handle());
00424 }
00425
00426
00428 pointer operator->() const {
00429 assert(mesh_);
00430 return &mesh_->deref(handle());
00431 }
00432
00433
00440 operator bool() const {
00441 return heh_.is_valid() && ((start_ != heh_) || (!active_));
00442 }
00443
00444
00445 private:
00446
00447 mesh_ptr mesh_;
00448 HalfedgeHandle start_, heh_;
00449 bool active_;
00450 };
00451
00452
00453
00454
00455
00456
00461 template <class Mesh>
00462 class VertexOHalfedgeIterT
00463 {
00464 public:
00465
00466
00467
00468
00469 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00470
00471 typedef typename Mesh::Halfedge value_type;
00472 typedef typename Mesh::HalfedgeHandle value_handle;
00473
00474 #if 0
00475 typedef const Mesh& mesh_ref;
00476 typedef const Mesh* mesh_ptr;
00477 typedef const typename Mesh::Halfedge& reference;
00478 typedef const typename Mesh::Halfedge* pointer;
00479 #else
00480 typedef Mesh& mesh_ref;
00481 typedef Mesh* mesh_ptr;
00482 typedef typename Mesh::Halfedge& reference;
00483 typedef typename Mesh::Halfedge* pointer;
00484 #endif
00485
00486
00487
00489 VertexOHalfedgeIterT() : mesh_(0), active_(false) {}
00490
00491
00493 VertexOHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start) :
00494 mesh_(&_mesh),
00495 start_(_mesh.halfedge_handle(_start)),
00496 heh_(start_),
00497 active_(false)
00498 { ; }
00499
00500
00502 VertexOHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
00503 mesh_(&_mesh),
00504 start_(_heh),
00505 heh_(_heh),
00506 active_(false)
00507 { ; }
00508
00509
00511 VertexOHalfedgeIterT(const VertexOHalfedgeIterT& _rhs) :
00512 mesh_(_rhs.mesh_),
00513 start_(_rhs.start_),
00514 heh_(_rhs.heh_),
00515 active_(_rhs.active_)
00516 { ; }
00517
00518
00520 VertexOHalfedgeIterT& operator=(const VertexOHalfedgeIterT<Mesh>& _rhs)
00521 {
00522 mesh_ = _rhs.mesh_;
00523 start_ = _rhs.start_;
00524 heh_ = _rhs.heh_;
00525 active_ = _rhs.active_;
00526 return *this;
00527 }
00528
00529
00530 #if 0
00531
00532 VertexOHalfedgeIterT(const VertexOHalfedgeIterT<Mesh>& _rhs) :
00533 mesh_(_rhs.mesh_),
00534 start_(_rhs.start_),
00535 heh_(_rhs.heh_),
00536 active_(_rhs.active_)
00537 { ; }
00538
00539
00541 VertexOHalfedgeIterT& operator=(const VertexOHalfedgeIterT<Mesh>& _rhs)
00542 {
00543 mesh_ = _rhs.mesh_;
00544 start_ = _rhs.start_;
00545 heh_ = _rhs.heh_;
00546 active_ = _rhs.active_;
00547 return *this;
00548 }
00549 #else
00550 friend class ConstVertexOHalfedgeIterT<Mesh>;
00551 #endif
00552
00553
00555 bool operator==(const VertexOHalfedgeIterT& _rhs) const {
00556 return ((mesh_ == _rhs.mesh_) &&
00557 (start_ == _rhs.start_) &&
00558 (heh_ == _rhs.heh_) &&
00559 (active_ == _rhs.active_));
00560 }
00561
00562
00564 bool operator!=(const VertexOHalfedgeIterT& _rhs) const {
00565 return !operator==(_rhs);
00566 }
00567
00568
00570 VertexOHalfedgeIterT& operator++() {
00571 assert(mesh_);
00572 active_ = true;
00573 heh_=mesh_->cw_rotated_halfedge_handle(heh_);;
00574 return *this;
00575 }
00576
00577
00579 VertexOHalfedgeIterT& operator--() {
00580 assert(mesh_);
00581 active_ = true;
00582 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);;
00583 return *this;
00584 }
00585
00586
00591 HalfedgeHandle current_halfedge_handle() const {
00592 return heh_;
00593 }
00594
00595
00597 typename Mesh::HalfedgeHandle handle() const {
00598 assert(mesh_);
00599 return heh_;
00600 }
00601
00602
00604 operator typename Mesh::HalfedgeHandle() const {
00605 assert(mesh_);
00606 return heh_;
00607 }
00608
00609
00611 reference operator*() const {
00612 assert(mesh_);
00613 return mesh_->deref(handle());
00614 }
00615
00616
00618 pointer operator->() const {
00619 assert(mesh_);
00620 return &mesh_->deref(handle());
00621 }
00622
00623
00630 operator bool() const {
00631 return heh_.is_valid() && ((start_ != heh_) || (!active_));
00632 }
00633
00634
00635 private:
00636
00637 mesh_ptr mesh_;
00638 HalfedgeHandle start_, heh_;
00639 bool active_;
00640 };
00641
00642
00643
00644
00645
00646
00651 template <class Mesh>
00652 class ConstVertexOHalfedgeIterT
00653 {
00654 public:
00655
00656
00657
00658
00659 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00660
00661 typedef typename Mesh::Halfedge value_type;
00662 typedef typename Mesh::HalfedgeHandle value_handle;
00663
00664 #if 1
00665 typedef const Mesh& mesh_ref;
00666 typedef const Mesh* mesh_ptr;
00667 typedef const typename Mesh::Halfedge& reference;
00668 typedef const typename Mesh::Halfedge* pointer;
00669 #else
00670 typedef Mesh& mesh_ref;
00671 typedef Mesh* mesh_ptr;
00672 typedef typename Mesh::Halfedge& reference;
00673 typedef typename Mesh::Halfedge* pointer;
00674 #endif
00675
00676
00677
00679 ConstVertexOHalfedgeIterT() : mesh_(0), active_(false) {}
00680
00681
00683 ConstVertexOHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start) :
00684 mesh_(&_mesh),
00685 start_(_mesh.halfedge_handle(_start)),
00686 heh_(start_),
00687 active_(false)
00688 { ; }
00689
00690
00692 ConstVertexOHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
00693 mesh_(&_mesh),
00694 start_(_heh),
00695 heh_(_heh),
00696 active_(false)
00697 { ; }
00698
00699
00701 ConstVertexOHalfedgeIterT(const ConstVertexOHalfedgeIterT& _rhs) :
00702 mesh_(_rhs.mesh_),
00703 start_(_rhs.start_),
00704 heh_(_rhs.heh_),
00705 active_(_rhs.active_)
00706 { ; }
00707
00708
00710 ConstVertexOHalfedgeIterT& operator=(const ConstVertexOHalfedgeIterT<Mesh>& _rhs)
00711 {
00712 mesh_ = _rhs.mesh_;
00713 start_ = _rhs.start_;
00714 heh_ = _rhs.heh_;
00715 active_ = _rhs.active_;
00716 return *this;
00717 }
00718
00719
00720 #if 1
00721
00722 ConstVertexOHalfedgeIterT(const VertexOHalfedgeIterT<Mesh>& _rhs) :
00723 mesh_(_rhs.mesh_),
00724 start_(_rhs.start_),
00725 heh_(_rhs.heh_),
00726 active_(_rhs.active_)
00727 { ; }
00728
00729
00731 ConstVertexOHalfedgeIterT& operator=(const VertexOHalfedgeIterT<Mesh>& _rhs)
00732 {
00733 mesh_ = _rhs.mesh_;
00734 start_ = _rhs.start_;
00735 heh_ = _rhs.heh_;
00736 active_ = _rhs.active_;
00737 return *this;
00738 }
00739 #else
00740 friend class ConstVertexOHalfedgeIterT<Mesh>;
00741 #endif
00742
00743
00745 bool operator==(const ConstVertexOHalfedgeIterT& _rhs) const {
00746 return ((mesh_ == _rhs.mesh_) &&
00747 (start_ == _rhs.start_) &&
00748 (heh_ == _rhs.heh_) &&
00749 (active_ == _rhs.active_));
00750 }
00751
00752
00754 bool operator!=(const ConstVertexOHalfedgeIterT& _rhs) const {
00755 return !operator==(_rhs);
00756 }
00757
00758
00760 ConstVertexOHalfedgeIterT& operator++() {
00761 assert(mesh_);
00762 active_ = true;
00763 heh_=mesh_->cw_rotated_halfedge_handle(heh_);;
00764 return *this;
00765 }
00766
00767
00769 ConstVertexOHalfedgeIterT& operator--() {
00770 assert(mesh_);
00771 active_ = true;
00772 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);;
00773 return *this;
00774 }
00775
00776
00781 HalfedgeHandle current_halfedge_handle() const {
00782 return heh_;
00783 }
00784
00785
00787 typename Mesh::HalfedgeHandle handle() const {
00788 assert(mesh_);
00789 return heh_;
00790 }
00791
00792
00794 operator typename Mesh::HalfedgeHandle() const {
00795 assert(mesh_);
00796 return heh_;
00797 }
00798
00799
00801 reference operator*() const {
00802 assert(mesh_);
00803 return mesh_->deref(handle());
00804 }
00805
00806
00808 pointer operator->() const {
00809 assert(mesh_);
00810 return &mesh_->deref(handle());
00811 }
00812
00813
00820 operator bool() const {
00821 return heh_.is_valid() && ((start_ != heh_) || (!active_));
00822 }
00823
00824
00825 private:
00826
00827 mesh_ptr mesh_;
00828 HalfedgeHandle start_, heh_;
00829 bool active_;
00830 };
00831
00832
00833
00834
00835
00836
00841 template <class Mesh>
00842 class VertexIHalfedgeIterT
00843 {
00844 public:
00845
00846
00847
00848
00849 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00850
00851 typedef typename Mesh::Halfedge value_type;
00852 typedef typename Mesh::HalfedgeHandle value_handle;
00853
00854 #if 0
00855 typedef const Mesh& mesh_ref;
00856 typedef const Mesh* mesh_ptr;
00857 typedef const typename Mesh::Halfedge& reference;
00858 typedef const typename Mesh::Halfedge* pointer;
00859 #else
00860 typedef Mesh& mesh_ref;
00861 typedef Mesh* mesh_ptr;
00862 typedef typename Mesh::Halfedge& reference;
00863 typedef typename Mesh::Halfedge* pointer;
00864 #endif
00865
00866
00867
00869 VertexIHalfedgeIterT() : mesh_(0), active_(false) {}
00870
00871
00873 VertexIHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start) :
00874 mesh_(&_mesh),
00875 start_(_mesh.halfedge_handle(_start)),
00876 heh_(start_),
00877 active_(false)
00878 { ; }
00879
00880
00882 VertexIHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
00883 mesh_(&_mesh),
00884 start_(_heh),
00885 heh_(_heh),
00886 active_(false)
00887 { ; }
00888
00889
00891 VertexIHalfedgeIterT(const VertexIHalfedgeIterT& _rhs) :
00892 mesh_(_rhs.mesh_),
00893 start_(_rhs.start_),
00894 heh_(_rhs.heh_),
00895 active_(_rhs.active_)
00896 { ; }
00897
00898
00900 VertexIHalfedgeIterT& operator=(const VertexIHalfedgeIterT<Mesh>& _rhs)
00901 {
00902 mesh_ = _rhs.mesh_;
00903 start_ = _rhs.start_;
00904 heh_ = _rhs.heh_;
00905 active_ = _rhs.active_;
00906 return *this;
00907 }
00908
00909
00910 #if 0
00911
00912 VertexIHalfedgeIterT(const VertexIHalfedgeIterT<Mesh>& _rhs) :
00913 mesh_(_rhs.mesh_),
00914 start_(_rhs.start_),
00915 heh_(_rhs.heh_),
00916 active_(_rhs.active_)
00917 { ; }
00918
00919
00921 VertexIHalfedgeIterT& operator=(const VertexIHalfedgeIterT<Mesh>& _rhs)
00922 {
00923 mesh_ = _rhs.mesh_;
00924 start_ = _rhs.start_;
00925 heh_ = _rhs.heh_;
00926 active_ = _rhs.active_;
00927 return *this;
00928 }
00929 #else
00930 friend class ConstVertexIHalfedgeIterT<Mesh>;
00931 #endif
00932
00933
00935 bool operator==(const VertexIHalfedgeIterT& _rhs) const {
00936 return ((mesh_ == _rhs.mesh_) &&
00937 (start_ == _rhs.start_) &&
00938 (heh_ == _rhs.heh_) &&
00939 (active_ == _rhs.active_));
00940 }
00941
00942
00944 bool operator!=(const VertexIHalfedgeIterT& _rhs) const {
00945 return !operator==(_rhs);
00946 }
00947
00948
00950 VertexIHalfedgeIterT& operator++() {
00951 assert(mesh_);
00952 active_ = true;
00953 heh_=mesh_->cw_rotated_halfedge_handle(heh_);;
00954 return *this;
00955 }
00956
00957
00959 VertexIHalfedgeIterT& operator--() {
00960 assert(mesh_);
00961 active_ = true;
00962 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);;
00963 return *this;
00964 }
00965
00966
00971 HalfedgeHandle current_halfedge_handle() const {
00972 return heh_;
00973 }
00974
00975
00977 typename Mesh::HalfedgeHandle handle() const {
00978 assert(mesh_);
00979 return mesh_->opposite_halfedge_handle(heh_);
00980 }
00981
00982
00984 operator typename Mesh::HalfedgeHandle() const {
00985 assert(mesh_);
00986 return mesh_->opposite_halfedge_handle(heh_);
00987 }
00988
00989
00991 reference operator*() const {
00992 assert(mesh_);
00993 return mesh_->deref(handle());
00994 }
00995
00996
00998 pointer operator->() const {
00999 assert(mesh_);
01000 return &mesh_->deref(handle());
01001 }
01002
01003
01010 operator bool() const {
01011 return heh_.is_valid() && ((start_ != heh_) || (!active_));
01012 }
01013
01014
01015 private:
01016
01017 mesh_ptr mesh_;
01018 HalfedgeHandle start_, heh_;
01019 bool active_;
01020 };
01021
01022
01023
01024
01025
01026
01031 template <class Mesh>
01032 class ConstVertexIHalfedgeIterT
01033 {
01034 public:
01035
01036
01037
01038
01039 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01040
01041 typedef typename Mesh::Halfedge value_type;
01042 typedef typename Mesh::HalfedgeHandle value_handle;
01043
01044 #if 1
01045 typedef const Mesh& mesh_ref;
01046 typedef const Mesh* mesh_ptr;
01047 typedef const typename Mesh::Halfedge& reference;
01048 typedef const typename Mesh::Halfedge* pointer;
01049 #else
01050 typedef Mesh& mesh_ref;
01051 typedef Mesh* mesh_ptr;
01052 typedef typename Mesh::Halfedge& reference;
01053 typedef typename Mesh::Halfedge* pointer;
01054 #endif
01055
01056
01057
01059 ConstVertexIHalfedgeIterT() : mesh_(0), active_(false) {}
01060
01061
01063 ConstVertexIHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start) :
01064 mesh_(&_mesh),
01065 start_(_mesh.halfedge_handle(_start)),
01066 heh_(start_),
01067 active_(false)
01068 { ; }
01069
01070
01072 ConstVertexIHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
01073 mesh_(&_mesh),
01074 start_(_heh),
01075 heh_(_heh),
01076 active_(false)
01077 { ; }
01078
01079
01081 ConstVertexIHalfedgeIterT(const ConstVertexIHalfedgeIterT& _rhs) :
01082 mesh_(_rhs.mesh_),
01083 start_(_rhs.start_),
01084 heh_(_rhs.heh_),
01085 active_(_rhs.active_)
01086 { ; }
01087
01088
01090 ConstVertexIHalfedgeIterT& operator=(const ConstVertexIHalfedgeIterT<Mesh>& _rhs)
01091 {
01092 mesh_ = _rhs.mesh_;
01093 start_ = _rhs.start_;
01094 heh_ = _rhs.heh_;
01095 active_ = _rhs.active_;
01096 return *this;
01097 }
01098
01099
01100 #if 1
01101
01102 ConstVertexIHalfedgeIterT(const VertexIHalfedgeIterT<Mesh>& _rhs) :
01103 mesh_(_rhs.mesh_),
01104 start_(_rhs.start_),
01105 heh_(_rhs.heh_),
01106 active_(_rhs.active_)
01107 { ; }
01108
01109
01111 ConstVertexIHalfedgeIterT& operator=(const VertexIHalfedgeIterT<Mesh>& _rhs)
01112 {
01113 mesh_ = _rhs.mesh_;
01114 start_ = _rhs.start_;
01115 heh_ = _rhs.heh_;
01116 active_ = _rhs.active_;
01117 return *this;
01118 }
01119 #else
01120 friend class ConstVertexIHalfedgeIterT<Mesh>;
01121 #endif
01122
01123
01125 bool operator==(const ConstVertexIHalfedgeIterT& _rhs) const {
01126 return ((mesh_ == _rhs.mesh_) &&
01127 (start_ == _rhs.start_) &&
01128 (heh_ == _rhs.heh_) &&
01129 (active_ == _rhs.active_));
01130 }
01131
01132
01134 bool operator!=(const ConstVertexIHalfedgeIterT& _rhs) const {
01135 return !operator==(_rhs);
01136 }
01137
01138
01140 ConstVertexIHalfedgeIterT& operator++() {
01141 assert(mesh_);
01142 active_ = true;
01143 heh_=mesh_->cw_rotated_halfedge_handle(heh_);;
01144 return *this;
01145 }
01146
01147
01149 ConstVertexIHalfedgeIterT& operator--() {
01150 assert(mesh_);
01151 active_ = true;
01152 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);;
01153 return *this;
01154 }
01155
01156
01161 HalfedgeHandle current_halfedge_handle() const {
01162 return heh_;
01163 }
01164
01165
01167 typename Mesh::HalfedgeHandle handle() const {
01168 assert(mesh_);
01169 return mesh_->opposite_halfedge_handle(heh_);
01170 }
01171
01172
01174 operator typename Mesh::HalfedgeHandle() const {
01175 assert(mesh_);
01176 return mesh_->opposite_halfedge_handle(heh_);
01177 }
01178
01179
01181 reference operator*() const {
01182 assert(mesh_);
01183 return mesh_->deref(handle());
01184 }
01185
01186
01188 pointer operator->() const {
01189 assert(mesh_);
01190 return &mesh_->deref(handle());
01191 }
01192
01193
01200 operator bool() const {
01201 return heh_.is_valid() && ((start_ != heh_) || (!active_));
01202 }
01203
01204
01205 private:
01206
01207 mesh_ptr mesh_;
01208 HalfedgeHandle start_, heh_;
01209 bool active_;
01210 };
01211
01212
01213
01214
01215
01216
01221 template <class Mesh>
01222 class VertexEdgeIterT
01223 {
01224 public:
01225
01226
01227
01228
01229 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01230
01231 typedef typename Mesh::Edge value_type;
01232 typedef typename Mesh::EdgeHandle value_handle;
01233
01234 #if 0
01235 typedef const Mesh& mesh_ref;
01236 typedef const Mesh* mesh_ptr;
01237 typedef const typename Mesh::Edge& reference;
01238 typedef const typename Mesh::Edge* pointer;
01239 #else
01240 typedef Mesh& mesh_ref;
01241 typedef Mesh* mesh_ptr;
01242 typedef typename Mesh::Edge& reference;
01243 typedef typename Mesh::Edge* pointer;
01244 #endif
01245
01246
01247
01249 VertexEdgeIterT() : mesh_(0), active_(false) {}
01250
01251
01253 VertexEdgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start) :
01254 mesh_(&_mesh),
01255 start_(_mesh.halfedge_handle(_start)),
01256 heh_(start_),
01257 active_(false)
01258 { ; }
01259
01260
01262 VertexEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
01263 mesh_(&_mesh),
01264 start_(_heh),
01265 heh_(_heh),
01266 active_(false)
01267 { ; }
01268
01269
01271 VertexEdgeIterT(const VertexEdgeIterT& _rhs) :
01272 mesh_(_rhs.mesh_),
01273 start_(_rhs.start_),
01274 heh_(_rhs.heh_),
01275 active_(_rhs.active_)
01276 { ; }
01277
01278
01280 VertexEdgeIterT& operator=(const VertexEdgeIterT<Mesh>& _rhs)
01281 {
01282 mesh_ = _rhs.mesh_;
01283 start_ = _rhs.start_;
01284 heh_ = _rhs.heh_;
01285 active_ = _rhs.active_;
01286 return *this;
01287 }
01288
01289
01290 #if 0
01291
01292 VertexEdgeIterT(const VertexEdgeIterT<Mesh>& _rhs) :
01293 mesh_(_rhs.mesh_),
01294 start_(_rhs.start_),
01295 heh_(_rhs.heh_),
01296 active_(_rhs.active_)
01297 { ; }
01298
01299
01301 VertexEdgeIterT& operator=(const VertexEdgeIterT<Mesh>& _rhs)
01302 {
01303 mesh_ = _rhs.mesh_;
01304 start_ = _rhs.start_;
01305 heh_ = _rhs.heh_;
01306 active_ = _rhs.active_;
01307 return *this;
01308 }
01309 #else
01310 friend class ConstVertexEdgeIterT<Mesh>;
01311 #endif
01312
01313
01315 bool operator==(const VertexEdgeIterT& _rhs) const {
01316 return ((mesh_ == _rhs.mesh_) &&
01317 (start_ == _rhs.start_) &&
01318 (heh_ == _rhs.heh_) &&
01319 (active_ == _rhs.active_));
01320 }
01321
01322
01324 bool operator!=(const VertexEdgeIterT& _rhs) const {
01325 return !operator==(_rhs);
01326 }
01327
01328
01330 VertexEdgeIterT& operator++() {
01331 assert(mesh_);
01332 active_ = true;
01333 heh_=mesh_->cw_rotated_halfedge_handle(heh_);;
01334 return *this;
01335 }
01336
01337
01339 VertexEdgeIterT& operator--() {
01340 assert(mesh_);
01341 active_ = true;
01342 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);;
01343 return *this;
01344 }
01345
01346
01351 HalfedgeHandle current_halfedge_handle() const {
01352 return heh_;
01353 }
01354
01355
01357 typename Mesh::EdgeHandle handle() const {
01358 assert(mesh_);
01359 return mesh_->edge_handle(heh_);
01360 }
01361
01362
01364 operator typename Mesh::EdgeHandle() const {
01365 assert(mesh_);
01366 return mesh_->edge_handle(heh_);
01367 }
01368
01369
01371 reference operator*() const {
01372 assert(mesh_);
01373 return mesh_->deref(handle());
01374 }
01375
01376
01378 pointer operator->() const {
01379 assert(mesh_);
01380 return &mesh_->deref(handle());
01381 }
01382
01383
01390 operator bool() const {
01391 return heh_.is_valid() && ((start_ != heh_) || (!active_));
01392 }
01393
01394
01395 private:
01396
01397 mesh_ptr mesh_;
01398 HalfedgeHandle start_, heh_;
01399 bool active_;
01400 };
01401
01402
01403
01404
01405
01406
01411 template <class Mesh>
01412 class ConstVertexEdgeIterT
01413 {
01414 public:
01415
01416
01417
01418
01419 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01420
01421 typedef typename Mesh::Edge value_type;
01422 typedef typename Mesh::EdgeHandle value_handle;
01423
01424 #if 1
01425 typedef const Mesh& mesh_ref;
01426 typedef const Mesh* mesh_ptr;
01427 typedef const typename Mesh::Edge& reference;
01428 typedef const typename Mesh::Edge* pointer;
01429 #else
01430 typedef Mesh& mesh_ref;
01431 typedef Mesh* mesh_ptr;
01432 typedef typename Mesh::Edge& reference;
01433 typedef typename Mesh::Edge* pointer;
01434 #endif
01435
01436
01437
01439 ConstVertexEdgeIterT() : mesh_(0), active_(false) {}
01440
01441
01443 ConstVertexEdgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start) :
01444 mesh_(&_mesh),
01445 start_(_mesh.halfedge_handle(_start)),
01446 heh_(start_),
01447 active_(false)
01448 { ; }
01449
01450
01452 ConstVertexEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
01453 mesh_(&_mesh),
01454 start_(_heh),
01455 heh_(_heh),
01456 active_(false)
01457 { ; }
01458
01459
01461 ConstVertexEdgeIterT(const ConstVertexEdgeIterT& _rhs) :
01462 mesh_(_rhs.mesh_),
01463 start_(_rhs.start_),
01464 heh_(_rhs.heh_),
01465 active_(_rhs.active_)
01466 { ; }
01467
01468
01470 ConstVertexEdgeIterT& operator=(const ConstVertexEdgeIterT<Mesh>& _rhs)
01471 {
01472 mesh_ = _rhs.mesh_;
01473 start_ = _rhs.start_;
01474 heh_ = _rhs.heh_;
01475 active_ = _rhs.active_;
01476 return *this;
01477 }
01478
01479
01480 #if 1
01481
01482 ConstVertexEdgeIterT(const VertexEdgeIterT<Mesh>& _rhs) :
01483 mesh_(_rhs.mesh_),
01484 start_(_rhs.start_),
01485 heh_(_rhs.heh_),
01486 active_(_rhs.active_)
01487 { ; }
01488
01489
01491 ConstVertexEdgeIterT& operator=(const VertexEdgeIterT<Mesh>& _rhs)
01492 {
01493 mesh_ = _rhs.mesh_;
01494 start_ = _rhs.start_;
01495 heh_ = _rhs.heh_;
01496 active_ = _rhs.active_;
01497 return *this;
01498 }
01499 #else
01500 friend class ConstVertexEdgeIterT<Mesh>;
01501 #endif
01502
01503
01505 bool operator==(const ConstVertexEdgeIterT& _rhs) const {
01506 return ((mesh_ == _rhs.mesh_) &&
01507 (start_ == _rhs.start_) &&
01508 (heh_ == _rhs.heh_) &&
01509 (active_ == _rhs.active_));
01510 }
01511
01512
01514 bool operator!=(const ConstVertexEdgeIterT& _rhs) const {
01515 return !operator==(_rhs);
01516 }
01517
01518
01520 ConstVertexEdgeIterT& operator++() {
01521 assert(mesh_);
01522 active_ = true;
01523 heh_=mesh_->cw_rotated_halfedge_handle(heh_);;
01524 return *this;
01525 }
01526
01527
01529 ConstVertexEdgeIterT& operator--() {
01530 assert(mesh_);
01531 active_ = true;
01532 heh_=mesh_->ccw_rotated_halfedge_handle(heh_);;
01533 return *this;
01534 }
01535
01536
01541 HalfedgeHandle current_halfedge_handle() const {
01542 return heh_;
01543 }
01544
01545
01547 typename Mesh::EdgeHandle handle() const {
01548 assert(mesh_);
01549 return mesh_->edge_handle(heh_);
01550 }
01551
01552
01554 operator typename Mesh::EdgeHandle() const {
01555 assert(mesh_);
01556 return mesh_->edge_handle(heh_);
01557 }
01558
01559
01561 reference operator*() const {
01562 assert(mesh_);
01563 return mesh_->deref(handle());
01564 }
01565
01566
01568 pointer operator->() const {
01569 assert(mesh_);
01570 return &mesh_->deref(handle());
01571 }
01572
01573
01580 operator bool() const {
01581 return heh_.is_valid() && ((start_ != heh_) || (!active_));
01582 }
01583
01584
01585 private:
01586
01587 mesh_ptr mesh_;
01588 HalfedgeHandle start_, heh_;
01589 bool active_;
01590 };
01591
01592
01593
01594
01595
01596
01601 template <class Mesh>
01602 class VertexFaceIterT
01603 {
01604 public:
01605
01606
01607
01608
01609 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01610
01611 typedef typename Mesh::Face value_type;
01612 typedef typename Mesh::FaceHandle value_handle;
01613
01614 #if 0
01615 typedef const Mesh& mesh_ref;
01616 typedef const Mesh* mesh_ptr;
01617 typedef const typename Mesh::Face& reference;
01618 typedef const typename Mesh::Face* pointer;
01619 #else
01620 typedef Mesh& mesh_ref;
01621 typedef Mesh* mesh_ptr;
01622 typedef typename Mesh::Face& reference;
01623 typedef typename Mesh::Face* pointer;
01624 #endif
01625
01626
01627
01629 VertexFaceIterT() : mesh_(0), active_(false) {}
01630
01631
01633 VertexFaceIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start) :
01634 mesh_(&_mesh),
01635 start_(_mesh.halfedge_handle(_start)),
01636 heh_(start_),
01637 active_(false)
01638 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01639
01640
01642 VertexFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
01643 mesh_(&_mesh),
01644 start_(_heh),
01645 heh_(_heh),
01646 active_(false)
01647 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01648
01649
01651 VertexFaceIterT(const VertexFaceIterT& _rhs) :
01652 mesh_(_rhs.mesh_),
01653 start_(_rhs.start_),
01654 heh_(_rhs.heh_),
01655 active_(_rhs.active_)
01656 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01657
01658
01660 VertexFaceIterT& operator=(const VertexFaceIterT<Mesh>& _rhs)
01661 {
01662 mesh_ = _rhs.mesh_;
01663 start_ = _rhs.start_;
01664 heh_ = _rhs.heh_;
01665 active_ = _rhs.active_;
01666 return *this;
01667 }
01668
01669
01670 #if 0
01671
01672 VertexFaceIterT(const VertexFaceIterT<Mesh>& _rhs) :
01673 mesh_(_rhs.mesh_),
01674 start_(_rhs.start_),
01675 heh_(_rhs.heh_),
01676 active_(_rhs.active_)
01677 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01678
01679
01681 VertexFaceIterT& operator=(const VertexFaceIterT<Mesh>& _rhs)
01682 {
01683 mesh_ = _rhs.mesh_;
01684 start_ = _rhs.start_;
01685 heh_ = _rhs.heh_;
01686 active_ = _rhs.active_;
01687 return *this;
01688 }
01689 #else
01690 friend class ConstVertexFaceIterT<Mesh>;
01691 #endif
01692
01693
01695 bool operator==(const VertexFaceIterT& _rhs) const {
01696 return ((mesh_ == _rhs.mesh_) &&
01697 (start_ == _rhs.start_) &&
01698 (heh_ == _rhs.heh_) &&
01699 (active_ == _rhs.active_));
01700 }
01701
01702
01704 bool operator!=(const VertexFaceIterT& _rhs) const {
01705 return !operator==(_rhs);
01706 }
01707
01708
01710 VertexFaceIterT& operator++() {
01711 assert(mesh_);
01712 active_ = true;
01713 do heh_=mesh_->cw_rotated_halfedge_handle(heh_); while ((*this) && (!handle().is_valid()));;
01714 return *this;
01715 }
01716
01717
01719 VertexFaceIterT& operator--() {
01720 assert(mesh_);
01721 active_ = true;
01722 do heh_=mesh_->ccw_rotated_halfedge_handle(heh_); while ((*this) && (!handle().is_valid()));;
01723 return *this;
01724 }
01725
01726
01731 HalfedgeHandle current_halfedge_handle() const {
01732 return heh_;
01733 }
01734
01735
01737 typename Mesh::FaceHandle handle() const {
01738 assert(mesh_);
01739 return mesh_->face_handle(heh_);
01740 }
01741
01742
01744 operator typename Mesh::FaceHandle() const {
01745 assert(mesh_);
01746 return mesh_->face_handle(heh_);
01747 }
01748
01749
01751 reference operator*() const {
01752 assert(mesh_);
01753 return mesh_->deref(handle());
01754 }
01755
01756
01758 pointer operator->() const {
01759 assert(mesh_);
01760 return &mesh_->deref(handle());
01761 }
01762
01763
01770 operator bool() const {
01771 return heh_.is_valid() && ((start_ != heh_) || (!active_));
01772 }
01773
01774
01775 private:
01776
01777 mesh_ptr mesh_;
01778 HalfedgeHandle start_, heh_;
01779 bool active_;
01780 };
01781
01782
01783
01784
01785
01786
01791 template <class Mesh>
01792 class ConstVertexFaceIterT
01793 {
01794 public:
01795
01796
01797
01798
01799 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01800
01801 typedef typename Mesh::Face value_type;
01802 typedef typename Mesh::FaceHandle value_handle;
01803
01804 #if 1
01805 typedef const Mesh& mesh_ref;
01806 typedef const Mesh* mesh_ptr;
01807 typedef const typename Mesh::Face& reference;
01808 typedef const typename Mesh::Face* pointer;
01809 #else
01810 typedef Mesh& mesh_ref;
01811 typedef Mesh* mesh_ptr;
01812 typedef typename Mesh::Face& reference;
01813 typedef typename Mesh::Face* pointer;
01814 #endif
01815
01816
01817
01819 ConstVertexFaceIterT() : mesh_(0), active_(false) {}
01820
01821
01823 ConstVertexFaceIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start) :
01824 mesh_(&_mesh),
01825 start_(_mesh.halfedge_handle(_start)),
01826 heh_(start_),
01827 active_(false)
01828 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01829
01830
01832 ConstVertexFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
01833 mesh_(&_mesh),
01834 start_(_heh),
01835 heh_(_heh),
01836 active_(false)
01837 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01838
01839
01841 ConstVertexFaceIterT(const ConstVertexFaceIterT& _rhs) :
01842 mesh_(_rhs.mesh_),
01843 start_(_rhs.start_),
01844 heh_(_rhs.heh_),
01845 active_(_rhs.active_)
01846 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01847
01848
01850 ConstVertexFaceIterT& operator=(const ConstVertexFaceIterT<Mesh>& _rhs)
01851 {
01852 mesh_ = _rhs.mesh_;
01853 start_ = _rhs.start_;
01854 heh_ = _rhs.heh_;
01855 active_ = _rhs.active_;
01856 return *this;
01857 }
01858
01859
01860 #if 1
01861
01862 ConstVertexFaceIterT(const VertexFaceIterT<Mesh>& _rhs) :
01863 mesh_(_rhs.mesh_),
01864 start_(_rhs.start_),
01865 heh_(_rhs.heh_),
01866 active_(_rhs.active_)
01867 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
01868
01869
01871 ConstVertexFaceIterT& operator=(const VertexFaceIterT<Mesh>& _rhs)
01872 {
01873 mesh_ = _rhs.mesh_;
01874 start_ = _rhs.start_;
01875 heh_ = _rhs.heh_;
01876 active_ = _rhs.active_;
01877 return *this;
01878 }
01879 #else
01880 friend class ConstVertexFaceIterT<Mesh>;
01881 #endif
01882
01883
01885 bool operator==(const ConstVertexFaceIterT& _rhs) const {
01886 return ((mesh_ == _rhs.mesh_) &&
01887 (start_ == _rhs.start_) &&
01888 (heh_ == _rhs.heh_) &&
01889 (active_ == _rhs.active_));
01890 }
01891
01892
01894 bool operator!=(const ConstVertexFaceIterT& _rhs) const {
01895 return !operator==(_rhs);
01896 }
01897
01898
01900 ConstVertexFaceIterT& operator++() {
01901 assert(mesh_);
01902 active_ = true;
01903 do heh_=mesh_->cw_rotated_halfedge_handle(heh_); while ((*this) && (!handle().is_valid()));;
01904 return *this;
01905 }
01906
01907
01909 ConstVertexFaceIterT& operator--() {
01910 assert(mesh_);
01911 active_ = true;
01912 do heh_=mesh_->ccw_rotated_halfedge_handle(heh_); while ((*this) && (!handle().is_valid()));;
01913 return *this;
01914 }
01915
01916
01921 HalfedgeHandle current_halfedge_handle() const {
01922 return heh_;
01923 }
01924
01925
01927 typename Mesh::FaceHandle handle() const {
01928 assert(mesh_);
01929 return mesh_->face_handle(heh_);
01930 }
01931
01932
01934 operator typename Mesh::FaceHandle() const {
01935 assert(mesh_);
01936 return mesh_->face_handle(heh_);
01937 }
01938
01939
01941 reference operator*() const {
01942 assert(mesh_);
01943 return mesh_->deref(handle());
01944 }
01945
01946
01948 pointer operator->() const {
01949 assert(mesh_);
01950 return &mesh_->deref(handle());
01951 }
01952
01953
01960 operator bool() const {
01961 return heh_.is_valid() && ((start_ != heh_) || (!active_));
01962 }
01963
01964
01965 private:
01966
01967 mesh_ptr mesh_;
01968 HalfedgeHandle start_, heh_;
01969 bool active_;
01970 };
01971
01972
01973
01974
01975
01976
01981 template <class Mesh>
01982 class FaceVertexIterT
01983 {
01984 public:
01985
01986
01987
01988
01989 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
01990
01991 typedef typename Mesh::Vertex value_type;
01992 typedef typename Mesh::VertexHandle value_handle;
01993
01994 #if 0
01995 typedef const Mesh& mesh_ref;
01996 typedef const Mesh* mesh_ptr;
01997 typedef const typename Mesh::Vertex& reference;
01998 typedef const typename Mesh::Vertex* pointer;
01999 #else
02000 typedef Mesh& mesh_ref;
02001 typedef Mesh* mesh_ptr;
02002 typedef typename Mesh::Vertex& reference;
02003 typedef typename Mesh::Vertex* pointer;
02004 #endif
02005
02006
02007
02009 FaceVertexIterT() : mesh_(0), active_(false) {}
02010
02011
02013 FaceVertexIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start) :
02014 mesh_(&_mesh),
02015 start_(_mesh.halfedge_handle(_start)),
02016 heh_(start_),
02017 active_(false)
02018 { ; }
02019
02020
02022 FaceVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
02023 mesh_(&_mesh),
02024 start_(_heh),
02025 heh_(_heh),
02026 active_(false)
02027 { ; }
02028
02029
02031 FaceVertexIterT(const FaceVertexIterT& _rhs) :
02032 mesh_(_rhs.mesh_),
02033 start_(_rhs.start_),
02034 heh_(_rhs.heh_),
02035 active_(_rhs.active_)
02036 { ; }
02037
02038
02040 FaceVertexIterT& operator=(const FaceVertexIterT<Mesh>& _rhs)
02041 {
02042 mesh_ = _rhs.mesh_;
02043 start_ = _rhs.start_;
02044 heh_ = _rhs.heh_;
02045 active_ = _rhs.active_;
02046 return *this;
02047 }
02048
02049
02050 #if 0
02051
02052 FaceVertexIterT(const FaceVertexIterT<Mesh>& _rhs) :
02053 mesh_(_rhs.mesh_),
02054 start_(_rhs.start_),
02055 heh_(_rhs.heh_),
02056 active_(_rhs.active_)
02057 { ; }
02058
02059
02061 FaceVertexIterT& operator=(const FaceVertexIterT<Mesh>& _rhs)
02062 {
02063 mesh_ = _rhs.mesh_;
02064 start_ = _rhs.start_;
02065 heh_ = _rhs.heh_;
02066 active_ = _rhs.active_;
02067 return *this;
02068 }
02069 #else
02070 friend class ConstFaceVertexIterT<Mesh>;
02071 #endif
02072
02073
02075 bool operator==(const FaceVertexIterT& _rhs) const {
02076 return ((mesh_ == _rhs.mesh_) &&
02077 (start_ == _rhs.start_) &&
02078 (heh_ == _rhs.heh_) &&
02079 (active_ == _rhs.active_));
02080 }
02081
02082
02084 bool operator!=(const FaceVertexIterT& _rhs) const {
02085 return !operator==(_rhs);
02086 }
02087
02088
02090 FaceVertexIterT& operator++() {
02091 assert(mesh_);
02092 active_ = true;
02093 heh_=mesh_->next_halfedge_handle(heh_);;
02094 return *this;
02095 }
02096
02097
02099 FaceVertexIterT& operator--() {
02100 assert(mesh_);
02101 active_ = true;
02102 heh_=mesh_->prev_halfedge_handle(heh_);;
02103 return *this;
02104 }
02105
02106
02111 HalfedgeHandle current_halfedge_handle() const {
02112 return heh_;
02113 }
02114
02115
02117 typename Mesh::VertexHandle handle() const {
02118 assert(mesh_);
02119 return mesh_->to_vertex_handle(heh_);
02120 }
02121
02122
02124 operator typename Mesh::VertexHandle() const {
02125 assert(mesh_);
02126 return mesh_->to_vertex_handle(heh_);
02127 }
02128
02129
02131 reference operator*() const {
02132 assert(mesh_);
02133 return mesh_->deref(handle());
02134 }
02135
02136
02138 pointer operator->() const {
02139 assert(mesh_);
02140 return &mesh_->deref(handle());
02141 }
02142
02143
02150 operator bool() const {
02151 return heh_.is_valid() && ((start_ != heh_) || (!active_));
02152 }
02153
02154
02155 private:
02156
02157 mesh_ptr mesh_;
02158 HalfedgeHandle start_, heh_;
02159 bool active_;
02160 };
02161
02162
02163
02164
02165
02166
02171 template <class Mesh>
02172 class ConstFaceVertexIterT
02173 {
02174 public:
02175
02176
02177
02178
02179 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
02180
02181 typedef typename Mesh::Vertex value_type;
02182 typedef typename Mesh::VertexHandle value_handle;
02183
02184 #if 1
02185 typedef const Mesh& mesh_ref;
02186 typedef const Mesh* mesh_ptr;
02187 typedef const typename Mesh::Vertex& reference;
02188 typedef const typename Mesh::Vertex* pointer;
02189 #else
02190 typedef Mesh& mesh_ref;
02191 typedef Mesh* mesh_ptr;
02192 typedef typename Mesh::Vertex& reference;
02193 typedef typename Mesh::Vertex* pointer;
02194 #endif
02195
02196
02197
02199 ConstFaceVertexIterT() : mesh_(0), active_(false) {}
02200
02201
02203 ConstFaceVertexIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start) :
02204 mesh_(&_mesh),
02205 start_(_mesh.halfedge_handle(_start)),
02206 heh_(start_),
02207 active_(false)
02208 { ; }
02209
02210
02212 ConstFaceVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
02213 mesh_(&_mesh),
02214 start_(_heh),
02215 heh_(_heh),
02216 active_(false)
02217 { ; }
02218
02219
02221 ConstFaceVertexIterT(const ConstFaceVertexIterT& _rhs) :
02222 mesh_(_rhs.mesh_),
02223 start_(_rhs.start_),
02224 heh_(_rhs.heh_),
02225 active_(_rhs.active_)
02226 { ; }
02227
02228
02230 ConstFaceVertexIterT& operator=(const ConstFaceVertexIterT<Mesh>& _rhs)
02231 {
02232 mesh_ = _rhs.mesh_;
02233 start_ = _rhs.start_;
02234 heh_ = _rhs.heh_;
02235 active_ = _rhs.active_;
02236 return *this;
02237 }
02238
02239
02240 #if 1
02241
02242 ConstFaceVertexIterT(const FaceVertexIterT<Mesh>& _rhs) :
02243 mesh_(_rhs.mesh_),
02244 start_(_rhs.start_),
02245 heh_(_rhs.heh_),
02246 active_(_rhs.active_)
02247 { ; }
02248
02249
02251 ConstFaceVertexIterT& operator=(const FaceVertexIterT<Mesh>& _rhs)
02252 {
02253 mesh_ = _rhs.mesh_;
02254 start_ = _rhs.start_;
02255 heh_ = _rhs.heh_;
02256 active_ = _rhs.active_;
02257 return *this;
02258 }
02259 #else
02260 friend class ConstFaceVertexIterT<Mesh>;
02261 #endif
02262
02263
02265 bool operator==(const ConstFaceVertexIterT& _rhs) const {
02266 return ((mesh_ == _rhs.mesh_) &&
02267 (start_ == _rhs.start_) &&
02268 (heh_ == _rhs.heh_) &&
02269 (active_ == _rhs.active_));
02270 }
02271
02272
02274 bool operator!=(const ConstFaceVertexIterT& _rhs) const {
02275 return !operator==(_rhs);
02276 }
02277
02278
02280 ConstFaceVertexIterT& operator++() {
02281 assert(mesh_);
02282 active_ = true;
02283 heh_=mesh_->next_halfedge_handle(heh_);;
02284 return *this;
02285 }
02286
02287
02289 ConstFaceVertexIterT& operator--() {
02290 assert(mesh_);
02291 active_ = true;
02292 heh_=mesh_->prev_halfedge_handle(heh_);;
02293 return *this;
02294 }
02295
02296
02301 HalfedgeHandle current_halfedge_handle() const {
02302 return heh_;
02303 }
02304
02305
02307 typename Mesh::VertexHandle handle() const {
02308 assert(mesh_);
02309 return mesh_->to_vertex_handle(heh_);
02310 }
02311
02312
02314 operator typename Mesh::VertexHandle() const {
02315 assert(mesh_);
02316 return mesh_->to_vertex_handle(heh_);
02317 }
02318
02319
02321 reference operator*() const {
02322 assert(mesh_);
02323 return mesh_->deref(handle());
02324 }
02325
02326
02328 pointer operator->() const {
02329 assert(mesh_);
02330 return &mesh_->deref(handle());
02331 }
02332
02333
02340 operator bool() const {
02341 return heh_.is_valid() && ((start_ != heh_) || (!active_));
02342 }
02343
02344
02345 private:
02346
02347 mesh_ptr mesh_;
02348 HalfedgeHandle start_, heh_;
02349 bool active_;
02350 };
02351
02352
02353
02354
02355
02356
02361 template <class Mesh>
02362 class FaceHalfedgeIterT
02363 {
02364 public:
02365
02366
02367
02368
02369 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
02370
02371 typedef typename Mesh::Halfedge value_type;
02372 typedef typename Mesh::HalfedgeHandle value_handle;
02373
02374 #if 0
02375 typedef const Mesh& mesh_ref;
02376 typedef const Mesh* mesh_ptr;
02377 typedef const typename Mesh::Halfedge& reference;
02378 typedef const typename Mesh::Halfedge* pointer;
02379 #else
02380 typedef Mesh& mesh_ref;
02381 typedef Mesh* mesh_ptr;
02382 typedef typename Mesh::Halfedge& reference;
02383 typedef typename Mesh::Halfedge* pointer;
02384 #endif
02385
02386
02387
02389 FaceHalfedgeIterT() : mesh_(0), active_(false) {}
02390
02391
02393 FaceHalfedgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start) :
02394 mesh_(&_mesh),
02395 start_(_mesh.halfedge_handle(_start)),
02396 heh_(start_),
02397 active_(false)
02398 { ; }
02399
02400
02402 FaceHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
02403 mesh_(&_mesh),
02404 start_(_heh),
02405 heh_(_heh),
02406 active_(false)
02407 { ; }
02408
02409
02411 FaceHalfedgeIterT(const FaceHalfedgeIterT& _rhs) :
02412 mesh_(_rhs.mesh_),
02413 start_(_rhs.start_),
02414 heh_(_rhs.heh_),
02415 active_(_rhs.active_)
02416 { ; }
02417
02418
02420 FaceHalfedgeIterT& operator=(const FaceHalfedgeIterT<Mesh>& _rhs)
02421 {
02422 mesh_ = _rhs.mesh_;
02423 start_ = _rhs.start_;
02424 heh_ = _rhs.heh_;
02425 active_ = _rhs.active_;
02426 return *this;
02427 }
02428
02429
02430 #if 0
02431
02432 FaceHalfedgeIterT(const FaceHalfedgeIterT<Mesh>& _rhs) :
02433 mesh_(_rhs.mesh_),
02434 start_(_rhs.start_),
02435 heh_(_rhs.heh_),
02436 active_(_rhs.active_)
02437 { ; }
02438
02439
02441 FaceHalfedgeIterT& operator=(const FaceHalfedgeIterT<Mesh>& _rhs)
02442 {
02443 mesh_ = _rhs.mesh_;
02444 start_ = _rhs.start_;
02445 heh_ = _rhs.heh_;
02446 active_ = _rhs.active_;
02447 return *this;
02448 }
02449 #else
02450 friend class ConstFaceHalfedgeIterT<Mesh>;
02451 #endif
02452
02453
02455 bool operator==(const FaceHalfedgeIterT& _rhs) const {
02456 return ((mesh_ == _rhs.mesh_) &&
02457 (start_ == _rhs.start_) &&
02458 (heh_ == _rhs.heh_) &&
02459 (active_ == _rhs.active_));
02460 }
02461
02462
02464 bool operator!=(const FaceHalfedgeIterT& _rhs) const {
02465 return !operator==(_rhs);
02466 }
02467
02468
02470 FaceHalfedgeIterT& operator++() {
02471 assert(mesh_);
02472 active_ = true;
02473 heh_=mesh_->next_halfedge_handle(heh_);;
02474 return *this;
02475 }
02476
02477
02479 FaceHalfedgeIterT& operator--() {
02480 assert(mesh_);
02481 active_ = true;
02482 heh_=mesh_->prev_halfedge_handle(heh_);;
02483 return *this;
02484 }
02485
02486
02491 HalfedgeHandle current_halfedge_handle() const {
02492 return heh_;
02493 }
02494
02495
02497 typename Mesh::HalfedgeHandle handle() const {
02498 assert(mesh_);
02499 return heh_;
02500 }
02501
02502
02504 operator typename Mesh::HalfedgeHandle() const {
02505 assert(mesh_);
02506 return heh_;
02507 }
02508
02509
02511 reference operator*() const {
02512 assert(mesh_);
02513 return mesh_->deref(handle());
02514 }
02515
02516
02518 pointer operator->() const {
02519 assert(mesh_);
02520 return &mesh_->deref(handle());
02521 }
02522
02523
02530 operator bool() const {
02531 return heh_.is_valid() && ((start_ != heh_) || (!active_));
02532 }
02533
02534
02535 private:
02536
02537 mesh_ptr mesh_;
02538 HalfedgeHandle start_, heh_;
02539 bool active_;
02540 };
02541
02542
02543
02544
02545
02546
02551 template <class Mesh>
02552 class ConstFaceHalfedgeIterT
02553 {
02554 public:
02555
02556
02557
02558
02559 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
02560
02561 typedef typename Mesh::Halfedge value_type;
02562 typedef typename Mesh::HalfedgeHandle value_handle;
02563
02564 #if 1
02565 typedef const Mesh& mesh_ref;
02566 typedef const Mesh* mesh_ptr;
02567 typedef const typename Mesh::Halfedge& reference;
02568 typedef const typename Mesh::Halfedge* pointer;
02569 #else
02570 typedef Mesh& mesh_ref;
02571 typedef Mesh* mesh_ptr;
02572 typedef typename Mesh::Halfedge& reference;
02573 typedef typename Mesh::Halfedge* pointer;
02574 #endif
02575
02576
02577
02579 ConstFaceHalfedgeIterT() : mesh_(0), active_(false) {}
02580
02581
02583 ConstFaceHalfedgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start) :
02584 mesh_(&_mesh),
02585 start_(_mesh.halfedge_handle(_start)),
02586 heh_(start_),
02587 active_(false)
02588 { ; }
02589
02590
02592 ConstFaceHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
02593 mesh_(&_mesh),
02594 start_(_heh),
02595 heh_(_heh),
02596 active_(false)
02597 { ; }
02598
02599
02601 ConstFaceHalfedgeIterT(const ConstFaceHalfedgeIterT& _rhs) :
02602 mesh_(_rhs.mesh_),
02603 start_(_rhs.start_),
02604 heh_(_rhs.heh_),
02605 active_(_rhs.active_)
02606 { ; }
02607
02608
02610 ConstFaceHalfedgeIterT& operator=(const ConstFaceHalfedgeIterT<Mesh>& _rhs)
02611 {
02612 mesh_ = _rhs.mesh_;
02613 start_ = _rhs.start_;
02614 heh_ = _rhs.heh_;
02615 active_ = _rhs.active_;
02616 return *this;
02617 }
02618
02619
02620 #if 1
02621
02622 ConstFaceHalfedgeIterT(const FaceHalfedgeIterT<Mesh>& _rhs) :
02623 mesh_(_rhs.mesh_),
02624 start_(_rhs.start_),
02625 heh_(_rhs.heh_),
02626 active_(_rhs.active_)
02627 { ; }
02628
02629
02631 ConstFaceHalfedgeIterT& operator=(const FaceHalfedgeIterT<Mesh>& _rhs)
02632 {
02633 mesh_ = _rhs.mesh_;
02634 start_ = _rhs.start_;
02635 heh_ = _rhs.heh_;
02636 active_ = _rhs.active_;
02637 return *this;
02638 }
02639 #else
02640 friend class ConstFaceHalfedgeIterT<Mesh>;
02641 #endif
02642
02643
02645 bool operator==(const ConstFaceHalfedgeIterT& _rhs) const {
02646 return ((mesh_ == _rhs.mesh_) &&
02647 (start_ == _rhs.start_) &&
02648 (heh_ == _rhs.heh_) &&
02649 (active_ == _rhs.active_));
02650 }
02651
02652
02654 bool operator!=(const ConstFaceHalfedgeIterT& _rhs) const {
02655 return !operator==(_rhs);
02656 }
02657
02658
02660 ConstFaceHalfedgeIterT& operator++() {
02661 assert(mesh_);
02662 active_ = true;
02663 heh_=mesh_->next_halfedge_handle(heh_);;
02664 return *this;
02665 }
02666
02667
02669 ConstFaceHalfedgeIterT& operator--() {
02670 assert(mesh_);
02671 active_ = true;
02672 heh_=mesh_->prev_halfedge_handle(heh_);;
02673 return *this;
02674 }
02675
02676
02681 HalfedgeHandle current_halfedge_handle() const {
02682 return heh_;
02683 }
02684
02685
02687 typename Mesh::HalfedgeHandle handle() const {
02688 assert(mesh_);
02689 return heh_;
02690 }
02691
02692
02694 operator typename Mesh::HalfedgeHandle() const {
02695 assert(mesh_);
02696 return heh_;
02697 }
02698
02699
02701 reference operator*() const {
02702 assert(mesh_);
02703 return mesh_->deref(handle());
02704 }
02705
02706
02708 pointer operator->() const {
02709 assert(mesh_);
02710 return &mesh_->deref(handle());
02711 }
02712
02713
02720 operator bool() const {
02721 return heh_.is_valid() && ((start_ != heh_) || (!active_));
02722 }
02723
02724
02725 private:
02726
02727 mesh_ptr mesh_;
02728 HalfedgeHandle start_, heh_;
02729 bool active_;
02730 };
02731
02732
02733
02734
02735
02736
02741 template <class Mesh>
02742 class FaceEdgeIterT
02743 {
02744 public:
02745
02746
02747
02748
02749 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
02750
02751 typedef typename Mesh::Edge value_type;
02752 typedef typename Mesh::EdgeHandle value_handle;
02753
02754 #if 0
02755 typedef const Mesh& mesh_ref;
02756 typedef const Mesh* mesh_ptr;
02757 typedef const typename Mesh::Edge& reference;
02758 typedef const typename Mesh::Edge* pointer;
02759 #else
02760 typedef Mesh& mesh_ref;
02761 typedef Mesh* mesh_ptr;
02762 typedef typename Mesh::Edge& reference;
02763 typedef typename Mesh::Edge* pointer;
02764 #endif
02765
02766
02767
02769 FaceEdgeIterT() : mesh_(0), active_(false) {}
02770
02771
02773 FaceEdgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start) :
02774 mesh_(&_mesh),
02775 start_(_mesh.halfedge_handle(_start)),
02776 heh_(start_),
02777 active_(false)
02778 { ; }
02779
02780
02782 FaceEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
02783 mesh_(&_mesh),
02784 start_(_heh),
02785 heh_(_heh),
02786 active_(false)
02787 { ; }
02788
02789
02791 FaceEdgeIterT(const FaceEdgeIterT& _rhs) :
02792 mesh_(_rhs.mesh_),
02793 start_(_rhs.start_),
02794 heh_(_rhs.heh_),
02795 active_(_rhs.active_)
02796 { ; }
02797
02798
02800 FaceEdgeIterT& operator=(const FaceEdgeIterT<Mesh>& _rhs)
02801 {
02802 mesh_ = _rhs.mesh_;
02803 start_ = _rhs.start_;
02804 heh_ = _rhs.heh_;
02805 active_ = _rhs.active_;
02806 return *this;
02807 }
02808
02809
02810 #if 0
02811
02812 FaceEdgeIterT(const FaceEdgeIterT<Mesh>& _rhs) :
02813 mesh_(_rhs.mesh_),
02814 start_(_rhs.start_),
02815 heh_(_rhs.heh_),
02816 active_(_rhs.active_)
02817 { ; }
02818
02819
02821 FaceEdgeIterT& operator=(const FaceEdgeIterT<Mesh>& _rhs)
02822 {
02823 mesh_ = _rhs.mesh_;
02824 start_ = _rhs.start_;
02825 heh_ = _rhs.heh_;
02826 active_ = _rhs.active_;
02827 return *this;
02828 }
02829 #else
02830 friend class ConstFaceEdgeIterT<Mesh>;
02831 #endif
02832
02833
02835 bool operator==(const FaceEdgeIterT& _rhs) const {
02836 return ((mesh_ == _rhs.mesh_) &&
02837 (start_ == _rhs.start_) &&
02838 (heh_ == _rhs.heh_) &&
02839 (active_ == _rhs.active_));
02840 }
02841
02842
02844 bool operator!=(const FaceEdgeIterT& _rhs) const {
02845 return !operator==(_rhs);
02846 }
02847
02848
02850 FaceEdgeIterT& operator++() {
02851 assert(mesh_);
02852 active_ = true;
02853 heh_=mesh_->next_halfedge_handle(heh_);;
02854 return *this;
02855 }
02856
02857
02859 FaceEdgeIterT& operator--() {
02860 assert(mesh_);
02861 active_ = true;
02862 heh_=mesh_->prev_halfedge_handle(heh_);;
02863 return *this;
02864 }
02865
02866
02871 HalfedgeHandle current_halfedge_handle() const {
02872 return heh_;
02873 }
02874
02875
02877 typename Mesh::EdgeHandle handle() const {
02878 assert(mesh_);
02879 return mesh_->edge_handle(heh_);
02880 }
02881
02882
02884 operator typename Mesh::EdgeHandle() const {
02885 assert(mesh_);
02886 return mesh_->edge_handle(heh_);
02887 }
02888
02889
02891 reference operator*() const {
02892 assert(mesh_);
02893 return mesh_->deref(handle());
02894 }
02895
02896
02898 pointer operator->() const {
02899 assert(mesh_);
02900 return &mesh_->deref(handle());
02901 }
02902
02903
02910 operator bool() const {
02911 return heh_.is_valid() && ((start_ != heh_) || (!active_));
02912 }
02913
02914
02915 private:
02916
02917 mesh_ptr mesh_;
02918 HalfedgeHandle start_, heh_;
02919 bool active_;
02920 };
02921
02922
02923
02924
02925
02926
02931 template <class Mesh>
02932 class ConstFaceEdgeIterT
02933 {
02934 public:
02935
02936
02937
02938
02939 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
02940
02941 typedef typename Mesh::Edge value_type;
02942 typedef typename Mesh::EdgeHandle value_handle;
02943
02944 #if 1
02945 typedef const Mesh& mesh_ref;
02946 typedef const Mesh* mesh_ptr;
02947 typedef const typename Mesh::Edge& reference;
02948 typedef const typename Mesh::Edge* pointer;
02949 #else
02950 typedef Mesh& mesh_ref;
02951 typedef Mesh* mesh_ptr;
02952 typedef typename Mesh::Edge& reference;
02953 typedef typename Mesh::Edge* pointer;
02954 #endif
02955
02956
02957
02959 ConstFaceEdgeIterT() : mesh_(0), active_(false) {}
02960
02961
02963 ConstFaceEdgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start) :
02964 mesh_(&_mesh),
02965 start_(_mesh.halfedge_handle(_start)),
02966 heh_(start_),
02967 active_(false)
02968 { ; }
02969
02970
02972 ConstFaceEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
02973 mesh_(&_mesh),
02974 start_(_heh),
02975 heh_(_heh),
02976 active_(false)
02977 { ; }
02978
02979
02981 ConstFaceEdgeIterT(const ConstFaceEdgeIterT& _rhs) :
02982 mesh_(_rhs.mesh_),
02983 start_(_rhs.start_),
02984 heh_(_rhs.heh_),
02985 active_(_rhs.active_)
02986 { ; }
02987
02988
02990 ConstFaceEdgeIterT& operator=(const ConstFaceEdgeIterT<Mesh>& _rhs)
02991 {
02992 mesh_ = _rhs.mesh_;
02993 start_ = _rhs.start_;
02994 heh_ = _rhs.heh_;
02995 active_ = _rhs.active_;
02996 return *this;
02997 }
02998
02999
03000 #if 1
03001
03002 ConstFaceEdgeIterT(const FaceEdgeIterT<Mesh>& _rhs) :
03003 mesh_(_rhs.mesh_),
03004 start_(_rhs.start_),
03005 heh_(_rhs.heh_),
03006 active_(_rhs.active_)
03007 { ; }
03008
03009
03011 ConstFaceEdgeIterT& operator=(const FaceEdgeIterT<Mesh>& _rhs)
03012 {
03013 mesh_ = _rhs.mesh_;
03014 start_ = _rhs.start_;
03015 heh_ = _rhs.heh_;
03016 active_ = _rhs.active_;
03017 return *this;
03018 }
03019 #else
03020 friend class ConstFaceEdgeIterT<Mesh>;
03021 #endif
03022
03023
03025 bool operator==(const ConstFaceEdgeIterT& _rhs) const {
03026 return ((mesh_ == _rhs.mesh_) &&
03027 (start_ == _rhs.start_) &&
03028 (heh_ == _rhs.heh_) &&
03029 (active_ == _rhs.active_));
03030 }
03031
03032
03034 bool operator!=(const ConstFaceEdgeIterT& _rhs) const {
03035 return !operator==(_rhs);
03036 }
03037
03038
03040 ConstFaceEdgeIterT& operator++() {
03041 assert(mesh_);
03042 active_ = true;
03043 heh_=mesh_->next_halfedge_handle(heh_);;
03044 return *this;
03045 }
03046
03047
03049 ConstFaceEdgeIterT& operator--() {
03050 assert(mesh_);
03051 active_ = true;
03052 heh_=mesh_->prev_halfedge_handle(heh_);;
03053 return *this;
03054 }
03055
03056
03061 HalfedgeHandle current_halfedge_handle() const {
03062 return heh_;
03063 }
03064
03065
03067 typename Mesh::EdgeHandle handle() const {
03068 assert(mesh_);
03069 return mesh_->edge_handle(heh_);
03070 }
03071
03072
03074 operator typename Mesh::EdgeHandle() const {
03075 assert(mesh_);
03076 return mesh_->edge_handle(heh_);
03077 }
03078
03079
03081 reference operator*() const {
03082 assert(mesh_);
03083 return mesh_->deref(handle());
03084 }
03085
03086
03088 pointer operator->() const {
03089 assert(mesh_);
03090 return &mesh_->deref(handle());
03091 }
03092
03093
03100 operator bool() const {
03101 return heh_.is_valid() && ((start_ != heh_) || (!active_));
03102 }
03103
03104
03105 private:
03106
03107 mesh_ptr mesh_;
03108 HalfedgeHandle start_, heh_;
03109 bool active_;
03110 };
03111
03112
03113
03114
03115
03116
03121 template <class Mesh>
03122 class FaceFaceIterT
03123 {
03124 public:
03125
03126
03127
03128
03129 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
03130
03131 typedef typename Mesh::Face value_type;
03132 typedef typename Mesh::FaceHandle value_handle;
03133
03134 #if 0
03135 typedef const Mesh& mesh_ref;
03136 typedef const Mesh* mesh_ptr;
03137 typedef const typename Mesh::Face& reference;
03138 typedef const typename Mesh::Face* pointer;
03139 #else
03140 typedef Mesh& mesh_ref;
03141 typedef Mesh* mesh_ptr;
03142 typedef typename Mesh::Face& reference;
03143 typedef typename Mesh::Face* pointer;
03144 #endif
03145
03146
03147
03149 FaceFaceIterT() : mesh_(0), active_(false) {}
03150
03151
03153 FaceFaceIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start) :
03154 mesh_(&_mesh),
03155 start_(_mesh.halfedge_handle(_start)),
03156 heh_(start_),
03157 active_(false)
03158 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03159
03160
03162 FaceFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
03163 mesh_(&_mesh),
03164 start_(_heh),
03165 heh_(_heh),
03166 active_(false)
03167 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03168
03169
03171 FaceFaceIterT(const FaceFaceIterT& _rhs) :
03172 mesh_(_rhs.mesh_),
03173 start_(_rhs.start_),
03174 heh_(_rhs.heh_),
03175 active_(_rhs.active_)
03176 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03177
03178
03180 FaceFaceIterT& operator=(const FaceFaceIterT<Mesh>& _rhs)
03181 {
03182 mesh_ = _rhs.mesh_;
03183 start_ = _rhs.start_;
03184 heh_ = _rhs.heh_;
03185 active_ = _rhs.active_;
03186 return *this;
03187 }
03188
03189
03190 #if 0
03191
03192 FaceFaceIterT(const FaceFaceIterT<Mesh>& _rhs) :
03193 mesh_(_rhs.mesh_),
03194 start_(_rhs.start_),
03195 heh_(_rhs.heh_),
03196 active_(_rhs.active_)
03197 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03198
03199
03201 FaceFaceIterT& operator=(const FaceFaceIterT<Mesh>& _rhs)
03202 {
03203 mesh_ = _rhs.mesh_;
03204 start_ = _rhs.start_;
03205 heh_ = _rhs.heh_;
03206 active_ = _rhs.active_;
03207 return *this;
03208 }
03209 #else
03210 friend class ConstFaceFaceIterT<Mesh>;
03211 #endif
03212
03213
03215 bool operator==(const FaceFaceIterT& _rhs) const {
03216 return ((mesh_ == _rhs.mesh_) &&
03217 (start_ == _rhs.start_) &&
03218 (heh_ == _rhs.heh_) &&
03219 (active_ == _rhs.active_));
03220 }
03221
03222
03224 bool operator!=(const FaceFaceIterT& _rhs) const {
03225 return !operator==(_rhs);
03226 }
03227
03228
03230 FaceFaceIterT& operator++() {
03231 assert(mesh_);
03232 active_ = true;
03233 do heh_=mesh_->next_halfedge_handle(heh_); while ((*this) && (!handle().is_valid()));;
03234 return *this;
03235 }
03236
03237
03239 FaceFaceIterT& operator--() {
03240 assert(mesh_);
03241 active_ = true;
03242 do heh_=mesh_->prev_halfedge_handle(heh_); while ((*this) && (!handle().is_valid()));;
03243 return *this;
03244 }
03245
03246
03251 HalfedgeHandle current_halfedge_handle() const {
03252 return heh_;
03253 }
03254
03255
03257 typename Mesh::FaceHandle handle() const {
03258 assert(mesh_);
03259 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
03260 }
03261
03262
03264 operator typename Mesh::FaceHandle() const {
03265 assert(mesh_);
03266 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
03267 }
03268
03269
03271 reference operator*() const {
03272 assert(mesh_);
03273 return mesh_->deref(handle());
03274 }
03275
03276
03278 pointer operator->() const {
03279 assert(mesh_);
03280 return &mesh_->deref(handle());
03281 }
03282
03283
03290 operator bool() const {
03291 return heh_.is_valid() && ((start_ != heh_) || (!active_));
03292 }
03293
03294
03295 private:
03296
03297 mesh_ptr mesh_;
03298 HalfedgeHandle start_, heh_;
03299 bool active_;
03300 };
03301
03302
03303
03304
03305
03306
03311 template <class Mesh>
03312 class ConstFaceFaceIterT
03313 {
03314 public:
03315
03316
03317
03318
03319 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
03320
03321 typedef typename Mesh::Face value_type;
03322 typedef typename Mesh::FaceHandle value_handle;
03323
03324 #if 1
03325 typedef const Mesh& mesh_ref;
03326 typedef const Mesh* mesh_ptr;
03327 typedef const typename Mesh::Face& reference;
03328 typedef const typename Mesh::Face* pointer;
03329 #else
03330 typedef Mesh& mesh_ref;
03331 typedef Mesh* mesh_ptr;
03332 typedef typename Mesh::Face& reference;
03333 typedef typename Mesh::Face* pointer;
03334 #endif
03335
03336
03337
03339 ConstFaceFaceIterT() : mesh_(0), active_(false) {}
03340
03341
03343 ConstFaceFaceIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start) :
03344 mesh_(&_mesh),
03345 start_(_mesh.halfedge_handle(_start)),
03346 heh_(start_),
03347 active_(false)
03348 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03349
03350
03352 ConstFaceFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh) :
03353 mesh_(&_mesh),
03354 start_(_heh),
03355 heh_(_heh),
03356 active_(false)
03357 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03358
03359
03361 ConstFaceFaceIterT(const ConstFaceFaceIterT& _rhs) :
03362 mesh_(_rhs.mesh_),
03363 start_(_rhs.start_),
03364 heh_(_rhs.heh_),
03365 active_(_rhs.active_)
03366 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03367
03368
03370 ConstFaceFaceIterT& operator=(const ConstFaceFaceIterT<Mesh>& _rhs)
03371 {
03372 mesh_ = _rhs.mesh_;
03373 start_ = _rhs.start_;
03374 heh_ = _rhs.heh_;
03375 active_ = _rhs.active_;
03376 return *this;
03377 }
03378
03379
03380 #if 1
03381
03382 ConstFaceFaceIterT(const FaceFaceIterT<Mesh>& _rhs) :
03383 mesh_(_rhs.mesh_),
03384 start_(_rhs.start_),
03385 heh_(_rhs.heh_),
03386 active_(_rhs.active_)
03387 { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
03388
03389
03391 ConstFaceFaceIterT& operator=(const FaceFaceIterT<Mesh>& _rhs)
03392 {
03393 mesh_ = _rhs.mesh_;
03394 start_ = _rhs.start_;
03395 heh_ = _rhs.heh_;
03396 active_ = _rhs.active_;
03397 return *this;
03398 }
03399 #else
03400 friend class ConstFaceFaceIterT<Mesh>;
03401 #endif
03402
03403
03405 bool operator==(const ConstFaceFaceIterT& _rhs) const {
03406 return ((mesh_ == _rhs.mesh_) &&
03407 (start_ == _rhs.start_) &&
03408 (heh_ == _rhs.heh_) &&
03409 (active_ == _rhs.active_));
03410 }
03411
03412
03414 bool operator!=(const ConstFaceFaceIterT& _rhs) const {
03415 return !operator==(_rhs);
03416 }
03417
03418
03420 ConstFaceFaceIterT& operator++() {
03421 assert(mesh_);
03422 active_ = true;
03423 do heh_=mesh_->next_halfedge_handle(heh_); while ((*this) && (!handle().is_valid()));;
03424 return *this;
03425 }
03426
03427
03429 ConstFaceFaceIterT& operator--() {
03430 assert(mesh_);
03431 active_ = true;
03432 do heh_=mesh_->prev_halfedge_handle(heh_); while ((*this) && (!handle().is_valid()));;
03433 return *this;
03434 }
03435
03436
03441 HalfedgeHandle current_halfedge_handle() const {
03442 return heh_;
03443 }
03444
03445
03447 typename Mesh::FaceHandle handle() const {
03448 assert(mesh_);
03449 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
03450 }
03451
03452
03454 operator typename Mesh::FaceHandle() const {
03455 assert(mesh_);
03456 return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
03457 }
03458
03459
03461 reference operator*() const {
03462 assert(mesh_);
03463 return mesh_->deref(handle());
03464 }
03465
03466
03468 pointer operator->() const {
03469 assert(mesh_);
03470 return &mesh_->deref(handle());
03471 }
03472
03473
03480 operator bool() const {
03481 return heh_.is_valid() && ((start_ != heh_) || (!active_));
03482 }
03483
03484
03485 private:
03486
03487 mesh_ptr mesh_;
03488 HalfedgeHandle start_, heh_;
03489 bool active_;
03490 };
03491
03492
03493
03494
03495 }
03496 }
03497
03498 #endif
03499