IKPy Documentation

Choosing the right backend depends on your robot complexity and use case:

To use the optional JAX backend, which provides JIT-compiled kinematics and inverse kinematics with analytical Jacobians computed via automatic differentiation, you must install the jax extra via pip.

pip install 'ikpy[jax]'

You can install IKPy via PyPI. Depending on your requirements, you may want to install optional dependencies for plotting or JAX acceleration.

Requirements:

• Python 3.10 or above (for IKPy v4+)
• numpy and scipy (required dependencies)

Installation Commands:

• Standard installation: pip install ikpy
• With plotting support (e.g., matplotlib): pip install 'ikpy[plot]'
• With JAX backend support: pip install 'ikpy[jax]'
• From source: pip install ./ (after downloading/extracting the archive)

All link classes (Link, URDFLink, DHLink, OriginLink) implement get_link_frame_matrix(actuator_parameters) to return the homogeneous transformation matrix for that link.

Behavior by Link Type

• URDFLink:
  • For revolute joints: actuator_parameters is treated as theta (rotation).
  • For prismatic joints: actuator_parameters is treated as mu (translation).
  • For fixed joints: actuator_parameters is ignored.
• DHLink: actuator_parameters is treated as theta (rotation).
• OriginLink: Always returns a $4 \times 4$ identity matrix.

The URDFTree is an experimental utility class used to represent the hierarchical relationship of links in a URDF file.

Each URDFTree instance represents a link and maintains a dictionary called children_links. This dictionary maps the names of child links to their corresponding URDFTree instances, allowing you to traverse the robot's kinematic chain from the root downwards.

Note: This class is marked as experimental and its implementation may change in future versions.

The jax_backend module provides accelerated forward and inverse kinematics using JAX. It leverages JIT compilation and automatic differentiation to speed up computations. To use it, you should utilize the JaxKinematicsCache class, which handles the extraction of chain parameters and the pre-compilation of kinematic functions for a specific robot configuration.

from ikpy.jax_backend import JaxKinematicsCache

# Assuming 'chain' is an existing ikpy.chain.Chain instance
cache = JaxKinematicsCache(chain, precompile=True)

# Compute Forward Kinematics
fk_result = cache.forward_kinematics(joints_array)

# Compute Inverse Kinematics
ik_result = cache.inverse_kinematics(target_frame)

To use inverse kinematics with a Poppy Torso, first initialize the robot using the PoppyTorso class. You can specify a simulator like vrep for safe testing. Once loaded, you can access the individual kinematic chains (e.g., l_arm_chain for the left arm and r_arm_chain for the right arm) and inspect their motors.

from poppy.creatures import PoppyTorso

# Load the robot (using V-REP simulator for safety)
poppy = PoppyTorso(simulator="vrep")

# Access kinematic chains
print(poppy.kinematic_chains)
print(poppy.l_arm_chain)
print(poppy.r_arm_chain)

# List motor names in the left arm chain
print([m.name for m in poppy.l_arm_chain.motors])

To perform hand-following experiments, you must first initialize a PoppyTorso instance using the pypot library and reset the motor positions.

Note: This requires a functioning torso, either physical or in a simulator like V-REP.

import time
import numpy as np
from pypot.creatures import PoppyTorso

# Create the robot
poppy = PoppyTorso()

# Initialize all motor positions to 0
for m in poppy.motors:
    m.goto_position(0, 2)

In a hand-following experiment where one arm follows the other, you must configure the compliance of the motors. For the follower to react to a moving target, the 'leader' arm (e.g., the left arm) should be compliant so it can be moved manually, while the 'follower' arm (e.g., the right arm) and the torso should be active (non-compliant) to maintain precise positioning.

# Left arm is compliant (can be moved manually)
for m in poppy.l_arm:
    m.compliant = True

# Right arm is active (follows targets)
for m in poppy.r_arm:
    m.compliant = False

# The torso must remain stable
for m in poppy.torso:
    m.compliant = False