File size: 4,165 Bytes
f91b300 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 | """Release policy for the preview panels.
Previews are a presentation artifact, not part of reproducing the data: they
render a 3-camera + OptiTrack + GelSight panel from the *source* recordings and
need rig-local calibration that the release does not ship. So this module owns
only the release-specific decisions —
* which calibration set belongs to which task (they were recalibrated between
the motherboard and pushT sessions, and using the wrong one silently
misprojects the overlay)
* the trim offset, read from the release sidecar so previews start on the same
frame as the published video
* the per-(task, date) world-frame offset
* the output layout
— and takes the renderer as a parameter. The previous version reached into the
renderer module and reassigned its globals, which meant preview settings could
not be reasoned about without reading both files, and two tasks could not be
rendered in one process.
"""
from __future__ import annotations
from pathlib import Path
from typing import Callable, Iterator
from .config import H5_ROOTS, STAGE_ROOT, WORLD_OFFSET
CALIB_ROOT = Path(__file__).resolve().parent.parent / "calibration"
# The rigs were recalibrated between sessions; each task must use the set that
# was current when it was recorded.
CALIB_DIRS = {
"motherboard": CALIB_ROOT / "result backup", # May 12
"pushT": CALIB_ROOT / "result", # June 26
}
CLIP_SECONDS = 30.0
SPEED = 2.0
def trim_offset(task: str, date: str, episode: str,
stage_root: Path = STAGE_ROOT) -> int:
"""Trim offset for an episode, from its release sidecar (0 if absent)."""
det = Path(stage_root) / task / "meta" / date / f"{episode}._detect.pt"
if not det.exists():
return 0
import torch
meta = torch.load(str(det), weights_only=False, map_location="cpu")
return int(meta["_contact_meta"].get("trim_offset", 0))
def plan(task: str, stage_root: Path = STAGE_ROOT) -> Iterator[dict]:
"""One job per published episode that still has its source recording.
Driven by the published videos rather than by the source tree, so episodes
excluded from the release (e.g. the corrupt pushT recording) do not
reappear here.
"""
stage_root = Path(stage_root)
h5_root = H5_ROOTS[task]
videos = stage_root / task / "videos"
if not videos.exists():
return
for date_dir in sorted(p for p in videos.iterdir() if p.is_dir()):
date = date_dir.name
dx, dy, dz = WORLD_OFFSET.get((task, date), (0.0, 0.0, 0.0))
for ep_dir in sorted(p for p in date_dir.iterdir() if p.is_dir()):
episode = ep_dir.name
h5 = h5_root / date / f"{episode}.h5"
if not h5.exists():
continue
yield {
"task": task, "date": date, "episode": episode,
"h5": h5,
"out": stage_root / task / "previews" / date / f"{episode}.mp4",
"calib_dir": CALIB_DIRS[task],
"trim_offset": trim_offset(task, date, episode, stage_root),
"world_offset": (dx, dy, dz),
}
def build_task(task: str, render: Callable[[dict], None],
stage_root: Path = STAGE_ROOT,
overwrite: bool = False) -> list[dict]:
"""Render every planned preview with the supplied renderer.
``render`` receives one job dict. A failure is recorded against that
episode and the rest continue — one bad recording should not cost the whole
batch.
"""
results = []
for job in plan(task, stage_root):
if job["out"].exists() and not overwrite:
results.append({**job, "status": "SKIP"})
continue
job["out"].parent.mkdir(parents=True, exist_ok=True)
try:
render(job)
size = job["out"].stat().st_size if job["out"].exists() else 0
results.append({**job, "status": "OK", "bytes": size})
except Exception as exc: # noqa: BLE001
results.append({**job, "status": "FAIL",
"error": f"{type(exc).__name__}: {exc}"})
return results
|