---
title: 'LiteGE: Lightweight Geodesic Estimation'
url: https://www.emergentmind.com/topics/litege
type: topic
---

# LiteGE: Lightweight Geodesic Estimation

LiteGE is a lightweight neural framework for efficient geodesic distance estimation and non-isometric shape correspondence on 3D surfaces, designed to operate on both meshes and point clouds. It replaces large 3D backbone architectures with compact, category-aware shape descriptors derived from unsigned distance field (UDF) samples and their principal component analysis (PCA) projections. This architecture delivers orders-of-magnitude improvements in memory usage and inference speed while maintaining high accuracy, even for sparse or noisy 3D inputs [2512.17781].

## 1. Motivation and Context

Classical mesh-based geodesic solvers compute geodesic distances between pairs of surface points with exact or approximate algorithms, typically incurring minutes to hours of runtime on large meshes. Learning-based neural approaches (e.g., NeuroGF, GeGNN) significantly reduce per-query latency to the millisecond scale but require multi-gigabyte 3D networks, which are impractical for real-time or memory-constrained scenarios and exhibit poor performance on sparse point clouds.

Many applications in AR/VR, robotics, and on-device 3D vision demand rapid geodesic queries across many shapes with limited compute and memory. Additionally, there is a tight connection between geodesic distance prediction and finding correspondences between non-isometric shapes—yet this relationship remained under-exploited by previous work. LiteGE directly addresses these gaps by substituting neural 3D backbones with an ultra-compact representation, yielding interactive runtimes and robust generalization across point density and shape types.

## 2. Category-Aware Compact Shape Descriptor

The shape descriptor pipeline consists of canonicalization, voxelization, informative voxel selection, UDF sampling, and PCA projection:

**a. Shape Canonicalization**  
- The input shape is translated to place its centroid at the origin.
- The surface is scaled to unit area for meshes or to a fixed bounding-box area for point clouds.
- A consistent orientation is enforced via PCA axes (for regression tasks) or by a learned T-Net (for matching scenarios).

**b. Voxelization and Informative Voxels**  
- Canonicalized shape is voxelized in a $128^3$ grid, labeling voxels as inside ($1$) or outside ($0$) the shape.
- Voxel occupancy variance is computed over the training set. Voxels with variance exceeding a threshold $\epsilon$—typically those near the surface—are retained, reducing the representation to $\sim20{,}000$–$30{,}000$ "informative" voxels.

**c. UDF Sampling and PCA Embedding**  
- For each selected voxel center $p$, the UDF $x_{\mathrm{UDF}}(p)$ is the unsigned distance to the nearest point on the shape surface.
- All UDF values are concatenated to yield a high-dimensional vector $x_{\mathrm{UDF}}$ ($M \approx 20{,}000$).
- PCA is performed on the $x_{\mathrm{UDF}}$ vectors across the training set. The top $D$ principal components are retained; \(D=50\) components typically explain over 95% variance.
- The final shape descriptor is $z_{\mathrm{UDF-PCA}} \in \mathbb{R}^D$ for each shape, with $z_i = \langle x_{\mathrm{UDF}} - \mu_{\mathrm{UDF}}, p_i\rangle$ where $\mu_{\mathrm{UDF}}$ is the mean UDF vector and $p_i$ are the principal components.

## 3. Algorithmic Pipeline and Inference

The LiteGE workflow is divided into category-level preprocessing and per-shape inference:

**A. Preprocessing (per Shape Category)**
  1. Collect and canonicalize training shapes; voxelize each.
  2. Identify informative voxels and compute $x_{\mathrm{UDF}}$ vectors.
  3. Fit PCA to obtain $\mu_{\mathrm{UDF}}$ and principal components.

**B. Inference (per Shape)**
  1. Canonicalize the input shape.
  2. For each informative voxel center, compute UDF.
  3. Project UDF vector to PCA space to obtain $z_{\mathrm{UDF-PCA}}$.
  4. Feed $z_{\mathrm{UDF-PCA}}$ through a small MLP (three layers, $200$ units each) to obtain a global shape embedding.
  5. Embed query points $s$, $d \in \mathbb{R}^3$ via a two-layer Coord-MLP ($200$ units each), concatenate with global shape descriptor, and pass through a shared three-layer point MLP (also $200$ units each).
  6. The difference of the two point embeddings is input to a final two-layer MLP (each $400$ units) to predict the geodesic $G(s,d; z_{\mathrm{UDF-PCA}})$.

**C. Support for Sparse Inputs**  
Because the UDF descriptor is independent of sampling density, LiteGE operates with inputs as sparse as $300$ points, a regime in which prior neural backbones (e.g., NeuroGF) fail.

## 4. Computational Complexity and Empirical Efficiency

The LiteGE architecture offers large improvements in runtime and memory usage:

| System         | Parameters / Memory    | Inference Time (1 query) | Inference Time (64 queries) | Shape Matching Time (5K verts) |
|----------------|-----------------------|--------------------------|-----------------------------|-------------------------------|
| NeuroGF        | >10 GB, multi-GPU     | 88 ms                    | 1529 ms                     | N/A                           |
| LiteGE         | ≈600K / <50 MB        | 1.9 ms (47× faster)      | 13.4 ms (114× faster)       | 119 ms (≈1000× faster)        |

- PCA projection costs $\mathcal{O}(D \cdot M)$ per shape, with $D \ll M$.
- Nearest-neighbor UDF computation: $\mathcal{O}(M \log N)$ for $N$ surface samples.
- MLP execution is $\mathcal{O}($number of parameters$)$.
- Overall, LiteGE yields up to $300\times$ memory reduction and 100–300$\times$ speedup over neural methods, and $100$–$1000\times$ speedup over mesh-based correspondence solvers [2512.17781].

## 5. Geodesic Distance and Non-Isometric Shape Correspondence

LiteGE is trained solely on intra-shape geodesic regression, yet at inference it supports shape-to-shape correspondence via an “average” cross-shape geodesic:

\[
G_{XY}(s_X, p_Y) = \tfrac{1}{2}\left[G(s_X, p_Y; z_X) + G(s_X, p_Y; z_Y)\right]
\]

Matching a query point $q_X$ to a target shape $Y$ is formulated as:
\[
p^* = \arg \min_{p \in Y} G_{XY}(q_X, p)
\]

To avoid brute-force $O(|V|)$ evaluation, LiteGE organizes the search with a multi-tier nearest-neighbor cache, starting from a sparse anchor set and recursively refining to all vertices for sub-millisecond per-point matching. This design supports interactive landmark and region correspondence and generalizes to non-isometric shape pairs and incomplete data.

## 6. Experimental Results

**a. Geodesic Regression (normalized; mean distance $=100$):**
- 300-pt clouds: LiteGE $L_1 = 3.4$; NeuroGF $=75$ (failure).
- 2000-pt clouds: LiteGE $= 2.3$; NeuroGF $= 13$.
- Generalization: FAUST (700 pts) L₁ = 2.6, Objaverse-XL (2000 pts) L₁ = 3.9.

**b. Shape Matching (1000 matches, error$\times100$):**
- 4K-vertex clean mesh: SMS AUC 79.4%, LiteGE 79.3%; mean error 2.2 vs 2.5; runtimes 21.3s vs 0.185s.
- 5K remeshed mesh: SMS error 7.44, LiteGE 7.2; 27s vs 0.119s.
- Broken mesh (40% faces removed): SMS error >28 (AUC 33%), LiteGE error 8 (AUC 69.5).
- Point clouds (8K/500 pts): error 7.6/8.1 in ≈200/126 ms.

**c. Geodesic Path Tracing:**  
On clouds $<$1,000 points, LiteGE recovers paths with median L₁ errors 3.7–4.7 (scaled to mean=100) in $<$6 MB memory.

## 7. Advantages, Limitations, and Applications

**Advantages**
- Extreme memory and runtime efficiency ($\leq$50 MB, single-digit ms inference).
- Robustness to sparse, noisy, or incomplete input.
- Unification of geodesic and non-isometric matching tasks in a single framework.
- No reliance on large 3D neural backbones, facilitating edge deployment.

**Limitations**
- Requires category-specific canonicalization for maximum accuracy.
- PCA basis and informative voxel set are category-specific, incurring upfront precomputation cost.
- Very fine surface details may be lost if voxel resolution or PCA dimension is low.

**Applications**
- Real-time shape editing, sculpting, and texture mapping (fast geodesic computation).
- Landmark and region matching in AR/VR and robotics with sparse sensing.
- Extension to dynamic 4D shapes with temporal consistency (with further development).
- On-device 3D vision tasks (SLAM, segmentation, retrieval) under memory constraints.

LiteGE demonstrates that a compact PCA embedding of UDF samples is sufficient to replace high-capacity neural 3D backbones for both geodesic regression and non-isometric correspondence with two to three orders of magnitude gains in efficiency while preserving competitive accuracy [2512.17781].

Source: https://www.emergentmind.com/topics/litege