Introduction

This package implements forward kinematics for a kinematic chain. The kinematic chain is a tree of joints (hpp::model::Joint) that belongs to a robot (hpp::model::Device).

The position of each joint depends on the current configuration of the robot.

A body (hpp::model::Body) can be attached to each joint. Bodies carry

geometric hpp::model::CollisionObject that can collide each other,
mass and inertia.

A hpp::model::HumanoidRobot is a device with accessors to specific joints like

left and right ankles,
left and right wrists,
gaze joint (that moves the cameras),
chest,
waist.

Main classes

Joints

In the following, we denote by $M = (R, \mathbf{T})$ a rigid-body motion with

$R\in SO(3)$ a rotation matrix, and
$\mathbf{T}\in\mathbf{R}^3$ a translation vector. The space of rigid-body motion is denoted by . A point $\mathbf{x}\in\mathbf{R}^3$ is mapped by $(R, \mathbf{T})$ to
$\begin{equation*} \mathbf{y} = R \mathbf{x} + \mathbf{T} \end{equation*}$

Joints are represented by abstract class hpp::model::Joint. A joint is a mapping from an input space (a Lie group or a vector space) to SE(3) the space of rigid-body motion. The mapping is called the joint internal motion.

The types of joints implemented in the package are the following:

hpp::model::JointTranslation <d> where d is the dimension between 1 and 3 that maps a vector of $\mathbf{R}^d$ to the rigid body motion
$\begin{eqnarray*} (I_3, \left(\begin{array}{c}x_1 \\ 0 \\ 0\end{array}\right)) & \mbox{if}& d = 1 \\ (I_3, \left(\begin{array}{c}x_1 \\ x_2 \\ 0\end{array}\right)) & \mbox{if}& d = 2 \\ (I_3, \left(\begin{array}{c}x_1 \\ x_2 \\ x_3\end{array}\right)) & \mbox{if}& d = 3 \\ \end{eqnarray*}$
hpp::model::jointRotation::Bounded that maps a real number $\theta$ to
$\begin{eqnarray*} (\left(\begin{array}{ccc}1 & 0 & 0 \\ 0 & \cos \theta & -\sin \theta \\ 0 & \sin \theta & \cos \theta\end{array}\right), \left(\begin{array}{c}0 \\ 0 \\ 0\end{array}\right)) & \mbox{if}& d = 1 \end{eqnarray*}$
hpp::model::jointRotation::UnBounded that maps an element of to
$\begin{equation*} (\left(\begin{array}{ccc}1 & 0 & 0 \\ 0 & x_1 & -x_2 \\ 0 & x_2 & x_1\end{array}\right), \left(\begin{array}{c}0 \\ 0 \\ 0\end{array}\right))\end{equation*}$
hpp::model::JointAnchor that maps nothing to
$\begin{equation*} (I_3, 0) \end{equation*}$
hpp::model::JointSO3 that maps $\mathbf{x}\in S^3$ (the sphere of unit quaternions) to
$\begin{equation*} (\left(\begin{array}{ccc} 1 - 2(x_3^2 + x_4^2)& 2x_3x_2 - 2x_4x_1& 2x_4x_2 + 2x_3x_1\\ 2x_3x_2 + 2x_4x_1& 1 - 2(x_2^2 + x_4^2)& 2x_4x_3 - 2x_2x_1\\ 2x_4x_2 - 2x_3x_1& 2x_4x_3 + 2x_2x_1& 1 - 2(x_2^2 + 2x_3^2) \end{array}\right),0) \end{equation*}$
where the rotation matrix corresponds to the unit quaternion .
Note:
The number of parameters of each joint configuration is different from the number of degrees of freedom of the joint.
Joints are the nodes of the kinematic chain considered as a tree. Each joint can access to its children and to its parent.

The position of a joint is defined by the following relation

$\begin{equation} P_{joint} = P_{parent} P_{joint/parent} M (\mathbf{x}_{joint}) \end{equation}$

where

$P_{joint} \in SE(3)$ is the position of the joint,
$P_{parent} \in SE(3)$ is the position of the parent joint,
$P_{joint/parent}$ is the position of the joint in the frame of its parent when the joint internal motion is identity,
$\mathbf{x}_{joint}$ is the joint configuration, and
is the joint internal motion as defined previously.

Joint configuration

Abstract class hpp::model::JointConfiguration aims at handling joint configuration and velocities. The main methods are the following:

hpp::model::JointConfiguration::integrate computes the configuration reached from an initial joint configuration after moving at constant joint velocity during unit time,
hpp::model::JointConfiguration::difference compute the constant joint velocity moving the joint from one configuration to the other one,
hpp::model::JointConfiguration::interpolate,
hpp::model::JointConfiguration::distance.

Device

The class device represents either a robot as a kinematic chain, or a free-floating object (hence the name of the class).

The kinematic chain can be accessed via method hpp::model::Device::rootJoint.

Configuration

The joints are stored in a vector (hpp::model::device::getJointVector). The configuration of the robot (commonly denoted by $\mathbf{q}$ is a vector built by concatenation of joint configuration vectors in the order to the joint vector.

Velocity

The velocity of the robot (commonly denoted by $\mathbf{q}$ is represented by a vector built by concatenating joint velocities in the order of the joint vector.

For hpp::model::JointTranslation the velocity of the joint is the time-derivative of the joint configuration as defined in Section Joints.
for hpp::model::JointSO3, the derivative of the joint is represented by the angular velocity vector $\omega\in\mathbf{R}^3$ such that if is the orientation of the joint as defined in Section Joints,
$\begin{equation*} \dot{R} = \left[\omega\right]_{\times} R \end{equation*}$
where $\left[\omega\right]_{\times}$ is the antisymmetric matrix corresponding to the cross product by $\omega$ ,
for hpp::model::jointRotation::UnBounded, the velocity is the angular velocity around x-axis $\alpha\in\mathbf{R}$ such that
$\begin{equation*} \omega = \left(\begin{array}{c}0 \\ 0 \\ \alpha\end{array}\right) \end{equation*}$
for hpp::model::jointRotation::Bounded, the velocity is the angular velocity around x-axis $\dot{\theta}\in\mathbf{R}$ such that
$\begin{equation*} \omega = \left(\begin{array}{c} 0 \\ 0 \\ \dot{\theta}\end{array}\right) \end{equation*}$

`

Note:: Unlike the dimension of the joint configuration, the dimension of the joint velocity is equal to the number of degrees of freedom. For instance configuration of hpp::model::JointSO3 is of dimension 4 for 3 degrees of freedom. Therefore, the dimension of the robot velocity vector can be different from the dimension of the robot configuration vector.

Operations between configurations and velocities

The following operations are defined between configurations and velocities.

hpp::model::integrate Integrates a constant velocity during unit time,
hpp::model::difference returns the constant velocity that moves from one configuration to the other in unit time.