Developer Documentation
unittests_read_write_OBJ.cc
1 
2 #include <gtest/gtest.h>
3 #include <Unittests/unittests_common.hh>
4 #include <cstdio>
5 
6 
7 namespace {
8 
9 class OpenMeshReadWriteOBJ : public OpenMeshBase {
10 
11  protected:
12 
13  // This function is called before each test is run
14  virtual void SetUp() {
15 
16  // Do some initial stuff with the member data here...
17  }
18 
19  // This function is called after all tests are through
20  virtual void TearDown() {
21 
22  // Do some final stuff with the member data here...
23  }
24 
25  // Member already defined in OpenMeshBase
26  //Mesh mesh_;
27 };
28 
29 /*
30  * ====================================================================
31  * Define tests below
32  * ====================================================================
33  */
34 
35 /*
36  * Just load a obj file of a cube
37  */
38 TEST_F(OpenMeshReadWriteOBJ, LoadSimpleOBJ) {
39 
40  mesh_.clear();
41 
42  bool ok = OpenMesh::IO::read_mesh(mesh_, "cube-minimal.obj");
43 
44  EXPECT_TRUE(ok) << "Unable to load cube-minimal.obj";
45 
46  EXPECT_EQ(8u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
47  EXPECT_EQ(18u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
48  EXPECT_EQ(12u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
49 }
50 
51 /*
52  * Just load a obj file of a cube with degenerated faces
53  */
54 TEST_F(OpenMeshReadWriteOBJ, LoadDegeneratedOBJ) {
55 
56  mesh_.clear();
57 
58  bool ok = OpenMesh::IO::read_mesh(mesh_, "cube-minimal-degenerated.obj");
59 
60  EXPECT_TRUE(ok) << "Unable to load cube-minimal-degenerated.obj";
61 
62  EXPECT_EQ(8u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
63  EXPECT_EQ(18u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
64  EXPECT_EQ(12u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
65 }
66 
67 /*
68  * Just load a obj file of a cube and checks the halfedge and vertex normals
69  */
70 TEST_F(OpenMeshReadWriteOBJ, LoadSimpleOBJCheckHalfEdgeAndVertexNormals) {
71 
72  mesh_.clear();
73 
74  mesh_.request_halfedge_normals();
75  mesh_.request_vertex_normals();
76 
77  OpenMesh::IO::Options options;
78  options += OpenMesh::IO::Options::VertexNormal;
79 
80  std::string file_name = "cube-minimal.obj";
81 
82  bool ok = OpenMesh::IO::read_mesh(mesh_, file_name,options);
83 
84  EXPECT_TRUE(ok) << file_name;
85 
86  EXPECT_EQ(8u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
87  EXPECT_EQ(18u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
88  EXPECT_EQ(12u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
89  EXPECT_EQ(36u , mesh_.n_halfedges()) << "The number of loaded halfedges is not correct!";
90 
92  //check vertex normals
93  EXPECT_EQ(0, mesh_.normal(mesh_.vertex_handle(0))[0] ) << "Wrong vertex normal at vertex 0 component 0";
94  EXPECT_EQ(-1, mesh_.normal(mesh_.vertex_handle(0))[1] ) << "Wrong vertex normal at vertex 0 component 1";
95  EXPECT_EQ(0, mesh_.normal(mesh_.vertex_handle(0))[2] ) << "Wrong vertex normal at vertex 0 component 2";
96 
97  EXPECT_EQ(0, mesh_.normal(mesh_.vertex_handle(3))[0] ) << "Wrong vertex normal at vertex 3 component 0";
98  EXPECT_EQ(0, mesh_.normal(mesh_.vertex_handle(3))[1] ) << "Wrong vertex normal at vertex 3 component 1";
99  EXPECT_EQ(1, mesh_.normal(mesh_.vertex_handle(3))[2] ) << "Wrong vertex normal at vertex 3 component 2";
100 
101  EXPECT_EQ(0, mesh_.normal(mesh_.vertex_handle(4))[0] ) << "Wrong vertex normal at vertex 4 component 0";
102  EXPECT_EQ(-1, mesh_.normal(mesh_.vertex_handle(4))[1] ) << "Wrong vertex normal at vertex 4 component 1";
103  EXPECT_EQ(0, mesh_.normal(mesh_.vertex_handle(4))[2] ) << "Wrong vertex normal at vertex 4 component 2";
104 
105  EXPECT_EQ(0, mesh_.normal(mesh_.vertex_handle(7))[0] ) << "Wrong vertex normal at vertex 7 component 0";
106  EXPECT_EQ(0, mesh_.normal(mesh_.vertex_handle(7))[1] ) << "Wrong vertex normal at vertex 7 component 1";
107  EXPECT_EQ(1, mesh_.normal(mesh_.vertex_handle(7))[2] ) << "Wrong vertex normal at vertex 7 component 2";
108 
110  //check halfedge normals
111  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(0))[0] ) << "Wrong halfedge normal at halfedge 0 component 0";
112  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(0))[1] ) << "Wrong halfedge normal at halfedge 0 component 1";
113  EXPECT_EQ(-1, mesh_.normal(mesh_.halfedge_handle(0))[2] ) << "Wrong halfedge normal at halfedge 0 component 2";
114 
115  EXPECT_EQ(-1, mesh_.normal(mesh_.halfedge_handle(10))[0] ) << "Wrong halfedge normal at halfedge 10 component 0";
116  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(10))[1] ) << "Wrong halfedge normal at halfedge 10 component 1";
117  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(10))[2] ) << "Wrong halfedge normal at halfedge 10 component 2";
118 
119  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(19))[0] ) << "Wrong halfedge normal at halfedge 19 component 0";
120  EXPECT_EQ(1, mesh_.normal(mesh_.halfedge_handle(19))[1] ) << "Wrong halfedge normal at halfedge 19 component 1";
121  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(19))[2] ) << "Wrong halfedge normal at halfedge 19 component 2";
122 
123  EXPECT_EQ(1, mesh_.normal(mesh_.halfedge_handle(24))[0] ) << "Wrong halfedge normal at halfedge 24 component 0";
124  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(24))[1] ) << "Wrong halfedge normal at halfedge 24 component 1";
125  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(24))[2] ) << "Wrong halfedge normal at halfedge 24 component 2";
126 
127  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(30))[0] ) << "Wrong halfedge normal at halfedge 30 component 0";
128  EXPECT_EQ(-1, mesh_.normal(mesh_.halfedge_handle(30))[1] ) << "Wrong halfedge normal at halfedge 30 component 1";
129  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(30))[2] ) << "Wrong halfedge normal at halfedge 30 component 2";
130 
131  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(35))[0] ) << "Wrong halfedge normal at halfedge 35 component 0";
132  EXPECT_EQ(0, mesh_.normal(mesh_.halfedge_handle(35))[1] ) << "Wrong halfedge normal at halfedge 35 component 1";
133  EXPECT_EQ(1, mesh_.normal(mesh_.halfedge_handle(35))[2] ) << "Wrong halfedge normal at halfedge 35 component 2";
134 
135  mesh_.release_vertex_normals();
136  mesh_.release_halfedge_normals();
137 
138 }
139 
140 /*
141  * Just load a obj file and set vertex color option before loading
142  */
143 TEST_F(OpenMeshReadWriteOBJ, LoadSimpleOBJForceVertexColorsAlthoughNotAvailable) {
144 
145  mesh_.clear();
146 
147  mesh_.request_vertex_colors();
148 
149  std::string file_name = "cube-minimal.obj";
150 
151  OpenMesh::IO::Options options;
152  options += OpenMesh::IO::Options::VertexColor;
153 
154  bool ok = OpenMesh::IO::read_mesh(mesh_, file_name,options);
155 
156  EXPECT_TRUE(ok) << file_name;
157 
158  EXPECT_EQ(8u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
159  EXPECT_EQ(18u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
160  EXPECT_EQ(12u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
161  EXPECT_EQ(36u , mesh_.n_halfedges()) << "The number of loaded halfedges is not correct!";
162 
163 }
164 
165 
166 /*
167  * Just load a obj file of a cube and checks the halfedge texCoords
168  */
169 TEST_F(OpenMeshReadWriteOBJ, LoadSimpleOBJCheckTexCoords) {
170 
171  mesh_.clear();
172 
173  mesh_.request_halfedge_texcoords2D();
174 
175  OpenMesh::IO::Options options;
176  options += OpenMesh::IO::Options::FaceTexCoord;
177 
178  std::string file_name = "cube-minimal-texCoords.obj";
179 
180  bool ok = OpenMesh::IO::read_mesh(mesh_, file_name,options);
181 
182  EXPECT_TRUE(ok) << file_name;
183 
184  EXPECT_EQ(1, mesh_.texcoord2D(mesh_.halfedge_handle(0))[0] ) << "Wrong texCoord at halfedge 0 component 0";
185  EXPECT_EQ(1, mesh_.texcoord2D(mesh_.halfedge_handle(0))[1] ) << "Wrong texCoord at halfedge 0 component 1";
186 
187  EXPECT_EQ(3, mesh_.texcoord2D(mesh_.halfedge_handle(10))[0] ) << "Wrong texCoord at halfedge 1 component 0";
188  EXPECT_EQ(3, mesh_.texcoord2D(mesh_.halfedge_handle(10))[1] ) << "Wrong texCoord at halfedge 1 component 1";
189 
190  EXPECT_EQ(6, mesh_.texcoord2D(mesh_.halfedge_handle(19))[0] ) << "Wrong texCoord at halfedge 4 component 0";
191  EXPECT_EQ(6, mesh_.texcoord2D(mesh_.halfedge_handle(19))[1] ) << "Wrong texCoord at halfedge 4 component 1";
192 
193  EXPECT_EQ(7, mesh_.texcoord2D(mesh_.halfedge_handle(24))[0] ) << "Wrong texCoord at halfedge 7 component 0";
194  EXPECT_EQ(7, mesh_.texcoord2D(mesh_.halfedge_handle(24))[1] ) << "Wrong texCoord at halfedge 7 component 1";
195 
196  EXPECT_EQ(9, mesh_.texcoord2D(mesh_.halfedge_handle(30))[0] ) << "Wrong texCoord at halfedge 9 component 0";
197  EXPECT_EQ(9, mesh_.texcoord2D(mesh_.halfedge_handle(30))[1] ) << "Wrong texCoord at halfedge 9 component 1";
198 
199  EXPECT_EQ(12, mesh_.texcoord2D(mesh_.halfedge_handle(35))[0] ) << "Wrong texCoord at halfedge 11 component 0";
200  EXPECT_EQ(12, mesh_.texcoord2D(mesh_.halfedge_handle(35))[1] ) << "Wrong texCoord at halfedge 11 component 1";
201 
202  mesh_.release_halfedge_texcoords2D();
203 }
204 
205 /*
206  * Just load and store obj file of a cube and checks the halfedge texCoords
207  */
208 TEST_F(OpenMeshReadWriteOBJ, LoadStoreSimpleOBJCheckTexCoords) {
209 
210  mesh_.clear();
211 
212  mesh_.request_halfedge_texcoords2D();
213 
214  OpenMesh::IO::Options options;
215  options += OpenMesh::IO::Options::FaceTexCoord;
216 
217  std::string file_name = "cube-minimal-texCoords.obj";
218 
219  bool ok = OpenMesh::IO::read_mesh(mesh_, file_name,options);
220 
221  EXPECT_TRUE(ok) << file_name;
222 
223 
224 
225  options.clear();
226  options += OpenMesh::IO::Options::FaceTexCoord;
227  bool writeOk = OpenMesh::IO::write_mesh(mesh_,"writeTest.obj",options);
228  EXPECT_TRUE(writeOk) << "writeTest.obj";
229  mesh_.release_halfedge_texcoords2D();
230 
231  Mesh loadedMesh_;
232  loadedMesh_.clear();
233 
234  loadedMesh_.request_halfedge_texcoords2D();
235 
236  options.clear();
237  options += OpenMesh::IO::Options::FaceTexCoord;
238  bool readOk = OpenMesh::IO::read_mesh(loadedMesh_, "writeTest.obj",options);
239  EXPECT_TRUE(readOk) << file_name;
240  EXPECT_EQ(1, loadedMesh_.texcoord2D(mesh_.halfedge_handle(0))[0] ) << "Wrong texCoord at halfedge 0 component 0";
241  EXPECT_EQ(1, loadedMesh_.texcoord2D(mesh_.halfedge_handle(0))[1] ) << "Wrong texCoord at halfedge 0 component 1";
242 
243  EXPECT_EQ(3, loadedMesh_.texcoord2D(mesh_.halfedge_handle(10))[0] ) << "Wrong texCoord at halfedge 1 component 0";
244  EXPECT_EQ(3, loadedMesh_.texcoord2D(mesh_.halfedge_handle(10))[1] ) << "Wrong texCoord at halfedge 1 component 1";
245 
246  EXPECT_EQ(6, loadedMesh_.texcoord2D(mesh_.halfedge_handle(19))[0] ) << "Wrong texCoord at halfedge 4 component 0";
247  EXPECT_EQ(6, loadedMesh_.texcoord2D(mesh_.halfedge_handle(19))[1] ) << "Wrong texCoord at halfedge 4 component 1";
248 
249  EXPECT_EQ(7, loadedMesh_.texcoord2D(mesh_.halfedge_handle(24))[0] ) << "Wrong texCoord at halfedge 7 component 0";
250  EXPECT_EQ(7, loadedMesh_.texcoord2D(mesh_.halfedge_handle(24))[1] ) << "Wrong texCoord at halfedge 7 component 1";
251 
252  EXPECT_EQ(9, loadedMesh_.texcoord2D(mesh_.halfedge_handle(30))[0] ) << "Wrong texCoord at halfedge 9 component 0";
253  EXPECT_EQ(9, loadedMesh_.texcoord2D(mesh_.halfedge_handle(30))[1] ) << "Wrong texCoord at halfedge 9 component 1";
254 
255  EXPECT_EQ(12, loadedMesh_.texcoord2D(mesh_.halfedge_handle(35))[0] ) << "Wrong texCoord at halfedge 11 component 0";
256  EXPECT_EQ(12, loadedMesh_.texcoord2D(mesh_.halfedge_handle(35))[1] ) << "Wrong texCoord at halfedge 11 component 1";
257 
258  loadedMesh_.release_halfedge_texcoords2D();
259 }
260 
261 /*
262  * Just load a obj file of a cube and checks the 3d halfedge texCoords
263  */
264 TEST_F(OpenMeshReadWriteOBJ, LoadSimpleOBJCheckTexCoords3d) {
265 
266  mesh_.clear();
267 
268  mesh_.request_halfedge_texcoords3D();
269 
270  OpenMesh::IO::Options options;
271  options += OpenMesh::IO::Options::FaceTexCoord;
272 
273  std::string file_name = "cube-minimal-texCoords3d.obj";
274 
275  bool ok = OpenMesh::IO::read_mesh(mesh_, file_name,options);
276 
277  EXPECT_TRUE(ok) << file_name;
278 
279  EXPECT_EQ(1, mesh_.texcoord3D(mesh_.halfedge_handle(0))[0] ) << "Wrong texCoord at halfedge 0 component 0";
280  EXPECT_EQ(1, mesh_.texcoord3D(mesh_.halfedge_handle(0))[1] ) << "Wrong texCoord at halfedge 0 component 1";
281  EXPECT_EQ(1, mesh_.texcoord3D(mesh_.halfedge_handle(0))[2] ) << "Wrong texCoord at halfedge 0 component 2";
282 
283  EXPECT_EQ(3, mesh_.texcoord3D(mesh_.halfedge_handle(10))[0] ) << "Wrong texCoord at halfedge 1 component 0";
284  EXPECT_EQ(3, mesh_.texcoord3D(mesh_.halfedge_handle(10))[1] ) << "Wrong texCoord at halfedge 1 component 1";
285  EXPECT_EQ(3, mesh_.texcoord3D(mesh_.halfedge_handle(10))[2] ) << "Wrong texCoord at halfedge 1 component 2";
286 
287  EXPECT_EQ(6, mesh_.texcoord3D(mesh_.halfedge_handle(19))[0] ) << "Wrong texCoord at halfedge 4 component 0";
288  EXPECT_EQ(6, mesh_.texcoord3D(mesh_.halfedge_handle(19))[1] ) << "Wrong texCoord at halfedge 4 component 1";
289  EXPECT_EQ(6, mesh_.texcoord3D(mesh_.halfedge_handle(19))[2] ) << "Wrong texCoord at halfedge 4 component 2";
290 
291  EXPECT_EQ(7, mesh_.texcoord3D(mesh_.halfedge_handle(24))[0] ) << "Wrong texCoord at halfedge 7 component 0";
292  EXPECT_EQ(7, mesh_.texcoord3D(mesh_.halfedge_handle(24))[1] ) << "Wrong texCoord at halfedge 7 component 1";
293  EXPECT_EQ(7, mesh_.texcoord3D(mesh_.halfedge_handle(24))[2] ) << "Wrong texCoord at halfedge 7 component 2";
294 
295  EXPECT_EQ(9, mesh_.texcoord3D(mesh_.halfedge_handle(30))[0] ) << "Wrong texCoord at halfedge 9 component 0";
296  EXPECT_EQ(9, mesh_.texcoord3D(mesh_.halfedge_handle(30))[1] ) << "Wrong texCoord at halfedge 9 component 1";
297  EXPECT_EQ(9, mesh_.texcoord3D(mesh_.halfedge_handle(30))[2] ) << "Wrong texCoord at halfedge 9 component 2";
298 
299  EXPECT_EQ(12, mesh_.texcoord3D(mesh_.halfedge_handle(35))[0] ) << "Wrong texCoord at halfedge 11 component 0";
300  EXPECT_EQ(12, mesh_.texcoord3D(mesh_.halfedge_handle(35))[1] ) << "Wrong texCoord at halfedge 11 component 1";
301  EXPECT_EQ(12, mesh_.texcoord3D(mesh_.halfedge_handle(35))[2] ) << "Wrong texCoord at halfedge 11 component 2";
302 
303  mesh_.request_halfedge_texcoords3D();
304 }
305 
306 /*
307  * Just load a obj file of a square with a material
308  */
309 TEST_F(OpenMeshReadWriteOBJ, LoadObjWithMaterial) {
310 
311  mesh_.clear();
312 
313  mesh_.request_face_colors();
314 
315  OpenMesh::IO::Options options;
316  options += OpenMesh::IO::Options::FaceColor;
317 
318  std::string file_name = "square_material.obj";
319 
320  bool ok = OpenMesh::IO::read_mesh(mesh_, file_name,options);
321 
322  EXPECT_TRUE(ok) << file_name;
323 
324  OpenMesh::FaceHandle fh = mesh_.face_handle(mesh_.halfedge_handle(0));
325 
326  EXPECT_TRUE(fh.is_valid()) << "fh should be valid";
327 
328  EXPECT_EQ(128, mesh_.color(fh)[0] ) << "Wrong vertex color at vertex 0 component 0";
329  EXPECT_EQ(128, mesh_.color(fh)[1] ) << "Wrong vertex color at vertex 0 component 1";
330  EXPECT_EQ(128, mesh_.color(fh)[2] ) << "Wrong vertex color at vertex 0 component 2";
331 
332  mesh_.release_face_colors();
333 }
334 
335 TEST_F(OpenMeshReadWriteOBJ, LoadObjWithTexture) {
336 
337  mesh_.clear();
338 
339  mesh_.request_face_colors();
340  mesh_.request_face_texture_index();
341 
342  OpenMesh::IO::Options options;
343  options += OpenMesh::IO::Options::FaceTexCoord;
344 
345  std::string file_name = "square_material_texture.obj";
346 
347  bool ok = OpenMesh::IO::read_mesh(mesh_, file_name, options);
348 
349  EXPECT_TRUE(ok) << file_name;
350 
351  //check texture mapping for the mesh
352  OpenMesh::MPropHandleT< std::map< int, std::string > > property;
353  mesh_.get_property_handle(property, "TextureMapping");
354  EXPECT_EQ(mesh_.property(property).size(), 1u) << "More than one texture defined";
355  std::map< int, std::string >::iterator tex = mesh_.property(property).find(1);
356  EXPECT_TRUE(tex != mesh_.property(property).end()) << "Could not find texture with id 1";
357  EXPECT_TRUE((mesh_.property(property)[1] == std::string("square_material_texture.jpg"))) << "Wrong texture name";
358 
359  //check texture mapping per face
360  OpenMesh::FaceHandle fh = mesh_.face_handle(mesh_.halfedge_handle(0));
361  EXPECT_TRUE(fh.is_valid()) << "fh should be valid";
362  EXPECT_EQ(mesh_.property(mesh_.face_texture_index_pph(),fh),1) << "Face texture index is not set correctly";
363 
364  mesh_.release_face_colors();
365  mesh_.release_face_texture_index();
366 }
367 
368 /*
369  * Just load a obj file of a cube with vertex colors defined directly after the vertex definitions
370  */
371 TEST_F(OpenMeshReadWriteOBJ, LoadSimpleOBJWithVertexColorsAfterVertices) {
372 
373  mesh_.clear();
374 
375  mesh_.request_vertex_colors();
376 
377  OpenMesh::IO::Options options;
378  options += OpenMesh::IO::Options::VertexColor;
379 
380  bool ok = OpenMesh::IO::read_mesh(mesh_, "cube-minimal-vertex-colors-after-vertex-definition.obj",options);
381 
382  EXPECT_TRUE(ok) << "Unable to load cube-minimal-vertex-colors-after-vertex-definition.obj";
383 
384  EXPECT_EQ(8u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
385  EXPECT_EQ(18u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
386  EXPECT_EQ(12u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
387 
388  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(0))[0] ) << "Wrong vertex color at vertex 0 component 0";
389  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(0))[1] ) << "Wrong vertex color at vertex 0 component 1";
390  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(0))[2] ) << "Wrong vertex color at vertex 0 component 2";
391 
392  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(3))[0] ) << "Wrong vertex color at vertex 3 component 0";
393  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(3))[1] ) << "Wrong vertex color at vertex 3 component 1";
394  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(3))[2] ) << "Wrong vertex color at vertex 3 component 2";
395 
396  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(4))[0] ) << "Wrong vertex color at vertex 4 component 0";
397  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(4))[1] ) << "Wrong vertex color at vertex 4 component 1";
398  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(4))[2] ) << "Wrong vertex color at vertex 4 component 2";
399 
400  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(7))[0] ) << "Wrong vertex color at vertex 7 component 0";
401  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(7))[1] ) << "Wrong vertex color at vertex 7 component 1";
402  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(7))[2] ) << "Wrong vertex color at vertex 7 component 2";
403 
404  mesh_.release_vertex_colors();
405 }
406 
407 /*
408  * Just load a obj file of a cube with vertex colors defined as separate lines
409  */
410 TEST_F(OpenMeshReadWriteOBJ, LoadSimpleOBJWithVertexColorsAsVCLines) {
411 
412  mesh_.clear();
413 
414  mesh_.request_vertex_colors();
415 
416  OpenMesh::IO::Options options;
417  options += OpenMesh::IO::Options::VertexColor;
418 
419  bool ok = OpenMesh::IO::read_mesh(mesh_, "cube-minimal-vertex-colors-as-vc-lines.obj",options);
420 
421  EXPECT_TRUE(ok) << "Unable to load cube-minimal-vertex-colors-as-vc-lines.obj";
422 
423  EXPECT_EQ(8u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
424  EXPECT_EQ(18u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
425  EXPECT_EQ(12u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
426 
427  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(0))[0] ) << "Wrong vertex color at vertex 0 component 0";
428  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(0))[1] ) << "Wrong vertex color at vertex 0 component 1";
429  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(0))[2] ) << "Wrong vertex color at vertex 0 component 2";
430 
431  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(3))[0] ) << "Wrong vertex color at vertex 3 component 0";
432  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(3))[1] ) << "Wrong vertex color at vertex 3 component 1";
433  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(3))[2] ) << "Wrong vertex color at vertex 3 component 2";
434 
435  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(4))[0] ) << "Wrong vertex color at vertex 4 component 0";
436  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(4))[1] ) << "Wrong vertex color at vertex 4 component 1";
437  EXPECT_EQ(0, mesh_.color(mesh_.vertex_handle(4))[2] ) << "Wrong vertex color at vertex 4 component 2";
438 
439  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(7))[0] ) << "Wrong vertex color at vertex 7 component 0";
440  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(7))[1] ) << "Wrong vertex color at vertex 7 component 1";
441  EXPECT_EQ(255, mesh_.color(mesh_.vertex_handle(7))[2] ) << "Wrong vertex color at vertex 7 component 2";
442 
443  mesh_.release_vertex_colors();
444 
445 }
446 
447 /*
448  * Load, save and load a simple obj
449  */
450 TEST_F(OpenMeshReadWriteOBJ, ReadWriteReadSimpleOBJ) {
451 
452  mesh_.clear();
453  mesh_.request_vertex_normals();
454 
455  OpenMesh::IO::Options options;
456  options += OpenMesh::IO::Options::VertexNormal;
457  bool ok = OpenMesh::IO::read_mesh(mesh_, "cube-minimal.obj", options);
458 
459  EXPECT_TRUE(ok) << "Unable to load cube-minimal.obj";
460 
461  options.clear();
462  options += OpenMesh::IO::Options::VertexNormal;
463  const char* filename = "cube-minimal_openmeshOutputTestfile.obj";
464  ok = OpenMesh::IO::write_mesh(mesh_, filename, options);
465 
466  mesh_.release_vertex_normals();
467  ASSERT_TRUE(ok) << "Unable to write obj mesh";
468 
469  Mesh mesh2;
470  mesh2.request_vertex_normals();
471 
472  options.clear();
473 
474  options += OpenMesh::IO::Options::VertexNormal;
475  ok = OpenMesh::IO::read_mesh(mesh2, filename, options);
476  remove(filename);
477  ASSERT_TRUE(ok) << "Unable to read written mesh";
478 
479  EXPECT_EQ(8u , mesh2.n_vertices()) << "The number of loaded vertices is not correct!";
480  EXPECT_EQ(18u , mesh2.n_edges()) << "The number of loaded edges is not correct!";
481  EXPECT_EQ(12u , mesh2.n_faces()) << "The number of loaded faces is not correct!";
482 
484  //check vertex normals
485  EXPECT_EQ(0, mesh2.normal(mesh2.vertex_handle(0))[0] ) << "Wrong vertex normal at vertex 0 component 0";
486  EXPECT_EQ(-1, mesh2.normal(mesh2.vertex_handle(0))[1] ) << "Wrong vertex normal at vertex 0 component 1";
487  EXPECT_EQ(0, mesh2.normal(mesh2.vertex_handle(0))[2] ) << "Wrong vertex normal at vertex 0 component 2";
488 
489  EXPECT_EQ(0, mesh2.normal(mesh2.vertex_handle(3))[0] ) << "Wrong vertex normal at vertex 3 component 0";
490  EXPECT_EQ(0, mesh2.normal(mesh2.vertex_handle(3))[1] ) << "Wrong vertex normal at vertex 3 component 1";
491  EXPECT_EQ(1, mesh2.normal(mesh2.vertex_handle(3))[2] ) << "Wrong vertex normal at vertex 3 component 2";
492 
493  EXPECT_EQ(0, mesh2.normal(mesh2.vertex_handle(4))[0] ) << "Wrong vertex normal at vertex 4 component 0";
494  EXPECT_EQ(-1, mesh2.normal(mesh2.vertex_handle(4))[1] ) << "Wrong vertex normal at vertex 4 component 1";
495  EXPECT_EQ(0, mesh2.normal(mesh2.vertex_handle(4))[2] ) << "Wrong vertex normal at vertex 4 component 2";
496 
497  EXPECT_EQ(0, mesh2.normal(mesh2.vertex_handle(7))[0] ) << "Wrong vertex normal at vertex 7 component 0";
498  EXPECT_EQ(0, mesh2.normal(mesh2.vertex_handle(7))[1] ) << "Wrong vertex normal at vertex 7 component 1";
499  EXPECT_EQ(1, mesh2.normal(mesh2.vertex_handle(7))[2] ) << "Wrong vertex normal at vertex 7 component 2";
500 
501 }
502 
503 
504 TEST_F(OpenMeshReadWriteOBJ, FaceTexCoordTest) {
505 
506  mesh_.clear();
507  mesh_.request_vertex_normals();
508  mesh_.request_halfedge_texcoords2D();
509 
510  // Add some vertices
511  Mesh::VertexHandle vhandle[5];
512 
513  vhandle[0] = mesh_.add_vertex(Mesh::Point(0, 0, 0));
514  vhandle[1] = mesh_.add_vertex(Mesh::Point(0, 1, 0));
515  vhandle[2] = mesh_.add_vertex(Mesh::Point(1, 1, 0));
516 
517  // Add one face
518  std::vector<Mesh::VertexHandle> face_vhandles;
519 
520  face_vhandles.push_back(vhandle[2]);
521  face_vhandles.push_back(vhandle[1]);
522  face_vhandles.push_back(vhandle[0]);
523 
524  Mesh::FaceHandle fh = mesh_.add_face(face_vhandles);
525 
526  // 1 --- 2
527  // | /
528  // | /
529  // | /
530  // 0
531 
532  mesh_.set_normal(vhandle[0] , Mesh::Normal(1,0,0));
533  mesh_.set_normal(vhandle[1] , Mesh::Normal(0,1,0));
534  mesh_.set_normal(vhandle[2] , Mesh::Normal(0,0,1));
535 
536 
537  float u = 8.0f;
538  for ( auto he : mesh_.halfedges() ) {
539 
540  mesh_.set_texcoord2D(he,Mesh::TexCoord2D(u,u));
541  u += 1.0;
542  }
543 
544 
545  u = 0.0f;
546 
547  for ( auto he : mesh_.fh_range(fh) )
548  {
549 
550  mesh_.set_texcoord2D(he,Mesh::TexCoord2D(u,u));
551  u += 1.0f;
552  }
553 
554 
555 
556  OpenMesh::IO::Options wopt;
557  wopt += OpenMesh::IO::Options::VertexNormal;
558  wopt += OpenMesh::IO::Options::FaceTexCoord;
559 
560  bool ok = OpenMesh::IO::write_mesh(mesh_, "OpenMeshReadWriteOBJ_FaceTexCoordTest.obj", wopt);
561 
562  EXPECT_TRUE(ok) << "Unable to write OpenMeshReadWriteOBJ_FaceTexCoordTest.obj";
563 
564  mesh_.clear();
565 
566 
567  OpenMesh::IO::Options ropt;
568 
569  ropt += OpenMesh::IO::Options::FaceTexCoord;
570 
571  mesh_.request_vertex_normals();
572  mesh_.request_face_normals();
573  mesh_.request_halfedge_texcoords2D();
574 
575  ok = OpenMesh::IO::read_mesh(mesh_, "OpenMeshReadWriteOBJ_FaceTexCoordTest.obj", ropt);
576 
577  EXPECT_TRUE(ok) << "Unable to read back OpenMeshReadWriteOBJ_FaceTexCoordTest.obj";
578 
579 }
580 
581 
582 
583 
584 
585 
586 }
OpenMesh::IO::Options::VertexColor
Has (r) / store (w) vertex colors.
Definition: Options.hh:105
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::IO::Options::FaceColor
Has (r) / store (w) face colors.
Definition: Options.hh:109
OpenMesh::IO::write_mesh
bool write_mesh(const Mesh &_mesh, const std::string &_filename, Options _opt=Options::Default, std::streamsize _precision=6)
Write a mesh to the file _filename.
Definition: MeshIO.hh:207
OpenMesh::PolyMeshT::VertexHandle
Kernel::VertexHandle VertexHandle
Handle for referencing the corresponding item.
Definition: PolyMeshT.hh:136
OpenMesh::IO::Options::FaceTexCoord
Has (r) / store (w) face texture coordinates.
Definition: Options.hh:110
OpenMesh::PolyMeshT::TexCoord2D
Kernel::TexCoord2D TexCoord2D
TexCoord2D type.
Definition: PolyMeshT.hh:120
OpenMesh::PolyMeshT::Normal
Kernel::Normal Normal
Normal type.
Definition: PolyMeshT.hh:114
OpenMesh::FaceHandle
Handle for a face entity.
Definition: Handles.hh:141
OpenMesh::IO::Options::clear
void clear(void)
Clear all bits.
Definition: Options.hh:147
OpenMesh::IO::Options
Set options for reader/writer modules.
Definition: Options.hh:90
OpenMesh::IO::Options::VertexNormal
Has (r) / store (w) vertex normals.
Definition: Options.hh:104
OpenMesh::BaseHandle::is_valid
bool is_valid() const
The handle is valid iff the index is not negative.
Definition: Handles.hh:72
OpenMesh::IO::read_mesh
bool read_mesh(Mesh &_mesh, const std::string &_filename)
Read a mesh from file _filename.
Definition: MeshIO.hh:112