OpenMesh
Loading...
Searching...
No Matches
PolyMeshT.hh
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
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
59#include <OpenMesh/Core/System/config.h>
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
70namespace OpenMesh {
71
72//== CLASS DEFINITION =========================================================
73
74
89template <class Kernel>
90class PolyMeshT : public Kernel
91{
92public:
93
96 //--- item types ---
97
99
100 static constexpr bool is_polymesh() { return true; }
101 static constexpr bool is_trimesh() { return false; }
102 using ConnectivityTag = PolyConnectivityTag;
103 enum { IsPolyMesh = 1 };
104 enum { IsTriMesh = 0 };
106
108
109
110 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
162 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
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
214 {
215 VertexHandle vh(Kernel::new_vertex());
216 this->set_point(vh, _p);
217 return make_smart(vh, this);
218 }
219
232 {
233 VertexHandle vh(Kernel::new_vertex_dirty());
234 this->set_point(vh, _p);
235 return make_smart(vh, this);
236 }
237
246 { return new_vertex(_p); }
247
250 { return make_smart(new_vertex_dirty(_p), this); }
251
252 // --- normal vectors ---
253
257
265 void update_normals();
266
269 { this->set_normal(_fh, calc_face_normal(_fh)); }
270
276 void update_face_normals();
277
279 virtual Normal calc_face_normal(FaceHandle _fh) const;
280
282 Normal calc_face_normal(const Point& _p0, const Point& _p1,
283 const Point& _p2) const;
284
286 Normal calc_normal(FaceHandle _fh) const;
287
289 void calc_face_centroid(FaceHandle _fh, Point& _pt) const {
290 _pt = calc_face_centroid(_fh);
291 }
292
295
297 Point calc_centroid(FaceHandle _fh) const;
298
300 Point calc_centroid(EdgeHandle _eh) const;
301
304
307
309 Point calc_centroid(MeshHandle _mh) const;
310
312 void update_normal(HalfedgeHandle _heh, const double _feature_angle = 0.8)
313 { this->set_normal(_heh, calc_halfedge_normal(_heh,_feature_angle)); }
314
324 void update_halfedge_normals(const double _feature_angle = 0.8);
325
338 virtual Normal calc_halfedge_normal(HalfedgeHandle _heh, const double _feature_angle = 0.8) const;
339
341 Normal calc_normal(HalfedgeHandle, const double _feature_angle = 0.8) const;
342
345 bool is_estimated_feature_edge(HalfedgeHandle _heh, const double _feature_angle) const;
346
349 { this->set_normal(_vh, calc_vertex_normal(_vh)); }
350
361
375
383 void calc_vertex_normal_fast(VertexHandle _vh, Normal& _n) const;
385 void calc_vertex_normal_loop(VertexHandle _vh, Normal& _n) const;
386
389
391
392 // --- Geometry API - still in development ---
393
396 void calc_edge_vector(EdgeHandle _eh, Normal& _edge_vec) const
397 {
398 _edge_vec = calc_edge_vector(_eh);
399 }
400
404 {
405 return calc_edge_vector(this->halfedge_handle(_eh,0));
406 }
407
410 void calc_edge_vector(HalfedgeHandle _heh, Normal& _edge_vec) const
411 {
412 _edge_vec = calc_edge_vector(_heh);
413 }
414
418 {
419 return this->point(this->to_vertex_handle(_heh)) -
420 this->point(this->from_vertex_handle(_heh));
421 }
422
423 // Calculates the length of the edge _eh
425 { return calc_edge_length(this->halfedge_handle(_eh,0)); }
426
430 { return (Scalar)sqrt(calc_edge_sqr_length(_heh)); }
431
433 { return calc_edge_sqr_length(this->halfedge_handle(_eh,0)); }
434
436 {
437 Normal edge_vec;
438 calc_edge_vector(_heh, edge_vec);
439 return sqrnorm(edge_vec);
440 }
441
445 {
446 VertexHandle vh0 = this->from_vertex_handle(_heh);
447 VertexHandle vh1 = this->to_vertex_handle(_heh);
448 return 0.5 * (this->point(vh0) + this->point(vh1));
449 }
450
454 {
455 return calc_edge_midpoint(this->halfedge_handle(_eh, 0));
456 }
457
460 {
461 HalfedgeHandle _heh = this->halfedge_handle(_eh, 0);
462 VertexHandle vh0 = this->from_vertex_handle(_heh);
463 VertexHandle vh1 = this->to_vertex_handle(_heh);
464 return 0.5 * (this->calc_normal(vh0) + this->calc_normal(vh1));
465 }
466
471 void calc_sector_vectors(HalfedgeHandle _in_heh, Normal& _vec0, Normal& _vec1) const
472 {
473 calc_edge_vector(this->next_halfedge_handle(_in_heh), _vec0);//p2 - p1
474 calc_edge_vector(this->opposite_halfedge_handle(_in_heh), _vec1);//p0 - p1
475 }
476
483 {
484 Normal v0, v1;
485 calc_sector_vectors(_in_heh, v0, v1);
486 Scalar denom = norm(v0)*norm(v1);
487 if ( denom == Scalar(0))
488 {
489 return 0;
490 }
491 Scalar cos_a = dot(v0 , v1) / denom;
492 if (this->is_boundary(_in_heh))
493 {//determine if the boundary sector is concave or convex
494 FaceHandle fh(this->face_handle(this->opposite_halfedge_handle(_in_heh)));
495 Normal f_n(calc_face_normal(fh));//this normal is (for convex fh) OK
496 Scalar sign_a = dot(cross(v0, v1), f_n);
497 return angle(cos_a, sign_a);
498 }
499 else
500 {
501 return acos(sane_aarg(cos_a));
502 }
503 }
504
505 // calculate the cos and the sin of angle <(_in_heh,next_halfedge(_in_heh))
506 /*
507 void calc_sector_angle_cos_sin(HalfedgeHandle _in_heh, Scalar& _cos_a, Scalar& _sin_a) const
508 {
509 Normal in_vec, out_vec;
510 calc_edge_vector(_in_heh, in_vec);
511 calc_edge_vector(next_halfedge_handle(_in_heh), out_vec);
512 Scalar denom = norm(in_vec)*norm(out_vec);
513 if (is_zero(denom))
514 {
515 _cos_a = 1;
516 _sin_a = 0;
517 }
518 else
519 {
520 _cos_a = dot(in_vec, out_vec)/denom;
521 _sin_a = norm(cross(in_vec, out_vec))/denom;
522 }
523 }
524 */
527 void calc_sector_normal(HalfedgeHandle _in_heh, Normal& _sector_normal) const
528 {
529 Normal vec0, vec1;
530 calc_sector_vectors(_in_heh, vec0, vec1);
531 _sector_normal = cross(vec0, vec1);//(p2-p1)^(p0-p1)
532 }
533
538 {
539 Normal sector_normal;
540 calc_sector_normal(_in_heh, sector_normal);
541 return norm(sector_normal)/2;
542 }
543
547 {
548 // Make sure that we have face normals on the mesh
549 assert(Kernel::has_face_normals());
550
551 if (this->is_boundary(this->edge_handle(_heh)))
552 {//the dihedral angle at a boundary edge is 0
553 return 0;
554 }
555 const Normal& n0 = this->normal(this->face_handle(_heh));
556 const Normal& n1 = this->normal(this->face_handle(this->opposite_halfedge_handle(_heh)));
557 Normal he;
558 calc_edge_vector(_heh, he);
559 Scalar da_cos = dot(n0, n1);
560 //should be normalized, but we need only the sign
561 Scalar da_sin_sign = dot(cross(n0, n1), he);
562 return angle(da_cos, da_sin_sign);
563 }
564
568 { return calc_dihedral_angle_fast(this->halfedge_handle(_eh,0)); }
569
570 // calculates the dihedral angle on the halfedge _heh
572 {
573 if (this->is_boundary(this->edge_handle(_heh)))
574 {//the dihedral angle at a boundary edge is 0
575 return 0;
576 }
577 Normal n0, n1, he;
578 calc_sector_normal(_heh, n0);
579 calc_sector_normal(this->opposite_halfedge_handle(_heh), n1);
580 calc_edge_vector(_heh, he);
581 Scalar denom = norm(n0)*norm(n1);
582 if (denom == Scalar(0))
583 {
584 return 0;
585 }
586 Scalar da_cos = dot(n0, n1)/denom;
587 //should be normalized, but we need only the sign
588 Scalar da_sin_sign = dot(cross(n0, n1), he);
589 return angle(da_cos, da_sin_sign);
590 }
591
592 // calculates the dihedral angle on the edge _eh
594 { return calc_dihedral_angle(this->halfedge_handle(_eh,0)); }
595
598 unsigned int find_feature_edges(Scalar _angle_tresh = OpenMesh::deg_to_rad(44.0));
599 // --- misc ---
600
602 inline void split(FaceHandle _fh, const Point& _p)
603 { Kernel::split(_fh, add_vertex(_p)); }
604
605 inline void split(FaceHandle _fh, VertexHandle _vh)
606 { Kernel::split(_fh, _vh); }
607
608 inline void split(EdgeHandle _eh, const Point& _p)
609 { Kernel::split_edge(_eh, add_vertex(_p)); }
610
611 inline void split(EdgeHandle _eh, VertexHandle _vh)
612 { Kernel::split_edge(_eh, _vh); }
613
614private:
615 struct PointIs3DTag {};
616 struct PointIsNot3DTag {};
617 Normal calc_face_normal_impl(FaceHandle, PointIs3DTag) const;
618 Normal calc_face_normal_impl(FaceHandle, PointIsNot3DTag) const;
619 Normal calc_face_normal_impl(const Point&, const Point&, const Point&, PointIs3DTag) const;
620 Normal calc_face_normal_impl(const Point&, const Point&, const Point&, PointIsNot3DTag) const;
621};
622
648template<typename LHS, typename KERNEL>
650 return MeshCast<LHS, PolyMeshT<KERNEL>&>::cast(rhs);
651}
652
653template<typename LHS, typename KERNEL>
654LHS mesh_cast(PolyMeshT<KERNEL> *rhs) {
655 return MeshCast<LHS, PolyMeshT<KERNEL>*>::cast(rhs);
656}
657
658template<typename LHS, typename KERNEL>
659const LHS mesh_cast(const PolyMeshT<KERNEL> &rhs) {
660 return MeshCast<LHS, const PolyMeshT<KERNEL>&>::cast(rhs);
661}
662
663template<typename LHS, typename KERNEL>
664const LHS mesh_cast(const PolyMeshT<KERNEL> *rhs) {
665 return MeshCast<LHS, const PolyMeshT<KERNEL>*>::cast(rhs);
666}
667
668//=============================================================================
669} // namespace OpenMesh
670//=============================================================================
671#if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_POLYMESH_C)
672# define OPENMESH_POLYMESH_TEMPLATES
673# include "PolyMeshT_impl.hh"
674#endif
675//=============================================================================
676#endif // OPENMESH_POLYMESHT_HH defined
677//=============================================================================
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition MeshItems.hh:59
SmartVertexHandle make_smart(VertexHandle _vh, const PolyConnectivity *_mesh)
Creats a SmartVertexHandle from a VertexHandle and a Mesh.
Definition SmartHandles.hh:256
osg::Vec3f::ValueType dot(const osg::Vec3f &_v1, const osg::Vec3f &_v2)
Adapter for osg vector member computing a scalar product.
Definition VectorAdapter.hh:176
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:140
LHS mesh_cast(PolyMeshT< KERNEL > &rhs)
Cast a mesh with different but identical traits into each other.
Definition PolyMeshT.hh:649
T sane_aarg(T _aarg)
Trigonometry/angles - related.
Definition MathDefs.hh:122
Cast a mesh with different but identical traits into each other.
Definition FinalMeshItemsT.hh:178
Handle for a vertex entity.
Definition Handles.hh:121
Handle for a halfedge entity.
Definition Handles.hh:128
Handle for a edge entity.
Definition Handles.hh:135
Handle for a face entity.
Definition Handles.hh:142
Handle type for meshes to simplify some template programming.
Definition Handles.hh:149
Base type for a polygonal mesh.
Definition PolyMeshT.hh:91
Kernel::Vertex Vertex
Vertex type.
Definition PolyMeshT.hh:124
Kernel::FaceEdgeIter FaceEdgeIter
Circulator.
Definition PolyMeshT.hh:169
void calc_face_centroid(FaceHandle _fh, Point &_pt) const
calculates the average of the vertices defining _fh
Definition PolyMeshT.hh:289
Kernel::ConstFaceIter ConstFaceIter
Scalar type.
Definition PolyMeshT.hh:151
Kernel::VertexHandle VertexHandle
Handle for referencing the corresponding item.
Definition PolyMeshT.hh:136
SmartVertexHandle add_vertex_dirty(const Point &_p)
Alias for new_vertex_dirty().
Definition PolyMeshT.hh:249
Kernel::Scalar Scalar
Scalar type.
Definition PolyMeshT.hh:110
Kernel::ConstVertexVertexIter ConstVertexVertexIter
Circulator.
Definition PolyMeshT.hh:172
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:410
Kernel::ConstFaceHalfedgeIter ConstFaceHalfedgeIter
Circulator.
Definition PolyMeshT.hh:178
Kernel::EdgeHandle EdgeHandle
Scalar type.
Definition PolyMeshT.hh:138
Kernel::VertexFaceIter VertexFaceIter
Circulator.
Definition PolyMeshT.hh:166
Kernel::ConstFaceVertexIter ConstFaceVertexIter
Circulator.
Definition PolyMeshT.hh:177
Kernel::Halfedge Halfedge
Halfedge type.
Definition PolyMeshT.hh:126
void calc_vertex_normal_fast(VertexHandle _vh, Normal &_n) const
Different methods for calculation of the normal at _vh:
Definition PolyMeshT_impl.hh:475
void calc_vertex_normal_correct(VertexHandle _vh, Normal &_n) const
Compute normals for all primitives.
Definition PolyMeshT_impl.hh:485
PolyMeshT()
Circulator.
Definition PolyMeshT.hh:185
Scalar calc_dihedral_angle(EdgeHandle _eh) const
Compute normals for all primitives.
Definition PolyMeshT.hh:593
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
Kernel::FaceIter FaceIter
Scalar type.
Definition PolyMeshT.hh:146
Kernel::Normal Normal
Normal type.
Definition PolyMeshT.hh:114
Kernel::FaceVertexIter FaceVertexIter
Circulator.
Definition PolyMeshT.hh:167
Point calc_edge_midpoint(EdgeHandle _eh) const
Calculates the midpoint of the edge _eh, defined by the positions of the two incident vertices.
Definition PolyMeshT.hh:453
SmartVertexHandle new_vertex()
Uses default copy and assignment operator.
Definition PolyMeshT.hh:201
Kernel::VertexIHalfedgeIter VertexIHalfedgeIter
Circulator.
Definition PolyMeshT.hh:164
void split(FaceHandle _fh, VertexHandle _vh)
Compute normals for all primitives.
Definition PolyMeshT.hh:605
PolyMeshT(const T &t)
Circulator.
Definition PolyMeshT.hh:187
Kernel::TexCoord2D TexCoord2D
TexCoord2D type.
Definition PolyMeshT.hh:120
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:537
SmartVertexHandle add_vertex(const Point &_p)
Alias for new_vertex(const Point&).
Definition PolyMeshT.hh:245
void update_face_normals()
Update normal vectors for all faces.
Definition PolyMeshT_impl.hh:335
void update_halfedge_normals(const double _feature_angle=0.8)
Update normal vectors for all halfedges.
Definition PolyMeshT_impl.hh:350
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_impl.hh:74
virtual Normal calc_halfedge_normal(HalfedgeHandle _heh, const double _feature_angle=0.8) const
Calculate halfedge normal for one specific halfedge.
Definition PolyMeshT_impl.hh:365
Scalar calc_sector_angle(HalfedgeHandle _in_heh) const
calculates the sector angle.
Definition PolyMeshT.hh:482
Kernel::ConstFaceEdgeIter ConstFaceEdgeIter
Circulator.
Definition PolyMeshT.hh:179
Kernel::TexCoord3D TexCoord3D
TexCoord3D type.
Definition PolyMeshT.hh:122
void update_normals()
Compute normals for all primitives.
Definition PolyMeshT_impl.hh:317
Kernel::ConstVertexFaceIter ConstVertexFaceIter
Circulator.
Definition PolyMeshT.hh:176
Kernel::VertexOHalfedgeIter VertexOHalfedgeIter
Circulator.
Definition PolyMeshT.hh:163
Point calc_centroid(FaceHandle _fh) const
Computes and returns the average of the vertices defining _fh (same as calc_face_centroid)
Definition PolyMeshT_impl.hh:267
Kernel::VertexEdgeIter VertexEdgeIter
Circulator.
Definition PolyMeshT.hh:165
Scalar calc_dihedral_angle(HalfedgeHandle _heh) const
Compute normals for all primitives.
Definition PolyMeshT.hh:571
Kernel::Face Face
Face type.
Definition PolyMeshT.hh:130
Kernel::ConstVertexIHalfedgeIter ConstVertexIHalfedgeIter
Circulator.
Definition PolyMeshT.hh:174
SmartVertexHandle new_vertex(const Point &_p)
Adds a new vertex initialized to a custom position.
Definition PolyMeshT.hh:213
virtual Normal calc_face_normal(FaceHandle _fh) const
Calculate normal vector for face _fh.
Definition PolyMeshT_impl.hh:97
Normal calc_normal(EdgeHandle _eh) const
calculated and returns the average of the two vertex normals
Definition PolyMeshT.hh:459
Scalar calc_edge_length(EdgeHandle _eh) const
Compute normals for all primitives.
Definition PolyMeshT.hh:424
Kernel::ConstHalfedgeIter ConstHalfedgeIter
Scalar type.
Definition PolyMeshT.hh:149
void update_normal(VertexHandle _vh)
Update normal for vertex _vh.
Definition PolyMeshT.hh:348
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:471
Kernel::FaceFaceIter FaceFaceIter
Circulator.
Definition PolyMeshT.hh:170
bool is_estimated_feature_edge(HalfedgeHandle _heh, const double _feature_angle) const
identifies feature edges w.r.t.
Definition PolyMeshT_impl.hh:430
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:403
virtual ~PolyMeshT()
Circulator.
Definition PolyMeshT.hh:188
Kernel::ConstVertexEdgeIter ConstVertexEdgeIter
Circulator.
Definition PolyMeshT.hh:175
Scalar calc_edge_sqr_length(HalfedgeHandle _heh) const
Compute normals for all primitives.
Definition PolyMeshT.hh:435
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:396
Kernel::Edge Edge
Edge type.
Definition PolyMeshT.hh:128
Kernel::FaceHandle FaceHandle
Scalar type.
Definition PolyMeshT.hh:139
void update_normal(FaceHandle _fh)
Update normal for face _fh.
Definition PolyMeshT.hh:268
Scalar calc_dihedral_angle_fast(EdgeHandle _eh) const
calculates the dihedral angle on the edge _eh
Definition PolyMeshT.hh:567
void calc_vertex_normal_loop(VertexHandle _vh, Normal &_n) const
Compute normals for all primitives.
Definition PolyMeshT_impl.hh:516
void split(EdgeHandle _eh, const Point &_p)
Compute normals for all primitives.
Definition PolyMeshT.hh:608
Kernel::HalfedgeHandle HalfedgeHandle
Scalar type.
Definition PolyMeshT.hh:137
Kernel::EdgeIter EdgeIter
Scalar type.
Definition PolyMeshT.hh:145
void update_normal(HalfedgeHandle _heh, const double _feature_angle=0.8)
Update normal for halfedge _heh.
Definition PolyMeshT.hh:312
Kernel::ConstEdgeIter ConstEdgeIter
Scalar type.
Definition PolyMeshT.hh:150
Kernel::ConstVertexIter ConstVertexIter
Scalar type.
Definition PolyMeshT.hh:148
void update_vertex_normals()
Update normal vectors for all vertices.
Definition PolyMeshT_impl.hh:550
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:527
Kernel::ConstVertexOHalfedgeIter ConstVertexOHalfedgeIter
Circulator.
Definition PolyMeshT.hh:173
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:417
Scalar calc_edge_sqr_length(EdgeHandle _eh) const
Compute normals for all primitives.
Definition PolyMeshT.hh:432
Point calc_edge_midpoint(HalfedgeHandle _heh) const
Calculates the midpoint of the halfedge _heh, defined by the positions of the two incident vertices.
Definition PolyMeshT.hh:444
Kernel::VertexVertexIter VertexVertexIter
Circulator.
Definition PolyMeshT.hh:162
void split(EdgeHandle _eh, VertexHandle _vh)
Compute normals for all primitives.
Definition PolyMeshT.hh:611
Kernel::HalfedgeIter HalfedgeIter
Scalar type.
Definition PolyMeshT.hh:144
SmartVertexHandle new_vertex_dirty(const Point &_p)
Same as new_vertex(const Point&) but never shrinks, only enlarges the vertex property vectors.
Definition PolyMeshT.hh:231
Scalar calc_edge_length(HalfedgeHandle _heh) const
Calculates the length of the edge _heh.
Definition PolyMeshT.hh:429
Kernel::FaceHalfedgeIter FaceHalfedgeIter
Circulator.
Definition PolyMeshT.hh:168
Kernel::Point Point
Coordinate type.
Definition PolyMeshT.hh:112
PolyMeshT< Kernel > This
Self type. Used to specify iterators/circulators.
Definition PolyMeshT.hh:95
Kernel::ConstFaceFaceIter ConstFaceFaceIter
Circulator.
Definition PolyMeshT.hh:180
void split(FaceHandle _fh, const Point &_p)
Face split (= 1-to-n split)
Definition PolyMeshT.hh:602
Kernel::Color Color
Color type.
Definition PolyMeshT.hh:116
Kernel::TexCoord1D TexCoord1D
TexCoord1D type.
Definition PolyMeshT.hh:118
Normal calc_normal(FaceHandle _fh) const
same as calc_face_normal
Definition PolyMeshT_impl.hh:187
Kernel::VertexIter VertexIter
Scalar type.
Definition PolyMeshT.hh:143
Scalar calc_dihedral_angle_fast(HalfedgeHandle _heh) const
calculates the dihedral angle on the halfedge _heh
Definition PolyMeshT.hh:546
Normal calc_vertex_normal(VertexHandle _vh) const
Calculate vertex normal for one specific vertex.
Definition PolyMeshT_impl.hh:461
Smart version of VertexHandle contains a pointer to the corresponding mesh and allows easier access t...
Definition SmartHandles.hh:110

Project OpenMesh, ©  Visual Computing Institute, RWTH Aachen. Documentation generated using doxygen .