---
title: Anchor-Octree LoD 3DGS for Efficient Rendering
url: https://www.emergentmind.com/topics/anchor-and-octree-based-lod-structured-3dgs
type: topic
---

# Anchor-Octree LoD 3DGS for Efficient Rendering

Anchor- and Octree-based LoD-structured 3DGS (3D Gaussian Splatting) refers to a class of scene representations and algorithms in which 3D Gaussians are spatially organized using a hierarchical structure based on sparse octrees and anchor points, enabling adaptive, memory-efficient, and real-time rendering with precise level-of-detail (LoD) control. In these frameworks, an explicit or implicit octree partitions the scene volume into voxels, each associated with a set of "anchors" that parameterize local clusters of Gaussians at varying spatial resolutions. This architecture underpins recent advances in novel view synthesis, dense mapping, streaming video reconstruction, and 3DGS compression, providing both scalability and dynamic adaptation to scene geometry and view constraints.

## 1. Principles of Anchor and Octree Structuring

Anchor- and octree-based LoD-structured 3DGS decomposes the scene into multi-resolution cells via an octree whose depth and occupancy are driven by scene geometry or data density. Anchors are positioned at the centers of occupied or geometrically salient voxels at different octree levels, each encoding spatial, appearance, and feature information at a given granularity. This approach implicitly defines a hierarchy of LoD, with coarse anchors providing large-scale coverage and fine anchors reserved for regions exhibiting high geometric or photometric complexity. Gaussian primitives are generated from anchor parameters, leveraging per-anchor feature codes and learnable offsets to capture intra-voxel detail.

Typical formulations [2508.14041] [2408.17223] [2601.18475] [2403.17898] initialize octree construction as follows:

- Define the base voxel size $\epsilon_0$ and maximum octree depth $L_\mathrm{max}$, with per-level cell size $\epsilon_\ell = \epsilon_0/2^\ell$.
- For each voxel $v$ at level $\ell$, compute point density $\rho_v = |P_v|/\epsilon_\ell^3$. Adaptive splitting (for $\rho_v > \tau_\mathrm{split}$) and pruning (for $\rho_v < \tau_\mathrm{prune}$) regulate refinement.
- Each anchor $v$ stores spatial center $p_v \in \mathbb{R}^3$, level $l_v$, scale $s_v$, feature embedding $f_v$, and a set of learnable offsets, often denoted $\{o_v^i\}$.

This strategy yields a sparse octree in which memory and computation grow sublinearly with scene size due to efficient encoding of empty or homogeneous regions and localized refinement where necessary.

## 2. Gaussian Parametrization and Anchor-based Generation

For each anchor, the framework generates a packet of neural Gaussians. Means are computed as $ \mu_{v,i} = p_v + s_v \odot o_v^i $, and covariances via an MLP decoder—e.g., $\Sigma_{v,i} = R_{v,i} S_{v,i}^2 R_{v,i}^\top$, where $R_{v,i}$ encodes rotation and $S_{v,i}$ scale. Appearance properties (opacity $\alpha_{v,i}$, color $c_{v,i}$, SH coefficients, etc.) are decoded from anchor features, view direction, and camera–anchor distance through compact neural networks [2408.17223] [2601.18475] [2403.17898].

Attributes are optimized by backpropagation through photometric, depth, and structural losses, with gradients either pooled or individually contributing to anchor growth/splitting and pruning in an online or batch regime.

This anchor-based parametrization enables highly compressed representations: anchors act as scaffolds supporting detailed, anisotropic Gaussian clusters where needed, while sparse regions retain only coarse anchors, minimizing storage without manual LoD tuning.

## 3. Level-of-Detail Hierarchies and Adaptive Selection

Octree-anchored multi-resolution structuring enables dynamic and view-dependent LoD scheduling. The system computes, for each anchor, the appropriate LoD level as a function of its distance to the camera or its projected screen-space size. For example, an anchor's “preferred” level can be calculated as

$$
L^* = \log_2 \left( \frac{d_\mathrm{max}}{d} \right)
$$

where $d$ is camera–anchor distance and $d_\mathrm{max}$ is the scene’s far bound [2403.17898] [2601.18475]. Anchors with $l \leq \hat{L}$, where $\hat{L}$ is the nearest integer to $L^*$, are queried. LoD culling is achieved either by thresholding projected size or through explicit per-anchor scheduling based on view geometry and gradient signals.

Smooth LoD blending (e.g., opacity interpolation between adjacent LoD levels) prevents visual popping. View- and loss-driven growing/pruning strategies selectively refine under-optimized regions and remove redundant anchors [2601.18475] [2408.17223] [2403.17898]. In streaming and online mapping contexts, LoD scheduling and anchor updates are intertwined with dynamic scene changes via GMM partitioning and progressive keyframe integration [2601.18475] [2408.17223].

## 4. Methods for Compression, Streaming, and Online Mapping

The anchor–octree LoD structure facilitates advanced compression and real-time updates. In HGSC [2411.06976], after importance-based pruning, the 3D positions are encoded in a depth-12 octree using context-adaptive arithmetic coding. Within spatial KD-tree blocks, anchor selection is performed by Farthest Point Sampling, and attributes of non-anchor Gaussians are predicted via $k$-NN regression from anchors and lower LoD reconstructions, with quantized residuals compressed by LZ77.

Streaming systems such as StreamLoD-GS [2601.18475] employ quantized residual refinement—only transmitting per-frame residuals for dynamic anchors identified by GMM analysis of anchor gradient magnitudes, yielding up to 80% reduction in per-frame bandwidth over naïve transmission. Online mapping pipelines like OG-Mapping [2408.17223] employ anchor-based progressive refinement in conjunction with a dynamic keyframe window to maintain compactness and avert catastrophic forgetting in continual operation.

## 5. Rendering, Optimization, and Implementation

Rendering proceeds by projecting Gaussian primitives from all anchors included by current LoD constraints into screen space, sorting by depth, and compositing with alpha blending. Per-anchor MLPs are efficiently batched for fast GPU execution. Training incorporates photometric, depth, and structural similarity losses, with additional regularizers for sparsity and LoD smoothness [2508.14041] [2408.17223] [2403.17898].

Implementation strategies across frameworks are unified in their use of:
- GPU-resident struct arrays and level-indexed anchor tables for rapid LoD selection.
- Auxiliary hash maps or Morton code-based indexing for fast octree traversal.
- On-demand growing and pruning policies executed infrequently for computational efficiency.

Typical models achieve gains such as storage reduction by factors of 5–20× and rendering speeds exceeding 500–700 FPS at high image resolutions [2508.14041] [2411.06976] [2601.18475].

## 6. Empirical Performance and Application Contexts

Anchor- and octree-based LoD-structured 3DGS achieves high-fidelity, scalable scene representations across a range of tasks:

| Method            | PSNR (dB) ↑ | Storage (MB) ↓ | Render (FPS) ↑ |
|-------------------|-------------|----------------|----------------|
| LongSplat         | 27.88       |   101          |    281.7       |
| OG-Mapping        | 38.6        |    30          | 500–800        |
| HGSC (small scene)| 41.31       |   15.81        | n/a            |
| StreamLoD-GS      | 27.84       |  0.19          |    312–608     |
| Octree-GS         | —           |  ~7            |   30–200+      |

Data sourced from [2508.14041], [2408.17223], [2411.06976], [2601.18475], [2403.17898].

In city-scale or long-video scenarios (e.g., LongSplat, Octree-GS), the octree anchor structure provides multi-order memory and throughput gains, enabling state-of-the-art fidelity with real-time rendering and minimal memory footprints [2508.14041] [2403.17898]. In streaming FVV (StreamLoD-GS), LoD-AO structuring, GMM-based motion partitioning, and quantized residual refinement achieve sub-MB per-frame storage and strong PSNR/SSIM under extremely sparse view regimes, with ablations indicating >2 dB drops without LoD structuring [2601.18475]. In compression (HGSC), LoD-staged anchor referencing delivers 4.5× size reduction and orders-of-magnitude faster decompression relative to blockwise compression baselines [2411.06976]. 

## 7. Context, Limitations, and Evolution

The anchor- and octree-based LoD-structured paradigm now underpins modern scalable 3DGS pipelines for scene reconstruction, streaming, and mapping. Key advances include efficient multi-resolution anchor scaffolds, dynamic LoD-driven refinement, and seamless integration with neural decoders and structured attribute coders. Limitations persist related to octree construction under very high noise, merging conflicts during rapid scene changes, and the trade-off between very aggressive pruning (storage) and preservation of fine detail (visual fidelity). Empirical analyses confirm that LoD-aware anchor selection and progressive update policies constitute critical factors in reconciling fidelity, speed, and compactness [2508.14041] [2408.17223] [2411.06976] [2601.18475] [2403.17898].

A plausible implication is that LoD-anchored Gaussian splatting, due to architectural flexibility and inherent responsiveness to data density and view constraints, will remain central for memory- and compute-efficient 3D scene representations across offline and online, static and dynamic applications.

Source: https://www.emergentmind.com/topics/anchor-and-octree-based-lod-structured-3dgs