Add OpenX Rerun Viewer: 6 robot types, 18 episodes

Interactive browser for OpenX-Embodiment datasets with embedded
Rerun visualization. Covers Google Robot, Franka Panda, WidowX,
Hello Stretch, Kinova Jaco, and KUKA IIWA.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

.dockerignore

@@ -0,0 +1,3 @@
+__pycache__
+*.pyc
+.git

.gitattributes

@@ -22,6 +22,7 @@
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
 *.rar filter=lfs diff=lfs merge=lfs -text
+*.rrd filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
 saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.tar.* filter=lfs diff=lfs merge=lfs -text

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    libavcodec-extra libavformat-dev libavdevice-dev \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE 7860
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,125 @@
+"""
+FastAPI server for the OpenX Rerun Viewer HF Space.
+Runs the selection UI and serves .rrd files.
+When running locally, also starts a local Rerun web viewer to avoid mixed-content issues.
+"""
+import json
+import os
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+from fastapi import FastAPI
+from fastapi.responses import FileResponse, HTMLResponse
+from fastapi.staticfiles import StaticFiles
+from fastapi.middleware.cors import CORSMiddleware
+
+app = FastAPI(title="OpenX Rerun Viewer")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["GET", "HEAD", "OPTIONS"],
+    allow_headers=["*"],
+    expose_headers=[
+        "Content-Length", "Content-Type", "Accept-Ranges",
+        "Cross-Origin-Resource-Policy",
+    ],
+)
+
+DATA_DIR = Path(__file__).parent / "data"
+MANIFEST_PATH = DATA_DIR / "manifest.json"
+
+IS_LOCAL = "SPACE_ID" not in os.environ and "HF_SPACE" not in os.environ
+
+
+def load_manifest():
+    if MANIFEST_PATH.exists():
+        return json.loads(MANIFEST_PATH.read_text())
+    return []
+
+
+@app.get("/", response_class=HTMLResponse)
+async def index():
+    html = (Path(__file__).parent / "templates" / "index.html").read_text()
+    # Inject the viewer base URL: use local viewer for dev, app.rerun.io for production
+    if IS_LOCAL:
+        viewer_base = "http://localhost:9090"
+    else:
+        viewer_base = "https://app.rerun.io/version/0.26.2"
+    html = html.replace("{{VIEWER_BASE}}", viewer_base)
+    return HTMLResponse(html)
+
+
+@app.get("/api/datasets")
+async def list_datasets():
+    manifest = load_manifest()
+    return [
+        {
+            "slug": m["slug"],
+            "robot_type": m["robot_type"],
+            "fps": m.get("fps", 0),
+            "camera_keys": m.get("camera_keys", []),
+            "camera_labels": m.get("camera_labels", []),
+            "num_episodes_total": m.get("num_episodes_total", 0),
+            "state_dim": m.get("state_dim", 0),
+            "action_dim": m.get("action_dim", 0),
+            "episodes_available": [
+                {"index": ep["index"], "frames": ep.get("frames", "?")}
+                for ep in m.get("episodes_available", [])
+            ],
+        }
+        for m in manifest
+    ]
+
+
+@app.get("/api/datasets/{slug}/episodes")
+async def list_episodes(slug: str):
+    manifest = load_manifest()
+    for m in manifest:
+        if m["slug"] == slug:
+            return m["episodes_available"]
+    return []
+
+
+@app.api_route("/data/{slug}/episode_{index:str}.rrd", methods=["GET", "HEAD"])
+async def serve_rrd(slug: str, index: str):
+    filepath = DATA_DIR / slug / f"episode_{index}.rrd"
+    if not filepath.exists():
+        return HTMLResponse(status_code=404, content="Episode not found")
+    return FileResponse(
+        filepath,
+        media_type="application/octet-stream",
+        headers={
+            "Accept-Ranges": "bytes",
+            "Access-Control-Allow-Origin": "*",
+            "Cross-Origin-Resource-Policy": "cross-origin",
+            "Cache-Control": "public, max-age=3600",
+        },
+    )
+
+
+static_dir = Path(__file__).parent / "static"
+if static_dir.exists():
+    app.mount("/static", StaticFiles(directory=str(static_dir)), name="static")
+
+
+def start_local_viewer():
+    """Start Rerun web viewer on port 9090 for local development."""
+    import rerun as rr
+    rr.serve_web_viewer(web_port=9090, open_browser=False)
+    # serve_web_viewer returns immediately after starting the server in a thread
+
+
+if __name__ == "__main__":
+    import uvicorn
+
+    port = int(os.environ.get("PORT", 8000))
+
+    if IS_LOCAL:
+        print("Local mode: starting Rerun web viewer on http://localhost:9090")
+        start_local_viewer()
+        time.sleep(0.5)
+
+    uvicorn.run(app, host="0.0.0.0", port=port)

data/bridge_orig/episode_000000.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:51903460b310529ac41f0335f4dcdff64d946704ba28bf8260c37b8b3cea7309
+size 14270099

data/bridge_orig/episode_000001.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:03c1d7099dd130d493237cefe9f281f22854d0e21e9426aa38d2792aca215f68
+size 7806978

data/bridge_orig/episode_000002.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3dca45de55db434e5df5db863912516f560b6d56c06267d19e3bf792b9ac43f0
+size 7312412

data/dobbe/episode_000000.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:89c62baf47a68f5570a7c3c0420d0eaa8c50ffd4c49cce523f76c06eba15c35b
+size 20219543

data/dobbe/episode_000001.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:433d18d82f73031dacaff98da6af9dc08308d952ecbd524375512bf432bd8906
+size 53905361

data/dobbe/episode_000002.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:09d5b8de3006c68bf5c4f27f747c75332e85bc928d3e4f65117afaf673c8b491
+size 26818095

data/droid/episode_000000.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3248d21abc772ba2bde357fd922e3a866fd53601ac5e83e133b5111e55056c3b
+size 95062810

data/droid/episode_000001.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b1600b232854183f30fa943318d4c867b41291a8074670aed2b83bef95252b52
+size 73363811

data/droid/episode_000002.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d059258a723f936488f98da219f20477b92e558c1f3f55460bf87b6f2644e2ea
+size 93381685

data/fractal20220817_data/episode_000000.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:534f14e125a1a9f019996794d241a5e20069266fb9790b81fabf58443b8fa1d1
+size 16987673

data/fractal20220817_data/episode_000001.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:48b38f276cae71ca6032d350fc670db8f09b6de7e3e950e3991dde6ce38391fa
+size 10698015

data/fractal20220817_data/episode_000002.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:937ed9829cd0827b7467c62abff810d7de4987d20a972989b30a07b84ff0d3e2
+size 3967992

data/jaco_play/episode_000000.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c64c2007fa1cb857012e70bd2f12509d965f326f28a7f69ad1c6fba2aa48eb2d
+size 17340014

data/jaco_play/episode_000001.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e4f12095aab2d0553f281f85052c64e810fba98a77ce854404154ff503b54cb4
+size 10299399

data/jaco_play/episode_000002.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1a9eb5f38489fb277bd6b21a0245b9245a37525978a1805c0bdb4b92b94d5fad
+size 20648516

data/kuka/episode_000000.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:50879f8c7047ca89e623d90590437688d5a7d64f1b644b2f5c69a1d60eaebe8d
+size 5200888

data/kuka/episode_000001.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4c908786af4f521a90dd5590766c766e9c44e9ef67af5ffb66d82ecb92b1dd2a
+size 6013097

data/kuka/episode_000002.rrd

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e06a42e5b45638eda39fd98196e14752fdbd94550137e4c1e8ab18641ff71a4d
+size 7105434

data/manifest.json

@@ -0,0 +1,206 @@
+[
+  {
+    "slug": "fractal20220817_data",
+    "repo_id": "IPEC-COMMUNITY/fractal20220817_data_lerobot",
+    "robot_type": "Google Robot",
+    "fps": 3,
+    "camera_keys": [
+      "observation.images.image"
+    ],
+    "camera_labels": [
+      "main"
+    ],
+    "episodes_available": [
+      {
+        "index": 0,
+        "file": "data/fractal20220817_data/episode_000000.rrd",
+        "frames": 115
+      },
+      {
+        "index": 1,
+        "file": "data/fractal20220817_data/episode_000001.rrd",
+        "frames": 66
+      },
+      {
+        "index": 2,
+        "file": "data/fractal20220817_data/episode_000002.rrd",
+        "frames": 25
+      }
+    ],
+    "state_dim": 8,
+    "action_dim": 7,
+    "num_episodes_total": 87212
+  },
+  {
+    "slug": "droid",
+    "repo_id": "IPEC-COMMUNITY/droid_lerobot",
+    "robot_type": "Franka Panda",
+    "fps": 15,
+    "camera_keys": [
+      "observation.images.exterior_image_1_left",
+      "observation.images.exterior_image_2_left",
+      "observation.images.wrist_image_left"
+    ],
+    "camera_labels": [
+      "exterior_left",
+      "exterior_right",
+      "wrist"
+    ],
+    "episodes_available": [
+      {
+        "index": 0,
+        "file": "data/droid/episode_000000.rrd",
+        "frames": 240
+      },
+      {
+        "index": 1,
+        "file": "data/droid/episode_000001.rrd",
+        "frames": 193
+      },
+      {
+        "index": 2,
+        "file": "data/droid/episode_000002.rrd",
+        "frames": 239
+      }
+    ],
+    "state_dim": 8,
+    "action_dim": 7,
+    "num_episodes_total": 92233
+  },
+  {
+    "slug": "bridge_orig",
+    "repo_id": "IPEC-COMMUNITY/bridge_orig_lerobot",
+    "robot_type": "WidowX",
+    "fps": 5,
+    "camera_keys": [
+      "observation.images.image_0",
+      "observation.images.image_1",
+      "observation.images.image_2",
+      "observation.images.image_3"
+    ],
+    "camera_labels": [
+      "cam_0",
+      "cam_1",
+      "cam_2",
+      "cam_3"
+    ],
+    "episodes_available": [
+      {
+        "index": 0,
+        "file": "data/bridge_orig/episode_000000.rrd",
+        "frames": 26
+      },
+      {
+        "index": 1,
+        "file": "data/bridge_orig/episode_000001.rrd",
+        "frames": 45
+      },
+      {
+        "index": 2,
+        "file": "data/bridge_orig/episode_000002.rrd",
+        "frames": 45
+      }
+    ],
+    "state_dim": 8,
+    "action_dim": 7,
+    "num_episodes_total": 53192
+  },
+  {
+    "slug": "dobbe",
+    "repo_id": "IPEC-COMMUNITY/dobbe_lerobot",
+    "robot_type": "Hello Stretch",
+    "fps": 3.75,
+    "camera_keys": [
+      "observation.images.wrist_image"
+    ],
+    "camera_labels": [
+      "wrist"
+    ],
+    "episodes_available": [
+      {
+        "index": 0,
+        "file": "data/dobbe/episode_000000.rrd",
+        "frames": 225
+      },
+      {
+        "index": 1,
+        "file": "data/dobbe/episode_000001.rrd",
+        "frames": 354
+      },
+      {
+        "index": 2,
+        "file": "data/dobbe/episode_000002.rrd",
+        "frames": 277
+      }
+    ],
+    "state_dim": 8,
+    "action_dim": 7,
+    "num_episodes_total": 5208
+  },
+  {
+    "slug": "jaco_play",
+    "repo_id": "IPEC-COMMUNITY/jaco_play_lerobot",
+    "robot_type": "Kinova Jaco",
+    "fps": 10,
+    "camera_keys": [
+      "observation.images.image",
+      "observation.images.image_wrist"
+    ],
+    "camera_labels": [
+      "main",
+      "wrist"
+    ],
+    "episodes_available": [
+      {
+        "index": 0,
+        "file": "data/jaco_play/episode_000000.rrd",
+        "frames": 78
+      },
+      {
+        "index": 1,
+        "file": "data/jaco_play/episode_000001.rrd",
+        "frames": 49
+      },
+      {
+        "index": 2,
+        "file": "data/jaco_play/episode_000002.rrd",
+        "frames": 94
+      }
+    ],
+    "state_dim": 8,
+    "action_dim": 7,
+    "num_episodes_total": 976
+  },
+  {
+    "slug": "kuka",
+    "repo_id": "IPEC-COMMUNITY/kuka_lerobot",
+    "robot_type": "KUKA IIWA",
+    "fps": 10,
+    "camera_keys": [
+      "observation.images.image"
+    ],
+    "camera_labels": [
+      "main"
+    ],
+    "episodes_available": [
+      {
+        "index": 0,
+        "file": "data/kuka/episode_000000.rrd",
+        "frames": 9
+      },
+      {
+        "index": 1,
+        "file": "data/kuka/episode_000001.rrd",
+        "frames": 10
+      },
+      {
+        "index": 2,
+        "file": "data/kuka/episode_000002.rrd",
+        "frames": 11
+      }
+    ],
+    "state_dim": 8,
+    "action_dim": 7,
+    "num_episodes_total": 209880
+  }
+]

prepare_episodes.py

@@ -0,0 +1,318 @@
+"""
+Offline preprocessing: download LeRobot episodes and convert to .rrd files.
+Downloads 3 episodes each from 6 OpenX datasets covering diverse robot types.
+Reads parquet + mp4 files directly (no lerobot dependency needed).
+"""
+import json
+import os
+import numpy as np
+from pathlib import Path
+import rerun as rr
+import pandas as pd
+import av
+from huggingface_hub import hf_hub_download
+
+DATA_DIR = Path(__file__).parent / "data"
+
+# ---- Dataset Configuration ----
+# chunk_size is how many episodes per chunk directory (1000 for most v2.0 datasets)
+DATASETS = [
+    {
+        "slug": "fractal20220817_data",
+        "repo_id": "IPEC-COMMUNITY/fractal20220817_data_lerobot",
+        "robot_type": "Google Robot",
+        "episodes": [0, 1, 2],
+        "camera_keys": ["observation.images.image"],
+        "camera_labels": ["main"],
+        "fps": 3,
+        "chunk_size": 1000,
+        "state_dim": 8,
+        "action_dim": 7,
+        "num_episodes_total": 87212,
+    },
+    {
+        "slug": "droid",
+        "repo_id": "IPEC-COMMUNITY/droid_lerobot",
+        "robot_type": "Franka Panda",
+        "episodes": [0, 1, 2],
+        "camera_keys": [
+            "observation.images.exterior_image_1_left",
+            "observation.images.exterior_image_2_left",
+            "observation.images.wrist_image_left",
+        ],
+        "camera_labels": ["exterior_left", "exterior_right", "wrist"],
+        "fps": 15,
+        "chunk_size": 1000,
+        "state_dim": 8,
+        "action_dim": 7,
+        "num_episodes_total": 92233,
+    },
+    {
+        "slug": "bridge_orig",
+        "repo_id": "IPEC-COMMUNITY/bridge_orig_lerobot",
+        "robot_type": "WidowX",
+        "episodes": [0, 1, 2],
+        "camera_keys": [
+            "observation.images.image_0",
+            "observation.images.image_1",
+            "observation.images.image_2",
+            "observation.images.image_3",
+        ],
+        "camera_labels": ["cam_0", "cam_1", "cam_2", "cam_3"],
+        "fps": 5,
+        "chunk_size": 1000,
+        "state_dim": 8,
+        "action_dim": 7,
+        "num_episodes_total": 53192,
+    },
+    {
+        "slug": "dobbe",
+        "repo_id": "IPEC-COMMUNITY/dobbe_lerobot",
+        "robot_type": "Hello Stretch",
+        "episodes": [0, 1, 2],
+        "camera_keys": ["observation.images.wrist_image"],
+        "camera_labels": ["wrist"],
+        "fps": 3.75,
+        "chunk_size": 1000,
+        "state_dim": 8,
+        "action_dim": 7,
+        "num_episodes_total": 5208,
+    },
+    {
+        "slug": "jaco_play",
+        "repo_id": "IPEC-COMMUNITY/jaco_play_lerobot",
+        "robot_type": "Kinova Jaco",
+        "episodes": [0, 1, 2],
+        "camera_keys": [
+            "observation.images.image",
+            "observation.images.image_wrist",
+        ],
+        "camera_labels": ["main", "wrist"],
+        "fps": 10,
+        "chunk_size": 1000,
+        "state_dim": 8,
+        "action_dim": 7,
+        "num_episodes_total": 976,
+    },
+    {
+        "slug": "kuka",
+        "repo_id": "IPEC-COMMUNITY/kuka_lerobot",
+        "robot_type": "KUKA IIWA",
+        "episodes": [0, 1, 2],
+        "camera_keys": ["observation.images.image"],
+        "camera_labels": ["main"],
+        "fps": 10,
+        "chunk_size": 1000,
+        "state_dim": 8,
+        "action_dim": 7,
+        "num_episodes_total": 209880,
+    },
+]
+
+
+def estimate_intrinsics(h, w):
+    """Estimate pinhole intrinsics from image resolution."""
+    fx = fy = max(h, w) * 1.2
+    cx, cy = w / 2, h / 2
+    return np.array([[fx, 0, cx], [0, fy, cy], [0, 0, 1]], dtype=np.float32)
+
+
+def download_file(repo_id, path, cache_dir=None):
+    """Download a file from HF and return local path. Returns None if not found."""
+    try:
+        return hf_hub_download(repo_id, path, repo_type="dataset", cache_dir=cache_dir)
+    except Exception:
+        return None
+
+
+def read_video_frames(video_path):
+    """Decode all frames from an MP4 file. Returns list of (H, W, C) numpy arrays."""
+    container = av.open(video_path)
+    stream = container.streams.video[0]
+    frames = []
+    for frame in container.decode(stream):
+        img = frame.to_ndarray(format="rgb24")  # (H, W, 3) uint8
+        frames.append(img)
+    container.close()
+    return frames
+
+
+def process_episode(ds_config, ep_idx):
+    """Download and convert a single episode to .rrd format.
+    Returns (rrd_path, num_frames) or (None, None) on failure."""
+    slug = ds_config["slug"]
+    repo_id = ds_config["repo_id"]
+    chunk_size = ds_config["chunk_size"]
+    camera_keys = ds_config["camera_keys"]
+    camera_labels = ds_config["camera_labels"]
+    fps = ds_config["fps"]
+
+    out_dir = DATA_DIR / slug
+    out_dir.mkdir(parents=True, exist_ok=True)
+
+    rrd_path = out_dir / f"episode_{ep_idx:06d}.rrd"
+    if rrd_path.exists():
+        # Get frame count from cached parquet
+        chunk = ep_idx // chunk_size
+        ep_str = f"episode_{ep_idx:06d}"
+        pq_path = f"data/chunk-{chunk:03d}/{ep_str}.parquet"
+        local_pq = download_file(repo_id, pq_path)
+        num_frames = len(pd.read_parquet(local_pq)) if local_pq else "?"
+        print(f"  Episode {ep_idx}: already exists ({rrd_path.stat().st_size / 1024:.0f} KB)")
+        return rrd_path, num_frames
+
+    chunk = ep_idx // chunk_size
+    ep_str = f"episode_{ep_idx:06d}"
+
+    # Download parquet file
+    pq_path = f"data/chunk-{chunk:03d}/{ep_str}.parquet"
+    local_pq = download_file(repo_id, pq_path)
+    if local_pq is None:
+        print(f"  Episode {ep_idx}: parquet not found ({pq_path})")
+        return None, None
+
+    # Read parquet data
+    df = pd.read_parquet(local_pq)
+    num_frames = len(df)
+    print(f"  Episode {ep_idx}: {num_frames} frames, parquet OK, downloading videos...")
+
+    # Download and decode video for each camera
+    camera_frames = {}
+    for ck, cl in zip(camera_keys, camera_labels):
+        video_path = f"videos/chunk-{chunk:03d}/{ck}/{ep_str}.mp4"
+        local_video = download_file(repo_id, video_path)
+        if local_video is None:
+            print(f"    Camera '{cl}': video not found, skipping")
+            continue
+        frames = read_video_frames(local_video)
+        camera_frames[cl] = frames
+        print(f"    Camera '{cl}': {len(frames)} frames decoded")
+
+    if not camera_frames:
+        print(f"  Episode {ep_idx}: no video data found, skipping")
+        return None, None
+
+    # Create .rrd recording
+    rec_id = f"{slug}_ep{ep_idx:06d}"
+    rr.init("openx_viewer", recording_id=rec_id)
+
+    # Determine camera positions (spread around the scene)
+    positions = [
+        (0.8, 0.2, 0.6),
+        (-0.8, 0.2, 0.6),
+        (0.2, 0.8, 0.4),
+        (-0.2, -0.8, 0.4),
+    ]
+
+    # Get image resolution from first frame of first camera
+    first_cam = list(camera_frames.keys())[0]
+    first_img = camera_frames[first_cam][0]
+    h, w = first_img.shape[:2]
+
+    # Log camera setups (static)
+    for i, (cl, frames) in enumerate(camera_frames.items()):
+        pos = positions[i % len(positions)]
+        cam_path = f"cameras/{cl}"
+        rr.log(cam_path, rr.Transform3D(translation=pos), static=True)
+        rr.log(
+            f"{cam_path}/image",
+            rr.Pinhole(
+                image_from_camera=estimate_intrinsics(h, w),
+                resolution=[w, h],
+                camera_xyz=rr.ViewCoordinates.RDF,
+                image_plane_distance=0.5,
+            ),
+            static=True,
+        )
+        # Note: subsequent cameras might have different resolutions but we keep same intrinsics
+        # as they're estimates anyway
+
+    # State/action labels
+    state_cols = [c for c in df.columns if c == "observation.state"]
+    action_cols = [c for c in df.columns if c == "action"]
+    state_labels = ["x", "y", "z", "rx", "ry", "rz", "rw", "gripper"]
+    action_labels = ["ax", "ay", "az", "aroll", "apitch", "ayaw", "agripper"]
+
+    # Log frames
+    n_video_frames = min(len(frames) for frames in camera_frames.values())
+    for frame_i in range(n_video_frames):
+        rr.set_time_sequence("frame", frame_i)
+        rr.set_time_seconds("time", frame_i / fps)
+
+        # Log camera images
+        for cl, frames in camera_frames.items():
+            if frame_i < len(frames):
+                rr.log(f"cameras/{cl}/image", rr.Image(frames[frame_i], color_model="RGB"))
+
+        # Log state if available and within bounds
+        if state_cols and frame_i < num_frames:
+            state = np.asarray(df.iloc[frame_i][state_cols[0]]).flatten()
+            for j, label in enumerate(state_labels):
+                if j < len(state):
+                    rr.log(f"state/{label}", rr.Scalars([float(state[j])]))
+
+        # Log action if available and within bounds
+        if action_cols and frame_i < num_frames:
+            action = np.asarray(df.iloc[frame_i][action_cols[0]]).flatten()
+            for j, label in enumerate(action_labels):
+                if j < len(action):
+                    rr.log(f"action/{label}", rr.Scalars([float(action[j])]))
+
+    rr.save(str(rrd_path))
+    rr.disconnect()
+
+    size_kb = rrd_path.stat().st_size / 1024
+    print(f"  Episode {ep_idx}: saved {size_kb:.0f} KB")
+    return rrd_path, num_frames
+
+
+def process_dataset(ds_config):
+    """Process all episodes for a dataset."""
+    slug = ds_config["slug"]
+    print(f"\n{'='*60}")
+    print(f"{ds_config['robot_type']} — {ds_config['repo_id']}")
+    print(f"  Cameras: {ds_config['camera_labels']}")
+    print(f"  Episodes: {ds_config['episodes']}")
+
+    manifest_entry = {
+        "slug": slug,
+        "repo_id": ds_config["repo_id"],
+        "robot_type": ds_config["robot_type"],
+        "fps": ds_config["fps"],
+        "camera_keys": ds_config["camera_keys"],
+        "camera_labels": ds_config["camera_labels"],
+        "state_dim": ds_config.get("state_dim", 8),
+        "action_dim": ds_config.get("action_dim", 7),
+        "num_episodes_total": ds_config.get("num_episodes_total", 0),
+        "episodes_available": [],
+    }
+
+    for ep_idx in ds_config["episodes"]:
+        rrd_path, num_frames = process_episode(ds_config, ep_idx)
+        if rrd_path:
+            manifest_entry["episodes_available"].append({
+                "index": ep_idx,
+                "frames": num_frames,
+                "file": f"data/{slug}/episode_{ep_idx:06d}.rrd",
+            })
+
+    return manifest_entry
+
+
+def main():
+    manifests = []
+    for ds_config in DATASETS:
+        meta = process_dataset(ds_config)
+        manifests.append(meta)
+
+    manifest_path = DATA_DIR / "manifest.json"
+    manifest_path.write_text(json.dumps(manifests, indent=2))
+    print(f"\n{'='*60}")
+    print(f"Manifest written to {manifest_path}")
+    print(f"Total datasets: {len(manifests)}")
+    total_eps = sum(len(m["episodes_available"]) for m in manifests)
+    print(f"Total episodes: {total_eps}")
+
+
+if __name__ == "__main__":
+    main()

requirements.txt

@@ -0,0 +1,8 @@
+fastapi>=0.115.0
+uvicorn>=0.30.0
+rerun-sdk>=0.26.0
+huggingface-hub
+jinja2
+av
+pandas
+pyarrow

static/style.css

@@ -0,0 +1 @@
+/* Minimal additional styling - everything else is inline in index.html */

templates/index.html

@@ -0,0 +1,188 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>OpenX Rerun Viewer</title>
+<style>
+  * { box-sizing: border-box; margin: 0; padding: 0; }
+  body {
+    font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif;
+    background: #0d1117;
+    color: #c9d1d9;
+    height: 100vh;
+    display: flex;
+    flex-direction: column;
+  }
+  .header {
+    padding: 12px 20px;
+    background: #161b22;
+    border-bottom: 1px solid #30363d;
+    display: flex;
+    align-items: center;
+    gap: 16px;
+    flex-shrink: 0;
+  }
+  .header h1 {
+    font-size: 18px;
+    font-weight: 600;
+    color: #f0f6fc;
+    white-space: nowrap;
+  }
+  .controls {
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    flex-wrap: wrap;
+  }
+  .controls select, .controls input, .controls button {
+    padding: 6px 12px;
+    border-radius: 6px;
+    border: 1px solid #30363d;
+    background: #21262d;
+    color: #c9d1d9;
+    font-size: 13px;
+  }
+  .controls select:focus, .controls button:focus {
+    outline: none;
+    border-color: #58a6ff;
+  }
+  .controls button {
+    cursor: pointer;
+    background: #238636;
+    border-color: #2ea043;
+    font-weight: 600;
+  }
+  .controls button:hover { background: #2ea043; }
+  .meta {
+    font-size: 12px;
+    color: #8b949e;
+    display: flex;
+    gap: 12px;
+    flex-wrap: wrap;
+  }
+  .meta span { white-space: nowrap; }
+  .viewer-container {
+    flex: 1;
+    overflow: hidden;
+    position: relative;
+  }
+  .viewer-container iframe {
+    width: 100%;
+    height: 100%;
+    border: none;
+  }
+  .placeholder {
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    height: 100%;
+    color: #484f58;
+    font-size: 16px;
+  }
+  .placeholder p { text-align: center; line-height: 1.6; }
+</style>
+</head>
+<body>
+<div class="header">
+  <h1>OpenX Rerun Viewer</h1>
+  <div class="controls">
+    <select id="dataset-select">
+      <option value="">-- Select Dataset --</option>
+    </select>
+    <select id="episode-select" disabled>
+      <option value="">-- Select Episode --</option>
+    </select>
+    <button id="view-btn" disabled>View in Rerun</button>
+  </div>
+  <div class="meta" id="meta-display"></div>
+</div>
+<div class="viewer-container">
+  <div class="placeholder" id="placeholder">
+    <p>Select a dataset and episode above to visualize in Rerun.<br>
+    <small>6 robot types · 18 episodes · OpenX-Embodiment</small></p>
+  </div>
+  <iframe id="rerun-frame" style="display:none"
+    allow="cross-origin-isolated"
+    allowfullscreen>
+  </iframe>
+</div>
+
+<script>
+const BASE = document.querySelector('meta[content]')?.content || window.location.origin;
+let datasets = [];
+let currentSlug = null;
+
+async function init() {
+  try {
+    const resp = await fetch('/api/datasets');
+    datasets = await resp.json();
+    const sel = document.getElementById('dataset-select');
+    datasets.forEach(ds => {
+      const opt = document.createElement('option');
+      opt.value = ds.slug;
+      opt.textContent = `${ds.robot_type} (${ds.episodes_available.length} eps, ${ds.fps}fps, ${ds.camera_labels.length} cam)`;
+      sel.appendChild(opt);
+    });
+  } catch (e) {
+    console.error('Failed to load datasets:', e);
+  }
+}
+
+document.getElementById('dataset-select').addEventListener('change', async (e) => {
+  const slug = e.target.value;
+  currentSlug = slug;
+  const epSel = document.getElementById('episode-select');
+  const viewBtn = document.getElementById('view-btn');
+  epSel.innerHTML = '<option value="">-- Select Episode --</option>';
+  epSel.disabled = !slug;
+  viewBtn.disabled = true;
+
+  if (!slug) {
+    document.getElementById('meta-display').innerHTML = '';
+    return;
+  }
+
+  const ds = datasets.find(d => d.slug === slug);
+  if (!ds) return;
+
+  document.getElementById('meta-display').innerHTML =
+    `<span>Robot: <strong>${ds.robot_type}</strong></span>` +
+    `<span>FPS: ${ds.fps}</span>` +
+    `<span>Cameras: ${ds.camera_labels.join(', ')}</span>` +
+    `<span>State dim: ${ds.state_dim}</span>` +
+    `<span>Action dim: ${ds.action_dim}</span>`;
+
+  ds.episodes_available.forEach(ep => {
+    const opt = document.createElement('option');
+    opt.value = ep.index;
+    opt.textContent = `Episode ${ep.index} (${ep.frames} frames)`;
+    epSel.appendChild(opt);
+  });
+  epSel.disabled = false;
+});
+
+document.getElementById('episode-select').addEventListener('change', () => {
+  document.getElementById('view-btn').disabled =
+    !document.getElementById('episode-select').value;
+});
+
+document.getElementById('view-btn').addEventListener('click', () => {
+  const slug = currentSlug;
+  const epIdx = document.getElementById('episode-select').value;
+  if (!slug || epIdx === '') return;
+
+  const rrdUrl = `${window.location.origin}/data/${slug}/episode_${String(epIdx).padStart(6, '0')}.rrd`;
+  const viewerBase = '{{VIEWER_BASE}}';
+  const viewerUrl = `${viewerBase}/index.html?url=${encodeURIComponent(rrdUrl)}`;
+
+  document.getElementById('placeholder').style.display = 'none';
+  const frame = document.getElementById('rerun-frame');
+  frame.src = viewerUrl;
+  frame.style.display = 'block';
+});
+
+init();
+</script>
+</body>
+</html>