| |
| """Local web UI for synchronized robot views and sensor/label curves.""" |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import math |
| import mimetypes |
| import os |
| import subprocess |
| import tempfile |
| import threading |
| import webbrowser |
| from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer |
| from pathlib import Path |
| from typing import Any, Dict, List |
| from urllib.parse import parse_qs, unquote, urlparse |
|
|
| import numpy as np |
| import pyarrow.parquet as pq |
|
|
|
|
| os.environ.setdefault( |
| "MPLCONFIGDIR", |
| str(Path(tempfile.gettempdir()) / "mplconfig-ui"), |
| ) |
|
|
|
|
| DATA_ROOT = Path(__file__).resolve().parent.parent |
| VIEWS = ["wrist", "side_1", "side_2"] |
| FORCE_NAMES = ["Fx", "Fy", "Fz", "Tx", "Ty", "Tz"] |
| FORCE_COLUMN = "observation.state.wrench_filtered_chunk" |
| VALID_LEN_COLUMN = "observation.state.wrench_chunk_valid_len" |
|
|
| |
| |
| |
| VIDEO_TRANSCODE = True |
| VIDEO_CACHE_TEMP: tempfile.TemporaryDirectory | None = None |
| VIDEO_CACHE_ROOT: Path | None = None |
| VIDEO_TRANSCODE_LOCK = threading.Lock() |
| VERBOSE = False |
|
|
|
|
| def find_one_file(task_dir: Path, pattern: str, description: str) -> Path: |
| matches = sorted(task_dir.glob(pattern)) |
| if not matches: |
| raise FileNotFoundError(f"Could not find {description}: {pattern}") |
| return matches[0] |
|
|
|
|
| def smooth_series(values: np.ndarray, window: int) -> np.ndarray: |
| if window <= 1 or len(values) == 0: |
| return np.asarray(values, dtype=np.float64).copy() |
| window = min(window, len(values)) |
| kernel = np.ones(window, dtype=np.float64) / window |
| left = window // 2 |
| right = window - 1 - left |
| padded = np.pad(values, (left, right), mode="edge") |
| return np.convolve(padded, kernel, mode="valid") |
|
|
|
|
| def interpolate_missing(values: np.ndarray) -> np.ndarray: |
| """Fill missing 1D values without smoothing the observed values.""" |
| values = np.asarray(values, dtype=np.float64).copy() |
| if values.ndim != 1: |
| raise ValueError("values must be a 1D array") |
| valid = np.isfinite(values) |
| if valid.all() or not valid.any(): |
| return values |
| indices = np.arange(len(values)) |
| return np.interp(indices, indices[valid], values[valid]) |
|
|
|
|
| def load_interaction_onset(task_dir: Path, episode: int) -> int | None: |
| annotation_path = task_dir / "meta" / "annotation.json" |
| if not annotation_path.exists(): |
| return None |
| try: |
| annotation = json.loads(annotation_path.read_text(encoding="utf-8")) |
| record = annotation.get("episodes", {}).get(f"{episode:06d}", {}) |
| except (json.JSONDecodeError, OSError): |
| return None |
|
|
| interaction = record.get("interaction", {}) |
| manual = interaction.get("manual", {}) |
| if isinstance(manual.get("onset_frame_index"), (int, float)): |
| return int(manual["onset_frame_index"]) |
| auto = interaction.get("auto", {}) |
| if isinstance(auto.get("onset_frame_index"), (int, float)): |
| return int(auto["onset_frame_index"]) |
| return None |
|
|
|
|
| def extract_force_channels(df: Any) -> np.ndarray: |
| raw = df[FORCE_COLUMN].to_numpy() |
| |
| stacked = np.stack([np.stack(list(item), axis=0) for item in raw], axis=0) |
| valid = df[VALID_LEN_COLUMN].to_numpy(dtype=np.int64) |
| result = np.zeros((len(stacked), len(FORCE_NAMES)), dtype=np.float64) |
| for i, (chunk, length) in enumerate(zip(stacked, valid)): |
| index = max(0, int(length) - 1) |
| result[i] = chunk[index] |
| return result |
|
|
|
|
| def load_episode_data(category: str, task: str, episode: int) -> Dict[str, Any]: |
| task_dir = DATA_ROOT / category / task |
| if not task_dir.is_dir(): |
| raise FileNotFoundError(f"Task directory does not exist: {task_dir}") |
|
|
| episode_key = f"{episode:06d}" |
| parquet_path = find_one_file( |
| task_dir, |
| f"data/chunk-*/episode_{episode_key}.parquet", |
| "episode parquet", |
| ) |
| table = pq.read_table(parquet_path) |
| df = table.to_pandas() |
|
|
| if "frame_index" in df.columns: |
| frame_indices = df["frame_index"].to_numpy(dtype=np.int64) |
| else: |
| frame_indices = np.arange(len(df), dtype=np.int64) |
|
|
| frame_label = smooth_series(df["frame_label"].to_numpy(dtype=np.float64), 15) |
|
|
| force = extract_force_channels(df) |
| force_smooth = np.column_stack( |
| [smooth_series(force[:, i], 15) for i in range(len(FORCE_NAMES))] |
| ) |
|
|
| force_norm_truth = np.sqrt( |
| np.sum(np.square(force_smooth[:, :3]), axis=1) |
| ) |
| ee_pose = np.stack(df["observation.state.ee_pose"].to_numpy(), axis=0) |
| position = np.column_stack( |
| [smooth_series(ee_pose[:, i].astype(np.float64), 15) for i in range(3)] |
| ) |
|
|
| videos: Dict[str, str] = {} |
| for view in VIEWS: |
| video_path = find_one_file( |
| task_dir, |
| f"videos/{view}/chunk-*/episode_{episode_key}.mp4", |
| f"video for view {view!r}", |
| ) |
| relative = video_path.relative_to(DATA_ROOT).as_posix() |
| videos[view] = f"/videos/{relative}" |
|
|
| interaction_onset = load_interaction_onset(task_dir, episode) |
|
|
| return { |
| "category": category, |
| "task": task, |
| "episode": episode, |
| "fps": 30.0, |
| "frame_count": len(frame_indices), |
| "frame_indices": frame_indices.tolist(), |
| "frame_label": frame_label.tolist(), |
| "force_names": FORCE_NAMES, |
| "force_truth": force_smooth.T.tolist(), |
| "force_norm_truth": force_norm_truth.tolist(), |
| "position": position.T.tolist(), |
| "interaction_onset": interaction_onset, |
| "videos": videos, |
| } |
|
|
|
|
| def list_categories_and_tasks() -> Dict[str, Any]: |
| categories: List[Dict[str, Any]] = [] |
| for category_dir in sorted(DATA_ROOT.iterdir()): |
| if not category_dir.is_dir() or category_dir.name.startswith("."): |
| continue |
| tasks = [ |
| task_dir.name |
| for task_dir in sorted(category_dir.iterdir()) |
| if task_dir.is_dir() and (task_dir / "meta" / "info.json").exists() |
| ] |
| if tasks: |
| categories.append({"name": category_dir.name, "tasks": tasks}) |
| return {"categories": categories} |
|
|
|
|
| def list_episode_records(category: str, task: str) -> List[Dict[str, Any]]: |
| path = DATA_ROOT / category / task / "meta" / "episodes.jsonl" |
| records: List[Dict[str, Any]] = [] |
| with path.open(encoding="utf-8") as handle: |
| for line in handle: |
| if line.strip(): |
| records.append(json.loads(line)) |
| return records |
|
|
|
|
| class UIRequestHandler(BaseHTTPRequestHandler): |
| server_version = "CRIAExplorerUI/1.0" |
|
|
| def log_message(self, fmt: str, *args: Any) -> None: |
| if VERBOSE: |
| print(f"[ui] {self.address_string()} - {fmt % args}") |
|
|
| def _send_json(self, payload: Any, status: int = 200) -> None: |
| body = json.dumps(payload, ensure_ascii=False).encode("utf-8") |
| self.send_response(status) |
| self.send_header("Content-Type", "application/json; charset=utf-8") |
| self.send_header("Content-Length", str(len(body))) |
| self.send_header("Cache-Control", "no-store") |
| self.end_headers() |
| self.wfile.write(body) |
|
|
| def _send_error(self, status: int, message: str) -> None: |
| self._send_json({"error": message}, status=status) |
|
|
| @staticmethod |
| def _browser_video_path(path: Path) -> Path: |
| if not VIDEO_TRANSCODE or path.suffix.lower() != ".mp4": |
| return path |
|
|
| global VIDEO_CACHE_TEMP, VIDEO_CACHE_ROOT |
| if VIDEO_CACHE_TEMP is None: |
| VIDEO_CACHE_TEMP = tempfile.TemporaryDirectory(prefix="forcewm_video_") |
| VIDEO_CACHE_ROOT = Path(VIDEO_CACHE_TEMP.name) |
| assert VIDEO_CACHE_ROOT is not None |
|
|
| relative = path.resolve().relative_to(DATA_ROOT.resolve()) |
| cached = VIDEO_CACHE_ROOT / relative |
| if cached.is_file(): |
| return cached |
|
|
| |
| |
| with VIDEO_TRANSCODE_LOCK: |
| if cached.is_file(): |
| return cached |
| cached.parent.mkdir(parents=True, exist_ok=True) |
| temporary = cached.with_suffix(".tmp.mp4") |
| command = [ |
| "ffmpeg", |
| "-hide_banner", |
| "-loglevel", |
| "error", |
| "-y", |
| "-i", |
| str(path), |
| "-map", |
| "0:v:0", |
| "-map", |
| "0:a?", |
| "-c:v", |
| "libx264", |
| "-preset", |
| "veryfast", |
| "-crf", |
| "23", |
| "-pix_fmt", |
| "yuv420p", |
| "-movflags", |
| "+faststart", |
| "-c:a", |
| "aac", |
| "-b:a", |
| "128k", |
| str(temporary), |
| ] |
| try: |
| subprocess.run(command, check=True, stdout=subprocess.DEVNULL) |
| temporary.replace(cached) |
| except (OSError, subprocess.CalledProcessError) as exc: |
| temporary.unlink(missing_ok=True) |
| raise RuntimeError(f"ffmpeg transcode failed for {path}: {exc}") from exc |
| return cached |
|
|
| def _send_file_range(self, path: Path) -> None: |
| resolved = path.resolve() |
| if not resolved.is_relative_to(DATA_ROOT.resolve()): |
| self._send_error(403, "forbidden path") |
| return |
| if not resolved.is_file(): |
| self._send_error(404, "file not found") |
| return |
|
|
| try: |
| resolved = self._browser_video_path(resolved) |
| except RuntimeError as exc: |
| self._send_error(500, str(exc)) |
| return |
|
|
| size = resolved.stat().st_size |
| range_header = self.headers.get("Range") |
| start = 0 |
| end = size - 1 |
| if range_header and range_header.startswith("bytes="): |
| try: |
| start_text, end_text = range_header[6:].split("-", 1) |
| start = int(start_text) if start_text else start |
| end = int(end_text) if end_text else end |
| except ValueError: |
| self._send_error(416, "invalid range") |
| return |
| start = max(0, min(start, size - 1)) |
| end = max(start, min(end, size - 1)) |
| status = 206 |
| else: |
| status = 200 |
|
|
| content_length = end - start + 1 |
| content_type = mimetypes.guess_type(resolved.name)[0] or "application/octet-stream" |
| self.send_response(status) |
| self.send_header("Content-Type", content_type) |
| self.send_header("Accept-Ranges", "bytes") |
| self.send_header("Content-Length", str(content_length)) |
| if status == 206: |
| self.send_header("Content-Range", f"bytes {start}-{end}/{size}") |
| self.end_headers() |
|
|
| with resolved.open("rb") as handle: |
| handle.seek(start) |
| remaining = content_length |
| while remaining > 0: |
| chunk = handle.read(min(1024 * 1024, remaining)) |
| if not chunk: |
| break |
| self.wfile.write(chunk) |
| remaining -= len(chunk) |
|
|
| def do_GET(self) -> None: |
| parsed = urlparse(self.path) |
| path = unquote(parsed.path) |
|
|
| if path == "/api/options": |
| self._send_json(list_categories_and_tasks()) |
| return |
|
|
| if path == "/api/data": |
| query = parse_qs(parsed.query) |
| try: |
| category = query.get("category", [""])[0] |
| task = query.get("task", [""])[0] |
| episode = int(query.get("episode", [""])[0]) |
| data = load_episode_data(category, task, episode) |
| self._send_json(data) |
| except (KeyError, TypeError, ValueError, FileNotFoundError) as exc: |
| self._send_error(400, str(exc)) |
| return |
|
|
| if path == "/api/episodes": |
| query = parse_qs(parsed.query) |
| try: |
| records = list_episode_records(query.get("category", [""])[0], query.get("task", [""])[0]) |
| source = query.get("source", ["all"])[0] |
| result = query.get("result", ["all"])[0] |
| if source != "all": |
| records = [r for r in records if r.get("source") == source] |
| if result != "all": |
| label = 1 if result == "success" else 0 |
| records = [r for r in records if int(r.get("episode_label", -1)) == label] |
| self._send_json({"episodes": records}) |
| except (KeyError, TypeError, ValueError, FileNotFoundError, json.JSONDecodeError) as exc: |
| self._send_error(400, str(exc)) |
| return |
|
|
| if path.startswith("/videos/"): |
| relative = path[len("/videos/") :] |
| self._send_file_range(DATA_ROOT / relative) |
| return |
|
|
| if path == "/" or path == "/index.html": |
| body = INDEX_HTML_BYTES |
| self.send_response(200) |
| self.send_header("Content-Type", "text/html; charset=utf-8") |
| self.send_header("Content-Length", str(len(body))) |
| self.end_headers() |
| self.wfile.write(body) |
| return |
|
|
| self._send_error(404, "not found") |
|
|
|
|
| INDEX_HTML = r"""<!doctype html> |
| <html lang="en"> |
| <head> |
| <meta charset="utf-8"> |
| <meta name="viewport" content="width=device-width, initial-scale=1"> |
| <title>CRIA Dataset Explorer</title> |
| <style> |
| :root { |
| --bg: #f3f5f8; |
| --panel: #ffffff; |
| --border: #e4e9f0; |
| --text: #17202a; |
| --muted: #66788c; |
| --truth: #2563eb; |
| --pred: #f97316; |
| --shadow: 0 5px 18px rgba(21, 40, 71, 0.06); |
| } |
| * { box-sizing: border-box; } |
| body { |
| margin: 0; |
| background: var(--bg); |
| color: var(--text); |
| font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", "PingFang SC", sans-serif; |
| } |
| .top-bar { |
| position: sticky; |
| top: 0; |
| z-index: 20; |
| background: linear-gradient(180deg, #ffffff, #fbfdff); |
| box-shadow: 0 2px 14px rgba(20, 40, 80, 0.06); |
| } |
| header { |
| position: relative; |
| display: grid; |
| grid-template-columns: auto minmax(0, 1fr) auto; |
| align-items: center; |
| gap: 5px; |
| padding: 5px 32px; |
| background: transparent; |
| border-bottom: 0; |
| } |
| .brand { |
| display: inline-flex; |
| align-items: center; |
| gap: 8px; |
| font-weight: 700; |
| font-size: 12px; |
| margin-right: 6px; |
| letter-spacing: .2px; |
| color: var(--text); |
| position: static; |
| transform: none; |
| white-space: nowrap; |
| grid-column: 1; |
| } |
| .brand svg { |
| width: 20px; |
| height: 20px; |
| color: #fff; |
| background: linear-gradient(135deg, #3b82f6, #1d4ed8); |
| padding: 4px; |
| border-radius: 8px; |
| box-shadow: 0 3px 8px rgba(37, 99, 235, .30); |
| } |
| .spacer { flex: 1 1 auto; } |
| header > .spacer { display: none; } |
| #load, #playPause { |
| width: 88px; |
| justify-content: center; |
| flex: 0 0 88px; |
| } |
| header > #load { grid-column: 3; } |
| |
| /* Selection set: a cohesive pill container holding the pickers */ |
| .control-group { |
| display: inline-flex; |
| align-items: center; |
| gap: 2px; |
| padding: 4px; |
| justify-self: start; |
| grid-column: 2; |
| background: linear-gradient(180deg, #eef3fa, #e6ecf5); |
| border: 1px solid var(--border); |
| border-radius: 11px; |
| box-shadow: inset 0 1px 2px rgba(30, 47, 75, 0.05); |
| } |
| .field { |
| display: inline-flex; |
| align-items: center; |
| gap: 4px; |
| padding: 3px 6px 3px 7px; |
| border-radius: 8px; |
| background: #ffffff; |
| border: 1px solid transparent; |
| transition: border-color .15s ease, box-shadow .15s ease, background .15s ease; |
| } |
| .field + .field { margin-left: 2px; } |
| .field:hover { border-color: #c8d6ea; } |
| .field:focus-within { |
| border-color: var(--truth); |
| box-shadow: 0 0 0 3px rgba(37, 99, 235, .12); |
| background: #fff; |
| } |
| .field label { |
| color: var(--muted); |
| font-size: 10px; |
| font-weight: 600; |
| text-transform: uppercase; |
| letter-spacing: .6px; |
| white-space: nowrap; |
| } |
| select, input[type="number"] { |
| height: 26px; |
| border: 0; |
| border-radius: 5px; |
| background: transparent; |
| color: var(--text); |
| font-size: 12px; |
| font-weight: 600; |
| padding: 0 4px; |
| outline: none; |
| min-width: 52px; |
| } |
| select { |
| appearance: none; |
| -webkit-appearance: none; |
| -moz-appearance: none; |
| padding-right: 18px; |
| background-image: url("data:image/svg+xml;utf8,<svg xmlns='http://www.w3.org/2000/svg' width='10' height='10' viewBox='0 0 10 10'><path fill='none' stroke='%2366788c' stroke-width='1.6' stroke-linecap='round' stroke-linejoin='round' d='M2 3.8l3 3 3-3'/></svg>"); |
| background-repeat: no-repeat; |
| background-position: right 2px center; |
| cursor: pointer; |
| } |
| #category, #task { min-width: 82px; } |
| #source, #result { min-width: 64px; } |
| #episode { min-width: 88px; } |
| input[type="number"] { width: 52px; text-align: left; -moz-appearance: textfield; } |
| input[type="number"]::-webkit-outer-spin-button, |
| input[type="number"]::-webkit-inner-spin-button { -webkit-appearance: none; margin: 0; } |
| |
| button { |
| display: inline-flex; |
| align-items: center; |
| justify-content: center; |
| gap: 6px; |
| height: 32px; |
| cursor: pointer; |
| border: 0; |
| border-radius: 9px; |
| background: linear-gradient(180deg, #3b82f6, #2563eb); |
| color: #fff; |
| font-size: 12px; |
| font-weight: 600; |
| padding: 0 15px; |
| outline: none; |
| box-shadow: 0 2px 6px rgba(37, 99, 235, .25), inset 0 1px 0 rgba(255, 255, 255, .22); |
| transition: background .15s ease, box-shadow .15s ease, transform .08s ease, filter .15s ease; |
| } |
| button svg { width: 14px; height: 14px; flex: 0 0 auto; } |
| button:hover:not(:disabled) { |
| background: linear-gradient(180deg, #2563eb, #1d4ed8); |
| transform: translateY(-1px); |
| box-shadow: 0 6px 16px rgba(37, 99, 235, .32), inset 0 1px 0 rgba(255, 255, 255, .22); |
| filter: saturate(1.05); |
| } |
| button:active:not(:disabled) { transform: translateY(0); box-shadow: 0 2px 6px rgba(37, 99, 235, .22), inset 0 1px 0 rgba(255, 255, 255, .22); } |
| button:focus-visible { box-shadow: 0 0 0 3px rgba(37, 99, 235, .28), 0 2px 6px rgba(37, 99, 235, .25); } |
| button.secondary { |
| background: linear-gradient(180deg, #ffffff, #eef2f7); |
| color: #26364a; |
| box-shadow: 0 2px 6px rgba(30, 47, 75, .08), inset 0 1px 0 rgba(255, 255, 255, .6); |
| } |
| button.secondary:hover:not(:disabled) { |
| background: linear-gradient(180deg, #ffffff, #e2e8f0); |
| color: #17202a; |
| box-shadow: 0 5px 12px rgba(30, 47, 75, .12), inset 0 1px 0 rgba(255, 255, 255, .6); |
| } |
| button:disabled { opacity: .5; cursor: not-allowed; transform: none; box-shadow: none; } |
| .grid { |
| display: grid; |
| grid-template-columns: repeat(3, minmax(0, 1fr)); |
| gap: 8px; |
| padding: 10px 32px 18px; |
| max-width: 1200px; |
| margin: 0 auto; |
| } |
| .top-bar > header, .progress-row { |
| max-width: 1200px; |
| margin-left: auto; |
| margin-right: auto; |
| } |
| .top-bar > header { width: 100%; } |
| .progress-row { width: 100%; } |
| .control-group { max-width: 100%; overflow: hidden; } |
| .field { min-width: 0; flex: 0 1 auto; } |
| .panel { |
| background: var(--panel); |
| border: 1px solid var(--border); |
| border-radius: 8px; |
| box-shadow: var(--shadow); |
| overflow: hidden; |
| min-width: 0; |
| } |
| .panel-title { |
| height: 23px; |
| display: flex; |
| align-items: center; |
| gap: 7px; |
| padding: 0 10px; |
| border-bottom: 1px solid var(--border); |
| font-size: 12px; |
| font-weight: 700; |
| color: var(--muted); |
| background: #fbfcfe; |
| } |
| .dot { width: 8px; height: 8px; border-radius: 50%; background: #cbd5e1; } |
| .video-panel video { display: block; width: 100%; height: auto; aspect-ratio: 4 / 3; object-fit: contain; background: #0b1220; } |
| .grid { font-family: "Times New Roman", Times, serif; } |
| .video-panel .panel-title { justify-content: flex-start; } |
| canvas.chart { display: block; width: 100%; height: 108px; } |
| .wide { grid-column: 1 / -1; } |
| .wide canvas.chart { height: 132px; } |
| .pair-row { |
| grid-column: 1 / -1; |
| display: grid; |
| grid-template-columns: repeat(2, minmax(0, 1fr)); |
| gap: 8px; |
| } |
| .pair-row canvas.chart { height: 132px; } |
| .playbar { |
| display: flex; |
| align-items: center; |
| gap: 8px; |
| padding: 5px 9px; |
| border-top: 1px solid var(--border); |
| background: #fbfcfe; |
| } |
| input[type="range"] { |
| flex: 1; |
| -webkit-appearance: none; |
| appearance: none; |
| height: 6px; |
| border-radius: 999px; |
| background: linear-gradient( |
| to right, |
| #2563eb var(--range-progress, 0%), |
| #dbe3ef var(--range-progress, 0%) |
| ); |
| cursor: pointer; |
| outline: none; |
| box-shadow: inset 0 1px 2px rgba(30, 47, 75, 0.10); |
| } |
| input[type="range"]::-webkit-slider-thumb { |
| -webkit-appearance: none; |
| appearance: none; |
| width: 16px; |
| height: 16px; |
| border-radius: 50%; |
| background: #ffffff; |
| border: 3px solid #2563eb; |
| box-shadow: 0 2px 6px rgba(37, 99, 235, .30); |
| transition: transform .12s ease, box-shadow .12s ease; |
| } |
| input[type="range"]:hover::-webkit-slider-thumb { transform: scale(1.18); box-shadow: 0 3px 9px rgba(37, 99, 235, .38); } |
| input[type="range"]:active::-webkit-slider-thumb { transform: scale(1.06); } |
| input[type="range"]::-moz-range-thumb { |
| width: 16px; |
| height: 16px; |
| border-radius: 50%; |
| background: #ffffff; |
| border: 3px solid #2563eb; |
| box-shadow: 0 2px 6px rgba(37, 99, 235, .30); |
| } |
| .legend { |
| display: inline-flex; |
| align-items: center; |
| gap: 10px; |
| padding: 5px 12px; |
| border-radius: 999px; |
| background: #f1f5fb; |
| border: 1px solid var(--border); |
| font-size: 11px; |
| color: var(--muted); |
| } |
| .legend span { display: inline-flex; align-items: center; gap: 6px; } |
| .legend i { width: 16px; height: 3px; border-radius: 2px; display: inline-block; box-shadow: 0 1px 2px rgba(0,0,0,.06); } |
| .source-badge { |
| display: inline-flex; |
| align-items: center; |
| height: 24px; |
| padding: 0 9px; |
| border-radius: 999px; |
| font-size: 10px; |
| font-weight: 700; |
| letter-spacing: .2px; |
| border: 1px solid var(--border); |
| white-space: nowrap; |
| } |
| .source-badge.synthetic { color: #9a6b00; background: #fff7db; } |
| .source-badge.episode_records { color: #047857; background: #e8f9f0; } |
| .source-badge.predicted_values\.json { color: #0369a1; background: #e8f5ff; } |
| .progress-row { |
| display: flex; |
| align-items: center; |
| gap: 8px; |
| padding: 5px 32px; |
| background: transparent; |
| border-bottom: 1px solid var(--border); |
| } |
| #time-label { |
| min-width: 96px; |
| text-align: center; |
| color: #26364a; |
| background: #eef2f7; |
| border: 1px solid var(--border); |
| border-radius: 7px; |
| padding: 3px 10px; |
| font-size: 11px; |
| font-weight: 600; |
| font-variant-numeric: tabular-nums; |
| box-shadow: inset 0 1px 1px rgba(30, 47, 75, 0.04); |
| } |
| @media (max-width: 900px) { |
| .grid { grid-template-columns: 1fr; padding: 12px 16px 20px; } |
| .pair-row { grid-template-columns: 1fr; } |
| header { flex-wrap: wrap; padding: 10px 16px; } |
| .progress-row { padding: 6px 16px; } |
| } |
| </style> |
| </head> |
| <body> |
| <div class="top-bar"> |
| <header> |
| <div class="brand"> |
| <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"> |
| <path d="M4 17l5-5 4 3 7-8" /> |
| <path d="M15 7h5v5" /> |
| </svg> |
| <span>CRIA Dataset Explorer</span> |
| </div> |
| <div class="control-group"> |
| <div class="field"> |
| <label for="category">Category</label> |
| <select id="category"></select> |
| </div> |
| <div class="field"> |
| <label for="task">Task</label> |
| <select id="task"></select> |
| </div> |
| <div class="field"> |
| <label for="source">Source</label> |
| <select id="source"><option value="all">all</option><option value="human">human</option><option value="pi05_joint">pi05_joint</option></select> |
| </div> |
| <div class="field"> |
| <label for="result">Result</label> |
| <select id="result"><option value="all">all</option><option value="success">success</option><option value="failure">failure</option></select> |
| </div> |
| <div class="field"> |
| <label for="episode">Episode</label> |
| <select id="episode"></select> |
| </div> |
| </div> |
| <button id="load"> |
| <svg viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true"> |
| <path d="M20 11a8 8 0 1 0-2.34 5.66" /> |
| <path d="M20 5v6h-6" /> |
| </svg> |
| Load |
| </button> |
| <div class="spacer"></div> |
| </header> |
| <div class="progress-row"> |
| <div class="legend"> |
| <span><i style="background:#2563eb"></i>measured signals</span> |
| <span><i style="background:#f97316"></i>interaction onset</span> |
| <span><i style="background:#fecaca;height:12px"></i>anomaly</span> |
| </div> |
| <input id="timeline" type="range" min="0" max="1000" step="0.01" value="0"> |
| <span id="time-label">frame 0 / 0</span> |
| <button id="playPause" class="secondary" disabled> |
| <svg id="play-icon" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true"><path d="M7 5l12 7-12 7z" /></svg> |
| <svg id="pause-icon" viewBox="0 0 24 24" fill="currentColor" aria-hidden="true" style="display:none"><rect x="6" y="5" width="4" height="14" rx="1" /><rect x="14" y="5" width="4" height="14" rx="1" /></svg> |
| <span id="playPauseText">Play</span> |
| </button> |
| </div> |
| </div> |
| |
| <main class="grid"> |
| <section class="panel video-panel"> |
| <div class="panel-title">wrist</div> |
| <video id="video-0" muted playsinline preload="auto"></video> |
| </section> |
| <section class="panel video-panel"> |
| <div class="panel-title">side_1</div> |
| <video id="video-1" muted playsinline preload="auto"></video> |
| </section> |
| <section class="panel video-panel"> |
| <div class="panel-title">side_2</div> |
| <video id="video-2" muted playsinline preload="auto"></video> |
| </section> |
| |
| <section class="panel"> |
| <div class="panel-title">F_x</div> |
| <canvas id="chart-0" class="chart"></canvas> |
| </section> |
| <section class="panel"> |
| <div class="panel-title">F_y</div> |
| <canvas id="chart-1" class="chart"></canvas> |
| </section> |
| <section class="panel"> |
| <div class="panel-title">F_z</div> |
| <canvas id="chart-2" class="chart"></canvas> |
| </section> |
| |
| <section class="panel"> |
| <div class="panel-title">τ_x</div> |
| <canvas id="chart-3" class="chart"></canvas> |
| </section> |
| <section class="panel"> |
| <div class="panel-title">τ_y</div> |
| <canvas id="chart-4" class="chart"></canvas> |
| </section> |
| <section class="panel"> |
| <div class="panel-title">τ_z</div> |
| <canvas id="chart-5" class="chart"></canvas> |
| </section> |
| |
| <section class="panel"> |
| <div class="panel-title">p_x</div> |
| <canvas id="chart-pose-0" class="chart"></canvas> |
| </section> |
| <section class="panel"> |
| <div class="panel-title">p_y</div> |
| <canvas id="chart-pose-1" class="chart"></canvas> |
| </section> |
| <section class="panel"> |
| <div class="panel-title">p_z</div> |
| <canvas id="chart-pose-2" class="chart"></canvas> |
| </section> |
| |
| </main> |
| |
| <script> |
| const $ = (id) => document.getElementById(id); |
| const TRUTH = '#2563eb'; |
| const views = ['wrist', 'side_1', 'side_2']; |
| const forceNames = ['F_x','F_y','F_z','tau_x','tau_y','tau_z']; |
| const poseNames = ['p_x', 'p_y', 'p_z']; |
| const videos = views.map((_, i) => $('video-' + i)); |
| const forceCharts = forceNames.map((_, i) => $('chart-' + i)); |
| const poseCharts = poseNames.map((_, i) => $('chart-pose-' + i)); |
| const playPause = $('playPause'); |
| const playPauseText = $('playPauseText'); |
| const playIcon = $('play-icon'); |
| const pauseIcon = $('pause-icon'); |
| const timeline = $('timeline'); |
| const timeLabel = $('time-label'); |
| const sourceSelect = $('source'); |
| const resultSelect = $('result'); |
| let data = null; |
| let currentFrame = 0; |
| let playing = false; |
| let rafId = null; |
| |
| const ONSET_COLOR = '#f97316'; |
| |
| function niceNum(range, round) { |
| const exp = Math.floor(Math.log10(range)); |
| const fraction = range / Math.pow(10, exp); |
| let nf; |
| if (round) { |
| if (fraction < 1.5) nf = 1; |
| else if (fraction < 2.25) nf = 2; |
| else if (fraction < 3.5) nf = 2.5; |
| else if (fraction < 7) nf = 5; |
| else nf = 10; |
| } else { |
| if (fraction <= 1) nf = 1; |
| else if (fraction <= 2) nf = 2; |
| else if (fraction <= 2.5) nf = 2.5; |
| else if (fraction <= 5) nf = 5; |
| else nf = 10; |
| } |
| return nf * Math.pow(10, exp); |
| } |
| |
| function niceTicks(min, max, targetTicks) { |
| if (!isFinite(min) || !isFinite(max) || min === max) { min = 0; max = 1; } |
| const range = niceNum(max - min, false); |
| const step = niceNum(range / Math.max(1, targetTicks - 1), true); |
| const niceMin = Math.floor(min / step) * step; |
| const niceMax = Math.ceil(max / step) * step; |
| return { min: niceMin, max: niceMax, step: step }; |
| } |
| |
| function tickDecimals(step) { |
| if (step >= 1) return 0; |
| let d = 0; |
| while (d < 6 && Math.abs(step * Math.pow(10, d) - Math.round(step * Math.pow(10, d))) > 1e-9) d++; |
| return d; |
| } |
| |
| function drawLineChart(canvas, truth, pred, frameIndex, title, yRange) { |
| const rect = canvas.getBoundingClientRect(); |
| const dpr = window.devicePixelRatio || 1; |
| const width = Math.max(200, rect.width); |
| const height = Math.max(120, rect.height); |
| canvas.width = Math.round(width * dpr); |
| canvas.height = Math.round(height * dpr); |
| const ctx = canvas.getContext('2d'); |
| ctx.setTransform(dpr, 0, 0, dpr, 0, 0); |
| ctx.clearRect(0, 0, width, height); |
| |
| const margin = { left: 46, right: 12, top: 14, bottom: 26 }; |
| const plotW = width - margin.left - margin.right; |
| const plotH = height - margin.top - margin.bottom; |
| if (plotW <= 10 || plotH <= 10) return; |
| |
| let minY, maxY, step; |
| if (yRange) { |
| minY = yRange.min; maxY = yRange.max; step = yRange.step; |
| } else { |
| let lo = Infinity, hi = -Infinity; |
| for (let i = 0; i < truth.length; i++) { |
| lo = Math.min(lo, truth[i], pred[i]); |
| hi = Math.max(hi, truth[i], pred[i]); |
| } |
| if (!Number.isFinite(lo) || !Number.isFinite(hi)) { lo = 0; hi = 1; } |
| const r = niceTicks(lo, hi, 5); |
| minY = r.min; maxY = r.max; step = r.step; |
| } |
| if (maxY === minY) maxY = minY + 1; |
| |
| const frameCount = data.frame_count; |
| function xAt(i) { return margin.left + (i / Math.max(1, frameCount - 1)) * plotW; } |
| function yAt(v) { return margin.top + (1 - (v - minY) / (maxY - minY)) * plotH; } |
| |
| // Shade frames whose frame_label is 0 (failure/anomaly). |
| ctx.fillStyle = 'rgba(248, 113, 113, 0.16)'; |
| let failureStart = null; |
| const visibleEnd = Math.min(frameCount, frameIndex + 1); |
| for (let i = 0; i <= visibleEnd; i++) { |
| const failure = i < visibleEnd && Number(data.frame_label[i]) === 0; |
| if (failure && failureStart === null) failureStart = i; |
| if ((!failure || i === frameCount) && failureStart !== null) { |
| const end = i - 1; |
| ctx.fillRect(xAt(failureStart), margin.top, Math.max(1, xAt(end) - xAt(failureStart)), plotH); |
| failureStart = null; |
| } |
| } |
| |
| ctx.strokeStyle = '#e5eaf0'; |
| ctx.lineWidth = 1; |
| ctx.font = '11px "Times New Roman", Times, serif'; |
| ctx.fillStyle = '#7b8a9a'; |
| const decimals = tickDecimals(step); |
| const tickCount = Math.round((maxY - minY) / step) + 1; |
| for (let k = 0; k < tickCount; k++) { |
| const v = minY + k * step; |
| const y = yAt(v); |
| ctx.beginPath(); ctx.moveTo(margin.left, y); ctx.lineTo(width - margin.right, y); ctx.stroke(); |
| ctx.textAlign = 'right'; |
| ctx.fillText(v.toFixed(decimals), margin.left - 8, y + 4); |
| } |
| |
| // X-axis: horizontal baseline + ticks every 100 frames |
| const axisY = margin.top + plotH; |
| const axisColor = '#c3ccd9'; |
| ctx.strokeStyle = axisColor; |
| ctx.lineWidth = 1.5; |
| ctx.beginPath(); |
| ctx.moveTo(margin.left, axisY); |
| ctx.lineTo(width - margin.right, axisY); |
| ctx.stroke(); |
| // Clean open arrowhead on the horizontal axis. |
| ctx.beginPath(); |
| ctx.moveTo(width - margin.right, axisY); |
| ctx.lineTo(width - margin.right - 7, axisY - 4); |
| ctx.moveTo(width - margin.right, axisY); |
| ctx.lineTo(width - margin.right - 7, axisY + 4); |
| ctx.stroke(); |
| // Vertical axis with an upward arrow. |
| ctx.beginPath(); |
| ctx.moveTo(margin.left, axisY); |
| ctx.lineTo(margin.left, margin.top); |
| ctx.stroke(); |
| ctx.beginPath(); |
| ctx.moveTo(margin.left, margin.top); |
| ctx.lineTo(margin.left - 4, margin.top + 7); |
| ctx.moveTo(margin.left, margin.top); |
| ctx.lineTo(margin.left + 4, margin.top + 7); |
| ctx.stroke(); |
| ctx.fillStyle = '#7b8a9a'; |
| ctx.textAlign = 'center'; |
| ctx.textBaseline = 'top'; |
| const lastFrame = frameCount - 1; |
| for (let f = 0; f <= lastFrame; f += 100) { |
| const x = xAt(f); |
| ctx.beginPath(); |
| ctx.moveTo(x, axisY); |
| ctx.lineTo(x, axisY + 4); |
| ctx.strokeStyle = '#c3ccd9'; |
| ctx.stroke(); |
| ctx.fillText(String(f), x, axisY + 6); |
| } |
| ctx.textAlign = 'left'; |
| ctx.textBaseline = 'alphabetic'; |
| |
| function drawSeries(values, color) { |
| ctx.beginPath(); |
| for (let i = 0; i <= frameIndex; i++) { |
| const x = xAt(i); |
| const y = yAt(values[i]); |
| if (i === 0) ctx.moveTo(x, y); else ctx.lineTo(x, y); |
| } |
| ctx.strokeStyle = color; |
| ctx.lineWidth = 2; |
| ctx.stroke(); |
| } |
| |
| drawSeries(truth, TRUTH); |
| |
| // Interaction onset vertical line (shown once playback passes it) |
| if (data.interaction_onset != null && frameIndex >= data.interaction_onset) { |
| const ox = xAt(data.interaction_onset); |
| ctx.beginPath(); |
| ctx.moveTo(ox, margin.top); |
| ctx.lineTo(ox, axisY); |
| ctx.strokeStyle = ONSET_COLOR; |
| ctx.setLineDash([5, 4]); |
| ctx.lineWidth = 1.6; |
| ctx.stroke(); |
| ctx.setLineDash([]); |
| } |
| |
| const cx = xAt(frameIndex); |
| ctx.beginPath(); |
| ctx.moveTo(cx, margin.top); |
| ctx.lineTo(cx, margin.top + plotH); |
| ctx.strokeStyle = '#cbd5e1'; |
| ctx.setLineDash([4, 4]); |
| ctx.lineWidth = 1; |
| ctx.stroke(); |
| ctx.setLineDash([]); |
| } |
| |
| let cachedRanges = null; |
| function computeSharedRange(indices) { |
| let lo = Infinity, hi = -Infinity; |
| for (const i of indices) { |
| for (const v of data.force_truth[i]) { lo = Math.min(lo, v); hi = Math.max(hi, v); } |
| } |
| return niceTicks(lo, hi, 5); |
| } |
| function getRanges() { |
| if (cachedRanges) return cachedRanges; |
| cachedRanges = { |
| force: computeSharedRange([0, 1, 2]), |
| torque: computeSharedRange([3, 4, 5]), |
| label: { min: 0, max: 1, step: 0.25 }, |
| }; |
| return cachedRanges; |
| } |
| |
| function renderCharts(frameIndex) { |
| if (!data) return; |
| currentFrame = Math.max(0, Math.min(frameIndex, data.frame_count - 1)); |
| const ranges = getRanges(); |
| for (let i = 0; i < forceCharts.length; i++) { |
| const r = i < 3 ? ranges.force : ranges.torque; |
| drawLineChart(forceCharts[i], data.force_truth[i], data.force_truth[i], currentFrame, forceNames[i], r); |
| } |
| for (let i = 0; i < poseCharts.length; i++) { |
| drawLineChart(poseCharts[i], data.position[i], data.position[i], currentFrame, poseNames[i], null); |
| } |
| // Invert ground truth for display: success(1)->0, failure(0)->1. |
| // The public CRIA viewer displays dataset signals only; no model predictions are loaded. |
| } |
| |
| function syncVideos() { |
| const master = videos[0]; |
| if (!master || master.readyState < 1) return; |
| for (let i = 1; i < videos.length; i++) { |
| const v = videos[i]; |
| if (v.readyState < 1) continue; |
| if (Math.abs(v.currentTime - master.currentTime) > 0.08) { |
| v.currentTime = master.currentTime; |
| } |
| } |
| } |
| |
| function loop() { |
| if (!playing) return; |
| const master = videos[0]; |
| if (master && master.readyState >= 1) { |
| const frame = Math.floor(master.currentTime * data.fps); |
| if (frame !== currentFrame) renderCharts(frame); |
| syncVideos(); |
| updateTimelineFromVideo(); |
| } |
| rafId = requestAnimationFrame(loop); |
| } |
| |
| function playAll() { |
| for (const v of videos) { |
| const p = v.play(); |
| if (p && p.catch) p.catch(() => {}); |
| } |
| playing = true; |
| playPauseText.textContent = 'Pause'; |
| playIcon.style.display = 'none'; |
| pauseIcon.style.display = 'block'; |
| cancelAnimationFrame(rafId); |
| rafId = requestAnimationFrame(loop); |
| } |
| |
| function pauseAll() { |
| playing = false; |
| cancelAnimationFrame(rafId); |
| for (const v of videos) v.pause(); |
| playPauseText.textContent = 'Play'; |
| playIcon.style.display = 'block'; |
| pauseIcon.style.display = 'none'; |
| } |
| |
| function formatFramesLabel(currentFrameIdx, totalFrames) { |
| return `frame ${currentFrameIdx} / ${totalFrames}`; |
| } |
| |
| function updateTimelineFromVideo() { |
| const master = videos[0]; |
| if (!master || master.readyState < 1 || !Number.isFinite(master.duration)) return; |
| if (document.activeElement !== timeline) { |
| timeline.value = master.currentTime; |
| } |
| const progress = master.duration ? (master.currentTime / master.duration) * 100 : 0; |
| timeline.style.setProperty('--range-progress', `${progress}%`); |
| const cur = Math.max(0, Math.min(Math.floor(master.currentTime * data.fps), data.frame_count - 1)); |
| timeLabel.textContent = formatFramesLabel(cur, data.frame_count - 1); |
| } |
| |
| function seekTo(value) { |
| if (!data) return; |
| const master = videos[0]; |
| const t = Math.max(0, Math.min(Number(value), master.duration || value)); |
| for (const v of videos) { |
| if (v.readyState >= 1) v.currentTime = t; |
| } |
| const progress = master.duration ? (t / master.duration) * 100 : 0; |
| timeline.style.setProperty('--range-progress', `${progress}%`); |
| const frameIdx = Math.max(0, Math.min(Math.floor(t * data.fps), data.frame_count - 1)); |
| renderCharts(frameIdx); |
| timeLabel.textContent = formatFramesLabel(frameIdx, data.frame_count - 1); |
| } |
| |
| async function loadOptions() { |
| const resp = await fetch('/api/options'); |
| const payload = await resp.json(); |
| const category = $('category'); |
| category.innerHTML = ''; |
| for (const item of payload.categories) { |
| const opt = document.createElement('option'); |
| opt.value = item.name; |
| opt.textContent = item.name; |
| category.appendChild(opt); |
| } |
| updateTasks(); |
| } |
| |
| function updateTasks() { |
| const category = $('category').value; |
| const task = $('task'); |
| task.innerHTML = ''; |
| // The next call to /api/options is intentionally simple and cheap. |
| fetch('/api/options').then((r) => r.json()).then((payload) => { |
| const item = payload.categories.find((c) => c.name === category); |
| if (!item) return; |
| for (const name of item.tasks) { |
| const opt = document.createElement('option'); |
| opt.value = name; |
| opt.textContent = name; |
| task.appendChild(opt); |
| } |
| updateEpisodes(); |
| }); |
| } |
| |
| let episodeRecords = []; |
| function updateEpisodes() { |
| const category = $('category').value; |
| const task = $('task').value; |
| const episodeSelect = $('episode'); |
| episodeSelect.innerHTML = ''; |
| episodeRecords = []; |
| if (!task) return; |
| const source = sourceSelect.value; |
| const result = resultSelect.value; |
| fetch(`/api/episodes?category=${encodeURIComponent(category)}&task=${encodeURIComponent(task)}&source=${encodeURIComponent(source)}&result=${encodeURIComponent(result)}`) |
| .then((r) => r.json()) |
| .then((payload) => { |
| episodeRecords = Array.isArray(payload.episodes) ? payload.episodes : []; |
| episodeRecords.forEach((record) => { |
| const opt = document.createElement('option'); |
| opt.value = String(record.episode_index); |
| opt.textContent = `${record.source || 'unknown'}_${Number(record.episode_label) === 1 ? 'success' : 'failure'}_${String(record.episode_index).padStart(6, '0')}`; |
| episodeSelect.appendChild(opt); |
| }); |
| if (episodeRecords.length) loadData(); |
| }) |
| .catch(() => {}); |
| } |
| |
| async function loadData() { |
| pauseAll(); |
| const category = $('category').value; |
| const task = $('task').value; |
| const episode = $('episode').value; |
| const resp = await fetch(`/api/data?category=${encodeURIComponent(category)}&task=${encodeURIComponent(task)}&episode=${encodeURIComponent(episode)}`); |
| if (!resp.ok) { |
| alert(await resp.text()); |
| return; |
| } |
| data = await resp.json(); |
| cachedRanges = null; |
| currentFrame = 0; |
| for (let i = 0; i < views.length; i++) { |
| videos[i].src = data.videos[views[i]]; |
| videos[i].load(); |
| } |
| videos[0].addEventListener('loadedmetadata', () => { |
| timeline.max = videos[0].duration || 0; |
| renderCharts(0); |
| playPause.disabled = false; |
| }, { once: true }); |
| renderCharts(0); |
| timeline.value = 0; |
| timeline.style.setProperty('--range-progress', '0%'); |
| timeLabel.textContent = formatFramesLabel(0, data.frame_count - 1); |
| playPause.disabled = false; |
| } |
| |
| $('category').addEventListener('change', updateTasks); |
| $('task').addEventListener('change', updateEpisodes); |
| sourceSelect.addEventListener('change', updateEpisodes); |
| resultSelect.addEventListener('change', updateEpisodes); |
| $('load').addEventListener('click', loadData); |
| playPause.addEventListener('click', () => playing ? pauseAll() : playAll()); |
| timeline.addEventListener('input', () => seekTo(timeline.value)); |
| document.addEventListener('keydown', (event) => { |
| if (event.key === 'Enter') { |
| event.preventDefault(); |
| loadData(); |
| } else if (event.code === 'Space' && !['SELECT', 'INPUT', 'TEXTAREA'].includes(document.activeElement.tagName)) { |
| event.preventDefault(); |
| playing ? pauseAll() : playAll(); |
| } |
| }); |
| window.addEventListener('resize', () => renderCharts(currentFrame)); |
| loadOptions(); |
| </script> |
| </body> |
| </html> |
| """ |
| INDEX_HTML_BYTES = INDEX_HTML.encode("utf-8") |
|
|
|
|
| def parse_args() -> argparse.Namespace: |
| parser = argparse.ArgumentParser(description="Serve the CRIA dataset explorer UI") |
| parser.add_argument("--host", default="127.0.0.1") |
| parser.add_argument("--port", type=int, default=8765) |
| parser.add_argument( |
| "--root", |
| type=Path, |
| default=Path(__file__).resolve().parent.parent, |
| help="Path to the CRIA dataset root", |
| ) |
| parser.add_argument( |
| "--verbose", |
| action="store_true", |
| help="Enable HTTP access logs", |
| ) |
| parser.add_argument("--no-browser", action="store_true") |
| return parser.parse_args() |
|
|
|
|
| def main() -> None: |
| args = parse_args() |
| global DATA_ROOT, VERBOSE |
| DATA_ROOT = args.root.expanduser().resolve() |
| VERBOSE = args.verbose |
| server = ThreadingHTTPServer((args.host, args.port), UIRequestHandler) |
| url = f"http://{args.host}:{args.port}/" |
| print(f"CRIA root: {DATA_ROOT}") |
| print(f"UI server running at {url}") |
| if not args.no_browser: |
| threading.Timer(0.8, lambda: webbrowser.open(url)).start() |
| try: |
| server.serve_forever() |
| except KeyboardInterrupt: |
| print("\nshutting down") |
| finally: |
| server.server_close() |
| global VIDEO_CACHE_TEMP |
| if VIDEO_CACHE_TEMP is not None: |
| VIDEO_CACHE_TEMP.cleanup() |
| VIDEO_CACHE_TEMP = None |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
