Efficient LDI Representation TPCG 2008

Slide1: 

Matthias Trapp, Jürgen Döllner Hasso-Plattner-Institute, University of Potsdam, Germany 9th June 2008 University of Manchester Efficient Representation of Layered Depth Images for Real-time Volumetric Tests

Motivation: Volumetric Tests: 

Motivation: Volumetric Tests …determine if a 3D point is inside or outside a given volume Areas of application: Generalized clipping, Rendering with hybrid styles, 3D magic lenses,… Characteristics: Volume representation = LDI Test performed in shader program Applicable in real-time

LDI Representation of Solid Meshes: 

LDI Representation of Solid Meshes

Depth-Peeling to 3D Textures: 

Depth-Peeling to 3D Textures Algorithm for LDI creation: Setup orthographic projection, adjust near/far planes Determine depth complexity of shape Create and initialize 3D texture (LDI) Depth-peel shape: Render-to-texture (into slice of 3D texture) Use linear depth buffer values GLSL fragment shader for 2nd depth test (SM4)

Volumetric Parity Test (VPT) Algorithm: 

Volumetric Parity Test (VPT) Algorithm “to determine if a point is inside or outside a complex 3D volume represented by an LDI” Given: arbitrary 3D point: Requested: Boolean parity: Solution: Transformation into LDI texture space: Perform ray-marching through depth maps

Ray-Marching through LDI Texture Space: 

Ray-Marching through LDI Texture Space Algorithm: Construct ray R: Sample form each slice: Compare depth values:

Shader Implementation (GLSL): 

Shader Implementation (GLSL)

Limitations of Current Representation: 

Limitations of Current Representation Memory Consumptions: 3D texture size: resolution2 * d Usually sparsely utilized Depth-Peeling Performance: Depends on depth complexity of shape Ray-Marching Performance: Depends on number of texture samples So far: d samples per ray necessary Goals: Minimal texture size: Cropping, Compression Minimal peeling passes: Viewpoint Selection Minimal texture samples per test: Compression

Outline – Next Topics: 

Outline – Next Topics Preprocessing Pipeline: Overview Viewpoint Selection Bounding Box Calculation & Cropping LDI Compression Algorithm Performance Results Limitations & Future Work Conclusions

Preprocessing Pipeline: Overview: 

Preprocessing Pipeline: Overview 5 Step process involves GPU and CPU: Viewpoint selection (ODP ) Depth-peeling to 3D texture (LDI) Calculate axis-aligned bounding box (AABBLDI ) Perform cropping (LDICrop ) Compress cropped texture (LDIComp )

Viewpoint Selection: 

Viewpoint Selection Find viewpoint for LDI creation based on: Minimal depth complexity: d Maximal texture coverage: o Determine camera orientation Altering viewpoint on bounding sphere Determine and store in list : Depth complexity Altered camera orientation Texture coverage Sort list to obtain result

Bounding Box Calculation & Cropping: 

Bounding Box Calculation & Cropping

Compressing Depth Ranges: 

Compressing Depth Ranges Depth Ranges: Group depth values: di = 0,…,d-1 DRj = (Sj,Ej ), j = 0,…,d/2 Interval [Sj, Ej ], Sj = d2j , Ej = d 2j+1 denotes inside of volume Lossless Compression Idea: Sequential align all depth ranges of a Ray R Fetch start (Sj ) and end (Sj ) with single instruction

Compression Algorithm – Overview : 

Compression Algorithm – Overview Two-phase process: Extract depth ranges from 3D texture into intermediate representation Pack depth ranges from intermediate representation into 2D texture

Compression - Extract Phase: 

Compression - Extract Phase Create intermediate representation: Prepare data structure for pack phase Read-back LDI from GPU Create 4 arrays from LDI: Index Segments (ISoffset, ISranges ) Range Segments (RSstart , RSend)

Compression - Pack Phase: 

Compression - Pack Phase Pack arrays into 2D texture Texture format: Luminance-Alpha Float point precision: unclamped values Texture resolution: Store successively: ISoffset , RSstart in luminance channel ISranges , RSend in alpha channel Issues: 2D texture format introduces unwrapping step in decompression Better: 1D texture, but resolution limited to 8192 pixel Possible Solution: Uniform Buffer (NVIDIA G80) + Geometry Shader

VPT for Compressed LDI: 

VPT for Compressed LDI

Performance Results: 

Performance Results

Limitations & Future Work: 

Limitations & Future Work Limitations: Specific approach for depth ranges Too much instruction for decompression Small compression ratio 1:2-3 GPU & CPU (hybrid) approach Future Work: Toward a complete GPU implementation: (Bounding box calculation, cropping, compression) Main Goal: enable preprocessing in real-time New filtering concepts necessary to compensate undersampling / alaising artefacts

Conclusions: 

Conclusions Efficient LDI Representation trough: Automatic viewpoint selection Fast bounding box calculation & cropping Lossless LDI compression Decompression algorithm applicable in shader Compression Characteristics: Ratio 1:2-3 (common for lossless compression) Effective for non-convex meshes with high depth complexity Compression should be avoided for symmetric convex meshes Preprocessing, no real-time performance Future Work: Implementation fully GPU-based

Questions ?: 

Questions ? Contact: Matthias Trapp matthias.trapp@hpi.uni-potsdam.de Computer Graphics Systems Group Prof. Dr. Jürgen Döllner www.hpi.uni-potsdam.de/3d Researchgroup 3D-Geoinformation www.3dgi.de