1 #include "unittests_common.hh" 3 #include <OpenVolumeMesh/Attribs/StatusAttrib.hh> 4 #include <OpenVolumeMesh/Attribs/NormalAttrib.hh> 5 #include <OpenVolumeMesh/Attribs/ColorAttrib.hh> 8 using namespace Geometry;
31 EXPECT_EQ(8u, mesh_.n_vertices()) <<
"The number of vertices is not correct!";
37 std::vector<VertexHandle> fvertices;
39 fvertices.push_back(v3);
40 fvertices.push_back(v2);
41 fvertices.push_back(v1);
42 fvertices.push_back(v0);
44 FaceHandle fh0 = mesh_.add_face(fvertices);
48 fvertices.push_back(v4);
49 fvertices.push_back(v5);
50 fvertices.push_back(v6);
51 fvertices.push_back(v7);
53 FaceHandle fh1 = mesh_.add_face(fvertices);
57 fvertices.push_back(v0);
58 fvertices.push_back(v4);
59 fvertices.push_back(v7);
60 fvertices.push_back(v3);
62 FaceHandle fh2 = mesh_.add_face(fvertices);
66 fvertices.push_back(v1);
67 fvertices.push_back(v2);
68 fvertices.push_back(v6);
69 fvertices.push_back(v5);
71 FaceHandle fh3 = mesh_.add_face(fvertices);
75 fvertices.push_back(v7);
76 fvertices.push_back(v6);
77 fvertices.push_back(v2);
78 fvertices.push_back(v3);
80 FaceHandle fh4 = mesh_.add_face(fvertices);
84 fvertices.push_back(v0);
85 fvertices.push_back(v1);
86 fvertices.push_back(v5);
87 fvertices.push_back(v4);
89 FaceHandle fh5 = mesh_.add_face(fvertices);
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!";
98 std::vector<HalfFaceHandle> chfaces;
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));
107 mesh_.add_cell(chfaces);
109 EXPECT_EQ(1u, mesh_.n_cells()) <<
"The number of cells is not correct!";
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);
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);
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);
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);
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());
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());
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());
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());
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);
218 EXPECT_HANDLE_EQ(FaceHandle(0), f1);
221 std::vector<HalfEdgeHandle> halfedges = mesh_.face(f1).halfedges();
223 std::vector<HalfEdgeHandle>::iterator it = halfedges.begin();
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));
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));
235 FaceHandle fI = mesh_.add_face(halfedges,
true);
237 EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidFaceHandle, fI);
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));
244 FaceHandle f2 = mesh_.add_face(halfedges);
246 EXPECT_HANDLE_EQ(FaceHandle(1), f2);
249 halfedges = mesh_.face(f2).halfedges();
251 for(it = halfedges.begin(); it != halfedges.end(); ++it) {
252 EXPECT_HANDLE_EQ(
EdgeHandle(handle), mesh_.edge_handle(*it)); handle++;
264 std::vector<VertexHandle> vertices;
267 vertices.push_back(v0); vertices.push_back(v1);vertices.push_back(v3);
268 FaceHandle f0 = mesh_.add_face(vertices);
271 vertices.push_back(v1); vertices.push_back(v2);vertices.push_back(v3);
272 FaceHandle f1 = mesh_.add_face(vertices);
275 vertices.push_back(v0); vertices.push_back(v1);vertices.push_back(v2);
276 FaceHandle f2 = mesh_.add_face(vertices);
279 vertices.push_back(v0); vertices.push_back(v3);vertices.push_back(v2);
280 FaceHandle f3 = mesh_.add_face(vertices);
282 std::vector<HalfFaceHandle> halffaces;
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));
300 std::vector<VertexHandle> vertices;
303 vertices.push_back(v0); vertices.push_back(v1);vertices.push_back(v3);
304 FaceHandle f0 = mesh_.add_face(vertices);
307 vertices.push_back(v1); vertices.push_back(v2);vertices.push_back(v3);
308 FaceHandle f1 = mesh_.add_face(vertices);
311 vertices.push_back(v0); vertices.push_back(v1);vertices.push_back(v2);
312 FaceHandle f2 = mesh_.add_face(vertices);
315 vertices.push_back(v0); vertices.push_back(v3);vertices.push_back(v2);
316 FaceHandle f3 = mesh_.add_face(vertices);
318 std::vector<HalfFaceHandle> halffaces;
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));
339 std::vector<VertexHandle> fvertices;
341 fvertices.push_back(v3);
342 fvertices.push_back(v2);
343 fvertices.push_back(v1);
344 fvertices.push_back(v0);
346 FaceHandle fh0 = mesh_.add_face(fvertices);
350 fvertices.push_back(v4);
351 fvertices.push_back(v5);
352 fvertices.push_back(v6);
353 fvertices.push_back(v7);
355 FaceHandle fh1 = mesh_.add_face(fvertices);
359 fvertices.push_back(v0);
360 fvertices.push_back(v4);
361 fvertices.push_back(v7);
362 fvertices.push_back(v3);
364 FaceHandle fh2 = mesh_.add_face(fvertices);
368 fvertices.push_back(v1);
369 fvertices.push_back(v2);
370 fvertices.push_back(v6);
371 fvertices.push_back(v5);
373 FaceHandle fh3 = mesh_.add_face(fvertices);
377 fvertices.push_back(v7);
378 fvertices.push_back(v6);
379 fvertices.push_back(v2);
380 fvertices.push_back(v3);
382 FaceHandle fh4 = mesh_.add_face(fvertices);
386 fvertices.push_back(v0);
387 fvertices.push_back(v1);
388 fvertices.push_back(v5);
389 fvertices.push_back(v4);
391 FaceHandle fh5 = mesh_.add_face(fvertices);
393 std::vector<HalfFaceHandle> chfaces;
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));
402 EXPECT_HANDLE_NE(HexahedralMesh::InvalidCellHandle, mesh_.add_cell(chfaces,
true));
416 std::vector<VertexHandle> fvertices;
418 fvertices.push_back(v3);
419 fvertices.push_back(v2);
420 fvertices.push_back(v1);
421 fvertices.push_back(v0);
423 FaceHandle fh0 = mesh_.add_face(fvertices);
427 fvertices.push_back(v4);
428 fvertices.push_back(v5);
429 fvertices.push_back(v6);
430 fvertices.push_back(v7);
432 FaceHandle fh1 = mesh_.add_face(fvertices);
436 fvertices.push_back(v0);
437 fvertices.push_back(v4);
438 fvertices.push_back(v7);
439 fvertices.push_back(v3);
441 FaceHandle fh2 = mesh_.add_face(fvertices);
445 fvertices.push_back(v1);
446 fvertices.push_back(v2);
447 fvertices.push_back(v6);
448 fvertices.push_back(v5);
450 FaceHandle fh3 = mesh_.add_face(fvertices);
454 fvertices.push_back(v7);
455 fvertices.push_back(v6);
456 fvertices.push_back(v2);
457 fvertices.push_back(v3);
459 FaceHandle fh4 = mesh_.add_face(fvertices);
463 fvertices.push_back(v0);
464 fvertices.push_back(v1);
465 fvertices.push_back(v5);
466 fvertices.push_back(v4);
468 FaceHandle fh5 = mesh_.add_face(fvertices);
470 std::vector<HalfFaceHandle> chfaces;
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));
479 EXPECT_HANDLE_EQ(HexahedralMesh::InvalidCellHandle, mesh_.add_cell(chfaces,
true));
484 generatePolyhedralMesh(mesh_);
486 EXPECT_EQ(0, mesh_.genus());
491 generatePolyhedralMesh(mesh_);
494 std::vector<HalfFaceHandle> hfaces;
498 CellHandle i_cell = mesh_.add_cell(hfaces,
true);
500 EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidCellHandle, i_cell);
527 EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidHalfFaceHandle, ad_hf3);
535 EXPECT_HANDLE_EQ(PolyhedralMesh::InvalidHalfFaceHandle, ad_hf5);
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());
545 generatePolyhedralMesh(mesh_);
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);
553 normals.update_face_normals();
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]);
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]);
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]);
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]);
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]);
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]);
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]);
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]);
602 generatePolyhedralMesh(mesh_);
608 status[FaceHandle(1)].set_tagged(
true);
609 status[FaceHandle(4)].set_tagged(
true);
614 status[VertexHandle(3)].set_selected(
true);
615 status[VertexHandle(8)].set_selected(
true);
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());
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());
635 generatePolyhedralMesh(mesh_);
642 colors[VertexHandle(7)] =
Vec4f(1.0f, 1.0f, 0.0f, 1.0f);
645 colors[FaceHandle(4)] =
Vec4f(1.0f, 1.0f, 0.0f, 1.0f);
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]);
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]);
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]);
677 generatePolyhedralMesh(mesh_);
681 EXPECT_TRUE(mesh_.vertex_property_exists<
Vec3d>(
"VProp"));
683 for(
VertexIter v_it = mesh_.v_iter(); v_it.valid(); ++v_it) {
684 vp[*v_it] =
Vec3d(1.0, 0.0, 0.0);
687 for(
VertexIter v_it = mesh_.v_iter(); v_it.valid(); ++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]);
698 EXPECT_DOUBLE_EQ(0.0, p[0]);
699 EXPECT_DOUBLE_EQ(0.0, p[1]);
700 EXPECT_DOUBLE_EQ(0.0, p[2]);
704 EXPECT_TRUE(mesh_.edge_property_exists<
unsigned int>(
"EProp"));
707 for(
EdgeIter e_it = mesh_.e_iter(); e_it.valid(); ++e_it) {
712 for(
EdgeIter e_it = mesh_.e_iter(); e_it.valid(); ++e_it) {
713 EXPECT_EQ(i++, ep[*e_it]);
718 EXPECT_TRUE(mesh_.halfface_property_exists<
bool>(
"HFProp"));
721 for(
HalfFaceIter hf_it = mesh_.hf_iter(); hf_it.valid(); ++hf_it) {
727 for(
HalfFaceIter hf_it = mesh_.hf_iter(); hf_it.valid(); ++hf_it) {
728 EXPECT_EQ(b, hfp[*hf_it]);
735 EXPECT_TRUE(mesh_.cell_property_exists<std::string>(
"CProp"));
737 for(
CellIter c_it = mesh_.c_iter(); c_it.valid(); ++c_it) {
738 cp[*c_it] = std::string(
"MyTestString");
741 for(
CellIter c_it = mesh_.c_iter(); c_it.valid(); ++c_it) {
742 EXPECT_EQ(std::string(
"MyTestString"), cp[*c_it]);
745 EXPECT_FALSE(mesh_.halfedge_property_exists<
unsigned char>(
"HEProp"));
746 EXPECT_FALSE(mesh_.vertex_property_exists<
size_t>(
""));
751 generatePolyhedralMesh(mesh_);
756 std::for_each(mesh_.vertices_begin(), mesh_.vertices_end(), p);
758 std::for_each(mesh_.edges_begin(), mesh_.edges_end(), p);
760 std::for_each(mesh_.halfedges_begin(), mesh_.halfedges_end(), p);
762 std::for_each(mesh_.faces_begin(), mesh_.faces_end(), p);
764 std::for_each(mesh_.halffaces_begin(), mesh_.halffaces_end(), p);
766 std::for_each(mesh_.cells_begin(), mesh_.cells_end(), p);
771 generatePolyhedralMesh(mesh_);
773 std::vector<HalfFaceHandle> hfs = mesh_.cell(
CellHandle(0)).halffaces();
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));
785 generatePolyhedralMesh(mesh_);
787 std::vector<HalfEdgeHandle> hes = mesh_.face(FaceHandle(0)).halfedges();
789 std::vector<HalfFaceHandle> ihfs[4];
791 for(
size_t i = 0; i < 4; ++i) {
796 if(mesh_.face_handle(hfh) == FaceHandle(0))
continue;
798 hfh.idx((hfh.idx() > mesh_.halfface_handle(FaceHandle(0), 1).idx() ? hfh.idx() - 2 : hfh.idx()));
800 ihfs[i].push_back(hfh);
804 mesh_.delete_face(FaceHandle(0));
806 std::set<HalfFaceHandle> nihfs[4];
807 for(
size_t i = 0; i < 4; ++i) {
809 nihfs[i].insert(*hehf_it);
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());
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);
828 generatePolyhedralMesh(mesh_);
830 VertexHandle vh0 = mesh_.edge(
EdgeHandle(0)).from_vertex();
831 VertexHandle vh1 = mesh_.edge(
EdgeHandle(0)).to_vertex();
833 std::vector<HalfEdgeHandle> hes0;
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()));
839 std::vector<HalfEdgeHandle> hes1;
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()));
847 std::set<HalfEdgeHandle> nhes0;
849 nhes0.insert(*voh_it);
852 std::set<HalfEdgeHandle> nhes1;
854 nhes1.insert(*voh_it);
857 EXPECT_EQ(hes0.size(), nhes0.size());
858 EXPECT_EQ(hes1.size(), nhes1.size());
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);
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);
873 generatePolyhedralMesh(mesh_);
875 mesh_.enable_bottom_up_incidences(
false);
877 std::vector<HalfFaceHandle> hfs = mesh_.cell(
CellHandle(0)).halffaces();
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));
889 generatePolyhedralMesh(mesh_);
891 mesh_.enable_bottom_up_incidences(
false);
893 std::vector<HalfEdgeHandle> hes = mesh_.face(FaceHandle(0)).halfedges();
895 std::vector<HalfFaceHandle> ihfs[4];
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) {
900 std::vector<HalfEdgeHandle> t_hes = mesh_.halfface(*hf_it).halfedges();
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()) {
913 if(mesh_.face_handle(hfh) == FaceHandle(0))
continue;
915 hfh.idx((hfh.idx() > mesh_.halfface_handle(FaceHandle(0), 1).idx() ? hfh.idx() - 2 : hfh.idx()));
917 ihfs[i].push_back(hfh);
921 mesh_.delete_face(FaceHandle(0));
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) {
927 std::vector<HalfEdgeHandle> t_hes = mesh_.halfface(*hf_it).halfedges();
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()) {
938 nihfs[i].insert(*hf_it);
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());
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);
957 generatePolyhedralMesh(mesh_);
959 mesh_.enable_bottom_up_incidences(
false);
961 VertexHandle vh0 = mesh_.edge(
EdgeHandle(0)).from_vertex();
962 VertexHandle vh1 = mesh_.edge(
EdgeHandle(0)).to_vertex();
964 std::vector<HalfEdgeHandle> hes0;
965 for(
HalfEdgeIter he_it = mesh_.halfedges_begin(), he_end = mesh_.halfedges_end(); he_it != he_end; ++he_it) {
967 if(mesh_.halfedge(*he_it).from_vertex() == vh0) {
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()));
974 std::vector<HalfEdgeHandle> hes1;
975 for(
HalfEdgeIter he_it = mesh_.halfedges_begin(), he_end = mesh_.halfedges_end(); he_it != he_end; ++he_it) {
977 if(mesh_.halfedge(*he_it).from_vertex() == vh1) {
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()));
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);
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);
1000 EXPECT_EQ(hes0.size(), nhes0.size());
1001 EXPECT_EQ(hes1.size(), nhes1.size());
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);
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);
1016 generatePolyhedralMesh(mesh_);
1019 he_it != mesh_.halfedges_end(); ++he_it) {
1021 const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1022 const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1024 EXPECT_LE(fromVertex.idx(), 11);
1025 EXPECT_LE(toVertex.idx(), 11);
1028 mesh_.delete_vertex(VertexHandle(11));
1031 he_it != mesh_.halfedges_end(); ++he_it) {
1033 const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1034 const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1036 EXPECT_LE(fromVertex.idx(), 10);
1037 EXPECT_LE(toVertex.idx(), 10);
1043 generatePolyhedralMesh(mesh_);
1046 f_it != mesh_.halffaces_end(); ++f_it) {
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);
1058 f_it != mesh_.halffaces_end(); ++f_it) {
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);
1070 generatePolyhedralMesh(mesh_);
1073 c_it != mesh_.cells_end(); ++c_it) {
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);
1083 mesh_.delete_face(FaceHandle(10));
1086 c_it != mesh_.cells_end(); ++c_it) {
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);
1099 generatePolyhedralMesh(mesh_);
1101 mesh_.enable_bottom_up_incidences(
false);
1104 he_it != mesh_.halfedges_end(); ++he_it) {
1106 const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1107 const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1109 EXPECT_LE(fromVertex.idx(), 11);
1110 EXPECT_LE(toVertex.idx(), 11);
1113 mesh_.delete_vertex(VertexHandle(11));
1116 he_it != mesh_.halfedges_end(); ++he_it) {
1118 const VertexHandle& fromVertex = mesh_.halfedge(*he_it).from_vertex();
1119 const VertexHandle& toVertex = mesh_.halfedge(*he_it).to_vertex();
1121 EXPECT_LE(fromVertex.idx(), 10);
1122 EXPECT_LE(toVertex.idx(), 10);
1128 generatePolyhedralMesh(mesh_);
1130 mesh_.enable_bottom_up_incidences(
false);
1133 f_it != mesh_.halffaces_end(); ++f_it) {
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);
1145 f_it != mesh_.halffaces_end(); ++f_it) {
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);
1157 generatePolyhedralMesh(mesh_);
1159 mesh_.enable_bottom_up_incidences(
false);
1162 c_it != mesh_.cells_end(); ++c_it) {
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);
1172 mesh_.delete_face(FaceHandle(10));
1175 c_it != mesh_.cells_end(); ++c_it) {
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);
1192 generateHexahedralMesh(mesh_);
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());
1206 EXPECT_HANDLE_EQ(
HalfFaceHandle(12), mesh_.opposite_halfface_handle_in_cell(
1209 EXPECT_HANDLE_EQ(
HalfFaceHandle(20), mesh_.adjacent_halfface_on_sheet(
1211 EXPECT_HANDLE_EQ(
HalfFaceHandle(21), mesh_.adjacent_halfface_on_sheet(
1214 HexahedralMesh::CellSheetCellIter csc_it = mesh_.csc_iter(
CellHandle(0), HexahedralMesh::YF);
1217 HexahedralMesh::HalfFaceSheetHalfFaceIter hfshf_it = mesh_.hfshf_iter(
HalfFaceHandle(5));
1225 generateHexahedralMesh(mesh_);
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());
1232 mesh_.delete_vertex(VertexHandle(0));
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());
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());
1253 generateHexahedralMesh(mesh_);
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());
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());
1273 status[VertexHandle(0)].set_deleted(
true);
1275 status.garbage_collection(
false);
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());
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());
1293 status.garbage_collection(
true);
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());
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());
1314 generateHexahedralMesh(mesh_);
1318 status[VertexHandle(0)].set_deleted(
true);
1320 status.garbage_collection(
false);
1322 status.garbage_collection(
false);
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());
1332 generateHexahedralMesh(mesh_);
1338 status.garbage_collection(
false);
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());
1348 generateHexahedralMesh(mesh_);
1354 status.garbage_collection(
false);
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());
1364 generateHexahedralMesh(mesh_);
1372 status.garbage_collection(
true);
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());
1382 generateHexahedralMesh(mesh_);
1386 status[VertexHandle(0)].set_deleted(
true);
1388 status.garbage_collection(
true);
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());
1398 generateHexahedralMesh(mesh_);
1404 status.garbage_collection(
true);
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());
1414 generateHexahedralMesh(mesh_);
1418 status[FaceHandle(0)].set_deleted(
true);
1420 status.garbage_collection(
true);
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());
1430 generateHexahedralMesh(mesh_);
1436 status.garbage_collection(
true);
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());
1446 generateHexahedralMesh(mesh_);
1452 status.garbage_collection(
false);
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());
1459 status.garbage_collection(
true);
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());
1469 generateHexahedralMesh(mesh_);
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());
1478 status[VertexHandle(0)].set_deleted(
true);
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;
1487 for (; v_it != mesh_.vertices_end(); ++v_it)
1488 vhs.push_back(*v_it);
1490 for (std::vector<VertexHandle>::iterator it = vhs.begin(); it != vhs.end(); ++it)
1491 track_vhs.push_back(&(*it));
1493 status.garbage_collection(track_vhs, hh_empty, hfh_empty, ch_empty,
false);
1495 EXPECT_HANDLE_EQ(vhs[0], VertexHandle(-1));
1496 EXPECT_HANDLE_EQ(vhs[11], VertexHandle(10));
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());
1506 generateHexahedralMesh(mesh_);
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;
1519 for (; hh_it != mesh_.halfedges_end(); ++hh_it)
1520 hhs.push_back(*hh_it);
1522 for (std::vector<HalfEdgeHandle>::iterator it = hhs.begin(); it != hhs.end(); ++it)
1523 track_hh.push_back(&(*it));
1525 status.garbage_collection(vh_empty, track_hh, hfh_empty, ch_empty,
false);
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());
1538 status.garbage_collection(vh_empty, track_hh, hfh_empty, ch_empty,
true);
1540 for (std::vector<HalfEdgeHandle>::iterator it = hhs.begin(); it != hhs.end(); ++it)
1541 EXPECT_EQ(it->idx(), -1);
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());
1551 generateHexahedralMesh(mesh_);
1555 status[FaceHandle(0)].set_deleted(
true);
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;
1564 for (; hfh_it != mesh_.halffaces_end(); ++hfh_it)
1565 hfhs.push_back(*hfh_it);
1567 for (std::vector<HalfFaceHandle>::iterator it = hfhs.begin(); it != hfhs.end(); ++it)
1568 track_hfh.push_back(&(*it));
1570 status.garbage_collection(vh_empty, hh_empty, track_hfh, ch_empty,
true);
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());
1587 generateHexahedralMesh(mesh_);
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;
1600 for (; c_it != mesh_.cells_end(); ++c_it)
1601 chs.push_back(*c_it);
1603 for (std::vector<CellHandle>::iterator it = chs.begin(); it != chs.end(); ++it)
1604 track_ch.push_back(&(*it));
1606 status.garbage_collection(vh_empty, hh_empty, hfh_empty, track_ch,
true);
1608 EXPECT_HANDLE_EQ(chs[0], HexahedralMesh::InvalidCellHandle);
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());
1619 generateHexahedralMesh(mesh_);
1635 FaceHandle fh10(10);
1649 status[VertexHandle(0)].set_deleted(
true);
1651 status.garbage_collection(
false);
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());
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]);
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));
1678 generateHexahedralMesh(mesh_);
1694 FaceHandle fh10(10);
1708 status[FaceHandle(0)].set_deleted(
true);
1710 status.garbage_collection(
false);
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());
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]);
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));
1737 generateHexahedralMesh(mesh_);
1757 EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfEdgeHandle, heInv);
1762 generateHexahedralMesh(mesh_);
1768 std::vector<HalfEdgeHandle> hes;
1769 hes.push_back(he0); hes.push_back(he2);
1773 hes.push_back(he0); hes.push_back(he4);
1780 hes.push_back(he16); hes.push_back(he18);
1784 hes.push_back(he0); hes.push_back(he18);
1791 hes.push_back(he17); hes.push_back(he19);
1798 EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfFaceHandle, hfInv);
1803 generateHexahedralMesh(mesh_);
1812 std::vector<VertexHandle> vs;
1813 vs.push_back(v0); vs.push_back(v1); vs.push_back(v2);
1816 vs.push_back(v2); vs.push_back(v1); vs.push_back(v0);
1819 vs.push_back(v2); vs.push_back(v1); vs.push_back(v5);
1822 vs.push_back(v6); vs.push_back(v5); vs.push_back(v4);
1825 vs.push_back(v4); vs.push_back(v5); vs.push_back(v6);
1828 vs.push_back(v0); vs.push_back(v1); vs.push_back(v4);
1831 vs.push_back(v0); vs.push_back(v1); vs.push_back(v6);
1839 EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfFaceHandle, hfInv0);
1840 EXPECT_HANDLE_EQ(HexahedralMesh::InvalidHalfFaceHandle, hfInv1);
1845 generateHexahedralMesh(mesh_);
1849 status[FaceHandle(0)].set_deleted(
true);
1851 status.garbage_collection(
false);
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());
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));
1870 EXPECT_HANDLE_NE(HexahedralMesh::InvalidCellHandle, ch);
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());
1880 generateHexahedralMesh(mesh_);
1884 status[FaceHandle(0)].set_deleted(
true);
1886 status.garbage_collection(
true);
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());
1898 std::vector<VertexHandle> vs;
1903 vs.push_back(VertexHandle(0));
1904 vs.push_back(VertexHandle(3));
1905 vs.push_back(VertexHandle(2));
1906 vs.push_back(VertexHandle(1));
1910 EXPECT_HANDLE_NE(HexahedralMesh::InvalidCellHandle, ch);
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());
1922 generatePolyhedralMesh(mesh_);
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);
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]);
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]);
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]);
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]);
1945 EXPECT_EQ(12u, mesh_.n_vertices());
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);
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);
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);
1965 std::vector<Vec3d> new_vertices;
1967 new_vertices.push_back(p1n);
1968 new_vertices.push_back(p2n);
1969 new_vertices.push_back(p3n);
1970 new_vertices.push_back(p4n);
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);
1981 mesh_.swap_vertices(new_vertices);
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]);
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]);
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]);
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]);
1999 EXPECT_EQ(12u, mesh_.n_vertices());
2005 mesh.delete_vertex(VertexHandle(0));
2006 mesh.collect_garbage();
2007 EXPECT_DOUBLE_EQ(mesh.
vertex(VertexHandle(0))[1], 1);
2011 mesh_.enable_deferred_deletion(
true);
2012 mesh_.enable_fast_deletion(
false);
2013 testDeferredDelete(mesh_);
2016 mesh_.enable_deferred_deletion(
true);
2017 mesh_.enable_fast_deletion(
true);
2018 testDeferredDelete(mesh_);
2024 ASSERT_FALSE(vh.is_valid());
2026 ASSERT_FALSE(eh.is_valid());
2028 ASSERT_FALSE(heh.is_valid());
2030 ASSERT_FALSE(fh.is_valid());
2032 ASSERT_FALSE(hfh.is_valid());
2034 ASSERT_FALSE(ch.is_valid());
Iterate over all vertices of a hexahedron in a specific order.
SmartVertexHandle add_vertex(const Point &_p)
Alias for new_vertex(const Point&).
const VecT & vertex(const VertexHandle &_vh) const
Get point _vh's coordinates.
VertexHandle add_vertex() override
Override of empty add_vertex function.