Add files using upload-large-folder tool

3d-belief/ARKITSCENES.md

@@ -0,0 +1,263 @@
+# ARKitScenes → 3D-Belief finetuning
+
+End-to-end procedure for wiring **ARKitScenes** (Apple iPad LiDAR room captures)
+into 3D-Belief training via the CUT3R adapter, plus the single-scene overfit used
+to validate the dataloader before multi-scene training.
+
+This mirrors the WildRGBD / ScanNet++ ports — see [`WILDRGBD.md`](WILDRGBD.md) and
+the `3d-belief-dataloader` skill for the shared invariants. Only the
+ARKitScenes-specific decisions are spelled out here.
+
+TL;DR of what was added:
+
+| file | change |
+|---|---|
+| `splat_belief/data_io/cut3r_adapter.py` | `_make_arkitscenes_short()` helper + `arkitscenes` branch now uses it |
+| `splat_belief/data_io/__init__.py` | registered `arkitscenes_cut3r` in `get_path` + the adapter tuple |
+| `splat_belief/config/dataset/arkitscenes_cut3r.yaml` | new Hydra dataset config (room-scale near/far, metric depth) |
+| `scripts/data_prep/verify_arkitscenes_pose_convention.py` | convention + schema + drift verifier |
+| `scripts/training/finetune_arkitscenes_overfit.sh` | single-scene overfit launcher (DFoT init, depth mask on) |
+
+---
+
+## 1. Preprocessing (CUT3R)
+
+ARKitScenes uses the **two-step** CUT3R pipeline (`docs/preprocess.md`), identical
+in shape to ScanNet: `preprocess_*` writes per-frame RGB/depth + `scene_metadata.npz`
+(with DUSt3R `pairs`); `generate_set_*` then writes `new_scene_metadata.npz` (with
+the `image_collection` / `video_collection` that the `ARKitScenes_Multi` loader
+actually reads at train time).
+
+### 1a. Inputs
+
+- **Raw data**: `data/ARKitScenes/raw/{Training,Validation}/<scene>/` with
+  `vga_wide/` (RGB), `lowres_depth/` (uint16 mm LiDAR depth), `vga_wide_intrinsics/`
+  (`*.pincam`), and `lowres_wide.traj` (per-frame device pose, angle-axis + t).
+- **Precomputed pairs** (required by `preprocess_arkitscenes.py`): DUSt3R's
+  [`arkitscenes_pairs.zip`](https://download.europe.naverlabs.com/ComputerVision/DUSt3R/arkitscenes_pairs.zip),
+  unzipped to `data/ARKitScenes/arkitscenes_pairs/{Training,Test}/`. The script
+  reads `scene_list.json` + per-scene `selected_pairs.npz`; **without it the
+  preprocessor cannot run** (it drives which frames are selected/exported).
+
+### 1b. Commands (run from `third_party/CUT3R/datasets_preprocess`)
+
+Use the `3d-belief-release` conda env's python for preprocessing — it has
+`numpy<2` + `numpy-quaternion` (the `3d-belief` training env has numpy 2.x where
+`quaternion` is ABI-broken; that's fine because the **dataloader** path never
+imports quaternion). Use the **absolute** interpreter path; `conda run -n <env>`
+is broken on this host (it silently resolves to the colmap-cuda env's py3.14).
+
+```bash
+PY=/home/ubuntu/tianmin-neurips/miniconda3/envs/3d-belief-release/bin/python
+DATA=/home/ubuntu/tianmin-neurips/zwen19/data/ARKitScenes
+
+# Step 1 — convert RGB/depth + interpolate poses to selected timestamps.
+$PY preprocess_arkitscenes.py \
+    --arkitscenes_dir   "$DATA/raw" \
+    --precomputed_pairs "$DATA/arkitscenes_pairs" \
+    --output_dir        "$DATA/processed_arkitscenes"
+
+# Step 2 — build image_collection / video_collection metadata.
+$PY generate_set_arkitscenes.py \
+    --root "$DATA/processed_arkitscenes" \
+    --splits Training Test --max_interval 5.0 --num_workers 8
+```
+
+Output layout (per scene): `processed_arkitscenes/Training/<scene>/{vga_wide/*.jpg,
+lowres_depth/*.png, scene_metadata.npz, new_scene_metadata.npz}` plus a top-level
+`all_metadata.npz` + `scene_list.json` per split.
+
+### 1c. Subset preprocessing (this run)
+
+The full ARKitScenes is still downloading, so only a **5-scene subset** was
+processed for the overfit smoke. The official `preprocess_arkitscenes.py`
+hardcodes `subdirs=["Test","Training"]` and crashes on an empty split
+(`np.concatenate([])`), and iterates the *entire* pairs `scene_list.json`. To
+process just a subset without touching the original script:
+
+1. Build `arkitscenes_pairs_subset/` with a filtered `Training/scene_list.json`
+   (chosen scenes), symlinked `Training/<scene>/selected_pairs.npz`, and an empty
+   `Test/scene_list.json` (`[]`).
+2. Run a `/tmp` copy of `preprocess_arkitscenes.py` patched to `subdirs=["Training"]`
+   (avoids the empty-Test crash; the original CUT3R script is left intact).
+3. Run `generate_set_arkitscenes.py --splits Training` on the output.
+
+Valid processed scenes: **`40958756`** (162 selected frames — overfit target),
+`41045408`, `41098145`. (Re-run on the full pairs `scene_list` once the download
+completes; no code changes needed.)
+
+---
+
+## 2. Dataloader wiring
+
+### 2a. `_make_arkitscenes_short()` — the ARKitScenes-specific subclass
+
+The raw CUT3R `ARKitScenes_Multi` is **not** directly usable for 3D-Belief; the
+helper returns a subclass fixing three things (full rationale in the docstring):
+
+1. **`<ROOT>_highres` crash.** `_load_data` does
+   `np.setdiff1d(scenes, os.listdir(ROOT + "_highres"/split))` to drop scenes that
+   also exist in the high-res variant. We only process the regular split, so the
+   subclass stubs empty `<ROOT>_highres/{Training,Validation}` dirs before
+   `_load_data` runs → the setdiff is a no-op.
+2. **50/50 shuffled sampling.** `_get_views` flips `rng.choice([True,False])`
+   between a temporal-video sequence and a *permuted* DUSt3R-pairs group. The pairs
+   branch is wide-baseline + non-temporal, which breaks the `[ctxt, intm…, trgt]`
+   time ordering 3D-Belief's intermediate loss requires. A tiny `_ForceVideoRng`
+   proxy makes the branch selector always return the video branch, forwarding every
+   other rng call unchanged.
+3. **Pose drift too wide.** Default `max_interval=8` + `video_prob=0.8` give
+   multi-frame gaps. The subclass forces `video_prob=1.0` (always time-ordered) and
+   tightens `max_interval=2`, matching `_make_scannet_short`.
+
+### 2b. Hydra config (`arkitscenes_cut3r.yaml`)
+
+Room-scale handheld capture, so it differs from object-centric WildRGBD:
+
+| key | value | why |
+|---|---|---|
+| `cut3r_dataset_class` | `arkitscenes` | routes to `_make_arkitscenes_short` |
+| `viz_type` | `interpolation` | ctxt/trgt are close after short-window sampling → linear interp stays in seen views (WildRGBD needed `spherical` because object-centric) |
+| `near` / `far` | **0.1 / 10.0** | room-scale indoor; covers full room while keeping splat precision tighter than the 20 m RE10K/ScanNet default |
+| `depth_loss_weight` | 1.0 | per-frame **metric** LiDAR depth on every pixel |
+| `depth_smooth_loss_weight` | 0.1 | canonical (regularizes predicted depth) |
+| `intermediate_weight` | 5.0 | canonical (train.sh / train_re10k.sh) |
+| `vggt_alignment_loss_weight` | 2.0 | canonical |
+| `camera.fx`/`fy` | 1.16 | **measured** fx_norm after the square center-crop (HFOV ≈ 47°); cx/cy ≈ 0.5 confirms centered crop. Nominal fallback only — per-sample K from the dataset dict takes precedence. |
+
+---
+
+## 3. Camera convention — VERIFIED OpenCV c2w (no flip)
+
+This was the make-or-break check. ARKit raw poses are OpenGL-ish, and CUT3R's
+preprocessor applies a non-trivial `pose_cam_to_world @ rotated_to_cam` (an
+in-plane sky-direction rotation), so the output convention was **not assumed** —
+it was tested on real geometry by
+`scripts/data_prep/verify_arkitscenes_pose_convention.py`.
+
+**Test 1 — camera +Y world axis (Z-up world).** Mean camera +Y → world
+`(-0.08, -0.12, -0.99)` = dominant **−Z** across all views ⇒ camera-Y points down
+⇒ OpenCV (y-down). (OpenGL y-up would give +Z.)
+
+**Test 2 — multi-view point-cloud consistency** (the definitive test). Backproject
+two **adjacent, high-overlap** frames into the world under OpenCV (c2w as-is) vs
+OpenGL (`c2w @ diag(1,-1,-1,1)`) and measure cross-frame overlap:
+
+| frame pair | OpenCV as-is | OpenGL flip |
+|---|---|---|
+| (0,1), baseline 2.9 cm | **median 0.011 m · 94% < 5 cm** | 0.016 m · 74% |
+| (0,2), baseline 6.3 cm | **0.016 m · 93%** | 0.026 m · 62% |
+| (10,11), rotated | **0.008 m · 94%** | 0.047 m · 53% |
+
+OpenCV wins every pair, and the margin **grows with inter-frame rotation** (the
+(10,11) pair: 94% vs 53%) — conclusive. (Comparing ctxt vs trgt directly is
+unreliable: they barely overlap, which made an earlier 128-res ctxt/trgt test
+ambiguous. Always use adjacent frames for this check.)
+
+**Conclusion: CUT3R-preprocessed ARKitScenes `camera_pose` is c2w OpenCV.** The
+`Cut3rAdapter` consumes it unchanged — **no `diag(1,-1,-1,1)` flip** (unlike SPOC's
+Habitat poses). Adapter schema checks also pass: `ctxt_c2w[0]==identity`, RGB in
+`[-1,1]`, depth 100% valid, normalized `cx≈cy≈0.5`.
+
+**Pose drift** (40 samples, `max_interval=2`): mean translation **0.14 m**, mean
+rotation **23°** — comfortably inside SPOC's bounds (1.0 m / 45°). `max_interval=2`
+is a good default; raise it only if the full dataset's selected frames turn out to
+be more densely spaced in time.
+
+---
+
+## 4. Finetuning / overfit
+
+**Init: DFoT weights**, exactly as train.sh / train_re10k.sh / the WildRGBD
+overfit — `checkpoint_path=checkpoints/DFoT_RE10K.ckpt` (diffusion init, full model)
++ `model.encoder.encoder_ckpt=checkpoints/re10k.ckpt` (pixelsplat encoder).
+`load_enc=true`, `load_optimizer=false`. The ~514 missing / 84 unexpected keys on
+load are **expected** (DFoT init has a different head than the re10k encoder).
+
+**Env: use the `3d-belief` conda env (torch 2.11), NOT `3d-belief-release`** — the
+release env's `diff_gaussian_rasterization/_C.so` is stale (`undefined symbol
+…decref_pyobject`). The `3d-belief` env has a working rasterizer build.
+
+**Depth mask: ENABLED** (the SPOC-style setup the user asked for):
+`use_depth_supervision=true`, `model.encoder.use_depth_mask=true`. The adapter's
+`(d>0)&(d<far)` mask excludes invalid (0) LiDAR pixels.
+
+Launch the single-scene overfit (scene `40958756`, `overfit_to_index=0`):
+
+```bash
+cd /home/ubuntu/tianmin-neurips/zwen19/3d-belief
+TRAIN_NUM_STEPS=8000 SAMPLE_EVERY=2000 SAVE_EVERY=4000 \
+WARMUP_PERIOD=200 LR=2e-5 CUDA_VISIBLE_DEVICES=3 \
+RESULTS_FOLDER=outputs/training/arkitscenes_overfit_scene0 \
+  bash scripts/training/finetune_arkitscenes_overfit.sh
+```
+
+### Key hyperparameters (overfit smoke)
+
+| param | value | note |
+|---|---|---|
+| `image_size` | 128 | DFoT_RE10K / re10k.ckpt native res |
+| `overfit_to_index` | 0 | deterministic (factory sets `cut3r_seed=42`) → scene 40958756, group 0 |
+| `num_context` / `num_target` | 1 / 1 | forced by `setting_name=debug` regardless of CLI |
+| `num_intermediate` | 3 | `intermediate=true` |
+| `warmup_period` | **200** | base config default is **10000** — that keeps LR≈0 for a short overfit (lr 2e-5 ⇒ +2e-9/step). Multi-scene training keeps 10000. |
+| `lr` | 2e-5 | canonical |
+| depth | `use_depth_supervision=true`, `use_depth_mask=true` | |
+| losses | rgb 1.0, depth 1.0, depth_smooth 0.1, intermediate 5.0, vggt_alignment 2.0, repa 5.0, lpips 1.0 | from `arkitscenes_cut3r.yaml` |
+
+### Smoke result (120-step, default warmup)
+
+Pipeline runs end-to-end from DFoT with no errors; per-component losses all
+present (`rgb_loss`, `depth_loss`≈1.8, `alignment_loss`≈4.96, no NaNs), depth
+supervision active, `rgb_loss_ctxt` already trending down (0.74 → 0.37). 120 steps
+under the 10000-step warmup is not a convergence test — see the 8000-step run
+(`outputs/training/arkitscenes_overfit_scene0/logs.json.txt`) with `warmup_period=200`
+for the actual overfit curve.
+
+### Overfit result (8000-step, `warmup_period=200`, scene 40958756, GPU 3)
+
+Single-scene overfit **converges cleanly and monotonically** (100-step means):
+
+| step | total loss | rgb_loss | rgb_loss_ctxt | depth_loss | alignment_loss |
+|---|---|---|---|---|---|
+| 0–100 | 39.9 | 0.461 | 0.445 | 1.760 | 4.953 |
+| 200–300 | 17.4 | 0.069 | 0.050 | 0.277 | 4.608 |
+| 500–600 | 11.5 | 0.036 | 0.041 | 0.079 | 3.718 |
+| 1000–1100 | 8.4 | 0.019 | 0.035 | 0.056 | 3.095 |
+| 1500–1600 | 7.1 | 0.014 | 0.031 | 0.050 | 2.782 |
+| 2000–2100 | **6.3** | **0.011** | **0.028** | **0.049** | 2.543 |
+
+`rgb_loss` drops below the skill's **0.05 overfit threshold by ~step 250** and reaches
+**0.011 by step 2000**; `depth_loss` 1.8 → 0.049 (depth-mask supervision is fitting the
+LiDAR depth); VGGT `alignment_loss` 5.0 → 2.5. **Milestone renders are healthy** — the
+`milestone_1_rendered_frames/rendered_{0..19}.png` camera sweep has **0.0–0.2% black
+pixels** across all frames (skill threshold: ≤1% healthy, >5% = collapsed gaussians), and
+`rendered_10.png` (middle of the sweep) shows a coherent room (window+blinds, furniture),
+not black. This is the definitive confirmation the dataloader + OpenCV convention are
+correct — a wrong pose convention or pose-drift bug would empty the middle frames and
+stall `rgb_loss` above 0.05.
+
+Verdict: **a single ARKitScenes scene overfits**, so 3D-Belief can be trained on it. Scale
+to multi-scene once the full dataset finishes downloading (re-run §1 preprocessing on the
+full pairs `scene_list`, drop `overfit_to_index`, restore `warmup_period=10000`).
+
+---
+
+## 5. Gotchas (this host / dataset)
+
+- **`conda run -n <env>` is broken here** — silently resolves to the colmap-cuda
+  env (py3.14). Always use absolute interpreter paths
+  (`.../envs/<env>/bin/python`).
+- **Two different envs**: preprocessing → `3d-belief-release` (numpy<2 +
+  quaternion); training → `3d-belief` (torch 2.11, working rasterizer).
+- **Precomputed pairs are mandatory** for `preprocess_arkitscenes.py`; it won't run
+  without DUSt3R's `arkitscenes_pairs`.
+- **`generate_set` is not optional** — the loader reads `new_scene_metadata.npz`
+  (image_collection), which only step 2 writes. Step 1 alone → loader finds no
+  groups.
+- Don't lower `video_prob` back below 1.0 or widen `max_interval` past ~2 for
+  handheld capture — both reintroduce the wide-baseline / non-temporal sampling
+  that empties the gaussian middles.
+- See [`scripts/data_prep/verify_arkitscenes_pose_convention.py`] — re-run the
+  convention check before any new ARKitScenes training; trusting the upstream c2w
+  without verification is the #1 way to get silent garbage.

3d-belief/outputs/training/arkitscenes_overfit_scene0/milestone_1_rendered_depth.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f2efd6713c261547bad614429b1c2794f147d795f04f12cabb5a8a40d07dbb7f
+size 169927

3d-belief/outputs/training/arkitscenes_overfit_scene0/milestone_1_rendered_rgb.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60d87dd9a22c008872878b326b20607ebd3e943ac9371828d316a85c26160abf
+size 121427

3d-belief/outputs/training/arkitscenes_overfit_scene0/milestone_2_rendered_depth.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c762d4dae90a9c4ee65c91416a98b7897cd780909df8b4fd96106bd0bf2792d5
+size 158013

3d-belief/outputs/training/arkitscenes_overfit_scene0/milestone_2_rendered_rgb.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:93bfe1713dd980aa89e725e9f9ff34b3e1c3a2d1bce5739d939b1319071883c3
+size 137684

3d-belief/outputs/training/arkitscenes_overfit_scene0/milestone_3_rendered_depth.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:668a6490be18df83852664c7127581d0a03cf211a16ab946cf9e853fc91d760a
+size 152946

3d-belief/outputs/training/arkitscenes_overfit_scene0/milestone_3_rendered_rgb.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2cbd8ecd2c1fc25983249dbe831dcdc6a6742bede59446228caafe8ed05dc625
+size 149260

3d-belief/scripts/data_prep/verify_arkitscenes_pose_convention.py

@@ -0,0 +1,205 @@
+"""
+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 <repo_root>
+  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()

3d-belief/scripts/training/finetune_arkitscenes_overfit.sh

@@ -0,0 +1,136 @@
+#!/usr/bin/env bash
+#
+# Single-scene overfit smoke test on ARKitScenes (scene 40958756, idx 0).
+#
+# ARKitScenes analog of finetune_wildrgbd_overfit.sh. Loads DFoT_RE10K.ckpt +
+# re10k.ckpt as initialization (same as train.sh / train_re10k.sh / the WildRGBD
+# overfit) then finetunes the encoder on a single ARKitScenes (ctxt, trgt, intm)
+# sample with overfit_to_index=0 so we can verify the loss actually drops.
+#
+# Camera convention: verify_arkitscenes_pose_convention.py confirms CUT3R's
+# preprocessed ARKitScenes camera_pose is c2w OpenCV (x right, y down, z fwd) —
+# the convention the Cut3rAdapter assumes. Multi-view consistency at 94% <5cm
+# for the OpenCV hypothesis vs 53% for the OpenGL flip. NO pose flip needed.
+#
+# Depth: ARKitScenes ships per-frame metric iPad-LiDAR depth (lowres_depth, mm,
+# 0=invalid). Depth supervision + the depth mask are ENABLED (use_depth_supervision
+# + model.encoder.use_depth_mask=true), per the SPOC-style setup.
+#
+# Required env vars (with sensible defaults):
+#   DATASET_ROOT  - path to processed_arkitscenes/  (the dir with Training/)
+#   CKPT_DIR      - directory with DFoT_RE10K.ckpt + re10k.ckpt
+#   CUDA_VISIBLE_DEVICES - which GPU (default: 3)
+
+set -e
+
+# ---- environment ----
+# NOTE: use the `3d-belief` env (torch 2.11), NOT `3d-belief-release`. The
+# release env's diff_gaussian_rasterization _C.so is stale (built against an
+# older libtorch) and fails with `undefined symbol ...decref_pyobject`. The
+# `3d-belief` env has a working rasterizer build. (quaternion is broken there
+# under numpy 2.x but is only needed by the CUT3R *preprocessing* scripts, not
+# the dataloader/training path.)
+eval "$(conda shell.bash hook)"
+conda activate 3d-belief
+
+nvidia-smi
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "$REPO_ROOT"
+# Avoid PYTHONPATH shadowing by an older splat_belief copy
+# (see memory: 3d-belief-training-script-gotchas).
+export PYTHONPATH="${REPO_ROOT}:${PYTHONPATH}"
+
+DATASET_ROOT="${DATASET_ROOT:-/home/ubuntu/tianmin-neurips/zwen19/data/ARKitScenes/processed_arkitscenes}"
+CKPT_DIR="${CKPT_DIR:-${REPO_ROOT}/checkpoints}"
+STAGE="${STAGE:-train}"
+
+export MASTER_PORT=$((12000 + RANDOM % 1000))
+export PATH=$CONDA_PREFIX/bin:$PATH
+export CUDA_HOME=$CONDA_PREFIX
+export LD_LIBRARY_PATH=$CONDA_PREFIX/lib:$LD_LIBRARY_PATH
+export CUDA_VISIBLE_DEVICES="${CUDA_VISIBLE_DEVICES:-3}"
+export TORCH_CUDA_ARCH_LIST="8.6;9.0"
+
+# Tunables for the smoke test — override in the env to scale up.
+RESULTS_FOLDER="${RESULTS_FOLDER:-outputs/training/arkitscenes_overfit_scene0}"
+TRAIN_NUM_STEPS="${TRAIN_NUM_STEPS:-500}"
+SAMPLE_EVERY="${SAMPLE_EVERY:-100}"
+SAVE_EVERY="${SAVE_EVERY:-500}"
+# wandb_every must divide sample_every (assert in diffusion.py:1514).
+WANDB_EVERY="${WANDB_EVERY:-${SAMPLE_EVERY}}"
+NUM_INTERMEDIATE="${NUM_INTERMEDIATE:-3}"
+OVERFIT_TO_INDEX="${OVERFIT_TO_INDEX:-0}"   # idx 0 -> scene 40958756, group 0
+# The base config warmup_period=10000 (with lr=2e-5 => +2e-9/step). That keeps
+# the LR near-zero for a short overfit, so the loss can't move. Use a short
+# warmup for the overfit smoke (the multi-scene training script keeps the
+# canonical 10000).
+WARMUP_PERIOD="${WARMUP_PERIOD:-200}"
+LR="${LR:-2e-5}"
+
+mkdir -p "${RESULTS_FOLDER}"
+
+# DFoT init (same as train.sh / train_re10k.sh / WildRGBD overfit).
+CKPT_PATH="${CKPT_PATH:-${CKPT_DIR}/DFoT_RE10K.ckpt}"
+LOAD_ENC="${LOAD_ENC:-true}"
+ENCODER_CKPT="${ENCODER_CKPT:-${CKPT_DIR}/re10k.ckpt}"
+DATASET_VIZ_TYPE="${DATASET_VIZ_TYPE:-}"  # leave empty to keep YAML default (interpolation)
+
+CUDA_LAUNCH_BLOCKING=1 torchrun --nnodes 1 --nproc_per_node 1 --master_port $MASTER_PORT \
+    splat_belief/experiment/train.py \
+    dataset=arkitscenes_cut3r \
+    dataset.root_dir="${DATASET_ROOT}" \
+    dataset.vggt_alignment_loss_weight=2.0 \
+    dataset.intermediate_weight=5.0 \
+    dataset.depth_smooth_loss_weight=0.1 \
+    setting_name=debug \
+    stage="${STAGE}" \
+    use_depth_supervision=true \
+    results_folder="${RESULTS_FOLDER}" \
+    semantic_config=splat_belief/config/semantic/onehot.yaml \
+    checkpoint_path="${CKPT_PATH}" \
+    $( [ -n "${DATASET_VIZ_TYPE}" ] && echo "dataset.viz_type=${DATASET_VIZ_TYPE}" ) \
+    ngpus=1 \
+    image_size=128 \
+    train_num_steps=${TRAIN_NUM_STEPS} \
+    warmup_period=${WARMUP_PERIOD} \
+    lr=${LR} \
+    sample_every=${SAMPLE_EVERY} \
+    save_every=${SAVE_EVERY} \
+    wandb_every=${WANDB_EVERY} \
+    overfit_to_index=${OVERFIT_TO_INDEX} \
+    ctxt_min=5 \
+    ctxt_max=15 \
+    model/encoder=uvitmvsplat \
+    model.encoder.use_image_condition=true \
+    model.encoder.depth_predictor_time_embed=true \
+    model.encoder.use_camera_pose=true \
+    model.encoder.use_semantic=false \
+    model.encoder.use_reg_model=false \
+    model.encoder.d_semantic=512 \
+    model.encoder.d_semantic_reg=384 \
+    model.encoder.gaussians_per_pixel=1 \
+    model.encoder.evolve_ctxt=false \
+    model.encoder.use_depth_mask=true \
+    model.encoder.encoder_ckpt="${ENCODER_CKPT}" \
+    model.encoder.freeze_depth_predictor=false \
+    model/encoder/backbone=u_vit3d_pose \
+    model.encoder.backbone.use_vggt_alignment=true \
+    model.encoder.backbone.use_repa=true \
+    model.encoder.backbone.input_size='[128, 128]' \
+    alignment.latents_info=-1 \
+    ctxt_losses_factor=0.9 \
+    repa_encoder_resolution=512 \
+    model_type=uvit_pose \
+    name=arkitscenes_overfit \
+    wandb=local \
+    clean_target=false \
+    use_identity=true \
+    intermediate=true \
+    num_intermediate=${NUM_INTERMEDIATE} \
+    load_optimizer=false \
+    load_enc=${LOAD_ENC} \
+    finetune_component=encoder \
+    finetune_steps=5 \
+    use_depth_smoothness=true \
+    adjacent_angle=0.785 \
+    adjacent_distance=1.0

3d-belief/splat_belief/config/dataset/arkitscenes_cut3r.yaml

@@ -0,0 +1,57 @@
+name: "arkitscenes_cut3r"
+# Which CUT3R BaseMultiViewDataset class to wrap. "arkitscenes" routes to an
+# ARKitScenes_Multi subclass (cut3r_adapter._make_arkitscenes_short) that forces
+# the temporal-video branch + video_prob=1.0 + a tighter max_interval, and stubs
+# the <ROOT>_highres dir the raw loader requires. The forced temporal ordering is
+# what makes the [ctxt, intm..., trgt] split in Cut3rAdapter.__getitem__
+# correspond to ascending time (required by the intermediate-frame loss).
+cut3r_dataset_class: "arkitscenes"
+overfit_to_index: null
+lindisp: false
+# Room-scale handheld capture: ctxt/trgt are close in pose (after the short-window
+# sampler), so the linear interpolation trajectory between them stays inside seen
+# views -> "interpolation" viz is legible (unlike the object-centric WildRGBD case
+# that needed "spherical").
+viz_type: "interpolation"
+dist_loss_weight: 0.005
+# ARKitScenes ships per-frame metric depth from the iPad LiDAR (lowres_depth, mm,
+# 0 = invalid). The (d > 0) & (d < far) mask in cut3r_adapter.stack_depth excludes
+# invalid pixels, so full-strength depth supervision is appropriate.
+depth_loss_weight: 1.0
+depth_mask_loss_weight: 0.0
+# Smoothness regularizes the encoder's PREDICTED depth (not GT) -> keep at the
+# canonical 0.1 (matches train.sh / train_re10k.sh CLI overrides).
+depth_smooth_loss_weight: 0.1
+# No semantic labels used for ARKitScenes finetuning.
+semantic_loss_weight: 0.0
+semantic_reg_loss_weight: 0.0
+lpips_loss_weight: 1.0
+repa_loss_weight: 5.0
+rgb_loss_weight: 1.0
+# Canonical intermediate_weight per train.sh / train_re10k.sh CLI overrides.
+intermediate_weight: 5.0
+# VGGT alignment submodule auto-loads facebook/VGGT-1B from HF Hub at construction
+# (splat/alignment/vggt_alignment_loss.py); canonical weight = 2.0.
+vggt_alignment_loss_weight: 2.0
+root_dir: ""
+camera:
+  # CUT3R's _crop_resize_if_necessary center-crops every frame so the principal
+  # point is centered: cx_norm = cy_norm = 0.5 by construction. fx/fy here are
+  # nominal fallbacks (model.camera = ${dataset.camera}); the per-sample
+  # intrinsics from the dataset dict take precedence in the encoder forward.
+  # ARKitScenes vga_wide ~ iPad rear camera. Measured fx_norm = fy_norm ≈ 1.16
+  # after the square center-crop (HFOV ≈ 47°); cx_norm=0.496, cy_norm=0.501
+  # (centered) — see verify_arkitscenes_pose_convention.py output for scene
+  # 40958756. These are nominal fallbacks; per-sample K from the dataset dict
+  # takes precedence in the encoder forward.
+  fx: 1.16
+  fy: 1.16
+  cx: 0.5
+  cy: 0.5
+  # Room-scale indoor (handheld iPad): depth typically ~0.2–6 m, occasionally to
+  # ~10 m. near=0.1 / far=10.0 covers the room while keeping splat depth
+  # precision tighter than the 20 m RealEstate/ScanNet default.
+  near: 0.1
+  far: 10.0
+  h: 128
+  w: 128

3d-belief/third_party/CUT3R/datasets_preprocess/generate_set_arkitscenes.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""
+Preprocess scenes by sorting images and generating image/video collections.
+
+This script processes scenes in parallel using a thread pool, updating metadata
+with sorted images, trajectories, intrinsics, and generating pair, image collection,
+and video collection data. The processed metadata is saved to a new file in each scene directory.
+
+Usage:
+    python generate_set_arkitscenes.py --root /path/to/data --splits Training Test --max_interval 5.0 --num_workers 8
+"""
+
+import os
+import os.path as osp
+import argparse
+import numpy as np
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from tqdm import tqdm
+
+
+def get_timestamp(img_name):
+    """
+    Extract the timestamp from an image filename.
+    Assumes the timestamp is the last underscore-separated token in the name (before the file extension).
+
+    Args:
+        img_name (str): The image filename.
+
+    Returns:
+        float: The extracted timestamp.
+    """
+    return float(img_name[:-4].split("_")[-1])
+
+
+def process_scene(root, split, scene, max_interval):
+    """
+    Process a single scene by sorting its images by timestamp, updating trajectories,
+    intrinsics, and pairings, and generating image/video collections.
+
+    Args:
+        root (str): Root directory of the dataset.
+        split (str): The dataset split (e.g., 'Training', 'Test').
+        scene (str): The scene identifier.
+        max_interval (float): Maximum allowed time interval (in seconds) between images to consider them in the same video collection.
+    """
+    scene_dir = osp.join(root, split, scene)
+    metadata_path = osp.join(scene_dir, "scene_metadata.npz")
+
+    # Load the scene metadata
+    with np.load(metadata_path) as data:
+        images = data["images"]
+        trajectories = data["trajectories"]
+        intrinsics = data["intrinsics"]
+        pairs = data["pairs"]
+
+    # Sort images by timestep
+    imgs_with_indices = sorted(enumerate(images), key=lambda x: x[1])
+    indices, images = zip(*imgs_with_indices)
+    indices = np.array(indices)
+    index2sorted = {index: i for i, index in enumerate(indices)}
+
+    # Reorder trajectories and intrinsics based on the new image order
+    trajectories = trajectories[indices]
+    intrinsics = intrinsics[indices]
+
+    # Update pair indices (each pair is (id1, id2, score))
+    pairs = [(index2sorted[id1], index2sorted[id2], score) for id1, id2, score in pairs]
+
+    # Form image_collection: mapping from an image id to a list of (other image id, score)
+    image_collection = {}
+    for id1, id2, score in pairs:
+        image_collection.setdefault(id1, []).append((id2, score))
+
+    # Form video_collection: for each image, collect subsequent images within the max_interval time window
+    video_collection = {}
+    for i, image in enumerate(images):
+        j = i + 1
+        for j in range(i + 1, len(images)):
+            if get_timestamp(images[j]) - get_timestamp(image) > max_interval:
+                break
+        video_collection[i] = list(range(i + 1, j))
+
+    # Save the new metadata
+    output_path = osp.join(scene_dir, "new_scene_metadata.npz")
+    np.savez(
+        output_path,
+        images=images,
+        trajectories=trajectories,
+        intrinsics=intrinsics,
+        pairs=pairs,
+        image_collection=image_collection,
+        video_collection=video_collection,
+    )
+    print(f"Processed scene: {scene}")
+
+
+def main(args):
+    """
+    Main function to process scenes across specified dataset splits in parallel.
+    """
+    root = args.root
+    splits = args.splits
+    max_interval = args.max_interval
+    num_workers = args.num_workers
+
+    futures = []
+
+    # Create a ThreadPoolExecutor for parallel processing
+    with ThreadPoolExecutor(max_workers=num_workers) as executor:
+        for split in splits:
+            all_meta_path = osp.join(root, split, "all_metadata.npz")
+            with np.load(all_meta_path) as data:
+                scenes = data["scenes"]
+
+            # Submit processing tasks for each scene in the current split
+            for scene in scenes:
+                futures.append(
+                    executor.submit(process_scene, root, split, scene, max_interval)
+                )
+
+        # Use tqdm to display a progress bar as futures complete
+        for future in tqdm(
+            as_completed(futures), total=len(futures), desc="Processing scenes"
+        ):
+            # This will raise any exceptions caught during scene processing.
+            future.result()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Preprocess scene data to update metadata with sorted images and collections."
+    )
+    parser.add_argument(
+        "--root",
+        type=str,
+        default="",
+        help="Root directory containing the dataset splits.",
+    )
+    parser.add_argument(
+        "--splits",
+        type=str,
+        nargs="+",
+        default=["Training", "Test"],
+        help="List of dataset splits to process (e.g., Training Test).",
+    )
+    parser.add_argument(
+        "--max_interval",
+        type=float,
+        default=5.0,
+        help="Maximum time interval (in seconds) between images to consider them in the same video sequence.",
+    )
+    parser.add_argument(
+        "--num_workers",
+        type=int,
+        default=8,
+        help="Number of worker threads for parallel processing.",
+    )
+    args = parser.parse_args()
+    main(args)

3d-belief/third_party/CUT3R/datasets_preprocess/preprocess_arkitscenes.py

@@ -0,0 +1,445 @@
+import os
+import json
+import os.path as osp
+import decimal
+import argparse
+import math
+from bisect import bisect_left
+from PIL import Image
+import numpy as np
+import quaternion
+from scipy import interpolate
+import cv2
+from tqdm import tqdm
+
+
+def get_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--arkitscenes_dir",
+        default="data/dust3r_data/data_arkitscenes/raw",
+    )
+    parser.add_argument(
+        "--precomputed_pairs",
+        default="data/dust3r_data/data_arkitscenes/arkitscenes_pairs",
+    )
+    parser.add_argument(
+        "--output_dir",
+        default="data/dust3r_data/processed_arkitscenes",
+    )
+    return parser
+
+
+def value_to_decimal(value, decimal_places):
+    decimal.getcontext().rounding = decimal.ROUND_HALF_UP  # define rounding method
+    return decimal.Decimal(str(float(value))).quantize(
+        decimal.Decimal("1e-{}".format(decimal_places))
+    )
+
+
+def closest(value, sorted_list):
+    index = bisect_left(sorted_list, value)
+    if index == 0:
+        return sorted_list[0]
+    elif index == len(sorted_list):
+        return sorted_list[-1]
+    else:
+        value_before = sorted_list[index - 1]
+        value_after = sorted_list[index]
+        if value_after - value < value - value_before:
+            return value_after
+        else:
+            return value_before
+
+
+def get_up_vectors(pose_device_to_world):
+    return np.matmul(pose_device_to_world, np.array([[0.0], [-1.0], [0.0], [0.0]]))
+
+
+def get_right_vectors(pose_device_to_world):
+    return np.matmul(pose_device_to_world, np.array([[1.0], [0.0], [0.0], [0.0]]))
+
+
+def read_traj(traj_path):
+    quaternions = []
+    poses = []
+    timestamps = []
+    poses_p_to_w = []
+    with open(traj_path) as f:
+        traj_lines = f.readlines()
+        for line in traj_lines:
+            tokens = line.split()
+            assert len(tokens) == 7
+            traj_timestamp = float(tokens[0])
+
+            timestamps_decimal_value = value_to_decimal(traj_timestamp, 3)
+            timestamps.append(
+                float(timestamps_decimal_value)
+            )  # for spline interpolation
+
+            angle_axis = [float(tokens[1]), float(tokens[2]), float(tokens[3])]
+            r_w_to_p, _ = cv2.Rodrigues(np.asarray(angle_axis))
+            t_w_to_p = np.asarray(
+                [float(tokens[4]), float(tokens[5]), float(tokens[6])]
+            )
+
+            pose_w_to_p = np.eye(4)
+            pose_w_to_p[:3, :3] = r_w_to_p
+            pose_w_to_p[:3, 3] = t_w_to_p
+
+            pose_p_to_w = np.linalg.inv(pose_w_to_p)
+
+            r_p_to_w_as_quat = quaternion.from_rotation_matrix(pose_p_to_w[:3, :3])
+            t_p_to_w = pose_p_to_w[:3, 3]
+            poses_p_to_w.append(pose_p_to_w)
+            poses.append(t_p_to_w)
+            quaternions.append(r_p_to_w_as_quat)
+    return timestamps, poses, quaternions, poses_p_to_w
+
+
+def main(rootdir, pairsdir, outdir):
+    os.makedirs(outdir, exist_ok=True)
+
+    subdirs = ["Test", "Training"]
+    for subdir in subdirs:
+        # STEP 1: list all scenes
+        outsubdir = osp.join(outdir, subdir)
+        os.makedirs(outsubdir, exist_ok=True)
+        listfile = osp.join(pairsdir, subdir, "scene_list.json")
+        with open(listfile, "r") as f:
+            scene_dirs = json.load(f)
+
+        valid_scenes = []
+        for scene_subdir in tqdm(scene_dirs):
+            if not os.path.isdir(osp.join(rootdir, "Test", scene_subdir)):
+                if not os.path.isdir(osp.join(rootdir, "Training", scene_subdir)):
+                    continue
+                else:
+                    root_subdir = "Training"
+            else:
+                root_subdir = "Test"
+            out_scene_subdir = osp.join(outsubdir, scene_subdir)
+            os.makedirs(out_scene_subdir, exist_ok=True)
+
+            scene_dir = osp.join(rootdir, root_subdir, scene_subdir)
+            depth_dir = osp.join(scene_dir, "lowres_depth")
+            rgb_dir = osp.join(scene_dir, "vga_wide")
+            intrinsics_dir = osp.join(scene_dir, "vga_wide_intrinsics")
+            traj_path = osp.join(scene_dir, "lowres_wide.traj")
+
+            # STEP 2: read selected_pairs.npz
+            selected_pairs_path = osp.join(
+                pairsdir, subdir, scene_subdir, "selected_pairs.npz"
+            )
+            selected_npz = np.load(selected_pairs_path)
+            selection, pairs = selected_npz["selection"], selected_npz["pairs"]
+            selected_sky_direction_scene = str(selected_npz["sky_direction_scene"][0])
+            if len(selection) == 0 or len(pairs) == 0:
+                # not a valid scene
+                continue
+            valid_scenes.append(scene_subdir)
+
+            # STEP 3: parse the scene and export the list of valid (K, pose, rgb, depth) and convert images
+            scene_metadata_path = osp.join(out_scene_subdir, "scene_metadata.npz")
+            if osp.isfile(scene_metadata_path):
+                continue
+            else:
+                print(f"parsing {scene_subdir}")
+                # loads traj
+                timestamps, poses, quaternions, poses_cam_to_world = read_traj(
+                    traj_path
+                )
+
+                poses = np.array(poses)
+                quaternions = np.array(quaternions, dtype=np.quaternion)
+                quaternions = quaternion.unflip_rotors(quaternions)
+                timestamps = np.array(timestamps)
+
+                selected_images = [
+                    (basename, basename.split(".png")[0].split("_")[1])
+                    for basename in selection
+                ]
+                timestamps_selected = [
+                    float(frame_id) for _, frame_id in selected_images
+                ]
+
+                sky_direction_scene, trajectories, intrinsics, images = (
+                    convert_scene_metadata(
+                        scene_subdir,
+                        intrinsics_dir,
+                        timestamps,
+                        quaternions,
+                        poses,
+                        poses_cam_to_world,
+                        selected_images,
+                        timestamps_selected,
+                    )
+                )
+                assert selected_sky_direction_scene == sky_direction_scene
+
+                os.makedirs(os.path.join(out_scene_subdir, "vga_wide"), exist_ok=True)
+                os.makedirs(
+                    os.path.join(out_scene_subdir, "lowres_depth"), exist_ok=True
+                )
+                assert isinstance(sky_direction_scene, str)
+                all_exist = True
+                for basename in images:
+                    vga_wide_path = osp.join(rgb_dir, basename)
+                    depth_path = osp.join(depth_dir, basename)
+                    if not osp.isfile(vga_wide_path) or not osp.isfile(depth_path):
+                        all_exist = False
+                        break
+                if not all_exist:
+                    continue
+
+                for basename in images:
+                    img_out = os.path.join(
+                        out_scene_subdir, "vga_wide", basename.replace(".png", ".jpg")
+                    )
+                    depth_out = os.path.join(out_scene_subdir, "lowres_depth", basename)
+                    if osp.isfile(img_out) and osp.isfile(depth_out):
+                        continue
+
+                    vga_wide_path = osp.join(rgb_dir, basename)
+                    depth_path = osp.join(depth_dir, basename)
+
+                    img = Image.open(vga_wide_path)
+                    depth = cv2.imread(depth_path, cv2.IMREAD_UNCHANGED)
+
+                    # rotate the image
+                    if sky_direction_scene == "RIGHT":
+                        try:
+                            img = img.transpose(Image.Transpose.ROTATE_90)
+                        except Exception:
+                            img = img.transpose(Image.ROTATE_90)
+                        depth = cv2.rotate(depth, cv2.ROTATE_90_COUNTERCLOCKWISE)
+                    elif sky_direction_scene == "LEFT":
+                        try:
+                            img = img.transpose(Image.Transpose.ROTATE_270)
+                        except Exception:
+                            img = img.transpose(Image.ROTATE_270)
+                        depth = cv2.rotate(depth, cv2.ROTATE_90_CLOCKWISE)
+                    elif sky_direction_scene == "DOWN":
+                        try:
+                            img = img.transpose(Image.Transpose.ROTATE_180)
+                        except Exception:
+                            img = img.transpose(Image.ROTATE_180)
+                        depth = cv2.rotate(depth, cv2.ROTATE_180)
+
+                    W, H = img.size
+                    if not osp.isfile(img_out):
+                        img.save(img_out)
+
+                    depth = cv2.resize(
+                        depth, (W, H), interpolation=cv2.INTER_NEAREST_EXACT
+                    )
+                    if not osp.isfile(
+                        depth_out
+                    ):  # avoid destroying the base dataset when you mess up the paths
+                        cv2.imwrite(depth_out, depth)
+
+                # save at the end
+                np.savez(
+                    scene_metadata_path,
+                    trajectories=trajectories,
+                    intrinsics=intrinsics,
+                    images=images,
+                    pairs=pairs,
+                )
+
+        outlistfile = osp.join(outsubdir, "scene_list.json")
+        for scene_subdir in valid_scenes:
+            scene_metadata_path = osp.join(
+                outsubdir, scene_subdir, "scene_metadata.npz"
+            )
+            if not osp.isfile(scene_metadata_path):
+                valid_scenes.remove(scene_subdir)
+        with open(outlistfile, "w") as f:
+            json.dump(valid_scenes, f)
+
+        # STEP 5: concat all scene_metadata.npz into a single file
+        scene_data = {}
+        for scene_subdir in valid_scenes:
+            scene_metadata_path = osp.join(
+                outsubdir, scene_subdir, "scene_metadata.npz"
+            )
+            with np.load(scene_metadata_path) as data:
+                trajectories = data["trajectories"]
+                intrinsics = data["intrinsics"]
+                images = data["images"]
+                pairs = data["pairs"]
+            scene_data[scene_subdir] = {
+                "trajectories": trajectories,
+                "intrinsics": intrinsics,
+                "images": images,
+                "pairs": pairs,
+            }
+        offset = 0
+        counts = []
+        scenes = []
+        sceneids = []
+        images = []
+        intrinsics = []
+        trajectories = []
+        pairs = []
+        for scene_idx, (scene_subdir, data) in enumerate(scene_data.items()):
+            num_imgs = data["images"].shape[0]
+            img_pairs = data["pairs"]
+
+            scenes.append(scene_subdir)
+            sceneids.extend([scene_idx] * num_imgs)
+
+            images.append(data["images"])
+
+            K = np.expand_dims(np.eye(3), 0).repeat(num_imgs, 0)
+            K[:, 0, 0] = [fx for _, _, fx, _, _, _ in data["intrinsics"]]
+            K[:, 1, 1] = [fy for _, _, _, fy, _, _ in data["intrinsics"]]
+            K[:, 0, 2] = [hw for _, _, _, _, hw, _ in data["intrinsics"]]
+            K[:, 1, 2] = [hh for _, _, _, _, _, hh in data["intrinsics"]]
+
+            intrinsics.append(K)
+            trajectories.append(data["trajectories"])
+
+            # offset pairs
+            img_pairs[:, 0:2] += offset
+            pairs.append(img_pairs)
+            counts.append(offset)
+
+            offset += num_imgs
+
+        images = np.concatenate(images, axis=0)
+        intrinsics = np.concatenate(intrinsics, axis=0)
+        trajectories = np.concatenate(trajectories, axis=0)
+        pairs = np.concatenate(pairs, axis=0)
+        np.savez(
+            osp.join(outsubdir, "all_metadata.npz"),
+            counts=counts,
+            scenes=scenes,
+            sceneids=sceneids,
+            images=images,
+            intrinsics=intrinsics,
+            trajectories=trajectories,
+            pairs=pairs,
+        )
+
+
+def convert_scene_metadata(
+    scene_subdir,
+    intrinsics_dir,
+    timestamps,
+    quaternions,
+    poses,
+    poses_cam_to_world,
+    selected_images,
+    timestamps_selected,
+):
+    # find scene orientation
+    sky_direction_scene, rotated_to_cam = find_scene_orientation(poses_cam_to_world)
+
+    # find/compute pose for selected timestamps
+    # most images have a valid timestamp / exact pose associated
+    timestamps_selected = np.array(timestamps_selected)
+    spline = interpolate.interp1d(timestamps, poses, kind="linear", axis=0)
+    interpolated_rotations = quaternion.squad(
+        quaternions, timestamps, timestamps_selected
+    )
+    interpolated_positions = spline(timestamps_selected)
+
+    trajectories = []
+    intrinsics = []
+    images = []
+    for i, (basename, frame_id) in enumerate(selected_images):
+        intrinsic_fn = osp.join(intrinsics_dir, f"{scene_subdir}_{frame_id}.pincam")
+        if not osp.exists(intrinsic_fn):
+            intrinsic_fn = osp.join(
+                intrinsics_dir, f"{scene_subdir}_{float(frame_id) - 0.001:.3f}.pincam"
+            )
+        if not osp.exists(intrinsic_fn):
+            intrinsic_fn = osp.join(
+                intrinsics_dir, f"{scene_subdir}_{float(frame_id) + 0.001:.3f}.pincam"
+            )
+        assert osp.exists(intrinsic_fn)
+        w, h, fx, fy, hw, hh = np.loadtxt(intrinsic_fn)  # PINHOLE
+
+        pose = np.eye(4)
+        pose[:3, :3] = quaternion.as_rotation_matrix(interpolated_rotations[i])
+        pose[:3, 3] = interpolated_positions[i]
+
+        images.append(basename)
+        if sky_direction_scene == "RIGHT" or sky_direction_scene == "LEFT":
+            intrinsics.append([h, w, fy, fx, hh, hw])  # swapped intrinsics
+        else:
+            intrinsics.append([w, h, fx, fy, hw, hh])
+        trajectories.append(
+            pose @ rotated_to_cam
+        )  # pose_cam_to_world @ rotated_to_cam = rotated(cam) to world
+
+    return sky_direction_scene, trajectories, intrinsics, images
+
+
+def find_scene_orientation(poses_cam_to_world):
+    if len(poses_cam_to_world) > 0:
+        up_vector = sum(get_up_vectors(p) for p in poses_cam_to_world) / len(
+            poses_cam_to_world
+        )
+        right_vector = sum(get_right_vectors(p) for p in poses_cam_to_world) / len(
+            poses_cam_to_world
+        )
+        up_world = np.array([[0.0], [0.0], [1.0], [0.0]])
+    else:
+        up_vector = np.array([[0.0], [-1.0], [0.0], [0.0]])
+        right_vector = np.array([[1.0], [0.0], [0.0], [0.0]])
+        up_world = np.array([[0.0], [0.0], [1.0], [0.0]])
+
+    # value between 0, 180
+    device_up_to_world_up_angle = (
+        np.arccos(np.clip(np.dot(np.transpose(up_world), up_vector), -1.0, 1.0)).item()
+        * 180.0
+        / np.pi
+    )
+    device_right_to_world_up_angle = (
+        np.arccos(
+            np.clip(np.dot(np.transpose(up_world), right_vector), -1.0, 1.0)
+        ).item()
+        * 180.0
+        / np.pi
+    )
+
+    up_closest_to_90 = abs(device_up_to_world_up_angle - 90.0) < abs(
+        device_right_to_world_up_angle - 90.0
+    )
+    if up_closest_to_90:
+        assert abs(device_up_to_world_up_angle - 90.0) < 45.0
+        # LEFT
+        if device_right_to_world_up_angle > 90.0:
+            sky_direction_scene = "LEFT"
+            cam_to_rotated_q = quaternion.from_rotation_vector(
+                [0.0, 0.0, math.pi / 2.0]
+            )
+        else:
+            # note that in metadata.csv RIGHT does not exist, but again it's not accurate...
+            # well, turns out there are scenes oriented like this
+            # for example Training/41124801
+            sky_direction_scene = "RIGHT"
+            cam_to_rotated_q = quaternion.from_rotation_vector(
+                [0.0, 0.0, -math.pi / 2.0]
+            )
+    else:
+        # right is close to 90
+        assert abs(device_right_to_world_up_angle - 90.0) < 45.0
+        if device_up_to_world_up_angle > 90.0:
+            sky_direction_scene = "DOWN"
+            cam_to_rotated_q = quaternion.from_rotation_vector([0.0, 0.0, math.pi])
+        else:
+            sky_direction_scene = "UP"
+            cam_to_rotated_q = quaternion.quaternion(1, 0, 0, 0)
+    cam_to_rotated = np.eye(4)
+    cam_to_rotated[:3, :3] = quaternion.as_rotation_matrix(cam_to_rotated_q)
+    rotated_to_cam = np.linalg.inv(cam_to_rotated)
+    return sky_direction_scene, rotated_to_cam
+
+
+if __name__ == "__main__":
+    parser = get_parser()
+    args = parser.parse_args()
+    main(args.arkitscenes_dir, args.precomputed_pairs, args.output_dir)

3d-belief/third_party/CUT3R/datasets_preprocess/preprocess_arkitscenes_highres.py

@@ -0,0 +1,409 @@
+import os
+import json
+import os.path as osp
+import decimal
+import argparse
+import math
+from bisect import bisect_left
+from PIL import Image
+import numpy as np
+import quaternion
+from scipy import interpolate
+import cv2
+from tqdm import tqdm
+from multiprocessing import Pool
+
+
+def get_parser():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--arkitscenes_dir",
+        default="",
+    )
+    parser.add_argument(
+        "--output_dir",
+        default="data/dust3r_data/processed_arkitscenes_highres",
+    )
+    return parser
+
+
+def value_to_decimal(value, decimal_places):
+    decimal.getcontext().rounding = decimal.ROUND_HALF_UP  # define rounding method
+    return decimal.Decimal(str(float(value))).quantize(
+        decimal.Decimal("1e-{}".format(decimal_places))
+    )
+
+
+def closest(value, sorted_list):
+    index = bisect_left(sorted_list, value)
+    if index == 0:
+        return sorted_list[0]
+    elif index == len(sorted_list):
+        return sorted_list[-1]
+    else:
+        value_before = sorted_list[index - 1]
+        value_after = sorted_list[index]
+        if value_after - value < value - value_before:
+            return value_after
+        else:
+            return value_before
+
+
+def get_up_vectors(pose_device_to_world):
+    return np.matmul(pose_device_to_world, np.array([[0.0], [-1.0], [0.0], [0.0]]))
+
+
+def get_right_vectors(pose_device_to_world):
+    return np.matmul(pose_device_to_world, np.array([[1.0], [0.0], [0.0], [0.0]]))
+
+
+def read_traj(traj_path):
+    quaternions = []
+    poses = []
+    timestamps = []
+    poses_p_to_w = []
+    with open(traj_path) as f:
+        traj_lines = f.readlines()
+        for line in traj_lines:
+            tokens = line.split()
+            assert len(tokens) == 7
+            traj_timestamp = float(tokens[0])
+
+            timestamps_decimal_value = value_to_decimal(traj_timestamp, 3)
+            timestamps.append(
+                float(timestamps_decimal_value)
+            )  # for spline interpolation
+
+            angle_axis = [float(tokens[1]), float(tokens[2]), float(tokens[3])]
+            r_w_to_p, _ = cv2.Rodrigues(np.asarray(angle_axis))
+            t_w_to_p = np.asarray(
+                [float(tokens[4]), float(tokens[5]), float(tokens[6])]
+            )
+
+            pose_w_to_p = np.eye(4)
+            pose_w_to_p[:3, :3] = r_w_to_p
+            pose_w_to_p[:3, 3] = t_w_to_p
+
+            pose_p_to_w = np.linalg.inv(pose_w_to_p)
+
+            r_p_to_w_as_quat = quaternion.from_rotation_matrix(pose_p_to_w[:3, :3])
+            t_p_to_w = pose_p_to_w[:3, 3]
+            poses_p_to_w.append(pose_p_to_w)
+            poses.append(t_p_to_w)
+            quaternions.append(r_p_to_w_as_quat)
+    return timestamps, poses, quaternions, poses_p_to_w
+
+
+def main(rootdir, outdir):
+    os.makedirs(outdir, exist_ok=True)
+    subdirs = ["Validation", "Training"]
+    for subdir in subdirs:
+        outsubdir = osp.join(outdir, subdir)
+        scene_dirs = sorted(
+            [
+                d
+                for d in os.listdir(osp.join(rootdir, subdir))
+                if osp.isdir(osp.join(rootdir, subdir, d))
+            ]
+        )
+
+        with Pool() as pool:
+            results = list(
+                tqdm(
+                    pool.imap(
+                        process_scene,
+                        [
+                            (rootdir, outdir, subdir, scene_subdir)
+                            for scene_subdir in scene_dirs
+                        ],
+                    ),
+                    total=len(scene_dirs),
+                )
+            )
+
+        # Filter None results and other post-processing
+        valid_scenes = [result for result in results if result is not None]
+        outlistfile = osp.join(outsubdir, "scene_list.json")
+        with open(outlistfile, "w") as f:
+            json.dump(valid_scenes, f)
+
+
+def process_scene(args):
+    rootdir, outdir, subdir, scene_subdir = args
+    # Unpack paths
+    scene_dir = osp.join(rootdir, subdir, scene_subdir)
+    outsubdir = osp.join(outdir, subdir)
+    out_scene_subdir = osp.join(outsubdir, scene_subdir)
+
+    # Validation if necessary resources exist
+    if (
+        not osp.exists(osp.join(scene_dir, "highres_depth"))
+        or not osp.exists(osp.join(scene_dir, "vga_wide"))
+        or not osp.exists(osp.join(scene_dir, "vga_wide_intrinsics"))
+        or not osp.exists(osp.join(scene_dir, "lowres_wide.traj"))
+    ):
+        return None
+
+    depth_dir = osp.join(scene_dir, "highres_depth")
+    rgb_dir = osp.join(scene_dir, "vga_wide")
+    intrinsics_dir = osp.join(scene_dir, "vga_wide_intrinsics")
+    traj_path = osp.join(scene_dir, "lowres_wide.traj")
+
+    depth_files = sorted(os.listdir(depth_dir))
+    img_files = sorted(os.listdir(rgb_dir))
+
+    out_scene_subdir = osp.join(outsubdir, scene_subdir)
+
+    # STEP 3: parse the scene and export the list of valid (K, pose, rgb, depth) and convert images
+    scene_metadata_path = osp.join(out_scene_subdir, "scene_metadata.npz")
+    if osp.isfile(scene_metadata_path):
+        print(f"Skipping {scene_subdir}")
+    else:
+        print(f"parsing {scene_subdir}")
+        # loads traj
+        timestamps, poses, quaternions, poses_cam_to_world = read_traj(traj_path)
+
+        poses = np.array(poses)
+        quaternions = np.array(quaternions, dtype=np.quaternion)
+        quaternions = quaternion.unflip_rotors(quaternions)
+        timestamps = np.array(timestamps)
+
+        all_depths = sorted(
+            [
+                (basename, basename.split(".png")[0].split("_")[1])
+                for basename in depth_files
+            ],
+            key=lambda x: float(x[1]),
+        )
+
+        selected_depths = []
+        timestamps_selected = []
+        timestamp_min = timestamps.min()
+        timestamp_max = timestamps.max()
+        for basename, frame_id in all_depths:
+            frame_id = float(frame_id)
+            if frame_id < timestamp_min or frame_id > timestamp_max:
+                continue
+            selected_depths.append((basename, frame_id))
+            timestamps_selected.append(frame_id)
+
+        sky_direction_scene, trajectories, intrinsics, images, depths = (
+            convert_scene_metadata(
+                scene_subdir,
+                intrinsics_dir,
+                timestamps,
+                quaternions,
+                poses,
+                poses_cam_to_world,
+                img_files,
+                selected_depths,
+                timestamps_selected,
+            )
+        )
+
+        if len(images) == 0:
+            print(f"Skipping {scene_subdir}")
+            return None
+
+        os.makedirs(out_scene_subdir, exist_ok=True)
+
+        os.makedirs(os.path.join(out_scene_subdir, "vga_wide"), exist_ok=True)
+        os.makedirs(os.path.join(out_scene_subdir, "highres_depth"), exist_ok=True)
+        assert isinstance(sky_direction_scene, str)
+
+        for image_path, depth_path in zip(images, depths):
+            img_out = os.path.join(
+                out_scene_subdir, "vga_wide", image_path.replace(".png", ".jpg")
+            )
+            depth_out = os.path.join(out_scene_subdir, "highres_depth", depth_path)
+            if osp.isfile(img_out) and osp.isfile(depth_out):
+                continue
+
+            vga_wide_path = osp.join(rgb_dir, image_path)
+            depth_path = osp.join(depth_dir, depth_path)
+
+            if not osp.isfile(vga_wide_path) or not osp.isfile(depth_path):
+                continue
+
+            img = Image.open(vga_wide_path)
+            depth = cv2.imread(depth_path, cv2.IMREAD_UNCHANGED)
+
+            # rotate the image
+            if sky_direction_scene == "RIGHT":
+                try:
+                    img = img.transpose(Image.Transpose.ROTATE_90)
+                except Exception:
+                    img = img.transpose(Image.ROTATE_90)
+                depth = cv2.rotate(depth, cv2.ROTATE_90_COUNTERCLOCKWISE)
+
+            elif sky_direction_scene == "LEFT":
+                try:
+                    img = img.transpose(Image.Transpose.ROTATE_270)
+                except Exception:
+                    img = img.transpose(Image.ROTATE_270)
+                depth = cv2.rotate(depth, cv2.ROTATE_90_CLOCKWISE)
+
+            elif sky_direction_scene == "DOWN":
+                try:
+                    img = img.transpose(Image.Transpose.ROTATE_180)
+                except Exception:
+                    img = img.transpose(Image.ROTATE_180)
+                depth = cv2.rotate(depth, cv2.ROTATE_180)
+
+            W, H = img.size
+            if not osp.isfile(img_out):
+                img.save(img_out)
+
+            depth = cv2.resize(depth, (W, H), interpolation=cv2.INTER_NEAREST)
+            if not osp.isfile(
+                depth_out
+            ):  # avoid destroying the base dataset when you mess up the paths
+                cv2.imwrite(depth_out, depth)
+
+        # save at the end
+        np.savez(
+            scene_metadata_path,
+            trajectories=trajectories,
+            intrinsics=intrinsics,
+            images=images,
+        )
+
+
+def convert_scene_metadata(
+    scene_subdir,
+    intrinsics_dir,
+    timestamps,
+    quaternions,
+    poses,
+    poses_cam_to_world,
+    all_images,
+    selected_depths,
+    timestamps_selected,
+):
+    # find scene orientation
+    sky_direction_scene, rotated_to_cam = find_scene_orientation(poses_cam_to_world)
+
+    # find/compute pose for selected timestamps
+    # most images have a valid timestamp / exact pose associated
+    timestamps_selected = np.array(timestamps_selected)
+    spline = interpolate.interp1d(timestamps, poses, kind="linear", axis=0)
+    interpolated_rotations = quaternion.squad(
+        quaternions, timestamps, timestamps_selected
+    )
+    interpolated_positions = spline(timestamps_selected)
+
+    trajectories = []
+    intrinsics = []
+    images = []
+    depths = []
+    for i, (basename, frame_id) in enumerate(selected_depths):
+        intrinsic_fn = osp.join(intrinsics_dir, f"{scene_subdir}_{frame_id}.pincam")
+        search_interval = int(0.1 / 0.001)
+        for timestamp in range(-search_interval, search_interval + 1):
+            if osp.exists(intrinsic_fn):
+                break
+            intrinsic_fn = osp.join(
+                intrinsics_dir,
+                f"{scene_subdir}_{float(frame_id) + timestamp * 0.001:.3f}.pincam",
+            )
+        if not osp.exists(intrinsic_fn):
+            print(f"Skipping {intrinsic_fn}")
+            continue
+
+        image_path = "{}_{}.png".format(scene_subdir, frame_id)
+        search_interval = int(0.001 / 0.001)
+        for timestamp in range(-search_interval, search_interval + 1):
+            if image_path in all_images:
+                break
+            image_path = "{}_{}.png".format(
+                scene_subdir, float(frame_id) + timestamp * 0.001
+            )
+        if image_path not in all_images:
+            print(f"Skipping {scene_subdir} {frame_id}")
+            continue
+
+        w, h, fx, fy, hw, hh = np.loadtxt(intrinsic_fn)  # PINHOLE
+
+        pose = np.eye(4)
+        pose[:3, :3] = quaternion.as_rotation_matrix(interpolated_rotations[i])
+        pose[:3, 3] = interpolated_positions[i]
+
+        images.append(basename)
+        depths.append(basename)
+        if sky_direction_scene == "RIGHT" or sky_direction_scene == "LEFT":
+            intrinsics.append([h, w, fy, fx, hh, hw])  # swapped intrinsics
+        else:
+            intrinsics.append([w, h, fx, fy, hw, hh])
+        trajectories.append(
+            pose @ rotated_to_cam
+        )  # pose_cam_to_world @ rotated_to_cam = rotated(cam) to world
+
+    return sky_direction_scene, trajectories, intrinsics, images, depths
+
+
+def find_scene_orientation(poses_cam_to_world):
+    if len(poses_cam_to_world) > 0:
+        up_vector = sum(get_up_vectors(p) for p in poses_cam_to_world) / len(
+            poses_cam_to_world
+        )
+        right_vector = sum(get_right_vectors(p) for p in poses_cam_to_world) / len(
+            poses_cam_to_world
+        )
+        up_world = np.array([[0.0], [0.0], [1.0], [0.0]])
+    else:
+        up_vector = np.array([[0.0], [-1.0], [0.0], [0.0]])
+        right_vector = np.array([[1.0], [0.0], [0.0], [0.0]])
+        up_world = np.array([[0.0], [0.0], [1.0], [0.0]])
+
+    # value between 0, 180
+    device_up_to_world_up_angle = (
+        np.arccos(np.clip(np.dot(np.transpose(up_world), up_vector), -1.0, 1.0)).item()
+        * 180.0
+        / np.pi
+    )
+    device_right_to_world_up_angle = (
+        np.arccos(
+            np.clip(np.dot(np.transpose(up_world), right_vector), -1.0, 1.0)
+        ).item()
+        * 180.0
+        / np.pi
+    )
+
+    up_closest_to_90 = abs(device_up_to_world_up_angle - 90.0) < abs(
+        device_right_to_world_up_angle - 90.0
+    )
+    if up_closest_to_90:
+        assert abs(device_up_to_world_up_angle - 90.0) < 45.0
+        # LEFT
+        if device_right_to_world_up_angle > 90.0:
+            sky_direction_scene = "LEFT"
+            cam_to_rotated_q = quaternion.from_rotation_vector(
+                [0.0, 0.0, math.pi / 2.0]
+            )
+        else:
+            # note that in metadata.csv RIGHT does not exist, but again it's not accurate...
+            # well, turns out there are scenes oriented like this
+            # for example Training/41124801
+            sky_direction_scene = "RIGHT"
+            cam_to_rotated_q = quaternion.from_rotation_vector(
+                [0.0, 0.0, -math.pi / 2.0]
+            )
+    else:
+        # right is close to 90
+        assert abs(device_right_to_world_up_angle - 90.0) < 45.0
+        if device_up_to_world_up_angle > 90.0:
+            sky_direction_scene = "DOWN"
+            cam_to_rotated_q = quaternion.from_rotation_vector([0.0, 0.0, math.pi])
+        else:
+            sky_direction_scene = "UP"
+            cam_to_rotated_q = quaternion.quaternion(1, 0, 0, 0)
+    cam_to_rotated = np.eye(4)
+    cam_to_rotated[:3, :3] = quaternion.as_rotation_matrix(cam_to_rotated_q)
+    rotated_to_cam = np.linalg.inv(cam_to_rotated)
+    return sky_direction_scene, rotated_to_cam
+
+
+if __name__ == "__main__":
+    parser = get_parser()
+    args = parser.parse_args()
+    main(args.arkitscenes_dir, args.output_dir)

3d-belief/third_party/CUT3R/src/dust3r/datasets/arkitscenes.py

@@ -0,0 +1,242 @@
+import os.path as osp
+import os
+import sys
+import itertools
+
+sys.path.append(osp.join(osp.dirname(__file__), "..", ".."))
+import cv2
+import numpy as np
+
+from dust3r.datasets.base.base_multiview_dataset import BaseMultiViewDataset
+from dust3r.utils.image import imread_cv2
+
+
+def stratified_sampling(indices, num_samples, rng=None):
+    if num_samples > len(indices):
+        raise ValueError("num_samples cannot exceed the number of available indices.")
+    elif num_samples == len(indices):
+        return indices
+
+    sorted_indices = sorted(indices)
+    stride = len(sorted_indices) / num_samples
+    sampled_indices = []
+    if rng is None:
+        rng = np.random.default_rng()
+
+    for i in range(num_samples):
+        start = int(i * stride)
+        end = int((i + 1) * stride)
+        # Ensure end does not exceed the list
+        end = min(end, len(sorted_indices))
+        if start < end:
+            # Randomly select within the current stratum
+            rand_idx = rng.integers(start, end)
+            sampled_indices.append(sorted_indices[rand_idx])
+        else:
+            # In case of any rounding issues, select the last index
+            sampled_indices.append(sorted_indices[-1])
+
+    return rng.permutation(sampled_indices)
+
+
+class ARKitScenes_Multi(BaseMultiViewDataset):
+    def __init__(self, *args, split, ROOT, **kwargs):
+        self.ROOT = ROOT
+        self.video = True
+        self.is_metric = True
+        self.max_interval = 8
+        super().__init__(*args, **kwargs)
+        if split == "train":
+            self.split = "Training"
+        elif split == "test":
+            self.split = "Test"
+        else:
+            raise ValueError("")
+
+        self.loaded_data = self._load_data(self.split)
+
+    def _load_data(self, split):
+        with np.load(osp.join(self.ROOT, split, "all_metadata.npz")) as data:
+            self.scenes: np.ndarray = data["scenes"]
+            high_res_list = np.array(
+                [
+                    d
+                    for d in os.listdir(
+                        os.path.join(
+                            self.ROOT.rstrip("/") + "_highres",
+                            split if split == "Training" else "Validation",
+                        )
+                    )
+                    if os.path.join(self.ROOT + "_highres", split, d)
+                ]
+            )
+            self.scenes = np.setdiff1d(self.scenes, high_res_list)
+        offset = 0
+        counts = []
+        scenes = []
+        sceneids = []
+        images = []
+        intrinsics = []
+        trajectories = []
+        groups = []
+        id_ranges = []
+        j = 0
+        for scene_idx, scene in enumerate(self.scenes):
+            scene_dir = osp.join(self.ROOT, self.split, scene)
+            with np.load(
+                osp.join(scene_dir, "new_scene_metadata.npz"), allow_pickle=True
+            ) as data:
+                imgs = data["images"]
+                intrins = data["intrinsics"]
+                traj = data["trajectories"]
+                min_seq_len = (
+                    self.num_views
+                    if not self.allow_repeat
+                    else max(self.num_views // 3, 3)
+                )
+                if len(imgs) < min_seq_len:
+                    print(f"Skipping {scene}")
+                    continue
+
+                collections = {}
+                assert "image_collection" in data, "Image collection not found"
+                collections["image"] = data["image_collection"]
+
+                num_imgs = imgs.shape[0]
+                img_groups = []
+                min_group_len = (
+                    self.num_views
+                    if not self.allow_repeat
+                    else max(self.num_views // 3, 3)
+                )
+                for ref_id, group in collections["image"].item().items():
+                    if len(group) + 1 < min_group_len:
+                        continue
+
+                    # groups are (idx, score)s
+                    group.insert(0, (ref_id, 1.0))
+                    group = [int(x[0] + offset) for x in group]
+                    img_groups.append(sorted(group))
+
+                if len(img_groups) == 0:
+                    print(f"Skipping {scene}")
+                    continue
+
+                scenes.append(scene)
+                sceneids.extend([j] * num_imgs)
+                id_ranges.extend([(offset, offset + num_imgs) for _ in range(num_imgs)])
+                images.extend(imgs)
+                K = np.expand_dims(np.eye(3), 0).repeat(num_imgs, 0)
+
+                K[:, 0, 0] = [fx for _, _, fx, _, _, _ in intrins]
+                K[:, 1, 1] = [fy for _, _, _, fy, _, _ in intrins]
+                K[:, 0, 2] = [cx for _, _, _, _, cx, _ in intrins]
+                K[:, 1, 2] = [cy for _, _, _, _, _, cy in intrins]
+                intrinsics.extend(list(K))
+                trajectories.extend(list(traj))
+
+                # offset groups
+                groups.extend(img_groups)
+                counts.append(offset)
+                offset += num_imgs
+                j += 1
+
+        self.scenes = scenes
+        self.sceneids = sceneids
+        self.id_ranges = id_ranges
+        self.images = images
+        self.intrinsics = intrinsics
+        self.trajectories = trajectories
+        self.groups = groups
+
+    def __len__(self):
+        return len(self.groups)
+
+    def get_image_num(self):
+        return len(self.images)
+
+    def _get_views(self, idx, resolution, rng, num_views):
+
+        if rng.choice([True, False]):
+            image_idxs = np.arange(self.id_ranges[idx][0], self.id_ranges[idx][1])
+            cut_off = num_views if not self.allow_repeat else max(num_views // 3, 3)
+            start_image_idxs = image_idxs[: len(image_idxs) - cut_off + 1]
+            start_id = rng.choice(start_image_idxs)
+            pos, ordered_video = self.get_seq_from_start_id(
+                num_views,
+                start_id,
+                image_idxs.tolist(),
+                rng,
+                max_interval=self.max_interval,
+                video_prob=0.8,
+                fix_interval_prob=0.5,
+                block_shuffle=16,
+            )
+            image_idxs = np.array(image_idxs)[pos]
+        else:
+            ordered_video = False
+            image_idxs = self.groups[idx]
+            image_idxs = rng.permutation(image_idxs)
+            if len(image_idxs) > num_views:
+                image_idxs = image_idxs[:num_views]
+            else:
+                if rng.random() < 0.8:
+                    image_idxs = rng.choice(image_idxs, size=num_views, replace=True)
+                else:
+                    repeat_num = num_views // len(image_idxs) + 1
+                    image_idxs = np.tile(image_idxs, repeat_num)[:num_views]
+
+        views = []
+        for v, view_idx in enumerate(image_idxs):
+            scene_id = self.sceneids[view_idx]
+            scene_dir = osp.join(self.ROOT, self.split, self.scenes[scene_id])
+
+            intrinsics = self.intrinsics[view_idx]
+            camera_pose = self.trajectories[view_idx]
+            basename = self.images[view_idx]
+            assert (
+                basename[:8] == self.scenes[scene_id]
+            ), f"{basename}, {self.scenes[scene_id]}"
+            # print(scene_dir, basename)
+            # Load RGB image
+            rgb_image = imread_cv2(
+                osp.join(scene_dir, "vga_wide", basename.replace(".png", ".jpg"))
+            )
+            # Load depthmap
+            depthmap = imread_cv2(
+                osp.join(scene_dir, "lowres_depth", basename), cv2.IMREAD_UNCHANGED
+            )
+            depthmap = depthmap.astype(np.float32) / 1000.0
+            depthmap[~np.isfinite(depthmap)] = 0  # invalid
+
+            rgb_image, depthmap, intrinsics = self._crop_resize_if_necessary(
+                rgb_image, depthmap, intrinsics, resolution, rng=rng, info=view_idx
+            )
+
+            # generate img mask and raymap mask
+            img_mask, ray_mask = self.get_img_and_ray_masks(
+                self.is_metric, v, rng, p=[0.75, 0.2, 0.05]
+            )
+
+            views.append(
+                dict(
+                    img=rgb_image,
+                    depthmap=depthmap.astype(np.float32),
+                    camera_pose=camera_pose.astype(np.float32),
+                    camera_intrinsics=intrinsics.astype(np.float32),
+                    dataset="arkitscenes",
+                    label=self.scenes[scene_id] + "_" + basename,
+                    instance=f"{str(idx)}_{str(view_idx)}",
+                    is_metric=self.is_metric,
+                    is_video=ordered_video,
+                    quantile=np.array(0.98, dtype=np.float32),
+                    img_mask=img_mask,
+                    ray_mask=ray_mask,
+                    camera_only=False,
+                    depth_only=False,
+                    single_view=False,
+                    reset=False,
+                )
+            )
+        assert len(views) == num_views
+        return views

3d-belief/third_party/CUT3R/src/dust3r/datasets/arkitscenes_highres.py

@@ -0,0 +1,175 @@
+import os.path as osp
+import os
+import sys
+import itertools
+
+sys.path.append(osp.join(osp.dirname(__file__), "..", ".."))
+import cv2
+import numpy as np
+import h5py
+import math
+from dust3r.datasets.base.base_multiview_dataset import BaseMultiViewDataset
+from dust3r.utils.image import imread_cv2
+
+
+class ARKitScenesHighRes_Multi(BaseMultiViewDataset):
+    def __init__(self, *args, split, ROOT, **kwargs):
+        self.ROOT = ROOT
+        self.video = True
+        self.max_interval = 8
+        self.is_metric = True
+        super().__init__(*args, **kwargs)
+        if split == "train":
+            self.split = "Training"
+        elif split == "test":
+            self.split = "Validation"
+        else:
+            raise ValueError("")
+
+        self.loaded_data = self._load_data(self.split)
+
+    def _load_data(self, split):
+        all_scenes = sorted(
+            [
+                d
+                for d in os.listdir(osp.join(self.ROOT, split))
+                if osp.isdir(osp.join(self.ROOT, split, d))
+            ]
+        )
+        offset = 0
+        scenes = []
+        sceneids = []
+        images = []
+        start_img_ids = []
+        scene_img_list = []
+        timestamps = []
+        intrinsics = []
+        trajectories = []
+        scene_id = 0
+        for scene in all_scenes:
+            scene_dir = osp.join(self.ROOT, self.split, scene)
+            with np.load(osp.join(scene_dir, "scene_metadata.npz")) as data:
+                imgs_with_indices = sorted(
+                    enumerate(data["images"]), key=lambda x: x[1]
+                )
+                imgs = [x[1] for x in imgs_with_indices]
+                cut_off = (
+                    self.num_views
+                    if not self.allow_repeat
+                    else max(self.num_views // 3, 3)
+                )
+                if len(imgs) < cut_off:
+                    print(f"Skipping {scene}")
+                    continue
+                indices = [x[0] for x in imgs_with_indices]
+                tsps = np.array(
+                    [float(img_name.split("_")[1][:-4]) for img_name in imgs]
+                )
+                assert [img[:8] == scene for img in imgs], f"{scene}, {imgs}"
+                num_imgs = data["images"].shape[0]
+                img_ids = list(np.arange(num_imgs) + offset)
+                start_img_ids_ = img_ids[: num_imgs - cut_off + 1]
+
+                scenes.append(scene)
+                scene_img_list.append(img_ids)
+                sceneids.extend([scene_id] * num_imgs)
+                images.extend(imgs)
+                start_img_ids.extend(start_img_ids_)
+                timestamps.extend(tsps)
+
+                K = np.expand_dims(np.eye(3), 0).repeat(num_imgs, 0)
+                intrins = data["intrinsics"][indices]
+                K[:, 0, 0] = [fx for _, _, fx, _, _, _ in intrins]
+                K[:, 1, 1] = [fy for _, _, _, fy, _, _ in intrins]
+                K[:, 0, 2] = [cx for _, _, _, _, cx, _ in intrins]
+                K[:, 1, 2] = [cy for _, _, _, _, _, cy in intrins]
+                intrinsics.extend(list(K))
+                trajectories.extend(list(data["trajectories"][indices]))
+
+                # offset groups
+                offset += num_imgs
+                scene_id += 1
+
+        self.scenes = scenes
+        self.sceneids = sceneids
+        self.images = images
+        self.scene_img_list = scene_img_list
+        self.intrinsics = intrinsics
+        self.trajectories = trajectories
+        self.start_img_ids = start_img_ids
+        assert len(self.images) == len(self.intrinsics) == len(self.trajectories)
+
+    def __len__(self):
+        return len(self.start_img_ids)
+
+    def get_image_num(self):
+        return len(self.images)
+
+    def _get_views(self, idx, resolution, rng, num_views):
+        start_id = self.start_img_ids[idx]
+        all_image_ids = self.scene_img_list[self.sceneids[start_id]]
+        pos, ordered_video = self.get_seq_from_start_id(
+            num_views,
+            start_id,
+            all_image_ids,
+            rng,
+            max_interval=self.max_interval,
+            block_shuffle=16,
+        )
+        image_idxs = np.array(all_image_ids)[pos]
+
+        views = []
+
+        for v, view_idx in enumerate(image_idxs):
+            scene_id = self.sceneids[view_idx]
+            scene_dir = osp.join(self.ROOT, self.split, self.scenes[scene_id])
+
+            intrinsics = self.intrinsics[view_idx]
+            camera_pose = self.trajectories[view_idx]
+            basename = self.images[view_idx]
+            assert (
+                basename[:8] == self.scenes[scene_id]
+            ), f"{basename}, {self.scenes[scene_id]}"
+            # print(scene_dir, basename)
+            # Load RGB image
+            rgb_image = imread_cv2(
+                osp.join(scene_dir, "vga_wide", basename.replace(".png", ".jpg"))
+            )
+            # Load depthmap
+            depthmap = imread_cv2(
+                osp.join(scene_dir, "highres_depth", basename), cv2.IMREAD_UNCHANGED
+            )
+            depthmap = depthmap.astype(np.float32) / 1000.0
+            depthmap[~np.isfinite(depthmap)] = 0  # invalid
+
+            rgb_image, depthmap, intrinsics = self._crop_resize_if_necessary(
+                rgb_image, depthmap, intrinsics, resolution, rng=rng, info=view_idx
+            )
+
+            # generate img mask and raymap mask
+            img_mask, ray_mask = self.get_img_and_ray_masks(
+                self.is_metric, v, rng, p=[0.7, 0.25, 0.05]
+            )
+
+            views.append(
+                dict(
+                    img=rgb_image,
+                    depthmap=depthmap.astype(np.float32),
+                    camera_pose=camera_pose.astype(np.float32),
+                    camera_intrinsics=intrinsics.astype(np.float32),
+                    dataset="arkitscenes_highres",
+                    label=self.scenes[scene_id] + "_" + basename,
+                    instance=f"{str(idx)}_{str(view_idx)}",
+                    is_metric=self.is_metric,
+                    is_video=ordered_video,
+                    quantile=np.array(0.99, dtype=np.float32),
+                    img_mask=img_mask,
+                    ray_mask=ray_mask,
+                    camera_only=False,
+                    depth_only=False,
+                    single_view=False,
+                    reset=False,
+                )
+            )
+        assert len(views) == num_views
+        return views