GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
#ifndef DOXYGEN_AUTODOC_HPP_FCL_SHAPE_GEOMETRIC_SHAPES_H |
||
2 |
#define DOXYGEN_AUTODOC_HPP_FCL_SHAPE_GEOMETRIC_SHAPES_H |
||
3 |
|||
4 |
#include "/root/robotpkg/path/py-hpp-fcl/work/hpp-fcl-2.4.1/doc/python/doxygen.hh" |
||
5 |
|||
6 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
7 |
|||
8 |
namespace doxygen { |
||
9 |
|||
10 |
template <> |
||
11 |
struct class_doc_impl< hpp::fcl::Box > |
||
12 |
{ |
||
13 |
static inline const char* run () |
||
14 |
{ |
||
15 |
return "Center at zero point, axis aligned box. "; |
||
16 |
} |
||
17 |
5 |
static inline const char* attribute (const char* attrib) |
|
18 |
{ |
||
19 |
✓✗ | 5 |
if (strcmp(attrib, "halfSide") == 0) |
20 |
5 |
return "box side half-length "; |
|
21 |
(void)attrib; // turn off unused parameter warning. |
||
22 |
return ""; |
||
23 |
} |
||
24 |
}; |
||
25 |
|||
26 |
template <> |
||
27 |
struct constructor_3_impl< hpp::fcl::Box, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL > |
||
28 |
{ |
||
29 |
5 |
static inline const char* doc () |
|
30 |
{ |
||
31 |
5 |
return ""; |
|
32 |
} |
||
33 |
5 |
static inline boost::python::detail::keywords<3+1> args () |
|
34 |
{ |
||
35 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("x"), boost::python::arg("y"), boost::python::arg("z")); |
36 |
} |
||
37 |
}; |
||
38 |
|||
39 |
template <> |
||
40 |
struct constructor_1_impl< hpp::fcl::Box, const hpp::fcl::Vec3f & > |
||
41 |
{ |
||
42 |
5 |
static inline const char* doc () |
|
43 |
{ |
||
44 |
5 |
return ""; |
|
45 |
} |
||
46 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
47 |
{ |
||
48 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("side_")); |
49 |
} |
||
50 |
}; |
||
51 |
|||
52 |
template <> |
||
53 |
struct constructor_1_impl< hpp::fcl::Box, const hpp::fcl::Box & > |
||
54 |
{ |
||
55 |
5 |
static inline const char* doc () |
|
56 |
{ |
||
57 |
5 |
return ""; |
|
58 |
} |
||
59 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
60 |
{ |
||
61 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("other")); |
62 |
} |
||
63 |
}; |
||
64 |
|||
65 |
template <> |
||
66 |
struct constructor_0_impl< hpp::fcl::Box > |
||
67 |
{ |
||
68 |
5 |
static inline const char* doc () |
|
69 |
{ |
||
70 |
5 |
return "Default constructor. "; |
|
71 |
} |
||
72 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
73 |
{ |
||
74 |
5 |
return (boost::python::arg("self")); |
|
75 |
} |
||
76 |
}; |
||
77 |
|||
78 |
inline const char* member_func_doc ( hpp::fcl::Box & (hpp::fcl::Box::*function_ptr) (const hpp::fcl::Box &)) |
||
79 |
{ |
||
80 |
if (function_ptr == static_cast< hpp::fcl::Box & (hpp::fcl::Box::*) (const hpp::fcl::Box &)>(&hpp::fcl::Box::operator=)) |
||
81 |
return ""; |
||
82 |
return ""; |
||
83 |
} |
||
84 |
|||
85 |
inline boost::python::detail::keywords<2> member_func_args ( hpp::fcl::Box & (hpp::fcl::Box::*function_ptr) (const hpp::fcl::Box &)) |
||
86 |
{ |
||
87 |
if (function_ptr == static_cast< hpp::fcl::Box & (hpp::fcl::Box::*) (const hpp::fcl::Box &)>(&hpp::fcl::Box::operator=)) |
||
88 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
89 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
90 |
} |
||
91 |
|||
92 |
5 |
inline const char* member_func_doc ( hpp::fcl::Box * (hpp::fcl::Box::*function_ptr) () const) |
|
93 |
{ |
||
94 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast< hpp::fcl::Box * (hpp::fcl::Box::*) () const>(&hpp::fcl::Box::clone)) |
95 |
5 |
return "Clone *this into a new hpp::fcl::Box. "; |
|
96 |
return ""; |
||
97 |
} |
||
98 |
|||
99 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Box * (hpp::fcl::Box::*function_ptr) () const) |
||
100 |
{ |
||
101 |
if (function_ptr == static_cast< hpp::fcl::Box * (hpp::fcl::Box::*) () const>(&hpp::fcl::Box::clone)) |
||
102 |
return (boost::python::arg("self")); |
||
103 |
return (boost::python::arg("self")); |
||
104 |
} |
||
105 |
|||
106 |
inline const char* member_func_doc (void (hpp::fcl::Box::*function_ptr) ()) |
||
107 |
{ |
||
108 |
if (function_ptr == static_cast<void (hpp::fcl::Box::*) ()>(&hpp::fcl::Box::computeLocalAABB)) |
||
109 |
return "Compute hpp::fcl::AABB. "; |
||
110 |
return ""; |
||
111 |
} |
||
112 |
|||
113 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::Box::*function_ptr) ()) |
||
114 |
{ |
||
115 |
if (function_ptr == static_cast<void (hpp::fcl::Box::*) ()>(&hpp::fcl::Box::computeLocalAABB)) |
||
116 |
return (boost::python::arg("self")); |
||
117 |
return (boost::python::arg("self")); |
||
118 |
} |
||
119 |
|||
120 |
inline const char* member_func_doc ( hpp::fcl::NODE_TYPE (hpp::fcl::Box::*function_ptr) () const) |
||
121 |
{ |
||
122 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Box::*) () const>(&hpp::fcl::Box::getNodeType)) |
||
123 |
return "Get node type: a box. "; |
||
124 |
return ""; |
||
125 |
} |
||
126 |
|||
127 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::NODE_TYPE (hpp::fcl::Box::*function_ptr) () const) |
||
128 |
{ |
||
129 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Box::*) () const>(&hpp::fcl::Box::getNodeType)) |
||
130 |
return (boost::python::arg("self")); |
||
131 |
return (boost::python::arg("self")); |
||
132 |
} |
||
133 |
|||
134 |
inline const char* member_func_doc ( hpp::fcl::FCL_REAL (hpp::fcl::Box::*function_ptr) () const) |
||
135 |
{ |
||
136 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Box::*) () const>(&hpp::fcl::Box::computeVolume)) |
||
137 |
return "compute the volume "; |
||
138 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Box::*) () const>(&hpp::fcl::Box::minInflationValue)) |
||
139 |
return ""; |
||
140 |
return ""; |
||
141 |
} |
||
142 |
|||
143 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::FCL_REAL (hpp::fcl::Box::*function_ptr) () const) |
||
144 |
{ |
||
145 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Box::*) () const>(&hpp::fcl::Box::computeVolume)) |
||
146 |
return (boost::python::arg("self")); |
||
147 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Box::*) () const>(&hpp::fcl::Box::minInflationValue)) |
||
148 |
return (boost::python::arg("self")); |
||
149 |
return (boost::python::arg("self")); |
||
150 |
} |
||
151 |
|||
152 |
inline const char* member_func_doc ( hpp::fcl::Matrix3f (hpp::fcl::Box::*function_ptr) () const) |
||
153 |
{ |
||
154 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Box::*) () const>(&hpp::fcl::Box::computeMomentofInertia)) |
||
155 |
return "compute the inertia matrix, related to the origin "; |
||
156 |
return ""; |
||
157 |
} |
||
158 |
|||
159 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Matrix3f (hpp::fcl::Box::*function_ptr) () const) |
||
160 |
{ |
||
161 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Box::*) () const>(&hpp::fcl::Box::computeMomentofInertia)) |
||
162 |
return (boost::python::arg("self")); |
||
163 |
return (boost::python::arg("self")); |
||
164 |
} |
||
165 |
|||
166 |
inline const char* member_func_doc (std::pair< hpp::fcl::Box , hpp::fcl::Transform3f > (hpp::fcl::Box::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
167 |
{ |
||
168 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Box , hpp::fcl::Transform3f > (hpp::fcl::Box::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Box::inflated)) |
||
169 |
return "Inflate the box by an amount given by value. \n" |
||
170 |
"\n" |
||
171 |
"\n" |
||
172 |
"Param\n" |
||
173 |
" - value of the shape inflation.\n" |
||
174 |
"\n" |
||
175 |
"Return: a new inflated box and the related transform to account for the change of shape frame "; |
||
176 |
return ""; |
||
177 |
} |
||
178 |
|||
179 |
inline boost::python::detail::keywords<2> member_func_args (std::pair< hpp::fcl::Box , hpp::fcl::Transform3f > (hpp::fcl::Box::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
180 |
{ |
||
181 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Box , hpp::fcl::Transform3f > (hpp::fcl::Box::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Box::inflated)) |
||
182 |
return (boost::python::arg("self"), boost::python::arg("value")); |
||
183 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
184 |
} |
||
185 |
} // namespace doxygen |
||
186 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
187 |
|||
188 |
namespace doxygen { |
||
189 |
|||
190 |
template <> |
||
191 |
struct class_doc_impl< hpp::fcl::Capsule > |
||
192 |
{ |
||
193 |
5 |
static inline const char* run () |
|
194 |
{ |
||
195 |
5 |
return "hpp::fcl::Capsule It is $ { x~\in~\mathbb{R}^3, d(x, AB) \leq radius } $ where $ d(x, AB) $ is the distance between the point x and the capsule segment AB, with $ A = (0,0,-halfLength), B = (0,0,halfLength) $. "; |
|
196 |
} |
||
197 |
10 |
static inline const char* attribute (const char* attrib) |
|
198 |
{ |
||
199 |
✓✓ | 10 |
if (strcmp(attrib, "radius") == 0) |
200 |
5 |
return "Radius of capsule. "; |
|
201 |
✓✗ | 5 |
if (strcmp(attrib, "halfLength") == 0) |
202 |
5 |
return "Half Length along z axis. "; |
|
203 |
(void)attrib; // turn off unused parameter warning. |
||
204 |
return ""; |
||
205 |
} |
||
206 |
}; |
||
207 |
|||
208 |
template <> |
||
209 |
struct constructor_0_impl< hpp::fcl::Capsule > |
||
210 |
{ |
||
211 |
5 |
static inline const char* doc () |
|
212 |
{ |
||
213 |
5 |
return "Default constructor. "; |
|
214 |
} |
||
215 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
216 |
{ |
||
217 |
5 |
return (boost::python::arg("self")); |
|
218 |
} |
||
219 |
}; |
||
220 |
|||
221 |
template <> |
||
222 |
struct constructor_2_impl< hpp::fcl::Capsule, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL > |
||
223 |
{ |
||
224 |
5 |
static inline const char* doc () |
|
225 |
{ |
||
226 |
5 |
return ""; |
|
227 |
} |
||
228 |
5 |
static inline boost::python::detail::keywords<2+1> args () |
|
229 |
{ |
||
230 |
✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("radius_"), boost::python::arg("lz_")); |
231 |
} |
||
232 |
}; |
||
233 |
|||
234 |
template <> |
||
235 |
struct constructor_1_impl< hpp::fcl::Capsule, const hpp::fcl::Capsule & > |
||
236 |
{ |
||
237 |
5 |
static inline const char* doc () |
|
238 |
{ |
||
239 |
5 |
return ""; |
|
240 |
} |
||
241 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
242 |
{ |
||
243 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("other")); |
244 |
} |
||
245 |
}; |
||
246 |
|||
247 |
5 |
inline const char* member_func_doc ( hpp::fcl::Capsule * (hpp::fcl::Capsule::*function_ptr) () const) |
|
248 |
{ |
||
249 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast< hpp::fcl::Capsule * (hpp::fcl::Capsule::*) () const>(&hpp::fcl::Capsule::clone)) |
250 |
5 |
return "Clone *this into a new hpp::fcl::Capsule. "; |
|
251 |
return ""; |
||
252 |
} |
||
253 |
|||
254 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Capsule * (hpp::fcl::Capsule::*function_ptr) () const) |
||
255 |
{ |
||
256 |
if (function_ptr == static_cast< hpp::fcl::Capsule * (hpp::fcl::Capsule::*) () const>(&hpp::fcl::Capsule::clone)) |
||
257 |
return (boost::python::arg("self")); |
||
258 |
return (boost::python::arg("self")); |
||
259 |
} |
||
260 |
|||
261 |
inline const char* member_func_doc (void (hpp::fcl::Capsule::*function_ptr) ()) |
||
262 |
{ |
||
263 |
if (function_ptr == static_cast<void (hpp::fcl::Capsule::*) ()>(&hpp::fcl::Capsule::computeLocalAABB)) |
||
264 |
return "Compute hpp::fcl::AABB. "; |
||
265 |
return ""; |
||
266 |
} |
||
267 |
|||
268 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::Capsule::*function_ptr) ()) |
||
269 |
{ |
||
270 |
if (function_ptr == static_cast<void (hpp::fcl::Capsule::*) ()>(&hpp::fcl::Capsule::computeLocalAABB)) |
||
271 |
return (boost::python::arg("self")); |
||
272 |
return (boost::python::arg("self")); |
||
273 |
} |
||
274 |
|||
275 |
inline const char* member_func_doc ( hpp::fcl::NODE_TYPE (hpp::fcl::Capsule::*function_ptr) () const) |
||
276 |
{ |
||
277 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Capsule::*) () const>(&hpp::fcl::Capsule::getNodeType)) |
||
278 |
return "Get node type: a capsule. "; |
||
279 |
return ""; |
||
280 |
} |
||
281 |
|||
282 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::NODE_TYPE (hpp::fcl::Capsule::*function_ptr) () const) |
||
283 |
{ |
||
284 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Capsule::*) () const>(&hpp::fcl::Capsule::getNodeType)) |
||
285 |
return (boost::python::arg("self")); |
||
286 |
return (boost::python::arg("self")); |
||
287 |
} |
||
288 |
|||
289 |
inline const char* member_func_doc ( hpp::fcl::FCL_REAL (hpp::fcl::Capsule::*function_ptr) () const) |
||
290 |
{ |
||
291 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Capsule::*) () const>(&hpp::fcl::Capsule::computeVolume)) |
||
292 |
return "compute the volume "; |
||
293 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Capsule::*) () const>(&hpp::fcl::Capsule::minInflationValue)) |
||
294 |
return ""; |
||
295 |
return ""; |
||
296 |
} |
||
297 |
|||
298 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::FCL_REAL (hpp::fcl::Capsule::*function_ptr) () const) |
||
299 |
{ |
||
300 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Capsule::*) () const>(&hpp::fcl::Capsule::computeVolume)) |
||
301 |
return (boost::python::arg("self")); |
||
302 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Capsule::*) () const>(&hpp::fcl::Capsule::minInflationValue)) |
||
303 |
return (boost::python::arg("self")); |
||
304 |
return (boost::python::arg("self")); |
||
305 |
} |
||
306 |
|||
307 |
inline const char* member_func_doc ( hpp::fcl::Matrix3f (hpp::fcl::Capsule::*function_ptr) () const) |
||
308 |
{ |
||
309 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Capsule::*) () const>(&hpp::fcl::Capsule::computeMomentofInertia)) |
||
310 |
return "compute the inertia matrix, related to the origin "; |
||
311 |
return ""; |
||
312 |
} |
||
313 |
|||
314 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Matrix3f (hpp::fcl::Capsule::*function_ptr) () const) |
||
315 |
{ |
||
316 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Capsule::*) () const>(&hpp::fcl::Capsule::computeMomentofInertia)) |
||
317 |
return (boost::python::arg("self")); |
||
318 |
return (boost::python::arg("self")); |
||
319 |
} |
||
320 |
|||
321 |
inline const char* member_func_doc (std::pair< hpp::fcl::Capsule , hpp::fcl::Transform3f > (hpp::fcl::Capsule::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
322 |
{ |
||
323 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Capsule , hpp::fcl::Transform3f > (hpp::fcl::Capsule::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Capsule::inflated)) |
||
324 |
return "Inflate the capsule by an amount given by value. \n" |
||
325 |
"\n" |
||
326 |
"\n" |
||
327 |
"Param\n" |
||
328 |
" - value of the shape inflation.\n" |
||
329 |
"\n" |
||
330 |
"Return: a new inflated capsule and the related transform to account for the change of shape frame "; |
||
331 |
return ""; |
||
332 |
} |
||
333 |
|||
334 |
inline boost::python::detail::keywords<2> member_func_args (std::pair< hpp::fcl::Capsule , hpp::fcl::Transform3f > (hpp::fcl::Capsule::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
335 |
{ |
||
336 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Capsule , hpp::fcl::Transform3f > (hpp::fcl::Capsule::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Capsule::inflated)) |
||
337 |
return (boost::python::arg("self"), boost::python::arg("value")); |
||
338 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
339 |
} |
||
340 |
} // namespace doxygen |
||
341 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
342 |
|||
343 |
namespace doxygen { |
||
344 |
|||
345 |
template <> |
||
346 |
struct class_doc_impl< hpp::fcl::Cone > |
||
347 |
{ |
||
348 |
5 |
static inline const char* run () |
|
349 |
{ |
||
350 |
5 |
return "hpp::fcl::Cone The base of the cone is at $ z = - halfLength $ and the top is at $ z = halfLength $. "; |
|
351 |
} |
||
352 |
10 |
static inline const char* attribute (const char* attrib) |
|
353 |
{ |
||
354 |
✓✓ | 10 |
if (strcmp(attrib, "radius") == 0) |
355 |
5 |
return "Radius of the cone. "; |
|
356 |
✓✗ | 5 |
if (strcmp(attrib, "halfLength") == 0) |
357 |
5 |
return "Half Length along z axis. "; |
|
358 |
(void)attrib; // turn off unused parameter warning. |
||
359 |
return ""; |
||
360 |
} |
||
361 |
}; |
||
362 |
|||
363 |
template <> |
||
364 |
struct constructor_0_impl< hpp::fcl::Cone > |
||
365 |
{ |
||
366 |
5 |
static inline const char* doc () |
|
367 |
{ |
||
368 |
5 |
return "Default constructor. "; |
|
369 |
} |
||
370 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
371 |
{ |
||
372 |
5 |
return (boost::python::arg("self")); |
|
373 |
} |
||
374 |
}; |
||
375 |
|||
376 |
template <> |
||
377 |
struct constructor_2_impl< hpp::fcl::Cone, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL > |
||
378 |
{ |
||
379 |
5 |
static inline const char* doc () |
|
380 |
{ |
||
381 |
5 |
return ""; |
|
382 |
} |
||
383 |
5 |
static inline boost::python::detail::keywords<2+1> args () |
|
384 |
{ |
||
385 |
✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("radius_"), boost::python::arg("lz_")); |
386 |
} |
||
387 |
}; |
||
388 |
|||
389 |
template <> |
||
390 |
struct constructor_1_impl< hpp::fcl::Cone, const hpp::fcl::Cone & > |
||
391 |
{ |
||
392 |
5 |
static inline const char* doc () |
|
393 |
{ |
||
394 |
5 |
return ""; |
|
395 |
} |
||
396 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
397 |
{ |
||
398 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("other")); |
399 |
} |
||
400 |
}; |
||
401 |
|||
402 |
5 |
inline const char* member_func_doc ( hpp::fcl::Cone * (hpp::fcl::Cone::*function_ptr) () const) |
|
403 |
{ |
||
404 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast< hpp::fcl::Cone * (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::clone)) |
405 |
5 |
return "Clone *this into a new hpp::fcl::Cone. "; |
|
406 |
return ""; |
||
407 |
} |
||
408 |
|||
409 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Cone * (hpp::fcl::Cone::*function_ptr) () const) |
||
410 |
{ |
||
411 |
if (function_ptr == static_cast< hpp::fcl::Cone * (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::clone)) |
||
412 |
return (boost::python::arg("self")); |
||
413 |
return (boost::python::arg("self")); |
||
414 |
} |
||
415 |
|||
416 |
inline const char* member_func_doc (void (hpp::fcl::Cone::*function_ptr) ()) |
||
417 |
{ |
||
418 |
if (function_ptr == static_cast<void (hpp::fcl::Cone::*) ()>(&hpp::fcl::Cone::computeLocalAABB)) |
||
419 |
return "Compute hpp::fcl::AABB. "; |
||
420 |
return ""; |
||
421 |
} |
||
422 |
|||
423 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::Cone::*function_ptr) ()) |
||
424 |
{ |
||
425 |
if (function_ptr == static_cast<void (hpp::fcl::Cone::*) ()>(&hpp::fcl::Cone::computeLocalAABB)) |
||
426 |
return (boost::python::arg("self")); |
||
427 |
return (boost::python::arg("self")); |
||
428 |
} |
||
429 |
|||
430 |
inline const char* member_func_doc ( hpp::fcl::NODE_TYPE (hpp::fcl::Cone::*function_ptr) () const) |
||
431 |
{ |
||
432 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::getNodeType)) |
||
433 |
return "Get node type: a cone. "; |
||
434 |
return ""; |
||
435 |
} |
||
436 |
|||
437 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::NODE_TYPE (hpp::fcl::Cone::*function_ptr) () const) |
||
438 |
{ |
||
439 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::getNodeType)) |
||
440 |
return (boost::python::arg("self")); |
||
441 |
return (boost::python::arg("self")); |
||
442 |
} |
||
443 |
|||
444 |
inline const char* member_func_doc ( hpp::fcl::FCL_REAL (hpp::fcl::Cone::*function_ptr) () const) |
||
445 |
{ |
||
446 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::computeVolume)) |
||
447 |
return "compute the volume "; |
||
448 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::minInflationValue)) |
||
449 |
return ""; |
||
450 |
return ""; |
||
451 |
} |
||
452 |
|||
453 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::FCL_REAL (hpp::fcl::Cone::*function_ptr) () const) |
||
454 |
{ |
||
455 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::computeVolume)) |
||
456 |
return (boost::python::arg("self")); |
||
457 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::minInflationValue)) |
||
458 |
return (boost::python::arg("self")); |
||
459 |
return (boost::python::arg("self")); |
||
460 |
} |
||
461 |
|||
462 |
inline const char* member_func_doc ( hpp::fcl::Matrix3f (hpp::fcl::Cone::*function_ptr) () const) |
||
463 |
{ |
||
464 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::computeMomentofInertia)) |
||
465 |
return "compute the inertia matrix, related to the origin "; |
||
466 |
return ""; |
||
467 |
} |
||
468 |
|||
469 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Matrix3f (hpp::fcl::Cone::*function_ptr) () const) |
||
470 |
{ |
||
471 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::computeMomentofInertia)) |
||
472 |
return (boost::python::arg("self")); |
||
473 |
return (boost::python::arg("self")); |
||
474 |
} |
||
475 |
|||
476 |
inline const char* member_func_doc ( hpp::fcl::Vec3f (hpp::fcl::Cone::*function_ptr) () const) |
||
477 |
{ |
||
478 |
if (function_ptr == static_cast< hpp::fcl::Vec3f (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::computeCOM)) |
||
479 |
return "compute center of mass "; |
||
480 |
return ""; |
||
481 |
} |
||
482 |
|||
483 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Vec3f (hpp::fcl::Cone::*function_ptr) () const) |
||
484 |
{ |
||
485 |
if (function_ptr == static_cast< hpp::fcl::Vec3f (hpp::fcl::Cone::*) () const>(&hpp::fcl::Cone::computeCOM)) |
||
486 |
return (boost::python::arg("self")); |
||
487 |
return (boost::python::arg("self")); |
||
488 |
} |
||
489 |
|||
490 |
inline const char* member_func_doc (std::pair< hpp::fcl::Cone , hpp::fcl::Transform3f > (hpp::fcl::Cone::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
491 |
{ |
||
492 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Cone , hpp::fcl::Transform3f > (hpp::fcl::Cone::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Cone::inflated)) |
||
493 |
return "Inflate the cone by an amount given by value. \n" |
||
494 |
"\n" |
||
495 |
"\n" |
||
496 |
"Param\n" |
||
497 |
" - value of the shape inflation.\n" |
||
498 |
"\n" |
||
499 |
"Return: a new inflated cone and the related transform to account for the change of shape frame "; |
||
500 |
return ""; |
||
501 |
} |
||
502 |
|||
503 |
inline boost::python::detail::keywords<2> member_func_args (std::pair< hpp::fcl::Cone , hpp::fcl::Transform3f > (hpp::fcl::Cone::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
504 |
{ |
||
505 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Cone , hpp::fcl::Transform3f > (hpp::fcl::Cone::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Cone::inflated)) |
||
506 |
return (boost::python::arg("self"), boost::python::arg("value")); |
||
507 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
508 |
} |
||
509 |
} // namespace doxygen |
||
510 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
511 |
|||
512 |
namespace doxygen { |
||
513 |
|||
514 |
template <> |
||
515 |
struct class_doc_impl< hpp::fcl::ConvexBase > |
||
516 |
{ |
||
517 |
5 |
static inline const char* run () |
|
518 |
{ |
||
519 |
return "Base for convex polytope. \n" |
||
520 |
"\n" |
||
521 |
5 |
"Note: Inherited classes are responsible for filling ConvexBase::neighbors; "; |
|
522 |
} |
||
523 |
10 |
static inline const char* attribute (const char* attrib) |
|
524 |
{ |
||
525 |
✗✓ | 10 |
if (strcmp(attrib, "points") == 0) |
526 |
return "An array of the points of the polygon. "; |
||
527 |
✗✓ | 10 |
if (strcmp(attrib, "neighbors") == 0) |
528 |
return "hpp::fcl::ConvexBase::Neighbors of each vertex. It is an array of size num_points. For each vertex, it contains the number of neighbors and a list of indices to them. "; |
||
529 |
✓✓ | 10 |
if (strcmp(attrib, "center") == 0) |
530 |
5 |
return "center of the convex polytope, this is used for collision: center is guaranteed in the internal of the polytope (as it is convex) "; |
|
531 |
(void)attrib; // turn off unused parameter warning. |
||
532 |
5 |
return ""; |
|
533 |
} |
||
534 |
}; |
||
535 |
|||
536 |
template <> |
||
537 |
struct destructor_doc_impl < hpp::fcl::ConvexBase > |
||
538 |
{ |
||
539 |
static inline const char* run () |
||
540 |
{ |
||
541 |
return ""; |
||
542 |
} |
||
543 |
}; |
||
544 |
|||
545 |
5 |
inline const char* member_func_doc ( hpp::fcl::ConvexBase * (hpp::fcl::ConvexBase::*function_ptr) () const) |
|
546 |
{ |
||
547 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast< hpp::fcl::ConvexBase * (hpp::fcl::ConvexBase::*) () const>(&hpp::fcl::ConvexBase::clone)) |
548 |
5 |
return "Clone (deep copy). "; |
|
549 |
return ""; |
||
550 |
} |
||
551 |
|||
552 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::ConvexBase * (hpp::fcl::ConvexBase::*function_ptr) () const) |
||
553 |
{ |
||
554 |
if (function_ptr == static_cast< hpp::fcl::ConvexBase * (hpp::fcl::ConvexBase::*) () const>(&hpp::fcl::ConvexBase::clone)) |
||
555 |
return (boost::python::arg("self")); |
||
556 |
return (boost::python::arg("self")); |
||
557 |
} |
||
558 |
|||
559 |
inline const char* member_func_doc (void (hpp::fcl::ConvexBase::*function_ptr) ()) |
||
560 |
{ |
||
561 |
if (function_ptr == static_cast<void (hpp::fcl::ConvexBase::*) ()>(&hpp::fcl::ConvexBase::computeLocalAABB)) |
||
562 |
return "Compute hpp::fcl::AABB. "; |
||
563 |
return ""; |
||
564 |
} |
||
565 |
|||
566 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::ConvexBase::*function_ptr) ()) |
||
567 |
{ |
||
568 |
if (function_ptr == static_cast<void (hpp::fcl::ConvexBase::*) ()>(&hpp::fcl::ConvexBase::computeLocalAABB)) |
||
569 |
return (boost::python::arg("self")); |
||
570 |
return (boost::python::arg("self")); |
||
571 |
} |
||
572 |
|||
573 |
inline const char* member_func_doc ( hpp::fcl::NODE_TYPE (hpp::fcl::ConvexBase::*function_ptr) () const) |
||
574 |
{ |
||
575 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::ConvexBase::*) () const>(&hpp::fcl::ConvexBase::getNodeType)) |
||
576 |
return "Get node type: a conex polytope. "; |
||
577 |
return ""; |
||
578 |
} |
||
579 |
|||
580 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::NODE_TYPE (hpp::fcl::ConvexBase::*function_ptr) () const) |
||
581 |
{ |
||
582 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::ConvexBase::*) () const>(&hpp::fcl::ConvexBase::getNodeType)) |
||
583 |
return (boost::python::arg("self")); |
||
584 |
return (boost::python::arg("self")); |
||
585 |
} |
||
586 |
} // namespace doxygen |
||
587 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
588 |
|||
589 |
namespace doxygen { |
||
590 |
|||
591 |
template <> |
||
592 |
struct class_doc_impl< hpp::fcl::Cylinder > |
||
593 |
{ |
||
594 |
5 |
static inline const char* run () |
|
595 |
{ |
||
596 |
5 |
return "hpp::fcl::Cylinder along Z axis. The cylinder is defined at its centroid. "; |
|
597 |
} |
||
598 |
10 |
static inline const char* attribute (const char* attrib) |
|
599 |
{ |
||
600 |
✓✓ | 10 |
if (strcmp(attrib, "radius") == 0) |
601 |
5 |
return "Radius of the cylinder. "; |
|
602 |
✓✗ | 5 |
if (strcmp(attrib, "halfLength") == 0) |
603 |
5 |
return "Half Length along z axis. "; |
|
604 |
(void)attrib; // turn off unused parameter warning. |
||
605 |
return ""; |
||
606 |
} |
||
607 |
}; |
||
608 |
|||
609 |
template <> |
||
610 |
struct constructor_0_impl< hpp::fcl::Cylinder > |
||
611 |
{ |
||
612 |
5 |
static inline const char* doc () |
|
613 |
{ |
||
614 |
5 |
return "Default constructor. "; |
|
615 |
} |
||
616 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
617 |
{ |
||
618 |
5 |
return (boost::python::arg("self")); |
|
619 |
} |
||
620 |
}; |
||
621 |
|||
622 |
template <> |
||
623 |
struct constructor_2_impl< hpp::fcl::Cylinder, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL > |
||
624 |
{ |
||
625 |
5 |
static inline const char* doc () |
|
626 |
{ |
||
627 |
5 |
return ""; |
|
628 |
} |
||
629 |
5 |
static inline boost::python::detail::keywords<2+1> args () |
|
630 |
{ |
||
631 |
✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("radius_"), boost::python::arg("lz_")); |
632 |
} |
||
633 |
}; |
||
634 |
|||
635 |
template <> |
||
636 |
struct constructor_1_impl< hpp::fcl::Cylinder, const hpp::fcl::Cylinder & > |
||
637 |
{ |
||
638 |
5 |
static inline const char* doc () |
|
639 |
{ |
||
640 |
5 |
return ""; |
|
641 |
} |
||
642 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
643 |
{ |
||
644 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("other")); |
645 |
} |
||
646 |
}; |
||
647 |
|||
648 |
inline const char* member_func_doc ( hpp::fcl::Cylinder & (hpp::fcl::Cylinder::*function_ptr) (const hpp::fcl::Cylinder &)) |
||
649 |
{ |
||
650 |
if (function_ptr == static_cast< hpp::fcl::Cylinder & (hpp::fcl::Cylinder::*) (const hpp::fcl::Cylinder &)>(&hpp::fcl::Cylinder::operator=)) |
||
651 |
return ""; |
||
652 |
return ""; |
||
653 |
} |
||
654 |
|||
655 |
inline boost::python::detail::keywords<2> member_func_args ( hpp::fcl::Cylinder & (hpp::fcl::Cylinder::*function_ptr) (const hpp::fcl::Cylinder &)) |
||
656 |
{ |
||
657 |
if (function_ptr == static_cast< hpp::fcl::Cylinder & (hpp::fcl::Cylinder::*) (const hpp::fcl::Cylinder &)>(&hpp::fcl::Cylinder::operator=)) |
||
658 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
659 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
660 |
} |
||
661 |
|||
662 |
5 |
inline const char* member_func_doc ( hpp::fcl::Cylinder * (hpp::fcl::Cylinder::*function_ptr) () const) |
|
663 |
{ |
||
664 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast< hpp::fcl::Cylinder * (hpp::fcl::Cylinder::*) () const>(&hpp::fcl::Cylinder::clone)) |
665 |
5 |
return "Clone *this into a new hpp::fcl::Cylinder. "; |
|
666 |
return ""; |
||
667 |
} |
||
668 |
|||
669 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Cylinder * (hpp::fcl::Cylinder::*function_ptr) () const) |
||
670 |
{ |
||
671 |
if (function_ptr == static_cast< hpp::fcl::Cylinder * (hpp::fcl::Cylinder::*) () const>(&hpp::fcl::Cylinder::clone)) |
||
672 |
return (boost::python::arg("self")); |
||
673 |
return (boost::python::arg("self")); |
||
674 |
} |
||
675 |
|||
676 |
inline const char* member_func_doc (void (hpp::fcl::Cylinder::*function_ptr) ()) |
||
677 |
{ |
||
678 |
if (function_ptr == static_cast<void (hpp::fcl::Cylinder::*) ()>(&hpp::fcl::Cylinder::computeLocalAABB)) |
||
679 |
return "Compute hpp::fcl::AABB. "; |
||
680 |
return ""; |
||
681 |
} |
||
682 |
|||
683 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::Cylinder::*function_ptr) ()) |
||
684 |
{ |
||
685 |
if (function_ptr == static_cast<void (hpp::fcl::Cylinder::*) ()>(&hpp::fcl::Cylinder::computeLocalAABB)) |
||
686 |
return (boost::python::arg("self")); |
||
687 |
return (boost::python::arg("self")); |
||
688 |
} |
||
689 |
|||
690 |
inline const char* member_func_doc ( hpp::fcl::NODE_TYPE (hpp::fcl::Cylinder::*function_ptr) () const) |
||
691 |
{ |
||
692 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Cylinder::*) () const>(&hpp::fcl::Cylinder::getNodeType)) |
||
693 |
return "Get node type: a cylinder. "; |
||
694 |
return ""; |
||
695 |
} |
||
696 |
|||
697 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::NODE_TYPE (hpp::fcl::Cylinder::*function_ptr) () const) |
||
698 |
{ |
||
699 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Cylinder::*) () const>(&hpp::fcl::Cylinder::getNodeType)) |
||
700 |
return (boost::python::arg("self")); |
||
701 |
return (boost::python::arg("self")); |
||
702 |
} |
||
703 |
|||
704 |
inline const char* member_func_doc ( hpp::fcl::FCL_REAL (hpp::fcl::Cylinder::*function_ptr) () const) |
||
705 |
{ |
||
706 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Cylinder::*) () const>(&hpp::fcl::Cylinder::computeVolume)) |
||
707 |
return "compute the volume "; |
||
708 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Cylinder::*) () const>(&hpp::fcl::Cylinder::minInflationValue)) |
||
709 |
return ""; |
||
710 |
return ""; |
||
711 |
} |
||
712 |
|||
713 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::FCL_REAL (hpp::fcl::Cylinder::*function_ptr) () const) |
||
714 |
{ |
||
715 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Cylinder::*) () const>(&hpp::fcl::Cylinder::computeVolume)) |
||
716 |
return (boost::python::arg("self")); |
||
717 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Cylinder::*) () const>(&hpp::fcl::Cylinder::minInflationValue)) |
||
718 |
return (boost::python::arg("self")); |
||
719 |
return (boost::python::arg("self")); |
||
720 |
} |
||
721 |
|||
722 |
inline const char* member_func_doc ( hpp::fcl::Matrix3f (hpp::fcl::Cylinder::*function_ptr) () const) |
||
723 |
{ |
||
724 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Cylinder::*) () const>(&hpp::fcl::Cylinder::computeMomentofInertia)) |
||
725 |
return "compute the inertia matrix, related to the origin "; |
||
726 |
return ""; |
||
727 |
} |
||
728 |
|||
729 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Matrix3f (hpp::fcl::Cylinder::*function_ptr) () const) |
||
730 |
{ |
||
731 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Cylinder::*) () const>(&hpp::fcl::Cylinder::computeMomentofInertia)) |
||
732 |
return (boost::python::arg("self")); |
||
733 |
return (boost::python::arg("self")); |
||
734 |
} |
||
735 |
|||
736 |
inline const char* member_func_doc (std::pair< hpp::fcl::Cylinder , hpp::fcl::Transform3f > (hpp::fcl::Cylinder::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
737 |
{ |
||
738 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Cylinder , hpp::fcl::Transform3f > (hpp::fcl::Cylinder::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Cylinder::inflated)) |
||
739 |
return "Inflate the cylinder by an amount given by value. \n" |
||
740 |
"\n" |
||
741 |
"\n" |
||
742 |
"Param\n" |
||
743 |
" - value of the shape inflation.\n" |
||
744 |
"\n" |
||
745 |
"Return: a new inflated cylinder and the related transform to account for the change of shape frame "; |
||
746 |
return ""; |
||
747 |
} |
||
748 |
|||
749 |
inline boost::python::detail::keywords<2> member_func_args (std::pair< hpp::fcl::Cylinder , hpp::fcl::Transform3f > (hpp::fcl::Cylinder::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
750 |
{ |
||
751 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Cylinder , hpp::fcl::Transform3f > (hpp::fcl::Cylinder::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Cylinder::inflated)) |
||
752 |
return (boost::python::arg("self"), boost::python::arg("value")); |
||
753 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
754 |
} |
||
755 |
} // namespace doxygen |
||
756 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
757 |
|||
758 |
namespace doxygen { |
||
759 |
|||
760 |
template <> |
||
761 |
struct class_doc_impl< hpp::fcl::Ellipsoid > |
||
762 |
{ |
||
763 |
5 |
static inline const char* run () |
|
764 |
{ |
||
765 |
5 |
return "hpp::fcl::Ellipsoid centered at point zero. "; |
|
766 |
} |
||
767 |
5 |
static inline const char* attribute (const char* attrib) |
|
768 |
{ |
||
769 |
✓✗ | 5 |
if (strcmp(attrib, "radii") == 0) |
770 |
return "Radii of the hpp::fcl::Ellipsoid (such that on boundary: x^2/rx^2 + y^2/ry^2. \n" |
||
771 |
"\n" |
||
772 |
"\n" |
||
773 |
5 |
"- z^2/rz^2 = 1) "; |
|
774 |
(void)attrib; // turn off unused parameter warning. |
||
775 |
return ""; |
||
776 |
} |
||
777 |
}; |
||
778 |
|||
779 |
template <> |
||
780 |
struct constructor_0_impl< hpp::fcl::Ellipsoid > |
||
781 |
{ |
||
782 |
5 |
static inline const char* doc () |
|
783 |
{ |
||
784 |
5 |
return "Default constructor. "; |
|
785 |
} |
||
786 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
787 |
{ |
||
788 |
5 |
return (boost::python::arg("self")); |
|
789 |
} |
||
790 |
}; |
||
791 |
|||
792 |
template <> |
||
793 |
struct constructor_3_impl< hpp::fcl::Ellipsoid, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL > |
||
794 |
{ |
||
795 |
5 |
static inline const char* doc () |
|
796 |
{ |
||
797 |
5 |
return ""; |
|
798 |
} |
||
799 |
5 |
static inline boost::python::detail::keywords<3+1> args () |
|
800 |
{ |
||
801 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("rx"), boost::python::arg("ry"), boost::python::arg("rz")); |
802 |
} |
||
803 |
}; |
||
804 |
|||
805 |
template <> |
||
806 |
struct constructor_1_impl< hpp::fcl::Ellipsoid, const hpp::fcl::Vec3f & > |
||
807 |
{ |
||
808 |
static inline const char* doc () |
||
809 |
{ |
||
810 |
return ""; |
||
811 |
} |
||
812 |
static inline boost::python::detail::keywords<1+1> args () |
||
813 |
{ |
||
814 |
return (boost::python::arg("self"), boost::python::arg("radii")); |
||
815 |
} |
||
816 |
}; |
||
817 |
|||
818 |
template <> |
||
819 |
struct constructor_1_impl< hpp::fcl::Ellipsoid, const hpp::fcl::Ellipsoid & > |
||
820 |
{ |
||
821 |
5 |
static inline const char* doc () |
|
822 |
{ |
||
823 |
5 |
return ""; |
|
824 |
} |
||
825 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
826 |
{ |
||
827 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("other")); |
828 |
} |
||
829 |
}; |
||
830 |
|||
831 |
5 |
inline const char* member_func_doc ( hpp::fcl::Ellipsoid * (hpp::fcl::Ellipsoid::*function_ptr) () const) |
|
832 |
{ |
||
833 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast< hpp::fcl::Ellipsoid * (hpp::fcl::Ellipsoid::*) () const>(&hpp::fcl::Ellipsoid::clone)) |
834 |
5 |
return "Clone *this into a new hpp::fcl::Ellipsoid. "; |
|
835 |
return ""; |
||
836 |
} |
||
837 |
|||
838 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Ellipsoid * (hpp::fcl::Ellipsoid::*function_ptr) () const) |
||
839 |
{ |
||
840 |
if (function_ptr == static_cast< hpp::fcl::Ellipsoid * (hpp::fcl::Ellipsoid::*) () const>(&hpp::fcl::Ellipsoid::clone)) |
||
841 |
return (boost::python::arg("self")); |
||
842 |
return (boost::python::arg("self")); |
||
843 |
} |
||
844 |
|||
845 |
inline const char* member_func_doc (void (hpp::fcl::Ellipsoid::*function_ptr) ()) |
||
846 |
{ |
||
847 |
if (function_ptr == static_cast<void (hpp::fcl::Ellipsoid::*) ()>(&hpp::fcl::Ellipsoid::computeLocalAABB)) |
||
848 |
return "Compute hpp::fcl::AABB. "; |
||
849 |
return ""; |
||
850 |
} |
||
851 |
|||
852 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::Ellipsoid::*function_ptr) ()) |
||
853 |
{ |
||
854 |
if (function_ptr == static_cast<void (hpp::fcl::Ellipsoid::*) ()>(&hpp::fcl::Ellipsoid::computeLocalAABB)) |
||
855 |
return (boost::python::arg("self")); |
||
856 |
return (boost::python::arg("self")); |
||
857 |
} |
||
858 |
|||
859 |
inline const char* member_func_doc ( hpp::fcl::NODE_TYPE (hpp::fcl::Ellipsoid::*function_ptr) () const) |
||
860 |
{ |
||
861 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Ellipsoid::*) () const>(&hpp::fcl::Ellipsoid::getNodeType)) |
||
862 |
return "Get node type: an ellipsoid. "; |
||
863 |
return ""; |
||
864 |
} |
||
865 |
|||
866 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::NODE_TYPE (hpp::fcl::Ellipsoid::*function_ptr) () const) |
||
867 |
{ |
||
868 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Ellipsoid::*) () const>(&hpp::fcl::Ellipsoid::getNodeType)) |
||
869 |
return (boost::python::arg("self")); |
||
870 |
return (boost::python::arg("self")); |
||
871 |
} |
||
872 |
|||
873 |
inline const char* member_func_doc ( hpp::fcl::Matrix3f (hpp::fcl::Ellipsoid::*function_ptr) () const) |
||
874 |
{ |
||
875 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Ellipsoid::*) () const>(&hpp::fcl::Ellipsoid::computeMomentofInertia)) |
||
876 |
return "compute the inertia matrix, related to the origin "; |
||
877 |
return ""; |
||
878 |
} |
||
879 |
|||
880 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Matrix3f (hpp::fcl::Ellipsoid::*function_ptr) () const) |
||
881 |
{ |
||
882 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Ellipsoid::*) () const>(&hpp::fcl::Ellipsoid::computeMomentofInertia)) |
||
883 |
return (boost::python::arg("self")); |
||
884 |
return (boost::python::arg("self")); |
||
885 |
} |
||
886 |
|||
887 |
inline const char* member_func_doc ( hpp::fcl::FCL_REAL (hpp::fcl::Ellipsoid::*function_ptr) () const) |
||
888 |
{ |
||
889 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Ellipsoid::*) () const>(&hpp::fcl::Ellipsoid::computeVolume)) |
||
890 |
return "compute the volume "; |
||
891 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Ellipsoid::*) () const>(&hpp::fcl::Ellipsoid::minInflationValue)) |
||
892 |
return ""; |
||
893 |
return ""; |
||
894 |
} |
||
895 |
|||
896 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::FCL_REAL (hpp::fcl::Ellipsoid::*function_ptr) () const) |
||
897 |
{ |
||
898 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Ellipsoid::*) () const>(&hpp::fcl::Ellipsoid::computeVolume)) |
||
899 |
return (boost::python::arg("self")); |
||
900 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Ellipsoid::*) () const>(&hpp::fcl::Ellipsoid::minInflationValue)) |
||
901 |
return (boost::python::arg("self")); |
||
902 |
return (boost::python::arg("self")); |
||
903 |
} |
||
904 |
|||
905 |
inline const char* member_func_doc (std::pair< hpp::fcl::Ellipsoid , hpp::fcl::Transform3f > (hpp::fcl::Ellipsoid::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
906 |
{ |
||
907 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Ellipsoid , hpp::fcl::Transform3f > (hpp::fcl::Ellipsoid::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Ellipsoid::inflated)) |
||
908 |
return "Inflate the ellipsoid by an amount given by value. \n" |
||
909 |
"\n" |
||
910 |
"\n" |
||
911 |
"Param\n" |
||
912 |
" - value of the shape inflation.\n" |
||
913 |
"\n" |
||
914 |
"Return: a new inflated ellipsoid and the related transform to account for the change of shape frame "; |
||
915 |
return ""; |
||
916 |
} |
||
917 |
|||
918 |
inline boost::python::detail::keywords<2> member_func_args (std::pair< hpp::fcl::Ellipsoid , hpp::fcl::Transform3f > (hpp::fcl::Ellipsoid::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
919 |
{ |
||
920 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Ellipsoid , hpp::fcl::Transform3f > (hpp::fcl::Ellipsoid::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Ellipsoid::inflated)) |
||
921 |
return (boost::python::arg("self"), boost::python::arg("value")); |
||
922 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
923 |
} |
||
924 |
} // namespace doxygen |
||
925 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
926 |
|||
927 |
namespace doxygen { |
||
928 |
|||
929 |
template <> |
||
930 |
struct class_doc_impl< hpp::fcl::Halfspace > |
||
931 |
{ |
||
932 |
5 |
static inline const char* run () |
|
933 |
{ |
||
934 |
5 |
return "Half Space: this is equivalent to the hpp::fcl::Plane in ODE. The separation plane is defined as n * x = d; Points in the negative side of the separation plane (i.e. {x | n * x < d}) are inside the half space and points in the positive side of the separation plane (i.e. {x | n * x > d}) are outside the half space. "; |
|
935 |
} |
||
936 |
10 |
static inline const char* attribute (const char* attrib) |
|
937 |
{ |
||
938 |
✓✓ | 10 |
if (strcmp(attrib, "n") == 0) |
939 |
5 |
return "hpp::fcl::Plane normal. "; |
|
940 |
✓✗ | 5 |
if (strcmp(attrib, "d") == 0) |
941 |
5 |
return "hpp::fcl::Plane offset. "; |
|
942 |
(void)attrib; // turn off unused parameter warning. |
||
943 |
return ""; |
||
944 |
} |
||
945 |
}; |
||
946 |
|||
947 |
template <> |
||
948 |
struct constructor_2_impl< hpp::fcl::Halfspace, const hpp::fcl::Vec3f &, hpp::fcl::FCL_REAL > |
||
949 |
{ |
||
950 |
5 |
static inline const char* doc () |
|
951 |
{ |
||
952 |
5 |
return "Construct a half space with normal direction and offset. "; |
|
953 |
} |
||
954 |
5 |
static inline boost::python::detail::keywords<2+1> args () |
|
955 |
{ |
||
956 |
✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("n_"), boost::python::arg("d_")); |
957 |
} |
||
958 |
}; |
||
959 |
|||
960 |
template <> |
||
961 |
struct constructor_4_impl< hpp::fcl::Halfspace, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL > |
||
962 |
{ |
||
963 |
5 |
static inline const char* doc () |
|
964 |
{ |
||
965 |
5 |
return "Construct a plane with normal direction and offset. "; |
|
966 |
} |
||
967 |
5 |
static inline boost::python::detail::keywords<4+1> args () |
|
968 |
{ |
||
969 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("a"), boost::python::arg("b"), boost::python::arg("c"), boost::python::arg("d_")); |
970 |
} |
||
971 |
}; |
||
972 |
|||
973 |
template <> |
||
974 |
struct constructor_0_impl< hpp::fcl::Halfspace > |
||
975 |
{ |
||
976 |
5 |
static inline const char* doc () |
|
977 |
{ |
||
978 |
5 |
return ""; |
|
979 |
} |
||
980 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
981 |
{ |
||
982 |
5 |
return (boost::python::arg("self")); |
|
983 |
} |
||
984 |
}; |
||
985 |
|||
986 |
template <> |
||
987 |
struct constructor_1_impl< hpp::fcl::Halfspace, const hpp::fcl::Halfspace & > |
||
988 |
{ |
||
989 |
5 |
static inline const char* doc () |
|
990 |
{ |
||
991 |
5 |
return ""; |
|
992 |
} |
||
993 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
994 |
{ |
||
995 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("other")); |
996 |
} |
||
997 |
}; |
||
998 |
|||
999 |
inline const char* member_func_doc ( hpp::fcl::Halfspace & (hpp::fcl::Halfspace::*function_ptr) (const hpp::fcl::Halfspace &)) |
||
1000 |
{ |
||
1001 |
if (function_ptr == static_cast< hpp::fcl::Halfspace & (hpp::fcl::Halfspace::*) (const hpp::fcl::Halfspace &)>(&hpp::fcl::Halfspace::operator=)) |
||
1002 |
return "operator = "; |
||
1003 |
return ""; |
||
1004 |
} |
||
1005 |
|||
1006 |
inline boost::python::detail::keywords<2> member_func_args ( hpp::fcl::Halfspace & (hpp::fcl::Halfspace::*function_ptr) (const hpp::fcl::Halfspace &)) |
||
1007 |
{ |
||
1008 |
if (function_ptr == static_cast< hpp::fcl::Halfspace & (hpp::fcl::Halfspace::*) (const hpp::fcl::Halfspace &)>(&hpp::fcl::Halfspace::operator=)) |
||
1009 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
1010 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
1011 |
} |
||
1012 |
|||
1013 |
5 |
inline const char* member_func_doc ( hpp::fcl::Halfspace * (hpp::fcl::Halfspace::*function_ptr) () const) |
|
1014 |
{ |
||
1015 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast< hpp::fcl::Halfspace * (hpp::fcl::Halfspace::*) () const>(&hpp::fcl::Halfspace::clone)) |
1016 |
5 |
return "Clone *this into a new hpp::fcl::Halfspace. "; |
|
1017 |
return ""; |
||
1018 |
} |
||
1019 |
|||
1020 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Halfspace * (hpp::fcl::Halfspace::*function_ptr) () const) |
||
1021 |
{ |
||
1022 |
if (function_ptr == static_cast< hpp::fcl::Halfspace * (hpp::fcl::Halfspace::*) () const>(&hpp::fcl::Halfspace::clone)) |
||
1023 |
return (boost::python::arg("self")); |
||
1024 |
return (boost::python::arg("self")); |
||
1025 |
} |
||
1026 |
|||
1027 |
inline const char* member_func_doc ( hpp::fcl::FCL_REAL (hpp::fcl::Halfspace::*function_ptr) (const hpp::fcl::Vec3f &) const) |
||
1028 |
{ |
||
1029 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Halfspace::*) (const hpp::fcl::Vec3f &) const>(&hpp::fcl::Halfspace::signedDistance)) |
||
1030 |
return ""; |
||
1031 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Halfspace::*) (const hpp::fcl::Vec3f &) const>(&hpp::fcl::Halfspace::distance)) |
||
1032 |
return ""; |
||
1033 |
return ""; |
||
1034 |
} |
||
1035 |
|||
1036 |
inline boost::python::detail::keywords<2> member_func_args ( hpp::fcl::FCL_REAL (hpp::fcl::Halfspace::*function_ptr) (const hpp::fcl::Vec3f &) const) |
||
1037 |
{ |
||
1038 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Halfspace::*) (const hpp::fcl::Vec3f &) const>(&hpp::fcl::Halfspace::signedDistance)) |
||
1039 |
return (boost::python::arg("self"), boost::python::arg("p")); |
||
1040 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Halfspace::*) (const hpp::fcl::Vec3f &) const>(&hpp::fcl::Halfspace::distance)) |
||
1041 |
return (boost::python::arg("self"), boost::python::arg("p")); |
||
1042 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
1043 |
} |
||
1044 |
|||
1045 |
inline const char* member_func_doc (void (hpp::fcl::Halfspace::*function_ptr) ()) |
||
1046 |
{ |
||
1047 |
if (function_ptr == static_cast<void (hpp::fcl::Halfspace::*) ()>(&hpp::fcl::Halfspace::computeLocalAABB)) |
||
1048 |
return "Compute hpp::fcl::AABB. "; |
||
1049 |
return ""; |
||
1050 |
} |
||
1051 |
|||
1052 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::Halfspace::*function_ptr) ()) |
||
1053 |
{ |
||
1054 |
if (function_ptr == static_cast<void (hpp::fcl::Halfspace::*) ()>(&hpp::fcl::Halfspace::computeLocalAABB)) |
||
1055 |
return (boost::python::arg("self")); |
||
1056 |
return (boost::python::arg("self")); |
||
1057 |
} |
||
1058 |
|||
1059 |
inline const char* member_func_doc ( hpp::fcl::NODE_TYPE (hpp::fcl::Halfspace::*function_ptr) () const) |
||
1060 |
{ |
||
1061 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Halfspace::*) () const>(&hpp::fcl::Halfspace::getNodeType)) |
||
1062 |
return "Get node type: a half space. "; |
||
1063 |
return ""; |
||
1064 |
} |
||
1065 |
|||
1066 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::NODE_TYPE (hpp::fcl::Halfspace::*function_ptr) () const) |
||
1067 |
{ |
||
1068 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Halfspace::*) () const>(&hpp::fcl::Halfspace::getNodeType)) |
||
1069 |
return (boost::python::arg("self")); |
||
1070 |
return (boost::python::arg("self")); |
||
1071 |
} |
||
1072 |
|||
1073 |
inline const char* member_func_doc ( hpp::fcl::FCL_REAL (hpp::fcl::Halfspace::*function_ptr) () const) |
||
1074 |
{ |
||
1075 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Halfspace::*) () const>(&hpp::fcl::Halfspace::minInflationValue)) |
||
1076 |
return ""; |
||
1077 |
return ""; |
||
1078 |
} |
||
1079 |
|||
1080 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::FCL_REAL (hpp::fcl::Halfspace::*function_ptr) () const) |
||
1081 |
{ |
||
1082 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Halfspace::*) () const>(&hpp::fcl::Halfspace::minInflationValue)) |
||
1083 |
return (boost::python::arg("self")); |
||
1084 |
return (boost::python::arg("self")); |
||
1085 |
} |
||
1086 |
|||
1087 |
inline const char* member_func_doc (std::pair< hpp::fcl::Halfspace , hpp::fcl::Transform3f > (hpp::fcl::Halfspace::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
1088 |
{ |
||
1089 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Halfspace , hpp::fcl::Transform3f > (hpp::fcl::Halfspace::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Halfspace::inflated)) |
||
1090 |
return "Inflate the cylinder by an amount given by value. \n" |
||
1091 |
"\n" |
||
1092 |
"\n" |
||
1093 |
"Param\n" |
||
1094 |
" - value of the shape inflation.\n" |
||
1095 |
"\n" |
||
1096 |
"Return: a new inflated cylinder and the related transform to account for the change of shape frame "; |
||
1097 |
return ""; |
||
1098 |
} |
||
1099 |
|||
1100 |
inline boost::python::detail::keywords<2> member_func_args (std::pair< hpp::fcl::Halfspace , hpp::fcl::Transform3f > (hpp::fcl::Halfspace::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
1101 |
{ |
||
1102 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Halfspace , hpp::fcl::Transform3f > (hpp::fcl::Halfspace::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Halfspace::inflated)) |
||
1103 |
return (boost::python::arg("self"), boost::python::arg("value")); |
||
1104 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
1105 |
} |
||
1106 |
} // namespace doxygen |
||
1107 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
1108 |
|||
1109 |
namespace doxygen { |
||
1110 |
|||
1111 |
inline const char* member_func_doc (unsigned char const & (hpp::fcl::ConvexBase::Neighbors::*function_ptr) () const) |
||
1112 |
{ |
||
1113 |
if (function_ptr == static_cast<unsigned char const & (hpp::fcl::ConvexBase::Neighbors::*) () const>(&hpp::fcl::ConvexBase::Neighbors::count)) |
||
1114 |
return ""; |
||
1115 |
return ""; |
||
1116 |
} |
||
1117 |
|||
1118 |
inline boost::python::detail::keywords<1> member_func_args (unsigned char const & (hpp::fcl::ConvexBase::Neighbors::*function_ptr) () const) |
||
1119 |
{ |
||
1120 |
if (function_ptr == static_cast<unsigned char const & (hpp::fcl::ConvexBase::Neighbors::*) () const>(&hpp::fcl::ConvexBase::Neighbors::count)) |
||
1121 |
return (boost::python::arg("self")); |
||
1122 |
return (boost::python::arg("self")); |
||
1123 |
} |
||
1124 |
|||
1125 |
inline const char* member_func_doc (unsigned int & (hpp::fcl::ConvexBase::Neighbors::*function_ptr) (int)) |
||
1126 |
{ |
||
1127 |
if (function_ptr == static_cast<unsigned int & (hpp::fcl::ConvexBase::Neighbors::*) (int)>(&hpp::fcl::ConvexBase::Neighbors::operator[])) |
||
1128 |
return ""; |
||
1129 |
return ""; |
||
1130 |
} |
||
1131 |
|||
1132 |
inline boost::python::detail::keywords<2> member_func_args (unsigned int & (hpp::fcl::ConvexBase::Neighbors::*function_ptr) (int)) |
||
1133 |
{ |
||
1134 |
if (function_ptr == static_cast<unsigned int & (hpp::fcl::ConvexBase::Neighbors::*) (int)>(&hpp::fcl::ConvexBase::Neighbors::operator[])) |
||
1135 |
return (boost::python::arg("self"), boost::python::arg("i")); |
||
1136 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
1137 |
} |
||
1138 |
|||
1139 |
inline const char* member_func_doc (unsigned int const & (hpp::fcl::ConvexBase::Neighbors::*function_ptr) (int) const) |
||
1140 |
{ |
||
1141 |
if (function_ptr == static_cast<unsigned int const & (hpp::fcl::ConvexBase::Neighbors::*) (int) const>(&hpp::fcl::ConvexBase::Neighbors::operator[])) |
||
1142 |
return ""; |
||
1143 |
return ""; |
||
1144 |
} |
||
1145 |
|||
1146 |
inline boost::python::detail::keywords<2> member_func_args (unsigned int const & (hpp::fcl::ConvexBase::Neighbors::*function_ptr) (int) const) |
||
1147 |
{ |
||
1148 |
if (function_ptr == static_cast<unsigned int const & (hpp::fcl::ConvexBase::Neighbors::*) (int) const>(&hpp::fcl::ConvexBase::Neighbors::operator[])) |
||
1149 |
return (boost::python::arg("self"), boost::python::arg("i")); |
||
1150 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
1151 |
} |
||
1152 |
|||
1153 |
inline const char* member_func_doc (bool (hpp::fcl::ConvexBase::Neighbors::*function_ptr) (const hpp::fcl::ConvexBase::Neighbors &) const) |
||
1154 |
{ |
||
1155 |
if (function_ptr == static_cast<bool (hpp::fcl::ConvexBase::Neighbors::*) (const hpp::fcl::ConvexBase::Neighbors &) const>(&hpp::fcl::ConvexBase::Neighbors::operator==)) |
||
1156 |
return ""; |
||
1157 |
if (function_ptr == static_cast<bool (hpp::fcl::ConvexBase::Neighbors::*) (const hpp::fcl::ConvexBase::Neighbors &) const>(&hpp::fcl::ConvexBase::Neighbors::operator!=)) |
||
1158 |
return ""; |
||
1159 |
return ""; |
||
1160 |
} |
||
1161 |
|||
1162 |
inline boost::python::detail::keywords<2> member_func_args (bool (hpp::fcl::ConvexBase::Neighbors::*function_ptr) (const hpp::fcl::ConvexBase::Neighbors &) const) |
||
1163 |
{ |
||
1164 |
if (function_ptr == static_cast<bool (hpp::fcl::ConvexBase::Neighbors::*) (const hpp::fcl::ConvexBase::Neighbors &) const>(&hpp::fcl::ConvexBase::Neighbors::operator==)) |
||
1165 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
1166 |
if (function_ptr == static_cast<bool (hpp::fcl::ConvexBase::Neighbors::*) (const hpp::fcl::ConvexBase::Neighbors &) const>(&hpp::fcl::ConvexBase::Neighbors::operator!=)) |
||
1167 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
1168 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
1169 |
} |
||
1170 |
} // namespace doxygen |
||
1171 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
1172 |
|||
1173 |
namespace doxygen { |
||
1174 |
|||
1175 |
template <> |
||
1176 |
struct class_doc_impl< hpp::fcl::Plane > |
||
1177 |
{ |
||
1178 |
5 |
static inline const char* run () |
|
1179 |
{ |
||
1180 |
5 |
return "Infinite plane. "; |
|
1181 |
} |
||
1182 |
10 |
static inline const char* attribute (const char* attrib) |
|
1183 |
{ |
||
1184 |
✓✓ | 10 |
if (strcmp(attrib, "n") == 0) |
1185 |
5 |
return "hpp::fcl::Plane normal. "; |
|
1186 |
✓✗ | 5 |
if (strcmp(attrib, "d") == 0) |
1187 |
5 |
return "hpp::fcl::Plane offset. "; |
|
1188 |
(void)attrib; // turn off unused parameter warning. |
||
1189 |
return ""; |
||
1190 |
} |
||
1191 |
}; |
||
1192 |
|||
1193 |
template <> |
||
1194 |
struct constructor_2_impl< hpp::fcl::Plane, const hpp::fcl::Vec3f &, hpp::fcl::FCL_REAL > |
||
1195 |
{ |
||
1196 |
5 |
static inline const char* doc () |
|
1197 |
{ |
||
1198 |
5 |
return "Construct a plane with normal direction and offset. "; |
|
1199 |
} |
||
1200 |
5 |
static inline boost::python::detail::keywords<2+1> args () |
|
1201 |
{ |
||
1202 |
✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("n_"), boost::python::arg("d_")); |
1203 |
} |
||
1204 |
}; |
||
1205 |
|||
1206 |
template <> |
||
1207 |
struct constructor_4_impl< hpp::fcl::Plane, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL > |
||
1208 |
{ |
||
1209 |
5 |
static inline const char* doc () |
|
1210 |
{ |
||
1211 |
5 |
return "Construct a plane with normal direction and offset. "; |
|
1212 |
} |
||
1213 |
5 |
static inline boost::python::detail::keywords<4+1> args () |
|
1214 |
{ |
||
1215 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("a"), boost::python::arg("b"), boost::python::arg("c"), boost::python::arg("d_")); |
1216 |
} |
||
1217 |
}; |
||
1218 |
|||
1219 |
template <> |
||
1220 |
struct constructor_0_impl< hpp::fcl::Plane > |
||
1221 |
{ |
||
1222 |
5 |
static inline const char* doc () |
|
1223 |
{ |
||
1224 |
5 |
return ""; |
|
1225 |
} |
||
1226 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
1227 |
{ |
||
1228 |
5 |
return (boost::python::arg("self")); |
|
1229 |
} |
||
1230 |
}; |
||
1231 |
|||
1232 |
template <> |
||
1233 |
struct constructor_1_impl< hpp::fcl::Plane, const hpp::fcl::Plane & > |
||
1234 |
{ |
||
1235 |
5 |
static inline const char* doc () |
|
1236 |
{ |
||
1237 |
5 |
return ""; |
|
1238 |
} |
||
1239 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
1240 |
{ |
||
1241 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("other")); |
1242 |
} |
||
1243 |
}; |
||
1244 |
|||
1245 |
inline const char* member_func_doc ( hpp::fcl::Plane & (hpp::fcl::Plane::*function_ptr) (const hpp::fcl::Plane &)) |
||
1246 |
{ |
||
1247 |
if (function_ptr == static_cast< hpp::fcl::Plane & (hpp::fcl::Plane::*) (const hpp::fcl::Plane &)>(&hpp::fcl::Plane::operator=)) |
||
1248 |
return "operator = "; |
||
1249 |
return ""; |
||
1250 |
} |
||
1251 |
|||
1252 |
inline boost::python::detail::keywords<2> member_func_args ( hpp::fcl::Plane & (hpp::fcl::Plane::*function_ptr) (const hpp::fcl::Plane &)) |
||
1253 |
{ |
||
1254 |
if (function_ptr == static_cast< hpp::fcl::Plane & (hpp::fcl::Plane::*) (const hpp::fcl::Plane &)>(&hpp::fcl::Plane::operator=)) |
||
1255 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
1256 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
1257 |
} |
||
1258 |
|||
1259 |
5 |
inline const char* member_func_doc ( hpp::fcl::Plane * (hpp::fcl::Plane::*function_ptr) () const) |
|
1260 |
{ |
||
1261 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast< hpp::fcl::Plane * (hpp::fcl::Plane::*) () const>(&hpp::fcl::Plane::clone)) |
1262 |
5 |
return "Clone *this into a new hpp::fcl::Plane. "; |
|
1263 |
return ""; |
||
1264 |
} |
||
1265 |
|||
1266 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Plane * (hpp::fcl::Plane::*function_ptr) () const) |
||
1267 |
{ |
||
1268 |
if (function_ptr == static_cast< hpp::fcl::Plane * (hpp::fcl::Plane::*) () const>(&hpp::fcl::Plane::clone)) |
||
1269 |
return (boost::python::arg("self")); |
||
1270 |
return (boost::python::arg("self")); |
||
1271 |
} |
||
1272 |
|||
1273 |
inline const char* member_func_doc ( hpp::fcl::FCL_REAL (hpp::fcl::Plane::*function_ptr) (const hpp::fcl::Vec3f &) const) |
||
1274 |
{ |
||
1275 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Plane::*) (const hpp::fcl::Vec3f &) const>(&hpp::fcl::Plane::signedDistance)) |
||
1276 |
return ""; |
||
1277 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Plane::*) (const hpp::fcl::Vec3f &) const>(&hpp::fcl::Plane::distance)) |
||
1278 |
return ""; |
||
1279 |
return ""; |
||
1280 |
} |
||
1281 |
|||
1282 |
inline boost::python::detail::keywords<2> member_func_args ( hpp::fcl::FCL_REAL (hpp::fcl::Plane::*function_ptr) (const hpp::fcl::Vec3f &) const) |
||
1283 |
{ |
||
1284 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Plane::*) (const hpp::fcl::Vec3f &) const>(&hpp::fcl::Plane::signedDistance)) |
||
1285 |
return (boost::python::arg("self"), boost::python::arg("p")); |
||
1286 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Plane::*) (const hpp::fcl::Vec3f &) const>(&hpp::fcl::Plane::distance)) |
||
1287 |
return (boost::python::arg("self"), boost::python::arg("p")); |
||
1288 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
1289 |
} |
||
1290 |
|||
1291 |
inline const char* member_func_doc (void (hpp::fcl::Plane::*function_ptr) ()) |
||
1292 |
{ |
||
1293 |
if (function_ptr == static_cast<void (hpp::fcl::Plane::*) ()>(&hpp::fcl::Plane::computeLocalAABB)) |
||
1294 |
return "Compute hpp::fcl::AABB. "; |
||
1295 |
return ""; |
||
1296 |
} |
||
1297 |
|||
1298 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::Plane::*function_ptr) ()) |
||
1299 |
{ |
||
1300 |
if (function_ptr == static_cast<void (hpp::fcl::Plane::*) ()>(&hpp::fcl::Plane::computeLocalAABB)) |
||
1301 |
return (boost::python::arg("self")); |
||
1302 |
return (boost::python::arg("self")); |
||
1303 |
} |
||
1304 |
|||
1305 |
inline const char* member_func_doc ( hpp::fcl::NODE_TYPE (hpp::fcl::Plane::*function_ptr) () const) |
||
1306 |
{ |
||
1307 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Plane::*) () const>(&hpp::fcl::Plane::getNodeType)) |
||
1308 |
return "Get node type: a plane. "; |
||
1309 |
return ""; |
||
1310 |
} |
||
1311 |
|||
1312 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::NODE_TYPE (hpp::fcl::Plane::*function_ptr) () const) |
||
1313 |
{ |
||
1314 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Plane::*) () const>(&hpp::fcl::Plane::getNodeType)) |
||
1315 |
return (boost::python::arg("self")); |
||
1316 |
return (boost::python::arg("self")); |
||
1317 |
} |
||
1318 |
} // namespace doxygen |
||
1319 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
1320 |
|||
1321 |
namespace doxygen { |
||
1322 |
|||
1323 |
template <> |
||
1324 |
struct class_doc_impl< hpp::fcl::ShapeBase > |
||
1325 |
{ |
||
1326 |
10 |
static inline const char* run () |
|
1327 |
{ |
||
1328 |
10 |
return "Base class for all basic geometric shapes. "; |
|
1329 |
} |
||
1330 |
static inline const char* attribute (const char* attrib) |
||
1331 |
{ |
||
1332 |
(void)attrib; // turn off unused parameter warning. |
||
1333 |
return ""; |
||
1334 |
} |
||
1335 |
}; |
||
1336 |
|||
1337 |
template <> |
||
1338 |
struct constructor_0_impl< hpp::fcl::ShapeBase > |
||
1339 |
{ |
||
1340 |
static inline const char* doc () |
||
1341 |
{ |
||
1342 |
return ""; |
||
1343 |
} |
||
1344 |
static inline boost::python::detail::keywords<0+1> args () |
||
1345 |
{ |
||
1346 |
return (boost::python::arg("self")); |
||
1347 |
} |
||
1348 |
}; |
||
1349 |
|||
1350 |
template <> |
||
1351 |
struct constructor_1_impl< hpp::fcl::ShapeBase, const hpp::fcl::ShapeBase & > |
||
1352 |
{ |
||
1353 |
static inline const char* doc () |
||
1354 |
{ |
||
1355 |
return "Copy constructor "; |
||
1356 |
} |
||
1357 |
static inline boost::python::detail::keywords<1+1> args () |
||
1358 |
{ |
||
1359 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
1360 |
} |
||
1361 |
}; |
||
1362 |
|||
1363 |
template <> |
||
1364 |
struct destructor_doc_impl < hpp::fcl::ShapeBase > |
||
1365 |
{ |
||
1366 |
static inline const char* run () |
||
1367 |
{ |
||
1368 |
return ""; |
||
1369 |
} |
||
1370 |
}; |
||
1371 |
|||
1372 |
inline const char* member_func_doc ( hpp::fcl::ShapeBase & (hpp::fcl::ShapeBase::*function_ptr) (const hpp::fcl::ShapeBase &)) |
||
1373 |
{ |
||
1374 |
if (function_ptr == static_cast< hpp::fcl::ShapeBase & (hpp::fcl::ShapeBase::*) (const hpp::fcl::ShapeBase &)>(&hpp::fcl::ShapeBase::operator=)) |
||
1375 |
return ""; |
||
1376 |
return ""; |
||
1377 |
} |
||
1378 |
|||
1379 |
inline boost::python::detail::keywords<2> member_func_args ( hpp::fcl::ShapeBase & (hpp::fcl::ShapeBase::*function_ptr) (const hpp::fcl::ShapeBase &)) |
||
1380 |
{ |
||
1381 |
if (function_ptr == static_cast< hpp::fcl::ShapeBase & (hpp::fcl::ShapeBase::*) (const hpp::fcl::ShapeBase &)>(&hpp::fcl::ShapeBase::operator=)) |
||
1382 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
1383 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
1384 |
} |
||
1385 |
|||
1386 |
inline const char* member_func_doc ( hpp::fcl::OBJECT_TYPE (hpp::fcl::ShapeBase::*function_ptr) () const) |
||
1387 |
{ |
||
1388 |
if (function_ptr == static_cast< hpp::fcl::OBJECT_TYPE (hpp::fcl::ShapeBase::*) () const>(&hpp::fcl::ShapeBase::getObjectType)) |
||
1389 |
return "Get object type: a geometric shape. "; |
||
1390 |
return ""; |
||
1391 |
} |
||
1392 |
|||
1393 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::OBJECT_TYPE (hpp::fcl::ShapeBase::*function_ptr) () const) |
||
1394 |
{ |
||
1395 |
if (function_ptr == static_cast< hpp::fcl::OBJECT_TYPE (hpp::fcl::ShapeBase::*) () const>(&hpp::fcl::ShapeBase::getObjectType)) |
||
1396 |
return (boost::python::arg("self")); |
||
1397 |
return (boost::python::arg("self")); |
||
1398 |
} |
||
1399 |
} // namespace doxygen |
||
1400 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
1401 |
|||
1402 |
namespace doxygen { |
||
1403 |
|||
1404 |
template <> |
||
1405 |
struct class_doc_impl< hpp::fcl::Sphere > |
||
1406 |
{ |
||
1407 |
5 |
static inline const char* run () |
|
1408 |
{ |
||
1409 |
5 |
return "Center at zero point sphere. "; |
|
1410 |
} |
||
1411 |
5 |
static inline const char* attribute (const char* attrib) |
|
1412 |
{ |
||
1413 |
✓✗ | 5 |
if (strcmp(attrib, "radius") == 0) |
1414 |
5 |
return "Radius of the sphere. "; |
|
1415 |
(void)attrib; // turn off unused parameter warning. |
||
1416 |
return ""; |
||
1417 |
} |
||
1418 |
}; |
||
1419 |
|||
1420 |
template <> |
||
1421 |
struct constructor_0_impl< hpp::fcl::Sphere > |
||
1422 |
{ |
||
1423 |
5 |
static inline const char* doc () |
|
1424 |
{ |
||
1425 |
5 |
return "Default constructor. "; |
|
1426 |
} |
||
1427 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
1428 |
{ |
||
1429 |
5 |
return (boost::python::arg("self")); |
|
1430 |
} |
||
1431 |
}; |
||
1432 |
|||
1433 |
template <> |
||
1434 |
struct constructor_1_impl< hpp::fcl::Sphere, hpp::fcl::FCL_REAL > |
||
1435 |
{ |
||
1436 |
5 |
static inline const char* doc () |
|
1437 |
{ |
||
1438 |
5 |
return ""; |
|
1439 |
} |
||
1440 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
1441 |
{ |
||
1442 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("radius_")); |
1443 |
} |
||
1444 |
}; |
||
1445 |
|||
1446 |
template <> |
||
1447 |
struct constructor_1_impl< hpp::fcl::Sphere, const hpp::fcl::Sphere & > |
||
1448 |
{ |
||
1449 |
5 |
static inline const char* doc () |
|
1450 |
{ |
||
1451 |
5 |
return ""; |
|
1452 |
} |
||
1453 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
1454 |
{ |
||
1455 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("other")); |
1456 |
} |
||
1457 |
}; |
||
1458 |
|||
1459 |
5 |
inline const char* member_func_doc ( hpp::fcl::Sphere * (hpp::fcl::Sphere::*function_ptr) () const) |
|
1460 |
{ |
||
1461 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast< hpp::fcl::Sphere * (hpp::fcl::Sphere::*) () const>(&hpp::fcl::Sphere::clone)) |
1462 |
5 |
return "Clone *this into a new hpp::fcl::Sphere. "; |
|
1463 |
return ""; |
||
1464 |
} |
||
1465 |
|||
1466 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Sphere * (hpp::fcl::Sphere::*function_ptr) () const) |
||
1467 |
{ |
||
1468 |
if (function_ptr == static_cast< hpp::fcl::Sphere * (hpp::fcl::Sphere::*) () const>(&hpp::fcl::Sphere::clone)) |
||
1469 |
return (boost::python::arg("self")); |
||
1470 |
return (boost::python::arg("self")); |
||
1471 |
} |
||
1472 |
|||
1473 |
inline const char* member_func_doc (void (hpp::fcl::Sphere::*function_ptr) ()) |
||
1474 |
{ |
||
1475 |
if (function_ptr == static_cast<void (hpp::fcl::Sphere::*) ()>(&hpp::fcl::Sphere::computeLocalAABB)) |
||
1476 |
return "Compute hpp::fcl::AABB. "; |
||
1477 |
return ""; |
||
1478 |
} |
||
1479 |
|||
1480 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::Sphere::*function_ptr) ()) |
||
1481 |
{ |
||
1482 |
if (function_ptr == static_cast<void (hpp::fcl::Sphere::*) ()>(&hpp::fcl::Sphere::computeLocalAABB)) |
||
1483 |
return (boost::python::arg("self")); |
||
1484 |
return (boost::python::arg("self")); |
||
1485 |
} |
||
1486 |
|||
1487 |
inline const char* member_func_doc ( hpp::fcl::NODE_TYPE (hpp::fcl::Sphere::*function_ptr) () const) |
||
1488 |
{ |
||
1489 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Sphere::*) () const>(&hpp::fcl::Sphere::getNodeType)) |
||
1490 |
return "Get node type: a sphere. "; |
||
1491 |
return ""; |
||
1492 |
} |
||
1493 |
|||
1494 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::NODE_TYPE (hpp::fcl::Sphere::*function_ptr) () const) |
||
1495 |
{ |
||
1496 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::Sphere::*) () const>(&hpp::fcl::Sphere::getNodeType)) |
||
1497 |
return (boost::python::arg("self")); |
||
1498 |
return (boost::python::arg("self")); |
||
1499 |
} |
||
1500 |
|||
1501 |
inline const char* member_func_doc ( hpp::fcl::Matrix3f (hpp::fcl::Sphere::*function_ptr) () const) |
||
1502 |
{ |
||
1503 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Sphere::*) () const>(&hpp::fcl::Sphere::computeMomentofInertia)) |
||
1504 |
return "compute the inertia matrix, related to the origin "; |
||
1505 |
return ""; |
||
1506 |
} |
||
1507 |
|||
1508 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::Matrix3f (hpp::fcl::Sphere::*function_ptr) () const) |
||
1509 |
{ |
||
1510 |
if (function_ptr == static_cast< hpp::fcl::Matrix3f (hpp::fcl::Sphere::*) () const>(&hpp::fcl::Sphere::computeMomentofInertia)) |
||
1511 |
return (boost::python::arg("self")); |
||
1512 |
return (boost::python::arg("self")); |
||
1513 |
} |
||
1514 |
|||
1515 |
inline const char* member_func_doc ( hpp::fcl::FCL_REAL (hpp::fcl::Sphere::*function_ptr) () const) |
||
1516 |
{ |
||
1517 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Sphere::*) () const>(&hpp::fcl::Sphere::computeVolume)) |
||
1518 |
return "compute the volume "; |
||
1519 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Sphere::*) () const>(&hpp::fcl::Sphere::minInflationValue)) |
||
1520 |
return ""; |
||
1521 |
return ""; |
||
1522 |
} |
||
1523 |
|||
1524 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::FCL_REAL (hpp::fcl::Sphere::*function_ptr) () const) |
||
1525 |
{ |
||
1526 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Sphere::*) () const>(&hpp::fcl::Sphere::computeVolume)) |
||
1527 |
return (boost::python::arg("self")); |
||
1528 |
if (function_ptr == static_cast< hpp::fcl::FCL_REAL (hpp::fcl::Sphere::*) () const>(&hpp::fcl::Sphere::minInflationValue)) |
||
1529 |
return (boost::python::arg("self")); |
||
1530 |
return (boost::python::arg("self")); |
||
1531 |
} |
||
1532 |
|||
1533 |
inline const char* member_func_doc (std::pair< hpp::fcl::Sphere , hpp::fcl::Transform3f > (hpp::fcl::Sphere::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
1534 |
{ |
||
1535 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Sphere , hpp::fcl::Transform3f > (hpp::fcl::Sphere::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Sphere::inflated)) |
||
1536 |
return "Inflate the sphere by an amount given by value. \n" |
||
1537 |
"\n" |
||
1538 |
"\n" |
||
1539 |
"Param\n" |
||
1540 |
" - value of the shape inflation.\n" |
||
1541 |
"\n" |
||
1542 |
"Return: a new inflated sphere and the related transform to account for the change of shape frame "; |
||
1543 |
return ""; |
||
1544 |
} |
||
1545 |
|||
1546 |
inline boost::python::detail::keywords<2> member_func_args (std::pair< hpp::fcl::Sphere , hpp::fcl::Transform3f > (hpp::fcl::Sphere::*function_ptr) (const hpp::fcl::FCL_REAL) const) |
||
1547 |
{ |
||
1548 |
if (function_ptr == static_cast<std::pair< hpp::fcl::Sphere , hpp::fcl::Transform3f > (hpp::fcl::Sphere::*) (const hpp::fcl::FCL_REAL) const>(&hpp::fcl::Sphere::inflated)) |
||
1549 |
return (boost::python::arg("self"), boost::python::arg("value")); |
||
1550 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
1551 |
} |
||
1552 |
} // namespace doxygen |
||
1553 |
#include <hpp/fcl/shape/geometric_shapes.h> |
||
1554 |
|||
1555 |
namespace doxygen { |
||
1556 |
|||
1557 |
template <> |
||
1558 |
struct class_doc_impl< hpp::fcl::TriangleP > |
||
1559 |
{ |
||
1560 |
5 |
static inline const char* run () |
|
1561 |
{ |
||
1562 |
5 |
return "hpp::fcl::Triangle stores the points instead of only indices of points. "; |
|
1563 |
} |
||
1564 |
15 |
static inline const char* attribute (const char* attrib) |
|
1565 |
{ |
||
1566 |
(void)attrib; // turn off unused parameter warning. |
||
1567 |
15 |
return ""; |
|
1568 |
} |
||
1569 |
}; |
||
1570 |
|||
1571 |
template <> |
||
1572 |
struct constructor_0_impl< hpp::fcl::TriangleP > |
||
1573 |
{ |
||
1574 |
5 |
static inline const char* doc () |
|
1575 |
{ |
||
1576 |
5 |
return ""; |
|
1577 |
} |
||
1578 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
1579 |
{ |
||
1580 |
5 |
return (boost::python::arg("self")); |
|
1581 |
} |
||
1582 |
}; |
||
1583 |
|||
1584 |
template <> |
||
1585 |
struct constructor_3_impl< hpp::fcl::TriangleP, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f & > |
||
1586 |
{ |
||
1587 |
5 |
static inline const char* doc () |
|
1588 |
{ |
||
1589 |
5 |
return ""; |
|
1590 |
} |
||
1591 |
5 |
static inline boost::python::detail::keywords<3+1> args () |
|
1592 |
{ |
||
1593 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("a_"), boost::python::arg("b_"), boost::python::arg("c_")); |
1594 |
} |
||
1595 |
}; |
||
1596 |
|||
1597 |
template <> |
||
1598 |
struct constructor_1_impl< hpp::fcl::TriangleP, const hpp::fcl::TriangleP & > |
||
1599 |
{ |
||
1600 |
5 |
static inline const char* doc () |
|
1601 |
{ |
||
1602 |
5 |
return ""; |
|
1603 |
} |
||
1604 |
5 |
static inline boost::python::detail::keywords<1+1> args () |
|
1605 |
{ |
||
1606 |
✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("other")); |
1607 |
} |
||
1608 |
}; |
||
1609 |
|||
1610 |
5 |
inline const char* member_func_doc ( hpp::fcl::TriangleP * (hpp::fcl::TriangleP::*function_ptr) () const) |
|
1611 |
{ |
||
1612 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast< hpp::fcl::TriangleP * (hpp::fcl::TriangleP::*) () const>(&hpp::fcl::TriangleP::clone)) |
1613 |
5 |
return "Clone *this into a new hpp::fcl::TriangleP. "; |
|
1614 |
return ""; |
||
1615 |
} |
||
1616 |
|||
1617 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::TriangleP * (hpp::fcl::TriangleP::*function_ptr) () const) |
||
1618 |
{ |
||
1619 |
if (function_ptr == static_cast< hpp::fcl::TriangleP * (hpp::fcl::TriangleP::*) () const>(&hpp::fcl::TriangleP::clone)) |
||
1620 |
return (boost::python::arg("self")); |
||
1621 |
return (boost::python::arg("self")); |
||
1622 |
} |
||
1623 |
|||
1624 |
inline const char* member_func_doc (void (hpp::fcl::TriangleP::*function_ptr) ()) |
||
1625 |
{ |
||
1626 |
if (function_ptr == static_cast<void (hpp::fcl::TriangleP::*) ()>(&hpp::fcl::TriangleP::computeLocalAABB)) |
||
1627 |
return "virtual function of compute hpp::fcl::AABB in local coordinate "; |
||
1628 |
return ""; |
||
1629 |
} |
||
1630 |
|||
1631 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::TriangleP::*function_ptr) ()) |
||
1632 |
{ |
||
1633 |
if (function_ptr == static_cast<void (hpp::fcl::TriangleP::*) ()>(&hpp::fcl::TriangleP::computeLocalAABB)) |
||
1634 |
return (boost::python::arg("self")); |
||
1635 |
return (boost::python::arg("self")); |
||
1636 |
} |
||
1637 |
|||
1638 |
inline const char* member_func_doc ( hpp::fcl::NODE_TYPE (hpp::fcl::TriangleP::*function_ptr) () const) |
||
1639 |
{ |
||
1640 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::TriangleP::*) () const>(&hpp::fcl::TriangleP::getNodeType)) |
||
1641 |
return "get the node type "; |
||
1642 |
return ""; |
||
1643 |
} |
||
1644 |
|||
1645 |
inline boost::python::detail::keywords<1> member_func_args ( hpp::fcl::NODE_TYPE (hpp::fcl::TriangleP::*function_ptr) () const) |
||
1646 |
{ |
||
1647 |
if (function_ptr == static_cast< hpp::fcl::NODE_TYPE (hpp::fcl::TriangleP::*) () const>(&hpp::fcl::TriangleP::getNodeType)) |
||
1648 |
return (boost::python::arg("self")); |
||
1649 |
return (boost::python::arg("self")); |
||
1650 |
} |
||
1651 |
} // namespace doxygen |
||
1652 |
|||
1653 |
#endif // DOXYGEN_AUTODOC_HPP_FCL_SHAPE_GEOMETRIC_SHAPES_H |
||
1654 |
Generated by: GCOVR (Version 4.2) |