Developer Documentation
Loading...
Searching...
No Matches
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
7using namespace OpenVolumeMesh;
8using namespace Geometry;
9
10/*
11 * ====================================================================
12 * Define tests below
13 * ====================================================================
14 */
15
16TEST_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
114TEST_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
256TEST_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
292TEST_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
328TEST_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
405TEST_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
482TEST_F(PolyhedralMeshBase, VolumeMeshGenus) {
483
484 generatePolyhedralMesh(mesh_);
485
486 EXPECT_EQ(0, mesh_.genus());
487}
488
489TEST_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 halfface 4
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
543TEST_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
600TEST_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
633TEST_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
675TEST_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
749TEST_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
769TEST_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
783TEST_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
826TEST_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
871TEST_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 mesh_.enable_bottom_up_incidences(true);
882
883 for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin(),
884 hf_end = hfs.end(); hf_it != hf_end; ++hf_it) {
885 EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidCellHandle, mesh_.incident_cell(*hf_it));
886 }
887}
888
889TEST_F(PolyhedralMeshBase, DeleteFaceBUTest1noBU) {
890
891 generatePolyhedralMesh(mesh_);
892
893 mesh_.enable_bottom_up_incidences(false);
894
895 std::vector<HalfEdgeHandle> hes = mesh_.face(FaceHandle(0)).halfedges();
896
897 std::vector<HalfFaceHandle> ihfs[4];
898
899 for(size_t i = 0; i < 4; ++i) {
900 for(HalfFaceIter hf_it = mesh_.halffaces_begin(), hf_end = mesh_.halffaces_end(); hf_it != hf_end; ++hf_it) {
901
902 std::vector<HalfEdgeHandle> t_hes = mesh_.halfface(*hf_it).halfedges();
903 bool found = false;
904 for(std::vector<HalfEdgeHandle>::const_iterator the_it = t_hes.begin(),
905 the_end = t_hes.end(); the_it != the_end; ++the_it) {
906 if(std::find(hes.begin(), hes.end(), *the_it) != hes.end()) {
907 found = true;
908 break;
909 }
910 }
911 if(!found) continue;
912
913 HalfFaceHandle hfh = *hf_it;
914
915 if(mesh_.face_handle(hfh) == FaceHandle(0)) continue;
916
917 hfh.idx((hfh.idx() > mesh_.halfface_handle(FaceHandle(0), 1).idx() ? hfh.idx() - 2 : hfh.idx()));
918
919 ihfs[i].push_back(hfh);
920 }
921 }
922
923 mesh_.delete_face(FaceHandle(0));
924
925 std::set<HalfFaceHandle> nihfs[4];
926 for(size_t i = 0; i < 4; ++i) {
927 for(HalfFaceIter hf_it = mesh_.halffaces_begin(), hf_end = mesh_.halffaces_end(); hf_it != hf_end; ++hf_it) {
928
929 std::vector<HalfEdgeHandle> t_hes = mesh_.halfface(*hf_it).halfedges();
930 bool found = false;
931 for(std::vector<HalfEdgeHandle>::const_iterator the_it = t_hes.begin(),
932 the_end = t_hes.end(); the_it != the_end; ++the_it) {
933 if(std::find(hes.begin(), hes.end(), *the_it) != hes.end()) {
934 found = true;
935 break;
936 }
937 }
938 if(!found) continue;
939
940 nihfs[i].insert(*hf_it);
941 }
942 }
943
944 EXPECT_EQ(ihfs[0].size(), nihfs[0].size());
945 EXPECT_EQ(ihfs[1].size(), nihfs[1].size());
946 EXPECT_EQ(ihfs[2].size(), nihfs[2].size());
947 EXPECT_EQ(ihfs[3].size(), nihfs[3].size());
948
949 for(size_t i = 0; i < 4; ++i) {
950 for(std::vector<HalfFaceHandle>::const_iterator hf_it = ihfs[i].begin(),
951 hf_end = ihfs[i].end(); hf_it != hf_end; ++hf_it) {
952 EXPECT_GT(nihfs[i].count(*hf_it), 0u);
953 }
954 }
955}
956
957TEST_F(PolyhedralMeshBase, DeleteEdgeBUTest1noBU) {
958
959 generatePolyhedralMesh(mesh_);
960
961 mesh_.enable_bottom_up_incidences(false);
962
963 VertexHandle vh0 = mesh_.edge(EdgeHandle(0)).from_vertex();
964 VertexHandle vh1 = mesh_.edge(EdgeHandle(0)).to_vertex();
965
966 std::vector<HalfEdgeHandle> hes0;
967 for(HalfEdgeIter he_it = mesh_.halfedges_begin(), he_end = mesh_.halfedges_end(); he_it != he_end; ++he_it) {
968
969 if(mesh_.halfedge(*he_it).from_vertex() == vh0) {
970
971 if(mesh_.edge_handle(*he_it) == EdgeHandle(0)) continue;
972 hes0.push_back(HalfEdgeHandle(he_it->idx() > mesh_.halfedge_handle(EdgeHandle(0), 1).idx() ? he_it->idx() - 2 : he_it->idx()));
973 }
974 }
975
976 std::vector<HalfEdgeHandle> hes1;
977 for(HalfEdgeIter he_it = mesh_.halfedges_begin(), he_end = mesh_.halfedges_end(); he_it != he_end; ++he_it) {
978
979 if(mesh_.halfedge(*he_it).from_vertex() == vh1) {
980
981 if(mesh_.edge_handle(*he_it) == EdgeHandle(0)) continue;
982 hes1.push_back(HalfEdgeHandle(he_it->idx() > mesh_.halfedge_handle(EdgeHandle(0), 1).idx() ? he_it->idx() - 2 : he_it->idx()));
983 }
984 }
985
986 mesh_.delete_edge(EdgeHandle(0));
987
988 std::set<HalfEdgeHandle> nhes0;
989 for(HalfEdgeIter he_it = mesh_.halfedges_begin(), he_end = mesh_.halfedges_end(); he_it != he_end; ++he_it) {
990 if(mesh_.halfedge(*he_it).from_vertex() == vh0) {
991 nhes0.insert(*he_it);
992 }
993 }
994
995 std::set<HalfEdgeHandle> nhes1;
996 for(HalfEdgeIter he_it = mesh_.halfedges_begin(), he_end = mesh_.halfedges_end(); he_it != he_end; ++he_it) {
997 if(mesh_.halfedge(*he_it).from_vertex() == vh1) {
998 nhes1.insert(*he_it);
999 }
1000 }
1001
1002 EXPECT_EQ(hes0.size(), nhes0.size());
1003 EXPECT_EQ(hes1.size(), nhes1.size());
1004
1005 for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes0.begin(),
1006 he_end = hes0.end(); he_it != he_end; ++he_it) {
1007 EXPECT_GT(nhes0.count(*he_it), 0u);
1008 }
1009
1010 for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes1.begin(),
1011 he_end = hes1.end(); he_it != he_end; ++he_it) {
1012 EXPECT_GT(nhes1.count(*he_it), 0u);
1013 }
1014}
1015
1016TEST_F(PolyhedralMeshBase, DeleteLastVertexTestBU) {
1017
1018 generatePolyhedralMesh(mesh_);
1019
1020 for(OpenVolumeMesh::HalfEdgeIter he_it = mesh_.halfedges_begin();
1021 he_it != mesh_.halfedges_end(); ++he_it) {
1022
1023 const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1024 const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1025
1026 EXPECT_LE(fromVertex.idx(), 11);
1027 EXPECT_LE(toVertex.idx(), 11);
1028 }
1029
1030 mesh_.delete_vertex(VertexHandle(11));
1031
1032 for(OpenVolumeMesh::HalfEdgeIter he_it = mesh_.halfedges_begin();
1033 he_it != mesh_.halfedges_end(); ++he_it) {
1034
1035 const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1036 const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1037
1038 EXPECT_LE(fromVertex.idx(), 10);
1039 EXPECT_LE(toVertex.idx(), 10);
1040 }
1041}
1042
1043TEST_F(PolyhedralMeshBase, DeleteLastEdgeTestBU) {
1044
1045 generatePolyhedralMesh(mesh_);
1046
1047 for(OpenVolumeMesh::HalfFaceIter f_it = mesh_.halffaces_begin();
1048 f_it != mesh_.halffaces_end(); ++f_it) {
1049
1050 std::vector<HalfEdgeHandle> hes = mesh_.halfface(*f_it).halfedges();
1051 for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes.begin();
1052 he_it != hes.end(); ++he_it) {
1053 EXPECT_LE(he_it->idx(), 39);
1054 }
1055 }
1056
1057 mesh_.delete_edge(EdgeHandle(19));
1058
1059 for(OpenVolumeMesh::HalfFaceIter f_it = mesh_.halffaces_begin();
1060 f_it != mesh_.halffaces_end(); ++f_it) {
1061
1062 std::vector<HalfEdgeHandle> hes = mesh_.halfface(*f_it).halfedges();
1063 for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes.begin();
1064 he_it != hes.end(); ++he_it) {
1065 EXPECT_LE(he_it->idx(), 37);
1066 }
1067 }
1068}
1069
1070TEST_F(PolyhedralMeshBase, DeleteLastFaceTestBU) {
1071
1072 generatePolyhedralMesh(mesh_);
1073
1074 for(OpenVolumeMesh::CellIter c_it = mesh_.cells_begin();
1075 c_it != mesh_.cells_end(); ++c_it) {
1076
1077 std::vector<HalfFaceHandle> hfs = mesh_.cell(*c_it).halffaces();
1078 for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin();
1079 hf_it != hfs.end(); ++hf_it) {
1080 EXPECT_LE(hf_it->idx(), 21);
1081 EXPECT_LE(mesh_.opposite_halfface_handle(*hf_it).idx(), 21);
1082 }
1083 }
1084
1085 mesh_.delete_face(FaceHandle(10));
1086
1087 for(OpenVolumeMesh::CellIter c_it = mesh_.cells_begin();
1088 c_it != mesh_.cells_end(); ++c_it) {
1089
1090 std::vector<HalfFaceHandle> hfs = mesh_.cell(*c_it).halffaces();
1091 for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin();
1092 hf_it != hfs.end(); ++hf_it) {
1093 EXPECT_LE(hf_it->idx(), 19);
1094 EXPECT_LE(mesh_.opposite_halfface_handle(*hf_it).idx(), 19);
1095 }
1096 }
1097}
1098
1099TEST_F(PolyhedralMeshBase, DeleteLastVertexTestNoBU) {
1100
1101 generatePolyhedralMesh(mesh_);
1102
1103 mesh_.enable_bottom_up_incidences(false);
1104
1105 for(OpenVolumeMesh::HalfEdgeIter he_it = mesh_.halfedges_begin();
1106 he_it != mesh_.halfedges_end(); ++he_it) {
1107
1108 const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1109 const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1110
1111 EXPECT_LE(fromVertex.idx(), 11);
1112 EXPECT_LE(toVertex.idx(), 11);
1113 }
1114
1115 mesh_.delete_vertex(VertexHandle(11));
1116
1117 for(OpenVolumeMesh::HalfEdgeIter he_it = mesh_.halfedges_begin();
1118 he_it != mesh_.halfedges_end(); ++he_it) {
1119
1120 const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1121 const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1122
1123 EXPECT_LE(fromVertex.idx(), 10);
1124 EXPECT_LE(toVertex.idx(), 10);
1125 }
1126}
1127
1128TEST_F(PolyhedralMeshBase, DeleteLastEdgeTestNoBU) {
1129
1130 generatePolyhedralMesh(mesh_);
1131
1132 mesh_.enable_bottom_up_incidences(false);
1133
1134 for(OpenVolumeMesh::HalfFaceIter f_it = mesh_.halffaces_begin();
1135 f_it != mesh_.halffaces_end(); ++f_it) {
1136
1137 std::vector<HalfEdgeHandle> hes = mesh_.halfface(*f_it).halfedges();
1138 for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes.begin();
1139 he_it != hes.end(); ++he_it) {
1140 EXPECT_LE(he_it->idx(), 39);
1141 }
1142 }
1143
1144 mesh_.delete_edge(EdgeHandle(19));
1145
1146 for(OpenVolumeMesh::HalfFaceIter f_it = mesh_.halffaces_begin();
1147 f_it != mesh_.halffaces_end(); ++f_it) {
1148
1149 std::vector<HalfEdgeHandle> hes = mesh_.halfface(*f_it).halfedges();
1150 for(std::vector<HalfEdgeHandle>::const_iterator he_it = hes.begin();
1151 he_it != hes.end(); ++he_it) {
1152 EXPECT_LE(he_it->idx(), 37);
1153 }
1154 }
1155}
1156
1157TEST_F(PolyhedralMeshBase, DeleteLastFaceTestNoBU) {
1158
1159 generatePolyhedralMesh(mesh_);
1160
1161 mesh_.enable_bottom_up_incidences(false);
1162
1163 for(OpenVolumeMesh::CellIter c_it = mesh_.cells_begin();
1164 c_it != mesh_.cells_end(); ++c_it) {
1165
1166 std::vector<HalfFaceHandle> hfs = mesh_.cell(*c_it).halffaces();
1167 for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin();
1168 hf_it != hfs.end(); ++hf_it) {
1169 EXPECT_LE(hf_it->idx(), 21);
1170 EXPECT_LE(mesh_.opposite_halfface_handle(*hf_it).idx(), 21);
1171 }
1172 }
1173
1174 mesh_.delete_face(FaceHandle(10));
1175
1176 for(OpenVolumeMesh::CellIter c_it = mesh_.cells_begin();
1177 c_it != mesh_.cells_end(); ++c_it) {
1178
1179 std::vector<HalfFaceHandle> hfs = mesh_.cell(*c_it).halffaces();
1180 for(std::vector<HalfFaceHandle>::const_iterator hf_it = hfs.begin();
1181 hf_it != hfs.end(); ++hf_it) {
1182 EXPECT_LE(hf_it->idx(), 19);
1183 EXPECT_LE(mesh_.opposite_halfface_handle(*hf_it).idx(), 19);
1184 }
1185 }
1186}
1187
1188/*
1189 * Hexahedral mesh tests
1190 */
1191
1192TEST_F(HexahedralMeshBase, SimpleHexMeshNavigation) {
1193
1194 generateHexahedralMesh(mesh_);
1195
1196 EXPECT_EQ(12u, mesh_.n_vertices());
1197 EXPECT_EQ(20u, mesh_.n_edges());
1198 EXPECT_EQ(11u, mesh_.n_faces());
1199 EXPECT_EQ(2u, mesh_.n_cells());
1200
1201 EXPECT_HANDLE_EQ(HalfFaceHandle(1), mesh_.xfront_halfface(CellHandle(0)));
1202 EXPECT_HANDLE_EQ(HalfFaceHandle(2), mesh_.xback_halfface(CellHandle(0)));
1203 EXPECT_HANDLE_EQ(HalfFaceHandle(5), mesh_.yfront_halfface(CellHandle(0)));
1204 EXPECT_HANDLE_EQ(HalfFaceHandle(6), mesh_.yback_halfface(CellHandle(0)));
1205 EXPECT_HANDLE_EQ(HalfFaceHandle(8), mesh_.zfront_halfface(CellHandle(0)));
1206 EXPECT_HANDLE_EQ(HalfFaceHandle(11), mesh_.zback_halfface(CellHandle(0)));
1207
1208 EXPECT_HANDLE_EQ(HalfFaceHandle(12), mesh_.opposite_halfface_handle_in_cell(
1209 HalfFaceHandle(3), CellHandle(1)));
1210
1211 EXPECT_HANDLE_EQ(HalfFaceHandle(20), mesh_.adjacent_halfface_on_sheet(
1212 HalfFaceHandle(10), HalfEdgeHandle(12)));
1213 EXPECT_HANDLE_EQ(HalfFaceHandle(21), mesh_.adjacent_halfface_on_sheet(
1214 HalfFaceHandle(11), HalfEdgeHandle(12)));
1215
1216 HexahedralMesh::CellSheetCellIter csc_it = mesh_.csc_iter(CellHandle(0), HexahedralMesh::YF);
1217 EXPECT_HANDLE_EQ(CellHandle(1), *csc_it);
1218
1219 HexahedralMesh::HalfFaceSheetHalfFaceIter hfshf_it = mesh_.hfshf_iter(HalfFaceHandle(5));
1220 EXPECT_HANDLE_EQ(HalfFaceHandle(15), *hfshf_it);
1221 hfshf_it = mesh_.hfshf_iter(HalfFaceHandle(6));
1222 EXPECT_HANDLE_EQ(HalfFaceHandle(16), *hfshf_it);
1223}
1224
1225TEST_F(HexahedralMeshBase, BottomUpIncidenceUpdate1) {
1226
1227 generateHexahedralMesh(mesh_);
1228
1229 EXPECT_EQ(12u, mesh_.n_vertices());
1230 EXPECT_EQ(20u, mesh_.n_edges());
1231 EXPECT_EQ(11u, mesh_.n_faces());
1232 EXPECT_EQ(2u, mesh_.n_cells());
1233
1234 mesh_.delete_vertex(VertexHandle(0));
1235
1236 EXPECT_EQ(11u, mesh_.n_vertices());
1237 EXPECT_EQ(17u, mesh_.n_edges());
1238 EXPECT_EQ(8u, mesh_.n_faces());
1239 EXPECT_EQ(1u, mesh_.n_cells());
1240
1241 HexVertexIter hv_it = mesh_.hv_iter(CellHandle(0));
1242
1243 EXPECT_EQ(3, hv_it->idx()); ++hv_it;
1244 EXPECT_EQ(4, hv_it->idx()); ++hv_it;
1245 EXPECT_EQ(5, hv_it->idx()); ++hv_it;
1246 EXPECT_EQ(6, hv_it->idx()); ++hv_it;
1247 EXPECT_EQ(7, hv_it->idx()); ++hv_it;
1248 EXPECT_EQ(10, hv_it->idx()); ++hv_it;
1249 EXPECT_EQ(9, hv_it->idx()); ++hv_it;
1250 EXPECT_EQ(8, hv_it->idx());
1251}
1252
1253TEST_F(HexahedralMeshBase, GarbageCollectionTest1) {
1254
1255 generateHexahedralMesh(mesh_);
1256
1257 EXPECT_EQ(12u, mesh_.n_vertices());
1258 EXPECT_EQ(20u, mesh_.n_edges());
1259 EXPECT_EQ(11u, mesh_.n_faces());
1260 EXPECT_EQ(2u, mesh_.n_cells());
1261
1262 StatusAttrib status(mesh_);
1263
1264 HexVertexIter hv_it = mesh_.hv_iter(CellHandle(1));
1265
1266 EXPECT_EQ(4, hv_it->idx()); ++hv_it;
1267 EXPECT_EQ(5, hv_it->idx()); ++hv_it;
1268 EXPECT_EQ(6, hv_it->idx()); ++hv_it;
1269 EXPECT_EQ(7, hv_it->idx()); ++hv_it;
1270 EXPECT_EQ(8, hv_it->idx()); ++hv_it;
1271 EXPECT_EQ(11, hv_it->idx()); ++hv_it;
1272 EXPECT_EQ(10, hv_it->idx()); ++hv_it;
1273 EXPECT_EQ(9, hv_it->idx());
1274
1275 status[VertexHandle(0)].set_deleted(true);
1276
1277 status.garbage_collection(false);
1278
1279 EXPECT_EQ(1u, mesh_.n_cells());
1280 EXPECT_EQ(11u, mesh_.n_vertices());
1281 EXPECT_EQ(17u, mesh_.n_edges());
1282 EXPECT_EQ(8u, mesh_.n_faces());
1283
1284 hv_it = mesh_.hv_iter(CellHandle(0));
1285
1286 EXPECT_EQ(3, hv_it->idx()); ++hv_it;
1287 EXPECT_EQ(4, hv_it->idx()); ++hv_it;
1288 EXPECT_EQ(5, hv_it->idx()); ++hv_it;
1289 EXPECT_EQ(6, hv_it->idx()); ++hv_it;
1290 EXPECT_EQ(7, hv_it->idx()); ++hv_it;
1291 EXPECT_EQ(10, hv_it->idx()); ++hv_it;
1292 EXPECT_EQ(9, hv_it->idx()); ++hv_it;
1293 EXPECT_EQ(8, hv_it->idx());
1294
1295 status.garbage_collection(true);
1296
1297 EXPECT_EQ(1u, mesh_.n_cells());
1298 EXPECT_EQ(8u, mesh_.n_vertices());
1299 EXPECT_EQ(12u, mesh_.n_edges());
1300 EXPECT_EQ(6u, mesh_.n_faces());
1301
1302 hv_it = mesh_.hv_iter(CellHandle(0));
1303
1304 EXPECT_EQ(0, hv_it->idx()); ++hv_it;
1305 EXPECT_EQ(1, hv_it->idx()); ++hv_it;
1306 EXPECT_EQ(2, hv_it->idx()); ++hv_it;
1307 EXPECT_EQ(3, hv_it->idx()); ++hv_it;
1308 EXPECT_EQ(4, hv_it->idx()); ++hv_it;
1309 EXPECT_EQ(7, hv_it->idx()); ++hv_it;
1310 EXPECT_EQ(6, hv_it->idx()); ++hv_it;
1311 EXPECT_EQ(5, hv_it->idx());
1312}
1313
1314TEST_F(HexahedralMeshBase, GarbageCollectionTest2) {
1315
1316 generateHexahedralMesh(mesh_);
1317
1318 StatusAttrib status(mesh_);
1319
1320 status[VertexHandle(0)].set_deleted(true);
1321
1322 status.garbage_collection(false);
1323
1324 status.garbage_collection(false);
1325
1326 EXPECT_EQ(1u, mesh_.n_cells());
1327 EXPECT_EQ(11u, mesh_.n_vertices());
1328 EXPECT_EQ(17u, mesh_.n_edges());
1329 EXPECT_EQ(8u, mesh_.n_faces());
1330}
1331
1332TEST_F(HexahedralMeshBase, GarbageCollectionTest3) {
1333
1334 generateHexahedralMesh(mesh_);
1335
1336 StatusAttrib status(mesh_);
1337
1338 status[EdgeHandle(0)].set_deleted(true);
1339
1340 status.garbage_collection(false);
1341
1342 EXPECT_EQ(1u, mesh_.n_cells());
1343 EXPECT_EQ(12u, mesh_.n_vertices());
1344 EXPECT_EQ(19u, mesh_.n_edges());
1345 EXPECT_EQ(9u, mesh_.n_faces());
1346}
1347
1348TEST_F(HexahedralMeshBase, GarbageCollectionTest4) {
1349
1350 generateHexahedralMesh(mesh_);
1351
1352 StatusAttrib status(mesh_);
1353
1354 status[EdgeHandle(5)].set_deleted(true);
1355
1356 status.garbage_collection(false);
1357
1358 EXPECT_EQ(0u, mesh_.n_cells());
1359 EXPECT_EQ(12u, mesh_.n_vertices());
1360 EXPECT_EQ(19u, mesh_.n_edges());
1361 EXPECT_EQ(8u, mesh_.n_faces());
1362}
1363
1364TEST_F(HexahedralMeshBase, GarbageCollectionTest5) {
1365
1366 generateHexahedralMesh(mesh_);
1367
1368 StatusAttrib status(mesh_);
1369
1370 status[EdgeHandle(0)].set_deleted(true);
1371 status[EdgeHandle(1)].set_deleted(true);
1372 status[EdgeHandle(2)].set_deleted(true);
1373
1374 status.garbage_collection(true);
1375
1376 EXPECT_EQ(1u, mesh_.n_cells());
1377 EXPECT_EQ(8u, mesh_.n_vertices());
1378 EXPECT_EQ(12u, mesh_.n_edges());
1379 EXPECT_EQ(6u, mesh_.n_faces());
1380}
1381
1382TEST_F(HexahedralMeshBase, GarbageCollectionTestManifoldness1) {
1383
1384 generateHexahedralMesh(mesh_);
1385
1386 StatusAttrib status(mesh_);
1387
1388 status[VertexHandle(0)].set_deleted(true);
1389
1390 status.garbage_collection(true);
1391
1392 EXPECT_EQ(1u, mesh_.n_cells());
1393 EXPECT_EQ(6u, mesh_.n_faces());
1394 EXPECT_EQ(12u, mesh_.n_edges());
1395 EXPECT_EQ(8u, mesh_.n_vertices());
1396}
1397
1398TEST_F(HexahedralMeshBase, GarbageCollectionTestManifoldness2) {
1399
1400 generateHexahedralMesh(mesh_);
1401
1402 StatusAttrib status(mesh_);
1403
1404 status[EdgeHandle(0)].set_deleted(true);
1405
1406 status.garbage_collection(true);
1407
1408 EXPECT_EQ(1u, mesh_.n_cells());
1409 EXPECT_EQ(6u, mesh_.n_faces());
1410 EXPECT_EQ(12u, mesh_.n_edges());
1411 EXPECT_EQ(8u, mesh_.n_vertices());
1412}
1413
1414TEST_F(HexahedralMeshBase, GarbageCollectionTestManifoldness3) {
1415
1416 generateHexahedralMesh(mesh_);
1417
1418 StatusAttrib status(mesh_);
1419
1420 status[FaceHandle(0)].set_deleted(true);
1421
1422 status.garbage_collection(true);
1423
1424 EXPECT_EQ(1u, mesh_.n_cells());
1425 EXPECT_EQ(6u, mesh_.n_faces());
1426 EXPECT_EQ(12u, mesh_.n_edges());
1427 EXPECT_EQ(8u, mesh_.n_vertices());
1428}
1429
1430TEST_F(HexahedralMeshBase, GarbageCollectionTestManifoldness4) {
1431
1432 generateHexahedralMesh(mesh_);
1433
1434 StatusAttrib status(mesh_);
1435
1436 status[CellHandle(0)].set_deleted(true);
1437
1438 status.garbage_collection(true);
1439
1440 EXPECT_EQ(1u, mesh_.n_cells());
1441 EXPECT_EQ(6u, mesh_.n_faces());
1442 EXPECT_EQ(12u, mesh_.n_edges());
1443 EXPECT_EQ(8u, mesh_.n_vertices());
1444}
1445
1446TEST_F(HexahedralMeshBase, GarbageCollectionTestManifoldness5) {
1447
1448 generateHexahedralMesh(mesh_);
1449
1450 StatusAttrib status(mesh_);
1451
1452 status[EdgeHandle(5)].set_deleted(true);
1453
1454 status.garbage_collection(false);
1455
1456 EXPECT_EQ(0u, mesh_.n_cells());
1457 EXPECT_EQ(8u, mesh_.n_faces());
1458 EXPECT_EQ(19u, mesh_.n_edges());
1459 EXPECT_EQ(12u, mesh_.n_vertices());
1460
1461 status.garbage_collection(true);
1462
1463 EXPECT_EQ(0u, mesh_.n_cells());
1464 EXPECT_EQ(0u, mesh_.n_faces());
1465 EXPECT_EQ(0u, mesh_.n_edges());
1466 EXPECT_EQ(0u, mesh_.n_vertices());
1467}
1468
1469TEST_F(HexahedralMeshBase, GarbageCollectionTestTrackVertexHandles) {
1470
1471 generateHexahedralMesh(mesh_);
1472
1473 EXPECT_EQ(12u, mesh_.n_vertices());
1474 EXPECT_EQ(20u, mesh_.n_edges());
1475 EXPECT_EQ(11u, mesh_.n_faces());
1476 EXPECT_EQ(2u, mesh_.n_cells());
1477
1478 StatusAttrib status(mesh_);
1479
1480 status[VertexHandle(0)].set_deleted(true);
1481
1482 std::vector<VertexHandle> vhs;
1483 std::vector<VertexHandle*> track_vhs;
1484 std::vector<HalfEdgeHandle*> hh_empty;
1485 std::vector<HalfFaceHandle*> hfh_empty;
1486 std::vector<CellHandle*> ch_empty;
1487
1488 OpenVolumeMesh::VertexIter v_it = mesh_.vertices_begin();
1489 for (; v_it != mesh_.vertices_end(); ++v_it)
1490 vhs.push_back(*v_it);
1491
1492 for (std::vector<VertexHandle>::iterator it = vhs.begin(); it != vhs.end(); ++it)
1493 track_vhs.push_back(&(*it));
1494
1495 status.garbage_collection(track_vhs, hh_empty, hfh_empty, ch_empty, false);
1496
1497 EXPECT_HANDLE_EQ(vhs[0], VertexHandle(-1));
1498 EXPECT_HANDLE_EQ(vhs[11], VertexHandle(10));
1499
1500 EXPECT_EQ(1u, mesh_.n_cells());
1501 EXPECT_EQ(11u, mesh_.n_vertices());
1502 EXPECT_EQ(17u, mesh_.n_edges());
1503 EXPECT_EQ(8u, mesh_.n_faces());
1504}
1505
1506TEST_F(HexahedralMeshBase, GarbageCollectionTestTrackHalfedgeHandles) {
1507
1508 generateHexahedralMesh(mesh_);
1509
1510 StatusAttrib status(mesh_);
1511
1512 status[EdgeHandle(5)].set_deleted(true);
1513
1514 std::vector<HalfEdgeHandle> hhs;
1515 std::vector<VertexHandle*> vh_empty;
1516 std::vector<HalfEdgeHandle*> track_hh;
1517 std::vector<HalfFaceHandle*> hfh_empty;
1518 std::vector<CellHandle*> ch_empty;
1519
1520 OpenVolumeMesh::HalfEdgeIter hh_it = mesh_.halfedges_begin();
1521 for (; hh_it != mesh_.halfedges_end(); ++hh_it)
1522 hhs.push_back(*hh_it);
1523
1524 for (std::vector<HalfEdgeHandle>::iterator it = hhs.begin(); it != hhs.end(); ++it)
1525 track_hh.push_back(&(*it));
1526
1527 status.garbage_collection(vh_empty, track_hh, hfh_empty, ch_empty, false);
1528
1529 EXPECT_HANDLE_EQ(hhs[9], HalfFaceHandle( 9));
1530 EXPECT_HANDLE_EQ(hhs[10], HalfFaceHandle(-1));
1531 EXPECT_HANDLE_EQ(hhs[11], HalfFaceHandle(-1));
1532 EXPECT_HANDLE_EQ(hhs[12], HalfFaceHandle(10));
1533 EXPECT_HANDLE_EQ(hhs[39], HalfFaceHandle(37));
1534
1535 EXPECT_EQ(0u, mesh_.n_cells());
1536 EXPECT_EQ(8u, mesh_.n_faces());
1537 EXPECT_EQ(19u, mesh_.n_edges());
1538 EXPECT_EQ(12u, mesh_.n_vertices());
1539
1540 status.garbage_collection(vh_empty, track_hh, hfh_empty, ch_empty, true);
1541
1542 for (std::vector<HalfEdgeHandle>::iterator it = hhs.begin(); it != hhs.end(); ++it)
1543 EXPECT_EQ(it->idx(), -1);
1544
1545 EXPECT_EQ(0u, mesh_.n_cells());
1546 EXPECT_EQ(0u, mesh_.n_faces());
1547 EXPECT_EQ(0u, mesh_.n_edges());
1548 EXPECT_EQ(0u, mesh_.n_vertices());
1549}
1550
1551TEST_F(HexahedralMeshBase, GarbageCollectionTestTrackHalffaceHandles) {
1552
1553 generateHexahedralMesh(mesh_);
1554
1555 StatusAttrib status(mesh_);
1556
1557 status[FaceHandle(0)].set_deleted(true);
1558
1559 std::vector<HalfFaceHandle> hfhs;
1560 std::vector<VertexHandle*> vh_empty;
1561 std::vector<HalfEdgeHandle*> hh_empty;
1562 std::vector<HalfFaceHandle*> track_hfh;
1563 std::vector<CellHandle*> ch_empty;
1564
1565 OpenVolumeMesh::HalfFaceIter hfh_it = mesh_.halffaces_begin();
1566 for (; hfh_it != mesh_.halffaces_end(); ++hfh_it)
1567 hfhs.push_back(*hfh_it);
1568
1569 for (std::vector<HalfFaceHandle>::iterator it = hfhs.begin(); it != hfhs.end(); ++it)
1570 track_hfh.push_back(&(*it));
1571
1572 status.garbage_collection(vh_empty, hh_empty, track_hfh, ch_empty, true);
1573
1574 EXPECT_HANDLE_EQ(hfhs[0], HalfFaceHandle(-1));
1575 EXPECT_HANDLE_EQ(hfhs[1], HalfFaceHandle(-1));
1576 EXPECT_HANDLE_EQ(hfhs[2], HalfFaceHandle(0));
1577 EXPECT_HANDLE_EQ(hfhs[3], HalfFaceHandle(1));
1578 EXPECT_HANDLE_EQ(hfhs[21], HalfFaceHandle(11));
1579
1580
1581 EXPECT_EQ(1u, mesh_.n_cells());
1582 EXPECT_EQ(6u, mesh_.n_faces());
1583 EXPECT_EQ(12u, mesh_.n_edges());
1584 EXPECT_EQ(8u, mesh_.n_vertices());
1585}
1586
1587TEST_F(HexahedralMeshBase, GarbageCollectionTestTrackCellHandles) {
1588
1589 generateHexahedralMesh(mesh_);
1590
1591 StatusAttrib status(mesh_);
1592
1593 status[CellHandle(0)].set_deleted(true);
1594
1595 std::vector<CellHandle> chs;
1596 std::vector<VertexHandle*> vh_empty;
1597 std::vector<HalfEdgeHandle*> hh_empty;
1598 std::vector<HalfFaceHandle*> hfh_empty;
1599 std::vector<CellHandle*> track_ch;
1600
1601 OpenVolumeMesh::CellIter c_it = mesh_.cells_begin();
1602 for (; c_it != mesh_.cells_end(); ++c_it)
1603 chs.push_back(*c_it);
1604
1605 for (std::vector<CellHandle>::iterator it = chs.begin(); it != chs.end(); ++it)
1606 track_ch.push_back(&(*it));
1607
1608 status.garbage_collection(vh_empty, hh_empty, hfh_empty, track_ch, true);
1609
1610 EXPECT_HANDLE_EQ(chs[0], HexahedralMesh::InvalidCellHandle);
1611 EXPECT_HANDLE_EQ(chs[1], CellHandle(0));
1612
1613 EXPECT_EQ(1u, mesh_.n_cells());
1614 EXPECT_EQ(6u, mesh_.n_faces());
1615 EXPECT_EQ(12u, mesh_.n_edges());
1616 EXPECT_EQ(8u, mesh_.n_vertices());
1617}
1618
1619TEST_F(HexahedralMeshBase, GarbageCollectionTestProps1) {
1620
1621 generateHexahedralMesh(mesh_);
1622
1623 StatusAttrib status(mesh_);
1624
1625 FacePropertyT<int> fprop = mesh_.request_face_property<int>("FProp");
1626
1627 FaceHandle fh0(0);
1628 FaceHandle fh1(1);
1629 FaceHandle fh2(2);
1630 FaceHandle fh3(3);
1631 FaceHandle fh4(4);
1632 FaceHandle fh5(5);
1633 FaceHandle fh6(6);
1634 FaceHandle fh7(7);
1635 FaceHandle fh8(8);
1636 FaceHandle fh9(9);
1637 FaceHandle fh10(10);
1638
1639 fprop[fh0] = 11;
1640 fprop[fh1] = 10;
1641 fprop[fh2] = 9;
1642 fprop[fh3] = 8;
1643 fprop[fh4] = 7;
1644 fprop[fh5] = 6;
1645 fprop[fh6] = 5;
1646 fprop[fh7] = 4;
1647 fprop[fh8] = 3;
1648 fprop[fh9] = 2;
1649 fprop[fh10] = 1;
1650
1651 status[VertexHandle(0)].set_deleted(true);
1652
1653 status.garbage_collection(false);
1654
1655 EXPECT_EQ(1u, mesh_.n_cells());
1656 EXPECT_EQ(11u, mesh_.n_vertices());
1657 EXPECT_EQ(17u, mesh_.n_edges());
1658 EXPECT_EQ(8u, mesh_.n_faces());
1659
1660 std::set<int> fprops_i;
1661 for(FaceIter f_it = mesh_.f_iter(); f_it.valid(); ++f_it) {
1662 fprops_i.insert(fprop[*f_it]);
1663 }
1664
1665 EXPECT_EQ(0u, fprops_i.count(11));
1666 EXPECT_EQ(1u, fprops_i.count(10));
1667 EXPECT_EQ(1u, fprops_i.count(9));
1668 EXPECT_EQ(0u, fprops_i.count(8));
1669 EXPECT_EQ(0u, fprops_i.count(7));
1670 EXPECT_EQ(1u, fprops_i.count(6));
1671 EXPECT_EQ(1u, fprops_i.count(5));
1672 EXPECT_EQ(1u, fprops_i.count(4));
1673 EXPECT_EQ(1u, fprops_i.count(3));
1674 EXPECT_EQ(1u, fprops_i.count(2));
1675 EXPECT_EQ(1u, fprops_i.count(1));
1676}
1677
1678TEST_F(HexahedralMeshBase, GarbageCollectionTestProps2) {
1679
1680 generateHexahedralMesh(mesh_);
1681
1682 StatusAttrib status(mesh_);
1683
1684 FacePropertyT<int> fprop = mesh_.request_face_property<int>("FProp");
1685
1686 FaceHandle fh0(0);
1687 FaceHandle fh1(1);
1688 FaceHandle fh2(2);
1689 FaceHandle fh3(3);
1690 FaceHandle fh4(4);
1691 FaceHandle fh5(5);
1692 FaceHandle fh6(6);
1693 FaceHandle fh7(7);
1694 FaceHandle fh8(8);
1695 FaceHandle fh9(9);
1696 FaceHandle fh10(10);
1697
1698 fprop[fh0] = 11;
1699 fprop[fh1] = 10;
1700 fprop[fh2] = 9;
1701 fprop[fh3] = 8;
1702 fprop[fh4] = 7;
1703 fprop[fh5] = 6;
1704 fprop[fh6] = 5;
1705 fprop[fh7] = 4;
1706 fprop[fh8] = 3;
1707 fprop[fh9] = 2;
1708 fprop[fh10] = 1;
1709
1710 status[FaceHandle(0)].set_deleted(true);
1711
1712 status.garbage_collection(false);
1713
1714 EXPECT_EQ(1u, mesh_.n_cells());
1715 EXPECT_EQ(12u, mesh_.n_vertices());
1716 EXPECT_EQ(20u, mesh_.n_edges());
1717 EXPECT_EQ(10u, mesh_.n_faces());
1718
1719 std::set<int> fprops_i;
1720 for(FaceIter f_it = mesh_.f_iter(); f_it.valid(); ++f_it) {
1721 fprops_i.insert(fprop[*f_it]);
1722 }
1723
1724 EXPECT_EQ(0u, fprops_i.count(11));
1725 EXPECT_EQ(1u, fprops_i.count(10));
1726 EXPECT_EQ(1u, fprops_i.count(9));
1727 EXPECT_EQ(1u, fprops_i.count(8));
1728 EXPECT_EQ(1u, fprops_i.count(7));
1729 EXPECT_EQ(1u, fprops_i.count(6));
1730 EXPECT_EQ(1u, fprops_i.count(5));
1731 EXPECT_EQ(1u, fprops_i.count(4));
1732 EXPECT_EQ(1u, fprops_i.count(3));
1733 EXPECT_EQ(1u, fprops_i.count(2));
1734 EXPECT_EQ(1u, fprops_i.count(1));
1735}
1736
1737TEST_F(HexahedralMeshBase, HalfEdgeFetchFunction1) {
1738
1739 generateHexahedralMesh(mesh_);
1740
1741 VertexHandle v0(0);
1742 VertexHandle v1(1);
1743
1744 VertexHandle v2(2);
1745 VertexHandle v3(3);
1746
1747 VertexHandle v5(5);
1748 VertexHandle v6(6);
1749 VertexHandle v7(7);
1750
1751 HalfEdgeHandle he0 = mesh_.find_halfedge(v0, v1);
1752 HalfEdgeHandle he5 = mesh_.find_halfedge(v3, v2);
1753 HalfEdgeHandle he10 = mesh_.find_halfedge(v5, v6);
1754 HalfEdgeHandle heInv = mesh_.find_halfedge(v5, v7);
1755
1756 EXPECT_HANDLE_EQ(HalfEdgeHandle(0), he0);
1757 EXPECT_HANDLE_EQ(HalfEdgeHandle(5), he5);
1758 EXPECT_HANDLE_EQ(HalfEdgeHandle(10), he10);
1759 EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfEdgeHandle, heInv);
1760}
1761
1762TEST_F(HexahedralMeshBase, HalfFaceFetchFunction1) {
1763
1764 generateHexahedralMesh(mesh_);
1765
1766 HalfEdgeHandle he0(0);
1767 HalfEdgeHandle he2(2);
1768 HalfEdgeHandle he4(4);
1769
1770 std::vector<HalfEdgeHandle> hes;
1771 hes.push_back(he0); hes.push_back(he2);
1772
1773 HalfFaceHandle hf0_0 = mesh_.find_halfface(hes);
1774 hes.clear();
1775 hes.push_back(he0); hes.push_back(he4);
1776 HalfFaceHandle hf0_1 = mesh_.find_halfface(hes);
1777
1778 HalfEdgeHandle he16(16);
1779 HalfEdgeHandle he18(18);
1780
1781 hes.clear();
1782 hes.push_back(he16); hes.push_back(he18);
1783 HalfFaceHandle hf4_0 = mesh_.find_halfface(hes);
1784
1785 hes.clear();
1786 hes.push_back(he0); hes.push_back(he18);
1787 HalfFaceHandle hfInv = mesh_.find_halfface(hes);
1788
1789 HalfEdgeHandle he17(17);
1790 HalfEdgeHandle he19(19);
1791
1792 hes.clear();
1793 hes.push_back(he17); hes.push_back(he19);
1794 HalfFaceHandle hf5_0 = mesh_.find_halfface(hes);
1795
1796 EXPECT_HANDLE_EQ(HalfFaceHandle(0), hf0_0);
1797 EXPECT_HANDLE_EQ(HalfFaceHandle(0), hf0_1);
1798 EXPECT_HANDLE_EQ(HalfFaceHandle(4), hf4_0);
1799 EXPECT_HANDLE_EQ(HalfFaceHandle(5), hf5_0);
1800 EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfFaceHandle, hfInv);
1801}
1802
1803TEST_F(HexahedralMeshBase, HalfFaceFetchFunction2) {
1804
1805 generateHexahedralMesh(mesh_);
1806
1807 VertexHandle v0(0);
1808 VertexHandle v1(1);
1809 VertexHandle v2(2);
1810 VertexHandle v4(4);
1811 VertexHandle v5(5);
1812 VertexHandle v6(6);
1813
1814 std::vector<VertexHandle> vs;
1815 vs.push_back(v0); vs.push_back(v1); vs.push_back(v2);
1816 HalfFaceHandle hf0 = mesh_.find_halfface(vs); vs.clear();
1817
1818 vs.push_back(v2); vs.push_back(v1); vs.push_back(v0);
1819 HalfFaceHandle hf1 = mesh_.find_halfface(vs); vs.clear();
1820
1821 vs.push_back(v2); vs.push_back(v1); vs.push_back(v5);
1822 HalfFaceHandle hf4 = mesh_.find_halfface(vs); vs.clear();
1823
1824 vs.push_back(v6); vs.push_back(v5); vs.push_back(v4);
1825 HalfFaceHandle hf3 = mesh_.find_halfface(vs); vs.clear();
1826
1827 vs.push_back(v4); vs.push_back(v5); vs.push_back(v6);
1828 HalfFaceHandle hf2 = mesh_.find_halfface(vs); vs.clear();
1829
1830 vs.push_back(v0); vs.push_back(v1); vs.push_back(v4);
1831 HalfFaceHandle hfInv0 = mesh_.find_halfface(vs); vs.clear();
1832
1833 vs.push_back(v0); vs.push_back(v1); vs.push_back(v6);
1834 HalfFaceHandle hfInv1 = mesh_.find_halfface(vs); vs.clear();
1835
1836 EXPECT_HANDLE_EQ(HalfFaceHandle(0), hf0);
1837 EXPECT_HANDLE_EQ(HalfFaceHandle(1), hf1);
1838 EXPECT_HANDLE_EQ(HalfFaceHandle(4), hf4);
1839 EXPECT_HANDLE_EQ(HalfFaceHandle(3), hf3);
1840 EXPECT_HANDLE_EQ(HalfFaceHandle(2), hf2);
1841 EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfFaceHandle, hfInv0);
1842 EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfFaceHandle, hfInv1);
1843}
1844
1845TEST_F(HexahedralMeshBase, AddCellViaVerticesFunction1) {
1846
1847 generateHexahedralMesh(mesh_);
1848
1849 StatusAttrib status(mesh_);
1850
1851 status[FaceHandle(0)].set_deleted(true);
1852
1853 status.garbage_collection(false);
1854
1855 EXPECT_EQ(1u, mesh_.n_cells());
1856 EXPECT_EQ(10u, mesh_.n_faces());
1857 EXPECT_EQ(20u, mesh_.n_edges());
1858 EXPECT_EQ(12u, mesh_.n_vertices());
1859
1860 std::vector<VertexHandle> vs;
1861 vs.push_back(VertexHandle(0));
1862 vs.push_back(VertexHandle(1));
1863 vs.push_back(VertexHandle(2));
1864 vs.push_back(VertexHandle(3));
1865 vs.push_back(VertexHandle(4));
1866 vs.push_back(VertexHandle(7));
1867 vs.push_back(VertexHandle(6));
1868 vs.push_back(VertexHandle(5));
1869
1870 CellHandle ch = mesh_.add_cell(vs);
1871
1872 EXPECT_HANDLE_NE(HexahedralMesh::InvalidCellHandle, ch);
1873
1874 EXPECT_EQ(2u, mesh_.n_cells());
1875 EXPECT_EQ(11u, mesh_.n_faces());
1876 EXPECT_EQ(20u, mesh_.n_edges());
1877 EXPECT_EQ(12u, mesh_.n_vertices());
1878}
1879
1880TEST_F(HexahedralMeshBase, AddCellViaVerticesFunction2) {
1881
1882 generateHexahedralMesh(mesh_);
1883
1884 StatusAttrib status(mesh_);
1885
1886 status[FaceHandle(0)].set_deleted(true);
1887
1888 status.garbage_collection(true);
1889
1890 EXPECT_EQ(1u, mesh_.n_cells());
1891 EXPECT_EQ(6u, mesh_.n_faces());
1892 EXPECT_EQ(12u, mesh_.n_edges());
1893 EXPECT_EQ(8u, mesh_.n_vertices());
1894
1895 VertexHandle v0 = mesh_.add_vertex(Vec3d(0.0, 0.0, 0.0));
1896 VertexHandle v1 = mesh_.add_vertex(Vec3d(1.0, 0.0, 0.0));
1897 VertexHandle v2 = mesh_.add_vertex(Vec3d(1.0, 1.0, 0.0));
1898 VertexHandle v3 = mesh_.add_vertex(Vec3d(0.0, 1.0, 0.0));
1899
1900 std::vector<VertexHandle> vs;
1901 vs.push_back(v0);
1902 vs.push_back(v1);
1903 vs.push_back(v2);
1904 vs.push_back(v3);
1905 vs.push_back(VertexHandle(0));
1906 vs.push_back(VertexHandle(3));
1907 vs.push_back(VertexHandle(2));
1908 vs.push_back(VertexHandle(1));
1909
1910 CellHandle ch = mesh_.add_cell(vs);
1911
1912 EXPECT_HANDLE_NE(HexahedralMesh::InvalidCellHandle, ch);
1913
1914 EXPECT_EQ(2u, mesh_.n_cells());
1915 EXPECT_EQ(11u, mesh_.n_faces());
1916 EXPECT_EQ(20u, mesh_.n_edges());
1917 EXPECT_EQ(12u, mesh_.n_vertices());
1918}
1919
1920//===========================================================================
1921
1922TEST_F(PolyhedralMeshBase, SwapVertices) {
1923
1924 generatePolyhedralMesh(mesh_);
1925
1926 Vec3d p1(0.0, 0.0, 0.0);
1927 Vec3d p2(1.0, 0.0, 0.0);
1928 Vec3d p3(1.0, 1.0, 0.0);
1929 Vec3d p4(0.0, 1.0, 0.0);
1930
1931 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[0], p1[0]);
1932 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[1], p1[1]);
1933 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[2], p1[2]);
1934
1935 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[0], p2[0]);
1936 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[1], p2[1]);
1937 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[2], p2[2]);
1938
1939 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[0], p3[0]);
1940 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[1], p3[1]);
1941 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[2], p3[2]);
1942
1943 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[0], p4[0]);
1944 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[1], p4[1]);
1945 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[2], p4[2]);
1946
1947 EXPECT_EQ(12u, mesh_.n_vertices());
1948
1949 Vec3d p1n(1.0, 1.0, 1.0);
1950 Vec3d p2n(0.0, 1.0, 2.0);
1951 Vec3d p3n(0.0, 0.0, 3.0);
1952 Vec3d p4n(1.0, 0.0, 4.0);
1953
1954 /*
1955 * Old coordinates
1956 */
1957 Vec3d p5(0.0, 0.0, 1.0);
1958 Vec3d p6(1.0, 0.0, 1.0);
1959 Vec3d p7(1.0, 1.0, 1.0);
1960 Vec3d p8(0.0, 1.0, 1.0);
1961
1962 Vec3d p9(0.0, 0.0, 2.0);
1963 Vec3d p10(1.0, 0.0, 2.0);
1964 Vec3d p11(1.0, 1.0, 2.0);
1965 Vec3d p12(0.0, 1.0, 2.0);
1966
1967 std::vector<Vec3d> new_vertices;
1968
1969 new_vertices.push_back(p1n);
1970 new_vertices.push_back(p2n);
1971 new_vertices.push_back(p3n);
1972 new_vertices.push_back(p4n);
1973
1974 new_vertices.push_back(p5);
1975 new_vertices.push_back(p6);
1976 new_vertices.push_back(p7);
1977 new_vertices.push_back(p8);
1978 new_vertices.push_back(p9);
1979 new_vertices.push_back(p10);
1980 new_vertices.push_back(p11);
1981 new_vertices.push_back(p12);
1982
1983 mesh_.swap_vertices(new_vertices);
1984
1985 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[0], p1n[0]);
1986 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[1], p1n[1]);
1987 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(0))[2], p1n[2]);
1988
1989 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[0], p2n[0]);
1990 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[1], p2n[1]);
1991 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(1))[2], p2n[2]);
1992
1993 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[0], p3n[0]);
1994 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[1], p3n[1]);
1995 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(2))[2], p3n[2]);
1996
1997 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[0], p4n[0]);
1998 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[1], p4n[1]);
1999 EXPECT_DOUBLE_EQ(mesh_.vertex(VertexHandle(3))[2], p4n[2]);
2000
2001 EXPECT_EQ(12u, mesh_.n_vertices());
2002}
2003
2004static void testDeferredDelete(PolyhedralMesh &mesh) {
2005 mesh.add_vertex(Vec3d(1,0,0));
2006 mesh.add_vertex(Vec3d(0,1,0));
2007 mesh.delete_vertex(VertexHandle(0));
2008 mesh.collect_garbage();
2009 EXPECT_DOUBLE_EQ(mesh.vertex(VertexHandle(0))[1], 1);
2010}
2011
2012TEST_F(PolyhedralMeshBase, DeferredDelete) {
2013 mesh_.enable_deferred_deletion(true);
2014 mesh_.enable_fast_deletion(false);
2015 testDeferredDelete(mesh_);
2016}
2017TEST_F(PolyhedralMeshBase, DeferredFastDelete) {
2018 mesh_.enable_deferred_deletion(true);
2019 mesh_.enable_fast_deletion(true);
2020 testDeferredDelete(mesh_);
2021}
2022
2023
2024TEST_F(PolyhedralMeshBase, HandleDefaultConstructors) {
2025 VertexHandle vh;
2026 ASSERT_FALSE(vh.is_valid());
2027 EdgeHandle eh;
2028 ASSERT_FALSE(eh.is_valid());
2029 HalfEdgeHandle heh;
2030 ASSERT_FALSE(heh.is_valid());
2031 FaceHandle fh;
2032 ASSERT_FALSE(fh.is_valid());
2033 HalfFaceHandle hfh;
2034 ASSERT_FALSE(hfh.is_valid());
2035 CellHandle ch;
2036 ASSERT_FALSE(ch.is_valid());
2037}
2038
2039#if 0
2040TEST_F(PolyhedralMeshBase, AssignmentAndCopyConstruction) {
2041
2042 /*
2043 * Add vertices
2044 */
2045
2046 VertexHandle v0 = mesh_.add_vertex(Vec3d(1, 1, 1));
2047
2048 PolyhedralMesh copy{mesh_};
2049 EXPECT_EQ(copy.n_vertices(), mesh_.n_vertices());
2050 EXPECT_EQ(copy.vertex(v0)[0], 1);
2051 mesh_.set_vertex(v0, Vec3d(2, 2, 2));
2052 EXPECT_EQ(copy.vertex(v0)[0], 1);
2053
2054 PolyhedralMesh assigned;
2055 assigned = mesh_;
2056 EXPECT_EQ(assigned.vertex(v0)[0], 2);
2057 assigned.set_vertex(v0, Vec3d(3, 3, 3));
2058 EXPECT_EQ(mesh_.vertex(v0)[0], 2);
2059
2060 PolyhedralMesh moved;
2061 moved = std::move(std::move(mesh_));
2062 EXPECT_EQ(moved.vertex(v0)[0], 2);
2063
2064 PolyhedralMesh move_constructed{std::move(copy)};
2065 EXPECT_EQ(move_constructed.vertex(v0)[0], 1);
2066
2067}
2068#endif
OpenMesh::PolyMeshT::add_vertex
SmartVertexHandle add_vertex(const Point _p)
Definition PolyMeshT.hh:255
OpenVolumeMesh::GeometryKernel::set_vertex
void set_vertex(VertexHandle _vh, const VecT &_p)
Set the coordinates of point _vh.
Definition GeometryKernel.hh:119
OpenVolumeMesh::GeometryKernel::vertex
const VecT & vertex(VertexHandle _vh) const
Get point _vh's coordinates.
Definition GeometryKernel.hh:127
OpenVolumeMesh::HexVertexIter
Iterate over all vertices of a hexahedron in a specific order.
Definition HexahedralMeshIterators.hh:170