NaviLoc: Trajectory-Level Visual Localization for GNSS-Denied UAV Navigation

Highlights

What are the main findings?

• NaviLoc enables training-free GNSS-denied aerial-to-satellite localization using trajectory-level fusion of image matching and motion sensing.
• On low-altitude (50–150 m) rural UAV flights, NaviLoc achieves a 19.5 m Mean Localization Error (16.0× better than prior state-of-the-art).

What are the implications of the main finding?

• Trajectory-level optimization handles visually repetitive rural environments, enabling reliable GPS-free navigation.
• The lightweight algorithm enables real-time CPU-only deployment (9 FPS on Raspberry Pi 5), supporting embedded autonomy.

Abstract

Aerial-to-satellite visual localization enables GNSS-denied UAV navigation, but the appearance gap between low-altitude (50–150 m) UAV imagery and nadir satellite tiles makes per-frame Visual Place Recognition (VPR) unreliable. Under perceptual aliasing, high-similarity matches are often geographically inconsistent, so naïve anchoring fails. We introduce NaviLoc, a training-free three-stage trajectory-level estimator that treats VPR as a noisy measurement source and exploits Visual-Inertial Odometry (VIO) as a relative-motion prior. Stage 1 (Global Align) estimates a global SE(2) transform by maximizing an explicit trajectory-level similarity objective. Stage 2 (Refinement) performs sliding-window bounded weighted Procrustes updates. Stage 3 (Smoothing) computes a strictly convex MAP trajectory estimate that fuses VIO displacements with VPR anchors while clamping detected outliers. On a challenging low-altitude rural UAV benchmark, NaviLoc attains 19.5 m Mean Localization Error (MLE)—a 16.0× reduction compared to state-of-the-art localization method AnyLoc-VLAD, and 32.1× compared to raw VIO drift. End-to-end inference runs at 9 FPS on Raspberry Pi 5, enabling real-time embedded deployment.

1. Introduction

Global localization is a prerequisite for long-horizon GNSS-denied UAV autonomy. Applications such as environmental monitoring, search-and-rescue, and autonomous delivery increasingly require operation in environments where GNSS signals may be unavailable, jammed, or spoofed. Visual-Inertial Odometry (VIO) provides locally accurate relative motion but drifts without bound, making it insufficient for missions requiring global position awareness.

A natural correction source is aerial-to-satellite Visual Place Recognition (VPR), matching onboard views to geo-referenced satellite tiles. However, as illustrated in Figure 1, the cross-view domain gap between low-altitude UAV imagery and nadir satellite maps produces frequent high-similarity false matches at geographically distant locations—even human observers find it difficult to identify correct correspondences. Per-frame VPR anchoring is therefore unreliable.

NaviLoc addresses this failure mode by estimating a trajectory-level solution rather than committing to individual matches. The method is training-free: it uses off-the-shelf pretrained image descriptors without domain-specific fine-tuning. NaviLoc operates in three stages: Stage 1 (Global Align) searches for a single global SE(2) transform whose implied trajectory yields consistently high local retrieval scores; Stage 2 (Refinement) refines the aligned trajectory through bounded weighted Procrustes updates on overlapping windows; and Stage 3 (Smoothing) computes a closed-form MAP estimate that fuses VIO displacements with VPR anchors while suppressing low-confidence anchors (see Figure 2).

Public benchmarks for this setting remain limited. We were unable to find an open-source dataset that jointly provides low-altitude (50–150 m) UAV imagery, synchronized VIO, and a geo-referenced satellite tile database suitable for trajectory-level evaluation. To study this practically relevant regime, we evaluate NaviLoc on a prepared real-world UAV-to-satellite dataset with VIO and curated satellite tiles.

Contributions

• A novel, training-free, lightweight, and embedded three-stage trajectory-level localization method with explicit objectives and closed-form solutions.
• An evaluation of low-altitude (50–150 m) UAV imagery showing a 19.5 m Mean Localization Error and 16.0× improvement over AnyLoc-VLAD [1].
• An ablation demonstrating robustness to hyperparameter variations, and an empirical study showing that distilled ViT descriptors are more effective for trajectory-level alignment than larger foundation models on our benchmark.
• An embedded implementation achieving 9 FPS end-to-end inference on Raspberry Pi 5.

2. Related Work

Visual Place Recognition. VPR evolved from handcrafted descriptors [2] through bag-of-words [3,4] to learned representations. NetVLAD [5] introduced end-to-end learning for place recognition. AnyLoc [1] aggregates foundation model features using VLAD or GeM pooling, achieving state-of-the-art results on diverse benchmarks. MixVPR [6] proposes feature mixing for compact descriptors. These methods produce per-image descriptors without trajectory-level consistency constraints.

Cross-Domain and Aerial Localization. The aerial-to-satellite domain gap presents challenges distinct from ground-level VPR. CVM-Net [7] learns cross-view representations. VIGOR [8] and CVUSA [9] established benchmarks for ground-to-aerial matching. Recent UAV-specific methods [10,11] address the UAV-to-satellite gap. Our approach is complementary: we accept that individual matches are unreliable and leverage trajectory-level statistics.

UAV-to-Satellite Geo-Localization. Several recent works study cross-view matching between UAV imagery and satellite maps in the remote sensing literature [11,12,13,14]. These methods improve per-frame matching but still face perceptual aliasing under viewpoint and appearance changes; NaviLoc instead aggregates evidence across time using an explicit trajectory-level objective. For broader context on absolute visual localization pipelines and design choices, we refer to a recent survey in Drones [15]. Recent work on neural network-based recognition [16] and air safety information management [17] provides a conceptual bridge between learning-based perception methods and system-level safety considerations; our trajectory-level, training-free approach complements these by enabling robust localization without domain-specific training.

Point Set Registration. The Iterative Closest Point (ICP) algorithm [18,19] alternates between correspondence assignment and transform estimation for point cloud alignment. Procrustes analysis [20] provides closed-form solutions for rigid alignment given correspondences. Extensions include weighted variants [21,22] and robust formulations. Our Stage 1 adapts ICP-style alternating optimization to the VPR similarity objective with provable monotone improvement over evaluated candidates.

Robust Estimation. Huber’s M-estimators [23] downweight outliers in regression. Pose graph optimization [24,25] fuses odometry and visual constraints. Switchable constraints [26] and graduated non-convexity [27] handle outliers in SLAM. Our Stage 3 performs z-score outlier detection and clamps detected outliers to the VIO prior (by setting ${\alpha }_i\to \infty$), yielding a closed-form strictly convex solve without iterative robust optimization.

Visual-Inertial Odometry. VIO methods—including EKF-based VIO [28], OKVIS [29], VINS-Mono [30], and ORB-SLAM3 [31] —provide accurate relative motion estimation but accumulate unbounded drift over long trajectories. These methods solve a fundamentally different problem than NaviLoc: VIO estimates how the platform moved (relative poses), while NaviLoc estimates where the platform is in the world (global positions). NaviLoc is designed to operate on top of any VIO system, using its relative motion output as a prior while correcting global drift via satellite imagery matching.

3. Method

This section presents the NaviLoc algorithm in three stages, illustrated in Figure 2. We first formalize the problem (Section 3.1) and then describe each stage: Global Align (Section 3.2) finds an initial SE(2) transform via robust trajectory-level optimization; Refinement (Section 3.3) applies windowed geometric corrections; and Smoothing (Section 3.4) fuses VIO constraints with VPR anchors while rejecting outliers. Each stage has a well-defined objective function with a closed-form or provably convergent solution.

3.1. Problem Formulation

Given N aerial query images with descriptors ${\mathbf{F}}_q={\left\{{\mathbf{f}}_i^q\right\}}_{i=1}^N$ and VIO-derived positions $\mathbf{V}={\left\{(v_i^x,v_i^y)\right\}}_{i=1}^N$ in a local frame, along with VIO displacements $\Delta \mathbf{V}=\{{\mathbf{v}}_{i+1}-{\mathbf{v}}_i\}$, and a geo-referenced satellite map with M reference tiles having descriptors ${\mathbf{F}}_r={\left\{{\mathbf{f}}_j^r\right\}}_{j=1}^M$ and coordinates $\mathbf{G}={\left\{(g_j^x,g_j^y)\right\}}_{j=1}^M$, we seek global positions $\mathbf{P}={\left\{(p_i^x,p_i^y)\right\}}_{i=1}^N$.

3.2. Stage 1: Global Align

We estimate a global SE(2) transform $(\theta ,\mathbf{t})$ by maximizing the trajectory-level similarity objective:

$$J(\theta ,\mathbf{t})={\displaystyle \frac{1}{N}}\sum _{i=1}^N\underset{j\in \mathcal{B}(R_{\theta }{\mathbf{v}}_i+\mathbf{t},r)}{max}\langle {\mathbf{f}}_i^q,{\mathbf{f}}_j^r\rangle$$

(1)

where $R_{\theta }$ is the 2D rotation matrix, $\mathcal{B}(\mathbf{x},r)=\{j:\parallel {\mathbf{g}}_j-\mathbf{x}\parallel \le r\}$ is the set of reference tiles within radius r, and $\langle ·,·\rangle$ denotes cosine similarity.

Algorithm and intuition. Stage 1 treats VPR as a noisy correspondence generator: for a fixed rotation $\theta$, each frame proposes a translation “measurement” ${\mathbf{d}}_i\left(\theta \right)={\mathbf{g}}_{j_i^{*}}-R_{\theta }{\mathbf{v}}_i$ based on the global top-1 match $j_i^{*}$. Under perceptual aliasing, many $j_i^{*}$ are outliers; we therefore aggregate $\left\{{\mathbf{d}}_i\left(\theta \right)\right\}$ with a robust location estimator (the component-wise median). The key contribution is casting these noisy retrieval outcomes into a trajectory-level objective. We use coordinate ascent: (1) scan a grid of K rotation angles $\theta \in \{-\pi ,-\pi +2\pi /K,\dots \}$; (2) for each $\theta$, compute the L1-optimal translation (component-wise median) [23]:

$$\mathbf{t}\left(\theta \right)=\mathrm{median}{\{{\mathbf{g}}_{j_i^{*}}-R_{\theta }{\mathbf{v}}_i\}}_{i=1}^N$$

(2)

where $j_i^{*}=arg{max}_j\langle {\mathbf{f}}_i^q,{\mathbf{f}}_j^r\rangle$ is the global top-1 match; (3) evaluate $J(\theta ,\mathbf{t}(\theta \left)\right)$ and select the best; and (4) refine with alternating maximization using local targets.

We denote the resulting aligned trajectory by ${\mathbf{P}}^{\left(1\right)}={\left\{{\mathbf{p}}_i^{\left(1\right)}\right\}}_{i=1}^N$. The following result formalizes why the median aggregator is optimal for robust translation estimation under outlier contamination:

Theorem 1 (L1-Optimal Translation (Median)).

Let ${\mathbf{d}}_i={\mathbf{g}}_{j_i}-R_{\theta }{\mathbf{v}}_i\in {\mathbb{R}}^2$ be translation residuals for fixed θ. The minimizer of

$$\underset{\mathbf{t}\in {\mathbb{R}}^2}{min}\sum _{i=1}^N{\parallel {\mathbf{d}}_i-\mathbf{t}\parallel }_1$$

(3)

is given by the component-wise median: $t_x=\mathrm{median}\left\{d_{i,x}\right\}$ and $t_y=\mathrm{median}\left\{d_{i,y}\right\}$. Consequently, $\mathbf{t}\left(\theta \right)$ is robust to outlier residuals: as long as more than half of the residuals are inliers per coordinate, the estimate is controlled by the inlier set rather than the outliers.

Proof. 

The L1 norm $\parallel {\mathbf{d}}_i{-\mathbf{t}\parallel }_1=|d_{i,x}-t_x|+|d_{i,y}-t_y|$ decomposes across coordinates, so the objective separates into two independent 1D problems: ${min}_{t_x}{\sum }_i|d_{i,x}-t_x|$ and ${min}_{t_y}{\sum }_i|d_{i,y}-t_y|$. The minimizer of ${\sum }_i|x_i-t|$ over $t\in \mathbb{R}$ is the median of $\left\{x_i\right\}$ [23]. Robustness follows because the median is unaffected by arbitrarily large perturbations to fewer than half of the samples. □

Remark 1 (monotone acceptance).

In our implementation, we only accept candidate updates that improve (or tie) J, so the sequence of evaluated objective values is monotone non-decreasing, bounded above by 1, and hence convergent. This guarantees convergence of the objective sequence, not global optimality (see Algorithm A1).

3.3. Stage 2: Refinement

After global alignment, we refine positions using sliding-window bounded Procrustes. This extends standard weighted Procrustes analysis [20,21] with a novel rotation bound constraint that prevents overcorrection from noisy VPR targets. For each frame index j, we compute a local VPR target ${\mathbf{t}}_j\in {\mathbb{R}}^2$ as the coordinate of the best-matching reference tile within radius r of the current predicted position ${\mathbf{p}}_j^{\left(1\right)}$ and record its cosine similarity score $s_j$. For each window $\mathcal{W}=\{i,i+1,\dots ,i+W-1\}$ with targets ${\left\{{\mathbf{t}}_j\right\}}_{j\in \mathcal{W}}$ and weights $w_j=max{(0,s_j)}^2$, we solve:

$$\underset{R\in SO\left(2\right),\mathbf{t}}{min}\sum _{j\in \mathcal{W}}{w}_j\parallel R{\mathbf{p}}_j^{\left(1\right)}+\mathbf{t}-{\mathbf{t}}_j{\parallel }^2,\mathrm{s}.\mathrm{t}.\left|\theta \right|\le {\theta }_{max}$$

(4)

This weighted Procrustes problem admits a closed-form solution for both rotation and translation. The rotation constraint prevents overcorrection when local VPR targets are noisy:

Theorem 2 (Optimal Bounded Procrustes).

For the constrained problem (4) in 2D, let $\overline{\mathbf{p}}={\sum }_j{w}_j{\mathbf{p}}_j^{\left(1\right)}/{\sum }_j{w}_j$ and $\overline{\mathbf{t}}={\sum }_j{w}_j{\mathbf{t}}_j/{\sum }_j{w}_j$ be the weighted centroids, and let $H={\sum }_{j\in \mathcal{W}}{w}_j({\mathbf{p}}_j^{\left(1\right)}-\overline{\mathbf{p}}){({\mathbf{t}}_j-\overline{\mathbf{t}})}^{\top }$ be the $2\times 2$ weighted cross-covariance matrix. The optimal rotation angle is ${\theta }^{*}=\mathrm{clip}(\widehat{\theta },-{\theta }_{max},{\theta }_{max})$, where $\widehat{\theta }=\mathrm{atan}2(H_{10}-H_{01},H_{00}+H_{11})$, and the optimal translation is ${\mathbf{t}}^{*}=\overline{\mathbf{t}}-R_{{\theta }^{*}}\overline{\mathbf{p}}$.

Proof. 

After centering by the weighted centroids, the objective separates into rotation and translation terms. For the rotation, we seek to maximize $\mathrm{tr}\left(R_{\theta }H\right)$. Writing $R_{\theta }=\left(\begin{array}{cc}\hfill cos\theta & -sin\theta \\ \hfill sin\theta & cos\theta \end{array}\right)$, the trace expands to $(H_{00}+H_{11})cos\theta +(H_{10}-H_{01})sin\theta$ [20,21]. This sinusoidal function of $\theta$ is maximized at $\widehat{\theta }=\mathrm{atan}2(H_{10}-H_{01},H_{00}+H_{11})$. The constraint $\left|\theta \right|\le {\theta }_{max}$ clips this to the boundary if $\widehat{\theta }$ lies outside. The optimal translation follows as ${\mathbf{t}}^{*}=\overline{\mathbf{t}}-R_{{\theta }^{*}}\overline{\mathbf{p}}$. □

Windows overlap (stride $S<W$), so each frame receives corrections from multiple windows; we average these contributions. Multiple passes are performed because each pass updates the trajectory, which changes the local VPR targets $\left\{{\mathbf{t}}_j\right\}$ (since they depend on the current predicted positions). Empirically, 2–3 passes suffice for convergence (see Algorithm A2).

3.4. Stage 3: Smoothing

Let ${\mathbf{P}}^{\left(2\right)}={\left\{{\mathbf{p}}_i^{\left(2\right)}\right\}}_{i=1}^N$ denote the Stage 2 output. We treat these positions as anchors $\mathbf{A}={\left\{{\mathbf{a}}_i\right\}}_{i=1}^N$ with ${\mathbf{a}}_i:={\mathbf{p}}_i^{\left(2\right)}$ and fuse them with VIO constraints via a standard MAP formulation  [32]. Our novel element is the z-score-based outlier detection that automatically clamps unreliable anchors to the VIO prior:

$$\underset{\mathbf{P}}{min}{\parallel \mathbf{D}\mathbf{P}-\Delta \mathbf{V}\parallel }^2+\sum _{i=1}^N{\alpha }_i{\parallel {\mathbf{p}}_i-{\mathbf{a}}_i\parallel }^2$$

(5)

where $\mathbf{D}$ is the $(N-1)\times N$ first-difference matrix.

Outlier detection. For each anchor ${\mathbf{a}}_i$, we recompute its local VPR similarity $s_i$ as the best cosine similarity among reference tiles within radius r of ${\mathbf{a}}_i$. We then compute z-scores $z_i=(s_i-\overline{s})/{\sigma }_s$. Frames with $z_i<\tau$ (default $\tau =-1.5$) are marked as outliers and assigned ${\alpha }_i\to \infty$ (implemented as ${10}^6$), effectively clamping them to the VIO prior. Inliers use ${\alpha }_i={\alpha }_{\mathrm{in}}=0.05$. With the anchor weights thus defined, the optimization problem has a unique closed-form solution:

Theorem 3 (Unique Solution).

If ${\alpha }_i>0$ for at least one i, then the objective (5) is strictly convex with unique minimizer given by the linear system:

$$({\mathbf{D}}^{\top }\mathbf{D}+\mathrm{diag}\left(\mathit{\alpha }\right))\mathbf{P}={\mathbf{D}}^{\top }\Delta \mathbf{V}+\mathit{\alpha }\odot \mathbf{A}$$

(6)

Proof. 

The objective (5) is quadratic in $\mathbf{P}$. Setting the gradient to zero yields the normal equations $({\mathbf{D}}^{\top }\mathbf{D}+\mathrm{diag}\left(\mathit{\alpha }\right))\mathbf{P}={\mathbf{D}}^{\top }\Delta \mathbf{V}+\mathit{\alpha }\odot \mathbf{A}$. The matrix ${\mathbf{D}}^{\top }\mathbf{D}$ is the graph Laplacian of a path, which is positive semidefinite with nullspace spanned by the constant vector $\mathbf{1}$. Adding $\mathrm{diag}\left(\mathit{\alpha }\right)$ with at least one ${\alpha }_i>0$ eliminates this nullspace: any $\mathbf{x}=c\mathbf{1}$ has ${\mathbf{x}}^{\top }\mathrm{diag}\left(\mathit{\alpha }\right)\mathbf{x}=c^2{\sum }_i{\alpha }_i>0$. Thus the combined matrix is positive definite, guaranteeing strict convexity and a unique solution [32]. □

See Algorithm A3 for pseudocode.

3.5. Implementation Details

Algorithm 1 summarizes the complete pipeline. We use DeiT-Tiny-Distilled [33], a distilled Vision Transformer [34], for feature extraction (192-dim descriptors). Fixed parameters: search radius $r=150$ m, $K=72$ angles, window size $W=10$, stride $S=7$, ${\theta }_{max}=0.09$ rad (≈5), and z-threshold $\tau =-1.5$.

Algorithm 1 NaviLoc

Require: Query features ${\mathbf{F}}_q\in {\mathbb{R}}^{N\times D}$, VIO trajectory $\mathbf{V}\in {\mathbb{R}}^{N\times 2}$ Require: Reference database $({\mathbf{F}}_r,\mathbf{G})$ with M tiles Ensure: Localized positions $\mathbf{P}\in {\mathbb{R}}^{N\times 2}$   1: $(\mathbf{P},{\theta }^{*})\leftarrow$GlobalAlign$(\mathbf{V},{\mathbf{F}}_q,{\mathbf{F}}_r,\mathbf{G})$                      ▹ Stage 1   2: $\mathbf{P}\leftarrow$Refinement$(\mathbf{P},{\mathbf{F}}_q,{\mathbf{F}}_r,\mathbf{G})$                      ▹ Stage 2   3: ${\mathbf{P}}^{*}\leftarrow$Smoothing$(\mathbf{P},\mathbf{V},{\theta }^{*},{\mathbf{F}}_q,{\mathbf{F}}_r,\mathbf{G})$                     ▹ Stage 3   4: return ${\mathbf{P}}^{*}$

Detailed pseudocode for each stage is provided in Appendix A.

4. Experiments

4.1. Dataset

To the best of our knowledge, there is no publicly available challenging dataset for our target setting—low-altitude (50–150 m) UAV imagery with synchronized VIO and a geo-referenced satellite tile database for trajectory-level evaluation—in particular with long real-world trajectories. We therefore evaluate on a prepared real-world UAV-to-satellite benchmark collected over rural terrain in Ukraine.

Table 1. Dataset statistics.

Property	Value
Query frames	58
Query spacing	40 m
Trajectory length	2323 m
Flight altitude (AGL)	50–150 m
Reference tiles	462
Reference tile spacing	40 m
Reference coverage	1.6 km2

summarizes the dataset statistics. The dataset comprises 58 aerial query frames captured at 50–150 m AGL along a 2.3 km trajectory with 40 m inter-frame spacing. Reference imagery consists of 462 geo-referenced satellite tiles at 0.3 m/px resolution covering 1.6 km² with 40 m tile spacing. The benchmark is challenging due to strong perceptual aliasing in rural/village scenes (repetitive texture, limited distinctive landmarks) combined with low-altitude viewpoint and appearance changes relative to the satellite map.

Data collection and preparation. The query stream was recorded from a real multirotor UAV flight over rural/village terrain in Ukraine under summer conditions. The platform was manually piloted in an FPV-style flight mode at 50–150 m AGL, with average speed below 60 m/s, producing a 2.3 km trajectory.

All onboard processing was performed on a Raspberry Pi 5 (8 GB RAM). Images were captured by a rigidly mounted nadir-view Sony IMX219 RGB camera at 30 FPS with approximately 77–80° diagonal field of view, with auto-exposure and auto-white-balance enabled; a separate forward/oblique camera was used only for piloting and is not part of the evaluation. Inertial measurements were provided by the onboard SpeedyBee V3 IMU. Relative motion was estimated by a standard EKF-based monocular Visual-Inertial Odometry (VIO) pipeline fusing the camera and IMU. These components were chosen for availability, low cost, and suitability for lightweight embedded UAV platforms; NaviLoc is designed to work with any standard VIO pipeline and is agnostic to the specific sensor choice. As expected, VIO is subject to drift over extended flights and performs no global map alignment; NaviLoc uses only the resulting relative pose increments and is agnostic to the specific VIO implementation.

Ground truth positions are obtained from onboard GNSS logs and are used only for evaluation (MLE/ATE) and visualization; GNSS data are not available to NaviLoc during inference. The reference database was built by sampling satellite map imagery via the Google Maps API at zoom level 19 on a 40 m grid over the flight area; each tile is associated with its geographic coordinate. We then convert both query frames and reference tiles into embeddings using the backbones in Table 1.

4.2. Baselines

We compare against:

• Raw VIO (IP only): VIO trajectory with initial position aligned to ground truth (no rotation).
• VIO + IP + IR (oracle): VIO with initial position and initial rotation estimated from the first displacement (one-segment oracle) and from the first $k=10$ displacements (multi-segment oracle).
• VIO SE(2) oracle: VIO with oracle global SE(2) alignment to ground truth (best possible rigid alignment).
• Per-frame VPR (top-k): For each query frame, retrieve the k reference tiles with highest cosine similarity and predict position as their coordinate mean (top-1 uses the single best match; top-3 averages the three best).
• AnyLoc-VLAD [1]: State-of-the-art VPR using DINOv2 [35] with VLAD aggregation, evaluated with top-3 retrieval.

4.3. Results

On this challenging real-world benchmark, NaviLoc achieves 19.5 m MLE—a 16.0× improvement over the state-of-the-art AnyLoc-VLAD, and a 32.1× improvement over raw VIO drift. Figure 3 and Figure 4 summarize these results.

4.4. Ablation Studies

Stage contributions. Each stage provides substantial improvement (

Table 2. Quantitative comparison. MLE = Mean Localization Error; ATE = Absolute Trajectory Error.

Method	MLE (m)	ATE (m)	Improvement
Raw VIO (IP only)	626.7	728.9	1.0×
VIO + IP + IR (first delta, oracle) *	98.4	132.5	6.4×
VIO + IP + IR (first $k=10$ deltas, oracle) *	90.1	132.2	7.0×
Per-frame VPR (top-1)	404.3	471.8	1.5×
Per-frame VPR (top-3)	342.1	413.8	1.8×
AnyLoc-VLAD (top-3) [1]	312.2	368.5	2.0×
VIO SE(2) oracle *	54.2	67.9	11.6×
NaviLoc: Stage 1	69.3	76.9	9.0×
NaviLoc: Stages 1 + 2	36.7	42.6	17.1×
NaviLoc: Full	19.5	21.6	32.1×

* Oracle baselines use ground truth information.

). Stage 1 alone achieves 9× improvement by finding the correct global transform. Stage 2 refines local errors, and Stage 3 leverages VIO constraints while excluding outliers.

Outlier threshold. 

Table 3. Outlier detection threshold ablation.

Threshold	Outliers	MLE (m)	Improvement
None	0	26.6	23.5×
$z<-2.0$	3	21.4	29.3×
$z<-1.5$	7	19.5	32.1×
$z<-1.0$	9	27.2	23.1×

shows sensitivity to the z-score threshold.

Hyperparameter sensitivity. 

Table 4. One-at-a-time hyperparameter sensitivity (full NaviLoc pipeline). Default settings are bold.

Hyperparameter	Setting	MLE (m)
Rotation grid (K angles)	36/72/144	32.7/19.5/23.8
Local search radius r (m)	100/150/200	36.6/19.5/83.0
Stage 1 iterations	1/2/3/4	19.8/22.2/19.5/19.5
Window size W (frames)	9/10/11/12	27.6/19.5/24.6/27.2
Stride S (frames)	5/7/9	33.2/19.5/35.2
Rotation bound ${\theta }_{max}$ (rad)	0.05/0.09/0.12	24.3/19.5/19.2
Anchor weight ${\alpha }_{\mathrm{in}}$	0.02/0.05/0.10	20.6/19.5/22.6

varies one hyperparameter at a time (others fixed to defaults). Performance is stable across moderate changes, while overly permissive local search radii or underconstrained refinement settings degrade accuracy.

Backbone comparison. 

Table 5. Backbone comparison.

Backbone	Dimensions	VPR MLE (m)	NaviLoc MLE (m)
DeiT-Tiny-Distilled	192	342.1	19.5
ConvNeXt-Tiny	768	364.1	42.0
LeViT-256 (distilled)	512	346.7	70.6
DeiT-Tiny	192	430.4	105.1
DINOv2-ViT-G/14 + VLAD	98,304	356.7	162.0

reveals that DeiT-Tiny-Distilled achieves the best NaviLoc performance despite not having the best per-frame VPR accuracy. Empirically, distillation appears to yield descriptors whose scores are more consistent across time, making trajectory-level alignment easier.

4.5. Computational Efficiency

NaviLoc operates on precomputed descriptors. We benchmark on Raspberry Pi 5 (ARM Cortex-A76, 8 GB RAM).

Table 6. Computational performance on Raspberry Pi 5.

Component	Time (ms)	FPS
Feature Extraction (DeiT-Tiny)	79	12.7
NaviLoc Algorithm (C++)	32	31
End-to-End Inference	111	9.0

summarizes the computational performance.

Inference strategy. At each timestep, the system samples an aerial image, extracts a 192-dimensional DeiT-Tiny-Distilled embedding (79 ms), and updates the global trajectory estimate using the C++ NaviLoc algorithm (32 ms). The combined end-to-end latency of 111 ms yields 9.0 FPS on Raspberry Pi 5, enabling real-time embedded deployment. Feature extraction becomes the bottleneck; DeiT-Tiny-Distilled requires 1.3 GFLOPs per image versus 21.1 GFLOPs for DINOv2-S, providing 16× faster extraction while achieving superior localization accuracy.

5. Discussion

We now analyze NaviLoc’s performance across multiple dimensions, compare it with alternative approaches, and discuss limitations and future directions.

5.1. Comparison with Existing Methods

Versus per-frame VPR. Per-frame VPR methods treat each query independently, producing 342.1 m MLE (top-3) on our benchmark. NaviLoc achieves 19.5 m—a 17.5× improvement. The key insight is that perceptual aliasing causes individual VPR errors that are spatially inconsistent: incorrect matches scatter across the map, while correct matches cluster near the true trajectory. Trajectory-level optimization exploits this statistical property.

Versus state-of-the-art. AnyLoc [1] represents the state-of-the-art in universal VPR, aggregating DINOv2 [35] features via VLAD pooling. On our benchmark, AnyLoc-VLAD achieves 312.2 m MLE (top-3)—only marginally better than simple per-frame VPR. NaviLoc reduces this to 19.5 m, a 16.0× improvement. This demonstrates that even powerful foundation model features remain susceptible to cross-view aliasing without trajectory-level reasoning.

Versus VIO baselines. Raw VIO accumulates 626.7 m drift over the 2.3 km trajectory. Even with oracle initial rotation alignment, VIO achieves only 90.1 m MLE due to scale and heading drift. NaviLoc’s 19.5 m MLE represents a 32.1× improvement over raw VIO, highlighting the benefit of trajectory-level use of noisy VPR measurements to correct long-horizon drift.

Versus graph-based SLAM. Traditional pose graph optimization [24,25] formulates localization as nonlinear least squares over loop closure constraints. These methods typically require multiple sensors (LiDAR, stereo cameras, IMU), 3D point cloud processing, and GPU acceleration for real-time operation. NaviLoc is fundamentally lighter: it operates on a single monocular camera plus VIO, uses 2D tile descriptors rather than 3D geometry, and requires no GPU. Each stage employs closed-form solutions (median, SVD, linear solve) rather than iterative solvers (Gauss-Newton, Levenberg-Marquardt) and handles outliers via z-score clamping rather than iterative robust optimization [26,27]. This yields deterministic, bounded runtime on CPU-only embedded platforms.

5.2. Computational Efficiency

Real-time embedded deployment. NaviLoc achieves 9 FPS end-to-end on Raspberry Pi 5, combining 79 ms feature extraction (DeiT-Tiny-Distilled) with 32 ms trajectory optimization (C++). This demonstrates that trajectory-level cross-view localization can run in real time on a CPU-only embedded platform.

Comparison with foundation model approaches. While larger backbones can improve standalone VPR on some benchmarks, they are substantially more expensive for embedded CPU deployment. Our ablation (Table 5) shows that DINOv2-ViT-G/14+VLAD achieves 162.0 m MLE versus 19.5 m for DeiT-Tiny-Distilled—larger models did not improve NaviLoc on this cross-view dataset.

Runtime scaling. Let N denote trajectory length and M reference database size. Stage 1 performs $O\left(N\right)$ global nearest-neighbor queries, each requiring $O\left(M\right)$ comparisons, yielding $O\left(NM\right)$. The angle grid size and iteration counts are small constants. Stage 2 runs in $O\left(N\right)$ per pass with constant window size. Stage 3 solves a tridiagonal system in $O\left(N\right)$ via the Thomas algorithm [36]. The overall time complexity is $O\left(NM\right)$; in practice, feature extraction dominates runtime. For larger reference databases, approximate nearest-neighbor structures could reduce this to sublinear in M.

5.3. Portability and Transferability

Training-free operation. Unlike learned cross-view methods [7,8] that require domain-specific training data, NaviLoc operates on pretrained features without fine-tuning. This is critical for GNSS-denied scenarios where ground truth correspondences are unavailable for training.

Backbone flexibility. NaviLoc accepts any image descriptor; our ablation tested five backbones (Table 5). This modularity allows leveraging future feature extractors without algorithmic changes.

Simplicity. NaviLoc has no learned components beyond the feature extractor, no hyperparameter schedules, and no complex data association. This facilitates debugging and deployment in safety-critical applications.

5.4. Robustness Analysis

Hyperparameter stability. Table 4 demonstrates that NaviLoc maintains sub-25 m accuracy across $\pm 50\%$ perturbations of most hyperparameters. The outlier threshold (Table 3) shows graceful degradation outside the optimal range. This robustness simplifies deployment: practitioners can use default settings without extensive tuning.

Adaptive outlier detection. Z-score normalization adapts to per-trajectory statistics: a similarity of 0.25 may indicate an outlier in one flight but a reliable match in another. This eliminates per-dataset threshold tuning.

5.5. Feature Descriptor Analysis

Table 5 shows that DeiT-Tiny-Distilled (5M parameters) achieves 19.5 m MLE, while DINOv2-ViT-G/14 (1.1B parameters) achieves 162.0 m—8× worse despite being 200× larger. This empirical finding suggests that model selection for trajectory-level VPR should consider compatibility with geometric reasoning, not just per-frame retrieval accuracy.

5.6. Practical Extensions

Long-trajectory operation. The current evaluation uses a 2.3 km trajectory processed in batch. For arbitrarily long flights, NaviLoc can be extended via a sliding-window approach: maintain a context window of the most recent 2–3 km of trajectory data and apply NaviLoc to this window for each new position estimate. This bounds memory and computation while providing continuous global localization.

5.7. Limitations and Future Work

VIO dependency. NaviLoc assumes VIO provides accurate relative motion over short horizons. Significant VIO failures (e.g., from aggressive maneuvers or texture-poor environments) would propagate to the final estimate. Future work could jointly estimate VIO scale and bias.

Trajectory length. Very short trajectories (<10 frames) provide insufficient statistics for robust similarity aggregation. A minimum flight distance of approximately 400 m is recommended. Conversely, NaviLoc handles arbitrarily long trajectories via the sliding-window extension described above.

Seasonal and environmental variation. Our evaluation uses satellite imagery captured under similar conditions (summer, clear weather) to the query flight. Performance under adverse weather conditions (rain, fog, and low visibility), seasonal changes (snow cover, vegetation differences), or significant lighting variations between the reference map and query images remains unevaluated. The training-free design may offer some robustness since the DeiT feature extractor was trained on diverse ImageNet conditions, but systematic evaluation across weather and seasonal variations is an important direction for future work.

Additional trajectories. Due to the complexity of real-world UAV data collection with synchronized VIO and ground truth, our evaluation is limited to a single 2.3 km trajectory. While the ablation studies (Table 3, Table 4 and Table 5) provide statistical validation across hyperparameter variations, the evaluation of additional trajectories in diverse environments would further strengthen the generalization claims. Collecting and evaluating datasets spanning multiple environments is planned as future work.

3D extension. The current SE(2) formulation assumes approximately planar flight. Extending to SE(3) would support altitude variations and complex terrain, potentially leveraging 3D point cloud or mesh references.

Online operation. NaviLoc currently processes trajectories in batch. An incremental variant that updates estimates as new frames arrive would enable tighter integration with flight controllers for real-time autonomous navigation.

Energy efficiency. Reducing onboard computation energy extends flight endurance and lowers environmental impact. Systematic energy profiling [37] could guide model selection and duty-cycling to further improve efficiency.

6. Conclusions

We presented NaviLoc, a three-stage trajectory-level localization pipeline with rigorous mathematical foundations. Each stage has a well-defined objective and provable convergence properties. NaviLoc achieves 19.5 m Mean Localization Error on a UAV-to-satellite benchmark, representing a 16× improvement over AnyLoc-VLAD, the state-of-the-art VPR method. End-to-end inference runs at 9 FPS on Raspberry Pi 5, demonstrating practical viability for real-time embedded UAV navigation.