P REGUNTAS DE R ESPUESTA O RAL EN P LENO

Even though the focus in this chapter is on the interactive visualization of scien- tific data sets, the hybrid visualization technique is not restricted to that. The basic concept also fits for gaming applications. Many games visualize player mod- els that are dynamically moving through a mostly static environment. Highly complex static environments may be ray cast instead of rasterized. This frees resources from the graphics card, which may be used to visualize more complex player models.

In the setup described here three rasterization passes are used, where two passes are needed for rendering the scene once in shadow and once not. High end graphics card do support multiple render targets. The two images could be written in one pass, discarding one rasterization pass.

Implicit kd-trees

3.1

Abstract

New implicit kd-trees are introduced here. They have fast construction times, low memory requirements, and allow on today’s desktop computers interactive iso surface ray casting and maximum intensity projection (MIP) of data sets that are larger than one half of the machine’s given main memory. Iso surface, clip planes, colors and the visualization technique (iso surfacing with or without shadows, MIP) can be changed interactively, since they all are computed on the fly. Due to the logarithmic dependency between visualization time and scene size it is possible to visualize even massively complex data sets at interactive framerates.

3.2

Problem

Many scientific data sets are scalar fields S ∈ R3 _{(∈ R}4_{) (e.g., CT- and MRI-}

scans, seismic- and CFD data sets) which are often given as 3D (or 4D: 3D + time) rectilinear grids with dimensions dimx, dimy, dimz(, dimt) discrete values

si,j,k(,u) and grid planes px(i), py(j), pz(k) (and times t(u)). These data sets are

often massively complex and are steadily increasing in size.

Iso surface ray tracing and MIP accelerated through min/max kd-trees have a logarithmic dependency between visualization time and scene size, making them

ideal techniques for the visualization of massively complex scalar fields. But explicitly stored kd-trees require a multiple of the original data set’s memory which strongly decreases the maximal possible size of a data set that can be rendered at interactive framerates.

3.3

State of the Art

This section’s focus is on software based visualization methods, which achieve in- teractive framerates for at least medium sized data sets (5123 _{voxels) on standard}

desktop machines.

Interactive iso surface raytracing (and MIP) for large regular scalar fields through software has first been achieved by Parker et al. (38) ((39)) by a brute- force implementation on a high end (distributed) shared-memory multiprocessor system. DeMarle et al. ported this system to run on PC clusters (9), (8). A major step forward to interactive iso surface ray tracing on desktop machines has recently been achieved by Wald et al. (50), where for each scalar field a min/max kd-tree is constructed, which is used to accelerate ray traversal of regions not containing an iso surface.

The results of Wald et al.’s work show that state of the art shared memory desktop machines are able to visualize large data sets at fairly interactive frame rates. But their min/max kd-trees have the drawbacks of being at least twice (and up to 16 times) as large as the scalar field itself, which is a too strong memory overhead for the visualization of large data sets.

Interactive high-quality MIP through software on desktop machines has first been achieved by Mroz et al. (32). Mora et al. recently implemented a fast object order ray casting algorithm (31), (30). Mora et al. also proved mathemat- ically that MIP through image order ray tracing has for discretized gray levels an average visualization time of order O(lg(n)) (30). For accelerating empty space skipping Mora et al. used octrees similar to Wald et al.’s min/max kd- trees, with the major difference that Mora et al.’s trees did also store leaf nodes, which therefore have a memory overhead of more than twice the scalar field’s size. They also tried to implement an image order ray casting algorithm, but stated: ”This result was not sufficient to get interactive rendering rates” without

supplying any framerates. Both MIP visualization techniques are fairly interac- tive for medium sized data sets. But both visualization techniques have memory overheads of more than twice the data’s size, and a visualization time of at least order O(n2/3_{). They are therefore unsuited for visualizing large data sets. Both}

visualization techniques are furthermore tied to parallel projection and do not support perspective projection.

3.4

Results

The different contributions of this chapter are:

• A new and very general definition for implicit kd-trees together with their construction and traversal algorithms is introduced.

• Corresponding implicit bit, bitmask, and min/max kd-trees are defined. • An efficient memory reduction scheme for (implicit) min/max kd-trees is

introduced. The resulting optimized implicit min/max or max kd-trees require as much resp. half as much memory as the original scalar field. • Besides the fact that optimized implicit max kd-trees may be used for ac-

celerated semi iso surfacing, it is shown that those trees may also be used for accelerating maximum intensity projection.

• It is shown that the visualization time using implicit kd-trees is comparable to the visualization times using explicit kd-trees.

• It is shown that the construction of implicit kd-trees is linear, scales linear to the amount of processor cores used, and is fairly fast.