Visualization of high-dimensional, large data sets, resulting from computational simulation, is one of the most challenging fields in scientific viualization. When visualization aims at supporting the analysis of such data sets, feature-based approches are very useful to reduce the amount of data which is shown at each instance of time and guide the user to the most interesting areas of the data. When using feature-based visualization, one of the most difficult questions is how to extract or specify the features. This is mostly done (semi-)automatic up to now. Especially when interactive analysis of the data is the main goal of the visualization, tools supporting interactive specification of features are needed. In this paper we present a framework for flexible and interactive specification of high-dimensional and/or complex features in simulation data. The framework makes use of multiple, linked views from information as well as scientific visualization and is based on a simple and compact feature definition language (FDL). It allows the definition of one or several features, which can be complex and/or hierarchically described by brushing multiple dimensions (using non-binary and composite brushes). The result of the specification is linked to all views, thereby a focus+context style of visualization in 3D is realized. To demonstrate the usage of the specification, as well as the linked tools, applications from flow simulation in the automotive industry are presented. 1.

We present a simple new algorithm that performs fast and memory-efficient cell projection for (exact) rendering of unstructured datasets. The main idea of the "ZSweep" algorithm is very simple; it is based on sweeping the data with a plane parallel to the viewing plane, in order of increasing z, projecting the faces of cells that are incident to vertices as they are encountered by the sweep plane. The efficiency arises from the fact that the algorithm exploits the implicit (approximate) global ordering that the z-ordering of the vertices induces on the cells that are incident on them. The algorithm projects cells by projecting each of their faces, with special care taken to avoid double projection of internal faces and to assure correctness in the projection order. The contribution for each pixel is computed in stages, during the sweep, using a short list of ordered face intersections, which is known to be correct and complete at the instant that each stage of the computation is comple...

Prioritized-Layered Projection (PLP) is a technique for fast rendering of high depth complexity scenes. It works by estimating the visible polygons of a scene from a given viewpoint incrementally, one primitive at a time. It is not a conservative technique, instead PLP is suitable for the computation of partially correct images for use as part of time-critical rendering systems. From a very high level, PLP amounts to a modification of a simple view-frustum culling algorithm, however, it requires the computation of a special occupancy-based tessellation, and the assignment to each cell of the tessellation a solidity value, which is used to compute a special ordering on how primitives get projected. In this paper, we detail the PLP algorithm, its main components and implementation. We also provide experimental evidence of its performance, including results on two types of spatial tessellation (using octree- and Delaunay-based tessellations), and several datasets. We also discu...

Sandia National Laboratories* Projective methods for volume rendering currently represent the best approach for interactive visualization of unstructured data sets. We present a technique for tetrahedral projection using the programmable vertex shaders on current generation commodity graphics cards. The technique is based on Shirley and Tuchman’s Projected Tetrahedra (PT) algorithm and allows tetrahedral elements to be volume scan converted within the graphics processing unit. Our technique requires no pre-processing of the data and no additional data structures. Our initial implementation allows interactive viewing of large unstructured datasets on a desktop personal computer.

Abstract—Harvesting the power of modern graphics hardware to solve the complex problem of real-time rendering of large unstructured meshes is a major research goal in the volume visualization community. While, for regular grids, texture-based techniques are well-suited for current GPUs, the steps necessary for rendering unstructured meshes are not so easily mapped to current hardware. We propose a novel volume rendering technique that simplifies the CPU-based processing and shifts much of the sorting burden to the GPU, where it can be performed more efficiently. Our hardware-assisted visibility sorting algorithm is a hybrid technique that operates in both object-space and image-space. In object-space, the algorithm performs a partial sort of the 3D primitives in preparation for rasterization. The goal of the partial sort is to create a list of primitives that generate fragments in nearly sorted order. In image-space, the fragment stream is incrementally sorted using a fixed-depth sorting network. In our algorithm, the object-space work is performed by the CPU and the fragment-level sorting is done completely on the GPU. A prototype implementation of the algorithm demonstrates that the fragment-level sorting achieves rendering rates of between one and six million tetrahedral cells per second on an ATI Radeon 9800. Index Terms—Volume visualization, graphics processors, visibility sorting. 1

We present a technique for optimizing the rendering of highdepth complexity scenes. Prioritized-Layered Projection (PLP) does this by rendering an estimation of the visible set for each frame. The novelty in our work lies in the fact that we do not explicitly compute visible sets. Instead, our work is based on computing on demand a priority order for the polygons that maximizes the likelihood of rendering visible polygons before occluded ones for any given scene. Given a fixed budget, e.g. time or number of triangles, our rendering algorithm makes sure to render geometry respecting the computed priority. There are two main steps to our technique: (1) an occupancy-based tessellation of space; and (2) a solidity-based traversal algorithm. PLP works by computing an occupancybased tessellation of space, which tends to have smaller cells where there are more geometric primitives, e.g., polygons. In this spatial tessellation, each cell is assigned a solidity value, which is directly proport...

In this paper we propose a technique for resampling scalar fields given on unstructured tetrahedral grids. This technique takes advantage of hardware accelerated polygon rendering and 2D texture mapping and thus avoids any sorting of the tetrahedral elements. Using this technique, we have built a visualization tool that enables us to either resample the data onto arbitrarily sized Cartesian grids, or to directly render the data on a slice-by-slice basis. Since our approach does not rely on any pre-processing of the data, it can be utilized efficiently for the display of time-dependent unstructured grids where geometry as well as topology change over time.

Real-time rendering of large unstructured meshes is a major research goal in the scientific visualization community. While, for regular grids, texture-based techniques are well-suited for current Graphics Processing Units (GPUs), the steps necessary for rendering unstructured meshes are not so easily mapped to current hardware. This paper reviews volume rendering algorithm and techniques for unstructured grids aimed at exploiting high-performance GPUs. We discuss both the algorithms and their implementation details, including major shortcomings of existing approaches. Resumo: A visualização volumétrica de grandes malhas não estruturadas é uma das principais metas da comunidade de visualização científica. Enquanto que em grades regulares o uso de técnicas baseadas em textura são adequadas para as Unidades de Processamento Gráfico (GPUs) atuais, os passos necessários para exibir malhas não estruturas não são diretamente mapeadas para o hardware atual. Este artigo revisa algoritmos e técnicas de visualização volumétrica que exploram GPUs de alta performance. São discutidos tanto os algoritmos como seus detalhes de implementação, incluindo as principais dificuldades das abordagens atuais. 1

Abstract. We present a new architecture for interactive unstructured volume rendering. Our system moves all the computations necessary for order-independent transparency and volume scan conversion from the CPU to the graphics hardware, and it makes a software sorting pass unnecessary. It therefore provides the same advantages for volume data that triangle-processing hardware provides for surfaces. To address a remaining bottleneck – the bandwidth between main memory and the graphics processor – we introduce two new primitives, tetrahedral strips and tetrahedral fans. These primitives allow performance improvements in rendering tetrahedral meshes similar to the improvements triangle strips and fans allow in rendering triangle meshes. We provide new techniques for generating tetrahedral strips that achieve, on the average, strip lengths of 17 on representative datasets. The combined effect of our architecture and new primitives is a 72 to 85 times increase in performance over triangle graphics hardware approaches. These improvements make it possible to use volumetric tetrahedral meshes in interactive applications. 1

. We propose a hardware-assisted visibility ordering algorithm. From a given viewpoint, a (back-to-front) visibility ordering of a set of objects is a partial order on the objects such that if object obstructs object , then precedes in the ordering. Such orderings are useful because they are the building blocks of other rendering algorithms such as direct volume rendering of unstructured grids. The traditional way to compute the visibility order is to build a set of visibility relations (e.g., ), and then run a topological sort on the set of relations to actually get the partial ordering. Our technique instead works by assigning a layer number to each primitive, which directly determines the visibility ordering. Objects that have the same layer number are independent, and can be placed anywhere with respect to each other. We use a simple technique which exploits a combination of the z- and stencil buffers to compute the layer number of each primitive...