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... | |
struct | CollisionObject |
Specialization of fcl::CollisionObject to add a name to objects. More... | |
struct | DefaultLieGroupMap |
class | Device |
Robot with geometric and dynamic pinocchio. More... | |
struct | DeviceObjectVector |
Iterator over all inner objects of a Device. More... | |
class | ExtraConfigSpace |
Extra degrees of freedom to store internal values in configurations. More... | |
struct | FakeContainer |
class | Frame |
Robot frame. More... | |
class | Gripper |
Definition of a robot gripper. More... | |
class | HumanoidRobot |
Humanoid robot. More... | |
class | Joint |
Robot joint. More... | |
struct | JointVector |
Fake std::vector<Joint>, used to comply with the actual structure of hpp::model. More... | |
class | LiegroupElementBase |
class | LiegroupNonconstElementBase |
class | LiegroupSpace |
Cartesian product of elementary Lie groups. More... | |
struct | LieGroupTpl |
struct | ObjectVector |
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_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 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... | |
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 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 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 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 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 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 boost::shared_ptr<LiegroupSpace> hpp::pinocchio::LiegroupSpacePtr_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 Eigen::Ref<matrix_t> hpp::pinocchio::matrixOut_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 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 |
void hpp::pinocchio::difference | ( | const DevicePtr_t & | robot, |
ConfigurationIn_t | q1, | ||
ConfigurationIn_t | q2, | ||
vectorOut_t | result | ||
) |
Difference between two configurations as a vector.
robot | robot that describes the kinematic chain |
q1 | first configuration, |
q2 | second configuration, |
result | difference as a vector ![]() ![]() |
std::ostream& hpp::pinocchio::display | ( | std::ostream & | os, |
const se3::SE3 & | m | ||
) |
Write a SE3 taking into account the indentation.
Referenced by displayConfig(), hpp::pinocchio::Frame::robot(), and hpp::pinocchio::Joint::robot().
|
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.
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 , |
||
Device::Computation_t | compFlags = (Device::Computation_t)(Device::JOINT_POSITION|Device::JACOBIAN) |
||
) |
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, se3::LieGroupTpl>
saturateConfig | when true, calls saturate at the end |
robot | robot that describes the kinematic chain |
configuration | initial and result configurations |
velocity | velocity vector |
result | configuration reached after integration. Velocity is dispatched to each joint that integrates according to its Lie group structure, i.e.
|
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.
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 |
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.
robot | robot that describes the kinematic chain |
q1 | first configuration, |
q2 | second configuration, |
eps | 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().
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().
|
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::Frame::display().
|
inline |
|
inline |
References hpp::pinocchio::Joint::display().
|
inline |
References hpp::pinocchio::Device::print().
Referenced by hpp::pinocchio::Gripper::init().
void hpp::pinocchio::saturate | ( | const DevicePtr_t & | robot, |
ConfigurationOut_t | configuration | ||
) |
Saturate joint parameter value so that they are not out of bounds.
robot | robot that describes the kinematic chain | |
[in,out] | configuration | initial and result configurations |
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.
robot | robot that describes the kinematic chain | |
[in,out] | configuration | initial and result configurations |
saturation | an array of boolean saying who saturated (size robot.numberDof()). |