Parametric functions are an extremely efficient representation for 3D geometry, capable of compactly modelling highly complex objects. Once specified, parametric 3D objects allow for visualization at arbitrary levels of detail, at no additional memory cost, limited only by the amount of evaluated samples. However, mapping the sample evaluation to the hardware rendering pipelines of modern graphics processing units (GPUs) is not trivial. This has given rise to several specialized solutions, each targeting interactive rendering of a constrained set of parametric functions. In this paper, we propose a general method for efficient rendering of parametrically defined 3D objects. Our solution is carefully designed around modern hardware architecture. Our method adaptively analyzes, allocates and evaluates parametric function samples to produce high-quality renderings. Geometric precision can be modulated from few pixels down to sub-pixel level, enabling real-time frame rates of several 100 frames per second (FPS) for various parametric functions. We propose a dedicated level-of-detail (LOD) stage, which outputs patches of similar geometric detail to a subsequent rendering stage that uses either a hardware tessellation-based approach or performs point-based softare rasterization. Our method requires neither preprocessing nor caching, and the proposed LOD mechanism is fast enough to run each frame. Hence, our approach also lends itself to animated parametric objects. We demonstrate the benefits of our method over a state-of-the-art spherical harmonics (SH) glyph rendering method, while showing its flexibility on a range of other demanding shapes.
Spatio-temporal ensemble data consist of several simulation runs with multiple spatial and a temporal dimension, where the runs are obtained using different parameter settings or initial conditions for the simulation. During analysis, one is interested in investigating the different facets of space, time, and parameter values. When globally analyzing some facet(s), others shall be aggregated to generate summary visualizations. Due to the large amount of data that an ensemble consists of, one may want to generate summary visualizations at multiple levels of detail. Wavelet transforms are a well-known concept for efficiently switching between multiple resolutions. We propose to extend this concept to ensemble data, where individual facets may be aggregated adaptively. We present how to apply the scheme for any data sizes to generate correct averages even when the number of samples is not a power of two in each dimension. We further develop an out-of-core strategy to handle large data sizes. Our scheme is coupled with common 1D, 2D, and 3D visualization methods for an interactive visual analysis of the ensemble data.
Among various space partitioning approaches for managing point sets out-of-core, octrees are commonly used for being simple and effective. An efficient and adaptive out-of-core octree construction method has been proposed by Kontkanen et al. [KTO11], generating the octree data in a single sweep over the points sorted in Morton order, for a given maximum point count m per octree leaf. Their method keeps m+ 1 points in memory during the process, which may become an issue for large m. We present an extension to their algorithm that requires a minimum of two points to be held in memory in addition to a limited sequence of integers, thus adapting their method for use cases with large m. Moreover, we do not compute Morton codes explicitly but rather perform both the sorting and the octree generation directly on the point data, supporting coordinates of any finite precision.
The clip technique is a popular method for visualizing complex structures and phenomena within 3D unstructured meshes. Meshes can be clipped by specifying a scalar isovalue to produce an output unstructured mesh with its external surface as the isovalue. Similar to isocontouring, the clipping process relies on scalar data associated with the mesh points, including scalar data generated by implicit functions such as planes, boxes, and spheres, which facilitates the visualization of results interior to the grid. In this paper, we introduce a novel batch-driven parallel algorithm based on a sequential clip algorithm designed for high-quality results in partial volume extraction. Our algorithm comprises five passes, each progressively processing data to generate the resulting clipped unstructured mesh. The novelty lies in the use of fixed-size batches of points and cells, which enable rapid workload trimming and parallel processing, leading to a significantly improved memory footprint and run-time performance compared to the original version. On a 32-core CPU, the proposed batch-driven parallel algorithm demonstrates a run-time speed-up of up to 32.6x and a memory footprint reduction of up to 4.37x compared to the existing sequential algorithm. The software is currently available under an open-source license in the VTK visualization system.
Visualization is an important tool for scientists to extract understanding from complex scientific data. Scientists need to understand the uncertainty inherent in all scientific data in order to interpret the data correctly. Uncertainty visualization has been an active and growing area of research to address this challenge. Algorithms for uncertainty visualization can be expensive, and research efforts have been focused mainly on structured grid types. Further, support for uncertainty visualization in production tools is limited. In this paper, we adapt an algorithm for computing key metrics for visualizing uncertainty in Marching Cubes (MC) to multi-core devices and present the design, implementation, and evaluation for a Filter for uncertainty visualization of Marching Cubes on Multi-Core devices (FunMC2). FunMC2 accelerates the uncertainty visualization of MC significantly, and it is portable across multi-core CPUs and GPUs. Evaluation results show that FunMC2 based on OpenMP runs around 11× to 41× faster on multi-core CPUs than the corresponding serial version using one CPU core. FunMC2 based on a single GPU is around 5× to 9× faster than FunMC2 running by OpenMP. Moreover, FunMC2 is flexible enough to process ensemble data with both structured and unstructured mesh types. Furthermore, we demonstrate that FunMC2 can be seamlessly integrated as a plugin into ParaView, a production visualization tool for post-processing.
Glyphs are an intuitive way of displaying the results of atomistic simulations, usually as spheres. Raycasting of camera-aligned billboards is considered the state-of-the-art technique to render large sets of spheres in a rasterization-based pipeline since the approach was first proposed by Gumhold. Over time various acceleration techniques have been proposed, such as the rendering of point primitives as billboards, which are trivial to rasterize and avoid a high workload in the vertex pipeline. Other techniques attempt to optimize data upload and access patterns in shader programs, both relevant aspects for dynamic data. Recent advances in graphics hardware raise the question of whether these optimizations are still valid. We evaluate several rendering and data access scheme combinations on real-world datasets and derive recommendations for efficient rasterization-based sphere rendering. CCS Concepts • Computing methodologies → Rasterization; • Human-centered computing → Scientific visualization;
Modern visualization software facilitates the creation of visualization pipelines combining a plethora of algorithms to achieve high-fidelity visualization. When the complexity of the pipelines to be created increases, additional techniques are needed to ensure that reasoning about the pipelines structure and its performance remains feasible. This paper presents three additions to ParaView with the goal of improving presentation of complex, parallel pipelines benefiting pipeline realization. More specifically, we provide a runtime performance annotation visualization integrated in a visual programming node editor, allowing all users to reason about basic performance and intuitively manipulate the structure and configuration of pipelines. Further, we extend the list of available filters with control flow filters, supporting forand while-loops with a comprehensible representation in the node editor. Our extension is based on graphical manipulation of a node graph that expresses the flow of data and computation in a VTK pipeline, and draws upon a long tradition and positive experience with similar interfaces across a wide range of software systems such as the visualization tools SCIRun and VTK Designer, or the rendering systems Blender and Houdini. The extension we provide integrates seamlessly into the existing ParaView architecture as a plug-in, i.e., it does not require any modifications to ParaView itself or VTK’s execution model.
We present a parallel compositing algorithm for Volumetric Depth Images (VDIs) of large three-dimensional volume data. Large distributed volume data are routinely produced in both numerical simulations and experiments, yet it remains challenging to visualize them at smooth, interactive frame rates. VDIs are view-dependent piecewise constant representations of volume data that offer a potential solution. They are more compact and less expensive to render than the original data. So far, however, there is no method for generating VDIs from distributed data. We propose an algorithm that enables this by sort-last parallel generation and compositing of VDIs with automatically chosen content-adaptive parameters. The resulting composited VDI can then be streamed for remote display, providing responsive visualization of large, distributed volume data.
Large scale graphs are used to encode data from a variety of application domains such as social networks, the web, biological networks, road maps, and finance. Computing enriching layouts and interactive rendering play an important role in many of these applications. However, producing an efficient and interactive visualization of large graphs remains a major challenge, particularly in the web-browser. Existing state of the art web-based visualization systems such as D3.js, Stardust, and NetV.js struggle to achieve interactive layout and visualization for large scale graphs. In this work, we leverage the latest WebGPU technology to develop GraphWaGu , the first WebGPU-based graph visualization system. WebGPU is a new graphics API that brings the full capabilities of modern GPUs to the web browser. Leveraging the computational capabilities of the GPU using this technology enables GraphWaGu to scale to larger graphs than existing technologies. GraphWaGu embodies both fast parallel rendering and layout creation using modified Frutcherman-Reingold and Barnes-Hut algorithms implemented in WebGPU compute shaders. Experimental results demonstrate that our solution achieves the best performance, scalability, and layout quality when compared to current state of the art web-based graph visualization libraries. All of our source code for the project is available at https://github.com/harp-lab/GraphWaGu.
We describe a systematic approach for rendering time-varying simulation data produced by exa-scale simulations, using GPU workstations. The data sets we focus on use adaptive mesh refinement (AMR) to overcome memory bandwidth limitations by representing interesting regions in space with high detail. Particularly, our focus is on data sets where the AMR hierarchy is fixed and does not change over time. Our study is motivated by the NASA Exajet, a large computational fluid dynamics simulation of a civilian cargo aircraft that consists of 423 simulation time steps, each storing 2.5 GB of data per scalar field, amounting to a total of 4 TB. We present strategies for rendering this time series data set with smooth animation and at interactive rates using current generation GPUs. We start with an unoptimized baseline and step by step extend that to support fast streaming updates. Our approach demonstrates how to push current visualization workstations and modern visualization APIs to their limits to achieve interactive visualization of exa-scale time series data sets
Over the last 20 years, flooding has been the most common natural disaster, accounting for 44.7% of all disasters, affecting about 1.65 billion people worldwide and causing roughly 105 thousand deaths†. In contrast to other natural disasters, the impact of floods is preventable through affordable structures such as dams, dykes and drainage systems. To be most effective, however, these structures have to be planned and evaluated using the highest precision data of the underlying terrain and current weather conditions. Modern laser scanning techniques provide very detailed and reliable terrain information that may be used for flood inundation modelling in planning and hazard warning systems. These warning systems become more important since flood hazards increase in recent years due to ongoing climate change. In contrast to simulations in planning, simulations in hazard warning systems are time critical due to potentially fast changing weather conditions and limited accuracy in forecasts. In this paper we present a highly optimized CUDA implementation of a numerical solver for the hydraulic equations. Our implementation maximizes the GPU’s memory throughput, achieving up to 80% utilization. A speedup of a factor of three is observed in comparison to previous work. Furthermore, we present a low-overhead, in-situ visualization of the simulated data running entirely on the GPU. With this, an area of 15 km2 with a resolution of 1 m can be visualized hundreds of times faster than real time on consumer grade hardware. Furthermore, the flow settings can be changed interactively during computation. CCS Concepts • Human-centered computing → Scientific visualization; Geographic visualization; • Computing methodologies → Realtime simulation; Massively parallel and high-performance simulations; Massively parallel algorithms;
Modern simulations and experiments can produce massive amounts of high-fidelity data that are challenging to transport and visualize interactively. We have designed a data streaming system to support interactive visualization of large volume data. Our streaming system design is unique in its flexibility to support diverse data organizations and its coupling with a highly efficient CPU-based ray-tracing renderer. In this paper, we present our streaming and rendering design and demonstrate the efficacy of our system with progressive rendering of streaming tree-based AMR (TAMR) volume data and radial basis function (RBF) particle volume data. With our system, interactive visualization can be achieved using only a mid-range workstation a single a quantity
Graphical processing units (GPUs) have gained popularity in recent years due to their efficiency in running massively parallel applications. Recent developments have also adapted ray-tracing algorithms to the GPU, where the bottleneck in the overall performance is usually given by the memory bandwidth. In this paper, we present an interactive, web-based visualization tool for GPU memory traces that provides visual insight into the memory and cache behavior of our reference ray tracer, by mapping internal GPU state back onto 3D objects. In order to visualize cache behavior, we use reuse distances on both GPU cache layers that are calculated on the basis of memory traces extracted from a real GPU using binary instrumentation. An advantage of our system is that it runs independently of the ray-tracing program. We further show visualizations of our GPU ray tracer and compare the visualizations of several ray-tracing approaches. We find our work to act as a convenient toolset to gather insights on which data structures and mesh regions can be cached efficiently, and how ray-tracing acceleration structures behave on various input meshes, bounding volume hierarchies, memory layouts, frame buffer resolutions
This paper presents a novel Discrete Element Method (DEM) on the GPU for efficient snow simulation. To this end, our approach employs an iterative scheme on particles that easily allows the snow density to vary vastly for simulation while still maintaining a relatively large time step. We provide computationally inexpensive ways to capture cohesion and compression in the snow that enables us to generalize the behavior of various kinds of snow (like dry, wet, etc.) by varying physical parameters within the same simulator. We achieve a speed-up of nearly eight times with one million snow particles over the existing real-time method, even while dealing with scenes containing complex object boundaries. Furthermore, our simulator not only retains stability at these large time steps but also improves upon the physical behavior of the existing method. We have also conducted a user evaluation of our approach, where a majority of the participants voted in favor of its realism value for computer games.
High-performance computing trends are requiring in situ processing increasingly often. This work considers automating camera placement for in situ visualization, specifically of isosurfaces, which is needed when there is no human in the loop and no a priori knowledge of where to place the camera. Our approach utilizes Viewpoint Quality (VQ) metrics, which quantify which camera positions provide the most insight. We have two primary contributions. First, we introduce an approach parallelizing the calculation of VQ metrics, which is necessary for usage in an in situ setting. Second, we introduce an algorithm for searching for a good camera position that balances between maximizing VQ metric score and minimizing execution time. We evaluate our contributions with an in situ performance study on a supercomputer. Our findings confirm that our approach is viable, and in particular that we can find good viewpoints with small execution time.
We study the problem of computing a spatial scatterplot on a large dataset for arbitrary zooming/panning queries. We introduce a general framework called “Rainbow” that generates a high-quality scatterplot for a given result-size budget. Rainbow augments a spatial index with judiciously selected representative points offline. To answer a query, Rainbow traverses the index top-down and selects representative points with a good quality until the result-size budget is reached. We experimentally demonstrate the effectiveness of Rainbow
We describe a technique for GPU and RTX accelerated space skipping of structured volumes that improves on prior work by replacing clustered proxy boxes with a GPU-extracted triangle mesh that bounds the active regions. Unlike prior methods, our technique avoids costly clustering operations, significantly reduces data structure construction cost, and incurs less overhead when traversing active regions.
Data-parallel programming (DPP) has attracted considerable interest from the visualization community, fostering major software initiatives such as VTK-m. However, there has been relatively little recent investigation of data-parallel APIs in higherlevel languages such as Python, which could help developers sidestep the need for low-level application programming in C++ and CUDA. Moreover, machine learning frameworks exposing data-parallel primitives, such as PyTorch and TensorFlow, have exploded in popularity, making them attractive platforms for parallel visualization and data analysis. In this work, we benchmark data-parallel primitives in PyTorch, and investigate its application to GPU volume rendering using two distinct DPP formulations: a parallel scan and reduce over the entire volume, and repeated application of data-parallel operators to an array of rays. We find that most relevant DPP primitives exhibit performance similar to a native CUDA library. However, our volume rendering implementation reveals that PyTorch is limited in expressiveness when compared to other DPP APIs. Furthermore, while render times are sufficient for an early “proof of concept”, memory usage acutely limits scalability. CCS Concepts • Human-centered computing → Scientific visualization; • Computing methodologies → Parallel computing methodologies; Rendering;
