source/isaaclab_mimic/test/test_curobo_planner_cube_stack.py

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

# Copyright (c) 2024-2025, The Isaac Lab Project Developers.
# All rights reserved.
#
# SPDX-License-Identifier: Apache-2.0
from __future__ import annotations

import random
from typing import Any

import pytest

SEED: int = 42
random.seed(SEED)

from isaaclab.app import AppLauncher

headless = True
app_launcher = AppLauncher(headless=headless)
simulation_app: Any = app_launcher.app

from collections.abc import Generator

import gymnasium as gym
import torch

import isaaclab.utils.math as math_utils
from isaaclab.assets import Articulation, RigidObject
from isaaclab.envs.manager_based_env import ManagerBasedEnv
from isaaclab.markers import FRAME_MARKER_CFG, VisualizationMarkers

from isaaclab_mimic.envs.franka_stack_ik_rel_mimic_env_cfg import FrankaCubeStackIKRelMimicEnvCfg
from isaaclab_mimic.motion_planners.curobo.curobo_planner import CuroboPlanner
from isaaclab_mimic.motion_planners.curobo.curobo_planner_cfg import CuroboPlannerCfg

GRIPPER_OPEN_CMD: float = 1.0
GRIPPER_CLOSE_CMD: float = -1.0


def _eef_name(env: ManagerBasedEnv) -> str:
    return list(env.cfg.subtask_configs.keys())[0]


def _action_from_pose(
    env: ManagerBasedEnv, target_pose: torch.Tensor, gripper_binary_action: float, env_id: int = 0
) -> torch.Tensor:
    eef = _eef_name(env)
    play_action = env.target_eef_pose_to_action(
        target_eef_pose_dict={eef: target_pose},
        gripper_action_dict={eef: torch.tensor([gripper_binary_action], device=env.device, dtype=torch.float32)},
        env_id=env_id,
    )
    if play_action.dim() == 1:
        play_action = play_action.unsqueeze(0)
    return play_action


def _env_step_with_action(env: ManagerBasedEnv, action: torch.Tensor) -> None:
    env.step(action)


def _execute_plan(env: ManagerBasedEnv, planner: CuroboPlanner, gripper_binary_action: float, env_id: int = 0) -> None:
    """Execute planner's EEF planned poses using env.step with IK-relative controller actions."""
    planned_poses = planner.get_planned_poses()
    if not planned_poses:
        return
    for pose in planned_poses:
        action = _action_from_pose(env, pose, gripper_binary_action, env_id=env_id)
        _env_step_with_action(env, action)


def _execute_gripper_action(
    env: ManagerBasedEnv, robot: Articulation, gripper_binary_action: float, steps: int = 12, env_id: int = 0
) -> None:
    """Hold current EEF pose and toggle gripper for a few steps."""
    eef = _eef_name(env)
    curr_pose = env.get_robot_eef_pose(eef_name=eef, env_ids=[env_id])[0]
    for _ in range(steps):
        action = _action_from_pose(env, curr_pose, gripper_binary_action, env_id=env_id)
        _env_step_with_action(env, action)


DOWN_FACING_QUAT = torch.tensor([0.0, 1.0, 0.0, 0.0], dtype=torch.float32)


@pytest.fixture(scope="class")
def cube_stack_test_env() -> Generator[dict[str, Any], None, None]:
    """Create the environment and motion planner once for the test suite and yield them."""
    random.seed(SEED)
    torch.manual_seed(SEED)

    env_cfg = FrankaCubeStackIKRelMimicEnvCfg()
    env_cfg.scene.num_envs = 1
    for frame in env_cfg.scene.ee_frame.target_frames:
        if frame.name == "end_effector":
            print(f"Setting end effector offset from {frame.offset.pos} to (0.0, 0.0, 0.0) for SkillGen parity")
            frame.offset.pos = (0.0, 0.0, 0.0)

    env: ManagerBasedEnv = gym.make(
        "Isaac-Stack-Cube-Franka-IK-Rel-Mimic-v0",
        cfg=env_cfg,
        headless=headless,
    ).unwrapped
    env.reset()

    robot: Articulation = env.scene["robot"]
    planner_cfg = CuroboPlannerCfg.franka_stack_cube_config()
    planner_cfg.visualize_plan = False
    planner_cfg.visualize_spheres = False
    planner_cfg.debug_planner = True
    planner_cfg.retreat_distance = 0.05
    planner_cfg.approach_distance = 0.05
    planner_cfg.time_dilation_factor = 1.0

    planner = CuroboPlanner(
        env=env,
        robot=robot,
        config=planner_cfg,
        env_id=0,
    )

    goal_pose_visualizer = None
    if not headless:
        marker_cfg = FRAME_MARKER_CFG.replace(prim_path="/World/Visuals/goal_pose")
        marker_cfg.markers["frame"].scale = (0.1, 0.1, 0.1)
        goal_pose_visualizer = VisualizationMarkers(marker_cfg)

    yield {
        "env": env,
        "robot": robot,
        "planner": planner,
        "goal_pose_visualizer": goal_pose_visualizer,
    }

    env.close()


class TestCubeStackPlanner:
    @pytest.fixture(autouse=True)
    def setup(self, cube_stack_test_env) -> None:
        self.env: ManagerBasedEnv = cube_stack_test_env["env"]
        self.robot: Articulation = cube_stack_test_env["robot"]
        self.planner: CuroboPlanner = cube_stack_test_env["planner"]
        self.goal_pose_visualizer: VisualizationMarkers | None = cube_stack_test_env["goal_pose_visualizer"]

    def _visualize_goal_pose(self, pos: torch.Tensor, quat: torch.Tensor) -> None:
        """Visualize the goal frame markers at pos, quat (xyzw)."""
        if headless or self.goal_pose_visualizer is None:
            return
        self.goal_pose_visualizer.visualize(translations=pos.unsqueeze(0), orientations=quat.unsqueeze(0))

    def _pose_from_xy_quat(self, xy: torch.Tensor, z: float, quat: torch.Tensor) -> torch.Tensor:
        """Build a 4×4 pose given xy (Tensor[2]), z, and quaternion."""
        device = xy.device
        dtype = xy.dtype
        pos = torch.cat([xy, torch.tensor([z], dtype=dtype, device=device)])
        rot = math_utils.matrix_from_quat(quat.to(device).unsqueeze(0))[0]
        return math_utils.make_pose(pos, rot)

    def _get_cube_pos(self, cube_name: str) -> torch.Tensor:
        """Return the current world position of a cube's root (x, y, z)."""
        obj: RigidObject = self.env.scene[cube_name]
        return obj.data.root_pos_w[0, :3].clone().detach()

    def _place_pose_over_cube(self, cube_name: str, height_offset: float) -> torch.Tensor:
        """Compute a goal pose directly above the named cube using the latest pose."""
        base_pos = self._get_cube_pos(cube_name)
        return self._pose_from_xy_quat(base_pos[:2], base_pos[2].item() + height_offset, DOWN_FACING_QUAT)

    def test_pick_and_stack(self) -> None:
        """Plan and execute pick-and-place to stack cube_1 on cube_2, then cube_3 on the stack."""
        cube_1_pos = self._get_cube_pos("cube_1")
        cube_2_pos = self._get_cube_pos("cube_2")
        cube_3_pos = self._get_cube_pos("cube_3")
        print(f"Cube 1 position: {cube_1_pos}")
        print(f"Cube 2 position: {cube_2_pos}")
        print(f"Cube 3 position: {cube_3_pos}")

        # Approach above cube_1
        pre_grasp_height = 0.1
        pre_grasp_pose = self._pose_from_xy_quat(cube_1_pos[:2], pre_grasp_height, DOWN_FACING_QUAT)
        print(f"Pre-grasp pose: {pre_grasp_pose}")
        if not headless:
            pos_pg = pre_grasp_pose[:3, 3].detach().cpu()
            quat_pg = math_utils.quat_from_matrix(pre_grasp_pose[:3, :3].unsqueeze(0))[0].detach().cpu()
            self._visualize_goal_pose(pos_pg, quat_pg)

        # Plan to pre-grasp
        assert self.planner.update_world_and_plan_motion(pre_grasp_pose), "Failed to plan to pre-grasp pose"
        _execute_plan(self.env, self.planner, gripper_binary_action=GRIPPER_OPEN_CMD)

        # Close gripper to grasp cube_1 (hold pose while closing)
        _execute_gripper_action(self.env, self.robot, GRIPPER_CLOSE_CMD, steps=16)

        # Plan placement with cube_1 attached (above latest cube_2)
        place_pose = self._place_pose_over_cube("cube_2", 0.15)

        if not headless:
            pos_place = place_pose[:3, 3].detach().cpu()
            quat_place = math_utils.quat_from_matrix(place_pose[:3, :3].unsqueeze(0))[0].detach().cpu()
            self._visualize_goal_pose(pos_place, quat_place)

        # Plan with attached object
        assert self.planner.update_world_and_plan_motion(place_pose, expected_attached_object="cube_1"), (
            "Failed to plan placement trajectory with attached cube"
        )
        _execute_plan(self.env, self.planner, gripper_binary_action=GRIPPER_CLOSE_CMD)

        # Release cube 1
        _execute_gripper_action(self.env, self.robot, GRIPPER_OPEN_CMD, steps=16)

        # Go to cube 3
        cube_3_pos_now = self._get_cube_pos("cube_3")
        pre_grasp_pose = self._pose_from_xy_quat(cube_3_pos_now[:2], pre_grasp_height, DOWN_FACING_QUAT)
        print(f"Pre-grasp pose: {pre_grasp_pose}")
        if not headless:
            pos_pg = pre_grasp_pose[:3, 3].detach().cpu()
            quat_pg = math_utils.quat_from_matrix(pre_grasp_pose[:3, :3].unsqueeze(0))[0].detach().cpu()
            self._visualize_goal_pose(pos_pg, quat_pg)

        assert self.planner.update_world_and_plan_motion(pre_grasp_pose, expected_attached_object=None), (
            "Failed to plan retract motion"
        )
        _execute_plan(self.env, self.planner, gripper_binary_action=GRIPPER_OPEN_CMD)

        # Grasp cube 3
        _execute_gripper_action(self.env, self.robot, GRIPPER_CLOSE_CMD)

        # Plan placement with cube_3 attached, to cube 2 (use latest cube_2 pose)
        place_pose = self._place_pose_over_cube("cube_2", 0.18)

        if not headless:
            pos_place = place_pose[:3, 3].detach().cpu()
            quat_place = math_utils.quat_from_matrix(place_pose[:3, :3].unsqueeze(0))[0].detach().cpu()
            self._visualize_goal_pose(pos_place, quat_place)

        assert self.planner.update_world_and_plan_motion(place_pose, expected_attached_object="cube_3"), (
            "Failed to plan placement trajectory with attached cube"
        )
        _execute_plan(self.env, self.planner, gripper_binary_action=GRIPPER_CLOSE_CMD)

        # Release cube 3
        _execute_gripper_action(self.env, self.robot, GRIPPER_OPEN_CMD)

        print("Pick-and-place stacking test completed successfully!")