OpenMesh

- Main Page
- Related Pages
- Modules
- Namespaces
- Classes
- Files

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
unittests_property.hh
1 #ifndef INCLUDE_UNITTESTS_PROPERTY_HH
2 #define INCLUDE_UNITTESTS_PROPERTY_HH
3
4 #include <gtest/gtest.h>
5 #include <Unittests/unittests_common.hh>
6
7 class OpenMeshProperties : public OpenMeshBase {
8
9 protected:
10
11 // This function is called before each test is run
12 virtual void SetUp() {
13
14 // Do some initial stuff with the member data here...
15 }
16
17 // This function is called after all tests are through
18 virtual void TearDown() {
19
20 // Do some final stuff with the member data here...
21 }
22
23 // Member already defined in OpenMeshBase
24 //Mesh mesh_;
25 };
26
27 /*
28 * ====================================================================
29 * Define tests below
30 * ====================================================================
31 */
32
33 /* Creates a double property and checks if it works
34 */
35 TEST_F(OpenMeshProperties, VertexPropertyCheckDouble) {
36
37 mesh_.clear();
38
39 // Add some vertices
40 Mesh::VertexHandle vhandle[4];
41
42 vhandle[0] = mesh_.add_vertex(Mesh::Point(0, 0, 0));
43 vhandle[1] = mesh_.add_vertex(Mesh::Point(0, 1, 0));
44 vhandle[2] = mesh_.add_vertex(Mesh::Point(1, 1, 0));
45 vhandle[3] = mesh_.add_vertex(Mesh::Point(1, 0, 0));
46
47 // Add two faces
48 std::vector<Mesh::VertexHandle> face_vhandles;
49
50 face_vhandles.push_back(vhandle[2]);
51 face_vhandles.push_back(vhandle[1]);
52 face_vhandles.push_back(vhandle[0]);
53 mesh_.add_face(face_vhandles);
54
55 face_vhandles.clear();
56
57 face_vhandles.push_back(vhandle[2]);
58 face_vhandles.push_back(vhandle[0]);
59 face_vhandles.push_back(vhandle[3]);
60 mesh_.add_face(face_vhandles);
61
62 // Test setup:
63 // 1 === 2
64 // | / |
65 // | / |
66 // | / |
67 // 0 === 3
68
69 // Check setup
70 EXPECT_EQ(4u, mesh_.n_vertices() ) << "Wrong number of vertices";
71 EXPECT_EQ(2u, mesh_.n_faces() ) << "Wrong number of faces";
72
73 // Add a double vertex property
74 OpenMesh::VPropHandleT<double> doubleHandle;
75
76 EXPECT_FALSE( mesh_.get_property_handle(doubleHandle,"doubleProp") );
77
78 mesh_.add_property(doubleHandle,"doubleProp");
79
80 EXPECT_TRUE(mesh_.get_property_handle(doubleHandle,"doubleProp"));
81
82
83 // Fill property
84 double index = 0.0;
85
86 for ( Mesh::VertexIter v_it = mesh_.vertices_begin() ; v_it != mesh_.vertices_end(); ++v_it ) {
87 mesh_.property(doubleHandle,v_it) = index;
88 index += 1.0;
89 }
90
91 // Check if it is ok.
92 Mesh::VertexIter v_it = mesh_.vertices_begin();
93 EXPECT_EQ( mesh_.property(doubleHandle,v_it) , 0.0 ) << "Invalid double value for vertex 0";
94 ++v_it;
95
96 EXPECT_EQ( mesh_.property(doubleHandle,v_it) , 1.0 ) << "Invalid double value for vertex 1";
97 ++v_it;
98
99 EXPECT_EQ( mesh_.property(doubleHandle,v_it) , 2.0 ) << "Invalid double value for vertex 2";
100 ++v_it;
101
102 EXPECT_EQ( mesh_.property(doubleHandle,v_it) , 3.0 ) << "Invalid double value for vertex 3";
103
104 // Try to get the stl iterators:
105 std::vector<double>::iterator it=mesh_.property(doubleHandle).data_vector().begin();
106 std::vector<double>::iterator end=mesh_.property(doubleHandle).data_vector().end();
107
108 EXPECT_EQ( *it , 0.0 ) << "Invalid double value for vertex 0";
109 ++it;
110
111 EXPECT_EQ( *it , 1.0 ) << "Invalid double value for vertex 1";
112 ++it;
113
114 EXPECT_EQ( *it , 2.0 ) << "Invalid double value for vertex 2";
115 ++it;
116
117 EXPECT_EQ( *it , 3.0 ) << "Invalid double value for vertex 3";
118 ++it;
119
120 EXPECT_EQ( it, end ) << "End iterator not mathing!";
121
122 }
123
124 /* Creates a bool property and checks if it works
125 */
126 TEST_F(OpenMeshProperties, VertexPropertyCheckBool) {
127
128 mesh_.clear();
129
130 // Add some vertices
131 Mesh::VertexHandle vhandle[4];
132
133 vhandle[0] = mesh_.add_vertex(Mesh::Point(0, 0, 0));
134 vhandle[1] = mesh_.add_vertex(Mesh::Point(0, 1, 0));
135 vhandle[2] = mesh_.add_vertex(Mesh::Point(1, 1, 0));
136 vhandle[3] = mesh_.add_vertex(Mesh::Point(1, 0, 0));
137
138 // Add two faces
139 std::vector<Mesh::VertexHandle> face_vhandles;
140
141 face_vhandles.push_back(vhandle[2]);
142 face_vhandles.push_back(vhandle[1]);
143 face_vhandles.push_back(vhandle[0]);
144 mesh_.add_face(face_vhandles);
145
146 face_vhandles.clear();
147
148 face_vhandles.push_back(vhandle[2]);
149 face_vhandles.push_back(vhandle[0]);
150 face_vhandles.push_back(vhandle[3]);
151 mesh_.add_face(face_vhandles);
152
153 // Test setup:
154 // 1 === 2
155 // | / |
156 // | / |
157 // | / |
158 // 0 === 3
159
160 // Check setup
161 EXPECT_EQ(4u, mesh_.n_vertices() ) << "Wrong number of vertices";
162 EXPECT_EQ(2u, mesh_.n_faces() ) << "Wrong number of faces";
163
164 // Add a double vertex property
165 OpenMesh::VPropHandleT<bool> boolHandle;
166
167 EXPECT_FALSE( mesh_.get_property_handle(boolHandle,"boolProp") );
168
169 mesh_.add_property(boolHandle,"boolProp");
170
171 EXPECT_TRUE(mesh_.get_property_handle(boolHandle,"boolProp"));
172
173 // Fill property
174 bool current = true;
175
176 for ( Mesh::VertexIter v_it = mesh_.vertices_begin() ; v_it != mesh_.vertices_end(); ++v_it ) {
177 mesh_.property(boolHandle,v_it) = current;
178 current = !current;
179 }
180
181 // Check if it is ok.
182 Mesh::VertexIter v_it = mesh_.vertices_begin();
183 EXPECT_TRUE( mesh_.property(boolHandle,v_it) ) << "Invalid bool value for vertex 0";
184 ++v_it;
185
186 EXPECT_FALSE( mesh_.property(boolHandle,v_it) ) << "Invalid bool value for vertex 1";
187 ++v_it;
188
189 EXPECT_TRUE( mesh_.property(boolHandle,v_it) ) << "Invalid bool value for vertex 2";
190 ++v_it;
191
192 EXPECT_FALSE( mesh_.property(boolHandle,v_it) ) << "Invalid bool value for vertex 3";
193
194 // Try to get the stl iterators:
195 std::vector<bool>::iterator it=mesh_.property(boolHandle).data_vector().begin();
196 std::vector<bool>::iterator end=mesh_.property(boolHandle).data_vector().end();
197
198 EXPECT_TRUE( *it ) << "Invalid bool value for vertex 0";
199 ++it;
200
201 EXPECT_FALSE( *it ) << "Invalid bool value for vertex 1";
202 ++it;
203
204 EXPECT_TRUE( *it ) << "Invalid bool value for vertex 2";
205 ++it;
206
207 EXPECT_FALSE( *it ) << "Invalid bool value for vertex 3";
208 ++it;
209
210 EXPECT_EQ( it, end ) << "End iterator not mathing!";
211
212 }
213
214 /* Creates an int property and checks if it the copy operation works
215 */
216 TEST_F(OpenMeshProperties, VertexPropertyCopypropertiesInt) {
217
218 mesh_.clear();
219
220 // Add some vertices
221 Mesh::VertexHandle vhandle[4];
222
223 vhandle[0] = mesh_.add_vertex(Mesh::Point(0, 0, 0));
224 vhandle[1] = mesh_.add_vertex(Mesh::Point(0, 1, 0));
225 vhandle[2] = mesh_.add_vertex(Mesh::Point(1, 1, 0));
226 vhandle[3] = mesh_.add_vertex(Mesh::Point(1, 0, 0));
227
228 // Add two faces
229 std::vector<Mesh::VertexHandle> face_vhandles;
230
231 face_vhandles.push_back(vhandle[2]);
232 face_vhandles.push_back(vhandle[1]);
233 face_vhandles.push_back(vhandle[0]);
234 mesh_.add_face(face_vhandles);
235
236 face_vhandles.clear();
237
238 face_vhandles.push_back(vhandle[2]);
239 face_vhandles.push_back(vhandle[0]);
240 face_vhandles.push_back(vhandle[3]);
241 mesh_.add_face(face_vhandles);
242
243 // Test setup:
244 // 1 === 2
245 // | / |
246 // | / |
247 // | / |
248 // 0 === 3
249
250 // Check setup
251 EXPECT_EQ(4u, mesh_.n_vertices() ) << "Wrong number of vertices";
252 EXPECT_EQ(2u, mesh_.n_faces() ) << "Wrong number of faces";
253
254 // Add a double vertex property
255 OpenMesh::VPropHandleT<int> intHandle;
256
257 EXPECT_FALSE( mesh_.get_property_handle(intHandle,"intProp") );
258
259 mesh_.add_property(intHandle,"intProp");
260
261 EXPECT_TRUE(mesh_.get_property_handle(intHandle,"intProp"));
262
263 // Fill property
264 for ( Mesh::VertexIter v_it = mesh_.vertices_begin() ; v_it != mesh_.vertices_end(); ++v_it ) {
265 mesh_.property(intHandle,v_it) = v_it.handle().idx();
266 }
267
268 // Check if property it is ok.
269 Mesh::VertexIter v_it = mesh_.vertices_begin();
270 EXPECT_EQ( 0, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 0";
271 ++v_it;
272
273 EXPECT_EQ( 1, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 1";
274 ++v_it;
275
276 EXPECT_EQ( 2, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 2";
277 ++v_it;
278
279 EXPECT_EQ( 3, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 3";
280
281 // Check vertex positions
282 v_it = mesh_.vertices_begin();
283
284 EXPECT_EQ( 0, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 0";
285 EXPECT_EQ( 0, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 0";
286 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 0";
287 ++v_it;
288
289 EXPECT_EQ( 0, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 1";
290 EXPECT_EQ( 1, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 1";
291 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 1";
292 ++v_it;
293
294 EXPECT_EQ( 1, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 2";
295 EXPECT_EQ( 1, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 2";
296 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 2";
297 ++v_it;
298
299 EXPECT_EQ( 1, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 3";
300 EXPECT_EQ( 0, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 3";
301 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 3";
302 ++v_it;
303
304 //===========================================================
305 // Copy from vertex 1 to 0, with skipping build in properties
306 //===========================================================
307 mesh_.copy_all_properties(vhandle[1], vhandle[0]);
308
309 // Check vertex positions
310 v_it = mesh_.vertices_begin();
311
312 EXPECT_EQ( 0, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 0 after copy";
313 EXPECT_EQ( 0, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 0 after copy";
314 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 0 after copy";
315 ++v_it;
316
317 EXPECT_EQ( 0, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 1 after copy";
318 EXPECT_EQ( 1, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 1 after copy";
319 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 1 after copy";
320 ++v_it;
321
322 EXPECT_EQ( 1, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 2 after copy";
323 EXPECT_EQ( 1, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 2 after copy";
324 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 2 after copy";
325 ++v_it;
326
327 EXPECT_EQ( 1, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 3 after copy";
328 EXPECT_EQ( 0, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 3 after copy";
329 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 3 after copy";
330 ++v_it;
331
332 v_it = mesh_.vertices_begin();
333 EXPECT_EQ( 1, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 0 after copy"; ++v_it;
334 EXPECT_EQ( 1, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 1 after copy"; ++v_it;
335 EXPECT_EQ( 2, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 2 after copy"; ++v_it;
336 EXPECT_EQ( 3, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 3 after copy";
337
338 //===========================================================
339 // Copy from vertex 2 to 3, including build in properties
340 //===========================================================
341 mesh_.copy_all_properties(vhandle[2], vhandle[3], true);
342
343 // Check vertex positions
344 v_it = mesh_.vertices_begin();
345
346 EXPECT_EQ( 0, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 0 after copy";
347 EXPECT_EQ( 0, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 0 after copy";
348 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 0 after copy";
349 ++v_it;
350
351 EXPECT_EQ( 0, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 1 after copy";
352 EXPECT_EQ( 1, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 1 after copy";
353 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 1 after copy";
354 ++v_it;
355
356 EXPECT_EQ( 1, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 2 after copy";
357 EXPECT_EQ( 1, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 2 after copy";
358 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 2 after copy";
359 ++v_it;
360
361 EXPECT_EQ( 1, mesh_.point(v_it)[0] ) << "Invalid x position for vertex 3 after copy";
362 EXPECT_EQ( 1, mesh_.point(v_it)[1] ) << "Invalid y position for vertex 3 after copy";
363 EXPECT_EQ( 0, mesh_.point(v_it)[2] ) << "Invalid z position for vertex 3 after copy";
364 ++v_it;
365
366 v_it = mesh_.vertices_begin();
367 EXPECT_EQ( 1, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 0 after copy"; ++v_it;
368 EXPECT_EQ( 1, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 1 after copy"; ++v_it;
369 EXPECT_EQ( 2, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 2 after copy"; ++v_it;
370 EXPECT_EQ( 2, mesh_.property(intHandle,v_it) ) << "Invalid int value for vertex 3 after copy";
371
372
373 }
374
375 /*
376 * Checking for deleted flags of halfedge and edge handles
377 *
378 * Checks if after deleting a face, all halfedges and edges are arked as deleted as well
379 */
380 TEST_F(OpenMeshProperties, CheckStatusPropertiesHalfedgeEdgeAllDeleted) {
381
382 mesh_.clear();
383
384 mesh_.request_vertex_status();
385 mesh_.request_face_status();
386 mesh_.request_halfedge_status();
387 mesh_.request_edge_status();
388
389 // Define positions
390 Mesh::Point p1 = Mesh::Point(0, 0, 0);
391 Mesh::Point p2 = Mesh::Point(0, 1, 0);
392 Mesh::Point p3 = Mesh::Point(1, 1, 0);
393 Mesh::Point p4 = Mesh::Point(0, 0, 1);
394
395 // Add some vertices
396 Mesh::VertexHandle vh1 = mesh_.add_vertex(p1);
397 Mesh::VertexHandle vh2 = mesh_.add_vertex(p2);
398 Mesh::VertexHandle vh3 = mesh_.add_vertex(p3);
399 Mesh::VertexHandle vh4 = mesh_.add_vertex(p4);
400
401 // Add some faces
402 Mesh::FaceHandle f1 = mesh_.add_face(vh1,vh3,vh2);
403 Mesh::FaceHandle f2 = mesh_.add_face(vh1,vh2,vh4);
404 Mesh::FaceHandle f3 = mesh_.add_face(vh2,vh3,vh4);
405 Mesh::FaceHandle f4 = mesh_.add_face(vh3,vh1,vh4);
406
407 // delete all faces
408 mesh_.delete_face(f1);
409 mesh_.delete_face(f2);
410 mesh_.delete_face(f3);
411 mesh_.delete_face(f4);
412
413 for( Mesh::ConstHalfedgeIter he_it = mesh_.halfedges_begin(); he_it != mesh_.halfedges_end(); ++he_it)
414 {
415 EXPECT_TRUE( mesh_.status(mesh_.edge_handle(he_it.handle())).deleted() ) << "Edge not deleted";
416 EXPECT_TRUE( mesh_.status(he_it.handle()).deleted() ) << "Halfedge not deleted";
417 }
418
419 }
420
421
422 #endif // INCLUDE GUARD