00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050 #ifndef OPENMESH_BASE_KERNEL_HH
00051 #define OPENMESH_BASE_KERNEL_HH
00052
00053
00054
00055
00056
00057 #include <OpenMesh/Core/System/config.h>
00058
00059 #include <vector>
00060 #include <string>
00061 #include <algorithm>
00062
00063 #include <OpenMesh/Core/Utils/PropertyContainer.hh>
00064
00065
00066
00067
00068
00069 namespace OpenMesh {
00070
00071
00072
00073
00090
00091 class BaseKernel
00092 {
00093 public:
00094
00095 BaseKernel() {}
00096 virtual ~BaseKernel() {
00097 vprops_.clear();
00098 eprops_.clear();
00099 hprops_.clear();
00100 fprops_.clear();
00101 }
00102
00103
00104 public:
00105
00107
00109
00130 template <class T>
00131 void add_property( VPropHandleT<T>& _ph, const std::string& _name="<vprop>")
00132 {
00133 _ph = VPropHandleT<T>( vprops_.add(T(), _name) );
00134 vprops_.resize(n_vertices());
00135 }
00136
00137 template <class T>
00138 void add_property( HPropHandleT<T>& _ph, const std::string& _name="<hprop>")
00139 {
00140 _ph = HPropHandleT<T>( hprops_.add(T(), _name) );
00141 hprops_.resize(n_halfedges());
00142 }
00143
00144 template <class T>
00145 void add_property( EPropHandleT<T>& _ph, const std::string& _name="<eprop>")
00146 {
00147 _ph = EPropHandleT<T>( eprops_.add(T(), _name) );
00148 eprops_.resize(n_edges());
00149 }
00150
00151 template <class T>
00152 void add_property( FPropHandleT<T>& _ph, const std::string& _name="<fprop>")
00153 {
00154 _ph = FPropHandleT<T>( fprops_.add(T(), _name) );
00155 fprops_.resize(n_faces());
00156 }
00157
00158 template <class T>
00159 void add_property( MPropHandleT<T>& _ph, const std::string& _name="<mprop>")
00160 {
00161 _ph = MPropHandleT<T>( mprops_.add(T(), _name) );
00162 mprops_.resize(1);
00163 }
00164
00166
00167
00168 public:
00169
00171
00172
00180 template <typename T>
00181 void remove_property(VPropHandleT<T>& _ph)
00182 {
00183 if (_ph.is_valid())
00184 vprops_.remove(_ph);
00185 _ph.reset();
00186 }
00187
00188 template <typename T>
00189 void remove_property(HPropHandleT<T>& _ph)
00190 {
00191 if (_ph.is_valid())
00192 hprops_.remove(_ph);
00193 _ph.reset();
00194 }
00195
00196 template <typename T>
00197 void remove_property(EPropHandleT<T>& _ph)
00198 {
00199 if (_ph.is_valid())
00200 eprops_.remove(_ph);
00201 _ph.reset();
00202 }
00203
00204 template <typename T>
00205 void remove_property(FPropHandleT<T>& _ph)
00206 {
00207 if (_ph.is_valid())
00208 fprops_.remove(_ph);
00209 _ph.reset();
00210 }
00211
00212 template <typename T>
00213 void remove_property(MPropHandleT<T>& _ph)
00214 {
00215 if (_ph.is_valid())
00216 mprops_.remove(_ph);
00217 _ph.reset();
00218 }
00219
00221
00222 public:
00223
00225
00226
00235 template <class T>
00236 bool get_property_handle(VPropHandleT<T>& _ph,
00237 const std::string& _name) const
00238 {
00239 return (_ph = VPropHandleT<T>(vprops_.handle(T(), _name))).is_valid();
00240 }
00241
00242 template <class T>
00243 bool get_property_handle(HPropHandleT<T>& _ph,
00244 const std::string& _name) const
00245 {
00246 return (_ph = HPropHandleT<T>(hprops_.handle(T(), _name))).is_valid();
00247 }
00248
00249 template <class T>
00250 bool get_property_handle(EPropHandleT<T>& _ph,
00251 const std::string& _name) const
00252 {
00253 return (_ph = EPropHandleT<T>(eprops_.handle(T(), _name))).is_valid();
00254 }
00255
00256 template <class T>
00257 bool get_property_handle(FPropHandleT<T>& _ph,
00258 const std::string& _name) const
00259 {
00260 return (_ph = FPropHandleT<T>(fprops_.handle(T(), _name))).is_valid();
00261 }
00262
00263 template <class T>
00264 bool get_property_handle(MPropHandleT<T>& _ph,
00265 const std::string& _name) const
00266 {
00267 return (_ph = MPropHandleT<T>(mprops_.handle(T(), _name))).is_valid();
00268 }
00269
00271
00272 public:
00273
00275
00276
00286 template <class T>
00287 PropertyT<T>& property(VPropHandleT<T> _ph) {
00288 return vprops_.property(_ph);
00289 }
00290 template <class T>
00291 const PropertyT<T>& property(VPropHandleT<T> _ph) const {
00292 return vprops_.property(_ph);
00293 }
00294
00295 template <class T>
00296 PropertyT<T>& property(HPropHandleT<T> _ph) {
00297 return hprops_.property(_ph);
00298 }
00299 template <class T>
00300 const PropertyT<T>& property(HPropHandleT<T> _ph) const {
00301 return hprops_.property(_ph);
00302 }
00303
00304 template <class T>
00305 PropertyT<T>& property(EPropHandleT<T> _ph) {
00306 return eprops_.property(_ph);
00307 }
00308 template <class T>
00309 const PropertyT<T>& property(EPropHandleT<T> _ph) const {
00310 return eprops_.property(_ph);
00311 }
00312
00313 template <class T>
00314 PropertyT<T>& property(FPropHandleT<T> _ph) {
00315 return fprops_.property(_ph);
00316 }
00317 template <class T>
00318 const PropertyT<T>& property(FPropHandleT<T> _ph) const {
00319 return fprops_.property(_ph);
00320 }
00321
00322 template <class T>
00323 PropertyT<T>& mproperty(MPropHandleT<T> _ph) {
00324 return mprops_.property(_ph);
00325 }
00326 template <class T>
00327 const PropertyT<T>& mproperty(MPropHandleT<T> _ph) const {
00328 return mprops_.property(_ph);
00329 }
00330
00332
00333 public:
00334
00336
00337
00341 template <class T>
00342 typename VPropHandleT<T>::reference
00343 property(VPropHandleT<T> _ph, VertexHandle _vh) {
00344 return vprops_.property(_ph)[_vh.idx()];
00345 }
00346
00347 template <class T>
00348 typename VPropHandleT<T>::const_reference
00349 property(VPropHandleT<T> _ph, VertexHandle _vh) const {
00350 return vprops_.property(_ph)[_vh.idx()];
00351 }
00352
00353
00354 template <class T>
00355 typename HPropHandleT<T>::reference
00356 property(HPropHandleT<T> _ph, HalfedgeHandle _hh) {
00357 return hprops_.property(_ph)[_hh.idx()];
00358 }
00359
00360 template <class T>
00361 typename HPropHandleT<T>::const_reference
00362 property(HPropHandleT<T> _ph, HalfedgeHandle _hh) const {
00363 return hprops_.property(_ph)[_hh.idx()];
00364 }
00365
00366
00367 template <class T>
00368 typename EPropHandleT<T>::reference
00369 property(EPropHandleT<T> _ph, EdgeHandle _eh) {
00370 return eprops_.property(_ph)[_eh.idx()];
00371 }
00372
00373 template <class T>
00374 typename EPropHandleT<T>::const_reference
00375 property(EPropHandleT<T> _ph, EdgeHandle _eh) const {
00376 return eprops_.property(_ph)[_eh.idx()];
00377 }
00378
00379
00380 template <class T>
00381 typename FPropHandleT<T>::reference
00382 property(FPropHandleT<T> _ph, FaceHandle _fh) {
00383 return fprops_.property(_ph)[_fh.idx()];
00384 }
00385
00386 template <class T>
00387 typename FPropHandleT<T>::const_reference
00388 property(FPropHandleT<T> _ph, FaceHandle _fh) const {
00389 return fprops_.property(_ph)[_fh.idx()];
00390 }
00391
00392
00393 template <class T>
00394 typename MPropHandleT<T>::reference
00395 property(MPropHandleT<T> _ph) {
00396 return mprops_.property(_ph)[0];
00397 }
00398
00399 template <class T>
00400 typename MPropHandleT<T>::const_reference
00401 property(MPropHandleT<T> _ph) const {
00402 return mprops_.property(_ph)[0];
00403 }
00404
00406
00407 protected:
00408
00409 public:
00410
00411 size_t n_vprops(void) const { return vprops_.size(); }
00412
00413 size_t n_eprops(void) const { return eprops_.size(); }
00414
00415 size_t n_hprops(void) const { return hprops_.size(); }
00416
00417 size_t n_fprops(void) const { return fprops_.size(); }
00418
00419 size_t n_mprops(void) const { return mprops_.size(); }
00420
00421 BaseProperty* _get_vprop( const std::string& _name)
00422 { return vprops_.property(_name); }
00423
00424 BaseProperty* _get_eprop( const std::string& _name)
00425 { return eprops_.property(_name); }
00426
00427 BaseProperty* _get_hprop( const std::string& _name)
00428 { return hprops_.property(_name); }
00429
00430 BaseProperty* _get_fprop( const std::string& _name)
00431 { return fprops_.property(_name); }
00432
00433 BaseProperty* _get_mprop( const std::string& _name)
00434 { return mprops_.property(_name); }
00435
00436 const BaseProperty* _get_vprop( const std::string& _name) const
00437 { return vprops_.property(_name); }
00438
00439 const BaseProperty* _get_eprop( const std::string& _name) const
00440 { return eprops_.property(_name); }
00441
00442 const BaseProperty* _get_hprop( const std::string& _name) const
00443 { return hprops_.property(_name); }
00444
00445 const BaseProperty* _get_fprop( const std::string& _name) const
00446 { return fprops_.property(_name); }
00447
00448 const BaseProperty* _get_mprop( const std::string& _name) const
00449 { return mprops_.property(_name); }
00450
00451 BaseProperty& _vprop( size_t _idx ) { return vprops_._property( _idx ); }
00452 BaseProperty& _eprop( size_t _idx ) { return eprops_._property( _idx ); }
00453 BaseProperty& _hprop( size_t _idx ) { return hprops_._property( _idx ); }
00454 BaseProperty& _fprop( size_t _idx ) { return fprops_._property( _idx ); }
00455 BaseProperty& _mprop( size_t _idx ) { return mprops_._property( _idx ); }
00456
00457 const BaseProperty& _vprop( size_t _idx ) const
00458 { return vprops_._property( _idx ); }
00459 const BaseProperty& _eprop( size_t _idx ) const
00460 { return eprops_._property( _idx ); }
00461 const BaseProperty& _hprop( size_t _idx ) const
00462 { return hprops_._property( _idx ); }
00463 const BaseProperty& _fprop( size_t _idx ) const
00464 { return fprops_._property( _idx ); }
00465 const BaseProperty& _mprop( size_t _idx ) const
00466 { return mprops_._property( _idx ); }
00467
00468 size_t _add_vprop( BaseProperty* _bp ) { return vprops_._add( _bp ); }
00469 size_t _add_eprop( BaseProperty* _bp ) { return eprops_._add( _bp ); }
00470 size_t _add_hprop( BaseProperty* _bp ) { return hprops_._add( _bp ); }
00471 size_t _add_fprop( BaseProperty* _bp ) { return fprops_._add( _bp ); }
00472 size_t _add_mprop( BaseProperty* _bp ) { return mprops_._add( _bp ); }
00473
00474 protected:
00475
00476 BaseProperty& _vprop( BaseHandle _h )
00477 { return vprops_._property( _h.idx() ); }
00478 BaseProperty& _eprop( BaseHandle _h )
00479 { return eprops_._property( _h.idx() ); }
00480 BaseProperty& _hprop( BaseHandle _h )
00481 { return hprops_._property( _h.idx() ); }
00482 BaseProperty& _fprop( BaseHandle _h )
00483 { return fprops_._property( _h.idx() ); }
00484 BaseProperty& _mprop( BaseHandle _h )
00485 { return mprops_._property( _h.idx() ); }
00486
00487 const BaseProperty& _vprop( BaseHandle _h ) const
00488 { return vprops_._property( _h.idx() ); }
00489 const BaseProperty& _eprop( BaseHandle _h ) const
00490 { return eprops_._property( _h.idx() ); }
00491 const BaseProperty& _hprop( BaseHandle _h ) const
00492 { return hprops_._property( _h.idx() ); }
00493 const BaseProperty& _fprop( BaseHandle _h ) const
00494 { return fprops_._property( _h.idx() ); }
00495 const BaseProperty& _mprop( BaseHandle _h ) const
00496 { return mprops_._property( _h.idx() ); }
00497
00498
00499 public:
00500
00501
00502 virtual unsigned int n_vertices() const { return 0; }
00503 virtual unsigned int n_halfedges() const { return 0; }
00504 virtual unsigned int n_edges() const { return 0; }
00505 virtual unsigned int n_faces() const { return 0; }
00506
00507
00508 protected:
00509
00510 void vprops_reserve(unsigned int _n) const { vprops_.reserve(_n); }
00511 void vprops_resize(unsigned int _n) const { vprops_.resize(_n); }
00512 void vprops_clear() {
00513 vprops_.clear();
00514 }
00515 void vprops_swap(unsigned int _i0, unsigned int _i1) const {
00516 vprops_.swap(_i0, _i1);
00517 }
00518
00519 void hprops_reserve(unsigned int _n) const { hprops_.reserve(_n); }
00520 void hprops_resize(unsigned int _n) const { hprops_.resize(_n); }
00521 void hprops_clear() {
00522 hprops_.clear();
00523 }
00524 void hprops_swap(unsigned int _i0, unsigned int _i1) const {
00525 hprops_.swap(_i0, _i1);
00526 }
00527
00528 void eprops_reserve(unsigned int _n) const { eprops_.reserve(_n); }
00529 void eprops_resize(unsigned int _n) const { eprops_.resize(_n); }
00530 void eprops_clear() {
00531 eprops_.clear();
00532 }
00533 void eprops_swap(unsigned int _i0, unsigned int _i1) const {
00534 eprops_.swap(_i0, _i1);
00535 }
00536
00537 void fprops_reserve(unsigned int _n) const { fprops_.reserve(_n); }
00538 void fprops_resize(unsigned int _n) const { fprops_.resize(_n); }
00539 void fprops_clear() {
00540 fprops_.clear();
00541 }
00542 void fprops_swap(unsigned int _i0, unsigned int _i1) const {
00543 fprops_.swap(_i0, _i1);
00544 }
00545
00546 void mprops_resize(unsigned int _n) const { mprops_.resize(_n); }
00547 void mprops_clear() {
00548 mprops_.clear();
00549 }
00550
00551 public:
00552
00553 void property_stats(std::ostream& _ostr = std::clog) const;
00554
00555 void vprop_stats( std::string& _string ) const;
00556 void hprop_stats( std::string& _string ) const;
00557 void eprop_stats( std::string& _string ) const;
00558 void fprop_stats( std::string& _string ) const;
00559 void mprop_stats( std::string& _string ) const;
00560
00561 void vprop_stats(std::ostream& _ostr = std::clog) const;
00562 void hprop_stats(std::ostream& _ostr = std::clog) const;
00563 void eprop_stats(std::ostream& _ostr = std::clog) const;
00564 void fprop_stats(std::ostream& _ostr = std::clog) const;
00565 void mprop_stats(std::ostream& _ostr = std::clog) const;
00566
00567 public:
00568
00569 typedef PropertyContainer::iterator prop_iterator;
00570 typedef PropertyContainer::const_iterator const_prop_iterator;
00571
00572 prop_iterator vprops_begin() { return vprops_.begin(); }
00573 prop_iterator vprops_end() { return vprops_.end(); }
00574 const_prop_iterator vprops_begin() const { return vprops_.begin(); }
00575 const_prop_iterator vprops_end() const { return vprops_.end(); }
00576
00577 prop_iterator eprops_begin() { return eprops_.begin(); }
00578 prop_iterator eprops_end() { return eprops_.end(); }
00579 const_prop_iterator eprops_begin() const { return eprops_.begin(); }
00580 const_prop_iterator eprops_end() const { return eprops_.end(); }
00581
00582 prop_iterator hprops_begin() { return hprops_.begin(); }
00583 prop_iterator hprops_end() { return hprops_.end(); }
00584 const_prop_iterator hprops_begin() const { return hprops_.begin(); }
00585 const_prop_iterator hprops_end() const { return hprops_.end(); }
00586
00587 prop_iterator fprops_begin() { return fprops_.begin(); }
00588 prop_iterator fprops_end() { return fprops_.end(); }
00589 const_prop_iterator fprops_begin() const { return fprops_.begin(); }
00590 const_prop_iterator fprops_end() const { return fprops_.end(); }
00591
00592 prop_iterator mprops_begin() { return mprops_.begin(); }
00593 prop_iterator mprops_end() { return mprops_.end(); }
00594 const_prop_iterator mprops_begin() const { return mprops_.begin(); }
00595 const_prop_iterator mprops_end() const { return mprops_.end(); }
00596
00597 private:
00598
00599 PropertyContainer vprops_;
00600 PropertyContainer hprops_;
00601 PropertyContainer eprops_;
00602 PropertyContainer fprops_;
00603 PropertyContainer mprops_;
00604 };
00605
00606
00607
00608 }
00609
00610 #endif // OPENMESH_BASE_KERNEL_HH defined
00611