Differentiable Probabilistic Rasterization

• The paper presents LucidRaster, a GPU-based rasterizer that achieves exact order-independent transparency using a novel two-stage sorting pipeline and per-pixel depth-filtering.
• The methodology leverages succinct data structures, such as k²-trees and k³-trees, to support efficient point, range, and interval queries on both static and time-evolving raster fields.
• Empirical results show high accuracy with minimal blending artifacts and competitive performance compared to traditional hardware blending, despite its substantial memory footprint.

Differentiable probabilistic rasterization refers to methods and data structures enabling efficient, queryable, and often exact processing of raster data, particularly supporting operations required for transparency, probabilistic accumulation, and differentiable computation in raster graphics and spatial data analysis. This domain encompasses GPU software rasterizers for pixel-accurate order-independent transparency (OIT), as well as succinct memory representations for general or time-evolving rasters that support probabilistic or range/value queries with high performance.

1. Principled Frameworks for Differentiable Probabilistic Rasterization

LucidRaster exemplifies a GPU-based software rasterizer designed for exact OIT, addressing the long-standing issue of correct and glitch-free transparency rendering in complex scenes. The pipeline is characterized by a two-stage sorting mechanism: (A) a coarse, block-level in-shared-memory bitonic sort, organizing fragments by 32-bit keys $(K = (D_1\ll10 + I))$ where $D_1$ is a 22-bit quantized depth and $I$ a 10-bit triangle index; (B) a fine-grained, per-pixel min-heap “depth-filter” of size $F$ (default $F=3$), which maintains only the $F$ nearest unblended fragments for each pixel and immediately blends any evicted fragment in accurate front-to-back order (Jakubowski, 2024).

This sorting pipeline permits exact probabilistic color and alpha composition for transparency—respecting the per-sample blend equation: $$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$ implemented as a per-pixel front-to-back accumulation in hardware-like style.

Within spatial data management, compact probabilistic representations leverage succinct tree structures, such as $k^2$-trees and $k^3$-trees, enabling point, range, and aggregate queries regarding observed or expected values across a raster field. Range and value queries map naturally to probabilistic interpretations in GIS applications, supporting operations such as likelihood-of-occurrence estimation over an interval or region (Brisaboa et al., 2019).

2. Algorithmic Structures, Sorting, and Accumulation

LucidRaster’s rasterization proceeds in three principal computation stages: setup, binning, and rasterization. During rasterization, for each 8×4-pixel half-block, a fixed-size list of “tri-half-blocks” records all samples of each intersecting triangle. A 32-bit primary key for sorting, computed as $K = (D_1\ll10 + I)$, ensures block-level fragment ordering in shared memory via bitonic sort. This local ordering is refined per-pixel by maintaining a min-heap (the “depth-filter”) of depth and color/alpha pairs of size $D_1$0.

For each incoming sample, the depth-filter admits the deepest $D_1$1 samples. If overflow occurs, the furthest is immediately blended into the buffer via

$D_1$2

$D_1$3

After all samples, any remaining entries in the heap are blended out in increasing depth order.

Optimization includes an alpha-threshold early-out: when $D_1$4, further shading is skipped for the half-block, with $D_1$5. This mechanism directly exploits probabilistic occlusion for efficiency (Jakubowski, 2024).

In succinct raster representations, ordering and accumulation are governed by bitmaps $D_1$6, $D_1$7, and $D_1$8 in $D_1$9-tree variations, with rank/select primitives providing $I$0 navigation and $I$1 cell access, supporting efficient probabilistic, value, and span queries on general and time-evolving rasters (Brisaboa et al., 2019).

3. Data Structures and Memory Utilization

LucidRaster relies on a per-triangle structure ($I$280 bytes/triangle) storing normals, edge functions, depth edge/flags, and AABBs, and per-quad structures (65 bytes/quad) for colors, texcoords, and bin metadata. Scratch buffers for raster subregions require $I$3768 KB/workgroup. Total GPU memory for tested scenes reaches 1.2 GB, with memory cost modeled by: $I$4 Data-oriented attribute grouping, two-phase batching with prefix sums, and subgroup shuffles minimize cache and memory bandwidth usage (Jakubowski, 2024).

In compact raster representations, structures such as $I$5-trees require

$I$6

bits, optimally $I$7 in the dense case. For general rasters with $I$8 values, multi-tree and interleaved strategies provide space between $I$9–$F$0 bits/cell ($F$1-tree to interleaved), competitive with compressed GeoTIFF for moderate alphabets (Brisaboa et al., 2019).

4. Query and Compositional Methods

Query patterns in differentiable probabilistic rasterization include point-sampling, spatial range selection, value-based retrieval, and temporal queries over time-evolving rasters. In LucidRaster, sampled fragment data is composited using the probabilistic blend equation above, with exact order maintained by the two-stage sorting. The front-to-back accumulation strategy aligns with hardware standards.

Succinct raster representations offer $F$2 cell queries, and $F$3 range and value window queries using rank/select. For general rasters, the cumulative $F$4 (CM) and $F$5-tree enable efficient interval and set queries vital for probabilistic modeling of raster fields over space, value, and time. For time-evolving rasters, interleaved structures ($F$6) and $F$7-trees enable $F$8 access and $F$9 interval queries (Brisaboa et al., 2019).

5. Performance Analysis

Empirical performance of LucidRaster indicates a mean slowdown of $F=3$03.3$F=3$1 compared to hardware alpha blending, competitive with or better than other high-quality OIT approximations, especially in triangle-dense or depth-complex scenes. Depth-filter size $F=3$2 allows for explicit accuracy-speed tradeoffs: $F=3$3 yields $F=3$4 invalid pixels, increasing $F=3$5 to $F=3$6 reduces error to $F=3$7 with $F=3$8 overhead. Alpha-threshold can accelerate opaque scenes by up to $F=3$9, being scene-dependent.

For compact in-memory raster representations, the $F$0-tree attains $F$1–$F$2s point queries in general rasters, and time-evolving representations ($F$3 and $F$4) consistently provide interval queries in $F$5–$F$6s. These structures are up to $F$7 smaller than traditional linear quadtrees in the binary case and answer range/select queries orders of magnitude faster than compressed GeoTIFF (Brisaboa et al., 2019).

Summary of performance (as measured in (Jakubowski, 2024, Brisaboa et al., 2019)):

Method	Space (bits/cell)	Point Query ($F$8s)	Range Query
LucidRaster	--	--	Front-to-back $F$9 per pixel
$$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$0-tree (general)	1.83	1.6–2.9	2–9 $$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$1s
$$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$2-ones (binary)	0.03–0.04	0.29–0.41	3.4 $$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$3s
QT-static (binary)	0.25	0.88–1.10	0.9 $$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$4s
GeoTIFF-comp (general)	1.12	460–500	>500 $$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$5s

6. Limitations and Prospective Extensions

LucidRaster’s memory footprint is substantial ($$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$61.2 GB); dynamic memory management could mitigate unused capacity. The fixed-bin size (32×32 pixels) could be adapted for scene density. No MSAA is currently implemented; enabling 4×–16× MSAA would increase interval storage but is feasible in the blend phase. The current default depth-filter ($$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$7) can be increased to further reduce blending artifacts, but at additional cost. Concurrent execution of low- and high-raster paths may improve utilization for irregular scenes (Jakubowski, 2024).

For succinct raster representations, scalability for very high-dimensional ($$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$8D) data, or rapidly changing time-evolving environments, may challenge the practical benefits of $$\mathbf{C}_{\text{out}} = \sum_{i=1}^n \mathbf{C}_i\,\alpha_i \prod_{j<i}(1-\alpha_j)$$9-tree or interleaved strategies. Increasing value or time domain size correlates directly with storage and navigation complexity. The optimal structure in practice depends crucially on the sparsity and change regime of the underlying raster data (Brisaboa et al., 2019).

7. Broader Context and Applications

Differentiable probabilistic rasterization forms a core computational substrate for real-time graphics, scientific visualization, and spatial data analysis, with direct relevance to order-independent transparency, light transport, and probabilistic spatial modeling in GIS. The LucidRaster pipeline demonstrates efficient, exact OIT for high-complexity scenes, while succinct raster representations with $k^2$0-tree and $k^2$1-tree enable high-speed, space-efficient in-memory analytics for raster fields over space, value, and time.

The methods surveyed enable:

• Exact, real-time compositing of transparent surfaces in GPU graphics pipelines (Jakubowski, 2024).
• Sub-microsecond point and range queries in high-dimensional raster fields, enabling probabilistic and top-$k^2$2 analytics in GIS and imaging pipelines (Brisaboa et al., 2019).

A plausible implication is that advances in GPU-software rasterization and succinct data structures may converge, enabling future rasterization and spatial analytics engines supporting both differentiability (for machine learning integration), probabilistic operations, and expressive query semantics at scale.