Debian Codegraph @

python/dartpy/dynamics/JacobianNode.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 JacobianNode(py::module& m)
45 {
46 ::py::class_<
47 dart::dynamics::JacobianNode,
48 dart::dynamics::Frame,
49 dart::dynamics::Node,
50 std::shared_ptr<dart::dynamics::JacobianNode>>(m, "JacobianNode")
51 .def(
52 "getIK",
53 +[](dart::dynamics::JacobianNode* self)
54 -> std::shared_ptr<dart::dynamics::InverseKinematics> {
55 return self->getIK();
56 })
57 .def(
58 "getIK",
59 +[](dart::dynamics::JacobianNode* self, bool createIfNull)
60 -> std::shared_ptr<dart::dynamics::InverseKinematics> {
61 return self->getIK(createIfNull);
62 },
63 ::py::arg("createIfNull"))
64 .def(
65 "getOrCreateIK",
66 +[](dart::dynamics::JacobianNode* self)
67 -> std::shared_ptr<dart::dynamics::InverseKinematics> {
68 return self->getOrCreateIK();
69 })
70 .def(
71 "clearIK",
72 +[](dart::dynamics::JacobianNode* self) { self->clearIK(); })
73 .def(
74 "dependsOn",
75 +[](const dart::dynamics::JacobianNode* self,
76 std::size_t _genCoordIndex) -> bool {
77 return self->dependsOn(_genCoordIndex);
78 },
79 ::py::arg("genCoordIndex"))
80 .def(
81 "getNumDependentGenCoords",
82 +[](const dart::dynamics::JacobianNode* self) -> std::size_t {
83 return self->getNumDependentGenCoords();
84 })
85 .def(
86 "getDependentGenCoordIndex",
87 +[](const dart::dynamics::JacobianNode* self,
88 std::size_t _arrayIndex) -> std::size_t {
89 return self->getDependentGenCoordIndex(_arrayIndex);
90 },
91 ::py::arg("arrayIndex"))
92 .def(
93 "getNumDependentDofs",
94 +[](const dart::dynamics::JacobianNode* self) -> std::size_t {
95 return self->getNumDependentDofs();
96 })
97 .def(
98 "getChainDofs",
99 +[](const dart::dynamics::JacobianNode* self)
100 -> const std::vector<const dart::dynamics::DegreeOfFreedom*> {
101 return self->getChainDofs();
102 })
103 .def(
104 "getJacobian",
105 +[](const dart::dynamics::JacobianNode* self,
106 const dart::dynamics::Frame* _inCoordinatesOf)
107 -> dart::math::Jacobian {
108 return self->getJacobian(_inCoordinatesOf);
109 },
110 ::py::arg("inCoordinatesOf"))
111 .def(
112 "getJacobian",
113 +[](const dart::dynamics::JacobianNode* self,
114 const Eigen::Vector3d& _offset) -> dart::math::Jacobian {
115 return self->getJacobian(_offset);
116 },
117 ::py::arg("offset"))
118 .def(
119 "getJacobian",
120 +[](const dart::dynamics::JacobianNode* self,
121 const Eigen::Vector3d& _offset,
122 const dart::dynamics::Frame* _inCoordinatesOf)
123 -> dart::math::Jacobian {
124 return self->getJacobian(_offset, _inCoordinatesOf);
125 },
126 ::py::arg("offset"),
127 ::py::arg("inCoordinatesOf"))
128 .def(
129 "getWorldJacobian",
130 +[](const dart::dynamics::JacobianNode* self,
131 const Eigen::Vector3d& _offset) -> dart::math::Jacobian {
132 return self->getWorldJacobian(_offset);
133 },
134 ::py::arg("offset"))
135 .def(
136 "getLinearJacobian",
137 +[](const dart::dynamics::JacobianNode* self)
138 -> dart::math::LinearJacobian {
139 return self->getLinearJacobian();
140 })
141 .def(
142 "getLinearJacobian",
143 +[](const dart::dynamics::JacobianNode* self,
144 const dart::dynamics::Frame* _inCoordinatesOf)
145 -> dart::math::LinearJacobian {
146 return self->getLinearJacobian(_inCoordinatesOf);
147 },
148 ::py::arg("inCoordinatesOf"))
149 .def(
150 "getLinearJacobian",
151 +[](const dart::dynamics::JacobianNode* self,
152 const Eigen::Vector3d& _offset) -> dart::math::LinearJacobian {
153 return self->getLinearJacobian(_offset);
154 },
155 ::py::arg("offset"))
156 .def(
157 "getLinearJacobian",
158 +[](const dart::dynamics::JacobianNode* self,
159 const Eigen::Vector3d& _offset,
160 const dart::dynamics::Frame* _inCoordinatesOf)
161 -> dart::math::LinearJacobian {
162 return self->getLinearJacobian(_offset, _inCoordinatesOf);
163 },
164 ::py::arg("offset"),
165 ::py::arg("inCoordinatesOf"))
166 .def(
167 "getAngularJacobian",
168 +[](const dart::dynamics::JacobianNode* self)
169 -> dart::math::AngularJacobian {
170 return self->getAngularJacobian();
171 })
172 .def(
173 "getAngularJacobian",
174 +[](const dart::dynamics::JacobianNode* self,
175 const dart::dynamics::Frame* _inCoordinatesOf)
176 -> dart::math::AngularJacobian {
177 return self->getAngularJacobian(_inCoordinatesOf);
178 },
179 ::py::arg("inCoordinatesOf"))
180 .def(
181 "getJacobianSpatialDeriv",
182 +[](const dart::dynamics::JacobianNode* self,
183 const dart::dynamics::Frame* _inCoordinatesOf)
184 -> dart::math::Jacobian {
185 return self->getJacobianSpatialDeriv(_inCoordinatesOf);
186 },
187 ::py::arg("inCoordinatesOf"))
188 .def(
189 "getJacobianSpatialDeriv",
190 +[](const dart::dynamics::JacobianNode* self,
191 const Eigen::Vector3d& _offset) -> dart::math::Jacobian {
192 return self->getJacobianSpatialDeriv(_offset);
193 },
194 ::py::arg("offset"))
195 .def(
196 "getJacobianSpatialDeriv",
197 +[](const dart::dynamics::JacobianNode* self,
198 const Eigen::Vector3d& _offset,
199 const dart::dynamics::Frame* _inCoordinatesOf)
200 -> dart::math::Jacobian {
201 return self->getJacobianSpatialDeriv(_offset, _inCoordinatesOf);
202 },
203 ::py::arg("offset"),
204 ::py::arg("inCoordinatesOf"))
205 .def(
206 "getJacobianClassicDeriv",
207 +[](const dart::dynamics::JacobianNode* self,
208 const dart::dynamics::Frame* _inCoordinatesOf)
209 -> dart::math::Jacobian {
210 return self->getJacobianClassicDeriv(_inCoordinatesOf);
211 },
212 ::py::arg("inCoordinatesOf"))
213 .def(
214 "getJacobianClassicDeriv",
215 +[](const dart::dynamics::JacobianNode* self,
216 const Eigen::Vector3d& _offset) -> dart::math::Jacobian {
217 return self->getJacobianClassicDeriv(_offset);
218 },
219 ::py::arg("offset"))
220 .def(
221 "getJacobianClassicDeriv",
222 +[](const dart::dynamics::JacobianNode* self,
223 const Eigen::Vector3d& _offset,
224 const dart::dynamics::Frame* _inCoordinatesOf)
225 -> dart::math::Jacobian {
226 return self->getJacobianClassicDeriv(_offset, _inCoordinatesOf);
227 },
228 ::py::arg("offset"),
229 ::py::arg("inCoordinatesOf"))
230 .def(
231 "getLinearJacobianDeriv",
232 +[](const dart::dynamics::JacobianNode* self)
233 -> dart::math::LinearJacobian {
234 return self->getLinearJacobianDeriv();
235 })
236 .def(
237 "getLinearJacobianDeriv",
238 +[](const dart::dynamics::JacobianNode* self,
239 const dart::dynamics::Frame* _inCoordinatesOf)
240 -> dart::math::LinearJacobian {
241 return self->getLinearJacobianDeriv(_inCoordinatesOf);
242 },
243 ::py::arg("inCoordinatesOf"))
244 .def(
245 "getLinearJacobianDeriv",
246 +[](const dart::dynamics::JacobianNode* self,
247 const Eigen::Vector3d& _offset) -> dart::math::LinearJacobian {
248 return self->getLinearJacobianDeriv(_offset);
249 },
250 ::py::arg("offset"))
251 .def(
252 "getLinearJacobianDeriv",
253 +[](const dart::dynamics::JacobianNode* self,
254 const Eigen::Vector3d& _offset,
255 const dart::dynamics::Frame* _inCoordinatesOf)
256 -> dart::math::LinearJacobian {
257 return self->getLinearJacobianDeriv(_offset, _inCoordinatesOf);
258 },
259 ::py::arg("offset"),
260 ::py::arg("inCoordinatesOf"))
261 .def(
262 "getAngularJacobianDeriv",
263 +[](const dart::dynamics::JacobianNode* self)
264 -> dart::math::AngularJacobian {
265 return self->getAngularJacobianDeriv();
266 })
267 .def(
268 "getAngularJacobianDeriv",
269 +[](const dart::dynamics::JacobianNode* self,
270 const dart::dynamics::Frame* _inCoordinatesOf)
271 -> dart::math::AngularJacobian {
272 return self->getAngularJacobianDeriv(_inCoordinatesOf);
273 },
274 ::py::arg("inCoordinatesOf"))
275 .def(
276 "dirtyJacobian",
277 +[](dart::dynamics::JacobianNode* self) { self->dirtyJacobian(); })
278 .def(
279 "dirtyJacobianDeriv", +[](dart::dynamics::JacobianNode* self) {
280 self->dirtyJacobianDeriv();
281 });
282 }
283
284 } // namespace python
285 } // namespace dart