Inverse Kinematics solutions buil on top of pinocchio

[JonathanKuelz]

Hello together,

first of all, thanks a lot for providing this amazing library! I started working with it a month ago and it's a pleasure to work with. Currently, I am looking for a way to solve inverse kinematics faster than I do right now - I am using pinocchio via the python bindings, so my current solution is using scipy's optimize.minimize to solve the inverse kinematics, but I am certain there are better ways to do so.

I have browsed though the issues, but I only learnt that pinocchio intentionally does not contain ik-solvers, but there seem to be libraries / projects that are built on top of pinocchio that do. I checked the stack-of-task repos, but was not succesfull with my search. I was wondering whether anyone could point me to a project implementing inverse kinematics efficiently on top of pinocchio. Thanks a lot in advance!

[proyan]

Have you tried https://github.com/stack-of-tasks/tsid ?

[JonathanKuelz]

Thank you for your quick reply!

I have had a look at it, but to be honest, after fixing a couple of environment/setup issues I had in the beginning, I did not manage to understand how to work with tsid, neither did I find inverse kinematics capabilities. In one of the summer school slides provided in the git, it even says inverse kinematics would be a missing feature, plus, I currently have no interest in calculating inverse dynamics - for now, I just want to solve a lot of reachability problems quickly without any dynamic constraints. If there is an easy way to calculate IK without a big overhead using tsid, I'd be happy to use it - but in the past days, I was not able to find one. Or did I miss something completely?

[florent-lamiraux]

You can also have a look at that file that implements several strategies:
https://github.com/humanoid-path-planner/hpp-constraints/blob/master/include/hpp/constraints/solver/impl/hierarchical-iterative.hh.

[jcarpent]

@JonathanKuelz Could you quickly summarize which kind of IK problems you aim to solve (soft tasks, hard tasks aka constraints, etc.) ?

[JonathanKuelz]

Sure - what I am trying to do is finding a quick answer to the question "can my robot end effector reach poses P1, P2, ..., Pn" to approximate fitness of a robot to a set of grasping tasks.

I am not sure about the distinction of soft vs hard tasks, but if I got you right, it is a soft problem:
As soon as I find a configuration q for which the end effector frame is within a pre-defined error around goal Pose P, this is a solution to my problem. If there is no such configuration q, it additionally would be nice to find the configuration q which leads to the smallest error between goal and actual pose. (For simplification, let's assume I just want to optimize position, so my error function could be |(x, y, z)_eef - (x, y, z)_goal|

At the moment, apart from the joint limits, there are no hard constraints for the task. However, eventually I also want to find a solution that contains a) no self-collision and b) no collision with obstacles in the environment.

I use RRT* to find a path between the configurations if there is a valid configuration q for all poses P in the end.

My priority here is that the ik solver should be fast - I want to use this in a pipeline for evaluating the fitness to a given problem for a large(>10e5) set of different robots - therefore speed is more important than accuracy for now.

[jmirabel]

Without external dependencies:

• Implementing your own solver based on the IK example of Pinocchio should be straightforward.
• To have a very fast solver, sort your point by proximity first and use as initial guess the solution of a nearby point. With such an approach, you should be able to be (possibly far) below 1ms per configuration (in C++, I don't know in Python)
• Handle the collision and the joint limits externally, by rejecting solutions in collision or out of bounds. The solver can eventually handle the joint limit but it will not easily handle collision.

[jmirabel]

And if you don't want to implement your own solution, use an already implemented one. I have used HPP, the framework suggested by @florent-lamiraux, several times for this type of problems and it worked very efficiently.

[JonathanKuelz]

Thanks a lot for your help, I will report on my final solution as soon as I implemented one, in case anyone reads this discussion in the future.