OpenMesh
BaseKernel.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 BaseKernel
53 //
54 //=============================================================================
55 
56 
57 #ifndef OPENMESH_BASE_KERNEL_HH
58 #define OPENMESH_BASE_KERNEL_HH
59 
60 
61 //== INCLUDES =================================================================
62 
63 
64 #include <OpenMesh/Core/System/config.h>
65 // --------------------
66 #include <vector>
67 #include <string>
68 #include <algorithm>
69 #include <iosfwd>
70 // --------------------
71 #include <OpenMesh/Core/Utils/PropertyContainer.hh>
72 
73 
74 //== NAMESPACES ===============================================================
75 
76 
77 namespace OpenMesh {
78 
79 
80 //== CLASS DEFINITION =========================================================
81 
101 
102 class OPENMESHDLLEXPORT BaseKernel
103 {
104 public: //-------------------------------------------- constructor / destructor
105 
106  BaseKernel() {}
107  virtual ~BaseKernel() {
108  vprops_.clear();
109  eprops_.clear();
110  hprops_.clear();
111  fprops_.clear();
112  }
113 
114 
115 public: //-------------------------------------------------- add new properties
116 
118 
120 
145  template <class T>
146  void add_property( VPropHandleT<T>& _ph, const std::string& _name="<vprop>")
147  {
148  _ph = VPropHandleT<T>( vprops_.add(T(), _name) );
149  vprops_.resize(n_vertices());
150  }
151 
152  template <class T>
153  void add_property( HPropHandleT<T>& _ph, const std::string& _name="<hprop>")
154  {
155  _ph = HPropHandleT<T>( hprops_.add(T(), _name) );
156  hprops_.resize(n_halfedges());
157  }
158 
159  template <class T>
160  void add_property( EPropHandleT<T>& _ph, const std::string& _name="<eprop>")
161  {
162  _ph = EPropHandleT<T>( eprops_.add(T(), _name) );
163  eprops_.resize(n_edges());
164  }
165 
166  template <class T>
167  void add_property( FPropHandleT<T>& _ph, const std::string& _name="<fprop>")
168  {
169  _ph = FPropHandleT<T>( fprops_.add(T(), _name) );
170  fprops_.resize(n_faces());
171  }
172 
173  template <class T>
174  void add_property( MPropHandleT<T>& _ph, const std::string& _name="<mprop>")
175  {
176  _ph = MPropHandleT<T>( mprops_.add(T(), _name) );
177  mprops_.resize(1);
178  }
179 
181 
182 
183 public: //--------------------------------------------------- remove properties
184 
186 
187 
198  template <typename T>
200  {
201  if (_ph.is_valid())
202  vprops_.remove(_ph);
203  _ph.reset();
204  }
205 
206  template <typename T>
208  {
209  if (_ph.is_valid())
210  hprops_.remove(_ph);
211  _ph.reset();
212  }
213 
214  template <typename T>
216  {
217  if (_ph.is_valid())
218  eprops_.remove(_ph);
219  _ph.reset();
220  }
221 
222  template <typename T>
224  {
225  if (_ph.is_valid())
226  fprops_.remove(_ph);
227  _ph.reset();
228  }
229 
230  template <typename T>
232  {
233  if (_ph.is_valid())
234  mprops_.remove(_ph);
235  _ph.reset();
236  }
237 
239 
240 public: //------------------------------------------------ get handle from name
241 
243 
244 
258  template <class T>
260  const std::string& _name) const
261  {
262  return (_ph = VPropHandleT<T>(vprops_.handle(T(), _name))).is_valid();
263  }
264 
265  template <class T>
267  const std::string& _name) const
268  {
269  return (_ph = HPropHandleT<T>(hprops_.handle(T(), _name))).is_valid();
270  }
271 
272  template <class T>
274  const std::string& _name) const
275  {
276  return (_ph = EPropHandleT<T>(eprops_.handle(T(), _name))).is_valid();
277  }
278 
279  template <class T>
281  const std::string& _name) const
282  {
283  return (_ph = FPropHandleT<T>(fprops_.handle(T(), _name))).is_valid();
284  }
285 
286  template <class T>
288  const std::string& _name) const
289  {
290  return (_ph = MPropHandleT<T>(mprops_.handle(T(), _name))).is_valid();
291  }
292 
294 
295 public: //--------------------------------------------------- access properties
296 
298 
299 
314  template <class T>
316  return vprops_.property(_ph);
317  }
318  template <class T>
320  return vprops_.property(_ph);
321  }
322 
323  template <class T>
325  return hprops_.property(_ph);
326  }
327  template <class T>
329  return hprops_.property(_ph);
330  }
331 
332  template <class T>
334  return eprops_.property(_ph);
335  }
336  template <class T>
338  return eprops_.property(_ph);
339  }
340 
341  template <class T>
343  return fprops_.property(_ph);
344  }
345  template <class T>
347  return fprops_.property(_ph);
348  }
349 
350  template <class T>
352  return mprops_.property(_ph);
353  }
354  template <class T>
356  return mprops_.property(_ph);
357  }
358 
360 
361 public: //-------------------------------------------- access property elements
362 
364 
365 
372  template <class T>
373  typename VPropHandleT<T>::reference
375  return vprops_.property(_ph)[_vh.idx()];
376  }
377 
378  template <class T>
379  typename VPropHandleT<T>::const_reference
381  return vprops_.property(_ph)[_vh.idx()];
382  }
383 
384 
385  template <class T>
386  typename HPropHandleT<T>::reference
388  return hprops_.property(_ph)[_hh.idx()];
389  }
390 
391  template <class T>
392  typename HPropHandleT<T>::const_reference
394  return hprops_.property(_ph)[_hh.idx()];
395  }
396 
397 
398  template <class T>
399  typename EPropHandleT<T>::reference
401  return eprops_.property(_ph)[_eh.idx()];
402  }
403 
404  template <class T>
405  typename EPropHandleT<T>::const_reference
407  return eprops_.property(_ph)[_eh.idx()];
408  }
409 
410 
411  template <class T>
412  typename FPropHandleT<T>::reference
414  return fprops_.property(_ph)[_fh.idx()];
415  }
416 
417  template <class T>
418  typename FPropHandleT<T>::const_reference
420  return fprops_.property(_ph)[_fh.idx()];
421  }
422 
423 
424  template <class T>
425  typename MPropHandleT<T>::reference
427  return mprops_.property(_ph)[0];
428  }
429 
430  template <class T>
431  typename MPropHandleT<T>::const_reference
433  return mprops_.property(_ph)[0];
434  }
435 
437 
438 
439 public: //------------------------------------------------ copy property
440 
451  template <class T>
453  if(_vh_from.is_valid() && _vh_to.is_valid())
454  vprops_.property(_ph)[_vh_to.idx()] = vprops_.property(_ph)[_vh_from.idx()];
455  }
456 
467  template <class T>
469  if(_hh_from.is_valid() && _hh_to.is_valid())
470  hprops_.property(_ph)[_hh_to.idx()] = hprops_.property(_ph)[_hh_from.idx()];
471  }
472 
483  template <class T>
484  void copy_property(EPropHandleT<T> _ph, EdgeHandle _eh_from, EdgeHandle _eh_to) {
485  if(_eh_from.is_valid() && _eh_to.is_valid())
486  eprops_.property(_ph)[_eh_to.idx()] = eprops_.property(_ph)[_eh_from.idx()];
487  }
488 
499  template <class T>
500  void copy_property(FPropHandleT<T> _ph, FaceHandle _fh_from, FaceHandle _fh_to) {
501  if(_fh_from.is_valid() && _fh_to.is_valid())
502  fprops_.property(_ph)[_fh_to.idx()] = fprops_.property(_ph)[_fh_from.idx()];
503  }
504 
505 
506 public:
507  //------------------------------------------------ copy all properties
508 
516  void copy_all_properties(VertexHandle _vh_from, VertexHandle _vh_to, bool _copyBuildIn = false) {
517 
518  for( PropertyContainer::iterator p_it = vprops_.begin();
519  p_it != vprops_.end(); ++p_it) {
520 
521  // Copy all properties, if build in is true
522  // Otherwise, copy only properties without build in specifier
523  if ( *p_it && ( _copyBuildIn || (*p_it)->name().substr(0,2) != "v:" ) )
524  (*p_it)->copy(_vh_from.idx(), _vh_to.idx());
525 
526  }
527  }
528 
535  void copy_all_properties(HalfedgeHandle _hh_from, HalfedgeHandle _hh_to, bool _copyBuildIn = false) {
536 
537  for( PropertyContainer::iterator p_it = hprops_.begin();
538  p_it != hprops_.end(); ++p_it) {
539 
540  // Copy all properties, if build in is true
541  // Otherwise, copy only properties without build in specifier
542  if ( *p_it && ( _copyBuildIn || (*p_it)->name().substr(0,2) != "h:") )
543  (*p_it)->copy(_hh_from.idx(), _hh_to.idx());
544 
545  }
546  }
547 
554  void copy_all_properties(EdgeHandle _eh_from, EdgeHandle _eh_to, bool _copyBuildIn = false) {
555  for( PropertyContainer::iterator p_it = eprops_.begin();
556  p_it != eprops_.end(); ++p_it) {
557 
558  // Copy all properties, if build in is true
559  // Otherwise, copy only properties without build in specifier
560  if ( *p_it && ( _copyBuildIn || (*p_it)->name().substr(0,2) != "e:") )
561  (*p_it)->copy(_eh_from.idx(), _eh_to.idx());
562 
563  }
564  }
565 
573  void copy_all_properties(FaceHandle _fh_from, FaceHandle _fh_to, bool _copyBuildIn = false) {
574 
575  for( PropertyContainer::iterator p_it = fprops_.begin();
576  p_it != fprops_.end(); ++p_it) {
577 
578  // Copy all properties, if build in is true
579  // Otherwise, copy only properties without build in specifier
580  if ( *p_it && ( _copyBuildIn || (*p_it)->name().substr(0,2) != "f:") )
581  (*p_it)->copy(_fh_from.idx(), _fh_to.idx());
582  }
583 
584  }
585 
586 protected: //------------------------------------------------- low-level access
587 
588 public: // used by non-native kernel and MeshIO, should be protected
589 
590  size_t n_vprops(void) const { return vprops_.size(); }
591 
592  size_t n_eprops(void) const { return eprops_.size(); }
593 
594  size_t n_hprops(void) const { return hprops_.size(); }
595 
596  size_t n_fprops(void) const { return fprops_.size(); }
597 
598  size_t n_mprops(void) const { return mprops_.size(); }
599 
600  BaseProperty* _get_vprop( const std::string& _name)
601  { return vprops_.property(_name); }
602 
603  BaseProperty* _get_eprop( const std::string& _name)
604  { return eprops_.property(_name); }
605 
606  BaseProperty* _get_hprop( const std::string& _name)
607  { return hprops_.property(_name); }
608 
609  BaseProperty* _get_fprop( const std::string& _name)
610  { return fprops_.property(_name); }
611 
612  BaseProperty* _get_mprop( const std::string& _name)
613  { return mprops_.property(_name); }
614 
615  const BaseProperty* _get_vprop( const std::string& _name) const
616  { return vprops_.property(_name); }
617 
618  const BaseProperty* _get_eprop( const std::string& _name) const
619  { return eprops_.property(_name); }
620 
621  const BaseProperty* _get_hprop( const std::string& _name) const
622  { return hprops_.property(_name); }
623 
624  const BaseProperty* _get_fprop( const std::string& _name) const
625  { return fprops_.property(_name); }
626 
627  const BaseProperty* _get_mprop( const std::string& _name) const
628  { return mprops_.property(_name); }
629 
630  BaseProperty& _vprop( size_t _idx ) { return vprops_._property( _idx ); }
631  BaseProperty& _eprop( size_t _idx ) { return eprops_._property( _idx ); }
632  BaseProperty& _hprop( size_t _idx ) { return hprops_._property( _idx ); }
633  BaseProperty& _fprop( size_t _idx ) { return fprops_._property( _idx ); }
634  BaseProperty& _mprop( size_t _idx ) { return mprops_._property( _idx ); }
635 
636  const BaseProperty& _vprop( size_t _idx ) const
637  { return vprops_._property( _idx ); }
638  const BaseProperty& _eprop( size_t _idx ) const
639  { return eprops_._property( _idx ); }
640  const BaseProperty& _hprop( size_t _idx ) const
641  { return hprops_._property( _idx ); }
642  const BaseProperty& _fprop( size_t _idx ) const
643  { return fprops_._property( _idx ); }
644  const BaseProperty& _mprop( size_t _idx ) const
645  { return mprops_._property( _idx ); }
646 
647  size_t _add_vprop( BaseProperty* _bp ) { return vprops_._add( _bp ); }
648  size_t _add_eprop( BaseProperty* _bp ) { return eprops_._add( _bp ); }
649  size_t _add_hprop( BaseProperty* _bp ) { return hprops_._add( _bp ); }
650  size_t _add_fprop( BaseProperty* _bp ) { return fprops_._add( _bp ); }
651  size_t _add_mprop( BaseProperty* _bp ) { return mprops_._add( _bp ); }
652 
653 protected: // low-level access non-public
654 
655  BaseProperty& _vprop( BaseHandle _h )
656  { return vprops_._property( _h.idx() ); }
657  BaseProperty& _eprop( BaseHandle _h )
658  { return eprops_._property( _h.idx() ); }
659  BaseProperty& _hprop( BaseHandle _h )
660  { return hprops_._property( _h.idx() ); }
661  BaseProperty& _fprop( BaseHandle _h )
662  { return fprops_._property( _h.idx() ); }
663  BaseProperty& _mprop( BaseHandle _h )
664  { return mprops_._property( _h.idx() ); }
665 
666  const BaseProperty& _vprop( BaseHandle _h ) const
667  { return vprops_._property( _h.idx() ); }
668  const BaseProperty& _eprop( BaseHandle _h ) const
669  { return eprops_._property( _h.idx() ); }
670  const BaseProperty& _hprop( BaseHandle _h ) const
671  { return hprops_._property( _h.idx() ); }
672  const BaseProperty& _fprop( BaseHandle _h ) const
673  { return fprops_._property( _h.idx() ); }
674  const BaseProperty& _mprop( BaseHandle _h ) const
675  { return mprops_._property( _h.idx() ); }
676 
677 
678 public: //----------------------------------------------------- element numbers
679 
680 
681  virtual size_t n_vertices() const { return 0; }
682  virtual size_t n_halfedges() const { return 0; }
683  virtual size_t n_edges() const { return 0; }
684  virtual size_t n_faces() const { return 0; }
685 
686 
687 protected: //------------------------------------------- synchronize properties
688 
690  void vprops_reserve(size_t _n) const { vprops_.reserve(_n); }
691 
693  void vprops_resize(size_t _n) const { vprops_.resize(_n); }
694 
703  void vprops_resize_if_smaller(size_t _n) const { vprops_.resize_if_smaller(_n); }
704 
705  void vprops_clear() {
706  vprops_.clear();
707  }
708 
709  void vprops_swap(unsigned int _i0, unsigned int _i1) const {
710  vprops_.swap(_i0, _i1);
711  }
712 
713  void hprops_reserve(size_t _n) const { hprops_.reserve(_n); }
714  void hprops_resize(size_t _n) const { hprops_.resize(_n); }
715  void hprops_clear() {
716  hprops_.clear();
717  }
718  void hprops_swap(unsigned int _i0, unsigned int _i1) const {
719  hprops_.swap(_i0, _i1);
720  }
721 
722  void eprops_reserve(size_t _n) const { eprops_.reserve(_n); }
723  void eprops_resize(size_t _n) const { eprops_.resize(_n); }
724  void eprops_clear() {
725  eprops_.clear();
726  }
727  void eprops_swap(unsigned int _i0, unsigned int _i1) const {
728  eprops_.swap(_i0, _i1);
729  }
730 
731  void fprops_reserve(size_t _n) const { fprops_.reserve(_n); }
732  void fprops_resize(size_t _n) const { fprops_.resize(_n); }
733  void fprops_clear() {
734  fprops_.clear();
735  }
736  void fprops_swap(unsigned int _i0, unsigned int _i1) const {
737  fprops_.swap(_i0, _i1);
738  }
739 
740  void mprops_resize(size_t _n) const { mprops_.resize(_n); }
741  void mprops_clear() {
742  mprops_.clear();
743  }
744 
745 public:
746 
747  // uses std::clog as output stream
748  void property_stats() const;
749  void property_stats(std::ostream& _ostr) const;
750 
751  void vprop_stats( std::string& _string ) const;
752  void hprop_stats( std::string& _string ) const;
753  void eprop_stats( std::string& _string ) const;
754  void fprop_stats( std::string& _string ) const;
755  void mprop_stats( std::string& _string ) const;
756 
757  // uses std::clog as output stream
758  void vprop_stats() const;
759  void hprop_stats() const;
760  void eprop_stats() const;
761  void fprop_stats() const;
762  void mprop_stats() const;
763 
764  void vprop_stats(std::ostream& _ostr) const;
765  void hprop_stats(std::ostream& _ostr) const;
766  void eprop_stats(std::ostream& _ostr) const;
767  void fprop_stats(std::ostream& _ostr) const;
768  void mprop_stats(std::ostream& _ostr) const;
769 
770 public:
771 
772  typedef PropertyContainer::iterator prop_iterator;
773  typedef PropertyContainer::const_iterator const_prop_iterator;
774 
775  prop_iterator vprops_begin() { return vprops_.begin(); }
776  prop_iterator vprops_end() { return vprops_.end(); }
777  const_prop_iterator vprops_begin() const { return vprops_.begin(); }
778  const_prop_iterator vprops_end() const { return vprops_.end(); }
779 
780  prop_iterator eprops_begin() { return eprops_.begin(); }
781  prop_iterator eprops_end() { return eprops_.end(); }
782  const_prop_iterator eprops_begin() const { return eprops_.begin(); }
783  const_prop_iterator eprops_end() const { return eprops_.end(); }
784 
785  prop_iterator hprops_begin() { return hprops_.begin(); }
786  prop_iterator hprops_end() { return hprops_.end(); }
787  const_prop_iterator hprops_begin() const { return hprops_.begin(); }
788  const_prop_iterator hprops_end() const { return hprops_.end(); }
789 
790  prop_iterator fprops_begin() { return fprops_.begin(); }
791  prop_iterator fprops_end() { return fprops_.end(); }
792  const_prop_iterator fprops_begin() const { return fprops_.begin(); }
793  const_prop_iterator fprops_end() const { return fprops_.end(); }
794 
795  prop_iterator mprops_begin() { return mprops_.begin(); }
796  prop_iterator mprops_end() { return mprops_.end(); }
797  const_prop_iterator mprops_begin() const { return mprops_.begin(); }
798  const_prop_iterator mprops_end() const { return mprops_.end(); }
799 
800 private:
801 
802  PropertyContainer vprops_;
803  PropertyContainer hprops_;
804  PropertyContainer eprops_;
805  PropertyContainer fprops_;
806  PropertyContainer mprops_;
807 };
808 
809 
810 //=============================================================================
811 } // namespace OpenMesh
812 //=============================================================================
813 #endif // OPENMESH_BASE_KERNEL_HH defined
814 //=============================================================================
bool get_property_handle(HPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:266
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:573
bool get_property_handle(VPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:259
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:333
Handle representing an edge property.
Definition: Property.hh:515
FPropHandleT< T >::const_reference property(FPropHandleT< T > _ph, FaceHandle _fh) const
You should not use this function directly.
Definition: BaseKernel.hh:419
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:355
void remove_property(FPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:223
void copy_property(EPropHandleT< T > _ph, EdgeHandle _eh_from, EdgeHandle _eh_to)
You should not use this function directly.
Definition: BaseKernel.hh:484
MPropHandleT< T >::reference property(MPropHandleT< T > _ph)
You should not use this function directly.
Definition: BaseKernel.hh:426
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:703
void copy_property(FPropHandleT< T > _ph, FaceHandle _fh_from, FaceHandle _fh_to)
You should not use this function directly.
Definition: BaseKernel.hh:500
Default property class for any type T.
Definition: Property.hh:94
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:554
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:342
void copy_property(VPropHandleT< T > &_ph, VertexHandle _vh_from, VertexHandle _vh_to)
You should not use this function directly.
Definition: BaseKernel.hh:452
void vprops_reserve(size_t _n) const
Reserves space for _n elements in all vertex property vectors.
Definition: BaseKernel.hh:690
void reset()
reset handle to be invalid
Definition: Handles.hh:80
Handle for a vertex entity.
Definition: Handles.hh:125
bool is_valid() const
The handle is valid iff the index is not equal to -1.
Definition: Handles.hh:77
void add_property(MPropHandleT< T > &_ph, const std::string &_name="<mprop>")
You should not use this function directly.
Definition: BaseKernel.hh:174
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:319
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:328
FPropHandleT< T >::reference property(FPropHandleT< T > _ph, FaceHandle _fh)
You should not use this function directly.
Definition: BaseKernel.hh:413
This class provides low-level property management like adding/removing properties and access to prope...
Definition: BaseKernel.hh:102
Base class for all handle types.
Definition: Handles.hh:67
void add_property(HPropHandleT< T > &_ph, const std::string &_name="<hprop>")
You should not use this function directly.
Definition: BaseKernel.hh:153
void remove_property(VPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:199
EPropHandleT< T >::const_reference property(EPropHandleT< T > _ph, EdgeHandle _eh) const
You should not use this function directly.
Definition: BaseKernel.hh:406
Handle representing a halfedge property.
Definition: Property.hh:501
EPropHandleT< T >::reference property(EPropHandleT< T > _ph, EdgeHandle _eh)
You should not use this function directly.
Definition: BaseKernel.hh:400
void remove_property(EPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:215
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:315
A a container for properties.
Definition: PropertyContainer.hh:67
int idx() const
Get the underlying index of this handle.
Definition: Handles.hh:74
Handle representing a face property.
Definition: Property.hh:529
void remove_property(HPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:207
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:351
Handle representing a vertex property.
Definition: Property.hh:487
bool get_property_handle(EPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:273
Handle representing a mesh property.
Definition: Property.hh:543
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:337
HPropHandleT< T >::reference property(HPropHandleT< T > _ph, HalfedgeHandle _hh)
You should not use this function directly.
Definition: BaseKernel.hh:387
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:324
MPropHandleT< T >::const_reference property(MPropHandleT< T > _ph) const
You should not use this function directly.
Definition: BaseKernel.hh:432
bool get_property_handle(FPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:280
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:346
void remove_property(MPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:231
void add_property(FPropHandleT< T > &_ph, const std::string &_name="<fprop>")
You should not use this function directly.
Definition: BaseKernel.hh:167
Abstract class defining the basic interface of a dynamic property.
Definition: BaseProperty.hh:65
HPropHandleT< T >::const_reference property(HPropHandleT< T > _ph, HalfedgeHandle _hh) const
You should not use this function directly.
Definition: BaseKernel.hh:393
VPropHandleT< T >::const_reference property(VPropHandleT< T > _ph, VertexHandle _vh) const
You should not use this function directly.
Definition: BaseKernel.hh:380
VPropHandleT< T >::reference property(VPropHandleT< T > _ph, VertexHandle _vh)
You should not use this function directly.
Definition: BaseKernel.hh:374
Handle for a face entity.
Definition: Handles.hh:146
void add_property(EPropHandleT< T > &_ph, const std::string &_name="<eprop>")
You should not use this function directly.
Definition: BaseKernel.hh:160
void add_property(VPropHandleT< T > &_ph, const std::string &_name="<vprop>")
You should not use this function directly.
Definition: BaseKernel.hh:146
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:516
Handle for a edge entity.
Definition: Handles.hh:139
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:64
void vprops_resize(size_t _n) const
Resizes all vertex property vectors to the specified size.
Definition: BaseKernel.hh:693
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:535
Handle for a halfedge entity.
Definition: Handles.hh:132
void copy_property(HPropHandleT< T > _ph, HalfedgeHandle _hh_from, HalfedgeHandle _hh_to)
You should not use this function directly.
Definition: BaseKernel.hh:468
bool get_property_handle(MPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:287

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