Namespaces
	liegroup

	unittest

	urdf

Classes
class	AbstractDevice
	Abstract class representing a Device. More...

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	DefaultLieGroupMap
	This class maps at compile time a joint type to a lie group type. More...

class	Device
	Robot with geometric and dynamic pinocchio. More...

struct	DeviceData
	Struct containing the Device data. More...

class	DeviceSync
	A thread-safe access to a Device. More...

class	ExtraConfigSpace
	Extra degrees of freedom to store internal values in configurations. More...

class	Frame
	Robot frame. More...

class	Gripper
	Definition of a robot gripper. More...

class	HumanoidRobot
	Humanoid robot. More...

class	Joint
	Robot joint. More...

struct	JointCollectionTpl

class	LiegroupElementBase
	Writable element of a Lie group. More...

class	LiegroupElementConstBase
	Const reference to a LiegroupElement. More...

class	LiegroupSpace
	Cartesian product of elementary Lie groups. More...

class	Pool
	Pool of objects. More...

struct	RnxSOnLieGroupMap
	This class maps at compile time a joint type to a lie group type. More...

Typedefs
typedef ::pinocchio::GeometryObject	GeometryObject

typedef double	value_type

typedef JointCollectionTpl< value_type, 0 >	JointCollection

typedef ::pinocchio::JointIndex	JointIndex

typedef ::pinocchio::FrameIndex	FrameIndex

typedef ::pinocchio::GeomIndex	GeomIndex

typedef ::pinocchio::ModelTpl< value_type, 0, JointCollectionTpl >	Model

typedef ::pinocchio::DataTpl< value_type, 0, JointCollectionTpl >	Data

typedef ::pinocchio::GeometryModel	GeomModel

typedef ::pinocchio::GeometryData	GeomData

typedef ::pinocchio::SE3	Transform3f

typedef ::pinocchio::SE3	SE3

typedef ::pinocchio::JointModelTpl< value_type, 0, JointCollectionTpl >	JointModel

typedef Eigen::Array< bool, Eigen::Dynamic, 1 >	ArrayXb

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_t >	vectorOut_t

typedef Eigen::Matrix< value_type, Eigen::Dynamic, Eigen::Dynamic >	matrix_t

typedef Eigen::Ref< matrix_t >	matrixOut_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< Body >	BodyPtr_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< Device >	DevicePtr_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< Joint >	JointPtr_t

typedef boost::shared_ptr< const Joint >	JointConstPtr_t

typedef boost::shared_ptr< Gripper >	GripperPtr_t

typedef std::vector< GripperPtr_t >	Grippers_t

typedef boost::shared_ptr< Model >	ModelPtr_t

typedef boost::shared_ptr< const Model >	ModelConstPtr_t

typedef boost::shared_ptr< Data >	DataPtr_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 LiegroupElementConstBase< vectorIn_t >	LiegroupElementConstRef
	Const reference to a LiegroupElement. More...

typedef LiegroupElementBase< vector_t >	LiegroupElement
	Element of a Lie group. More...

typedef LiegroupElementBase< vectorOut_t >	LiegroupElementRef
	Writable reference to a LiegroupElement. More...

typedef boost::shared_ptr< LiegroupSpace >	LiegroupSpacePtr_t

typedef boost::shared_ptr< const LiegroupSpace >	LiegroupSpaceConstPtr_t

typedef JointCollection::JointModelVariant	JointModelVariant

typedef JointCollection::JointDataVariant	JointDataVariant

typedef ABoostVariant	LiegroupType
	Elementary Lie groups A boost variant with the following classes: More...

typedef HPP_PINOCCHIO_DEPRECATED RnxSOnLieGroupMap	LieGroupTpl

Enumerations
enum	Computation_t { JOINT_POSITION = 0x1, JACOBIAN = 0x2, VELOCITY = 0x4, ACCELERATION = 0x8, COM = 0xf, COMPUTE_ALL = 0Xffff }

enum	Request_t { COLLISION, DISTANCE }

enum	InOutType { INNER, OUTER }

enum	DerivativeProduct { DerivativeTimesInput, InputTimesDerivative }

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 &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 LiegroupElementConstBase< 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 LiegroupElementConstBase< vector_type1 > &e1, const LiegroupElementConstBase< vector_type2 > &e2)
	Difference between two configurations. More...

template<typename vector_type >
vector_t	log (const LiegroupElementConstBase< 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 LiegroupElementConstBase< 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, Computation_t compFlags=(Computation_t)(JOINT_POSITION\|JACOBIAN))

DevicePtr_t	humanoidSimple (const std::string &name="humanoidSimple", Computation_t compFlags=(Computation_t)(JOINT_POSITION\|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 boost::shared_ptr<CenterOfMassComputation> hpp::pinocchio::CenterOfMassComputationPtr_t

typedef boost::shared_ptr<const CollisionObject> hpp::pinocchio::CollisionObjectConstPtr_t

typedef boost::shared_ptr<CollisionObject> hpp::pinocchio::CollisionObjectPtr_t

typedef Eigen::Matrix<value_type, 3, Eigen::Dynamic> hpp::pinocchio::ComJacobian_t

typedef vector_t hpp::pinocchio::Configuration_t

typedef Eigen::Ref<const Configuration_t> hpp::pinocchio::ConfigurationIn_t

typedef Eigen::Ref<Configuration_t> hpp::pinocchio::ConfigurationOut_t

typedef boost::shared_ptr<Configuration_t> hpp::pinocchio::ConfigurationPtr_t

typedef ::pinocchio::DataTpl<value_type, 0, JointCollectionTpl> 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 ::pinocchio::FrameIndex hpp::pinocchio::FrameIndex

typedef ::pinocchio::GeometryData hpp::pinocchio::GeomData

typedef boost::shared_ptr<const GeomData> hpp::pinocchio::GeomDataConstPtr_t

typedef boost::shared_ptr<GeomData> hpp::pinocchio::GeomDataPtr_t

typedef ::pinocchio::GeometryObject hpp::pinocchio::GeometryObject

typedef ::pinocchio::GeomIndex hpp::pinocchio::GeomIndex

typedef ::pinocchio::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 std::vector<GripperPtr_t> hpp::pinocchio::Grippers_t

typedef Eigen::Block<JointJacobian_t, 3, Eigen::Dynamic> hpp::pinocchio::HalfJointJacobian_t

typedef boost::shared_ptr<HumanoidRobot> hpp::pinocchio::HumanoidRobotPtr_t

typedef JointCollectionTpl<value_type, 0> hpp::pinocchio::JointCollection

typedef boost::shared_ptr<const Joint> hpp::pinocchio::JointConstPtr_t

typedef JointCollection::JointDataVariant hpp::pinocchio::JointDataVariant

typedef ::pinocchio::JointIndex hpp::pinocchio::JointIndex

typedef Eigen::Matrix<value_type, 6, Eigen::Dynamic> hpp::pinocchio::JointJacobian_t

typedef ::pinocchio::JointModelTpl<value_type, 0, JointCollectionTpl> hpp::pinocchio::JointModel

typedef JointCollection::JointModelVariant hpp::pinocchio::JointModelVariant

typedef boost::shared_ptr<Joint> hpp::pinocchio::JointPtr_t

typedef JointVector hpp::pinocchio::JointVector_t

typedef LiegroupElementBase< vector_t> hpp::pinocchio::LiegroupElement

Element of a Lie group.

typedef LiegroupElementConstBase< vectorIn_t> hpp::pinocchio::LiegroupElementConstRef

Const reference to a LiegroupElement.

typedef LiegroupElementBase<vectorOut_t> hpp::pinocchio::LiegroupElementRef

Writable reference to a LiegroupElement.

typedef boost::shared_ptr<const LiegroupSpace> hpp::pinocchio::LiegroupSpaceConstPtr_t

typedef boost::shared_ptr<LiegroupSpace> hpp::pinocchio::LiegroupSpacePtr_t

typedef HPP_PINOCCHIO_DEPRECATED RnxSOnLieGroupMap hpp::pinocchio::LieGroupTpl

Deprecated:: Use RnxSOnLieGroupMap

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 Eigen::Ref<matrix_t> hpp::pinocchio::matrixOut_t

typedef ::pinocchio::ModelTpl<value_type, 0, JointCollectionTpl> hpp::pinocchio::Model

typedef boost::shared_ptr<const Model> hpp::pinocchio::ModelConstPtr_t

typedef boost::shared_ptr<Model> hpp::pinocchio::ModelPtr_t

typedef ObjectVector hpp::pinocchio::ObjectVector_t

typedef ::pinocchio::SE3 hpp::pinocchio::SE3

typedef matrix_t::Index hpp::pinocchio::size_type

typedef ::pinocchio::SE3 hpp::pinocchio::Transform3f

typedef double hpp::pinocchio::value_type

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

typedef Eigen::Ref<vector_t> hpp::pinocchio::vectorOut_t

Enumeration Type Documentation

enum hpp::pinocchio::Computation_t

Enumerator
JOINT_POSITION
JACOBIAN
VELOCITY
ACCELERATION
COM
COMPUTE_ALL

enum hpp::pinocchio::InOutType

Enumerator
INNER
OUTER

enum hpp::pinocchio::Request_t

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

robot	robot that describes the kinematic chain
q1	first configuration,
q2	second configuration,

Return values

result difference 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 &	m
	)

Write a SE3 taking into account the indentation.

Referenced by displayConfig(), hpp::pinocchio::Frame::robot(), and hpp::pinocchio::Joint::robot().

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

inline

Write configuration in a string.

References display().

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

Distance between two configuration.

Parameters

robot	robot that describes the kinematic chain
q1	first configuration,
q2	second 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`,
		Computation_t	compFlags = `(Computation_t)(JOINT_POSITION\|JACOBIAN)`
	)

DevicePtr_t hpp::pinocchio::humanoidSimple	(	const std::string &	name = `"humanoidSimple"`,
		Computation_t	compFlags = `(Computation_t)(JOINT_POSITION\|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>

Template Parameters

saturateConfig when true, calls saturate at the end

Parameters

robot	robot that describes the kinematic chain
configuration	initial and result configurations
velocity	velocity vector

Return values

result

configuration reached after integration. Velocity is dispatched to each joint that integrates according to its Lie group structure, i.e.

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

robot	robot that describes the kinematic chain
q0,q1	two configurations to interpolate
u	in [0,1] position along the interpolation: q0 for u=0, q1 for u=1

Return values

result interpolated 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

robot	robot that describes the kinematic chain
q1	first configuration,
q2	second configuration,
eps	numerical 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(), and normalize().

template<typename vector_type >

vector_t hpp::pinocchio::log ( const LiegroupElementConstBase< vector_type > & lge )

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

Referenced by hpp::pinocchio::LiegroupElementBase< vector_type >::operator=().

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 isNormalized(), and normalize().

std::ostream& hpp::pinocchio::operator<<	(	std::ostream &	os,
		const Gripper &	gripper
	)

inline

References hpp::pinocchio::Gripper::print().

std::ostream& hpp::pinocchio::operator<<	(	std::ostream &	os,
		const Frame &	frame
	)

inline

References hpp::pinocchio::Frame::display().

template<typename vector_type >

std::ostream& hpp::pinocchio::operator<<	(	std::ostream &	os,
		const LiegroupElementConstBase< vector_type > &	e
	)

inline

References hpp::pinocchio::LiegroupElementConstBase< vector_type >::vector().

std::ostream& hpp::pinocchio::operator<<	(	std::ostream &	os,
		const Joint &	joint
	)

inline

References hpp::pinocchio::Joint::display().

std::ostream& hpp::pinocchio::operator<<	(	std::ostream &	os,
		const hpp::pinocchio::Device &	device
	)

inline

References hpp::pinocchio::Device::print().

void hpp::pinocchio::saturate	(	const DevicePtr_t &	robot,
		ConfigurationOut_t	configuration
	)

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

Parameters

	robot	robot that describes the kinematic chain
[in,out]	configuration	initial and result configurations

Return values

configuration reached 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

	robot	robot that describes the kinematic chain
[in,out]	configuration	initial and result configurations

Return values

saturation an array of boolean saying who saturated (size robot.numberDof()).

Namespaces

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation