GigaWalk: Interactive Walkthrough of Complex...

UNC-CH Technical Report TR02-013

GigaWalk: Interactive Walkthrough of Complex Environments

William V. Baxter III Avneesh Sud Naga K. Govindaraju Dinesh ManochaUniversity of North Carolina at Chapel Hill{baxter,sud,naga,dm}@cs.unc.eduhttp://gamma.cs.unc.edu/GigaWalk

Figure 1: DoubleEagle Tanker: This 4 gigabyte environment consists of more than 82 million triangles and 127 thousand objects. Ouralgorithm can render it 11-50 frames per second on an SGI system with two IR2 graphics pipelines and three 300MHz R12000 CPUs.

AbstractWe present a new parallel algorithm for interactivewalkthrough of complex, gigabyte-sized environments.Our approach combines occlusion culling and levels-of-detail and uses two graphics pipelines with one ormore processors. We use a unified scene graph repre-sentation for multiple acceleration techniques, and wepresent novel algorithms for clustering geometry spa-tially, computing a scene graph hierarchy, performingconservative occlusion culling, and performing load-balancing between graphics pipelines and processors.The resulting system, GigaWalk, has been used to ren-der CAD environments composed of tens of millionsof polygons at interactive rates on an SGI Onyx systemwith two Infinite Reality rendering pipelines. Overall,our system’s combination of levels-of-detail and occlu-sion culling techniques results in significant improve-ments in frame-rate over view-frustum culling or eithersingle technique alone.Keywords: Interactive display systems, parallel ren-dering, occlusion culling, levels-of-detail, EngineeringVisualization.

1 IntroductionUsers of computer-aided design and virtual reality ap-plications often create and employ geometric models

of large, complex 3D environments. It is not uncom-mon to generate gigabyte-sized datasets representingpower plants, ships, airplanes, submarines and urbanscenes. Simulation-based design and design reviewof such datasets benefits significantly from the abilityto generate user-steered interactive displays orwalk-throughsof these environments. Yet, rendering theseenvironments at the required interactive rates and withhigh fidelity has been a major challenge.

Many acceleration techniques for interactive displayof complex datasets have been developed. These in-clude visibility culling, object simplification and theuse of image-based or sampled representations. Theyhave been successfully combined to render certainspecific types of datasets at interactive rates, includ-ing architectural models [FKST96], terrain datasets[Hop98], scanned models [RL00] and urban environ-ments [WWS01]. However, there has been less successin displaying more general complex datasets due to sev-eral challenges facing existing techniques:

Occlusion Culling: While possible for certain envi-ronments, performing exact visibility computations onlarge, general datasets is difficult to achieve in real timeon current graphics systems [ESSS01]. Furthermore,occlusion culling alone will not sufficiently reduce theload on the graphics pipeline when many primitives areactually visible.

GigaWalk: Interactive Walkthrough of Complex Environments of 15


Object Simplification: Object simplificationtechniques alone have difficulty with high-depth-complexity scenes, as they do not address the problemsof overdraw and fill load on the graphics pipeline.

Image-based Representations:There are somepromising image-based algorithms, but generatingcomplete samplings of large complex environments au-tomatically and efficiently remains a difficult problem.The use of image-based methods can also lead to pop-ping and aliasing artifacts.1.1 Main ResultsWe present a parallel architecture that enables interac-tive rendering of complex environments comprised ofmany tens of millions of polygons. Initially, we pre-compute geometric levels-of-detail (LODs) and repre-sent the dataset using a scene graph. Then at runtimewe compute apotentially visible set(PVS) of geome-try for each frame using a combination of view frustumculling and a two-pass hierarchical Z-buffer occlusionculling algorithm [GKM93] in conjunction with thepre-computed LODs. The system runs on two graph-ics rasterization pipelines and one or more CPU pro-cessors. Key features of our approach include:

1. A parallel rendering algorithm that is generaland automatic, makes few assumptions about themodel, and places no restrictions on user motionthrough the scene.

2. A clustering algorithm for generating a unifiedscene graph hierarchy that is used for both geo-metric simplification and occlusion culling.

3. A parallel, image-precision occlusion cullingalgorithm based on the hierarchical Z-buffer[GKM93, Gre01]. It useshierarchical occludersand can perform conservative as well as approxi-mate occlusion culling.

4. A parallel rendering algorithm that balancesthe computational load between two renderingpipelines and one or more processors.

5. An interactive system, GigaWalk, to render large,complex environments with good fidelity on two-pipeline graphics systems. The graphics pipelinesthemselves require only standard rasterization ca-pabilities.

We demonstrate the performance of our system on twocomplex CAD environments: a coal-fired power plant(Fig. 2) composed of 13 million triangles, and a Dou-ble Eagle Tanker (Fig. 1) composed of over 82 milliontriangles. GigaWalk is able to render models such asthese at 11-50 frames a second with little loss in im-age quality on an SGI Onyx workstation using two IR2pipelines. The end-to-end latency of the system is typ-ically 50-150 milliseconds.

Figure 2:Coal-Fired Power plant: This 1.7 gigabyte envi-ronment consists of over 13 million triangles and 1200 ob-jects. GigaWalk can display it 12-37 frames per second onan SGI Onyx workstation using two IR2 graphics pipelinesand three 300MHz R12000 CPUs.

1.2 OrganizationThe rest of the paper is organized as follows. We givea brief survey of previous work in Section 2. Section 3gives an overview of our approach. In Section 4 we de-scribe the scene representation and preprocessing steps,including hierarchy computation. Section 5 presentsthe parallel algorithm for interactive display. We de-scribe the system implementation and highlight its per-formance on complex models in Section 6.2 Prior WorkIn this section, we present a brief overview of previousresearch on interactive rendering of large datasets, in-cluding geometric simplification and occlusion cullingalgorithms, and other systems that have combined mul-tiple rendering acceleration techniques.2.1 Geometric SimplificationSimplification algorithms compute a reduced-polygonapproximation of a model while attempting to retain theshape of the original. A survey of recent algorithms ispresented in [Lue01].

Algorithms for simplifying large environments canbe classified as either static (view-independent) ordynamic (view-dependent). Static approaches pre-compute a discrete series of levels-of-detail (LODs)in a view-independent manner [EM99, GH97, RB93,Sch97]. Erikson et al. [EMB01] presented an approachto large model rendering based on the hierarchical useof static LODs, or HLODs. We also use LODs andHLODs in our system.

At run-time, rendering algorithms for static LODschoose an appropriate LOD to represent each objectbased on the viewpoint. Selecting the LODs requireslittle run-time computation, and rendering static LODs



on contemporary graphics hardware is also efficient.View-dependent, dynamic algorithms pre-compute

a data structure that encodes a continuous range of de-tail. Examples include progressive meshes [Hop96,Hop97, XESV97] and hierarchies of decimation op-erations [LE97, ESV99]. Selection of the appropriateLOD is based on view-parameters such as illuminationand viewing position. Overall, view-dependent LODscan provide better fidelity than static LODs and workwell for large connected datasets such as terrain andspatially large objects. However, the run-time overheadis higher compared to static LODs, since all level-of-detail selection is done at the individual feature level(vertex, edge, polygon), rather than the object level.

2.2 Occlusion Culling

Occlusion culling methods attempt to quickly deter-mine a PVS for a viewpoint by excluding geometry thatis occluded. A recent survey of different algorithms ispresented in [COCS01].

Several effective algorithms have been developedfor specific environments. Examples include cells andportals for architectural models [ARB90, Tel92] and al-gorithms for urban datasets or scenes with large, con-vex occluders [CT97, HMC+97, SDDS00, WWS00,WWS01]. In this section, we restrict the discussion toocclusion culling algorithms for general environments.

Algorithms for occlusion culling can be broadlyclassified based on whether they are conservative orapproximate, whether they use object space or imagespace hierarchies, and whether they compute visibil-ity from a point or a region. Conservative algorithmscompute a PVS that includes all the visible primitives,plus a small number of potentially occluded primitives[CT97, GKM93, HMC+97, KS01, ZMHH97]. The ap-proximate algorithms identify most of the visible ob-jects but may incorrectly cull some objects [BMH99,KS00, ZMHH97].

Object space algorithms can perform culling effi-ciently and accurately given a small set of large oc-cluders, but it is difficult to perform the “occluder fu-sion” necessary to effectively cull in scenes composedof many small occluders. For these types of scenes, theimage space algorithms typified by the hierarchical Z-buffer (HZB) [GKM93, Gre01] or hierarchical occlu-sion maps (HOM) [ZMHH97] are more effective.

Region-based algorithms pre-compute a PVS foreach region of space to reduce the run-time overhead[DDTP00, SDDS00, WWS00]. This works well forscenes with large occluders, but the amount of geom-etry culled by a given occluder diminishes as the regionsizes are increased. Thus there is a trade-off betweenthe quality of the PVS estimation for each region andthe memory overhead. These algorithms may be overlyconservative and have difficulty obtaining significantculling in scenes including only small occluders.

2.3 Parallel ApproachesA number of parallel approaches based on multiplegraphics pipelines have been proposed. These canprovide scalable rendering on shared-memory systemsor clusters of PCs. These approaches can by clas-sified mainly as either object-parallel, screen-space-parallel, or frame-parallel [HEB+01, SFLS00]. Spe-cific examples include distributing primitives to dif-ferent pipelines by the screen region into which theyfall (screen-space-parallel), or rendering only every Nthframe on each pipeline (frame-parallel).

Another parallel approach to large model renderingthat shows promise is interactive ray tracing [AT99,WSB01]. The algorithm described in [WSB01] is ableto render the Power Plant model at 4-5 frames a sec-ond with 640×480 pixel resolution on a cluster of sevendual processor PCs.

Garlick et al. [GBW90] presented a system for per-forming view-frustum culling on multiple CPUs in par-allel with the rendering process. Their observation thatculling can be performed in parallel to improve overallsystem performance is the fundamental concept behindour approach as well.

Wonka et al. [WWS01] presented a “visibilityserver” that performed occlusion culling to computea PVS at run-time in parallel on a separate machine.Their system works well for urban environments; how-ever, it relies on theoccluder shrinkingalgorithm[WWS00] to compute the region-based visibility. Thisapproach is effective only if the occluders are large andvolumetric in nature.2.4 Hybrid ApproachesThe literature reports several systems that combinemultiple techniques to accelerate the rendering of largemodels. For example, The BRUSH system [SBM+94]used LODs with hierarchical representation for largemechanical and architectural models. The UC Berke-ley Architecture Walkthrough system [FKST96] com-bined hierarchical algorithms with object-space visibil-ity computations [Tel92] and LODs for architecturalmodels.

More recently, [ASVNB00] presented a frameworkthat integrates occlusion culling and LODs. The cruxof the approach is to estimate the degree of visibility ofeach object in the PVS and use that value both to se-lect appropriate LODs and to cull. The method relieson decomposing scene objects into overlapping convexpieces (axis-aligned boxes) that then serve as individ-ual “synthetic occluders”. Thus the effective maximumoccluder size depends on the largest axis-aligned boxthat will fit inside each object.

Another recent integrated approach uses aprioritized-layered projection visibility approximationalgorithm with view-dependent rendering [ESSS01].The resulting rendering algorithm seems a promis-ing approach when approximate (non-conservative)



visibility is acceptable.The UNC Massive Model Rendering (MMR) sys-

tem [ACW+99] combined LODs with image-basedimpostors and occlusion culling to deliver interactivewalkthroughs of complex models. A more detailedcomparison with this system will be made later in Sec-tion 6.4.

Various proprietary systems exist as well, such asthe one Boeing created in the 1990’s to visualize mod-els of large passenger jets. However, to the best of ourknowledge, no detailed descriptions of this system areavailable, so it is difficult to make comparisons.

3 OverviewIn this section, we give a brief overview of the maincomponents of our approach. These components aresimplification, occlusion culling, and a parallel archi-tecture.

3.1 Model SimplificationGiven a large environment, we generate a scene graphby clustering small objects, and partitioning large ob-jects to create a spatially coherent, axis-aligned bound-ing box (AABB) hierarchy. Details of the hierarchyconstruction will be discussed in Section 4.

3.2 Parallel Occlusion CullingAt run-time, our algorithm performs occlusion culling,in addition to view frustum culling, based on the pre-computed AABB scene graph hierarchy. We use atwo-pass version of the hierarchical Z-buffer algorithm[GKM93] with a two-graphics-pipeline parallel archi-tecture. In this architecture, occluders are rendered onone pipeline while the final interactive rendering of vis-ible primitives takes place on the second pipeline. Aseparate software thread performs the actual culling us-ing the Z-buffer that results from the occluder render-ing. The architecture will be presented in detail in Sec-tion 5.

We chose to use the hierarchical Z-buffer (HZB) be-cause of its good culling performance, minimal restric-tions on the type of occluders, and for its ability to per-form occluder fusion. Moreover, it can be made to workwell without extra preprocessing or storage overheadby exploiting temporal coherence. The preprocessingand storage cost of GigaWalk is thus the same as thatof an LOD-only system.

Occluder Selection: A key component of any occlu-sion culling algorithm is occluder selection, which canbe accomplished in a number of ways. A typical ap-proach uses solid angle to estimate a small set of goodoccluders [ZMHH97, KS00]. However, occluders se-lected according to such heuristics are not necessarilyoptimal in terms of the number of other objects they ac-tually occlude. The likelihood of obtaining good occlu-sion can be increased by making the occluder set larger,but computational costs usually demand the set be as

small as possible.Our parallel approach, on the other hand, allows

us to take advantage of the temporal coherence basedoccluder selection algorithm presented in [GKM93],which treatsall the visible geometry from the previousframe as occluders for the current frame. This methodmakes use of frame-to-frame coherence and provides agood approximation to the foreground occluders for thecurrent frame.

Figure 3:System Architecture: Each color represents a sep-arate process. The OR and RVG processes are associatedwith separate graphics pipelines, whereas the STC uses oneor more processors.

3.3 GigaWalk ArchitectureFig. 3 presents the overall architecture of our run-timesystem. It shows the three processes that run in parallel:

1. Occluder Rendering (OR): Using all the visiblegeometry from a previous frame as the occluderset, this process renders that set into a depth buffer.It runs on the first graphics pipeline.

2. Scene Traversal, Culling and LOD Selection(STC): This process computes the HZB usingthe depth buffer computed by OR. It traversesthe scene graph, computes the visible geometryand selects appropriate LODs based on the user-specified error tolerance. The visible geometry isused by RVG for the current frame and OR for thenext frame. It runs on one or more processors.

3. Rendering Visible Scene Geometry (RVG):This process renders the visible scene geometrycomputed by STC. It uses the second graphicspipeline.

More details of the run-time system are given in Sec-tions 5 and 6.4 Scene RepresentationIn this section, we present an object clustering-basedalgorithm to automatically compute a scene graph rep-resentation of the geometric dataset.

CAD datasets often consist of a large number of ob-jects which are organized according to a functional,rather than spatial, hierarchy. By “object” we mean



simply the lowest level of organization in a model ormodel data structure above the primitive level. Thesize of objects can vary dramatically in CAD datasets.For example, in the Power Plant model a large pipestructure, which spans the entire model and consistsof more than 6 million polygons, is one object. Simi-larly, a relatively small bolt with 20 polygons is anotherobject. Our rendering algorithm computes LODs, se-lects them, and performs occlusion culling at the objectlevel; therefore, the criteria used for organizing prim-itives into objects has a serious impact on the perfor-mance of the system. Our first step, then, is to redefineobjects in a dataset based on criteria that will improveperformance.4.1 Unified Scene HierarchyOur rendering algorithm performs occlusion culling intwo rendering passes: pass one renders occluders tocreate a hierarchical Z-buffer to use for culling, passtwo renders the objects that are deemed visible by theHZB culling test. Given this two-pass approach, wecould consider using a separate representation for oc-cluders in pass one than for displayed objects in passtwo [HMC+97, ZMHH97]. Using different representa-tions has the advantage of allowing different criteria forpartitioning and clustering for each hierarchy. More-over, it would give us the flexibility of using a differ-ent error metric to create simplified occluders, one op-timized to preserve occlusion power rather than visualfidelity.

Despite these potential advantages, we used a sin-gle unified hierarchy for occlusion culling and levels-of-detail based rendering. A single hierarchy offers thefollowing benefits:• Simplicity: A single representation leads to a simpleralgorithm.• Memory And Preprocessing Overhead: A sepa-rate occluder representation would increase the storageoverhead, and increase the overall preprocessing cost.This can be significant for gigabyte datasets, depend-ing upon the type of occluder representation used.• Conservative Occlusion Culling:Our rendering al-gorithm treats the visible geometry from the previousframe as the occluder set for the current frame. In or-der to guarantee conservative occlusion culling, it issufficient to ensure that exactly the same set of nodesand LODs in the scene graph are used by each process.Ensuring conservative occlusion culling when differentrepresentations are used is more difficult.4.1.1 Criteria for HierarchyA good hierarchical representation of the scene graph iscrucial for the performance of occlusion culling and theoverall rendering algorithm. We use the same hierarchyfor view frustum culling, occluder selection, occlusiontests on potential occludees, hierarchical simplification,and LOD selection. Though there has been consider-able work on spatial partitioning and bounding volume

hierarchies, including top-down and bottom-up strate-gies and spatial clustering, none of them seem to haveaddressed all the characteristics desired by our render-ing algorithm. These include good spatial localization,object size, balance of the hierarchy, and minimal over-lap between the bounding boxes of sibling nodes in thetree.

Bottom-up hierarchies lead to better localization andhigher fidelity LODs. However, it is harder to usebottom-up techniques to compute hierarchies that areboth balanced and have minimal spatial overlap be-tween nodes. On the other hand, top-down schemes arebetter at ensuring balanced hierarchies and boundingboxes with little or no overlap between sibling nodes.Given their respective benefits, we use a hybrid ap-proach that combines both top-down partitioning andhierarchy construction with bottom-up clustering.4.2 Hierarchy GenerationIn order to generate uniformly-sized objects, our pre-processing algorithm first redefines the objects using acombination of partitioning and clustering algorithms(see Fig. 5). The partitioning algorithm takes large ob-jects and splits them into multiple objects. The cluster-ing step groups objects with low polygon counts basedon their spatial proximity. The combination of thesesteps results in a redistribution of geometry with goodlocalization and emulates some of the benefits of purebottom-up hierarchy generation. The overall algorithmproceeds as follows:

1. Partition large objects into sub-objects in the ini-tial database (top-down)

2. Organize disjoint objects in and sub-objects intoclusters (bottom-up)

3. Partition again to eliminate any uneven spatialclusters (top-down)

4. Compute an AABB bounding volume hierarchyon the final redefined set of objects (top-down).

Next, we present the algorithms for clustering and par-titioning in detail.4.2.1 Partitioning ObjectsWe subdivide large objects based on their size, as-pect ratios and polygon count into multiple sub-objects,since long, thin objects with large bounding boxes areless likely to be occluded. The algorithm proceeds asfollows:

1. Check if an object meets the splitting criteria :

• the number of triangles is above a thresholdt1, and,

• the size (bounding box diagonal) is greaterthan a thresholds1, or



(a) Partitioning & Clustering on PowerPlant

(b) Original Objects in Double Eagle (c) Partitioning & Clustering on DoubleEagle

Figure 4:The image on the left shows the application of the partitioning and clustering algorithm to the Power Plant model.The middle image shows the original objects in the Double Eagle tanker model with different colors. The right image showsthe application of the clustering algorithm on the same model. Each cluster is shown with a different color.

• ratio of largest dimension of bounding box tosmallest dimension is above a thresholdr1.

2. Partition the object along the longest axis of thebounding box. If that results in an unbalanced par-tition, choose the next longest axis.

3. Recursively split the child objects in the samemanner.

See Section 6.3.1 for the parameter values used for thisand the subsequent stages of our preprocess.4.2.2 ClusteringMany approaches for clustering disjoint objects arebased on spatial partitioning, such as adaptive grids oroctrees. However, they may not work well for complex,irregular environments composed of a number of smalland large objects. Rather we present an object-spaceclustering algorithm extending a computer vision algo-rithm for image segmentation [FH98]. The algorithmuses minimum spanning trees (MST) to represent clus-ters. It uses local spatial properties of the environmentto incrementally generate clusters that represent globalproperties of the underlying geometry. The resultingclusters are neither too coarse nor too fine. The algo-rithm imposes this criteria by ensuring that it combinestwo clusters only if the internal variation in each clusteris greater than its external variation (by using Hausdorffmetric). In each cluster, the maximum weight edge(which denotes the internal variation) of the MST rep-resenting the cluster denotes the maximum separationbetween any two “connected” objects in the cluster. Aminimum weight edge connecting two different clus-ters (which denotes the external variation between thetwo clusters) estimates the separation between objectsof one cluster with those of the other. In other words,

it denotes the minimum radius of dilation necessary toconnect at least one point of one cluster to that in an-other. The algorithm is similar toKruskal’s algorithm[Kru56] for generating a forest of minimum spanningtrees. The overall algorithm proceeds as follows:

1. Construct a graphG(V,E) on the environmentwith each object representing a vertex in the graph.Construct an edge between two vertices if the dis-tance between the two vertices (objects) is lessthan a thresholdD. The distance function is de-fined as the shortest distance between the bound-ing boxes of the two objects. If the two boxes areoverlapping, then it is zero.

2. SortE into π = (o1, o2, . . . , ok), oi ∈ E, i =1, . . . , k in a non-decreasing order based on edgeweights,w(oi). Start with a forestF 0 where eachvertexvi represents a cluster.

3. Repeat Step4 for the set of edgesoq =o1, . . . , ok, k = ‖E‖.

4. Construct forestF q from F q−1 as follows. Letoq = (vi, vj), i.e., edgeoq connects verticesviandvj . If there is no path fromvi to vj in F q−1

andw(oq) is small compared to the internal vari-ation of components containingvi andvj , and ifthe bounding volume of the resultant component isless than a maximum volume threshold, then addoq to F q−1 to obtainF q, otherwise add nothing.Mathematically, ifCq−1

i 6= Cq−1j andw(oq) ≤

MI(Cq−1i , Cq−1

j ), thenF q = F q−1 ∪ oq where

Cq−1i denotes the cluster containing vertexvi in

F q−1 andCq−1j is the cluster containing vertexvj .



Figure 5: Our clustering and partitioning process applied to a 2D example. Each different color represents adifferent object at the end of a stage. (a) The model’s original objects. This object distribution captures a numberof features common in CAD models in which objects are defined by function rather than by location. (b) The initialpartitioning stage serves to split objects with large bounding boxes. This prevents objects like3, whose initialbounding box intersects most of the others, from causing clustering to generate just one large cluster. (c) Afterclustering, the group of small objects around1 have all been merged to form1∗. The row of objects,2, have alsobeen merged into one cluster,2∗, as well, but one which has a poor aspect ratio. (d) The final partition splits2∗into two separate objects.

elseF q = F q−1, where

MI(C1, C2) =min(I(C1) +K/‖C1‖, I(C2) +K/‖C2‖)

andI(C) = max

e∈MST (C,E)w(e) (1)

The K/‖Ci‖ terms bias the results toward clustersof cardinality bounded byO(K), where K is user-specified. We set a maximum volume thresholdV toensure final clusters are not too large in size. It is rea-sonably fast in practice and generates good spatial clus-ters. Fig. 4 shows its application to the Power Plant andDouble Eagle models.

Overall, the clustering algorithm successfullymerges small objects into larger groups with good lo-calization. It improves the performance of the cullingalgorithm as well as the final image fidelity.4.2.3 Partitioning ClustersWe finally repartition clusters with an uneven distribu-tion of geometry, splitting objects about their center ofmass. This is similar to the partitioning algorithm pre-sented in Section 4.2.1. However, we use higher thresh-olds for the size and triangle count to avoid splittingclusters back into small objects, but tighter bounds forthe aspect ratio to force splitting of uneven clusters.4.2.4 Hierarchy GenerationWe compute a standard AABB bounding volume hi-erarchy in a top-down manner on the set of redefinedobjects generated after clustering and partitioning. Thebounding boxes are assigned to left and right branchesof the hierarchy using their geometric centers to avoidoverlap. The redefined objects become the leaf nodesin the AABB hierarchy.

4.3 HLOD GenerationGiven the above scene graph, the algorithm computesa series of LODs for each node. The HLODs arecomputed in a bottom-up manner. The HLODs of theleaf nodes are standard static LODs, while the HLODsof intermediate nodes are computed by combining theLODs of the nodes with the HLODs of node’s children.We use a topological simplification algorithm to mergedisjoint objects [EM99].

The majority of the pre-computation time is spent inLOD and HLOD generation. The HLODs of an inter-nal node depend only on the LODs of the children, soby keeping only the LODs of the current node and itschildren in main memory, HLOD generation is accom-plished within a small memory footprint. Specifically,the memory usage is given by

main memory footprint ≤ sizeof(AABBHierarchy)+ maxNi∈SG

(sizeof(Ni) +∑Cj∈Child(Ni)

sizeof(Cj))

4.4 HLODs as Hierarchical OccludersOur occlusion culling algorithm uses LODs andHLODs of nodes as occluders to compute the HZB.They are selected based on the maximum screen-spacepixel deviation error on object silhouettes.

The HLODs our rendering algorithm uses for oc-cluders can be thought of as “hierarchical occluders”.A hierarchical occluder associated with a nodei is anapproximation of a group of occluders contained in thesubtree rooted ati. The approximation provides a lowerpolygon count representation of a collection of object-space occluders. It can also be regarded as object-space



occluder fusion.5 Interactive DisplayIn this section, we present our parallel rendering ar-chitecture for interactive display of complex environ-ments. Here we describe in detail the operations per-formed by each of the two graphics pipelines and eachof the three processes: occluder rendering (OR), scenetraversal and culling (STC) and rendering visible ge-ometry (RVG), which run synchronously in parallel (asshown in Fig. 6).5.1 Run-time ArchitectureThe relationship between different processes and thetasks performed by them is shown in Fig. 3.5.1.1 Occluder RenderingThe first stage for a given frame is to render the oc-cluders. The occluders are simply the visible geometryfrom a previous frame. By using this temporal coher-ence strategy, the load on the two graphics pipelines isessentially balanced, since they render the exact samegeometry, just shifted in time. The culling and LODselection performed for displaying framei naturally re-sults in an occluder set for framei + 1 that is of man-ageable size. A brief pseudo-code description is givenin Algorithm 5.1.

Occluder Render(δ,framei)• get current instantaneous camera position(camerai)• while (more nodes on node queue from STC (i-1))∗ pop next node off the queue∗ select LOD/HLOD for the node according to

error tolerance,δ, using camerai∗ render that LOD/HLOD into Z-bufferi• read back Z-bufferi from graphics hardware• push Z-bufferi onto queue for STCi• push camerai onto queue for STCi

ALGORITHM 5.1: OccluderRender.

Since the list of visible geometry for renderingcomes from the culling stage (STC), and STC gets itsinput from this process (OR), a startup procedure is re-quired to initialize the pipeline and resolve this cyclicdependency. During startup, the OR stage is bypassedon the first frame, and STC generates its initial list ofvisible geometry without occlusion culling.5.1.2 Scene Traversal, Culling and LOD SelectionThe STC process first computes the HZB from thedepth buffer output from OR. It then traverses thescene graph, performing view-frustum culling, occlu-sion culling and LOD error-based selection in a recur-sive manner. The LOD selection proceeds exactly asin [EMB01]: recursion terminates at nodes that are ei-ther culled, or which meet the user-specified pixel-errortolerance. A pseudo-code description is given in Al-gorithm 5.2. The occlusion culling is performed

SceneTraversal Cull (ε, framei)• get Z-bufferi from ORi via Z-buffer queue• build HZB i• get camerai from ORi queue• push copy of camerai onto queue for RVGi• set NodeList[i] = Root(SceneGraph)• while (NotEmpty(NodeList[i]))∗ node = First(NodeList[i])∗ set NodeList[i] = Delete(NodeList[i],node)∗ if (View Frustumculled(node)) then next;∗ if (OcclusionCulled(node)) then next;∗ if HLOD Error Acceptable(ε,node) then− push node onto queue for ORi+ 1;− push node onto display queue for RVGi;∗ elseset NodeList[i] = Add(NodeList[i],

Children(node));

ALGORITHM 5.2: SceneTraversalCull.

by comparing the bounding box of the node with theHZB. It can be performed in software or can make useof hardware-based queries as more culling extensionsbecome available.5.1.3 Rendering Visible Scene GeometryAll the culling is performed by STC, so the final renderloop has only to rasterize the nodes from STC as theyare placed in the queue. See Algorithm 5.3.

Render Visible SceneGeometry(framei)• get camerai from STCi queue• while (more nodes on queue from STCi)• pop node off queue• render node

ALGORITHM 5.3: RenderVisible SceneGeometry.

5.2 Occluder SelectionIdeally, the algorithm uses the visible geometry fromthe previous frame (i− 1) as the occluders for the cur-rent frame to get the best approximation to the cur-rent foreground geometry. However, using the previousframe’s geometry can lead to bubbles in the pipeline,because of the dependency between the OR and STCstages: STC must wait for OR to finish rendering theoccluders before it can begin traversing the scene graphand culling. Fortunately, using the visible geometryfrom two frames previous can eliminate that depen-dency, and still provides a good approximation to thevisible geometry for most interactive applications.5.3 Trading Fidelity for PerformanceThe user can trade off fidelity for better performance ina number of ways. The primary control for achievinghigher frame rates is the allowable LOD pixel error (seeFigure 7).

Our system has been designed primarily to offer



Figure 6: Timing relationship between different processes. The arrows indicate data passed between processes during thecomputation of frame 2. Along with the other data indicated, viewpoints also travel through the pipeline according to theframe numbers. This diagram demonstrates the use of occluders from framei− 2 rather thani− 1 (see Section 5.2).

(a) Pixel Error =0 (b) Pixel Error =20 (c) Difference Image

Figure 7: The Engine Room in the Double Eagle Tanker displayed without and with HLODs. The inset shows amagnification of one region. Original resolution 1280×960.

conservative occlusion culling, and we report all of ourresults based on this mode of operation. Our system canguarantee conservative culling results for two reasons:1) the underlying HZB algorithm used is itself conser-vative, and 2) for a given framei we choose the exactsame set of LODs for both OR and STC stages. Bychoosing the same LODs, we ensure that the Z-bufferused for culling is consistent with the geometry it isused to cull. Without this selection algorithm, conser-vativity is not guaranteed.

We have also modified our run-time pipeline in anumber of ways to optionally increase frame rate ordecrease latency, by allowing the user to relax the re-striction that occlusion culling be performed conserva-tively:

• Asynchronous rendering pipeline: Rather thanwaiting for the next list of visible geometry from theculling stage (STC) to render framei + 1, the ren-der stage (RVG) can instead proceed to render anotherframe, still using the geometry from framei, but us-ing the most recent camera position, corresponding tothe user’s most up-to-date position. This modification

eliminates the extra frame of latency introduced by ourmethod. The main drawback is that it may introduceocclusion errors that, while typically brief, are poten-tially unbounded when the user moves drastically.

• Nth Farthest Z Buffer Values: The occlusionculling can be modified to use not the farthest Z val-ues in building the depth pyramid, but the Nth far-thest [Gre01], thereby allowing for approximate “ag-gressive” culling.

• Lower HZB resolution for occluder rendering:The pixel resolution of the OR stage can be set smallerthan that of the RVG stage. If readback from the depthbuffer or HZB computation is relatively slow, this canimprove the performance. However, using a lower res-olution source for HZB allows for the possibility ofdepth buffer aliasing artifacts that can manifest them-selves as small occlusion errors. In practice, however,we have not been able to visually detect any such errorswhen using OR depth buffers with as little as half theRVG resolution.



(a) Polygon Count =202666 (b) Polygon Count =3578485 (c) Polygon Count =61771

Figure 8:Comparison between different acceleration techniques from the same viewpoint. (a) Rendered with only HLODs.(b) Rendered with only HZB occlusion culling. (c) Rendered with GigaWalk using HLODs and HZB occlusion culling.

Figure 9:Comparison of different acceleration algorithms on a path in the Power Plant model (left) and DoubleEagle (right). The Y-axis shows the instantaneous frame rate. The combination of HLODs + occlusion cullingresults in 2-5 times improvement over using only one of them.

6 Implementation and PerformanceWe have implemented our parallel rendering algorithmon a shared-memory multiprocessor machine with dualgraphics rasterization pipelines: an SGI Onyx work-station with 300MHz R12000 MIPS processors, Infi-nite Reality (IR2e) graphics boards, and 16GB of mainmemory. Our algorithm uses three CPUs and twographics pipelines.

All of the inter-process communication is imple-mented using a simple templated producer-consumershared queue data structure of under 100 lines of C++code. Each stage (OR,STC,RVG) is connected with theothers using one or more instances of this queue datastructure. Synchronization between the processes is ac-complished by pushing sentinel nodes onto the sharedqueues to delimit the data at the end of a frame. Thescene graph resides in shared memory, and is accessi-ble to all processes.

We have tested the performance of GigaWalk ontwo complex environments, a coal-fired Power Plant

(shown in Fig. 2) and a Double Eagle Tanker (shownin Fig. 1). The details about these environments areshown in Table 1. In addition to the model complexity,the table also lists the object counts after the clusteringand partitioning steps.

6.1 Improvement in Frame Rate

GigaWalk is able to render our two example complexenvironments at interactive rates from most viewpoints.The frame rate varies from 11 to 50 FPS. It is more than20 frames a second from most viewpoints in the scene.We have recorded and analyzed some example pathsthrough these models (as shown in the video). In Fig. 9,we show the improvement in frame rate for each envi-ronment. The graphs compare the frame rate for eachindividual rendering acceleration technique alone andfor the combination. Table 2 shows the average speed-ups obtained by each technique over the same path. Thecomparison between the techniques for a given view-point is shown in Fig. 8.



Object CountEnv Poly Init Part1 Clust Part2

×106 ×104 ×104 ×103 ×105

PP 12.2 0.12 6.95 3.33 0.38DE 82.4 12.7 2.21 2.31 1.2

Table 1: A breakdown of the complexity of each envi-ronment.Poly is the polygon count.Init is the numberof objects in the original dataset. The algorithm firstpartitions (Part1) objects into sub-objects, then gener-ates clusters (Clust), and finally partitions large un-even spatial clustersPart2. The table shows the objectcount after each step.

Model Average FPSOCH HLOD+VFC OCC+VFC VFC

PP 30.67 9.55 9.48 1.15DE 29.43 9.76 3.27 0.02

Table 2:Average frame rates obtained by different ac-celeration techniques over the sample path.FPS =Frames Per Second,HLOD = Hierarchical levels ofdetail,OCH = Occlusion culling with HLOD,OCC =Occlusion Culling,VFC = View Frustum Culling

6.2 System LatencyOur algorithm introduces a frame of latency to render-ing times. Latency can be a serious issue for many in-teractive applications like augmented reality. Our ap-proach is best suited for latency-tolerant applications,namely walkthroughs of large synthetic environmentson desktop or projection displays. The end-to-end la-tency in our system varies with the frame rate. It istypically in the range 50-150 ms. The high end of thisrange is achieved when the frame rate dips close to10 frames a second. This latency is within the rangethat most users can easily adapt to (less than 300 ms)without changing their interaction mode with the model[EYAE99].

In many interactive applications, the dominantcomponent of latency is the frame rendering time[EYAE99]. Through the use of our two-pass occlusionculling technique, our rendering algorithm improvesthe frame rate by a factor of 3-4. As a result, the overallsystem latency is decreased, in contrast to an algorithmthat does not use occlusion culling.

6.3 PreprocessingThis section reports the values we used for the prepro-cessing parameters mentioned in Section 4 and givesdetails about the amount of time and memory used byour preprocess.

6.3.1 Preprocessing ParametersFor Partition-I (Sec. 4.2.1), empirically, wehave obtained good results witht1=1000,

s1=0.1×model dimension, r1=2.5.For Clustering (Sec. 4.2.2), we useD = 0.1 ×

max bounding box dimension. We can also workon a complete graph but choosing a thresholdin general works well and reduces the computa-tional complexity. We chooseV = 10−3 ×total scene bounding box volume as the maxi-mum volume threshold. ForK we use 1500, which pre-vents too many closely-packed objects from all merg-ing into a single cluster.

For Partition-II (Sec. 4.2.3) we uses2 = 2s1 andtriangle countt2 = 10t1, but tighter bounds for theaspect ratior2 = 0.5r1.6.3.2 Time and Space RequirementsThe preprocessing was done on a single-processor2GHz Pentium 4 PC with 2GB RAM. The preprocess-ing times for the Double Eagle model were: 45 min forPartition-I, 90 min for Clustering, 30 min for Partition-II, 32.5 hours for out of core HLOD generation and 12min for the AABB hierarchy generation. The size ofthe final HLOD scene graph representation is 7.6GBwhich is less than 2 times the original data size. TheAABBTree hierarchy occupies 7MB space.

The main memory requirement for partitioning andclustering is bounded by the size of the largest ob-ject/cluster. For the Double Eagle it was less than200MB for partitioning, 1GB for clustering and 300MBfor out of core HLOD generation.6.4 Comparison with Earlier ApproachesA number of algorithms and systems have been pro-posed for interactive display of complex environments.These include specialized approaches for architectural,terrain and urban environments, as highlighted in Sec-tion 2. Given low depth complexity scenes, or scenescomposed of large or convex occluders (e.g, architec-tural or urban models), our general approach is notlikely to perform any better than special-purpose algo-rithms designed specifically to exploit such features. Inthe rest of this section, we compare GigaWalk with ear-lier systems that can handle general environments.

Some of the commonly used algorithms for generalenvironments are based on a scene graph representationand using a combination of LODs or HLODs at eachnode [Clar76]. The SGI’s Performer toolkit [RH94]and IBM’s BRUSH system [SBM+94] provided thiscapability. The BRUSH system used the LODs gen-erated by a vertex clustering algorithm [RB93] that didnot provide good error bounds on the quality of result-ing approximations. Cohen et al. [Cohe96] used LODsgenerated using the “simplification envelopes” algo-rithm and integrated them into the Performer frame-work. However, the resulting algorithm was unable tocompute drastic simplifications of large environments.Erikson et al. [EMB01] used a combination of LODsand HLODs computed using GAPS [EM99] for differ-ent nodes in the scene graph. However, none of these



approaches performed occlusion culling. As a result,they were unable to render high depth complexity mod-els at interactive rates with good fidelity. GigaWalk alsouses GAPS to compute LODs and HLODs of objects.However, our approach for computing a unified hierar-chy that is used for LOD and HLOD selection at run-time, and occlusion culling is quite different from thatpresented in [EMB01].

The MMR system combined LODs and occlusionculling for near-field geometry with image-based tex-tured meshes to approximate the far-field, in a cell-based framework [ACW+99]. While the combina-tion of techniques proved capable of achieving inter-active frame rates, the system had some drawbacks.No good algorithms are known for automatic compu-tation of cells for a large and general environment.The MMR system used some model-dependent features(e.g. walkways in the Powerplant) for cell computa-tion. On the other hand, the preprocessing and scenegraph computation in GigaWalk is fully automatic. Theimage-based far-field representations used in the MMRsystem can result in dramatic popping and distortionwhen switching between different cells. Moreover, thememory overhead and preprocessing cost of creatingsix meshes and textures per-cell was quite quite high.The MMR system used a single graphics pipeline forocclusion culling as well as rendering the visible geom-etry and textured meshes. It used some preprocessingtechniques to estimate the depth complexity of near-geometry in each cell and only used occlusion cullingwhen the viewer is in a cell with high depth complex-ity. However, the overall benefit of occlusion cullingwas rather limited because of these heuristics and a sin-gle graphics pipeline based implementation. The cellbased spatial decomposition in the MMR system re-sulted in a simple out-of-core rendering and prefetchingalgorithm. The runtime memory footprint was muchsmaller than the total size of the model and associateddata structures (e.g. LODs and image-based represen-tations). On the other hand, GigaWalk assumes thatthe entire scene graph and the LODs and HLODs areloaded in the main memory.

7 Conclusions and Lessons LearnedWe have presented an approach to rendering interactivewalkthroughs of complex 3D environments. The algo-rithm features a novel integration of conservative oc-clusion culling and levels-of-detail using a parallel al-gorithm. We have demonstrated a new parallel render-ing architecture that integrates these acceleration tech-niques on two graphics pipelines and one or more pro-cessors. Finally, we have presented novel algorithmsfor partitioning and clustering, and generating an inte-grated hierarchy suitable for both HLODs and occlu-sion culling. We have demonstrated the performance ofour system, GigaWalk, on two complex CAD environ-ments. To the best of our knowledge, GigaWalk is the

first system that can render such complex environmentsat interactive rates with good fidelity, i.e. no popping oraliasing artifacts.

There are many complex issues with respect tothe design and performance of systems for interac-tive display of complex environments. These includeload balancing, extent of parallelism and scalabilityof the resulting approach, the effectiveness of occlu-sion culling and issues related to loading and managinglarge datasets.

7.1 Load BalancingThere is a trade-off between the depth of scene graph,which is controlled by the choice of minimum clus-ter size, and the culling efficiency. Smaller bound-ing boxes lead to better culling since more boxes canbe rejected, so less geometry is sent to RVG. On theother hand, more boxes increases the cost of scenegraph traversal and culling in STC. In our system, scenetraversal and object culling (STC) operate in parallelwith rendering (OR and RVG). If our performance bot-tleneck is the rendering processes (RVG and OR), wecan shift the load back to the culling (STC) process bycreating a finer partitioning. Conversely, we can usea coarser partitioning to move the load back to RVGand OR. Thus, the system can achieve load balancingbetween different processes running on the CPUs orgraphics pipelines by changing the granularity of par-titioning.

7.2 ParallelismParallel graphics hardware is increasingly being usedto improve the rendering performance of a walkthroughsystem. Generally, though, the speed-up obtained fromusingN pipelines is no more than a factor ofN . Usinga second pipeline for occlusion culling (i.e.N = 2),however, enables GigaWalk to achieve more than twotimes speed-up for scenes with high depth complexity.For low depth complexity scenes there is little or nospeed-up, but there is no loss in frame rate as the oc-clusion culling is performed using a separate pipeline.However, our parallel algorithm introduces a frame oflatency.

Note also that other parallel approaches [HEB+01,SFLS00] are fundamentally orthogonal to our ap-proach, and could potentially be used in conjunctionwith our architecture as black-box replacements for theOR and RVG rendering pipelines.

7.3 Load TimesOne of the considerations in developing a walkthroughsystem to render gigabyte datasets is the time taken toload gigabytes of data from secondary storage, whichcan be many hours. To speed up the system we haveimplemented an on-demand loading system. Initiallythe system takes a few seconds to load the skeletalrepresentation of the scene graph with just boundingboxes. Once loaded, the user commences the walk-



through while a fourth, asynchronous background pro-cess automatically loads the geometry for the nodes inthe scene graph that are visible. We have found thatadding such a feature is very useful in terms of systemdevelopment and testing its performance on new com-plex environments.

8 Limitations and Future WorkOur current implementation of GigaWalk has manylimitations. The current system works only for staticenvironments, and it would be desirable to extend it todynamic environments as well, perhaps with a strategysimilar to the one proposed in [EMB01].

The memory overhead of GigaWalk can be high. Inthe current implementation, viewing an entire model re-quires loading the scene graph and HLODs. It wouldbe useful to develop an out-of-core rendering systemthat uses a finite memory footprint and uses prefetch-ing techniques to load the visible nodes.

The preprocessing time for our largest dataset, theDouble Eagle, was also higher than desired. Sincemost nodes in the scene graph are non-overlapping, theLODs can be generated independently. Thus the al-gorithm could compute the LODs and HLODs in par-allel, using multiple threads. This could improve thepreprocessing performance considerably, reducing the32.5 hours spent on the Double Eagle to overnight.

One interesting possibility for further increasing theefficiency of GigaWalk would be to use speculative ren-dering in the RVG process to eliminate any time lostto pipeline stalls when RVG needs to wait for visiblenodes from the STC process. Since we know that thegeometry rendered during the last frame is likely to stillbe visible in the current frame, the RVG process couldproceed to render nodes from the old list whenever theSTC is not ready with new data. It would also beuseful to use a progressive occlusion culling algorithm[GKM93], as opposed to a two-pass HZB algorithm. Itmay need extra support from the graphics hardware.

The algorithm described in this paper guarantees im-age quality in terms of a bound on screen-space LODerror, but there are no guarantees on the frame rates.The current system would be improved by the additionof a target-frame-rate rendering mode. Furthermore,the current system’s use of static LODs and HLODsleads to some popping when switching between de-tail levels. We would like to explore view-dependentor hybrid view-dependent/static LOD-based simplifica-tion approaches that can improve the fidelity of our ge-ometric approximations without increasing the polygoncount, while decreasing popping artifacts.

Finally we are interested in adapting GigaWalk toa distributed system architecture using two graphics-capable PCs, connected using a standard network. Weexpect that the network bandwidth requirement will beless than 10-megabits per second, enabling the systemto run over a standard ethernet LAN. Our current imple-

mentation runs on a shared-memory SGI workstation.We believe that taking advantage of the performance ofcurrent commodity PC graphics hardware will both im-prove the rendering performance and enable wider useof the resulting system.

AcknowledgmentsOur work was supported in part by ARO Con-tract DAAD19-99-1-0162, NSF award ACI 9876914,ONR Young Investigator Award (N00014-97-1-0631),a DOE ASCI grant, and by Intel Corporation.

The Double Eagle model is courtesy of Rob Lisle,Bryan Marz, and Jack Kanakaris at NNS. The PowerPlant environment is courtesy of an anonymous donor.We would like to thank Carl Erikson, Brian Salomonand other members of UNC Walkthrough group fortheir useful discussions and support. Special thanks toDorian Miller for help measuring end-to-end latencieswith his latency meter [MB02].

References[ACW+99] D. Aliaga, J. Cohen, A. Wilson, H. Zhang,

C. Erikson, K. Hoff, T. Hudson, W. Stuer-zlinger, E. Baker, R. Bastos, M. Whitton,F. Brooks, and D. Manocha. Mmr: An inte-grated massive model rendering system usinggeometric and image-based acceleration. InProc. of ACM Symposium on Interactive 3DGraphics, 1999.

[ARB90] J. Airey, J. Rohlf, and F. Brooks. Towardsimage realism with interactive update rates incomplex virtual building environments. InSymposium on Interactive 3D Graphics, pages41–50, 1990.

[ASVNB00] C. Andujar, C. Saona-Vazquez, I. Navazo, andP. Brunet. Integrating occlusion culling andlevels of detail through hardly-visibly sets. InProceedings of Eurographics, 2000.

[AT99] J. Alex and S. Teller. Immediate-mode ray-casting. Technical report, MIT LCS TechnicalReport 784, 1999.

[BMH99] D. Bartz, M. Meibner, and T. Huttner. Openglassisted occlusion culling for large polygonalmodels. Computer and Graphics, 23(3):667–679, 1999.

[Clar76] Clark, J. Hierarchical Geometric Models forVisible Surface Algorithms. Communicationsof the ACM, 547-554, 1976.

[Cohe96] Cohen, J., Varshney, A., Manocha, D., Turk,G., Weber, H., Agarwal, P., Brooks, F., andWright, W. Simplification Envelopes. InProc.of ACM SIGGRAPH, 119-128, 1996.

[COCS01] D. Cohen-Or, Y. Chrysanthou, and C. Silva.A survey of visibility for walkthrough applica-tions. SIGGRAPH Course Notes # 30, 2001.

[CT97] S. Coorg and S. Teller. Real-time occlusionculling for models with large occluders. InProc. of ACM Symposium on Interactive 3DGraphics, 1997.



[DDTP00] F. Durand, G. Drettakis, J. Thollot, andC. Puech. Conservative visibility preprocess-ing using extended projections.Proc. of ACMSIGGRAPH, pages 239–248, 2000.

[EM99] C. Erikson and D. Manocha. Gaps: Generaland automatic polygon simplification. InProc.of ACM Symposium on Interactive 3D Graph-ics, 1999.

[EMB01] C. Erikson, D. Manocha, and W. Baxter.HLODS for fast display of large static anddynmaic environments.Proc. of ACM Sym-posium on Interactive 3D Graphics, 2001.

[ESSS01] J. El-Sana, N. Sokolovsky, and C. Silva. Inte-grating occlusion culling with view-dependentrendering.Proc. of IEEE Visualization, 2001.

[ESV99] J. El-Sana and A. Varshney. Generalized view-dependent simplification.Computer GraphicsForum, pages C83–C94, 1999.

[EYAE99] S. Ellis, M. Young, B. Adelstein, andS. Ehrlich. Discrimination of changes of la-tency during voluntary hand movement of vir-tual objects. InProc. of the Human Factorsand Ergonomics Society, 1999.

[FH98] P. Felzenszwalb and D. Huttenlocher. Effi-ciently computing a good segmentation. InProceedings of IEEE CVPR, pages 98–104,1998.

[FKST96] T.A. Funkhouser, D. Khorramabadi, C.H. Se-quin, and S. Teller. The ucb system for inter-active visualization of large architectural mod-els. Presence, 5(1):13–44, 1996.

[GBW90] B. Garlick, D. Baum, and J. Winget. Inter-active Viewing of Large Geometric DatabasesUsing Multiprocessor Graphics Workstations.In SIGGRAPH ’90 Course Notes (Parallel Al-gorithms and Architectures for 3D Image Gen-eration), volume 28, 1990.

[GH97] M. Garland and P. Heckbert. Surface simpli-fication using quadric error bounds.Proc. ofACM SIGGRAPH, pages 209–216, 1997.

[GKM93] N. Greene, M. Kass, and G. Miller. Hierarchi-cal z-buffer visibility. InProc. of ACM SIG-GRAPH, pages 231–238, 1993.

[Gre01] N. Greene. Occlusion culling with optimizedhierarchical z-buffering. InACM SIGGRAPHCOURSE NOTES ON VISIBILITY, # 30, 2001.

[HEB+01] G. Humphreys, M. Eldridge, I. Buck, G. Stoll,M. Everett, and P. Hanrahan. WireGL: A scal-able graphics system for clusters.Proc. ofACM SIGGRAPH, 2001.

[HMC+97] T. Hudson, D. Manocha, J. Cohen, M. Lin,K. Hoff, and H. Zhang. Accelerated occlu-sion culling using shadow frusta. InProc. ofACM Symposium on Computational Geome-try, pages 1–10, 1997.

[Hop96] H. Hoppe. Progressive meshes. InProc. ofACM SIGGRAPH, pages 99–108, 1996.

[Hop97] H. Hoppe. View dependent refinement of pro-gressive meshes. InACM SIGGRAPH Confer-ence Proceedings, pages 189–198. ACM SIG-GRAPH, 1997.

[Hop98] H. Hoppe. Smooth view-dependent level-of-detail control and its application to terrain ren-dering. InIEEE Visualization Conference Pro-ceedings, pages 35–42, 1998.

[Kru56] J.B. Kruskal On the shortest spanning subtreeof a graph and the traveling salesman problem.Proceedings of American Mathematical Soci-ety, 7:48–50, 1956.

[KS00] J. Klowoski and C. Silva. The prioritized-layered projection algorithm for visible set es-timation. IEEE Trans. on Visualization andComputer Graphics, 6(2):108–123, 2000.

[KS01] J. Klowoski and C. Silva. Efficient conser-vative visiblity culling using the prioritized-layered projection algorithm. IEEE Trans.on Visualization and Computer Graphics,7(4):365–379, 2001.

[LE97] D. Luebke and C. Erikson. View-dependentsimplification of arbitrary polygon environ-ments. InProc. of ACM SIGGRAPH, 1997.

[Lue01] D. Luebke. A developer’s survey of poly-gon simplification algorithms.IEEE CG & A,pages 24–35, May 2001.

[MB02] D. Miller and G. Bishop. Latency meter: adevice for easily monitoring VE delay. InProceedings of SPIE, Vol. #4660 StereoscopicDisplays and Virtual Reality Systems IX, SanJose, CA, January 2002.

[RB93] J. Rossignac and P. Borrel. Multi-resolution3D approximations for rendering. InMod-eling in Computer Graphics, pages 455–465.Springer-Verlag, June–July 1993.

[RH94] J. Rohlf and J. Helman. Iris Performer: Ahigh performance multiprocessor toolkit forrealtime 3D Graphics InProc. of ACM SIG-GRAPH, 381–394, 1994.

[RL00] S. Rusinkiewicz and M. Levoy. QQplat:A multiresolution point rendering system forlarge meshes. Proc. of ACM SIGGRAPH,2000.

[SBM+94] B. Schneider, P. Borrel, J. Menon, J. Mittle-man, and J. Rossignac. BRUSH as a walk-through system for architectural models. InFifth Eurographics Workshop on Rendering,pages 389–399, July 1994.

[Sch97] W. Schroeder. A topology modifying progres-sive decimation algorithm. InProceedings ofVisualization’97, pages 205–212, 1997.

[SDDS00] G. Schaufler, J. Dorsey, X. Decoret, and F. Sil-lion. Conservative visibility preprocessing us-ing extended projections.Proc. of ACM SIG-GRAPH, pages 229–238, 2000.

[SFLS00] R. Samanta, T. Funkhouser, K. Li, and J. P.Singh. Hybrid sort-first and sort-last parallelrendering with a cluster of pcs.Eurograph-ics/SIGGRAPH workshop on Graphics Hard-ware, pages 99–108, 2000.

[Tel92] S. J. Teller.Visibility Computations in DenselyOccluded Polyheral Environments. PhD the-sis, CS Division, UC Berkeley, 1992.



[WSB01] I. Wald, P. Slusallek, and C. Benthin. Interac-tive distributed ray-tracing of highly complexmodels. InRendering Techniques, pages 274–285, 2001.

[WWS00] P. Wonka, M. Wimmer, and D. Schmalstieg.Visibility preprocessing with occluder fusionfor urban walkthroughs. InRendering Tech-niques, pages 71–82, 2000.

[WWS01] P. Wonka, M. Wimmer, and F. Sillion. Instantvisibility. In Proc. of Eurographics, 2001.

[XESV97] J. Xia, J. El-Sana, and A. Varshney. Adap-tive real-time level-of-detail-based renderingfor polygonal models. IEEE Transactionson Visualization and Computer Graphics,3(2):171–183, June 1997.

[ZMHH97] H. Zhang, D. Manocha, T. Hudson, andK. Hoff. Visibility culling using hierarchi-cal occlusion maps. Proc. of ACM SIG-GRAPH’97, 1997.


GigaWalk: Interactive Walkthrough of Complex...

Documents

Transcript of GigaWalk: Interactive Walkthrough of Complex...