We present a new algorithm for rendering very large volume data sets at interactive framerates on standard PC hardware. The algorithm accepts scalar data sampled on a regular grid as input. The input data is converted into a compressed hierarchical wavelet representation in a preprocessing step. During rendering, the wavelet representation is decompressed on-the-fly and rendered using hardware texture mapping. The level of detail used for rendering is adapted to the local frequency spectrum of the data and its position relative to the viewer. Using a prototype implementation of the algorithm we were able to perform an interactive walkthrough of large data sets such as the visible human on a single of-the-shelf PC.

Figure 1: Volumes rendered using 3D textures on commodity GPU. The rendering is accelerated by our empty space skipping. The images are identical to those rendered without the acceleration, while the rendering is about 2 to 5 times faster. We propose methods to accelerate texture-based volume rendering by skipping invisible voxels. We partition the volume into sub-volumes, each containing voxels with similar properties. Subvolumes composed of only voxels mapped to empty by the transfer function are skipped. To render the adaptively partitioned subvolumes in visibility order, we reorganize them into an orthogonal BSP tree. We also present an algorithm that computes incrementally the intersection of the volume with the slicing planes, which avoids the overhead of the intersection and texture coordinates computation introduced by the partitioning. Rendering with empty space skipping is 2 to 5 times faster than without it. To skip occluded voxels, we introduce the concept of orthogonal opacity map, that simplifies the transformation between the volume coordinates and the opacity map coordinates, which is intensively used for occlusion detection. The map is updated efficiently by the GPU. The sub-volumes are then culled and clipped against the opacity map. We also present a method that adaptively adjusts the optimal number of the opacity map updates. With occlusion clipping, about 60 % of non-empty voxels can be skipped and an additional 80% speedup on average is gained for iso-surface-like rendering.

This paper presents a solution for texture mapping unparameterized models. The quality of a texture on a model is often limited by the model's parameterization into a 2D texture space. For models with complex topologies or complex distributions of structural detail, finding this parameterization can be very difficult and usually must be performed manually through a slow iterative process between the modeler and texture painter. This is especially true of models which carry no natural parameterizations, such as subdivision surfaces or models acquired from 3D scanners. Instead, we remove the 2D parameterization and store the texture in 3D space as a sparse, adaptive octree. Because no parameterization is necessary, textures can be painted on any surface that can be rendered. No mappings between disparate topologies are used, so texture artifacts such as seams and stretching do not exist. Because this method is adaptive, detail is created in the map only where required by the texture painter, conserving memory usage.

planes rendered. Right: Refined to 98 textures with extra planes. We present a system for interactively rendering large, unstructured grids. Our approach is to voxelize the grid into a 3D voxel octree, and then to render the data using hierarchical, 3D texture mapping. This approach leverages the current 3D texture mapping PC hardware for the problem of unstructured grid rendering. We specialize the 3D texture octree to the task of rendering unstructured grids through a novel pad and stencil algorithm, which distinguishes between data and non-data voxels. Both the voxelization and rendering processes efficiently manage large, out-ofcore datasets. The system manages cache usage in main memory and texture memory, as well as bandwidths among disk, main memory, and texture memory. It also manages rendering load to achieve interactivity at all times. It maximizes a quality metric for a desired level of interactivity. It has been applied to a number of large data and produces high quality images at interactive, userselectable frame rates using standard PC hardware. 1

Figure 1: Large volume data ray-traced at 512 2 using octrees for compression and acceleration. From left to right: (1) LLNL Richtmyer-Meshkov instability field (shown at timestep 270, with an isovalue of 100). (2) Closer view of the previous scene. (3) Utah CSAFE heptane simulation (timestep 152, isovalue 42). Data is losslessly compressed into an octree volume to occupy less than one quarter the size of the original 3D array. Our approach permits storage of large data such as the LLNL simulation, and full sequences of medium-size data such as the heptane, in main memory of consumer machines. Frame rates on an Intel Core Duo 2.16 GHz laptop with 2 GB RAM are 2.4, 1.3, and 3.3 fps respectively. On a 16-node NUMA 2.4 GHz Opteron workstation, these images render at 17.9, 9.8, and 22.0 fps. We present a technique for ray tracing isosurfaces of large compressed structured volumes. Data is first converted into a losslesscompression octree representation that occupies a fraction of the original memory footprint. An isosurface is then dynamically rendered by tracing rays through a min/max hierarchy inside interior octree nodes. By embedding the acceleration tree and scalar data in a single structure and employing optimized octree hash schemes, we achieve competitive frame rates on common multicore architectures, and render large time-variant data that could not otherwise be accomodated.

Datasets of tens of gigabytes are becoming common in computational and experimental science. This development is driven by advances in imaging technology, producing detectors with growing resolutions, as well as availability of cheap processing power and memory capacity in commodity-based computing clusters. In this article we describe the design of a visualization system that allows scientists to interactively explore large remote data sets in an efficient and flexible way. The system is broadly applicable and currently used by medical scientists conducting an osteoporosis research project. Human vertebral bodies are scanned using a high resolution micro-CT scanner producing scans of roughly 8 GB size each. All participating research groups require access to the centrally stored data. Due to the rich internal bone structure, scientists need to interactively explore the full dataset at coarse levels, as well as visualize subvolumes of interest at the highest resolution. Our solution is based on HDF5 and GridFTP. When accessing data remotely, the HDF5 data processing pipeline is modified to support efficient retrieval of subvolumes. We reduce the overall latency and optimize throughput by executing high-level operations on the remote side. The GridFTP protocol is used to pass the HDF5 requests to a customized server. The approach takes full advantage of local graphics hardware for rendering. Interactive visualization is accomplished using a background thread to access the datasets stored in a multi-resolution format. A hierarchical volume renderer provides seamless integration of high resolution details with low resolution overviews.

We describe two techniques for rendering isosurfaces in multiresolution volume data so that the uncertainty (error) in the data is shown in the visualization. In general the visualization of uncertainty in data is difficult, but the nature of isosurface rendering makes it amenable to an effective solution. In addition to showing the error in the data used to generate the isosurface, we can also show the value of an additional data variate on the isosurface .

We implement and evaluate a fast ray tracing method for rendering large structured volumes. Input data is compressed into an octree, enabling residency in CPU main memory. We cast packets of coherent rays through a min/max acceleration structure within the octree, employing a slice-based technique to amortize the higher cost of compressed data access. By employing a multiresolution level of detail scheme in conjunction with packets, coherent ray tracing can efficiently render inherently incoherent scenes of complex data. We achieve higher performance with lesser footprint than previous isosurface ray tracers, and deliver large frame buffers, smooth gradient normals and shadows at relatively lesser cost. In this context, we weigh the strengths of coherent ray tracing against those of the conventional single-ray approach.

We present a new framework for managing and rendering large scale time-varying data using the wavelet-based time-space partitioning (WTSP) tree. We utilize the hierarchical TSP tree data structure to capture both spatial and temporal locality and coherence of the underlying time-varying data and exploit the wavelet transform to convert the data into a multiresolution spatio-temporal representation. Coupled with the construction of TSP tree, a twostage wavelet transform process (3D+1D) is applied to the data in the spatial and temporal domains respectively at the preprocessing step. During rendering, the wavelet-compressed data stream is decompressed on-the-fly and rendered using 3D hardware texture mapping. WTSP tree allows random access of data at arbitrary spatial and temporal resolutions at run time. The user is provided with flexible error control of image quality and rendering speed tradeoff. We demonstrate the effectiveness and utility of our framework by rendering gigabytes of time-varying data sets on a single off-theshelf PC.

In this paper, we present an algorithm that accelerates 3D texture-based volume rendering of large, sparse data sets, i.e., data sets where only a fraction of the voxels contain relevant information. In texture-based approaches, the rendering performance is affected by the fill-rate, the size of texture memory, and the texture I/O bandwidth. For sparse data, these limitations can be circumvented by restricting most of the rendering work to the relevant parts of the volume. In order to efficiently enclose the corresponding regions with axis-aligned boxes, we employ a hierarchical data structure, known as an AMR (Adaptive Mesh Refinement) tree. The hierarchy is generated utilizing a clustering algorithm. A good balance is thereby achieved between the size of the enclosed volume, i.e., the amount to render in graphics hardware and the number of axis-aligned regions, i.e., the number of texture coordinates to compute in software. The waste of texture memory by the power-of-two restriction is minimized by a 3D packing algorithm which arranges texture bricks economically in memory. Compared to an octree approach, the rendering performance is significantly increased and less parameter tuning is necessary.