| |
| """Unpack a 4DCodeBench synthetic world h5 into a plain directory + spec.json. |
| |
| Usage: |
| python unpack_world.py <case.h5> <outdir> |
| |
| Output (our own simplified layout, plain numpy npz): |
| <outdir>/camera.json verbatim from the h5 (intrinsics K 3x3 px, extrinsic E 4x4 cam-to-world) |
| <outdir>/render.mp4 verbatim from the h5 (the reference render) |
| <outdir>/mesh/<id>.npz vertices (F,V,3) f32, faces (F,T,3) i32, nverts/nfaces per frame |
| <outdir>/dyn/<name>.npz pos (F,N,3) f32, ids (M,) u16, faces (T,3) i32 |
| <outdir>/spec.json F, video specs, per-object summary, static/dynamic split |
| """ |
| import argparse |
| import json |
| from pathlib import Path |
|
|
| import numpy as np |
| import h5py |
| import hdf5plugin |
|
|
|
|
| def read_series(group): |
| """Per-frame series stored as (frames + stack) or (frames + flat + lengths).""" |
| frames = group["frames"][()] |
| if "stack" in group: |
| parts = list(group["stack"][()]) |
| else: |
| flat = group["flat"][()] |
| lengths = group["lengths"][()] |
| edges = np.concatenate([[0], np.cumsum(lengths)]) |
| parts = [flat[edges[i]:edges[i + 1]] for i in range(len(frames))] |
| return frames, parts |
|
|
|
|
| def probe_video(path): |
| try: |
| import cv2 |
| cap = cv2.VideoCapture(str(path)) |
| fps = cap.get(cv2.CAP_PROP_FPS) |
| w = int(cap.get(cv2.CAP_PROP_FRAME_WIDTH)) |
| h = int(cap.get(cv2.CAP_PROP_FRAME_HEIGHT)) |
| n = int(cap.get(cv2.CAP_PROP_FRAME_COUNT)) |
| cap.release() |
| if fps and fps > 0 and w > 0: |
| return {"fps": round(float(fps), 6), "width": w, "height": h, "frames": n} |
| except Exception: |
| pass |
| return None |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("h5") |
| ap.add_argument("out") |
| args = ap.parse_args() |
|
|
| out = Path(args.out) |
| (out / "mesh").mkdir(parents=True, exist_ok=True) |
| (out / "dyn").mkdir(parents=True, exist_ok=True) |
|
|
| spec = {"source": str(args.h5)} |
| with h5py.File(args.h5, "r") as h: |
| (out / "camera.json").write_bytes(bytes(h["camera.json"][()])) |
| (out / "render.mp4").write_bytes(bytes(h["render.mp4"][()])) |
| vid = probe_video(out / "render.mp4") or {"fps": 24.0, "width": 1280, "height": 720, "frames": None} |
| spec["video"] = vid |
|
|
| F = int(h[f"dynamics/{next(iter(h['dynamics']))}/pos"].shape[0]) if len(h["dynamics"]) \ |
| else int(h[f"meshes/{next(iter(h['meshes']))}/vertices/frames"].shape[0]) |
| spec["F"] = F |
|
|
| dyn = {} |
| for name in h["dynamics"]: |
| g = h[f"dynamics/{name}"] |
| np.savez_compressed(out / "dyn" / f"{name}.npz", |
| pos=g["pos"][()].astype(np.float32), |
| ids=g["ids"][()].astype(np.uint16), |
| faces=g["faces"][()].astype(np.int32)) |
| dyn[name] = {"ids": [int(i) for i in g["ids"][()]], "N": int(g["pos"].shape[1])} |
| spec["dynamics"] = dyn |
|
|
| dyn_ids = {i for v in dyn.values() for i in v["ids"]} |
| meshes = {} |
| for mid in h["meshes"]: |
| vf, vp = read_series(h[f"meshes/{mid}/vertices"]) |
| ff, fp = read_series(h[f"meshes/{mid}/faces"]) |
| V = max(len(p) for p in vp) |
| T = max(len(p) for p in fp) |
| vert = np.zeros((len(vp), V, 3), np.float32) |
| face = np.zeros((len(fp), T, 3), np.int32) |
| for i, (pv, pf) in enumerate(zip(vp, fp)): |
| vert[i, :len(pv)] = pv |
| face[i, :len(pf)] = pf |
| np.savez_compressed(out / "mesh" / f"{int(mid)}.npz", vertices=vert, faces=face, |
| frames=np.asarray(vf, np.int32), |
| nverts=np.array([len(p) for p in vp], np.int32), |
| nfaces=np.array([len(p) for p in fp], np.int32)) |
| meshes[int(mid)] = {"nverts": int(len(vp[0])), "nfaces": int(len(fp[0])), |
| "static": int(mid) not in dyn_ids} |
| spec["meshes"] = {str(k): v for k, v in sorted(meshes.items())} |
|
|
| cam = json.loads((out / "camera.json").read_text()) |
| K = np.array(cam["intrinsics"], float) |
| spec["camera"] = {"K": K.tolist(), "E": np.array(cam["extrinsic"], float).tolist()} |
|
|
| (out / "spec.json").write_text(json.dumps(spec, indent=1)) |
| print(f"unpacked to {out} | F={spec['F']} | video={vid}") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
