forgebench: Pixal3D MV uses upstream f7cf384 inference_mv (drop stale local copy), env-overridable paths, SETUP.md

forgebench/code/SETUP.md

@@ -0,0 +1,16 @@
+# Setup: the drivers are NOT self-contained
+
+Each driver wraps an official repo + its conda env + HF weights. Install each official repo per its README, then point
+the drivers at it (edit the path constants at the top of the file, or the env vars below).
+
+| method | official repo @ commit | weights (HF) | driver | notes |
+|---|---|---|---|---|
+| Pixal3D 1v | TencentARC/Pixal3D @ `cdbb2bb` | `TencentARC/Pixal3D` (single-view `ckpts/*`, `pipeline.json`) | `baselines/pixal3d_ours/batch_pixal3d.py` | copy `mv_common.py`, `mv_proper.py` into the repo root; `PIXAL3D_REPO=<repo>` |
+| Pixal3D 4v | TencentARC/Pixal3D @ **`f7cf384`** ("support multi-view image input", 2026-09-01), unmodified | same HF repo, **`ckpts/*_bf16_mv.safetensors` + `pipeline_mv.json`** (+ NAF upsampler, auto-downloaded) | `baselines/pixal3d_ours/batch_pixal3d_mv.py` | uses upstream `inference_mv.py` exactly; `PIXAL3D_UPSTREAM=<f7cf384 checkout>`, `PIXAL3D_OURS=<dir with mv_common.py>`. Same env as Pixal3D 1v (o_voxel, utils3d wheel per README). |
+| ReconViaGen | GAP-LAB-CUHK-SZ/ReconViaGen @ `f672092` + `baselines/reconviagen_local.diff` | per its README | `baselines/batch_reconviagen.py` | edit `REPO`, `ENV`, `HF` |
+| Amodal3R | Amodal3R official (ReconViaGen env) | per its README | `baselines/batch_amodal3r.py` | edit `AMODAL_ROOT`, `ENV`, `HF` |
+| Hunyuan3D-2mv | Tencent Hunyuan3D-2 (2mv) | `tencent/Hunyuan3D-2mv` | `baselines/batch_hy3d_2mv.py` | `--seed 42 --simplify-faces 40000`; edit `HY_ROOT`, `HF` |
+| Cupid | cupid3d/Cupid @ `10af9b2` | per its README | `baselines/batch_cupid.py` (1v) | multi-view driver pending |
+
+Exact argument lists: `baselines/commands_reference.py` (`cmd_for`). Every driver is skip-existing and takes `--shard i --nshards n`.
+Ours: `ours/` needs the training repo (`Ronaldo-GOAT/bert_simpson: migrator/code/mv-sam3d-for-6d-v2-ssflow/`), the SAM3D env, SS-flow 80k + SLAT 32k checkpoints (README.md).

forgebench/code/baselines/pixal3d_ours/batch_pixal3d.py

@@ -15,7 +15,7 @@ os.environ['OPENCV_IO_ENABLE_OPENEXR'] = '1'
 os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
 os.environ.setdefault("ATTN_BACKEND", "sdpa")
 
-REPO = "/lp-dev/jonghoon/mv-mesh/pixal3d"
+REPO = os.environ.get("PIXAL3D_REPO", "/lp-dev/jonghoon/mv-mesh/pixal3d")  # TencentARC/Pixal3D @ cdbb2bb + mv_common.py, mv_proper.py
 os.chdir(REPO)
 sys.path.insert(0, REPO)
 os.environ["FLEX_GEMM_AUTOTUNE_CACHE_PATH"] = os.path.join(REPO, 'autotune_cache.json')

forgebench/code/baselines/pixal3d_ours/batch_pixal3d.py.pre8v

@@ -1,266 +0,0 @@
-#!/usr/bin/env python
-"""Batch Pixal3D driver: load pipeline ONCE, process an object list.
-
-Usage:
-  python batch_pixal3d.py --selection SEL.json --inputs DIR --out OUTDIR \
-      --views 1|2 [--seed 42] [--limit N] [--resolution 1536]
-
-1v -> single front image; 2v -> front+side mean-pool (inference_mv style).
-Inputs are RGBA crops (alpha = mask), so preprocess_image uses alpha directly
-(no rembg download). Idempotent: existing OUTDIR/<object>.glb is skipped.
-"""
-import os, sys, argparse, json, time, traceback
-
-os.environ['OPENCV_IO_ENABLE_OPENEXR'] = '1'
-os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
-os.environ.setdefault("ATTN_BACKEND", "sdpa")
-
-REPO = "/lp-dev/jonghoon/mv-mesh/pixal3d"
-os.chdir(REPO)
-sys.path.insert(0, REPO)
-os.environ["FLEX_GEMM_AUTOTUNE_CACHE_PATH"] = os.path.join(REPO, 'autotune_cache.json')
-
-import torch
-import numpy as np
-from PIL import Image
-
-import mv_common
-mv_common.patch_rembg_lazy()
-import o_voxel
-import inference as _inf
-# NOTE: 'hack' MV (inference_mv.build_mv_cond_functions) is REMOVED — it projected
-# every view through the front camera (geometrically wrong). Only corrected 'proper' remains.
-from mv_proper import build_mv_cond_functions_proper
-
-
-def export_vertex_colored(mesh, out, pbr_attr_layout, simplify_target=150000):
-    """FAST path: run the AUTHORS' own GPU quadric simplifier (cumesh, via
-    Mesh.simplify -> the same primitive o_voxel.postprocess.to_glb uses for its
-    decimation_target) to lower the res-1536 dual-grid mesh (~3-32M faces) down to
-    ~simplify_target faces, THEN sample the decoder's native per-vertex base_color
-    from the attr volume at the SIMPLIFIED vertices (one trilinear grid_sample) and
-    write a vertex-colored GLB. Skips only the expensive UV-parameterize + 4096
-    texture bake (eval renders vertex colors). Colors stay exact because they are
-    re-sampled from the volume at the new vertex positions (not interpolated).
-    Orientation matches the to_glb path (same Y/Z swap + rot)."""
-    import trimesh
-    if simplify_target and mesh.faces.shape[0] > simplify_target:
-        mesh.simplify(int(simplify_target))            # authors' cumesh quadric decimate
-    va = mesh.query_vertex_attrs()                      # [N, C] trilinear at verts
-    bc = va[:, pbr_attr_layout['base_color']]
-    rgb = (torch.clamp(bc, 0, 1) * 255).to(torch.uint8).cpu().numpy()
-    verts = mesh.vertices.detach().cpu().numpy().astype(np.float64)
-    faces = mesh.faces.detach().cpu().numpy()
-    v1 = verts[:, 2].copy(); v2 = (-verts[:, 1]).copy()
-    verts[:, 1] = v1; verts[:, 2] = v2                  # Y/Z swap (as in to_glb)
-    vc = np.concatenate([rgb, np.full((len(rgb), 1), 255, np.uint8)], axis=1)
-    tm = trimesh.Trimesh(vertices=verts, faces=faces, vertex_colors=vc, process=False)
-    rot = np.array([[-1,0,0,0],[0,0,-1,0],[0,-1,0,0],[0,0,0,1]], dtype=np.float64)
-    tm.apply_transform(rot)
-    tmp = out + ".tmp.glb"; tm.export(tmp); os.replace(tmp, out)
-
-
-def wait_for_vram(min_free_mib=16000, timeout_s=10800, poll_s=20):
-    """Block until the current CUDA device has >= min_free_mib free (after releasing
-    our own transient cache), so the res-1536 sampling spike (~13.5GB) can run without
-    OOMing against co-located sibling jobs sharing the GPU. Our resident model weights
-    are NOT counted as free, so min_free just needs to cover the spike + margin."""
-    import torch, time as _t
-    t0 = _t.time()
-    while True:
-        torch.cuda.empty_cache()
-        free, total = torch.cuda.mem_get_info()
-        free_mib = free / (1024 * 1024)
-        if free_mib >= min_free_mib:
-            return
-        if _t.time() - t0 > timeout_s:
-            print(f"[vram] timeout waiting for {min_free_mib}MiB (free={free_mib:.0f}); proceeding", flush=True)
-            return
-        print(f"[vram] free={free_mib:.0f}MiB < {min_free_mib}MiB, waiting for GPU headroom...", flush=True)
-        _t.sleep(poll_s)
-
-
-def run_one_resilient(*args, retries=6, **kw):
-    """Run one object, retrying on CUDA OOM after clearing cache + waiting for VRAM
-    headroom (co-located sibling jobs release memory between their own objects)."""
-    import torch
-    for attempt in range(retries):
-        try:
-            wait_for_vram()
-            return run_one(*args, **kw)
-        except torch.cuda.OutOfMemoryError:
-            torch.cuda.empty_cache()
-            import time as _t; _t.sleep(15)
-            print(f"[oom] attempt {attempt+1}/{retries} hit CUDA OOM; cleared cache, retrying", flush=True)
-    # last attempt without swallowing
-    wait_for_vram(min_free_mib=18000)
-    return run_one(*args, **kw)
-
-
-def _load_c2w_for_views(renders_dir, obj_name, view_tags):
-    """Load GT camera-to-world (c2w_cv, 4x4) for each view from renders/<obj>_<tag>.npz."""
-    import numpy as _np
-    mats = []
-    for t in view_tags:
-        npz = os.path.join(renders_dir, f"{obj_name}_{t}.npz")
-        z = _np.load(npz)
-        mats.append(_np.asarray(z["c2w_cv"], dtype=_np.float64))
-    return mats
-
-
-def run_one(pipeline, moge, imgs, out, seed, resolution, image_resolution, low_vram,
-            vertex_color=True, mv_mode="proper", side_azimuth=90.0, simplify_target=150000,
-            renders_dir=None, obj_name=None, view_tags=None):
-    outdir = os.path.dirname(os.path.abspath(out))
-    os.makedirs(outdir, exist_ok=True)
-    pre_imgs, tmp_paths = [], []
-    for i, p in enumerate(imgs):
-        img = Image.open(p)          # RGBA -> preprocess uses alpha directly
-        pi = pipeline.preprocess_image(img)
-        pre_imgs.append(pi)
-        tp = os.path.join(outdir, f"_tmp_mv_{i}_{int(time.time()*1000)}.png")
-        pi.save(tp); tmp_paths.append(tp)
-
-    cams = []
-    for tp in tmp_paths:
-        cp = _inf.get_camera_params_wild_moge(tp, moge, device="cuda",
-                                              mesh_scale=1.0, extend_pixel=0,
-                                              image_resolution=image_resolution)
-        cams.append(cp)
-    for tp in tmp_paths:
-        try: os.remove(tp)
-        except OSError: pass
-
-    if len(pre_imgs) > 1:
-        # CORRECTED proper MV: per-view back-projection through each view's REAL
-        # camera, read per-object from GT renders (renders/<obj>_<tag>.npz c2w_cv),
-        # then simple averaging (paper Sec 3.2.3). Fixes the previous zero-elevation
-        # / hard-coded-azimuth-sign rig. 'hack' mode is REMOVED.
-        if mv_mode != "proper":
-            raise ValueError(f"mv_mode={mv_mode!r} removed; only 'proper' is supported")
-        if renders_dir is None or obj_name is None or view_tags is None:
-            raise ValueError("proper MV requires renders_dir, obj_name, view_tags")
-        c2w_list = _load_c2w_for_views(renders_dir, obj_name, view_tags)
-        from mv_proper import real_view_transforms
-        vt = real_view_transforms(c2w_list, cams[0]['distance'], device="cuda")
-        build_mv_cond_functions_proper(pipeline, pre_imgs, cams, view_transforms=vt)
-    # len==1: single view -> pipeline uses its native official get_proj_cond (no patch)
-
-    torch.manual_seed(seed)
-    pipeline_type = f"{resolution if resolution > 0 else (1024 if low_vram else 1536)}_cascade"
-    mesh_list, (shape_slat, tex_slat, res) = pipeline.run(
-        pre_imgs[0], camera_params=cams[0], seed=seed,
-        sparse_structure_sampler_params={"steps": 12, "guidance_strength": 7.5, "guidance_rescale": 0.7, "rescale_t": 5.0},
-        shape_slat_sampler_params={"steps": 12, "guidance_strength": 7.5, "guidance_rescale": 0.5, "rescale_t": 3.0},
-        tex_slat_sampler_params={"steps": 12, "guidance_strength": 1.0, "guidance_rescale": 0.0, "rescale_t": 3.0},
-        preprocess_image=False, return_latent=True, pipeline_type=pipeline_type, max_num_tokens=49152,
-    )
-    mesh = mesh_list[0]
-    if vertex_color:
-        export_vertex_colored(mesh, out, pipeline.pbr_attr_layout, simplify_target=simplify_target)
-        return
-    glb = o_voxel.postprocess.to_glb(
-        vertices=mesh.vertices, faces=mesh.faces, attr_volume=mesh.attrs,
-        coords=mesh.coords, attr_layout=pipeline.pbr_attr_layout,
-        grid_size=res, aabb=[[-0.5, -0.5, -0.5], [0.5, 0.5, 0.5]],
-        decimation_target=1000000, texture_size=4096,
-        remesh=True, remesh_band=1, remesh_project=0, use_tqdm=False,
-    )
-    rot = np.array([[-1,0,0,0],[0,0,-1,0],[0,-1,0,0],[0,0,0,1]], dtype=np.float64)
-    glb.apply_transform(rot)
-    tmp = out + ".tmp.glb"
-    glb.export(tmp, extension_webp=True)
-    os.replace(tmp, out)
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--selection", required=True)
-    ap.add_argument("--inputs", required=True)
-    ap.add_argument("--out", required=True)
-    ap.add_argument("--views", type=int, required=True, choices=[1, 2, 4])
-    ap.add_argument("--seed", type=int, default=42)
-    ap.add_argument("--limit", type=int, default=None)
-    ap.add_argument("--resolution", type=int, default=1536)
-    ap.add_argument("--image_resolution", type=int, default=512)
-    ap.add_argument("--low_vram", action="store_true")
-    ap.add_argument("--to_glb", dest="vertex_color", action="store_false", default=True,
-                    help="use slow textured to_glb export (default: fast vertex-color)")
-    ap.add_argument("--shard", type=int, default=0)
-    ap.add_argument("--nshards", type=int, default=1)
-    ap.add_argument("--reverse", action="store_true",
-                    help="process objects in reverse order (convergent co-located "
-                         "helper against a forward run; skip-existing + atomic write)")
-    ap.add_argument("--mv_mode", choices=["proper"], default="proper",
-                    help="proper=paper-faithful per-view back-projection through REAL "
-                         "per-object GT extrinsics + average ('hack' removed)")
-    ap.add_argument("--renders", default=None,
-                    help="dir with GT renders/<obj>_<view>.npz (c2w_cv); "
-                         "default: <inputs>/../renders")
-    ap.add_argument("--side_azimuth", type=float, default=90.0,
-                    help="azimuth offset (deg) of the side view from front, about up-axis")
-    ap.add_argument("--simplify_target", type=int, default=150000,
-                    help="target face count for the authors' cumesh quadric decimate "
-                         "in the vertex-color export (0=off); ~150k renders/evals fast "
-                         "and avoids the nvdiffrast CUDA-700 crash on the raw dual-grid mesh")
-    args = ap.parse_args()
-
-    with open(args.selection) as f:
-        sel = json.load(f)["selections"]
-    objects = [s["object"] for s in sel]
-    if args.limit:
-        objects = objects[:args.limit]
-    if args.nshards > 1:
-        objects = objects[args.shard::args.nshards]
-    if args.reverse:
-        objects = objects[::-1]
-    outdir = os.path.abspath(args.out)
-    os.makedirs(outdir, exist_ok=True)
-    renders_dir = args.renders or os.path.join(os.path.dirname(os.path.abspath(args.inputs)), "renders")
-    view_tags = {1: ["front"], 2: ["front", "side"],
-                 4: ["front", "side", "back", "oside"]}[args.views]
-
-    jobs = []
-    for name in objects:
-        out = os.path.join(outdir, f"{name}.glb")
-        imgs = [os.path.join(args.inputs, f"{name}_{t}.png") for t in view_tags]
-        jobs.append((name, imgs, out))
-    todo = [j for j in jobs if not os.path.isfile(j[2])]
-    print(f"[pixal] {len(jobs)} obj, {len(jobs)-len(todo)} done, {len(todo)} to run "
-          f"| views={args.views} res={args.resolution}", flush=True)
-
-    pipeline = _inf.init_pipeline(_inf.MODEL_PATH, low_vram=args.low_vram)
-    moge = _inf.load_moge_model(device="cuda")
-
-    n_ok = n_fail = n_skip = 0
-    for i, (name, imgs, out) in enumerate(jobs, 1):
-        t0 = time.time()
-        try:
-            if os.path.isfile(out):
-                n_skip += 1
-                print(f"[{i}/{len(jobs)}] {name} SKIP", flush=True)
-                continue
-            for p in imgs:
-                if not os.path.isfile(p):
-                    raise FileNotFoundError(p)
-            run_one_resilient(pipeline, moge, imgs, out, args.seed, args.resolution,
-                    args.image_resolution, args.low_vram, vertex_color=args.vertex_color,
-                    mv_mode=args.mv_mode, side_azimuth=args.side_azimuth,
-                    simplify_target=args.simplify_target,
-                    renders_dir=renders_dir, obj_name=name, view_tags=view_tags)
-            torch.cuda.empty_cache()
-            n_ok += 1
-            print(f"[{i}/{len(jobs)}] {name} OK {time.time()-t0:.1f}s -> {out}", flush=True)
-        except Exception:
-            n_fail += 1
-            traceback.print_exc()
-            print(f"[{i}/{len(jobs)}] {name} FAIL {time.time()-t0:.1f}s", flush=True)
-        finally:
-            try: torch.cuda.empty_cache()
-            except Exception: pass
-    print(f"BATCH DONE ok={n_ok} fail={n_fail} skip={n_skip} total={len(jobs)}", flush=True)
-    return 1 if n_fail else 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

forgebench/code/baselines/pixal3d_ours/batch_pixal3d_mv.py

@@ -32,8 +32,8 @@ os.environ['OPENCV_IO_ENABLE_OPENEXR'] = '1'
 os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
 os.environ.setdefault("ATTN_BACKEND", "sdpa")
 
-UPSTREAM = "/lp-dev/jonghoon/mv-mesh/.debug_pixal3d_verify/pixal3d_upstream"
-OURREPO = "/lp-dev/jonghoon/mv-mesh/pixal3d"
+UPSTREAM = os.environ.get("PIXAL3D_UPSTREAM", "/lp-dev/jonghoon/mv-mesh/.debug_pixal3d_verify/pixal3d_upstream")  # TencentARC/Pixal3D @ f7cf384 (official MV)
+OURREPO = os.environ.get("PIXAL3D_OURS", "/lp-dev/jonghoon/mv-mesh/pixal3d")  # dir holding mv_common.py
 os.chdir(UPSTREAM)
 sys.path.insert(0, UPSTREAM)
 sys.path.insert(1, OURREPO)          # mv_common only

forgebench/code/baselines/pixal3d_ours/inference_mv.py

@@ -1,178 +0,0 @@
-"""
-EXPERIMENTAL multi-view inference for Pixal3D.
-
-IMPORTANT / HONEST CAVEAT:
-Pixal3D's released `proj` pipeline + weights are architecturally SINGLE-IMAGE.
-There is NO native multi-view inference. This script constructs a multi-view
-variant by the ONLY mechanism the code allows: it runs the DinoV3ProjFeatureExtractor
-on V views (each with its own MoGe-estimated camera), then MEAN-POOLS the projected
-grid features (and global tokens) across views before the sparse coords indexing.
-
-Two known limitations (do not report this as "true" multi-view):
-  1. ProjGrid.forward asserts transform_matrix is None -> every view is projected
-     through the SAME canonical front-view camera. Non-frontal views (back/top/45deg)
-     therefore paint their features onto geometrically wrong grid cells.
-  2. The DiT was trained on ONE view per object, so averaged multi-view features are
-     out-of-distribution; there is no learned view-fusion to exploit.
-
-Usage:
-  python inference_mv.py --images v1.jpg v2.jpg v3.jpg --output out.glb --seed 42
-"""
-import os, argparse, math, time, types
-import torch, numpy as np
-from PIL import Image
-
-os.environ['OPENCV_IO_ENABLE_OPENEXR'] = '1'
-os.environ["PYTORCH_CUDA_ALLOC_CONF"] = "expandable_segments:True"
-os.environ.setdefault("ATTN_BACKEND", "sdpa")
-os.environ["FLEX_GEMM_AUTOTUNE_CACHE_PATH"] = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'autotune_cache.json')
-
-import mv_common
-mv_common.patch_rembg_lazy()
-
-from pixal3d.pipelines import Pixal3DImageTo3DPipeline
-from pixal3d.modules.sparse import SparseTensor
-import o_voxel
-import inference as _inf  # reuse init_pipeline / camera helpers
-
-
-def build_mv_cond_functions(pipeline, images, cams):
-    """Monkeypatch get_proj_cond_ss / get_proj_cond_shape to use V views + mean-pool.
-
-    images: list of V preprocessed PIL images.
-    cams:   list of V dicts {camera_angle_x, distance, mesh_scale}.
-    """
-    device_getter = lambda: pipeline.device
-
-    def _cam_tensors(dev):
-        cax = torch.tensor([c['camera_angle_x'] for c in cams], device=dev)
-        dist = torch.tensor([c['distance'] for c in cams], device=dev)
-        scal = torch.tensor([c.get('mesh_scale', 1.0) for c in cams], device=dev)
-        return cax, dist, scal
-
-    @torch.no_grad()
-    def get_proj_cond_ss(self, image, camera_angle_x=None, distance=None, mesh_scale=None):
-        dev = self.device
-        m = self.image_cond_model_ss
-        if self.low_vram: m.to(dev)
-        cax, dist, scal = _cam_tensors(dev)
-        z_global, z_proj = m(images, camera_angle_x=cax, distance=dist, mesh_scale=scal)  # [V,..],[V,R3,C]
-        if self.low_vram: m.cpu()
-        z_global = z_global.mean(dim=0, keepdim=True)   # [1,tok,C]
-        z_proj = z_proj.mean(dim=0, keepdim=True)        # [1,R3,C]
-        return {
-            'cond': {'global': z_global, 'proj': z_proj},
-            'neg_cond': {'global': torch.zeros_like(z_global), 'proj': torch.zeros_like(z_proj)},
-        }
-
-    @torch.no_grad()
-    def get_proj_cond_shape(self, image_cond_model, image, coords,
-                            camera_angle_x=None, distance=None, mesh_scale=None,
-                            grid_resolution_override=None):
-        dev = self.device
-        if self.low_vram: image_cond_model.to(dev)
-        orig_grid_res = image_cond_model.grid_resolution
-        if grid_resolution_override is not None and grid_resolution_override != orig_grid_res:
-            image_cond_model.grid_resolution = grid_resolution_override
-            image_cond_model.proj_grid = image_cond_model.proj_grid.__class__(
-                grid_resolution=grid_resolution_override,
-                image_resolution=image_cond_model.proj_grid.image_resolution,
-            ).to(dev)
-        cax, dist, scal = _cam_tensors(dev)
-        z_global, z_proj = image_cond_model(images, camera_angle_x=cax, distance=dist, mesh_scale=scal)
-        # mean-pool over views
-        z_global = z_global.mean(dim=0, keepdim=True)     # [1,tok,C]
-        z_proj = z_proj.mean(dim=0, keepdim=True)          # [1,R3,C]
-        grid_res = image_cond_model.grid_resolution
-        z_proj_grid = z_proj.reshape(1, grid_res, grid_res, grid_res, -1)
-        bi = coords[:, 0].long(); xc = coords[:, 1].long(); yc = coords[:, 2].long(); zc = coords[:, 3].long()
-        z_proj_sparse = z_proj_grid[bi, xc, yc, zc]
-        z_proj_st = SparseTensor(feats=z_proj_sparse, coords=coords)
-        if grid_resolution_override is not None and grid_resolution_override != orig_grid_res:
-            image_cond_model.grid_resolution = orig_grid_res
-            image_cond_model.proj_grid = image_cond_model.proj_grid.__class__(
-                grid_resolution=orig_grid_res,
-                image_resolution=image_cond_model.proj_grid.image_resolution,
-            ).to(dev)
-        if self.low_vram: image_cond_model.cpu()
-        return {
-            'cond': {'global': z_global, 'proj': z_proj_st},
-            'neg_cond': {'global': torch.zeros_like(z_global),
-                         'proj': SparseTensor(feats=torch.zeros_like(z_proj_sparse), coords=coords)},
-        }
-
-    pipeline.get_proj_cond_ss = types.MethodType(get_proj_cond_ss, pipeline)
-    pipeline.get_proj_cond_shape = types.MethodType(get_proj_cond_shape, pipeline)
-
-
-def main():
-    ap = argparse.ArgumentParser()
-    ap.add_argument("--images", nargs="+", required=True)
-    ap.add_argument("--masks", nargs="+", default=None, help="optional per-view masks (aligned with --images)")
-    ap.add_argument("--output", required=True)
-    ap.add_argument("--seed", type=int, default=42)
-    ap.add_argument("--low_vram", action="store_true")
-    ap.add_argument("--resolution", type=int, default=-1)
-    ap.add_argument("--image_resolution", type=int, default=512)
-    args = ap.parse_args()
-
-    pipeline = _inf.init_pipeline(_inf.MODEL_PATH, low_vram=args.low_vram)
-
-    # preprocess each view (bg removal + crop) and estimate per-view camera via MoGe
-    pre_imgs, tmp_paths = [], []
-    outdir = os.path.dirname(os.path.abspath(args.output))
-    os.makedirs(outdir, exist_ok=True)
-    masks = args.masks if args.masks else [None] * len(args.images)
-    assert len(masks) == len(args.images), "masks must align with images"
-    for i, p in enumerate(args.images):
-        img = mv_common.load_rgba(p, masks[i])
-        pi = pipeline.preprocess_image(img)
-        pre_imgs.append(pi)
-        tp = os.path.join(outdir, f"_tmp_mv_{i}_{int(time.time()*1000)}.png")
-        pi.save(tp); tmp_paths.append(tp)
-
-    print("[MoGe-2] estimating per-view cameras...")
-    moge = _inf.load_moge_model(device="cuda")
-    cams = []
-    for tp in tmp_paths:
-        cp = _inf.get_camera_params_wild_moge(tp, moge, device="cuda",
-                                              mesh_scale=1.0, extend_pixel=0,
-                                              image_resolution=args.image_resolution)
-        cams.append(cp)
-        print(f"   view cam: angle_x={cp['camera_angle_x']:.4f} dist={cp['distance']:.4f}")
-    moge.cpu(); del moge; torch.cuda.empty_cache()
-    for tp in tmp_paths:
-        try: os.remove(tp)
-        except OSError: pass
-
-    build_mv_cond_functions(pipeline, pre_imgs, cams)
-
-    seed = args.seed
-    torch.manual_seed(seed)
-    pipeline_type = f"{args.resolution if args.resolution > 0 else (1024 if args.low_vram else 1536)}_cascade"
-    print(f"[MV-Inference] {len(pre_imgs)} views, pipeline_type={pipeline_type}")
-    # camera_params passed to run() are ignored by patched cond fns; supply view-0's as placeholder
-    mesh_list, (shape_slat, tex_slat, res) = pipeline.run(
-        pre_imgs[0], camera_params=cams[0], seed=seed,
-        sparse_structure_sampler_params={"steps": 12, "guidance_strength": 7.5, "guidance_rescale": 0.7, "rescale_t": 5.0},
-        shape_slat_sampler_params={"steps": 12, "guidance_strength": 7.5, "guidance_rescale": 0.5, "rescale_t": 3.0},
-        tex_slat_sampler_params={"steps": 12, "guidance_strength": 1.0, "guidance_rescale": 0.0, "rescale_t": 3.0},
-        preprocess_image=False, return_latent=True, pipeline_type=pipeline_type, max_num_tokens=49152,
-    )
-    mesh = mesh_list[0]
-    print("[MV-Inference] extracting GLB...")
-    glb = o_voxel.postprocess.to_glb(
-        vertices=mesh.vertices, faces=mesh.faces, attr_volume=mesh.attrs,
-        coords=mesh.coords, attr_layout=pipeline.pbr_attr_layout,
-        grid_size=res, aabb=[[-0.5, -0.5, -0.5], [0.5, 0.5, 0.5]],
-        decimation_target=1000000, texture_size=4096,
-        remesh=True, remesh_band=1, remesh_project=0, use_tqdm=True,
-    )
-    rot = np.array([[-1,0,0,0],[0,0,-1,0],[0,-1,0,0],[0,0,0,1]], dtype=np.float64)
-    glb.apply_transform(rot)
-    glb.export(args.output, extension_webp=True)
-    print(f"[Done] GLB saved to: {args.output}")
-
-
-if __name__ == "__main__":
-    main()