""" Verify the camera-pose convention + adapter schema for preprocessed ARKitScenes. ARKitScenes is the single most important convention to get right here, because ARKit raw poses are OpenGL-ish (x right, y up, z BACK) and CUT3R's preprocess_arkitscenes.py applies a non-trivial `pose_cam_to_world @ rotated_to_cam` (an in-plane sky-direction rotation), so we must NOT assume the result is OpenCV — we test it on real geometry. The Cut3rAdapter feeds view["camera_pose"] downstream AS c2w OpenCV (x right, y down, z forward). This script answers: is that actually true? Three tests, in increasing rigor: (1) Camera-Y world-axis. ARKitScenes' world frame is Z-up (preprocess uses up_world = [0,0,1]). For an upright handheld camera looking roughly horizontally, the OpenCV camera +Y axis (down) should point toward world -Z. If c2w[:3,1] is dominantly +Z, the pose is OpenGL (Y up). (2) Multi-view point-cloud consistency (the definitive test). Backproject two time-separated frames' depth into the world under two hypotheses: - OpenCV : use c2w as-is, OpenCV pinhole unprojection. - OpenGL : use c2w @ diag(1,-1,-1,1), same unprojection. Whichever hypothesis makes the two frames' surfaces OVERLAP (small median nearest-neighbor distance) is the true convention. Mismatched conventions send the two clouds to different/ mirrored places -> large NN distance. (3) ctxt->trgt pose drift over many samples, to validate max_interval against SPOC's bounds (mean translation < 1 m, mean rotation ~45 deg). Run: cd PYTHONPATH=$PWD:$PWD/splat_belief \ .../envs/3d-belief-release/bin/python \ scripts/data_prep/verify_arkitscenes_pose_convention.py \ --root /home/ubuntu/tianmin-neurips/zwen19/data/ARKitScenes/processed_arkitscenes \ --scene 40958756 """ from __future__ import annotations import argparse import os import sys from pathlib import Path import numpy as np # Make `import data_io...` work whether or not PYTHONPATH was set. _REPO = Path(__file__).resolve().parents[2] for p in (str(_REPO), str(_REPO / "splat_belief")): if p not in sys.path: sys.path.insert(0, p) from data_io.cut3r_adapter import build_cut3r_dataset, Cut3rAdapter # noqa: E402 OPENGL_FLIP = np.diag([1.0, -1.0, -1.0, 1.0]).astype(np.float64) def unproject_opencv(depth_m, K): """Backproject valid depth pixels with the OpenCV pinhole model -> (N,3) cam.""" H, W = depth_m.shape us, vs = np.meshgrid(np.arange(W), np.arange(H)) valid = depth_m > 0 u = us[valid].astype(np.float64) v = vs[valid].astype(np.float64) d = depth_m[valid].astype(np.float64) fx, fy, cx, cy = K[0, 0], K[1, 1], K[0, 2], K[1, 2] x = (u - cx) * d / fx y = (v - cy) * d / fy return np.stack([x, y, d], axis=-1) def cam_to_world(pts_cam, c2w): ones = np.ones((pts_cam.shape[0], 1)) return (c2w @ np.concatenate([pts_cam, ones], axis=-1).T).T[:, :3] def median_nn(a, b, max_pts=4000, seed=0): """Median nearest-neighbor distance from a -> b (subsampled).""" from scipy.spatial import cKDTree rng = np.random.default_rng(seed) if a.shape[0] > max_pts: a = a[rng.choice(a.shape[0], max_pts, replace=False)] if b.shape[0] > max_pts: b = b[rng.choice(b.shape[0], max_pts, replace=False)] d, _ = cKDTree(b).query(a, k=1) return float(np.median(d)) def rot_angle_deg(Ra, Rb): R = Ra.T @ Rb c = (np.trace(R) - 1.0) / 2.0 return float(np.degrees(np.arccos(np.clip(c, -1.0, 1.0)))) def find_scene_idx(cut3r, scene): """Return a dataset index whose sampled sequence is from `scene`.""" for i in range(min(len(cut3r), 50)): v = cut3r[i] if v[0]["label"].split("_")[0] == scene: return i return 0 def main(): ap = argparse.ArgumentParser() ap.add_argument("--root", required=True) ap.add_argument("--scene", default="40958756") ap.add_argument("--num_views", type=int, default=5) # 1 ctxt + 1 trgt + 3 intm ap.add_argument("--image_size", type=int, default=128) ap.add_argument("--drift_samples", type=int, default=40) args = ap.parse_args() res = (args.image_size, args.image_size) # seed -> deterministic sampling (mirrors overfit's cut3r_seed=42) cut3r = build_cut3r_dataset("arkitscenes", root=args.root, split="train", num_views=args.num_views, resolution=res, seed=42) print(f"[verify] dataset len (groups) = {len(cut3r)}; scenes = " f"{list(getattr(cut3r, 'scenes', []))}") idx = find_scene_idx(cut3r, args.scene) views = cut3r[idx] print(f"[verify] using idx={idx}, scene={views[0]['label'].split('_')[0]}, " f"{len(views)} views; labels={[v['label'] for v in views]}") # ---- intrinsics report (fills the yaml fx/fy fallback) ---- K = views[0]["camera_intrinsics"].astype(np.float64) th, tw = views[0]["true_shape"] print(f"\n[verify] first-view K (pixel, true_shape={int(th)}x{int(tw)}):\n{np.round(K,2)}") print(f" normalized: fx/W={K[0,0]/tw:.3f} fy/H={K[1,1]/th:.3f} " f"cx/W={K[0,2]/tw:.3f} cy/H={K[1,2]/th:.3f}") # ---- (1) camera-Y world axis (Z-up world) ---- print("\n[verify] TEST 1 — camera +Y world axis (Z-up world):") for i, v in enumerate(views): c2w = v["camera_pose"].astype(np.float64) y = c2w[:3, 1]; z = c2w[:3, 2] print(f" view{i}: cam+Y_world=({y[0]:+.2f},{y[1]:+.2f},{y[2]:+.2f}) " f"cam+Z_world(fwd)=({z[0]:+.2f},{z[1]:+.2f},{z[2]:+.2f})") meanY = np.mean([v["camera_pose"][:3, 1] for v in views], axis=0) print(f" mean cam+Y world = ({meanY[0]:+.2f},{meanY[1]:+.2f},{meanY[2]:+.2f}) " f"-> dominant {'−Z (OpenCV, Y-down)' if meanY[2] < 0 else '+Z (OpenGL, Y-up)'}") # ---- (2) multi-view point-cloud consistency ---- # Use ADJACENT views (high overlap) — comparing ctxt vs trgt (far apart) # gives an unreliable verdict because they barely overlap. With adjacent # frames the correct convention is cm-scale; the wrong one degrades clearly # (and degrades MORE as inter-frame rotation grows). print("\n[verify] TEST 2 — multi-view consistency, ADJACENT views (OpenCV vs OpenGL flip):") va, vb = views[0], views[1] Ka, Kb = va["camera_intrinsics"].astype(np.float64), vb["camera_intrinsics"].astype(np.float64) da, db = va["depthmap"].astype(np.float64), vb["depthmap"].astype(np.float64) pa, pb = unproject_opencv(da, Ka), unproject_opencv(db, Kb) for tag, M in (("OpenCV (as-is)", np.eye(4)), ("OpenGL (@diag(1,-1,-1,1))", OPENGL_FLIP)): wa = cam_to_world(pa, va["camera_pose"].astype(np.float64) @ M) wb = cam_to_world(pb, vb["camera_pose"].astype(np.float64) @ M) nn = median_nn(wa, wb) print(f" {tag:32s}: median cross-frame NN dist = {nn:.3f} m") # ---- (3) ctxt->trgt drift ---- print("\n[verify] TEST 3 — ctxt->trgt pose drift " f"({args.drift_samples} samples, max_interval={cut3r.max_interval}):") trans, rots = [], [] for i in range(args.drift_samples): v = cut3r[i % len(cut3r)] c0 = v[0]["camera_pose"].astype(np.float64) c1 = v[-1]["camera_pose"].astype(np.float64) trans.append(np.linalg.norm(c1[:3, 3] - c0[:3, 3])) rots.append(rot_angle_deg(c0[:3, :3], c1[:3, :3])) trans, rots = np.array(trans), np.array(rots) print(f" translation: mean={trans.mean():.2f} m median={np.median(trans):.2f} max={trans.max():.2f}") print(f" rotation : mean={rots.mean():.1f}° median={np.median(rots):.1f} max={rots.max():.1f}") print(f" SPOC bounds: adjacent_distance=1.0 m, adjacent_angle=45° " f"-> {'OK' if trans.mean()<1.0 and rots.mean()<60 else 'TOO WIDE: lower max_interval'}") # ---- adapter schema check ---- print("\n[verify] adapter schema (language_encoder=None -> lang is None):") ad = Cut3rAdapter(cut3r_dataset=cut3r, num_context=1, num_target=1, image_size=args.image_size, language_encoder=None, use_depth_supervision=True, intermediate=True, num_intermediate=3, z_near=0.1, z_far=10.0, overfit_to_index=idx) d, trgt = ad[0] for k in ("ctxt_rgb", "trgt_rgb", "intm_rgb", "ctxt_c2w", "trgt_c2w", "intm_c2w", "ctxt_abs_camera_poses", "intrinsics", "ctxt_depth", "ctxt_depth_mask", "near", "far", "image_shape"): if k in d: val = d[k] shp = tuple(val.shape) if hasattr(val, "shape") else val print(f" {k:24s}: {shp}") else: print(f" {k:24s}: MISSING") rgb = d["ctxt_rgb"] print(f" ctxt_rgb range = [{rgb.min():.2f}, {rgb.max():.2f}] (expect ~[-1,1])") import torch assert torch.allclose(d["ctxt_c2w"][0], torch.eye(4), atol=1e-4), "ctxt_c2w[0] != identity!" print(" ctxt_c2w[0] == identity ✓") cm = d["ctxt_depth_mask"] print(f" ctxt_depth valid fraction = {cm.float().mean().item():.1%}") print("\n[verify] DONE.") if __name__ == "__main__": main()