| OpenMesh

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

- File List
- File Members

All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Decimater.hh
1 #ifndef OPENMESH_PYTHON_DECIMATER_HH
2 #define OPENMESH_PYTHON_DECIMATER_HH
3
4 #include "Python/Bindings.hh"
5 #include "OpenMesh/Tools/Decimater/ModBaseT.hh"
6 #include "OpenMesh/Tools/Decimater/ModAspectRatioT.hh"
7 #include "OpenMesh/Tools/Decimater/ModEdgeLengthT.hh"
8 #include "OpenMesh/Tools/Decimater/ModHausdorffT.hh"
9 #include "OpenMesh/Tools/Decimater/ModIndependentSetsT.hh"
10 #include "OpenMesh/Tools/Decimater/ModNormalDeviationT.hh"
11 #include "OpenMesh/Tools/Decimater/ModNormalFlippingT.hh"
12 #include "OpenMesh/Tools/Decimater/ModProgMeshT.hh"
13 #include "OpenMesh/Tools/Decimater/ModQuadricT.hh"
14 #include "OpenMesh/Tools/Decimater/ModRoundnessT.hh"
15 #include "OpenMesh/Tools/Decimater/DecimaterT.hh"
16
17 #include <cstdio>
18
19 namespace OpenMesh {
20 namespace Python {
21
22 #define INIT_MESH_REF init<Mesh&>()[with_custodian_and_ward<1,2>()]
23
24 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(decimate_overloads, decimate, 0, 1)
25 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(decimate_to_faces_overloads, decimate_to_faces, 0, 2)
26 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_max_err_overloads, set_max_err, 1, 2)
27 BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(set_min_roundness_overloads, set_min_roundness, 1, 2)
28
29
30 template <class Handle>
31 void expose_module_handle(const char *_name) {
32 class_<Handle, boost::noncopyable>(_name)
33 .def("is_valid", &Handle::is_valid)
34 ;
35 }
36
37 template <class Module>
38 list infolist(Module& _self) {
39 const typename Module::InfoList& infos = _self.infolist();
40 list res;
41 for (size_t i = 0; i < infos.size(); ++i) {
42 res.append(infos[i]);
43 }
44 return res;
45 }
46
47 template <class Mesh>
48 void expose_decimater(const char *_name) {
49
50 typedef Decimater::ModBaseT<Mesh> ModBase;
51 typedef Decimater::ModAspectRatioT<Mesh> ModAspectRatio;
52 typedef Decimater::ModEdgeLengthT<Mesh> ModEdgeLength;
53 typedef Decimater::ModHausdorffT<Mesh> ModHausdorff;
54 typedef Decimater::ModIndependentSetsT<Mesh> ModIndependentSets;
55 typedef Decimater::ModNormalDeviationT<Mesh> ModNormalDeviation;
56 typedef Decimater::ModNormalFlippingT<Mesh> ModNormalFlipping;
57 typedef Decimater::ModProgMeshT<Mesh> ModProgMesh;
58 typedef Decimater::ModQuadricT<Mesh> ModQuadric;
59 typedef Decimater::ModRoundnessT<Mesh> ModRoundness;
60
61 typedef Decimater::ModHandleT<ModAspectRatio> ModAspectRatioHandle;
62 typedef Decimater::ModHandleT<ModEdgeLength> ModEdgeLengthHandle;
63 typedef Decimater::ModHandleT<ModHausdorff> ModHausdorffHandle;
64 typedef Decimater::ModHandleT<ModIndependentSets> ModIndependentSetsHandle;
65 typedef Decimater::ModHandleT<ModNormalDeviation> ModNormalDeviationHandle;
66 typedef Decimater::ModHandleT<ModNormalFlipping> ModNormalFlippingHandle;
67 typedef Decimater::ModHandleT<ModProgMesh> ModProgMeshHandle;
68 typedef Decimater::ModHandleT<ModQuadric> ModQuadricHandle;
69 typedef Decimater::ModHandleT<ModRoundness> ModRoundnessHandle;
70
71 typedef Decimater::BaseDecimaterT<Mesh> BaseDecimater;
72 typedef Decimater::DecimaterT<Mesh> Decimater;
73
74 typedef typename ModProgMesh::Info Info;
75 typedef std::vector<Info> InfoList;
76
77 bool (BaseDecimater::*add1)(ModAspectRatioHandle&) = &Decimater::add;
78 bool (BaseDecimater::*add2)(ModEdgeLengthHandle&) = &Decimater::add;
79 bool (BaseDecimater::*add3)(ModHausdorffHandle&) = &Decimater::add;
80 bool (BaseDecimater::*add4)(ModIndependentSetsHandle&) = &Decimater::add;
81 bool (BaseDecimater::*add5)(ModNormalDeviationHandle&) = &Decimater::add;
82 bool (BaseDecimater::*add6)(ModNormalFlippingHandle&) = &Decimater::add;
83 bool (BaseDecimater::*add7)(ModProgMeshHandle&) = &Decimater::add;
84 bool (BaseDecimater::*add8)(ModQuadricHandle&) = &Decimater::add;
85 bool (BaseDecimater::*add9)(ModRoundnessHandle&) = &Decimater::add;
86
87 bool (BaseDecimater::*remove1)(ModAspectRatioHandle&) = &Decimater::remove;
88 bool (BaseDecimater::*remove2)(ModEdgeLengthHandle&) = &Decimater::remove;
89 bool (BaseDecimater::*remove3)(ModHausdorffHandle&) = &Decimater::remove;
90 bool (BaseDecimater::*remove4)(ModIndependentSetsHandle&) = &Decimater::remove;
91 bool (BaseDecimater::*remove5)(ModNormalDeviationHandle&) = &Decimater::remove;
92 bool (BaseDecimater::*remove6)(ModNormalFlippingHandle&) = &Decimater::remove;
93 bool (BaseDecimater::*remove7)(ModProgMeshHandle&) = &Decimater::remove;
94 bool (BaseDecimater::*remove8)(ModQuadricHandle&) = &Decimater::remove;
95 bool (BaseDecimater::*remove9)(ModRoundnessHandle&) = &Decimater::remove;
96
97 ModAspectRatio& (BaseDecimater::*module1)(ModAspectRatioHandle&) = &Decimater::module;
98 ModEdgeLength& (BaseDecimater::*module2)(ModEdgeLengthHandle&) = &Decimater::module;
99 ModHausdorff& (BaseDecimater::*module3)(ModHausdorffHandle&) = &Decimater::module;
100 ModIndependentSets& (BaseDecimater::*module4)(ModIndependentSetsHandle&) = &Decimater::module;
101 ModNormalDeviation& (BaseDecimater::*module5)(ModNormalDeviationHandle&) = &Decimater::module;
102 ModNormalFlipping& (BaseDecimater::*module6)(ModNormalFlippingHandle&) = &Decimater::module;
103 ModProgMesh& (BaseDecimater::*module7)(ModProgMeshHandle&) = &Decimater::module;
104 ModQuadric& (BaseDecimater::*module8)(ModQuadricHandle&) = &Decimater::module;
105 ModRoundness& (BaseDecimater::*module9)(ModRoundnessHandle&) = &Decimater::module;
106
107 // Decimater
108 // ----------------------------------------
109
110 char buffer[64];
111 snprintf(buffer, sizeof buffer, "%s%s", _name, "Decimater");
112
113 class_<Decimater, boost::noncopyable>(buffer, INIT_MESH_REF)
114 .def("decimate", &Decimater::decimate, decimate_overloads())
115 .def("decimate_to", &Decimater::decimate_to)
116 .def("decimate_to_faces", &Decimater::decimate_to_faces, decimate_to_faces_overloads())
117
118 .def("initialize", &Decimater::initialize)
119 .def("is_initialized", &Decimater::is_initialized)
120
121 .def("add", add1)
122 .def("add", add2)
123 .def("add", add3)
124 .def("add", add4)
125 .def("add", add5)
126 .def("add", add6)
127 .def("add", add7)
128 .def("add", add8)
129 .def("add", add9)
130
131 .def("remove", remove1)
132 .def("remove", remove2)
133 .def("remove", remove3)
134 .def("remove", remove4)
135 .def("remove", remove5)
136 .def("remove", remove6)
137 .def("remove", remove7)
138 .def("remove", remove8)
139 .def("remove", remove9)
140
141 .def("module", module1, return_value_policy<reference_existing_object>())
142 .def("module", module2, return_value_policy<reference_existing_object>())
143 .def("module", module3, return_value_policy<reference_existing_object>())
144 .def("module", module4, return_value_policy<reference_existing_object>())
145 .def("module", module5, return_value_policy<reference_existing_object>())
146 .def("module", module6, return_value_policy<reference_existing_object>())
147 .def("module", module7, return_value_policy<reference_existing_object>())
148 .def("module", module8, return_value_policy<reference_existing_object>())
149 .def("module", module9, return_value_policy<reference_existing_object>())
150 ;
151
152 // ModBase
153 // ----------------------------------------
154
155 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModBase");
156
157 class_<ModBase, boost::noncopyable>(buffer, no_init)
158 .def("name", &ModBase::name, OPENMESH_PYTHON_DEFAULT_POLICY)
159 .def("is_binary", &ModBase::is_binary)
160 .def("set_binary", &ModBase::set_binary)
161 .def("initialize", &ModBase::initialize) // TODO VIRTUAL
162 .def("collapse_priority", &ModBase::collapse_priority) // TODO VIRTUAL
163 .def("preprocess_collapse", &ModBase::preprocess_collapse) // TODO VIRTUAL
164 .def("postprocess_collapse", &ModBase::postprocess_collapse) // TODO VIRTUAL
165 .def("set_error_tolerance_factor", &ModBase::set_error_tolerance_factor) // TODO VIRTUAL
166 ;
167
168 // ModAspectRatio
169 // ----------------------------------------
170
171 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModAspectRatio");
172
173 class_<ModAspectRatio, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
174 .def("aspect_ratio", &ModAspectRatio::aspect_ratio)
175 .def("set_aspect_ratio", &ModAspectRatio::set_aspect_ratio)
176 ;
177
178 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModAspectRatioHandle");
179 expose_module_handle<ModAspectRatioHandle>(buffer);
180
181 // ModEdgeLength
182 // ----------------------------------------
183
184 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModEdgeLength");
185
186 class_<ModEdgeLength, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
187 .def("edge_length", &ModEdgeLength::edge_length)
188 .def("set_edge_length", &ModEdgeLength::set_edge_length)
189 ;
190
191 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModEdgeLengthHandle");
192 expose_module_handle<ModEdgeLengthHandle>(buffer);
193
194 // ModHausdorff
195 // ----------------------------------------
196
197 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModHausdorff");
198
199 class_<ModHausdorff, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
200 .def("tolerance", &ModHausdorff::tolerance)
201 .def("set_tolerance", &ModHausdorff::set_tolerance)
202 ;
203
204 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModHausdorffHandle");
205 expose_module_handle<ModHausdorffHandle>(buffer);
206
207 // ModIndependentSets
208 // ----------------------------------------
209
210 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModIndependentSets");
211
212 class_<ModIndependentSets, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF);
213
214 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModIndependentSetsHandle");
215 expose_module_handle<ModIndependentSetsHandle>(buffer);
216
217 // ModNormalDeviation
218 // ----------------------------------------
219
220 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModNormalDeviation");
221
222 class_<ModNormalDeviation, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
223 .def("normal_deviation", &ModNormalDeviation::normal_deviation)
224 .def("set_normal_deviation", &ModNormalDeviation::set_normal_deviation)
225 ;
226
227 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModNormalDeviationHandle");
228 expose_module_handle<ModNormalDeviationHandle>(buffer);
229
230 // ModNormalFlipping
231 // ----------------------------------------
232
233 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModNormalFlipping");
234
235 class_<ModNormalFlipping, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
236 .def("max_normal_deviation", &ModNormalFlipping::max_normal_deviation)
237 .def("set_max_normal_deviation", &ModNormalFlipping::set_max_normal_deviation)
238 ;
239
240 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModNormalFlippingHandle");
241 expose_module_handle<ModNormalFlippingHandle>(buffer);
242
243 // ModProgMesh
244 // ----------------------------------------
245
246 class_<Info>("Info", no_init)
247 .def_readwrite("v0", &Info::v0)
248 .def_readwrite("v1", &Info::v1)
249 .def_readwrite("vl", &Info::vl)
250 .def_readwrite("vr", &Info::vr)
251 ;
252
253 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModProgMesh");
254
255 class_<ModProgMesh, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
256 .def("pmi", &infolist<ModProgMesh>)
257 .def("infolist", &infolist<ModProgMesh>)
258 .def("write", &ModProgMesh::write)
259 ;
260
261 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModProgMeshHandle");
262 expose_module_handle<ModProgMeshHandle>(buffer);
263
264 // ModQuadric
265 // ----------------------------------------
266
267 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModQuadric");
268
269 class_<ModQuadric, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
270 .def("set_max_err", &ModQuadric::set_max_err, set_max_err_overloads())
271 .def("unset_max_err", &ModQuadric::unset_max_err)
272 .def("max_err", &ModQuadric::max_err)
273 ;
274
275 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModQuadricHandle");
276 expose_module_handle<ModQuadricHandle>(buffer);
277
278 // ModRoundness
279 // ----------------------------------------
280
281 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModRoundness");
282
283 class_<ModRoundness, bases<ModBase>, boost::noncopyable>(buffer, INIT_MESH_REF)
284 .def("set_min_angle", &ModRoundness::set_min_angle)
285 .def("set_min_roundness", &ModRoundness::set_min_roundness, set_min_roundness_overloads())
286 .def("unset_min_roundness", &ModRoundness::unset_min_roundness)
287 .def("roundness", &ModRoundness::roundness)
288 ;
289
290 snprintf(buffer, sizeof buffer, "%s%s", _name, "ModRoundnessHandle");
291 expose_module_handle<ModRoundnessHandle>(buffer);
292 }
293
294 } // namespace OpenMesh
295 } // namespace Python
296
297 #endif
ModRoundnessT.hh
ModBaseT.hh
Base class for all decimation modules.
OPENMESH_PYTHON_DEFAULT_POLICY
#define OPENMESH_PYTHON_DEFAULT_POLICY
Return value policy for functions that return references to objects that are managed by OpenMesh...
Definition: Bindings.hh:29
ModNormalDeviationT.hh
ModQuadricT.hh
ModAspectRatioT.hh
ModNormalFlippingT.hh
ModEdgeLengthT.hh
OpenMesh
Contains all the mesh ingredients like the polygonal mesh, the triangle mesh, different mesh kernels ...
Definition: MeshItems.hh:64
Bindings.hh
DecimaterT.hh
ModHausdorffT.hh
ModProgMeshT.hh