Developer Documentation
unittests_basics.cc
1 #include "unittests_common.hh"
2 
3 #include <OpenVolumeMesh/Attribs/StatusAttrib.hh>
4 #include <OpenVolumeMesh/Attribs/NormalAttrib.hh>
5 #include <OpenVolumeMesh/Attribs/ColorAttrib.hh>
6 
7 using namespace OpenVolumeMesh;
8 using namespace Geometry;
9 
10 /*
11  * ====================================================================
12  * Define tests below
13  * ====================================================================
14  */
15 
16 TEST_F(PolyhedralMeshBase, CreateSimpleMesh) {
17 
18  /*
19  * Add vertices
20  */
21 
22  VertexHandle v0 = mesh_.add_vertex(Vec3d(-1.0, -1.0, -1.0));
23  VertexHandle v1 = mesh_.add_vertex(Vec3d( 1.0, -1.0, -1.0));
24  VertexHandle v2 = mesh_.add_vertex(Vec3d( 1.0, 1.0, -1.0));
25  VertexHandle v3 = mesh_.add_vertex(Vec3d(-1.0, 1.0, -1.0));
26  VertexHandle v4 = mesh_.add_vertex(Vec3d(-1.0, -1.0, 1.0));
27  VertexHandle v5 = mesh_.add_vertex(Vec3d( 1.0, -1.0, 1.0));
28  VertexHandle v6 = mesh_.add_vertex(Vec3d( 1.0, 1.0, 1.0));
29  VertexHandle v7 = mesh_.add_vertex(Vec3d(-1.0, 1.0, 1.0));
30 
31  EXPECT_EQ(8u, mesh_.n_vertices()) << "The number of vertices is not correct!";
32 
33  /*
34  * Add faces
35  */
36 
37  std::vector<VertexHandle> fvertices;
38 
39  fvertices.push_back(v3);
40  fvertices.push_back(v2);
41  fvertices.push_back(v1);
42  fvertices.push_back(v0);
43 
44  FaceHandle fh0 = mesh_.add_face(fvertices);
45 
46  fvertices.clear();
47 
48  fvertices.push_back(v4);
49  fvertices.push_back(v5);
50  fvertices.push_back(v6);
51  fvertices.push_back(v7);
52 
53  FaceHandle fh1 = mesh_.add_face(fvertices);
54 
55  fvertices.clear();
56 
57  fvertices.push_back(v0);
58  fvertices.push_back(v4);
59  fvertices.push_back(v7);
60  fvertices.push_back(v3);
61 
62  FaceHandle fh2 = mesh_.add_face(fvertices);
63 
64  fvertices.clear();
65 
66  fvertices.push_back(v1);
67  fvertices.push_back(v2);
68  fvertices.push_back(v6);
69  fvertices.push_back(v5);
70 
71  FaceHandle fh3 = mesh_.add_face(fvertices);
72 
73  fvertices.clear();
74 
75  fvertices.push_back(v7);
76  fvertices.push_back(v6);
77  fvertices.push_back(v2);
78  fvertices.push_back(v3);
79 
80  FaceHandle fh4 = mesh_.add_face(fvertices);
81 
82  fvertices.clear();
83 
84  fvertices.push_back(v0);
85  fvertices.push_back(v1);
86  fvertices.push_back(v5);
87  fvertices.push_back(v4);
88 
89  FaceHandle fh5 = mesh_.add_face(fvertices);
90 
91  EXPECT_EQ(12u, mesh_.n_edges()) << "The number of edges is not correct!";
92  EXPECT_EQ(6u, mesh_.n_faces()) << "The number of faces is not correct!";
93 
94  /*
95  * Add cell
96  */
97 
98  std::vector<HalfFaceHandle> chfaces;
99 
100  chfaces.push_back(mesh_.halfface_handle(fh0, 0));
101  chfaces.push_back(mesh_.halfface_handle(fh1, 0));
102  chfaces.push_back(mesh_.halfface_handle(fh2, 0));
103  chfaces.push_back(mesh_.halfface_handle(fh3, 0));
104  chfaces.push_back(mesh_.halfface_handle(fh4, 0));
105  chfaces.push_back(mesh_.halfface_handle(fh5, 0));
106 
107  mesh_.add_cell(chfaces);
108 
109  EXPECT_EQ(1u, mesh_.n_cells()) << "The number of cells is not correct!";
110 }
111 
112 //===========================================================================
113 
114 TEST_F(PolyhedralMeshBase, CreateSimpleMeshWithoutCells) {
115 
116  Vec3d p1(0.0, 0.0, 0.0);
117  Vec3d p2(1.0, 0.0, 0.0);
118  Vec3d p3(1.0, 1.0, 0.0);
119  Vec3d p4(0.0, 1.0, 0.0);
120 
121  Vec3d p5(0.0, 0.0, 1.0);
122  Vec3d p6(1.0, 0.0, 1.0);
123  Vec3d p7(1.0, 1.0, 1.0);
124  Vec3d p8(0.0, 1.0, 1.0);
125 
126  VertexHandle v1 = mesh_.add_vertex(p1);
127  VertexHandle v2 = mesh_.add_vertex(p2);
128  VertexHandle v3 = mesh_.add_vertex(p3);
129  VertexHandle v4 = mesh_.add_vertex(p4);
130 
131  VertexHandle v5 = mesh_.add_vertex(p5);
132  VertexHandle v6 = mesh_.add_vertex(p6);
133  VertexHandle v7 = mesh_.add_vertex(p7);
134  VertexHandle v8 = mesh_.add_vertex(p8);
135 
136  EXPECT_HANDLE_EQ(VertexHandle(0), v1);
137  EXPECT_HANDLE_EQ(VertexHandle(1), v2);
138  EXPECT_HANDLE_EQ(VertexHandle(2), v3);
139  EXPECT_HANDLE_EQ(VertexHandle(3), v4);
140  EXPECT_HANDLE_EQ(VertexHandle(4), v5);
141  EXPECT_HANDLE_EQ(VertexHandle(5), v6);
142  EXPECT_HANDLE_EQ(VertexHandle(6), v7);
143  EXPECT_HANDLE_EQ(VertexHandle(7), v8);
144 
145  EdgeHandle e1 = mesh_.add_edge(v1, v2);
146  EdgeHandle e2 = mesh_.add_edge(v2, v3);
147  EdgeHandle e3 = mesh_.add_edge(v3, v4);
148  EdgeHandle e4 = mesh_.add_edge(v4, v1);
149 
150  EdgeHandle e5 = mesh_.add_edge(v5, v6);
151  EdgeHandle e6 = mesh_.add_edge(v6, v7);
152  EdgeHandle e7 = mesh_.add_edge(v7, v8);
153  EdgeHandle e8 = mesh_.add_edge(v8, v5);
154 
155  EXPECT_HANDLE_EQ(VertexHandle(0), e1);
156  EXPECT_HANDLE_EQ(VertexHandle(1), e2);
157  EXPECT_HANDLE_EQ(VertexHandle(2), e3);
158  EXPECT_HANDLE_EQ(VertexHandle(3), e4);
159  EXPECT_HANDLE_EQ(VertexHandle(4), e5);
160  EXPECT_HANDLE_EQ(VertexHandle(5), e6);
161  EXPECT_HANDLE_EQ(VertexHandle(6), e7);
162  EXPECT_HANDLE_EQ(VertexHandle(7), e8);
163 
164  // Get halfedges
165  HalfEdgeHandle h1 = mesh_.halfedge_handle(e1, 0u);
166  HalfEdgeHandle h2 = mesh_.halfedge_handle(e2, 0u);
167  HalfEdgeHandle h3 = mesh_.halfedge_handle(e3, 0u);
168  HalfEdgeHandle h4 = mesh_.halfedge_handle(e4, 0u);
169 
170  HalfEdgeHandle h5 = mesh_.halfedge_handle(e5, 0u);
171  HalfEdgeHandle h6 = mesh_.halfedge_handle(e6, 0u);
172  HalfEdgeHandle h7 = mesh_.halfedge_handle(e7, 0u);
173  HalfEdgeHandle h8 = mesh_.halfedge_handle(e8, 0u);
174 
175  EXPECT_HANDLE_EQ(v1, mesh_.halfedge(h1).from_vertex());
176  EXPECT_HANDLE_EQ(v2, mesh_.halfedge(h1).to_vertex());
177  EXPECT_HANDLE_EQ(v2, mesh_.halfedge(h2).from_vertex());
178  EXPECT_HANDLE_EQ(v3, mesh_.halfedge(h2).to_vertex());
179  EXPECT_HANDLE_EQ(v3, mesh_.halfedge(h3).from_vertex());
180  EXPECT_HANDLE_EQ(v4, mesh_.halfedge(h3).to_vertex());
181  EXPECT_HANDLE_EQ(v4, mesh_.halfedge(h4).from_vertex());
182  EXPECT_HANDLE_EQ(v1, mesh_.halfedge(h4).to_vertex());
183 
184  EXPECT_HANDLE_EQ(v5, mesh_.halfedge(h5).from_vertex());
185  EXPECT_HANDLE_EQ(v6, mesh_.halfedge(h5).to_vertex());
186  EXPECT_HANDLE_EQ(v6, mesh_.halfedge(h6).from_vertex());
187  EXPECT_HANDLE_EQ(v7, mesh_.halfedge(h6).to_vertex());
188  EXPECT_HANDLE_EQ(v7, mesh_.halfedge(h7).from_vertex());
189  EXPECT_HANDLE_EQ(v8, mesh_.halfedge(h7).to_vertex());
190  EXPECT_HANDLE_EQ(v8, mesh_.halfedge(h8).from_vertex());
191  EXPECT_HANDLE_EQ(v5, mesh_.halfedge(h8).to_vertex());
192 
193  // Check opposite halfedges
194  EXPECT_HANDLE_EQ(v2, mesh_.opposite_halfedge(h1).from_vertex());
195  EXPECT_HANDLE_EQ(v1, mesh_.opposite_halfedge(h1).to_vertex());
196  EXPECT_HANDLE_EQ(v3, mesh_.opposite_halfedge(h2).from_vertex());
197  EXPECT_HANDLE_EQ(v2, mesh_.opposite_halfedge(h2).to_vertex());
198  EXPECT_HANDLE_EQ(v4, mesh_.opposite_halfedge(h3).from_vertex());
199  EXPECT_HANDLE_EQ(v3, mesh_.opposite_halfedge(h3).to_vertex());
200  EXPECT_HANDLE_EQ(v1, mesh_.opposite_halfedge(h4).from_vertex());
201  EXPECT_HANDLE_EQ(v4, mesh_.opposite_halfedge(h4).to_vertex());
202 
203  EXPECT_HANDLE_EQ(v6, mesh_.opposite_halfedge(h5).from_vertex());
204  EXPECT_HANDLE_EQ(v5, mesh_.opposite_halfedge(h5).to_vertex());
205  EXPECT_HANDLE_EQ(v7, mesh_.opposite_halfedge(h6).from_vertex());
206  EXPECT_HANDLE_EQ(v6, mesh_.opposite_halfedge(h6).to_vertex());
207  EXPECT_HANDLE_EQ(v8, mesh_.opposite_halfedge(h7).from_vertex());
208  EXPECT_HANDLE_EQ(v7, mesh_.opposite_halfedge(h7).to_vertex());
209  EXPECT_HANDLE_EQ(v5, mesh_.opposite_halfedge(h8).from_vertex());
210  EXPECT_HANDLE_EQ(v8, mesh_.opposite_halfedge(h8).to_vertex());
211 
212  // Add a face via vertices
213  std::vector<VertexHandle> vertices;
214  vertices.push_back(v2); vertices.push_back(v6);
215  vertices.push_back(v7); vertices.push_back(v3);
216  FaceHandle f1 = mesh_.add_face(vertices);
217 
218  EXPECT_HANDLE_EQ(FaceHandle(0), f1);
219 
220  // Get halfedges of face
221  std::vector<HalfEdgeHandle> halfedges = mesh_.face(f1).halfedges();
222 
223  std::vector<HalfEdgeHandle>::iterator it = halfedges.begin();
224 
225  EXPECT_HANDLE_EQ(EdgeHandle(8), mesh_.edge_handle(*it)); ++it;
226  EXPECT_HANDLE_EQ(EdgeHandle(5), mesh_.edge_handle(*it)); ++it;
227  EXPECT_HANDLE_EQ(EdgeHandle(9), mesh_.edge_handle(*it)); ++it;
228  EXPECT_HANDLE_EQ(EdgeHandle(1), mesh_.edge_handle(*it));
229 
230  // Add invalid face
231  halfedges.clear();
232  halfedges.push_back(mesh_.halfedge_handle(e1, 0)); halfedges.push_back(mesh_.halfedge_handle(e2, 0));
233  halfedges.push_back(mesh_.halfedge_handle(e7, 0)); halfedges.push_back(mesh_.halfedge_handle(e4, 0));
234 
235  FaceHandle fI = mesh_.add_face(halfedges, true);
236 
237  EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidFaceHandle, fI);
238 
239  // Now add valid face via edges
240  halfedges.clear();
241  halfedges.push_back(mesh_.halfedge_handle(e1, 0)); halfedges.push_back(mesh_.halfedge_handle(e2, 0));
242  halfedges.push_back(mesh_.halfedge_handle(e3, 0)); halfedges.push_back(mesh_.halfedge_handle(e4, 0));
243 
244  FaceHandle f2 = mesh_.add_face(halfedges);
245 
246  EXPECT_HANDLE_EQ(FaceHandle(1), f2);
247 
248  // Get halfedges of face
249  halfedges = mesh_.face(f2).halfedges();
250  int handle = 0;
251  for(it = halfedges.begin(); it != halfedges.end(); ++it) {
252  EXPECT_HANDLE_EQ(EdgeHandle(handle), mesh_.edge_handle(*it)); handle++;
253  }
254 }
255 
256 TEST_F(PolyhedralMeshBase, TopologyCheckPass) {
257 
258  // Add eight vertices
259  VertexHandle v0 = mesh_.add_vertex(Vec3d(-1.0, 0.0, 0.0));
260  VertexHandle v1 = mesh_.add_vertex(Vec3d( 0.0, 0.0, 1.0));
261  VertexHandle v2 = mesh_.add_vertex(Vec3d( 1.0, 0.0, 0.0));
262  VertexHandle v3 = mesh_.add_vertex(Vec3d( 0.0, 1.0, 0.0));
263 
264  std::vector<VertexHandle> vertices;
265 
266  // Add faces
267  vertices.push_back(v0); vertices.push_back(v1);vertices.push_back(v3);
268  FaceHandle f0 = mesh_.add_face(vertices);
269 
270  vertices.clear();
271  vertices.push_back(v1); vertices.push_back(v2);vertices.push_back(v3);
272  FaceHandle f1 = mesh_.add_face(vertices);
273 
274  vertices.clear();
275  vertices.push_back(v0); vertices.push_back(v1);vertices.push_back(v2);
276  FaceHandle f2 = mesh_.add_face(vertices);
277 
278  vertices.clear();
279  vertices.push_back(v0); vertices.push_back(v3);vertices.push_back(v2);
280  FaceHandle f3 = mesh_.add_face(vertices);
281 
282  std::vector<HalfFaceHandle> halffaces;
283 
284  // Add first tetrahedron
285  halffaces.push_back(mesh_.halfface_handle(f0, 1));
286  halffaces.push_back(mesh_.halfface_handle(f1, 1));
287  halffaces.push_back(mesh_.halfface_handle(f2, 0));
288  halffaces.push_back(mesh_.halfface_handle(f3, 1));
289  EXPECT_HANDLE_NE(PolyhedralMesh::InvalidCellHandle, mesh_.add_cell(halffaces));
290 }
291 
292 TEST_F(PolyhedralMeshBase, TopologyCheckFail) {
293 
294  // Add eight vertices
295  VertexHandle v0 = mesh_.add_vertex(Vec3d(-1.0, 0.0, 0.0));
296  VertexHandle v1 = mesh_.add_vertex(Vec3d( 0.0, 0.0, 1.0));
297  VertexHandle v2 = mesh_.add_vertex(Vec3d( 1.0, 0.0, 0.0));
298  VertexHandle v3 = mesh_.add_vertex(Vec3d( 0.0, 1.0, 0.0));
299 
300  std::vector<VertexHandle> vertices;
301 
302  // Add faces
303  vertices.push_back(v0); vertices.push_back(v1);vertices.push_back(v3);
304  FaceHandle f0 = mesh_.add_face(vertices);
305 
306  vertices.clear();
307  vertices.push_back(v1); vertices.push_back(v2);vertices.push_back(v3);
308  FaceHandle f1 = mesh_.add_face(vertices);
309 
310  vertices.clear();
311  vertices.push_back(v0); vertices.push_back(v1);vertices.push_back(v2);
312  FaceHandle f2 = mesh_.add_face(vertices);
313 
314  vertices.clear();
315  vertices.push_back(v0); vertices.push_back(v3);vertices.push_back(v2);
316  FaceHandle f3 = mesh_.add_face(vertices);
317 
318  std::vector<HalfFaceHandle> halffaces;
319 
320  // Add first tetrahedron
321  halffaces.push_back(mesh_.halfface_handle(f0, 1));
322  halffaces.push_back(mesh_.halfface_handle(f1, 1));
323  halffaces.push_back(mesh_.halfface_handle(f2, 0));
324  halffaces.push_back(mesh_.halfface_handle(f3, 0));
325  EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidCellHandle, mesh_.add_cell(halffaces, true));
326 }
327 
328 TEST_F(HexahedralMeshBase, TopologyCheckPass) {
329 
330  VertexHandle v0 = mesh_.add_vertex(Vec3d(-1.0, -1.0, -1.0));
331  VertexHandle v1 = mesh_.add_vertex(Vec3d( 1.0, -1.0, -1.0));
332  VertexHandle v2 = mesh_.add_vertex(Vec3d( 1.0, 1.0, -1.0));
333  VertexHandle v3 = mesh_.add_vertex(Vec3d(-1.0, 1.0, -1.0));
334  VertexHandle v4 = mesh_.add_vertex(Vec3d(-1.0, -1.0, 1.0));
335  VertexHandle v5 = mesh_.add_vertex(Vec3d( 1.0, -1.0, 1.0));
336  VertexHandle v6 = mesh_.add_vertex(Vec3d( 1.0, 1.0, 1.0));
337  VertexHandle v7 = mesh_.add_vertex(Vec3d(-1.0, 1.0, 1.0));
338 
339  std::vector<VertexHandle> fvertices;
340 
341  fvertices.push_back(v3);
342  fvertices.push_back(v2);
343  fvertices.push_back(v1);
344  fvertices.push_back(v0);
345 
346  FaceHandle fh0 = mesh_.add_face(fvertices);
347 
348  fvertices.clear();
349 
350  fvertices.push_back(v4);
351  fvertices.push_back(v5);
352  fvertices.push_back(v6);
353  fvertices.push_back(v7);
354 
355  FaceHandle fh1 = mesh_.add_face(fvertices);
356 
357  fvertices.clear();
358 
359  fvertices.push_back(v0);
360  fvertices.push_back(v4);
361  fvertices.push_back(v7);
362  fvertices.push_back(v3);
363 
364  FaceHandle fh2 = mesh_.add_face(fvertices);
365 
366  fvertices.clear();
367 
368  fvertices.push_back(v1);
369  fvertices.push_back(v2);
370  fvertices.push_back(v6);
371  fvertices.push_back(v5);
372 
373  FaceHandle fh3 = mesh_.add_face(fvertices);
374 
375  fvertices.clear();
376 
377  fvertices.push_back(v7);
378  fvertices.push_back(v6);
379  fvertices.push_back(v2);
380  fvertices.push_back(v3);
381 
382  FaceHandle fh4 = mesh_.add_face(fvertices);
383 
384  fvertices.clear();
385 
386  fvertices.push_back(v0);
387  fvertices.push_back(v1);
388  fvertices.push_back(v5);
389  fvertices.push_back(v4);
390 
391  FaceHandle fh5 = mesh_.add_face(fvertices);
392 
393  std::vector<HalfFaceHandle> chfaces;
394 
395  chfaces.push_back(mesh_.halfface_handle(fh0, 0));
396  chfaces.push_back(mesh_.halfface_handle(fh1, 0));
397  chfaces.push_back(mesh_.halfface_handle(fh2, 0));
398  chfaces.push_back(mesh_.halfface_handle(fh3, 0));
399  chfaces.push_back(mesh_.halfface_handle(fh4, 0));
400  chfaces.push_back(mesh_.halfface_handle(fh5, 0));
401 
402  EXPECT_HANDLE_NE(HexahedralMesh::InvalidCellHandle, mesh_.add_cell(chfaces, true));
403 }
404 
405 TEST_F(HexahedralMeshBase, TopologyCheckFail) {
406 
407  VertexHandle v0 = mesh_.add_vertex(Vec3d(-1.0, -1.0, -1.0));
408  VertexHandle v1 = mesh_.add_vertex(Vec3d( 1.0, -1.0, -1.0));
409  VertexHandle v2 = mesh_.add_vertex(Vec3d( 1.0, 1.0, -1.0));
410  VertexHandle v3 = mesh_.add_vertex(Vec3d(-1.0, 1.0, -1.0));
411  VertexHandle v4 = mesh_.add_vertex(Vec3d(-1.0, -1.0, 1.0));
412  VertexHandle v5 = mesh_.add_vertex(Vec3d( 1.0, -1.0, 1.0));
413  VertexHandle v6 = mesh_.add_vertex(Vec3d( 1.0, 1.0, 1.0));
414  VertexHandle v7 = mesh_.add_vertex(Vec3d(-1.0, 1.0, 1.0));
415 
416  std::vector<VertexHandle> fvertices;
417 
418  fvertices.push_back(v3);
419  fvertices.push_back(v2);
420  fvertices.push_back(v1);
421  fvertices.push_back(v0);
422 
423  FaceHandle fh0 = mesh_.add_face(fvertices);
424 
425  fvertices.clear();
426 
427  fvertices.push_back(v4);
428  fvertices.push_back(v5);
429  fvertices.push_back(v6);
430  fvertices.push_back(v7);
431 
432  FaceHandle fh1 = mesh_.add_face(fvertices);
433 
434  fvertices.clear();
435 
436  fvertices.push_back(v0);
437  fvertices.push_back(v4);
438  fvertices.push_back(v7);
439  fvertices.push_back(v3);
440 
441  FaceHandle fh2 = mesh_.add_face(fvertices);
442 
443  fvertices.clear();
444 
445  fvertices.push_back(v1);
446  fvertices.push_back(v2);
447  fvertices.push_back(v6);
448  fvertices.push_back(v5);
449 
450  FaceHandle fh3 = mesh_.add_face(fvertices);
451 
452  fvertices.clear();
453 
454  fvertices.push_back(v7);
455  fvertices.push_back(v6);
456  fvertices.push_back(v2);
457  fvertices.push_back(v3);
458 
459  FaceHandle fh4 = mesh_.add_face(fvertices);
460 
461  fvertices.clear();
462 
463  fvertices.push_back(v0);
464  fvertices.push_back(v1);
465  fvertices.push_back(v5);
466  fvertices.push_back(v4);
467 
468  FaceHandle fh5 = mesh_.add_face(fvertices);
469 
470  std::vector<HalfFaceHandle> chfaces;
471 
472  chfaces.push_back(mesh_.halfface_handle(fh0, 0));
473  chfaces.push_back(mesh_.halfface_handle(fh1, 1));
474  chfaces.push_back(mesh_.halfface_handle(fh2, 0));
475  chfaces.push_back(mesh_.halfface_handle(fh3, 0));
476  chfaces.push_back(mesh_.halfface_handle(fh4, 0));
477  chfaces.push_back(mesh_.halfface_handle(fh5, 0));
478 
479  EXPECT_HANDLE_EQ(HexahedralMesh::InvalidCellHandle, mesh_.add_cell(chfaces, true));
480 }
481 
482 TEST_F(PolyhedralMeshBase, VolumeMeshGenus) {
483 
484  generatePolyhedralMesh(mesh_);
485 
486  EXPECT_EQ(0, mesh_.genus());
487 }
488 
489 TEST_F(PolyhedralMeshBase, VolumeMeshConnectivity) {
490 
491  generatePolyhedralMesh(mesh_);
492 
493  // Add invalid cell
494  std::vector<HalfFaceHandle> hfaces;
495  hfaces.push_back(HalfFaceHandle(1)); hfaces.push_back(HalfFaceHandle(5));
496  hfaces.push_back(HalfFaceHandle(7)); hfaces.push_back(HalfFaceHandle(9));
497  hfaces.push_back(HalfFaceHandle(10)); hfaces.push_back(HalfFaceHandle(21));
498  CellHandle i_cell = mesh_.add_cell(hfaces, true);
499 
500  EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidCellHandle, i_cell);
501 
502  EXPECT_HANDLE_EQ(CellHandle(0), mesh_.incident_cell(HalfFaceHandle(1)));
503  EXPECT_HANDLE_EQ(CellHandle(0), mesh_.incident_cell(HalfFaceHandle(2)));
504  EXPECT_HANDLE_EQ(CellHandle(0), mesh_.incident_cell(HalfFaceHandle(5)));
505  EXPECT_HANDLE_EQ(CellHandle(0), mesh_.incident_cell(HalfFaceHandle(7)));
506  EXPECT_HANDLE_EQ(CellHandle(0), mesh_.incident_cell(HalfFaceHandle(9)));
507  EXPECT_HANDLE_EQ(CellHandle(0), mesh_.incident_cell(HalfFaceHandle(10)));
508 
509  EXPECT_HANDLE_EQ(CellHandle(1), mesh_.incident_cell(HalfFaceHandle(3)));
510  EXPECT_HANDLE_EQ(CellHandle(1), mesh_.incident_cell(HalfFaceHandle(12)));
511  EXPECT_HANDLE_EQ(CellHandle(1), mesh_.incident_cell(HalfFaceHandle(15)));
512  EXPECT_HANDLE_EQ(CellHandle(1), mesh_.incident_cell(HalfFaceHandle(17)));
513  EXPECT_HANDLE_EQ(CellHandle(1), mesh_.incident_cell(HalfFaceHandle(19)));
514  EXPECT_HANDLE_EQ(CellHandle(1), mesh_.incident_cell(HalfFaceHandle(20)));
515 
516  // Test adjacency function
517  HalfFaceHandle ad_hf1 = mesh_.adjacent_halfface_in_cell(HalfFaceHandle(1), HalfEdgeHandle(3));
518  // Should be halfface 5
519  EXPECT_HANDLE_EQ(HalfFaceHandle(5), ad_hf1);
520 
521  HalfFaceHandle ad_hf2 = mesh_.adjacent_halfface_in_cell(HalfFaceHandle(1), HalfEdgeHandle(7));
522  // Should be halfface 7
523  EXPECT_HANDLE_EQ(HalfFaceHandle(7), ad_hf2);
524 
525  HalfFaceHandle ad_hf3 = mesh_.adjacent_halfface_in_cell(HalfFaceHandle(5), HalfEdgeHandle(24));
526  // Should be invalid
527  EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidHalfFaceHandle, ad_hf3);
528 
529  HalfFaceHandle ad_hf4 = mesh_.adjacent_halfface_in_cell(HalfFaceHandle(12), HalfEdgeHandle(24));
530  // Should be invalid
531  EXPECT_HANDLE_EQ(HalfFaceHandle(20), ad_hf4);
532 
533  HalfFaceHandle ad_hf5 = mesh_.adjacent_halfface_in_cell(HalfFaceHandle(0), HalfEdgeHandle(0));
534  // Should be invalid
535  EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidHalfFaceHandle, ad_hf5);
536 
537  EXPECT_EQ(12u, mesh_.n_vertices());
538  EXPECT_EQ(20u, mesh_.n_edges());
539  EXPECT_EQ(2u, mesh_.n_cells());
540  EXPECT_EQ(11u, mesh_.n_faces());
541 }
542 
543 TEST_F(PolyhedralMeshBase, VolumeMeshNormals) {
544 
545  generatePolyhedralMesh(mesh_);
546 
547  NormalAttrib<GeometricPolyhedralMeshV3d> normals(mesh_);
548 
549  Vec3d n_x(1.0, 0.0, 0.0);
550  Vec3d n_y(0.0, 1.0, 0.0);
551  Vec3d n_z(0.0, 0.0, 1.0);
552 
553  normals.update_face_normals();
554 
555  // Should be positive z-axis
556  Vec3d& n = normals[FaceHandle(0)];
557  EXPECT_DOUBLE_EQ(n_z[0], n[0]);
558  EXPECT_DOUBLE_EQ(n_z[1], n[1]);
559  EXPECT_DOUBLE_EQ(n_z[2], n[2]);
560 
561  n = normals[HalfFaceHandle(1)];
562  EXPECT_DOUBLE_EQ(-n_z[0], n[0]);
563  EXPECT_DOUBLE_EQ(-n_z[1], n[1]);
564  EXPECT_DOUBLE_EQ(-n_z[2], n[2]);
565 
566  // Should be negative x-axis
567  n = normals[FaceHandle(2)];
568  EXPECT_DOUBLE_EQ(-n_x[0], n[0]);
569  EXPECT_DOUBLE_EQ(-n_x[1], n[1]);
570  EXPECT_DOUBLE_EQ(-n_x[2], n[2]);
571 
572  n = normals[HalfFaceHandle(4)];
573  EXPECT_DOUBLE_EQ(-n_x[0], n[0]);
574  EXPECT_DOUBLE_EQ(-n_x[1], n[1]);
575  EXPECT_DOUBLE_EQ(-n_x[2], n[2]);
576 
577  n = normals[HalfFaceHandle(5)];
578  EXPECT_DOUBLE_EQ(n_x[0], n[0]);
579  EXPECT_DOUBLE_EQ(n_x[1], n[1]);
580  EXPECT_DOUBLE_EQ(n_x[2], n[2]);
581 
582  // Should be negative y-axis
583  n = normals[FaceHandle(4)];
584  EXPECT_DOUBLE_EQ(-n_y[0], n[0]);
585  EXPECT_DOUBLE_EQ(-n_y[1], n[1]);
586  EXPECT_DOUBLE_EQ(-n_y[2], n[2]);
587 
588  n = normals[HalfFaceHandle(9)];
589  EXPECT_DOUBLE_EQ(n_y[0], n[0]);
590  EXPECT_DOUBLE_EQ(n_y[1], n[1]);
591  EXPECT_DOUBLE_EQ(n_y[2], n[2]);
592 
593  // Should be positive y-axis
594  n = normals[FaceHandle(5)];
595  EXPECT_DOUBLE_EQ(-n_y[0], n[0]);
596  EXPECT_DOUBLE_EQ(-n_y[1], n[1]);
597  EXPECT_DOUBLE_EQ(-n_y[2], n[2]);
598 }
599 
600 TEST_F(PolyhedralMeshBase, PolyhedralMeshStatusTest) {
601 
602  generatePolyhedralMesh(mesh_);
603 
604  // Request status
605  StatusAttrib status(mesh_);
606 
607  // Select a few faces
608  status[FaceHandle(1)].set_tagged(true);
609  status[FaceHandle(4)].set_tagged(true);
610 
611  status[HalfFaceHandle(21)].set_deleted(true);
612  status[HalfFaceHandle(0)].set_deleted(true);
613 
614  status[VertexHandle(3)].set_selected(true);
615  status[VertexHandle(8)].set_selected(true);
616 
617  EXPECT_TRUE(status[FaceHandle(1)].tagged());
618  EXPECT_TRUE(status[FaceHandle(4)].tagged());
619  EXPECT_FALSE(status[FaceHandle(7)].tagged());
620  EXPECT_FALSE(status[FaceHandle(2)].tagged());
621 
622  EXPECT_TRUE(status[HalfFaceHandle(21)].deleted());
623  EXPECT_TRUE(status[HalfFaceHandle(0)].deleted());
624  EXPECT_FALSE(status[HalfFaceHandle(13)].deleted());
625  EXPECT_FALSE(status[HalfFaceHandle(20)].deleted());
626 
627  EXPECT_TRUE(status[VertexHandle(3)].selected());
628  EXPECT_TRUE(status[VertexHandle(8)].selected());
629  EXPECT_FALSE(status[VertexHandle(1)].selected());
630  EXPECT_FALSE(status[VertexHandle(9)].selected());
631 }
632 
633 TEST_F(PolyhedralMeshBase, PolyhedralMeshColorTest) {
634 
635  generatePolyhedralMesh(mesh_);
636 
637  using OpenVolumeMesh::Geometry::Vec4f;
638 
639  // Request colors
640  ColorAttrib<Vec4f> colors(mesh_);
641 
642  colors[VertexHandle(7)] = Vec4f(1.0f, 1.0f, 0.0f, 1.0f);
643  colors[EdgeHandle(6)] = Vec4f(1.0f, 1.0f, 0.0f, 1.0f);
644  colors[HalfEdgeHandle(5)] = Vec4f(1.0f, 1.0f, 0.0f, 1.0f);
645  colors[FaceHandle(4)] = Vec4f(1.0f, 1.0f, 0.0f, 1.0f);
646  colors[HalfFaceHandle(3)] = Vec4f(1.0f, 1.0f, 0.0f, 1.0f);
647  colors[CellHandle(1)] = Vec4f(1.0f, 1.0f, 0.0f, 1.0f);
648 
649  EXPECT_FLOAT_EQ(1.0f, colors[VertexHandle(7)][0]);
650  EXPECT_FLOAT_EQ(1.0f, colors[VertexHandle(7)][1]);
651  EXPECT_FLOAT_EQ(0.0f, colors[VertexHandle(7)][2]);
652  EXPECT_FLOAT_EQ(1.0f, colors[VertexHandle(7)][3]);
653  EXPECT_FLOAT_EQ(1.0f, colors[EdgeHandle(6)][0]);
654  EXPECT_FLOAT_EQ(1.0f, colors[EdgeHandle(6)][1]);
655  EXPECT_FLOAT_EQ(0.0f, colors[EdgeHandle(6)][2]);
656  EXPECT_FLOAT_EQ(1.0f, colors[EdgeHandle(6)][3]);
657  EXPECT_FLOAT_EQ(1.0f, colors[HalfEdgeHandle(5)][0]);
658  EXPECT_FLOAT_EQ(1.0f, colors[HalfEdgeHandle(5)][1]);
659  EXPECT_FLOAT_EQ(0.0f, colors[HalfEdgeHandle(5)][2]);
660  EXPECT_FLOAT_EQ(1.0f, colors[HalfEdgeHandle(5)][3]);
661  EXPECT_FLOAT_EQ(1.0f, colors[FaceHandle(4)][0]);
662  EXPECT_FLOAT_EQ(1.0f, colors[FaceHandle(4)][1]);
663  EXPECT_FLOAT_EQ(0.0f, colors[FaceHandle(4)][2]);
664  EXPECT_FLOAT_EQ(1.0f, colors[FaceHandle(4)][3]);
665  EXPECT_FLOAT_EQ(1.0f, colors[HalfFaceHandle(3)][0]);
666  EXPECT_FLOAT_EQ(1.0f, colors[HalfFaceHandle(3)][1]);
667  EXPECT_FLOAT_EQ(0.0f, colors[HalfFaceHandle(3)][2]);
668  EXPECT_FLOAT_EQ(1.0f, colors[HalfFaceHandle(3)][3]);
669  EXPECT_FLOAT_EQ(1.0f, colors[CellHandle(1)][0]);
670  EXPECT_FLOAT_EQ(1.0f, colors[CellHandle(1)][1]);
671  EXPECT_FLOAT_EQ(0.0f, colors[CellHandle(1)][2]);
672  EXPECT_FLOAT_EQ(1.0f, colors[CellHandle(1)][3]);
673 }
674 
675 TEST_F(PolyhedralMeshBase, PolyhedralMeshProperties) {
676 
677  generatePolyhedralMesh(mesh_);
678 
679  VertexPropertyT<Vec3d> vp = mesh_.request_vertex_property<Vec3d>("VProp");
680 
681  EXPECT_TRUE(mesh_.vertex_property_exists<Vec3d>("VProp"));
682 
683  for(VertexIter v_it = mesh_.v_iter(); v_it.valid(); ++v_it) {
684  vp[*v_it] = Vec3d(1.0, 0.0, 0.0);
685  }
686 
687  for(VertexIter v_it = mesh_.v_iter(); v_it.valid(); ++v_it) {
688  Vec3d t;
689  t = vp[*v_it];
690  EXPECT_DOUBLE_EQ(1.0, t[0]);
691  EXPECT_DOUBLE_EQ(0.0, t[1]);
692  EXPECT_DOUBLE_EQ(0.0, t[2]);
693  }
694 
695  VertexHandle vh = mesh_.add_vertex(Vec3d(3.0,3.0,3.0));
696  vp[vh] = Vec3d(0.0);
697  Vec3d p = vp[vh];
698  EXPECT_DOUBLE_EQ(0.0, p[0]);
699  EXPECT_DOUBLE_EQ(0.0, p[1]);
700  EXPECT_DOUBLE_EQ(0.0, p[2]);
701 
702  EdgePropertyT<unsigned int> ep = mesh_.request_edge_property<unsigned int>("EProp");
703 
704  EXPECT_TRUE(mesh_.edge_property_exists<unsigned int>("EProp"));
705 
706  unsigned int i = 0;
707  for(EdgeIter e_it = mesh_.e_iter(); e_it.valid(); ++e_it) {
708  ep[*e_it] = i++;
709  }
710 
711  i = 0;
712  for(EdgeIter e_it = mesh_.e_iter(); e_it.valid(); ++e_it) {
713  EXPECT_EQ(i++, ep[*e_it]);
714  }
715 
716  HalfFacePropertyT<bool> hfp = mesh_.request_halfface_property<bool>("HFProp");
717 
718  EXPECT_TRUE(mesh_.halfface_property_exists<bool>("HFProp"));
719 
720  bool b = false;
721  for(HalfFaceIter hf_it = mesh_.hf_iter(); hf_it.valid(); ++hf_it) {
722  hfp[*hf_it] = b;
723  b = !b;
724  }
725 
726  b = false;
727  for(HalfFaceIter hf_it = mesh_.hf_iter(); hf_it.valid(); ++hf_it) {
728  EXPECT_EQ(b, hfp[*hf_it]);
729  b = !b;
730  }
731 
732  // Request halfface properties
733  CellPropertyT<std::string> cp = mesh_.request_cell_property<std::string>("CProp");
734 
735  EXPECT_TRUE(mesh_.cell_property_exists<std::string>("CProp"));
736 
737  for(CellIter c_it = mesh_.c_iter(); c_it.valid(); ++c_it) {
738  cp[*c_it] = std::string("MyTestString");
739  }
740 
741  for(CellIter c_it = mesh_.c_iter(); c_it.valid(); ++c_it) {
742  EXPECT_EQ(std::string("MyTestString"), cp[*c_it]);
743  }
744 
745  EXPECT_FALSE(mesh_.halfedge_property_exists<unsigned char>("HEProp"));
746  EXPECT_FALSE(mesh_.vertex_property_exists<size_t>(""));
747 }
748 
749 TEST_F(PolyhedralMeshBase, STLCompliance) {
750 
751  generatePolyhedralMesh(mesh_);
752 
753  Print p;
754  p.mute(true);
755  //std::cerr << "Vertices:" << std::endl;
756  std::for_each(mesh_.vertices_begin(), mesh_.vertices_end(), p);
757  //std::cerr << "Edges:" << std::endl;
758  std::for_each(mesh_.edges_begin(), mesh_.edges_end(), p);
759  //std::cerr << "HalfEdges:" << std::endl;
760  std::for_each(mesh_.halfedges_begin(), mesh_.halfedges_end(), p);
761  //std::cerr << "Faces:" << std::endl;
762  std::for_each(mesh_.faces_begin(), mesh_.faces_end(), p);
763  //std::cerr << "HalfFaces:" << std::endl;
764  std::for_each(mesh_.halffaces_begin(), mesh_.halffaces_end(), p);
765  //std::cerr << "Cells:" << std::endl;
766  std::for_each(mesh_.cells_begin(), mesh_.cells_end(), p);
767 }
768 
769 TEST_F(PolyhedralMeshBase, DeleteCellBUTest1) {
770 
771  generatePolyhedralMesh(mesh_);
772 
773  std::vector<HalfFaceHandle> hfs = mesh_.cell(CellHandle(0)).halffaces();
774 
775  mesh_.delete_cell(CellHandle(0));
776 
777  for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin(),
778  hf_end = hfs.end(); hf_it != hf_end; ++hf_it) {
779  EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidCellHandle, mesh_.incident_cell(*hf_it));
780  }
781 }
782 
783 TEST_F(PolyhedralMeshBase, DeleteFaceBUTest1) {
784 
785  generatePolyhedralMesh(mesh_);
786 
787  std::vector<HalfEdgeHandle> hes = mesh_.face(FaceHandle(0)).halfedges();
788 
789  std::vector<HalfFaceHandle> ihfs[4];
790 
791  for(size_t i = 0; i < 4; ++i) {
792  for(HalfEdgeHalfFaceIter hehf_it = mesh_.hehf_iter(hes[i]); hehf_it.valid(); ++hehf_it) {
793 
794  HalfFaceHandle hfh = *hehf_it;
795 
796  if(mesh_.face_handle(hfh) == FaceHandle(0)) continue;
797 
798  hfh.idx((hfh.idx() > mesh_.halfface_handle(FaceHandle(0), 1).idx() ? hfh.idx() - 2 : hfh.idx()));
799 
800  ihfs[i].push_back(hfh);
801  }
802  }
803 
804  mesh_.delete_face(FaceHandle(0));
805 
806  std::set<HalfFaceHandle> nihfs[4];
807  for(size_t i = 0; i < 4; ++i) {
808  for(HalfEdgeHalfFaceIter hehf_it = mesh_.hehf_iter(hes[i]); hehf_it.valid(); ++hehf_it) {
809  nihfs[i].insert(*hehf_it);
810  }
811  }
812 
813  EXPECT_EQ(ihfs[0].size(), nihfs[0].size());
814  EXPECT_EQ(ihfs[1].size(), nihfs[1].size());
815  EXPECT_EQ(ihfs[2].size(), nihfs[2].size());
816  EXPECT_EQ(ihfs[3].size(), nihfs[3].size());
817 
818  for(size_t i = 0; i < 4; ++i) {
819  for(std::vector<HalfFaceHandle>::const_iterator hf_it = ihfs[i].begin(),
820  hf_end = ihfs[i].end(); hf_it != hf_end; ++hf_it) {
821  EXPECT_GT(nihfs[i].count(*hf_it), 0u);
822  }
823  }
824 }
825 
826 TEST_F(PolyhedralMeshBase, DeleteEdgeBUTest1) {
827 
828  generatePolyhedralMesh(mesh_);
829 
830  VertexHandle vh0 = mesh_.edge(EdgeHandle(0)).from_vertex();
831  VertexHandle vh1 = mesh_.edge(EdgeHandle(0)).to_vertex();
832 
833  std::vector<HalfEdgeHandle> hes0;
834  for(VertexOHalfEdgeIter voh_it = mesh_.voh_iter(vh0); voh_it.valid(); ++voh_it) {
835  if(mesh_.edge_handle(*voh_it) == EdgeHandle(0)) continue;
836  hes0.push_back(HalfEdgeHandle(voh_it->idx() > mesh_.halfedge_handle(EdgeHandle(0), 1).idx() ? voh_it->idx() - 2 : voh_it->idx()));
837  }
838 
839  std::vector<HalfEdgeHandle> hes1;
840  for(VertexOHalfEdgeIter voh_it = mesh_.voh_iter(vh1); voh_it.valid(); ++voh_it) {
841  if(mesh_.edge_handle(*voh_it) == EdgeHandle(0)) continue;
842  hes1.push_back(HalfEdgeHandle(voh_it->idx() > mesh_.halfedge_handle(EdgeHandle(0), 1).idx() ? voh_it->idx() - 2 : voh_it->idx()));
843  }
844 
845  mesh_.delete_edge(EdgeHandle(0));
846 
847  std::set<HalfEdgeHandle> nhes0;
848  for(VertexOHalfEdgeIter voh_it = mesh_.voh_iter(vh0); voh_it.valid(); ++voh_it) {
849  nhes0.insert(*voh_it);
850  }
851 
852  std::set<HalfEdgeHandle> nhes1;
853  for(VertexOHalfEdgeIter voh_it = mesh_.voh_iter(vh1); voh_it.valid(); ++voh_it) {
854  nhes1.insert(*voh_it);
855  }
856 
857  EXPECT_EQ(hes0.size(), nhes0.size());
858  EXPECT_EQ(hes1.size(), nhes1.size());
859 
860  for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes0.begin(),
861  he_end = hes0.end(); he_it != he_end; ++he_it) {
862  EXPECT_GT(nhes0.count(*he_it), 0u);
863  }
864 
865  for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes1.begin(),
866  he_end = hes1.end(); he_it != he_end; ++he_it) {
867  EXPECT_GT(nhes1.count(*he_it), 0u);
868  }
869 }
870 
871 TEST_F(PolyhedralMeshBase, DeleteCellBUTest1noBU) {
872 
873  generatePolyhedralMesh(mesh_);
874 
875  mesh_.enable_bottom_up_incidences(false);
876 
877  std::vector<HalfFaceHandle> hfs = mesh_.cell(CellHandle(0)).halffaces();
878 
879  mesh_.delete_cell(CellHandle(0));
880 
881  for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin(),
882  hf_end = hfs.end(); hf_it != hf_end; ++hf_it) {
883  EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidCellHandle, mesh_.incident_cell(*hf_it));
884  }
885 }
886 
887 TEST_F(PolyhedralMeshBase, DeleteFaceBUTest1noBU) {
888 
889  generatePolyhedralMesh(mesh_);
890 
891  mesh_.enable_bottom_up_incidences(false);
892 
893  std::vector<HalfEdgeHandle> hes = mesh_.face(FaceHandle(0)).halfedges();
894 
895  std::vector<HalfFaceHandle> ihfs[4];
896 
897  for(size_t i = 0; i < 4; ++i) {
898  for(HalfFaceIter hf_it = mesh_.halffaces_begin(), hf_end = mesh_.halffaces_end(); hf_it != hf_end; ++hf_it) {
899 
900  std::vector<HalfEdgeHandle> t_hes = mesh_.halfface(*hf_it).halfedges();
901  bool found = false;
902  for(std::vector<HalfEdgeHandle>::const_iterator the_it = t_hes.begin(),
903  the_end = t_hes.end(); the_it != the_end; ++the_it) {
904  if(std::find(hes.begin(), hes.end(), *the_it) != hes.end()) {
905  found = true;
906  break;
907  }
908  }
909  if(!found) continue;
910 
911  HalfFaceHandle hfh = *hf_it;
912 
913  if(mesh_.face_handle(hfh) == FaceHandle(0)) continue;
914 
915  hfh.idx((hfh.idx() > mesh_.halfface_handle(FaceHandle(0), 1).idx() ? hfh.idx() - 2 : hfh.idx()));
916 
917  ihfs[i].push_back(hfh);
918  }
919  }
920 
921  mesh_.delete_face(FaceHandle(0));
922 
923  std::set<HalfFaceHandle> nihfs[4];
924  for(size_t i = 0; i < 4; ++i) {
925  for(HalfFaceIter hf_it = mesh_.halffaces_begin(), hf_end = mesh_.halffaces_end(); hf_it != hf_end; ++hf_it) {
926 
927  std::vector<HalfEdgeHandle> t_hes = mesh_.halfface(*hf_it).halfedges();
928  bool found = false;
929  for(std::vector<HalfEdgeHandle>::const_iterator the_it = t_hes.begin(),
930  the_end = t_hes.end(); the_it != the_end; ++the_it) {
931  if(std::find(hes.begin(), hes.end(), *the_it) != hes.end()) {
932  found = true;
933  break;
934  }
935  }
936  if(!found) continue;
937 
938  nihfs[i].insert(*hf_it);
939  }
940  }
941 
942  EXPECT_EQ(ihfs[0].size(), nihfs[0].size());
943  EXPECT_EQ(ihfs[1].size(), nihfs[1].size());
944  EXPECT_EQ(ihfs[2].size(), nihfs[2].size());
945  EXPECT_EQ(ihfs[3].size(), nihfs[3].size());
946 
947  for(size_t i = 0; i < 4; ++i) {
948  for(std::vector<HalfFaceHandle>::const_iterator hf_it = ihfs[i].begin(),
949  hf_end = ihfs[i].end(); hf_it != hf_end; ++hf_it) {
950  EXPECT_GT(nihfs[i].count(*hf_it), 0u);
951  }
952  }
953 }
954 
955 TEST_F(PolyhedralMeshBase, DeleteEdgeBUTest1noBU) {
956 
957  generatePolyhedralMesh(mesh_);
958 
959  mesh_.enable_bottom_up_incidences(false);
960 
961  VertexHandle vh0 = mesh_.edge(EdgeHandle(0)).from_vertex();
962  VertexHandle vh1 = mesh_.edge(EdgeHandle(0)).to_vertex();
963 
964  std::vector<HalfEdgeHandle> hes0;
965  for(HalfEdgeIter he_it = mesh_.halfedges_begin(), he_end = mesh_.halfedges_end(); he_it != he_end; ++he_it) {
966 
967  if(mesh_.halfedge(*he_it).from_vertex() == vh0) {
968 
969  if(mesh_.edge_handle(*he_it) == EdgeHandle(0)) continue;
970  hes0.push_back(HalfEdgeHandle(he_it->idx() > mesh_.halfedge_handle(EdgeHandle(0), 1).idx() ? he_it->idx() - 2 : he_it->idx()));
971  }
972  }
973 
974  std::vector<HalfEdgeHandle> hes1;
975  for(HalfEdgeIter he_it = mesh_.halfedges_begin(), he_end = mesh_.halfedges_end(); he_it != he_end; ++he_it) {
976 
977  if(mesh_.halfedge(*he_it).from_vertex() == vh1) {
978 
979  if(mesh_.edge_handle(*he_it) == EdgeHandle(0)) continue;
980  hes1.push_back(HalfEdgeHandle(he_it->idx() > mesh_.halfedge_handle(EdgeHandle(0), 1).idx() ? he_it->idx() - 2 : he_it->idx()));
981  }
982  }
983 
984  mesh_.delete_edge(EdgeHandle(0));
985 
986  std::set<HalfEdgeHandle> nhes0;
987  for(HalfEdgeIter he_it = mesh_.halfedges_begin(), he_end = mesh_.halfedges_end(); he_it != he_end; ++he_it) {
988  if(mesh_.halfedge(*he_it).from_vertex() == vh0) {
989  nhes0.insert(*he_it);
990  }
991  }
992 
993  std::set<HalfEdgeHandle> nhes1;
994  for(HalfEdgeIter he_it = mesh_.halfedges_begin(), he_end = mesh_.halfedges_end(); he_it != he_end; ++he_it) {
995  if(mesh_.halfedge(*he_it).from_vertex() == vh1) {
996  nhes1.insert(*he_it);
997  }
998  }
999 
1000  EXPECT_EQ(hes0.size(), nhes0.size());
1001  EXPECT_EQ(hes1.size(), nhes1.size());
1002 
1003  for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes0.begin(),
1004  he_end = hes0.end(); he_it != he_end; ++he_it) {
1005  EXPECT_GT(nhes0.count(*he_it), 0u);
1006  }
1007 
1008  for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes1.begin(),
1009  he_end = hes1.end(); he_it != he_end; ++he_it) {
1010  EXPECT_GT(nhes1.count(*he_it), 0u);
1011  }
1012 }
1013 
1014 TEST_F(PolyhedralMeshBase, DeleteLastVertexTestBU) {
1015 
1016  generatePolyhedralMesh(mesh_);
1017 
1018  for(OpenVolumeMesh::HalfEdgeIter he_it = mesh_.halfedges_begin();
1019  he_it != mesh_.halfedges_end(); ++he_it) {
1020 
1021  const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1022  const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1023 
1024  EXPECT_LE(fromVertex.idx(), 11);
1025  EXPECT_LE(toVertex.idx(), 11);
1026  }
1027 
1028  mesh_.delete_vertex(VertexHandle(11));
1029 
1030  for(OpenVolumeMesh::HalfEdgeIter he_it = mesh_.halfedges_begin();
1031  he_it != mesh_.halfedges_end(); ++he_it) {
1032 
1033  const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1034  const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1035 
1036  EXPECT_LE(fromVertex.idx(), 10);
1037  EXPECT_LE(toVertex.idx(), 10);
1038  }
1039 }
1040 
1041 TEST_F(PolyhedralMeshBase, DeleteLastEdgeTestBU) {
1042 
1043  generatePolyhedralMesh(mesh_);
1044 
1045  for(OpenVolumeMesh::HalfFaceIter f_it = mesh_.halffaces_begin();
1046  f_it != mesh_.halffaces_end(); ++f_it) {
1047 
1048  std::vector<HalfEdgeHandle> hes = mesh_.halfface(*f_it).halfedges();
1049  for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes.begin();
1050  he_it != hes.end(); ++he_it) {
1051  EXPECT_LE(he_it->idx(), 39);
1052  }
1053  }
1054 
1055  mesh_.delete_edge(EdgeHandle(19));
1056 
1057  for(OpenVolumeMesh::HalfFaceIter f_it = mesh_.halffaces_begin();
1058  f_it != mesh_.halffaces_end(); ++f_it) {
1059 
1060  std::vector<HalfEdgeHandle> hes = mesh_.halfface(*f_it).halfedges();
1061  for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes.begin();
1062  he_it != hes.end(); ++he_it) {
1063  EXPECT_LE(he_it->idx(), 37);
1064  }
1065  }
1066 }
1067 
1068 TEST_F(PolyhedralMeshBase, DeleteLastFaceTestBU) {
1069 
1070  generatePolyhedralMesh(mesh_);
1071 
1072  for(OpenVolumeMesh::CellIter c_it = mesh_.cells_begin();
1073  c_it != mesh_.cells_end(); ++c_it) {
1074 
1075  std::vector<HalfFaceHandle> hfs = mesh_.cell(*c_it).halffaces();
1076  for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin();
1077  hf_it != hfs.end(); ++hf_it) {
1078  EXPECT_LE(hf_it->idx(), 21);
1079  EXPECT_LE(mesh_.opposite_halfface_handle(*hf_it).idx(), 21);
1080  }
1081  }
1082 
1083  mesh_.delete_face(FaceHandle(10));
1084 
1085  for(OpenVolumeMesh::CellIter c_it = mesh_.cells_begin();
1086  c_it != mesh_.cells_end(); ++c_it) {
1087 
1088  std::vector<HalfFaceHandle> hfs = mesh_.cell(*c_it).halffaces();
1089  for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin();
1090  hf_it != hfs.end(); ++hf_it) {
1091  EXPECT_LE(hf_it->idx(), 19);
1092  EXPECT_LE(mesh_.opposite_halfface_handle(*hf_it).idx(), 19);
1093  }
1094  }
1095 }
1096 
1097 TEST_F(PolyhedralMeshBase, DeleteLastVertexTestNoBU) {
1098 
1099  generatePolyhedralMesh(mesh_);
1100 
1101  mesh_.enable_bottom_up_incidences(false);
1102 
1103  for(OpenVolumeMesh::HalfEdgeIter he_it = mesh_.halfedges_begin();
1104  he_it != mesh_.halfedges_end(); ++he_it) {
1105 
1106  const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1107  const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1108 
1109  EXPECT_LE(fromVertex.idx(), 11);
1110  EXPECT_LE(toVertex.idx(), 11);
1111  }
1112 
1113  mesh_.delete_vertex(VertexHandle(11));
1114 
1115  for(OpenVolumeMesh::HalfEdgeIter he_it = mesh_.halfedges_begin();
1116  he_it != mesh_.halfedges_end(); ++he_it) {
1117 
1118  const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1119  const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1120 
1121  EXPECT_LE(fromVertex.idx(), 10);
1122  EXPECT_LE(toVertex.idx(), 10);
1123  }
1124 }
1125 
1126 TEST_F(PolyhedralMeshBase, DeleteLastEdgeTestNoBU) {
1127 
1128  generatePolyhedralMesh(mesh_);
1129 
1130  mesh_.enable_bottom_up_incidences(false);
1131 
1132  for(OpenVolumeMesh::HalfFaceIter f_it = mesh_.halffaces_begin();
1133  f_it != mesh_.halffaces_end(); ++f_it) {
1134 
1135  std::vector<HalfEdgeHandle> hes = mesh_.halfface(*f_it).halfedges();
1136  for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes.begin();
1137  he_it != hes.end(); ++he_it) {
1138  EXPECT_LE(he_it->idx(), 39);
1139  }
1140  }
1141 
1142  mesh_.delete_edge(EdgeHandle(19));
1143 
1144  for(OpenVolumeMesh::HalfFaceIter f_it = mesh_.halffaces_begin();
1145  f_it != mesh_.halffaces_end(); ++f_it) {
1146 
1147  std::vector<HalfEdgeHandle> hes = mesh_.halfface(*f_it).halfedges();
1148  for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes.begin();
1149  he_it != hes.end(); ++he_it) {
1150  EXPECT_LE(he_it->idx(), 37);
1151  }
1152  }
1153 }
1154 
1155 TEST_F(PolyhedralMeshBase, DeleteLastFaceTestNoBU) {
1156 
1157  generatePolyhedralMesh(mesh_);
1158 
1159  mesh_.enable_bottom_up_incidences(false);
1160 
1161  for(OpenVolumeMesh::CellIter c_it = mesh_.cells_begin();
1162  c_it != mesh_.cells_end(); ++c_it) {
1163 
1164  std::vector<HalfFaceHandle> hfs = mesh_.cell(*c_it).halffaces();
1165  for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin();
1166  hf_it != hfs.end(); ++hf_it) {
1167  EXPECT_LE(hf_it->idx(), 21);
1168  EXPECT_LE(mesh_.opposite_halfface_handle(*hf_it).idx(), 21);
1169  }
1170  }
1171 
1172  mesh_.delete_face(FaceHandle(10));
1173 
1174  for(OpenVolumeMesh::CellIter c_it = mesh_.cells_begin();
1175  c_it != mesh_.cells_end(); ++c_it) {
1176 
1177  std::vector<HalfFaceHandle> hfs = mesh_.cell(*c_it).halffaces();
1178  for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin();
1179  hf_it != hfs.end(); ++hf_it) {
1180  EXPECT_LE(hf_it->idx(), 19);
1181  EXPECT_LE(mesh_.opposite_halfface_handle(*hf_it).idx(), 19);
1182  }
1183  }
1184 }
1185 
1186 /*
1187  * Hexahedral mesh tests
1188  */
1189 
1190 TEST_F(HexahedralMeshBase, SimpleHexMeshNavigation) {
1191 
1192  generateHexahedralMesh(mesh_);
1193 
1194  EXPECT_EQ(12u, mesh_.n_vertices());
1195  EXPECT_EQ(20u, mesh_.n_edges());
1196  EXPECT_EQ(11u, mesh_.n_faces());
1197  EXPECT_EQ(2u, mesh_.n_cells());
1198 
1199  EXPECT_HANDLE_EQ(HalfFaceHandle(1), mesh_.xfront_halfface(CellHandle(0)));
1200  EXPECT_HANDLE_EQ(HalfFaceHandle(2), mesh_.xback_halfface(CellHandle(0)));
1201  EXPECT_HANDLE_EQ(HalfFaceHandle(5), mesh_.yfront_halfface(CellHandle(0)));
1202  EXPECT_HANDLE_EQ(HalfFaceHandle(6), mesh_.yback_halfface(CellHandle(0)));
1203  EXPECT_HANDLE_EQ(HalfFaceHandle(8), mesh_.zfront_halfface(CellHandle(0)));
1204  EXPECT_HANDLE_EQ(HalfFaceHandle(11), mesh_.zback_halfface(CellHandle(0)));
1205 
1206  EXPECT_HANDLE_EQ(HalfFaceHandle(12), mesh_.opposite_halfface_handle_in_cell(
1207  HalfFaceHandle(3), CellHandle(1)));
1208 
1209  EXPECT_HANDLE_EQ(HalfFaceHandle(20), mesh_.adjacent_halfface_on_sheet(
1210  HalfFaceHandle(9), HalfEdgeHandle(12)));
1211  EXPECT_HANDLE_EQ(HalfFaceHandle(21), mesh_.adjacent_halfface_on_sheet(
1212  HalfFaceHandle(8), HalfEdgeHandle(12)));
1213 
1214  HexahedralMesh::CellSheetCellIter csc_it = mesh_.csc_iter(CellHandle(0), HexahedralMesh::YF);
1215  EXPECT_HANDLE_EQ(CellHandle(1), *csc_it);
1216 
1217  HexahedralMesh::HalfFaceSheetHalfFaceIter hfshf_it = mesh_.hfshf_iter(HalfFaceHandle(5));
1218  EXPECT_HANDLE_EQ(HalfFaceHandle(15), *hfshf_it);
1219  hfshf_it = mesh_.hfshf_iter(HalfFaceHandle(6));
1220  EXPECT_HANDLE_EQ(HalfFaceHandle(16), *hfshf_it);
1221 }
1222 
1223 TEST_F(HexahedralMeshBase, BottomUpIncidenceUpdate1) {
1224 
1225  generateHexahedralMesh(mesh_);
1226 
1227  EXPECT_EQ(12u, mesh_.n_vertices());
1228  EXPECT_EQ(20u, mesh_.n_edges());
1229  EXPECT_EQ(11u, mesh_.n_faces());
1230  EXPECT_EQ(2u, mesh_.n_cells());
1231 
1232  mesh_.delete_vertex(VertexHandle(0));
1233 
1234  EXPECT_EQ(11u, mesh_.n_vertices());
1235  EXPECT_EQ(17u, mesh_.n_edges());
1236  EXPECT_EQ(8u, mesh_.n_faces());
1237  EXPECT_EQ(1u, mesh_.n_cells());
1238 
1239  HexVertexIter hv_it = mesh_.hv_iter(CellHandle(0));
1240 
1241  EXPECT_EQ(3, hv_it->idx()); ++hv_it;
1242  EXPECT_EQ(4, hv_it->idx()); ++hv_it;
1243  EXPECT_EQ(5, hv_it->idx()); ++hv_it;
1244  EXPECT_EQ(6, hv_it->idx()); ++hv_it;
1245  EXPECT_EQ(7, hv_it->idx()); ++hv_it;
1246  EXPECT_EQ(10, hv_it->idx()); ++hv_it;
1247  EXPECT_EQ(9, hv_it->idx()); ++hv_it;
1248  EXPECT_EQ(8, hv_it->idx());
1249 }
1250 
1251 TEST_F(HexahedralMeshBase, GarbageCollectionTest1) {
1252 
1253  generateHexahedralMesh(mesh_);
1254 
1255  EXPECT_EQ(12u, mesh_.n_vertices());
1256  EXPECT_EQ(20u, mesh_.n_edges());
1257  EXPECT_EQ(11u, mesh_.n_faces());
1258  EXPECT_EQ(2u, mesh_.n_cells());
1259 
1260  StatusAttrib status(mesh_);
1261 
1262  HexVertexIter hv_it = mesh_.hv_iter(CellHandle(1));
1263 
1264  EXPECT_EQ(4, hv_it->idx()); ++hv_it;
1265  EXPECT_EQ(5, hv_it->idx()); ++hv_it;
1266  EXPECT_EQ(6, hv_it->idx()); ++hv_it;
1267  EXPECT_EQ(7, hv_it->idx()); ++hv_it;
1268  EXPECT_EQ(8, hv_it->idx()); ++hv_it;
1269  EXPECT_EQ(11, hv_it->idx()); ++hv_it;
1270  EXPECT_EQ(10, hv_it->idx()); ++hv_it;
1271  EXPECT_EQ(9, hv_it->idx());
1272 
1273  status[VertexHandle(0)].set_deleted(true);
1274 
1275  status.garbage_collection(false);
1276 
1277  EXPECT_EQ(1u, mesh_.n_cells());
1278  EXPECT_EQ(11u, mesh_.n_vertices());
1279  EXPECT_EQ(17u, mesh_.n_edges());
1280  EXPECT_EQ(8u, mesh_.n_faces());
1281 
1282  hv_it = mesh_.hv_iter(CellHandle(0));
1283 
1284  EXPECT_EQ(3, hv_it->idx()); ++hv_it;
1285  EXPECT_EQ(4, hv_it->idx()); ++hv_it;
1286  EXPECT_EQ(5, hv_it->idx()); ++hv_it;
1287  EXPECT_EQ(6, hv_it->idx()); ++hv_it;
1288  EXPECT_EQ(7, hv_it->idx()); ++hv_it;
1289  EXPECT_EQ(10, hv_it->idx()); ++hv_it;
1290  EXPECT_EQ(9, hv_it->idx()); ++hv_it;
1291  EXPECT_EQ(8, hv_it->idx());
1292 
1293  status.garbage_collection(true);
1294 
1295  EXPECT_EQ(1u, mesh_.n_cells());
1296  EXPECT_EQ(8u, mesh_.n_vertices());
1297  EXPECT_EQ(12u, mesh_.n_edges());
1298  EXPECT_EQ(6u, mesh_.n_faces());
1299 
1300  hv_it = mesh_.hv_iter(CellHandle(0));
1301 
1302  EXPECT_EQ(0, hv_it->idx()); ++hv_it;
1303  EXPECT_EQ(1, hv_it->idx()); ++hv_it;
1304  EXPECT_EQ(2, hv_it->idx()); ++hv_it;
1305  EXPECT_EQ(3, hv_it->idx()); ++hv_it;
1306  EXPECT_EQ(4, hv_it->idx()); ++hv_it;
1307  EXPECT_EQ(7, hv_it->idx()); ++hv_it;
1308  EXPECT_EQ(6, hv_it->idx()); ++hv_it;
1309  EXPECT_EQ(5, hv_it->idx());
1310 }
1311 
1312 TEST_F(HexahedralMeshBase, GarbageCollectionTest2) {
1313 
1314  generateHexahedralMesh(mesh_);
1315 
1316  StatusAttrib status(mesh_);
1317 
1318  status[VertexHandle(0)].set_deleted(true);
1319 
1320  status.garbage_collection(false);
1321 
1322  status.garbage_collection(false);
1323 
1324  EXPECT_EQ(1u, mesh_.n_cells());
1325  EXPECT_EQ(11u, mesh_.n_vertices());
1326  EXPECT_EQ(17u, mesh_.n_edges());
1327  EXPECT_EQ(8u, mesh_.n_faces());
1328 }
1329 
1330 TEST_F(HexahedralMeshBase, GarbageCollectionTest3) {
1331 
1332  generateHexahedralMesh(mesh_);
1333 
1334  StatusAttrib status(mesh_);
1335 
1336  status[EdgeHandle(0)].set_deleted(true);
1337 
1338  status.garbage_collection(false);
1339 
1340  EXPECT_EQ(1u, mesh_.n_cells());
1341  EXPECT_EQ(12u, mesh_.n_vertices());
1342  EXPECT_EQ(19u, mesh_.n_edges());
1343  EXPECT_EQ(9u, mesh_.n_faces());
1344 }
1345 
1346 TEST_F(HexahedralMeshBase, GarbageCollectionTest4) {
1347 
1348  generateHexahedralMesh(mesh_);
1349 
1350  StatusAttrib status(mesh_);
1351 
1352  status[EdgeHandle(5)].set_deleted(true);
1353 
1354  status.garbage_collection(false);
1355 
1356  EXPECT_EQ(0u, mesh_.n_cells());
1357  EXPECT_EQ(12u, mesh_.n_vertices());
1358  EXPECT_EQ(19u, mesh_.n_edges());
1359  EXPECT_EQ(8u, mesh_.n_faces());
1360 }
1361 
1362 TEST_F(HexahedralMeshBase, GarbageCollectionTest5) {
1363 
1364  generateHexahedralMesh(mesh_);
1365 
1366  StatusAttrib status(mesh_);
1367 
1368  status[EdgeHandle(0)].set_deleted(true);
1369  status[EdgeHandle(1)].set_deleted(true);
1370  status[EdgeHandle(2)].set_deleted(true);
1371 
1372  status.garbage_collection(true);
1373 
1374  EXPECT_EQ(1u, mesh_.n_cells());
1375  EXPECT_EQ(8u, mesh_.n_vertices());
1376  EXPECT_EQ(12u, mesh_.n_edges());
1377  EXPECT_EQ(6u, mesh_.n_faces());
1378 }
1379 
1380 TEST_F(HexahedralMeshBase, GarbageCollectionTestManifoldness1) {
1381 
1382  generateHexahedralMesh(mesh_);
1383 
1384  StatusAttrib status(mesh_);
1385 
1386  status[VertexHandle(0)].set_deleted(true);
1387 
1388  status.garbage_collection(true);
1389 
1390  EXPECT_EQ(1u, mesh_.n_cells());
1391  EXPECT_EQ(6u, mesh_.n_faces());
1392  EXPECT_EQ(12u, mesh_.n_edges());
1393  EXPECT_EQ(8u, mesh_.n_vertices());
1394 }
1395 
1396 TEST_F(HexahedralMeshBase, GarbageCollectionTestManifoldness2) {
1397 
1398  generateHexahedralMesh(mesh_);
1399 
1400  StatusAttrib status(mesh_);
1401 
1402  status[EdgeHandle(0)].set_deleted(true);
1403 
1404  status.garbage_collection(true);
1405 
1406  EXPECT_EQ(1u, mesh_.n_cells());
1407  EXPECT_EQ(6u, mesh_.n_faces());
1408  EXPECT_EQ(12u, mesh_.n_edges());
1409  EXPECT_EQ(8u, mesh_.n_vertices());
1410 }
1411 
1412 TEST_F(HexahedralMeshBase, GarbageCollectionTestManifoldness3) {
1413 
1414  generateHexahedralMesh(mesh_);
1415 
1416  StatusAttrib status(mesh_);
1417 
1418  status[FaceHandle(0)].set_deleted(true);
1419 
1420  status.garbage_collection(true);
1421 
1422  EXPECT_EQ(1u, mesh_.n_cells());
1423  EXPECT_EQ(6u, mesh_.n_faces());
1424  EXPECT_EQ(12u, mesh_.n_edges());
1425  EXPECT_EQ(8u, mesh_.n_vertices());
1426 }
1427 
1428 TEST_F(HexahedralMeshBase, GarbageCollectionTestManifoldness4) {
1429 
1430  generateHexahedralMesh(mesh_);
1431 
1432  StatusAttrib status(mesh_);
1433 
1434  status[CellHandle(0)].set_deleted(true);
1435 
1436  status.garbage_collection(true);
1437 
1438  EXPECT_EQ(1u, mesh_.n_cells());
1439  EXPECT_EQ(6u, mesh_.n_faces());
1440  EXPECT_EQ(12u, mesh_.n_edges());
1441  EXPECT_EQ(8u, mesh_.n_vertices());
1442 }
1443 
1444 TEST_F(HexahedralMeshBase, GarbageCollectionTestManifoldness5) {
1445 
1446  generateHexahedralMesh(mesh_);
1447 
1448  StatusAttrib status(mesh_);
1449 
1450  status[EdgeHandle(5)].set_deleted(true);
1451 
1452  status.garbage_collection(false);
1453 
1454  EXPECT_EQ(0u, mesh_.n_cells());
1455  EXPECT_EQ(8u, mesh_.n_faces());
1456  EXPECT_EQ(19u, mesh_.n_edges());
1457  EXPECT_EQ(12u, mesh_.n_vertices());
1458 
1459  status.garbage_collection(true);
1460 
1461  EXPECT_EQ(0u, mesh_.n_cells());
1462  EXPECT_EQ(0u, mesh_.n_faces());
1463  EXPECT_EQ(0u, mesh_.n_edges());
1464  EXPECT_EQ(0u, mesh_.n_vertices());
1465 }
1466 
1467 TEST_F(HexahedralMeshBase, GarbageCollectionTestTrackVertexHandles) {
1468 
1469  generateHexahedralMesh(mesh_);
1470 
1471  EXPECT_EQ(12u, mesh_.n_vertices());
1472  EXPECT_EQ(20u, mesh_.n_edges());
1473  EXPECT_EQ(11u, mesh_.n_faces());
1474  EXPECT_EQ(2u, mesh_.n_cells());
1475 
1476  StatusAttrib status(mesh_);
1477 
1478  status[VertexHandle(0)].set_deleted(true);
1479 
1480  std::vector<VertexHandle> vhs;
1481  std::vector<VertexHandle*> track_vhs;
1482  std::vector<HalfEdgeHandle*> hh_empty;
1483  std::vector<HalfFaceHandle*> hfh_empty;
1484  std::vector<CellHandle*> ch_empty;
1485 
1486  OpenVolumeMesh::VertexIter v_it = mesh_.vertices_begin();
1487  for (; v_it != mesh_.vertices_end(); ++v_it)
1488  vhs.push_back(*v_it);
1489 
1490  for (std::vector<VertexHandle>::iterator it = vhs.begin(); it != vhs.end(); ++it)
1491  track_vhs.push_back(&(*it));
1492 
1493  status.garbage_collection(track_vhs, hh_empty, hfh_empty, ch_empty, false);
1494 
1495  EXPECT_HANDLE_EQ(vhs[0], VertexHandle(-1));
1496  EXPECT_HANDLE_EQ(vhs[11], VertexHandle(10));
1497 
1498  EXPECT_EQ(1u, mesh_.n_cells());
1499  EXPECT_EQ(11u, mesh_.n_vertices());
1500  EXPECT_EQ(17u, mesh_.n_edges());
1501  EXPECT_EQ(8u, mesh_.n_faces());
1502 }
1503 
1504 TEST_F(HexahedralMeshBase, GarbageCollectionTestTrackHalfedgeHandles) {
1505 
1506  generateHexahedralMesh(mesh_);
1507 
1508  StatusAttrib status(mesh_);
1509 
1510  status[EdgeHandle(5)].set_deleted(true);
1511 
1512  std::vector<HalfEdgeHandle> hhs;
1513  std::vector<VertexHandle*> vh_empty;
1514  std::vector<HalfEdgeHandle*> track_hh;
1515  std::vector<HalfFaceHandle*> hfh_empty;
1516  std::vector<CellHandle*> ch_empty;
1517 
1518  OpenVolumeMesh::HalfEdgeIter hh_it = mesh_.halfedges_begin();
1519  for (; hh_it != mesh_.halfedges_end(); ++hh_it)
1520  hhs.push_back(*hh_it);
1521 
1522  for (std::vector<HalfEdgeHandle>::iterator it = hhs.begin(); it != hhs.end(); ++it)
1523  track_hh.push_back(&(*it));
1524 
1525  status.garbage_collection(vh_empty, track_hh, hfh_empty, ch_empty, false);
1526 
1527  EXPECT_HANDLE_EQ(hhs[9], HalfFaceHandle( 9));
1528  EXPECT_HANDLE_EQ(hhs[10], HalfFaceHandle(-1));
1529  EXPECT_HANDLE_EQ(hhs[11], HalfFaceHandle(-1));
1530  EXPECT_HANDLE_EQ(hhs[12], HalfFaceHandle(10));
1531  EXPECT_HANDLE_EQ(hhs[39], HalfFaceHandle(37));
1532 
1533  EXPECT_EQ(0u, mesh_.n_cells());
1534  EXPECT_EQ(8u, mesh_.n_faces());
1535  EXPECT_EQ(19u, mesh_.n_edges());
1536  EXPECT_EQ(12u, mesh_.n_vertices());
1537 
1538  status.garbage_collection(vh_empty, track_hh, hfh_empty, ch_empty, true);
1539 
1540  for (std::vector<HalfEdgeHandle>::iterator it = hhs.begin(); it != hhs.end(); ++it)
1541  EXPECT_EQ(it->idx(), -1);
1542 
1543  EXPECT_EQ(0u, mesh_.n_cells());
1544  EXPECT_EQ(0u, mesh_.n_faces());
1545  EXPECT_EQ(0u, mesh_.n_edges());
1546  EXPECT_EQ(0u, mesh_.n_vertices());
1547 }
1548 
1549 TEST_F(HexahedralMeshBase, GarbageCollectionTestTrackHalffaceHandles) {
1550 
1551  generateHexahedralMesh(mesh_);
1552 
1553  StatusAttrib status(mesh_);
1554 
1555  status[FaceHandle(0)].set_deleted(true);
1556 
1557  std::vector<HalfFaceHandle> hfhs;
1558  std::vector<VertexHandle*> vh_empty;
1559  std::vector<HalfEdgeHandle*> hh_empty;
1560  std::vector<HalfFaceHandle*> track_hfh;
1561  std::vector<CellHandle*> ch_empty;
1562 
1563  OpenVolumeMesh::HalfFaceIter hfh_it = mesh_.halffaces_begin();
1564  for (; hfh_it != mesh_.halffaces_end(); ++hfh_it)
1565  hfhs.push_back(*hfh_it);
1566 
1567  for (std::vector<HalfFaceHandle>::iterator it = hfhs.begin(); it != hfhs.end(); ++it)
1568  track_hfh.push_back(&(*it));
1569 
1570  status.garbage_collection(vh_empty, hh_empty, track_hfh, ch_empty, true);
1571 
1572  EXPECT_HANDLE_EQ(hfhs[0], HalfFaceHandle(-1));
1573  EXPECT_HANDLE_EQ(hfhs[1], HalfFaceHandle(-1));
1574  EXPECT_HANDLE_EQ(hfhs[2], HalfFaceHandle(0));
1575  EXPECT_HANDLE_EQ(hfhs[3], HalfFaceHandle(1));
1576  EXPECT_HANDLE_EQ(hfhs[21], HalfFaceHandle(11));
1577 
1578 
1579  EXPECT_EQ(1u, mesh_.n_cells());
1580  EXPECT_EQ(6u, mesh_.n_faces());
1581  EXPECT_EQ(12u, mesh_.n_edges());
1582  EXPECT_EQ(8u, mesh_.n_vertices());
1583 }
1584 
1585 TEST_F(HexahedralMeshBase, GarbageCollectionTestTrackCellHandles) {
1586 
1587  generateHexahedralMesh(mesh_);
1588 
1589  StatusAttrib status(mesh_);
1590 
1591  status[CellHandle(0)].set_deleted(true);
1592 
1593  std::vector<CellHandle> chs;
1594  std::vector<VertexHandle*> vh_empty;
1595  std::vector<HalfEdgeHandle*> hh_empty;
1596  std::vector<HalfFaceHandle*> hfh_empty;
1597  std::vector<CellHandle*> track_ch;
1598 
1599  OpenVolumeMesh::CellIter c_it = mesh_.cells_begin();
1600  for (; c_it != mesh_.cells_end(); ++c_it)
1601  chs.push_back(*c_it);
1602 
1603  for (std::vector<CellHandle>::iterator it = chs.begin(); it != chs.end(); ++it)
1604  track_ch.push_back(&(*it));
1605 
1606  status.garbage_collection(vh_empty, hh_empty, hfh_empty, track_ch, true);
1607 
1608  EXPECT_HANDLE_EQ(chs[0], HexahedralMesh::InvalidCellHandle);
1609  EXPECT_HANDLE_EQ(chs[1], CellHandle(0));
1610 
1611  EXPECT_EQ(1u, mesh_.n_cells());
1612  EXPECT_EQ(6u, mesh_.n_faces());
1613  EXPECT_EQ(12u, mesh_.n_edges());
1614  EXPECT_EQ(8u, mesh_.n_vertices());
1615 }
1616 
1617 TEST_F(HexahedralMeshBase, GarbageCollectionTestProps1) {
1618 
1619  generateHexahedralMesh(mesh_);
1620 
1621  StatusAttrib status(mesh_);
1622 
1623  FacePropertyT<int> fprop = mesh_.request_face_property<int>("FProp");
1624 
1625  FaceHandle fh0(0);
1626  FaceHandle fh1(1);
1627  FaceHandle fh2(2);
1628  FaceHandle fh3(3);
1629  FaceHandle fh4(4);
1630  FaceHandle fh5(5);
1631  FaceHandle fh6(6);
1632  FaceHandle fh7(7);
1633  FaceHandle fh8(8);
1634  FaceHandle fh9(9);
1635  FaceHandle fh10(10);
1636 
1637  fprop[fh0] = 11;
1638  fprop[fh1] = 10;
1639  fprop[fh2] = 9;
1640  fprop[fh3] = 8;
1641  fprop[fh4] = 7;
1642  fprop[fh5] = 6;
1643  fprop[fh6] = 5;
1644  fprop[fh7] = 4;
1645  fprop[fh8] = 3;
1646  fprop[fh9] = 2;
1647  fprop[fh10] = 1;
1648 
1649  status[VertexHandle(0)].set_deleted(true);
1650 
1651  status.garbage_collection(false);
1652 
1653  EXPECT_EQ(1u, mesh_.n_cells());
1654  EXPECT_EQ(11u, mesh_.n_vertices());
1655  EXPECT_EQ(17u, mesh_.n_edges());
1656  EXPECT_EQ(8u, mesh_.n_faces());
1657 
1658  std::set<int> fprops_i;
1659  for(FaceIter f_it = mesh_.f_iter(); f_it.valid(); ++f_it) {
1660  fprops_i.insert(fprop[*f_it]);
1661  }
1662 
1663  EXPECT_EQ(0u, fprops_i.count(11));
1664  EXPECT_EQ(1u, fprops_i.count(10));
1665  EXPECT_EQ(1u, fprops_i.count(9));
1666  EXPECT_EQ(0u, fprops_i.count(8));
1667  EXPECT_EQ(0u, fprops_i.count(7));
1668  EXPECT_EQ(1u, fprops_i.count(6));
1669  EXPECT_EQ(1u, fprops_i.count(5));
1670  EXPECT_EQ(1u, fprops_i.count(4));
1671  EXPECT_EQ(1u, fprops_i.count(3));
1672  EXPECT_EQ(1u, fprops_i.count(2));
1673  EXPECT_EQ(1u, fprops_i.count(1));
1674 }
1675 
1676 TEST_F(HexahedralMeshBase, GarbageCollectionTestProps2) {
1677 
1678  generateHexahedralMesh(mesh_);
1679 
1680  StatusAttrib status(mesh_);
1681 
1682  FacePropertyT<int> fprop = mesh_.request_face_property<int>("FProp");
1683 
1684  FaceHandle fh0(0);
1685  FaceHandle fh1(1);
1686  FaceHandle fh2(2);
1687  FaceHandle fh3(3);
1688  FaceHandle fh4(4);
1689  FaceHandle fh5(5);
1690  FaceHandle fh6(6);
1691  FaceHandle fh7(7);
1692  FaceHandle fh8(8);
1693  FaceHandle fh9(9);
1694  FaceHandle fh10(10);
1695 
1696  fprop[fh0] = 11;
1697  fprop[fh1] = 10;
1698  fprop[fh2] = 9;
1699  fprop[fh3] = 8;
1700  fprop[fh4] = 7;
1701  fprop[fh5] = 6;
1702  fprop[fh6] = 5;
1703  fprop[fh7] = 4;
1704  fprop[fh8] = 3;
1705  fprop[fh9] = 2;
1706  fprop[fh10] = 1;
1707 
1708  status[FaceHandle(0)].set_deleted(true);
1709 
1710  status.garbage_collection(false);
1711 
1712  EXPECT_EQ(1u, mesh_.n_cells());
1713  EXPECT_EQ(12u, mesh_.n_vertices());
1714  EXPECT_EQ(20u, mesh_.n_edges());
1715  EXPECT_EQ(10u, mesh_.n_faces());
1716 
1717  std::set<int> fprops_i;
1718  for(FaceIter f_it = mesh_.f_iter(); f_it.valid(); ++f_it) {
1719  fprops_i.insert(fprop[*f_it]);
1720  }
1721 
1722  EXPECT_EQ(0u, fprops_i.count(11));
1723  EXPECT_EQ(1u, fprops_i.count(10));
1724  EXPECT_EQ(1u, fprops_i.count(9));
1725  EXPECT_EQ(1u, fprops_i.count(8));
1726  EXPECT_EQ(1u, fprops_i.count(7));
1727  EXPECT_EQ(1u, fprops_i.count(6));
1728  EXPECT_EQ(1u, fprops_i.count(5));
1729  EXPECT_EQ(1u, fprops_i.count(4));
1730  EXPECT_EQ(1u, fprops_i.count(3));
1731  EXPECT_EQ(1u, fprops_i.count(2));
1732  EXPECT_EQ(1u, fprops_i.count(1));
1733 }
1734 
1735 TEST_F(HexahedralMeshBase, HalfEdgeFetchFunction1) {
1736 
1737  generateHexahedralMesh(mesh_);
1738 
1739  VertexHandle v0(0);
1740  VertexHandle v1(1);
1741 
1742  VertexHandle v2(2);
1743  VertexHandle v3(3);
1744 
1745  VertexHandle v5(5);
1746  VertexHandle v6(6);
1747  VertexHandle v7(7);
1748 
1749  HalfEdgeHandle he0 = mesh_.halfedge(v0, v1);
1750  HalfEdgeHandle he5 = mesh_.halfedge(v3, v2);
1751  HalfEdgeHandle he10 = mesh_.halfedge(v5, v6);
1752  HalfEdgeHandle heInv = mesh_.halfedge(v5, v7);
1753 
1754  EXPECT_HANDLE_EQ(HalfEdgeHandle(0), he0);
1755  EXPECT_HANDLE_EQ(HalfEdgeHandle(5), he5);
1756  EXPECT_HANDLE_EQ(HalfEdgeHandle(10), he10);
1757  EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfEdgeHandle, heInv);
1758 }
1759 
1760 TEST_F(HexahedralMeshBase, HalfFaceFetchFunction1) {
1761 
1762  generateHexahedralMesh(mesh_);
1763 
1764  HalfEdgeHandle he0(0);
1765  HalfEdgeHandle he2(2);
1766  HalfEdgeHandle he4(4);
1767 
1768  std::vector<HalfEdgeHandle> hes;
1769  hes.push_back(he0); hes.push_back(he2);
1770 
1771  HalfFaceHandle hf0_0 = mesh_.halfface(hes);
1772  hes.clear();
1773  hes.push_back(he0); hes.push_back(he4);
1774  HalfFaceHandle hf0_1 = mesh_.halfface(hes);
1775 
1776  HalfEdgeHandle he16(16);
1777  HalfEdgeHandle he18(18);
1778 
1779  hes.clear();
1780  hes.push_back(he16); hes.push_back(he18);
1781  HalfFaceHandle hf4_0 = mesh_.halfface(hes);
1782 
1783  hes.clear();
1784  hes.push_back(he0); hes.push_back(he18);
1785  HalfFaceHandle hfInv = mesh_.halfface(hes);
1786 
1787  HalfEdgeHandle he17(17);
1788  HalfEdgeHandle he19(19);
1789 
1790  hes.clear();
1791  hes.push_back(he17); hes.push_back(he19);
1792  HalfFaceHandle hf5_0 = mesh_.halfface(hes);
1793 
1794  EXPECT_HANDLE_EQ(HalfFaceHandle(0), hf0_0);
1795  EXPECT_HANDLE_EQ(HalfFaceHandle(0), hf0_1);
1796  EXPECT_HANDLE_EQ(HalfFaceHandle(4), hf4_0);
1797  EXPECT_HANDLE_EQ(HalfFaceHandle(5), hf5_0);
1798  EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfFaceHandle, hfInv);
1799 }
1800 
1801 TEST_F(HexahedralMeshBase, HalfFaceFetchFunction2) {
1802 
1803  generateHexahedralMesh(mesh_);
1804 
1805  VertexHandle v0(0);
1806  VertexHandle v1(1);
1807  VertexHandle v2(2);
1808  VertexHandle v4(4);
1809  VertexHandle v5(5);
1810  VertexHandle v6(6);
1811 
1812  std::vector<VertexHandle> vs;
1813  vs.push_back(v0); vs.push_back(v1); vs.push_back(v2);
1814  HalfFaceHandle hf0 = mesh_.halfface(vs); vs.clear();
1815 
1816  vs.push_back(v2); vs.push_back(v1); vs.push_back(v0);
1817  HalfFaceHandle hf1 = mesh_.halfface(vs); vs.clear();
1818 
1819  vs.push_back(v2); vs.push_back(v1); vs.push_back(v5);
1820  HalfFaceHandle hf4 = mesh_.halfface(vs); vs.clear();
1821 
1822  vs.push_back(v6); vs.push_back(v5); vs.push_back(v4);
1823  HalfFaceHandle hf3 = mesh_.halfface(vs); vs.clear();
1824 
1825  vs.push_back(v4); vs.push_back(v5); vs.push_back(v6);
1826  HalfFaceHandle hf2 = mesh_.halfface(vs); vs.clear();
1827 
1828  vs.push_back(v0); vs.push_back(v1); vs.push_back(v4);
1829  HalfFaceHandle hfInv0 = mesh_.halfface(vs); vs.clear();
1830 
1831  vs.push_back(v0); vs.push_back(v1); vs.push_back(v6);
1832  HalfFaceHandle hfInv1 = mesh_.halfface(vs); vs.clear();
1833 
1834  EXPECT_HANDLE_EQ(HalfFaceHandle(0), hf0);
1835  EXPECT_HANDLE_EQ(HalfFaceHandle(1), hf1);
1836  EXPECT_HANDLE_EQ(HalfFaceHandle(4), hf4);
1837  EXPECT_HANDLE_EQ(HalfFaceHandle(3), hf3);
1838  EXPECT_HANDLE_EQ(HalfFaceHandle(2), hf2);
1839  EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfFaceHandle, hfInv0);
1840  EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfFaceHandle, hfInv1);
1841 }
1842 
1843 TEST_F(HexahedralMeshBase, AddCellViaVerticesFunction1) {
1844 
1845  generateHexahedralMesh(mesh_);
1846 
1847  StatusAttrib status(mesh_);
1848 
1849  status[FaceHandle(0)].set_deleted(true);
1850 
1851  status.garbage_collection(false);
1852 
1853  EXPECT_EQ(1u, mesh_.n_cells());
1854  EXPECT_EQ(10u, mesh_.n_faces());
1855  EXPECT_EQ(20u, mesh_.n_edges());
1856  EXPECT_EQ(12u, mesh_.n_vertices());
1857 
1858  std::vector<VertexHandle> vs;
1859  vs.push_back(VertexHandle(0));
1860  vs.push_back(VertexHandle(1));
1861  vs.push_back(VertexHandle(2));
1862  vs.push_back(VertexHandle(3));
1863  vs.push_back(VertexHandle(4));
1864  vs.push_back(VertexHandle(7));
1865  vs.push_back(VertexHandle(6));
1866  vs.push_back(VertexHandle(5));
1867 
1868  CellHandle ch = mesh_.add_cell(vs);
1869 
1870  EXPECT_HANDLE_NE(HexahedralMesh::InvalidCellHandle, ch);
1871 
1872  EXPECT_EQ(2u, mesh_.n_cells());
1873  EXPECT_EQ(11u, mesh_.n_faces());
1874  EXPECT_EQ(20u, mesh_.n_edges());
1875  EXPECT_EQ(12u, mesh_.n_vertices());
1876 }
1877 
1878 TEST_F(HexahedralMeshBase, AddCellViaVerticesFunction2) {
1879 
1880  generateHexahedralMesh(mesh_);
1881 
1882  StatusAttrib status(mesh_);
1883 
1884  status[FaceHandle(0)].set_deleted(true);
1885 
1886  status.garbage_collection(true);
1887 
1888  EXPECT_EQ(1u, mesh_.n_cells());
1889  EXPECT_EQ(6u, mesh_.n_faces());
1890  EXPECT_EQ(12u, mesh_.n_edges());
1891  EXPECT_EQ(8u, mesh_.n_vertices());
1892 
1893  VertexHandle v0 = mesh_.add_vertex(Vec3d(0.0, 0.0, 0.0));
1894  VertexHandle v1 = mesh_.add_vertex(Vec3d(1.0, 0.0, 0.0));
1895  VertexHandle v2 = mesh_.add_vertex(Vec3d(1.0, 1.0, 0.0));
1896  VertexHandle v3 = mesh_.add_vertex(Vec3d(0.0, 1.0, 0.0));
1897 
1898  std::vector<VertexHandle> vs;
1899  vs.push_back(v0);
1900  vs.push_back(v1);
1901  vs.push_back(v2);
1902  vs.push_back(v3);
1903  vs.push_back(VertexHandle(0));
1904  vs.push_back(VertexHandle(3));
1905  vs.push_back(VertexHandle(2));
1906  vs.push_back(VertexHandle(1));
1907 
1908  CellHandle ch = mesh_.add_cell(vs);
1909 
1910  EXPECT_HANDLE_NE(HexahedralMesh::InvalidCellHandle, ch);
1911 
1912  EXPECT_EQ(2u, mesh_.n_cells());
1913  EXPECT_EQ(11u, mesh_.n_faces());
1914  EXPECT_EQ(20u, mesh_.n_edges());
1915  EXPECT_EQ(12u, mesh_.n_vertices());
1916 }
1917 
1918 //===========================================================================
1919 
1920 TEST_F(PolyhedralMeshBase, SwapVertices) {
1921 
1922  generatePolyhedralMesh(mesh_);
1923 
1924  Vec3d p1(0.0, 0.0, 0.0);
1925  Vec3d p2(1.0, 0.0, 0.0);
1926  Vec3d p3(1.0, 1.0, 0.0);
1927  Vec3d p4(0.0, 1.0, 0.0);
1928 
1929  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[0], p1[0]);
1930  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[1], p1[1]);
1931  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[2], p1[2]);
1932 
1933  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[0], p2[0]);
1934  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[1], p2[1]);
1935  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[2], p2[2]);
1936 
1937  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[0], p3[0]);
1938  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[1], p3[1]);
1939  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[2], p3[2]);
1940 
1941  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[0], p4[0]);
1942  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[1], p4[1]);
1943  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[2], p4[2]);
1944 
1945  EXPECT_EQ(12u, mesh_.n_vertices());
1946 
1947  Vec3d p1n(1.0, 1.0, 1.0);
1948  Vec3d p2n(0.0, 1.0, 2.0);
1949  Vec3d p3n(0.0, 0.0, 3.0);
1950  Vec3d p4n(1.0, 0.0, 4.0);
1951 
1952  /*
1953  * Old coordinates
1954  */
1955  Vec3d p5(0.0, 0.0, 1.0);
1956  Vec3d p6(1.0, 0.0, 1.0);
1957  Vec3d p7(1.0, 1.0, 1.0);
1958  Vec3d p8(0.0, 1.0, 1.0);
1959 
1960  Vec3d p9(0.0, 0.0, 2.0);
1961  Vec3d p10(1.0, 0.0, 2.0);
1962  Vec3d p11(1.0, 1.0, 2.0);
1963  Vec3d p12(0.0, 1.0, 2.0);
1964 
1965  std::vector<Vec3d> new_vertices;
1966 
1967  new_vertices.push_back(p1n);
1968  new_vertices.push_back(p2n);
1969  new_vertices.push_back(p3n);
1970  new_vertices.push_back(p4n);
1971 
1972  new_vertices.push_back(p5);
1973  new_vertices.push_back(p6);
1974  new_vertices.push_back(p7);
1975  new_vertices.push_back(p8);
1976  new_vertices.push_back(p9);
1977  new_vertices.push_back(p10);
1978  new_vertices.push_back(p11);
1979  new_vertices.push_back(p12);
1980 
1981  mesh_.swap_vertices(new_vertices);
1982 
1983  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[0], p1n[0]);
1984  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[1], p1n[1]);
1985  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[2], p1n[2]);
1986 
1987  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[0], p2n[0]);
1988  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[1], p2n[1]);
1989  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[2], p2n[2]);
1990 
1991  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[0], p3n[0]);
1992  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[1], p3n[1]);
1993  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[2], p3n[2]);
1994 
1995  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[0], p4n[0]);
1996  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[1], p4n[1]);
1997  EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[2], p4n[2]);
1998 
1999  EXPECT_EQ(12u, mesh_.n_vertices());
2000 }
2001 
2002 static void testDeferredDelete(PolyhedralMesh &mesh) {
2003  mesh.add_vertex(Vec3d(1,0,0));
2004  mesh.add_vertex(Vec3d(0,1,0));
2005  mesh.delete_vertex(VertexHandle(0));
2006  mesh.collect_garbage();
2007  EXPECT_DOUBLE_EQ(mesh.vertex(VertexHandle(0))[1], 1);
2008 }
2009 
2010 TEST_F(PolyhedralMeshBase, DeferredDelete) {
2011  mesh_.enable_deferred_deletion(true);
2012  mesh_.enable_fast_deletion(false);
2013  testDeferredDelete(mesh_);
2014 }
2015 TEST_F(PolyhedralMeshBase, DeferredFastDelete) {
2016  mesh_.enable_deferred_deletion(true);
2017  mesh_.enable_fast_deletion(true);
2018  testDeferredDelete(mesh_);
2019 }
2020 
2021 
2022 TEST_F(PolyhedralMeshBase, HandleDefaultConstructors) {
2023  VertexHandle vh;
2024  ASSERT_FALSE(vh.is_valid());
2025  EdgeHandle eh;
2026  ASSERT_FALSE(eh.is_valid());
2027  HalfEdgeHandle heh;
2028  ASSERT_FALSE(heh.is_valid());
2029  FaceHandle fh;
2030  ASSERT_FALSE(fh.is_valid());
2031  HalfFaceHandle hfh;
2032  ASSERT_FALSE(hfh.is_valid());
2033  CellHandle ch;
2034  ASSERT_FALSE(ch.is_valid());
2035 }
2036 
OpenVolumeMesh::HexVertexIter
Iterate over all vertices of a hexahedron in a specific order.
Definition: HexahedralMeshIterators.hh:177
OpenMesh::PolyMeshT::add_vertex
SmartVertexHandle add_vertex(const Point &_p)
Alias for new_vertex(const Point&).
Definition: PolyMeshT.hh:235
OpenVolumeMesh::GeometryKernel::vertex
const VecT & vertex(const VertexHandle &_vh) const
Get point _vh&#39;s coordinates.
Definition: GeometryKernel.hh:87
OpenVolumeMesh::GeometryKernel::add_vertex
VertexHandle add_vertex() override
Override of empty add_vertex function.
Definition: GeometryKernel.hh:66