Developer Documentation
Loading...
Searching...
No Matches
unittests_iterators.cc
1#include "unittests_common.hh"
2
3
4using namespace OpenVolumeMesh;
5
6TEST_F(HexahedralMeshBase, HexVertexIterTest) {
7
8 generateHexahedralMesh(mesh_);
9
10 HexVertexIter hv_it = mesh_.hv_iter(CellHandle(0));
11
12 EXPECT_TRUE(hv_it.valid());
13
14 EXPECT_HANDLE_EQ(VertexHandle(0), *hv_it); ++hv_it;
15 EXPECT_HANDLE_EQ(VertexHandle(1), *hv_it); ++hv_it;
16 EXPECT_HANDLE_EQ(VertexHandle(2), *hv_it); ++hv_it;
17 EXPECT_HANDLE_EQ(VertexHandle(3), *hv_it); ++hv_it;
18 EXPECT_HANDLE_EQ(VertexHandle(4), *hv_it); ++hv_it;
19 EXPECT_HANDLE_EQ(VertexHandle(7), *hv_it); ++hv_it;
20 EXPECT_HANDLE_EQ(VertexHandle(6), *hv_it); ++hv_it;
21 EXPECT_HANDLE_EQ(VertexHandle(5), *hv_it);
22}
23
24TEST_F(TetrahedralMeshBase, VertexVertexIteratorTest) {
25
26 generateTetrahedralMesh(mesh_);
27
28 {
29
30 VertexVertexIter vv_it = mesh_.vv_iter(VertexHandle(0));
31
32 EXPECT_TRUE(vv_it.valid());
33
34 std::set<VertexHandle> onering;
35 int valence = 0;
36
37 while (vv_it.valid())
38 {
39 ++valence;
40 onering.insert(*vv_it);
41 ++vv_it;
42 }
43
44 // check that there have been three adjacent vertices
45 EXPECT_EQ(3, valence);
46
47 // check that no vertex was visited twice
48 EXPECT_EQ(3u, onering.size());
49
50 // check that no invalid vertex was adjacent
51 EXPECT_EQ(onering.end(), std::find(onering.begin(), onering.end(), VertexHandle(-1)));
52
53 }
54
55 {
56
57 std::set<VertexHandle> onering;
58 int valence = 0;
59
60 for (auto vh : mesh_.vertex_vertices(VertexHandle(0)))
61 {
62 ++valence;
63 onering.insert(vh);
64 }
65
66 // check that there have been three adjacent vertices
67 EXPECT_EQ(3, valence);
68
69 // check that no vertex was visited twice
70 EXPECT_EQ(3u, onering.size());
71
72 // check that no invalid vertex was adjacent
73 EXPECT_EQ(onering.end(), std::find(onering.begin(), onering.end(), VertexHandle(-1)));
74
75 }
76
77}
78
79TEST_F(TetrahedralMeshBase, VertexFaceIteratorTest) {
80
81 generateTetrahedralMesh(mesh_);
82
83 {
84
85 VertexFaceIter vf_it = mesh_.vf_iter(VertexHandle(0));
86
87 EXPECT_TRUE(vf_it.valid());
88
89 std::set<FaceHandle> incident_faces;
90 int valence = 0;
91
92 while (vf_it.valid())
93 {
94 ++valence;
95 incident_faces.insert(*vf_it);
96 ++vf_it;
97 }
98
99 // check that there have been three adjacent vertices
100 EXPECT_EQ(3, valence);
101
102 // check that no vertex was visited twice
103 EXPECT_EQ(3u, incident_faces.size());
104
105 // check that no invalid vertex was adjacent
106 EXPECT_EQ(incident_faces.end(), std::find(incident_faces.begin(), incident_faces.end(), FaceHandle(-1)));
107
108 }
109
110 {
111
112 std::set<VertexHandle> onering;
113 int valence = 0;
114
115 for (auto vh : mesh_.vertex_vertices(VertexHandle(0)))
116 {
117 ++valence;
118 onering.insert(vh);
119 }
120
121 // check that there have been three adjacent vertices
122 EXPECT_EQ(3, valence);
123
124 // check that no vertex was visited twice
125 EXPECT_EQ(3u, onering.size());
126
127 // check that no invalid vertex was adjacent
128 EXPECT_EQ(onering.end(), std::find(onering.begin(), onering.end(), VertexHandle(-1)));
129
130 }
131
132}
133
134TEST_F(TetrahedralMeshBase, HalfFaceHalfEdgeIter)
135{
136 VertexHandle vh0 = mesh_.add_vertex(Vec3d(0.0, 0.0, 0.0));
137 VertexHandle vh1 = mesh_.add_vertex(Vec3d(1.0, 0.0, 0.0));
138 VertexHandle vh2 = mesh_.add_vertex(Vec3d(1.0, 1.0, 0.0));
139 VertexHandle vh3 = mesh_.add_vertex(Vec3d(0.0, 1.0, 0.0));
140
141 HalfFaceHandle hfh012 = mesh_.add_halfface(vh0, vh1, vh2);
142 HalfFaceHandle hfh023 = mesh_.add_halfface(vh0, vh2, vh3);
143 HalfFaceHandle hfh031 = mesh_.add_halfface(vh0, vh3, vh1);
144 HalfFaceHandle hfh132 = mesh_.add_halfface(vh1, vh3, vh2);
145
146 mesh_.add_cell({hfh012, hfh023, hfh031, hfh132});
147
148 auto hfhe_it = mesh_.hfhe_iter(hfh012);
149 ASSERT_EQ(hfhe_it.cur_handle(), mesh_.find_halfedge(vh0, vh1));
150 ++hfhe_it;
151 ASSERT_EQ(hfhe_it.cur_handle(), mesh_.find_halfedge(vh1, vh2));
152 ++hfhe_it;
153 ASSERT_EQ(hfhe_it.cur_handle(), mesh_.find_halfedge(vh2, vh0));
154
155 hfhe_it = mesh_.hfhe_iter(hfh012.opposite_handle());
156 ASSERT_EQ(hfhe_it.cur_handle(), mesh_.find_halfedge(vh0, vh2));
157 ++hfhe_it;
158 ASSERT_EQ(hfhe_it.cur_handle(), mesh_.find_halfedge(vh2, vh1));
159 ++hfhe_it;
160 ASSERT_EQ(hfhe_it.cur_handle(), mesh_.find_halfedge(vh1, vh0));
161}
162
163TEST_F(TetrahedralMeshBase, HalfFaceVertexIter)
164{
165 VertexHandle vh0 = mesh_.add_vertex(Vec3d(0.0, 0.0, 0.0));
166 VertexHandle vh1 = mesh_.add_vertex(Vec3d(1.0, 0.0, 0.0));
167 VertexHandle vh2 = mesh_.add_vertex(Vec3d(1.0, 1.0, 0.0));
168 VertexHandle vh3 = mesh_.add_vertex(Vec3d(0.0, 1.0, 0.0));
169
170 HalfFaceHandle hfh012 = mesh_.add_halfface(vh0, vh1, vh2);
171 HalfFaceHandle hfh023 = mesh_.add_halfface(vh0, vh2, vh3);
172 HalfFaceHandle hfh031 = mesh_.add_halfface(vh0, vh3, vh1);
173 HalfFaceHandle hfh132 = mesh_.add_halfface(vh1, vh3, vh2);
174
175 mesh_.add_cell({hfh012, hfh023, hfh031, hfh132});
176
177 auto hfv_it = mesh_.hfv_iter(hfh012);
178 ASSERT_EQ(hfv_it.cur_handle(), vh0);
179 ++hfv_it;
180 ASSERT_EQ(hfv_it.cur_handle(), vh1);
181 ++hfv_it;
182 ASSERT_EQ(hfv_it.cur_handle(), vh2);
183
184 hfv_it = mesh_.hfv_iter(hfh012.opposite_handle());
185 ASSERT_EQ(hfv_it.cur_handle(), vh0);
186 ++hfv_it;
187 ASSERT_EQ(hfv_it.cur_handle(), vh2);
188 ++hfv_it;
189 ASSERT_EQ(hfv_it.cur_handle(), vh1);
190}
191
192TEST_F(TetrahedralMeshBase, GetHalfFaceVerticesHfh)
193{
194 VertexHandle vh0 = mesh_.add_vertex(Vec3d(0.0, 0.0, 0.0));
195 VertexHandle vh1 = mesh_.add_vertex(Vec3d(1.0, 0.0, 0.0));
196 VertexHandle vh2 = mesh_.add_vertex(Vec3d(1.0, 1.0, 0.0));
197
198 HalfFaceHandle hfh012 = mesh_.add_halfface(vh0, vh1, vh2);
199
200 auto vhs = mesh_.get_halfface_vertices(hfh012);
201 ASSERT_EQ(vhs[0], vh0);
202 ASSERT_EQ(vhs[1], vh1);
203 ASSERT_EQ(vhs[2], vh2);
204
205 vhs = mesh_.get_halfface_vertices(hfh012.opposite_handle());
206 ASSERT_EQ(vhs[0], vh0);
207 ASSERT_EQ(vhs[1], vh2);
208 ASSERT_EQ(vhs[2], vh1);
209}
210
211TEST_F(TetrahedralMeshBase, GetHalfFaceVerticesHfhHeh)
212{
213 VertexHandle vh0 = mesh_.add_vertex(Vec3d(0.0, 0.0, 0.0));
214 VertexHandle vh1 = mesh_.add_vertex(Vec3d(1.0, 0.0, 0.0));
215 VertexHandle vh2 = mesh_.add_vertex(Vec3d(1.0, 1.0, 0.0));
216
217 HalfFaceHandle hfh012 = mesh_.add_halfface(vh0, vh1, vh2);
218
219 auto vhs = mesh_.get_halfface_vertices(hfh012, mesh_.find_halfedge(vh1, vh2));
220 ASSERT_EQ(vhs[0], vh1);
221 ASSERT_EQ(vhs[1], vh2);
222 ASSERT_EQ(vhs[2], vh0);
223
224 vhs = mesh_.get_halfface_vertices(hfh012.opposite_handle(), mesh_.find_halfedge(vh2, vh1));
225 ASSERT_EQ(vhs[0], vh2);
226 ASSERT_EQ(vhs[1], vh1);
227 ASSERT_EQ(vhs[2], vh0);
228}
229
230TEST_F(TetrahedralMeshBase, GetHalfFaceVerticesHfhVh)
231{
232 VertexHandle vh0 = mesh_.add_vertex(Vec3d(0.0, 0.0, 0.0));
233 VertexHandle vh1 = mesh_.add_vertex(Vec3d(1.0, 0.0, 0.0));
234 VertexHandle vh2 = mesh_.add_vertex(Vec3d(1.0, 1.0, 0.0));
235
236 HalfFaceHandle hfh012 = mesh_.add_halfface(vh0, vh1, vh2);
237
238 auto vhs = mesh_.get_halfface_vertices(hfh012, vh2);
239 ASSERT_EQ(vhs[0], vh2);
240 ASSERT_EQ(vhs[1], vh0);
241 ASSERT_EQ(vhs[2], vh1);
242
243 vhs = mesh_.get_halfface_vertices(hfh012.opposite_handle(), vh1);
244 ASSERT_EQ(vhs[0], vh1);
245 ASSERT_EQ(vhs[1], vh0);
246 ASSERT_EQ(vhs[2], vh2);
247}
248
249TEST_F(HexahedralMeshBase, RangeForTest) {
250 // no EXPECTs here, if it compiles, it'll work.
251 generateHexahedralMesh(mesh_);
252 VertexHandle _dummy; // use vh to avoid compiler warnings
253 for (const auto& vh: mesh_.vertices()) { _dummy = vh;}
254 const auto& constref = mesh_;
255 for (const auto& vh: constref.vertices()) { _dummy = vh;}
256}
OpenMesh::PolyMeshT::add_vertex
SmartVertexHandle add_vertex(const Point _p)
Definition PolyMeshT.hh:255
OpenVolumeMesh::HexVertexIter
Iterate over all vertices of a hexahedron in a specific order.
Definition HexahedralMeshIterators.hh:170