src/spatial/explog.hpp
Go to the documentation of this file.
1 //
2 // Copyright (c) 2015-2020 CNRS INRIA
3 // Copyright (c) 2015 Wandercraft, 86 rue de Paris 91400 Orsay, France.
4 //
5 
6 #ifndef __pinocchio_spatial_explog_hpp__
7 #define __pinocchio_spatial_explog_hpp__
8 
9 #include "pinocchio/fwd.hpp"
10 #include "pinocchio/utils/static-if.hpp"
11 #include "pinocchio/math/fwd.hpp"
12 #include "pinocchio/math/sincos.hpp"
13 #include "pinocchio/math/taylor-expansion.hpp"
14 #include "pinocchio/spatial/motion.hpp"
15 #include "pinocchio/spatial/skew.hpp"
16 #include "pinocchio/spatial/se3.hpp"
17 
18 #include <Eigen/Geometry>
19 
20 #include "pinocchio/spatial/log.hpp"
21 
22 namespace pinocchio
23 {
32  template<typename Vector3Like>
33  typename Eigen::Matrix<typename Vector3Like::Scalar,3,3,PINOCCHIO_EIGEN_PLAIN_TYPE(Vector3Like)::Options>
34  exp3(const Eigen::MatrixBase<Vector3Like> & v)
35  {
36  PINOCCHIO_ASSERT_MATRIX_SPECIFIC_SIZE (Vector3Like, v, 3, 1);
37 
38  typedef typename Vector3Like::Scalar Scalar;
39  typedef typename PINOCCHIO_EIGEN_PLAIN_TYPE(Vector3Like) Vector3LikePlain;
40  typedef Eigen::Matrix<Scalar,3,3,Vector3LikePlain::Options> Matrix3;
41 
42  const Scalar t2 = v.squaredNorm();
43 
44  const Scalar t = math::sqrt(t2);
45  Scalar ct,st; SINCOS(t,&st,&ct);
46 
47  const Scalar alpha_vxvx = internal::if_then_else(internal::GT, t, TaylorSeriesExpansion<Scalar>::template precision<3>(),
48  (1 - ct)/t2,
49  Scalar(1)/Scalar(2) - t2/24);
50  const Scalar alpha_vx = internal::if_then_else(internal::GT, t, TaylorSeriesExpansion<Scalar>::template precision<3>(),
51  (st)/t,
52  Scalar(1) - t2/6);
53  Matrix3 res(alpha_vxvx * v * v.transpose());
54  res.coeffRef(0,1) -= alpha_vx * v[2]; res.coeffRef(1,0) += alpha_vx * v[2];
55  res.coeffRef(0,2) += alpha_vx * v[1]; res.coeffRef(2,0) -= alpha_vx * v[1];
56  res.coeffRef(1,2) -= alpha_vx * v[0]; res.coeffRef(2,1) += alpha_vx * v[0];
57 
58  ct = internal::if_then_else(internal::GT, t, TaylorSeriesExpansion<Scalar>::template precision<3>(),
59  ct,
60  Scalar(1) - t2/2);
61  res.diagonal().array() += ct;
62 
63  return res;
64  }
65 
73  template<typename Matrix3Like>
74  Eigen::Matrix<typename Matrix3Like::Scalar,3,1,PINOCCHIO_EIGEN_PLAIN_TYPE(Matrix3Like)::Options>
75  log3(const Eigen::MatrixBase<Matrix3Like> & R,
76  typename Matrix3Like::Scalar & theta)
77  {
78  typedef typename Matrix3Like::Scalar Scalar;
79  typedef Eigen::Matrix<Scalar,3,1,
80  PINOCCHIO_EIGEN_PLAIN_TYPE(Matrix3Like)::Options> Vector3;
81  Vector3 res;
82  log3_impl<Scalar>::run(R, theta, res);
83  return res;
84  }
85 
94  template<typename Matrix3Like>
95  Eigen::Matrix<typename Matrix3Like::Scalar,3,1,PINOCCHIO_EIGEN_PLAIN_TYPE(Matrix3Like)::Options>
96  log3(const Eigen::MatrixBase<Matrix3Like> & R)
97  {
98  typename Matrix3Like::Scalar theta;
99  return log3(R.derived(),theta);
100  }
101 
110  template<AssignmentOperatorType op, typename Vector3Like, typename Matrix3Like>
111  void Jexp3(const Eigen::MatrixBase<Vector3Like> & r,
112  const Eigen::MatrixBase<Matrix3Like> & Jexp)
113  {
114  PINOCCHIO_ASSERT_MATRIX_SPECIFIC_SIZE (Vector3Like, r , 3, 1);
115  PINOCCHIO_ASSERT_MATRIX_SPECIFIC_SIZE (Matrix3Like, Jexp, 3, 3);
116 
117  Matrix3Like & Jout = PINOCCHIO_EIGEN_CONST_CAST(Matrix3Like,Jexp);
118  typedef typename Matrix3Like::Scalar Scalar;
119 
120  const Scalar n2 = r.squaredNorm();
121  const Scalar n = math::sqrt(n2);
122  const Scalar n_inv = Scalar(1)/n;
123  const Scalar n2_inv = n_inv * n_inv;
124  Scalar cn,sn; SINCOS(n,&sn,&cn);
125 
126  const Scalar a = internal::if_then_else(internal::LT, n, TaylorSeriesExpansion<Scalar>::template precision<3>(),
127  Scalar(1) - n2/Scalar(6),
128  sn*n_inv);
129  const Scalar b = internal::if_then_else(internal::LT, n, TaylorSeriesExpansion<Scalar>::template precision<3>(),
130  - Scalar(1)/Scalar(2) - n2/Scalar(24),
131  - (1-cn)*n2_inv);
132  const Scalar c = internal::if_then_else(internal::LT, n, TaylorSeriesExpansion<Scalar>::template precision<3>(),
133  Scalar(1)/Scalar(6) - n2/Scalar(120),
134  n2_inv * (1 - a));
135 
136  switch(op)
137  {
138  case SETTO:
139  Jout.diagonal().setConstant(a);
140  Jout(0,1) = -b*r[2]; Jout(1,0) = -Jout(0,1);
141  Jout(0,2) = b*r[1]; Jout(2,0) = -Jout(0,2);
142  Jout(1,2) = -b*r[0]; Jout(2,1) = -Jout(1,2);
143  Jout.noalias() += c * r * r.transpose();
144  break;
145  case ADDTO:
146  Jout.diagonal().array() += a;
147  Jout(0,1) += -b*r[2]; Jout(1,0) += b*r[2];
148  Jout(0,2) += b*r[1]; Jout(2,0) += -b*r[1];
149  Jout(1,2) += -b*r[0]; Jout(2,1) += b*r[0];
150  Jout.noalias() += c * r * r.transpose();
151  break;
152  case RMTO:
153  Jout.diagonal().array() -= a;
154  Jout(0,1) -= -b*r[2]; Jout(1,0) -= b*r[2];
155  Jout(0,2) -= b*r[1]; Jout(2,0) -= -b*r[1];
156  Jout(1,2) -= -b*r[0]; Jout(2,1) -= b*r[0];
157  Jout.noalias() -= c * r * r.transpose();
158  break;
159  default:
160  assert(false && "Wrong Op requesed value");
161  break;
162  }
163  }
164 
173  template<typename Vector3Like, typename Matrix3Like>
174  void Jexp3(const Eigen::MatrixBase<Vector3Like> & r,
175  const Eigen::MatrixBase<Matrix3Like> & Jexp)
176  {
177  Jexp3<SETTO>(r, Jexp);
178  }
179 
192  template<typename Scalar, typename Vector3Like, typename Matrix3Like>
193  void Jlog3(const Scalar & theta,
194  const Eigen::MatrixBase<Vector3Like> & log,
195  const Eigen::MatrixBase<Matrix3Like> & Jlog)
196  {
197  Jlog3_impl<Scalar>::run(theta, log,
198  PINOCCHIO_EIGEN_CONST_CAST(Matrix3Like,Jlog));
199  }
200 
213  template<typename Matrix3Like1, typename Matrix3Like2>
214  void Jlog3(const Eigen::MatrixBase<Matrix3Like1> & R,
215  const Eigen::MatrixBase<Matrix3Like2> & Jlog)
216  {
217  typedef typename Matrix3Like1::Scalar Scalar;
218  typedef Eigen::Matrix<Scalar,3,1,PINOCCHIO_EIGEN_PLAIN_TYPE(Matrix3Like1)::Options> Vector3;
219 
220  Scalar t;
221  Vector3 w(log3(R,t));
222  Jlog3(t,w,PINOCCHIO_EIGEN_CONST_CAST(Matrix3Like2,Jlog));
223  }
224 
225  template<typename Scalar, typename Vector3Like1, typename Vector3Like2, typename Matrix3Like>
226  void Hlog3(const Scalar & theta,
227  const Eigen::MatrixBase<Vector3Like1> & log,
228  const Eigen::MatrixBase<Vector3Like2> & v,
229  const Eigen::MatrixBase<Matrix3Like> & vt_Hlog)
230  {
231  typedef Eigen::Matrix<Scalar,3,1,PINOCCHIO_EIGEN_PLAIN_TYPE(Matrix3Like)::Options> Vector3;
232  Matrix3Like & vt_Hlog_ = PINOCCHIO_EIGEN_CONST_CAST(Matrix3Like,vt_Hlog);
233 
234  // theta = (log^T * log)^.5
235  // dt/dl = .5 * 2 * log^T * (log^T * log)^-.5
236  // = log^T / theta
237  // dt_dl = log / theta
238  Scalar ctheta,stheta; SINCOS(theta,&stheta,&ctheta);
239 
240  Scalar denom = .5 / (1-ctheta),
241  a = theta * stheta * denom,
242  da_dt = (stheta - theta) * denom, // da / dtheta
243  b = ( 1 - a ) / (theta*theta),
244  //db_dt = - (2 * (1 - a) / theta + da_dt ) / theta**2; // db / dtheta
245  db_dt = - (2 / theta - (theta + stheta) * denom) / (theta*theta); // db / dtheta
246 
247  // Compute dl_dv_v = Jlog * v
248  // Jlog = a I3 + .5 [ log ] + b * log * log^T
249  // if v == log, then Jlog * v == v
250  Vector3 dl_dv_v (a*v + .5*log.cross(v) + b*log*log.transpose()*v);
251 
252  Scalar dt_dv_v = log.dot(dl_dv_v) / theta;
253 
254  // Derivative of b * log * log^T
255  vt_Hlog_.noalias() = db_dt * dt_dv_v * log * log.transpose();
256  vt_Hlog_.noalias() += b * dl_dv_v * log.transpose();
257  vt_Hlog_.noalias() += b * log * dl_dv_v.transpose();
258  // Derivative of .5 * [ log ]
259  addSkew(.5 * dl_dv_v, vt_Hlog_);
260  // Derivative of a * I3
261  vt_Hlog_.diagonal().array() += da_dt * dt_dv_v;
262  }
263 
272  template<typename Matrix3Like1, typename Vector3Like, typename Matrix3Like2>
273  void Hlog3(const Eigen::MatrixBase<Matrix3Like1> & R,
274  const Eigen::MatrixBase<Vector3Like> & v,
275  const Eigen::MatrixBase<Matrix3Like2> & vt_Hlog)
276  {
277  typedef typename Matrix3Like1::Scalar Scalar;
278  typedef Eigen::Matrix<Scalar,3,1,PINOCCHIO_EIGEN_PLAIN_TYPE(Matrix3Like1)::Options> Vector3;
279 
280  Scalar t;
281  Vector3 w(log3(R,t));
282  Hlog3(t,w,v,PINOCCHIO_EIGEN_CONST_CAST(Matrix3Like2,vt_Hlog));
283  }
284 
294  template<typename MotionDerived>
295  SE3Tpl<typename MotionDerived::Scalar,PINOCCHIO_EIGEN_PLAIN_TYPE(typename MotionDerived::Vector3)::Options>
296  exp6(const MotionDense<MotionDerived> & nu)
297  {
298  typedef typename MotionDerived::Scalar Scalar;
299  enum { Options = PINOCCHIO_EIGEN_PLAIN_TYPE(typename MotionDerived::Vector3)::Options };
300 
301  typedef SE3Tpl<Scalar,Options> SE3;
302 
303  SE3 res;
304  typename SE3::LinearType & trans = res.translation();
305  typename SE3::AngularType & rot = res.rotation();
306 
307  const typename MotionDerived::ConstAngularType & w = nu.angular();
308  const typename MotionDerived::ConstLinearType & v = nu.linear();
309 
310  Scalar alpha_wxv, alpha_v, alpha_w, diagonal_term;
311  const Scalar t2 = w.squaredNorm();
312  const Scalar t = math::sqrt(t2);
313  Scalar ct,st; SINCOS(t,&st,&ct);
314  const Scalar inv_t2 = Scalar(1)/t2;
315 
316  alpha_wxv = internal::if_then_else(internal::LT, t, TaylorSeriesExpansion<Scalar>::template precision<3>(),
317  Scalar(1)/Scalar(2) - t2/24,
318  (Scalar(1) - ct)*inv_t2);
319 
320  alpha_v = internal::if_then_else(internal::LT, t, TaylorSeriesExpansion<Scalar>::template precision<3>(),
321  Scalar(1) - t2/6,
322  (st)/t);
323 
324  alpha_w = internal::if_then_else(internal::LT, t, TaylorSeriesExpansion<Scalar>::template precision<3>(),
325  (Scalar(1)/Scalar(6) - t2/120),
326  (Scalar(1) - alpha_v)*inv_t2);
327 
328  diagonal_term = internal::if_then_else(internal::LT, t, TaylorSeriesExpansion<Scalar>::template precision<3>(),
329  Scalar(1) - t2/2,
330  ct);
331 
332  // Linear
333  trans.noalias() = (alpha_v*v + (alpha_w*w.dot(v))*w + alpha_wxv*w.cross(v));
334 
335  // Rotational
336  rot.noalias() = alpha_wxv * w * w.transpose();
337  rot.coeffRef(0,1) -= alpha_v * w[2]; rot.coeffRef(1,0) += alpha_v * w[2];
338  rot.coeffRef(0,2) += alpha_v * w[1]; rot.coeffRef(2,0) -= alpha_v * w[1];
339  rot.coeffRef(1,2) -= alpha_v * w[0]; rot.coeffRef(2,1) += alpha_v * w[0];
340  rot.diagonal().array() += diagonal_term;
341 
342  return res;
343  }
344 
353  template<typename Vector6Like>
354  SE3Tpl<typename Vector6Like::Scalar,PINOCCHIO_EIGEN_PLAIN_TYPE(Vector6Like)::Options>
355  exp6(const Eigen::MatrixBase<Vector6Like> & v)
356  {
357  PINOCCHIO_ASSERT_MATRIX_SPECIFIC_SIZE (Vector6Like, v, 6, 1);
358 
359  MotionRef<const Vector6Like> nu(v.derived());
360  return exp6(nu);
361  }
362 
371  template<typename Scalar, int Options>
372  MotionTpl<Scalar,Options>
373  log6(const SE3Tpl<Scalar,Options> & M)
374  {
375  typedef MotionTpl<Scalar,Options> Motion;
376  Motion mout;
377  log6_impl<Scalar>::run(M, mout);
378  return mout;
379  }
380 
389  template<typename Matrix4Like>
390  MotionTpl<typename Matrix4Like::Scalar,Eigen::internal::traits<Matrix4Like>::Options>
391  log6(const Eigen::MatrixBase<Matrix4Like> & M)
392  {
393  PINOCCHIO_ASSERT_MATRIX_SPECIFIC_SIZE(Matrix4Like, M, 4, 4);
394 
395  typedef typename Matrix4Like::Scalar Scalar;
396  enum {Options = Eigen::internal::traits<Matrix4Like>::Options};
397  typedef MotionTpl<Scalar,Options> Motion;
398  typedef SE3Tpl<Scalar,Options> SE3;
399 
400  SE3 m(M);
401  Motion mout;
402  log6_impl<Scalar>::run(m, mout);
403  return mout;
404  }
405 
408  template<AssignmentOperatorType op, typename MotionDerived, typename Matrix6Like>
409  void Jexp6(const MotionDense<MotionDerived> & nu,
410  const Eigen::MatrixBase<Matrix6Like> & Jexp)
411  {
412  PINOCCHIO_ASSERT_MATRIX_SPECIFIC_SIZE (Matrix6Like, Jexp, 6, 6);
413 
414  typedef typename MotionDerived::Scalar Scalar;
415  typedef typename MotionDerived::Vector3 Vector3;
416  typedef Eigen::Matrix<Scalar, 3, 3, Vector3::Options> Matrix3;
417  Matrix6Like & Jout = PINOCCHIO_EIGEN_CONST_CAST(Matrix6Like,Jexp);
418 
419  const typename MotionDerived::ConstLinearType & v = nu.linear();
420  const typename MotionDerived::ConstAngularType & w = nu.angular();
421  const Scalar t2 = w.squaredNorm();
422  const Scalar t = math::sqrt(t2);
423 
424  const Scalar tinv = Scalar(1)/t,
425  t2inv = tinv*tinv;
426  Scalar st,ct; SINCOS (t, &st, &ct);
427  const Scalar inv_2_2ct = Scalar(1)/(Scalar(2)*(Scalar(1)-ct));
428 
429 
430  const Scalar beta = internal::if_then_else(internal::LT, t, TaylorSeriesExpansion<Scalar>::template precision<3>(),
431  Scalar(1)/Scalar(12) + t2/Scalar(720),
432  t2inv - st*tinv*inv_2_2ct);
433 
434  const Scalar beta_dot_over_theta = internal::if_then_else(internal::LT, t, TaylorSeriesExpansion<Scalar>::template precision<3>(),
435  Scalar(1)/Scalar(360),
436  -Scalar(2)*t2inv*t2inv + (Scalar(1) + st*tinv) * t2inv * inv_2_2ct);
437 
438  switch(op)
439  {
440  case SETTO:
441  {
442  Jexp3<SETTO>(w, Jout.template bottomRightCorner<3,3>());
443  Jout.template topLeftCorner<3,3>() = Jout.template bottomRightCorner<3,3>();
444  const Vector3 p = Jout.template topLeftCorner<3,3>().transpose() * v;
445  const Scalar wTp (w.dot (p));
446  const Matrix3 J (alphaSkew(.5, p) +
447  (beta_dot_over_theta*wTp) *w*w.transpose()
448  - (t2*beta_dot_over_theta+Scalar(2)*beta)*p*w.transpose()
449  + wTp * beta * Matrix3::Identity()
450  + beta *w*p.transpose());
451  Jout.template topRightCorner<3,3>().noalias() =
452  - Jout.template topLeftCorner<3,3>() * J;
453  Jout.template bottomLeftCorner<3,3>().setZero();
454  break;
455  }
456  case ADDTO:
457  {
458  Matrix3 Jtmp3;
459  Jexp3<SETTO>(w, Jtmp3);
460  Jout.template bottomRightCorner<3,3>() += Jtmp3;
461  Jout.template topLeftCorner<3,3>() += Jtmp3;
462  const Vector3 p = Jtmp3.transpose() * v;
463  const Scalar wTp (w.dot (p));
464  const Matrix3 J (alphaSkew(.5, p) +
465  (beta_dot_over_theta*wTp) *w*w.transpose()
466  - (t2*beta_dot_over_theta+Scalar(2)*beta)*p*w.transpose()
467  + wTp * beta * Matrix3::Identity()
468  + beta *w*p.transpose());
469  Jout.template topRightCorner<3,3>().noalias() +=
470  - Jtmp3 * J;
471  break;
472  }
473  case RMTO:
474  {
475  Matrix3 Jtmp3;
476  Jexp3<SETTO>(w, Jtmp3);
477  Jout.template bottomRightCorner<3,3>() -= Jtmp3;
478  Jout.template topLeftCorner<3,3>() -= Jtmp3;
479  const Vector3 p = Jtmp3.transpose() * v;
480  const Scalar wTp (w.dot (p));
481  const Matrix3 J (alphaSkew(.5, p) +
482  (beta_dot_over_theta*wTp) *w*w.transpose()
483  - (t2*beta_dot_over_theta+Scalar(2)*beta)*p*w.transpose()
484  + wTp * beta * Matrix3::Identity()
485  + beta *w*p.transpose());
486  Jout.template topRightCorner<3,3>().noalias() -=
487  - Jtmp3 * J;
488  break;
489  }
490  default:
491  assert(false && "Wrong Op requesed value");
492  break;
493  }
494  }
495 
498  template<typename MotionDerived, typename Matrix6Like>
499  void Jexp6(const MotionDense<MotionDerived> & nu,
500  const Eigen::MatrixBase<Matrix6Like> & Jexp)
501  {
502  Jexp6<SETTO>(nu, Jexp);
503  }
504 
537  template<typename Scalar, int Options, typename Matrix6Like>
538  void Jlog6(const SE3Tpl<Scalar, Options> & M,
539  const Eigen::MatrixBase<Matrix6Like> & Jlog)
540  {
541  Jlog6_impl<Scalar>::run(M,PINOCCHIO_EIGEN_CONST_CAST(Matrix6Like,Jlog));
542  }
543 
544  template<typename Scalar, int Options>
545  template<typename OtherScalar>
546  SE3Tpl<Scalar,Options> SE3Tpl<Scalar,Options>::Interpolate(const SE3Tpl & A,
547  const SE3Tpl & B,
548  const OtherScalar & alpha)
549  {
550  typedef SE3Tpl<Scalar,Options> ReturnType;
551  typedef MotionTpl<Scalar,Options> Motion;
552 
553  Motion dv = log6(A.actInv(B));
554  ReturnType res = A * exp6(alpha*dv);
555  return res;
556  }
557 
558 } // namespace pinocchio
559 
560 #include "pinocchio/spatial/explog-quaternion.hpp"
561 #include "pinocchio/spatial/log.hxx"
562 
563 #endif //#ifndef __pinocchio_spatial_explog_hpp__
pinocchio::log3
Eigen::Matrix< typename Matrix3Like::Scalar, 3, 1, PINOCCHIO_EIGEN_PLAIN_TYPE(Matrix3Like)::Options > log3(const Eigen::MatrixBase< Matrix3Like > &R, typename Matrix3Like::Scalar &theta)
Same as log3.
Definition: src/spatial/explog.hpp:75
pinocchio::v
JointCollectionTpl const Eigen::MatrixBase< ConfigVectorType > const Eigen::MatrixBase< TangentVectorType > & v
Definition: joint-configuration.hpp:746
ocp.c
c
Definition: ocp.py:61
pinocchio::Jexp3
void Jexp3(const Eigen::MatrixBase< Vector3Like > &r, const Eigen::MatrixBase< Matrix3Like > &Jexp)
Derivative of .
Definition: src/spatial/explog.hpp:111
PINOCCHIO_ASSERT_MATRIX_SPECIFIC_SIZE
#define PINOCCHIO_ASSERT_MATRIX_SPECIFIC_SIZE(type, M, nrows, ncols)
Ensure that a matrix (or vector) is of correct size (compile-time and run-time assertion) ...
Definition: src/macros.hpp:54
pinocchio::log3_impl
Definition: log.hpp:10
pinocchio::Jlog3
void Jlog3(const Scalar &theta, const Eigen::MatrixBase< Vector3Like > &log, const Eigen::MatrixBase< Matrix3Like > &Jlog)
Derivative of log3.
Definition: src/spatial/explog.hpp:193
pinocchio::Jlog6
void Jlog6(const SE3Tpl< Scalar, Options > &M, const Eigen::MatrixBase< Matrix6Like > &Jlog)
Derivative of log6 where and .
Definition: src/spatial/explog.hpp:538
pinocchio::log6
MotionTpl< Scalar, Options > log6(const SE3Tpl< Scalar, Options > &M)
Log: SE3 -> se3.
Definition: src/spatial/explog.hpp:373
pinocchio::log6
MotionTpl< typename Matrix4Like::Scalar, Eigen::internal::traits< Matrix4Like >::Options > log6(const Eigen::MatrixBase< Matrix4Like > &M)
Log: SE3 -> se3.
Definition: src/spatial/explog.hpp:391
pinocchio::exp6
SE3Tpl< typename Vector6Like::Scalar, PINOCCHIO_EIGEN_PLAIN_TYPE(Vector6Like)::Options > exp6(const Eigen::MatrixBase< Vector6Like > &v)
Exp: se3 -> SE3.
Definition: src/spatial/explog.hpp:355
pinocchio::Jexp6
void Jexp6(const MotionDense< MotionDerived > &nu, const Eigen::MatrixBase< Matrix6Like > &Jexp)
Derivative of exp6 Computed as the inverse of Jlog6.
Definition: src/spatial/explog.hpp:409
PINOCCHIO_EIGEN_CONST_CAST
#define PINOCCHIO_EIGEN_CONST_CAST(TYPE, OBJ)
Macro for an automatic const_cast.
Definition: eigen-macros.hpp:43
pinocchio::Jlog3_impl
Definition: log.hpp:11
pinocchio::python::Scalar
SE3::Scalar Scalar
Definition: conversions.cpp:13
pinocchio::exp3
Eigen::Matrix< typename Vector3Like::Scalar, 3, 3, PINOCCHIO_EIGEN_PLAIN_TYPE(Vector3Like)::Options > exp3(const Eigen::MatrixBase< Vector3Like > &v)
Exp: so3 -> SO3.
Definition: src/spatial/explog.hpp:34
pinocchio::Jlog6_impl
Definition: log.hpp:14
pinocchio::SE3Base::actInv
SE3GroupAction< D >::ReturnType actInv(const D &d) const
by = aXb.actInv(ay)
Definition: se3-base.hpp:97
pinocchio::MotionBase::linear
ConstLinearType linear() const
Definition: motion-base.hpp:22
pinocchio::Motion
MotionTpl< double, 0 > Motion
Definition: src/spatial/fwd.hpp:57
pinocchio::SE3Base::translation
ConstLinearRef translation() const
Definition: se3-base.hpp:38
pinocchio::SINCOS
void SINCOS(const S1 &a, S2 *sa, S3 *ca)
Computes sin/cos values of a given input scalar.
Definition: sincos.hpp:26
pinocchio::addSkew
void addSkew(const Eigen::MatrixBase< Vector3Like > &v, const Eigen::MatrixBase< Matrix3Like > &M)
Add skew matrix represented by a 3d vector to a given matrix, i.e. add the antisymmetric matrix repre...
Definition: skew.hpp:60
pinocchio
Main pinocchio namespace.
Definition: timings.cpp:30
pinocchio::PINOCCHIO_EIGEN_PLAIN_TYPE
PINOCCHIO_EIGEN_PLAIN_TYPE(ConfigVectorType) integrate(const ModelTpl< Scalar
Integrate a configuration vector for the specified model for a tangent vector during one unit time...
res
res
pinocchio::alphaSkew
void alphaSkew(const Scalar alpha, const Eigen::MatrixBase< Vector3 > &v, const Eigen::MatrixBase< Matrix3 > &M)
Computes the skew representation of a given 3d vector multiplied by a given scalar. i.e. the antisymmetric matrix representation of the cross product operator ( )
Definition: skew.hpp:124
pinocchio::Hlog3
void Hlog3(const Scalar &theta, const Eigen::MatrixBase< Vector3Like1 > &log, const Eigen::MatrixBase< Vector3Like2 > &v, const Eigen::MatrixBase< Matrix3Like > &vt_Hlog)
Definition: src/spatial/explog.hpp:226
pinocchio::internal::if_then_else
if_then_else_impl< LhsType, RhsType, ThenType, ElseType >::ReturnType if_then_else(const ComparisonOperators op, const LhsType &lhs_value, const RhsType &rhs_value, const ThenType &then_value, const ElseType &else_value)
Definition: utils/static-if.hpp:77
a
list a
pinocchio::MotionBase::angular
ConstAngularType angular() const
Definition: motion-base.hpp:21
pinocchio::exp6
SE3Tpl< typename MotionDerived::Scalar, PINOCCHIO_EIGEN_PLAIN_TYPE(typename MotionDerived::Vector3)::Options > exp6(const MotionDense< MotionDerived > &nu)
Exp: se3 -> SE3.
Definition: src/spatial/explog.hpp:296
ur5x4.w
w
Definition: ur5x4.py:45
pinocchio::SE3
SE3Tpl< double, 0 > SE3
Definition: src/spatial/fwd.hpp:53
pinocchio::log6_impl
Definition: log.hpp:13
pinocchio::SE3Tpl::Interpolate
static SE3Tpl Interpolate(const SE3Tpl &A, const SE3Tpl &B, const OtherScalar &alpha)
Linear interpolation on the SE3 manifold.
pinocchio::SE3Base::rotation
ConstAngularRef rotation() const
Definition: se3-base.hpp:37

pinocchio
Author(s):
autogenerated on Tue Jun 1 2021 02:45:02