OpenMesh
Loading...
Searching...
No Matches
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 * $Revision$ *
45 * $Date$ *
46 * *
47\*===========================================================================*/
48
49
50//=============================================================================
51//
52// CLASS PolyMeshT
53//
54//=============================================================================
55
56
57#ifndef OPENMESH_POLYMESHT_HH
58#define OPENMESH_POLYMESHT_HH
59
60
61//== INCLUDES =================================================================
62
63
64#include <OpenMesh/Core/System/config.h>
65#include <OpenMesh/Core/Geometry/MathDefs.hh>
66#include <OpenMesh/Core/Mesh/PolyConnectivity.hh>
67#include <OpenMesh/Core/Mesh/FinalMeshItemsT.hh>
68#include <vector>
69
70
71//== NAMESPACES ===============================================================
72
73
74namespace OpenMesh {
75
76//== CLASS DEFINITION =========================================================
77
78
93template <class Kernel>
94class PolyMeshT : public Kernel
95{
96public:
97
100 //--- item types ---
101
103
104 enum { IsPolyMesh = 1 };
105 enum { IsTriMesh = 0 };
106 static bool is_polymesh() { return true; }
107 static bool is_trimesh() { return false; }
109
111
112
113 typedef typename Kernel::Scalar Scalar;
115 typedef typename Kernel::Point Point;
117 typedef typename Kernel::Normal Normal;
119 typedef typename Kernel::Color Color;
121 typedef typename Kernel::TexCoord1D TexCoord1D;
123 typedef typename Kernel::TexCoord2D TexCoord2D;
125 typedef typename Kernel::TexCoord3D TexCoord3D;
127 typedef typename Kernel::Vertex Vertex;
129 typedef typename Kernel::Halfedge Halfedge;
131 typedef typename Kernel::Edge Edge;
133 typedef typename Kernel::Face Face;
135
136 //--- handle types ---
137
139 typedef typename Kernel::VertexHandle VertexHandle;
140 typedef typename Kernel::HalfedgeHandle HalfedgeHandle;
141 typedef typename Kernel::EdgeHandle EdgeHandle;
142 typedef typename Kernel::FaceHandle FaceHandle;
143
144
145
146 typedef typename Kernel::VertexIter VertexIter;
147 typedef typename Kernel::HalfedgeIter HalfedgeIter;
148 typedef typename Kernel::EdgeIter EdgeIter;
149 typedef typename Kernel::FaceIter FaceIter;
150
151 typedef typename Kernel::ConstVertexIter ConstVertexIter;
152 typedef typename Kernel::ConstHalfedgeIter ConstHalfedgeIter;
153 typedef typename Kernel::ConstEdgeIter ConstEdgeIter;
154 typedef typename Kernel::ConstFaceIter ConstFaceIter;
156
157 //--- circulators ---
158
165 typedef typename Kernel::VertexVertexIter VertexVertexIter;
166 typedef typename Kernel::VertexOHalfedgeIter VertexOHalfedgeIter;
167 typedef typename Kernel::VertexIHalfedgeIter VertexIHalfedgeIter;
168 typedef typename Kernel::VertexEdgeIter VertexEdgeIter;
169 typedef typename Kernel::VertexFaceIter VertexFaceIter;
170 typedef typename Kernel::FaceVertexIter FaceVertexIter;
171 typedef typename Kernel::FaceHalfedgeIter FaceHalfedgeIter;
172 typedef typename Kernel::FaceEdgeIter FaceEdgeIter;
173 typedef typename Kernel::FaceFaceIter FaceFaceIter;
174
175 typedef typename Kernel::ConstVertexVertexIter ConstVertexVertexIter;
176 typedef typename Kernel::ConstVertexOHalfedgeIter ConstVertexOHalfedgeIter;
177 typedef typename Kernel::ConstVertexIHalfedgeIter ConstVertexIHalfedgeIter;
178 typedef typename Kernel::ConstVertexEdgeIter ConstVertexEdgeIter;
179 typedef typename Kernel::ConstVertexFaceIter ConstVertexFaceIter;
180 typedef typename Kernel::ConstFaceVertexIter ConstFaceVertexIter;
181 typedef typename Kernel::ConstFaceHalfedgeIter ConstFaceHalfedgeIter;
182 typedef typename Kernel::ConstFaceEdgeIter ConstFaceEdgeIter;
183 typedef typename Kernel::ConstFaceFaceIter ConstFaceFaceIter;
185
186
187 // --- constructor/destructor
189 virtual ~PolyMeshT() {}
190
195 // --- creation ---
196
203 { return Kernel::new_vertex(); }
204
210 inline VertexHandle new_vertex(const Point& _p)
211 {
212 VertexHandle vh(Kernel::new_vertex());
213 this->set_point(vh, _p);
214 return vh;
215 }
216
229 {
230 VertexHandle vh(Kernel::new_vertex_dirty());
231 this->set_point(vh, _p);
232 return vh;
233 }
234
236 inline VertexHandle add_vertex(const Point& _p)
237 { return new_vertex(_p); }
238
241 { return new_vertex_dirty(_p); }
242
243 // --- normal vectors ---
244
248
256 void update_normals();
257
260 { this->set_normal(_fh, calc_face_normal(_fh)); }
261
267 void update_face_normals();
268
270 virtual Normal calc_face_normal(FaceHandle _fh) const;
271
273 Normal calc_face_normal(const Point& _p0, const Point& _p1,
274 const Point& _p2) const;
276 void calc_face_centroid(FaceHandle _fh, Point& _pt) const {
277 _pt = calc_face_centroid(_fh);
278 }
279
282
284 void update_normal(HalfedgeHandle _heh, const double _feature_angle = 0.8)
285 { this->set_normal(_heh, calc_halfedge_normal(_heh,_feature_angle)); }
286
296 void update_halfedge_normals(const double _feature_angle = 0.8);
297
310 virtual Normal calc_halfedge_normal(HalfedgeHandle _heh, const double _feature_angle = 0.8) const;
311
312
315 bool is_estimated_feature_edge(HalfedgeHandle _heh, const double _feature_angle) const;
316
319 { this->set_normal(_vh, calc_vertex_normal(_vh)); }
320
331
345
353 void calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const;
355 void calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const;
356
357
359
360 // --- Geometry API - still in development ---
361
364 void calc_edge_vector(EdgeHandle _eh, Normal& _edge_vec) const
365 {
366 _edge_vec = calc_edge_vector(_eh);
367 }
368
372 {
373 return calc_edge_vector(this->halfedge_handle(_eh,0));
374 }
375
378 void calc_edge_vector(HalfedgeHandle _heh, Normal& _edge_vec) const
379 {
380 _edge_vec = calc_edge_vector(_heh);
381 }
382
386 {
387 return this->point(this->to_vertex_handle(_heh)) -
388 this->point(this->from_vertex_handle(_heh));
389 }
390
391 // Calculates the length of the edge _eh
393 { return calc_edge_length(this->halfedge_handle(_eh,0)); }
394
398 { return (Scalar)sqrt(calc_edge_sqr_length(_heh)); }
399
401 { return calc_edge_sqr_length(this->halfedge_handle(_eh,0)); }
402
404 {
405 Normal edge_vec;
406 calc_edge_vector(_heh, edge_vec);
407 return edge_vec.sqrnorm();
408 }
409
414 void calc_sector_vectors(HalfedgeHandle _in_heh, Normal& _vec0, Normal& _vec1) const
415 {
416 calc_edge_vector(this->next_halfedge_handle(_in_heh), _vec0);//p2 - p1
417 calc_edge_vector(this->opposite_halfedge_handle(_in_heh), _vec1);//p0 - p1
418 }
419
426 {
427 Normal v0, v1;
428 calc_sector_vectors(_in_heh, v0, v1);
429 Scalar denom = v0.norm()*v1.norm();
430 if (is_zero(denom))
431 {
432 return 0;
433 }
434 Scalar cos_a = dot(v0 , v1) / denom;
435 if (this->is_boundary(_in_heh))
436 {//determine if the boundary sector is concave or convex
437 FaceHandle fh(this->face_handle(this->opposite_halfedge_handle(_in_heh)));
438 Normal f_n(calc_face_normal(fh));//this normal is (for convex fh) OK
439 Scalar sign_a = dot(cross(v0, v1), f_n);
440 return angle(cos_a, sign_a);
441 }
442 else
443 {
444 return acos(sane_aarg(cos_a));
445 }
446 }
447
448 // calculate the cos and the sin of angle <(_in_heh,next_halfedge(_in_heh))
449 /*
450 void calc_sector_angle_cos_sin(HalfedgeHandle _in_heh, Scalar& _cos_a, Scalar& _sin_a) const
451 {
452 Normal in_vec, out_vec;
453 calc_edge_vector(_in_heh, in_vec);
454 calc_edge_vector(next_halfedge_handle(_in_heh), out_vec);
455 Scalar denom = in_vec.norm()*out_vec.norm();
456 if (is_zero(denom))
457 {
458 _cos_a = 1;
459 _sin_a = 0;
460 }
461 else
462 {
463 _cos_a = dot(in_vec, out_vec)/denom;
464 _sin_a = cross(in_vec, out_vec).norm()/denom;
465 }
466 }
467 */
470 void calc_sector_normal(HalfedgeHandle _in_heh, Normal& _sector_normal) const
471 {
472 Normal vec0, vec1;
473 calc_sector_vectors(_in_heh, vec0, vec1);
474 _sector_normal = cross(vec0, vec1);//(p2-p1)^(p0-p1)
475 }
476
481 {
482 Normal sector_normal;
483 calc_sector_normal(_in_heh, sector_normal);
484 return sector_normal.norm()/2;
485 }
486
490 {
491 // Make sure that we have face normals on the mesh
492 assert(Kernel::has_face_normals());
493
494 if (this->is_boundary(this->edge_handle(_heh)))
495 {//the dihedral angle at a boundary edge is 0
496 return 0;
497 }
498 const Normal& n0 = this->normal(this->face_handle(_heh));
499 const Normal& n1 = this->normal(this->face_handle(this->opposite_halfedge_handle(_heh)));
500 Normal he;
501 calc_edge_vector(_heh, he);
502 Scalar da_cos = dot(n0, n1);
503 //should be normalized, but we need only the sign
504 Scalar da_sin_sign = dot(cross(n0, n1), he);
505 return angle(da_cos, da_sin_sign);
506 }
507
511 { return calc_dihedral_angle_fast(this->halfedge_handle(_eh,0)); }
512
513 // calculates the dihedral angle on the halfedge _heh
515 {
516 if (this->is_boundary(this->edge_handle(_heh)))
517 {//the dihedral angle at a boundary edge is 0
518 return 0;
519 }
520 Normal n0, n1, he;
521 calc_sector_normal(_heh, n0);
522 calc_sector_normal(this->opposite_halfedge_handle(_heh), n1);
523 calc_edge_vector(_heh, he);
524 Scalar denom = n0.norm()*n1.norm();
525 if (denom == Scalar(0))
526 {
527 return 0;
528 }
529 Scalar da_cos = dot(n0, n1)/denom;
530 //should be normalized, but we need only the sign
531 Scalar da_sin_sign = dot(cross(n0, n1), he);
532 return angle(da_cos, da_sin_sign);
533 }
534
535 // calculates the dihedral angle on the edge _eh
537 { return calc_dihedral_angle(this->halfedge_handle(_eh,0)); }
538
541 unsigned int find_feature_edges(Scalar _angle_tresh = OpenMesh::deg_to_rad(44.0));
542 // --- misc ---
543
545 inline void split(FaceHandle _fh, const Point& _p)
546 { Kernel::split(_fh, add_vertex(_p)); }
547
548 inline void split(FaceHandle _fh, VertexHandle _vh)
549 { Kernel::split(_fh, _vh); }
550
551 inline void split(EdgeHandle _eh, const Point& _p)
552 { Kernel::split_edge(_eh, add_vertex(_p)); }
553
554 inline void split(EdgeHandle _eh, VertexHandle _vh)
555 { Kernel::split_edge(_eh, _vh); }
556
557private:
558 struct PointIs3DTag {};
559 struct PointIsNot3DTag {};
560 Normal calc_face_normal_impl(FaceHandle, PointIs3DTag) const;
561 Normal calc_face_normal_impl(FaceHandle, PointIsNot3DTag) const;
562 Normal calc_face_normal_impl(const Point&, const Point&, const Point&, PointIs3DTag) const;
563 Normal calc_face_normal_impl(const Point&, const Point&, const Point&, PointIsNot3DTag) const;
564};
565
591template<typename LHS, typename KERNEL>
593 return MeshCast<LHS, PolyMeshT<KERNEL>&>::cast(rhs);
594}
595
596template<typename LHS, typename KERNEL>
597LHS mesh_cast(PolyMeshT<KERNEL> *rhs) {
598 return MeshCast<LHS, PolyMeshT<KERNEL>*>::cast(rhs);
599}
600
601template<typename LHS, typename KERNEL>
602const LHS mesh_cast(const PolyMeshT<KERNEL> &rhs) {
603 return MeshCast<LHS, const PolyMeshT<KERNEL>&>::cast(rhs);
604}
605
606template<typename LHS, typename KERNEL>
607const LHS mesh_cast(const PolyMeshT<KERNEL> *rhs) {
608 return MeshCast<LHS, const PolyMeshT<KERNEL>*>::cast(rhs);
609}
610
611//=============================================================================
612} // namespace OpenMesh
613//=============================================================================
614#if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_POLYMESH_C)
615# define OPENMESH_POLYMESH_TEMPLATES
616# include "PolyMeshT.cc"
617#endif
618//=============================================================================
619#endif // OPENMESH_POLYMESHT_HH defined
620//=============================================================================
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:64
osg::Vec3f::ValueType dot(const osg::Vec3f &_v1, const osg::Vec3f &_v2)
Adapter for osg vector member computing a scalar product.
Definition: VectorAdapter.hh:181
T angle(T _cos_angle, T _sin_angle)
returns the angle determined by its cos and the sign of its sin result is positive if the angle is in...
Definition: MathDefs.hh:145
bool is_zero(const T &_a, Real _eps)
comparison operators with user-selected precision control
Definition: MathDefs.hh:66
LHS mesh_cast(PolyMeshT< KERNEL > &rhs)
Cast a mesh with different but identical traits into each other.
Definition: PolyMeshT.hh:592
T sane_aarg(T _aarg)
Trigonometry/angles - related.
Definition: MathDefs.hh:127
Cast a mesh with different but identical traits into each other.
Definition: FinalMeshItemsT.hh:183
Handle for a vertex entity.
Definition: Handles.hh:126
Handle for a halfedge entity.
Definition: Handles.hh:133
Handle for a face entity.
Definition: Handles.hh:147
Base type for a polygonal mesh.
Definition: PolyMeshT.hh:95
Kernel::Vertex Vertex
Vertex type.
Definition: PolyMeshT.hh:127
Kernel::FaceEdgeIter FaceEdgeIter
Circulator.
Definition: PolyMeshT.hh:172
void calc_face_centroid(FaceHandle _fh, Point &_pt) const
calculates the average of the vertices defining _fh
Definition: PolyMeshT.hh:276
Kernel::ConstFaceIter ConstFaceIter
Scalar type.
Definition: PolyMeshT.hh:154
Kernel::VertexHandle VertexHandle
Handle for referencing the corresponding item.
Definition: PolyMeshT.hh:139
Kernel::Scalar Scalar
Scalar type.
Definition: PolyMeshT.hh:113
Kernel::ConstVertexVertexIter ConstVertexVertexIter
Circulator.
Definition: PolyMeshT.hh:175
void calc_edge_vector(HalfedgeHandle _heh, Normal &_edge_vec) const
Calculates the edge vector as the difference of the the points defined by to_vertex_handle() and from...
Definition: PolyMeshT.hh:378
Kernel::ConstFaceHalfedgeIter ConstFaceHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:181
Kernel::EdgeHandle EdgeHandle
Scalar type.
Definition: PolyMeshT.hh:141
Kernel::VertexFaceIter VertexFaceIter
Circulator.
Definition: PolyMeshT.hh:169
Kernel::ConstFaceVertexIter ConstFaceVertexIter
Circulator.
Definition: PolyMeshT.hh:180
Kernel::Halfedge Halfedge
Halfedge type.
Definition: PolyMeshT.hh:129
void calc_vertex_normal_fast(VertexHandle _vh, Normal &_n) const
Different methods for calculation of the normal at _vh:
Definition: PolyMeshT.cc:387
void calc_vertex_normal_correct(VertexHandle _vh, Normal &_n) const
Compute normals for all primitives.
Definition: PolyMeshT.cc:397
PolyMeshT()
Circulator.
Definition: PolyMeshT.hh:188
Scalar calc_dihedral_angle(EdgeHandle _eh) const
Compute normals for all primitives.
Definition: PolyMeshT.hh:536
Kernel::FaceIter FaceIter
Scalar type.
Definition: PolyMeshT.hh:149
Kernel::Normal Normal
Normal type.
Definition: PolyMeshT.hh:117
Kernel::FaceVertexIter FaceVertexIter
Circulator.
Definition: PolyMeshT.hh:170
Kernel::VertexIHalfedgeIter VertexIHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:167
void split(FaceHandle _fh, VertexHandle _vh)
Compute normals for all primitives.
Definition: PolyMeshT.hh:548
Kernel::TexCoord2D TexCoord2D
TexCoord2D type.
Definition: PolyMeshT.hh:123
Scalar calc_sector_area(HalfedgeHandle _in_heh) const
calculates the area of the face sector defined by the angle <(_in_heh,next_halfedge(_in_heh)) NOTE: s...
Definition: PolyMeshT.hh:480
void update_face_normals()
Update normal vectors for all faces.
Definition: PolyMeshT.cc:259
void update_halfedge_normals(const double _feature_angle=0.8)
Update normal vectors for all halfedges.
Definition: PolyMeshT.cc:274
unsigned int find_feature_edges(Scalar _angle_tresh=OpenMesh::deg_to_rad(44.0))
tags an edge as a feature if its dihedral angle is larger than _angle_tresh returns the number of the...
Definition: PolyMeshT.cc:79
virtual Normal calc_halfedge_normal(HalfedgeHandle _heh, const double _feature_angle=0.8) const
Calculate halfedge normal for one specific halfedge.
Definition: PolyMeshT.cc:289
Scalar calc_sector_angle(HalfedgeHandle _in_heh) const
calculates the sector angle.
Definition: PolyMeshT.hh:425
Kernel::ConstFaceEdgeIter ConstFaceEdgeIter
Circulator.
Definition: PolyMeshT.hh:182
Kernel::TexCoord3D TexCoord3D
TexCoord3D type.
Definition: PolyMeshT.hh:125
void update_normals()
Compute normals for all primitives.
Definition: PolyMeshT.cc:241
Kernel::ConstVertexFaceIter ConstVertexFaceIter
Circulator.
Definition: PolyMeshT.hh:179
Kernel::VertexOHalfedgeIter VertexOHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:166
Kernel::VertexEdgeIter VertexEdgeIter
Circulator.
Definition: PolyMeshT.hh:168
Scalar calc_dihedral_angle(HalfedgeHandle _heh) const
Compute normals for all primitives.
Definition: PolyMeshT.hh:514
Kernel::Face Face
Face type.
Definition: PolyMeshT.hh:133
Kernel::ConstVertexIHalfedgeIter ConstVertexIHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:177
virtual Normal calc_face_normal(FaceHandle _fh) const
Calculate normal vector for face _fh.
Definition: PolyMeshT.cc:102
VertexHandle new_vertex(const Point &_p)
Adds a new vertex initialized to a custom position.
Definition: PolyMeshT.hh:210
Scalar calc_edge_length(EdgeHandle _eh) const
Compute normals for all primitives.
Definition: PolyMeshT.hh:392
Kernel::ConstHalfedgeIter ConstHalfedgeIter
Scalar type.
Definition: PolyMeshT.hh:152
VertexHandle new_vertex_dirty(const Point &_p)
Same as new_vertex(const Point&) but never shrinks, only enlarges the vertex property vectors.
Definition: PolyMeshT.hh:228
void update_normal(VertexHandle _vh)
Update normal for vertex _vh.
Definition: PolyMeshT.hh:318
void calc_sector_vectors(HalfedgeHandle _in_heh, Normal &_vec0, Normal &_vec1) const
defines a consistent representation of a sector geometry: the halfedge _in_heh defines the sector ori...
Definition: PolyMeshT.hh:414
Kernel::FaceFaceIter FaceFaceIter
Circulator.
Definition: PolyMeshT.hh:173
bool is_estimated_feature_edge(HalfedgeHandle _heh, const double _feature_angle) const
identifies feature edges w.r.t.
Definition: PolyMeshT.cc:342
Normal calc_edge_vector(EdgeHandle _eh) const
Calculates the edge vector as the vector defined by the halfedge with id #0 (see below)
Definition: PolyMeshT.hh:371
virtual ~PolyMeshT()
Circulator.
Definition: PolyMeshT.hh:189
Kernel::ConstVertexEdgeIter ConstVertexEdgeIter
Circulator.
Definition: PolyMeshT.hh:178
Scalar calc_edge_sqr_length(HalfedgeHandle _heh) const
Compute normals for all primitives.
Definition: PolyMeshT.hh:403
void calc_edge_vector(EdgeHandle _eh, Normal &_edge_vec) const
Calculates the edge vector as the vector defined by the halfedge with id #0 (see below)
Definition: PolyMeshT.hh:364
Kernel::Edge Edge
Edge type.
Definition: PolyMeshT.hh:131
Kernel::FaceHandle FaceHandle
Scalar type.
Definition: PolyMeshT.hh:142
void update_normal(FaceHandle _fh)
Update normal for face _fh.
Definition: PolyMeshT.hh:259
Scalar calc_dihedral_angle_fast(EdgeHandle _eh) const
calculates the dihedral angle on the edge _eh
Definition: PolyMeshT.hh:510
VertexHandle add_vertex(const Point &_p)
Alias for new_vertex(const Point&).
Definition: PolyMeshT.hh:236
void calc_vertex_normal_loop(VertexHandle _vh, Normal &_n) const
Compute normals for all primitives.
Definition: PolyMeshT.cc:425
void split(EdgeHandle _eh, const Point &_p)
Compute normals for all primitives.
Definition: PolyMeshT.hh:551
Kernel::HalfedgeHandle HalfedgeHandle
Scalar type.
Definition: PolyMeshT.hh:140
Kernel::EdgeIter EdgeIter
Scalar type.
Definition: PolyMeshT.hh:148
void update_normal(HalfedgeHandle _heh, const double _feature_angle=0.8)
Update normal for halfedge _heh.
Definition: PolyMeshT.hh:284
Kernel::ConstEdgeIter ConstEdgeIter
Scalar type.
Definition: PolyMeshT.hh:153
Kernel::ConstVertexIter ConstVertexIter
Scalar type.
Definition: PolyMeshT.hh:151
void update_vertex_normals()
Update normal vectors for all vertices.
Definition: PolyMeshT.cc:448
void calc_sector_normal(HalfedgeHandle _in_heh, Normal &_sector_normal) const
calculates the normal (non-normalized) of the face sector defined by the angle <(_in_heh,...
Definition: PolyMeshT.hh:470
Kernel::ConstVertexOHalfedgeIter ConstVertexOHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:176
VertexHandle add_vertex_dirty(const Point &_p)
Alias for new_vertex_dirty().
Definition: PolyMeshT.hh:240
Normal calc_edge_vector(HalfedgeHandle _heh) const
Calculates the edge vector as the difference of the the points defined by to_vertex_handle() and from...
Definition: PolyMeshT.hh:385
Scalar calc_edge_sqr_length(EdgeHandle _eh) const
Compute normals for all primitives.
Definition: PolyMeshT.hh:400
Kernel::VertexVertexIter VertexVertexIter
Circulator.
Definition: PolyMeshT.hh:165
void split(EdgeHandle _eh, VertexHandle _vh)
Compute normals for all primitives.
Definition: PolyMeshT.hh:554
Kernel::HalfedgeIter HalfedgeIter
Scalar type.
Definition: PolyMeshT.hh:147
Scalar calc_edge_length(HalfedgeHandle _heh) const
Calculates the length of the edge _heh.
Definition: PolyMeshT.hh:397
Kernel::FaceHalfedgeIter FaceHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:171
Kernel::Point Point
Coordinate type.
Definition: PolyMeshT.hh:115
VertexHandle new_vertex()
Uses default copy and assignment operator.
Definition: PolyMeshT.hh:202
PolyMeshT< Kernel > This
Self type. Used to specify iterators/circulators.
Definition: PolyMeshT.hh:99
Kernel::ConstFaceFaceIter ConstFaceFaceIter
Circulator.
Definition: PolyMeshT.hh:183
void split(FaceHandle _fh, const Point &_p)
Face split (= 1-to-n split)
Definition: PolyMeshT.hh:545
Kernel::Color Color
Color type.
Definition: PolyMeshT.hh:119
Kernel::TexCoord1D TexCoord1D
TexCoord1D type.
Definition: PolyMeshT.hh:121
Kernel::VertexIter VertexIter
Scalar type.
Definition: PolyMeshT.hh:146
Scalar calc_dihedral_angle_fast(HalfedgeHandle _heh) const
calculates the dihedral angle on the halfedge _heh
Definition: PolyMeshT.hh:489
Normal calc_vertex_normal(VertexHandle _vh) const
Calculate vertex normal for one specific vertex.
Definition: PolyMeshT.cc:373

Project OpenMesh, ©  Computer Graphics Group, RWTH Aachen. Documentation generated using doxygen .