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