visualize_dataset.py

#!/usr/bin/env python3
"""
LeRobot Dataset Visualizer — Web Dashboard
运行: python visualize_dataset.py -d <dataset_folder>
浏览器访问 http://localhost:7777
"""

import sys, json, argparse, base64, threading, webbrowser, time
from urllib.parse import urlparse, parse_qs
from http.server import HTTPServer, BaseHTTPRequestHandler

try:
    from scipy.ndimage import median_filter as _scipy_medfilt
    from scipy.ndimage import gaussian_filter as _scipy_gauss
    _HAS_SCIPY = True
except ImportError:
    _HAS_SCIPY = False

def _filter_tactile(vals, shape):
    """
    两步滤波：
    1. 两遍 3×3 中值滤波：彻底消除孤立单点和双点噪声（数学保证：孤立点被邻域中值替换）。
    2. 轻度高斯平滑（sigma=0.7）。
    """
    if not _HAS_SCIPY or not vals:
        return vals
    try:
        arr = np.array(vals, dtype=np.float32).reshape(shape)
        # 两遍中值滤波：第一遍消单点，第二遍消残余双点
        arr = _scipy_medfilt(arr, size=3, mode='nearest')
        arr = _scipy_medfilt(arr, size=3, mode='nearest')
        # 高斯平滑
        arr = _scipy_gauss(arr, sigma=0.7, mode='nearest')
        return arr.flatten().tolist()
    except Exception:
        return vals
from pathlib import Path
import numpy as np

try:
    import pyarrow as pa
    import pyarrow.parquet as pq
except ImportError:
    sys.exit("缺少 pyarrow")

try:
    import cv2
    _HAS_CV2 = True
except ImportError:
    _HAS_CV2 = False

PORT = 7777
_DS  = None

# 触觉传感器分组（基于 id 映射表）
# 拇指 3 片(0-2)；食/中/无名/小指各 4 片（指尖→中→尾→掌内关节）；掌心 1 片(19)
SENSOR_GROUPS = [
    {"id":"thumb",  "label":"拇指", "color":"#ff6b6b", "type":"finger",
     "sensors":["tactile_0","tactile_1","tactile_2"]},
    {"id":"index",  "label":"食指", "color":"#ffd93d", "type":"finger",
     "sensors":["tactile_3","tactile_4","tactile_5","tactile_6"]},
    {"id":"middle", "label":"中指", "color":"#6bcb77", "type":"finger",
     "sensors":["tactile_7","tactile_8","tactile_9","tactile_10"]},
    {"id":"ring",   "label":"无名", "color":"#4d96ff", "type":"finger",
     "sensors":["tactile_11","tactile_12","tactile_13","tactile_14"]},
    {"id":"pinky",  "label":"小指", "color":"#c77dff", "type":"finger",
     "sensors":["tactile_15","tactile_16","tactile_17","tactile_18"]},
    {"id":"palm",   "label":"掌心", "color":"#9ecbff", "type":"palm",
     "sensors":["tactile_19"]},
]


# ══════════════════════════════════════════════════════════════════════════════
class DataServer:
    def __init__(self, root: str):
        self.root = Path(root)
        self._load_info(); self._load_episodes()
        self._load_frames(); self._load_tasks(); self._load_cmap()
        self._compute_tactile_baselines()

    def _load_info(self):
        with open(self.root/"meta"/"info.json", encoding="utf-8") as f:
            self.info = json.load(f)
        self.fps               = self.info["fps"]
        self.tactile_2d_shapes = self.info.get("tactile_2d_shapes", {})
        print(f"OK  {self.root.name}  fps={self.fps}  frames={self.info['total_frames']}")

    def _load_episodes(self):
        files   = sorted((self.root/"meta"/"episodes").rglob("*.parquet"))
        ep_dict = pa.concat_tables([pq.read_table(f) for f in files]).to_pydict()
        n = len(ep_dict["episode_index"])
        self.episodes   = [{k: ep_dict[k][i] for k in ep_dict} for i in range(n)]
        self.n_episodes = n

    def _load_frames(self):
        files = sorted((self.root/"data").rglob("*.parquet"))
        fd    = pa.concat_tables([pq.read_table(f) for f in files]).to_pydict()
        self.frame_dict = fd
        self._idx_map   = {int(v): i for i, v in enumerate(fd["index"])}

    def _load_tasks(self):
        try:
            tp = next((self.root/"meta").rglob("tasks.parquet"), None)
            self.task_desc = pq.read_table(tp).to_pydict().get("task",["Unknown"])[0] if tp else "Unknown"
        except Exception:
            self.task_desc = "Unknown"

    def _load_cmap(self):
        cfg = (self.root.parent.parent /
               "hand"/"Usb_API_stable_Tujian_"/"spliter"/"config_mapping_zyhand.json")
        if cfg.exists():
            with open(cfg, encoding='utf-8') as f:
                data = json.load(f)
            self.cmap_colors = [
                f"#{int(c[0]*255):02x}{int(c[1]*255):02x}{int(c[2]*255):02x}"
                for c in data["color_map"]]
        else:
            self.cmap_colors = [
                "#262626","#0a2a5e","#0d4f8b","#0d7ab5","#18a0c8",
                "#1dc9d0","#22e0be","#39e87d","#8aef3f","#d4e830",
                "#f0c020","#f0901a","#e05015","#c02510","#8b0d08","#5e0505","#3d0202"]

    def _compute_tactile_baselines(self):
        """每个 episode 前 10 帧取均值作为触觉零点基准。"""
        self.tactile_baselines = {}
        for ep_id, ep in enumerate(self.episodes):
            start = int(ep["dataset_from_index"])
            end   = int(ep["dataset_to_index"]) - 1
            sums, count = {}, 0
            for fidx in range(start, min(start + 10, end + 1)):
                i = self._idx_map.get(fidx)
                if i is None:
                    continue
                for key in self.tactile_2d_shapes:
                    raw = self.frame_dict.get(f"tactile_{key}")
                    if raw is None or i >= len(raw) or raw[i] is None:
                        continue
                    arr = [float(v) for v in raw[i]]
                    if key not in sums:
                        sums[key] = [0.0] * len(arr)
                    for j, v in enumerate(arr):
                        sums[key][j] += v
                count += 1
            self.tactile_baselines[ep_id] = (
                {k: [v / count for v in sums[k]] for k in sums} if count else {}
            )
        print(f"触觉基准已计算  episodes={len(self.tactile_baselines)}")

    def get_tactile_timeline(self, ep_id: int) -> dict:
        ep       = self.episodes[ep_id]
        start    = int(ep["dataset_from_index"])
        end      = int(ep["dataset_to_index"]) - 1
        baseline = self.tactile_baselines.get(ep_id, {})
        sensors_data = []
        for grp in SENSOR_GROUPS:
            for sensor_key in grp["sensors"]:
                # parquet列名是 "tactile_tactile_0"，sensor_key是 "tactile_0"
                col_key = f"tactile_{sensor_key}"
                sums  = []
                for fidx in range(start, end + 1):
                    i = self._idx_map.get(fidx)
                    if i is None:
                        sums.append(0.0); continue
                    raw_col = self.frame_dict.get(col_key)
                    if raw_col is None or i >= len(raw_col) or raw_col[i] is None:
                        sums.append(0.0); continue
                    base = baseline.get(sensor_key, [])
                    vals = [float(v) for v in raw_col[i]]
                    if base:
                        vals = [max(0.0, v - b) for v, b in zip(vals, base)]
                    shape = self.tactile_2d_shapes.get(sensor_key)
                    if shape:
                        vals = _filter_tactile(vals, shape)
                    sums.append(round(sum(vals), 2))
                sensors_data.append({
                    "key":   sensor_key,
                    "color": grp["color"],
                    "sums":  sums,
                })
        return {"sensors": sensors_data, "n_frames": end - start + 1, "start": start}

    def get_frame(self, idx: int) -> dict:
        i = self._idx_map.get(idx, idx)
        return {k: self.frame_dict[k][i] for k in self.frame_dict}

    def get_video_frame_b64(self, ep_idx, frame_in_ep, stream):
        if not _HAS_CV2: return None
        ep      = self.episodes[ep_idx]
        vk      = f"observation.images.{stream}"
        chunk   = int(ep.get(f"videos/{vk}/chunk_index", 0))
        fidx    = int(ep.get(f"videos/{vk}/file_index",  0))
        from_ts = float(ep.get(f"videos/{vk}/from_timestamp", 0.0))
        vpath   = (self.root/f"videos/{vk}/chunk-{chunk:03d}/file-{fidx:04d}.mp4")
        if not vpath.exists(): return None
        cap = cv2.VideoCapture(str(vpath))
        cap.set(cv2.CAP_PROP_POS_FRAMES, int(round(from_ts*self.fps)) + frame_in_ep)
        ret, frame = cap.read(); cap.release()
        if not ret: return None
        if stream == "depth":
            r, g, b = frame[:,:,2], frame[:,:,1], frame[:,:,0]
            if np.abs(r.astype(int)-g.astype(int)).mean() < 4:
                frame = cv2.applyColorMap(r, cv2.COLORMAP_TURBO)
        _, buf = cv2.imencode(".jpg", frame, [cv2.IMWRITE_JPEG_QUALITY, 88])
        return base64.b64encode(buf).decode()


# ══════════════════════════════════════════════════════════════════════════════
class Handler(BaseHTTPRequestHandler):
    def log_message(self, *_): pass

    def _json(self, data):
        body = json.dumps(data, ensure_ascii=False).encode()
        self.send_response(200)
        self.send_header("Content-Type", "application/json")
        self.send_header("Access-Control-Allow-Origin", "*")
        self.end_headers()
        self.wfile.write(body)

    def _html(self, body):
        enc = body.encode()
        self.send_response(200)
        self.send_header("Content-Type", "text/html; charset=utf-8")
        self.end_headers()
        self.wfile.write(enc)

    def do_GET(self):
        ds  = _DS
        url = urlparse(self.path)
        qs  = parse_qs(url.query)

        if url.path == "/":
            self._html(build_html(ds))

        elif url.path == "/api/meta":
            self._json({
                "name": ds.root.name, "fps": ds.fps,
                "n_episodes": ds.n_episodes, "task": ds.task_desc,
                "tactile_2d_shapes": ds.tactile_2d_shapes,
                "cmap_colors": ds.cmap_colors,
                "sensor_groups": SENSOR_GROUPS,
                "episodes": [{"start": int(ep["dataset_from_index"]),
                               "end":   int(ep["dataset_to_index"]) - 1,
                               "length":int(ep["length"]),
                               "task":  (ep.get("tasks") or ["—"])[0]}
                              for ep in ds.episodes],
            })

        elif url.path == "/api/frame":
            n  = int(qs.get("n",  [0])[0])
            ep = int(qs.get("ep", [0])[0])
            d  = ds.get_frame(n)
            pos  = d.get("observation_motion_positions",    [])
            quat = d.get("observation_motion_quaternions",  [])
            tactile = {}
            baseline = ds.tactile_baselines.get(ep, {})
            for key in ds.tactile_2d_shapes:
                raw = d.get(f"tactile_{key}")
                if raw is not None:
                    base = baseline.get(key, [])
                    if base:
                        vals = [max(0.0, float(v) - b) for v, b in zip(raw, base)]
                    else:
                        vals = [float(v) for v in raw]
                    tactile[key] = _filter_tactile(vals, ds.tactile_2d_shapes[key])
            self._json({
                "timestamp":   float(d.get("timestamp", 0)),
                "positions":   [float(v) for v in pos]  if pos  else [],
                "quaternions": [float(v) for v in quat] if quat else [],
                "tactile":     tactile,
            })

        elif url.path == "/api/tactile_timeline":
            ep = int(qs.get("ep", [0])[0])
            self._json(ds.get_tactile_timeline(ep))

        elif url.path == "/api/image":
            ep  = int(qs.get("ep",   [0])[0])
            f   = int(qs.get("f",    [0])[0])
            typ = qs.get("type", ["color"])[0]
            self._json({"data": ds.get_video_frame_b64(ep, f, typ)})

        else:
            self.send_response(404); self.end_headers()


# ══════════════════════════════════════════════════════════════════════════════
def build_html(ds: DataServer) -> str:
    return r"""<!DOCTYPE html>
<html lang="zh">
<head>
<meta charset="UTF-8">
<title>LeRobot Dataset Visualizer</title>
<style>
*{box-sizing:border-box;margin:0;padding:0}
:root{
  --bg:#0d1117;--panel:#161b22;--border:#30363d;
  --text:#e6edf3;--dim:#8b949e;--accent:#58a6ff;--hdr:#0e1520;
  --r:10px;--gap:12px;
}
body{background:var(--bg);color:var(--text);
     font-family:'Segoe UI',system-ui,sans-serif;font-size:13px;
     height:100vh;display:flex;flex-direction:column;overflow:hidden}

/* ── Header ─────────────────────────────────────────────────────── */
#hdr{
  background:var(--hdr);border-bottom:1px solid var(--border);
  padding:0 18px;height:50px;display:flex;align-items:center;
  gap:14px;flex-shrink:0;
}
.logo{font-size:12px;font-weight:700;color:var(--accent);
      white-space:nowrap;letter-spacing:.04em}
#ep-ctrl{display:flex;align-items:center;gap:6px}
.ep-btn{
  background:#21262d;border:1px solid var(--border);color:var(--text);
  border-radius:6px;padding:3px 10px;cursor:pointer;font-size:13px;
  line-height:1;transition:background .12s;
}
.ep-btn:hover{background:#2d333b}
#ep-select{
  background:#21262d;border:1px solid var(--border);color:var(--text);
  border-radius:6px;padding:3px 8px;font-size:12px;cursor:pointer;
  outline:none;min-width:200px;
}
#ep-select:focus{border-color:var(--accent)}
.chip{
  background:#161b22;border:1px solid var(--border);border-radius:20px;
  padding:2px 10px;font-size:11px;color:var(--dim);white-space:nowrap;
}
.hdr-r{margin-left:auto;display:flex;align-items:center;gap:8px}
#play-btn{
  background:var(--accent);color:#000;border:none;border-radius:6px;
  padding:4px 13px;cursor:pointer;font-weight:700;font-size:12px;
}
#play-btn:hover{opacity:.85}

/* ── Main 2×2 ───────────────────────────────────────────────────── */
#main{
  flex:1;display:grid;
  grid-template-columns:1fr 1fr;
  grid-template-rows:1fr 1fr;
  gap:var(--gap);padding:var(--gap);min-height:0;
}
.panel{
  background:var(--panel);border:1px solid var(--border);
  border-radius:var(--r);display:flex;flex-direction:column;
  overflow:hidden;min-height:0;
}
.ph{
  padding:7px 13px;border-bottom:1px solid var(--border);
  display:flex;align-items:center;gap:8px;flex-shrink:0;
}
.ph .pt{font-weight:600;font-size:11px;letter-spacing:.05em;text-transform:uppercase}
.ph .pd{font-size:10px;color:var(--dim);margin-left:auto}
.pb{flex:1;display:flex;align-items:center;justify-content:center;
    overflow:hidden;position:relative;min-height:0}
.pb img{max-width:100%;max-height:100%;object-fit:contain}

/* ── Skeleton ────────────────────────────────────────────────────── */
#svg-skel{width:100%;height:100%}

/* ── Tactile ─────────────────────────────────────────────────────── */
#tac-scroll{
  width:100%;height:100%;overflow:auto;
  display:flex;align-items:center;justify-content:center;padding:10px 8px;
}
#tac-root{display:flex;flex-direction:column;align-items:center;gap:14px}

/* Fingers: bottom-aligned row */
#tac-fingers{
  display:flex;flex-direction:row;
  align-items:flex-end;   /* 指根底部对齐 */
  gap:18px;
}
.fg{display:flex;flex-direction:column;align-items:center;gap:0}
.fg-label{
  font-size:9px;font-weight:700;text-transform:uppercase;
  letter-spacing:.08em;margin-bottom:6px;opacity:.85;
}
.fg-sensors{display:flex;flex-direction:column;align-items:center;gap:3px}

/* Palm: horizontal row */
#tac-palm-wrap{display:flex;flex-direction:column;align-items:center;gap:6px}
#tac-palm-label{
  font-size:9px;font-weight:700;text-transform:uppercase;
  letter-spacing:.08em;color:#9ecbff;opacity:.85;
}
#tac-palm{display:flex;flex-direction:row;align-items:flex-end;gap:12px}

/* sensor card */
.sc{display:flex;flex-direction:column;align-items:center;gap:1px}
.sn{font-size:8px;color:var(--dim);line-height:1.2}
.ss{font-size:8px;color:var(--text);line-height:1.2}
canvas.tc{display:block;border-radius:2px}

/* section divider */
.sec-div{
  width:100%;border-top:1px solid var(--border);
  display:flex;align-items:center;gap:8px;
}

/* ── Task bar ────────────────────────────────────────────────────── */
#task-bar{
  background:#0c1625;border-bottom:1px solid var(--border);
  padding:0 18px;height:38px;display:flex;align-items:center;
  gap:14px;flex-shrink:0;overflow:hidden;
}
#task-bar-ep{font-size:11px;color:var(--dim);white-space:nowrap;min-width:64px}
#task-bar-text{
  font-size:15px;font-weight:600;color:#c77dff;
  white-space:nowrap;overflow:hidden;text-overflow:ellipsis;flex:1;
}

/* ── Tactile timeline canvas ─────────────────────────────────────── */
#tl-pb{overflow:hidden}
#tac-timeline{display:block}

/* ── Footer ──────────────────────────────────────────────────────── */
#ftr{
  background:var(--hdr);border-top:1px solid var(--border);
  padding:7px 18px;display:flex;align-items:center;gap:12px;flex-shrink:0;
}
#slider{flex:1;accent-color:var(--accent);cursor:pointer}
#ts-lbl{color:var(--dim);font-size:11px;white-space:nowrap;min-width:90px}
#fr-lbl{color:var(--dim);font-size:11px;white-space:nowrap;min-width:110px;text-align:right}
</style>
</head>
<body>

<!-- Header -->
<div id="hdr">
  <div class="logo">LeRobot Visualizer</div>

  <div id="ep-ctrl">
    <button class="ep-btn" id="btn-prev">◀</button>
    <select id="ep-select"></select>
    <button class="ep-btn" id="btn-next">▶</button>
  </div>

  <div class="hdr-r">
    <span class="chip" id="c-ds">—</span>
    <span class="chip" id="c-eps">—</span>
    <span class="chip" id="c-fps">—</span>
    <button id="play-btn">▶ Play</button>
  </div>
</div>

<!-- Task bar -->
<div id="task-bar">
  <span id="task-bar-ep">Ep 0</span>
  <span style="font-size:11px;color:var(--dim);white-space:nowrap">Description:</span>
  <span id="task-bar-text">—</span>
</div>

<!-- Main 2×2 -->
<div id="main">
  <!-- TL: Color -->
  <div class="panel">
    <div class="ph">
      <span class="pt" style="color:#9ecbff">Color</span>
      <span class="pd" id="pd-color">—</span>
    </div>
    <div class="pb"><img id="img-color" alt=""></div>
  </div>

  <!-- TR: Skeleton -->
  <div class="panel">
    <div class="ph">
      <span class="pt" style="color:#e6edf3">Motion Skeleton</span>
      <span class="pd" id="pd-skel">20 markers · 5 fingers</span>
    </div>
    <div class="pb">
      <svg id="svg-skel" viewBox="-200 -200 400 400"
           xmlns="http://www.w3.org/2000/svg"></svg>
    </div>
  </div>

  <!-- BL: Tactile Timeline -->
  <div class="panel">
    <div class="ph">
      <span class="pt" style="color:#c77dff">Tactile Timeline</span>
      <span class="pd" id="pd-timeline">—</span>
    </div>
    <div class="pb" id="tl-pb" style="display:block;padding:0">
      <canvas id="tac-timeline" style="display:block"></canvas>
    </div>
  </div>

  <!-- BR: Tactile -->
  <div class="panel">
    <div class="ph">
      <span class="pt" style="color:#6bcb77">Tactile</span>
      <span class="pd" id="pd-tac">—</span>
    </div>
    <div class="pb">
      <div id="tac-scroll">
        <div id="tac-root">
          <!-- Fingers row -->
          <div id="tac-fingers"></div>
          <!-- divider -->
          <div class="sec-div"></div>
          <!-- Palm row -->
          <div id="tac-palm-wrap">
            <div id="tac-palm-label">Palm</div>
            <div id="tac-palm"></div>
          </div>
        </div>
      </div>
    </div>
  </div>
</div>

<!-- Footer -->
<div id="ftr">
  <span id="ts-lbl">t = 0.000 s</span>
  <input type="range" id="slider" min="0" max="0" value="0">
  <span id="fr-lbl">Frame 0 / 0</span>
</div>

<script>
// ── State ──────────────────────────────────────────────────────────────────
let META=null, curEp=0, curFrame=0, playing=false, playTimer=null;
let skelScale=null, skelCenter=null;  // fixed from first frame of each episode
let TIMELINE=null;  // tactile timeline for current episode

// ── Colormap ───────────────────────────────────────────────────────────────
let CMAP=[];
function cmapRGB(t){
  const n=CMAP.length-1, fi=t*n;
  const lo=Math.floor(fi), hi=Math.min(lo+1,n), f=fi-lo;
  const p=h=>[parseInt(h.slice(1,3),16),parseInt(h.slice(3,5),16),parseInt(h.slice(5,7),16)];
  const [r0,g0,b0]=p(CMAP[lo]), [r1,g1,b1]=p(CMAP[hi]);
  return [r0+(r1-r0)*f, g0+(g1-g0)*f, b0+(b1-b0)*f];
}

// ── Tactile canvas map ─────────────────────────────────────────────────────
const cvMap={}, sumMap={};
const PX=9; // pixels per tactile point (fixed → equal-sized squares)

const TAC_NAMES={
  'tactile_0':'拇指尖','tactile_1':'拇指中','tactile_2':'拇指根',
  'tactile_3':'食指尖','tactile_4':'食指中','tactile_5':'食指根','tactile_6':'食指掌',
  'tactile_7':'中指尖','tactile_8':'中指中','tactile_9':'中指根','tactile_10':'中指掌',
  'tactile_11':'无名尖','tactile_12':'无名中','tactile_13':'无名根','tactile_14':'无名掌',
  'tactile_15':'小指尖','tactile_16':'小指中','tactile_17':'小指根','tactile_18':'小指掌',
  'tactile_19':'掌心',
};

function buildTactile(shapes, groups){
  const fingers=groups.filter(g=>g.type==='finger');
  const palmGrp =groups.find(g=>g.type==='palm');

  // ── Fingers section ──────────────────────────────────────
  const fRow=document.getElementById('tac-fingers');
  fRow.innerHTML='';
  fingers.forEach(grp=>{
    const col=document.createElement('div');
    col.className='fg';
    const lbl=document.createElement('div');
    lbl.className='fg-label';
    lbl.style.color=grp.color;
    lbl.textContent=grp.label;
    col.appendChild(lbl);
    const sensors=document.createElement('div');
    sensors.className='fg-sensors';
    grp.sensors.forEach(key=>{
      const sh=shapes[key]; if(!sh) return;
      const [nr,nc]=sh;
      sensors.appendChild(makeSensorCard(key,nr,nc,grp.color));
    });
    col.appendChild(sensors);
    fRow.appendChild(col);
  });

  // ── Palm section ─────────────────────────────────────────
  const pRow=document.getElementById('tac-palm');
  pRow.innerHTML='';
  if(palmGrp){
    palmGrp.sensors.forEach(key=>{
      const sh=shapes[key]; if(!sh) return;
      const [nr,nc]=sh;
      pRow.appendChild(makeSensorCard(key,nr,nc,palmGrp.color));
    });
  }

  const total=Object.keys(shapes).length;
  document.getElementById('pd-tac').textContent=`${total} sensors · ${PX}px/pt`;
}

function makeSensorCard(key,nr,nc,color){
  const wrap=document.createElement('div'); wrap.className='sc';
  const nm=document.createElement('div'); nm.className='sn';
  nm.textContent=(TAC_NAMES[key]||key)+` [${nr}×${nc}]`;
  wrap.appendChild(nm);
  const cv=document.createElement('canvas');
  cv.className='tc';
  cv.width=nc*PX; cv.height=nr*PX;
  cv.style.width=cv.width+'px'; cv.style.height=cv.height+'px';
  cv.style.border=`1px solid ${color}40`;
  cvMap[key]=cv; wrap.appendChild(cv);
  const sm=document.createElement('div'); sm.className='ss';
  sm.textContent='0.0'; sumMap[key]=sm; wrap.appendChild(sm);
  return wrap;
}

// ── Draw heatmap ───────────────────────────────────────────────────────────
function drawHeatmap(key, data){
  const cv=cvMap[key]; if(!cv) return;
  const sh=META.tactile_2d_shapes[key]; if(!sh) return;
  const [nr,nc]=sh;
  const vmax=Math.max(...data,1e-6);
  const ctx=cv.getContext('2d');
  const id=ctx.createImageData(cv.width,cv.height);
  const d32=id.data;
  for(let r=0;r<nr;r++){
    for(let c=0;c<nc;c++){
      const v=Math.max(0,data[r*nc+c])/vmax;
      const [R,G,B]=cmapRGB(Math.min(v,1));
      const px_y=r*PX, px_x=c*PX;
      for(let dy=0;dy<PX;dy++) for(let dx=0;dx<PX;dx++){
        const i=((px_y+dy)*cv.width+(px_x+dx))*4;
        d32[i]=R; d32[i+1]=G; d32[i+2]=B; d32[i+3]=255;
      }
    }
  }
  ctx.putImageData(id,0,0);
  if(sumMap[key]) sumMap[key].textContent=
    data.reduce((s,v)=>s+(v>0?v:0),0).toFixed(1);
}

// ── Quaternion utilities ───────────────────────────────────────────────────
function quatRotate(v, q){
  // Rotate vector v=[x,y,z] by unit quaternion q=[w,x,y,z]
  const [w,qx,qy,qz]=q, [vx,vy,vz]=v;
  const tx=2*(qy*vz-qz*vy), ty=2*(qz*vx-qx*vz), tz=2*(qx*vy-qy*vx);
  return [vx+w*tx+qy*tz-qz*ty, vy+w*ty+qz*tx-qx*tz, vz+w*tz+qx*ty-qy*tx];
}
function quatNorm(q){ const n=Math.hypot(...q); return q.map(v=>v/n); }

// ── Skeleton projection (draggable view) ──────────────────────────────────
const FC=['#ff6b6b','#ffd93d','#6bcb77','#4d96ff','#c77dff'];
const FIDX=[[0,1,2,3],[4,5,6,7],[8,9,10,11],[12,13,14,15],[16,17,18,19]];
const PBASES=[0,4,8,12,16];

// Z-up 视角：方位角 + 仰角（垂直于重力的 XY 平面为地面）
let viewAZ=0.75, viewEL=0.45;   // azimuth around Z-axis, elevation above XY-plane

function proj(pts3d){
  // 1. 绕 Z 轴旋转方位角
  // 2. 绕新 X 轴仰角倾斜
  // 3. 正射投影，丢弃深度
  const cA=Math.cos(viewAZ), sA=Math.sin(viewAZ);
  const cE=Math.cos(viewEL), sE=Math.sin(viewEL);
  return pts3d.map(([x,y,z])=>{
    const xR = x*cA - y*sA;          // rotate azimuth
    const yR = x*sA + y*cA;
    const yT = yR*cE + z*sE;         // tilt elevation (this becomes screen-Y)
    return [xR, -yT];                // flip so +Z is up on screen
  });
}

// Last skeleton data — re-rendered on drag without network fetch
let lastSkelPos=null, lastSkelQuat=null;

function initSkelDrag(){
  const svg=document.getElementById('svg-skel');
  svg.style.cursor='grab';
  let dragStart=null, az0, el0;
  svg.addEventListener('mousedown',e=>{
    dragStart={x:e.clientX,y:e.clientY}; az0=viewAZ; el0=viewEL;
    svg.style.cursor='grabbing'; e.preventDefault();
  });
  window.addEventListener('mousemove',e=>{
    if(!dragStart) return;
    viewAZ=az0+(e.clientX-dragStart.x)*0.009;
    viewEL=Math.max(0.05,Math.min(1.5, el0-(e.clientY-dragStart.y)*0.009));
    if(lastSkelPos) drawSkeleton(lastSkelPos,lastSkelQuat);
  });
  window.addEventListener('mouseup',()=>{
    dragStart=null; svg.style.cursor='grab';
  });
}

function drawSkeleton(positions, quaternions){
  lastSkelPos=positions; lastSkelQuat=quaternions;
  const svg=document.getElementById('svg-skel');
  svg.innerHTML='';
  const noData = !positions || positions.length<60 ||
                 Math.max(...positions.map(Math.abs)) < 1e-6;
  if(noData){
    const t=mkel('text',{x:0,y:10,fill:'#8b949e','text-anchor':'middle','font-size':'13'});
    t.textContent='Motion data unavailable'; svg.appendChild(t); return;
  }

  // Parse 20 world-space markers
  let pts3d=[];
  for(let i=0;i<20;i++) pts3d.push([positions[i*3],positions[i*3+1],positions[i*3+2]]);

  // First frame: record centroid and scale
  if(!skelCenter){
    const cx3=pts3d.reduce((s,p)=>s+p[0],0)/20;
    const cy3=pts3d.reduce((s,p)=>s+p[1],0)/20;
    const cz3=pts3d.reduce((s,p)=>s+p[2],0)/20;
    skelCenter=[cx3,cy3,cz3];
    // Scale: based on hand span at first frame (orientation-invariant max-radius)
    const rel0=pts3d.map(([x,y,z])=>[x-cx3,y-cy3,z-cz3]);
    const maxR=Math.max(...rel0.map(([x,y,z])=>Math.sqrt(x*x+y*y+z*z)));
    skelScale=90/Math.max(maxR,1e-6);  // smaller scale leaves room for displacement
  }
  // Subtract fixed first-frame center → translation relative to start is preserved
  pts3d=pts3d.map(([x,y,z])=>[x-skelCenter[0],y-skelCenter[1],z-skelCenter[2]]);

  const spts=pts3d.map(([x,y,z])=>[x*skelScale,y*skelScale,z*skelScale]);

  // Isometric projection
  const proj2d=proj(spts);
  const pts=proj2d; // already in pixel coords (centered at origin)

  // Palm center (projected)
  const pbS=PBASES.map(i=>spts[i]);
  const pm=[pbS.reduce((s,p)=>s+p[0],0)/5, pbS.reduce((s,p)=>s+p[1],0)/5,
            pbS.reduce((s,p)=>s+p[2],0)/5];
  const [[pcx,pcy]]=proj([pm]);

  // Ground grid: XY plane (Z=const, Z is vertical/gravity axis)
  {
    const GZ=-1.6*skelScale; // below hand (Z is up, gravity is -Z)
    const GR=2.4*skelScale, GN=8, gStep=GR*2/GN;
    for(let i=0;i<=GN;i++){
      const t=-GR+i*gStep;
      const isCenter=(i===GN/2);
      const sc=isCenter?'#2e3d52':'#1e2a38', sw=isCenter?'1.0':'0.6';
      // Lines parallel to X axis (vary X, Y=t, Z=ground)
      const [[ax0,ay0]]=proj([[-GR,t,GZ]]);
      const [[ax1,ay1]]=proj([[ GR,t,GZ]]);
      svg.appendChild(mkel('line',{x1:ax0,y1:ay0,x2:ax1,y2:ay1,stroke:sc,strokeWidth:sw}));
      // Lines parallel to Y axis (vary Y, X=t, Z=ground)
      const [[bx0,by0]]=proj([[t,-GR,GZ]]);
      const [[bx1,by1]]=proj([[t, GR,GZ]]);
      svg.appendChild(mkel('line',{x1:bx0,y1:by0,x2:bx1,y2:by1,stroke:sc,strokeWidth:sw}));
    }
  }

  // Palm dashed spokes
  PBASES.forEach(bi=>{
    const [x,y]=pts[bi];
    svg.appendChild(mkel('line',{x1:pcx,y1:pcy,x2:x,y2:y,
      stroke:'#444c56',strokeWidth:'1.2','stroke-dasharray':'4 3'}));
  });

  // Finger bones & joints
  FIDX.forEach((idxs,fi)=>{
    const col=FC[fi];
    for(let k=0;k<idxs.length-1;k++){
      const [x0,y0]=pts[idxs[k]], [x1,y1]=pts[idxs[k+1]];
      svg.appendChild(mkel('line',{x1:x0,y1:y0,x2:x1,y2:y1,
        stroke:col,strokeWidth:'2.8',strokeLinecap:'round'}));
    }
    idxs.forEach(i=>{
      const [x,y]=pts[i];
      svg.appendChild(mkel('circle',{cx:x,cy:y,r:'4.5',
        fill:col,stroke:'#0d1117',strokeWidth:'1.2'}));
    });
  });

  // Palm star
  svg.appendChild(mkel('circle',{cx:pcx,cy:pcy,r:'8',
    fill:'#ffffff18',stroke:'#ffffff88',strokeWidth:'1.5'}));
  const star=mkel('text',{x:pcx,y:pcy+4.5,'text-anchor':'middle',
    fill:'white','font-size':'11','font-weight':'bold'});
  star.textContent='★'; svg.appendChild(star);
}

function mkel(tag,attrs){
  const el=document.createElementNS('http://www.w3.org/2000/svg',tag);
  for(const[k,v] of Object.entries(attrs)) el.setAttribute(k,v);
  return el;
}

// ── Tactile Timeline ───────────────────────────────────────────────────────
async function fetchTimeline(ep){
  TIMELINE=null;
  document.getElementById('pd-timeline').textContent='loading…';
  try{
    TIMELINE=await fetch(`/api/tactile_timeline?ep=${ep}`).then(r=>r.json());
    document.getElementById('pd-timeline').textContent=
      `${TIMELINE.n_frames} frames · 6 groups`;
  }catch(e){ document.getElementById('pd-timeline').textContent='error'; }
  drawTimeline(curFrame);
}

const TAC_NAMES_SHORT={
  'tactile_0':'拇尖','tactile_1':'拇中','tactile_2':'拇根',
  'tactile_3':'食尖','tactile_4':'食中','tactile_5':'食根','tactile_6':'食掌',
  'tactile_7':'中尖','tactile_8':'中中','tactile_9':'中根','tactile_10':'中掌',
  'tactile_11':'无尖','tactile_12':'无中','tactile_13':'无根','tactile_14':'无掌',
  'tactile_15':'小尖','tactile_16':'小中','tactile_17':'小根','tactile_18':'小掌',
  'tactile_19':'掌心',
};

function setupTimeline(){
  const pb=document.getElementById('tl-pb');
  const cv=document.getElementById('tac-timeline');
  if(!pb||!cv) return;
  function resize(){
    const W=pb.clientWidth, H=pb.clientHeight;
    if(W>10&&H>10){ cv.width=W; cv.height=H; drawTimeline(curFrame); }
  }
  new ResizeObserver(resize).observe(pb);
  resize();
}

function drawTimeline(frame){
  const cv=document.getElementById('tac-timeline');
  if(!cv||!cv.width||!cv.height) return;
  const W=cv.width, H=cv.height;
  const ctx=cv.getContext('2d');
  ctx.fillStyle='#161b22'; ctx.fillRect(0,0,W,H);
  if(!TIMELINE){
    ctx.fillStyle='#555e6a'; ctx.font='12px sans-serif'; ctx.textAlign='center';
    ctx.fillText('Loading…',W/2,H/2); return;
  }
  const sensors=TIMELINE.sensors, nf=TIMELINE.n_frames, start=TIMELINE.start;
  const fi=Math.max(0,Math.min(frame-start,nf-1));

  const LW=72;
  const PAD={l:36,r:LW+4,t:8,b:20};
  const cw=W-PAD.l-PAD.r, ch=H-PAD.t-PAD.b;

  // Y max
  let ymax=0;
  sensors.forEach(s=>s.sums.forEach(v=>{if(v>ymax)ymax=v;}));
  if(ymax<1) ymax=1;

  // Grid
  ctx.lineWidth=0.5;
  for(let i=0;i<=4;i++){
    const y=PAD.t+ch*(1-i/4);
    ctx.strokeStyle='#1e2a38';
    ctx.beginPath(); ctx.moveTo(PAD.l,y); ctx.lineTo(PAD.l+cw,y); ctx.stroke();
    ctx.fillStyle='#555e6a'; ctx.font='8px monospace'; ctx.textAlign='right';
    ctx.fillText(Math.round(ymax*i/4),PAD.l-3,y+3);
  }

  // Lines
  sensors.forEach(s=>{
    ctx.strokeStyle=s.color; ctx.lineWidth=1.2; ctx.globalAlpha=0.8;
    ctx.beginPath();
    s.sums.forEach((v,i)=>{
      const x=PAD.l+(nf>1?i/(nf-1):0)*cw;
      const y=PAD.t+ch*(1-v/ymax);
      i===0?ctx.moveTo(x,y):ctx.lineTo(x,y);
    });
    ctx.stroke();
  });
  ctx.globalAlpha=1;

  // Cursor
  const cx=PAD.l+(nf>1?fi/(nf-1):0)*cw;
  ctx.strokeStyle='rgba(255,255,255,0.5)'; ctx.lineWidth=1;
  ctx.setLineDash([3,3]);
  ctx.beginPath(); ctx.moveTo(cx,PAD.t); ctx.lineTo(cx,PAD.t+ch); ctx.stroke();
  ctx.setLineDash([]);
  ctx.fillStyle='#8b949e'; ctx.font='8px monospace'; ctx.textAlign='center';
  ctx.fillText('f'+fi,Math.min(Math.max(cx,18),W-LW-8),PAD.t+ch+13);

  // Right list: sensor name + current value
  const lx=W-LW;
  const rowH=Math.max(10,Math.min(14,ch/sensors.length));
  sensors.forEach((s,idx)=>{
    const val=(s.sums[fi]??0).toFixed(1);
    const ly=PAD.t+rowH*idx+rowH*0.78;
    const fs=Math.max(7,Math.min(9,Math.floor(rowH*0.75)));
    ctx.fillStyle=s.color; ctx.fillRect(lx,ly-4,6,2);
    ctx.font=`${fs}px sans-serif`;
    ctx.fillStyle='#c0c8d0'; ctx.textAlign='left';
    ctx.fillText(TAC_NAMES_SHORT[s.key]||s.key,lx+9,ly);
    ctx.fillStyle=s.color; ctx.textAlign='right';
    ctx.fillText(val,W-2,ly);
  });
}

// ── Fetch frame ────────────────────────────────────────────────────────────
let aborter=null;
function fetchFrame(n, ep){
  if(aborter) try{aborter.abort()}catch(_){}
  aborter=new AbortController();
  const sig=aborter.signal;
  const ep_data=META.episodes[ep];
  const fin=n-ep_data.start;

  fetch(`/api/frame?n=${n}&ep=${ep}`,{signal:sig}).then(r=>r.json()).then(d=>{
    document.getElementById('ts-lbl').textContent=`t = ${d.timestamp.toFixed(3)} s`;
    document.getElementById('fr-lbl').textContent=
      `Frame ${fin} / ${ep_data.length-1}`;
    drawSkeleton(d.positions, d.quaternions);
    for(const key of Object.keys(META.tactile_2d_shapes)){
      if(d.tactile[key]) drawHeatmap(key, d.tactile[key]);
    }
    drawTimeline(n);
  }).catch(e=>{ if(e.name!=='AbortError') console.warn('frame fetch:',e); });

  fetch(`/api/image?ep=${ep}&f=${fin}&type=color`,{signal:sig})
    .then(r=>r.json()).then(d=>{
      if(d.data) document.getElementById('img-color').src='data:image/jpeg;base64,'+d.data;
    }).catch(()=>{});

}

// ── Episode switch ─────────────────────────────────────────────────────────
function switchEp(ep){
  curEp=Math.max(0,Math.min(META.n_episodes-1,ep));
  skelScale=null; skelCenter=null; lastSkelPos=null; lastSkelQuat=null;
  // 清空骨架面板，避免上一个 episode 的残影
  const svgEl=document.getElementById('svg-skel');
  if(svgEl) svgEl.innerHTML='';
  const epd=META.episodes[curEp];
  curFrame=epd.start;
  const sl=document.getElementById('slider');
  sl.min=epd.start; sl.max=epd.end; sl.value=curFrame;
  document.getElementById('ep-select').value=curEp;
  // 更新顶部任务描述条
  document.getElementById('task-bar-ep').textContent=`Ep ${curEp}`;
  document.getElementById('task-bar-text').textContent=epd.task||'—';
  fetchFrame(curFrame,curEp);
  fetchTimeline(curEp);
}

// ── Play ───────────────────────────────────────────────────────────────────
function togglePlay(){
  playing=!playing;
  document.getElementById('play-btn').textContent=playing?'⏸ Pause':'▶ Play';
  if(playing) tick();
}
function tick(){
  if(!playing) return;
  const epd=META.episodes[curEp];
  curFrame=(curFrame>=epd.end)?epd.start:curFrame+1;
  document.getElementById('slider').value=curFrame;
  fetchFrame(curFrame,curEp);
  playTimer=setTimeout(tick,Math.max(40,1000/META.fps));
}

// ── Init ───────────────────────────────────────────────────────────────────
async function init(){
  const meta=await fetch('/api/meta').then(r=>r.json());
  META=meta; CMAP=meta.cmap_colors;

  document.getElementById('c-ds').textContent=meta.name;
  document.getElementById('c-eps').textContent=meta.n_episodes+' episodes';
  document.getElementById('c-fps').textContent=meta.fps+' fps';

  // Populate episode dropdown
  const sel=document.getElementById('ep-select');
  meta.episodes.forEach((ep,i)=>{
    const opt=document.createElement('option');
    opt.value=i;
    opt.textContent=`Episode ${i}  (${ep.length} frames)`;
    sel.appendChild(opt);
  });
  sel.addEventListener('change',()=>switchEp(parseInt(sel.value)));

  document.getElementById('btn-prev').onclick=()=>switchEp(curEp-1);
  document.getElementById('btn-next').onclick=()=>switchEp(curEp+1);
  document.getElementById('play-btn').onclick=togglePlay;

  const sl=document.getElementById('slider');
  sl.addEventListener('input',()=>{
    if(playing){clearTimeout(playTimer);playing=false;
      document.getElementById('play-btn').textContent='▶ Play';}
    curFrame=parseInt(sl.value);
    fetchFrame(curFrame,curEp);
  });

  buildTactile(meta.tactile_2d_shapes, meta.sensor_groups);
  initSkelDrag();
  setupTimeline();
  switchEp(0);
}
init();
</script>
</body>
</html>"""


# ══════════════════════════════════════════════════════════════════════════════
def _pick_folder():
    try:
        import tkinter as tk
        from tkinter import filedialog
        r=tk.Tk(); r.withdraw()
        p=filedialog.askdirectory(title="选择 LeRobot 数据集文件夹")
        r.destroy(); return p or None
    except Exception:
        return None

def main():
    global _DS
    parser=argparse.ArgumentParser()
    parser.add_argument("--dataset","-d",default=None)
    parser.add_argument("--port","-p",type=int,default=PORT)
    args=parser.parse_args()
    path=args.dataset or _pick_folder()
    if not path: sys.exit("未指定数据集路径")
    _DS=DataServer(path)
    class _Srv(HTTPServer):
        allow_reuse_address=True
    srv=_Srv(("127.0.0.1",args.port),Handler)
    url=f"http://127.0.0.1:{args.port}"
    print(f"\n可视化服务已启动  →  {url}\n按 Ctrl+C 停止\n")
    threading.Thread(target=lambda:(time.sleep(0.8),webbrowser.open(url)),daemon=True).start()
    try: srv.serve_forever()
    except KeyboardInterrupt: print("\n已停止")

if __name__=="__main__":
    main()