visualize_dataset.py

#!/usr/bin/env python3
"""Browser app for visualizing merged LIBERO HDF5 trajectories."""

from __future__ import annotations

import argparse
import base64
import io
import json
import re
import threading
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from urllib.parse import parse_qs, urlparse

import h5py
import numpy as np
from PIL import Image


SCRIPT_DIR = Path(__file__).resolve().parent
DEFAULT_DATASETS_DIR = SCRIPT_DIR / "datasets"
APP_STATE = {"datasets_dir": DEFAULT_DATASETS_DIR}
LOCK = threading.Lock()


def natural_demo_key(name: str) -> int:
    match = re.fullmatch(r"demo_(\d+)", name)
    return int(match.group(1)) if match else 10**9


def decode_value(value):
    if isinstance(value, bytes):
        return value.decode("utf-8")
    if isinstance(value, np.generic):
        return value.item()
    return value


def json_value(value):
    value = decode_value(value)
    if isinstance(value, np.ndarray):
        return value.tolist()
    return value


def image_to_data_url(array: np.ndarray) -> str:
    flipped = np.ascontiguousarray(np.flipud(array).astype(np.uint8))
    image = Image.fromarray(flipped, mode="RGB")
    buffer = io.BytesIO()
    image.save(buffer, format="PNG")
    encoded = base64.b64encode(buffer.getvalue()).decode("ascii")
    return f"data:image/png;base64,{encoded}"


def suite_paths() -> list[Path]:
    root = APP_STATE["datasets_dir"]
    return sorted(path for path in root.iterdir() if path.is_dir())


def hdf5_files(suite: str) -> list[Path]:
    return sorted((APP_STATE["datasets_dir"] / suite).glob("*.hdf5"))


def read_task_label(path: Path) -> str:
    try:
        with h5py.File(path, "r") as f:
            info = f["data"].attrs.get("problem_info")
            if info:
                info = decode_value(info)
                return json.loads(info).get("language_instruction", path.stem)
    except Exception:
        pass
    return path.stem.replace("_demo", "").replace("_", " ")


def selected_file(suite: str, task: str) -> Path:
    path = APP_STATE["datasets_dir"] / suite / task
    root = (APP_STATE["datasets_dir"] / suite).resolve()
    resolved = path.resolve()
    if root not in resolved.parents or not resolved.exists() or resolved.suffix != ".hdf5":
        raise ValueError("Invalid task file")
    return resolved


def read_metadata() -> dict:
    suites = []
    for suite_path in suite_paths():
        files = []
        for path in hdf5_files(suite_path.name):
            files.append({"file": path.name, "label": read_task_label(path)})
        suites.append({"name": suite_path.name, "tasks": files})
    return {"suites": suites}


def read_demos(suite: str, task: str) -> dict:
    path = selected_file(suite, task)
    with h5py.File(path, "r") as f:
        demos = []
        for name in sorted(f["data"].keys(), key=natural_demo_key):
            group = f[f"data/{name}"]
            demos.append({"name": name, "frames": int(group["actions"].shape[0])})
        attrs = {k: json_value(v) for k, v in f["data"].attrs.items()}
    return {"demos": demos, "attrs": attrs}


def read_frame(suite: str, task: str, demo: str, frame: int) -> dict:
    path = selected_file(suite, task)
    with LOCK, h5py.File(path, "r") as f:
        group = f[f"data/{demo}"]
        frame_count = int(group["actions"].shape[0])
        frame = max(0, min(frame, frame_count - 1))

        def arr(name: str):
            return np.asarray(group[name][frame])

        logical_state = decode_value(group["logical_states"][frame])
        logical_action = decode_value(group["logical_actions"][frame])
        try:
            parsed_state = json.loads(logical_state)
        except Exception:
            parsed_state = logical_state

        return {
            "frame": frame,
            "frames": frame_count,
            "agentview_rgb": image_to_data_url(arr("obs/agentview_rgb")),
            "eye_in_hand_rgb": image_to_data_url(arr("obs/eye_in_hand_rgb")),
            "logical_action": logical_action,
            "logical_state": parsed_state,
            "robot_action": arr("actions").round(6).tolist(),
            "robot_states": arr("robot_states").round(6).tolist(),
            "ee_pos": arr("obs/ee_pos").round(6).tolist(),
            "ee_ori": arr("obs/ee_ori").round(6).tolist(),
            "gripper_states": arr("obs/gripper_states").round(6).tolist(),
            "joint_states": arr("obs/joint_states").round(6).tolist(),
            "reward": json_value(group["rewards"][frame]),
            "done": json_value(group["dones"][frame]),
        }


HTML = r"""<!doctype html>
<html>
<head>
  <meta charset="utf-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>LIBERO Dataset Viewer</title>
  <style>
    :root {
      color-scheme: light;
      font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
      background: #f6f7f9;
      color: #1d232f;
    }
    * { box-sizing: border-box; }
    body { margin: 0; }
    header {
      height: 56px;
      display: flex;
      align-items: center;
      gap: 18px;
      padding: 0 20px;
      background: #ffffff;
      border-bottom: 1px solid #d9dde5;
    }
    h1 { margin: 0; font-size: 18px; font-weight: 650; }
    .subtle { color: #667085; font-size: 13px; }
    main { padding: 16px 20px 24px; }
    .controls {
      display: grid;
      grid-template-columns: 150px minmax(320px, 1.4fr) minmax(150px, .55fr) minmax(280px, 1fr) 90px 72px;
      gap: 10px;
      align-items: end;
      margin-bottom: 14px;
    }
    label { display: grid; gap: 5px; font-size: 12px; color: #475467; font-weight: 600; }
    select, input[type="range"], input[type="number"], button {
      min-width: 0;
      height: 34px;
      border: 1px solid #cfd5df;
      background: #ffffff;
      color: #1d232f;
      border-radius: 6px;
      padding: 0 10px;
      font: inherit;
    }
    button { cursor: pointer; min-width: 38px; font-weight: 650; }
    button:hover { background: #eef2f7; }
    .frame-control { display: grid; grid-template-columns: 1fr 86px; gap: 8px; align-items: center; }
    #demo { width: 100%; }
    #frame { width: 100%; }
    #frameNum { width: 86px; }
    .layout {
      display: grid;
      grid-template-columns: minmax(360px, 1.1fr) minmax(360px, .9fr);
      gap: 16px;
      align-items: start;
    }
    .panel {
      background: #ffffff;
      border: 1px solid #d9dde5;
      border-radius: 8px;
      overflow: hidden;
    }
    .panel h2 {
      margin: 0;
      padding: 10px 12px;
      font-size: 14px;
      border-bottom: 1px solid #e5e8ee;
      background: #fbfcfe;
    }
    .images {
      display: grid;
      grid-template-columns: repeat(2, minmax(0, 1fr));
      gap: 12px;
      padding: 12px;
    }
    figure { margin: 0; }
    figcaption { font-size: 12px; color: #667085; margin-bottom: 5px; }
    img {
      width: 100%;
      image-rendering: pixelated;
      border: 1px solid #d9dde5;
      border-radius: 6px;
      background: #20242c;
      aspect-ratio: 1 / 1;
      object-fit: contain;
    }
    .kv { padding: 12px; display: grid; gap: 10px; }
    .metric-grid { display: grid; grid-template-columns: repeat(4, 1fr); gap: 8px; }
    .metric { border: 1px solid #e5e8ee; border-radius: 6px; padding: 8px; background: #fbfcfe; }
    .metric span { display: block; font-size: 11px; color: #667085; margin-bottom: 4px; }
    .metric strong { font-size: 14px; }
    pre {
      margin: 0;
      padding: 12px;
      white-space: pre-wrap;
      overflow-wrap: anywhere;
      max-height: 340px;
      overflow: auto;
      background: #101828;
      color: #eef4ff;
      font-size: 12px;
      line-height: 1.45;
    }
    .inline-json {
      display: block;
      margin: 0;
      padding: 8px;
      max-height: 220px;
      overflow: auto;
      border-radius: 6px;
    }
    table { width: 100%; border-collapse: collapse; font-size: 12px; }
    td { padding: 6px 8px; border-bottom: 1px solid #edf0f5; vertical-align: top; }
    td:first-child { width: 130px; color: #667085; font-weight: 650; }
    @media (max-width: 1100px) {
      .controls { grid-template-columns: minmax(0, 1fr) minmax(0, 1fr); }
      .layout { grid-template-columns: 1fr; }
    }
    @media (max-width: 680px) {
      .controls { grid-template-columns: minmax(0, 1fr); }
    }
  </style>
</head>
<body>
  <header>
    <h1>LIBERO Dataset Viewer</h1>
    <div class="subtle" id="summary"></div>
  </header>
  <main>
    <section class="controls">
      <label>Suite<select id="suite"></select></label>
      <label>Task<select id="task"></select></label>
      <label>Demo<select id="demo"></select></label>
      <label>Frame<div class="frame-control"><input id="frame" type="range" min="0" value="0"><input id="frameNum" type="number" min="0" value="0"></div></label>
      <label>FPS<select id="fps"><option>5</option><option selected>10</option><option>15</option><option>20</option></select></label>
      <button id="play">Play</button>
    </section>

    <section class="layout">
      <div class="panel">
        <h2>Images</h2>
        <div class="images">
          <figure><figcaption>Agent View</figcaption><img id="agentview"></figure>
          <figure><figcaption>Eye In Hand</figcaption><img id="eye"></figure>
        </div>
      </div>
      <div class="panel">
        <h2>Frame</h2>
        <div class="kv">
          <div class="metric-grid">
            <div class="metric"><span>Frame</span><strong id="frameLabel">0</strong></div>
            <div class="metric"><span>Total</span><strong id="totalLabel">0</strong></div>
            <div class="metric"><span>Reward</span><strong id="reward">0</strong></div>
            <div class="metric"><span>Done</span><strong id="done">0</strong></div>
          </div>
          <table>
            <tbody>
              <tr><td>Logical Action</td><td id="logicalAction"></td></tr>
              <tr><td>Logical State</td><td><pre class="inline-json" id="logicalState"></pre></td></tr>
              <tr><td>Robot Action</td><td><code id="robotAction"></code></td></tr>
              <tr><td>EE Position</td><td><code id="eePos"></code></td></tr>
              <tr><td>EE Orientation</td><td><code id="eeOri"></code></td></tr>
              <tr><td>Gripper</td><td><code id="gripper"></code></td></tr>
            </tbody>
          </table>
        </div>
      </div>
    </section>
  </main>

  <script>
    const $ = id => document.getElementById(id);
    let meta = null, demos = [], timer = null, loading = false;

    async function api(path) {
      const res = await fetch(path);
      if (!res.ok) throw new Error(await res.text());
      return await res.json();
    }
    function option(select, value, text) {
      const el = document.createElement('option');
      el.value = value;
      el.textContent = text;
      select.appendChild(el);
    }
    function fmt(v) {
      return JSON.stringify(v, null, 2);
    }
    function fmtLogicalState(state) {
      if (!Array.isArray(state)) return String(state);
      return state.map(predicate => {
        if (!Array.isArray(predicate) || predicate.length === 0) return String(predicate);
        const [name, ...args] = predicate;
        return `${name}(${args.join(', ')})`;
      }).join('\n');
    }
    function currentSuiteObj() {
      return meta.suites.find(s => s.name === $('suite').value);
    }
    async function loadMeta() {
      meta = await api('/api/meta');
      $('suite').innerHTML = '';
      meta.suites.forEach(s => option($('suite'), s.name, s.name));
      $('summary').textContent = `${meta.suites.length} suites`;
      await loadTasks();
    }
    async function loadTasks() {
      const suite = currentSuiteObj();
      $('task').innerHTML = '';
      suite.tasks.forEach(t => option($('task'), t.file, t.label));
      await loadDemos();
    }
    async function loadDemos() {
      const data = await api(`/api/demos?suite=${encodeURIComponent($('suite').value)}&task=${encodeURIComponent($('task').value)}`);
      demos = data.demos;
      $('demo').innerHTML = '';
      demos.forEach(d => option($('demo'), d.name, `${d.name} (${d.frames} frames)`));
      configureFrame(0);
      await loadFrame(0);
    }
    function configureFrame(frame) {
      const demo = demos.find(d => d.name === $('demo').value);
      const maxFrame = Math.max(0, (demo ? demo.frames : 1) - 1);
      $('frame').max = maxFrame;
      $('frameNum').max = maxFrame;
      $('frame').value = Math.min(frame, maxFrame);
      $('frameNum').value = Math.min(frame, maxFrame);
    }
    async function loadFrame(frame) {
      if (loading) return;
      loading = true;
      try {
        configureFrame(frame);
        const q = new URLSearchParams({
          suite: $('suite').value,
          task: $('task').value,
          demo: $('demo').value,
          frame: $('frame').value
        });
        const data = await api(`/api/frame?${q}`);
        $('agentview').src = data.agentview_rgb;
        $('eye').src = data.eye_in_hand_rgb;
        $('frameLabel').textContent = data.frame;
        $('totalLabel').textContent = data.frames;
        $('reward').textContent = data.reward;
        $('done').textContent = data.done;
        $('logicalAction').textContent = data.logical_action;
        $('robotAction').textContent = fmt(data.robot_action);
        $('eePos').textContent = fmt(data.ee_pos);
        $('eeOri').textContent = fmt(data.ee_ori);
        $('gripper').textContent = fmt(data.gripper_states);
        $('logicalState').textContent = fmtLogicalState(data.logical_state);
      } finally {
        loading = false;
      }
    }
    function stop() {
      if (timer) clearInterval(timer);
      timer = null;
      $('play').textContent = 'Play';
    }
    function togglePlay() {
      if (timer) return stop();
      $('play').textContent = 'Pause';
      timer = setInterval(() => {
        const next = Number($('frame').value) + 1;
        if (next > Number($('frame').max)) return stop();
        $('frame').value = next;
        $('frameNum').value = next;
        loadFrame(next);
      }, 1000 / Number($('fps').value));
    }
    $('suite').addEventListener('change', () => { stop(); loadTasks(); });
    $('task').addEventListener('change', () => { stop(); loadDemos(); });
    $('demo').addEventListener('change', () => { stop(); configureFrame(0); loadFrame(0); });
    $('frame').addEventListener('input', e => { stop(); $('frameNum').value = e.target.value; loadFrame(Number(e.target.value)); });
    $('frameNum').addEventListener('change', e => { stop(); loadFrame(Number(e.target.value)); });
    $('play').addEventListener('click', togglePlay);
    loadMeta().catch(err => {
      document.body.innerHTML = `<pre>${err.stack || err}</pre>`;
    });
  </script>
</body>
</html>
"""


class Handler(BaseHTTPRequestHandler):
    def send_json(self, payload: dict, status: int = 200) -> None:
        data = json.dumps(payload).encode("utf-8")
        self.send_response(status)
        self.send_header("Content-Type", "application/json")
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)

    def send_html(self) -> None:
        data = HTML.encode("utf-8")
        self.send_response(200)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.send_header("Content-Length", str(len(data)))
        self.end_headers()
        self.wfile.write(data)

    def do_GET(self) -> None:
        try:
            parsed = urlparse(self.path)
            query = {k: v[0] for k, v in parse_qs(parsed.query).items()}
            if parsed.path == "/":
                self.send_html()
            elif parsed.path == "/api/meta":
                self.send_json(read_metadata())
            elif parsed.path == "/api/demos":
                self.send_json(read_demos(query["suite"], query["task"]))
            elif parsed.path == "/api/frame":
                self.send_json(
                    read_frame(
                        query["suite"],
                        query["task"],
                        query["demo"],
                        int(query.get("frame", 0)),
                    )
                )
            else:
                self.send_json({"error": "Not found"}, 404)
        except Exception as exc:
            self.send_json({"error": str(exc)}, 500)

    def log_message(self, fmt: str, *args) -> None:
        print(f"{self.address_string()} - {fmt % args}")


def main() -> int:
    parser = argparse.ArgumentParser()
    parser.add_argument(
        "--datasets-dir",
        type=Path,
        default=DEFAULT_DATASETS_DIR,
        help="Path to datasets directory. Defaults to ./datasets next to this script.",
    )
    parser.add_argument("--host", default="127.0.0.1")
    parser.add_argument("--port", type=int, default=8000)
    args = parser.parse_args()

    APP_STATE["datasets_dir"] = args.datasets_dir.expanduser().resolve()
    if not APP_STATE["datasets_dir"].exists():
        raise SystemExit(f"Datasets directory not found: {APP_STATE['datasets_dir']}")
    if not APP_STATE["datasets_dir"].is_dir():
        raise SystemExit(f"Datasets path is not a directory: {APP_STATE['datasets_dir']}")

    server = ThreadingHTTPServer((args.host, args.port), Handler)
    print(f"Serving dataset viewer at http://{args.host}:{args.port}")
    print(f"Reading datasets from {APP_STATE['datasets_dir']}")
    server.serve_forever()
    return 0


if __name__ == "__main__":
    raise SystemExit(main())