Silhouette ClippingPedro V. Sander Xianfeng Gu Steven J. Gortler Hugues Hoppe John Snyder

Harvard University Microsoft Research

AbstractApproximating detailed models with coarse, texture-mappedmeshesresultsin polygonalsilhouettes.To eliminatethis artifact,we introducesilhouetteclipping, a framework for efficiently clip-ping the renderingof coarsegeometryto the exact silhouetteoftheoriginal model. Thecoarsemeshis obtainedusingprogressivehulls, a novel representationwith thenestingpropertyrequiredforproperclipping. We describeanimprovedtechniquefor construct-ing texture andnormalmapsover this coarsemesh. Given a per-spective view, silhouettesareefficiently extractedfrom theoriginalmeshusingaprecomputedsearchtree.Within thetree,hierarchicalculling is achieved usingpairsof anchoredcones. The extractedsilhouetteedgesareusedto setthehardwarestencilbuffer andal-phabuffer, which in turn clip andantialiastherenderedcoarsege-ometry. Resultsdemonstratethat silhouetteclipping canproducerenderingsof similar quality to high-resolutionmeshesin lessren-deringtime.Keywords: Level of Detail Algorithms, RenderingAlgorithms,TextureMapping,TriangleDecimation.

1 Intr oductionRenderingdetailedsurfacemodelsrequiresmany triangles,result-ing in a geometryprocessingbottleneck.Previouswork shows thatsuchmodelscanbereplacedwith muchcoarsermeshesby captur-ing the color andnormalfields of thesurfaceastexture mapsandnormalmapsrespectively [2, 3, 20,26]. Althoughthesetechniquesoffer a goodapproximation,the coarsegeometrybetraysitself inthepolygonalsilhouetteof therendering.This is unfortunatesincethesilhouetteis oneof thestrongestvisualcuesof theshapeof anobject[14], andmoreover thecomplexity of thesilhouetteis oftenonly O(

�n) on thenumbern of facesin theoriginalmesh.

In this paper, we introducesilhouetteclipping, a framework forefficiently clipping the renderingof coarsegeometryto the exactsilhouetteof theoriginal model.As shown in Figure1, our systemperformsthefollowing steps.

Prepr ocess Givenadenseoriginalmesh:� Build a progressivehull representationof theoriginalmeshandextract from it a coarsemesh,which has the property that itenclosestheoriginal,allowing properclipping (Section3).� Constructa texture mapand/ornormalmapover eachfaceofthe coarsemeshby samplingthe color and/ornormalfield oftheoriginalmesh(Section4).� Entertheedgesof theoriginal meshinto a searchtreefor effi-cientruntimeextractionof silhouetteedges(Section5).

http://cs.harvard.edu/��� pvs,xgu,sjg�http://research.microsoft.com/��� hoppe,johnsny �

normal map

silhouette clipped

Run

time

edge hierarchy

original mesh

rendered

coarse hull

Pre

proc

ess

2D silhouette

Figure1: Overview of stepsin silhouetteclipping.

Runtime Then,for a givenviewpoint:� Extractthesilhouetteedgesfrom thesearchtree(Section5).� Createa maskin the stencil buffer by drawing the silhouetteedgesastrianglefans. Optionally, draw theedgesagainasan-tialiasedlinesto setthealphabuffer (Section6).� Renderthecoarsemeshwith its associatedtexture/normalmaps,but clippedandantialiasedusingthestencilandalphabuffers.

Contrib utions Thispaperdescribes:� The framework of silhouetteclipping, wherebylow-resolutiongeometryis renderedwith a high-resolutionsilhouette.� A progressive hull datastructurefor representinga nestedse-quenceof approximatinggeometries.Within thesequence,anycoarsermeshcompletelyenclosesany finer mesh.� A new methodfor associatingtexel coordinateson the coarsemodel with positionson the original model. The associationis basedon the simple idea of shootingalong an interpolatedsurfacenormal.� A schemefor efficiently extracting the silhouetteedgesof amodelunderanarbitraryperspective view. It is inspiredby pre-viouswork on backfaceculling [13, 15], but usesa convenient“anchoredcone” primitive and a flexible n-ary tree to reduceextractiontime.

� An efficient techniquefor settingthestencilbuffer giventhesil-houette� edges.Specialcareis taken to overcomerasterizationbottlenecksby reducingtriangleeccentricities.� An improvementfor efficiently antialiasingthe silhouettewithlittle additionalcost.� Demonstrationsthatsilhouetteclipping producesrenderingsofsimilarquality to high-resolutionmeshesin lesstime.

Limitations� Only theexteriorsilhouetteis usedfor clippingandantialiasing.Internalsilhouettesretaintheir polygonalizedappearancefromthecoarsemodel.� As in othertexturemappingschemes,someminor textureslip-pingcanoccur, dependingon theaccuracy of thecoarsemodel.� Efficiency dependson a relative sparsityof silhouettes,andthereforebreaksdown for extremelyroughgeometrylike treesor fractalmountains.� The approachonly works for static models representedbyclosed,oriented,2-dimensionalmanifolds.� Thestencilsettingmethodassumesthattheviewpoint is outsidetheconvex hull of theoriginalmodel.

2 Previous WorkLevel of Detail/Simplification Level-of-detail (LOD) tech-niquesadaptmeshcomplexity to a changingview. The simplestapproachprecomputesa setof view-independentmeshesat differ-entresolutionsfrom whichanappropriateapproximationis selectedbasedonviewerdistance(seesurvey in [10]). A moreelaborateap-proach,termedview-dependentLOD [12, 18, 27], locally adaptstheapproximatingmesh.Areasof thesurfacecanbekeptcoarserifthey are outsidethe view frustum, facing away from the viewer,or sufficiently far away. In particular, the view-dependenterrormetric of Hoppe[12] automaticallyrefinesnearmeshsilhouettes.However, acascadeof dependenciesbetweenrefinementoperationscausesrefinementin areasadjacentto thesilhouette,increasingren-dering load. Also, the efficiency of thesesystemsrelieson time-coherenceof theviewing parameters.

With silhouetteclipping, fewer polygonsneedto be processedsincesilhouettesareobtainedasa 2D post-process.Antialiasingisachievedby processingonly thesilhouetteedgesratherthansuper-samplingtheentireframebuffer.

Texturing Maruya[20] andSoucy etal. [26] definetexturesovera coarsedomainby following invertible mappingsthrougha sim-plification process.Theshapeof thefinal parametrizationis influ-encedby thefairly arbitrarysequenceof simplificationsteps.

Cignoni et al. [2] describea simple method for defining aparametrizationusing only the geometryof the coarseand finemodels. Eachpositionon the coarsemodel is associatedwith itsclosestpoint on the fine model. This methodoften createsmap-ping discontinuitiesin concave regions (Figure 4). In Section4we presenta methodthatinsteadshootsraysalongtheinterpolatedsurfacenormal. Althoughnot guaranteedto producea one-to-onemapping,ourparametrizationhasfar fewer discontinuities.

Silhouette Extraction Silhouetteinformationhasbeenusedtoenhanceartisticrenderingsof 3D objects[6, 7,19]. Blytheetal. [1]describea multipassrenderingalgorithmto draw silhouettesin thescreen.Otherwork highlights the visible silhouetteby renderingthickenededges[24] or backfaces[23] translatedslightly towardstheviewpoint. Theseworksrequirethetraversalof theentiregeo-metricobject.

A numberof algorithmsexist for extracting silhouetteedgesfrom polyhedralmodels. Markosianet al. [19] describea proba-bilistic algorithm that testsrandomsubsetsof edgesandexploits

view coherenceto trackcontours.Their methodis not guaranteedto find all of thesilhouettecomponents,andis too slow for modelsof high geometriccomplexity. Goochet al. [7] extract silhouetteedgesefficiently usinga hierarchicalGaussmap. Their schemeisapplicableonly to orthographicviews, whereasoursworks for ar-bitrary perspective views.

Backface Culling Our methodfor fastsilhouetteextractionisinspiredby previous schemesfor fast backface culling. Kumaret al. [15] describean exact test to verify that all facesareback-facing. They reduceits largecostby creatinga memory-intensiveauxiliarydatastructurethatexploits frame-to-framecoherence.Jo-hannsenandCarter[13] improveonthisby introducingaconserva-tive, constant-timebackfacingtest. The testis basedon boundingthe “backfacingviewpoint region” with a constantnumberof halfspaces.In our systemwe usean even simpleranchoredconetestprimitive.

Johannsenand Carter do not addresshierarchyconstruction,while Kumaretal. build theirhierarchyusingadualspacegriddingthatdoesnotexplicitly takeinto accounttheextractioncost.Wede-scribea generalbottom-upclusteringstrategy, similar to Huffmantreeconstruction,thatis greedywith respectto predictedextractioncost. In the resultssectionwe report the advantageof usingourmethodover thatof JohannsenandCarter.

Silhouette Mapping Ourearliersystem[8] performssilhouetteclippingusinganapproximatesilhouette,obtainedusinginterpola-tion from afixednumberof precomputedsilhouettes.

3 Progressive HullIn order to be properlyclipped by the high-resolutionsilhouette,thecoarsemeshshouldcompletelyenclosethe original meshMn.In this sectionwe show how sucha coarsemeshcanbe obtainedby representingMn asa progressivehull — a sequenceof nestedapproximatingmeshesM0 ����� Mn, suchthat

(M0) (M1) ����� (Mn)

where

(M) denotesthesetof pointsinterior to M. A relatedcon-structionfor thespecialcaseof convex setswasexploredin [4].

Interior volume To defineinterior volume,we assumethatMn

is orientedandclosed(i.e. it hasnoboundaries).In mostcases,it isrelatively clearwhich pointslie in

(M). Thedefinitionof interior

is lessobvious in the presenceof self-intersections,or whensur-facesarenested(e.g.concentricspheres).To determineif a pointp � R3 lies in

(M), selecta ray from p off to infinity, andfind all

intersectionsof theray with M. Assumewithout lossof generalitythat the ray intersectsthe meshonly within interiorsof faces(i.e.notonany edges).Eachintersectionpoint is assignedanumber, +1or � 1, equalto the signof the dot productbetweenthe ray direc-tion andthe normalof the intersectedface. Let thewinding num-ber wM(p) be the sumof thesenumbers[22]. Becausethe meshis closed,it canbeshown thatwM(p) is independentof thechosenray. To properlyinteractwith thestencilalgorithmdescribedlaterin Section6, we defineinterior volumeusingthepositivewindingrule as

(M) = p � R3 : wM(p) � 0� . Notethatthis description

only definesinteriorvolume;it is notusedin actualprocessing.

Review of progressive mesh Theprogressive hull sequenceis an adaptationof the earlierprogressivemesh(PM) representa-tion [11] developedfor level-of-detailcontrolandprogressivetrans-missionof geometry. ThePM representationof a meshMn is ob-tainedby simplifying themeshthrougha sequenceof n edge col-lapsetransformations(Figure3), thusdefininga densefamily ofapproximatingmeshesM0 ����� Mn.

For thepurposeof level-of-detailcontrol,edgecollapsesarese-lectedsoasto bestpreservetheappearanceof themeshduringsim-plification(e.g.[3, 10, 11,17]). Weshow thatproperconstraintson

M0 (40 faces) M30 (100faces) M80 (200faces) M230 (500faces) M980 (2,000faces) Original meshMn�

M0

(38 faces) M31

(100faces) M81

(200faces) M231

(500faces) M981

(2,000faces) Original meshMn

Figure2: Exampleof progressive innerandouterhulls. Theoriginal meshhas69,674faces;n� =34,817;n=34,818.

ecol

v

M i

facesF i

M i+1

facesF i+1

Figure3: Theedgecollapsetransformation.

theselectionof edgecollapsetransformationsallow thecreationofPM sequencesthatareprogressive hulls.

Progressive hull construction For the PM sequenceto bea progressive hull, eachedgecollapsetransformationMi+1 � Mi

mustsatisfytheproperty

(Mi ) (Mi+1). A sufficient conditionis to guaranteethat,atall pointsin space,thewindingnumbereitherremainsconstantor increases:�

p � R3 , wMi+1(p) � wMi (p) .

Intuitively, the surface must either remain unchangedor locallymove outwardseverywhere.

Let F i+1 andF i denotethesetsof facesin the neighborhoodoftheedgecollapseasshown in Figure3, andlet v bethepositionoftheunifiedvertex in Mi . Foreachfacef � F i+1, weconstrainv to lieoutsidetheplanecontainingfacef . Notethat theoutsidedirectionfrom a faceis meaningfulsincethemeshis oriented.Theresultingsetof linearinequalityconstraintsdefinesa feasiblevolumefor thelocationof v. The feasiblevolumemay be empty, in which casetheedgecollapsetransformationis disallowed.Thetransformationis alsodisallowed if eitherF i or F i+1 containself-intersections1. Ifv lies within the feasiblevolume, it can be shown that the facesF i cannotintersectany of the facesF i+1. Therefore,F i � flip(F i+1)formsasimplyconnected,non-intersecting,closedmeshenclosingthedifferencevolumebetweenMi andMi+1. Thewinding numberw(p) is increasedby 1 within this differencevolumeandremainsconstanteverywhereelse.Therefore,

(Mi) (Mi+1).

Thepositionv is foundwith alinearprogrammingalgorithm,us-ing theabove linearinequalityconstraintsandthegoal functionofminimizingvolume.Meshvolume,definedhereas �

p � R3 wM(p)dp,

1We currently hypothesizethat preventing self-intersectionsin Fi andFi+1 maybeunnecessary.

is a linear functionon v that involvesthe ring of verticesadjacentto v (referto [9, 17]).

As in earlier simplification schemes,candidateedgecollapsesare enteredinto a priority queueaccordingto a cost metric. Ateachiteration,the edgewith the lowestcost is collapsed,andthecostsof affectededgesarerecomputed.Variouscostmetricsarepossible.Weobtaingoodresultssimplyby minimizingtheincreasein volume,whichmatchesthegoalfunctionusedin positioningthevertex.

Inner and outer hulls The algorithm describedso far con-structsa progressiveouter hull sequenceM

0 ����� Mn. By

simply reversingtheorientationof the initial mesh,thesamecon-structiongives rise to an progressiveinner hull sequenceM0 �������� Mn� . Combiningtheseproducesa singlesequenceof hulls

M0 ��������� Mn� = Mn ��������� M

0

that boundsthe original meshfrom both sides,as shown in Fig-ure2. (Althoughthesurfacesometimesself-intersects,interiorvol-umedefinedusingthewinding numberrule is still correct.)

We expectthat this representationwill alsofind usefulapplica-tionsin theareasof occlusiondetectionandcollisiondetection,par-ticularly usinga selective refinementframework [12, 27].

4 Texture CreationAs in [2, 20, 26], we createa texturetile over eachfaceof thesim-plified mesh,andpackthesetiles into a rectangulartexture image.As illustrated in Figure 1, all tiles are right trianglesof uniformsize.Theproblemof texturecreationis to fill thesetilesusingtexelvalues(colors or normals)sampledfrom the original mesh. In-spiredby Cignonietal. [2], ourapproachconstructsaparametriza-tion from thesimplifiedmeshto theoriginal meshbasedsolelyontheir geometries(i.e. independentof thesimplificationalgorithm).WhereasCignonietal. useaclosest-pointparametrization,webaseour parametrizationon a normal-shootingapproach,which signifi-cantlyreducesthenumberof discontinuitiesin theparametrization(seeFigures4 and5).

Giventheoriginalmeshanda triangleT of thesimplifiedmesh,we must determinehow to calculatethe valuesassignedto eachtexel. Our normal-shootingalgorithmperformsthefollowing stepsto computethecolor or normalat eachtexel t of T:

coarse

original

closest-point

coarse

original

vertex normal

normal-shooting

Figure4: Closest-pointparametrizationoftenproducesdiscontinu-itiesnotpresentwith normal-shooting.

(a) originalmesh (b) closest-point (c) normal-shooting

Figure 5: Comparison of texturing the coarse mesh us-ing the closest-pointparametrizationand our normal-shootingparametrization.Notetheparametricdiscontinuitiesin theconcaveregionsfor closest-point.� Calculatethebarycentriccoordinatesof t within thetriangleT.� Calculatethepositionp andnormal �n by interpolatingtheposi-

tionsandnormalsof theverticesof T.� Shoota ray from p in the ���n direction. This ray will intersecttheoriginal meshat a particularpoint q. In theextremelyrareevent of a ray failing to hit the original model,we insteadusetheclosestpoint to p.� Giventhetriangleandbarycentriccoordinatesof q in theorigi-nalmodel,interpolatetheprelit coloror normalof its threever-tices,andstoretheresultin t.

We adjustthesamplingresolutionon thetexturetilesdependingon thecomplexities of theoriginal andsimplifiedmeshes.For themodelsin Section7, we sampled512texelspercoarsefaceon thebunny andholes,but only 128 texels on thedragon,parasaur, andknot sincethesehave many morecoarsefaces.Theseresolutionsareenoughto capturethe desiredlevel of detail. To allow bilin-earinterpolationon theresultingtexture,we appropriatelypadthetriangletexturetiles.

5 Fast Silhouette ExtractionWeconsidereachgeometricedgein themeshto consistof apairofopposite-pointingdirectededges. For a givenmeshandviewpointp, the3D silhouetteis thesubsetof directededgeswhoseleft adja-centfaceis frontfacingandwhoseright adjacentfaceis backfacing.More formally, a directededgee is on thesilhouetteif andonly if

p � frontfacing(e. f1) and p �� frontfacing(e. f2),

wheretheregion

frontfacing(f ) = p � R3 � (p � f .v) � f . �n � 0�in which f .v is any vertex of f , andf . �n is its outwardfacingnormal.

Runtime Algorithm Applying this testto all edgesin a brute-force mannerproves to be too slow. Instead,our approachis toenterthe edgesinto a hierarchicalsearchtree, or more properly,a forest. Eachnodein the forestcontainsa (possiblyempty) listof edgesto test. Let the faceclusterF(n) for a noden be the setof facesattachedto edgescontainedin that nodeandin all of itsdescendants.If for a given viewpoint we can determinethat thefacesin F(n) areentirely frontfacingor entirely backfacing, then

noneof theedgescontainedin thenode’ssubtreecanbesilhouettes,and thus the depth-firsttraversalskips the subtreebelow n. Thebasicstructureof thealgorithmis asfollows:

procedure findSilhouetteEdges(noden, viewpoint p)if ( p � frontfacing(F(n)) or p � backfacing(F(n)) )

return; // skipthis subtreefor edgese in n.E

if ( p � frontfacing(e. f1) and p �� frontfacing(e. f2) )output(e);

for childrenc in n.CfindSilhouetteEdges(c,p);

The frontfacingandbackfacing regionsof a faceclusterF aredefinedas

frontfacing(F) = f � F

frontfacing(f ) and

backfacing(F) = f � F

frontfacing(f ) .

To make hierarchicalculling efficient, we needa fast,constant-time algorithmto conservatively testp � frontfacing(F) andp �backfacing(F). We do this by approximatingtheseregionsusingtwo open-endedanchoredcones, af andab, satisfying

af ! frontfacing(F) and ab ! backfacing(F)

as shown in Figure 6. Eachanchoredconea is specifiedby ananchororigin a.o, normala. �n, andconeanglea. " . Theconstructionof theseconeswill bepresentedshortly.

Eachregion testthenreducesto

p � a # cos$ 1 % p � a.o&p � a.o

& � a. �n ')( a. " .

For efficiency andto reducestorage,we storein our datastruc-ture thescalednormala. �ns = a. �n * cos(a. " ). With carefulprecom-putation,theabovetestcanbethenimplementedwith two dotprod-uctsandno squarerootsor trigonometricoperations,via

p � a # (p � a.o) � a. �ns � 0 and+(p � a.o) � a. �ns , 2 � &

p � a.o& 2 .

Becausewe constructaf andab to have the sameconeangleandoppositeconenormals,we cantestfor inclusionin bothanchoredconeswith just two dotproducts.This is madepossibleby precom-putingandstoringthe“anchorseparation”d = (af.o � ab.o) � af. �n.For reference,thefinal nodedatastructureis:

struct nodevectorscaledNormal; // �ns

point ffAnchor; // af .opointbfAnchor; // ab.ofloatAnchorSeparation; // dedgeListE;childPointerListC;

Anc hored Cone Construction We first find theconehavingthe largestangle " insidethe frontfacingregion. It canbe shownthatthecentralaxis �n of sucha conehasthefollowing property:ifoneassociatesa point on theunit spherewith eachfacenormalinthecluster, andcomputesthe3D convex hull of thispointset,�n mustpassthroughthe closestpoint from the origin to that convex hull.We thereforeuseGilbert’s algorithm[5] which directly finds thisclosestpoint in linear time. (Note thatan open-endedconeexists

af .n

af .o

ab .o

(θ = af .θ = ab .θ )θ

θ θ

θ

ab .n = -af .n

Figure 6: Anchoredconesprovide conservative boundson thefrontfacingandbackfacingregionsof asetof faces,illustratedherein 2D for the4 orientedline segmentsin blue.

a b parent(a,b) adopt(a,b) merge(a,b)

Figure7: Thethreejoin operations.

if and only if the convex hull doesnot containthe origin.) Thelargestconeangle " is theneasilycomputedasthecomplementofthemaximumanglefrom �n to thesetof facenormals.In fact, " isalsothe complementof the angulardistanceof �n to any vertex intheclosestsimplex foundby Gilbert’salgorithm.

For a givennode,weassign

af . �n = � ab. �n = �naf . " = ab. " = " .

We then find the bestconeorigins, af .o andab.o, by solving thelinearprograms

af .o = argmino � frontfacing(F)

�n � o and ab.o = argmino � backfacing(F)

�-�n � o .

Tree Construction We construct our trees in a bottom-upgreedyfashionmuch like the constructionof Huffman trees. Webegin with a forestwhereeachedgeis in its own node.Givenanytwo nodes(a,b), we allow the following threejoin operations(seeFigure7).� parent(a,b): createsanew nodewith two childrena andb.� adopt(a,b): givesnodeb to nodea asanadditionalchild node.� merge(a,b): createsa new nodewhoseedgeandchild lists are

theunionof thosefrom a andb.

Giventhesepossiblejoin operations,thealgorithmis asfollows:

ForestbuildOptimalForest(Forestforest)candidates= buildJoinCandidates(forest);candidates.heapify();while (joinOp= candidates.removeTop())

if ( joinOp.cost � 0 ) break;forest.applyJoin(joinOp);candidates.updateCosts(joinOp);

return forest;

Candidatejoin operationsareorderedin the heapby their pre-dicteddecreasein silhouetteextractioncost.Thesilhouetteextrac-tion costis computedasfollows.

Thecostof a forestis simply thesumof thecostsof its roots:

forestCost= .r

rootCost(r) .

Thecostof a root nodeis someconstantka for theanchoredconetests,plusthepossiblecostof testingits edgesandits children:

rootCost(r) = ka + P(r) / ke� r. E � + .

c � r.C

nodeCost(c, r � ) 0 ,

whereke is thecostfor testinganedge,andP(r) is theprobabilityof thenoder notbeingculled2. To computeP(r), onemustassumesomeprobability distribution over the viewpoints. We assumeauniformdistributionover a largesphereU, in whichcase

P(r) =vol(U � r.af � r.ab)

vol(U).

The costof a non-rootnoden with ancestorsetA is computedrecursively as:

nodeCost(n, A) = ka+P(n � A) / ke� n. E � + .

c � n.C

nodeCost(c, n� � A)0whereP(n � A) is theprobabilityof thenoden notbeingculledgiventhat its ancestorsA werealsonot culled. If oneassumesthatbothanchoredconesof a child arecontainedin its parent’s, then

P(n � A) =vol(U � n. af � n. ab)vol(U � p. af � p. ab)

wherep is n’s immediateparent.While this containmentmustbetrue of a node’s respective frontfacing andbackfacing regions, itis not necessarilytrue for their approximatinganchoredcones.Inpractice,numericalexperimentshave shown this approximationtobereasonable.

In principle onemight considerall n2 pairs of forest roots forcandidatejoin operations.For computationalefficiency during thepreprocess,we limit thecandidatesetin thefollowing way. A can-didategraphis initialized with a graphvertex for eachroot in theinitial forest,eachrepresentinga singlemeshedge. Two verticesin thegrapharelinkedif their correspondingmeshedgessharethesamemeshvertex, or if adjacentmeshfaceshave normalswithinan angularthreshold3. Then during tree construction,when tworootsarejoined,theirverticesandlinks aremergedin thecandidategraph.

6 Stencil SettingThe 3D silhouetteextractedin the previous sectionis a setof di-rectededges. Sincethe meshis closedand the silhouetteedgesseparatefrontfacingtrianglesfrom backfacingones,thenumberofsilhouetteedgesadjacentto any vertex mustbeeven.Thereforetheedgescanbeorganized(non-uniquely)into asetof closedcontours.Eachsuchcontourprojectsinto theimageplaneasanoriented2Dpolygon,possiblywith many loops,andpossiblyself-intersecting.The winding numberof this polygonat a 2D imagelocationcor-respondsto the numberof frontfacingsurfacelayersthat areseenalongtheray from theviewpoint throughthat imagelocation[19].Our approachis to accumulatethesewinding numbersin thehard-warestencilbuffer for all contoursin the3D silhouette.Then,weclip thecoarsegeometryto theexternalsilhouetteof theoriginalge-ometryby only renderingthecoarsemodelwherethestencilbuffervaluesarepositive.

2Wehave foundthatsettingka 1 ke = 41 3 givesusthebestresults.3In practicewehave foundthatignoringsimilarity of normals(i.e.,only

consideringmeshproximity) still providessearchtreesthat arealmostasgood,with far lesspreprocessingtime.

(a) originalmesh (b) binarystencil (c) alphamatte

Figure8: Comparisonof renderingthe bunny earusingthe orig-inal mesh(69,674facemodel),andusinga coarsehull (500 facemodel)whosesilhouetteis (b) clippedto thestencilbuffer and(c)antialiasedusingthealphabuffer.

Basic Algorithm The directedsilhouetteedgesare organizedinto closedcontoursusinga hashtable. (For eachdirectededge,the hashkey is the vertex index of the sourcevertex.) In ordertorenderthewinding numberof eachcontourinto thestencilbuffer,we usea variationof thestandardstencilalgorithmfor filling con-cavepolygons[21]. Eachedgecontouris drawn asafanof trianglesaboutanarbitrarycenterpoint,which we chooseto bethe3D cen-troid of thecontourvertices.Theorientationof eachtriangledeter-mineswhetherits renderedpixelsincrementor decrementthesten-cil buffer values.To avoid testingtriangleorientationsin theCPU,weinsteadrenderthetrianglestwice,first with backfacecullingandstencilmodesetto increment,andthenwith frontfaceculling andstencilmodesetto decrement,asshown in thepseudocodebelow.Thetrianglesaredrawn astrianglefansfor efficiency.

procedure setStencil(contoursC, viewpoint p)setStencilToZero(boundingBox(C));cullFace(BACKFACE);for contoursc in C

point q = centroid(c. E);for edgese in c. E

trianglet = makeTriangle(q, e.v1, e.v2);rasterizeToStencil(t, INCREMENT);

cullFace(FRONTFACE);for contoursc in C

point q = centroid(c. E);for edgese in c. E

trianglet = makeTriangle(q, e.v1, e.v2);rasterizeToStencil(t, DECREMENT);

setDrawingToPositiveStencil();

Although the graphicshardwareclips triangle fansto the viewfrustum,thesetStencilalgorithmremainscorrectevenif partsof themodellie behindtheviewer, aslong astheviewer remainsoutsidetheconvex hull of theobject.This canbetrackedefficiently by thetestusedin [25].

Loop Decomposition The basic algorithm describedso fartendsto draw many long, thin triangles.On many rasterizingchips(e.g.NVIDIA ’s TNT2), thereis a largepenaltyfor renderingsucheccentrictriangles. It is easyto show that the setStencil algorithmbehavesbestwhenthescreen-spaceprojectionof q hasa y coordi-nateat the medianof the contourvertices. Choosingq asthe 3Dcentroidof thecontourverticesservesasa fastapproximation.

To further reducetheeccentricityof the fan triangles,we breakup eachlarge contourinto a setof smallerloops. More precisely,we pick two verticeson the contour, addto thedatastructuretwoopposingdirectededgesbetweenthesevertices,andproceedasbe-foreon thesmallerloopsthusformed.

Whentestedwith theNVIDIA ’sTNT2, loopdecompositiongavespeedupsof upto a factorof 2.3onmodelsthatarerasterboundonthestencilsettingstage.

Model Bunny Dragon Parasaur Knot Holes3Model complexities (numberof faces)

Originalmesh 69,674 400,000 43,886 185,856 188,416Coarsehull 500 4,000 1,020 928 500

Systemtimings(milliseconds)Original rendering 34.7 204.7 20.63 81.12 90.3Silhouetteextraction 4.5 24.2 4.0 6.5 4.0Stencilsetting 2.7 21.5 2.0 2.8 1.0Coarserendering 4.8 5.2 4.9 4.9 4.4Total2 7.8 50.3 6.9 10.3 5.5Speedupfactor 4.4 4.1 3.0 7.9 16.4(Antialiasing) +3.0 +22.5 +2.9 +3.4 +1.5

Table1: Timings of stepsin our silhouetteclipping scheme,andcomparisonwith renderingthe original mesh. 2 Total frametimesarelessthanthesumdueto parallelismbetweenCPUandgraphics.

Model Bunny Dragon Parasaur Knot Holes3Total faces 69,674 400,000 43,866 185,856 188,416Totaledges 104,511 600,000 65,799 278,784 282,624

SilhouetteextractionstatisticsSilhouetteedges 3,461 23,493 3,227 3,291 1,737Testededges 10,256 67,934 10,938 13,134 5,976Testednodes 4,282 26,291 3,538 7,926 4,594

Silhouetteextractiontimes(milliseconds)Our searchtree 4.1 28.2 4.3 6.4 3.3Brute-force 20.4 117.3 12.5 50.6 51.4Speedupfactor 5.0 4.2 2.9 7.9 15.6

Table2: Statisticsof oursilhouetteextractionalgorithm.

0

5

10

15

20

25

0 1000 2000 3000 4000

Average silhouette edges extracted

Silh

ouet

te e

xtra

ctio

n tim

e (m

illise

cond

s)

Brute-force

Anchored cone

Figure9: Comparisonof theaveragesilhouetteextractiontimewithour algorithmandthebrute-forcealgorithm,usingbunny approxi-mationswith 500,4,000,20,000,50,000,and69,674faces.

Antialiasing Althoughmany graphicssystemscanantialiaslinesegments,triangleantialiasingrequiresframebuffer supersamplingwhich slows renderingexcepton high-endworkstations.As a re-sult, the silhouettetypically suffers from aliasing artifacts (Fig-ure8a).Thestencilbuffer algorithmdescribedin theprevioussec-tion createsa binary pixel mask,thereforethecoarsemeshclippedto this maskexhibits thesamestaircaseartifacts(Figure8b).

We can antialias the silhouetteby applying line antialiasingon the silhouettecontour. First, the silhouetteedgesare ren-dered as antialiasedline segments into the alpha buffer (usingglBlend(GL ONE,GL ZERO)). Second,the stencil buffer is computedas in the previous section. This binary stencil is then transferredto the alpha buffer, i.e. pixels interior to the silhouetteare as-signedalpha valuesof 1. Finally, the low-resolutiongeometryis renderedwith thesealphabuffer valuesusing the over opera-tion (glBlend(GL DST ALPHA,GL ONE MINUS DST ALPHA)). The resultis shown in Figure8c. As thetimings in Table1 reveal,silhouetteantialiasingaddslittle to theoverall time. Notethatantialiasedsil-houetteclippingon multiple modelsinvolvesthenon-commutativeover operation,andthusrequiresvisibility sorting[25].

(a) originalmesh (b) simplifiedmesh(nothull) (c) silhouette-clippedcoarsehull

Figure10: Comparisonof renderingthe original mesh,a normal-mappedsimplified meshwithout the progressive hull constraints,andacoarsehull with thesamenumberof facesbut with silhouetteclipping.

7 Results

Wetestedour framework on thefive modelsof Table1. Thebunnyanddragonarefrom 3D scansat StanfordUniversity. (Thedragonwas simplified to 400,000faces;the four boundariesin the baseof the bunny were closed.) The parasauris from the Viewpointlibrary. The3-holedtorusandknot aresubdivision surfacestessel-latedfinely to obtainanaccuratesilhouette.We usednormalmapsfor all of ourexamples.

Preprocessingamodelconsistsof building acoarsehull, thenor-mal and/ortexturemap,andtheedgesearchstructures.This takesbetween30minutesand5 hoursdependingonmodelcomplexity.

Wehavefocusedoureffort onoptimizingtheruntimealgorithm.Timesfor thesubstepsof our schemeareshown in Table1. Theseareobtainedon a PC with a 550MHz PentiumIII anda CreativeLabsAnnihilator256graphicscardbasedontheNVIDIA GeForce256GPU.Theexecutiontimesrepresentaveragesover many ran-dom views of themodels.Note that theexpenseof extractingsil-houetteedgesis significantly reduceddueto parallelismbetweentheCPUandGPU.For instance,silhouetteextractionis nearlyfreefor the bunny. We compareour approachof silhouette-clippingacoarsehull with renderingtheoriginal mesh,andfind speedupsofapproximately3 to 16. For renderingboththecoarsehulls andtheoriginalmeshes,we useprecomputedtrianglestrips.

Figure10 comparesthe imagequality of the silhouette-clippedcoarsehull with a simplifiedmeshof thesamecomplexity andtheoriginal mesh. Figure 11 indicatesthat given a fixed amountofresources,oursystemcanrenderamodelwith asilhouetteof muchhigherresolutionthanthebrute-forcemethod.

As shown in Table2, our hierarchicalculling schemeresultsinexplicit silhouettetestingof only a smallfractionof theedges,par-ticularly on the smoothmodels. In all cases,our extraction timeis much lower than the brute-forceapproachof explicitly testingall edges.It works muchlike a quadtreesearchalgorithm,whichcanfind all cells that toucha line in O(

�n) time. Figure9 shows

this comparisonasa function of silhouettecomplexity for severalsimplifiedbunny meshes.Thegraphindicatesthatthetime for ouralgorithmincreaseslinearlyonthenumbermof silhouetteedgesinthe model,whereasthe brute-forcetime increaseslinearly on thetotalnumbern of edges,which in thiscaseis quadraticonm.

We implementedJohannsenandCarter’s backfaceculling algo-rithm andmodifiedit to extract silhouettes,in orderto compareitwith oursilhouetteextractionscheme.For thiscomparisonwemea-suredcomputationbasedon the numberof edgesexplicitly testedandnodestraversed.We did not usewall-clock time becauseourimplementationof JohannsenandCarterwasnotoverly optimized.For bunnieswith 500,4000,20,000,50,000,and69,674faces,ourspeedupfactorswere1.1,1.3,1.5,2.0,and2.1,respectively.

8 Summar y and Future WorkWehaveshown thatsilhouetteclipping is apracticalframework forrenderingsimplifiedgeometrywhile preservingtheoriginal modelsilhouette.Theoperationsof extractingsilhouetteedgesandsettingthestencilbuffer canbe implementedefficiently at runtime. Withlittle addedcost,silhouetteclipping alsopermitsantialiasingof thesilhouette,a featurepreviously available only throughexpensivesupersampling.Severalareasfor futurework remain.

0

5000

10000

15000

20000

0 10000 20000 30000 40000 50000 60000 70000

Silhouette clipping (# faces)

Bru

te-f

orce

(#

face

s)

Bunny

Holes

Silhouette Clipping Brute-force

Figure11: Comparisonbetweensilhouetteclippingandbrute-forcerendering.The x-axis representsthe resolutionof the modelusedfor silhouetteextraction.Theresolutionof thecoarsehull wasfixedat500faces.Thecurvesrepresentconfigurationsthattakethesameamountof timeto render. Thestarrepresentstheconfigurationusedin thebunny earexampleshown above.

Thecomplexity of theextractedsilhouetteshouldbeadaptedtotheview, sinceit is obviously unnecessaryto extract thousandsofedgesfrom an objectcovering a few pixels. Given a setof LODmeshes,our framework canusethesefor silhouetteextractionbycreatingfor eachonea correspondingcoarserhull. Alternatively,all of thesilhouettemeshesandtheir associatedcoarsehulls couldbe extractedfrom a single progressive hull. A relatedidea is toperformhigher-orderinterpolationonthesilhouetteusingprojectedderivativesor curvaturesin additionto 2D points.Thiswouldresultin smoothersilhouetteswithoutextractingmoresilhouetteedges.

Currently, silhouetteclipping only improves the appearanceofexterior silhouettes. We have consideredseveral approachesfordealingwith interior silhouettes.Onepossibility is to exploit thewinding numbercomputedin thestencilbuffer. Anotherapproachpartitionsthemeshandappliessilhouetteclipping to eachpiecein-dependently. We have performedinitial experimentsalong theselines,but have notyetobtaineda satisfactorysolution.

Sincetheexteriorsilhouetteof ashapeis determinedby its visualhull [16], silhouetteextractionis unaffectedby any simplificationof theoriginal meshthatpreservesits visualhull. As anexample,the interior concavity of a bowl canbesimplifieduntil it spansthebowl’s rim. Suchsimplificationoffers an opportunityfor furtherreducingsilhouetteextractioncost.

Ackno wledgments

For the modelswe would like to thank StanfordUniversity andViewpoint DataLabs.We would also like to thank the MIT Lab-oratoryfor ComputerSciencefor useof their equipment.Thefirstthreeauthorshave beensupportedin partby theNSF, SloanFoun-dation,andMicrosoftResearch.

References[1] BLYTHE, D., GRANTHAM , B., NELSON, S., AND MCREYNOLDS,

T. AdvancedgraphicsprogrammingtechniquesusingOpenGL.availfrom www.opengl.org.

[2] CIGNONI , P., MONTANI , C., ROCCHINI , C., AND SCOPIGNO, R. Ageneralmethodfor preservingattribute valueson simplifiedmeshes.In Visualization’98 Proceedings, IEEE,pp.59–66.

[3] COHEN, J., OLANO, M., AND MANOCHA , D. Appearance-preservingsimplification.SIGGRAPH’98, 115–122.

[4] DOBKIN, D. P., AND K IRKPATRICK , D. Determiningtheseparationof preprocessedpolyhedra–aunifiedapproach.ICALP-90,LNCS443(1990),400–413.

[5] GI LBERT, E. G., JOHNSON, D., AND KEERTHI , S. A FastProce-durefor ComputingtheDistanceBetweenComplex Objectsin Three-DimensionalSpace. IEEE Journal Of Roboticsand Automation, 2(April 1988),193–203.

[6] GOOCH, A ., GOOCH, B., SHIRLEY, P., AND COHEN, E. A Non-PhotorealisticLighting Model for Automatic TechnicalIllustration.SIGGRAPH98, 447–452.

[7] GOOCH, B., SLOAN, P., GOOCH, A ., SHIRLEY, P., AND RIESEN-FELD, R. Interactive TechnicalIllustration. ACM Symposiumon In-teractive3D graphics1999, 31–38.

[8] GU, X ., GORTLER, S., HOPPE, H., MCM I LLAN, L ., BROWN, B.,AND STONE, A . SilhouetteMapping. TechnicalReportTR-1-99,Departmentof ComputerScience,HarvardUniversity, March1999.

[9] GUEZIEC, A . Surfacesimplificationwith variabletolerance.In Pro-ceedingsof theSecondInternationalSymposiumonMedicalRoboticsandComputerAssistedSurgery (November1995),pp.132–139.

[10] HECKBERT, P., AND GARLAND, M. Survey of polygonalsurfacesimplificationalgorithms. In Multiresolutionsurfacemodeling(SIG-GRAPH’97 Coursenotes#25). ACM SIGGRAPH,1997.

[11] HOPPE, H. Progressive meshes.SIGGRAPH’96, 99–108.

[12] HOPPE, H. View-dependentrefinementof progressive meshes.SIG-GRAPH’97, 189–198.

[13] JOHANNSEN, A ., AND CARTER, M. B. ClusteredBackfaceCulling.Journal of GraphicsTools3, 1 (1998),1–14.

[14] KOENDERINK , J. J. What doesthe occludingcontourtell us aboutsolid shape.Perception13 (1984),321–330.

[15] KUMAR, S., MANOCHA , D., GARRETT, W., AND L IN, M. Hier-archicalBack-FaceComputation.EurographicsRenderingWorkshop1996, 235–244.

[16] LAURENTINI , A . Thevisualhull conceptfor silhouettebasedimageunderstanding.IEEEPAMI 16, 2 (1994),150–162.

[17] L INDSTROM , P., AND TURK , G. Fastandmemoryefficientpolygonalsimplification. In Visualization’98 Proceedings, IEEE,pp.279–286.

[18] LUEBKE, D., AND ERIKSON, C. View-dependentsimplificationofarbitrarypolygonalenvironments.SIGGRAPH’97, 199–208.

[19] MARKOSIAN, L ., KOWALSKI , M., TRYCHIN, S., AND HUGUES, J.Realtime nonphotorealisticrendering.SIGGRAPH’97, 415–420.

[20] MARUYA , M. Generatingtexture map from object-surface texturedata. ComputerGraphicsForum (Proceedingsof Eurographics’95)14, 3 (1995),397–405.

[21] NEIDER, J., DAVIS, T., AND WOO, M. OpenGLProgrammingGuide, SecondEdition. Addison-Wesley, 1997.

[22] NEWELL , M. E., AND SEQUIN, C. The Inside Story on Self-IntersectingPolygons.Lambda1, 2 (1980),20–24.

[23] RASKAR, R., AND COHEN, M. ImagePrecisionSilhouetteEdges.ACM Symposiumon Interactive3D Graphics1999, 135–140.

[24] ROSSIGNAC, J., AND VAN EMMERIK , M. Hidden contourson aframe-buffer. Proceedingsof the7thWorkshoponComputerGraphicsHardware (1992).

[25] SNYDER, J., AND LENGYEL , J. Visibility SortingandCompositingwithout Splitting for ImageLayerDecompositions.SIGGRAPH’98,219–230.

[26] SOUCY, M., GODIN, G., AND RIOUX , M. A texture-mappingap-proachfor thecompressionof colored3D triangulations.TheVisualComputer12 (1986),503–514.

[27] X IA , J., AND VARSHNEY, A . Dynamicview-dependentsimplifica-tion for polygonalmodels. In Visualization’96 Proceedings, IEEE,pp.327–334.