52 #ifndef OPENMESH_SUBDIVIDER_UNIFORM_LOOPT_HH
53 #define OPENMESH_SUBDIVIDER_UNIFORM_LOOPT_HH
58 #include <OpenMesh/Core/System/config.hh>
60 #include <OpenMesh/Core/Utils/vector_cast.hh>
61 #include <OpenMesh/Core/Utils/Property.hh>
64 #if defined(OM_CC_MIPS)
74 namespace Subdivider {
88 template <
typename MeshType,
typename RealType =
float>
93 typedef RealType real_t;
94 typedef MeshType mesh_t;
97 typedef std::pair< real_t, real_t > weight_t;
98 typedef std::vector< std::pair<real_t,real_t> > weights_t;
103 LoopT(
void) : parent_t(), _1over8( 1.0/8.0 ), _3over8( 3.0/8.0 )
107 LoopT( mesh_t& _m ) : parent_t(_m), _1over8( 1.0/8.0 ), _3over8( 3.0/8.0 )
117 const char *
name()
const {
return "Uniform Loop"; }
123 weights_.resize(_max_valence);
124 std::generate(weights_.begin(), weights_.end(), compute_weight());
133 _m.add_property( vp_pos_ );
134 _m.add_property( ep_pos_ );
141 _m.remove_property( vp_pos_ );
142 _m.remove_property( ep_pos_ );
147 bool subdivide( mesh_t& _m,
size_t _n,
const bool _update_points =
true)
152 typename mesh_t::FaceIter fit, f_end;
153 typename mesh_t::EdgeIter eit, e_end;
154 typename mesh_t::VertexIter vit;
157 for (
size_t i=0; i < _n; ++i)
162 for (vit = _m.vertices_begin(); vit != _m.vertices_end(); ++vit) {
168 for (eit=_m.edges_begin(); eit != _m.edges_end(); ++eit)
169 compute_midpoint( _m, *eit );
175 e_end = _m.edges_end();
176 for (eit=_m.edges_begin(); eit != e_end; ++eit)
177 split_edge(_m, *eit );
183 f_end = _m.faces_end();
184 for (fit = _m.faces_begin(); fit != f_end; ++fit)
185 split_face(_m, *fit );
189 for ( vit = _m.vertices_begin();
190 vit != _m.vertices_end(); ++vit) {
191 _m.set_point(*vit, _m.property( vp_pos_, *vit ) );
196 #if defined(_DEBUG) || defined(DEBUG)
209 struct compute_weight
211 compute_weight() : valence(-1) { }
214 #if !defined(OM_CC_MIPS)
223 double inv_v = 1.0/double(valence);
224 double t = (3.0 + 2.0 * cos( 2.0 * M_PI * inv_v) );
225 double alpha = (40.0 - t * t)/64.0;
227 return weight_t( 1.0-alpha, inv_v*alpha);
229 return weight_t(0.0, 0.0);
236 void split_face(mesh_t& _m,
const typename mesh_t::FaceHandle& _fh)
238 typename mesh_t::HalfedgeHandle
239 heh1(_m.halfedge_handle(_fh)),
240 heh2(_m.next_halfedge_handle(_m.next_halfedge_handle(heh1))),
241 heh3(_m.next_halfedge_handle(_m.next_halfedge_handle(heh2)));
244 corner_cutting( _m, heh1 );
245 corner_cutting( _m, heh2 );
246 corner_cutting( _m, heh3 );
250 void corner_cutting(mesh_t& _m,
const typename mesh_t::HalfedgeHandle& _he)
253 typename mesh_t::HalfedgeHandle
256 heh6(_m.next_halfedge_handle(heh1));
259 for (; _m.next_halfedge_handle(_m.next_halfedge_handle(heh5)) != heh1;
260 heh5 = _m.next_halfedge_handle(heh5))
264 vh1 = _m.to_vertex_handle(heh1),
265 vh2 = _m.to_vertex_handle(heh5);
267 typename mesh_t::HalfedgeHandle
268 heh2(_m.next_halfedge_handle(heh5)),
269 heh3(_m.new_edge( vh1, vh2)),
270 heh4(_m.opposite_halfedge_handle(heh3));
286 typename mesh_t::FaceHandle fh_old(_m.face_handle(heh6));
287 typename mesh_t::FaceHandle fh_new(_m.new_face());
291 _m.set_next_halfedge_handle(heh4, heh6);
292 _m.set_next_halfedge_handle(heh5, heh4);
294 _m.set_face_handle(heh4, fh_old);
295 _m.set_face_handle(heh5, fh_old);
296 _m.set_face_handle(heh6, fh_old);
297 _m.set_halfedge_handle(fh_old, heh4);
300 _m.set_next_halfedge_handle(heh1, heh3);
301 _m.set_next_halfedge_handle(heh3, heh2);
303 _m.set_face_handle(heh1, fh_new);
304 _m.set_face_handle(heh2, fh_new);
305 _m.set_face_handle(heh3, fh_new);
307 _m.set_halfedge_handle(fh_new, heh1);
311 void split_edge(mesh_t& _m,
const typename mesh_t::EdgeHandle& _eh)
313 typename mesh_t::HalfedgeHandle
314 heh = _m.halfedge_handle(_eh, 0),
315 opp_heh = _m.halfedge_handle(_eh, 1);
317 typename mesh_t::HalfedgeHandle new_heh, opp_new_heh, t_heh;
320 typename mesh_t::Point midP(_m.point(_m.to_vertex_handle(heh)));
321 midP += _m.point(_m.to_vertex_handle(opp_heh));
328 _m.property( vp_pos_, vh ) = _m.property( ep_pos_, _eh );
332 if (_m.is_boundary(_eh))
335 _m.next_halfedge_handle(t_heh) != opp_heh;
336 t_heh = _m.opposite_halfedge_handle(_m.next_halfedge_handle(t_heh)))
341 for (t_heh = _m.next_halfedge_handle(opp_heh);
342 _m.next_halfedge_handle(t_heh) != opp_heh;
343 t_heh = _m.next_halfedge_handle(t_heh) )
347 new_heh = _m.new_edge(vh, vh1);
348 opp_new_heh = _m.opposite_halfedge_handle(new_heh);
349 _m.set_vertex_handle( heh, vh );
351 _m.set_next_halfedge_handle(t_heh, opp_new_heh);
352 _m.set_next_halfedge_handle(new_heh, _m.next_halfedge_handle(heh));
353 _m.set_next_halfedge_handle(heh, new_heh);
354 _m.set_next_halfedge_handle(opp_new_heh, opp_heh);
356 if (_m.face_handle(opp_heh).is_valid())
358 _m.set_face_handle(opp_new_heh, _m.face_handle(opp_heh));
359 _m.set_halfedge_handle(_m.face_handle(opp_new_heh), opp_new_heh);
362 _m.set_face_handle( new_heh, _m.face_handle(heh) );
363 _m.set_halfedge_handle( vh, new_heh);
364 _m.set_halfedge_handle( _m.face_handle(heh), heh );
365 _m.set_halfedge_handle( vh1, opp_new_heh );
368 _m.adjust_outgoing_halfedge( vh );
369 _m.adjust_outgoing_halfedge( vh1 );
374 void compute_midpoint(mesh_t& _m,
const typename mesh_t::EdgeHandle& _eh)
376 #define V( X ) vector_cast< typename mesh_t::Normal >( X )
377 typename mesh_t::HalfedgeHandle heh, opp_heh;
379 heh = _m.halfedge_handle( _eh, 0);
380 opp_heh = _m.halfedge_handle( _eh, 1);
383 pos(_m.point(_m.to_vertex_handle(heh)));
385 pos += V( _m.point(_m.to_vertex_handle(opp_heh)) );
388 if (_m.is_boundary(_eh) )
395 pos += V(_m.point(_m.to_vertex_handle(_m.next_halfedge_handle(heh))));
396 pos += V(_m.point(_m.to_vertex_handle(_m.next_halfedge_handle(opp_heh))));
399 _m.property( ep_pos_, _eh ) = pos;
407 if (_m.is_boundary(_vh) )
409 typename mesh_t::HalfedgeHandle heh, prev_heh;
410 heh = _m.halfedge_handle( _vh );
412 if ( heh.is_valid() )
414 assert( _m.is_boundary( _m.edge_handle( heh ) ) );
416 prev_heh = _m.prev_halfedge_handle( heh );
419 to_vh = _m.to_vertex_handle( heh ),
420 from_vh = _m.from_vertex_handle( prev_heh );
423 pos = _m.point( _vh );
440 for (vvit=_m.vv_iter(_vh); vvit.is_valid(); ++vvit) {
444 pos *= weights_[valence].second;
445 pos += weights_[valence].first
449 _m.property( vp_pos_, _vh ) = pos;
459 const real_t _1over8;
460 const real_t _3over8;
470 #endif // OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITELOOPT_HH defined
Uniform Loop subdivision algorithm.
Definition: LoopT.hh:89
VertexHandle new_vertex()
Uses default copy and assignment operator.
Definition: PolyMeshT.hh:189
Kernel::VertexVertexIter VertexVertexIter
Circulator.
Definition: PolyMeshT.hh:158
Kernel::Normal Normal
Normal type.
Definition: PolyMeshT.hh:110
Check integrity of mesh.
Definition: MeshCheckerT.hh:71
vector_caster< dst_t, src_t >::return_type vector_cast(const src_t &_src)
Cast vector type to another vector type by copying the vector elements.
Definition: vector_cast.hh:170
Kernel::VertexHandle VertexHandle
Handle for referencing the corresponding item.
Definition: PolyMeshT.hh:132
bool subdivide(mesh_t &_m, size_t _n, const bool _update_points=true)
Subdivide mesh _m _n times.
Definition: LoopT.hh:147
Abstract base class for uniform subdivision algorithms.
Definition: SubdividerT.hh:87
Kernel::Point Point
Coordinate type.
Definition: PolyMeshT.hh:108
const char * name() const
Return name of subdivision algorithm.
Definition: LoopT.hh:117
bool prepare(mesh_t &_m)
Prepare mesh, e.g. add properties.
Definition: LoopT.hh:131
bool cleanup(mesh_t &_m)
Cleanup mesh after usage, e.g. remove added properties.
Definition: LoopT.hh:139
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:56
bool operator()(MeshType &_m, size_t _n, const bool _update_points=true)
Subdivide the mesh _m _n times.
Definition: SubdividerT.hh:121
void init_weights(size_t _max_valence=50)
Pre-compute weights.
Definition: LoopT.hh:121