Developer Documentation
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
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);
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);
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);
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);
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 //=============================================================================
VectorT< unsigned int, 3 > Vec3ui
Definition: Vector11T.hh:848
Handle for a edge entity.
Definition: Handles.hh:134
Handle for a face entity.
Definition: Handles.hh:141
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
VectorT< double, 3 > Vec3d
Definition: Vector11T.hh:852
VectorT< float, 2 > Vec2f
Definition: Vector11T.hh:833
Kernel::Normal Normal
Normal type.
Definition: PolyMeshT.hh:114
Handle for a halfedge entity.
Definition: Handles.hh:127
Kernel::Point Point
Coordinate type.
Definition: PolyMeshT.hh:112
VectorT< float, 3 > Vec3f
Definition: Vector11T.hh:850
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
Handle for a vertex entity.
Definition: Handles.hh:120
Kernel::ConstFaceHalfedgeIter ConstFaceHalfedgeIter
Circulator.
Definition: PolyMeshT.hh:178
VectorT< unsigned char, 4 > Vec4uc
Definition: Vector11T.hh:859
VectorT< unsigned char, 3 > Vec3uc
Definition: Vector11T.hh:840
VectorT< unsigned int, 4 > Vec4ui
Definition: Vector11T.hh:867
VectorT< float, 4 > Vec4f
Definition: Vector11T.hh:869