scripts/annotate_motion.py

"""Convert tracked human poses into retargetable dance/contact annotations.

The source clip contains two deliberate foot close-ups. Those frames remain
useful as footwork evidence, but are excluded from full-body imitation. This
script keeps both facts explicit instead of silently treating a cropped body as
a valid pose.
"""

from __future__ import annotations

import argparse
import csv
from dataclasses import dataclass
import json
import math
from pathlib import Path

import cv2
import numpy as np
from scipy.signal import find_peaks, savgol_filter


COCO = {
    "nose": 0,
    "left_shoulder": 5,
    "right_shoulder": 6,
    "left_elbow": 7,
    "right_elbow": 8,
    "left_wrist": 9,
    "right_wrist": 10,
    "left_hip": 11,
    "right_hip": 12,
    "left_knee": 13,
    "right_knee": 14,
    "left_ankle": 15,
    "right_ankle": 16,
}

SKELETON = (
    (5, 6), (5, 7), (7, 9), (6, 8), (8, 10), (5, 11), (6, 12),
    (11, 12), (11, 13), (13, 15), (12, 14), (14, 16),
)

COLORS = ((40, 220, 250), (238, 82, 170))
SHOT_CUT_SECONDS = (9.718, 12.054, 14.264, 15.849)
TARGET_BPM = 111.0


@dataclass(frozen=True)
class Section:
    start: float
    end: float
    name: str
    view: str
    full_body: bool
    note: str


SECTIONS = (
    Section(0.000, 9.718, "front_travel_and_groove", "front", True, "wide full-body shot"),
    Section(9.718, 12.054, "footwork_closeup_a", "cropped", False, "feet retained; hidden body interpolated"),
    Section(12.054, 14.264, "front_reset", "front", True, "wide full-body shot"),
    Section(14.264, 15.849, "footwork_closeup_b", "cropped", False, "feet retained; hidden body interpolated"),
    Section(15.849, 18.500, "turn_away", "turning_away", True, "wide shot; orientation transition"),
    Section(18.500, 27.500, "back_facing_phrase", "back", True, "wide shot"),
    Section(27.500, 29.000, "turn_to_front", "turning_to_front", True, "wide shot; orientation transition"),
    Section(29.000, 34.500, "front_groove_and_stride", "front", True, "wide shot"),
    Section(34.500, 37.250, "low_lunge_kneel", "front", True, "intentional low body level, not a tracking failure"),
    Section(37.250, 39.039, "recovery_finish", "front", True, "rise and finish"),
)


def section_at(time_seconds: float) -> Section:
    for section in SECTIONS:
        if section.start <= time_seconds < section.end:
            return section
    return SECTIONS[-1]


def odd_window(fps: float, seconds: float, size: int) -> int:
    value = min(size if size % 2 else size - 1, max(5, int(round(fps * seconds)) | 1))
    return value if value % 2 else value - 1


def interpolate_smooth(
    values: np.ndarray,
    valid: np.ndarray,
    fps: float,
    seconds: float = 0.25,
) -> np.ndarray:
    """Interpolate invalid observations, then apply zero-phase smoothing."""
    result = np.empty_like(values, dtype=np.float64)
    x = np.arange(len(values), dtype=np.float64)
    for column in range(values.shape[1]):
        usable = valid & np.isfinite(values[:, column])
        if usable.sum() < 2:
            result[:, column] = np.nan_to_num(values[:, column], nan=0.0)
            continue
        filled = np.interp(x, x[usable], values[usable, column])
        window = odd_window(fps, seconds, len(filled))
        result[:, column] = savgol_filter(
            filled,
            window_length=window,
            polyorder=min(3, window - 2),
            mode="interp",
        )
    return result.astype(np.float32)


def midpoint(points: np.ndarray, a: int, b: int) -> np.ndarray:
    return (points[:, :, a] + points[:, :, b]) * 0.5


def angle_at(a: np.ndarray, b: np.ndarray, c: np.ndarray) -> np.ndarray:
    first = a - b
    second = c - b
    dot = np.sum(first * second, axis=-1)
    norm = np.linalg.norm(first, axis=-1) * np.linalg.norm(second, axis=-1)
    return np.arccos(np.clip(dot / np.maximum(norm, 1e-7), -1.0, 1.0)).astype(np.float32)


def finite_diff(values: np.ndarray, fps: float) -> np.ndarray:
    return np.gradient(values, 1.0 / fps, axis=0).astype(np.float32)


def make_full_body_mask(
    keypoints: np.ndarray,
    boxes: np.ndarray,
    fps: float,
    height: int,
) -> tuple[np.ndarray, np.ndarray]:
    times = np.arange(len(keypoints), dtype=np.float32) / fps
    camera_crop = np.zeros(len(keypoints), dtype=bool)
    camera_crop |= (times >= SHOT_CUT_SECONDS[0]) & (times < SHOT_CUT_SECONDS[1])
    camera_crop |= (times >= SHOT_CUT_SECONDS[2]) & (times < SHOT_CUT_SECONDS[3])
    required = [5, 6, 11, 12, 13, 14, 15, 16]
    confidence_ok = np.min(keypoints[:, :, required, 2], axis=2) >= 0.20
    torso_ok = np.mean(keypoints[:, :, [5, 6, 11, 12], 2], axis=2) >= 0.45
    box_ok = ((boxes[:, :, 3] - boxes[:, :, 1]) / float(height)) >= 0.48
    full_body = confidence_ok & torso_ok & box_ok & ~camera_crop[:, None]
    return full_body, camera_crop


def contact_annotations(
    ankle_xy: np.ndarray,
    fps: float,
    camera_crop: np.ndarray,
) -> tuple[np.ndarray, np.ndarray, list[dict]]:
    """Estimate planted feet from image-plane height and velocity.

    These are pseudo-labels for review/retargeting, not force-plate ground truth.
    """
    frame_count, dancers, feet, _ = ankle_xy.shape
    velocity = finite_diff(ankle_xy, fps)
    speed = np.linalg.norm(velocity, axis=-1)
    lower_y = np.max(ankle_xy[..., 1], axis=2, keepdims=True)
    y_gap = np.maximum(0.0, lower_y - ankle_xy[..., 1])
    height_score = np.exp(-np.square(y_gap / 0.045))
    speed_score = np.exp(-np.square(speed / 0.28))
    probability = 0.68 * height_score + 0.32 * speed_score
    for dancer in range(dancers):
        for foot in range(feet):
            window = odd_window(fps, 0.21, frame_count)
            probability[:, dancer, foot] = savgol_filter(
                probability[:, dancer, foot],
                window,
                2,
                mode="interp",
            )
    probability = np.clip(probability, 0.0, 1.0).astype(np.float32)
    state = probability >= 0.66

    events: list[dict] = []
    for dancer in range(dancers):
        for foot, foot_name in enumerate(("left", "right")):
            peaks, props = find_peaks(
                probability[:, dancer, foot],
                height=0.72,
                prominence=0.06,
                distance=max(1, int(round(fps * 0.65))),
            )
            for frame, peak_height in zip(peaks, props["peak_heights"], strict=True):
                events.append({
                    "frame_index": int(frame),
                    "time_seconds": round(float(frame / fps), 6),
                    "dancer_index": dancer,
                    "foot": foot_name,
                    "event": "plant_candidate",
                    "confidence": round(float(peak_height), 6),
                    "evidence": "foot_closeup" if camera_crop[frame] else "full_body",
                })
    events.sort(key=lambda item: (item["frame_index"], item["dancer_index"], item["foot"]))
    return probability, state, events


def draw_pose(
    canvas: np.ndarray,
    points: np.ndarray,
    center: tuple[int, int],
    scale: float,
    color: tuple[int, int, int],
    contacts: np.ndarray,
) -> None:
    pelvis = (points[11] + points[12]) * 0.5
    torso = max(1e-5, float(np.linalg.norm((points[5] + points[6]) * 0.5 - pelvis)))
    display = (points - pelvis) * (scale / torso)
    display[:, 1] *= -1.0
    display += np.asarray(center, dtype=np.float32)
    for a, b in SKELETON:
        pa = tuple(np.round(display[a]).astype(int))
        pb = tuple(np.round(display[b]).astype(int))
        cv2.line(canvas, pa, pb, color, 4, cv2.LINE_AA)
    for joint in (5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16):
        point = tuple(np.round(display[joint]).astype(int))
        cv2.circle(canvas, point, 5, (255, 255, 255), -1, cv2.LINE_AA)
        cv2.circle(canvas, point, 3, color, -1, cv2.LINE_AA)
    for foot, joint in enumerate((15, 16)):
        if contacts[foot]:
            point = tuple(np.round(display[joint]).astype(int))
            cv2.circle(canvas, point, 13, (60, 205, 90), 3, cv2.LINE_AA)


def write_visualization(
    path: Path,
    points: np.ndarray,
    contact_state: np.ndarray,
    camera_crop: np.ndarray,
    fps: float,
) -> list[str]:
    width, height = 960, 540
    writer = cv2.VideoWriter(
        str(path),
        cv2.VideoWriter_fourcc(*"mp4v"),
        fps,
        (width, height),
    )
    if not writer.isOpened():
        raise RuntimeError(f"Could not write {path}")
    example_dir = path.parent
    example_frames = sorted(set(
        int(round(value * fps))
        for value in (1, 5, 10.5, 13, 15, 19, 24, 29, 33, 35.5, 38)
    ))
    examples: list[str] = []
    for frame in range(len(points)):
        time_seconds = frame / fps
        section = section_at(time_seconds)
        canvas = np.full((height, width, 3), (248, 249, 252), dtype=np.uint8)
        cv2.line(canvas, (80, 465), (880, 465), (196, 201, 211), 2, cv2.LINE_AA)
        draw_pose(canvas, points[frame, 0], (285, 280), 105.0, COLORS[0], contact_state[frame, 0])
        draw_pose(canvas, points[frame, 1], (675, 280), 105.0, COLORS[1], contact_state[frame, 1])
        title = (
            f"t={time_seconds:05.2f}s | beat@111={time_seconds * TARGET_BPM / 60.0:05.2f} "
            f"| {section.name}"
        )
        cv2.putText(
            canvas,
            title,
            (24, 36),
            cv2.FONT_HERSHEY_SIMPLEX,
            0.68,
            (37, 42, 54),
            2,
            cv2.LINE_AA,
        )
        cv2.putText(
            canvas,
            "green rings = estimated foot contact",
            (24, 515),
            cv2.FONT_HERSHEY_SIMPLEX,
            0.55,
            (72, 79, 94),
            1,
            cv2.LINE_AA,
        )
        if camera_crop[frame]:
            cv2.rectangle(canvas, (12, 54), (948, 92), (225, 239, 255), -1)
            cv2.putText(
                canvas,
                "CAMERA CROP: feet observed; hidden body interpolated; full-body loss disabled",
                (28, 80),
                cv2.FONT_HERSHEY_SIMPLEX,
                0.59,
                (20, 86, 150),
                2,
                cv2.LINE_AA,
            )
        writer.write(canvas)
        if frame in example_frames:
            filename = f"annotated_{frame:04d}_{section.name}.png"
            cv2.imwrite(str(example_dir / filename), canvas)
            examples.append(filename)
    writer.release()
    return examples


def run(args: argparse.Namespace) -> dict:
    pose_path = args.pose.resolve()
    output_dir = args.output.resolve()
    examples_dir = output_dir / "examples" / "annotated"
    examples_dir.mkdir(parents=True, exist_ok=True)
    data = np.load(pose_path, allow_pickle=True)
    raw = data["keypoints_xyc"].astype(np.float32)
    boxes = data["bbox_xyxy"].astype(np.float32)
    fps = float(data["fps"])
    width = int(data["frame_width"])
    height = int(data["frame_height"])
    track_names = [str(value) for value in data["track_names"]]
    frame_count = len(raw)
    times = np.arange(frame_count, dtype=np.float32) / fps

    full_body_valid, camera_crop = make_full_body_mask(raw, boxes, fps, height)
    smooth = np.empty_like(raw[..., :2])
    for dancer in range(2):
        for joint in range(17):
            usable = (raw[:, dancer, joint, 2] >= 0.20) & full_body_valid[:, dancer]
            smooth[:, dancer, joint] = interpolate_smooth(
                raw[:, dancer, joint, :2],
                usable,
                fps,
            )

    pelvis = midpoint(smooth, 11, 12)
    shoulders = midpoint(smooth, 5, 6)
    torso_length = np.linalg.norm(shoulders - pelvis, axis=-1)
    torso_scale = np.empty_like(torso_length)
    for dancer in range(2):
        torso_scale[:, dancer] = interpolate_smooth(
            torso_length[:, dancer, None],
            full_body_valid[:, dancer],
            fps,
            0.35,
        )[:, 0]
    centered = (
        (smooth - pelvis[:, :, None, :])
        / np.maximum(torso_scale[:, :, None, None], 1e-4)
    )

    knee_flexion = np.stack((
        math.pi - angle_at(smooth[:, :, 11], smooth[:, :, 13], smooth[:, :, 15]),
        math.pi - angle_at(smooth[:, :, 12], smooth[:, :, 14], smooth[:, :, 16]),
    ), axis=2)
    hip_angle = np.stack((
        angle_at(shoulders, smooth[:, :, 11], smooth[:, :, 13]),
        angle_at(shoulders, smooth[:, :, 12], smooth[:, :, 14]),
    ), axis=2)
    shoulder_vector = smooth[:, :, 6] - smooth[:, :, 5]
    torso_vector = shoulders - pelvis
    body_roll = np.arctan2(torso_vector[..., 0], -torso_vector[..., 1]).astype(np.float32)
    shoulder_slope = np.arctan2(
        shoulder_vector[..., 1],
        shoulder_vector[..., 0],
    ).astype(np.float32)
    pelvis_velocity = finite_diff(
        pelvis / np.array((width, height), dtype=np.float32),
        fps,
    )
    body_level = (
        (np.max(smooth[:, :, [15, 16], 1], axis=2) - pelvis[..., 1])
        / np.maximum(torso_scale, 1e-4)
    ).astype(np.float32)

    ankles_norm = (
        smooth[:, :, [15, 16]]
        / np.array((width, height), dtype=np.float32)
    )
    contact_probability, contact_state, events = contact_annotations(
        ankles_norm,
        fps,
        camera_crop,
    )
    for event in events:
        event["track"] = track_names[event["dancer_index"]]
        event["section"] = section_at(event["time_seconds"]).name
        event["target_beat_111bpm"] = round(
            event["time_seconds"] * TARGET_BPM / 60.0,
            6,
        )

    np.savez_compressed(
        output_dir / "motion_features.npz",
        time_seconds=times,
        smoothed_keypoints_xy=smooth,
        pelvis_center_xy=pelvis,
        pelvis_velocity_norm=pelvis_velocity,
        pelvis_centered_keypoints=centered,
        torso_scale_px=torso_scale,
        knee_flexion_rad=knee_flexion,
        hip_angle_rad=hip_angle,
        body_roll_proxy_rad=body_roll,
        shoulder_slope_rad=shoulder_slope,
        body_level_torso_units=body_level,
        foot_contact_probability=contact_probability,
        foot_contact_state=contact_state,
        full_body_valid=full_body_valid,
        camera_crop=camera_crop,
        target_beat_111bpm=times * (TARGET_BPM / 60.0),
        track_names=np.asarray(track_names),
        fps=np.asarray(fps),
    )

    with (output_dir / "motion_features.jsonl").open("w", encoding="utf-8") as stream:
        for frame in range(frame_count):
            section = section_at(float(times[frame]))
            record = {
                "frame_index": frame,
                "time_seconds": round(float(times[frame]), 7),
                "target_beat_111bpm": round(float(times[frame] * TARGET_BPM / 60.0), 7),
                "section": section.name,
                "view": section.view,
                "camera_crop": bool(camera_crop[frame]),
                "tracks": {},
            }
            for dancer, name in enumerate(track_names):
                record["tracks"][name] = {
                    "full_body_valid": bool(full_body_valid[frame, dancer]),
                    "body_roll_proxy_rad": round(float(body_roll[frame, dancer]), 6),
                    "shoulder_slope_rad": round(float(shoulder_slope[frame, dancer]), 6),
                    "body_level_torso_units": round(float(body_level[frame, dancer]), 6),
                    "pelvis_velocity_norm_per_s": [
                        round(float(value), 7)
                        for value in pelvis_velocity[frame, dancer]
                    ],
                    "knee_flexion_rad": [
                        round(float(value), 6)
                        for value in knee_flexion[frame, dancer]
                    ],
                    "hip_angle_rad": [
                        round(float(value), 6)
                        for value in hip_angle[frame, dancer]
                    ],
                    "foot_contact_probability": [
                        round(float(value), 6)
                        for value in contact_probability[frame, dancer]
                    ],
                    "foot_contact_state": [
                        bool(value)
                        for value in contact_state[frame, dancer]
                    ],
                }
            stream.write(json.dumps(record, separators=(",", ":")) + "\n")

    with (output_dir / "step_events.csv").open("w", newline="", encoding="utf-8") as stream:
        fields = (
            "frame_index", "time_seconds", "dancer_index", "track", "foot",
            "event", "confidence", "evidence", "section", "target_beat_111bpm",
        )
        writer = csv.DictWriter(stream, fieldnames=fields)
        writer.writeheader()
        writer.writerows(events)

    sections_payload = [section.__dict__ for section in SECTIONS]
    (output_dir / "motion_sections.json").write_text(
        json.dumps(sections_payload, indent=2),
        encoding="utf-8",
    )
    schema = {
        "schema_version": "1.0",
        "coordinate_convention": {
            "image_xy": "pixels, +x right, +y down",
            "angles": "radians",
            "normalized_pelvis_velocity": "image fraction per second",
        },
        "joint_schema": "COCO-17",
        "contact_semantics": "image-derived pseudo-label; not force-plate ground truth",
        "full_body_valid_semantics": "false frames must not contribute to full-body imitation loss",
        "camera_crop_semantics": "foot observations may remain useful; hidden body landmarks are interpolated",
        "target_music_grid": {
            "song": "Candy",
            "artist": "Cameo",
            "bpm": TARGET_BPM,
            "audio_included": False,
            "note": "tempo grid only; copyrighted recording is not redistributed",
        },
    }
    (output_dir / "annotation_schema.json").write_text(
        json.dumps(schema, indent=2),
        encoding="utf-8",
    )

    examples = write_visualization(
        examples_dir / "annotated_skeleton_contacts.mp4",
        smooth,
        contact_state,
        camera_crop,
        fps,
    )
    event_counts = {
        name: {
            foot: sum(
                1
                for item in events
                if item["track"] == name and item["foot"] == foot
            )
            for foot in ("left", "right")
        }
        for name in track_names
    }
    summary = {
        "schema_version": "1.0",
        "frames": frame_count,
        "fps": fps,
        "duration_seconds": frame_count / fps,
        "camera_cut_seconds": list(SHOT_CUT_SECONDS),
        "camera_crop_frame_count": int(camera_crop.sum()),
        "full_body_valid_fraction": {
            name: round(float(full_body_valid[:, dancer].mean()), 6)
            for dancer, name in enumerate(track_names)
        },
        "step_event_counts": event_counts,
        "target_music_grid_bpm": TARGET_BPM,
        "example_images": examples,
        "limitations": [
            "2D monocular pose has depth and front/back ambiguity.",
            "Foot contacts are pseudo-labels inferred from height and image velocity.",
            "Camera-crop body landmarks are interpolated and excluded from full-body loss.",
            "Music metadata is a tempo grid; no copyrighted song audio is included.",
        ],
    }
    (output_dir / "annotation_summary.json").write_text(
        json.dumps(summary, indent=2),
        encoding="utf-8",
    )
    print(json.dumps(summary, indent=2))
    return summary


def main() -> None:
    parser = argparse.ArgumentParser(description=__doc__)
    parser.add_argument("--pose", type=Path, required=True, help="human_pose_coco17.npz")
    parser.add_argument("--output", type=Path, required=True, help="Derived annotation directory")
    run(parser.parse_args())


if __name__ == "__main__":
    main()