Simplification of Reconstructed Meshes in Real Time

Transcription

1 Simplification of Reconstructed Meshes in Real Time Fernando Pizarro and Stefan Preuss Institut fr Betriebs- und Dialogsysteme - University Karlsruhe (TH) Am Fasanengarten Karlsruhe fpizarro@ira.uka.de, stpreuss@ira.uka.de Abstract Immersing a scanned replication of a person into a virtual reality environment is a multifaceted challenge. One key issue of this task is to improve the result and performance of the reconstruction algorithm that is used to create the 3D-Meshes out of pictures taken from the person. In this paper, we present a method to reduce the effort of a 3D-Mesh reconstruction process by polygonal simplification in real time (in less than 0:06 seconds). Besides being a relative fast algorithm, in every step the method holds a consistent mesh, so it can be aborted if calculation time runs short. Furthermore, we describe a data structure called AI-Tree (Adjustable Index Tree), that allows to speed up the process of rebuilding a mesh data structure out of lists of vertices, edges and polygons that appear in file formats and data communication. AI-Trees offer a fast way to find indices out of linked lists, and a scaleable trade-off between performance and memory consumption. 1

2 Introduction The main goal for this work is to immerse real people into a virtual reality environment. Contrary to other works (e.g., Fautz [1]), the number and the flexibility of the camera positions are reduced. Further the algorithm has to achieve visual realtime (currently at 15 fps, due to the synchronisation mode of the used ieee1394-cameras). So the algorithm has to be optimized in account to speed, further usability of the result and visual quality. In this paper we describe the optimization of a geometric mesh resulting of the volume intersection algorithm. The polygonal simplification should reduce the effort in the following cutting steps of the volume intersection algorithm and the effort of texturing the final visual hull. Related Work Laurentini [2] introduced the concept of a visual hull. Plainly speaking the visual hull of an object against a definite viewing space is the maximum body that casts the same silhouettes. Depending of the viewing space, it might be impossible to reconstruct certain concave features that lie inside the convex hull of the object. One statement of this paper is that, despite some concave features might be skipped, the visual hull defines the best possible result for silhouette based reconstruction algorithms. Franco et al. [3] propose a realtime approach to reconstruct objects (and people) which has similarities to our own. His precise connectivity method also uses the silhouettes acquired from the object s images and casts rays through the silhouette boundaries. Using epipolar geometry, the silhouettes taken from different camera positions provide information to separate these rays 2

3 into intervals which belong to the object and intervals that do not. These intervals are assembled into the desired visual hull of the object. Fautz [1] described in his PhD thesis an automatic reconstruction process of real objects. Pictures of an object are taken by a camera on a robot arm, which provides a great flexibility in the choice of the viewing points. He developped a new variant of the principle of volume intersection, using boundary representations and thus avoiding disadvantages of volumetric representations. Additionally the visual impression of the resulting geometry is improved with refined textures out of the taken images of the object. The high performance of this algorithm at that time leads to this work, in which it is tried to establish it in an real-time environment. Image Based Reconstruction Process The reconstruction process as illustrated in 1 starts with the synchronized taking of pictures from different points of view of the object to be scanned. In each picture the object must be extracted from the background to obtain the silhouette and an usable texture. The description of the adaptive background model to extract the object from the background, while ignoring changing lighting conditions, shadows and the changing projection wall is described in [4]. Also a rough 2D-adaptation of a skeleton model is preprocessed in this step for further interaction with the virtual reality. It is used for navigation and gesture analysis. The silhouettes are sent to the volume intersection algorithm to generate the visual hull of the object to be reconstructed (here the user in front of the projection wall). In the first reconstruction step the data structures of the viewing cones are build with the knowledge of the camera positions (the tip) and the silhouettes (the base surface). Starting with a 3

4 cube representing the workspace containing the object to be scanned, each viewing cone is successively cut from the previous result to further approximate the visual hull of the object. This reconstruction process is the main objective for the discussed polygonal simplification algorithm of this paper. Finally the texture coordinates are calculated by projecting the images from the camera positions onto the reconstructed object. One of the images or a set of blended images are used for view dependend texturing. Polygonal Simplification Our polygonal simplification has a main restriction according to the main process. If we consider at least 15 frames per second, then the simplification process must be executed or stopped in less than 0:06 seconds. As a second criterion desirable to meet, our simplification should be based on the resultant structure of the main reconstruction process (bidirecional list for Edges, Vertices and Polygons with cross references among them). Our goal is to reduce the mesh as much as possible in this stretch of time without visual degradation of the mesh. Previous Works Several algorithms have been developed for mesh simplification. We cover a generic group of the more outstanding algorithms with similar characteristics. The authors in [5, 6] and more recent [7], use vertex removal as a local method to gradually simplify meshes. This method remove vertices and its geometric information associate (polygons 4

5 and edges), generating holes in the surface of the mesh that are replaced with new triangulations without use the removed vertices. The holes around the removed vertices need to be replaced by concave triangulations to not generate polygons self-intersection. Also, it is necessary to find a plane that fits (as much is possible) all the adyacent vertices belonging to the created hole, to evaluate the volume cost of this operation using the vertex removed as reference. Other approaches [8, 9, 10, 11] use edge-collapse as local method. This method introduced by [8] has become used in many applications for automatic simplification of meshes. Undoubtedly this method has demonstrated to be very effective in mesh simplification, using heap-sort with edges-costs [10, 11]. Although [10] is the faster algorithm of simplification with high quality approximation (to our knowledge), only to compute the Q matrix 1 of every vertex and to create the heap-sort according to edges-cost is enough to use more than 0:06 seconds. Also, minimize the geometric error of every edge-collapse operation as [10, 11], would drain our simplification time quickly. [8, 9] use a strategy too slow to be considered in our real time problem. The works in [12, 13, 14] use vertex-clustering to simplify the mesh by incremental steps instead of small local simplifications. This approach is faster than [10], but with several changes in the topology of the mesh that will produce undesirable effects for our purpose (the obtained meshes in the main reconstruction process are already poor in detail quality). Furthermore, this process cannot be stopped before its natural execution to obtain acceptable results. [14] has improved the visual performance of this technique, but increasing the execution time by a factor of 7.5 times. 1 The matrix Q is the association of all the planes of each traingle adyacent to the vertex in question. 5

6 Fast Polygonal Simplification Our approach uses edge-collapse as local simplification operation, but the use of global geometric information to create heap-sort by edges-costs is too time consuming. Instead, we are forced to use simple logic based only on the local geometric information at the moment of each collapse operation. This trade-off between the use of global and local geometric information makes it possible to obtain a simplification of meshes in 0:06 seconds. Of course this trade-off does not allow to obtain high simplification quality as [8, 9, 11, 12, 13, 14], but we obtain visually acceptable results very fast and without the topological degradation of the meshes than [12, 13, 14]. We will use the notation v, e and t to represent the geometric elements; vertices, edges and triangles respectively. We have adopted the operators de and bc defined by [11] to describe our approach (see Figure 2). We define our simplification method 2 as the execution of successive simplification phases. Defined as simplification phase the verification of each valid vertex v in the mesh to be collaps with onother valid vertex, where a valid vertex is any vertex that was not created by a successful edge-collapse in the current simplification phase (at the beginning of every phase each vertex is considered valid to collapse). 2 We introduce this definition of our simplification method as formal definition, to explain our approach, however is not our intention to present it as automatic polygonal simplification for meshes. Our goal is restricted only to real time problem. 6

7 Collapse Metric Given a vertex v we choose its collapse counterpart v 0 by minimizing (v; v 0 ). (v; v 0 ) is defined as: (v; v 0 ) = j!(v)!(v 0 )j (1) where:!(v) = X 8e2dve (e) (2) The operator (e) calculates the dihedral angle between the triangles in dee and v 0 2 fbdvec vg. Once v 0 is choosen, we replace the vertices v and v 0 by v n in dbdve \ dv 0 ece and ddbdve \ dv 0 ecee, to finish with the elimination of dve \ dv 0 e and ddve \ dv 0 ee. v n is defined as: v n = v + (v 0 v)! 1 2 +!(v 0 )!(v) 2 max[!(v 0 );!(v)] If we meet the condition!(v) +!(v 0 ) = 0 we choose the midpoint between v and v 0 for v n. Error Metric The use of the previous described curvature metric to collapsed edges is not enough to guarantee the preservation of the original topology. We must consider other restrictions to guarantee the topology preservation and also avoid the self intersection in the new triangulation generated by edge-collapse operations. These rectricions are defined as:. (v; v 0 ) > (3)!(v n ) > max[!(v);!(v 0 )] (4) 7

8 The edge-collaps is rejected, if (3) is met and if (4) is met after the edge-collapse operation. Through these parameters and is controled the output of the simplification process. The parameter guarantees the preservation of strong characteristics in the mesh; on the other hand controls the level quality and at the same time avoids triangles intersection produced by collapse operations. Although we always use the same parameters in all our tests (to assure a robust algorithm). If we consider meshes with hundred of thousands or millions of polygons, to be simplify in less than 0:06 seconds restrictions as (3) or (4) are unnecessary, because with such vertices density is not possible to see visual changes after several thousands edge-collapse operations. However with meshes of 6,000 or 8,000 polygons obtained under our reconstruction process, the limitless application of edge-collapse operations without any error metric will produce several visual changes only in 0:06 seconds. Figures 4 and 5 show the visual results of our collapse and error metric propuse. Additional Considerations The reconstruction process in real time does not create meshes with holes, only closed manifold meshes, but we developed our polygonal simplification by many meshes of public domain. Of course, to reduce our tests only to closed meshes would deprive us of interesting meshes to test. The problem reside in determining (2) for vertices that belong to the boundary of the mesh, because if one of the edges in dve has only one triangle associate, it is impossible to calculate (e). To solve this problem we define 0 (v; v 0 ),! 0 (v) and 0 (e 1 ; e 2 ), These functions are defined as: 0 (v; v 0 ) = j! 0 (v)! 0 (v 0 )j (5) 8

9 where:! 0 (v) = 0 (e 1 ; e 2 ); 8e 1 ; e 2 2 dve (6) The 0 (e 1 ; e 2 ) calculates the angle between the directional edges e 1 and e 2. Although we do not need this metric in our real time algorithm, it allows us to examine the behavior of our simplification approach in many meshes. We consider also a similar restriction such as (3) for (5) by 0 (v; v 0 ) = j! 0 (v)! 0 (v 0 )j > 0 (notice that a simillar restriction such as (4) is not necessary with (6) because the edge-collapse operation with boundary vertices does not generate self intersections). As an extra consideration we reject each vertex v with!(v) > 5 3 or!0 (v) > 2 before its counterpar selection in (1) and (5), because represent areas too characteristic in the mesh to be simplify. Those areas do not usually exist in physical models with soft changes in the curvature (as animals models), but it is a necessary restriction for models of low detail quality. AI-Tree The reconstruction of the data structure configuration by meshes stored in files is an inefficient process because bidirectional list (used in our real time reconstruction process) has a worst case of O(n) in the search operation; as a consequence to create the cross references between vertices and polygons or edges becomes a process of several minutes for meshes such as the stanford bunny. In order to solve this problem we designed a data structure called AI-Tree (Adjustable Index Tree) that allow to rebuild the original mesh structure quickly and efficiently (less than 1 second for meshes with polygons). 9

10 The AI-Tree is attached to another data structure (in this particular case a bidirectional list) to improve the execution costs from O(n) to O(log 2 (n)) for search operations (see Figure 3a). Additional minimal memory is used to improve the search operation because every node use only 20 bytes (we will discuss this point further in the next subsection). It is also possible to obtain a trade-off between performance and memory consumption reducing the number of levels in the AI-Tree. AI-Tree Implementation 1. The AI-Tree has a total of L levels 3 for n elements. L is defined as: 2 L dlog 4 (n)e (7) 2. Each level L i will have T i elements. T i is defined as: T i = 8 >< 0:25 dt i+1 e if L = dlog 4 (n)e and i 6= L (8) 0iL >: n i L else 3. The execution cost in the worst case for the search operation is defined by C as: C = L + LX i=1 c i (9) where: c i = 8 >< >: l T i 2 T i 1 0 if T i 2 T i m else (10) We will use the expression node(l,t) to refer to a specific node in the AI-Tree, where l is the level 3 We will consider the bidirectional list attached to the AI-Tree as the last level. 10

11 number (0 l L) and t the position in the level (1 t T i ). If l = L, the expression node(l,t) will be an element in our information data structure, but we will consider only part of the AI-Tree for this analysis. Figure 3b shows the visual appearance of the node with its variables. As could be seen, such a node consist of three pointers and two integer variables. So a node occupies 20 Byte of memory on a 32-Bit architecture. The variables for the AI-Tree node represent respectively: range: represents the data found in the last level (the bidirectional list) with id smaller than or equal than our id of search. If we meet the previous condition we use the references NextNode[0] and NextNode[1] according to the variable segmentation. If we do not meet the previous condition then we navigate to the next node in the same level (NextNode). segmentation: represents the data found in the last level through the references to the next level. If the current segmentation corresponds to an id smaller than or equal to our id of search, then we navigate to the next level through the first reference (NextLevel[0]). If we do not meet the previous condition we navigate to the next level usign the second reference (NextLevel[1]). NextNode[0],NextLevel[1]: represents the navigation references that are used according to the variables range and segmentation. We will define formally every variable in each node(l,t) according to Figure 3b as: a = 2tD l b = (2t 1)D l c = (2t 2)D l + 1 d = (2t 1)D l + 1 where: D l = T l+1 2T l Note that we always meet the condition c b d a. Through these variables is easy to create the AI-Tree in descending cascade beginning from the last level (bidirectional list). Let 11

12 X be a single node node(l,t) with l < L. X needs to complete its creation of references the creation of the node node(l+1,a), where a is the variable of the current X node. Of course we can reverse the problem so that the level l + 1 would send a signal to the level of X at the moment of the creation of the node node(l+1,a). Once the reference between the node X and node(l+1,a) is created, the new signal from the level l + 1 will be according to the references of the next node to X in the same level. This co-operative system of signals between levels according to the variables a, b, c and d facilitates the creation of the AI-Tree simultaneously with the creation of the bidirectional list. AI-Tree Performance The AI-Tree uses half of the levels of a binary tree but maintains the performance in the search operation. We can prove this hypothesis easily if we use a continuous function of (9). This continuous function can be expressed as: C 0 = L n 1 L 2 (11) Notice that (9) is a discreet function and (11) is equivalent to (9) as a continuous function. The second expression in (11) represents the worst navigation case in the same level before cross to the next level in the search operation. According to our hypothesis we can affirm the following statement: Let be A an AVL-Tree and B a AI-Tree. A and B have n elements each one, then B uses half the levels of A to have the same performance than A does in the search operation. 12

13 Operations number in the search operation (worst case) AI-Tree levels v/s n 5,000 35, , , , Operations number in the search operation (worst case) AVL-Tree AVL-Tree Trade-off with memory cost in MB. levels v/s n 5,000 35, , , , ,001 0,004 0,006 0,010 0, ,006 0,022 0,044 0,081 0, ,014 0,055 0,199 0,234 0, ,022 0,099 0,222 0,454 0, ,032 0,148 0,344 0,721 1, ,033 0,202 0,479 1,020 1, ,233 0,622 1,341 2, ,667 1,667 3, ,333 Table 2: Temporal memory cost AI-Tree. Table 1: Execution cost AI-Tree and AVL-Tree. Using (11) and our previous statement, we can easily prove our hypothesis: log 2 (n) n 1 log 2 (n) 2 = log 2 (n) 2 n 1 log 2 (n) 2 2 (12) Table 1 shows also the performance of the AI-Tree using different levels and we observe that our hypothesis is correct according to (12). Table 2 shows the trade-off between memory and levels. AI-Tree Creation Cost As was mentioned, the AI-Tree is created simultaneously with the creation of the bidirectional list. Although the insertion of elements into the list has cost O(1), we must consider the creation cost of the AI-Tree. The creation worst case happens when the AI-Tree has the maximal possible levels because it 13

14 has more nodes. Using (7) and (8) we can create the next recurrent equation: T (n) = 8 >< >: 1 if n 4 n + T n else 4 4 Solving these equations we obtain the next worst case for n elements we obtain O n 1. 3 Collective Performance We can make an analysis considering the global simplification process in two parts; data structure reconstruction and polygonal simplification. These two processes can be evaluated in function of the operations; insert, search and delete respectively 4 creating a general cost functions of the processes. The data structure reconstruction implies a continuous insertion in the bidirectional list for n vertices, 2n triangles and 3n edges. Also this reconstruction needs the creation of the cross references through search operations for 12n vertices by triangles and edges 5. It is defined the execution cost of these processes as: nx I(i) + 2nX I(i) + 3nX I(i) + 6nX S(n) + 6nX i=1 i=1 i=1 i=1 i=1 S(n) + 2 n 1 3! {z } (13) only AI T ree The polygonal simplification implies a deletion of vertices, triangles and edges. We can assume for this analysis a polygonal simplification at less than 50%. The execution cost of this process is defined as: nx D(i) + 2nX D(i) + 3nX i= n i=n i= 3n 2 2 D(i) (14) 4 We will use the abrevation I, S and D for the insert, search and delete operations. 5 Note that the 12n search operation correspond to 3 references to vertices by 2n triangles and 2 references by 3n edges. 14

15 Through these functions we can compare the performance of several alternatives. Our natural intention is to use the original bidirectional list of our simplification methods but the search operation among vertices, edges and polygons its excessively costly (several minutes for meshes such of stanford bunny). Considering that our simplification process delete information dynamically, we considered the AVL-Tree as alternative data structure. This solution will improve the time problem in the cross references reconstruction process, nevertheless, on the other hand this change will modify the scenario of our real problem and also will increase the operations number for the simplification process. The AI-Tree fit in our real time scenario perfectly as the tables 3 and 4 show. We included the creation and the elimination of the AI-Tree in our analyses. Of course this expression in the equation (13), is not considered in the calculations with the bidirectional list and the AVL-Tree. The AI-Tree not only improves the number of operations in the reconstruction process in comparison with the AVL-Tree; it also does not produce alterations to prove our simplification according to our real reconstruction process. The AI-Tree has better performance than any other dynamic structure for the reconstruction process and to execute the simplification process to our knowledge (in the simplification process the bidirectional list offers the best performance to eliminate dynamically data, given its cost O(1) by cross references between geometric information). We do not consider other aspects in our previous analysis that affect the time process as recursive implementations in the AVL-Tree. This tree structure needs a lot of reorganization to remain as AVL-Tree and not become a binary tree if the data input is a mesh, because each element inserted will be the successor for the previously inserted element. As consequence this 15

16 Data Structure Reconstruction n B.List AVL-Tree AI-Tree 5, ,030, , ,595 35,000 14,700,210,176 6,992,770 6,573, , ,000,602,112 21,948,272 20,598, , ,001,520,640 59,166,936 55,461, , ,000,293, ,833, ,922,744 Table 3: Operation cost for generate the cross references between vertices, edges and polygons. Polygonal Simplification n B.List AVL-Tree AI-Tree 5,000 15,003 42,126 15,003 35, , , , , ,003 1,058, , , ,003 2,811, , ,000 1,500,003 5,872,239 1,500,003 Table 4: The AI-Tree keep intact the performance of the real time reconstruction process. task of reorganization will be used constantly, using a considerable cost in records and time by copy of local variables. Another point is navigation in a tree. It is necessary to cross the whole tree for our simplification and rendering process, that also has considerable cost in stack memory and time. On the other hand the AI-Tree and bidirectional lists do not need recursive implementations and stack memory for keeping its performance and navigation operation, making it more faster in time process. Results We tested our polygonal simplification under a wide range of meshes of public domain, with meshes more or less uniform, using always the same parameters = 6, = 5 36, 0 = 6 obtaining the visual result according to the Figures??-??,??-6. Our results show that our simplification method does not produce topology change after several optimization phases in many tested meshes, guaranteeing the silhouette conservation in the first 0:06 seconds of simplification. Figures??-6 show the visual result in real time for our approach and table 5 shows real statistics 16

17 Mesh Original Vertices Edges Polygons Polygons Verifed Collapsed Eliminated Bunny 69,461 2,293 1,030 2,060 Horse 39,698 2,628 1,090 2,180 Aki 9,989 2,788 1,104 2,208 Surface 7,504 3,907 1,245 2,421 Table 5: Polygonal simplification performance for eliminated polygons obtained in less than 0:06 seconds. 6 with the meshes presented in this paper. If we consider the current experiment of real time reconstruction, it generates meshes about 6,000 and 8,000 polygons, affording to predict a reduction of about 30% and 40% as average in the texture process and data transmission (perhaps also in the reconstruction process). In Figure?? we notice that even when our simplification method collaps similar curvature in the mesh, the corners are rejected in the simplification process assuring the original topology. Figure?? shows that although most edges in the areas of low curvature were not collapsed by time, the simplification did not make topology changes in the areas with higher curvature. Figure 6 was created by the reconstruction process from Michael Fautz [1], that is the base of the main project of this paper. Although this mesh has more polygons than the meshes created in our current reconstruction process, the characteristics of this mesh offers good references of our future results in a real time enviroment. Future Work The polygonal simplification exposed here is our first approach to simplification in real time, developed with meshes of public domain. Our future efforts will concentrate on optimizing the 6 These results were obtain in a machine AMD Athlom 2.08GHz with 384MB. 17

18 polygonal simplification using as base meshes generated under our real time such as Figure 6. The next task will be to examine the optimal trade-off between time spent for polygonal simplification and time spent in the intersection process. Another use of the simplification algorithm will be to generate different level-of-detail sets of a scanned moving person, that could be used in real-time graphics. Further parallelization of our VR-environment and addition of further modules into it, will lead to a stronger use and refinement of the AI data structure for the exchange of meshes. References [1] Michael Fautz. Objekt-und Texturrekonstruktion mit einer robotergeführten Kamera. PhD thesis, Karlsruhe University, [2] Aldo Laurentini. The visual hull concept for silhouette-based image understanding. IEEE Transactions on Pattern Analysis and Machine Intelligence, [3] Jean Sébastien Franco, Clément Ménier, Edmond Boyer, and Bruno Raffin. A distributed approach for real time 3d modeling. Proceedings of the 2004 IEEE Computer Society Conference on Computer Vision and Pattern Recognition Workshops, [4] Sven Thüring, Jörn Herwig, and Alfred Schmitt. Silhouette-based motion capture for interactive vr-systems including a rear projection screen. In CASA 2005 Proceedings, [5] Michel van Klink and Michael S. Lew. Decimation of visible surfaces. Pattern Recognition, Fourteenth International Conference, [6] William J. Schroeder, Jonathan A. Zarge, and William E. Lorensen. Decimation of triangle meshes. SIGGRAPH 92, [7] Pierre Alliez and Mathieu Desbrun. Progressive compression for lossless transmission of triangle meshes. SIGGRAPH 01, [8] Hugues Hoppe, Tony DeRose, Tom Duchamp, John Mc-Donald, and Werner Stuetzle. Mesh optimization. SIGGRAPH 93, [9] Hugues Hoppe. Progressive meshes. SIGGRAPH 96,

19 [10] Michael Garland and Paul S. Heckbert. Surface simplification using quadric error metrics. SIGGRAPH 97, [11] P. Lindstrom and G. Turk. Fast and memory efficient polygonal simplification. IEEE Visualization 98, [12] Chan K.F., Wong Y.T., and Kok C.W. Multiresolution mesh representation using vertex cluster contraction. IEEE International Symposium, [13] Remi Ronfard and Jarek Rossignac. Full-range approximation of triangulated polyhedra. Computer Graphics Forum, [14] Dmitry Brodsky, BenjaminWatson, I. Scott MacKenzie (editor), and James Stewart (editor). Model simplification through refinement. Morgan Kaufmann Publishers, Montreal, Canada,

20 c) f) i) b) e) h) a) d) g) Figure 1: These pictures illustrate the several steps of the reconstruction process: a) One of the pictures of the object to be reconstructed. b) A silhouette of this object extracted from picture a). c) The start volume, from which each viewing cone is substracted. d) A Viewing cone, generated out of the Silhouette b) and the respective camera position. Viewed from the position of this camera. e) The viewing Cone 20 of this silhouette from the side view already intersected with the starting volume. f) Here a second viewing cone is substracted from the bounding representation. g) shows the nearly finished Object after 5 cuts. h+i) The pictures are also used to texturize the reconstructed object.

21 Figure 2: Operators de and bc returns all adyacent objects which have one dimension more or less than the original object (dve 7! e, dee 7! t, btc 7! e, bec 7! v). 21

22 Figure 3: Structure of the AI-Tree. 22

23 Figure 4: Our collapse and error metrics have been proved with different types of meshes and after thousands collapse operations we keep high fidelity of the original meshes guaranteeing the quality of the simplified meshes in real-time. Top original stanford bunny mesh reduced from to 3756 polyons. Bottom eagle mesh reduced from to polygons. In both meshes 7 phases of optimization were applied in less than 2.6 seconds. 23

24 Figure 5: Top: original horse model (39,698 polygons). Center: mesh reduced by 62% after 10 simplification phases using =. Bottom: mesh reduced by 86% after 10 simplification 18 phases using =

25 Figure 6: Top: Aki and Hypopotamus mesh created by our reconstructed process. Bottom: Aki mesh simplified from 8085 to polygons and Hypopotamus mesh simplified from 8020 to 5436 polygons. 25