Update README, docs (annotation plan + guidelines), scripts, src/data

README.md

@@ -1,123 +1,214 @@
-# TopoSlots Unified Motion Dataset
+# TopoSlots Motion Data
 
-Multi-skeleton motion dataset for topology-agnostic motion tokenization research.
+Unified multi-skeleton 3D motion dataset for **TopoSlots**: topology-agnostic per-slot motion tokenization with foundation alignment.
 
-## Overview
+- **Paper target**: NeurIPS 2026 / ICLR 2027
+- **Last updated**: 2026-03-27
+- **Motions**: 24,448 across 7 datasets, 79 skeleton types (6 human + 73 animal species)
 
-| Dataset | Skeleton Type | Joints | Motions | Text | Source |
-|---------|:-------------|:------:|:-------:|:----:|--------|
-| `humanml3d/` | Human (SMPL) | 22 | 14,449 | 44K texts | AMASS MoCap |
-| `lafan1/` | Human (Ubisoft) | 22 | 77 | ✗ | Ubisoft La Forge |
-| `100style/` | Human (XSens) | 23 | 810 | style labels | 100Style (Zenodo) |
-| `bandai_namco/` | Human (BN) | 22 | 3,053 | ✗ | Bandai Namco Research |
-| `cmu_mocap/` | Human (CMU) | 31 | 2,496 | ✗ | CMU MoCap Database |
-| `mixamo/` | Human (Mixamo) | 67 | 2,453 | ✗ | Adobe Mixamo |
-| `truebones_zoo/` | 73 Animal Species | 9-145 | 1,110 | 888 captions | Truebones Zoo |
-| **Total** | **79 skeletons** | **9-145** | **24,448** | | |
+---
 
-## Data Format (Scheme C)
+## Dataset Summary
+
+| Dataset | Motions | Joints | Skeleton Type | Text Coverage | Text Quality | Renders |
+|---------|:-------:|:------:|---------------|:------------:|:------------:|:-------:|
+| **humanml3d** | 14,449 | 22 | Human (SMPL) | 100% | High (human multi-caption) | 14,449 |
+| **bandai_namco** | 3,053 | 21 | Human (BN) | 100% | Low (template sentences) | 3,053 |
+| **cmu_mocap** | 2,496 | 31 | Human (CMU) | 92% | Low (CMU index text) | 2,496 |
+| **mixamo** | 2,453 | 67 | Human (Mixamo, full fingers) | **0%** | None (hash filenames) | 2,453 |
+| **truebones_zoo** | 1,110 | 25-143 | 73 animal species | 80% | Medium (auto-generated) | 1,110 |
+| **100style** | 810 | 23 | Human (XSens) | 100% | Low (template sentences) | 810 |
+| **lafan1** | 77 | 22 | Human (Ubisoft) | 100% | Low (action type only) | 77 |
+| **Total** | **24,448** | 9-143 | **79 skeletons** | 88% | | 24,448 |
 
-All datasets use a unified `.npz` format per motion clip:
+### Text Annotation Status
 
-### Slot Token Input (cross-skeleton compatible)
-- `local_positions`: `[T, J, 3]` float32 — root-relative joint positions (meters)
-- `velocities`: `[T, J, 3]` float32 — joint velocities (m/s)
+**Needs annotation** (6 datasets, 9,999 motions):
+- `mixamo`: 2,453 — completely missing, filenames are hashes
+- `truebones_zoo`: 222 missing + 888 need review
+- `cmu_mocap`: 195 missing
+- `bandai_namco`, `100style`, `lafan1`: have template text, need upgrade to natural language
 
-### Root Track (separate)
-- `root_position`: `[T, 3]` float32 — global root position (meters)
-- `root_velocity`: `[T, 3]` float32 — root velocity (m/s)
+**Complete** (no annotation needed):
+- `humanml3d`: 14,449 with high-quality human annotations (3-5 captions each)
 
-### Decoder Ground Truth (skeleton-specific)
-- `joint_positions`: `[T, J, 3]` float32 — global joint positions (meters)
-- `local_rotations_6d`: `[T, J-1, 6]` float32 — continuous 6D rotation representation
-- `accelerations`: `[T, J, 3]` float32 — joint accelerations
-- `bone_lengths`: `[T, J]` float32 — per-frame bone lengths (meters)
+---
 
-### Auxiliary
-- `foot_contact`: `[T, 4]` float32 — [left_heel, left_toe, right_heel, right_toe] binary contact
+## Data Format (Scheme C)
 
-### Metadata
-- `num_frames`: int — actual frame count (before padding)
-- `fps`: float — frames per second (all resampled to 20 fps)
-- `skeleton_id`: str — dataset identifier
-- `texts`: str — text descriptions joined by `|||` (empty if unavailable)
+### Per-motion file: `motions/{id}.npz`
+
+| Field | Shape | Description |
+|-------|-------|-------------|
+| `local_positions` | [T, J, 3] | Root-relative joint positions (slot token input) |
+| `velocities` | [T, J, 3] | Joint velocities (slot token input) |
+| `root_position` | [T, 3] | Global root trajectory |
+| `root_velocity` | [T, 3] | Root velocity |
+| `joint_positions` | [T, J, 3] | Global joint positions (FK output) |
+| `local_rotations_6d` | [T, J-1, 6] | 6D rotation representation (decoder GT) |
+| `accelerations` | [T, J, 3] | Joint accelerations |
+| `bone_lengths` | [T, J] | Per-frame bone lengths |
+| `foot_contact` | [T, 4] | Foot contact labels (l_heel, l_toe, r_heel, r_toe) |
+| `num_frames` | scalar | Number of valid frames |
+| `fps` | scalar | Frames per second (20) |
+| `skeleton_id` | str | Dataset identifier |
+| `texts` | str | Text descriptions separated by `\|\|\|` |
+| `source_file` | str | Original BVH/source filename |
+| `species` | str | (Zoo only) Animal species name |
+
+### Per-skeleton file: `skeleton.npz`
+
+| Field | Shape | Description |
+|-------|-------|-------------|
+| `joint_names` | [J] | Original joint names from BVH |
+| `canonical_names` | [J] | Standardized English anatomical names (for CLIP) |
+| `parent_indices` | [J] | Parent joint index (-1 for root) |
+| `rest_offsets` | [J, 3] | Rest-pose offsets from parent (meters) |
+| `adjacency` | [J, J] | Undirected adjacency matrix |
+| `geodesic_dist` | [J, J] | Geodesic distance matrix |
+| `bone_lengths` | [J] | Rest-pose bone lengths |
+| `depths` | [J] | Tree depth per joint |
+| `degrees` | [J] | Number of children per joint |
+| `side_tags` | [J] | left/right/center classification |
+| `symmetry_pairs` | [P, 2] | Symmetric joint pair indices |
+
+### Per-dataset files
+
+| File | Description |
+|------|-------------|
+| `labels.json` | Structured L1 labels: `{motion_id: {L1_action, L1_style, source_file, ...}}` |
+| `stats.npz` | Normalization statistics (mean/std for positions and velocities) |
+| `splits/{train,val,test,all}.txt` | Data split files (80/10/10) |
+
+### Renders (for annotation)
+
+| File | Description |
+|------|-------------|
+| `renders/{id}.gif` | Stick figure animation (GIF) |
+| `renders/{id}_overview.png` | Multi-view static overview |
+
+---
+
+## File Structure
 
-### Per-Dataset Files
 ```
-{dataset}/
-├── skeleton.npz          # Skeleton graph (joint_names, parent_indices, rest_offsets, adjacency, geodesic_dist)
-├── stats.npz             # Normalization statistics (mean/std for positions and velocities)
-├── motions/              # Per-motion .npz files
-│   ├── 000000.npz
-│   ├── 000001.npz
+TopoSlots-MotionData/
+├── README.md
+│
+├── humanml3d/                      # 14,449 motions, SMPL-22, HIGH-QUALITY TEXT
+│   ├── skeleton.npz
+│   ├── labels.json
+│   ├── stats.npz
+│   ├── splits/
+│   └── motions/*.npz
+│
+├── bandai_namco/                   # 3,053 motions, 21 joints, NEEDS TEXT UPGRADE
+│   ├── skeleton.npz
+│   ├── labels.json
+│   ├── stats.npz
+│   ├── splits/
+│   ├── motions/*.npz
+│   └── renders/*.gif + *_overview.png
+│
+├── cmu_mocap/                      # 2,496 motions, 31 joints, NEEDS TEXT UPGRADE
+│   ├── (same structure)
+│   └── renders/
+│
+├── mixamo/                         # 2,453 motions, 67 joints, NO TEXT
+│   ├── (same structure)
+│   └── renders/
+│
+├── truebones_zoo/                  # 1,110 motions, 73 species, PARTIAL TEXT
+│   ├── skeleton.npz                # representative skeleton
+│   ├── skeletons/*.npz             # per-species skeletons
+│   ├── (same structure)
+│   └── renders/
+│
+├── 100style/                       # 810 motions, 23 joints, NEEDS TEXT UPGRADE
 │   └── ...
-└── splits/               # Data splits
-    ├── train.txt
-    ├── val.txt
-    ├── test.txt
-    └── all.txt
+│
+├── lafan1/                         # 77 motions, 22 joints, NEEDS TEXT UPGRADE
+│   └── ...
+│
+├── docs/
+│   ├── ANNOTATION_TOOL_PLAN.md     # Web annotation tool design + implementation prompt
+│   ├── ANNOTATION_GUIDELINE.md     # Annotation specification for annotators (Chinese)
+│   └── PROMPT_DESIGN.md            # Text prompt design decisions (L1/L2/L3)
+│
+├── scripts/
+│   ├── render_motion.py            # Render npz → GIF + overview PNG
+│   ├── preprocess_bvh.py           # Generic BVH → Scheme C converter
+│   ├── preprocess_humanml3d.py     # HumanML3D → Scheme C converter
+│   └── preprocess_truebones_zoo.py # Zoo species-aware converter
+│
+└── src/
+    └── data/
+        ├── skeleton_graph.py       # Skeleton topology: adjacency, geodesic, side tags, symmetry
+        ├── bvh_parser.py           # BVH file parser (handles 6-channel joints)
+        ├── canonical_names.py      # Human dataset canonical name mapping
+        ├── zoo_canonical_names.py  # Animal canonical name mapping (rule engine)
+        ├── humanml3d_converter.py  # SMPL-22 skeleton + 263D feature extraction
+        └── unified_dataset.py      # PyTorch Dataset (multi-skeleton, variable joints)
 ```
 
-### Truebones Zoo Additional
-```
-truebones_zoo/
-├── skeletons/            # Per-species skeleton graphs
-│   ├── Dog.npz
-│   ├── Cat.npz
-│   ├── Horse.npz
-│   └── ...  (73 species)
-└── motions/              # Named as {species}_{index}.npz
-    ├── Dog_0000.npz      # Extra fields: species, source_file
-    ├── Cat_0004.npz
-    └── ...
-```
+---
+
+## Annotation Workflow
+
+### For agents setting up the annotation tool:
+
+1. **Read** `docs/ANNOTATION_TOOL_PLAN.md` — contains the complete design and implementation prompt
+2. **Read** `docs/ANNOTATION_GUIDELINE.md` — annotation specification for human annotators
+3. **Data needed**: `{dataset}/renders/` (GIF/PNG) + `{dataset}/motions/` (npz metadata) + `{dataset}/labels.json`
+4. **Tool**: Flask + SQLite web app, implementation prompt in Section 9 of ANNOTATION_TOOL_PLAN.md
+5. **Post-processing**: Chinese annotations → LLM batch translate → English → inject into npz `texts` field
 
-## Scale & Units
-- All positions in **meters**
-- BVH datasets auto-converted from centimeters (÷100)
-- CMU MoCap uses custom scale factor (×0.0685)
-- Truebones Zoo: natural animal scale preserved (Pigeon 0.13m, Horse 1.50m, Trex 6.06m)
-- All motions resampled to **20 fps**
-- Max frames: **196** (~10 seconds)
-
-## Skeleton Diversity
-
-| Category | Species Count | Joint Range | Examples |
-|----------|:------------:|:-----------:|---------|
-| Human (various rigs) | 6 | 22-67 | SMPL, LAFAN1, CMU, Mixamo (with fingers) |
-| Quadrupeds | ~25 | 18-79 | Dog, Cat, Horse, Bear, Elephant |
-| Flying | ~10 | 9-69 | Eagle, Bat, Buzzard, Pigeon |
-| Reptiles/Dinos | ~10 | 25-69 | Trex, Alligator, Crocodile |
-| Insects/Arachnids | ~10 | 41-84 | Ant, Spider, Scorpion, Centipede |
-| Snakes | ~3 | 19-27 | Anaconda, KingCobra |
-| Fantasy | ~5 | 32-143 | Dragon (143j), Mammoth |
-
-## Usage (PyTorch)
-
-```python
-from src.data.unified_dataset import UnifiedMotionDataset, collate_fn
-from torch.utils.data import DataLoader
-
-dataset = UnifiedMotionDataset(
-    data_dirs=['data/processed/humanml3d', 'data/processed/mixamo', 'data/processed/truebones_zoo'],
-    split='train',
-    max_joints=128,   # pad all skeletons to this
-    max_frames=196,
-)
-
-dataloader = DataLoader(dataset, batch_size=8, collate_fn=collate_fn, shuffle=True)
-batch = next(iter(dataloader))
-# batch['motion_features']:  [8, 196, 128, 6]  — per-joint position+velocity
-# batch['skeleton_features']: [8, 128, 9]       — joint graph features
-# batch['joint_mask']:        [8, 128]           — valid joint mask
-# batch['num_joints']:        [8]                — actual joint counts (22, 67, 31, ...)
+### Annotation priority:
+| Priority | Dataset | Count | Task |
+|:--------:|---------|:-----:|------|
+| P0 | mixamo | 2,453 | Annotate from scratch (no existing text) |
+| P1 | truebones_zoo | 1,110 | Fill 222 missing + review 888 existing |
+| P1 | cmu_mocap | 195 | Fill missing entries |
+| P2 | bandai_namco | 3,053 | Upgrade template text to natural language |
+| P2 | 100style | 810 | Upgrade template text |
+| P2 | lafan1 | 77 | Upgrade template text |
+
+---
+
+## Data Processing History
+
+### Bug fixes applied (2026-03-18 ~ 2026-03-27):
+1. **FK rotation convention**: Fixed intrinsic vs extrinsic Euler angle bug in `preprocess_bvh.py`. All 5 BVH datasets reprocessed.
+2. **Bandai Namco dummy root**: Removed static `joint_Root` placeholder node (22→21 joints).
+3. **Bandai Namco per-joint positions**: Fixed parser to read 6-channel BVH (all joints have position+rotation channels).
+4. **Side tag detection**: Expanded from 2 patterns to 6-priority regex system (99.3% accuracy across 3,563 joints).
+5. **Canonical name standardization**: 1,193 unique raw names → 916 canonical names across all 79 skeletons.
+
+### Skeleton audit results:
+- 0 errors across 79 skeletons
+- Side tag accuracy: 99.3%
+- Canonical name coverage: 100%
+- Geodesic distance validity: 100%
+- Motion data integrity: 100% (no NaN/Inf)
+
+---
+
+## Citation
+
+```bibtex
+@misc{toposlots2026,
+  title={TopoSlots: Topology-Agnostic Per-Slot Motion Tokenization with Foundation Alignment},
+  year={2026},
+}
 ```
 
 ## License
-- HumanML3D: See original AMASS license
-- LAFAN1: CC BY-NC-ND 4.0
+
+Research use only. Individual dataset licenses apply:
+- HumanML3D: MIT
+- LAFAN1: CC BY-NC 4.0
 - 100Style: CC BY 4.0
-- Bandai Namco: CC BY-NC 4.0
-- CMU MoCap: Free for research
-- Mixamo: Adobe Mixamo Terms of Use
-- Truebones Zoo: Royalty-free
+- Bandai Namco: CC BY-NC-ND 4.0
+- CMU MoCap: Public domain
+- Mixamo: Adobe Mixamo terms
+- Truebones Zoo: Commercial license (research use)

docs/ANNOTATION_GUIDELINE.md

@@ -1,282 +1,259 @@
 # TopoSlots 动作文本标注规范
 
-## 1. 背景与目标
+> 更新: 2026-03-19
 
-### 当前标注状况
+## 1. 当前数据状况
 
-| 数据集 | Motions | 已有文本 | 缺失情况 |
-|--------|:-------:|:-------:|---------|
-| HumanML3D | 14,449 | 44,970 条 | ✅ 完整（多条/动作） |
-| Truebones Zoo | 1,110 | 888 条 | ⚠ 部分缺失（222条无文本），且标注来自 VLM 自动生成 |
-| LAFAN1 | 77 | 0 | ❌ 完全缺失 |
-| 100Style | 810 | 0 | ❌ 只有风格标签（如 "ShieldedRight"），无动作描述 |
-| Bandai Namco | 3,053 | 0 | ❌ 完全缺失 |
-| CMU MoCap | 2,496 | 0 | ❌ 完全缺失 |
-| Mixamo | 2,453 | 0 | ❌ 只有哈希文件名，无语义信息 |
+### 1.1 总览
 
-### 标注目标
+7 个数据集，24,448 条动作，79 种骨架（6 人类 + 73 动物）。
 
-为缺失文本的动作补充统一格式的中文/英文双语标注，用于：
-1. **文本条件动作生成**（text-to-motion generation）
-2. **文本-动作检索**（text-motion retrieval）
-3. **跨骨架语义对齐**（cross-skeleton semantic alignment）
+| 数据集 | Motions | 骨架 | 已有文本 | 覆盖率 | 文本质量 | 需要标注 |
+|--------|:-------:|:----:|:-------:|:------:|---------|:--------:|
+| HumanML3D | 14,449 | 22j 人类 | 14,449 | **100%** | 高——人工多条标注 | 0 |
+| Bandai Namco | 3,053 | 21j 人类 | 3,053 | **100%** | **低**——模板句，L1级 | **需升级** |
+| CMU MoCap | 2,496 | 31j 人类 | 2,301 | 92% | **低**——CMU官方索引直接拼接 | **195 + 升级** |
+| Mixamo | 2,453 | 67j 人类 | 0 | **0%** | 无 | **2,453** |
+| Truebones Zoo | 1,110 | 25~143j 动物×73种 | 888 | 80% | 中——自动生成 species+action | **222 + 审校** |
+| 100Style | 810 | 23j 人类 | 810 | **100%** | **低**——模板句，L1级 | **需升级** |
+| LAFAN1 | 77 | 22j 人类 | 77 | **100%** | **低**——仅动作类型 | **需升级** |
 
----
+### 1.2 现有文本样例及问题
 
-## 2. 标注格式规范
+**HumanML3D (OK, 不需要动)**:
+```
+"a man kicks something or someone with his left leg.|||the standing person kicks
+with their left foot before going back to standing position.|||a person kicks with
+their left leg.|||a person standing kicks their left foot forward."
+```
+- 多条标注（3-5 条），自然语言，L2-L3 级别
 
-### 2.1 文件组织
+**Bandai Namco (需升级)**:
+```
+"A person performs a active bow."          ← 语法不通，模板生硬
+"A person performs a angry bow."           ← 缺冠词、无细节
+"A person performs walk turn left."        ← 不自然
+```
 
-每个动作对应一个 JSON 标注文件，命名与 motion npz 文件一致：
+**CMU MoCap (需升级)**:
+```
+"A person performs: playground - forward jumps, turn around."   ← 原始索引直接拼接
+"A person performs: walk."                                     ← 太简单
+```
+195 条完全无文本（CMU 索引中缺失或标注为 "Unknown" 的条目）
 
+**100Style (需升级)**:
 ```
-annotations/
-├── humanml3d/          # 已有标注，转换为统一格式
-├── lafan1/
-│   ├── 000000.json
-│   └── ...
-├── 100style/
-├── bandai_namco/
-├── cmu_mocap/
-├── mixamo/
-└── truebones_zoo/
-    ├── Dog_0000.json
-    └── ...
+"A person does a backward run in a aeroplane style."    ← 模板句，aeroplane style 含义不明
+"A person stands idle in a monk style."                 ← style 语义对人来说不直观
 ```
 
-### 2.2 JSON Schema
+**LAFAN1 (需升级)**:
+```
+"A person performs aiming."       ← 极度简单，无任何细节
+"A person performs fight."
+```
 
-```json
-{
-  "motion_id": "000000",
-  "dataset": "lafan1",
-  "skeleton_type": "human",
-  "skeleton_id": "lafan1",
-  "species": "human",
-  "num_joints": 22,
-  "num_frames": 196,
-  "fps": 20,
-  "duration_sec": 9.8,
-
-  "captions": {
-    "short": {
-      "zh": ["一个人向前走了几步然后停下。"],
-      "en": ["A person walks forward a few steps then stops."]
-    },
-    "detailed": {
-      "zh": ["一个人从静止状态开始，先迈出左脚向前走了三步，步伐平稳，双臂自然摆动，然后逐渐减速停在原地。"],
-      "en": ["A person starts from a standing position, takes three steps forward beginning with the left foot, walks with steady pace and natural arm swing, then gradually decelerates to a stop."]
-    }
-  },
+**Mixamo (完全缺失)**:
+- 文件名是哈希值（如 `00041fd3325430d72c5a947e1171de3b.bvh`），无任何语义信息
+- **必须通过观看 GIF 渲染来标注**
 
-  "labels": {
-    "action_category": "locomotion",
-    "action_subcategory": "walk",
-    "style": null,
-    "intensity": "normal",
-    "locomotion_type": "forward",
-    "has_contact": true,
-    "contact_type": ["foot_ground"]
-  },
+**Truebones Zoo (部分缺失)**:
+```
+"An alligator sways its head and wags its tail.|||An ambush predator sways its
+head and wags its tail.|||An animal sways its head and wags its tail.|||"
+```
+- 已有 888/1110 条，自动生成，质量中等
+- 缺失 222 条（主要是 Idle、TPOSE 等难以描述的姿态）
 
-  "body_parts_involved": ["legs", "arms", "spine"],
+### 1.3 文本存储位置
 
-  "annotation_source": "manual",
-  "annotator_id": null,
-  "annotation_date": null
-}
+文本**存在 motion npz 文件的 `texts` 字段里**：
+```python
+data = np.load("data/processed/{dataset}/motions/{id}.npz")
+texts = str(data["texts"])  # 多条文本用 "|||" 分隔
 ```
 
-### 2.3 字段说明
+另有结构化标签存在 `data/processed/{dataset}/labels.json`。
 
-#### 必填字段
+### 1.4 可视化文件位置
 
-| 字段 | 类型 | 说明 | 示例 |
-|------|------|------|------|
-| `motion_id` | str | 与 npz 文件名对应 | `"000000"`, `"Dog_0000"` |
-| `dataset` | str | 数据集来源 | `"lafan1"`, `"truebones_zoo"` |
-| `skeleton_type` | str | 骨架大类 | `"human"`, `"quadruped"`, `"flying"`, `"reptile"`, `"insect"`, `"snake"`, `"fantasy"` |
-| `species` | str | 具体物种/角色 | `"human"`, `"dog"`, `"eagle"`, `"trex"` |
-| `captions.short.en` | list[str] | 英文简短描述（1-2句） | |
-| `captions.short.zh` | list[str] | 中文简短描述（1-2句） | |
+每条 motion 都有渲染好的 GIF 和静态图，用于标注时参考：
+```
+/scratch/ts1v23/workspace/motion_representation_study/data/processed/{dataset}/renders/
+  {id}.gif              ← stick figure 动画
+  {id}_overview.png     ← 多视角静态截图
+```
 
-#### 推荐字段
+---
 
-| 字段 | 类型 | 说明 |
-|------|------|------|
-| `captions.detailed.en` | list[str] | 英文详细描述（包含时序、身体部位、运动细节） |
-| `captions.detailed.zh` | list[str] | 中文详细描述 |
-| `labels.action_category` | str | 动作大类（见下表） |
-| `labels.action_subcategory` | str | 动作子类 |
-| `labels.style` | str | 风格标签（如 "angry", "sneaky"） |
-| `body_parts_involved` | list[str] | 参与的身体部位 |
+## 2. 标注任务
 
----
+### 2.1 任务分级
 
-## 3. 标注内容指南
+| 优先级 | 任务 | 数据集 | 条数 | 方式 |
+|:------:|------|--------|:----:|------|
+| **P0** | 从零标注 | Mixamo | 2,453 | 看 GIF 写描述 |
+| **P1** | 补缺 + 审校 | Truebones Zoo | 222 缺失 + 888 审校 | 看 GIF 补写/修正 |
+| **P1** | 补缺 | CMU MoCap | 195 | 看 GIF 写描述 |
+| **P2** | 升级文本 | Bandai Namco | 3,053 | 看 GIF，替换模板句 |
+| **P2** | 升级文本 | 100Style | 810 | 看 GIF，替换模板句 |
+| **P2** | 升级文本 | LAFAN1 | 77 | 看 GIF，替换模板句 |
+| - | 不需要 | HumanML3D | 0 | 已有高质量标注 |
 
-### 3.1 动作类别体系
+### 2.2 P0/P1: 从零标注或补缺
 
-#### 人类动作类别
+打开对应的 GIF 文件，写 **1-2 句英文描述**。
 
-| 大类 `action_category` | 子类 `action_subcategory` 示例 |
-|----------------------|------------------------------|
-| `locomotion` | walk, run, jog, sprint, crawl, sidestep, backward_walk |
-| `upper_body` | wave, point, reach, grab, throw, push, pull, clap |
-| `full_body` | jump, squat, lunge, stretch, bend, twist, turn |
-| `dance` | ballet, hip_hop, freestyle, waltz |
-| `sport` | kick, punch, swing, block, dodge |
-| `daily_activity` | sit_down, stand_up, pick_up, put_down, open_door |
-| `interaction` | handshake, hug, fight, carry |
-| `transition` | idle, t_pose, rest, fall, get_up |
+**描述原则**：
+- 写 **"做什么"**，不写 **"怎么做"**
+- 以 "A person..." 或 "A [animal]..." 开头
+- 包含：动作主体 + 核心动作 + 方向/速度/风格（如适用）
+- **不要提及关节名、骨骼数量、骨架结构**
 
-#### 动物动作类别
+**好的描述**：
+```
+A person jogs forward and then slows to a walk.
+A person throws a punch with their right hand then steps back.
+A dog runs forward and leaps over an obstacle.
+An eagle spreads its wings and takes off from the ground.
+```
 
-| 大类 `action_category` | 子类示例 |
-|----------------------|---------|
-| `locomotion` | walk, run, gallop, trot, slither, fly, swim, hop, crawl |
-| `combat` | attack, bite, claw, charge, headbutt, sting |
-| `idle` | stand, sit, lie_down, sleep, breathe, look_around |
-| `expression` | roar, bark, hiss, chirp, howl, growl |
-| `interaction` | eat, drink, dig, scratch, groom, play |
-| `special` | fly_takeoff, fly_land, dive, jump, roll, shake |
+**差的描述**：
+```
+❌ "Walking."                               → 太短，缺主体
+❌ "The skeleton moves forward."             → 提到了骨架
+❌ "Left knee bends 45 degrees."             → 关节级细节
+❌ "A 67-joint character performs motion."    → 技术信息
+❌ "一段动画"                                → 无信息量
+```
 
-### 3.2 描述撰写规范
+### 2.3 P2: 升级已有模板文本
 
-#### 简短描述 (short)
-- **1-2 句话**，概括动作核心语义
-- 必须包含：**动作主体** + **核心动作** + **方向/方式**（如有）
-- 人类动作：以 "一个人..." / "A person..." 开头
-- 动物动作：以 "一��[动物]..." / "A [animal]..." 开头
+已有模板句需要**替换为自然语言描述**，不是在模板句上修改。
 
-**好的示例**：
-```
-en: "A person walks forward steadily then turns left."
-zh: "一个人平稳地向前走然后左转。"
+| 原始模板 | → 升级后 |
+|---------|---------|
+| `A person performs a active bow.` | `A person bows energetically with a wide arm gesture.` |
+| `A person performs walk turn left.` | `A person walks forward and makes a left turn.` |
+| `A person does a backward run in a aeroplane style.` | `A person runs backward with both arms extended out to the sides like airplane wings.` |
+| `A person performs aiming.` | `A person holds a steady aiming pose, looking forward with arms raised as if holding a rifle.` |
 
-en: "A dog leaps forward and snaps its jaws in an attack."
-zh: "一只狗向前扑跳并张嘴撕咬进行攻击。"
-```
+### 2.4 多条描述
 
-**不好的示例**：
+每条动作**至少写 2 条不同描述**，用 `|||` 分隔：
 ```
-❌ "Walking." — 太简短，缺少主体和细节
-❌ "The motion data shows a bipedal character performing locomotion in the XZ plane." — 太技术化
-❌ "一段动画" — 无信息量
+A person walks forward briskly.|||A person takes quick steps in the forward direction.
 ```
 
-#### 详细描述 (detailed)
-- **2-4 句话**，包含时序信息和身体部位细节
-- 描述顺序：**起始姿态 → 主要动作 → 结束状态**
-- 包含：速度、幅度、哪些身体部位参与、是否有接触
+用词不同但语义相同。参考 HumanML3D 的风格——同一动作由不同人描述。
 
-**好的示例**：
-```
-en: "A person starts from a standing position with arms at their sides. They bend their knees
-and lower into a deep squat, keeping their back straight. After holding briefly, they push
-upward explosively into a small jump, landing softly on both feet."
+---
 
-zh: "一个人从自然站立姿势开始，双臂自然下垂。然后弯曲膝盖向下蹲至深蹲位置，保持背部挺直。
-短暂停顿后，爆发性地向上推起做一个小跳跃，双脚轻柔落地。"
-```
+## 3. 标注格式
 
-### 3.3 多条标注要求
+### 3.1 交付格式
 
-每个动作 **至少 2 条** 不同的简短描述，保持：
-- 用词不同但语义相同（如 "走路" vs "行走"，"walk" vs "stroll"）
-- 不同粒度的关注点（如一条描述整体动作，一条描述细节）
+每个数据集提交一个 JSON 文件：
 
-参考 HumanML3D 的做法：每个动作有 3-5 条不同标注者的描述。
+```json
+{
+  "000000": {
+    "texts_en": [
+      "A person bows politely with a slight forward lean.",
+      "A person performs a respectful bow, bending at the waist."
+    ],
+    "action_category": "gesture",
+    "style": "active",
+    "notes": ""
+  },
+  "000001": {
+    "texts_en": [
+      "A person bows with an aggressive, exaggerated motion.",
+      "A person angrily bends forward in a forceful bow."
+    ],
+    "action_category": "gesture",
+    "style": "angry",
+    "notes": ""
+  }
+}
+```
 
-### 3.4 跨骨架一致性
+字段说明：
 
-**关键原则**：相同语义的动作，在不同骨架上的描述应该可以匹配。
+| 字段 | 必填 | 说明 |
+|------|:----:|------|
+| `texts_en` | ✅ | 英文描述列表，至少 2 条 |
+| `action_category` | ✅ | 动作大类（见下表） |
+| `style` | 选填 | 风格标签（如 angry, sneaky, tired） |
+| `notes` | 选填 | 标注备注（如 "动作不清晰"、"可能是两个动作拼接"） |
 
-例如，"向前走" 的描述应在以下情况通用：
-- HumanML3D (22 joints, SMPL) 的人类行走
-- LAFAN1 (22 joints, Ubisoft) 的人类行走
-- Dog (55 joints, Truebones) 的狗行走
-- Horse (79 joints, Truebones) 的马行走
+### 3.2 动作类别
 
-描述应聚焦于 **语义动作**（"向前走"）而非 **关节/骨骼细节**（"left_knee flexion 45°"）。
+#### 人类
 
----
+| `action_category` | 包含 |
+|-------------------|------|
+| `locomotion` | walk, run, jog, sprint, crawl, sidestep, backward walk, skip, hop |
+| `upper_body` | wave, point, reach, grab, throw, push, pull, clap, salute |
+| `full_body` | jump, squat, lunge, stretch, bend, twist, turn, roll, cartwheel |
+| `dance` | ballet, hip hop, freestyle, waltz, spin |
+| `combat` | kick, punch, slash, block, dodge, stab |
+| `daily` | sit down, stand up, pick up, put down, drink, eat |
+| `gesture` | bow, nod, shrug, beckon, wave goodbye |
+| `idle` | stand, t-pose, rest pose, breathe |
 
-## 4. 标注流程
+#### 动物
 
-### 4.1 已有标注转换
+| `action_category` | 包含 |
+|-------------------|------|
+| `locomotion` | walk, run, gallop, trot, slither, fly, swim, hop, crawl |
+| `combat` | attack, bite, claw, charge, headbutt, sting |
+| `idle` | stand, sit, lie down, sleep, breathe, look around |
+| `vocalization` | roar, bark, hiss, chirp, howl |
+| `interaction` | eat, drink, dig, scratch, groom, play |
+| `aerial` | takeoff, land, dive, soar, hover |
 
-| 来源 | 转换方式 |
-|------|---------|
-| HumanML3D texts | 解析 `text#tokens#start#end` 格式 → JSON |
-| Truebones Zoo captions | 已有 JSON，提取 `short.original` → `captions.short.en`，缺 zh |
-| 100Style style labels | 文件名解析（如 `Angry_FW.bvh` → action=walk, style=angry） |
+---
 
-### 4.2 缺失标注补充
+## 4. 标注工具
 
-**推荐流程**：
+### 4.1 查看动作
 
-1. **VLM 自动标注**（初稿）
-   - 渲染动作骨架视频（stick figure）
-   - 使用 VLM（如 Qwen2.5-VL、GPT-4o）生成描述
-   - NECromancer 就是用 Qwen2.5-VL 做的自动标注
+GIF 和概览图在：
+```
+/scratch/ts1v23/workspace/motion_representation_study/data/processed/{dataset}/renders/
+```
 
-2. **人工审核**（修正）
-   - 检查自动标注的准确性
-   - 补充中文翻译
-   - 修正错误描述（特别是动物动作）
+用任何图片查看器打开 `.gif` 即可预览动作。如果 GIF 不够清晰，可以看 `_overview.png` 的多视角静态图。
 
-3. **质量控制**
-   - 每条标注由至少 1 人审核
-   - 不确定的动作标记为 `"annotation_source": "auto_vlm_unverified"`
+### 4.2 按数据集分配
 
-### 4.3 标注优先级
+建议按数据集拆分给不同标注者：
 
-| 优先级 | 数据集 | 理由 |
-|:------:|--------|------|
-| P0 | Truebones Zoo（缺失 222 条） | 论文核心卖点——多物种，且部分已有标注 |
-| P1 | LAFAN1 (77 条) | 高质量人类动画，数量少 |
-| P1 | 100Style (810 条) | 已有风格标签，只需扩展为句子 |
-| P2 | Bandai Namco (3,053 条) | 数量较多，可先自动标注 |
-| P2 | CMU MoCap (2,496 条) | 数量较多，CMU 有原始动作分类 |
-| P3 | Mixamo (2,453 条) | 文件名是哈希，需从原始 Mixamo 网站恢复动作名 |
+| 标注者 | 数据集 | 条数 |
+|--------|--------|:----:|
+| A | Mixamo (前半) | ~1,200 |
+| B | Mixamo (后半) | ~1,200 |
+| C | Bandai Namco | 3,053 |
+| D | CMU MoCap (195 缺失) + 100Style + LAFAN1 | ~1,082 |
+| E | Truebones Zoo (222 缺失 + 888 审校) | ~1,110 |
 
----
+### 4.3 审校 Truebones Zoo
 
-## 5. 与相关工作的对比
-
-| 数据集 | 标注格式 | 标注方式 | 语言 | 每动作条数 | 物种数 |
-|--------|---------|---------|------|:---------:|:-----:|
-| **HumanML3D** | `text#tokens#start#end` 纯文本 | 人工 (AMT) | 英文 | 3-5 | 1 (人) |
-| **BABEL** | 动作标签 + 帧级标注 | 人工 | 英文 | 2-3 | 1 (人) |
-| **Motion-X** | 语义标签 + 身体/手/脸描述 | Vicuna 1.5 增强 | 英文 | 多级 | 1 (人) |
-| **NECromancer UvU** | 自由文本 | VLM (Qwen2.5-VL) | 英文 | 1 | 多种 |
-| **T2M4LVO Zoo** | JSON: 4长度 × 7变体 × 7实体 | VLM + 变换 | 英文 | **196** | 68 |
-| **AniMo4D** (CVPR 2025) | 文本描述 + 物种属性 | 人工 | 英文 | 2.4 | 114 |
-| **AnimalML3D** | 文本描述 | 人工 | 英文 | 3 | 36 |
-| **TopoSlots (本项目)** | JSON: short/detailed × en/zh + 结构化标签 | VLM + 人工审核 | **中英双语** | ≥ 2 | 79 |
-
-### 我们的改进点
-1. **中英双语**：方便中文团队使用，也支持多语言条件生成和检索
-2. **结构化标签**：`action_category` + `subcategory` + `style` 便于分类分析和条件生成
-3. **骨架元信息**：`skeleton_type` + `species` 支持跨物种检索和过滤
-4. **标注来源追踪**：`annotation_source` + `quality_score` 区分人工/自动标注质量
-5. **分词保留**：兼容 HumanML3D 的 `word/POS` 格式，支持检索评估
-
-### 注意事项
-- **NECromancer 的 VLM 标注流程不透明**（未公开 prompt、渲染方式、质量评估），审稿人可能质疑。我们应明确记录标注流程。
-- **T2M4LVO 的 196 条/动作过于冗余**，我们采用 ≥2 条精选描述 + 结构化标签的平衡方案。
-- **AniMo4D 是动物标注竞争对手**（114 种，185K 描述），但它基于 SMAL 模板不是 BVH，且不含人类。
+对已有的 888 条 Zoo 文本，审校任务是：
+1. 打开 GIF
+2. 对比已有文本，判断是否准确
+3. 如果描述有误或太泛（如 "An animal moves"），**重写**
+4. 如果描述正确，跳过
 
 ---
 
-## 6. 验证标准
-
-标注完成后，需验证：
+## 5. 质量标准
 
-- [ ] 每个动作至少 2 条 `short.en` 描述
-- [ ] 每个动作至少 1 条 `short.zh` 描述
-- [ ] `action_category` 字段填充率 > 95%
-- [ ] 动物动作的 `species` 字段全部正确
-- [ ] 随机抽样 100 条，人工检查描述与动作的一致性 > 90%
-- [ ] 文本-动作检索实验（TMR 评估）验证标注质量
+- [ ] 每条动作至少 2 条英文描述
+- [ ] 描述必须以 "A person..." / "A [animal]..." 开头
+- [ ] 描述不提及骨骼/关节/技术细节
+- [ ] `action_category` 全部填写
+- [ ] 动作与描述不匹配率 < 5%（抽样检查）
+- [ ] Idle / T-Pose 也需要标注（如 "A person stands still in a neutral pose."）

docs/ANNOTATION_TOOL_PLAN.md

@@ -0,0 +1,401 @@
+# 动作标注 Web 平台 — 实现方案
+
+> 基于 Codex (GPT) 审批意见修订
+> 2026-03-27
+
+---
+
+## 一、总体架构
+
+```
+标注者(浏览器) ──HTTP──▶ Flask App (端口 8080)
+                            │
+                            ├── SQLite (annotations.db)
+                            ├── /data/renders/{dataset}/{id}.gif
+                            └── /data/renders/{dataset}/{id}_overview.png
+```
+
+**技术栈**: Flask + Jinja2 + vanilla JS + SQLite
+**部署**: `python app.py --port 8080 --host 0.0.0.0`，标注者浏览器直连内网 IP
+
+---
+
+## 二、数据库 Schema
+
+### motions 表（只读，初始化时从 npz 导入）
+
+```sql
+CREATE TABLE motions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    dataset TEXT NOT NULL,           -- 'bandai_namco', 'mixamo', ...
+    motion_id TEXT NOT NULL,         -- '000042', 'Dog_0001'
+    source_file TEXT,                -- 原始 BVH 文件名
+    num_frames INTEGER,
+    fps REAL,
+    num_joints INTEGER,
+    species TEXT,                    -- 仅 Zoo 数据集
+    existing_en TEXT,                -- 已有的英文文本（只读展示）
+    action_category_auto TEXT,       -- 自动提取的 L1（从 labels.json）
+    gif_path TEXT,                   -- 相对路径
+    overview_path TEXT,              -- 相对路径
+    UNIQUE(dataset, motion_id)
+);
+```
+
+### annotations 表（标注者写入）
+
+```sql
+CREATE TABLE annotations (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    dataset TEXT NOT NULL,
+    motion_id TEXT NOT NULL,
+    annotator TEXT NOT NULL DEFAULT '',
+    L1_zh TEXT DEFAULT '',           -- 动作标签（2-6字）
+    L2_zh TEXT DEFAULT '',           -- 短描述（1句，12-30字）
+    L3_zh TEXT DEFAULT '',           -- 详细描述（2-3句，仅复杂动作）
+    action_category TEXT DEFAULT '', -- 标注者选择的类别
+    style TEXT DEFAULT '',           -- 风格标签（可选）
+    species_override TEXT DEFAULT '',-- 物种修正（仅 Zoo）
+    notes TEXT DEFAULT '',           -- 备注
+    status TEXT DEFAULT 'unassigned',-- unassigned/in_progress/submitted/reviewed/needs_revision/skipped
+    flag TEXT DEFAULT '',            -- uncertain/bad_render/ambiguous（异常标记）
+    version INTEGER DEFAULT 1,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(dataset, motion_id)
+);
+```
+
+### annotation_history 表（变更记录）
+
+```sql
+CREATE TABLE annotation_history (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    dataset TEXT NOT NULL,
+    motion_id TEXT NOT NULL,
+    annotator TEXT,
+    L1_zh TEXT,
+    L2_zh TEXT,
+    L3_zh TEXT,
+    action_category TEXT,
+    status TEXT,
+    version INTEGER,
+    saved_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+```
+
+---
+
+## 三、页面设计
+
+### 3.1 主页 `/`
+
+6 个数据集卡片（排除 HumanML3D），每个显示：
+- 数据集名（中文别名）
+- 总条数 / 已标注数 / 完成率进度条
+- 优先级标记（P0/P1/P2）
+
+数据集中文映射：
+| dataset_id | 中文名 | 优先级 |
+|---|---|---|
+| mixamo | Mixamo 人类动画 | P0 |
+| truebones_zoo | 动物动作 | P1 |
+| cmu_mocap | CMU 动作捕捉 | P1 |
+| bandai_namco | 万代南梦宫 | P2 |
+| 100style | 100种风格 | P2 |
+| lafan1 | LAFAN1 | P2 |
+
+### 3.2 标注列表页 `/dataset/<dataset_id>`
+
+- 分页表格（每页 50 条）
+- 列：序号 | GIF 缩略图(小) | Motion ID | 已有标注状态 | L1 | L2 | 状态标签 | 操作
+- 顶部筛选栏：全部 / 未标注 / 已标注 / 已提交 / 需修改 / 已跳过
+- **"开始标注下一条"按钮**（自动跳到第一条未标注的）
+
+### 3.3 标注页面 `/annotate/<dataset_id>/<motion_id>` (核心)
+
+```
+┌─────────────────────────────────────────────────────────────┐
+│  ◀ 上一条    [000042 / 3053]    下一条 ▶    [跳到未标注]     │
+├────────────────────────┬────────────────────────────────────┤
+│                        │                                    │
+│  ┌──────────────────┐  │  📝 标注表单                       │
+│  │                  │  │                                    │
+│  │   GIF 动画       │  │  L1 动作标签 *（必填，2-6字）       │
+│  │   (播放/暂停)    │  │  ┌────────────────────────┐       │
+│  │                  │  │  │ 例: 走路、跳跃、攻击    │       │
+│  └──────────────────┘  │  └────────────────────────┘       │
+│                        │                                    │
+│  ┌──────────────────┐  │  L2 短描述 *（必填，1句话）         │
+│  │  多视角静态图     │  │  ┌────────────────────────┐       │
+│  │  (overview.png)  │  │  │ 例: 一个人向前走了几步   │       │
+│  └──────────────────┘  │  │ 然后停下。              │       │
+│                        │  └────────────────────────┘       │
+│  ────────────────────  │                                    │
+│  ▶ 显示参考文本(折叠)  │  L3 详细描述（选填，复杂动作建议填） │
+│  "A person performs    │  ┌────────────────────────┐       │
+│   walk turn left."     │  │                        │       │
+│                        │  │                        │       │
+│                        │  └────────────────────────┘       │
+│                        │                                    │
+│                        │  动作类别 [下拉选择]               │
+│                        │  风格/物种 [选填]                  │
+│                        │  备注 [选填]                       │
+│                        │                                    │
+│                        │  异常标记: ☐看不清 ☐动作模糊 ☐渲染异常│
+│                        │                                    │
+│                        │  [💾 保存] [保存并下一条 ▶] [跳过]  │
+├────────────────────────┴────────────────────────────────────┤
+│  📖 标注指南（可折叠）                                       │
+│  L1: 2-6字动作标签 | L2: 1句12-30字 | L3: 2-3句含时序细节   │
+│  ✅ 好: "一个人向前快走" | ❌ 差: "走路" "关节运动"           │
+└─────────────────────────────────────────────────────────────┘
+```
+
+**关键交互**:
+- 已有英文模板句**默认折叠**（避免锚定偏差）
+- 自动保存：输入 2 秒无操作后自动 AJAX 保存草稿
+- 明确"提交本条"按钮（status 从 in_progress → submitted）
+- 键盘: `Ctrl+S` 保存, `Ctrl+→` 下一条, `Ctrl+←` 上一条
+- GIF 播放/暂停: 用 libgif-js 库实现帧级控制（无需 ffmpeg 转 mp4）
+
+### 3.4 进度统计页 `/stats`
+
+- 各数据集完成率柱状图
+- 各标注者贡献统计
+- 按 action_category 分布饼图
+
+---
+
+## 四、API 设计
+
+```
+GET  /                                  → 主页
+GET  /dataset/<ds>                      → 标注列表（支持 ?page=&filter=）
+GET  /annotate/<ds>/<mid>               → 标注页面
+POST /api/save/<ds>/<mid>               → 保存标注（自动保存/手动保存）
+POST /api/submit/<ds>/<mid>             → 提交标注（status→submitted）
+POST /api/skip/<ds>/<mid>               → 跳过（status→skipped, flag 必填）
+GET  /api/next_unannotated/<ds>         → 获取下一条未标注的 motion_id
+GET  /api/stats                         → JSON 统计数据
+GET  /renders/<ds>/<filename>           → 静态文件（GIF/PNG）
+```
+
+---
+
+## 五、状态机
+
+```
+unassigned ──(打开标注页)──▶ in_progress
+in_progress ──(提交)──▶ submitted
+in_progress ──(跳过)──▶ skipped
+submitted ──(审核通过)──▶ reviewed
+submitted ──(打回)──▶ needs_revision
+needs_revision ──(重新提交)──▶ submitted
+skipped ──(重新打开)──▶ in_progress
+```
+
+---
+
+## 六、后处理流水线
+
+```
+1. 标注冻结后导出:
+   python scripts/export_annotations.py --db annotations.db --output annotations_zh.json
+
+2. LLM 批量翻译:
+   python scripts/translate_annotations.py \
+     --input annotations_zh.json \
+     --output annotations_en.json \
+     --model qwen2.5-72b \
+     --terminology docs/terminology.json
+
+3. 注入 npz:
+   python scripts/inject_texts.py \
+     --annotations annotations_en.json \
+     --data_dir data/processed/
+```
+
+**翻译脚本职责**：
+- 中文 → 英文直译
+- 生成第 2 条同义改写（不同用词相同语义）
+- 质量检查：长度、禁止技术词（关节/骨骼/帧数）、格式一致性
+- 记录 `translation_model`, `prompt_version`, `translated_at`
+
+**术语表** (`docs/terminology.json`)：
+```json
+{
+  "走路": "walk", "跑步": "run", "跳跃": "jump",
+  "左手": "left hand", "右脚": "right foot",
+  "鳄鱼": "alligator", "老鹰": "eagle", ...
+}
+```
+
+---
+
+## 七、文件结构
+
+```
+annotation_tool/
+├── app.py                   # Flask 主程序
+├── db.py                    # SQLite 数据库层
+├── init_db.py               # 从 npz/labels.json 初始化数据库
+├── requirements.txt         # flask
+├── annotations.db           # SQLite 数据库（运行时生成）
+├── templates/
+│   ├── base.html            # 基础模板（导航栏、CSS/JS 引用）
+│   ├── index.html           # 主页（数据集卡片）
+│   ├── dataset.html         # 标注列表页
+│   ├── annotate.html        # 标注页面（核心）
+│   └── stats.html           # 统计页
+├── static/
+│   ├── css/
+│   │   └── style.css        # 全局样式
+│   ├── js/
+│   │   ├── annotate.js      # 标注页交互逻辑（自动保存、键盘、GIF控制）
+│   │   └── libgif.js        # GIF 帧级控制库
+│   └── img/
+│       └── logo.png         # 可选
+└── scripts/
+    ├── export_annotations.py     # 导出标注为 JSON
+    ├── translate_annotations.py  # LLM 批量翻译
+    └── inject_texts.py           # 注入 npz
+```
+
+---
+
+## 八、数据迁移
+
+标注工具需要访问以下数据（从深度学习机拷贝到标注机）：
+
+```bash
+# 需要拷贝的文件（约 23G renders + 少量 npz 元数据）
+rsync -avP data/processed/*/renders/ target_machine:/path/to/data/renders/
+rsync -avP data/processed/*/motions/ target_machine:/path/to/data/motions/  # 用于读取 texts/metadata
+rsync -avP data/processed/*/labels.json target_machine:/path/to/data/labels/
+rsync -avP data/processed/*/skeleton.npz target_machine:/path/to/data/skeletons/
+```
+
+或者只拷贝 renders（GIF/PNG）+ labels.json，init_db.py 只需要这些来初始化。
+
+---
+
+## 九、在标注机上的实现 Prompt
+
+把以下 prompt 直接给标注机上的 Claude Code 执行：
+
+```
+请实现一个 3D 动作文本标注 Web 平台。
+
+## 技术栈
+Flask + Jinja2 + vanilla JS + SQLite，无需 React/Vue 等前端框架。
+
+## 数据位置
+动作 GIF 渲染在: {DATA_ROOT}/renders/{dataset}/{id}.gif 和 {id}_overview.png
+动作元数据在: {DATA_ROOT}/motions/{dataset}/{id}.npz（numpy，含 texts/source_file/num_frames 等字段）
+标签在: {DATA_ROOT}/labels/{dataset}/labels.json（JSON，motion_id → {L1_action, source_file, ...}）
+
+需要处理的 6 个数据集（排除 humanml3d）:
+- bandai_namco: 3053 条, 人类
+- cmu_mocap: 2496 条, 人类
+- mixamo: 2453 条, 人类
+- truebones_zoo: 1110 条, 动物(73种)
+- 100style: 810 条, 人类
+- lafan1: 77 条, 人类
+
+## 数据库
+SQLite，三张表:
+
+motions 表（只读，init 时从 npz/labels 导入）:
+- dataset, motion_id, source_file, num_frames, fps, num_joints, species, existing_en, action_category_auto, gif_path, overview_path
+
+annotations 表（标注者写入）:
+- dataset, motion_id, annotator, L1_zh, L2_zh, L3_zh, action_category, style, species_override, notes, status(unassigned/in_progress/submitted/reviewed/needs_revision/skipped), flag(uncertain/bad_render/ambiguous), version, created_at, updated_at
+
+annotation_history 表（每次保存记录快照）:
+- dataset, motion_id, annotator, L1_zh, L2_zh, L3_zh, action_category, status, version, saved_at
+
+## 页面设计（全中文界面）
+
+### 主页 /
+6 个数据集卡片，显示名称/条数/已标注数/完成率进度条/优先级(P0/P1/P2)
+
+### 列表页 /dataset/<ds>
+分页表格(50条/页), 列: 序号|缩略图|ID|L1|L2|状态标签|操作
+顶部筛选: 全部/未标注/已标注/已提交/需修改/已跳过
+核心按钮: "开始标注下一条"（自动跳到第一条未标注的）
+
+### 标注页 /annotate/<ds>/<mid>（核心页面）
+左侧: GIF 动画(用 libgif-js 或 SuperGif 实现暂停/播放) + 多视角概览图
+右侧表单:
+- L1 动作标签 *必填 (placeholder: "2-6字，如: 走路、跳跃")
+- L2 短描述 *必填 (placeholder: "1句话12-30字，描述动作主体和核心动作")
+- L3 详细描述 选填 (placeholder: "2-3句，包含时序和身体部位细节")
+- 动作类别下拉 *必填: locomotion/upper_body/full_body/dance/combat/daily/gesture/idle/vocalization/aerial/interaction
+- 风格标签 选填
+- 物种 选填（仅 truebones_zoo 显示，预填充）
+- 备注 选填
+- 异常标记 复选框: 看不清/动作模糊/渲染异常
+- 已有英文参考文本 **默认折叠**（点击展开，避免锚定偏差）
+- 按钮: [保存草稿] [提交本条] [保存并下一条] [跳过]
+- 导航: 上一条/下一条/跳到未标注
+- 自动保存: 输入停止 2 秒后自动 AJAX 保存草稿（不改变 status）
+- 键盘: Ctrl+S 保存, Ctrl+Enter 提交并下一条, Ctrl+→ 下一条, Ctrl+← 上一条
+- 顶部显示当前进度: "第 42 / 3053 条"
+- 底部可折叠标注指南（含正反例）
+
+### 统计页 /stats
+各数据集完成率, 标注者贡献
+
+## API
+POST /api/save/<ds>/<mid>       — 保存草稿（自动保存调用）
+POST /api/submit/<ds>/<mid>     — 提交（status→submitted, L1+L2+category 必填校验）
+POST /api/skip/<ds>/<mid>       — 跳过（flag 必填）
+GET  /api/next/<ds>?status=unassigned  — 下一条指定状态的 motion_id
+GET  /api/stats                 — JSON 统计
+GET  /renders/<path>            — 静态文件服务
+
+## 状态流转
+unassigned → in_progress（打开标注页时自动）
+in_progress → submitted（提交）
+in_progress → skipped（跳过）
+submitted → reviewed（审核通过, 预留）
+submitted → needs_revision（打回, 预留）
+needs_revision → submitted（重新提交）
+
+## 保存机制
+- 每次保存同时写 annotations 表（更新 version+1）和 annotation_history 表（追加快照）
+- 提交时校验: L1_zh 非空且 2-6 字, L2_zh 非空且 >=10 字, action_category 非空
+
+## 初始化脚本 init_db.py
+遍历 6 个数据集的 motions/*.npz 和 labels.json，填充 motions 表。
+从 npz 的 texts 字段读取 existing_en。
+从 labels.json 读取 action_category_auto。
+检查 renders 目录中 gif/png 是否存在。
+
+## 样式要求
+- 中文界面，简洁实用
+- 标注页左右分栏，左侧固定宽度(GIF)，右侧表单
+- 响应式，支持 1920px 宽屏
+- 状态标签用颜色区分（未标注灰色/进行中蓝色/已提交绿色/需修改橙色/已跳过灰色）
+- GIF 区域固定高度，不随表单滚动
+
+## 注意事项
+- 不要安装 React/Vue/npm，纯 Flask+Jinja+vanilla JS
+- libgif-js 可以从 CDN 引入或直接内嵌（用于 GIF 暂停/播放/帧控制）
+- 如果 libgif-js 太复杂，可以简化为点击 GIF 暂停(替换为 overview.png)/再点播放(恢复 GIF src)
+- SQLite 文件放在 annotation_tool/annotations.db
+- 启动命令: python annotation_tool/app.py --port 8080 --data-root /path/to/data
+```
+
+---
+
+## 十、后续步骤
+
+1. 将 renders + labels.json + motions 拷贝到标注机
+2. 在标注机上用上述 prompt 让 Claude Code 实现
+3. 运行 `python init_db.py` 初始化数据库
+4. 启动 `python app.py --port 8080`
+5. 分配标注者账号（简单用户名即可）
+6. 标注完成后运行导出 → 翻译 → 注入流水线
+7. 翻译结果拷回深度学习机，注入 npz

scripts/preprocess_bvh.py

@@ -35,45 +35,26 @@ def euler_to_6d_rotation(euler_angles: np.ndarray, order: str = 'ZYX') -> np.nda
     """
     Convert Euler angles (degrees) to continuous 6D rotation representation.
 
+    Uses scipy for correct BVH intrinsic Euler convention.
+
     Args:
         euler_angles: [..., 3] Euler angles in degrees
-        order: rotation order string (e.g., 'ZYX')
+        order: rotation order string (e.g., 'ZYX') — intrinsic convention
 
     Returns:
         [..., 6] continuous 6D rotation (first two columns of rotation matrix)
     """
-    rad = np.radians(euler_angles)
-    shape = rad.shape[:-1]
-
-    # Build rotation matrices from Euler angles
-    c = np.cos(rad)
-    s = np.sin(rad)
-
-    # Map order to axis indices
-    axis_map = {'X': 0, 'Y': 1, 'Z': 2}
-    axes = [axis_map[ch] for ch in order.upper()]
-
-    # Elementary rotation matrices
-    def rot_matrix(axis, cos_a, sin_a):
-        R = np.zeros(shape + (3, 3), dtype=np.float64)
-        R[..., axis, axis] = 1.0
-        other = [i for i in range(3) if i != axis]
-        R[..., other[0], other[0]] = cos_a
-        R[..., other[0], other[1]] = -sin_a
-        R[..., other[1], other[0]] = sin_a
-        R[..., other[1], other[1]] = cos_a
-        return R
-
-    R0 = rot_matrix(axes[0], c[..., 0], s[..., 0])
-    R1 = rot_matrix(axes[1], c[..., 1], s[..., 1])
-    R2 = rot_matrix(axes[2], c[..., 2], s[..., 2])
-
-    # Combined rotation: R = R0 @ R1 @ R2
-    R = np.einsum('...ij,...jk->...ik', R0, np.einsum('...ij,...jk->...ik', R1, R2))
+    from scipy.spatial.transform import Rotation
+
+    orig_shape = euler_angles.shape[:-1]
+    flat = euler_angles.reshape(-1, 3)
+
+    # BVH uses intrinsic rotations → scipy uppercase order
+    R = Rotation.from_euler(order.upper(), flat, degrees=True).as_matrix()  # [N, 3, 3]
 
     # Extract first two columns → 6D representation
-    rot_6d = np.concatenate([R[..., :, 0], R[..., :, 1]], axis=-1)
-    return rot_6d.astype(np.float32)
+    rot_6d = np.concatenate([R[:, :, 0], R[:, :, 1]], axis=-1)  # [N, 6]
+    return rot_6d.reshape(orig_shape + (6,)).astype(np.float32)
 
 
 def forward_kinematics(
@@ -82,48 +63,38 @@ def forward_kinematics(
     offsets: np.ndarray,
     parents: list[int],
     rotation_order: str = 'ZYX',
+    local_translations: np.ndarray = None,
 ) -> np.ndarray:
     """
     Compute global joint positions from local rotations + skeleton offsets via FK.
 
+    Uses scipy.spatial.transform.Rotation for correct BVH intrinsic Euler convention.
+    Verified against Blender's BVH FK (< 0.01mm error).
+
     Args:
-        rotations: [T, J, 3] Euler angles in degrees
+        rotations: [T, J, 3] Euler angles in degrees (columns match rotation_order)
         root_positions: [T, 3]
-        offsets: [J, 3] rest-pose offsets from parent
+        offsets: [J, 3] rest-pose offsets from parent (used when local_translations is None)
         parents: [J] parent indices
-        rotation_order: Euler rotation order
+        rotation_order: Euler rotation order (e.g., 'ZYX') — intrinsic convention
+        local_translations: [T, J, 3] optional per-frame local translations
+            (for BVH files where all joints have position channels)
 
     Returns:
         [T, J, 3] global joint positions
     """
+    from scipy.spatial.transform import Rotation
+
     T, J, _ = rotations.shape
-    rad = np.radians(rotations)
 
     positions = np.zeros((T, J, 3), dtype=np.float64)
     global_rotmats = np.zeros((T, J, 3, 3), dtype=np.float64)
 
     for j in range(J):
-        # Build local rotation matrix
-        c = np.cos(rad[:, j])
-        s = np.sin(rad[:, j])
-
-        axis_map = {'X': 0, 'Y': 1, 'Z': 2}
-        axes = [axis_map[ch] for ch in rotation_order.upper()]
-
-        def _rot(axis, cos_a, sin_a):
-            R = np.zeros((T, 3, 3), dtype=np.float64)
-            R[:, axis, axis] = 1.0
-            other = [i for i in range(3) if i != axis]
-            R[:, other[0], other[0]] = cos_a
-            R[:, other[0], other[1]] = -sin_a
-            R[:, other[1], other[0]] = sin_a
-            R[:, other[1], other[1]] = cos_a
-            return R
-
-        R0 = _rot(axes[0], c[:, 0], s[:, 0])
-        R1 = _rot(axes[1], c[:, 1], s[:, 1])
-        R2 = _rot(axes[2], c[:, 2], s[:, 2])
-        local_rot = np.einsum('tij,tjk->tik', R0, np.einsum('tij,tjk->tik', R1, R2))
+        # Build local rotation matrix using scipy (intrinsic Euler)
+        local_rot = Rotation.from_euler(
+            rotation_order.upper(), rotations[:, j], degrees=True
+        ).as_matrix()  # [T, 3, 3]
 
         p = parents[j]
         if p < 0:
@@ -133,10 +104,17 @@ def forward_kinematics(
             global_rotmats[:, j] = np.einsum(
                 'tij,tjk->tik', global_rotmats[:, p], local_rot
             )
-            offset = offsets[j]  # [3]
-            positions[:, j] = positions[:, p] + np.einsum(
-                'tij,j->ti', global_rotmats[:, p], offset
-            )
+            # Use per-frame translations if available, otherwise static offsets
+            if local_translations is not None:
+                offset = local_translations[:, j, :]  # [T, 3]
+                positions[:, j] = positions[:, p] + np.einsum(
+                    'tij,tj->ti', global_rotmats[:, p], offset
+                )
+            else:
+                offset = offsets[j]  # [3]
+                positions[:, j] = positions[:, p] + np.einsum(
+                    'tij,j->ti', global_rotmats[:, p], offset
+                )
 
     return positions.astype(np.float32)
 
@@ -161,20 +139,60 @@ def process_bvh_file(
     offsets = bvh.skeleton.rest_offsets
     rotations = bvh.rotations
     root_pos = bvh.root_positions
+    local_trans = bvh.local_translations  # [T, J, 3] or None
 
     # Remove end sites if requested
     if do_remove_end_sites:
         joint_names, parent_indices, offsets, rotations = remove_end_sites(
             joint_names, parent_indices, offsets, rotations
         )
+        # Also filter local_translations if present
+        if local_trans is not None:
+            keep_mask = [not name.endswith('_end') for name in bvh.skeleton.joint_names]
+            keep_indices = [i for i, k in enumerate(keep_mask) if k]
+            local_trans = local_trans[:, keep_indices, :]
+
+    # Remove dummy root: a static root joint whose only child is the real root (e.g. Hips).
+    if len(joint_names) > 1 and parent_indices[0] == -1:
+        children_of_root = [j for j in range(len(joint_names)) if parent_indices[j] == 0]
+        if len(children_of_root) == 1:
+            root_rot_range = rotations[:, 0].max(axis=0) - rotations[:, 0].min(axis=0)
+            root_is_static = np.all(root_rot_range < 1.0)  # <1 degree range = static
+            if root_is_static:
+                old_root_name = joint_names[0]
+                child_idx = children_of_root[0]
+                # Use per-frame position of child as new root_pos if available
+                if local_trans is not None:
+                    root_pos = local_trans[:, child_idx, :].copy()
+                    local_trans = local_trans[:, 1:, :]
+                else:
+                    root_pos = root_pos + offsets[child_idx]
+                # Remove joint 0
+                joint_names = joint_names[1:]
+                offsets = offsets[1:]
+                rotations = rotations[:, 1:]
+                # Remap parent indices
+                new_parents = []
+                for p in parent_indices[1:]:
+                    if p <= 0:
+                        new_parents.append(-1)
+                    else:
+                        new_parents.append(p - 1)
+                parent_indices = new_parents
+                print(f"  Removed dummy root '{old_root_name}' → new root '{joint_names[0]}'")
 
     J = len(joint_names)
 
     # Resample to target FPS
     if abs(bvh.fps - target_fps) > 0.5:
-        rotations, root_pos = resample_motion(
-            rotations, root_pos, bvh.fps, target_fps
-        )
+        if local_trans is not None:
+            rotations, root_pos, local_trans = resample_motion(
+                rotations, root_pos, bvh.fps, target_fps, local_trans
+            )
+        else:
+            rotations, root_pos = resample_motion(
+                rotations, root_pos, bvh.fps, target_fps
+            )
 
     T = rotations.shape[0]
     if T < min_frames:
@@ -182,6 +200,8 @@ def process_bvh_file(
     if T > max_frames:
         rotations = rotations[:max_frames]
         root_pos = root_pos[:max_frames]
+        if local_trans is not None:
+            local_trans = local_trans[:max_frames]
         T = max_frames
 
     # Build skeleton graph
@@ -193,7 +213,8 @@ def process_bvh_file(
 
     # Forward kinematics → global joint positions
     joint_positions = forward_kinematics(
-        rotations, root_pos, offsets, parent_indices, bvh.rotation_order
+        rotations, root_pos, offsets, parent_indices, bvh.rotation_order,
+        local_translations=local_trans,
     )
 
     # Scale normalization to meters

scripts/render_motion.py

@@ -0,0 +1,348 @@
+"""
+Unified motion visualization: npz → stick figure video/gif.
+
+Supports all datasets (human + animal, any joint count).
+Outputs: MP4 video or GIF for human/VLM review.
+
+Usage:
+    # Render single motion
+    python scripts/render_motion.py --input data/processed/humanml3d/motions/000001.npz --output results/videos/
+
+    # Batch render dataset
+    python scripts/render_motion.py --dataset humanml3d --num 20 --output results/videos/humanml3d/
+
+    # Render with text overlay
+    python scripts/render_motion.py --input ... --output ... --show_text --show_skeleton_info
+"""
+
+import sys
+import os
+import argparse
+from pathlib import Path
+import numpy as np
+import matplotlib
+matplotlib.use('Agg')
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+from matplotlib.animation import FuncAnimation, PillowWriter
+import matplotlib.patches as mpatches
+
+project_root = Path(__file__).parent.parent
+sys.path.insert(0, str(project_root))
+
+from src.data.skeleton_graph import SkeletonGraph
+
+SIDE_COLORS = {'left': '#e74c3c', 'right': '#3498db', 'center': '#555555'}
+
+
+def load_motion_and_skeleton(npz_path: Path, dataset_path: Path = None):
+    """Load motion data and its skeleton."""
+    d = dict(np.load(npz_path, allow_pickle=True))
+    T = int(d['num_frames'])
+
+    # Find skeleton
+    skel_data = None
+    if dataset_path:
+        # Try per-species skeleton for Zoo
+        species = str(d.get('species', ''))
+        if species:
+            sp_path = dataset_path / 'skeletons' / f'{species}.npz'
+            if sp_path.exists():
+                skel_data = dict(np.load(sp_path, allow_pickle=True))
+        if skel_data is None:
+            main_skel = dataset_path / 'skeleton.npz'
+            if main_skel.exists():
+                skel_data = dict(np.load(main_skel, allow_pickle=True))
+
+    if skel_data is None:
+        # Infer from parent directory
+        parent = npz_path.parent.parent
+        main_skel = parent / 'skeleton.npz'
+        if main_skel.exists():
+            skel_data = dict(np.load(main_skel, allow_pickle=True))
+
+    skeleton = SkeletonGraph.from_dict(skel_data) if skel_data else None
+    canon = [str(n) for n in skel_data.get('canonical_names', [])] if skel_data else []
+
+    return d, T, skeleton, canon
+
+
+def render_motion_to_gif(
+    npz_path: Path,
+    output_path: Path,
+    dataset_path: Path = None,
+    fps: int = 20,
+    show_text: bool = True,
+    show_skeleton_info: bool = True,
+    figsize: tuple = (10, 8),
+    frame_skip: int = 1,
+    view_angles: tuple = (25, -60),
+):
+    """Render a single motion npz to an animated GIF."""
+    d, T, skeleton, canon = load_motion_and_skeleton(npz_path, dataset_path)
+
+    joint_positions = d['joint_positions'][:T]  # [T, J, 3]
+    J = joint_positions.shape[1]
+    parents = skeleton.parent_indices if skeleton else [-1] + [0] * (J - 1)
+    side_tags = skeleton.side_tags if skeleton else ['center'] * J
+
+    # Subsample frames
+    frames = range(0, T, frame_skip)
+    n_frames = len(list(frames))
+
+    # Compute scene bounds (from all frames)
+    all_pos = joint_positions.reshape(-1, 3)
+    center = all_pos.mean(axis=0)
+    span = max(all_pos.max(axis=0) - all_pos.min(axis=0)) / 2 + 0.1
+
+    # Metadata
+    texts = str(d.get('texts', ''))
+    first_text = texts.split('|||')[0] if texts else ''
+    species = str(d.get('species', ''))
+    skeleton_id = str(d.get('skeleton_id', ''))
+    motion_id = npz_path.stem
+
+    # Create figure
+    fig = plt.figure(figsize=figsize)
+    ax = fig.add_subplot(111, projection='3d')
+
+    def update(frame_idx):
+        ax.clear()
+        fi = list(frames)[frame_idx]
+        pos = joint_positions[fi]
+
+        # Draw bones
+        for j in range(J):
+            p = parents[j]
+            if p >= 0 and p < J:
+                ax.plot3D(
+                    [pos[j, 0], pos[p, 0]],
+                    [pos[j, 2], pos[p, 2]],
+                    [pos[j, 1], pos[p, 1]],
+                    color='#bdc3c7', linewidth=2, zorder=1,
+                )
+
+        # Draw joints (colored by side)
+        for j in range(J):
+            color = SIDE_COLORS.get(side_tags[j] if j < len(side_tags) else 'center', '#555')
+            ax.scatter3D(
+                [pos[j, 0]], [pos[j, 2]], [pos[j, 1]],
+                color=color, s=25, zorder=3, edgecolors='black', linewidths=0.3,
+            )
+
+        # Draw ground plane
+        ground_y = joint_positions[:, :, 1].min() - 0.02
+        gx = np.array([center[0] - span, center[0] + span])
+        gz = np.array([center[2] - span, center[2] + span])
+        gx, gz = np.meshgrid(gx, gz)
+        gy = np.full_like(gx, ground_y)
+        ax.plot_surface(gx, gz, gy, alpha=0.1, color='green')
+
+        # Draw root trajectory (faded)
+        traj = joint_positions[:fi+1, 0, :]
+        if len(traj) > 1:
+            ax.plot3D(traj[:, 0], traj[:, 2], np.full(len(traj), ground_y),
+                     color='blue', alpha=0.3, linewidth=1)
+
+        # Axes
+        ax.set_xlim(center[0] - span, center[0] + span)
+        ax.set_ylim(center[2] - span, center[2] + span)
+        ax.set_zlim(center[1] - span, center[1] + span)
+        ax.set_xlabel('X')
+        ax.set_ylabel('Z')
+        ax.set_zlabel('Y')
+        ax.view_init(elev=view_angles[0], azim=view_angles[1])
+
+        # Title
+        title_parts = []
+        if show_skeleton_info:
+            info = f'{skeleton_id}'
+            if species:
+                info = f'{species}'
+            title_parts.append(f'{info} ({J}j)')
+        title_parts.append(f'frame {fi}/{T}')
+        if show_text and first_text:
+            # Truncate text
+            txt = first_text[:60] + ('...' if len(first_text) > 60 else '')
+            title_parts.append(f'"{txt}"')
+        ax.set_title('\n'.join(title_parts), fontsize=9)
+
+    anim = FuncAnimation(fig, update, frames=n_frames, interval=1000 // (fps // frame_skip))
+
+    # Save
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    suffix = output_path.suffix.lower()
+    if suffix == '.gif':
+        anim.save(str(output_path), writer=PillowWriter(fps=fps // frame_skip))
+    elif suffix == '.mp4':
+        try:
+            anim.save(str(output_path), writer='ffmpeg', fps=fps // frame_skip)
+        except Exception:
+            # Fallback to gif
+            gif_path = output_path.with_suffix('.gif')
+            anim.save(str(gif_path), writer=PillowWriter(fps=fps // frame_skip))
+            output_path = gif_path
+    else:
+        anim.save(str(output_path), writer=PillowWriter(fps=fps // frame_skip))
+
+    plt.close(fig)
+    return output_path
+
+
+def render_multi_view(
+    npz_path: Path,
+    output_path: Path,
+    dataset_path: Path = None,
+    n_frames: int = 8,
+):
+    """Render a multi-frame overview image (static, for quick review)."""
+    d, T, skeleton, canon = load_motion_and_skeleton(npz_path, dataset_path)
+
+    joint_positions = d['joint_positions'][:T]
+    J = joint_positions.shape[1]
+    parents = skeleton.parent_indices if skeleton else [-1] + [0] * (J - 1)
+    side_tags = skeleton.side_tags if skeleton else ['center'] * J
+
+    frame_indices = np.linspace(0, T - 1, n_frames, dtype=int)
+    colors = plt.cm.viridis(np.linspace(0, 1, n_frames))
+
+    texts = str(d.get('texts', ''))
+    first_text = texts.split('|||')[0][:80] if texts else ''
+    species = str(d.get('species', ''))
+    skeleton_id = str(d.get('skeleton_id', ''))
+
+    fig = plt.figure(figsize=(16, 6))
+
+    # Left: multi-frame overlay
+    ax1 = fig.add_subplot(121, projection='3d')
+    for idx, fi in enumerate(frame_indices):
+        pos = joint_positions[fi]
+        alpha = 0.3 + 0.7 * (idx / max(n_frames - 1, 1))
+        for j in range(J):
+            p = parents[j]
+            if p >= 0 and p < J:
+                ax1.plot3D([pos[j, 0], pos[p, 0]], [pos[j, 2], pos[p, 2]],
+                          [pos[j, 1], pos[p, 1]], color=colors[idx], alpha=alpha, linewidth=1.5)
+
+    all_pos = joint_positions.reshape(-1, 3)
+    mid = all_pos.mean(axis=0)
+    sp = max(all_pos.max(axis=0) - all_pos.min(axis=0)) / 2 + 0.1
+    ax1.set_xlim(mid[0]-sp, mid[0]+sp); ax1.set_ylim(mid[2]-sp, mid[2]+sp); ax1.set_zlim(mid[1]-sp, mid[1]+sp)
+    ax1.set_title(f'{species or skeleton_id} ({J}j, {T} frames)\n{first_text}', fontsize=9)
+    ax1.view_init(25, -60)
+
+    # Right: trajectory top view + velocity
+    ax2 = fig.add_subplot(222)
+    root = d['root_position'][:T]
+    ax2.plot(root[:, 0], root[:, 2], 'b-', linewidth=1)
+    ax2.plot(root[0, 0], root[0, 2], 'go', ms=6, label='start')
+    ax2.plot(root[-1, 0], root[-1, 2], 'ro', ms=6, label='end')
+    ax2.set_title('Root trajectory (top)', fontsize=8)
+    ax2.set_aspect('equal')
+    ax2.legend(fontsize=7)
+    ax2.grid(True, alpha=0.3)
+
+    ax3 = fig.add_subplot(224)
+    vel = d['velocities'][:T]
+    mean_vel = np.linalg.norm(vel, axis=-1).mean(axis=1)
+    ax3.plot(mean_vel, 'b-', alpha=0.7, linewidth=1)
+    fc = d['foot_contact'][:T]
+    if fc.shape[1] >= 4:
+        ax3.fill_between(range(T), 0, fc[:, :2].max(axis=1) * mean_vel.max() * 0.3,
+                        alpha=0.2, color='red', label='L foot')
+        ax3.fill_between(range(T), 0, fc[:, 2:].max(axis=1) * mean_vel.max() * 0.3,
+                        alpha=0.2, color='green', label='R foot')
+    ax3.set_title('Velocity + foot contact', fontsize=8)
+    ax3.legend(fontsize=7)
+    ax3.grid(True, alpha=0.3)
+
+    plt.tight_layout()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    plt.savefig(output_path, dpi=120, bbox_inches='tight')
+    plt.close()
+    return output_path
+
+
+def batch_render(
+    dataset_id: str,
+    output_dir: Path,
+    num: int = 20,
+    mode: str = 'overview',  # 'overview' | 'gif' | 'both'
+    frame_skip: int = 2,
+):
+    """Batch render samples from a dataset."""
+    base = project_root / 'data' / 'processed' / dataset_id
+    mdir = base / 'motions'
+    files = sorted(os.listdir(mdir))
+
+    # Select diverse samples (spread across dataset)
+    indices = np.linspace(0, len(files) - 1, min(num, len(files)), dtype=int)
+    selected = [files[i] for i in indices]
+
+    output_dir.mkdir(parents=True, exist_ok=True)
+    rendered = 0
+
+    for f in selected:
+        npz_path = mdir / f
+        name = f.replace('.npz', '')
+
+        if mode in ('overview', 'both'):
+            out = output_dir / f'{name}_overview.png'
+            render_multi_view(npz_path, out, base)
+            rendered += 1
+
+        if mode in ('gif', 'both'):
+            out = output_dir / f'{name}.gif'
+            render_motion_to_gif(npz_path, out, base, frame_skip=frame_skip)
+            rendered += 1
+
+    return rendered
+
+
+def main():
+    parser = argparse.ArgumentParser(description='Render motion visualizations')
+    parser.add_argument('--input', type=str, help='Single npz file to render')
+    parser.add_argument('--dataset', type=str, help='Dataset ID for batch render')
+    parser.add_argument('--output', type=str, default='results/videos/', help='Output directory')
+    parser.add_argument('--num', type=int, default=20, help='Number of samples for batch')
+    parser.add_argument('--mode', choices=['overview', 'gif', 'both'], default='both')
+    parser.add_argument('--frame_skip', type=int, default=2, help='Frame skip for GIF (1=all frames)')
+    parser.add_argument('--show_text', action='store_true', default=True)
+    parser.add_argument('--show_skeleton_info', action='store_true', default=True)
+    args = parser.parse_args()
+
+    output = Path(args.output)
+
+    if args.input:
+        npz_path = Path(args.input)
+        ds_path = npz_path.parent.parent
+        print(f'Rendering: {npz_path.name}')
+
+        if args.mode in ('overview', 'both'):
+            out = output / f'{npz_path.stem}_overview.png'
+            render_multi_view(npz_path, out, ds_path)
+            print(f'  Overview: {out}')
+
+        if args.mode in ('gif', 'both'):
+            out = output / f'{npz_path.stem}.gif'
+            render_motion_to_gif(npz_path, out, ds_path, frame_skip=args.frame_skip)
+            print(f'  GIF: {out}')
+
+    elif args.dataset:
+        print(f'Batch rendering: {args.dataset} ({args.num} samples, mode={args.mode})')
+        n = batch_render(args.dataset, output / args.dataset, args.num, args.mode, args.frame_skip)
+        print(f'  Rendered: {n} files → {output / args.dataset}')
+
+    else:
+        # Render all datasets
+        for ds in ['humanml3d', 'lafan1', '100style', 'bandai_namco', 'cmu_mocap', 'mixamo', 'truebones_zoo']:
+            ds_path = project_root / 'data' / 'processed' / ds
+            if not ds_path.exists():
+                continue
+            print(f'Rendering {ds}...')
+            n = batch_render(ds, output / ds, min(args.num, 10), args.mode, args.frame_skip)
+            print(f'  {n} files')
+
+
+if __name__ == '__main__':
+    main()

src/data/__init__.py

@@ -1,2 +0,0 @@
-from .skeleton_graph import SkeletonGraph, normalize_joint_name
-from .bvh_parser import parse_bvh, BVHData, resample_motion, remove_end_sites

src/data/bvh_parser.py

@@ -23,6 +23,7 @@ class BVHData:
     fps: float
     num_frames: int
     rotation_order: str  # e.g., 'ZYX'
+    local_translations: np.ndarray | None = None  # [T, J, 3] per-frame local translations (if available)
 
 
 def parse_bvh(filepath: str | Path) -> BVHData:
@@ -54,15 +55,16 @@ def parse_bvh(filepath: str | Path) -> BVHData:
     fps = 1.0 / frame_time if frame_time > 0 else 30.0
 
     # Extract rotations and root positions from channel data
-    rotations, root_positions = _extract_motion_channels(
-        motion_data, channels_per_joint, len(joint_names)
+    rest_offsets_arr = np.array(rest_offsets, dtype=np.float32)
+    rotations, root_positions, local_translations = _extract_motion_channels(
+        motion_data, channels_per_joint, len(joint_names), rest_offsets_arr
     )
 
     # Build skeleton graph
     skeleton = SkeletonGraph(
         joint_names=joint_names,
         parent_indices=parent_indices,
-        rest_offsets=np.array(rest_offsets, dtype=np.float32),
+        rest_offsets=rest_offsets_arr,
     )
 
     return BVHData(
@@ -72,6 +74,7 @@ def parse_bvh(filepath: str | Path) -> BVHData:
         fps=fps,
         num_frames=num_frames,
         rotation_order=rotation_order,
+        local_translations=local_translations,
     )
 
 
@@ -172,12 +175,24 @@ def _extract_motion_channels(
     motion_data: np.ndarray,
     channels_per_joint: list[tuple[int, bool]],
     num_joints: int,
-) -> tuple[np.ndarray, np.ndarray]:
-    """Extract per-joint rotations and root positions from flat channel data."""
+    rest_offsets: np.ndarray = None,
+) -> tuple[np.ndarray, np.ndarray, np.ndarray | None]:
+    """Extract per-joint rotations, root positions, and local translations.
+
+    Returns:
+        rotations: [T, J, 3] Euler angles
+        root_positions: [T, 3]
+        local_translations: [T, J, 3] or None — per-frame local translations
+            for joints that have position channels. None if only root has positions.
+    """
     T = len(motion_data)
     rotations = np.zeros((T, num_joints, 3), dtype=np.float32)
     root_positions = np.zeros((T, 3), dtype=np.float32)
 
+    # Track which non-root joints have position channels
+    has_per_joint_positions = False
+    joint_has_pos = [False] * num_joints
+
     col = 0
     joint_idx = 0
 
@@ -188,12 +203,15 @@ def _extract_motion_channels(
 
         if has_position and joint_idx == 0:
             # Root joint: extract position (3) + rotation (3)
-            root_positions = motion_data[:, col:col + 3]
+            root_positions = motion_data[:, col:col + 3].copy()
             rotations[:, 0, :] = motion_data[:, col + 3:col + 6]
+            joint_has_pos[0] = True
             col += num_ch
         elif has_position:
-            # Non-root with position (rare but possible)
+            # Non-root with position channels
             rotations[:, joint_idx, :] = motion_data[:, col + 3:col + 6]
+            joint_has_pos[joint_idx] = True
+            has_per_joint_positions = True
             col += num_ch
         else:
             # Rotation only
@@ -202,7 +220,27 @@ def _extract_motion_channels(
 
         joint_idx += 1
 
-    return rotations, root_positions
+    # Build per-joint local translations if any non-root joint has position channels
+    local_translations = None
+    if has_per_joint_positions:
+        local_translations = np.zeros((T, num_joints, 3), dtype=np.float32)
+        # Fill with rest_offsets as default
+        if rest_offsets is not None:
+            for j in range(num_joints):
+                local_translations[:, j, :] = rest_offsets[j]
+        # Overwrite with per-frame position data where available
+        col = 0
+        joint_idx = 0
+        for num_ch, has_position in channels_per_joint:
+            if num_ch == 0:
+                joint_idx += 1
+                continue
+            if has_position and joint_idx > 0:
+                local_translations[:, joint_idx, :] = motion_data[:, col:col + 3]
+            col += num_ch
+            joint_idx += 1
+
+    return rotations, root_positions, local_translations
 
 
 def resample_motion(
@@ -210,9 +248,12 @@ def resample_motion(
     root_positions: np.ndarray,
     source_fps: float,
     target_fps: float = 20.0,
-) -> tuple[np.ndarray, np.ndarray]:
+    local_translations: np.ndarray = None,
+) -> tuple[np.ndarray, np.ndarray] | tuple[np.ndarray, np.ndarray, np.ndarray]:
     """Resample motion to target FPS via linear interpolation."""
     if abs(source_fps - target_fps) < 0.5:
+        if local_translations is not None:
+            return rotations, root_positions, local_translations
         return rotations, root_positions
 
     T_src = len(rotations)
@@ -234,6 +275,14 @@ def resample_motion(
     for d in range(3):
         new_pos[:, d] = np.interp(tgt_times, src_times, root_positions[:, d])
 
+    # Interpolate local translations if present [T, J, 3]
+    if local_translations is not None:
+        new_trans = np.zeros((T_tgt, J, 3), dtype=np.float32)
+        for j in range(J):
+            for d in range(3):
+                new_trans[:, j, d] = np.interp(tgt_times, src_times, local_translations[:, j, d])
+        return new_rots, new_pos, new_trans
+
     return new_rots, new_pos