OpenMesh
BaseKernel.hh
1/* ========================================================================= *
2 * *
3 * OpenMesh *
4 * Copyright (c) 2001-2025, 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
72namespace OpenMesh {
73
74
75//== CLASS DEFINITION =========================================================
76
96
97class OPENMESHDLLEXPORT BaseKernel
98{
99public: //-------------------------------------------- constructor / destructor
100
101 BaseKernel() {}
102 virtual ~BaseKernel() {
103 vprops_.clear();
104 eprops_.clear();
105 hprops_.clear();
106 fprops_.clear();
107 }
108
109
110public: //-------------------------------------------------- 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
178public: //--------------------------------------------------- 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
235public: //------------------------------------------------ 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
290public: //--------------------------------------------------- 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
356public: //-------------------------------------------- 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
434public: //------------------------------------------------ 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>
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>
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
501public:
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
593protected: //------------------------------------------------- low-level access
594
595public: // 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
660protected: // 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
685public: //----------------------------------------------------- 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
697protected: //------------------------------------------- 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
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); }
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); }
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); }
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); }
752 mprops_.clear();
753 }
754
755public:
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
780public:
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
810private:
811
812 PropertyContainer vprops_;
813 PropertyContainer hprops_;
814 PropertyContainer eprops_;
815 PropertyContainer fprops_;
816 PropertyContainer mprops_;
817};
818
819
820template <>
821inline size_t BaseKernel::n_elements<VertexHandle>() const { return n_vertices(); }
822template <>
823inline size_t BaseKernel::n_elements<HalfedgeHandle>() const { return n_halfedges(); }
824template <>
825inline size_t BaseKernel::n_elements<EdgeHandle>() const { return n_edges(); }
826template <>
827inline 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
BaseProperty & _hprop(BaseHandle _h)
You should not use this function directly.
Definition: BaseKernel.hh:666
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
BaseProperty * _get_eprop(const std::string &_name)
You should not use this function directly.
Definition: BaseKernel.hh:610
void hprops_clear()
You should not use this function directly.
Definition: BaseKernel.hh:725
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
size_t n_eprops(void) const
You should not use this function directly.
Definition: BaseKernel.hh:599
prop_iterator vprops_end()
You should not use this function directly.
Definition: BaseKernel.hh:786
bool get_property_handle(HPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:261
const BaseProperty & _eprop(size_t _idx) const
You should not use this function directly.
Definition: BaseKernel.hh:645
const BaseProperty * _get_mprop(const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:634
const BaseProperty * _get_hprop(const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:628
bool get_property_handle(EPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:268
void remove_property(VPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:194
BaseProperty & _eprop(BaseHandle _h)
You should not use this function directly.
Definition: BaseKernel.hh:664
const BaseProperty * _get_fprop(const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:631
void add_property(MPropHandleT< T > &_ph, const std::string &_name="<mprop>")
You should not use this function directly.
Definition: BaseKernel.hh:169
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
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
BaseProperty & _mprop(BaseHandle _h)
You should not use this function directly.
Definition: BaseKernel.hh:670
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
BaseProperty * _get_vprop(const std::string &_name)
You should not use this function directly.
Definition: BaseKernel.hh:607
const BaseProperty * _get_eprop(const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:625
prop_iterator hprops_begin()
You should not use this function directly.
Definition: BaseKernel.hh:795
BaseProperty * _get_fprop(const std::string &_name)
You should not use this function directly.
Definition: BaseKernel.hh:616
BaseProperty & _vprop(size_t _idx)
You should not use this function directly.
Definition: BaseKernel.hh:637
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
size_t n_vprops(void) const
You should not use this function directly.
Definition: BaseKernel.hh:597
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
const BaseProperty & _mprop(BaseHandle _h) const
You should not use this function directly.
Definition: BaseKernel.hh:681
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 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
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
BaseProperty & _eprop(size_t _idx)
You should not use this function directly.
Definition: BaseKernel.hh:638
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_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
void remove_property(FPropHandleT< T > &_ph)
You should not use this function directly.
Definition: BaseKernel.hh:218
BaseProperty & _fprop(size_t _idx)
You should not use this function directly.
Definition: BaseKernel.hh:640
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
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
const BaseProperty & _fprop(size_t _idx) const
You should not use this function directly.
Definition: BaseKernel.hh:649
const BaseProperty & _hprop(size_t _idx) const
You should not use this function directly.
Definition: BaseKernel.hh:647
size_t _add_vprop(BaseProperty *_bp)
You should not use this function directly.
Definition: BaseKernel.hh:654
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
FPropHandleT< T >::reference property(FPropHandleT< T > _ph, FaceHandle _fh)
You should not use this function directly.
Definition: BaseKernel.hh:408
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
void vprops_reserve(size_t _n) const
Reserves space for _n elements in all vertex property vectors.
Definition: BaseKernel.hh:700
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
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
bool get_property_handle(MPropHandleT< T > &_ph, const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:282
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_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
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
prop_iterator mprops_end()
You should not use this function directly.
Definition: BaseKernel.hh:806
BaseProperty & _fprop(BaseHandle _h)
You should not use this function directly.
Definition: BaseKernel.hh:668
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
const BaseProperty & _hprop(BaseHandle _h) const
You should not use this function directly.
Definition: BaseKernel.hh:677
const BaseProperty & _vprop(BaseHandle _h) const
You should not use this function directly.
Definition: BaseKernel.hh:673
prop_iterator eprops_begin()
You should not use this function directly.
Definition: BaseKernel.hh:790
VPropHandleT< T >::reference property(VPropHandleT< T > _ph, VertexHandle _vh)
You should not use this function directly.
Definition: BaseKernel.hh:369
MPropHandleT< T >::reference property(MPropHandleT< T > _ph)
You should not use this function directly.
Definition: BaseKernel.hh:421
void mprops_clear()
You should not use this function directly.
Definition: BaseKernel.hh:751
EPropHandleT< T >::reference property(EPropHandleT< T > _ph, EdgeHandle _eh)
You should not use this function directly.
Definition: BaseKernel.hh:395
const_prop_iterator mprops_end() const
You should not use this function directly.
Definition: BaseKernel.hh:808
const BaseProperty & _mprop(size_t _idx) const
You should not use this function directly.
Definition: BaseKernel.hh:651
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
HPropHandleT< T >::reference property(HPropHandleT< T > _ph, HalfedgeHandle _hh)
You should not use this function directly.
Definition: BaseKernel.hh:382
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
BaseProperty & _hprop(size_t _idx)
You should not use this function directly.
Definition: BaseKernel.hh:639
void fprops_reserve(size_t _n) const
You should not use this function directly.
Definition: BaseKernel.hh:741
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 & _vprop(BaseHandle _h)
You should not use this function directly.
Definition: BaseKernel.hh:662
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
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
const BaseProperty & _fprop(BaseHandle _h) const
You should not use this function directly.
Definition: BaseKernel.hh:679
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
void hprops_reserve(size_t _n) const
You should not use this function directly.
Definition: BaseKernel.hh:723
FPropHandleT< T >::const_reference property(FPropHandleT< T > _ph, FaceHandle _fh) const
You should not use this function directly.
Definition: BaseKernel.hh:414
size_t _add_mprop(BaseProperty *_bp)
You should not use this function directly.
Definition: BaseKernel.hh:658
BaseProperty & _mprop(size_t _idx)
You should not use this function directly.
Definition: BaseKernel.hh:641
HPropHandleT< T >::const_reference property(HPropHandleT< T > _ph, HalfedgeHandle _hh) const
You should not use this function directly.
Definition: BaseKernel.hh:388
EPropHandleT< T >::const_reference property(EPropHandleT< T > _ph, EdgeHandle _eh) const
You should not use this function directly.
Definition: BaseKernel.hh:401
BaseProperty * _get_mprop(const std::string &_name)
You should not use this function directly.
Definition: BaseKernel.hh:619
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
const BaseProperty * _get_vprop(const std::string &_name) const
You should not use this function directly.
Definition: BaseKernel.hh:622
void add_property(HPropHandleT< T > &_ph, const std::string &_name="<hprop>")
You should not use this function directly.
Definition: BaseKernel.hh:148
const BaseProperty & _vprop(size_t _idx) const
You should not use this function directly.
Definition: BaseKernel.hh:643
const BaseProperty & _eprop(BaseHandle _h) const
You should not use this function directly.
Definition: BaseKernel.hh:675
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
MPropHandleT< T >::const_reference property(MPropHandleT< T > _ph) const
You should not use this function directly.
Definition: BaseKernel.hh:427
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
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
BaseProperty * _get_hprop(const std::string &_name)
You should not use this function directly.
Definition: BaseKernel.hh:613
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
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
VPropHandleT< T >::const_reference property(VPropHandleT< T > _ph, VertexHandle _vh) const
You should not use this function directly.
Definition: BaseKernel.hh:375
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 .