Debian Codegraph @

python/dartpy/dynamics/Frame.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 Frame(py::module& m)
45 {
46 ::py::class_<
47 dart::dynamics::Frame,
48 dart::dynamics::Entity,
49 std::shared_ptr<dart::dynamics::Frame> >(m, "Frame")
50 .def(
51 "getRelativeTransform",
52 +[](const dart::dynamics::Frame* self) -> Eigen::Isometry3d {
53 return self->getRelativeTransform();
54 })
55 .def(
56 "getWorldTransform",
57 +[](const dart::dynamics::Frame* self) -> Eigen::Isometry3d {
58 return self->getWorldTransform();
59 })
60 .def(
61 "getTransform",
62 +[](const dart::dynamics::Frame* self) -> Eigen::Isometry3d {
63 return self->getTransform();
64 })
65 .def(
66 "getTransform",
67 +[](const dart::dynamics::Frame* self,
68 const dart::dynamics::Frame* withRespectTo) -> Eigen::Isometry3d {
69 return self->getTransform(withRespectTo);
70 },
71 ::py::arg("withRespectTo"))
72 .def(
73 "getTransform",
74 +[](const dart::dynamics::Frame* self,
75 const dart::dynamics::Frame* withRespectTo,
76 const dart::dynamics::Frame* inCoordinatesOf)
77 -> Eigen::Isometry3d {
78 return self->getTransform(withRespectTo, inCoordinatesOf);
79 },
80 ::py::arg("withRespectTo"),
81 ::py::arg("inCoordinatesOf"))
82 .def(
83 "getSpatialVelocity",
84 +[](const dart::dynamics::Frame* self) -> Eigen::Vector6d {
85 return self->getSpatialVelocity();
86 })
87 .def(
88 "getSpatialVelocity",
89 +[](const dart::dynamics::Frame* self,
90 const dart::dynamics::Frame* relativeTo,
91 const dart::dynamics::Frame* inCoordinatesOf) -> Eigen::Vector6d {
92 return self->getSpatialVelocity(relativeTo, inCoordinatesOf);
93 },
94 ::py::arg("relativeTo"),
95 ::py::arg("inCoordinatesOf"))
96 .def(
97 "getSpatialVelocity",
98 +[](const dart::dynamics::Frame* self, const Eigen::Vector3d& offset)
99 -> Eigen::Vector6d { return self->getSpatialVelocity(offset); },
100 ::py::arg("offset"))
101 .def(
102 "getSpatialVelocity",
103 +[](const dart::dynamics::Frame* self,
104 const Eigen::Vector3d& offset,
105 const dart::dynamics::Frame* relativeTo,
106 const dart::dynamics::Frame* inCoordinatesOf) -> Eigen::Vector6d {
107 return self->getSpatialVelocity(
108 offset, relativeTo, inCoordinatesOf);
109 },
110 ::py::arg("offset"),
111 ::py::arg("relativeTo"),
112 ::py::arg("inCoordinatesOf"))
113 .def(
114 "getLinearVelocity",
115 +[](const dart::dynamics::Frame* self) -> Eigen::Vector3d {
116 return self->getLinearVelocity();
117 })
118 .def(
119 "getLinearVelocity",
120 +[](const dart::dynamics::Frame* self,
121 const dart::dynamics::Frame* relativeTo) -> Eigen::Vector3d {
122 return self->getLinearVelocity(relativeTo);
123 },
124 ::py::arg("relativeTo"))
125 .def(
126 "getLinearVelocity",
127 +[](const dart::dynamics::Frame* self,
128 const dart::dynamics::Frame* relativeTo,
129 const dart::dynamics::Frame* inCoordinatesOf) -> Eigen::Vector3d {
130 return self->getLinearVelocity(relativeTo, inCoordinatesOf);
131 },
132 ::py::arg("relativeTo"),
133 ::py::arg("inCoordinatesOf"))
134 .def(
135 "getLinearVelocity",
136 +[](const dart::dynamics::Frame* self, const Eigen::Vector3d& offset)
137 -> Eigen::Vector3d { return self->getLinearVelocity(offset); },
138 ::py::arg("offset"))
139 .def(
140 "getLinearVelocity",
141 +[](const dart::dynamics::Frame* self,
142 const Eigen::Vector3d& offset,
143 const dart::dynamics::Frame* relativeTo) -> Eigen::Vector3d {
144 return self->getLinearVelocity(offset, relativeTo);
145 },
146 ::py::arg("offset"),
147 ::py::arg("relativeTo"))
148 .def(
149 "getLinearVelocity",
150 +[](const dart::dynamics::Frame* self,
151 const Eigen::Vector3d& offset,
152 const dart::dynamics::Frame* relativeTo,
153 const dart::dynamics::Frame* inCoordinatesOf) -> Eigen::Vector3d {
154 return self->getLinearVelocity(offset, relativeTo, inCoordinatesOf);
155 },
156 ::py::arg("offset"),
157 ::py::arg("relativeTo"),
158 ::py::arg("inCoordinatesOf"))
159 .def(
160 "getAngularVelocity",
161 +[](const dart::dynamics::Frame* self) -> Eigen::Vector3d {
162 return self->getAngularVelocity();
163 })
164 .def(
165 "getAngularVelocity",
166 +[](const dart::dynamics::Frame* self,
167 const dart::dynamics::Frame* relativeTo) -> Eigen::Vector3d {
168 return self->getAngularVelocity(relativeTo);
169 },
170 ::py::arg("relativeTo"))
171 .def(
172 "getAngularVelocity",
173 +[](const dart::dynamics::Frame* self,
174 const dart::dynamics::Frame* relativeTo,
175 const dart::dynamics::Frame* inCoordinatesOf) -> Eigen::Vector3d {
176 return self->getAngularVelocity(relativeTo, inCoordinatesOf);
177 },
178 ::py::arg("relativeTo"),
179 ::py::arg("inCoordinatesOf"))
180 .def(
181 "getSpatialAcceleration",
182 +[](const dart::dynamics::Frame* self) -> Eigen::Vector6d {
183 return self->getSpatialAcceleration();
184 })
185 .def(
186 "getSpatialAcceleration",
187 +[](const dart::dynamics::Frame* self,
188 const dart::dynamics::Frame* relativeTo,
189 const dart::dynamics::Frame* inCoordinatesOf) -> Eigen::Vector6d {
190 return self->getSpatialAcceleration(relativeTo, inCoordinatesOf);
191 },
192 ::py::arg("relativeTo"),
193 ::py::arg("inCoordinatesOf"))
194 .def(
195 "getSpatialAcceleration",
196 +[](const dart::dynamics::Frame* self,
197 const Eigen::Vector3d& offset) -> Eigen::Vector6d {
198 return self->getSpatialAcceleration(offset);
199 },
200 ::py::arg("offset"))
201 .def(
202 "getSpatialAcceleration",
203 +[](const dart::dynamics::Frame* self,
204 const Eigen::Vector3d& offset,
205 const dart::dynamics::Frame* relativeTo,
206 const dart::dynamics::Frame* inCoordinatesOf) -> Eigen::Vector6d {
207 return self->getSpatialAcceleration(
208 offset, relativeTo, inCoordinatesOf);
209 },
210 ::py::arg("offset"),
211 ::py::arg("relativeTo"),
212 ::py::arg("inCoordinatesOf"))
213 .def(
214 "getLinearAcceleration",
215 +[](const dart::dynamics::Frame* self) -> Eigen::Vector3d {
216 return self->getLinearAcceleration();
217 })
218 .def(
219 "getLinearAcceleration",
220 +[](const dart::dynamics::Frame* self,
221 const dart::dynamics::Frame* relativeTo) -> Eigen::Vector3d {
222 return self->getLinearAcceleration(relativeTo);
223 },
224 ::py::arg("relativeTo"))
225 .def(
226 "getLinearAcceleration",
227 +[](const dart::dynamics::Frame* self,
228 const dart::dynamics::Frame* relativeTo,
229 const dart::dynamics::Frame* inCoordinatesOf) -> Eigen::Vector3d {
230 return self->getLinearAcceleration(relativeTo, inCoordinatesOf);
231 },
232 ::py::arg("relativeTo"),
233 ::py::arg("inCoordinatesOf"))
234 .def(
235 "getLinearAcceleration",
236 +[](const dart::dynamics::Frame* self,
237 const Eigen::Vector3d& offset) -> Eigen::Vector3d {
238 return self->getLinearAcceleration(offset);
239 },
240 ::py::arg("offset"))
241 .def(
242 "getLinearAcceleration",
243 +[](const dart::dynamics::Frame* self,
244 const Eigen::Vector3d& offset,
245 const dart::dynamics::Frame* relativeTo) -> Eigen::Vector3d {
246 return self->getLinearAcceleration(offset, relativeTo);
247 },
248 ::py::arg("offset"),
249 ::py::arg("relativeTo"))
250 .def(
251 "getLinearAcceleration",
252 +[](const dart::dynamics::Frame* self,
253 const Eigen::Vector3d& offset,
254 const dart::dynamics::Frame* relativeTo,
255 const dart::dynamics::Frame* inCoordinatesOf) -> Eigen::Vector3d {
256 return self->getLinearAcceleration(
257 offset, relativeTo, inCoordinatesOf);
258 },
259 ::py::arg("offset"),
260 ::py::arg("relativeTo"),
261 ::py::arg("inCoordinatesOf"))
262 .def(
263 "getAngularAcceleration",
264 +[](const dart::dynamics::Frame* self) -> Eigen::Vector3d {
265 return self->getAngularAcceleration();
266 })
267 .def(
268 "getAngularAcceleration",
269 +[](const dart::dynamics::Frame* self,
270 const dart::dynamics::Frame* relativeTo) -> Eigen::Vector3d {
271 return self->getAngularAcceleration(relativeTo);
272 },
273 ::py::arg("relativeTo"))
274 .def(
275 "getAngularAcceleration",
276 +[](const dart::dynamics::Frame* self,
277 const dart::dynamics::Frame* relativeTo,
278 const dart::dynamics::Frame* inCoordinatesOf) -> Eigen::Vector3d {
279 return self->getAngularAcceleration(relativeTo, inCoordinatesOf);
280 },
281 ::py::arg("relativeTo"),
282 ::py::arg("inCoordinatesOf"))
283 .def(
284 "getChildEntities",
285 +[](const dart::dynamics::Frame* self)
286 -> const std::set<const dart::dynamics::Entity*> {
287 return self->getChildEntities();
288 })
289 .def(
290 "getNumChildEntities",
291 +[](const dart::dynamics::Frame* self) -> std::size_t {
292 return self->getNumChildEntities();
293 })
294 .def(
295 "getChildFrames",
296 +[](const dart::dynamics::Frame* self)
297 -> std::set<const dart::dynamics::Frame*> {
298 return self->getChildFrames();
299 })
300 .def(
301 "getNumChildFrames",
302 +[](const dart::dynamics::Frame* self) -> std::size_t {
303 return self->getNumChildFrames();
304 })
305 .def(
306 "isShapeFrame",
307 +[](const dart::dynamics::Frame* self) -> bool {
308 return self->isShapeFrame();
309 })
310 .def(
311 "isWorld",
312 +[](const dart::dynamics::Frame* self) -> bool {
313 return self->isWorld();
314 })
315 .def(
316 "dirtyTransform",
317 +[](dart::dynamics::Frame* self) { self->dirtyTransform(); })
318 .def(
319 "dirtyVelocity",
320 +[](dart::dynamics::Frame* self) { self->dirtyVelocity(); })
321 .def(
322 "dirtyAcceleration",
323 +[](dart::dynamics::Frame* self) { self->dirtyAcceleration(); })
324 .def_static(
325 "World", +[]() -> std::shared_ptr<dart::dynamics::Frame> {
326 return dart::dynamics::Frame::WorldShared();
327 });
328 }
329
330 } // namespace python
331 } // namespace dart