Upload multiview.py with huggingface_hub

multiview.py

@@ -0,0 +1,407 @@
+#!/venv/main/bin/python3
+"""
+multiview.py — synthesize teleop-style 3-camera views for the retargeted
+LeRobot v2.1 dataset (method A': keypoint-guided crops), writing the videos
+STRAIGHT INTO the dataset's videos/ tree so it slots in on the go.
+
+LOCKED conventions (per user, 2026-07-24):
+  observation.images.top         = full egocentric frame, square center-crop -> 224
+  observation.images.left_wrist  = zoom crop tracking the human LEFT-hand grasp point
+  observation.images.right_wrist = zoom crop tracking the human RIGHT-hand grasp point
+  L/R is ANATOMICAL / as-is: rightThumbTip.. -> right_wrist ; leftThumbTip.. -> left_wrist.
+  BOTH wrist views are ALWAYS rendered (both viewpoints must be present) — each
+  crop tracks its hand's grasp point every frame; only when a hand genuinely
+  leaves the image does crop_at zero-pad that region. No forced all-black views.
+
+Output matches abc-teleop EXACTLY: 224x224, h264, yuv420p, 30 fps.
+
+Episode E (v2.1) -> EgoDex source (category, file-YYY), reconstructed with the
+same ordering to_lerobot_v21.discover() used (sort by category, file index):
+  keypoints/intrinsics/pose <- /workspace/ego/<cat>/data/chunk-*/file-YYY.parquet
+  frames                    <- /workspace/ego/<cat>/videos/observation.images.camera/chunk-*/file-YYY.mp4
+Frames 0..T-1 (T = episode length) are prefix-aligned t=0 — verified 1:1 with the
+already-shipped observation.images.camera (parquet_rows == video_frames == T).
+
+Resumable (results.jsonl = source of truth, carries per-episode image stats used
+by finalize_multiview.py), logged (--log tees to <ds>/multiview.log), pooled.
+
+Usage:
+  /venv/main/bin/python3 multiview.py --ds /workspace/retargeted_lerobot \
+      --ego /workspace/ego --retgt /workspace/retargeted \
+      --workers 48 --log [--limit N] [--categories a,b]
+"""
+import os, sys, re, io, glob, json, time, argparse, subprocess, signal
+os.environ.setdefault("OMP_NUM_THREADS", "1")
+os.environ.setdefault("OPENBLAS_NUM_THREADS", "1")
+from pathlib import Path
+import numpy as np
+import pyarrow.parquet as pq
+from scipy.ndimage import map_coordinates, gaussian_filter1d
+from PIL import Image
+import multiprocessing as mp
+
+# ── constants ────────────────────────────────────────────────────────────────
+FW, FH = 1920, 1080          # source frame size
+OUT    = 224                 # output view size
+FPS    = 30
+CHUNK  = 1000
+WRIST_CROP = 620             # px window @1080p tracking the grasp point
+KEYS = ["observation.images.top",
+        "observation.images.left_wrist",
+        "observation.images.right_wrist"]
+SIDES = {"R": ("rightThumbTip", "rightIndexFingerTip", "rightMiddleFingerTip"),
+         "L": ("leftThumbTip",  "leftIndexFingerTip",  "leftMiddleFingerTip")}
+# per-clip activity gate for a wrist view
+MOTION_MIN   = 0.06          # m of total grasp-path travel to count as "used"
+INBOUNDS_MIN = 0.15          # fraction of frames the hand must be inside the frame
+CENTER_SIGMA = 2.0           # gaussian smoothing (frames) of the crop-center track
+
+# per-view fixed lens (virtual camera) — geometry is content-independent, so the
+# barrel+tilt remap coords are precomputed ONCE below and reused every frame.
+VIEW = {  # key: (tilt_deg, barrel_k, color_gain, color_bias)
+    "observation.images.top":         ( 3.0, 0.00, 1.05,  3.0),
+    "observation.images.left_wrist":  ( 5.0, 0.12, 1.08,  5.0),
+    "observation.images.right_wrist": (-5.0, 0.12, 0.96, -3.0),
+}
+
+DS = EGO = RETGT = ""        # set in main
+
+
+# ── precomputed remap coords (barrel∘tilt), one (YS,XS) per view ─────────────
+def _remap_coords(tilt_deg, barrel_k, n=OUT):
+    """Source-sampling coords for output pixel (y,x) after resize->barrel->tilt.
+    Pixel flow in make_view is R --barrel--> B --tilt--> final, so we compose:
+      final[y,x] = B[y, sx_t(x)] = R[ barrel(sx_t(x), y) ].  Returns (YS, XS)."""
+    c = (n - 1) / 2.0
+    yy, xx = np.mgrid[0:n, 0:n].astype(np.float64)
+    # tilt: horizontal perspective shear, sx depends only on x
+    d = np.tan(np.radians(tilt_deg)) * n * 0.5
+    Xt = (xx - n / 2) * (1 + d / n * (xx / n - 0.5) * 2) + n / 2      # intermediate x
+    Yt = yy                                                            # tilt keeps y
+    # barrel evaluated at (Xt, Yt)
+    xn = (Xt - c) / c
+    yn = (Yt - c) / c
+    f = 1 + barrel_k * (xn * xn + yn * yn)
+    XS = xn * f * c + c
+    YS = yn * f * c + c
+    return YS.astype(np.float32), XS.astype(np.float32)
+
+REMAP = {k: _remap_coords(VIEW[k][0], VIEW[k][1]) for k in KEYS}
+
+
+# ── image ops ────────────────────────────────────────────────────────────────
+def square_center(img):
+    h, w = img.shape[:2]; s = min(h, w)
+    return img[(h - s) // 2:(h - s) // 2 + s, (w - s) // 2:(w - s) // 2 + s]
+
+def crop_at(img, cx, cy, size):
+    """Zero-padded square crop centered at (cx,cy). Out-of-frame -> black pixels."""
+    h, w = img.shape[:2]; half = size // 2
+    x0 = int(round(cx - half)); y0 = int(round(cy - half))
+    out = np.zeros((size, size, 3), np.uint8)
+    sx0, sy0 = max(0, x0), max(0, y0)
+    sx1, sy1 = min(w, x0 + size), min(h, y0 + size)
+    if sx1 > sx0 and sy1 > sy0:
+        out[sy0 - y0:sy0 - y0 + (sy1 - sy0), sx0 - x0:sx0 - x0 + (sx1 - sx0)] = img[sy0:sy1, sx0:sx1]
+    return out
+
+def resize224(img):
+    return np.asarray(Image.fromarray(img).resize((OUT, OUT), Image.LANCZOS))
+
+def apply_lens(img224, key, gain, bias):
+    ys, xs = REMAP[key]
+    out = np.empty_like(img224)
+    for c in range(3):
+        out[..., c] = map_coordinates(img224[..., c], (ys, xs), order=3, mode="nearest")
+    if gain != 1.0 or bias != 0.0:
+        out = np.clip(out.astype(np.float32) * gain + bias, 0, 255).astype(np.uint8)
+    return out
+
+
+# ── geometry ─────────────────────────────────────────────────────────────────
+def _mat(col, fr):
+    return np.array(col[fr].as_py(), dtype=np.float64).reshape(4, 4)
+
+def grasp_and_project(t, T):
+    """Return dict side-> (u[T], v[T], world_g[T,3]) and per-frame K,cam already
+    applied. Projection uses EgoDex's per-frame intrinsics + camera pose."""
+    Kc  = t.column("camera_intrinsics")
+    Cc  = t.column("observation.state.camera")
+    cols = {s: [t.column("observation.state." + n) for n in names]
+            for s, names in SIDES.items()}
+    out = {}
+    for s in SIDES:
+        th, ix, md = cols[s]
+        g = np.empty((T, 3)); u = np.empty(T); v = np.empty(T)
+        for fr in range(T):
+            pt = 0.5 * (_mat(th, fr)[:3, 3]
+                        + 0.7 * _mat(ix, fr)[:3, 3]
+                        + 0.3 * _mat(md, fr)[:3, 3])
+            g[fr] = pt
+            K   = np.array(Kc[fr].as_py()).reshape(3, 3)
+            cam = _mat(Cc, fr)
+            Xc  = (np.linalg.inv(cam) @ np.append(pt, 1))[:3]
+            z   = -Xc[2] if Xc[2] != 0 else 1e-6
+            u[fr] = K[0, 0] * Xc[0] / z + K[0, 2]
+            v[fr] = -K[1, 1] * Xc[1] / z + K[1, 2]
+        out[s] = (u, v, g)
+    return out
+
+HALF = WRIST_CROP // 2       # crop-center bounds so the window stays fully in-frame
+
+def hand_track(u, v, g):
+    """(active, cu[T], cv[T]). The crop-center track is smoothed AND clamped so the
+    WRIST_CROP window always lies fully inside the frame -> the wrist view is ALWAYS
+    real scene content, never black. When the hand is in FOV the crop tracks it; when
+    the hand leaves FOV the center rides the nearest edge (hand-adjacent workspace).
+    `active` is informational only (logging) now that no view is blacked."""
+    T = len(u)
+    inb = (u >= 0) & (u < FW) & (v >= 0) & (v < FH)
+    motion = float(np.linalg.norm(np.diff(g, axis=0), axis=1).sum()) if T > 1 else 0.0
+    active = (motion >= MOTION_MIN) and (inb.mean() >= INBOUNDS_MIN)
+    cu = np.nan_to_num(u, nan=FW / 2, posinf=FW, neginf=0.0)
+    cv = np.nan_to_num(v, nan=FH / 2, posinf=FH, neginf=0.0)
+    cu = np.clip(cu, HALF, FW - HALF).astype(np.float64)
+    cv = np.clip(cv, HALF, FH - HALF).astype(np.float64)
+    if T >= 3:
+        cu = gaussian_filter1d(cu, CENTER_SIGMA, mode="nearest")
+        cv = gaussian_filter1d(cv, CENTER_SIGMA, mode="nearest")
+        cu = np.clip(cu, HALF, FW - HALF)
+        cv = np.clip(cv, HALF, FH - HALF)
+    return active, cu, cv, inb
+
+
+# ── running per-view image stats (LeRobot: per-channel, [0,1], shape (3,1,1)) ─
+class Stat:
+    def __init__(self):
+        self.n = 0
+        self.s = np.zeros(3); self.ss = np.zeros(3)
+        self.mn = np.full(3, np.inf); self.mx = np.full(3, -np.inf)
+    def add(self, frame):                    # frame uint8 (H,W,3)
+        a = frame.reshape(-1, 3).astype(np.float64) / 255.0
+        self.n += a.shape[0]
+        self.s += a.sum(0); self.ss += (a * a).sum(0)
+        self.mn = np.minimum(self.mn, a.min(0)); self.mx = np.maximum(self.mx, a.max(0))
+    def finalize(self, T):
+        if self.n == 0:                      # all-black safety
+            z = np.zeros((3, 1, 1))
+            return {"min": z.tolist(), "max": z.tolist(),
+                    "mean": z.tolist(), "std": z.tolist(), "count": [T]}
+        mean = self.s / self.n
+        var = np.maximum(self.ss / self.n - mean * mean, 0.0)
+        r = lambda a: a.reshape(3, 1, 1).tolist()
+        return {"min": r(self.mn), "max": r(self.mx),
+                "mean": r(mean), "std": r(np.sqrt(var)), "count": [T]}
+
+
+# ── ffmpeg streaming ─────────────────────────────────────────────────────────
+def _readn(f, n):
+    buf = bytearray()
+    while len(buf) < n:
+        chunk = f.read(n - len(buf))
+        if not chunk:
+            break
+        buf += chunk
+    return bytes(buf)
+
+def _fferr():
+    return open(os.environ.get("FFMPEG_LOG", os.devnull), "a")
+
+
+def open_decoder(vid, T):
+    return subprocess.Popen(
+        ["ffmpeg", "-v", "error", "-i", vid, "-frames:v", str(T),
+         "-f", "rawvideo", "-pix_fmt", "rgb24", "-s", f"{FW}x{FH}", "-"],
+        stdout=subprocess.PIPE, stderr=_fferr(), bufsize=FW * FH * 3 * 2)
+
+def open_encoder(path):
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    return subprocess.Popen(
+        ["ffmpeg", "-y", "-v", "error", "-f", "rawvideo", "-pix_fmt", "rgb24",
+         "-s", f"{OUT}x{OUT}", "-r", str(FPS), "-i", "-",
+         "-c:v", "libx264", "-pix_fmt", "yuv420p", "-crf", "23",
+         "-g", str(FPS), "-preset", "veryfast", "-threads", "1",
+         "-f", "mp4", path],
+        stdin=subprocess.PIPE, stderr=_fferr())
+
+
+# ── per-episode work ─────────────────────────────────────────────────────────
+def src_paths(cat, fyy):
+    p = glob.glob(f"{EGO}/{cat}/data/chunk-*/{fyy}.parquet")
+    v = glob.glob(f"{EGO}/{cat}/videos/observation.images.camera/chunk-*/{fyy}.mp4")
+    return (p[0] if p else None), (v[0] if v else None)
+
+def out_paths(eidx):
+    ci = eidx // CHUNK
+    return {k: f"{DS}/videos/chunk-{ci:03d}/{k}/episode_{eidx:06d}.mp4" for k in KEYS}
+
+def process(e):
+    eidx, cat, fyy, T = e["episode_index"], e["category"], e["fyy"], e["length"]
+    t0 = time.time()
+    pqf, vid = src_paths(cat, fyy)
+    if not pqf or not vid:
+        return {"episode_index": eidx, "error": f"missing source ({cat}/{fyy})"}
+    outs = out_paths(eidx)
+    try:
+        cols = ["camera_intrinsics", "observation.state.camera"] + \
+               [f"observation.state.{n}" for s in SIDES.values() for n in s]
+        t = pq.read_table(pqf, columns=cols)
+        Tsrc = t.num_rows
+        Tn = min(T, Tsrc)
+        proj = grasp_and_project(t, Tn)
+        tracks = {}
+        for s in SIDES:
+            u, v, g = proj[s]
+            tracks[s] = hand_track(u, v, g)
+
+        stats = {k: Stat() for k in KEYS}
+        dec = open_decoder(vid, T)
+        enc = {k: open_encoder(outs[k] + ".tmp") for k in KEYS}
+        frame_bytes = FW * FH * 3
+        last = None
+        for fr in range(T):
+            raw = _readn(dec.stdout, frame_bytes)
+            if len(raw) < frame_bytes:
+                img = last if last is not None else np.zeros((FH, FW, 3), np.uint8)
+            else:
+                img = np.frombuffer(raw, np.uint8).reshape(FH, FW, 3)
+                last = img
+            fi = min(fr, Tn - 1)             # keypoints index (prefix-aligned)
+
+            # top
+            g_top, b_top = VIEW[KEYS[0]][2], VIEW[KEYS[0]][3]
+            top = apply_lens(resize224(square_center(img)), KEYS[0], g_top, b_top)
+
+            views = {KEYS[0]: top}
+            for key, s in ((KEYS[1], "L"), (KEYS[2], "R")):
+                _active, cu, cv, _ = tracks[s]
+                # ALWAYS render both wrist views (both viewpoints present) —
+                # crop tracks the hand's grasp point every frame; if the hand is
+                # genuinely off-frame, crop_at zero-pads only that region.
+                crop = crop_at(img, cu[fi], cv[fi], WRIST_CROP)
+                gn, bs = VIEW[key][2], VIEW[key][3]
+                views[key] = apply_lens(resize224(crop), key, gn, bs)
+
+            for k in KEYS:
+                stats[k].add(views[k])
+                enc[k].stdin.write(views[k].tobytes())
+
+        dec.stdout.close(); dec.wait()
+        for k in KEYS:
+            enc[k].stdin.close(); enc[k].wait()
+            os.replace(outs[k] + ".tmp", outs[k])       # atomic publish
+
+        return {"episode_index": eidx, "category": cat, "length": T,
+                "active": {"L": bool(tracks["L"][0]), "R": bool(tracks["R"][0])},
+                "stats": {k: stats[k].finalize(T) for k in KEYS},
+                "sec": round(time.time() - t0, 2)}
+    except Exception as ex:
+        for k in KEYS:
+            for p in (outs[k] + ".tmp",):
+                try: os.remove(p)
+                except OSError: pass
+        return {"episode_index": eidx, "error": f"{type(ex).__name__}: {ex}"}
+
+
+# ── mapping (replicate to_lerobot_v21.discover ordering) ─────────────────────
+def build_episodes():
+    lengths = {}
+    with open(f"{DS}/meta/episodes.jsonl") as f:
+        for line in f:
+            d = json.loads(line); lengths[d["episode_index"]] = d["length"]
+    rows = []
+    for h in sorted(glob.glob(f"{RETGT}/*/clip_*/retargeted.hdf5")):
+        parts = h.split("/")
+        cat, name = parts[-3], parts[-2]
+        m = re.search(r"(file-\d+)_ep", name)
+        if not m:
+            continue
+        fyy = m.group(1)
+        rows.append({"category": cat, "fyy": fyy, "fileidx": int(fyy.split("-")[1])})
+    rows.sort(key=lambda r: (r["category"], r["fileidx"]))
+    eps = []
+    for i, r in enumerate(rows):
+        if i not in lengths:            # dataset has fewer episodes than clips
+            continue
+        eps.append({"episode_index": i, "category": r["category"],
+                    "fyy": r["fyy"], "length": lengths[i]})
+    return eps
+
+
+def main():
+    global DS, EGO, RETGT
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--ds", default="/workspace/retargeted_lerobot")
+    ap.add_argument("--ego", default="/workspace/ego")
+    ap.add_argument("--retgt", default="/workspace/retargeted")
+    ap.add_argument("--workers", type=int, default=48)
+    ap.add_argument("--limit", type=int, default=0)
+    ap.add_argument("--categories", default="")
+    ap.add_argument("--log", action="store_true")
+    args = ap.parse_args()
+    DS, EGO, RETGT = args.ds, args.ego, args.retgt
+
+    logf = None
+    if args.log:
+        logf = open(f"{DS}/multiview.log", "a", buffering=1)
+    def emit(msg):
+        print(msg, flush=True)
+        if logf: logf.write(msg + "\n")
+
+    eps = build_episodes()
+    if args.categories:
+        keep = set(args.categories.split(","))
+        eps = [e for e in eps if e["category"] in keep]
+    if args.limit:
+        eps = eps[:args.limit]
+
+    # resume: results.jsonl is the source of truth (carries stats for finalize)
+    res_path = f"{DS}/multiview_results.jsonl"
+    done = set()
+    if os.path.exists(res_path):
+        with open(res_path) as f:
+            for line in f:
+                try:
+                    d = json.loads(line)
+                    if "stats" in d:
+                        done.add(d["episode_index"])
+                except Exception:
+                    pass
+    todo = [e for e in eps if e["episode_index"] not in done]
+
+    emit(f"\n=== multiview run {time.strftime('%Y-%m-%d %H:%M:%S')} ===")
+    emit(f"episodes={len(eps)}  resumed={len(done)}  todo={len(todo)}  "
+         f"workers={args.workers}  keys={len(KEYS)}  out={OUT}x{OUT} h264")
+    if not todo:
+        emit("nothing to do — all episodes already have results.")
+        return
+
+    res_f = open(res_path, "a", buffering=1)
+    t_start = time.time()
+    n_ok = n_err = 0
+    errs = []
+    with mp.Pool(args.workers, maxtasksperchild=200) as pool:
+        for i, r in enumerate(pool.imap_unordered(process, todo, chunksize=1), 1):
+            res_f.write(json.dumps(r) + "\n")
+            eidx = r["episode_index"]
+            if "error" in r:
+                n_err += 1; errs.append((eidx, r["error"]))
+                emit(f"  [ERR {r['error'][:40]:40s}] ep{eidx:06d}  {i}/{len(todo)}")
+            else:
+                n_ok += 1
+                el = time.time() - t_start
+                eta = el / i * (len(todo) - i) / 3600
+                a = r.get("active", {})
+                tag = ("LR" if a.get("L") and a.get("R") else
+                       "L-" if a.get("L") else "-R" if a.get("R") else "--")
+                emit(f"  [ok {tag}] ep{eidx:06d} {r['category'][:14]:14s} "
+                     f"{r['sec']:5.1f}s  {i}/{len(todo)}  ETA {eta:4.2f}h")
+    res_f.close()
+    emit(f"\nDONE: ok={n_ok} err={n_err} in {(time.time()-t_start)/3600:.2f}h")
+    for eidx, msg in errs[:15]:
+        emit(f"  ERR ep{eidx:06d}: {msg}")
+    emit("next: /venv/main/bin/python3 finalize_multiview.py --ds " + DS)
+
+
+if __name__ == "__main__":
+    signal.signal(signal.SIGINT, signal.SIG_DFL)