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_ITERATORS_HH
00026 #define OPENMESH_ITERATORS_HH
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037 #include <OpenMesh/Core/System/config.hh>
00038 #include <OpenMesh/Core/Attributes/Status.hh>
00039 #include <assert.h>
00040
00041
00042
00043
00044 namespace OpenMesh {
00045 namespace Iterators {
00046
00047
00048
00049
00050
00051 template <class Mesh> class VertexIterT;
00052 template <class Mesh> class ConstVertexIterT;
00053 template <class Mesh> class HalfedgeIterT;
00054 template <class Mesh> class ConstHalfedgeIterT;
00055 template <class Mesh> class EdgeIterT;
00056 template <class Mesh> class ConstEdgeIterT;
00057 template <class Mesh> class FaceIterT;
00058 template <class Mesh> class ConstFaceIterT;
00059
00060
00061
00062
00063
00064
00065
00070 template <class Mesh>
00071 class VertexIterT
00072 {
00073 public:
00074
00075
00076
00077
00078 typedef typename Mesh::Vertex value_type;
00079 typedef typename Mesh::VertexHandle value_handle;
00080
00081 #if 0
00082 typedef const value_type& reference;
00083 typedef const value_type* pointer;
00084 typedef const Mesh* mesh_ptr;
00085 typedef const Mesh& mesh_ref;
00086 #else
00087 typedef value_type& reference;
00088 typedef value_type* pointer;
00089 typedef Mesh* mesh_ptr;
00090 typedef Mesh& mesh_ref;
00091 #endif
00092
00093
00094
00095
00097 VertexIterT()
00098 : mesh_(0), skip_bits_(0)
00099 {}
00100
00101
00103 VertexIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false)
00104 : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0)
00105 {
00106 if (_skip) enable_skipping();
00107 }
00108
00109
00111 VertexIterT(const VertexIterT& _rhs)
00112 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00113 {}
00114
00115
00117 VertexIterT& operator=(const VertexIterT<Mesh>& _rhs)
00118 {
00119 mesh_ = _rhs.mesh_;
00120 hnd_ = _rhs.hnd_;
00121 skip_bits_ = _rhs.skip_bits_;
00122 return *this;
00123 }
00124
00125
00126 #if 0
00127
00129 VertexIterT(const VertexIterT<Mesh>& _rhs)
00130 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00131 {}
00132
00133
00135 VertexIterT& operator=(const VertexIterT<Mesh>& _rhs)
00136 {
00137 mesh_ = _rhs.mesh_;
00138 hnd_ = _rhs.hnd_;
00139 skip_bits_ = _rhs.skip_bits_;
00140 return *this;
00141 }
00142
00143 #else
00144 friend class ConstVertexIterT<Mesh>;
00145 #endif
00146
00147
00149 reference operator*() const { return mesh_->deref(hnd_); }
00150
00152 pointer operator->() const { return &(mesh_->deref(hnd_)); }
00153
00155 value_handle handle() const { return hnd_; }
00156
00158 operator value_handle() const { return hnd_; }
00159
00161 bool operator==(const VertexIterT& _rhs) const
00162 { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
00163
00165 bool operator!=(const VertexIterT& _rhs) const
00166 { return !operator==(_rhs); }
00167
00169 VertexIterT& operator++()
00170 { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
00171
00173 VertexIterT& operator--()
00174 { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
00175
00176
00178 void enable_skipping()
00179 {
00180 if (mesh_ && mesh_->has_vertex_status())
00181 {
00182 Attributes::StatusInfo status;
00183 status.set_deleted(true);
00184 status.set_hidden(true);
00185 skip_bits_ = status.bits();
00186 skip_fwd();
00187 }
00188 else skip_bits_ = 0;
00189 }
00190
00191
00193 void disable_skipping() { skip_bits_ = 0; }
00194
00195
00196
00197 private:
00198
00199 void skip_fwd()
00200 {
00201 assert(mesh_ && skip_bits_);
00202 while ((hnd_.idx() < (signed) mesh_->n_vertices()) &&
00203 (mesh_->status(hnd_).bits() & skip_bits_))
00204 hnd_.__increment();
00205 }
00206
00207
00208 void skip_bwd()
00209 {
00210 assert(mesh_ && skip_bits_);
00211 while ((hnd_.idx() >= 0) &&
00212 (mesh_->status(hnd_).bits() & skip_bits_))
00213 hnd_.__decrement();
00214 }
00215
00216
00217
00218 private:
00219 mesh_ptr mesh_;
00220 value_handle hnd_;
00221 unsigned int skip_bits_;
00222 };
00223
00224
00225
00226
00227
00232 template <class Mesh>
00233 class ConstVertexIterT
00234 {
00235 public:
00236
00237
00238
00239
00240 typedef typename Mesh::Vertex value_type;
00241 typedef typename Mesh::VertexHandle value_handle;
00242
00243 #if 1
00244 typedef const value_type& reference;
00245 typedef const value_type* pointer;
00246 typedef const Mesh* mesh_ptr;
00247 typedef const Mesh& mesh_ref;
00248 #else
00249 typedef value_type& reference;
00250 typedef value_type* pointer;
00251 typedef Mesh* mesh_ptr;
00252 typedef Mesh& mesh_ref;
00253 #endif
00254
00255
00256
00257
00259 ConstVertexIterT()
00260 : mesh_(0), skip_bits_(0)
00261 {}
00262
00263
00265 ConstVertexIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false)
00266 : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0)
00267 {
00268 if (_skip) enable_skipping();
00269 }
00270
00271
00273 ConstVertexIterT(const ConstVertexIterT& _rhs)
00274 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00275 {}
00276
00277
00279 ConstVertexIterT& operator=(const ConstVertexIterT<Mesh>& _rhs)
00280 {
00281 mesh_ = _rhs.mesh_;
00282 hnd_ = _rhs.hnd_;
00283 skip_bits_ = _rhs.skip_bits_;
00284 return *this;
00285 }
00286
00287
00288 #if 1
00289
00291 ConstVertexIterT(const VertexIterT<Mesh>& _rhs)
00292 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00293 {}
00294
00295
00297 ConstVertexIterT& operator=(const VertexIterT<Mesh>& _rhs)
00298 {
00299 mesh_ = _rhs.mesh_;
00300 hnd_ = _rhs.hnd_;
00301 skip_bits_ = _rhs.skip_bits_;
00302 return *this;
00303 }
00304
00305 #else
00306 friend class ConstVertexIterT<Mesh>;
00307 #endif
00308
00309
00311 reference operator*() const { return mesh_->deref(hnd_); }
00312
00314 pointer operator->() const { return &(mesh_->deref(hnd_)); }
00315
00317 value_handle handle() const { return hnd_; }
00318
00320 operator value_handle() const { return hnd_; }
00321
00323 bool operator==(const ConstVertexIterT& _rhs) const
00324 { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
00325
00327 bool operator!=(const ConstVertexIterT& _rhs) const
00328 { return !operator==(_rhs); }
00329
00331 ConstVertexIterT& operator++()
00332 { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
00333
00335 ConstVertexIterT& operator--()
00336 { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
00337
00338
00340 void enable_skipping()
00341 {
00342 if (mesh_ && mesh_->has_vertex_status())
00343 {
00344 Attributes::StatusInfo status;
00345 status.set_deleted(true);
00346 status.set_hidden(true);
00347 skip_bits_ = status.bits();
00348 skip_fwd();
00349 }
00350 else skip_bits_ = 0;
00351 }
00352
00353
00355 void disable_skipping() { skip_bits_ = 0; }
00356
00357
00358
00359 private:
00360
00361 void skip_fwd()
00362 {
00363 assert(mesh_ && skip_bits_);
00364 while ((hnd_.idx() < (signed) mesh_->n_vertices()) &&
00365 (mesh_->status(hnd_).bits() & skip_bits_))
00366 hnd_.__increment();
00367 }
00368
00369
00370 void skip_bwd()
00371 {
00372 assert(mesh_ && skip_bits_);
00373 while ((hnd_.idx() >= 0) &&
00374 (mesh_->status(hnd_).bits() & skip_bits_))
00375 hnd_.__decrement();
00376 }
00377
00378
00379
00380 private:
00381 mesh_ptr mesh_;
00382 value_handle hnd_;
00383 unsigned int skip_bits_;
00384 };
00385
00386
00387
00388
00389
00394 template <class Mesh>
00395 class HalfedgeIterT
00396 {
00397 public:
00398
00399
00400
00401
00402 typedef typename Mesh::Halfedge value_type;
00403 typedef typename Mesh::HalfedgeHandle value_handle;
00404
00405 #if 0
00406 typedef const value_type& reference;
00407 typedef const value_type* pointer;
00408 typedef const Mesh* mesh_ptr;
00409 typedef const Mesh& mesh_ref;
00410 #else
00411 typedef value_type& reference;
00412 typedef value_type* pointer;
00413 typedef Mesh* mesh_ptr;
00414 typedef Mesh& mesh_ref;
00415 #endif
00416
00417
00418
00419
00421 HalfedgeIterT()
00422 : mesh_(0), skip_bits_(0)
00423 {}
00424
00425
00427 HalfedgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false)
00428 : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0)
00429 {
00430 if (_skip) enable_skipping();
00431 }
00432
00433
00435 HalfedgeIterT(const HalfedgeIterT& _rhs)
00436 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00437 {}
00438
00439
00441 HalfedgeIterT& operator=(const HalfedgeIterT<Mesh>& _rhs)
00442 {
00443 mesh_ = _rhs.mesh_;
00444 hnd_ = _rhs.hnd_;
00445 skip_bits_ = _rhs.skip_bits_;
00446 return *this;
00447 }
00448
00449
00450 #if 0
00451
00453 HalfedgeIterT(const HalfedgeIterT<Mesh>& _rhs)
00454 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00455 {}
00456
00457
00459 HalfedgeIterT& operator=(const HalfedgeIterT<Mesh>& _rhs)
00460 {
00461 mesh_ = _rhs.mesh_;
00462 hnd_ = _rhs.hnd_;
00463 skip_bits_ = _rhs.skip_bits_;
00464 return *this;
00465 }
00466
00467 #else
00468 friend class ConstHalfedgeIterT<Mesh>;
00469 #endif
00470
00471
00473 reference operator*() const { return mesh_->deref(hnd_); }
00474
00476 pointer operator->() const { return &(mesh_->deref(hnd_)); }
00477
00479 value_handle handle() const { return hnd_; }
00480
00482 operator value_handle() const { return hnd_; }
00483
00485 bool operator==(const HalfedgeIterT& _rhs) const
00486 { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
00487
00489 bool operator!=(const HalfedgeIterT& _rhs) const
00490 { return !operator==(_rhs); }
00491
00493 HalfedgeIterT& operator++()
00494 { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
00495
00497 HalfedgeIterT& operator--()
00498 { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
00499
00500
00502 void enable_skipping()
00503 {
00504 if (mesh_ && mesh_->has_halfedge_status())
00505 {
00506 Attributes::StatusInfo status;
00507 status.set_deleted(true);
00508 status.set_hidden(true);
00509 skip_bits_ = status.bits();
00510 skip_fwd();
00511 }
00512 else skip_bits_ = 0;
00513 }
00514
00515
00517 void disable_skipping() { skip_bits_ = 0; }
00518
00519
00520
00521 private:
00522
00523 void skip_fwd()
00524 {
00525 assert(mesh_ && skip_bits_);
00526 while ((hnd_.idx() < (signed) mesh_->n_halfedges()) &&
00527 (mesh_->status(hnd_).bits() & skip_bits_))
00528 hnd_.__increment();
00529 }
00530
00531
00532 void skip_bwd()
00533 {
00534 assert(mesh_ && skip_bits_);
00535 while ((hnd_.idx() >= 0) &&
00536 (mesh_->status(hnd_).bits() & skip_bits_))
00537 hnd_.__decrement();
00538 }
00539
00540
00541
00542 private:
00543 mesh_ptr mesh_;
00544 value_handle hnd_;
00545 unsigned int skip_bits_;
00546 };
00547
00548
00549
00550
00551
00556 template <class Mesh>
00557 class ConstHalfedgeIterT
00558 {
00559 public:
00560
00561
00562
00563
00564 typedef typename Mesh::Halfedge value_type;
00565 typedef typename Mesh::HalfedgeHandle value_handle;
00566
00567 #if 1
00568 typedef const value_type& reference;
00569 typedef const value_type* pointer;
00570 typedef const Mesh* mesh_ptr;
00571 typedef const Mesh& mesh_ref;
00572 #else
00573 typedef value_type& reference;
00574 typedef value_type* pointer;
00575 typedef Mesh* mesh_ptr;
00576 typedef Mesh& mesh_ref;
00577 #endif
00578
00579
00580
00581
00583 ConstHalfedgeIterT()
00584 : mesh_(0), skip_bits_(0)
00585 {}
00586
00587
00589 ConstHalfedgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false)
00590 : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0)
00591 {
00592 if (_skip) enable_skipping();
00593 }
00594
00595
00597 ConstHalfedgeIterT(const ConstHalfedgeIterT& _rhs)
00598 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00599 {}
00600
00601
00603 ConstHalfedgeIterT& operator=(const ConstHalfedgeIterT<Mesh>& _rhs)
00604 {
00605 mesh_ = _rhs.mesh_;
00606 hnd_ = _rhs.hnd_;
00607 skip_bits_ = _rhs.skip_bits_;
00608 return *this;
00609 }
00610
00611
00612 #if 1
00613
00615 ConstHalfedgeIterT(const HalfedgeIterT<Mesh>& _rhs)
00616 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00617 {}
00618
00619
00621 ConstHalfedgeIterT& operator=(const HalfedgeIterT<Mesh>& _rhs)
00622 {
00623 mesh_ = _rhs.mesh_;
00624 hnd_ = _rhs.hnd_;
00625 skip_bits_ = _rhs.skip_bits_;
00626 return *this;
00627 }
00628
00629 #else
00630 friend class ConstHalfedgeIterT<Mesh>;
00631 #endif
00632
00633
00635 reference operator*() const { return mesh_->deref(hnd_); }
00636
00638 pointer operator->() const { return &(mesh_->deref(hnd_)); }
00639
00641 value_handle handle() const { return hnd_; }
00642
00644 operator value_handle() const { return hnd_; }
00645
00647 bool operator==(const ConstHalfedgeIterT& _rhs) const
00648 { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
00649
00651 bool operator!=(const ConstHalfedgeIterT& _rhs) const
00652 { return !operator==(_rhs); }
00653
00655 ConstHalfedgeIterT& operator++()
00656 { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
00657
00659 ConstHalfedgeIterT& operator--()
00660 { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
00661
00662
00664 void enable_skipping()
00665 {
00666 if (mesh_ && mesh_->has_halfedge_status())
00667 {
00668 Attributes::StatusInfo status;
00669 status.set_deleted(true);
00670 status.set_hidden(true);
00671 skip_bits_ = status.bits();
00672 skip_fwd();
00673 }
00674 else skip_bits_ = 0;
00675 }
00676
00677
00679 void disable_skipping() { skip_bits_ = 0; }
00680
00681
00682
00683 private:
00684
00685 void skip_fwd()
00686 {
00687 assert(mesh_ && skip_bits_);
00688 while ((hnd_.idx() < (signed) mesh_->n_halfedges()) &&
00689 (mesh_->status(hnd_).bits() & skip_bits_))
00690 hnd_.__increment();
00691 }
00692
00693
00694 void skip_bwd()
00695 {
00696 assert(mesh_ && skip_bits_);
00697 while ((hnd_.idx() >= 0) &&
00698 (mesh_->status(hnd_).bits() & skip_bits_))
00699 hnd_.__decrement();
00700 }
00701
00702
00703
00704 private:
00705 mesh_ptr mesh_;
00706 value_handle hnd_;
00707 unsigned int skip_bits_;
00708 };
00709
00710
00711
00712
00713
00718 template <class Mesh>
00719 class EdgeIterT
00720 {
00721 public:
00722
00723
00724
00725
00726 typedef typename Mesh::Edge value_type;
00727 typedef typename Mesh::EdgeHandle value_handle;
00728
00729 #if 0
00730 typedef const value_type& reference;
00731 typedef const value_type* pointer;
00732 typedef const Mesh* mesh_ptr;
00733 typedef const Mesh& mesh_ref;
00734 #else
00735 typedef value_type& reference;
00736 typedef value_type* pointer;
00737 typedef Mesh* mesh_ptr;
00738 typedef Mesh& mesh_ref;
00739 #endif
00740
00741
00742
00743
00745 EdgeIterT()
00746 : mesh_(0), skip_bits_(0)
00747 {}
00748
00749
00751 EdgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false)
00752 : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0)
00753 {
00754 if (_skip) enable_skipping();
00755 }
00756
00757
00759 EdgeIterT(const EdgeIterT& _rhs)
00760 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00761 {}
00762
00763
00765 EdgeIterT& operator=(const EdgeIterT<Mesh>& _rhs)
00766 {
00767 mesh_ = _rhs.mesh_;
00768 hnd_ = _rhs.hnd_;
00769 skip_bits_ = _rhs.skip_bits_;
00770 return *this;
00771 }
00772
00773
00774 #if 0
00775
00777 EdgeIterT(const EdgeIterT<Mesh>& _rhs)
00778 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00779 {}
00780
00781
00783 EdgeIterT& operator=(const EdgeIterT<Mesh>& _rhs)
00784 {
00785 mesh_ = _rhs.mesh_;
00786 hnd_ = _rhs.hnd_;
00787 skip_bits_ = _rhs.skip_bits_;
00788 return *this;
00789 }
00790
00791 #else
00792 friend class ConstEdgeIterT<Mesh>;
00793 #endif
00794
00795
00797 reference operator*() const { return mesh_->deref(hnd_); }
00798
00800 pointer operator->() const { return &(mesh_->deref(hnd_)); }
00801
00803 value_handle handle() const { return hnd_; }
00804
00806 operator value_handle() const { return hnd_; }
00807
00809 bool operator==(const EdgeIterT& _rhs) const
00810 { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
00811
00813 bool operator!=(const EdgeIterT& _rhs) const
00814 { return !operator==(_rhs); }
00815
00817 EdgeIterT& operator++()
00818 { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
00819
00821 EdgeIterT& operator--()
00822 { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
00823
00824
00826 void enable_skipping()
00827 {
00828 if (mesh_ && mesh_->has_edge_status())
00829 {
00830 Attributes::StatusInfo status;
00831 status.set_deleted(true);
00832 status.set_hidden(true);
00833 skip_bits_ = status.bits();
00834 skip_fwd();
00835 }
00836 else skip_bits_ = 0;
00837 }
00838
00839
00841 void disable_skipping() { skip_bits_ = 0; }
00842
00843
00844
00845 private:
00846
00847 void skip_fwd()
00848 {
00849 assert(mesh_ && skip_bits_);
00850 while ((hnd_.idx() < (signed) mesh_->n_edges()) &&
00851 (mesh_->status(hnd_).bits() & skip_bits_))
00852 hnd_.__increment();
00853 }
00854
00855
00856 void skip_bwd()
00857 {
00858 assert(mesh_ && skip_bits_);
00859 while ((hnd_.idx() >= 0) &&
00860 (mesh_->status(hnd_).bits() & skip_bits_))
00861 hnd_.__decrement();
00862 }
00863
00864
00865
00866 private:
00867 mesh_ptr mesh_;
00868 value_handle hnd_;
00869 unsigned int skip_bits_;
00870 };
00871
00872
00873
00874
00875
00880 template <class Mesh>
00881 class ConstEdgeIterT
00882 {
00883 public:
00884
00885
00886
00887
00888 typedef typename Mesh::Edge value_type;
00889 typedef typename Mesh::EdgeHandle value_handle;
00890
00891 #if 1
00892 typedef const value_type& reference;
00893 typedef const value_type* pointer;
00894 typedef const Mesh* mesh_ptr;
00895 typedef const Mesh& mesh_ref;
00896 #else
00897 typedef value_type& reference;
00898 typedef value_type* pointer;
00899 typedef Mesh* mesh_ptr;
00900 typedef Mesh& mesh_ref;
00901 #endif
00902
00903
00904
00905
00907 ConstEdgeIterT()
00908 : mesh_(0), skip_bits_(0)
00909 {}
00910
00911
00913 ConstEdgeIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false)
00914 : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0)
00915 {
00916 if (_skip) enable_skipping();
00917 }
00918
00919
00921 ConstEdgeIterT(const ConstEdgeIterT& _rhs)
00922 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00923 {}
00924
00925
00927 ConstEdgeIterT& operator=(const ConstEdgeIterT<Mesh>& _rhs)
00928 {
00929 mesh_ = _rhs.mesh_;
00930 hnd_ = _rhs.hnd_;
00931 skip_bits_ = _rhs.skip_bits_;
00932 return *this;
00933 }
00934
00935
00936 #if 1
00937
00939 ConstEdgeIterT(const EdgeIterT<Mesh>& _rhs)
00940 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
00941 {}
00942
00943
00945 ConstEdgeIterT& operator=(const EdgeIterT<Mesh>& _rhs)
00946 {
00947 mesh_ = _rhs.mesh_;
00948 hnd_ = _rhs.hnd_;
00949 skip_bits_ = _rhs.skip_bits_;
00950 return *this;
00951 }
00952
00953 #else
00954 friend class ConstEdgeIterT<Mesh>;
00955 #endif
00956
00957
00959 reference operator*() const { return mesh_->deref(hnd_); }
00960
00962 pointer operator->() const { return &(mesh_->deref(hnd_)); }
00963
00965 value_handle handle() const { return hnd_; }
00966
00968 operator value_handle() const { return hnd_; }
00969
00971 bool operator==(const ConstEdgeIterT& _rhs) const
00972 { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
00973
00975 bool operator!=(const ConstEdgeIterT& _rhs) const
00976 { return !operator==(_rhs); }
00977
00979 ConstEdgeIterT& operator++()
00980 { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
00981
00983 ConstEdgeIterT& operator--()
00984 { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
00985
00986
00988 void enable_skipping()
00989 {
00990 if (mesh_ && mesh_->has_edge_status())
00991 {
00992 Attributes::StatusInfo status;
00993 status.set_deleted(true);
00994 status.set_hidden(true);
00995 skip_bits_ = status.bits();
00996 skip_fwd();
00997 }
00998 else skip_bits_ = 0;
00999 }
01000
01001
01003 void disable_skipping() { skip_bits_ = 0; }
01004
01005
01006
01007 private:
01008
01009 void skip_fwd()
01010 {
01011 assert(mesh_ && skip_bits_);
01012 while ((hnd_.idx() < (signed) mesh_->n_edges()) &&
01013 (mesh_->status(hnd_).bits() & skip_bits_))
01014 hnd_.__increment();
01015 }
01016
01017
01018 void skip_bwd()
01019 {
01020 assert(mesh_ && skip_bits_);
01021 while ((hnd_.idx() >= 0) &&
01022 (mesh_->status(hnd_).bits() & skip_bits_))
01023 hnd_.__decrement();
01024 }
01025
01026
01027
01028 private:
01029 mesh_ptr mesh_;
01030 value_handle hnd_;
01031 unsigned int skip_bits_;
01032 };
01033
01034
01035
01036
01037
01042 template <class Mesh>
01043 class FaceIterT
01044 {
01045 public:
01046
01047
01048
01049
01050 typedef typename Mesh::Face value_type;
01051 typedef typename Mesh::FaceHandle value_handle;
01052
01053 #if 0
01054 typedef const value_type& reference;
01055 typedef const value_type* pointer;
01056 typedef const Mesh* mesh_ptr;
01057 typedef const Mesh& mesh_ref;
01058 #else
01059 typedef value_type& reference;
01060 typedef value_type* pointer;
01061 typedef Mesh* mesh_ptr;
01062 typedef Mesh& mesh_ref;
01063 #endif
01064
01065
01066
01067
01069 FaceIterT()
01070 : mesh_(0), skip_bits_(0)
01071 {}
01072
01073
01075 FaceIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false)
01076 : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0)
01077 {
01078 if (_skip) enable_skipping();
01079 }
01080
01081
01083 FaceIterT(const FaceIterT& _rhs)
01084 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
01085 {}
01086
01087
01089 FaceIterT& operator=(const FaceIterT<Mesh>& _rhs)
01090 {
01091 mesh_ = _rhs.mesh_;
01092 hnd_ = _rhs.hnd_;
01093 skip_bits_ = _rhs.skip_bits_;
01094 return *this;
01095 }
01096
01097
01098 #if 0
01099
01101 FaceIterT(const FaceIterT<Mesh>& _rhs)
01102 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
01103 {}
01104
01105
01107 FaceIterT& operator=(const FaceIterT<Mesh>& _rhs)
01108 {
01109 mesh_ = _rhs.mesh_;
01110 hnd_ = _rhs.hnd_;
01111 skip_bits_ = _rhs.skip_bits_;
01112 return *this;
01113 }
01114
01115 #else
01116 friend class ConstFaceIterT<Mesh>;
01117 #endif
01118
01119
01121 reference operator*() const { return mesh_->deref(hnd_); }
01122
01124 pointer operator->() const { return &(mesh_->deref(hnd_)); }
01125
01127 value_handle handle() const { return hnd_; }
01128
01130 operator value_handle() const { return hnd_; }
01131
01133 bool operator==(const FaceIterT& _rhs) const
01134 { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
01135
01137 bool operator!=(const FaceIterT& _rhs) const
01138 { return !operator==(_rhs); }
01139
01141 FaceIterT& operator++()
01142 { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
01143
01145 FaceIterT& operator--()
01146 { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
01147
01148
01150 void enable_skipping()
01151 {
01152 if (mesh_ && mesh_->has_face_status())
01153 {
01154 Attributes::StatusInfo status;
01155 status.set_deleted(true);
01156 status.set_hidden(true);
01157 skip_bits_ = status.bits();
01158 skip_fwd();
01159 }
01160 else skip_bits_ = 0;
01161 }
01162
01163
01165 void disable_skipping() { skip_bits_ = 0; }
01166
01167
01168
01169 private:
01170
01171 void skip_fwd()
01172 {
01173 assert(mesh_ && skip_bits_);
01174 while ((hnd_.idx() < (signed) mesh_->n_faces()) &&
01175 (mesh_->status(hnd_).bits() & skip_bits_))
01176 hnd_.__increment();
01177 }
01178
01179
01180 void skip_bwd()
01181 {
01182 assert(mesh_ && skip_bits_);
01183 while ((hnd_.idx() >= 0) &&
01184 (mesh_->status(hnd_).bits() & skip_bits_))
01185 hnd_.__decrement();
01186 }
01187
01188
01189
01190 private:
01191 mesh_ptr mesh_;
01192 value_handle hnd_;
01193 unsigned int skip_bits_;
01194 };
01195
01196
01197
01198
01199
01204 template <class Mesh>
01205 class ConstFaceIterT
01206 {
01207 public:
01208
01209
01210
01211
01212 typedef typename Mesh::Face value_type;
01213 typedef typename Mesh::FaceHandle value_handle;
01214
01215 #if 1
01216 typedef const value_type& reference;
01217 typedef const value_type* pointer;
01218 typedef const Mesh* mesh_ptr;
01219 typedef const Mesh& mesh_ref;
01220 #else
01221 typedef value_type& reference;
01222 typedef value_type* pointer;
01223 typedef Mesh* mesh_ptr;
01224 typedef Mesh& mesh_ref;
01225 #endif
01226
01227
01228
01229
01231 ConstFaceIterT()
01232 : mesh_(0), skip_bits_(0)
01233 {}
01234
01235
01237 ConstFaceIterT(mesh_ref _mesh, value_handle _hnd, bool _skip=false)
01238 : mesh_(&_mesh), hnd_(_hnd), skip_bits_(0)
01239 {
01240 if (_skip) enable_skipping();
01241 }
01242
01243
01245 ConstFaceIterT(const ConstFaceIterT& _rhs)
01246 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
01247 {}
01248
01249
01251 ConstFaceIterT& operator=(const ConstFaceIterT<Mesh>& _rhs)
01252 {
01253 mesh_ = _rhs.mesh_;
01254 hnd_ = _rhs.hnd_;
01255 skip_bits_ = _rhs.skip_bits_;
01256 return *this;
01257 }
01258
01259
01260 #if 1
01261
01263 ConstFaceIterT(const FaceIterT<Mesh>& _rhs)
01264 : mesh_(_rhs.mesh_), hnd_(_rhs.hnd_), skip_bits_(_rhs.skip_bits_)
01265 {}
01266
01267
01269 ConstFaceIterT& operator=(const FaceIterT<Mesh>& _rhs)
01270 {
01271 mesh_ = _rhs.mesh_;
01272 hnd_ = _rhs.hnd_;
01273 skip_bits_ = _rhs.skip_bits_;
01274 return *this;
01275 }
01276
01277 #else
01278 friend class ConstFaceIterT<Mesh>;
01279 #endif
01280
01281
01283 reference operator*() const { return mesh_->deref(hnd_); }
01284
01286 pointer operator->() const { return &(mesh_->deref(hnd_)); }
01287
01289 value_handle handle() const { return hnd_; }
01290
01292 operator value_handle() const { return hnd_; }
01293
01295 bool operator==(const ConstFaceIterT& _rhs) const
01296 { return ((mesh_ == _rhs.mesh_) && (hnd_ == _rhs.hnd_)); }
01297
01299 bool operator!=(const ConstFaceIterT& _rhs) const
01300 { return !operator==(_rhs); }
01301
01303 ConstFaceIterT& operator++()
01304 { hnd_.__increment(); if (skip_bits_) skip_fwd(); return *this; }
01305
01307 ConstFaceIterT& operator--()
01308 { hnd_.__decrement(); if (skip_bits_) skip_bwd(); return *this; }
01309
01310
01312 void enable_skipping()
01313 {
01314 if (mesh_ && mesh_->has_face_status())
01315 {
01316 Attributes::StatusInfo status;
01317 status.set_deleted(true);
01318 status.set_hidden(true);
01319 skip_bits_ = status.bits();
01320 skip_fwd();
01321 }
01322 else skip_bits_ = 0;
01323 }
01324
01325
01327 void disable_skipping() { skip_bits_ = 0; }
01328
01329
01330
01331 private:
01332
01333 void skip_fwd()
01334 {
01335 assert(mesh_ && skip_bits_);
01336 while ((hnd_.idx() < (signed) mesh_->n_faces()) &&
01337 (mesh_->status(hnd_).bits() & skip_bits_))
01338 hnd_.__increment();
01339 }
01340
01341
01342 void skip_bwd()
01343 {
01344 assert(mesh_ && skip_bits_);
01345 while ((hnd_.idx() >= 0) &&
01346 (mesh_->status(hnd_).bits() & skip_bits_))
01347 hnd_.__decrement();
01348 }
01349
01350
01351
01352 private:
01353 mesh_ptr mesh_;
01354 value_handle hnd_;
01355 unsigned int skip_bits_;
01356 };
01357
01358
01359
01360 }
01361 }
01362
01363 #endif
01364