Motion-Player-ROS/scripts/motion_player.py

#!/usr/bin/env python3
"""
Motion player for ROS2.

Supports two modes:
  1. Playback mode (default): Plays pre-recorded motion from pickle/BVH files
  2. Realtime mode (--realtime): Receives live mocap data via OSC/UDP

Usage:
  ros2 run motion_player motion_player --ros-args -p motion_file:=/path/to/motion.pkl
  ros2 run motion_player motion_player --realtime --ros-args -p port:=11235
"""

import os
import argparse
import rclpy
from rclpy.node import Node
from sensor_msgs.msg import JointState
from geometry_msgs.msg import TransformStamped
from visualization_msgs.msg import Marker, MarkerArray
from tf2_ros import TransformBroadcaster
import numpy as np

# Joint names in the order stored in the motion data
JOINT_NAMES = [
    "left_hip_pitch_joint", "left_hip_roll_joint", "left_hip_yaw_joint",
    "left_knee_joint", "left_ankle_pitch_joint", "left_ankle_roll_joint",
    "right_hip_pitch_joint", "right_hip_roll_joint", "right_hip_yaw_joint",
    "right_knee_joint", "right_ankle_pitch_joint", "right_ankle_roll_joint",
    "waist_yaw_joint", "waist_roll_joint", "waist_pitch_joint",
    "left_shoulder_pitch_joint", "left_shoulder_roll_joint", "left_shoulder_yaw_joint",
    "left_elbow_joint", "left_wrist_roll_joint", "left_wrist_pitch_joint", "left_wrist_yaw_joint",
    "right_shoulder_pitch_joint", "right_shoulder_roll_joint", "right_shoulder_yaw_joint",
    "right_elbow_joint", "right_wrist_roll_joint", "right_wrist_pitch_joint", "right_wrist_yaw_joint",
]


class MotionPlayerNode(Node):
    """Unified ROS2 node for motion playback and real-time mocap visualization."""

    def __init__(self, realtime: bool = False):
        super().__init__('motion_player')
        self.realtime = realtime

        # Common publishers
        self.joint_state_pub = self.create_publisher(JointState, 'joint_states', 10)
        self.tf_broadcaster = TransformBroadcaster(self)
        self.skeleton_marker_pub = self.create_publisher(MarkerArray, 'skeleton_markers', 10)

        if self.realtime:
            self._init_realtime()
            self.timer = self.create_timer(1.0 / 100.0, self._realtime_callback)
        else:
            self._init_playback()
            if hasattr(self, 'fps') and self.fps > 0:
                self.timer = self.create_timer(1.0 / self.fps, self._playback_callback)

    # -------------------------------------------------------------------------
    # Playback mode initialization and callback
    # -------------------------------------------------------------------------
    def _init_playback(self):
        """Initialize playback mode from pickle/BVH files."""
        import pickle
        from movin_sdk_python import load_bvh_file

        # Declare parameters for playback mode
        self.declare_parameter('motion_file', '')
        self.declare_parameter('bvh_file', '')
        self.declare_parameter('loop', True)
        self.declare_parameter('skeleton_offset_x', 1.0)
        self.declare_parameter('human_height', 1.75)

        motion_file = self.get_parameter('motion_file').get_parameter_value().string_value
        bvh_file_param = self.get_parameter('bvh_file').get_parameter_value().string_value
        self.loop = self.get_parameter('loop').get_parameter_value().bool_value
        self.skeleton_offset_x = self.get_parameter('skeleton_offset_x').get_parameter_value().double_value
        human_height = self.get_parameter('human_height').get_parameter_value().double_value

        if not motion_file:
            self.get_logger().error('No motion_file specified!')
            return

        # Load motion data
        with open(motion_file, 'rb') as f:
            self.motion_data = pickle.load(f)

        self.fps = self.motion_data['fps']
        self.root_pos = self.motion_data['root_pos']      # [n_frames, 3]
        self.root_rot = self.motion_data['root_rot']      # [n_frames, 4] xyzw
        self.dof_pos = self.motion_data['dof_pos']        # [n_frames, 29]
        self.n_frames = len(self.root_pos)
        self.current_frame = 0

        self.get_logger().info(f'Loaded motion with {self.n_frames} frames at {self.fps} FPS')

        # Load BVH data if available
        self.bvh_frames = None
        self.bvh_bone_names = None
        self.bvh_bone_parents = None

        # Use explicit bvh_file parameter, or auto-detect from motion_file
        if bvh_file_param:
            bvh_file = bvh_file_param
        else:
            bvh_file = motion_file.replace('.pkl', '.bvh')

        if os.path.exists(bvh_file):
            # load_bvh_file returns (frames, human_height, parents, bones)
            self.bvh_frames, _, self.bvh_bone_parents, self.bvh_bone_names = load_bvh_file(
                bvh_file, human_height=human_height
            )
            self.get_logger().info(f'Loaded BVH with {len(self.bvh_frames)} frames, {len(self.bvh_bone_names)} bones')
        else:
            self.get_logger().warn(f'No BVH file found at {bvh_file}')

    def _playback_callback(self):
        """Timer callback for playback mode."""
        if self.current_frame >= self.n_frames:
            if self.loop:
                self.current_frame = 0
            else:
                self.get_logger().info('Motion playback complete')
                self.timer.cancel()
                return

        now = self.get_clock().now().to_msg()

        # Get current frame data
        root_pos = self.root_pos[self.current_frame]
        root_rot_xyzw = self.root_rot[self.current_frame]
        dof_pos = self.dof_pos[self.current_frame]

        # Publish robot state (convert xyzw to wxyz for consistency)
        root_rot_wxyz = np.array([root_rot_xyzw[3], root_rot_xyzw[0], root_rot_xyzw[1], root_rot_xyzw[2]])
        self._publish_robot_state(root_pos, root_rot_wxyz, dof_pos, now)

        # Publish BVH markers if available
        if self.bvh_frames is not None:
            # Use modulo to handle frame count mismatch between BVH and PKL
            bvh_frame_idx = self.current_frame % len(self.bvh_frames)
            frame_data = self.bvh_frames[bvh_frame_idx]
            self._publish_skeleton_markers(frame_data, now, self.bvh_bone_names, self.bvh_bone_parents)

        self.current_frame += 1

    # -------------------------------------------------------------------------
    # Realtime mode initialization and callback
    # -------------------------------------------------------------------------
    def _init_realtime(self):
        """Initialize realtime mode with mocap receiver."""
        from movin_sdk_python import Retargeter, MocapReceiver

        # Declare parameters for realtime mode
        self.declare_parameter('port', 11235)
        self.declare_parameter('robot_type', 'unitree_g1')
        self.declare_parameter('human_height', 1.75)
        self.declare_parameter('skeleton_offset_x', 1.0)

        # Get parameters
        port = self.get_parameter('port').get_parameter_value().integer_value
        robot_type = self.get_parameter('robot_type').get_parameter_value().string_value
        human_height = self.get_parameter('human_height').get_parameter_value().double_value
        self.skeleton_offset_x = self.get_parameter('skeleton_offset_x').get_parameter_value().double_value

        self.get_logger().info(f'Initializing Retargeter for {robot_type} with human_height={human_height}')

        # Initialize retargeter
        self.retargeter = Retargeter(
            robot_type=robot_type,
            human_height=human_height,
            verbose=False,
        )
        self.required_bones = self.retargeter.get_required_bones()

        # Initialize mocap receiver
        self.receiver = MocapReceiver(port=port)
        self.receiver.start()
        self.get_logger().info(f'MocapReceiver started on port {port}')

        # State tracking
        self.waiting_for_data = True
        self.warned_missing = 0

        self.get_logger().info(f'Waiting for mocap data on port {port}...')

    def _realtime_callback(self):
        """Timer callback for realtime mode - poll for mocap frames."""
        # Get latest mocap frame
        frame = self.receiver.get_latest_frame()

        if frame is None:
            return

        if self.waiting_for_data:
            self.waiting_for_data = False
            bone_names = [b["bone_name"] for b in frame["bones"]]
            self.get_logger().info(f'Receiving mocap data! {len(bone_names)} bones')

        bones = frame["bones"]

        # Process mocap frame
        mocap_data = self.retargeter.process_mocap_frame(bones)

        # Check for required bones
        missing = sorted(self.required_bones.difference(mocap_data.keys()))
        if missing:
            if self.warned_missing < 5:
                self.warned_missing += 1
                self.get_logger().warn(f'Missing {len(missing)} required bones: {missing}')
            return

        # Filter to only required bones for retargeting
        filtered_mocap_data = {k: mocap_data[k] for k in self.required_bones if k in mocap_data}

        # Retarget
        qpos = self.retargeter.retarget(filtered_mocap_data)

        now = self.get_clock().now().to_msg()

        # Extract root position and orientation
        root_pos = qpos[:3]
        root_rot = qpos[3:7]  # (w, x, y, z) format from mujoco
        dof_pos = qpos[7:]

        # Publish robot state
        self._publish_robot_state(root_pos, root_rot, dof_pos, now)

        # Publish skeleton markers with bone hierarchy from mocap frame
        bone_names = [b["bone_name"] for b in bones]
        bone_parents = {b["bone_index"]: b["parent_index"] for b in bones}
        self._publish_skeleton_markers(mocap_data, now, bone_names, bone_parents)

    # -------------------------------------------------------------------------
    # Common methods
    # -------------------------------------------------------------------------
    def _publish_skeleton_markers(self, frame_data: dict, stamp, bone_names, bone_parents):
        """Publish skeleton visualization as MarkerArray.
        
        Args:
            frame_data: Dictionary mapping bone_name -> [position, orientation]
                       Position is [x, y, z], orientation is quaternion
            stamp: ROS timestamp
            bone_names: List of bone names (ordered by index) or None
            bone_parents: Parent indices - either np.array (BVH) or dict {idx: parent_idx} (realtime)
        """
        marker_array = MarkerArray()
        marker_id = 0

        # Build bone positions dict
        bone_positions = {}
        for bone_name in frame_data.keys():
            pos = np.array(frame_data[bone_name][0])
            bone_positions[bone_name] = pos

        # Create sphere markers for each joint
        for bone_name, pos in bone_positions.items():
            marker = Marker()
            marker.header.stamp = stamp
            marker.header.frame_id = 'world'
            marker.ns = 'skeleton_joints'
            marker.id = marker_id
            marker.type = Marker.SPHERE
            marker.action = Marker.ADD

            marker.pose.position.x = float(pos[0] + self.skeleton_offset_x)
            marker.pose.position.y = float(pos[1])
            marker.pose.position.z = float(pos[2])
            marker.pose.orientation.w = 1.0

            marker.scale.x = 0.03
            marker.scale.y = 0.03
            marker.scale.z = 0.03

            marker.color.r = 1.0
            marker.color.g = 0.2
            marker.color.b = 0.2
            marker.color.a = 1.0

            marker_array.markers.append(marker)
            marker_id += 1

        # Create cylinder markers for bones using parent hierarchy
        if bone_names is not None and bone_parents is not None:
            for joint_idx in range(1, len(bone_names)):
                bone_name = bone_names[joint_idx]
                
                # Get parent index (handle both np.array and dict)
                if isinstance(bone_parents, dict):
                    parent_idx = bone_parents.get(joint_idx, -1)
                else:
                    parent_idx = int(bone_parents[joint_idx])
                
                if parent_idx < 0 or parent_idx >= len(bone_names):
                    continue
                
                parent_name = bone_names[parent_idx]
                
                if bone_name not in bone_positions or parent_name not in bone_positions:
                    continue

                start = bone_positions[parent_name].copy()
                end = bone_positions[bone_name].copy()

                start[0] += self.skeleton_offset_x
                end[0] += self.skeleton_offset_x

                self._add_bone_marker(marker_array, marker_id, start, end, stamp)
                marker_id += 1

        self.skeleton_marker_pub.publish(marker_array)

    def _publish_robot_state(self, root_pos, root_rot_wxyz, dof_pos, stamp):
        """Publish robot joint states and root TF.
        
        Args:
            root_pos: [x, y, z] root position
            root_rot_wxyz: [w, x, y, z] root quaternion
            dof_pos: joint positions array
            stamp: ROS timestamp
        """
        # Publish TF for pelvis (root)
        t = TransformStamped()
        t.header.stamp = stamp
        t.header.frame_id = 'world'
        t.child_frame_id = 'pelvis'

        t.transform.translation.x = float(root_pos[0])
        t.transform.translation.y = float(root_pos[1])
        t.transform.translation.z = float(root_pos[2])

        # ROS TF expects (x, y, z, w)
        t.transform.rotation.x = float(root_rot_wxyz[1])
        t.transform.rotation.y = float(root_rot_wxyz[2])
        t.transform.rotation.z = float(root_rot_wxyz[3])
        t.transform.rotation.w = float(root_rot_wxyz[0])

        self.tf_broadcaster.sendTransform(t)

        # Publish joint states
        joint_state = JointState()
        joint_state.header.stamp = stamp
        joint_state.name = JOINT_NAMES
        joint_state.position = dof_pos.tolist() if hasattr(dof_pos, 'tolist') else list(dof_pos)

        self.joint_state_pub.publish(joint_state)

    def _add_bone_marker(self, marker_array, marker_id, start, end, stamp):
        """Add a cylinder marker connecting two joints."""
        center = (start + end) / 2.0
        diff = end - start
        length = np.linalg.norm(diff)

        if length < 1e-6:
            return

        marker = Marker()
        marker.header.stamp = stamp
        marker.header.frame_id = 'world'
        marker.ns = 'skeleton_bones'
        marker.id = marker_id
        marker.type = Marker.CYLINDER
        marker.action = Marker.ADD

        marker.pose.position.x = float(center[0])
        marker.pose.position.y = float(center[1])
        marker.pose.position.z = float(center[2])

        # Calculate quaternion to orient cylinder along bone
        direction = diff / length
        z_axis = np.array([0.0, 0.0, 1.0])

        rot_axis = np.cross(z_axis, direction)
        rot_axis_norm = np.linalg.norm(rot_axis)

        if rot_axis_norm < 1e-6:
            if direction[2] > 0:
                marker.pose.orientation.w = 1.0
            else:
                marker.pose.orientation.x = 1.0
                marker.pose.orientation.w = 0.0
        else:
            rot_axis = rot_axis / rot_axis_norm
            angle = np.arccos(np.clip(np.dot(z_axis, direction), -1.0, 1.0))
            marker.pose.orientation.x = float(rot_axis[0] * np.sin(angle / 2))
            marker.pose.orientation.y = float(rot_axis[1] * np.sin(angle / 2))
            marker.pose.orientation.z = float(rot_axis[2] * np.sin(angle / 2))
            marker.pose.orientation.w = float(np.cos(angle / 2))

        marker.scale.x = 0.015
        marker.scale.y = 0.015
        marker.scale.z = float(length)

        marker.color.r = 1.0
        marker.color.g = 0.5
        marker.color.b = 0.0
        marker.color.a = 1.0

        marker_array.markers.append(marker)

    def destroy_node(self):
        """Clean up resources."""
        if self.realtime and hasattr(self, 'receiver'):
            self.get_logger().info('Stopping MocapReceiver...')
            self.receiver.stop()
        super().destroy_node()


def main(args=None):
    # Parse --realtime argument before ROS args
    parser = argparse.ArgumentParser(description='Motion player for ROS2')
    parser.add_argument('--realtime', action='store_true',
                        help='Use live mocap instead of file playback')
    parsed, ros_args = parser.parse_known_args()

    rclpy.init(args=ros_args)
    node = MotionPlayerNode(realtime=parsed.realtime)

    try:
        rclpy.spin(node)
    except KeyboardInterrupt:
        pass
    finally:
        node.destroy_node()
        try:
            rclpy.shutdown()
        except Exception:
            pass


if __name__ == '__main__':
    main()