Add portable BONES-SEED G1 MT and Isaac converters

.gitignore

@@ -0,0 +1,11 @@
+__pycache__/
+*.py[cod]
+.venv/
+.cache/
+*.log
+*.csv
+*.npz
+*.tar
+*.tar.gz
+data/
+outputs/

LICENSE.md

@@ -0,0 +1,15 @@
+# Code License
+
+Copyright (c) 2026 the repository author(s). All rights reserved.
+
+The source code in this repository is made available for inspection. No
+permission is granted to copy, modify, redistribute, sublicense, or use it
+except with the copyright holder's prior written permission.
+
+This notice applies only to the conversion code authored for this repository.
+It does not grant any rights to BONES-SEED motion data, metadata, Unitree
+assets, MuJoCo models, names, trademarks, or other third-party materials.
+
+Before publishing this repository under an open-source license, the repository
+owner may replace this file with the full text of the selected code license,
+such as Apache-2.0 or MIT.

README.md

@@ -0,0 +1,163 @@
+---
+pretty_name: BONES-SEED Unitree G1 Converters
+tags:
+  - robotics
+  - motion-capture
+  - humanoid-robotics
+  - unitree-g1
+  - mujoco
+  - timeseries
+---
+
+# BONES-SEED Unitree G1 Converters
+
+将 BONES-SEED Unitree G1 CSV 动作转换为 MT 或 Isaac NPZ 格式。
+
+本仓库**只包含转换代码和格式文档**，不包含 BONES-SEED CSV、MT/Isaac NPZ、元数据、MuJoCo 模型或其他运动数据。用户必须从 BONES-SEED 官方渠道取得数据，并遵守其许可证。
+
+## 仓库内容
+
+```text
+bones-seed-g1/
+├── README.md
+├── LICENSE.md
+├── THIRD_PARTY_NOTICES.md
+├── requirements.txt
+├── docs/
+│   └── DATA_FORMAT.md
+└── scripts/
+    ├── converter_common.py
+    ├── csv_to_mt.py
+    ├── csv_to_isaac.py
+    ├── batch_convert.py
+    └── validate_npz.py
+```
+
+## 输入要求
+
+转换脚本要求用户自行准备：
+
+1. BONES-SEED 的 Unitree G1 CSV 文件。
+2. 与 CSV 关节定义匹配的 Unitree G1 MuJoCo MJCF XML。
+
+脚本不会下载或分发这些第三方文件。MJCF 模型必须包含一个自由根节点和 29 个 G1 关节，并且关节顺序必须与 `scripts/converter_common.py` 中的 `MT_JOINT_NAMES` 完全一致。脚本会在转换前进行检查。
+
+输入 CSV 默认约定：
+
+- 采样率：120 FPS；
+- 根节点平移：厘米；
+- 根节点旋转：XYZ 欧拉角，单位为度；
+- 关节角：度；
+- 关节列名称：`{joint_name}_dof`。
+
+完整字段说明见 [docs/DATA_FORMAT.md](docs/DATA_FORMAT.md)。
+
+## 安装
+
+```bash
+python -m venv .venv
+source .venv/bin/activate
+python -m pip install -r requirements.txt
+```
+
+建议记录实际使用的 Python、MuJoCo、NumPy 和 SciPy 版本，以便复现实验。
+
+## 单文件转换
+
+### 转换为 MT
+
+```bash
+python scripts/csv_to_mt.py \
+  --input /path/to/g1/csv/group/motion.csv \
+  --output /path/to/output/mt/group/motion.npz \
+  --g1-xml /path/to/g1.xml \
+  --source-fps 120 \
+  --target-fps 50
+```
+
+### 转换为 Isaac
+
+```bash
+python scripts/csv_to_isaac.py \
+  --input /path/to/g1/csv/group/motion.csv \
+  --output /path/to/output/isaac/group/motion.npz \
+  --g1-xml /path/to/g1.xml \
+  --source-fps 120 \
+  --target-fps 50
+```
+
+## 批量转换
+
+同时生成 MT 和 Isaac：
+
+```bash
+python scripts/batch_convert.py \
+  --input-dir /path/to/g1/csv \
+  --output-dir /path/to/output \
+  --g1-xml /path/to/g1.xml \
+  --format both \
+  --source-fps 120 \
+  --target-fps 50 \
+  --workers 16
+```
+
+输出目录会保留输入 CSV 的相对路径：
+
+```text
+/path/to/output/
+├── mt/{relative_path}.npz
+└── isaac/{relative_path}.npz
+```
+
+也可以只生成一种格式：
+
+```bash
+# 只生成 MT
+python scripts/batch_convert.py ... --format mt
+
+# 只生成 Isaac
+python scripts/batch_convert.py ... --format isaac
+```
+
+默认跳过已经存在的输出；使用 `--overwrite` 可重新生成。首次运行建议使用 `--limit 10` 做小规模检查。
+
+## 验证输出
+
+验证单个文件或整个目录：
+
+```bash
+python scripts/validate_npz.py /path/to/output/mt/motion.npz
+python scripts/validate_npz.py /path/to/output
+```
+
+校验内容包括必需字段、形状、数据类型、有限值、四元数单位长度、关节名称和局部根节点位置。
+
+## 格式摘要
+
+MT 格式保存：
+
+- `root_pos`、`root_rot`；
+- MT 顺序的 `dof_pos`；
+- 根坐标系下的 `local_body_pos`；
+- `joint_names`、`body_names` 和 `fps`。
+
+Isaac 格式保存：
+
+- Isaac 顺序的 `joint_pos`、`joint_vel`；
+- 世界坐标系下的刚体位置、四元数、线速度和角速度；
+- `fps`。
+
+注意：MT 根四元数为 `xyzw`，Isaac 刚体四元数为 `wxyz`。
+
+## 数据与许可
+
+本仓库不授予 BONES-SEED 数据、Unitree G1 模型或其他第三方资产的任何权利。代码许可见 [LICENSE.md](LICENSE.md)，第三方声明见 [THIRD_PARTY_NOTICES.md](THIRD_PARTY_NOTICES.md)。
+
+根据 BONES-SEED 的署名要求：
+
+> Motion Data by [Bones Studio](https://bones.studio/). Use of the underlying dataset is subject to the BONES Motion Capture Dataset License Agreement.
+
+官方资源：
+
+- BONES-SEED：https://bones.studio/datasets/seed
+- 数据许可证：https://bones.studio/info/seed-license

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,26 @@
+# Third-Party Notices
+
+## BONES-SEED
+
+This repository contains conversion code only. It does not contain or
+redistribute BONES-SEED motion files, metadata, annotations, or derived motion
+files.
+
+Users must obtain BONES-SEED from its official distribution channel and comply
+with the license in effect for their use:
+
+- Dataset page: https://bones.studio/datasets/seed
+- License: https://bones.studio/info/seed-license
+
+Required attribution:
+
+> Motion Data by [Bones Studio](https://bones.studio/). Use of the underlying
+> dataset is subject to the BONES Motion Capture Dataset License Agreement.
+
+## Unitree G1 and MuJoCo assets
+
+No Unitree G1 MJCF, mesh, texture, or other robot asset is included. Users are
+responsible for obtaining a compatible model and complying with its license.
+
+MuJoCo is a third-party dependency. Its software and license are not included
+in this repository; see https://mujoco.org/ for official information.

docs/DATA_FORMAT.md

@@ -0,0 +1,205 @@
+# Unitree G1 CSV、MT 与 Isaac 数据格式
+
+本文档定义本仓库转换脚本使用的输入 CSV，以及输出的 MT 和 Isaac NPZ 格式。
+
+## 通用约定
+
+- `T`：输出动作的帧数。
+- 位置：米（m）。
+- 关节角：弧度（rad）。
+- 线速度：米每秒（m/s）。
+- 角速度：弧度每秒（rad/s）。
+- 时序浮点字段：`float32`。
+- `fps`：形状 `(1,)` 的 `int64` 数组。
+- 输出帧数：`max(1, round(T_source × target_fps / source_fps))`。
+- 位置与关节角使用线性插值，四元数使用 SLERP。
+
+坐标轴方向由用户提供的 G1 MJCF 模型决定。
+
+## 输入 CSV
+
+每行表示一帧。CSV 通常包含 `Frame`，转换必需的是根节点和 29 个
+关节字段：
+
+```text
+Frame              # 可选，不参与时间计算
+root_translateX
+root_translateY
+root_translateZ
+root_rotateX
+root_rotateY
+root_rotateZ
+{joint_name}_dof  # 29 列
+```
+
+输入约定：
+
+| 内容 | 单位/表示 |
+|---|---|
+| `root_translate*` | 厘米 |
+| `root_rotate*` | XYZ 欧拉角，度 |
+| `*_dof` | 关节角，度 |
+
+CSV 的 29 个 DOF 使用以下 MT 顺序：
+
+```python
+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",
+]
+```
+
+时间间隔由 `--source-fps` 指定。
+
+## MT NPZ
+
+| 字段 | 形状 | 类型 | 含义 |
+|---|---:|---|---|
+| `root_pos` | `(T, 3)` | `float32` | 根节点世界坐标位置 |
+| `root_rot` | `(T, 4)` | `float32` | 根节点世界坐标四元数，`xyzw` |
+| `dof_pos` | `(T, 29)` | `float32` | MT 顺序的关节角 |
+| `local_body_pos` | `(T, 27, 3)` | `float32` | 根坐标系下的刚体位置 |
+| `joint_names` | `(29,)` | Unicode | `dof_pos` 的关节名称 |
+| `body_names` | `(27,)` | Unicode | `local_body_pos` 的刚体名称 |
+| `fps` | `(1,)` | `int64` | 输出帧率 |
+
+局部刚体位置定义：
+
+```text
+local_body_pos = inverse(root_rot) · (body_pos_w - root_pos)
+```
+
+MT 刚体顺序：
+
+```python
+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",
+]
+```
+
+当前实现使用以下近似：
+
+- `head_mimic` 复制 `torso_link` 的位置；
+- `left_hand_mimic` 复制 `left_wrist_roll_link` 的位置；
+- `right_hand_mimic` 复制 `right_wrist_roll_link` 的位置。
+
+## Isaac NPZ
+
+| 字段 | 形状 | 类型 | 含义 |
+|---|---:|---|---|
+| `fps` | `(1,)` | `int64` | 输出帧率 |
+| `joint_pos` | `(T, 29)` | `float32` | Isaac 顺序的关节角 |
+| `joint_vel` | `(T, 29)` | `float32` | Isaac 顺序的关节角速度 |
+| `body_pos_w` | `(T, 30, 3)` | `float32` | 刚体世界坐标位置 |
+| `body_quat_w` | `(T, 30, 4)` | `float32` | 刚体世界坐标四元数，`wxyz` |
+| `body_lin_vel_w` | `(T, 30, 3)` | `float32` | 刚体世界坐标线速度 |
+| `body_ang_vel_w` | `(T, 30, 3)` | `float32` | 刚体世界坐标角速度 |
+
+Isaac 关节顺序：
+
+```python
+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",
+]
+```
+
+Isaac 刚体顺序：
+
+```python
+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",
+]
+```
+
+根节点为刚体索引 `0`：
+
+```python
+root_pos_w = data["body_pos_w"][:, 0]
+root_quat_wxyz = data["body_quat_w"][:, 0]
+```
+
+`pelvis_contour_link` 在当前实现中复制 `pelvis` 的状态。Isaac NPZ 不保存名称数组，读取方必须使用上述固定顺序。
+
+## MT 与 Isaac 的差异
+
+| 项目 | MT | Isaac |
+|---|---|---|
+| 关节角字段 | `dof_pos` | `joint_pos` |
+| 关节顺序 | 按肢体分组 | 左右交替 |
+| 根四元数 | `root_rot`，`xyzw` | `body_quat_w[:, 0]`，`wxyz` |
+| 刚体位置 | 根节点局部坐标 | 世界坐标 |
+| 刚体数量 | 27 | 30 |
+| 速度 | 不保存 | 保存 |
+| 名称数组 | 保存 | 不保存 |
+
+四元数重排：
+
+```python
+# wxyz -> xyzw
+quat_xyzw = quat_wxyz[..., [1, 2, 3, 0]]
+
+# xyzw -> wxyz
+quat_wxyz = quat_xyzw[..., [3, 0, 1, 2]]
+```
+
+## 加载示例
+
+```python
+import numpy as np
+
+with np.load("motion_mt.npz", allow_pickle=False) as data:
+    fps = int(data["fps"][0])
+    dof_pos = data["dof_pos"]
+    root_rot_xyzw = data["root_rot"]
+
+with np.load("motion_isaac.npz", allow_pickle=False) as data:
+    fps = int(data["fps"][0])
+    joint_pos = data["joint_pos"]
+    root_quat_wxyz = data["body_quat_w"][:, 0]
+```

requirements.txt

@@ -0,0 +1,3 @@
+numpy>=1.24,<3
+scipy>=1.10,<2
+mujoco>=3.1,<4

scripts/batch_convert.py

@@ -0,0 +1,194 @@
+#!/usr/bin/env python3
+"""Batch-convert BONES-SEED G1 CSV files to MT, Isaac, or both."""
+
+from __future__ import annotations
+
+import argparse
+import multiprocessing
+import time
+from functools import partial
+from pathlib import Path
+
+from csv_to_isaac import convert_csv_to_isaac
+from csv_to_mt import convert_csv_to_mt
+
+
+def convert_one(
+    csv_path: Path,
+    *,
+    input_dir: Path,
+    output_dir: Path,
+    formats: tuple[str, ...],
+    g1_xml: Path,
+    source_fps: int,
+    target_fps: int,
+    overwrite: bool,
+) -> tuple[int, int, list[str]]:
+    """Convert one source file. Return completed, skipped, and error messages."""
+    relative_path = csv_path.relative_to(input_dir).with_suffix(".npz")
+    completed = 0
+    skipped = 0
+    errors = []
+
+    for output_format in formats:
+        output_path = output_dir / output_format / relative_path
+        if output_path.exists() and not overwrite:
+            skipped += 1
+            continue
+
+        try:
+            if output_format == "mt":
+                convert_csv_to_mt(
+                    csv_path=csv_path,
+                    output_path=output_path,
+                    g1_xml=g1_xml,
+                    source_fps=source_fps,
+                    target_fps=target_fps,
+                    verbose=False,
+                )
+            else:
+                convert_csv_to_isaac(
+                    csv_path=csv_path,
+                    output_path=output_path,
+                    g1_xml=g1_xml,
+                    source_fps=source_fps,
+                    target_fps=target_fps,
+                    verbose=False,
+                )
+            completed += 1
+        except Exception as error:  # keep the batch running and report failures
+            errors.append(f"{output_format}\t{csv_path}\t{error}")
+
+    return completed, skipped, errors
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Batch-convert BONES-SEED G1 CSV files"
+    )
+    parser.add_argument(
+        "--input-dir",
+        required=True,
+        type=Path,
+        help="Directory recursively containing G1 CSV files",
+    )
+    parser.add_argument(
+        "--output-dir",
+        required=True,
+        type=Path,
+        help="Output root; results are written under mt/ and/or isaac/",
+    )
+    parser.add_argument(
+        "--g1-xml",
+        required=True,
+        type=Path,
+        help="Compatible Unitree G1 MJCF XML",
+    )
+    parser.add_argument(
+        "--format",
+        choices=("mt", "isaac", "both"),
+        default="both",
+        help="Output format (default: both)",
+    )
+    parser.add_argument("--source-fps", type=int, default=120)
+    parser.add_argument("--target-fps", type=int, default=50)
+    parser.add_argument(
+        "--workers",
+        type=int,
+        default=max(1, multiprocessing.cpu_count() - 2),
+        help="Worker processes (default: CPU count minus two)",
+    )
+    parser.add_argument(
+        "--overwrite",
+        action="store_true",
+        help="Replace output files that already exist",
+    )
+    parser.add_argument(
+        "--limit",
+        type=int,
+        help="Convert only the first N files (useful for smoke tests)",
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    input_dir = args.input_dir.expanduser().resolve()
+    output_dir = args.output_dir.expanduser().resolve()
+    g1_xml = args.g1_xml.expanduser().resolve()
+
+    if not input_dir.is_dir():
+        raise SystemExit(f"Input directory not found: {input_dir}")
+    if not g1_xml.is_file():
+        raise SystemExit(f"G1 MJCF file not found: {g1_xml}")
+    if args.workers <= 0:
+        raise SystemExit("--workers must be positive")
+    if args.limit is not None and args.limit <= 0:
+        raise SystemExit("--limit must be positive")
+
+    csv_files = sorted(input_dir.rglob("*.csv"))
+    if args.limit is not None:
+        csv_files = csv_files[: args.limit]
+    if not csv_files:
+        raise SystemExit(f"No CSV files found under: {input_dir}")
+
+    formats = ("mt", "isaac") if args.format == "both" else (args.format,)
+    output_dir.mkdir(parents=True, exist_ok=True)
+
+    worker = partial(
+        convert_one,
+        input_dir=input_dir,
+        output_dir=output_dir,
+        formats=formats,
+        g1_xml=g1_xml,
+        source_fps=args.source_fps,
+        target_fps=args.target_fps,
+        overwrite=args.overwrite,
+    )
+
+    total_outputs = len(csv_files) * len(formats)
+    print(f"CSV files: {len(csv_files)}")
+    print(f"Formats: {', '.join(formats)}")
+    print(f"Expected outputs: {total_outputs}")
+    print(f"Workers: {args.workers}")
+    print(f"Output root: {output_dir}")
+
+    start_time = time.time()
+    completed = 0
+    skipped = 0
+    failures = []
+
+    with multiprocessing.Pool(args.workers) as pool:
+        for index, result in enumerate(
+            pool.imap_unordered(worker, csv_files), start=1
+        ):
+            done_count, skipped_count, errors = result
+            completed += done_count
+            skipped += skipped_count
+            failures.extend(errors)
+
+            if index % 1000 == 0 or index == len(csv_files):
+                elapsed = max(time.time() - start_time, 1e-6)
+                rate = index / elapsed
+                print(
+                    f"[{index}/{len(csv_files)}] "
+                    f"done={completed} skipped={skipped} "
+                    f"failed={len(failures)} files={rate:.1f}/s"
+                )
+
+    if failures:
+        failure_log = output_dir / "conversion_failures.log"
+        failure_log.write_text("\n".join(failures) + "\n", encoding="utf-8")
+        print(f"Failure details: {failure_log}")
+
+    elapsed = time.time() - start_time
+    print(
+        f"Finished in {elapsed / 60:.1f} min: "
+        f"done={completed}, skipped={skipped}, failed={len(failures)}"
+    )
+    if failures:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()

scripts/converter_common.py

@@ -0,0 +1,359 @@
+"""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

scripts/csv_to_isaac.py

@@ -0,0 +1,134 @@
+#!/usr/bin/env python3
+"""Convert one BONES-SEED Unitree G1 CSV file to Isaac-style NPZ format."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import mujoco
+import numpy as np
+
+from converter_common import (
+    ISAAC_BODY_NAMES,
+    ISAAC_JOINT_NAMES,
+    MT_JOINT_NAMES,
+    body_angular_velocity_wxyz,
+    ensure_output_parent,
+    finite_difference,
+    interpolate_linear,
+    interpolate_quaternions,
+    load_csv_motion,
+    load_g1_model,
+    output_frame_count,
+    require_body_id,
+    validate_fps,
+)
+
+
+def convert_csv_to_isaac(
+    csv_path: str | Path,
+    output_path: str | Path,
+    g1_xml: str | Path,
+    source_fps: int = 120,
+    target_fps: int = 50,
+    verbose: bool = True,
+) -> Path:
+    """Convert a single CSV motion to Isaac format and return the output path."""
+    validate_fps(source_fps, target_fps)
+    root_pos, root_rot_xyzw, dof_pos_mt = load_csv_motion(csv_path)
+
+    model = load_g1_model(str(Path(g1_xml).expanduser().resolve()))
+    model_data = mujoco.MjData(model)
+
+    body_ids = {}
+    for body_name in ISAAC_BODY_NAMES:
+        source_name = "pelvis" if body_name == "pelvis_contour_link" else body_name
+        body_ids[body_name] = require_body_id(model, source_name)
+
+    mt_indices = np.asarray(
+        [MT_JOINT_NAMES.index(name) for name in ISAAC_JOINT_NAMES],
+        dtype=np.int64,
+    )
+    joint_pos = dof_pos_mt[:, mt_indices]
+
+    body_pos_w = np.zeros(
+        (len(root_pos), len(ISAAC_BODY_NAMES), 3), dtype=np.float32
+    )
+    body_quat_w = np.zeros(
+        (len(root_pos), len(ISAAC_BODY_NAMES), 4), dtype=np.float32
+    )
+
+    for frame in range(len(root_pos)):
+        model_data.qpos[:3] = root_pos[frame]
+        model_data.qpos[3:7] = root_rot_xyzw[frame, [3, 0, 1, 2]]
+        model_data.qpos[7:] = dof_pos_mt[frame]
+        mujoco.mj_forward(model, model_data)
+
+        for output_index, body_name in enumerate(ISAAC_BODY_NAMES):
+            body_id = body_ids[body_name]
+            body_pos_w[frame, output_index] = model_data.xpos[body_id]
+            body_quat_w[frame, output_index] = model_data.xquat[body_id]
+
+    target_frames = output_frame_count(
+        len(root_pos), source_fps, target_fps
+    )
+    joint_pos = interpolate_linear(joint_pos, target_frames)
+    body_pos_w = interpolate_linear(body_pos_w, target_frames)
+    body_quat_w = interpolate_quaternions(body_quat_w, target_frames)
+
+    joint_vel = finite_difference(joint_pos, target_fps)
+    body_lin_vel_w = finite_difference(body_pos_w, target_fps)
+    body_ang_vel_w = body_angular_velocity_wxyz(
+        body_quat_w, target_fps
+    )
+
+    output_path = ensure_output_parent(output_path)
+    np.savez(
+        output_path,
+        fps=np.asarray([target_fps], dtype=np.int64),
+        joint_pos=joint_pos.astype(np.float32),
+        joint_vel=joint_vel.astype(np.float32),
+        body_pos_w=body_pos_w.astype(np.float32),
+        body_quat_w=body_quat_w.astype(np.float32),
+        body_lin_vel_w=body_lin_vel_w.astype(np.float32),
+        body_ang_vel_w=body_ang_vel_w.astype(np.float32),
+    )
+
+    if verbose:
+        print(
+            f"Saved Isaac: {output_path} "
+            f"({len(joint_pos)} frames @ {target_fps} fps)"
+        )
+    return output_path
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Convert one BONES-SEED G1 CSV motion to Isaac NPZ"
+    )
+    parser.add_argument("--input", required=True, help="Input G1 CSV file")
+    parser.add_argument(
+        "--output", required=True, help="Output Isaac NPZ file"
+    )
+    parser.add_argument(
+        "--g1-xml", required=True, help="Compatible Unitree G1 MJCF XML"
+    )
+    parser.add_argument("--source-fps", type=int, default=120)
+    parser.add_argument("--target-fps", type=int, default=50)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    convert_csv_to_isaac(
+        csv_path=args.input,
+        output_path=args.output,
+        g1_xml=args.g1_xml,
+        source_fps=args.source_fps,
+        target_fps=args.target_fps,
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/csv_to_mt.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+"""Convert one BONES-SEED Unitree G1 CSV file to MT NPZ format."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import mujoco
+import numpy as np
+from scipy.spatial.transform import Rotation as R
+
+from converter_common import (
+    MT_BODY_NAMES,
+    MT_JOINT_NAMES,
+    ensure_output_parent,
+    interpolate_linear,
+    interpolate_quaternions,
+    load_csv_motion,
+    load_g1_model,
+    output_frame_count,
+    require_body_id,
+    validate_fps,
+)
+
+
+MIMIC_BODY_SOURCES = {
+    "head_mimic": "torso_link",
+    "left_hand_mimic": "left_wrist_roll_link",
+    "right_hand_mimic": "right_wrist_roll_link",
+}
+
+
+def convert_csv_to_mt(
+    csv_path: str | Path,
+    output_path: str | Path,
+    g1_xml: str | Path,
+    source_fps: int = 120,
+    target_fps: int = 50,
+    verbose: bool = True,
+) -> Path:
+    """Convert a single CSV motion to MT format and return the output path."""
+    validate_fps(source_fps, target_fps)
+    root_pos, root_rot_xyzw, dof_pos = load_csv_motion(csv_path)
+
+    model = load_g1_model(str(Path(g1_xml).expanduser().resolve()))
+    model_data = mujoco.MjData(model)
+
+    physical_body_names = [
+        name for name in MT_BODY_NAMES if name not in MIMIC_BODY_SOURCES
+    ]
+    body_ids = {
+        name: require_body_id(model, name) for name in physical_body_names
+    }
+
+    body_pos_w = np.zeros(
+        (len(root_pos), len(MT_BODY_NAMES), 3), dtype=np.float32
+    )
+    for frame in range(len(root_pos)):
+        model_data.qpos[:3] = root_pos[frame]
+        model_data.qpos[3:7] = root_rot_xyzw[frame, [3, 0, 1, 2]]
+        model_data.qpos[7:] = dof_pos[frame]
+        mujoco.mj_forward(model, model_data)
+
+        for body_name, body_id in body_ids.items():
+            output_index = MT_BODY_NAMES.index(body_name)
+            body_pos_w[frame, output_index] = model_data.xpos[body_id]
+
+    for mimic_name, source_name in MIMIC_BODY_SOURCES.items():
+        body_pos_w[:, MT_BODY_NAMES.index(mimic_name)] = body_pos_w[
+            :, MT_BODY_NAMES.index(source_name)
+        ]
+
+    root_rotation_inverse = R.from_quat(root_rot_xyzw).inv().as_matrix()
+    local_body_pos = np.einsum(
+        "tij,tbj->tbi",
+        root_rotation_inverse,
+        body_pos_w - root_pos[:, None, :],
+    ).astype(np.float32)
+
+    target_frames = output_frame_count(
+        len(root_pos), source_fps, target_fps
+    )
+    root_pos = interpolate_linear(root_pos, target_frames)
+    root_rot_xyzw = interpolate_quaternions(
+        root_rot_xyzw, target_frames
+    )
+    dof_pos = interpolate_linear(dof_pos, target_frames)
+    local_body_pos = interpolate_linear(local_body_pos, target_frames)
+
+    output_path = ensure_output_parent(output_path)
+    np.savez(
+        output_path,
+        root_pos=root_pos.astype(np.float32),
+        root_rot=root_rot_xyzw.astype(np.float32),
+        dof_pos=dof_pos.astype(np.float32),
+        local_body_pos=local_body_pos.astype(np.float32),
+        joint_names=np.asarray(MT_JOINT_NAMES),
+        body_names=np.asarray(MT_BODY_NAMES),
+        fps=np.asarray([target_fps], dtype=np.int64),
+    )
+
+    if verbose:
+        print(
+            f"Saved MT: {output_path} "
+            f"({len(root_pos)} frames @ {target_fps} fps)"
+        )
+    return output_path
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(
+        description="Convert one BONES-SEED G1 CSV motion to MT NPZ"
+    )
+    parser.add_argument("--input", required=True, help="Input G1 CSV file")
+    parser.add_argument("--output", required=True, help="Output MT NPZ file")
+    parser.add_argument(
+        "--g1-xml", required=True, help="Compatible Unitree G1 MJCF XML"
+    )
+    parser.add_argument("--source-fps", type=int, default=120)
+    parser.add_argument("--target-fps", type=int, default=50)
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    convert_csv_to_mt(
+        csv_path=args.input,
+        output_path=args.output,
+        g1_xml=args.g1_xml,
+        source_fps=args.source_fps,
+        target_fps=args.target_fps,
+    )
+
+
+if __name__ == "__main__":
+    main()

scripts/validate_npz.py

@@ -0,0 +1,202 @@
+#!/usr/bin/env python3
+"""Validate MT and Isaac NPZ files produced by this repository."""
+
+from __future__ import annotations
+
+import argparse
+from pathlib import Path
+
+import numpy as np
+
+from converter_common import MT_BODY_NAMES, MT_JOINT_NAMES
+
+
+MT_FIELDS = {
+    "root_pos",
+    "root_rot",
+    "dof_pos",
+    "local_body_pos",
+    "joint_names",
+    "body_names",
+    "fps",
+}
+ISAAC_FIELDS = {
+    "fps",
+    "joint_pos",
+    "joint_vel",
+    "body_pos_w",
+    "body_quat_w",
+    "body_lin_vel_w",
+    "body_ang_vel_w",
+}
+
+
+def infer_format(keys: set[str]) -> str:
+    if MT_FIELDS.issubset(keys):
+        return "mt"
+    if ISAAC_FIELDS.issubset(keys):
+        return "isaac"
+    raise ValueError(f"Cannot infer format from fields: {sorted(keys)}")
+
+
+def require_shape(
+    data: np.lib.npyio.NpzFile,
+    name: str,
+    expected: tuple[int, ...],
+) -> None:
+    actual = data[name].shape
+    if actual != expected:
+        raise ValueError(f"{name}: expected shape {expected}, found {actual}")
+
+
+def require_float32(data: np.lib.npyio.NpzFile, fields: list[str]) -> None:
+    for name in fields:
+        if data[name].dtype != np.float32:
+            raise ValueError(
+                f"{name}: expected dtype float32, found {data[name].dtype}"
+            )
+        if not np.isfinite(data[name]).all():
+            raise ValueError(f"{name}: contains NaN or Inf")
+
+
+def validate_mt(data: np.lib.npyio.NpzFile) -> None:
+    missing = MT_FIELDS - set(data.files)
+    if missing:
+        raise ValueError(f"Missing MT fields: {sorted(missing)}")
+
+    frame_count = data["dof_pos"].shape[0]
+    if frame_count < 1:
+        raise ValueError("MT motion contains no frames")
+
+    require_shape(data, "root_pos", (frame_count, 3))
+    require_shape(data, "root_rot", (frame_count, 4))
+    require_shape(data, "dof_pos", (frame_count, 29))
+    require_shape(data, "local_body_pos", (frame_count, 27, 3))
+    require_shape(data, "joint_names", (29,))
+    require_shape(data, "body_names", (27,))
+    require_shape(data, "fps", (1,))
+    require_float32(
+        data, ["root_pos", "root_rot", "dof_pos", "local_body_pos"]
+    )
+
+    if data["fps"].dtype != np.int64 or int(data["fps"][0]) <= 0:
+        raise ValueError("fps must be a positive int64 array with shape (1,)")
+    if data["joint_names"].tolist() != MT_JOINT_NAMES:
+        raise ValueError("joint_names does not match the MT joint order")
+    if data["body_names"].tolist() != MT_BODY_NAMES:
+        raise ValueError("body_names does not match the MT body order")
+
+    quat_norm = np.linalg.norm(data["root_rot"], axis=-1)
+    if not np.allclose(quat_norm, 1.0, atol=1e-4):
+        raise ValueError("root_rot contains non-unit quaternions")
+    if not np.allclose(data["local_body_pos"][:, 0], 0.0, atol=1e-4):
+        raise ValueError("pelvis local_body_pos is not approximately zero")
+
+
+def validate_isaac(data: np.lib.npyio.NpzFile) -> None:
+    missing = ISAAC_FIELDS - set(data.files)
+    if missing:
+        raise ValueError(f"Missing Isaac fields: {sorted(missing)}")
+
+    frame_count = data["joint_pos"].shape[0]
+    if frame_count < 1:
+        raise ValueError("Isaac motion contains no frames")
+
+    require_shape(data, "fps", (1,))
+    require_shape(data, "joint_pos", (frame_count, 29))
+    require_shape(data, "joint_vel", (frame_count, 29))
+    require_shape(data, "body_pos_w", (frame_count, 30, 3))
+    require_shape(data, "body_quat_w", (frame_count, 30, 4))
+    require_shape(data, "body_lin_vel_w", (frame_count, 30, 3))
+    require_shape(data, "body_ang_vel_w", (frame_count, 30, 3))
+    require_float32(
+        data,
+        [
+            "joint_pos",
+            "joint_vel",
+            "body_pos_w",
+            "body_quat_w",
+            "body_lin_vel_w",
+            "body_ang_vel_w",
+        ],
+    )
+
+    if data["fps"].dtype != np.int64 or int(data["fps"][0]) <= 0:
+        raise ValueError("fps must be a positive int64 array with shape (1,)")
+    quat_norm = np.linalg.norm(data["body_quat_w"], axis=-1)
+    if not np.allclose(quat_norm, 1.0, atol=1e-4):
+        raise ValueError("body_quat_w contains non-unit quaternions")
+    if not np.allclose(
+        data["body_pos_w"][:, 0], data["body_pos_w"][:, 3], atol=1e-6
+    ):
+        raise ValueError("pelvis_contour_link must duplicate pelvis position")
+    if not np.allclose(
+        data["body_quat_w"][:, 0], data["body_quat_w"][:, 3], atol=1e-6
+    ):
+        raise ValueError("pelvis_contour_link must duplicate pelvis rotation")
+
+
+def validate_file(path: Path, expected_format: str) -> str:
+    with np.load(path, allow_pickle=False) as data:
+        actual_format = infer_format(set(data.files))
+        if expected_format != "auto" and actual_format != expected_format:
+            raise ValueError(
+                f"expected {expected_format}, inferred {actual_format}"
+            )
+        if actual_format == "mt":
+            validate_mt(data)
+        else:
+            validate_isaac(data)
+    return actual_format
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description="Validate MT/Isaac NPZ files")
+    parser.add_argument("path", type=Path, help="NPZ file or directory")
+    parser.add_argument(
+        "--format", choices=("auto", "mt", "isaac"), default="auto"
+    )
+    parser.add_argument(
+        "--limit", type=int, help="Validate only the first N files"
+    )
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = parse_args()
+    target = args.path.expanduser().resolve()
+    if target.is_file():
+        paths = [target]
+    elif target.is_dir():
+        paths = sorted(target.rglob("*.npz"))
+    else:
+        raise SystemExit(f"Path not found: {target}")
+
+    if args.limit is not None:
+        if args.limit <= 0:
+            raise SystemExit("--limit must be positive")
+        paths = paths[: args.limit]
+    if not paths:
+        raise SystemExit(f"No NPZ files found: {target}")
+
+    failures = []
+    counts = {"mt": 0, "isaac": 0}
+    for path in paths:
+        try:
+            actual_format = validate_file(path, args.format)
+            counts[actual_format] += 1
+        except Exception as error:
+            failures.append((path, error))
+            print(f"FAIL\t{path}\t{error}")
+
+    print(
+        f"Validated {len(paths)} file(s): "
+        f"mt={counts['mt']}, isaac={counts['isaac']}, "
+        f"failed={len(failures)}"
+    )
+    if failures:
+        raise SystemExit(1)
+
+
+if __name__ == "__main__":
+    main()