Developer Documentation
unittests_property.cc
1 
2 #include <gtest/gtest.h>
3 #include <Unittests/unittests_common.hh>
4 
5 namespace {
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->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 
303  //===========================================================
304  // Copy from vertex 1 to 0, with skipping build in properties
305  //===========================================================
306  mesh_.copy_all_properties(vhandle[1], vhandle[0]);
307 
308  // Check vertex positions
309  v_it = mesh_.vertices_begin();
310 
311  EXPECT_EQ( 0, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 0 after copy";
312  EXPECT_EQ( 0, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 0 after copy";
313  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 0 after copy";
314  ++v_it;
315 
316  EXPECT_EQ( 0, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 1 after copy";
317  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 1 after copy";
318  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 1 after copy";
319  ++v_it;
320 
321  EXPECT_EQ( 1, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 2 after copy";
322  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 2 after copy";
323  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 2 after copy";
324  ++v_it;
325 
326  EXPECT_EQ( 1, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 3 after copy";
327  EXPECT_EQ( 0, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 3 after copy";
328  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 3 after copy";
329 
330  v_it = mesh_.vertices_begin();
331  EXPECT_EQ( 1, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 0 after copy"; ++v_it;
332  EXPECT_EQ( 1, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 1 after copy"; ++v_it;
333  EXPECT_EQ( 2, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 2 after copy"; ++v_it;
334  EXPECT_EQ( 3, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 3 after copy";
335 
336  //===========================================================
337  // Copy from vertex 2 to 3, including build in properties
338  //===========================================================
339  mesh_.copy_all_properties(vhandle[2], vhandle[3], true);
340 
341  // Check vertex positions
342  v_it = mesh_.vertices_begin();
343 
344  EXPECT_EQ( 0, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 0 after copy";
345  EXPECT_EQ( 0, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 0 after copy";
346  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 0 after copy";
347  ++v_it;
348 
349  EXPECT_EQ( 0, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 1 after copy";
350  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 1 after copy";
351  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 1 after copy";
352  ++v_it;
353 
354  EXPECT_EQ( 1, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 2 after copy";
355  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 2 after copy";
356  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 2 after copy";
357  ++v_it;
358 
359  EXPECT_EQ( 1, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 3 after copy";
360  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 3 after copy";
361  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 3 after copy";
362 
363  v_it = mesh_.vertices_begin();
364  EXPECT_EQ( 1, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 0 after copy"; ++v_it;
365  EXPECT_EQ( 1, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 1 after copy"; ++v_it;
366  EXPECT_EQ( 2, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 2 after copy"; ++v_it;
367  EXPECT_EQ( 2, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 3 after copy";
368 
369 
370 }
371 
372 /*
373  * Checking for deleted flags of halfedge and edge handles
374  *
375  * Checks if after deleting a face, all halfedges and edges are arked as deleted as well
376 */
377 TEST_F(OpenMeshProperties, CheckStatusPropertiesHalfedgeEdgeAllDeleted) {
378 
379  mesh_.clear();
380 
381  mesh_.request_vertex_status();
382  mesh_.request_face_status();
383  mesh_.request_halfedge_status();
384  mesh_.request_edge_status();
385 
386  // Define positions
387  Mesh::Point p1 = Mesh::Point(0, 0, 0);
388  Mesh::Point p2 = Mesh::Point(0, 1, 0);
389  Mesh::Point p3 = Mesh::Point(1, 1, 0);
390  Mesh::Point p4 = Mesh::Point(0, 0, 1);
391 
392  // Add some vertices
393  Mesh::VertexHandle vh1 = mesh_.add_vertex(p1);
394  Mesh::VertexHandle vh2 = mesh_.add_vertex(p2);
395  Mesh::VertexHandle vh3 = mesh_.add_vertex(p3);
396  Mesh::VertexHandle vh4 = mesh_.add_vertex(p4);
397 
398  // Add some faces
399  Mesh::FaceHandle f1 = mesh_.add_face(vh1,vh3,vh2);
400  Mesh::FaceHandle f2 = mesh_.add_face(vh1,vh2,vh4);
401  Mesh::FaceHandle f3 = mesh_.add_face(vh2,vh3,vh4);
402  Mesh::FaceHandle f4 = mesh_.add_face(vh3,vh1,vh4);
403 
404  // delete all faces
405  mesh_.delete_face(f1);
406  mesh_.delete_face(f2);
407  mesh_.delete_face(f3);
408  mesh_.delete_face(f4);
409 
410  for( Mesh::ConstHalfedgeIter he_it = mesh_.halfedges_begin(); he_it != mesh_.halfedges_end(); ++he_it)
411  {
412  EXPECT_TRUE( mesh_.status(mesh_.edge_handle(*he_it)).deleted() ) << "Edge not deleted";
413  EXPECT_TRUE( mesh_.status(*he_it).deleted() ) << "Halfedge not deleted";
414  }
415 
416 }
417 
418 /*
419  * Copy properties from one mesh to another
420  *
421 */
422 TEST_F(OpenMeshProperties, CopyAllPropertiesVertexAfterRemoveOfProperty) {
423 
424  mesh_.clear();
425 
426  // Add some vertices
427  Mesh::VertexHandle vhandle[4];
428 
429  vhandle[0] = mesh_.add_vertex(Mesh::Point(0, 0, 0));
430  vhandle[1] = mesh_.add_vertex(Mesh::Point(0, 1, 0));
431  vhandle[2] = mesh_.add_vertex(Mesh::Point(1, 1, 0));
432  vhandle[3] = mesh_.add_vertex(Mesh::Point(1, 0, 0));
433 
434  // Add two faces
435  std::vector<Mesh::VertexHandle> face_vhandles;
436 
437  face_vhandles.push_back(vhandle[2]);
438  face_vhandles.push_back(vhandle[1]);
439  face_vhandles.push_back(vhandle[0]);
440  mesh_.add_face(face_vhandles);
441 
442  face_vhandles.clear();
443 
444  face_vhandles.push_back(vhandle[2]);
445  face_vhandles.push_back(vhandle[0]);
446  face_vhandles.push_back(vhandle[3]);
447  mesh_.add_face(face_vhandles);
448 
449  // Test setup:
450  // 1 === 2
451  // | / |
452  // | / |
453  // | / |
454  // 0 === 3
455 
456  // Check setup
457  EXPECT_EQ(4u, mesh_.n_vertices() ) << "Wrong number of vertices";
458  EXPECT_EQ(2u, mesh_.n_faces() ) << "Wrong number of faces";
459 
460  // Add a double vertex property
461  OpenMesh::VPropHandleT<double> doubleHandle;
462 
463  EXPECT_FALSE( mesh_.get_property_handle(doubleHandle,"doubleProp") );
464 
465  mesh_.add_property(doubleHandle,"doubleProp");
466 
467  EXPECT_TRUE(mesh_.get_property_handle(doubleHandle,"doubleProp"));
468 
469  // Add a double vertex property
470  OpenMesh::VPropHandleT<int> intHandle;
471 
472  EXPECT_FALSE( mesh_.get_property_handle(intHandle,"intProp") );
473 
474  mesh_.add_property(intHandle,"intProp");
475 
476  EXPECT_TRUE(mesh_.get_property_handle(intHandle,"intProp"));
477 
478  // Now remove the double property again.
479  mesh_.remove_property(doubleHandle);
480 
481  // Fill int property
482  for ( Mesh::VertexIter v_it = mesh_.vertices_begin() ; v_it != mesh_.vertices_end(); ++v_it ) {
483  mesh_.property(intHandle,*v_it) = v_it->idx();
484  }
485 
486  // Check if property it is ok.
487  Mesh::VertexIter v_it = mesh_.vertices_begin();
488  EXPECT_EQ( 0, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 0";
489  ++v_it;
490 
491  EXPECT_EQ( 1, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 1";
492  ++v_it;
493 
494  EXPECT_EQ( 2, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 2";
495  ++v_it;
496 
497  EXPECT_EQ( 3, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 3";
498 
499  // Check vertex positions
500  v_it = mesh_.vertices_begin();
501 
502  EXPECT_EQ( 0, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 0";
503  EXPECT_EQ( 0, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 0";
504  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 0";
505  ++v_it;
506 
507  EXPECT_EQ( 0, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 1";
508  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 1";
509  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 1";
510  ++v_it;
511 
512  EXPECT_EQ( 1, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 2";
513  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 2";
514  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 2";
515  ++v_it;
516 
517  EXPECT_EQ( 1, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 3";
518  EXPECT_EQ( 0, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 3";
519  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 3";
520 
521  //===========================================================
522  // Copy from vertex 1 to 0, with skipping build in properties
523  //===========================================================
524  mesh_.copy_all_properties(vhandle[1], vhandle[0]);
525 
526  // Check vertex positions
527  v_it = mesh_.vertices_begin();
528 
529  EXPECT_EQ( 0, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 0 after copy";
530  EXPECT_EQ( 0, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 0 after copy";
531  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 0 after copy";
532  ++v_it;
533 
534  EXPECT_EQ( 0, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 1 after copy";
535  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 1 after copy";
536  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 1 after copy";
537  ++v_it;
538 
539  EXPECT_EQ( 1, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 2 after copy";
540  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 2 after copy";
541  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 2 after copy";
542  ++v_it;
543 
544  EXPECT_EQ( 1, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 3 after copy";
545  EXPECT_EQ( 0, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 3 after copy";
546  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 3 after copy";
547 
548  v_it = mesh_.vertices_begin();
549  EXPECT_EQ( 1, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 0 after copy"; ++v_it;
550  EXPECT_EQ( 1, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 1 after copy"; ++v_it;
551  EXPECT_EQ( 2, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 2 after copy"; ++v_it;
552  EXPECT_EQ( 3, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 3 after copy";
553 
554  //===========================================================
555  // Copy from vertex 2 to 3, including build in properties
556  //===========================================================
557  mesh_.copy_all_properties(vhandle[2], vhandle[3], true);
558 
559  // Check vertex positions
560  v_it = mesh_.vertices_begin();
561 
562  EXPECT_EQ( 0, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 0 after copy";
563  EXPECT_EQ( 0, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 0 after copy";
564  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 0 after copy";
565  ++v_it;
566 
567  EXPECT_EQ( 0, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 1 after copy";
568  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 1 after copy";
569  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 1 after copy";
570  ++v_it;
571 
572  EXPECT_EQ( 1, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 2 after copy";
573  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 2 after copy";
574  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 2 after copy";
575  ++v_it;
576 
577  EXPECT_EQ( 1, mesh_.point(*v_it)[0] ) << "Invalid x position for vertex 3 after copy";
578  EXPECT_EQ( 1, mesh_.point(*v_it)[1] ) << "Invalid y position for vertex 3 after copy";
579  EXPECT_EQ( 0, mesh_.point(*v_it)[2] ) << "Invalid z position for vertex 3 after copy";
580 
581  v_it = mesh_.vertices_begin();
582  EXPECT_EQ( 1, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 0 after copy"; ++v_it;
583  EXPECT_EQ( 1, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 1 after copy"; ++v_it;
584  EXPECT_EQ( 2, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 2 after copy"; ++v_it;
585  EXPECT_EQ( 2, mesh_.property(intHandle,*v_it) ) << "Invalid int value for vertex 3 after copy";
586 
587 
588 
589 }
590 
591 /* Creates a double and int properties and check if we can iterate across them
592  */
593 TEST_F(OpenMeshProperties, PropertyIterators ) {
594 
595  mesh_.clear();
596 
597  // Add some vertices
598  Mesh::VertexHandle vhandle[4];
599 
600  vhandle[0] = mesh_.add_vertex(Mesh::Point(0, 0, 0));
601  vhandle[1] = mesh_.add_vertex(Mesh::Point(0, 1, 0));
602  vhandle[2] = mesh_.add_vertex(Mesh::Point(1, 1, 0));
603  vhandle[3] = mesh_.add_vertex(Mesh::Point(1, 0, 0));
604 
605  // Add two faces
606  std::vector<Mesh::VertexHandle> face_vhandles;
607 
608  face_vhandles.push_back(vhandle[2]);
609  face_vhandles.push_back(vhandle[1]);
610  face_vhandles.push_back(vhandle[0]);
611  mesh_.add_face(face_vhandles);
612 
613  face_vhandles.clear();
614 
615  face_vhandles.push_back(vhandle[2]);
616  face_vhandles.push_back(vhandle[0]);
617  face_vhandles.push_back(vhandle[3]);
618  mesh_.add_face(face_vhandles);
619 
620  // Test setup:
621  // 1 === 2
622  // | / |
623  // | / |
624  // | / |
625  // 0 === 3
626 
627  // Check setup
628  EXPECT_EQ(4u, mesh_.n_vertices() ) << "Wrong number of vertices";
629  EXPECT_EQ(2u, mesh_.n_faces() ) << "Wrong number of faces";
630 
631 
632  // Add vertex properties
633  OpenMesh::VPropHandleT<double> doubleHandleV;
634  OpenMesh::VPropHandleT<double> intHandleV;
635 
636  EXPECT_FALSE( mesh_.get_property_handle(doubleHandleV,"doublePropV") );
637  EXPECT_FALSE( mesh_.get_property_handle(intHandleV,"intPropV") );
638 
639  mesh_.add_property(doubleHandleV,"doublePropV");
640  mesh_.add_property(intHandleV,"intPropV");
641 
642  EXPECT_TRUE(mesh_.get_property_handle(doubleHandleV,"doublePropV"));
643  EXPECT_TRUE(mesh_.get_property_handle(intHandleV,"intPropV"));
644 
645  // Add a double Edge properties
646  OpenMesh::EPropHandleT<double> doubleHandleE;
647  OpenMesh::EPropHandleT<double> intHandleE;
648 
649  EXPECT_FALSE( mesh_.get_property_handle(doubleHandleE,"doublePropE") );
650  EXPECT_FALSE( mesh_.get_property_handle(intHandleE,"intPropE") );
651 
652  mesh_.add_property(doubleHandleE,"doublePropE");
653  mesh_.add_property(intHandleE,"intPropE");
654 
655  EXPECT_TRUE(mesh_.get_property_handle(doubleHandleE,"doublePropE"));
656  EXPECT_TRUE(mesh_.get_property_handle(intHandleE,"intPropE"));
657 
658 
659  // Add Face properties
660  OpenMesh::FPropHandleT<double> doubleHandleF;
661  OpenMesh::FPropHandleT<double> intHandleF;
662 
663  EXPECT_FALSE( mesh_.get_property_handle(doubleHandleF,"doublePropF") );
664  EXPECT_FALSE( mesh_.get_property_handle(intHandleF,"intPropF") );
665 
666  mesh_.add_property(doubleHandleF,"doublePropF");
667  mesh_.add_property(intHandleF,"intPropF");
668 
669  EXPECT_TRUE(mesh_.get_property_handle(doubleHandleF,"doublePropF"));
670  EXPECT_TRUE(mesh_.get_property_handle(intHandleF,"intPropF"));
671 
672 
673 
674 
675  unsigned int vertex_props = 0;
676  for (Mesh::prop_iterator vprop_it = mesh_.vprops_begin() ; vprop_it != mesh_.vprops_end(); ++vprop_it) {
677  switch (vertex_props) {
678  case 0:
679  EXPECT_EQ ("v:points",(*vprop_it)->name()) << "Wrong Vertex property name";
680  break;
681  case 1:
682  EXPECT_EQ ("<vprop>",(*vprop_it)->name()) << "Wrong Vertex property name";
683  break;
684  case 2:
685  EXPECT_EQ ("doublePropV",(*vprop_it)->name()) << "Wrong Vertex property name";
686  break;
687  case 3:
688  EXPECT_EQ ("intPropV",(*vprop_it)->name()) << "Wrong Vertex property name";
689  break;
690  default:
691  EXPECT_EQ (4u , vertex_props);
692  break;
693  }
694  ++vertex_props;
695  }
696 
697  EXPECT_EQ (4u,vertex_props) << "Wrong number of vertex properties";
698 
699 
700 
701  unsigned int edge_props = 0;
702  for (Mesh::prop_iterator eprop_it = mesh_.eprops_begin() ; eprop_it != mesh_.eprops_end(); ++eprop_it) {
703  switch (edge_props) {
704  case 0:
705  EXPECT_EQ ("<eprop>",(*eprop_it)->name()) << "Wrong Edge property name";
706  break;
707  case 1:
708  EXPECT_EQ ("doublePropE",(*eprop_it)->name()) << "Wrong Edge property name";
709  break;
710  case 2:
711  EXPECT_EQ ("intPropE",(*eprop_it)->name()) << "Wrong Edge property name";
712  break;
713  default:
714  EXPECT_EQ (4u , edge_props);
715  break;
716  }
717  ++edge_props;
718  }
719 
720  EXPECT_EQ (3u,edge_props) << "Wrong number of edge properties";
721 
722 
723 
724  unsigned int face_props = 0;
725  for (Mesh::prop_iterator prop_it = mesh_.fprops_begin() ; prop_it != mesh_.fprops_end(); ++prop_it) {
726  switch (face_props) {
727  case 0:
728  EXPECT_EQ ("<fprop>",(*prop_it)->name()) << "Wrong Face property name";
729  break;
730  case 1:
731  EXPECT_EQ ("doublePropF",(*prop_it)->name()) << "Wrong Face property name";
732  break;
733  case 2:
734  EXPECT_EQ ("intPropF",(*prop_it)->name()) << "Wrong Face property name";
735  break;
736  default:
737  EXPECT_EQ (4u , face_props);
738  break;
739  }
740  ++face_props;
741  }
742 
743  EXPECT_EQ (3u,face_props) << "Wrong number of face properties";
744 
745 
746 }
747 
748 
749 TEST_F(OpenMeshProperties, MeshAssignment ) {
750 
751  mesh_.clear();
752  mesh_.add_vertex(Mesh::Point());
753 
754  auto copy = mesh_;
755 
756  copy.request_vertex_status();
757  copy.request_vertex_normals();
758  copy.request_vertex_colors();
759  copy.request_vertex_texcoords1D();
760  copy.request_vertex_texcoords2D();
761  copy.request_vertex_texcoords3D();
762  copy.request_halfedge_status();
763  copy.request_halfedge_texcoords1D();
764  copy.request_halfedge_texcoords2D();
765  copy.request_halfedge_texcoords3D();
766  copy.request_edge_status();
767  copy.request_edge_colors();
768  copy.request_halfedge_normals();
769  copy.request_halfedge_colors();
770  copy.request_face_status();
771  copy.request_face_normals();
772  copy.request_face_colors();
773  copy.request_face_texture_index();
774 
775  EXPECT_TRUE(copy.has_vertex_status());
776  EXPECT_TRUE(copy.has_vertex_normals());
777  EXPECT_TRUE(copy.has_vertex_colors());
778  EXPECT_TRUE(copy.has_vertex_texcoords1D());
779  EXPECT_TRUE(copy.has_vertex_texcoords2D());
780  EXPECT_TRUE(copy.has_vertex_texcoords3D());
781  EXPECT_TRUE(copy.has_halfedge_status());
782  EXPECT_TRUE(copy.has_halfedge_texcoords1D());
783  EXPECT_TRUE(copy.has_halfedge_texcoords2D());
784  EXPECT_TRUE(copy.has_halfedge_texcoords3D());
785  EXPECT_TRUE(copy.has_edge_status());
786  EXPECT_TRUE(copy.has_edge_colors());
787  EXPECT_TRUE(copy.has_halfedge_normals());
788  EXPECT_TRUE(copy.has_halfedge_colors());
789  EXPECT_TRUE(copy.has_face_status());
790  EXPECT_TRUE(copy.has_face_normals());
791  EXPECT_TRUE(copy.has_face_colors());
792  EXPECT_TRUE(copy.has_face_texture_index());
793 
794  copy.assign(mesh_, true);
795 
796  EXPECT_FALSE(copy.has_vertex_status());
797  EXPECT_FALSE(copy.has_vertex_normals());
798  EXPECT_FALSE(copy.has_vertex_colors());
799  EXPECT_FALSE(copy.has_vertex_texcoords1D());
800  EXPECT_FALSE(copy.has_vertex_texcoords2D());
801  EXPECT_FALSE(copy.has_vertex_texcoords3D());
802  EXPECT_FALSE(copy.has_halfedge_status());
803  EXPECT_FALSE(copy.has_halfedge_texcoords1D());
804  EXPECT_FALSE(copy.has_halfedge_texcoords2D());
805  EXPECT_FALSE(copy.has_halfedge_texcoords3D());
806  EXPECT_FALSE(copy.has_edge_status());
807  EXPECT_FALSE(copy.has_edge_colors());
808  EXPECT_FALSE(copy.has_halfedge_normals());
809  EXPECT_FALSE(copy.has_halfedge_colors());
810  EXPECT_FALSE(copy.has_face_status());
811  EXPECT_FALSE(copy.has_face_normals());
812  EXPECT_FALSE(copy.has_face_colors());
813  EXPECT_FALSE(copy.has_face_texture_index());
814 
815  copy.request_vertex_status();
816  copy.request_vertex_normals();
817  copy.request_vertex_colors();
818  copy.request_vertex_texcoords1D();
819  copy.request_vertex_texcoords2D();
820  copy.request_vertex_texcoords3D();
821  copy.request_halfedge_status();
822  copy.request_halfedge_texcoords1D();
823  copy.request_halfedge_texcoords2D();
824  copy.request_halfedge_texcoords3D();
825  copy.request_edge_status();
826  copy.request_edge_colors();
827  copy.request_halfedge_normals();
828  copy.request_halfedge_colors();
829  copy.request_face_status();
830  copy.request_face_normals();
831  copy.request_face_colors();
832  copy.request_face_texture_index();
833 
834  EXPECT_TRUE(copy.has_vertex_status()) << "Mesh has no vertex status even though they have been requested";
835  EXPECT_TRUE(copy.has_vertex_normals()) << "Mesh has no vertex normals even though they have been requested";
836  EXPECT_TRUE(copy.has_vertex_colors()) << "Mesh has no vertex colors even though they have been requested";
837  EXPECT_TRUE(copy.has_vertex_texcoords1D()) << "Mesh has no vertex texcoord1D even though they have been requested";
838  EXPECT_TRUE(copy.has_vertex_texcoords2D()) << "Mesh has no vertex texcoord2D even though they have been requested";
839  EXPECT_TRUE(copy.has_vertex_texcoords3D()) << "Mesh has no vertex texcoord3D even though they have been requested";
840  EXPECT_TRUE(copy.has_halfedge_status()) << "Mesh has no halfedge status even though they have been requested";
841  EXPECT_TRUE(copy.has_halfedge_texcoords1D()) << "Mesh has no halfedge texcoords1D even though they have been requested";
842  EXPECT_TRUE(copy.has_halfedge_texcoords2D()) << "Mesh has no halfedge texcoords2D even though they have been requested";
843  EXPECT_TRUE(copy.has_halfedge_texcoords3D()) << "Mesh has no halfedge texcoords3D even though they have been requested";
844  EXPECT_TRUE(copy.has_edge_status()) << "Mesh has no edge status even though they have been requested";
845  EXPECT_TRUE(copy.has_edge_colors()) << "Mesh has no edge colors even though they have been requested";
846  EXPECT_TRUE(copy.has_halfedge_normals()) << "Mesh has no halfedge normals even though they have been requested";
847  EXPECT_TRUE(copy.has_halfedge_colors()) << "Mesh has no halfedge colors even though they have been requested";
848  EXPECT_TRUE(copy.has_face_status()) << "Mesh has no face status even though they have been requested";
849  EXPECT_TRUE(copy.has_face_normals()) << "Mesh has no face normals even though they have been requested";
850  EXPECT_TRUE(copy.has_face_colors()) << "Mesh has no face colors even though they have been requested";
851  EXPECT_TRUE(copy.has_face_texture_index()) << "Mesh has no face texture index even though they have been requested";
852 
853 }
854 
855 
856 }
OpenMesh::PolyMeshT::Point
Kernel::Point Point
Coordinate type.
Definition: PolyMeshT.hh:112
OpenMesh::PolyMeshT::add_vertex
VertexHandle add_vertex(const Point &_p)
Alias for new_vertex(const Point&).
Definition: PolyMeshT.hh:235
OpenMesh::PolyMeshT::VertexHandle
Kernel::VertexHandle VertexHandle
Handle for referencing the corresponding item.
Definition: PolyMeshT.hh:136