52 #ifndef OPENMESH_SUBDIVIDER_UNIFORM_SQRT3T_HH
53 #define OPENMESH_SUBDIVIDER_UNIFORM_SQRT3T_HH
58 #include <OpenMesh/Core/Mesh/Handles.hh>
59 #include <OpenMesh/Core/System/config.hh>
61 #if defined(_DEBUG) || defined(DEBUG)
64 # include <OpenMesh/Tools/Utils/MeshCheckerT.hh>
65 # define ASSERT_CONSISTENCY( T, m ) \
66 assert(OpenMesh::Utils::MeshCheckerT<T>(m).check())
68 # define ASSERT_CONSISTENCY( T, m )
72 #if defined(OM_CC_MIPS)
82 namespace Subdivider {
95 template <
typename MeshType,
typename RealType =
float>
100 typedef RealType real_t;
101 typedef MeshType mesh_t;
104 typedef std::pair< real_t, real_t > weight_t;
105 typedef std::vector< std::pair<real_t,real_t> > weights_t;
110 Sqrt3T(
void) : parent_t(), _1over3( real_t(1.0/3.0) ), _1over27( real_t(1.0/27.0) )
113 Sqrt3T(MeshType &_m) : parent_t(_m), _1over3( real_t(1.0/3.0) ), _1over27( real_t(1.0/27.0) )
122 const char *
name()
const {
return "Uniform Sqrt3"; }
128 weights_.resize(_max_valence);
129 std::generate(weights_.begin(), weights_.end(), compute_weight());
138 _m.request_edge_status();
139 _m.add_property( vp_pos_ );
140 _m.add_property( ep_nv_ );
141 _m.add_property( mp_gen_ );
142 _m.property( mp_gen_ ) = 0;
144 return _m.has_edge_status() && vp_pos_.
is_valid()
145 && ep_nv_.is_valid() && mp_gen_.
is_valid();
151 _m.release_edge_status();
152 _m.remove_property( vp_pos_ );
153 _m.remove_property( ep_nv_ );
154 _m.remove_property( mp_gen_ );
158 bool subdivide( MeshType& _m,
size_t _n ,
const bool _update_points =
true)
163 typename MeshType::VertexIter vit;
164 typename MeshType::VertexVertexIter vvit;
165 typename MeshType::EdgeIter eit;
166 typename MeshType::FaceIter fit;
167 typename MeshType::FaceVertexIter fvit;
168 typename MeshType::VertexHandle vh;
169 typename MeshType::HalfedgeHandle heh;
170 typename MeshType::Point pos(0,0,0), zero(0,0,0);
171 size_t &gen = _m.property( mp_gen_ );
173 for (
size_t l=0; l<_n; ++l)
176 for (eit=_m.edges_begin(); eit != _m.edges_end();++eit)
178 _m.status( *eit ).set_tagged(
true );
179 if ( (gen%2) && _m.is_boundary(*eit) )
180 compute_new_boundary_points( _m, *eit );
185 for (vit=_m.vertices_begin(); vit!=_m.vertices_end(); ++vit)
187 if ( _m.is_boundary(*vit) )
191 heh = _m.halfedge_handle(*vit);
195 prev_heh = _m.prev_halfedge_handle(heh);
197 assert( _m.is_boundary(heh ) );
198 assert( _m.is_boundary(prev_heh) );
200 pos = _m.point(_m.to_vertex_handle(heh));
201 pos += _m.point(_m.from_vertex_handle(prev_heh));
204 pos += real_t(19.0) * _m.point( *vit );
207 _m.property( vp_pos_, *vit ) = pos;
211 _m.property( vp_pos_, *vit ) = _m.point( *vit );
218 for ( vvit = _m.vv_iter(*vit); vvit.is_valid(); ++vvit)
220 pos += _m.point( *vvit );
223 pos *= weights_[ valence ].second;
224 pos += weights_[ valence ].first * _m.point(*vit);
225 _m.property( vp_pos_, *vit ) = pos;
230 typename MeshType::FaceIter fend = _m.faces_end();
231 for (fit = _m.faces_begin();fit != fend; ++fit)
233 if ( (gen%2) && _m.is_boundary(*fit))
235 boundary_split( _m, *fit );
239 fvit = _m.fv_iter( *fit );
240 pos = _m.point( *fvit);
241 pos += _m.point(*(++fvit));
242 pos += _m.point(*(++fvit));
244 vh = _m.add_vertex( zero );
245 _m.property( vp_pos_, vh ) = pos;
246 _m.split( *fit, vh );
251 for (vit=_m.vertices_begin();vit != _m.vertices_end(); ++vit)
252 _m.set_point(*vit, _m.property( vp_pos_, *vit ) );
255 for (eit=_m.edges_begin(); eit != _m.edges_end(); ++eit)
256 if ( _m.status( *eit ).tagged() && !_m.is_boundary( *eit ) )
260 ASSERT_CONSISTENCY( MeshType, _m );
272 struct compute_weight
274 compute_weight() : valence(-1) { }
277 #if !defined(OM_CC_MIPS)
282 real_t alpha = real_t( (4.0-2.0*cos(2.0*M_PI / real_t(valence)) )/9.0 );
283 return weight_t( real_t(1)-alpha, alpha/real_t(valence) );
285 return weight_t(real_t(0.0), real_t(0.0) );
294 void compute_new_boundary_points( MeshType& _m,
295 const typename MeshType::EdgeHandle& _eh)
297 assert( _m.is_boundary(_eh) );
299 typename MeshType::HalfedgeHandle heh;
300 typename MeshType::VertexHandle vh1, vh2, vh3, vh4, vhl, vhr;
301 typename MeshType::Point zero(0,0,0), P1, P2, P3, P4;
316 heh = _m.halfedge_handle(_eh,
317 _m.is_boundary(_m.halfedge_handle(_eh,1)));
319 assert( _m.is_boundary( _m.next_halfedge_handle( heh ) ) );
320 assert( _m.is_boundary( _m.prev_halfedge_handle( heh ) ) );
322 vh1 = _m.to_vertex_handle( _m.next_halfedge_handle( heh ) );
323 vh2 = _m.to_vertex_handle( heh );
324 vh3 = _m.from_vertex_handle( heh );
325 vh4 = _m.from_vertex_handle( _m.prev_halfedge_handle( heh ));
332 vhl = _m.add_vertex(zero);
333 vhr = _m.add_vertex(zero);
335 _m.property(vp_pos_, vhl ) = (P1 + real_t(16.0f) * P2 + real_t(10.0f) * P3) * _1over27;
336 _m.property(vp_pos_, vhr ) = ( real_t(10.0f) * P2 + real_t(16.0f) * P3 + P4) * _1over27;
337 _m.property(ep_nv_, _eh).first = vhl;
338 _m.property(ep_nv_, _eh).second = vhr;
342 void boundary_split( MeshType& _m,
const typename MeshType::FaceHandle& _fh )
344 assert( _m.is_boundary(_fh) );
346 typename MeshType::VertexHandle vhl, vhr;
347 typename MeshType::FaceEdgeIter fe_it;
348 typename MeshType::HalfedgeHandle heh;
351 for( fe_it=_m.fe_iter( _fh ); fe_it.is_valid() && !_m.is_boundary( *fe_it ); ++fe_it ) {};
354 vhl = _m.property(ep_nv_, *fe_it).first;
355 vhr = _m.property(ep_nv_, *fe_it).second;
370 heh = _m.halfedge_handle(*fe_it,
371 _m.is_boundary(_m.halfedge_handle(*fe_it,0)));
373 typename MeshType::HalfedgeHandle pl_P3;
376 boundary_split( _m, heh, vhl );
377 pl_P3 = _m.next_halfedge_handle( heh );
378 boundary_split( _m, heh );
381 boundary_split( _m, pl_P3, vhr );
382 boundary_split( _m, pl_P3 );
384 assert( _m.is_boundary( vhl ) && _m.halfedge_handle(vhl).is_valid() );
385 assert( _m.is_boundary( vhr ) && _m.halfedge_handle(vhr).is_valid() );
388 void boundary_split(MeshType& _m,
389 const typename MeshType::HalfedgeHandle& _heh,
390 const typename MeshType::VertexHandle& _vh)
392 assert( _m.is_boundary( _m.edge_handle(_heh) ) );
394 typename MeshType::HalfedgeHandle
396 opp_heh( _m.opposite_halfedge_handle(_heh) ),
397 new_heh, opp_new_heh;
398 typename MeshType::VertexHandle to_vh(_m.to_vertex_handle(heh));
399 typename MeshType::HalfedgeHandle t_heh;
420 _m.next_halfedge_handle(t_heh) != opp_heh;
421 t_heh = _m.opposite_halfedge_handle(_m.next_halfedge_handle(t_heh)))
424 assert( _m.is_boundary( t_heh ) );
426 new_heh = _m.new_edge( _vh, to_vh );
427 opp_new_heh = _m.opposite_halfedge_handle(new_heh);
431 _m.set_next_halfedge_handle(t_heh, opp_new_heh);
433 _m.set_next_halfedge_handle(new_heh, _m.next_halfedge_handle(heh));
434 _m.set_next_halfedge_handle(heh, new_heh);
435 _m.set_next_halfedge_handle(opp_new_heh, opp_heh);
438 _m.set_face_handle(opp_new_heh, _m.face_handle(opp_heh));
441 _m.set_vertex_handle(heh, _vh);
444 _m.set_face_handle(new_heh, _m.face_handle(heh));
448 _m.set_halfedge_handle( to_vh, opp_new_heh );
451 _m.set_halfedge_handle( _vh, opp_heh );
454 void boundary_split( MeshType& _m,
455 const typename MeshType::HalfedgeHandle& _heh)
457 assert( _m.is_boundary( _m.opposite_halfedge_handle( _heh ) ) );
459 typename MeshType::HalfedgeHandle
461 n_heh(_m.next_halfedge_handle(heh));
463 typename MeshType::VertexHandle
464 to_vh(_m.to_vertex_handle(heh));
466 typename MeshType::HalfedgeHandle
467 heh2(_m.new_edge(to_vh,
468 _m.to_vertex_handle(_m.next_halfedge_handle(n_heh)))),
469 heh3(_m.opposite_halfedge_handle(heh2));
471 typename MeshType::FaceHandle
472 new_fh(_m.new_face()),
473 fh(_m.face_handle(heh));
477 #define set_next_heh set_next_halfedge_handle
478 #define next_heh next_halfedge_handle
480 _m.set_face_handle(heh, new_fh);
481 _m.set_face_handle(heh2, new_fh);
482 _m.set_next_heh(heh2, _m.next_heh(_m.next_heh(n_heh)));
483 _m.set_next_heh(heh, heh2);
484 _m.set_face_handle( _m.next_heh(heh2), new_fh);
488 _m.set_next_heh(heh3, n_heh);
489 _m.set_next_heh(_m.next_halfedge_handle(n_heh), heh3);
490 _m.set_face_handle(heh3, fh);
493 _m.set_halfedge_handle( fh, n_heh);
494 _m.set_halfedge_handle(new_fh, heh);
496 #undef set_next_halfedge_handle
497 #undef next_halfedge_handle
506 typename MeshType::VertexHandle> > ep_nv_;
509 const real_t _1over3;
510 const real_t _1over27;
519 #endif // OPENMESH_SUBDIVIDER_UNIFORM_SQRT3T_HH
bool operator()(MeshType &_m, size_t _n, const bool _update_points=true)
Subdivide the mesh _m _n times.
Definition: SubdividerT.hh:121
bool is_valid() const
The handle is valid iff the index is not equal to -1.
Definition: Handles.hh:70
bool prepare(MeshType &_m)
Prepare mesh, e.g. add properties.
Definition: Sqrt3T.hh:136
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:56
Handle for a halfedge entity.
Definition: Handles.hh:121
void init_weights(size_t _max_valence=50)
Pre-compute weights.
Definition: Sqrt3T.hh:126
bool subdivide(MeshType &_m, size_t _n, const bool _update_points=true)
Subdivide mesh _m _n times.
Definition: Sqrt3T.hh:158
bool cleanup(MeshType &_m)
Cleanup mesh after usage, e.g. remove added properties.
Definition: Sqrt3T.hh:149
const char * name() const
Return name of subdivision algorithm.
Definition: Sqrt3T.hh:122
Uniform Sqrt3 subdivision algorithm
Definition: Sqrt3T.hh:96
Handle representing an edge property.
Definition: Property.hh:504
Abstract base class for uniform subdivision algorithms.
Definition: SubdividerT.hh:87