Scene-Extrapolation Benchmark Suite

Executive summary & key findings

Per-scene 3D Gaussian Splatting is superb at interpolating densely observed captures — and brittle exactly where it is asked to invent: extrapolative held-out views with big disocclusion holes, dynamic moving content, and long-horizon chained / loop-closing trajectories that accumulate drift. Diffusion-based generative NVS replaces 3D-GS in precisely those regimes. Our method — Wan2.1-VACE-14B warp+inpaint warps the input to each target pose, then lets video diffusion fill the disocclusions hole-free while staying geometrically anchored to the warped scaffold.

Every number below is read verbatim off the scored runs (eval50, Kubric-4D clean-GT, NVIDIA, SpatialVID, LH-DL3DV, WorldScore) and SLURM sacct timing — nothing is interpolated. "Ours" = vace14b; best-in-column values are noted as such.

Bottom line Warp+inpaint VACE-14B delivers hole-free, geometry-anchored novel views that stay on-trajectory where 3D-GS fails — best FID and consistency, 2nd on WorldScore — at a mid-pack inference cost (~6–8× the fastest feed-forward models), with dynamic movers still hard for the whole field.

Sources: quantitative.html tables, runs/dyn_kubric4d_metrics/*.json (per-method aggregate + by-bin), and infer_time.json (SLURM sacct s/clip). Ratios computed from long-horizon secs_per_clip. Where Ours has no value for a metric (e.g. exact-pose reconstruction PSNR), it is stated as not-applicable rather than estimated.

Coverage matrix — methods × benchmarks

Computed honestly from disk (metrics JSONs & generated mp4 outputs under runs/). n = clips scored; gen = mp4 outputs produced.

20 methods × 6 benchmarks = 120 cells  |  ✓ scored: 58   🔄 running: 5   ⏭/— pending+N/A: 57 (pending 34, N/A 23)

Quantitative Benchmarks

1 · Static novel-view extrapolation — DL3DV (50 held-out clips)

2 · Dynamic-scene novel-view synthesis

2a · NVIDIA Dynamic Scenes SECONDARY

2b · Kubric-4D (synthetic dynamic — summary) PRIMARY STANDARD GCD/AnyView

2c · SpatialVID (in-the-wild dynamic)

5 · Average inference time — wall-clock per clip (SLURM accounting)

3 · Kubric-4D angle-binned difficulty curve — per-bin table

4 · Long-horizon geometric stability

4a · Drift / loop-closure (GVS-style, DL3DV)

4c · Long-horizon finetune — vace14b_ft_lh (ft@4000) vs base vace14b

4b · WorldScore (ICCV 2025 Stanford world-gen benchmark)

Why explicit caching, not learned memory

The static warp+inpaint recipe that wins the static benchmarks cannot represent movers on revisit: it can only re-project a stale earlier observation, so a moving object is smeared or frozen when the camera returns. The obvious "just learn a memory" fix — a learned key/value attention memory (MemAttn) spliced into the generator — destabilises training and collapses to colored noise. What actually works is an explicit, geometry-grounded rolling 4D cache: it stores per-time point clouds and re-renders the mover from the correct time, beating the static warp on the true mover region.

All deltas are on the true-mover region only (background id 0 and >35%-area static planes excluded). An earlier prototype reported a spurious +34 dB because a mask bug counted the Kubric background as a mover; the corrected mover mask gives the honest single-digit-dB win above.

1 · Static warp ghosts movers; the rolling cache renders them clean

2 · Learned KV-memory (MemAttn) is a NO-GO — it collapses to colored noise

Memory / revisit — a 4th axis (NEW)

Headline result — return-degradation across all three scene types CAMPAIGN HEADLINE

M1 · multi_visit — revisit-consistency

M1a · Kubric-4D clean-GT PRIMARY — revisit a fixed observed pose (no warp confound)

M1b · DL3DV static — revisit a fixed observed pose 3×

M1c · SpatialVID in-the-wild dynamic — revisit

M2 · moving_back — return-fidelity

M2a · Kubric-4D clean-GT PRIMARY — move away into unseen space, then return

M2b · DL3DV static — move away, then return to the observed pose

M2c · SpatialVID in-the-wild dynamic — move-back

M3 · Kubric-4D return-fidelity by away-distance bin PRIMARY clean-GT

Fair common-N comparison

Kubric-4D (synthetic dynamic NVS, perfect-GT anchor)

Exact-pose methods are scored with reference pixel metrics; our model and TrajCrafter generate freely (do not follow exact 81 poses) so they have only pose-free metrics. We therefore form two common-N groups.

Pending (still scoring / too few clips, excluded from the intersection so they do not shrink N_common): Shape-of-Motion (N=15), Voyager (N=5).

NVIDIA Dynamic Scenes (real dynamic, mono diagonal protocol)

Same split as Kubric-4D: pixel metrics over exact-pose methods; pose-free metrics (MEt3R, COLMAP-ATE) include our model and TrajCrafter.

Pending (still scoring / too few clips, excluded from the intersection so they do not shrink N_common): TrajCrafter (N=14).

SpatialVid (in-the-wild dynamic camera-trajectory set)

Our model follows exact poses on a subset of clips, so it appears in the pixel-metric group on those common clips; the pose-free group spans all methods including TrajCrafter.

DL3DV eval50 (50-clip static-scene extrapolation)

All methods follow exact poses except TrajCrafter; the pixel group covers exact-pose methods (incl. Ours), the pose-free group adds TrajCrafter.

Long-Horizon DL3DV (extended-trajectory generation)

Reference pixels exist only on the GT-backed extrapolation clips (psnr_extrapGT), so the pixel group intersects over those clips; the pose-free group uses MEt3R / drift-ATE / collision over all clips. All scored methods follow exact poses here.

Pending (still scoring / too few clips, excluded from the intersection so they do not shrink N_common): VACE-14B-ft (Ours, LH-ft) (N=13).

All aggregates in every table above are recomputed on the identical intersected clip set for that group — no method is averaged over clips another method in the group did not see.