Appears in the ACM SIGGRAPH 2003 conference proceedings

Combining Edges and Points for Interactive High-Quality Rendering

Kavita Bala∗Computer Science Department

Cornell University

Bruce WalterProgram of Computer Graphics

Cornell University

Donald P. GreenbergProgram of Computer Graphics

Cornell University

AbstractThis paper presents a new interactive rendering and display tech-nique for complex scenes with expensive shading, such as globalillumination. Our approach combines sparsely sampled shading(points) and analytically computed discontinuities (edges) to inter-actively generate high-quality images. Theedge-and-point image isa new compact representation that combines edges and points suchthat fast, table-driven interpolation of pixel shading from nearbypoint samples is possible, while respecting discontinuities.

The edge-and-point renderer is extensible, permitting the use ofarbitrary shaders to collect shading samples. Shading discontinu-ities, such as silhouettes and shadow edges, are found at interactiverates. Our software implementation supports interactive navigationand object manipulation in scenes that include expensive lightingeffects (such as global illumination) and geometrically complex ob-jects. For interactive rendering we show that high-quality images ofthese scenes can be rendered at 8–14 frames per second on a desk-top PC: a speedup of 20–60 over a ray tracer computing a singlesample per pixel.

CR Categories: I.3.7 [Three-Dimensional Graphics and Realism]:Raytracing; I.3.3 [Picture/Image Generation]: Display algorithms

Keywords: interactive software rendering, sparse sampling andreconstruction, silhouette and shadow edges

1 IntroductionThis paper presentsedge-and-point rendering, a new rendering anddisplay technique that can generate high-quality images of complexscenes at interactive rates. It targets expensive effects such as globalillumination, where pixel shading is too slow for interactive use. Inthis context, sparse sampling of shading is essential for interactiverendering, and a number of systems have tried to accelerate render-ing through sparse sampling and reconstruction (see Section 2). Inthe absence of shading discontinuities, sparse samples can be ef-fectively interpolated to produce good images. However, interpola-tion across discontinuities results in visually objectionable blurring.This paper shows that analytically computed discontinuities can becombined with sparse shading samples to produce high-quality im-ages at interactive rates.

Edge-and-Point Image. Figure 1 illustrates how edge-and-point rendering works. A novel intermediate display representa-tion called theedge-and-point image (EPI) supports the new ren-

∗email: kb@cs.cornell.edu, bjw@graphics.cornell.edu

camera/object updates

sparse

points

Edge-and-Point Image

Output Image

Edge-constrained interpolation

edges

Figure 1: Edge-and-point rendering for the dragon with grid (∼871K polygons). After 3D edges and points are found, they areprojected and combined into the edge-and-point image. The outputimage is computed by interpolating point samples, while respectingdiscontinuity edges. On the left a 5×5 neighborhood of pixels fromthe EPI is depicted. To reconstruct the center pixel, the blue samplesare interpolated, while the unreachable gray samples are ignored.

dering process. Discontinuity edges and point samples are com-bined and stored with subpixel precision in the pixels of the EPI.Shading for each pixel is reconstructed by interpolating betweennearby samples while obeying anedge-respecting invariant: in-terpolation is only performed using samples that are not separatedfrom the pixel by a discontinuity. This invariant prevents the incor-rect blurring produced by many sparse sampling and reconstructionalgorithms. The explicit representation of discontinuities also en-ables anti-aliasing without supersampling. Interactive performanceis achieved because the compact EPI representation permits fast,simple, table-driven interpolation and anti-aliasing.

The two most important shading discontinuities are typically ge-ometric discontinuities, such as silhouettes, and shadow disconti-nuities. Our system analytically finds these discontinuities usingefficient algorithms and data structures. Sparse shading samplesare computed similar to the Render Cache [Walter et al. 1999].Because edge-and-point rendering decouples shading from imagereconstruction our implementation is flexible and can work withmany different types of shaders, e.g., shaders for ray-traced glossyreflections and global illumination.

1

Appears in the ACM SIGGRAPH 2003 conference proceedings

Using the edge-and-point renderer, the user can navigate andmanipulate objects in complex scenes while obtaining high-qualityrendering feedback at interactive rates (8–14 frames per second ona desktop machine). The system collects samples for only 1–3% ofthe image pixels for any given frame, while reusing samples fromframe to frame when possible.

2 Related WorkSparse sampling and reconstruction. Several approaches adap-tively sample and reconstruct smoothly varying shading. [Guo1998] proposes a progressive technique that samples the imageplane and tries to detect discontinuities. This system samples alonghypothesized discontinuities and interpolates shading using thesesamples. The radiance interpolant system [Bala et al. 1999b] sam-ples radiance in 4D ray space driven by conservative error analy-sis. Ray space is subdivided around discontinuities and radiance isinterpolated where it varies smoothly. Both these approaches usesampling to detect discontinuities, thus requiring sampling patternsand densities that are difficult to maintain in an interactive context.

A progressive previewing technique that uses hardware to de-tect visibility and hard shadow edges in static scenes is presentedin [Pighin et al. 1997]. A constrained Delaunay triangulation ofsparse samples is used to reconstruct images. While this is an inter-esting approach, it is likely to be too expensive for the interactiverendering of complex scenes. Tapestry [Simmons and S´equin 2000]sparsely samples the scene and meshes samples using a Delaunaytriangulation. Since this mesh is not in image space, it can be usedas the viewpoint changes. Because this system does not try to detectdiscontinuities, it blurs edges.

The Render Cache [Walter et al. 1999] reprojects cached pointsamples from frame to frame. Interactive performance is achievedby interpolating available samples, but results tend to be blurrysince no knowledge of edges exists. We have adapted the RenderCache for the point-based part of our algorithm.

The Shading Cache [Tole et al. 2002] displays scenes with ex-pensive global illumination by interpolating sparse shading sam-ples using graphics hardware. Because this technique requires atleast one sample per visible polygon, it is too expensive for the ge-ometrically complex scenes rendered in this paper.

Interactive ray tracing has become an active area of re-search [Parker et al. 1999; Wald et al. 2001]. The edge-and-pointrenderer is complementary to these approaches. Wald et al. [Waldet al. 2002] use fast distributed ray tracing and filtering to reduceimage noise in parallel Monte Carlo simulations. A simple heuris-tic based on pixel depths and normals tries to detect discontinuitiesand avoid blurring over them.Discontinuity meshing. The literature on finding discontinuities isextensive; visibility and shadow detection research is summarizedin [Durand 1999]. Several approaches have tried to find all visibil-ity events [Drettakis and Fiume 1994; Duguet and Drettakis 2002;Durand et al. 1997; Heckbert 1992; Lischinski et al. 1992]. How-ever, the enumeration of all discontinuities is typically too slow forinteractive use. Discontinuity meshing [Heckbert 1992; Lischin-ski et al. 1992] tesselates scenes based on radiosity discontinuities.Because it remeshes geometry around discontinuities, it often cre-ates very large meshes with tiny mesh elements of poor aspect ra-tio. Our technique directly projects discontinuities onto the imageplane, avoiding the need to construct a mesh.Complexity. Recent efforts in 3D scanning have created massivedata sets [Levoy et al. 2000; Rushmeier et al. 1998]. Point-basedapproaches [Pfister et al. 2000; Rusinkiewicz and Levoy 2000;Wand et al. 2001; Zwicker et al. 2001] suggest an alternative repre-sentation for the interactive display of these very large data sets. Be-cause they use precomputed sampling, these techniques are mainlyuseful for the display of static scenes. None of these approaches

3D Shading SamplesEdge Finder

cameraobject updates

Edge-and-Point Image

request samples

Output Image

Visible Objects(Light,Blocker,Receiver)

Shader

ReachabilityInterpolationAnti-Aliasing

Edge Rasterizerand Occlusion Culling

3D edges

2D discretized edges

Point Reprojection

3D point samples

asynchronoussynchronous

filtered depth

2D discretized points

edge-and-point renderer shader

Figure 2: An overview of the edge-and-point rendering system.

try to support expensive illumination effects such as shadows andglobal illumination.

Silhouette clipping [Sander et al. 2000] was proposed for the in-teractive viewing of complex objects with distinct silhouettes thatwould not be effectively represented by point-based approaches.It introduces cone-based hierarchical techniques to find silhou-ettes. A further extension uses hardware to anti-alias silhouetteedges [Sander et al. 2001]. However, these systems are aimed at theinteractive viewing of stand-alone objects and do not render sceneswith expensive shading effects. [Johnson and Cohen 2001] extendsthe above cone-based data structure for a different application: lo-cal minimum distance computation. For a simple scene consistingof two smooth surfaces, a sphere and a torus, they also demonstratethe ability to compute shadow events, though these events are notused to compute shadow edges or used by a rendering system.

3 System OverviewFigure 2 shows an overview of our system. The system consists oftwo processes: the edge-and-point renderer and an external shaderprocess. The shader asynchronously finds visible points and com-putes their color. These 3D point samples are cached and repro-jected onto the image plane for each frame [Walter et al. 1999].

For each frame, theedge finder rapidly finds silhouettes andshadow edges for each visible object using hierarchical interval-based trees (Section 6). Theedge rasterizer rasterizes these 3Dedges, representing them to subpixel precision. Additionally, depthinformation from the reprojected point samples is used to performconservative occlusion culling of the edges.

Both edges and point samples, represented at subpixel precision,are combined to form the edge-and-point image (Section 4). Thiscompact representation discretizes positional information, enablingfast, high-quality interpolation of shading values using table-drivenfiltering algorithms (Section 5). These algorithms includereacha-bility determination, which identifies the samples that are not sepa-rated by a discontinuity edge;interpolation, which reconstructs thepixel’s shading using the computed reachability; andanti-aliasing.

Feedback from interpolation is used to decide where new pointsamples are needed and these requests are passed to the externalshader. In addition to asynchronously computing shading samples,the shader also sends information to the edge finder about currentlyvisible objects and shadows. This flexible architecture decouplesthe shader process from the edge-and-point renderer. Thus, almostany shader can be used to compute samples and visibility.

2

Appears in the ACM SIGGRAPH 2003 conference proceedings

4 Edge-and-Point ImageThe edge-and-point image (EPI) is the key intermediate display rep-resentation in the edge-and-point renderer. First, edges and shadedpoints are rasterized into the EPI. Each pixel in the EPI now con-tains its classification, including approximate edge location, if any,and the closest point, if any, that reprojected onto it. This producesa compact regular data structure whose size is independent of scenecomplexity. This representation allows fast image reconstruction.This section describes the EPI data structure and how it is com-puted for each frame.

4.1 Pixel classification

When the 3D edges from the edge finder are projected onto theimage plane, they can vary in length from a fraction of a pixel tohundreds of pixels. Moreover, a single pixel may contain manyedges or none. This edge information needs to be transformed intoa compact regular format for rapid pixel processing. Therefore, pix-els in the edge-and-point image are classified as empty, simple, orcomplex. Figure 3 shows examples of simple and complex pixels.

Empty ComplexSimple

Figure 3: Examples of pixel classifications.

• Empty: A pixel with no edges is empty.

• Simple: A pixel is simple if the edge(s) through the pixel canbe approximated well by a single edge spanning the pixel.

• Complex: Pixels that are neither empty nor simple are con-sidered complex.

Most pixels are empty or simple. Our system reconstructs shadingfor simple pixels at the same cost as empty pixels as described inSection 5. Identification of simple pixels also permits anti-aliasingfor higher image quality. Additionally, the ability to identify com-plex pixels allows us to concentrate more effort where needed.

4.2 Edge representation

For a simple pixel, its edge is approximated by locating its end-points on the pixel boundary to eighth-of-a-pixel accuracy. Thepixel boundary is subdivided into 32 segments (8 on each side) asshown in Figure 4 and the approximated edge is represented by 10bits (5 bits for each end point). The approximated edge is not al-lowed to have both endpoints on the same side of the pixel; two ofthese disallowed combinations are used to encode empty and com-plex pixels. This subpixel precision is sufficient to permit goodanti-aliasing while compactly encoding edges, thus, allowing fastedge-related operations using table lookups.

pixel

Figure 4: A single pixel crossed by an edge. Each side is dividedinto 8 segments and the interior into 16 regions. An edge dividesthe pixel into primary (blue) and secondary (pink) regions. Thecross-hatched regions are classified as edge-ambiguous.

3x3 neighborhood of pixels

boundary intersectionsedges discretized edges

simple complexempty

Figure 5: Edge rasterization for a 3× 3 pixel neighborhood. 3Dedge segments are shown delimited by points on the left. Theseedges are rasterized to compute their discretized intersections withpixel boundaries, shown in purple (middle). Pixels are classifiedfrom the boundary intersections as either empty (white), simple(green), or complex (cross-hatched pink), shown on the right. Forsimple pixels, an approximated edge is reconstructed.

4.3 Point representation

The EPI also compactly records information about shading sam-ples. Each pixel is divided into 16 interior regions as shown in Fig-ure 4. For each sample we record which subpixel region it lies in,requiring 4 bits per sample. Because both edges and points are rep-resented with limited accuracy, it cannot always be determined onwhich side of an edge a point sample lies. Such samples are callededge-ambiguous and cannot be used for edge-respecting interpo-lation. For simple pixels, table lookups are used with the edge’s10-bit encoding and the sample’s 4-bit subpixel position to deter-mine on which side of the edge the sample lies, or if the sample isedge-ambiguous.

Point processing. Point processing in the edge-and-point ren-derer is based on the Render Cache [Walter et al. 1999; Walter et al.2002]. Point samples are produced by an external shading processthat computes the color and first point of intersection for a view-ing ray. The Render Cache manages a fixed-sized cache of recentshading samples, which are stored as colored points in 3D. For eachframe, the cached points are reprojected using the current cameraparameters, filtered to reduce occlusion errors, and interpolated tofill in small gaps between reprojected samples.

4.4 EPI pixels

Each pixel of the EPI includes at most one discretized edge and onepoint sample. Thus, the EPI size depends only on image resolutionand is independent of scene complexity. A pixel in the edge-and-point image uses 10 bytes of storage: 10 bits for edge encoding, 4bits for sample subpixel location, 24 bits for sample color, and 36bits for other Render Cache data.

4.5 Constructing the edge-and-point image

The first step of EPI construction is edge rasterization. Edges arerasterized by recording their intersections (shown in purple in Fig-ure 5) with all pixel boundaries. This can be done quickly, becauseit is equivalent to recording the edges’ intersections with regularlyspaced parallel horizontal and vertical lines. Each pixel boundarysegment is divided into 8 pieces and its intersections are stored inan 8-bit mask; since neighboring pixels share intersections, only 16bits per pixel are needed to store the intersections.

Eliminating occluded edges makes interpolation more effective.Since points approximate the visible surfaces, depth informationfrom point reprojection can be used to cull occluded edges. How-ever, points and edges do not exactly coincide and there are gaps inthe point data, so the depth buffer must be filtered first. We com-pute a fairly conservative depth buffer by using the maximum depthvalue in a 4×4 neighborhood and adding an additional offset thatdepends on the local point density. These filtered depths are used

3

Appears in the ACM SIGGRAPH 2003 conference proceedings

1

1

1

1

1

1

1

1

1

1

1

1

1

1

1

32

8

8

88

4

44

4

1 11

1 1 1

reachability interpolation weights

a

bd

c

Figure 6: Reachability computation and interpolation weights for a5×5 neighborhood of pixels. Weights are renormalized after ex-cluding unreachable pixels.

as a read-only z-buffer during edge rasterization. This occlusionculling typically removes about half the edges.Edge reconstruction. After rasterization, pixels are classified andedges are reconstructed from the boundary intersections, usingthese simple rules. If a pixel has zero intersections then it is consid-ered empty. If a pixel has two intersections on its boundary and theyare not on the same side of the pixel, then it is simple and a singleedge is reconstructed (shown on the right in Figure 5). Otherwise,the pixel is complex.

5 ReconstructionIn image reconstruction, the EPI is used to compute the color foreach pixel. The first step is to compute areachability map that de-termines which samples may be used to interpolate color for eachpixel. Then pixels are interpolated using this map. Finally, a sepa-rate pass reconstructs complex pixels more accurately.

5.1 Pixel regions

Each simple pixel is divided into two regions by its edge (Figure 4),termed the primary and secondary regions. To correctly anti-alias asimple pixel, color must be determined for both regions. For perfor-mance, color is initially reconstructed only for the primary region.Color for the secondary region is approximated using the recon-structed color from a neighboring pixel. If a pixel has a sample, theregion containing the sample is considered primary. Otherwise, thelarger region is primary. For empty and complex pixels, the entirepixel is considered the primary region.

5.2 Reachability map

When reconstructing radiance for the primary region of a pixel,only reachable samples are used to interpolate the radiance at thatpixel. A sample in pixel regionb is consideredreachable from apixel regiona if there exists a reasonably direct path that does notcross any edges froma to b. Let us denote the primary region ofpixel x asPx and the secondary asSx. The reachability between twopixels a andb is denoted asa ↔ b and can be encoded in 4 bits:(Pa ↔ Pb, Pa ↔ Sb, Sa ↔ Pb, Sa ↔ Sb), where↔ denotes reacha-bility. Reachability is computed as shown in Figure 6. There arethree main operations in reachability computation:

1. Neighbor reachability: The reachability between pixels thatshare a boundary (e.g., pixelsc andd in Figure 6) can be found us-ing a lookup table based on the edge encodings for the pixels. Only4 bits out of each edge’s 10-bit encoding are used in this lookup.This optimization is possible because two adjacent pixels alwayshave the same intersection on their shared boundary; therefore, thesubpixel location of the boundary crossing is not needed. The 4 bitsper edge used in the lookup encode if its pixel is empty, simple orcomplex, and if simple, which two sides of the pixel the edge inter-sects. Thus, a 256-entry table indexed by two 4-bit edge encodingsreturns the 4-bit reachability mask between the two pixels.

2. Chaining: Reachability between two pixelsa andd throughan intermediate pixelb (Figure 6), denoteda

b↔ d, is obtained by

combininga ↔ b with b ↔ d using a lookup table. The lookuptable is indexed by the two 4-bit reachability masks and returnsthe 4-bit maska

b↔ d. Chaining considers potential reachabilitypaths through both the primary and secondary regions of interme-diate pixelb.

3. Combining: Reachability between two pixels along multiplepaths (e.g.,a

b↔ d∪ac↔ d) is combined by simply taking a bit-wise

boolean OR of the reachability masks of the paths.Example. To compute reachability between pixelsa and d in

Figure 6, we first find the reachability between neighbors using theneighbor reachability lookup table:a ↔ b = (1,0,0,0), a ↔ c =(0,1,0,0), c ↔ d = (1,0,0,1), b ↔ d = (0,1,0,0). Pixelsa andbare both empty and therefore are considered to have only a primaryregion. The gray region is primary in pixeld because it containsa sample. Since pixelc does not have a sample, the larger region(gray) is considered its primary. The reachability betweena andd can be computed along two paths, throughb andc respectively.Using the chaining lookup table we find:a

b↔ d = (0,1,0,0) anda

c↔ d = (0,1,0,0). Combining these gives the final reachabilitya ↔ d: (0,1,0,0). Note that the primary-to-primary reachability is0; that is, the gray sample ind is unreachable froma.

Complex pixels are always considered unreachable and reacha-bility is not propagated through them.

Reachability is first propagated to a pixel’s immediate neighborsacross their shared boundary along the arrows shown in Figure 6and then from them to their neighbors. At each step, reachabilityis propagated using the three operations above, always away fromthe center pixel. Together these operations allow reachability to bequickly computed in the 5×5 neighborhood.

Since the goal is to reconstruct radiance in the primary regionof a pixel, and samples always lie in a pixel’s primary region,reachability is finally needed only between primary regions. How-ever, since two primary regions might be reachable via anotherpixel’s secondary region, reachability is computed between bothprimary and secondary regions. Once it is computed, the primary-to-primary reachability from a pixel to every other pixel in its 5×5neighborhood is stored in a 24-bit mask. Since reachability is sym-metric,a is reachable fromd if and only if d is reachable froma,reachability of pixels on prior scanlines is reused for efficiency.

5.3 Interpolation

Once reachability is computed, the colors for pixels are recon-structed using constrained interpolation. For each pixel’s primaryregion, color is reconstructed using all the reachable samples in its5×5 neighborhood. The particular filter weights we use are shownin Figure 6; reconstruction is not sensitive to the choice of weights,provided the filter is sharply peaked in the center. Any pixel thatis either unreachable or does not contain a sample point is given aweight of zero and then the weights are renormalized.

Prioritized sampling. Future sampling is prioritized using feed-back from interpolation. Our sampling strategy is essentially thesame as in the Render Cache, except that edges influence the sam-pling distribution. As in the Render Cache, the priority for pixelswithout points is inversely related to the total interpolation filterweight before renormalization. More samples are concentrated inregions where the interpolation filter found low point densities, andpixels without reachable samples are given the highest priority. Thepresence of edges reduces the number of nearby reachable samples,and therefore increases the sampling near edges.

Anti-aliasing. A separate pass anti-aliases simple pixels usingan area-weighted combination of the colors of its primary and sec-ondary regions. For efficiency, the shading of the secondary regionis approximated by looking up the color of a neighboring pixel’sprimary region. An edge-indexed table is used to choose the neigh-bor most likely to contain a good approximation for the secondary

4

Appears in the ACM SIGGRAPH 2003 conference proceedings

Figure 7: Chains scene with tesselated torii. The edge image shows simple pixels in purple and complex pixels in green. The images on theright show reconstruction for the part of the image shown in the red box without (top) and with (bottom) the complex filter.

color and to obtain the relative weights to use. This filter is cheapand effective.

The EPI representation lets us distinguish between simple andcomplex pixels, thus permitting better reachability propagation, in-terpolation and anti-aliasing for simple pixels.

5.4 Complex pixelsThe mechanisms described thus far do not generate enough infor-mation to accurately shade complex pixels. One simple approach isto interpolate a color for them while ignoring reachability. At thevery least, this color is consistent with the local region of the image.It is computed during interpolation by simply considering all neigh-bors reachable from complex pixels (without affecting reachabilityfor other pixels).

A better approximation is computed at a slightly higher cost byrasterizing the edges at a higher resolution. We add horizontal andvertical boundaries through the center of each pixel and record in-tersections with them during edge rasterization. Intersections arestill recorded to eighth-of-a-pixel precision along each boundary,and these additional boundaries are ignored by all the prior recon-struction steps. However, the new boundaries divide each pixel into4 subpixels, enabling edge reconstruction in each subpixel.

For each complex pixel, we subdivide its 3× 3 neighborhoodinto a 6×6 subpixel neighborhood. Edge reconstruction and reach-ability are computed for subpixels similarly to the prior stages. Fora complex pixel, typically some of its 4 subpixels will be simpleor empty and can have colors interpolated for them. Any subpixelregion that is still complex or has no reachable samples uses thecomplex pixel’s estimated color from the simple interpolation. Thecomplete pixel is then shaded by combining the colors of the sub-pixel regions.

This additional filter for complex pixels subtly but noticeablyimproves image quality. An example is seen in Figure 7. Evenmore accurate reconstruction is possible by supersampling complexpixels. While this option is less attractive for an interactive system,it could be useful for progressive rendering.

6 Finding EdgesEdge-and-point rendering can be used with a variety of tech-niques for discontinuity finding. We have developed fast algorithmsfor computing discontinuities arising from silhouette and shadowedges, including soft shadow edges. For each frame, the silhouettesof the currently visible objects are computed from the current cam-era position. This recomputation is needed because silhouettes areview-dependent. Shadow edges, which are view-independent, arecomputed once and reused when possible.

6.1 SilhouettesA point on a surface is on an object’s silhouette if the normal at thatpoint is perpendicular to the view vector. In a polygonal scene, an

umbral event

light source

blocker

receiver

penumbral event

eye

silhouette

Figure 8: Sources of silhouette and shadow edges.

edge is on an object’s silhouette if one of the edge’s adjacent facesis forward-facing while the other face is backward-facing, as shownon the left in Figure 8. Thus, an edgee is a silhouette edge if thefollowing test succeeds:

sign(N f0 ·V f0) �= sign(N f1 ·V f1) (1)

Here, f0 and f1 are the two polygons adjacent to the edgee, Nf isthe normal of polygonf , and the view vectorVf is a vector from avertex of the facef to the current viewpoint.

6.2 Normal discontinuities

A simple form of geometric discontinuity is an edge that is intendedto be perceived as sharp (e.g., the edges of a box). These edgescause shading discontinuities. The edge finder reports these edgesif they are forward-facing with respect to the viewpoint. For a givenmesh, the user can specify a cutoff angle that determines whichedges are considered sharp. In our scenes, the cutoff angle is 85◦.

6.3 Shadows

A shadow on a receiving object (the receiver) occurs when a lightis occluded by an intervening object (the occluder or blocker). Ablocker creates shadowevents with respect to a light. In polygonalscenes, these shadow events intersect receivers to createshadowedges. In polygonal scenes with area lights, two types of shadowevents cause shadow discontinuities [Gigus et al. 1991; Heck-bert 1992; Lischinski et al. 1992]: vertex–edge events, and edge–edge–edge (EEE) events. Vertex–edge events are planes (actually,wedges) defined by a vertex of the light and an edge of the blocker,or vice-versa. The algorithm described here only finds vertex–edgeevents, which are more common than EEE events and result in vi-sually more important discontinuities.

Umbral and penumbral events are shown in Figure 8 on the right.They occur when the plane through the vertexv and edgee is tan-gential to the light and the blocker, and the light and blocker lie onthe same side or opposite side of the plane respectively. For pointlights, the umbral and penumbral events coincide.

The hard shadows caused by the occlusion of a point light sourceby a blocker create perceptually importantD0 radiance discontinu-ities. Soft shadows arise from the occlusion of an area light source

5

Appears in the ACM SIGGRAPH 2003 conference proceedings

and generateD1 discontinuities [Heckbert 1992]. It is important toidentify soft shadow edges near the point where a blocker contactsa receiver. At that point, soft shadows show a “hardening” effect inwhich the radiance gradient increases [Wanger et al. 1992]. Identi-fying penumbral and umbral shadow boundaries allows this effectto be rendered correctly (see Figure 9).

Shadow discontinuities are computed in two steps. First, shadowevents produced by lights and blockers are found. Then, shadowedges are computed by intersecting the shadow events with re-ceivers.

6.4 Accelerating silhouette computation

A brute-force identification of silhouette edges and shadow eventscan be done using Equation 1 and (for shadow events) Appendix A.Our implementation further accelerates the computation by usinga tree to store and look up the edges of an object. The leaves ofthis tree store edges; the internal nodes of the tree conservativelyrepresent the normals and positions of all the contained edges. Un-like the cone-based representations in [Sander et al. 2000; Johnsonand Cohen 2001], normals and positions are represented byintervalvectors, vectors of 3 intervals1.

The edge tree is constructed top-down. At each node of the tree,the node is subdivided on one of the three axes of the normal vectorso that the combined size of its children on those axes is minimized.This construction has low preprocessing overhead (about 7 minutesfor our largest scene, the dragon in Figure 13); it appears to be as ef-fective as the more specialized hierarchical construction in [Sanderet al. 2000] that takes hours to construct.

Tree traversal for silhouette and shadow events

Silhouettes and hard shadow events are found by traversing the tree.During the traversal, Equation 1 is evaluated at each node reached.Using interval arithmetic, the dot product of the normal intervalvector and the interval vector for the view vector,V, results in an in-terval[r0,r1]2. If [r0,r1] does not contain zero, all edges representedby the node are either forward- or backward-facing and are there-fore not silhouette edges. In this case, the sub-tree is pruned fromthe search; otherwise, the subtree is recursively explored. Whena leaf node is reached, all its edges are tested using Equation 1 todetermine if they are on the object silhouette.

For point lights, shadow events are essentially silhouette com-putations from the light’s point of view. Therefore they are foundby the same tree traversal. For area lights, our algorithm finds thepenumbral and umbral VE and EV events using a recursive traversalof the blocker’s edge tree. Using intervals permits us to uniformlyuse the same test (Equation 1) for area lights and point lights at in-ternal nodes. Leaf node tests for umbral and penumbral events aredescribed in Appendix A.

Shadow edge computation

Given the VE and EV event wedges, shadow edges are computed byintersecting these events with the receiver geometry. This processis accelerated using a bounding volume hierarchy for the receiverfaces. Each shadow event is walked down the receiver’s face tree tofind intersections of the event with the geometry represented by thatnode of the tree. The hierarchy is extended to include a conservativenormal interval vector at each internal node. These normal interval

1An interval vector used to represent a range of normals has three inter-vals each representing the range of the corresponding Cartesian componentof the normals. Operators on interval vectors are defined using the usualinterval arithmetic operations [Moore 1979]; e.g., the dot product of two in-terval vectors is computed as a component-wise interval multiplication andan interval addition of the resulting intervals to obtain the final interval.

2The interval vector forV is computed using the position interval vectorof the node.

Figure 9: Umbral and Penumbral edges: umbral edges in red,penumbral edges in blue. Notice the coincidence of umbral andpenumbral edges where the torus contacts the capsule, resulting inthe correctly rendered “hardening-at-contact” shadow effect.

vectors are used to eliminate entire sub-trees of receiver polygonsthat are back-facing with respect to the light.

Non-smooth surfaces

The edge tree has similarities to the cone-based hierarchiesof [Johnson and Cohen 2001; Sander et al. 2000]; we chose theinterval representation for its simplicity. Both [Johnson and Cohen2001; Sander et al. 2000] note that their cone-based data structureswork less well for meshes produced from scanned data, becausethese meshes often contain “sharp” edges whose normals vary sig-nificantly. Such edges make the data structure less effective at prun-ing the search space.

To address this problem, we place sharp edges higher in the tree.During top-down tree construction, an edge is stored at a node if itsnormals span more than half of the node’s entire range of normals.This optimization makes normals represented by the child nodesmore compact. When an internal node is reached while traversingthe tree, all its stored edges are tested. This simple extension to thedata structure substantially improves its performance on complexmeshes: for the David head (Figure 12), performance improves bya factor of 2.

6.5 Complex Scenes

A few additional features are important for the interactive detectionof silhouettes and shadow edges in complex scenes.Finding light-blocker-receiver triples. To determine the shadowedges for a receiver, the lights and blockers that cast shadows onthat receiver must be identified. Exhaustive computation of shadowevents for all potential light-blocker pairs would be too slow. In-stead, the shading process asynchronously communicates the light-blocker-receiver triples that it discovers during shading to the edgefinder. All shadow edges associated with a receiver are stored withthe receiver, and reused as long as the light, blocker and receiver donot move.Clipping. A nearby receiver may prevent a shadow event frompropagating to more distant receivers. For each shadow event, wesort the shadow edges it generates and clip them against each other,retaining only the unoccluded edges. Clipping is simple and effi-cient because it is performed in one dimension, along the edge ofthe VE/EV event.Moving objects. If a light or blocker are moved, the shadow eventsassociated with that light-blocker pair are recomputed and the shad-ows for receivers associated with that pair are also recomputed.When a receiver moves, its shadows are affected; other receiversthat share a light-blocker pair with that receiver and are farther fromthe light might also be affected by the move because they are nolonger occluded by the moved object. To be conservative, all theseshadows are recomputed.

6

Appears in the ACM SIGGRAPH 2003 conference proceedings

Figure 10: The left image shows a tea-stand with fine geometry and complex shadows. The middle image shows the edges found; complexpixels are shaded in green. The images on the right compare a standard 1-sample-per-pixel sampling (top) against our technique (bottom).

Queries into the tree data structure are performed in object co-ordinates, thus eliminating the need to rebuild these data structureswhen an object is moved.

6.6 Discussion

Unlike discontinuity meshing techniques, our goal is to achieve in-teractive performance. Therefore, we focus on the shadow edgesthat are typically the most important perceptually: those cor-responding to silhouettes, hard shadow events, and umbral andpenumbral VE/EV events. Additionally, computed shadow edgesare directly rendered onto the image plane; we never explicitlymesh discontinuities.

7 Implementation and ResultsIn this section we present results from our edge-and-point basedrendering system. All result images are 512× 512. We use threedifferent shaders: direct illumination with ambient, direct withglossy reflections, and direct with global illumination. The edge-and-point renderer runs on a single 2.8 GHz Pentium 4. All theshaders use ray tracing. The direct illumination shader runs on asingle 2.8 GHz Pentium 4. The glossy reflection shader uses raytracing to sample the glossy reflection and runs on four 1.7 GHzprocessors. The global illumination shader uses a dynamic variantof irradiance caching [Ward et al. 1988] modified for interactiveuse. The global illumination shading is computed on four 1.7 GHzprocessors, and 6 processors asynchronously compute the irradi-ance samples.

7.1 Scene descriptions

Scene Polygons Edges ShaderRooms 15,006 23,004 global illuminationChains 73,728 110,592 directMack 101,306 153,526 global illuminationDavid 250,014 374,635 glossy reflectionDragon 872,184 1,305,164 direct

Table 1: Scene statistics and the shaders used for each scene.

Table 1 lists the scenes used to acquire results. The Rooms scene(Figure 12) shows a textured multi-room scene with six lights. TheChains scene (Figure 7), with two lights, has tesselated non-convexobjects casting complex shadows on each other. The edge imageshows our ability to correctly find silhouettes and shadows.

The Mackintosh room (Figures 10 and 11), has three lights andis rendered with the global illumination shader. The David headfrom Stanford’s Digital Michelangelo project (Figure 12), has 250kpolygons and is lit by 1 light; the scene is rendered using glossy re-flections. The Dragon scene (Figure 13) has a grid casting a shadowpattern on a dragon with 871k polygons (from Georgia Tech’s LargeGeometry Models Archive). All these scenes also demonstrate self-shadowing of complex objects.

7.2 PerformanceTable 2 gives the breakdown of time (in milliseconds) spent on theimportant components of the algorithm for a typical frame: fromleft to right, edge finding, edge rasterization, point reprojection,reachability, interpolation, anti-aliasing and complex filtering. Thetotal time is slightly higher than the sum of all these modules sinceit includes all processing.

Silhouette finding is efficient, ranging from 0.5 ms up to 22 msfor the most complex model, the dragon, which has 1.3M edges.Edge rasterization is slowest for the David, because it has the mostsilhouette and shadow edges (see Table 3). Point reprojection costsare essentially unchanged from the Render Cache.

Reachability, interpolation, and anti-aliasing have constant costper frame, because the compact EPI and their implementation usingfast table lookups makes these stages independent of scene and edgecomplexity. Their run time only depends on image resolution. Thecost of the complex filter depends on the number of complex pixels(see Table 3).

Table 2 presents the frame rate in frames per second; numbersin parentheses give the slightly improved frame rates achieved withcomplex filtering turned off. The system achieves interactive framerates of about 8–14 frames per second.

The framerate is essentially independent of the speed of theshader being used, although the quality of the images does dependon the number of newly shaded samples per frame. The samplingsparseness ratio is also reported for the examples given. This is theratio between the number of pixels in an image and the number ofnew samples acquired per frame. The sparseness ratio is between40 to 125; thus only 1 to 3% of the point samples are updated eachframe. The ability to tolerate such sparse sampling is crucial forgood interactive image quality when using expensive shaders.

Finally, we compare our results with a ray tracer that samplesevery pixel in each frame. Frames for this ray tracer were computedusing our shaders and the same number of processors as used by oursystem (i.e., the display processor is also used for shading by thisray tracer). Compared to this ray tracer we achieve speedups of 20to 65. We also produce higher quality images with anti-aliasing (seecomparison on the right of Figure 10).

7

Appears in the ACM SIGGRAPH 2003 conference proceedings

Figure 11: Mackintosh Room comparing edge-preserving interpolation (left and bottom right) vs. standard interpolation similar to the RenderCache (middle and top right) from the same samples. For both images, only 20% of the pixels have samples. The images on the right show amagnified comparison.

Scene Find Rasterize Point Reach Interp Anti Complex Total FPS Sparseness Full SpeedupEdges Edges Proc. Alias Filter (ms) Ratio RT (s)

Rooms 0.5 17 26 11 14 2 17 95 10.5 (13.3) 97 (124) 4.8 51 (64)Chains 4 13 26 11 14 2 6 88 11.4 (12.3) 52 ( 58) 2.0 23 (25)Mack 2.5 11 26 11 14 2 6 77 13.0 (14.3) 92 (101) 4.5 58 (64)David 9 39 27 11 14 2 16 127 7.9 ( 9.7) 65 ( 80) 5.1 40 (50)Dragon 22 29 26 11 14 2 6 124 8.1 ( 8.8) 40 ( 40) 2.3 19 (20)

Table 2: Performance results. Frame breakdown of different components and total time (in milliseconds), frame rates, and speedup numbers.

EPI complexity. Table 3 presents the detailed number of silhouetteand shadow edges for a typical frame of each scene. The number ofshadow events for a light-blocker pair is proportional to silhouetteedge size. Theoretically, the total number of shadow events is pro-portional tonlights×nsil , wherensil , the number of silhouette edges,is usuallyO(

√n) in the number of polygons [Sander et al. 2000].

Shadow edges are computed for each light-blocker-receivertriple, and depend on the receivers associated with each light-blocker. Thus, a large blocker casting a shadow on a finely tesse-lated receiver could generate several shadow edges per event. Con-versely, a finely tesselated blocker could cast only a small numberof shadow edges per event. In theory, each shadow event couldcauseO(n) shadow edges. In practice, the number of edges is sub-stantially smaller than(nlightsn

√n), as can be seen from our results.

The detailed edge counts give a flavor of the number of edgesinteractively computed and manipulated by our system. The Davidhead has the largest number of edges because of its finely tesselated,irregular geometry, which results in significant self-shadowing.

Table 3 also gives a detailed breakdown of the pixel classifica-tions. The fraction of complex pixels is small for all of the scenes.Most pixels are empty or simple, and can be efficiently and accu-

Scene # Sil # Shadow Pixel CategorizationEdges Edges Empty Simple Complex

Rooms 1,814 7,356 87.0% 8.9% 4.1%Chains 3,644 14,138 92.0% 6.9% 1.1%Mack 3,669 27,917 89.1% 9.7% 1.2%David 39,116 163,338 92.5% 3.5% 4.0%Dragon 26,269 92,884 92.9% 5.9% 1.2%

Table 3: Number of silhouette and shadow edges and pixel catego-rization for a typical 512×512 frame in each scene.

rately reconstructed by the edge-and-point renderer.Edge finding. The preprocessing time to construct the edge treesranges from about a second to a maximum of 7 minutes for thedragon scene (as compared to hours for [Sander et al. 2000]).

Silhouette finding and shadow event computation is fast (see Ta-ble 2). The edge tree appears to be about as effective in pruningthe search space as the cone-based data structure of [Sander et al.2000]; therefore detailed results are omitted.

The torus scene (30,000 polygons) in Figure 9 shows soft shadowedges for an area light. Computing shadow events for area lights isapproximately twice as expensive as a silhouette computation sinceboth umbral and penumbral events must be computed.

Shadow edge computation time varies substantially dependingon the viewpoint and the light-blocker-receiver triples being pro-cessed. Therefore, we summarize the total time for shadow compu-tation over all scenes. When our scenes are loaded, initial shadowcomputation takes 0.1 to approximately 2 seconds (for the Davidhead). As the user moves around or manipulates objects in laterframes, the shadow computation time ranges from 1 to 50 millisec-onds depending on how many new light-blocker-receiver triples arefound by the shader. When the grid is moved in the Dragon scene,shadows on the dragon are updated in 50 ms. The average costof intersecting a shadow event with the scene to compute shadowedges ranges from 8–28µs per event depending on the scene.

7.3 Sparse sampling and anti-aliasing

The Mackintosh scene shows the ability of the renderer to find andanti-alias fine shadow details. On the right in Figure 10, magnifiedimages of the tea-stand are shown. On the top is the result producedby a regular ray tracer using 1 sample per pixel; on the bottom isthe anti-aliased result produced by our system.

Figure 11 compares our image with an image produced usinginterpolation that does not respect edges (like the Render Cache).

8

Appears in the ACM SIGGRAPH 2003 conference proceedings

Both images use the same samples, and only 20% of the pixels con-tain samples. We can see that using edge-respecting interpolationproduces a significantly better image, while using the same sam-ples. Even at this low sampling density we are able to effectivelyanti-alias the image.

Our system can reconstruct good images with very sparse sam-pling densities as can be seen in the video. For example, in theMackintosh room, only 1 out of every 100 pixels had a new sampleshaded per frame. By reusing and interpolating sparse samples weproduce high-quality images at interactive frame rates.

7.4 Memory UsageThe per-pixel memory costs for various data structures are as fol-lows: the EPI uses 10 bytes (Section 4.4), reachability masks re-quire 3 bytes, and boundary intersections require 2–4 bytes depend-ing on whether complex filtering is turned on. For 512×512 resultimages, these structures use 3.75–4.25 MB of memory. The variouslookup tables use less than 16 KB. Point-based processing requiresthe same space as the Render Cache (∼ 9 MB). The edge trees arelinear in the size of the objects.

7.5 DiscussionFrom Table 2 we see that the cost of the 3 main filters (reachability,interpolation, and anti-aliasing) is independent of scene complexityand the number of edges. One of the strengths of the EPI represen-tation is this decoupling of the cost of reachability and interpolationfrom scene complexity.

Edge finding and rasterization are dependent on scene complex-ity but are typically fast enough. It should be possible to further ac-celerate these components using programmable graphics hardware.

Scenes with a very large fraction of complex pixels violate theassumptions made by sparse sampling and reconstruction algo-rithms. Fundamentally, such scenes must be reconstructed at higherresolutions for reasonable image quality. While our algorithm willslow down for these scenes, our image quality should not be worsethan traditional sampling and reconstruction algorithms for thesescenes. We expect our techniques would also be useful in the con-text of non-interactive progessive viewing for these scenes.

When objects are moved, some shading samples become invalidand new samples must be acquired. In addition, shadow edges mustbe recomputed. In our results, the time required to obtain updatedshading samples is the bottleneck; shadow edges are computed fastenough. Better techniques for sample invalidation (e.g., [Bala et al.1999a]) would speed up shading updates for dynamic scenes.

8 ConclusionsThis paper introduces a new interactive rendering technique thatcombines shading discontinuities (edges) and sparse samples(points) to generate high-quality, anti-aliased images. Discontinu-ity edges are found interactively and are projected on the imageplane. Shading is reconstructed from sparse samples using edge-respecting interpolation. We have demonstrated that our systemrenders high-quality anti-aliased images at interactive rates of manyframes per second in scenes including geometrically complex ob-jects and lighting effects such as shadows and global illuminationwith very low sampling ratios (1%–3% of the pixels per frame). Theuser can also dynamically move objects within the environment.

We describe a new compact representation of discontinuities andpoint samples called theedge-and-point image; this image is usedby efficient interpolation algorithms to reconstruct radiance. Theexplicit detection of discontinuities permits the generation of anti-aliased output images, without supersampling, at interactive ratesof 8–14 fps on a modern desktop computer.Future Work. A promising avenue of future research is to ac-celerate our edge-and-point renderer using the new programmable

Figure 12: David head and Rooms scene.

Figure 13: Grid casting shadow on Dragon.

graphics hardware. Our table-driven filters are simple enough forthis to be feasible. Hardware assisted silhouette and shadow edgedetection should also be possible.

Our system identifies two important types of discontinuities;other discontinuities such as mirror reflections, specular trans-parency, and textures can be perceptually important for somescenes. It appears possible to extend interval-based edge findingfor reflection and transparency edges. For some textures it mayalso be beneficial to include edges from the texture in the EPI.

To improve the rendering of complex scenes, it would be usefulto identify the perceptually important discontinuities in an image.For example, in scenes with large numbers of lights, discontinuitiesfrom unimportant lights could be eliminated [Ward 1994].

Acknowledgements. The authors thank Sebastian Fernandez, JimFerwerda, Andrew Myers, Steve Westin, and the anonymous re-viewers for their feedback. We also thank Stanford’s DigitalMichelangelo project, the Georgia Tech Large Geometry ModelsArchive, Gene Gregor, and Reynald Dumont for their models. Weacknowledge the support of NSF grant ACI-0205438 and Intel Cor-poration for generously providing funding and equipment.

ReferencesBALA , K., DORSEY, J., AND TELLER, S. 1999. Interactive ray-traced

scene editing using ray segment trees. In10th Eurographics Workshopon Rendering, 39–52.

BALA , K., DORSEY, J.,AND TELLER, S. 1999. Radiance interpolants foraccelerated bounded-error ray tracing.ACM Transactions on Graphics18, 3, 213–256.

DRETTAKIS, G., AND FIUME, E. 1994. A fast shadow algorithm for arealight sources using backprojection. InSIGGRAPH ’94, 223–230.

DUGUET, F., AND DRETTAKIS, G. 2002. Robust epsilon visibility. InSIGGRAPH ’02, 567–575.

DURAND, F., DRETTAKIS, G., AND PUECH, C. 1997. The visibilityskeleton: A powerful and efficient multi-purpose global visibility tool.In SIGGRAPH ’97, 89–100.

DURAND, F. 1999.3D Visibility: Analytical Study and Applications. PhDthesis, Grenoble University.

9

Appears in the ACM SIGGRAPH 2003 conference proceedings

GIGUS, Z., CANNY, J.,AND SEIDEL, R. 1991. Efficiently computing andrepresenting aspect graphics of polyhedral objects.IEEE Transactionson Pattern Analysis and Machine Intelligence 13, 6, 542–551.

GUO, B. 1998. Progressive radiance evaluation using directional coherencemaps. InSIGGRAPH ’98, 255–266.

HECKBERT, P. 1992. Discontinuity meshing for radiosity. In3rd Euro-graphics Workshop on Rendering, 203–226.

JOHNSON, D., AND COHEN, E. 2001. Spatialized normal cone hierarchies.In Symposium on Interactive 3D Graphics, 129–134.

LEVOY, M., PULLI , K., CURLESS, B., RUSINKIEWICZ, S., KOLLER, D.,PEREIRA, L., GINZTON, M., ANDERSON, S., DAVIS, J., GINSBERG,J., SHADE, J.,AND FULK , D. 2000. The digital Michelangelo project:3D scanning of large statues. InSIGGRAPH ’00, 131–144.

L ISCHINSKI, D., TAMPIERI, F., AND GREENBERG, D. P. 1992. Discon-tinuity Meshing for Accurate Radiosity.IEEE Computer Graphics andApplications 12, 6, 25–39.

MOORE, R. E. 1979.Methods and Applications of Interval Analysis. Stud-ies in Applied Mathematics (SIAM), Philadelphia.

PARKER, S., MARTIN, W., SLOAN, P.-P., SHIRLEY, P., SMITS, B., AND

HANSEN, C. 1999. Interactive ray tracing. InSymposium on Interactive3D Graphics, 119–126.

PFISTER, H., ZWICKER, M., VAN BAAR, J.,AND GROSS, M. 2000. Sur-fels: Surface elements as rendering primitives. InSIGGRAPH ’00, 335–342.

PIGHIN, F., LISCHINSKI, D., AND SALESIN, D. 1997. Progressive pre-viewing of ray-traced images using image-plane discontinuity meshing.In 8th Eurographics Workshop on Rendering, 115–126.

RUSHMEIER, H., BERNARDINI, F., MITTLEMAN , J., AND TAUBIN , G.1998. Acquiring input for rendering at appropriate level of detail: Digi-tizing a pieta. In9th Eurographics Workshop on Rendering, 81–92.

RUSINKIEWICZ, S., AND LEVOY, M. 2000. Qsplat: A multiresolutionpoint rendering system for large meshes. InSIGGRAPH ’00, 343–352.

SANDER, P. V., GORTLER, S. J., HOPPE, H., AND SNYDER, J. 2000.Silhouette clipping. InSIGGRAPH ’00, 327–334.

SANDER, P. V., GORTLER, S. J., HOPPE, H., AND SNYDER, J. 2001.Discontinuity edge overdraw. InSymposium on Interactive 3D Graphics,167–174.

SIMMONS, M., AND SEQUIN, C. H. 2000. Tapestry: A dynamic mesh-based display representation for interactive rendering. In11th Euro-graphics Workshop on Rendering, 329–340.

TOLE, P., PELLACINI , F., WALTER, B., AND GREENBERG, D. 2002.Interactive global illumination. InSIGGRAPH ’02, 537–546.

WALD , I., BENTHIN, C., WAGNER, M., AND SLUSALLEK , P. 2001. In-teractive rendering with coherent ray tracing. InProc. of Eurographics,153–164.

WALD , I., KOLLIG, T., BENTHIN, C., KELLER, A., AND SLUSALLEK , P.2002. Interactive Global Illumination using Fast Ray Tracing. In13thEurographics Workshop on Rendering, 15–24.

WALTER, B., DRETTAKIS, G.,AND PARKER, S. 1999. Interactive render-ing using the Render Cache. In10th Eurographics Workshop on Render-ing, 19–30.

WALTER, B., DRETTAKIS, G., AND GREENBERG, D. 2002. Enhancingand optimizing the Render Cache. In13th Eurographics Workshop onRendering, 37–42.

WAND, M., FISCHER, M., PETER, I., AUF DER HEIDE, F. M., AND

STRAER, W. 2001. The randomized z-buffer algorithm: Interactiverendering of highly complex scenes. InSIGGRAPH ’01, 361–370.

WANGER, L., FERWERDA, J., AND GREENBERG, D. 1992. Perceiv-ing spatial relationships in computer-generated images.IEEE ComputerGraphics and Applications 12, 3, 44–58.

WARD, G. J., RUBINSTEIN, F. M., AND CLEAR, R. D. 1988. A RayTracing Solution for Diffuse Interreflection. InSIGGRAPH ’88, 85–92.

WARD, G. J. 1994. Adaptive shadow testing for ray tracing. In5th Euro-graphics Workshop on Rendering, 11–20.

YOO, K.-H., KIM , D. S., SHIN, S. Y., AND CHWA, K.-Y. 1998. Linear-time algorithms for finding the shadow volumes from a convex area lightsource.Algorithmica 20, 3, 227–241.

ZWICKER, M., PFISTER, H., VAN BAAR, J.,AND GROSS, M. 2001. Sur-

blocker

receiver

light v'

e

θ''

θ'

v

ve

v''

Figure 14: Finding an umbral EV event.

face splatting. InSIGGRAPH ’01, 371–378.

A Umbral and Penumbral EventsWe extend an efficient algorithm for finding penumbral events [Yooet al. 1998] to support meshes, concave surfaces, and umbral events.Our algorithm efficiently finds all shadow events that participate inthe shadow volume boundary. We follow [Lischinski et al. 1992]in using the term “VE event” to refer to a vertex–edge event whosevertex lies on the light; an “EV event” is correspondingly definedby an edge of the light and a vertex of the blocker.

VE events. To identify VE events involving a particular edgee of the blocker and a vertexv of the light, the silhouette test ofEquation 1 is first performed to ensure that the normal of the planedefined by the VE event is included in the normals represented bythe edge. The vertices of the light adjacent tov are tested to deter-mine whether they all lie on the same side of the plane; if so, anevent has been found. To determine whether the event is umbral orpenumbral, the orientation of the blocker surface is compared to theposition of these adjacent light vertices.

EV events. EV events can be found efficiently by piggyback-ing onto the discovery of VE events, thus avoiding a separate treetraversal. Once a VE event connecting vertexv and edgee is found,the shadow volume boundary is traversed in both directions (alonge) looking for adjacent EV events. This traversal is simplified us-ing the following observation: for surfaces that appear locally con-vex from the viewpoint of the vertexv, EV events contribute to thepenumbral shadow volume boundary, but not to the umbral shadowvolume boundary. Conversely, for locally concave surfaces, EVevents contribute to the umbral boundary but not to the penumbralboundary.

Figure 14 illustrates the algorithm used to find EV events in thecase of a concave umbral event. Here, the shadow volume boundaryis being traversed towards the vertexve along the blocker surface.The first step is to determine whether the surface is locally convexor concave. This is done by finding the angleθ′′ between thev–e plane and the plane defined by the three vertices:v, ve, and theblocker vertexv′′ adjacent tove that minimizes this angle. If theangle is less thanπ, the blocker surface is locally concave from theviewpoint ofv.

Given this geometry, there are two possibilities for the next eventalong the shadow volume boundary: it is either the EV event shadedin purple, defined by the verticesv, v′ andve, or else it is the VEplane defined byv, v′′, andve. Which is correct is determined bycomputing the angleθ′ between thev–e plane and the possible EVplane; if this angle is larger thanθ′′, the EV event is part of theshadow volume boundary.

Penumbral EV events are found similarly, except that they areonly found for convex surfaces, and the angles involved are greaterthanπ.

10