Developer Documentation
PolyMeshT.hh
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 
45 //=============================================================================
46 //
47 // CLASS PolyMeshT
48 //
49 //=============================================================================
50 
51 
52 #ifndef OPENMESH_POLYMESHT_HH
53 #define OPENMESH_POLYMESHT_HH
54 
55 
56 //== INCLUDES =================================================================
57 
58 
60 #include <OpenMesh/Core/Geometry/MathDefs.hh>
61 #include <OpenMesh/Core/Mesh/PolyConnectivity.hh>
62 #include <OpenMesh/Core/Mesh/FinalMeshItemsT.hh>
63 #include <OpenMesh/Core/Mesh/Tags.hh>
64 #include <vector>
65 
66 
67 //== NAMESPACES ===============================================================
68 
69 
70 namespace OpenMesh {
71 
72 //== CLASS DEFINITION =========================================================
73 
74 
89 template <class Kernel>
90 class PolyMeshT : public Kernel
91 {
92 public:
93 
96  //--- item types ---
97 
99  static constexpr bool is_polymesh() { return true; }
101  static constexpr bool is_trimesh() { return false; }
103  enum { IsPolyMesh = 1 };
104  enum { IsTriMesh = 0 };
106 
108 
109  typedef typename Kernel::Scalar Scalar;
112  typedef typename Kernel::Point Point;
114  typedef typename Kernel::Normal Normal;
116  typedef typename Kernel::Color Color;
118  typedef typename Kernel::TexCoord1D TexCoord1D;
120  typedef typename Kernel::TexCoord2D TexCoord2D;
122  typedef typename Kernel::TexCoord3D TexCoord3D;
124  typedef typename Kernel::Vertex Vertex;
126  typedef typename Kernel::Halfedge Halfedge;
128  typedef typename Kernel::Edge Edge;
130  typedef typename Kernel::Face Face;
132 
133  //--- handle types ---
134 
136  typedef typename Kernel::VertexHandle VertexHandle;
137  typedef typename Kernel::HalfedgeHandle HalfedgeHandle;
138  typedef typename Kernel::EdgeHandle EdgeHandle;
139  typedef typename Kernel::FaceHandle FaceHandle;
140 
141 
142 
143  typedef typename Kernel::VertexIter VertexIter;
144  typedef typename Kernel::HalfedgeIter HalfedgeIter;
145  typedef typename Kernel::EdgeIter EdgeIter;
146  typedef typename Kernel::FaceIter FaceIter;
147 
148  typedef typename Kernel::ConstVertexIter ConstVertexIter;
149  typedef typename Kernel::ConstHalfedgeIter ConstHalfedgeIter;
150  typedef typename Kernel::ConstEdgeIter ConstEdgeIter;
151  typedef typename Kernel::ConstFaceIter ConstFaceIter;
153 
154  //--- circulators ---
155 
161  typedef typename Kernel::VertexVertexIter VertexVertexIter;
163  typedef typename Kernel::VertexOHalfedgeIter VertexOHalfedgeIter;
164  typedef typename Kernel::VertexIHalfedgeIter VertexIHalfedgeIter;
165  typedef typename Kernel::VertexEdgeIter VertexEdgeIter;
166  typedef typename Kernel::VertexFaceIter VertexFaceIter;
167  typedef typename Kernel::FaceVertexIter FaceVertexIter;
168  typedef typename Kernel::FaceHalfedgeIter FaceHalfedgeIter;
169  typedef typename Kernel::FaceEdgeIter FaceEdgeIter;
170  typedef typename Kernel::FaceFaceIter FaceFaceIter;
171 
172  typedef typename Kernel::ConstVertexVertexIter ConstVertexVertexIter;
173  typedef typename Kernel::ConstVertexOHalfedgeIter ConstVertexOHalfedgeIter;
174  typedef typename Kernel::ConstVertexIHalfedgeIter ConstVertexIHalfedgeIter;
175  typedef typename Kernel::ConstVertexEdgeIter ConstVertexEdgeIter;
176  typedef typename Kernel::ConstVertexFaceIter ConstVertexFaceIter;
177  typedef typename Kernel::ConstFaceVertexIter ConstFaceVertexIter;
178  typedef typename Kernel::ConstFaceHalfedgeIter ConstFaceHalfedgeIter;
179  typedef typename Kernel::ConstFaceEdgeIter ConstFaceEdgeIter;
180  typedef typename Kernel::ConstFaceFaceIter ConstFaceFaceIter;
182 
183 
184  // --- constructor/destructor
185  PolyMeshT() {}
186  template<typename T>
187  explicit PolyMeshT(const T& t) : Kernel(t) {}
188  virtual ~PolyMeshT() {}
189 
194  // --- creation ---
195 
202  { return make_smart(Kernel::new_vertex(), this); }
203 
209  inline SmartVertexHandle new_vertex(const Point& _p)
210  {
211  VertexHandle vh(Kernel::new_vertex());
212  this->set_point(vh, _p);
213  return make_smart(vh, this);
214  }
215 
227  inline SmartVertexHandle new_vertex_dirty(const Point& _p)
228  {
229  VertexHandle vh(Kernel::new_vertex_dirty());
230  this->set_point(vh, _p);
231  return make_smart(vh, this);
232  }
233 
235  inline SmartVertexHandle add_vertex(const Point& _p)
236  { return new_vertex(_p); }
237 
239  inline SmartVertexHandle add_vertex_dirty(const Point& _p)
240  { return make_smart(new_vertex_dirty(_p), this); }
241 
242  // --- normal vectors ---
243 
247 
255  void update_normals();
256 
258  void update_normal(FaceHandle _fh)
259  { this->set_normal(_fh, calc_face_normal(_fh)); }
260 
266  void update_face_normals();
267 
269  virtual Normal calc_face_normal(FaceHandle _fh) const;
270 
272  Normal calc_face_normal(const Point& _p0, const Point& _p1,
273  const Point& _p2) const;
274 
276  Normal calc_normal(FaceHandle _fh) const;
277 
279  void calc_face_centroid(FaceHandle _fh, Point& _pt) const {
280  _pt = calc_face_centroid(_fh);
281  }
282 
284  Point calc_face_centroid(FaceHandle _fh) const;
285 
287  Point calc_centroid(FaceHandle _fh) const;
288 
290  Point calc_centroid(EdgeHandle _eh) const;
291 
293  Point calc_centroid(HalfedgeHandle _heh) const;
294 
296  Point calc_centroid(VertexHandle _vh) const;
297 
299  Point calc_centroid(MeshHandle _mh) const;
300 
302  void update_normal(HalfedgeHandle _heh, const double _feature_angle = 0.8)
303  { this->set_normal(_heh, calc_halfedge_normal(_heh,_feature_angle)); }
304 
314  void update_halfedge_normals(const double _feature_angle = 0.8);
315 
328  virtual Normal calc_halfedge_normal(HalfedgeHandle _heh, const double _feature_angle = 0.8) const;
329 
331  Normal calc_normal(HalfedgeHandle, const double _feature_angle = 0.8) const;
332 
335  bool is_estimated_feature_edge(HalfedgeHandle _heh, const double _feature_angle) const;
336 
338  void update_normal(VertexHandle _vh)
339  { this->set_normal(_vh, calc_vertex_normal(_vh)); }
340 
350  void update_vertex_normals();
351 
364  Normal calc_vertex_normal(VertexHandle _vh) const;
365 
373  void calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const;
374  void calc_vertex_normal_correct(VertexHandle _vh, Normal& _n) const;
375  void calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const;
376 
378  Normal calc_normal(VertexHandle _vh) const;
379 
381 
382  // --- Geometry API - still in development ---
383 
386  void calc_edge_vector(EdgeHandle _eh, Normal& _edge_vec) const
387  {
388  _edge_vec = calc_edge_vector(_eh);
389  }
390 
393  Normal calc_edge_vector(EdgeHandle _eh) const
394  {
395  return calc_edge_vector(this->halfedge_handle(_eh,0));
396  }
397 
400  void calc_edge_vector(HalfedgeHandle _heh, Normal& _edge_vec) const
401  {
402  _edge_vec = calc_edge_vector(_heh);
403  }
404 
407  Normal calc_edge_vector(HalfedgeHandle _heh) const
408  {
409  return this->point(this->to_vertex_handle(_heh)) -
410  this->point(this->from_vertex_handle(_heh));
411  }
412 
413  // Calculates the length of the edge _eh
414  Scalar calc_edge_length(EdgeHandle _eh) const
415  { return calc_edge_length(this->halfedge_handle(_eh,0)); }
416 
419  Scalar calc_edge_length(HalfedgeHandle _heh) const
420  { return (Scalar)sqrt(calc_edge_sqr_length(_heh)); }
421 
422  Scalar calc_edge_sqr_length(EdgeHandle _eh) const
423  { return calc_edge_sqr_length(this->halfedge_handle(_eh,0)); }
424 
425  Scalar calc_edge_sqr_length(HalfedgeHandle _heh) const
426  {
427  Normal edge_vec;
428  calc_edge_vector(_heh, edge_vec);
429  return sqrnorm(edge_vec);
430  }
431 
434  Point calc_edge_midpoint(HalfedgeHandle _heh) const
435  {
436  VertexHandle vh0 = this->from_vertex_handle(_heh);
437  VertexHandle vh1 = this->to_vertex_handle(_heh);
438  return 0.5 * (this->point(vh0) + this->point(vh1));
439  }
440 
443  Point calc_edge_midpoint(EdgeHandle _eh) const
444  {
445  return calc_edge_midpoint(this->halfedge_handle(_eh, 0));
446  }
447 
449  Normal calc_normal(EdgeHandle _eh) const
450  {
451  HalfedgeHandle _heh = this->halfedge_handle(_eh, 0);
452  VertexHandle vh0 = this->from_vertex_handle(_heh);
453  VertexHandle vh1 = this->to_vertex_handle(_heh);
454  return 0.5 * (this->calc_normal(vh0) + this->calc_normal(vh1));
455  }
456 
461  void calc_sector_vectors(HalfedgeHandle _in_heh, Normal& _vec0, Normal& _vec1) const
462  {
463  calc_edge_vector(this->next_halfedge_handle(_in_heh), _vec0);//p2 - p1
464  calc_edge_vector(this->opposite_halfedge_handle(_in_heh), _vec1);//p0 - p1
465  }
466 
472  Scalar calc_sector_angle(HalfedgeHandle _in_heh) const
473  {
474  Normal v0, v1;
475  calc_sector_vectors(_in_heh, v0, v1);
476  Scalar denom = norm(v0)*norm(v1);
477  if ( denom == Scalar(0))
478  {
479  return 0;
480  }
481  Scalar cos_a = dot(v0 , v1) / denom;
482  if (this->is_boundary(_in_heh))
483  {//determine if the boundary sector is concave or convex
484  FaceHandle fh(this->face_handle(this->opposite_halfedge_handle(_in_heh)));
485  Normal f_n(calc_face_normal(fh));//this normal is (for convex fh) OK
486  Scalar sign_a = dot(cross(v0, v1), f_n);
487  return angle(cos_a, sign_a);
488  }
489  else
490  {
491  return acos(sane_aarg(cos_a));
492  }
493  }
494 
495  // calculate the cos and the sin of angle <(_in_heh,next_halfedge(_in_heh))
496  /*
497  void calc_sector_angle_cos_sin(HalfedgeHandle _in_heh, Scalar& _cos_a, Scalar& _sin_a) const
498  {
499  Normal in_vec, out_vec;
500  calc_edge_vector(_in_heh, in_vec);
501  calc_edge_vector(next_halfedge_handle(_in_heh), out_vec);
502  Scalar denom = norm(in_vec)*norm(out_vec);
503  if (is_zero(denom))
504  {
505  _cos_a = 1;
506  _sin_a = 0;
507  }
508  else
509  {
510  _cos_a = dot(in_vec, out_vec)/denom;
511  _sin_a = norm(cross(in_vec, out_vec))/denom;
512  }
513  }
514  */
517  void calc_sector_normal(HalfedgeHandle _in_heh, Normal& _sector_normal) const
518  {
519  Normal vec0, vec1;
520  calc_sector_vectors(_in_heh, vec0, vec1);
521  _sector_normal = cross(vec0, vec1);//(p2-p1)^(p0-p1)
522  }
523 
527  Scalar calc_sector_area(HalfedgeHandle _in_heh) const
528  {
529  Normal sector_normal;
530  calc_sector_normal(_in_heh, sector_normal);
531  return norm(sector_normal)/2;
532  }
533 
536  Scalar calc_dihedral_angle_fast(HalfedgeHandle _heh) const
537  {
538  // Make sure that we have face normals on the mesh
539  assert(Kernel::has_face_normals());
540 
541  if (this->is_boundary(this->edge_handle(_heh)))
542  {//the dihedral angle at a boundary edge is 0
543  return 0;
544  }
545  const Normal& n0 = this->normal(this->face_handle(_heh));
546  const Normal& n1 = this->normal(this->face_handle(this->opposite_halfedge_handle(_heh)));
547  Normal he;
548  calc_edge_vector(_heh, he);
549  Scalar da_cos = dot(n0, n1);
550  //should be normalized, but we need only the sign
551  Scalar da_sin_sign = dot(cross(n0, n1), he);
552  return angle(da_cos, da_sin_sign);
553  }
554 
557  Scalar calc_dihedral_angle_fast(EdgeHandle _eh) const
558  { return calc_dihedral_angle_fast(this->halfedge_handle(_eh,0)); }
559 
560  // calculates the dihedral angle on the halfedge _heh
561  Scalar calc_dihedral_angle(HalfedgeHandle _heh) const
562  {
563  if (this->is_boundary(this->edge_handle(_heh)))
564  {//the dihedral angle at a boundary edge is 0
565  return 0;
566  }
567  Normal n0, n1, he;
568  calc_sector_normal(_heh, n0);
569  calc_sector_normal(this->opposite_halfedge_handle(_heh), n1);
570  calc_edge_vector(_heh, he);
571  Scalar denom = norm(n0)*norm(n1);
572  if (denom == Scalar(0))
573  {
574  return 0;
575  }
576  Scalar da_cos = dot(n0, n1)/denom;
577  //should be normalized, but we need only the sign
578  Scalar da_sin_sign = dot(cross(n0, n1), he);
579  return angle(da_cos, da_sin_sign);
580  }
581 
582  // calculates the dihedral angle on the edge _eh
583  Scalar calc_dihedral_angle(EdgeHandle _eh) const
584  { return calc_dihedral_angle(this->halfedge_handle(_eh,0)); }
585 
588  unsigned int find_feature_edges(Scalar _angle_tresh = OpenMesh::deg_to_rad(44.0));
589  // --- misc ---
590 
592  inline void split(FaceHandle _fh, const Point& _p)
593  { Kernel::split(_fh, add_vertex(_p)); }
594 
595  inline void split(FaceHandle _fh, VertexHandle _vh)
596  { Kernel::split(_fh, _vh); }
597 
598  inline void split(EdgeHandle _eh, const Point& _p)
599  { Kernel::split_edge(_eh, add_vertex(_p)); }
600 
601  inline void split(EdgeHandle _eh, VertexHandle _vh)
602  { Kernel::split_edge(_eh, _vh); }
603 
604 private:
605  struct PointIs3DTag {};
606  struct PointIsNot3DTag {};
607  Normal calc_face_normal_impl(FaceHandle, PointIs3DTag) const;
608  Normal calc_face_normal_impl(FaceHandle, PointIsNot3DTag) const;
609  Normal calc_face_normal_impl(const Point&, const Point&, const Point&, PointIs3DTag) const;
610  Normal calc_face_normal_impl(const Point&, const Point&, const Point&, PointIsNot3DTag) const;
611 };
612 
638 template<typename LHS, typename KERNEL>
640  return MeshCast<LHS, PolyMeshT<KERNEL>&>::cast(rhs);
641 }
642 
643 template<typename LHS, typename KERNEL>
644 LHS mesh_cast(PolyMeshT<KERNEL> *rhs) {
645  return MeshCast<LHS, PolyMeshT<KERNEL>*>::cast(rhs);
646 }
647 
648 template<typename LHS, typename KERNEL>
649 const LHS mesh_cast(const PolyMeshT<KERNEL> &rhs) {
650  return MeshCast<LHS, const PolyMeshT<KERNEL>&>::cast(rhs);
651 }
652 
653 template<typename LHS, typename KERNEL>
654 const LHS mesh_cast(const PolyMeshT<KERNEL> *rhs) {
655  return MeshCast<LHS, const PolyMeshT<KERNEL>*>::cast(rhs);
656 }
657 
658 //=============================================================================
659 } // namespace OpenMesh
660 //=============================================================================
661 #if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_POLYMESH_C)
662 # define OPENMESH_POLYMESH_TEMPLATES
663 # include "PolyMeshT_impl.hh"
664 #endif
665 //=============================================================================
666 #endif // OPENMESH_POLYMESHT_HH defined
667 //=============================================================================
void calc_sector_normal(HalfedgeHandle _in_heh, Normal &_sector_normal) const
Definition: PolyMeshT.hh:517
Kernel::VertexVertexIter VertexVertexIter
Circulator.
Definition: PolyMeshT.hh:162
Kernel::FaceFaceIter FaceFaceIter
Circulator.
Definition: PolyMeshT.hh:170
Add 3D texture coordinates (vertices, halfedges)
Definition: Attributes.hh:88
Kernel::Edge Edge
Edge type.
Definition: PolyMeshT.hh:128
Normal calc_edge_vector(HalfedgeHandle _heh) const
Definition: PolyMeshT.hh:407
bool is_estimated_feature_edge(HalfedgeHandle _heh, const double _feature_angle) const
Kernel::ConstVertexIHalfedgeIter ConstVertexIHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:174
Kernel::ConstVertexFaceIter ConstVertexFaceIter
Circulator.
Definition: PolyMeshT.hh:176
Kernel::ConstFaceVertexIter ConstFaceVertexIter
Circulator.
Definition: PolyMeshT.hh:177
Handle type for meshes to simplify some template programming.
Definition: Handles.hh:148
void update_normal(VertexHandle _vh)
Update normal for vertex _vh.
Definition: PolyMeshT.hh:338
void calc_edge_vector(EdgeHandle _eh, Normal &_edge_vec) const
Definition: PolyMeshT.hh:386
osg::Vec3f cross(const osg::Vec3f &_v1, const osg::Vec3f &_v2)
Adapter for osg vector member computing a scalar product.
void calc_sector_vectors(HalfedgeHandle _in_heh, Normal &_vec0, Normal &_vec1) const
Definition: PolyMeshT.hh:461
Kernel::Color Color
Color type.
Definition: PolyMeshT.hh:116
Connectivity tag indicating that the tagged mesh has polygon connectivity.
Definition: Tags.hh:47
Normal calc_normal(EdgeHandle _eh) const
calculated and returns the average of the two vertex normals
Definition: PolyMeshT.hh:449
Kernel::FaceEdgeIter FaceEdgeIter
Circulator.
Definition: PolyMeshT.hh:169
Kernel::Normal Normal
Normal type.
Definition: PolyMeshT.hh:114
Kernel::VertexFaceIter VertexFaceIter
Circulator.
Definition: PolyMeshT.hh:166
Kernel::FaceVertexIter FaceVertexIter
Circulator.
Definition: PolyMeshT.hh:167
Kernel::Vertex Vertex
Vertex type.
Definition: PolyMeshT.hh:124
SmartVertexHandle new_vertex(const Point &_p)
Adds a new vertex initialized to a custom position.
Definition: PolyMeshT.hh:209
Kernel::Point Point
Coordinate type.
Definition: PolyMeshT.hh:112
void calc_edge_vector(HalfedgeHandle _heh, Normal &_edge_vec) const
Definition: PolyMeshT.hh:400
virtual Normal calc_face_normal(FaceHandle _fh) const
T angle(T _cos_angle, T _sin_angle)
Definition: MathDefs.hh:140
SmartVertexHandle new_vertex_dirty(const Point &_p)
Definition: PolyMeshT.hh:227
virtual Normal calc_halfedge_normal(HalfedgeHandle _heh, const double _feature_angle=0.8) const
Calculate halfedge normal for one specific halfedge.
Add 2D texture coordinates (vertices, halfedges)
Definition: Attributes.hh:87
Kernel::Face Face
Face type.
Definition: PolyMeshT.hh:130
T sane_aarg(T _aarg)
Trigonometry/angles - related.
Definition: MathDefs.hh:122
Kernel::TexCoord1D TexCoord1D
TexCoord1D type.
Definition: PolyMeshT.hh:118
SmartVertexHandle add_vertex_dirty(const Point &_p)
Alias for new_vertex_dirty().
Definition: PolyMeshT.hh:239
Add colors to mesh item (vertices/faces/edges)
Definition: Attributes.hh:83
Kernel::TexCoord3D TexCoord3D
TexCoord3D type.
Definition: PolyMeshT.hh:122
Kernel::ConstVertexEdgeIter ConstVertexEdgeIter
Circulator.
Definition: PolyMeshT.hh:175
Kernel::VertexOHalfedgeIter VertexOHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:163
Kernel::ConstFaceHalfedgeIter ConstFaceHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:178
void update_normal(FaceHandle _fh)
Update normal for face _fh.
Definition: PolyMeshT.hh:258
SmartVertexHandle make_smart(VertexHandle _vh, const PolyConnectivity *_mesh)
Creats a SmartVertexHandle from a VertexHandle and a Mesh.
Scalar calc_sector_area(HalfedgeHandle _in_heh) const
Definition: PolyMeshT.hh:527
Kernel::VertexIHalfedgeIter VertexIHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:164
void update_vertex_normals()
Update normal vectors for all vertices.
Kernel::TexCoord2D TexCoord2D
TexCoord2D type.
Definition: PolyMeshT.hh:120
void calc_vertex_normal_fast(VertexHandle _vh, Normal &_n) const
Scalar calc_edge_length(HalfedgeHandle _heh) const
Definition: PolyMeshT.hh:419
Kernel::ConstFaceFaceIter ConstFaceFaceIter
Circulator.
Definition: PolyMeshT.hh:180
SmartVertexHandle add_vertex(const Point &_p)
Alias for new_vertex(const Point&).
Definition: PolyMeshT.hh:235
Scalar calc_dihedral_angle_fast(EdgeHandle _eh) const
Definition: PolyMeshT.hh:557
static constexpr bool is_polymesh()
Determine whether this is a PolyMeshT or TriMeshT (This function does not check the per face vertex c...
Definition: PolyMeshT.hh:100
Cast a mesh with different but identical traits into each other.
unsigned int find_feature_edges(Scalar _angle_tresh=OpenMesh::deg_to_rad(44.0))
void calc_vertex_normal_correct(VertexHandle _vh, Normal &_n) const
Compute normals for all primitives.
void update_normals()
Compute normals for all primitives.
Kernel::Scalar Scalar
Scalar type.
Definition: PolyMeshT.hh:110
void update_face_normals()
Update normal vectors for all faces.
PolyMeshT< Kernel > This
Self type. Used to specify iterators/circulators.
Definition: PolyMeshT.hh:95
static constexpr bool is_trimesh()
Determine whether this is a PolyMeshT or TriMeshT (This function does not check the per face vertex c...
Definition: PolyMeshT.hh:101
Point calc_edge_midpoint(HalfedgeHandle _heh) const
Definition: PolyMeshT.hh:434
void split(FaceHandle _fh, const Point &_p)
Face split (= 1-to-n split)
Definition: PolyMeshT.hh:592
Scalar calc_dihedral_angle_fast(HalfedgeHandle _heh) const
Definition: PolyMeshT.hh:536
Kernel::FaceHalfedgeIter FaceHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:168
Smart version of VertexHandle contains a pointer to the corresponding mesh and allows easier access t...
Definition: SmartHandles.hh:84
LHS mesh_cast(PolyMeshT< KERNEL > &rhs)
Cast a mesh with different but identical traits into each other.
Definition: PolyMeshT.hh:639
Add 1D texture coordinates (vertices, halfedges)
Definition: Attributes.hh:86
Point calc_centroid(FaceHandle _fh) const
Computes and returns the average of the vertices defining _fh (same as calc_face_centroid) ...
void calc_face_centroid(FaceHandle _fh, Point &_pt) const
calculates the average of the vertices defining _fh
Definition: PolyMeshT.hh:279
Normal calc_edge_vector(EdgeHandle _eh) const
Definition: PolyMeshT.hh:393
Point calc_edge_midpoint(EdgeHandle _eh) const
Definition: PolyMeshT.hh:443
Scalar calc_sector_angle(HalfedgeHandle _in_heh) const
Definition: PolyMeshT.hh:472
Kernel::Halfedge Halfedge
Halfedge type.
Definition: PolyMeshT.hh:126
void calc_vertex_normal_loop(VertexHandle _vh, Normal &_n) const
Compute normals for all primitives.
void update_halfedge_normals(const double _feature_angle=0.8)
Update normal vectors for all halfedges.
Kernel::VertexEdgeIter VertexEdgeIter
Circulator.
Definition: PolyMeshT.hh:165
Kernel::ConstVertexVertexIter ConstVertexVertexIter
Circulator.
Definition: PolyMeshT.hh:172
osg::Vec3f::ValueType dot(const osg::Vec3f &_v1, const osg::Vec3f &_v2)
Adapter for osg vector member computing a scalar product.
Kernel::ConstVertexOHalfedgeIter ConstVertexOHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:173
void update_normal(HalfedgeHandle _heh, const double _feature_angle=0.8)
Update normal for halfedge _heh.
Definition: PolyMeshT.hh:302
Normal calc_normal(FaceHandle _fh) const
same as calc_face_normal
Kernel::ConstFaceEdgeIter ConstFaceEdgeIter
Circulator.
Definition: PolyMeshT.hh:179
Kernel::VertexHandle VertexHandle
Handle for referencing the corresponding item.
Definition: PolyMeshT.hh:136
Normal calc_vertex_normal(VertexHandle _vh) const
Calculate vertex normal for one specific vertex.
SmartVertexHandle new_vertex()
Adds a new default-initialized vertex.
Definition: PolyMeshT.hh:201