acceptodds
Under review as a conference paper at ICLR 2027

OddEye: Bridging Pairwise Dense Matching and Incremental Structure-from-Motion

Abstract

While pairwise dense matchers offer dense coverage and robustness in low-texture scenes, their integration into incremental Structure-from-Motion (SfM) is hindered by two fundamental issues: fragmented multi-view tracks caused by independent pairwise sampling, and a high per-pair matching cost that makes exhaustive matching prohibitive. To overcome these challenges, we present OddEye, an incremental SfM framework that pairs off-the-shelf dense matchers with dynamic, reconstruction-aware scheduling. First, OddEye enforces consistent observation identities across views by anchoring queries to a fixed set of source coordinates per image, forming well-connected star-shaped multi-view tracks. Second, OddEye extracts a compact geometric prior from the cross-view attention of a feed-forward 3D model, and uses it to dynamically schedule dense matching only between candidate unregistered images and already registered partners. OddEye attains state-of-the-art results on ETH3D, IMC 2021, and Texture-Poor SfM, achieving 94.98% AUC@3° on ETH3D with RoMa v2. It also delivers a 9.53× speedup on the largest ETH3D scene with negligible pose loss and scales to SMERF scenes of up to 1,874 images, registering 99.8% of images with under 10 GiB of peak GPU memory.

Primary area:
applications to computer vision, audio, language, and other modalities
Keywords:
Image Matching, Structure-from-Motion, Feed-forward 3D Model

Reviews

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

OddEye integrates off-the-shelf pairwise dense matchers into incremental SfM through two components: fixed per-image source anchors for constructing connected multi-view tracks, and attention-guided scheduling for selecting the initial pair, the next image, and registered matching partners. The framework improves reconstruction accuracy across several benchmarks and reduces matching costs through on-demand pair selection.

Critical strengths
  1. The empirical results are strong, particularly on ETH3D. Improvements with the same underlying matcher suggest that the gains extend beyond adopting RoMa v2.
  2. The evaluation covers multiple matchers, backbones, and component ablations. The fixed-anchor modification to MV-RoMa and larger-scale reconstructions provide useful evidence of transferability and practical value.
Critical weaknesses
  1. Limited methodological novelty. Fixed anchors provide a simple and effective way to preserve observation identities across pairwise dense matching calls while retaining continuous target coordinates. The results, including the MV-RoMa modification, establish its utility. However, given the established principle of persistent observations in SfM and prior work on dense track construction and registration-aware matching, I find the methodological advance relatively incremental. The paper could more precisely articulate the distinctive insight in its attention-and-track-based scheduling.

  2. Limited comparison with geometry-aware alternatives. Tables 4 and 5 convincingly establish gains over appearance-based retrieval, but do not show whether the attention prior improves upon a competitive geometry-aware selector. A feasible comparison using the same matcher and comparable matching costs would strengthen this contribution. Extending the existing end-to-end runtime comparison to a competitive sparse pairing strategy would also better establish the practical efficiency advantage.

Questions for authors
  1. Can you more precisely distinguish fixed-anchor construction from source-centered track construction in existing multi-view matching methods, particularly regarding persistence across groups?

  2. Can you provide a representative geometry-aware or registration-aware scheduling baseline under comparable matching costs, or explain the relevant implementation constraints?

3 comments

We thank the reviewer for the thoughtful assessment and the two questions.

W1. The distinctive insight of the scheduling. We agree that persistent observations are an established principle of SfM, and that fixed anchors are a simple way to apply it to pairwise dense matching. The insight that we consider distinctive is that fixed anchors allow us to estimate, before matching an image, how many of the existing tracks are visible in it. This number is the classical next-view criterion of incremental SfM, and we obtain it from the attention of a 3D foundation model instead of from precomputed matches.

The classical criterion. Incremental SfM commonly selects the next image by the number of already triangulated points that it observes, and COLMAP (Schönberger & Frahm, 2016) additionally considers how these points are distributed in the image. This criterion has been the standard for more than a decade. However, it is computed from the matches of every candidate image, so the pairs have to be matched in advance, either all of them or those selected by a retrieval prior that may be inaccurate (see also our reply to W2/Q2).

Why this is possible. Every track starts from a fixed anchor, so we know the image and the patch from which it originates. The attention of a 3D foundation model from this patch indicates in which other images the patch is visible, and the model computes it from all images of the scene jointly. For every image that is not registered yet, we can therefore count the existing tracks that are estimated to be visible in it, without matching this image (Eq. 6). We select the image with the highest count as the next view, and we use the same attention to select the registered images with which it is matched.

Difference from prior work. DetectorFreeSfM and DenseSfM first match the image pairs and build an initial reconstruction. They then use this reconstruction to refine the tracks (DetectorFreeSfM) or to extend them to further images (DenseSfM). In both methods, the reconstruction is used after the matching, and it is not used to decide which image pairs are matched. In OddEye, the current reconstruction is used before matching, to decide which image and which pairs are matched next, which allows us to run a dense matcher on only a few pairs per image.

Evidence. To test the role of the tracks, we scored the next image with the same attention at the image level, without using the tracks, and AUC@3° decreased from 89.07 to 86.69. To test the role of selecting the pairs during reconstruction, we fixed the pairs before reconstruction, using the same attention scores and the same number of pairs. In this case, AUC@3° decreased to 80.04, and only 730 of the 809 images were registered instead of 796 (App. G.1).

Q1. Fixed anchors vs. source-centered track construction, and persistence across groups. The difference is whether the points sampled in an image are kept from one group to the next. Suppose image A belongs to two groups of views, {A, B, C} and {A, D, E}, and all five images observe the same window corner. A multi-view matcher such as MV-RoMa (Lee et al., 2026) samples points in A for the first group and predicts their corresponding locations in B and C. For the second group, it samples a new set of points in A. The corner is then tracked once through A, B, and C, and once more through A, D, and E from a different point, and the two tracks are not connected. In OddEye, we sample the points of A once and keep them throughout the reconstruction. Whenever A is matched with B, C, D, or E, the same anchor on the corner is used, so its observations in these images belong to a single track, and a pair matched at a later step extends existing tracks instead of starting new ones. The table below compares how far a tracked point is reused in each method.

MethodTrack points come fromTarget coordinatesA point is reused acrossLearned refinement
Keypoint SfMdetector, every imagediscrete keypointswhole reconstruction, if re-detectednone
DetectorFreeSfMquantized matchesquantized to a gridone grid cellmulti-view refiner
DenseSfMdense matches + Gaussian Splatting extensioncontinuous, projected in extended viewsviews where its 3D point is visiblemulti-view refiner
MV-RoMaper-group source samplescontinuousone groupmulti-view track model
OddEyefixed anchors of the source imagecontinuouswhole reconstructionnone

We included a condensed version of the table above as Table R17 in the revision (App. G.8) and added this discussion to Sec. 2, 3.1, and 3.3.

W2/Q2. Geometry-aware and registration-aware scheduling baselines under comparable matching cost. We compared the attention prior with three published selectors and with a geometry-aware selector that we built for this comparison, using the same matcher and a similar number of matched pairs. Attention outperforms all of them with both matchers.

Published selectors. We selected recent methods that can be applied before any matching and that use geometry in their training or their features. SupScene is a retrieval descriptor trained with overlap supervision, MASt3R-SfM retrieval uses the encoder features of a 3D model, and Global Edge Prior (CVPR 2026) ranks pairs with a network trained on labels derived from SfM geometry. Note that all three still assign a single score to each image pair. We used their scores in place of the attention prior in all three scheduling decisions (initial pair, next view, and registered partners). For the next view, we ranked the candidates by their mean score to the registered views, because the mean gives higher accuracy than the maximum on the methods where we ran both (SupScene and Global Edge Prior).

A geometry-aware selector from the same model. To test geometry more directly, we designed a selector based on the geometry decoded by the same DVLT model that provides our attention, so that the two schedulers differ only in which output of the model they use. For each patch of image i, we take the 3D points that DVLT predicts for its pixels and project them into image j with the predicted cameras. We then compute the fraction of these points that fall inside the image and lie in front of the surface predicted for j, with a 10% depth tolerance. We use this fraction in place of the attention score of the patch and set the visibility threshold of Eq. 6 to 0.5. This selector is a strong baseline, because its ranking of image pairs is as accurate as that of attention (AP 0.936 vs. 0.938) and its ranking of next-view candidates agrees with the ground truth better (ρ = 0.938 vs. 0.756, App. G.4).

Scheduler (ETH3D, 22 scenes, k = 3, AUC@3° %)RoMaRoMa v2Pairs / scene (RoMa)
Attention prior (ours)89.0794.79116
Decoded geometry (same 3D model)85.5393.90120
Global Edge Prior (CVPR 2026)82.7187.87128
SupScene81.6490.28137
MASt3R-SfM retrieval73.8284.43111

Decoded geometry is the strongest alternative, and attention outperforms it by 3.5 points with RoMa and by 0.9 points with RoMa v2. With RoMa, we found that most of this difference comes from pair selection. When geometry selects the initial pair and the partners, two scenes (bridge and meadow) fall to 48 and 45 AUC@3°, compared with 95 and 92 with attention. When geometry selects only the next view, these scenes reach 96 and 87, and the mean is 88.15 (Table R5). Geometry also needs the decoders of the model, which raise the peak GPU memory of a 110-image forward pass from 3.9 to 13.7 GiB, whereas attention is available without them.

Registration-aware scheduling. We understand “registration-aware scheduling” as selecting the next view or the pairs based on the state of the current reconstruction, as in the next-best-view score of COLMAP, or based on the matches obtained so far, as in the covisibility-based matching of EC-SfM. These methods score a candidate from its correspondences, so they need the matches of every candidate. With on-demand matching, a candidate has no matches before it is selected, and matching every candidate in advance would remove the benefit of on-demand matching. These methods can therefore be applied at a comparable matching cost only when the pairs are fixed before reconstruction. In this setting, COLMAP, which uses its own registration-aware selection, reaches 91–93 with the sparse matcher LoMa on the same number of attention-selected pairs as OddEye, compared with 94.79 for RoMa v2 + OddEye (App. G.2). Within on-demand matching, our scheduler and the decoded-geometry selector are both registration-aware, since Eq. 6 counts the tracks of the current reconstruction that are predicted to be visible in each candidate.

Methods that we could not include. SARA estimates overlap and parallax from a lightweight pre-matching pass to select the pairs, and we did not find public code for it. Co-VGGT learns a co-visibility predictor on a frozen 3D model, but its code and weights have not been released yet.

W2 (continued). Runtime against a sparse pairing strategy. We extended the runtime comparison of the submission (Fig. 8), which compares OddEye with exhaustive matching, to schedulers that also match a sparse set of pairs with the same dense matcher. On the same 110-image bridge scene, the attention scheduler has the shortest total runtime among them (RoMa v2, k = 3, RTX 3090).

SchedulerPairsEnd-to-end timeAUC@3°
Attention prior (ours)3241,247 s96.68
NetVLAD, on-demand3871,328 s96.19
Global Edge Prior, on-demand3731,476 s86.05

Extracting the attention prior takes 64 s, which is 16 s longer than extracting the NetVLAD descriptors, but its matching stage is shorter (454 s, compared with 618 s and 709 s). The attention scheduler also registers an image at every attempt (108 of 108), whereas the NetVLAD scheduler fails in 18 of 126 attempts and the Global Edge Prior scheduler in 53 of 157. Its accuracy on this scene is similar to that of the NetVLAD scheduler (96.68 vs. 96.19). Table R10 (App. G.3) gives the time of each stage and also includes sparse-matcher pipelines (LoMa and FlexGlue with COLMAP).

If the reviewer has a specific baseline in mind, we would be glad to include it.

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

This paper proposes OddEye, an incremental Structure-from-Motion (SfM) framework that integrates off-the-shelf dense matchers through anchor-based track construction and attention-guided on-demand matching. The authors identify two limitations of conventional pairwise dense matching in incremental SfM: fragmented multi-view tracks caused by independently sampled correspondences and the high computational cost of exhaustive pairwise matching. OddEye introduces fixed per-image source anchors to establish consistent multi-view tracks and extracts compact co-visibility priors from the cross-view attention of a frozen 3D foundation model. These priors guide initial-pair selection, next-view registration, and matching-partner selection during reconstruction. Experiments on ETH3D, IMC 2021, Texture-Poor SfM, and SMERF demonstrate strong camera-pose estimation, improved track connectivity and reconstruction completeness, and substantial end-to-end runtime reductions.

Critical strengths
  1. The anchor-based track construction provides a simple and effective solution to a practical problem in incremental SfM. By reusing fixed source coordinates across image pairs, OddEye preserves observation identities and allows independently predicted correspondences to form consistent multi-view tracks. Confidence filtering, forward–backward consistency checks, and geometric verification further improve matching reliability. Importantly, the approach works with existing dense matchers without requiring an additional learned track-refinement module. The ablation results also show substantial improvements in track connectivity and camera registration.

  2. I find the use of cross-view attention from a 3D foundation model to estimate geometric co-visibility particularly interesting. Rather than relying only on appearance-based image retrieval, OddEye extracts geometric priors from jointly processed views and uses them to guide the reconstruction process. The distinction between patch-level and image-pair-level scores is well suited to the task: the former helps estimate the visibility of existing 3D tracks, while the latter guides initial-pair and matching-partner selection. The authors also compress the original attention representation into compact scores, greatly reducing storage requirements. This is an effective way to use pretrained geometric representations to guide downstream reconstruction.

Critical weaknesses

The incremental end-to-end efficiency benefit of the attention prior is not fully established. Although the paper demonstrates substantial speedups over exhaustive matching and improved accuracy with attention-guided scheduling, it lacks a controlled end-to-end comparison against a simpler retrieval-based on-demand scheduler using the same fixed-anchor construction and dense matcher. Such a comparison would help clarify the value of the additional prior, since extracting global cross-view attention introduces computational overhead. So the additional accuracy–efficiency benefit of the attention prior over simpler on-demand alternatives remains unclear.

Questions for authors
  1. Could the authors further clarify the practical benefit of attention-guided scheduling over a simpler retrieval-based on-demand approach? While the paper demonstrates improved reconstruction accuracy, it remains unclear whether these gains justify the additional computational cost of extracting the geometric attention prior.

  2. The patch-level scores are derived from global post-softmax attention without per-target renormalization, and Eq. (6) uses a fixed visibility threshold of 0.05. Since the sum of per-target maximum attention scores for a given source patch cannot exceed one, at most 20 target images can exceed this threshold. Is this restriction intentional, and how sensitive is next-view selection to the threshold as the number of images and their overlap density increase? This concerns the visibility estimates used for scheduling, rather than a hard limit on the actual multi-view track length.

2 comments

We thank the reviewer for the careful reading. In response to both questions, we conducted additional experiments, and we provide the full tables in App. G.1, G.3, and G.6 of the revision.

1. Practical benefit over retrieval-based on-demand scheduling (W, Q1). The practical benefit of the attention prior is higher accuracy at a similar matching cost. With the same fixed anchors, the same dense matcher, and a similar number of matched pairs, attention-guided scheduling is 11.3–13.9 AUC@3° points more accurate than retrieval-based on-demand scheduling (NetVLAD, MegaLoc) with RoMa, and 6.2–11.0 points more accurate with RoMa v2. The additional cost is the extraction of the prior, which takes 16 s longer than extracting NetVLAD descriptors on a 110-image scene and 5.9% of the total runtime on a 990-image scene.

Setup. We kept the fixed anchors, the dense matcher, k = 3, and all other settings unchanged. We then used the retrieval score in place of the attention prior in all three scheduling decisions, namely the initial pair, the next view, and the registered partners of each new image. For the next view, we ranked the candidates by their mean score to the registered views, because the mean gives higher accuracy than the maximum on the baselines where we ran both (75.19 vs. 73.27 for NetVLAD). This setting is different from Table 5 of the submission, which changes only the selection of the registered partners. In its on-demand NetVLAD row (81.47), the attention prior still selects the initial pair and the next view. We clarified this in Sec. 4.5 of the revision.

Scheduler (ETH3D, 22 scenes, k = 3, AUC@3° %)RoMaRoMa v2
Attention prior (ours)89.0794.79
Global Edge Prior (CVPR 2026)82.7187.87
SupScene81.6490.28
MegaLoc77.8188.60
NetVLAD75.1983.77
MASt3R-SfM retrieval73.8284.43

SupScene and MASt3R-SfM retrieval are retrieval methods, and Global Edge Prior is a network that ranks image pairs before matching and is trained on SfM results. They are 4.5–15.3 points less accurate than the attention prior.

Where the difference comes from. We observed that a large part of the difference comes from scenes with repeated, visually similar structures (old_computer, exhibition_hall, meadow). On old_computer and exhibition_hall, 22.4% and 30.7% of the top 10% of pairs ranked by NetVLAD have no ground-truth overlap, whereas the top 10% of pairs ranked by the attention prior contain no such pair.

Cost. Across the 22 scenes, the attention scheduler matches 116–118 pairs per scene depending on the matcher, which is similar to the 112–126 pairs matched by the NetVLAD and MegaLoc schedulers (App. G.1). The higher accuracy therefore does not come from matching more pairs. To compare the runtime, we measured the full pipeline with RoMa v2 on the 110-image ETH3D bridge scene (RTX 3090). Extracting the attention prior takes 64 s, compared with 48 s for the NetVLAD descriptors (both excluding model loading). On this scene, the attention scheduler matches fewer pairs than the NetVLAD scheduler (324 vs. 387), so its matching stage is shorter (454 s vs. 618 s) and its total runtime is also shorter (1,247 s vs. 1,328 s), with similar accuracy (96.68 vs. 96.19).

2. τ_v and the limit of 1/τ_v images (Q2). Yes, this limit is intentional. We use the attention normalized over all images, because this makes the scores of different images comparable. τ_v is a parameter set by the user, and it also determines the maximum number of views in which a track can be counted as visible. We also found that the value reported in the submission was a typo. Table 6 and App. A.1 state τ_v = 0.05, but all our experiments use τ_v = 0.01, so the limit is 100 images, not 20, and we corrected this in the revision.

Sensitivity of next-view selection. To measure this sensitivity, we took the 699 registration steps of our ETH3D run with τ_v = 0.01 and recomputed Eq. 6 at every step with five thresholds on the same reconstruction state. As the reference, we ranked the candidates of each step by the number of currently triangulated points that they observe under their ground-truth poses. For the row with the final accuracy, we ran the full reconstruction with each threshold.

τ_v0.0050.01 (used)0.020.050.1
Limit 1/τ_v (images)200100502010
Steps in which the best view is selected46.2%42.2%34.6%27.8%20.9%
Points observed by the selected view, relative to the best view84%79%73%68%63%
The same ratio on scenes with more than 60 images71%62%55%49%48%
Final ETH3D AUC@3° (RoMa, k = 3)87.6289.0789.0188.9788.45
NYC (990 images): images above τ_v per patch (median / max)18 / 769 / 452 / 270 / 120 / 7

We found that next-view selection is sensitive to the threshold, and that a lower threshold selects better views, especially on larger scenes. The final accuracy is much less sensitive, and it differs by only 0.1 points between τ_v = 0.01 and 0.05. We believe this is because the selected view still observes enough triangulated points to be registered, as 796 of the 809 images are registered with every threshold up to 0.05. The lower mean at τ_v = 0.005 comes from a single scene (bridge, 94.55 → 61.89), and the other 21 scenes change by at most 0.4 points.

As the number of images grows. The number of images that exceed τ_v = 0.01 for a patch does not grow with the size of the scene. Its median is 7–10 on the ETH3D scenes with 31–110 images and 9 on the 990-image NYC scene. The maximum on NYC is 45, which is less than half of the limit, and all 990 images of this scene are registered.

As the overlap grows. The attention of a patch is shared among the views that observe the same point, so the score of each view becomes smaller for widely visible points. On ETH3D, for points that are observed in 2–7 views, 73% of the observing views have a score above τ_v = 0.01, and this share decreases to 43% for points that are observed in 16 or more views. With τ_v = 0.05, it decreases from 34% to 8%, which is why we use a low threshold. We measured this share on ETH3D, which provides ground-truth 3D points. We added these results to App. G.6.

Reviewer_DQGuOpenReview ↗
Rating
3(+1)
Confidence
3
Informativeness
2
Presentation
3
Soundness
3
Read review
Paper summary

The paper presents oddeye, an incremental sfm framework using off-the-shelf dense matching methods. The paper tries to tackle two well established challenges when applying dense matcher to sfm pipeline. Inconsistent multiview tracks and computational cost of heavy matching network. The authors address them through several designs. 1. use fixed anchor points per source image for pairwise matching. 2. Use cross attention in an off-the-shelf multi view 3d model for view selection. The paper should have strong empirical performance compared to other incremental sfm pipelines with dense matchers.

Critical strengths
  1. The improvements over previous methods are strong and impressive, showcasing the effectiveness of the system.
  2. The fixed anchor points per source image are simple and effective. The author also shows that it’s able to improve the performance of MV-RoMa’s performance by simply applying this mechanism in the appendix which is informative.
  3. The experiments also cover large scale reconstruction results, demonstrating the scalability of the method. The runtime and accuracy trade off is well balanced here.
  4. The limitations are clearly stated and well analyzed.
Critical weaknesses
  1. To me, using fixed anchor points seems to be one of the most central ideas of traditional sfm pipeline in which it detects a fixed set of keypoints before matching. This has been proven effective for more than a decade. The authors apply this straightforward idea and prove its effectiveness in the context of dense matching, but the underlying novelty and insight feels limited. Also, the performance of the traditional sfm pipeline is limited by the sparse matcher used in the system and SP+SG is a bit outdated and not surprisingly performance much worse. The state of the art sparse matching methods like LoMa(ECCV 2026) provide dense matching level performance. It would be interesting to see the performance comparison with a similar compute budget.

  2. The cross attention guided view selection is another important component in oddeye. In the ablation, the author only compares it with DINOv2 and NetVLAD which naturally fell short in comparison as they don't have inter image information. The authors discussed some similar alternatives like Co-VGGT but yet did not compare against them. This makes it difficult to verify whether the improvements arise specifically from the proposed calibration or simply from cross image information.

  3. The pair selection still remains quadratic. In the large scale experiment, the authors did not provide a detailed runtime breakdown. It’s unclear which stage dominates the multi hour run.

  4. The robustness of the attention calibration and retrieval performance remain unclear. It would be great if the author could evaluate the accuracy. Ideally with precision, recall AUC etc.

  5. The proposed fixed anchor points per source image ensure consistency, however, this can potentially generate redundant tracks as different anchor points can correspond to the same 3d points. There is no guarantee that those independent anchor points can eventually form multi view tracks. Additional analysis of this would be appreciated.

  6. Limited contribution to representation learning. The paper demonstrates strong empirical performance. The primary contributions involve reusing off-the-shelf models with a well designed system. Although the usage of cross attention in 3d models is interesting, the current work provides only limited analysis.

Questions for authors
  1. As mentioned in W1, how does oddeye compare against traditional pipeline with a more advanced matcher in both efficiency and accuracy. Since all dense matcher used demonstrate much stronger matching performance in original paper compared to SP+SG
  2. How accurate is the next view selection?
  3. What is the runtime breakdown of those large scale reconstruction.
6 comments

We thank the reviewer for the detailed feedback and concrete experimental suggestions. We report the new experiments below, with full tables in Appendix G of the revision.

W1/Q1. Fixed anchors vs. keypoints, and comparison with an advanced sparse matcher. Regarding novelty, we agree that fixing points before matching is a classical principle. Our contribution is to show that a dense matcher needs the points to be fixed on one side only. Regarding the comparison, a traditional pipeline with LoMa is as accurate as OddEye on most ETH3D scenes at a similar runtime, but it fails on scenes with repeated structures, so its mean is 9–12 points lower.

Novelty. On the source side, a fixed anchor plays the same role as a keypoint. The difference is that an anchor is defined only in its source image and does not need to be detected again in any other image, because the dense matcher predicts its corresponding location. This is why OddEye needs neither a detector, nor quantization, nor the learned refinement of DetectorFreeSfM and DenseSfM.

We also examined whether anchors behave like keypoints. If they did, a better detector would lead to better reconstructions. However, we found that using the 4,096 highest-scoring ALIKED keypoints of each image as anchors is less accurate than using 4,096 random points (82.84 vs. 89.07 AUC@3° with RoMa at k = 3). We suspected that the highest-scoring keypoints leave parts of the image without anchors. We therefore selected the highest-scoring ALIKED keypoint in each 13-px cell instead, which recovers the accuracy of random anchors (89.14, App. G.8). This shows that anchors need to cover the image, but they do not need to be salient or repeatable.

Comparison with LoMa. We ran LoMa-B and LoMa-G (DaD keypoints, DeDoDe-G descriptors, LoMa matcher) with COLMAP on all image pairs of the 22 ETH3D scenes, over three seeds.

ETH3D, 22 scenesAUC@3° (LoMa: mean ± std over seeds)Median (range over seeds)Scenes below 60 (range over seeds)Time on bridge (110 images)
RoMa v2 + OddEye (k = 3)94.7995.7101,247 s
LoMa-B + COLMAP, all pairs83.2 ± 3.794.6–94.83–5798 s
LoMa-G + COLMAP, all pairs85.6 ± 0.793.8–94.631,388 s

At this scale, matching all pairs with LoMa takes 0.6–1.1 times as long as OddEye, so this is the comparison at a similar compute budget that the reviewer asked for. The medians are close, so LoMa is competitive with a dense matcher on most scenes. The means differ mainly because LoMa + COLMAP fails on three scenes with repeated, visually similar structures (old_computer, exhibition_hall, meadow). On each of these scenes, the reconstruction is incorrect in 11 or 12 of the 12 runs (two models, two camera settings, three seeds), and about half of the relative poses are rotated by 180° or translated in the wrong direction (Fig. R1). With OddEye, this happens for only one of the 3,814 image pairs of these scenes. The table reports the results with per-image cameras, and with one shared camera per scene LoMa achieves similar accuracy (84.3–85.4, App. G.2).

W1/Q1 (continued). When all pairs cannot be matched. The cost of matching all pairs grows quadratically with the number of images, and on the 990-image SMERF NYC scene OddEye matches only 1.0% of them. At this scale, a sparse pipeline also has to select which pairs to match. To evaluate this setting, we ran LoMa + COLMAP with the same number of pairs that OddEye matches on each ETH3D scene, which is about one eighth of all pairs, and selected these pairs with four different signals (AUC@3°, mean ± std over three seeds).

Pairs selected byLoMa-BLoMa-G
All pairs (for reference)83.2 ± 3.785.6 ± 0.7
NetVLAD73.4 ± 3.478.0 ± 1.5
Global Edge Prior76.8 ± 1.179.3 ± 1.3
MegaLoc84.0 ± 0.784.1 ± 0.5
Our attention prior91.2 ± 1.493.0 ± 0.3

With pairs selected by our attention prior, it is 7–9 points more accurate than with MegaLoc and also more accurate than with all pairs, which shows that the attention prior helps a sparse pipeline as well (Fig. R2). RoMa v2 + OddEye (94.79) remains the most accurate configuration. Compared with LoMa-G with our prior, it is more than 0.5 points higher on 15 of the 22 scenes and lower on none (Table R9, App. G.2), and the margin grows from 1.8 points at AUC@3° to 3.5 points at AUC@1°. The largest differences are on exhibition_hall and old_computer, two of the scenes with repeated structures, where LoMa-G with our prior reaches 82.88 and 85.13, compared with 91.19 and 92.99 for OddEye.

Holding the matcher fixed. To separate the effect of the pipeline from that of the matcher, we used FlexGlue, which provides a dense and a sparse mode with shared matching weights. Its dense mode additionally uses the refiner of RoMa v2, so the matcher is nearly, but not exactly, the same in the two pipelines (ETH3D, 22 scenes, AUC@3° %).

MethodPairs / sceneAUC@3°Scenes below 60
FlexGlue dense + OddEye (k = 3)11092.460
FlexGlue dense + DetectorFreeSfM96878.014
FlexGlue sparse + COLMAP, all pairs96879.685
FlexGlue sparse + COLMAP, same number of pairs (NetVLAD)11672.736

With the same matching weights, the dense mode with OddEye is 12.8 points more accurate than the sparse mode with COLMAP on all pairs, while matching about one ninth as many pairs (110 vs. 968 per scene). The dense mode with DetectorFreeSfM, which quantizes the matches, reaches 78.01.

W2. Calibration or cross-image information. Both contribute to the improvement, and our new experiments evaluate them separately. Here, calibration refers to the selection of the attention head, which we perform once on Tanks & Temples (App. D.1). In the table below, each scheduler replaces the attention prior for the initial pair, the next view, and the registered partners, with the fixed anchors, the matcher, and k = 3 unchanged (ETH3D, 22 scenes, AUC@3° %):

SchedulerRoMaRoMa v2
Attention prior, head (11,0) (ours)89.0794.79
Attention prior, head (11,2)74.1891.09
Attention prior, head (2,0)73.4683.16
Decoded geometry (same 3D model)85.5393.90
Global Edge Prior (CVPR 2026)82.7187.87
SupScene81.6490.28
MegaLoc77.8188.60
NetVLAD75.1983.77
MASt3R-SfM retrieval73.8284.43

Calibration. Two other heads of the same model have access to the same cross-image information, but using them lowers the accuracy by about 15 points with RoMa and by 3.7 and 11.6 points with RoMa v2. Cross-image information alone therefore does not explain the result, and selecting the appropriate head is necessary.

Cross-image information. The retrieval methods (SupScene, MegaLoc, NetVLAD, MASt3R-SfM retrieval), which describe each image independently, are 7–15 points lower than our attention prior with RoMa. Global Edge Prior scores all image pairs of a scene jointly, but it relies on a single MegaLoc descriptor per image, and it is 6.4–6.9 points lower. The geometry decoded by the same 3D model is the closest alternative, with a gap of 3.5 points with RoMa and 0.9 points with RoMa v2.

Co-VGGT, which the reviewer mentioned, trains a co-visibility predictor on frozen VGGT features. Its code and weights have not been released yet, so we could not include it in this comparison.

W3/Q3. Quadratic pair selection and runtime at scale. On the 990-image SMERF NYC scene, dense matching takes about half of the runtime and extracting the attention prior 5.9% (RoMa v2, k = 5, RTX A6000):

StageTimeShare
Attention prior (including model and image loading)494 s5.9%
Dense matching (4,936 pairs = 1.0% of all pairs)4,314 s51.6%
Triangulation and bundle adjustment1,812 s21.7%
Anchor refresh698 s8.4%
Next-view ranking14 s0.2%
Other (anchor landing, verification, initialization, evaluation)1,023 s12.2%
Total8,355 s100%

“Anchor refresh” updates the links between anchors and triangulated 3D points after each registration step, and “anchor landing” samples the output of the dense matcher at the fixed anchor coordinates (App. G.3).

The breakdown comes from a new run that uses our current implementation, which updates the anchors incrementally, and a different GPU from the one used for Table 17 of the submission. It registers the same 990 images with 95.30 AUC@3° (95.33 in Table 17) and takes 2.18 h excluding prior extraction, compared with 3.26 h in Table 17, where the runtime also excludes prior extraction.

We agree that computing the attention prior remains quadratic in the number of images (App. F). It is, however, far cheaper than matching a quadratic number of pairs. On this scene, the prior scores all 489,555 pairs in 494 s, about 1 ms per pair, whereas a dense match takes 0.87 s on average, so matching every pair would take about 119 hours at this rate.

W4/Q2. Accuracy of the selection. We evaluated both selections against ground truth on ETH3D. The head was chosen once on Tanks & Temples and is used unchanged on every benchmark (App. D.1), so these numbers also show that the calibration transfers to another dataset.

Pair selection. We define a pair as positive if the two images share at least 10% of their ETH3D 3D points. Under this definition, the attention prior achieves an AP of 0.938 and a ROC-AUC of 0.967, compared with an AP of 0.896 for MegaLoc, 0.878 for Global Edge Prior, 0.873 for SupScene, 0.859 for MASt3R-SfM retrieval, 0.856 for NetVLAD, and 0.741 for DINOv2. We report ROC-AUC and precision at k for all signals in Table R12 (App. G.4).

Next view. We evaluated the 699 registration steps that have at least two candidates. As the reference, we ranked the candidates of each step by the number of currently triangulated points that they observe under their ground-truth poses. Our scheduler selects the best view in 42.2% of the steps and one of the best three in 66.5% (ρ = 0.756), and the selected view observes on average 79% as many points as the best one. The best retrieval signal in this evaluation is MegaLoc with the maximum score over the registered images, and the corresponding numbers are 31.6%, 62.8% (ρ = 0.582), and 73%. We report the other signals in Table R13 (App. G.4).

W5. Redundant tracks and multi-view tracks. Redundant tracks. Two anchors in different images can indeed start separate tracks for the same 3D point, because a track is extended only from the image that contains its anchor. To measure how often this happens, we regard two tracks as duplicates when their observations lie within 1 px of each other in at least two images that both tracks contain, which indicates that they follow the same surface point. Only 0.17% of the tracks have such a duplicate (1.76% within 3 px), and merging the duplicates leaves the mean track length at 3.72 (3.75 at 3 px; App. G.5).

Multi-view tracks. Among the tracks that are triangulated, 75.2% have at least three views with RoMa at k = 3, and 91.1% in the setting of Table 3 of the submission (RoMa v2 with a precomputed pair graph).

W6. Representation-learning contribution. We agree that OddEye does not train a new representation. Its contribution is to show what already-learned representations contain and how SfM can use them without further training. On the matching side, DetectorFreeSfM and DenseSfM train an additional multi-view refiner to make pairwise matches consistent, whereas fixed anchors make the output of a frozen pairwise matcher directly usable as tracks. On the scheduling side, instead of training a co-visibility predictor, we obtain co-visibility directly from the attention of a frozen 3D foundation model.

Regarding the analysis, we added App. G.7, which summarizes our findings about this attention. We found that co-visibility is concentrated in a few heads, and that using another head lowers the accuracy by 4–16 points. The selected head predicts co-visibility at the patch level although it was never trained for this task (W4 above). In addition, its scores are shared among the views that observe a point, which is why we use a low threshold and use the counts only to rank the candidates (App. G.6).

Comments on the paper

2 comments
AuthorsOpenReview ↗

General response

We thank Reviewers DQGu (R1), JJbC (R2), and 8D3K (R3) for their constructive feedback and for recognizing the strong empirical results (R1, R3), the simplicity and effectiveness of fixed anchors (R1, R2, R3), and the use of cross-view attention as a geometric prior (R1, R2). We describe the additional experiments in the individual replies, provide the full tables in Appendix G of the revision, and summarize the main results below. Tables, figures, and sections whose numbers start with R or G are in the revision, and all other numbers refer to the submission.

1. Scheduling baselines under controlled conditions (R1 W2, R2 W/Q1, R3 W2/Q2). We keep the fixed anchors, the dense matcher, and k = 3 partners unchanged, and replace the attention prior with another signal in all three scheduling decisions, namely the initial pair, the next view, and the registered partners of each new image (ETH3D, 22 scenes, AUC@3° %):

SchedulerRoMaRoMa v2FlexGlue
Attention prior (ours)89.0794.7992.46
Decoded geometry (same 3D model)85.5393.9088.96
Global Edge Prior (CVPR 2026)82.7187.8783.85
MegaLoc77.8188.6086.13
NetVLAD75.1983.7780.52

We find that the attention prior achieves the highest accuracy with all three matchers. The closest alternative is the geometry decoded by the same 3D model, which is 0.9–3.5 points lower (reply to R3). The retrieval methods (MegaLoc, NetVLAD) and the learned pair ranking of Global Edge Prior are less accurate mainly on scenes with repeated, visually similar structures.

2. Comparison with advanced sparse matchers (R1 W1/Q1). FlexGlue has a dense and a sparse mode with shared matching weights (the dense mode adds RoMa v2's refiner), so we can compare the two pipelines with nearly the same matcher. OddEye with the dense mode reaches 92.46 while matching 110 image pairs per scene, whereas the sparse mode with COLMAP reaches 79.68 on all pairs (968 per scene). We also ran LoMa + COLMAP on all pairs and found that it is on par with RoMa v2 + OddEye on most scenes. However, it produces incorrect reconstructions on three scenes with repeated structures, which mainly accounts for its lower mean over three seeds (83–86, compared with 94.79 for OddEye). When LoMa instead matches only the pairs selected by our attention prior, which is about one eighth of all pairs, its mean rises to 91–93, whereas the same number of pairs selected by MegaLoc gives 84. The prior therefore also benefits sparse pipelines, and RoMa v2 + OddEye remains the most accurate.

3. Cost and accuracy of the selection (R1 W3/Q3, W4, R2 Q1). Extracting the attention prior takes 5.9% of the runtime on a 990-image scene. On the 110-image ETH3D bridge scene, it takes 16 s longer than extracting NetVLAD descriptors, yet the total runtime is lower because the matching stage is shorter (454 s vs. 618 s). When evaluated with ground-truth co-visibility on ETH3D, the attention prior achieves an average precision (AP) of 0.938, compared with 0.741–0.896 for retrieval signals.

4. Positioning (R1 W1/W6, R3 W1/Q1). We agree that giving observations a persistent identity is a classical principle of SfM, and that a fixed anchor plays this role on the source side as a keypoint does. Our claim is that a pairwise dense matcher needs observation identity only on the source side. The target side can therefore simply be the continuous prediction of the matcher, and no detection, quantization, or refinement is required afterwards. The scheduler then estimates, before any matching, how many existing tracks are visible in a candidate view, using the attention from the anchor patch of each track. Classical incremental SfM obtains this number from precomputed matches.

Corrections. We also corrected three errors in the submission. First, the visibility threshold reported in the submission was a typo, as all experiments use τ_v = 0.01, not 0.05 (reply to R2). Second, we corrected the matcher-call counts of the NetVLAD and DINOv2 rows of Table 16 (NetVLAD 156 → 170, DINOv2 262 → 281), and their accuracy and registration rates are unchanged. Third, Sec. 4.5 stated that the DINOv2 and NetVLAD baselines of Table 4 rank the candidate views by their maximum similarity to the registered views, whereas these results use the mean. The numbers in Table 4 are unchanged, and the mean is more accurate where we ran both (App. G.1). None of these changes affects our conclusions. We will release the code upon acceptance, or earlier at a reviewer's request, and are happy to run additional experiments.

Thank you for reading our response and the additional experiments, and for raising your rating. We are glad that the new results answered your questions. Regarding novelty, we would like to note that the gain in accuracy does not come only from the anchor-based track construction. As the name OddEye (On-demand Dense Matching) indicates, we match on demand during reconstruction using an attention prior (Secs. 3.2 and 3.3), unlike classical incremental SfM such as COLMAP, which requires matching before reconstruction. A large part of the gain comes from this change (Tables 5 and R1).

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

Related papers

Loading the map…

Discussion (0)

Sign in to comment.