#!/usr/bin/env python """Consolidate per-frame Holistic-Multiview-Tracker SMPL-X npz -> ONE per-capture smplx.npz. Source (READ ONLY, produced by the tracker): //hmt_seq_out/smplx/smplx_.npz Each per-frame file holds unbatched arrays: global_orient(3) body_pose(63) jaw_pose(3) leye_pose(3) reye_pose(3) left_hand_pose(45) right_hand_pose(45) betas(300) expression(100) transl(3) vertices(10475,3) joints(144,3) view_ids(V,) gt_frame() n_face_views() stages() Output `smplx.npz` stacks every parameter over time, LOSSLESSLY (identical dtypes, no downcast, no re-quantisation) and adds an explicit frame index: frames int32 (T,) frame id, == the number in the source filename video_frames int32 (T,) == frames (offset d=0; kept as an explicit column so a reader never has to remember whether an offset applies) global_orient float32 (T,3) body_pose float32 (T,63) jaw_pose float32 (T,3) leye_pose float32 (T,3) reye_pose float32 (T,3) left_hand_pose float32 (T,45) axis-angle, use_pca=False right_hand_pose float32 (T,45) axis-angle, use_pca=False betas float32 (T,300) expression float32 (T,100) transl float32 (T,3) joints float32 (T,144,3) SMPL-X joints in world frame (derived, shipped for convenience) view_ids int16 (T,Vmax) camera indices actually used at that frame, -1 padded n_views int16 (T,) n_face_views int16 (T,) stages /smplx_vertices.npz. Usage: python consolidate_smplx.py P1C1 --out /path/to/staging/data/P1C1/smplx.npz """ from __future__ import annotations import argparse import json import sys from pathlib import Path import numpy as np sys.path.insert(0, str(Path(__file__).resolve().parent)) from load_capture import VIDEO_FRAME_OFFSET # noqa: E402 single source of truth for d DATASET_ROOT = Path("/mnt/sdb/degas_project/DEGAS_DATASET") # Params that are stacked over time. Order is the SMPL-X forward() kwarg order. PARAM_KEYS = [ "global_orient", "body_pose", "jaw_pose", "leye_pose", "reye_pose", "left_hand_pose", "right_hand_pose", "betas", "expression", "transl", ] EXTRA_KEYS = ["joints"] # Locked by the tracker (configs/degas.yaml + hmt/smplx_builder.py LOCKED_KWARGS). SMPLX_KWARGS = dict( model_type="smplx", gender="neutral", use_pca=False, num_betas=300, num_expression_coeffs=100, use_face_contour=True, flat_hand_mean=False, create_global_orient=False, create_body_pose=False, create_betas=False, create_left_hand_pose=False, create_right_hand_pose=False, create_jaw_pose=False, create_leye_pose=False, create_reye_pose=False, create_expression=False, create_transl=False, ) def consolidate(capture: str, dataset_root: Path, out_path: Path, with_vertices: bool = False, verify: bool = True) -> dict: seq = dataset_root / capture / "hmt_seq_out" / "smplx" files = sorted(seq.glob("smplx_*.npz")) if not files: raise SystemExit(f"no per-frame npz under {seq}") frames = np.array([int(f.stem.split("_")[1]) for f in files], np.int32) T = len(files) print(f"[consolidate] {capture}: {T} frames, GT {frames[0]}..{frames[-1]}", flush=True) acc: dict[str, list] = {k: [] for k in PARAM_KEYS + EXTRA_KEYS} view_ids, n_face, stages, verts = [], [], [], [] for i, f in enumerate(files): z = np.load(f, allow_pickle=False) for k in PARAM_KEYS + EXTRA_KEYS: acc[k].append(z[k]) view_ids.append(np.asarray(z["view_ids"], np.int16)) n_face.append(int(z["n_face_views"])) stages.append(str(z["stages"])) if with_vertices: verts.append(z["vertices"]) assert int(z["gt_frame"]) == int(frames[i]), f"{f}: gt_frame != filename" if (i + 1) % 500 == 0: print(f" .. {i + 1}/{T}", flush=True) vmax = max(len(v) for v in view_ids) vids = np.full((T, vmax), -1, np.int16) for i, v in enumerate(view_ids): vids[i, :len(v)] = v out = {k: np.stack(acc[k]) for k in PARAM_KEYS + EXTRA_KEYS} out["frames"] = frames out["video_frames"] = (frames + VIDEO_FRAME_OFFSET).astype(np.int32) out["view_ids"] = vids out["n_views"] = np.array([len(v) for v in view_ids], np.int16) out["n_face_views"] = np.asarray(n_face, np.int16) out["stages"] = np.asarray(stages) out["smplx_kwargs"] = np.asarray(json.dumps(SMPLX_KWARGS)) out["meta"] = np.asarray(json.dumps({ "capture": capture, "n_frames": T, "frame_first": int(frames[0]), "frame_last": int(frames[-1]), "video_frame_offset": VIDEO_FRAME_OFFSET, "note": ("video frame index = frame + %d; d=0 is measured (verify_alignment.py), " "not assumed, and is uniform across all captures" % VIDEO_FRAME_OFFSET), "source": "Holistic-Multiview-Tracker run_degas_sequence.py (branch reusable-v0.2.0)", "world_frame": "Y-up; cameras.json world is Y-down -> world_flip=diag(1,-1,-1)", })) out_path.parent.mkdir(parents=True, exist_ok=True) np.savez_compressed(out_path, **out) mb = out_path.stat().st_size / 2**20 print(f"[consolidate] wrote {out_path} ({mb:.1f} MB)", flush=True) if with_vertices: vp = out_path.with_name("smplx_vertices.npz") np.savez_compressed(vp, frames=frames, vertices=np.stack(verts)) print(f"[consolidate] wrote {vp} ({vp.stat().st_size / 2**20:.1f} MB)", flush=True) if verify: _verify(out_path, files, frames) return {"capture": capture, "n_frames": T, "bytes": out_path.stat().st_size, "gt_first": int(frames[0]), "gt_last": int(frames[-1]), "n_views_max": int(vmax)} def _verify(out_path: Path, files: list[Path], frames: np.ndarray) -> None: """Bit-exact round-trip check on a random sample of frames.""" z = np.load(out_path, allow_pickle=False) rng = np.random.default_rng(0) idx = rng.choice(len(files), size=min(25, len(files)), replace=False) for i in idx: src = np.load(files[int(i)], allow_pickle=False) for k in PARAM_KEYS + EXTRA_KEYS: a, b = src[k], z[k][int(i)] if a.dtype != b.dtype or not np.array_equal(a, b): raise SystemExit(f"LOSSY: frame {frames[i]} key {k} mismatch") print(f"[consolidate] verify OK: {len(idx)} random frames bit-identical to source", flush=True) def main() -> int: ap = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) ap.add_argument("capture", help="e.g. P1C1") ap.add_argument("--dataset-root", type=Path, default=DATASET_ROOT) ap.add_argument("--out", type=Path, required=True, help="output smplx.npz path") ap.add_argument("--expect-first-frame", type=int, default=None, help="assert the first source frame id equals this. Guards against " "consolidating a capture whose per-frame npz have not been " "relabelled to the d=0 convention (P1C1 shipped as 1..N once).") ap.add_argument("--with-vertices", action="store_true", help="also write smplx_vertices.npz (~200 MB/capture)") ap.add_argument("--no-verify", action="store_true") a = ap.parse_args() if a.expect_first_frame is not None: seq = a.dataset_root / a.capture / "hmt_seq_out" / "smplx" first = sorted(seq.glob("smplx_*.npz")) if not first: raise SystemExit(f"no per-frame npz under {seq}") got = int(first[0].stem.split("_")[1]) if got != a.expect_first_frame: raise SystemExit( f"REFUSING: {a.capture} first frame is {got}, expected " f"{a.expect_first_frame}. The source has not been relabelled to d=0 yet.") info = consolidate(a.capture, a.dataset_root, a.out, a.with_vertices, not a.no_verify) print(json.dumps(info)) return 0 if __name__ == "__main__": sys.exit(main())