View-dependent Polygonal Simplification Pekka Kuismanen HUT pkuisman@cc.hut.fi Abstract This paper describes methods for view-dependent simplification of polygonal environments. A description of a refinement algorithm and different types of selective refinement criteria that the algorithm could be applied to is given. An imaginative scene helps to illustrate the workings of the algorithm together with selective refinement criteria in a more concrete way. Finally, there is a comparison of methods for constructing the vertex tree. 1 INTRODUCTION Since 1976 (Clark, 1976), techniques for simplifying polygonal objects and scenes have been developed. These techniques allowed displaying polygonal models at various resolutions and levels of detail. For example, early flight simulators used handcrafted multi-resolution models of airplanes and landscape to guarantee a constant framerate. In the recent years, polygonal simplification has become important in displaying complex models with a very large number of polygons. These complex models may be, e.g., CAD models, terrains generated from satellite data, and laser scanned models (see Figure 1). View-dependent polygonal simplification uses selective refinement criteria based on the position and orientation of the view frustum relative to the model. This means that objects closer to the viewer are displayed in more detail than others. Furhermore, objects outside the view frustum are simplified minimizing the amount of data entering the rendering pipeline. Also, since object silhuettes and contours are important in recognizing shape (Xia and Varshney, 1996), they are allocated more detail than planes perpendicular to the viewer (see Figure 1). This paper is an overview of methods for view dependent simplification. 1
Figure 1: Simplified laser scanned bunny-model of 10,528 (original 69,473) faces (Hoppe, 1997a). 2 VERTEX TREE AND ACTIVE TRIANGLE LIST There are a number of considerations concerning the algorithm performing the task of view dependent simplification. Mainly, the algorithm should enable dynamic simplification of the model at runtime. The model is assumed to consist of triangles. Simplification, i.e., lowering the amount of triangles in the model, is done on different parts of the model by a certain view-dependent factor. On the other hand, it should be possible to "desimplify" or add more triangles to the model, or parts of the model, gaining a higher level of detail. The considerations taken into account lead to the assumption that an optimal approach would be to have the model exist at various levels of detail. Also, it should be possible for parts of the model to have a higher level of detail and some to have a lower one. One approach is to store the vertices of the model in a vertex tree in which the nodes near the root of the tree represent the model at the coarsest levels of detail and the leaf nodes correspond to the model at a higher detail level (see Figure 2). Nodes in the vertex tree are labeled active, inactive or boundary. The algorithm traverses the active nodes to create a simplified scene. During simplification, nodes are collapsed and labeled inactive. When more detail is allocated to the model, inactive nodes are expanded, i.e., labeled active. The vertex tree is created at preprocessing stage. Depending on the technique of construction (see Section 5), the preprocessing takes time from a few seconds to some hours on a computer comparable to a 150MHz SGI (Hoppe, 1997a, Luebke and Erikson 1997). Due to the quite long preprocessing times, as with progressive meshes (several hours) and with the octree (several seconds or minutes) these techniques can be performed only on static models. At runtime the vertex tree is queried dynamically to create a simplified scene. The vertex tree controls the order in which vertices are collapsed and stores the data necessary to collapse and uncollapse these vertices quickly. An active triangle list is also maintained. This list is a sequence of visible triangles. 2
Figure 2: The vertex tree (Luebke and Erikson, 1997). Here is the datastructure of a node in the active triangle list. struct Tri { }; Node* Node* Tri corners[3]; proxies[3]; *prev, *next; In this data structure, the corners[] represent the original corners of the triangle at the highest level of detail. The proxies[] represent the triangle corners in the current simplification. Presenting the active triangle list as a doubly linked list assumes that the amount of triangles removed or added remains relatively small. Collapsing a node in the vertex tree collapses the corners of triangles that have two or three corners in the node, but not more than one corner within any child of the node into the representative vertex of the node. These triangles are called subtris of the node. When any two corners of a triangle are collapsed the triangle becomes redundant and can be removed from the triangle list. Expanding a node is a converse operation where removed subtris become visible again as their vertices are expanded and they are added to the active triangle list. Here is the data structure of a node in the vertex tree: struct Node { BitVec id; Byte depth; NodeStatus label; // inactive, border or active Coord repvert; // representative vertex of the node Coord center; float radius; Tri * tris; // triangles containing one corner in the node Tri * subtris; // triangles containing two or more corners in the node but 3
} ; //not anymore than one corner in the nodes children. Node * parent; Byte numchildren; Node** children; Here is the pseudocode of functions collapsenode and expandnode: collapsenode (Node *N) { N->label=boundary; Foreach child C of N //label all children inactive if (C->label=inactive) collapsenode(c); C->label=inactive; Foreach triangle T in N->tris //update tri proxies foreach corner c of {1, 2, 3} T->proxies[c]= FirstActiveAncestor(T->corners[c]); Foreach triangle T in N->subtris //remove subtris from active list removetri(t); } expandnode(node *N) { foreach child C of N C->label=boundary; N->label=inactive; Foreach triangle T in N->tris //update tri proxies foreach corner c of {1, 2, 3} T->proxies[c]= FirstActiveAncestor(T->corners[c]); Foreach triangle T in N->subtris // add subtris to active list addtri(t); } Here the proxies[] of the tris (triangles that have one corner in a node) are always moved to the representative vertex (repvert) of the first active ancestor of the corner. Note that the representative vertex is a coordinate defined during preprocessing of the triangle list. At the same time the subtris[] (triangles that have two corners in a node but not more than one corner in any child of the node) are added and removed from the active list depending whether the node is collapsed or expanded. When a node is expanded, the subtris proxies[] are also made to point to the representative vertices of their first active ancestors. The idea is that when nodes are collapsed triangles disappear so that the remaining triangles corners move to new positions, covering the surface occupied by the triangles that disappeared. On expansion, the removed triangles become 4
once again visible and all the triangles corners will move back to their previous positions. 3 SELECTIVE REFINEMENT CRITERIA As mentioned above, the main selective refinement criteria are the location of the object relative to the view frustum, the distance of the object from the viewer and the orientation of the surface of the object. 3.1 Screen-space geometric error threshold The first criterion concerns with screen-space geometric error threshold, that is a runtime strategy is to collapse vertices which occupy a small amount of the screen. This criterion is the most obvious one since objects far away from the viewer consist of only a few pixels on the screen, therefore it is not necessary to use a high level of detail. Consider a node that represents several nodes clustered together. The error introduced by collapsing the vertices can be thought of as the maximum distance a vertex can be shifted during the collapse operation, which equals the length of the vector between the two farthest vertices in the cluster. The extent of this vector on the screen is the screenspace error of the node. By unfolding exactly those nodes whose screenspace error threshold exceeds a user-specified threshold t, a quality constraint is enforced on the simplification: no vertex shall move by more than t pixels on the screen. A good approximation of determining the screenspace extent of a vertex cluster can be obtained by associating a bounding volume (for example, a sphere) with each node in the vertex tree. The screenspace extent of all nodes is projected to the screen and tested with t. If the size of the node exceeds t the node needs to be expanded. Conversely, if t is larger than the screenspace extent of a node, the node is collapsed. 3.2 View frustum The second criterion is to coarsen parts of the object outside the view frustum to reduce graphics load. As the viewer shifts his view, parts of the scene move out of sight. These parts can be simplified as much as possible. However, collapsing all the nodes outside the view frustum is not feasible. The node might contain a vertice of a visible triangle. Nodes outside the view frustum can be placed into two categories: invisible and irrelevant (see figure 3). An invisible node lies outside the view frustum but contains at least one vertex of one visible triangle. Therefore expanding or collapsing an invisible node has effect on the scene so they cannot be ignored. An irrelevant node is one which expansion or collapse cannot possibly effect the scene, so these nodes can be ignored. 5
Figure 3: Invisible nodes and irrelevant nodes (Luebke and Erikson, 1997). Figure 4: The cone of normals is tested against the view cone to determine the orientation of the node (Luebke and Erikson, 1997). 3.3 Silhuette preservation The third criterion is silhuette preservation (see figure 4). Detecting nodes along object silhuettes and allocating more detail to those regions increases the perceived quality of a simplification, therefore more detail is needed on surfaces almost parallel to the line of sight. By adding two fields to the datastructure of the node conenormal (which is a vector) and coneangle (which is a floating point scalar) a cone of normals, which contains all the normals of the vertices in the node, can be defined for the node. The cone of normals can be tested against the view cone to determine the orientation of the node. The node can be either completely frontfacing, completely backfacing or potentially on the silhuette. If a surface within a node is found to be potentially lying on 6
the silhuette, the node can be tested against a tighter screenspace error than nodes with frontfacing surfaces. 4 VIEW-DEPENDENT GEOMORPHING The function of the algorithm combined with the refinement criteria described above can be understood and visualized more easily through the concept of geomorphing. Imagine a scene where the viewer flies towards a mountain, like in a flight simulator. He sees it far away in the horizon as a small triangular shape. The mountain at this point exists at its lowest level of detail and is almost like a pyramid. As the viewer flies closer towards the mountain it starts to transform. Gradually, more adjacent triangles start to appear forming slopes on the mountainside. Of course, this gradual transformation is not perceptible (in optimal conditions) to the viewer because his screen resolution is limited. If at the same time there would be another viewer close to the mountain and whose position and orientation were completely ignored by the refinement algorithm, he would see these changes. Now as the viewer flies even closer, the mountain starts to have even more detail. The sides of the pyramid are no longer distinguishable. This is because the triangles constituting the sides of the mountain at its lowest level of detail have been expanded into their numerous subtriangles. The parts of the mountain near the silhuettes relative to the viewer have more detail than other parts of the mountain. Also, the side of the mountain frontfacing the viewer has more detail than the side backfacing him (see figure 5). The mountain gradually covers the entire view of the viewer as he flies even more closer. The viewer is now close enough to notice chasms, ledges and caves on the side of the mountain. At this proximity, parts of the mountain outside the viewer s sight start to decrease in level of detail. As he flies by a highly detailed cave, the triangles constituting the cave s highest level of detail are first expanded as viewer observes the cave and then collapsed once they re outside his view. Also, when the viewer starts circling around the mountain, chasms, ledges, caves and other detail disappear when they are on the other side of the mountain relative to the viewer and reappear when the viewer flies by them once more. Figure 5: The frontfacing side has more detail than the backfacing side (Hoppe, 1997a). 7
After this, as the viewer flies away unaware (hopefully) of any change, the mountain begins to coarsen while it s triangles gradually collapse until, when he has disappeared into the horizon, there is left only a simple triangular shape consisting of a few triangles. 5 CONSTRUCTING THE VERTEX TREE Any algorithm that can be expressed in terms of vertex collapse operations can be used to create the vertex tree. The construction of the vertex tree determines the order of the vertices collapsed. This also determines the quality of the simplification. Possible algorithms range from fast and simple approaches with moderate fidelity to slower, more sophisticated methods with high fidelity. 5.1 Spatial subdivision Spatial subdivision is a simple technique and good when viewing and reviewing CAD models, where the preprocessing time of many hours is not wanted. Vertices are ranked in importance depending on surface curvature and edge length. An octree (see Figure 6), which partitions the scene into boxes, is constructed. First the most important vertex is chosen as the representative vertex of the root node of the octree, that is, the biggest box. The vertices are then partitioned among the node s eight children and the process is repeated recursively. This approach assumes that the vertices of the model are uniformly distributed. However, vertices in a CAD model are seldom uniformly distributed, simplification on small parts of the model may have undesired effects on the larger elements of the model. For example, simplification done on a guitar model s frets might effect the shape of the neck, this is not wanted. A better approach for CAD models is to use a tight octree (Luebke and Erikson, 1997). This is similar to the octree described above but in which each node of the octree is tightened to the smallest axis aligned cube that encloses the relevant vertices before the node is subdivided. This way a better runtime performance is gained. Top-down spatial subdivision mechanisms are fast to preprocess, but no assumption is made about the polygon mesh of the model. Manifold topology is not preserved. Cracks, degeneracies, T-junctions and missing polygons may appear. However in practice tight octrees seem to work well (Luebke and Erikson, 1997). 5.2 Progressive mesh and hybrid approach An optimized approach is the progressive mesh algorithm. Each edge collapse corresponds to a node in the vertex tree with two children and one or two subtris. The stream of edge collapse records in a progressive mesh contains an implicit hierarchy that maps directly to the vertex tree (Luebke and Erikson, 1997). A progressive mesh never collapses more than two vertices together at a time, which may result in an unnecessary deep vertex tree. Also, progressive meshes collapse only vertices within a mesh. Therefore merging of different objects is not possible. Manifold topology is preserved which restricts the amount of simplification possible. The preprocessing time 8
of a progressive mesh is also very long, several hours on models with a million faces (Hoppe, 1997a). Figure 6: A model of a chair in an octree (Hoppe, 1997b). A hybrid approach is also possible by combining the progressive mesh algorithm and the spatial subdivision algorithm. In this approach the objects in the scene requiring more detail are first preprocessed into progressive meshes. The objects are then merged into a tight octree without regard to topology. This way, the final vertex tree exhibits both high fidelity at low levels of the tree and drastic simplification at high levels (Luebke and Erikson 1997). 6 CONCLUSIONS The methods described above, querying the vertex tree and maintaining an active triangle list depending on view-dependent criteria, perform well when viewing models with a large amount of polygons. They support view dependent factors such as the distance and orientation of the object. Also the viewer can move within the model, as it is geomorphed. Constructing the vertex tree with an octree algorithm requires much less preprocessing time than with a progressive mesh algorithm. Preprocessing with an octree results in lower fidelity at runtime (cracks, discontinuities and missing polygons) but allows drastic simplification. With progressive meshes drastic simplification is not possible because manifold topology is preserved. In practice a hybrid approach combining the progressive mesh and octree algorithms works well (Luebke and Erikson 1997). The surface attributes of the model can be added to the model. Such attributes are characterized as discrete and scalar attributes and associated with the faces of the model. 9
Common discrete attributes include material and texture identifiers. Common scalar attributes are color, normal and texture coordinates. REFERENCES Clark, J. H. 1976 Hierarchical Geometric Models for Visible Surface Algorithms, Communications of the ACM, Vol 18, no 10, pp 547-554 Hoppe, H. 1996 Progressive Meshes, Computer Graphics (Siggraph 96), pp 99-108. Hoppe, H. 1997a View-Dependent Refinement of Progressive Meshes, Computer Graphics (Siggraph 97), pp 189-198. Hoppe, H. 1997b Robust Meshes from Multiple Range Maps, Proceedings of International Conference on Recent Advances in 3-D Digital Imaging and Modeling, pp 205-211. Luebke, D. and Erikson, C. 1997 View-Dependent Simplification Of Arbitrary Polygonal Environments, Computer Graphics (Siggraph 97), pp 199-208. Xia J. and Varshney A. 1996 Dynamic View-Dependent Simplification for Polygonal Models, in Proceedings of the IEEE Visualization 96, San Francisco, CA, pp 327-334. 10