GCC Code Coverage Report | |||||||||||||||||||||
|
|||||||||||||||||||||
Line | Branch | Exec | Source |
1 |
// |
||
2 |
// Copyright (c) 2015-2023 CNRS INRIA |
||
3 |
// Copyright (c) 2016 Wandercraft, 86 rue de Paris 91400 Orsay, France. |
||
4 |
// |
||
5 |
|||
6 |
#ifndef __pinocchio_python_spatial_se3_hpp__ |
||
7 |
#define __pinocchio_python_spatial_se3_hpp__ |
||
8 |
|||
9 |
#include <eigenpy/eigenpy.hpp> |
||
10 |
#include <eigenpy/memory.hpp> |
||
11 |
#include <boost/python/tuple.hpp> |
||
12 |
|||
13 |
#include "pinocchio/spatial/se3.hpp" |
||
14 |
#include "pinocchio/spatial/motion.hpp" |
||
15 |
#include "pinocchio/spatial/force.hpp" |
||
16 |
#include "pinocchio/spatial/inertia.hpp" |
||
17 |
#include "pinocchio/spatial/explog.hpp" |
||
18 |
|||
19 |
#include "pinocchio/bindings/python/fwd.hpp" |
||
20 |
#include "pinocchio/bindings/python/utils/copyable.hpp" |
||
21 |
#include "pinocchio/bindings/python/utils/printable.hpp" |
||
22 |
|||
23 |
EIGENPY_DEFINE_STRUCT_ALLOCATOR_SPECIALIZATION(pinocchio::SE3) |
||
24 |
|||
25 |
namespace pinocchio |
||
26 |
{ |
||
27 |
namespace python |
||
28 |
{ |
||
29 |
namespace bp = boost::python; |
||
30 |
|||
31 |
✗✗ | 38 |
BOOST_PYTHON_MEMBER_FUNCTION_OVERLOADS(isIdentity_overload,SE3::isIdentity,0,1) |
32 |
|||
33 |
template<typename T> struct call; |
||
34 |
|||
35 |
template<typename Scalar, int Options> |
||
36 |
struct call< SE3Tpl<Scalar,Options> > |
||
37 |
{ |
||
38 |
typedef SE3Tpl<Scalar,Options> SE3; |
||
39 |
|||
40 |
static bool isApprox(const SE3 & self, const SE3 & other, |
||
41 |
const Scalar & prec = Eigen::NumTraits<Scalar>::dummy_precision()) |
||
42 |
{ |
||
43 |
return self.isApprox(other,prec); |
||
44 |
} |
||
45 |
}; |
||
46 |
|||
47 |
✗✗ | 38 |
BOOST_PYTHON_FUNCTION_OVERLOADS(isApproxSE3_overload,call<SE3>::isApprox,2,3) |
48 |
|||
49 |
template<typename SE3> |
||
50 |
struct SE3PythonVisitor |
||
51 |
: public boost::python::def_visitor< SE3PythonVisitor<SE3> > |
||
52 |
{ |
||
53 |
typedef typename SE3::Scalar Scalar; |
||
54 |
typedef typename SE3::Matrix3 Matrix3; |
||
55 |
typedef typename SE3::Vector3 Vector3; |
||
56 |
typedef typename SE3::Matrix4 Matrix4; |
||
57 |
typedef typename SE3::Quaternion Quaternion; |
||
58 |
|||
59 |
public: |
||
60 |
|||
61 |
template<class PyClass> |
||
62 |
19 |
void visit(PyClass& cl) const |
|
63 |
{ |
||
64 |
cl |
||
65 |
.def(bp::init<Matrix3,Vector3> |
||
66 |
(bp::args("self","rotation","translation"), |
||
67 |
"Initialize from a rotation matrix and a translation vector.")) |
||
68 |
✓✗✓✗ |
19 |
.def(bp::init<Quaternion,Vector3> |
69 |
(bp::args("self","quat","translation"), |
||
70 |
"Initialize from a quaternion and a translation vector.")) |
||
71 |
✓✗✓✗ ✓✗ |
38 |
.def(bp::init<int>(bp::args("self","int"),"Init to identity.")) |
72 |
✓✗✓✗ ✓✗ |
38 |
.def(bp::init<SE3>(bp::args("self","other"), "Copy constructor.")) |
73 |
✓✗✓✗ ✓✗ |
38 |
.def(bp::init<Matrix4> |
74 |
(bp::args("self","array"), |
||
75 |
"Initialize from an homogeneous matrix.")) |
||
76 |
|||
77 |
✓✗✓✗ ✓✗ |
38 |
.add_property("rotation", |
78 |
bp::make_function((typename SE3::AngularRef (SE3::*)()) &SE3::rotation,bp::return_internal_reference<>()), |
||
79 |
(void (SE3::*)(const Matrix3 &)) &SE3::rotation, |
||
80 |
"The rotation part of the transformation.") |
||
81 |
✓✗ | 38 |
.add_property("translation", |
82 |
bp::make_function((typename SE3::LinearRef (SE3::*)()) &SE3::translation,bp::return_internal_reference<>()), |
||
83 |
(void (SE3::*)(const Vector3 &)) &SE3::translation, |
||
84 |
"The translation part of the transformation.") |
||
85 |
|||
86 |
✓✗✓✗ |
57 |
.add_property("homogeneous",&SE3::toHomogeneousMatrix, |
87 |
"Returns the equivalent homegeneous matrix (acting on SE3).") |
||
88 |
✓✗ | 19 |
.add_property("action",&SE3::toActionMatrix, |
89 |
"Returns the related action matrix (acting on Motion).") |
||
90 |
✓✗ | 19 |
.def("toActionMatrix",&SE3::toActionMatrix,bp::arg("self"), |
91 |
"Returns the related action matrix (acting on Motion).") |
||
92 |
✓✗✓✗ |
38 |
.add_property("actionInverse",&SE3::toActionMatrixInverse, |
93 |
"Returns the inverse of the action matrix (acting on Motion).\n" |
||
94 |
"This is equivalent to do m.inverse().action") |
||
95 |
✓✗ | 19 |
.def("toActionMatrixInverse",&SE3::toActionMatrixInverse,bp::arg("self"), |
96 |
"Returns the inverse of the action matrix (acting on Motion).\n" |
||
97 |
"This is equivalent to do m.inverse().toActionMatrix()") |
||
98 |
✓✗✓✗ |
38 |
.add_property("dualAction",&SE3::toDualActionMatrix, |
99 |
"Returns the related dual action matrix (acting on Force).") |
||
100 |
✓✗ | 19 |
.def("toDualActionMatrix",&SE3::toDualActionMatrix,bp::arg("self"), |
101 |
"Returns the related dual action matrix (acting on Force).") |
||
102 |
|||
103 |
✓✗✓✗ |
38 |
.def("setIdentity",&SE3PythonVisitor::setIdentity,bp::arg("self"), |
104 |
"Set *this to the identity placement.") |
||
105 |
✓✗✓✗ ✓✗ |
38 |
.def("setRandom",&SE3PythonVisitor::setRandom,bp::arg("self"), |
106 |
"Set *this to a random placement.") |
||
107 |
|||
108 |
✓✗✓✗ |
38 |
.def("inverse", &SE3::inverse, bp::arg("self"), |
109 |
"Returns the inverse transform") |
||
110 |
|||
111 |
✓✗ | 38 |
.def("act", (Vector3 (SE3::*)(const Vector3 &) const) &SE3::act, |
112 |
bp::args("self","point"), |
||
113 |
"Returns a point which is the result of the entry point transforms by *this.") |
||
114 |
✓✗✓✗ |
38 |
.def("actInv", (Vector3 (SE3::*)(const Vector3 &) const) &SE3::actInv, |
115 |
bp::args("self","point"), |
||
116 |
"Returns a point which is the result of the entry point by the inverse of *this.") |
||
117 |
|||
118 |
✓✗✓✗ |
38 |
.def("act", (SE3 (SE3::*)(const SE3 & other) const) &SE3::act, |
119 |
bp::args("self","M"), "Returns the result of *this * M.") |
||
120 |
✓✗✓✗ |
38 |
.def("actInv", (SE3 (SE3::*)(const SE3 & other) const) &SE3::actInv, |
121 |
bp::args("self","M"), "Returns the result of the inverse of *this times M.") |
||
122 |
|||
123 |
✓✗✓✗ |
38 |
.def("act", (Motion (SE3::*)(const Motion &) const) &SE3::act, |
124 |
bp::args("self","motion"), "Returns the result action of *this onto a Motion.") |
||
125 |
✓✗✓✗ |
38 |
.def("actInv", (Motion (SE3::*)(const Motion &) const) &SE3::actInv, |
126 |
bp::args("self","motion"), "Returns the result of the inverse of *this onto a Motion.") |
||
127 |
|||
128 |
✓✗✓✗ |
38 |
.def("act", (Force (SE3::*)(const Force &) const) &SE3::act, |
129 |
bp::args("self","force"), "Returns the result of *this onto a Force.") |
||
130 |
✓✗✓✗ |
38 |
.def("actInv", (Force (SE3::*)(const Force &) const) &SE3::actInv, |
131 |
bp::args("self","force"), "Returns the result of the inverse of *this onto an Inertia.") |
||
132 |
|||
133 |
✓✗✓✗ |
38 |
.def("act", (Inertia (SE3::*)(const Inertia &) const) &SE3::act, |
134 |
bp::args("self","inertia"), "Returns the result of *this onto a Force.") |
||
135 |
✓✗✓✗ |
38 |
.def("actInv", (Inertia (SE3::*)(const Inertia &) const) &SE3::actInv, |
136 |
bp::args("self","inertia"), "Returns the result of the inverse of *this onto an Inertia.") |
||
137 |
|||
138 |
✓✗✓✗ |
38 |
.def("isApprox", |
139 |
call<SE3>::isApprox, |
||
140 |
isApproxSE3_overload(bp::args("self","other","prec"), |
||
141 |
"Returns true if *this is approximately equal to other, within the precision given by prec.")) |
||
142 |
|||
143 |
✓✗✓✗ ✓✗✓✗ |
38 |
.def("isIdentity", |
144 |
&SE3::isIdentity, |
||
145 |
isIdentity_overload(bp::args("self","prec"), |
||
146 |
"Returns true if *this is approximately equal to the identity placement, within the precision given by prec.")) |
||
147 |
|||
148 |
✓✗✓✗ |
38 |
.def("__invert__",&SE3::inverse,"Returns the inverse of *this.") |
149 |
✓✗ | 38 |
.def(bp::self * bp::self) |
150 |
✓✗✓✗ |
38 |
.def("__mul__",&__mul__<Motion>) |
151 |
✓✗ | 19 |
.def("__mul__",&__mul__<Force>) |
152 |
✓✗ | 19 |
.def("__mul__",&__mul__<Inertia>) |
153 |
✓✗ | 19 |
.def("__mul__",&__mul__<Vector3>) |
154 |
✓✗ | 19 |
.add_property("np",&SE3::toHomogeneousMatrix) |
155 |
|||
156 |
19 |
.def(bp::self == bp::self) |
|
157 |
✓✗✓✗ |
38 |
.def(bp::self != bp::self) |
158 |
|||
159 |
✓✗ | 19 |
.def("Identity",&SE3::Identity,"Returns the identity transformation.") |
160 |
✓✗ | 19 |
.staticmethod("Identity") |
161 |
✓✗ | 19 |
.def("Random",&SE3::Random,"Returns a random transformation.") |
162 |
✓✗ | 19 |
.staticmethod("Random") |
163 |
✓✗ | 19 |
.def("Interpolate",&SE3::template Interpolate<double>, |
164 |
bp::args("A","B","alpha"), |
||
165 |
"Linear interpolation on the SE3 manifold.\n\n" |
||
166 |
"This method computes the linear interpolation between A and B, such that the result C = A + (B-A)*t if it would be applied on classic Euclidian space.\n" |
||
167 |
"This operation is very similar to the SLERP operation on Rotations.\n" |
||
168 |
"Parameters:\n" |
||
169 |
"\tA: Initial transformation\n" |
||
170 |
"\tB: Target transformation\n" |
||
171 |
"\talpha: Interpolation factor") |
||
172 |
✓✗✓✗ |
38 |
.staticmethod("Interpolate") |
173 |
|||
174 |
✓✗ | 19 |
.def("__array__",&SE3::toHomogeneousMatrix) |
175 |
|||
176 |
✓✗✓✗ |
19 |
.def_pickle(Pickle()) |
177 |
; |
||
178 |
19 |
} |
|
179 |
|||
180 |
19 |
static void expose() |
|
181 |
{ |
||
182 |
#if PY_MAJOR_VERSION == 3 && PY_MINOR_VERSION == 6 && EIGENPY_VERSION_AT_LEAST(2,9,0) |
||
183 |
typedef PINOCCHIO_SHARED_PTR_HOLDER_TYPE(SE3) HolderType; |
||
184 |
#else |
||
185 |
typedef ::boost::python::detail::not_specified HolderType; |
||
186 |
#endif |
||
187 |
bp::class_<SE3,HolderType>("SE3", |
||
188 |
"SE3 transformation defined by a 3d vector and a rotation matrix.", |
||
189 |
bp::init<>(bp::arg("self"),"Default constructor.")) |
||
190 |
.def(SE3PythonVisitor<SE3>()) |
||
191 |
✓✗✓✗ ✓✗ |
38 |
.def(CopyableVisitor<SE3>()) |
192 |
✓✗✓✗ |
19 |
.def(PrintableVisitor<SE3>()) |
193 |
; |
||
194 |
|||
195 |
19 |
} |
|
196 |
private: |
||
197 |
|||
198 |
struct Pickle : bp::pickle_suite |
||
199 |
{ |
||
200 |
static |
||
201 |
boost::python::tuple |
||
202 |
getinitargs(const SE3 & M) |
||
203 |
{ return bp::make_tuple((Matrix3)M.rotation(),(Vector3)M.translation()); } |
||
204 |
|||
205 |
19 |
static bool getstate_manages_dict() { return true; } |
|
206 |
}; |
||
207 |
|||
208 |
static void setIdentity(SE3 & self) { self.setIdentity(); } |
||
209 |
static void setRandom(SE3 & self) { self.setRandom(); } |
||
210 |
|||
211 |
template<typename Spatial> |
||
212 |
static Spatial __mul__(const SE3 & self, const Spatial & other) |
||
213 |
{ return self.act(other); } |
||
214 |
}; |
||
215 |
|||
216 |
} // namespace python |
||
217 |
} // namespace pinocchio |
||
218 |
|||
219 |
#endif // ifndef __pinocchio_python_spatial_se3_hpp__ |
Generated by: GCOVR (Version 4.2) |