| Directory: | ./ |
|---|---|
| File: | python/doxygen_autodoc/coal/collision_data.h |
| Date: | 2025-04-01 09:23:31 |
| Exec | Total | Coverage | |
|---|---|---|---|
| Lines: | 150 | 172 | 87.2% |
| Branches: | 114 | 174 | 65.5% |
| Line | Branch | Exec | Source |
|---|---|---|---|
| 1 | #ifndef DOXYGEN_AUTODOC_COAL_COLLISION_DATA_H | ||
| 2 | #define DOXYGEN_AUTODOC_COAL_COLLISION_DATA_H | ||
| 3 | |||
| 4 | #include "/root/robotpkg/path/py-coal/work/coal-3.0.1/doc/python/doxygen.hh" | ||
| 5 | |||
| 6 | #include <coal/collision_data.h> | ||
| 7 | |||
| 8 | namespace doxygen { | ||
| 9 | |||
| 10 | template <> | ||
| 11 | struct class_doc_impl< coal::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 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 25 times.
|
30 | if (strcmp(attrib, "num_max_contacts") == 0) |
| 20 | 5 | return "The maximum number of contacts that can be returned. "; | |
| 21 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 20 times.
|
25 | if (strcmp(attrib, "enable_contact") == 0) |
| 22 | 5 | return "whether the contact information (normal, penetration depth and contact position) will return. "; | |
| 23 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 15 times.
|
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 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 10 times.
|
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 coal::collide of class coal::ComputeCollision. "; | |
| 29 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
|
10 | if (strcmp(attrib, "break_distance") == 0) |
| 30 | 5 | return "Distance below which bounding volumes are broken down. See Collision. "; | |
| 31 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
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< coal::CollisionRequest, const coal::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 |
4/8✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 5 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 5 times.
✗ Branch 9 not taken.
✓ Branch 11 taken 5 times.
✗ Branch 12 not taken.
|
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< coal::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 (coal::CollisionRequest::*function_ptr) (const coal::CollisionResult &) const) | ||
| 72 | { | ||
| 73 | if (function_ptr == static_cast<bool (coal::CollisionRequest::*) (const coal::CollisionResult &) const>(&coal::CollisionRequest::isSatisfied)) | ||
| 74 | return ""; | ||
| 75 | return ""; | ||
| 76 | } | ||
| 77 | |||
| 78 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::CollisionRequest::*function_ptr) (const coal::CollisionResult &) const) | ||
| 79 | { | ||
| 80 | if (function_ptr == static_cast<bool (coal::CollisionRequest::*) (const coal::CollisionResult &) const>(&coal::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 (coal::CollisionRequest::*function_ptr) (const coal::CollisionRequest &) const) | ||
| 86 | { | ||
| 87 | if (function_ptr == static_cast<bool (coal::CollisionRequest::*) (const coal::CollisionRequest &) const>(&coal::CollisionRequest::operator==)) | ||
| 88 | return "whether two coal::CollisionRequest are the same or not "; | ||
| 89 | return ""; | ||
| 90 | } | ||
| 91 | |||
| 92 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::CollisionRequest::*function_ptr) (const coal::CollisionRequest &) const) | ||
| 93 | { | ||
| 94 | if (function_ptr == static_cast<bool (coal::CollisionRequest::*) (const coal::CollisionRequest &) const>(&coal::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 <coal/collision_data.h> | ||
| 100 | |||
| 101 | namespace doxygen { | ||
| 102 | |||
| 103 | template <> | ||
| 104 | struct class_doc_impl< coal::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 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if (strcmp(attrib, "distance_lower_bound") == 0) |
| 113 | 5 | return "Lower bound on distance between objects if they are disjoint. See Collision Note: Always computed. If CollisionRequest::distance_upper_bound is set to infinity, distance_lower_bound is the actual distance between the shapes. "; | |
| 114 | ✗ | if (strcmp(attrib, "normal") == 0) | |
| 115 | ✗ | return "normal associated to nearest_points. Same as CollisionResult::nearest_points but for the normal. "; | |
| 116 | ✗ | if (strcmp(attrib, "nearest_points") == 0) | |
| 117 | ✗ | return "nearest points. A coal::CollisionResult can have multiple contacts. The nearest points in CollisionResults correspond to the witness points associated with the smallest distance i.e the distance_lower_bound. For bounding volumes and BVHs, these nearest points are available only when distance_lower_bound is inferior to CollisionRequest::break_distance. "; | |
| 118 | (void)attrib; // turn off unused parameter warning. | ||
| 119 | ✗ | return ""; | |
| 120 | } | ||
| 121 | }; | ||
| 122 | |||
| 123 | template <> | ||
| 124 | struct constructor_0_impl< coal::CollisionResult > | ||
| 125 | { | ||
| 126 | 5 | static inline const char* doc () | |
| 127 | { | ||
| 128 | 5 | return ""; | |
| 129 | } | ||
| 130 | 5 | static inline boost::python::detail::keywords<0+1> args () | |
| 131 | { | ||
| 132 | 5 | return (boost::python::arg("self")); | |
| 133 | } | ||
| 134 | }; | ||
| 135 | |||
| 136 | inline const char* member_func_doc (void (coal::CollisionResult::*function_ptr) (const coal::Scalar &)) | ||
| 137 | { | ||
| 138 | if (function_ptr == static_cast<void (coal::CollisionResult::*) (const coal::Scalar &)>(&coal::CollisionResult::updateDistanceLowerBound)) | ||
| 139 | return "Update the lower bound only if the distance is inferior. "; | ||
| 140 | return ""; | ||
| 141 | } | ||
| 142 | |||
| 143 | inline boost::python::detail::keywords<2> member_func_args (void (coal::CollisionResult::*function_ptr) (const coal::Scalar &)) | ||
| 144 | { | ||
| 145 | if (function_ptr == static_cast<void (coal::CollisionResult::*) (const coal::Scalar &)>(&coal::CollisionResult::updateDistanceLowerBound)) | ||
| 146 | return (boost::python::arg("self"), boost::python::arg("distance_lower_bound_")); | ||
| 147 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 148 | } | ||
| 149 | |||
| 150 | inline const char* member_func_doc (void (coal::CollisionResult::*function_ptr) (const coal::Contact &)) | ||
| 151 | { | ||
| 152 | if (function_ptr == static_cast<void (coal::CollisionResult::*) (const coal::Contact &)>(&coal::CollisionResult::addContact)) | ||
| 153 | return "add one contact into result structure "; | ||
| 154 | return ""; | ||
| 155 | } | ||
| 156 | |||
| 157 | inline boost::python::detail::keywords<2> member_func_args (void (coal::CollisionResult::*function_ptr) (const coal::Contact &)) | ||
| 158 | { | ||
| 159 | if (function_ptr == static_cast<void (coal::CollisionResult::*) (const coal::Contact &)>(&coal::CollisionResult::addContact)) | ||
| 160 | return (boost::python::arg("self"), boost::python::arg("c")); | ||
| 161 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 162 | } | ||
| 163 | |||
| 164 | inline const char* member_func_doc (bool (coal::CollisionResult::*function_ptr) (const coal::CollisionResult &) const) | ||
| 165 | { | ||
| 166 | if (function_ptr == static_cast<bool (coal::CollisionResult::*) (const coal::CollisionResult &) const>(&coal::CollisionResult::operator==)) | ||
| 167 | return "whether two coal::CollisionResult are the same or not "; | ||
| 168 | return ""; | ||
| 169 | } | ||
| 170 | |||
| 171 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::CollisionResult::*function_ptr) (const coal::CollisionResult &) const) | ||
| 172 | { | ||
| 173 | if (function_ptr == static_cast<bool (coal::CollisionResult::*) (const coal::CollisionResult &) const>(&coal::CollisionResult::operator==)) | ||
| 174 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 175 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 176 | } | ||
| 177 | |||
| 178 | inline const char* member_func_doc (bool (coal::CollisionResult::*function_ptr) () const) | ||
| 179 | { | ||
| 180 | if (function_ptr == static_cast<bool (coal::CollisionResult::*) () const>(&coal::CollisionResult::isCollision)) | ||
| 181 | return "return binary collision result "; | ||
| 182 | return ""; | ||
| 183 | } | ||
| 184 | |||
| 185 | inline boost::python::detail::keywords<1> member_func_args (bool (coal::CollisionResult::*function_ptr) () const) | ||
| 186 | { | ||
| 187 | if (function_ptr == static_cast<bool (coal::CollisionResult::*) () const>(&coal::CollisionResult::isCollision)) | ||
| 188 | return (boost::python::arg("self")); | ||
| 189 | return (boost::python::arg("self")); | ||
| 190 | } | ||
| 191 | |||
| 192 | inline const char* member_func_doc (size_t (coal::CollisionResult::*function_ptr) () const) | ||
| 193 | { | ||
| 194 | if (function_ptr == static_cast<size_t (coal::CollisionResult::*) () const>(&coal::CollisionResult::numContacts)) | ||
| 195 | return "number of contacts found "; | ||
| 196 | return ""; | ||
| 197 | } | ||
| 198 | |||
| 199 | inline boost::python::detail::keywords<1> member_func_args (size_t (coal::CollisionResult::*function_ptr) () const) | ||
| 200 | { | ||
| 201 | if (function_ptr == static_cast<size_t (coal::CollisionResult::*) () const>(&coal::CollisionResult::numContacts)) | ||
| 202 | return (boost::python::arg("self")); | ||
| 203 | return (boost::python::arg("self")); | ||
| 204 | } | ||
| 205 | |||
| 206 | 5 | inline const char* member_func_doc (const coal::Contact & (coal::CollisionResult::*function_ptr) (size_t) const) | |
| 207 | { | ||
| 208 |
2/6✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
5 | if (function_ptr == static_cast<const coal::Contact & (coal::CollisionResult::*) (size_t) const>(&coal::CollisionResult::getContact)) |
| 209 | 5 | return "get the i-th contact calculated "; | |
| 210 | ✗ | return ""; | |
| 211 | } | ||
| 212 | |||
| 213 | inline boost::python::detail::keywords<2> member_func_args (const coal::Contact & (coal::CollisionResult::*function_ptr) (size_t) const) | ||
| 214 | { | ||
| 215 | if (function_ptr == static_cast<const coal::Contact & (coal::CollisionResult::*) (size_t) const>(&coal::CollisionResult::getContact)) | ||
| 216 | return (boost::python::arg("self"), boost::python::arg("i")); | ||
| 217 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 218 | } | ||
| 219 | |||
| 220 | inline const char* member_func_doc (void (coal::CollisionResult::*function_ptr) (size_t, const coal::Contact &)) | ||
| 221 | { | ||
| 222 | if (function_ptr == static_cast<void (coal::CollisionResult::*) (size_t, const coal::Contact &)>(&coal::CollisionResult::setContact)) | ||
| 223 | return "set the i-th contact calculated "; | ||
| 224 | return ""; | ||
| 225 | } | ||
| 226 | |||
| 227 | inline boost::python::detail::keywords<3> member_func_args (void (coal::CollisionResult::*function_ptr) (size_t, const coal::Contact &)) | ||
| 228 | { | ||
| 229 | if (function_ptr == static_cast<void (coal::CollisionResult::*) (size_t, const coal::Contact &)>(&coal::CollisionResult::setContact)) | ||
| 230 | return (boost::python::arg("self"), boost::python::arg("i"), boost::python::arg("c")); | ||
| 231 | return (boost::python::arg("self"), boost::python::arg("arg0"), boost::python::arg("arg1")); | ||
| 232 | } | ||
| 233 | |||
| 234 | inline const char* member_func_doc (void (coal::CollisionResult::*function_ptr) (std::vector< coal::Contact > &) const) | ||
| 235 | { | ||
| 236 | if (function_ptr == static_cast<void (coal::CollisionResult::*) (std::vector< coal::Contact > &) const>(&coal::CollisionResult::getContacts)) | ||
| 237 | return "get all the contacts "; | ||
| 238 | return ""; | ||
| 239 | } | ||
| 240 | |||
| 241 | inline boost::python::detail::keywords<2> member_func_args (void (coal::CollisionResult::*function_ptr) (std::vector< coal::Contact > &) const) | ||
| 242 | { | ||
| 243 | if (function_ptr == static_cast<void (coal::CollisionResult::*) (std::vector< coal::Contact > &) const>(&coal::CollisionResult::getContacts)) | ||
| 244 | return (boost::python::arg("self"), boost::python::arg("contacts_")); | ||
| 245 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 246 | } | ||
| 247 | |||
| 248 | 5 | inline const char* member_func_doc (const std::vector< coal::Contact > & (coal::CollisionResult::*function_ptr) () const) | |
| 249 | { | ||
| 250 |
2/6✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
5 | if (function_ptr == static_cast<const std::vector< coal::Contact > & (coal::CollisionResult::*) () const>(&coal::CollisionResult::getContacts)) |
| 251 | 5 | return ""; | |
| 252 | ✗ | return ""; | |
| 253 | } | ||
| 254 | |||
| 255 | inline boost::python::detail::keywords<1> member_func_args (const std::vector< coal::Contact > & (coal::CollisionResult::*function_ptr) () const) | ||
| 256 | { | ||
| 257 | if (function_ptr == static_cast<const std::vector< coal::Contact > & (coal::CollisionResult::*) () const>(&coal::CollisionResult::getContacts)) | ||
| 258 | return (boost::python::arg("self")); | ||
| 259 | return (boost::python::arg("self")); | ||
| 260 | } | ||
| 261 | |||
| 262 | inline const char* member_func_doc (void (coal::CollisionResult::*function_ptr) ()) | ||
| 263 | { | ||
| 264 | if (function_ptr == static_cast<void (coal::CollisionResult::*) ()>(&coal::CollisionResult::clear)) | ||
| 265 | return "clear the results obtained "; | ||
| 266 | if (function_ptr == static_cast<void (coal::CollisionResult::*) ()>(&coal::CollisionResult::swapObjects)) | ||
| 267 | return "reposition coal::Contact objects when fcl inverts them during their construction. "; | ||
| 268 | return ""; | ||
| 269 | } | ||
| 270 | |||
| 271 | inline boost::python::detail::keywords<1> member_func_args (void (coal::CollisionResult::*function_ptr) ()) | ||
| 272 | { | ||
| 273 | if (function_ptr == static_cast<void (coal::CollisionResult::*) ()>(&coal::CollisionResult::clear)) | ||
| 274 | return (boost::python::arg("self")); | ||
| 275 | if (function_ptr == static_cast<void (coal::CollisionResult::*) ()>(&coal::CollisionResult::swapObjects)) | ||
| 276 | return (boost::python::arg("self")); | ||
| 277 | return (boost::python::arg("self")); | ||
| 278 | } | ||
| 279 | } // namespace doxygen | ||
| 280 | #include <coal/collision_data.h> | ||
| 281 | |||
| 282 | namespace doxygen { | ||
| 283 | |||
| 284 | template <> | ||
| 285 | struct class_doc_impl< coal::Contact > | ||
| 286 | { | ||
| 287 | 5 | static inline const char* run () | |
| 288 | { | ||
| 289 | 5 | return "coal::Contact information returned by collision. "; | |
| 290 | } | ||
| 291 | 50 | static inline const char* attribute (const char* attrib) | |
| 292 | { | ||
| 293 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 45 times.
|
50 | if (strcmp(attrib, "o1") == 0) |
| 294 | 5 | return "collision object 1 "; | |
| 295 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 40 times.
|
45 | if (strcmp(attrib, "o2") == 0) |
| 296 | 5 | return "collision object 2 "; | |
| 297 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 35 times.
|
40 | if (strcmp(attrib, "b1") == 0) |
| 298 | 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 "; | |
| 299 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 30 times.
|
35 | if (strcmp(attrib, "b2") == 0) |
| 300 | 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 "; | |
| 301 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 25 times.
|
30 | if (strcmp(attrib, "normal") == 0) |
| 302 | return "contact normal, pointing from o1 to o2. The normal defined as the normalized separation vector: normal = (p2 - p1) / dist(o1, o2), where p1 = nearest_points[0] belongs to o1 and p2 = nearest_points[1] belongs to o2 and dist(o1, o2) is the signed distance between o1 and o2. The normal always points from o1 to o2. \n" | ||
| 303 | "\n" | ||
| 304 | 5 | "Note: The separation vector is the smallest vector such that if o1 is translated by it, o1 and o2 are in touching contact (they share at least one contact point but have a zero intersection volume). If the shapes overlap, dist(o1, o2) = -((p2-p1).norm()). Otherwise, dist(o1, o2) = (p2-p1).norm(). "; | |
| 305 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 10 times.
|
25 | if (strcmp(attrib, "nearest_points") == 0) |
| 306 | return "nearest points associated to this contact. \n" | ||
| 307 | "\n" | ||
| 308 | 15 | "Note: Also referred as \"witness points\" in other collision libraries. The points p1 = nearest_points[0] and p2 = nearest_points[1] verify the property that dist(o1, o2) * (p1 - p2) is the separation vector between o1 and o2, with dist(o1, o2) being the signed distance separating o1 from o2. See DistanceResult::normal for the definition of the separation vector. If o1 and o2 have multiple contacts, the nearest_points are associated with the contact which has the greatest penetration depth. TODO (louis): rename nearest_points to witness_points. "; | |
| 309 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
|
10 | if (strcmp(attrib, "pos") == 0) |
| 310 | 5 | return "contact position, in world space "; | |
| 311 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if (strcmp(attrib, "penetration_depth") == 0) |
| 312 | 5 | return "penetration depth "; | |
| 313 | ✗ | if (strcmp(attrib, "NONE") == 0) | |
| 314 | ✗ | return "invalid contact primitive information "; | |
| 315 | (void)attrib; // turn off unused parameter warning. | ||
| 316 | ✗ | return ""; | |
| 317 | } | ||
| 318 | }; | ||
| 319 | |||
| 320 | template <> | ||
| 321 | struct constructor_0_impl< coal::Contact > | ||
| 322 | { | ||
| 323 | static inline const char* doc () | ||
| 324 | { | ||
| 325 | return "Default constructor. "; | ||
| 326 | } | ||
| 327 | static inline boost::python::detail::keywords<0+1> args () | ||
| 328 | { | ||
| 329 | return (boost::python::arg("self")); | ||
| 330 | } | ||
| 331 | }; | ||
| 332 | |||
| 333 | template <> | ||
| 334 | struct constructor_4_impl< coal::Contact, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int > | ||
| 335 | { | ||
| 336 | 5 | static inline const char* doc () | |
| 337 | { | ||
| 338 | 5 | return ""; | |
| 339 | } | ||
| 340 | 5 | static inline boost::python::detail::keywords<4+1> args () | |
| 341 | { | ||
| 342 |
8/16✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 5 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 5 times.
✗ Branch 9 not taken.
✓ Branch 11 taken 5 times.
✗ Branch 12 not taken.
✓ Branch 14 taken 5 times.
✗ Branch 15 not taken.
✓ Branch 17 taken 5 times.
✗ Branch 18 not taken.
✓ Branch 20 taken 5 times.
✗ Branch 21 not taken.
✓ Branch 23 taken 5 times.
✗ Branch 24 not taken.
|
10 | return (boost::python::arg("self"), boost::python::arg("o1_"), boost::python::arg("o2_"), boost::python::arg("b1_"), boost::python::arg("b2_")); |
| 343 | } | ||
| 344 | }; | ||
| 345 | |||
| 346 | template <> | ||
| 347 | struct constructor_7_impl< coal::Contact, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int, const coal::Vec3s &, const coal::Vec3s &, coal::Scalar > | ||
| 348 | { | ||
| 349 | 5 | static inline const char* doc () | |
| 350 | { | ||
| 351 | 5 | return ""; | |
| 352 | } | ||
| 353 | 5 | static inline boost::python::detail::keywords<7+1> args () | |
| 354 | { | ||
| 355 |
14/28✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
✓ Branch 5 taken 5 times.
✗ Branch 6 not taken.
✓ Branch 8 taken 5 times.
✗ Branch 9 not taken.
✓ Branch 11 taken 5 times.
✗ Branch 12 not taken.
✓ Branch 14 taken 5 times.
✗ Branch 15 not taken.
✓ Branch 17 taken 5 times.
✗ Branch 18 not taken.
✓ Branch 20 taken 5 times.
✗ Branch 21 not taken.
✓ Branch 23 taken 5 times.
✗ Branch 24 not taken.
✓ Branch 26 taken 5 times.
✗ Branch 27 not taken.
✓ Branch 29 taken 5 times.
✗ Branch 30 not taken.
✓ Branch 32 taken 5 times.
✗ Branch 33 not taken.
✓ Branch 35 taken 5 times.
✗ Branch 36 not taken.
✓ Branch 38 taken 5 times.
✗ Branch 39 not taken.
✓ Branch 41 taken 5 times.
✗ Branch 42 not taken.
|
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_")); |
| 356 | } | ||
| 357 | }; | ||
| 358 | |||
| 359 | template <> | ||
| 360 | struct constructor_8_impl< coal::Contact, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int, const coal::Vec3s &, const coal::Vec3s &, const coal::Vec3s &, coal::Scalar > | ||
| 361 | { | ||
| 362 | static inline const char* doc () | ||
| 363 | { | ||
| 364 | return ""; | ||
| 365 | } | ||
| 366 | static inline boost::python::detail::keywords<8+1> args () | ||
| 367 | { | ||
| 368 | return (boost::python::arg("self"), 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_"), boost::python::arg("depth_")); | ||
| 369 | } | ||
| 370 | }; | ||
| 371 | |||
| 372 | inline const char* member_func_doc (bool (coal::Contact::*function_ptr) (const coal::Contact &) const) | ||
| 373 | { | ||
| 374 | if (function_ptr == static_cast<bool (coal::Contact::*) (const coal::Contact &) const>(&coal::Contact::operator<)) | ||
| 375 | return ""; | ||
| 376 | if (function_ptr == static_cast<bool (coal::Contact::*) (const coal::Contact &) const>(&coal::Contact::operator==)) | ||
| 377 | return ""; | ||
| 378 | if (function_ptr == static_cast<bool (coal::Contact::*) (const coal::Contact &) const>(&coal::Contact::operator!=)) | ||
| 379 | return ""; | ||
| 380 | return ""; | ||
| 381 | } | ||
| 382 | |||
| 383 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::Contact::*function_ptr) (const coal::Contact &) const) | ||
| 384 | { | ||
| 385 | if (function_ptr == static_cast<bool (coal::Contact::*) (const coal::Contact &) const>(&coal::Contact::operator<)) | ||
| 386 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 387 | if (function_ptr == static_cast<bool (coal::Contact::*) (const coal::Contact &) const>(&coal::Contact::operator==)) | ||
| 388 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 389 | if (function_ptr == static_cast<bool (coal::Contact::*) (const coal::Contact &) const>(&coal::Contact::operator!=)) | ||
| 390 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 391 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 392 | } | ||
| 393 | |||
| 394 | inline const char* member_func_doc ( coal::Scalar (coal::Contact::*function_ptr) (const coal::CollisionRequest &) const) | ||
| 395 | { | ||
| 396 | if (function_ptr == static_cast< coal::Scalar (coal::Contact::*) (const coal::CollisionRequest &) const>(&coal::Contact::getDistanceToCollision)) | ||
| 397 | return ""; | ||
| 398 | return ""; | ||
| 399 | } | ||
| 400 | |||
| 401 | inline boost::python::detail::keywords<2> member_func_args ( coal::Scalar (coal::Contact::*function_ptr) (const coal::CollisionRequest &) const) | ||
| 402 | { | ||
| 403 | if (function_ptr == static_cast< coal::Scalar (coal::Contact::*) (const coal::CollisionRequest &) const>(&coal::Contact::getDistanceToCollision)) | ||
| 404 | return (boost::python::arg("self"), boost::python::arg("request")); | ||
| 405 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 406 | } | ||
| 407 | } // namespace doxygen | ||
| 408 | #include <coal/collision_data.h> | ||
| 409 | |||
| 410 | namespace doxygen { | ||
| 411 | |||
| 412 | template <> | ||
| 413 | struct class_doc_impl< coal::ContactPatch > | ||
| 414 | { | ||
| 415 | 5 | static inline const char* run () | |
| 416 | { | ||
| 417 | return "This structure allows to encode contact patches. A contact patch is defined by a set of points belonging to a subset of a plane passing by p and supported by n, where n =Contact::normal and p =Contact::pos. If we denote by P this plane and by S1 and S2 the first and second shape of a collision pair, a contact patch is represented as a polytope which vertices all belong to P & S1 & S2, where & denotes the set-intersection. Since a contact patch is a subset of a plane supported by n, it has a preferred direction. In Coal, the Contact::normal points from S1 to S2. In the same way, a contact patch points by default from S1 to S2. \n" | ||
| 418 | "\n" | ||
| 419 | "Note: For now (April 2024), a coal::ContactPatch is a polygon (2D polytope), so the points of the set, forming the convex-hull of the polytope, are stored in a counter-clockwise fashion. \n" | ||
| 420 | "\n" | ||
| 421 | 5 | "Note: If needed, the internal algorithms of Coal can easily be extended to compute a contact volume instead of a contact patch. "; | |
| 422 | } | ||
| 423 | 15 | static inline const char* attribute (const char* attrib) | |
| 424 | { | ||
| 425 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 10 times.
|
15 | if (strcmp(attrib, "tf") == 0) |
| 426 | 5 | return "Frame of the set, expressed in the world coordinates. The z-axis of the frame's rotation is the contact patch normal. "; | |
| 427 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
|
10 | if (strcmp(attrib, "direction") == 0) |
| 428 | 5 | return "Direction of this contact patch. "; | |
| 429 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if (strcmp(attrib, "penetration_depth") == 0) |
| 430 | return "Penetration depth of the contact patch. This value corresponds to the signed distance d between the shapes. \n" | ||
| 431 | "\n" | ||
| 432 | "Note: For each contact point p in the patch of normal n, p1 = p - 0.5*d*n and p2 = p + 0.5*d*n define a pair of witness points. p1 belongs to the surface of the first shape and p2 belongs to the surface of the second shape. For any pair of witness points, we always have p2 - p1 = d * n. The vector d * n is called a minimum separation vector: if S1 is translated by it, S1 and S2 are not in collision anymore. \n" | ||
| 433 | "\n" | ||
| 434 | 5 | "Note: Although there may exist multiple minimum separation vectors between two shapes, the term \"minimum\" comes from the fact that it's impossible to find a different separation vector which has a smaller norm than d * n. "; | |
| 435 | ✗ | if (strcmp(attrib, "default_preallocated_size") == 0) | |
| 436 | ✗ | return "Default maximum size of the polygon representing the contact patch. Used to pre-allocate memory for the patch. "; | |
| 437 | (void)attrib; // turn off unused parameter warning. | ||
| 438 | ✗ | return ""; | |
| 439 | } | ||
| 440 | }; | ||
| 441 | |||
| 442 | template <> | ||
| 443 | struct constructor_1_impl< coal::ContactPatch, size_t > | ||
| 444 | { | ||
| 445 | static inline const char* doc () | ||
| 446 | { | ||
| 447 | return "Default constructor. Note: the preallocated size does not determine the maximum number of points in the patch, it only serves as preallocation if the maximum size of the patch is known in advance. Coal will automatically expand/shrink the contact patch if needed. "; | ||
| 448 | } | ||
| 449 | static inline boost::python::detail::keywords<1+1> args () | ||
| 450 | { | ||
| 451 | return (boost::python::arg("self"), boost::python::arg("preallocated_size")); | ||
| 452 | } | ||
| 453 | }; | ||
| 454 | |||
| 455 | inline const char* member_func_doc ( coal::Vec3s (coal::ContactPatch::*function_ptr) () const) | ||
| 456 | { | ||
| 457 | if (function_ptr == static_cast< coal::Vec3s (coal::ContactPatch::*) () const>(&coal::ContactPatch::getNormal)) | ||
| 458 | return "Normal of the contact patch, expressed in the WORLD frame. "; | ||
| 459 | return ""; | ||
| 460 | } | ||
| 461 | |||
| 462 | inline boost::python::detail::keywords<1> member_func_args ( coal::Vec3s (coal::ContactPatch::*function_ptr) () const) | ||
| 463 | { | ||
| 464 | if (function_ptr == static_cast< coal::Vec3s (coal::ContactPatch::*) () const>(&coal::ContactPatch::getNormal)) | ||
| 465 | return (boost::python::arg("self")); | ||
| 466 | return (boost::python::arg("self")); | ||
| 467 | } | ||
| 468 | |||
| 469 | inline const char* member_func_doc (size_t (coal::ContactPatch::*function_ptr) () const) | ||
| 470 | { | ||
| 471 | if (function_ptr == static_cast<size_t (coal::ContactPatch::*) () const>(&coal::ContactPatch::size)) | ||
| 472 | return "Returns the number of points in the contact patch. "; | ||
| 473 | return ""; | ||
| 474 | } | ||
| 475 | |||
| 476 | inline boost::python::detail::keywords<1> member_func_args (size_t (coal::ContactPatch::*function_ptr) () const) | ||
| 477 | { | ||
| 478 | if (function_ptr == static_cast<size_t (coal::ContactPatch::*) () const>(&coal::ContactPatch::size)) | ||
| 479 | return (boost::python::arg("self")); | ||
| 480 | return (boost::python::arg("self")); | ||
| 481 | } | ||
| 482 | |||
| 483 | inline const char* member_func_doc (void (coal::ContactPatch::*function_ptr) (const coal::Vec3s &)) | ||
| 484 | { | ||
| 485 | if (function_ptr == static_cast<void (coal::ContactPatch::*) (const coal::Vec3s &)>(&coal::ContactPatch::addPoint)) | ||
| 486 | return "Add a 3D point to the set, expressed in the world frame. \n" | ||
| 487 | "\n" | ||
| 488 | "Note: This function takes a 3D point and expresses it in the local frame of the set. It then takes only the x and y components of the vector, effectively doing a projection onto the plane to which the set belongs. TODO(louis): if necessary, we can store the offset to the plane (x, y). "; | ||
| 489 | return ""; | ||
| 490 | } | ||
| 491 | |||
| 492 | inline boost::python::detail::keywords<2> member_func_args (void (coal::ContactPatch::*function_ptr) (const coal::Vec3s &)) | ||
| 493 | { | ||
| 494 | if (function_ptr == static_cast<void (coal::ContactPatch::*) (const coal::Vec3s &)>(&coal::ContactPatch::addPoint)) | ||
| 495 | return (boost::python::arg("self"), boost::python::arg("point_3d")); | ||
| 496 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 497 | } | ||
| 498 | |||
| 499 | inline const char* member_func_doc ( coal::Vec3s (coal::ContactPatch::*function_ptr) (const size_t) const) | ||
| 500 | { | ||
| 501 | if (function_ptr == static_cast< coal::Vec3s (coal::ContactPatch::*) (const size_t) const>(&coal::ContactPatch::getPoint)) | ||
| 502 | return "Get the i-th point of the set, expressed in the 3D world frame. "; | ||
| 503 | if (function_ptr == static_cast< coal::Vec3s (coal::ContactPatch::*) (const size_t) const>(&coal::ContactPatch::getPointShape1)) | ||
| 504 | return "Get the i-th point of the contact patch, projected back onto the first shape of the collision pair. This point is expressed in the 3D world frame. "; | ||
| 505 | if (function_ptr == static_cast< coal::Vec3s (coal::ContactPatch::*) (const size_t) const>(&coal::ContactPatch::getPointShape2)) | ||
| 506 | return "Get the i-th point of the contact patch, projected back onto the first shape of the collision pair. This 3D point is expressed in the world frame. "; | ||
| 507 | return ""; | ||
| 508 | } | ||
| 509 | |||
| 510 | inline boost::python::detail::keywords<2> member_func_args ( coal::Vec3s (coal::ContactPatch::*function_ptr) (const size_t) const) | ||
| 511 | { | ||
| 512 | if (function_ptr == static_cast< coal::Vec3s (coal::ContactPatch::*) (const size_t) const>(&coal::ContactPatch::getPoint)) | ||
| 513 | return (boost::python::arg("self"), boost::python::arg("i")); | ||
| 514 | if (function_ptr == static_cast< coal::Vec3s (coal::ContactPatch::*) (const size_t) const>(&coal::ContactPatch::getPointShape1)) | ||
| 515 | return (boost::python::arg("self"), boost::python::arg("i")); | ||
| 516 | if (function_ptr == static_cast< coal::Vec3s (coal::ContactPatch::*) (const size_t) const>(&coal::ContactPatch::getPointShape2)) | ||
| 517 | return (boost::python::arg("self"), boost::python::arg("i")); | ||
| 518 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 519 | } | ||
| 520 | |||
| 521 | inline const char* member_func_doc ( coal::ContactPatch::Polygon & (coal::ContactPatch::*function_ptr) ()) | ||
| 522 | { | ||
| 523 | if (function_ptr == static_cast< coal::ContactPatch::Polygon & (coal::ContactPatch::*) ()>(&coal::ContactPatch::points)) | ||
| 524 | return "Getter for the 2D points in the set. "; | ||
| 525 | return ""; | ||
| 526 | } | ||
| 527 | |||
| 528 | inline boost::python::detail::keywords<1> member_func_args ( coal::ContactPatch::Polygon & (coal::ContactPatch::*function_ptr) ()) | ||
| 529 | { | ||
| 530 | if (function_ptr == static_cast< coal::ContactPatch::Polygon & (coal::ContactPatch::*) ()>(&coal::ContactPatch::points)) | ||
| 531 | return (boost::python::arg("self")); | ||
| 532 | return (boost::python::arg("self")); | ||
| 533 | } | ||
| 534 | |||
| 535 | inline const char* member_func_doc (const coal::ContactPatch::Polygon & (coal::ContactPatch::*function_ptr) () const) | ||
| 536 | { | ||
| 537 | if (function_ptr == static_cast<const coal::ContactPatch::Polygon & (coal::ContactPatch::*) () const>(&coal::ContactPatch::points)) | ||
| 538 | return "Const getter for the 2D points in the set. "; | ||
| 539 | return ""; | ||
| 540 | } | ||
| 541 | |||
| 542 | inline boost::python::detail::keywords<1> member_func_args (const coal::ContactPatch::Polygon & (coal::ContactPatch::*function_ptr) () const) | ||
| 543 | { | ||
| 544 | if (function_ptr == static_cast<const coal::ContactPatch::Polygon & (coal::ContactPatch::*) () const>(&coal::ContactPatch::points)) | ||
| 545 | return (boost::python::arg("self")); | ||
| 546 | return (boost::python::arg("self")); | ||
| 547 | } | ||
| 548 | |||
| 549 | inline const char* member_func_doc ( coal::Vec2s & (coal::ContactPatch::*function_ptr) (const size_t)) | ||
| 550 | { | ||
| 551 | if (function_ptr == static_cast< coal::Vec2s & (coal::ContactPatch::*) (const size_t)>(&coal::ContactPatch::point)) | ||
| 552 | return "Getter for the i-th 2D point in the set. "; | ||
| 553 | return ""; | ||
| 554 | } | ||
| 555 | |||
| 556 | inline boost::python::detail::keywords<2> member_func_args ( coal::Vec2s & (coal::ContactPatch::*function_ptr) (const size_t)) | ||
| 557 | { | ||
| 558 | if (function_ptr == static_cast< coal::Vec2s & (coal::ContactPatch::*) (const size_t)>(&coal::ContactPatch::point)) | ||
| 559 | return (boost::python::arg("self"), boost::python::arg("i")); | ||
| 560 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 561 | } | ||
| 562 | |||
| 563 | inline const char* member_func_doc (const coal::Vec2s & (coal::ContactPatch::*function_ptr) (const size_t) const) | ||
| 564 | { | ||
| 565 | if (function_ptr == static_cast<const coal::Vec2s & (coal::ContactPatch::*) (const size_t) const>(&coal::ContactPatch::point)) | ||
| 566 | return "Const getter for the i-th 2D point in the set. "; | ||
| 567 | return ""; | ||
| 568 | } | ||
| 569 | |||
| 570 | inline boost::python::detail::keywords<2> member_func_args (const coal::Vec2s & (coal::ContactPatch::*function_ptr) (const size_t) const) | ||
| 571 | { | ||
| 572 | if (function_ptr == static_cast<const coal::Vec2s & (coal::ContactPatch::*) (const size_t) const>(&coal::ContactPatch::point)) | ||
| 573 | return (boost::python::arg("self"), boost::python::arg("i")); | ||
| 574 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 575 | } | ||
| 576 | |||
| 577 | inline const char* member_func_doc (void (coal::ContactPatch::*function_ptr) ()) | ||
| 578 | { | ||
| 579 | if (function_ptr == static_cast<void (coal::ContactPatch::*) ()>(&coal::ContactPatch::clear)) | ||
| 580 | return "Clear the set. "; | ||
| 581 | return ""; | ||
| 582 | } | ||
| 583 | |||
| 584 | inline boost::python::detail::keywords<1> member_func_args (void (coal::ContactPatch::*function_ptr) ()) | ||
| 585 | { | ||
| 586 | if (function_ptr == static_cast<void (coal::ContactPatch::*) ()>(&coal::ContactPatch::clear)) | ||
| 587 | return (boost::python::arg("self")); | ||
| 588 | return (boost::python::arg("self")); | ||
| 589 | } | ||
| 590 | |||
| 591 | inline const char* member_func_doc (bool (coal::ContactPatch::*function_ptr) (const coal::ContactPatch &) const) | ||
| 592 | { | ||
| 593 | if (function_ptr == static_cast<bool (coal::ContactPatch::*) (const coal::ContactPatch &) const>(&coal::ContactPatch::operator==)) | ||
| 594 | return "Whether two contact patches are the same or not. \n" | ||
| 595 | "\n" | ||
| 596 | "Note: This compares the two sets terms by terms. However, two contact patches can be identical, but have a different order for their points. Use isEqual in this case. "; | ||
| 597 | return ""; | ||
| 598 | } | ||
| 599 | |||
| 600 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::ContactPatch::*function_ptr) (const coal::ContactPatch &) const) | ||
| 601 | { | ||
| 602 | if (function_ptr == static_cast<bool (coal::ContactPatch::*) (const coal::ContactPatch &) const>(&coal::ContactPatch::operator==)) | ||
| 603 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 604 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 605 | } | ||
| 606 | |||
| 607 | inline const char* member_func_doc (bool (coal::ContactPatch::*function_ptr) (const coal::ContactPatch &, const coal::Scalar) const) | ||
| 608 | { | ||
| 609 | if (function_ptr == static_cast<bool (coal::ContactPatch::*) (const coal::ContactPatch &, const coal::Scalar) const>(&coal::ContactPatch::isSame)) | ||
| 610 | return "Whether two contact patches are the same or not. Checks for different order of the points. "; | ||
| 611 | return ""; | ||
| 612 | } | ||
| 613 | |||
| 614 | inline boost::python::detail::keywords<3> member_func_args (bool (coal::ContactPatch::*function_ptr) (const coal::ContactPatch &, const coal::Scalar) const) | ||
| 615 | { | ||
| 616 | if (function_ptr == static_cast<bool (coal::ContactPatch::*) (const coal::ContactPatch &, const coal::Scalar) const>(&coal::ContactPatch::isSame)) | ||
| 617 | return (boost::python::arg("self"), boost::python::arg("other"), boost::python::arg("tol")); | ||
| 618 | return (boost::python::arg("self"), boost::python::arg("arg0"), boost::python::arg("arg1")); | ||
| 619 | } | ||
| 620 | } // namespace doxygen | ||
| 621 | #include <coal/collision_data.h> | ||
| 622 | |||
| 623 | namespace doxygen { | ||
| 624 | |||
| 625 | template <> | ||
| 626 | struct class_doc_impl< coal::ContactPatchRequest > | ||
| 627 | { | ||
| 628 | 5 | static inline const char* run () | |
| 629 | { | ||
| 630 | 5 | return "Request for a contact patch computation. "; | |
| 631 | } | ||
| 632 | 5 | static inline const char* attribute (const char* attrib) | |
| 633 | { | ||
| 634 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if (strcmp(attrib, "max_num_patch") == 0) |
| 635 | 5 | return "Maximum number of contact patches that will be computed. "; | |
| 636 | (void)attrib; // turn off unused parameter warning. | ||
| 637 | ✗ | return ""; | |
| 638 | } | ||
| 639 | }; | ||
| 640 | |||
| 641 | template <> | ||
| 642 | struct constructor_3_impl< coal::ContactPatchRequest, size_t, size_t, coal::Scalar > | ||
| 643 | { | ||
| 644 | static inline const char* doc () | ||
| 645 | { | ||
| 646 | return "Default constructor. \n" | ||
| 647 | "\n" | ||
| 648 | "\n" | ||
| 649 | "Param\n" | ||
| 650 | " - max_num_patch maximum number of contact patches per collision pair. \n" | ||
| 651 | " - max_sub_patch_size maximum size of each sub contact patch. Each contact patch contains an internal representation for an inscribed sub contact patch. This allows physics simulation to always work with a predetermined maximum size for each contact patch. A sub contact patch is simply a subset of the vertices of a contact patch. \n" | ||
| 652 | " - num_samples_curved_shapes for shapes like cones and cylinders, which have smooth basis (circles in this case), we need to sample a certain amount of point of this basis. \n" | ||
| 653 | " - patch_tolerance the tolerance below which a point of a shape is considered to belong to the support set of this shape in the direction of the normal. Said otherwise, patch_tolerance determines the \"thickness\" of the separating plane between shapes of a collision pair. "; | ||
| 654 | } | ||
| 655 | static inline boost::python::detail::keywords<3+1> args () | ||
| 656 | { | ||
| 657 | return (boost::python::arg("self"), boost::python::arg("max_num_patch"), boost::python::arg("num_samples_curved_shapes"), boost::python::arg("patch_tolerance")); | ||
| 658 | } | ||
| 659 | }; | ||
| 660 | |||
| 661 | template <> | ||
| 662 | struct constructor_3_impl< coal::ContactPatchRequest, const coal::CollisionRequest &, size_t, coal::Scalar > | ||
| 663 | { | ||
| 664 | static inline const char* doc () | ||
| 665 | { | ||
| 666 | return "Construct a contact patch request from a collision request. "; | ||
| 667 | } | ||
| 668 | static inline boost::python::detail::keywords<3+1> args () | ||
| 669 | { | ||
| 670 | return (boost::python::arg("self"), boost::python::arg("collision_request"), boost::python::arg("num_samples_curved_shapes"), boost::python::arg("patch_tolerance")); | ||
| 671 | } | ||
| 672 | }; | ||
| 673 | |||
| 674 | inline const char* member_func_doc (void (coal::ContactPatchRequest::*function_ptr) (const size_t)) | ||
| 675 | { | ||
| 676 | if (function_ptr == static_cast<void (coal::ContactPatchRequest::*) (const size_t)>(&coal::ContactPatchRequest::setNumSamplesCurvedShapes)) | ||
| 677 | return "Maximum samples to compute the support sets of curved shapes, i.e. when the normal is perpendicular to the base of a cylinder. For now, only relevant for coal::Cone and coal::Cylinder. In the future this might be extended to coal::Sphere and coal::Ellipsoid. "; | ||
| 678 | return ""; | ||
| 679 | } | ||
| 680 | |||
| 681 | inline boost::python::detail::keywords<2> member_func_args (void (coal::ContactPatchRequest::*function_ptr) (const size_t)) | ||
| 682 | { | ||
| 683 | if (function_ptr == static_cast<void (coal::ContactPatchRequest::*) (const size_t)>(&coal::ContactPatchRequest::setNumSamplesCurvedShapes)) | ||
| 684 | return (boost::python::arg("self"), boost::python::arg("num_samples_curved_shapes")); | ||
| 685 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 686 | } | ||
| 687 | |||
| 688 | inline const char* member_func_doc (size_t (coal::ContactPatchRequest::*function_ptr) () const) | ||
| 689 | { | ||
| 690 | if (function_ptr == static_cast<size_t (coal::ContactPatchRequest::*) () const>(&coal::ContactPatchRequest::getNumSamplesCurvedShapes)) | ||
| 691 | return "Maximum samples to compute the support sets of curved shapes, i.e. when the normal is perpendicular to the base of a cylinder. For now, only relevant for coal::Cone and coal::Cylinder. In the future this might be extended to coal::Sphere and coal::Ellipsoid. "; | ||
| 692 | return ""; | ||
| 693 | } | ||
| 694 | |||
| 695 | inline boost::python::detail::keywords<1> member_func_args (size_t (coal::ContactPatchRequest::*function_ptr) () const) | ||
| 696 | { | ||
| 697 | if (function_ptr == static_cast<size_t (coal::ContactPatchRequest::*) () const>(&coal::ContactPatchRequest::getNumSamplesCurvedShapes)) | ||
| 698 | return (boost::python::arg("self")); | ||
| 699 | return (boost::python::arg("self")); | ||
| 700 | } | ||
| 701 | |||
| 702 | inline const char* member_func_doc (void (coal::ContactPatchRequest::*function_ptr) (const coal::Scalar)) | ||
| 703 | { | ||
| 704 | if (function_ptr == static_cast<void (coal::ContactPatchRequest::*) (const coal::Scalar)>(&coal::ContactPatchRequest::setPatchTolerance)) | ||
| 705 | return "Tolerance below which points are added to a contact patch. In details, given two shapes S1 and S2, a contact patch is the triple intersection between the separating plane (P) (passing by Contact::pos and supported by Contact::normal), S1 and S2; i.e. a contact patch is P & S1 & S2 if we denote & the set intersection operator. If a point p1 of S1 is at a distance below patch_tolerance from the separating plane, it is taken into account in the computation of the contact patch. Otherwise, it is not used for the computation. \n" | ||
| 706 | "\n" | ||
| 707 | "Note: Needs to be positive. "; | ||
| 708 | return ""; | ||
| 709 | } | ||
| 710 | |||
| 711 | inline boost::python::detail::keywords<2> member_func_args (void (coal::ContactPatchRequest::*function_ptr) (const coal::Scalar)) | ||
| 712 | { | ||
| 713 | if (function_ptr == static_cast<void (coal::ContactPatchRequest::*) (const coal::Scalar)>(&coal::ContactPatchRequest::setPatchTolerance)) | ||
| 714 | return (boost::python::arg("self"), boost::python::arg("patch_tolerance")); | ||
| 715 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 716 | } | ||
| 717 | |||
| 718 | inline const char* member_func_doc ( coal::Scalar (coal::ContactPatchRequest::*function_ptr) () const) | ||
| 719 | { | ||
| 720 | if (function_ptr == static_cast< coal::Scalar (coal::ContactPatchRequest::*) () const>(&coal::ContactPatchRequest::getPatchTolerance)) | ||
| 721 | return "Tolerance below which points are added to a contact patch. In details, given two shapes S1 and S2, a contact patch is the triple intersection between the separating plane (P) (passing by Contact::pos and supported by Contact::normal), S1 and S2; i.e. a contact patch is P & S1 & S2 if we denote & the set intersection operator. If a point p1 of S1 is at a distance below patch_tolerance from the separating plane, it is taken into account in the computation of the contact patch. Otherwise, it is not used for the computation. \n" | ||
| 722 | "\n" | ||
| 723 | "Note: Needs to be positive. "; | ||
| 724 | return ""; | ||
| 725 | } | ||
| 726 | |||
| 727 | inline boost::python::detail::keywords<1> member_func_args ( coal::Scalar (coal::ContactPatchRequest::*function_ptr) () const) | ||
| 728 | { | ||
| 729 | if (function_ptr == static_cast< coal::Scalar (coal::ContactPatchRequest::*) () const>(&coal::ContactPatchRequest::getPatchTolerance)) | ||
| 730 | return (boost::python::arg("self")); | ||
| 731 | return (boost::python::arg("self")); | ||
| 732 | } | ||
| 733 | |||
| 734 | inline const char* member_func_doc (bool (coal::ContactPatchRequest::*function_ptr) (const coal::ContactPatchRequest &) const) | ||
| 735 | { | ||
| 736 | if (function_ptr == static_cast<bool (coal::ContactPatchRequest::*) (const coal::ContactPatchRequest &) const>(&coal::ContactPatchRequest::operator==)) | ||
| 737 | return "Whether two coal::ContactPatchRequest are identical or not. "; | ||
| 738 | return ""; | ||
| 739 | } | ||
| 740 | |||
| 741 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::ContactPatchRequest::*function_ptr) (const coal::ContactPatchRequest &) const) | ||
| 742 | { | ||
| 743 | if (function_ptr == static_cast<bool (coal::ContactPatchRequest::*) (const coal::ContactPatchRequest &) const>(&coal::ContactPatchRequest::operator==)) | ||
| 744 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 745 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 746 | } | ||
| 747 | } // namespace doxygen | ||
| 748 | #include <coal/collision_data.h> | ||
| 749 | |||
| 750 | namespace doxygen { | ||
| 751 | |||
| 752 | template <> | ||
| 753 | struct class_doc_impl< coal::ContactPatchResult > | ||
| 754 | { | ||
| 755 | 5 | static inline const char* run () | |
| 756 | { | ||
| 757 | 5 | return "Result for a contact patch computation. "; | |
| 758 | } | ||
| 759 | static inline const char* attribute (const char* attrib) | ||
| 760 | { | ||
| 761 | (void)attrib; // turn off unused parameter warning. | ||
| 762 | return ""; | ||
| 763 | } | ||
| 764 | }; | ||
| 765 | |||
| 766 | template <> | ||
| 767 | struct constructor_0_impl< coal::ContactPatchResult > | ||
| 768 | { | ||
| 769 | static inline const char* doc () | ||
| 770 | { | ||
| 771 | return "Default constructor. "; | ||
| 772 | } | ||
| 773 | static inline boost::python::detail::keywords<0+1> args () | ||
| 774 | { | ||
| 775 | return (boost::python::arg("self")); | ||
| 776 | } | ||
| 777 | }; | ||
| 778 | |||
| 779 | template <> | ||
| 780 | struct constructor_1_impl< coal::ContactPatchResult, const coal::ContactPatchRequest & > | ||
| 781 | { | ||
| 782 | static inline const char* doc () | ||
| 783 | { | ||
| 784 | return "Constructor using a coal::ContactPatchRequest. "; | ||
| 785 | } | ||
| 786 | static inline boost::python::detail::keywords<1+1> args () | ||
| 787 | { | ||
| 788 | return (boost::python::arg("self"), boost::python::arg("request")); | ||
| 789 | } | ||
| 790 | }; | ||
| 791 | |||
| 792 | inline const char* member_func_doc (size_t (coal::ContactPatchResult::*function_ptr) () const) | ||
| 793 | { | ||
| 794 | if (function_ptr == static_cast<size_t (coal::ContactPatchResult::*) () const>(&coal::ContactPatchResult::numContactPatches)) | ||
| 795 | return "Number of contact patches in the result. "; | ||
| 796 | return ""; | ||
| 797 | } | ||
| 798 | |||
| 799 | inline boost::python::detail::keywords<1> member_func_args (size_t (coal::ContactPatchResult::*function_ptr) () const) | ||
| 800 | { | ||
| 801 | if (function_ptr == static_cast<size_t (coal::ContactPatchResult::*) () const>(&coal::ContactPatchResult::numContactPatches)) | ||
| 802 | return (boost::python::arg("self")); | ||
| 803 | return (boost::python::arg("self")); | ||
| 804 | } | ||
| 805 | |||
| 806 | inline const char* member_func_doc ( coal::ContactPatchResult::ContactPatchRef (coal::ContactPatchResult::*function_ptr) ()) | ||
| 807 | { | ||
| 808 | if (function_ptr == static_cast< coal::ContactPatchResult::ContactPatchRef (coal::ContactPatchResult::*) ()>(&coal::ContactPatchResult::getUnusedContactPatch)) | ||
| 809 | return "Returns a new unused contact patch from the internal data vector. "; | ||
| 810 | return ""; | ||
| 811 | } | ||
| 812 | |||
| 813 | inline boost::python::detail::keywords<1> member_func_args ( coal::ContactPatchResult::ContactPatchRef (coal::ContactPatchResult::*function_ptr) ()) | ||
| 814 | { | ||
| 815 | if (function_ptr == static_cast< coal::ContactPatchResult::ContactPatchRef (coal::ContactPatchResult::*) ()>(&coal::ContactPatchResult::getUnusedContactPatch)) | ||
| 816 | return (boost::python::arg("self")); | ||
| 817 | return (boost::python::arg("self")); | ||
| 818 | } | ||
| 819 | |||
| 820 | 5 | inline const char* member_func_doc (const coal::ContactPatch & (coal::ContactPatchResult::*function_ptr) (const size_t) const) | |
| 821 | { | ||
| 822 |
2/6✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
5 | if (function_ptr == static_cast<const coal::ContactPatch & (coal::ContactPatchResult::*) (const size_t) const>(&coal::ContactPatchResult::getContactPatch)) |
| 823 | 5 | return "Const getter for the i-th contact patch of the result. "; | |
| 824 | ✗ | return ""; | |
| 825 | } | ||
| 826 | |||
| 827 | inline boost::python::detail::keywords<2> member_func_args (const coal::ContactPatch & (coal::ContactPatchResult::*function_ptr) (const size_t) const) | ||
| 828 | { | ||
| 829 | if (function_ptr == static_cast<const coal::ContactPatch & (coal::ContactPatchResult::*) (const size_t) const>(&coal::ContactPatchResult::getContactPatch)) | ||
| 830 | return (boost::python::arg("self"), boost::python::arg("i")); | ||
| 831 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 832 | } | ||
| 833 | |||
| 834 | inline const char* member_func_doc ( coal::ContactPatch & (coal::ContactPatchResult::*function_ptr) (const size_t)) | ||
| 835 | { | ||
| 836 | if (function_ptr == static_cast< coal::ContactPatch & (coal::ContactPatchResult::*) (const size_t)>(&coal::ContactPatchResult::contactPatch)) | ||
| 837 | return "Getter for the i-th contact patch of the result. "; | ||
| 838 | return ""; | ||
| 839 | } | ||
| 840 | |||
| 841 | inline boost::python::detail::keywords<2> member_func_args ( coal::ContactPatch & (coal::ContactPatchResult::*function_ptr) (const size_t)) | ||
| 842 | { | ||
| 843 | if (function_ptr == static_cast< coal::ContactPatch & (coal::ContactPatchResult::*) (const size_t)>(&coal::ContactPatchResult::contactPatch)) | ||
| 844 | return (boost::python::arg("self"), boost::python::arg("i")); | ||
| 845 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 846 | } | ||
| 847 | |||
| 848 | inline const char* member_func_doc (void (coal::ContactPatchResult::*function_ptr) ()) | ||
| 849 | { | ||
| 850 | if (function_ptr == static_cast<void (coal::ContactPatchResult::*) ()>(&coal::ContactPatchResult::clear)) | ||
| 851 | return "Clears the contact patch result. "; | ||
| 852 | if (function_ptr == static_cast<void (coal::ContactPatchResult::*) ()>(&coal::ContactPatchResult::swapObjects)) | ||
| 853 | return "Repositions the coal::ContactPatch when they get inverted during their construction. "; | ||
| 854 | return ""; | ||
| 855 | } | ||
| 856 | |||
| 857 | inline boost::python::detail::keywords<1> member_func_args (void (coal::ContactPatchResult::*function_ptr) ()) | ||
| 858 | { | ||
| 859 | if (function_ptr == static_cast<void (coal::ContactPatchResult::*) ()>(&coal::ContactPatchResult::clear)) | ||
| 860 | return (boost::python::arg("self")); | ||
| 861 | if (function_ptr == static_cast<void (coal::ContactPatchResult::*) ()>(&coal::ContactPatchResult::swapObjects)) | ||
| 862 | return (boost::python::arg("self")); | ||
| 863 | return (boost::python::arg("self")); | ||
| 864 | } | ||
| 865 | |||
| 866 | inline const char* member_func_doc (void (coal::ContactPatchResult::*function_ptr) (const coal::ContactPatchRequest &)) | ||
| 867 | { | ||
| 868 | if (function_ptr == static_cast<void (coal::ContactPatchResult::*) (const coal::ContactPatchRequest &)>(&coal::ContactPatchResult::set)) | ||
| 869 | return "Set up a coal::ContactPatchResult from a coal::ContactPatchRequest "; | ||
| 870 | return ""; | ||
| 871 | } | ||
| 872 | |||
| 873 | inline boost::python::detail::keywords<2> member_func_args (void (coal::ContactPatchResult::*function_ptr) (const coal::ContactPatchRequest &)) | ||
| 874 | { | ||
| 875 | if (function_ptr == static_cast<void (coal::ContactPatchResult::*) (const coal::ContactPatchRequest &)>(&coal::ContactPatchResult::set)) | ||
| 876 | return (boost::python::arg("self"), boost::python::arg("request")); | ||
| 877 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 878 | } | ||
| 879 | |||
| 880 | inline const char* member_func_doc (bool (coal::ContactPatchResult::*function_ptr) (const coal::ContactPatchRequest &) const) | ||
| 881 | { | ||
| 882 | if (function_ptr == static_cast<bool (coal::ContactPatchResult::*) (const coal::ContactPatchRequest &) const>(&coal::ContactPatchResult::check)) | ||
| 883 | return "Return true if this coal::ContactPatchResult is aligned with the coal::ContactPatchRequest given as input. "; | ||
| 884 | return ""; | ||
| 885 | } | ||
| 886 | |||
| 887 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::ContactPatchResult::*function_ptr) (const coal::ContactPatchRequest &) const) | ||
| 888 | { | ||
| 889 | if (function_ptr == static_cast<bool (coal::ContactPatchResult::*) (const coal::ContactPatchRequest &) const>(&coal::ContactPatchResult::check)) | ||
| 890 | return (boost::python::arg("self"), boost::python::arg("request")); | ||
| 891 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 892 | } | ||
| 893 | |||
| 894 | inline const char* member_func_doc (bool (coal::ContactPatchResult::*function_ptr) (const coal::ContactPatchResult &) const) | ||
| 895 | { | ||
| 896 | if (function_ptr == static_cast<bool (coal::ContactPatchResult::*) (const coal::ContactPatchResult &) const>(&coal::ContactPatchResult::operator==)) | ||
| 897 | return "Whether two coal::ContactPatchResult are identical or not. "; | ||
| 898 | return ""; | ||
| 899 | } | ||
| 900 | |||
| 901 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::ContactPatchResult::*function_ptr) (const coal::ContactPatchResult &) const) | ||
| 902 | { | ||
| 903 | if (function_ptr == static_cast<bool (coal::ContactPatchResult::*) (const coal::ContactPatchResult &) const>(&coal::ContactPatchResult::operator==)) | ||
| 904 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 905 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 906 | } | ||
| 907 | } // namespace doxygen | ||
| 908 | #include <coal/collision_data.h> | ||
| 909 | |||
| 910 | namespace doxygen { | ||
| 911 | |||
| 912 | template <> | ||
| 913 | struct class_doc_impl< coal::DistanceRequest > | ||
| 914 | { | ||
| 915 | 5 | static inline const char* run () | |
| 916 | { | ||
| 917 | 5 | return "request to the distance computation "; | |
| 918 | } | ||
| 919 | 20 | static inline const char* attribute (const char* attrib) | |
| 920 | { | ||
| 921 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 15 times.
|
20 | if (strcmp(attrib, "enable_nearest_points") == 0) |
| 922 | 5 | return "whether to return the nearest points. Nearest points are always computed and are the points of the shapes that achieve a distance of DistanceResult::min_distance. "; | |
| 923 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 10 times.
|
15 | if (strcmp(attrib, "enable_signed_distance") == 0) |
| 924 | return "whether to compute the penetration depth when objects are in collision. Turning this off can save computation time if only the distance when objects are disjoint is needed. \n" | ||
| 925 | "\n" | ||
| 926 | 5 | "Note: The minimum distance between the shapes is stored in DistanceResult::min_distance. If enable_signed_distance is off, DistanceResult::min_distance is always positive. If enable_signed_distance is on, DistanceResult::min_distance can be positive or negative. The nearest points are the points of the shapes that achieve a distance of DistanceResult::min_distance. "; | |
| 927 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
|
10 | if (strcmp(attrib, "rel_err") == 0) |
| 928 | 5 | return "error threshold for approximate distance "; | |
| 929 | (void)attrib; // turn off unused parameter warning. | ||
| 930 | 5 | return ""; | |
| 931 | } | ||
| 932 | }; | ||
| 933 | |||
| 934 | template <> | ||
| 935 | struct constructor_4_impl< coal::DistanceRequest, bool, bool, coal::Scalar, coal::Scalar > | ||
| 936 | { | ||
| 937 | static inline const char* doc () | ||
| 938 | { | ||
| 939 | return "Param\n" | ||
| 940 | " - enable_nearest_points_ enables the nearest points computation. \n" | ||
| 941 | " - enable_signed_distance_ allows to compute the penetration depth \n" | ||
| 942 | " - rel_err_ \n" | ||
| 943 | " - abs_err_ "; | ||
| 944 | } | ||
| 945 | static inline boost::python::detail::keywords<4+1> args () | ||
| 946 | { | ||
| 947 | return (boost::python::arg("self"), boost::python::arg("enable_nearest_points_"), boost::python::arg("enable_signed_distance_"), boost::python::arg("rel_err_"), boost::python::arg("abs_err_")); | ||
| 948 | } | ||
| 949 | }; | ||
| 950 | |||
| 951 | inline const char* member_func_doc (bool (coal::DistanceRequest::*function_ptr) (const coal::DistanceResult &) const) | ||
| 952 | { | ||
| 953 | if (function_ptr == static_cast<bool (coal::DistanceRequest::*) (const coal::DistanceResult &) const>(&coal::DistanceRequest::isSatisfied)) | ||
| 954 | return ""; | ||
| 955 | return ""; | ||
| 956 | } | ||
| 957 | |||
| 958 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::DistanceRequest::*function_ptr) (const coal::DistanceResult &) const) | ||
| 959 | { | ||
| 960 | if (function_ptr == static_cast<bool (coal::DistanceRequest::*) (const coal::DistanceResult &) const>(&coal::DistanceRequest::isSatisfied)) | ||
| 961 | return (boost::python::arg("self"), boost::python::arg("result")); | ||
| 962 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 963 | } | ||
| 964 | |||
| 965 | inline const char* member_func_doc ( coal::DistanceRequest & (coal::DistanceRequest::*function_ptr) (const coal::DistanceRequest &)) | ||
| 966 | { | ||
| 967 | if (function_ptr == static_cast< coal::DistanceRequest & (coal::DistanceRequest::*) (const coal::DistanceRequest &)>(&coal::DistanceRequest::operator=)) | ||
| 968 | return ""; | ||
| 969 | return ""; | ||
| 970 | } | ||
| 971 | |||
| 972 | inline boost::python::detail::keywords<2> member_func_args ( coal::DistanceRequest & (coal::DistanceRequest::*function_ptr) (const coal::DistanceRequest &)) | ||
| 973 | { | ||
| 974 | if (function_ptr == static_cast< coal::DistanceRequest & (coal::DistanceRequest::*) (const coal::DistanceRequest &)>(&coal::DistanceRequest::operator=)) | ||
| 975 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 976 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 977 | } | ||
| 978 | |||
| 979 | inline const char* member_func_doc (bool (coal::DistanceRequest::*function_ptr) (const coal::DistanceRequest &) const) | ||
| 980 | { | ||
| 981 | if (function_ptr == static_cast<bool (coal::DistanceRequest::*) (const coal::DistanceRequest &) const>(&coal::DistanceRequest::operator==)) | ||
| 982 | return "whether two coal::DistanceRequest are the same or not "; | ||
| 983 | return ""; | ||
| 984 | } | ||
| 985 | |||
| 986 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::DistanceRequest::*function_ptr) (const coal::DistanceRequest &) const) | ||
| 987 | { | ||
| 988 | if (function_ptr == static_cast<bool (coal::DistanceRequest::*) (const coal::DistanceRequest &) const>(&coal::DistanceRequest::operator==)) | ||
| 989 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 990 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 991 | } | ||
| 992 | } // namespace doxygen | ||
| 993 | #include <coal/collision_data.h> | ||
| 994 | |||
| 995 | namespace doxygen { | ||
| 996 | |||
| 997 | template <> | ||
| 998 | struct class_doc_impl< coal::DistanceResult > | ||
| 999 | { | ||
| 1000 | 5 | static inline const char* run () | |
| 1001 | { | ||
| 1002 | 5 | return "distance result "; | |
| 1003 | } | ||
| 1004 | 45 | static inline const char* attribute (const char* attrib) | |
| 1005 | { | ||
| 1006 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 40 times.
|
45 | if (strcmp(attrib, "min_distance") == 0) |
| 1007 | return "minimum distance between two objects. If two objects are in collision and DistanceRequest::enable_signed_distance is activated, min_distance <= 0. \n" | ||
| 1008 | "\n" | ||
| 1009 | 5 | "Note: The nearest points are the points of the shapes that achieve a distance of DistanceResult::min_distance. "; | |
| 1010 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 35 times.
|
40 | if (strcmp(attrib, "normal") == 0) |
| 1011 | 5 | return "normal. "; | |
| 1012 |
2/2✓ Branch 0 taken 15 times.
✓ Branch 1 taken 20 times.
|
35 | if (strcmp(attrib, "nearest_points") == 0) |
| 1013 | 15 | return "nearest points. See CollisionResult::nearest_points. "; | |
| 1014 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 15 times.
|
20 | if (strcmp(attrib, "o1") == 0) |
| 1015 | 5 | return "collision object 1 "; | |
| 1016 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 10 times.
|
15 | if (strcmp(attrib, "o2") == 0) |
| 1017 | 5 | return "collision object 2 "; | |
| 1018 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
|
10 | if (strcmp(attrib, "b1") == 0) |
| 1019 | 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 "; | |
| 1020 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if (strcmp(attrib, "b2") == 0) |
| 1021 | 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 "; | |
| 1022 | ✗ | if (strcmp(attrib, "NONE") == 0) | |
| 1023 | ✗ | return "invalid contact primitive information "; | |
| 1024 | (void)attrib; // turn off unused parameter warning. | ||
| 1025 | ✗ | return ""; | |
| 1026 | } | ||
| 1027 | }; | ||
| 1028 | |||
| 1029 | template <> | ||
| 1030 | struct constructor_1_impl< coal::DistanceResult, coal::Scalar > | ||
| 1031 | { | ||
| 1032 | static inline const char* doc () | ||
| 1033 | { | ||
| 1034 | return ""; | ||
| 1035 | } | ||
| 1036 | static inline boost::python::detail::keywords<1+1> args () | ||
| 1037 | { | ||
| 1038 | return (boost::python::arg("self"), boost::python::arg("min_distance_")); | ||
| 1039 | } | ||
| 1040 | }; | ||
| 1041 | |||
| 1042 | inline const char* member_func_doc (void (coal::DistanceResult::*function_ptr) ( coal::Scalar, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int)) | ||
| 1043 | { | ||
| 1044 | if (function_ptr == static_cast<void (coal::DistanceResult::*) ( coal::Scalar, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int)>(&coal::DistanceResult::update)) | ||
| 1045 | return "add distance information into the result "; | ||
| 1046 | return ""; | ||
| 1047 | } | ||
| 1048 | |||
| 1049 | inline boost::python::detail::keywords<6> member_func_args (void (coal::DistanceResult::*function_ptr) ( coal::Scalar, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int)) | ||
| 1050 | { | ||
| 1051 | if (function_ptr == static_cast<void (coal::DistanceResult::*) ( coal::Scalar, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int)>(&coal::DistanceResult::update)) | ||
| 1052 | 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_")); | ||
| 1053 | 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")); | ||
| 1054 | } | ||
| 1055 | |||
| 1056 | inline const char* member_func_doc (void (coal::DistanceResult::*function_ptr) ( coal::Scalar, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int, const coal::Vec3s &, const coal::Vec3s &, const coal::Vec3s &)) | ||
| 1057 | { | ||
| 1058 | if (function_ptr == static_cast<void (coal::DistanceResult::*) ( coal::Scalar, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int, const coal::Vec3s &, const coal::Vec3s &, const coal::Vec3s &)>(&coal::DistanceResult::update)) | ||
| 1059 | return "add distance information into the result "; | ||
| 1060 | return ""; | ||
| 1061 | } | ||
| 1062 | |||
| 1063 | inline boost::python::detail::keywords<9> member_func_args (void (coal::DistanceResult::*function_ptr) ( coal::Scalar, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int, const coal::Vec3s &, const coal::Vec3s &, const coal::Vec3s &)) | ||
| 1064 | { | ||
| 1065 | if (function_ptr == static_cast<void (coal::DistanceResult::*) ( coal::Scalar, const coal::CollisionGeometry *, const coal::CollisionGeometry *, int, int, const coal::Vec3s &, const coal::Vec3s &, const coal::Vec3s &)>(&coal::DistanceResult::update)) | ||
| 1066 | 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_")); | ||
| 1067 | 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")); | ||
| 1068 | } | ||
| 1069 | |||
| 1070 | inline const char* member_func_doc (void (coal::DistanceResult::*function_ptr) (const coal::DistanceResult &)) | ||
| 1071 | { | ||
| 1072 | if (function_ptr == static_cast<void (coal::DistanceResult::*) (const coal::DistanceResult &)>(&coal::DistanceResult::update)) | ||
| 1073 | return "add distance information into the result "; | ||
| 1074 | return ""; | ||
| 1075 | } | ||
| 1076 | |||
| 1077 | inline boost::python::detail::keywords<2> member_func_args (void (coal::DistanceResult::*function_ptr) (const coal::DistanceResult &)) | ||
| 1078 | { | ||
| 1079 | if (function_ptr == static_cast<void (coal::DistanceResult::*) (const coal::DistanceResult &)>(&coal::DistanceResult::update)) | ||
| 1080 | return (boost::python::arg("self"), boost::python::arg("other_result")); | ||
| 1081 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 1082 | } | ||
| 1083 | |||
| 1084 | 5 | inline const char* member_func_doc (void (coal::DistanceResult::*function_ptr) ()) | |
| 1085 | { | ||
| 1086 |
2/6✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 5 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
5 | if (function_ptr == static_cast<void (coal::DistanceResult::*) ()>(&coal::DistanceResult::clear)) |
| 1087 | 5 | return "clear the result "; | |
| 1088 | ✗ | return ""; | |
| 1089 | } | ||
| 1090 | |||
| 1091 | inline boost::python::detail::keywords<1> member_func_args (void (coal::DistanceResult::*function_ptr) ()) | ||
| 1092 | { | ||
| 1093 | if (function_ptr == static_cast<void (coal::DistanceResult::*) ()>(&coal::DistanceResult::clear)) | ||
| 1094 | return (boost::python::arg("self")); | ||
| 1095 | return (boost::python::arg("self")); | ||
| 1096 | } | ||
| 1097 | |||
| 1098 | inline const char* member_func_doc (bool (coal::DistanceResult::*function_ptr) (const coal::DistanceResult &) const) | ||
| 1099 | { | ||
| 1100 | if (function_ptr == static_cast<bool (coal::DistanceResult::*) (const coal::DistanceResult &) const>(&coal::DistanceResult::operator==)) | ||
| 1101 | return "whether two coal::DistanceResult are the same or not "; | ||
| 1102 | return ""; | ||
| 1103 | } | ||
| 1104 | |||
| 1105 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::DistanceResult::*function_ptr) (const coal::DistanceResult &) const) | ||
| 1106 | { | ||
| 1107 | if (function_ptr == static_cast<bool (coal::DistanceResult::*) (const coal::DistanceResult &) const>(&coal::DistanceResult::operator==)) | ||
| 1108 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 1109 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 1110 | } | ||
| 1111 | } // namespace doxygen | ||
| 1112 | #include <coal/collision_data.h> | ||
| 1113 | |||
| 1114 | namespace doxygen { | ||
| 1115 | |||
| 1116 | template <> | ||
| 1117 | struct class_doc_impl< coal::QueryRequest > | ||
| 1118 | { | ||
| 1119 | 5 | static inline const char* run () | |
| 1120 | { | ||
| 1121 | 5 | return "base class for all query requests "; | |
| 1122 | } | ||
| 1123 | 65 | static inline const char* attribute (const char* attrib) | |
| 1124 | { | ||
| 1125 |
2/2✓ Branch 0 taken 10 times.
✓ Branch 1 taken 55 times.
|
65 | if (strcmp(attrib, "enable_cached_gjk_guess") == 0) |
| 1126 | 10 | return "whether enable gjk initial guess @Deprecated Use gjk_initial_guess instead "; | |
| 1127 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 50 times.
|
55 | if (strcmp(attrib, "cached_gjk_guess") == 0) |
| 1128 | 5 | return "the gjk initial guess set by user "; | |
| 1129 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 45 times.
|
50 | if (strcmp(attrib, "cached_support_func_guess") == 0) |
| 1130 | 5 | return "the support function initial guess set by user "; | |
| 1131 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 40 times.
|
45 | if (strcmp(attrib, "gjk_max_iterations") == 0) |
| 1132 | 5 | return "maximum iteration for the GJK algorithm "; | |
| 1133 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 35 times.
|
40 | if (strcmp(attrib, "gjk_tolerance") == 0) |
| 1134 | 5 | return "tolerance for the GJK algorithm. Note: This tolerance determines the precision on the estimated distance between two geometries which are not in collision. It is recommended to not set this tolerance to less than 1e-6. "; | |
| 1135 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 30 times.
|
35 | if (strcmp(attrib, "gjk_variant") == 0) |
| 1136 | 5 | return "whether to enable the Nesterov accleration of GJK "; | |
| 1137 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 25 times.
|
30 | if (strcmp(attrib, "gjk_convergence_criterion") == 0) |
| 1138 | 5 | return "convergence criterion used to stop GJK "; | |
| 1139 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 20 times.
|
25 | if (strcmp(attrib, "gjk_convergence_criterion_type") == 0) |
| 1140 | 5 | return "convergence criterion used to stop GJK "; | |
| 1141 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 15 times.
|
20 | if (strcmp(attrib, "epa_max_iterations") == 0) |
| 1142 | 5 | return "max number of iterations for EPA "; | |
| 1143 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 10 times.
|
15 | if (strcmp(attrib, "epa_tolerance") == 0) |
| 1144 | 5 | return "tolerance for EPA. Note: This tolerance determines the precision on the estimated distance between two geometries which are in collision. It is recommended to not set this tolerance to less than 1e-6. Also, setting EPA's tolerance to less than GJK's is not recommended. "; | |
| 1145 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
|
10 | if (strcmp(attrib, "enable_timings") == 0) |
| 1146 | 5 | return "enable timings when performing collision/distance request "; | |
| 1147 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 5 times.
|
5 | if (strcmp(attrib, "collision_distance_threshold") == 0) |
| 1148 | ✗ | return "threshold below which a collision is considered. "; | |
| 1149 | (void)attrib; // turn off unused parameter warning. | ||
| 1150 | 5 | return ""; | |
| 1151 | } | ||
| 1152 | }; | ||
| 1153 | |||
| 1154 | template <> | ||
| 1155 | struct constructor_0_impl< coal::QueryRequest > | ||
| 1156 | { | ||
| 1157 | static inline const char* doc () | ||
| 1158 | { | ||
| 1159 | return "Default constructor. "; | ||
| 1160 | } | ||
| 1161 | static inline boost::python::detail::keywords<0+1> args () | ||
| 1162 | { | ||
| 1163 | return (boost::python::arg("self")); | ||
| 1164 | } | ||
| 1165 | }; | ||
| 1166 | |||
| 1167 | template <> | ||
| 1168 | struct constructor_1_impl< coal::QueryRequest, const coal::QueryRequest & > | ||
| 1169 | { | ||
| 1170 | static inline const char* doc () | ||
| 1171 | { | ||
| 1172 | return "Copy constructor. "; | ||
| 1173 | } | ||
| 1174 | static inline boost::python::detail::keywords<1+1> args () | ||
| 1175 | { | ||
| 1176 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 1177 | } | ||
| 1178 | }; | ||
| 1179 | |||
| 1180 | inline const char* member_func_doc ( coal::QueryRequest & (coal::QueryRequest::*function_ptr) (const coal::QueryRequest &)) | ||
| 1181 | { | ||
| 1182 | if (function_ptr == static_cast< coal::QueryRequest & (coal::QueryRequest::*) (const coal::QueryRequest &)>(&coal::QueryRequest::operator=)) | ||
| 1183 | return "Copy assignment operator. "; | ||
| 1184 | return ""; | ||
| 1185 | } | ||
| 1186 | |||
| 1187 | inline boost::python::detail::keywords<2> member_func_args ( coal::QueryRequest & (coal::QueryRequest::*function_ptr) (const coal::QueryRequest &)) | ||
| 1188 | { | ||
| 1189 | if (function_ptr == static_cast< coal::QueryRequest & (coal::QueryRequest::*) (const coal::QueryRequest &)>(&coal::QueryRequest::operator=)) | ||
| 1190 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 1191 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 1192 | } | ||
| 1193 | |||
| 1194 | inline const char* member_func_doc (void (coal::QueryRequest::*function_ptr) (const coal::QueryResult &) const) | ||
| 1195 | { | ||
| 1196 | if (function_ptr == static_cast<void (coal::QueryRequest::*) (const coal::QueryResult &) const>(&coal::QueryRequest::updateGuess)) | ||
| 1197 | return "Updates the guess for the internal GJK algorithm in order to warm-start it when reusing this collision request on the same collision pair. \n" | ||
| 1198 | "\n" | ||
| 1199 | "Note: The option gjk_initial_guess must be set to GJKInitialGuess::CachedGuess for this to work. "; | ||
| 1200 | return ""; | ||
| 1201 | } | ||
| 1202 | |||
| 1203 | inline boost::python::detail::keywords<2> member_func_args (void (coal::QueryRequest::*function_ptr) (const coal::QueryResult &) const) | ||
| 1204 | { | ||
| 1205 | if (function_ptr == static_cast<void (coal::QueryRequest::*) (const coal::QueryResult &) const>(&coal::QueryRequest::updateGuess)) | ||
| 1206 | return (boost::python::arg("self"), boost::python::arg("result")); | ||
| 1207 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 1208 | } | ||
| 1209 | |||
| 1210 | inline const char* member_func_doc (bool (coal::QueryRequest::*function_ptr) (const coal::QueryRequest &) const) | ||
| 1211 | { | ||
| 1212 | if (function_ptr == static_cast<bool (coal::QueryRequest::*) (const coal::QueryRequest &) const>(&coal::QueryRequest::operator==)) | ||
| 1213 | return "whether two coal::QueryRequest are the same or not "; | ||
| 1214 | return ""; | ||
| 1215 | } | ||
| 1216 | |||
| 1217 | inline boost::python::detail::keywords<2> member_func_args (bool (coal::QueryRequest::*function_ptr) (const coal::QueryRequest &) const) | ||
| 1218 | { | ||
| 1219 | if (function_ptr == static_cast<bool (coal::QueryRequest::*) (const coal::QueryRequest &) const>(&coal::QueryRequest::operator==)) | ||
| 1220 | return (boost::python::arg("self"), boost::python::arg("other")); | ||
| 1221 | return (boost::python::arg("self"), boost::python::arg("arg0")); | ||
| 1222 | } | ||
| 1223 | } // namespace doxygen | ||
| 1224 | #include <coal/collision_data.h> | ||
| 1225 | |||
| 1226 | namespace doxygen { | ||
| 1227 | |||
| 1228 | template <> | ||
| 1229 | struct class_doc_impl< coal::QueryResult > | ||
| 1230 | { | ||
| 1231 | 5 | static inline const char* run () | |
| 1232 | { | ||
| 1233 | 5 | return "base class for all query results "; | |
| 1234 | } | ||
| 1235 | 15 | static inline const char* attribute (const char* attrib) | |
| 1236 | { | ||
| 1237 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 10 times.
|
15 | if (strcmp(attrib, "cached_gjk_guess") == 0) |
| 1238 | 5 | return "stores the last GJK ray when relevant. "; | |
| 1239 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 5 times.
|
10 | if (strcmp(attrib, "cached_support_func_guess") == 0) |
| 1240 | 5 | return "stores the last support function vertex index, when relevant. "; | |
| 1241 |
1/2✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
|
5 | if (strcmp(attrib, "timings") == 0) |
| 1242 | 5 | return "timings for the given request "; | |
| 1243 | (void)attrib; // turn off unused parameter warning. | ||
| 1244 | ✗ | return ""; | |
| 1245 | } | ||
| 1246 | }; | ||
| 1247 | |||
| 1248 | template <> | ||
| 1249 | struct constructor_0_impl< coal::QueryResult > | ||
| 1250 | { | ||
| 1251 | static inline const char* doc () | ||
| 1252 | { | ||
| 1253 | return ""; | ||
| 1254 | } | ||
| 1255 | static inline boost::python::detail::keywords<0+1> args () | ||
| 1256 | { | ||
| 1257 | return (boost::python::arg("self")); | ||
| 1258 | } | ||
| 1259 | }; | ||
| 1260 | } // namespace doxygen | ||
| 1261 | |||
| 1262 | #endif // DOXYGEN_AUTODOC_COAL_COLLISION_DATA_H | ||
| 1263 | |||
| 1264 |