Robust face recovery for hybrid surface visualization

Transcription

1 Robust face recovery for hybrid surface visualization C. Andújar, P. Brunet, J. Esteve, E. Monclús, I. Navazo and A. Vinacua Universitat Politècnica de Catalunya Edif. Omega, Jordi Girona 1-3, Barcelona, Spain Abstract Modern adquisition techniques provide 3D datasets with unprecedented detail. Both triangle-based and point-based techniques have been proposed for efficient rendering of these objects. We present a new technique for interactive visualization of volumetric data which combines polygonal faces for flat areas and oriented points for curved regions. The paper focuses on extracting large polygonal faces from voxel data. The key ingredient is a region-growing algorithm which maintains a discrete representation of the set of planes that satisfy a separability problem. A robust representation of this set of planes based on a discretized 4D convex polytope is also discussed. The proposed face extraction algorithm is able to recover information at sub-voxel precision and automatically detects sharp edges. 1 Introduction Current adquisition techniques such as laser range scanners and medical imaging devices provide very large 3D datasets with unprecedented detail. Over the last few years, a number of techniques have been proposed for the interactive visualization of such large datasets. In a conventional approach, these objects are rendered through a triangle mesh extracted from the raw data. Most surface reconstruction techniques from data sampled on 3D grids are extensions of the well-known Marching Cubes (MC) algorithm [12]. These techniques often suffer from two problems: uniform over-tessellation and alias artifacts. Strategies for alleviating over-tessellation include Discrete MC [13] and mesh simplification; on the other hand, several techniques address feature-preserving extraction [10, 8]. In recent years, strategies for discretizing synthetic graphics objects into point-based representations [18, 15] have become an attractive alternative for rendering very large scanned objects. Comparing both approaches, point primitives outperform triangles in curved areas whereas triangle primitives could be a more compact representation for flat regions, provided that these regions are conveniently detected. Therefore, for a method combining both kinds of primitives, efficient detection of flat regions and feature-preserving reconstruction of large polygonal faces is required. This paper focuses on the problem of extracting large polygonal faces from volume datasets. We show that resulting meshes can be used in combination with point-rendering approaches for efficient rendering of complex datasets involving a mixture of planar and curved regions. The input model is first converted into a set of face-connected voxels called Discrete Band [5] which supplies the necessary framework for guaranteeing an error bound [3, 1]. Flat regions inside the Discrete Band are detected with a region-growing algorithm which maintains a discrete representation of the set of planes that satisfy a separability problem. The key ingredient is a robust representation of this set of planes based on a discretized 4D convex polytope. Once flat regions have been identified, their boundaries are computed by intersecting their supporting planes; finally, point-samples are computed in curved regions where not sufficiently large faces have been found. Original contributions of the paper include, A robust way of representing the set of planes that split a linearly separable set of points. A feature-preserving face extraction algorithm which detects and large planar regions. The extensive use of integer arithmetic, which is essential for the algorithm s ability to recover large faces of the original model. A hybrid visualization approach [4] combining polygonal faces and oriented points. VMV 2003 Munich, Germany, November 19 21, 2003

2 Our face extraction algorithm produces faces which are guaranteed to locally separate interior and exterior points. These faces can be further simplified with standard simplification algorithms for generating multiresolution representations. Note however that most surface simplification algorithms will not preserve the correct interior/exterior point classification (for one exception see [17]). The rest of the paper is organized as follows. Section 2 reviews previous work on isosurface extraction and visualization. Section 3 outlines the proposed algorithm, which is detailed in Section 4 (tetrahedra decomposition) and Section 5 (algorithms for the generation of tiles and points). Results are presented in Section 6. 2 Previous Work The Marching Cubes (MC) [12] algorithm is the most common technique for generating an explicit surface description from sampled volume data. MC-like algorithms suffer from some limitations: resulting meshes often exhibit noise artifacts, they are uniformly over-tessellated, and sharp edges are not automatically reconstructed. In this section we briefly describe the previous work more closely related to our proposal. Several methods have been proposed for extracting smooth surfaces from voxel representations of sampled data. Vinacua et al propose a method for converting voxel data into a C 2 algebraic surface defined as the zero-valued isosurface of a tensorproduct uniform cubic B-spline. An improved version with reduced computational costs is presented in [6]. These techniques are well-suited for applications that deal with smooth surfaces, but they are unable to represent sharp features. Liu et al [11] propose a novel fairing algorithm to remove noise from triangular meshes. The algorithm produces a smooth surface without undesired shrinkage and distorsion. Encouraging results are presented but sharp edges are also smoothened. Ohtake et al method [14] smoothes isosurfaces computed by the Marching Cubes algorithm while maintaining sharp features. The algorithm is based on a mesh evolution process where three different filters are combined to control the smoothness of the extracted surface. Volumetric models where the gradient field of the implicit function is known enable more efficient feature-preserving algorithms. Kobbelt et al s approach [10] uses a vector distance field evaluated at the mesh points. Cells containing feature edges of the original surface are identified and refined introducing new vertices which minimize a quadric error function. A dual approach for solving the same problem is presented in [8]. A number of methods have been proposed for reducing the number of polygons generated by MC. These techniques have traditionally been divided into voxel-based decimation [13] and stardard surface simplification techniques. Voxel-based decimation methods produce consistent meshes (i.e. they preserve the inside/outside classification of sampled points). Montani et al [13] propose a Discretized Marching Cubes (DMC) algorithm for decimating MC output. The algorithm discards the values at sampled points and considers only their binary inside/outside classification with respect to the surface. Mesh vertices are created at the midpoint of the grid edges so that the resulting polygons lie on one of 13 different planes, thus allowing simple merging of the output faces into large coplanar polygons. Standard surface simplification techniques operating on MC output are broadly used when producing voxel-consistent meshes is not an issue. Although some methods can guarantee the mesh to stay within a prescribed approximation volume by using a suitable global error criterion, translating the consistency requirement to a tolerance volume results in a discrete axis-aligned volume which forces a redesign of the simplification strategy [17]. Although most standard simplification techniques require and produce triangle meshes, a few methods attempt to produce polygonal faces with an arbitrary number of vertices. Kalvin and Taylor [9] propose a surface simplification method which includes a face extraction procedure in two steps. First, flat regions called superfaces are detected using a region-growing algorithm; then borders betweensuperfaces are simplified using 2D polygonal simplification. In our proposal two similar steps are also involved but in a more flexible way. Recently, new rendering approaches based only on point primitives have been proposed [18, 15]. We adopt the idea of representing complex smoothed areas by a set of points while maintaining polygonal faces in large planar regions. The idea of mixing polygonal and point primitives for

3 visualization has also been proposed by Coconu and Hege [4]. They use an octree-based spatial representation containing both a triangle-based and a point-based description of the surface. During rendering, the surface inside each octree node is rendered with triangles only if the point density is too low to ensure a hole-free surface. Our hybrid visualization differs from [4] in that we do not use point primitives for the whole surface but only for those regions which are not properly captured by planar faces. 3 Algorithm overview Given a volumetric model we aim at extracting an isosurface representation having a minimal number of polygonal faces along with a set of oriented points. The input volumetric model can be provided in several forms, including uniform grids, discrete object representations and unstructured pointsets. In order to handle all these models in a uniform way, the input dataset is first converted into a set of face-connected voxels called Discrete Band [5] which contains the boundary of the object implicitly defined by the volumetric model. Discrete bands can be constructed in a number of different ways. Given a uniform grid, the discrete band is defined as the set of cubic voxels containing the isosurface. A discrete band can be easily constructed from a voxelization of a polygonal model by simply selecting the boundary voxels of the object [1]. Robust algorithms for constructing discrete bands from unstructured point clouds also exist [5]. Discrete Bands are well suited for surface reconstruction. The band thickness provides the necessary flexibility for relaxing and improving the quality and fairness of the final surface. In our approach, we are interested in obtaining a minimum number of large polygonal faces being completely contained in the discrete band. The approximation error can be guaranteed, by construction, to be less than the voxel diagonal size. For discrete bands computed from uniform grids, resulting surfaces always preserve the inside/outside classification with respect to the grid points. Starting from a discrete band representation, our algorithm proceeds through the following steps (see Figure 5): Weight assignment. Voxel vertices are assigned a positive value if they belong to the outer boundary of the discrete band, and a negative value otherwise. This weight assignment is based on a conceptual partition of the voxels into tetrahedra. Planarity radius computation. For each tetrahedron face we compute a measure of the flatness of its neighborhood called radius. Tile generation. A simple region-growing algorithm is used for connecting sets of tetrahedra in planar regions and mark them as tiles. Border detection. Tile borders are computed by intersecting neighbor tiles. Tile clipping. Tiles are converted into polygonal faces by adding new edges and completing their edge loops. Oriented point generation. As an alternative for sewing faces, tetrahedra not belonging to any polygonal face can be represented as oriented points, when producing a watertight model is not an issue. 4 Tetrahedra decomposition As already discussed, the algorithm starts from a discrete band approximation of the object. This band is a face-connected set of voxels enclosing the object boundary. Given a discrete band we can assign a signed value (which we call weight) to each voxel vertex. For example, if vertices in the outside part are assigned an arbitrary possitive value and vertices in the inside part are assigned a negative value, then the zero-valued isosurface of the resulting scalar field will be completely contained in the discrete band. These weights play an important role in the first steps of our algorithm because they allow us to represent an evolving surface implicitly. As a consequence, the problem of extracting a suitable surface completely contained inside the discrete band can be reduced basically to compute a suitable set of weights for the voxel vertices. We represent weigths as integer values in the range N N. Note that discretizing the weights has the effect of discretizing the set of incident planes for the resulting faces, thus allowing automatic compactation of neighbor faces in flat parts of the object surface [13]. We have chosen to split each discrete band voxel into five tetrahedra [7]. This tetrahedral decomposition allows the automatic generation of local affine functions that extend across a number of neighbor

4 tetrahedra and voxels. Figure 1 shows a blown-out picture of this arrangement. It must be noted here that this split is logical in the sense that the tetrahedra are not explicitely stored since they are implicitly represented in the voxel data. For referencing a tetrahedron four integers i j k t suffice, t being an integer identifying a tetrahedron out of the five in voxel i j k. This tetrahedra decomposition is a key aspect of our face recovery algorithm. Tetrahedra are inherently simpler, and each one of them will only hold a single planar portion of a face. Unlike tetrahedra, many cubic cells configurations require more than one such planar face and will not automatically enforce its planarity even on the cases where only one plane suffices. The tetrahedra decomposition is not the same on all voxels, but rather is copied to neighbor voxels by symmetry about the common plane. If the voxel at that contains the point is split as in Figure 1 (the origin being at the bottom, back and to the left), then the vertices of the interior tetrahedron (in green, made up of equilateral triangles) lie on points such that the sum of their coordinates i j k is even, whereas the vertices common to three isoceles facets of the other tetrahedra lie on points such that the sum of their coordinates is odd. We call these vertices even and odd respectively. The exterior tetrahedra (in blue) are called class E, and the interior tetrahedra are called class I. Class I tetrahedra consist exclusively of even vertices, whereas class E tetrahedra have one odd vertex and three even vertices. Let us see next how this tricky partition allows us to guarantee in a simple way that the discrete family of planes modeled inside each of the tetrahedra is the same. In what follows, we call relevant tetrahedron (resp. facet) a tetrahedron (resp. facet) that has both positive and negative weights. For our approach to work, we need to make sure that the planes in the discrete families corresponding to neighbor tetrahedra match. Let us consider first two arbitrary tetrahedra sharing a facet, as in Figure 2. Let us suposse first vertices having an initial associated weight w vertex. Consider the tetrahedron T 1 (painted in black lines) as the domain of an affine function g : T 1, such that g P w P, g R w R, g S w S and g T w T. For a relevant tetrahedron not all the w x will have the same sign, and therefore the plane of zeros of P Figure 1: A voxel splited into five tetrahedra. T 1 T S Figure 2: Two neighbor tetrahedra g will cross the tetrahedron. This is the plane inside T 1 defined by these weights. Notice that the evaluation of g is simple in barycentric coordinates: the function g X in a point X with barycentric coordinates X P X R X S X T with respect to T 1 is g X P X R X S X T X i w i, i P R S T. Notice also that should we want to express the same function with respect to the neighbor tetrahedron, it would suffice to assign Q the weight w Q g Q and leave the weights w R, w S and w T unchanged. A normal vector for that plane is g. Ifwefixan Euclidean orthogonal reference e x e y e z,andif these vectors can be expressed in barycentric coordinates with respect to T 1 as e i i P i R i S i T, then the gradient of g in the Euclidean frame is readily seen to be x v P R S T v w v y v P R S T v w v z v P R S T v w v! " The problem of consistency is that of determining discrete sets of weights to use at each vertex so that the discrete family of planes modeled on each tetrahedron is the same, ensuring that common faces may be represented across the different F R T 2 Q

5 tetrahedra they visit. In the chosen splitting scheme there are only two kinds of neighbor configurations: two tetrahedra of class E sharing half a voxel s face, and one tetrahedron of class E and its class I neighbor. Figure 3 shows these two cases and the barycentric coordinates of the non-common vertex of each tetrahedron with respect to its neighbor. In both cases only one of the vertices that appear is odd, and we have explicitely marked it so. Notice that the coefficient of the odd vertices in the coordinates of the neighbor free vertex is in both cases 2. Also notice that the vertices of the green (class I) tetrahedron are all even, and their coefficients in the barycentric coordinates of the odd vertices are all positive or negative 2 1. Our aim is to choose two subsets of the integers, K 1 and K 2 so that if we have any tetrahedron in our scheme all of whose even vertices take values in K 2 and whose odd vertex (if it has one) has a weight in K 1, then if we compute the coefficient of the fourth vertex of any neighbouring tetrahedron so that the same plane extends into it, the resulting weight (given by w Q $ g% Q& as noted above) falls in the right category, that is if the vertex is odd the result of g% Q& is necessarily in K 1, and if the vertex is even then it is necessarily in K 2. The previous observations on the baricentric coordinates of this fourth vertex in the two possible cases implies that values in K 2 must be even because they appear divided by two in the computation of g% Q& when Q is the odd vertex in the case depicted on the left of figure 3. Likewise we see that any integer value may be allowed in K 1, as the weights of odd vertices are always multiplied by two in the computation of g% Q& from an even Q. Therefore we see that if we let the even vertices take weights in 2' (the even integers), and the odd vertices in ',wehaveaconsistent scheme. In practice we shall truncate these to ( x ) * + 2N, 2N-...x $ 2y, y ) ' 1 and * + N, N- 3 ' odd Figure 3: The two neighbor configurations Figure 4: Plane directions available in the 1 st quadrant using only four bits to encode the weights rections available when four bits are used to store the weights, giving weights in * + 8, 7- for odd vertices and in * + 16, 14- for the even ones. The total number of distinct directions in the first quadrant is in this case of 2, Algorithm Description 5.1 Weight and radius computation The algorithm starts by assigning values to voxel vertices of the discrete band. Voxel vertices are assigned a positive integer value v centered in the range * 0, N- if they belong to the outer boundary of the discrete band and a negative value (also centered in the range * + N, 0- ) otherwise. After this, the second step involves the computation of the planarity radii that will drive the tile generation process. We use the following recursive definition of the k-neighborhood of a relevant facet f : The 1-neighborhood of f is the set containing the two tetrahedra sharing f ;the k-neighborhood of f is the union of the (k-1)-neighborhood with all the relevant tetrahedra that share a relevant facet with some tetrahedon of this (k-1)-neighborhood. For every relevant facet f, we compute its radius as the maximum value of k such that the k- neighborhood of f is linearly separable. The k- neighborhood of f is said to be linearly separable iff the vertices with positive weights in the k- neighborhood are linearly separable from the vertices with negative weights in the same tetrahedra. respectively, where N is a parameter setting the desired precision, as we want to handle only a finite set of possible directions. With this choice of K 1 and K 2, the set of normals to the planes is the set of vectors in ' 3 whose three components are all even numbers or they are all odd numbers. Truncated to a certain precision, these are reasonably distributed over the set of directions. Figure 4 shows an orthogonal projection of the first quadrant of the unit sphere, with the diodd

6 For every facet f, we build its k-neighborhoods for increasing values of k in an incremental way using the randomized algorithm described in [16]. We have observed that it is not necessary to go beyond k 9 9, as this has no effect in the rest of the algorithm. As a consequence, the computation of the facet radii takes linear time. Figure 5-c and Figure 6 show the radii of two different datasets, red color indicating the largest radius. 5.2 Tile Generation Tile generation is the most important step of our algorithm. A tile is a connected set of relevant tetrahedra that have positive vertices being linearly separable from their negative vertices. Tiles are represented as a set of tetrahedra together with the plane equation of the separating plane. When clear by the context, we will use the term tile for referring to the set of tetrahedra, to its associated plane and to a clipped face lying on this plane. Separating planes are represented by the four integer weights at the vertices of a single relevant tetrahedron that we will designate as the tile representative. We use an easy-to-implement region-growing algorithm for connecting sets of tetrahedra in planar regions and mark them as tiles. Regions start growing from a relevant class I tetrahedron that will act as the tile representative. The key ingredient for finding the best plane is a robust and efficient way of representing the set of planes that split a linearly separable set of points. The set of candidate planes through a tetrahedron is uniquely defined by the discrete values of the weights of its four vertices (in the range : 1; N< or : = N ; = 1< depending of the sign). As a consequence any possible discrete plane is represented by the integer coordinates of a point in a four dimensional box in the space of vertex values. Initially, the set of feasible planes corresponds to the whole box. We represent the set of feasible planes as a run-length encoding of the four-dimensional voxelization of the discrete convex set of 4D points representing the vertex weights? w 4B of the representative tetrahedron. More precisely, we represent it as a 3D array that stores at each cell a 1D interval in the fourth dimension. We call this array 4DCone. Note that the shape of this convex set is a cone since for any point? w 4B of the set, the points? λ C λ C w 4B also belong to the set. The algorithm works by iterating the insertion of new neighbor relevant tetrahedra into the tile while updating the convex cone of feasible 4D points. Each update requires a boolean set intersection between the previous cone and the planar halfspace defined by the new candidate vertex. This algorithm can be implemented in a very efficient way using dynamically-maintained bounding volumes and it is strictly based on integer arithmetic. Note that if real values were used then the 4DCone would represent a 4D polyhedron that will be subsequently cut by a plane at each relevant tetrahedron insertion. As a consequence a polyhedron with a high number of faces would be produced; the algorithm complexity would grow while its robustness would decrease with the successive insertions. As soon as a tile has been completed, the algorithm starts again with a new seed tetrahedron to generate a new tile. Candidate seed tetrahedra are visited in decreasing order of radii: a possible seed of radius R will only be accepted if all possible seeds of radius R D 1 have already been included in some tile. On the other hand, tiles that contain a number of tetrahedra below a certain threshold are discarded. 5.3 Border detection and tile clipping During tile generation we track neighbor tiles. Neighbor tiles are tiles sharing a set of voxels of the discrete band. A single pointer per voxel (pointing to the first detected tile that stabs the voxel) is required for this detection, since a neighborhood relationship can be created every time that any voxel pointing to the tile t i is stabbed by another tile t j. Once the tiles have been obtained, their bounding edges are computed by intersecting the associated planes. Every intersection line can produce one or more edges: valid edges are segments of the intersection line that are contained in connected sets of voxels belonging to both tiles (imagine the tile created by a complex concave face). These edges are labeled as hard edges and assigned to both neighbor tiles. The algorithm also computes a set of hard vertices at the voxels where three or more tiles converge. A quadric error function is used where more than three tiles are involved. Once hard edges and hard vertices have been computed, we extract for each tile a set of planar faces. The algorithm works in 2D by first projecting the set of boundary voxels of the tile in the direction of the maximum component of its associated plane

7 normal. A first approximation of the tile s boundary is obtained by completing the hard edges with a 2D cuberille from the voxel projection. This initial polyline is iteralively simplified by alternating 2D vertex and edge removal operations (for further details see [2]). 5.4 Oriented Point Generation The last step in our algorithm is the computation of the oriented points (a position plus normal vector). The algorithm starts by computing a short list of the (at most) three nearest polygonal faces for every tetrahedron of the discrete band that has not been included in any polygonal face (see [2] for further details). The orientation of the point associated to a certain tetrahedron is computed as a weighted average of the normal vectors of its nearest planar faces, the weights being inversely proportional to the positive distances from the point to the corresponding planes. In our present implementation, the positions of the points are simply set to the centroids of the tetrahedra. This integer sub-voxel approximation has shown to be an acceptable solution in our experiments. Alternatively, the algorithm could provide a watertight model by using the generated tiles for computing Hermite data and then applying [8]. 6 Results and Discussion The proposed algorithm has been implemented and tested with two different datasets: a car engine model and the well known happy budda. In both cases the input of the algorithm was a discrete band computed from a 256x256x256 grid (Figure 5a-b and Figure 6a-b). The integer range parameter N was 64 in both cases. The car engine model involves many planar regions which were precisely reconstructed by our algorithm. Figure 6e shows the largest tiles generated by the tile extraction step. Figure 6d shows a detailed view. Note the jagged edges of the tile boundary (due to the alternating tetrahedra decomposition), which will be clipped in the border detection step. Table 1 compares the number of tiles and oriented points produced by our algorithm with a corrected version of Marching Cubes. Tiles with less than 30 tetrahedra have been discarded. The engine model contains many planar regions, helping our algorithm to extract large planar tiles covering 2,256 tetrahedra on average, whereas tiles on the budda model covered only 576 tetrahedra on average. Running times on a Pentium 4 at 2.8GHz are shown in Table 2. We have split running times into two phases because the radius computation clearly dominated the overall cost. Phase 1 includes weight assignement and radius computation, whereas Phase 2 includes the rest of steps: tile generation, border detection, tile clipping and point generation. Note that the radius computation step mainly depends on the number of voxels and on the maximum radius value. Running times for Phase 1 can be reduced by reducing the maximum radius, which has only a moderate impact on the tile generation. Running times for tile generation mainly depends on the number of voxels and on the parameter N, which in turn determines the space of discrete plane orientations and the constant factor for operations on the 4D Cone. Model Tiles Points MC MT Budda 868 7, , ,946 Engine , ,152 1,442,622 Table 1: Results on the budda and engine models: number of tiles, number of oriented points, triangles that would produce a corrected Marching Cubes and number of tetrahedra containing surface. Model Phase 1 Phase 2 Budda 15.3 min 53 s Engine 30.2 min 71 s Table 2: Running times on the budda and engine models. 7 Conclusions and Future Work We have presented a new technique for discrete surface extraction. Our algorithm accepts as input voxelizations of polygonal models, volume voxel models and general point cloud models. The original contributions of our approach include a robust and efficient way of representing the set of planes that split a linearly separable set of points, a featurepreserving face extraction algorithm from signed voxels which detects and extracts large planar regions and a hybrid visualization approach combining polygonal faces in flat areas and oriented points

8 in curved areas. The algorithm has proven to be more flexible and efficient than Marching Cubes and Discrete Marching Cubes in models involving a mixture of planar and curved regions, when preprocessing time is not an issue. Future work includes a number of methods for improving the tile generation algorithm and for increasing the total surface area of the tiles. Algorithms for reducing the tile clipped areas in the polygonal face generation process are also being investigated. These algorithms can create several convex polygonal faces from a single tile while minimizing the number of discarded tile tetrahedra. The effect of the size of the integer range E F N G NH and the size, convexity and number of generated tiles on the overall efficiency of the algorithm must be further investigated. 8 Acknowledgements The authors would like to thank Professor Jarek Rossignac for his helpful comments and discussions. This work has been partially supported by the Spanish Ministry of Science and Technology under the project TIC C References [1] C. Andujar, P. Brunet, and D. Ayala. Topology-reducing simplification through discrete models. ACM Transactions on Graphics, 20(6):88 105, [2] C. Andujar, P. Brunet, J. Esteve, E. Monclus, I. Navazo, and A. Vinacua. Discrete surface extraction and visualization. Technical report, Software Department, Universitat Politecnica de Catalunya, [3] D. Ayala, P. Brunet, R. Joan-Arinyo, and I. Navazo. Multiresolution approximation of polyhedral solids. In CAD Systems Development: Tools and Methods. Springer-Verlag, [4] Liviu Coconu and Hans-Christian Hege. Hardware-accelerated point-based rendering of complex scenes. In Proceedings of 13th Eurographics Workshop on Rendering, [5] J. Esteve, P. Brunet, and A. Vinacua. Approximation of a variable density cloud of points by shrinking a discrete membrane. Technical report, Software Department, Universitat Politecnica de Catalunya, [6] J. Esteve, A Vinacua, and P. Brunet. Multiresolution for algebraic curves and surfaces using wavelets. Computer Graphics Forum, 20(1):47 58, [7] A. Gueziec and R. Hummel. Exploiting triangulated surface extraction using tetrahedral decomposition. IEEE Trans. on Visualization and Computer Graphics, 1(4): , [8] T. Ju, F. Losasso, S. Schaefer, and J. Warren. Dual contouring of hermite data. In Proceedings of SIGGRAPH 2002, pages , [9] A.D. Kalvin and R.H. Taylor. Superfaces: Polygonal mesh simplification with bounded error. IEEE Computer Graphics and Applications, May:64 77, [10] L.P. Kobbelt, M. Botsch, U. Schwanecke, and H-P. Seidel. Feature sensitive surface extraction from volume data. In Proceedings of SIG- GRAPH 2001, pages 57 66, [11] X. Liu, H. Bao, P-A. Heng, T-T. Wong, and Q. Peng. Constrained fairing for meshes. Computer Graphics Forum, 20(2): , [12] W. Lorenson and H. Cline. Marching cubes: a high resolution 3d surface reconstrution algorithm. ACM Computer Graphics, 21: , [13] C. Montani, R. Scateni, and R. Scopigno. Discretized marching cubes. In IEEE Visualization 94, pages IEEE, [14] Y. Ohtake and A.G. Belyaev. Mesh optimization for polygonal isosurfaces. Computer Graphics Forum (Eurographics 01), 20(3): , [15] M. Pauly and M. Gross. Spectral processing of point-sampled geometry. In Proceedings of SIGGRAPH 2001, pages ACM, [16] R Seidel. Linear programming and convex hulls made easy. In ACM Symposium on Computational Geometry, pages , [17] S. Zelinka and M. Garland. Permission grids: Practical, error-bounded simplification. ACM Transactions on Graphics, 21(2), [18] M. Zwicker, H. Pfister, J. VanBaar, and M. Gross. Surface splatting. In Proceedings of SIGGRAPH 2001, pages , 2001.

9 Figure 5: Algorithm overwiew: (a) Input pointset; (b) Discrete Band; (c) Measure of local flatness; (d) Largest tiles; (e) Oriented points (with exagerated splat size); (f) Underlying model. (a) Input pointset (b) Discrete band (c) Radii (d) Tile detail (before clipping) (e) Largest tiles (before clipping) (f) Underlying model Figure 6: Results on the car engine model.