#!/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"""
LIBERO Dataset Viewer
Images
Agent View![]()
Eye In Hand![]()
Frame
Frame0
Total0
Reward0
Done0
| Logical Action | |
| Logical State | |
| Robot Action | |
| EE Position | |
| EE Orientation | |
| Gripper | |
"""
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())