OpenMesh
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
ArrayKernel.hh
1 /* ========================================================================= *
2  * *
3  * OpenMesh *
4  * Copyright (c) 2001-2015, RWTH-Aachen University *
5  * Department of Computer Graphics and Multimedia *
6  * All rights reserved. *
7  * www.openmesh.org *
8  * *
9  *---------------------------------------------------------------------------*
10  * This file is part of OpenMesh. *
11  *---------------------------------------------------------------------------*
12  * *
13  * Redistribution and use in source and binary forms, with or without *
14  * modification, are permitted provided that the following conditions *
15  * are met: *
16  * *
17  * 1. Redistributions of source code must retain the above copyright notice, *
18  * this list of conditions and the following disclaimer. *
19  * *
20  * 2. Redistributions in binary form must reproduce the above copyright *
21  * notice, this list of conditions and the following disclaimer in the *
22  * documentation and/or other materials provided with the distribution. *
23  * *
24  * 3. Neither the name of the copyright holder nor the names of its *
25  * contributors may be used to endorse or promote products derived from *
26  * this software without specific prior written permission. *
27  * *
28  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
29  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
30  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
31  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
32  * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
33  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
34  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
35  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
36  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
37  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
38  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
39  * *
40  * ========================================================================= */
41 
42 /*===========================================================================*\
43  * *
44  * $Revision$ *
45  * $Date$ *
46  * *
47 \*===========================================================================*/
48 
49 
50 //=============================================================================
51 //
52 // CLASS ArrayKernel
53 //
54 //=============================================================================
55 
56 
57 #ifndef OPENMESH_ARRAY_KERNEL_HH
58 #define OPENMESH_ARRAY_KERNEL_HH
59 
60 
61 //== INCLUDES =================================================================
62 #include <vector>
63 
64 #include <OpenMesh/Core/System/config.h>
65 #include <OpenMesh/Core/Utils/GenProg.hh>
66 
67 #include <OpenMesh/Core/Mesh/ArrayItems.hh>
68 #include <OpenMesh/Core/Mesh/BaseKernel.hh>
69 #include <OpenMesh/Core/Mesh/Status.hh>
70 
71 //== NAMESPACES ===============================================================
72 namespace OpenMesh {
73 
74 
75 //== CLASS DEFINITION =========================================================
92 class OPENMESHDLLEXPORT ArrayKernel : public BaseKernel, public ArrayItems
93 {
94 public:
95 
96  // handles
106 
107 public:
108 
109  // --- constructor/destructor ---
110  ArrayKernel();
111  virtual ~ArrayKernel();
112 
119  void assign_connectivity(const ArrayKernel& _other);
120 
121  // --- handle -> item ---
122  VertexHandle handle(const Vertex& _v) const;
123 
124  HalfedgeHandle handle(const Halfedge& _he) const;
125 
126  EdgeHandle handle(const Edge& _e) const;
127 
128  FaceHandle handle(const Face& _f) const;
129 
130 
132  bool is_valid_handle(VertexHandle _vh) const;
133 
135  bool is_valid_handle(HalfedgeHandle _heh) const;
136 
138  bool is_valid_handle(EdgeHandle _eh) const;
139 
141  bool is_valid_handle(FaceHandle _fh) const;
142 
143 
144  // --- item -> handle ---
145  const Vertex& vertex(VertexHandle _vh) const
146  {
147  assert(is_valid_handle(_vh));
148  return vertices_[_vh.idx()];
149  }
150 
151  Vertex& vertex(VertexHandle _vh)
152  {
153  assert(is_valid_handle(_vh));
154  return vertices_[_vh.idx()];
155  }
156 
157  const Halfedge& halfedge(HalfedgeHandle _heh) const
158  {
159  assert(is_valid_handle(_heh));
160  return edges_[_heh.idx() >> 1].halfedges_[_heh.idx() & 1];
161  }
162 
163  Halfedge& halfedge(HalfedgeHandle _heh)
164  {
165  assert(is_valid_handle(_heh));
166  return edges_[_heh.idx() >> 1].halfedges_[_heh.idx() & 1];
167  }
168 
169  const Edge& edge(EdgeHandle _eh) const
170  {
171  assert(is_valid_handle(_eh));
172  return edges_[_eh.idx()];
173  }
174 
175  Edge& edge(EdgeHandle _eh)
176  {
177  assert(is_valid_handle(_eh));
178  return edges_[_eh.idx()];
179  }
180 
181  const Face& face(FaceHandle _fh) const
182  {
183  assert(is_valid_handle(_fh));
184  return faces_[_fh.idx()];
185  }
186 
187  Face& face(FaceHandle _fh)
188  {
189  assert(is_valid_handle(_fh));
190  return faces_[_fh.idx()];
191  }
192 
193  // --- get i'th items ---
194 
195  VertexHandle vertex_handle(unsigned int _i) const
196  { return (_i < n_vertices()) ? handle( vertices_[_i] ) : VertexHandle(); }
197 
198  HalfedgeHandle halfedge_handle(unsigned int _i) const
199  {
200  return (_i < n_halfedges()) ?
201  halfedge_handle(edge_handle(_i/2), _i%2) : HalfedgeHandle();
202  }
203 
204  EdgeHandle edge_handle(unsigned int _i) const
205  { return (_i < n_edges()) ? handle(edges_[_i]) : EdgeHandle(); }
206 
207  FaceHandle face_handle(unsigned int _i) const
208  { return (_i < n_faces()) ? handle(faces_[_i]) : FaceHandle(); }
209 
210 public:
211 
212  inline VertexHandle new_vertex()
213  {
214  vertices_.push_back(Vertex());
215  vprops_resize(n_vertices());//TODO:should it be push_back()?
216 
217  return handle(vertices_.back());
218  }
219 
220  inline HalfedgeHandle new_edge(VertexHandle _start_vh, VertexHandle _end_vh)
221  {
222 // assert(_start_vh != _end_vh);
223  edges_.push_back(Edge());
224  eprops_resize(n_edges());//TODO:should it be push_back()?
225  hprops_resize(n_halfedges());//TODO:should it be push_back()?
226 
227  EdgeHandle eh(handle(edges_.back()));
228  HalfedgeHandle heh0(halfedge_handle(eh, 0));
229  HalfedgeHandle heh1(halfedge_handle(eh, 1));
230  set_vertex_handle(heh0, _end_vh);
231  set_vertex_handle(heh1, _start_vh);
232  return heh0;
233  }
234 
235  inline FaceHandle new_face()
236  {
237  faces_.push_back(Face());
238  fprops_resize(n_faces());
239  return handle(faces_.back());
240  }
241 
242  inline FaceHandle new_face(const Face& _f)
243  {
244  faces_.push_back(_f);
245  fprops_resize(n_faces());
246  return handle(faces_.back());
247  }
248 
249 public:
250  // --- resize/reserve ---
251  void resize( size_t _n_vertices, size_t _n_edges, size_t _n_faces );
252  void reserve(size_t _n_vertices, size_t _n_edges, size_t _n_faces );
253 
254  // --- deletion ---
270  void garbage_collection(bool _v=true, bool _e=true, bool _f=true);
271 
289  template<typename std_API_Container_VHandlePointer,
290  typename std_API_Container_HHandlePointer,
291  typename std_API_Container_FHandlePointer>
292  void garbage_collection(std_API_Container_VHandlePointer& vh_to_update,
293  std_API_Container_HHandlePointer& hh_to_update,
294  std_API_Container_FHandlePointer& fh_to_update,
295  bool _v=true, bool _e=true, bool _f=true);
296 
301  void clear();
302 
307  void clean();
308 
309  // --- number of items ---
310  size_t n_vertices() const { return vertices_.size(); }
311  size_t n_halfedges() const { return 2*edges_.size(); }
312  size_t n_edges() const { return edges_.size(); }
313  size_t n_faces() const { return faces_.size(); }
314 
315  bool vertices_empty() const { return vertices_.empty(); }
316  bool halfedges_empty() const { return edges_.empty(); }
317  bool edges_empty() const { return edges_.empty(); }
318  bool faces_empty() const { return faces_.empty(); }
319 
320  // --- vertex connectivity ---
321 
322  HalfedgeHandle halfedge_handle(VertexHandle _vh) const
323  { return vertex(_vh).halfedge_handle_; }
324 
325  void set_halfedge_handle(VertexHandle _vh, HalfedgeHandle _heh)
326  {
327 // assert(is_valid_handle(_heh));
328  vertex(_vh).halfedge_handle_ = _heh;
329  }
330 
331  bool is_isolated(VertexHandle _vh) const
332  { return !halfedge_handle(_vh).is_valid(); }
333 
334  void set_isolated(VertexHandle _vh)
335  { vertex(_vh).halfedge_handle_.invalidate(); }
336 
337  unsigned int delete_isolated_vertices();
338 
339  // --- halfedge connectivity ---
340  VertexHandle to_vertex_handle(HalfedgeHandle _heh) const
341  { return halfedge(_heh).vertex_handle_; }
342 
343  VertexHandle from_vertex_handle(HalfedgeHandle _heh) const
344  { return to_vertex_handle(opposite_halfedge_handle(_heh)); }
345 
346  void set_vertex_handle(HalfedgeHandle _heh, VertexHandle _vh)
347  {
348 // assert(is_valid_handle(_vh));
349  halfedge(_heh).vertex_handle_ = _vh;
350  }
351 
352  FaceHandle face_handle(HalfedgeHandle _heh) const
353  { return halfedge(_heh).face_handle_; }
354 
355  void set_face_handle(HalfedgeHandle _heh, FaceHandle _fh)
356  {
357 // assert(is_valid_handle(_fh));
358  halfedge(_heh).face_handle_ = _fh;
359  }
360 
361  void set_boundary(HalfedgeHandle _heh)
362  { halfedge(_heh).face_handle_.invalidate(); }
363 
365  bool is_boundary(HalfedgeHandle _heh) const
366  { return !face_handle(_heh).is_valid(); }
367 
368  HalfedgeHandle next_halfedge_handle(HalfedgeHandle _heh) const
369  { return halfedge(_heh).next_halfedge_handle_; }
370 
371  void set_next_halfedge_handle(HalfedgeHandle _heh, HalfedgeHandle _nheh)
372  {
373  assert(is_valid_handle(_nheh));
374 // assert(to_vertex_handle(_heh) == from_vertex_handle(_nheh));
375  halfedge(_heh).next_halfedge_handle_ = _nheh;
376  set_prev_halfedge_handle(_nheh, _heh);
377  }
378 
379 
380  void set_prev_halfedge_handle(HalfedgeHandle _heh, HalfedgeHandle _pheh)
381  {
382  assert(is_valid_handle(_pheh));
383  set_prev_halfedge_handle(_heh, _pheh, HasPrevHalfedge());
384  }
385 
386  void set_prev_halfedge_handle(HalfedgeHandle _heh, HalfedgeHandle _pheh,
387  GenProg::TrueType)
388  { halfedge(_heh).prev_halfedge_handle_ = _pheh; }
389 
390  void set_prev_halfedge_handle(HalfedgeHandle /* _heh */, HalfedgeHandle /* _pheh */,
391  GenProg::FalseType)
392  {}
393 
394  HalfedgeHandle prev_halfedge_handle(HalfedgeHandle _heh) const
395  { return prev_halfedge_handle(_heh, HasPrevHalfedge() ); }
396 
397  HalfedgeHandle prev_halfedge_handle(HalfedgeHandle _heh, GenProg::TrueType) const
398  { return halfedge(_heh).prev_halfedge_handle_; }
399 
400  HalfedgeHandle prev_halfedge_handle(HalfedgeHandle _heh, GenProg::FalseType) const
401  {
402  if (is_boundary(_heh))
403  {//iterating around the vertex should be faster than iterating the boundary
404  HalfedgeHandle curr_heh(opposite_halfedge_handle(_heh));
405  HalfedgeHandle next_heh(next_halfedge_handle(curr_heh));
406  do
407  {
408  curr_heh = opposite_halfedge_handle(next_heh);
409  next_heh = next_halfedge_handle(curr_heh);
410  }
411  while (next_heh != _heh);
412  return curr_heh;
413  }
414  else
415  {
416  HalfedgeHandle heh(_heh);
417  HalfedgeHandle next_heh(next_halfedge_handle(heh));
418  while (next_heh != _heh) {
419  heh = next_heh;
420  next_heh = next_halfedge_handle(next_heh);
421  }
422  return heh;
423  }
424  }
425 
426 
427  HalfedgeHandle opposite_halfedge_handle(HalfedgeHandle _heh) const
428  { return HalfedgeHandle(_heh.idx() ^ 1); }
429 
430 
431  HalfedgeHandle ccw_rotated_halfedge_handle(HalfedgeHandle _heh) const
432  { return opposite_halfedge_handle(prev_halfedge_handle(_heh)); }
433 
434 
435  HalfedgeHandle cw_rotated_halfedge_handle(HalfedgeHandle _heh) const
436  { return next_halfedge_handle(opposite_halfedge_handle(_heh)); }
437 
438  // --- edge connectivity ---
439  HalfedgeHandle halfedge_handle(EdgeHandle _eh, unsigned int _i) const
440  {
441  assert(_i<=1);
442  return HalfedgeHandle((_eh.idx() << 1) + _i);
443  }
444 
445  EdgeHandle edge_handle(HalfedgeHandle _heh) const
446  { return EdgeHandle(_heh.idx() >> 1); }
447 
448  // --- face connectivity ---
449  HalfedgeHandle halfedge_handle(FaceHandle _fh) const
450  { return face(_fh).halfedge_handle_; }
451 
452  void set_halfedge_handle(FaceHandle _fh, HalfedgeHandle _heh)
453  {
454 // assert(is_valid_handle(_heh));
455  face(_fh).halfedge_handle_ = _heh;
456  }
457 
459  //------------------------------------------------------------ vertex status
460  const StatusInfo& status(VertexHandle _vh) const
461  { return property(vertex_status_, _vh); }
462 
463  StatusInfo& status(VertexHandle _vh)
464  { return property(vertex_status_, _vh); }
465 
466  //----------------------------------------------------------- halfedge status
467  const StatusInfo& status(HalfedgeHandle _hh) const
468  { return property(halfedge_status_, _hh); }
469 
470  StatusInfo& status(HalfedgeHandle _hh)
471  { return property(halfedge_status_, _hh); }
472 
473  //--------------------------------------------------------------- edge status
474  const StatusInfo& status(EdgeHandle _eh) const
475  { return property(edge_status_, _eh); }
476 
477  StatusInfo& status(EdgeHandle _eh)
478  { return property(edge_status_, _eh); }
479 
480  //--------------------------------------------------------------- face status
481  const StatusInfo& status(FaceHandle _fh) const
482  { return property(face_status_, _fh); }
483 
484  StatusInfo& status(FaceHandle _fh)
485  { return property(face_status_, _fh); }
486 
487  inline bool has_vertex_status() const
488  { return vertex_status_.is_valid(); }
489 
490  inline bool has_halfedge_status() const
491  { return halfedge_status_.is_valid(); }
492 
493  inline bool has_edge_status() const
494  { return edge_status_.is_valid(); }
495 
496  inline bool has_face_status() const
497  { return face_status_.is_valid(); }
498 
499  inline VertexStatusPropertyHandle vertex_status_pph() const
500  { return vertex_status_; }
501 
502  inline HalfedgeStatusPropertyHandle halfedge_status_pph() const
503  { return halfedge_status_; }
504 
505  inline EdgeStatusPropertyHandle edge_status_pph() const
506  { return edge_status_; }
507 
508  inline FaceStatusPropertyHandle face_status_pph() const
509  { return face_status_; }
510 
512  inline VertexStatusPropertyHandle status_pph(VertexHandle /*_hnd*/) const
513  { return vertex_status_pph(); }
514 
515  inline HalfedgeStatusPropertyHandle status_pph(HalfedgeHandle /*_hnd*/) const
516  { return halfedge_status_pph(); }
517 
518  inline EdgeStatusPropertyHandle status_pph(EdgeHandle /*_hnd*/) const
519  { return edge_status_pph(); }
520 
521  inline FaceStatusPropertyHandle status_pph(FaceHandle /*_hnd*/) const
522  { return face_status_pph(); }
523 
526  {
527  if (!refcount_vstatus_++)
528  add_property( vertex_status_, "v:status" );
529  }
530 
531  void request_halfedge_status()
532  {
533  if (!refcount_hstatus_++)
534  add_property( halfedge_status_, "h:status" );
535  }
536 
537  void request_edge_status()
538  {
539  if (!refcount_estatus_++)
540  add_property( edge_status_, "e:status" );
541  }
542 
543  void request_face_status()
544  {
545  if (!refcount_fstatus_++)
546  add_property( face_status_, "f:status" );
547  }
548 
551  {
552  if ((refcount_vstatus_ > 0) && (! --refcount_vstatus_))
553  remove_property(vertex_status_);
554  }
555 
556  void release_halfedge_status()
557  {
558  if ((refcount_hstatus_ > 0) && (! --refcount_hstatus_))
559  remove_property(halfedge_status_);
560  }
561 
562  void release_edge_status()
563  {
564  if ((refcount_estatus_ > 0) && (! --refcount_estatus_))
565  remove_property(edge_status_);
566  }
567 
568  void release_face_status()
569  {
570  if ((refcount_fstatus_ > 0) && (! --refcount_fstatus_))
571  remove_property(face_status_);
572  }
573 
575 
583  template <class HandleT>
585  {
586  public:
587  typedef HandleT Handle;
588 
589  protected:
590  ArrayKernel& kernel_;
591 
592  public:
593  const unsigned int bit_mask_;
594 
595  public:
596  StatusSetT(ArrayKernel& _kernel, const unsigned int _bit_mask)
597  : kernel_(_kernel), bit_mask_(_bit_mask)
598  {}
599 
600  ~StatusSetT()
601  {}
602 
603  inline bool is_in(Handle _hnd) const
604  { return kernel_.status(_hnd).is_bit_set(bit_mask_); }
605 
606  inline void insert(Handle _hnd)
607  { kernel_.status(_hnd).set_bit(bit_mask_); }
608 
609  inline void erase(Handle _hnd)
610  { kernel_.status(_hnd).unset_bit(bit_mask_); }
611 
613  size_t size() const
614  {
615  const int n = kernel_.status_pph(Handle()).is_valid() ?
616  (int)kernel_.property(kernel_.status_pph(Handle())).n_elements() : 0;
617 
618  size_t sz = 0;
619  for (int i = 0; i < n; ++i)
620  sz += (size_t)is_in(Handle(i));
621  return sz;
622  }
623 
625  void clear()
626  {
627  const int n = kernel_.status_pph(Handle()).is_valid() ?
628  (int)kernel_.property(kernel_.status_pph(Handle())).n_elements() : 0;
629 
630  for (int i = 0; i < n; ++i)
631  erase(Handle(i));
632  }
633  };
634 
635  friend class StatusSetT<VertexHandle>;
636  friend class StatusSetT<EdgeHandle>;
637  friend class StatusSetT<FaceHandle>;
638  friend class StatusSetT<HalfedgeHandle>;
639 
641  template <class HandleT>
642  class AutoStatusSetT : public StatusSetT<HandleT>
643  {
644  private:
645  typedef HandleT Handle;
646  typedef StatusSetT<Handle> Base;
647 
648  public:
649  AutoStatusSetT(ArrayKernel& _kernel)
650  : StatusSetT<Handle>(_kernel, _kernel.pop_bit_mask(Handle()))
651  { /*assert(size() == 0);*/ } //the set should be empty on creation
652 
653  ~AutoStatusSetT()
654  {
655  //assert(size() == 0);//the set should be empty on leave?
656  Base::kernel_.push_bit_mask(Handle(), Base::bit_mask_);
657  }
658  };
659 
660  friend class AutoStatusSetT<VertexHandle>;
661  friend class AutoStatusSetT<EdgeHandle>;
662  friend class AutoStatusSetT<FaceHandle>;
663  friend class AutoStatusSetT<HalfedgeHandle>;
664 
669 
671  template <class HandleT>
672  class ExtStatusSetT : public AutoStatusSetT<HandleT>
673  {
674  public:
675  typedef HandleT Handle;
677 
678  protected:
679  typedef std::vector<Handle> HandleContainer;
680  HandleContainer handles_;
681 
682  public:
683  typedef typename HandleContainer::iterator
684  iterator;
685  typedef typename HandleContainer::const_iterator
686  const_iterator;
687  public:
688  ExtStatusSetT(ArrayKernel& _kernel, size_t _capacity_hint = 0)
689  : Base(_kernel)
690  { handles_.reserve(_capacity_hint); }
691 
692  ~ExtStatusSetT()
693  { clear(); }
694 
695  // Complexity: O(1)
696  inline void insert(Handle _hnd)
697  {
698  if (!is_in(_hnd))
699  {
700  Base::insert(_hnd);
701  handles_.push_back(_hnd);
702  }
703  }
704 
706  inline void erase(Handle _hnd)
707  {
708  if (is_in(_hnd))
709  {
710  iterator it = std::find(begin(), end(), _hnd);
711  erase(it);
712  }
713  }
714 
716  inline void erase(iterator _it)
717  {
718  assert(_it != end() && is_in(*_it));
719  Base::erase(*_it);
720  *_it = handles_.back();
721  _it.pop_back();
722  }
723 
724  inline void clear()
725  {
726  for (iterator it = begin(); it != end(); ++it)
727  {
728  assert(is_in(*it));
729  Base::erase(*it);
730  }
731  handles_.clear();
732  }
733 
735  inline unsigned int size() const
736  { return handles_.size(); }
737  inline bool empty() const
738  { return handles_.empty(); }
739 
740  //Vector API
741  inline iterator begin()
742  { return handles_.begin(); }
743  inline const_iterator begin() const
744  { return handles_.begin(); }
745 
746  inline iterator end()
747  { return handles_.end(); }
748  inline const_iterator end() const
749  { return handles_.end(); }
750 
751  inline Handle& front()
752  { return handles_.front(); }
753  inline const Handle& front() const
754  { return handles_.front(); }
755 
756  inline Handle& back()
757  { return handles_.back(); }
758  inline const Handle& back() const
759  { return handles_.back(); }
760  };
761 
762  typedef ExtStatusSetT<FaceHandle> ExtFaceStatusSet;
763  typedef ExtStatusSetT<VertexHandle> ExtVertexStatusSet;
764  typedef ExtStatusSetT<EdgeHandle> ExtEdgeStatusSet;
765  typedef ExtStatusSetT<HalfedgeHandle> ExtHalfedgeStatusSet;
766 
767 private:
768  // iterators
769  typedef std::vector<Vertex> VertexContainer;
770  typedef std::vector<Edge> EdgeContainer;
771  typedef std::vector<Face> FaceContainer;
772  typedef VertexContainer::iterator KernelVertexIter;
773  typedef VertexContainer::const_iterator KernelConstVertexIter;
774  typedef EdgeContainer::iterator KernelEdgeIter;
775  typedef EdgeContainer::const_iterator KernelConstEdgeIter;
776  typedef FaceContainer::iterator KernelFaceIter;
777  typedef FaceContainer::const_iterator KernelConstFaceIter;
778  typedef std::vector<unsigned int> BitMaskContainer;
779 
780 
781  KernelVertexIter vertices_begin() { return vertices_.begin(); }
782  KernelConstVertexIter vertices_begin() const { return vertices_.begin(); }
783  KernelVertexIter vertices_end() { return vertices_.end(); }
784  KernelConstVertexIter vertices_end() const { return vertices_.end(); }
785 
786  KernelEdgeIter edges_begin() { return edges_.begin(); }
787  KernelConstEdgeIter edges_begin() const { return edges_.begin(); }
788  KernelEdgeIter edges_end() { return edges_.end(); }
789  KernelConstEdgeIter edges_end() const { return edges_.end(); }
790 
791  KernelFaceIter faces_begin() { return faces_.begin(); }
792  KernelConstFaceIter faces_begin() const { return faces_.begin(); }
793  KernelFaceIter faces_end() { return faces_.end(); }
794  KernelConstFaceIter faces_end() const { return faces_.end(); }
795 
797  inline BitMaskContainer& bit_masks(VertexHandle /*_dummy_hnd*/)
798  { return vertex_bit_masks_; }
799  inline BitMaskContainer& bit_masks(EdgeHandle /*_dummy_hnd*/)
800  { return edge_bit_masks_; }
801  inline BitMaskContainer& bit_masks(FaceHandle /*_dummy_hnd*/)
802  { return face_bit_masks_; }
803  inline BitMaskContainer& bit_masks(HalfedgeHandle /*_dummy_hnd*/)
804  { return halfedge_bit_masks_; }
805 
806  template <class Handle>
807  unsigned int pop_bit_mask(Handle _hnd)
808  {
809  assert(!bit_masks(_hnd).empty());//check if the client request too many status sets
810  unsigned int bit_mask = bit_masks(_hnd).back();
811  bit_masks(_hnd).pop_back();
812  return bit_mask;
813  }
814 
815  template <class Handle>
816  void push_bit_mask(Handle _hnd, unsigned int _bit_mask)
817  {
818  assert(std::find(bit_masks(_hnd).begin(), bit_masks(_hnd).end(), _bit_mask) ==
819  bit_masks(_hnd).end());//this mask should be not already used
820  bit_masks(_hnd).push_back(_bit_mask);
821  }
822 
823  void init_bit_masks(BitMaskContainer& _bmc);
824  void init_bit_masks();
825 
826 private:
827  VertexContainer vertices_;
828  EdgeContainer edges_;
829  FaceContainer faces_;
830 
831  VertexStatusPropertyHandle vertex_status_;
832  HalfedgeStatusPropertyHandle halfedge_status_;
833  EdgeStatusPropertyHandle edge_status_;
834  FaceStatusPropertyHandle face_status_;
835 
836  unsigned int refcount_vstatus_;
837  unsigned int refcount_hstatus_;
838  unsigned int refcount_estatus_;
839  unsigned int refcount_fstatus_;
840 
841  BitMaskContainer halfedge_bit_masks_;
842  BitMaskContainer edge_bit_masks_;
843  BitMaskContainer vertex_bit_masks_;
844  BitMaskContainer face_bit_masks_;
845 };
846 
847 
848 //=============================================================================
849 } // namespace OpenMesh
850 //=============================================================================
851 #if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_ARRAY_KERNEL_C)
852 # define OPENMESH_ARRAY_KERNEL_TEMPLATES
853 # include "ArrayKernelT.cc"
854 #endif
855 //=============================================================================
856 #endif // OPENMESH_ARRAY_KERNEL_HH defined
857 //=============================================================================
void release_vertex_status()
Status Release API.
Definition: ArrayKernel.hh:550
This class provides the basic property management like adding/removing properties and access to prope...
Definition: BaseKernel.hh:99
ExtStatusSet: A status set augmented with an array.
Definition: ArrayKernel.hh:672
PropertyT< T > & property(VPropHandleT< T > _ph)
Access a property.
Definition: BaseKernel.hh:294
int idx() const
Get the underlying index of this handle.
Definition: Handles.hh:74
void erase(iterator _it)
Complexity: O(1)
Definition: ArrayKernel.hh:716
Mesh kernel using arrays for mesh item storage.
Definition: ArrayKernel.hh:92
unsigned int size() const
Complexity: 0(1)
Definition: ArrayKernel.hh:735
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:64
VertexStatusPropertyHandle status_pph(VertexHandle) const
status property by handle
Definition: ArrayKernel.hh:512
AutoStatusSetT: A status set that automatically picks a status bit.
Definition: ArrayKernel.hh:642
const StatusInfo & status(VertexHandle _vh) const
Status Query API.
Definition: ArrayKernel.hh:460
size_t size() const
Note: 0(n) complexity.
Definition: ArrayKernel.hh:613
void erase(Handle _hnd)
Complexity: O(k), (k - number of the elements in the set)
Definition: ArrayKernel.hh:706
void clear()
Note: O(n) complexity.
Definition: ArrayKernel.hh:625
— StatusSet API —
Definition: ArrayKernel.hh:584
void request_vertex_status()
Status Request API.
Definition: ArrayKernel.hh:525
bool is_bit_set(unsigned int _s) const
is a certain bit set ?
Definition: Status.hh:162
void invalidate()
reset handle to be invalid
Definition: Handles.hh:82
Handle for a face entity.
Definition: Handles.hh:142
void unset_bit(unsigned int _s)
unset a certain bit
Definition: Status.hh:166
Handle for a vertex entity.
Definition: Handles.hh:121
Handle for a edge entity.
Definition: Handles.hh:135
bool is_boundary(HalfedgeHandle _heh) const
Is halfedge _heh a boundary halfedge (is its face handle invalid) ?
Definition: ArrayKernel.hh:365
Handle for a halfedge entity.
Definition: Handles.hh:128
Add status information to a base class.
Definition: Status.hh:99
void set_bit(unsigned int _s)
set a certain bit
Definition: Status.hh:164
bool is_valid() const
The handle is valid iff the index is not equal to -1.
Definition: Handles.hh:77

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