source/isaaclab/test/controllers/test_pink_ik_components.py

# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause

"""Test cases for PinkKinematicsConfiguration class."""

# Import pinocchio in the main script to force the use of the dependencies installed
# by IsaacLab and not the one installed by Isaac Sim
# pinocchio is required by the Pink IK controller
import sys

if sys.platform != "win32":
    import pinocchio  # noqa: F401

from isaaclab.app import AppLauncher

# launch omniverse app
simulation_app = AppLauncher(headless=True).app

from pathlib import Path

import numpy as np
import pinocchio as pin
import pytest
from pink.exceptions import FrameNotFound

from isaaclab.controllers.pink_ik.pink_kinematics_configuration import PinkKinematicsConfiguration


class TestPinkKinematicsConfiguration:
    """Test suite for PinkKinematicsConfiguration class."""

    @pytest.fixture
    def urdf_path(self):
        """Path to test URDF file."""
        return Path(__file__).parent / "urdfs/test_urdf_two_link_robot.urdf"

    @pytest.fixture
    def mesh_path(self):
        """Path to mesh directory (empty for simple test)."""
        return ""

    @pytest.fixture
    def controlled_joint_names(self):
        """List of controlled joint names for testing."""
        return ["joint_1", "joint_2"]

    @pytest.fixture
    def pink_config(self, urdf_path, mesh_path, controlled_joint_names):
        """Create a PinkKinematicsConfiguration instance for testing."""
        return PinkKinematicsConfiguration(
            urdf_path=str(urdf_path),
            mesh_path=mesh_path,
            controlled_joint_names=controlled_joint_names,
            copy_data=True,
            forward_kinematics=True,
        )

    def test_initialization(self, pink_config, controlled_joint_names):
        """Test proper initialization of PinkKinematicsConfiguration."""
        # Check that controlled joint names are stored correctly
        assert pink_config._controlled_joint_names == controlled_joint_names

        # Check that both full and controlled models are created
        assert pink_config.full_model is not None
        assert pink_config.controlled_model is not None
        assert pink_config.full_data is not None
        assert pink_config.controlled_data is not None

        # Check that configuration vectors are initialized
        assert pink_config.full_q is not None
        assert pink_config.controlled_q is not None

        # Check that the controlled model has the same number or fewer joints than the full model
        assert pink_config.controlled_model.nq == pink_config.full_model.nq

    def test_joint_names_properties(self, pink_config):
        """Test joint name properties."""
        # Test controlled joint names in pinocchio order
        controlled_names = pink_config.controlled_joint_names_pinocchio_order
        assert isinstance(controlled_names, list)
        assert len(controlled_names) == len(pink_config._controlled_joint_names)
        assert "joint_1" in controlled_names
        assert "joint_2" in controlled_names

        # Test all joint names in pinocchio order
        all_names = pink_config.all_joint_names_pinocchio_order
        assert isinstance(all_names, list)
        assert len(all_names) == len(controlled_names)
        assert "joint_1" in all_names
        assert "joint_2" in all_names

    def test_update_with_valid_configuration(self, pink_config):
        """Test updating configuration with valid joint values."""
        # Get initial configuration
        initial_q = pink_config.full_q.copy()

        # Create a new configuration with different joint values
        new_q = initial_q.copy()
        new_q[1] = 0.5  # Change first revolute joint value (index 1, since 0 is fixed joint)

        # Update configuration
        pink_config.update(new_q)

        # Check that the configuration was updated
        print(pink_config.full_q)
        assert not np.allclose(pink_config.full_q, initial_q)
        assert np.allclose(pink_config.full_q, new_q)

    def test_update_with_none(self, pink_config):
        """Test updating configuration with None (should use current configuration)."""
        # Get initial configuration
        initial_q = pink_config.full_q.copy()

        # Update with None
        pink_config.update(None)

        # Configuration should remain the same
        assert np.allclose(pink_config.full_q, initial_q)

    def test_update_with_wrong_dimensions(self, pink_config):
        """Test that update raises ValueError with wrong configuration dimensions."""
        # Create configuration with wrong number of joints
        wrong_q = np.array([0.1, 0.2, 0.3])  # Wrong number of joints

        with pytest.raises(ValueError, match="q must have the same length as the number of joints"):
            pink_config.update(wrong_q)

    def test_get_frame_jacobian_existing_frame(self, pink_config):
        """Test getting Jacobian for an existing frame."""
        # Get Jacobian for link_1 frame
        jacobian = pink_config.get_frame_jacobian("link_1")

        # Check that Jacobian has correct shape
        # Should be 6 rows (linear + angular velocity) and columns equal to controlled joints
        expected_rows = 6
        expected_cols = len(pink_config._controlled_joint_names)
        assert jacobian.shape == (expected_rows, expected_cols)

        # Check that Jacobian is not all zeros (should have some non-zero values)
        assert not np.allclose(jacobian, 0.0)

    def test_get_frame_jacobian_nonexistent_frame(self, pink_config):
        """Test that get_frame_jacobian raises FrameNotFound for non-existent frame."""
        with pytest.raises(FrameNotFound):
            pink_config.get_frame_jacobian("nonexistent_frame")

    def test_get_transform_frame_to_world_existing_frame(self, pink_config):
        """Test getting transform for an existing frame."""
        # Get transform for link_1 frame
        transform = pink_config.get_transform_frame_to_world("link_1")

        # Check that transform is a pinocchio SE3 object
        assert isinstance(transform, pin.SE3)

        # Check that transform has reasonable values (not identity for non-zero joint angles)
        assert not np.allclose(transform.homogeneous, np.eye(4))

    def test_get_transform_frame_to_world_nonexistent_frame(self, pink_config):
        """Test that get_transform_frame_to_world raises FrameNotFound for non-existent frame."""
        with pytest.raises(FrameNotFound):
            pink_config.get_transform_frame_to_world("nonexistent_frame")

    def test_multiple_controlled_joints(self, urdf_path, mesh_path):
        """Test configuration with multiple controlled joints."""
        # Create configuration with all available joints as controlled
        controlled_joint_names = ["joint_1", "joint_2"]  # Both revolute joints

        pink_config = PinkKinematicsConfiguration(
            urdf_path=str(urdf_path),
            mesh_path=mesh_path,
            controlled_joint_names=controlled_joint_names,
        )

        # Check that controlled model has correct number of joints
        assert pink_config.controlled_model.nq == len(controlled_joint_names)

    def test_no_controlled_joints(self, urdf_path, mesh_path):
        """Test configuration with no controlled joints."""
        controlled_joint_names = []

        pink_config = PinkKinematicsConfiguration(
            urdf_path=str(urdf_path),
            mesh_path=mesh_path,
            controlled_joint_names=controlled_joint_names,
        )

        # Check that controlled model has 0 joints
        assert pink_config.controlled_model.nq == 0
        assert len(pink_config.controlled_q) == 0

    def test_jacobian_consistency(self, pink_config):
        """Test that Jacobian computation is consistent across updates."""
        # Get Jacobian at initial configuration
        jacobian_1 = pink_config.get_frame_jacobian("link_2")

        # Update configuration
        new_q = pink_config.full_q.copy()
        new_q[1] = 0.3  # Change first revolute joint (index 1, since 0 is fixed joint)
        pink_config.update(new_q)

        # Get Jacobian at new configuration
        jacobian_2 = pink_config.get_frame_jacobian("link_2")

        # Jacobians should be different (not all close)
        assert not np.allclose(jacobian_1, jacobian_2)

    def test_transform_consistency(self, pink_config):
        """Test that transform computation is consistent across updates."""
        # Get transform at initial configuration
        transform_1 = pink_config.get_transform_frame_to_world("link_2")

        # Update configuration
        new_q = pink_config.full_q.copy()
        new_q[1] = 0.5  # Change first revolute joint (index 1, since 0 is fixed joint)
        pink_config.update(new_q)

        # Get transform at new configuration
        transform_2 = pink_config.get_transform_frame_to_world("link_2")

        # Transforms should be different
        assert not np.allclose(transform_1.homogeneous, transform_2.homogeneous)

    def test_inheritance_from_configuration(self, pink_config):
        """Test that PinkKinematicsConfiguration properly inherits from Pink Configuration."""
        from pink.configuration import Configuration

        # Check inheritance
        assert isinstance(pink_config, Configuration)

        # Check that we can call parent class methods
        assert hasattr(pink_config, "update")
        assert hasattr(pink_config, "get_transform_frame_to_world")

    def test_controlled_joint_indices_calculation(self, pink_config):
        """Test that controlled joint indices are calculated correctly."""
        # Check that controlled joint indices are valid
        assert len(pink_config._controlled_joint_indices) == len(pink_config._controlled_joint_names)

        # Check that all indices are within bounds
        for idx in pink_config._controlled_joint_indices:
            assert 0 <= idx < len(pink_config._all_joint_names)

        # Check that indices correspond to controlled joint names
        for i, idx in enumerate(pink_config._controlled_joint_indices):
            joint_name = pink_config._all_joint_names[idx]
            assert joint_name in pink_config._controlled_joint_names

    def test_full_model_integrity(self, pink_config):
        """Test that the full model maintains integrity."""
        # Check that full model has all joints
        assert pink_config.full_model.nq > 0
        assert len(pink_config.full_model.names) > 1  # More than just "universe"

    def test_controlled_model_integrity(self, pink_config):
        """Test that the controlled model maintains integrity."""
        # Check that controlled model has correct number of joints
        assert pink_config.controlled_model.nq == len(pink_config._controlled_joint_names)

    def test_configuration_vector_consistency(self, pink_config):
        """Test that configuration vectors are consistent between full and controlled models."""
        # Check that controlled_q is a subset of full_q
        controlled_indices = pink_config._controlled_joint_indices
        for i, idx in enumerate(controlled_indices):
            assert np.isclose(pink_config.controlled_q[i], pink_config.full_q[idx])

    def test_error_handling_invalid_urdf(self, mesh_path, controlled_joint_names):
        """Test error handling with invalid URDF path."""
        with pytest.raises(Exception):  # Should raise some exception for invalid URDF
            PinkKinematicsConfiguration(
                urdf_path="nonexistent.urdf",
                mesh_path=mesh_path,
                controlled_joint_names=controlled_joint_names,
            )

    def test_error_handling_invalid_joint_names(self, urdf_path, mesh_path):
        """Test error handling with invalid joint names."""
        invalid_joint_names = ["nonexistent_joint"]

        # This should not raise an error, but the controlled model should have 0 joints
        pink_config = PinkKinematicsConfiguration(
            urdf_path=str(urdf_path),
            mesh_path=mesh_path,
            controlled_joint_names=invalid_joint_names,
        )

        assert pink_config.controlled_model.nq == 0
        assert len(pink_config.controlled_q) == 0

    def test_undercontrolled_kinematics_model(self, urdf_path, mesh_path):
        """Test that the fixed joint to world is properly handled."""

        test_model = PinkKinematicsConfiguration(
            urdf_path=str(urdf_path),
            mesh_path=mesh_path,
            controlled_joint_names=["joint_1"],
            copy_data=True,
            forward_kinematics=True,
        )
        # Check that the controlled model only includes the revolute joints
        assert "joint_1" in test_model.controlled_joint_names_pinocchio_order
        assert "joint_2" not in test_model.controlled_joint_names_pinocchio_order
        assert len(test_model.controlled_joint_names_pinocchio_order) == 1  # Only the two revolute joints

        # Check that the full configuration has more elements than controlled
        assert len(test_model.full_q) > len(test_model.controlled_q)
        assert len(test_model.full_q) == len(test_model.all_joint_names_pinocchio_order)
        assert len(test_model.controlled_q) == len(test_model.controlled_joint_names_pinocchio_order)