| OpenMesh

ExporterT.hh
1 /* ========================================================================= *
2 * *
3 * OpenMesh *
4 * Copyright (c) 2001-2015, RWTH-Aachen University *
5 * Department of Computer Graphics and Multimedia *
6 * All rights reserved. *
7 * www.openmesh.org *
8 * *
9 *---------------------------------------------------------------------------*
10 * This file is part of OpenMesh. *
11 *---------------------------------------------------------------------------*
12 * *
13 * Redistribution and use in source and binary forms, with or without *
14 * modification, are permitted provided that the following conditions *
15 * are met: *
16 * *
17 * 1. Redistributions of source code must retain the above copyright notice, *
18 * this list of conditions and the following disclaimer. *
19 * *
20 * 2. Redistributions in binary form must reproduce the above copyright *
21 * notice, this list of conditions and the following disclaimer in the *
22 * documentation and/or other materials provided with the distribution. *
23 * *
24 * 3. Neither the name of the copyright holder nor the names of its *
25 * contributors may be used to endorse or promote products derived from *
26 * this software without specific prior written permission. *
27 * *
28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS *
29 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED *
30 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A *
31 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER *
32 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, *
33 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, *
34 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR *
35 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF *
36 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING *
37 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS *
38 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. *
39 * *
40 * ========================================================================= */
41
42
43
44
45 //=============================================================================
46 //
47 // Implements an exporter module for arbitrary OpenMesh meshes
48 //
49 //=============================================================================
50
51
52 #ifndef __EXPORTERT_HH__
53 #define __EXPORTERT_HH__
54
55
56 //=== INCLUDES ================================================================
57
58 // C++
59 #include <vector>
60
61 // OpenMesh
62 #include <OpenMesh/Core/System/config.h>
63 #include <OpenMesh/Core/Geometry/VectorT.hh>
64 #include <OpenMesh/Core/Utils/GenProg.hh>
65 #include <OpenMesh/Core/Utils/vector_cast.hh>
66 #include <OpenMesh/Core/Utils/color_cast.hh>
67 #include <OpenMesh/Core/IO/exporter/BaseExporter.hh>
68 #include <OpenMesh/Core/IO/OMFormat.hh>
69
70
71 //=== NAMESPACES ==============================================================
72
73 namespace OpenMesh {
74 namespace IO {
75
76
77 //=== EXPORTER CLASS ==========================================================
78
82 template <class Mesh>
83 class ExporterT : public BaseExporter
84 {
85 public:
86
87 // Constructor
88 explicit ExporterT(const Mesh& _mesh) : mesh_(_mesh) {}
89
90
91 // get vertex data
92
93 Vec3f point(VertexHandle _vh) const override
94 {
95 return vector_cast<Vec3f>(mesh_.point(_vh));
96 }
97
98 Vec3d pointd(VertexHandle _vh) const override
99 {
100 return vector_cast<Vec3d>(mesh_.point(_vh));
101 }
102
103 bool is_point_double() const override
104 {
105 return OMFormat::is_double(typename Mesh::Point()[0]);
106 }
107
108 bool is_normal_double() const override
109 {
110 return OMFormat::is_double(typename Mesh::Normal()[0]);
111 }
112
113 Vec3f normal(VertexHandle _vh) const override
114 {
115 return (mesh_.has_vertex_normals()
116 ? vector_cast<Vec3f>(mesh_.normal(_vh))
117 : Vec3f(0.0f, 0.0f, 0.0f));
118 }
119
120 Vec3d normald(VertexHandle _vh) const override
121 {
122 return (mesh_.has_vertex_normals()
123 ? vector_cast<Vec3d>(mesh_.normal(_vh))
124 : Vec3d(0.0f, 0.0f, 0.0f));
125 }
126
127 Vec3uc color(VertexHandle _vh) const override
128 {
129 return (mesh_.has_vertex_colors()
130 ? color_cast<Vec3uc>(mesh_.color(_vh))
131 : Vec3uc(0, 0, 0));
132 }
133
134 Vec4uc colorA(VertexHandle _vh) const override
135 {
136 return (mesh_.has_vertex_colors()
137 ? color_cast<Vec4uc>(mesh_.color(_vh))
138 : Vec4uc(0, 0, 0, 0));
139 }
140
141 Vec3ui colori(VertexHandle _vh) const override
142 {
143 return (mesh_.has_vertex_colors()
144 ? color_cast<Vec3ui>(mesh_.color(_vh))
145 : Vec3ui(0, 0, 0));
146 }
147
148 Vec4ui colorAi(VertexHandle _vh) const override
149 {
150 return (mesh_.has_vertex_colors()
151 ? color_cast<Vec4ui>(mesh_.color(_vh))
152 : Vec4ui(0, 0, 0, 0));
153 }
154
155 Vec3f colorf(VertexHandle _vh) const override
156 {
157 return (mesh_.has_vertex_colors()
158 ? color_cast<Vec3f>(mesh_.color(_vh))
159 : Vec3f(0, 0, 0));
160 }
161
162 Vec4f colorAf(VertexHandle _vh) const override
163 {
164 return (mesh_.has_vertex_colors()
165 ? color_cast<Vec4f>(mesh_.color(_vh))
166 : Vec4f(0, 0, 0, 0));
167 }
168
169 Vec2f texcoord(VertexHandle _vh) const override
170 {
171 #if defined(OM_CC_GCC) && (OM_CC_VERSION<30000)
172 // Workaround!
173 // gcc 2.95.3 exits with internal compiler error at the
174 // code below!??? **)
175 if (mesh_.has_vertex_texcoords2D())
176 return vector_cast<Vec2f>(mesh_.texcoord2D(_vh));
177 return Vec2f(0.0f, 0.0f);
178 #else // **)
179 return (mesh_.has_vertex_texcoords2D()
180 ? vector_cast<Vec2f>(mesh_.texcoord2D(_vh))
181 : Vec2f(0.0f, 0.0f));
182 #endif
183 }
184
185 Vec2f texcoord(HalfedgeHandle _heh) const override
186 {
187 return (mesh_.has_halfedge_texcoords2D()
188 ? vector_cast<Vec2f>(mesh_.texcoord2D(_heh))
189 : Vec2f(0.0f, 0.0f));
190 }
191
192 OpenMesh::Attributes::StatusInfo status(VertexHandle _vh) const override
193 {
194 if (mesh_.has_vertex_status())
195 return mesh_.status(_vh);
196 return OpenMesh::Attributes::StatusInfo();
197 }
198
199 // get edge data
200
201 Vec3uc color(EdgeHandle _eh) const override
202 {
203 return (mesh_.has_edge_colors()
204 ? color_cast<Vec3uc>(mesh_.color(_eh))
205 : Vec3uc(0, 0, 0));
206 }
207
208 Vec4uc colorA(EdgeHandle _eh) const override
209 {
210 return (mesh_.has_edge_colors()
211 ? color_cast<Vec4uc>(mesh_.color(_eh))
212 : Vec4uc(0, 0, 0, 0));
213 }
214
215 Vec3ui colori(EdgeHandle _eh) const override
216 {
217 return (mesh_.has_edge_colors()
218 ? color_cast<Vec3ui>(mesh_.color(_eh))
219 : Vec3ui(0, 0, 0));
220 }
221
222 Vec4ui colorAi(EdgeHandle _eh) const override
223 {
224 return (mesh_.has_edge_colors()
225 ? color_cast<Vec4ui>(mesh_.color(_eh))
226 : Vec4ui(0, 0, 0, 0));
227 }
228
229 Vec3f colorf(EdgeHandle _eh) const override
230 {
231 return (mesh_.has_vertex_colors()
232 ? color_cast<Vec3f>(mesh_.color(_eh))
233 : Vec3f(0, 0, 0));
234 }
235
236 Vec4f colorAf(EdgeHandle _eh) const override
237 {
238 return (mesh_.has_vertex_colors()
239 ? color_cast<Vec4f>(mesh_.color(_eh))
240 : Vec4f(0, 0, 0, 0));
241 }
242
243 OpenMesh::Attributes::StatusInfo status(EdgeHandle _eh) const override
244 {
245 if (mesh_.has_edge_status())
246 return mesh_.status(_eh);
247 return OpenMesh::Attributes::StatusInfo();
248 }
249
250 // get halfedge data
251
252 int get_halfedge_id(VertexHandle _vh) override
253 {
254 return mesh_.halfedge_handle(_vh).idx();
255 }
256
257 int get_halfedge_id(FaceHandle _fh) override
258 {
259 return mesh_.halfedge_handle(_fh).idx();
260 }
261
262 int get_next_halfedge_id(HalfedgeHandle _heh) override
263 {
264 return mesh_.next_halfedge_handle(_heh).idx();
265 }
266
267 int get_to_vertex_id(HalfedgeHandle _heh) override
268 {
269 return mesh_.to_vertex_handle(_heh).idx();
270 }
271
272 int get_face_id(HalfedgeHandle _heh) override
273 {
274 return mesh_.face_handle(_heh).idx();
275 }
276
277 OpenMesh::Attributes::StatusInfo status(HalfedgeHandle _heh) const override
278 {
279 if (mesh_.has_halfedge_status())
280 return mesh_.status(_heh);
281 return OpenMesh::Attributes::StatusInfo();
282 }
283
284 // get face data
285
286 unsigned int get_vhandles(FaceHandle _fh,
287 std::vector<VertexHandle>& _vhandles) const override
288 {
289 unsigned int count(0);
290 _vhandles.clear();
291 for (typename Mesh::CFVIter fv_it=mesh_.cfv_iter(_fh); fv_it.is_valid(); ++fv_it)
292 {
293 _vhandles.push_back(*fv_it);
294 ++count;
295 }
296 return count;
297 }
298
299 unsigned int get_face_texcoords(std::vector<Vec2f>& _hehandles) const override
300 {
301 unsigned int count(0);
302 _hehandles.clear();
303 for(typename Mesh::CHIter he_it=mesh_.halfedges_begin();
304 he_it != mesh_.halfedges_end(); ++he_it)
305 {
306 _hehandles.push_back(vector_cast<Vec2f>(mesh_.texcoord2D( *he_it)));
307 ++count;
308 }
309
310 return count;
311 }
312
313 HalfedgeHandle getHeh(FaceHandle _fh, VertexHandle _vh) const override
314 {
315 typename Mesh::ConstFaceHalfedgeIter fh_it;
316 for(fh_it = mesh_.cfh_iter(_fh); fh_it.is_valid();++fh_it)
317 {
318 if(mesh_.to_vertex_handle(*fh_it) == _vh)
319 return *fh_it;
320 }
321 return *fh_it;
322 }
323
324 Vec3f normal(FaceHandle _fh) const override
325 {
326 return (mesh_.has_face_normals()
327 ? vector_cast<Vec3f>(mesh_.normal(_fh))
328 : Vec3f(0.0f, 0.0f, 0.0f));
329 }
330
331 Vec3d normald(FaceHandle _fh) const override
332 {
333 return (mesh_.has_face_normals()
334 ? vector_cast<Vec3d>(mesh_.normal(_fh))
335 : Vec3d(0.0, 0.0, 0.0));
336 }
337
338 Vec3uc color(FaceHandle _fh) const override
339 {
340 return (mesh_.has_face_colors()
341 ? color_cast<Vec3uc>(mesh_.color(_fh))
342 : Vec3uc(0, 0, 0));
343 }
344
345 Vec4uc colorA(FaceHandle _fh) const override
346 {
347 return (mesh_.has_face_colors()
348 ? color_cast<Vec4uc>(mesh_.color(_fh))
349 : Vec4uc(0, 0, 0, 0));
350 }
351
352 Vec3ui colori(FaceHandle _fh) const override
353 {
354 return (mesh_.has_face_colors()
355 ? color_cast<Vec3ui>(mesh_.color(_fh))
356 : Vec3ui(0, 0, 0));
357 }
358
359 Vec4ui colorAi(FaceHandle _fh) const override
360 {
361 return (mesh_.has_face_colors()
362 ? color_cast<Vec4ui>(mesh_.color(_fh))
363 : Vec4ui(0, 0, 0, 0));
364 }
365
366 Vec3f colorf(FaceHandle _fh) const override
367 {
368 return (mesh_.has_face_colors()
369 ? color_cast<Vec3f>(mesh_.color(_fh))
370 : Vec3f(0, 0, 0));
371 }
372
373 Vec4f colorAf(FaceHandle _fh) const override
374 {
375 return (mesh_.has_face_colors()
376 ? color_cast<Vec4f>(mesh_.color(_fh))
377 : Vec4f(0, 0, 0, 0));
378 }
379
380 OpenMesh::Attributes::StatusInfo status(FaceHandle _fh) const override
381 {
382 if (mesh_.has_face_status())
383 return mesh_.status(_fh);
384 return OpenMesh::Attributes::StatusInfo();
385 }
386
387 virtual const BaseKernel* kernel() override { return &mesh_; }
388
389
390 // query number of faces, vertices, normals, texcoords
391 size_t n_vertices() const override { return mesh_.n_vertices(); }
392 size_t n_faces() const override { return mesh_.n_faces(); }
393 size_t n_edges() const override { return mesh_.n_edges(); }
394
395
396 // property information
397 bool is_triangle_mesh() const override
398 { return Mesh::is_triangles(); }
399
400 bool has_vertex_normals() const override { return mesh_.has_vertex_normals(); }
401 bool has_vertex_colors() const override { return mesh_.has_vertex_colors(); }
402 bool has_vertex_texcoords() const override { return mesh_.has_vertex_texcoords2D(); }
403 bool has_vertex_status() const override { return mesh_.has_vertex_status(); }
404 bool has_edge_colors() const override { return mesh_.has_edge_colors(); }
405 bool has_edge_status() const override { return mesh_.has_edge_status(); }
406 bool has_halfedge_status() const override { return mesh_.has_halfedge_status(); }
407 bool has_face_normals() const override { return mesh_.has_face_normals(); }
408 bool has_face_colors() const override { return mesh_.has_face_colors(); }
409 bool has_face_status() const override { return mesh_.has_face_status(); }
410
411 private:
412
413 const Mesh& mesh_;
414 };
415
416
417 //=============================================================================
418 } // namespace IO
419 } // namespace OpenMesh
420 //=============================================================================
421 #endif
422 //=============================================================================
OpenMesh::vector_cast
void vector_cast(const src_t &_src, dst_t &_dst, GenProg::Int2Type< n >)
Cast vector type to another vector type by copying the vector elements.
Definition: vector_cast.hh:81
OpenMesh::FaceHandle
Handle for a face entity.
Definition: Handles.hh:141
OpenMesh::Vec4f
VectorT< float, 4 > Vec4f
4-float vector
Definition: Vector11T.hh:869
OpenMesh::Vec4ui
VectorT< unsigned int, 4 > Vec4ui
4-int unsigned vector
Definition: Vector11T.hh:867
OpenMesh::PolyMesh_ArrayKernelT
Polygonal mesh based on the ArrayKernel.
Definition: PolyMesh_ArrayKernelT.hh:94
OpenMesh::VectorT< float, 3 >
OpenMesh::Vec3ui
VectorT< unsigned int, 3 > Vec3ui
3-int unsigned vector
Definition: Vector11T.hh:848
OpenMesh::PolyMeshT::ConstFaceHalfedgeIter
Kernel::ConstFaceHalfedgeIter ConstFaceHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:178
OpenMesh::Vec3uc
VectorT< unsigned char, 3 > Vec3uc
3-byte unsigned vector
Definition: Vector11T.hh:840
OpenMesh::IO::ExporterT::getHeh
HalfedgeHandle getHeh(FaceHandle _fh, VertexHandle _vh) const override
getHeh returns the HalfEdgeHandle that belongs to the face specified by _fh and has a toVertexHandle ...
Definition: ExporterT.hh:313
OpenMesh::Vec3f
VectorT< float, 3 > Vec3f
3-float vector
Definition: Vector11T.hh:850
OpenMesh::VertexHandle
Handle for a vertex entity.
Definition: Handles.hh:120
OpenMesh::PolyMeshT::Normal
Kernel::Normal Normal
Normal type.
Definition: PolyMeshT.hh:114
OpenMesh::IO::BaseExporter
Base class for exporter modules.
Definition: BaseExporter.hh:84
OpenMesh::Vec4uc
VectorT< unsigned char, 4 > Vec4uc
4-byte unsigned vector
Definition: Vector11T.hh:859
OpenMesh::Vec3d
VectorT< double, 3 > Vec3d
3-double vector
Definition: Vector11T.hh:852
VectorT< float, 4 >
OpenMesh::EdgeHandle
Handle for a edge entity.
Definition: Handles.hh:134
OpenMesh::IO::ExporterT
This class template provides an exporter module for OpenMesh meshes.
Definition: ExporterT.hh:83
OpenMesh::Vec2f
VectorT< float, 2 > Vec2f
2-float vector
Definition: Vector11T.hh:833
OpenMesh::Attributes::StatusInfo
Add status information to a base class.
Definition: Status.hh:94
OpenMesh::PolyMeshT::Point
Kernel::Point Point
Coordinate type.
Definition: PolyMeshT.hh:112
OpenMesh
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:59
OpenMesh::HalfedgeHandle
Handle for a halfedge entity.
Definition: Handles.hh:127
OpenMesh::BaseKernel
This class provides low-level property management like adding/removing properties and access to prope...
Definition: BaseKernel.hh:97