| """ |
| 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 |
|
|
| 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() |
|
|
