Inverse kinematics (clik)

This example shows how to position the end effector of a manipulator robot to a given pose (position and orientation). The example employs a simple Jacobian-based iterative algorithm, which is called closed-loop inverse kinematics (CLIK).

Python

import numpy as np
import pinocchio
from numpy.linalg import norm, solve

model = pinocchio.buildSampleModelManipulator()
data = model.createData()

JOINT_ID = 6
oMdes = pinocchio.SE3(np.eye(3), np.array([1.0, 0.0, 1.0]))

q = pinocchio.neutral(model)
eps = 1e-4
IT_MAX = 1000
DT = 1e-1
damp = 1e-12

i = 0
while True:
 pinocchio.forwardKinematics(model, data, q)
 iMd = data.oMi[JOINT_ID].actInv(oMdes)
 err = pinocchio.log(iMd).vector # in joint frame
 if norm(err) < eps:
 success = True
 break
 if i >= IT_MAX:
 success = False
 break
 J = pinocchio.computeJointJacobian(model, data, q, JOINT_ID) # in joint frame
 J = -np.dot(pinocchio.Jlog6(iMd.inverse()), J)
 v = -J.T.dot(solve(J.dot(J.T) + damp * np.eye(6), err))
 q = pinocchio.integrate(model, q, v * DT)
 if not i % 10:
 print(f"{i}: error = {err.T}")
 i += 1

if success:
 print("Convergence achieved!")
else:
 print(
 "\n"
 "Warning: the iterative algorithm has not reached convergence "
 "to the desired precision"
 )

print(f"\nresult: {q.flatten().tolist()}")
print(f"\nfinal error: {err.T}")

Explanation of the code

First of all, we import the necessary libraries and we create the Model and Data objects:

import numpy as np
import pinocchio
from numpy.linalg import norm, solve

model = pinocchio.buildSampleModelManipulator()
data = model.createData()

The end effector corresponds to the 6th joint

JOINT_ID = 6

and its desired pose is given as

oMdes = pinocchio.SE3(np.eye(3), np.array([1.0, 0.0, 1.0]))

Next, we define an initial configuration

q = pinocchio.neutral(model)

This is the starting point of the algorithm. A priori, any valid configuration would work. We decided to use the robot's neutral configuration, returned by algorithm neutral. For a simple manipulator such as the one in this case, it simply corresponds to an all-zero vector, but using this method generalizes well to more complex kinds of robots, ensuring validity.

Next, we set some computation-related values

eps = 1e-4
IT_MAX = 1000
DT = 1e-1
damp = 1e-12

corresponding to the desired position precision (we will see later what it exactly means), a maximum number of iterations (to avoid infinite looping in case the position is not reachable), a positive "time step" defining the convergence rate, and a fixed damping factor for the pseudoinversion (see below).

Then, we begin the iterative process. At each iteration, we begin by computing the forward kinematics:

 pinocchio.forwardKinematics(model, data, q)

Next, we compute the error between the desired pose d and the current one i, expressed in the current joint frame i:

 iMd = data.oMi[JOINT_ID].actInv(oMdes)
 err = pinocchio.log(iMd).vector # in joint frame

Here, data.oMi[JOINT_ID] corresponds to the placement of the sixth joint (previously computed by forwardKinematics), dMi corresponds to the transformation between the desired pose and the current one, and err is the error. In order to compute the error, we employed log: this is a Motion object, and it is one way of computing an error in \(SO(3)\) as a six-dimensional vector.

If the error norm is below the previously-defined threshold, we have found the solution and we break out of the loop

 if norm(err) < eps:
 success = True
 break

Notice that, strictly speaking, the norm of a spatial velocity does not make physical sense, since it mixes linear and angular quantities. A more rigorous implementation should treat the linar part and the angular part separately. In this example, however, we choose to slightly abuse the notation in order to keep it simple.

If we have reached the maximum number of iterations, it means a solution has not been found. We take notice of the failure and we also break

 if i >= IT_MAX:
 success = False
 break

Otherwise, we search for another configuration trying to reduce the error.

We start by computing the Jacobian in the joint frame:

 J = pinocchio.computeJointJacobian(model, data, q, JOINT_ID) # in joint frame

To get the proper Jacobian of our task, we should include a call to the Jlog6 function (see e.g. this note for derivation details):

 J = -np.dot(pinocchio.Jlog6(iMd.inverse()), J)

Next, we can compute the evolution of the configuration by solving the inverse kinematics. In order to avoid problems at singularities, we employ the damped pseudo-inverse: \(v = - J^T (J J^T + \lambda I)^{-1} e\) implementing the equation as

 v = -J.T.dot(solve(J.dot(J.T) + damp * np.eye(6), err))

Notice that this way to compute the damped pseudo-inverse was chosen mostly because of its simplicity of implementation. It is not necessarily the best nor the fastest way, and using a fixed damping factor \(\lambda\) is not necessarily the best course of action.

Finally, we can add the obtained tangent vector to the current configuration

 q = pinocchio.integrate(model, q, v * DT)

where integrate in our case amounts to a simple sum. The resulting error will be verified in the next iteration.

At the end of the loop, we display the result:

if success:
 print("Convergence achieved!")
else:
 print(
 "\n"
 "Warning: the iterative algorithm has not reached convergence "
 "to the desired precision"
 )

print(f"\nresult: {q.flatten().tolist()}")
print(f"\nfinal error: {err.T}")

C++

The equivalent C++ implemetation is given below

#include <Eigen/Cholesky>
#include <Eigen/Core>
#include <Eigen/SparseCore>

#include <boost/core/ref.hpp>
#include <boost/fusion/algorithm.hpp>
#include <boost/fusion/functional.hpp>
#include <boost/variant.hpp>

#include <iostream>
#include <vector>

#include "pinocchio/algorithm/check-data.hpp"
#include "pinocchio/algorithm/jacobian.hpp"
#include "pinocchio/algorithm/joint-configuration.hpp"
#include "pinocchio/algorithm/kinematics.hpp"
#include "pinocchio/eigen-common.hpp"
#include "pinocchio/math.hpp"
#include "pinocchio/multibody.hpp"
#include "pinocchio/multibody/joint.hpp"
#include "pinocchio/multibody/sample-models.hpp"
#include "pinocchio/spatial.hpp"
#include "pinocchio/utils/check.hpp"
#include "pinocchio/utils/static-if.hpp"

int main(int /* argc */, char ** /* argv */)
{
 pinocchio::Model model;
 pinocchio::buildModels::manipulator(model);
 pinocchio::Data data(model);

 const int JOINT_ID = 6;
 const pinocchio::SE3 oMdes(Eigen::Matrix3d::Identity(), Eigen::Vector3d(1., 0., 1.));

 Eigen::VectorXd q = pinocchio::neutral(model);
 const double eps = 1e-4;
 const int IT_MAX = 1000;
 const double DT = 1e-1;
 const double damp = 1e-6;

 pinocchio::Data::Matrix6x J(6, model.nv);
 J.setZero();

 bool success = false;
 typedef Eigen::Matrix<double, 6, 1> Vector6d;
 Vector6d err;
 Eigen::VectorXd v(model.nv);
 for (int i = 0;; i++)
 {
 pinocchio::forwardKinematics(model, data, q);
 const pinocchio::SE3 iMd = data.oMi[JOINT_ID].actInv(oMdes);
 err = pinocchio::log6(iMd).toVector(); // in joint frame
 if (err.norm() < eps)
 {
 success = true;
 break;
 }
 if (i >= IT_MAX)
 {
 success = false;
 break;
 }
 pinocchio::computeJointJacobian(model, data, q, JOINT_ID, J); // J in joint frame
 pinocchio::Data::Matrix6 Jlog;
 pinocchio::Jlog6(iMd.inverse(), Jlog);
 J = -Jlog * J;
 pinocchio::Data::Matrix6 JJt;
 JJt.noalias() = J * J.transpose();
 JJt.diagonal().array() += damp;
 v.noalias() = -J.transpose() * JJt.ldlt().solve(err);
 q = pinocchio::integrate(model, q, v * DT);
 if (!(i % 10))
 std::cout << i << ": error = " << err.transpose() << std::endl;
 }

 if (success)
 {
 std::cout << "Convergence achieved!" << std::endl;
 }
 else
 {
 std::cout
 << "\nWarning: the iterative algorithm has not reached convergence to the desired precision"
 << std::endl;
 }

 std::cout << "\nresult: " << q.transpose() << std::endl;
 std::cout << "\nfinal error: " << err.transpose() << std::endl;
}

Explanation of the code

The code follows exactly the same steps as Python. Apart from the usual syntactic discrepancies between Python and C++, we can identify two major differences. The first one concerns the Jacobian computation. In C++, you need to pre-allocate its memory space, set it to zero, and pass it as an input

This allows to always use the same memory space, avoiding re-allocation and achieving greater efficiency.

The second difference consists in the way the velocity is computed

This code is longer than the Python version, but equivalent to it. Notice we explicitly employ the ldlt decomposition.