Developer Documentation
Loading...
Searching...
No Matches
unittests_smart_ranges.cc
1#include <gtest/gtest.h>
2#include <Unittests/unittests_common.hh>
3
4#include <OpenMesh/Core/Mesh/PolyConnectivity.hh>
5#include <OpenMesh/Core/Utils/PropertyManager.hh>
6#include <OpenMesh/Core/Utils/Predicates.hh>
7
8#include <iostream>
9#include <chrono>
10
11
12#if defined(__has_include)
13# if __has_include(<version>)
14# include <version>
15# endif
16#endif
17#ifdef __cpp_lib_ranges
18# include <ranges>
19#endif
20
21namespace {
22
23class OpenMeshSmartRanges : public OpenMeshBase {
24
25protected:
26
27 // This function is called before each test is run
28 virtual void SetUp() {
29
30 mesh_.clear();
31
32 // Add some vertices
33 Mesh::VertexHandle vhandle[8];
34 vhandle[0] = mesh_.add_vertex(Mesh::Point(-1, -1, 1));
35 vhandle[1] = mesh_.add_vertex(Mesh::Point( 1, -1, 1));
36 vhandle[2] = mesh_.add_vertex(Mesh::Point( 1, 1, 1));
37 vhandle[3] = mesh_.add_vertex(Mesh::Point(-1, 1, 1));
38 vhandle[4] = mesh_.add_vertex(Mesh::Point(-1, -1, -1));
39 vhandle[5] = mesh_.add_vertex(Mesh::Point( 1, -1, -1));
40 vhandle[6] = mesh_.add_vertex(Mesh::Point( 1, 1, -1));
41 vhandle[7] = mesh_.add_vertex(Mesh::Point(-1, 1, -1));
42
43 // Add six faces to form a cube
44 std::vector<Mesh::VertexHandle> face_vhandles;
45
46 face_vhandles.clear();
47 face_vhandles.push_back(vhandle[0]);
48 face_vhandles.push_back(vhandle[1]);
49 face_vhandles.push_back(vhandle[3]);
50 mesh_.add_face(face_vhandles);
51
52 face_vhandles.clear();
53 face_vhandles.push_back(vhandle[1]);
54 face_vhandles.push_back(vhandle[2]);
55 face_vhandles.push_back(vhandle[3]);
56 mesh_.add_face(face_vhandles);
57
58 //=======================
59
60 face_vhandles.clear();
61 face_vhandles.push_back(vhandle[7]);
62 face_vhandles.push_back(vhandle[6]);
63 face_vhandles.push_back(vhandle[5]);
64 mesh_.add_face(face_vhandles);
65
66 face_vhandles.clear();
67 face_vhandles.push_back(vhandle[7]);
68 face_vhandles.push_back(vhandle[5]);
69 face_vhandles.push_back(vhandle[4]);
70 mesh_.add_face(face_vhandles);
71
72 //=======================
73
74 face_vhandles.clear();
75 face_vhandles.push_back(vhandle[1]);
76 face_vhandles.push_back(vhandle[0]);
77 face_vhandles.push_back(vhandle[4]);
78 mesh_.add_face(face_vhandles);
79
80 face_vhandles.clear();
81 face_vhandles.push_back(vhandle[1]);
82 face_vhandles.push_back(vhandle[4]);
83 face_vhandles.push_back(vhandle[5]);
84 mesh_.add_face(face_vhandles);
85
86 //=======================
87
88 face_vhandles.clear();
89 face_vhandles.push_back(vhandle[2]);
90 face_vhandles.push_back(vhandle[1]);
91 face_vhandles.push_back(vhandle[5]);
92 mesh_.add_face(face_vhandles);
93
94 face_vhandles.clear();
95 face_vhandles.push_back(vhandle[2]);
96 face_vhandles.push_back(vhandle[5]);
97 face_vhandles.push_back(vhandle[6]);
98 mesh_.add_face(face_vhandles);
99
100
101 //=======================
102
103 face_vhandles.clear();
104 face_vhandles.push_back(vhandle[3]);
105 face_vhandles.push_back(vhandle[2]);
106 face_vhandles.push_back(vhandle[6]);
107 mesh_.add_face(face_vhandles);
108
109 face_vhandles.clear();
110 face_vhandles.push_back(vhandle[3]);
111 face_vhandles.push_back(vhandle[6]);
112 face_vhandles.push_back(vhandle[7]);
113 mesh_.add_face(face_vhandles);
114
115 //=======================
116
117 face_vhandles.clear();
118 face_vhandles.push_back(vhandle[0]);
119 face_vhandles.push_back(vhandle[3]);
120 face_vhandles.push_back(vhandle[7]);
121 mesh_.add_face(face_vhandles);
122
123 face_vhandles.clear();
124 face_vhandles.push_back(vhandle[0]);
125 face_vhandles.push_back(vhandle[7]);
126 face_vhandles.push_back(vhandle[4]);
127 mesh_.add_face(face_vhandles);
128
129
130 // Test setup:
131 //
132 //
133 // 3 ======== 2
134 // / /|
135 // / / | z
136 // 0 ======== 1 | |
137 // | | | | y
138 // | 7 | 6 | /
139 // | | / | /
140 // | |/ |/
141 // 4 ======== 5 -------> x
142 //
143
144 // Check setup
145 EXPECT_EQ(18u, mesh_.n_edges() ) << "Wrong number of Edges";
146 EXPECT_EQ(36u, mesh_.n_halfedges() ) << "Wrong number of HalfEdges";
147 EXPECT_EQ(8u, mesh_.n_vertices() ) << "Wrong number of vertices";
148 EXPECT_EQ(12u, mesh_.n_faces() ) << "Wrong number of faces";
149 }
150
151 // This function is called after all tests are through
152 virtual void TearDown() {
153
154 // Do some final stuff with the member data here...
155
156 mesh_.clear();
157 }
158
159 // Member already defined in OpenMeshBase
160 //Mesh mesh_;
161};
162
163/*
164 * ====================================================================
165 * Define tests below
166 * ====================================================================
167 */
168
169
170template <typename HandleT>
171struct F
172{
173 unsigned int operator()(HandleT ) { return 1; }
174};
175
176/* Test if smart ranges work
177 */
178TEST_F(OpenMeshSmartRanges, Sum)
179{
180 auto one = [](OpenMesh::VertexHandle ) { return 1u; };
181 EXPECT_EQ(mesh_.vertices().sum(one), mesh_.n_vertices());
182 EXPECT_EQ(mesh_.vertices().sum(F<OpenMesh::VertexHandle>()), mesh_.n_vertices());
183 EXPECT_EQ(mesh_.halfedges().sum(F<OpenMesh::HalfedgeHandle>()), mesh_.n_halfedges());
184 EXPECT_EQ(mesh_.edges().sum(F<OpenMesh::EdgeHandle>()), mesh_.n_edges());
185 EXPECT_EQ(mesh_.faces().sum(F<OpenMesh::FaceHandle>()), mesh_.n_faces());
186
187 for (auto vh : mesh_.vertices())
188 EXPECT_EQ(vh.vertices().sum(F<OpenMesh::VertexHandle>()), mesh_.valence(vh));
189 for (auto vh : mesh_.vertices())
190 EXPECT_EQ(vh.faces().sum(F<OpenMesh::FaceHandle>()), mesh_.valence(vh));
191 for (auto vh : mesh_.vertices())
192 EXPECT_EQ(vh.outgoing_halfedges().sum(F<OpenMesh::HalfedgeHandle>()), mesh_.valence(vh));
193 for (auto vh : mesh_.vertices())
194 EXPECT_EQ(vh.incoming_halfedges().sum(F<OpenMesh::HalfedgeHandle>()), mesh_.valence(vh));
195
196 for (auto fh : mesh_.faces())
197 EXPECT_EQ(fh.vertices().sum(F<OpenMesh::VertexHandle>()), mesh_.valence(fh));
198 for (auto fh : mesh_.faces())
199 EXPECT_EQ(fh.halfedges().sum(F<OpenMesh::HalfedgeHandle>()), mesh_.valence(fh));
200 for (auto fh : mesh_.faces())
201 EXPECT_EQ(fh.edges().sum(F<OpenMesh::EdgeHandle>()), mesh_.valence(fh));
202 for (auto fh : mesh_.faces())
203 EXPECT_EQ(fh.faces().sum(F<OpenMesh::FaceHandle>()), 3u);
204}
205
206TEST_F(OpenMeshSmartRanges, Size)
207{
208 EXPECT_EQ(mesh_.n_faces(), mesh_.faces().size());
209 mesh_.request_face_status(); // required for soft deletion
210 mesh_.delete_face(*mesh_.faces_begin());
211 EXPECT_EQ(mesh_.n_faces()-1, mesh_.faces().size());
212}
213
214#ifdef __cpp_lib_ranges
215TEST_F(OpenMeshSmartRanges, StdRanges)
216{
217 mesh_.request_vertex_status();
218 mesh_.request_edge_status();
219 mesh_.request_face_status();
220 mesh_.delete_face(OpenMesh::FaceHandle(0)); // ensure there is a boundary
221 mesh_.garbage_collection();
222
223 auto vpos_range = mesh_.vertices() | std::views::transform( [&](auto vh){return mesh_.point(vh);});
224 auto vpos_vec = std::vector(vpos_range.begin(), vpos_range.end());
225 EXPECT_EQ(vpos_vec.size(), mesh_.n_vertices());
226 EXPECT_EQ(vpos_vec[0], mesh_.point(OpenMesh::VertexHandle(0)));
227 EXPECT_NE(vpos_vec[1], mesh_.point(OpenMesh::VertexHandle(0)));
228
229 static_assert(std::ranges::input_range<decltype(mesh_.edges())>);
230
231 auto bnd_edges = std::views::filter( mesh_.edges(), [](OpenMesh::SmartEdgeHandle h){return h.is_boundary();});
232 EXPECT_EQ(std::ranges::distance(bnd_edges), 3);
233
234 auto bnd_edges2 = mesh_.edges() | std::views::filter(OpenMesh::Predicates::Boundary());
235 EXPECT_EQ(std::ranges::distance(bnd_edges2), 3);
236
237 auto fh = mesh_.make_smart(mesh_.face_handle(1));
238 auto f_bnds = fh.halfedges() | std::views::filter([](auto h) {return h.opp().is_boundary();});
239 ASSERT_EQ(std::ranges::distance(f_bnds), 1);
240 EXPECT_EQ(f_bnds.begin()->idx(), 3);
241}
242#else
243TEST_F(OpenMeshSmartRanges, DISABLED_StdRanges)
244{
245}
246#endif
247
248/* Test if Property Manager can be used in smart ranges
249 */
250TEST_F(OpenMeshSmartRanges, PropertyManagerAsFunctor)
251{
252 OpenMesh::VProp<Mesh::Point> myPos(mesh_);
253 for (auto vh : mesh_.vertices())
254 myPos(vh) = mesh_.point(vh);
255
256 Mesh::Point cog(0,0,0);
257 for (auto vh : mesh_.vertices())
258 cog += mesh_.point(vh);
259 cog /= mesh_.n_vertices();
260
261 auto cog2 = mesh_.vertices().avg(myPos);
262
263 EXPECT_LT(norm(cog - cog2), 0.00001) << "Computed center of gravities are significantly different.";
264}
265
266/* Test to vector
267 */
268TEST_F(OpenMeshSmartRanges, ToVector)
269{
270 OpenMesh::HProp<OpenMesh::Vec2d> uvs(mesh_);
271
272 for (auto heh : mesh_.halfedges())
273 uvs(heh) = OpenMesh::Vec2d(heh.idx(), (heh.idx() * 13)%7);
274
275 for (auto fh : mesh_.faces())
276 {
277 auto tri_uvs = fh.halfedges().to_vector(uvs);
278 auto heh_handles = fh.halfedges().to_vector();
279 for (auto heh : heh_handles)
280 heh.next();
281 }
282
283 auto vertex_vec = mesh_.vertices().to_vector();
284 for (auto vh : vertex_vec)
285 vh.out();
286}
287
288/* Test to array
289 */
290TEST_F(OpenMeshSmartRanges, ToArray)
291{
292 OpenMesh::HProp<OpenMesh::Vec2d> uvs(mesh_);
293
294 for (auto heh : mesh_.halfedges())
295 uvs(heh) = OpenMesh::Vec2d(heh.idx(), (heh.idx() * 13)%7);
296
297 for (auto fh : mesh_.faces())
298 {
299 fh.halfedges().to_array<3>(uvs);
300 fh.halfedges().to_array<3>();
301 }
302}
303
304
305/* Test bounding box
306 */
307TEST_F(OpenMeshSmartRanges, BoundingBox)
308{
309 // The custom vecs OpenMesh are tested with here do not implement a min or max function.
310 // Thus we convert here.
311 OpenMesh::VProp<OpenMesh::Vec3f> myPos(mesh_);
312 for (auto vh : mesh_.vertices())
313 for (int i = 0; i < 3; ++i)
314 myPos(vh)[i] = mesh_.point(vh)[i];
315
316 auto bb_min = mesh_.vertices().min(myPos);
317 auto bb_max = mesh_.vertices().max(myPos);
318 mesh_.vertices().minmax(myPos);
319
320 EXPECT_LT(norm(bb_min - OpenMesh::Vec3f(-1,-1,-1)), 0.000001) << "Bounding box minimum seems off";
321 EXPECT_LT(norm(bb_max - OpenMesh::Vec3f( 1, 1, 1)), 0.000001) << "Bounding box maximum seems off";
322
323
324 auto uvs = OpenMesh::makeTemporaryProperty<OpenMesh::HalfedgeHandle, OpenMesh::Vec2d>(mesh_);
325 for (auto heh : mesh_.halfedges())
326 uvs(heh) = OpenMesh::Vec2d(heh.idx(), (heh.idx() * 13)%7);
327
328 for (auto fh : mesh_.faces())
329 {
330 fh.halfedges().min(uvs);
331 fh.halfedges().max(uvs);
332 }
333}
334
335
336/* Test for each
337 */
338TEST_F(OpenMeshSmartRanges, ForEach)
339{
340 std::vector<int> vec;
341 auto f = [&vec](OpenMesh::VertexHandle vh) { vec.push_back(vh.idx()); };
342
343 mesh_.vertices().for_each(f);
344
345 ASSERT_EQ(vec.size(), mesh_.n_vertices()) << "vec has wrong size";
346 for (size_t i = 0; i < vec.size(); ++i)
347 EXPECT_EQ(vec[i], static_cast<int>(i)) << "wrong index in vector";
348}
349
350
351/* Test filter
352 */
353TEST_F(OpenMeshSmartRanges, Filtered)
354{
355 using VH = OpenMesh::VertexHandle;
356 using FH = OpenMesh::FaceHandle;
357
358 auto is_even = [](VH vh) { return vh.idx() % 2 == 0; };
359 auto is_odd = [](VH vh) { return vh.idx() % 2 == 1; };
360 auto is_divisible_by_3 = [](VH vh) { return vh.idx() % 3 == 0; };
361 auto to_id = [](VH vh) { return vh.idx(); };
362
363 auto even_vertices = mesh_.vertices().filtered(is_even).to_vector(to_id);
364 EXPECT_EQ(even_vertices.size(), 4u);
365 EXPECT_EQ(even_vertices[0], 0);
366 EXPECT_EQ(even_vertices[1], 2);
367 EXPECT_EQ(even_vertices[2], 4);
368 EXPECT_EQ(even_vertices[3], 6);
369
370 auto odd_vertices = mesh_.vertices().filtered(is_odd).to_vector(to_id);
371 EXPECT_EQ(odd_vertices.size(), 4u);
372 EXPECT_EQ(odd_vertices[0], 1);
373 EXPECT_EQ(odd_vertices[1], 3);
374 EXPECT_EQ(odd_vertices[2], 5);
375 EXPECT_EQ(odd_vertices[3], 7);
376
377 auto even_3_vertices = mesh_.vertices().filtered(is_even).filtered(is_divisible_by_3).to_vector(to_id);
378 EXPECT_EQ(even_3_vertices.size(), 2u);
379 EXPECT_EQ(even_3_vertices[0], 0);
380 EXPECT_EQ(even_3_vertices[1], 6);
381
382 auto odd_3_vertices = mesh_.vertices().filtered(is_odd).filtered(is_divisible_by_3).to_vector(to_id);
383 EXPECT_EQ(odd_3_vertices.size(), 1u);
384 EXPECT_EQ(odd_3_vertices[0], 3);
385
386
387 // create a vector of vertices in the order they are visited when iterating over face vertices, but every vertex only once
388 std::vector<VH> vertices;
389 OpenMesh::VProp<bool> to_be_processed(true, mesh_);
390 auto store_vertex = [&](VH vh) { to_be_processed(vh) = false; vertices.push_back(vh); };
391
392 for (auto fh : mesh_.faces())
393 fh.vertices().filtered(to_be_processed).for_each(store_vertex);
394
395 EXPECT_EQ(vertices.size(), mesh_.n_vertices()) << " number of visited vertices not correct";
396 EXPECT_TRUE(mesh_.vertices().all_of([&](VH vh) { return !to_be_processed(vh); })) << "did not visit all vertices";
397
398 {
399 OpenMesh::FProp<bool> to_be_visited(true, mesh_);
400 size_t visited_faces_in_main_loop = 0;
401 size_t visited_faces_in_sub_loop = 0;
402 for (auto fh : mesh_.faces().filtered(to_be_visited))
403 {
404 to_be_visited(fh) = false;
405 ++visited_faces_in_main_loop;
406 for (auto neighbor : fh.faces().filtered(to_be_visited))
407 {
408 to_be_visited(neighbor) = false;
409 ++visited_faces_in_sub_loop;
410 }
411 }
412
413 EXPECT_LT(visited_faces_in_main_loop, mesh_.n_faces()) << "Visted more faces than expected";
414 EXPECT_TRUE(mesh_.faces().all_of([&](FH fh) { return !to_be_visited(fh); })) << "did not visit all faces";
415 EXPECT_EQ(visited_faces_in_main_loop + visited_faces_in_sub_loop, mesh_.n_faces()) << "Did not visited all faces exactly once";
416 }
417
418 {
419 OpenMesh::FProp<bool> to_be_visited(true, mesh_);
420 const auto& to_be_visited_const_ref = to_be_visited;
421 size_t visited_faces_in_main_loop = 0;
422 size_t visited_faces_in_sub_loop = 0;
423 for (auto fh : mesh_.faces().filtered(to_be_visited_const_ref))
424 {
425 to_be_visited(fh) = false;
426 ++visited_faces_in_main_loop;
427 for (auto neighbor : fh.faces().filtered(to_be_visited_const_ref))
428 {
429 to_be_visited(neighbor) = false;
430 ++visited_faces_in_sub_loop;
431 }
432 }
433
434 EXPECT_LT(visited_faces_in_main_loop, mesh_.n_faces()) << "Visted more faces than expected";
435 EXPECT_TRUE(mesh_.faces().all_of([&](FH fh) { return !to_be_visited(fh); })) << "did not visit all faces";
436 EXPECT_EQ(visited_faces_in_main_loop + visited_faces_in_sub_loop, mesh_.n_faces()) << "Did not visited all faces exactly once";
437 }
438
439}
440
441/* Test avg
442 */
443TEST_F(OpenMeshSmartRanges, Avg)
444{
445
446 Mesh::Point cog(0,0,0);
447 for (auto vh : mesh_.vertices())
448 cog += mesh_.point(vh);
449 cog /= mesh_.n_vertices();
450
451 auto points = OpenMesh::getPointsProperty(mesh_);
452 auto cog2 = mesh_.vertices().avg(points);
453
454 EXPECT_LT(norm(cog - cog2), 0.00001) << "Computed center of gravities are significantly different.";
455}
456
457/* Test weighted avg
458 */
459TEST_F(OpenMeshSmartRanges, WeightedAvg)
460{
461 Mesh::Point cog(0,0,0);
462 for (auto fh : mesh_.faces())
463 cog += mesh_.calc_face_centroid(fh);
464 cog /= mesh_.n_faces();
465
466 OpenMesh::FProp<float> area(mesh_);
467 for (auto fh : mesh_.faces())
468 area[fh] = mesh_.calc_face_area(fh);
469
470 auto cog2 = mesh_.faces().avg([&](OpenMesh::FaceHandle fh) { return mesh_.calc_face_centroid(fh); }, area);
471
472 EXPECT_LT(norm(cog - cog2), 0.00001) << "Computed area weighted center of gravities are significantly different.";
473}
474
475
476template <typename HandleT>
477void test_range_predicates(Mesh& _mesh)
478{
479 using namespace OpenMesh::Predicates;
480
481 auto get_random_set = [&](int n)
482 {
483 auto max = _mesh.n_elements<HandleT>();
484 std::vector<HandleT> set;
485 set.push_back(HandleT(0));
486 for (int i = 0; i < n; ++i)
487 set.push_back(HandleT(rand() % max));
488 std::sort(set.begin(), set.end());
489 set.erase(std::unique(set.begin(), set.end()), set.end());
490 return set;
491 };
492
493 // Feature
494 {
495 for (auto el : _mesh.elements<HandleT>())
496 _mesh.status(el).set_feature(false);
497 auto set = get_random_set(4);
498 for (auto el : set)
499 _mesh.status(el).set_feature(true);
500
501 auto set2 = _mesh.elements<HandleT>().filtered(Feature()).to_vector();
502
503 EXPECT_EQ(set.size(), set2.size()) << "Set sizes differ";
504 for (size_t i = 0; i < std::min(set.size(), set2.size()); ++i)
505 EXPECT_EQ(set[i], set2[i]) << "Sets differ at position " << i;
506
507 for (auto el : _mesh.elements<HandleT>())
508 _mesh.status(el).set_feature(false);
509 }
510
511 // Selected
512 {
513 for (auto el : _mesh.elements<HandleT>())
514 _mesh.status(el).set_selected(false);
515 auto set = get_random_set(4);
516 for (auto el : set)
517 _mesh.status(el).set_selected(true);
518
519 auto set2 = _mesh.elements<HandleT>().filtered(Selected()).to_vector();
520
521 EXPECT_EQ(set.size(), set2.size()) << "Set sizes differ";
522 for (size_t i = 0; i < std::min(set.size(), set2.size()); ++i)
523 EXPECT_EQ(set[i], set2[i]) << "Sets differ at position " << i;
524
525 for (auto el : _mesh.elements<HandleT>())
526 _mesh.status(el).set_selected(false);
527 }
528
529 // Tagged
530 {
531 for (auto el : _mesh.elements<HandleT>())
532 _mesh.status(el).set_tagged(false);
533 auto set = get_random_set(4);
534 for (auto el : set)
535 _mesh.status(el).set_tagged(true);
536
537 auto set2 = _mesh.elements<HandleT>().filtered(Tagged()).to_vector();
538
539 EXPECT_EQ(set.size(), set2.size()) << "Set sizes differ";
540 for (size_t i = 0; i < std::min(set.size(), set2.size()); ++i)
541 EXPECT_EQ(set[i], set2[i]) << "Sets differ at position " << i;
542
543 for (auto el : _mesh.elements<HandleT>())
544 _mesh.status(el).set_tagged(false);
545 }
546
547 // Tagged2
548 {
549 for (auto el : _mesh.elements<HandleT>())
550 _mesh.status(el).set_tagged2(false);
551 auto set = get_random_set(4);
552 for (auto el : set)
553 _mesh.status(el).set_tagged2(true);
554
555 auto set2 = _mesh.elements<HandleT>().filtered(Tagged2()).to_vector();
556
557 EXPECT_EQ(set.size(), set2.size()) << "Set sizes differ";
558 for (size_t i = 0; i < std::min(set.size(), set2.size()); ++i)
559 EXPECT_EQ(set[i], set2[i]) << "Sets differ at position " << i;
560
561 for (auto el : _mesh.elements<HandleT>())
562 _mesh.status(el).set_tagged2(false);
563 }
564
565 // Locked
566 {
567 for (auto el : _mesh.elements<HandleT>())
568 _mesh.status(el).set_locked(false);
569 auto set = get_random_set(4);
570 for (auto el : set)
571 _mesh.status(el).set_locked(true);
572
573 auto set2 = _mesh.elements<HandleT>().filtered(Locked()).to_vector();
574
575 EXPECT_EQ(set.size(), set2.size()) << "Set sizes differ";
576 for (size_t i = 0; i < std::min(set.size(), set2.size()); ++i)
577 EXPECT_EQ(set[i], set2[i]) << "Sets differ at position " << i;
578
579 for (auto el : _mesh.elements<HandleT>())
580 _mesh.status(el).set_locked(false);
581 }
582
583 // Hidden
584 {
585 for (auto el : _mesh.all_elements<HandleT>())
586 _mesh.status(el).set_hidden(false);
587 auto set = get_random_set(4);
588 for (auto el : set)
589 _mesh.status(el).set_hidden(true);
590
591 auto set2 = _mesh.all_elements<HandleT>().filtered(Hidden()).to_vector();
592
593 EXPECT_EQ(set.size(), set2.size()) << "Set sizes differ";
594 for (size_t i = 0; i < std::min(set.size(), set2.size()); ++i)
595 EXPECT_EQ(set[i], set2[i]) << "Sets differ at position " << i;
596
597 for (auto el : _mesh.all_elements<HandleT>())
598 _mesh.status(el).set_hidden(false);
599 }
600
601 // Deleted
602 {
603 for (auto el : _mesh.all_elements<HandleT>())
604 _mesh.status(el).set_deleted(false);
605 auto set = get_random_set(4);
606 for (auto el : set)
607 _mesh.status(el).set_deleted(true);
608
609 auto set2 = _mesh.all_elements<HandleT>().filtered(Deleted()).to_vector();
610
611 EXPECT_EQ(set.size(), set2.size()) << "Set sizes differ";
612 for (size_t i = 0; i < std::min(set.size(), set2.size()); ++i)
613 EXPECT_EQ(set[i], set2[i]) << "Sets differ at position " << i;
614
615 for (auto el : _mesh.all_elements<HandleT>())
616 _mesh.status(el).set_deleted(false);
617 }
618
619 // Custom property
620 {
621 OpenMesh::PropertyManager<typename OpenMesh::PropHandle<HandleT>::template type<bool>> prop(false, _mesh);
622 auto set = get_random_set(4);
623 for (auto el : set)
624 prop[el] = true;
625
626 auto set2 = _mesh.elements<HandleT>().filtered(prop).to_vector();
627
628 EXPECT_EQ(set.size(), set2.size()) << "Set sizes differ";
629 for (size_t i = 0; i < std::min(set.size(), set2.size()); ++i)
630 EXPECT_EQ(set[i], set2[i]) << "Sets differ at position " << i;
631 }
632
633 // boundary
634 {
635 for (auto el : _mesh.elements<HandleT>().filtered(Boundary()))
636 EXPECT_TRUE(el.is_boundary());
637 int n_boundary1 = 0.0;
638 for (auto el : _mesh.elements<HandleT>())
639 if (el.is_boundary())
640 n_boundary1 += 1;
641 int n_boundary2 = _mesh.elements<HandleT>().count_if(Boundary());
642 EXPECT_EQ(n_boundary1, n_boundary2);
643 }
644}
645
646template <typename HandleT>
647void test_range_predicate_combinations(Mesh& _mesh)
648{
649 using namespace OpenMesh::Predicates;
650
651 auto n_elements = _mesh.n_elements<HandleT>();
652 auto get_random_set = [&](int n)
653 {
654 std::vector<HandleT> set;
655 for (int i = 0; i < n; ++i)
656 set.push_back(HandleT(rand() % n_elements));
657 std::sort(set.begin(), set.end());
658 set.erase(std::unique(set.begin(), set.end()), set.end());
659 return set;
660 };
661
662 // negation
663 {
664 auto set = get_random_set(4);
665 for (auto el : _mesh.elements<HandleT>())
666 _mesh.status(el).set_selected(false);
667 for (auto el : set)
668 _mesh.status(el).set_selected(true);
669
670 auto true_set = _mesh.elements<HandleT>().filtered(Selected()).to_vector();
671 auto false_set = _mesh.elements<HandleT>().filtered(!Selected()).to_vector();
672
673 std::vector<HandleT> intersection;
674 std::set_intersection(true_set.begin(), true_set.end(), false_set.begin(), false_set.end(), std::back_inserter(intersection));
675
676 EXPECT_TRUE(intersection.empty());
677 EXPECT_EQ(true_set.size() + false_set.size(), n_elements);
678
679 for (auto el : _mesh.elements<HandleT>())
680 _mesh.status(el).set_selected(false);
681 }
682
683 // conjunction
684 {
685 auto set1 = get_random_set(4);
686 auto set2 = get_random_set(4);
687 // make sure there is some overlap
688 {
689 auto set3 = get_random_set(3);
690 set1.insert(set1.end(), set3.begin(), set3.end());
691 set2.insert(set2.end(), set3.begin(), set3.end());
692 std::sort(set1.begin(), set1.end());
693 std::sort(set2.begin(), set2.end());
694 set1.erase(std::unique(set1.begin(), set1.end()), set1.end());
695 set2.erase(std::unique(set2.begin(), set2.end()), set2.end());
696 }
697
698 for (auto el : _mesh.elements<HandleT>())
699 _mesh.status(el).set_selected(false);
700 for (auto el : _mesh.elements<HandleT>())
701 _mesh.status(el).set_tagged(false);
702 for (auto el : set1)
703 _mesh.status(el).set_selected(true);
704 for (auto el : set2)
705 _mesh.status(el).set_tagged(true);
706
707 auto set = _mesh.elements<HandleT>().filtered(Selected() && Tagged()).to_vector();
708
709 std::vector<HandleT> intersection;
710 std::set_intersection(set1.begin(), set1.end(), set2.begin(), set2.end(), std::back_inserter(intersection));
711
712 EXPECT_EQ(intersection.size(), set.size());
713 for (size_t i = 0; i < std::min(intersection.size(), set.size()); ++i)
714 EXPECT_EQ(intersection[i], set[i]) << "Sets differ at position " << i;
715
716 for (auto el : _mesh.elements<HandleT>())
717 _mesh.status(el).set_selected(false);
718 for (auto el : _mesh.elements<HandleT>())
719 _mesh.status(el).set_tagged(false);
720 }
721
722 // Disjunction
723 {
724 auto set1 = get_random_set(4);
725 auto set2 = get_random_set(4);
726 for (auto el : _mesh.elements<HandleT>())
727 _mesh.status(el).set_selected(false);
728 for (auto el : _mesh.elements<HandleT>())
729 _mesh.status(el).set_tagged(false);
730 for (auto el : set1)
731 _mesh.status(el).set_selected(true);
732 for (auto el : set2)
733 _mesh.status(el).set_tagged(true);
734
735 auto set = _mesh.elements<HandleT>().filtered(Selected() || Tagged()).to_vector();
736
737 std::vector<HandleT> union_set;
738 std::set_union(set1.begin(), set1.end(), set2.begin(), set2.end(), std::back_inserter(union_set));
739
740 EXPECT_EQ(union_set.size(), set.size());
741 for (size_t i = 0; i < std::min(union_set.size(), set.size()); ++i)
742 EXPECT_EQ(union_set[i], set[i]) << "Sets differ at position " << i;
743
744 for (auto el : _mesh.elements<HandleT>())
745 _mesh.status(el).set_selected(false);
746 for (auto el : _mesh.elements<HandleT>())
747 _mesh.status(el).set_tagged(false);
748 }
749
750}
751
752template <typename HandleT>
753bool test_func(HandleT _h)
754{
755 return _h.idx() % 3 == 0;
756}
757
758template <typename HandleT>
759void test_make_predicate(Mesh& _mesh)
760{
761 using namespace OpenMesh::Predicates;
762
763 auto n_elements = _mesh.n_elements<HandleT>();
764 auto get_random_set = [&](int n)
765 {
766 std::vector<HandleT> set;
767 for (int i = 0; i < n; ++i)
768 set.push_back(HandleT(rand() % n_elements));
769 std::sort(set.begin(), set.end());
770 set.erase(std::unique(set.begin(), set.end()), set.end());
771 return set;
772 };
773
774 // custom property
775 {
776 OpenMesh::PropertyManager<typename OpenMesh::PropHandle<HandleT>::template type<bool>> prop(false, _mesh);
777 auto set1 = get_random_set(4);
778 auto set2 = get_random_set(4);
779 for (auto el : set1)
780 prop[el] = true;
781 for (auto el : _mesh.elements<HandleT>())
782 _mesh.status(el).set_selected(false);
783 for (auto el : set2)
784 _mesh.status(el).set_selected(true);
785
786 auto set = _mesh.elements<HandleT>().filtered(Selected() || make_predicate(prop)).to_vector();
787
788 std::vector<HandleT> union_set;
789 std::set_union(set1.begin(), set1.end(), set2.begin(), set2.end(), std::back_inserter(union_set));
790
791 EXPECT_EQ(union_set.size(), set.size());
792 for (size_t i = 0; i < std::min(union_set.size(), set.size()); ++i)
793 EXPECT_EQ(union_set[i], set[i]) << "Sets differ at position " << i;
794
795 for (auto el : _mesh.elements<HandleT>())
796 _mesh.status(el).set_selected(false);
797 for (auto el : _mesh.elements<HandleT>())
798 _mesh.status(el).set_tagged(false);
799 }
800
801 // lambda
802 {
803 OpenMesh::PropertyManager<typename OpenMesh::PropHandle<HandleT>::template type<bool>> prop(false, _mesh);
804 auto set1 = get_random_set(4);
805 auto set2 = get_random_set(4);
806 for (auto el : set1)
807 prop[el] = true;
808 for (auto el : _mesh.elements<HandleT>())
809 _mesh.status(el).set_selected(false);
810 for (auto el : set2)
811 _mesh.status(el).set_selected(true);
812
813 auto test = [&](HandleT h) { return prop(h); };
814
815 auto set = _mesh.elements<HandleT>().filtered(Selected() || make_predicate(test)).to_vector();
816
817 std::vector<HandleT> union_set;
818 std::set_union(set1.begin(), set1.end(), set2.begin(), set2.end(), std::back_inserter(union_set));
819
820 EXPECT_EQ(union_set.size(), set.size());
821 for (size_t i = 0; i < std::min(union_set.size(), set.size()); ++i)
822 EXPECT_EQ(union_set[i], set[i]) << "Sets differ at position " << i;
823
824 for (auto el : _mesh.elements<HandleT>())
825 _mesh.status(el).set_selected(false);
826 for (auto el : _mesh.elements<HandleT>())
827 _mesh.status(el).set_tagged(false);
828 }
829
830 // r value lambda
831 {
832 OpenMesh::PropertyManager<typename OpenMesh::PropHandle<HandleT>::template type<bool>> prop(false, _mesh);
833 auto set1 = get_random_set(4);
834 auto set2 = get_random_set(4);
835 for (auto el : set1)
836 prop[el] = true;
837 for (auto el : _mesh.elements<HandleT>())
838 _mesh.status(el).set_selected(false);
839 for (auto el : set2)
840 _mesh.status(el).set_selected(true);
841
842 auto set = _mesh.elements<HandleT>().filtered(Selected() || make_predicate([&](HandleT h) { return prop(h); })).to_vector();
843
844 std::vector<HandleT> union_set;
845 std::set_union(set1.begin(), set1.end(), set2.begin(), set2.end(), std::back_inserter(union_set));
846
847 EXPECT_EQ(union_set.size(), set.size());
848 for (size_t i = 0; i < std::min(union_set.size(), set.size()); ++i)
849 EXPECT_EQ(union_set[i], set[i]) << "Sets differ at position " << i;
850
851 for (auto el : _mesh.elements<HandleT>())
852 _mesh.status(el).set_selected(false);
853 for (auto el : _mesh.elements<HandleT>())
854 _mesh.status(el).set_tagged(false);
855 }
856
857 // function pointer
858 {
859 auto set1 = _mesh.elements<HandleT>().filtered([&](const HandleT& h) { return test_func(h); }).to_vector();
860 auto set2 = get_random_set(4);
861 for (auto el : _mesh.elements<HandleT>())
862 _mesh.status(el).set_selected(false);
863 for (auto el : set2)
864 _mesh.status(el).set_selected(true);
865
866 auto set = _mesh.elements<HandleT>().filtered(Selected() || make_predicate(test_func<HandleT>)).to_vector();
867
868 std::vector<HandleT> union_set;
869 std::set_union(set1.begin(), set1.end(), set2.begin(), set2.end(), std::back_inserter(union_set));
870
871 EXPECT_EQ(union_set.size(), set.size());
872 for (size_t i = 0; i < std::min(union_set.size(), set.size()); ++i)
873 EXPECT_EQ(union_set[i], set[i]) << "Sets differ at position " << i;
874
875 for (auto el : _mesh.elements<HandleT>())
876 _mesh.status(el).set_selected(false);
877 for (auto el : _mesh.elements<HandleT>())
878 _mesh.status(el).set_tagged(false);
879 }
880}
881
882TEST_F(OpenMeshSmartRanges, Predicate)
883{
884 using namespace OpenMesh;
885
886 mesh_.request_vertex_status();
887 mesh_.request_halfedge_status();
888 mesh_.request_edge_status();
889 mesh_.request_face_status();
890
891 mesh_.delete_face(FaceHandle(0)); // ensure there is a boundary
892 mesh_.garbage_collection();
893
894 test_range_predicates<VertexHandle>(mesh_);
895 test_range_predicates<HalfedgeHandle>(mesh_);
896 test_range_predicates<EdgeHandle>(mesh_);
897 test_range_predicates<FaceHandle>(mesh_);
898
899 test_range_predicate_combinations<VertexHandle>(mesh_);
900 test_range_predicate_combinations<HalfedgeHandle>(mesh_);
901 test_range_predicate_combinations<EdgeHandle>(mesh_);
902 test_range_predicate_combinations<FaceHandle>(mesh_);
903
904 test_make_predicate<VertexHandle>(mesh_);
905 test_make_predicate<HalfedgeHandle>(mesh_);
906 test_make_predicate<EdgeHandle>(mesh_);
907 test_make_predicate<FaceHandle>(mesh_);
908}
909
910struct MemberFunctionWrapperTestStruct
911{
912 MemberFunctionWrapperTestStruct(int _i)
913 :
914 i_(_i)
915 {
916 }
917
918 int get_i(const OpenMesh::SmartEdgeHandle& /*_eh*/) const
919 {
920 return i_;
921 }
922
923 bool id_divisible_by_2(const OpenMesh::SmartEdgeHandle& _eh) const
924 {
925 return _eh.idx() % 2 == 0;
926 }
927
928 int valence_times_i(const OpenMesh::SmartVertexHandle& vh)
929 {
930 return vh.edges().sum(OM_MFW(get_i));
931 }
932
933 int i_;
934};
935
936TEST_F(OpenMeshSmartRanges, MemberFunctionFunctor)
937{
938 using namespace OpenMesh::Predicates;
939
940 EXPECT_TRUE(mesh_.n_vertices() > 0) << "Mesh has no vertices";
941 EXPECT_TRUE(mesh_.n_edges() > 0) << "Mesh has no edges";
942
943 int factor = 3;
944 MemberFunctionWrapperTestStruct test_object(factor);
945
946 // Test using a MemberFunctionWrapper as Functorstatic_cast<int>(
947 EXPECT_EQ(static_cast<int>(mesh_.n_edges() / 2), mesh_.edges().count_if(make_member_function_wrapper(test_object, &MemberFunctionWrapperTestStruct::id_divisible_by_2)));
948
949
950 // Test using a MemberFunctionWrapper as Functor that is created using the convenience macro from inside the struct
951 for (auto vh : mesh_.vertices())
952 EXPECT_EQ(test_object.valence_times_i(vh), static_cast<int>(vh.valence()) * factor);
953
954 factor = 4;
955 test_object.i_ = factor;
956 for (auto vh : mesh_.vertices())
957 {
958 EXPECT_EQ(test_object.valence_times_i(vh), static_cast<int>(vh.valence() * factor));
959 }
960
961
962
963}
964
965}
OpenMesh::BaseHandle::idx
int idx() const
Get the underlying index of this handle.
Definition Handles.hh:69
OpenMesh::PolyMeshT::calc_face_centroid
void calc_face_centroid(FaceHandle _fh, Point &_pt) const
calculates the average of the vertices defining _fh
Definition PolyMeshT.hh:299
OpenMesh::PolyMeshT::VertexHandle
Kernel::VertexHandle VertexHandle
Handle for referencing the corresponding item.
Definition PolyMeshT.hh:136
OpenMesh::PolyMeshT::make_smart
auto make_smart(H const &h) const -> typename SmartHandle< H >::type const
Create a smart handle from a regular handle.
Definition PolyMeshT.hh:201
OpenMesh::PolyMeshT::add_vertex
SmartVertexHandle add_vertex(const Point _p)
Definition PolyMeshT.hh:255
OpenMesh::PolyMeshT::Point
Kernel::Point Point
Coordinate type.
Definition PolyMeshT.hh:112
OpenMesh::TriMesh_ArrayKernelT< CustomTraits >
OpenMesh::VectorT::min
Scalar min() const
return the minimal component
Definition Vector11T.hh:532
OpenMesh::FaceHandle
Handle for a face entity.
Definition Handles.hh:142
OpenMesh::SmartRangeT::sum
auto sum(Functor &&f) const -> typename std::decay< decltype(f(std::declval< HandleT >()))>::type
Computes the sum of elements.
Definition SmartRange.hh:96
OpenMesh::SmartVertexHandle
Smart version of VertexHandle contains a pointer to the corresponding mesh and allows easier access t...
Definition SmartHandles.hh:110
OpenMesh::SmartVertexHandle::valence
uint valence() const
Returns valence of the vertex.
Definition SmartHandles.hh:373
OpenMesh::SmartVertexHandle::edges
PolyConnectivity::ConstVertexEdgeRange edges() const
Returns a range of edges incident to the vertex (PolyConnectivity::ve_range())
Definition PolyConnectivity_inline_impl.hh:975
OpenMesh::VertexHandle
Handle for a vertex entity.
Definition Handles.hh:121