Debian Codegraph @

python/dartpy/dynamics/MetaSkeleton.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 namespace dart {
43 namespace python {
44
45 void MetaSkeleton(py::module& m)
46 {
47 ::py::class_<
48 dart::dynamics::MetaSkeleton,
49 std::shared_ptr<dart::dynamics::MetaSkeleton>>(m, "MetaSkeleton")
50 .def(
51 "cloneMetaSkeleton",
52 +[](const dart::dynamics::MetaSkeleton* self,
53 const std::string& cloneName) -> dart::dynamics::MetaSkeletonPtr {
54 return self->cloneMetaSkeleton(cloneName);
55 },
56 ::py::arg("cloneName"))
57 .def(
58 "cloneMetaSkeleton",
59 +[](const dart::dynamics::MetaSkeleton* self)
60 -> dart::dynamics::MetaSkeletonPtr {
61 return self->cloneMetaSkeleton();
62 })
63 .def(
64 "getLockableReference",
65 +[](const dart::dynamics::MetaSkeleton* self)
66 -> std::unique_ptr<dart::common::LockableReference> {
67 return self->getLockableReference();
68 })
69 .def(
70 "setName",
71 +[](dart::dynamics::MetaSkeleton* self, const std::string& _name)
72 -> const std::string& { return self->setName(_name); },
73 ::py::return_value_policy::reference_internal,
74 ::py::arg("name"))
75 .def(
76 "getName",
77 +[](const dart::dynamics::MetaSkeleton* self) -> const std::string& {
78 return self->getName();
79 },
80 ::py::return_value_policy::reference_internal)
81 .def(
82 "getNumBodyNodes",
83 +[](const dart::dynamics::MetaSkeleton* self) -> std::size_t {
84 return self->getNumBodyNodes();
85 })
86 .def(
87 "getBodyNode",
88 +[](dart::dynamics::MetaSkeleton* self, std::size_t index)
89 -> dart::dynamics::BodyNode* { return self->getBodyNode(index); },
90 ::py::arg("index"),
91 py::return_value_policy::reference)
92 .def(
93 "getBodyNode",
94 +[](dart::dynamics::MetaSkeleton* self, const std::string& name)
95 -> dart::dynamics::BodyNode* { return self->getBodyNode(name); },
96 ::py::arg("treeIndex"),
97 py::return_value_policy::reference)
98 .def(
99 "getBodyNodes",
100 +[](dart::dynamics::MetaSkeleton* self, const std::string& name)
101 -> std::vector<dart::dynamics::BodyNode*> {
102 return self->getBodyNodes(name);
103 },
104 ::py::arg("name"))
105 .def(
106 "getBodyNodes",
107 +[](const dart::dynamics::MetaSkeleton* self, const std::string& name)
108 -> std::vector<const dart::dynamics::BodyNode*> {
109 return self->getBodyNodes(name);
110 },
111 ::py::arg("name"))
112 .def(
113 "hasBodyNode",
114 +[](const dart::dynamics::MetaSkeleton* self,
115 const dart::dynamics::BodyNode* bodyNode) -> bool {
116 return self->hasBodyNode(bodyNode);
117 },
118 ::py::arg("bodyNode"))
119 .def(
120 "getIndexOf",
121 +[](const dart::dynamics::MetaSkeleton* self,
122 const dart::dynamics::BodyNode* _bn) -> std::size_t {
123 return self->getIndexOf(_bn);
124 },
125 ::py::arg("bn"))
126 .def(
127 "getIndexOf",
128 +[](const dart::dynamics::MetaSkeleton* self,
129 const dart::dynamics::BodyNode* _bn,
130 bool _warning) -> std::size_t {
131 return self->getIndexOf(_bn, _warning);
132 },
133 ::py::arg("bn"),
134 ::py::arg("warning"))
135 .def(
136 "getNumJoints",
137 +[](const dart::dynamics::MetaSkeleton* self) -> std::size_t {
138 return self->getNumJoints();
139 })
140 .def(
141 "getJoint",
142 +[](dart::dynamics::MetaSkeleton* self, std::size_t index)
143 -> dart::dynamics::Joint* { return self->getJoint(index); },
144 ::py::return_value_policy::reference_internal,
145 ::py::arg("index"))
146 .def(
147 "getJoint",
148 +[](dart::dynamics::MetaSkeleton* self, const std::string& name)
149 -> dart::dynamics::Joint* { return self->getJoint(name); },
150 ::py::return_value_policy::reference_internal,
151 ::py::arg("name"))
152 .def(
153 "getJoints",
154 +[](dart::dynamics::MetaSkeleton* self)
155 -> std::vector<dart::dynamics::Joint*> {
156 DART_SUPPRESS_DEPRECATED_BEGIN
157 return self->getJoints();
158 DART_SUPPRESS_DEPRECATED_END
159 })
160 .def(
161 "getJoints",
162 +[](const dart::dynamics::MetaSkeleton* self)
163 -> std::vector<const dart::dynamics::Joint*> {
164 DART_SUPPRESS_DEPRECATED_BEGIN
165 return self->getJoints();
166 DART_SUPPRESS_DEPRECATED_END
167 })
168 .def(
169 "getJoints",
170 +[](dart::dynamics::MetaSkeleton* self,
171 const std::string& name) -> std::vector<dart::dynamics::Joint*> {
172 return self->getJoints(name);
173 },
174 ::py::arg("name"))
175 .def(
176 "getJoints",
177 +[](const dart::dynamics::MetaSkeleton* self, const std::string& name)
178 -> std::vector<const dart::dynamics::Joint*> {
179 return self->getJoints(name);
180 },
181 ::py::arg("name"))
182 .def(
183 "hasJoint",
184 +[](const dart::dynamics::MetaSkeleton* self,
185 const dart::dynamics::Joint* joint) -> bool {
186 return self->hasJoint(joint);
187 },
188 ::py::arg("joint"))
189 .def(
190 "getIndexOf",
191 +[](const dart::dynamics::MetaSkeleton* self,
192 const dart::dynamics::Joint* _joint) -> std::size_t {
193 return self->getIndexOf(_joint);
194 },
195 ::py::arg("joint"))
196 .def(
197 "getIndexOf",
198 +[](const dart::dynamics::MetaSkeleton* self,
199 const dart::dynamics::Joint* _joint,
200 bool _warning) -> std::size_t {
201 return self->getIndexOf(_joint, _warning);
202 },
203 ::py::arg("joint"),
204 ::py::arg("warning"))
205 .def(
206 "getNumDofs",
207 +[](const dart::dynamics::MetaSkeleton* self) -> std::size_t {
208 return self->getNumDofs();
209 })
210 .def(
211 "getDof",
212 +[](dart::dynamics::MetaSkeleton* self,
213 std::size_t index) -> dart::dynamics::DegreeOfFreedom* {
214 return self->getDof(index);
215 },
216 ::py::return_value_policy::reference_internal,
217 ::py::arg("index"))
218 .def(
219 "getDofs",
220 +[](dart::dynamics::MetaSkeleton* self)
221 -> std::vector<dart::dynamics::DegreeOfFreedom*> {
222 DART_SUPPRESS_DEPRECATED_BEGIN
223 return self->getDofs();
224 DART_SUPPRESS_DEPRECATED_END
225 },
226 ::py::return_value_policy::reference_internal)
227 .def(
228 "getIndexOf",
229 +[](const dart::dynamics::MetaSkeleton* self,
230 const dart::dynamics::DegreeOfFreedom* _dof) -> std::size_t {
231 return self->getIndexOf(_dof);
232 },
233 ::py::arg("dof"))
234 .def(
235 "getIndexOf",
236 +[](const dart::dynamics::MetaSkeleton* self,
237 const dart::dynamics::DegreeOfFreedom* _dof,
238 bool _warning) -> std::size_t {
239 return self->getIndexOf(_dof, _warning);
240 },
241 ::py::arg("dof"),
242 ::py::arg("warning"))
243 .def(
244 "setCommand",
245 +[](dart::dynamics::MetaSkeleton* self,
246 std::size_t _index,
247 double _command) { self->setCommand(_index, _command); },
248 ::py::arg("index"),
249 ::py::arg("command"))
250 .def(
251 "getCommand",
252 +[](const dart::dynamics::MetaSkeleton* self, std::size_t _index)
253 -> double { return self->getCommand(_index); },
254 ::py::arg("index"))
255 .def(
256 "setCommands",
257 +[](dart::dynamics::MetaSkeleton* self,
258 const Eigen::VectorXd& _commands) {
259 self->setCommands(_commands);
260 },
261 ::py::arg("commands"))
262 .def(
263 "setCommands",
264 +[](dart::dynamics::MetaSkeleton* self,
265 const std::vector<std::size_t>& _indices,
266 const Eigen::VectorXd& _commands) {
267 self->setCommands(_indices, _commands);
268 },
269 ::py::arg("indices"),
270 ::py::arg("commands"))
271 .def(
272 "getCommands",
273 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
274 return self->getCommands();
275 })
276 .def(
277 "getCommands",
278 +[](const dart::dynamics::MetaSkeleton* self,
279 const std::vector<std::size_t>& _indices) -> Eigen::VectorXd {
280 return self->getCommands(_indices);
281 },
282 ::py::arg("indices"))
283 .def(
284 "resetCommands",
285 +[](dart::dynamics::MetaSkeleton* self) { self->resetCommands(); })
286 .def(
287 "setPosition",
288 +[](dart::dynamics::MetaSkeleton* self,
289 std::size_t index,
290 double _position) { self->setPosition(index, _position); },
291 ::py::arg("index"),
292 ::py::arg("position"))
293 .def(
294 "getPosition",
295 +[](const dart::dynamics::MetaSkeleton* self, std::size_t _index)
296 -> double { return self->getPosition(_index); },
297 ::py::arg("index"))
298 .def(
299 "setPositions",
300 +[](dart::dynamics::MetaSkeleton* self,
301 const Eigen::VectorXd& _positions) {
302 self->setPositions(_positions);
303 },
304 ::py::arg("positions"))
305 .def(
306 "setPositions",
307 +[](dart::dynamics::MetaSkeleton* self,
308 const std::vector<std::size_t>& _indices,
309 const Eigen::VectorXd& _positions) {
310 self->setPositions(_indices, _positions);
311 },
312 ::py::arg("indices"),
313 ::py::arg("positions"))
314 .def(
315 "getPositions",
316 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
317 return self->getPositions();
318 })
319 .def(
320 "getPositions",
321 +[](const dart::dynamics::MetaSkeleton* self,
322 const std::vector<std::size_t>& _indices) -> Eigen::VectorXd {
323 return self->getPositions(_indices);
324 },
325 ::py::arg("indices"))
326 .def(
327 "resetPositions",
328 +[](dart::dynamics::MetaSkeleton* self) { self->resetPositions(); })
329 .def(
330 "setPositionLowerLimit",
331 +[](dart::dynamics::MetaSkeleton* self,
332 std::size_t _index,
333 double _position) {
334 self->setPositionLowerLimit(_index, _position);
335 },
336 ::py::arg("index"),
337 ::py::arg("position"))
338 .def(
339 "setPositionLowerLimits",
340 +[](dart::dynamics::MetaSkeleton* self,
341 const Eigen::VectorXd& positions) {
342 self->setPositionLowerLimits(positions);
343 },
344 ::py::arg("positions"))
345 .def(
346 "setPositionLowerLimits",
347 +[](dart::dynamics::MetaSkeleton* self,
348 const std::vector<std::size_t>& indices,
349 const Eigen::VectorXd& positions) {
350 self->setPositionLowerLimits(indices, positions);
351 },
352 ::py::arg("indices"),
353 ::py::arg("positions"))
354 .def(
355 "getPositionLowerLimit",
356 +[](const dart::dynamics::MetaSkeleton* self, std::size_t _index)
357 -> double { return self->getPositionLowerLimit(_index); },
358 ::py::arg("index"))
359 .def(
360 "getPositionLowerLimits",
361 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
362 return self->getPositionLowerLimits();
363 })
364 .def(
365 "getPositionLowerLimits",
366 +[](const dart::dynamics::MetaSkeleton* self,
367 const std::vector<std::size_t>& indices) -> Eigen::VectorXd {
368 return self->getPositionLowerLimits(indices);
369 },
370 ::py::arg("indices"))
371 .def(
372 "setPositionUpperLimit",
373 +[](dart::dynamics::MetaSkeleton* self,
374 std::size_t _index,
375 double _position) {
376 self->setPositionUpperLimit(_index, _position);
377 },
378 ::py::arg("index"),
379 ::py::arg("position"))
380 .def(
381 "setPositionUpperLimits",
382 +[](dart::dynamics::MetaSkeleton* self,
383 const Eigen::VectorXd& positions) {
384 self->setPositionUpperLimits(positions);
385 },
386 ::py::arg("positions"))
387 .def(
388 "setPositionUpperLimits",
389 +[](dart::dynamics::MetaSkeleton* self,
390 const std::vector<std::size_t>& indices,
391 const Eigen::VectorXd& positions) {
392 self->setPositionUpperLimits(indices, positions);
393 },
394 ::py::arg("indices"),
395 ::py::arg("positions"))
396 .def(
397 "getPositionUpperLimit",
398 +[](const dart::dynamics::MetaSkeleton* self, std::size_t _index)
399 -> double { return self->getPositionUpperLimit(_index); },
400 ::py::arg("index"))
401 .def(
402 "getPositionUpperLimits",
403 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
404 return self->getPositionUpperLimits();
405 })
406 .def(
407 "getPositionUpperLimits",
408 +[](const dart::dynamics::MetaSkeleton* self,
409 const std::vector<std::size_t>& indices) -> Eigen::VectorXd {
410 return self->getPositionUpperLimits(indices);
411 },
412 ::py::arg("indices"))
413 .def(
414 "setVelocity",
415 +[](dart::dynamics::MetaSkeleton* self,
416 std::size_t _index,
417 double _velocity) { self->setVelocity(_index, _velocity); },
418 ::py::arg("index"),
419 ::py::arg("velocity"))
420 .def(
421 "getVelocity",
422 +[](const dart::dynamics::MetaSkeleton* self, std::size_t _index)
423 -> double { return self->getVelocity(_index); },
424 ::py::arg("index"))
425 .def(
426 "setVelocities",
427 +[](dart::dynamics::MetaSkeleton* self,
428 const Eigen::VectorXd& _velocities) {
429 self->setVelocities(_velocities);
430 },
431 ::py::arg("velocities"))
432 .def(
433 "setVelocities",
434 +[](dart::dynamics::MetaSkeleton* self,
435 const std::vector<std::size_t>& _indices,
436 const Eigen::VectorXd& _velocities) {
437 self->setVelocities(_indices, _velocities);
438 },
439 ::py::arg("indices"),
440 ::py::arg("velocities"))
441 .def(
442 "getVelocities",
443 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
444 return self->getVelocities();
445 })
446 .def(
447 "getVelocities",
448 +[](const dart::dynamics::MetaSkeleton* self,
449 const std::vector<std::size_t>& _indices) -> Eigen::VectorXd {
450 return self->getVelocities(_indices);
451 },
452 ::py::arg("indices"))
453 .def(
454 "resetVelocities",
455 +[](dart::dynamics::MetaSkeleton* self) { self->resetVelocities(); })
456 .def(
457 "setVelocityLowerLimit",
458 +[](dart::dynamics::MetaSkeleton* self,
459 std::size_t _index,
460 double _velocity) {
461 self->setVelocityLowerLimit(_index, _velocity);
462 },
463 ::py::arg("index"),
464 ::py::arg("velocity"))
465 .def(
466 "setVelocityLowerLimits",
467 +[](dart::dynamics::MetaSkeleton* self,
468 const Eigen::VectorXd& velocities) {
469 self->setVelocityLowerLimits(velocities);
470 },
471 ::py::arg("velocities"))
472 .def(
473 "setVelocityLowerLimits",
474 +[](dart::dynamics::MetaSkeleton* self,
475 const std::vector<std::size_t>& indices,
476 const Eigen::VectorXd& velocities) {
477 self->setVelocityLowerLimits(indices, velocities);
478 },
479 ::py::arg("indices"),
480 ::py::arg("velocities"))
481 .def(
482 "getVelocityLowerLimit",
483 +[](dart::dynamics::MetaSkeleton* self, std::size_t _index)
484 -> double { return self->getVelocityLowerLimit(_index); },
485 ::py::arg("index"))
486 .def(
487 "getVelocityLowerLimits",
488 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
489 return self->getVelocityLowerLimits();
490 })
491 .def(
492 "getVelocityLowerLimits",
493 +[](const dart::dynamics::MetaSkeleton* self,
494 const std::vector<std::size_t>& indices) -> Eigen::VectorXd {
495 return self->getVelocityLowerLimits(indices);
496 },
497 ::py::arg("indices"))
498 .def(
499 "setVelocityUpperLimit",
500 +[](dart::dynamics::MetaSkeleton* self,
501 std::size_t _index,
502 double _velocity) {
503 self->setVelocityUpperLimit(_index, _velocity);
504 },
505 ::py::arg("index"),
506 ::py::arg("velocity"))
507 .def(
508 "setVelocityUpperLimits",
509 +[](dart::dynamics::MetaSkeleton* self,
510 const Eigen::VectorXd& velocities) {
511 self->setVelocityUpperLimits(velocities);
512 },
513 ::py::arg("velocities"))
514 .def(
515 "setVelocityUpperLimits",
516 +[](dart::dynamics::MetaSkeleton* self,
517 const std::vector<std::size_t>& indices,
518 const Eigen::VectorXd& velocities) {
519 self->setVelocityUpperLimits(indices, velocities);
520 },
521 ::py::arg("indices"),
522 ::py::arg("velocities"))
523 .def(
524 "getVelocityUpperLimit",
525 +[](dart::dynamics::MetaSkeleton* self, std::size_t _index)
526 -> double { return self->getVelocityUpperLimit(_index); },
527 ::py::arg("index"))
528 .def(
529 "getVelocityUpperLimits",
530 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
531 return self->getVelocityUpperLimits();
532 })
533 .def(
534 "getVelocityUpperLimits",
535 +[](const dart::dynamics::MetaSkeleton* self,
536 const std::vector<std::size_t>& indices) -> Eigen::VectorXd {
537 return self->getVelocityUpperLimits(indices);
538 },
539 ::py::arg("indices"))
540 .def(
541 "setAcceleration",
542 +[](dart::dynamics::MetaSkeleton* self,
543 std::size_t _index,
544 double _acceleration) {
545 self->setAcceleration(_index, _acceleration);
546 },
547 ::py::arg("index"),
548 ::py::arg("acceleration"))
549 .def(
550 "getAcceleration",
551 +[](const dart::dynamics::MetaSkeleton* self, std::size_t _index)
552 -> double { return self->getAcceleration(_index); },
553 ::py::arg("index"))
554 .def(
555 "setAccelerations",
556 +[](dart::dynamics::MetaSkeleton* self,
557 const Eigen::VectorXd& _accelerations) {
558 self->setAccelerations(_accelerations);
559 },
560 ::py::arg("accelerations"))
561 .def(
562 "setAccelerations",
563 +[](dart::dynamics::MetaSkeleton* self,
564 const std::vector<std::size_t>& _indices,
565 const Eigen::VectorXd& _accelerations) {
566 self->setAccelerations(_indices, _accelerations);
567 },
568 ::py::arg("indices"),
569 ::py::arg("accelerations"))
570 .def(
571 "getAccelerations",
572 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
573 return self->getAccelerations();
574 })
575 .def(
576 "getAccelerations",
577 +[](const dart::dynamics::MetaSkeleton* self,
578 const std::vector<std::size_t>& _indices) -> Eigen::VectorXd {
579 return self->getAccelerations(_indices);
580 },
581 ::py::arg("indices"))
582 .def(
583 "resetAccelerations",
584 +[](dart::dynamics::MetaSkeleton*
585 self) { self->resetAccelerations(); })
586 .def(
587 "setAccelerationLowerLimit",
588 +[](dart::dynamics::MetaSkeleton* self,
589 std::size_t _index,
590 double _acceleration) {
591 self->setAccelerationLowerLimit(_index, _acceleration);
592 },
593 ::py::arg("index"),
594 ::py::arg("acceleration"))
595 .def(
596 "setAccelerationLowerLimits",
597 +[](dart::dynamics::MetaSkeleton* self,
598 const Eigen::VectorXd& accelerations) {
599 self->setAccelerationLowerLimits(accelerations);
600 },
601 ::py::arg("accelerations"))
602 .def(
603 "setAccelerationLowerLimits",
604 +[](dart::dynamics::MetaSkeleton* self,
605 const std::vector<std::size_t>& indices,
606 const Eigen::VectorXd& accelerations) {
607 self->setAccelerationLowerLimits(indices, accelerations);
608 },
609 ::py::arg("indices"),
610 ::py::arg("accelerations"))
611 .def(
612 "getAccelerationLowerLimit",
613 +[](const dart::dynamics::MetaSkeleton* self, std::size_t _index)
614 -> double { return self->getAccelerationLowerLimit(_index); },
615 ::py::arg("index"))
616 .def(
617 "getAccelerationLowerLimits",
618 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
619 return self->getAccelerationLowerLimits();
620 })
621 .def(
622 "getAccelerationLowerLimits",
623 +[](const dart::dynamics::MetaSkeleton* self,
624 const std::vector<std::size_t>& indices) -> Eigen::VectorXd {
625 return self->getAccelerationLowerLimits(indices);
626 },
627 ::py::arg("indices"))
628 .def(
629 "setAccelerationUpperLimit",
630 +[](dart::dynamics::MetaSkeleton* self,
631 std::size_t _index,
632 double _acceleration) {
633 self->setAccelerationUpperLimit(_index, _acceleration);
634 },
635 ::py::arg("index"),
636 ::py::arg("acceleration"))
637 .def(
638 "setAccelerationUpperLimits",
639 +[](dart::dynamics::MetaSkeleton* self,
640 const Eigen::VectorXd& accelerations) {
641 self->setAccelerationUpperLimits(accelerations);
642 },
643 ::py::arg("accelerations"))
644 .def(
645 "setAccelerationUpperLimits",
646 +[](dart::dynamics::MetaSkeleton* self,
647 const std::vector<std::size_t>& indices,
648 const Eigen::VectorXd& accelerations) {
649 self->setAccelerationUpperLimits(indices, accelerations);
650 },
651 ::py::arg("indices"),
652 ::py::arg("accelerations"))
653 .def(
654 "getAccelerationUpperLimit",
655 +[](const dart::dynamics::MetaSkeleton* self, std::size_t _index)
656 -> double { return self->getAccelerationUpperLimit(_index); },
657 ::py::arg("index"))
658 .def(
659 "getAccelerationUpperLimits",
660 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
661 return self->getAccelerationUpperLimits();
662 })
663 .def(
664 "getAccelerationUpperLimits",
665 +[](const dart::dynamics::MetaSkeleton* self,
666 const std::vector<std::size_t>& indices) -> Eigen::VectorXd {
667 return self->getAccelerationUpperLimits(indices);
668 },
669 ::py::arg("indices"))
670 .def(
671 "setForce",
672 +[](dart::dynamics::MetaSkeleton* self,
673 std::size_t _index,
674 double _force) { self->setForce(_index, _force); },
675 ::py::arg("index"),
676 ::py::arg("force"))
677 .def(
678 "getForce",
679 +[](const dart::dynamics::MetaSkeleton* self,
680 std::size_t _index) -> double { return self->getForce(_index); },
681 ::py::arg("index"))
682 .def(
683 "setForces",
684 +[](dart::dynamics::MetaSkeleton* self,
685 const Eigen::VectorXd& _forces) { self->setForces(_forces); },
686 ::py::arg("forces"))
687 .def(
688 "setForces",
689 +[](dart::dynamics::MetaSkeleton* self,
690 const std::vector<std::size_t>& _index,
691 const Eigen::VectorXd& _forces) {
692 self->setForces(_index, _forces);
693 },
694 ::py::arg("index"),
695 ::py::arg("forces"))
696 .def(
697 "getForces",
698 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
699 return self->getForces();
700 })
701 .def(
702 "getForces",
703 +[](const dart::dynamics::MetaSkeleton* self,
704 const std::vector<std::size_t>& _indices) -> Eigen::VectorXd {
705 return self->getForces(_indices);
706 },
707 ::py::arg("indices"))
708 .def(
709 "resetGeneralizedForces",
710 +[](dart::dynamics::MetaSkeleton*
711 self) { self->resetGeneralizedForces(); })
712 .def(
713 "setForceLowerLimit",
714 +[](dart::dynamics::MetaSkeleton* self,
715 std::size_t _index,
716 double _force) { self->setForceLowerLimit(_index, _force); },
717 ::py::arg("index"),
718 ::py::arg("force"))
719 .def(
720 "setForceLowerLimits",
721 +[](dart::dynamics::MetaSkeleton* self,
722 const Eigen::VectorXd& forces) {
723 self->setForceLowerLimits(forces);
724 },
725 ::py::arg("forces"))
726 .def(
727 "setForceLowerLimits",
728 +[](dart::dynamics::MetaSkeleton* self,
729 const std::vector<std::size_t>& indices,
730 const Eigen::VectorXd& forces) {
731 self->setForceLowerLimits(indices, forces);
732 },
733 ::py::arg("indices"),
734 ::py::arg("forces"))
735 .def(
736 "getForceLowerLimit",
737 +[](const dart::dynamics::MetaSkeleton* self, std::size_t _index)
738 -> double { return self->getForceLowerLimit(_index); },
739 ::py::arg("index"))
740 .def(
741 "getForceLowerLimits",
742 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
743 return self->getForceLowerLimits();
744 })
745 .def(
746 "getForceLowerLimits",
747 +[](const dart::dynamics::MetaSkeleton* self,
748 const std::vector<std::size_t>& indices) -> Eigen::VectorXd {
749 return self->getForceLowerLimits(indices);
750 },
751 ::py::arg("indices"))
752 .def(
753 "setForceUpperLimit",
754 +[](dart::dynamics::MetaSkeleton* self,
755 std::size_t _index,
756 double _force) { self->setForceUpperLimit(_index, _force); },
757 ::py::arg("index"),
758 ::py::arg("force"))
759 .def(
760 "setForceUpperLimits",
761 +[](dart::dynamics::MetaSkeleton* self,
762 const Eigen::VectorXd& forces) {
763 self->setForceUpperLimits(forces);
764 },
765 ::py::arg("forces"))
766 .def(
767 "setForceUpperLimits",
768 +[](dart::dynamics::MetaSkeleton* self,
769 const std::vector<std::size_t>& indices,
770 const Eigen::VectorXd& forces) {
771 self->setForceUpperLimits(indices, forces);
772 },
773 ::py::arg("indices"),
774 ::py::arg("forces"))
775 .def(
776 "getForceUpperLimit",
777 +[](const dart::dynamics::MetaSkeleton* self, std::size_t _index)
778 -> double { return self->getForceUpperLimit(_index); },
779 ::py::arg("index"))
780 .def(
781 "getForceUpperLimits",
782 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
783 return self->getForceUpperLimits();
784 })
785 .def(
786 "getForceUpperLimits",
787 +[](const dart::dynamics::MetaSkeleton* self,
788 const std::vector<std::size_t>& indices) -> Eigen::VectorXd {
789 return self->getForceUpperLimits(indices);
790 },
791 ::py::arg("indices"))
792 .def(
793 "getVelocityChanges",
794 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
795 return self->getVelocityChanges();
796 })
797 .def(
798 "setJointConstraintImpulses",
799 +[](dart::dynamics::MetaSkeleton* self,
800 const Eigen::VectorXd& _impulses) {
801 self->setJointConstraintImpulses(_impulses);
802 },
803 ::py::arg("impulses"))
804 .def(
805 "getJointConstraintImpulses",
806 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::VectorXd {
807 return self->getJointConstraintImpulses();
808 })
809 .def(
810 "getJacobian",
811 +[](const dart::dynamics::MetaSkeleton* self,
812 const dart::dynamics::JacobianNode* _node)
813 -> dart::math::Jacobian { return self->getJacobian(_node); },
814 ::py::arg("node"))
815 .def(
816 "getJacobian",
817 +[](const dart::dynamics::MetaSkeleton* self,
818 const dart::dynamics::JacobianNode* _node,
819 const dart::dynamics::Frame* _inCoordinatesOf)
820 -> dart::math::Jacobian {
821 return self->getJacobian(_node, _inCoordinatesOf);
822 },
823 ::py::arg("node"),
824 ::py::arg("inCoordinatesOf"))
825 .def(
826 "getJacobian",
827 +[](const dart::dynamics::MetaSkeleton* self,
828 const dart::dynamics::JacobianNode* _node,
829 const dart::dynamics::JacobianNode* _relativeTo,
830 const dart::dynamics::Frame* _inCoordinatesOf)
831 -> dart::math::Jacobian {
832 return self->getJacobian(_node, _relativeTo, _inCoordinatesOf);
833 },
834 ::py::arg("node"),
835 ::py::arg("relativeTo"),
836 ::py::arg("inCoordinatesOf"))
837 .def(
838 "getJacobian",
839 +[](const dart::dynamics::MetaSkeleton* self,
840 const dart::dynamics::JacobianNode* _node,
841 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
842 return self->getJacobian(_node, _localOffset);
843 },
844 ::py::arg("node"),
845 ::py::arg("localOffset"))
846 .def(
847 "getJacobian",
848 +[](const dart::dynamics::MetaSkeleton* self,
849 const dart::dynamics::JacobianNode* _node,
850 const Eigen::Vector3d& _localOffset,
851 const dart::dynamics::Frame* _inCoordinatesOf)
852 -> dart::math::Jacobian {
853 return self->getJacobian(_node, _localOffset, _inCoordinatesOf);
854 },
855 ::py::arg("node"),
856 ::py::arg("localOffset"),
857 ::py::arg("inCoordinatesOf"))
858 .def(
859 "getJacobian",
860 +[](const dart::dynamics::MetaSkeleton* self,
861 const dart::dynamics::JacobianNode* _node,
862 const Eigen::Vector3d& _localOffset,
863 const dart::dynamics::JacobianNode* _relativeTo,
864 const dart::dynamics::Frame* _inCoordinatesOf)
865 -> dart::math::Jacobian {
866 return self->getJacobian(
867 _node, _localOffset, _relativeTo, _inCoordinatesOf);
868 },
869 ::py::arg("node"),
870 ::py::arg("localOffset"),
871 ::py::arg("relativeTo"),
872 ::py::arg("inCoordinatesOf"))
873 .def(
874 "getWorldJacobian",
875 +[](const dart::dynamics::MetaSkeleton* self,
876 const dart::dynamics::JacobianNode* _node)
877 -> dart::math::Jacobian { return self->getWorldJacobian(_node); },
878 ::py::arg("node"))
879 .def(
880 "getWorldJacobian",
881 +[](const dart::dynamics::MetaSkeleton* self,
882 const dart::dynamics::JacobianNode* _node,
883 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
884 return self->getWorldJacobian(_node, _localOffset);
885 },
886 ::py::arg("node"),
887 ::py::arg("localOffset"))
888 .def(
889 "getLinearJacobian",
890 +[](const dart::dynamics::MetaSkeleton* self,
891 const dart::dynamics::JacobianNode* _node)
892 -> dart::math::LinearJacobian {
893 return self->getLinearJacobian(_node);
894 },
895 ::py::arg("node"))
896 .def(
897 "getLinearJacobian",
898 +[](const dart::dynamics::MetaSkeleton* self,
899 const dart::dynamics::JacobianNode* _node,
900 const dart::dynamics::Frame* _inCoordinatesOf)
901 -> dart::math::LinearJacobian {
902 return self->getLinearJacobian(_node, _inCoordinatesOf);
903 },
904 ::py::arg("node"),
905 ::py::arg("inCoordinatesOf"))
906 .def(
907 "getLinearJacobian",
908 +[](const dart::dynamics::MetaSkeleton* self,
909 const dart::dynamics::JacobianNode* _node,
910 const Eigen::Vector3d& _localOffset)
911 -> dart::math::LinearJacobian {
912 return self->getLinearJacobian(_node, _localOffset);
913 },
914 ::py::arg("node"),
915 ::py::arg("localOffset"))
916 .def(
917 "getLinearJacobian",
918 +[](const dart::dynamics::MetaSkeleton* self,
919 const dart::dynamics::JacobianNode* _node,
920 const Eigen::Vector3d& _localOffset,
921 const dart::dynamics::Frame* _inCoordinatesOf)
922 -> dart::math::LinearJacobian {
923 return self->getLinearJacobian(
924 _node, _localOffset, _inCoordinatesOf);
925 },
926 ::py::arg("node"),
927 ::py::arg("localOffset"),
928 ::py::arg("inCoordinatesOf"))
929 .def(
930 "getLinearJacobian",
931 +[](const dart::dynamics::MetaSkeleton* self,
932 const dart::dynamics::JacobianNode* _node,
933 const dart::dynamics::JacobianNode* _relativeTo)
934 -> dart::math::LinearJacobian {
935 return self->getLinearJacobian(_node, _relativeTo);
936 },
937 ::py::arg("node"),
938 ::py::arg("relativeTo"))
939 .def(
940 "getLinearJacobian",
941 +[](const dart::dynamics::MetaSkeleton* self,
942 const dart::dynamics::JacobianNode* _node,
943 const dart::dynamics::JacobianNode* _relativeTo,
944 const dart::dynamics::Frame* _inCoordinatesOf)
945 -> dart::math::LinearJacobian {
946 return self->getLinearJacobian(
947 _node, _relativeTo, _inCoordinatesOf);
948 },
949 ::py::arg("node"),
950 ::py::arg("relativeTo"),
951 ::py::arg("inCoordinatesOf"))
952 .def(
953 "getLinearJacobian",
954 +[](const dart::dynamics::MetaSkeleton* self,
955 const dart::dynamics::JacobianNode* _node,
956 const Eigen::Vector3d& _localOffset,
957 const dart::dynamics::JacobianNode* _relativeTo)
958 -> dart::math::LinearJacobian {
959 return self->getLinearJacobian(_node, _localOffset, _relativeTo);
960 },
961 ::py::arg("node"),
962 ::py::arg("localOffset"),
963 ::py::arg("relativeTo"))
964 .def(
965 "getLinearJacobian",
966 +[](const dart::dynamics::MetaSkeleton* self,
967 const dart::dynamics::JacobianNode* _node,
968 const Eigen::Vector3d& _localOffset,
969 const dart::dynamics::JacobianNode* _relativeTo,
970 const dart::dynamics::Frame* _inCoordinatesOf)
971 -> dart::math::LinearJacobian {
972 return self->getLinearJacobian(
973 _node, _localOffset, _relativeTo, _inCoordinatesOf);
974 },
975 ::py::arg("node"),
976 ::py::arg("localOffset"),
977 ::py::arg("relativeTo"),
978 ::py::arg("inCoordinatesOf"))
979 .def(
980 "getAngularJacobian",
981 +[](const dart::dynamics::MetaSkeleton* self,
982 const dart::dynamics::JacobianNode* _node)
983 -> dart::math::AngularJacobian {
984 return self->getAngularJacobian(_node);
985 },
986 ::py::arg("node"))
987 .def(
988 "getAngularJacobian",
989 +[](const dart::dynamics::MetaSkeleton* self,
990 const dart::dynamics::JacobianNode* _node,
991 const dart::dynamics::Frame* _inCoordinatesOf)
992 -> dart::math::AngularJacobian {
993 return self->getAngularJacobian(_node, _inCoordinatesOf);
994 },
995 ::py::arg("node"),
996 ::py::arg("inCoordinatesOf"))
997 .def(
998 "getAngularJacobian",
999 +[](const dart::dynamics::MetaSkeleton* self,
1000 const dart::dynamics::JacobianNode* _node,
1001 const dart::dynamics::JacobianNode* _relativeTo)
1002 -> dart::math::AngularJacobian {
1003 return self->getAngularJacobian(_node, _relativeTo);
1004 },
1005 ::py::arg("node"),
1006 ::py::arg("relativeTo"))
1007 .def(
1008 "getAngularJacobian",
1009 +[](const dart::dynamics::MetaSkeleton* self,
1010 const dart::dynamics::JacobianNode* _node,
1011 const dart::dynamics::JacobianNode* _relativeTo,
1012 const dart::dynamics::Frame* _inCoordinatesOf)
1013 -> dart::math::AngularJacobian {
1014 return self->getAngularJacobian(
1015 _node, _relativeTo, _inCoordinatesOf);
1016 },
1017 ::py::arg("node"),
1018 ::py::arg("relativeTo"),
1019 ::py::arg("inCoordinatesOf"))
1020 .def(
1021 "getJacobianSpatialDeriv",
1022 +[](const dart::dynamics::MetaSkeleton* self,
1023 const dart::dynamics::JacobianNode* _node)
1024 -> dart::math::Jacobian {
1025 return self->getJacobianSpatialDeriv(_node);
1026 },
1027 ::py::arg("node"))
1028 .def(
1029 "getJacobianSpatialDeriv",
1030 +[](const dart::dynamics::MetaSkeleton* self,
1031 const dart::dynamics::JacobianNode* _node,
1032 const dart::dynamics::Frame* _inCoordinatesOf)
1033 -> dart::math::Jacobian {
1034 return self->getJacobianSpatialDeriv(_node, _inCoordinatesOf);
1035 },
1036 ::py::arg("node"),
1037 ::py::arg("inCoordinatesOf"))
1038 .def(
1039 "getJacobianSpatialDeriv",
1040 +[](const dart::dynamics::MetaSkeleton* self,
1041 const dart::dynamics::JacobianNode* _node,
1042 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
1043 return self->getJacobianSpatialDeriv(_node, _localOffset);
1044 },
1045 ::py::arg("node"),
1046 ::py::arg("localOffset"))
1047 .def(
1048 "getJacobianSpatialDeriv",
1049 +[](const dart::dynamics::MetaSkeleton* self,
1050 const dart::dynamics::JacobianNode* _node,
1051 const Eigen::Vector3d& _localOffset,
1052 const dart::dynamics::Frame* _inCoordinatesOf)
1053 -> dart::math::Jacobian {
1054 return self->getJacobianSpatialDeriv(
1055 _node, _localOffset, _inCoordinatesOf);
1056 },
1057 ::py::arg("node"),
1058 ::py::arg("localOffset"),
1059 ::py::arg("inCoordinatesOf"))
1060 .def(
1061 "getJacobianSpatialDeriv",
1062 +[](const dart::dynamics::MetaSkeleton* self,
1063 const dart::dynamics::JacobianNode* _node,
1064 const dart::dynamics::JacobianNode* _relativeTo,
1065 const dart::dynamics::Frame* _inCoordinatesOf)
1066 -> dart::math::Jacobian {
1067 return self->getJacobianSpatialDeriv(
1068 _node, _relativeTo, _inCoordinatesOf);
1069 },
1070 ::py::arg("node"),
1071 ::py::arg("relativeTo"),
1072 ::py::arg("inCoordinatesOf"))
1073 .def(
1074 "getJacobianSpatialDeriv",
1075 +[](const dart::dynamics::MetaSkeleton* self,
1076 const dart::dynamics::JacobianNode* _node,
1077 const Eigen::Vector3d& _localOffset,
1078 const dart::dynamics::JacobianNode* _relativeTo,
1079 const dart::dynamics::Frame* _inCoordinatesOf)
1080 -> dart::math::Jacobian {
1081 return self->getJacobianSpatialDeriv(
1082 _node, _localOffset, _relativeTo, _inCoordinatesOf);
1083 },
1084 ::py::arg("node"),
1085 ::py::arg("localOffset"),
1086 ::py::arg("relativeTo"),
1087 ::py::arg("inCoordinatesOf"))
1088 .def(
1089 "getJacobianClassicDeriv",
1090 +[](const dart::dynamics::MetaSkeleton* self,
1091 const dart::dynamics::JacobianNode* _node)
1092 -> dart::math::Jacobian {
1093 return self->getJacobianClassicDeriv(_node);
1094 },
1095 ::py::arg("node"))
1096 .def(
1097 "getJacobianClassicDeriv",
1098 +[](const dart::dynamics::MetaSkeleton* self,
1099 const dart::dynamics::JacobianNode* _node,
1100 const dart::dynamics::Frame* _inCoordinatesOf)
1101 -> dart::math::Jacobian {
1102 return self->getJacobianClassicDeriv(_node, _inCoordinatesOf);
1103 },
1104 ::py::arg("node"),
1105 ::py::arg("inCoordinatesOf"))
1106 .def(
1107 "getJacobianClassicDeriv",
1108 +[](const dart::dynamics::MetaSkeleton* self,
1109 const dart::dynamics::JacobianNode* _node,
1110 const Eigen::Vector3d& _localOffset) -> dart::math::Jacobian {
1111 return self->getJacobianClassicDeriv(_node, _localOffset);
1112 },
1113 ::py::arg("node"),
1114 ::py::arg("localOffset"))
1115 .def(
1116 "getJacobianClassicDeriv",
1117 +[](const dart::dynamics::MetaSkeleton* self,
1118 const dart::dynamics::JacobianNode* _node,
1119 const Eigen::Vector3d& _localOffset,
1120 const dart::dynamics::Frame* _inCoordinatesOf)
1121 -> dart::math::Jacobian {
1122 return self->getJacobianClassicDeriv(
1123 _node, _localOffset, _inCoordinatesOf);
1124 },
1125 ::py::arg("node"),
1126 ::py::arg("localOffset"),
1127 ::py::arg("inCoordinatesOf"))
1128 .def(
1129 "getLinearJacobianDeriv",
1130 +[](const dart::dynamics::MetaSkeleton* self,
1131 const dart::dynamics::JacobianNode* _node)
1132 -> dart::math::LinearJacobian {
1133 return self->getLinearJacobianDeriv(_node);
1134 },
1135 ::py::arg("node"))
1136 .def(
1137 "getLinearJacobianDeriv",
1138 +[](const dart::dynamics::MetaSkeleton* self,
1139 const dart::dynamics::JacobianNode* _node,
1140 const dart::dynamics::Frame* _inCoordinatesOf)
1141 -> dart::math::LinearJacobian {
1142 return self->getLinearJacobianDeriv(_node, _inCoordinatesOf);
1143 },
1144 ::py::arg("node"),
1145 ::py::arg("inCoordinatesOf"))
1146 .def(
1147 "getLinearJacobianDeriv",
1148 +[](const dart::dynamics::MetaSkeleton* self,
1149 const dart::dynamics::JacobianNode* _node,
1150 const Eigen::Vector3d& _localOffset)
1151 -> dart::math::LinearJacobian {
1152 return self->getLinearJacobianDeriv(_node, _localOffset);
1153 },
1154 ::py::arg("node"),
1155 ::py::arg("localOffset"))
1156 .def(
1157 "getLinearJacobianDeriv",
1158 +[](const dart::dynamics::MetaSkeleton* self,
1159 const dart::dynamics::JacobianNode* _node,
1160 const Eigen::Vector3d& _localOffset,
1161 const dart::dynamics::Frame* _inCoordinatesOf)
1162 -> dart::math::LinearJacobian {
1163 return self->getLinearJacobianDeriv(
1164 _node, _localOffset, _inCoordinatesOf);
1165 },
1166 ::py::arg("node"),
1167 ::py::arg("localOffset"),
1168 ::py::arg("inCoordinatesOf"))
1169 .def(
1170 "getAngularJacobianDeriv",
1171 +[](const dart::dynamics::MetaSkeleton* self,
1172 const dart::dynamics::JacobianNode* _node)
1173 -> dart::math::AngularJacobian {
1174 return self->getAngularJacobianDeriv(_node);
1175 },
1176 ::py::arg("node"))
1177 .def(
1178 "getAngularJacobianDeriv",
1179 +[](const dart::dynamics::MetaSkeleton* self,
1180 const dart::dynamics::JacobianNode* _node,
1181 const dart::dynamics::Frame* _inCoordinatesOf)
1182 -> dart::math::AngularJacobian {
1183 return self->getAngularJacobianDeriv(_node, _inCoordinatesOf);
1184 },
1185 ::py::arg("node"),
1186 ::py::arg("inCoordinatesOf"))
1187 .def(
1188 "getMass",
1189 +[](const dart::dynamics::MetaSkeleton* self)
1190 -> double { return self->getMass(); })
1191 .def(
1192 "getMassMatrix",
1193 +[](const dart::dynamics::MetaSkeleton* self)
1194 -> const Eigen::MatrixXd& { return self->getMassMatrix(); })
1195 .def(
1196 "getAugMassMatrix",
1197 +[](const dart::dynamics::MetaSkeleton* self)
1198 -> const Eigen::MatrixXd& { return self->getAugMassMatrix(); })
1199 .def(
1200 "getInvMassMatrix",
1201 +[](const dart::dynamics::MetaSkeleton* self)
1202 -> const Eigen::MatrixXd& { return self->getInvMassMatrix(); })
1203 .def(
1204 "getCoriolisForces",
1205 +[](dart::dynamics::MetaSkeleton* self) -> const Eigen::VectorXd& {
1206 return self->getCoriolisForces();
1207 })
1208 .def(
1209 "getGravityForces",
1210 +[](dart::dynamics::MetaSkeleton* self) -> const Eigen::VectorXd& {
1211 return self->getGravityForces();
1212 })
1213 .def(
1214 "getCoriolisAndGravityForces",
1215 +[](dart::dynamics::MetaSkeleton* self) -> const Eigen::VectorXd& {
1216 return self->getCoriolisAndGravityForces();
1217 })
1218 .def(
1219 "getExternalForces",
1220 +[](dart::dynamics::MetaSkeleton* self) -> const Eigen::VectorXd& {
1221 return self->getExternalForces();
1222 })
1223 .def(
1224 "getConstraintForces",
1225 +[](dart::dynamics::MetaSkeleton* self) -> const Eigen::VectorXd& {
1226 return self->getConstraintForces();
1227 })
1228 .def(
1229 "clearExternalForces",
1230 +[](dart::dynamics::MetaSkeleton*
1231 self) { self->clearExternalForces(); })
1232 .def(
1233 "clearInternalForces",
1234 +[](dart::dynamics::MetaSkeleton*
1235 self) { self->clearInternalForces(); })
1236 .def(
1237 "computeLagrangian",
1238 +[](const dart::dynamics::MetaSkeleton* self) -> double {
1239 return self->computeLagrangian();
1240 })
1241 .def(
1242 "computeKineticEnergy",
1243 +[](const dart::dynamics::MetaSkeleton* self) -> double {
1244 return self->computeKineticEnergy();
1245 })
1246 .def(
1247 "computePotentialEnergy",
1248 +[](const dart::dynamics::MetaSkeleton* self) -> double {
1249 return self->computePotentialEnergy();
1250 })
1251 .def(
1252 "getCOM",
1253 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::Vector3d {
1254 return self->getCOM();
1255 })
1256 .def(
1257 "getCOM",
1258 +[](const dart::dynamics::MetaSkeleton* self,
1259 const dart::dynamics::Frame* _withRespectTo) -> Eigen::Vector3d {
1260 return self->getCOM(_withRespectTo);
1261 },
1262 ::py::arg("withRespectTo"))
1263 .def(
1264 "getCOMSpatialVelocity",
1265 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::Vector6d {
1266 return self->getCOMSpatialVelocity();
1267 })
1268 .def(
1269 "getCOMSpatialVelocity",
1270 +[](const dart::dynamics::MetaSkeleton* self,
1271 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector6d {
1272 return self->getCOMSpatialVelocity(_relativeTo);
1273 },
1274 ::py::arg("relativeTo"))
1275 .def(
1276 "getCOMSpatialVelocity",
1277 +[](const dart::dynamics::MetaSkeleton* self,
1278 const dart::dynamics::Frame* _relativeTo,
1279 const dart::dynamics::Frame* _inCoordinatesOf)
1280 -> Eigen::Vector6d {
1281 return self->getCOMSpatialVelocity(_relativeTo, _inCoordinatesOf);
1282 },
1283 ::py::arg("relativeTo"),
1284 ::py::arg("inCoordinatesOf"))
1285 .def(
1286 "getCOMLinearVelocity",
1287 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::Vector3d {
1288 return self->getCOMLinearVelocity();
1289 })
1290 .def(
1291 "getCOMLinearVelocity",
1292 +[](const dart::dynamics::MetaSkeleton* self,
1293 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector3d {
1294 return self->getCOMLinearVelocity(_relativeTo);
1295 },
1296 ::py::arg("relativeTo"))
1297 .def(
1298 "getCOMLinearVelocity",
1299 +[](const dart::dynamics::MetaSkeleton* self,
1300 const dart::dynamics::Frame* _relativeTo,
1301 const dart::dynamics::Frame* _inCoordinatesOf)
1302 -> Eigen::Vector3d {
1303 return self->getCOMLinearVelocity(_relativeTo, _inCoordinatesOf);
1304 },
1305 ::py::arg("relativeTo"),
1306 ::py::arg("inCoordinatesOf"))
1307 .def(
1308 "getCOMSpatialAcceleration",
1309 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::Vector6d {
1310 return self->getCOMSpatialAcceleration();
1311 })
1312 .def(
1313 "getCOMSpatialAcceleration",
1314 +[](const dart::dynamics::MetaSkeleton* self,
1315 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector6d {
1316 return self->getCOMSpatialAcceleration(_relativeTo);
1317 },
1318 ::py::arg("relativeTo"))
1319 .def(
1320 "getCOMSpatialAcceleration",
1321 +[](const dart::dynamics::MetaSkeleton* self,
1322 const dart::dynamics::Frame* _relativeTo,
1323 const dart::dynamics::Frame* _inCoordinatesOf)
1324 -> Eigen::Vector6d {
1325 return self->getCOMSpatialAcceleration(
1326 _relativeTo, _inCoordinatesOf);
1327 },
1328 ::py::arg("relativeTo"),
1329 ::py::arg("inCoordinatesOf"))
1330 .def(
1331 "getCOMLinearAcceleration",
1332 +[](const dart::dynamics::MetaSkeleton* self) -> Eigen::Vector3d {
1333 return self->getCOMLinearAcceleration();
1334 })
1335 .def(
1336 "getCOMLinearAcceleration",
1337 +[](const dart::dynamics::MetaSkeleton* self,
1338 const dart::dynamics::Frame* _relativeTo) -> Eigen::Vector3d {
1339 return self->getCOMLinearAcceleration(_relativeTo);
1340 },
1341 ::py::arg("relativeTo"))
1342 .def(
1343 "getCOMLinearAcceleration",
1344 +[](const dart::dynamics::MetaSkeleton* self,
1345 const dart::dynamics::Frame* _relativeTo,
1346 const dart::dynamics::Frame* _inCoordinatesOf)
1347 -> Eigen::Vector3d {
1348 return self->getCOMLinearAcceleration(
1349 _relativeTo, _inCoordinatesOf);
1350 },
1351 ::py::arg("relativeTo"),
1352 ::py::arg("inCoordinatesOf"))
1353 .def(
1354 "getCOMJacobian",
1355 +[](const dart::dynamics::MetaSkeleton* self)
1356 -> dart::math::Jacobian { return self->getCOMJacobian(); })
1357 .def(
1358 "getCOMJacobian",
1359 +[](const dart::dynamics::MetaSkeleton* self,
1360 const dart::dynamics::Frame* _inCoordinatesOf)
1361 -> dart::math::Jacobian {
1362 return self->getCOMJacobian(_inCoordinatesOf);
1363 },
1364 ::py::arg("inCoordinatesOf"))
1365 .def(
1366 "getCOMLinearJacobian",
1367 +[](const dart::dynamics::MetaSkeleton* self)
1368 -> dart::math::LinearJacobian {
1369 return self->getCOMLinearJacobian();
1370 })
1371 .def(
1372 "getCOMLinearJacobian",
1373 +[](const dart::dynamics::MetaSkeleton* self,
1374 const dart::dynamics::Frame* _inCoordinatesOf)
1375 -> dart::math::LinearJacobian {
1376 return self->getCOMLinearJacobian(_inCoordinatesOf);
1377 },
1378 ::py::arg("inCoordinatesOf"))
1379 .def(
1380 "getCOMJacobianSpatialDeriv",
1381 +[](const dart::dynamics::MetaSkeleton* self)
1382 -> dart::math::Jacobian {
1383 return self->getCOMJacobianSpatialDeriv();
1384 })
1385 .def(
1386 "getCOMJacobianSpatialDeriv",
1387 +[](const dart::dynamics::MetaSkeleton* self,
1388 const dart::dynamics::Frame* _inCoordinatesOf)
1389 -> dart::math::Jacobian {
1390 return self->getCOMJacobianSpatialDeriv(_inCoordinatesOf);
1391 },
1392 ::py::arg("inCoordinatesOf"))
1393 .def(
1394 "getCOMLinearJacobianDeriv",
1395 +[](const dart::dynamics::MetaSkeleton* self)
1396 -> dart::math::LinearJacobian {
1397 return self->getCOMLinearJacobianDeriv();
1398 })
1399 .def(
1400 "getCOMLinearJacobianDeriv",
1401 +[](const dart::dynamics::MetaSkeleton* self,
1402 const dart::dynamics::Frame* _inCoordinatesOf)
1403 -> dart::math::LinearJacobian {
1404 return self->getCOMLinearJacobianDeriv(_inCoordinatesOf);
1405 },
1406 ::py::arg("inCoordinatesOf"))
1407 .def(
1408 "setColor",
1409 ::py::overload_cast<const Eigen::Vector3d&>(
1410 &dynamics::MetaSkeleton::setColor),
1411 ::py::arg("color"))
1412 .def(
1413 "setColor",
1414 ::py::overload_cast<const Eigen::Vector4d&>(
1415 &dynamics::MetaSkeleton::setColor),
1416 ::py::arg("color"))
1417 .def(
1418 "setAlpha",
1419 &dart::dynamics::MetaSkeleton::setAlpha,
1420 ::py::arg("alpha"));
1421 }
1422
1423 } // namespace python
1424 } // namespace dart