Hierarchical Ray Sampling in Rendering

• Hierarchical ray sampling is a set of structured techniques that organizes ray samples based on spatial and statistical importance to streamline rendering pipelines.
• It employs a two-stage process—coarse sampling followed by fine sampling—to focus computation on high-opacity or high-importance regions in neural radiance fields and GPU ray tracing.
• Optimized data orchestration and hierarchical grouping methods yield significant speedups, with studies reporting up to 49% faster performance and 63.8% fewer intersection tests in complex scenes.

Hierarchical ray sampling is a family of strategies for efficiently selecting and processing ray samples in rendering pipelines, most notably in neural radiance field (NeRF) methods and GPU ray tracing. By exploiting spatial and/or statistical coherence among rays—and organizing samples or rays into hierarchical structures—these algorithms dramatically reduce redundant computation, accelerate convergence, and, in some instances, yield highly parallelizable pipelines suitable for modern hardware.

1. Core Principles of Hierarchical Ray Sampling

Hierarchical ray sampling techniques organize rays or ray samples into structures based on spatial origin, direction, or statistical importance. The central idea is to focus computational effort on the subset of samples or directions most relevant to the final rendering, culling or deprioritizing unlikely or redundant samples early in the process.

In the context of neural rendering (e.g., NeRF), hierarchical sampling frequently refers to casting “coarse” samples uniformly along a ray, evaluating importance weights, and then casting a second “fine” set of samples where the probability of encountering non-negligible opacity is high (Morozov et al., 2023, Pan et al., 2022). In GPU ray tracing, the method extends to building explicit n-level hierarchies of ray packets (bundles) that allow collective intersection and culling in scene traversal (Reis et al., 2023).

2. Hierarchical Sampling in Neural Radiance Fields

The canonical hierarchical scheme, introduced in the original NeRF pipeline and subsequently refined, proceeds in two main stages:

1. Coarse Sampling: Evaluate a neural field at $N_c$ uniformly spaced points $t_i$ along a ray $r(t) = o + t d$ to obtain densities $\sigma_i$ and colors $c_i$.
2. Fine Sampling: Compute weights

$$w_i = (1 - \exp(-\sigma_i \delta_i)) \exp(-\sum_{j<i} \sigma_j \delta_j)$$

and form a piecewise-constant PDF over bins. Sample $N_f$ new points from this PDF, evaluate the field, and re-compute the output using all samples (Pan et al., 2022).

An improved approach based on reparameterized (RVS) inverse-transform sampling generates samples directly according to the opacity-induced distribution:

$$p_r(t) = \sigma_r(t)\exp\Big(-\int_{t_n}^t \sigma_r(s)ds\Big)$$

Sampling is accomplished by inverting the CDF, enabling end-to-end differentiability and eliminating the need for auxiliary proposal network losses (Morozov et al., 2023). This step not only concentrates computation on non-transparent portions, but allows Monte Carlo estimation with as few as 8–16 samples per ray without artifacts.

3. Hierarchical Structures in Ray Tracing: Ray-Space Hierarchies

In high-performance GPU ray tracing, hierarchical ray sampling is realized as an explicit hierarchy over secondary rays, known as a Ray-Space Hierarchy (RSH) (Reis et al., 2023). The algorithm consists of:

• Primary-Ray Phase: Rasterization pipelines (e.g., OpenGL, Vulkan) process primary rays. No hierarchy is built due to GPU hardware throughput; only per-pixel data is extracted.
• Secondary-Ray Phase: Shadow, reflection, and refraction rays (secondary effects) are bundled into coherent groups using sorting schemes based on quantized origin and direction (via integer hashes), then recursively grouped into a tree. Each node holds a bounding sphere and cone for the set of rays it contains.
• Top-Down Traversal: Scene geometry is partitioned into bounding spheres; at each recursive node, the node's bounding sphere/cone is intersected with all object spheres to cull non-intersecting meshes before proceeding deeper.
• Leaf Processing: For leaf nodes, only the remaining triangle candidates are tested for intersection, dramatically decreasing the number of operations.

This approach exploits both spatial and directional coherence of secondary rays to achieve tighter bounds for groups of rays, yielding substantial reductions in ray-primitive intersection tests—up to 50% compared to previous hierarchical approaches in shadow ray scenarios (Reis et al., 2023).

4. Generalizations: Hierarchical Sampling Along Curved Rays

Traditional hierarchical NeRF methods assume homogeneous media and straight rays. To address rendering in heterogeneous (e.g., refractive) volumes, hierarchical sampling can be extended along curved paths defined by the Eikonal equation:

$\|\nabla\phi(x)\| = n(x)$

where $n(x)$ is the spatially varying refractive index. The ray path is integrated as a sequence $x_{i+1} = x_i + \frac{\Delta s}{n(x_i)}v_i$, with direction updates $v_{i+1} = v_i + \Delta s\nabla n(x_i)$. Hierarchical sampling proceeds identically, only using arc-length along the curved path in place of straight-line distance (Pan et al., 2022):

• Coarse points are subsampled from the curved trajectory.
• Weights and PDFs are calculated using curved-segment lengths.
• Fine samples are drawn along the total optical path using inverse-CDF methods and locally linearized for network evaluation.

This generalization enables hierarchical ray sampling for a broader class of light transport problems.

5. Algorithmic Details and GPU Implementation

Efficient hierarchical ray sampling on GPUs requires careful data orchestration and parallelization. In Coherent RSH on the GPU (Reis et al., 2023):

• Rays are stored in Structure-of-Arrays format for memory efficiency.
• Ray attributes are quantized and hashed for sorting and grouping.
• Arrays of keys, indices, and flags are used for fast compaction and radix sort (using CUB primitives).
• Nodes in the hierarchy store bounding sphere (center, radius) and cone (axis, angle cosine) descriptors.
• GPU kernel grids are tuned for hardware occupancy, with one thread per ray (for sorting) or per node-level bundle (for traversal).

Typical pipeline stages include rasterization, bounding sphere updates, secondary ray generation, key sorting, bottom-up hierarchy build, top-down culling, and final per-primitive intersection, all executed with high parallel efficiency.

6. Quantitative Impact and Empirical Results

Hierarchical ray sampling methods consistently reduce computational load relative to brute-force approaches or non-coherent hierarchical schemes.

For Coherent RSH (Reis et al., 2023):

• In the “OFFICE” scene (251,546 rays, 36k triangles):
  • Brute-force: $1.28 \times 10^{10}$ tests
  • Classical hierarchy: $6.6 \times 10^7$ (5.14%)
  • Coherent RSH: $2.5 \times 10^7$ (1.86%; 63.8% fewer than classical hierarchy)
• Frame time: Classical hierarchy 618 ms vs. Coherent RSH 316 ms on GTX Titan (~49% speedup).
• Hierarchy traversal and intersection account for >95% of frame time, and traversal is $2 \times$ faster in Coherent RSH due to tighter mesh culling.

For hierarchical NeRF sampling with reparameterized volume sampling (Morozov et al., 2023):

• On Blender “Lego” ($N_p = 32, N_f = 64$): NeRF PSNR = 30.11 vs. RVS-NeRF = 31.89
• Across Blender scenes (average): PSNR improves from 29.49 (original) to 30.26 (RVS), with faster training and elimination of auxiliary losses.

A plausible implication is that hierarchical sampling, when matched to the basin of high-opacity or high-importance signal, drives both computational and statistical efficiency in differentiable rendering.

7. Extensions and Considerations

Hierarchical ray sampling strategies require problem-specific adaptation:

• For straight rays in homogeneous media, traditional hierarchical sampling suffices.
• In refractive or heterogenous contexts, sampling must align to optical path length and curved trajectories (Pan et al., 2022).
• The effectiveness of ray bundling depends on the ability of hash/sort heuristics to maintain real coherence, a factor sensitive to scene distribution.
• The parallelization model (threads per ray/node) and arithmetic intensity need to be tailored to the target GPU or accelerator.

Future research may generalize these frameworks to even richer domains—e.g., multi-spectral rendering, stochastic media, or real-time adaptive neural fields—where the trade-off between sampling density and computational cost is dynamically re-optimized.