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
SetUp()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
TearDown()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  */
TEST_F(OpenMeshProperties,VertexPropertyCheckDouble)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  */
TEST_F(OpenMeshProperties,VertexPropertyCheckBool)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  */
TEST_F(OpenMeshProperties,VertexPropertyCopypropertiesInt)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 */
TEST_F(OpenMeshProperties,CheckStatusPropertiesHalfedgeEdgeAllDeleted)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 */
TEST_F(OpenMeshProperties,CopyAllPropertiesVertexAfterRemoveOfProperty)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  */
TEST_F(OpenMeshProperties,PropertyIterators)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 
TEST_F(OpenMeshProperties,MeshAssignment)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 }
857