IK_LM - Levemberg-Marquadt Numerical IK

class roboticstoolbox.robot.IK.IK_LM(name='IK Solver', ilimit=30, slimit=100, tol=1e-06, mask=None, joint_limits=True, seed=None, k=1.0, method='chan', kq=0.0, km=0.0, ps=0.0, pi=0.3, **kwargs)[source]

Bases: IKSolver

Levemberg-Marquadt Numerical Inverse Kinematics Solver

A class which provides functionality to perform numerical inverse kinematics (IK) using the Levemberg-Marquadt method. See step method for mathematical description.

Parameters:

name (str) – The name of the IK algorithm
ilimit (int) – How many iterations are allowed within a search before a new search is started
slimit (int) – How many searches are allowed before being deemed unsuccessful
tol (float) – Maximum allowed residual error E, where \(E = \tfrac{1}{2} \vec{e}^\top \mat{W}_e \vec{e}\) is a quadratic form in the 6-vector angle-axis pose error \(\vec{e}\) (see error()). Because E is quadratic, tol does not bound the linear-scale position/ orientation error directly — with the default unit weighting, components of \(\vec{e}\) are only guaranteed to be within roughly \(\sqrt{2 \cdot \text{tol}}\) (e.g. tol=1e-6 guarantees pose error on the order of 1e-3, not 1e-6). Pick tol accordingly if you need a specific linear-scale accuracy
mask (Union[ndarray, List[float], Tuple[float, ...], None]) – A 6 vector which assigns weights to Cartesian degrees-of-freedom error priority
joint_limits (bool) – Reject solutions with joint limit violations
seed (int | None) – A seed for the private RNG used to generate random joint coordinate vectors
k (float) – Sets the gain value for the damping matrix Wn in the step method. See notes
method – One of “chan”, “sugihara” or “wampler”. Defines which method is used to calculate the damping matrix Wn in the step method
kq (float) – The gain for joint limit avoidance. Setting to 0.0 will remove this completely from the solution
km (float) – The gain for maximisation. Setting to 0.0 will remove this completely from the solution
ps (float) – The minimum angle/distance (in radians or metres) in which the joint is allowed to approach to its limit
pi (ndarray | float) – The influence angle/distance (in radians or metres) in null space motion becomes active

Example:

The following example gets the ``ets`` of a ``panda`` robot object, instantiates
the IK_LM solver class using default parameters, makes a goal pose ``Tep``,
and then solves for the joint coordinates which result in the pose ``Tep``
using the `solve` method.

>>> import roboticstoolbox as rtb
>>> panda = rtb.models.Panda().ets()
>>> solver = rtb.IK_LM()
>>> Tep = panda.fkine([0, -0.3, 0, -2.2, 0, 2, 0.7854])
>>> solver.solve(panda, Tep)
IKSolution(q=array([ 1.2824, -0.6955, -1.0205, -2.1602, -0.6325,  1.8081,  1.278 ]), success=True, iterations=9, searches=1, residual=2.1476405468479918e-07, reason='Success')

Notes

The value for the k kwarg will depend on the method chosen and the arm you are using. Use the following as a rough guide chan, k = 1.0 - 0.01, wampler, k = 0.01 - 0.0001, and sugihara, k = 0.1 - 0.0001

When using the this method, the initial joint coordinates \(q_0\), should correspond to a non-singular manipulator pose, since it uses the manipulator Jacobian.

This class supports null-space motion to assist with maximising manipulability and avoiding joint limits. These are enabled by setting kq and km to non-zero values.

References

J. Haviland, and P. Corke. “Manipulator Differential Kinematics Part I: Kinematics, Velocity, and Applications.” arXiv preprint arXiv:2207.01796 (2022).
J. Haviland, and P. Corke. “Manipulator Differential Kinematics Part II: Acceleration and Advanced Applications.” arXiv preprint arXiv:2207.01794 (2022).

`step`(ets, Tep, q)	Performs a single iteration of the Levenberg-Marquadt optimisation
`solve`(ets, Tep[, q0])	Solves the IK problem
`error`(Te, Tep)	Calculates the error between Te and Tep

`_random_q`(ets[, i])	Generate a random valid joint configuration using a private RNG
`_check_jl`(ets, q)	Checks if the joints are within their respective limits