scripts/verify_alignment.py

#!/usr/bin/env python
"""Measure the video<->SMPL-X frame offset EMPIRICALLY. Never assume it.

Why this exists
    The DEGAS captures were first tracked assuming `GT frame = video frame + 1`. That
    offset had been measured on a near-static frame, where every candidate looks alike,
    and it was wrong. A one-frame error is nearly invisible in a still overlay but
    poisons every downstream avatar. So the offset is now MEASURED, on motion, before a
    capture is published.

Method (needs no SMPL-X model, only what the dataset ships)
    The discriminating signal is the FAST-MOVING HAND against the ALPHA MATTE.
    A forearm is only ~40-80 px wide, and during a gesture the wrist moves tens of px
    per frame, so a projected wrist lands inside the silhouette at the correct offset and
    outside it one frame away. Slow signals (body centroid) cannot resolve +-1 frame and
    will happily report nonsense with a margin of ~0.01; that weak-signal trap is exactly
    what produced the original wrong +1, so this script refuses to answer when the margin
    is small.

    1. Rank fit frames by projected 2D WRIST SPEED; keep the fastest ones.
    2. Decode a contiguous low-res window of the ALPHA half (right 2048) of each camera.
    3. For each candidate offset d, measure the fraction of hand/wrist joints that land
       on foreground at video frame (fit_frame + d).
    4. Report argmax, plus the margin. A margin below --min-margin is INCONCLUSIVE and
       exits non-zero rather than guessing.

Usage
    # ARGUMENT IS A CAPTURE DIRECTORY (the one holding cameras.json), not a bare name.
    python verify_alignment.py /path/to/staging/data/P2C1 --expect 0
    python verify_alignment.py P2C1 --expect 0     # bare name -> resolved under --staging

    The probe window is chosen AUTOMATICALLY (highest hand motion, cheap: it uses the
    shipped joints, no decoding) unless --start is given. Passing a hand-picked --start
    is how you land on a static stretch and get an unresolvable answer.
"""
from __future__ import annotations

import argparse
import subprocess
import sys
from pathlib import Path

import numpy as np

sys.path.insert(0, str(Path(__file__).resolve().parent))
from load_capture import Capture  # noqa: E402


# SMPL-X joint indices that move fastest and sit on THIN geometry, which is what makes
# a one-frame error visible: wrists + both hands' finger joints.
HAND_JOINTS = np.r_[20, 21, np.arange(25, 55)]

DEFAULT_STAGING = Path("/mnt/sdb/degas_project/DREAMS-AVATAR-hf/staging/data")


def resolve_capture_dir(arg: str, staging: Path) -> Path:
    """Accept a real directory OR a bare capture name like 'P2C1'.

    The bare-name form exists because passing 'P3C1' where a path was wanted is an easy
    mistake that fails late and confusingly ('FileNotFoundError: P3C1/cameras.json'),
    which reads like a misalignment rather than a bad argument.
    """
    p = Path(arg)
    if (p / "cameras.json").is_file():
        return p
    cand = staging / arg
    if (cand / "cameras.json").is_file():
        return cand
    raise SystemExit(
        f"no cameras.json found.\n"
        f"  tried: {p / 'cameras.json'}\n"
        f"  tried: {cand / 'cameras.json'}\n"
        f"Pass the capture DIRECTORY (the one containing cameras.json / smplx.npz / "
        f"videos/), or a bare capture name resolvable under --staging.")


def pick_window(cap: Capture, cam: str, frames: list[int], count: int,
                lo: int, hi: int, search_limit: int) -> list[int]:
    """Choose the highest-hand-motion window that is fully decodable.

    Uses only the shipped joints, so it costs no video decoding. Constraints:
      * every probed frame f must satisfy 0 <= f+lo and f+hi <= last frame, so the
        candidate offsets all have a real video frame to look at (captures start at
        frame 0, so a naive window would ask for negative video indices);
      * the window starts within `search_limit` frames of the beginning, to bound how
        much video has to be decoded to reach it.
    """
    first, last = frames[0], frames[-1]
    usable = [f for f in frames if f + lo >= 0 and f + hi <= last]
    if not usable:
        raise SystemExit(f"capture too short for lags {lo}..{hi}")
    count = min(count, len(usable))
    spd = hand_speed(cap, cam, usable)
    k = np.cumsum(np.r_[0.0, spd])
    n_start = len(usable) - count + 1
    limit = max(1, min(n_start, search_limit - (usable[0] - first) + 1))
    tot = k[count:count + limit] - k[:limit]
    i = int(np.argmax(tot))
    return usable[i:i + count]


def decode_alpha_window(video: Path, v_start: int, count: int, src_w: int, src_h: int,
                        scale: float = 0.25) -> tuple[np.ndarray, float]:
    """(n, h, w) uint8 stack of the ALPHA half, downscaled by `scale`.

    `n` is whatever ffmpeg actually produced, which can be fewer than `count` when the
    window runs past the end of the video. The frame size is derived from the source
    dimensions rather than inferred from the byte count, so a short read is detected as a
    short read instead of silently reshaping into the wrong geometry.
    """
    w = int(round(src_w / 2 * scale))
    h = int(round(src_h * scale))
    vf = (f"select='between(n\\,{v_start}\\,{v_start + count - 1})',"
          f"crop=iw/2:ih:iw/2:0,scale={w}:{h},format=gray")
    proc = subprocess.run(
        ["ffmpeg", "-v", "error", "-threads", "1", "-i", str(video),
         "-vf", vf, "-vsync", "0", "-f", "rawvideo", "-pix_fmt", "gray", "-"],
        capture_output=True, check=True)
    buf = np.frombuffer(proc.stdout, np.uint8)
    if len(buf) % (w * h):
        raise RuntimeError(f"{video.name}: raw size {len(buf)} not a multiple of {w}x{h}")
    n = len(buf) // (w * h)
    if n == 0:
        raise RuntimeError(f"{video.name}: decoded 0 frames from {v_start}")
    return buf.reshape(n, h, w), scale


def hand_speed(cap: Capture, cam: str, frames: list[int]) -> np.ndarray:
    """Mean projected 2D speed of the hand joints, px/frame, per fit frame."""
    c = cap.cameras[cam]
    uv = np.stack([c.project(cap.joints(f)[HAND_JOINTS]) for f in frames])
    d = np.linalg.norm(np.diff(uv, axis=0), axis=2).mean(1)
    return np.r_[d[0], d]


def hit_rate(cap: Capture, cam: str, probe: list[int], stack: np.ndarray, scale: float,
             v_first: int, offsets: range) -> dict[int, float]:
    """For each offset d: fraction of hand joints landing on foreground alpha."""
    c = cap.cameras[cam]
    n, h, w = stack.shape
    out = {}
    for d in offsets:
        hits, tot = 0, 0
        for f in probe:
            idx = (f + d) - v_first
            if not (0 <= idx < n):
                continue
            m = stack[idx] > 12
            uv = c.project(cap.joints(f)[HAND_JOINTS]) * scale
            u = np.round(uv[:, 0]).astype(int)
            v = np.round(uv[:, 1]).astype(int)
            ok = (u >= 0) & (u < w) & (v >= 0) & (v < h)
            if not ok.any():
                continue
            hits += int(m[v[ok], u[ok]].sum())
            tot += int(ok.sum())
        out[d] = hits / tot if tot else float("nan")
    return out


def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("capture_dir", help="capture DIR (holding cameras.json), or a bare name")
    ap.add_argument("--staging", type=Path, default=DEFAULT_STAGING,
                    help="where a bare capture name is resolved")
    ap.add_argument("--cams", type=int, nargs="*", default=[6, 12])
    ap.add_argument("--start", type=int, default=None,
                    help="force the window start; default = auto-pick highest motion")
    ap.add_argument("--search-limit", type=int, default=600,
                    help="auto-pick searches windows starting within this many frames")
    ap.add_argument("--count", type=int, default=250)
    ap.add_argument("--lags", type=int, nargs=2, default=[-3, 3])
    ap.add_argument("--n-probe", type=int, default=40,
                    help="how many of the fastest-hand frames to score")
    ap.add_argument("--min-margin", type=float, default=0.05,
                    help="required hit-rate gap to the runner-up; below this = INCONCLUSIVE")
    ap.add_argument("--expect", type=int, default=None,
                    help="fail (exit 1) if the measured offset differs from this")
    a = ap.parse_args()

    cdir = resolve_capture_dir(a.capture_dir, a.staging)
    cap = Capture(cdir)
    print(f"{cap}\n  dir: {cdir}")
    lo, hi = a.lags
    all_frames = [int(f) for f in cap.frames]
    cam0 = f"cam{a.cams[0]:02d}"

    if a.start is not None:
        frames = [f for f in all_frames if f >= a.start and f + lo >= 0
                  and f + hi <= all_frames[-1]][:a.count]
        if not frames:
            raise SystemExit(f"--start {a.start} leaves no decodable frames")
    else:
        frames = pick_window(cap, cam0, all_frames, a.count, lo, hi, a.search_limit)
    print(f"window: fit frames {frames[0]}..{frames[-1]} ({len(frames)})"
          f"{'' if a.start is not None else '  [auto-picked: highest hand motion]'}")

    spd = hand_speed(cap, cam0, frames)
    order = np.argsort(-spd)[:a.n_probe]
    probe = sorted(frames[i] for i in order)
    print(f"hand speed in window: median {np.median(spd):.1f} px/frame, "
          f"probe frames use {spd[order].min():.1f}..{spd[order].max():.1f} px/frame")
    if spd[order].min() < 3.0:
        print("WARNING: probe frames are slow; +-1 frame may be unresolvable here")

    v_first = frames[0] + lo
    assert v_first >= 0, f"window start {frames[0]} with lag {lo} needs video frame {v_first}"
    n_dec = min(len(frames) + (hi - lo) + 1, all_frames[-1] - v_first + 1)
    src_w, src_h = cap.card["video"]["width"], cap.card["video"]["height"]
    print(f"decoding alpha window: video frames {v_first}..{v_first + n_dec - 1}")

    per_cam = {}
    for ci in a.cams:
        cam = f"cam{ci:02d}"
        stack, scale = decode_alpha_window(cap.video_dir / f"{cam}.mp4", v_first, n_dec,
                                           src_w, src_h)
        r = hit_rate(cap, cam, probe, stack, scale, v_first, range(lo, hi + 1))
        per_cam[cam] = r
        best = max(r, key=r.get)
        print(f"  {cam} ({stack.shape[2]}x{stack.shape[1]}): "
              + "  ".join(f"d={k:+d}:{v:.3f}" for k, v in sorted(r.items()))
              + f"   -> best d={best:+d}")

    total = {}
    for r in per_cam.values():
        for k, v in r.items():
            total[k] = total.get(k, 0.0) + v / len(per_cam)
    ranked = sorted(total.items(), key=lambda kv: -kv[1])
    best, margin = ranked[0][0], ranked[0][1] - ranked[1][1]
    print("\nhand-on-silhouette hit rate by offset: "
          + "  ".join(f"d={k:+d}:{v:.3f}" for k, v in sorted(total.items())))
    print(f"MEASURED: video_frame = fit_frame + ({best:+d})  "
          f"(margin over d={ranked[1][0]:+d}: {margin:.3f})")

    if margin < a.min_margin:
        print(f"INCONCLUSIVE: margin {margin:.3f} < --min-margin {a.min_margin}. "
              f"This window cannot resolve the offset; do NOT act on it. "
              f"Retry on a higher-motion window or more cameras.")
        return 2
    if a.expect is not None:
        if best != a.expect:
            print(f"FAIL: expected {a.expect:+d}, measured {best:+d}")
            return 1
        print(f"PASS: matches expected {a.expect:+d}")
    return 0


if __name__ == "__main__":
    sys.exit(main())