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( 1.0/3.0 ), _1over27( 1.0/27.0 )
113 Sqrt3T(MeshType &_m) :
parent_t(_m), _1over3( 1.0/3.0 ), _1over27( 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()
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; ++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;
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) { }
275 weight_t operator() (
void)
277 #if !defined(OM_CC_MIPS)
282 real_t alpha = (4.0-2.0*cos(2.0*M_PI / (
double)valence))/9.0;
283 return weight_t( real_t(1)-alpha, alpha/real_t(valence) );
285 return weight_t(0.0, 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 && !_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