Loading in 5 sec....

Hardware-Assisted Visibility Sorting for Tetrahedral Volume RenderingPowerPoint Presentation

Hardware-Assisted Visibility Sorting for Tetrahedral Volume Rendering

- By
**neona** - Follow User

- 128 Views
- Uploaded on

Download Presentation
## PowerPoint Slideshow about 'Hardware-Assisted Visibility Sorting for Tetrahedral Volume Rendering' - neona

**An Image/Link below is provided (as is) to download presentation**

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -

Presentation Transcript

Hardware-Assisted Visibility Sortingfor Tetrahedral Volume Rendering

Steven Callahan Milan Ikits

João Comba Cláudio Silva

Overview

- Introduction
- Previous Work
- Hardware-Assisted Visibility Sorting
- Results
- Future Work
- Conclusion

Research Goal

- Real-time volume rendering
- Scalable (machine performance)
- Data of arbitrary size
- Simple and robust implementations

Why Irregular Grids ?

Unstructured grids are the preferred data type in scientific computations

Level-Of-Detail (LOD) techniques intrinsically need unstructured grids

El-Sana et al, Ben-Gurion

Volume Rendering: (Intersection) Sampling + Sorting

Sampling: Triangle-Based Approach

Class 1 (+, +, +, -)

Class 2 (+, +, -, -)

Projected Tetrahedra [Shirley-Tuchman 1990]

Sorting

Application

Object-Space

Sorting

i.e., let’s sort the geometry!

Rasterization

Image Space

Display

Object-Space Sorting: Williams’ MPVO

B < A

A < C

B < E

C < E

C < D

E < F

D < F

Idea: Define ordering relations

by looking at shared faces.

D

A

C

F

B

E

Viewing direction

MPVO Limitations

Missing relations!

XMPVO

A < C

B < D

Idea: Using ray shooting queries to complement ordering relations.

C

D

A

B

A < B

Viewing direction

Sorting

Application

Object Space

Rasterization

Image-Space

Sorting

Display

i.e., let’s sort the pixels!

Cell-Projection With An A-Buffer

Not sorted!

Cell-Projection With An A-Buffer

Sorted!

A-Buffer Limitations

2

Number of Intersections: O(cn )

n x n pixels

c cells

- Problems
- Time: sorting takes too long
- Memory: storage too high

Approximate Object-Space Sorting

What about the space problem?

3

7

5

6

1

4

2

Use a conservative bound on the intersections

Hardware Assisted Visibility Sorting (HAVS)

- Sort in image-space and object-space
- Do an approximate object-space sorting of the cells on the CPU (i.e. sort by face centroid)
- Complete the sort in image-space by using a fixed depth A-buffer (called a k-buffer) implemented on the GPU
- Can handle non-convex meshes, has a low memory overhead, and requires minimal pre-processing of data

k-buffer

- Fixed size A-buffer of depth k
- Fragment stream sorter
- Stores k entries for each pixel. Each entry consists of the fragment’s scalar value and its distance to the viewpoint
- An incoming fragment replaces the entry that is closest to the eye (front-to-back compositing)
- Given a sequence of fragments such that each fragment is within k positions from its position is sorted order, it will output the fragments in sorted order

k-buffer: Hardware Implementation

r

a

b

g

g comp

r comp

b comp

a comp

v1

v2

d2

d1

v3

d4

d3

v4

d5

v6

v5

d6

- Use multiple render target capability of ATI graphics cards (ATI_draw_buffers in OpenGL)
- Use P-buffer to accumulate color and opacity and three Aux buffers for the k-buffer entries

P-buffer

Aux 0

Aux 1

Aux 2

Details

- Fix incorrect screen-space texture coordinates caused by perspective-correct interpolation

Projecting vertices to find tex coords

Projecting tex coords in shader

Perspective interpolation

Details

- Simultaneously reading and writing to a buffer is undefined when fragments are rasterized in parallel

Details

- The buffers are initialized and flushed using k screen-aligned rectangles with negative scalar values
- Handling non-convex objects requires the exterior faces to be tagged with a negative distance d and keeping track of when we are inside or outside of the mesh with the sign of the scalar value v

Details

- Early ray termination reads accumulated opacity and kills fragment if it is over a given threshold. Early z-test is currently not available on ATI 9800 when using multiple rendering targets

Pre-Integrated Transfer Function

- Previous Work
- Volume density optical model
- Williams and Max 1992

- Pre-integration on GPU
- Roettger et al. 2000
- 5 s to update a 128x128x128 table

- Incremental pre-integration on CPU
- Wieler et al. 2003
- 1.5 s to update a 128x128x128 table

- Volume density optical model

Pre-Integrated Transfer Function

- Our Approach
- Incremental pre-integration of the 3D transfer function completely on the GPU
- Compute base slice using [Roettger et al.]
- Compute the other slices using the base slice and the previously computed slice [Weiler et al.]

- 0.067 s to update a 128x128x128 table
- This allows interactive updates to the colormap and transfer function opacity

- Incremental pre-integration of the 3D transfer function completely on the GPU

Experiments

- Environment
- 3.0 GHz Pentium 4
- 1024 MB RAM
- Windows XP
- ATI Radeon 9800 Pro

- Results
- k-buffer analysis
- Performance results

K-buffer Analysis

- Accuracy analysis
- Analysis of k depth required to correctly render datasets
- Max values from 14 fixed viewpoints

k-buffer Analysis

- Distribution analysis
- Shows actual pixels that require large k depths to render correctly for each viewpoint

k <= 2 (green) 2 < k <= 6 (yellow) k > 6 (red)

Results

- Performance
- Average values from 14 fixed viewpoints
- Does not include partial sort on CPU
- 512 x 512 viewport with a 128 x 128 x 128 pre-integrated transfer function

Future Work

- Optimize partial sort on CPU
- Develop techniques to refine datasets to respect a given k (subdivide degenerate tets)
- Incorporate isosurface rendering
- Parallel techniques
- Proper hole handling
- Dynamic data
- Use early z-test

Conclusion

- Renders up to 6 million Tets/sec when using a linear transfer function
- Handles arbitrary non-convex meshes
- Requires minimal pre-processing of data
- Maximum data size is bounded by main memory
- Uses simple vertex and fragment shaders

Download Presentation

Connecting to Server..