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 #ifndef OPENMESH_BASE_KERNEL_HH
00040 #define OPENMESH_BASE_KERNEL_HH
00041
00042
00043
00044
00045
00046 #include <OpenMesh/Core/System/config.hh>
00047
00048 #include <vector>
00049 #include <string>
00050 #include <algorithm>
00051
00052 #include <OpenMesh/Core/Utils/Property.hh>
00053
00054
00055
00056
00057
00058 namespace OpenMesh {
00059
00060
00061
00062
00079
00080 class BaseKernel
00081 {
00082 public:
00083
00084 BaseKernel() {}
00085 virtual ~BaseKernel() {}
00086
00087
00088 public:
00089
00091
00093
00114 template <class T> void add_property( VPropHandleT<T>& _ph,
00115 const std::string& _name="<vprop>" )
00116 {
00117 _ph = VPropHandleT<T>( vprops_.add(T(), _name) );
00118 vprops_.resize(n_vertices());
00119 }
00120
00121 template <class T> void add_property( HPropHandleT<T>& _ph,
00122 const std::string& _name="<hprop>" )
00123 {
00124 _ph = HPropHandleT<T>( hprops_.add(T(), _name) );
00125 hprops_.resize(n_halfedges());
00126 }
00127
00128 template <class T> void add_property( EPropHandleT<T>& _ph,
00129 const std::string& _name="<eprop>" )
00130 {
00131 _ph = EPropHandleT<T>( eprops_.add(T(), _name) );
00132 eprops_.resize(n_edges());
00133 }
00134
00135 template <class T> void add_property( FPropHandleT<T>& _ph,
00136 const std::string& _name="<fprop>" )
00137 {
00138 _ph = FPropHandleT<T>( fprops_.add(T(), _name) );
00139 fprops_.resize(n_faces());
00140 }
00141
00142 template <class T> void add_property( MPropHandleT<T>& _ph,
00143 const std::string& _name="<mprop>" )
00144 {
00145 _ph = MPropHandleT<T>( mprops_.add(T(), _name) );
00146 mprops_.resize(1);
00147 }
00148
00150
00151
00152 public:
00153
00155
00156
00164 template <typename T>
00165 void remove_property(VPropHandleT<T>& _ph) {
00166 if (_ph.is_valid())
00167 vprops_.remove(_ph);
00168 _ph.reset();
00169 }
00170
00171 template <typename T>
00172 void remove_property(HPropHandleT<T>& _ph) {
00173 if (_ph.is_valid())
00174 hprops_.remove(_ph);
00175 _ph.reset();
00176 }
00177
00178 template <typename T>
00179 void remove_property(EPropHandleT<T>& _ph) {
00180 if (_ph.is_valid())
00181 eprops_.remove(_ph);
00182 _ph.reset();
00183 }
00184
00185 template <typename T>
00186 void remove_property(FPropHandleT<T>& _ph) {
00187 if (_ph.is_valid())
00188 fprops_.remove(_ph);
00189 _ph.reset();
00190 }
00191
00192 template <typename T>
00193 void remove_property(MPropHandleT<T>& _ph) {
00194 if (_ph.is_valid())
00195 mprops_.remove(_ph);
00196 _ph.reset();
00197 }
00198
00200
00201
00202 public:
00203
00205
00206
00215 template <class T>
00216 bool get_property_handle(VPropHandleT<T>& _ph,
00217 const std::string& _name) const
00218 {
00219 return (_ph = VPropHandleT<T>(vprops_.handle(T(), _name))).is_valid();
00220 }
00221
00222 template <class T>
00223 bool get_property_handle(HPropHandleT<T>& _ph,
00224 const std::string& _name) const
00225 {
00226 return (_ph = HPropHandleT<T>(hprops_.handle(T(), _name))).is_valid();
00227 }
00228
00229 template <class T>
00230 bool get_property_handle(EPropHandleT<T>& _ph,
00231 const std::string& _name) const
00232 {
00233 return (_ph = EPropHandleT<T>(eprops_.handle(T(), _name))).is_valid();
00234 }
00235
00236 template <class T>
00237 bool get_property_handle(FPropHandleT<T>& _ph,
00238 const std::string& _name) const
00239 {
00240 return (_ph = FPropHandleT<T>(fprops_.handle(T(), _name))).is_valid();
00241 }
00242
00243 template <class T>
00244 bool get_property_handle(MPropHandleT<T>& _ph,
00245 const std::string& _name) const
00246 {
00247 return (_ph = MPropHandleT<T>(mprops_.handle(T(), _name))).is_valid();
00248 }
00249
00251
00252
00253 public:
00254
00256
00257
00267 template <class T>
00268 PropertyT<T>& property(VPropHandleT<T> _ph) {
00269 return vprops_.property(_ph);
00270 }
00271 template <class T>
00272 const PropertyT<T>& property(VPropHandleT<T> _ph) const {
00273 return vprops_.property(_ph);
00274 }
00275
00276
00277 template <class T>
00278 PropertyT<T>& property(HPropHandleT<T> _ph) {
00279 return hprops_.property(_ph);
00280 }
00281 template <class T>
00282 const PropertyT<T>& property(HPropHandleT<T> _ph) const {
00283 return hprops_.property(_ph);
00284 }
00285
00286
00287 template <class T>
00288 PropertyT<T>& property(EPropHandleT<T> _ph) {
00289 return eprops_.property(_ph);
00290 }
00291 template <class T>
00292 const PropertyT<T>& property(EPropHandleT<T> _ph) const {
00293 return eprops_.property(_ph);
00294 }
00295
00296
00297 template <class T>
00298 PropertyT<T>& property(FPropHandleT<T> _ph) {
00299 return fprops_.property(_ph);
00300 }
00301 template <class T>
00302 const PropertyT<T>& property(FPropHandleT<T> _ph) const {
00303 return fprops_.property(_ph);
00304 }
00305
00306 template <class T>
00307 PropertyT<T>& mproperty(MPropHandleT<T> _ph) {
00308 return mprops_.property(_ph);
00309 }
00310 template <class T>
00311 const PropertyT<T>& mproperty(MPropHandleT<T> _ph) const {
00312 return mprops_.property(_ph);
00313 }
00314
00316
00317 public:
00318
00320
00321
00325 template <class T>
00326 typename VPropHandleT<T>::reference
00327 property(VPropHandleT<T> _ph, VertexHandle _vh) {
00328 return vprops_.property(_ph)[_vh.idx()];
00329 }
00330 template <class T>
00331 typename VPropHandleT<T>::const_reference
00332 property(VPropHandleT<T> _ph, VertexHandle _vh) const {
00333 return vprops_.property(_ph)[_vh.idx()];
00334 }
00335
00336
00337 template <class T>
00338 typename HPropHandleT<T>::reference
00339 property(HPropHandleT<T> _ph, HalfedgeHandle _hh) {
00340 return hprops_.property(_ph)[_hh.idx()];
00341 }
00342
00343 template <class T>
00344 typename HPropHandleT<T>::const_reference
00345 property(HPropHandleT<T> _ph, HalfedgeHandle _hh) const {
00346 return hprops_.property(_ph)[_hh.idx()];
00347 }
00348
00349
00350 template <class T>
00351 typename EPropHandleT<T>::reference
00352 property(EPropHandleT<T> _ph, EdgeHandle _eh) {
00353 return eprops_.property(_ph)[_eh.idx()];
00354 }
00355
00356 template <class T>
00357 typename EPropHandleT<T>::const_reference
00358 property(EPropHandleT<T> _ph, EdgeHandle _eh) const {
00359 return eprops_.property(_ph)[_eh.idx()];
00360 }
00361
00362
00363 template <class T>
00364 typename FPropHandleT<T>::reference
00365 property(FPropHandleT<T> _ph, FaceHandle _fh) {
00366 return fprops_.property(_ph)[_fh.idx()];
00367 }
00368
00369 template <class T>
00370 typename FPropHandleT<T>::const_reference
00371 property(FPropHandleT<T> _ph, FaceHandle _fh) const {
00372 return fprops_.property(_ph)[_fh.idx()];
00373 }
00374
00375
00376 template <class T>
00377 typename MPropHandleT<T>::reference
00378 property(MPropHandleT<T> _ph) {
00379 return mprops_.property(_ph)[0];
00380 }
00381
00382 template <class T>
00383 typename MPropHandleT<T>::const_reference
00384 property(MPropHandleT<T> _ph) const {
00385 return mprops_.property(_ph)[0];
00386 }
00387
00389
00390 protected:
00391
00392 public:
00393
00394 size_t n_vprops(void) const { return vprops_.size(); }
00395
00396 size_t n_eprops(void) const { return eprops_.size(); }
00397
00398 size_t n_hprops(void) const { return hprops_.size(); }
00399
00400 size_t n_fprops(void) const { return fprops_.size(); }
00401
00402 size_t n_mprops(void) const { return mprops_.size(); }
00403
00404 BaseProperty* _get_vprop( const std::string& _name)
00405 { return vprops_.property(_name); }
00406
00407 BaseProperty* _get_eprop( const std::string& _name)
00408 { return eprops_.property(_name); }
00409
00410 BaseProperty* _get_hprop( const std::string& _name)
00411 { return hprops_.property(_name); }
00412
00413 BaseProperty* _get_fprop( const std::string& _name)
00414 { return fprops_.property(_name); }
00415
00416 BaseProperty* _get_mprop( const std::string& _name)
00417 { return mprops_.property(_name); }
00418
00419 const BaseProperty* _get_vprop( const std::string& _name) const
00420 { return vprops_.property(_name); }
00421
00422 const BaseProperty* _get_eprop( const std::string& _name) const
00423 { return eprops_.property(_name); }
00424
00425 const BaseProperty* _get_hprop( const std::string& _name) const
00426 { return hprops_.property(_name); }
00427
00428 const BaseProperty* _get_fprop( const std::string& _name) const
00429 { return fprops_.property(_name); }
00430
00431 const BaseProperty* _get_mprop( const std::string& _name) const
00432 { return mprops_.property(_name); }
00433
00434 BaseProperty& _vprop( size_t _idx ) { return vprops_._property( _idx ); }
00435 BaseProperty& _eprop( size_t _idx ) { return eprops_._property( _idx ); }
00436 BaseProperty& _hprop( size_t _idx ) { return hprops_._property( _idx ); }
00437 BaseProperty& _fprop( size_t _idx ) { return fprops_._property( _idx ); }
00438 BaseProperty& _mprop( size_t _idx ) { return mprops_._property( _idx ); }
00439
00440 const BaseProperty& _vprop( size_t _idx ) const
00441 { return vprops_._property( _idx ); }
00442 const BaseProperty& _eprop( size_t _idx ) const
00443 { return eprops_._property( _idx ); }
00444 const BaseProperty& _hprop( size_t _idx ) const
00445 { return hprops_._property( _idx ); }
00446 const BaseProperty& _fprop( size_t _idx ) const
00447 { return fprops_._property( _idx ); }
00448 const BaseProperty& _mprop( size_t _idx ) const
00449 { return mprops_._property( _idx ); }
00450
00451 size_t _add_vprop( BaseProperty* _bp ) { return vprops_._add( _bp ); }
00452 size_t _add_eprop( BaseProperty* _bp ) { return eprops_._add( _bp ); }
00453 size_t _add_hprop( BaseProperty* _bp ) { return hprops_._add( _bp ); }
00454 size_t _add_fprop( BaseProperty* _bp ) { return fprops_._add( _bp ); }
00455 size_t _add_mprop( BaseProperty* _bp ) { return mprops_._add( _bp ); }
00456
00457 protected:
00458
00459 BaseProperty& _vprop( BaseHandle _h )
00460 { return vprops_._property( _h.idx() ); }
00461 BaseProperty& _eprop( BaseHandle _h )
00462 { return eprops_._property( _h.idx() ); }
00463 BaseProperty& _hprop( BaseHandle _h )
00464 { return hprops_._property( _h.idx() ); }
00465 BaseProperty& _fprop( BaseHandle _h )
00466 { return fprops_._property( _h.idx() ); }
00467 BaseProperty& _mprop( BaseHandle _h )
00468 { return mprops_._property( _h.idx() ); }
00469
00470 const BaseProperty& _vprop( BaseHandle _h ) const
00471 { return vprops_._property( _h.idx() ); }
00472 const BaseProperty& _eprop( BaseHandle _h ) const
00473 { return eprops_._property( _h.idx() ); }
00474 const BaseProperty& _hprop( BaseHandle _h ) const
00475 { return hprops_._property( _h.idx() ); }
00476 const BaseProperty& _fprop( BaseHandle _h ) const
00477 { return fprops_._property( _h.idx() ); }
00478 const BaseProperty& _mprop( BaseHandle _h ) const
00479 { return mprops_._property( _h.idx() ); }
00480
00481
00482 public:
00483
00484
00485 virtual unsigned int n_vertices() const { return 0; }
00486 virtual unsigned int n_halfedges() const { return 0; }
00487 virtual unsigned int n_edges() const { return 0; }
00488 virtual unsigned int n_faces() const { return 0; }
00489
00490
00491 protected:
00492
00493 void vprops_reserve(unsigned int _n) const { vprops_.reserve(_n); }
00494 void vprops_resize(unsigned int _n) const { vprops_.resize(_n); }
00495 void vprops_free_mem() const { vprops_.free_mem(); }
00496 void vprops_swap(unsigned int _i0, unsigned int _i1) const {
00497 vprops_.swap(_i0, _i1);
00498 }
00499
00500 void hprops_reserve(unsigned int _n) const { hprops_.reserve(_n); }
00501 void hprops_resize(unsigned int _n) const { hprops_.resize(_n); }
00502 void hprops_free_mem() const { hprops_.free_mem(); }
00503 void hprops_swap(unsigned int _i0, unsigned int _i1) const {
00504 hprops_.swap(_i0, _i1);
00505 }
00506
00507 void eprops_reserve(unsigned int _n) const { eprops_.reserve(_n); }
00508 void eprops_resize(unsigned int _n) const { eprops_.resize(_n); }
00509 void eprops_free_mem() const { eprops_.free_mem(); }
00510 void eprops_swap(unsigned int _i0, unsigned int _i1) const {
00511 eprops_.swap(_i0, _i1);
00512 }
00513
00514 void fprops_reserve(unsigned int _n) const { fprops_.reserve(_n); }
00515 void fprops_resize(unsigned int _n) const { fprops_.resize(_n); }
00516 void fprops_free_mem() const { fprops_.free_mem(); }
00517 void fprops_swap(unsigned int _i0, unsigned int _i1) const {
00518 fprops_.swap(_i0, _i1);
00519 }
00520
00521 void mprops_resize(unsigned int _n) const { mprops_.resize(_n); }
00522
00523 public:
00524
00525 void property_stats(std::ostream& _ostr = std::clog) const;
00526
00527 public:
00528
00529 typedef PropertyContainer::iterator prop_iterator;
00530 typedef PropertyContainer::const_iterator const_prop_iterator;
00531
00532 prop_iterator vprops_begin() { return vprops_.begin(); }
00533 prop_iterator vprops_end() { return vprops_.end(); }
00534 const_prop_iterator vprops_begin() const { return vprops_.begin(); }
00535 const_prop_iterator vprops_end() const { return vprops_.end(); }
00536
00537 prop_iterator eprops_begin() { return eprops_.begin(); }
00538 prop_iterator eprops_end() { return eprops_.end(); }
00539 const_prop_iterator eprops_begin() const { return eprops_.begin(); }
00540 const_prop_iterator eprops_end() const { return eprops_.end(); }
00541
00542 prop_iterator hprops_begin() { return hprops_.begin(); }
00543 prop_iterator hprops_end() { return hprops_.end(); }
00544 const_prop_iterator hprops_begin() const { return hprops_.begin(); }
00545 const_prop_iterator hprops_end() const { return hprops_.end(); }
00546
00547 prop_iterator fprops_begin() { return fprops_.begin(); }
00548 prop_iterator fprops_end() { return fprops_.end(); }
00549 const_prop_iterator fprops_begin() const { return fprops_.begin(); }
00550 const_prop_iterator fprops_end() const { return fprops_.end(); }
00551
00552 prop_iterator mprops_begin() { return mprops_.begin(); }
00553 prop_iterator mprops_end() { return mprops_.end(); }
00554 const_prop_iterator mprops_begin() const { return mprops_.begin(); }
00555 const_prop_iterator mprops_end() const { return mprops_.end(); }
00556
00557 private:
00558
00559 PropertyContainer vprops_;
00560 PropertyContainer hprops_;
00561 PropertyContainer eprops_;
00562 PropertyContainer fprops_;
00563 PropertyContainer mprops_;
00564 };
00565
00566
00567
00568 }
00569
00570 #endif // OPENMESH_BASE_KERNEL_HH defined
00571