SILHOUETTE-OPAQUE TRANSPARENCY RENDERING

Osman SenDepartment of Computer ScienceUniversity of California, Irvine

osen@ics.uci.edu

Chaitanya ChemuduguntaDepartment of Computer ScienceUniversity of California, Irvine

chandra@ics.uci.edu

M. GopiDepartment of Computer ScienceUniversity of California, Irvine

gopi@ics.uci.edu

ABSTRACTTransparency in 3D graphics has traditionally been createdby ordering the transparent objects from back-to-front withrespect to the viewpoint, and rendering the opaque objectsfirst and then the transparent objects in the prescribed or-der. This has three major disadvantages: need for splittingintersecting polygons, repeated ordering for varying viewpoints, and finally, incorrect transparency at the regionsnear silhouettes. The first two problems are eliminated byorder independent transparency rendering techniques. Thegoal of this paper is to eliminate the third disadvantage also.Silhouettes look more opaque than the rest of the regionsof the model. We call thissilhouette-opaque transparencyrendering. We use the alpha value as a probabilistic mea-sure, similar to other order independent methods. We dif-fer from the traditional methods by using this probabilis-tic measure in object space rather than in image space torender the transparency in silhouettes correctly. We callour technique to achievesilhouette-opacityasobject-spacescreen-door transparency.

KEY WORDSObject-space screen-door transparency, silhouette-opacity,transparency rendering.

1 Introduction

Traditional transparency algorithms would separate opaqueand transparent objects, and sort transparent objects back tofront. The Z-buffer being enabled, the opaque objects arerendered first, and then the transparent objects are renderedback to front. The transparency of a fragment is denoted byits α value. The color of the fragment is linearly compos-ited with the color already existing in the framebuffer.

Crow [3], and Kay and Greenberg [9] in their clas-sic works noted that the transparency is dependent on theamount of material the light passes through. The amountof material depth is invariably more along the silhouettes,and hence silhouettes will look more opaque than other re-gions of the object. We call this assilhouette-opacity. Crow[3] proposed to change theα value towards silhouettes andinterpolated theα value non-linearly based on the normalvector at the surface point and the viewing direction. Thisfunction isα = (αmax − αmin)(1 − (1 − Nz)p) + αmin.The quantitiesαmax andαmin are the maximum and mini-mum transparency of any point on the object. TheNz is the

Z component of the unit normal to the surface andp is thecosine power factor. Kay and Greenberg [9] proposed solu-tions for refraction in the transparent medium by modelingthe thickness of the material. This model also incorporatedfeatures to take care ofsilhouette-opacity. As far as weknow, [3, 9] are the only works in the literature that talkaboutsilhouette-opacityand propose solutions.

The advent of latest graphics hardware acceleratorshave not followed up on these proposals for various rea-sons. The model proposed by [9] has similar problemsas ray-tracing algorithm has in terms of its amenability tohardware implementation. The solution proposed in [3] hasthe following problems. First, when all other more com-monly used attributes like depth value, texture coordinates,and color are interpolated linearly (at least in homogeneouscoordinates), interpolating theα value using a non-linearfunction is a significant overhead. Second, irrespective ofthe interpolation function, the ordering of triangles (or pixelfragments) from back-to-front has to be computed either byapplication or during rasterization.Main Contributions: In this paper, we propose a methodfor silhouette-opaque transparent renderingthat eliminatesall the above mentioned disadvantages of the methods pro-posed earlier. First, we achieve order-independent trans-parency rendering by using a probabilistic method of sam-pling the surface.

This is similar to the screen-door transparencymethod but uses random alpha mask patterns in the objectspace, and super-sampling to generate high quality images.Second, we achievesilhouette-opacityby a simple object-space screen-door transparency. Our method is a singlepass rendering method that also lends itself for easy hard-ware implementation.Outline of the Paper: Next section analyzes the previouswork in this area. Section 3 describes our method concep-tually. Section 4 describes the implementation details ofour algorithm and presents the results. Sections 5 and 6 listthe limitations of our apprach and conclude this paper.

2 Previous Work

Rendering objects transparently can open the door for amultitude of graphics and 3D visualization applications.However, rendering of realistic object transparency simu-lation, including refraction, is a computationally expensiveoperation. Therefore, non-refractive transparency is used

398-032 153

Figure 1. The imagea show the results of using conventional alpha blendin, using stipple buffer [14], our hardware assistedimplementation and our software implementation of our object-space screen door transparency algorithm. Notice the silhouettesin our software implementation. The artifacts in the stipple image are due to overlapping polygons getting mapped on to similarstipple maps. Note that this is a filtered image with16 × 16 kernel size.

for most of the applications requiring fast rendering. Exactsimulation of non-refractive transparent surfaces with alphablending requires ordering of polygons from back to frontand subdividing intersecting polygons [2, 15]. The cur-rent day transparency algorithms can be classified as sort-ing based algorithms and order independent transparencyalgorithms.

Sorting based algorithms require the primitives to besorted back to front with respect to the viewpoint. Thesealgorithms can be further classified based on how the sort-ing is done: application sorting, hardware assisted applica-tion sorting, and hardware sorting. Examples of applica-tion sorting algorithms include [2, 15, 16, 11, 13, 9] whereapplication takes the complete responsibility of sorting theprimitives. Hardware assisted sorting based transparencyalgorithms include methods like layer depth sorting (depthpeeling) using data structures for pixel depth information[5]. Hardware sorting are special purpose architectures forsorting rasterized fragments [18, 1, 13, 8, 12, 4, 10, 17, 11].Most of these works are derivatives of A-buffer [1]. Afew of these hardware-assisted or hardware algorithms usemulti-pass rendering methods [5, 12, 4, 17, 11]. Thesemulti-pass algorithms use data structures like linked list ofpointers with special hardware and/or render a fixed num-ber of transparent levels.

Order independent transparency algorithms, typicallymodel theα value as a probability measure. Usually, poly-gons are rendered in the image space that is overlaid withmasks. Random masks are used to choose or reject pixelsto produce dithering-like effects in the image space [14, 7].Methods like screen-door transparency using stipple and al-pha buffers fall under this category. These techniques haveseveral advantages like they are single pass methods, do notrequire sorting of primitives, and are able to handle inter-secting polygons without further processing. They also suf-fer from artifacts such as incorrect opacities and distractingpatterns due to dithering and masks. Further a few of thesemethods also have the disadvantage of storing many masksfor each transparency value. Supersampling and filtering isa common technique that is used to remove image qualityproblems. But the correctness of the image generated, es-

pecially along the silhouettes cannot be improved by theseimage-space masking techniques.

The method we present in this paper is an order-independent transparency algorithm. Hence our method isa single pass method and use alpha masks as other meth-ods. Unlike previous techniques, we use these masks inthe object space rather than in the image space. Thissolves the problem of incorrect opacities and also producessilhouette-opaque rendering. We also use supersamplingto eliminate the dithering artifacts introduced by mask-ing. Finally, we suggest the use of certain hardware fea-tures to accelerate our implementation. In the next section,we formally introduce the underlying concepts behind ourmethod, and our method itself.

3 Object Space Screen-Door Transparency

Let us define the transparency factorα. Consider two vec-tor fields in 3D space. One field contains the outgoing lightin all directions from any 3D pointP and the other con-sists of the incoming light from all directions toP . Thelength of a vectorVo(P ) (or Vi(P )) at a 3D pointP de-notes the amount of the outgoing (or incoming) light in thedirection ofVo(P ) (or Vi(P )). The relationship betweeneveryVi(P ) andVo(P ) is the radiance transfer equation.But we are going to restrict this relationship between thosetwo rays that are the same. That is,Vi(P ) = Vo(P ) = V .

Given a directionV and a pointP , let βV (P ) =|Vo(P )|/|Vi(P )|, whereVi(P ) andVo(P ) are vectors fromthe two fields in the same direction asV . The transparencyfactorαV (P ) = 1 − βV (P ). (Actually,α should be calledthe opacity factor. We call it the transparency factor tobe consistent with the convention.) IfP is vacuum, thenαV (P ) = 0, for anyV .

Notice the dependence ofα on the directionV , andits independence on the incoming light from directionsother thanV . In other words, this definition models theanisotropic transparency effects of object points, and ig-nores the refractive properties. Similar definitions can bearrived at from the above model for refraction, reflection,and other radiance properties of the object.

154

Silhouette-Opacity: The silhouette-opacity property,where the silhouettes are more opaque than the other partsof the object, can be modeled as an anisotropic property ofthe object regions. Basically,|Vo(P )| the outgoing vectortowards the viewpoint is less ifP is near silhouette thanif P is in other regions of the object. Since|Vo(P )| =(1 − αV )|Vi(P )|, this attenuation near the silhouettes canbe modeled either by reducing the incoming light, or byincreasingαV .

The approach taken by [3] to model silhouette-opacity, increases the value ofαV as a non-linear functionof the viewing direction and the normal vector at that point.In our method, we take the alternate approach of reducingthe length of the incoming light vector to model silhouette-opacity, and assuming thatαV is same in all directions (thatis, isotropic and independent ofV ).

We model the object using uniform sized primitivesand the union of these primitives covers the object. Sincethe density of primitives in the projection plane is naturallymore along the silhouettes, the light reaching the viewpointfrom these regions will be attenuated more that the lightfrom other regions of the model. Note that the “primitive”is a generic term. A primitive can be a point (disk) or atriangle or any other geometric feature that is small enoughand reliably covers the surface.

Order Independent Transparency: The above pro-cess takes care of the silhouette-opacity. We still have tosolve the problem of order-independency. In the abovesampling of the surface, every primitive is assumed to beof the same size and have the sameα value. The amountof outgoing light is|Vo(P )| = (1 − α)|Vi(P )|. Consider aset ofn primitives in a small region. The amount of lightlet through by this set ofn regions is(1− α)Σn

j=1|Vi(Pj)|corresponding to all primitives in the set. Assuming thatthe same amount of light is incident on each primitive, dueto their spatial proximity, the amount of light let throughby the set ofn primitives is |Vo| = n(1 − α)|Vi|. Letus consider a case in which|Vo| is same as above, butunder the condition that every primitive can have eitherα = 0 or 1. Assuming same amount of input light|Vi|, thenumber of primitiviesm (out of the aboven primitives),that can haveα = 1 is m = nα. If α = 1, then thatprimitive is rendered opaque; otherwise it is not rendered.Renderingm(< n) opaque primitives, instead ofn semi-transparent primitives, wouldon an averagegive the sameeffect. Choosingm out of n primitives can be achievedusing a mask. If these primitives are pixels, and the maskis applied on the image plane, then this method is calledscreen-door transparency[14].

Let us first prove that screen-door transparency pro-duces correct results under restricted conditions. Sincebinary-alpha transparency rendering is an “averaging” pro-cess, it is inherently probabilistic. So the image is super-sampled such thatn pixels are averaged to get one pixel inthe final image. Assume that there is one transparent ob-ject with α = α1 and hence the number of primitives tohaveα = 1 is m = nα1. Let the color of the object beC1

and that of the background color beC2. The final color ofthe pixel after filtering isC = (mC1 + (n − m)C2)/n =α1C1 + (1 − α1)C2, which is the equation for traditionaltransparency. Assuming that the Z-buffer is enabled, thisconcept can be proved to be correct for multiple objectsalso, and does not dependent on the order of rendering ofthe objects.

Transparency is inherently an object property. Obvi-ously, the above “image-space” argument is correct only ifn primitives on the object surface coversn pixels in the im-age space. But, this is not true for the primitives in the sil-houette of the model. Hence, the “image-space screen-doortransparency” cannot be used to produce silhouette-opacity.

Silhouette-Opaque Order-Independent Trans-parency: To achieve order-independent transparentrendering, we choosem out of n primitives from theobject, rather than from theimage. We call this method,object-space screen-door transparency. To achievesilhouette-opacity, we useuniform object space sampling.By combining these two techniques, we achieveorder-independent silhouette-opacity transparency rendering.

3.1 Decision Parameters

We are now ready to analyze various parameters that wouldinfluence the quality of images generated by a method us-ing object-space screen-door transparency.Size and Number of the Point Samples: The numberof primitives to be generated depends onα and the surfacearea. Since these two quantities do not change, the prim-itives can be generated as a pre-process. All the chosenprimitives are opaque (α = 1) and the rest of the area istotally transparent(α = 0). This static sampling has a dis-advantage. In the worst case, the viewpoint can be such thatone singe (opaque) primitive covers the whole image planegenerating incorrect images. Hence the primitives shouldbe sampled during run-time, and the size of the primitivesshould be dependent on the distance of the triangle(object)from the viewpoint. The optimum size of the primitive iswhen it covers just one pixel on the screen. The numberof generated primitives is dictated by this chosen size of aprimitive, the value ofα, and the actual area of the poly-gon(object).Randomness of Primitive Selection:The choice of prim-itives on the surface should be uniformly random for ourtheory to work correctly in practice. We choose primi-tives in two different ways: by software and by using alphamasks on the triangle in the object space. While choos-ing primitives by software, we use pseudo-random numbergenerator. In our hardware-assisted implementation, wegenerate the alpha-mask using a (pseudo-) random patternof ones and zeros and thus randomize the primitive selec-tion from the object.

Image-space screen-door transparency runs the risk ofrejecting all primitives falling on a pixel, if the same image-space mask is used for all objects (with sameα value).Such methods avoid this problem by randomly choosing

155

mask from a set of pre-generated masks for eachα value.In our method we have only one mask for eachα value.In our method, we do not face this problem as the maskand selection of primitives are in object space rather thanin screen space.Size of Supersampling Kernel: The size supersamplingkernel should be large enough to accommodate the requirednumber of pixels generated by all the transparent objectsthat fall in that region. This size is based on theα valuesof all these objects and the transparent depth complexity(that is, the depth complexity till the first opaque objectfrom the viewpoint). If we assume an 8-bit representationof α, then we found thatn = 256 = 16 × 16 would bemore than sufficient for most practical purposes. All resultsshown in this paper, including the implementation of otheralgorithms, are generated with this kernel size.

4 Implementation Details

In this section, we describe two algorithms to demonstratethe concept ofobject-space screen door transparency. Oneis a software implementation, and the other a hardware as-sisted method. In both these implementations, we will dis-cuss how the vital decision parameters explained in the pre-vious section are taken into account.

4.1 Software Implementation

In this method, we discretize the triangles using point prim-itives. The number of samples, the choice of samples,and the generation of these samples form the core of ourmethod. In the final step, the high-resultion image we gen-erate is filtered to an image of required size.

4.1.1 Size and Number of Point Primitives

Since we use object-space sampling, the sampling shouldbe independent of the orientation of the triangle. But as wediscussed earlier, it should be dependent on the distance ofthe triangle from the viewpoint. Further, the size of thepoint should be approximately equal to the pixel size in thesuper-sampled image.

(Figure 2)Given three vertices of the triangle in theobject space, we find the closest distance of the trianglefrom the viewpoint. We calculate the screen space areaoccupied by that triangle at that distance, by rotating thetriangle to be parallel to the image plane. The number ofpixels in this projected area is the number of samples in thetriangle. This is calculated as follows:

n =(

Nhim

dh

)2

A

whereN is the distance of the near plane from the view-point, d is the distance to the centroid of the triangle fromthe viewpoint,him is the height of image in number of pix-els, h is the height of image in object space units, andA

is the area of the triangle in object space units. Clearly,this method of calculating the number of samples is inde-pendent of the orientation of the triangle, and is dependenton its distance from the viewpoint. Hence, this samplingis truly an object-space sampling. We useuv parameteri-zation of the triangle to equally distribute these primitives-to-be-generated on the object-space triangle. This achievesuniform object space sampling. Next step is to choose asubset of these uniform samples based onα.

4.1.2 Randomness

The number of chosen primitives is proportional toα of thetriangle. For eachuv parameterized coordinate of a trian-gle, a psuedo-uniform-random number is generated in therange of the transparency values. This random number iscompared with the transparency value of the triangle to de-cide whether theuv point under consideration should beopaque or transparent. This approach is equivalent to thatof using a dynamic random alpha mask mapped on theuvparameterization of a triangle.

4.1.3 Final Image Generation

As mentioned in Section 3, the generated points are ren-dered onto the high-resolution image using conventionaltechniques with Z-buffer being enabled. Then this imageis repeatedly filtered down to one-fourth its size using box-filtering. This technique is same as the one used for texturemip-map generation. Results on comparison of our tech-nique with other techniques are shown in Figures 1. Notethe silhouette-opacity effects in these images. Further, notethe artifacts in Figure 1 for rendering using stipple buffer.Even though this is a filtered image, these artifacts are dueto the mapping of many overlapping polygons to the samestipple map.

4.2 Hardware Accelerated Implementation

The basic idea of the algorithm is to take the help of texture-mapping hardware support for theuv parameterization.This is achieved as follows. As a preprocess, the trans-parency values are discretized and for each transparencylevel an appropriate alpha mask (with binary alpha valuesfor each texel) is generated. Each triangle is mapped onwith an alpha mask corresponding to itsα value. The trans-parent texels of the mask will produce the required numberof points on the triangle automatically. The rest of the ren-dering proceeds as in our software implementation (Section4.1). Note that, unlike the image-space screen-door trans-parency, generation of a single mask for each transparencylevel is sufficient for the object space. Further, the size ofthe mask when compared to the size of the triangle woulddictate the size and number of pixels generated on the trian-gle. Next section elaborates the details of finding this scaleto generate appropriate number of samples.

156

Figure 2. The left image shows diagram for computing the number of samples in a triangle in our software implementation.The right image shows the diagram used in our hardware assisted method.

4.2.1 Size and Number of Pixels

The scale of the texture with respect to the triangle can becontrolled by changing the texture coordinates assigned tothe triangle vertices. The texture coordinates of the verticesare computed such that each texel of the texture-mappedobject-space triangle covers approximately one pixel in theimage space when projected.

The computation of the texture coordinates for a maskis done as follows. (Figure 2)In the first step, the edge vec-tors of the triangle,~U and~V , are scaled to their projectedsizes after bringing the vectors parallel to the image plane,and they are transformed to image space units as,~Uim =

(Nhim

dh

)~U ; ~Vim =

(Nhim

dh

)~V

where ~Uim and ~Vim are in the image plane and in imagespace units. The next step is to transform the dimensionsto texture space units. As each texel corresponds to a pixelin the image, this transformation is performed simply byrescaling the vectors proportional to size of the mask innumber of texels.~Ut =

(1M

)~Uim; ~Vt =

(1M

)~Vim

whereM is the size of the mask in terms of number oftexels.

Last step is computing the texture coordinates for thetriangle points. The relationship between thest parame-terization of the texture and the vertices of the triangle isgiven as follows. Letk = ~Ut · ~Vt/| ~Ut|.~Cu =

(| ~Ut|, 0

); ~Cv =

(k,

√~Vt

2− k2

)where ~Cu and ~Cv are the texture coordinates of theverticesU andV , respectively (refer to Figure 2).

4.2.2 Randomness

The randomness in the opaque texels in the alpha mask pro-vides the randomness in the choice of object-space pointsamples. The generation of this random alpha mask is sim-ilar to that of the software implementation. For each texelin the alpha mask, a random number is produced and com-

Figure 3. Two random alphs masks forα = 0.5 (left) andα = 0.9 (right), both of size 128×128.

pared to the alpha level of the mask to decide whether thetexel should be transparent or opaque. As a result the num-ber of opaque texels is proportional to the alpha value andits distribution is (pseudo-)uniform. Example masks areshown in Figure 3.

5 Limitations

In both the algorithms, at the silhouettes, there are manysample-points that correspond to a single pixel in the im-age. However, in the hardware accelerated implementation,the silhouettes are not visible due to the limitations in thefilters available for texture mapping. At present, there aretwo types of filters provided for texture mapping:LinearandNearest. The Nearestfilter is used in the current al-gorithm which results in images without silhouettes. How-ever, this can be corrected if we have aMax filter that se-lects the maximum value among the available candidates.

The sampling of the object depends on the distance ofthe primitive from the viewpoint. This prohibits the use ofthese algorithms with large models.

157

6 Conclusion

In this paper we presented a new approach for order-independent transparency. The important problem that ourwork solves is thesilhouette-opacity, and we achieve thisusingobject-space screen-door transparency. Our methodis a probabilitic, single-pass method and the results are sig-nificantly better than the previous approaches. We have im-plemented our method using a software approach for sam-pling and a hardware assisted approach for sampling pointsfrom the surface of the object. We believe that this workwill renew the enthusiasm to improve the hardware capa-bilities for efficient and correct transparency rendering inthe future.

References

[1] Loren Carpenter. The a -buffer, an antialiased hid-den surface method. InProceedings of the 11th an-nual conference on Computer graphics and interac-tive techniques, pages 103–108, 1984.

[2] E. Catmull. A subdivision algorithm for computerdisplay of curved surfaces. InUniversity of Utah, SaltLake City, 1974.

[3] Franklin C. Crow. Shaded computer graphics in theentertainment industry. InComputer Magazine, pages10–22, 1978.

[4] S. J. Baker et al. Image generator for generatingperspective views from data defining a model hav-ing opaque and translucent features. InUnited StatesPatent Number 5,363,475, Nov 8, 1994.

[5] Cass Everitt. Interactive order-independent trans-parency. InTechnical report, NVIDIA Corporation.ACM Press, 2001.

[6] James D. Foley, Andries van Dam, Steven K. Feiner,and John F. Hughes.Computer Graphics, Principlesand Practice, Second Edition. Addison-Wesley, Read-ing, Masachusetts. Addison-Wesley, 1990.

[7] Henry Fuchs, Jack Goldfeather, Jeff P. Hultquist, Su-san Spach, John D. Austin, Jr. Frederick P. Brooks,John G. Eyles, and John Poulton. Fast spheres, shad-ows, textures, transparencies, and imgage enhance-ments in pixel-planes. InProceedings of the 12thannual conference on Computer graphics and inter-active techniques, pages 111–120. ACM Press, 1985.

[8] Norman P. Jouppi and Chun-Fa Chang. Z3: aneconomical hardware technique for high-quality an-tialiasing and transparency. InProceedings of the1999 Eurographics/SIGGRAPH workshop on Graph-ics hardware, pages 85–93. ACM Press, 1999.

[9] Douglas Scott Kay and Donald Greenberg. Trans-parency for computer synthesized images. InPro-ceedings of the 6th annual conference on Computergraphics and interactive techniques, pages 158–164,1979.

[10] Michael Kelley, Kirk Gould, Brent Pease, StephanieWinner, and Alex Yen. Hardware accelerated render-ing of csg and transparency. InProceedings of the21st annual conference on Computer graphics andinteractive techniques, pages 177–184. ACM Press,1994.

[11] Kevin Kreeger and Arie Kaufman. Mixing translucentpolygons with volumes. InProceedings of the con-ference on Visualization ’99, pages 191–198. IEEEComputer Society Press, 1999.

[12] Jin-Aeon Lee and Lee-Sup Kim. Single-pass full-screen hardware accelerated antialiasing. InProceed-ings 2000 SIGGRAPH/EUROGRAPHICS workshopon Graphics hardware, pages 67–75. ACM Press,2000.

[13] A. Mammen. Transparency and antialiasing algo-rithms implemented with the virtual pixel maps tech-nique. InIEEE Computer Graphics and Applications,pages 9(4):43–55, 1989.

[14] Jurriaan D. Mulder, Frans C. A. Groen, and Jarke J.van Wijk. Pixel masks for screen-door transparency.In Proceedings of the conference on Visualization ’98,pages 351–358. IEEE Computer Society Press, 1998.

[15] Thomas Porter and Tom Duff. Compositing digi-tal images. InProceedings of the 11th annual con-ference on Computer graphics and interactive tech-niques, pages 253–259, 1984.

[16] John Snyder and Jed Lengyel. Visibility sorting andcompositing without splitting for image layer decom-positions. InProceedings of the 25th annual con-ference on Computer graphics and interactive tech-niques, pages 219–230. ACM Press, 1998.

[17] Stephanie Winner, Mike Kelley, Brent Pease, BillRivard, and Alex Yen. Hardware accelerated ren-dering of antialiasing using a modified a-buffer al-gorithm. In Proceedings of the 24th annual con-ference on Computer graphics and interactive tech-niques, pages 307–316. ACM Press/Addison-WesleyPublishing Co., 1997.

[18] Craig M. Wittenbrink. R-buffer: a pointerless a-buffer hardware architecture. InProceedings of theACM SIGGRAPH/EUROGRAPHICS workshop on onGraphics hardware, pages 73–80. ACM Press, 2001.

158