scripts/extract_synthetic.py

#!/usr/bin/env python3
"""Ground-truth depth, flow and tracks of the synthetic cases, from their reference worlds.

Run from the root of the 4DCodeBench code release, after its environment is set up
and `python scripts/download_data.py --kind synthetic` has unpacked the worlds:

    python /path/to/extract_synthetic.py                         # every case under data/synthetic
    python /path/to/extract_synthetic.py B_01 G_03 --out gt      # some cases, another output root

Each case gets `<out>/<case>/` with the same files, keys and timeline as the real
cases' estimates, computed from the world's meshes and camera instead of a model:

    depth.h5     `depth (F', H, W)` float32 camera-space z in metres, `inf` where no
                 surface covers the pixel; `shape [F, H, W]`, `stride`, `fps`
    flow.h5      `flow (F'-1, H, W, 2)` float16 pixels from sampled frame k to k + 1,
                 `valid (F'-1, H, W)` bool, `stride`
    tracks.npz   `tracks (Q, F', 2)` float32 pixels, `visible (Q, F')` bool, the frame-0
                 queries `queries (Q, 3)` `(0, x, y)`, `on_mask`, `shape`, `step`, `stride`

Flow and tracks follow each surface point through the world: by its face and
barycentrics where the object keeps its topology, by the nearest material columns of
`dynamics/` where it does not (a liquid, a fracture). These are the scorer's own
`scorer.analytic` paths, the ones it reads every submission with. The query grid is
the benchmark's: dense on the frame-0 dynamic pixels, sparse over the whole frame.
Files already written are skipped, so an interrupted run resumes by running again.
"""

from __future__ import annotations

import argparse
import sys
import time
from pathlib import Path

import numpy as np


def main() -> None:
    ap = argparse.ArgumentParser(description=__doc__,
                                 formatter_class=argparse.RawDescriptionHelpFormatter)
    ap.add_argument("cases", nargs="*", help="case names (default: every world under --data)")
    ap.add_argument("--code", type=Path, default=Path("."), help="code release root (default: .)")
    ap.add_argument("--data", type=Path, default=None,
                    help="directory of <case>/world (default: <code>/data/synthetic)")
    ap.add_argument("--out", type=Path, default=Path("synthetic"), help="output root")
    args = ap.parse_args()

    sys.path.insert(0, str(args.code.resolve()))
    from config.estimates import DEPTH_FILENAME, FLOW_FILENAME, TRACKS_FILENAME
    from config.sampling import sampled_indices, stride_for
    from scorer.analytic.flow import frame_flow
    from scorer.analytic.tracks import DRIFT, grid_queries, grid_step, inside, track_points
    from scorer.raster import default_device, id_frame, rasterize_frame
    from scorer.storage import write_dense
    from scorer.world import World

    data = args.data or args.code / "data/synthetic"
    cases = args.cases or sorted(p.parent.name for p in data.glob("*/world"))
    device = default_device()

    for number, case in enumerate(cases, 1):
        out = args.out / case
        out.mkdir(parents=True, exist_ok=True)
        world = World(data / case / "world")
        stride = stride_for(world.frames)
        frames = sampled_indices(world.frames, stride)
        height, width = world.shape[1:]
        started = time.time()

        if not (out / DEPTH_FILENAME).exists():
            depth = np.stack([rasterize_frame(world, int(t), device)[0] for t in frames])
            write_dense(out / DEPTH_FILENAME, depth=depth.astype(np.float32),
                        shape=np.asarray(world.shape, dtype=np.int64),
                        stride=np.int64(stride), fps=np.float64(world.fps))

        if not (out / FLOW_FILENAME).exists():
            flows, valids = [], []
            for t in frames[:-1]:
                flow, valid, _ = frame_flow(world, int(t), device, stride=stride)
                flows.append(flow.cpu().numpy().astype(np.float16))
                valids.append(valid.cpu().numpy())
            write_dense(out / FLOW_FILENAME, flow=np.stack(flows), valid=np.stack(valids),
                        stride=np.int64(stride), model="ground_truth")

        if not (out / TRACKS_FILENAME).exists():
            mask = np.isin(id_frame(world, 0, device), world.dynamic_ids)
            mask = mask if mask.any() else None
            queries = grid_queries(height, width, mask=mask)
            on_mask = (inside(queries[:, 1:], mask) if mask is not None
                       else np.zeros(len(queries), dtype=bool))
            step = (grid_step(height, width, max(len(queries) - DRIFT, 1), mask)
                    if mask is not None else grid_step(height, width))
            tracks, visible = track_points(world, queries, device, stride=stride)
            np.savez_compressed(out / TRACKS_FILENAME, tracks=tracks.astype(np.float32),
                                visible=visible, queries=queries.astype(np.float32),
                                on_mask=on_mask,
                                shape=np.asarray([len(frames), height, width], dtype=np.int64),
                                step=np.int64(step), stride=np.int64(stride),
                                model="ground_truth")

        print(f"[{number}/{len(cases)}] {case}: {len(frames)} frames, "
              f"{time.time() - started:.0f}s", flush=True)


if __name__ == "__main__":
    main()