rynson w.h. lau real-time continuous multiresolution ...rynson/papers/presence98.pdf · presence,...

Rynson W.H. LauMark Green*Danny ToandJanis WongComputer Graphics and MediaLaboratoryDepartment of ComputingThe Hong Kong PolytechnicUniversityHong [email protected]

Real-Time ContinuousMultiresolution Method forModels of Arbitrary Topology

Abstract

Many multiresolution methods have been proposed. Most of them emphasize accu-racy and hence are slow. Some methods may be fast, but they may not preserve thegeometry of the model. Although there are a few real-time multiresolution methodsavailable, they are developed mainly for handling large terrain models. In this paper,we present a very efficient multiresolution method for continuously reducing the reso-lution of a triangle model by incrementally removing triangles from it. The algorithm issimple to implement, requires no complicated data structures, and has a linear triangledeletion rate. We also present a method for caching the most recent sequence oftriangle removal operations into a list, called the simplification list, so that it is possibleto continuously increase the resolution of the model by inserting triangles in the re-verse order of the sequence. We will compare our method with Hoppe’s progressivemeshes. Towards the end of the paper, we discuss the performance and memoryusage of our method.

1 Introduction

Because visual feedback plays a very important role in human communi-cation, most existing VR applications require the use of expensive graphicshardware to provide high rendering throughput. To improve the overall perfor-mance of a given graphics system, our current research is directed toward devel-oping a framework for time-critical rendering in VR (Green, 1996). That is, weare looking at different aspects of the image-rendering process, trying to main-tain a constant frame rate by trading off the least important factors. For ex-ample, when there are too many objects to be processed and rendered withinthe given frame time, we may consider using flat shading instead of Gouraudshading or using low-resolution object models when rendering objects of lowervisual importance. To achieve this objective, we have proposed a model for pre-dicting the time needed to render the objects. However, unlike other predictivemodels such as (Funkhouser and Sequin, 1993), ours also addresses the issuesof how various aspects of the hardware affect rendering time. This paper con-siders only one aspect of the total problem, the dynamic construction of mul-tiresolution models of 3D objects. The number of triangles used to representan object is one of the major factors affecting the object’s display rate. Themethod presented here allows us to dynamically adjust the number of triangles

Presence, Vol. 7, No. 1, February 1998, 22–35

r 1998 by the Massachusetts Institute of Technology * Department of Computer Science, University of Alberta, Alberta, Canada

22 PRESENCE: VOLUME 7, NUMBER 1

a model, in real time, and thus control the time required todisplay the model. The other aspects of our approach to timecritical rendering are presented in Green (1996).

Although the performance of graphics accelerators isincreasing rapidly, the demand for even higher perfor-mance to handle more complex environments is increas-ing too. To overcome this demand for improved render-ing performance, a technique called multiresolutionmodeling is attracting a lot of attention. The techniqueis based on the fact that distant objects occupy smallerscreen areas after projection than nearby objects do. Assuch, details of distant objects are less visible to theviewer than those of the nearby objects. To take advan-tage of this situation, multiresolution modeling opti-mizes the rendering performance by representing nearbyobjects with more detailed models, containing more tri-angles, and distant objects with simplier models, con-taining fewer triangles.

In this paper, we present a very efficient multiresolu-tion method for continuously reducing the resolution ofa given triangle model by incrementally removing tri-angles from the model. The algorithm is simple toimplement, requires no complicated data structures, andhas a linear triangle deletion rate resulting in a predict-able performance. We also present a method for cachingthe most recent sequence of triangle removal operationsinto a list, called the simplification list, so that it is pos-sible to continuously increase the resolution of themodel by inserting triangles in the reverse order of thesequence. The rest of the paper is organized as follows.Section 2 describes previous work on multiresolutionmodeling. Section 3 gives an overview of the idea pre-sented in this paper, and Section 4 presents our methodin detail. Section 5 presents the simplification list algo-rithm. Section 6 shows some experimental results anddiscusses the advantages and limitations of the method.Finally, Section 7 presents conclusions and discussessome possible future work.

2 Related Work

Existing methods for generating multiresolutionmodels can be classified into refinement methods and

decimation methods (Heckbert and Garland, 1995). Re-finement methods improve the accuracy of a minimalapproximation of a model that has been initially built(DeHaemer and Zyda, 1991; Hoppe et al., 1993; Turk,1992). They are also called global reconstruction heuris-tics. DeHaemer and Zyda (1991) use an adaptive subdi-vision method to recursively subdivide each quadrilateralpolygon into four until the error is within a given toler-ance. The location for the subdivision is selected in sucha way that the resulting error after the subdivision isminimum. Turk (1992) handles the problem as meshoptimization. He first distributes a number of verticesover the object surface based on its curvature and thentriangulates the vertices to obtain a higher-resolutionmodel with the specified number of vertices. Althoughthe algorithm works well for curved surfaces, it is slowand may fail to preserve the geometry of surfaces withhigh curvature. Hoppe et al. (1993) optimize an energyfunction over a surface iteratively to minimize the dis-tance of the approximating surface from the original, aswell as the number of vertices in the resultant approxi-mation. This may preserve the geometry of the modelbetter, but it is too slow for on-the-fly real-time compu-tations.

Decimation methods, on the other hand, remove ver-tices from an exact representation of a model to createless accurate, but simpler versions of the initial model(Cohen, et al., 1996; Eck et al., 1995; Lounsbery, DeR-ose, & Warren, 1993; Rossignac and Borrel, 1992;Schroeder, Zarge, and Lorensen, 1992). These methodsare also called local simplification heuristics since theymodify the model locally. Schroeder et al. (1992) try todelete edges or vertices from almost coplanar faces. Theresultant holes are filled by a local triangulation process.Although their method is generally faster than the re-finement methods described above, the need to processand triangulate the models in multiple passes can becomputationally expensive and hence difficult to use inreal-time generation of multiresolution models. In addi-tion, since the method does not consider feature edges,the generated models may not preserve the geometry ofthe model. Lounsbery et al. (1993) proposed the mul-tiresolution analysis on arbitrary triangle models withsubdivision connectivity, i.e., models obtained from a

Lau et al. 23

simple base model by recursively splitting each trianglein the model into four. The method is based on repeat-edly decomposing the surface function into a lower-resolution part and a set of wavelet coefficients repre-senting the surface details. Eck et al. (1995) laterproposed a method to overcome the subdivision con-nectivity limitation by approximating an input arbitrarytriangle model with one having subdivision connectivity.From the performance figures given at the end of thispaper, this method can simplify a few hundred trianglesper second. This is much faster than most existing mul-tiresolution methods, but it may still be slow for real-time multiresolution modeling. Cohen et al. (1996)proposed the idea of simplification envelopes for modelsimplification. Two envelopes, the inner envelope andthe outer envelope, are created to constraint the simplifi-cation of a model to within a given error tolerance. Ros-signac and Borrel (1992) propose a very efficient mul-tiresolution method. The object model is uniformlysubdivided into 3D cells. The resolution of the modelmay be reduced by clustering all vertices within a cell toform a single new vertex. This method can greatly sim-plify the simplification process and is therefore very fast.However, because the geometry of the model is notconsidered when subdividing it, it is possible that impor-tant vertices (and the associated triangles) that define thegeometry of the model are clustered first before the lessimportant ones. Hence this method fails to preserve thegeometry of the model.

Despite the fact that the two classes of methods cangenerate multiresolution models, there are still somelimitations in this area. These methods, especially therefinement methods, have high computational cost, andsome of them do not even preserve the geometry of themodel. To overcome the performance limitation, a com-mon method is to generate a few key models of the ob-ject at different resolutions in advance. During run-time,the object distance from the viewer determines which ofthese pre-generated models to use for rendering a par-ticular frame. This method is referred to as discrete mul-tiresolution method. Although this method is fast andsimple, it has a major limitation. Since there is usually aconsiderable visual difference between two successivemodels, when the object crosses the threshold distance,the sudden change in resolution may create an objec-

tionable visual effect. Turk (1992) proposed to have atransition period during which a smooth interpolationbetween the two successive models is performed to pro-duce models of intermediate resolutions. This method,however, further increases the computational cost dur-ing the transition period because of the need to processtwo models at the same time.

There are a few real-time multiresolution methods.They are used primarily for handling large terrain models(Falby et al., 1993; Herzen & Barr, 1987; Lindstrom etal., 1996). Falby et al. (1993) divide a large terrain sur-face into 50 3 50 square blocks. All the polygons insidea block are arranged in a quadtree structure such thatthe root node of the tree represents the whole block andthe leaf nodes represent individual polygons. Each suc-cessive lower level of the tree represents a four-time in-crease in resolution. This quadtree structure helps inculling polygons that are outside the field of view muchmore quickly and provides a multiresolution representa-tion for rendering. The major limitation of using aquadtree to represent a surface is that the surface has tobe divided into regular square tiles. Although this maybe fine for representing smooth landscapes, it may notbe the best way to represent objects or surfaces of arbi-trary topology because those objects may contain a lot ofsharp edges (or feature edges), which will cause a lot ofnodes to be generated around them.

Hoppe (1996) proposed an idea called progressivemeshes. A progressive mesh stores a pre-computed list ofedge collapses (or edge splits). By following the list inthe forward or backward direction, the resolution of themodel can be modified in a very efficient way. This ideais similar to the simplification list we propose here al-though we developed our idea independently (Isler, Lau,and Green, 1996). The major advantages of Hoppe’smethod as compared to the quadtree type of real-timemultiresolution methods are that it works on surfaces ofarbitrary topology, and the models do not have to beregularly subdivided.

3 Overview of Our Method

One may argue that it is not important to preservethe geometry of an object model since the objects will


be too far away for the changes to be visible. However,this argument is not valid for two reasons. First, in con-tinuous multiresolution modeling, triangles (or vertices)are being removed from the model in a continuous man-ner as the object moves away from the viewer. If the ge-ometry of the model is not considered, it is possible thattriangles that form important features of the model areremoved in an earlier stage while the object is still nearthe viewer. This may result in giving the incorrect per-ception to the viewer that the object is deforming as itmoves. Second, in some VR applications, there may notbe any distant objects. However, if the graphics accelera-tor is overloaded, in order to maintain a constant framerate, we may need to simplify some objects that are con-sidered as visually less important, even though these ob-jects may not be too far away from the viewer. For ex-ample, in an architectural walkthough, where there aretypically no distant objects, a sofa in an office may beconsidered as visually less important and, hence, can besimplified. However, as we still want it to look like asofa, we must preserve its geometry while removing thedetails.

Most existing multiresolution methods either spend alot of computational time trying to preserve the geom-etry of the original model in order to produce the bestpossible multiresolution model, or concentrate on theperformance of the method and not on preserving thegeometry of the original model. The method that wepropose here takes a somewhat middle course. Althoughit is important to preserve the geometry of the model,we argue that it is not necessary to spend a large amountof computational time so as to find the best triangles toremove in order to minimize some error function whenreducing the resolution of the model. The result of thisapproach is a continuous multiresolution method that isfast enough to simplify object models on-the-fly in real-time; at the same time it continuously updates a datastructure representing the geometry of the model, tomake sure that the geometry is preserved as much aspossible.

There are two major contributions of our presentwork. The first one is the introduction of the continuousmultiresolution method. The method is based on edgecollapse and can be applied to triangle models of arbi-trary topology. The second contribution is a simple en-

hancement method to the first, which makes real-timeand on-the-fly multiresolution modeling possible evenwith a less powerful computer. The cost is only a smallincrease in memory. This increase is achieved by storingthe sequence of edge collapses in a simplification list.During run time, we may decrease or increase the reso-lution of the model by following the list in the forwardor backward direction. Although our idea of the simplifi-cation list is similar to the progressive meshes proposedby Hoppe, it differs from his in the following respects:

1. We believe that in a virtual world we may have de-formable objects as well as rigid objects. Ourmethod is based on a fast multiresolution method,which also has a low pre-processing time. As such,it can handle objects with changing geometry. Onthe other hand, Hoppe’s method is based on aslow but accurate multiresolution method. Theprogressive meshes must be constructed offline,and hence cannot be used to handle objects withchanging geometry. (As an example, Hoppe[1996] indicates that a model containing 13,546triangles took 23 minutes to simplify on a 150MHz SGI Indigo2 workstation.) In this sense, ourmethod is a more general approach to multiresolu-tion modeling.

2. One of the advantages of our algorithm is that acomplete simplification list for the object need notbe constructed. The programmer can state the sizeof the simplification list associated with each ob-ject, and only the most recent sequence of edgecollapses will be stored. The programmer has morecontrol over memory resources and over thetradeoff between memory and processor time thanwith Hoppe’s algorithm, where a complete recon-struction of the object is stored in the progressivemesh.

3. The objective of our research is to develop a real-time continuous multiresolution method. Al-though the method that we have developed (to bediscussed in Section 4) can reduce the resolution ofan object model efficiently, it is unable to increasethe resolution of the model because there is noinformation on where triangles can be inserted intothe model. Hence, as the object moves away from

Lau et al. 25

the viewer, we may incrementally remove trianglesfrom the model during each frame time. As theobject moves towards the viewer, however, weneed to simplify the model starting from the high-est resolution until the intended resolution isreached during every frame time. Our idea of cach-ing, in a simplification list, the most recent se-quence of edge collapses was developed to solvethis limitation. This list contains a minimal amountof information and is not meant to replace the datastructure of the object model. By following thereverse order of the list, we may perform edge un-collapses to increase the resolution of the model.This idea was first mentioned in Isler, Lau, &Green (1996) as possible future work. On theother hand, it appears to us that Hoppe developedhis idea oriented towards progressive transmissionof object models as he puts all the informationneeded to recreate the object model, such as thevertex coordinates, into the progressive mesh datastructure. In this way, transmission of the modelcan be achieved by transmitting the correspondingprogressive mesh alone, starting with the low resolu-tion end. At the receiving side, the model may be re-constructed to whatever resolution desired, dependingon the time available for receiving the data.

4. In order to reduce the bandwidth in transmittingthe progressive meshes, Hoppe suggests encodingthe vertex coordinates stored in the meshes. Thisapproach will certainly decrease the overall perfor-mance of the method when used in real-time mul-tiresolution modeling. On the other hand, oursimplification list is not developed for model trans-mission. Hence, no compression is applied to re-duce the size of the list. The list stores only enoughinformation for multiresolution modeling. As willbe shown later, the simplification list method isvery efficient and requires a small amount of addi-tional memory.

4 Real-Time Multiresolution Method

In our method, we assume that the object model iscomposed of triangles. However, curved surfaces can be

handled by first converting them into triangle meshes.The process of generating multiresolution models is di-vided into two stages, the pre-processing stage and therun-time stage. During the pre-processing stage, we cal-culate the visual importance value (or simply the impor-tance value) of each vertex in the model according to thelocal geometry. Based on these vertex importance values,we also calculate the importance value of each triangleedge in the model. All edges are then divided intogroups according to their importance values. During therun-time stage, we remove a specified number of tri-angles from the model. This number is determined bythe time available to render the object (Green, 1996)and the distance of the object from the viewer at a par-ticular frame. To remove triangles without re-triangula-tion, we introduce an operator called edge collapse. Edgecollapse works by merging one of the two vertices of anedge onto the other one; the former vertex is referred toas the collapsed vertex and the latter one as the survivingvertex. The removal of triangles is achieved by collapsingedges starting with those in the lowest importancegroup. The method is summarized in the followingtable, and we discuss the various operations in detail inthe following subsections.

Pre-processing stageCalculate the visual importance of all vertices.Calculate the visual importance of all edges.Create the visual importance table by dividing alledges into groups.

Run-time stageSelect an edge to collapse from the visual importancetable.Check for edge crossover.Collapse the edge, and update neighboring geometricinformation.Recalculate the visual importance of all affected verti-ces and edges.

4.1 Visual Importance of aTriangle Vertex

In order to define the importance of a vertex, weclassify vertices into three types, namely flat vertices, edgevertices, and corner vertices. A flat vertex is located on a


locally flat surface and, therefore, all triangles connectedto it have similar orientations. A flat vertex can be re-moved if needed. By contrast, an edge vertex is locatedalong a feature edge of an object and hence all the tri-angles connected to it can roughly be divided into twogroups according to their orientations. An edge vertexcan be removed if the collapse is along the feature edge.Finally, a corner vertex is located at a sharp corner of thesurface, which is usually the intersection point of mul-tiple feature edges. The removal of a corner vertex willcertainly affect the geometry of the object model andhence it should be the last to be removed. Figure 1shows examples of the three types of vertices.

To determine the visual importance of a vertex, wecompute the largest angle between any two normal vec-tors of the triangles connected to the vertex. Althoughthis largest angle can be computed by comparing all thenormal vectors with each other, this comparison is ex-pensive to do at run-time when we need to recalculatethe visual importance of all affected vertices and edgesafter an edge-collapse operation. Instead, we approxi-mate the angle by finding the minimum and maximumvalues (xmin, xmax, ymin, ymax, zmin, zmax) of all triangle nor-mal vectors around the vertex. The vertex importance isthen calculated as follows:

Vimp 5 (xmax 2 xmin) 1 (ymax 2 ymin) 1 (zmax2 zmin) (1)

If Vimp is smaller than a given threshold, VThres, the vertexis considered as a flat vertex; otherwise, if the normalvectors of the triangles connected to the vertex can beclassified into exactly two groups with respect to theirorientations, the vertex is considered as an edge vertex.The importance values Vimp1

and Vimp2of the two groups

are calculated independently with Equation 1. The im-portance value of the edge vertex is then calculated as:

Vimp 5 Max(Vimp1, Vimp2

) (2)

If a vertex is neither a flat vertex nor an edge vertex, it isconsidered as a corner vertex.

4.2 Visual Importance of aTriangle Edge

Once we have calculated the importance of all ver-tices, we proceed to calculate the importance value ofeach triangle edge. This importance value indicates howmuch the geometry of the model will be affected if theedge is collapsed. Currently, we consider two factors, thelength of the edge and the importance values of its twovertices as follows:

Eimp 50E 0

Lref* Min(V1imp, V2imp) (3)

where V1imp and V2imp are the importance values of thetwo vertices V1 and V2, respectively, of edge E. 0E 0 is thelength of E. Lref is a reference length for bounding 0E 0 sothat the edge importance values can be quantized intogroups. In our implementation, Lref is proportional tothe maximum extent of the object in the x, y, or z direc-tion. Both V1imp and V2imp are already bounded by thethreshold value, VThres. We consider 0E 0 in calculating theedge importance because it indicates how important thetwo adjacent triangles are. A short edge indicates thatthe adjacent triangles are either small or degenerate. Asmall triangle covers relatively small area and causes lesserror than a larger one if removed. A degenerate trianglereduces the performance of the graphics hardware and ismore prone to rendering and numerical errors. In eithercase, the triangle should have a higher priority to be re-moved, and hence the edge should be assigned a lowervisual importance value. For the second term of theequation, the reason for choosing the minimum of thetwo vertex importance values is that we may perform anedge collapse when one of the two vertices has a lowvisual importance value. The details of this will be dis-cussed in Section 4.5.

Figure 1. Three types of vertices: flat, edge, and corner.

Lau et al. 27

4.3 The Visual Importance Table

In our earlier method (Isler, Lau, & Green, 1996),we perform a full sorting on all triangles according totheir importance values. Triangles are removed startingwith the one having the lowest value. During run time,this sorting process is also needed to reorder the priori-ties of some triangles whose importance values arechanged by the latest edge collapse operation. The com-plexity of the sorting process is O (nT), where n is thenumber of edges to be removed, and T is the number oftriangles in the model. To eliminate this sorting process,we adopt a quantization method here. We divide themaximum range of edge importance values into a fixednumber of groups. In our current implementation, weuse 100 to 1,000 groups depending on the size of themodel. Each group is basically a linked list of triangleedges whose importance values fall inside the range cov-ered by the group. The list is not sorted and is main-tained in a first-in first-out manner. When an edge is in-serted in a list, it is added to the end of the list. When anedge is to be removed from a list, it is taken from thebeginning of the list. Figure 2 shows an example of thevisual importance table.

We set up the visual importance table in the pre-pro-cessing stage. During the run-time stage, we simplify theobject model by collapsing triangle edges one at a timetaken from the edge list of the lowest visual importancegroup. Normally, two triangles will be removed as a re-sult of an edge collapse, except at the boundary of a sur-face where only one triangle will be removed. After anedge collapse, all the edges that were originally con-nected to the collapsed vertex are now connected to thesurviving vertex. We need to re-compute their impor-tance values. If the new importance value of an affected

edge is outside the importance range of its currentgroup, it is moved to the end of the edge list in the ap-propriate group.

The idea of quantizing the edge importance values isto trade off accuracy for efficiency. This quantizationmethod is much more efficient than the original sortingmethod. However, it causes errors, as all edges within agroup are considered as equally important. A way to re-duce this quantization error is by increasing the numberof groups in the table, but this will increase the memorycost too.

4.4 Edge Collapse

In our earlier work (Isler, Lau, & Green, 1996),we proposed two operators, edge collapse and trianglecollapse, for simplifying a triangle mesh, with trianglecollapse being the preferred operator because it can re-move four triangles each time instead of two, as with theedge collapse operator. In this work, we suggest the useof the edge collapse operator alone for simplifying objectmodels for the following reasons:

• The triangle-collapse operation can be separatedinto two edge-collapse operations.

• The use of the edge collapse operator alone furthersimplifies the multiresolution method because onlyone operator is used.

• There is only one type of data structure stored in thesimplification list instead of two.

An edge collapse merges two vertices of an edge into asingle point. Ideally, the final point should be some-where along the edge to be collapsed so as to minimizethe error of the approximation. However, we choose tohave the final point as one of the two original verticesbecause it is fast and does not require the creation ofnew vertices. Figure 3 shows an example of the edgecollapse operation.

4.5 Edge Collapse Criteria

In order to minimize the change in the geometryof the model, edges are collapsed according to their im-portance values. An edge has a low importance value if it

Figure 2. The visual importance table.


is not important in defining the geometry of the model,and hence its removal does not cause a high error be-tween the simplified and the original models.

Since each edge has two vertices and each vertex maybe classified as flat, edge, or corner, there are six possibleedge types. If we denote a flat vertex as F, an edge vertexas E, and a corner vertex as C, the six edge types are F–F,F–E, E–E, C–F, C–E, and C–C. If both vertices are oftype flat, we can always perform an edge collapse bymerging the vertex with lower visual importance to theother one. If only one of the two vertices is of type flat,we can still perform an edge collapse by merging the flatvertex to the other vertex. If both of them are of typecorner, we should not perform a collapse unless all theremaining vertices in the model are of type corner too.An edge collapse in this case will certainly affect the ge-ometry of the model. However, at this time, the objectmay already be too far away for the change to be visible.For the remaining types, E–E and C–E, we may performan edge collapse only if the two vertices share a commonfeature edge. The following table shows a summary ofthe six cases.

4.6 Detecting Crossover Edgesand Collinear Edges

Normally, when we collapse an edge, the geometryof the model remains essentially the same since the ori-entations of the neighboring triangles do not changesignificantly after the collapse. However, there is an ex-ceptional situation. When we collapse an edge, someneighboring edges may cross over the others, resultingin a dramatic change in orientations for some triangles.

We need to detect this situation and prevent such a col-lapse. Figure 4 shows an example of this situation. Al-though both V1 and V2 may be considered as flat verti-ces, as we collapse V2 onto V1, edge V2–V5 will becomeV1–V5 and cross over edge V3–V4 as shown in the 2Dview of Figure 4(b). This will cause triangle S9 to have adramatic change in orientation, resulting in a visual dis-continuity as shown in the 3D view of Figure 4(b).

To prevent this result, we compare the normal vectorsof each affected triangle before and after the collapse. Ifthe change in orientation of a triangle is found to be toohigh, the collapse is not performed. Since this crossoverproblem does not occur very often and we need to up-date the normal vector of the triangle anyway if the col-

Figure 3. Collapsing an edge into a point.

TABLE I

CasesEdgetypes

Collapsedirections Conditions

1 F–F & Collapse to the vertex withlower visual importance.

2 F–E = Always collapse to the edgevertex.

3 E–E & Collapse only when theyshare a common featureedge.

4 C–F ; Always collapse to the cornervertex.

5 C–E ; Collapse only when theyshare a common featureedge, and always collapseto the corner vertex.

6 C–C x No collapse.

Figure 4. Crossover of triangle edges.

Lau et al. 29

lapse is performed, the cost of this method is only anextra comparison.

In addition, it is sometimes possible that collapsing anedge will remove three or more triangles. This happenswhen some edges are collinear. For example, in Figure 5,E3, E4, and E5 are collinear edges. If we collapse V1 ontoV2, all three triangles will be removed. This situation canalso be detected with the above method. If E1 in Figure5 is collapsed first, triangle T3 will become a line and itsnormal vector after the collapse will be zero. To preventcreating a new type of data structure to handle this situa-tion, we do not allow E1 to collapse. Instead, we mayconsider collapsing E5 first, for example, before we con-sider collapsing E1.

5 The Simplification List

In the previous section, we presented a method forgenerating real-time multiresolution models. Althoughthe method is very efficient in removing triangles as theobject moves further away from the viewer, it is not effi-cient if the object moves towards the viewer. Considerthe situation when an object is moving away from theviewer. Between two consecutive frames the objectmoves a little farther away from the viewer and hence anadditional few triangles are removed from the objectmodel. In this situation, the method works fine even inenvironments containing a large number of objects.However, if the object moves towards the viewer, be-tween two consecutive frames the object moves a littlebit closer to the viewer and hence an additional few tri-angles need to be added to the model to provide more

detail. Unfortunately, we do not know where the tri-angles should be inserted. Hence, although the differ-ence may be only a few triangles, we need to simplifyfrom the high-resolution model to the intended resolu-tion during every frame. If a lot of objects are movingsimultaneously towards the viewer, the cost of simplifica-tion will become too high to be practical.

We have developed a simple method to overcome thisproblem: cache the most recent sequence of edge col-lapses in a last-in-first-out circular buffer, called the sim-plification list. A record is stored into the buffer when-ever an edge is removed from the model. When thebuffer is full, the oldest records will be replaced by themost recent records. If the object moves farther awayfrom the viewer, edges are removed from the modelsand records are inserted into the buffer. If the objectmoves towards the viewer, we perform an ‘‘un-collapse’’operation by reconstructing the model from the infor-mation stored in the buffer. The most recently insertedrecords provide information on which edges (or tri-angles) are to be reconstructed. With this improvement,we need to simplify from the initial high-resolutionmodel only when the object moves a large distance to-ward the viewer, which results in exhausting the buffer.(Here, a low watermark may actually be used to triggerthe start of the simplification process before the buffer iscompletely exhausted.) This method relieves the need tosimplify from the high-resolution model to the intendedresolution once per frame, to once every several framesas the object moves towards the viewer. The actual num-ber of frames depends on the size of the buffer. This im-provement basically trades off memory for efficiency.The data structure for storing the information about anedge collapse is as follows:

typedef struct 5

short colvertex; /* colapsed vertex of the edge */

short survertex; /* surviving vertex of the edge */

short remedge[2]; /* two removed edges */

short suredge [2]; /* two surviving edges */

6 EdgeRecord;

typedef EdgeRecord simplificationlist[MaxEdges];

The information needed in order to execute an edgeun-collapse operation is stored in an EdgeRecord. Here

Figure 5. Edge collapse problem with collinear edges.


colvertex and survertex store the IDs for the collapsedvertex and the surviving vertex, respectively, of an edgecollapse. The two locations in remedge store the IDs ofthe two removed edges due to the removal of the twoadjacent triangles, and those in suredge store the IDs ofthe two surviving edges of the two triangles as shown inFigure 6.

To take this idea to the extreme, we may pre-generatea complete simplification list of the model. We simplifyan object model from the highest resolution to the low-est one and save all the edge collapse records into a fullsimplification list in advance. During run time, we usethe full simplification list to reconstruct the model of aparticular resolution, whether the object moves closer toor farther away from the viewer. The major advantage ofcreating a full simplification list is speed. We no longerneed to determine at run time which edges to collapse.The sequence of edge collapses are all determined inadvance. In the multiresolution method discussed in theprevious section, in order to achieve real-time perfor-mance, we simplify a lot of tests when selecting edges tocollapse. For example, we divide all edges into groupsaccording to their visual importance to save sortingtime. If the simplification process is done in advance, wemay perform more checks to produce more accuratemultiresolution models. This approach of generatingmore accurate models is taken by Hoppe (1996).

6 Results and Discussions

We implemented our method in C11 and Open-Inventor. Figure 7 shows some output images of a facemodel with the multiresolution method. Images in col-

umn (i) show the model in full resolution (4,356 tri-angles). Those in columns (ii), (iii), and (iv) have 3,000,2,000, and 860 triangles, respectively. On the otherhand, the images in row (a) show the model at differentresolutions and placed at appropriate distances from theviewer. The images in row (b) show the close-up viewsof the model at different resolutions. The images in row(c) show the triangle mesh of the model at differentresolutions. Figure 8 shows the output images of a land-scape at different resolutions (triangles:9,620 = 5,690 = 1,680).

We tested the program on an SGI Indigo2 workstationwith a 195MHz R10000 CPU and Solid Impact graph-ics accelerator. Figure 9 shows the performance of ourmultiresolution method, i.e. the run-time performanceof the edge collapse operator without the simplificationlist, in simplifying the face model shown in Figure 7. Wecan see that the number of triangles removed is close tolinear in the time taken to remove them. We have deter-mined that the method can eliminate about 8,700 tri-angles per second. At first glance, this number may ap-pear to be small. However, this number represents anincremental change in the number of triangles per sec-ond. On the other hand, we would expect to be able toachieve a two to three times performance improvementif we could implement the algorithm in a low-level lan-guage. We have compared the new method with ourearlier method (Isler, Lau, & Green, 1996) under thesame system configuration. The new method is overthree times faster than the old one. We have also mea-sured the pre-processing time of the new method on theface model as shown in Table 2.

From the figures, we can see that the pre-processingtime of the multiresolution method is short, and the

Figure 6. Triangle edges affected by an edge collapse.

Lau et al. 31

creation of the full simplification list is also very efficient.(Note that the 0.47 s already includes the time neededto collapse all the edges in the model using the mul-tiresolution method.) The computational complexitiesof both the pre-processing algorithm and the run-timealgorithm are proportional to the number of edges tocollapse. Since, in most situations, an edge collapsecauses two triangles to be removed, the computationalcomplexity of the method is O(n), where n is the num-ber of triangles in the model.

Figure 10 shows the performance of edge collapses

and edge uncollapses when the simplification list is used.We have determined that the system can collapse ap-proximately 133,333 triangles per second and can un-collapse approximately 160,000 triangles per second.

Figure 11 shows the frame rates of rendering the facemodel shown in Figure 7 as it moves from the closestpoint (point 0 in the diagram) to the point farthest away(point 80 in the diagram). When the model is at theclosest point, it covers roughly one-third of the screenand when it is at the farthest point, it covers less than 50pixels. When there is no simplification to the model (i.e.,

Figure 7. A face model generated at different resolutions.


when the model contains 4,356 triangles) the renderingspeed is always 36 frames per second. Therefore, theframe rate does not depend on the distance or the pro-jected size of the model. However, when simplificationis used, the frame rate increases as we remove more andmore triangles from the model. The numbers shown atthe top of the diagram indicate the total numbers of tri-angles removed from the model at the correspondingdistances from the viewer. The time needed for the sim-plification process is considerably smaller and dependson the moving speed of the model. For example, if we

maintain a frame rate of 20 in a particular virtual realityapplication and the model takes 20 seconds to movefrom the closest point to the farthest point, the totalnumber of frames for the duration will be 400. Thismeans that we only need to remove 10 triangles fromthe model during each frame time, and the time spenton removing these triangles will only be 75 ms with thesimplification list.

We also tested the method on a PC with a Pentium166 MHz CPU; the system can both collapse and uncol-lapse 80,000 triangles per second. In terms of memoryusage, each edge collapse stores two vertex IDs and fouredge IDs. If each ID requires two bytes to store, eachedge collapse will require 12 bytes. The face modelshown in Figure 7 has a total of 6,633 edges. The totalamount of memory needed for the full simplification listis approximately 78 kilobytes. Of course, if memoryspace is tight, we may only keep a small section of the

Figure 8. A landscape model generated at different resolutions.

Figure 9. Performance of the multiresolution method.

TABLE 2

New method (on face model) Time

Calculation of vertex and edge importances 0.03 sCreating the visual importance table 0.00 sCreating the full simplification list 0.47 s

Figure 10. Performance of edge collapses and uncollapses with the

simplification list.

Lau et al. 33

simplification list in main memory and use a predictionalgorithm to pre-fetch other sections on demand.

It would be interesting here to consider the perfor-mance of the simplification list method if the face modeldeforms. When the surface deforms, we need to recalcu-late the importance values of all vertices and edges, rec-reate the visual importance table, and recreate the fullsimplification list. If the surface deforms by changing the3D positions of the vertices in the original high-resolu-tion face model, the data structures of the model do notneed to change. We may gradually increase the resolu-tion of the model based on the order of the simplifica-tion list as the surface is deforming and the vertex posi-tions are being updated. As soon as the deformationstops, the simplification list is recomputed by a separateprocessor. The current processor continues to use thehigh-resolution models for rendering until the list is re-computed. The amount of time needed to recomputethe full simplification list is 0.5 s (0.03 s 1 0.00 s 1

0.47 s). Of course, if the deformation is small, we mayonly need to update the vertex positions in the modelwithout recomputing the simplification list.

7 Conclusions

In this paper, we have presented an efficient mul-tiresolution method. Not only is this method fast, but italso preserves the geometry of the model as much aspossible. We have also presented an improved algorithmto the multiresolution method based on the simplifica-

tion list. Similar to Hoppe’s method, this enhancementstores the pre-computed sequence of edge collapses.With the simplification list, it is possible to decrease orincrease the resolution of the model simply by followingthe list in the forward or backward direction. UnlikeHoppe’s method, our method is based on a fast mul-tiresolution method and hence can be applied to de-formable objects. Towards the end of the paper, we havediscussed the performance and memory usage of themethod. Since the new method has linear triangle inser-tion and deletion rates, the time needed to increase ordecrease the resolution of a model by a certain amountcan easily be predicted. Hence, the new method fits wellinto our framework for time-critical rendering in VR(Green, 1996).

Currently, we are studying the possibility of paralleliz-ing the multiresolution method. There are two ap-proaches. The first approach is to distribute the task ofcreating the full simplification list to different processorsin the machine to improve the performance of creatingthe list if the object deforms. The second approach is tocluster objects of different behaviors into groups anddistribute these object clusters to other processors whenthe current processor is not fast enough to update theresolutions of all objects. We are also working on anadaptive approach to the multiresolution method de-scribed here, so that different parts of a large model mayhave different amount of simplification depending onsome run-time factors such as the viewer’s line of sight.Such a method will allow local deformations to behandled more efficiently. (Lau, To, and Green, 1997)described some initial results of this idea.

Acknowledgments

We would like to thank the anonymous reviewers for their use-ful comments and suggestions. This work is supported in partby the University Central Research Grant number 351/084.

References

Cohen, J., Varshney, A., Manocha, D., Turk, G., Weber, H.,Agarwal, P., Brooks, F., & Wright, W. (1996). Simplification

Figure 11. Frame-rate improvement with model simplification.


envelopes. ACM Computer Graphics (SIGGRAPH’96),119–128.

DeHaemer, M., & Zyda, M. (1991). Simplification of objectsrendered by polygonal approximations. Computers andGraphics, 15(2), 175–184.

Eck, M., DeRose, T., Hoppe, H., Lounsbery, M., & W. Stu-etzle. (1995). Multiresolution analysis of arbitrary meshes.ACM Computer Graphics (SIGGRAPH’95), 29, 173–182.

Falby, J., Zyda, M., Pratt, D., & Mackey, R. (1993). NPSNET:Hierarchical data structures for real-time three-dimensionalvisual simulation. Computers and Graphics, 17(1), 65–69.

Funkhouser, T., & Sequin, C. (1993). Adaptive display algo-rithm for interactive frame rates during visualization of com-plex virtual environments. ACM Computer Graphics (SIG-GRAPH’93), 27, 247–254.

Green, M. (1996). A framework for real-time rendering in vir-tual reality. ACM Symposium on Virtual Reality Softwareand Technology, 3–10.

Heckbert, P., & Garland, M. (1995). Fast polygonal approxi-mation of terrains and height fields. Technical ReportCMU-CS-95-181, School of Computer Science, CarnegieMellon University.

Herzen, B., & Barr, A. (1987). Accurate triangulations of de-formed, intersecting surfaces. ACM Computer Graphics(SIGGRAPH’87), 21, 103–110.

Hoppe, H. (1996). Progressive meshes. ACM ComputerGraphics (SIGGRAPH’96), 99–108.

Hoppe, H., DeRose, T., Duchamp, T., McDonald, J., & Stu-etzle, W. (1993). Mesh optimization. ACM ComputerGraphics (SIGGRAPH’93), 27, 19–26.

Isler, V., Lau, R. W. H., & Green, M. (1996). Real-time multi-resolution modeling for complex virtual environments.ACM Symposium on Virtual Reality Software and Technol-ogy, 11–20.

Lau, R. W. H., To, D., & Green, M. (1997). An adaptivemulti-resolution modeling technique based on viewing andanimation parameters. IEEE Virtual Reality Annual Inter-national Symposium, 20–27.

Lindstrom, P., Koller, D., Ribarsky, W., Hodges, L., Faust, N.,& Turner, G. (1996). Real-time, continuous level of detailrendering of height fields. ACM Computer Graphics (SIG-GRAPH’96), 109–118.

Lounsbery, M., DeRose, T., & Warren, J. (1993). Multiresolu-tion analysis for surfaces of arbitrary topological type. Tech-nical Report TR931005b, Department of Computer Scienceand Engineering, University of Washington.

Rossignac, J., & Borrel, P. (1992). Multi-resolution 3D ap-proximations for rendering complex scenes. Technical Re-port RC 17697 (#77951), IBM Research Division, T.J.Watson Research Center.

Schroeder, W., Zarge, J., & Lorensen, W. (1992). Decimationof triangle meshes. ACM Computer Graphics (SIG-GRAPH’92), 26, 65–70.

Turk, G. (1992). Re-tiling polygonal surfaces. ACM ComputerGraphics (SIGGRAPH’92), 26, 55–64.

Lau et al. 35

rynson w.h. lau real-time continuous multiresolution ...rynson/papers/presence98.pdf · presence,...

Documents