Debian Codegraph @

python/dartpy/dynamics/ReferentialSkeleton.cpp

raw
1 /*
2 * Copyright (c) 2011-2022, The DART development contributors
3 * All rights reserved.
4 *
5 * The list of contributors can be found at:
6 * https://github.com/dartsim/dart/blob/master/LICENSE
7 *
8 * This file is provided under the following "BSD-style" License:
9 * Redistribution and use in source and binary forms, with or
10 * without modification, are permitted provided that the following
11 * conditions are met:
12 * * Redistributions of source code must retain the above copyright
13 * notice, this list of conditions and the following disclaimer.
14 * * Redistributions in binary form must reproduce the above
15 * copyright notice, this list of conditions and the following
16 * disclaimer in the documentation and/or other materials provided
17 * with the distribution.
18 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
19 * CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
20 * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
21 * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
22 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR
23 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
26 * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED
27 * AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
29 * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30 * POSSIBILITY OF SUCH DAMAGE.
31 */
32
33 #include <dart/dart.hpp>
34 #include <pybind11/pybind11.h>
35
36 #include "eigen_geometry_pybind.h"
37 #include "eigen_pybind.h"
38
39 namespace py = pybind11;
40
41 namespace dart {
42 namespace python {
43
44 void ReferentialSkeleton(py::module& m)
45 {
46 ::py::class_<
47 dart::dynamics::ReferentialSkeleton,
48 dart::dynamics::MetaSkeleton,
49 std::shared_ptr<dart::dynamics::ReferentialSkeleton>>(
50 m, "ReferentialSkeleton")
51 .def(
52 "getLockableReference",
53 +[](const dart::dynamics::ReferentialSkeleton* self)
54 -> std::unique_ptr<dart::common::LockableReference> {
55 return self->getLockableReference();
56 })
57 .def(
58 "setName",
59 +[](dart::dynamics::ReferentialSkeleton* self,
60 const std::string& _name) -> const std::string& {
61 return self->setName(_name);
62 },
63 ::py::return_value_policy::reference_internal,
64 ::py::arg("name"))
65 .def(
66 "getName",
67 +[](const dart::dynamics::ReferentialSkeleton* self)
68 -> const std::string& { return self->getName(); },
69 ::py::return_value_policy::reference_internal)
70 .def(
71 "getNumSkeletons",
72 +[](const dart::dynamics::ReferentialSkeleton* self) -> std::size_t {
73 return self->getNumSkeletons();
74 })
75 .def(
76 "hasSkeleton",
77 +[](const dart::dynamics::ReferentialSkeleton* self,
78 const dart::dynamics::Skeleton* skel) -> bool {
79 return self->hasSkeleton(skel);
80 },
81 ::py::arg("skel"))
82 .def(
83 "getNumBodyNodes",
84 +[](const dart::dynamics::ReferentialSkeleton* self) -> std::size_t {
85 return self->getNumBodyNodes();
86 })
87 .def(
88 "getBodyNodes",
89 +[](dart::dynamics::ReferentialSkeleton* self)
90 -> const std::vector<dart::dynamics::BodyNode*>& {
91 return self->getBodyNodes();
92 })
93 .def(
94 "getBodyNodes",
95 +[](dart::dynamics::ReferentialSkeleton* self,
96 const std::string& name)
97 -> std::vector<dart::dynamics::BodyNode*> {
98 return self->getBodyNodes(name);
99 },
100 ::py::arg("name"))
101 .def(
102 "getBodyNodes",
103 +[](const dart::dynamics::ReferentialSkeleton* self,
104 const std::string& name)
105 -> std::vector<const dart::dynamics::BodyNode*> {
106 return self->getBodyNodes(name);
107 },
108 ::py::arg("name"))
109 .def(
110 "hasBodyNode",
111 +[](const dart::dynamics::ReferentialSkeleton* self,
112 const dart::dynamics::BodyNode* bodyNode) -> bool {
113 return self->hasBodyNode(bodyNode);
114 },
115 ::py::arg("bodyNode"))
116 .def(
117 "getIndexOf",
118 +[](const dart::dynamics::ReferentialSkeleton* self,
119 const dart::dynamics::BodyNode* _bn) -> std::size_t {
120 return self->getIndexOf(_bn);
121 },
122 ::py::arg("bn"))
123 .def(
124 "getIndexOf",
125 +[](const dart::dynamics::ReferentialSkeleton* self,
126 const dart::dynamics::BodyNode* _bn,
127 bool _warning) -> std::size_t {
128 return self->getIndexOf(_bn, _warning);
129 },
130 ::py::arg("bn"),
131 ::py::arg("warning"))
132 .def(
133 "getNumJoints",
134 +[](const dart::dynamics::ReferentialSkeleton* self) -> std::size_t {
135 return self->getNumJoints();
136 })
137 .def(
138 "getJoints",
139 +[](dart::dynamics::ReferentialSkeleton* self)
140 -> std::vector<dart::dynamics::Joint*> {
141 return self->getJoints();
142 })
143 .def(
144 "getJoints",
145 +[](const dart::dynamics::ReferentialSkeleton* self)
146 -> std::vector<const dart::dynamics::Joint*> {
147 return self->getJoints();
148 })
149 .def(
150 "getJoints",
151 +[](dart::dynamics::ReferentialSkeleton* self,
152 const std::string& name) -> std::vector<dart::dynamics::Joint*> {
153 return self->getJoints(name);
154 },
155 ::py::arg("name"))
156 .def(
157 "getJoints",
158 +[](const dart::dynamics::ReferentialSkeleton* self,
159 const std::string& name)
160 -> std::vector<const dart::dynamics::Joint*> {
161 return self->getJoints(name);
162 },
163 ::py::arg("name"))
164 .def(
165 "hasJoint",
166 +[](const dart::dynamics::ReferentialSkeleton* self,
167 const dart::dynamics::Joint* joint) -> bool {
168 return self->hasJoint(joint);
169 },
170 ::py::arg("joint"))
171 .def(
172 "getIndexOf",
173 +[](const dart::dynamics::ReferentialSkeleton* self,
174 const dart::dynamics::Joint* _joint) -> std::size_t {
175 return self->getIndexOf(_joint);
176 },
177 ::py::arg("joint"))
178 .def(
179 "getIndexOf",
180 +[](const dart::dynamics::ReferentialSkeleton* self,
181 const dart::dynamics::Joint* _joint,
182 bool _warning) -> std::size_t {
183 return self->getIndexOf(_joint, _warning);
184 },
185 ::py::arg("joint"),
186 ::py::arg("warning"))
187 .def(
188 "getNumDofs",
189 +[](const dart::dynamics::ReferentialSkeleton* self) -> std::size_t {
190 return self->getNumDofs();
191 })
192 .def(
193 "getDofs",
194 +[](const dart::dynamics::ReferentialSkeleton* self)
195 -> std::vector<const dart::dynamics::DegreeOfFreedom*> {
196 return self->getDofs();
197 })
198 .def(
199 "getIndexOf",
200 +[](const dart::dynamics::ReferentialSkeleton* self,
201 const dart::dynamics::DegreeOfFreedom* _dof) -> std::size_t {
202 return self->getIndexOf(_dof);
203 },
204 ::py::arg("dof"))
205 .def(
206 "getIndexOf",
207 +[](const dart::dynamics::ReferentialSkeleton* self,
208 const dart::dynamics::DegreeOfFreedom* _dof,
209 bool _warning) -> std::size_t {
210 return self->getIndexOf(_dof, _warning);
211 },
212 ::py::arg("dof"),
213 ::py::arg("warning"))
214 .def(
215 "getJacobian",
216 +[](const dart::dynamics::ReferentialSkeleton* self,
217 const dart::dynamics::JacobianNode* _node)
218 -> dart::math::Jacobian { return self->getJacobian(_node); },
219 ::py::arg("node"))
220 .def(
221 "getJacobian",
222 +[](const dart::dynamics::ReferentialSkeleton* self,
223 const dart::dynamics::JacobianNode* _node,
224 const dart::dynamics::Frame* _inCoordinatesOf)
225 -> dart::math::Jacobian {
226 return self->getJacobian(_node, _inCoordinatesOf);
227 },
228 ::py::arg("node"),
229 ::py::arg("inCoordinatesOf"))
230 .def(
231 "getJacobian",
232 +[](const dart::dynamics::ReferentialSkeleton* self,
233 const dart::dynamics::JacobianNode* _node,
234 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
235 return self->getJacobian(_node, _localOffset);
236 },
237 ::py::arg("node"),
238 ::py::arg("localOffset"))
239 .def(
240 "getJacobian",
241 +[](const dart::dynamics::ReferentialSkeleton* self,
242 const dart::dynamics::JacobianNode* _node,
243 const Eigen::Vector3d& _localOffset,
244 const dart::dynamics::Frame* _inCoordinatesOf)
245 -> dart::math::Jacobian {
246 return self->getJacobian(_node, _localOffset, _inCoordinatesOf);
247 },
248 ::py::arg("node"),
249 ::py::arg("localOffset"),
250 ::py::arg("inCoordinatesOf"))
251 .def(
252 "getWorldJacobian",
253 +[](const dart::dynamics::ReferentialSkeleton* self,
254 const dart::dynamics::JacobianNode* _node)
255 -> dart::math::Jacobian { return self->getWorldJacobian(_node); },
256 ::py::arg("node"))
257 .def(
258 "getWorldJacobian",
259 +[](const dart::dynamics::ReferentialSkeleton* self,
260 const dart::dynamics::JacobianNode* _node,
261 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
262 return self->getWorldJacobian(_node, _localOffset);
263 },
264 ::py::arg("node"),
265 ::py::arg("localOffset"))
266 .def(
267 "getLinearJacobian",
268 +[](const dart::dynamics::ReferentialSkeleton* self,
269 const dart::dynamics::JacobianNode* _node)
270 -> dart::math::LinearJacobian {
271 return self->getLinearJacobian(_node);
272 },
273 ::py::arg("node"))
274 .def(
275 "getLinearJacobian",
276 +[](const dart::dynamics::ReferentialSkeleton* self,
277 const dart::dynamics::JacobianNode* _node,
278 const dart::dynamics::Frame* _inCoordinatesOf)
279 -> dart::math::LinearJacobian {
280 return self->getLinearJacobian(_node, _inCoordinatesOf);
281 },
282 ::py::arg("node"),
283 ::py::arg("inCoordinatesOf"))
284 .def(
285 "getLinearJacobian",
286 +[](const dart::dynamics::ReferentialSkeleton* self,
287 const dart::dynamics::JacobianNode* _node,
288 const Eigen::Vector3d& _localOffset)
289 -> dart::math::LinearJacobian {
290 return self->getLinearJacobian(_node, _localOffset);
291 },
292 ::py::arg("node"),
293 ::py::arg("localOffset"))
294 .def(
295 "getLinearJacobian",
296 +[](const dart::dynamics::ReferentialSkeleton* self,
297 const dart::dynamics::JacobianNode* _node,
298 const Eigen::Vector3d& _localOffset,
299 const dart::dynamics::Frame* _inCoordinatesOf)
300 -> dart::math::LinearJacobian {
301 return self->getLinearJacobian(
302 _node, _localOffset, _inCoordinatesOf);
303 },
304 ::py::arg("node"),
305 ::py::arg("localOffset"),
306 ::py::arg("inCoordinatesOf"))
307 .def(
308 "getAngularJacobian",
309 +[](const dart::dynamics::ReferentialSkeleton* self,
310 const dart::dynamics::JacobianNode* _node)
311 -> dart::math::AngularJacobian {
312 return self->getAngularJacobian(_node);
313 },
314 ::py::arg("node"))
315 .def(
316 "getAngularJacobian",
317 +[](const dart::dynamics::ReferentialSkeleton* self,
318 const dart::dynamics::JacobianNode* _node,
319 const dart::dynamics::Frame* _inCoordinatesOf)
320 -> dart::math::AngularJacobian {
321 return self->getAngularJacobian(_node, _inCoordinatesOf);
322 },
323 ::py::arg("node"),
324 ::py::arg("inCoordinatesOf"))
325 .def(
326 "getJacobianSpatialDeriv",
327 +[](const dart::dynamics::ReferentialSkeleton* self,
328 const dart::dynamics::JacobianNode* _node)
329 -> dart::math::Jacobian {
330 return self->getJacobianSpatialDeriv(_node);
331 },
332 ::py::arg("node"))
333 .def(
334 "getJacobianSpatialDeriv",
335 +[](const dart::dynamics::ReferentialSkeleton* self,
336 const dart::dynamics::JacobianNode* _node,
337 const dart::dynamics::Frame* _inCoordinatesOf)
338 -> dart::math::Jacobian {
339 return self->getJacobianSpatialDeriv(_node, _inCoordinatesOf);
340 },
341 ::py::arg("node"),
342 ::py::arg("inCoordinatesOf"))
343 .def(
344 "getJacobianSpatialDeriv",
345 +[](const dart::dynamics::ReferentialSkeleton* self,
346 const dart::dynamics::JacobianNode* _node,
347 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
348 return self->getJacobianSpatialDeriv(_node, _localOffset);
349 },
350 ::py::arg("node"),
351 ::py::arg("localOffset"))
352 .def(
353 "getJacobianSpatialDeriv",
354 +[](const dart::dynamics::ReferentialSkeleton* self,
355 const dart::dynamics::JacobianNode* _node,
356 const Eigen::Vector3d& _localOffset,
357 const dart::dynamics::Frame* _inCoordinatesOf)
358 -> dart::math::Jacobian {
359 return self->getJacobianSpatialDeriv(
360 _node, _localOffset, _inCoordinatesOf);
361 },
362 ::py::arg("node"),
363 ::py::arg("localOffset"),
364 ::py::arg("inCoordinatesOf"))
365 .def(
366 "getJacobianClassicDeriv",
367 +[](const dart::dynamics::ReferentialSkeleton* self,
368 const dart::dynamics::JacobianNode* _node)
369 -> dart::math::Jacobian {
370 return self->getJacobianClassicDeriv(_node);
371 },
372 ::py::arg("node"))
373 .def(
374 "getJacobianClassicDeriv",
375 +[](const dart::dynamics::ReferentialSkeleton* self,
376 const dart::dynamics::JacobianNode* _node,
377 const dart::dynamics::Frame* _inCoordinatesOf)
378 -> dart::math::Jacobian {
379 return self->getJacobianClassicDeriv(_node, _inCoordinatesOf);
380 },
381 ::py::arg("node"),
382 ::py::arg("inCoordinatesOf"))
383 .def(
384 "getJacobianClassicDeriv",
385 +[](const dart::dynamics::ReferentialSkeleton* self,
386 const dart::dynamics::JacobianNode* _node,
387 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
388 return self->getJacobianClassicDeriv(_node, _localOffset);
389 },
390 ::py::arg("node"),
391 ::py::arg("localOffset"))
392 .def(
393 "getJacobianClassicDeriv",
394 +[](const dart::dynamics::ReferentialSkeleton* self,
395 const dart::dynamics::JacobianNode* _node,
396 const Eigen::Vector3d& _localOffset,
397 const dart::dynamics::Frame* _inCoordinatesOf)
398 -> dart::math::Jacobian {
399 return self->getJacobianClassicDeriv(
400 _node, _localOffset, _inCoordinatesOf);
401 },
402 ::py::arg("node"),
403 ::py::arg("localOffset"),
404 ::py::arg("inCoordinatesOf"))
405 .def(
406 "getLinearJacobianDeriv",
407 +[](const dart::dynamics::ReferentialSkeleton* self,
408 const dart::dynamics::JacobianNode* _node)
409 -> dart::math::LinearJacobian {
410 return self->getLinearJacobianDeriv(_node);
411 },
412 ::py::arg("node"))
413 .def(
414 "getLinearJacobianDeriv",
415 +[](const dart::dynamics::ReferentialSkeleton* self,
416 const dart::dynamics::JacobianNode* _node,
417 const dart::dynamics::Frame* _inCoordinatesOf)
418 -> dart::math::LinearJacobian {
419 return self->getLinearJacobianDeriv(_node, _inCoordinatesOf);
420 },
421 ::py::arg("node"),
422 ::py::arg("inCoordinatesOf"))
423 .def(
424 "getLinearJacobianDeriv",
425 +[](const dart::dynamics::ReferentialSkeleton* self,
426 const dart::dynamics::JacobianNode* _node,
427 const Eigen::Vector3d& _localOffset)
428 -> dart::math::LinearJacobian {
429 return self->getLinearJacobianDeriv(_node, _localOffset);
430 },
431 ::py::arg("node"),
432 ::py::arg("localOffset"))
433 .def(
434 "getLinearJacobianDeriv",
435 +[](const dart::dynamics::ReferentialSkeleton* self,
436 const dart::dynamics::JacobianNode* _node,
437 const Eigen::Vector3d& _localOffset,
438 const dart::dynamics::Frame* _inCoordinatesOf)
439 -> dart::math::LinearJacobian {
440 return self->getLinearJacobianDeriv(
441 _node, _localOffset, _inCoordinatesOf);
442 },
443 ::py::arg("node"),
444 ::py::arg("localOffset"),
445 ::py::arg("inCoordinatesOf"))
446 .def(
447 "getAngularJacobianDeriv",
448 +[](const dart::dynamics::ReferentialSkeleton* self,
449 const dart::dynamics::JacobianNode* _node)
450 -> dart::math::AngularJacobian {
451 return self->getAngularJacobianDeriv(_node);
452 },
453 ::py::arg("node"))
454 .def(
455 "getAngularJacobianDeriv",
456 +[](const dart::dynamics::ReferentialSkeleton* self,
457 const dart::dynamics::JacobianNode* _node,
458 const dart::dynamics::Frame* _inCoordinatesOf)
459 -> dart::math::AngularJacobian {
460 return self->getAngularJacobianDeriv(_node, _inCoordinatesOf);
461 },
462 ::py::arg("node"),
463 ::py::arg("inCoordinatesOf"))
464 .def(
465 "getMass",
466 +[](const dart::dynamics::ReferentialSkeleton* self) -> double {
467 return self->getMass();
468 })
469 .def(
470 "clearExternalForces",
471 +[](dart::dynamics::ReferentialSkeleton* self) {
472 self->clearExternalForces();
473 })
474 .def(
475 "clearInternalForces",
476 +[](dart::dynamics::ReferentialSkeleton* self) {
477 self->clearInternalForces();
478 })
479 .def(
480 "computeKineticEnergy",
481 +[](const dart::dynamics::ReferentialSkeleton* self) -> double {
482 return self->computeKineticEnergy();
483 })
484 .def(
485 "computePotentialEnergy",
486 +[](const dart::dynamics::ReferentialSkeleton* self) -> double {
487 return self->computePotentialEnergy();
488 })
489 // .def(
490 // "clearCollidingBodies",
491 // +[](dart::dynamics::ReferentialSkeleton* self) {
492 // self->clearCollidingBodies();
493 // })
494 .def(
495 "getCOM",
496 +[](const dart::dynamics::ReferentialSkeleton* self)
497 -> Eigen::Vector3d { return self->getCOM(); })
498 .def(
499 "getCOM",
500 +[](const dart::dynamics::ReferentialSkeleton* self,
501 const dart::dynamics::Frame* _withRespectTo) -> Eigen::Vector3d {
502 return self->getCOM(_withRespectTo);
503 },
504 ::py::arg("withRespectTo"))
505 .def(
506 "getCOMSpatialVelocity",
507 +[](const dart::dynamics::ReferentialSkeleton* self)
508 -> Eigen::Vector6d { return self->getCOMSpatialVelocity(); })
509 .def(
510 "getCOMSpatialVelocity",
511 +[](const dart::dynamics::ReferentialSkeleton* self,
512 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector6d {
513 return self->getCOMSpatialVelocity(_relativeTo);
514 },
515 ::py::arg("relativeTo"))
516 .def(
517 "getCOMSpatialVelocity",
518 +[](const dart::dynamics::ReferentialSkeleton* self,
519 const dart::dynamics::Frame* _relativeTo,
520 const dart::dynamics::Frame* _inCoordinatesOf)
521 -> Eigen::Vector6d {
522 return self->getCOMSpatialVelocity(_relativeTo, _inCoordinatesOf);
523 },
524 ::py::arg("relativeTo"),
525 ::py::arg("inCoordinatesOf"))
526 .def(
527 "getCOMLinearVelocity",
528 +[](const dart::dynamics::ReferentialSkeleton* self)
529 -> Eigen::Vector3d { return self->getCOMLinearVelocity(); })
530 .def(
531 "getCOMLinearVelocity",
532 +[](const dart::dynamics::ReferentialSkeleton* self,
533 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector3d {
534 return self->getCOMLinearVelocity(_relativeTo);
535 },
536 ::py::arg("relativeTo"))
537 .def(
538 "getCOMLinearVelocity",
539 +[](const dart::dynamics::ReferentialSkeleton* self,
540 const dart::dynamics::Frame* _relativeTo,
541 const dart::dynamics::Frame* _inCoordinatesOf)
542 -> Eigen::Vector3d {
543 return self->getCOMLinearVelocity(_relativeTo, _inCoordinatesOf);
544 },
545 ::py::arg("relativeTo"),
546 ::py::arg("inCoordinatesOf"))
547 .def(
548 "getCOMSpatialAcceleration",
549 +[](const dart::dynamics::ReferentialSkeleton* self)
550 -> Eigen::Vector6d { return self->getCOMSpatialAcceleration(); })
551 .def(
552 "getCOMSpatialAcceleration",
553 +[](const dart::dynamics::ReferentialSkeleton* self,
554 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector6d {
555 return self->getCOMSpatialAcceleration(_relativeTo);
556 },
557 ::py::arg("relativeTo"))
558 .def(
559 "getCOMSpatialAcceleration",
560 +[](const dart::dynamics::ReferentialSkeleton* self,
561 const dart::dynamics::Frame* _relativeTo,
562 const dart::dynamics::Frame* _inCoordinatesOf)
563 -> Eigen::Vector6d {
564 return self->getCOMSpatialAcceleration(
565 _relativeTo, _inCoordinatesOf);
566 },
567 ::py::arg("relativeTo"),
568 ::py::arg("inCoordinatesOf"))
569 .def(
570 "getCOMLinearAcceleration",
571 +[](const dart::dynamics::ReferentialSkeleton* self)
572 -> Eigen::Vector3d { return self->getCOMLinearAcceleration(); })
573 .def(
574 "getCOMLinearAcceleration",
575 +[](const dart::dynamics::ReferentialSkeleton* self,
576 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector3d {
577 return self->getCOMLinearAcceleration(_relativeTo);
578 },
579 ::py::arg("relativeTo"))
580 .def(
581 "getCOMLinearAcceleration",
582 +[](const dart::dynamics::ReferentialSkeleton* self,
583 const dart::dynamics::Frame* _relativeTo,
584 const dart::dynamics::Frame* _inCoordinatesOf)
585 -> Eigen::Vector3d {
586 return self->getCOMLinearAcceleration(
587 _relativeTo, _inCoordinatesOf);
588 },
589 ::py::arg("relativeTo"),
590 ::py::arg("inCoordinatesOf"))
591 .def(
592 "getCOMJacobian",
593 +[](const dart::dynamics::ReferentialSkeleton* self)
594 -> dart::math::Jacobian { return self->getCOMJacobian(); })
595 .def(
596 "getCOMJacobian",
597 +[](const dart::dynamics::ReferentialSkeleton* self,
598 const dart::dynamics::Frame* _inCoordinatesOf)
599 -> dart::math::Jacobian {
600 return self->getCOMJacobian(_inCoordinatesOf);
601 },
602 ::py::arg("inCoordinatesOf"))
603 .def(
604 "getCOMLinearJacobian",
605 +[](const dart::dynamics::ReferentialSkeleton* self)
606 -> dart::math::LinearJacobian {
607 return self->getCOMLinearJacobian();
608 })
609 .def(
610 "getCOMLinearJacobian",
611 +[](const dart::dynamics::ReferentialSkeleton* self,
612 const dart::dynamics::Frame* _inCoordinatesOf)
613 -> dart::math::LinearJacobian {
614 return self->getCOMLinearJacobian(_inCoordinatesOf);
615 },
616 ::py::arg("inCoordinatesOf"))
617 .def(
618 "getCOMJacobianSpatialDeriv",
619 +[](const dart::dynamics::ReferentialSkeleton* self)
620 -> dart::math::Jacobian {
621 return self->getCOMJacobianSpatialDeriv();
622 })
623 .def(
624 "getCOMJacobianSpatialDeriv",
625 +[](const dart::dynamics::ReferentialSkeleton* self,
626 const dart::dynamics::Frame* _inCoordinatesOf)
627 -> dart::math::Jacobian {
628 return self->getCOMJacobianSpatialDeriv(_inCoordinatesOf);
629 },
630 ::py::arg("inCoordinatesOf"))
631 .def(
632 "getCOMLinearJacobianDeriv",
633 +[](const dart::dynamics::ReferentialSkeleton* self)
634 -> dart::math::LinearJacobian {
635 return self->getCOMLinearJacobianDeriv();
636 })
637 .def(
638 "getCOMLinearJacobianDeriv",
639 +[](const dart::dynamics::ReferentialSkeleton* self,
640 const dart::dynamics::Frame* _inCoordinatesOf)
641 -> dart::math::LinearJacobian {
642 return self->getCOMLinearJacobianDeriv(_inCoordinatesOf);
643 },
644 ::py::arg("inCoordinatesOf"));
645 }
646
647 } // namespace python
648 } // namespace dart