CoReMatch: Recurrent Continuous Coordinate Refinement for Real-Time Robotic Feature Matching

Introduction

Image feature matching establishes pixel-level correspondences between images and is a core component of robotic perception. It supports visual localization, mapping, pose estimation, and navigation in systems such as SLAM, VIO, and autonomous aerial robots. In real-time applications, matches must be computed under tight latency, memory, and power constraints, as unreliable correspondences can directly degrade trajectory estimation, map consistency, and control stability. Classical matching pipelines rely on keypoint detection and descriptor matching, but often struggle with large viewpoint changes, motion blur, illumination variations, and low-texture regions. Learning-based methods improve robustness by combining dense visual features with global context. In particular, semi-dense matchers [1, 2, 3, 4, 5, 6, 7, 8] replace explicit keypoint detection with coarse dense matching, followed by local refinement of high-confidence correspondences.

Despite their effectiveness, existing semi-dense matchers typically predict discrete confidence maps over spatial grids. Precise localization is therefore constrained by the resolution of the prediction grid, often requiring higher-resolution inputs to achieve accurate correspondences. However, the computational and memory costs of Transformer-based architectures increase substantially with input resolution. Although recent methods reduce theoretical FLOPs through linear or aggregated attention, practical runtime on embedded platforms can still be dominated by memory movement and feature aggregation. Consequently, modest increases in image resolution can lead to disproportionate latency growth. For example, as shown in Table 7, Efficient LoFTR [8] requires 311 ms to process a $640 \times640$ image pair, while increasing the resolution to $960 \times960$ results in a $4.5 \times$ runtime increase for only a $1.5 \times$ increase in input resolution. At $1152 \times1152$, it requires more than two seconds to process an image pair on an NVIDIA AGX Orin. This scaling behavior presents a significant challenge for real-time and on-device robotic perception, motivating more resolution-efficient approaches to correspondence estimation.

Method	Resolution	Pose Est. AUC	Runtime (ms)	Memory (MB)
		@5°/@10°/@20°	Orin	3090
ELoFTR	512×512	45.7/62.9/76.1	191.4	11.7	822
	640×640	51.0/67.4/79.8	310.6	18.2	932
	800×800	53.4/70.0/81.9	668.1	42.2	2652
	960×960	54.7/70.7/82.4	1394.9	48.7	3046
	1152×1152	56.4/72.2/83.5	2066.7	66.7	3574
EDM	512×512	47.6/64.7/77.8	61.5	5.7	176
	640×640	52.2/68.9/80.9	104.1	6.7	284
	800×800	54.3/70.8/82.4	237.3	14.7	486
	960×960	55.6/71.4/82.8	513.2	17.1	676
	1152×1152	57.5/73.2/84.2	752.3	23.5	1060
CoReMatch-S	448×448	53.4/69.8/81.6	54.2	4.5	128
	512×512	55.8/71.6/83.0	72.9	4.6	132
	640×640	56.7/72.3/83.4	95.8	6.4	156
	1024×1024	57.4/72.8/83.7	177.1	7.1	266
	1152×1152	57.3/72.6/83.6	243.4	12.2	322

Category	Method	MegaDepth AUC@5°/10°/20°	MegaDepth Time	ScanNet AUC@5°/10°/20°	ScanNet Time
Sparse	SP [20] + SG [21]	49.7 / 67.1 / 80.6	-	16.2 / 32.8 / 49.7	-
Sparse	SP [20] + LG [22]	49.9 / 67.0 / 80.1	548	14.8 / 30.8 / 47.5	461
Dense	DKM [9]	60.4 / 74.9 / 85.1	7110	26.6 / 47.1 / 64.2	1418
Dense	ROMA [10]	60.9 / 75.6 / 85.6	4964	28.9 / 50.4 / 68.3	4964
Semi-Dense	LoFTR [1]	52.8 / 69.2 / 81.2	2465	16.9 / 33.6 / 50.6	437
Semi-Dense	QuadTree [6]	54.6 / 70.5 / 82.2	-	19.0 / 37.3 / 53.5	-
Semi-Dense	ASpanFormer [3]	55.3 / 71.5 / 83.1	3501	19.6 / 37.7 / 54.4	1078
Semi-Dense	TopicFM [4]	54.1 / 70.1 / 81.6	1639	17.3 / 35.5 / 50.9	260
Semi-Dense	EfficientLoFTR [8]	56.4 / 72.2 / 83.5	2067	19.2 / 37.0 / 53.6	311
Semi-Dense	EDM [23]	57.5 / 73.2 / 84.2	752	19.8 / 37.5 / 54.4	104
Semi-Dense	CoReMatch-S(Ours)	57.4 / 72.8 / 83.7	177	22.8 / 42.7 / 60.6	95
Semi-Dense	CoReMatch-M(Ours)	58.2 / 73.3 / 84.0	335	24.4 / 44.2 / 61.7	161
Semi-Dense	CoReMatch-L(Ours)	59.5 / 74.4 / 84.8	639	27.9 / 49.1 / 66.6	366

Recent dense matching methods [9, 10] obtain subpixel correspondences through continuous regression and iterative refinement. However, they commonly rely on correlation volumes and multi-scale warping, which introduce substantial computational and memory overhead. These limitations motivate a central question: Can semi-dense matching produce accurate subpixel correspondences without high-resolution prediction grids or costly correlation-volume refinement?

In this work, we answer this question with CoReMatch (Coordinate Refinement Match), an efficient semi-dense feature matching framework designed for real-time robotic perception. Unlike existing semi-dense methods that formulate matching as discrete confidence prediction over feature grids, CoReMatch reformulates correspondence estimation as a recurrent continuous coordinate refinement problem. CoReMatch directly refines correspondences in coordinate space through persistent hidden-state updates, significantly reducing computational and memory overhead while preserving accurate sub-pixel localization. Specifically, CoReMatch adopts a two-stage recurrent refinement framework. At the coarse level, a Deep Aggregated Transformer (DAT) iteratively predicts and refines correspondences through direct coordinate updates while maintaining a persistent hidden state across iterations. This design enables efficient global geometric reasoning without explicit dense correlation-volume construction. The recurrent refinement process shares parameters across iterations, allowing the number of refinement steps to be dynamically adjusted at runtime based on hardware constraints or convergence behavior. At the fine level, a lightweight convolutional network performs local dense regression within small full-resolution windows for efficient sub-pixel refinement. By combining recurrent coordinate-space refinement with sparse computation, CoReMatch bridges the gap between efficient semi-dense matching and accurate dense correspondence estimation. Our contributions are summarized as follows:

A recurrent continuous refinement framework for efficient semi-dense feature matching. We formulate semi-dense matching as a recurrent continuous coordinate refinement problem, enabling accurate sub-pixel correspondence estimation without constructing a dense correlation volume. CoReMatch enables efficient geometric reasoning while reducing reliance on high-resolution feature maps. As a result, CoReMatch achieves higher accuracy at a lower input resolution ($448 \times448$) than Efficient LoFTR at substantially higher resolutions.

State-of-the-art accuracy–efficiency trade-offs with strong robotic generalization. We evaluate CoReMatch on multiple indoor and outdoor correspondence benchmarks, including MegaDepth [11], ScanNet [12], and HPatches [13]. CoReMatch consistently outperforms state-of-the-art semi-dense methods while achieving over $10 \times$ faster inference on embedded edge devices. Beyond benchmarks, CoReMatch improves robustness in downstream SLAM and VIO systems and demonstrates strong generalization to unseen environments and cross-modality RGB–infrared matching.

Method

Overview

CoReMatch formulates feature matching as a recurrent continuous coordinate refinement problem for efficient semi-dense correspondence estimation. As shown in Figure 2, the framework follows a coarse-to-fine pipeline. DAT handles global semantic correspondence reasoning, while the fine-level module focuses solely on local geometric and confidence refinement. Overall, this recurrent coordinate refinement design combines the efficiency of semi-dense matching with accurate sub-pixel localization, making it suitable for real-time deployment on embedded robotic platforms.

Coarse-Level Recurrent Coordinate Refinement

Correspondence Representation

Given an image pair $(I_A, I_B)$, CoReMatch first extracts low-resolution feature maps $F_A \in\mathbb{R}^{H \times W \times C}$ and $F_B \in\mathbb{R}^{H \times W \times C}$ using a shared feature encoder. Unlike existing semi-dense methods that formulate matching as discrete confidence prediction over spatial grids, we represent correspondences directly in continuous coordinate space. Specifically, each query location is associated with a continuous correspondence coordinate $\mathbf{x}_i = (u_i, v_i)$ in the target image together with a latent hidden state $\mathbf{h}_i$ that stores iterative geometric context during refinement.

We initialize a set of coarse query locations $Q = \{\mathbf{q}_i\}_{i=1}^{N}$ on the source feature map using a regular low-resolution grid. Initial correspondences are obtained through global feature similarity matching on the low-resolution features, producing continuous target coordinates $X^0 = \{\mathbf{x}_i^0\}_{i=1}^{N}$. Rather than discretizing matches onto feature cells, CoReMatch maintains continuous coordinate estimates throughout the entire refinement process. This representation enables sub-pixel correspondence estimation even from low-resolution feature maps while avoiding the discretization artifacts commonly observed in grid-based semi-dense matching methods.

Each correspondence hypothesis is iteratively refined through recurrent coordinate updates:

where $\Delta x_i^t$ denotes the coordinate update predicted at iteration $t$.

Recurrent Coordinate Update

Starting from the initial dense correspondence field $\mathcal{X}^0=\mathbf{x}*i^0*i=1^N$, CoReMatch performs iterative refinement directly in continuous coordinate space. Unlike existing dense correspondence methods that rely on local correlation volumes and multi-scale warping, our refinement uses recurrent hidden-state propagation without explicit correlation-volume search, substantially reducing computational and memory overhead while retaining iterative geometric refinement.

At iteration $t$, each correspondence hypothesis consists of a source location $\mathbf{q}_i$, a target coordinate estimate $\mathbf{x}_i^t$, and a latent hidden state $\mathbf{h}_i^t$. Given the current coordinate estimate, target features are sampled from the feature map $F_B$ using differentiable bilinear interpolation:

where $\phi(\cdot)$ denotes continuous feature sampling.

The sampled target feature, source feature, and previous hidden state are then processed by a recurrent Transformer update module:

where $\mathcal{T}(\cdot)$ shares parameters across refinement iterations. The updated hidden representation is used to predict a continuous coordinate offset:

followed by coordinate refinement:

The hidden state $\mathbf{h}_i^t$ is recurrently updated and propagated across iterations, enabling the model to accumulate geometric reasoning over time without constructing dense correlation volumes or performing multi-scale warping. As shown in Figure 3, three recurrent iterations at the $1/8$ feature scale are over $5\times$ faster than RoMa-style multi-scale refinement at $1/16$, $1/8$, and $1/4$ scales for $512\times512$ inputs, and over $8\times$ faster for $1024\times1024$ inputs.

Deep Aggregated Transformer

Attention plays a central role in Transformer-based feature matching by enabling global geometric reasoning. However, standard attention has quadratic complexity with respect to the number of tokens, making it prohibitively expensive for dense correspondence estimation at high resolutions. To improve efficiency, LoFTR adopts linear attention, while Efficient LoFTR introduces an Aggregated Attention Module (AAM), which computes attention over a compact set of aggregated tokens. Although AAM significantly reduces theoretical FLOPs, its practical efficiency on embedded platforms remains limited by repeated token aggregation and feature reconstruction operations across attention layers. These operations introduce substantial memory movement and kernel-launch overhead, which increasingly dominate runtime at high resolutions. As shown in Figure 4, the inference time of AAM grows rapidly for resolutions larger than $640\times640$, limiting its scalability for real-time robotic perception.

To address this limitation, we propose a Deep Aggregated Transformer (DAT), a memory-efficient architecture designed for recurrent coordinate refinement. Unlike Efficient LoFTR, DAT performs token aggregation only once at the Transformer input. The aggregated tokens are then processed by a deep Transformer operating entirely at the compact resolution, followed by a lightweight feature fusion block that combines intermediate and final Transformer features to recover spatial representations. This deep-and-narrow design substantially reduces intermediate memory traffic while preserving strong global reasoning capability. By avoiding repeated aggregation and reconstruction operations across attention layers, DAT achieves significantly better scalability on embedded platforms. As shown in Figure 4, DAT achieves over 4× lower inference time than AAM at 1024 × 1024 resolution.

Fine-Level Refinement

Existing semi-dense matching methods such as LoFTR and Efficient LoFTR perform fine-level refinement by computing local correlations within cropped feature patches around coarse correspondences. However, refinement is typically formulated as discrete confidence prediction over local feature grids, which inherently limits sub-pixel localization accuracy.

To address this limitation, we reformulate fine-level refinement as a local continuous regression problem. Specifically, we select the top-$N$ coarse correspondences according to matching confidence for fine-level refinement. For each selected correspondence, an $8 \times8$ local window is extracted from the fine-level feature maps, and the network directly predicts continuous coordinate offsets within the window. This formulation enables sub-pixel refinement directly in coordinate space without relying on discretized local matching grids. Since semantic correspondence estimation is largely resolved at the coarse stage, the fine-level module focuses mainly on local geometric refinement. As illustrated in Figure 2, the refinement network consists of three depthwise separable convolutional layers followed by a lightweight $1 \times1$ prediction head. The lightweight design introduces minimal computational overhead while preserving accurate sub-pixel localization, making it well suited for real-time robotic perception on embedded platforms.

Feature Representation

CoReMatch is backbone-agnostic and does not depend on a specific feature encoder. For real-time deployment, we use a lightweight PeleeNet-based backbone [14, 15], providing a strong speed–accuracy trade-off on embedded platforms. To evaluate generalization, we also integrate frozen DINOv2 [16, 17] features into the same refinement framework. The DINOv2-based variants achieve stronger performance than the lightweight CNN backbone on MegaDepth while substantially improving robustness across unseen domains and sensing modalities without fine-tuning, including indoor scenes, autonomous driving, UAV imagery, and RGB–infrared matching.

We further provide scalable variants under the same recurrent refinement framework. CoReMatch-S employs a lightweight CNN backbone with a single refinement iteration for maximum efficiency on embedded platforms. CoReMatch-M adopts a frozen DINOv2 ViT-S backbone with two refinement iterations for improved robustness and cross-domain generalization. CoReMatch-L further scales the framework using a DINOv2 ViT-L backbone with three refinement iterations for higher matching accuracy in challenging large-scale environments. All variants share the same recurrent coordinate refinement formulation, demonstrating that CoReMatch scales effectively from lightweight embedded deployment to high-capacity foundation-model-based robotic perception systems.

Training Objectives

CoReMatch is trained in a two-stage strategy. We first train the coarse-level matcher, after which its weights are frozen and the fine-level refiner is trained. Since both the coarse matcher and the fine-level refiner predict dense correspondence fields along with confidence scores, they share the same loss formulation.

The overall loss consists of a regression term and a confidence term:

where $\lambda= 0.01$ balances the two terms, following DKM and RoMa.

The confidence loss $\mathcal{L}_{\mathrm{conf}}$ is implemented using binary cross-entropy. For the regression loss $\mathcal{L}_{\mathrm{warp}}$, we adopt the generalized Charbonnier loss [18]:

where $c = 0.001$ controls the width of the quadratic region near zero.

Experiments

We evaluate CoReMatch on homography and relative pose estimation across diverse indoor and outdoor benchmarks. To assess downstream performance, we further evaluate visual odometry on four datasets. All evaluations use a single model trained exclusively on MegaDepth, enabling a direct assessment of zero-shot generalization. Finally, we conduct extensive ablation studies to analyze key architectural and training configurations.

Training Details

All models are trained on MegaDepth using the standard split [1, 10]. Training is performed on three NVIDIA A6000 GPUs with a batch size of 24 using AdamW [19]. The learning rate is set to $1 \times10^{-4}$ for the backbone and $3 \times10^{-4}$ for the matcher and refiner. Training uses a fixed resolution of $512 \times512$. Ablation models are trained for 30 epochs, while final models are trained for 100 epochs.

Relative Pose Estimation

Dataset and Evaluation Protocol. We evaluate relative pose estimation on MegaDepth [11] and ScanNet [12]. Predicted correspondences are rescaled to the original image resolution following DKM and RoMa. Relative poses are estimated from matches and evaluated using the maximum angular error between rotation and translation. We report AUC at 5°, 10°, and 20°. For LightGlue, runtime includes SuperPoint extraction (2048 keypoints).

Homography Estimation

We evaluate homography estimation on the HPatches dataset [13], which consists of planar image sequences captured under varying viewpoints and illumination conditions. Predicted correspondences are used to estimate homographies via RANSAC, and accuracy is measured by the mean reprojection error of corner points. We report the Area Under the Curve (AUC) at 3, 5, and 10 pixel thresholds. For fair comparison, all methods share the same RANSAC settings, and for semi-dense approaches only the top 1000 predicted matches are retained, following LoFTR. As shown in Table 2, our method demonstrates strong performance, significantly outperforming existing semi-dense approaches.

Method	AUC @3px	AUC @5px	AUC @10px
SuperGlue	53.9	68.3	81.7
LoFTR	65.9	75.6	84.6
DRC-Net	50.6	56.2	68.3
ELoFTR	66.5	76.4	85.5
EDM	68.5	78.1	86.6
CoReMatch-S	69.5	79.1	87.7
CoReMatch-M	70.3	79.7	88.0
CoReMatch-L	71.2	80.6	88.8
DKM	71.2	80.4	88.4
RoMa	70.6	79.9	88.2

Visual Odometry Evaluation

We integrate CoReMatch as the feature-matching frontend within PySLAM and evaluate its performance against LoFTR, EfficientLoFTR (ELoFTR), and CoReMatch-S using a unified backend pipeline. With identical system configurations across all methods, we report unaligned Absolute Trajectory Error (ATE RMSE, in meters) on challenging sequences from four diverse datasets: TUM [24] (fr1/desk), EuRoC [25] (V1_03_difficult), KITTI [26] (06), and TartanAir [27] (abandonedfactory/P001). As presented in Table 4, CoReMatch achieves the lowest ATE on three of the four sequences while remaining highly competitive on TUM. These results demonstrate that CoReMatch translates effectively to downstream visual odometry while maintaining strong trajectory accuracy.

Dataset	LoFTR	ELoFTR	CoReMatch	$\Delta$ vs. ELoFTR
TUM [24]	0.5931	0.5932	0.5934	-0.03%
EuRoC [25]	2.3859	2.2769	2.0673	+9.2%
KITTI [26]	10.5482	10.1711	6.9788	+31.4%
TartanAir [27]	35.0914	35.4660	33.7973	+4.7%

Ablation Studies

Contribution of Each Component

We conduct ablation studies to evaluate the contribution of each component in CoReMatch. The results are summarized in Table 3. Replacing ELoFTR’s discrete coarse matcher with a RoMa-style regression-based matcher substantially improves matching accuracy, but at a significant cost in inference efficiency. In contrast, our proposed coarse matcher further improves accuracy while maintaining efficient inference, and the fine-level refiner provides an additional improvement in accuracy with only a modest computational overhead.

Setup	Time	AUC
Baseline: ELoFTR-512	191.4	62.8
Coarse Matching Module
RoMa-style	408.3	68.5
RoMa-style (w/o correlation volume)	295.9	67.3
Ours (1 iteration)	158.6	68.9
Ours (2 iterations)	178.7	69.7
Fine-Level Refinement
Top-1 confidence (max)	98.9	69.1
Mutual nearest neighbor (MNN)	104.4	69.5
Feature Encoder
Our CNN encoder	72.9	70.0
DINOv2 ViT-S encoder	144.2	71.1

Comparison with Alternative Attention Mechanisms

In Table 5, we evaluate DAT against a WAFT-style [28] structure and two token-reduction techniques: Simple Compact Transformer (SCT) and Proxy-Token Attention [29] (PTA). DAT achieves the highest reprojection AUC@3px of 95.5%, substantially outperforming SCT (89.1%) and PTA (92.2%). Meanwhile, DAT maintains competitive efficiency, with an inference time of 4.6 ms, compared with 4.1 ms for SCT and 4.7 ms for PTA.

	DAT	WAFT [28]	SCT	PTA [29]
Reprojection AUC@3px (%) $\uparrow$	95.5	67.7	89.1	92.2
Inference Time (ms) $\downarrow$	4.6	19.3	4.1	4.7

Ablation of Refinement Iterations and Top-Confidence Ratio

As shown in Table 6, the first two refinement iterations yield substantial performance gains, while the third iteration provides only a marginal improvement. Regarding the top-$K$ ratio, performance remains relatively stable once the ratio exceeds 20%.

	Iteration				Top-$K$ Ratio (%)
	0	1	2	3	10	20	35	50
Reprojection AUC@3px (%) $\uparrow$	29.2	92.8	95.5	95.9	–	–	–	–
Relative Pose AUC@10 (%) $\uparrow$	–	71.0	71.6	71.7	67.4	70.5	71.6	71.6
Inference Time (ms) $\downarrow$	–	72.9	86.5	98.1	83.4	84.2	86.5	87.5

Limitations and Future Work

While CoReMatch achieves a strong accuracy–efficiency trade-off for real-time feature matching, several limitations remain and suggest promising directions for future work.

Hardware optimization. CoReMatch is primarily optimized for GPU-based platforms. Although its design reduces memory movement and refinement overhead, further optimization is needed for deployment on mobile and ultra-low-power platforms.

Training data and generalization. Although CoReMatch generalizes well across indoor, driving, UAV, and RGB–IR scenarios, its training still relies primarily on MegaDepth supervision. Larger-scale and more diverse training data could further improve robustness in challenging real-world conditions. Exploring more diverse correspondence supervision and self-supervised training could further reduce the dependence on curated geometric datasets.

Geometry-aware refinement. CoReMatch performs correspondence refinement through learned coordinate updates without explicitly incorporating geometric constraints. Integrating geometric priors, pose constraints, or temporal consistency could further improve performance in SLAM and visual odometry, particularly in challenging sequences with ambiguous or repetitive visual structures, where geometric consistency across frames becomes especially important.

Conclusion

We introduced CoReMatch, a semi-dense feature matching framework that replaces discrete grid-based confidence prediction with continuous coordinate-space refinement. CoReMatch combines a Deep Aggregated Transformer for global correspondence reasoning with a lightweight local regression module for precise refinement, achieving sub-pixel accuracy with substantially lower computational and memory costs than prior semi-dense methods.

Across standard benchmarks, CoReMatch achieves a strong accuracy–efficiency trade-off, consistently outperforming prior semi-dense methods while running over $10 \times$ faster on embedded hardware. Its integration with frozen foundation-model features further improves robustness across unseen indoor, driving, UAV, and visible–thermal scenarios without fine-tuning. These results demonstrate that accurate geometric correspondence can be achieved without high-resolution prediction grids or explicit correlation-volume construction, providing an efficient alternative to prevailing designs for semi-dense matching.

Acknowledgments

This work was supported by the Natural Sciences and Engineering Research Council of Canada (NSERC), Discovery Grants program.

Appendix: Additional Quantitative Results

Table 7 compares CoReMatch with ELoFTR and EDM across input resolutions in terms of relative pose estimation accuracy (AUC), inference time, and GPU memory consumption. At comparable accuracy levels, CoReMatch achieves substantially higher efficiency, running $2.2 \times$ faster than EDM and over $11 \times$ faster than ELoFTR, while reducing GPU memory consumption by more than $13 \times$ compared with ELoFTR.

CoReMatch is particularly effective at low-resolution inference, achieving comparable AUC at $448 \times448$ to ELoFTR at $800 \times800$. At the same $640 \times640$ input resolution, CoReMatch substantially outperforms both ELoFTR and EDM in accuracy (56.7 vs. 51.0 AUC) while requiring less inference time and GPU memory. These results demonstrate a substantially improved accuracy–efficiency trade-off, making CoReMatch well suited for real-time robotic perception on resource-constrained platforms.

Appendix: Qualitative Results

We qualitatively compare Efficient LoFTR (ELoFTR), EDM, and CoReMatch-M under challenging robotic perception scenarios, including motion blur, large viewpoint changes, repetitive structures, low-texture regions, and visible–thermal cross-modal matching. As shown in Figure 5 and Figure 6, CoReMatch produces more consistent and reliable correspondences across wide-baseline geometric scenes and substantial appearance and modality variations. On MegaDepth and ScanNet, CoReMatch maintains reliable correspondences under changes in illumination and scene content, whereas ELoFTR and EDM can produce accurate matches in one view but fail under such variations. On the challenging TartanAir scenarios, CoReMatch consistently produces more reliable correspondences than both baselines. These results demonstrate the robustness of CoReMatch-M to challenging appearance variations and cross-modal matching.

Failure Cases. As shown in Figure 7, CoReMatch’s failure cases typically occur under large viewpoint changes combined with textureless regions or repetitive and visually similar structures, where reliable correspondence becomes inherently ambiguous.

Related Work

Learning-Based Feature Matching

Classical feature matching pipelines typically consist of keypoint detection, descriptor extraction, and descriptor matching using handcrafted representations such as SIFT [30] and ORB [31]. While computationally efficient, these methods often struggle under large viewpoint changes, weak texture, and significant illumination variations. Learning-based approaches have substantially improved robustness by learning discriminative visual representations and leveraging global contextual reasoning. Early deep matching methods primarily focused on learning local descriptors or improving keypoint repeatability. SuperPoint [20] introduced self-supervised keypoint detection and description, while SuperGlue [21] incorporated graph neural networks and attention-based context aggregation for robust feature matching. LightGlue [22] further improved efficiency through adaptive Transformer inference.

More recently, semi-dense feature matching methods have gained popularity by eliminating explicit keypoint detection and directly establishing correspondences from dense feature maps. LoFTR [1] introduced Transformer [32]-based coarse matching followed by local fine refinement, achieving strong performance in low-texture regions. Subsequent works have improved efficiency and robustness through adaptive sparse attention and hierarchical refinement. QuadTree [6] hierarchically restricts attention to spatially relevant regions, while TopicFM [4] limits attention by grouping semantically similar features. ASpanFormer [3] introduced adaptive span attention for efficient long-range reasoning, while Efficient LoFTR [8] introduced Aggregated Attention Modules (AAM) to reduce Transformer complexity on high-resolution inputs. EDM [23] further improves efficiency using a lightweight CNN with correlation injection for multi-scale feature fusion.

Dense Correspondence Estimation

Dense correspondence estimation has been extensively studied in optical flow and dense image matching [9, 10, 28, 33, 34, 35]. RAFT [33] introduced recurrent all-pairs field transforms, iteratively refining dense flow fields through correlation volumes and recurrent updates. Subsequent methods have extended this paradigm toward higher-resolution and more memory-efficient correspondence estimation. More recently, RoMa [10] combined global Transformer-based matching with local correlation refinement and multi-scale warping, achieving strong dense matching performance. Several recent methods [28, 34] have sought to reduce reliance on explicit correlation volumes. In particular, WAFT [28] introduced Warping-Alone Field Transforms, demonstrating that iterative optical-flow refinement can achieve competitive performance using warping-based updates alone. Although WAFT reduces memory consumption, it relies on large pretrained foundation models and performs iterative updates on high-resolution feature maps, resulting in substantial runtime overhead.