| GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
| Line | Branch | Exec | Source |
1 |
#ifndef DOXYGEN_AUTODOC_HPP_FCL_COLLISION_DATA_H |
||
2 |
#define DOXYGEN_AUTODOC_HPP_FCL_COLLISION_DATA_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/collision_data.h> |
||
7 |
|||
8 |
namespace doxygen { |
||
9 |
|||
10 |
template <> |
||
11 |
struct class_doc_impl< hpp::fcl::CollisionRequest > |
||
12 |
{ |
||
13 |
5 |
static inline const char* run () |
|
14 |
{ |
||
15 |
5 |
return "request to the collision algorithm "; |
|
16 |
} |
||
17 |
30 |
static inline const char* attribute (const char* attrib) |
|
18 |
{ |
||
19 |
✓✓ | 30 |
if (strcmp(attrib, "num_max_contacts") == 0) |
20 |
5 |
return "The maximum number of contacts will return. "; |
|
21 |
✓✓ | 25 |
if (strcmp(attrib, "enable_contact") == 0) |
22 |
5 |
return "whether the contact information (normal, penetration depth and contact position) will return "; |
|
23 |
✓✓ | 20 |
if (strcmp(attrib, "enable_distance_lower_bound") == 0) |
24 |
5 |
return "Whether a lower bound on distance is returned when objects are disjoint. "; |
|
25 |
✓✓ | 15 |
if (strcmp(attrib, "security_margin") == 0) |
26 |
return "Distance below which objects are considered in collision. See Collision. \n" |
||
27 |
"\n" |
||
28 |
5 |
"Note: If set to -inf, the objects tested for collision are considered as collision free and no test is actually performed by functions hpp::fcl::collide of class hpp::fcl::ComputeCollision. "; |
|
29 |
✓✓ | 10 |
if (strcmp(attrib, "break_distance") == 0) |
30 |
5 |
return "Distance below which bounding volumes are broken down. See Collision. "; |
|
31 |
✓✗ | 5 |
if (strcmp(attrib, "distance_upper_bound") == 0) |
32 |
return "Distance above which GJK solver makes an early stopping. GJK stops searching for the closest points when it proves that the distance between two geometries is above this threshold. \n" |
||
33 |
"\n" |
||
34 |
5 |
"Remark: Consequently, the closest points might be incorrect, but allows to save computational resources. "; |
|
35 |
(void)attrib; // turn off unused parameter warning. |
||
36 |
return ""; |
||
37 |
} |
||
38 |
}; |
||
39 |
|||
40 |
template <> |
||
41 |
struct constructor_2_impl< hpp::fcl::CollisionRequest, const hpp::fcl::CollisionRequestFlag, size_t > |
||
42 |
{ |
||
43 |
5 |
static inline const char* doc () |
|
44 |
{ |
||
45 |
return "Constructor from a flag and a maximal number of contacts. \n" |
||
46 |
"\n" |
||
47 |
"\n" |
||
48 |
"Param\n" |
||
49 |
" - flag Collision request flag \n" |
||
50 |
5 |
" - num_max_contacts Maximal number of allowed contacts "; |
|
51 |
} |
||
52 |
5 |
static inline boost::python::detail::keywords<2+1> args () |
|
53 |
{ |
||
54 |
✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("flag"), boost::python::arg("num_max_contacts_")); |
55 |
} |
||
56 |
}; |
||
57 |
|||
58 |
template <> |
||
59 |
struct constructor_0_impl< hpp::fcl::CollisionRequest > |
||
60 |
{ |
||
61 |
5 |
static inline const char* doc () |
|
62 |
{ |
||
63 |
5 |
return "Default constructor. "; |
|
64 |
} |
||
65 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
66 |
{ |
||
67 |
5 |
return (boost::python::arg("self")); |
|
68 |
} |
||
69 |
}; |
||
70 |
|||
71 |
inline const char* member_func_doc (bool (hpp::fcl::CollisionRequest::*function_ptr) (const hpp::fcl::CollisionResult &) const) |
||
72 |
{ |
||
73 |
if (function_ptr == static_cast<bool (hpp::fcl::CollisionRequest::*) (const hpp::fcl::CollisionResult &) const>(&hpp::fcl::CollisionRequest::isSatisfied)) |
||
74 |
return ""; |
||
75 |
return ""; |
||
76 |
} |
||
77 |
|||
78 |
inline boost::python::detail::keywords<2> member_func_args (bool (hpp::fcl::CollisionRequest::*function_ptr) (const hpp::fcl::CollisionResult &) const) |
||
79 |
{ |
||
80 |
if (function_ptr == static_cast<bool (hpp::fcl::CollisionRequest::*) (const hpp::fcl::CollisionResult &) const>(&hpp::fcl::CollisionRequest::isSatisfied)) |
||
81 |
return (boost::python::arg("self"), boost::python::arg("result")); |
||
82 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
83 |
} |
||
84 |
|||
85 |
inline const char* member_func_doc (bool (hpp::fcl::CollisionRequest::*function_ptr) (const hpp::fcl::CollisionRequest &) const) |
||
86 |
{ |
||
87 |
if (function_ptr == static_cast<bool (hpp::fcl::CollisionRequest::*) (const hpp::fcl::CollisionRequest &) const>(&hpp::fcl::CollisionRequest::operator==)) |
||
88 |
return "whether two hpp::fcl::CollisionRequest are the same or not "; |
||
89 |
return ""; |
||
90 |
} |
||
91 |
|||
92 |
inline boost::python::detail::keywords<2> member_func_args (bool (hpp::fcl::CollisionRequest::*function_ptr) (const hpp::fcl::CollisionRequest &) const) |
||
93 |
{ |
||
94 |
if (function_ptr == static_cast<bool (hpp::fcl::CollisionRequest::*) (const hpp::fcl::CollisionRequest &) const>(&hpp::fcl::CollisionRequest::operator==)) |
||
95 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
96 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
97 |
} |
||
98 |
} // namespace doxygen |
||
99 |
#include <hpp/fcl/collision_data.h> |
||
100 |
|||
101 |
namespace doxygen { |
||
102 |
|||
103 |
template <> |
||
104 |
struct class_doc_impl< hpp::fcl::CollisionResult > |
||
105 |
{ |
||
106 |
5 |
static inline const char* run () |
|
107 |
{ |
||
108 |
5 |
return "collision result "; |
|
109 |
} |
||
110 |
5 |
static inline const char* attribute (const char* attrib) |
|
111 |
{ |
||
112 |
✓✗ | 5 |
if (strcmp(attrib, "distance_lower_bound") == 0) |
113 |
5 |
return "Lower bound on distance between objects if they are disjoint. See Collision Note: computed only on request (or if it does not add any computational overhead). "; |
|
114 |
if (strcmp(attrib, "nearest_points") == 0) |
||
115 |
return "nearest points available only when distance_lower_bound is inferior to CollisionRequest::break_distance. "; |
||
116 |
(void)attrib; // turn off unused parameter warning. |
||
117 |
return ""; |
||
118 |
} |
||
119 |
}; |
||
120 |
|||
121 |
template <> |
||
122 |
struct constructor_0_impl< hpp::fcl::CollisionResult > |
||
123 |
{ |
||
124 |
5 |
static inline const char* doc () |
|
125 |
{ |
||
126 |
5 |
return ""; |
|
127 |
} |
||
128 |
5 |
static inline boost::python::detail::keywords<0+1> args () |
|
129 |
{ |
||
130 |
5 |
return (boost::python::arg("self")); |
|
131 |
} |
||
132 |
}; |
||
133 |
|||
134 |
inline const char* member_func_doc (void (hpp::fcl::CollisionResult::*function_ptr) (const hpp::fcl::FCL_REAL &)) |
||
135 |
{ |
||
136 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) (const hpp::fcl::FCL_REAL &)>(&hpp::fcl::CollisionResult::updateDistanceLowerBound)) |
||
137 |
return "Update the lower bound only if the distance is inferior. "; |
||
138 |
return ""; |
||
139 |
} |
||
140 |
|||
141 |
inline boost::python::detail::keywords<2> member_func_args (void (hpp::fcl::CollisionResult::*function_ptr) (const hpp::fcl::FCL_REAL &)) |
||
142 |
{ |
||
143 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) (const hpp::fcl::FCL_REAL &)>(&hpp::fcl::CollisionResult::updateDistanceLowerBound)) |
||
144 |
return (boost::python::arg("self"), boost::python::arg("distance_lower_bound_")); |
||
145 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
146 |
} |
||
147 |
|||
148 |
inline const char* member_func_doc (void (hpp::fcl::CollisionResult::*function_ptr) (const hpp::fcl::Contact &)) |
||
149 |
{ |
||
150 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) (const hpp::fcl::Contact &)>(&hpp::fcl::CollisionResult::addContact)) |
||
151 |
return "add one contact into result structure "; |
||
152 |
return ""; |
||
153 |
} |
||
154 |
|||
155 |
inline boost::python::detail::keywords<2> member_func_args (void (hpp::fcl::CollisionResult::*function_ptr) (const hpp::fcl::Contact &)) |
||
156 |
{ |
||
157 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) (const hpp::fcl::Contact &)>(&hpp::fcl::CollisionResult::addContact)) |
||
158 |
return (boost::python::arg("self"), boost::python::arg("c")); |
||
159 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
160 |
} |
||
161 |
|||
162 |
inline const char* member_func_doc (bool (hpp::fcl::CollisionResult::*function_ptr) (const hpp::fcl::CollisionResult &) const) |
||
163 |
{ |
||
164 |
if (function_ptr == static_cast<bool (hpp::fcl::CollisionResult::*) (const hpp::fcl::CollisionResult &) const>(&hpp::fcl::CollisionResult::operator==)) |
||
165 |
return "whether two hpp::fcl::CollisionResult are the same or not "; |
||
166 |
return ""; |
||
167 |
} |
||
168 |
|||
169 |
inline boost::python::detail::keywords<2> member_func_args (bool (hpp::fcl::CollisionResult::*function_ptr) (const hpp::fcl::CollisionResult &) const) |
||
170 |
{ |
||
171 |
if (function_ptr == static_cast<bool (hpp::fcl::CollisionResult::*) (const hpp::fcl::CollisionResult &) const>(&hpp::fcl::CollisionResult::operator==)) |
||
172 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
173 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
174 |
} |
||
175 |
|||
176 |
inline const char* member_func_doc (bool (hpp::fcl::CollisionResult::*function_ptr) () const) |
||
177 |
{ |
||
178 |
if (function_ptr == static_cast<bool (hpp::fcl::CollisionResult::*) () const>(&hpp::fcl::CollisionResult::isCollision)) |
||
179 |
return "return binary collision result "; |
||
180 |
return ""; |
||
181 |
} |
||
182 |
|||
183 |
inline boost::python::detail::keywords<1> member_func_args (bool (hpp::fcl::CollisionResult::*function_ptr) () const) |
||
184 |
{ |
||
185 |
if (function_ptr == static_cast<bool (hpp::fcl::CollisionResult::*) () const>(&hpp::fcl::CollisionResult::isCollision)) |
||
186 |
return (boost::python::arg("self")); |
||
187 |
return (boost::python::arg("self")); |
||
188 |
} |
||
189 |
|||
190 |
inline const char* member_func_doc (size_t (hpp::fcl::CollisionResult::*function_ptr) () const) |
||
191 |
{ |
||
192 |
if (function_ptr == static_cast<size_t (hpp::fcl::CollisionResult::*) () const>(&hpp::fcl::CollisionResult::numContacts)) |
||
193 |
return "number of contacts found "; |
||
194 |
return ""; |
||
195 |
} |
||
196 |
|||
197 |
inline boost::python::detail::keywords<1> member_func_args (size_t (hpp::fcl::CollisionResult::*function_ptr) () const) |
||
198 |
{ |
||
199 |
if (function_ptr == static_cast<size_t (hpp::fcl::CollisionResult::*) () const>(&hpp::fcl::CollisionResult::numContacts)) |
||
200 |
return (boost::python::arg("self")); |
||
201 |
return (boost::python::arg("self")); |
||
202 |
} |
||
203 |
|||
204 |
5 |
inline const char* member_func_doc (const hpp::fcl::Contact & (hpp::fcl::CollisionResult::*function_ptr) (size_t) const) |
|
205 |
{ |
||
206 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast<const hpp::fcl::Contact & (hpp::fcl::CollisionResult::*) (size_t) const>(&hpp::fcl::CollisionResult::getContact)) |
207 |
5 |
return "get the i-th contact calculated "; |
|
208 |
return ""; |
||
209 |
} |
||
210 |
|||
211 |
inline boost::python::detail::keywords<2> member_func_args (const hpp::fcl::Contact & (hpp::fcl::CollisionResult::*function_ptr) (size_t) const) |
||
212 |
{ |
||
213 |
if (function_ptr == static_cast<const hpp::fcl::Contact & (hpp::fcl::CollisionResult::*) (size_t) const>(&hpp::fcl::CollisionResult::getContact)) |
||
214 |
return (boost::python::arg("self"), boost::python::arg("i")); |
||
215 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
216 |
} |
||
217 |
|||
218 |
inline const char* member_func_doc (void (hpp::fcl::CollisionResult::*function_ptr) (size_t, const hpp::fcl::Contact &)) |
||
219 |
{ |
||
220 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) (size_t, const hpp::fcl::Contact &)>(&hpp::fcl::CollisionResult::setContact)) |
||
221 |
return "set the i-th contact calculated "; |
||
222 |
return ""; |
||
223 |
} |
||
224 |
|||
225 |
inline boost::python::detail::keywords<3> member_func_args (void (hpp::fcl::CollisionResult::*function_ptr) (size_t, const hpp::fcl::Contact &)) |
||
226 |
{ |
||
227 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) (size_t, const hpp::fcl::Contact &)>(&hpp::fcl::CollisionResult::setContact)) |
||
228 |
return (boost::python::arg("self"), boost::python::arg("i"), boost::python::arg("c")); |
||
229 |
return (boost::python::arg("self"), boost::python::arg("arg0"), boost::python::arg("arg1")); |
||
230 |
} |
||
231 |
|||
232 |
inline const char* member_func_doc (void (hpp::fcl::CollisionResult::*function_ptr) (std::vector< hpp::fcl::Contact > &) const) |
||
233 |
{ |
||
234 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) (std::vector< hpp::fcl::Contact > &) const>(&hpp::fcl::CollisionResult::getContacts)) |
||
235 |
return "get all the contacts "; |
||
236 |
return ""; |
||
237 |
} |
||
238 |
|||
239 |
inline boost::python::detail::keywords<2> member_func_args (void (hpp::fcl::CollisionResult::*function_ptr) (std::vector< hpp::fcl::Contact > &) const) |
||
240 |
{ |
||
241 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) (std::vector< hpp::fcl::Contact > &) const>(&hpp::fcl::CollisionResult::getContacts)) |
||
242 |
return (boost::python::arg("self"), boost::python::arg("contacts_")); |
||
243 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
244 |
} |
||
245 |
|||
246 |
5 |
inline const char* member_func_doc (const std::vector< hpp::fcl::Contact > & (hpp::fcl::CollisionResult::*function_ptr) () const) |
|
247 |
{ |
||
248 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast<const std::vector< hpp::fcl::Contact > & (hpp::fcl::CollisionResult::*) () const>(&hpp::fcl::CollisionResult::getContacts)) |
249 |
5 |
return ""; |
|
250 |
return ""; |
||
251 |
} |
||
252 |
|||
253 |
inline boost::python::detail::keywords<1> member_func_args (const std::vector< hpp::fcl::Contact > & (hpp::fcl::CollisionResult::*function_ptr) () const) |
||
254 |
{ |
||
255 |
if (function_ptr == static_cast<const std::vector< hpp::fcl::Contact > & (hpp::fcl::CollisionResult::*) () const>(&hpp::fcl::CollisionResult::getContacts)) |
||
256 |
return (boost::python::arg("self")); |
||
257 |
return (boost::python::arg("self")); |
||
258 |
} |
||
259 |
|||
260 |
inline const char* member_func_doc (void (hpp::fcl::CollisionResult::*function_ptr) ()) |
||
261 |
{ |
||
262 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) ()>(&hpp::fcl::CollisionResult::clear)) |
||
263 |
return "clear the results obtained "; |
||
264 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) ()>(&hpp::fcl::CollisionResult::swapObjects)) |
||
265 |
return "reposition hpp::fcl::Contact objects when fcl inverts them during their construction. "; |
||
266 |
return ""; |
||
267 |
} |
||
268 |
|||
269 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::CollisionResult::*function_ptr) ()) |
||
270 |
{ |
||
271 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) ()>(&hpp::fcl::CollisionResult::clear)) |
||
272 |
return (boost::python::arg("self")); |
||
273 |
if (function_ptr == static_cast<void (hpp::fcl::CollisionResult::*) ()>(&hpp::fcl::CollisionResult::swapObjects)) |
||
274 |
return (boost::python::arg("self")); |
||
275 |
return (boost::python::arg("self")); |
||
276 |
} |
||
277 |
} // namespace doxygen |
||
278 |
#include <hpp/fcl/collision_data.h> |
||
279 |
|||
280 |
namespace doxygen { |
||
281 |
|||
282 |
template <> |
||
283 |
struct class_doc_impl< hpp::fcl::Contact > |
||
284 |
{ |
||
285 |
5 |
static inline const char* run () |
|
286 |
{ |
||
287 |
5 |
return "hpp::fcl::Contact information returned by collision. "; |
|
288 |
} |
||
289 |
35 |
static inline const char* attribute (const char* attrib) |
|
290 |
{ |
||
291 |
✓✓ | 35 |
if (strcmp(attrib, "o1") == 0) |
292 |
5 |
return "collision object 1 "; |
|
293 |
✓✓ | 30 |
if (strcmp(attrib, "o2") == 0) |
294 |
5 |
return "collision object 2 "; |
|
295 |
✓✓ | 25 |
if (strcmp(attrib, "b1") == 0) |
296 |
5 |
return "contact primitive in object 1 if object 1 is mesh or point cloud, it is the triangle or point id if object 1 is geometry shape, it is NONE (-1), if object 1 is octree, it is the id of the cell "; |
|
297 |
✓✓ | 20 |
if (strcmp(attrib, "b2") == 0) |
298 |
5 |
return "contact primitive in object 2 if object 2 is mesh or point cloud, it is the triangle or point id if object 2 is geometry shape, it is NONE (-1), if object 2 is octree, it is the id of the cell "; |
|
299 |
✓✓ | 15 |
if (strcmp(attrib, "normal") == 0) |
300 |
5 |
return "contact normal, pointing from o1 to o2 "; |
|
301 |
✓✓ | 10 |
if (strcmp(attrib, "pos") == 0) |
302 |
5 |
return "contact position, in world space "; |
|
303 |
✓✗ | 5 |
if (strcmp(attrib, "penetration_depth") == 0) |
304 |
5 |
return "penetration depth "; |
|
305 |
if (strcmp(attrib, "NONE") == 0) |
||
306 |
return "invalid contact primitive information "; |
||
307 |
(void)attrib; // turn off unused parameter warning. |
||
308 |
return ""; |
||
309 |
} |
||
310 |
}; |
||
311 |
|||
312 |
template <> |
||
313 |
struct constructor_0_impl< hpp::fcl::Contact > |
||
314 |
{ |
||
315 |
static inline const char* doc () |
||
316 |
{ |
||
317 |
return "Default constructor. "; |
||
318 |
} |
||
319 |
static inline boost::python::detail::keywords<0+1> args () |
||
320 |
{ |
||
321 |
return (boost::python::arg("self")); |
||
322 |
} |
||
323 |
}; |
||
324 |
|||
325 |
template <> |
||
326 |
struct constructor_4_impl< hpp::fcl::Contact, const hpp::fcl::CollisionGeometry *, const hpp::fcl::CollisionGeometry *, int, int > |
||
327 |
{ |
||
328 |
5 |
static inline const char* doc () |
|
329 |
{ |
||
330 |
5 |
return ""; |
|
331 |
} |
||
332 |
5 |
static inline boost::python::detail::keywords<4+1> args () |
|
333 |
{ |
||
334 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("o1_"), boost::python::arg("o2_"), boost::python::arg("b1_"), boost::python::arg("b2_")); |
335 |
} |
||
336 |
}; |
||
337 |
|||
338 |
template <> |
||
339 |
struct constructor_7_impl< hpp::fcl::Contact, const hpp::fcl::CollisionGeometry *, const hpp::fcl::CollisionGeometry *, int, int, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, hpp::fcl::FCL_REAL > |
||
340 |
{ |
||
341 |
5 |
static inline const char* doc () |
|
342 |
{ |
||
343 |
5 |
return ""; |
|
344 |
} |
||
345 |
5 |
static inline boost::python::detail::keywords<7+1> args () |
|
346 |
{ |
||
347 |
✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ ✓✗✓✗ |
10 |
return (boost::python::arg("self"), boost::python::arg("o1_"), boost::python::arg("o2_"), boost::python::arg("b1_"), boost::python::arg("b2_"), boost::python::arg("pos_"), boost::python::arg("normal_"), boost::python::arg("depth_")); |
348 |
} |
||
349 |
}; |
||
350 |
|||
351 |
inline const char* member_func_doc (bool (hpp::fcl::Contact::*function_ptr) (const hpp::fcl::Contact &) const) |
||
352 |
{ |
||
353 |
if (function_ptr == static_cast<bool (hpp::fcl::Contact::*) (const hpp::fcl::Contact &) const>(&hpp::fcl::Contact::operator<)) |
||
354 |
return ""; |
||
355 |
if (function_ptr == static_cast<bool (hpp::fcl::Contact::*) (const hpp::fcl::Contact &) const>(&hpp::fcl::Contact::operator==)) |
||
356 |
return ""; |
||
357 |
if (function_ptr == static_cast<bool (hpp::fcl::Contact::*) (const hpp::fcl::Contact &) const>(&hpp::fcl::Contact::operator!=)) |
||
358 |
return ""; |
||
359 |
return ""; |
||
360 |
} |
||
361 |
|||
362 |
inline boost::python::detail::keywords<2> member_func_args (bool (hpp::fcl::Contact::*function_ptr) (const hpp::fcl::Contact &) const) |
||
363 |
{ |
||
364 |
if (function_ptr == static_cast<bool (hpp::fcl::Contact::*) (const hpp::fcl::Contact &) const>(&hpp::fcl::Contact::operator<)) |
||
365 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
366 |
if (function_ptr == static_cast<bool (hpp::fcl::Contact::*) (const hpp::fcl::Contact &) const>(&hpp::fcl::Contact::operator==)) |
||
367 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
368 |
if (function_ptr == static_cast<bool (hpp::fcl::Contact::*) (const hpp::fcl::Contact &) const>(&hpp::fcl::Contact::operator!=)) |
||
369 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
370 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
371 |
} |
||
372 |
} // namespace doxygen |
||
373 |
#include <hpp/fcl/collision_data.h> |
||
374 |
|||
375 |
namespace doxygen { |
||
376 |
|||
377 |
template <> |
||
378 |
struct class_doc_impl< hpp::fcl::DistanceRequest > |
||
379 |
{ |
||
380 |
5 |
static inline const char* run () |
|
381 |
{ |
||
382 |
5 |
return "request to the distance computation "; |
|
383 |
} |
||
384 |
15 |
static inline const char* attribute (const char* attrib) |
|
385 |
{ |
||
386 |
✓✓ | 15 |
if (strcmp(attrib, "enable_nearest_points") == 0) |
387 |
5 |
return "whether to return the nearest points "; |
|
388 |
✓✓ | 10 |
if (strcmp(attrib, "rel_err") == 0) |
389 |
5 |
return "error threshold for approximate distance "; |
|
390 |
(void)attrib; // turn off unused parameter warning. |
||
391 |
5 |
return ""; |
|
392 |
} |
||
393 |
}; |
||
394 |
|||
395 |
template <> |
||
396 |
struct constructor_3_impl< hpp::fcl::DistanceRequest, bool, hpp::fcl::FCL_REAL, hpp::fcl::FCL_REAL > |
||
397 |
{ |
||
398 |
static inline const char* doc () |
||
399 |
{ |
||
400 |
return "Param\n" |
||
401 |
" - enable_nearest_points_ enables the nearest points computation. \n" |
||
402 |
" - rel_err_ \n" |
||
403 |
" - abs_err_ "; |
||
404 |
} |
||
405 |
static inline boost::python::detail::keywords<3+1> args () |
||
406 |
{ |
||
407 |
return (boost::python::arg("self"), boost::python::arg("enable_nearest_points_"), boost::python::arg("rel_err_"), boost::python::arg("abs_err_")); |
||
408 |
} |
||
409 |
}; |
||
410 |
|||
411 |
inline const char* member_func_doc (bool (hpp::fcl::DistanceRequest::*function_ptr) (const hpp::fcl::DistanceResult &) const) |
||
412 |
{ |
||
413 |
if (function_ptr == static_cast<bool (hpp::fcl::DistanceRequest::*) (const hpp::fcl::DistanceResult &) const>(&hpp::fcl::DistanceRequest::isSatisfied)) |
||
414 |
return ""; |
||
415 |
return ""; |
||
416 |
} |
||
417 |
|||
418 |
inline boost::python::detail::keywords<2> member_func_args (bool (hpp::fcl::DistanceRequest::*function_ptr) (const hpp::fcl::DistanceResult &) const) |
||
419 |
{ |
||
420 |
if (function_ptr == static_cast<bool (hpp::fcl::DistanceRequest::*) (const hpp::fcl::DistanceResult &) const>(&hpp::fcl::DistanceRequest::isSatisfied)) |
||
421 |
return (boost::python::arg("self"), boost::python::arg("result")); |
||
422 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
423 |
} |
||
424 |
|||
425 |
inline const char* member_func_doc (bool (hpp::fcl::DistanceRequest::*function_ptr) (const hpp::fcl::DistanceRequest &) const) |
||
426 |
{ |
||
427 |
if (function_ptr == static_cast<bool (hpp::fcl::DistanceRequest::*) (const hpp::fcl::DistanceRequest &) const>(&hpp::fcl::DistanceRequest::operator==)) |
||
428 |
return "whether two hpp::fcl::DistanceRequest are the same or not "; |
||
429 |
return ""; |
||
430 |
} |
||
431 |
|||
432 |
inline boost::python::detail::keywords<2> member_func_args (bool (hpp::fcl::DistanceRequest::*function_ptr) (const hpp::fcl::DistanceRequest &) const) |
||
433 |
{ |
||
434 |
if (function_ptr == static_cast<bool (hpp::fcl::DistanceRequest::*) (const hpp::fcl::DistanceRequest &) const>(&hpp::fcl::DistanceRequest::operator==)) |
||
435 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
436 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
437 |
} |
||
438 |
} // namespace doxygen |
||
439 |
#include <hpp/fcl/collision_data.h> |
||
440 |
|||
441 |
namespace doxygen { |
||
442 |
|||
443 |
template <> |
||
444 |
struct class_doc_impl< hpp::fcl::DistanceResult > |
||
445 |
{ |
||
446 |
5 |
static inline const char* run () |
|
447 |
{ |
||
448 |
5 |
return "distance result "; |
|
449 |
} |
||
450 |
40 |
static inline const char* attribute (const char* attrib) |
|
451 |
{ |
||
452 |
✓✓ | 40 |
if (strcmp(attrib, "min_distance") == 0) |
453 |
5 |
return "minimum distance between two objects. if two objects are in collision, min_distance <= 0. "; |
|
454 |
✓✓ | 35 |
if (strcmp(attrib, "nearest_points") == 0) |
455 |
10 |
return "nearest points "; |
|
456 |
✓✓ | 25 |
if (strcmp(attrib, "normal") == 0) |
457 |
5 |
return "In case both objects are in collision, store the normal. "; |
|
458 |
✓✓ | 20 |
if (strcmp(attrib, "o1") == 0) |
459 |
5 |
return "collision object 1 "; |
|
460 |
✓✓ | 15 |
if (strcmp(attrib, "o2") == 0) |
461 |
5 |
return "collision object 2 "; |
|
462 |
✓✓ | 10 |
if (strcmp(attrib, "b1") == 0) |
463 |
5 |
return "information about the nearest point in object 1 if object 1 is mesh or point cloud, it is the triangle or point id if object 1 is geometry shape, it is NONE (-1), if object 1 is octree, it is the id of the cell "; |
|
464 |
✓✗ | 5 |
if (strcmp(attrib, "b2") == 0) |
465 |
5 |
return "information about the nearest point in object 2 if object 2 is mesh or point cloud, it is the triangle or point id if object 2 is geometry shape, it is NONE (-1), if object 2 is octree, it is the id of the cell "; |
|
466 |
if (strcmp(attrib, "NONE") == 0) |
||
467 |
return "invalid contact primitive information "; |
||
468 |
(void)attrib; // turn off unused parameter warning. |
||
469 |
return ""; |
||
470 |
} |
||
471 |
}; |
||
472 |
|||
473 |
template <> |
||
474 |
struct constructor_1_impl< hpp::fcl::DistanceResult, hpp::fcl::FCL_REAL > |
||
475 |
{ |
||
476 |
static inline const char* doc () |
||
477 |
{ |
||
478 |
return ""; |
||
479 |
} |
||
480 |
static inline boost::python::detail::keywords<1+1> args () |
||
481 |
{ |
||
482 |
return (boost::python::arg("self"), boost::python::arg("min_distance_")); |
||
483 |
} |
||
484 |
}; |
||
485 |
|||
486 |
inline const char* member_func_doc (void (hpp::fcl::DistanceResult::*function_ptr) ( hpp::fcl::FCL_REAL, const hpp::fcl::CollisionGeometry *, const hpp::fcl::CollisionGeometry *, int, int)) |
||
487 |
{ |
||
488 |
if (function_ptr == static_cast<void (hpp::fcl::DistanceResult::*) ( hpp::fcl::FCL_REAL, const hpp::fcl::CollisionGeometry *, const hpp::fcl::CollisionGeometry *, int, int)>(&hpp::fcl::DistanceResult::update)) |
||
489 |
return "add distance information into the result "; |
||
490 |
return ""; |
||
491 |
} |
||
492 |
|||
493 |
inline boost::python::detail::keywords<6> member_func_args (void (hpp::fcl::DistanceResult::*function_ptr) ( hpp::fcl::FCL_REAL, const hpp::fcl::CollisionGeometry *, const hpp::fcl::CollisionGeometry *, int, int)) |
||
494 |
{ |
||
495 |
if (function_ptr == static_cast<void (hpp::fcl::DistanceResult::*) ( hpp::fcl::FCL_REAL, const hpp::fcl::CollisionGeometry *, const hpp::fcl::CollisionGeometry *, int, int)>(&hpp::fcl::DistanceResult::update)) |
||
496 |
return (boost::python::arg("self"), boost::python::arg("distance"), boost::python::arg("o1_"), boost::python::arg("o2_"), boost::python::arg("b1_"), boost::python::arg("b2_")); |
||
497 |
return (boost::python::arg("self"), boost::python::arg("arg0"), boost::python::arg("arg1"), boost::python::arg("arg2"), boost::python::arg("arg3"), boost::python::arg("arg4")); |
||
498 |
} |
||
499 |
|||
500 |
inline const char* member_func_doc (void (hpp::fcl::DistanceResult::*function_ptr) ( hpp::fcl::FCL_REAL, const hpp::fcl::CollisionGeometry *, const hpp::fcl::CollisionGeometry *, int, int, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &)) |
||
501 |
{ |
||
502 |
if (function_ptr == static_cast<void (hpp::fcl::DistanceResult::*) ( hpp::fcl::FCL_REAL, const hpp::fcl::CollisionGeometry *, const hpp::fcl::CollisionGeometry *, int, int, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &)>(&hpp::fcl::DistanceResult::update)) |
||
503 |
return "add distance information into the result "; |
||
504 |
return ""; |
||
505 |
} |
||
506 |
|||
507 |
inline boost::python::detail::keywords<9> member_func_args (void (hpp::fcl::DistanceResult::*function_ptr) ( hpp::fcl::FCL_REAL, const hpp::fcl::CollisionGeometry *, const hpp::fcl::CollisionGeometry *, int, int, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &)) |
||
508 |
{ |
||
509 |
if (function_ptr == static_cast<void (hpp::fcl::DistanceResult::*) ( hpp::fcl::FCL_REAL, const hpp::fcl::CollisionGeometry *, const hpp::fcl::CollisionGeometry *, int, int, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &, const hpp::fcl::Vec3f &)>(&hpp::fcl::DistanceResult::update)) |
||
510 |
return (boost::python::arg("self"), boost::python::arg("distance"), boost::python::arg("o1_"), boost::python::arg("o2_"), boost::python::arg("b1_"), boost::python::arg("b2_"), boost::python::arg("p1"), boost::python::arg("p2"), boost::python::arg("normal_")); |
||
511 |
return (boost::python::arg("self"), boost::python::arg("arg0"), boost::python::arg("arg1"), boost::python::arg("arg2"), boost::python::arg("arg3"), boost::python::arg("arg4"), boost::python::arg("arg5"), boost::python::arg("arg6"), boost::python::arg("arg7")); |
||
512 |
} |
||
513 |
|||
514 |
inline const char* member_func_doc (void (hpp::fcl::DistanceResult::*function_ptr) (const hpp::fcl::DistanceResult &)) |
||
515 |
{ |
||
516 |
if (function_ptr == static_cast<void (hpp::fcl::DistanceResult::*) (const hpp::fcl::DistanceResult &)>(&hpp::fcl::DistanceResult::update)) |
||
517 |
return "add distance information into the result "; |
||
518 |
return ""; |
||
519 |
} |
||
520 |
|||
521 |
inline boost::python::detail::keywords<2> member_func_args (void (hpp::fcl::DistanceResult::*function_ptr) (const hpp::fcl::DistanceResult &)) |
||
522 |
{ |
||
523 |
if (function_ptr == static_cast<void (hpp::fcl::DistanceResult::*) (const hpp::fcl::DistanceResult &)>(&hpp::fcl::DistanceResult::update)) |
||
524 |
return (boost::python::arg("self"), boost::python::arg("other_result")); |
||
525 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
526 |
} |
||
527 |
|||
528 |
5 |
inline const char* member_func_doc (void (hpp::fcl::DistanceResult::*function_ptr) ()) |
|
529 |
{ |
||
530 |
✓✗✗✓ ✗✗ |
5 |
if (function_ptr == static_cast<void (hpp::fcl::DistanceResult::*) ()>(&hpp::fcl::DistanceResult::clear)) |
531 |
5 |
return "clear the result "; |
|
532 |
return ""; |
||
533 |
} |
||
534 |
|||
535 |
inline boost::python::detail::keywords<1> member_func_args (void (hpp::fcl::DistanceResult::*function_ptr) ()) |
||
536 |
{ |
||
537 |
if (function_ptr == static_cast<void (hpp::fcl::DistanceResult::*) ()>(&hpp::fcl::DistanceResult::clear)) |
||
538 |
return (boost::python::arg("self")); |
||
539 |
return (boost::python::arg("self")); |
||
540 |
} |
||
541 |
|||
542 |
inline const char* member_func_doc (bool (hpp::fcl::DistanceResult::*function_ptr) (const hpp::fcl::DistanceResult &) const) |
||
543 |
{ |
||
544 |
if (function_ptr == static_cast<bool (hpp::fcl::DistanceResult::*) (const hpp::fcl::DistanceResult &) const>(&hpp::fcl::DistanceResult::operator==)) |
||
545 |
return "whether two hpp::fcl::DistanceResult are the same or not "; |
||
546 |
return ""; |
||
547 |
} |
||
548 |
|||
549 |
inline boost::python::detail::keywords<2> member_func_args (bool (hpp::fcl::DistanceResult::*function_ptr) (const hpp::fcl::DistanceResult &) const) |
||
550 |
{ |
||
551 |
if (function_ptr == static_cast<bool (hpp::fcl::DistanceResult::*) (const hpp::fcl::DistanceResult &) const>(&hpp::fcl::DistanceResult::operator==)) |
||
552 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
553 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
554 |
} |
||
555 |
} // namespace doxygen |
||
556 |
#include <hpp/fcl/collision_data.h> |
||
557 |
|||
558 |
namespace doxygen { |
||
559 |
|||
560 |
template <> |
||
561 |
struct class_doc_impl< hpp::fcl::QueryRequest > |
||
562 |
{ |
||
563 |
5 |
static inline const char* run () |
|
564 |
{ |
||
565 |
5 |
return "base class for all query requests "; |
|
566 |
} |
||
567 |
55 |
static inline const char* attribute (const char* attrib) |
|
568 |
{ |
||
569 |
✓✓ | 55 |
if (strcmp(attrib, "enable_cached_gjk_guess") == 0) |
570 |
10 |
return "whether enable gjk initial guess @Deprecated Use gjk_initial_guess instead "; |
|
571 |
✓✓ | 45 |
if (strcmp(attrib, "gjk_variant") == 0) |
572 |
5 |
return "whether to enable the Nesterov accleration of GJK "; |
|
573 |
✓✓ | 40 |
if (strcmp(attrib, "gjk_convergence_criterion") == 0) |
574 |
5 |
return "convergence criterion used to stop GJK "; |
|
575 |
✓✓ | 35 |
if (strcmp(attrib, "gjk_convergence_criterion_type") == 0) |
576 |
5 |
return "convergence criterion used to stop GJK "; |
|
577 |
✓✓ | 30 |
if (strcmp(attrib, "gjk_tolerance") == 0) |
578 |
5 |
return "tolerance for the GJK algorithm "; |
|
579 |
✓✓ | 25 |
if (strcmp(attrib, "gjk_max_iterations") == 0) |
580 |
5 |
return "maximum iteration for the GJK algorithm "; |
|
581 |
✓✓ | 20 |
if (strcmp(attrib, "cached_gjk_guess") == 0) |
582 |
5 |
return "the gjk initial guess set by user "; |
|
583 |
✓✓ | 15 |
if (strcmp(attrib, "cached_support_func_guess") == 0) |
584 |
5 |
return "the support function initial guess set by user "; |
|
585 |
✓✓ | 10 |
if (strcmp(attrib, "enable_timings") == 0) |
586 |
5 |
return "enable timings when performing collision/distance request "; |
|
587 |
✗✓ | 5 |
if (strcmp(attrib, "collision_distance_threshold") == 0) |
588 |
return "threshold below which a collision is considered. "; |
||
589 |
(void)attrib; // turn off unused parameter warning. |
||
590 |
5 |
return ""; |
|
591 |
} |
||
592 |
}; |
||
593 |
|||
594 |
template <> |
||
595 |
struct constructor_0_impl< hpp::fcl::QueryRequest > |
||
596 |
{ |
||
597 |
static inline const char* doc () |
||
598 |
{ |
||
599 |
return "Default constructor. "; |
||
600 |
} |
||
601 |
static inline boost::python::detail::keywords<0+1> args () |
||
602 |
{ |
||
603 |
return (boost::python::arg("self")); |
||
604 |
} |
||
605 |
}; |
||
606 |
|||
607 |
template <> |
||
608 |
struct constructor_1_impl< hpp::fcl::QueryRequest, const hpp::fcl::QueryRequest & > |
||
609 |
{ |
||
610 |
static inline const char* doc () |
||
611 |
{ |
||
612 |
return "Copy constructor. "; |
||
613 |
} |
||
614 |
static inline boost::python::detail::keywords<1+1> args () |
||
615 |
{ |
||
616 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
617 |
} |
||
618 |
}; |
||
619 |
|||
620 |
inline const char* member_func_doc ( hpp::fcl::QueryRequest & (hpp::fcl::QueryRequest::*function_ptr) (const hpp::fcl::QueryRequest &)) |
||
621 |
{ |
||
622 |
if (function_ptr == static_cast< hpp::fcl::QueryRequest & (hpp::fcl::QueryRequest::*) (const hpp::fcl::QueryRequest &)>(&hpp::fcl::QueryRequest::operator=)) |
||
623 |
return "Copy assignment operator. "; |
||
624 |
return ""; |
||
625 |
} |
||
626 |
|||
627 |
inline boost::python::detail::keywords<2> member_func_args ( hpp::fcl::QueryRequest & (hpp::fcl::QueryRequest::*function_ptr) (const hpp::fcl::QueryRequest &)) |
||
628 |
{ |
||
629 |
if (function_ptr == static_cast< hpp::fcl::QueryRequest & (hpp::fcl::QueryRequest::*) (const hpp::fcl::QueryRequest &)>(&hpp::fcl::QueryRequest::operator=)) |
||
630 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
631 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
632 |
} |
||
633 |
|||
634 |
inline const char* member_func_doc (void (hpp::fcl::QueryRequest::*function_ptr) (const hpp::fcl::QueryResult &)) |
||
635 |
{ |
||
636 |
if (function_ptr == static_cast<void (hpp::fcl::QueryRequest::*) (const hpp::fcl::QueryResult &)>(&hpp::fcl::QueryRequest::updateGuess)) |
||
637 |
return ""; |
||
638 |
return ""; |
||
639 |
} |
||
640 |
|||
641 |
inline boost::python::detail::keywords<2> member_func_args (void (hpp::fcl::QueryRequest::*function_ptr) (const hpp::fcl::QueryResult &)) |
||
642 |
{ |
||
643 |
if (function_ptr == static_cast<void (hpp::fcl::QueryRequest::*) (const hpp::fcl::QueryResult &)>(&hpp::fcl::QueryRequest::updateGuess)) |
||
644 |
return (boost::python::arg("self"), boost::python::arg("result")); |
||
645 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
646 |
} |
||
647 |
|||
648 |
inline const char* member_func_doc (bool (hpp::fcl::QueryRequest::*function_ptr) (const hpp::fcl::QueryRequest &) const) |
||
649 |
{ |
||
650 |
if (function_ptr == static_cast<bool (hpp::fcl::QueryRequest::*) (const hpp::fcl::QueryRequest &) const>(&hpp::fcl::QueryRequest::operator==)) |
||
651 |
return "whether two hpp::fcl::QueryRequest are the same or not "; |
||
652 |
return ""; |
||
653 |
} |
||
654 |
|||
655 |
inline boost::python::detail::keywords<2> member_func_args (bool (hpp::fcl::QueryRequest::*function_ptr) (const hpp::fcl::QueryRequest &) const) |
||
656 |
{ |
||
657 |
if (function_ptr == static_cast<bool (hpp::fcl::QueryRequest::*) (const hpp::fcl::QueryRequest &) const>(&hpp::fcl::QueryRequest::operator==)) |
||
658 |
return (boost::python::arg("self"), boost::python::arg("other")); |
||
659 |
return (boost::python::arg("self"), boost::python::arg("arg0")); |
||
660 |
} |
||
661 |
} // namespace doxygen |
||
662 |
#include <hpp/fcl/collision_data.h> |
||
663 |
|||
664 |
namespace doxygen { |
||
665 |
|||
666 |
template <> |
||
667 |
struct class_doc_impl< hpp::fcl::QueryResult > |
||
668 |
{ |
||
669 |
5 |
static inline const char* run () |
|
670 |
{ |
||
671 |
5 |
return "base class for all query results "; |
|
672 |
} |
||
673 |
15 |
static inline const char* attribute (const char* attrib) |
|
674 |
{ |
||
675 |
✓✓ | 15 |
if (strcmp(attrib, "cached_gjk_guess") == 0) |
676 |
5 |
return "stores the last GJK ray when relevant. "; |
|
677 |
✓✓ | 10 |
if (strcmp(attrib, "cached_support_func_guess") == 0) |
678 |
5 |
return "stores the last support function vertex index, when relevant. "; |
|
679 |
✓✗ | 5 |
if (strcmp(attrib, "timings") == 0) |
680 |
5 |
return "timings for the given request "; |
|
681 |
(void)attrib; // turn off unused parameter warning. |
||
682 |
return ""; |
||
683 |
} |
||
684 |
}; |
||
685 |
|||
686 |
template <> |
||
687 |
struct constructor_0_impl< hpp::fcl::QueryResult > |
||
688 |
{ |
||
689 |
static inline const char* doc () |
||
690 |
{ |
||
691 |
return ""; |
||
692 |
} |
||
693 |
static inline boost::python::detail::keywords<0+1> args () |
||
694 |
{ |
||
695 |
return (boost::python::arg("self")); |
||
696 |
} |
||
697 |
}; |
||
698 |
} // namespace doxygen |
||
699 |
|||
700 |
#endif // DOXYGEN_AUTODOC_HPP_FCL_COLLISION_DATA_H |
||
701 |
| Generated by: GCOVR (Version 4.2) |