All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
Namespaces | Classes | Typedefs | Enumerations | Functions
hpp::pinocchio Namespace Reference

Namespaces

 liegroup
 
 unittest
 
 urdf
 

Classes

class  Body
 Geometry associated to a Joint. More...
 
class  CenterOfMassComputation
 Computation of the center of mass of a subtree of a kinematic tree. More...
 
class  CollisionObject
 Specialization of fcl::CollisionObject to add a name to objects. More...
 
struct  DeviceObjectVector
 Iterator over all inner objects of a Device. More...
 
struct  ObjectVector
 
struct  JointVector
 Fake std::vector<Joint>, used to comply with the actual structure of hpp::model. More...
 
class  Device
 Robot with geometric and dynamic pinocchio. More...
 
class  ExtraConfigSpace
 Extra degrees of freedom to store internal values in configurations. More...
 
struct  FakeContainer
 
class  Frame
 Robot frame. More...
 
class  LiegroupNonconstElementBase
 
class  Gripper
 Definition of a robot gripper. More...
 
class  HumanoidRobot
 Humanoid robot. More...
 
class  Joint
 Robot joint. More...
 
class  LiegroupElementBase
 
class  LiegroupSpace
 Cartesian product of elementary Lie groups. More...
 
struct  RnxSOnLieGroupMap
 This class maps at compile time a joint type to a lie group type. More...
 
struct  DefaultLieGroupMap
 This class maps at compile time a joint type to a lie group type. More...
 

Typedefs

typedef se3::JointIndex JointIndex
 
typedef se3::FrameIndex FrameIndex
 
typedef se3::GeomIndex GeomIndex
 
typedef se3::Model Model
 
typedef se3::Data Data
 
typedef se3::GeometryModel GeomModel
 
typedef se3::GeometryData GeomData
 
typedef se3::SE3 Transform3f
 
typedef se3::JointModel JointModel
 
typedef Eigen::Array< bool,
Eigen::Dynamic, 1 > 
ArrayXb
 
typedef double value_type
 
typedef Eigen::Matrix
< value_type, Eigen::Dynamic, 1 > 
vector_t
 
typedef vector_t Configuration_t
 
typedef Eigen::Ref< const
Configuration_t
ConfigurationIn_t
 
typedef Eigen::Ref
< Configuration_t
ConfigurationOut_t
 
typedef boost::shared_ptr
< Configuration_t
ConfigurationPtr_t
 
typedef Eigen::Ref< const
vector_t
vectorIn_t
 
typedef Eigen::Ref< vector_tvectorOut_t
 
typedef Eigen::Matrix
< value_type, Eigen::Dynamic,
Eigen::Dynamic > 
matrix_t
 
typedef Eigen::Ref< matrix_tmatrixOut_t
 
typedef matrix_t::Index size_type
 
typedef Eigen::Matrix
< value_type, 3, 3 > 
matrix3_t
 
typedef Eigen::Matrix
< value_type, 3, 1 > 
vector3_t
 
typedef Eigen::Matrix
< value_type, 4, 1 > 
vector4_t
 
typedef Eigen::Matrix
< value_type,
6, Eigen::Dynamic > 
JointJacobian_t
 
typedef Eigen::Matrix
< value_type,
3, Eigen::Dynamic > 
ComJacobian_t
 
typedef Eigen::Block
< JointJacobian_t,
3, Eigen::Dynamic > 
HalfJointJacobian_t
 
typedef JointVector JointVector_t
 
typedef ObjectVector ObjectVector_t
 
typedef boost::shared_ptr< BodyBodyPtr_t
 
typedef boost::shared_ptr
< const Body
BodyConstPtr_t
 
typedef fcl::CollisionObject FclCollisionObject
 
typedef fcl::CollisionObject * FclCollisionObjectPtr_t
 
typedef const
fcl::CollisionObject * 
FclConstCollisionObjectPtr_t
 
typedef boost::shared_ptr
< CollisionObject
CollisionObjectPtr_t
 
typedef boost::shared_ptr
< const CollisionObject
CollisionObjectConstPtr_t
 
typedef boost::shared_ptr< DeviceDevicePtr_t
 
typedef boost::shared_ptr
< const Device
DeviceConstPtr_t
 
typedef std::vector
< fcl::DistanceResult > 
DistanceResults_t
 
typedef boost::shared_ptr
< HumanoidRobot
HumanoidRobotPtr_t
 
typedef boost::shared_ptr
< CenterOfMassComputation
CenterOfMassComputationPtr_t
 
typedef boost::shared_ptr< JointJointPtr_t
 
typedef boost::shared_ptr
< const Joint
JointConstPtr_t
 
typedef boost::shared_ptr
< Gripper
GripperPtr_t
 
typedef std::vector< GripperPtr_tGrippers_t
 
typedef boost::shared_ptr< ModelModelPtr_t
 
typedef boost::shared_ptr
< const Model
ModelConstPtr_t
 
typedef boost::shared_ptr< DataDataPtr_t
 
typedef boost::shared_ptr
< const Data
DataConstPtr_t
 
typedef boost::shared_ptr
< GeomModel
GeomModelPtr_t
 
typedef boost::shared_ptr
< const GeomModel
GeomModelConstPtr_t
 
typedef boost::shared_ptr
< GeomData
GeomDataPtr_t
 
typedef boost::shared_ptr
< const GeomData
GeomDataConstPtr_t
 
typedef
LiegroupNonconstElementBase
< vector_t
LiegroupElement
 Element of a Lie group. More...
 
typedef boost::shared_ptr
< LiegroupSpace
LiegroupSpacePtr_t
 
typedef boost::shared_ptr
< const LiegroupSpace
LiegroupSpaceConstPtr_t
 
typedef LiegroupElementBase
< vectorIn_t
LiegroupConstElementRef
 
typedef
LiegroupNonconstElementBase
< vectorOut_t
LiegroupElementRef
 
typedef boost::variant
< liegroup::VectorSpaceOperation
< Eigen::Dynamic, false >
, liegroup::VectorSpaceOperation
< 1, true >
, liegroup::VectorSpaceOperation
< 1, false >
, liegroup::VectorSpaceOperation
< 2, false >
, liegroup::VectorSpaceOperation
< 3, false >
, liegroup::VectorSpaceOperation
< 3, true >
, liegroup::CartesianProductOperation
< liegroup::VectorSpaceOperation
< 3, false >
, liegroup::SpecialOrthogonalOperation
< 3 > >, liegroup::CartesianProductOperation
< liegroup::VectorSpaceOperation
< 2, false >
, liegroup::SpecialOrthogonalOperation
< 2 > >, liegroup::SpecialOrthogonalOperation
< 2 >, liegroup::SpecialOrthogonalOperation
< 3 >, se3::SpecialEuclideanOperation
< 2 >, se3::SpecialEuclideanOperation< 3 > > 
LiegroupType
 Elementary Lie groups. More...
 
typedef
HPP_PINOCCHIO_DEPRECATED
RnxSOnLieGroupMap 
LieGroupTpl
 

Enumerations

enum  Request_t {
  COLLISION,
  DISTANCE
}
 
enum  InOutType {
  INNER,
  OUTER
}
 

Functions

void saturate (const DevicePtr_t &robot, ConfigurationOut_t configuration)
 Saturate joint parameter value so that they are not out of bounds. More...
 
bool saturate (const DevicePtr_t &robot, ConfigurationOut_t configuration, ArrayXb &saturation)
 Saturate joint parameter value so that they are not out of bounds. More...
 
template<bool saturateConfig, typename LieGroup >
void integrate (const DevicePtr_t &robot, ConfigurationIn_t configuration, vectorIn_t velocity, ConfigurationOut_t result)
 Integrate a constant velocity during unit time. More...
 
template<typename LieGroup >
void interpolate (const DevicePtr_t &robot, ConfigurationIn_t q0, ConfigurationIn_t q1, const value_type &u, ConfigurationOut_t result)
 Interpolate between two configurations of the robot. More...
 
template<typename LieGroup >
void difference (const DevicePtr_t &robot, ConfigurationIn_t q1, ConfigurationIn_t q2, vectorOut_t result)
 Difference between two configurations as a vector. More...
 
bool isApprox (const DevicePtr_t &robot, ConfigurationIn_t q1, ConfigurationIn_t q2, value_type eps)
 Test that two configurations are close. More...
 
value_type distance (const DevicePtr_t &robot, ConfigurationIn_t q1, ConfigurationIn_t q2)
 Distance between two configuration. More...
 
void normalize (const DevicePtr_t &robot, Configuration_t &q)
 Normalize configuration. More...
 
void normalize (const DevicePtr_t &robot, ConfigurationOut_t q)
 For backward compatibility. More...
 
bool isNormalized (const DevicePtr_t &robot, ConfigurationIn_t q, const value_type &eps)
 Check if a configuration is normalized. More...
 
std::string displayConfig (ConfigurationIn_t q, int precision=20)
 Write configuration in a string. More...
 
std::ostream & display (std::ostream &os, const se3::SE3 &m)
 Write a SE3 taking into account the indentation. More...
 
std::ostream & operator<< (std::ostream &os, const hpp::pinocchio::Device &device)
 
std::ostream & operator<< (std::ostream &os, const Frame &frame)
 
 HPP_PREDEF_CLASS (Body)
 
 HPP_PREDEF_CLASS (CollisionObject)
 
 HPP_PREDEF_CLASS (Device)
 
 HPP_PREDEF_CLASS (HumanoidRobot)
 
 HPP_PREDEF_CLASS (Joint)
 
 HPP_PREDEF_CLASS (JointConfiguration)
 
 HPP_PREDEF_CLASS (Gripper)
 
 HPP_PREDEF_CLASS (CenterOfMassComputation)
 
 HPP_PREDEF_CLASS (LiegroupSpace)
 
std::ostream & operator<< (std::ostream &os, const Gripper &gripper)
 
std::ostream & operator<< (std::ostream &os, const Joint &joint)
 
template<typename vector_type >
LiegroupElement operator+ (const LiegroupElementBase< vector_type > &e, vectorIn_t v)
 Integration of a velocity vector from a configuration. More...
 
template<typename vector_type1 , typename vector_type2 >
vector_t operator- (const LiegroupElementBase< vector_type1 > &e1, const LiegroupElementBase< vector_type2 > &e2)
 Difference between two configurations. More...
 
template<typename vector_type >
vector_t log (const LiegroupElementBase< vector_type > &lge)
 Compute the log as a tangent vector of a Lie group element. More...
 
template<typename vector_type >
std::ostream & operator<< (std::ostream &os, const LiegroupElementBase< vector_type > &e)
 
std::ostream & operator<< (std::ostream &os, const LiegroupSpace &space)
 Writing in a stream. More...
 
DevicePtr_t humanoidSimple (const std::string &name="humanoidSimple", bool usingFF=true, Device::Computation_t compFlags=(Device::Computation_t)(Device::JOINT_POSITION|Device::JACOBIAN))
 

Typedef Documentation

typedef Eigen::Array<bool, Eigen::Dynamic, 1> hpp::pinocchio::ArrayXb
typedef boost::shared_ptr<const Body> hpp::pinocchio::BodyConstPtr_t
typedef boost::shared_ptr<Body> hpp::pinocchio::BodyPtr_t
typedef Eigen::Matrix<value_type, 3, Eigen::Dynamic> hpp::pinocchio::ComJacobian_t
typedef se3::Data hpp::pinocchio::Data
typedef boost::shared_ptr<const Data> hpp::pinocchio::DataConstPtr_t
typedef boost::shared_ptr<Data> hpp::pinocchio::DataPtr_t
typedef boost::shared_ptr<const Device> hpp::pinocchio::DeviceConstPtr_t
typedef boost::shared_ptr<Device> hpp::pinocchio::DevicePtr_t
typedef std::vector<fcl::DistanceResult> hpp::pinocchio::DistanceResults_t
typedef fcl::CollisionObject hpp::pinocchio::FclCollisionObject
typedef fcl::CollisionObject* hpp::pinocchio::FclCollisionObjectPtr_t
typedef const fcl::CollisionObject* hpp::pinocchio::FclConstCollisionObjectPtr_t
typedef se3::FrameIndex hpp::pinocchio::FrameIndex
typedef se3::GeometryData hpp::pinocchio::GeomData
typedef boost::shared_ptr<const GeomData> hpp::pinocchio::GeomDataConstPtr_t
typedef boost::shared_ptr<GeomData> hpp::pinocchio::GeomDataPtr_t
typedef se3::GeomIndex hpp::pinocchio::GeomIndex
typedef se3::GeometryModel hpp::pinocchio::GeomModel
typedef boost::shared_ptr<const GeomModel> hpp::pinocchio::GeomModelConstPtr_t
typedef boost::shared_ptr<GeomModel> hpp::pinocchio::GeomModelPtr_t
typedef boost::shared_ptr<Gripper> hpp::pinocchio::GripperPtr_t
typedef Eigen::Block<JointJacobian_t, 3, Eigen::Dynamic> hpp::pinocchio::HalfJointJacobian_t
typedef boost::shared_ptr<const Joint> hpp::pinocchio::JointConstPtr_t
typedef se3::JointIndex hpp::pinocchio::JointIndex
typedef Eigen::Matrix<value_type, 6, Eigen::Dynamic> hpp::pinocchio::JointJacobian_t
typedef se3::JointModel hpp::pinocchio::JointModel
typedef boost::shared_ptr<Joint> hpp::pinocchio::JointPtr_t
typedef boost::shared_ptr<const LiegroupSpace> hpp::pinocchio::LiegroupSpaceConstPtr_t
typedef Eigen::Matrix<value_type, 3, 3> hpp::pinocchio::matrix3_t
typedef Eigen::Matrix<value_type, Eigen::Dynamic, Eigen::Dynamic> hpp::pinocchio::matrix_t
typedef se3::Model hpp::pinocchio::Model
typedef boost::shared_ptr<const Model> hpp::pinocchio::ModelConstPtr_t
typedef boost::shared_ptr<Model> hpp::pinocchio::ModelPtr_t
typedef matrix_t::Index hpp::pinocchio::size_type
typedef se3::SE3 hpp::pinocchio::Transform3f
typedef Eigen::Matrix<value_type, 3, 1> hpp::pinocchio::vector3_t
typedef Eigen::Matrix<value_type, 4, 1> hpp::pinocchio::vector4_t
typedef Eigen::Matrix<value_type, Eigen::Dynamic, 1> hpp::pinocchio::vector_t
typedef Eigen::Ref<const vector_t> hpp::pinocchio::vectorIn_t

Enumeration Type Documentation

Enumerator
INNER 
OUTER 
Enumerator
COLLISION 
DISTANCE 

Function Documentation

template<typename LieGroup >
void hpp::pinocchio::difference ( const DevicePtr_t &  robot,
ConfigurationIn_t  q1,
ConfigurationIn_t  q2,
vectorOut_t  result 
)

Difference between two configurations as a vector.

Parameters
robotrobot that describes the kinematic chain
q1first configuration,
q2second configuration,
Return values
resultdifference as a vector $\textbf{v}$ such that q1 is the result of method integrate from q2 with vector $\textbf{v}$
Note
If the configuration space is a vector space, this is $\textbf{v} = q_1 - q_2$
std::ostream& hpp::pinocchio::display ( std::ostream &  os,
const se3::SE3 &  m 
)

Write a SE3 taking into account the indentation.

std::string hpp::pinocchio::displayConfig ( ConfigurationIn_t  q,
int  precision = 20 
)
inline

Write configuration in a string.

value_type hpp::pinocchio::distance ( const DevicePtr_t &  robot,
ConfigurationIn_t  q1,
ConfigurationIn_t  q2 
)

Distance between two configuration.

Parameters
robotrobot that describes the kinematic chain
q1first configuration,
q2second configuration,
hpp::pinocchio::HPP_PREDEF_CLASS ( Body  )
hpp::pinocchio::HPP_PREDEF_CLASS ( CollisionObject  )
hpp::pinocchio::HPP_PREDEF_CLASS ( Device  )
hpp::pinocchio::HPP_PREDEF_CLASS ( HumanoidRobot  )
hpp::pinocchio::HPP_PREDEF_CLASS ( Joint  )
hpp::pinocchio::HPP_PREDEF_CLASS ( JointConfiguration  )
hpp::pinocchio::HPP_PREDEF_CLASS ( Gripper  )
hpp::pinocchio::HPP_PREDEF_CLASS ( CenterOfMassComputation  )
hpp::pinocchio::HPP_PREDEF_CLASS ( LiegroupSpace  )
DevicePtr_t hpp::pinocchio::humanoidSimple ( const std::string &  name = "humanoidSimple",
bool  usingFF = true,
Device::Computation_t  compFlags = (Device::Computation_t)(Device::JOINT_POSITION|Device::JACOBIAN) 
)
template<bool saturateConfig, typename LieGroup >
void hpp::pinocchio::integrate ( const DevicePtr_t &  robot,
ConfigurationIn_t  configuration,
vectorIn_t  velocity,
ConfigurationOut_t  result 
)

Integrate a constant velocity during unit time.

Same as integrate<true, DefaultLieGroupMap>

Parameters
saturateConfigwhen true, calls saturate at the end
robotrobot that describes the kinematic chain
configurationinitial and result configurations
velocityvelocity vector
Return values
resultconfiguration reached after integration. Velocity is dispatched to each joint that integrates according to its Lie group structure, i.e.
  • $q_i += v_i$ for translation joint and bounded rotation joints,
  • $q_i += v_i \mbox{ modulo } 2\pi$ for unbounded rotation joints,
  • constant rotation velocity for SO(3) joints.
Note
bounded degrees of freedom are saturated if the result of the above operation is beyond a bound.
template<typename LieGroup >
void hpp::pinocchio::interpolate ( const DevicePtr_t &  robot,
ConfigurationIn_t  q0,
ConfigurationIn_t  q1,
const value_type &  u,
ConfigurationOut_t  result 
)

Interpolate between two configurations of the robot.

Parameters
robotrobot that describes the kinematic chain
q0,q1,twoconfigurations to interpolate
uin [0,1] position along the interpolation: q0 for u=0, q1 for u=1
Return values
resultinterpolated configuration
bool hpp::pinocchio::isApprox ( const DevicePtr_t &  robot,
ConfigurationIn_t  q1,
ConfigurationIn_t  q2,
value_type  eps 
)

Test that two configurations are close.

Parameters
robotrobot that describes the kinematic chain
q1first configuration,
q2second configuration,
epsnumerical threshold
Returns
true if the configurations are closer than the numerical threshold
bool hpp::pinocchio::isNormalized ( const DevicePtr_t &  robot,
ConfigurationIn_t  q,
const value_type &  eps 
)

Check if a configuration is normalized.

It consists in checking that norm of quaternions and complex is one.

Referenced by hpp::pinocchio::liegroup::CartesianProductOperation< LieGroup1, LieGroup2 >::isNormalized().

template<typename vector_type >
vector_t hpp::pinocchio::log ( const LiegroupElementBase< vector_type > &  lge)

Compute the log as a tangent vector of a Lie group element.

void hpp::pinocchio::normalize ( const DevicePtr_t &  robot,
Configuration_t &  q 
)

Normalize configuration.

Configuration space is a represented by a sub-manifold of a vector space. Normalization consists in projecting a vector on this sub-manifold. It mostly consists in normalizing quaternions for SO3 joints and 2D-vectors for unbounded rotations.

Referenced by normalize().

void hpp::pinocchio::normalize ( const DevicePtr_t &  robot,
ConfigurationOut_t  q 
)
inline

For backward compatibility.

See normalize normalize (const DevicePtr_t&, Configuration_t&)

References normalize().

std::ostream& hpp::pinocchio::operator<< ( std::ostream &  os,
const Gripper &  gripper 
)
std::ostream& hpp::pinocchio::operator<< ( std::ostream &  os,
const Frame &  frame 
)
inline
template<typename vector_type >
std::ostream& hpp::pinocchio::operator<< ( std::ostream &  os,
const LiegroupElementBase< vector_type > &  e 
)
inline
std::ostream& hpp::pinocchio::operator<< ( std::ostream &  os,
const Joint &  joint 
)
inline
std::ostream& hpp::pinocchio::operator<< ( std::ostream &  os,
const hpp::pinocchio::Device device 
)
inline
void hpp::pinocchio::saturate ( const DevicePtr_t &  robot,
ConfigurationOut_t  configuration 
)

Saturate joint parameter value so that they are not out of bounds.

Parameters
robotrobot that describes the kinematic chain
[in,out]configurationinitial and result configurations
Return values
configurationreached after saturation.
bool hpp::pinocchio::saturate ( const DevicePtr_t &  robot,
ConfigurationOut_t  configuration,
ArrayXb &  saturation 
)

Saturate joint parameter value so that they are not out of bounds.

Parameters
robotrobot that describes the kinematic chain
[in,out]configurationinitial and result configurations
Return values
saturationan array of boolean saying who saturated (size robot.numberDof()).