hpp-core  4.10.1
Implement basic classes for canonical path planning for kinematic chains.
hpp::core::path::Spline< _PolynomeBasis, _Order > Class Template Reference

#include <hpp/core/fwd.hh>

Public Types

enum  { PolynomeBasis = _PolynomeBasis, Order = _Order, NbCoeffs = _Order + 1, NbPowerOfT = 2 * NbCoeffs + 1 }
 
typedef internal::sbf_traits< PolynomeBasis, Ordersbf_traits
 
typedef internal::spline_basis_function< PolynomeBasis, OrderBasisFunction_t
 
typedef Eigen::Matrix< value_type, NbPowerOfT, 1 > PowersOfT_t
 
typedef sbf_traits::Coeffs_t BasisFunctionVector_t
 
typedef sbf_traits::IntegralCoeffs_t BasisFunctionIntegralMatrix_t
 
typedef Eigen::Matrix< value_type, NbCoeffs, Eigen::Dynamic, Eigen::RowMajor > ParameterMatrix_t
 
typedef Eigen::Map< const vector_t, Eigen::Aligned > ConstParameterVector_t
 
typedef Eigen::Map< vector_t, Eigen::Aligned > ParameterVector_t
 
typedef boost::shared_ptr< SplinePtr_t
 
typedef boost::weak_ptr< SplineWkPtr_t
 

Public Member Functions

size_type parameterSize () const
 
void parameterDerivativeCoefficients (vectorOut_t res, const value_type &t) const
 
void parameterIntegrate (vectorIn_t dParam)
 Adds dParam to the parameters. More...
 
value_type squaredNormIntegral (const size_type order) const
 
void squaredNormIntegralDerivative (const size_type order, vectorOut_t res) const
 
void basisFunctionDerivative (const size_type order, const value_type &u, BasisFunctionVector_t &res) const
 
void basisFunctionDerivative (const size_type order, const value_type &u, vectorOut_t res) const
 
void maxVelocity (vectorOut_t res) const
 
void squaredNormBasisFunctionIntegral (const size_type order, BasisFunctionIntegralMatrix_t &res) const
 
void squaredNormBasisFunctionIntegral (const size_type order, matrixOut_t res) const
 
virtual Configuration_t initial () const
 
virtual Configuration_t end () const
 
const Configuration_tbase () const
 
void base (const Configuration_t &q)
 
const ParameterMatrix_tparameters () const
 Each row corresponds to a velocity of the robot. More...
 
void parameters (const ParameterMatrix_t &m)
 
ConstParameterVector_t rowParameters () const
 Concatenate the parameters as one vector (P_0^T, ..., P_n^T). More...
 
void rowParameters (vectorIn_t p)
 Set the parameters. More...
 
PathPtr_t copy () const
 
PathPtr_t copy (const ConstraintSetPtr_t &constraints) const
 
virtual ~Spline ()
 

Static Public Member Functions

static void timeFreeBasisFunctionDerivative (const size_type order, const value_type &u, BasisFunctionVector_t &res)
 
static void timeFreeBasisFunctionDerivative (const size_type order, const value_type &u, vectorOut_t res)
 
static Ptr_t create (const DevicePtr_t &robot, const interval_t &interval, const ConstraintSetPtr_t &constraints)
 
static void value (pinocchio::LiegroupElementConstRef base, Eigen::Ref< const ParameterMatrix_t > params, const value_type &u, ConfigurationOut_t config, vectorOut_t velocity)
 

Protected Member Functions

 Spline (const DevicePtr_t &robot, const interval_t &interval, const ConstraintSetPtr_t &constraints)
 
 Spline (const Spline &path)
 
 Spline (const Spline &path, const ConstraintSetPtr_t &constraints)
 
void init (const Ptr_t &self)
 
std::ostream & print (std::ostream &os) const
 
bool impl_compute (ConfigurationOut_t configuration, value_type t) const
 
void impl_derivative (vectorOut_t res, const value_type &t, size_type order) const
 
void impl_paramDerivative (vectorOut_t res, const value_type &t) const
 
void impl_paramIntegrate (vectorIn_t dParam)
 
void impl_velocityBound (vectorOut_t result, const value_type &t0, const value_type &t1) const
 

Protected Attributes

size_type parameterSize_
 Robot number of degrees of freedom. More...
 
DevicePtr_t robot_
 
LiegroupElement base_
 
ParameterMatrix_t parameters_
 

Detailed Description

template<int _PolynomeBasis, int _Order>
class hpp::core::path::Spline< _PolynomeBasis, _Order >

Base class for spline paths

Splines are polynomials with various possible representations.

Parameters
_PolynomeBasisbasis of polynomials used among
  • CanonicalPolynomeBasis for the canonical basis,
  • BernsteinBasis for Bernstein basis
_Orderdegree of the polynomial representation.
See also
hpp::core::path::PolynomeBasisType.

Splines represent a curve in the tangent space of a given robot (hpp::core::Device) at a configuration called base.

\begin{eqnarray*} spline (u) &=& base + PM^{T} B (u) \end{eqnarray*}

where*

  • \(u\in [0,1]\),
  • operator "+" should be understood as Lie group integration,
  • \(PM\) is the matrix of parameters the rows of which are the spline control points. This matrix is accessible via setter and getter Spline::parameters,
  • \(B (t)\) is the vector containing the values of the basis functions at parameter \(t\).

The dimension of control points, corresponding to the robot number of degrees of freedom can be retrieved by getter Spline::parameterSize.

Member Typedef Documentation

◆ BasisFunction_t

template<int _PolynomeBasis, int _Order>
typedef internal::spline_basis_function<PolynomeBasis, Order> hpp::core::path::Spline< _PolynomeBasis, _Order >::BasisFunction_t

◆ BasisFunctionIntegralMatrix_t

template<int _PolynomeBasis, int _Order>
typedef sbf_traits::IntegralCoeffs_t hpp::core::path::Spline< _PolynomeBasis, _Order >::BasisFunctionIntegralMatrix_t

◆ BasisFunctionVector_t

template<int _PolynomeBasis, int _Order>
typedef sbf_traits::Coeffs_t hpp::core::path::Spline< _PolynomeBasis, _Order >::BasisFunctionVector_t

◆ ConstParameterVector_t

template<int _PolynomeBasis, int _Order>
typedef Eigen::Map<const vector_t, Eigen::Aligned> hpp::core::path::Spline< _PolynomeBasis, _Order >::ConstParameterVector_t

◆ ParameterMatrix_t

template<int _PolynomeBasis, int _Order>
typedef Eigen::Matrix<value_type, NbCoeffs, Eigen::Dynamic, Eigen::RowMajor> hpp::core::path::Spline< _PolynomeBasis, _Order >::ParameterMatrix_t

◆ ParameterVector_t

template<int _PolynomeBasis, int _Order>
typedef Eigen::Map< vector_t, Eigen::Aligned> hpp::core::path::Spline< _PolynomeBasis, _Order >::ParameterVector_t

◆ PowersOfT_t

template<int _PolynomeBasis, int _Order>
typedef Eigen::Matrix<value_type, NbPowerOfT, 1> hpp::core::path::Spline< _PolynomeBasis, _Order >::PowersOfT_t

◆ Ptr_t

template<int _PolynomeBasis, int _Order>
typedef boost::shared_ptr<Spline> hpp::core::path::Spline< _PolynomeBasis, _Order >::Ptr_t

◆ sbf_traits

template<int _PolynomeBasis, int _Order>
typedef internal::sbf_traits<PolynomeBasis, Order> hpp::core::path::Spline< _PolynomeBasis, _Order >::sbf_traits

◆ WkPtr_t

template<int _PolynomeBasis, int _Order>
typedef boost::weak_ptr<Spline> hpp::core::path::Spline< _PolynomeBasis, _Order >::WkPtr_t

Member Enumeration Documentation

◆ anonymous enum

template<int _PolynomeBasis, int _Order>
anonymous enum
Enumerator
PolynomeBasis 
Order 
NbCoeffs 
NbPowerOfT 

Constructor & Destructor Documentation

◆ ~Spline()

template<int _PolynomeBasis, int _Order>
virtual hpp::core::path::Spline< _PolynomeBasis, _Order >::~Spline ( )
inlinevirtual

◆ Spline() [1/3]

template<int _PolynomeBasis, int _Order>
hpp::core::path::Spline< _PolynomeBasis, _Order >::Spline ( const DevicePtr_t robot,
const interval_t interval,
const ConstraintSetPtr_t constraints 
)
inlineprotected

◆ Spline() [2/3]

template<int _PolynomeBasis, int _Order>
hpp::core::path::Spline< _PolynomeBasis, _Order >::Spline ( const Spline< _PolynomeBasis, _Order > &  path)
protected

◆ Spline() [3/3]

template<int _PolynomeBasis, int _Order>
hpp::core::path::Spline< _PolynomeBasis, _Order >::Spline ( const Spline< _PolynomeBasis, _Order > &  path,
const ConstraintSetPtr_t constraints 
)
protected

Member Function Documentation

◆ base() [1/2]

template<int _PolynomeBasis, int _Order>
const Configuration_t& hpp::core::path::Spline< _PolynomeBasis, _Order >::base ( ) const
inline

Get the base configuration. The parameters are velocities to be integrated from this configuration.

◆ base() [2/2]

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::base ( const Configuration_t q)
inline
See also
base() const

◆ basisFunctionDerivative() [1/2]

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::basisFunctionDerivative ( const size_type  order,
const value_type u,
BasisFunctionVector_t res 
) const

Returns a vector \( (v_i) \) as

\[ v_i = T^{-k} b_i^{(k)}(u) \]

◆ basisFunctionDerivative() [2/2]

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::basisFunctionDerivative ( const size_type  order,
const value_type u,
vectorOut_t  res 
) const
inline

◆ copy() [1/2]

template<int _PolynomeBasis, int _Order>
PathPtr_t hpp::core::path::Spline< _PolynomeBasis, _Order >::copy ( ) const
inline

◆ copy() [2/2]

template<int _PolynomeBasis, int _Order>
PathPtr_t hpp::core::path::Spline< _PolynomeBasis, _Order >::copy ( const ConstraintSetPtr_t constraints) const
inline

◆ create()

template<int _PolynomeBasis, int _Order>
static Ptr_t hpp::core::path::Spline< _PolynomeBasis, _Order >::create ( const DevicePtr_t robot,
const interval_t interval,
const ConstraintSetPtr_t constraints 
)
inlinestatic

◆ end()

template<int _PolynomeBasis, int _Order>
virtual Configuration_t hpp::core::path::Spline< _PolynomeBasis, _Order >::end ( ) const
inlinevirtual

◆ impl_compute()

template<int _PolynomeBasis, int _Order>
bool hpp::core::path::Spline< _PolynomeBasis, _Order >::impl_compute ( ConfigurationOut_t  configuration,
value_type  t 
) const
protected

◆ impl_derivative()

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::impl_derivative ( vectorOut_t  res,
const value_type t,
size_type  order 
) const
protected

◆ impl_paramDerivative()

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::impl_paramDerivative ( vectorOut_t  res,
const value_type t 
) const
protected

◆ impl_paramIntegrate()

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::impl_paramIntegrate ( vectorIn_t  dParam)
protected

◆ impl_velocityBound()

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::impl_velocityBound ( vectorOut_t  result,
const value_type t0,
const value_type t1 
) const
protected

◆ init()

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::init ( const Ptr_t self)
inlineprotected

◆ initial()

template<int _PolynomeBasis, int _Order>
virtual Configuration_t hpp::core::path::Spline< _PolynomeBasis, _Order >::initial ( ) const
inlinevirtual

◆ maxVelocity()

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::maxVelocity ( vectorOut_t  res) const

Returns an upper bound of the velocity on the complete interval.

See also
Path::velocityBound

◆ parameterDerivativeCoefficients()

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::parameterDerivativeCoefficients ( vectorOut_t  res,
const value_type t 
) const
inline

The partial derivative with respects to the parameters is of the form

\begin{eqnarray*} \frac{\partial S}{\partial p_{k}} (q, p, t) &=& B_k(t) \times I \\ \frac{\partial S}{\partial q_{base}} (q, p, t) &=& I \end{eqnarray*}

This method returns the coefficients \( (B_k(t))_{k} \)

◆ parameterIntegrate()

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::parameterIntegrate ( vectorIn_t  dParam)
inline

Adds dParam to the parameters.

◆ parameters() [1/2]

template<int _PolynomeBasis, int _Order>
const ParameterMatrix_t& hpp::core::path::Spline< _PolynomeBasis, _Order >::parameters ( ) const
inline

Each row corresponds to a velocity of the robot.

◆ parameters() [2/2]

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::parameters ( const ParameterMatrix_t m)
inline

Returns the \( (P_i^T) \). Each row contains one parameter.

◆ parameterSize()

template<int _PolynomeBasis, int _Order>
size_type hpp::core::path::Spline< _PolynomeBasis, _Order >::parameterSize ( ) const
inline

◆ print()

template<int _PolynomeBasis, int _Order>
std::ostream& hpp::core::path::Spline< _PolynomeBasis, _Order >::print ( std::ostream &  os) const
protected

◆ rowParameters() [1/2]

template<int _PolynomeBasis, int _Order>
ConstParameterVector_t hpp::core::path::Spline< _PolynomeBasis, _Order >::rowParameters ( ) const
inline

Concatenate the parameters as one vector (P_0^T, ..., P_n^T).

◆ rowParameters() [2/2]

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::rowParameters ( vectorIn_t  p)
inline

Set the parameters.

◆ squaredNormBasisFunctionIntegral() [1/2]

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::squaredNormBasisFunctionIntegral ( const size_type  order,
BasisFunctionIntegralMatrix_t res 
) const

Returns a matrix \( (m_{i,j}) \) as

\[ m_{i,j} = T^{1-2k} \int_0^1 b_i^{(k)}(u) b_j^{(k)}(u) du \]

◆ squaredNormBasisFunctionIntegral() [2/2]

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::squaredNormBasisFunctionIntegral ( const size_type  order,
matrixOut_t  res 
) const
inline

◆ squaredNormIntegral()

template<int _PolynomeBasis, int _Order>
value_type hpp::core::path::Spline< _PolynomeBasis, _Order >::squaredNormIntegral ( const size_type  order) const

Returns \( \int S^{(k)}(t)^T \times S^{(k)}(t) dt \)

where k is the argument

◆ squaredNormIntegralDerivative()

template<int _PolynomeBasis, int _Order>
void hpp::core::path::Spline< _PolynomeBasis, _Order >::squaredNormIntegralDerivative ( const size_type  order,
vectorOut_t  res 
) const

Returns the derivative of squaredNormIntegral wrt the parameters.

\[ res(j) \gets 2 \sum_i P_i^T \times m_{i,j} \]

◆ timeFreeBasisFunctionDerivative() [1/2]

template<int _PolynomeBasis, int _Order>
static void hpp::core::path::Spline< _PolynomeBasis, _Order >::timeFreeBasisFunctionDerivative ( const size_type  order,
const value_type u,
BasisFunctionVector_t res 
)
static

Returns a vector \( (v_i) \) as

\[ v_i = b_i^{(k)}(u) \]

◆ timeFreeBasisFunctionDerivative() [2/2]

template<int _PolynomeBasis, int _Order>
static void hpp::core::path::Spline< _PolynomeBasis, _Order >::timeFreeBasisFunctionDerivative ( const size_type  order,
const value_type u,
vectorOut_t  res 
)
inlinestatic

◆ value()

template<int _PolynomeBasis, int _Order>
static void hpp::core::path::Spline< _PolynomeBasis, _Order >::value ( pinocchio::LiegroupElementConstRef  base,
Eigen::Ref< const ParameterMatrix_t params,
const value_type u,
ConfigurationOut_t  config,
vectorOut_t  velocity 
)
static

Evaluate a spline.

Parameters
basethe base configuration.
paramsconcatenation of row vectors representing the velocity interpolation points.
uthe ratio, between 0 and 1.
Return values
configthe output configuration
velocitythe interpolated velocity

Member Data Documentation

◆ base_

template<int _PolynomeBasis, int _Order>
LiegroupElement hpp::core::path::Spline< _PolynomeBasis, _Order >::base_
protected

Base of the spline path. The spline is a curve in the tangent space of the robot at this configuration.

◆ parameters_

template<int _PolynomeBasis, int _Order>
ParameterMatrix_t hpp::core::path::Spline< _PolynomeBasis, _Order >::parameters_
protected

Parameters of the spline are stored in a matrix number of rows = degree of polynomial + 1 number of columns = robot number of degrees of freedom.

◆ parameterSize_

template<int _PolynomeBasis, int _Order>
size_type hpp::core::path::Spline< _PolynomeBasis, _Order >::parameterSize_
protected

Robot number of degrees of freedom.

◆ robot_

template<int _PolynomeBasis, int _Order>
DevicePtr_t hpp::core::path::Spline< _PolynomeBasis, _Order >::robot_
protected

The documentation for this class was generated from the following files: