Informatica Universiteit van Amsterdam

Transcription

1 Bachelor Informatica Informatica Universiteit van Amsterdam Volumetric Comparison of Simplified 3D Models Steven Klein June 12, 2012 Supervisor: Robert Belleman (UvA)

2 Abstract In the field of computer graphics, performance is often an issue when working with highly detailed 3D models. Simplification methods have been developed to increase performance when detail is not important, for example when models are far away or moving at high speed. The results of these simplification methods depend on the types of input models, and many of these methods do not have proper support for texture mapping. They also usually require manual tuning, taking up valuable time and leaving room for human error. This thesis presents a method that can compare different simplifications of a model automatically, making it possible to select optimal simplification methods and settings for any model, without the need for any user input. This work also includes a method that can handle texture mapping for any combination of simplification methods. 2

3 Table of Contents TITLE PAGE... 1 ABSTRACT INTRODUCTION D Models and Performance Level of Detail Simplification Voxels Research Goals RELATED WORK Contribution of this thesis METHODS AND IMPLEMENTATION Step one: Voxelization Step two: Morphological Operations Step three: Isosurface Extraction Step four: Simplification Step five: Comparison Step six: Texture Mapping RESULTS Model simplification results Texture Simplification Results DISCUSSION Texture mapping limitations Comparison algorithm limitations Simplification algorithm limitations CONCLUSION REFERENCES APPENDIX - A - MODEL SIMPLIFICATION SCORES

4 1. Introduction 1.1 3D Models and Performance Visualization of 3D objects and environments (rendering) is becoming increasingly important in modern computer graphics. 3D rendering is used in many types of applications such as video games, software used for CGI in movies, and 3D modeling applications such as architectural or industrial design software. In general 3D objects used for rendering are represented by a polygonal model, usually consisting of two main components. The first component is a mesh that describes the model s morphology through a collection of vertices (points in 3D space) and edges between these vertices. Three edges together make up a triangle. Together, these triangles form polygons that describe the surface of the 3D model (see figure 1). Figure 1: Example of a triangle mesh representing a dolphin (Source: The second component is an image (often called a texture ) that is mapped onto the model s polygons to provide color for its surface. Many of the applications that use 3D rendering are interactive, and for optimal use they often require visual continuity by means of a high frame rate, also referred to as frames per second (FPS); the rate at which a graphics device produces consecutive images per second. Because graphics hardware can only perform a limited amount of calculations per second, the frame rate will generally be lower for more complex scenes. This also means that one way to increase the frame rate of an application is to reduce the complexity of the scene to be rendered. 1.2 Level of Detail When talking about reduction of complexity of features of a 3D scene, the term Level of Detail is often used. Techniques to reduce complexity are often applied when the gain in performance is worth the loss of detail, especially in cases where the loss of detail is less noticeable, for example when the object is far away or moving at high speeds. In Level of Detail, there are two main categories: Continuous Level of Detail and Discrete Level of Detail

5 In Continuous Level of Detail implementations, the simplifications happen gradually. This prevents visual popping of objects or effects, but usually at the cost of increased processing and/or memory requirements. In Continuous Level of Detail it is important to be able to efficiently calculate any level of simplification of the target during the execution of the application. One example of a solution to this problem are Progressive Meshes [4], where the original model and a simplified version of that model are loaded into memory with the algorithm interpolating between these two models. In Discrete Level of Detail implementations, switching between a more complex object and a more simplified object will take place at specific intervals. For example, at a distance of 50 or more from the camera, an original model could be replaced by a simplified model with half the original triangles while at a distance of 100 or more that simplified model could be replaced by an even more simplified model with only a quarter of the original triangles. The main advantage of this method is that when the simplifications are generated beforehand, no extra processing is required during the actual execution of the application. 1.3 Simplification A 3D scene can have many components, each requiring more processing to be rendered the more complex they are. As a result, there are different targets for simplification. One of the targets for simplification are textures, this is called mipmapping [11](see figure 2). In mipmapping, multiple versions of the same texture are loaded into memory, each with a different resolution (often in powers of two). For example, a 64 2 texture could have 7 images loaded into memory with resolutions of 64 2, 32 2, 16 2, 8 2, 4 2, 2 2 and 1 2. Figure 2: Example of mipmapping. Full resolution image (left) with corresponding lower resolution images (right) (Source: Another common target for simplification are 3D models. The goal of these simplifications is generally to reduce the amount of triangles of a model, thus reducing the amount of processing required to render the model, while minimizing topological changes to the model. However, simplifying a 3D model is not a trivial task; finding a good simplification of a model can be very hard, and what simplification is optimal can often be subjective and heavily dependent on context. 5

6 Another problem in 3D model simplification are textures. With the topology changes caused by model simplification, some triangles will be removed, while others could be stretched, shrunk or deformed. What will happen to the textures on those triangles? With single colors attached to vertices, it is relatively easy to get a new color by interpolating the colors of merged vertices. However, with more complex textures and texture mappings it gets more complicated to preserve textures during the simplification process. 1.4 Voxels Volumetric pixels (voxels) are three dimensional pixels that have volume, usually represented by a uniform grid (see figure 3). Figure 3: Uniform grid of volumetric pixels (voxels) (Source: Working with voxels has a number of advantages: they re relatively easy to manipulate, they have volume, meaning you always know what is inside and what is outside of a model, and they are always correct; no holes, double walls or overlapping parts. Because of these advantages, they are sometimes used as an intermediate representation of a model, for example to more easily perform topology changing operations. There are downsides to using voxels as well. They generally use more memory than equivalent polygonal models, most current rendering hardware and software are not designed to visualize voxels, and voxels are very hard to animate. Because of these downsides they are rarely rendered directly but instead converted to a polygonal model for rendering using an isosurface extraction method, for example the Marching Cubes [5] or Marching Tetrahedra [9] algorithms. 6

7 1.5 Research Goals There are already many existing methods that are able to simplify 3D models, each with their own advantages and disadvantages. Some, for example, are good at simplifying objects with many small details, while others are better suited for models consisting of many unconnected parts. Because of this, it can often be a problem to decide which methods and settings are best suited for a model. We believe the simplification process can be improved by implementing multiple simplification methods side by side and running them with multiple settings. The results can then be compared and the best simplification can be chosen. This however requires a method to automatically compare the results. Therefore, the main goal of this thesis is to research objective measures to compare different simplifications of a model. Most of the existing simplification methods only have support for simple colors assigned to vertices or no support for colors or textures at all. Therefore, the second goal of this thesis is to look into possibilities to add support for texture mapping to the simplification process, preferably independent of the simplification method and settings used. 7

8 2. Related work Schroeder s method [8] was one of the first 3D model simplification algorithms. It uses vertex removal and re-triangulation to simplify a model. It classifies vertices into different categories based on their features. It is a solid method and provided the basis for many new model simplification methods. As van Kaick and Pedrini [6] showed however, the metric they used for selecting vertices to remove (vertex distance to average plane) performs relatively poorly compared to other newer metrics. Garland and Heckbert s method [3] makes use of pair contractions. A pair contraction consists of contracting two vertices into one new vertex, thus reducing the vertex and triangle count of the model. They iteratively contract the vertex pair that has the lowest cost, meaning it introduces the smallest change to the model. They calculate this cost by using quadric error matrices based on the planes of the triangles that share these two vertices. When the target triangle count is reached, the algorithm will stop and the resulting model will be a simplified version of the original model with a specific number of triangles. Some of the advantages of this method are that it does not have to divide vertices into different categories, that it can modify topology by merging non-edge pairs when necessary. According to van Kaick and Pedrini [6], the quadric metric used performs relatively well compared to many others simplification metrics. It is however relatively complicated to understand and implement and when using non-edge contraction it can result in a mesh with certain degeneracies like holes. Nooruddin and Turk s method [7] is basically a pre-processing step for Garland and Heckbert s method. First, they voxelize the original model using a parity count or ray stabbing algorithm. Voxelizing the model in this way also repairs many degeneracies often present in polygonal models such as holes, double walls or intersecting parts. After the voxelization step, one or more morphological operations are performed (zero if the only goal is to repair the model or eliminate interior details). One of the two morphological operations they use is the closing operation (dilation followed by erosion) that can close small holes, tunnels or openings between two surfaces. The other operation is an opening operation (erosion followed by dilation) that can remove small and/or thin details. After these morphological operations, an isosurface is generated using the Marching Cubes algorithm [5] resulting in a modified version of the original model. As a final step, Garland and Heckbert s method is then applied to this new model to reduce the amount of triangles of the model, but without non-edge contraction (contracting two vertices that do not share an edge) to prevent non-manifold meshes. The advantages of this added step is that it can filter out many small details before the actual simplification, making it possible to create an acceptable simplification with less total triangles than many other methods. This extra step however comes at the price of a lower initial accuracy and a higher processing cost because of the two conversions and geological changes, making it less useful for models that need a lower degree of simplification. Cignoni, Rocchini and Scopigno [1] designed a method to compare simplifications using the Hausdorff Distance. They take sample points from the original model and for each of those points they find the closest point to any surface of the simplified model. The distance between these two points is then used as the error. The advantage of this method is that it measures the error of surfaces, which is often what you want for Level of Detail purposes. However, when significant topological changes occur during simplification this method has the potential to become unstable, for example when 8

9 multiple surfaces are close together and the algorithm finds a surface close to a point that belongs to a different part of the model. The score it calculates is also hard to interpret when used in an absolute sense as it gives a distance value as the error that is dependent on the size of the model and distances between different parts of the model. 2.1 Contribution of this thesis The comparison method described above is based on the Hausdorff Distance. The results are dependent on model geometry and features, causing the algorithm to become unstable in some situations. The results are also difficult to interpret in an absolute context. The comparison method presented in this thesis is based on volume, and the results are independent of model geometry and features and are easily interpreted in both absolute and relative contexts. The simplification methods described above only have support for simple colors assigned to vertices or no support for colors or textures at all. This thesis presents a method to automatically re-sample and re-map any colors or textures of the original model to the simplified model that is independent of the type of texture mapping and simplification method used. 9

10 3. Methods and Implementation As a testing framework for this thesis, two simplification algorithms were implemented; one from Garland and Heckbert, the other from Nooruddin and Turk. These methods were chosen for this thesis because there is a large overlap for some of the techniques making it easier to implement: for example, the distance map in step two can also be used for the texture mapping in step six and the voxelization from step one can also be used for the comparison in step five. The implementation of this testing framework is based on OGRE (Object-oriented Graphics Rendering Engine 2 ). This section describes the different steps of the simplification pipeline (see figure 4). Steps one through three consist of a modified version of Nooruddin and Turk s algorithm and are skipped when using the direct simplification setting. Step two can be partially or fully skipped depending on the opening and closing settings. Step four is a modified version of Garland and Heckbert s algorithm. Step five is the comparison algorithm designed to compare the different simplifications resulting from the previous steps, by going through those steps multiple times with different settings and comparing the simplified models to the original. Step six is the algorithm designed to handle models mapped textures. 1. Voxelization 2. Morphologic Ops. 3. Isosurface Extract. 4. Simplification Direct Simplification 5. Comparison 6. Texture Mapping Figure 4: Flowchart representation of the simplification pipeline

11 3.1 Step one: Voxelization Method The first step is to go from a polygonal representation of a model to a voxel representation (see figure 5). Nooruddin and Turk used either a parity-count or a ray-stabbing approach, both from 13 different directions. They chose these methods because they can repair degeneracies in models. However, when model repair is not required, a parity count algorithm with rays along the 3 main axes is sufficient. Figure 5: Polygonal representation of a teapot (background) and its corresponding voxel representation (foreground) (Source: The parity-count algorithm sends rays in three directions parallel to the main axes. It then finds all intersections between the rays and the faces of the model and stores them. Any ray with an uneven total number of intersections is discarded. Any voxel that has an uneven number of intersections along both directions of any of its three corresponding rays is classified as internal, all other voxels are classified as external (see figure 6). Figure 6: All voxels between two intersections with rays with an even number of intersections are set to filled (left), while rays with an uneven number of intersections are discarded (right) (Source: [7]). 11

12 The quality of the resulting voxel model is mostly dependent on the resolution of the grid used in this step. When high quality is desired, a voxel grid with a high resolution should be used; otherwise a lower resolution can be used for faster simplification Pseudocode Pseudocode for the z direction of the voxelization method: Voxelize the polygonal model in the z direction for x = 0 to xsize for y = 0 to ysize cast ray in z direction for every relevant triangle if ray intersects triangle add position of intersection to sorted list save intersection location for use in isosurface extraction step if number of intersections is even for every set of two intersections in the list (1 and 2, 3 and 4, etc) set all voxels between intersections to filled else discard ray This loop is repeated multiple times in different directions Implementation Remarks A simple brute force approach (checking all triangles of the model for intersection for every ray, regardless of proximity) is sufficient for smaller models if processing speed isn t an issue. When voxelizing larger models or when processing speed is important, optimizations can and should be made. One possibility is to sort triangles with a tree structure (BSP, octree, etc) and only check triangles in sections that the ray passes through for intersections. Using an optimized version of the ray-triangle intersection function can give significant performance boosts as well. 3.2 Step two: Morphological Operations Method The next step is to perform morphological operations on the voxel data produced in step one. The same method is used as Nooruddin and Turk, which is a combination of erosion and dilation operations. For these operations a distance map (see figure 7) is calculated. Nooruddin and Turk chose to use a 3D version of Danielsson s algorithm [2] to generate the distance maps, because it is well suited for this task. The general idea of this algorithm is to propagate the distances in all six main directions by iteratively checking neighboring points if their closest known point is closer to the current point than the currently known closest point. The results of this algorithm are not entirely precise, but the error margins are in an acceptable range for the task. 12

13 Figure 7: 2D example of a simple distance map. The white squares represent internal voxels. A dilation operation with a distance of 1 changes all black squares (empty voxels) with the number 1 into white squares (filled voxels) (Source: Erosion operations decrease the volume of a model while dilation operations increase the volume. A close operation is a dilation operation followed by an erosion operation and is capable of closing small holes, tunnels or open spaces between two surfaces. An open operation is an erosion operation followed by a dilation operation and is capable of removing small and/or thin details. Both of these operations use a distance threshold setting. These open and close operations are used to get rid of certain features of a model, making it easier to get a good simplification with fewer triangles in step four Pseudocode Pseudocode for the initialization step and the loop in one direction for generating a distance map for dilation: Set initial values for every voxel storedvector = vector(0,0,0) If voxel is filled storedmagnitude = 0 else storedmagnitude= inf 13

14 Danielsson s loop in positive and negative z direction for x = 0 to xsize for y = 0 to ysize for z = 0 to (zsize 1) if magnitude(storedvector(x,y,z+1) + vector(0,0,1)) < storedmagnitude(x,y,z) storedvector(x, y, z) = storedvector(x, y, z+1) + vector(0, 0, 1) storedmagnitude(x,y,z) = magnitude(vector(x,y,z+1) + vector(0, 0, 1)) for z = zsize to 1 if magnitude(storedvector(x,y,z-1) + vector(0,0,-1)) < storedmagnitude(x,y,z) storedvector(x, y, z) = storedvector(x, y, z-1) + vector(0, 0, -1) storedmagnitude(x,y,z) = magnitude(vector(x,y,z-1) + vector(0, 0, -1)) In the full algorithm, this loop is repeated in all three directions and also examines voxels to the sides. When generating the distance map for erosion, internal and external voxels are reversed. Pseudocode for applying dilation and erosion operations with a certain threshold: Dilation for every voxel if voxel is empty and magnitude stored in voxel < squared threshold set voxel to filled else do nothing Erosion for every voxel if voxel is filled and magnitude stored in voxel < squared threshold set voxel to empty else do nothing The erosion operation uses a distance map calculated with an inverted voxel grid Implementation Remarks In the distance map, each voxel will store a vector and a magnitude. The vector points to either the closest filled voxel for an empty voxel, or to the closest empty voxel for a filled voxel. The magnitude is the squared length of the vector (to save unnecessary square root operations) 3.3 Step three: Isosurface Extraction Method The third step is to obtain a polygonal representation of the volumetric model resulting from step one and two. Nooruddin and Turk chose to use an extended version [10] of the original marching cubes algorithm, using supersampling to obtain density values for the voxels. 14

15 Another option is to use exact intersection values of the surface of the original model that can be gathered during the voxelization in step one to place the vertices resulting from the Marching Cubes algorithm. This should provide similar if not a better quality of the resulting model, especially in areas where internal voxels have more than one adjacent external voxel or vice versa such as corners or thin areas. A third option is to use the Marching Tetrahedra algorithm [9]. It can produce better results, but comes at the cost of more triangles per voxel. In many cases however, the Marching Cubes algorithm, if used right, should produces results of sufficient quality (see figure 8). Figure 8: Original untextured model (left) and voxelized model s isosurface extracted with an extended Marching Cubes algorithm with a voxel grid with recalculated normal vectors (right). One problem in this step is that that any voxels changed in step two will not have positioning data, which means the faces generated from these voxels will be placed in the default positions (on the center point between two voxels) and thus are subject to the aliasing often seen in standard marching cubes algorithms (see figure 9). Nooruddin and Turk suggested filtering out these artifacts with a smoothing operation. However, we found that smoothing is not strictly necessary, because these aliasing artifacts mostly get filtered out by the simplifications performed in step four (see figure 9). 15

16 Figure 9: Open operation with a distance threshold of 2 performed on ninja model (left), and that same model simplified to 25% of original triangle count after open operation (right).the noise resulting from the default positions of voxels caused by the open operation is clearly visible (left), but was filtered out by the simplification step without any smoothing operations (right) Pseudocode Pseudocode for generating a redundant grid (see Implementation Remarks) and for generating triangles using the marching cubes algorithm: Generate redundant grid for every voxel if voxel is filled set corresponding bit of 8 surrounding points in redundant grid to 1 else set corresponding bit of 8 surrounding points in redundant grid to 0 Generate triangles for every point in redundant grid look up triangles to generate in marching cubes lookup table using the bitmask generate triangles based on looked up values position vertices at exact intersection points gathered in the voxelization step Implementation Remarks It can be helpful to first generate a grid consisting of a bitmask of one byte for each center point between eight voxels, containing the filled status of the eight surrounding voxels. A zero layer is also added around the grid to make sure the resulting model will be closed on all sides. This grid makes it easier to implement a straightforward algorithm to generate the triangles using the marching cubes algorithm; enter the value of the bitmask into the Marching Cubes lookup table to directly retrieve the triangles to add for that point. 16

17 Any voxels changed by the morphological operations in step two might not have intersection data for all their vertices, in those cases the default halfway point will be used for positioning. 3.4 Step four: Simplification Method The fourth step is simplification of the polygonal model. The input model is either the original model when using the direct simplification setting or the model resulting from steps one through three. The algorithm used is that of Garland and Heckbert with the same modification Nooruddin and Turk used: no non-edge contractions. The main reason to disallow non-edge contraction is to ensure an output model without any degeneracies. This algorithm uses pair contractions (see figure 10) that contract two vertices into one new vertex, thus reducing the vertex count and triangle count of the model. It iteratively contracts the vertex pair that has the lowest cost, meaning it introduces the smallest change to the model. This cost is calculated by using quadric error matrices based on the planes of the triangles that one or both vertices. When the target triangle count is reached, the algorithm will stop and the resulting model will be a simplified version of the original model, with the specified number of triangles. Figure 10: Model simplification using vertex contraction (Source: [3]) Pseudocode Pseudocode for calculating the error matrices, creating the pairs and removing pairs (thus merging two vertices): Calculate error matrices for every vertex calculate error matrix based on planes of adjacent triangles Create pairs for every triangle with vertices v1,v2,v3 create vertex pair (v1, v2), (v2, v3) and (v1, v3) and calculate costs and position 17

18 Remove pairs while currenttriangles < targettriangles find vertex pair with lowest cost and remove it function removepair(v1, v2) reposition v1 to new position remove triangles with edge v1, v2 transfer indices from v2 to v1 transfer pairs from v2 to v1 delete v2 update error matrices of vertices involving triangles containing v1 update matrices, positions and costs of pairs involving updated vertices end function Implementation Remarks Garland and Heckbert recommend using a heap for selecting the lowest cost pairs to remove. It is not strictly necessary to implement a heap, but it does significantly reduce the processing time for larger models by making the selection of the vertex pair with the lowest cost more efficient. 3.5 Step five: Comparison Method The fifth step is comparing the different simplifications of a model and selecting the best one. This method compares the differences in volume, thus giving a relatively high weight to the overall shape of the model and less to smaller details. This works well for simplifying models that are far away from the viewer or moving at high speed, but might be less suited for stationary models close to the viewer where small details might be important. If small details are important, it should be possible to assign different weights to different parts of the model depending on their features and position. First, the original model and the different simplified models are all voxelized using the same voxelization method used in step one. The algorithm will then perform a 3D image subtraction with the original model and one of the simplified models as the input. It will compare each voxel of the original model to the corresponding voxel of the simplified model. If both voxels are filled, they will be classified as correct. If one of the two voxels is filled while the other is empty, they will be classified as incorrect (see figure 11). Voxels that are empty in both the original and simplified model are ignored. The score is the percentage of correct voxels compared to the total correct and incorrect voxels. 18

19 Figure 11: Illustration of the method used to compare models. In this example, the score would be 3 out of 5 or 60%. After the scores are calculated for all the simplified models, the scores will be compared and the best simplification will be selected Pseudocode Pseudocode for voxelization of a model in one direction and for scoring a model: Voxelize the polygonal model in the z direction for x = 0 to xsize for y = 0 to ysize cast ray in z direction for every relevant triangle if ray intersects triangle add position of intersection to sorted list if number of intersections even for every set of two intersections set all voxels between intersections to filled else discard ray Score a model for every voxel if original model voxel == 0 and simplified model voxel == 0 do nothing if original model voxel == 1 and simplified model voxel == 0 incorrect += 1 if original model voxel == 0 and simplified model voxel == 1 incorrect += 1 if original model voxel == 1 and simplified model voxel == 1 correct += 1 score = correct / (correct + incorrect) 19

20 3.5.3 Implementation Remarks To increase the precision of the comparison the resolution of the grid into which the models are voxelized could be increased, at the cost of higher processing time. See the results section for more details on the relation between grid size and precision. Care should be taken that both models have the same orientation and scale. 3.6 Step six: Texture Mapping Method After selecting the optimal simplification, the last step is re-sampling the original textures and mapping them to the simplified model. A three dimensional grid is generated using a method similar to the voxelization method in step one with two differences: only the voxel closest to an intersection is filled instead of all voxels between two intersections and the voxels get a color value based on the color of the texture at the intersection instead of a simple empty or filled value. A distance map is then calculated for the resulting color grid using Danielsson s algorithm. For every point in the grid without a color value assigned to it, the closest point with a color value assigned to it is calculated. The empty points are then filled with the color of their closest filled point. The texture image is then filled by sampling the colors from the color grid for each pixel of each triangle in the new texture. Finally the texture coordinates are added to the simplified model and vertices are duplicated where necessary Pseudocode Pseudocode for generating the color grid in the z direction and generating the texture for the simplified model: Generate the color grid in the z direction for x = 0 to xsize for y = 0 to ysize cast ray in z direction for every relevant triangle if ray intersects triangle sample surface color at intersection point from texture using bi-linear filtering store it in the nearest voxel in the color grid 20

21 Generate texture calculate texture size and triangle positions for each triangle in texture file for each pixel in triangle calculate position of corresponding 3D point sample color value from color grid using calculated position and tri-linear filtering assign color to pixel in the texture Implementation Remarks The positioning of the triangles in the texture image can be done in different ways. An easy and straightforward solution is to position the triangles from the top left to the bottom right, looping back to the left before the maximum width is reached. However, using this method means that the triangles in the texture file are unconnected. Depending on the rendering method used, it is likely that most or all vertices have to be duplicated, resulting in a drop in performance. Using a more sophisticated unwrapping method will likely give better results. 21

22 4. Results This section describes the results of a number of test cases designed to test the methods described in this thesis. For all these test cases grids were used for both the voxelization in step one and the texturing in step five, while a grid was used for the comparison in step five unless noted otherwise. 4.1 Model simplification results Three models, Ninja (see figure 12), Robot (see figure 13) and Razor (see figure 14), were simplified using a variety of settings and degrees of simplification. Each model was simplified with five different settings: - Direct simplification (Direct) - Simplification after voxelization and isosurface extraction without open and close operations ( Open 0, Close 0 ) - Simplification after voxelization and isosurface extraction with a close distance of 1 ( Open 0, Close 1 ) - Simplification after voxelization and isosurface extraction with an open distance of 1 ( Open 1, Close 0 ) - Simplification after voxelization and isosurface extraction with both a close and open distance of 1 ( Open 1, Close 1 ) For each of these 5 settings, 100 simplifications were made with a triangle count ranging from 1% to 100% of the original number of triangles. These simplifications were then compared to the original model and a score was calculated for each of them. The scores of these 15 series of simplifications (3 models with 5 settings each) are shown in figures 12 through 14. Visual results are show in figures 16 through 18. Figure 12: Scores of the Ninja simplifications. Original Ninja model consists of 1008 triangles. 22

23 Figure 13: Scores of the Robot simplifications. Original Robot model consists of 308 triangles. Figure 14: Scores of the Razor simplifications. Original Razor model consists of 468 triangles. For the direct simplifications of the Ninja model the scores were also calculated with different grid sizes in the comparison step to test the accuracy of the comparison algorithm. Grid sizes of 64 3, 128 3, and were used and the resulting differences between the smaller three grids and the grid are shown in figure 15. As can be seen in the graph, the difference in score when using a grid size of 64 3 when compared to using a grid is generally under 1% (average absolute difference of 0.43%). The average difference between the scores and the scores was 0.07%. The chaotic behavior of the graph is mostly caused by the inherent randomness of the error of the comparison. 23

24 Figure 15: Error of the comparison algorithm on the Ninja model with smaller grid sizes when using the grid comparison as the true score. The expression used here is ABS(((true score calculated score) / true score) * 100%). A more elaborate score comparison is shown in tables 1 through 3 in Appendix A. These tables show that when only simplifying to a small degree, Garland and Heckbert s algorithm obtain better results. When simplifying to a larger degree however, Noorudin and Turk s algorithm starts to become more competitive and, in the cases of these three models, wins with one or more of the different distance threshold settings. These differences are possibly due to the errors introduced when voxelizing the model, then using isosurface extraction resulting in a model that often has over triangles, then simplifying the model back to the original triangle count. These errors then gradually become less important compared to the new errors introduced as both algorithms further simplify the model, while Nooruddin and Turk s algorithm might gain an edge due to the morphological operations performed or simply due to luck from running the algorithm more than once on models that are slightly different each time. 4.2 Texture Simplification Results For all three models the original model, the 50%, 25% and 10% direct simplifications and the 10% simplification out of all the settings with the highest scores were retextured and visualized. The screenshots of these models and the original model are shown in figure 16 through 18. The differences in the scores of the simplifications of the two algorithms and different distance thresholds for the open and close operations are relatively small, most likely because they use the same method for triangle count reduction and the test models don t have many small details. As can be seen in figure 16 through 18, retexturing the model comes with a moderate quality loss of the textures due to the fact that the grid used for the retexturing has a finite resolution. Increasing the resolution of the grid can increase the quality of the resulting textures, but doing this is often not necessary or not desired; when the model is far away from the observer or moving with high speed, which is often the case when employing level of detail, the quality should in most cases be sufficient. Also, when employing level of detail, mipmapping is usually used in combination with simplifying the geometry of the model, resulting in a similar drop in resolution and quality of the textures anyway. 24

25 Figure 16: Visual simplification results of the Ninja model. Figure 17: Visual simplification results of the Robot model. 25

26 Figure 18: Visual simplification results of the Razor model. 26

27 5. Discussion This section discusses a number of shortcomings of the current versions of these techniques and provides areas for future research. 5.1 Texture mapping limitations The current method for sampling and mapping the textures on the simplified models is fairly simple and straightforward but has its limitations. One of the problems can be bleeding or disappearance of textures near locations that are heavily simplified, especially where multiple surfaces meet. The method can likely be improved from the simple nearest neighbor function, by for example considering the surface normals or using different filtering methods. The layout of the texture file used, while simple to implement, has its disadvantages. Because more than 50% of the space is empty, the texture image is larger than it needs to be. Also, because the triangles are all disjoint, all the vertices of the model need to be duplicated instead of just those at the seams, resulting in a possible performance drop and an increase in data size. A proper unwrapping algorithm will likely give better results. 5.2 Comparison algorithm limitations The current comparison algorithm, while effective, also has its limitations. The current version weighs all voxels equally. This works well for solid models far away from the viewer, but is less effective when the model is near the observer and small details might be just as important as the general shape. Also, when working with models that have very thin surfaces, these surfaces might get a relatively small weight compared to their importance for the visual shape of the model. This method might be improved by assigning different weights to voxels, for example by weighing thin surfaces more heavily. 5.3 Simplification algorithm limitations Currently the algorithm uses a set number of user defined settings for different simplifications. It might be possible to automate the process to be more efficient in finding optimal settings and methods by intelligently choosing which simplification to try next based on statistical methods. For example a regression or cluster analysis might find a more optimal order to perform the simplifications in to get a more optimal result without running every possible combination of settings; while something like least squares might be able to predict optimal settings for any method using numerical settings by fitting a function to a smaller number of previous results and finding the optimum of that function. It might also be worth researching whether a statistical link can be found between different types of features of a model and which algorithm and settings are most successful in simplifying that model. 27

28 6. Conclusion The main goal of this thesis was to research and develop a new method that can compare different simplifications of the same model. The comparison method presented in this thesis can be used to objectively and automatically compare simplifications based on their volume and is easy to implement and independent of the simplification method used. The resulting score is stable (independent of model geometry) and easily interpreted in both absolute and relative contexts. The second goal of this thesis was to research and develop a method that can preserve textures of the original model during the simplification process and map them to the simplified version of the model. The texture mapping method presented in this thesis can be used to transfer the textures of any original model to any simplified version of that model, regardless of the method used for the simplification and without requiring user input. This method can produce results of high quality depending on the degree of simplification and the features of the model. 28

29 References [1] P. Cignoni, C. Rocchini, and R. Scopigno, "Metro: measuring error on simplified surfaces." Computer.Graphics.Forum vol. 17 no. 2, pp [2] P. E. Danielsson, "Euclidean distance mapping," Computer.Graphics.and image processing., vol. 14, no. 3. pp , [3] M. Garland and P. S. Heckbert, "Surface simplification using quadric error metrics." Proceedings.of the.24th.annual.conference.on Computer.graphics.and interactive.techniques. pp [4] H. Hoppe, "Progressive meshes." Proceedings.of the.23rd.annual.conference.on Computer.graphics.and interactive.techniques. pp [5] W. E. Lorensen and H. E. Cline, "Marching cubes: A high resolution 3D surface construction algorithm." ACM.Siggraph.Computer.Graphics. vol. 21 no. 4, pp [6] O. Matias van Kaick and H. Pedrini, "A comparative evaluation of metrics for fast mesh simplification." Computer.Graphics.Forum vol. 25 no. 2, pp [7] F. S. Nooruddin and G. Turk, "Simplification and repair of polygonal models using volumetric techniques," Visualization.and Computer.Graphics., IEEE Transactions.on, vol. 9, no. 2. pp , [8] W. J. Schroeder, J. A. Zarge, and W. E. Lorensen, "Decimation of triangle meshes," COMPUTER.GRAPHICS.-NEW YORK.-ASSOCIATION.FOR.COMPUTING.MACHINERY.-, vol. 26. pp.65, [9] G. M. Treece, R. W. Prager, and A. H. Gee, "Regularised marching tetrahedra: improved iso-surface extraction," Computers.& Graphics., vol. 23, no. 4. pp , [10] A. Van Gelder and J. Wilhelms, "Topological considerations in isosurface generation," ACM.Transactions.on Graphics.(TOG.), vol. 13, no. 4. pp , [11] L. Williams, "Pyramidal parametrics." ACM.Siggraph.Computer.Graphics. vol. 17 no. 3, pp

30 Appendix - A - Model simplification scores This appendix has the tables with the simplification scores of the different simplifications of the different models. The percentages in the top row are the triangle counts of the simplified model compared to the original model. The descriptions in the left column are the simplification method and settings used: direct for Garland and Heckbert s algorithm, the others are the open and close distance thresholds for Nooruddin and Turk s algorithm. For each column, the best score is highlighted. Table 1. Simplification scores for the Ninja model. Ninja 100% 50% 25% 10% Direct Open: 0, Close Open: 1, Close Open: 0, Close Open: 2, Close Open: 0, Close Open: 3, Close Open: 0, Close Open: 1, Close Open: 2, Close Open: 1, Close Open: 3, Close Open: 1, Close Open: 2, Close Open: 3, Close Open: 2, Close Open: 3, Close

31 Table 2. Simplification scores for the Razor model. Razor 100% 50% 25% 10% Direct Open: 0, Close Open: 1, Close Open: 0, Close Open: 2, Close Open: 0, Close Open: 3, Close Open: 0, Close Open: 1, Close Open: 2, Close Open: 1, Close Open: 3, Close Open: 1, Close Open: 2, Close Open: 3, Close Open: 2, Close Open: 3, Close Table 3. Simplification scores for the Robot model. Robot 100% 50% 25% 10% Direct Open: 0, Close Open: 1, Close Open: 0, Close Open: 2, Close Open: 0, Close Open: 3, Close Open: 0, Close Open: 1, Close Open: 2, Close Open: 1, Close Open: 3, Close Open: 1, Close Open: 2, Close Open: 3, Close Open: 2, Close Open: 3, Close