A General Framework for Mesh Decimation

The decimation of highly detailed meshes has emerged as an important issue in many computer graphics related fields. A whole library of different algorithms has been proposed in the literature. By carefully investigating such algorithms, we can derive a generic structure for mesh reduction schemes which is analogous to a class of greedy-algorithms for heuristic optimization. Particular instances of this algorithmic template allow to adapt to specific target applications. We present a new mesh reduction algorithm which clearly reflects this meta scheme and efficiently generates decimated high quality meshes while observing global error bounds. Introduction In several areas of computer graphics and geometric modeling, the representation of surface geometry by polygonal meshes is a well established standard. However, the complexity of the object models has increased much faster than the through-put of today’s graphics hardware. Hence, in order to be able to display and modify geometric objects within reasonable response times, it is necessary to reduce the amount of data by removing redundant information from triangle meshes. A precise definition of the term redundancy in this context obviously depends on the application for which the decimated mesh is to be used. Technically speaking, the most important aspect is the approximation error, i.e., the modified mesh has to stay within a prescribed tolerance to the original data. From an optical point of view, local flatness of the mesh might be a better indicator for redundancy. It is natural that applications as different as rendering and finite element analysis put their emphasis also on the preservation of different aspects in the simplified geometric shape. In the last years, a host of proposed algorithms for mesh reduction has been applied successfully to level of detail generation [14, 2], progressive transmission [6], and reverse engineering [1]. See [15] for an overview of some relevant literature. We consider most of the suggested algorithms as generic templates leaving the freedom to plug in specific instances of predicates. For example, each algorithm is based on a scalar valued oracle which indicates the degree of redundancy of a particular vertex, edge, or triangle. Depending on the target application, different choices for this oracle are appropriate but this does not affect the algorithmic structure of the scheme. On the most abstract level, there are two different basic approaches to find a coarser approximation of a given polygonal mesh. The one is to build the new mesh without necessarily inheriting the topology of the original and the other is to obtain the new mesh by (iteratively) modifying the original without changing the topology. Having a topologically simplified model of the original mesh is useful in applications where the topology itself does not carry crucial information. For example, when rendering remote objects, small holes can be removed without affecting the quality but for a finite element simulation on the same object the holes might be important to obtain reliable results. In this paper we will analyze incremental mesh reduction, i.e., algorithms that reduce the mesh complexity by the iterative application of simple topological operations instead of completely reorganizing the mesh. We will identify the slots where custom tailored predicates or operators can be inserted and will give recommendations when to use which. We then present an original mesh reduction algorithm based on these considerations. The algorithm is fast according to Schroeder’s recent definition [17] yet allows global error control with respect to the geometric Hausdorff distance. The scheme is validated in the result section by showing and discussing some examples. Relevant algorithmic aspects The topology preserving mesh reduction schemes typically use a simple operation which removes a small submesh and retriangulates the remaining hole. Some schemes use local optimization to find the best retriangulation. To control the decimation process, a scalar valued predicate induces a priority ordering on the set of candidates for being removed. This predicate can be based purely on distance measures between the original and the reduced mesh or it can additionally take local flatness into account. This macroscopic description matches most of the known incremental mesh reduction schemes. Due to the overwhelming variety of different algorithms that have been proposed in the literature, there are several authors who attempted to identify important features and classify the different approaches accordingly [16, 15, 3]. We do not want to add another survey but we just give an abridged overview. We will focus on three fundamental ingredients that are necessary (and sufficient) to build your own mesh reduction algorithm. The ingredients are a topological operator to modify the mesh locally, a distance measure to check whether the maximum tolerance is not violated, and a fairness criterion to evaluate the quality of the current mesh. Topological operators The classical scheme of [18] removes a single vertex v and retriangulates its crown. Thus, in every step, a patch of n triangles (the valence of v) is replaced by a new patch with n 2 triangles. In general, a local edgeswapping optimization is necessary to guarantee a reasonable quality of the retriangulated patch. In [6], edges pq are collapsed into a new vertex r which removes two triangles from the mesh. This operation can also be understood as submesh removal and retriangulation. In this case the local connectivity of the retriangulation is fixed but the optimal location for r is determined by a local energy minimization heuristic. We could cut out larger submeshes from the original mesh but this would require a more sophisticated treatment of special cases. A nice property of the basic vertex-removal and edgecollapse operators is that consistency preservation is easy to guarantee. We just have to check the injectivity of the crown of the vertex v or the edge pq respectively. The rejection of all operations that would lead to complex vertices or edges is the reason why most incremental schemes do not change the global topology of a mesh. Our observation when testing different reduction schemes on a variety of meshed models is that the underlying topological operator on which an algorithm is based does not have a significant impact on the results. The quality of the resulting mesh turns out to be much more sensitive to the criteria which decide where to apply the next reduction operation. Hence, we recommend to make the topological operator itself as simple as possible, i.e., by eliminating all geometric degrees of freedom. Concluding from these considerations, we suggest the use of what we call the half-edge collapse. A common way to store orientable triangle meshes is the half-edge structure [13] where an undirected edge pq is represented by two directed halves p ! q and q ! p. Collapsing the halfedge p ! q means to pull the vertex q into p and to remove the triangles that have become singular. This topological operator’s major advantage is that it does not contain any unset degrees of freedom which would have to be determined by local optimization. If we treat the two half-edge mates as separate entities then the only decision is whether a particular collapse is to be performed or not. Moreover, the reduction operation does not “invent” new geometry by letting some heuristic decide about the position of r. The vertices of the decimated mesh are always a proper subset of the original vertices. The half-edge collapse can be understood as a vertex removal without the freedom of chosing the triangulation or as an edge collapse without the freedom of setting the position of the new vertex. Figure 1 shows the submeshes involved in the basic topological operations. Figure 1: Vertex-removal, Edge-collapse, and Half-Edge-