acceptodds
Under review as a conference paper at ICLR 2027

REVISABLE ONLINE 3D SCENE GRAPH GENERATION

Abstract

Online 3D semantic scene graph generation must assign frame-level detections to persistent object nodes while observations are partial and noisy. Once made, these assignments and the resulting relation endpoints are usually fixed, so early false merges and splits persist throughout processing. We introduce Revisable 3D Scene Graph Generation (ReSGG), an online setting that allows historical observation-to-node assignments to change as new views provide evidence. We propose SGReviser, a training-free back end for existing scene graph front ends. SGReviser detects local association conflicts and compares joint and separate surface reconstructions using leave-one-frame-out geometric evidence. It converts the resulting signed preferences into an observation partition with a constrained correlation-clustering resolver, abstaining when the evidence is inconclusive. Because relation records retain their observation-level endpoints, graph edges can be repaired after repartitioning without re-predicting predicates. On 3DSSG, SGReviser improves relation Recall@1 by 16.4 points for FROSS and 13.0 points for NoPA; on ReplicaSSG, it improves the corresponding scores by 4.6 and 5.7 points. The method operates online with modest latency and requires no task-specific training, demonstrating that revising historical associations can substantially improve online 3D scene graph quality.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Online 3D scene graph generation, multi-view geometric consistency, held-out reconstruction

Reviews

Among:
Shape:
1234this paper, Bottom 27%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.00 over 3 reviews, above 27% of the others.
Reviewer_GpZ3OpenReview ↗
Rating
3
Confidence
3
Informativeness
3
Presentation
2
Soundness
3
Read review
Paper summary

The paper proposed a method called Revisable 3D Scene Graph Generation (ReSGG). It's an plug-and-play module that allows historical observation-to-node assignments to change online as new views provide evidence. It is evaluated on 3DSSG and ReplicaSSG, Recall@1 improves by 16.4 and 13.0 percentage points over FROSS and NoPA on 3DSSG, and by 4.6 and 5.7 points on ReplicaSSG, with mean per-frame latency between 20.57 and 26.78 ms

Critical strengths
  1. The paper try to solve an important and common problem in online 3D scene graph generation: early false merges and splits can corrupt subsequent object fusion and relation aggregation. By combining historical observation regrouping with relation endpoint repair, the authors propose a well-motivated mechanism for correcting these errors during online processing.
  2. On 3DSSG, SGReviser improves relation Recall@1 from 28.4% to 44.8% for FROSS and from 53.3% to 66.3% for NoPA, with consistent gains on ReplicaSSG. The ablations also support the contribution: removing inter-fragment evidence reduces relation Recall@1 from 44.8% to 32.9%.
Critical weaknesses
  1. The revision criterion relies on depth and geometric alignment, which may limit its robustness under noisy real-world observations. The main experiments use rendered depth and benchmark poses. The ORB-SLAM3 ablation is useful, but it retains rendered depth and therefore does not establish robustness to sensor noise and pose errors occurring together.
  2. Long-term scalability remains insufficiently evaluated. Historical observations and relation records accumulate throughout processing, and revision uses the complete histories of participating nodes. Further analysis of how revision cost and correction delay scale with history length would strengthen the evidence for sustained online operation.
Questions for authors
  1. How sensitive is the revision criterion to depth noise?
  2. How do revision time and write-back delay scale with the length of the observation history?
2 comments
AuthorsOpenReview ↗

Response to GpZ3: Depth Noise and History Scaling

We thank the reviewer for the positive assessment and the focused questions. A revised PDF with changes highlighted is uploaded.

W1 / Q1. Sensitivity to depth noise. We agree that the ORB-SLAM3 ablation isolates pose error and does not cover sensor noise. Three design choices limit noise effects, though they do not remove them:

  1. The comparison is paired. Both hypotheses are rendered against the same held-out depth. On pixels covered by both, noise affects them identically and largely cancels in ΔAB\Delta_{AB}. Only noise on the pixels added by pooling can change the sign.
  2. Boundary pixels are excluded. Sensor noise concentrates at depth discontinuities, and the bb-pixel margin removes these pixels.
  3. Weak evidence leads to abstention. Noise that shrinks ∣Δ∣\lvert\Delta\rvert below η\eta or removes testable pixels yields abstention rather than a decision (Prop. C.13). Abstention adds no cross-fragment evidence, so it cannot by itself cause a merge or split (Prop. C.18(vi), Cor. C.20).

Noise larger than δ=5\delta=5 cm can still turn depth agreement into free-space contradiction and reverse the sign (App. L). We add (a) a sweep with depth-dependent noise σ(z)=kz2\sigma(z)=kz^2, 5% pixel dropout, and boundary jitter; (b) raw 3RScan sensor depth (*.depth.pgm), which the benchmark replaces with rendered depth; and (c) sensor depth with ORB-SLAM3 poses:

Input (FROSS + SGReviser, 3DSSG)Rel. (%; Δ\Delta vs. FROSS in pp)sRel. (%)Preference precision (%)Abstention rate (%)
Rendered depth (paper)44.8 (+16.4)28.195.134.9
k=0.0012k=0.001243.2 (+16.1)27.493.237.3
k=0.0025k=0.002541.5 (+15.2)26.191.543.8
k=0.005k=0.00535.3 (+12.2)23.582.149.2
Sensor depth (benchmark poses)40.4 (+16.8)25.986.347.1
Sensor depth + ORB-SLAM330.6 (+11.3)19.681.453.7

We also test a depth-adaptive tolerance δ(z)=δ0+3σ(z)\delta(z)=\delta_0+3\sigma(z) under the above noise conditions at k=0.005k=0.005 and δ0=0.05\delta_0=0.05 m. Fixed →\to adaptive tolerance gives Rel. 35.3 →\to 38.9, sRel. 23.5 →\to 24.2, preference precision 82.1 →\to 85.6, and abstention 49.2 →\to 45.2.

W2 / Q2. Scaling with history length. One revision has four cost components:

  • Voxelization of pooled raw points is linear in history length. This also applies to the conflict trigger, which rebuilds the node surface without the current frame. Because leave-one-frame-out only removes one frame's contribution, we now maintain per-voxel, per-frame point counts incrementally, which makes this step independent of history length: voxelization time drops by 20.1% relative to full rebuilding.
  • Rendering, the dominant cost (5.05 of 22.42 ms/frame, Tab. 24), is linear in voxelized points. It is therefore bounded by the object's surface area and saturates for repeated views of the same surface.
  • Comparisons scale as O(Kcheck∣G∣2)O(K_{check}\lvert\mathcal{G}\rvert^2) in the number of fragments. Fragments are temporal paths (Lemma C.10), so new ones arise mainly when an object is revisited after a gap or matching fails, not with every frame.
  • The resolver is O(n2log⁡n)O(n^2\log n) in the region size nn (Prop. C.22).

Regions larger than BsyncB_{sync} run in the background, so long histories mainly appear as write-back delay: 1.5% of revisions run in the background, with a median delay of 3 frames [IQR 1, 6] over 157 sequences (Tab. 25).

(i) Cost by region size (all revision events):

∣St∣\lvert S_t\rvert (observations)Execution count (including recomputations)Revision time (ms)Write-back delay (frames)Fragment count
≤90\leq 90 (sync)≈101,900\approx101{,}90021.1–6
91–200≈1543\approx154376.3311
>200>200≈735\approx735634.22120

(ii) Long-run test. We concatenate each test trajectory in alternating forward and reverse order to LL times its original length. All copies of a source frame are held out together, so a replayed frame never explains its own original. We also test a bounded-history variant that keeps at most Hmax=250H_{max}=250 observations per node, selected by coverage gain:

LLVariantP95 latency (ms)Max pending jobsWrite-back P95 (frames)
1Full history27.20529
5Full history36.71667
5Bounded history32.41054

Foreground P95 latency is the median of per-sequence P95 values.

Bounded history and backlog management were future work in Sec. 5. The revised paper reports these results and their limits.

We thank the reviewer again and are happy to answer any further questions.

Thanks for the response and the updates about depth noise and history scaling. My concerns have been resolved. I will keep my score because it's already positive.

Reviewer_bj3UOpenReview ↗
Rating
1
Confidence
3
Informativeness
2
Presentation
1
Soundness
2
Read review
Paper summary

Online 3D Semantic Scene Graph Generation is the process of incrementally constructing and updating a graph-based representation of a 3D environment as new sensor observations become available. Errors introduced during the early stages, such as object detection, data association, or object grouping, can propagate to subsequent stages, resulting in inconsistencies in the final scene graph. This paper introduces a sequential algorithm that detects and resolves conflicts in the generated scene graph, thereby mitigating error propagation. Unlike previous methods, which typically lack mechanisms to correct errors introduced during the initial stages of graph generation, the proposed approach revises erroneous associations to improve the consistency of the final scene graph.

Critical strengths
  1. SGReviser keeps observation-level provenance, re-examines the stored history of affected nodes, and regroups observations, so it can fix both false merges and false splits unlike existing front ends.
  2. Plugged into FROSS and NoPA without retraining, relation Recall@1 improves by 16.4 and 13.0 points on 3DSSG and by 4.6 and 5.7 points on ReplicaSSG. Streaming recall improves in all four comparisons.
  3. The leave-one-frame-out comparison avoids the failures of point-overlap tests. Excluding the evaluation frame, discounting occluded pixels, and abstaining under weak evidence are all sensible design choices.z
Critical weaknesses
  1. The leave-one-frame-out joint-vs-separate comparison (Sec. 3.2) is explained only with definitions and formulas. A worked example on real data would help. It should show the pooled and separate surfaces, the held-out depth, and the scores. Fig. 1 and Fig. 2 do not show the evidence on real scenes.
  2. The method stores all observations and relation records for the whole sequence. Memory grows with sequence length. The resolver’s pairwise storage grows quadratically with scope size. The main text gives no memory figures, total time, or tail latency. Please report them.
  3. Main results use benchmark poses and depth rendered from ground-truth meshes. Only one ORB-SLAM3 experiment tests robustness. Please evaluate on real RGB-D sequences with estimated poses and sensor depth.
  4. PUF-Gaussian, an online model, scores higher than FROSS + SGReviser (46.0 vs. 44.8) at lower latency. Please add a same-protocol comparison with PUF, or PUF combined with SGReviser. Please also explain why the offline variant (31.8) is far below the online one (44.8).
  5. The paper relies heavily on notation. Key details are in the appendix. More figures and examples would help. Qualitative before/after scene graphs and failure cases would be useful.
Questions for authors
  1. Present a trade-off between online and offline versions is needed in terms of memory and time.
  2. Please present the results for studies mentioned in weaknesses.
2 comments
AuthorsOpenReview ↗

Response to bj3U (1/2): Worked Example, Memory, and Latency

We thank the reviewer for the constructive feedback. A revised PDF with changes highlighted is uploaded.

W1. Worked example on real data. We agree that Fig. 1/2 are schematic and Fig. 5 has no scores. Fig. 3 in the revised manuscript (p. 6; (a) same table, (b) adjacent chairs) uses real 3DSSG data and shows the separate and pooled surfaces, the held-out depth, the residual map, and scores for (i) two fragments of one table and (ii) two adjacent chairs. Both reconstructions exclude all observations from the held-out frame.

The table gives single-frame scores for target A in Fig. 3, listed as separate (A only) / pooled (A+B).

Case / held-out frameccν\nuϕ\phiqq
Table / 4950.8843 / 0.88700.9436 / 0.92790.0000 / 0.00000.9130 / 0.9070
Chairs / 4300.9929 / 0.99680.7676 / 0.57640.0006 / 0.00040.8653 / 0.7301

Following Eq. (12), we average score differences over valid observations within each valid held-out frame, then over valid frames, to obtain Δ\Delta.

CaseValid held-out frames (count)Multi-frame gain Δ\DeltaGeometric preference ρ\rho
Same table495, 500 (2)-0.0009510
Adjacent chairs425, 430, 433 (3)-0.189757-1

The near-zero gain for the table shows that even the same object can yield abstention when evidence is insufficient. For the chairs, pooling increases projections outside the target box, lowering the score and supporting separation.

W2. Memory, total time, and tail latency. The main text now summarizes overhead and long-run results; detailed runtime breakdowns, tail-latency statistics, and single-sequence memory analysis remain in App. J.2/K:

  • Runtime (Tab. 24): 22.42 ms/frame. Held-out rendering takes 5.05 ms, fragments 2.50 ms, the resolver 2.30 ms, and write-back 1.35 ms.
  • Tail latency (Tab. 25): median p95 of 27.20 ms [IQR 23.40, 39.40] over 157 sequences. 1.5% of revisions run in the background, with a median write-back delay of 3 frames.
  • Memory (Fig. 7): host 2.66 vs. 2.21 GB; peak GPU 1.90 vs. 1.30 GB.

The reviewer is right that storage grows. Stored history grows linearly with the sequence, and resolver storage is quadratic in the region size. Synchronous regions are capped at Bsync=90B_{sync}=90 (≤4,005\leq 4{,}005 weights), but background regions contain full node histories and grow with sequence length. We report this over all original sequences and add a bounded-history variant that selects observations by coverage gain, retaining at most 250 per node:

StatisticMedianP95Max
Background region size (observations)1525131,501
Resolver memory (MB)1.38.272.2
Host memory growth (MB / 1,000 frames), full / bounded203 / 170410 / 342662 / 547
Total time per sequence (s)45.7108220

We address W3–W5 and Q1 in Part 2.

AuthorsOpenReview ↗

Response to bj3U (2/2): Real RGB-D, Comparisons, and Offline Revision

Continuing our response to Reviewer bj3U, we address W3–W5 and Q1 below.

W3. Real RGB-D input. 3RScan provides raw sensor depth, which the benchmark protocol does not use. We run it jointly with ORB-SLAM3 poses (Rel. / sRel., %):

Front endOriginal association (Rel. / sRel., %)+ SGReviser (Rel. / sRel., %)
FROSS19.3 / 14.730.6 / 19.6
NoPA44.5 / 13.552.8 / 17.8

W4. PUF comparison. The PUF-Gaussian row is copied from its paper, which uses a different front end, hardware, and timing protocol. Its 15 ms latency covers its full pipeline on its own hardware, so neither accuracy nor latency is paired. SGReviser is a back end: PUF improves fusion when an observation arrives but never moves past observations, so the two are complementary. We reproduce PUF on our hardware and protocol:

Method (3DSSG, same protocol)Rel. (%)sRel. (%)Mean foreground time (ms/frame)
PUF (reproduced, relation prior enabled)43.926.310.4
PUF + SGReviser (same relation prior)60.132.726.3

Why offline (31.8) < online (44.8). The offline variant is not a global re-solve or upper bound. It applies the same local revision once, after the last frame, to the seeds recorded during an uncorrected run (App. F). Three effects explain the gap:

  1. Error compounding. Online corrections immediately change later associations. Offline, an uncorrected false merge keeps attracting observations that belong elsewhere, and errors this induces in nodes that were never seeded lie outside every offline region.
  2. Harder regions. Offline regions hold end-of-sequence histories and merge transitively, so they are larger and contain more erroneous matching chains (Prop. C.16).
  3. No re-ranking. Offline never re-selects candidates on the final graph.

We quantify this and add a global offline re-solve over all final nodes:

VariantMedian region size (observations)Consistent regions (%)Rel. (%)
Online6374.344.8
Offline (seeded)26454.731.8
Offline (global)1,56313.437.2

W5. Presentation. The revised PDF (i) adds a running example through Sec. 2–3 using Fig. 3 in the revised manuscript (p. 6), (ii) keeps only main-path symbols in the main text, and (iii) summarizes the failure cases in the main text.

Q1. Online vs. offline trade-off (3DSSG, all sequences):

MethodRel. (%)sRel. (%)Mean / P95 latency (ms)Post-input time (s)Median per-sequence peak host / GPU memory (GB)
FROSS28.421.38.91 / 11.6–2.3 / 1.2
Offline31.821.312.71 / 13.63.72.8 / 2.1
Online44.828.122.42 / 27.203.12.6 / 1.8

We hope these additions address the concerns and would appreciate a reconsideration of the score.

Reviewer_rE3qOpenReview ↗
Rating
2
Confidence
3
Informativeness
2
Presentation
2
Soundness
2
Read review
Paper summary

This paper proposes Revisable 3D Scene Graph Generation (ReSGG), a framework that allows historical observation-to-node assignments to be revised during online 3D scene graph construction. The authors introduce SGReviser, a training-free module that detects association conflicts and employs leave-one-frame-out geometric evidence to compare joint and separate surface reconstructions. A constrained correlation-clustering strategy is then used to correct erroneous object associations, while the affected relation edges are updated without re-predicting relation predicates. The proposed method is integrated with existing online 3D scene graph generation frameworks, including FROSS and NoPA. Experiments on 3DSSG and ReplicaSSG demonstrate improvements in object and relation recall, suggesting the effectiveness of historical association revision for online 3D scene graph generation.

Critical strengths

The paper addresses an important issue in online 3D scene graph generation by introducing a revisable association mechanism that can correct historical object assignment errors. The proposed SGReviser framework is well motivated and integrates geometric consistency evaluation with constrained correlation clustering to revise object associations and update relation edges without additional task-specific training. Its plug-and-play design allows integration with existing frameworks such as FROSS and NoPA. Experimental results demonstrate substantial improvements in object and relation recall across the 3DSSG and ReplicaSSG datasets. Furthermore, the ablation studies provide useful evidence for the effectiveness of the proposed components, while the clear methodology and well-organized presentation make the paper easy to follow.

Critical weaknesses

Although the proposed method achieves substantial performance improvements in the experiments, several limitations of its core association revision mechanism warrant further investigation. First, the method relies on predefined geometric conflict conditions to trigger historical association revision. However, some false splits may not exhibit obvious geometric inconsistencies, potentially preventing such errors from being detected and corrected in a timely manner. Second, the authors primarily determine object identity by comparing the geometric consistency of joint and separate surface reconstructions. However, for objects with similar geometric shapes, close spatial proximity, or severe occlusions, such geometric evidence may be ambiguous, potentially affecting the accuracy and reliability of association revision. Furthermore, the method converts continuous geometric consistency differences into discrete association preferences, thereby discarding information about the relative strength of the evidence. The use of a greedy clustering strategy may also limit its ability to resolve complex association errors. Regarding experimental evaluation, the paper adopts a simplified 3DSSG setting with only 20 object categories and 7 predicate categories, without evaluating the method under the original setting of 160 object categories and 26 predicate categories. Consequently, the current results are insufficient to fully demonstrate its generalization capability across a larger category space and more complex 3D semantic relationships. Finally, the experimental results reveal a noticeable trade-off between the extent of association revision and online processing efficiency, while the computational overhead, background task accumulation, and end-to-end real-time performance during long-term operation remain insufficiently evaluated.

Questions for authors
  1. Can the authors evaluate the proposed method on the full 3DSSG category setting to demonstrate its effectiveness on more diverse objects and complex 3D spatial relationships?
  2. Since SGReviser only updates object associations and relation endpoints, how does the framework handle incorrect or missing relation predicates predicted by the 2D front end?
  3. Can the authors further evaluate the robustness of the proposed method under dynamic scenes, inaccurate camera poses, and noisy real-world depth observations?
  4. Can the authors provide a more comprehensive analysis of the computational overhead, memory consumption, and long-term scalability of the proposed online revision mechanism?
  5. How does the proposed method handle duplicate detections or overlapping observations that may violate the same-frame cannot-link constraint? If the authors can adequately address the aforementioned issues, I would be willing to raise my score.
2 comments
AuthorsOpenReview ↗

Response to rE3q (1/2): Triggers, Evidence, and Optimization

We thank the reviewer for the detailed review. A revised PDF with changes highlighted is uploaded.

W1. False splits without geometric inconsistency. Both triggers (geometric and same-frame) mainly target false merges. False splits are repaired through the revision scope. Every trigger adds the top-KcandK_{cand} front-end alternatives, which need not be recently visible and are not filtered by the front end's acceptance threshold (App. E). A once-rejected node can thus enter the region, and the resolver (starting from singletons) can join the two. False-split pair errors drop by 42.8%/37.5% (FROSS/NoPA, Tab. 11), and Kcand=1K_{cand}=1 costs 10.9 Rel. points. We agree that a split whose nodes never meet a conflict is missed or corrected late (App. L). We add a proximity trigger that reopens two nodes whose held-out surfaces lie within δ\delta in the current frame. On 3DSSG, relative to the original version: false-split pair errors -9.3%, Rel. +3.5 points, sRel. +1.2 points, foreground latency +1.4 ms/frame.

W2. Similar, nearby, or occluded objects. The test does not compare shapes; it asks whether pooling explains a held-out depth map at known poses. For two identical chairs in different places, pooling puts the other chair outside the target box (lower ν\nu) or in observed free space (higher ϕ\phi), which supports separation (Cor. C.9, case 3). The hard cases are occlusion (case 4) and touching objects. The test abstains when evidence is insufficient; surface interference from contact can also cause errors. Abstention adds no cross-fragment evidence, so it cannot by itself cause a merge or split (Prop. C.18(vi), Cor. C.20), but such errors may then remain. At a matched abstention rate, held-out evidence beats point overlap by 15.6/15.7 points in merge/separation precision (App. H.2). Neighbor points inside boxes are a main error source (GT masks: +4.9 Rel., Tab. 3). We report event share, error rate, and abstention overall and on three difficult subsets:

GroupEvent share (%)Error rate (%)Abstention rate (%)
Overall (App. H)–3.234.9
Same category, different instances402.228.2
Nearby instances (gap <5<5 cm)233.842.4
Low visible fraction (<25%<25\%)313.548.3

All values are means over three runs. Event shares use all events as the denominator; error and abstention rates use events within each group. Subsets may overlap.

W3. Discrete preferences and greedy clustering. Lifting only the sign is deliberate. ΔAB\Delta_{AB} is uncalibrated, and normalization bounds each comparison's influence to one (Prop. C.15). The greedy resolver is exact whenever a feasible zero-loss partition exists (Thm. C.19), which holds in 74.3% of regions. We compare sign lifting with greedy clustering, magnitude lifting, and exact ILP:

VariantRel. (%)sRel. (%)Latency (ms)
Sign + greedy (default)44.828.122.42
Magnitude lifting, Δ/c\Delta/c (original abstention rule)45.227.724.49
Exact ILP (all regions with ∣St∣≤90\lvert S_t\rvert\le 90)43.726.327.52

Here cc is the mean ∣Δ∣\lvert\Delta\rvert over non-abstaining comparisons on the validation set. On inconsistent regions within the synchronous size limit, the greedy loss is 2.2% above the ILP optimum.

We address W4/Q1 and Q2–Q5 in Part 2.

AuthorsOpenReview ↗

Response to rE3q (2/2): Evaluation, Robustness, and Overhead

Continuing our response to Reviewer rE3q, we address W4/Q1 and Q2–Q5 below.

W4 / Q1. Full 3DSSG (160/26). We followed the FROSS/NoPA protocol (20/7), which also underlies all external rows in Tab. 1. SGReviser's evidence and resolver (Eqs. 7–17) use no category information, so the label space mainly affects the front end. The full vocabulary, however, contains many small objects that may fall below our testability thresholds, so we report results by object size:

Method (160/26)Rel. (%)Obj. (%)Pred. (%)Rel. (small / large objects, %)
FROSS12.535.121.310.3 / 17.8
+ SGReviser29.747.539.422.4 / 36.1

Taking the mean object volume as 100%, the small/large subsets have volumes below 20%/above 50% of that mean; overall Rel. uses the full set.

Q2. Incorrect or missing predicates. SGReviser does not correct predicate predictions. It changes which records vote for each edge: splitting a false merge removes another object's votes, and merging a false split pools divided votes. In 29.6% of newly recovered triplets both endpoints were already matched in the baseline (App. G.2), suggesting that part of the gain comes from edge re-aggregation. Most remaining error lies in the front end: even with GT association, FROSS reaches only 53.5 Rel. (Tab. 1). SGReviser is thus complementary to predicate-side methods.

Q3. Robustness. With ORB-SLAM3 poses, SGReviser adds 19.1 Rel. points over FROSS (Tab. 18). We further compare rendered and sensor depth with benchmark and online-estimated poses. Arrows denote FROSS →\to FROSS + SGReviser on the same inputs:

DepthPosesRel. (%; Δ\Delta in pp)sRel. (%; Δ\Delta in pp)
RenderedBenchmark28.4 →\to 44.8 (+16.4)21.3 →\to 28.1 (+6.8)
RenderedORB-SLAM322.1 →\to 41.2 (+19.1)17.1 →\to 26.9 (+9.8)
SensorBenchmark23.6 →\to 40.4 (+16.8)18.5 →\to 25.9 (+7.4)
SensorORB-SLAM319.3 →\to 30.6 (+11.3)14.7 →\to 19.6 (+4.9)

Dynamic scenes violate our static premise. A moved object may cause free-space conflicts and be split into old and new nodes, and the stale node may persist without temporal decay; we state this as a limitation.

Q4. Overhead.

  1. Runtime and memory. On 3DSSG, FROSS + SGReviser/FROSS take 22.42/8.91 ms/frame of mean foreground time (Tab. 24). On the selected 1,281-frame sequence, peak host memory is 2.66/2.21 GB and peak GPU memory is 1.90/1.30 GB (Fig. 7).
  2. Revision scope. Initial regions contain only the histories of the triggered node and at most three alternatives. Regions above 90 observations run in the background, but stored history still grows with the sequence.
  3. Long-run test. To assess long-run computation and storage costs, we compare A: original sequences with full history; B: repeated visits extending each sequence to five times its original length, with full history; and C: the same input as B, retaining at most Hmax=250H_{max}=250 observations per node by coverage gain.
MetricA: original, full historyB: 5×5\times length, full historyC: same as B, Hmax=250H_{max}=250
Rel. (%)44.846.242.7
Median per-sequence peak host memory (GB)2.63.63.1
Host memory growth (MB / 1,000 frames), whole-run average203212140

These tests cover finite runs in static scenes; we do not extrapolate to indefinite operation.

Q5. Duplicate detections. Acknowledged in Sec. 2 and Fig. 8(d). Same-frame conflicts are a reliable false-merge signal: trigger precision is 94.5%/95.1% for FROSS/NoPA (Tab. 12). Distinct instances in the same frame still support separation when contact or occlusion weakens geometric evidence. Duplicate detections can cause false splits: Fig. 8(d) shows two highly overlapping detections of the same chair being kept apart. Even counting new errors, false-split pair errors still fall by 42.8%/37.5% overall, showing a net benefit despite this limitation.

We hope these address the concerns and would be grateful for a reconsideration of the score.

Comments on the paper

1 comment

Dear reviewers,

As the rebuttal period is coming to an end, I kindly remind you to check the authors' responses. If you have not yet responded, please indicate whether your concerns have been adequately addressed. Many thanks!

Best, AC

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.