Offline Framework for 3D Global Relocalization

• Offline Framework is a method that transforms detailed point-cloud maps into a coarse 3D occupancy grid and indexed descriptor database, decoupling heavy preprocessing from online processing.
• It simulates synthetic LiDAR scans using grid-based ray casting and constructs compact geometric descriptors, significantly reducing online computational overhead.
• Real-world tests show the framework achieves 8 cm 3D localization accuracy in about 3 seconds, offering an order-of-magnitude efficiency boost over traditional methods.

In "Offline-Online Hierarchical 3D Global Relocalization With Synthetic LiDAR Sensing and Descriptor-Space Retrieval" (Ren et al., 8 May 2026), the offline framework is the preprocessing component of an offline-online hierarchical architecture for 3D global relocalization. It converts a dense prior point-cloud map into a coarse 3D occupancy grid, uniformly samples feasible robot positions in the grid, simulates a synthetic LiDAR scan at each sample, computes a compact geometric descriptor, and stores $\langle \text{position}, \text{descriptor} \rangle$ pairs in an indexed database. By precomputing sampling, ray casting, descriptor creation, and indexing once, the method decouples the search space and reduces online relocalization to lightweight descriptor encoding, a few nearest-neighbor lookups, and local ICP refinements. Real-world experiments report an average relocalization time of 3 s, an average localization accuracy of 8 cm in 3D environments, and an order-of-magnitude improvement in computational efficiency while delivering comparable relocalization accuracy (Ren et al., 8 May 2026).

1. Architectural role and decoupling principle

The overall structure is explicitly split into an offline phase and an online phase. In the offline phase, the method converts a dense prior point-cloud map into a coarse 3D occupancy grid, uniformly samples feasible robot positions in the grid, simulates a synthetic LiDAR scan at each sample, computes a compact geometric descriptor, and stores $\langle \text{position}, \text{descriptor} \rangle$ pairs in an indexed database. In the online phase, it accumulates $K_f$ recent LiDAR scans into a local grid, generates a synthetic scan and query descriptor, retrieves the top $K_c$ candidates by descriptor matching, and refines each candidate by GN-ICP registration to output a precise 6-DoF pose estimate (Ren et al., 8 May 2026).

The stated benefit of this decomposition is that heavy-compute tasks—sampling, ray casting, descriptor creation, and indexing—are precomputed once. Online work is therefore reduced to lightweight descriptor encoding, a few nearest-neighbor lookups of complexity $O(\log N_p)$, and local ICP refinements. Within the paper’s formulation, the offline framework is not merely data preparation; it is the mechanism that decouples a massive pose search space into an indexed set of candidate positions and descriptor-space retrieval operations.

2. Grid map representation and synthetic LiDAR sensing

The offline stage begins from a grid representation. Let $\Omega \subset \mathbb{R}^3$ be the map bounding box and $r$ the grid resolution. The method defines the binary occupancy function

$$\chi(x)= \begin{cases} 1, & \text{if cell at } x \text{ is occupied},\ 0, & \text{otherwise}, \end{cases}$$

and the free-space set

$F=\{x \mid \chi(x)=0\}.$

Synthetic LiDAR sensing is then performed over the grid. A beam set of predefined unit directions $D=\{d_\ell\}_{\ell=1\ldots K_r}$ and a maximum range $\langle \text{position}, \text{descriptor} \rangle$0 are fixed. For each sampled position $\langle \text{position}, \text{descriptor} \rangle$1 and for each beam $\langle \text{position}, \text{descriptor} \rangle$2, the method traces the ray

$\langle \text{position}, \text{descriptor} \rangle$3

in steps of $\langle \text{position}, \text{descriptor} \rangle$4. It stops at the first $\langle \text{position}, \text{descriptor} \rangle$5 such that $\langle \text{position}, \text{descriptor} \rangle$6, following a first-return model. The hit point $\langle \text{position}, \text{descriptor} \rangle$7 is recorded; if no hit occurs within $\langle \text{position}, \text{descriptor} \rangle$8, that beam is dropped. All valid returns form a synthetic point set in the map frame,

$\langle \text{position}, \text{descriptor} \rangle$9

To align the synthetic scan with the real sensor frame, the method fixes a reference orientation $K_f$0 to match the real sensor’s roll and pitch. For each $K_f$1 it computes

$K_f$2

and forms the LiDAR-frame synthetic scan $K_f$3 (Ren et al., 8 May 2026).

This construction makes the offline database sensor-aware: the stored descriptors are derived from simulated observations at feasible robot positions rather than from arbitrary subsamples of the map.

3. Descriptor construction and representation

At each candidate pose, the method constructs a Scan Context descriptor $K_f$4. The descriptor uses $K_f$5 concentric rings, $K_f$6 angular sectors, and a maximum range $K_f$7. Bin $K_f$8 spans radius

$K_f$9

and angle

$K_c$0

Each point $K_c$1 is assigned to its corresponding bin $K_c$2. The descriptor uses max-height encoding:

$K_c$3

with empty bins set to $K_c$4. The paper denotes the descriptor in vectorized form as

$K_c$5

A second representation, the ring-key, is used for indexing. The ring-key is the vector of $K_c$6’s max over each ring and has size $K_c$7. In the offline framework, this separation between the full descriptor and its ring-key is operationally important: the full descriptor preserves retrieval fidelity, while the ring-key provides a lower-dimensional structure for efficient nearest-neighbor search (Ren et al., 8 May 2026).

4. Descriptor database and indexed retrieval space

The offline database is

$K_c$8

Each entry couples a feasible sampled position with the descriptor generated from the synthetic LiDAR scan at that position.

Indexing is performed by building a KD-tree over the ring-key subvector of each $K_c$9. The KD-tree supports exact or approximate nearest-neighbor queries under $O(\log N_p)$0 in $O(\log N_p)$1. Given a query descriptor $O(\log N_p)$2, retrieval first finds nearest ring-keys and then evaluates the full Scan Context distance by circularly shifting descriptor columns:

$O(\log N_p)$3

The associated complexities are explicit. KD-tree build complexity is

$O(\log N_p)$4

and query complexity is

$O(\log N_p)$5

where $O(\log N_p)$6 is the number of ring-key neighbors examined (Ren et al., 8 May 2026).

The indexing scheme therefore converts map-scale candidate generation into descriptor-space retrieval. A plausible implication is that the offline framework’s main contribution is not only candidate enumeration, but the construction of a search structure in which coarse pose hypotheses can be recovered without searching the full 6-DoF map space online.

5. Offline preprocessing algorithm, complexity, and storage

The offline preprocessing procedure is given in the paper as an explicit algorithm:

$r$1

The sampling loop has complexity

$O(\log N_p)$7

Ray casting plus descriptor construction across all samples has complexity

$O(\log N_p)$8

and KD-tree construction is

$O(\log N_p)$9

The overall offline complexity is summarized as

$\Omega \subset \mathbb{R}^3$0

Storage demands are also stated explicitly. Positions require $\Omega \subset \mathbb{R}^3$1 floats. Descriptors require $\Omega \subset \mathbb{R}^3$2 floats. KD-tree overhead is approximately $\Omega \subset \mathbb{R}^3$3. The paper gives the example

$\Omega \subset \mathbb{R}^3$4

for which the descriptor matrix is about $\Omega \subset \mathbb{R}^3$5 floats, approximately $\Omega \subset \mathbb{R}^3$6 MB, plus about $\Omega \subset \mathbb{R}^3$7 KB for positions (Ren et al., 8 May 2026).

6. Runtime implications and relocalization significance

The paper summarizes the offline framework as turning a massive 6-DoF search in point-cloud space into a one-time grid-based ray-casting pass plus a descriptor-space indexing structure. At run time, one only needs to voxelize a small local patch, encode it in $\Omega \subset \mathbb{R}^3$8, perform $\Omega \subset \mathbb{R}^3$9 lookups, and launch a handful of local ICP refinements with $r$0 (Ren et al., 8 May 2026).

Within the full system, this means that the offline framework does not itself return the final pose. The online phase still performs global retrieval for a coarse pose estimate and then point cloud registration for a precise 6-DoF estimate. The offline framework’s role is to make that online stage computationally tractable in large-scale maps by precomputing the candidate positions and their descriptor indices.

The reported experimental outcome is that this decoupling enables second-level relocalization in very large environments: the method achieves an average relocalization time of 3 s and an average localization accuracy of 8 cm, with an order-of-magnitude improvement in computational efficiency while delivering comparable relocalization accuracy (Ren et al., 8 May 2026). In that sense, the offline framework is the enabling substrate of the hierarchical relocalization pipeline rather than an auxiliary preprocessing convenience.