Layered depth images

Jonathan ShadeSteven GortlerLi-wei HeRichard Szeliski

article1998SIGGRAPH1,399 citations

Introduces the Layered Depth Image representation to render complex novel views at interactive frame rates by storing multiple depth pixels along each line of sight and using a back-to-front warp ordering that avoids explicit depth sorting.

Listen

Generating new synthetic views of complex three-dimensional scenes typically demands substantial computing power, with processing times scaling sharply as geometric detail and visual richness increase. While image-based rendering techniques aim to accelerate this process by reprojecting existing two-dimensional images rather than recalculating full three-dimensional models, standard approaches suffer from visible rendering gaps, poor handling of occlusions, and severe visual artifacts when viewing angles shift.

The article evaluates and demonstrates two novel image-based rendering techniques designed to achieve interactive, multi-frame-per-second performance on standard personal computers without requiring specialized graphics hardware. The authors introduce Sprites with Depth to render smoothly varying surfaces and Layered Depth Images to handle complex scenes exhibiting high depth variation and occlusion.

To establish these solutions, the authors designed algorithmic pipelines and evaluated them across diverse test cases, including synthetic geometric models, dense ray-traced natural environments, and photographic image sets. For Sprites with Depth, the method forward-maps surface displacement values before applying backward color mapping and planar perspective warps. For Layered Depth Images, multiple depth pixels are stored along single lines of sight from a single camera view and rendered using an adapted back-to-front ordering algorithm combined with efficient pixel splatting, cache-aligned data structures, and view-frustum clipping.

The experimental findings show that these representations deliver substantial performance and efficiency gains. Rendering Sprites with Depth achieved frame rates between 16 and 47 frames per second on a 300 MHz Pentium II processor while eliminating surface rendering gaps. For complex scenes, Layered Depth Images maintained a very low average depth complexity—such as 1.24 layers per pixel in a multi-view test—resulting in only a 24 percent increase in rendering cost relative to single-layer images while sustaining interactive speeds of 8 to 10 frames per second. On a highly complex scene containing over 1.1 million depth pixels, frustum clipping accelerated rendering speeds by a factor of 2 to 4, sustaining 4 to 10 frames per second. Furthermore, packing depth pixel data into 8-byte structures to fit CPU cache lines yielded an immediate 25 percent improvement in rendering throughput.

These results indicate that complex visual scenes can be rendered interactively on commodity hardware without relying on expensive depth-sorting buffers or specialized rendering pipelines. By scaling storage linearly with depth complexity rather than multiplying it by the number of input viewpoints, the approach lowers hardware costs, decreases memory overhead, and broadens the deployment of interactive graphics in resource-constrained environments.

Organizations developing interactive visualization systems should consider adopting Layered Depth Images for complex geometries and Sprites with Depth for smoothly curved surfaces as intermediate primitives within a tiered rendering framework. Future efforts should focus on creating automated pipelines that classify scene components into the most appropriate rendering primitive and developing methods that account for dynamic lighting and view-dependent effects such as specular highlights.

The primary limitations of this approach include potential image degradation caused by multiple resampling stages and reduced spatial resolution for surfaces viewed at glancing angles from the base camera perspective. The sampling and aliasing behaviors under extreme view angles remain not fully formalized, so implementers should exercise caution when viewpoints diverge significantly from the original reference camera.

Harvard University Microsoft Stanford University University of Washington color images digital image frames layered depth images layered depth pixel samples depth map

Shade et al (1998).pdf

Paper: View Interpolation for Image Synthesis, Shenchang Eric Chen et al. (1993). This foundational paper introduces image-based rendering via range-data warping and visibility-ordered compositing, which Layered Depth Images generalizes to handle complex multi-surface occlusions.
Paper: Compositing digital images, Thomas K. Porter et al. (1984). This classic paper establishes the mathematical rules for alpha compositing and back-to-front blending that enable LDI rendering to correctly combine warped layers without a z-buffer.
Paper: Light field rendering, Marc Levoy et al. (1996). This work establishes 4D light field representations for novel view synthesis, providing key conceptual motivation for using compact, depth-augmented image representations to bypass dense spatial sampling.
Paper: The lumigraph, Steven J. Gortler et al. (1996). This paper demonstrates how incorporating geometric depth into image-based rendering improves reconstruction and resampling coherence, directly preceding the layered depth concept.

Paper: High-quality video view interpolation using a layered representation, C. Lawrence Zitnick et al. (2004). This paper extends layered depth representations to interactive dynamic video view interpolation by adding explicit boundary matting and stereo layer segmentation.

Abstract

In this paper we present a set of efficient image based rendering methods capable of rendering multiple frames per second on a PC. The first method warps Sprites with Depth representing smooth surfaces without the gaps found in other techniques. A second method for more general scenes performs warping from an intermediate representation called a Layered Depth Image (LDI). An LDI is a view of the scene from a single input camera view, but with multiple pixels along each line of sight. The size of the representation grows only linearly with the observed depth complexity in the scene. Moreover, because the LDI data are represented in a single image coordinate system, McMillan’s warp ordering algorithm can be successfully adapted. As a result, pixels are drawn in the output image in back-to-front order. No z-buffer is required, so alpha-compositing can be done efficiently without depth sorting. This makes splatting an efficient solution to the resampling problem.

Topics

color images digital image frames high resolution image layered reference image intermediate representations single images viewpoint

Keywords

layered depth images layered depth pixel samples depth map depth sorting depth complexity image warping perspective warp texture mapping LDI camera camera matrix

1 Introduction
2 Previous Work
3 Rendering Sprites
3.1 Sprites with Depth
3.2 Recovering sprites from image sequences
4 Layered Depth Images
4.1 LDIs from Multiple Depth Images
4.2 LDIs from a Modified Ray Tracer
4.3 LDIs from Real Images
5 Rendering Layered Depth Images
5.1 Space Efficient Representation
5.2 Incremental Warping Computation
5.3 Splat Size Computation
5.4 Depth Pixel Representation
5.5 Clipping
6 Results
7 Discussion
Acknowledgments
References

Knowls

Knowl 1 — Layered Depth Image Data Structure
definition
A Layered Depth Image (LDI) is an image-based scene representation defined from a single camera viewpoint where each discrete pixel location in a 2D grid contains an array of depth pixels sorted in front-to-back order along the camera ray line of sight.

Unlike a standard depth image with a single depth value per pixel, an LDI stores multiple depth pixels along the same ray to represent occluded surfaces. The data structures are defined as follows:
- DepthPixel: Contains ColorRGBA (32-bit integer representing red, green, blue, and alpha channels), Z (20-bit integer representing depth), and SplatIndex (11-bit integer indexing a precomputed splat size lookup table based on surface normal and distance).
- LayeredDepthPixel: Contains NumLayers (integer count of depth pixels at this pixel location) and Layers (array or linked list of DepthPixel structures sorted front-to-back).
- LayeredDepthImage: Contains Camera (camera calibration and projection matrices) and Pixels (a 2D array of size $\text{xres} \times \text{yres}$ of LayeredDepthPixel elements).
The memory footprint and rendering cost of an LDI scale linearly with the depth complexity (average number of layers per pixel) of the scene rather than the number of reference images.
Knowl 2 — Incremental Back-to-Front LDI Warping Algorithm
algorithm
The LDI warping algorithm renders novel views from an LDI in back-to-front order without requiring a z-buffer by combining McMillan's list-priority traversal with incremental matrix evaluation across layered depth pixels.

Given the $4 \times 4$ LDI camera matrix $C_1 = V_1 \cdot P_1 \cdot A_1$ and output camera matrix $C_2$ , the coordinate transfer matrix is $T_{1,2} = C_2 \cdot C_1^{-1}$ . The projected output coordinates $(x_2, y_2, z_2, w_2)$ for a pixel $(x_1, y_1)$ at depth $z_1$ satisfy: $T_{1,2} \begin{bmatrix} x_1 \\ y_1 \\ z_1 \\ 1 \end{bmatrix} = T_{1,2} \begin{bmatrix} x_1 \\ y_1 \\ 0 \\ 1 \end{bmatrix} + z_1 \cdot T_{1,2} \begin{bmatrix} 0 \\ 0 \\ 1 \\ 0 \end{bmatrix} = \mathbf{start} + z_1 \cdot \mathbf{depth}$ Advancing along a scanline increments $\mathbf{start}$ by $\mathbf{xincr} = T_{1,2} [1, 0, 0, 0]^T$ .

The input image is split at the epipolar point into up to four quadrants. Each quadrant is traversed in scanline order (moving toward or away from the epipolar point depending on relative camera depth) and depth pixels within each pixel are processed back-to-front.
procedure RenderLDI(ldi, outputCam)
    epipolarPoint = Project(outputCam.center, ldi.camera)
    quadrants = SplitImageAtEpipole(ldi, epipolarPoint)
    for each quadrant in quadrants do
        for each scanline in quadrant according to McMillan order do
            start = ComputeInitialStart(scanline.x0, scanline.y, T12)
            for each pixel (x1, y1) in scanline order do
                for k = ldi.Pixels[x1, y1].NumLayers - 1 down to 0 do
                    dpix = ldi.Pixels[x1, y1].Layers[k]
                    result = start + dpix.Z * depth
                    if result.w > 0 and IsInViewport(result) then
                        x2 = result.x / result.w
                        y2 = result.y / result.w
                        z2 = result.z / result.w
                        sqrtSize = z2 * SplatLookupTable[dpix.SplatIndex]
                        SplatOver(dpix.ColorRGBA, x2, y2, sqrtSize)
                    end if
                end for
                start = start + xincr
            end for
        end for
    end for
end procedure
Knowl 3 — Differential Splat Size Estimation and Lookup Table Approximation
model/method
When reprojecting LDI depth pixels to a new view, the projected footprint area $\text{size}$ of a warped pixel is differentially estimated as: $\text{size} = \frac{(d_1)^2 \cos(\theta_2) \, \text{res}_2 \tan(\text{fov}_1 / 2)}{(d_2)^2 \cos(\theta_1) \, \text{res}_1 \tan(\text{fov}_2 / 2)}$ where $d_1$ and $d_2$ are distances from the surface point to the LDI camera and output camera, $\text{fov}_1$ and $\text{fov}_2$ are the fields of view, $\text{res}_1 = (w_1 h_1)^{-1}$ and $\text{res}_2 = (w_2 h_2)^{-1}$ are the inverse image resolutions, and $\theta_1, \theta_2$ are angles between the surface normal and the respective viewing rays.

Approximating $\theta_1, \theta_2$ by the angles $\phi_1, \phi_2$ relative to the camera optical axes, and approximating $d_2$ by eye-coordinate depth $Z_2$ where $z_2 = 1 / Z_2$ , the splat radius $\sqrt{\text{size}}$ simplifies to: $\sqrt{\text{size}} \approx z_2 \cdot \frac{d_1 \sqrt{\cos(\phi_2) \, \text{res}_2 \tan(\text{fov}_1 / 2)}}{\sqrt{\cos(\phi_1) \, \text{res}_1 \tan(\text{fov}_2 / 2)}} \approx z_2 \cdot \text{lookupTable}[n_x, n_y, d_1]$

The lookup table index uses 11 bits: 5 bits for $d_1$ (quantized nonlinearly using an exponential distribution to allocate higher precision to nearby points), 3 bits for surface normal component $n_x$ , and 3 bits for $n_y$ . The 2048 lookup table entries are precomputed once per output frame from the output camera parameters. Splats use footprints of $1 \times 1$ , $3 \times 3$ , $5 \times 5$ , or $7 \times 7$ pixels with Gaussian-approximating alpha weights rounded to $1$ , $1/2$ , or $1/4$ to allow compositing via integer shifts and adds.
Knowl 4 — Coordinate Transfer Equation for Sprites with Depth
equation
The 2D coordinate mapping between a source pixel $(x_1, y_1)$ with out-of-plane displacement $d_1$ in a reference sprite camera $C_1$ and the corresponding pixel $(x_2, y_2)$ in a target camera $C_2$ is governed by the transfer equation: $\begin{bmatrix} w_2 x_2 \\ w_2 y_2 \\ w_2 \end{bmatrix} = H_{1,2} \begin{bmatrix} x_1 \\ y_1 \\ 1 \end{bmatrix} + d_1 \mathbf{e}_{1,2}$ where:
- $H_{1,2}$ is the $3 \times 3$ planar homography matrix obtained by dropping the third row and third column of the $4 \times 4$ transfer matrix $T_{1,2} = \hat{C}_2 \hat{C}_1^{-1}$ .
- $\hat{C}_1$ is the reference camera matrix modified by replacing its third row with the sprite reference plane equation $[A, B, C, D]$ (with $A^2 + B^2 + C^2 = 1$ ), such that $d_1$ is the scaled perpendicular distance to the plane divided by camera distance $w_1$ .
- $\hat{C}_2$ is the target camera matrix with the third row similarly modified by the plane equation.
- $\mathbf{e}_{1,2} \in \mathbb{R}^3$ is the epipole in the target view, corresponding to the third column of $T_{1,2}$ .
- $(x_2, y_2) = (w_2 x_2 / w_2, w_2 y_2 / w_2)$ are the target pixel coordinates.
Knowl 5 — Two-Step Warping Algorithm for Sprites with Depth
algorithm
Rendering a sprite with depth via standard forward mapping introduces sampling gaps and aliasing. The two-step rendering algorithm decouples parallax displacement from perspective transformation, using a forward warp on the smoothly varying displacement field followed by a backward color resampling pass.
1. Forward Parallax Warp: The scalar displacement map $d_1(x_1, y_1)$ is forward mapped using pure parallax to obtain an intermediate displacement map $d_3(x_3, y_3)$ : $\begin{bmatrix} w_3 x_3 \\ w_3 y_3 \\ w_3 \end{bmatrix} = \begin{bmatrix} x_1 \\ y_1 \\ 1 \end{bmatrix} + d_1(x_1, y_1) \mathbf{e}^*_{1,2}$ where $\mathbf{e}^*_{1,2} = H_{1,2}^{-1} \mathbf{e}_{1,2}$ . Gaps in $d_3(x_3, y_3)$ are filled using local hole filling (e.g., 1 to 3 dilation steps).
2. Combined Backward Color Resampling: For every output pixel $(x_2, y_2)$ in the target image, the intermediate lookup coordinate $(x_3, y_3)$ is obtained via the inverse homography $H_{2,1} = H_{1,2}^{-1}$ : $\begin{bmatrix} w_3 x_3 \\ w_3 y_3 \\ w_3 \end{bmatrix} = H_{2,1} \begin{bmatrix} x_2 \\ y_2 \\ 1 \end{bmatrix}$ The displacement $d_3(x_3, y_3)$ is sampled and used to compute the source sprite coordinate $(x_1, y_1)$ via: $\begin{bmatrix} w_1 x_1 \\ w_1 y_1 \\ w_1 \end{bmatrix} = \begin{bmatrix} w_3 x_3 \\ w_3 y_3 \\ w_3 \end{bmatrix} + d_3(x_3, y_3) \mathbf{e}_{2,1}$ The final color at $(x_2, y_2)$ is sampled from $I_1(x_1, y_1)$ using bilinear interpolation.
To accelerate step 1, an affine parallax approximation can be used by setting the third component of $\mathbf{e}^*_{1,2}$ to 0, eliminating per-pixel division.
Knowl 6 — Stratified Stochastic 4D Ray-Tracing for LDI Construction
model/method
To construct an LDI of a complex synthetic scene that provides adequate sampling across a viewing region without introducing clumping or memory thrashing, rays are cast using a stratified 4D sampling scheme across a bounding viewing cube surrounding the LDI camera center.
1. Ray Parameterization: Each of the six cube faces defines a $90^\circ$ LDI frustum. Ray position is parameterized by uniform coordinates on the cube face. Ray direction is cosine-weighted over the hemisphere by mapping the unit square to the unit disk $(x, y)$ and setting $z = \sqrt{1 - x^2 - y^2}$ .
2. Stratification: The 4D space of ray positions and directions is partitioned uniformly into an $N \times N \times N \times N$ grid of strata (typically $N = 32$ ). For each stratum, $M$ rays (typically $M = 16$ ) are traced, generating approximately 16 million rays per cube face while preserving spatial and directional cache coherence.
3. Insertion and Merging: Each ray-surface intersection inside the frustum is reprojected onto the LDI image plane. If the hit falls within a depth tolerance $\epsilon$ of an existing depth pixel in that ray's layered depth pixel, its color is averaged with the existing depth pixel; otherwise, a new DepthPixel (color, normal, depth) is inserted into the layered depth pixel.
Knowl 7 — Segmented Frustum Clipping for LDIs
model/method
When rendering an LDI from a side viewpoint, intersecting the novel view frustum with the LDI frustum yields a conservative bounding box that spans nearly the entire cross-section of the LDI frustum, causing most depth pixels to be redundantly processed and culled per pixel.

To optimize culling, the LDI frustum is segmented along depth into two stacked sub-frusta:
- A near segment frustum (covering a smaller depth range near the LDI camera).
- A far segment frustum (covering the remaining depth range).
During rendering, the output view frustum is intersected separately with the near and far segment frusta to compute tight individual bounding boxes. The segments are processed in back-to-front order (far segment first, near segment second) to maintain correct visibility and splat ordering. This segmented clipping increases rendering speed by a factor of 2 to 4 on dense datasets.
Knowl 8 — Cache-Optimized Linear Storage for Depth Pixels
model/method
To maximize CPU L2 cache efficiency during rasterization, an LDI is organized at render-time as a packed contiguous linear array without pointer-based per-pixel layer lists:
1. Array Ordering: All depth pixels across the entire LDI are stored in a single linear array sorted by scanline (bottom to top), pixel along scanline (left to right), and ray depth (back to front).
2. Offset Indexing: Two integer offset tables locate pixels:
  - A scanline offset table storing the starting index of each scanline in the linear array.
  - A cumulative per-pixel offset table storing the depth pixel count from the scanline start to each $(x, y)$ position.
3. 8-Byte Packed Depth Pixel: Each depth pixel is compressed into exactly 8 bytes to fit four depth pixels per 32-byte CPU cache line:
  - 32 bits for ColorRGBA (8 bits per channel).
  - 20 bits for integer depth Z.
  - 11 bits for SplatIndex.
  - 1 unused bit.
Packing depth pixels into 8 bytes improves rendering performance by 25% compared to unpacked representations.
Knowl 9 — LDI Construction from Multi-View Depth Images and Voxel Coloring
model/method
LDIs can be constructed from input sources other than ray tracing:
- From Multiple Depth Images: Given $n$ registered depth images from cameras $C_1, \dots, C_n$ , images $C_2, \dots, C_n$ are warped into the reference camera frame $C_1$ . When multiple pixels map to the same $(x_1, y_1)$ LDI location, their depths are compared. If the depth difference exceeds a threshold $\epsilon$ , a new layer is added to the layered depth pixel; if the difference is within $\epsilon$ , the color and depth values are averaged into the existing layer.
- From Uncalibrated Multi-View Photographs: An adaptation of voxel coloring reconstructs an LDI from photograph sequences (e.g., turntable captures). Rays emanating from the LDI center are traversed outward. Candidate voxels along the ray are projected into all input photographs; if all views agree on color consistency, the voxel is inserted as a depth pixel in the LDI structure.
Knowl 10 — Empirical Rendering Performance of LDIs and Sprites with Depth
empirical result
Performance benchmarks measured on a 300 MHz Pentium II PC demonstrate real-time rendering rates:
- Sprites with Depth ( $256 \times 256$ image):
  - Bilinear pixel sampling: 30 Hz for planar homography (no parallax), 21 Hz for single-pass crude parallax (using $d_1$ directly), and 16 Hz for two-pass forward/backward warping.
  - Nearest-neighbor sampling: 47 Hz (no parallax), 24 Hz (single-pass), and 20 Hz (two-pass).
- Barnyard Chicken LDI ( $320 \times 320$ source, $300 \times 300$ output):
  - Constructed in low-priority background thread in ~1 second from 3 nearby views selected out of 17.
  - Average depth complexity is 1.24 layers per pixel (max 10 layers allocated), yielding a rendering overhead of only 24% over a single depth image.
  - Renders interactively at 8 to 10 frames per second.
- Chestnut Tree LDI (Complex Geometry):
  - 1.1 million total depth pixels (70,000 near segment, remainder far segment), generated via 16 million ray samples.
  - Two-segment clipping achieves 4 to 10 frames per second.

Coverage note — None was omitted; all key contributions—including the LDI data structure, rendering algorithms, splat size calculations, clipping optimizations, cache memory packing, sprite with depth mathematical transfer formulations, generation techniques, and experimental benchmarks—have been fully extracted.

References

1.S. Baker, R. Szeliski, and P. Anandan. A Layered Approach to Stereo Reconstruction. In IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR'98). Santa Barbara, June 1998.
2.Shenchang Eric Chen and Lance Williams. View Interpolation for Image Synthesis. In James T. Kajiya, editor, Computer Graphics (SIGGRAPH '93 Proceedings), volume 27, pages 279–288. August 1993.
3.William Dally, Leonard McMillan, Gary Bishop, and Henry Fuchs. The Delta Tree: An Object Centered Approach to Image Based Rendering. AI technical Memo 1604, MIT, 1996.
4.Lucia Darsa, Bruno Costa Silva, and Amitabh Varshney. Navigating Static Environments Using Image-Space Simplification and Morphing. In Proc. 1997 Symposium on Interactive 3D Graphics, pages 25–34. 1997.
5.Paul E. Debevec, Camillo J. Taylor, and Jitendra Malik. Modeling and Rendering Architecture from Photographs: A Hybrid Geometry- and Image-Based Approach. In Holly Rushmeier, editor, SIGGRAPH 96 Conference Proceedings, Annual Conference Series, pages 11–20. ACM SIGGRAPH, Addison Wesley, August 1996.
6.O. Faugeras. Three-dimensional computer vision: A geometric viewpoint. MIT Press, Cambridge, Massachusetts, 1993.
7.Steven J. Gortler, Radek Grzeszczuk, Richard Szeliski, and Michael F. Cohen. The Lumigraph. In Holly Rushmeier, editor, SIGGRAPH 96 Conference Proceedings, Annual Conference Series, pages 43–54. ACM SIGGRAPH, Addison Wesley, August 1996.
8.Paul S. Heckbert. Survey of Texture Mapping. IEEE Computer Graphics and Applications, 6(11):56–67, November 1986.
9.Paul S. Heckbert and Henry P. Moreton. Interpolation for Polygon Texture Mapping and Shading. In David Rogers and Rae Earnshaw, editors, State of the Art in Computer Graphics: Visualization and Modeling, pages 101–111. Springer-Verlag, 1991.
10.Youichi Horry, Ken ichi Anjyo, and Kiyoshi Arai. Tour Into the Picture: Using a Spidery Mesh Interface to Make Animation from a Single Image. In Turner Whitted, editor, SIGGRAPH 97 Conference Proceedings, Annual Conference Series, pages 225–232. ACM SIGGRAPH, Addison Wesley, August 1997.
11.R. Kumar, P. Anandan, and K. Hanna. Direct recovery of shape from multiple views: A parallax based approach. In Twelfth International Conference on Pattern Recognition (ICPR'94), volume A, pages 685–688. IEEE Computer Society Press, Jerusalem, Israel, October 1994.
12.Anthony G. LaMarca. Caches and Algorithms. Ph.D. thesis, University of Washington, 1996.
13.S. Laveau and O. D. Faugeras. 3-D Scene Representation as a Collection of Images. In Twelfth International Conference on Pattern Recognition (ICPR'94), volume A, pages 689–691. IEEE Computer Society Press, Jerusalem, Israel, October 1994.
14.Jed Lengyel and John Snyder. Rendering with Coherent Layers. In Turner Whitted, editor, SIGGRAPH 97 Conference Proceedings, Annual Conference Series, pages 233–242. ACM SIGGRAPH, Addison Wesley, August 1997.
15.Marc Levoy and Pat Hanrahan. Light Field Rendering. In Holly Rushmeier, editor, SIGGRAPH 96 Conference Proceedings, Annual Conference Series, pages 31–42. ACM SIGGRAPH, Addison Wesley, August 1996.
16.Mark Levoy and Turner Whitted. The Use of Points as a Display Primitive. Technical Report 85-022, University of North Carolina, 1985.
17.William R. Mark, Leonard McMilland, and Gary Bishop. Post-Rendering 3D Warping. In Proc. 1997 Symposium on Interactive 3D Graphics, pages 7–16. 1997.
18.Nelson Max. Hierarchical Rendering of Trees from Precomputed Multi-Layer Z-Buffers. In Xavier Pueyo and Peter Schröder, editors, Eurographics Rendering Workshop 1996, pages 165–174. Eurographics, Springer Wein, New York City, NY, June 1996.
19.Leonard McMillan. Computing Visibility Without Depth. Technical Report 95-047, University of North Carolina, 1995.
20.Leonard McMillan. A List-Priority Rendering Algorithm for Redisplaying Projected Surfaces. Technical Report 95-005, University of North Carolina, 1995.
21.Leonard McMillan and Gary Bishop. Plenoptic Modeling: An Image-Based Rendering System. In Robert Cook, editor, SIGGRAPH 95 Conference Proceedings, Annual Conference Series, pages 39–46. ACM SIGGRAPH, Addison Wesley, August 1995.
22.Leonard McMillan and Gary Bishop. Shape as a Pertebation to Projective Mapping. Technical Report 95-046, University of North Carolina, 1995.
23.Don P. Mitchell. personal communication. 1997.
24.Matt Pharr, Craig Kolb, Reid Gershbein, and Pat Hanrahan. Rendering Complex Scenes with Memory-Coherent Ray Tracing. In Turner Whitted, editor, SIGGRAPH 97 Conference Proceedings, Annual Conference Series, pages 101–108. ACM SIGGRAPH, Addison Wesley, August 1997.
25.H. S. Sawhney. 3D Geometry from Planar Parallax. In IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR'94), pages 929–934. IEEE Computer Society, Seattle, Washington, June 1994.
26.Gernot Schaufler and Wolfgang Stürzlinger. A Three-Dimensional Image Cache for Virtual Reality. In Proceedings of Eurographics '96, pages 227–236. August 1996.
27.Mark Segal, Carl Korobkin, Rolf van Widenfelt, Jim Foran, and Paul E. Haeberli. Fast shadows and lighting effects using texture mapping. In Edwin E. Catmull, editor, Computer Graphics (SIGGRAPH '92 Proceedings), volume 26, pages 249–252. July 1992.
28.Steven M. Seitz and Charles R. Dyer. View Morphing: Synthesizing 3D Metamorphoses Using Image Transforms. In Holly Rushmeier, editor, SIGGRAPH 96 Conference Proceedings, Annual Conference Series, pages 21–30. ACM SIGGRAPH, Addison Wesley, August 1996.
29.Steven M. seitz and Charles R. Dyer. Photorealistic Scene Reconstruction by Voxel Coloring. In Proc. Computer Vision and Pattern Recognition Conf., pages 1067–1073. 1997.
30.Jonathan Shade, Dani Lischinski, David Salesin, Tony DeRose, and John Snyder. Hierarchical Image Caching for Accelerated Walkthroughs of Complex Environments. In Holly Rushmeier, editor, SIGGRAPH 96 Conference Proceedings, Annual Conference Series, pages 75–82. ACM SIGGRAPH, Addison Wesley, August 1996.
31.Jay Torborg and Jim Kajiya. Talisman: Commodity Real-time 3D Graphics for the PC. In Holly Rushmeier, editor, SIGGRAPH 96 Conference Proceedings, Annual Conference Series, pages 353–364. ACM SIGGRAPH, Addison Wesley, August 1996.
32.J. Y. A. Wang and E. H. Adelson. Layered Representation for Motion Analysis. In IEEE Computer Society Conference on Computer Vision and Pattern Recognition (CVPR'93), pages 361–366. New York, New York, June 1993.
33.Lee Westover. Footprint Evaluation for Volume Rendering. In Forest Baskett, editor, Computer Graphics (SIGGRAPH '90 Proceedings), volume 24, pages 367–376. August 1990.
34.G. Wolberg. Digital Image Warping. IEEE Computer Society Press, Los Alamitos, California, 1990.

Citation

MLA

Shade, J., et al. “Layered Depth Images”. Proceedings of the 25th Annual Conference on Computer Graphics and Interactive Techniques - SIGGRAPH '98, 1998, pp. 231–42, https://doi.org/10.1145/280814.280882.

APA

Shade, J., Gortler, S., He, L.-. wei ., & Szeliski, R. (1998). Layered depth images. Proceedings of the 25th Annual Conference on Computer Graphics and Interactive Techniques - SIGGRAPH '98, 231–242. https://doi.org/10.1145/280814.280882

Chicago

Shade, J., S. Gortler, L.-. wei . He, and R. Szeliski. 1998. “Layered Depth Images”. Proceedings of the 25th Annual Conference on Computer Graphics and Interactive Techniques - SIGGRAPH '98, 231–42. https://doi.org/10.1145/280814.280882.

Harvard

Shade, J. et al. (1998) “Layered depth images”, Proceedings of the 25th annual conference on Computer graphics and interactive techniques - SIGGRAPH '98. ACM Press, pp. 231–242. Available at: https://doi.org/10.1145/280814.280882.

Vancouver

1. Shade J, Gortler S, He L-wei, Szeliski R (1998) Layered depth images. In: Proceedings of the 25th annual conference on Computer graphics and interactive techniques - SIGGRAPH '98. ACM Press, pp 231–242

BibTeX

@inproceedings{Shade_1998, series={SIGGRAPH ’98}, title={Layered depth images}, url={http://dx.doi.org/10.1145/280814.280882}, DOI={10.1145/280814.280882}, booktitle={Proceedings of the 25th annual conference on Computer graphics and interactive techniques  - SIGGRAPH ’98}, publisher={ACM Press}, author={Shade, Jonathan and Gortler, Steven and He, Li-wei and Szeliski, Richard}, year={1998}, pages={231–242}, collection={SIGGRAPH ’98} }

Metadata:Crossref

Access the Paper

This paper is available from its original source. Click below to access the PDF.

Open PDF

Layered depth images

Abstract

Topics

Keywords

Table of Contents

Knowls

Knowl 1 — Layered Depth Image Data Structure

Knowl 2 — Incremental Back-to-Front LDI Warping Algorithm

Knowl 3 — Differential Splat Size Estimation and Lookup Table Approximation

Knowl 4 — Coordinate Transfer Equation for Sprites with Depth

Knowl 5 — Two-Step Warping Algorithm for Sprites with Depth

Knowl 6 — Stratified Stochastic 4D Ray-Tracing for LDI Construction

Knowl 7 — Segmented Frustum Clipping for LDIs

Knowl 8 — Cache-Optimized Linear Storage for Depth Pixels

Knowl 9 — LDI Construction from Multi-View Depth Images and Voxel Coloring

Knowl 10 — Empirical Rendering Performance of LDIs and Sprites with Depth

References

Citation

BibTeX

Access the Paper