droid/scripts/preprocess_droid_tracks.py

"""
Preprocess DROID tracks from local raw data (``data/droid_small``).

Reads ``trajectory.h5`` (cartesian + per-frame camera_extrinsics) and ``recordings/MP4``.
Projection: per-camera ZED intrinsics (ZED 2 vs ZED Mini) + distortion, native 1280x720 then scale to output.
Exterior mesh (7 pts/view): analytical per-frame projection.
Wrist: CoTracker for 25 background grid + 7 gripper mesh (fixed template seeds on frame 0).
"""

from __future__ import annotations

import os
import sys
from pathlib import Path


def _ensure_droid_main_on_syspath() -> Path:
    default_root = Path(__file__).resolve().parent.parent
    env = os.environ.get("DROID_MAIN_ROOT", "").strip()
    if env:
        alt = Path(env).expanduser().resolve()
        root = alt if (alt / "utils").is_dir() else default_root
    else:
        root = default_root
    p = str(root)
    if p not in sys.path:
        sys.path.insert(0, p)
    return root


_ensure_droid_main_on_syspath()

import argparse
import json
from typing import Dict, List, Optional

import cv2
import numpy as np
import torch
from tqdm import tqdm

from utils.cotracker_wrist_grid import (
    NUM_WRIST_GRID,
    NUM_WRIST_MESH,
    NUM_WRIST_POINTS,
    default_cotracker_checkpoint,
    load_cotracker_predictor,
    track_points_on_video,
)
from utils.raw_episode_loader import RawDroidEpisode, iter_raw_droid_episodes
from utils.camera_geometry import (
    DROID_NATIVE_HW,
    make_image_grid,
    project_gripper_mesh,
    scale_pixels_between_hw,
    wrist_gripper_template_pixels,
)
from utils.track_coords import clamp_tracks_pixels_for_draw, normalize_tracks_xy
from utils.karlp_calib import KarlpCalibStore, default_karlp_calib_dir
from utils.zed_intrinsics import load_camera_intrinsics

NUM_EXT_MESH_POINTS = 7
NUM_COMBINED_POINTS = NUM_EXT_MESH_POINTS * 2 + NUM_WRIST_POINTS  # 46

VIEW_ORDER = ("exterior_1", "exterior_2", "wrist")
DEFAULT_IMAGE_SIZE = 448


def _resolve_karlp_calib_dir(karlp_calib_dir: str) -> str:
    """Use explicit dir, else env, else bundled ``droid/calibration/karlp`` if present."""
    explicit = karlp_calib_dir.strip() or os.environ.get("DROID_KARLP_CALIB_DIR", "").strip()
    if explicit:
        return explicit
    default = default_karlp_calib_dir()
    if (default / "cam2base_extrinsics.json").is_file():
        return str(default)
    return ""


def _resize_frames(frames: List[np.ndarray], out_h: int, out_w: int) -> np.ndarray:
    out = [cv2.resize(np.asarray(f, dtype=np.uint8), (out_w, out_h)) for f in frames]
    return np.stack(out, axis=0)


def _extrinsics_for(ep: RawDroidEpisode, view: str, t: int) -> np.ndarray:
    if view == "exterior_1":
        return ep.ext1_extrinsics[t]
    if view == "exterior_2":
        return ep.ext2_extrinsics[t]
    if view == "wrist":
        return ep.wrist_extrinsics[t]
    raise KeyError(view)


def _view_projection_setup(
    ep: RawDroidEpisode,
    view: str,
    *,
    zed_calib_dir: str,
    karlp: KarlpCalibStore | None,
) -> tuple[str, np.ndarray, np.ndarray, str | None, str]:
    if view == "exterior_1":
        serial, ctype, svo = ep.ext1_serial, ep.ext1_camera_type, ep.ext1_svo_path
    elif view == "exterior_2":
        serial, ctype, svo = ep.ext2_serial, ep.ext2_camera_type, ep.ext2_svo_path
    elif view == "wrist":
        serial, ctype, svo = ep.wrist_serial, ep.wrist_camera_type, ep.wrist_svo_path
    else:
        raise KeyError(view)

    intr_source = "zed_default"
    K: np.ndarray | None = None
    dist: np.ndarray | None = None
    if karlp is not None:
        parsed = karlp.intrinsics_for_serial(ep.episode_id, serial)
        if parsed is not None:
            K, dist = parsed
            intr_source = "karlp_intrinsics_json"

    if K is None:
        K, dist = load_camera_intrinsics(
            serial,
            ctype,
            svo_path=str(svo) if svo else None,
            calib_dir=zed_calib_dir,
        )
        if karlp is not None:
            intr_source = "zed_fallback"

    return serial, K, dist, str(svo) if svo else None, intr_source


def _tracks_episode(
    ep: RawDroidEpisode,
    *,
    image_size: int,
    wrist_grid_queries: np.ndarray,
    wrist_gripper_queries: np.ndarray,
    cotracker_model,
    cotracker_device: torch.device,
    zed_calib_dir: str,
    karlp: KarlpCalibStore | None,
) -> tuple[Dict[str, np.ndarray], Dict[str, np.ndarray], Dict[str, np.ndarray], Dict[str, dict]]:
    """Per-view tracks (T,N,2) and vis (T,N) in each panel's own square ``image_size`` frame."""
    t_len = int(ep.cartesian.shape[0])
    s = int(image_size)
    out_hw = (s, s)
    view_images = {
        "exterior_1": _resize_frames(ep.exterior_1_images, s, s),
        "exterior_2": _resize_frames(ep.exterior_2_images, s, s),
        "wrist": _resize_frames(ep.wrist_images, s, s),
    }

    wrist_queries = np.concatenate(
        [
            np.asarray(wrist_grid_queries, dtype=np.float32),
            np.asarray(wrist_gripper_queries, dtype=np.float32),
        ],
        axis=0,
    )
    wrist_trk_px, wrist_vis = track_points_on_video(
        cotracker_model,
        view_images["wrist"],
        wrist_queries,
        cotracker_device,
    )
    if int(wrist_trk_px.shape[1]) != NUM_WRIST_POINTS:
        raise ValueError(
            f"wrist CoTracker expects {NUM_WRIST_POINTS} points, got {wrist_trk_px.shape[1]}"
        )
    wrist_grid_trk_px = wrist_trk_px[:, :NUM_WRIST_GRID]
    wrist_mesh_trk_px = wrist_trk_px[:, NUM_WRIST_GRID : NUM_WRIST_GRID + NUM_WRIST_MESH]
    wrist_grid_vis = wrist_vis[:, :NUM_WRIST_GRID]
    wrist_mesh_vis = wrist_vis[:, NUM_WRIST_GRID : NUM_WRIST_GRID + NUM_WRIST_MESH]
    view_tracks: Dict[str, np.ndarray] = {}
    view_vis: Dict[str, np.ndarray] = {}
    view_calib: Dict[str, dict] = {}

    for view in VIEW_ORDER:
        serial, K_native, dist, svo_path, intr_source = _view_projection_setup(
            ep, view, zed_calib_dir=zed_calib_dir, karlp=karlp
        )
        view_calib[view] = {
            "serial": serial,
            "K_native": K_native,
            "dist": dist,
            "svo_path": svo_path,
            "intrinsic_source": intr_source,
            "extrinsic_source": ep.extrinsic_source.get(view, "h5_camera_extrinsics"),
        }
        if view == "wrist":
            grid_trk = normalize_tracks_xy(wrist_grid_trk_px, s, s)
            mesh_trk = normalize_tracks_xy(wrist_mesh_trk_px, s, s)
            view_tracks[view] = np.concatenate([grid_trk, mesh_trk], axis=1)
            view_vis[view] = np.concatenate([wrist_grid_vis, wrist_mesh_vis], axis=1)
            continue

        n_pts = NUM_EXT_MESH_POINTS
        trk_px = np.zeros((t_len, n_pts, 2), dtype=np.float32)
        vis = np.zeros((t_len, n_pts), dtype=np.float32)
        for t in range(t_len):
            cart = ep.cartesian[t]
            ext6 = _extrinsics_for(ep, view, t)
            mesh_pix, mesh_vis = project_gripper_mesh(
                cart,
                ext6,
                K=K_native,
                dist=dist,
                native_hw=DROID_NATIVE_HW,
                gripper_open=float(ep.gripper_open[t]),
            )
            mesh_pix = scale_pixels_between_hw(mesh_pix, DROID_NATIVE_HW, out_hw)
            trk_px[t] = mesh_pix.astype(np.float32)
            vis[t] = mesh_vis.astype(np.float32)
        view_tracks[view] = normalize_tracks_xy(trk_px, s, s)
        view_vis[view] = vis

    return view_tracks, view_vis, view_images, wrist_trk_px, view_calib


class DROIDTrackPreprocessor:
    def __init__(
        self,
        *,
        raw_data_root: str,
        output_path: str,
        min_len: int = 16,
        max_len: int = 800,
        max_episodes: int = 20000,
        save_viz: bool = True,
        viz_out_dir: Optional[str] = None,
        viz_fps: int = 10,
        viz_trail: int = 15,
        save_query_debug: bool = False,
        img_size: int = DEFAULT_IMAGE_SIZE,
        zed_calib_dir: str = "",
        karlp_calib_dir: str = "",
        cotracker_checkpoint: str | None = None,
        cotracker_device: str = "",
    ):
        self.raw_data_root = Path(raw_data_root)
        self.output_path = Path(output_path)
        self.min_len = min_len
        self.max_len = max_len
        self.max_episodes = max_episodes
        self.save_viz = save_viz
        self.viz_out_dir = Path(viz_out_dir) if viz_out_dir else (self.output_path / "viz_tracks")
        self.viz_fps = viz_fps
        self.viz_trail = max(0, int(viz_trail))
        self.save_query_debug = save_query_debug
        self.image_size = int(img_size) if int(img_size) > 0 else DEFAULT_IMAGE_SIZE
        self.zed_calib_dir = zed_calib_dir.strip()
        karlp_dir = _resolve_karlp_calib_dir(karlp_calib_dir)
        self.karlp: KarlpCalibStore | None = None
        if karlp_dir:
            self.karlp = KarlpCalibStore(karlp_dir)
        self.output_path.mkdir(parents=True, exist_ok=True)
        s = self.image_size
        self.wrist_grid_queries = make_image_grid(s, s, grid_size=5)
        self.wrist_gripper_queries = wrist_gripper_template_pixels((s, s)).astype(np.float32)

        if not self.raw_data_root.is_dir():
            raise FileNotFoundError(f"raw_data_root not found: {self.raw_data_root}")

        ckpt = Path(cotracker_checkpoint) if cotracker_checkpoint else default_cotracker_checkpoint()
        dev_str = cotracker_device.strip() or ("cuda:0" if torch.cuda.is_available() else "cpu")
        self.cotracker_device = torch.device(dev_str)
        self.cotracker_checkpoint = ckpt
        self.cotracker_model = load_cotracker_predictor(ckpt, self.cotracker_device)

    def process_episode(self, ep: RawDroidEpisode) -> bool:
        t_len = int(ep.cartesian.shape[0])
        if t_len < self.min_len or t_len > self.max_len:
            return False

        ep_idx = ep.episode_index
        view_tracks, view_vis, view_images, wrist_trk_px, view_calib = _tracks_episode(
            ep,
            image_size=self.image_size,
            wrist_grid_queries=self.wrist_grid_queries,
            wrist_gripper_queries=self.wrist_gripper_queries,
            cotracker_model=self.cotracker_model,
            cotracker_device=self.cotracker_device,
            zed_calib_dir=self.zed_calib_dir,
            karlp=self.karlp,
        )
        s = self.image_size
        ww = view_tracks["wrist"]
        oob = (
            (ww[..., 0] < 0.0)
            | (ww[..., 0] > 1.0)
            | (ww[..., 1] < 0.0)
            | (ww[..., 1] > 1.0)
        )
        px_oob = (
            (wrist_trk_px[..., 0] < 0)
            | (wrist_trk_px[..., 0] >= s)
            | (wrist_trk_px[..., 1] < 0)
            | (wrist_trk_px[..., 1] >= s)
        )
        if oob.any() or px_oob.any():
            tqdm.write(
                f"  ep {ep_idx:06d} wrist CoTracker OOB: "
                f"norm {100.0 * oob.mean():.1f}%  px {100.0 * px_oob.mean():.1f}%  "
                f"norm range x=[{ww[...,0].min():.3f},{ww[...,0].max():.3f}] "
                f"y=[{ww[...,1].min():.3f},{ww[...,1].max():.3f}]"
            )

        tracks_combined = np.concatenate(
            [view_tracks["exterior_1"], view_tracks["exterior_2"], view_tracks["wrist"]],
            axis=1,
        )
        vis_combined = np.concatenate(
            [view_vis["exterior_1"], view_vis["exterior_2"], view_vis["wrist"]],
            axis=1,
        )

        out_npz = self.output_path / f"episode_{ep_idx:06d}.npz"
        np.savez_compressed(
            out_npz,
            tracks=tracks_combined,
            vis=vis_combined,
            tracks_exterior_1=view_tracks["exterior_1"],
            tracks_exterior_2=view_tracks["exterior_2"],
            tracks_wrist=view_tracks["wrist"],
            vis_exterior_1=view_vis["exterior_1"],
            vis_exterior_2=view_vis["exterior_2"],
            vis_wrist=view_vis["wrist"],
            images_exterior_1=view_images["exterior_1"],
            images_exterior_2=view_images["exterior_2"],
            images_wrist=view_images["wrist"],
            language=np.array(ep.language),
            episode_id=np.array(ep.h5_path.parent.name),
            h5_path=np.array(str(ep.h5_path)),
            num_steps=t_len,
            point_slices=np.array([0, 7, 14, 46], dtype=np.int32),
            karlp_episode_id=np.array(ep.episode_id),
            projection_pose_source=np.array("observation_robot_state_cartesian"),
            projection_extrinsic_source=np.array(
                "ext_karlp_or_h5+wrist_h5_only" if self.karlp else "h5_camera_extrinsics_inv_cam_to_world"
            ),
            extrinsic_source_ext1=np.array(view_calib["exterior_1"]["extrinsic_source"]),
            extrinsic_source_ext2=np.array(view_calib["exterior_2"]["extrinsic_source"]),
            extrinsic_source_wrist=np.array(view_calib["wrist"]["extrinsic_source"]),
            intrinsic_source_ext1=np.array(view_calib["exterior_1"]["intrinsic_source"]),
            intrinsic_source_ext2=np.array(view_calib["exterior_2"]["intrinsic_source"]),
            intrinsic_source_wrist=np.array(view_calib["wrist"]["intrinsic_source"]),
            wrist_grid_source=np.array("cotracker"),
            wrist_mesh_source=np.array("cotracker_fixed_template"),
            wrist_gripper_query_source=np.array("WRIST_GRIPPER_TEMPLATE_FRAC"),
            wrist_projection_chain=np.array("cotracker_frame0_seeds"),
            tracks_coord_space=np.array("normalized_div_wh"),
            cotracker_checkpoint=np.array(str(self.cotracker_checkpoint)),
            projection_native_hw=np.array(DROID_NATIVE_HW, dtype=np.int32),
            intrinsics_ext1_serial=np.array(view_calib["exterior_1"]["serial"]),
            intrinsics_ext2_serial=np.array(view_calib["exterior_2"]["serial"]),
            intrinsics_wrist_serial=np.array(view_calib["wrist"]["serial"]),
            intrinsics_ext1_native_flat=np.asarray(view_calib["exterior_1"]["K_native"].reshape(-1)),
            intrinsics_ext2_native_flat=np.asarray(view_calib["exterior_2"]["K_native"].reshape(-1)),
            intrinsics_wrist_native_flat=np.asarray(view_calib["wrist"]["K_native"].reshape(-1)),
            image_size=np.array(self.image_size, dtype=np.int32),
            proj_image_hw=np.array([self.image_size, self.image_size], dtype=np.int32),
        )

        if self.save_query_debug:
            dbg = self.output_path / "query_debug" / f"episode_{ep_idx:06d}"
            dbg.mkdir(parents=True, exist_ok=True)
            for view in VIEW_ORDER:
                frame0 = view_images[view][0]
                q = clamp_tracks_pixels_for_draw(view_tracks[view][0:1], s, s, normalized=True)[0]
                vis_bgr = cv2.cvtColor(frame0, cv2.COLOR_RGB2BGR)
                for i, (x, y) in enumerate(q):
                    if not np.isfinite(x) or not np.isfinite(y):
                        continue
                    cv2.circle(vis_bgr, (int(round(x)), int(round(y))), 4, (0, 0, 255), -1)
                cv2.imwrite(str(dbg / f"{view}_frame0.jpg"), vis_bgr)

        if self.save_viz:
            from utils.viz_tracks import render_three_view_combined_video

            render_three_view_combined_video(
                view_images=view_images,
                view_tracks=view_tracks,
                view_vis=view_vis,
                out_path=self.viz_out_dir / f"episode_{ep_idx:06d}.mp4",
                fps=self.viz_fps,
                draw_trail=self.viz_trail,
            )
        return True

    def run(self) -> None:
        print("Starting DROID raw preprocessing")
        print(f"  Raw root: {self.raw_data_root}")
        print(f"  Output: {self.output_path}")
        print(f"  Output frames: {self.image_size}x{self.image_size} per view (3-panel MP4 = {self.image_size * 3}x{self.image_size})")
        if self.karlp:
            print(f"  KarlP calib: {self.karlp.calib_dir} ({self.karlp.num_covered_episodes} episodes)")
            print("  Episode filter: union(cam2base, cam2base_superset, cam2cam)")
            print("  Ext ext1/ext2: KarlP cam2base when serial present, else h5")
            print("  Wrist extrinsics: h5 only (observation/camera_extrinsics/{wrist_serial}_left)")
            print("  Intrinsics: KarlP intrinsics.json per episode+serial, else ZED fallback")
        else:
            print(f"  Intrinsics: per-serial ZED (ZED2 ext / ZED Mini wrist) @ 1280x720 -> {self.image_size}x{self.image_size}")
            if self.zed_calib_dir:
                print(f"  ZED calib dir: {self.zed_calib_dir}")
            print("  Extrinsics: h5 observation/camera_extrinsics")
            print(
                "  WARNING: KarlP disabled — full-tree scan is slow on droid_raw. "
                "Pass --karlp-calib-dir or install droid/calibration/karlp/"
            )
        print("  Pose: observation/robot_state/cartesian_position (h5)")
        print("  Tracks: ext1/ext2 gripper mesh analytical; wrist 25-grid + 7-gripper CoTracker")
        print(f"  CoTracker: {self.cotracker_checkpoint} on {self.cotracker_device}")
        if self.save_viz:
            print(f"  Viz: one 3-panel MP4 per episode -> {self.viz_out_dir}/episode_XXXXXX.mp4")
        print()

        processed = skipped = 0
        pbar = tqdm(total=self.max_episodes, desc="Processing episodes")
        for ep in iter_raw_droid_episodes(self.raw_data_root, karlp=self.karlp):
            if processed >= self.max_episodes:
                break
            try:
                if self.process_episode(ep):
                    processed += 1
                    pbar.update(1)
                else:
                    skipped += 1
            except Exception as e:
                print(f"\nError episode {ep.episode_index} ({ep.h5_path}): {e}")
                skipped += 1
        pbar.close()

        meta = {
            "num_processed": processed,
            "num_skipped": skipped,
            "source": "local_raw",
            "raw_data_root": str(self.raw_data_root),
            "image_size": self.image_size,
            "proj_image_hw": [self.image_size, self.image_size],
            "intrinsics": "karlp_intrinsics_json" if self.karlp else "per_serial_zed_native_hd_scaled",
            "karlp_calib_dir": str(self.karlp.calib_dir) if self.karlp else None,
            "karlp_num_covered_episodes": self.karlp.num_covered_episodes if self.karlp else None,
            "zed_calib_dir": self.zed_calib_dir or None,
            "num_points": NUM_COMBINED_POINTS,
            "wrist_grid": "cotracker_25",
            "wrist_mesh": "cotracker_fixed_template_7",
            "cotracker_checkpoint": str(self.cotracker_checkpoint),
            "cotracker_device": str(self.cotracker_device),
        }
        meta_path = self.output_path / "metadata.json"
        meta_path.write_text(json.dumps(meta, indent=2) + "\n", encoding="utf-8")
        print(f"\nDone: processed={processed}, skipped={skipped}")
        print(f"  Output: {self.output_path}")
        print(f"  Metadata: {meta_path}")


def main() -> None:
    p = argparse.ArgumentParser(description="Preprocess DROID tracks from local raw DROID data")
    p.add_argument(
        "--raw-data-root",
        type=str,
        default="/z/home/zhicao/droid_raw/1.0.1",
        help="Root with lab/success|failure/.../trajectory.h5 + recordings/MP4",
    )
    p.add_argument(
        "--output",
        type=str,
        default="/scratch1/home/zhicao/openpi/data_track/droid_small",
        help="Output directory for .npz and viz",
    )
    p.add_argument("--min-len", type=int, default=16)
    p.add_argument("--max-len", type=int, default=800)
    p.add_argument("--max-episodes", type=int, default=40)
    p.add_argument(
        "--img-size",
        type=int,
        default=DEFAULT_IMAGE_SIZE,
        help=f"Square output per view (default {DEFAULT_IMAGE_SIZE})",
    )
    p.add_argument("--save-query-debug", action="store_true")
    p.add_argument("--no-save-viz", action="store_true")
    p.add_argument("--viz-out-dir", type=str, default="")
    p.add_argument("--viz-fps", type=int, default=10)
    p.add_argument("--viz-trail", type=int, default=15, help="Track polyline tail length (frames)")
    p.add_argument(
        "--karlp-calib-dir",
        type=str,
        default="",
        help=(
            "KarlP/droid folder with cam2base_extrinsics.json, cam2base_extrinsic_superset.json, "
            "cam2cam_extrinsics.json, intrinsics.json. If set, only processes episodes in those files. "
            f"Default after download: {default_karlp_calib_dir()}"
        ),
    )
    p.add_argument(
        "--zed-calib-dir",
        type=str,
        default="",
        help="Folder with Stereolabs SN{serial}.conf (fallback intrinsics; DROID_ZED_CALIB_DIR)",
    )
    p.add_argument(
        "--cotracker-checkpoint",
        type=str,
        default="",
        help="CoTracker checkpoint (default: openpi/co-tracker/checkpoints/scaled_offline.pth)",
    )
    p.add_argument(
        "--cotracker-device",
        type=str,
        default="",
        help="torch device for CoTracker (default: cuda:0 if available else cpu)",
    )
    args = p.parse_args()

    DROIDTrackPreprocessor(
        raw_data_root=args.raw_data_root.strip(),
        output_path=args.output.strip(),
        min_len=args.min_len,
        max_len=args.max_len,
        max_episodes=args.max_episodes,
        save_viz=not args.no_save_viz,
        viz_out_dir=args.viz_out_dir.strip() or None,
        viz_fps=args.viz_fps,
        viz_trail=args.viz_trail,
        save_query_debug=bool(args.save_query_debug),
        img_size=args.img_size,
        zed_calib_dir=args.zed_calib_dir.strip(),
        karlp_calib_dir=args.karlp_calib_dir.strip(),
        cotracker_checkpoint=args.cotracker_checkpoint.strip() or None,
        cotracker_device=args.cotracker_device.strip(),
    ).run()


if __name__ == "__main__":
    main()