OpenMesh
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
CirculatorsT.hh
1 /*===========================================================================*\
2  * *
3  * OpenMesh *
4  * Copyright (C) 2001-2012 by Computer Graphics Group, RWTH Aachen *
5  * www.openmesh.org *
6  * *
7  *---------------------------------------------------------------------------*
8  * This file is part of OpenMesh. *
9  * *
10  * OpenMesh is free software: you can redistribute it and/or modify *
11  * it under the terms of the GNU Lesser General Public License as *
12  * published by the Free Software Foundation, either version 3 of *
13  * the License, or (at your option) any later version with the *
14  * following exceptions: *
15  * *
16  * If other files instantiate templates or use macros *
17  * or inline functions from this file, or you compile this file and *
18  * link it with other files to produce an executable, this file does *
19  * not by itself cause the resulting executable to be covered by the *
20  * GNU Lesser General Public License. This exception does not however *
21  * invalidate any other reasons why the executable file might be *
22  * covered by the GNU Lesser General Public License. *
23  * *
24  * OpenMesh is distributed in the hope that it will be useful, *
25  * but WITHOUT ANY WARRANTY; without even the implied warranty of *
26  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
27  * GNU Lesser General Public License for more details. *
28  * *
29  * You should have received a copy of the GNU LesserGeneral Public *
30  * License along with OpenMesh. If not, *
31  * see <http://www.gnu.org/licenses/>. *
32  * *
33 \*===========================================================================*/
34 
35 /*===========================================================================*\
36  * *
37  * $Revision: 736 $ *
38  * $Date: 2012-10-08 09:30:49 +0200 (Mo, 08 Okt 2012) $ *
39  * *
40 \*===========================================================================*/
41 
42 #ifndef OPENMESH_CIRCULATORS_HH
43 #define OPENMESH_CIRCULATORS_HH
44 //=============================================================================
45 //
46 // Vertex and Face circulators for PolyMesh/TriMesh
47 //
48 //=============================================================================
49 
50 
51 
52 //== INCLUDES =================================================================
53 
54 #include <OpenMesh/Core/System/config.h>
55 #include <assert.h>
56 #include <cstddef>
57 
58 
59 //== NAMESPACES ===============================================================
60 
61 namespace OpenMesh {
62 namespace Iterators {
63 
64 
65 //== FORWARD DECLARATIONS =====================================================
66 
67 
68 template <class Mesh> class VertexVertexIterT;
69 template <class Mesh> class VertexIHalfedgeIterT;
70 template <class Mesh> class VertexOHalfedgeIterT;
71 template <class Mesh> class VertexEdgeIterT;
72 template <class Mesh> class VertexFaceIterT;
73 
74 template <class Mesh> class ConstVertexVertexIterT;
75 template <class Mesh> class ConstVertexIHalfedgeIterT;
76 template <class Mesh> class ConstVertexOHalfedgeIterT;
77 template <class Mesh> class ConstVertexEdgeIterT;
78 template <class Mesh> class ConstVertexFaceIterT;
79 
80 template <class Mesh> class FaceVertexIterT;
81 template <class Mesh> class FaceHalfedgeIterT;
82 template <class Mesh> class FaceEdgeIterT;
83 template <class Mesh> class FaceFaceIterT;
84 
85 template <class Mesh> class ConstFaceVertexIterT;
86 template <class Mesh> class ConstFaceHalfedgeIterT;
87 template <class Mesh> class ConstFaceEdgeIterT;
88 template <class Mesh> class ConstFaceFaceIterT;
89 
90 
91 
92 //== CLASS DEFINITION =========================================================
93 
94 
99 template <class Mesh>
101 {
102  public:
103 
104 
105  //--- Typedefs ---
106 
107  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
108 
109  typedef typename Mesh::Vertex value_type;
110  typedef typename Mesh::VertexHandle value_handle;
111 
112 #if 0
113  typedef std::bidirectional_iterator_tag iterator_category;
114  typedef std::ptrdiff_t difference_type;
115  typedef const Mesh& mesh_ref;
116  typedef const Mesh* mesh_ptr;
117  typedef const typename Mesh::Vertex& reference;
118  typedef const typename Mesh::Vertex* pointer;
119 #else
120  typedef std::bidirectional_iterator_tag iterator_category;
121  typedef std::ptrdiff_t difference_type;
122  typedef Mesh& mesh_ref;
123  typedef Mesh* mesh_ptr;
124  typedef typename Mesh::Vertex& reference;
125  typedef typename Mesh::Vertex* pointer;
126 #endif
127 
128 
129 
131  VertexVertexIterT() : mesh_(0), lap_counter_(0) {}
132 
133 
135  VertexVertexIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
136  mesh_(&_mesh),
137  start_(_mesh.halfedge_handle(_start)),
138  heh_(start_),
139  lap_counter_(_end)
140  { ; }
141 
142 
144  VertexVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
145  mesh_(&_mesh),
146  start_(_heh),
147  heh_(_heh),
148  lap_counter_(_end)
149  { ; }
150 
151 
154  mesh_(_rhs.mesh_),
155  start_(_rhs.start_),
156  heh_(_rhs.heh_),
157  lap_counter_(_rhs.lap_counter_)
158  { ; }
159 
160 
163  {
164  mesh_ = _rhs.mesh_;
165  start_ = _rhs.start_;
166  heh_ = _rhs.heh_;
167  lap_counter_ = _rhs.lap_counter_;
168  return *this;
169  }
170 
171 
172 #if 0
173 
175  mesh_(_rhs.mesh_),
176  start_(_rhs.start_),
177  heh_(_rhs.heh_),
178  lap_counter_(_rhs.lap_counter_)
179  { ; }
180 
181 
183  VertexVertexIterT& operator=(const VertexVertexIterT<Mesh>& _rhs)
184  {
185  mesh_ = _rhs.mesh_;
186  start_ = _rhs.start_;
187  heh_ = _rhs.heh_;
188  lap_counter_ = _rhs.lap_counter_;
189  return *this;
190  }
191 #else
192  friend class ConstVertexVertexIterT<Mesh>;
193 #endif
194 
195 
197  bool operator==(const VertexVertexIterT& _rhs) const {
198  return ((mesh_ == _rhs.mesh_) &&
199  (start_ == _rhs.start_) &&
200  (heh_ == _rhs.heh_) &&
201  (lap_counter_ == _rhs.lap_counter_));
202  }
203 
204 
206  bool operator!=(const VertexVertexIterT& _rhs) const {
207  return !operator==(_rhs);
208  }
209 
210 
213  assert(mesh_);
214  heh_=mesh_->cw_rotated_halfedge_handle(heh_);
215  if(heh_ == start_) lap_counter_++;
216  return *this;
217  }
218 
219 
222  assert(mesh_);
223  if(heh_ == start_) lap_counter_--;
224  heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
225  return *this;
226  }
227 
228 
233  HalfedgeHandle current_halfedge_handle() const {
234  return heh_;
235  }
236 
237 
239  typename Mesh::VertexHandle handle() const {
240  assert(mesh_);
241  return mesh_->to_vertex_handle(heh_);;
242  }
243 
244 
246  operator typename Mesh::VertexHandle() const {
247  assert(mesh_);
248  return mesh_->to_vertex_handle(heh_);;
249  }
250 
251 
253  reference operator*() const {
254  assert(mesh_);
255  return mesh_->deref(handle());
256  }
257 
258 
260  pointer operator->() const {
261  assert(mesh_);
262  return &mesh_->deref(handle());
263  }
264 
265 
272  operator bool() const {
273  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
274  }
275 
276 
277 protected:
278 
279  mesh_ptr mesh_;
280  HalfedgeHandle start_, heh_;
281  int lap_counter_;
282 };
283 
284 
285 
286 //== CLASS DEFINITION =========================================================
287 
288 
293 template <class Mesh>
295 {
296  public:
297 
298 
299  //--- Typedefs ---
300 
301  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
302 
303  typedef typename Mesh::Vertex value_type;
304  typedef typename Mesh::VertexHandle value_handle;
305 
306 #if 1
307  typedef std::bidirectional_iterator_tag iterator_category;
308  typedef std::ptrdiff_t difference_type;
309  typedef const Mesh& mesh_ref;
310  typedef const Mesh* mesh_ptr;
311  typedef const typename Mesh::Vertex& reference;
312  typedef const typename Mesh::Vertex* pointer;
313 #else
314  typedef std::bidirectional_iterator_tag iterator_category;
315  typedef std::ptrdiff_t difference_type;
316  typedef Mesh& mesh_ref;
317  typedef Mesh* mesh_ptr;
318  typedef typename Mesh::Vertex& reference;
319  typedef typename Mesh::Vertex* pointer;
320 #endif
321 
322 
323 
325  ConstVertexVertexIterT() : mesh_(0), lap_counter_(0) {}
326 
327 
329  ConstVertexVertexIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
330  mesh_(&_mesh),
331  start_(_mesh.halfedge_handle(_start)),
332  heh_(start_),
333  lap_counter_(_end)
334  { ; }
335 
336 
338  ConstVertexVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
339  mesh_(&_mesh),
340  start_(_heh),
341  heh_(_heh),
342  lap_counter_(_end)
343  { ; }
344 
345 
348  mesh_(_rhs.mesh_),
349  start_(_rhs.start_),
350  heh_(_rhs.heh_),
351  lap_counter_(_rhs.lap_counter_)
352  { ; }
353 
354 
357  {
358  mesh_ = _rhs.mesh_;
359  start_ = _rhs.start_;
360  heh_ = _rhs.heh_;
361  lap_counter_ = _rhs.lap_counter_;
362  return *this;
363  }
364 
365 
366 #if 1
367 
369  mesh_(_rhs.mesh_),
370  start_(_rhs.start_),
371  heh_(_rhs.heh_),
372  lap_counter_(_rhs.lap_counter_)
373  { ; }
374 
375 
378  {
379  mesh_ = _rhs.mesh_;
380  start_ = _rhs.start_;
381  heh_ = _rhs.heh_;
382  lap_counter_ = _rhs.lap_counter_;
383  return *this;
384  }
385 #else
386  friend class ConstVertexVertexIterT<Mesh>;
387 #endif
388 
389 
391  bool operator==(const ConstVertexVertexIterT& _rhs) const {
392  return ((mesh_ == _rhs.mesh_) &&
393  (start_ == _rhs.start_) &&
394  (heh_ == _rhs.heh_) &&
395  (lap_counter_ == _rhs.lap_counter_));
396  }
397 
398 
400  bool operator!=(const ConstVertexVertexIterT& _rhs) const {
401  return !operator==(_rhs);
402  }
403 
404 
407  assert(mesh_);
408  heh_=mesh_->cw_rotated_halfedge_handle(heh_);
409  if(heh_ == start_) lap_counter_++;
410  return *this;
411  }
412 
413 
416  assert(mesh_);
417  if(heh_ == start_) lap_counter_--;
418  heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
419  return *this;
420  }
421 
422 
427  HalfedgeHandle current_halfedge_handle() const {
428  return heh_;
429  }
430 
431 
433  typename Mesh::VertexHandle handle() const {
434  assert(mesh_);
435  return mesh_->to_vertex_handle(heh_);;
436  }
437 
438 
440  operator typename Mesh::VertexHandle() const {
441  assert(mesh_);
442  return mesh_->to_vertex_handle(heh_);;
443  }
444 
445 
447  reference operator*() const {
448  assert(mesh_);
449  return mesh_->deref(handle());
450  }
451 
452 
454  pointer operator->() const {
455  assert(mesh_);
456  return &mesh_->deref(handle());
457  }
458 
459 
466  operator bool() const {
467  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
468  }
469 
470 
471 protected:
472 
473  mesh_ptr mesh_;
474  HalfedgeHandle start_, heh_;
475  int lap_counter_;
476 };
477 
478 
479 
480 //== CLASS DEFINITION =========================================================
481 
482 
487 template <class Mesh>
489 {
490  public:
491 
492 
493  //--- Typedefs ---
494 
495  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
496 
497  typedef typename Mesh::Halfedge value_type;
498  typedef typename Mesh::HalfedgeHandle value_handle;
499 
500 #if 0
501  typedef std::bidirectional_iterator_tag iterator_category;
502  typedef std::ptrdiff_t difference_type;
503  typedef const Mesh& mesh_ref;
504  typedef const Mesh* mesh_ptr;
505  typedef const typename Mesh::Halfedge& reference;
506  typedef const typename Mesh::Halfedge* pointer;
507 #else
508  typedef std::bidirectional_iterator_tag iterator_category;
509  typedef std::ptrdiff_t difference_type;
510  typedef Mesh& mesh_ref;
511  typedef Mesh* mesh_ptr;
512  typedef typename Mesh::Halfedge& reference;
513  typedef typename Mesh::Halfedge* pointer;
514 #endif
515 
516 
517 
519  VertexOHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
520 
521 
523  VertexOHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
524  mesh_(&_mesh),
525  start_(_mesh.halfedge_handle(_start)),
526  heh_(start_),
527  lap_counter_(_end)
528  { ; }
529 
530 
532  VertexOHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
533  mesh_(&_mesh),
534  start_(_heh),
535  heh_(_heh),
536  lap_counter_(_end)
537  { ; }
538 
539 
542  mesh_(_rhs.mesh_),
543  start_(_rhs.start_),
544  heh_(_rhs.heh_),
545  lap_counter_(_rhs.lap_counter_)
546  { ; }
547 
548 
551  {
552  mesh_ = _rhs.mesh_;
553  start_ = _rhs.start_;
554  heh_ = _rhs.heh_;
555  lap_counter_ = _rhs.lap_counter_;
556  return *this;
557  }
558 
559 
560 #if 0
561 
563  mesh_(_rhs.mesh_),
564  start_(_rhs.start_),
565  heh_(_rhs.heh_),
566  lap_counter_(_rhs.lap_counter_)
567  { ; }
568 
569 
571  VertexOHalfedgeIterT& operator=(const VertexOHalfedgeIterT<Mesh>& _rhs)
572  {
573  mesh_ = _rhs.mesh_;
574  start_ = _rhs.start_;
575  heh_ = _rhs.heh_;
576  lap_counter_ = _rhs.lap_counter_;
577  return *this;
578  }
579 #else
580  friend class ConstVertexOHalfedgeIterT<Mesh>;
581 #endif
582 
583 
585  bool operator==(const VertexOHalfedgeIterT& _rhs) const {
586  return ((mesh_ == _rhs.mesh_) &&
587  (start_ == _rhs.start_) &&
588  (heh_ == _rhs.heh_) &&
589  (lap_counter_ == _rhs.lap_counter_));
590  }
591 
592 
594  bool operator!=(const VertexOHalfedgeIterT& _rhs) const {
595  return !operator==(_rhs);
596  }
597 
598 
601  assert(mesh_);
602  heh_=mesh_->cw_rotated_halfedge_handle(heh_);
603  if(heh_ == start_) lap_counter_++;
604  return *this;
605  }
606 
607 
610  assert(mesh_);
611  if(heh_ == start_) lap_counter_--;
612  heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
613  return *this;
614  }
615 
616 
621  HalfedgeHandle current_halfedge_handle() const {
622  return heh_;
623  }
624 
625 
627  typename Mesh::HalfedgeHandle handle() const {
628  assert(mesh_);
629  return heh_;
630  }
631 
632 
634  operator typename Mesh::HalfedgeHandle() const {
635  assert(mesh_);
636  return heh_;
637  }
638 
639 
641  reference operator*() const {
642  assert(mesh_);
643  return mesh_->deref(handle());
644  }
645 
646 
648  pointer operator->() const {
649  assert(mesh_);
650  return &mesh_->deref(handle());
651  }
652 
653 
660  operator bool() const {
661  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
662  }
663 
664 
665 protected:
666 
667  mesh_ptr mesh_;
668  HalfedgeHandle start_, heh_;
669  int lap_counter_;
670 };
671 
672 
673 
674 //== CLASS DEFINITION =========================================================
675 
676 
681 template <class Mesh>
683 {
684  public:
685 
686 
687  //--- Typedefs ---
688 
689  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
690 
691  typedef typename Mesh::Halfedge value_type;
692  typedef typename Mesh::HalfedgeHandle value_handle;
693 
694 #if 1
695  typedef std::bidirectional_iterator_tag iterator_category;
696  typedef std::ptrdiff_t difference_type;
697  typedef const Mesh& mesh_ref;
698  typedef const Mesh* mesh_ptr;
699  typedef const typename Mesh::Halfedge& reference;
700  typedef const typename Mesh::Halfedge* pointer;
701 #else
702  typedef std::bidirectional_iterator_tag iterator_category;
703  typedef std::ptrdiff_t difference_type;
704  typedef Mesh& mesh_ref;
705  typedef Mesh* mesh_ptr;
706  typedef typename Mesh::Halfedge& reference;
707  typedef typename Mesh::Halfedge* pointer;
708 #endif
709 
710 
711 
713  ConstVertexOHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
714 
715 
717  ConstVertexOHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
718  mesh_(&_mesh),
719  start_(_mesh.halfedge_handle(_start)),
720  heh_(start_),
721  lap_counter_(_end)
722  { ; }
723 
724 
726  ConstVertexOHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
727  mesh_(&_mesh),
728  start_(_heh),
729  heh_(_heh),
730  lap_counter_(_end)
731  { ; }
732 
733 
736  mesh_(_rhs.mesh_),
737  start_(_rhs.start_),
738  heh_(_rhs.heh_),
739  lap_counter_(_rhs.lap_counter_)
740  { ; }
741 
742 
745  {
746  mesh_ = _rhs.mesh_;
747  start_ = _rhs.start_;
748  heh_ = _rhs.heh_;
749  lap_counter_ = _rhs.lap_counter_;
750  return *this;
751  }
752 
753 
754 #if 1
755 
757  mesh_(_rhs.mesh_),
758  start_(_rhs.start_),
759  heh_(_rhs.heh_),
760  lap_counter_(_rhs.lap_counter_)
761  { ; }
762 
763 
766  {
767  mesh_ = _rhs.mesh_;
768  start_ = _rhs.start_;
769  heh_ = _rhs.heh_;
770  lap_counter_ = _rhs.lap_counter_;
771  return *this;
772  }
773 #else
774  friend class ConstVertexOHalfedgeIterT<Mesh>;
775 #endif
776 
777 
779  bool operator==(const ConstVertexOHalfedgeIterT& _rhs) const {
780  return ((mesh_ == _rhs.mesh_) &&
781  (start_ == _rhs.start_) &&
782  (heh_ == _rhs.heh_) &&
783  (lap_counter_ == _rhs.lap_counter_));
784  }
785 
786 
788  bool operator!=(const ConstVertexOHalfedgeIterT& _rhs) const {
789  return !operator==(_rhs);
790  }
791 
792 
795  assert(mesh_);
796  heh_=mesh_->cw_rotated_halfedge_handle(heh_);
797  if(heh_ == start_) lap_counter_++;
798  return *this;
799  }
800 
801 
804  assert(mesh_);
805  if(heh_ == start_) lap_counter_--;
806  heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
807  return *this;
808  }
809 
810 
815  HalfedgeHandle current_halfedge_handle() const {
816  return heh_;
817  }
818 
819 
821  typename Mesh::HalfedgeHandle handle() const {
822  assert(mesh_);
823  return heh_;
824  }
825 
826 
828  operator typename Mesh::HalfedgeHandle() const {
829  assert(mesh_);
830  return heh_;
831  }
832 
833 
835  reference operator*() const {
836  assert(mesh_);
837  return mesh_->deref(handle());
838  }
839 
840 
842  pointer operator->() const {
843  assert(mesh_);
844  return &mesh_->deref(handle());
845  }
846 
847 
854  operator bool() const {
855  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
856  }
857 
858 
859 protected:
860 
861  mesh_ptr mesh_;
862  HalfedgeHandle start_, heh_;
863  int lap_counter_;
864 };
865 
866 
867 
868 //== CLASS DEFINITION =========================================================
869 
870 
875 template <class Mesh>
877 {
878  public:
879 
880 
881  //--- Typedefs ---
882 
883  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
884 
885  typedef typename Mesh::Halfedge value_type;
886  typedef typename Mesh::HalfedgeHandle value_handle;
887 
888 #if 0
889  typedef std::bidirectional_iterator_tag iterator_category;
890  typedef std::ptrdiff_t difference_type;
891  typedef const Mesh& mesh_ref;
892  typedef const Mesh* mesh_ptr;
893  typedef const typename Mesh::Halfedge& reference;
894  typedef const typename Mesh::Halfedge* pointer;
895 #else
896  typedef std::bidirectional_iterator_tag iterator_category;
897  typedef std::ptrdiff_t difference_type;
898  typedef Mesh& mesh_ref;
899  typedef Mesh* mesh_ptr;
900  typedef typename Mesh::Halfedge& reference;
901  typedef typename Mesh::Halfedge* pointer;
902 #endif
903 
904 
905 
907  VertexIHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
908 
909 
911  VertexIHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
912  mesh_(&_mesh),
913  start_(_mesh.halfedge_handle(_start)),
914  heh_(start_),
915  lap_counter_(_end)
916  { ; }
917 
918 
920  VertexIHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
921  mesh_(&_mesh),
922  start_(_heh),
923  heh_(_heh),
924  lap_counter_(_end)
925  { ; }
926 
927 
930  mesh_(_rhs.mesh_),
931  start_(_rhs.start_),
932  heh_(_rhs.heh_),
933  lap_counter_(_rhs.lap_counter_)
934  { ; }
935 
936 
939  {
940  mesh_ = _rhs.mesh_;
941  start_ = _rhs.start_;
942  heh_ = _rhs.heh_;
943  lap_counter_ = _rhs.lap_counter_;
944  return *this;
945  }
946 
947 
948 #if 0
949 
951  mesh_(_rhs.mesh_),
952  start_(_rhs.start_),
953  heh_(_rhs.heh_),
954  lap_counter_(_rhs.lap_counter_)
955  { ; }
956 
957 
959  VertexIHalfedgeIterT& operator=(const VertexIHalfedgeIterT<Mesh>& _rhs)
960  {
961  mesh_ = _rhs.mesh_;
962  start_ = _rhs.start_;
963  heh_ = _rhs.heh_;
964  lap_counter_ = _rhs.lap_counter_;
965  return *this;
966  }
967 #else
968  friend class ConstVertexIHalfedgeIterT<Mesh>;
969 #endif
970 
971 
973  bool operator==(const VertexIHalfedgeIterT& _rhs) const {
974  return ((mesh_ == _rhs.mesh_) &&
975  (start_ == _rhs.start_) &&
976  (heh_ == _rhs.heh_) &&
977  (lap_counter_ == _rhs.lap_counter_));
978  }
979 
980 
982  bool operator!=(const VertexIHalfedgeIterT& _rhs) const {
983  return !operator==(_rhs);
984  }
985 
986 
989  assert(mesh_);
990  heh_=mesh_->cw_rotated_halfedge_handle(heh_);
991  if(heh_ == start_) lap_counter_++;
992  return *this;
993  }
994 
995 
998  assert(mesh_);
999  if(heh_ == start_) lap_counter_--;
1000  heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
1001  return *this;
1002  }
1003 
1004 
1009  HalfedgeHandle current_halfedge_handle() const {
1010  return heh_;
1011  }
1012 
1013 
1015  typename Mesh::HalfedgeHandle handle() const {
1016  assert(mesh_);
1017  return mesh_->opposite_halfedge_handle(heh_);
1018  }
1019 
1020 
1022  operator typename Mesh::HalfedgeHandle() const {
1023  assert(mesh_);
1024  return mesh_->opposite_halfedge_handle(heh_);
1025  }
1026 
1027 
1029  reference operator*() const {
1030  assert(mesh_);
1031  return mesh_->deref(handle());
1032  }
1033 
1034 
1036  pointer operator->() const {
1037  assert(mesh_);
1038  return &mesh_->deref(handle());
1039  }
1040 
1041 
1048  operator bool() const {
1049  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
1050  }
1051 
1052 
1053 protected:
1054 
1055  mesh_ptr mesh_;
1056  HalfedgeHandle start_, heh_;
1057  int lap_counter_;
1058 };
1059 
1060 
1061 
1062 //== CLASS DEFINITION =========================================================
1063 
1064 
1069 template <class Mesh>
1071 {
1072  public:
1073 
1074 
1075  //--- Typedefs ---
1076 
1077  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
1078 
1079  typedef typename Mesh::Halfedge value_type;
1080  typedef typename Mesh::HalfedgeHandle value_handle;
1081 
1082 #if 1
1083  typedef std::bidirectional_iterator_tag iterator_category;
1084  typedef std::ptrdiff_t difference_type;
1085  typedef const Mesh& mesh_ref;
1086  typedef const Mesh* mesh_ptr;
1087  typedef const typename Mesh::Halfedge& reference;
1088  typedef const typename Mesh::Halfedge* pointer;
1089 #else
1090  typedef std::bidirectional_iterator_tag iterator_category;
1091  typedef std::ptrdiff_t difference_type;
1092  typedef Mesh& mesh_ref;
1093  typedef Mesh* mesh_ptr;
1094  typedef typename Mesh::Halfedge& reference;
1095  typedef typename Mesh::Halfedge* pointer;
1096 #endif
1097 
1098 
1099 
1101  ConstVertexIHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
1102 
1103 
1105  ConstVertexIHalfedgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
1106  mesh_(&_mesh),
1107  start_(_mesh.halfedge_handle(_start)),
1108  heh_(start_),
1109  lap_counter_(_end)
1110  { ; }
1111 
1112 
1114  ConstVertexIHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
1115  mesh_(&_mesh),
1116  start_(_heh),
1117  heh_(_heh),
1118  lap_counter_(_end)
1119  { ; }
1120 
1121 
1124  mesh_(_rhs.mesh_),
1125  start_(_rhs.start_),
1126  heh_(_rhs.heh_),
1127  lap_counter_(_rhs.lap_counter_)
1128  { ; }
1129 
1130 
1133  {
1134  mesh_ = _rhs.mesh_;
1135  start_ = _rhs.start_;
1136  heh_ = _rhs.heh_;
1137  lap_counter_ = _rhs.lap_counter_;
1138  return *this;
1139  }
1140 
1141 
1142 #if 1
1143 
1145  mesh_(_rhs.mesh_),
1146  start_(_rhs.start_),
1147  heh_(_rhs.heh_),
1148  lap_counter_(_rhs.lap_counter_)
1149  { ; }
1150 
1151 
1154  {
1155  mesh_ = _rhs.mesh_;
1156  start_ = _rhs.start_;
1157  heh_ = _rhs.heh_;
1158  lap_counter_ = _rhs.lap_counter_;
1159  return *this;
1160  }
1161 #else
1162  friend class ConstVertexIHalfedgeIterT<Mesh>;
1163 #endif
1164 
1165 
1167  bool operator==(const ConstVertexIHalfedgeIterT& _rhs) const {
1168  return ((mesh_ == _rhs.mesh_) &&
1169  (start_ == _rhs.start_) &&
1170  (heh_ == _rhs.heh_) &&
1171  (lap_counter_ == _rhs.lap_counter_));
1172  }
1173 
1174 
1176  bool operator!=(const ConstVertexIHalfedgeIterT& _rhs) const {
1177  return !operator==(_rhs);
1178  }
1179 
1180 
1183  assert(mesh_);
1184  heh_=mesh_->cw_rotated_halfedge_handle(heh_);
1185  if(heh_ == start_) lap_counter_++;
1186  return *this;
1187  }
1188 
1189 
1192  assert(mesh_);
1193  if(heh_ == start_) lap_counter_--;
1194  heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
1195  return *this;
1196  }
1197 
1198 
1203  HalfedgeHandle current_halfedge_handle() const {
1204  return heh_;
1205  }
1206 
1207 
1209  typename Mesh::HalfedgeHandle handle() const {
1210  assert(mesh_);
1211  return mesh_->opposite_halfedge_handle(heh_);
1212  }
1213 
1214 
1216  operator typename Mesh::HalfedgeHandle() const {
1217  assert(mesh_);
1218  return mesh_->opposite_halfedge_handle(heh_);
1219  }
1220 
1221 
1223  reference operator*() const {
1224  assert(mesh_);
1225  return mesh_->deref(handle());
1226  }
1227 
1228 
1230  pointer operator->() const {
1231  assert(mesh_);
1232  return &mesh_->deref(handle());
1233  }
1234 
1235 
1242  operator bool() const {
1243  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
1244  }
1245 
1246 
1247 protected:
1248 
1249  mesh_ptr mesh_;
1250  HalfedgeHandle start_, heh_;
1251  int lap_counter_;
1252 };
1253 
1254 
1255 
1256 //== CLASS DEFINITION =========================================================
1257 
1258 
1263 template <class Mesh>
1265 {
1266  public:
1267 
1268 
1269  //--- Typedefs ---
1270 
1271  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
1272 
1273  typedef typename Mesh::Edge value_type;
1274  typedef typename Mesh::EdgeHandle value_handle;
1275 
1276 #if 0
1277  typedef std::bidirectional_iterator_tag iterator_category;
1278  typedef std::ptrdiff_t difference_type;
1279  typedef const Mesh& mesh_ref;
1280  typedef const Mesh* mesh_ptr;
1281  typedef const typename Mesh::Edge& reference;
1282  typedef const typename Mesh::Edge* pointer;
1283 #else
1284  typedef std::bidirectional_iterator_tag iterator_category;
1285  typedef std::ptrdiff_t difference_type;
1286  typedef Mesh& mesh_ref;
1287  typedef Mesh* mesh_ptr;
1288  typedef typename Mesh::Edge& reference;
1289  typedef typename Mesh::Edge* pointer;
1290 #endif
1291 
1292 
1293 
1295  VertexEdgeIterT() : mesh_(0), lap_counter_(false) {}
1296 
1297 
1299  VertexEdgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
1300  mesh_(&_mesh),
1301  start_(_mesh.halfedge_handle(_start)),
1302  heh_(start_),
1303  lap_counter_(_end)
1304  { ; }
1305 
1306 
1308  VertexEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
1309  mesh_(&_mesh),
1310  start_(_heh),
1311  heh_(_heh),
1312  lap_counter_(_end)
1313  { ; }
1314 
1315 
1318  mesh_(_rhs.mesh_),
1319  start_(_rhs.start_),
1320  heh_(_rhs.heh_),
1321  lap_counter_(_rhs.lap_counter_)
1322  { ; }
1323 
1324 
1327  {
1328  mesh_ = _rhs.mesh_;
1329  start_ = _rhs.start_;
1330  heh_ = _rhs.heh_;
1331  lap_counter_ = _rhs.lap_counter_;
1332  return *this;
1333  }
1334 
1335 
1336 #if 0
1337 
1338  VertexEdgeIterT(const VertexEdgeIterT<Mesh>& _rhs) :
1339  mesh_(_rhs.mesh_),
1340  start_(_rhs.start_),
1341  heh_(_rhs.heh_),
1342  lap_counter_(_rhs.lap_counter_)
1343  { ; }
1344 
1345 
1347  VertexEdgeIterT& operator=(const VertexEdgeIterT<Mesh>& _rhs)
1348  {
1349  mesh_ = _rhs.mesh_;
1350  start_ = _rhs.start_;
1351  heh_ = _rhs.heh_;
1352  lap_counter_ = _rhs.lap_counter_;
1353  return *this;
1354  }
1355 #else
1356  friend class ConstVertexEdgeIterT<Mesh>;
1357 #endif
1358 
1359 
1361  bool operator==(const VertexEdgeIterT& _rhs) const {
1362  return ((mesh_ == _rhs.mesh_) &&
1363  (start_ == _rhs.start_) &&
1364  (heh_ == _rhs.heh_) &&
1365  (lap_counter_ == _rhs.lap_counter_));
1366  }
1367 
1368 
1370  bool operator!=(const VertexEdgeIterT& _rhs) const {
1371  return !operator==(_rhs);
1372  }
1373 
1374 
1377  assert(mesh_);
1378  heh_=mesh_->cw_rotated_halfedge_handle(heh_);
1379  if(heh_ == start_) lap_counter_++;
1380  return *this;
1381  }
1382 
1383 
1386  assert(mesh_);
1387  if(heh_ == start_) lap_counter_--;
1388  heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
1389  return *this;
1390  }
1391 
1392 
1397  HalfedgeHandle current_halfedge_handle() const {
1398  return heh_;
1399  }
1400 
1401 
1403  typename Mesh::EdgeHandle handle() const {
1404  assert(mesh_);
1405  return mesh_->edge_handle(heh_);
1406  }
1407 
1408 
1410  operator typename Mesh::EdgeHandle() const {
1411  assert(mesh_);
1412  return mesh_->edge_handle(heh_);
1413  }
1414 
1415 
1417  reference operator*() const {
1418  assert(mesh_);
1419  return mesh_->deref(handle());
1420  }
1421 
1422 
1424  pointer operator->() const {
1425  assert(mesh_);
1426  return &mesh_->deref(handle());
1427  }
1428 
1429 
1436  operator bool() const {
1437  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
1438  }
1439 
1440 
1441 protected:
1442 
1443  mesh_ptr mesh_;
1444  HalfedgeHandle start_, heh_;
1445  int lap_counter_;
1446 };
1447 
1448 
1449 
1450 //== CLASS DEFINITION =========================================================
1451 
1452 
1457 template <class Mesh>
1459 {
1460  public:
1461 
1462 
1463  //--- Typedefs ---
1464 
1465  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
1466 
1467  typedef typename Mesh::Edge value_type;
1468  typedef typename Mesh::EdgeHandle value_handle;
1469 
1470 #if 1
1471  typedef std::bidirectional_iterator_tag iterator_category;
1472  typedef std::ptrdiff_t difference_type;
1473  typedef const Mesh& mesh_ref;
1474  typedef const Mesh* mesh_ptr;
1475  typedef const typename Mesh::Edge& reference;
1476  typedef const typename Mesh::Edge* pointer;
1477 #else
1478  typedef std::bidirectional_iterator_tag iterator_category;
1479  typedef std::ptrdiff_t difference_type;
1480  typedef Mesh& mesh_ref;
1481  typedef Mesh* mesh_ptr;
1482  typedef typename Mesh::Edge& reference;
1483  typedef typename Mesh::Edge* pointer;
1484 #endif
1485 
1486 
1487 
1489  ConstVertexEdgeIterT() : mesh_(0), lap_counter_(false) {}
1490 
1491 
1493  ConstVertexEdgeIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
1494  mesh_(&_mesh),
1495  start_(_mesh.halfedge_handle(_start)),
1496  heh_(start_),
1497  lap_counter_(_end)
1498  { ; }
1499 
1500 
1502  ConstVertexEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
1503  mesh_(&_mesh),
1504  start_(_heh),
1505  heh_(_heh),
1506  lap_counter_(_end)
1507  { ; }
1508 
1509 
1512  mesh_(_rhs.mesh_),
1513  start_(_rhs.start_),
1514  heh_(_rhs.heh_),
1515  lap_counter_(_rhs.lap_counter_)
1516  { ; }
1517 
1518 
1521  {
1522  mesh_ = _rhs.mesh_;
1523  start_ = _rhs.start_;
1524  heh_ = _rhs.heh_;
1525  lap_counter_ = _rhs.lap_counter_;
1526  return *this;
1527  }
1528 
1529 
1530 #if 1
1531 
1533  mesh_(_rhs.mesh_),
1534  start_(_rhs.start_),
1535  heh_(_rhs.heh_),
1536  lap_counter_(_rhs.lap_counter_)
1537  { ; }
1538 
1539 
1542  {
1543  mesh_ = _rhs.mesh_;
1544  start_ = _rhs.start_;
1545  heh_ = _rhs.heh_;
1546  lap_counter_ = _rhs.lap_counter_;
1547  return *this;
1548  }
1549 #else
1550  friend class ConstVertexEdgeIterT<Mesh>;
1551 #endif
1552 
1553 
1555  bool operator==(const ConstVertexEdgeIterT& _rhs) const {
1556  return ((mesh_ == _rhs.mesh_) &&
1557  (start_ == _rhs.start_) &&
1558  (heh_ == _rhs.heh_) &&
1559  (lap_counter_ == _rhs.lap_counter_));
1560  }
1561 
1562 
1564  bool operator!=(const ConstVertexEdgeIterT& _rhs) const {
1565  return !operator==(_rhs);
1566  }
1567 
1568 
1571  assert(mesh_);
1572  heh_=mesh_->cw_rotated_halfedge_handle(heh_);
1573  if(heh_ == start_) lap_counter_++;
1574  return *this;
1575  }
1576 
1577 
1580  assert(mesh_);
1581  if(heh_ == start_) lap_counter_--;
1582  heh_=mesh_->ccw_rotated_halfedge_handle(heh_);
1583  return *this;
1584  }
1585 
1586 
1591  HalfedgeHandle current_halfedge_handle() const {
1592  return heh_;
1593  }
1594 
1595 
1597  typename Mesh::EdgeHandle handle() const {
1598  assert(mesh_);
1599  return mesh_->edge_handle(heh_);
1600  }
1601 
1602 
1604  operator typename Mesh::EdgeHandle() const {
1605  assert(mesh_);
1606  return mesh_->edge_handle(heh_);
1607  }
1608 
1609 
1611  reference operator*() const {
1612  assert(mesh_);
1613  return mesh_->deref(handle());
1614  }
1615 
1616 
1618  pointer operator->() const {
1619  assert(mesh_);
1620  return &mesh_->deref(handle());
1621  }
1622 
1623 
1630  operator bool() const {
1631  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
1632  }
1633 
1634 
1635 protected:
1636 
1637  mesh_ptr mesh_;
1638  HalfedgeHandle start_, heh_;
1639  int lap_counter_;
1640 };
1641 
1642 
1643 
1644 //== CLASS DEFINITION =========================================================
1645 
1646 
1651 template <class Mesh>
1653 {
1654  public:
1655 
1656 
1657  //--- Typedefs ---
1658 
1659  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
1660 
1661  typedef typename Mesh::Face value_type;
1662  typedef typename Mesh::FaceHandle value_handle;
1663 
1664 #if 0
1665  typedef std::bidirectional_iterator_tag iterator_category;
1666  typedef std::ptrdiff_t difference_type;
1667  typedef const Mesh& mesh_ref;
1668  typedef const Mesh* mesh_ptr;
1669  typedef const typename Mesh::Face& reference;
1670  typedef const typename Mesh::Face* pointer;
1671 #else
1672  typedef std::bidirectional_iterator_tag iterator_category;
1673  typedef std::ptrdiff_t difference_type;
1674  typedef Mesh& mesh_ref;
1675  typedef Mesh* mesh_ptr;
1676  typedef typename Mesh::Face& reference;
1677  typedef typename Mesh::Face* pointer;
1678 #endif
1679 
1680 
1681 
1683  VertexFaceIterT() : mesh_(0), lap_counter_(false) {}
1684 
1685 
1687  VertexFaceIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
1688  mesh_(&_mesh),
1689  start_(_mesh.halfedge_handle(_start)),
1690  heh_(start_),
1691  lap_counter_(_end)
1692  { if (heh_.is_valid() && !handle().is_valid() && !_end) operator++();; }
1693 
1694 
1696  VertexFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
1697  mesh_(&_mesh),
1698  start_(_heh),
1699  heh_(_heh),
1700  lap_counter_(_end)
1701  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
1702 
1703 
1706  mesh_(_rhs.mesh_),
1707  start_(_rhs.start_),
1708  heh_(_rhs.heh_),
1709  lap_counter_(_rhs.lap_counter_)
1710  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
1711 
1712 
1715  {
1716  mesh_ = _rhs.mesh_;
1717  start_ = _rhs.start_;
1718  heh_ = _rhs.heh_;
1719  lap_counter_ = _rhs.lap_counter_;
1720  return *this;
1721  }
1722 
1723 
1724 #if 0
1725 
1726  VertexFaceIterT(const VertexFaceIterT<Mesh>& _rhs) :
1727  mesh_(_rhs.mesh_),
1728  start_(_rhs.start_),
1729  heh_(_rhs.heh_),
1730  lap_counter_(_rhs.lap_counter_)
1731  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
1732 
1733 
1735  VertexFaceIterT& operator=(const VertexFaceIterT<Mesh>& _rhs)
1736  {
1737  mesh_ = _rhs.mesh_;
1738  start_ = _rhs.start_;
1739  heh_ = _rhs.heh_;
1740  lap_counter_ = _rhs.lap_counter_;
1741  return *this;
1742  }
1743 #else
1744  friend class ConstVertexFaceIterT<Mesh>;
1745 #endif
1746 
1747 
1749  bool operator==(const VertexFaceIterT& _rhs) const {
1750  return ((mesh_ == _rhs.mesh_) &&
1751  (start_ == _rhs.start_) &&
1752  (heh_ == _rhs.heh_) &&
1753  (lap_counter_ == _rhs.lap_counter_));
1754  }
1755 
1756 
1758  bool operator!=(const VertexFaceIterT& _rhs) const {
1759  return !operator==(_rhs);
1760  }
1761 
1762 
1765  assert(mesh_);
1766  do { heh_=mesh_->cw_rotated_halfedge_handle(heh_); if(heh_ == start_) lap_counter_++; } while ((*this) && (!handle().is_valid()));;
1767  return *this;
1768  }
1769 
1770 
1773  assert(mesh_);
1774  do { if(heh_ == start_) lap_counter_--; heh_=mesh_->ccw_rotated_halfedge_handle(heh_); } while ((*this) && (!handle().is_valid()));;
1775  return *this;
1776  }
1777 
1778 
1783  HalfedgeHandle current_halfedge_handle() const {
1784  return heh_;
1785  }
1786 
1787 
1789  typename Mesh::FaceHandle handle() const {
1790  assert(mesh_);
1791  return mesh_->face_handle(heh_);
1792  }
1793 
1794 
1796  operator typename Mesh::FaceHandle() const {
1797  assert(mesh_);
1798  return mesh_->face_handle(heh_);
1799  }
1800 
1801 
1803  reference operator*() const {
1804  assert(mesh_);
1805  return mesh_->deref(handle());
1806  }
1807 
1808 
1810  pointer operator->() const {
1811  assert(mesh_);
1812  return &mesh_->deref(handle());
1813  }
1814 
1815 
1822  operator bool() const {
1823  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
1824  }
1825 
1826 
1827 protected:
1828 
1829  mesh_ptr mesh_;
1830  HalfedgeHandle start_, heh_;
1831  int lap_counter_;
1832 };
1833 
1834 
1835 
1836 //== CLASS DEFINITION =========================================================
1837 
1838 
1843 template <class Mesh>
1845 {
1846  public:
1847 
1848 
1849  //--- Typedefs ---
1850 
1851  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
1852 
1853  typedef typename Mesh::Face value_type;
1854  typedef typename Mesh::FaceHandle value_handle;
1855 
1856 #if 1
1857  typedef std::bidirectional_iterator_tag iterator_category;
1858  typedef std::ptrdiff_t difference_type;
1859  typedef const Mesh& mesh_ref;
1860  typedef const Mesh* mesh_ptr;
1861  typedef const typename Mesh::Face& reference;
1862  typedef const typename Mesh::Face* pointer;
1863 #else
1864  typedef std::bidirectional_iterator_tag iterator_category;
1865  typedef std::ptrdiff_t difference_type;
1866  typedef Mesh& mesh_ref;
1867  typedef Mesh* mesh_ptr;
1868  typedef typename Mesh::Face& reference;
1869  typedef typename Mesh::Face* pointer;
1870 #endif
1871 
1872 
1873 
1875  ConstVertexFaceIterT() : mesh_(0), lap_counter_(false) {}
1876 
1877 
1879  ConstVertexFaceIterT(mesh_ref _mesh, typename Mesh::VertexHandle _start, bool _end = false) :
1880  mesh_(&_mesh),
1881  start_(_mesh.halfedge_handle(_start)),
1882  heh_(start_),
1883  lap_counter_(_end)
1884  { if (heh_.is_valid() && !handle().is_valid() && !_end) operator++();; }
1885 
1886 
1888  ConstVertexFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
1889  mesh_(&_mesh),
1890  start_(_heh),
1891  heh_(_heh),
1892  lap_counter_(_end)
1893  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
1894 
1895 
1898  mesh_(_rhs.mesh_),
1899  start_(_rhs.start_),
1900  heh_(_rhs.heh_),
1901  lap_counter_(_rhs.lap_counter_)
1902  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
1903 
1904 
1907  {
1908  mesh_ = _rhs.mesh_;
1909  start_ = _rhs.start_;
1910  heh_ = _rhs.heh_;
1911  lap_counter_ = _rhs.lap_counter_;
1912  return *this;
1913  }
1914 
1915 
1916 #if 1
1917 
1919  mesh_(_rhs.mesh_),
1920  start_(_rhs.start_),
1921  heh_(_rhs.heh_),
1922  lap_counter_(_rhs.lap_counter_)
1923  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
1924 
1925 
1928  {
1929  mesh_ = _rhs.mesh_;
1930  start_ = _rhs.start_;
1931  heh_ = _rhs.heh_;
1932  lap_counter_ = _rhs.lap_counter_;
1933  return *this;
1934  }
1935 #else
1936  friend class ConstVertexFaceIterT<Mesh>;
1937 #endif
1938 
1939 
1941  bool operator==(const ConstVertexFaceIterT& _rhs) const {
1942  return ((mesh_ == _rhs.mesh_) &&
1943  (start_ == _rhs.start_) &&
1944  (heh_ == _rhs.heh_) &&
1945  (lap_counter_ == _rhs.lap_counter_));
1946  }
1947 
1948 
1950  bool operator!=(const ConstVertexFaceIterT& _rhs) const {
1951  return !operator==(_rhs);
1952  }
1953 
1954 
1957  assert(mesh_);
1958  do { heh_=mesh_->cw_rotated_halfedge_handle(heh_); if(heh_ == start_) lap_counter_++; } while ((*this) && (!handle().is_valid()));;
1959  return *this;
1960  }
1961 
1962 
1965  assert(mesh_);
1966  do { if(heh_ == start_) lap_counter_--; heh_=mesh_->ccw_rotated_halfedge_handle(heh_); } while ((*this) && (!handle().is_valid()));;
1967  return *this;
1968  }
1969 
1970 
1975  HalfedgeHandle current_halfedge_handle() const {
1976  return heh_;
1977  }
1978 
1979 
1981  typename Mesh::FaceHandle handle() const {
1982  assert(mesh_);
1983  return mesh_->face_handle(heh_);
1984  }
1985 
1986 
1988  operator typename Mesh::FaceHandle() const {
1989  assert(mesh_);
1990  return mesh_->face_handle(heh_);
1991  }
1992 
1993 
1995  reference operator*() const {
1996  assert(mesh_);
1997  return mesh_->deref(handle());
1998  }
1999 
2000 
2002  pointer operator->() const {
2003  assert(mesh_);
2004  return &mesh_->deref(handle());
2005  }
2006 
2007 
2014  operator bool() const {
2015  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2016  }
2017 
2018 
2019 protected:
2020 
2021  mesh_ptr mesh_;
2022  HalfedgeHandle start_, heh_;
2023  int lap_counter_;
2024 };
2025 
2026 
2027 
2028 //== CLASS DEFINITION =========================================================
2029 
2030 
2035 template <class Mesh>
2037 {
2038  public:
2039 
2040 
2041  //--- Typedefs ---
2042 
2043  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
2044 
2045  typedef typename Mesh::Vertex value_type;
2046  typedef typename Mesh::VertexHandle value_handle;
2047 
2048 #if 0
2049  typedef std::bidirectional_iterator_tag iterator_category;
2050  typedef std::ptrdiff_t difference_type;
2051  typedef const Mesh& mesh_ref;
2052  typedef const Mesh* mesh_ptr;
2053  typedef const typename Mesh::Vertex& reference;
2054  typedef const typename Mesh::Vertex* pointer;
2055 #else
2056  typedef std::bidirectional_iterator_tag iterator_category;
2057  typedef std::ptrdiff_t difference_type;
2058  typedef Mesh& mesh_ref;
2059  typedef Mesh* mesh_ptr;
2060  typedef typename Mesh::Vertex& reference;
2061  typedef typename Mesh::Vertex* pointer;
2062 #endif
2063 
2064 
2065 
2067  FaceVertexIterT() : mesh_(0), lap_counter_(false) {}
2068 
2069 
2071  FaceVertexIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
2072  mesh_(&_mesh),
2073  start_(_mesh.halfedge_handle(_start)),
2074  heh_(start_),
2075  lap_counter_(_end)
2076  { ; }
2077 
2078 
2080  FaceVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
2081  mesh_(&_mesh),
2082  start_(_heh),
2083  heh_(_heh),
2084  lap_counter_(_end)
2085  { ; }
2086 
2087 
2090  mesh_(_rhs.mesh_),
2091  start_(_rhs.start_),
2092  heh_(_rhs.heh_),
2093  lap_counter_(_rhs.lap_counter_)
2094  { ; }
2095 
2096 
2099  {
2100  mesh_ = _rhs.mesh_;
2101  start_ = _rhs.start_;
2102  heh_ = _rhs.heh_;
2103  lap_counter_ = _rhs.lap_counter_;
2104  return *this;
2105  }
2106 
2107 
2108 #if 0
2109 
2110  FaceVertexIterT(const FaceVertexIterT<Mesh>& _rhs) :
2111  mesh_(_rhs.mesh_),
2112  start_(_rhs.start_),
2113  heh_(_rhs.heh_),
2114  lap_counter_(_rhs.lap_counter_)
2115  { ; }
2116 
2117 
2119  FaceVertexIterT& operator=(const FaceVertexIterT<Mesh>& _rhs)
2120  {
2121  mesh_ = _rhs.mesh_;
2122  start_ = _rhs.start_;
2123  heh_ = _rhs.heh_;
2124  lap_counter_ = _rhs.lap_counter_;
2125  return *this;
2126  }
2127 #else
2128  friend class ConstFaceVertexIterT<Mesh>;
2129 #endif
2130 
2131 
2133  bool operator==(const FaceVertexIterT& _rhs) const {
2134  return ((mesh_ == _rhs.mesh_) &&
2135  (start_ == _rhs.start_) &&
2136  (heh_ == _rhs.heh_) &&
2137  (lap_counter_ == _rhs.lap_counter_));
2138  }
2139 
2140 
2142  bool operator!=(const FaceVertexIterT& _rhs) const {
2143  return !operator==(_rhs);
2144  }
2145 
2146 
2149  assert(mesh_);
2150  heh_=mesh_->next_halfedge_handle(heh_);
2151  if(heh_ == start_) lap_counter_++;
2152  return *this;
2153  }
2154 
2155 
2158  assert(mesh_);
2159  if(heh_ == start_) lap_counter_--;
2160  heh_=mesh_->prev_halfedge_handle(heh_);
2161  return *this;
2162  }
2163 
2164 
2169  HalfedgeHandle current_halfedge_handle() const {
2170  return heh_;
2171  }
2172 
2173 
2175  typename Mesh::VertexHandle handle() const {
2176  assert(mesh_);
2177  return mesh_->to_vertex_handle(heh_);
2178  }
2179 
2180 
2182  operator typename Mesh::VertexHandle() const {
2183  assert(mesh_);
2184  return mesh_->to_vertex_handle(heh_);
2185  }
2186 
2187 
2189  reference operator*() const {
2190  assert(mesh_);
2191  return mesh_->deref(handle());
2192  }
2193 
2194 
2196  pointer operator->() const {
2197  assert(mesh_);
2198  return &mesh_->deref(handle());
2199  }
2200 
2201 
2208  operator bool() const {
2209  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2210  }
2211 
2212 
2213 protected:
2214 
2215  mesh_ptr mesh_;
2216  HalfedgeHandle start_, heh_;
2217  int lap_counter_;
2218 };
2219 
2220 
2221 
2222 //== CLASS DEFINITION =========================================================
2223 
2224 
2229 template <class Mesh>
2231 {
2232  public:
2233 
2234 
2235  //--- Typedefs ---
2236 
2237  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
2238 
2239  typedef typename Mesh::Vertex value_type;
2240  typedef typename Mesh::VertexHandle value_handle;
2241 
2242 #if 1
2243  typedef std::bidirectional_iterator_tag iterator_category;
2244  typedef std::ptrdiff_t difference_type;
2245  typedef const Mesh& mesh_ref;
2246  typedef const Mesh* mesh_ptr;
2247  typedef const typename Mesh::Vertex& reference;
2248  typedef const typename Mesh::Vertex* pointer;
2249 #else
2250  typedef std::bidirectional_iterator_tag iterator_category;
2251  typedef std::ptrdiff_t difference_type;
2252  typedef Mesh& mesh_ref;
2253  typedef Mesh* mesh_ptr;
2254  typedef typename Mesh::Vertex& reference;
2255  typedef typename Mesh::Vertex* pointer;
2256 #endif
2257 
2258 
2259 
2261  ConstFaceVertexIterT() : mesh_(0), lap_counter_(false) {}
2262 
2263 
2265  ConstFaceVertexIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
2266  mesh_(&_mesh),
2267  start_(_mesh.halfedge_handle(_start)),
2268  heh_(start_),
2269  lap_counter_(_end)
2270  { ; }
2271 
2272 
2274  ConstFaceVertexIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
2275  mesh_(&_mesh),
2276  start_(_heh),
2277  heh_(_heh),
2278  lap_counter_(_end)
2279  { ; }
2280 
2281 
2284  mesh_(_rhs.mesh_),
2285  start_(_rhs.start_),
2286  heh_(_rhs.heh_),
2287  lap_counter_(_rhs.lap_counter_)
2288  { ; }
2289 
2290 
2293  {
2294  mesh_ = _rhs.mesh_;
2295  start_ = _rhs.start_;
2296  heh_ = _rhs.heh_;
2297  lap_counter_ = _rhs.lap_counter_;
2298  return *this;
2299  }
2300 
2301 
2302 #if 1
2303 
2305  mesh_(_rhs.mesh_),
2306  start_(_rhs.start_),
2307  heh_(_rhs.heh_),
2308  lap_counter_(_rhs.lap_counter_)
2309  { ; }
2310 
2311 
2314  {
2315  mesh_ = _rhs.mesh_;
2316  start_ = _rhs.start_;
2317  heh_ = _rhs.heh_;
2318  lap_counter_ = _rhs.lap_counter_;
2319  return *this;
2320  }
2321 #else
2322  friend class ConstFaceVertexIterT<Mesh>;
2323 #endif
2324 
2325 
2327  bool operator==(const ConstFaceVertexIterT& _rhs) const {
2328  return ((mesh_ == _rhs.mesh_) &&
2329  (start_ == _rhs.start_) &&
2330  (heh_ == _rhs.heh_) &&
2331  (lap_counter_ == _rhs.lap_counter_));
2332  }
2333 
2334 
2336  bool operator!=(const ConstFaceVertexIterT& _rhs) const {
2337  return !operator==(_rhs);
2338  }
2339 
2340 
2343  assert(mesh_);
2344  heh_=mesh_->next_halfedge_handle(heh_);
2345  if(heh_ == start_) lap_counter_++;
2346  return *this;
2347  }
2348 
2349 
2352  assert(mesh_);
2353  if(heh_ == start_) lap_counter_--;
2354  heh_=mesh_->prev_halfedge_handle(heh_);
2355  return *this;
2356  }
2357 
2358 
2363  HalfedgeHandle current_halfedge_handle() const {
2364  return heh_;
2365  }
2366 
2367 
2369  typename Mesh::VertexHandle handle() const {
2370  assert(mesh_);
2371  return mesh_->to_vertex_handle(heh_);
2372  }
2373 
2374 
2376  operator typename Mesh::VertexHandle() const {
2377  assert(mesh_);
2378  return mesh_->to_vertex_handle(heh_);
2379  }
2380 
2381 
2383  reference operator*() const {
2384  assert(mesh_);
2385  return mesh_->deref(handle());
2386  }
2387 
2388 
2390  pointer operator->() const {
2391  assert(mesh_);
2392  return &mesh_->deref(handle());
2393  }
2394 
2395 
2402  operator bool() const {
2403  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2404  }
2405 
2406 
2407 protected:
2408 
2409  mesh_ptr mesh_;
2410  HalfedgeHandle start_, heh_;
2411  int lap_counter_;
2412 };
2413 
2414 
2415 
2416 //== CLASS DEFINITION =========================================================
2417 
2418 
2423 template <class Mesh>
2425 {
2426  public:
2427 
2428 
2429  //--- Typedefs ---
2430 
2431  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
2432 
2433  typedef typename Mesh::Halfedge value_type;
2434  typedef typename Mesh::HalfedgeHandle value_handle;
2435 
2436 #if 0
2437  typedef std::bidirectional_iterator_tag iterator_category;
2438  typedef std::ptrdiff_t difference_type;
2439  typedef const Mesh& mesh_ref;
2440  typedef const Mesh* mesh_ptr;
2441  typedef const typename Mesh::Halfedge& reference;
2442  typedef const typename Mesh::Halfedge* pointer;
2443 #else
2444  typedef std::bidirectional_iterator_tag iterator_category;
2445  typedef std::ptrdiff_t difference_type;
2446  typedef Mesh& mesh_ref;
2447  typedef Mesh* mesh_ptr;
2448  typedef typename Mesh::Halfedge& reference;
2449  typedef typename Mesh::Halfedge* pointer;
2450 #endif
2451 
2452 
2453 
2455  FaceHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
2456 
2457 
2459  FaceHalfedgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
2460  mesh_(&_mesh),
2461  start_(_mesh.halfedge_handle(_start)),
2462  heh_(start_),
2463  lap_counter_(_end)
2464  { ; }
2465 
2466 
2468  FaceHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
2469  mesh_(&_mesh),
2470  start_(_heh),
2471  heh_(_heh),
2472  lap_counter_(_end)
2473  { ; }
2474 
2475 
2478  mesh_(_rhs.mesh_),
2479  start_(_rhs.start_),
2480  heh_(_rhs.heh_),
2481  lap_counter_(_rhs.lap_counter_)
2482  { ; }
2483 
2484 
2487  {
2488  mesh_ = _rhs.mesh_;
2489  start_ = _rhs.start_;
2490  heh_ = _rhs.heh_;
2491  lap_counter_ = _rhs.lap_counter_;
2492  return *this;
2493  }
2494 
2495 
2496 #if 0
2497 
2499  mesh_(_rhs.mesh_),
2500  start_(_rhs.start_),
2501  heh_(_rhs.heh_),
2502  lap_counter_(_rhs.lap_counter_)
2503  { ; }
2504 
2505 
2507  FaceHalfedgeIterT& operator=(const FaceHalfedgeIterT<Mesh>& _rhs)
2508  {
2509  mesh_ = _rhs.mesh_;
2510  start_ = _rhs.start_;
2511  heh_ = _rhs.heh_;
2512  lap_counter_ = _rhs.lap_counter_;
2513  return *this;
2514  }
2515 #else
2516  friend class ConstFaceHalfedgeIterT<Mesh>;
2517 #endif
2518 
2519 
2521  bool operator==(const FaceHalfedgeIterT& _rhs) const {
2522  return ((mesh_ == _rhs.mesh_) &&
2523  (start_ == _rhs.start_) &&
2524  (heh_ == _rhs.heh_) &&
2525  (lap_counter_ == _rhs.lap_counter_));
2526  }
2527 
2528 
2530  bool operator!=(const FaceHalfedgeIterT& _rhs) const {
2531  return !operator==(_rhs);
2532  }
2533 
2534 
2537  assert(mesh_);
2538  heh_=mesh_->next_halfedge_handle(heh_);
2539  if(heh_ == start_) lap_counter_++;
2540  return *this;
2541  }
2542 
2543 
2546  assert(mesh_);
2547  if(heh_ == start_) lap_counter_--;
2548  heh_=mesh_->prev_halfedge_handle(heh_);
2549  return *this;
2550  }
2551 
2552 
2557  HalfedgeHandle current_halfedge_handle() const {
2558  return heh_;
2559  }
2560 
2561 
2563  typename Mesh::HalfedgeHandle handle() const {
2564  assert(mesh_);
2565  return heh_;
2566  }
2567 
2568 
2570  operator typename Mesh::HalfedgeHandle() const {
2571  assert(mesh_);
2572  return heh_;
2573  }
2574 
2575 
2577  reference operator*() const {
2578  assert(mesh_);
2579  return mesh_->deref(handle());
2580  }
2581 
2582 
2584  pointer operator->() const {
2585  assert(mesh_);
2586  return &mesh_->deref(handle());
2587  }
2588 
2589 
2596  operator bool() const {
2597  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2598  }
2599 
2600 
2601 protected:
2602 
2603  mesh_ptr mesh_;
2604  HalfedgeHandle start_, heh_;
2605  int lap_counter_;
2606 };
2607 
2608 
2609 
2610 //== CLASS DEFINITION =========================================================
2611 
2612 
2617 template <class Mesh>
2619 {
2620  public:
2621 
2622 
2623  //--- Typedefs ---
2624 
2625  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
2626 
2627  typedef typename Mesh::Halfedge value_type;
2628  typedef typename Mesh::HalfedgeHandle value_handle;
2629 
2630 #if 1
2631  typedef std::bidirectional_iterator_tag iterator_category;
2632  typedef std::ptrdiff_t difference_type;
2633  typedef const Mesh& mesh_ref;
2634  typedef const Mesh* mesh_ptr;
2635  typedef const typename Mesh::Halfedge& reference;
2636  typedef const typename Mesh::Halfedge* pointer;
2637 #else
2638  typedef std::bidirectional_iterator_tag iterator_category;
2639  typedef std::ptrdiff_t difference_type;
2640  typedef Mesh& mesh_ref;
2641  typedef Mesh* mesh_ptr;
2642  typedef typename Mesh::Halfedge& reference;
2643  typedef typename Mesh::Halfedge* pointer;
2644 #endif
2645 
2646 
2647 
2649  ConstFaceHalfedgeIterT() : mesh_(0), lap_counter_(false) {}
2650 
2651 
2653  ConstFaceHalfedgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
2654  mesh_(&_mesh),
2655  start_(_mesh.halfedge_handle(_start)),
2656  heh_(start_),
2657  lap_counter_(_end)
2658  { ; }
2659 
2660 
2662  ConstFaceHalfedgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
2663  mesh_(&_mesh),
2664  start_(_heh),
2665  heh_(_heh),
2666  lap_counter_(_end)
2667  { ; }
2668 
2669 
2672  mesh_(_rhs.mesh_),
2673  start_(_rhs.start_),
2674  heh_(_rhs.heh_),
2675  lap_counter_(_rhs.lap_counter_)
2676  { ; }
2677 
2678 
2681  {
2682  mesh_ = _rhs.mesh_;
2683  start_ = _rhs.start_;
2684  heh_ = _rhs.heh_;
2685  lap_counter_ = _rhs.lap_counter_;
2686  return *this;
2687  }
2688 
2689 
2690 #if 1
2691 
2693  mesh_(_rhs.mesh_),
2694  start_(_rhs.start_),
2695  heh_(_rhs.heh_),
2696  lap_counter_(_rhs.lap_counter_)
2697  { ; }
2698 
2699 
2702  {
2703  mesh_ = _rhs.mesh_;
2704  start_ = _rhs.start_;
2705  heh_ = _rhs.heh_;
2706  lap_counter_ = _rhs.lap_counter_;
2707  return *this;
2708  }
2709 #else
2710  friend class ConstFaceHalfedgeIterT<Mesh>;
2711 #endif
2712 
2713 
2715  bool operator==(const ConstFaceHalfedgeIterT& _rhs) const {
2716  return ((mesh_ == _rhs.mesh_) &&
2717  (start_ == _rhs.start_) &&
2718  (heh_ == _rhs.heh_) &&
2719  (lap_counter_ == _rhs.lap_counter_));
2720  }
2721 
2722 
2724  bool operator!=(const ConstFaceHalfedgeIterT& _rhs) const {
2725  return !operator==(_rhs);
2726  }
2727 
2728 
2731  assert(mesh_);
2732  heh_=mesh_->next_halfedge_handle(heh_);
2733  if(heh_ == start_) lap_counter_++;
2734  return *this;
2735  }
2736 
2737 
2740  assert(mesh_);
2741  if(heh_ == start_) lap_counter_--;
2742  heh_=mesh_->prev_halfedge_handle(heh_);
2743  return *this;
2744  }
2745 
2746 
2751  HalfedgeHandle current_halfedge_handle() const {
2752  return heh_;
2753  }
2754 
2755 
2757  typename Mesh::HalfedgeHandle handle() const {
2758  assert(mesh_);
2759  return heh_;
2760  }
2761 
2762 
2764  operator typename Mesh::HalfedgeHandle() const {
2765  assert(mesh_);
2766  return heh_;
2767  }
2768 
2769 
2771  reference operator*() const {
2772  assert(mesh_);
2773  return mesh_->deref(handle());
2774  }
2775 
2776 
2778  pointer operator->() const {
2779  assert(mesh_);
2780  return &mesh_->deref(handle());
2781  }
2782 
2783 
2790  operator bool() const {
2791  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2792  }
2793 
2794 
2795 protected:
2796 
2797  mesh_ptr mesh_;
2798  HalfedgeHandle start_, heh_;
2799  int lap_counter_;
2800 };
2801 
2802 
2803 
2804 //== CLASS DEFINITION =========================================================
2805 
2806 
2811 template <class Mesh>
2813 {
2814  public:
2815 
2816 
2817  //--- Typedefs ---
2818 
2819  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
2820 
2821  typedef typename Mesh::Edge value_type;
2822  typedef typename Mesh::EdgeHandle value_handle;
2823 
2824 #if 0
2825  typedef std::bidirectional_iterator_tag iterator_category;
2826  typedef std::ptrdiff_t difference_type;
2827  typedef const Mesh& mesh_ref;
2828  typedef const Mesh* mesh_ptr;
2829  typedef const typename Mesh::Edge& reference;
2830  typedef const typename Mesh::Edge* pointer;
2831 #else
2832  typedef std::bidirectional_iterator_tag iterator_category;
2833  typedef std::ptrdiff_t difference_type;
2834  typedef Mesh& mesh_ref;
2835  typedef Mesh* mesh_ptr;
2836  typedef typename Mesh::Edge& reference;
2837  typedef typename Mesh::Edge* pointer;
2838 #endif
2839 
2840 
2841 
2843  FaceEdgeIterT() : mesh_(0), lap_counter_(false) {}
2844 
2845 
2847  FaceEdgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
2848  mesh_(&_mesh),
2849  start_(_mesh.halfedge_handle(_start)),
2850  heh_(start_),
2851  lap_counter_(_end)
2852  { ; }
2853 
2854 
2856  FaceEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
2857  mesh_(&_mesh),
2858  start_(_heh),
2859  heh_(_heh),
2860  lap_counter_(_end)
2861  { ; }
2862 
2863 
2866  mesh_(_rhs.mesh_),
2867  start_(_rhs.start_),
2868  heh_(_rhs.heh_),
2869  lap_counter_(_rhs.lap_counter_)
2870  { ; }
2871 
2872 
2875  {
2876  mesh_ = _rhs.mesh_;
2877  start_ = _rhs.start_;
2878  heh_ = _rhs.heh_;
2879  lap_counter_ = _rhs.lap_counter_;
2880  return *this;
2881  }
2882 
2883 
2884 #if 0
2885 
2886  FaceEdgeIterT(const FaceEdgeIterT<Mesh>& _rhs) :
2887  mesh_(_rhs.mesh_),
2888  start_(_rhs.start_),
2889  heh_(_rhs.heh_),
2890  lap_counter_(_rhs.lap_counter_)
2891  { ; }
2892 
2893 
2895  FaceEdgeIterT& operator=(const FaceEdgeIterT<Mesh>& _rhs)
2896  {
2897  mesh_ = _rhs.mesh_;
2898  start_ = _rhs.start_;
2899  heh_ = _rhs.heh_;
2900  lap_counter_ = _rhs.lap_counter_;
2901  return *this;
2902  }
2903 #else
2904  friend class ConstFaceEdgeIterT<Mesh>;
2905 #endif
2906 
2907 
2909  bool operator==(const FaceEdgeIterT& _rhs) const {
2910  return ((mesh_ == _rhs.mesh_) &&
2911  (start_ == _rhs.start_) &&
2912  (heh_ == _rhs.heh_) &&
2913  (lap_counter_ == _rhs.lap_counter_));
2914  }
2915 
2916 
2918  bool operator!=(const FaceEdgeIterT& _rhs) const {
2919  return !operator==(_rhs);
2920  }
2921 
2922 
2925  assert(mesh_);
2926  heh_=mesh_->next_halfedge_handle(heh_);
2927  if(heh_ == start_) lap_counter_++;
2928  return *this;
2929  }
2930 
2931 
2934  assert(mesh_);
2935  if(heh_ == start_) lap_counter_--;
2936  heh_=mesh_->prev_halfedge_handle(heh_);
2937  return *this;
2938  }
2939 
2940 
2945  HalfedgeHandle current_halfedge_handle() const {
2946  return heh_;
2947  }
2948 
2949 
2951  typename Mesh::EdgeHandle handle() const {
2952  assert(mesh_);
2953  return mesh_->edge_handle(heh_);
2954  }
2955 
2956 
2958  operator typename Mesh::EdgeHandle() const {
2959  assert(mesh_);
2960  return mesh_->edge_handle(heh_);
2961  }
2962 
2963 
2965  reference operator*() const {
2966  assert(mesh_);
2967  return mesh_->deref(handle());
2968  }
2969 
2970 
2972  pointer operator->() const {
2973  assert(mesh_);
2974  return &mesh_->deref(handle());
2975  }
2976 
2977 
2984  operator bool() const {
2985  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
2986  }
2987 
2988 
2989 protected:
2990 
2991  mesh_ptr mesh_;
2992  HalfedgeHandle start_, heh_;
2993  int lap_counter_;
2994 };
2995 
2996 
2997 
2998 //== CLASS DEFINITION =========================================================
2999 
3000 
3005 template <class Mesh>
3007 {
3008  public:
3009 
3010 
3011  //--- Typedefs ---
3012 
3013  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
3014 
3015  typedef typename Mesh::Edge value_type;
3016  typedef typename Mesh::EdgeHandle value_handle;
3017 
3018 #if 1
3019  typedef std::bidirectional_iterator_tag iterator_category;
3020  typedef std::ptrdiff_t difference_type;
3021  typedef const Mesh& mesh_ref;
3022  typedef const Mesh* mesh_ptr;
3023  typedef const typename Mesh::Edge& reference;
3024  typedef const typename Mesh::Edge* pointer;
3025 #else
3026  typedef std::bidirectional_iterator_tag iterator_category;
3027  typedef std::ptrdiff_t difference_type;
3028  typedef Mesh& mesh_ref;
3029  typedef Mesh* mesh_ptr;
3030  typedef typename Mesh::Edge& reference;
3031  typedef typename Mesh::Edge* pointer;
3032 #endif
3033 
3034 
3035 
3037  ConstFaceEdgeIterT() : mesh_(0), lap_counter_(false) {}
3038 
3039 
3041  ConstFaceEdgeIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
3042  mesh_(&_mesh),
3043  start_(_mesh.halfedge_handle(_start)),
3044  heh_(start_),
3045  lap_counter_(_end)
3046  { ; }
3047 
3048 
3050  ConstFaceEdgeIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
3051  mesh_(&_mesh),
3052  start_(_heh),
3053  heh_(_heh),
3054  lap_counter_(_end)
3055  { ; }
3056 
3057 
3060  mesh_(_rhs.mesh_),
3061  start_(_rhs.start_),
3062  heh_(_rhs.heh_),
3063  lap_counter_(_rhs.lap_counter_)
3064  { ; }
3065 
3066 
3069  {
3070  mesh_ = _rhs.mesh_;
3071  start_ = _rhs.start_;
3072  heh_ = _rhs.heh_;
3073  lap_counter_ = _rhs.lap_counter_;
3074  return *this;
3075  }
3076 
3077 
3078 #if 1
3079 
3081  mesh_(_rhs.mesh_),
3082  start_(_rhs.start_),
3083  heh_(_rhs.heh_),
3084  lap_counter_(_rhs.lap_counter_)
3085  { ; }
3086 
3087 
3090  {
3091  mesh_ = _rhs.mesh_;
3092  start_ = _rhs.start_;
3093  heh_ = _rhs.heh_;
3094  lap_counter_ = _rhs.lap_counter_;
3095  return *this;
3096  }
3097 #else
3098  friend class ConstFaceEdgeIterT<Mesh>;
3099 #endif
3100 
3101 
3103  bool operator==(const ConstFaceEdgeIterT& _rhs) const {
3104  return ((mesh_ == _rhs.mesh_) &&
3105  (start_ == _rhs.start_) &&
3106  (heh_ == _rhs.heh_) &&
3107  (lap_counter_ == _rhs.lap_counter_));
3108  }
3109 
3110 
3112  bool operator!=(const ConstFaceEdgeIterT& _rhs) const {
3113  return !operator==(_rhs);
3114  }
3115 
3116 
3119  assert(mesh_);
3120  heh_=mesh_->next_halfedge_handle(heh_);
3121  if(heh_ == start_) lap_counter_++;
3122  return *this;
3123  }
3124 
3125 
3128  assert(mesh_);
3129  if(heh_ == start_) lap_counter_--;
3130  heh_=mesh_->prev_halfedge_handle(heh_);
3131  return *this;
3132  }
3133 
3134 
3139  HalfedgeHandle current_halfedge_handle() const {
3140  return heh_;
3141  }
3142 
3143 
3145  typename Mesh::EdgeHandle handle() const {
3146  assert(mesh_);
3147  return mesh_->edge_handle(heh_);
3148  }
3149 
3150 
3152  operator typename Mesh::EdgeHandle() const {
3153  assert(mesh_);
3154  return mesh_->edge_handle(heh_);
3155  }
3156 
3157 
3159  reference operator*() const {
3160  assert(mesh_);
3161  return mesh_->deref(handle());
3162  }
3163 
3164 
3166  pointer operator->() const {
3167  assert(mesh_);
3168  return &mesh_->deref(handle());
3169  }
3170 
3171 
3178  operator bool() const {
3179  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
3180  }
3181 
3182 
3183 protected:
3184 
3185  mesh_ptr mesh_;
3186  HalfedgeHandle start_, heh_;
3187  int lap_counter_;
3188 };
3189 
3190 
3191 
3192 //== CLASS DEFINITION =========================================================
3193 
3194 
3199 template <class Mesh>
3201 {
3202  public:
3203 
3204 
3205  //--- Typedefs ---
3206 
3207  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
3208 
3209  typedef typename Mesh::Face value_type;
3210  typedef typename Mesh::FaceHandle value_handle;
3211 
3212 #if 0
3213  typedef std::bidirectional_iterator_tag iterator_category;
3214  typedef std::ptrdiff_t difference_type;
3215  typedef const Mesh& mesh_ref;
3216  typedef const Mesh* mesh_ptr;
3217  typedef const typename Mesh::Face& reference;
3218  typedef const typename Mesh::Face* pointer;
3219 #else
3220  typedef std::bidirectional_iterator_tag iterator_category;
3221  typedef std::ptrdiff_t difference_type;
3222  typedef Mesh& mesh_ref;
3223  typedef Mesh* mesh_ptr;
3224  typedef typename Mesh::Face& reference;
3225  typedef typename Mesh::Face* pointer;
3226 #endif
3227 
3228 
3229 
3231  FaceFaceIterT() : mesh_(0), lap_counter_(false) {}
3232 
3233 
3235  FaceFaceIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
3236  mesh_(&_mesh),
3237  start_(_mesh.halfedge_handle(_start)),
3238  heh_(start_),
3239  lap_counter_(_end)
3240  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
3241 
3242 
3244  FaceFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
3245  mesh_(&_mesh),
3246  start_(_heh),
3247  heh_(_heh),
3248  lap_counter_(_end)
3249  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
3250 
3251 
3254  mesh_(_rhs.mesh_),
3255  start_(_rhs.start_),
3256  heh_(_rhs.heh_),
3257  lap_counter_(_rhs.lap_counter_)
3258  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
3259 
3260 
3263  {
3264  mesh_ = _rhs.mesh_;
3265  start_ = _rhs.start_;
3266  heh_ = _rhs.heh_;
3267  lap_counter_ = _rhs.lap_counter_;
3268  return *this;
3269  }
3270 
3271 
3272 #if 0
3273 
3274  FaceFaceIterT(const FaceFaceIterT<Mesh>& _rhs) :
3275  mesh_(_rhs.mesh_),
3276  start_(_rhs.start_),
3277  heh_(_rhs.heh_),
3278  lap_counter_(_rhs.lap_counter_)
3279  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
3280 
3281 
3283  FaceFaceIterT& operator=(const FaceFaceIterT<Mesh>& _rhs)
3284  {
3285  mesh_ = _rhs.mesh_;
3286  start_ = _rhs.start_;
3287  heh_ = _rhs.heh_;
3288  lap_counter_ = _rhs.lap_counter_;
3289  return *this;
3290  }
3291 #else
3292  friend class ConstFaceFaceIterT<Mesh>;
3293 #endif
3294 
3295 
3297  bool operator==(const FaceFaceIterT& _rhs) const {
3298  return ((mesh_ == _rhs.mesh_) &&
3299  (start_ == _rhs.start_) &&
3300  (heh_ == _rhs.heh_) &&
3301  (lap_counter_ == _rhs.lap_counter_));
3302  }
3303 
3304 
3306  bool operator!=(const FaceFaceIterT& _rhs) const {
3307  return !operator==(_rhs);
3308  }
3309 
3310 
3313  assert(mesh_);
3314  do { heh_=mesh_->next_halfedge_handle(heh_); if(heh_ == start_) lap_counter_++; } while ((*this) && (!handle().is_valid()));
3315  return *this;
3316  }
3317 
3318 
3321  assert(mesh_);
3322  do { if(heh_ == start_) lap_counter_--; heh_=mesh_->prev_halfedge_handle(heh_); } while ((*this) && (!handle().is_valid()));
3323  return *this;
3324  }
3325 
3326 
3331  HalfedgeHandle current_halfedge_handle() const {
3332  return heh_;
3333  }
3334 
3335 
3337  typename Mesh::FaceHandle handle() const {
3338  assert(mesh_);
3339  return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
3340  }
3341 
3342 
3344  operator typename Mesh::FaceHandle() const {
3345  assert(mesh_);
3346  return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
3347  }
3348 
3349 
3351  reference operator*() const {
3352  assert(mesh_);
3353  return mesh_->deref(handle());
3354  }
3355 
3356 
3358  pointer operator->() const {
3359  assert(mesh_);
3360  return &mesh_->deref(handle());
3361  }
3362 
3363 
3370  operator bool() const {
3371  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
3372  }
3373 
3374 
3375 protected:
3376 
3377  mesh_ptr mesh_;
3378  HalfedgeHandle start_, heh_;
3379  int lap_counter_;
3380 };
3381 
3382 
3383 
3384 //== CLASS DEFINITION =========================================================
3385 
3386 
3391 template <class Mesh>
3393 {
3394  public:
3395 
3396 
3397  //--- Typedefs ---
3398 
3399  typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
3400 
3401  typedef typename Mesh::Face value_type;
3402  typedef typename Mesh::FaceHandle value_handle;
3403 
3404 #if 1
3405  typedef std::bidirectional_iterator_tag iterator_category;
3406  typedef std::ptrdiff_t difference_type;
3407  typedef const Mesh& mesh_ref;
3408  typedef const Mesh* mesh_ptr;
3409  typedef const typename Mesh::Face& reference;
3410  typedef const typename Mesh::Face* pointer;
3411 #else
3412  typedef std::bidirectional_iterator_tag iterator_category;
3413  typedef std::ptrdiff_t difference_type;
3414  typedef Mesh& mesh_ref;
3415  typedef Mesh* mesh_ptr;
3416  typedef typename Mesh::Face& reference;
3417  typedef typename Mesh::Face* pointer;
3418 #endif
3419 
3420 
3421 
3423  ConstFaceFaceIterT() : mesh_(0), lap_counter_(false) {}
3424 
3425 
3427  ConstFaceFaceIterT(mesh_ref _mesh, typename Mesh::FaceHandle _start, bool _end = false) :
3428  mesh_(&_mesh),
3429  start_(_mesh.halfedge_handle(_start)),
3430  heh_(start_),
3431  lap_counter_(_end)
3432  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
3433 
3434 
3436  ConstFaceFaceIterT(mesh_ref _mesh, HalfedgeHandle _heh, bool _end = false) :
3437  mesh_(&_mesh),
3438  start_(_heh),
3439  heh_(_heh),
3440  lap_counter_(_end)
3441  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
3442 
3443 
3446  mesh_(_rhs.mesh_),
3447  start_(_rhs.start_),
3448  heh_(_rhs.heh_),
3449  lap_counter_(_rhs.lap_counter_)
3450  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
3451 
3452 
3455  {
3456  mesh_ = _rhs.mesh_;
3457  start_ = _rhs.start_;
3458  heh_ = _rhs.heh_;
3459  lap_counter_ = _rhs.lap_counter_;
3460  return *this;
3461  }
3462 
3463 
3464 #if 1
3465 
3467  mesh_(_rhs.mesh_),
3468  start_(_rhs.start_),
3469  heh_(_rhs.heh_),
3470  lap_counter_(_rhs.lap_counter_)
3471  { if (heh_.is_valid() && !handle().is_valid()) operator++();; }
3472 
3473 
3476  {
3477  mesh_ = _rhs.mesh_;
3478  start_ = _rhs.start_;
3479  heh_ = _rhs.heh_;
3480  lap_counter_ = _rhs.lap_counter_;
3481  return *this;
3482  }
3483 #else
3484  friend class ConstFaceFaceIterT<Mesh>;
3485 #endif
3486 
3487 
3489  bool operator==(const ConstFaceFaceIterT& _rhs) const {
3490  return ((mesh_ == _rhs.mesh_) &&
3491  (start_ == _rhs.start_) &&
3492  (heh_ == _rhs.heh_) &&
3493  (lap_counter_ == _rhs.lap_counter_));
3494  }
3495 
3496 
3498  bool operator!=(const ConstFaceFaceIterT& _rhs) const {
3499  return !operator==(_rhs);
3500  }
3501 
3502 
3505  assert(mesh_);
3506  do { heh_=mesh_->next_halfedge_handle(heh_); if(heh_ == start_) lap_counter_++; } while ((*this) && (!handle().is_valid()));;
3507  return *this;
3508  }
3509 
3510 
3513  assert(mesh_);
3514  do { if(heh_ == start_) lap_counter_--; heh_=mesh_->prev_halfedge_handle(heh_); } while ((*this) && (!handle().is_valid()));;
3515  return *this;
3516  }
3517 
3518 
3523  HalfedgeHandle current_halfedge_handle() const {
3524  return heh_;
3525  }
3526 
3527 
3529  typename Mesh::FaceHandle handle() const {
3530  assert(mesh_);
3531  return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
3532  }
3533 
3534 
3536  operator typename Mesh::FaceHandle() const {
3537  assert(mesh_);
3538  return mesh_->face_handle(mesh_->opposite_halfedge_handle(heh_));
3539  }
3540 
3541 
3543  reference operator*() const {
3544  assert(mesh_);
3545  return mesh_->deref(handle());
3546  }
3547 
3548 
3550  pointer operator->() const {
3551  assert(mesh_);
3552  return &mesh_->deref(handle());
3553  }
3554 
3555 
3562  operator bool() const {
3563  return heh_.is_valid() && ((start_ != heh_) || (lap_counter_ == 0));
3564  }
3565 
3566 
3567 protected:
3568 
3569  mesh_ptr mesh_;
3570  HalfedgeHandle start_, heh_;
3571  int lap_counter_;
3572 };
3573 
3574 
3575 
3576 //=============================================================================
3577 } // namespace Iterators
3578 } // namespace OpenMesh
3579 //=============================================================================
3580 #endif
3581 //=============================================================================

acg pic Project OpenMesh, ©  Computer Graphics Group, RWTH Aachen. Documentation generated using doxygen .