Local feature matching

Overview

Local feature matching pairs points in two inputs that show the same point in the scene. The usual pipeline detects keypoints in each input, describes each one, and matches the descriptors 2104.00680 §1. Detector-free methods drop the detection step and predict matches over dense feature maps. Seven of the eight variants below produce correspondences, or a pose built from them, that a pose or localisation solver can consume 2104.00680 §1 2305.15404 §3.3 1304.3192 §6 2011.13005 §4.1 2004.11540 §3.3 2103.05465 §3.5 1910.12240 §3.2. The eighth uses learned matches inside a navigation policy, to choose waypoints and to decide when to stop 2402.12498 §4.2 2402.12498 §4.3.

The LoFTR card reports that detectors find too few repeatable points under poor texture, repetitive patterns, viewpoint or illumination change and motion blur. Indoors, low-texture regions can cover most of the view 2104.00680 §1. The PREDATOR card argues that, for low-overlap scans, the bottleneck is where interest points are chosen, not how each point is described 2011.13005 §1.

Each variant rests on one card, so each comparison rests on one paper's author-reported results. This page covers eight methods and not the full literature.

Variants

Detector-free, coarse-to-fine with Transformers (LoFTR)

The matcher runs in two stages. The coarse stage works on the 1/8 grid. A CNN with a feature pyramid gives coarse and fine maps, a 2-D sine encoding is added once, and the coarse features go through alternating self and cross attention 2104.00680 §3.1 2104.00680 §3.2. The attention uses a linear kernel, φ(x) = elu(x) + 1, so the cost is linear in the number of positions 2104.00680 §3.2. See linear attention.

The coarse matches come from one of two confidence heads. The dual-softmax head multiplies a softmax over each axis of the score matrix. The optimal-transport head runs Sinkhorn iterations with a learned score for unmatched positions 2104.00680 §3.3. See optimal transport. A match is kept when it is a mutual nearest neighbour and its confidence is at least 0.2 2104.00680 §3.3 2104.00680 §3.6.

The fine stage crops a 5×5 window around each coarse match on the 1/2 map, runs one fine self and cross round, and takes the expectation of a heatmap as the sub-pixel position 2104.00680 §3.4 2104.00680 §3.6. The variance of the heatmap is reported as the match's uncertainty 2104.00680 §3.5. Card: LoFTR: Detector-Free Local Feature Matching with Transformers.

Author-reported results, all from the card's tables:

• Homography on HPatches, 1K matches: LoFTR-DS reaches 65.9 AUC@3px against 53.9 for SuperPoint with SuperGlue 2104.00680 tab. 1.
• Indoor relative pose on ScanNet: LoFTR-DS reaches 40.8 AUC@10°, against 33.81 for SuperPoint with SuperGlue 2104.00680 tab. 2.
• Outdoor relative pose on MegaDepth: LoFTR-DS reaches 69.19 AUC@10°, against 61.16 for SuperPoint with SuperGlue 2104.00680 tab. 3.
• Visual localisation on Aachen Day-Night v1.1, local-feature track, night: LoFTR-DS is about level with SuperPoint with SuperGlue 2104.00680 tab. 4.

Frozen foundation features with a Transformer matcher and robust refinement (RoMa)

RoMa is a dense matcher with a coarse-to-fine design. It keeps the structure of DKM, which has no card here, and changes the encoders, the coarse decoder and both losses 2305.15404 §3.1 2305.15404 §4.2. The coarse features are the patch tokens of a frozen DINOv2 ViT-L/14, with no class token. The fine features come from a VGG19 pyramid at strides 1, 2, 4 and 8 2305.15404 §3.2 2305.15404 app. B.

A Gaussian-process encoder and a 5-block Transformer decoder predict, for each coarse pixel, a distribution over 64×64 anchors and one matchability logit 2305.15404 §3.3 2305.15404 eq. 8. The coarse warp is the arg-max anchor refined by a soft-argmax over its neighbours. Five convolutional refiners then move the warp from coarse to fine, with gradients detached between them 2305.15404 §3.1 2305.15404 app. B. See Gaussian process and dense correspondence.

The coarse stage is trained as classification over the anchor nearest the ground truth, plus a matchability term. Each refiner is trained with a generalised Charbonnier loss, because the authors argue that the refinement distribution is locally unimodal while the coarse one is often multimodal 2305.15404 §1 2305.15404 §3.4. The paper adds the two parts with no extra weighting, and it does not state the weight on the matchability term 2305.15404 §3.4. Training needs dense supervised correspondences from MVS depth or RGB-D data 2305.15404 §4.2. Card: RoMa: Robust Dense Feature Matching.

Author-reported results, all from the card's tables:

• WxBS v1.1, mAA at 10 px: 80.1, against 58.9 for DKM and 55.4 for LoFTR 2305.15404 tab. 4.
• IMC2022 hidden test set, mAA@10: 88.0, against 83.8 for ASpanFormer, the best prior entry in the table 2305.15404 tab. 3.
• MegaDepth-1500, AUC@10°: 76.7, against 74.9 for DKM and 69.2 for LoFTR 2305.15404 tab. 5.
• ScanNet-1500, AUC@10°, with the model trained on ScanNet: 53.4, against 50.7 for DKM and 40.8 for LoFTR 2305.15404 tab. 6.
• Ablation on the authors' validation pairs: 100-PCK at 1 px falls from 17.0 for the retrained DKM to 13.1 for RoMa 2305.15404 tab. 2. These pairs come from MegaDepth scenes that may overlap the test set, so the ablation may not be a clean held-out result 2305.15404 §4.1 2305.15404 §4.3.

Cost: at 560×560, batch 8, on an RTX6000, RoMa takes 198.8 ms per pair against 186.3 ms for DKM, about 7% more 2305.15404 §4.5. The paper gives no memory figure, and no RoMa timing against LoFTR, so compare on your own hardware.

Detector-based pipelines (the baselines)

The paper compares against detect-then-match pipelines such as SuperPoint with SuperGlue, D2-Net, R2D2, DISK and ORB with GMS 2104.00680 §4.1 2104.00680 §4.2. No card exists for these methods, so this page uses only the numbers that the LoFTR paper reports for them.

Hand-designed 3D surface descriptors (RoPS)

RoPS recognises 3D objects in scenes with clutter and occlusion. It works on mesh triangles 1304.3192 §3.1. For each feature point it builds a local reference frame (LRF) from the scatter matrix of the triangles inside a sphere of radius r. Each axis is sign-fixed by a weighted first-moment test, and the second axis follows from a right-handed cross product 1304.3192 §3.1 1304.3192 §3.2.

The descriptor rotates the neighbouring points about each LRF axis, projects them onto three planes, and counts points in a 5×5 grid per projection. From each normalised grid it keeps four central moments and the entropy. With three rotations per axis, that gives 135 numbers 1304.3192 §4.1 1304.3192 tab. 2. Recognition proposes each pose from a single correspondence, then clusters the proposals and refines them with ICP 1304.3192 §6. The single-correspondence design depends on LRF repeatability, which the paper measures only on its tuning set 1304.3192 §3.3. Card: Rotational Projection Statistics for 3D Local Surface Description and Object Recognition.

Author-reported results, all from the card's text and tables:

• Bologna, 45 scenes, noise 0.1 to 0.5 mesh resolution: 100% at every noise level 1304.3192 §7.1.
• UWA, 50 scenes, Rhino excluded: 98.9% overall. Recognition is 100% up to 80% occlusion and 93.1% at 85% 1304.3192 §7.2.
• Queen's: 95.4% on the 80-scene set and on the 55-scene subset 1304.3192 tab. 6.
• Ca' Foscari, 18 models: 99% precision and 96% recall 1304.3192 §7.4 1304.3192 tab. 7.

Learned overlap-aware point selection for 3D registration (PREDATOR)

PREDATOR registers two point clouds that share only a small surface. The two encoders share weights. An overlap-attention block in the bottleneck lets the two clouds exchange information, and the decoder outputs a descriptor per point together with two separate per-point scores, overlap and matchability 2011.13005 §3.3 2011.13005 §3.4. The descriptor is 32-dimensional on 3DMatch 2011.13005 tab. 7.

At test time, interest points are drawn without replacement, with probability proportional to overlap times matchability. RANSAC then estimates the transform 2011.13005 §4.1 2011.13005 tab. 1. Training uses ground-truth correspondences for three losses: a circle loss on the descriptors, and binary cross-entropy on the overlap and matchability scores 2011.13005 §3.5.

Author-reported results:

• 3DLoMatch (10-30% overlap), registration recall at 5000 samples: 59.8%, against 40.1% for FCGF and 37.2% for D3Feat 2011.13005 tab. 2.
• 3DMatch at 5000 samples: 89.0%, against 85.1% for FCGF 2011.13005 tab. 2.
• Sampling on 3DLoMatch at 5000 samples: top-k over the overlap-matchability product gives a higher inlier ratio than the probabilistic choice (33.7% against 26.7%) but lower registration recall (58.5% against 59.8%) 2011.13005 tab. 1.

Cost: 30 epochs on 3DMatch at batch size 1 2011.13005 app. A.3. About 271 ms per fragment pair on a GTX 1080 Ti, of which about 191 ms is data loading 2011.13005 tab. 11. Card: PREDATOR: Registration of 3D Point Clouds with Low Overlap.

Learned inlier filtering with a differentiable pose solver (Deep Global Registration)

This variant keeps the detect-describe-match front end and changes what is done with its output. Each point gets a fully convolutional descriptor (FCGF, from prior work with no card here). Each point in the first scan is matched to its nearest neighbour in feature space 2004.11540 §3.1 2004.11540 §3.2. A U-Net-shaped 6-D convolutional network then scores every putative match, with the match written as the point pair in R^6, and predicts an inlier probability 2004.11540 §3.2 2004.11540 fig. 2.

Scores below a clip threshold are set to zero, and the rest enter a closed-form weighted Procrustes solve 2004.11540 §3.3. A robust refinement on SE(3) follows, with the matches held fixed 2004.11540 §4.2. A safeguard checks the fraction of weight that survives the clip. When that fraction is below τ_s = 0.05, the method falls back to RANSAC or branch-and-bound 2004.11540 §4. Card: Deep Global Registration.

Author-reported results on 3DMatch, 5 cm voxels, on a GTX 1080Ti 2004.11540 §5.1:

• Recall 91.3%, TE 7.34 cm, RE 2.43°, in 1.21 s. RANSAC with 8M iterations reaches 74.9% in 4.55 s, and FGR reaches 42.7% in 0.31 s 2004.11540 tab. 1.
• Without the safeguard the recall is 85.2% 2004.11540 tab. 1.
• On KITTI, with 30 cm voxels, the method reaches 96.9% recall and 98.0% with ICP. The FCGF row of the same table reaches 98.2% 2004.11540 tab. 3.

Its timings include feature extraction 2004.11540 tab. 1.

Learned spatial consistency with seeded spectral fits (PointDSC)

PointDSC also filters putative matches from a fixed descriptor, but it judges each match against the others rather than on its own. Two correspondences that are both correct keep the same distance between their two points in both scans. A nonlocal attention block uses that rule: feature similarity is multiplied by a length-consistency term, which is zero when the length changes by more than σ_d 2103.05465 §3.2 2103.05465 eq. 1 2103.05465 eq. 2. An MLP on the output gives each match an initial confidence, and non-maximum suppression picks well-spread seeds, capped at 10% of the input at test time 2103.05465 §3.3 2103.05465 §4.

For each seed, the k = 40 nearest neighbours in feature space, not in 3-D, form a subset 2103.05465 §3.4 2103.05465 §4. A compatibility matrix built from the length term and a learned feature term has a leading eigenvector whose entries serve as inlier weights. A weighted SVD fit then gives one rigid hypothesis per seed 2103.05465 §3.4 2103.05465 eq. 3 2103.05465 eq. 5. The hypothesis with the most matches inside the inlier threshold τ is kept 2103.05465 §3.5 2103.05465 eq. 6. The result is refined by reweighting the inliers, for at most 20 rounds 2103.05465 app. Post-refinement.

Training labels each match as an inlier from the true pose. The loss sums a binary cross-entropy on the initial confidence and a squared error on the compatibility targets, which are 1 only when both matches are inliers 2103.05465 §3.6 2103.05465 eq. 7 2103.05465 eq. 8 2103.05465 eq. 9. The paper uses Adam with learning rate 1e-4, 100 epochs, batch size 16 and 1,000 sampled matches per pair, with λ = 3 2103.05465 §4. Card: PointDSC: Robust Point Cloud Registration using Deep Spatial Consistency.

Author-reported results, from the card's tables:

• 3DMatch with FCGF, 5 cm voxels, τ = 10 cm: registration recall 93.28%, against 91.30% for DGR and 91.50% for RANSAC with 100k iterations 2103.05465 tab. 1.
• Same setting, 0.09 s per pair against 1.36 s for DGR and 5.50 s for RANSAC with 100k iterations 2103.05465 tab. 1. The text gives about 60 times against RANSAC with 100k iterations 2103.05465 §5.1.
• 3DMatch with FPFH, same model and not fine-tuned: 78.50%, against 69.13% for DGR and 73.57% for RANSAC with 100k iterations 2103.05465 tab. 1.
• KITTI with FPFH, re-trained, TE below 60 cm and RE below 5°: 98.20%, against 89.37% for RANSAC with 100k iterations and 77.12% for DGR re-trained. Time is 0.31 s against 13.7 s 2103.05465 tab. 2.
• 3DLoMatch: the appendix reports FCGF rising from 35.7 to 52.0 when PointDSC is added 2103.05465 app. 3DLoMatch.
• Ablation on 3DMatch: the spatial term lifts the classifier-head recall from 83.30% to 88.17% 2103.05465 tab. 4. Removing the spectral loss lowers the full model from 93.28% to 92.61% 2103.05465 tab. 5.

Cost: 89.5 ms per 3DMatch pair with about 5,000 matches, of which 62.0 ms is the nonlocal encoder. The timing comes from an 8-core Xeon E5-2620 with a GTX 1080 Ti 2103.05465 app. Time complexity. The attention is a full N-by-N matrix in every block, so cost grows quickly with the match count.

Limits: gains shrink with fewer than about 500 matches 2103.05465 app. 3DLoMatch. Large symmetric surfaces such as walls and floors can produce 90° or 180° rotation errors when outlier clusters dominate 2103.05465 app. Qualitative Results 2103.05465 fig. 7.

Learned soft keypoint matching with iterated SVD (PRNet)

PRNet aligns two partial point clouds without labelled correspondences. Each pass embeds both clouds with a DGCNN, then passes the two embeddings through one Transformer encoder and one decoder so that each cloud sees the other 1910.12240 §3.2. It takes the k points with the largest feature norm in each cloud as keypoints, and the paper states no supervision for them 1910.12240 eq. 9 1910.12240 §4.3. A value head predicts a temperature from the pooled features. Gumbel-Softmax at that temperature gives a keypoint-to-keypoint matrix that is one-hot in the forward pass, with a straight-through gradient 1910.12240 eq. 10 1910.12240 eq. 11. The matched keypoints give a rigid motion through the closed-form SVD fit 1910.12240 eq. 2 1910.12240 eq. 8. The source is moved and the pass repeats, with three passes in the paper's training setting and a discount factor below 1 on later passes 1910.12240 eq. 7 1910.12240 eq. 12. The iterative loop is the same idea as iterative closest point, with learned keypoints and matching in place of nearest neighbours.

Training is self-supervised. Each pair is a partial crop of one object, moved by a random rigid motion whose true value serves as the label 1910.12240 §4.1. The loss sums a motion term, a cycle-consistency term and a feature-alignment term 1910.12240 eq. 13 1910.12240 eq. 14 1910.12240 eq. 15. Matching is sampled at test time too, so the released code's predictions depend on the random seed, and the paper does not say whether it averaged over samples model.py. Card: PRNet: Self-Supervised Learning for Partial-to-Partial Registration.

Author-reported results, all on synthetic motions:

• ModelNet40, unseen point clouds: rotation MSE 10.235 for PRNet against 45.005 for DCP-v2, and the best value in all eight columns of the table 1910.12240 tab. 1.
• Unseen categories: rotation MSE 24.857 against 95.431 for DCP-v2. FGR has lower rotation MAE (1.952 against 2.329) and translation MAE (0.007 against 0.015) 1910.12240 tab. 2.
• Gaussian noise: rotation MSE 18.691 against 47.378 for DCP-v2 1910.12240 tab. 3.
• Real scans: qualitative only. The model was fine-tuned for 10 epochs on 100 synthetic examples per scan 1910.12240 §4.2.
• Keypoint choice: random keypoints give rotation MAE 1.689, against 1.454 for the norm-based choice 1910.12240 supp. (a).
• Timing per pair at 1024 points: 0.073 s for PRNet against 0.024 s for DCP-v2 1910.12240 supp. Efficiency.

Learned matches as goal checks in image-goal navigation (FeudalNav)

This variant does not estimate a pose. An agent is shown a goal image and must walk to the place it shows. The paper uses SuperGlue, a learned matcher on detected keypoints, in three places 2402.12498 §4.1 2402.12498 §4.2 2402.12498 §4.3:

• A view joins the cluster of earlier views whose match confidence is highest, if that confidence is above ψ = 0.7, and otherwise starts a new cluster 2402.12498 §4.1 2402.12498 §5.2.
• When the current view matches the goal image with confidence above β = 0.7, the mean of the matched keypoints replaces the predicted waypoint 2402.12498 §4.2 2402.12498 §5.2.
• Between two environment steps, a crop around the waypoint is matched again to re-locate it. The agent stops when the goal-match confidence is above β and the depth at the centre of the matched keypoints is at most 1 m 2402.12498 §4.3.

The card does not measure matching accuracy on its own. It also leaves the confidence aggregation over keypoints undefined 2402.12498 §4.2, and it does not say how the centre used for the stopping depth is computed 2402.12498 §4.3. The reported results are navigation success and SPL on Gibson, averaged over difficulty bands. Stacked FeudalNav reaches 40.50 success on curved paths, against 23.97 for NRNS without noise 2402.12498 tab. 2. Card: Feudal Networks for Visual Navigation.

When to use which

The table gives the constraints the cards' results address. All numbers are author-reported, and each row compares only the numbers from its own card.

Implementation sketch

Pseudocode for the LoFTR inference path, with the coarse and fine steps. The shapes and constants come from the paper, and the code defaults are noted where the paper does not state them. The RoPS card gives pseudocode for its LRF, descriptor and recognition loop, and the PREDATOR card gives pseudocode for overlap attention, its losses and the overlap-weighted sampling. The Deep Global Registration card gives pseudocode for the whole filter-and-solve pipeline. The common core of that family is: score each putative match, zero the weak scores, then solve a weighted pose 2004.11540 alg. 1. The PointDSC card gives pseudocode for seeded hypotheses and for its loss. It differs by fitting one pose per seed, not one pose overall 2103.05465 §3.4 2103.05465 §3.6. The PRNet card gives pseudocode for one pass, its SVD fit and its discounted training loss 1910.12240 §3.2.

# Coarse-to-fine dense matching, one image pair  [arxiv:2104.00680 §3.1-§3.4]
def match(image0, image1):
    # Coarse map at 1/8 and fine map at 1/2 of the image side  [§3.1]
    coarse0, fine0 = backbone(image0)
    coarse1, fine1 = backbone(image1)
    # One 2-D sine encoding per image, then flatten to token sequences  [§3.2]
    coarse0 = flatten(coarse0 + pos_encoding(coarse0))
    coarse1 = flatten(coarse1 + pos_encoding(coarse1))
    # Alternate self and cross linear attention, N_c = 4 times  [§3.2] [§3.6]
    for kind in ["self", "cross"] * 4:
        if kind == "self":
            coarse0 = attend(coarse0, coarse0)
            coarse1 = attend(coarse1, coarse1)
        else:
            coarse0 = attend(coarse0, coarse1)
            coarse1 = attend(coarse1, coarse0)  # reads updated coarse0
    # Dual-softmax confidence over all coarse pairs; tau not stated  [§3.3]
    # tau: not stated in the paper; code uses 0.1  [code: src/config/default.py#L30]
    scores = coarse0 @ coarse1.T / tau
    conf = softmax_rows(scores) * softmax_cols(scores)
    # Keep mutual nearest neighbours with confidence >= 0.2  [§3.3] [§3.6]
    coarse_matches = mutual_nearest(conf) & (conf >= 0.2)
    points = []
    for (i, j) in coarse_matches:
        # 5x5 window around each coarse match on the 1/2 map  [§3.4] [§3.6]
        w0 = crop(fine0, centre=i, size=5)
        w1 = crop(fine1, centre=j, size=5)
        # One fine self and cross round, then a heatmap from the window centre  [§3.6]
        w0, w1 = fine_round(w0, w1)
        heat = softmax(w1 @ w0[centre] / sqrt(d_fine))
        # Sub-pixel offset: expectation of the heatmap  [§3.4]
        points.append((pos(i), pos(j) + expectation(heat)))
    return points

Contradictions

Disagreements between papers, and within the cards' papers, each side cited.

• Cross-family numbers. The seven variants are scored on different tasks: image pose, homography and warp accuracy (LoFTR, RoMa), recognition rate on object scenes (RoPS), registration recall on scan pairs (PREDATOR), registration recall with TE and RE thresholds (Deep Global Registration), rotation and translation error on synthetic ModelNet40 pairs (PRNet), and navigation success and SPL on Gibson (FeudalNav). No card reports another card's benchmark, so the numbers above are not comparable across variants 2104.00680 tab. 2 2305.15404 tab. 4 1304.3192 tab. 6 2011.13005 tab. 2 2004.11540 tab. 1 2103.05465 tab. 1 1910.12240 tab. 1 2402.12498 tab. 2. PointDSC's registration recall uses the same TE and RE thresholds as DGR, but its KITTI rows use a different setting from the DGR card's KITTI row 2103.05465 §5.2 2004.11540 tab. 3.
• DGR numbers in two papers. PointDSC's table gives DGR 91.30% recall, 7.48 cm TE, 2.40° RE and 1.36 s on 3DMatch with FCGF 2103.05465 tab. 1. The DGR card gives 91.3% recall, 7.34 cm, 2.43° and 1.21 s on the same benchmark 2004.11540 tab. 1. The cards do not say why the timing and error differ. Compare the two papers' DGR rows with that in mind.
• PointDSC paper and released code. The paper sets σ_d to 60 cm for outdoor scenes 2103.05465 §4. The KITTI release config and test script use 1.2 m config.json test_KITTI.py. The paper also sets λ = 3, while the released configs use 1.0 for both weights 2103.05465 eq. 10 config.json. The 3DMatch release runs 50 epochs, against 100 in the paper config.json. Reimplementing from the paper alone may not reproduce the table.
• RoMa paper and released code. The paper sets the Charbonnier scale c = 0.03 2305.15404 §3.4. The training script sets c = 1e-4 on normalised grid coordinates train_roma_outdoor.py. The paper's kernel has inverse temperature 10 2305.15404 app. A. The code's T = 0.2 gives an inverse temperature of 5 under the form the code uses roma_models.py matcher.py. The training split and the augmentation also differ: the paper uses DKM's split, and the code uses LoFTR's split with horizontal flips 2305.15404 §4.2 train_roma_outdoor.py. The training script is marked untested, and as written it passes an argument that the model constructor does not take train_roma_outdoor.py encoders.py. Reimplementing from the paper alone may not reproduce the table.
• PRNet paper and released code. The code divides the matching logits by sqrt(d_k), while the paper's logits are unscaled 1910.12240 eq. 10 model.py. The code clamps the predicted temperature to [0.01, 100], a range the paper does not state 1910.12240 §3.2 model.py. For the backward pass, the paper uses the DCP softmax gradient 1910.12240 §3.2, while the code uses PyTorch's Gumbel-Softmax straight-through gradient model.py. Reimplementing from the paper alone may not reproduce the table.
• RoPS baselines use its own frame. For spin image, NormHist, LSP and THRIFT the paper replaces their LRF with its own, so the comparison tests the descriptor and the new LRF together 1304.3192 §7.1.
• RoPS abstract against body. The abstract gives 96.0% on Ca' Foscari. The body reports 99% precision and 96% recall, and the abstract figure matches the recall rather than the precision 1304.3192 §7.4 1304.3192 tab. 7. This page quotes the body.
• PREDATOR headline numbers. The arXiv abstract in our metadata gives 89%, while the LaTeX source gives 90.6%. The table gives 89.0% at 5000 samples and 90.6% at 1000 samples on 3DMatch 2011.13005 tab. 2. This page quotes the 5000-sample value.
• PREDATOR paper and released code. The paper adds the matchability loss after a few epochs. The released code keeps its weight at zero until validation recall passes 0.3 2011.13005 §3.5 trainer.py. The code also computes the matchability loss only on overlap points loss.py, while the paper sums over all points 2011.13005 eq. 11.
• Ablation against the main table. The ablation text says OT matching is used, but the Full row does not match the OT row of the main ScanNet table 2104.00680 tab. 6 2104.00680 tab. 2. Compare ablation rows only with each other.
• InLoc claim against its table. The text says LoFTR-OT outperforms all published methods on InLoc. In the table, SuperPoint with SuperGlue scores higher at DUC1 0.25 m and DUC2 0.5 m 2104.00680 §4.3 2104.00680 tab. 5.
• Border setting. The ScanNet result depends on the border-removal setting. The released code's note gives 40.8 without it, and 39.5 with it loftr_ds_eval_new.py.
• Paper and released code (LoFTR). The released code differs from the paper in the optimiser, the coarse loss, the fine-loss weighting and the positional encoding 2104.00680 §3.2 2104.00680 §3.5 2104.00680 §3.6 default.py. Reimplementing from the paper alone may not reproduce its numbers.
• Speed claims in the Deep Global Registration paper. The caption of its timing table says the method is as fast as FGR. The text says it is about twice as fast as RANSAC with 2M iterations 2004.11540 §5.1. The table gives 1.21 s for the method, 0.31 s for FGR and 1.39 s for RANSAC with 2M iterations 2004.11540 tab. 1. This page quotes the table.
• ICP in the 3DMatch row. The paper does not say whether its 3DMatch row includes ICP. The released code runs point-to-point ICP after every registration deep_global_registration.py, and its README gives the paper's 3DMatch figures README.md. The KITTI row differs slightly: the paper gives 3.46 cm TE for "Ours + ICP", and the README gives 3.14 cm 2004.11540 tab. 3 README.md.

Papers

• LoFTR: Detector-Free Local Feature Matching with Transformers: a detector-free matcher with a coarse dense stage and a sub-pixel fine stage, using dual-softmax or optimal-transport heads.
• RoMa: Robust Dense Feature Matching: a dense matcher with frozen DINOv2 coarse features, VGG19 fine features, an anchor-classification Transformer decoder and a robust refinement loss.
• Rotational Projection Statistics for 3D Local Surface Description and Object Recognition: a hand-designed 3D surface descriptor with a sign-fixed local reference frame and a 135-number descriptor, recognised through single correspondences.
• PREDATOR: Registration of 3D Point Clouds with Low Overlap: overlap attention with learned overlap and matchability scores, used to choose points for registering low-overlap scans.
• Deep Global Registration: a 6-D convolutional inlier filter over putative matches, a differentiable weighted Procrustes solve and a robust SE(3) refinement, with a RANSAC fallback.
• PointDSC: Robust Point Cloud Registration using Deep Spatial Consistency: a nonlocal attention block with a length-consistency term, seeded neural spectral matching and one weighted rigid fit per seed, used to prune outlier correspondences.
• PRNet: Self-Supervised Learning for Partial-to-Partial Registration: self-supervised keypoint selection and Gumbel-Softmax matching, with a closed-form SVD pose applied over repeated passes.
• Feudal Networks for Visual Navigation: SuperGlue matches used to cluster views, to replace a waypoint with a goal match and to decide when to stop, inside a three-level navigation policy.