rpy.hpp

//
// Copyright (c) 2016-2020 CNRS INRIA
//
 
#ifndef __pinocchio_math_rpy_hpp__
#define __pinocchio_math_rpy_hpp__
 
#include "pinocchio/math/fwd.hpp"
#include "pinocchio/math/comparison-operators.hpp"
#include "pinocchio/multibody/fwd.hpp"
 
namespace pinocchio
{
  namespace rpy
  {
    template<typename Scalar>
    Eigen::Matrix<Scalar, 3, 3> rpyToMatrix(const Scalar & r, const Scalar & p, const Scalar & y);
 
    template<typename Vector3Like>
    Eigen::
      Matrix<typename Vector3Like::Scalar, 3, 3, PINOCCHIO_EIGEN_PLAIN_TYPE(Vector3Like)::Options>
      rpyToMatrix(const Eigen::MatrixBase<Vector3Like> & rpy);
 
    template<typename Matrix3Like>
    Eigen::
      Matrix<typename Matrix3Like::Scalar, 3, 1, PINOCCHIO_EIGEN_PLAIN_TYPE(Matrix3Like)::Options>
      matrixToRpy(const Eigen::MatrixBase<Matrix3Like> & R);
 
    template<typename Vector3Like>
    Eigen::
      Matrix<typename Vector3Like::Scalar, 3, 3, PINOCCHIO_EIGEN_PLAIN_TYPE(Vector3Like)::Options>
      computeRpyJacobian(
        const Eigen::MatrixBase<Vector3Like> & rpy, const ReferenceFrame rf = LOCAL);
 
    template<typename Vector3Like>
    Eigen::
      Matrix<typename Vector3Like::Scalar, 3, 3, PINOCCHIO_EIGEN_PLAIN_TYPE(Vector3Like)::Options>
      computeRpyJacobianInverse(
        const Eigen::MatrixBase<Vector3Like> & rpy, const ReferenceFrame rf = LOCAL);
 
    template<typename Vector3Like0, typename Vector3Like1>
    Eigen::
      Matrix<typename Vector3Like0::Scalar, 3, 3, PINOCCHIO_EIGEN_PLAIN_TYPE(Vector3Like0)::Options>
      computeRpyJacobianTimeDerivative(
        const Eigen::MatrixBase<Vector3Like0> & rpy,
        const Eigen::MatrixBase<Vector3Like1> & rpydot,
        const ReferenceFrame rf = LOCAL);
  } // namespace rpy
} // namespace pinocchio
 
/* --- Details -------------------------------------------------------------------- */
#include "pinocchio/math/rpy.hxx"
 
#endif // #ifndef __pinocchio_math_rpy_hpp__