Visibility Bitmask: Data Structure & Applications

• Visibility Bitmask is a binary data structure that encodes the visibility state of discretized spatial or angular subdomains using an N-bit integer.
• It employs bitwise operations and efficient population algorithms to update and query occlusion data in constant time, enabling real-time performance.
• Applications include screen-space ambient occlusion, LiDAR volumetric mapping, and dynamic indexing, offering rigorous error bounds and low computational overhead.

A visibility bitmask is a compact data structure and computational abstraction for representing binary visibility/occlusion state across a discretized angular or spatial domain. By encoding the state of $N$ subregions (sectors, direction bins, or elements) into an $N$-bit integer, visibility bitmasks permit highly efficient queries, updates, and aggregation over visibility data—enabling real-time performance in applications spanning graphics, geometric reconstruction, and succinct indexing. Recent research has formalized and systematized the use of bitmasks for ambient occlusion integration (Therrien et al., 2023), volumetric mapping from LiDAR (Maese et al., 24 Sep 2025), and dynamic rank/select-indexed visibility sets (Pibiri et al., 2020).

1. Mathematical Formalization

A visibility bitmask $M$ encodes, for a set of $N$ discrete subdomains (e.g., angular sectors, voxels, or elements), the binary state $V_j \in \{0,1\}$ for each $j \in [0,N-1]$. This is typically aggregated as:

$M = \sum_{j=0}^{N-1} V_j \cdot 2^j$

where $V_j = 1$ denotes “occluded” (or visible, depending on convention), and $V_j = 0$ otherwise. Bitwise operations—AND, OR, XOR, POPCOUNT, bit-shift—allow for $O(1)$ update and query cost per operation on modern architectures.

For domains with multidimensional or directional structure, $N$0 may correspond to the number of spatial directions (e.g., hemisphere sectors in graphics (Therrien et al., 2023)), voxels at specific distance bins (Maese et al., 24 Sep 2025), or abstract elements in compressed indices (Pibiri et al., 2020).

2. Construction and Update Algorithms

Bitmask population—i.e., determining $N$1 for each sector or element—depends on the application and geometric semantics:

• Screen-Space Visibility: For each sample along an azimuthal slice, a wedge $N$2 is assigned by projecting the visible occluder geometry, then all $N$3 whose sector $N$4 overlaps this wedge are marked (set to $N$5) in $N$6. This is done via bit arithmetic: $N$7, followed by $N$8 (Therrien et al., 2023).
• Directional Volumetric Mapping: In DB-TSDF, each voxel stores a 32-bit distance_mask. Integration for a LiDAR return uses direction-binned, precomputed kernels $N$9, with bitwise AND between $M$0 and $M$1 giving an updated mask. “Shadow” region voxels have a hit_counter and sign_flag to mark occupancy transitions (Maese et al., 24 Sep 2025).
• Succinct Rank/Select over Bitmaps: For a fully dynamic (mutable) visibility bitmask, blocks of $M$2 bits are augmented with a segment tree over block popcounts. Flip, rank, and select operations are each $M$3 with typical empirical costs $M$4 ns for $M$5 (Pibiri et al., 2020).

3. Query, Aggregation, and Analytic Integration

Visibility bitmasks enable a range of query primitives:

• Rank: The number of “visible” (or “occluded”, by convention) bits up to position $M$6 can be determined by prefix POPCOUNT, possibly accelerated with local block and segment tree summaries (Pibiri et al., 2020).
• Select: The position of the $M$7-th “one” bit is found using in-block select (using, e.g., $M$8) plus segment tree search (Pibiri et al., 2020).
• Popcount Integration: For analytic integration (e.g., in ambient occlusion), summing over $M$9 across $N$0 sectors provides an unbiased estimate of unoccluded area; error is provably $N$1 in this discretization (Therrien et al., 2023).
• Distance Extraction: In DB-TSDF, the number of trailing ones in the mask ($N$2) recovers the signed distance estimate to the nearest surface (Maese et al., 24 Sep 2025).

4. Applications in Computer Graphics and Geometry

The visibility bitmask paradigm has been widely adopted in:

• Screen-Space Ambient Occlusion and Indirect Lighting: Traditional horizon-based AO used two scalar horizon angles; the visibility bitmask approach replaces this with an $N$3-bit field per slice, capturing binary sector occlusion. This enables physically coherent, multisector integration for AO and indirect irradiance, reducing artifacts and providing low-noise multi-cone directional lighting (Therrien et al., 2023). The method allows for occlusion behind thin surfaces and seamless integration into existing pipelines, with practical configurations using $N$4 (single 32-bit word) for negligible ALU overhead.
• Volumetric Mapping (TSDF/ESDF): DB-TSDF utilizes a 32-bit distance_mask bitmask in each voxel, encoding discretized $N$5-distance to surfaces, with additional accumulators for occupancy and state transitions. The bitmask-based update kernel leverages direction quantization (e.g., $N$6) and per-direction kernels, yielding strictly constant cost per pointcloud independent of grid resolution. This achieves CPU-only high-fidelity mapping at fixed runtime per scan (Maese et al., 24 Sep 2025).
• Compressed Indexing/Data Structures: Fully dynamic bitmask representations with efficient rank/select (for flip/rank/select queries) support updates and queries for visibility sets or access control lists in data systems, succinct integer sets, and other computational geometry problems (Pibiri et al., 2020).

5. Performance, Error Bounds, and Trade-offs

Bitmask-based visibility incurs discretization error proportional to subdomain width ($N$7 for angular AO sectors), but enables constant-time ALU-only integration. In GPU lighting, increasing $N$8 from $N$9 halves error but incurs minor additional computation, with all bitmask operations ($V_j \in \{0,1\}$0, shifts, logicals) mapped to hardware primitives (Therrien et al., 2023). On modern CPUs, segment-tree-augmented bitmasks deliver flip/rank/select in $V_j \in \{0,1\}$1 ns per operation and sub-7% overhead at $V_j \in \{0,1\}$2 (Pibiri et al., 2020).

In volumetric schemes like DB-TSDF, per-scan integration is independent of voxel grid size or resolution; only memory usage scales with resolution (Maese et al., 24 Sep 2025). On an i7-13620H CPU, 100k-point scans are fused in $V_j \in \{0,1\}$3 ms across resolutions, and downsampling linearly reduces runtime.

6. Comparison to Classical and Alternative Approaches

Visibility bitmasks generalize and optimally discretize previous scalar or list-based occlusion metrics:

Classical Approach	Bitmask-based Analog	Key Advantages
Scalar horizon angles	$V_j \in \{0,1\}$4-bit sector bitmask	No overdarkening, multi-directional AO (Therrien et al., 2023)
Floating-point distances	trailing-ones in distance_mask	Integer-only, monotonic updates (Maese et al., 24 Sep 2025)
List-based sets	Sorted/subset bits, segment trees	O(1)-O(log n) ops, low memory (Pibiri et al., 2020)

Compared to horizon-based AO, bitmask AO removes “halos”, improves thin surface fidelity, and supports multi-cone lighting. Compared to classical TSDF, bitmask DB-TSDF enables CPU-only, resolution-independent computation with sharply defined boundaries.

7. Limitations and Ongoing Research

Discretization coarseness ($V_j \in \{0,1\}$5 or kernel granularity) determines error bounds; higher resolution increases ALU/memory demands. Some applications (e.g., DB-TSDF mapping) require precomputed directional kernels and careful quantization to maintain performance/accuracy balance (Maese et al., 24 Sep 2025). A plausible implication is that extending bitmask logic to irregular or dynamic domains presents nontrivial challenges in lookup structures and kernel management.

Future research may extend bitmask strategies to fully GPU-parallel volumetric fusion (beyond screen-space) or hybridize segmented visibility sets with learned priors for context-adaptive occlusion and mapping. The formal complexity-optimality of bitmask-based dynamic rank/select structures (Pibiri et al., 2020) further suggests broad applicability in data-intensive, resource-constrained environments.