OpenMesh: OpenMesh/Tools/Subdivider/Uniform/ModifiedButterFlyT.hh Source File

| OpenMesh

ModifiedButterFlyT.hh
Go to the documentation of this file.
1 /* ========================================================================= *
2 * *
3 * OpenMesh *
4 * Copyright (c) 2001-2022, RWTH-Aachen University *
5 * Department of Computer Graphics and Multimedia *
6 * All rights reserved. *
7 * www.openmesh.org *
8 * *
9 *---------------------------------------------------------------------------*
10 * This file is part of OpenMesh. *
11 *---------------------------------------------------------------------------*
12 * *
13 * Redistribution and use in source and binary forms, with or without *
14 * modification, are permitted provided that the following conditions *
15 * are met: *
16 * *
17 * 1. Redistributions of source code must retain the above copyright notice, *
18 * this list of conditions and the following disclaimer. *
19 * *
20 * 2. Redistributions in binary form must reproduce the above copyright *
21 * notice, this list of conditions and the following disclaimer in the *
22 * documentation and/or other materials provided with the distribution. *
23 * *
24 * 3. Neither the name of the copyright holder nor the names of its *
25 * contributors may be used to endorse or promote products derived from *
26 * this software without specific prior written permission. *
27 * *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
30 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
31 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
32 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
33 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
34 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
35 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
36 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
37 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
38 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
39 * *
40 * ========================================================================= */
41
51 //=============================================================================
52 //
53 // CLASS ModifiedButterflyT
54 //
55 //=============================================================================
56
57
58 #ifndef SP_MODIFIED_BUTTERFLY_H
59 #define SP_MODIFIED_BUTTERFLY_H
60
61 #include <OpenMesh/Tools/Subdivider/Uniform/SubdividerT.hh>
62 #include <OpenMesh/Core/Utils/vector_cast.hh>
63 #include <OpenMesh/Core/Utils/Property.hh>
64 // -------------------- STL
65 #include <vector>
66 #if defined(OM_CC_MIPS)
67 # include <math.h>
68 #else
69 # include <cmath>
70 #endif
71
72
73 //== NAMESPACE ================================================================
74
75 namespace OpenMesh { // BEGIN_NS_OPENMESH
76 namespace Subdivider { // BEGIN_NS_DECIMATER
77 namespace Uniform { // BEGIN_NS_UNIFORM
78
79
80 //== CLASS DEFINITION =========================================================
81
82
91 template <typename MeshType, typename RealType = double>
92 class ModifiedButterflyT : public SubdividerT<MeshType, RealType>
93 {
94 public:
95
96 typedef RealType real_t;
97 typedef MeshType mesh_t;
98 typedef SubdividerT< mesh_t, real_t > parent_t;
99
100 typedef std::vector< std::vector<real_t> > weights_t;
101 typedef std::vector<real_t> weight_t;
102
103 public:
104
105
106 ModifiedButterflyT() : parent_t()
107 { init_weights(); }
108
109
110 explicit ModifiedButterflyT( mesh_t& _m) : parent_t(_m)
111 { init_weights(); }
112
113
114 ~ModifiedButterflyT() {}
115
116
117 public:
118
119
120 const char *name() const override { return "Uniform Spectral"; }
121
122
124 void init_weights(size_t _max_valence=30)
125 {
126 weights.resize(_max_valence);
127
128 //special case: K==3, K==4
129 weights[3].resize(4);
130 weights[3][0] = real_t(5.0)/12;
131 weights[3][1] = real_t(-1.0)/12;
132 weights[3][2] = real_t(-1.0)/12;
133 weights[3][3] = real_t(3.0)/4;
134
135 weights[4].resize(5);
136 weights[4][0] = real_t(3.0)/8;
137 weights[4][1] = 0;
138 weights[4][2] = real_t(-1.0)/8;
139 weights[4][3] = 0;
140 weights[4][4] = real_t(3.0)/4;
141
142 for(unsigned int K = 5; K<_max_valence; ++K)
143 {
144 weights[K].resize(K+1);
145 // s(j) = ( 1/4 + cos(2*pi*j/K) + 1/2 * cos(4*pi*j/K) )/K
146 double invK = 1.0/static_cast<double>(K);
147 real_t sum = 0;
148 for(unsigned int j=0; j<K; ++j)
149 {
150 weights[K][j] = static_cast<real_t>((0.25 + cos(2.0*M_PI*static_cast<double>(j)*invK) + 0.5*cos(4.0*M_PI*static_cast<double>(j)*invK))*invK);
151 sum += weights[K][j];
152 }
153 weights[K][K] = static_cast<real_t>(1.0) - sum;
154 }
155 }
156
157
158 protected:
159
160
161 bool prepare( mesh_t& _m ) override
162 {
163 _m.add_property( vp_pos_ );
164 _m.add_property( ep_pos_ );
165 return true;
166 }
167
168
169 bool cleanup( mesh_t& _m ) override
170 {
171 _m.remove_property( vp_pos_ );
172 _m.remove_property( ep_pos_ );
173 return true;
174 }
175
176
177 bool subdivide( MeshType& _m, size_t _n , const bool _update_points = true) override
178 {
179
181
182 // Compute the maximal vertex valence in the mesh
183 unsigned int maxValence = 0;
184 for ( auto vertex : _m.vertices() ) {
185 maxValence = std::max(maxValence,_m.valence(vertex));
186 }
187
188 // We pre initialized with 30. If it's larger, we update the weights
189 if (maxValence >= 30) {
190 init_weights( maxValence + 1 );
191 }
192
193 // Do _n subdivisions
194 for (size_t i=0; i < _n; ++i)
195 {
196
197 // This is an interpolating scheme, old vertices remain the same.
198 for ( auto vh : _m.vertices())
199 _m.property( vp_pos_, vh ) = _m.point(vh);
200
201 // Compute position for new vertices and store them in the edge property
202 for (auto eh : _m.edges())
203 compute_midpoint( _m, eh);
204
205
206 // Split each edge at midpoint and store precomputed positions (stored in
207 // edge property ep_pos_) in the vertex property vp_pos_;
208
209 // Attention! Creating new edges, hence make sure the loop ends correctly.
210 for (auto eh : _m.edges())
211 split_edge(_m, eh );
212
213
214 // Commit changes in topology and reconsitute consistency
215
216 // Attention! Creating new faces, hence make sure the loop ends correctly.
217 for (auto fh : _m.faces())
218 split_face(_m, fh );
219
220
221 // Commit changes in geometry
222 for ( auto vh : _m.vertices())
223 _m.set_point(vh, _m.property( vp_pos_, vh ) );
224
225 #if defined(_DEBUG) || defined(DEBUG)
226 // Now we have an consistent mesh!
227 assert( OpenMesh::Utils::MeshCheckerT<mesh_t>(_m).check() );
228 #endif
229 }
230
231 return true;
232 }
233
234 private: // topological modifiers
235
236 void split_face(mesh_t& _m, const typename mesh_t::FaceHandle& _fh)
237 {
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)));
242
243 // Cutting off every corner of the 6_gon
244 corner_cutting( _m, heh1 );
245 corner_cutting( _m, heh2 );
246 corner_cutting( _m, heh3 );
247 }
248
249
250 void corner_cutting(mesh_t& _m, const typename mesh_t::HalfedgeHandle& _he)
251 {
252 // Define Halfedge Handles
253 typename mesh_t::HalfedgeHandle
254 heh1(_he),
255 heh5(heh1),
256 heh6(_m.next_halfedge_handle(heh1));
257
258 // Cycle around the polygon to find correct Halfedge
259 for (; _m.next_halfedge_handle(_m.next_halfedge_handle(heh5)) != heh1;
260 heh5 = _m.next_halfedge_handle(heh5))
261 {}
262
263 typename mesh_t::VertexHandle
264 vh1 = _m.to_vertex_handle(heh1),
265 vh2 = _m.to_vertex_handle(heh5);
266
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));
271
272 /* Intermediate result
273 *
274 * *
275 * 5 /|\
276 * /_ \
277 * vh2> * *
278 * /|\3 |\
279 * /_ \|4 \
280 * *----\*----\*
281 * 1 ^ 6
282 * vh1 (adjust_outgoing halfedge!)
283 */
284
285 // Old and new Face
286 typename mesh_t::FaceHandle fh_old(_m.face_handle(heh6));
287 typename mesh_t::FaceHandle fh_new(_m.new_face());
288
289
290 // Re-Set Handles around old Face
291 _m.set_next_halfedge_handle(heh4, heh6);
292 _m.set_next_halfedge_handle(heh5, heh4);
293
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);
298
299 // Re-Set Handles around new Face
300 _m.set_next_halfedge_handle(heh1, heh3);
301 _m.set_next_halfedge_handle(heh3, heh2);
302
303 _m.set_face_handle(heh1, fh_new);
304 _m.set_face_handle(heh2, fh_new);
305 _m.set_face_handle(heh3, fh_new);
306
307 _m.set_halfedge_handle(fh_new, heh1);
308 }
309
310
311 void split_edge(mesh_t& _m, const typename mesh_t::EdgeHandle& _eh)
312 {
313 typename mesh_t::HalfedgeHandle
314 heh = _m.halfedge_handle(_eh, 0),
315 opp_heh = _m.halfedge_handle(_eh, 1);
316
317 typename mesh_t::HalfedgeHandle new_heh, opp_new_heh, t_heh;
318 typename mesh_t::VertexHandle vh;
319 typename mesh_t::VertexHandle vh1(_m.to_vertex_handle(heh));
320 typename mesh_t::Point zero(0,0,0);
321
322 // new vertex
323 vh = _m.new_vertex( zero );
324
325 // memorize position, will be set later
326 _m.property( vp_pos_, vh ) = _m.property( ep_pos_, _eh );
327
328
329 // Re-link mesh entities
330 if (_m.is_boundary(_eh))
331 {
332 for (t_heh = heh;
333 _m.next_halfedge_handle(t_heh) != opp_heh;
334 t_heh = _m.opposite_halfedge_handle(_m.next_halfedge_handle(t_heh)))
335 {}
336 }
337 else
338 {
339 for (t_heh = _m.next_halfedge_handle(opp_heh);
340 _m.next_halfedge_handle(t_heh) != opp_heh;
341 t_heh = _m.next_halfedge_handle(t_heh) )
342 {}
343 }
344
345 new_heh = _m.new_edge(vh, vh1);
346 opp_new_heh = _m.opposite_halfedge_handle(new_heh);
347 _m.set_vertex_handle( heh, vh );
348
349 _m.set_next_halfedge_handle(t_heh, opp_new_heh);
350 _m.set_next_halfedge_handle(new_heh, _m.next_halfedge_handle(heh));
351 _m.set_next_halfedge_handle(heh, new_heh);
352 _m.set_next_halfedge_handle(opp_new_heh, opp_heh);
353
354 if (_m.face_handle(opp_heh).is_valid())
355 {
356 _m.set_face_handle(opp_new_heh, _m.face_handle(opp_heh));
357 _m.set_halfedge_handle(_m.face_handle(opp_new_heh), opp_new_heh);
358 }
359
360 _m.set_face_handle( new_heh, _m.face_handle(heh) );
361 _m.set_halfedge_handle( vh, new_heh);
362
363 // We cant reconnect a non existing face, so we skip this here if necessary
364 if ( !_m.is_boundary(heh) )
365 _m.set_halfedge_handle( _m.face_handle(heh), heh );
366
367 _m.set_halfedge_handle( vh1, opp_new_heh );
368
369 // Never forget this, when playing with the topology
370 _m.adjust_outgoing_halfedge( vh );
371 _m.adjust_outgoing_halfedge( vh1 );
372 }
373
374 private: // geometry helper
375
376 void compute_midpoint(mesh_t& _m, const typename mesh_t::EdgeHandle& _eh)
377 {
378 typename mesh_t::HalfedgeHandle heh, opp_heh;
379
380 heh = _m.halfedge_handle( _eh, 0);
381 opp_heh = _m.halfedge_handle( _eh, 1);
382
383 typename mesh_t::Point pos(0,0,0);
384
385 typename mesh_t::VertexHandle a_0(_m.to_vertex_handle(heh));
386 typename mesh_t::VertexHandle a_1(_m.to_vertex_handle(opp_heh));
387
388 // boundary edge: 4-point scheme
389 if (_m.is_boundary(_eh) )
390 {
391 pos = _m.point(a_0);
392 pos += _m.point(a_1);
393 pos *= static_cast<RealType>(9.0/16.0);
394 typename mesh_t::Point tpos;
395 if(_m.is_boundary(heh))
396 {
397 tpos = _m.point(_m.to_vertex_handle(_m.next_halfedge_handle(heh)));
398 tpos += _m.point(_m.to_vertex_handle(_m.opposite_halfedge_handle(_m.prev_halfedge_handle(heh))));
399 }
400 else
401 {
402 assert(_m.is_boundary(opp_heh));
403 tpos = _m.point(_m.to_vertex_handle(_m.next_halfedge_handle(opp_heh)));
404 tpos += _m.point(_m.to_vertex_handle(_m.opposite_halfedge_handle(_m.prev_halfedge_handle(opp_heh))));
405 }
406 tpos *= static_cast<RealType>(-1.0/16.0);
407 pos += tpos;
408 }
409 else
410 {
411 int valence_a_0 = _m.valence(a_0);
412 int valence_a_1 = _m.valence(a_1);
413 assert(valence_a_0>2);
414 assert(valence_a_1>2);
415
416 if( (valence_a_0==6 && valence_a_1==6) || (_m.is_boundary(a_0) && valence_a_1==6) || (_m.is_boundary(a_1) && valence_a_0==6) || (_m.is_boundary(a_0) && _m.is_boundary(a_1)) )// use 8-point scheme
417 {
418 real_t alpha = real_t(1.0/2);
419 real_t beta = real_t(1.0/8);
420 real_t gamma = real_t(-1.0/16);
421
422 //get points
423 typename mesh_t::VertexHandle b_0, b_1, c_0, c_1, c_2, c_3;
424 typename mesh_t::HalfedgeHandle t_he;
425
426 t_he = _m.next_halfedge_handle(_m.opposite_halfedge_handle(heh));
427 b_0 = _m.to_vertex_handle(t_he);
428 if(!_m.is_boundary(_m.opposite_halfedge_handle(t_he)))
429 {
430 t_he = _m.next_halfedge_handle(_m.opposite_halfedge_handle(t_he));
431 c_0 = _m.to_vertex_handle(t_he);
432 }
433
434 t_he = _m.opposite_halfedge_handle(_m.prev_halfedge_handle(heh));
435 b_1 = _m.to_vertex_handle(t_he);
436 if(!_m.is_boundary(t_he))
437 {
438 t_he = _m.opposite_halfedge_handle(_m.prev_halfedge_handle(t_he));
439 c_1 = _m.to_vertex_handle(t_he);
440 }
441
442 t_he = _m.next_halfedge_handle(_m.opposite_halfedge_handle(opp_heh));
443 assert(b_1.idx()==_m.to_vertex_handle(t_he).idx());
444 if(!_m.is_boundary(_m.opposite_halfedge_handle(t_he)))
445 {
446 t_he = _m.next_halfedge_handle(_m.opposite_halfedge_handle(t_he));
447 c_2 = _m.to_vertex_handle(t_he);
448 }
449
450 t_he = _m.opposite_halfedge_handle(_m.prev_halfedge_handle(opp_heh));
451 assert(b_0==_m.to_vertex_handle(t_he));
452 if(!_m.is_boundary(t_he))
453 {
454 t_he = _m.opposite_halfedge_handle(_m.prev_halfedge_handle(t_he));
455 c_3 = _m.to_vertex_handle(t_he);
456 }
457
458 //compute position.
459 //a0,a1,b0,b1 must exist.
460 assert(a_0.is_valid());
461 assert(a_1.is_valid());
462 assert(b_0.is_valid());
463 assert(b_1.is_valid());
464 //The other vertices may be created from symmetry is they are on the other side of the boundary.
465
466 pos = _m.point(a_0);
467 pos += _m.point(a_1);
468 pos *= alpha;
469
470 typename mesh_t::Point tpos ( _m.point(b_0) );
471 tpos += _m.point(b_1);
472 tpos *= beta;
473 pos += tpos;
474
475 typename mesh_t::Point pc_0, pc_1, pc_2, pc_3;
476 if(c_0.is_valid())
477 pc_0 = _m.point(c_0);
478 else //create the point by symmetry
479 {
480 pc_0 = _m.point(a_1) + _m.point(b_0) - _m.point(a_0);
481 }
482 if(c_1.is_valid())
483 pc_1 = _m.point(c_1);
484 else //create the point by symmetry
485 {
486 pc_1 = _m.point(a_1) + _m.point(b_1) - _m.point(a_0);
487 }
488 if(c_2.is_valid())
489 pc_2 = _m.point(c_2);
490 else //create the point by symmetry
491 {
492 pc_2 = _m.point(a_0) + _m.point(b_1) - _m.point(a_1);
493 }
494 if(c_3.is_valid())
495 pc_3 = _m.point(c_3);
496 else //create the point by symmetry
497 {
498 pc_3 = _m.point(a_0) + _m.point(b_0) - _m.point(a_1);
499 }
500 tpos = pc_0;
501 tpos += pc_1;
502 tpos += pc_2;
503 tpos += pc_3;
504 tpos *= gamma;
505 pos += tpos;
506 }
507 else //at least one endpoint is [irregular and not in boundary]
508 {
509 RealType normFactor = static_cast<RealType>(0.0);
510
511 if(valence_a_0!=6 && !_m.is_boundary(a_0))
512 {
513 assert((int)weights[valence_a_0].size()==valence_a_0+1);
514 typename mesh_t::HalfedgeHandle t_he = opp_heh;
515 for(int i = 0; i < valence_a_0 ; t_he=_m.next_halfedge_handle(_m.opposite_halfedge_handle(t_he)), ++i)
516 {
517 pos += weights[valence_a_0][i] * _m.point(_m.to_vertex_handle(t_he));
518 }
519 assert(t_he==opp_heh);
520
521 //add irregular vertex:
522 pos += weights[valence_a_0][valence_a_0] * _m.point(a_0);
523 ++normFactor;
524 }
525
526 if(valence_a_1!=6 && !_m.is_boundary(a_1))
527 {
528 assert((int)weights[valence_a_1].size()==valence_a_1+1);
529 typename mesh_t::HalfedgeHandle t_he = heh;
530 for(int i = 0; i < valence_a_1 ; t_he=_m.next_halfedge_handle(_m.opposite_halfedge_handle(t_he)), ++i)
531 {
532 pos += weights[valence_a_1][i] * _m.point(_m.to_vertex_handle(t_he));
533 }
534 assert(t_he==heh);
535 //add irregular vertex:
536 pos += weights[valence_a_1][valence_a_1] * _m.point(a_1);
537 ++normFactor;
538 }
539
540 assert(normFactor>0.1); //normFactor should be 1 or 2
541
542 //if both vertices are irregular, average positions:
543 pos /= normFactor;
544 }
545 }
546 _m.property( ep_pos_, _eh ) = pos;
547 }
548
549 private: // data
550
551 OpenMesh::VPropHandleT< typename mesh_t::Point > vp_pos_;
552 OpenMesh::EPropHandleT< typename mesh_t::Point > ep_pos_;
553
554 weights_t weights;
555
556 };
557
558 } // END_NS_UNIFORM
559 } // END_NS_SUBDIVIDER
560 } // END_NS_OPENMESH
561 #endif
562
SubdividerT.hh
OpenMesh
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:59
OpenMesh::TriMesh_ArrayKernelT
Triangle mesh based on the ArrayKernel.
Definition: TriMesh_ArrayKernelT.hh:96
OpenMesh::PolyMeshT::VertexHandle
Kernel::VertexHandle VertexHandle
Handle for referencing the corresponding item.
Definition: PolyMeshT.hh:136
OpenMesh::PolyMeshT::EdgeHandle
Kernel::EdgeHandle EdgeHandle
Scalar type.
Definition: PolyMeshT.hh:138
OpenMesh::PolyMeshT::new_vertex
SmartVertexHandle new_vertex()
Uses default copy and assignment operator.
Definition: PolyMeshT.hh:201
OpenMesh::PolyMeshT::FaceHandle
Kernel::FaceHandle FaceHandle
Scalar type.
Definition: PolyMeshT.hh:139
OpenMesh::PolyMeshT::HalfedgeHandle
Kernel::HalfedgeHandle HalfedgeHandle
Scalar type.
Definition: PolyMeshT.hh:137
OpenMesh::PolyMeshT::Point
Kernel::Point Point
Coordinate type.
Definition: PolyMeshT.hh:112
OpenMesh::VPropHandleT< typename mesh_t::Point >
OpenMesh::EPropHandleT< typename mesh_t::Point >
OpenMesh::Subdivider::Uniform::ModifiedButterflyT
Modified Butterfly subdivision algorithm.
Definition: ModifiedButterFlyT.hh:93
OpenMesh::Subdivider::Uniform::ModifiedButterflyT::subdivide
bool subdivide(MeshType &_m, size_t _n, const bool _update_points=true) override
Subdivide mesh _m _n times.
Definition: ModifiedButterFlyT.hh:177
OpenMesh::Subdivider::Uniform::ModifiedButterflyT::init_weights
void init_weights(size_t _max_valence=30)
Pre-compute weights.
Definition: ModifiedButterFlyT.hh:124
OpenMesh::Subdivider::Uniform::ModifiedButterflyT::cleanup
bool cleanup(mesh_t &_m) override
Cleanup mesh after usage, e.g. remove added properties.
Definition: ModifiedButterFlyT.hh:169
OpenMesh::Subdivider::Uniform::ModifiedButterflyT::name
const char * name() const override
Return name of subdivision algorithm.
Definition: ModifiedButterFlyT.hh:120
OpenMesh::Subdivider::Uniform::ModifiedButterflyT::prepare
bool prepare(mesh_t &_m) override
Prepare mesh, e.g. add properties.
Definition: ModifiedButterFlyT.hh:161
OpenMesh::Subdivider::Uniform::SubdividerT
Abstract base class for uniform subdivision algorithms.
Definition: SubdividerT.hh:89
OpenMesh::Utils::MeshCheckerT
Check integrity of mesh.
Definition: MeshCheckerT.hh:74