robosuite/examples/third_party_controller/mink_controller.py

import os
import pathlib
import sys
from contextlib import contextmanager
from typing import Dict, List, Literal, Optional, Tuple

import mink
import mujoco
import mujoco.viewer
import numpy as np
from mink.configuration import Configuration
from mink.tasks.exceptions import TargetNotSet
from mink.tasks.frame_task import FrameTask

import robosuite.utils.transform_utils as T
from robosuite.controllers.composite.composite_controller import WholeBody, register_composite_controller
from robosuite.models.grippers.gripper_model import GripperModel
from robosuite.models.robots.robot_model import RobotModel
from robosuite.utils.binding_utils import MjSim
from robosuite.utils.log_utils import ROBOSUITE_DEFAULT_LOGGER


def update(self, q: Optional[np.ndarray] = None, update_idxs: Optional[np.ndarray] = None) -> None:
    """Run forward kinematics.
    Args:
        q: Optional configuration vector to override internal `data.qpos` with.
    """
    if q is not None:
        if update_idxs is not None:
            self.data.qpos[update_idxs] = q
        else:
            self.data.qpos = q
    # The minimal function call required to get updated frame transforms is
    # mj_kinematics. An extra call to mj_comPos is required for updated Jacobians.
    mujoco.mj_kinematics(self.model, self.data)
    mujoco.mj_comPos(self.model, self.data)


Configuration.update = update


def compute_translation_error(self, configuration: Configuration) -> np.ndarray:
    r"""Compute the translation part of the frame task error.
    Args:
        configuration: Robot configuration :math:`q`.
    Returns:
        Frame task translation error vector :math:`e_p(q)`.
    """
    if self.transform_target_to_world is None:
        raise TargetNotSet(self.__class__.__name__)

    transform_frame_to_world = configuration.get_transform_frame_to_world(self.frame_name, self.frame_type)
    return np.linalg.norm(self.transform_target_to_world.translation() - transform_frame_to_world.translation())


def compute_orientation_error(self, configuration: Configuration) -> np.ndarray:
    r"""Compute the orientation part of the frame task error.
    Args:
        configuration: Robot configuration :math:`q`.
    Returns:
        Frame task orientation error vector :math:`e_o(q)`.
    """
    if self.transform_target_to_world is None:
        raise TargetNotSet(self.__class__.__name__)

    transform_frame_to_world = configuration.get_transform_frame_to_world(self.frame_name, self.frame_type)

    rot_src = self.transform_target_to_world.rotation().as_matrix()
    rot_tgt = transform_frame_to_world.rotation().as_matrix()
    angle_diff = np.arccos(np.clip((np.trace(rot_src @ rot_tgt.T) - 1) / 2, -1, 1))
    angle_diff = angle_diff * 180 / np.pi
    return angle_diff


@contextmanager
def suppress_stdout():
    """
    helper function to supress logging info from mink controller
    """
    with open(os.devnull, "w") as devnull:
        old_stdout = sys.stdout
        sys.stdout = devnull
        try:
            yield
        finally:
            sys.stdout = old_stdout


# monkey patch the FrameTask class for computing debugging errors
FrameTask.compute_translation_error = compute_translation_error
FrameTask.compute_orientation_error = compute_orientation_error


class WeightedPostureTask(mink.PostureTask):
    def __init__(
        self, model: mujoco.MjModel, cost: float, weights: np.ndarray, lm_damping: float = 0.0, gain: float = 1.0
    ) -> None:
        r"""Create weighted posture task.
        Args:
            cost: value used to cast joint angle differences to a homogeneous
                cost, in :math:`[\mathrm{cost}] / [\mathrm{rad}]`.
            weights: vector of weights for each joint.
            lm_damping: Unitless scale of the Levenberg-Marquardt (only when
                the error is large) regularization term, which helps when
                targets are unfeasible. Increase this value if the task is too
                jerky under unfeasible targets, but beware that too large a
                damping can slow down the task.
            gain: Task gain :math:`\alpha \in [0, 1]` for additional low-pass
                filtering. Defaults to 1.0 (no filtering) for dead-beat
                control.
        """
        super().__init__(model=model, cost=cost, lm_damping=lm_damping, gain=gain)
        self.weights = weights

    def compute_error(self, configuration):
        error = super().compute_error(configuration)
        return self.weights * error

    def compute_jacobian(self, configuration):
        J = super().compute_jacobian(configuration)
        # breakpoint()
        return self.weights[:, np.newaxis] * J

    def __repr__(self):
        """Human-readable representation of the weighted posture task."""
        return (
            "WeightedPostureTask("
            f"cost={self.cost}, "
            f"weights={self.weights}, "
            f"gain={self.gain}, "
            f"lm_damping={self.lm_damping})"
        )


class IKSolverMink:
    def __init__(
        self,
        model: mujoco.MjModel,
        data: mujoco.MjData,
        site_names: List[str],
        robot_model: mujoco.MjModel,
        robot_joint_names: Optional[List[str]] = None,
        verbose: bool = False,
        input_type: Literal["absolute", "delta", "delta_pose"] = "absolute",
        input_ref_frame: Literal["world", "base", "eef"] = "world",
        input_rotation_repr: Literal["quat_wxyz", "axis_angle"] = "axis_angle",
        posture_weights: Dict[str, float] = None,
        solve_freq: float = 20.0,
        hand_pos_cost: float = 1,
        hand_ori_cost: float = 0.5,
        com_cost: float = 0.0,
        use_mink_posture_task: bool = False,
        initial_qpos_as_posture_target: bool = False,
    ):
        self.full_model: mujoco.MjModel = model
        self.full_model_data: mujoco.MjData = data

        self.robot_model = robot_model
        self.configuration = mink.Configuration(self.robot_model)
        self.posture_weights = posture_weights
        self.hand_pos_cost = hand_pos_cost
        self.hand_ori_cost = hand_ori_cost
        self.com_cost = com_cost
        self.use_mink_posture_task = use_mink_posture_task
        self.hand_tasks: List[mink.FrameTask]
        self.posture_task: WeightedPostureTask
        self.com_task: mink.ComTask | None = None

        if robot_joint_names is None:
            robot_joint_names: List[str] = [
                self.robot_model.joint(i).name
                for i in range(self.robot_model.njnt)
                if self.robot_model.joint(i).type != 0
            ]  # Exclude fixed joints

        # the order of the index is the same of model.qposadr
        self.all_robot_qpos_indexes_in_full_model: List[int] = []
        for i in range(self.robot_model.njnt):
            joint_name = self.robot_model.joint(i).name
            self.all_robot_qpos_indexes_in_full_model.extend(
                self.full_model.joint(joint_name).qposadr[0] + np.arange(len(self.full_model.joint(joint_name).qpos0))
            )
        assert len(self.all_robot_qpos_indexes_in_full_model) == self.robot_model.nq

        # the order of the index is determined by the order of the actuation_part_names
        self.controlled_robot_qpos_indexes: List[int] = []
        self.controlled_robot_qpos_indexes_in_full_model: List[int] = []
        for name in robot_joint_names:
            self.controlled_robot_qpos_indexes.extend(
                self.robot_model.joint(name).qposadr[0] + np.arange(len(self.robot_model.joint(name).qpos0))
            )
            self.controlled_robot_qpos_indexes_in_full_model.extend(
                self.full_model.joint(name).qposadr[0] + np.arange(len(self.full_model.joint(name).qpos0))
            )

        self.site_ids = [self.robot_model.site(site_name).id for site_name in site_names]
        self.site_names = site_names

        # update robot states
        self.update_robot_states()

        # setup tasks
        self._setup_tasks()
        if initial_qpos_as_posture_target:
            self.set_posture_target()
        else:
            self.set_posture_target(np.zeros(self.robot_model.nq))
        if self.com_cost > 0.0:
            self.set_com_target()

        self.solver = "quadprog"

        self.solve_freq = solve_freq

        self.input_type = input_type
        self.input_ref_frame = input_ref_frame
        self.input_rotation_repr = input_rotation_repr
        ROTATION_REPRESENTATION_DIMS: Dict[str, int] = {"quat_wxyz": 4, "axis_angle": 3}
        self.rot_dim = ROTATION_REPRESENTATION_DIMS[input_rotation_repr]
        self.pos_dim = 3
        self.control_dim = len(self.site_names) * (self.pos_dim + self.rot_dim)
        # hardcoded control limits for now
        self.control_limits = np.array([-np.inf] * self.control_dim), np.array([np.inf] * self.control_dim)

        self.i = 0
        self.verbose = verbose
        if verbose:
            self.task_errors: List[np.ndarray] = []
            self.trask_translation_errors: List[np.ndarray] = []
            self.task_orientation_errors: List[np.ndarray] = []

    def __repr__(self) -> str:
        return "IKSolverMink"

    def _setup_tasks(self):
        weights = np.ones(self.robot_model.nv)

        for joint_name, posture_weight in self.posture_weights.items():
            joint = self.robot_model.joint(joint_name)
            joint_dof_idx = joint.dofadr[0] + np.arange(len(joint.jntid))
            weights[joint_dof_idx] = posture_weight

        if self.use_mink_posture_task:
            self.posture_task = mink.PostureTask(self.robot_model, cost=weights * 0.1, lm_damping=1.0)
        else:
            self.posture_task = WeightedPostureTask(self.robot_model, cost=0.01, weights=weights, lm_damping=2)

        self.tasks = [self.posture_task]

        self.hand_tasks = self._create_frame_tasks(
            self.site_names, position_cost=self.hand_pos_cost, orientation_cost=self.hand_ori_cost
        )
        self.tasks.extend(self.hand_tasks)

        if self.com_cost > 0.0:
            self.com_task = mink.ComTask(cost=self.com_cost)
            self.tasks.append(self.com_task)

    def _create_frame_tasks(self, frame_names: List[str], position_cost: float, orientation_cost: float):
        return [
            mink.FrameTask(
                frame_name=frame,
                frame_type="site",
                position_cost=position_cost,
                orientation_cost=orientation_cost,
                lm_damping=1.0,
            )
            for frame in frame_names
        ]

    def update_robot_states(self):
        # update the base pose, important for mobile robots such as humanoids
        self.configuration.model.body("robot0_base").pos = self.full_model.body("robot0_base").pos
        self.configuration.model.body("robot0_base").quat = self.full_model.body("robot0_base").quat

        # update the qpos for the robot model
        self.configuration.update(
            self.full_model_data.qpos[self.controlled_robot_qpos_indexes_in_full_model],
            self.controlled_robot_qpos_indexes,
        )

    def set_target_poses(self, target_poses: List[np.ndarray]):
        for task, target in zip(self.hand_tasks, target_poses):
            se3_target = mink.SE3.from_matrix(target)
            task.set_target(se3_target)

    def set_posture_target(self, posture_target: np.ndarray | None = None):
        if posture_target is None:
            self.posture_task.set_target_from_configuration(self.configuration)
        else:
            self.posture_task.set_target(posture_target)

    def set_com_target(self, com_target: np.ndarray | None = None):
        assert self.com_task is not None, "COM task is not initialized"
        if com_target is None:
            com_target = self.configuration.data.subtree_com[1]
        self.com_task.set_target(com_target)

    def action_split_indexes(self) -> Dict[str, Tuple[int, int]]:
        action_split_indexes: Dict[str, Tuple[int, int]] = {}
        previous_idx = 0

        for site_name in self.site_names:
            total_dim = self.pos_dim + self.rot_dim
            last_idx = previous_idx + total_dim
            simplified_site_name = "left" if "left" in site_name else "right"  # hack to simplify site names
            # goal is to specify the end effector actions as "left" or "right" instead of the actual site name
            # we assume that the site names for the ik solver are unique and contain "left" or "right" in them
            action_split_indexes[simplified_site_name] = (previous_idx, last_idx)
            previous_idx = last_idx

        return action_split_indexes

    def transform_pose(
        self, src_frame_pose: np.ndarray, src_frame: Literal["world", "base"], dst_frame: Literal["world", "base"]
    ) -> np.ndarray:
        """
        Transforms src_frame_pose from src_frame to dst_frame.
        """
        if src_frame == dst_frame:
            return src_frame_pose

        self.robot_model.body("robot0_base").pos = self.full_model.body("robot0_base").pos
        self.robot_model.body("robot0_base").quat = self.full_model.body("robot0_base").quat

        X_src_frame_pose = src_frame_pose
        # convert src frame pose to world frame pose
        if src_frame != "world":
            X_W_src_frame = self.configuration.get_transform_frame_to_world(src_frame, "body").as_matrix()
            X_W_pose = X_W_src_frame @ X_src_frame_pose
        else:
            X_W_pose = src_frame_pose

        # now convert to destination frame
        if dst_frame == "world":
            X_dst_frame_pose = X_W_pose
        elif dst_frame == "base":
            X_dst_frame_W = np.linalg.inv(
                self.configuration.get_transform_frame_to_world("robot0_base", "body").as_matrix()
            )  # hardcode name of base
            X_dst_frame_pose = X_dst_frame_W.dot(X_W_pose)

        return X_dst_frame_pose

    def solve(self, input_action: np.ndarray) -> np.ndarray:
        """
        Solve for the joint angles that achieve the desired target action.

        We assume input_action is specified as self.input_type, self.input_ref_frame, self.input_rotation_repr.
        We also assume input_action has the following format: [site1_pos, site1_rot, site2_pos, site2_rot, ...].

        By updating configuration's bose to match the actual base pose (in 'world' frame),
        we're requiring our tasks' targets to be in the 'world' frame for mink.solve_ik().
        """

        self.update_robot_states()

        input_action = input_action.reshape(len(self.site_names), -1)
        input_pos = input_action[:, : self.pos_dim]
        input_ori = input_action[:, self.pos_dim :]

        input_quat_wxyz = None
        if self.input_rotation_repr == "axis_angle":
            input_quat_wxyz = np.array([np.roll(T.axisangle2quat(input_ori[i]), 1) for i in range(len(input_ori))])
        elif self.input_rotation_repr == "mat":
            input_quat_wxyz = np.array([np.roll(T.mat2quat(input_ori[i])) for i in range(len(input_ori))])
        elif self.input_rotation_repr == "quat_wxyz":
            input_quat_wxyz = input_ori

        if self.input_ref_frame == "base":
            base_pos = self.configuration.data.body("robot0_base").xpos
            base_ori = self.configuration.data.body("robot0_base").xmat.reshape(3, 3)

            if self.input_type == "absolute":
                # For absolute poses, transform both position and orientation from base to world frame
                base_pose = T.make_pose(base_pos, base_ori)

                # Transform each input pose to world frame
                input_poses = []
                for pos, quat in zip(input_pos, input_quat_wxyz):
                    pose_in_base = T.make_pose(pos, T.quat2mat(np.roll(quat, -1)))
                    world_pose = base_pose @ pose_in_base
                    input_poses.append(world_pose)

                input_poses = np.array(input_poses)
                input_pos = input_poses[:, :3, 3]
                input_quat_wxyz = np.array([np.roll(T.mat2quat(pose[:3, :3]), 1) for pose in input_poses])

            elif self.input_type == "delta":
                # For deltas, only rotate the vectors from base to world frame
                input_pos = np.array([base_ori @ pos for pos in input_pos])

                # Transform rotation deltas using rotation matrices
                input_quat_wxyz = np.array(
                    [np.roll(T.mat2quat(base_ori @ T.quat2mat(np.roll(quat, -1))), 1) for quat in input_quat_wxyz]
                )
        elif self.input_ref_frame == "eef":
            raise NotImplementedError("Input reference frame 'eef' not yet implemented")

        if "delta" in self.input_type:
            cur_pos = np.array([self.configuration.data.site(site_id).xpos for site_id in self.site_ids])
            cur_ori = np.array([self.configuration.data.site(site_id).xmat for site_id in self.site_ids])
        if self.input_type == "delta":
            # decoupled pos and rotation deltas
            target_pos = input_pos + cur_pos
            target_quat_xyzw = np.array(
                [
                    T.quat_multiply(np.roll(input_quat_wxyz[i], -1), T.mat2quat(cur_ori[i].reshape(3, 3)))
                    for i in range(len(self.site_ids))
                ]
            )
            target_quat_wxyz = np.array([np.roll(target_quat_xyzw[i], shift=1) for i in range(len(self.site_ids))])
        elif self.input_type == "delta_pose":
            cur_poses = np.zeros((len(self.site_ids), 4, 4))
            for i in range(len(self.site_ids)):
                cur_poses[i] = T.make_pose(cur_pos[i], cur_ori[i])

            # Convert target action to target pose
            delta_poses = np.zeros_like(cur_poses)
            for i in range(len(self.site_ids)):
                delta_poses[i] = T.make_pose(input_pos[i], T.quat2mat(np.roll(input_quat_wxyz[i], -1)))

            # Apply target pose to current pose
            target_poses = np.array([np.dot(cur_poses[i], delta_poses[i]) for i in range(len(self.site_ids))])

            # Split new target pose back into position and quaternion
            target_pos = target_poses[:, :3, 3]
            target_quat_wxyz = np.array(
                [np.roll(T.mat2quat(target_poses[i, :3, :3]), shift=1) for i in range(len(self.site_ids))]
            )
        elif self.input_type == "absolute":
            target_pos = input_pos
            target_quat_wxyz = input_quat_wxyz
        else:
            raise ValueError(f"Invalid input type: {self.input_type}")

        # create targets list shape is n_sites, 4, 4
        targets = [np.eye(4) for _ in range(len(self.site_names))]
        for i, (pos, quat_wxyz) in enumerate(zip(target_pos, target_quat_wxyz)):
            targets[i][:3, 3] = pos
            targets[i][:3, :3] = T.quat2mat(np.roll(quat_wxyz, -1))

        # set target poses
        for task, target in zip(self.hand_tasks, targets):
            with suppress_stdout():
                se3_target = mink.SE3.from_matrix(target)
            task.set_target(se3_target)

        with suppress_stdout():
            vel = mink.solve_ik(self.configuration, self.tasks, 1 / self.solve_freq, self.solver, 1e-5)
        self.configuration.integrate_inplace(vel, 1 / self.solve_freq)

        self.i += 1
        if self.verbose:
            task_errors = self._get_task_errors()
            task_translation_errors = self._get_task_translation_errors()
            task_orientation_errors = self._get_task_orientation_errors()
            self.task_errors.append(task_errors)
            self.trask_translation_errors.append(task_translation_errors)
            self.task_orientation_errors.append(task_orientation_errors)

            if self.i % 50:
                print(f"Task errors: {task_translation_errors}")

        return self.configuration.data.qpos[self.controlled_robot_qpos_indexes]

    def _get_task_translation_errors(self) -> List[float]:
        errors = []
        for task in self.hand_tasks:
            error = task.compute_translation_error(self.configuration)
            errors.append(error)
        return errors

    def _get_task_orientation_errors(self) -> List[float]:
        errors = []
        for task in self.hand_tasks:
            error = task.compute_orientation_error(self.configuration)
            errors.append(error)
        return errors

    def _get_task_errors(self) -> List[float]:
        errors = []
        for task in self.hand_tasks:
            error = task.compute_error(self.configuration)
            errors.append(np.linalg.norm(error[:3]))
        errors.append(self.posture_task.compute_error(self.configuration))
        return errors


@register_composite_controller
class WholeBodyMinkIK(WholeBody):
    name = "WHOLE_BODY_MINK_IK"

    def __init__(self, sim: MjSim, robot_model: RobotModel, grippers: Dict[str, GripperModel]):
        super().__init__(sim, robot_model, grippers)

    def _validate_composite_controller_specific_config(self) -> None:
        # Check that all actuation_part_names exist in part_controllers
        original_ik_controlled_parts = self.composite_controller_specific_config["actuation_part_names"]
        self.valid_ik_controlled_parts = []
        valid_ref_names = []

        assert (
            "ref_name" in self.composite_controller_specific_config
        ), "The 'ref_name' key is missing from composite_controller_specific_config."

        for part in original_ik_controlled_parts:
            if part in self.part_controllers:
                self.valid_ik_controlled_parts.append(part)
            else:
                ROBOSUITE_DEFAULT_LOGGER.warning(
                    f"Part '{part}' specified in 'actuation_part_names' "
                    "does not exist in part_controllers. Removing ..."
                )

        # Update the configuration with only the valid parts
        self.composite_controller_specific_config["actuation_part_names"] = self.valid_ik_controlled_parts

        # Loop through ref_names and validate against mujoco model
        original_ref_names = self.composite_controller_specific_config.get("ref_name", [])
        for ref_name in original_ref_names:
            if ref_name in self.sim.model.site_names:  # Check if the site exists in the mujoco model
                valid_ref_names.append(ref_name)
            else:
                ROBOSUITE_DEFAULT_LOGGER.warning(
                    f"Reference name '{ref_name}' specified in configuration"
                    " does not exist in the mujoco model. Removing ..."
                )

        # Update the configuration with only the valid reference names
        self.composite_controller_specific_config["ref_name"] = valid_ref_names

        # Check all the ik posture weights exist in the robot model
        ik_posture_weights = self.composite_controller_specific_config.get("ik_posture_weights", {})
        valid_posture_weights = {}
        for weight_name in ik_posture_weights:
            if weight_name in self.robot_model.joints:
                valid_posture_weights[weight_name] = ik_posture_weights[weight_name]
            else:
                ROBOSUITE_DEFAULT_LOGGER.warning(
                    f"Ik posture weight '{weight_name}' does not exist in the robot model. Removing ..."
                )

        # Update the configuration with only the valid posture weights
        self.composite_controller_specific_config["ik_posture_weights"] = valid_posture_weights

    def _init_joint_action_policy(self):
        joint_names: str = []
        for part_name in self.composite_controller_specific_config["actuation_part_names"]:
            if part_name in self.part_controllers:
                joint_names += self.part_controllers[part_name].joint_names

        default_site_names: List[str] = []
        for arm in ["right", "left"]:
            if arm in self.part_controller_config:
                default_site_names.append(self.part_controller_config[arm]["ref_name"])

        self.joint_action_policy = IKSolverMink(
            model=self.sim.model._model,
            data=self.sim.data._data,
            site_names=(
                self.composite_controller_specific_config["ref_name"]
                if "ref_name" in self.composite_controller_specific_config
                else default_site_names
            ),
            robot_model=self.robot_model.mujoco_model,
            robot_joint_names=joint_names,
            input_type=self.composite_controller_specific_config.get("ik_input_type", "absolute"),
            input_ref_frame=self.composite_controller_specific_config.get("ik_input_ref_frame", "world"),
            input_rotation_repr=self.composite_controller_specific_config.get("ik_input_rotation_repr", "axis_angle"),
            solve_freq=self.composite_controller_specific_config.get("ik_solve_freq", 20),
            posture_weights=self.composite_controller_specific_config.get("ik_posture_weights", {}),
            hand_pos_cost=self.composite_controller_specific_config.get("ik_hand_pos_cost", 1.0),
            hand_ori_cost=self.composite_controller_specific_config.get("ik_hand_ori_cost", 0.5),
            use_mink_posture_task=self.composite_controller_specific_config.get("use_mink_posture_task", False),
            initial_qpos_as_posture_target=self.composite_controller_specific_config.get(
                "initial_qpos_as_posture_target", False
            ),
            verbose=self.composite_controller_specific_config.get("verbose", False),
        )