scripts/preprocess_humanml3d.py

"""
Preprocess HumanML3D data into TopoSlots unified format.

Input: HumanML3D raw data (new_joints/*.npy, texts/*.txt)
Output: Processed data in data/processed/humanml3d/
  - skeleton.npz: SMPL-22 skeleton graph
  - motions/{motion_id}.npz: per-motion features
  - splits/{train,val,test}.txt: data splits
  - stats.npz: dataset statistics (mean, std)
"""

import sys
import argparse
from pathlib import Path
import numpy as np
from tqdm import tqdm

# Add project root to path
project_root = Path(__file__).parent.parent
sys.path.insert(0, str(project_root))

from src.data.skeleton_graph import SkeletonGraph
from src.data.humanml3d_converter import (
    get_smpl22_skeleton,
    load_humanml3d_motion,
    compute_motion_features,
    extract_rotations_from_263d,
    load_humanml3d_split,
    SMPL_22_JOINT_NAMES,
)


def preprocess_humanml3d(
    raw_dir: str,
    output_dir: str,
    target_fps: float = 20.0,
    max_frames: int = 196,  # ~10s at 20fps
    min_frames: int = 24,   # ~1.2s at 20fps
):
    raw_dir = Path(raw_dir)
    output_dir = Path(output_dir)

    # Create output directories
    (output_dir / 'motions').mkdir(parents=True, exist_ok=True)
    (output_dir / 'splits').mkdir(parents=True, exist_ok=True)

    # 1. Save skeleton graph
    print("Building SMPL-22 skeleton graph...")

    # Compute average rest pose from first 100 motions
    train_ids = load_humanml3d_split(raw_dir, 'train')
    rest_poses = []
    for mid in train_ids[:100]:
        try:
            motion = load_humanml3d_motion(mid, raw_dir)
            rest_poses.append(motion['joint_positions'][0])  # first frame
        except Exception:
            continue

    avg_rest_pose = np.mean(rest_poses, axis=0) if rest_poses else None
    skeleton = get_smpl22_skeleton(avg_rest_pose)

    # Save skeleton
    np.savez(
        output_dir / 'skeleton.npz',
        **skeleton.to_dict(),
    )
    print(f"  Skeleton: {skeleton.num_joints} joints")

    # 2. Process all motions
    all_splits = {}
    for split in ['train', 'val', 'test']:
        try:
            ids = load_humanml3d_split(raw_dir, split)
            all_splits[split] = ids
        except FileNotFoundError:
            print(f"  Warning: {split}.txt not found, skipping")
            all_splits[split] = []

    all_ids = set()
    for ids in all_splits.values():
        all_ids.update(ids)

    print(f"\nProcessing {len(all_ids)} motions...")

    # Collect statistics
    all_local_pos = []
    all_velocities = []
    all_root_vel = []
    processed_count = 0
    skipped_count = 0

    for motion_id in tqdm(sorted(all_ids)):
        try:
            # Load raw motion
            motion = load_humanml3d_motion(motion_id, raw_dir)
            joint_positions = motion['joint_positions']
            T = joint_positions.shape[0]

            # Filter by length
            if T < min_frames:
                skipped_count += 1
                continue
            if T > max_frames:
                joint_positions = joint_positions[:max_frames]

            # Compute position-based features (Scheme C: slot token input)
            features = compute_motion_features(
                joint_positions, skeleton, fps=target_fps
            )

            # Extract rotation-based features from 263D (Scheme C: decoder GT)
            joint_vecs = motion['joint_vecs']
            rot_features = None
            if joint_vecs is not None and joint_vecs.shape[0] == joint_positions.shape[0]:
                rot_features = extract_rotations_from_263d(joint_vecs)

            # Build save dict
            # --- Scheme C layout ---
            # Slot token input: local_positions [T,J,3] + velocities [T,J,3] = 6D per joint
            # Decoder GT: local_rotations_6d [T,J-1,6] (for FK supervision)
            # Root track: root_position [T,3] + root_velocity [T,3]
            # Auxiliary: foot_contact [T,4], bone_lengths [T,J], accelerations [T,J,3]
            save_dict = {
                # Slot token features (cross-skeleton compatible)
                'local_positions': features['local_positions'].astype(np.float32),   # [T, 22, 3]
                'velocities': features['velocities'].astype(np.float32),             # [T, 22, 3]
                # Root trajectory (separate track)
                'root_position': features['root_position'].astype(np.float32),       # [T, 3]
                'root_velocity': features['root_velocity'].astype(np.float32),       # [T, 3]
                # Decoder GT (skeleton-specific, for FK supervision)
                'joint_positions': joint_positions.astype(np.float32),               # [T, 22, 3]
                'accelerations': features['accelerations'].astype(np.float32),       # [T, 22, 3]
                'bone_lengths': features['bone_lengths'].astype(np.float32),         # [T, 22]
                # Auxiliary
                'foot_contact': features['foot_contact'].astype(np.float32),         # [T, 4]
                # Metadata
                'num_frames': joint_positions.shape[0],
                'fps': target_fps,
                'skeleton_id': 'smpl_22',
            }

            # Add rotation data if available (from 263D vector)
            if rot_features is not None:
                save_dict['local_rotations_6d'] = rot_features['local_rotations_6d'].astype(np.float32)  # [T, 21, 6]
                save_dict['foot_contact'] = rot_features['foot_contact_4ch'].astype(np.float32)          # [T, 4] (override with GT)

            # Save texts
            texts = motion['texts']
            save_dict['texts'] = '|||'.join(texts) if texts else ''

            np.savez_compressed(
                output_dir / 'motions' / f'{motion_id}.npz',
                **save_dict,
            )

            # Collect stats (subsample for memory)
            if processed_count % 5 == 0:
                all_local_pos.append(features['local_positions'])
                all_velocities.append(features['velocities'])
                all_root_vel.append(features['root_velocity'])

            processed_count += 1

        except Exception as e:
            print(f"  Error processing {motion_id}: {e}")
            skipped_count += 1

    print(f"\nProcessed: {processed_count}, Skipped: {skipped_count}")

    # 3. Compute and save statistics
    print("Computing dataset statistics...")
    all_local_pos = np.concatenate(all_local_pos, axis=0)  # [N, J, 3]
    all_velocities = np.concatenate(all_velocities, axis=0)
    all_root_vel = np.concatenate(all_root_vel, axis=0)

    stats = {
        'local_pos_mean': all_local_pos.mean(axis=0),
        'local_pos_std': all_local_pos.std(axis=0) + 1e-8,
        'velocity_mean': all_velocities.mean(axis=0),
        'velocity_std': all_velocities.std(axis=0) + 1e-8,
        'root_vel_mean': all_root_vel.mean(axis=0),
        'root_vel_std': all_root_vel.std(axis=0) + 1e-8,
    }

    np.savez(output_dir / 'stats.npz', **stats)

    # 4. Save splits
    for split, ids in all_splits.items():
        # Filter to only processed motions
        valid_ids = [
            mid for mid in ids
            if (output_dir / 'motions' / f'{mid}.npz').exists()
        ]
        with open(output_dir / 'splits' / f'{split}.txt', 'w') as f:
            for mid in valid_ids:
                f.write(f'{mid}\n')
        print(f"  {split}: {len(valid_ids)} motions")

    print(f"\nDone! Output saved to {output_dir}")


if __name__ == '__main__':
    parser = argparse.ArgumentParser()
    parser.add_argument(
        '--raw_dir',
        type=str,
        default='data/raw/HumanML3D',
        help='Path to raw HumanML3D data',
    )
    parser.add_argument(
        '--output_dir',
        type=str,
        default='data/processed/humanml3d',
        help='Output directory',
    )
    parser.add_argument('--target_fps', type=float, default=20.0)
    parser.add_argument('--max_frames', type=int, default=196)
    parser.add_argument('--min_frames', type=int, default=24)

    args = parser.parse_args()
    preprocess_humanml3d(
        args.raw_dir, args.output_dir,
        target_fps=args.target_fps,
        max_frames=args.max_frames,
        min_frames=args.min_frames,
    )