| |
| """Overlay wrist gripper projections (compare inv / direct extrinsic, K sources). |
| |
| Usage: |
| cd openpi/droid |
| ../.venv/bin/python scripts/debug_wrist_projection.py \\ |
| --h5 /z/home/zhicao/droid_raw/.../trajectory.h5 \\ |
| --out /tmp/wrist_proj_debug.jpg |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import json |
| import sys |
| from pathlib import Path |
|
|
| import cv2 |
| import h5py |
| import numpy as np |
|
|
| _DROID = Path(__file__).resolve().parents[1] |
| for p in (_DROID.parent / "third_party", _DROID.parent / "third_party" / "libero", _DROID): |
| ps = str(p) |
| if p.exists() and ps not in sys.path: |
| sys.path.insert(0, ps) |
| if str(_DROID) not in sys.path: |
| sys.path.insert(0, str(_DROID)) |
|
|
| from utils.camera_geometry import ( |
| DROID_NATIVE_HW, |
| GRIPPER_OFFSETS, |
| pose6_to_matrix, |
| project_gripper_mesh, |
| project_gripper_mesh_wrist, |
| scale_pixels_between_hw, |
| ) |
| from utils.karlp_calib import KarlpCalibStore, episode_id_from_metadata |
| from utils.raw_episode_loader import _load_episode |
| from utils.zed_intrinsics import default_K_native, default_dist_native, zed_model_for_camera_type |
|
|
|
|
| def _project_manual( |
| cart6: np.ndarray, |
| ext6: np.ndarray, |
| K: np.ndarray, |
| *, |
| use_inv: bool, |
| ) -> np.ndarray: |
| from scipy.spatial.transform import Rotation |
|
|
| c = np.asarray(cart6, dtype=np.float64).reshape(-1) |
| R_wg = Rotation.from_euler("xyz", c[3:6]).as_matrix() |
| world = (R_wg @ GRIPPER_OFFSETS.T).T + c[:3] |
| T = pose6_to_matrix(ext6) |
| w2c = np.linalg.inv(T) if use_inv else T |
| pix = [] |
| for p in world: |
| pc = (w2c @ np.concatenate([p, [1.0]]))[:3] |
| u = K @ pc |
| pix.append(u[:2] / u[2]) |
| return np.asarray(pix, dtype=np.float64) |
|
|
|
|
| def main() -> None: |
| p = argparse.ArgumentParser() |
| p.add_argument("--h5", type=str, required=True) |
| p.add_argument("--t", type=int, default=0) |
| p.add_argument("--size", type=int, default=448) |
| p.add_argument("--karlp-calib-dir", type=str, default="") |
| p.add_argument("--out", type=str, default="wrist_proj_debug.jpg") |
| args = p.parse_args() |
|
|
| h5_path = Path(args.h5).expanduser().resolve() |
| meta_paths = sorted(h5_path.parent.glob("metadata_*.json")) |
| if not meta_paths: |
| raise SystemExit(f"No metadata_*.json next to {h5_path}") |
| meta = json.loads(meta_paths[0].read_text(encoding="utf-8")) |
| episode_id = episode_id_from_metadata(meta_paths[0], meta) |
|
|
| karlp = None |
| kdir = args.karlp_calib_dir.strip() |
| if not kdir: |
| default = _DROID / "calibration" / "karlp" |
| if (default / "cam2base_extrinsics.json").is_file(): |
| kdir = str(default) |
| if kdir: |
| karlp = KarlpCalibStore(kdir) |
|
|
| ep = _load_episode(h5_path, 0, karlp=karlp, preset_episode_id=episode_id) |
| if ep is None: |
| raise SystemExit("Failed to load episode (KarlP filter or missing MP4)") |
|
|
| t = int(np.clip(args.t, 0, len(ep.cartesian) - 1)) |
| s = int(args.size) |
| out_hw = (s, s) |
| frame = cv2.resize(ep.wrist_images[t], (s, s)) |
| vis = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR) |
|
|
| model = zed_model_for_camera_type(ep.wrist_camera_type) |
| K_zed = default_K_native(model) |
| dist_zed = default_dist_native(model) |
| K_karlp, dist_karlp = K_zed, dist_zed |
| if karlp is not None: |
| parsed = karlp.intrinsics_for_serial(ep.episode_id, ep.wrist_serial) |
| if parsed is not None: |
| K_karlp, dist_karlp = parsed |
|
|
| cart = ep.cartesian[t] |
| ext = ep.wrist_extrinsics[t] |
| go = ep.wrist_gripper_offset[t] |
|
|
| with h5py.File(h5_path, "r") as f: |
| has_action = "action/robot_state/cartesian_position" in f |
| cart_action = ( |
| np.asarray(f["action/robot_state/cartesian_position"], dtype=np.float64)[t] |
| if has_action |
| else None |
| ) |
|
|
| layers: list[tuple[str, tuple[int, int, int], np.ndarray]] = [] |
|
|
| pix_wrist, _ = project_gripper_mesh_wrist(cart, ext, go, K=K_karlp, dist=dist_karlp) |
| layers.append( |
| ( |
| "wrist mesh (fixed)", |
| (0, 255, 0), |
| scale_pixels_between_hw(pix_wrist, DROID_NATIVE_HW, out_hw), |
| ) |
| ) |
|
|
| for label, K, dist, use_inv in [ |
| ("inv_no_offset", K_karlp, dist_karlp, True), |
| ("direct_no_offset", K_karlp, dist_karlp, False), |
| ]: |
| pix, _ = project_gripper_mesh(cart, ext, K=K, dist=dist) |
| pix_s = scale_pixels_between_hw(pix, DROID_NATIVE_HW, out_hw) |
| layers.append((label, (0, 0, 255), pix_s)) |
| manual = _project_manual(cart, ext, K, use_inv=use_inv) |
| manual_s = scale_pixels_between_hw(manual, DROID_NATIVE_HW, out_hw) |
| layers.append((f"{label}_manual", (255, 0, 0), manual_s)) |
|
|
| if cart_action is not None: |
| pix_a, _ = project_gripper_mesh(cart_action, ext, K=K_karlp, dist=dist_karlp) |
| layers.append( |
| ("action_cart", (0, 255, 0), scale_pixels_between_hw(pix_a, DROID_NATIVE_HW, out_hw)) |
| ) |
|
|
| y0 = 20 |
| for label, color, pts in layers: |
| cv2.putText(vis, label, (8, y0), cv2.FONT_HERSHEY_SIMPLEX, 0.45, color, 1, cv2.LINE_AA) |
| y0 += 16 |
| for i, (x, y) in enumerate(pts): |
| if 0 <= x < s and 0 <= y < s: |
| cv2.circle(vis, (int(round(x)), int(round(y))), 4, color, -1) |
| if label.startswith("wrist+offset"): |
| cv2.putText( |
| vis, |
| str(i), |
| (int(round(x)) + 3, int(round(y)) - 3), |
| cv2.FONT_HERSHEY_SIMPLEX, |
| 0.35, |
| (255, 255, 255), |
| 1, |
| cv2.LINE_AA, |
| ) |
|
|
| out_path = Path(args.out).expanduser().resolve() |
| out_path.parent.mkdir(parents=True, exist_ok=True) |
| cv2.imwrite(str(out_path), vis) |
| print(f"Wrote {out_path}") |
| print(f" episode_id={ep.episode_id} wrist_serial={ep.wrist_serial} t={t}") |
| print(f" extrinsic_source={ep.extrinsic_source.get('wrist')}") |
| print(" Green=wrist mesh (inv(c2w)@T_eef@mesh, same as exterior; preprocess uses this).") |
| print(" Red/blue=legacy debug paths (inv vs direct extrinsic, no mesh).") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
