Skip to content

OpenSpatial: A Principled Data Engine for Empowering Spatial Intelligence

Conference: ECCV 2026
Paper: ECCV official page
Code: https://github.com/VINHYU/OpenSpatial
Area: Multimodal VLM
Keywords: spatial intelligence, data engine, oriented 3D box, vision-language model, data synthesis

TL;DR

OpenSpatial turns "how to build spatial training data" into an open, reproducible data engine: it uses world-coordinate oriented 3D bounding boxes (OBBs) as a unified primitive, produces scene-level boxes through two complementary routes (human annotation and automated 3D lifting), converts them into an object–frame index via projection, filtering and mask refinement, and finally enumerates scene graphs into single-view and multi-view QA, yielding the 3M-sample OpenSpatial-3M dataset that lifts several open-source VLMs by 14.1% on average (up to 19%) across BLINK, AllAngles, VSI and MMSI while largely preserving general multimodal ability.

Background & Motivation

Multimodal LLMs have moved from image-text alignment to instruction following: they write convincing descriptions and handle complex cross-modal questions. Their spatial competence, however, lags clearly behind their semantic expressiveness — a model can say "there is a cup on the table" yet often fails to measure the camera-to-cup distance, hold two views consistent, or build a usable spatial cognitive map. Those are precisely the capabilities embodied decision-making and robotic manipulation depend on. This gap has motivated a wave of "spatialized" VLMs (adding 3D encoders or depth/localization tools) and a set of dedicated benchmarks, and the numbers do move. But the gains are very uneven across tasks and scenes: a method that jumps on some viewpoint-centric benchmark barely moves on metric or scene-level ones. That unevenness itself points to a diagnosis: the bottleneck is not model architecture alone, but the foundations of spatial generalization.

That foundation is data. Current data-centric spatial work faces two systemic obstacles. The first is limited diversity: existing spatial VQA corpora are heavily concentrated on indoor scenes, fixed viewpoints and a small set of object categories, so models score high on benchmarks while lacking the versatility real environments demand — the authors call this "spatial myopia". The second, and more damaging, is closure: the data in mainstream work comes from opaque, proprietary pipelines, and only a fixed, preprocessed dataset (sometimes a subset) is released while the generative engine stays private. As a result the community cannot run controlled ablations to answer "which data design actually drives spatial capability", cannot consistently scale data to its own scenarios, and cannot treat data production as a debuggable system — every line of work becomes an isolated silo.

This paper's angle is to reframe the problem from "release a bigger dataset" to "release reusable data infrastructure". OpenSpatial is therefore not a corpus but an engine: it exposes every link of the spatial supervision chain (geometric representation, annotation source, quality filtering, task synthesis), supports both maximum-accuracy human annotation and automatic "3D lifting" of in-the-wild web video into 3D supervision, and thereby makes scale, task coverage and data quality independently adjustable and attributable. Core idea: use world-coordinate oriented 3D boxes as the geometric primitive that runs through the entire pipeline and aligns 2D visual cues with 3D metric properties; on top of it, make the annotation source pluggable (human or automatic lifting), the quality checks switchable (frustum and occupancy filtering) and the task coverage enumerable (scene-graph-driven dual-branch QA), turning spatial data production into a transparent, scalable, ablation-friendly system.

Method

Overall Architecture

OpenSpatial addresses the whole chain of "where spatial supervision comes from, how to keep it clean, and how to cover enough tasks". Its input is multi-view images or video keyframes (with poses) and its output is paired image-question-answer samples. The pipeline is hierarchical: first obtain scene-level oriented 3D boxes, then lower scene-level annotations to the frame level as usable object attributes, and finally synthesize tasks on top of those attributes. Each level deliberately emits a canonical intermediate representation, so swapping the annotation source upstream or the task family downstream requires no rewrite of the middle stages.

Concretely, the first step produces scene-level oriented 3D boxes for all visible objects along two complementary routes: human annotation for accuracy (object-level 3D labeling following the EmbodiedScan protocol) and automated 3D lifting for scale — per-view object recognition and instance mask extraction from keyframes, 3D association and merging of instances, and convex-hull fitting into oriented boxes. Both routes are normalized to the same canonical format: a scene mesh plus a set of object-aligned 3D boxes. The second step projects these scene-level boxes into every frame, applies frustum culling and a depth-based occupancy check, adds mask refinement and semantic tags, and distills everything into a cross-frame-consistent object–frame index (3D/2D boxes, masks, partial point clouds, tags, metric flags). The third step opens two annotation branches on that index: single-view QA builds on the per-frame scene graph and pairs it with a marked image that highlights the queried object to remove referential ambiguity; multi-view QA samples view pairs that share a subset of 3D boxes and builds a unified cross-view scene graph for consistency-type questions. The final product is OpenSpatial-3M: 3M samples covering five capability families (Spatial Measurement, Spatial Relationship, Camera Perception, Multi-view Consistency and Scene-Aware Reasoning), subdivided into 19 sub-tasks and organized as a progressive curriculum that bridges egocentric observations with stable world-coordinate understanding.

%%{init: {'flowchart': {'rankSpacing': 24, 'nodeSpacing': 28, 'padding': 6, 'wrappingWidth': 400}}}%%
flowchart TD
    A["multi-view images / video keyframes"] --> B["3D-box-centric unified representation<br/>world-coordinate OBB · viewpoint-invariant"]
    B --> C["human annotation<br/>EmbodiedScan protocol"]
    B --> D["automated 3D lifting<br/>recognize → mask → 3D merge → hull"]
    C --> E["attribute-centric object–frame index<br/>projection → frustum/occupancy filter → mask"]
    D --> E
    E --> F["scene-graph-driven dual-branch QA<br/>single-view anchors + multi-view pairs"]
    F --> G["OpenSpatial-3M<br/>3M samples · 5 families · 19 sub-tasks"]

Orthogonal to this main chain, the engine adds a throughput layer: most components run in parallel; consecutive stages communicate through message queues so that one stage infers a batch while the previous stage processes the next (asynchronous pipelining); and tasks sharing intermediate features (for example several tasks reusing the same frame) trigger an automatic reuse mechanism that avoids recomputation. The paper reports speed-ups of several-fold up to more than tenfold (annotated as ×3.1 / ×2.7 / ×1.5 / ×12 in Fig. 6 — ⚠️ the main text does not map each factor to a specific component; refer to the original paper).

Key Designs

1. A 3D-box-centric unified representation: giving every object a viewpoint-invariant world-coordinate anchor

Spatial understanding needs a stable 3D scene state — objects keep the same position, size, orientation and mutual relations under viewpoint change and occlusion. 2D labels cannot deliver this: the same object's projected box changes shape, size and location across frames, so cross-frame association degenerates into appearance matching. Dense 3D reconstruction (meshes, voxels) is geometrically exact but expensive to capture and annotate, heavy in format, and hard to extend to in-the-wild sources. OpenSpatial takes oriented bounding boxes as the middle ground. Each object is parameterized as \((x, y, z, x_l, y_l, z_l, r, p, y)\) — the center in world coordinates, the side lengths along the three axes, and the Roll/Pitch/Yaw orientation — all defined in a global world coordinate system with a Z-up convention.

The value of this choice lies not in precision but in the fact that it encodes exactly the minimum 3D structure spatial reasoning needs: depth, extent and orientation are all present, which suffices for metric, topological and directional relations, while the representation stays compact, batch-friendly and far cheaper to annotate than dense reconstruction. More importantly it is viewpoint-invariant — an object has exactly one 3D anchor across frames, so "are these two detections the same object" becomes pure geometry rather than appearance matching, and consistent projection, occlusion filtering and box-conditioned mask refinement all line up as a consequence. The ablation is direct: on the same 200k ScanNet data, replacing the representation with a point-cloud-centric one drops BLINK from 60.3 to 57.2 and CV-3D from 89.9 to 83.7 — a partial point cloud only covers the visible part of an object, and the missing back side makes measurement-type QA wrong at the source.

2. Automated 3D lifting: upgrading in-the-wild video into usable 3D boxes, extending data sources beyond indoor scans

Human 3D annotation is accurate but slow and hard to scale, and it depends on already-annotated indoor datasets (ScanNet, Matterport3D, ARKitScenes and others aggregated by EmbodiedScan), so the number of scenes is inherently capped and the environments skew heavily indoor — exactly the data-source root of "spatial myopia". To break that ceiling the engine adds a second annotation route: starting from video keyframes or multi-view images, it runs per-view object recognition with Gemini and instance mask extraction with SAM; then it associates and merges instances in 3D space; finally it fits a convex hull over the merged points to produce the oriented box. The procedure needs no human 3D labeling at all, so it can consume uncurated outdoor web video. The paper quantifies it on 30 randomly sampled ScanNet scenes against EmbodiedScan annotations: before filtering, precision 76.3% and recall 67.9%; after filtering, precision 80.2% and recall 67.5% — precision rises while recall barely moves (a 0.4 drop), indicating the filter mainly removes wrong boxes. The authors state explicitly that they prioritize precision over recall here, because a wrong box in downstream VLM training directly teaches the model a false geometric relation, which is far more dangerous than missing one object.

The significance of this route is not "one more data source" but decoupling scale and diversity from the human annotation budget. The paper validates it in isolation: training Qwen2.5-VL on 200k lifting-only samples raises BLINK from 55.3 to 62.2, 3DSR from 49.0 to 54.3, CV-3D from 73.8 to 87.9 and RealWorldQA from 68.1 to 71.8 — all four go up, and by comfortable margins. Automatically lifted boxes are less precise than human ones, yet as training supervision they are already effective.

3. Attribute-centric object–frame index: projection, dual filtering and mask refinement turn scene-level boxes into trustworthy frame-level supervision

Obtaining scene-level 3D boxes is not the same as obtaining usable training data, because supervision ultimately lands on "one image plus one sentence". Naively projecting 3D boxes into every frame produces two kinds of dirty samples: objects entirely outside the camera frustum, and objects that do project into the frame but are heavily occluded, leaving only a corner visible. The latter is especially harmful — the model is asked to report that object's size or distance from a frame in which it cannot be seen, so the only thing it can learn is to hallucinate. OpenSpatial therefore applies two filters and then a refinement step. The first is frustum culling. The second is a depth-based occupancy check: pixels inside the projected 2D box are back-projected into world coordinates using the depth map and the camera intrinsics/extrinsics to form a local point cloud, and the volumetric occupancy of those points inside the 3D box is computed; boxes with occupancy below a threshold are discarded. This step separates "projects inside the box" from "genuinely belongs to this box in 3D" and is the discriminator for occlusion and truncation.

Boxes that pass filtering continue to yield supervision through the same point-cloud pixel path: those pixels first give coarse masks, which SAM then refines into fine-grained 2D instance masks tightly aligned with object appearance. This is not only about prettier masks — it also makes the engine robust to semantically duplicated automatic annotations: when lifting fails to associate instances and emits two near-identical objects, the masks serve as reliable instance indicators that turn an ambiguous reference into pixel-level evidence, and can be further converted into boxes or keypoints as spatial prompts. Finally, all extracted attributes (masks, 2D/3D boxes, partial point clouds, object tags) are consolidated into a structured cross-frame index, and every object receives a metric flag indicating whether its box reflects real-world scale; when false, all measurement-related QA is skipped rather than emitting noisy supervision. The value of this filtering stands out in the ablation: with the same 3D-box-centric representation, removing the filter drops BLINK from 60.3 to 56.6, VSI from 41.7 to 32.1 and CV-3D from 89.9 to 78.2 — below even the point-cloud-centric variant on those three metrics. In other words, a large part of the benefit of the box-centric representation is earned by the filter; the two form an inseparable pair.

4. Scene-graph-driven dual-branch QA synthesis: explicit anchors for single views, shared-box pairing for multi-view

With a clean index in hand, the remaining problem is task coverage. Synthesizing data around a single "look and answer about position" template yields the "spatial myopia" the authors describe — high scores on one distribution, failure elsewhere. OpenSpatial instead enumerates objects, attributes and inter-object relations programmatically through scene graphs, spreading the question space across measurement, relations, camera/viewpoint changes, multi-view consistency and scene-level reasoning, and splitting it into two branches with different supervision formats. The single-view branch builds a structured scene graph per frame and renders a visually marked image that highlights the queried object as an explicit anchor. This targets referential ambiguity: scenes often contain several semantically similar instances (two or three identical chairs), and plain text cannot single one out, so a wrong answer reflects confusion about which object is meant rather than a spatial failure; the marked image turns "it is this one" into a pixel-level fact. On top of it the engine generates object–object and object–environment relational queries (left, right, front, behind, occlusion), attribute comparisons (size, relative depth) and context-dependent reasoning grounded in the current view.

The multi-view branch targets cross-view spatial reasoning, and its difficulty is pairing: a view pair must overlap enough for a human (and a model) to establish correspondence through jointly visible objects, yet if the two views nearly coincide the viewpoint variation that makes the reasoning meaningful disappears. Here the 3D boxes are again the solution — because they are anchored in the world coordinate system they are natural viewpoint-invariant references, so "which detections in two frames are the same object" follows directly from geometry. The engine therefore samples only view pairs that share a subset of 3D boxes, satisfying contextual overlap and viewpoint diversity at once. For each pair it builds a unified multi-view scene graph, merges instances across views, and generates questions about re-identification under perspective shift, camera-change reasoning and, where permitted, consistency or measurement checks. This supervision forces the model to maintain a persistent 3D representation across views instead of treating each image as an independent scene — which is also the main reason it opens gaps above 10 points on multi-image and multi-view benchmarks such as BLINK, AllAngles and MMSI.

Loss & Training

The engine introduces no new training objective; all experiments use standard supervised fine-tuning (SFT). The protocol follows VST: one epoch, 32 NVIDIA GPUs, global batch size 128, the AdamW optimizer, a base learning rate of \(5\times10^{-5}\), and a smaller decoupled learning rate of \(5\times10^{-6}\) for the vision encoder. For data mixture, a 1:1 strategy preserves general multimodal ability while improving spatial intelligence: half the general multimodal data from LLaVA-OneVision and half from OpenSpatial-3M. The main experiments additionally mix in SenseNova-800K to cover spatial reasoning dimensions the corpus does not fully address.

Key Experimental Results

Main Results

All models are evaluated under an identical codebase with their native system prompts. The spatial side uses eight benchmarks (BLINK, AllAngles, ERQA, VSI, 3DSR, MMSI, CVBench-3D, RealWorldQA) with 3D-Avg as the spatial average. Every OpenSpatial model improves on its own same-size baseline:

Base model 3D-Avg BLINK AllAngles VSI 3DSR MMSI CV-3D
InternVL2.5-8B 51.6 54.9 48.9 39.3 51.0 28.6 79.9
+ OpenSpatial data 59.3 (+7.7) 63.5 (+8.6) 58.3 (+9.4) 56.7 (+17.6) 52.0 (+1.0) 38.7 (+10.1) 93.8 (+13.9)
InternVL3-8B 53.2 55.7 50.5 38.7 52.7 30.9 86.0
+ OpenSpatial data 59.8 (+6.6) 66.0 (+10.3) 58.3 (+7.8) 57.4 (+18.7) 53.5 (+0.8) 38.6 (+7.7) 93.7 (+7.7)
Qwen2.5-VL-7B 50.0 55.3 50.1 36.0 49.0 26.5 73.8
+ OpenSpatial data 59.5 (+9.5) 65.9 (+10.6) 58.4 (+8.3) 56.7 (+20.7) 53.2 (+4.2) 39.6 (+13.1) 92.5 (+18.4)
Qwen3-VL-8B 56.7 66.1 49.5 55.6 52.8 28.1 90.8
+ OpenSpatial data 62.1 (+5.4) 68.2 (+2.1) 59.8 (+10.3) 61.6 (+6.0) 56.2 (+3.4) 41.9 (+13.8) 94.0 (+3.2)
VST-7B-SFT (prior spatial model) 57.9 62.1 49.5 55.3 53.3 33.3 94.8
Gemini-2.5-Pro (proprietary reference) 62.4 70.6 61.3 48.4 57.6 36.9 91.3

Scale-matched comparison against open-source spatial datasets (all trained on Qwen2.5-VL under one protocol, 500k–800k each):

Data source Size MAD Std. Dev. BLINK AllAngles MMSI CV-3D
Cambrian-S 590k −6.0 5.4 54.1 (−10.1) 48.6 (−5.3) 29.2 (−7.1) 75.3 (−17.9)
SenseNova-SI 800k −6.5 7.0 59.7 (−4.5) 47.5 (−6.4) 36.3 69.0 (−24.2)
VST 500k −2.8 3.9 61.4 (−2.8) 50.7 (−3.2) 32.4 (−3.9) 93.2
OpenSpatial (subset) 500k −2.5 4.4 64.2 53.9 34.7 (−1.6) 91.8 (−1.4)

Here "−" is the gap to the best result in that column. MAD (mean deviation) closer to 0 with a smaller standard deviation means the data behaves more evenly across benchmarks. OpenSpatial and VST are both "well-rounded" (MAD −2.5 / −2.8), whereas Cambrian-S and SenseNova-SI fluctuate much more (MAD −6.0 / −6.5) with localized strength on VSI and MMSI — the paper reads the two families as complementary and therefore mixes SenseNova-800K into the main training mixture.

Ablation Study

Config BLINK AllAngles VSI CV-3D Note
Qwen2.5-VL-7B (no spatial data) 55.3 50.1 36.0 73.8 baseline
+ point-cloud-centric 57.2 49.7 37.2 83.7 AllAngles even falls below the baseline
+ 3D-box-centric 60.3 53.2 41.7 89.9 full design
+ 3D-box-centric (no filter) 56.6 47.0 32.1 78.2 most metrics below the point-cloud variant

All reproduced on ScanNet with roughly 200k samples per set. The quality and effectiveness of 3D lifting are validated separately:

Config Metric Value Note
Lifting, before filter Precision / Recall 76.3% / 67.9% 30 random ScanNet scenes vs. EmbodiedScan
Lifting, after filter Precision / Recall 80.2% / 67.5% precision +3.9, recall −0.4; precision prioritized
w/o lifting data (200k) BLINK / AllAngles / ERQA / VSI 64.3 / 56.2 / 41.8 / 55.2 human-annotation sources only
w/ lifting data (200k) BLINK / AllAngles / ERQA / VSI 65.9 / 58.4 / 41.8 / 56.7 ERQA flat, the other three rise

Scaling ablations (data volume, model size, data source):

Axis Config 3D-Avg Key columns
Data volume 20% → 40% → 60% → 80% → 100% 57.6 → 58.5 → 58.6 → 59.2 → 59.7 BLINK 64.9→65.9; MMSI 34.7→39.6; VSI 51.8→56.7
Model size Qwen2.5-VL 3B / 7B / 32B 56.1 / 59.7 / 61.3 BLINK 61.0 / 65.9 / 68.2; AllAngles 53.0 / 58.4 / 63.3
Data source 200k baseline → lifting data added — BLINK 55.3→62.2; 3DSR 49.0→54.3; CV-3D 73.8→87.9; RealWorldQA 68.1→71.8

Key Findings

  • The representation and the filter are one unit, not two choices. Switching to a 3D-box-centric representation alone lifts CV-3D from 73.8 to 89.9, but removing the occupancy filter on that same representation drops CV-3D back to 78.2 and BLINK to 56.6 (below the point-cloud variant's 57.2). The paper's qualitative explanation: a box for an occluded object still projects "inside the frame", and without filtering the model learns to fabricate geometry for objects it cannot see — the single most convincing ablation in the paper.
  • 3D lifting is a genuinely effective data source, not just a cheap substitute for human labels. At an identical 200k budget, adding lifting data alone raises BLINK by 1.6, AllAngles by 2.2 and VSI by 1.5; training from scratch on lifting-only data improves all four measured metrics over the baseline (CV-3D by as much as 14.1). The bottleneck is scene and viewpoint coverage, not absolute annotation precision.
  • The spatial gains scale with data volume but with diminishing returns. 3D-Avg rises monotonically from 57.6 at 20% to 59.7 at 100%, while individual benchmarks are not strictly monotonic (ERQA peaks at 42.1 at 40% but is 41.8 at full scale; RealWorldQA is 71.1 at 40% and 68.3 at full scale). The authors draw a rather sober conclusion: further gains in spatial intelligence require exponentially larger datasets. The model-size trend is much cleaner — 3B→7B→32B rises monotonically on almost every column, showing that larger capacity internalizes the supplied supervision more fully.
  • Tasks are complementary rather than redundant. The per-task heatmap shows different tasks leaving different footprints: Spatial Measurement (SM) mainly lifts metric-heavy evaluations, while Camera Perception (CP) mainly strengthens the reading of extrinsics and ego-motion and yields the largest gains on benchmarks requiring precise viewpoint awareness. In the incremental composition experiment the overall average curve rises steadily (with occasional local plateaus or small dips attributed to distribution shift or gradient interference in multi-task optimization), indicating that task diversity does mitigate the limits of single-task learning.
  • General ability is largely preserved, but not losslessly. MMB and MMMU hold up broadly while MMStar drops (InternVL3-8B −3.9, InternVL2.5-8B −0.8), so the 1:1 mixture mitigates rather than eliminates the distribution shift introduced by spatial data.
  • Base-model compatibility varies, and scene coverage remains the weak spot. Qwen3-VL-8B pairs best with this data (3D-Avg 62.1, close to Gemini-2.5-Pro's 62.4), which the paper attributes to the stronger visual perception of its SigLIP vision encoder. Gains on desktop-level and outdoor scenes are markedly smaller, which the authors acknowledge stems from the mainly indoor data distribution.

Highlights & Insights

  • Data quality is turned into a switchable, attributable knob rather than a slogan. The most valuable contribution is not the "3M" number but that questions like "how much do we lose by removing the occupancy filter" become answerable, because every stage of the pipeline is explicit and replaceable. This "dataset as infrastructure" framing transfers to any data-driven field: expose annotation source, quality validation and task synthesis as independently ablatable modules instead of shipping one packed corpus.
  • Defining multi-view pairs by shared 3D boxes turns pairing into a geometric problem. View-pair selection is usually stated as a vague heuristic (how much overlap is enough?); here, because every object has a world-coordinate anchor, it becomes "share at least a set of 3D boxes", satisfying overlap and diversity at once. The idea transfers to any task needing paired cross-view supervision (ego-exo video, multi-camera driving data).
  • Trading recall for precision deliberately. After filtering, precision reaches 80.2% while recall barely moves, showing that the filter removes mostly wrong boxes; for a downstream task where one wrong box teaches one false geometric relation, the trade is in the right direction, and the paper states it and verifies it rather than tuning silently.
  • The metric flag is a small design worth noting. Attaching a boolean "is this box at true scale" to every object and skipping all measurement QA when it is false uses a tiny mechanism to prevent an entire class of systematic noise. The same trick transfers to depth estimation, size regression, or any synthetic pipeline that depends on absolute scale.
  • Naming the failure mode matters. The failure the paper keeps emphasizing is not "the model cannot answer", but "it scores high and does not transfer". This argues for evaluating spatial ability by balance too (the paper quantifies it with MAD and standard deviation) rather than by the best single-benchmark score.

Limitations & Future Work

  • The authors acknowledge three limitations: gains on desktop-level and outdoor scenes remain small because the data still skews indoor; further volume scaling demands exponentially more data with diminishing returns; and although filtering raises lifting precision to 80.2%, roughly one fifth of boxes entering training are still wrong.
  • A design trade-off worth noting: human annotation and automatic lifting are treated as parallel routes rather than a cascade, so lifting errors cannot be corrected by human labels; similarly, the metric flag only gates measurement tasks, while relational and reasoning tasks still absorb wrong spatial relations from erroneous boxes.
  • Multi-view pairing relies on "sharing 3D boxes" as a sufficient condition, so genuine correspondences with little view overlap (the same object under a large viewpoint change) are discarded outright — one plausible reason there is still headroom on AllAngles-style benchmarks.
  • Experimentally, the main results compare against each base model's released weights, without a strong baseline that keeps training on general data of the same volume, so "the spatial gain comes from data content rather than merely from extra training compute" remains open; mixing in SenseNova-800K also muddies attribution in the main table (the subset comparison in Tab. 2 isolates it, but the main table does not).
  • Possible improvements: turn lifting and human annotation into a cascade of "automatic candidates → human/model correction" to spend annotation budget on the remaining 20% noise; extend the metric flag into a continuous confidence and weight relational tasks by it; and target desktop and outdoor scenes explicitly to close the distribution gap.
  • vs VST: VST also builds spatial data from EmbodiedScan, and this paper follows VST's training protocol, but VST releases a fixed dataset whereas this work releases a pluggable engine and adds camera perception, multi-view consistency and scene-aware reasoning. At matched scale (500k) the two are comparably balanced (MAD −2.5 vs −2.8); OpenSpatial is stronger on BLINK and AllAngles (64.2 / 53.9 vs 61.4 / 50.7) while VST is stronger on CV-3D (93.2 vs 91.8).
  • vs SenseNova-SI: SenseNova-SI follows a larger (800k) closed-dataset route and is very strong on specific benchmarks such as VSI (58.8), but its cross-benchmark balance is poor (MAD −6.5, standard deviation 7.0). This paper does not compete head-on; it judges the two data families complementary and mixes SenseNova-800K into training — a pragmatic choice that also shows an open engine and strong point-wise data are not substitutes.
  • vs SpatialVLM / SpatialRGPT: these pioneered large-scale synthesized spatial VQA, but their supervision rests mainly on 2D detection boxes and depth estimation without object-level 3D structure in world coordinates; this paper's OBB primitive makes cross-frame association and occlusion filtering a geometric computation, which is what they cannot do for multi-view consistency tasks.
  • vs Spatial-MLLM / VLM-3R / 3DThinker: those works inject geometric priors through external 3D encoders or reconstruction modules, i.e. architectural change; this paper works purely on the data side and reaches 3D-Avg 59–62 with SFT alone on general VLMs, suggesting a good part of the "spatial deficit" can be fixed with data rather than architecture — whether the two routes stack is an open question.
  • vs Cambrian-S: also about spatial supervision, but its data distribution is more skewed — strong on VSI (57.0) yet clearly weak on CV-3D (75.3) — a useful contrast to this paper's balance-oriented stance.

Rating

  • Novelty: ⭐⭐⭐⭐ The 3D oriented box as the engine's primitive and the use of shared 3D boxes to define multi-view pairs are distinctive, and "release the engine, not the dataset" hits the right target; the individual components (SAM masks, scene-graph QA enumeration) are mostly a systematic combination of existing techniques.
  • Experimental Thoroughness: ⭐⭐⭐⭐⭐ Eight spatial plus three general benchmarks, four base models, and seven families of ablations (representation, filtering, lifting, data volume, model size, data source, task diversity) with a MAD/standard-deviation balance analysis — very solid for a data-engine paper.
  • Writing Quality: ⭐⭐⭐⭐ The design principles are clear and motivation lines up with the ablations; deductions for table-number mismatches with the text (the text cites Tab. 6 where it means Tab. 7), Fig. 6's efficiency factors not being mapped to components, and a few baseline name typos (e.g. "Cambrain-S" in Tab. 2).
  • Value: ⭐⭐⭐⭐⭐ An open engine plus a 3M dataset on HuggingFace directly lowers the barrier to producing spatial supervision, and its modularity makes "which data design works" a reproducible question — infrastructure-level value for embodied AI and robotics follow-up work.