Developer Documentation
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
CompositeT.cc
Go to the documentation of this file.
1 /* ========================================================================= *
2  * *
3  * OpenMesh *
4  * Copyright (c) 2001-2015, 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 
42 /*===========================================================================*\
43  * *
44  * $Revision$ *
45  * $Date$ *
46  * *
47 \*===========================================================================*/
48 
53 //=============================================================================
54 //
55 // CLASS CompositeT - IMPLEMENTATION
56 //
57 //=============================================================================
58 
59 #ifndef OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_CC
60 #define OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_CC
61 
62 
63 //== INCLUDES =================================================================
64 
65 
66 #include <vector>
67 #include <OpenMesh/Tools/Subdivider/Uniform/Composite/CompositeT.hh>
68 
69 
70 //== NAMESPACE ================================================================
71 
72 namespace OpenMesh { // BEGIN_NS_OPENMESH
73 namespace Subdivider { // BEGIN_NS_DECIMATER
74 namespace Uniform { // BEGIN_NS_UNIFORM
75 
76 
77 //== IMPLEMENTATION ==========================================================
78 
79 
80 template <typename MeshType, typename RealType>
81 bool CompositeT<MeshType,RealType>::prepare( MeshType& _m )
82 {
83  // store mesh for later usage in subdivide(), cleanup() and all rules.
84  p_mesh_ = &_m;
85 
86  typename MeshType::VertexIter v_it(_m.vertices_begin());
87 
88  for (; v_it != _m.vertices_end(); ++v_it)
89  _m.data(*v_it).set_position(_m.point(*v_it));
90 
91  return true;
92 }
93 
94 
95 
96 template<typename MeshType, typename RealType>
97 void CompositeT<MeshType,RealType>::Tvv3()
98 {
99  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
100 
101  typename MeshType::VertexHandle vh;
102  typename MeshType::FaceIter f_it;
103  typename MeshType::EdgeIter e_it;
104  typename MeshType::VertexIter v_it;
105  typename MeshType::Point zero_point(0.0, 0.0, 0.0);
106  size_t n_edges, n_faces, n_vertices, j;
107 
108  // Store number of original edges
109  n_faces = mesh_.n_faces();
110  n_edges = mesh_.n_edges();
111  n_vertices = mesh_.n_vertices();
112 
113  // reserve enough memory for iterator
114  mesh_.reserve(n_vertices + n_faces, n_edges + 3 * n_faces, 3 * n_faces);
115 
116  // set new positions for vertices
117  v_it = mesh_.vertices_begin();
118  for (j = 0; j < n_vertices; ++j) {
119  mesh_.data(*v_it).set_position(mesh_.data(*v_it).position() * 3.0);
120  ++v_it;
121  }
122 
123  // Split each face
124  f_it = mesh_.faces_begin();
125  for (j = 0; j < n_faces; ++j) {
126 
127  vh = mesh_.add_vertex(zero_point);
128 
129  mesh_.data(vh).set_position(zero_point);
130 
131  mesh_.split(*f_it, vh);
132 
133  ++f_it;
134  }
135 
136  // Flip each old edge
137  std::vector<typename MeshType::EdgeHandle> edge_vector;
138  edge_vector.clear();
139 
140  e_it = mesh_.edges_begin();
141  for (j = 0; j < n_edges; ++j) {
142  if (mesh_.is_flip_ok(*e_it)) {
143  mesh_.flip(*e_it);
144  } else {
145  edge_vector.push_back(*e_it);
146  }
147  ++e_it;
148  }
149 
150  // split all boundary edges
151  while (!edge_vector.empty()) {
152  vh = mesh_.add_vertex(zero_point);
153  mesh_.data(vh).set_position(zero_point);
154  mesh_.split(edge_vector.back(), vh);
155  edge_vector.pop_back();
156  }
157 }
158 
159 
160 template<typename MeshType, typename RealType>
161 void CompositeT<MeshType,RealType>::Tvv4()
162 {
163  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
164 
165  typename MeshType::VertexHandle vh;
166  typename MeshType::FaceIter f_it;
167  typename MeshType::EdgeIter e_it;
168  typename MeshType::VertexIter v_it;
169  typename MeshType::Point zero_point(0.0, 0.0, 0.0);
170  size_t n_edges, n_faces, n_vertices, j;
171 
172  // Store number of original edges
173  n_faces = mesh_.n_faces();
174  n_edges = mesh_.n_edges();
175  n_vertices = mesh_.n_vertices();
176 
177  // reserve memory ahead for the succeeding operations
178  mesh_.reserve(n_vertices + n_edges, 2 * n_edges + 3 * n_faces, 4 * n_faces);
179 
180  // set new positions for vertices
181  v_it = mesh_.vertices_begin();
182  for (j = 0; j < n_vertices; ++j) {
183  mesh_.data(*v_it).set_position(mesh_.data(*v_it).position() * 4.0);
184  ++v_it;
185  }
186 
187  // Split each edge
188  e_it = mesh_.edges_begin();
189  for (j = 0; j < n_edges; ++j) {
190 
191  vh = split_edge(mesh_.halfedge_handle(*e_it, 0));
192  mesh_.data(vh).set_position(zero_point);
193 
194  ++e_it;
195  }
196 
197  // Corner Cutting of Each Face
198  f_it = mesh_.faces_begin();
199  for (j = 0; j < n_faces; ++j) {
200  typename MeshType::HalfedgeHandle heh1(mesh_.halfedge_handle(*f_it));
201  typename MeshType::HalfedgeHandle heh2(mesh_.next_halfedge_handle(mesh_.next_halfedge_handle(heh1)));
202  typename MeshType::HalfedgeHandle heh3(mesh_.next_halfedge_handle(mesh_.next_halfedge_handle(heh2)));
203 
204  // Cutting off every corner of the 6_gon
205 
206  corner_cutting(heh1);
207  corner_cutting(heh2);
208  corner_cutting(heh3);
209 
210  ++f_it;
211  }
212 }
213 
214 
215 template<typename MeshType, typename RealType>
216 void CompositeT<MeshType,RealType>::Tfv()
217 {
218  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
219 
220  typename MeshType::VertexHandle vh;
221  typename MeshType::FaceIter f_it;
222  typename MeshType::EdgeIter e_it;
223  typename MeshType::VertexIter v_it;
224  typename MeshType::VertexFaceIter vf_it;
225  typename MeshType::FaceFaceIter ff_it;
226  typename MeshType::Point cog;
227  const typename MeshType::Point zero_point(0.0, 0.0, 0.0);
228  size_t n_edges, n_faces, n_vertices, j, valence;
229 
230  // Store number of original edges
231  n_faces = mesh_.n_faces();
232  n_edges = mesh_.n_edges();
233  n_vertices = mesh_.n_vertices();
234 
235  // reserve enough space for iterator
236  mesh_.reserve(n_vertices + n_faces, n_edges + 3 * n_faces, 3 * n_faces);
237 
238  // set new positions for vertices
239  v_it = mesh_.vertices_begin();
240  for (j = 0; j < n_vertices; ++j) {
241  valence = 0;
242  cog = zero_point;
243  for (vf_it = mesh_.vf_iter(*v_it); vf_it; ++vf_it) {
244  ++valence;
245  cog += vf_it->position();
246  }
247  cog /= valence;
248 
249  v_it->set_position(cog);
250  ++v_it;
251  }
252 
253  // Split each face, insert new vertex and calculate position
254  f_it = mesh_.faces_begin();
255  for (j = 0; j < n_faces; ++j) {
256 
257  vh = mesh_.add_vertex();
258 
259  valence = 0;
260  cog = zero_point;
261  for (ff_it = mesh_.ff_iter(*f_it); ff_it; ++ff_it) {
262  ++valence;
263  cog += ff_it->position();
264  }
265  cog /= valence;
266 
267  mesh_.split(*f_it, vh);
268 
269  for (vf_it = mesh_.vf_iter(vh); vf_it; ++vf_it) {
270  vf_it->set_position(f_it->position());
271  }
272 
273  mesh_.deref(vh).set_position(cog);
274 
275  mesh_.set_point(vh, cog);
276 
277  ++f_it;
278  }
279 
280  // Flip each old edge
281  e_it = mesh_.edges_begin();
282  for (j = 0; j < n_edges; ++j) {
283  if (mesh_.is_flip_ok(*e_it))
284  mesh_.flip(*e_it);
285  ++e_it;
286  }
287 }
288 
289 
290 
291 template<typename MeshType, typename RealType>
292 void CompositeT<MeshType,RealType>::VF()
293 {
294  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
295 
296  typename MeshType::Point cog,zero_point(0.0, 0.0, 0.0);
297  typename MeshType::FaceVertexIter fv_it;
298  typename MeshType::FaceIter f_it;
299 
300  for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
301 
302  unsigned int valence = 0;
303  cog = zero_point;
304 
305  for (fv_it = mesh_.fv_iter(*f_it); fv_it.is_valid(); ++fv_it) {
306  cog += mesh_.data(*fv_it).position();
307  ++valence;
308  }
309  cog /= valence;
310  mesh_.data(*f_it).set_position(cog);
311  }
312 }
313 
314 
315 template<typename MeshType, typename RealType>
316 void CompositeT<MeshType,RealType>::VFa(Coeff& _coeff)
317 {
318  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
319 
320  unsigned int valence[3], i;
321  typename MeshType::Point cog,zero_point(0.0, 0.0, 0.0);
322  typename MeshType::Scalar alpha;
323  typename MeshType::FaceIter f_it;
324  typename MeshType::HalfedgeHandle heh;
325  typename MeshType::VertexHandle vh[3];
326  typename MeshType::VertexOHalfedgeIter voh_it;
327  typename MeshType::FaceVertexIter fv_it;
328 
329  for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
330 
331  heh = mesh_.halfedge_handle(*f_it);
332  for (i = 0; i <= 2; ++i) {
333 
334  valence[i] = 0;
335  vh[i] = mesh_.to_vertex_handle(heh);
336 
337  for (voh_it = mesh_.voh_iter(vh[i]); voh_it; ++voh_it) {
338  ++valence[i];
339  }
340 
341  heh = mesh_.next_halfedge_handle(heh);
342  }
343 
344  if (valence[0] <= valence[1])
345  if (valence[0] <= valence[2])
346  i = 0;
347  else
348  i = 2;
349  else
350  if (valence[1] <= valence[2])
351  i = 1;
352  else
353  i = 2;
354 
355  alpha = _coeff(valence[i]);
356 
357  cog = zero_point;
358 
359  for (fv_it = mesh_.fv_iter(*f_it); fv_it.is_valid(); ++fv_it) {
360  if (*fv_it == vh[i]) {
361  cog += fv_it->position() * alpha;
362  } else {
363  cog += fv_it->position() * (1.0 - alpha) / 2.0;
364  }
365  }
366 
367  f_it->set_position(cog);
368  }
369 }
370 
371 
372 template<typename MeshType, typename RealType>
373 void CompositeT<MeshType,RealType>::VFa(scalar_t _alpha)
374 {
375  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
376 
377  unsigned int valence[3], i;
378  typename MeshType::Point cog,
379  zero_point(0.0, 0.0, 0.0);
380  typename MeshType::FaceIter f_it;
381  typename MeshType::HalfedgeHandle heh;
382  typename MeshType::VertexHandle vh[3];
383  typename MeshType::VertexOHalfedgeIter voh_it;
384  typename MeshType::FaceVertexIter fv_it;
385 
386  for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
387 
388  heh = mesh_.halfedge_handle(*f_it);
389  for (i = 0; i <= 2; ++i) {
390 
391  valence[i] = 0;
392  vh[i] = mesh_.to_vertex_handle(heh);
393 
394  for (voh_it = mesh_.voh_iter(vh[i]); voh_it; ++voh_it) {
395  ++valence[i];
396  }
397 
398  heh = mesh_.next_halfedge_handle(heh);
399  }
400 
401  if (valence[0] <= valence[1])
402  if (valence[0] <= valence[2])
403  i = 0;
404  else
405  i = 2;
406  else
407  if (valence[1] <= valence[2])
408  i = 1;
409  else
410  i = 2;
411 
412  cog = zero_point;
413 
414  for (fv_it = mesh_.fv_iter(*f_it); fv_it.is_valid(); ++fv_it) {
415  if (*fv_it == vh[i]) {
416  cog += fv_it->position() * _alpha;
417  } else {
418  cog += fv_it->position() * (1.0 - _alpha) / 2.0;
419  }
420  }
421 
422  f_it->set_position(cog);
423  }
424 }
425 
426 
427 template<typename MeshType, typename RealType>
428 void CompositeT<MeshType,RealType>::FF()
429 {
430  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
431 
432  typename MeshType::Point cog,
433  zero_point(0.0, 0.0, 0.0);
434  typename MeshType::FaceFaceIter ff_it;
435  typename MeshType::FaceIter f_it;
436  std::vector<typename MeshType::Point> point_vector;
437 
438  point_vector.clear();
439 
440  for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it)
441  {
442  unsigned int valence = 0;
443  cog = zero_point;
444 
445  for (ff_it = mesh_.ff_iter(*f_it); ff_it.is_valid(); ++ff_it)
446  {
447  cog += mesh_.data(*ff_it).position();
448  ++valence;
449  }
450  cog /= valence;
451  point_vector.push_back(cog);
452  }
453 
454  for (f_it = mesh_.faces_end(); f_it != mesh_.faces_begin(); )
455  {
456  --f_it;
457  mesh_.data(*f_it).set_position(point_vector.back());
458  point_vector.pop_back();
459  }
460 }
461 
462 
463 template<typename MeshType, typename RealType>
464 void CompositeT<MeshType,RealType>::FFc(Coeff& _coeff)
465 {
466  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
467 
468  typename MeshType::Point cog,
469  zero_point(0.0, 0.0, 0.0);
470  typename MeshType::FaceFaceIter ff_it;
471  typename MeshType::FaceIter f_it;
472  typename MeshType::Scalar c;
473  std::vector<typename MeshType::Point> point_vector;
474 
475  for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
476 
477  unsigned int valence = 0;
478  cog = zero_point;
479 
480  for (ff_it = mesh_.ff_iter(*f_it); ff_it; ++ff_it) {
481  cog += ff_it->position();
482  ++valence;
483  }
484  cog /= valence;
485 
486  c = _coeff(valence);
487 
488  cog = cog * (1.0 - c) + f_it->position() * c;
489 
490  point_vector.push_back(cog);
491 
492  }
493  for (f_it = mesh_.faces_end(); f_it != mesh_.faces_begin(); ) {
494 
495  --f_it;
496  f_it->set_position(point_vector.back());
497  point_vector.pop_back();
498 
499  }
500 }
501 
502 
503 template<typename MeshType, typename RealType>
504 void CompositeT<MeshType,RealType>::FFc(scalar_t _c)
505 {
506  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
507 
508  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
509  typename MeshType::FaceFaceIter ff_it;
510  typename MeshType::FaceIter f_it;
511  std::vector<typename MeshType::Point> point_vector;
512 
513  for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
514 
515  unsigned int valence = 0;
516  cog = zero_point;
517 
518  for (ff_it = mesh_.ff_iter(*f_it); ff_it; ++ff_it) {
519  cog += ff_it->position();
520  ++valence;
521  }
522  cog /= valence;
523 
524  cog = cog * (1.0 - _c) + f_it->position() * _c;
525 
526  point_vector.push_back(cog);
527 
528  }
529  for (f_it = mesh_.faces_end(); f_it != mesh_.faces_begin(); ) {
530 
531  --f_it;
532  f_it->set_position(point_vector.back());
533  point_vector.pop_back();
534  }
535 }
536 
537 
538 template<typename MeshType, typename RealType>
539 void CompositeT<MeshType,RealType>::FV()
540 {
541  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
542 
543  typename MeshType::Point cog,
544  zero_point(0.0, 0.0, 0.0);
545  typename MeshType::VertexFaceIter vf_it;
546  typename MeshType::VertexIter v_it;
547 
548  for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
549 
550  unsigned int valence = 0;
551  cog = zero_point;
552 
553  for (vf_it = mesh_.vf_iter(*v_it); vf_it; ++vf_it) {
554  cog += vf_it->position();
555  ++valence;
556  }
557  cog /= valence;
558  v_it->set_position(cog);
559  }
560 }
561 
562 
563 template<typename MeshType, typename RealType>
564 void CompositeT<MeshType,RealType>::FVc(Coeff& _coeff)
565 {
566  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
567 
568 
569  typename MeshType::Point cog,
570  zero_point(0.0, 0.0, 0.0);
571  scalar_t c;
572  typename MeshType::VertexOHalfedgeIter voh_it;
573  typename MeshType::VertexIter v_it;
574 
575  for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
576 
577  unsigned int valence = 0;
578  cog = zero_point;
579 
580  for (voh_it = mesh_.voh_iter(*v_it); voh_it.is_valid(); ++voh_it) {
581  ++valence;
582  }
583 
584  c = _coeff(valence);
585 
586  for (voh_it = mesh_.voh_iter(*v_it); voh_it.is_valid(); ++voh_it) {
587 
588  if (mesh_.face_handle(*voh_it).is_valid()) {
589 
590  if (mesh_.face_handle(mesh_.opposite_halfedge_handle(mesh_.next_halfedge_handle(*voh_it))).is_valid()) {
591  cog += mesh_.data(mesh_.face_handle(*voh_it)).position() * c;
592  cog += mesh_.data(mesh_.face_handle(mesh_.opposite_halfedge_handle(mesh_.next_halfedge_handle(*voh_it)))).position() * (1.0 - c);
593  } else {
594  cog += mesh_.data(mesh_.face_handle(*voh_it)).position();
595  }
596  } else {
597  --valence;
598  }
599  }
600 
601  if (valence > 0)
602  cog /= valence;
603 
604  mesh_.data(*v_it).set_position(cog);
605  }
606 }
607 
608 
609 template<typename MeshType, typename RealType>
610 void CompositeT<MeshType,RealType>::FVc(scalar_t _c)
611 {
612  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
613 
614  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
615  typename MeshType::VertexOHalfedgeIter voh_it;
616  typename MeshType::VertexIter v_it;
617 
618  for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
619 
620  unsigned int valence = 0;
621  cog = zero_point;
622 
623  for (voh_it = mesh_.voh_iter(*v_it); voh_it; ++voh_it) {
624  ++valence;
625  }
626 
627  for (voh_it = mesh_.voh_iter(*v_it); voh_it; ++voh_it) {
628 
629  if (mesh_.face_handle(*voh_it).is_valid()) {
630 
631  if (mesh_.face_handle(mesh_.opposite_halfedge_handle(mesh_.next_halfedge_handle(*voh_it))).is_valid()) {
632  cog += mesh_.deref(mesh_.face_handle(*voh_it)).position() * _c;
633  cog += mesh_.deref(mesh_.face_handle(mesh_.opposite_halfedge_handle(mesh_.next_halfedge_handle(*voh_it)))).position() * (1.0 - _c);
634  } else {
635  cog += mesh_.deref(mesh_.face_handle(*voh_it)).position();
636  }
637  } else {
638  --valence;
639  }
640  }
641 
642  if (valence > 0)
643  cog /= valence;
644 
645  v_it->set_position(cog);
646  }
647 }
648 
649 
650 template<typename MeshType, typename RealType>
651 void CompositeT<MeshType,RealType>::VdE()
652 {
653  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
654 
655  typename MeshType::EdgeIter e_it;
656  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
657  typename MeshType::HalfedgeHandle heh1, heh2;
658 
659  for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
660 
661  cog = zero_point;
662  unsigned int valence = 2;
663 
664  heh1 = mesh_.halfedge_handle(*e_it, 0);
665  heh2 = mesh_.opposite_halfedge_handle(heh1);
666  cog += mesh_.data(mesh_.to_vertex_handle(heh1)).position();
667  cog += mesh_.data(mesh_.to_vertex_handle(heh2)).position();
668 
669  if (!mesh_.is_boundary(heh1)) {
670  cog += mesh_.data(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh1))).position();
671  ++valence;
672  }
673 
674  if (!mesh_.is_boundary(heh2)) {
675  cog += mesh_.data(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh2))).position();
676  ++valence;
677  }
678 
679  cog /= valence;
680 
681  mesh_.data(*e_it).set_position(cog);
682  }
683 }
684 
685 
686 template<typename MeshType, typename RealType>
687 void CompositeT<MeshType,RealType>::VdEc(scalar_t _c)
688 {
689  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
690 
691  typename MeshType::EdgeIter e_it;
692  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
693  typename MeshType::HalfedgeHandle heh;
694 
695  for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
696 
697  cog = zero_point;
698 
699  for (int i = 0; i <= 1; ++i) {
700 
701  heh = mesh_.halfedge_handle(*e_it, i);
702  if (!mesh_.is_boundary(heh))
703  {
704  cog += mesh_.point(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh))) * (0.5 - _c);
705  cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * _c;
706  }
707  else
708  {
709  cog += mesh_.data(mesh_.to_vertex_handle(heh)).position();
710  }
711  }
712 
713  mesh_.data(*e_it).set_position(cog);
714  }
715 }
716 
717 
718 template<typename MeshType, typename RealType>
719 void CompositeT<MeshType,RealType>::VdEg(scalar_t _gamma)
720 {
721  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
722 
723  typename MeshType::EdgeIter e_it;
724  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
725  typename MeshType::HalfedgeHandle heh;
726  typename MeshType::VertexOHalfedgeIter voh_it;
727  unsigned int valence[2], i;
728 
729  for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
730 
731  cog = zero_point;
732 
733  for (i = 0; i <= 1; ++i)
734  {
735  heh = mesh_.halfedge_handle(*e_it, i);
736  valence[i] = 0;
737 
738  // look for lowest valence vertex
739  for (voh_it = mesh_.voh_iter(mesh_.to_vertex_handle(heh)); voh_it; ++voh_it)
740  {
741  ++valence[i];
742  }
743  }
744 
745  if (valence[0] < valence[1])
746  i = 0;
747  else
748  i = 1;
749 
750  heh = mesh_.halfedge_handle(*e_it, i);
751 
752  if (!mesh_.is_boundary(heh)) {
753  cog += mesh_.point(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh))) * (_gamma);
754  cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * (1.0 - 3.0 * _gamma);
755  } else {
756  cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * (1.0 - 2.0 * _gamma);
757  }
758 
759 
760  heh = mesh_.halfedge_handle(*e_it, 1-i);
761 
762  if (!mesh_.is_boundary(heh))
763  {
764  cog += mesh_.point(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh))) * (_gamma);
765  cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * _gamma;
766  }
767  else
768  {
769  cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * 2.0 * _gamma;
770  }
771 
772  mesh_.data(*e_it).set_position(cog);
773  }
774 }
775 
776 
777 template<typename MeshType, typename RealType>
778 void CompositeT<MeshType,RealType>::VdEg(Coeff& _coeff)
779 {
780  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
781 
782  typename MeshType::EdgeIter e_it;
783  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
784  typename MeshType::HalfedgeHandle heh;
785  typename MeshType::VertexOHalfedgeIter voh_it;
786  unsigned int valence[2], i;
787  scalar_t gamma;
788 
789  for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
790 
791  cog = zero_point;
792 
793  for (i = 0; i <= 1; ++i) {
794 
795  heh = mesh_.halfedge_handle(*e_it, i);
796  valence[i] = 0;
797 
798  // look for lowest valence vertex
799  for (voh_it = mesh_.voh_iter(mesh_.to_vertex_handle(heh)); voh_it; ++voh_it)
800  {
801  ++valence[i];
802  }
803  }
804 
805  if (valence[0] < valence[1])
806  i = 0;
807  else
808  i = 1;
809 
810  gamma = _coeff(valence[i]);
811 
812  heh = mesh_.halfedge_handle(*e_it, i);
813 
814  if (!mesh_.is_boundary(heh))
815  {
816  cog += mesh_.point(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh))) * (gamma);
817  cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * (1.0 - 3.0 * gamma);
818  }
819  else
820  {
821  cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * (1.0 - 2.0 * gamma);
822  }
823 
824 
825  heh = mesh_.halfedge_handle(*e_it, 1-i);
826 
827  if (!mesh_.is_boundary(heh)) {
828  cog += mesh_.point(mesh_.to_vertex_handle(mesh_.next_halfedge_handle(heh))) * (gamma);
829  cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * gamma;
830  } else {
831  cog += mesh_.data(mesh_.to_vertex_handle(heh)).position() * 2.0 * gamma;
832  }
833 
834  mesh_.data(*e_it).set_position(cog);
835  }
836 }
837 
838 
839 template<typename MeshType, typename RealType>
840 void CompositeT<MeshType,RealType>::EV()
841 {
842  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
843 
844  typename MeshType::VertexIter v_it;
845  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
846  typename MeshType::VertexEdgeIter ve_it;
847 
848  for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it)
849  {
850  unsigned int valence = 0;
851  cog = zero_point;
852 
853  for (ve_it = mesh_.ve_iter(*v_it); ve_it; ++ve_it) {
854  cog += mesh_.data(ve_it).position();
855  ++valence;
856  }
857 
858  cog /= valence;
859 
860  mesh_.data(*v_it).set_position(cog);
861  }
862 }
863 
864 
865 template<typename MeshType, typename RealType>
866 void CompositeT<MeshType,RealType>::EVc(Coeff& _coeff)
867 {
868  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
869 
870  typename MeshType::VertexIter v_it;
871  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
872  typename MeshType::VertexOHalfedgeIter voh_it;
873  scalar_t c;
874 
875  for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it)
876  {
877  unsigned int valence = 0;
878  cog = zero_point;
879 
880  for (voh_it = mesh_.voh_iter(*v_it); voh_it.is_valid(); ++voh_it)
881  {
882  ++valence;
883  }
884 
885  c = _coeff(valence);
886 
887  for (voh_it = mesh_.voh_iter(*v_it); voh_it.is_valid(); ++voh_it) {
888  cog += mesh_.data(mesh_.edge_handle(*voh_it)).position() * c;
889  cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(*voh_it))).position() * (1.0 - c);
890  }
891 
892  cog /= valence;
893 
894  mesh_.data(*v_it).set_position(cog);
895  }
896 }
897 
898 
899 template<typename MeshType, typename RealType>
900 void CompositeT<MeshType,RealType>::EVc(scalar_t _c)
901 {
902  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
903  typename MeshType::VertexIter v_it;
904  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
905  typename MeshType::VertexOHalfedgeIter voh_it;
906 
907  for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
908  unsigned int valence = 0;
909  cog = zero_point;
910 
911  for (voh_it = mesh_.voh_iter(*v_it); voh_it; ++voh_it) {
912  ++valence;
913  }
914 
915  for (voh_it = mesh_.voh_iter(*v_it); voh_it; ++voh_it) {
916  cog += mesh_.data(mesh_.edge_handle(*voh_it)).position() * _c;
917  cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(*voh_it))).position() * (1.0 - _c);
918  }
919 
920  cog /= valence;
921 
922  mesh_.data(*v_it).set_position(cog);
923  }
924 }
925 
926 
927 template<typename MeshType, typename RealType>
928 void CompositeT<MeshType,RealType>::EF()
929 {
930  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
931 
932  typename MeshType::FaceIter f_it;
933  typename MeshType::FaceEdgeIter fe_it;
934  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
935 
936  for (f_it = mesh_.faces_begin(); f_it != mesh_.faces_end(); ++f_it) {
937  unsigned int valence = 0;
938  cog = zero_point;
939 
940  for (fe_it = mesh_.fe_iter(*f_it); fe_it; ++fe_it) {
941  ++valence;
942  cog += mesh_.data(fe_it).position();
943  }
944 
945  cog /= valence;
946  mesh_.data(*f_it).set_position(cog);
947  }
948 }
949 
950 
951 template<typename MeshType, typename RealType>
952 void CompositeT<MeshType,RealType>::FE()
953 {
954  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
955 
956  typename MeshType::EdgeIter e_it;
957  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
958 
959  for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
960  unsigned int valence = 0;
961  cog = zero_point;
962 
963  if (mesh_.face_handle(mesh_.halfedge_handle(*e_it, 0)).is_valid()) {
964  cog += mesh_.data(mesh_.face_handle(mesh_.halfedge_handle(*e_it, 0))).position();
965  ++valence;
966  }
967 
968  if (mesh_.face_handle(mesh_.halfedge_handle(*e_it, 1)).is_valid()) {
969  cog += mesh_.data(mesh_.face_handle(mesh_.halfedge_handle(*e_it, 1))).position();
970  ++valence;
971  }
972 
973  cog /= valence;
974  mesh_.data(*e_it).set_position(cog);
975  }
976 }
977 
978 
979 template<typename MeshType, typename RealType>
980 void CompositeT<MeshType,RealType>::VE()
981 {
982  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
983 
984  typename MeshType::EdgeIter e_it;
985  typename MeshType::Point cog;
986 
987  for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it)
988  {
989  cog = mesh_.data(mesh_.to_vertex_handle(mesh_.halfedge_handle(*e_it, 0))).position();
990  cog += mesh_.data(mesh_.to_vertex_handle(mesh_.halfedge_handle(*e_it, 1))).position();
991  cog /= 2.0;
992  mesh_.data(*e_it).set_position(cog);
993  }
994 }
995 
996 
997 template<typename MeshType, typename RealType>
998 void CompositeT<MeshType,RealType>::VV()
999 {
1000  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
1001 
1002  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
1003  typename MeshType::VertexVertexIter vv_it;
1004  typename MeshType::VertexIter v_it;
1005  std::vector<typename MeshType::Point> point_vector;
1006 
1007  point_vector.clear();
1008 
1009  for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
1010 
1011  unsigned int valence = 0;
1012  cog = zero_point;
1013 
1014  for (vv_it = mesh_.vv_iter(*v_it); vv_it; ++vv_it) {
1015  cog += vv_it->position();
1016  ++valence;
1017  }
1018  cog /= valence;
1019  point_vector.push_back(cog);
1020  }
1021 
1022  for (v_it = mesh_.vertices_end(); v_it != mesh_.vertices_begin(); )
1023  {
1024  --v_it;
1025  mesh_.data(*v_it).set_position(point_vector.back());
1026  point_vector.pop_back();
1027  }
1028 }
1029 
1030 
1031 template<typename MeshType, typename RealType>
1032 void CompositeT<MeshType,RealType>::VVc(Coeff& _coeff)
1033 {
1034  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
1035 
1036  typename MeshType::Point cog,
1037  zero_point(0.0, 0.0, 0.0);
1038  typename MeshType::VertexVertexIter vv_it;
1039  typename MeshType::VertexIter v_it;
1040  scalar_t c;
1041  std::vector<typename MeshType::Point> point_vector;
1042 
1043  for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it)
1044  {
1045  unsigned int valence = 0;
1046  cog = zero_point;
1047 
1048  for (vv_it = mesh_.vv_iter(*v_it); vv_it; ++vv_it)
1049  {
1050  cog += vv_it->position();
1051  ++valence;
1052  }
1053  cog /= valence;
1054  c = _coeff(valence);
1055  cog = cog * (1 - c) + mesh_.data(*v_it).position() * c;
1056  point_vector.push_back(cog);
1057  }
1058  for (v_it = mesh_.vertices_end(); v_it != mesh_.vertices_begin(); )
1059  {
1060  --v_it;
1061  mesh_.data(*v_it).set_position(point_vector.back());
1062  point_vector.pop_back();
1063  }
1064 }
1065 
1066 
1067 template<typename MeshType, typename RealType>
1068 void CompositeT<MeshType,RealType>::VVc(scalar_t _c)
1069 {
1070  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
1071 
1072  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
1073  typename MeshType::VertexVertexIter vv_it;
1074  typename MeshType::VertexIter v_it;
1075  std::vector<typename MeshType::Point> point_vector;
1076 
1077  for (v_it = mesh_.vertices_begin(); v_it != mesh_.vertices_end(); ++v_it) {
1078 
1079  unsigned int valence = 0;
1080  cog = zero_point;
1081 
1082  for (vv_it = mesh_.vv_iter(*v_it); vv_it; ++vv_it) {
1083  cog += mesh_.data(vv_it).position();
1084  ++valence;
1085  }
1086  cog /= valence;
1087 
1088  cog = cog * (1.0 - _c) + v_it->position() * _c;
1089 
1090  point_vector.push_back(cog);
1091 
1092  }
1093  for (v_it = mesh_.vertices_end(); v_it != mesh_.vertices_begin(); ) {
1094 
1095  --v_it;
1096  mesh_.data(*v_it).set_position(point_vector.back());
1097  point_vector.pop_back();
1098 
1099  }
1100 }
1101 
1102 
1103 template<typename MeshType, typename RealType>
1104 void CompositeT<MeshType,RealType>::EdE()
1105 {
1106  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
1107 
1108  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
1109  typename MeshType::EdgeIter e_it;
1110  typename MeshType::HalfedgeHandle heh;
1111  std::vector<typename MeshType::Point> point_vector;
1112 
1113  point_vector.clear();
1114 
1115  for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it) {
1116 
1117  unsigned int valence = 0;
1118  cog = zero_point;
1119 
1120  for (int i = 0; i <= 1; ++i) {
1121  heh = mesh_.halfedge_handle(*e_it, i);
1122  if (mesh_.face_handle(heh).is_valid())
1123  {
1124  cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(heh))).position();
1125  cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(mesh_.next_halfedge_handle(heh)))).position();
1126  ++valence;
1127  ++valence;
1128  }
1129  }
1130 
1131  cog /= valence;
1132  point_vector.push_back(cog);
1133  }
1134 
1135  for (e_it = mesh_.edges_end(); e_it != mesh_.edges_begin(); )
1136  {
1137  --e_it;
1138  mesh_.data(*e_it).set_position(point_vector.back());
1139  point_vector.pop_back();
1140  }
1141 }
1142 
1143 
1144 template<typename MeshType, typename RealType>
1145 void CompositeT<MeshType,RealType>::EdEc(scalar_t _c)
1146 {
1147  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
1148 
1149  typename MeshType::Point cog, zero_point(0.0, 0.0, 0.0);
1150  typename MeshType::EdgeIter e_it;
1151  typename MeshType::HalfedgeHandle heh;
1152  std::vector<typename MeshType::Point> point_vector;
1153 
1154  point_vector.clear();
1155 
1156  for (e_it = mesh_.edges_begin(); e_it != mesh_.edges_end(); ++e_it)
1157  {
1158  unsigned int valence = 0;
1159  cog = zero_point;
1160 
1161  for (int i = 0; i <= 1; ++i) {
1162  heh = mesh_.halfedge_handle(*e_it, i);
1163  if (mesh_.face_handle(heh).is_valid())
1164  {
1165  cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(heh))).position() * (1.0 - _c);
1166  cog += mesh_.data(mesh_.edge_handle(mesh_.next_halfedge_handle(mesh_.next_halfedge_handle(heh)))).position() * (1.0 - _c);
1167  ++valence;
1168  ++valence;
1169  }
1170  }
1171 
1172  cog /= valence;
1173  cog += mesh_.data(e_it).position() * _c;
1174  point_vector.push_back(cog);
1175  }
1176 
1177  for (e_it = mesh_.edges_end(); e_it != mesh_.edges_begin(); ) {
1178 
1179  --e_it;
1180  mesh_.data(*e_it).set_position(point_vector.back());
1181  point_vector.pop_back();
1182  }
1183 }
1184 
1185 
1187 template<typename MeshType, typename RealType>
1188 void CompositeT<MeshType,RealType>::corner_cutting(HalfedgeHandle _heh)
1189 {
1190  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
1191 
1192  // Define Halfedge Handles
1193  typename MeshType::HalfedgeHandle heh5(_heh);
1194  typename MeshType::HalfedgeHandle heh6(mesh_.next_halfedge_handle(_heh));
1195 
1196  // Cycle around the polygon to find correct Halfedge
1197  for (; mesh_.next_halfedge_handle(mesh_.next_halfedge_handle(heh5)) != _heh;
1198  heh5 = mesh_.next_halfedge_handle(heh5)) {};
1199 
1200  typename MeshType::HalfedgeHandle heh2(mesh_.next_halfedge_handle(heh5));
1201  typename MeshType::HalfedgeHandle
1202  heh3(mesh_.new_edge(mesh_.to_vertex_handle(_heh),
1203  mesh_.to_vertex_handle(heh5)));
1204  typename MeshType::HalfedgeHandle heh4(mesh_.opposite_halfedge_handle(heh3));
1205 
1206  // Old and new Face
1207  typename MeshType::FaceHandle fh_old(mesh_.face_handle(heh6));
1208  typename MeshType::FaceHandle fh_new(mesh_.new_face());
1209 
1210  // Init new face
1211  mesh_.data(fh_new).set_position(mesh_.data(fh_old).position());
1212 
1213  // Re-Set Handles around old Face
1214  mesh_.set_next_halfedge_handle(heh4, heh6);
1215  mesh_.set_next_halfedge_handle(heh5, heh4);
1216 
1217  mesh_.set_face_handle(heh4, fh_old);
1218  mesh_.set_face_handle(heh5, fh_old);
1219  mesh_.set_face_handle(heh6, fh_old);
1220  mesh_.set_halfedge_handle(fh_old, heh4);
1221 
1222  // Re-Set Handles around new Face
1223  mesh_.set_next_halfedge_handle(_heh, heh3);
1224  mesh_.set_next_halfedge_handle(heh3, heh2);
1225 
1226  mesh_.set_face_handle(_heh, fh_new);
1227  mesh_.set_face_handle(heh2, fh_new);
1228  mesh_.set_face_handle(heh3, fh_new);
1229 
1230  mesh_.set_halfedge_handle(fh_new, _heh);
1231 }
1232 
1233 
1235 template<typename MeshType, typename RealType>
1236 typename MeshType::VertexHandle
1237 CompositeT<MeshType,RealType>::split_edge(HalfedgeHandle _heh)
1238 {
1239  assert(p_mesh_); MeshType& mesh_ = *p_mesh_;
1240 
1241  HalfedgeHandle heh1;
1242  HalfedgeHandle heh2;
1243  HalfedgeHandle heh3;
1244  HalfedgeHandle temp_heh;
1245 
1246  VertexHandle
1247  vh,
1248  vh1(mesh_.to_vertex_handle(_heh)),
1249  vh2(mesh_.from_vertex_handle(_heh));
1250 
1251  // Calculate and Insert Midpoint of Edge
1252  vh = mesh_.add_vertex((mesh_.point(vh2) + mesh_.point(vh1)) / 2.0);
1253  // Re-Set Handles
1254  heh2 = mesh_.opposite_halfedge_handle(_heh);
1255 
1256  if (!mesh_.is_boundary(mesh_.edge_handle(_heh))) {
1257 
1258  for (temp_heh = mesh_.next_halfedge_handle(heh2);
1259  mesh_.next_halfedge_handle(temp_heh) != heh2;
1260  temp_heh = mesh_.next_halfedge_handle(temp_heh) ) {}
1261  } else {
1262  for (temp_heh = _heh;
1263  mesh_.next_halfedge_handle(temp_heh) != heh2;
1264  temp_heh = mesh_.opposite_halfedge_handle(mesh_.next_halfedge_handle(temp_heh))) {}
1265  }
1266 
1267  heh1 = mesh_.new_edge(vh, vh1);
1268  heh3 = mesh_.opposite_halfedge_handle(heh1);
1269  mesh_.set_vertex_handle(_heh, vh);
1270  mesh_.set_next_halfedge_handle(temp_heh, heh3);
1271  mesh_.set_next_halfedge_handle(heh1, mesh_.next_halfedge_handle(_heh));
1272  mesh_.set_next_halfedge_handle(_heh, heh1);
1273  mesh_.set_next_halfedge_handle(heh3, heh2);
1274  if (mesh_.face_handle(heh2).is_valid()) {
1275  mesh_.set_face_handle(heh3, mesh_.face_handle(heh2));
1276  mesh_.set_halfedge_handle(mesh_.face_handle(heh3), heh3);
1277  }
1278  mesh_.set_face_handle(heh1, mesh_.face_handle(_heh));
1279  mesh_.set_halfedge_handle(vh, heh1);
1280  mesh_.set_halfedge_handle(mesh_.face_handle(_heh), _heh);
1281  mesh_.set_halfedge_handle(vh1, heh3);
1282 
1283  return vh;
1284 }
1285 
1286 
1287 //=============================================================================
1288 } // END_NS_UNIFORM
1289 } // END_NS_SUBDIVIDER
1290 } // END_NS_OPENMESH
1291 //=============================================================================
1292 #endif // OPENMESH_SUBDIVIDER_UNIFORM_COMPOSITE_CC defined
1293 //=============================================================================
1294 
OpenMesh::Subdivider::Uniform::CompositeT::VVc
void VVc(Coeff &_coeff)
Vertex to vertex averaging, weighted.
Definition: CompositeT.cc:1032
OpenMesh::Subdivider::Uniform::CompositeT::FVc
void FVc(Coeff &_coeff)
Weighted face to vertex Averaging with flaps.
Definition: CompositeT.cc:564
OpenMesh::Subdivider::Uniform::CompositeT::FF
void FF()
Face to face averaging.
Definition: CompositeT.cc:428
OpenMesh::Subdivider::Uniform::CompositeT::VFa
void VFa(Coeff &_coeff)
Vertex to Face Averaging, weighted.
Definition: CompositeT.cc:316
OpenMesh::Subdivider::Uniform::CompositeT::EF
void EF()
Edge to face averaging.
Definition: CompositeT.cc:928
OpenMesh::Subdivider::Uniform::CompositeT::Tfv
void Tfv()
Split Face, using Face Information.
Definition: CompositeT.cc:216
OpenMesh::Subdivider::Uniform::CompositeT::Tvv3
void Tvv3()
Split Face, using Vertex information (1-3 split)
Definition: CompositeT.cc:97
OpenMesh::Subdivider::Uniform::CompositeT::VdE
void VdE()
Vertex to edge averaging, using diamond of edges.
Definition: CompositeT.cc:651
OpenMesh::Subdivider::Uniform::CompositeT::VdEc
void VdEc(scalar_t _c)
Weighted vertex to edge averaging, using diamond of edges.
Definition: CompositeT.cc:687
OpenMesh::Subdivider::Uniform::CompositeT::split_edge
VertexHandle split_edge(HalfedgeHandle _heh)
Split Edge.
Definition: CompositeT.cc:1237
OpenMesh::Subdivider::Uniform::CompositeT::EVc
void EVc(Coeff &_coeff)
Weighted edge to vertex averaging.
Definition: CompositeT.cc:866
OpenMesh::PolyMeshT::add_vertex
VertexHandle add_vertex(const Point &_p)
Alias for new_vertex(const Point&).
Definition: PolyMeshT.hh:236
OpenMesh::Subdivider::Uniform::CompositeT::VE
void VE()
VE Step (Vertex to Edge Averaging)
Definition: CompositeT.cc:980
OpenMesh::Subdivider::Uniform::CompositeT::prepare
bool prepare(MeshType &_m)
Prepare mesh, e.g. add properties.
Definition: CompositeT.cc:81
OpenMesh::Subdivider::Uniform::CompositeT::FV
void FV()
Face to vertex averaging.
Definition: CompositeT.cc:539
OpenMesh::Subdivider::Uniform::CompositeT::EdEc
void EdEc(scalar_t _c)
Weighted edge to edge averaging w/ flap rule.
Definition: CompositeT.cc:1145
OpenMesh::Subdivider::Uniform::CompositeT::EdE
void EdE()
Edge to edge averaging w/ flap rule.
Definition: CompositeT.cc:1104
OpenMesh::Subdivider::Uniform::CompositeT::Tvv4
void Tvv4()
Split Face, using Vertex information (1-4 split)
Definition: CompositeT.cc:161
OpenMesh::Subdivider::Uniform::CompositeT::FFc
void FFc(Coeff &_coeff)
Weighted face to face averaging.
Definition: CompositeT.cc:464
OpenMesh::Subdivider::Uniform::CompositeT::EV
void EV()
Edge to vertex averaging.
Definition: CompositeT.cc:840
OpenMesh::Subdivider::Uniform::CompositeT::VV
void VV()
Vertex to vertex averaging.
Definition: CompositeT.cc:998
OpenMesh::Subdivider::Uniform::CompositeT::VF
void VF()
Vertex to Face Averaging.
Definition: CompositeT.cc:292
OpenMesh::Subdivider::Uniform::CompositeT::corner_cutting
void corner_cutting(HalfedgeHandle _heh)
Corner Cutting.
Definition: CompositeT.cc:1188
OpenMesh::Subdivider::Uniform::CompositeT::Coeff
Abstract base class for coefficient functions.
Definition: CompositeT.hh:162
OpenMesh::Subdivider::Uniform::CompositeT::FE
void FE()
Face to edge averaging.
Definition: CompositeT.cc:952