| OpenMesh

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
ArrayKernel.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: 1308 $ *
45 * $Date: 2015-07-08 12:12:49 +0200 (Mi, 08 Jul 2015) $ *
46 * *
47 \*===========================================================================*/
48
49
50 //=============================================================================
51 //
52 // CLASS ArrayKernel
53 //
54 //=============================================================================
55
56
57 #ifndef OPENMESH_ARRAY_KERNEL_HH
58 #define OPENMESH_ARRAY_KERNEL_HH
59
60
61 //== INCLUDES =================================================================
62 #include <vector>
63
64 #include <OpenMesh/Core/System/config.h>
65 #include <OpenMesh/Core/Utils/GenProg.hh>
66
67 #include <OpenMesh/Core/Mesh/ArrayItems.hh>
68 #include <OpenMesh/Core/Mesh/BaseKernel.hh>
69 #include <OpenMesh/Core/Mesh/Status.hh>
70
71 //== NAMESPACES ===============================================================
72 namespace OpenMesh {
73
74
75 //== CLASS DEFINITION =========================================================
92 class OPENMESHDLLEXPORT ArrayKernel : public BaseKernel, public ArrayItems
93 {
94 public:
95
96 // handles
97 typedef OpenMesh::VertexHandle VertexHandle;
98 typedef OpenMesh::HalfedgeHandle HalfedgeHandle;
99 typedef OpenMesh::EdgeHandle EdgeHandle;
100 typedef OpenMesh::FaceHandle FaceHandle;
101 typedef Attributes::StatusInfo StatusInfo;
102 typedef VPropHandleT<StatusInfo> VertexStatusPropertyHandle;
103 typedef HPropHandleT<StatusInfo> HalfedgeStatusPropertyHandle;
104 typedef EPropHandleT<StatusInfo> EdgeStatusPropertyHandle;
105 typedef FPropHandleT<StatusInfo> FaceStatusPropertyHandle;
106
107 public:
108
109 // --- constructor/destructor ---
110 ArrayKernel();
111 virtual ~ArrayKernel();
112
119 void assign_connectivity(const ArrayKernel& _other);
120
121 // --- handle -> item ---
122 VertexHandle handle(const Vertex& _v) const;
123
124 HalfedgeHandle handle(const Halfedge& _he) const;
125
126 EdgeHandle handle(const Edge& _e) const;
127
128 FaceHandle handle(const Face& _f) const;
129
130
132 bool is_valid_handle(VertexHandle _vh) const;
133
135 bool is_valid_handle(HalfedgeHandle _heh) const;
136
138 bool is_valid_handle(EdgeHandle _eh) const;
139
141 bool is_valid_handle(FaceHandle _fh) const;
142
143
144 // --- item -> handle ---
145 const Vertex& vertex(VertexHandle _vh) const
146 {
147 assert(is_valid_handle(_vh));
148 return vertices_[_vh.idx()];
149 }
150
151 Vertex& vertex(VertexHandle _vh)
152 {
153 assert(is_valid_handle(_vh));
154 return vertices_[_vh.idx()];
155 }
156
157 const Halfedge& halfedge(HalfedgeHandle _heh) const
158 {
159 assert(is_valid_handle(_heh));
160 return edges_[_heh.idx() >> 1].halfedges_[_heh.idx() & 1];
161 }
162
163 Halfedge& halfedge(HalfedgeHandle _heh)
164 {
165 assert(is_valid_handle(_heh));
166 return edges_[_heh.idx() >> 1].halfedges_[_heh.idx() & 1];
167 }
168
169 const Edge& edge(EdgeHandle _eh) const
170 {
171 assert(is_valid_handle(_eh));
172 return edges_[_eh.idx()];
173 }
174
175 Edge& edge(EdgeHandle _eh)
176 {
177 assert(is_valid_handle(_eh));
178 return edges_[_eh.idx()];
179 }
180
181 const Face& face(FaceHandle _fh) const
182 {
183 assert(is_valid_handle(_fh));
184 return faces_[_fh.idx()];
185 }
186
187 Face& face(FaceHandle _fh)
188 {
189 assert(is_valid_handle(_fh));
190 return faces_[_fh.idx()];
191 }
192
193 // --- get i'th items ---
194
195 VertexHandle vertex_handle(unsigned int _i) const
196 { return (_i < n_vertices()) ? handle( vertices_[_i] ) : VertexHandle(); }
197
198 HalfedgeHandle halfedge_handle(unsigned int _i) const
199 {
200 return (_i < n_halfedges()) ?
201 halfedge_handle(edge_handle(_i/2), _i%2) : HalfedgeHandle();
202 }
203
204 EdgeHandle edge_handle(unsigned int _i) const
205 { return (_i < n_edges()) ? handle(edges_[_i]) : EdgeHandle(); }
206
207 FaceHandle face_handle(unsigned int _i) const
208 { return (_i < n_faces()) ? handle(faces_[_i]) : FaceHandle(); }
209
210 public:
211
212 inline VertexHandle new_vertex()
213 {
214 vertices_.push_back(Vertex());
215 vprops_resize(n_vertices());//TODO:should it be push_back()?
216
217 return handle(vertices_.back());
218 }
219
220 inline HalfedgeHandle new_edge(VertexHandle _start_vh, VertexHandle _end_vh)
221 {
222 // assert(_start_vh != _end_vh);
223 edges_.push_back(Edge());
224 eprops_resize(n_edges());//TODO:should it be push_back()?
225 hprops_resize(n_halfedges());//TODO:should it be push_back()?
226
227 EdgeHandle eh(handle(edges_.back()));
228 HalfedgeHandle heh0(halfedge_handle(eh, 0));
229 HalfedgeHandle heh1(halfedge_handle(eh, 1));
230 set_vertex_handle(heh0, _end_vh);
231 set_vertex_handle(heh1, _start_vh);
232 return heh0;
233 }
234
235 inline FaceHandle new_face()
236 {
237 faces_.push_back(Face());
238 fprops_resize(n_faces());
239 return handle(faces_.back());
240 }
241
242 inline FaceHandle new_face(const Face& _f)
243 {
244 faces_.push_back(_f);
245 fprops_resize(n_faces());
246 return handle(faces_.back());
247 }
248
249 public:
250 // --- resize/reserve ---
251 void resize( size_t _n_vertices, size_t _n_edges, size_t _n_faces );
252 void reserve(size_t _n_vertices, size_t _n_edges, size_t _n_faces );
253
254 // --- deletion ---
270 void garbage_collection(bool _v=true, bool _e=true, bool _f=true);
271
289 template<typename std_API_Container_VHandlePointer,
290 typename std_API_Container_HHandlePointer,
291 typename std_API_Container_FHandlePointer>
292 void garbage_collection(std_API_Container_VHandlePointer& vh_to_update,
293 std_API_Container_HHandlePointer& hh_to_update,
294 std_API_Container_FHandlePointer& fh_to_update,
295 bool _v=true, bool _e=true, bool _f=true);
296
301 void clear();
302
307 void clean();
308
309 // --- number of items ---
310 size_t n_vertices() const { return vertices_.size(); }
311 size_t n_halfedges() const { return 2*edges_.size(); }
312 size_t n_edges() const { return edges_.size(); }
313 size_t n_faces() const { return faces_.size(); }
314
315 bool vertices_empty() const { return vertices_.empty(); }
316 bool halfedges_empty() const { return edges_.empty(); }
317 bool edges_empty() const { return edges_.empty(); }
318 bool faces_empty() const { return faces_.empty(); }
319
320 // --- vertex connectivity ---
321
322 HalfedgeHandle halfedge_handle(VertexHandle _vh) const
323 { return vertex(_vh).halfedge_handle_; }
324
325 void set_halfedge_handle(VertexHandle _vh, HalfedgeHandle _heh)
326 {
327 // assert(is_valid_handle(_heh));
328 vertex(_vh).halfedge_handle_ = _heh;
329 }
330
331 bool is_isolated(VertexHandle _vh) const
332 { return !halfedge_handle(_vh).is_valid(); }
333
334 void set_isolated(VertexHandle _vh)
335 { vertex(_vh).halfedge_handle_.invalidate(); }
336
337 unsigned int delete_isolated_vertices();
338
339 // --- halfedge connectivity ---
340 VertexHandle to_vertex_handle(HalfedgeHandle _heh) const
341 { return halfedge(_heh).vertex_handle_; }
342
343 VertexHandle from_vertex_handle(HalfedgeHandle _heh) const
344 { return to_vertex_handle(opposite_halfedge_handle(_heh)); }
345
346 void set_vertex_handle(HalfedgeHandle _heh, VertexHandle _vh)
347 {
348 // assert(is_valid_handle(_vh));
349 halfedge(_heh).vertex_handle_ = _vh;
350 }
351
352 FaceHandle face_handle(HalfedgeHandle _heh) const
353 { return halfedge(_heh).face_handle_; }
354
355 void set_face_handle(HalfedgeHandle _heh, FaceHandle _fh)
356 {
357 // assert(is_valid_handle(_fh));
358 halfedge(_heh).face_handle_ = _fh;
359 }
360
361 void set_boundary(HalfedgeHandle _heh)
362 { halfedge(_heh).face_handle_.invalidate(); }
363
365 bool is_boundary(HalfedgeHandle _heh) const
366 { return !face_handle(_heh).is_valid(); }
367
368 HalfedgeHandle next_halfedge_handle(HalfedgeHandle _heh) const
369 { return halfedge(_heh).next_halfedge_handle_; }
370
371 void set_next_halfedge_handle(HalfedgeHandle _heh, HalfedgeHandle _nheh)
372 {
373 assert(is_valid_handle(_nheh));
374 // assert(to_vertex_handle(_heh) == from_vertex_handle(_nheh));
375 halfedge(_heh).next_halfedge_handle_ = _nheh;
376 set_prev_halfedge_handle(_nheh, _heh);
377 }
378
379
380 void set_prev_halfedge_handle(HalfedgeHandle _heh, HalfedgeHandle _pheh)
381 {
382 assert(is_valid_handle(_pheh));
383 set_prev_halfedge_handle(_heh, _pheh, HasPrevHalfedge());
384 }
385
386 void set_prev_halfedge_handle(HalfedgeHandle _heh, HalfedgeHandle _pheh,
387 GenProg::TrueType)
388 { halfedge(_heh).prev_halfedge_handle_ = _pheh; }
389
390 void set_prev_halfedge_handle(HalfedgeHandle /* _heh */, HalfedgeHandle /* _pheh */,
391 GenProg::FalseType)
392 {}
393
394 HalfedgeHandle prev_halfedge_handle(HalfedgeHandle _heh) const
395 { return prev_halfedge_handle(_heh, HasPrevHalfedge() ); }
396
397 HalfedgeHandle prev_halfedge_handle(HalfedgeHandle _heh, GenProg::TrueType) const
398 { return halfedge(_heh).prev_halfedge_handle_; }
399
400 HalfedgeHandle prev_halfedge_handle(HalfedgeHandle _heh, GenProg::FalseType) const
401 {
402 if (is_boundary(_heh))
403 {//iterating around the vertex should be faster than iterating the boundary
404 HalfedgeHandle curr_heh(opposite_halfedge_handle(_heh));
405 HalfedgeHandle next_heh(next_halfedge_handle(curr_heh));
406 do
407 {
408 curr_heh = opposite_halfedge_handle(next_heh);
409 next_heh = next_halfedge_handle(curr_heh);
410 }
411 while (next_heh != _heh);
412 return curr_heh;
413 }
414 else
415 {
416 HalfedgeHandle heh(_heh);
417 HalfedgeHandle next_heh(next_halfedge_handle(heh));
418 while (next_heh != _heh) {
419 heh = next_heh;
420 next_heh = next_halfedge_handle(next_heh);
421 }
422 return heh;
423 }
424 }
425
426
427 HalfedgeHandle opposite_halfedge_handle(HalfedgeHandle _heh) const
428 { return HalfedgeHandle((_heh.idx() & 1) ? _heh.idx()-1 : _heh.idx()+1); }
429
430
431 HalfedgeHandle ccw_rotated_halfedge_handle(HalfedgeHandle _heh) const
432 { return opposite_halfedge_handle(prev_halfedge_handle(_heh)); }
433
434
435 HalfedgeHandle cw_rotated_halfedge_handle(HalfedgeHandle _heh) const
436 { return next_halfedge_handle(opposite_halfedge_handle(_heh)); }
437
438 // --- edge connectivity ---
439 HalfedgeHandle halfedge_handle(EdgeHandle _eh, unsigned int _i) const
440 {
441 assert(_i<=1);
442 return HalfedgeHandle((_eh.idx() << 1) + _i);
443 }
444
445 EdgeHandle edge_handle(HalfedgeHandle _heh) const
446 { return EdgeHandle(_heh.idx() >> 1); }
447
448 // --- face connectivity ---
449 HalfedgeHandle halfedge_handle(FaceHandle _fh) const
450 { return face(_fh).halfedge_handle_; }
451
452 void set_halfedge_handle(FaceHandle _fh, HalfedgeHandle _heh)
453 {
454 // assert(is_valid_handle(_heh));
455 face(_fh).halfedge_handle_ = _heh;
456 }
457
459 //------------------------------------------------------------ vertex status
460 const StatusInfo& status(VertexHandle _vh) const
461 { return property(vertex_status_, _vh); }
462
463 StatusInfo& status(VertexHandle _vh)
464 { return property(vertex_status_, _vh); }
465
466 //----------------------------------------------------------- halfedge status
467 const StatusInfo& status(HalfedgeHandle _hh) const
468 { return property(halfedge_status_, _hh); }
469
470 StatusInfo& status(HalfedgeHandle _hh)
471 { return property(halfedge_status_, _hh); }
472
473 //--------------------------------------------------------------- edge status
474 const StatusInfo& status(EdgeHandle _eh) const
475 { return property(edge_status_, _eh); }
476
477 StatusInfo& status(EdgeHandle _eh)
478 { return property(edge_status_, _eh); }
479
480 //--------------------------------------------------------------- face status
481 const StatusInfo& status(FaceHandle _fh) const
482 { return property(face_status_, _fh); }
483
484 StatusInfo& status(FaceHandle _fh)
485 { return property(face_status_, _fh); }
486
487 inline bool has_vertex_status() const
488 { return vertex_status_.is_valid(); }
489
490 inline bool has_halfedge_status() const
491 { return halfedge_status_.is_valid(); }
492
493 inline bool has_edge_status() const
494 { return edge_status_.is_valid(); }
495
496 inline bool has_face_status() const
497 { return face_status_.is_valid(); }
498
499 inline VertexStatusPropertyHandle vertex_status_pph() const
500 { return vertex_status_; }
501
502 inline HalfedgeStatusPropertyHandle halfedge_status_pph() const
503 { return halfedge_status_; }
504
505 inline EdgeStatusPropertyHandle edge_status_pph() const
506 { return edge_status_; }
507
508 inline FaceStatusPropertyHandle face_status_pph() const
509 { return face_status_; }
510
512 inline VertexStatusPropertyHandle status_pph(VertexHandle /*_hnd*/) const
513 { return vertex_status_pph(); }
514
515 inline HalfedgeStatusPropertyHandle status_pph(HalfedgeHandle /*_hnd*/) const
516 { return halfedge_status_pph(); }
517
518 inline EdgeStatusPropertyHandle status_pph(EdgeHandle /*_hnd*/) const
519 { return edge_status_pph(); }
520
521 inline FaceStatusPropertyHandle status_pph(FaceHandle /*_hnd*/) const
522 { return face_status_pph(); }
523
525 void request_vertex_status()
526 {
527 if (!refcount_vstatus_++)
528 add_property( vertex_status_, "v:status" );
529 }
530
531 void request_halfedge_status()
532 {
533 if (!refcount_hstatus_++)
534 add_property( halfedge_status_, "h:status" );
535 }
536
537 void request_edge_status()
538 {
539 if (!refcount_estatus_++)
540 add_property( edge_status_, "e:status" );
541 }
542
543 void request_face_status()
544 {
545 if (!refcount_fstatus_++)
546 add_property( face_status_, "f:status" );
547 }
548
550 void release_vertex_status()
551 {
552 if ((refcount_vstatus_ > 0) && (! --refcount_vstatus_))
553 remove_property(vertex_status_);
554 }
555
556 void release_halfedge_status()
557 {
558 if ((refcount_hstatus_ > 0) && (! --refcount_hstatus_))
559 remove_property(halfedge_status_);
560 }
561
562 void release_edge_status()
563 {
564 if ((refcount_estatus_ > 0) && (! --refcount_estatus_))
565 remove_property(edge_status_);
566 }
567
568 void release_face_status()
569 {
570 if ((refcount_fstatus_ > 0) && (! --refcount_fstatus_))
571 remove_property(face_status_);
572 }
573
574 private:
575 // iterators
576 typedef std::vector<Vertex> VertexContainer;
577 typedef std::vector<Edge> EdgeContainer;
578 typedef std::vector<Face> FaceContainer;
579 typedef VertexContainer::iterator KernelVertexIter;
580 typedef VertexContainer::const_iterator KernelConstVertexIter;
581 typedef EdgeContainer::iterator KernelEdgeIter;
582 typedef EdgeContainer::const_iterator KernelConstEdgeIter;
583 typedef FaceContainer::iterator KernelFaceIter;
584 typedef FaceContainer::const_iterator KernelConstFaceIter;
585 typedef std::vector<unsigned int> BitMaskContainer;
586
587
588 KernelVertexIter vertices_begin() { return vertices_.begin(); }
589 KernelConstVertexIter vertices_begin() const { return vertices_.begin(); }
590 KernelVertexIter vertices_end() { return vertices_.end(); }
591 KernelConstVertexIter vertices_end() const { return vertices_.end(); }
592
593 KernelEdgeIter edges_begin() { return edges_.begin(); }
594 KernelConstEdgeIter edges_begin() const { return edges_.begin(); }
595 KernelEdgeIter edges_end() { return edges_.end(); }
596 KernelConstEdgeIter edges_end() const { return edges_.end(); }
597
598 KernelFaceIter faces_begin() { return faces_.begin(); }
599 KernelConstFaceIter faces_begin() const { return faces_.begin(); }
600 KernelFaceIter faces_end() { return faces_.end(); }
601 KernelConstFaceIter faces_end() const { return faces_.end(); }
602
604 inline BitMaskContainer& bit_masks(VertexHandle /*_dummy_hnd*/)
605 { return vertex_bit_masks_; }
606 inline BitMaskContainer& bit_masks(EdgeHandle /*_dummy_hnd*/)
607 { return edge_bit_masks_; }
608 inline BitMaskContainer& bit_masks(FaceHandle /*_dummy_hnd*/)
609 { return face_bit_masks_; }
610 inline BitMaskContainer& bit_masks(HalfedgeHandle /*_dummy_hnd*/)
611 { return halfedge_bit_masks_; }
612
613 template <class Handle>
614 unsigned int pop_bit_mask(Handle _hnd)
615 {
616 assert(!bit_masks(_hnd).empty());//check if the client request too many status sets
617 unsigned int bit_mask = bit_masks(_hnd).back();
618 bit_masks(_hnd).pop_back();
619 return bit_mask;
620 }
621
622 template <class Handle>
623 void push_bit_mask(Handle _hnd, unsigned int _bit_mask)
624 {
625 assert(std::find(bit_masks(_hnd).begin(), bit_masks(_hnd).end(), _bit_mask) ==
626 bit_masks(_hnd).end());//this mask should be not already used
627 bit_masks(_hnd).push_back(_bit_mask);
628 }
629
630 void init_bit_masks(BitMaskContainer& _bmc);
631 void init_bit_masks();
632
633 private:
634 VertexContainer vertices_;
635 EdgeContainer edges_;
636 FaceContainer faces_;
637
638 VertexStatusPropertyHandle vertex_status_;
639 HalfedgeStatusPropertyHandle halfedge_status_;
640 EdgeStatusPropertyHandle edge_status_;
641 FaceStatusPropertyHandle face_status_;
642
643 unsigned int refcount_vstatus_;
644 unsigned int refcount_hstatus_;
645 unsigned int refcount_estatus_;
646 unsigned int refcount_fstatus_;
647
648 BitMaskContainer halfedge_bit_masks_;
649 BitMaskContainer edge_bit_masks_;
650 BitMaskContainer vertex_bit_masks_;
651 BitMaskContainer face_bit_masks_;
652 };
653
654
655 //=============================================================================
656 } // namespace OpenMesh
657 //=============================================================================
658 #if defined(OM_INCLUDE_TEMPLATES) && !defined(OPENMESH_ARRAY_KERNEL_C)
659 # define OPENMESH_ARRAY_KERNEL_TEMPLATES
660 # include "ArrayKernelT.cc"
661 #endif
662 //=============================================================================
663 #endif // OPENMESH_ARRAY_KERNEL_HH defined
664 //=============================================================================
OpenMesh::ArrayKernel::release_vertex_status
void release_vertex_status()
Status Release API.
Definition: ArrayKernel.hh:550
OpenMesh::BaseHandle::is_valid
bool is_valid() const
The handle is valid iff the index is not equal to -1.
Definition: Handles.hh:77
OpenMesh
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:64
OpenMesh::EdgeHandle
Handle for a edge entity.
Definition: Handles.hh:135
OpenMesh::BaseHandle::idx
int idx() const
Get the underlying index of this handle.
Definition: Handles.hh:74
OpenMesh::VPropHandleT< StatusInfo >
OpenMesh::ArrayKernel
Mesh kernel using arrays for mesh item storage.
Definition: ArrayKernel.hh:92
OpenMesh::FaceHandle
Handle for a face entity.
Definition: Handles.hh:142
OpenMesh::ArrayKernel::status_pph
VertexStatusPropertyHandle status_pph(VertexHandle) const
status property by handle
Definition: ArrayKernel.hh:512
OpenMesh::HalfedgeHandle
Handle for a halfedge entity.
Definition: Handles.hh:128
OpenMesh::Attributes::StatusInfo
Add status information to a base class.
Definition: Status.hh:99
OpenMesh::EPropHandleT< StatusInfo >
OpenMesh::ArrayKernel::status
const StatusInfo & status(VertexHandle _vh) const
Status Query API.
Definition: ArrayKernel.hh:460
OpenMesh::VertexHandle
Handle for a vertex entity.
Definition: Handles.hh:121
OpenMesh::ArrayKernel::request_vertex_status
void request_vertex_status()
Status Request API.
Definition: ArrayKernel.hh:525
OpenMesh::FPropHandleT< StatusInfo >
OpenMesh::ArrayKernel::is_boundary
bool is_boundary(HalfedgeHandle _heh) const
Is halfedge _heh a boundary halfedge (is its face handle invalid) ?
Definition: ArrayKernel.hh:365
OpenMesh::BaseKernel
This class provides the basic property management like adding/removing properties and access to prope...
Definition: BaseKernel.hh:99
OpenMesh::HPropHandleT< StatusInfo >
OpenMesh::BaseHandle::invalidate
void invalidate()
reset handle to be invalid
Definition: Handles.hh:82