Debian Codegraph @

python/dartpy/dynamics/Skeleton.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 #include <pybind11/stl.h>
36
37 #include "eigen_geometry_pybind.h"
38 #include "eigen_pybind.h"
39
40 namespace py = pybind11;
41
42 #define DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(joint_type) \
43 .def( \
44 "create" #joint_type "AndBodyNodePair", \
45 +[](dart::dynamics::Skeleton* self) \
46 -> std:: \
47 pair<dart::dynamics::joint_type*, dart::dynamics::BodyNode*> { \
48 return self->createJointAndBodyNodePair< \
49 dart::dynamics::joint_type, \
50 dart::dynamics::BodyNode>(); \
51 }, \
52 ::py::return_value_policy::reference_internal) \
53 .def( \
54 "create" #joint_type "AndBodyNodePair", \
55 +[](dart::dynamics::Skeleton* self, \
56 dart::dynamics::BodyNode* parent) \
57 -> std::pair< \
58 dart::dynamics::joint_type*, \
59 dart::dynamics::BodyNode*> { \
60 return self->createJointAndBodyNodePair< \
61 dart::dynamics::joint_type, \
62 dart::dynamics::BodyNode>(parent); \
63 }, \
64 ::py::return_value_policy::reference_internal, \
65 ::py::arg("parent")) \
66 .def( \
67 "create" #joint_type "AndBodyNodePair", \
68 +[](dart::dynamics::Skeleton* self, \
69 dart::dynamics::BodyNode* parent, \
70 const dart::dynamics::joint_type::Properties& jointProperties) \
71 -> std::pair< \
72 dart::dynamics::joint_type*, \
73 dart::dynamics::BodyNode*> { \
74 return self->createJointAndBodyNodePair< \
75 dart::dynamics::joint_type, \
76 dart::dynamics::BodyNode>(parent, jointProperties); \
77 }, \
78 ::py::return_value_policy::reference_internal, \
79 ::py::arg("parent"), \
80 ::py::arg("jointProperties")) \
81 .def( \
82 "create" #joint_type "AndBodyNodePair", \
83 +[](dart::dynamics::Skeleton* self, \
84 dart::dynamics::BodyNode* parent, \
85 const dart::dynamics::joint_type::Properties& jointProperties, \
86 const dart::dynamics::BodyNode::Properties& bodyProperties) \
87 -> std::pair< \
88 dart::dynamics::joint_type*, \
89 dart::dynamics::BodyNode*> { \
90 return self->createJointAndBodyNodePair< \
91 dart::dynamics::joint_type, \
92 dart::dynamics::BodyNode>( \
93 parent, jointProperties, bodyProperties); \
94 }, \
95 ::py::return_value_policy::reference_internal, \
96 ::py::arg("parent").none(true), \
97 ::py::arg("jointProperties"), \
98 ::py::arg("bodyProperties"))
99
100 namespace dart {
101 namespace python {
102
103 void Skeleton(py::module& m)
104 {
105 ::py::class_<
106 dart::dynamics::Skeleton,
107 dart::dynamics::MetaSkeleton,
108 std::shared_ptr<dart::dynamics::Skeleton>>(m, "Skeleton")
109 .def(::py::init(+[]() -> dart::dynamics::SkeletonPtr {
110 return dart::dynamics::Skeleton::create();
111 }))
112 .def(
113 ::py::init(
114 +[](const std::string& _name) -> dart::dynamics::SkeletonPtr {
115 return dart::dynamics::Skeleton::create(_name);
116 }),
117 ::py::arg("name"))
118 .def(
119 ::py::init(
120 +[](const dart::dynamics::Skeleton::AspectPropertiesData&
121 properties) -> dart::dynamics::SkeletonPtr {
122 return dart::dynamics::Skeleton::create(properties);
123 }),
124 ::py::arg("properties"))
125 .def(
126 "getPtr",
127 +[](dart::dynamics::Skeleton* self) -> dart::dynamics::SkeletonPtr {
128 return self->getPtr();
129 })
130 .def(
131 "getPtr",
132 +[](const dart::dynamics::Skeleton* self)
133 -> dart::dynamics::ConstSkeletonPtr { return self->getPtr(); })
134 .def(
135 "getSkeleton",
136 +[](dart::dynamics::Skeleton* self) -> dart::dynamics::SkeletonPtr {
137 return self->getSkeleton();
138 })
139 .def(
140 "getSkeleton",
141 +[](const dart::dynamics::Skeleton* self)
142 -> dart::dynamics::ConstSkeletonPtr {
143 return self->getSkeleton();
144 })
145 .def(
146 "getLockableReference",
147 +[](const dart::dynamics::Skeleton* self)
148 -> std::unique_ptr<dart::common::LockableReference> {
149 return self->getLockableReference();
150 })
151 .def(
152 "clone",
153 +[](const dart::dynamics::Skeleton* self)
154 -> dart::dynamics::SkeletonPtr { return self->cloneSkeleton(); })
155 .def(
156 "clone",
157 +[](const dart::dynamics::Skeleton* self,
158 const std::string& cloneName) -> dart::dynamics::SkeletonPtr {
159 return self->cloneSkeleton(cloneName);
160 },
161 ::py::arg("cloneName"))
162 .def(
163 "setConfiguration",
164 +[](dart::dynamics::Skeleton* self,
165 const dart::dynamics::Skeleton::Configuration& configuration)
166 -> void { return self->setConfiguration(configuration); },
167 ::py::arg("configuration"))
168 .def(
169 "getConfiguration",
170 +[](const dart::dynamics::Skeleton* self)
171 -> dart::dynamics::Skeleton::Configuration {
172 return self->getConfiguration();
173 })
174 .def(
175 "getConfiguration",
176 +[](const dart::dynamics::Skeleton* self,
177 int flags) -> dart::dynamics::Skeleton::Configuration {
178 return self->getConfiguration(flags);
179 },
180 ::py::arg("flags"))
181 .def(
182 "getConfiguration",
183 +[](const dart::dynamics::Skeleton* self,
184 const std::vector<std::size_t>& indices)
185 -> dart::dynamics::Skeleton::Configuration {
186 return self->getConfiguration(indices);
187 },
188 ::py::arg("indices"))
189 .def(
190 "getConfiguration",
191 +[](const dart::dynamics::Skeleton* self,
192 const std::vector<std::size_t>& indices,
193 int flags) -> dart::dynamics::Skeleton::Configuration {
194 return self->getConfiguration(indices, flags);
195 },
196 ::py::arg("indices"),
197 ::py::arg("flags"))
198 .def(
199 "setState",
200 +[](dart::dynamics::Skeleton* self,
201 const dart::dynamics::Skeleton::State& state) -> void {
202 return self->setState(state);
203 },
204 ::py::arg("state"))
205 .def(
206 "getState",
207 +[](const dart::dynamics::Skeleton* self)
208 -> dart::dynamics::Skeleton::State { return self->getState(); })
209 .def(
210 "setProperties",
211 +[](dart::dynamics::Skeleton* self,
212 const dart::dynamics::Skeleton::Properties& properties) -> void {
213 return self->setProperties(properties);
214 },
215 ::py::arg("properties"))
216 .def(
217 "getProperties",
218 +[](const dart::dynamics::Skeleton* self)
219 -> dart::dynamics::Skeleton::Properties {
220 return self->getProperties();
221 })
222 .def(
223 "setProperties",
224 +[](dart::dynamics::Skeleton* self,
225 const dart::dynamics::Skeleton::AspectProperties& properties)
226 -> void { return self->setProperties(properties); },
227 ::py::arg("properties"))
228 .def(
229 "setAspectProperties",
230 +[](dart::dynamics::Skeleton* self,
231 const dart::dynamics::Skeleton::AspectProperties& properties)
232 -> void { return self->setAspectProperties(properties); },
233 ::py::arg("properties"))
234 .def(
235 "setName",
236 +[](dart::dynamics::Skeleton* self, const std::string& _name)
237 -> const std::string& { return self->setName(_name); },
238 ::py::return_value_policy::reference_internal,
239 ::py::arg("name"))
240 .def(
241 "getName",
242 +[](const dart::dynamics::Skeleton* self) -> const std::string& {
243 return self->getName();
244 },
245 ::py::return_value_policy::reference_internal)
246 .def(
247 "setSelfCollisionCheck",
248 +[](dart::dynamics::Skeleton* self, bool enable) -> void {
249 return self->setSelfCollisionCheck(enable);
250 },
251 ::py::arg("enable"))
252 .def(
253 "getSelfCollisionCheck",
254 +[](const dart::dynamics::Skeleton* self) -> bool {
255 return self->getSelfCollisionCheck();
256 })
257 .def(
258 "enableSelfCollisionCheck",
259 +[](dart::dynamics::Skeleton* self) -> void {
260 return self->enableSelfCollisionCheck();
261 })
262 .def(
263 "disableSelfCollisionCheck",
264 +[](dart::dynamics::Skeleton* self) -> void {
265 return self->disableSelfCollisionCheck();
266 })
267 .def(
268 "isEnabledSelfCollisionCheck",
269 +[](const dart::dynamics::Skeleton* self) -> bool {
270 return self->isEnabledSelfCollisionCheck();
271 })
272 .def(
273 "setAdjacentBodyCheck",
274 +[](dart::dynamics::Skeleton* self, bool enable) -> void {
275 return self->setAdjacentBodyCheck(enable);
276 },
277 ::py::arg("enable"))
278 .def(
279 "getAdjacentBodyCheck",
280 +[](const dart::dynamics::Skeleton* self) -> bool {
281 return self->getAdjacentBodyCheck();
282 })
283 .def(
284 "enableAdjacentBodyCheck",
285 +[](dart::dynamics::Skeleton* self) -> void {
286 return self->enableAdjacentBodyCheck();
287 })
288 .def(
289 "disableAdjacentBodyCheck",
290 +[](dart::dynamics::Skeleton* self) -> void {
291 return self->disableAdjacentBodyCheck();
292 })
293 .def(
294 "isEnabledAdjacentBodyCheck",
295 +[](const dart::dynamics::Skeleton* self) -> bool {
296 return self->isEnabledAdjacentBodyCheck();
297 })
298 .def(
299 "setMobile",
300 +[](dart::dynamics::Skeleton* self, bool _isMobile) -> void {
301 return self->setMobile(_isMobile);
302 },
303 ::py::arg("isMobile"))
304 .def(
305 "isMobile",
306 +[](const dart::dynamics::Skeleton* self) -> bool {
307 return self->isMobile();
308 })
309 .def(
310 "setTimeStep",
311 +[](dart::dynamics::Skeleton* self, double _timeStep) -> void {
312 return self->setTimeStep(_timeStep);
313 },
314 ::py::arg("timeStep"))
315 .def(
316 "getTimeStep",
317 +[](const dart::dynamics::Skeleton* self) -> double {
318 return self->getTimeStep();
319 })
320 .def(
321 "setGravity",
322 +[](dart::dynamics::Skeleton* self, const Eigen::Vector3d& _gravity)
323 -> void { return self->setGravity(_gravity); },
324 ::py::arg("gravity"))
325 .def(
326 "getGravity",
327 +[](const dart::dynamics::Skeleton* self) -> const Eigen::Vector3d& {
328 return self->getGravity();
329 },
330 ::py::return_value_policy::reference_internal)
331 // clang-format off
332 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(WeldJoint)
333 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(RevoluteJoint)
334 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(PrismaticJoint)
335 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(ScrewJoint)
336 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(UniversalJoint)
337 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(TranslationalJoint2D)
338 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(PlanarJoint)
339 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(EulerJoint)
340 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(BallJoint)
341 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(TranslationalJoint)
342 DARTPY_DEFINE_CREATE_JOINT_AND_BODY_NODE_PAIR(FreeJoint)
343 // clang-format on
344 .def(
345 "getNumBodyNodes",
346 +[](const dart::dynamics::Skeleton* self) -> std::size_t {
347 return self->getNumBodyNodes();
348 })
349 .def(
350 "getNumRigidBodyNodes",
351 +[](const dart::dynamics::Skeleton* self) -> std::size_t {
352 return self->getNumRigidBodyNodes();
353 })
354 .def(
355 "getNumSoftBodyNodes",
356 +[](const dart::dynamics::Skeleton* self) -> std::size_t {
357 return self->getNumSoftBodyNodes();
358 })
359 .def(
360 "getNumTrees",
361 +[](const dart::dynamics::Skeleton* self) -> std::size_t {
362 return self->getNumTrees();
363 })
364 .def(
365 "getRootBodyNode",
366 +[](dart::dynamics::Skeleton* self) -> dart::dynamics::BodyNode* {
367 return self->getRootBodyNode();
368 },
369 py::return_value_policy::reference)
370 .def(
371 "getRootBodyNode",
372 +[](dart::dynamics::Skeleton* self,
373 std::size_t index) -> dart::dynamics::BodyNode* {
374 return self->getRootBodyNode(index);
375 },
376 ::py::arg("treeIndex"),
377 py::return_value_policy::reference)
378 .def(
379 "getRootJoint",
380 +[](dart::dynamics::Skeleton* self) -> dart::dynamics::Joint* {
381 return self->getRootJoint();
382 },
383 py::return_value_policy::reference_internal)
384 .def(
385 "getRootJoint",
386 +[](dart::dynamics::Skeleton* self, std::size_t index)
387 -> dart::dynamics::Joint* { return self->getRootJoint(index); },
388 ::py::arg("treeIndex"),
389 py::return_value_policy::reference_internal)
390 .def(
391 "getBodyNodes",
392 +[](dart::dynamics::Skeleton* self)
393 -> const std::vector<dart::dynamics::BodyNode*>& {
394 return self->getBodyNodes();
395 })
396 .def(
397 "getBodyNodes",
398 +[](dart::dynamics::Skeleton* self, const std::string& name)
399 -> std::vector<dart::dynamics::BodyNode*> {
400 return self->getBodyNodes(name);
401 },
402 ::py::arg("name"))
403 .def(
404 "getBodyNodes",
405 +[](const dart::dynamics::Skeleton* self, const std::string& name)
406 -> std::vector<const dart::dynamics::BodyNode*> {
407 return self->getBodyNodes(name);
408 },
409 ::py::arg("name"))
410 .def(
411 "hasBodyNode",
412 +[](const dart::dynamics::Skeleton* self,
413 const dart::dynamics::BodyNode* bodyNode) -> bool {
414 return self->hasBodyNode(bodyNode);
415 },
416 ::py::arg("bodyNode"))
417 .def(
418 "getIndexOf",
419 +[](const dart::dynamics::Skeleton* self,
420 const dart::dynamics::BodyNode* _bn) -> std::size_t {
421 return self->getIndexOf(_bn);
422 },
423 ::py::arg("bn"))
424 .def(
425 "getIndexOf",
426 +[](const dart::dynamics::Skeleton* self,
427 const dart::dynamics::BodyNode* _bn,
428 bool _warning) -> std::size_t {
429 return self->getIndexOf(_bn, _warning);
430 },
431 ::py::arg("bn"),
432 ::py::arg("warning"))
433 .def(
434 "getTreeBodyNodes",
435 +[](const dart::dynamics::Skeleton* self, std::size_t _treeIdx)
436 -> std::vector<const dart::dynamics::BodyNode*> {
437 return self->getTreeBodyNodes(_treeIdx);
438 },
439 ::py::arg("treeIdx"))
440 .def(
441 "getNumJoints",
442 +[](const dart::dynamics::Skeleton* self) -> std::size_t {
443 return self->getNumJoints();
444 })
445 .def(
446 "getJoint",
447 +[](dart::dynamics::Skeleton* self, std::size_t _idx)
448 -> dart::dynamics::Joint* { return self->getJoint(_idx); },
449 ::py::arg("idx"),
450 py::return_value_policy::reference_internal)
451 .def(
452 "getJoint",
453 +[](dart::dynamics::Skeleton* self, const std::string& name)
454 -> dart::dynamics::Joint* { return self->getJoint(name); },
455 ::py::arg("name"),
456 py::return_value_policy::reference_internal)
457 .def(
458 "getJoints",
459 +[](dart::dynamics::Skeleton* self)
460 -> std::vector<dart::dynamics::Joint*> {
461 return self->getJoints();
462 })
463 .def(
464 "getJoints",
465 +[](const dart::dynamics::Skeleton* self)
466 -> std::vector<const dart::dynamics::Joint*> {
467 return self->getJoints();
468 })
469 .def(
470 "getJoints",
471 +[](dart::dynamics::Skeleton* self,
472 const std::string& name) -> std::vector<dart::dynamics::Joint*> {
473 return self->getJoints(name);
474 },
475 ::py::arg("name"))
476 .def(
477 "getJoints",
478 +[](const dart::dynamics::Skeleton* self, const std::string& name)
479 -> std::vector<const dart::dynamics::Joint*> {
480 return self->getJoints(name);
481 },
482 ::py::arg("name"))
483 .def(
484 "hasJoint",
485 +[](const dart::dynamics::Skeleton* self,
486 const dart::dynamics::Joint* joint) -> bool {
487 return self->hasJoint(joint);
488 },
489 ::py::arg("joint"))
490 .def(
491 "getIndexOf",
492 +[](const dart::dynamics::Skeleton* self,
493 const dart::dynamics::Joint* _joint) -> std::size_t {
494 return self->getIndexOf(_joint);
495 },
496 ::py::arg("joint"))
497 .def(
498 "getIndexOf",
499 +[](const dart::dynamics::Skeleton* self,
500 const dart::dynamics::Joint* _joint,
501 bool _warning) -> std::size_t {
502 return self->getIndexOf(_joint, _warning);
503 },
504 ::py::arg("joint"),
505 ::py::arg("warning"))
506 .def(
507 "getNumDofs",
508 +[](const dart::dynamics::Skeleton* self) -> std::size_t {
509 return self->getNumDofs();
510 })
511 .def(
512 "getDof",
513 +[](dart::dynamics::Skeleton* self,
514 std::size_t index) -> dart::dynamics::DegreeOfFreedom* {
515 return self->getDof(index);
516 },
517 ::py::return_value_policy::reference_internal,
518 ::py::arg("index"))
519 .def(
520 "getDof",
521 +[](dart::dynamics::Skeleton* self,
522 const std::string& name) -> dart::dynamics::DegreeOfFreedom* {
523 return self->getDof(name);
524 },
525 ::py::return_value_policy::reference_internal,
526 ::py::arg("name"))
527 .def(
528 "getDofs",
529 +[](const dart::dynamics::Skeleton* self)
530 -> std::vector<const dart::dynamics::DegreeOfFreedom*> {
531 return self->getDofs();
532 })
533 .def(
534 "getIndexOf",
535 +[](const dart::dynamics::Skeleton* self,
536 const dart::dynamics::DegreeOfFreedom* _dof) -> std::size_t {
537 return self->getIndexOf(_dof);
538 },
539 ::py::arg("dof"))
540 .def(
541 "getIndexOf",
542 +[](const dart::dynamics::Skeleton* self,
543 const dart::dynamics::DegreeOfFreedom* _dof,
544 bool _warning) -> std::size_t {
545 return self->getIndexOf(_dof, _warning);
546 },
547 ::py::arg("dof"),
548 ::py::arg("warning"))
549 .def(
550 "checkIndexingConsistency",
551 +[](const dart::dynamics::Skeleton* self) -> bool {
552 return self->checkIndexingConsistency();
553 })
554 .def(
555 "getIK",
556 +[](const dart::dynamics::Skeleton* self)
557 -> std::shared_ptr<const dart::dynamics::WholeBodyIK> {
558 return self->getIK();
559 })
560 .def(
561 "clearIK",
562 +[](dart::dynamics::Skeleton* self)
563 -> void { return self->clearIK(); })
564 .def(
565 "getNumMarkers",
566 +[](const dart::dynamics::Skeleton* self) -> std::size_t {
567 return self->getNumMarkers();
568 })
569 .def(
570 "getNumMarkers",
571 +[](const dart::dynamics::Skeleton* self, std::size_t treeIndex)
572 -> std::size_t { return self->getNumMarkers(treeIndex); },
573 ::py::arg("treeIndex"))
574 .def(
575 "getNumShapeNodes",
576 +[](const dart::dynamics::Skeleton* self) -> std::size_t {
577 return self->getNumShapeNodes();
578 })
579 .def(
580 "getNumShapeNodes",
581 +[](const dart::dynamics::Skeleton* self, std::size_t treeIndex)
582 -> std::size_t { return self->getNumShapeNodes(treeIndex); },
583 ::py::arg("treeIndex"))
584 .def(
585 "getShapeNode",
586 +[](dart::dynamics::Skeleton* self,
587 std::size_t index) -> dart::dynamics::ShapeNode* {
588 return self->getShapeNode(index);
589 },
590 ::py::return_value_policy::reference_internal,
591 ::py::arg("index"))
592 .def(
593 "getShapeNode",
594 +[](dart::dynamics::Skeleton* self,
595 const std::string& name) -> dart::dynamics::ShapeNode* {
596 return self->getShapeNode(name);
597 },
598 ::py::return_value_policy::reference_internal,
599 ::py::arg("name"))
600 .def(
601 "getNumEndEffectors",
602 +[](const dart::dynamics::Skeleton* self) -> std::size_t {
603 return self->getNumEndEffectors();
604 })
605 .def(
606 "getNumEndEffectors",
607 +[](const dart::dynamics::Skeleton* self, std::size_t treeIndex)
608 -> std::size_t { return self->getNumEndEffectors(treeIndex); },
609 ::py::arg("treeIndex"))
610 .def(
611 "integratePositions",
612 +[](dart::dynamics::Skeleton* self, double _dt) -> void {
613 return self->integratePositions(_dt);
614 },
615 ::py::arg("dt"))
616 .def(
617 "integrateVelocities",
618 +[](dart::dynamics::Skeleton* self, double _dt) -> void {
619 return self->integrateVelocities(_dt);
620 },
621 ::py::arg("dt"))
622 .def(
623 "getPositionDifferences",
624 +[](const dart::dynamics::Skeleton* self,
625 const Eigen::VectorXd& _q2,
626 const Eigen::VectorXd& _q1) -> Eigen::VectorXd {
627 return self->getPositionDifferences(_q2, _q1);
628 },
629 ::py::arg("q2"),
630 ::py::arg("q1"))
631 .def(
632 "getVelocityDifferences",
633 +[](const dart::dynamics::Skeleton* self,
634 const Eigen::VectorXd& _dq2,
635 const Eigen::VectorXd& _dq1) -> Eigen::VectorXd {
636 return self->getVelocityDifferences(_dq2, _dq1);
637 },
638 ::py::arg("dq2"),
639 ::py::arg("dq1"))
640 .def(
641 "getSupportVersion",
642 +[](const dart::dynamics::Skeleton* self) -> std::size_t {
643 return self->getSupportVersion();
644 })
645 .def(
646 "getSupportVersion",
647 +[](const dart::dynamics::Skeleton* self, std::size_t _treeIdx)
648 -> std::size_t { return self->getSupportVersion(_treeIdx); },
649 ::py::arg("treeIdx"))
650 .def(
651 "computeForwardKinematics",
652 +[](dart::dynamics::Skeleton* self) -> void {
653 return self->computeForwardKinematics();
654 })
655 .def(
656 "computeForwardKinematics",
657 +[](dart::dynamics::Skeleton* self, bool _updateTransforms) -> void {
658 return self->computeForwardKinematics(_updateTransforms);
659 },
660 ::py::arg("updateTransforms"))
661 .def(
662 "computeForwardKinematics",
663 +[](dart::dynamics::Skeleton* self,
664 bool _updateTransforms,
665 bool _updateVels) -> void {
666 return self->computeForwardKinematics(
667 _updateTransforms, _updateVels);
668 },
669 ::py::arg("updateTransforms"),
670 ::py::arg("updateVels"))
671 .def(
672 "computeForwardKinematics",
673 +[](dart::dynamics::Skeleton* self,
674 bool _updateTransforms,
675 bool _updateVels,
676 bool _updateAccs) -> void {
677 return self->computeForwardKinematics(
678 _updateTransforms, _updateVels, _updateAccs);
679 },
680 ::py::arg("updateTransforms"),
681 ::py::arg("updateVels"),
682 ::py::arg("updateAccs"))
683 .def(
684 "computeForwardDynamics",
685 +[](dart::dynamics::Skeleton* self) -> void {
686 return self->computeForwardDynamics();
687 })
688 .def(
689 "computeInverseDynamics",
690 +[](dart::dynamics::Skeleton* self) -> void {
691 return self->computeInverseDynamics();
692 })
693 .def(
694 "computeInverseDynamics",
695 +[](dart::dynamics::Skeleton* self,
696 bool _withExternalForces) -> void {
697 return self->computeInverseDynamics(_withExternalForces);
698 },
699 ::py::arg("withExternalForces"))
700 .def(
701 "computeInverseDynamics",
702 +[](dart::dynamics::Skeleton* self,
703 bool _withExternalForces,
704 bool _withDampingForces) -> void {
705 return self->computeInverseDynamics(
706 _withExternalForces, _withDampingForces);
707 },
708 ::py::arg("withExternalForces"),
709 ::py::arg("withDampingForces"))
710 .def(
711 "computeInverseDynamics",
712 +[](dart::dynamics::Skeleton* self,
713 bool _withExternalForces,
714 bool _withDampingForces,
715 bool _withSpringForces) -> void {
716 return self->computeInverseDynamics(
717 _withExternalForces, _withDampingForces, _withSpringForces);
718 },
719 ::py::arg("withExternalForces"),
720 ::py::arg("withDampingForces"),
721 ::py::arg("withSpringForces"))
722 .def(
723 "clearConstraintImpulses",
724 +[](dart::dynamics::Skeleton* self) -> void {
725 return self->clearConstraintImpulses();
726 })
727 .def(
728 "updateBiasImpulse",
729 +[](dart::dynamics::Skeleton* self,
730 dart::dynamics::BodyNode* _bodyNode) -> void {
731 return self->updateBiasImpulse(_bodyNode);
732 },
733 ::py::arg("bodyNode"))
734 .def(
735 "updateBiasImpulse",
736 +[](dart::dynamics::Skeleton* self,
737 dart::dynamics::BodyNode* _bodyNode,
738 const Eigen::Vector6d& _imp) -> void {
739 return self->updateBiasImpulse(_bodyNode, _imp);
740 },
741 ::py::arg("bodyNode"),
742 ::py::arg("imp"))
743 .def(
744 "updateBiasImpulse",
745 +[](dart::dynamics::Skeleton* self,
746 dart::dynamics::BodyNode* _bodyNode1,
747 const Eigen::Vector6d& _imp1,
748 dart::dynamics::BodyNode* _bodyNode2,
749 const Eigen::Vector6d& _imp2) -> void {
750 return self->updateBiasImpulse(
751 _bodyNode1, _imp1, _bodyNode2, _imp2);
752 },
753 ::py::arg("bodyNode1"),
754 ::py::arg("imp1"),
755 ::py::arg("bodyNode2"),
756 ::py::arg("imp2"))
757 .def(
758 "updateBiasImpulse",
759 +[](dart::dynamics::Skeleton* self,
760 dart::dynamics::SoftBodyNode* _softBodyNode,
761 dart::dynamics::PointMass* _pointMass,
762 const Eigen::Vector3d& _imp) -> void {
763 return self->updateBiasImpulse(_softBodyNode, _pointMass, _imp);
764 },
765 ::py::arg("softBodyNode"),
766 ::py::arg("pointMass"),
767 ::py::arg("imp"))
768 .def(
769 "updateVelocityChange",
770 +[](dart::dynamics::Skeleton* self)
771 -> void { return self->updateVelocityChange(); })
772 .def(
773 "setImpulseApplied",
774 +[](dart::dynamics::Skeleton* self, bool _val) -> void {
775 return self->setImpulseApplied(_val);
776 },
777 ::py::arg("val"))
778 .def(
779 "isImpulseApplied",
780 +[](const dart::dynamics::Skeleton* self) -> bool {
781 return self->isImpulseApplied();
782 })
783 .def(
784 "computeImpulseForwardDynamics",
785 +[](dart::dynamics::Skeleton* self) -> void {
786 return self->computeImpulseForwardDynamics();
787 })
788 .def(
789 "getJacobian",
790 +[](const dart::dynamics::Skeleton* self,
791 const dart::dynamics::JacobianNode* _node)
792 -> dart::math::Jacobian { return self->getJacobian(_node); },
793 ::py::arg("node"))
794 .def(
795 "getJacobian",
796 +[](const dart::dynamics::Skeleton* self,
797 const dart::dynamics::JacobianNode* _node,
798 const dart::dynamics::Frame* _inCoordinatesOf)
799 -> dart::math::Jacobian {
800 return self->getJacobian(_node, _inCoordinatesOf);
801 },
802 ::py::arg("node"),
803 ::py::arg("inCoordinatesOf"))
804 .def(
805 "getJacobian",
806 +[](const dart::dynamics::Skeleton* self,
807 const dart::dynamics::JacobianNode* _node,
808 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
809 return self->getJacobian(_node, _localOffset);
810 },
811 ::py::arg("node"),
812 ::py::arg("localOffset"))
813 .def(
814 "getJacobian",
815 +[](const dart::dynamics::Skeleton* self,
816 const dart::dynamics::JacobianNode* _node,
817 const Eigen::Vector3d& _localOffset,
818 const dart::dynamics::Frame* _inCoordinatesOf)
819 -> dart::math::Jacobian {
820 return self->getJacobian(_node, _localOffset, _inCoordinatesOf);
821 },
822 ::py::arg("node"),
823 ::py::arg("localOffset"),
824 ::py::arg("inCoordinatesOf"))
825 .def(
826 "getWorldJacobian",
827 +[](const dart::dynamics::Skeleton* self,
828 const dart::dynamics::JacobianNode* _node)
829 -> dart::math::Jacobian { return self->getWorldJacobian(_node); },
830 ::py::arg("node"))
831 .def(
832 "getWorldJacobian",
833 +[](const dart::dynamics::Skeleton* self,
834 const dart::dynamics::JacobianNode* _node,
835 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
836 return self->getWorldJacobian(_node, _localOffset);
837 },
838 ::py::arg("node"),
839 ::py::arg("localOffset"))
840 .def(
841 "getLinearJacobian",
842 +[](const dart::dynamics::Skeleton* self,
843 const dart::dynamics::JacobianNode* _node)
844 -> dart::math::LinearJacobian {
845 return self->getLinearJacobian(_node);
846 },
847 ::py::arg("node"))
848 .def(
849 "getLinearJacobian",
850 +[](const dart::dynamics::Skeleton* self,
851 const dart::dynamics::JacobianNode* _node,
852 const dart::dynamics::Frame* _inCoordinatesOf)
853 -> dart::math::LinearJacobian {
854 return self->getLinearJacobian(_node, _inCoordinatesOf);
855 },
856 ::py::arg("node"),
857 ::py::arg("inCoordinatesOf"))
858 .def(
859 "getLinearJacobian",
860 +[](const dart::dynamics::Skeleton* self,
861 const dart::dynamics::JacobianNode* _node,
862 const Eigen::Vector3d& _localOffset)
863 -> dart::math::LinearJacobian {
864 return self->getLinearJacobian(_node, _localOffset);
865 },
866 ::py::arg("node"),
867 ::py::arg("localOffset"))
868 .def(
869 "getLinearJacobian",
870 +[](const dart::dynamics::Skeleton* self,
871 const dart::dynamics::JacobianNode* _node,
872 const Eigen::Vector3d& _localOffset,
873 const dart::dynamics::Frame* _inCoordinatesOf)
874 -> dart::math::LinearJacobian {
875 return self->getLinearJacobian(
876 _node, _localOffset, _inCoordinatesOf);
877 },
878 ::py::arg("node"),
879 ::py::arg("localOffset"),
880 ::py::arg("inCoordinatesOf"))
881 .def(
882 "getAngularJacobian",
883 +[](const dart::dynamics::Skeleton* self,
884 const dart::dynamics::JacobianNode* _node)
885 -> dart::math::AngularJacobian {
886 return self->getAngularJacobian(_node);
887 },
888 ::py::arg("node"))
889 .def(
890 "getAngularJacobian",
891 +[](const dart::dynamics::Skeleton* self,
892 const dart::dynamics::JacobianNode* _node,
893 const dart::dynamics::Frame* _inCoordinatesOf)
894 -> dart::math::AngularJacobian {
895 return self->getAngularJacobian(_node, _inCoordinatesOf);
896 },
897 ::py::arg("node"),
898 ::py::arg("inCoordinatesOf"))
899 .def(
900 "getJacobianSpatialDeriv",
901 +[](const dart::dynamics::Skeleton* self,
902 const dart::dynamics::JacobianNode* _node)
903 -> dart::math::Jacobian {
904 return self->getJacobianSpatialDeriv(_node);
905 },
906 ::py::arg("node"))
907 .def(
908 "getJacobianSpatialDeriv",
909 +[](const dart::dynamics::Skeleton* self,
910 const dart::dynamics::JacobianNode* _node,
911 const dart::dynamics::Frame* _inCoordinatesOf)
912 -> dart::math::Jacobian {
913 return self->getJacobianSpatialDeriv(_node, _inCoordinatesOf);
914 },
915 ::py::arg("node"),
916 ::py::arg("inCoordinatesOf"))
917 .def(
918 "getJacobianSpatialDeriv",
919 +[](const dart::dynamics::Skeleton* self,
920 const dart::dynamics::JacobianNode* _node,
921 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
922 return self->getJacobianSpatialDeriv(_node, _localOffset);
923 },
924 ::py::arg("node"),
925 ::py::arg("localOffset"))
926 .def(
927 "getJacobianSpatialDeriv",
928 +[](const dart::dynamics::Skeleton* self,
929 const dart::dynamics::JacobianNode* _node,
930 const Eigen::Vector3d& _localOffset,
931 const dart::dynamics::Frame* _inCoordinatesOf)
932 -> dart::math::Jacobian {
933 return self->getJacobianSpatialDeriv(
934 _node, _localOffset, _inCoordinatesOf);
935 },
936 ::py::arg("node"),
937 ::py::arg("localOffset"),
938 ::py::arg("inCoordinatesOf"))
939 .def(
940 "getJacobianClassicDeriv",
941 +[](const dart::dynamics::Skeleton* self,
942 const dart::dynamics::JacobianNode* _node)
943 -> dart::math::Jacobian {
944 return self->getJacobianClassicDeriv(_node);
945 },
946 ::py::arg("node"))
947 .def(
948 "getJacobianClassicDeriv",
949 +[](const dart::dynamics::Skeleton* self,
950 const dart::dynamics::JacobianNode* _node,
951 const dart::dynamics::Frame* _inCoordinatesOf)
952 -> dart::math::Jacobian {
953 return self->getJacobianClassicDeriv(_node, _inCoordinatesOf);
954 },
955 ::py::arg("node"),
956 ::py::arg("inCoordinatesOf"))
957 .def(
958 "getJacobianClassicDeriv",
959 +[](const dart::dynamics::Skeleton* self,
960 const dart::dynamics::JacobianNode* _node,
961 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
962 return self->getJacobianClassicDeriv(_node, _localOffset);
963 },
964 ::py::arg("node"),
965 ::py::arg("localOffset"))
966 .def(
967 "getJacobianClassicDeriv",
968 +[](const dart::dynamics::Skeleton* self,
969 const dart::dynamics::JacobianNode* _node,
970 const Eigen::Vector3d& _localOffset,
971 const dart::dynamics::Frame* _inCoordinatesOf)
972 -> dart::math::Jacobian {
973 return self->getJacobianClassicDeriv(
974 _node, _localOffset, _inCoordinatesOf);
975 },
976 ::py::arg("node"),
977 ::py::arg("localOffset"),
978 ::py::arg("inCoordinatesOf"))
979 .def(
980 "getLinearJacobianDeriv",
981 +[](const dart::dynamics::Skeleton* self,
982 const dart::dynamics::JacobianNode* _node)
983 -> dart::math::LinearJacobian {
984 return self->getLinearJacobianDeriv(_node);
985 },
986 ::py::arg("node"))
987 .def(
988 "getLinearJacobianDeriv",
989 +[](const dart::dynamics::Skeleton* self,
990 const dart::dynamics::JacobianNode* _node,
991 const dart::dynamics::Frame* _inCoordinatesOf)
992 -> dart::math::LinearJacobian {
993 return self->getLinearJacobianDeriv(_node, _inCoordinatesOf);
994 },
995 ::py::arg("node"),
996 ::py::arg("inCoordinatesOf"))
997 .def(
998 "getLinearJacobianDeriv",
999 +[](const dart::dynamics::Skeleton* self,
1000 const dart::dynamics::JacobianNode* _node,
1001 const Eigen::Vector3d& _localOffset)
1002 -> dart::math::LinearJacobian {
1003 return self->getLinearJacobianDeriv(_node, _localOffset);
1004 },
1005 ::py::arg("node"),
1006 ::py::arg("localOffset"))
1007 .def(
1008 "getLinearJacobianDeriv",
1009 +[](const dart::dynamics::Skeleton* self,
1010 const dart::dynamics::JacobianNode* _node,
1011 const Eigen::Vector3d& _localOffset,
1012 const dart::dynamics::Frame* _inCoordinatesOf)
1013 -> dart::math::LinearJacobian {
1014 return self->getLinearJacobianDeriv(
1015 _node, _localOffset, _inCoordinatesOf);
1016 },
1017 ::py::arg("node"),
1018 ::py::arg("localOffset"),
1019 ::py::arg("inCoordinatesOf"))
1020 .def(
1021 "getAngularJacobianDeriv",
1022 +[](const dart::dynamics::Skeleton* self,
1023 const dart::dynamics::JacobianNode* _node)
1024 -> dart::math::AngularJacobian {
1025 return self->getAngularJacobianDeriv(_node);
1026 },
1027 ::py::arg("node"))
1028 .def(
1029 "getAngularJacobianDeriv",
1030 +[](const dart::dynamics::Skeleton* self,
1031 const dart::dynamics::JacobianNode* _node,
1032 const dart::dynamics::Frame* _inCoordinatesOf)
1033 -> dart::math::AngularJacobian {
1034 return self->getAngularJacobianDeriv(_node, _inCoordinatesOf);
1035 },
1036 ::py::arg("node"),
1037 ::py::arg("inCoordinatesOf"))
1038 .def(
1039 "getMass",
1040 +[](const dart::dynamics::Skeleton* self)
1041 -> double { return self->getMass(); })
1042 .def(
1043 "getMassMatrix",
1044 +[](const dart::dynamics::Skeleton* self,
1045 std::size_t treeIndex) -> const Eigen::MatrixXd& {
1046 return self->getMassMatrix(treeIndex);
1047 })
1048 // TODO(JS): Redefining get[~]() that are already defined in MetaSkeleton.
1049 // We need this because the methods with same name (but different
1050 // arguments) are hidden. Update (or remove) once following issue is
1051 // resolved: https://github.com/pybind/pybind11/issues/974
1052 .def(
1053 "getMassMatrix",
1054 +[](const dart::dynamics::Skeleton* self) -> const Eigen::MatrixXd& {
1055 return self->getMassMatrix();
1056 })
1057 .def(
1058 "getAugMassMatrix",
1059 +[](const dart::dynamics::Skeleton* self,
1060 std::size_t treeIndex) -> const Eigen::MatrixXd& {
1061 return self->getAugMassMatrix(treeIndex);
1062 })
1063 .def(
1064 "getAugMassMatrix",
1065 +[](const dart::dynamics::Skeleton* self) -> const Eigen::MatrixXd& {
1066 return self->getAugMassMatrix();
1067 })
1068 .def(
1069 "getInvMassMatrix",
1070 +[](const dart::dynamics::Skeleton* self,
1071 std::size_t treeIndex) -> const Eigen::MatrixXd& {
1072 return self->getInvMassMatrix(treeIndex);
1073 })
1074 .def(
1075 "getInvMassMatrix",
1076 +[](const dart::dynamics::Skeleton* self) -> const Eigen::MatrixXd& {
1077 return self->getInvMassMatrix();
1078 })
1079 .def(
1080 "getCoriolisForces",
1081 +[](dart::dynamics::Skeleton* self,
1082 std::size_t treeIndex) -> const Eigen::VectorXd& {
1083 return self->getCoriolisForces(treeIndex);
1084 })
1085 .def(
1086 "getCoriolisForces",
1087 +[](dart::dynamics::Skeleton* self) -> const Eigen::VectorXd& {
1088 return self->getCoriolisForces();
1089 })
1090 .def(
1091 "getGravityForces",
1092 +[](dart::dynamics::Skeleton* self,
1093 std::size_t treeIndex) -> const Eigen::VectorXd& {
1094 return self->getGravityForces(treeIndex);
1095 })
1096 .def(
1097 "getGravityForces",
1098 +[](dart::dynamics::Skeleton* self) -> const Eigen::VectorXd& {
1099 return self->getGravityForces();
1100 })
1101 .def(
1102 "getCoriolisAndGravityForces",
1103 +[](dart::dynamics::Skeleton* self,
1104 std::size_t treeIndex) -> const Eigen::VectorXd& {
1105 return self->getCoriolisAndGravityForces(treeIndex);
1106 })
1107 .def(
1108 "getCoriolisAndGravityForces",
1109 +[](dart::dynamics::Skeleton* self) -> const Eigen::VectorXd& {
1110 return self->getCoriolisAndGravityForces();
1111 })
1112 .def(
1113 "getExternalForces",
1114 +[](dart::dynamics::Skeleton* self,
1115 std::size_t treeIndex) -> const Eigen::VectorXd& {
1116 return self->getExternalForces(treeIndex);
1117 })
1118 .def(
1119 "getExternalForces",
1120 +[](dart::dynamics::Skeleton* self) -> const Eigen::VectorXd& {
1121 return self->getExternalForces();
1122 })
1123 .def(
1124 "getConstraintForces",
1125 +[](dart::dynamics::Skeleton* self,
1126 std::size_t treeIndex) -> const Eigen::VectorXd& {
1127 return self->getConstraintForces(treeIndex);
1128 })
1129 .def(
1130 "getConstraintForces",
1131 +[](dart::dynamics::Skeleton* self) -> const Eigen::VectorXd& {
1132 return self->getConstraintForces();
1133 })
1134 .def(
1135 "clearExternalForces",
1136 +[](dart::dynamics::Skeleton* self)
1137 -> void { return self->clearExternalForces(); })
1138 .def(
1139 "clearInternalForces",
1140 +[](dart::dynamics::Skeleton* self)
1141 -> void { return self->clearInternalForces(); })
1142 // .def("notifyArticulatedInertiaUpdate",
1143 // +[](dart::dynamics::Skeleton *self, std::size_t _treeIdx) -> void
1144 // { return self->notifyArticulatedInertiaUpdate(_treeIdx); },
1145 // ::py::arg("treeIdx"))
1146 .def(
1147 "dirtyArticulatedInertia",
1148 +[](dart::dynamics::Skeleton* self, std::size_t _treeIdx) -> void {
1149 return self->dirtyArticulatedInertia(_treeIdx);
1150 },
1151 ::py::arg("treeIdx"))
1152 // .def("notifySupportUpdate", +[](dart::dynamics::Skeleton *self,
1153 // std::size_t _treeIdx) -> void { return
1154 // self->notifySupportUpdate(_treeIdx); },
1155 // ::py::arg("treeIdx"))
1156 .def(
1157 "dirtySupportPolygon",
1158 +[](dart::dynamics::Skeleton* self, std::size_t _treeIdx) -> void {
1159 return self->dirtySupportPolygon(_treeIdx);
1160 },
1161 ::py::arg("treeIdx"))
1162 .def(
1163 "computeKineticEnergy",
1164 +[](const dart::dynamics::Skeleton* self) -> double {
1165 return self->computeKineticEnergy();
1166 })
1167 .def(
1168 "computePotentialEnergy",
1169 +[](const dart::dynamics::Skeleton* self) -> double {
1170 return self->computePotentialEnergy();
1171 })
1172 // .def("clearCollidingBodies", +[](dart::dynamics::Skeleton *self)
1173 // -> void { return self->clearCollidingBodies(); })
1174 .def(
1175 "getCOM",
1176 +[](const dart::dynamics::Skeleton* self) -> Eigen::Vector3d {
1177 return self->getCOM();
1178 })
1179 .def(
1180 "getCOM",
1181 +[](const dart::dynamics::Skeleton* self,
1182 const dart::dynamics::Frame* _withRespectTo) -> Eigen::Vector3d {
1183 return self->getCOM(_withRespectTo);
1184 },
1185 ::py::arg("withRespectTo"))
1186 .def(
1187 "getCOMSpatialVelocity",
1188 +[](const dart::dynamics::Skeleton* self) -> Eigen::Vector6d {
1189 return self->getCOMSpatialVelocity();
1190 })
1191 .def(
1192 "getCOMSpatialVelocity",
1193 +[](const dart::dynamics::Skeleton* self,
1194 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector6d {
1195 return self->getCOMSpatialVelocity(_relativeTo);
1196 },
1197 ::py::arg("relativeTo"))
1198 .def(
1199 "getCOMSpatialVelocity",
1200 +[](const dart::dynamics::Skeleton* self,
1201 const dart::dynamics::Frame* _relativeTo,
1202 const dart::dynamics::Frame* _inCoordinatesOf)
1203 -> Eigen::Vector6d {
1204 return self->getCOMSpatialVelocity(_relativeTo, _inCoordinatesOf);
1205 },
1206 ::py::arg("relativeTo"),
1207 ::py::arg("inCoordinatesOf"))
1208 .def(
1209 "getCOMLinearVelocity",
1210 +[](const dart::dynamics::Skeleton* self) -> Eigen::Vector3d {
1211 return self->getCOMLinearVelocity();
1212 })
1213 .def(
1214 "getCOMLinearVelocity",
1215 +[](const dart::dynamics::Skeleton* self,
1216 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector3d {
1217 return self->getCOMLinearVelocity(_relativeTo);
1218 },
1219 ::py::arg("relativeTo"))
1220 .def(
1221 "getCOMLinearVelocity",
1222 +[](const dart::dynamics::Skeleton* self,
1223 const dart::dynamics::Frame* _relativeTo,
1224 const dart::dynamics::Frame* _inCoordinatesOf)
1225 -> Eigen::Vector3d {
1226 return self->getCOMLinearVelocity(_relativeTo, _inCoordinatesOf);
1227 },
1228 ::py::arg("relativeTo"),
1229 ::py::arg("inCoordinatesOf"))
1230 .def(
1231 "getCOMSpatialAcceleration",
1232 +[](const dart::dynamics::Skeleton* self) -> Eigen::Vector6d {
1233 return self->getCOMSpatialAcceleration();
1234 })
1235 .def(
1236 "getCOMSpatialAcceleration",
1237 +[](const dart::dynamics::Skeleton* self,
1238 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector6d {
1239 return self->getCOMSpatialAcceleration(_relativeTo);
1240 },
1241 ::py::arg("relativeTo"))
1242 .def(
1243 "getCOMSpatialAcceleration",
1244 +[](const dart::dynamics::Skeleton* self,
1245 const dart::dynamics::Frame* _relativeTo,
1246 const dart::dynamics::Frame* _inCoordinatesOf)
1247 -> Eigen::Vector6d {
1248 return self->getCOMSpatialAcceleration(
1249 _relativeTo, _inCoordinatesOf);
1250 },
1251 ::py::arg("relativeTo"),
1252 ::py::arg("inCoordinatesOf"))
1253 .def(
1254 "getCOMLinearAcceleration",
1255 +[](const dart::dynamics::Skeleton* self) -> Eigen::Vector3d {
1256 return self->getCOMLinearAcceleration();
1257 })
1258 .def(
1259 "getCOMLinearAcceleration",
1260 +[](const dart::dynamics::Skeleton* self,
1261 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector3d {
1262 return self->getCOMLinearAcceleration(_relativeTo);
1263 },
1264 ::py::arg("relativeTo"))
1265 .def(
1266 "getCOMLinearAcceleration",
1267 +[](const dart::dynamics::Skeleton* self,
1268 const dart::dynamics::Frame* _relativeTo,
1269 const dart::dynamics::Frame* _inCoordinatesOf)
1270 -> Eigen::Vector3d {
1271 return self->getCOMLinearAcceleration(
1272 _relativeTo, _inCoordinatesOf);
1273 },
1274 ::py::arg("relativeTo"),
1275 ::py::arg("inCoordinatesOf"))
1276 .def(
1277 "getCOMJacobian",
1278 +[](const dart::dynamics::Skeleton* self) -> dart::math::Jacobian {
1279 return self->getCOMJacobian();
1280 })
1281 .def(
1282 "getCOMJacobian",
1283 +[](const dart::dynamics::Skeleton* self,
1284 const dart::dynamics::Frame* _inCoordinatesOf)
1285 -> dart::math::Jacobian {
1286 return self->getCOMJacobian(_inCoordinatesOf);
1287 },
1288 ::py::arg("inCoordinatesOf"))
1289 .def(
1290 "getCOMLinearJacobian",
1291 +[](const dart::dynamics::Skeleton* self)
1292 -> dart::math::LinearJacobian {
1293 return self->getCOMLinearJacobian();
1294 })
1295 .def(
1296 "getCOMLinearJacobian",
1297 +[](const dart::dynamics::Skeleton* self,
1298 const dart::dynamics::Frame* _inCoordinatesOf)
1299 -> dart::math::LinearJacobian {
1300 return self->getCOMLinearJacobian(_inCoordinatesOf);
1301 },
1302 ::py::arg("inCoordinatesOf"))
1303 .def(
1304 "getCOMJacobianSpatialDeriv",
1305 +[](const dart::dynamics::Skeleton* self) -> dart::math::Jacobian {
1306 return self->getCOMJacobianSpatialDeriv();
1307 })
1308 .def(
1309 "getCOMJacobianSpatialDeriv",
1310 +[](const dart::dynamics::Skeleton* self,
1311 const dart::dynamics::Frame* _inCoordinatesOf)
1312 -> dart::math::Jacobian {
1313 return self->getCOMJacobianSpatialDeriv(_inCoordinatesOf);
1314 },
1315 ::py::arg("inCoordinatesOf"))
1316 .def(
1317 "getCOMLinearJacobianDeriv",
1318 +[](const dart::dynamics::Skeleton* self)
1319 -> dart::math::LinearJacobian {
1320 return self->getCOMLinearJacobianDeriv();
1321 })
1322 .def(
1323 "getCOMLinearJacobianDeriv",
1324 +[](const dart::dynamics::Skeleton* self,
1325 const dart::dynamics::Frame* _inCoordinatesOf)
1326 -> dart::math::LinearJacobian {
1327 return self->getCOMLinearJacobianDeriv(_inCoordinatesOf);
1328 },
1329 ::py::arg("inCoordinatesOf"))
1330 .def(
1331 "resetUnion",
1332 +[](dart::dynamics::Skeleton* self)
1333 -> void { return self->resetUnion(); })
1334 .def_readwrite(
1335 "mUnionRootSkeleton", &dart::dynamics::Skeleton::mUnionRootSkeleton)
1336 .def_readwrite("mUnionSize", &dart::dynamics::Skeleton::mUnionSize)
1337 .def_readwrite("mUnionIndex", &dart::dynamics::Skeleton::mUnionIndex);
1338 }
1339
1340 } // namespace python
1341 } // namespace dart