examples/demo_react_window.py

"""Demonstrate ReactWindowDataset:
  - build the dataset with sensible defaults
  - sample N random windows
  - render static grid PNG (N rows × 8 cols, each cell a [view | tac_L | tac_R] composite)
  - render one window as a GIF with sensor-frame axes projected on `view`
"""
import json
import sys
from pathlib import Path

import cv2
import numpy as np
import torch
from PIL import Image, ImageDraw, ImageFont
from scipy.spatial.transform import Rotation

sys.path.insert(0, "/tmp")
from react_window_dataset import ReactWindowDataset

OUT = Path("/media/yxma/Disk1/twm/figures/dataloader_examples")
OUT.mkdir(parents=True, exist_ok=True)

DATA_ROOT = Path("/media/yxma/Disk1/twm/processed/mode1_v1/motherboard")
BAD_FRAMES = Path("/media/yxma/Disk1/twm/figures/dataset_figures/bad_frames.json")
TASKS_JSON = Path("/tmp/tasks_local.json")    # written below from HF

# `view` in the .pt = realsense/cam0/color, center-cropped 640→480 then resized → 128
# cam0 serial = 143322063538 → T_mocap_to_cam_right.json
CALIB_DIR = Path("/home/yxma/MultimodalData/twm/calibration/result")
CAM_CALIB_FOR_VIEW = CALIB_DIR / "T_mocap_to_cam_right.json"
GEL_LEFT_CALIB = CALIB_DIR / "T_gel_to_rigid_left.json"
GEL_RIGHT_CALIB = CALIB_DIR / "T_gel_to_rigid_right.json"

AX_COLORS_RGB = [(0, 0, 255), (0, 255, 0), (255, 128, 0)]   # X red, Y green, Z blue-ish
AX_LABELS = ["X", "Y", "Z"]
GEL_DOT_COLOR = {"L": (0, 255, 120), "R": (0, 180, 255)}


def load_calib():
    cam = json.loads(CAM_CALIB_FOR_VIEW.read_text())
    return {
        "T_mocap_to_cam": np.array(cam["T_mocap_to_cam"], np.float64),
        "intrinsics": cam["intrinsics"],
        "gel_left":  np.array(json.loads(GEL_LEFT_CALIB.read_text())["gel_center_in_rigid_mm"], np.float64),
        "gel_right": np.array(json.loads(GEL_RIGHT_CALIB.read_text())["gel_center_in_rigid_mm"], np.float64),
    }


def pose_to_T(pose_7):
    """7-vec (x,y,z, qx,qy,qz,qw) in meters → 4×4 in mm."""
    pos_mm = np.array(pose_7[:3], np.float64) * 1000.0
    q = np.array(pose_7[3:], np.float64)
    q /= np.linalg.norm(q)
    T = np.eye(4)
    T[:3, :3] = Rotation.from_quat(q).as_matrix()
    T[:3, 3] = pos_mm
    return T


def project_to_view(P_world_mm, calib, *, view_size=128, orig_w=640, orig_h=480):
    """Project a single mocap-frame point (mm) into 128×128 view coords.

    The .pt `view` was made by center-cropping cam0 from 640×480 → 480×480 and
    then bilinear-resizing to 128×128. We replicate that here.
    """
    T_m2c = calib["T_mocap_to_cam"]
    I = calib["intrinsics"]
    P = (T_m2c @ np.append(P_world_mm, 1.0))[:3]
    if P[2] <= 0:
        return None
    u640 = I["fx"] * P[0] / P[2] + I["ppx"]
    v480 = I["fy"] * P[1] / P[2] + I["ppy"]
    crop_left = (orig_w - orig_h) / 2.0          # 80
    u_in_crop = u640 - crop_left
    s = view_size / orig_h                       # 128/480
    return (u_in_crop * s, v480 * s)


def project_gel_with_axes(pose_7, gel_center_mm, calib, axis_len_mm=80.0):
    """Return (center_uv, [(x_uv, y_uv, z_uv) or None])."""
    if pose_7 is None or np.allclose(pose_7, 0.0):
        return None, None
    T_r2m = pose_to_T(pose_7)
    P_gel = (T_r2m @ np.append(gel_center_mm, 1.0))[:3]
    R = T_r2m[:3, :3]
    tips = [P_gel + R @ np.array([axis_len_mm, 0, 0]),
            P_gel + R @ np.array([0, axis_len_mm, 0]),
            P_gel + R @ np.array([0, 0, axis_len_mm])]
    center = project_to_view(P_gel, calib)
    if center is None:
        return None, None
    return center, [project_to_view(t, calib) for t in tips]


def to_hwc(t):
    return t.permute(1, 2, 0).numpy() if t.ndim == 3 else t.numpy()


def annotate_view(view_uint8, pose_L, pose_R, calib, *, scale=1):
    """Draw sensor axes on a (H, W, 3) RGB image. Returns annotated copy."""
    H, W, _ = view_uint8.shape
    img = view_uint8.copy()
    for side, pose, gel in [("L", pose_L, calib["gel_left"]),
                             ("R", pose_R, calib["gel_right"])]:
        ctr, axes = project_gel_with_axes(pose, gel, calib)
        if ctr is None:
            continue
        cx, cy = int(round(ctr[0])), int(round(ctr[1]))
        if axes is not None:
            for tip, c, lab in zip(axes, AX_COLORS_RGB, AX_LABELS):
                if tip is None:
                    continue
                tx, ty = int(round(tip[0])), int(round(tip[1]))
                cv2.line(img, (cx, cy), (tx, ty), c, max(1, scale), cv2.LINE_AA)
        dot_color = GEL_DOT_COLOR[side]
        cv2.circle(img, (cx, cy), max(2, 3 * scale), dot_color, -1, cv2.LINE_AA)
        cv2.circle(img, (cx, cy), max(2, 3 * scale) + 1, (255, 255, 255), 1, cv2.LINE_AA)
        cv2.putText(img, side, (cx + 4, cy + 4),
                    cv2.FONT_HERSHEY_SIMPLEX, 0.4 * scale,
                    dot_color, max(1, scale), cv2.LINE_AA)
    return img


def make_static_grid(ds, sample_indices, calib, out_path,
                     n_cols=6, cell_scale=3):
    rows = []
    for idx in sample_indices:
        s = ds[idx]
        T = s["view"].shape[0]
        pick = np.linspace(0, T - 1, n_cols).astype(int)
        cells = []
        for t in pick:
            view_rgb = to_hwc(s["view"][t]).astype(np.uint8)
            view_rgb = annotate_view(view_rgb,
                                      s["sensor_left_pose"][t].numpy() if "left" in s["active_sensors"] else None,
                                      s["sensor_right_pose"][t].numpy() if "right" in s["active_sensors"] else None,
                                      calib, scale=1)
            tl = to_hwc(s["tactile_left"][t])
            tr = to_hwc(s["tactile_right"][t])
            # Stack horizontally: view | tac_L | tac_R, each 128×128
            triplet = np.concatenate([view_rgb, tl, tr], axis=1)  # (128, 384, 3)
            # Upscale for clarity
            triplet = cv2.resize(triplet, (triplet.shape[1] * cell_scale, triplet.shape[0] * cell_scale),
                                 interpolation=cv2.INTER_NEAREST)
            cells.append(triplet)
        rows.append(np.concatenate(cells, axis=1))

    H_row = rows[0].shape[0]
    W_row = rows[0].shape[1]
    pad_y = 16
    label_h = 88                 # vertical label band above each row
    canvas_h = 60 + len(rows) * (H_row + label_h + pad_y)
    canvas = np.full((canvas_h, W_row + 20, 3), 245, dtype=np.uint8)

    # Page header
    cv2.putText(canvas, f"ReactWindowDataset — {n_cols} evenly-spaced frames per sample (time runs left → right)",
                (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.7, (50, 50, 50), 2, cv2.LINE_AA)

    cell_w = W_row // n_cols
    for r, idx in enumerate(sample_indices):
        s = ds[idx]
        y0 = 60 + r * (H_row + label_h + pad_y)
        # Sample label band
        ep = s["episode_key"]
        dur_s = float(s["timestamps"][-1] - s["timestamps"][0])
        mL = float(s["tactile_left_mixed"].max())
        mR = float(s["tactile_right_mixed"].max())
        cv2.putText(canvas, f"sample #{idx}  ·  {ep}  ·  frames {s['frame_start']}-{s['frame_end']}  ({dur_s:.2f}s)  ·  active: {','.join(s['active_sensors'])}  ·  peak mixed L={mL:.2f}  R={mR:.2f}",
                    (10, y0 + 24), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (40, 40, 40), 1, cv2.LINE_AA)
        # Per-cell time labels
        T = s["view"].shape[0]
        pick = np.linspace(0, T - 1, n_cols).astype(int)
        for c, t in enumerate(pick):
            cv2.putText(canvas, f"t = {int(t)}  (frame {s['frame_start'] + int(t)})",
                        (10 + c * cell_w + 8, y0 + 56), cv2.FONT_HERSHEY_SIMPLEX, 0.45, (90, 90, 90), 1, cv2.LINE_AA)
        cv2.putText(canvas, "view  |  tactile_left  |  tactile_right",
                    (10, y0 + 76), cv2.FONT_HERSHEY_SIMPLEX, 0.42, (130, 130, 130), 1, cv2.LINE_AA)
        # Place row
        canvas[y0 + label_h:y0 + label_h + H_row, 10:10 + W_row] = rows[r]

    Image.fromarray(canvas).save(out_path)
    print(f"  static -> {out_path}  ({out_path.stat().st_size / 1024:.1f} KB)")


def make_gif(ds, sample_idx, calib, out_path, *, panel_scale=3, fps=15):
    s = ds[sample_idx]
    T = s["view"].shape[0]
    frames = []
    for t in range(T):
        view_rgb = to_hwc(s["view"][t]).astype(np.uint8)
        view_ann = annotate_view(view_rgb,
                                  s["sensor_left_pose"][t].numpy() if "left" in s["active_sensors"] else None,
                                  s["sensor_right_pose"][t].numpy() if "right" in s["active_sensors"] else None,
                                  calib, scale=1)
        # Upscale each subpanel
        view_big = cv2.resize(view_ann, (128 * panel_scale, 128 * panel_scale), cv2.INTER_NEAREST)
        tl_big = cv2.resize(to_hwc(s["tactile_left"][t]),
                            (128 * panel_scale, 128 * panel_scale), cv2.INTER_NEAREST)
        tr_big = cv2.resize(to_hwc(s["tactile_right"][t]),
                            (128 * panel_scale, 128 * panel_scale), cv2.INTER_NEAREST)
        triplet = np.concatenate([view_big, tl_big, tr_big], axis=1)
        # Header strip with frame counter
        H, W, _ = triplet.shape
        header = np.full((36, W, 3), 230, dtype=np.uint8)
        text = f"{s['episode_key']}  frame {s['frame_start'] + t}/{s['frame_end']}  ({t+1}/{T})  |  view | tactile_L | tactile_R"
        cv2.putText(header, text, (8, 24), cv2.FONT_HERSHEY_SIMPLEX, 0.55, (40, 40, 40), 1, cv2.LINE_AA)
        panel = np.concatenate([header, triplet], axis=0)
        frames.append(panel)

    # Shared-palette GIF
    pil = [Image.fromarray(f) for f in frames]
    mosaic = Image.new("RGB", (pil[0].width * min(8, len(pil)), pil[0].height))
    for i, im in enumerate(pil[: min(8, len(pil))]):
        mosaic.paste(im, (i * pil[0].width, 0))
    pal = mosaic.quantize(colors=128, method=Image.MEDIANCUT, dither=Image.NONE)
    qframes = [im.quantize(palette=pal, dither=Image.NONE) for im in pil]
    qframes[0].save(out_path, save_all=True, append_images=qframes[1:],
                     duration=int(round(1000 / fps)), loop=0, optimize=True, disposal=0)
    print(f"  gif    -> {out_path}  ({out_path.stat().st_size / 1024:.1f} KB)")


def main():
    # tasks.json was pre-fetched to TASKS_JSON via the base env
    if not TASKS_JSON.exists():
        raise FileNotFoundError(f"{TASKS_JSON} missing; fetch from yxma/React first")
    calib = load_calib()

    print("=== Build dataset ===")
    ds = ReactWindowDataset(
        data_root=DATA_ROOT,
        bad_frames_path=BAD_FRAMES,
        tasks_json_path=TASKS_JSON,
        window_length=16,
        stride=1,
        window_step=16,
        contact_metric="mixed",
        tactile_threshold=0.4,
        min_contact_fraction=0.6,
        which_sensors="any",
        skip_bad_frames=True,
        respect_active_sensors=True,
    )

    rng = np.random.default_rng(42)
    pick = rng.choice(len(ds), 4, replace=False)
    print(f"\n=== Render 4 random samples ===")
    make_static_grid(ds, pick, calib, OUT / "sample_grid.png")
    print(f"\n=== Render one as GIF ===")
    make_gif(ds, int(pick[0]), calib, OUT / "sample_window.gif")

    print("\nSample dict shapes (sample 0):")
    s = ds[int(pick[0])]
    for k, v in s.items():
        if isinstance(v, torch.Tensor):
            print(f"  {k:30s} {tuple(v.shape)}  {v.dtype}")
        else:
            print(f"  {k:30s} {v!r}")


if __name__ == "__main__":
    main()