""" Preprocess DROID Dataset for ControlNet Training Generates 32-point tracks (25 grid + 7 mesh) for DROID episodes using: - Camera parameters from raw metadata_*.json (uuid-matched) - Franka mesh projection via forward kinematics - Data source: local LeRobot dataset Example:: python preprocess_droid_tracks.py \\ --lerobot-root /path/to/lerobot_dataset \\ --raw-data-root /path/to/raw_droid \\ --calib-dir /path/to/cameras \\ --output /path/to/out_npz """ from __future__ import annotations import os import sys from pathlib import Path def _ensure_droid_main_on_syspath() -> Path: """Prepend the directory that contains ``utils/`` to ``sys.path`` (for ``import utils.*``). Uses ``$DROID_MAIN_ROOT`` when it exists and contains ``utils/``; otherwise this script's parent directory (the ``droid/`` folder in this repo). """ 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 import re from typing import Any, Dict, List, Optional, Tuple import cv2 import numpy as np import torch from scipy.spatial.transform import Rotation as R from tqdm import tqdm from cotracker.predictor import CoTrackerPredictor from lerobot.common.datasets.lerobot_dataset import LeRobotDataset from utils.franka_mesh_projection import FrankaMeshProjector def _normalize_task(text: str) -> str: return re.sub(r"[^a-z0-9]+", " ", str(text).lower()).strip() def _scale_intrinsics(K: np.ndarray, ref_hw: Tuple[int, int], new_hw: Tuple[int, int]) -> np.ndarray: """Scale pinhole K from reference (H_ref, W_ref) to new (H_new, W_new).""" href, wref = ref_hw hnew, wnew = new_hw Ks = np.array(K, dtype=np.float64, copy=True) sx = wnew / float(wref) sy = hnew / float(href) Ks[0, 0] *= sx Ks[0, 2] *= sx Ks[1, 1] *= sy Ks[1, 2] *= sy return Ks def _image_to_uint8_hwc(img: Any, *, expect_rgb: bool) -> np.ndarray: """LeRobot / torch -> HWC uint8.""" if hasattr(img, "detach"): img = img.detach().cpu().numpy() else: img = np.asarray(img) if img.ndim == 3 and img.shape[0] in (1, 3) and img.shape[-1] not in (1, 3, 4): # CHW img = np.transpose(img, (1, 2, 0)) if np.issubdtype(img.dtype, np.floating): img = np.clip(img, 0.0, 1.0) img = (img * 255.0).astype(np.uint8) else: img = img.astype(np.uint8) if not expect_rgb and img.shape[-1] == 3: img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) return np.ascontiguousarray(img) def build_uuid_lookup_from_raw( raw_data_root: Path, annotations: Optional[Dict[str, Any]], ) -> Dict[Tuple[int, str], str]: """ Map (trajectory_length, normalized_language) -> uuid using per-episode metadata JSON. Used to align LeRobot episodes (length + task string) with raw DROID calibration uuid. """ lookup: Dict[Tuple[int, str], str] = {} for meta_path in sorted(raw_data_root.glob("**/metadata_*.json")): with meta_path.open() as f: m = json.load(f) uuid = m.get("uuid") if not uuid: continue length = int(m.get("trajectory_length", -1)) if length < 0: continue if annotations is not None and uuid in annotations: lang = annotations[uuid].get("language_instruction1", "") else: lang = str(m.get("current_task", "")).split("\n")[0] key = (length, _normalize_task(lang)) if key in lookup and lookup[key] != uuid: raise ValueError( f"Ambiguous uuid lookup for key {key}: {lookup[key]} vs {uuid} " f"(metadata files collide on length+language — check raw_data_root)." ) lookup[key] = uuid return lookup def _task_token_similarity(lerobot_task: str, candidate_text: str) -> float: a = set(_normalize_task(lerobot_task).split()) b = set(_normalize_task(candidate_text).split()) if not a or not b: return 0.0 return len(a & b) / max(1, len(a | b)) def build_uuid_resolution_tables( raw_data_root: Path, annotations: Optional[Dict[str, Any]], *, episode_order_sorted: bool, ) -> tuple[ Dict[Tuple[int, str], str], Dict[int, str], List[Tuple[str, int]], Dict[str, str], Dict[int, List[str]], ]: """ Returns: - lookup (length, norm_task) -> uuid - unique_by_length: trajectory_length -> uuid when exactly one episode has that length in metadata - episode_order: [(uuid, trajectory_length), ...] in the same discovery order as convert_droid_data_to_lerobot - uuid_to_langtext: uuid -> raw language string for similarity - uuids_by_length: trajectory_length -> list of uuids (for similarity tie-break) """ from collections import defaultdict lookup = build_uuid_lookup_from_raw(raw_data_root, annotations) by_len_sets: defaultdict[int, set[str]] = defaultdict(set) uuid_to_langtext: Dict[str, str] = {} for meta_path in raw_data_root.glob("**/metadata_*.json"): with meta_path.open() as f: m = json.load(f) uuid = m.get("uuid") if not uuid: continue L = int(m.get("trajectory_length", -1)) if L < 0: continue by_len_sets[L].add(uuid) if annotations is not None and uuid in annotations: uuid_to_langtext[uuid] = str(annotations[uuid].get("language_instruction1", "")) else: uuid_to_langtext[uuid] = str(m.get("current_task", "")).split("\n")[0] uuids_by_length: Dict[int, List[str]] = {L: list(s) for L, s in by_len_sets.items()} unique_by_length = {length: us[0] for length, us in uuids_by_length.items() if len(us) == 1} traj_paths = list(raw_data_root.glob("**/trajectory.h5")) if episode_order_sorted: traj_paths = sorted(traj_paths) episode_order: List[Tuple[str, int]] = [] if traj_paths: for tp in traj_paths: parent = tp.parent metas = list(parent.glob("metadata_*.json")) if not metas: continue meta_path = min(metas, key=lambda p: p.name) with meta_path.open() as f: m = json.load(f) uuid = m.get("uuid") if not uuid: continue episode_order.append((uuid, int(m.get("trajectory_length", -1)))) else: meta_paths = sorted(raw_data_root.glob("**/metadata_*.json")) if episode_order_sorted else list( raw_data_root.glob("**/metadata_*.json") ) for meta_path in meta_paths: with meta_path.open() as f: m = json.load(f) uuid = m.get("uuid") if not uuid: continue episode_order.append((uuid, int(m.get("trajectory_length", -1)))) return lookup, unique_by_length, episode_order, uuid_to_langtext, uuids_by_length def lerobot_episode_bounds(ds: Any, ep_idx: int) -> Tuple[int, int, str]: ep_from = int(ds.episode_data_index["from"][ep_idx]) ep_to = int(ds.episode_data_index["to"][ep_idx]) task = ds.meta.episodes[ep_idx]["tasks"][0] return ep_from, ep_to, task def _resolve_default_cotracker_checkpoint() -> Optional[str]: candidates = [ os.environ.get("COTRACKER_CHECKPOINT", "").strip(), "/scratch1/home/zhicao/openpi/co-tracker/checkpoints/scaled_offline.pth", "/scratch1/home/zhicao/co-tracker/checkpoints/scaled_offline.pth", "/scratch1/home/zhicao/cotracker/checkpoints/scaled_offline.pth", ] for p in candidates: if p and Path(p).is_file(): return p return None def _se3_vector_to_matrix(xyz_euler6: np.ndarray) -> np.ndarray: """ Build 4x4 world->camera transform from [tx,ty,tz,rx,ry,rz] where r is XYZ Euler. """ x = np.asarray(xyz_euler6, dtype=np.float64).reshape(-1) if x.size < 6: raise ValueError(f"Extrinsics vector must have >=6 values, got shape={x.shape}") t_world = x[:3] euler = x[3:6] R_wc = R.from_euler("xyz", euler).as_matrix() R_cw = R_wc.T t_c = -R_cw @ t_world T = np.eye(4, dtype=np.float64) T[:3, :3] = R_cw T[:3, 3] = t_c return T def _run_cotracker( cotracker: Any, *, frames_rgb: np.ndarray, query_points_xy: np.ndarray, device: torch.device, ) -> tuple[np.ndarray, np.ndarray]: """ Run CoTracker on one video. Args: frames_rgb: [T, H, W, 3] uint8 query_points_xy: [N, 2] pixel coordinates on frame 0 Returns: tracks: [T, N, 2] in pixel coords vis: [T, N] bool-like (float32 0/1) """ if frames_rgb.ndim != 4 or frames_rgb.shape[-1] != 3: raise ValueError(f"frames_rgb must be [T,H,W,3], got {frames_rgb.shape}") video = torch.from_numpy(frames_rgb).float().permute(0, 3, 1, 2) / 255.0 # [T,3,H,W] video = video.unsqueeze(0).to(device) # [1,T,3,H,W] queries = np.zeros((query_points_xy.shape[0], 3), dtype=np.float32) queries[:, 0] = 0.0 queries[:, 1:] = query_points_xy.astype(np.float32) queries_t = torch.from_numpy(queries).unsqueeze(0).to(device) with torch.no_grad(): tracks, vis = cotracker(video, queries=queries_t, backward_tracking=False) return tracks[0].detach().cpu().numpy(), vis[0].detach().cpu().numpy() class DROIDTrackPreprocessor: """Preprocess DROID episodes to generate 32-point tracks.""" def __init__( self, *, lerobot_root: Optional[str], raw_data_root: Optional[str], annotations_path: Optional[str], calib_path: str, output_path: str, min_len: int = 16, max_len: int = 70, max_episodes: int = 20000, use_cartesian: bool = True, require_refined: bool = True, img_size: int = 448, intrinsic_ref_hw: Tuple[int, int] = (360, 640), cotracker_checkpoint: Optional[str] = None, cotracker_device: str = "cuda:0", episode_order_sorted: bool = False, ): self.source = "lerobot" self.output_path = Path(output_path) self.min_len = min_len self.max_len = max_len self.max_episodes = max_episodes self.use_cartesian = use_cartesian self.require_refined = require_refined self.img_size = int(img_size) self.intrinsic_ref_hw = intrinsic_ref_hw self.episode_order_sorted = episode_order_sorted self.output_path.mkdir(parents=True, exist_ok=True) self.projector = FrankaMeshProjector(use_gui=False) # cotracker model self.cotracker_device = torch.device( cotracker_device if cotracker_device.startswith("cuda") and torch.cuda.is_available() else "cpu" ) ckpt = cotracker_checkpoint or _resolve_default_cotracker_checkpoint() if not ckpt or not Path(ckpt).is_file(): raise FileNotFoundError( "CoTracker checkpoint not found. Pass --cotracker-checkpoint or set COTRACKER_CHECKPOINT." ) print(f"Loading CoTracker from: {ckpt}") self.cotracker = CoTrackerPredictor(checkpoint=ckpt).to(self.cotracker_device) self.cotracker.eval() # lerobot dataset self.lerobot_ds = None if not lerobot_root: raise ValueError("lerobot_root is required.") if not raw_data_root: raise ValueError("raw_data_root is required.") root = Path(lerobot_root) self.raw_data_root = Path(raw_data_root) print(f"Loading LeRobot dataset from {root}...") self.lerobot_ds = LeRobotDataset(str(root)) # language annotations self.annotations: Optional[Dict[str, Any]] = None ann_path = Path(annotations_path) if annotations_path else Path(raw_data_root) / "aggregated-annotations-030724.json" if ann_path.is_file(): with ann_path.open() as f: self.annotations = json.load(f) print(f"Loaded language annotations: {ann_path}") else: print(f"No annotations file at {ann_path}; using current_task from metadata only.") # uuid lookup self.uuid_lookup: Dict[Tuple[int, str], str] = {} self.uuid_unique_by_length: Dict[int, str] = {} self.uuid_episode_order: List[Tuple[str, int]] = [] self.uuid_to_langtext: Dict[str, str] = {} self.uuids_by_length: Dict[int, List[str]] = {} ( self.uuid_lookup, self.uuid_unique_by_length, self.uuid_episode_order, self.uuid_to_langtext, self.uuids_by_length, ) = build_uuid_resolution_tables( Path(raw_data_root), self.annotations, episode_order_sorted=self.episode_order_sorted, ) print(f"Built uuid lookup with {len(self.uuid_lookup)} (length, task) keys under {raw_data_root}") print(f" Unique-by-length uuid slots: {len(self.uuid_unique_by_length)}") print(f" Episode-order pairs (trajectory.h5 or metadata glob): {len(self.uuid_episode_order)}") self.uuid_to_metadata_path = self._build_uuid_to_metadata_path(self.raw_data_root) print(f"Built uuid->metadata index with {len(self.uuid_to_metadata_path)} entries") def _scaled_dual_params(self, dual_params: Dict[str, Any]) -> Dict[str, Any]: """Apply intrinsics scaling to match resized square images.""" h_new = w_new = self.img_size href, wref = self.intrinsic_ref_hw out = {} for name, (K, E) in dual_params.items(): Ks = _scale_intrinsics(np.asarray(K), (href, wref), (h_new, w_new)) out[name] = (Ks, np.asarray(E)) return out def _default_intrinsics(self) -> np.ndarray: href, wref = self.intrinsic_ref_hw cx = (wref - 1.0) / 2.0 cy = (href - 1.0) / 2.0 # Conservative pinhole prior when metadata has no intrinsics fields. fx = 0.9 * float(wref) fy = 0.9 * float(href) return np.array([[fx, 0.0, cx], [0.0, fy, cy], [0.0, 0.0, 1.0]], dtype=np.float64) @staticmethod def _build_uuid_to_metadata_path(raw_data_root: Path) -> Dict[str, Path]: out: Dict[str, Path] = {} for meta_path in raw_data_root.glob("**/metadata_*.json"): try: with meta_path.open() as f: m = json.load(f) except Exception: continue uuid = str(m.get("uuid", "")).strip() if uuid and uuid not in out: out[uuid] = meta_path return out def _dual_params_from_raw_metadata(self, uuid: str) -> Optional[Dict[str, Tuple[np.ndarray, np.ndarray]]]: meta_path = self.uuid_to_metadata_path.get(uuid) if meta_path is None: return None with meta_path.open() as f: m = json.load(f) ext1_raw = m.get("ext1_cam_extrinsics") wrist_raw = m.get("wrist_cam_extrinsics") if ext1_raw is None or wrist_raw is None: return None E_ext = _se3_vector_to_matrix(np.asarray(ext1_raw, dtype=np.float64).reshape(-1)) E_wrist = _se3_vector_to_matrix(np.asarray(wrist_raw, dtype=np.float64).reshape(-1)) # Most raw metadata files do not include intrinsics; fallback to a stable prior. K_default = self._default_intrinsics() K_ext = np.asarray(m.get("ext1_cam_intrinsics", K_default), dtype=np.float64).reshape(3, 3) K_wrist = np.asarray(m.get("wrist_cam_intrinsics", K_default), dtype=np.float64).reshape(3, 3) return {"exterior_1": (K_ext, E_ext), "wrist": (K_wrist, E_wrist)} def _resolve_lerobot_uuid(self, episode_idx: int, num_steps: int, task: str) -> tuple[Optional[str], str]: """ Match LeRobot episode to raw calibration uuid. Order: exact (len+norm task) -> unique trajectory_length in metadata -> token similarity among episodes sharing that length -> episode index order (same glob rule as convert_droid_data_to_lerobot) with length check. """ key = (num_steps, _normalize_task(task)) u = self.uuid_lookup.get(key) if u: return u, "exact" u = self.uuid_unique_by_length.get(num_steps) if u: return u, "unique_len" cands = self.uuids_by_length.get(num_steps, []) if len(cands) > 1: best_u: Optional[str] = None best_s = 0.0 for cu in cands: s = _task_token_similarity(task, self.uuid_to_langtext.get(cu, "")) if s > best_s: best_s, best_u = s, cu if best_u is not None and best_s >= 0.2: return best_u, "similarity" if self.uuid_episode_order and episode_idx < len(self.uuid_episode_order): u2, meta_len = self.uuid_episode_order[episode_idx] if meta_len == num_steps or abs(meta_len - num_steps) <= 2: return u2, "episode_order" return None, "" def process_lerobot_episode(self, episode_idx: int) -> bool: ds = self.lerobot_ds ep_from, ep_to, task = lerobot_episode_bounds(ds, episode_idx) num_steps = ep_to - ep_from if num_steps < self.min_len or num_steps > self.max_len: return False uuid, how = self._resolve_lerobot_uuid(episode_idx, num_steps, task) if uuid is None: print(f"Warning: no uuid for ep {episode_idx} len={num_steps} task={task!r}") return False if how != "exact": print(f" ep {episode_idx}: uuid via {how} -> {uuid} (len={num_steps})") try: dual_params = self._dual_params_from_raw_metadata(uuid) if dual_params is None: print(f"Warning: no usable camera params in raw metadata for {uuid}") return False except Exception as e: print(f"Warning: failed reading raw metadata camera params for {uuid}: {e}") return False dual_params = self._scaled_dual_params(dual_params) steps_range = range(ep_from, ep_to) return self._process_steps( num_steps=num_steps, episode_idx=episode_idx, uuid=uuid, dual_params=dual_params, language=task, joint_iter=self._iter_lerobot_frames(ds, steps_range), image_from_bgr=False, ) def _iter_lerobot_frames(self, ds: Any, steps_range: range): for i in steps_range: row = ds[i] jp = np.asarray(row["joint_position"], dtype=np.float32).reshape(-1) img_ext = _image_to_uint8_hwc(row["exterior_image_1_left"], expect_rgb=True) img_wrist = _image_to_uint8_hwc(row["wrist_image_left"], expect_rgb=True) yield jp, img_ext, img_wrist def _process_steps( self, *, num_steps: int, episode_idx: int, uuid: str, dual_params: Dict[str, Any], language: str, joint_iter, image_from_bgr: bool, ) -> bool: images_exterior: List[np.ndarray] = [] images_wrist: List[np.ndarray] = [] state0: Optional[np.ndarray] = None K_ext, E_ext = dual_params["exterior_1"] K_wrist, E_wrist = dual_params["wrist"] h = w = self.img_size for state, img_ext, img_wrist in joint_iter: if self.use_cartesian and state.shape[0] < 6: return False proj_state = np.asarray(state, dtype=np.float32) if state0 is None: state0 = proj_state if img_ext is None: img_rgb = np.zeros((h, w, 3), dtype=np.uint8) else: img_rgb = cv2.cvtColor(img_ext, cv2.COLOR_BGR2RGB) if image_from_bgr else np.asarray(img_ext) img_rgb = cv2.resize(img_rgb, (w, h)) if img_wrist is None: img_wrist_rgb = np.zeros((h, w, 3), dtype=np.uint8) else: img_wrist_rgb = ( cv2.cvtColor(img_wrist, cv2.COLOR_BGR2RGB) if image_from_bgr else np.asarray(img_wrist) ) img_wrist_rgb = cv2.resize(img_wrist_rgb, (w, h)) images_exterior.append(img_rgb) images_wrist.append(img_wrist_rgb) if not images_exterior or not images_wrist or state0 is None: return False # Keep existing 32-point convention by using frame-0 projector points as CoTracker queries. if self.use_cartesian: proj_fn_e = self.projector.project_32_points_cartesian proj_fn_w = self.projector.project_32_points_cartesian else: proj_fn_e = self.projector.project_32_points proj_fn_w = self.projector.project_32_points query_ext, _ = proj_fn_e(state0, K_ext, E_ext, img_h=h, img_w=w) query_wrist, _ = proj_fn_w(state0, K_wrist, E_wrist, img_h=h, img_w=w) images_exterior_arr = np.array(images_exterior, dtype=np.uint8) images_wrist_arr = np.array(images_wrist, dtype=np.uint8) tracks_exterior_arr, vis_exterior_arr = _run_cotracker( self.cotracker, frames_rgb=images_exterior_arr, query_points_xy=np.asarray(query_ext, dtype=np.float32), device=self.cotracker_device, ) tracks_wrist_arr, vis_wrist_arr = _run_cotracker( self.cotracker, frames_rgb=images_wrist_arr, query_points_xy=np.asarray(query_wrist, dtype=np.float32), device=self.cotracker_device, ) output_file = self.output_path / f"episode_{episode_idx:06d}.npz" np.savez_compressed( output_file, tracks_exterior=tracks_exterior_arr, tracks_wrist=tracks_wrist_arr, vis_exterior=vis_exterior_arr, vis_wrist=vis_wrist_arr, images_exterior=images_exterior_arr, images_wrist=images_wrist_arr, language=language, uuid=uuid, num_steps=num_steps, ) return True def run(self): print("Starting preprocessing:") print(f" Source: {self.source}") print(f" Output: {self.output_path}") print(f" Episode length: [{self.min_len}, {self.max_len}]") print(f" Max episodes: {self.max_episodes}") print(f" Image size: {self.img_size}x{self.img_size} (intrinsics scaled from {self.intrinsic_ref_hw})") print(f" Mesh projection: {'cartesian_position' if self.use_cartesian else 'joint_position (FK)'}") print(f" Require refined extrinsics: {self.require_refined}") print(f" CoTracker device: {self.cotracker_device}") print() processed = 0 skipped = 0 pbar = tqdm(total=self.max_episodes, desc="Processing episodes") n_eps = len(self.lerobot_ds.meta.episodes) for idx in range(n_eps): if processed >= self.max_episodes: break try: if self.process_lerobot_episode(idx): processed += 1 pbar.update(1) else: skipped += 1 except Exception as e: print(f"\nError processing LeRobot episode {idx}: {e}") skipped += 1 pbar.close() metadata = { "num_processed": processed, "num_skipped": skipped, "source": self.source, "min_len": self.min_len, "max_len": self.max_len, "img_size": self.img_size, "intrinsic_ref_hw": list(self.intrinsic_ref_hw), "num_points": 32, "grid_points": 25, "mesh_points": 7, } metadata_file = self.output_path / "metadata.json" with metadata_file.open("w") as f: json.dump(metadata, f, indent=2) print(f"\nPreprocessing complete:") print(f" Processed: {processed} episodes") print(f" Skipped: {skipped} episodes") print(f" Output: {self.output_path}") print(f" Metadata: {metadata_file}") def main(): parser = argparse.ArgumentParser(description="Preprocess DROID tracks for ControlNet training") parser.add_argument( "--lerobot-root", type=str, default="/scratch1/home/zhicao/openpi_org/lerobot_cache/droid_small", help="Root directory of the LeRobot dataset.", ) parser.add_argument( "--raw-data-root", type=str, default="/scratch1/home/zhicao/openpi/data", help="Root of raw DROID data (metadata_*.json per episode) for uuid alignment.", ) parser.add_argument( "--annotations-json", type=str, default="/scratch1/home/zhicao/openpi/data/aggregated-annotations-030724.json", help="Optional aggregated-annotations JSON. If empty, use raw_data_root/aggregated-annotations-030724.json when present.", ) parser.add_argument( "--calib-dir", type=str, default="/scratch1/home/zhicao/openpi/data/cameras", help="Deprecated (kept for backward compatibility; script reads camera params from raw metadata now).", ) parser.add_argument( "--output", type=str, default="/scratch1/home/zhicao/openpi/data_track", help="Output directory for .npz files and metadata.json.", ) parser.add_argument( "--uuid-episode-order-sorted", action="store_true", help="If set, use sorted(glob) for episode order; default False matches convert script list(glob).", ) parser.add_argument("--min-len", type=int, default=16, help="Minimum episode length") parser.add_argument("--max-len", type=int, default=800, help="Maximum episode length (raise for long demos)") parser.add_argument("--max-episodes", type=int, default=20000, help="Max successfully written episodes") parser.add_argument("--img-size", type=int, default=448, help="Square resize (pixels) for images + projection") parser.add_argument( "--intrinsic-ref-h", type=int, default=360, help="Reference intrinsics height (DROID measured K is often for 360p)", ) parser.add_argument( "--intrinsic-ref-w", type=int, default=640, help="Reference intrinsics width", ) parser.add_argument( "--allow-measured-fallback", action="store_true", help=( "If set, allow measured extrinsics fallback when refined_extrinsics is missing. " "Default is strict mode (require refined_extrinsics)." ), ) parser.add_argument( "--cotracker-checkpoint", type=str, default="/scratch1/home/zhicao/openpi/co-tracker/checkpoints/scaled_offline.pth", help="Path to CoTracker checkpoint (.pth). If empty, auto-discover from known paths/env.", ) parser.add_argument( "--cotracker-device", type=str, default="cuda:0", help="CoTracker torch device (e.g. cuda:0 or cpu).", ) args = parser.parse_args() ann_path = str(args.annotations_json).strip() or None preprocessor = DROIDTrackPreprocessor( lerobot_root=str(args.lerobot_root).strip(), raw_data_root=str(args.raw_data_root).strip(), annotations_path=ann_path, calib_path=str(args.calib_dir).strip(), output_path=str(args.output).strip(), min_len=args.min_len, max_len=args.max_len, max_episodes=args.max_episodes, use_cartesian=False, require_refined=not args.allow_measured_fallback, img_size=args.img_size, intrinsic_ref_hw=(args.intrinsic_ref_h, args.intrinsic_ref_w), cotracker_checkpoint=args.cotracker_checkpoint.strip() or None, cotracker_device=args.cotracker_device, episode_order_sorted=bool(args.uuid_episode_order_sorted), ) preprocessor.run() if __name__ == "__main__": main()