Add MASt3R-SLAM runs for I12X Video1_T3 and Video2_T3, each without and with ARCore intrinsics

.gitattributes

@@ -1338,3 +1338,7 @@ P63/Spatiallm1_MasterSlam1/room_with_scan_preview.glb filter=lfs diff=lfs merge=
 P64/Spatiallm1_MasterSlam1/room_with_scan_preview.glb filter=lfs diff=lfs merge=lfs -text
 I87X/Spatiallm1_MasterSlam1/room_with_scan_preview.glb filter=lfs diff=lfs merge=lfs -text
 I87X/Spatiallm1_MasterSlam2/room_with_scan_preview.glb filter=lfs diff=lfs merge=lfs -text
+I12X/MasterSlam1_ScanVideo1/scan.ply filter=lfs diff=lfs merge=lfs -text
+I12X/MasterSlam2_ScanVideo1/scan.ply filter=lfs diff=lfs merge=lfs -text
+I12X/MasterSlam3_ScanVideo2/scan.ply filter=lfs diff=lfs merge=lfs -text
+I12X/MasterSlam4_ScanVideo2/scan.ply filter=lfs diff=lfs merge=lfs -text

I12X/MasterSlam1_ScanVideo1/compare_t3.py

@@ -0,0 +1,68 @@
+import json, sys
+import numpy as np
+from scipy.spatial.transform import Rotation as R
+from scipy.spatial import cKDTree
+
+root, video, names = sys.argv[1], sys.argv[2], sys.argv[3:]  # room dir, T3 capture name, MasterSlam folders
+gt = {}
+for line in open(f"{root}/ScanVideos/{video}/poses.jsonl"):
+    d = json.loads(line)
+    if d["state"] == "TRACKING":
+        gt[d["i"]] = (np.array(d["p"]), np.array(d["q"]))  # q = x,y,z,w (ARCore)
+
+def umeyama(src, dst):
+    mu_s, mu_d = src.mean(0), dst.mean(0)
+    xs, xd = src - mu_s, dst - mu_d
+    U, D, Vt = np.linalg.svd(xd.T @ xs / len(src))
+    S = np.eye(3); S[2, 2] = np.sign(np.linalg.det(U @ Vt))
+    Rm = U @ S @ Vt
+    s = np.trace(np.diag(D) @ S) / xs.var(0).sum()
+    return s, Rm, mu_d - s * Rm @ mu_s
+
+res = {}
+C = R.from_matrix(np.diag([1.0, -1.0, -1.0]))  # OpenGL (ARCore) camera -> OpenCV camera
+for name in names:
+    T = np.loadtxt(f"{root}/{name}/scan.txt")
+    idx = np.round(T[:, 0] * 30).astype(int)
+    keep = [k for k, i in enumerate(idx) if i in gt]
+    P = T[keep, 1:4]; Q = T[keep, 4:8]
+    G = np.array([gt[idx[k]][0] for k in keep]); GQ = np.array([gt[idx[k]][1] for k in keep])
+    s, Rm, t = umeyama(P, G)
+    Pa = (s * (Rm @ P.T)).T + t
+    ate = np.linalg.norm(Pa - G, axis=1)
+    # relative rotation error between consecutive keyframes (alignment-free)
+    rre = []
+    for a, b in zip(range(len(keep) - 1), range(1, len(keep))):
+        de = (R.from_quat(Q[a]).inv() * R.from_quat(Q[b]))
+        dg = C.inv() * R.from_quat(GQ[a]).inv() * R.from_quat(GQ[b]) * C
+        rre.append(np.degrees((de.inv() * dg).magnitude()))
+    path_gt = np.linalg.norm(np.diff(G, axis=0), axis=1).sum()
+    print(f"{name}: {len(keep)} kf matched | Sim3 scale {s:.3f} | ATE rmse {np.sqrt((ate**2).mean())*100:.1f} cm "
+          f"(max {ate.max()*100:.1f}) | RPE-rot mean {np.mean(rre):.2f} deg (max {np.max(rre):.2f}) | ARCore path {path_gt:.2f} m")
+    res[name] = (s, Rm, t)
+
+# point clouds in ARCore frame (metric), compare each other
+def load_ply(p):
+    with open(p, "rb") as f:
+        hdr = b""
+        while not hdr.endswith(b"end_header\n"):
+            hdr += f.readline()
+        h = hdr.decode()
+        n = int([l for l in h.splitlines() if l.startswith("element vertex")][0].split()[-1])
+        props = [l.split() for l in h.splitlines() if l.startswith("property")]
+        dt = np.dtype([(p[2], {"float": "<f4", "double": "<f8", "uchar": "u1", "float32": "<f4", "uint8": "u1"}[p[1]]) for p in props])
+        a = np.frombuffer(f.read(n * dt.itemsize), dt, n) if "binary" in h else np.loadtxt(f, max_rows=n)
+    return np.stack([a["x"], a["y"], a["z"]], 1).astype(np.float64)
+
+rng = np.random.default_rng(0)
+clouds = {}
+for name, (s, Rm, t) in res.items():
+    X = load_ply(f"{root}/{name}/scan.ply")
+    X = X[rng.choice(len(X), min(len(X), 300_000), replace=False)]
+    clouds[name] = (s * (Rm @ X.T)).T + t
+    lo, hi = np.percentile(clouds[name], [2, 98], axis=0)
+    print(f"{name}: extent (2-98 pct, ARCore metres) {np.round(hi - lo, 2)}")
+a, b = clouds.values()
+d_ab = cKDTree(b).query(a)[0]; d_ba = cKDTree(a).query(b)[0]
+print(f"cloud-to-cloud (after each aligned to ARCore): median {np.median(np.r_[d_ab, d_ba])*100:.1f} cm, "
+      f"90th pct {np.percentile(np.r_[d_ab, d_ba], 90)*100:.1f} cm")

I12X/MasterSlam1_ScanVideo1/config.yaml

@@ -0,0 +1,58 @@
+use_calib: False
+single_thread: False
+dataset:
+  subsample: 1
+  img_downsample: 1
+  center_principle_point: True
+
+matching:
+  max_iter: 10
+  lambda_init: 1e-8
+  convergence_thresh: 1e-6
+  dist_thresh: 1e-1 # distance in 3D space
+  radius: 3
+  dilation_max: 5 # Right now starts from max and iteratively decreases until 1
+
+tracking:
+  min_match_frac: 0.05
+  max_iters: 50
+  C_conf: 0.0
+  Q_conf: 1.5
+  rel_error: 1e-3
+  delta_norm: 1e-3
+  huber: 1.345
+  match_frac_thresh: 0.333
+  sigma_ray: 0.003
+  sigma_dist: 1e+1
+  sigma_pixel: 1.0
+  sigma_depth: 1e+1 # NOTE: log-depth!
+  sigma_point: 0.05
+  pixel_border: -10 # Only in calib (negative means allow pixels outside image up to that distance)
+  depth_eps: 1e-6 # Only in calib case
+  filtering_mode: weighted_pointmap # recent, first, best_score, weighted_pointmap, weighted_spherical, indep_conf
+  filtering_score: median # median, mean (only used for filtering_mode=best_score)
+
+local_opt:
+  pin: 1
+  window_size: 1e+6   
+  C_conf: 0.0
+  Q_conf: 1.5
+  min_match_frac: 0.1
+  pixel_border: -10 # Only in calib (negative means allow pixels outside image up to that distance)
+  depth_eps: 1e-6 # Only in calib case
+  max_iters: 10
+  sigma_ray: 0.003
+  sigma_dist: 1e+1
+  sigma_pixel: 1.0
+  sigma_depth: 1e+1 # NOTE: log-depth!
+  sigma_point: 0.05
+  delta_norm: 1e-8
+  use_cuda: True
+
+retrieval:
+  k: 3
+  min_thresh: 5e-3
+
+reloc:
+  min_match_frac: 0.3
+  strict: True