Developer Documentation

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

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Properties Friends Macros Modules Pages
unittests_read_write_STL.cc
1
2 #include <gtest/gtest.h>
3 #include <Unittests/unittests_common.hh>
4
5
6 namespace {
7
8 class OpenMeshReadWriteSTL : public OpenMeshBase {
9
10 protected:
11
12 // This function is called before each test is run
13 virtual void SetUp() {
14
15 // Do some initial stuff with the member data here...
16 }
17
18 // This function is called after all tests are through
19 virtual void TearDown() {
20
21 // Do some final stuff with the member data here...
22 }
23
24 // Member already defined in OpenMeshBase
25 //Mesh mesh_;
26 };
27
28 /*
29 * ====================================================================
30 * Define tests below
31 * ====================================================================
32 */
33
34 /*
35 * Just load a simple mesh file in stla format and count whether
36 * the right number of entities has been loaded.
37 */
38 TEST_F(OpenMeshReadWriteSTL, LoadSimpleSTLFile) {
39
40 mesh_.clear();
41
42 bool ok = OpenMesh::IO::read_mesh(mesh_, "cube1.stl");
43
44 EXPECT_TRUE(ok);
45
46 EXPECT_EQ(7526u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
47 EXPECT_EQ(22572u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
48 EXPECT_EQ(15048u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
49 }
50
51
52 /*
53 * Just load a simple mesh file in stla format and count whether
54 * the right number of entities has been loaded. Also check facet normals.
55 */
56 TEST_F(OpenMeshReadWriteSTL, LoadSimpleSTLFileWithNormals) {
57
58 mesh_.clear();
59 mesh_.request_face_normals();
60
61 OpenMesh::IO::Options opt;
62 opt += OpenMesh::IO::Options::FaceNormal;
63
64 bool ok = OpenMesh::IO::read_mesh(mesh_, "cube1.stl", opt);
65
66 EXPECT_TRUE(ok);
67
68 EXPECT_TRUE(opt.face_has_normal());
69 EXPECT_FALSE(opt.vertex_has_normal());
70
71 EXPECT_NEAR(-0.038545f, mesh_.normal(mesh_.face_handle(0))[0], 0.0001 ) << "Wrong face normal at face 0 component 0";
72 EXPECT_NEAR(-0.004330f, mesh_.normal(mesh_.face_handle(0))[1], 0.0001 ) << "Wrong face normal at face 0 component 1";
73 EXPECT_NEAR(0.999247f, mesh_.normal(mesh_.face_handle(0))[2], 0.0001 ) << "Wrong face normal at face 0 component 2";
74
75 EXPECT_EQ(7526u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
76 EXPECT_EQ(22572u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
77 EXPECT_EQ(15048u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
78
79 mesh_.release_face_normals();
80 }
81
82
83 /*
84 * Just load a simple mesh file in stlb format and count whether
85 * the right number of entities has been loaded.
86 */
87 TEST_F(OpenMeshReadWriteSTL, LoadSimpleSTLBinaryFile) {
88
89 mesh_.clear();
90
91 bool ok = OpenMesh::IO::read_mesh(mesh_, "cube1Binary.stl");
92
93 EXPECT_TRUE(ok);
94
95 EXPECT_EQ(7526u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
96 EXPECT_EQ(22572u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
97 EXPECT_EQ(15048u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
98 }
99
100
101 /*
102 * Just load a simple mesh file in stlb format and count whether
103 * the right number of entities has been loaded. Also check facet normals.
104 */
105 TEST_F(OpenMeshReadWriteSTL, LoadSimpleSTLBinaryFileWithNormals) {
106
107 mesh_.clear();
108 mesh_.request_face_normals();
109
110 OpenMesh::IO::Options opt;
111 opt += OpenMesh::IO::Options::FaceNormal;
112 opt += OpenMesh::IO::Options::Binary;
113
114 bool ok = OpenMesh::IO::read_mesh(mesh_, "cube1Binary.stl", opt);
115
116 EXPECT_TRUE(ok);
117
118 EXPECT_TRUE(opt.is_binary());
119 EXPECT_TRUE(opt.face_has_normal());
120 EXPECT_FALSE(opt.vertex_has_normal());
121
122 EXPECT_NEAR(-0.038545f, mesh_.normal(mesh_.face_handle(0))[0], 0.0001 ) << "Wrong face normal at face 0 component 0";
123 EXPECT_NEAR(-0.004330f, mesh_.normal(mesh_.face_handle(0))[1], 0.0001 ) << "Wrong face normal at face 0 component 1";
124 EXPECT_NEAR(0.999247f, mesh_.normal(mesh_.face_handle(0))[2], 0.0001 ) << "Wrong face normal at face 0 component 2";
125
126 EXPECT_EQ(7526u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
127 EXPECT_EQ(22572u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
128 EXPECT_EQ(15048u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
129
130 mesh_.release_face_normals();
131 }
132
133 /*
134 * Read and Write stl binary file
135 */
136 TEST_F(OpenMeshReadWriteSTL, ReadWriteSimpleSTLBinaryFile) {
137
138 mesh_.clear();
139
140 OpenMesh::IO::Options opt;
141 opt += OpenMesh::IO::Options::Binary;
142
143 bool ok = OpenMesh::IO::read_mesh(mesh_, "cube1Binary.stl");
144
145 EXPECT_TRUE(ok);
146
147 const char* filename = "cube1Binary_openmeshWriteTestFile.stl";
148
149 ok = OpenMesh::IO::write_mesh(mesh_, filename, opt);
150
151 EXPECT_TRUE(ok);
152
153 ok = OpenMesh::IO::read_mesh(mesh_, filename, opt);
154
155 EXPECT_TRUE(ok);
156
157 EXPECT_EQ(7526u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
158 EXPECT_EQ(22572u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
159 EXPECT_EQ(15048u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
160
161 remove(filename);
162 }
163
164 /*
165 * Just load a simple mesh file in stlb format rewrite and load it again and count whether
166 * the right number of entities has been loaded. Also check facet normals.
167 */
168 TEST_F(OpenMeshReadWriteSTL, ReadWriteSimpleSTLBinaryFileWithNormals) {
169
170 mesh_.clear();
171 mesh_.request_face_normals();
172
173 OpenMesh::IO::Options opt;
174 opt += OpenMesh::IO::Options::FaceNormal;
175 opt += OpenMesh::IO::Options::Binary;
176
177 bool ok = OpenMesh::IO::read_mesh(mesh_, "cube1Binary.stl", opt);
178
179 EXPECT_TRUE(ok);
180
181 const char* filename = "cube1BinaryNormal_openmeshWriteTestFile.stl";
182
183 ok = OpenMesh::IO::write_mesh(mesh_, filename, opt);
184
185 EXPECT_TRUE(ok);
186
187 ok = OpenMesh::IO::read_mesh(mesh_, filename, opt);
188
189 EXPECT_TRUE(ok);
190
191 EXPECT_TRUE(opt.is_binary());
192 EXPECT_TRUE(opt.face_has_normal());
193 EXPECT_FALSE(opt.vertex_has_normal());
194
195 EXPECT_NEAR(-0.038545f, mesh_.normal(mesh_.face_handle(0))[0], 0.0001 ) << "Wrong face normal at face 0 component 0";
196 EXPECT_NEAR(-0.004330f, mesh_.normal(mesh_.face_handle(0))[1], 0.0001 ) << "Wrong face normal at face 0 component 1";
197 EXPECT_NEAR(0.999247f, mesh_.normal(mesh_.face_handle(0))[2], 0.0001 ) << "Wrong face normal at face 0 component 2";
198
199 EXPECT_EQ(7526u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
200 EXPECT_EQ(22572u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
201 EXPECT_EQ(15048u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
202
203 mesh_.release_face_normals();
204 remove(filename);
205 }
206
207 /*
208 * Just load a simple mesh file in stlb format rewrite and load it again and count whether
209 * the right number of entities has been loaded. Also check facet normals.
210 */
211 TEST_F(OpenMeshReadWriteSTL, ReadWriteSimpleSTLAsciiFileWithNormals) {
212
213 mesh_.clear();
214 mesh_.request_face_normals();
215
216 OpenMesh::IO::Options opt;
217 opt += OpenMesh::IO::Options::FaceNormal;
218
219 bool ok = OpenMesh::IO::read_mesh(mesh_, "cube1Binary.stl", opt);
220
221 EXPECT_TRUE(ok);
222 opt.clear();
223 opt += OpenMesh::IO::Options::FaceNormal;
224 const char* filename = "cube1Normal_openmeshWriteTestFile.stl";
225
226 ok = OpenMesh::IO::write_mesh(mesh_, filename, opt);
227
228 EXPECT_TRUE(ok);
229
230 opt.clear();
231 opt += OpenMesh::IO::Options::FaceNormal;
232 ok = OpenMesh::IO::read_mesh(mesh_, filename, opt);
233
234 EXPECT_TRUE(ok);
235
236 EXPECT_FALSE(opt.is_binary());
237 EXPECT_TRUE(opt.face_has_normal());
238 EXPECT_FALSE(opt.vertex_has_normal());
239
240 EXPECT_NEAR(-0.038545f, mesh_.normal(mesh_.face_handle(0))[0], 0.0001 ) << "Wrong face normal at face 0 component 0";
241 EXPECT_NEAR(-0.004330f, mesh_.normal(mesh_.face_handle(0))[1], 0.0001 ) << "Wrong face normal at face 0 component 1";
242 EXPECT_NEAR(0.999247f, mesh_.normal(mesh_.face_handle(0))[2], 0.0001 ) << "Wrong face normal at face 0 component 2";
243
244 EXPECT_EQ(7526u , mesh_.n_vertices()) << "The number of loaded vertices is not correct!";
245 EXPECT_EQ(22572u , mesh_.n_edges()) << "The number of loaded edges is not correct!";
246 EXPECT_EQ(15048u , mesh_.n_faces()) << "The number of loaded faces is not correct!";
247
248 mesh_.release_face_normals();
249 remove(filename);
250 }
251
252
253 }
OpenMesh::IO::read_mesh
bool read_mesh(Mesh &_mesh, const std::string &_filename)
Read a mesh from file _filename.
Definition: MeshIO.hh:104
OpenMesh::IO::Options::FaceNormal
Has (r) / store (w) face normals.
Definition: Options.hh:113
OpenMeshBase
Definition: unittests_common.hh:21
OpenMesh::IO::Options
Set options for reader/writer modules.
Definition: Options.hh:95
OpenMesh::IO::Options::Binary
Set binary mode for r/w.
Definition: Options.hh:105
OpenMesh::IO::Options::clear
void clear(void)
Clear all bits.
Definition: Options.hh:151
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:199