Namespaces
namespace	liegroup

namespace	unittest

namespace	urdf

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

class	Body

class	CenterOfMassComputation

class	CollisionObject

struct	DefaultLieGroupMap

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

struct	DeviceData

class	DeviceSync

class	ExtraConfigSpace

class	Frame
	Robot frame. More...

class	Gripper

class	HumanoidRobot
	Humanoid robot. More...

class	Joint

struct	JointCollectionTpl

class	LiegroupElementBase

class	LiegroupElementConstBase

class	LiegroupSpace

class	Pool
	Pool of objects. More...

struct	RnxSOnLieGroupMap

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	Transform3s

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 shared_ptr< Configuration_t > ConfigurationPtr_t	HPP_PINOCCHIO_DEPRECATED

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 shared_ptr< Body >	BodyPtr_t

typedef shared_ptr< const Body >	BodyConstPtr_t

typedef shared_ptr< CollisionGeometry >	CollisionGeometryPtr_t

typedef coal::CollisionObject	FclCollisionObject

typedef coal::CollisionObject *	FclCollisionObjectPtr_t

typedef const coal::CollisionObject *	FclConstCollisionObjectPtr_t

typedef shared_ptr< CollisionObject >	CollisionObjectPtr_t

typedef shared_ptr< const CollisionObject >	CollisionObjectConstPtr_t

typedef shared_ptr< Device >	DevicePtr_t

typedef shared_ptr< const Device >	DeviceConstPtr_t

typedef std::vector< coal::DistanceResult >	DistanceResults_t

typedef shared_ptr< HumanoidRobot >	HumanoidRobotPtr_t

typedef shared_ptr< CenterOfMassComputation >	CenterOfMassComputationPtr_t

typedef shared_ptr< Joint >	JointPtr_t

typedef shared_ptr< const Joint >	JointConstPtr_t

typedef shared_ptr< Gripper >	GripperPtr_t

typedef std::vector< GripperPtr_t >	Grippers_t

typedef shared_ptr< Model >	ModelPtr_t

typedef shared_ptr< const Model >	ModelConstPtr_t

typedef shared_ptr< Data >	DataPtr_t

typedef shared_ptr< const Data >	DataConstPtr_t

typedef shared_ptr< GeomModel >	GeomModelPtr_t

typedef shared_ptr< const GeomModel >	GeomModelConstPtr_t

typedef shared_ptr< GeomData >	GeomDataPtr_t

typedef shared_ptr< const GeomData >	GeomDataConstPtr_t

typedef LiegroupElementConstBase< vectorIn_t >	LiegroupElementConstRef
	Const reference to a LiegroupElement.

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

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

typedef shared_ptr< LiegroupSpace >	LiegroupSpacePtr_t

typedef shared_ptr< const LiegroupSpace >	LiegroupSpaceConstPtr_t

typedef JointCollection::JointModelVariant	JointModelVariant

typedef JointCollection::JointDataVariant	JointDataVariant

typedef ABoostVariant	LiegroupType

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)

bool	saturate (const DevicePtr_t &robot, ConfigurationOut_t configuration, ArrayXb &saturation)

template<bool saturateConfig, typename LieGroup >
void	integrate (const DevicePtr_t &robot, ConfigurationIn_t configuration, vectorIn_t velocity, ConfigurationOut_t result)

void	integrate (const DevicePtr_t &robot, ConfigurationIn_t configuration, vectorIn_t velocity, ConfigurationOut_t result)

template<typename LieGroup >
void	interpolate (const DevicePtr_t &robot, ConfigurationIn_t q0, ConfigurationIn_t q1, const value_type &u, ConfigurationOut_t result)

void	interpolate (const DevicePtr_t &robot, ConfigurationIn_t q0, ConfigurationIn_t q1, const value_type &u, ConfigurationOut_t result)

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

void	difference (const DevicePtr_t &robot, ConfigurationIn_t q1, ConfigurationIn_t q2, vectorOut_t result)

bool	isApprox (const DevicePtr_t &robot, ConfigurationIn_t q1, ConfigurationIn_t q2, value_type eps)

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

void	normalize (const DevicePtr_t &robot, Configuration_t &q)

void	normalize (const DevicePtr_t &robot, ConfigurationOut_t q)

bool	isNormalized (const DevicePtr_t &robot, ConfigurationIn_t q, const value_type &eps)

std::string	displayConfig (ConfigurationIn_t q, int precision=20)
	Write configuration in a string.

std::ostream &	display (std::ostream &os, const SE3 &m)
	Write a SE3 taking into account the indentation.

void	replaceGeometryByConvexHull (GeomModel &geomModel, const std::vector< std::string > &geometryNames)

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)

template<typename vector_type1 , typename vector_type2 >
vector_t	operator- (const LiegroupElementConstBase< vector_type1 > &e1, const LiegroupElementConstBase< vector_type2 > &e2)

template<typename vector_type >
bool	checkNormalized (const LiegroupElementConstBase< vector_type > &e1, const value_type &eps=PINOCCHIO_DEFAULT_QUATERNION_NORM_TOLERANCE_VALUE)

template<typename vector_type >
vector_t	log (const LiegroupElementConstBase< vector_type > &lge)
	Compute the log as a tangent vector of a Lie group element.

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.

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

◆ ArrayXb

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

◆ BodyConstPtr_t

typedef shared_ptr<const Body> hpp::pinocchio::BodyConstPtr_t

◆ BodyPtr_t

typedef shared_ptr<Body> hpp::pinocchio::BodyPtr_t

◆ CenterOfMassComputationPtr_t

typedef shared_ptr<CenterOfMassComputation> hpp::pinocchio::CenterOfMassComputationPtr_t

◆ CollisionGeometryPtr_t

typedef shared_ptr<CollisionGeometry> hpp::pinocchio::CollisionGeometryPtr_t

◆ CollisionObjectConstPtr_t

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

◆ CollisionObjectPtr_t

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

◆ ComJacobian_t

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

◆ Configuration_t

typedef vector_t hpp::pinocchio::Configuration_t

◆ ConfigurationIn_t

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

◆ ConfigurationOut_t

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

◆ Data

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

◆ DataConstPtr_t

typedef shared_ptr<const Data> hpp::pinocchio::DataConstPtr_t

◆ DataPtr_t

typedef shared_ptr<Data> hpp::pinocchio::DataPtr_t

◆ DeviceConstPtr_t

typedef shared_ptr<const Device> hpp::pinocchio::DeviceConstPtr_t

◆ DevicePtr_t

typedef shared_ptr<Device> hpp::pinocchio::DevicePtr_t

◆ DistanceResults_t

typedef std::vector<coal::DistanceResult> hpp::pinocchio::DistanceResults_t

◆ FclCollisionObject

typedef coal::CollisionObject hpp::pinocchio::FclCollisionObject

◆ FclCollisionObjectPtr_t

typedef coal::CollisionObject* hpp::pinocchio::FclCollisionObjectPtr_t

◆ FclConstCollisionObjectPtr_t

typedef const coal::CollisionObject* hpp::pinocchio::FclConstCollisionObjectPtr_t

◆ FrameIndex

typedef ::pinocchio::FrameIndex hpp::pinocchio::FrameIndex

◆ GeomData

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

◆ GeomDataConstPtr_t

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

◆ GeomDataPtr_t

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

◆ GeometryObject

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

◆ GeomIndex

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

◆ GeomModel

typedef ::pinocchio::GeometryModel hpp::pinocchio::GeomModel

◆ GeomModelConstPtr_t

typedef shared_ptr<const GeomModel> hpp::pinocchio::GeomModelConstPtr_t

◆ GeomModelPtr_t

typedef shared_ptr<GeomModel> hpp::pinocchio::GeomModelPtr_t

◆ GripperPtr_t

typedef shared_ptr<Gripper> hpp::pinocchio::GripperPtr_t

◆ Grippers_t

typedef std::vector<GripperPtr_t> hpp::pinocchio::Grippers_t

◆ HalfJointJacobian_t

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

◆ HPP_PINOCCHIO_DEPRECATED

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

◆ HumanoidRobotPtr_t

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

◆ JointCollection

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

◆ JointConstPtr_t

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

◆ JointDataVariant

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

◆ JointIndex

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

◆ JointJacobian_t

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

◆ JointModel

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

◆ JointModelVariant

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

◆ JointPtr_t

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

◆ JointVector_t

typedef JointVector hpp::pinocchio::JointVector_t

◆ LiegroupElement

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

Element of a Lie group.

◆ LiegroupElementConstRef

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

Const reference to a LiegroupElement.

◆ LiegroupElementRef

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

Writable reference to a LiegroupElement.

◆ LiegroupSpaceConstPtr_t

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

◆ LiegroupSpacePtr_t

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

◆ matrix3_t

typedef Eigen::Matrix<value_type, 3, 3> hpp::pinocchio::matrix3_t

◆ matrix_t

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

◆ matrixOut_t

typedef Eigen::Ref<matrix_t> hpp::pinocchio::matrixOut_t

◆ Model

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

◆ ModelConstPtr_t

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

◆ ModelPtr_t

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

◆ ObjectVector_t

typedef ObjectVector hpp::pinocchio::ObjectVector_t

◆ SE3

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

◆ size_type

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

◆ Transform3s

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

◆ value_type

typedef double hpp::pinocchio::value_type

◆ vector3_t

typedef Eigen::Matrix<value_type, 3, 1> hpp::pinocchio::vector3_t

◆ vector4_t

typedef Eigen::Matrix<value_type, 4, 1> hpp::pinocchio::vector4_t

◆ vector_t

typedef Eigen::Matrix<value_type, Eigen::Dynamic, 1> hpp::pinocchio::vector_t

◆ vectorIn_t

typedef Eigen::Ref<const vector_t> hpp::pinocchio::vectorIn_t

◆ vectorOut_t

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

Enumeration Type Documentation

◆ Computation_t

enum hpp::pinocchio::Computation_t

Enumerator
JOINT_POSITION
JACOBIAN
VELOCITY
ACCELERATION
COM
COMPUTE_ALL

◆ InOutType

enum hpp::pinocchio::InOutType

Enumerator
INNER
OUTER

◆ Request_t

enum hpp::pinocchio::Request_t

Enumerator
COLLISION
DISTANCE

Function Documentation

◆ difference() [1/2]

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

Template Parameters

LieGroup is a compile-time map of joint type to Lie group type, that defines the joint-wise operations.

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\); The default template arguments correspond to difference<RnxSOnLieGroupMap>.

◆ difference() [2/2]

void hpp::pinocchio::difference	(	const DevicePtr_t &	robot,
		ConfigurationIn_t	q1,
		ConfigurationIn_t	q2,
		vectorOut_t	result
	)

◆ display()

std::ostream & hpp::pinocchio::display	(	std::ostream &	os,
		const SE3 &	m
	)

Write a SE3 taking into account the indentation.

◆ displayConfig()

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

inline

Write configuration in a string.

◆ distance()

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_PREDEF_CLASS() [1/9]

hpp::pinocchio::HPP_PREDEF_CLASS ( Body )

◆ HPP_PREDEF_CLASS() [2/9]

hpp::pinocchio::HPP_PREDEF_CLASS ( CenterOfMassComputation )

◆ HPP_PREDEF_CLASS() [3/9]

hpp::pinocchio::HPP_PREDEF_CLASS ( CollisionObject )

◆ HPP_PREDEF_CLASS() [4/9]

hpp::pinocchio::HPP_PREDEF_CLASS ( Device )

◆ HPP_PREDEF_CLASS() [5/9]

hpp::pinocchio::HPP_PREDEF_CLASS ( Gripper )

◆ HPP_PREDEF_CLASS() [6/9]

hpp::pinocchio::HPP_PREDEF_CLASS ( HumanoidRobot )

◆ HPP_PREDEF_CLASS() [7/9]

hpp::pinocchio::HPP_PREDEF_CLASS ( Joint )

◆ HPP_PREDEF_CLASS() [8/9]

hpp::pinocchio::HPP_PREDEF_CLASS ( JointConfiguration )

◆ HPP_PREDEF_CLASS() [9/9]

hpp::pinocchio::HPP_PREDEF_CLASS ( LiegroupSpace )

◆ humanoidSimple() [1/2]

DevicePtr_t hpp::pinocchio::humanoidSimple	(	const std::string &	name = `"humanoidSimple"`,
		bool	usingFF = `true`,
		Computation_t	compFlags = `(Computation_t)(JOINT_POSITION\|JACOBIAN)`
	)

◆ humanoidSimple() [2/2]

DevicePtr_t hpp::pinocchio::humanoidSimple	(	const std::string &	name = `"humanoidSimple"`,
		Computation_t	compFlags = `(Computation_t)(JOINT_POSITION\|JACOBIAN)`
	)

◆ integrate() [1/2]

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.

Template Parameters

saturateConfig	when true, calls `hpp::pinocchio::saturate(robot, result)` at the end
LieGroup	is a compile-time map of joint type to Lie group type, that defines the joint-wise operations.

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.

\(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: The default template arguments correspond to integrate<true,DefaultLieGroupMap>.

◆ integrate() [2/2]

void hpp::pinocchio::integrate	(	const DevicePtr_t &	robot,
		ConfigurationIn_t	configuration,
		vectorIn_t	velocity,
		ConfigurationOut_t	result
	)

◆ interpolate() [1/2]

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

Template Parameters

LieGroup is a compile-time map of joint type to Lie group type, that defines the joint-wise operations.

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

Note: The default template arguments correspond to interpolate<RnxSOnLieGroupMap>.

◆ interpolate() [2/2]

void hpp::pinocchio::interpolate	(	const DevicePtr_t &	robot,
		ConfigurationIn_t	q0,
		ConfigurationIn_t	q1,
		const value_type &	u,
		ConfigurationOut_t	result
	)

◆ isApprox()

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

◆ isNormalized()

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.

◆ log()

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.

◆ normalize() [1/2]

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.

◆ normalize() [2/2]

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

inline

For backward compatibility. See normalize normalize (const DevicePtr_t&, Configuration_t&)

◆ operator<<() [1/5]

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

inline

◆ operator<<() [2/5]

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

inline

◆ operator<<() [3/5]

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

inline

◆ operator<<() [4/5]

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

inline

◆ operator<<() [5/5]

template<typename vector_type >

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

inline

◆ replaceGeometryByConvexHull()

void hpp::pinocchio::replaceGeometryByConvexHull	(	GeomModel &	geomModel,
		const std::vector< std::string > &	geometryNames
	)

◆ saturate() [1/2]

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.

◆ saturate() [2/2]

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

◆ ArrayXb

◆ BodyConstPtr_t

◆ BodyPtr_t

◆ CenterOfMassComputationPtr_t

◆ CollisionGeometryPtr_t

◆ CollisionObjectConstPtr_t

◆ CollisionObjectPtr_t

◆ ComJacobian_t

◆ Configuration_t

◆ ConfigurationIn_t

◆ ConfigurationOut_t

◆ Data

◆ DataConstPtr_t

◆ DataPtr_t

◆ DeviceConstPtr_t

◆ DevicePtr_t

◆ DistanceResults_t

◆ FclCollisionObject

◆ FclCollisionObjectPtr_t

◆ FclConstCollisionObjectPtr_t

◆ FrameIndex

◆ GeomData

◆ GeomDataConstPtr_t

◆ GeomDataPtr_t

◆ GeometryObject

◆ GeomIndex

◆ GeomModel

◆ GeomModelConstPtr_t

◆ GeomModelPtr_t

◆ GripperPtr_t

◆ Grippers_t

◆ HalfJointJacobian_t

◆ HPP_PINOCCHIO_DEPRECATED

◆ HumanoidRobotPtr_t

◆ JointCollection

◆ JointConstPtr_t

◆ JointDataVariant

◆ JointIndex

◆ JointJacobian_t

◆ JointModel

◆ JointModelVariant

◆ JointPtr_t

◆ JointVector_t

◆ LiegroupElement

◆ LiegroupElementConstRef

◆ LiegroupElementRef

◆ LiegroupSpaceConstPtr_t

◆ LiegroupSpacePtr_t

◆ matrix3_t

◆ matrix_t

◆ matrixOut_t

◆ Model

◆ ModelConstPtr_t

◆ ModelPtr_t

◆ ObjectVector_t

◆ SE3

◆ size_type

◆ Transform3s

◆ value_type

◆ vector3_t

◆ vector4_t

◆ vector_t

◆ vectorIn_t

◆ vectorOut_t

Enumeration Type Documentation

◆ Computation_t

◆ InOutType

◆ Request_t

Function Documentation

◆ difference() [1/2]

◆ difference() [2/2]

◆ display()

◆ displayConfig()

◆ distance()