| |
| """Consolidate per-frame Holistic-Multiview-Tracker SMPL-X npz -> ONE per-capture smplx.npz. |
| |
| Source (READ ONLY, produced by the tracker): |
| <DEGAS_DATASET>/<PxCy>/hmt_seq_out/smplx/smplx_<gt_frame:08d>.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 <U.. (T,) fit schedule for that frame ("A+B+C+F" cold / "W" warm) |
| smplx_kwargs <U.. () JSON: exact smplx.SMPLX(...) kwargs to rebuild the model |
| meta <U.. () JSON: capture, n_frames, source, tracker commit, ... |
| |
| `vertices` (10475,3 per frame, ~230 MB per capture) is DERIVED and omitted by default; |
| pass --with-vertices to also emit <out_dir>/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 |
|
|
| DATASET_ROOT = Path("/mnt/sdb/degas_project/DEGAS_DATASET") |
|
|
| |
| PARAM_KEYS = [ |
| "global_orient", "body_pose", "jaw_pose", "leye_pose", "reye_pose", |
| "left_hand_pose", "right_hand_pose", "betas", "expression", "transl", |
| ] |
| EXTRA_KEYS = ["joints"] |
|
|
| |
| 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()) |
|
|
