scripts/dreams_to_actorshq.py

#!/usr/bin/env python
"""Convert one DREAMS-AVATAR capture into an on-disk **ActorsHQ-format** tree.

Goal: an UNMODIFIED ActorsHQ reader -- DEGAS's own `dataset/actorshq_data.py`, or
Synthesia's `actorshq.dataset.camera_data`, or anything else that speaks the
ActorsHQ layout -- can open the result and train, with no knowledge that the data
came from a video bundle.

    huggingface-cli download initialneil/DREAMS-AVATAR --repo-type dataset \
        --local-dir DREAMS-AVATAR
    cd DREAMS-AVATAR
    python scripts/dreams_to_actorshq.py --capture-dir data/P1C1 --out actorshq/P1C1

Needs only numpy + ffmpeg on PATH (torch too, but only for the optional `.pt`).
Subsetting, for a quick look or a smoke train:

    python scripts/dreams_to_actorshq.py --capture-dir data/P1C1 --out actorshq/P1C1 \
        --scale 2x --stride 4 --cams 0 3 6 9 12 15 18 21 --workers 8

OUTPUT TREE
    <out>/
      <scale>/                       e.g. 1x, 2x, 4x  (ActorsHQ calls this the "scale" dir)
        calibration.csv              ActorsHQ calibration, exact column order
        rgbs/Cam001/Cam001_rgb000000.jpg   ...
        masks/Cam001/Cam001_mask000000.png ...
      smplx_dreams.pt                LOSSLESS SMPL-X, full metadata  <- use this one
      smpl_params.npz                float-array-only compat file    <- see CAVEAT below
      dreams_meta.json               what was emitted, and with which conventions

============================== THE CALIBRATION ==============================
ActorsHQ `calibration.csv` (verified against synthesiaresearch/humanrf
`actorshq/dataset/camera_data.py`) is:

    name,w,h,rx,ry,rz,tx,ty,tz,fx,fy,px,py

  * (rx,ry,rz)  axis-angle of the **camera-to-world** rotation.
                  world = R_c2w @ cam + t          (their docstring, verbatim)
  * (tx,ty,tz)  the **camera centre in world space** -- NOT the w2c translation.
  * (fx,fy)     focal length **normalised**: fx_pixels = fx * w, fy_pixels = fy * h
  * (px,py)     principal point **normalised**: cx_pixels = px * w, cy = py * h

DREAMS-AVATAR ships the DEGAS-native rig calibration instead:
`cameras.json` -> rigs[i].cameras[0] with fx,fy,cx,cy in pixels, `R`, and the camera
centre `c`, in a **Y-down** world.  `capture.json["camera_convention"]` fixes the
mapping to the Y-up world the SMPL-X fit lives in:

    A     = diag(1, -1, -1)                    # world_flip, Y-down -> Y-up
    R_w2c = R_json @ A
    t_w2c = -R_json @ c_json

so the ActorsHQ row for camera i is

    R_c2w = R_w2c.T = A @ R_json.T             (A is symmetric and A@A = I)
    rx,ry,rz = Rodrigues(R_c2w)
    tx,ty,tz = -R_w2c.T @ t_w2c = A @ c_json   # centre, moved into the Y-up world
    fx = fx_px / w ;  fy = fy_px / h ;  px = cx_px / w ;  py = cy_px / h

Because the focal/principal are normalised, the SAME csv row is valid at every
`--scale`; only `w` and `h` change.  That is why the scale dir owns its own csv.

Round-trip sanity: DEGAS's reader does `cam.R = Rodrigues(rvec).T ; cam.c = t`, and
its `libcore.Camera.t` property is `-R @ c`.  So it recovers exactly (R_w2c, t_w2c).
`--verify` re-projects the SMPL-X joints through both paths and asserts they agree.

============================== THE IMAGES ==============================
Each `videos/camNN.mp4` is 4096x1500 and holds two things side by side:
LEFT 2048 = matted RGB, RIGHT 2048 = the alpha matte (binary silhouette).  One
ffmpeg pass per camera per half.  ActorsHQ camera `Cam%03d` is 1-based, so DREAMS
`cam00` becomes `Cam001`.  File numbering is the GT frame id, `%06d`, which is the
same number that indexes `smplx.npz` (frame offset d = 0).

============================== THE SMPL-X ==============================
ActorsHQ itself ships **no** SMPL-X; DEGAS reads a registration file next to the
scale dir, chosen by `dataset.smplx_type`, and supports two formats:

  `.pt`   torch.load -> dict.  Non-tensor entries pass through untouched, so the
          model metadata survives.  **This is the lossless path.**  We write
          `smplx_dreams.pt` with gender/model_type/use_pca/flat_hand_mean/
          num_betas(300)/num_expression_coeffs(100) plus every per-frame tensor.
          Config:  `smplx_type: smplx_dreams.pt`

  `.npz`  `dataset/dataset_utils.py:load_smplx_npz` turns EVERY array into a
          tensor and then indexes anything with shape[0] > 1.  A 0-d scalar or a
          string in the npz therefore crashes it, so an npz can only carry the
          per-frame float arrays.  Two consequences, both handled here:
            1. `flat_hand_mean` defaults to True in that loader, but the DREAMS fit
               is flat_hand_mean=False.  We bake the difference in:
                   hand_pose_npz = hand_pose_dreams + hands_mean
               (smplx does `full_pose += pose_mean`, and pose_mean carries
               hands_meanl/r only when flat_hand_mean=False -- so adding the mean
               makes a flat_hand_mean=True model reproduce the same hands).
               Needs `--smplx-model-dir` (reads hands_meanl/hands_meanr straight
               out of SMPLX_NEUTRAL.npz with numpy; the smplx package is not
               imported).
            2. `num_expression_coeffs` cannot be expressed, so the loader would
               build a 10-coefficient model and choke on our (N,100) expression.
               By default `expression` is OMITTED from the npz -- which is also
               what DEGAS's own ActorsHQ configs effectively do
               (`smplx_nofacial: exp+jaw`).  `--npz-expression-coeffs 10` writes
               the leading 10 instead.  Either way the npz is a COMPAT artifact:
               for full fidelity use the .pt.

Row index == frame id.  `load_smplx_npz` indexes the arrays with the raw frame
numbers from `frm_list`, so the arrays are emitted at full length
(max(frame)+1 rows) and rows for frames without a fit are filled with the nearest
preceding fit.  `dreams_meta.json["smplx"]["valid_rows"]` records which are real.
"""
from __future__ import annotations

import argparse
import csv
import json
import shutil
import subprocess
import sys
from concurrent.futures import ProcessPoolExecutor, as_completed
from pathlib import Path

import numpy as np

# --------------------------------------------------------------------------------
# Self-contained copies of the two conventions, so this script can be dropped into
# the published dataset repo and run with nothing but numpy + ffmpeg on PATH.
WORLD_FLIP = np.diag([1.0, -1.0, -1.0])   # cameras.json is Y-down; SMPL-X world is Y-up
VIDEO_FRAME_OFFSET = 0                    # measured per capture by verify_alignment.py

PARAM_KEYS = ("global_orient", "body_pose", "jaw_pose", "leye_pose", "reye_pose",
              "left_hand_pose", "right_hand_pose", "betas", "expression", "transl")

# per-frame arrays that go into the ActorsHQ-compat npz (expression handled separately)
NPZ_KEYS = ("global_orient", "body_pose", "jaw_pose", "leye_pose", "reye_pose",
            "left_hand_pose", "right_hand_pose", "betas", "transl")

CALIB_HEADER = ["name", "w", "h", "rx", "ry", "rz", "tx", "ty", "tz", "fx", "fy", "px", "py"]

SCALES = {"1x": 1, "2x": 2, "4x": 4}


# --------------------------------------------------------------------------- cameras
def load_dreams_cameras(cameras_json: Path) -> list[dict]:
    """cameras.json -> [{K, R_w2c, t_w2c, w, h, info}, ...]; index i == videos/cam{i:02d}.mp4."""
    d = json.loads(cameras_json.read_text())
    out = []
    for rig in d["rigs"]:
        c = rig["cameras"][0]
        K = np.array([[c["fx"], 0.0, c["cx"]],
                      [0.0, c["fy"], c["cy"]],
                      [0.0, 0.0, 1.0]], np.float64)
        R = np.asarray(c["R"], np.float64).reshape(3, 3)
        C = np.asarray(c["c"], np.float64).reshape(3)
        out.append({
            "K": K,
            "R_w2c": R @ WORLD_FLIP,
            "t_w2c": -R @ C,
            "w": int(c["w"]),
            "h": int(c["h"]),
            "info": str(c.get("info", "")),
        })
    return out


def orthonormalize(R: np.ndarray) -> np.ndarray:
    """Nearest true rotation to R (SVD). cameras.json rows are ~1e-7 off orthonormal, and
    axis-angle can only represent an exact rotation, so project before converting."""
    U, _, Vt = np.linalg.svd(R)
    S = np.eye(3)
    S[2, 2] = np.sign(np.linalg.det(U @ Vt))
    return U @ S @ Vt


def rodrigues(R: np.ndarray) -> np.ndarray:
    """Rotation matrix -> axis-angle vector, via a quaternion.

    NOT the textbook `axis = (R - R.T) / (2 sin th)`: that divides by sin(th), so it
    bleeds precision as th approaches pi, and several of these rigs sit there. Measured
    on P1C1 the naive form round-tripped to only 4e-3 (worst camera, and cv2.Rodrigues
    is no better); Shepperd's branch-on-the-largest-diagonal quaternion form round-trips
    to ~1e-15 everywhere.
    """
    R = orthonormalize(np.asarray(R, np.float64))
    m00, m01, m02 = R[0]
    m10, m11, m12 = R[1]
    m20, m21, m22 = R[2]
    tr = m00 + m11 + m22
    if tr > 0.0:
        s = np.sqrt(tr + 1.0) * 2.0
        qw, qx, qy, qz = 0.25 * s, (m21 - m12) / s, (m02 - m20) / s, (m10 - m01) / s
    elif m00 > m11 and m00 > m22:
        s = np.sqrt(1.0 + m00 - m11 - m22) * 2.0
        qw, qx, qy, qz = (m21 - m12) / s, 0.25 * s, (m01 + m10) / s, (m02 + m20) / s
    elif m11 > m22:
        s = np.sqrt(1.0 + m11 - m00 - m22) * 2.0
        qw, qx, qy, qz = (m02 - m20) / s, (m01 + m10) / s, 0.25 * s, (m12 + m21) / s
    else:
        s = np.sqrt(1.0 + m22 - m00 - m11) * 2.0
        qw, qx, qy, qz = (m10 - m01) / s, (m02 + m20) / s, (m12 + m21) / s, 0.25 * s

    q = np.array([qw, qx, qy, qz], np.float64)
    q /= np.linalg.norm(q)
    if q[0] < 0:
        q = -q                      # shortest arc, so |theta| <= pi
    v = q[1:]
    nv = float(np.linalg.norm(v))
    if nv < 1e-15:
        return np.zeros(3)
    theta = 2.0 * np.arctan2(nv, q[0])
    return v / nv * theta


def rodrigues_inv(rvec: np.ndarray) -> np.ndarray:
    """Axis-angle -> rotation matrix (only used by --verify)."""
    theta = float(np.linalg.norm(rvec))
    if theta < 1e-12:
        return np.eye(3)
    k = rvec / theta
    K = np.array([[0, -k[2], k[1]], [k[2], 0, -k[0]], [-k[1], k[0], 0]])
    return np.eye(3) + np.sin(theta) * K + (1 - np.cos(theta)) * (K @ K)


def actorshq_rows(cams: list[dict], cam_ids: list[int], down: int) -> list[list]:
    """ActorsHQ calibration.csv rows, at 1/`down` resolution.

    ALWAYS every camera, even when only a subset is decoded. ActorsHQ readers derive the
    image folder from the ROW INDEX -- DEGAS's is literally
    `cam_sn = 'Cam%03d' % (cam_id + 1)` over `range(len(cams))` -- and ignore the `name`
    column. A csv holding only the decoded cameras would therefore silently shift every
    camera onto the wrong images. Keeping it dense makes row i == DREAMS cam{i:02d} ==
    Cam{i+1:03d}, so a config's 1-based `cam_select` means what it looks like it means.
    Rows for cameras that were not decoded are still correct calibration; the reader only
    touches the ones `cam_select` asks for.
    """
    rows = []
    for i in range(len(cams)):
        c = cams[i]
        R_c2w = c["R_w2c"].T
        centre = -c["R_w2c"].T @ c["t_w2c"]
        rvec = rodrigues(R_c2w)
        w, h = c["w"] // down, c["h"] // down
        rows.append([
            "Cam%03d" % (i + 1), w, h,
            rvec[0], rvec[1], rvec[2],
            centre[0], centre[1], centre[2],
            # normalised -- scale-invariant, so `down` never enters here
            c["K"][0, 0] / c["w"], c["K"][1, 1] / c["h"],
            c["K"][0, 2] / c["w"], c["K"][1, 2] / c["h"],
        ])
    return rows


def write_calibration(rows: list[list], path: Path) -> None:
    path.parent.mkdir(parents=True, exist_ok=True)
    with path.open("w", newline="") as fp:
        w = csv.writer(fp)
        w.writerow(CALIB_HEADER)
        for r in rows:
            w.writerow(r)
    print(f"[calib] {path} ({len(rows)} cameras)", flush=True)


def verify_calibration(cams: list[dict], rows: list[list],
                       joints: np.ndarray, down: int) -> float:
    """Re-project `joints` through cameras.json and through the emitted csv; max |du,dv|."""
    worst = 0.0
    for i, row in enumerate(rows):
        c = cams[i]
        # native path
        x = joints @ c["R_w2c"].T + c["t_w2c"]
        uv_native = (x @ c["K"].T)[:, :2] / x[:, 2:3] / down
        # ActorsHQ path, replayed exactly as DEGAS's reader does it
        rvec = np.array(row[3:6], float)
        R_w2c = rodrigues_inv(rvec).T
        centre = np.array(row[6:9], float)
        t_w2c = -R_w2c @ centre
        w, h = int(row[1]), int(row[2])
        K = np.array([[row[9] * w, 0, row[11] * w],
                      [0, row[10] * h, row[12] * h],
                      [0, 0, 1.0]])
        x2 = joints @ R_w2c.T + t_w2c
        uv_ahq = (x2 @ K.T)[:, :2] / x2[:, 2:3]
        worst = max(worst, float(np.abs(uv_native - uv_ahq).max()))
    return worst


# ---------------------------------------------------------------------------- images
def _select_expr(frames: list[int]) -> str:
    """ffmpeg select expression for a video-frame list; compact for arithmetic runs."""
    v = [f + VIDEO_FRAME_OFFSET for f in frames]
    if len(v) > 1:
        step = v[1] - v[0]
        if step > 0 and all(b - a == step for a, b in zip(v, v[1:])):
            if step == 1:
                return f"between(n\\,{v[0]}\\,{v[-1]})"
            return f"between(n\\,{v[0]}\\,{v[-1]})*not(mod(n-{v[0]}\\,{step}))"
    return "+".join(f"eq(n\\,{n})" for n in v)


def _decode_cam(video: Path, out_root: Path, cam_id: int, frames: list[int],
                rgb_w: int, rgb_h: int, down: int, quality: int, masks: bool) -> tuple[str, int]:
    """Two ffmpeg passes for one camera: LEFT half -> rgbs/, RIGHT half -> masks/."""
    sn = "Cam%03d" % (cam_id + 1)
    sel = _select_expr(frames)
    w, h = rgb_w // down, rgb_h // down
    scale = "" if down == 1 else f",scale={w}:{h}:flags=area"

    img_dir = out_root / "rgbs" / sn
    img_dir.mkdir(parents=True, exist_ok=True)
    tmp = img_dir / "_tmp"
    if tmp.exists():
        shutil.rmtree(tmp)
    tmp.mkdir()
    subprocess.run(
        ["ffmpeg", "-y", "-v", "error", "-threads", "1", "-i", str(video),
         "-vf", f"select='{sel}',crop={rgb_w}:in_h:0:0{scale}", "-vsync", "0",
         "-q:v", str(quality), str(tmp / "%08d.jpg")],
        check=True)
    got = sorted(tmp.glob("*.jpg"))
    if len(got) != len(frames):
        raise RuntimeError(f"{sn}: ffmpeg produced {len(got)} rgb frames, wanted {len(frames)}")
    for src, f in zip(got, frames):
        src.rename(img_dir / f"{sn}_rgb{f:06d}.jpg")
    shutil.rmtree(tmp)

    if masks:
        msk_dir = out_root / "masks" / sn
        msk_dir.mkdir(parents=True, exist_ok=True)
        tmp.mkdir()
        subprocess.run(
            ["ffmpeg", "-y", "-v", "error", "-threads", "1", "-i", str(video),
             "-vf", f"select='{sel}',crop={rgb_w}:in_h:{rgb_w}:0{scale},format=gray",
             "-vsync", "0", "-pix_fmt", "gray", str(tmp / "%08d.png")],
            check=True)
        got = sorted(tmp.glob("*.png"))
        if len(got) != len(frames):
            raise RuntimeError(f"{sn}: ffmpeg produced {len(got)} masks, wanted {len(frames)}")
        for src, f in zip(got, frames):
            src.rename(msk_dir / f"{sn}_mask{f:06d}.png")
        shutil.rmtree(tmp)

    return sn, len(frames)


# ---------------------------------------------------------------------------- smplx
def _dense(arr: np.ndarray, frames: np.ndarray, n_rows: int) -> np.ndarray:
    """Scatter (T,...) fit rows to (n_rows,...) indexed by frame id; gaps hold-forward."""
    out = np.zeros((n_rows, *arr.shape[1:]), arr.dtype)
    filled = np.zeros(n_rows, bool)
    out[frames] = arr
    filled[frames] = True
    last = None
    for i in range(n_rows):
        if filled[i]:
            last = i
        elif last is not None:
            out[i] = out[last]
    if last is None:
        return out
    first = int(frames.min())
    out[:first] = out[first]
    return out


def read_hands_mean(model_dir: Path, gender: str = "neutral") -> tuple[np.ndarray, np.ndarray]:
    """(hands_meanl, hands_meanr) straight out of SMPLX_<GENDER>.npz -- no smplx import."""
    fn = model_dir / f"SMPLX_{gender.upper()}.npz"
    if not fn.exists():
        fn = model_dir / "smplx" / f"SMPLX_{gender.upper()}.npz"
    if not fn.exists():
        raise FileNotFoundError(f"no SMPLX_{gender.upper()}.npz under {model_dir}")
    z = np.load(fn, allow_pickle=True)
    return (np.asarray(z["hands_meanl"], np.float64).reshape(-1),
            np.asarray(z["hands_meanr"], np.float64).reshape(-1))


def write_smplx(z: dict, frames: np.ndarray, out: Path, kwargs: dict,
                smplx_model_dir: Path | None, npz_expr_coeffs: int) -> dict:
    """Write smplx_dreams.pt (lossless) and smpl_params.npz (ActorsHQ compat)."""
    import torch

    n_rows = int(frames.max()) + 1
    note = {}

    # ---- lossless .pt: tensors + the metadata SMPLXOptimizer.init_keys asks for
    pt = {k: torch.from_numpy(_dense(z[k], frames, n_rows).astype(np.float32))
          for k in PARAM_KEYS if k in z}
    pt.update({
        "gender": str(kwargs.get("gender", "neutral")),
        "model_type": str(kwargs.get("model_type", "smplx")),
        "use_pca": bool(kwargs.get("use_pca", False)),
        "flat_hand_mean": bool(kwargs.get("flat_hand_mean", False)),
        "num_betas": int(z["betas"].shape[-1]),
        "num_expression_coeffs": int(z["expression"].shape[-1]) if "expression" in z else 10,
    })
    pt_fn = out / "smplx_dreams.pt"
    torch.save(pt, pt_fn)
    print(f"[smplx] {pt_fn}  ({n_rows} rows, lossless, flat_hand_mean="
          f"{pt['flat_hand_mean']}, num_betas={pt['num_betas']}, "
          f"num_expression_coeffs={pt['num_expression_coeffs']})", flush=True)
    note["pt"] = pt_fn.name

    # ---- ActorsHQ-compat .npz: float arrays only
    npz = {k: _dense(z[k], frames, n_rows).astype(np.float32) for k in NPZ_KEYS if k in z}

    if not bool(kwargs.get("flat_hand_mean", False)):
        if smplx_model_dir is None:
            note["npz_hands"] = "RAW -- no --smplx-model-dir given, hands are WRONG for a " \
                                "flat_hand_mean=True reader"
            print("[smplx][WARN] no --smplx-model-dir: smpl_params.npz hand poses are NOT "
                  "converted to the flat_hand_mean=True convention that load_smplx_npz "
                  "assumes. Use smplx_dreams.pt, or re-run with --smplx-model-dir.",
                  flush=True)
        else:
            ml, mr = read_hands_mean(Path(smplx_model_dir), str(kwargs.get("gender", "neutral")))
            npz["left_hand_pose"] = (npz["left_hand_pose"] + ml).astype(np.float32)
            npz["right_hand_pose"] = (npz["right_hand_pose"] + mr).astype(np.float32)
            note["npz_hands"] = "hands_mean folded in (flat_hand_mean False -> True)"
    else:
        note["npz_hands"] = "already flat_hand_mean=True"

    if npz_expr_coeffs > 0 and "expression" in z:
        npz["expression"] = _dense(z["expression"], frames, n_rows)[:, :npz_expr_coeffs] \
            .astype(np.float32)
        note["npz_expression"] = f"first {npz_expr_coeffs} coefficients"
    else:
        note["npz_expression"] = "omitted (load_smplx_npz cannot carry " \
                                 "num_expression_coeffs; the model would default to 10)"

    npz_fn = out / "smpl_params.npz"
    np.savez(npz_fn, **npz)
    print(f"[smplx] {npz_fn}  (compat: {note['npz_hands']}; expression: "
          f"{note['npz_expression']})", flush=True)
    note["npz"] = npz_fn.name
    note["n_rows"] = n_rows
    note["valid_rows"] = [int(frames.min()), int(frames.max())]
    return note


# ----------------------------------------------------------------------------- main
def main() -> int:
    ap = argparse.ArgumentParser(description=__doc__,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("capture_dir_pos", type=Path, nargs="?", default=None,
                    help=argparse.SUPPRESS)
    ap.add_argument("--capture-dir", type=Path, default=None,
                    help="DREAMS-AVATAR capture dir, e.g. data/P1C1 (may also be positional)")
    ap.add_argument("--out", type=Path, required=True)
    ap.add_argument("--scale", default="2x", choices=sorted(SCALES),
                    help="ActorsHQ scale dir; 2x halves 2048x1500 to 1024x750 (default 2x)")
    ap.add_argument("--cams", type=int, nargs="*", default=None, help="0-based DREAMS cam ids")
    ap.add_argument("--frames", type=int, nargs=2, metavar=("START", "END"), default=None)
    ap.add_argument("--stride", type=int, default=1)
    ap.add_argument("--workers", type=int, default=4)
    ap.add_argument("--quality", type=int, default=2, help="ffmpeg -q:v for the jpgs")
    ap.add_argument("--no-masks", action="store_true")
    ap.add_argument("--no-images", action="store_true", help="calibration + SMPL-X only")
    ap.add_argument("--smplx-model-dir", type=Path, default=None,
                    help="dir holding SMPLX_NEUTRAL.npz; needed to fold hands_mean into "
                         "smpl_params.npz")
    ap.add_argument("--npz-expression-coeffs", type=int, default=0,
                    help="how many expression coefficients to put in smpl_params.npz "
                         "(0 = omit; >10 will break an unmodified reader)")
    ap.add_argument("--verify", action="store_true",
                    help="re-project SMPL-X joints through cameras.json and through the "
                         "emitted csv and report the worst pixel disagreement")
    ap.add_argument("--verify-tol", type=float, default=1e-3,
                    help="px; the floor is cameras.json's ~1e-7 orthonormality defect, "
                         "which axis-angle has to project away (default 1e-3)")
    a = ap.parse_args()

    cap = a.capture_dir if a.capture_dir is not None else a.capture_dir_pos
    if cap is None:
        raise SystemExit("give the capture dir, either positionally or with --capture-dir")
    for need in ("cameras.json", "smplx.npz"):
        if not (cap / need).exists():
            raise SystemExit(f"{cap} is not a DREAMS-AVATAR capture dir (no {need}). "
                             f"After `huggingface-cli download initialneil/DREAMS-AVATAR "
                             f"--repo-type dataset --local-dir DREAMS-AVATAR` the captures "
                             f"live at DREAMS-AVATAR/data/<PxCy>/.")
    down = SCALES[a.scale]
    out = a.out
    scale_dir = out / a.scale
    scale_dir.mkdir(parents=True, exist_ok=True)

    cams = load_dreams_cameras(cap / "cameras.json")
    card = json.loads((cap / "capture.json").read_text()) if (cap / "capture.json").exists() else {}

    z = dict(np.load(cap / "smplx.npz", allow_pickle=False))
    frames_all = z["frames"].astype(int)
    kwargs = json.loads(str(z["smplx_kwargs"])) if "smplx_kwargs" in z else {}

    cam_ids = a.cams if a.cams is not None else list(range(len(cams)))
    bad = [i for i in cam_ids if not (0 <= i < len(cams))]
    if bad:
        raise SystemExit(f"camera ids out of range: {bad} (capture has {len(cams)})")

    frames = frames_all
    if a.frames is not None:
        frames = frames[(frames >= a.frames[0]) & (frames <= a.frames[1])]
    frames = frames[::a.stride]
    frame_list = [int(f) for f in frames]
    if not frame_list:
        raise SystemExit("no frames selected")

    print(f"[dreams->actorshq] {cap.name}: {len(cam_ids)} cams x {len(frame_list)} frames "
          f"-> {out} (scale {a.scale}, {cams[0]['w'] // down}x{cams[0]['h'] // down})",
          flush=True)

    rows = actorshq_rows(cams, cam_ids, down)
    write_calibration(rows, scale_dir / "calibration.csv")

    reproj_err = None
    if a.verify:
        j = z["joints"][int(np.searchsorted(frames_all, frame_list[len(frame_list) // 2]))]
        reproj_err = verify_calibration(cams, rows, j.astype(np.float64), down)
        print(f"[verify] cameras.json vs calibration.csv reprojection: "
              f"max |delta| = {reproj_err:.3e} px  (tol {a.verify_tol:g})", flush=True)
        if reproj_err > a.verify_tol:
            raise SystemExit(f"calibration round-trip failed ({reproj_err:.3e} px)")

    smplx_note = write_smplx(z, frames_all, out, kwargs, a.smplx_model_dir,
                             a.npz_expression_coeffs)

    n_done = 0
    if not a.no_images:
        jobs = []
        with ProcessPoolExecutor(max_workers=a.workers) as ex:
            for i in cam_ids:
                jobs.append(ex.submit(_decode_cam, cap / "videos" / f"cam{i:02d}.mp4",
                                      scale_dir, i, frame_list,
                                      cams[i]["w"], cams[i]["h"], down,
                                      a.quality, not a.no_masks))
            for fut in as_completed(jobs):
                sn, n = fut.result()
                n_done += 1
                print(f"[decode] {sn}: {n} frames  ({n_done}/{len(cam_ids)})", flush=True)

    meta = {
        "source_capture": str(cap),
        "capture": cap.name,
        "format": "ActorsHQ",
        "scale": a.scale,
        "downscale": down,
        "width": cams[0]["w"] // down,
        "height": cams[0]["h"] // down,
        "n_cameras_in_calibration": len(cams),
        "cam_ids_decoded_dreams": cam_ids,
        "cam_names_decoded_actorshq": ["Cam%03d" % (i + 1) for i in cam_ids],
        "cam_select_hint_1based": [i + 1 for i in cam_ids],
        "frames": {"n": len(frame_list), "first": frame_list[0], "last": frame_list[-1],
                   "stride": a.stride},
        "frame_convention": card.get("frame_convention", {"offset_d": VIDEO_FRAME_OFFSET}),
        "calibration": {
            "file": f"{a.scale}/calibration.csv",
            "columns": CALIB_HEADER,
            "rotation": "axis-angle of R_cam2world",
            "translation": "camera centre in world space",
            "focal": "normalised by (w, h)",
            "principal_point": "normalised by (w, h)",
            "world": "Y-up (cameras.json world_flip diag(1,-1,-1) applied)",
            "reprojection_max_px_vs_cameras_json": reproj_err,
        },
        "images": {
            "rgb": f"{a.scale}/rgbs/Cam%03d/Cam%03d_rgb%06d.jpg",
            "mask": None if a.no_masks else f"{a.scale}/masks/Cam%03d/Cam%03d_mask%06d.png",
            "note": "rgb is the LEFT half of camNN.mp4, mask is the RIGHT half (alpha matte)",
        },
        "smplx": {**smplx_note, "smplx_kwargs": kwargs},
        "degas_config_hint": {
            "frameset_type": "actorshq",
            "scale": a.scale,
            "smplx_type": "smplx_dreams.pt",
            "resolution": 1,
        },
    }
    (out / "dreams_meta.json").write_text(json.dumps(meta, indent=2) + "\n")
    print(f"[done] {out}", flush=True)
    return 0


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