# Source Registry — C3 — Cross-domain matcher candidates

> Mode A Phase 2 — engine Step 2 (Source Tiering & Exhaustive Web Investigation).
> Critical-novelty sensitivity per Step 0.5 in `../00_question_decomposition.md`. Time windows applied:
> - **Lead-candidate / SOTA claims**: prefer sources within last 6 months; up to 18 months if older is the official authority.
> - **Library/SDK API behaviour**: must reflect the currently shipped version at search time (`context7` mandatory per lead candidate).
> - **Established baselines** (KLT, RANSAC, EKF, ORB, SIFT, GTSAM): no time window.
>
> This file replaces a section of the previous monolithic `01_source_registry.md`. See `00_summary.md` for the full category index. Investigation order is tracked in `../00_question_decomposition.md` and the cross-category Investigation Status table in `00_summary.md`.

---

### Source #69
- **Title**: LightGlue — `context7` per-mode capability lookup (`/cvg/lightglue`, main) — High source reputation, benchmark score 85.4, 64 code snippets indexed
- **Link**: context7 query against `/cvg/lightglue`, accessed 2026-05-08; canonical doc references returned: `https://context7.com/cvg/lightglue/llms.txt`, snippets `Initialize LightGlue Feature Matcher`, `LightGlue - Feature Matcher Initialization`, `Initialize SuperPoint Feature Extractor`, `Initialize and Use DISK Feature Extractor`, `Initialize and Use SIFT Feature Extractor`, `Perform Feature Matching with LightGlue`, `Complete Matching Pipeline Example`, `Initialize and Use SuperPoint + LightGlue Matcher`, `Extract Matched Keypoint Coordinates`
- **Tier**: L1 (project-official codebase by canonical LightGlue authors Philipp Lindenberger + Paul-Edouard Sarlin + Marc Pollefeys, ETH Zurich + Microsoft Mixed Reality & AI Lab; `context7` indexed at `/cvg/lightglue` with High reputation, benchmark 85.4, 64 code snippets — confirms this is a widely-adopted reference implementation)
- **Publication Date**: live docs (main HEAD, accessed 2026-05-08)
- **Timeliness Status**: ✅ Within Critical-novelty window (active main + community evidence through 2025–2026 — see Source #73 LightGlue-ONNX changelog with January 2026 entries; HuggingFace Transformers integration mentioned in canonical README confirms continued active distribution)
- **Version Info**: main HEAD at access time. **Mode-enumeration query (1/3) PASS** — all five extractor modes documented as first-class `features` enum values: `superpoint` (256-D descriptors, MagicLeap pretrained), `disk` (128-D, Apache-2.0 weights), `aliked` (128-D, BSD-3-Clause), `sift` (128-D, includes scale + orientation, classical), `doghardnet` (128-D, includes scale + orientation). Construction signature: `LightGlue(features: str, n_layers: int = 9, depth_confidence: float = 0.8, width_confidence: float = 0.9, filter_threshold: float = 0.1, flash: bool = False, mp: bool = False)`. **NOTE — version skew between context7 docstring and canonical README defaults**: context7 docstring says `depth_confidence=0.8` and `width_confidence=0.9`; canonical README §"Advanced configuration" says `depth_confidence=0.95, disable with -1` and `width_confidence=0.99, disable with -1` and `flash=True (LightGlue automatically detects if FlashAttention is available)`. The canonical README values are authoritative for the live source. PyTorch ≥2.0 enables `matcher.compile(mode='reduce-overhead')` for additional speedup (with caveat: for inputs <1536 keypoints compiles but disables point pruning; for larger inputs falls back to eager mode with point pruning).
- **Target Audience**: System architects + C3 implementer + Step-7.5 reviewer
- **Research Boundary Match**: **Full match** for the project's pinned C3 mode (SuperPoint feature extractor + LightGlue matcher in single-pair single-image-pair inference mode on GPU, with `feats_q = extractor.extract(image_q)`, `feats_t = extractor.extract(image_t)`, `matches_qt = matcher({'image0': feats_q, 'image1': feats_t})` followed by `rbd()` to remove batch dimension). The canonical pipeline and the rbd helper handle asymmetric image-pair sizes (UAV nadir 5472×3648 vs satellite tile of any size at 0.5 m/px) since each image is independently extracted before matching. **Open**: `context7` Disqualifier-Probe query did not surface ONNX/TensorRT export paths inside the cvg/lightglue repo itself — those are documented in the companion `fabio-sim/LightGlue-ONNX` project (Source #73), which the canonical README explicitly links to. Did not surface Jetson-specific latency/memory measurements (similarly to all C2 candidates — Jetson MVE phase will resolve).
- **Summary**: Confirms LightGlue's per-mode API surface and runnable example for single-pair feature matching: each `(features, matcher)` extractor-matcher tuple is a separately-cataloged sibling mode per the Per-Mode API rule. Confirmed five sibling modes via `features=` enum: SuperPoint+LightGlue, DISK+LightGlue, ALIKED+LightGlue, SIFT+LightGlue, DoGHardNet+LightGlue. Canonical inference signature is `matcher({'image0': feats0, 'image1': feats1})` returning `{matches0, matches1, matching_scores0, matching_scores1, matches: List[[K,2]], scores: List[[K]], stop: int}`; `rbd(x)` helper removes the batch dimension to extract single-pair tensors. The `points0 = feats0['keypoints'][matches[..., 0]]` and `points1 = feats1['keypoints'][matches[..., 1]]` extraction pattern produces 2D-2D correspondences directly consumable by the project's downstream C4 PnP+RANSAC pose estimator. Performance configuration knobs documented: `depth_confidence`, `width_confidence`, `filter_threshold`, `flash`, `mp`, `n_layers`, `compile()`. **Open**: cross-domain (UAV nadir × ortho satellite) recall numbers absent from context7-indexed snippets (concentration on phototourism/visual-localization benchmarks); aerial-domain validation requires Jetson MVE on AerialExtreMatch + Derkachi flight per D-C3 deferred phase.
- **Related Sub-question**: SQ3+SQ4 / C3 — LightGlue per-mode API capability verification (Mandatory `context7` lookup per Per-Mode API Capability Verification rule)


### Source #70
- **Title**: LightGlue canonical implementation — `cvg/LightGlue` (Lindenberger, Sarlin, Pollefeys — ICCV 2023) — official PyTorch reference implementation, README + LICENSE, demo notebook (`demo.ipynb`), benchmark script (`benchmark.py`), training/eval framework reference (companion `cvg/glue-factory`); pretrained weights for SuperPoint + DISK + ALIKED + SIFT + DoGHardNet local features; HuggingFace Transformers integration (`pip install transformers`, model card `ETH-CVG/lightglue_superpoint`); kornia integration (`kornia.feature.LightGlue` and `kornia.feature.LightGlueMatcher`); hloc integration for Structure-from-Motion + visual localization; LightGlue-ONNX export project (Source #73)
- **Link**: README https://raw.githubusercontent.com/cvg/LightGlue/main/README.md (accessed 2026-05-08); LICENSE https://raw.githubusercontent.com/cvg/LightGlue/main/LICENSE (accessed 2026-05-08); repo https://github.com/cvg/LightGlue ; HuggingFace model card https://huggingface.co/ETH-CVG/lightglue_superpoint ; companion training framework https://github.com/cvg/glue-factory ; companion ONNX export https://github.com/fabio-sim/LightGlue-ONNX (Source #73); kornia API https://kornia.readthedocs.io/en/latest/feature.html#kornia.feature.LightGlue
- **Tier**: L1 (project-official codebase by the canonical LightGlue authors Philipp Lindenberger + Paul-Edouard Sarlin + Marc Pollefeys, ETH Zurich + Microsoft Mixed Reality & AI Lab; same author group as `cvg/Hierarchical-Localization` (hloc), `cvg/glue-factory`, `cvg/pixel-perfect-sfm`)
- **Publication Date**: README live; main HEAD active through 2024–2026 (HuggingFace Transformers integration is recent — `@sbucaille` credited; LightGlue-ONNX companion has January 2026 entries per Source #73); canonical paper ICCV 2023
- **Timeliness Status**: ⚠️ Borderline — paper Jun 2023 / ICCV 2023 is at the edge of the Critical-novelty 18-month window for SQ3+SQ4 component selection; **HOWEVER**, LightGlue is treated as the SOTA sparse matcher reference baseline in every modern (2024–2026) feature-matching paper, the algorithmic content is stable, the canonical implementation is actively maintained (HuggingFace Transformers integration adds plug-and-play API), the LightGlue-ONNX project (Source #73) is actively maintained through January 2026 with FP8 quantization workflow added, and Berton+Trivigno's `gmberton/auto_VPR` companion harness for the C2 row also explicitly evaluates SP+LightGlue as the C3 reference matcher. Per the engine's Established-baseline exemption applicable to widely-adopted reference algorithms, LightGlue's canonical role is the sparse-matcher SOTA reference point for the C3 row; freshness concerns are on (a) emerging successors that improve on LightGlue (XFeat 2024, XFeat* 2024, SuperGlue/LightGlue successor candidates), (b) aerial-domain transfer of canonical phototourism-trained weights (same caveat as C2 candidates' aerial-domain training caveat — D-C3-1 raised by this closure)
- **Version Info**: main HEAD; PyTorch (≥2.0 recommended for FlashAttention auto-detection + `compile()` support); installation via `git clone && pip install -e .`; canonical inference five-line pipeline shown in README (loads `LightGlue + SuperPoint/DISK/SIFT/ALIKED/DoGHardNet` from the `lightglue` package); `lightglue.utils.load_image` returns `torch.Tensor[3, H, W]` normalized to [0,1]; `lightglue.utils.rbd` removes batch dimension; `lightglue.match_pair(extractor, matcher, image0, image1)` is a one-call convenience method; `lightglue.viz2d.{plot_images, plot_keypoints, plot_matches, save_plot}` for visualization. **Default LightGlue construction parameters per canonical README** (authoritative over context7 docstring): `n_layers=9` (all layers), `flash=True` (auto-detected when available), `mp=False`, `depth_confidence=0.95` (disable with -1), `width_confidence=0.99` (disable with -1), `filter_threshold=0.1`. **Reported benchmark numbers (canonical README + paper)**: 150 FPS @ 1024 keypoints on RTX 3080 (= ~6.7 ms per pair, with compilation + adaptivity); 50 FPS @ 4096 keypoints on RTX 3080 (= 20 ms per pair); 4–10× speedup over SuperGlue depending on input difficulty; 20 FPS @ 512 keypoints on Intel i7 10700K CPU (= ~50 ms per pair, CPU baseline). **License**: **Apache-2.0** for cvg/LightGlue code AND for cvg/LightGlue's pre-trained weights AND for the bundled DISK weights (DISK is published under Apache-2.0). **CRITICAL CAVEAT** for the SuperPoint-extractor-mode: the SuperPoint pretrained weights AND its inference file `lightglue/superpoint.py` follow `magicleap/SuperPointPretrainedNetwork`'s **separate, restrictive license** — see Source #72 for the full license text. ALIKED is published under **BSD-3-Clause**; SIFT is patent-free since 2020 in OpenCV, classical algorithm with no weight-licensing concern. 4.7k+ stars at canonical repo
- **Target Audience**: System architects + C3 implementer + Step-7.5 reviewer + license-posture decision-maker (D-C1-1 + D-C3-1 NEW)
- **Research Boundary Match**: **Full match** for the project's pinned C3 mode (single-image-pair sparse feature matching: take a UAV nadir frame + a retrieved satellite tile, run feature extraction on each independently, match via LightGlue, return 2D-2D correspondences with confidence scores feeding the project's downstream C4 PnP+RANSAC pose estimator). The repo ships everything needed: extractor classes (`SuperPoint, DISK, ALIKED, SIFT, DoGHardNet`), matcher class (`LightGlue`), I/O utilities (`load_image, rbd, match_pair`), visualization (`viz2d`), benchmark tooling (`benchmark.py`). **Asymmetric image-pair sizes are handled natively**: each image is independently fed through `extractor.extract(...)` which auto-resizes to the extractor's preferred resolution (default 1024 on longest edge for SuperPoint), then matched — the matcher operates on (keypoint coords, descriptor vectors) tuples that are size-independent. **Partial match** for the project's domain (canonical training on synthetic homographies of Oxford-Paris 1M distractors + fine-tuning on MegaDepth phototourism — neither dataset is aerial nadir; **NO aerial nadir benchmark** in the canonical paper, **same aerial-domain caveat as the C2 candidates**; aerial applicability is referenced transitively via Zhang et al. 2022 ISPRS [paper ref [83]], but explicit aerial-nadir validation is project-side via Jetson MVE on AerialExtreMatch + Derkachi flight)
- **Summary**: LightGlue is the canonical reference implementation of the ICCV 2023 paper "LightGlue: Local Feature Matching at Light Speed" by Lindenberger, Sarlin, Pollefeys. **CRITICAL LICENSE FINDING**: LICENSE file is **Apache-2.0** (Copyright 2023 ETH Zurich) — permissive; this places LightGlue ITSELF on the **BSD/permissive license track** alongside MixVPR (MIT) + SelaVPR (MIT) + NetVLAD-canonical (MIT) + EigenPlaces (MIT) + Kimera-VIO (BSD-2) + OKVIS2 (BSD-3) + DPVO (MIT) + pure-VO baseline (OpenCV-Apache-2.0). DISK (the second extractor mode) is also Apache-2.0 per the canonical README. ALIKED is BSD-3-Clause. SIFT is classical patent-free in OpenCV. **HOWEVER, the SuperPoint pretrained weights AND the `lightglue/superpoint.py` inference file follow `magicleap/SuperPointPretrainedNetwork`'s license — see Source #72** — which is "ACADEMIC OR NON-PROFIT ORGANIZATION NONCOMMERCIAL RESEARCH USE ONLY". This is a **HARD DISQUALIFIER** for the canonical SP+LightGlue pinned mode in the project's commercial/dual-use deployment context (eastern/southern Ukraine fixed-wing UAV is explicitly dual-use military per the project disqualifier "anything whose license blocks military / dual-use deployment"). **License-track summary**: cvg/LightGlue itself = Apache-2.0 (BSD/permissive track, no commercial restriction); SP weights = Magic Leap restrictive (NOT BSD/permissive, blocks commercial/dual-use); DISK weights = Apache-2.0; ALIKED weights = BSD-3-Clause; SIFT = classical no-license-concern. **Plan-phase decision raised** (will be tagged D-C3-1): swap canonical SP+LightGlue for one of: (a) DISK+LightGlue (Apache-2.0 throughout, paper Table 6+7 demonstrates DISK+LightGlue often outperforms SP+LightGlue on Image Matching Challenge benchmarks); (b) ALIKED+LightGlue (BSD-3-Clause + Apache-2.0); (c) re-train a SuperPoint-class extractor under permissive license (e.g., kornia's reproduction OR retrain on aerial nadir corpus); (d) accept Magic Leap noncommercial-research license for the project's research/development phase only with explicit Plan-phase commitment to swap before production deployment. Multiple downstream integration points documented: (i) **HuggingFace Transformers** — `pip install transformers` plug-and-play with `ETH-CVG/lightglue_superpoint` model card (separate license terms inherited from HuggingFace + Magic Leap stack); (ii) **kornia** — `kornia.feature.LightGlue` and `kornia.feature.LightGlueMatcher` interfaces; (iii) **hloc** — Structure-from-Motion + visual localization toolbox; (iv) **LightGlue-ONNX** — ONNX/TensorRT/OpenVINO/FP16/FP8 export project (Source #73); (v) **Image Matching WebUI** — comparison harness. **Performance**: **150 FPS @ 1024 keypoints on RTX 3080** with compilation + adaptivity (= ~6.7 ms per pair) and **50 FPS @ 4096 keypoints on RTX 3080** (= 20 ms per pair). **Adaptive depth and width** (paper §3.3) reduce inference time by ~33% at <1% loss of accuracy on common workloads (paper Table 11 ablation). At the project's expected per-frame 2 image-pair load (UAV-nadir → top-1 satellite tile after C2 retrieval, possibly 2-5 pairs if K=5–10 top-K reranking), Jetson Orin Nano Super extrapolation factor 4-6× of RTX 3080 baseline → **~30–60 ms per pair @ 1024 keypoints** at fp16 + TensorRT; **~80–120 ms per pair @ 2048 keypoints**. Additional speedups available via LightGlue-ONNX (Source #73) up to FP8 quantization (factor ~2× over fp16). **Architecture**: 9 transformer layers (self-attention + cross-attention per layer), 4 attention heads per unit, descriptor dimension d=256; rotary positional encoding (relative, applied at each self-attention); soft partial assignment matrix combining similarity + matchability scores; bidirectional cross-attention saves ~33% time; deep supervision (loss at every layer, stops early when confident). **Training**: pre-train on synthetic homographies of Oxford-Paris 1M distractors (170k images, 6M image pairs, 2 days on 2 RTX 3090) + fine-tune on MegaDepth phototourism (368/5/24 train/val/test scenes, 50 epochs, 2 days on 2 RTX 3090, 32 image pairs per batch with gradient checkpointing). **Modern lineage / successors**: ALIKED+LightGlue, DoGHardNet+LightGlue (added to canonical repo post-paper); XFeat (CVPR 2024 — separately-cataloged C3 candidate per Fact #26 NGPS template confirmed; documented to outperform LightGlue on speed at slightly lower accuracy); MASt3R (separately-cataloged but pruned by Fact #26 due to dense-matcher latency on Jetson)
- **Related Sub-question**: SQ3+SQ4 / C3 — LightGlue per-mode API capability verification (Mandatory `context7` lookup PASS — `/cvg/lightglue` indexed with High source reputation and benchmark score 85.4; cross-validated against canonical README + LICENSE WebFetch + canonical paper WebFetch [Source #71])


### Source #71
- **Title**: LightGlue canonical paper — "LightGlue: Local Feature Matching at Light Speed" (Lindenberger, Sarlin, Pollefeys — ICCV 2023, arXiv:2306.13643)
- **Link**: arXiv https://arxiv.org/abs/2306.13643 (Jun 2023); ICCV 2023 published version (citation booktitle = ICCV); accessed 2026-05-08
- **Tier**: L1 (peer-reviewed ICCV 2023 + canonical implementation cross-referenced; **most-cited modern sparse matcher paper of the post-SuperGlue era**, treated as the SOTA sparse-matcher reference baseline in every 2024–2026 feature-matching paper)
- **Publication Date**: arXiv preprint 2023-06-23; ICCV 2023 acceptance October 2023
- **Timeliness Status**: ⚠️ Borderline — paper Jun 2023 is at the edge of the Critical-novelty 18-month window for SQ3+SQ4; **HOWEVER**, the Established-baseline exemption applies (LightGlue is the canonical sparse-matcher reference baseline, like NetVLAD is for VPR), the algorithmic content is stable, the canonical implementation is actively maintained (HuggingFace Transformers integration recent), and 2024–2026 successor candidates (XFeat, XFeat*) explicitly position themselves as LightGlue alternatives in the same paper space. Freshness concerns are (a) successor candidates that improve on LightGlue (XFeat 2024 separately-cataloged), (b) aerial-domain weights (the project's D-C3-1 + same caveat as C2 candidates)
- **Version Info**: arXiv v1 (Jun 2023, ICCV camera-ready); paper §3 architecture + §3.3 adaptive depth/width + §4 training recipe + §5 experiments + Appendix A IMC 2020/2021/2023 + Appendix B MegaDepth-1800 / Aachen v1.1 / InLoc + Appendix C implementation details + Appendix D timing breakdowns
- **Target Audience**: System architects + C3 implementer + Step-7.5 reviewer
- **Research Boundary Match**: **Full match** for the algorithm (sparse feature matching with adaptive-depth + adaptive-width transformer pruning, soft partial assignment matrix combining similarity + matchability, bidirectional cross-attention, rotary positional encoding); **partial match** for the project's domain (paper benchmarks: HPatches homography estimation [§5.1, planar scenes with illumination + viewpoint changes], MegaDepth-1500 + MegaDepth-1800 relative pose estimation [§5.2 + Appendix B, outdoor phototourism], Aachen Day-Night + Aachen v1.1 outdoor visual localization [§5.3 + Appendix B, urban day/night], InLoc indoor visual localization [Appendix B], Image Matching Challenge 2020/2021/2023 [Appendix A, phototourism]; **NO aerial nadir benchmark** in the canonical paper). **Critical paper reference [83]**: paper §1 Related work cites "Zhang et al. ISPRS Journal of Photogrammetry and Remote Sensing 2022 — Feature matching for multi-epoch historical aerial images" as documentary evidence that "SuperGlue generalizes well to aerial matching" — by transitive lineage (LightGlue is the SuperGlue successor with documented 4-10× speedup), this provides weak documentary evidence that LightGlue is similarly applicable to aerial matching, but **NOT explicit aerial-nadir validation**.
- **Summary**: The canonical paper introduces **LightGlue = a deep neural network for sparse feature matching that is faster, more accurate, and easier to train than SuperGlue**, with the central novelty being **adaptivity to image-pair difficulty** (paper §3.3): (a) **adaptive depth** — predict a confidence score per point per layer; halt the inference at any layer if a sufficient ratio α (default 95%) of points are confident; (b) **adaptive width** — discard at each layer the points that are confidently predicted as both confident and unmatchable (paper Eq. 13: `unmatchable(i) = c_i^l > λ_l & σ_i^l < β` with β=0.01); these two mechanisms reduce inference time by **~33% on average** (paper §5.4 + Table 5: 1.86× speedup on easy pairs, 1.16× on hard pairs, 1.45× average) at <1% accuracy loss. **Architecture (paper §3.1 + §3.5 + Appendix C.1)**: stack of L=9 transformer layers, each with one self-attention + one cross-attention unit; descriptor dimension d=256; 4 attention heads per unit; **rotary positional encoding** [Su et al. 2023 RoFormer reference [67]] applied to query+key in self-attention only (NOT cross-attention) with a learned 2D Fourier basis; **bidirectional cross-attention** that computes the similarity matrix only once per layer (saves ~33% time vs full cross-attention per Appendix D); **soft partial assignment matrix** P combining pairwise similarity scores `S_{ij} = Linear(x_i^A)^T Linear(x_j^B)` and unary matchability scores `σ_i = Sigmoid(Linear(x_i))` via `P_{ij} = σ_i^A · σ_j^B · Softmax_k(S_{kj})_i · Softmax_k(S_{ik})_j` (Eq. 8); **filter threshold τ=0.1** (Eq. 8 + Appendix C.4) — pairs (i,j) yield correspondence when `P_{ij} > τ` AND `P_{ij}` is the row-max AND column-max. **Reported headline performance**: **HPatches homography estimation (Table 1, SuperPoint+LightGlue, 1024 keypoints)** R=94.3 / P=88.9 (best precision among sparse matchers, +1.5 over SuperGlue 87.4); AUC-DLT@5px=78.6 (vs SuperGlue 76.7, vs SGMNet 76.0; competitive with dense LoFTR 70.6). **MegaDepth-1500 relative pose estimation (Table 2, SuperPoint+LightGlue with LO-RANSAC)** AUC@5°/10°/20°=66.7/79.3/87.9 (vs SuperGlue 65.8/78.7/87.5; vs LoFTR 66.4/78.6/86.5 — competitive with dense matcher at fraction of inference time); inference time **44.2 ms** standard / **31.4 ms adaptive**. **Aachen Day-Night visual localization (Table 3, SuperPoint+LightGlue with hloc + NetVLAD top-50 retrieval)** Day (0.25m,2°)/(0.5m,5°)/(1.0m,10°) = **89.2/95.4/98.5**, Night = **87.8/93.9/100**, **17.2 pairs/sec** (26.1 optimized) — competitive with SuperGlue at 2.5–4× higher throughput. **CRITICAL OBSERVATION FOR THE PROJECT**: the Aachen Day-Night benchmark (Table 3) directly demonstrates the **NetVLAD top-K retrieval → SP+LightGlue matching → PnP+RANSAC pose estimation** pipeline, which is **exactly the project's intended pipeline shape** (C2 NetVLAD/MixVPR/SelaVPR/EigenPlaces top-K retrieval → C3 SP+LightGlue match → C4 PnP+RANSAC). The reported pose accuracies and throughput are documentary evidence that the chosen architectural pattern is canonical and well-validated in the visual-localization community. **Indirect aerial evidence (paper §1 Related work + ref [83])**: paper cites "Zhang et al. 2022 ISPRS" as evidence that SuperGlue generalizes well to aerial matching; LightGlue inherits this generalization by being the strict successor. **Image Matching Challenge benchmarks (Appendix A, Tables 6+7)**: SP+LightGlue beats SP+SuperGlue both in IMC 2020 stereo (AUC@5°=59.03 vs 58.64) and IMC 2021 phototourism (50.2 / 62.6 vs SuperGlue 49.9 / 62.2); **DISK+LightGlue beats SP+LightGlue** by +8% / +5% AUC on stereo / multi-view (IMC 2020), with ~30% more matches at higher epipolar precision — **important Plan-phase signal that DISK+LightGlue is competitive with SP+LightGlue and may be preferable when the SuperPoint license is the binding constraint**. **Adaptive variant** at IMC 2023 (Appendix A): SP+LightGlue 38.4 / 46.1 public/private (vs SP+SuperGlue 36.1 / 43.8 — +2.3% improvement). **Ease of training**: paper §4 + Figure 5 — LightGlue reaches SuperGlue parity in **5M image pairs (~2 GPU-days)** vs SuperGlue's 7+ days; **fits 32 image pairs on 24 GB VRAM** with gradient checkpointing + mixed precision. **License (canonical implementation): Apache-2.0** (per Source #70 LICENSE) — permissive, BSD/permissive license track; SuperPoint pretrained weights are Magic Leap noncommercial-research only (Source #72 disqualifier).
- **Related Sub-question**: SQ3+SQ4 / C3 — LightGlue per-mode API capability verification (cross-source verification of the canonical implementation's mode/parameter/training-recipe/Recall@K + AUC + throughput claims; Aachen Day-Night benchmark Table 3 documentary evidence for the project's intended pipeline shape NetVLAD top-K → SP+LightGlue → PnP+RANSAC; aerial-domain caveat documented; D-C3-1 SuperPoint license disqualifier raised)


### Source #72
- **Title**: SuperPoint pretrained weights LICENSE — `magicleap/SuperPointPretrainedNetwork` LICENSE — "ACADEMIC OR NON-PROFIT ORGANIZATION NONCOMMERCIAL RESEARCH USE ONLY" Software License Agreement; binding on the SuperPoint weights AND on the `lightglue/superpoint.py` inference file used by `cvg/LightGlue` for the SP+LightGlue mode
- **Link**: https://raw.githubusercontent.com/magicleap/SuperPointPretrainedNetwork/master/LICENSE (accessed 2026-05-08); repo https://github.com/magicleap/SuperPointPretrainedNetwork
- **Tier**: L1 (canonical Magic Leap LICENSE file controlling the SuperPoint pretrained weights distribution)
- **Publication Date**: SuperPoint paper CVPR 2018 Workshop (DeTone, Malisiewicz, Rabinovich); LICENSE file timestamps within Magic Leap's repo HEAD
- **Timeliness Status**: ✅ Authoritative — license terms are owned by Magic Leap and do not have a freshness window concern; the binding is permanent and applies to every distribution of the SuperPoint pretrained weights including the copy in `cvg/LightGlue`
- **Version Info**: SuperPoint pretrained network checkpoint distributed by Magic Leap; bundled into `cvg/LightGlue` as `lightglue/superpoint.py` + the embedded weights (per cvg/LightGlue README §License)
- **Target Audience**: Step-7.5 reviewer + license-posture decision-maker (D-C1-1 + D-C3-1 NEW — license-track gate for SuperPoint-extractor-mode adoption in dual-use commercial deployment)
- **Research Boundary Match**: **Full match** for the license restriction analysis (the Magic Leap LICENSE is the binding instrument controlling SuperPoint weight redistribution in `cvg/LightGlue`'s SP+LightGlue mode)
- **Summary**: Magic Leap's SuperPoint LICENSE is **NOT a permissive open-source license**. It is a noncommercial-research-only Software License Agreement between Magic Leap (Licensor) and the user (Licensee, an academic institution OR non-profit organization OR self-individual). The key restrictions are: (a) **PERMITTED USES**: "for your own noncommercial internal research purposes" — the Software (= SuperPoint weights + inference code + any derivatives) may NOT be used for commercial purposes; (b) **DERIVATIVES**: "all and any such derivatives and modifications will be owned by Licensor and become a part of the Software licensed to You under this Agreement" — modifications are auto-owned by Magic Leap, restricting downstream redistribution; (c) **USES NOT PERMITTED**: "You may not distribute, copy or use the Software except as explicitly permitted herein. You may not sell, rent, lease, sublicense, lend, time-share or transfer, in whole or in part, or provide third parties access to prior or present versions (or any parts thereof) of the Software"; (d) **EXPORT REGULATION**: Licensee must comply with U.S. export control + OFAC embargo/sanction programs — note that fixed-wing UAV deployment in eastern/southern Ukraine in active-conflict context likely interacts with U.S. export controls + Russia/Ukraine/Crimea sanctions specifics (independent legal analysis required); (e) **GOVERNING LAW**: Florida (Broward County) — non-negotiable jurisdiction. **PROJECT IMPACT**: the GPS-Denied Onboard project's question_decomposition.md hard disqualifier is "anything whose license blocks military / dual-use deployment"; the Magic Leap LICENSE explicitly blocks commercial use AND blocks distribution. The project's deployment context (fixed-wing UAV in active-conflict Ukraine, AC-NEW-2 spoofing-promotion path explicitly deals with hostile electromagnetic warfare) is **dual-use military** by every reasonable interpretation. Therefore the canonical Magic Leap SuperPoint pretrained weights AND `lightglue/superpoint.py` inference code are **HARD DISQUALIFIED** for the project's commercial / dual-use deployment context. **Mitigation paths** (for D-C3-1 Plan-phase Choose block): (a) DISK+LightGlue (Apache-2.0 throughout) — paper Table 6 shows DISK+LightGlue stereo AUC@5°=67.02 vs SP+LightGlue 59.03 (+7.99 absolute) — DISK+LightGlue is **demonstrably superior on phototourism** to SP+LightGlue; (b) ALIKED+LightGlue (BSD-3-Clause + Apache-2.0); (c) re-train a SuperPoint-class extractor under permissive license — kornia has a SuperPoint reproduction (`kornia.feature.SuperPoint`) but its weights' license must be independently verified at Plan-phase (LightGlue-ONNX Source #73 also distributes its own SuperPoint+LightGlue ONNX weights — which inherit the Magic Leap restriction by transitive lineage); (d) accept Magic Leap noncommercial-research license for the project's R&D phase only with explicit Plan-phase commitment to swap before production deployment (legally risky — internal research could still be construed as commercial preparation given the dual-use deployment intent). **Recommendation: D-C3-1 = (a) DISK+LightGlue is the cleanest license-compliant alternative; per paper Table 6 it's also the strongest phototourism alternative**. ALIKED+LightGlue is the second-cleanest BSD-3-Clause + Apache-2.0 option but lacks the IMC 2020 / 2021 / 2023 documentary phototourism benchmarks that DISK+LightGlue has.
- **Related Sub-question**: SQ3+SQ4 / C3 — SuperPoint pretrained weights license restriction analysis (License-track gate for the SP+LightGlue canonical mode); applies to D-C1-1 license posture interaction; raises NEW **D-C3-1 SuperPoint-replacement-strategy choice (DISK+LightGlue / ALIKED+LightGlue / SuperPoint-reproduction-with-permissive-license / accept-Magic-Leap-noncommercial-with-swap-commitment)** Plan-phase decision


### Source #73
- **Title**: LightGlue-ONNX — `fabio-sim/LightGlue-ONNX` (Sim, fabio-sim) — Open Neural Network Exchange compatible implementation of LightGlue + SuperPoint (and DISK) end-to-end pipeline; supports TensorRT, OpenVINO, FP16 mixed precision, FP8 Q/DQ quantization (NVIDIA ModelOpt — January 2026 addition); FlashAttention-2 fused ONNX models; MultiHead-Attention fusion optimization; ArgMax → TopK trick for ~30% speedup; Kornia integration as `kornia.feature.OnnxLightGlue`; CLI `lightglue-onnx` with `export | infer | trtexec` commands; canonical reference for Jetson/edge/embedded LightGlue deployment
- **Link**: README https://raw.githubusercontent.com/fabio-sim/LightGlue-ONNX/main/README.md (accessed 2026-05-08); repo https://github.com/fabio-sim/LightGlue-ONNX ; FP8 quantization blog post https://fabio-sim.github.io/blog/fp8-quantized-lightglue-tensorrt-nvidia-model-optimizer/ ; ONNX Runtime + TensorRT inference blog post https://fabio-sim.github.io/blog/accelerating-lightglue-inference-onnx-runtime-tensorrt/ ; Kornia integration https://kornia.readthedocs.io/en/latest/feature.html#kornia.feature.OnnxLightGlue
- **Tier**: L2 (third-party canonical ONNX export project — most-cited LightGlue ONNX deployment reference in the modern feature-matching deployment community as of 2026; explicitly endorsed by `cvg/LightGlue` README "Other links" section as the canonical TensorRT/OpenVINO export path; Kornia integration confirms broader community adoption)
- **Publication Date**: Initial commit Jun 2023 (one week after `cvg/LightGlue` paper publication); active maintenance through January 2026 (most recent changelog entry: "19 January 2026: Add FP8 quantization workflow"); 1k+ stars
- **Timeliness Status**: ✅ Fully within Critical-novelty window (active main + January 2026 changelog entries on FP8 quantization and refurbished CLI UX with modern uv)
- **Version Info**: main HEAD; CLI `lightglue-onnx` with three commands: `export` (pipeline ONNX export with `--num-keypoints N`, `-b 2 -h 1024 -w 1024` static-shape parameterization), `infer` (ONNX Runtime inference with `-d cuda|tensorrt|openvino|cpu` provider selection, `--fp16` mixed-precision flag), `trtexec` (Polygraphy-based pure TensorRT inference with `--fp16` flag); legacy export path available via `--legacy-export` flag; FP8 quantization workflow via `lightglue_dynamo/scripts/quantize.py --quantize-mode fp8 --dq-only --simplify` produces FP8 Q/DQ ONNX models with `--precision-constraints prefer --fp16` TensorRT inference; uv-based dependency management (`uv sync` for inference-only; `uv sync --group export` for export support; `uv sync --group trt` for TensorRT CLI). **Performance evolution**: 28 Jun 2023 — initial end-to-end SP+LightGlue export; 11 Jul 2023 — mixed precision; 13 Jul 2023 — Flash Attention; 19 Jul 2023 — TensorRT support; 04 Oct 2023 — MultiHead-Attention fusion + Fused LightGlue ONNX with FlashAttention-2 (up to **80% faster inference** on long sequences); 27 Oct 2023 — Kornia integration; 02 Nov 2023 — TopK trick optimizes out ArgMax (~30% speedup); 17 Jul 2024 — end-to-end parallel dynamic batch size support; 09 Jan 2026 — modern uv UX refresh; 19 Jan 2026 — FP8 quantization workflow via NVIDIA ModelOpt
- **Target Audience**: System architects + C3 implementer + C7 (Jetson runtime) implementer + Step-7.5 reviewer
- **Research Boundary Match**: **Full match** for the project's pinned C3 Jetson deployment runtime question (LightGlue's TensorRT export path on Jetson Orin Nano Super at fp16 + INT8/FP8 + ONNX Runtime). The project's C7 row will inherit the choice between PyTorch-fp16, Torch-TensorRT, ONNX Runtime + TensorRT EP, or pure TensorRT — LightGlue-ONNX is the canonical reference for the latter three options. **Partial match** for the project's domain (this project's repository targets phototourism / general-purpose visual-localization, NOT aerial nadir specifically; the same aerial-domain caveat as `cvg/LightGlue` applies — D-C3-1 Plan-phase decision)
- **Summary**: LightGlue-ONNX is the canonical third-party ONNX/TensorRT/OpenVINO deployment path for `cvg/LightGlue`. **Critical findings for the C3 + C7 deployment gates**: (a) **End-to-end SP+LightGlue + DISK+LightGlue ONNX pipeline export** with static-shape parameterization (e.g., `-b 2 -h 1024 -w 1024 --num-keypoints 1024`) — image dimensions and keypoint count are baked in at export time; dynamic-shape support added 17 Jul 2024 for parallel batch sizes; (b) **TensorRT 8.5+ support on Jetson** is feasible — the `lightglue-onnx trtexec` CLI uses Polygraphy as the TensorRT runner, which is well-documented on JetPack; FP16 mixed-precision is the default and recommended Jetson configuration; (c) **FP8 quantization workflow** (Jan 2026 addition) via NVIDIA ModelOpt's Q/DQ insertion produces FP8 ONNX models that, when run with TensorRT `--precision-constraints prefer --fp16`, achieve **~2× speedup over fp16 baseline** on Hopper/Ada/Blackwell GPUs (paper reference: NVIDIA ModelOpt FP8 documentation) — **but Jetson Orin Nano Super has Ampere architecture, NOT FP8-native; FP8 path is Plan-phase deferred for Jetson and applies only if the project upgrades to a Jetson Orin Super (Ampere with FP8 NOT supported) or if the FP8 graph falls back to INT8 quantization on Ampere via TensorRT's transparent precision-emulation (verification required at Jetson MVE phase)**; (d) **FlashAttention-2 fused ONNX** (Oct 2023) with up to 80% faster inference on long-keypoint sequences via `onnxruntime>=1.16.0` — applies to the project's pinned 1024-keypoint extraction; (e) **TopK trick** (Nov 2023) optimizes out ArgMax for ~30% speedup — applies transparently after re-export; (f) **OpenVINO support** for Intel-CPU/iGPU deployment — not directly applicable to Jetson but useful for offline-PC pre-flight cache provisioning (C10 row); (g) **Kornia integration** via `kornia.feature.OnnxLightGlue` interface — drop-in replacement for `kornia.feature.LightGlue` when ONNX deployment is preferred. **Documented inference-time comparison** (linked blog post): on RTX-class GPUs the ONNX/TensorRT path achieves **3-5× speedup** over the canonical PyTorch path at fp16; FP8 path adds another ~2× on FP8-native architectures; Ampere/Jetson Orin Nano Super FP8 emulation factor is unverified (Jetson MVE phase). **License**: not explicitly checked in this fetch; repo README does not cite a LICENSE file in the visible header — Plan-phase verification gate (similar to D-C2-8 Nanne PyTorch port license-uncertainty caveat). **Acknowledged dependencies**: ONNX, TensorRT, ONNX Runtime, OpenVINO, NVIDIA ModelOpt (FP8), Polygraphy. **Project relevance**: this project's C7 (Jetson runtime) row will likely choose between PyTorch-fp16 (lowest engineering cost, highest deployment footprint), Torch-TensorRT (medium engineering cost, Jetson-friendly), ONNX Runtime + TensorRT EP via LightGlue-ONNX (medium engineering cost, well-documented Jetson pathway), or pure TensorRT via `trtexec` + Polygraphy (highest engineering cost, lowest deployment footprint, Jetson-friendly) — LightGlue-ONNX is the canonical reference for options 3 and 4.
- **Related Sub-question**: SQ3+SQ4 / C3 + C7 — LightGlue Jetson deployment runtime evidence (cross-source confirmation that LightGlue has a documented, actively-maintained TensorRT/ONNX/OpenVINO/FP8 export path; the project's C7 row will reference this source when the inference-runtime decision is closed at Plan-phase); also raises **D-C3-2 LightGlue inference runtime choice (PyTorch-fp16 / Torch-TensorRT / ONNX Runtime + TensorRT EP / pure TensorRT via trtexec + Polygraphy / FP8 ModelOpt-on-Jetson if Ampere FP8 emulation works)** Plan-phase decision


### Source #74
- **Title**: ALIKED canonical implementation — `Shiaoming/ALIKED` (Zhao et al. IEEE T-IM 2023) — official PyTorch reference implementation, README + LICENSE (BSD-3-Clause), `demo_pair.py` + `demo_seq.py` runnable demos, four pretrained model variants distributed in-tree under `models/` (`aliked-t16` tiny / `aliked-n16` normal / `aliked-n16rot` rotation-augmented normal / `aliked-n32` higher-SDDH-sample-count normal), `custom_ops/build.sh` legacy CUDA extension build (NOT used by the cvg/LightGlue port — the port replaced `custom_ops` with `torchvision.ops.deform_conv2d` directly per Source #70 `lightglue/aliked.py` lines 39 + 336–344, removing the build-from-source requirement)
- **Link**: README https://raw.githubusercontent.com/Shiaoming/ALIKED/main/README.md (accessed 2026-05-08); LICENSE https://raw.githubusercontent.com/Shiaoming/ALIKED/main/LICENSE (accessed 2026-05-08); repo https://github.com/Shiaoming/ALIKED ; cvg/LightGlue's ALIKED port `lightglue/aliked.py` https://raw.githubusercontent.com/cvg/LightGlue/main/lightglue/aliked.py (BSD-3-Clause inherited from Shiaoming/ALIKED canonical, with explicit author + license attribution in the file header lines 1–33)
- **Tier**: L1 (project-official codebase by the canonical ALIKED authors Xiaoming Zhao + Xingming Wu + Weihai Chen + Peter C. Y. Chen + Qingsong Xu + Zhengguo Li, Beihang University + University of Macau + National University of Singapore + A*STAR Singapore; same author group as `Shiaoming/ALIKE` (T-MM 2022, the predecessor network), 1.4k+ stars at canonical repo, IEEE Transactions on Instrumentation & Measurement 2023 publication)
- **Publication Date**: ALIKED paper IEEE T-IM April 2023 (DOI 10.1109/TIM.2023.3271000); canonical repo HEAD active (cvg/LightGlue port added the four-variant `aliked-t16/n16/n16rot/n32` interface post-publication via `lightglue/aliked.py`)
- **Timeliness Status**: ✅ Within Critical-novelty window (April 2023 — modern competitive ground for sparse-extractor reference; widely-adopted reference implementation across modern feature-matching deployment community); cvg/LightGlue's ALIKED port itself is actively maintained on the cvg/LightGlue main branch
- **Version Info**: main HEAD at access time. **Mode-enumeration query (1/3) — context7 NOT INDEXED + WebFetch fallback PASS** — `context7 resolve-library-id` returned no relevant matches for "ALIKED" (Supabase / Vitest / AI SDK / Mastra / Better Auth top-results, indicating no `Shiaoming/ALIKED` library entry in the context7 index); per Per-Mode API Capability Verification rule item 2, fall-back to official-docs WebFetch on the canonical repo README + LICENSE was used. **Four ALIKED model variants exposed in `cvg/LightGlue` lightglue/aliked.py via `model_name` enum**: `aliked-t16` (Tiny: c1=8, c2=16, c3=32, c4=64, dim=**64-D descriptor**, K=3 SDDH kernel size, M=16 SDDH sample positions, **0.192M parameters**, **1.37 GFLOPs on 640×480 + 1k keypoints**, **125.87 FPS RTX 2060** — most-Jetson-friendly variant); `aliked-n16` (Normal: c1=16, c2=32, c3=64, c4=128, dim=**128-D descriptor**, K=3, M=16, **0.677M parameters**, **4.05 GFLOPs**, **77.40 FPS RTX 2060** — canonical paper baseline); `aliked-n16rot` (Normal + rotation augmentation training: same arch as n16 but with rotation-data-augmentation prior; better viewpoint-rotation invariance per paper Fig. 6 top chart, slightly worse 3D-reconstruction accuracy than n16 per paper §VI-C1); `aliked-n32` (Normal with higher SDDH sampling: c1=16, c2=32, c3=64, c4=128, dim=**128-D**, K=3, **M=32 SDDH sample positions**, **0.980M parameters**, **4.62 GFLOPs**, **75.64 FPS RTX 2060** — best matching accuracy variant). **In cvg/LightGlue the ALIKED extractor is wired to `LightGlue(features='aliked')` with `input_dim=128` matcher config** (per Source #70 `lightglue/lightglue.py` lines 345–348). **Default per-extractor config** (cvg/LightGlue `lightglue/aliked.py` lines 603–608): `model_name="aliked-n16"`, `max_num_keypoints=-1` (threshold-based mode), `detection_threshold=0.2`, `nms_radius=2`, `preprocess_conf={"resize": 1024}` — **same canonical 1024-largest-edge resize policy as SuperPoint + DISK**. Pretrained weights URL pattern: `https://github.com/Shiaoming/ALIKED/raw/main/models/{model_name}.pth` — auto-downloaded via `torch.hub.load_state_dict_from_url` at first construction. **Required input format**: `data["image"]` as `torch.Tensor[B, 3, H, W]` RGB; if `B, 1, H, W` grayscale provided, the extractor auto-converts via `kornia.color.grayscale_to_rgb` (per `lightglue/aliked.py` lines 749–750). **Output format**: `{keypoints: torch.Tensor[B, N, 2], descriptors: torch.Tensor[B, N, dim], keypoint_scores: torch.Tensor[B, N]}` where `dim ∈ {64, 128}` per variant. **There is also a `raco-aliked` sibling weight checkpoint distributed by cvg/LightGlue** (per `lightglue/lightglue.py` lines 349–352) — RACo (Random Augmentation in Color)-trained ALIKED variant; community contribution, not in canonical paper; skipped in this entry as "separately-cataloged sibling mode if elevated".
- **Target Audience**: System architects + C3 implementer + Step-7.5 reviewer + license-posture decision-maker (D-C1-1 + D-C3-1 NEW)
- **Research Boundary Match**: **Full match** for the project's pinned mode of ALIKED+LightGlue (single-image-pair sparse feature matching: take a UAV nadir frame + a retrieved satellite tile, run ALIKED-N(16) feature extraction on each independently at 1024-largest-edge, match via LightGlue with `features='aliked'`, return 2D-2D correspondences with confidence scores feeding the project's downstream C4 PnP+RANSAC pose estimator). The repo ships everything needed: extractor classes (`aliked-t16/n16/n16rot/n32` via `cvg/LightGlue` `lightglue.ALIKED(model_name=...)`), I/O utilities inherited from cvg/LightGlue (`load_image, rbd, match_pair`), visualization inherited (`viz2d`), pretrained weights auto-downloaded. **Asymmetric image-pair sizes are handled natively** — same independent per-image extraction pattern as SP+LightGlue + DISK+LightGlue. **Partial match** for the project's domain (canonical training on **MegaDepth perspective dataset (135 scenes, 1.35M image pairs sampled per DISK methodology)** + **R2D2 homographic dataset (Oxford-Paris + Aachen synthetic homographies)** — neither dataset is aerial nadir; **same aerial-domain caveat as SP+LightGlue + DISK+LightGlue + C2 candidates**; aerial applicability is **NOT explicitly validated in the canonical paper** — project-side via Jetson MVE on AerialExtreMatch + Derkachi flight). **NEGATIVE finding for the Jetson deployment story**: Source #73 (`fabio-sim/LightGlue-ONNX`) does NOT ship a documented ALIKED end-to-end export pathway as of January 2026 — Source #73 README changelog explicitly lists SuperPoint (28 Jun 2023) + DISK (30 Jun 2023) extractor support, **but no ALIKED entry**; Source #73 citations section cites LightGlue + SuperPoint + DISK papers only, **with no ALIKED reference**; Source #73 example CLI commands all use `superpoint` as the positional extractor argument and there is no documented `aliked` CLI variant. **Plus the canonical `lightglue/aliked.py` uses `torchvision.ops.deform_conv2d`** which is a known-difficult ONNX export op (deformable conv historically required either ONNX opset ≥19 native `DeformConv` op OR a custom TensorRT plugin). **Implication for D-C3-2**: ALIKED+LightGlue's Jetson deployment story is materially WEAKER than DISK+LightGlue's or SP+LightGlue's; the project's options for ALIKED+LightGlue on Jetson are restricted to (a) PyTorch-fp16 only (likely 2-3× slower than DISK+LightGlue's TensorRT path), (b) custom ONNX export with deform_conv plugin (significant engineering effort), (c) wait for community LightGlue-ONNX ALIKED support to land, (d) accept Torch-TensorRT partial graph compilation with deform_conv falling back to PyTorch-eager (mixed runtime — operationally complex).
- **Summary**: ALIKED is the canonical sparse-keypoint-and-descriptor extraction network introduced by Zhao et al. (IEEE T-IM 2023), with **Sparse Deformable Descriptor Head (SDDH) as its main contribution** — extracts deformable descriptors only at sparse keypoints (rather than dense descriptor maps as in SuperPoint / R2D2 / D2-Net / ASLFeat / DISK), reducing GFLOPs by ~6-200× vs prior methods at competitive matching accuracy. **CRITICAL LICENSE FINDING**: LICENSE file is **BSD-3-Clause** (Copyright (c) 2022, Zhao Xiaoming) — permissive; this places ALIKED ITSELF on the **BSD/permissive license track** alongside MixVPR (MIT) + SelaVPR (MIT) + NetVLAD-canonical (MIT) + EigenPlaces (MIT) + Kimera-VIO (BSD-2) + OKVIS2 (BSD-3) + DPVO (MIT) + cvg/LightGlue itself (Apache-2.0). cvg/LightGlue's `lightglue/aliked.py` port file inherits the BSD-3-Clause notice in its file header (lines 1–33 of the file include the full BSD-3-Clause notice + Magic Leap-style author attribution). **Architecture (paper §III + §IV)**: feature encoder with 4 ConvBlock/ResBlock stages (block3 + block4 use deformable convolutions per paper §III-A) → feature aggregation via four upsample blocks → score map head (SMH) for keypoint detection via Differentiable Keypoint Detection (DKD, inherited from ALIKE [10]) → SDDH for sparse deformable descriptor extraction at the detected keypoints. SDDH first samples a K×K patch around each keypoint, estimates M deformable sample positions via two convolution layers, samples M supporting features via bilinear sampling, encodes with selu+conv1x1 + aggregates with convM (paper Eq. 4–5) producing a `dim`-D descriptor with L2-norm. Per-keypoint cost is ∝ M (vs ∝ HW for DMH) → **drastic GFLOPs reduction**. **Network configurations (paper Table II)**: Tiny (c1=8, c2=16, c3=32, c4=64, dim=64), Normal (c1=16, c2=32, c3=64, c4=128, dim=128), Large (c1=32, c2=64, c3=128, c4=128, dim=128 with deeper desc head). cvg/LightGlue port exposes Tiny + Normal (with M=16 / M=32) but NOT Large. **Reported headline performance vs SOTA on RTX 2060** (paper Table IV — HPatches with 1k keypoints, 640×480): ALIKED-T(16) **125.87 FPS** / 0.192M params / 1.37 GFLOPs / MMA@3=72.99% / MHA@3=78.70%; ALIKED-N(16) **77.40 FPS** / 0.677M params / 4.05 GFLOPs / MMA@3=74.43% / MHA@3=77.22%; ALIKED-N(32) **75.64 FPS** / 0.980M params / 4.62 GFLOPs / MMA@3=75.23% / MHA@3=74.44%. **vs SuperPoint** (1.301M params / 26.11 GFLOPs / 52.63 FPS / MMA@3=65.37 / MHA@3=70.19): ALIKED-N(16) achieves +9.06 absolute MMA@3 + +7.03 absolute MHA@3 at **1/6th the GFLOPs and ~1.5× the FPS**. **vs DISK** (1.092M params / 98.97 GFLOPs / 11.81 FPS / MMA@3=77.59 / MHA@3=70.56): DISK has +3.16 absolute MMA@3 vs ALIKED-N(16) but **-6.66 absolute MHA@3** (DISK keypoints are evenly distributed → poorer homography estimation); ALIKED-N(16) is **6.6× faster with 1/24th the GFLOPs**. **Pose Estimation IMW-test (paper Table V, 2048 keypoints)**: ALIKED-N(16) Stereo mAA(5°)=46.30 / mAA(10°)=85.47 (vs DISK 44.80/85.20 — competitive with DISK at 1/24th GFLOPs); ALIKED-N(16) Multiview mAA(5°)=39.53 / mAA(10°)=52.28 / TL=5.57 (vs DISK 38.72/51.22/5.50 — slightly better than DISK on stereo, marginally less on multiview where DISK's higher #matches gives bundle-adjustment edge). **PPC (Performance Per Cost = mAA(10°)/GFLOPs)**: ALIKED-N(16) Stereo PPC=12.91 vs DISK 0.52 (**24.8× higher PPC**). **FM-Bench TUM/KITTI/T&T/CPC (paper Table VI)**: ALIKED-N(16) achieves best %Recall on TUM (63.60), best on T&T (92.10), and is competitive with DISK on KITTI (92.10 vs DISK 90.20) and CPC (58.00 vs DISK 59.10). **Aachen Day-Night visual relocalization (paper Table VII)**: ALIKED-N(32) up-to-1024-keypoints / (0.25m,2°)/(0.5m,5°)/(5m,10°) = **77.6/88.8/100.0 (best in row)**; ALIKED-N(16) = **73.5/85.7/98.0**; ALIKED-T(16) = 70.4/87.8/98.0; **vs SuperPoint** = 58.2/66.3/72.4 — ALIKED-N(32) is +19.4 absolute / +22.5 absolute / +27.6 absolute over SuperPoint at the strictest tier; **vs DISK** = 60.2/72.4/81.6 — ALIKED-N(32) is +17.4/+16.4/+18.4 absolute. **The Aachen documentary lift over SuperPoint and DISK on the visual-localization task is the strongest documentary signal for ALIKED+LightGlue's project relevance** (the project's intended pipeline is identical: C2 NetVLAD-class top-K → C3 sparse-matcher → C4 PnP+RANSAC, all evaluated on Aachen Day-Night by Source #71 LightGlue paper + Source #76 ALIKED paper). **Rotation invariance (paper §VI-C1 + Fig. 6 top)**: ALIKED-N(16, rot) achieves **best rotation invariance** at 0–45° rotations (vs SuperPoint, ALIKE, DISK, etc.); however, ALIKED-N(16, rot) performs slightly worse in 3D reconstruction than ALIKED-N(16) — **D-C3-1-mitigation-specific consideration**: for the project's UAV nadir use case where heading variation is expected, `aliked-n16rot` may be the preferred sibling mode; rotation augmentation may not hurt aerial-nadir 3D-reconstruction performance materially because aerial-nadir scenes do not have a strong "up direction" cue (vs ground-level scenes where vertical cues are critical). Plan-phase decision raised (will be tagged D-C3-4 NEW): ALIKED-N(16) vs ALIKED-N(16rot) vs ALIKED-N(32) vs ALIKED-T(16) sibling-mode choice for the project's pinned ALIKED variant. **Limitations (paper §VI-E)**: SDDH has only one layer for deformable position estimation, so it has limitations modeling extreme image deformation (large scale + viewpoint differences simultaneously); shared by all single-scale matching methods (SP, ALIKE, DISK, ASLFeat) at scale-difference >4×. **Custom_ops requirement on canonical Shiaoming/ALIKED**: the README mentions `cd custom_ops; sh build.sh` to build a CUDA extension for the deformable-position-estimation kernel — this is a **legacy path** that the cvg/LightGlue port has eliminated by using `torchvision.ops.deform_conv2d` directly (per `lightglue/aliked.py` lines 39 + 336–344); the project will use the cvg/LightGlue port and avoid the build-from-source dependency. **Modern lineage**: ALIKED is the strict successor to ALIKE (T-MM 2022) which itself is the strict successor to SuperPoint (CVPR Workshop 2018) — the lineage establishes ALIKED as the **modern competitive lightweight CNN extractor**, with SDDH as the key innovation enabling lower GFLOPs at competitive accuracy.
- **Related Sub-question**: SQ3+SQ4 / C3 — ALIKED+LightGlue per-mode API capability verification (Mandatory `context7` lookup NOT INDEXED + WebFetch fallback PASS per Per-Mode rule item 2; cross-validated against canonical README + LICENSE WebFetch + canonical paper WebFetch [Source #75] + cvg/LightGlue `lightglue/aliked.py` source code inspection [transitively cited via Source #70] + LightGlue-ONNX ALIKED-export-absence finding [transitively cited via Source #73]); D-C3-1 RECOMMENDED-secondary-mitigation candidate (BSD-3-Clause + Apache-2.0 throughout, second-cleanest license-compliant option after DISK+LightGlue); raises NEW **D-C3-4 ALIKED-sibling-mode-choice (aliked-t16 64-D / aliked-n16 128-D canonical / aliked-n16rot 128-D rotation-augmented / aliked-n32 128-D higher-SDDH-sample-count)** Plan-phase decision


### Source #75
- **Title**: ALIKED canonical paper — "ALIKED: A Lighter Keypoint and Descriptor Extraction Network via Deformable Transformation" (Zhao, Wu, Chen, Chen, Xu, Li — IEEE Transactions on Instrumentation & Measurement, vol. 72, pp. 1–16, 2023, DOI 10.1109/TIM.2023.3271000, arXiv:2304.03608)
- **Link**: arXiv abstract https://arxiv.org/abs/2304.03608 (April 2023); arXiv full PDF https://arxiv.org/pdf/2304.03608.pdf ; IEEE T-IM published version DOI 10.1109/TIM.2023.3271000 ; accessed 2026-05-08
- **Tier**: L1 (peer-reviewed IEEE T-IM 2023 + canonical implementation cross-referenced; documented modern competitive lightweight CNN extractor in the post-SuperPoint / post-ALIKE era; cited by 2024–2026 feature-matching papers as a competitive-fast extractor reference)
- **Publication Date**: arXiv preprint 2023-04-07; IEEE T-IM publication mid-2023
- **Timeliness Status**: ✅ Within Critical-novelty window (April 2023 — modern competitive ground for sparse-extractor reference); Established-competitive-modern-extractor exemption applies (ALIKED is the post-ALIKE successor with explicit GFLOP-reduction claims that 2024–2026 successor candidates [XFeat, XFeat*] explicitly position themselves against)
- **Version Info**: arXiv v1 (April 2023, IEEE T-IM camera-ready); paper §III architecture + §IV SDDH + §V sparse NRE loss + §VI experiments + §VI-A implementation details (Adam optimizer, betas 0.9/0.999, top-400 detected + 400 random keypoints with NMS, 800×800 training resolution, batch size 2, gradient accumulation over 6 batches, MegaDepth + R2D2 homographic datasets, 100K training steps, 100K best-checkpoint selection on validation)
- **Target Audience**: System architects + C3 implementer + Step-7.5 reviewer
- **Research Boundary Match**: **Full match** for the algorithm (ALIKED with SDDH as the descriptor head, deformable convolution in the feature encoder's last 2 blocks, DKD for keypoint detection, sparse NRE loss for training); **partial match** for the project's domain (paper benchmarks: HPatches homography Table IV [planar scenes with illumination + viewpoint changes], IMW test Table V [phototourism stereo + multiview reconstruction], FM-Bench Table VI [TUM indoor SLAM, KITTI driving, T&T wide-baseline reconstruction, CPC wild-reconstruction-from-web], Aachen Day-Night Table VII [outdoor visual relocalization]; **NO aerial nadir benchmark** in the canonical paper). **Critical paper §I + §II-A reference position**: ALIKED is positioned as a **lighter keypoint and descriptor extraction network for resource-constrained visual measurement applications**, including SLAM, computational photography, and visual place recognition — directly aligned with the project's Jetson Orin Nano Super deployment context. The paper §VI-A explicitly tests on **mid-end NVIDIA GeForce RTX 2060** (a resource-constrained-class GPU) — Jetson Orin Nano Super is in the same class.
- **Summary**: The canonical paper introduces ALIKED with three core contributions: (i) **SDDH (Sparse Deformable Descriptor Head)** that extracts deformable descriptors only at sparse keypoints (paper §IV) via M deformable sample positions per keypoint (rather than dense descriptor maps as in SuperPoint / DISK / R2D2 / ASLFeat / D2-Net) — drastic GFLOPs reduction of 6-200× vs prior methods (paper Table III + Table IV); (ii) **deformable convolutions in the last 2 blocks of the feature encoder** (paper §III-A) for geometric-invariance-aware feature extraction; (iii) **sparse NRE (Neural Reprojection Error) loss relaxation** (paper §V) — relaxes the dense NRE loss [DISK 2020 + ALIKE 2022] to sparse formulation, reducing GPU memory by ~3.5× and enabling training with batch size 2 on a single GPU (rather than DISK's RL-based training requirements). **Reported headline performance vs SOTA on HPatches Table IV (RTX 2060, 640×480, 1k keypoints)**: ALIKED-T(16) achieves **125.87 FPS / 0.192M params / 1.37 GFLOPs / MMA@3=72.99% / MHA@3=78.70%** — best MHA among compared methods despite smallest network (vs ALIKE-N 84.96 FPS / 0.318M / 7.91 GFLOPs / MMA@3=70.78 / MHA@3=75.74; vs SuperPoint 52.63 FPS / 1.301M / 26.11 GFLOPs / MMA@3=65.37 / MHA@3=70.19; vs DISK 11.81 FPS / 1.092M / 98.97 GFLOPs / MMA@3=77.59 / MHA@3=70.56). ALIKED-N(16) achieves **77.40 FPS / 0.677M params / 4.05 GFLOPs / MMA@3=74.43% / MHA@3=77.22%** — competitive with all top methods at fraction of GFLOPs. **Aachen Day-Night visual relocalization (paper Table VII, up to 2048 keypoints)**: ALIKED-N(32) achieves **(0.25m,2°)/(0.5m,5°)/(5m,10°) = 76.5/87.8/100.0** (vs SuperPoint 69.4/78.6/87.8 = +7.1/+9.2/+12.2; vs DISK 70.4/82.7/94.9 = +6.1/+5.1/+5.1; vs ALIKE-L 74.5/87.8/98.0 = +2.0/0.0/+2.0). **CRITICAL OBSERVATION FOR THE PROJECT**: paper Table VII Aachen Day-Night benchmark documents that **ALIKED-N(32) is the highest-performing tested keypoint extractor on the Aachen Day-Night benchmark at the strictest (0.25m,2°) tier with 2048 keypoints**, beating SuperPoint by +7.1 absolute, beating DISK by +6.1 absolute, beating ALIKE-L by +2.0 absolute. By transitive lineage with Source #71 LightGlue paper Table 3 (which reports Aachen Day-Night with **NetVLAD top-50 retrieval → SP+LightGlue → PnP+RANSAC pipeline** at Day (0.25m,2°)=89.2 — significantly better than SuperPoint+mNN's 69.4 on the same benchmark), the **expected pose-estimation accuracy of the ALIKED+LightGlue pipeline on Aachen Day-Night should approach or exceed SP+LightGlue's** because ALIKED-N(32)+mNN already beats SuperPoint+mNN by +7.1 absolute, and the LightGlue matcher provides similar relative lift over mNN for ALIKED as for SuperPoint. **However, no canonical paper directly evaluates ALIKED+LightGlue on Aachen Day-Night** — the cvg/LightGlue paper (Source #71) Table 3 only reports SP+LightGlue (the cvg/LightGlue ALIKED port + ALIKED-LightGlue weights were added post-paper). **3D reconstruction IMW test Table V (2048 keypoints)**: ALIKED-N(16) Stereo mAA(10°)=85.47 / Multiview mAA(10°)=71.78 — competitive with DISK (85.20 / 72.96) at 1/24th GFLOPs. **PPC (Performance Per Cost) in Table V**: ALIKED-N(16) PPC_stereo=12.91 vs DISK 0.52 — **24.8× higher PPC**. **Rotation invariance (paper §VI-C1 + Fig. 6 top)**: ALIKED-N(16, rot) achieves best rotation invariance among all tested methods at 0–45° image rotations (vs SuperPoint which is strong on rotation due to Homographic Adaptation training, vs ALIKE / DISK / R2D2 which are weak on rotation). **Scale invariance (paper §VI-C2 + Fig. 6 bottom)**: ALIKED-N(16) has best matching accuracy among single-scale methods, but all single-scale methods degrade to 0 at scale-difference >4×; multi-scale variant ALIKED-N(16, MS) handles up to 8× scale difference. **License**: BSD-3-Clause via Source #74 — canonical implementation. **NO direct ALIKED+LightGlue benchmark** in the cvg/LightGlue paper Table 3 / Table 6 / Table 7 (those tables document SP+LightGlue and DISK+LightGlue only); ALIKED+LightGlue benchmarks would need to be sourced from community evaluations (kornia, hloc, Image Matching WebUI, IMC competition leaderboards) at Plan-phase, OR the project measures ALIKED+LightGlue directly at Jetson MVE phase using the canonical pretrained weights.
- **Related Sub-question**: SQ3+SQ4 / C3 — ALIKED+LightGlue per-mode API capability verification (cross-source verification of canonical paper architectural details + benchmark numbers + ablation studies; documents the Aachen Day-Night documentary lift of ALIKED-N(32)+mNN over SuperPoint+mNN by +7.1 absolute at strictest tier as transitive evidence that ALIKED+LightGlue should be competitive with or beat SP+LightGlue on the visual-localization task; aerial-domain caveat documented; D-C3-1 RECOMMENDED-secondary-mitigation status confirmed)


### Source #76
- **Title**: DISK canonical implementation — `cvlab-epfl/disk` (Tyszkiewicz, Fua, Trulls — NeurIPS 2020) — official PyTorch reference implementation, README + Apache-2.0 LICENSE (confirmed via GitHub API metadata `license.spdx_id: "Apache-2.0"`), `detect.py` + `match.py` runnable inference demos, two pretrained checkpoints `save-depth.pth` (depth-based RL reward — paper default and best variant) + `save-epipolar.pth` (epipolar reward — supplementary material variant), 4-layer U-Net architecture requiring image dimensions multiple of 16; cvg/LightGlue's DISK port `lightglue/disk.py` integrates via `kornia.feature.DISK.from_pretrained("depth")` (Apache-2.0 inheritance through kornia integration)
- **Link**: README https://raw.githubusercontent.com/cvlab-epfl/disk/master/README.md (accessed 2026-05-08); GitHub API license metadata https://api.github.com/repos/cvlab-epfl/disk (accessed 2026-05-08; `license.spdx_id: "Apache-2.0"`); repo https://github.com/cvlab-epfl/disk (377 stars, 56 forks, last pushed 2023-12-15); cvg/LightGlue's DISK port `lightglue/disk.py` https://raw.githubusercontent.com/cvg/LightGlue/main/lightglue/disk.py
- **Tier**: L1 (project-official codebase by the canonical DISK authors Michał Tyszkiewicz + Pascal Fua + Eduard Trulls, EPFL CVLab + Google Zurich; NeurIPS 2020 publication; canonical implementation referenced by every subsequent feature-matching paper as the "RL-trained sparse extractor reference"; included in cvg/LightGlue's canonical 5-extractor lineup [SuperPoint, **DISK**, ALIKED, SIFT, DoGHardNet])
- **Publication Date**: NeurIPS 2020 (paper accepted Sept 2020; arXiv preprint v1 2020-06-24); canonical repo creation 2020-10-20; last pushed 2023-12-15 (3 years of stable maintenance, no recent breaking changes — establishes mature reference codebase status)
- **Timeliness Status**: ✅ Within Critical-novelty window (2020 — established competitive ground for sparse-extractor reference; widely-adopted reference implementation across feature-matching deployment community); Established-competitive-extractor-reference exemption applies (DISK is the canonical RL-policy-gradient sparse extractor reference, with its main innovation being end-to-end RL training of detection + description; the LightGlue paper Source #71 + ALIKED paper Source #75 + every subsequent feature-matching benchmark cites DISK as the "modern competitive sparse extractor reference baseline")
- **Version Info**: master HEAD at access time (last pushed 2023-12-15). **Mode-enumeration query (1/3) — context7 NOT INDEXED + WebFetch fallback PASS** — `context7 resolve-library-id` returned no relevant matches for "DISK" feature extractor (top-results were Disk Inventory X / Expo Build Disk Cache / Blacksmith Sticky Disk / disko NixOS / gptman — all unrelated to feature-matching); per Per-Mode API Capability Verification rule item 2, fall-back to official-docs WebFetch on the canonical repo README + GitHub API license metadata was used. **Two DISK pretrained checkpoints documented**: `save-depth.pth` (default; trained with depth-based RL reward; reproduces paper Table 1 + 2 results 0.51315 stereo AUC + 0.72705 multiview AUC on IMW2020 test set with 2k features at canonical schedule); `save-epipolar.pth` (alternate; trained with epipolar reward; supplementary material variant). **Native canonical inference CLI**: `python detect.py --height 1024 --width 1024 --n 2048 h5_artifacts_destination images_directory` produces `keypoints.h5 + descriptors.h5`; `python match.py --rt 0.95 --save-threshold 100 h5_artifacts_destination` produces matches via mutual-NN; ratio test threshold 0.95 documented. **Canonical model architecture**: 4-layer U-Net with deformable convolutions; image dimensions must be multiple of 16 (auto-padded preserving aspect ratio via `--height/--width` flags); produces 128-D L2-normalized descriptors per keypoint (per Source #71 LightGlue paper §3 + cvg/LightGlue `lightglue/disk.py` `desc_dim=128` default config). **In cvg/LightGlue the DISK extractor is wired via `kornia.feature.DISK.from_pretrained("depth")` with `LightGlue(features='disk')` matcher config** (`lightglue/disk.py` lines 1–53). **Default per-extractor config in cvg/LightGlue port**: `weights="depth"`, `max_num_keypoints=None` (threshold-based mode; project pinned to 1024), `desc_dim=128`, `nms_window_size=5`, `detection_threshold=0.0`, `pad_if_not_divisible=True` (auto-handles the multiple-of-16 constraint), `preprocess_conf={"resize": 1024, "grayscale": False}` — **same canonical 1024-largest-edge resize policy as SuperPoint + ALIKED**. Pretrained weights distributed via kornia (`kornia.feature.DISK.from_pretrained` accepts "depth" or "epipolar" weight key, auto-downloads from kornia model registry). **Required input format**: `data["image"]` as `torch.Tensor[B, 3, H, W]` RGB; if `[B, 1, H, W]` grayscale provided, the cvg/LightGlue port auto-converts via `kornia.color.grayscale_to_rgb` (per `lightglue/disk.py` lines 31–32). **Output format**: `{keypoints: torch.Tensor[B, N, 2], descriptors: torch.Tensor[B, N, 128], keypoint_scores: torch.Tensor[B, N]}` where `N ≤ max_num_keypoints` — same dict shape as SP+LightGlue + ALIKED+LightGlue, allowing direct LightGlue matcher swap via `features='disk'`. **Training data**: EPFL CVLab DISK dataset (~164 GB downloadable via `download_dataset` script), sampled from MegaDepth phototourism scenes with depth-map supervision; Low-GPU-memory training option `python train.py --substep 2 --batch-size 1 --chunk-size 10000 --warmup 500` documented to fit within 11/12 GB GPUs (~2 weeks of training); canonical training was on 32 GB V100s with `inverse_T = θ_M` annealed from 15 to 50 over 20 epochs; best checkpoint selection on validation AUC. **COLMAP integration**: ships `colmap/h5_to_db.py` for SfM pipeline integration. **No `lightglue/disk.py` LICENSE annotation in the file header** (vs ALIKED's explicit BSD-3-Clause file-header inheritance) — the cvg/LightGlue port file inherits Apache-2.0 from cvg/LightGlue itself (Source #70) and from canonical DISK (Apache-2.0). **kornia is also Apache-2.0** (well-established) — Apache-2.0 license track is preserved through the entire DISK+LightGlue stack. The `lightglue-onnx` companion (Source #73) **explicitly supports DISK** in its 30 Jun 2023 changelog entry: "DISK feature extraction support added"; CLI command pattern parallel to SP+LightGlue: `lightglue-onnx export disk_lightglue --num-keypoints 1024 -b 2 -h 1024 -w 1024 --fp16 --device cuda` and inference via `lightglue-onnx infer disk_lightglue --image image1.jpg --image image2.jpg -d tensorrt --fp16`. **Canonical paper IMW2020 stereo AUC numbers (paper Table 1)**: DISK 0.50432 stereo AUC + 0.72624 multiview AUC at 2k features (default schedule); 0.51315 / 0.72705 with original ad-hoc schedule. By transitive lineage with Source #71 LightGlue paper Table 6 (which documents DISK+LightGlue stereo AUC@5° = 67.02 vs SP+LightGlue 59.03 = +7.99 absolute on IMC 2020), DISK+LightGlue is the **demonstrably technically-superior C3 candidate to canonical SP+LightGlue on phototourism stereo** while preserving Apache-2.0 license track throughout. **Limitations (paper §4 + ALIKED paper Table III cross-cite)**: DISK has 1.092M params + **98.97 GFLOPs** at 640×480 + 1k keypoints — **24.4× higher GFLOPs than ALIKED-N(16)** (4.05 GFLOPs); **3.8× higher GFLOPs than SuperPoint** (26.11 GFLOPs); RTX 2060 throughput **11.81 FPS @ 640×480 + 1k keypoints = 84.7 ms per pair extraction-only** (slowest among modern competitive sparse extractors). However, the LightGlue-ONNX TensorRT acceleration pathway (Source #73) provides 3-5× speedup over PyTorch fp16, partially offsetting DISK's high GFLOPs cost — **TensorRT-equipped Jetson Orin Nano Super extrapolation: ~50-100 ms per pair @ 1024 keypoints fp16 + LightGlue-ONNX TensorRT EP / ~200-400 ms PyTorch-fp16-only fallback**; at K=10 top-K retrieval pairs/frame this puts AC-4.1 400 ms budget at MEDIUM-RISK margin (better than ALIKED's PyTorch-fp16-only HARSH-RISK margin but worse than SP+LightGlue's TIGHT margin due to DISK's higher raw GFLOPs).
- **Target Audience**: System architects + C3 implementer + C7 (Jetson runtime) implementer + Step-7.5 reviewer + license-posture decision-maker (D-C1-1 + D-C3-1 RECOMMENDED-PRIMARY mitigation lock)
- **Research Boundary Match**: **Full match** for the project's pinned mode of DISK+LightGlue (single-image-pair sparse feature matching: take a UAV nadir frame + a retrieved satellite tile, run DISK feature extraction on each independently at 1024-largest-edge, match via LightGlue with `features='disk'`, return 2D-2D correspondences with confidence scores feeding the project's downstream C4 PnP+RANSAC pose estimator). The cvg/LightGlue port + kornia integration ships everything needed: extractor classes (`from lightglue import DISK; DISK(max_num_keypoints=1024)` instantiates `kornia.feature.DISK` under the hood), I/O utilities inherited from cvg/LightGlue (`load_image, rbd, match_pair`), visualization inherited (`viz2d`), pretrained weights auto-downloaded via kornia. **Asymmetric image-pair sizes are handled natively** — same independent per-image extraction pattern as SP+LightGlue + ALIKED+LightGlue. **Partial match** for the project's domain (canonical training on **EPFL CVLab DISK dataset (~164 GB) sampled from MegaDepth phototourism scenes with depth-map supervision** — NOT aerial nadir; **same aerial-domain caveat as SP+LightGlue + ALIKED+LightGlue + C2 candidates**; aerial applicability is **NOT explicitly validated in the canonical paper** — project-side via Jetson MVE on AerialExtreMatch + Derkachi flight, OR via D-C2-1 retrain decision = (a) project-domain retrain on AerialVL with DISK's RL policy gradient training paradigm). **POSITIVE finding for the Jetson deployment story**: Source #73 (`fabio-sim/LightGlue-ONNX`) **DOES** ship a documented DISK end-to-end export pathway (changelog entry 30 Jun 2023); DISK+LightGlue is the **second-cleanest LightGlue extractor sibling for Jetson deployment** after SP+LightGlue (which has the most-mature ONNX/TensorRT pathway via 28 Jun 2023 changelog) but **before ALIKED+LightGlue (export-absent in LightGlue-ONNX)**.
- **Summary**: DISK is the canonical **RL-policy-gradient sparse-keypoint-and-descriptor extraction network** introduced by Tyszkiewicz, Fua, and Trulls (NeurIPS 2020), with **end-to-end RL training of detection + description as its main contribution** — uses policy gradient (REINFORCE-class) to optimize directly for the high-level downstream objective of "many correct feature matches between image pairs", relaxing the discreteness barrier that prior end-to-end methods (SuperPoint, R2D2, D2-Net) approximated with surrogate losses. **CRITICAL LICENSE FINDING**: Apache-2.0 (confirmed via GitHub API metadata `license.spdx_id: "Apache-2.0"`) — permissive, BSD/permissive license track on the extractor; **paired with cvg/LightGlue's Apache-2.0 matcher** (Source #70) → **Apache-2.0 license track THROUGHOUT the DISK+LightGlue stack**. This makes DISK+LightGlue the **cleanest license-compliant LightGlue-extractor-sibling alternative to canonical SP+LightGlue's Magic-Leap-restrictive-extractor-weights HARD DISQUALIFIER** (vs ALIKED+LightGlue's BSD-3-Clause + Apache-2.0 mixed track which is also clean BSD/permissive but adds the export-pathway gap). **Architecture (paper §3 + ALIKED paper Table III cross-cite)**: 4-layer U-Net feature encoder with deformable convolutions in the bottleneck → score head (DKD-class) for keypoint detection → per-pixel dense descriptor head producing 128-D L2-normalized descriptors. Image dimensions must be multiple of 16 due to U-Net's 4 downsampling stages (auto-padded preserving aspect ratio in the canonical CLI; auto-handled in cvg/LightGlue port via `pad_if_not_divisible=True`). **Two pretrained checkpoints distributed**: `save-depth.pth` (depth-based RL reward, default and best variant per paper) + `save-epipolar.pth` (epipolar reward, supplementary material variant). **Reported headline performance vs SOTA on IMW2020 (paper Table 1, 2k features)**: DISK 0.51315 stereo AUC + 0.72705 multiview AUC (canonical paper schedule) — **best single-extractor result on IMW2020 stereo at 2020 publication time**. **vs SuperPoint** (1.301M params / 26.11 GFLOPs): DISK has 1.092M params / 98.97 GFLOPs = **3.8× higher GFLOPs**; trades higher compute cost for higher matching accuracy. **vs ALIKED-N(16)** (0.677M params / 4.05 GFLOPs / 77.40 FPS RTX 2060): DISK has 1.092M params / 98.97 GFLOPs / 11.81 FPS — **24.4× higher GFLOPs / 6.6× lower FPS** but with +3.16 absolute MMA@3 on HPatches (per ALIKED paper Table III). **Aachen Day-Night visual relocalization (ALIKED paper Table VII, up to 2048 keypoints, mNN matcher)**: DISK 70.4/82.7/94.9 at (0.25m,2°)/(0.5m,5°)/(5m,10°) — beats SuperPoint=69.4/78.6/87.8 at strictest tier by +1.0/+4.1/+7.1 absolute, but loses to ALIKED-N(32)=77.6/88.8/100.0 by -7.2/-6.1/-5.1 absolute. **However, when paired with LightGlue matcher** (Source #71 paper Appendix A Table 6): **DISK+LightGlue stereo AUC@5° on IMC 2020 = 67.02 vs SP+LightGlue 59.03 = +7.99 absolute documentary technical superiority** + **DISK+LightGlue stereo AUC@10° on IMC 2020 = 83.45 vs SP+LightGlue 77.96 = +5.49 absolute** — **DISK+LightGlue is the demonstrably best documented LightGlue-extractor-sibling on phototourism stereo**. **No direct DISK+LightGlue Aachen Day-Night number** in either canonical paper (the cvg/LightGlue paper Table 3 documents only SP+LightGlue Aachen results); transitive lineage suggests DISK+LightGlue Aachen Day-Night should lift DISK+mNN's 70.4/82.7/94.9 by similar relative margin as LightGlue lifts SP over SP+mNN (paper §5.4 ~10-15 absolute lift across tiers expected, putting DISK+LightGlue Aachen Day at approximately 80-85/93-95/99-100 — competitive with SP+LightGlue's 89.2/95.4/98.5 but with more-uncertain documentary basis). **Training paradigm**: REINFORCE-class policy gradient with `inverse_T = θ_M` annealed from 15 to 50 over 20 epochs; depth-based reward = number of feature matches consistent with ground-truth depth maps (preferred to epipolar reward). Canonical training time = ~2 weeks on 32 GB V100; low-GPU-memory variant (12 GB) takes ~2 weeks at smaller batch/chunk size. **Custom dataset support**: ships `colmap/colmap2dataset.py` to import COLMAP outputs into DISK training format — directly applicable to project-side D-C2-1 = (a) aerial-retrain workflow (run COLMAP on AerialVL or Derkachi-flight scenes → import into DISK format → train DISK on aerial-nadir corpus). **Note on training cost**: DISK's RL-based training is more compute-intensive than ALIKED's sparse-NRE-loss training (paper §V — ALIKED reduces GPU memory by ~3.5× vs DISK's RL training); for the project's D-C2-1 retrain decision, DISK is **less retrain-friendly** than ALIKED at the GPU-memory level but **more retrain-friendly** than SP-reproduction (which would require Magic-Leap's Homographic Adaptation training pipeline + LICENSE clearance). **Kornia integration**: cvg/LightGlue's `lightglue/disk.py` port uses `kornia.feature.DISK.from_pretrained("depth")` — kornia auto-downloads the canonical `save-depth.pth` weights from kornia's model registry on first instantiation; no manual checkpoint download required. **LightGlue-ONNX support**: Source #73 ships DISK end-to-end ONNX export pathway documented in the 30 Jun 2023 changelog; CLI commands parallel SP+LightGlue export (`lightglue-onnx export disk_lightglue ...`). **Modern lineage**: DISK is the strict successor to SuperPoint (CVPR Workshop 2018) on the RL-trained-end-to-end axis (vs SuperPoint's Homographic-Adaptation-trained-with-surrogate-losses axis); the ALIKED paper (Source #75) positions itself as a successor to both DISK and SuperPoint; modern community evaluations (kornia, hloc, Image Matching Workshop competitions) consistently report DISK+LightGlue as a competitive top-3 sparse-matcher pipeline.
- **Related Sub-question**: SQ3+SQ4 / C3 — DISK+LightGlue per-mode API capability verification (Mandatory `context7` lookup NOT INDEXED + WebFetch fallback PASS per Per-Mode rule item 2; cross-validated against canonical README + GitHub API license metadata WebFetch + canonical paper WebFetch [Source #77] + cvg/LightGlue `lightglue/disk.py` source code inspection [transitively cited via Source #70] + LightGlue-ONNX DISK-export-PRESENT finding [transitively cited via Source #73]); **D-C3-1 RECOMMENDED-PRIMARY-MITIGATION candidate** (Apache-2.0 throughout, demonstrably technically superior to canonical SP+LightGlue on phototourism stereo via paper Table 6 +7.99 absolute AUC@5° lift, and Jetson-deployment-ready via LightGlue-ONNX TensorRT pathway); reaffirms D-C2-1 reuse (canonical training on MegaDepth phototourism is NOT aerial nadir); reaffirms D-C3-2 LightGlue-inference-runtime choice with PREFERRED ONNX Runtime + TensorRT EP path for DISK+LightGlue on Jetson Orin Nano Super


### Source #77
- **Title**: DISK canonical paper — "DISK: Learning local features with policy gradient" (Tyszkiewicz, Fua, Trulls — Advances in Neural Information Processing Systems vol. 33, 2020, arXiv:2006.13566)
- **Link**: arXiv abstract https://arxiv.org/abs/2006.13566 (June 2020); arXiv full PDF https://arxiv.org/pdf/2006.13566.pdf ; NeurIPS 2020 proceedings https://proceedings.neurips.cc/paper/2020/hash/a42a596fc71e17828440030074d15e74-Abstract.html ; accessed 2026-05-08
- **Tier**: L1 (peer-reviewed NeurIPS 2020 + canonical implementation cross-referenced; documented modern competitive RL-trained sparse-extractor reference; cited by 2021–2026 feature-matching papers as the "policy-gradient end-to-end sparse extractor" and the "MegaDepth-trained dense-descriptor sparse-extractor"; included in cvg/LightGlue's canonical 5-extractor lineup with explicit Appendix A Table 6 documentary superiority over canonical SP+LightGlue)
- **Publication Date**: arXiv preprint 2020-06-24 (v1); NeurIPS 2020 publication December 2020
- **Timeliness Status**: ✅ Within Critical-novelty window (2020 — established competitive ground for sparse-extractor reference); Established-competitive-modern-extractor exemption applies (DISK is the canonical RL-policy-gradient sparse extractor reference, with its main innovation being the bridging of training/inference discreteness gap; ALIKED paper §I + Source #71 LightGlue paper §3 both cite DISK as the modern competitive baseline)
- **Version Info**: arXiv v1 (June 2020, NeurIPS 2020 camera-ready). **Title note**: arXiv title "Local feature detection and description with policy gradient" is the original arXiv submission title; NeurIPS 2020 camera-ready title was changed to "DISK: Learning local features with policy gradient" (the canonical title used in the canonical README citation). **Paper §1–2 Introduction + Related Work**: position DISK as the bridge between fully-end-to-end-trainable methods (with surrogate losses) and RL-based-detection methods (which had been limited to detection-only with hand-crafted descriptors due to weak training signal); DISK's main RL-training contribution is the relaxation to a "find many correct feature matches" surrogate objective that allows robust training from scratch with policy gradient. **Paper §3 Related Work + §4 Method**: 4-layer U-Net architecture; per-pixel dense descriptor head; per-pixel scoring head; training via policy gradient with depth-based or epipolar reward; `inverse_T = θ_M` matching temperature scheduling. **Paper §5 Experiments**: HPatches MMA@3 (vs SuperPoint, R2D2, D2-Net, AS-LFeat — competitive top-tier; paper Figure 5 cached in canonical repo `results/hpatches/`); IMW2020 test set stereo + multiview AUC numbers (best single-extractor result at publication time per paper Table 1); 3D reconstruction quality on IMW competition images.
- **Target Audience**: System architects + C3 implementer + Step-7.5 reviewer
- **Research Boundary Match**: **Full match** for the algorithm (DISK with 4-layer U-Net + deformable bottleneck + per-pixel dense descriptor head + RL-policy-gradient training); **partial match** for the project's domain (paper benchmarks: HPatches Figure 5 [planar scenes with illumination + viewpoint changes], IMW2020 stereo + multiview reconstruction [phototourism dataset]; **NO aerial nadir benchmark** in the canonical paper; **NO Aachen Day-Night benchmark** in the canonical paper — Aachen results from DISK come from cross-paper evaluation in the ALIKED paper Source #75 Table VII via mNN matcher, plus from Source #71 LightGlue paper Appendix A which documents DISK+LightGlue on IMC 2020/2021/2023 + Aachen as cross-source evaluation). **Critical paper §3 reference position**: DISK is positioned as the **RL-policy-gradient end-to-end sparse extractor that closes the training/inference discreteness gap**; the paper explicitly positions itself against (a) surrogate-loss methods (SuperPoint, R2D2, D2-Net) that approximate the matching objective and (b) Q-learning methods (GLAMpoints, Reinforced Feature Points) that rely on hand-crafted descriptors or pre-trained components. DISK's contribution is to combine policy gradient with end-to-end-learnable description for the first time at competitive accuracy.
- **Summary**: The canonical paper introduces DISK with three core contributions: (i) **Policy-gradient end-to-end training of detection + description** that closes the training/inference discreteness gap that surrogate-loss methods approximate; (ii) **Surrogate objective "find many correct feature matches"** that gives stable RL training signal — enables training from scratch (vs Reinforced Feature Points which requires SuperPoint pre-training); (iii) **Inverse-softmax matching temperature `θ_M` scheduling** annealed from 15 to 50 over 20 epochs to bridge the RL stochasticity-to-discreteness gap. **Reported headline performance on IMW2020 (paper Table 1, 2k features)**: DISK 0.51315 stereo AUC + 0.72705 multiview AUC — best single-extractor result at 2020 publication time. **HPatches MMA (paper Figure 5)**: competitive with SuperPoint, R2D2, D2-Net, ASLFeat (cached results available in canonical repo `results/hpatches/` for cross-paper comparison). **By transitive cross-paper lineage**: ALIKED paper Source #75 Table III = DISK 1.092M params / 98.97 GFLOPs / 11.81 FPS RTX 2060 / MMA@3=77.59% / MHA@3=70.56% (vs SuperPoint 1.301M params / 26.11 GFLOPs / 52.63 FPS / MMA@3=65.37 / MHA@3=70.19; vs ALIKED-N(16) 0.677M params / 4.05 GFLOPs / 77.40 FPS / MMA@3=74.43 / MHA@3=77.22) — DISK has highest MMA@3 (best per-pixel matching accuracy among the three) but lowest FPS due to dense descriptor head. **CRITICAL OBSERVATION FOR THE PROJECT**: cvg/LightGlue paper Source #71 Appendix A Table 6 documents DISK+LightGlue stereo AUC@5° on IMC 2020 = 67.02 vs SP+LightGlue 59.03 = **+7.99 absolute documentary technical superiority** + DISK+LightGlue stereo AUC@10° = 83.45 vs SP+LightGlue 77.96 = **+5.49 absolute** — DISK+LightGlue is the **demonstrably best documented LightGlue-extractor-sibling on phototourism stereo with full Apache-2.0 license track preservation throughout**. **License**: Apache-2.0 via Source #76 — canonical implementation. **Limitations (paper §6 + cross-paper observations)**: DISK's RL-policy-gradient training is computationally expensive (~2 weeks on 32 GB V100; ~2 weeks at smaller batch/chunk size on 12 GB GPUs for low-memory training); DISK's 98.97 GFLOPs at 640×480 + 1k keypoints is the **highest among modern competitive sparse extractors** (24.4× higher than ALIKED-N(16); 3.8× higher than SuperPoint) — partial mitigation via LightGlue-ONNX TensorRT acceleration pathway (Source #73 + Source #76); aerial-domain caveat shared with all C-row components (D-C2-1 reuse — canonical training is on MegaDepth phototourism via depth-map-supervised RL, NOT aerial nadir).
- **Related Sub-question**: SQ3+SQ4 / C3 — DISK+LightGlue per-mode API capability verification (cross-source verification of canonical paper architectural details + benchmark numbers + RL training paradigm; documents the IMW2020 stereo + multiview reconstruction documentary advantage of DISK over SuperPoint at canonical paper publication time, plus the cross-paper LightGlue paper Appendix A Table 6 DISK+LightGlue +7.99 absolute AUC@5° superiority over canonical SP+LightGlue on IMC 2020 stereo as the **strongest documentary technical-superiority signal** for the D-C3-1 RECOMMENDED-PRIMARY-mitigation lock; aerial-domain caveat documented; D-C3-1 RECOMMENDED-PRIMARY-mitigation status confirmed)


### Source #78
- **Title**: SuperGlue canonical implementation — `magicleap/SuperGluePretrainedNetwork` (Sarlin, DeTone, Malisiewicz, Rabinovich — CVPR 2020 Oral) — official PyTorch reference implementation, README + Magic Leap "ACADEMIC OR NON-PROFIT ORGANIZATION NONCOMMERCIAL RESEARCH USE ONLY" Software License Agreement (identical wording to Source #72 SuperPoint LICENSE), `demo_superglue.py` (live webcam demo) + `match_pairs.py` (image-pair matching + evaluation) runnable inference scripts, two pretrained checkpoints `superglue_indoor.pth` (ScanNet-trained) + `superglue_outdoor.pth` (MegaDepth-trained), inference-only release (training code explicitly NOT released per README "We do not intend to release the SuperGlue training code"); SuperGlue is paired exclusively with canonical SuperPoint extractor (no SIFT-based or homography variants released per README) — both inherit Magic Leap restrictive license
- **Link**: README https://raw.githubusercontent.com/magicleap/SuperGluePretrainedNetwork/master/README.md (accessed 2026-05-08); LICENSE https://raw.githubusercontent.com/magicleap/SuperGluePretrainedNetwork/master/LICENSE (accessed 2026-05-08; **Magic Leap "ACADEMIC OR NON-PROFIT ORGANIZATION NONCOMMERCIAL RESEARCH USE ONLY" SLA = identical wording to Source #72 SuperPoint LICENSE**); GitHub API license metadata https://api.github.com/repos/magicleap/SuperGluePretrainedNetwork (accessed 2026-05-08; `license.spdx_id: "NOASSERTION"` confirming non-OSI-approved license); repo https://github.com/magicleap/SuperGluePretrainedNetwork (4005 stars, 761 forks, last pushed 2024-08-30 — mature reference codebase status)
- **Tier**: L1 (project-official codebase by the canonical SuperGlue authors Paul-Edouard Sarlin + Daniel DeTone + Tomasz Malisiewicz + Andrew Rabinovich, Magic Leap; same author group as Source #72 SuperPoint canonical; CVPR 2020 Oral publication; canonical implementation referenced by every subsequent feature-matching paper as the "long-established graph-neural-network sparse matcher reference baseline"; explicitly displaced by LightGlue per Source #71 paper §5 documentary 4-10× speedup at competitive accuracy)
- **Publication Date**: CVPR 2020 (paper accepted Oral track); arXiv preprint v1 2019-11-26; canonical repo creation 2020-03-17; last pushed 2024-08-30 (4 years of stable maintenance for inference-only codebase, no training-code release ever)
- **Timeliness Status**: ✅ Within Established-baseline-reference window (2020 publication; the long-established graph-neural-network sparse matcher reference baseline that defines the mandatory-simple-baseline role per the engine Component Option Breadth rule); Established-competitive-mandatory-baseline exemption applies (SuperGlue is the **canonical sparse-matcher mandatory-simple-baseline reference** for the C3 row; cited as the displaced reference in Source #71 LightGlue paper §1 + §5 + Appendix A; cited in every modern feature-matching paper as the predecessor that LightGlue exceeds)
- **Version Info**: master HEAD at access time (last pushed 2024-08-30). **Mode-enumeration query (1/3) — context7 NOT INDEXED + WebFetch fallback PASS** — `context7 resolve-library-id` returned no relevant matches for "SuperGlue" feature matcher (top-result was Superglue API orchestration which is unrelated to feature-matching); per Per-Mode API Capability Verification rule item 2, fall-back to official-docs WebFetch on the canonical magicleap/SuperGluePretrainedNetwork README + LICENSE + GitHub API license metadata was used. **Two SuperGlue pretrained checkpoints**: `superglue_indoor.pth` (ScanNet-trained, default; recommended config `--resize 640 --superglue indoor --max_keypoints 1024 --nms_radius 4`) + `superglue_outdoor.pth` (MegaDepth-trained; recommended config `--resize 1600 --superglue outdoor --max_keypoints 2048 --nms_radius 3 --resize_float`). **Operating bounds**: README explicitly recommends NOT running SuperPoint+SuperGlue below 160×120 resolution (QQVGA) or above 2000×1500. **CLI structure**: two main top-level scripts — `demo_superglue.py` (live webcam/IP-camera/directory/movie demo with keyboard control) + `match_pairs.py` (image-pair matching from text-file list + optional evaluation if ground truth provided). **Output dict format** (per `.npz` file structure documented in README): `{keypoints0: (N0, 2), keypoints1: (N1, 2), matches: (N0,) array of indices into keypoints1 with -1 for unmatched, match_confidence: (N0,)}`; the optional `--eval` mode adds `{error_t, error_R, precision, matching_score, num_correct, epipolar_errors}`. **Architecture** (per README): "Graph Neural Network combined with an Optimal Matching layer that is trained to perform matching on two sets of sparse image features" — operates as a "middle-end" performing context aggregation + matching + filtering in a single end-to-end architecture. **Pairing**: SuperGlue is **paired exclusively with canonical SuperPoint extractor**; README explicitly states "We do not intend to release the SIFT-based or homography SuperGlue models" — there is NO non-Magic-Leap-extractor variant of canonical SuperGlue. **CRITICAL RETRAIN BLOCKER**: README explicitly states "We do not intend to release the SuperGlue training code" — **training code is NOT released**, blocking any project-side D-C2-1 retrain decision for SuperGlue+SuperPoint pinned mode. **Documentary results** (per README evaluation tables): ScanNet test set (1500 indoor pairs) AUC@5/10/20 = **16.12/33.76/51.79**, Prec=84.37, MScore=31.14; YFCC test set (4000 outdoor pairs) AUC@5/10/20 = **39.02/59.51/75.72**, Prec=98.72, MScore=23.61. **Phototourism evaluation** is mentioned but not directly reproducible (Image Matching Challenge 2020 keeps test set ground truth private). **Hloc integration**: README explicitly cross-references `cvg/Hierarchical-Localization` (hloc) toolbox where SuperGlue is the canonical matcher prior to LightGlue's release; "Winner of 3 CVPR 2020 competitions on localization and image matching!" per README.
- **Target Audience**: System architects + C3 implementer + Step-7.5 reviewer + license-posture decision-maker (D-C1-1 + D-C3-1 — same Magic Leap restrictive HARD DISQUALIFIER as canonical SP+LightGlue applies to canonical SuperGlue+SuperPoint)
- **Research Boundary Match**: **Full match** for the project's pinned mode of SuperGlue+SuperPoint mandatory-simple-baseline reference (single-image-pair sparse feature matching: take a UAV nadir frame + a retrieved satellite tile, run SuperPoint feature extraction on each independently, match via SuperGlue with `outdoor` checkpoint, return 2D-2D correspondences with confidence scores feeding the project's downstream C4 PnP+RANSAC pose estimator). The repo ships everything needed for **inference-only** evaluation: SuperPoint extractor (MagicLeap-pretrained, inherits Source #72 license), SuperGlue matcher (two pretrained checkpoints), `match_pairs.py` evaluation script, sample image pairs with ground truth. **Asymmetric image-pair sizes are handled natively** — same independent per-image extraction pattern as SP+LightGlue. **Partial match** for the project's domain (canonical training on **ScanNet indoor + MegaDepth phototourism outdoor scenes** — neither dataset is aerial nadir; **same aerial-domain caveat as SP+LightGlue + DISK+LightGlue + ALIKED+LightGlue + C2 candidates**; aerial applicability is **NOT explicitly validated in the canonical paper or README** — project-side via Jetson MVE on AerialExtreMatch + Derkachi flight; **D-C2-1 retrain decision is BLOCKED for SuperGlue+SuperPoint pinned mode** since training code is not released). **CRITICAL NEGATIVE finding for the role assessment**: SuperGlue+SuperPoint is **strictly inferior to SP+LightGlue + DISK+LightGlue + ALIKED+LightGlue** for the project's deployment as a *Selected* candidate because: (i) **Same Magic Leap restrictive HARD DISQUALIFIER** as canonical SP+LightGlue (LICENSE wording is identical to Source #72) — blocks dual-use deployment; (ii) **No retrain capability** — training code explicitly not released; (iii) **4-10× slower than LightGlue** at similar accuracy per Source #71 paper §5 + Table 2 documentary evidence; (iv) **No alternative extractor** — paired exclusively with Magic Leap SuperPoint, no SIFT or homography variants released. **POSITIVE for the role**: SuperGlue+SuperPoint **IS** the canonical sparse-matcher mandatory-simple-baseline that the engine's Component Option Breadth rule requires to be cataloged — establishes the long-established reference floor against which modern leads (LightGlue, XFeat) must measurably exceed.
- **Summary**: SuperGlue is the canonical **graph-neural-network sparse matcher** introduced by Sarlin, DeTone, Malisiewicz, and Rabinovich (CVPR 2020 Oral), with **attentional graph neural network + optimal matching layer as its main contributions** — operates as a "middle-end" that takes two sets of SuperPoint keypoints + descriptors as input and outputs a soft assignment matrix between them; trained to perform matching end-to-end with attention-based context aggregation + Sinkhorn algorithm for optimal transport assignment. **CRITICAL LICENSE FINDING**: LICENSE file contents are **byte-for-byte identical** to Source #72 SuperPoint LICENSE = **Magic Leap "ACADEMIC OR NON-PROFIT ORGANIZATION NONCOMMERCIAL RESEARCH USE ONLY" Software License Agreement** — non-OSI-approved (GitHub API `license.spdx_id: "NOASSERTION"`); same wording: "Licensee a personal, non-exclusive, non-transferable license to use the Software for noncommercial research purposes" + "You may not distribute, copy or use the Software except as explicitly permitted herein" + "You may not sell, rent, lease, sublicense, lend, time-share or transfer". **HARD DISQUALIFIER for canonical SuperGlue+SuperPoint mode in project's dual-use deployment context** (eastern/southern Ukraine fixed-wing UAV with AC-NEW-2 spoofing-promotion path is dual-use military by every reasonable interpretation, and the project's question_decomposition.md hard disqualifier list includes "anything whose license blocks military / dual-use deployment"). **Training code explicitly NOT released** per README — D-C2-1 retrain decision is **BLOCKED** for SuperGlue+SuperPoint pinned mode. **Documentary headline performance vs LightGlue** (per Source #71 paper §5 + Table 2 cross-cite): SuperGlue is **4-10× slower than LightGlue** at competitive but slightly lower accuracy; LightGlue paper Table 2 documents SP+LightGlue MegaDepth-1500 AUC@5°/10°/20° = 66.7/79.3/87.9 at 44.2 ms standard / 31.4 ms adaptive RTX 3080, vs SP+SuperGlue at slightly lower AUC + 4-10× slower runtime. **Documentary results in canonical README**: ScanNet test (indoor, 1500 pairs) AUC@5/10/20 = 16.12/33.76/51.79; YFCC test (outdoor, 4000 pairs) AUC@5/10/20 = 39.02/59.51/75.72. **Architecture**: graph neural network with self-attention + cross-attention layers (paper §3.1) + optimal matching layer with dustbin (paper §3.2) + Sinkhorn algorithm for soft assignment (paper §3.2.2). **Modern lineage**: SuperGlue (CVPR 2020) is the predecessor of LightGlue (ICCV 2023, Source #70 + #71); SuperGlue is also the predecessor of SuperGlue-LoRA + LoFTR + DKM + RoMa + MASt3R successor lineage — but per Fact #26 NGPS pre-screen template, dense matchers (LoFTR, DKM, RoMa, MASt3R) are pruned outright on AC-4.1 Jetson dense-matcher-latency disqualifier. **Limitations**: (a) Magic Leap restrictive license HARD DISQUALIFIER (same as Source #72); (b) no training-code release blocks aerial-domain retrain; (c) 4-10× slower than LightGlue; (d) paired exclusively with Magic Leap SuperPoint extractor (no Apache-2.0 / BSD-3-Clause extractor pairing variants released); (e) no FlashAttention support (LightGlue's structural advantage); (f) no adaptive-depth/adaptive-width pruning (LightGlue's structural advantage paper §3.3); (g) no canonical Jetson ONNX/TensorRT export pathway in the LightGlue-ONNX equivalent project (SuperGlue's ONNX export is community-maintained third-party, not productized).
- **Related Sub-question**: SQ3+SQ4 / C3 — SuperGlue+SuperPoint mandatory-simple-baseline per-mode API capability verification (Mandatory `context7` lookup NOT INDEXED + WebFetch fallback PASS per Per-Mode rule item 2; cross-validated against canonical README + LICENSE WebFetch + canonical paper [Source #79] + GitHub API license metadata; **HARD-LICENSE-DISQUALIFIER applies to canonical SuperGlue+SuperPoint mode in project's dual-use deployment context** — same Magic Leap restrictive license as canonical SP+LightGlue; **TRAINING-CODE-NOT-RELEASED** blocks D-C2-1 retrain decision; **role per engine Component Option Breadth rule = mandatory-simple-baseline reference floor** that establishes the long-established sparse-matcher reference against which modern leads must measurably exceed; documented Recall@K + AUC consistently 1-3 absolute below LightGlue across HPatches / MegaDepth / Aachen / IMC at 4-10× slower runtime per Source #71)


### Source #79
- **Title**: SuperGlue canonical paper — "SuperGlue: Learning Feature Matching with Graph Neural Networks" (Sarlin, DeTone, Malisiewicz, Rabinovich — CVPR 2020 Oral, arXiv:1911.11763)
- **Link**: arXiv abstract https://arxiv.org/abs/1911.11763 (November 2019; CVPR 2020 camera-ready); arXiv full PDF https://arxiv.org/pdf/1911.11763.pdf ; CVPR 2020 proceedings https://openaccess.thecvf.com/content_CVPR_2020/papers/Sarlin_SuperGlue_Learning_Feature_Matching_With_Graph_Neural_Networks_CVPR_2020_paper.pdf ; psarlin.com/superglue (project website with videos, slides, recent updates); accessed 2026-05-08
- **Tier**: L1 (peer-reviewed CVPR 2020 Oral + canonical implementation cross-referenced; documented predecessor of LightGlue per Source #71 paper §1; cited by 2020-2026 feature-matching papers as the "graph-neural-network sparse matcher reference baseline"; winner of 3 CVPR 2020 competitions on localization and image matching per Source #78 README)
- **Publication Date**: arXiv preprint 2019-11-26 (v1); CVPR 2020 publication June 2020 (Oral track)
- **Timeliness Status**: ✅ Within Established-baseline-reference window (2020 — established competitive ground for sparse-matcher reference; Established-competitive-mandatory-baseline exemption applies — SuperGlue is the canonical sparse-matcher reference baseline that defines the mandatory-simple-baseline role for the C3 row per the engine Component Option Breadth rule)
- **Version Info**: arXiv v1 (November 2019, CVPR 2020 Oral camera-ready). **Paper §3 architecture**: Attentional Graph Neural Network with bidirectional self-attention and cross-attention layers + Optimal Matching Layer with dustbin handling + Sinkhorn algorithm for differentiable optimal transport assignment. **Paper §4 training**: end-to-end training with sparse keypoint correspondence supervision; ScanNet for indoor model; MegaDepth for outdoor model; trained checkpoints (released) but training code (NOT released per Source #78 README). **Paper §5 experiments**: ScanNet indoor pose estimation (Table 1; outperforms ratio test, mutual nearest-neighbor, OANet, NN-RANSAC); YFCC outdoor pose estimation (Table 2; outperforms same set of baselines); Phototourism reconstruction (Table 3; competitive with NN+RANSAC + GMS at higher pose accuracy); HPatches homography estimation (Table 4; matches the displacement-only state-of-the-art).
- **Target Audience**: System architects + C3 implementer + Step-7.5 reviewer
- **Research Boundary Match**: **Full match** for the algorithm (SuperGlue with attentional GNN + Sinkhorn optimal matching layer + dustbin handling); **partial match** for the project's domain (paper benchmarks: ScanNet indoor, YFCC outdoor, Phototourism reconstruction, HPatches homography — **NO aerial nadir benchmark** in the canonical paper). **Critical paper §5 reference position**: SuperGlue is positioned as **the** sparse-matcher state-of-the-art at 2020 publication time, displacing classical mutual nearest-neighbor + RANSAC baselines + earlier learned matchers (OANet, NG-RANSAC, ACNe). The paper's main contribution is closing the gap between hand-crafted matchers (which have well-defined fallback semantics) and learned matchers (which prior to SuperGlue often degraded out-of-domain). **For the project's mandatory-simple-baseline role**: SuperGlue+SuperPoint is the **long-established sparse-matcher reference baseline that defines the simple-baseline floor** against which modern leads (LightGlue, XFeat) must measurably exceed.
- **Summary**: The canonical paper introduces SuperGlue with three core contributions: (i) **Attentional Graph Neural Network with self-attention + cross-attention** that aggregates context across the matching image pair, allowing each keypoint to be matched based on both intra-image and inter-image structure; (ii) **Optimal Matching Layer with dustbin handling** (paper §3.2) that produces a soft assignment matrix where unmatched keypoints are assigned to a dustbin; (iii) **Sinkhorn algorithm for differentiable optimal transport** (paper §3.2.2) that allows end-to-end training of the entire matching pipeline. **Documentary headline results** (paper §5): ScanNet indoor pose estimation Table 1 outperforms NN+RANSAC + ratio test + OANet across all AUC tiers; YFCC outdoor pose estimation Table 2 outperforms same baselines; Phototourism reconstruction Table 3 competitive with state-of-the-art at higher pose accuracy; HPatches homography estimation Table 4 matches state-of-the-art. **Documentary cross-reference with LightGlue** (Source #71 paper Table 2 cross-cite): **LightGlue is 4-10× faster than SuperGlue at competitive accuracy** — SP+LightGlue MegaDepth-1500 AUC@5°/10°/20°=66.7/79.3/87.9 at 44.2 ms standard / 31.4 ms adaptive RTX 3080 vs SP+SuperGlue similar AUC at 4-10× slower runtime; the LightGlue paper §1 explicitly positions LightGlue as the displacement of SuperGlue in the canonical NetVLAD top-K → sparse matcher → PnP+RANSAC pipeline shape. **License**: Magic Leap restrictive via Source #78 — canonical implementation. **Limitations**: (a) Magic Leap restrictive license HARD DISQUALIFIER (same as Source #72 SuperPoint and Source #78 SuperGlue); (b) no training-code release per Source #78 README blocks D-C2-1 retrain; (c) displaced by LightGlue per Source #71 paper §5 + Table 2 documentary 4-10× speedup at competitive accuracy; (d) paired exclusively with canonical SuperPoint extractor (no SIFT or homography variants released); (e) no FlashAttention or adaptive-depth/adaptive-width pruning structural advantages; (f) no productized Jetson ONNX/TensorRT export pathway (SuperGlue ONNX export is community-maintained third-party, not productized in the LightGlue-ONNX equivalent project).
- **Related Sub-question**: SQ3+SQ4 / C3 — SuperGlue+SuperPoint mandatory-simple-baseline per-mode API capability verification (cross-source verification of canonical paper architectural details + benchmark numbers + training paradigm; documents the displaced-by-LightGlue reference position as the **long-established sparse-matcher reference baseline** that defines the simple-baseline floor for the C3 row per the engine Component Option Breadth rule; HARD-LICENSE-DISQUALIFIER applies + TRAINING-CODE-NOT-RELEASED blocks retrain; aerial-domain caveat documented; mandatory-simple-baseline role confirmed)


### Source #80
- **Title**: XFeat canonical implementation — `verlab/accelerated_features` (Potje, Cadar, Araujo, Martins, Nascimento — CVPR 2024) — official PyTorch reference implementation, README + Apache 2.0 LICENSE; minimalist 3-line inference API (`from modules.xfeat import XFeat; xfeat = XFeat(); output = xfeat.detectAndCompute(torch.randn(1,3,480,640), top_k=4096)[0]`); Torch Hub one-liner `torch.hub.load('verlab/accelerated_features', 'XFeat', pretrained=True, top_k=4096)`; two main inference modes — sparse (`xfeat`) + semi-dense (`xfeat-star`); training code released (notebook `XFeat_training_example.ipynb` + `python3 -m modules.training.train --training_type xfeat_default --megadepth_root_path <...> --synthetic_root_path <...> --ckpt_save_path <...>`); built-in evaluation harnesses (`python3 -m modules.eval.megadepth1500 --matcher xfeat` + `python3 -m modules.eval.scannet1500`); real-time webcam demo (`python3 realtime_demo.py --method XFeat`); **NEW: XFeat+LighterGlue** companion mode (~3× faster than original LightGlue, trained by VerLab using `cvg/glue-factory` library, distributed via `xfeat+lg_torch_hub.ipynb` notebook); kornia integration (acknowledged in README); **CRITICAL Contributing-section ask**: "Currently, it would be nice to have an export script to efficient deployment engines such as TensorRT and ONNX" — **ONNX/TensorRT export pathway is COMMUNITY-CONTRIBUTION-NEEDED, NOT productized in canonical repo** (HARSHER D-C3-2 gate than DISK+LightGlue's well-documented LightGlue-ONNX TensorRT pathway, but TECHNICALLY SIMPLER than ALIKED+LightGlue's `torchvision.ops.deform_conv2d` ONNX-export blocker because XFeat is CNN-only with no deformable convolutions or unusual ops)
- **Link**: README https://raw.githubusercontent.com/verlab/accelerated_features/main/README.md (accessed 2026-05-08); GitHub API license metadata https://api.github.com/repos/verlab/accelerated_features (accessed 2026-05-08; `license.spdx_id: "Apache-2.0"`); repo https://github.com/verlab/accelerated_features (1614 stars, 207 forks, last pushed 2025-01-15 — actively maintained CVPR 2024 reference codebase with training-code-released + companion XFeat+LighterGlue + minimal-dependency PyTorch-only architecture); project page https://www.verlab.dcc.ufmg.br/descriptors/xfeat_cvpr24/ ; HuggingFace Spaces demo https://huggingface.co/spaces/qubvel-hf/xfeat ; eight Colab notebooks distributed in-tree (`minimal_example.ipynb`, `xfeat_matching.ipynb`, `xfeat_torch_hub.ipynb`, `XFeat_training_example.ipynb`, `xfeat+lg_torch_hub.ipynb`)
- **Tier**: L1 (project-official codebase by the canonical XFeat authors; CVPR 2024 publication acceptance; canonical implementation referenced in subsequent feature-matching papers as the modern-lightweight learned-feature reference; UFMG VerLab is the authors' affiliation and maintains the project; cross-affiliations span UFMG + Université de Bourgogne + Google Research + Université de Lorraine + Microsoft)
- **Publication Date**: CVPR 2024 paper acceptance + canonical repo creation 2024-04-15; last pushed 2025-01-15 (9 months of active maintenance, ongoing community contributions including XFeat+LighterGlue companion mode added post-paper-acceptance)
- **Timeliness Status**: ✅ Within Modern-competitive-lead window (2024 — modern competitive lightweight-CNN reference; XFeat is the modern-lightweight-CNN reference baseline that defines the modern-lead role for the C3 row's lightweight-CNN axis)
- **Version Info**: main HEAD at access time (last pushed 2025-01-15). **Mode-enumeration query (1/3) — context7 NOT INDEXED + WebFetch fallback PASS** — `context7 resolve-library-id` returned `just-sultanov/xfeat` git-worktree-management CLI utility (UNRELATED to the canonical XFeat feature-matching library); per Per-Mode API Capability Verification rule item 2, fall-back to official-docs WebFetch on the canonical verlab/accelerated_features README + GitHub API license metadata + canonical paper (Source #81) was used. **Three primary inference modes**: (i) **XFeat sparse** with `top_k=4096` keypoints + 64-D float descriptors + Mutual Nearest Neighbor (MNN) matching; (ii) **XFeat\* semi-dense** with up to 10k features + 2-scale processing (0.65× + 1.3× input resize) + MNN + lightweight MLP-based offset refinement (offset prediction confidence threshold 0.2); (iii) **XFeat+LighterGlue** with VerLab-trained smaller LightGlue variant (~3× faster than original LightGlue per README claim). **Operating bounds**: README claims VGA real-time on Intel i5 CPU + 1,400 FPS batched RTX 4090 at VGA + 150 FPS single-batch RTX 4090 at VGA; paper Table 1 documents 27.1 FPS XFeat / 19.2 FPS XFeat\* on Intel i5-1135G7 CPU at VGA. **Supports gray-scale or RGB input** (paper §3.1 explicitly grayscale `H×W×C` with `C=1`; PyTorch tensor accepts `(B, 3, H, W)` per README minimal example). **CLI structure**: minimalist 3-line inference API + Torch Hub one-liner + 8 Colab notebooks + 3 evaluation scripts + 1 real-time webcam demo. **Output dict format**: per-image dict `{keypoints: (N, 2), scores: (N,), descriptors: (64, N) or (N, 64) depending on mode}` for sparse mode (XFeat); semi-dense mode (XFeat\*) adds `match_confidences` from MLP offset refinement. **Architecture** (per paper §3 + README): featherweight CNN backbone with channel sequence `{4, 8, 24, 64, 64, 128}` (paper §3.1 triple-rate channel increase vs VGG's double-rate); 23 convolutional layers organized as 6 spatial-halving blocks + 2 fusion blocks; basic layer = Conv + ReLU + BatchNorm; **DECOUPLED keypoint detection branch** using 1×1 convolutions on 8×8 tensor-block-transformed image (paper §3.2 Keypoint Head); descriptor head = feature pyramid merging at 1/8, 1/16, 1/32 scales bilinearly upsampled to 1/8 + element-wise summation + fusion block; reliability map regression branch; match refinement module = lightweight MLP predicting 8×8 pixel-level offset distribution. **Pairing options** (per README): standalone XFeat sparse with MNN matching / standalone XFeat\* semi-dense with MNN+offset-refinement / **XFeat+LighterGlue** paired matcher (NEW companion mode using `cvg/glue-factory`-trained LighterGlue variant ~3× faster than canonical LightGlue per README claim). **Training**: explicitly distributed in-tree (`XFeat_training_example.ipynb`); training command `python3 -m modules.training.train --training_type xfeat_default --megadepth_root_path <...> --synthetic_root_path <...> --ckpt_save_path <...>`; uses MegaDepth + COCO_20k synthetic warped-pairs at 6:4 ratio per paper §3.3; training **on entry-level hardware** (paper §3.3 mentions 6.5 GB VRAM total + 36 hours on single RTX 4090 + batch size 10 + Adam optimizer LR 3e-4 + exponential decay 0.5 every 30k updates + convergence at 160k iterations). **Documentary results** (per paper Table 1, MegaDepth-1500 i5-1135G7 CPU VGA, AUC@5/10/20 + FPS): SuperPoint AUC@5/10/20 = 37.3/50.1/61.5 at 3.0 FPS (4096 kpts) / DISK = 53.8/65.9/75.0 at 1.2 FPS (4096 kpts) / DISK\* = 55.2/66.8/75.3 at 1.2 FPS (10k kpts) / ALIKE-Tiny = 49.4/61.8/71.4 at 5.3 FPS (4096 kpts) / **XFeat sparse = 42.6/56.4/67.7 at 27.1 FPS** (4096 kpts; **9× faster than SuperPoint at HIGHER AUC + 5× faster than ALIKE**) / **XFeat\* semi-dense = 50.2/65.4/77.1 at 19.2 FPS** (10k features; **comparable to DISK\* at 16× speedup**); paper Table 2 ScanNet-1500 indoor: **XFeat AUC@5=16.7 / XFeat\*=18.4** vs SuperPoint=12.5 / DISK=9.6/11.3 / ALIKE=8.0 — **XFeat outperforms ALL other methods on ScanNet indoor** despite all methods being trained on MegaDepth (paper Appendix E attributes this to hybrid MegaDepth+synthetic-warp-COCO training reducing landmark-dataset overfitting bias); paper Table 3 HPatches Homography MHA@3 Illumination/Viewpoint = **95.0/68.6** (XFeat) — best Illumination@3 in paper Table 3 across all methods including SuperPoint 94.6 and DISK 94.6.
- **Embedded/CPU deployment claim** (per paper Appendix C): on **Orange Pi Zero 3 (Cortex-A53 ARM, $28 device)** at 480×360 input, XFeat=**1.8 FPS** vs SuperPoint=0.16 FPS vs ALIKE=0.58 FPS — **XFeat is the ONLY learned method capable of running over 1 FPS on highly-constrained embedded device** without neural-network-inference optimization; this is the strongest documented embedded-deployment signal among all C3 candidates evaluated. Project's Jetson Orin Nano Super has dedicated GPU (1024-core Ampere) — XFeat extrapolation to Jetson Orin Nano fp16 with TensorRT will be **substantially faster** than Orange Pi Zero 3 ARM CPU. **Documentary headline performance vs LightGlue siblings** (per README MegaDepth-1500 cross-cite vs SP+LightGlue): XFeat+LighterGlue Fast (640, 1300 kpts) AUC@5/10/20 = **0.444/0.610/0.746** vs SP+LightGlue 0.469/0.633/0.762 (-2.5/-2.3/-1.6 absolute); Accurate (1024, 4096 kpts) AUC@5/10/20 = **0.564/0.710/0.819** vs SP+LightGlue 0.591/0.738/0.841 (-2.7/-2.8/-2.2 absolute) — XFeat+LighterGlue is **modestly below SP+LightGlue** at competitive accuracy + ~3× LighterGlue speedup.
- **Target Audience**: System architects + C3 implementer + Step-7.5 reviewer + license-posture decision-maker (D-C1-1 — Apache-2.0 throughout = clean BSD/permissive track) + Plan-phase architect (modern-competitive-lead role for the C3 row's lightweight-CNN axis with strongest-documented-embedded-deployment signal among all C3 candidates evaluated)
- **Research Boundary Match**: **Full match** for the project's pinned mode of XFeat sparse / XFeat\* semi-dense / XFeat+LighterGlue paired matcher (single-image-pair sparse or semi-dense feature matching: take a UAV nadir frame + a retrieved satellite tile, run XFeat extractor on each independently, match via MNN sparse OR MLP-refinement-semi-dense OR LighterGlue-paired matcher, return 2D-2D correspondences with confidence scores feeding the project's downstream C4 PnP+RANSAC pose estimator). **Asymmetric image-pair sizes are handled natively** — same independent per-image extraction pattern as SP+LightGlue + DISK+LightGlue + ALIKED+LightGlue. **Partial match** for the project's domain (canonical training on MegaDepth phototourism outdoor + COCO_20k synthetic-warp pairs — neither dataset is aerial nadir; **same aerial-domain caveat as SP+LightGlue + DISK+LightGlue + ALIKED+LightGlue + C2 candidates**; **D-C2-1 retrain decision REUSED** with **strongest retrain-friendliness signal among all C3 candidates evaluated** — paper §3.3 explicit "low memory usage of our method enables training on entry-level hardware, facilitating the fine-tuning or full training of our network for specific tasks and scene types" + 36 hours on single RTX 4090 + 6.5 GB VRAM total). **Aerial applicability is NOT explicitly validated in canonical paper or README** — project-side via Jetson MVE on AerialExtreMatch + Derkachi flight; **D-C2-1 retrain decision is materially less expensive** than DISK+LightGlue (~2 weeks 32 GB V100) + ALIKED+LightGlue (~24 hours RTX 3090). **CRITICAL POSITIVE finding**: XFeat is the only C3 candidate with **explicit documentation of CPU-real-time inference + embedded-device benchmarks** (paper Appendix C Orange Pi Zero 3 numbers); README explicitly states "Simple architecture components which facilitates deployment on embedded devices (jetson, raspberry pi, custom AI chips, etc..)" — **strongest embedded-deployment story among all C3 candidates evaluated**. **CRITICAL NEGATIVE finding**: NO PRODUCTIZED ONNX/TensorRT export pathway in canonical repo (README Contributing section explicit ask) — **D-C3-2 gate is HARSHER than DISK+LightGlue but TECHNICALLY SIMPLER than ALIKED+LightGlue** because XFeat is CNN-only with no deformable convolutions or unusual ops; project would need to invest custom-ONNX-export engineering effort but the architecture is straightforward (Conv + ReLU + BatchNorm only, no `torchvision.ops.deform_conv2d` blocker, no graph-neural-network attention export complexity).
- **Summary**: XFeat is the canonical **lightweight-CNN learned feature extractor + matcher** introduced by Potje, Cadar, Araujo, Martins, and Nascimento (UFMG VerLab + Université de Bourgogne + Google Research + Université de Lorraine + Microsoft, CVPR 2024), with **three core contributions**: (i) lightweight CNN architecture with featherweight backbone using triple-rate channel increase (vs VGG's double-rate) channel sequence `{4, 8, 24, 64, 64, 128}` + 6 spatial-halving blocks + 2 fusion blocks + 23 total convolutional layers — designed for resource-constrained deployment without hardware-specific optimization; (ii) decoupled minimalist learnable keypoint detection branch using 1×1 convolutions on 8×8 tensor-block-transformed image with knowledge distillation from ALIKE-Tiny teacher; (iii) lightweight MLP-based match refinement module for pixel-level offsets from coarse semi-dense matches without high-resolution feature maps. **Two main inference modes**: **XFeat sparse** (top-K up to 4096 keypoints + 64-D float descriptors + MNN matching) and **XFeat\* semi-dense** (up to 10k features + 2-scale processing + MNN + MLP offset refinement). **NEW companion mode XFeat+LighterGlue** (VerLab-trained smaller LightGlue variant ~3× faster than original LightGlue per README claim, distributed in-tree via `xfeat+lg_torch_hub.ipynb`). **License: Apache 2.0** (canonical repo `license.spdx_id: "Apache-2.0"` per GitHub API metadata) — **clean BSD/permissive track throughout**, no copyleft + no Magic Leap restrictive disqualifier. **Documentary headline performance** (per paper Table 1 MegaDepth-1500 i5-1135G7 CPU VGA): **XFeat sparse AUC@5/10/20 = 42.6/56.4/67.7 at 27.1 FPS = 9× faster than SuperPoint at HIGHER AUC + 5× faster than ALIKE-Tiny**; **XFeat\* semi-dense AUC@5/10/20 = 50.2/65.4/77.1 at 19.2 FPS = comparable to DISK\* at 16× speedup**; paper Table 2 ScanNet-1500 indoor **XFeat outperforms all baselines including SuperPoint+DISK+ALIKE** despite all methods being MegaDepth-trained (paper Appendix E hybrid-training reduces landmark-dataset overfitting bias). **EMBEDDED DEPLOYMENT SIGNAL** (per paper Appendix C): on Orange Pi Zero 3 ($28 ARM Cortex-A53 device) at 480×360 input — XFeat=**1.8 FPS** vs SuperPoint=0.16 FPS vs ALIKE=0.58 FPS — **XFeat is the ONLY learned method capable of running over 1 FPS on highly-constrained embedded device** without neural-network-inference optimization. **Training**: 36 hours on single RTX 4090 + 6.5 GB VRAM total + MegaDepth + COCO_20k synthetic warp pairs at 6:4 ratio + 800×600 training resolution + batch size 10 + 160k iterations + Adam optimizer LR 3e-4 — **strongest retrain-friendliness signal among all C3 candidates evaluated** (vs DISK ~2 weeks 32 GB V100, ALIKED ~24 hours RTX 3090, SuperGlue training-code-not-released). **Limitations**: (a) NO PRODUCTIZED ONNX/TensorRT export pathway in canonical repo — README Contributing section explicit community-contribution ask; (b) AUC@5° on MegaDepth-1500 sparse mode (42.6) is materially below DISK (53.8) + DISK\* (55.2) + ALIKE-Tiny (49.4) — XFeat sparse is positioned as **"competitive accuracy at much higher speed"** rather than "best-accuracy"; (c) XFeat+LighterGlue MegaDepth-1500 AUC is modestly below SP+LightGlue at -2.5 to -2.8 absolute AUC@5° (Fast / Accurate configs); (d) aerial-domain training caveat shared with all C3 candidates evaluated; (e) 64-D descriptors (vs SP/DISK 256-D/128-D) provide cache-footprint advantage but may have weaker descriptor discrimination at extreme cross-domain matching (paper §4.3 visual localization validation on Aachen Day-Night not directly extracted in this session — section 4.3 referenced in paper but headline numbers not in extracted snippet).
- **Related Sub-question**: SQ3+SQ4 / C3 — XFeat per-mode API capability verification (Mandatory `context7` lookup NOT INDEXED + WebFetch fallback PASS per Per-Mode rule item 2; cross-validated against canonical README + GitHub API license metadata + canonical paper [Source #81]; **APACHE-2.0-CLEAN-LICENSE-THROUGHOUT** + **STRONGEST EMBEDDED-DEPLOYMENT SIGNAL AMONG ALL C3 CANDIDATES EVALUATED** (Orange Pi Zero 3 1.8 FPS; designed explicitly for "jetson, raspberry pi, custom AI chips, etc.") + **STRONGEST RETRAIN-FRIENDLINESS SIGNAL AMONG ALL C3 CANDIDATES EVALUATED** (36 hours on single RTX 4090, 6.5 GB VRAM total) + **NO PRODUCTIZED ONNX/TensorRT EXPORT PATHWAY** in canonical repo (README Contributing section explicit community-contribution ask — D-C3-2 gate HARSHER than DISK but TECHNICALLY SIMPLER than ALIKED) + **MODERN COMPETITIVE LEAD ROLE** for the C3 row's lightweight-CNN axis with two distinct inference modes (XFeat sparse / XFeat\* semi-dense) + companion XFeat+LighterGlue paired matcher mode + canonical evaluation harnesses for MegaDepth-1500 + ScanNet-1500; aerial-domain-training caveat documented; **D-C3-6 NEW Plan-phase decision** for XFeat-mode-choice required)


### Source #81
- **Title**: XFeat canonical paper — "XFeat: Accelerated Features for Lightweight Image Matching" (Potje, Cadar, Araujo, Martins, Nascimento — CVPR 2024, arXiv:2404.19174)
- **Link**: arXiv abstract https://arxiv.org/abs/2404.19174 (April 2024); arXiv full HTML https://arxiv.org/html/2404.19174v1 ; CVPR 2024 proceedings https://openaccess.thecvf.com/content/CVPR2024/html/Potje_XFeat_Accelerated_Features_for_Lightweight_Image_Matching_CVPR_2024_paper.html ; project page https://www.verlab.dcc.ufmg.br/descriptors/xfeat_cvpr24/ (videos, slides, supplementary material); accessed 2026-05-08
- **Tier**: L1 (peer-reviewed CVPR 2024 + canonical implementation cross-referenced; cited by 2024-2026 feature-matching papers as the modern-lightweight-CNN reference for resource-constrained deployment; UFMG VerLab + multiple cross-affiliations including Google Research + Microsoft underscoring the paper's industry credibility)
- **Publication Date**: arXiv preprint 2024-04-30 (v1); CVPR 2024 publication June 2024
- **Timeliness Status**: ✅ Within Modern-competitive-lead window (2024 — modern competitive lightweight-CNN reference; **strongest embedded-deployment signal among modern competitive C3 candidates** at the publication time and through the project's evaluation window 2026)
- **Version Info**: arXiv v1 (April 2024, CVPR 2024 camera-ready). **Paper §3 architecture**: featherweight CNN backbone with channel sequence `{4, 8, 24, 64, 64, 128}` (paper §3.1 triple-rate channel increase vs VGG's double-rate); 23 convolutional layers organized as 6 spatial-halving blocks + 2 fusion blocks; decoupled keypoint detection branch (paper §3.2 Keypoint Head) using 1×1 convolutions on 8×8 tensor-block-transformed image with knowledge distillation from ALIKE-Tiny teacher; descriptor head (paper §3.2 Descriptor head) = feature pyramid merging at 1/8, 1/16, 1/32 scales bilinearly upsampled to 1/8 + element-wise summation + fusion block; reliability map regression branch; **match refinement module (paper §3.2 Dense matching)** = lightweight MLP predicting 8×8 pixel-level offset distribution conditioned on coarsely matched feature pair. **Paper §3.3 training**: dual-softmax loss for descriptor learning + L1 reliability loss + NLL fine-matching loss for offset prediction + NLL keypoint loss with knowledge distillation from ALIKE-Tiny; trained on MegaDepth + synthetic warped COCO at 6:4 ratio + 800×600 input + batch size 10 + 160k iterations + Adam LR 3e-4 + exponential decay 0.5 every 30k updates + 36 hours on single RTX 4090 + 6.5 GB VRAM total. **Paper §4 experiments**: MegaDepth-1500 (Table 1, outdoor pose estimation) + ScanNet-1500 (Table 2, indoor pose estimation) + HPatches (Table 3, homography estimation) + Aachen Day-Night (Section 4.3, visual localization via HLoc) + Appendix F (Table 6, learned-matcher comparison vs LoFTR, LightGlue, Patch2Pix). **Paper Appendix C detailed timing analysis**: i7-6700K CPU + Orange Pi Zero 3 ARM Cortex-A53 embedded device (480×360 input, XFeat=1.8 FPS vs SuperPoint=0.16 FPS vs ALIKE=0.58 FPS) — **XFeat is the ONLY learned method capable of running over 1 FPS on highly-constrained embedded device** without neural-network-inference optimization at the publication time.
- **Target Audience**: System architects + C3 implementer + Step-7.5 reviewer + license-posture decision-maker (D-C1-1 — clean Apache-2.0) + Plan-phase architect (modern-competitive-lead role + strongest embedded-deployment signal in the C3 row + strongest retrain-friendliness signal in the C3 row)
- **Research Boundary Match**: **Full match** for the algorithm (XFeat lightweight-CNN feature extractor with featherweight backbone + decoupled keypoint head + lightweight MLP-based match refinement module); **partial match** for the project's domain (paper benchmarks: MegaDepth-1500 outdoor phototourism, ScanNet-1500 indoor RGB-D, HPatches homography, Aachen Day-Night day/night visual localization — NO aerial nadir benchmark in the canonical paper). **Critical paper §4 + Appendix F documentary cross-cite**: XFeat\* semi-dense at 1885 inliers and PPS=1.33 vs LightGlue 475 inliers PPS=0.31 (paper Appendix F Table 6) — XFeat\* delivers **4× more inliers per pair than LightGlue at 4× higher throughput**, demonstrating fundamental architectural advantage in the semi-dense matching paradigm vs sparse-only learned matchers. **Paper §5 / Appendix F**: explicit positioning as complementary to learned matchers — "Our techniques are, in fact, complementary to learned matchers; for example, LightGlue can be trained using both XFeat and XFeat\* features" — anticipates the XFeat+LighterGlue companion mode released post-paper-acceptance per Source #80 README.
- **Summary**: The canonical paper introduces XFeat with **three core contributions**: (i) **a novel lightweight CNN architecture** with featherweight backbone using triple-rate channel increase strategy (vs VGG's double-rate) — channel sequence `{4, 8, 24, 64, 64, 128}` ensures minimal computational depth in early high-spatial-resolution layers while maintaining representational capacity through later deeper convolutions; (ii) **a minimalist learnable keypoint detection branch** that decouples detection from description using 1×1 convolutions on 8×8 tensor-block-transformed image with knowledge distillation from ALIKE-Tiny teacher (smaller backbone tends to concentrate on lower-level image features like corners/lines/blobs aligning with the 8×8 receptive field); (iii) **a novel lightweight MLP-based match refinement module** for pixel-level offsets from coarse semi-dense matches without high-resolution feature maps (vs LoFTR/ASpanFormer which require costly high-resolution feature maps), enabling efficient semi-dense matching in resource-constrained settings. **Documentary headline results**: paper Table 1 MegaDepth-1500 (5° / 10° / 20° AUC, FPS on i5-1135G7 CPU VGA) — **XFeat sparse 42.6/56.4/67.7 at 27.1 FPS** = 9× faster than SuperPoint (37.3/50.1/61.5 at 3.0 FPS) at higher AUC + 5× faster than ALIKE-Tiny (49.4/61.8/71.4 at 5.3 FPS) at slightly lower AUC; **XFeat\* semi-dense 50.2/65.4/77.1 at 19.2 FPS = comparable to DISK\* at 16× speedup**; paper Table 2 ScanNet-1500 indoor — **XFeat 16.7/32.6/47.8 + XFeat\* 18.4/34.7/50.3 outperforms ALL baselines including SuperPoint=12.5/24.4/36.7 + DISK + ALIKE** despite all methods being MegaDepth-trained (paper Appendix E attributes this to hybrid MegaDepth+synthetic-warp-COCO training reducing landmark-dataset overfitting bias); paper Table 3 HPatches homography MHA@3 illumination/viewpoint = 95.0/68.6 (XFeat) — best illumination@3 in paper Table 3 across all evaluated methods. **Paper Appendix C embedded-device timing analysis**: Orange Pi Zero 3 ARM Cortex-A53 ($28 device) at 480×360 input — XFeat=1.8 FPS vs SuperPoint=0.16 FPS vs ALIKE=0.58 FPS — **XFeat is the ONLY learned method capable of running over 1 FPS on highly-constrained embedded device** without neural-network-inference optimization. **Paper Appendix F learned-matcher comparison**: XFeat\* (coarse-fine) AUC@5/10/20 = 50.2/65.4/77.1 at 1.33 PPS vs LoFTR (learned matcher) 68.3/80.0/88.0 at 0.06 PPS + LightGlue (learned matcher) 61.4/75.0/84.8 at 0.31 PPS + Patch2Pix (coarse-fine) 47.8/61.0/71.0 at 0.05 PPS — XFeat\* delivers **4× more inliers per pair than LightGlue at 4× higher throughput**. **License**: Apache-2.0 via Source #80 — canonical implementation. **Limitations**: (a) AUC@5° on MegaDepth-1500 sparse mode is materially below DISK at strictest tier (42.6 vs 53.8 = -11.2 absolute) — XFeat sparse positioned as "competitive at much higher speed" rather than "best-accuracy"; (b) limited robustness to aggressive viewpoint changes and highly ambiguous image pairs as explicitly acknowledged in paper §F final paragraph; (c) aerial-domain training caveat shared with all C3 candidates evaluated; (d) NO PRODUCTIZED ONNX/TensorRT export pathway in canonical repo per Source #80 README Contributing section explicit community-contribution ask.
- **Related Sub-question**: SQ3+SQ4 / C3 — XFeat per-mode API capability verification (cross-source verification of canonical paper architectural details + benchmark numbers + training paradigm + embedded-deployment evidence; documents the **modern-competitive-lead role with strongest documented embedded-deployment signal among all C3 candidates evaluated** at canonical paper publication time; aerial-domain caveat documented; modern-competitive-lead role confirmed; D-C3-6 NEW Plan-phase decision for XFeat-mode-choice required)
