OpenMesh
BaseKernel.hh
1 /* ========================================================================= *
2  * *
3  * OpenMesh *
4  * Copyright (c) 2001-2022, 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 
45 //=============================================================================
46 //
47 // CLASS BaseKernel
48 //
49 //=============================================================================
50 
51 
52 #ifndef OPENMESH_BASE_KERNEL_HH
53 #define OPENMESH_BASE_KERNEL_HH
54 
55 
56 //== INCLUDES =================================================================
57 
58 
59 #include <OpenMesh/Core/System/config.h>
60 // --------------------
61 #include <vector>
62 #include <string>
63 #include <algorithm>
64 #include <iosfwd>
65 // --------------------
66 #include <OpenMesh/Core/Utils/PropertyContainer.hh>
67 
68 
69 //== NAMESPACES ===============================================================
70 
71 
72 namespace OpenMesh {
73 
74 
75 //== CLASS DEFINITION =========================================================
76 
96 
97 class OPENMESHDLLEXPORT BaseKernel
98 {
99 public: //-------------------------------------------- constructor / destructor
100 
101  BaseKernel() {}
102  virtual ~BaseKernel() {
103  vprops_.clear();
104  eprops_.clear();
105  hprops_.clear();
106  fprops_.clear();
107  }
108 
109 
110 public: //-------------------------------------------------- add new properties
111 
113 
115 
140  template <class T>
141  void add_property( VPropHandleT<T>& _ph, const std::string& _name="<vprop>")
142  {
143  _ph = VPropHandleT<T>( vprops_.add(T(), _name) );
144  vprops_.resize(n_vertices());
145  }
146 
147  template <class T>
148  void add_property( HPropHandleT<T>& _ph, const std::string& _name="<hprop>")
149  {
150  _ph = HPropHandleT<T>( hprops_.add(T(), _name) );
151  hprops_.resize(n_halfedges());
152  }
153 
154  template <class T>
155  void add_property( EPropHandleT<T>& _ph, const std::string& _name="<eprop>")
156  {
157  _ph = EPropHandleT<T>( eprops_.add(T(), _name) );
158  eprops_.resize(n_edges());
159  }
160 
161  template <class T>
162  void add_property( FPropHandleT<T>& _ph, const std::string& _name="<fprop>")
163  {
164  _ph = FPropHandleT<T>( fprops_.add(T(), _name) );
165  fprops_.resize(n_faces());
166  }
167 
168  template <class T>
169  void add_property( MPropHandleT<T>& _ph, const std::string& _name="<mprop>")
170  {
171  _ph = MPropHandleT<T>( mprops_.add(T(), _name) );
172  mprops_.resize(1);
173  }
174 
176 
177 
178 public: //--------------------------------------------------- remove properties
179 
181 
182 
193  template <typename T>
195  {
196  if (_ph.is_valid())
197  vprops_.remove(_ph);
198  _ph.reset();
199  }
200 
201  template <typename T>
203  {
204  if (_ph.is_valid())
205  hprops_.remove(_ph);
206  _ph.reset();
207  }
208 
209  template <typename T>
211  {
212  if (_ph.is_valid())
213  eprops_.remove(_ph);
214  _ph.reset();
215  }
216 
217  template <typename T>
219  {
220  if (_ph.is_valid())
221  fprops_.remove(_ph);
222  _ph.reset();
223  }
224 
225  template <typename T>
227  {
228  if (_ph.is_valid())
229  mprops_.remove(_ph);
230  _ph.reset();
231  }
232 
234 
235 public: //------------------------------------------------ get handle from name
236 
238 
239 
253  template <class T>
255  const std::string& _name) const
256  {
257  return (_ph = VPropHandleT<T>(vprops_.handle(T(), _name))).is_valid();
258  }
259 
260  template <class T>
262  const std::string& _name) const
263  {
264  return (_ph = HPropHandleT<T>(hprops_.handle(T(), _name))).is_valid();
265  }
266 
267  template <class T>
269  const std::string& _name) const
270  {
271  return (_ph = EPropHandleT<T>(eprops_.handle(T(), _name))).is_valid();
272  }
273 
274  template <class T>
276  const std::string& _name) const
277  {
278  return (_ph = FPropHandleT<T>(fprops_.handle(T(), _name))).is_valid();
279  }
280 
281  template <class T>
283  const std::string& _name) const
284  {
285  return (_ph = MPropHandleT<T>(mprops_.handle(T(), _name))).is_valid();
286  }
287 
289 
290 public: //--------------------------------------------------- access properties
291 
293 
294 
309  template <class T>
311  return vprops_.property(_ph);
312  }
313  template <class T>
315  return vprops_.property(_ph);
316  }
317 
318  template <class T>
320  return hprops_.property(_ph);
321  }
322  template <class T>
324  return hprops_.property(_ph);
325  }
326 
327  template <class T>
329  return eprops_.property(_ph);
330  }
331  template <class T>
333  return eprops_.property(_ph);
334  }
335 
336  template <class T>
338  return fprops_.property(_ph);
339  }
340  template <class T>
342  return fprops_.property(_ph);
343  }
344 
345  template <class T>
347  return mprops_.property(_ph);
348  }
349  template <class T>
351  return mprops_.property(_ph);
352  }
353 
355 
356 public: //-------------------------------------------- access property elements
357 
359 
360 
367  template <class T>
368  typename VPropHandleT<T>::reference
370  return vprops_.property(_ph)[_vh.idx()];
371  }
372 
373  template <class T>
374  typename VPropHandleT<T>::const_reference
376  return vprops_.property(_ph)[_vh.idx()];
377  }
378 
379 
380  template <class T>
381  typename HPropHandleT<T>::reference
383  return hprops_.property(_ph)[_hh.idx()];
384  }
385 
386  template <class T>
387  typename HPropHandleT<T>::const_reference
389  return hprops_.property(_ph)[_hh.idx()];
390  }
391 
392 
393  template <class T>
394  typename EPropHandleT<T>::reference
396  return eprops_.property(_ph)[_eh.idx()];
397  }
398 
399  template <class T>
400  typename EPropHandleT<T>::const_reference
402  return eprops_.property(_ph)[_eh.idx()];
403  }
404 
405 
406  template <class T>
407  typename FPropHandleT<T>::reference
409  return fprops_.property(_ph)[_fh.idx()];
410  }
411 
412  template <class T>
413  typename FPropHandleT<T>::const_reference
415  return fprops_.property(_ph)[_fh.idx()];
416  }
417 
418 
419  template <class T>
420  typename MPropHandleT<T>::reference
422  return mprops_.property(_ph)[0];
423  }
424 
425  template <class T>
426  typename MPropHandleT<T>::const_reference
428  return mprops_.property(_ph)[0];
429  }
430 
432 
433 
434 public: //------------------------------------------------ copy property
435 
446  template <class T>
448  if(_vh_from.is_valid() && _vh_to.is_valid())
449  vprops_.property(_ph)[_vh_to.idx()] = vprops_.property(_ph)[_vh_from.idx()];
450  }
451 
462  template <class T>
464  if(_hh_from.is_valid() && _hh_to.is_valid())
465  hprops_.property(_ph)[_hh_to.idx()] = hprops_.property(_ph)[_hh_from.idx()];
466  }
467 
478  template <class T>
479  void copy_property(EPropHandleT<T> _ph, EdgeHandle _eh_from, EdgeHandle _eh_to) {
480  if(_eh_from.is_valid() && _eh_to.is_valid())
481  eprops_.property(_ph)[_eh_to.idx()] = eprops_.property(_ph)[_eh_from.idx()];
482  }
483 
494  template <class T>
495  void copy_property(FPropHandleT<T> _ph, FaceHandle _fh_from, FaceHandle _fh_to) {
496  if(_fh_from.is_valid() && _fh_to.is_valid())
497  fprops_.property(_ph)[_fh_to.idx()] = fprops_.property(_ph)[_fh_from.idx()];
498  }
499 
500 
501 public:
502  //------------------------------------------------ copy all properties
503 
511  void copy_all_properties(VertexHandle _vh_from, VertexHandle _vh_to, bool _copyBuildIn = false) {
512 
513  for( PropertyContainer::iterator p_it = vprops_.begin();
514  p_it != vprops_.end(); ++p_it) {
515 
516  // Copy all properties, if build in is true
517  // Otherwise, copy only properties without build in specifier
518  if ( *p_it && ( _copyBuildIn || (*p_it)->name().substr(0,2) != "v:" ) )
519  (*p_it)->copy(static_cast<size_t>(_vh_from.idx()), static_cast<size_t>(_vh_to.idx()));
520 
521  }
522  }
523 
530  void copy_all_properties(HalfedgeHandle _hh_from, HalfedgeHandle _hh_to, bool _copyBuildIn = false) {
531 
532  for( PropertyContainer::iterator p_it = hprops_.begin();
533  p_it != hprops_.end(); ++p_it) {
534 
535  // Copy all properties, if build in is true
536  // Otherwise, copy only properties without build in specifier
537  if ( *p_it && ( _copyBuildIn || (*p_it)->name().substr(0,2) != "h:") )
538  (*p_it)->copy(_hh_from.idx(), _hh_to.idx());
539 
540  }
541  }
542 
549  void copy_all_properties(EdgeHandle _eh_from, EdgeHandle _eh_to, bool _copyBuildIn = false) {
550  for( PropertyContainer::iterator p_it = eprops_.begin();
551  p_it != eprops_.end(); ++p_it) {
552 
553  // Copy all properties, if build in is true
554  // Otherwise, copy only properties without build in specifier
555  if ( *p_it && ( _copyBuildIn || (*p_it)->name().substr(0,2) != "e:") )
556  (*p_it)->copy(_eh_from.idx(), _eh_to.idx());
557 
558  }
559  }
560 
568  void copy_all_properties(FaceHandle _fh_from, FaceHandle _fh_to, bool _copyBuildIn = false) {
569 
570  for( PropertyContainer::iterator p_it = fprops_.begin();
571  p_it != fprops_.end(); ++p_it) {
572 
573  // Copy all properties, if build in is true
574  // Otherwise, copy only properties without build in specifier
575  if ( *p_it && ( _copyBuildIn || (*p_it)->name().substr(0,2) != "f:") )
576  (*p_it)->copy(_fh_from.idx(), _fh_to.idx());
577  }
578 
579  }
580 
586  {
587  this->vprops_ = _other.vprops_;
588  this->eprops_ = _other.eprops_;
589  this->hprops_ = _other.hprops_;
590  this->fprops_ = _other.fprops_;
591  }
592 
593 protected: //------------------------------------------------- low-level access
594 
595 public: // used by non-native kernel and MeshIO, should be protected
596 
597  size_t n_vprops(void) const { return vprops_.size(); }
598 
599  size_t n_eprops(void) const { return eprops_.size(); }
600 
601  size_t n_hprops(void) const { return hprops_.size(); }
602 
603  size_t n_fprops(void) const { return fprops_.size(); }
604 
605  size_t n_mprops(void) const { return mprops_.size(); }
606 
607  BaseProperty* _get_vprop( const std::string& _name)
608  { return vprops_.property(_name); }
609 
610  BaseProperty* _get_eprop( const std::string& _name)
611  { return eprops_.property(_name); }
612 
613  BaseProperty* _get_hprop( const std::string& _name)
614  { return hprops_.property(_name); }
615 
616  BaseProperty* _get_fprop( const std::string& _name)
617  { return fprops_.property(_name); }
618 
619  BaseProperty* _get_mprop( const std::string& _name)
620  { return mprops_.property(_name); }
621 
622  const BaseProperty* _get_vprop( const std::string& _name) const
623  { return vprops_.property(_name); }
624 
625  const BaseProperty* _get_eprop( const std::string& _name) const
626  { return eprops_.property(_name); }
627 
628  const BaseProperty* _get_hprop( const std::string& _name) const
629  { return hprops_.property(_name); }
630 
631  const BaseProperty* _get_fprop( const std::string& _name) const
632  { return fprops_.property(_name); }
633 
634  const BaseProperty* _get_mprop( const std::string& _name) const
635  { return mprops_.property(_name); }
636 
637  BaseProperty& _vprop( size_t _idx ) { return vprops_._property( _idx ); }
638  BaseProperty& _eprop( size_t _idx ) { return eprops_._property( _idx ); }
639  BaseProperty& _hprop( size_t _idx ) { return hprops_._property( _idx ); }
640  BaseProperty& _fprop( size_t _idx ) { return fprops_._property( _idx ); }
641  BaseProperty& _mprop( size_t _idx ) { return mprops_._property( _idx ); }
642 
643  const BaseProperty& _vprop( size_t _idx ) const
644  { return vprops_._property( _idx ); }
645  const BaseProperty& _eprop( size_t _idx ) const
646  { return eprops_._property( _idx ); }
647  const BaseProperty& _hprop( size_t _idx ) const
648  { return hprops_._property( _idx ); }
649  const BaseProperty& _fprop( size_t _idx ) const
650  { return fprops_._property( _idx ); }
651  const BaseProperty& _mprop( size_t _idx ) const
652  { return mprops_._property( _idx ); }
653 
654  size_t _add_vprop( BaseProperty* _bp ) { return vprops_._add( _bp ); }
655  size_t _add_eprop( BaseProperty* _bp ) { return eprops_._add( _bp ); }
656  size_t _add_hprop( BaseProperty* _bp ) { return hprops_._add( _bp ); }
657  size_t _add_fprop( BaseProperty* _bp ) { return fprops_._add( _bp ); }
658  size_t _add_mprop( BaseProperty* _bp ) { return mprops_._add( _bp ); }
659 
660 protected: // low-level access non-public
661 
663  { return vprops_._property( _h.idx() ); }
665  { return eprops_._property( _h.idx() ); }
667  { return hprops_._property( _h.idx() ); }
669  { return fprops_._property( _h.idx() ); }
671  { return mprops_._property( _h.idx() ); }
672 
673  const BaseProperty& _vprop( BaseHandle _h ) const
674  { return vprops_._property( _h.idx() ); }
675  const BaseProperty& _eprop( BaseHandle _h ) const
676  { return eprops_._property( _h.idx() ); }
677  const BaseProperty& _hprop( BaseHandle _h ) const
678  { return hprops_._property( _h.idx() ); }
679  const BaseProperty& _fprop( BaseHandle _h ) const
680  { return fprops_._property( _h.idx() ); }
681  const BaseProperty& _mprop( BaseHandle _h ) const
682  { return mprops_._property( _h.idx() ); }
683 
684 
685 public: //----------------------------------------------------- element numbers
686 
687 
688  virtual size_t n_vertices() const { return 0; }
689  virtual size_t n_halfedges() const { return 0; }
690  virtual size_t n_edges() const { return 0; }
691  virtual size_t n_faces() const { return 0; }
692 
693  template <typename HandleT>
694  size_t n_elements() const;
695 
696 
697 protected: //------------------------------------------- synchronize properties
698 
700  void vprops_reserve(size_t _n) const { vprops_.reserve(_n); }
701 
703  void vprops_resize(size_t _n) const { vprops_.resize(_n); }
704 
713  void vprops_resize_if_smaller(size_t _n) const { vprops_.resize_if_smaller(_n); }
714 
715  void vprops_clear() {
716  vprops_.clear();
717  }
718 
719  void vprops_swap(unsigned int _i0, unsigned int _i1) const {
720  vprops_.swap(_i0, _i1);
721  }
722 
723  void hprops_reserve(size_t _n) const { hprops_.reserve(_n); }
724  void hprops_resize(size_t _n) const { hprops_.resize(_n); }
725  void hprops_clear() {
726  hprops_.clear();
727  }
728  void hprops_swap(unsigned int _i0, unsigned int _i1) const {
729  hprops_.swap(_i0, _i1);
730  }
731 
732  void eprops_reserve(size_t _n) const { eprops_.reserve(_n); }
733  void eprops_resize(size_t _n) const { eprops_.resize(_n); }
734  void eprops_clear() {
735  eprops_.clear();
736  }
737  void eprops_swap(unsigned int _i0, unsigned int _i1) const {
738  eprops_.swap(_i0, _i1);
739  }
740 
741  void fprops_reserve(size_t _n) const { fprops_.reserve(_n); }
742  void fprops_resize(size_t _n) const { fprops_.resize(_n); }
743  void fprops_clear() {
744  fprops_.clear();
745  }
746  void fprops_swap(unsigned int _i0, unsigned int _i1) const {
747  fprops_.swap(_i0, _i1);
748  }
749 
750  void mprops_resize(size_t _n) const { mprops_.resize(_n); }
751  void mprops_clear() {
752  mprops_.clear();
753  }
754 
755 public:
756 
757  // uses std::clog as output stream
758  void property_stats() const;
759  void property_stats(std::ostream& _ostr) const;
760 
761  void vprop_stats( std::string& _string ) const;
762  void hprop_stats( std::string& _string ) const;
763  void eprop_stats( std::string& _string ) const;
764  void fprop_stats( std::string& _string ) const;
765  void mprop_stats( std::string& _string ) const;
766 
767  // uses std::clog as output stream
768  void vprop_stats() const;
769  void hprop_stats() const;
770  void eprop_stats() const;
771  void fprop_stats() const;
772  void mprop_stats() const;
773 
774  void vprop_stats(std::ostream& _ostr) const;
775  void hprop_stats(std::ostream& _ostr) const;
776  void eprop_stats(std::ostream& _ostr) const;
777  void fprop_stats(std::ostream& _ostr) const;
778  void mprop_stats(std::ostream& _ostr) const;
779 
780 public:
781 
782  typedef PropertyContainer::iterator prop_iterator;
783  typedef PropertyContainer::const_iterator const_prop_iterator;
784 
785  prop_iterator vprops_begin() { return vprops_.begin(); }
786  prop_iterator vprops_end() { return vprops_.end(); }
787  const_prop_iterator vprops_begin() const { return vprops_.begin(); }
788  const_prop_iterator vprops_end() const { return vprops_.end(); }
789 
790  prop_iterator eprops_begin() { return eprops_.begin(); }
791  prop_iterator eprops_end() { return eprops_.end(); }
792  const_prop_iterator eprops_begin() const { return eprops_.begin(); }
793  const_prop_iterator eprops_end() const { return eprops_.end(); }
794 
795  prop_iterator hprops_begin() { return hprops_.begin(); }
796  prop_iterator hprops_end() { return hprops_.end(); }
797  const_prop_iterator hprops_begin() const { return hprops_.begin(); }
798  const_prop_iterator hprops_end() const { return hprops_.end(); }
799 
800  prop_iterator fprops_begin() { return fprops_.begin(); }
801  prop_iterator fprops_end() { return fprops_.end(); }
802  const_prop_iterator fprops_begin() const { return fprops_.begin(); }
803  const_prop_iterator fprops_end() const { return fprops_.end(); }
804 
805  prop_iterator mprops_begin() { return mprops_.begin(); }
806  prop_iterator mprops_end() { return mprops_.end(); }
807  const_prop_iterator mprops_begin() const { return mprops_.begin(); }
808  const_prop_iterator mprops_end() const { return mprops_.end(); }
809 
810 private:
811 
812  PropertyContainer vprops_;
813  PropertyContainer hprops_;
814  PropertyContainer eprops_;
815  PropertyContainer fprops_;
816  PropertyContainer mprops_;
817 };
818 
819 
820 template <>
821 inline size_t BaseKernel::n_elements<VertexHandle>() const { return n_vertices(); }
822 template <>
823 inline size_t BaseKernel::n_elements<HalfedgeHandle>() const { return n_halfedges(); }
824 template <>
825 inline size_t BaseKernel::n_elements<EdgeHandle>() const { return n_edges(); }
826 template <>
827 inline size_t BaseKernel::n_elements<FaceHandle>() const { return n_faces(); }
828 
829 
830 //=============================================================================
831 } // namespace OpenMesh
832 //=============================================================================
833 #endif // OPENMESH_BASE_KERNEL_HH defined
834 //=============================================================================
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:59
This class provides low-level property management like adding/removing properties and access to prope...
Definition: BaseKernel.hh:98
void vprops_clear()
You should not use this function directly.
Definition: BaseKernel.hh:715
PropertyContainer::iterator prop_iterator
You should not use this function directly.
Definition: BaseKernel.hh:782
prop_iterator mprops_begin()
You should not use this function directly.
Definition: BaseKernel.hh:805
void hprops_clear()
You should not use this function directly.
Definition: BaseKernel.hh:725
FPropHandleT< T >::reference property(FPropHandleT< T > _ph, FaceHandle _fh)
You should not use this function directly.
Definition: BaseKernel.hh:408
virtual size_t n_vertices() const
You should not use this function directly.
Definition: BaseKernel.hh:688
void remove_property(EPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:210
const BaseProperty & _vprop(BaseHandle _h) const
You should not use this function directly.
Definition: BaseKernel.hh:673
size_t n_eprops(void) const
You should not use this function directly.
Definition: BaseKernel.hh:599
BaseProperty & _vprop(size_t _idx)
You should not use this function directly.
Definition: BaseKernel.hh:637
const BaseProperty * _get_vprop(const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:622
prop_iterator vprops_end()
You should not use this function directly.
Definition: BaseKernel.hh:786
const BaseProperty & _fprop(size_t _idx) const
You should not use this function directly.
Definition: BaseKernel.hh:649
PropertyT< T > & property(FPropHandleT< T > _ph)
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:337
EPropHandleT< T >::const_reference property(EPropHandleT< T > _ph, EdgeHandle _eh) const
You should not use this function directly.
Definition: BaseKernel.hh:401
bool get_property_handle(HPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:261
bool get_property_handle(EPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:268
const BaseProperty & _fprop(BaseHandle _h) const
You should not use this function directly.
Definition: BaseKernel.hh:679
void remove_property(VPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:194
void add_property(MPropHandleT< T > &_ph, const std::string &_name="<mprop>")
You should not use this function directly.
Definition: BaseKernel.hh:169
BaseProperty & _fprop(BaseHandle _h)
You should not use this function directly.
Definition: BaseKernel.hh:668
size_t _add_eprop(BaseProperty *_bp)
You should not use this function directly.
Definition: BaseKernel.hh:655
prop_iterator vprops_begin()
You should not use this function directly.
Definition: BaseKernel.hh:785
MPropHandleT< T >::const_reference property(MPropHandleT< T > _ph) const
You should not use this function directly.
Definition: BaseKernel.hh:427
const_prop_iterator vprops_begin() const
You should not use this function directly.
Definition: BaseKernel.hh:787
void eprops_swap(unsigned int _i0, unsigned int _i1) const
You should not use this function directly.
Definition: BaseKernel.hh:737
void vprops_swap(unsigned int _i0, unsigned int _i1) const
You should not use this function directly.
Definition: BaseKernel.hh:719
size_t n_mprops(void) const
You should not use this function directly.
Definition: BaseKernel.hh:605
prop_iterator hprops_end()
You should not use this function directly.
Definition: BaseKernel.hh:796
PropertyT< T > & property(VPropHandleT< T > _ph)
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:310
const PropertyT< T > & property(EPropHandleT< T > _ph) const
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:332
const BaseProperty & _mprop(size_t _idx) const
You should not use this function directly.
Definition: BaseKernel.hh:651
BaseProperty & _hprop(BaseHandle _h)
You should not use this function directly.
Definition: BaseKernel.hh:666
const BaseProperty * _get_fprop(const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:631
prop_iterator hprops_begin()
You should not use this function directly.
Definition: BaseKernel.hh:795
BaseProperty * _get_eprop(const std::string &_name)
You should not use this function directly.
Definition: BaseKernel.hh:610
const BaseProperty * _get_mprop(const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:634
size_t n_vprops(void) const
You should not use this function directly.
Definition: BaseKernel.hh:597
BaseProperty * _get_fprop(const std::string &_name)
You should not use this function directly.
Definition: BaseKernel.hh:616
const BaseProperty * _get_hprop(const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:628
void copy_property(EPropHandleT< T > _ph, EdgeHandle _eh_from, EdgeHandle _eh_to)
You should not use this function directly.
Definition: BaseKernel.hh:479
virtual size_t n_halfedges() const
You should not use this function directly.
Definition: BaseKernel.hh:689
const BaseProperty & _mprop(BaseHandle _h) const
You should not use this function directly.
Definition: BaseKernel.hh:681
void remove_property(HPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:202
const_prop_iterator fprops_end() const
You should not use this function directly.
Definition: BaseKernel.hh:803
void hprops_resize(size_t _n) const
You should not use this function directly.
Definition: BaseKernel.hh:724
const_prop_iterator vprops_end() const
You should not use this function directly.
Definition: BaseKernel.hh:788
const BaseProperty & _hprop(size_t _idx) const
You should not use this function directly.
Definition: BaseKernel.hh:647
EPropHandleT< T >::reference property(EPropHandleT< T > _ph, EdgeHandle _eh)
You should not use this function directly.
Definition: BaseKernel.hh:395
const PropertyT< T > & mproperty(MPropHandleT< T > _ph) const
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:350
const_prop_iterator eprops_begin() const
You should not use this function directly.
Definition: BaseKernel.hh:792
void vprops_resize_if_smaller(size_t _n) const
Same as vprops_resize() but ignores vertex property vectors that have a size larger than _n.
Definition: BaseKernel.hh:713
MPropHandleT< T >::reference property(MPropHandleT< T > _ph)
You should not use this function directly.
Definition: BaseKernel.hh:421
void remove_property(FPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:218
BaseProperty & _mprop(size_t _idx)
You should not use this function directly.
Definition: BaseKernel.hh:641
void copy_all_kernel_properties(const BaseKernel &_other)
copy_all_kernel_properties uses the = operator to copy all properties from a given other BaseKernel.
Definition: BaseKernel.hh:585
void copy_all_properties(EdgeHandle _eh_from, EdgeHandle _eh_to, bool _copyBuildIn=false)
Copies all properties from one mesh element to another (of the same type)
Definition: BaseKernel.hh:549
const BaseProperty & _eprop(BaseHandle _h) const
You should not use this function directly.
Definition: BaseKernel.hh:675
void fprops_clear()
You should not use this function directly.
Definition: BaseKernel.hh:743
size_t n_hprops(void) const
You should not use this function directly.
Definition: BaseKernel.hh:601
size_t _add_vprop(BaseProperty *_bp)
You should not use this function directly.
Definition: BaseKernel.hh:654
const_prop_iterator hprops_begin() const
You should not use this function directly.
Definition: BaseKernel.hh:797
virtual size_t n_edges() const
You should not use this function directly.
Definition: BaseKernel.hh:690
BaseProperty & _eprop(BaseHandle _h)
You should not use this function directly.
Definition: BaseKernel.hh:664
BaseProperty & _mprop(BaseHandle _h)
You should not use this function directly.
Definition: BaseKernel.hh:670
VPropHandleT< T >::reference property(VPropHandleT< T > _ph, VertexHandle _vh)
You should not use this function directly.
Definition: BaseKernel.hh:369
void vprops_reserve(size_t _n) const
Reserves space for _n elements in all vertex property vectors.
Definition: BaseKernel.hh:700
const PropertyT< T > & property(HPropHandleT< T > _ph) const
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:323
const_prop_iterator hprops_end() const
You should not use this function directly.
Definition: BaseKernel.hh:798
prop_iterator fprops_begin()
You should not use this function directly.
Definition: BaseKernel.hh:800
PropertyT< T > & mproperty(MPropHandleT< T > _ph)
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:346
void copy_all_properties(FaceHandle _fh_from, FaceHandle _fh_to, bool _copyBuildIn=false)
Copies all properties from one mesh element to another (of the same type)
Definition: BaseKernel.hh:568
void hprops_swap(unsigned int _i0, unsigned int _i1) const
You should not use this function directly.
Definition: BaseKernel.hh:728
BaseProperty * _get_mprop(const std::string &_name)
You should not use this function directly.
Definition: BaseKernel.hh:619
bool get_property_handle(MPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:282
const PropertyT< T > & property(FPropHandleT< T > _ph) const
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:341
const_prop_iterator eprops_end() const
You should not use this function directly.
Definition: BaseKernel.hh:793
void fprops_resize(size_t _n) const
You should not use this function directly.
Definition: BaseKernel.hh:742
size_t _add_hprop(BaseProperty *_bp)
You should not use this function directly.
Definition: BaseKernel.hh:656
const BaseProperty * _get_eprop(const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:625
prop_iterator mprops_end()
You should not use this function directly.
Definition: BaseKernel.hh:806
BaseProperty & _fprop(size_t _idx)
You should not use this function directly.
Definition: BaseKernel.hh:640
void add_property(VPropHandleT< T > &_ph, const std::string &_name="<vprop>")
You should not use this function directly.
Definition: BaseKernel.hh:141
const_prop_iterator fprops_begin() const
You should not use this function directly.
Definition: BaseKernel.hh:802
HPropHandleT< T >::reference property(HPropHandleT< T > _ph, HalfedgeHandle _hh)
You should not use this function directly.
Definition: BaseKernel.hh:382
BaseProperty * _get_vprop(const std::string &_name)
You should not use this function directly.
Definition: BaseKernel.hh:607
prop_iterator eprops_begin()
You should not use this function directly.
Definition: BaseKernel.hh:790
PropertyT< T > & property(EPropHandleT< T > _ph)
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:328
void mprops_clear()
You should not use this function directly.
Definition: BaseKernel.hh:751
const BaseProperty & _eprop(size_t _idx) const
You should not use this function directly.
Definition: BaseKernel.hh:645
const_prop_iterator mprops_end() const
You should not use this function directly.
Definition: BaseKernel.hh:808
void eprops_resize(size_t _n) const
You should not use this function directly.
Definition: BaseKernel.hh:733
virtual size_t n_faces() const
You should not use this function directly.
Definition: BaseKernel.hh:691
BaseProperty & _vprop(BaseHandle _h)
You should not use this function directly.
Definition: BaseKernel.hh:662
void copy_all_properties(VertexHandle _vh_from, VertexHandle _vh_to, bool _copyBuildIn=false)
Copies all properties from one mesh element to another (of the same type)
Definition: BaseKernel.hh:511
void fprops_reserve(size_t _n) const
You should not use this function directly.
Definition: BaseKernel.hh:741
VPropHandleT< T >::const_reference property(VPropHandleT< T > _ph, VertexHandle _vh) const
You should not use this function directly.
Definition: BaseKernel.hh:375
void copy_all_properties(HalfedgeHandle _hh_from, HalfedgeHandle _hh_to, bool _copyBuildIn=false)
Copies all properties from one mesh element to another (of the same type)
Definition: BaseKernel.hh:530
BaseProperty & _hprop(size_t _idx)
You should not use this function directly.
Definition: BaseKernel.hh:639
BaseProperty & _eprop(size_t _idx)
You should not use this function directly.
Definition: BaseKernel.hh:638
void fprops_swap(unsigned int _i0, unsigned int _i1) const
You should not use this function directly.
Definition: BaseKernel.hh:746
bool get_property_handle(VPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:254
PropertyT< T > & property(HPropHandleT< T > _ph)
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:319
HPropHandleT< T >::const_reference property(HPropHandleT< T > _ph, HalfedgeHandle _hh) const
You should not use this function directly.
Definition: BaseKernel.hh:388
bool get_property_handle(FPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:275
prop_iterator eprops_end()
You should not use this function directly.
Definition: BaseKernel.hh:791
FPropHandleT< T >::const_reference property(FPropHandleT< T > _ph, FaceHandle _fh) const
You should not use this function directly.
Definition: BaseKernel.hh:414
void remove_property(MPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:226
void eprops_clear()
You should not use this function directly.
Definition: BaseKernel.hh:734
PropertyContainer::const_iterator const_prop_iterator
You should not use this function directly.
Definition: BaseKernel.hh:783
void mprops_resize(size_t _n) const
You should not use this function directly.
Definition: BaseKernel.hh:750
const BaseProperty & _vprop(size_t _idx) const
You should not use this function directly.
Definition: BaseKernel.hh:643
void hprops_reserve(size_t _n) const
You should not use this function directly.
Definition: BaseKernel.hh:723
size_t _add_mprop(BaseProperty *_bp)
You should not use this function directly.
Definition: BaseKernel.hh:658
size_t _add_fprop(BaseProperty *_bp)
You should not use this function directly.
Definition: BaseKernel.hh:657
void add_property(FPropHandleT< T > &_ph, const std::string &_name="<fprop>")
You should not use this function directly.
Definition: BaseKernel.hh:162
void vprops_resize(size_t _n) const
Resizes all vertex property vectors to the specified size.
Definition: BaseKernel.hh:703
void add_property(HPropHandleT< T > &_ph, const std::string &_name="<hprop>")
You should not use this function directly.
Definition: BaseKernel.hh:148
void copy_property(VPropHandleT< T > &_ph, VertexHandle _vh_from, VertexHandle _vh_to)
You should not use this function directly.
Definition: BaseKernel.hh:447
void eprops_reserve(size_t _n) const
You should not use this function directly.
Definition: BaseKernel.hh:732
const_prop_iterator mprops_begin() const
You should not use this function directly.
Definition: BaseKernel.hh:807
const BaseProperty & _hprop(BaseHandle _h) const
You should not use this function directly.
Definition: BaseKernel.hh:677
BaseProperty * _get_hprop(const std::string &_name)
You should not use this function directly.
Definition: BaseKernel.hh:613
void copy_property(FPropHandleT< T > _ph, FaceHandle _fh_from, FaceHandle _fh_to)
You should not use this function directly.
Definition: BaseKernel.hh:495
void add_property(EPropHandleT< T > &_ph, const std::string &_name="<eprop>")
You should not use this function directly.
Definition: BaseKernel.hh:155
const PropertyT< T > & property(VPropHandleT< T > _ph) const
In most cases you should use the convenient PropertyManager wrapper and use of this function should n...
Definition: BaseKernel.hh:314
prop_iterator fprops_end()
You should not use this function directly.
Definition: BaseKernel.hh:801
void copy_property(HPropHandleT< T > _ph, HalfedgeHandle _hh_from, HalfedgeHandle _hh_to)
You should not use this function directly.
Definition: BaseKernel.hh:463
size_t n_elements() const
You should not use this function directly.
size_t n_fprops(void) const
You should not use this function directly.
Definition: BaseKernel.hh:603
Base class for all handle types.
Definition: Handles.hh:63
bool is_valid() const
The handle is valid iff the index is not negative.
Definition: Handles.hh:72
void reset()
reset handle to be invalid
Definition: Handles.hh:75
int idx() const
Get the underlying index of this handle.
Definition: Handles.hh:69
Handle for a vertex entity.
Definition: Handles.hh:121
Handle for a halfedge entity.
Definition: Handles.hh:128
Handle for a edge entity.
Definition: Handles.hh:135
Handle for a face entity.
Definition: Handles.hh:142
Abstract class defining the basic interface of a dynamic property.
Definition: BaseProperty.hh:61
Default property class for any type T.
Definition: Property.hh:93
Handle representing a vertex property.
Definition: Property.hh:417
Handle representing a halfedge property.
Definition: Property.hh:432
Handle representing an edge property.
Definition: Property.hh:447
Handle representing a face property.
Definition: Property.hh:462
Handle representing a mesh property.
Definition: Property.hh:477
A a container for properties.
Definition: PropertyContainer.hh:59

Project OpenMesh, ©  Visual Computing Institute, RWTH Aachen. Documentation generated using doxygen .