acceptodds
Under review as a conference paper at ICLR 2027

DMap: Efficient Dense Matching and Bundle Adjustment for Accurate 3D reconstruction

66 views

Abstract

Deep 3D models provide remarkable global robustness, but direct regression acts as an information bottleneck that discards sub-pixel geometric constraints. Conversely, classical optimization achieves sub-pixel precision but fails to scale to dense correspondences and relies on heuristic, discrete track building. We present DMap, a framework that bridges frozen foundation representations with efficient dense optimization. First, DMap extracts dense multi-view correspondences from the latent features of a frozen multi-view backbone, amortizing per-view representation computation so that per-pair decoding reduces to lightweight coarse feature matching and local convolutional refinement. Second, we resolve the efficiency bottleneck of non-linear optimization by formulating dense bundle adjustment on a regular view graph over regular 2D pixel grids rather than irregular point graphs. By anchoring tracks to source rays, dense warps enter the optimization directly without keypoint quantization or track merging, and millions of depth variables are marginalized in parallel within milliseconds. DMap achieves state-of-the-art accuracy across unordered (ETH3D, Texture-Poor) and sequential (TUM RGB-D, ETH3D-SLAM) benchmarks, improving relative-pose AUC@1◦ to 88.6% on ETH3D while running 13–17× faster than existing dense optimization baselines.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
3D reconstruction, dense matching, bundle adjustment, multi-view geometry, geometric optimization, visual representation learning

Reviews

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

The paper proposes a robust 3D reconstruction pipeline that relies on combining a frozen 3D foundation model (by default VGGT-Ω b) with lightweight dense matching and efficient bundle adjustment. The backbone supplies initial camera and depth estimates, while a hierarchical matching decoder with a looped transformer adapter produces multi-view features reused across image pairs. This shared computation reduces the marginal cost per pair to coarse descriptor matching, local coordinate decoding, and convolutional refinement.

The convolutional refiner, based on the RoMa v2 architecture, uses local image features to iteratively adjust the coarse correspondence map, producing more precise sub-pixel matches. The camera poses and per-pixel depths are jointly refined through dense bundle adjustment over regular pixel grids, regularized by confidence-weighted log-depth priors. This is done efficiently with GPU fused kernels that compute residuals and derivatives in one pass, reducing the normal equations via the Schur complement in parallel. The solver supports self-calibration of focal length, principal point, and radial distortion, with a robust Cauchy loss for reprojection errors.

Critical strengths

Main arguments for acceptance:

  • DMap combines an elegant matching architecture with efficient dense bundle adjustment, achieving strong accuracy and speed through shared multi-view features and GPU-friendly optimization. -Flexible camera modeling, particularly effective rolling-shutter correction, adds practical value, while extensive ablations substantiate the contributions of its main components.

Paper's strengths in more detail:

  1. The main idea is not revolutionary, but it is elegant and interesting. In particular, the hierarchical matching decoder with a looped transformer adapter producing multi-view features that can be reused across image pairs, and hence significantly reducing the computational cost, nicely illustrated in Figure 3 and Figure 4.

  2. DMap obtains more accurate results and is faster than recent SOTA methods (AMB3R, BLASt3R, VidMap). The high precision and the high speed they obtain are due to the usage of a regular pixel grid and fixed view graph enabling aligned memory access and the construction of the optimization problem memory-bound with fused GPU kernels. This yields a dense BA with millions of observations at a low cost.

  3. DMap supports self-calibration of focal length, principal point, and radial distortion, as well as rotation-based rolling-shutter correction. Explicitly accounting for rolling shutter is a valuable strength for visual SLAM, where camera motion during image acquisition can introduce geometric errors. Table 3 demonstrates this benefit on TUM RGB-D: rolling-shutter correction reduces average trajectory error from 2.3 to 1.1 cm in the calibrated setting and from 2.2 to 1.0 cm in the uncalibrated setting. Moreover, the uncalibrated rolling-shutter variant slightly outperforms its calibrated counterpart, showing that accurate reconstruction does not require supplied camera intrinsics.

  4. The paper provides extensive and informative ablation studies including backbone choices (Table 5), multi-view context and the number of adapter iterations (Figure 6), and the separate contributions of matching and optimization (Table 8). The component-swap experiment, which evaluates DMap and BLASt3R matchers with both BA backends under a common initialization is also interesting showing that each component independently improves accuracy and that their combination performs best.

Critical weaknesses

I did not identify any critical weaknesses that would support rejection, my main concerns being:

  1. The technical novelty is somewhat limited. The contribution lies primarily in the integration and efficient implementation of ideas with established precedents, including dense source-anchored BA, Schur elimination, depth priors, and hierarchical matching. Nevertheless, reusing foundation-model features for multi-view matching and combining them with an efficient dense BA solver constitute meaningful technical contributions.

  2. The experimental presentation lacks clarity about which DMap configuration is used in each evaluation. Table 1 distinguishes fast and HR variants, Table 3 separates global- and rolling-shutter settings, and the reconstruction experiments distinguish direct BA from fusion, whereas other tables simply report “DMap (ours).” Please explicitly specifying the settings for each result and consistently including a shared reference configuration across applicable tables. This would make the comparisons easier to interpret and help isolate the contribution of each component.

  3. The paper’s organization could be significantly improved. Depth fusion appears to contribute significantly to reconstruction quality, yet its description is confined to the appendix. I think part of section C should be in the main paper. Space could be recovered by moving Figures 3, 4 and/or 6 to the appendix, keeping only their main findings in the text. Also some tables can be made more compact.

Questions for authors
  1. It would be good to clarify how DMap chunking maintains consistency across long sequences and provide a scaling study of runtime and memory usage, particularly for global bundle adjustment as the number of views increases?
2 comments
AuthorsOpenReview ↗

Reply to Reviewer hreS

We thank the reviewer for the positive assessment.

Novelty. We thank the reviewer for recognizing that our contributions are meaningful. What unifies them is the design insight: dense matching as a simple, efficient, and general interface between a feed-forward 3D model and classical optimization. Each component operates at the abstraction it is suited for: the foundation model provides global context and initialization, the decoder translates it into geometric evidence, and a standalone solver optimizes it efficiently, without the need for joint training. Much as a language model calls a calculator for arithmetic, a 3D foundation model can call an external optimizer through dense matching. We believe this paradigm enables future exploration of 3D foundation models beyond scaling the backbone alone.

Presentation: which configuration each table uses (revised PDF, Appendix K, Table 14). Most tables use the same settings. Input images are at VGGT-Ω's default size, about 512² pixels, including ETH3D fast. Only ETH3D HR adds a second refinement round on 2× higher-resolution input, because its images are high resolution. All datasets assume global shutter, except the TUM rows that are marked as rolling shutter. The revised PDF adds a table with the configuration of the main experiments (image resolution, high-resolution refinement, shutter model). We will remove the redundant fast/global shutter annotation for the default, to avoid confusion.

Paper organization. We thank the reviewer for the thoughtful suggestions. We will improve the organization and move the core of the depth fusion from the appendix into the main text in the final version.

Consistency over long sequences. For long sequences, drift can be reduced by proper loop closure. However, developing an effective image retrieval strategy to find loop candidates efficiently is out of scope for this work. For simplicity, as described in Section 3.3 (Edge selection), we sample 30 keyframe anchors at a uniform stride for long sequences, and they match each other. Every other frame also matches its 8 nearest keyframes. Together with the edges between temporal neighbors, the view graph is well connected and our global BA can keep the sequence consistent. The feed-forward model runs in windows of around 100 frames that share the 30 keyframes and overlap by 5 frames. Each window is aligned to the first by a Sim(3) on the shared frames, and then one global BA refines all frames.

Scaling of runtime and memory with the number of views (revised PDF, Appendix J, Figure 17). We measured our BA on subsets of the Eyeful Tower kitchen, from 500 to 6,042 views. Runtime and peak GPU memory grow about linearly with the number of views, to 27.3 s and 19.0 GiB at 6,042 views.

Reviewer_hreSOpenReview ↗

Satisfied with the author's answers

I have read the authors’ responses to the reviewers’ concerns and find them satisfactory. I appreciate the ported clarifications, the new sections in the updated appendix and I see no reason to lower my initial clear accept score.

Reviewer_46KEOpenReview ↗
Rating
4(+2)
Confidence
4
Informativeness
2
Presentation
3
Soundness
2
Read review
Paper summary

This paper presents DMap, a reconstruction pipeline that refines a frozen feed-forward 3D model with dense matching and dense bundle adjustment. A lightweight decoder reuses the VGGT-Ω features to produce dense multi-view matches, which enter a per-pixel BA on regular pixel grids solved with fused GPU kernels, including self-calibration and rolling shutter. Experiments on ETH3D, Texture-Poor, TUM RGB-D, ETH3D-SLAM and MegaDepth-X report state-of-the-art accuracy and a 13–17× speed-up over dense optimization baselines.

Critical strengths

The main new element is to bring dense correspondence and per-pixel depth into a single GPU-native BA for unordered image sets, on top of a feed-forward model. Dense BA of this kind was so far used mainly for video, as in DROID-SLAM and its extensions; the paper shows that it is practical for unordered SfM at high resolution, and that the gain is large: on ETH3D, it reaches 88.6 AUC@1°, against 78.4 for COLMAP with LoMa matches and 77.0 for Dense-SfM, the strongest sparse and dense SfM baselines. The dense matches come at low extra cost, since they are decoded from features the feed-forward model has already computed. The same BA also recovers per-pixel depth and uncertainty, so the cameras and the dense geometry come out of one optimization. The gains carry over to video and across backbones, and the ablations show that both the matcher and the BA contribute.

Critical weaknesses

My main concern is the efficiency claim in the title and abstract. The pipeline runs the full feed-forward model, a multi-view adapter with global attention over all views, a dense warp per edge, and one depth per pixel, so it has at least quadratic complexity from start to end. I do not think it can claim efficiency for reconstruction in general, only within the dense correspondence setting. The numbers support this narrower reading: the 13–17× is measured only against BLASt3R on video, the gap is about 2.5× on ETH3D, DMap is slower than DROID-SLAM on TUM RGB-D. GPU-native SfM is also not new: FastMap runs entirely on the GPU with per-step cost linear in the number of image pairs, and reports one to two orders of magnitude speed-up over COLMAP and GLOMAP on scenes with thousands of images, which is substantially faster and larger in scale than what DMap shows. The paper neither cites nor compares with it. I would suggest that the paper scope itself as an efficient and accurate framework for dense correspondence estimation and dense BA, and name the baseline behind the speed-up.

My second major concern is novelty. Most of the elements have been explored and demonstrated before. Fast BA on the GPU is established: multicore and GPU solvers such as PBA and MegBA (vectorized, distributed Schur elimination for large-scale SfM), and BAE/PyPose (sparse Jacobians and LM on the GPU, integrated with PyTorch), already show that BA need not be the bottleneck, so the motivation that iterative optimization is believed to be slow is overstated. Dense BA with one depth per pixel, a diagonal depth block eliminated by the Schur complement and fused CUDA kernels is the formulation of DROID-SLAM, extended with self-calibration in DroidCalib; the camera models follow classical work (Fitzgibbon; Hedborg et al.), and the refiner is the released RoMa-Ω refiner. What remains new is mainly the regrouping of these observations under dense matching, with a fixed set of target views per source image so that they form regular tensors. This is good engineering, but for ICLR I find the methodological contribution limited. It is also not shown that the speed requires this layout: running the same dense observations through a general GPU solver such as MegBA or BAE would clarify what the regular layout itself contributes.

Missing depth-map evaluation. A better point cloud can also be obtained simply by removing bad points, and the reported curves rank and keep the most certain points. It would be much more interesting to see whether the system actually improves the depth values predicted by the network, rather than only serving as a way to remove bad candidates. Hence, I would like to suggest a per-pixel comparison of the BA depth with the raw VGGT-Ω depth after scale alignment, for example AbsRel and δ<1.25 over all pixels or a selected subset, on indoor scenes such as held-out ScanNet or ScanNet++ or TUM RGB-D scenes (ScanNet++ is in the training data). Indoor scenes are especially informative, since SfM is weak on textureless surfaces where feed-forward models are comparatively strong, and it is unclear whether the BA improves or degrades the prediction there.

Overall, the accuracy gains are strong, but the efficiency claim is too broad and the methodological novelty is limited. I would be inclined to raise my score if the authors scope the efficiency claim to dense correspondence and clarify what is new beyond existing GPU and dense BA.

Questions for authors

Please see the weaknesses above. I would adjust my rating based on the response.

4 comments
AuthorsOpenReview ↗

Reply to Reviewer 46KE (1/3)

We thank the reviewer for the detailed and expert feedback. We address the three concerns in the order of the review.

1. The efficiency claim should be scoped to dense correspondence and name the baseline.

Scope claim: We agree that the current focus of our paper might be received as too broad on efficiency. Indeed, we prioritised accuracy with dense matching, so we will scope the efficiency claim mainly to the dense, high-accuracy setting. In the revised PDF, we removed the 13–17× speed-up from the abstract and conclusion, since it holds only against BLASt3R on video. The final version will scope the efficiency claim to dense correspondence and dense bundle adjustment. We agree that global attention makes the feed-forward model inevitably quadratic in the number of views with a single inference. We have preliminary attempts with simple chunking, but scaling it with optimal windowed inference like GlueMap is outside the scope of our work.

Nevertheless, we show, with the following experiments, that our work overall has an efficiency competitive with other efficient methods, like FastMap and DROID-SLAM, while reaching a much higher accuracy.

Comparison against FastMap (revised PDF, Appendix I, Table 13). As suggested, we compare to FastMap on the Eyeful Tower dataset, using two of the largest scenes that its evaluation already considers. FastMap's own runtime protocol excludes matching time because it starts from a COLMAP database obtained with exhaustive matching. We additionally report the matching time and the runtime of the final optimization step (their epipolar refinement vs. our dense BA) separately, for a more direct comparison. FastMap's epipolar refinement uses first-order optimization (Adam) for more than 10k steps, while our dense BA uses 20 Levenberg–Marquardt iterations. It reaches higher final AUC in a fraction of the time. The revised PDF now cites FastMap.
We timed FastMap on the same 5090 GPU. The AUC of FastMap, and the FastMap protocol time and AUC of ᵃ, are from the paper of FastMap.

MethodRuntimeAUC@1° ↑AUC@3° ↑
MatchingFastMap protocolOptimization (steps)Total
apartment, 3.8k images
Ours728 s37 s20 s (20 LM)765 s70.286.1
FastMap~7.3 h442 s58 s (12.6k Adam)~7.4 h6.445.5
COLMAP / GLOMAP ᵃ~7.3 h51.5 h / 1.6 h––21.9 / 18.262.0 / 50.5
kitchen, 6.0k images
Ours1,117 s50 s27 s (20 LM)1,167 s85.995.2
FastMap~38 h1,137 s55 s (11.0k Adam)~38 h4.638.1
COLMAP / GLOMAP ᵃ~38 htimed out / 6.4 h––timed out / 14.4timed out / 41.2

DROID-SLAM on TUM RGB-D.
The results for TUM in our initial submission are based on a subsampling of frames to 1/4th, about twice the ~110 keyframes DROID-SLAM keeps per sequence, and we have not tuned this for speed. When subsampling frames to 1/8th, which is close to DROID-SLAM's keyframe count and fits in a single feedforward inference without chunking, our pipeline is faster than DROID-SLAM and remains more accurate (see table).

TUM RGB-D fr1, calibrated, global shutterkeyframes / seqATE cm ↓time s / seq ↓
DROID-SLAM~1103.823
Ours every 8th frame~1202.310.7
Ours every 4th frame~2402.329
AuthorsOpenReview ↗

Reply to Reviewer 46KE (2/3)

2. Novelty.

Our insight is that dense matching can be a simple, efficient, and general interface that combines a feedforward model and optimization. We show that a hierarchical loop transformer that reuses feedforward features and per-view computation allows efficient match decoding. By fully utilizing the fixed and regular structure of the dense matching and view graph, the BA can be efficient and as fast as other steps. We believe that this insight is valuable and not supported by existing published research. The VGGT paper claims in its introduction that optimization is too costly, which we here disprove.

With our simple, efficient and general interface, each component operates at the level of abstraction it is suited for: the foundation model provides global context and initialization, the decoder translates it into geometric evidence, and a standalone solver optimizes it efficiently, without the need for joint training. Much as a language model calls a calculator for arithmetic, a 3D foundation model can call an external optimizer through dense matching. We believe that this opens new possibilities of 3D foundation models beyond scaling the backbone.

Comparison against other formulations of GPU BA (revised PDF, Appendix G, Table 10). As suggested, we ran existing GPU bundle adjustments on the same input considered for our approach (table below). General-purpose solvers are not suitable: MegBA (in single-GPU mode) is 15–27× slower and BAE 59× slower, and both use far more memory.

DROID-SLAM’s BA also exploits the regular structure of dense depth, but not the regular view graph. It loops over an irregular list of unordered image pairs, caching per-pair blocks with further passes gathering them. We iterate over a star-wise loop, processing each image with all its targets in one pass with regular memory access, and computing Jacobians on the fly. Ours is 3.0× faster on ETH3D and 8.6× on TUM, using less memory. DroidCalib adds self-calibration but is 16–88× slower.

Beyond performance, DROID-SLAM’s BA was designed for tight integration with a jointly trained flow estimation network, which predicts per-pixel weights that filter outliers and even controls the solver’s damping, while the BA itself supports only an L2 loss and fixed-damping Gauss–Newton. Without the network, this design is not robust and converges more slowly (see reply to Reviewer L5B2). We show that, decoupled from the network, a simple standalone dense BA with a robust Cauchy loss and adaptive Levenberg–Marquardt damping is usually enough for efficient robust optimization. Together with flexible camera calibration, it serves as a general tool for any feed-forward model that outputs dense matches, without joint training. We believe that this will be a valuable contribution to the community.

MethodRuntime, ms / iteration ↓Peak memory, GiB ↓
ETH3D-25TUM-cal-9TUM-uncal-9ETH3DTUM-calTUM-uncal
Ours1.7011.614.11.53.73.8
DROID-SLAM5.13 (3.0×)100 (8.6×)–2.28.4–
DroidCalib26.7 (16×)–1,235 (88×)2.3–11
MegBA26.3 (15×)315 (27×)OOM on 1/91128OOM
BAE100 (59×)OOM on 8/9OOM on 9/921OOMOOM

In parentheses: runtime relative to ours. Ours with its Cauchy loss, the others with L2 (the reply to Reviewer L5B2 compares the same L2 objective).

AuthorsOpenReview ↗

Reply to Reviewer 46KE (3/3)

3. Per-pixel depth against the VGGT-Ω prediction (revised PDF, Appendix H, Table 12).

As suggested, we evaluate the per-pixel depth on the official ScanNet++ validation split, which includes 50 scenes. We follow a protocol similar to DVLT, with 100 frames per scene at a uniform stride. None of these scenes are included in our training set. We also evaluate using the 13 scenes of the ETH3D dataset. Both are evaluated without known poses. We report the standard metrics AbsRel and the inlier ratios δ<1.03 and δ<1.25. The gain is more visible at the tight threshold, while δ<1.25 is saturated for all three methods.

We align predicted depth to ground truth using the median of per-pixel ratios, with either one scale per scene or one scale per image. The depth of VGGT-Ω has inconsistent scale across views: switching from per-scene to per-image alignment lowers its AbsRel substantially. After BA, the scale across views is largely consistent and the two alignments give similar results.

With per-scene alignment, BA improves depth significantly by jointly aligns inter-view scale. With per-image alignment, which isolates improvement beyond scale consistency, BA still lowers AbsRel, by half on ETH3D and modestly on ScanNet++. Fusion further improves depth in both cases by aggregating cross-view consensus weighted by uncertainty.

MethodScanNet++ETH3D
AbsRel ↓δ<1.03 ↑δ<1.25 ↑AbsRel ↓δ<1.03 ↑δ<1.25 ↑
One scale per scene
VGGT-Ω0.04460.6240.9750.00990.9580.999
Ours BA0.03290.8140.9760.00420.9840.999
Ours fused0.02800.8750.9760.00350.9900.999
One scale per image
VGGT-Ω0.03330.7940.9760.00820.9650.999
Ours BA0.03120.8230.9760.00410.9840.999
Ours fused0.02650.8820.9760.00340.9900.999

Thank you for the detailed response and additional experiments. I find the comparisons with other GPU-based BA solvers particularly convincing, and the runtime reduction in correspondence estimation is also very meaningful. The per-pixel depth improvements are strong as well. These results address my concerns, and I will raise my rating.

Reviewer_L5B2OpenReview ↗
Rating
4
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

DMap reconstructs cameras and dense geometry from image sets or video using a frozen VGGT-Ω model for initialization and features. Its main contributions are a dense matcher that shares per-view computation across image pairs and an efficient GPU bundle adjustment that jointly refines cameras and depths, with uncertainty estimates supporting depth fusion. Evaluation on ETH3D, Texture-Poor, TUM RGB-D and ETH3D-SLAM reports strong accuracy and runtime gains. Component swaps under a common initialization, together with context-view experiments using a common refiner, validate the contributions of both matching and optimization.

Critical strengths
  1. Large, broad accuracy gains at substantially lower cost. On ETH3D, DMap reaches 88.6 AUC@1° versus 78.4 for the next most accurate method, in 8.8 versus 189 s (Table 1), with strong results also on Texture-Poor, TUM RGB-D and ETH3D-SLAM. This combination of accuracy, speed and breadth is the principal reason I recommend acceptance.

  2. The efficient matching and optimization contributions are convincingly separated. Sharing per-view computation makes matching affordable across a view graph. Under the same initialization, Table 8 improves AUC@1° from 55.3 to 74.9 with the new BA, to 82.9 with the new matcher, and to 88.6 with both. Table 9 further shows useful context-view gains with a common refiner. These controls establish that the proposed components contribute beyond the foundation-model initialization and explain why the system succeeds.

Critical weaknesses

None.

Questions for authors

Additional evidence (contribution of the BA): With dense correspondences, initialization and camera model held fixed, how does DMap's BA compare with an existing DROID-style dense BA in accuracy and runtime? Table 8 convincingly establishes gains over BLASt3R's sparse BA, but does not isolate the advance over the source-anchored dense formulation credited in Section 2. This would clarify how much of the accuracy and runtime improvement comes from DMap's optimization design beyond established dense BA, which matters to my assessment of its technical contribution.

2 comments
AuthorsOpenReview ↗

Reply to Reviewer L5B2

We thank the reviewer for the positive feedback and the precise question.

Comparison to DROID-style dense BA (revised PDF, Appendix G, Table 11).
DROID-SLAM’s BA is designed to be integrated with a neural network that is trained end-to-end to predict per-pixel weights to down-weight outliers and to control the damping of depth updates. The BA itself supports only an L2 loss and fixed-damping Gauss–Newton, with no robust loss or adaptive Levenberg–Marquardt damping. We disable its update network and instead run it for 20 iterations using our dense matches, confidence, and VGGT-Ω initialization. For fairness, we disable the depth prior in our approach and minimize the same objective. We report results on TUM, using fixed ground truth intrinsics. We also report results in an uncalibrated mode, in which intrinsics are free. We then compare against DroidCalib, which extends DROID-SLAM with self-calibration.

The results are given in the table below. Our approach, when using the same L2 loss, is both faster and more accurate, in both calibration modes. With only fixed-damping Gauss–Newton, DROID-SLAM ends at a 4.4 % higher cost after 20 iterations (median over 9 sequences). Using the Cauchy loss reduces the influence of outliers and further improves accuracy.

Efficiency. DROID-SLAM’s BA exploits the regular structure of dense depth, but not the regular view graph. It loops over an irregular list of unordered image pairs, caching per-pair blocks with further passes gathering them. We iterate over a star-wise loop, processing each image with all its targets in one pass with regular memory access, and computing Jacobians on the fly. With the same L2 objective, ours is 8.7× faster per iteration than DROID-SLAM on calibrated TUM and 92× faster than DroidCalib on uncalibrated TUM (table below). The full runtime and memory comparison, including ETH3D and general GPU solvers (MegBA, BAE), is in our reply to Reviewer 46KE (2/3) and in the revised PDF (Appendix G, Table 10).

TUM RGB-D fr1, 9 sequencessolverlossATE cm ↓ms / iteration ↓
calibrated (fixed intrinsics)OursL24.811.5
DROID-SLAML28.0100
OursCauchy2.311.6
uncalibrated (free intrinsics)OursL23.413.4
DroidCalibL25.21,235
OursCauchy2.214.1

Thanks for adding Table 11. That answers my question, and my rating stays the same.

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.