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
00034
00035
00036
00037
00038
00039
00040 #ifndef OPENMESH_DECIMATER_DECIMATERT_HH
00041 #define OPENMESH_DECIMATER_DECIMATERT_HH
00042
00043
00044
00045
00046 #include <memory>
00047
00048 #include <OpenMesh/Core/Utils/Property.hh>
00049 #include <OpenMesh/Tools/Utils/HeapT.hh>
00050 #include <OpenMesh/Tools/Decimater/ModBaseT.hh>
00051
00052
00053
00054
00055
00056 namespace OpenMesh {
00057 namespace Decimater {
00058
00059
00060
00061
00062
00066 template < typename MeshT >
00067 class DecimaterT
00068 {
00069 public:
00070
00071 typedef DecimaterT< MeshT > Self;
00072 typedef MeshT Mesh;
00073 typedef CollapseInfoT<MeshT> CollapseInfo;
00074 typedef ModBaseT<Self> Module;
00075 typedef std::vector< Module* > ModuleList;
00076
00077 public:
00078
00080 DecimaterT( Mesh& _mesh );
00081
00083 ~DecimaterT();
00084
00085
00093 bool initialize();
00094
00095
00097 bool is_initialized() const { return initialized_; }
00098
00099
00101 void info( std::ostream& _os );
00102
00103 public:
00104
00106 Mesh& mesh() { return mesh_; }
00107
00109 template < typename _Module >
00110 bool add( ModHandleT<_Module>& _mh )
00111 {
00112 if (_mh.is_valid())
00113 return false;
00114
00115 _mh.init( new _Module(*this) );
00116 bmodules_.push_back( _mh.module() );
00117
00118 initialized_ = false;
00119 return true;
00120 }
00121
00122
00124 template < typename _Module >
00125 bool remove( ModHandleT<_Module>& _mh )
00126 {
00127 if (!_mh.is_valid())
00128 return false;
00129
00130 typename ModuleList::iterator it = std::find(bmodules_.begin(),
00131 bmodules_.end(),
00132 _mh.module() );
00133
00134 if ( it == bmodules_.end() )
00135 return false;
00136
00137 delete *it;
00138 bmodules_.erase( it );
00139 _mh.clear();
00140
00141 initialized_ = false;
00142 return true;
00143 }
00144
00145
00147 template < typename Module >
00148 Module& module( ModHandleT<Module>& _mh )
00149 {
00150 assert( _mh.is_valid() );
00151 return *_mh.module();
00152 }
00153
00154 public:
00155
00159 size_t decimate( size_t _n_collapses = 0 );
00160
00162 size_t decimate_to( size_t _n_vertices )
00163 {
00164 return ( (_n_vertices < mesh().n_vertices()) ?
00165 decimate( mesh().n_vertices() - _n_vertices ) : 0 );
00166 }
00167
00168
00169 private:
00170
00171 void update_modules(CollapseInfo& _ci)
00172 {
00173 typename ModuleList::iterator m_it, m_end = bmodules_.end();
00174 for (m_it = bmodules_.begin(); m_it != m_end; ++m_it)
00175 (*m_it)->postprocess_collapse(_ci);
00176 cmodule_->postprocess_collapse(_ci);
00177 }
00178
00179 public:
00180
00181 typedef typename Mesh::VertexHandle VertexHandle;
00182 typedef typename Mesh::HalfedgeHandle HalfedgeHandle;
00183
00185 class HeapInterface
00186 {
00187 public:
00188
00189 HeapInterface(Mesh& _mesh,
00190 VPropHandleT<float> _prio,
00191 VPropHandleT<int> _pos)
00192 : mesh_(_mesh), prio_(_prio), pos_(_pos)
00193 { }
00194
00195 inline bool
00196 less( VertexHandle _vh0, VertexHandle _vh1 )
00197 { return mesh_.property(prio_, _vh0) < mesh_.property(prio_, _vh1); }
00198
00199 inline bool
00200 greater( VertexHandle _vh0, VertexHandle _vh1 )
00201 { return mesh_.property(prio_, _vh0) > mesh_.property(prio_, _vh1); }
00202
00203 inline int
00204 get_heap_position(VertexHandle _vh)
00205 { return mesh_.property(pos_, _vh); }
00206
00207 inline void
00208 set_heap_position(VertexHandle _vh, int _pos)
00209 { mesh_.property(pos_, _vh) = _pos; }
00210
00211
00212 private:
00213 Mesh& mesh_;
00214 VPropHandleT<float> prio_;
00215 VPropHandleT<int> pos_;
00216 };
00217
00218 typedef Utils::HeapT<VertexHandle, HeapInterface> DeciHeap;
00219
00220
00221 private:
00222
00224 void heap_vertex(VertexHandle _vh);
00225
00230 bool is_collapse_legal(const CollapseInfo& _ci);
00231
00233 float collapse_priority(const CollapseInfo& _ci);
00234
00236 void postprocess_collapse(CollapseInfo& _ci);
00237
00238
00239
00240
00241 private:
00242
00243
00244
00245 Mesh& mesh_;
00246
00247
00248 std::auto_ptr<DeciHeap> heap_;
00249
00250
00251 ModuleList bmodules_;
00252 Module* cmodule_;
00253
00254 bool initialized_;
00255
00256
00257
00258 VPropHandleT<HalfedgeHandle> collapse_target_;
00259 VPropHandleT<float> priority_;
00260 VPropHandleT<int> heap_position_;
00261
00262
00263
00264 private:
00265
00266 DecimaterT(const Self&);
00267 Self& operator = (const Self&);
00268
00269 };
00270
00271
00272 }
00273 }
00274
00275 #if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_DECIMATER_DECIMATERT_CC)
00276 #define OPENMESH_DECIMATER_TEMPLATES
00277 #include "DecimaterT.cc"
00278 #endif
00279
00280 #endif // OPENMESH_DECIMATER_DECIMATERT_HH defined
00281
00282