Data-Driven Compute Overlays for Interactive Geographic Simulation and Visualization (2506.23364v1)

Abstract: We present interactive data-driven compute overlays for native and web-based 3D geographic map applications based on WebGPU. Our data-driven overlays are generated in a multi-step compute workflow from multiple data sources on the GPU. We demonstrate their potential by showing results from snow cover and avalanche simulations, where simulation parameters can be adjusted interactively and results are visualized instantly. Benchmarks show that our approach can compute large-scale avalanche simulations in milliseconds to seconds, depending on the size of the terrain and the simulation parameters, which is multiple orders of magnitude faster than a state-of-the-art Python implementation.

• The paper introduces a novel WebGPU-based system (weBIGeo) that dynamically generates compute overlays for geographic simulation, enhancing real-time interactivity.
• It employs a flexible API with multi-node compute workflows to handle high-resolution data for snow cover and avalanche simulations.
• Performance evaluations demonstrate speedups up to 3120x over traditional methods, underscoring the system’s efficiency on both high-end and commodity hardware.

Data-Driven Compute Overlays for Interactive Geographic Simulation and Visualization

This paper introduces a novel approach for generating interactive, data-driven compute overlays in 3D geographic map applications using WebGPU. The authors present weBIGeo, a prototype system that leverages compute shaders to dynamically generate overlays from multiple data sources, enabling real-time simulation and visualization of geographic phenomena. The work showcases the potential of this approach through two use cases: snow cover simulation and avalanche simulation, demonstrating significant performance improvements compared to traditional CPU-based methods.

Background and Motivation

Traditional methods for creating data-driven overlays for geographic maps often involve offline computation, limiting their applicability to static data. While server-side rendering offers an alternative, it requires substantial server resources and bandwidth. Client-side rendering using fragment shaders suffers from limitations in resolution and the need for recomputation whenever new map tiles are loaded. The advent of WebGPU provides an opportunity to overcome these limitations by enabling the use of compute shaders in web browsers, thus facilitating dynamic, client-side computation of overlays.

Methodology: Data-Driven Compute Overlays

The core of the proposed approach is a flexible API within weBIGeo that allows users to construct compute workflows as a sequence of compute nodes, similar to dataflow models. Each node represents a computation that can operate on various forms of input data, including scalar values, spatial point data, and raster data. The output of each node can be a texture, buffer, or vector, enabling the creation of complex, multi-step computations. A key advantage of this approach is that the compute pass, which generates the overlay, only needs to be re-executed when the input data changes or simulation parameters are modified. This contrasts with fragment shader-based approaches, which require recomputation for every frame.

Figure 1: A node graph generated from the workflow specification for the avalanche use case, illustrating the multi-resolution Avalanche Overlay Texture generation from terrain model tiles.

Implementation Details of weBIGeo

weBIGeo is built on top of the AlpineMaps.org 3D map rendering framework, using C++ and leveraging Qt for multi-threading, networking, and file I/O, and ImGUI for the user interface. It supports both native (Windows and Linux) and web-based deployment, with the latter achieved through Emscripten, which compiles C++ code into WebAssembly. The rendering pipeline employs a multi-pass approach with deferred shading. The geometry pass renders the z-buffer of the base map, along with albedo, position, and normal information. The compute pass executes the specified compute workflow to generate the multi-resolution overlay texture. Finally, the compose pass blends the data-driven overlay with the base map.

Use Cases and Results

Snow Cover Simulation

The first use case demonstrates a simple snow cover simulation based on terrain features. Users can interactively control parameters such as snow line altitude and terrain steepness. The simulation leverages a compute workflow that retrieves high-resolution DEM tiles, stitches them into a DEM texture, computes surface normals, and determines snow cover based on input parameters. The authors highlight that computing the snow cover in a fragment shader, coupled with the base map resolution, leads to visual artifacts when zooming out, particularly in areas with varying steepness. The data-driven compute overlay, computed at the highest available DEM resolution, mitigates these artifacts.

Figure 2: A comparison of snow cover simulation using a fragment shader versus a data-driven compute overlay, illustrating improved visual quality with the latter when zooming out.

Avalanche Simulation

The second use case focuses on avalanche simulation using a GMF model. The compute workflow fetches DEM tiles, computes normals, and identifies potential release points based on terrain steepness. The final compute node models avalanche particle trajectories and runout distance, taking into account parameters such as persistence and runout angle. The authors compare the performance of weBIGeo with FlowPy, a state-of-the-art Python implementation, on both a high-end desktop and a commodity notebook. The results demonstrate a significant speedup of weBIGeo over FlowPy, with runtimes reduced from seconds to milliseconds for a synthetic dataset and from hours to seconds for a large-scale real-world dataset. For instance, on the desktop configuration, weBIGeo achieved a 748x speedup on the parabola dataset and a 3120x speedup on the vals dataset.

Figure 3: weBIGeo avalanche simulation results on the parabola and vals datasets, highlighting release points and vertical displacement as an indicator of velocity.

Discussion and Implications

The results presented in this paper underscore the potential of WebGPU for interactive geographic simulation and visualization. The data-driven compute overlays offer a significant improvement in visual quality compared to fragment shader-based approaches, while also achieving substantial performance gains compared to CPU-based methods. The authors acknowledge that the spatial extent of the overlay is limited by GPU memory, particularly when working with high-resolution DEMs. The work suggests that client-side analysis and rendering is a viable option, even on commodity hardware, and is particularly promising for expert users who require intensive interaction with simulation parameters.

Conclusion

This paper makes a compelling case for the use of WebGPU-based data-driven compute overlays in geographic simulation and visualization. By leveraging the power of compute shaders, weBIGeo enables real-time interaction with complex simulations, opening up new possibilities for scientific research and public domain applications. Future work could explore the application of this approach to interactive visualizations of large geographic datasets, such as heatmaps of user-selected points of interest or solar potential analysis under different scenarios.