Add mast3r_mesh_gpu.py: mast3r_mesh.py with TSDF fusion on CUDA:0 when available (used for I87X meshes)

Bedroom1/MasterSlam1_ScanVideo1/mast3r_mesh_gpu.py

@@ -0,0 +1,541 @@
+#!/usr/bin/env python3
+"""
+mast3r_mesh.py - textured room mesh from a MASt3R-SLAM run, by TSDF fusion.
+
+    myenv/bin/python mast3r_mesh.py                                   # run dir = this folder
+    myenv/bin/python mast3r_mesh.py --video ../ScanVideos/Video1.mp4  # texture from full-res video
+    myenv/bin/python mast3r_mesh.py RUN_DIR -o out.obj --voxel 0.008
+
+Why not Poisson on scan.ply (ply2obj.py --mesh): an uncalibrated monocular SLAM cloud has
+drift (walls in 2-3 offset layers), floaters and no reliable normals; Poisson turns that
+into blobs, and colours averaged from points are blurry. This script does what RGB-D
+mappers like RTAB-Map do instead:
+
+  1. Rebuild each keyframe's depth map. MASt3R-SLAM writes scan.ply keyframe by keyframe in
+     pixel (raster) order, with each point's colour copied from keyframes/<t>.png, so a
+     greedy colour match recovers the keyframe + pixel of every point.
+  2. Fit a pinhole camera per keyframe (scan.txt pose + pixel <-> point), drop points that
+     don't reproject (colour coincidences) and flying pixels at depth edges.
+  2b. Refine keyframe poses like RTAB-Map's graph optimisation: ICP between overlapping
+     keyframes, then a pose graph solve, so SLAM drift doesn't leave doubled surfaces.
+  3. Fuse all depth maps in a TSDF volume (Open3D) and extract the surface. Offset layers
+     closer than --trunc merge into one surface.
+  4. UV-unwrap (xatlas) and texture each texel from the camera images that see it
+     (z-tested against the mesh, weighted by viewing angle and distance). With --video the
+     full-resolution frames are used instead of the 512 px keyframes.
+
+Inputs (in RUN_DIR): scan.ply, scan.txt, keyframes/scan/<timestamp>.png
+Outputs: <out>.obj, <out>.mtl, <out>.png. Same coordinate frame as scan.ply.
+Needs numpy, scipy, open3d, xatlas; --video also needs ffmpeg/ffprobe on PATH.
+"""
+import argparse
+import os
+import subprocess
+import sys
+
+import numpy as np
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from ply2obj import read_ply, write_rows  # noqa: E402
+
+
+def log(*a):
+    print("[mast3r_mesh]", *a, file=sys.stderr, flush=True)
+
+
+def quat_to_R(qx, qy, qz, qw):
+    n = np.sqrt(qx * qx + qy * qy + qz * qz + qw * qw)
+    x, y, z, w = qx / n, qy / n, qz / n, qw / n
+    return np.array([
+        [1 - 2 * (y * y + z * z), 2 * (x * y - z * w), 2 * (x * z + y * w)],
+        [2 * (x * y + z * w), 1 - 2 * (x * x + z * z), 2 * (y * z - x * w)],
+        [2 * (x * z - y * w), 2 * (y * z + x * w), 1 - 2 * (x * x + y * y)],
+    ])
+
+
+def read_rgb(path):
+    import open3d as o3d
+    a = np.asarray(o3d.io.read_image(path))
+    if a.ndim == 2:
+        a = np.repeat(a[..., None], 3, axis=2)
+    return np.ascontiguousarray(a[..., :3]).astype(np.uint8)
+
+
+def pack(rgb):
+    rgb = rgb.astype(np.int64)
+    return (rgb[..., 0] << 16) | (rgb[..., 1] << 8) | rgb[..., 2]
+
+
+# ----------------------------------------------------------------------------- 1. load + assign
+def load_run(run_dir):
+    _, data, _ = read_ply(os.path.join(run_dir, "scan.ply"))
+    v = data["vertex"]
+    P = np.stack([v["x"], v["y"], v["z"]], 1).astype(np.float64)
+    rgb = np.stack([v["red"], v["green"], v["blue"]], 1)
+    if rgb.dtype != np.uint8:
+        raise ValueError("expected uchar colours in scan.ply (MASt3R-SLAM output)")
+    traj = np.loadtxt(os.path.join(run_dir, "scan.txt"), ndmin=2)
+    kdir = os.path.join(run_dir, "keyframes", "scan")
+    by_t = {float(f[:-4]): f for f in os.listdir(kdir) if f.endswith(".png")}
+    imgs = []
+    for t in traj[:, 0]:
+        name = by_t.get(float(t))
+        if name is None:
+            raise FileNotFoundError(f"no keyframe image for timestamp {t} in {kdir}")
+        imgs.append(read_rgb(os.path.join(kdir, name)))
+    log(f"{len(P):,} points, {len(imgs)} keyframes {imgs[0].shape[1]}x{imgs[0].shape[0]}")
+    return P, rgb, traj, imgs
+
+
+def assign_pixels(rgb, imgs):
+    """Greedy subsequence match of point colours against keyframe pixels in raster order."""
+    cols = pack(rgb).tolist()
+    n, p = len(cols), 0
+    pix = np.full(n, -1, np.int64)
+    kf = np.full(n, -1, np.int64)
+    for k, im in enumerate(imgs):
+        start = p
+        for i, c in enumerate(pack(im).reshape(-1).tolist()):
+            if p < n and cols[p] == c:
+                pix[p] = i
+                p += 1
+        kf[start:p] = k
+    if p != n:
+        raise ValueError(f"only {p:,} of {n:,} points matched keyframe pixels: scan.ply is not in "
+                         "MASt3R-SLAM keyframe/raster order, or keyframes/ is from another run")
+    return pix, kf
+
+
+# ----------------------------------------------------------------------------- 2. cameras + depth
+def fit_camera(X, pix, W, thresh):
+    u, v, z = (pix % W).astype(np.float64), (pix // W).astype(np.float64), X[:, 2]
+    ok = z > 1e-6
+    for th in (50.0, 10.0, thresh):
+        a = X[ok, 0] / z[ok]
+        b = X[ok, 1] / z[ok]
+        fx, cx = np.linalg.lstsq(np.stack([a, np.ones_like(a)], 1), u[ok], rcond=None)[0]
+        fy, cy = np.linalg.lstsq(np.stack([b, np.ones_like(b)], 1), v[ok], rcond=None)[0]
+        with np.errstate(divide="ignore", invalid="ignore"):
+            r = np.hypot(fx * X[:, 0] / z + cx - u, fy * X[:, 1] / z + cy - v)
+        ok = (z > 1e-6) & (r < th)
+    return np.array([[fx, 0, cx], [0, fy, cy], [0, 0, 1]]), ok
+
+
+def drop_depth_edges(D, rel):
+    pad = np.pad(D, 1, mode="edge")
+    bad = np.zeros(D.shape, bool)
+    for nb in (pad[:-2, 1:-1], pad[2:, 1:-1], pad[1:-1, :-2], pad[1:-1, 2:]):
+        bad |= (nb > 0) & (np.abs(nb - D) > rel * D)
+    D = D.copy()
+    D[bad] = 0
+    return D
+
+
+def build_cameras(P, traj, imgs, pix, kf, reproj, edge):
+    H, W = imgs[0].shape[:2]
+    cams = []
+    for k in range(len(imgs)):
+        m = kf == k
+        R = quat_to_R(*traj[k, 4:8])
+        t = traj[k, 1:4]
+        X = (P[m] - t) @ R          # world -> camera (scan.txt drops the Sim3 scale; depth stays in world units)
+        cam = {"R": R, "t": t, "img": imgs[k], "depth": np.zeros((H, W), np.float32)}
+        if m.sum() < 100:
+            log(f"keyframe {k}: only {m.sum()} points, skipped")
+            cam["K"] = None
+            cams.append(cam)
+            continue
+        K, ok = fit_camera(X, pix[m], W, reproj)
+        D = np.zeros(H * W, np.float32)
+        D[pix[m][ok]] = X[ok, 2]
+        D = drop_depth_edges(D.reshape(H, W), edge)
+        cam["K"], cam["depth"] = K, D
+        cams.append(cam)
+        if k % 10 == 0 or k == len(imgs) - 1:
+            log(f"keyframe {k}: f={K[0, 0]:.0f} c=({K[0, 2]:.0f},{K[1, 2]:.0f}), "
+                f"{int((D > 0).sum()):,}/{int(m.sum()):,} depth px kept")
+    return cams
+
+
+# ----------------------------------------------------------------------------- 2b. pose refinement
+def cam_to_world(c):
+    T = np.eye(4)
+    T[:3, :3] = c["R"]
+    T[:3, 3] = c["t"]
+    return T
+
+
+def cam_cloud(c, voxel):
+    """Keyframe depth map -> downsampled cloud with normals, in camera coordinates."""
+    import open3d as o3d
+    D, K = c["depth"], c["K"]
+    v, u = np.nonzero(D > 0)
+    z = D[v, u].astype(np.float64)
+    X = np.stack([(u - K[0, 2]) * z / K[0, 0], (v - K[1, 2]) * z / K[1, 1], z], 1)
+    pc = o3d.geometry.PointCloud(o3d.utility.Vector3dVector(X))
+    pc = pc.voxel_down_sample(voxel)
+    pc.estimate_normals(o3d.geometry.KDTreeSearchParamHybrid(radius=voxel * 3, max_nn=30))
+    pc.orient_normals_towards_camera_location(np.zeros(3))
+    return pc
+
+
+def refine_poses(cams, voxel, max_dist, min_overlap):
+    """What RTAB-Map does after odometry: register overlapping views (ICP), add those as
+    loop-closure constraints, and solve the pose graph so drift is spread out instead of
+    showing up as doubled walls. Depth maps stay as they are; only the keyframe poses move."""
+    import open3d as o3d
+    from scipy.spatial import cKDTree
+    reg = o3d.pipelines.registration
+    ids = [k for k, c in enumerate(cams) if c["K"] is not None]
+    clouds = {k: cam_cloud(cams[k], voxel) for k in ids}
+    T = {k: cam_to_world(cams[k]) for k in ids}
+    world = {k: np.asarray(clouds[k].points) @ T[k][:3, :3].T + T[k][:3, 3] for k in ids}
+    trees = {k: cKDTree(world[k]) for k in ids}
+    node = {k: i for i, k in enumerate(ids)}
+    graph = reg.PoseGraph()
+    for k in ids:
+        graph.nodes.append(reg.PoseGraphNode(T[k]))
+
+    n_odo = n_loop = n_fail = 0
+    for i, s in enumerate(ids):
+        for t in ids[i + 1:]:
+            consecutive = t == ids[i + 1]
+            d, _ = trees[t].query(world[s][::4], distance_upper_bound=max_dist)
+            if np.isfinite(d).mean() < min_overlap and not consecutive:
+                continue
+            init = np.linalg.inv(T[t]) @ T[s]  # source (s) camera -> target (t) camera
+            tf = init
+            for md in (max_dist, max_dist / 2, max_dist / 4):
+                res = reg.registration_icp(
+                    clouds[s], clouds[t], md, tf,
+                    reg.TransformationEstimationPointToPlane(reg.TukeyLoss(k=md)),
+                    reg.ICPConvergenceCriteria(max_iteration=30))
+                tf = res.transformation
+            ok = res.fitness >= min_overlap
+            if not ok:
+                if not consecutive:
+                    continue
+                tf = init  # keep the SLAM odometry so the graph stays connected
+                n_fail += 1
+            info = reg.get_information_matrix_from_point_clouds(clouds[s], clouds[t], max_dist / 4, tf)
+            graph.edges.append(reg.PoseGraphEdge(node[s], node[t], tf, info, uncertain=not consecutive))
+            n_odo += consecutive
+            n_loop += not consecutive
+    log(f"refine: {n_odo} odometry edges ({n_fail} kept SLAM pose, ICP failed), {n_loop} loop edges")
+
+    o3d.utility.set_verbosity_level(o3d.utility.VerbosityLevel.Error)
+    reg.global_optimization(
+        graph, reg.GlobalOptimizationLevenbergMarquardt(), reg.GlobalOptimizationConvergenceCriteria(),
+        reg.GlobalOptimizationOption(max_correspondence_distance=max_dist / 4,
+                                     edge_prune_threshold=0.25, reference_node=0))
+    moved = []
+    for k in ids:
+        P = np.asarray(graph.nodes[node[k]].pose)
+        moved.append(np.linalg.norm(P[:3, 3] - cams[k]["t"]))
+        cams[k]["R"], cams[k]["t"] = P[:3, :3].copy(), P[:3, 3].copy()
+    log(f"refine: keyframes moved median {np.median(moved):.3f}, max {np.max(moved):.3f} (scene units)")
+
+
+# ----------------------------------------------------------------------------- 3. TSDF
+def fuse(cams, voxel, trunc, min_weight):
+    # Tensor VoxelBlockGrid: the legacy ScalableTSDFVolume extracts an empty mesh in Open3D 0.20 (macOS arm64)
+    import open3d as o3d
+    core = o3d.core
+    DEV = core.Device("CUDA:0" if core.cuda.is_available() else "CPU:0")  # GPU patch (server run)
+    log(f"tsdf device: {DEV}")
+    vbg = o3d.t.geometry.VoxelBlockGrid(
+        attr_names=("tsdf", "weight", "color"), attr_dtypes=(core.float32, core.float32, core.float32),
+        attr_channels=((1), (1), (3)), voxel_size=voxel, block_resolution=8, block_count=50000,
+        device=DEV)
+    for c in cams:
+        if c["K"] is None:
+            continue
+        K = core.Tensor(c["K"], core.float64)
+        E = core.Tensor(world_to_cam(c), core.float64)
+        depth = o3d.t.geometry.Image(core.Tensor(c["depth"])).to(DEV)
+        color = o3d.t.geometry.Image(core.Tensor(c["img"].astype(np.float32))).to(DEV)
+        blocks = vbg.compute_unique_block_coordinates(depth, K, E, 1.0, 1e6, trunc_voxel_multiplier=trunc / voxel)
+        vbg.integrate(blocks, depth, color, K, K, E, 1.0, 1e6, trunc_voxel_multiplier=trunc / voxel)
+    tm = vbg.extract_triangle_mesh(weight_threshold=min_weight)
+    mesh = tm.cpu().to_legacy()
+    if mesh.has_vertex_colors():
+        mesh.vertex_colors = o3d.utility.Vector3dVector(np.asarray(mesh.vertex_colors).clip(0, 255) / 255)
+    log(f"tsdf: {len(mesh.vertices):,} verts, {len(mesh.triangles):,} tris "
+        f"(voxel {voxel:.4g}, trunc {trunc:.4g}, min weight {min_weight})")
+    return mesh
+
+
+def world_to_cam(c):
+    E = np.eye(4)
+    E[:3, :3] = c["R"].T
+    E[:3, 3] = -c["R"].T @ c["t"]
+    return E
+
+
+def clean_mesh(mesh, min_cluster, tris):
+    tri_cluster, n_tri, _ = mesh.cluster_connected_triangles()
+    tri_cluster, n_tri = np.asarray(tri_cluster), np.asarray(n_tri)
+    small = n_tri[tri_cluster] < min_cluster * len(tri_cluster)
+    mesh.remove_triangles_by_mask(small)
+    mesh.remove_unreferenced_vertices()
+    log(f"clean: removed {int(small.sum()):,} tris in {int((n_tri < min_cluster * len(tri_cluster)).sum()):,} "
+        f"small pieces")
+    if len(mesh.triangles) > tris:
+        mesh = mesh.simplify_quadric_decimation(target_number_of_triangles=tris)
+    mesh.remove_degenerate_triangles()
+    mesh.remove_unreferenced_vertices()
+    mesh.compute_vertex_normals()
+    log(f"clean: {len(mesh.vertices):,} verts, {len(mesh.triangles):,} tris")
+    return mesh
+
+
+# ----------------------------------------------------------------------------- 4. colour sources
+def video_size(path):
+    out = subprocess.run(["ffprobe", "-v", "error", "-select_streams", "v:0", "-show_entries",
+                          "stream=width,height:stream_side_data=rotation", "-of", "default=nw=1", path],
+                         capture_output=True, text=True, check=True).stdout
+    kv = dict(l.split("=", 1) for l in out.split() if "=" in l)
+    w, h = int(kv["width"]), int(kv["height"])
+    if abs(int(float(kv.get("rotation", 0)))) % 180 == 90:  # ffmpeg auto-rotates on decode
+        w, h = h, w
+    return w, h
+
+
+def video_frames(path):
+    vw, vh = video_size(path)
+    proc = subprocess.Popen(["ffmpeg", "-v", "error", "-i", path, "-f", "rawvideo", "-pix_fmt", "rgb24", "-"],
+                            stdout=subprocess.PIPE)
+    n = vw * vh * 3
+    while True:
+        buf = proc.stdout.read(n)
+        if len(buf) < n:
+            break
+        yield np.frombuffer(buf, np.uint8).reshape(vh, vw, 3)
+    proc.wait()
+
+
+def attach_video(cams, path, max_err):
+    """Find each keyframe's source frame (best match after MASt3R's resize + centre crop)."""
+    H, W = cams[0]["img"].shape[:2]
+    vw, vh = video_size(path)
+    s = min(vw / W, vh / H)
+    ox, oy = (vw - W * s) / 2, (vh - H * s) / 2
+    step = 4
+    ref = np.stack([c["img"][::step, ::step] for c in cams]).astype(np.float32)
+    ys = np.clip(((np.arange(0, H, step) + 0.5) * s - 0.5 + oy).round().astype(int), 0, vh - 1)
+    xs = np.clip(((np.arange(0, W, step) + 0.5) * s - 0.5 + ox).round().astype(int), 0, vw - 1)
+    best = np.full(len(cams), np.inf)
+    keep = [None] * len(cams)
+    log(f"video: {path} {vw}x{vh}, matching {len(cams)} keyframes (scale {s:.3g})")
+    for fr in video_frames(path):
+        # box-average around each sample so a 3.75x downscale compares like with like
+        r = max(int(s // 2), 0)
+        sm = np.zeros((len(ys), len(xs), 3), np.float32)
+        for dy in range(-r, r + 1):
+            for dx in range(-r, r + 1):
+                sm += fr[np.clip(ys + dy, 0, vh - 1)][:, np.clip(xs + dx, 0, vw - 1)]
+        sm /= (2 * r + 1) ** 2
+        err = np.abs(ref - sm).mean(axis=(1, 2, 3))
+        better = err < best
+        for k in np.nonzero(better)[0]:
+            best[k], keep[k] = err[k], fr.copy()
+    used = 0
+    for k, c in enumerate(cams):
+        if keep[k] is None or best[k] > max_err:
+            log(f"video: keyframe {k} best match error {best[k]:.1f} > {max_err}, using keyframe image")
+            continue
+        c["src"] = keep[k]
+        c["src_K"] = scale_K(c["K"], s, ox, oy) if c["K"] is not None else None
+        used += 1
+    log(f"video: {used}/{len(cams)} keyframes textured from video (match error median {np.median(best):.2f})")
+
+
+def scale_K(K, s, ox, oy):
+    K2 = K.copy()
+    K2[0, 0] *= s
+    K2[1, 1] *= s
+    K2[0, 2] = (K[0, 2] + 0.5) * s - 0.5 + ox
+    K2[1, 2] = (K[1, 2] + 0.5) * s - 0.5 + oy
+    return K2
+
+
+def bilinear(img, u, v):
+    h, w = img.shape[:2]
+    u = np.clip(u, 0, w - 1.001)
+    v = np.clip(v, 0, h - 1.001)
+    x0, y0 = u.astype(np.int64), v.astype(np.int64)
+    fx, fy = (u - x0)[:, None], (v - y0)[:, None]
+    a = img[y0, x0].astype(np.float32)
+    b = img[y0, x0 + 1].astype(np.float32)
+    c = img[y0 + 1, x0].astype(np.float32)
+    d = img[y0 + 1, x0 + 1].astype(np.float32)
+    return (a * (1 - fx) + b * fx) * (1 - fy) + (c * (1 - fx) + d * fx) * fy
+
+
+def render_depths(mesh, cams):
+    """Depth of the fused mesh seen from each keyframe camera, for occlusion tests."""
+    import open3d as o3d
+    scene = o3d.t.geometry.RaycastingScene()
+    scene.add_triangles(o3d.t.geometry.TriangleMesh.from_legacy(mesh))
+    for c in cams:
+        if c["K"] is None:
+            continue
+        H, W = c["depth"].shape
+        rays = scene.create_rays_pinhole(o3d.core.Tensor(c["K"]), o3d.core.Tensor(world_to_cam(c)), W, H)
+        hit = scene.cast_rays(rays)["t_hit"].numpy()
+        r = rays.numpy()
+        pts = r[..., :3] + r[..., 3:] * hit[..., None]
+        z = ((pts - c["t"]) @ c["R"])[..., 2]
+        z[~np.isfinite(hit)] = np.inf
+        c["zbuf"] = z.astype(np.float32)
+
+
+def colour_texels(P, N, cams, voxel, power, chunk=1_000_000):
+    acc = np.zeros((len(P), 3), np.float32)
+    wsum = np.zeros(len(P), np.float32)
+    for c in cams:
+        if c["K"] is None:
+            continue
+        K, R, t, zb = c["K"], c["R"], c["t"], c["zbuf"]
+        H, W = zb.shape
+        src = c.get("src", c["img"])
+        sK = c.get("src_K", K) if "src" in c else K
+        border = 0.08 * W
+        for i in range(0, len(P), chunk):
+            p, n = P[i:i + chunk], N[i:i + chunk]
+            X = (p - t) @ R
+            z = X[:, 2]
+            with np.errstate(divide="ignore", invalid="ignore"):
+                u = K[0, 0] * X[:, 0] / z + K[0, 2]
+                v = K[1, 1] * X[:, 1] / z + K[1, 2]
+            inb = (z > 1e-6) & (u >= 0) & (u <= W - 1) & (v >= 0) & (v <= H - 1)
+            idx = np.nonzero(inb)[0]
+            if not len(idx):
+                continue
+            zr = zb[v[idx].round().astype(int), u[idx].round().astype(int)]
+            vis = np.abs(z[idx] - zr) < np.maximum(2 * voxel, 0.02 * z[idx])
+            idx = idx[vis]
+            if not len(idx):
+                continue
+            view = t - p[idx]
+            dist = np.linalg.norm(view, axis=1)
+            cos = np.einsum("ij,ij->i", n[idx], view) / np.maximum(dist, 1e-9)
+            edge = np.minimum.reduce([u[idx], W - 1 - u[idx], v[idx], H - 1 - v[idx]]) / border
+            w = (np.clip(cos, 0, 1) * np.clip(edge, 0, 1) / np.maximum(dist, 1e-6)) ** power
+            good = w > 0
+            idx, w = idx[good], w[good].astype(np.float32)
+            Xs = X[idx]
+            us = sK[0, 0] * Xs[:, 0] / Xs[:, 2] + sK[0, 2]
+            vs = sK[1, 1] * Xs[:, 1] / Xs[:, 2] + sK[1, 2]
+            acc[i + idx] += w[:, None] * bilinear(src, us, vs)
+            wsum[i + idx] += w
+    seen = wsum > 0
+    acc[seen] /= wsum[seen, None]
+    return acc, seen
+
+
+# ----------------------------------------------------------------------------- textured OBJ
+def write_textured(mesh, cams, dst, size, voxel, power):
+    import open3d as o3d
+    import xatlas
+    from scipy import ndimage
+
+    V = np.asarray(mesh.vertices)
+    T = np.asarray(mesh.triangles)
+    N = np.asarray(mesh.vertex_normals)
+    C = np.asarray(mesh.vertex_colors) if mesh.has_vertex_colors() else np.full_like(V, 0.5)
+    log(f"texture: unwrapping {len(T):,} tris with xatlas (slow: ~30 s per 60k tris)")
+    atlas = xatlas.Atlas()
+    atlas.add_mesh(V.astype(np.float32), T.astype(np.uint32))
+    chart = xatlas.ChartOptions()
+    chart.max_iterations = 1
+    pack_opt = xatlas.PackOptions()
+    pack_opt.resolution = size
+    pack_opt.padding = 4
+    atlas.generate(chart, pack_opt)
+    vmap, idx, uv = atlas[0]
+    if uv.max() > 1.5:  # older xatlas wheels return texel units
+        uv = uv / np.array([atlas.width, atlas.height])
+    idx = idx.astype(np.int64)
+
+    tm = o3d.t.geometry.TriangleMesh()
+    tm.vertex.positions = o3d.core.Tensor(V[vmap].astype(np.float32))
+    tm.vertex.normals = o3d.core.Tensor(N[vmap].astype(np.float32))
+    tm.vertex.colors = o3d.core.Tensor(C[vmap].astype(np.float32))
+    tm.triangle.indices = o3d.core.Tensor(idx.astype(np.int32))
+    tm.triangle.texture_uvs = o3d.core.Tensor(uv[idx].astype(np.float32))
+    maps = tm.bake_vertex_attr_textures(size, {"positions", "normals", "colors"}, 8, -1e6, False)
+    pos, nrm, col = (maps[k].numpy() for k in ("positions", "normals", "colors"))
+    valid = pos[..., 0] > -1e5
+    P = pos[valid].astype(np.float64)
+    Nn = nrm[valid].astype(np.float64)
+    Nn /= np.maximum(np.linalg.norm(Nn, axis=1, keepdims=True), 1e-9)
+    log(f"texture: colouring {len(P):,} texels from {sum(c['K'] is not None for c in cams)} views")
+    render_depths(mesh, cams)
+    rgb, seen = colour_texels(P, Nn, cams, voxel, power)
+    rgb[~seen] = col[valid][~seen] * 255  # never seen unoccluded: fall back to TSDF colour
+    log(f"texture: {int(seen.sum()):,} texels from images, {int((~seen).sum()):,} from TSDF colour")
+
+    tex = np.zeros((size, size, 3), np.uint8)
+    tex[valid] = rgb.clip(0, 255).astype(np.uint8)
+    # bleed chart colours into the gutters so mipmapping doesn't pull in black seams
+    _, (iy, ix) = ndimage.distance_transform_edt(~valid, return_indices=True)
+    tex = tex[iy, ix]
+
+    base = os.path.splitext(dst)[0]
+    name = os.path.basename(base)
+    os.makedirs(os.path.dirname(os.path.abspath(dst)), exist_ok=True)
+    o3d.io.write_image(base + ".png", o3d.geometry.Image(np.ascontiguousarray(tex)))  # row 0 = v 1, as OBJ expects
+    with open(base + ".mtl", "w") as m:
+        m.write(f"newmtl material0\nKd 1 1 1\nmap_Kd {name}.png\n")
+    with open(dst, "w", buffering=1 << 20) as fh:
+        fh.write(f"# textured TSDF mesh by mast3r_mesh.py\nmtllib {name}.mtl\n")
+        write_rows(fh, V[vmap], "v %.7g %.7g %.7g")
+        write_rows(fh, N[vmap], "vn %.6g %.6g %.6g")
+        write_rows(fh, uv, "vt %.6g %.6g")
+        fh.write("usemtl material0\n")
+        # v, vt and vn share one index (xatlas splits vertices), so each corner is i/i/i
+        write_rows(fh, np.repeat(idx + 1, 3, axis=1), "f %d/%d/%d %d/%d/%d %d/%d/%d")
+    log(f"done: {dst}, {base}.png ({size}x{size}), {len(vmap):,} verts, {len(idx):,} tris")
+
+
+def main():
+    here = os.path.dirname(os.path.abspath(__file__))
+    ap = argparse.ArgumentParser(description="Textured TSDF mesh from a MASt3R-SLAM run")
+    ap.add_argument("run_dir", nargs="?", default=here, help="folder with scan.ply, scan.txt, keyframes/ (default: script folder)")
+    ap.add_argument("-o", "--output", help="default: <run_dir>/scan_tsdf.obj")
+    ap.add_argument("--video", help="source video of the run: texture from its full-res frames instead of 512 px keyframes")
+    ap.add_argument("--voxel", type=float, default=0, help="TSDF voxel size in scene units (default: 2x median pixel footprint)")
+    ap.add_argument("--trunc", type=float, default=0, help="TSDF truncation; offset layers closer than this merge (default 5x voxel)")
+    ap.add_argument("--min-weight", type=float, default=1.5, help="keep surface seen in at least this many keyframes (default 1.5, i.e. 2)")
+    ap.add_argument("--reproj", type=float, default=8.0, help="drop points that reproject worse than this many px (default 8)")
+    ap.add_argument("--no-refine", action="store_true", help="skip ICP + pose-graph refinement of keyframe poses")
+    ap.add_argument("--icp-dist", type=float, default=0, help="refine: max ICP correspondence distance (default 10x voxel)")
+    ap.add_argument("--edge", type=float, default=0.05, help="drop depth px differing from a neighbour by > this fraction (default 0.05)")
+    ap.add_argument("--min-cluster", type=float, default=0.002, help="remove mesh pieces smaller than this fraction of all tris (default 0.002)")
+    ap.add_argument("--tris", type=int, default=300000, help="max triangles after decimation (default 300000)")
+    ap.add_argument("--tex-size", type=int, default=4096, help="texture size in pixels (default 4096)")
+    ap.add_argument("--blend", type=float, default=4.0, help="view blending sharpness; higher = closer to best-view-only (default 4)")
+    ap.add_argument("--video-max-err", type=float, default=6.0, help="max mean abs error (0-255) for a video frame to count as a keyframe's source")
+    a = ap.parse_args()
+    out = a.output or os.path.join(a.run_dir, "scan_tsdf.obj")
+
+    P, rgb, traj, imgs = load_run(a.run_dir)
+    pix, kf = assign_pixels(rgb, imgs)
+    cams = build_cameras(P, traj, imgs, pix, kf, a.reproj, a.edge)
+    del P, rgb, pix, kf
+
+    zs = np.concatenate([c["depth"][c["depth"] > 0] / c["K"][0, 0] for c in cams if c["K"] is not None])
+    voxel = a.voxel or 2 * float(np.median(zs))
+    trunc = a.trunc or 5 * voxel
+    if not a.no_refine:
+        refine_poses(cams, 2 * voxel, a.icp_dist or 10 * voxel, 0.3)
+    mesh = fuse(cams, voxel, trunc, a.min_weight)
+    mesh = clean_mesh(mesh, a.min_cluster, a.tris)
+    if a.video:
+        attach_video(cams, a.video, a.video_max_err)
+    write_textured(mesh, cams, out, a.tex_size, voxel, a.blend)
+
+
+if __name__ == "__main__":
+    main()