| """Shared definitions and utilities for BONES-SEED G1 converters.""" |
|
|
| from __future__ import annotations |
|
|
| from functools import lru_cache |
| from pathlib import Path |
|
|
| import mujoco |
| import numpy as np |
| from scipy.spatial.transform import Rotation as R |
|
|
|
|
| MT_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", |
| ] |
|
|
| ISAAC_JOINT_NAMES = [ |
| "left_hip_pitch_joint", |
| "right_hip_pitch_joint", |
| "waist_yaw_joint", |
| "left_hip_roll_joint", |
| "right_hip_roll_joint", |
| "waist_roll_joint", |
| "left_hip_yaw_joint", |
| "right_hip_yaw_joint", |
| "waist_pitch_joint", |
| "left_knee_joint", |
| "right_knee_joint", |
| "left_shoulder_pitch_joint", |
| "right_shoulder_pitch_joint", |
| "left_ankle_pitch_joint", |
| "right_ankle_pitch_joint", |
| "left_shoulder_roll_joint", |
| "right_shoulder_roll_joint", |
| "left_ankle_roll_joint", |
| "right_ankle_roll_joint", |
| "left_shoulder_yaw_joint", |
| "right_shoulder_yaw_joint", |
| "left_elbow_joint", |
| "right_elbow_joint", |
| "left_wrist_roll_joint", |
| "right_wrist_roll_joint", |
| "left_wrist_pitch_joint", |
| "right_wrist_pitch_joint", |
| "left_wrist_yaw_joint", |
| "right_wrist_yaw_joint", |
| ] |
|
|
| MT_BODY_NAMES = [ |
| "pelvis", |
| "left_hip_pitch_link", |
| "left_hip_roll_link", |
| "left_hip_yaw_link", |
| "left_knee_link", |
| "left_ankle_pitch_link", |
| "left_ankle_roll_link", |
| "right_hip_pitch_link", |
| "right_hip_roll_link", |
| "right_hip_yaw_link", |
| "right_knee_link", |
| "right_ankle_pitch_link", |
| "right_ankle_roll_link", |
| "torso_link", |
| "left_shoulder_pitch_link", |
| "left_shoulder_roll_link", |
| "left_shoulder_yaw_link", |
| "left_elbow_link", |
| "left_wrist_roll_link", |
| "right_shoulder_pitch_link", |
| "right_shoulder_roll_link", |
| "right_shoulder_yaw_link", |
| "right_elbow_link", |
| "right_wrist_roll_link", |
| "head_mimic", |
| "left_hand_mimic", |
| "right_hand_mimic", |
| ] |
|
|
| ISAAC_BODY_NAMES = [ |
| "pelvis", |
| "left_hip_pitch_link", |
| "right_hip_pitch_link", |
| "pelvis_contour_link", |
| "left_hip_roll_link", |
| "right_hip_roll_link", |
| "waist_roll_link", |
| "left_hip_yaw_link", |
| "right_hip_yaw_link", |
| "torso_link", |
| "left_knee_link", |
| "right_knee_link", |
| "left_shoulder_pitch_link", |
| "right_shoulder_pitch_link", |
| "left_ankle_pitch_link", |
| "right_ankle_pitch_link", |
| "left_shoulder_roll_link", |
| "right_shoulder_roll_link", |
| "left_ankle_roll_link", |
| "right_ankle_roll_link", |
| "left_shoulder_yaw_link", |
| "right_shoulder_yaw_link", |
| "left_elbow_link", |
| "right_elbow_link", |
| "left_wrist_roll_link", |
| "right_wrist_roll_link", |
| "left_wrist_pitch_link", |
| "right_wrist_pitch_link", |
| "left_wrist_yaw_link", |
| "right_wrist_yaw_link", |
| ] |
|
|
| ROOT_TRANSLATION_COLUMNS = [ |
| "root_translateX", |
| "root_translateY", |
| "root_translateZ", |
| ] |
| ROOT_ROTATION_COLUMNS = [ |
| "root_rotateX", |
| "root_rotateY", |
| "root_rotateZ", |
| ] |
|
|
|
|
| def validate_fps(source_fps: int, target_fps: int) -> None: |
| if source_fps <= 0 or target_fps <= 0: |
| raise ValueError("source_fps and target_fps must both be positive") |
|
|
|
|
| def load_csv_motion(csv_path: str | Path) -> tuple[np.ndarray, np.ndarray, np.ndarray]: |
| """Load root position, root quaternion (xyzw), and MT-order DOF positions.""" |
| csv_path = Path(csv_path) |
| if not csv_path.is_file(): |
| raise FileNotFoundError(f"CSV file not found: {csv_path}") |
|
|
| data = np.genfromtxt(csv_path, delimiter=",", names=True) |
| data = np.atleast_1d(data) |
| if data.size == 0 or data.dtype.names is None: |
| raise ValueError(f"CSV contains no motion frames: {csv_path}") |
|
|
| required_columns = ( |
| ROOT_TRANSLATION_COLUMNS |
| + ROOT_ROTATION_COLUMNS |
| + [f"{name}_dof" for name in MT_JOINT_NAMES] |
| ) |
| missing = [name for name in required_columns if name not in data.dtype.names] |
| if missing: |
| raise ValueError( |
| f"CSV is missing {len(missing)} required column(s): {', '.join(missing)}" |
| ) |
|
|
| root_pos = np.column_stack([data[name] for name in ROOT_TRANSLATION_COLUMNS]) |
| root_pos = root_pos.astype(np.float32) / 100.0 |
|
|
| root_euler_xyz_deg = np.column_stack( |
| [data[name] for name in ROOT_ROTATION_COLUMNS] |
| ) |
| root_rot_xyzw = R.from_euler( |
| "xyz", root_euler_xyz_deg, degrees=True |
| ).as_quat().astype(np.float32) |
|
|
| dof_pos_deg = np.column_stack( |
| [data[f"{name}_dof"] for name in MT_JOINT_NAMES] |
| ).astype(np.float32) |
| dof_pos = np.deg2rad(dof_pos_deg).astype(np.float32) |
|
|
| for name, value in ( |
| ("root_pos", root_pos), |
| ("root_rot_xyzw", root_rot_xyzw), |
| ("dof_pos", dof_pos), |
| ): |
| if not np.isfinite(value).all(): |
| raise ValueError(f"{name} contains NaN or Inf: {csv_path}") |
|
|
| return root_pos, root_rot_xyzw, dof_pos |
|
|
|
|
| @lru_cache(maxsize=8) |
| def load_g1_model(g1_xml: str) -> mujoco.MjModel: |
| """Load and validate a G1 MJCF model, cached once per worker process.""" |
| xml_path = Path(g1_xml).expanduser().resolve() |
| if not xml_path.is_file(): |
| raise FileNotFoundError(f"G1 MJCF file not found: {xml_path}") |
|
|
| model = mujoco.MjModel.from_xml_path(str(xml_path)) |
| expected_nq = 7 + len(MT_JOINT_NAMES) |
| if model.nq != expected_nq: |
| raise ValueError( |
| f"Expected G1 model nq={expected_nq}, but {xml_path} has nq={model.nq}" |
| ) |
|
|
| model_joint_names = [] |
| for joint_id in range(model.njnt): |
| if model.jnt_type[joint_id] == mujoco.mjtJoint.mjJNT_FREE: |
| continue |
| name = mujoco.mj_id2name( |
| model, mujoco.mjtObj.mjOBJ_JOINT, joint_id |
| ) |
| if name: |
| model_joint_names.append(name) |
|
|
| if model_joint_names != MT_JOINT_NAMES: |
| raise ValueError( |
| "G1 MJCF joint order does not match the expected MT order.\n" |
| f"Expected: {MT_JOINT_NAMES}\n" |
| f"Found: {model_joint_names}" |
| ) |
| return model |
|
|
|
|
| def require_body_id(model: mujoco.MjModel, body_name: str) -> int: |
| body_id = mujoco.mj_name2id( |
| model, mujoco.mjtObj.mjOBJ_BODY, body_name |
| ) |
| if body_id < 0: |
| raise ValueError(f"G1 MJCF is missing required body: {body_name}") |
| return body_id |
|
|
|
|
| def output_frame_count(frame_count: int, source_fps: int, target_fps: int) -> int: |
| return max(1, int(round(frame_count * target_fps / source_fps))) |
|
|
|
|
| def interpolate_linear(array: np.ndarray, new_frame_count: int) -> np.ndarray: |
| """Linearly resample an array along its first dimension.""" |
| old_frame_count = len(array) |
| if new_frame_count == old_frame_count: |
| return array.copy() |
| if old_frame_count == 1: |
| return np.repeat(array, new_frame_count, axis=0) |
|
|
| new_times = np.linspace(0, old_frame_count - 1, new_frame_count) |
| result = np.empty( |
| (new_frame_count,) + array.shape[1:], dtype=np.float32 |
| ) |
| for index, time in enumerate(new_times): |
| lower = int(np.floor(time)) |
| upper = min(lower + 1, old_frame_count - 1) |
| fraction = time - lower |
| result[index] = array[lower] + fraction * ( |
| array[upper] - array[lower] |
| ) |
| return result |
|
|
|
|
| def interpolate_quaternions( |
| quaternions: np.ndarray, new_frame_count: int |
| ) -> np.ndarray: |
| """SLERP quaternion arrays along the first dimension.""" |
| old_frame_count = len(quaternions) |
| if new_frame_count == old_frame_count: |
| result = quaternions.copy() |
| elif old_frame_count == 1: |
| result = np.repeat(quaternions, new_frame_count, axis=0) |
| else: |
| result = np.empty( |
| (new_frame_count,) + quaternions.shape[1:], dtype=np.float32 |
| ) |
| new_times = np.linspace(0, old_frame_count - 1, new_frame_count) |
| for index, time in enumerate(new_times): |
| lower = int(np.floor(time)) |
| upper = min(lower + 1, old_frame_count - 1) |
| fraction = time - lower |
|
|
| q0 = quaternions[lower] |
| q1 = quaternions[upper] |
| dot = np.sum(q0 * q1, axis=-1, keepdims=True) |
| q1 = np.where(dot < 0.0, -q1, q1) |
| dot = np.clip(np.abs(dot), 0.0, 1.0) |
|
|
| theta = np.arccos(dot) |
| sin_theta = np.sin(theta) |
| small = sin_theta < 1e-6 |
| denominator = np.maximum(sin_theta, 1e-6) |
| weight0 = np.where( |
| small, |
| 1.0 - fraction, |
| np.sin((1.0 - fraction) * theta) / denominator, |
| ) |
| weight1 = np.where( |
| small, |
| fraction, |
| np.sin(fraction * theta) / denominator, |
| ) |
| result[index] = weight0 * q0 + weight1 * q1 |
|
|
| norms = np.linalg.norm(result, axis=-1, keepdims=True) |
| if np.any(norms < 1e-8): |
| raise ValueError("Encountered a zero-length quaternion during resampling") |
| return (result / norms).astype(np.float32) |
|
|
|
|
| def finite_difference(array: np.ndarray, fps: int) -> np.ndarray: |
| """Compute a time derivative using forward/backward and central differences.""" |
| derivative = np.zeros_like(array, dtype=np.float32) |
| if len(array) == 1: |
| return derivative |
|
|
| dt = 1.0 / fps |
| derivative[0] = (array[1] - array[0]) / dt |
| derivative[-1] = (array[-1] - array[-2]) / dt |
| if len(array) > 2: |
| derivative[1:-1] = (array[2:] - array[:-2]) / (2.0 * dt) |
| return derivative |
|
|
|
|
| def body_angular_velocity_wxyz( |
| body_quat_wxyz: np.ndarray, fps: int |
| ) -> np.ndarray: |
| """Compute world-frame body angular velocity from wxyz quaternions.""" |
| angular_velocity = np.zeros( |
| body_quat_wxyz.shape[:-1] + (3,), dtype=np.float32 |
| ) |
| if len(body_quat_wxyz) == 1: |
| return angular_velocity |
|
|
| dt = 1.0 / fps |
| for frame in range(len(body_quat_wxyz) - 1): |
| q0_xyzw = body_quat_wxyz[frame][:, [1, 2, 3, 0]] |
| q1_xyzw = body_quat_wxyz[frame + 1][:, [1, 2, 3, 0]] |
| rotation0 = R.from_quat(q0_xyzw) |
| rotation1 = R.from_quat(q1_xyzw) |
| delta = rotation1 * rotation0.inv() |
| angular_velocity[frame] = delta.as_rotvec() / dt |
| angular_velocity[-1] = angular_velocity[-2] |
| return angular_velocity |
|
|
|
|
| def ensure_output_parent(output_path: str | Path) -> Path: |
| output_path = Path(output_path) |
| output_path.parent.mkdir(parents=True, exist_ok=True) |
| return output_path |
|
|
