Consistent Mesh Partitioning using Tetrahedral Meshes

Transcription

1 Consistent Mesh Partitioning using Tetrahedral Meshes Philipp Fürnstahl Institute for Computer Graphics and Vision Graz University of Technology Inffeldgasse 16 A-8010 Graz, Austria Master s Thesis Advisor: Dipl.-Ing. Bernhard Reitinger Supervisor: Univ.-Prof. Dipl.-Ing. Dr.techn. Dieter Schmalstieg 2005

2 Contents 1 Introduction Motivation Contribution Overview Related Work Partitioning, Subdivision, and Cutting Intersection Collision Detection Mesh Optimization Floating Point Calculations Mesh Representation Formal Mesh Model Entities Boundary Extraction Rendering Plane Partitioning Intersection Consistent Intersection Point Propagation Subdivision Node Snapping Algorithm Outline Shape Partitioning Method of Separating Axes Collision Detection Intersection Consistent Intersection Point Propagation Subdivision Edge Iterator Iterative Subdivision i

3 CONTENTS CONTENTS 5.6 Region Detection - Inside/Outside Determination Algorithm Outline Mesh Improvement Floating Point Consistency Exact Floating Point Arithmetic Adaptive Precision Floating Point Arithmetic Implementation Mesh Optimization Mesh Smoothing Mesh Simplification Results Data Sets Discussion Conclusion and Future Work 98 9 Appendix 101 Bibliography 103 ii

4 List of Tables 4.1 Subdivisions of a tetrahedron intersected by a plane Partitioning of tetrahedron vertices for each particular subdivision case Subdivision of a pyramid into tetrahedra Subdivision of a prism into tetrahedra Possible intersections of a tetrahedron and a partitioning shape Performance and quality measurements of the algorithms (cube model) Performance and quality measurements of the algorithms (sphere model) Performance and quality measurements of the algorithms (head model) Performance and quality measurements of the algorithms (troll model) Performance and quality measurements of the algorithms (liver model) iii

5 List of Figures 1.1 Outline of the partitioning technique Examples of incorrectly and properly connected simplices Example of a binary tree storing a sequence of partitioning operations Example of a mesh whereon a sequence of partitioning operations is applied to Example of a mesh showing a sequence of partitioning operations Intersections of a tetrahedron and a plane Intersection of a line segment and a plane Orthogonal projection of a point onto a plane Robust floating point calculations can be achieved by using node snapping An example of the method of separating axes Example of an octree Example of a quadtree subdivision Outline of the point in triangle test Example of a hash table organized in buckets Possible cases, if splitting a tetrahedron face with a partitioning shape face Simplified iterative tetrahedra subdivision Assignment of subdivided triangles to entities Outline of the region detection algorithm Work flows of the fast-expansion sum and scale-expansion algorithm Classification of degenerated tetrahedra with given edge collapsing strategy Examples of a valid and an invalid edge collapse concerning topological correctness Models used for performance and quality tests Runtime analyses of the plane and shape partitioning algorithms Comparison of the mesh optimization algorithms Comparison of the plane partitioning algorithm with and without node snapping iv

6 LIST OF FIGURES LIST OF FIGURES 7.5 Example of various resection strategies using plane and shape partitioning operations Example of the hierarchical mesh data structure, showing the benefits for surgical planning Limitations of the shape partitioning algorithm The subdivision algorithm can also be used to partition a liver into its segments Visualization of the mesh quality Local numbering of vertices of tetrahedra, pyramids, and prisms v

7 Abstract This thesis presents partitioning techniques which classify a volumetric mesh into different regions while preserving the mesh connectivity (consistency). A mesh is partitioned by applying a plane partitioning technique which is geometrically exact, and a novel approach for approximate partitioning where triangular surface meshes are used as partitioning shapes. In both methods, the propagation of intersection points to adjacent faces is performed by using a hash table. The subdivision of the plane partitioning technique relies on existing methods while the shape partitioning algorithm requires an extension of these subdivision methods to identify correct partitions and handle multiple intersection points per edge. Therefore, a subdivision technique is introduced which splits tetrahedra in an iterative way. In order to partition the volumetric mesh after splitting, a strategy is introduced which assigns subdivided and initial tetrahedra to the corresponding region in a robust way. A labeled hierarchical mesh model is used which is able to store consecutive partitioning operation, and to perform an efficient boundary extraction for visualization. A known problem of subdivision algorithms is the generation of badly shaped tetrahedra due to subdivision. In order to avoid degenerated primitives, several optimization and node snapping techniques are presented. Finally, the problem of floating point roundoff errors, which can cause inconsistency, is covered in the thesis as well. Index words: partition, consistency, shape partitioning, plane partitioning, tetrahedral mesh, subdivision, mesh optimization, degeneracies, floating point errors

8 Acknowledgments The first person I would like to thank is my advisor Bernhard Reitinger for his great support and the pleasant collaboration. Thank you for introducing me to this interesting topic. I would also like to thank my supervisor Dieter Schmalstieg for giving me the possibility to write this thesis at the Institute for Computer Graphics and Vision. I would like to thank Thomas Fuchs, Florian Mendel, and Daniel Nebel for perusing my thesis. Special thanks go to my colleagues Ramin Dalkouhi, Thomas Fuchs, Mark Klostermann, and Florian Mendel who completed almost any course and examination with me. Thank you all for being my colleagues and friends. I want to express my gratitude to Roland Perko who introduced me to the Institute for Computer Graphics and Vision. Thanks to all my friends for their help and appreciation. Particularly, Peter Baldi, Sandra Burghard, Robert Hoffmann, and Georg Pessler. I am very grateful for the encouragement from my family and relatives, especially for my parents and my sister. My parents always gave me the necessary support, required to complete this degree. Finally, thanks to all people who cannot see their name in these lines but think it should be there. 1

9 Chapter 1 Introduction 1.1 Motivation In computer-aided medical visualization systems such as the virtual liver surgery planning system [8], analysis tools are required for planning surgical interventions such as liver tumor removal. In contrast to surgical simulation environments which focus on the training aspect of surgical procedures, our aim is to produce quantitative information for analysis and planning. For this reason, physically-based models, deformation, or photo-realistic rendering techniques are not useful since physicians are only interested in the quantitative outcome of the planning procedure. In the case of liver surgery, surgeons have to find out which parts of the liver must be resected (removed). This is done by performing a sequence of partitioning operations in order to isolate the diseased part of the tissue in an iterative way. Each region can then be individually analyzed and gives important indices (e.g. volume) to the surgeon. The typical planning procedure for a surgical intervention starts by locating the tumor in the liver data set. Then, the data set is partitioned using a plane in order to uncover the tumor. Subsequently, a suitable shape is used to apply a more specific partitioning operation for removing the residual. Finally, the volumes of the resected parts are measured which gives important quantitative indices for the actual surgical intervention. By using our data structures, several intervention strategies can be explored and stored in the model. Analysis of such variants is often necessary if surgeons want to find a trade off between minimal tissue removal and oncological requirements. In particular, the surgeon may want to revisit and alter operations done earlier. For a procedure explained above, partitioning tools are required for classifying the liver tissue in healthy/diseased or removed/remaining regions, while measuring certain aspects, such as removed volume. These tools are similar to constructive solid geometry (CSG) operations which are often used in the field of computer-aided engineering. A mesh is decomposed by either applying a plane or a shape partitioning operation which divides the mesh into disjoint regions. A partitioning plane is specified analytically, whereas a 2

10 1.1. Motivation Introduction partitioning shape requires an explicit geometrical (i.e. a triangular mesh) representation of the shape. Both partitioning methods are applied globally to the mesh, in contrast to cutting techniques used in surgery simulation which aim at local mesh modification (e.g. simulation of scalpel cutting). In addition, a cutting operation usually deletes part of the mesh geometry. However, for surgical planning procedures, all existing model information must be preserved. Therefore, our proposed partitioning operations add additional partitioning information to the data structure rather than deleting a part of the mesh. The storage of consecutive partitioning operations is archived in a labeled hierarchical data structure based on a binary tree. A partitioning operation introduces a new level in the tree. Figure 1.1 sketches an example where two consecutive partitioning operations are stored in the according binary tree. plane partitioning (a) The sequence of the partitioning operations stored in a binary tree. shape partitioning (b) Each partitioning operation decomposes the mesh into regions. Figure 1.1: Outline of the partitioning technique. While the binary tree is only responsible for handling different partitioning results, the input mesh is stored as volumetric data. Tetrahedral meshes are often the data structure of choice if volumetric information (e.g. type of tissue) must be processed. Although traditional medical planning systems often use either voxel-based or surface-based models, tetrahedral meshes are more flexible than both data structures, because complex volumetric data sets can be represented with few primitives. Moreover, the properties of simplicial 3

11 1.2. Contribution Introduction complexes used in our tetrahedral mesh implementation guarantee a consistent mesh topology. This thesis aims at discussing the technical aspects of the partitioning methods outlined above. The plane partitioning technique relies on existing methods while the shape partitioning algorithm requires several extensions in order to identify correct splits and handle multiple intersection points per edge. Taking into account that the partitioning methods operate globally on a potentially large mesh model, an acceptable runtime of under one second should be achieved. 1.2 Contribution Apart from the application-specific contribution, this thesis also provides the following list of contributions: Plane Partitioning Partitioning using an infinite plane will be a fundamental feature in our surgical planning system. Although intersection point calculation is built upon basic vector algebra, several problems must be solved: Adjacent tetrahedra sharing an intersection point have to refer to the same vertex index. A hash table is used for fast intersection point propagation which is able to store additional information maintaining consistent mesh topology. Another challenge concerning plane partitioning is a consistent subdivision being able to split each tetrahedron according to the plane. Subdivision is a technique where objects are split into smaller mesh primitives. Although a lot of work was done concerning subdivision, a detailed and explicit description of subdivision is not given in existing publications. Therefore, the subdivision cases which arise if intersecting a tetrahedron with a plane, including the required subdivision of pyramids and prisms are discussed in detail. Shape Partitioning Dividing volumetric meshes by using a partitioning shape is a complex task. Techniques like collision detection and consistent intersection point calculations must be combined. The collision detection has to be fast enough for interactivity (i.e. less than 10 ms to detect 1000 collisions). In addition, extensibility to handle collisions of deformable objects should be considered for future work. 4

12 1.3. Overview Introduction Beside collision detection and intersection calculations, the actual shape partitioning algorithm is the most challenging part: Similar to the plane partitioning algorithm, a hash table is used for the propagation of shared intersection points. The propagation algorithm of the shape partitioning technique relies on geometric tests which use floating point arithmetic. Exact results can be achieved by using an exact floating point arithmetic. Existing subdivision methods are extended by a new data structure which is able to handle multiple intersection points per edge and to separate the mesh into two partitions. Thus, the so-called iterative subdivision is introduced. Additionally, a region detection algorithm is described which efficiently assigns the partitioning result to the corresponding entity. 1.3 Overview In Chapter 2 an overview of existing partitioning, cutting, and subdivision methods is given. In addition, required techniques like collision detection or mesh simplification algorithms are compared. The mesh model, used to guarantee consistency, is presented in Chapter 3. The partitioning algorithms are described in detail in Chapter 4 and Chapter 5. The problem of floating point roundoff errors, which can negatively affect consistent partitioning, is discussed in Chapter 6. In addition, two mesh optimization techniques to improve the quality of partitioning results are presented in Chapter 6. Finally, the results including runtime analyses of the algorithms and the quality of partitioning results are stated in Chapter 7. 5

13 Chapter 2 Related Work 2.1 Partitioning, Subdivision, and Cutting Since each partitioning operation divides the tetrahedra of the volumetric mesh into disjoint parts, the presented partitioning algorithms are related to existing cutting techniques. In addition, most cutting algorithms use subdivision techniques in order to split tetrahedra. Interactive volume-based partitioning and cutting is an active research field. A survey and classification of different cutting techniques can be found in [10], where a simple framework for building a generalized cutting scheme is described as well. Partitioning and cutting techniques can be divided into methods which remove intersected primitives and methods which perform remeshing of intersected primitives. The latter technique results in more accurate cuts and gives more precise results for coarser meshes. Although the volumetric mesh size increases and more complex algorithms have to be applied, it is the method of choice for surgical applications. Further, cutting can be classified based on the cutting tool. Recently, a lot of research was done in cutting with a moving tool (e.g. a scalpel) [5, 64, 50], frequently in conjunction with haptic feedback devices and soft tissue simulations [51, 49]. Bielser et al. [7] were one of the first presenting a generalized subdivision schema which is able to handle partially cut tetrahedra. The actual subdivision is reduced to five basic topological cases. Two cases represent complete splits while the other three are applied to partially cut tetrahedra. A tetrahedron is divided into a fixed number of 17 smaller simplices by adding one vertex to each face and one vertex to the middle of each edge (so-called 17:1 splitting schema). The generalized subdivision schema introduced in [7] was improved by Bielser and Gross [6]. Cut-specific subdivision patterns were introduced by subdividing only faces and edges which are part of the cut surface. The algorithm subdivides tetrahedra consistently while correct neighborhood is guaranteed. In addition, surface and volume collision detection, relaxation using a mass-spring system, and a haptic scalpel model are described. 6

14 2.1. Partitioning, Subdivision, and Cutting Related Work Bielser et al. [4, 5] extended the approach described in [6], using a progressive subdivision method (but no progressive cutting is performed). The subdivision is built incrementally from an undivided tetrahedron up to a complex subdivision. A state machine handles arbitrary progressive subdivisions and updates in an efficient way. Algorithms which handle cases where the direction of the cut tool is changing or trembling are also presented. Nienhuys [51] introduced novel cutting algorithms for deformable objects where deformations are based on physical forces using the finite element method (FEM). The FEM is a popular method for computing solutions to partial differential equations defined on irregularly shaped objects. Objects are subdivided into elements (e.g. triangles or tetrahedra) which are deformed in elementary ways. Physical laws, defined by the material, specify how neighboring elements interact. Applying the FEM to a mesh, leads to a complex system of equations which can be solved with numerical methods. Nienhuys presented three cutting methods: the first method which is also described in [52], simulates cuts without increasing mesh size (in contrast to a subdivision approach). However, this technique can produce degenerated tetrahedra. Therefore, algorithms like node snapping and mesh simplification (using a heuristic edge collapsing algorithm) are provided to avoid badly shaped tetrahedra. The second approach covers interactive cutting in triangulated surfaces based on Delaunay triangulation (see also [53]). The algorithm produces measurably smaller and better results than previous methods but cannot be used for tetrahedral meshes. The third algorithm presented, is a needle insertion technique for deformable objects. Additionally, the underlying mesh representation used in all algorithms is discussed in detail. Mor [49] also addressed the problem of cutting tissue within a physically-based surgical simulator. The actual cutting is performed by subdividing tetrahedra which are intersected by the cutting tool. Based on the five basic intersection cases introduced by Biesler et al. [7], a minimal set of new elements is generated (only four to nine elements for each cut element). The subdivisions were examined by hand to find the minimal set of new elements. A lookup table is used to determine how to rotate or flip the vertices to fit the default orientation. In order to allow for progressive cutting, the described subdivision schema was extended to a temporary subdivision technique for the currently cut element. In contrast to usual node snapping approaches for avoiding degeneracies, Mor introduced an algorithm where snapping is only done if the current subdivision is instable (i.e. degenerated tetrahedra are detected according to a certain metric). Subsequently, a list of all possible permutations of snapped vertices is created. These permutations consist of all possible combinations of moving one or more intersection points to their closest feature. Test subdivisions are performed until a stable subdivision is found. Ganovelli et al. [27, 26] presented a technique in order to enable cuts using a cut shape on multi-resolution representations where the multi-resolution data representation is updated on-the-fly. The actual subdivision case is determined by generating a code based on the edges being intersected. The corresponding tetrahedralization is stored in a lookup table. 7

15 2.2. Intersection Related Work Simplicial complex properties are always preserved due to the introduction of a consistent subdivision. In contrast to the shape partitioning algorithm introduced in this thesis, the technique of Ganovelli et al. supports partially split tetrahedra, thus being more exact, but has the drawback of a limitation to convex and planar shapes. A different cutting approach using a deformable plane which is generated by userdefined lines was introduced in [42]. Instead of subdividing tetrahedra, mesh nodes are displaced to fit the original set of points. Forest et al. [25] presented an algorithm to partially or completely remove tetrahedra using an ultrasound cautery. In addition, mesh representation, and updates which keep the mesh consistent after tetrahedra removal are discussed. Concerning subdivision, Ferrant et al. [46] provides ten subdivision cases based on intersection points per edge where one to all six tetrahedral edges are split (ignoring symmetrical identities). Multiple intersection points per edge or partially cut tetrahedra are not considered. The resulting subdivision contains tetrahedra, pyramids and prisms which must be subdivided further. Splitting prisms according to their diagonals, is outlined in [46]. Quadrilateral faces are split by the shortest diagonal. The splitting rule is mentioned as being consistent which is only guaranteed if exact arithmetic is used. In addition, the case where the two diagonals are of equal length cannot be handled. Tetrahedral subdivision and subsequent splitting of pyramids and prisms were presented in [20]. Quadrilateral faces are split by the diagonal which contains the smallest vertex index. Therefore, this subdivision schema is consistent and independent of floating point calculations. Our subdivision is based on this consistency criterion due to the simplicity and efficiency of this algorithm. Up to our knowledge, partitioning or cutting with arbitrary shapes represented by triangular meshes was not yet addressed. Although intersection point calculation and existing subdivision strategies can be used for this purpose, additional algorithms and data structures are required for preserving a consistent mesh. Additionally, none of these papers provides algorithms for identifying different regions after applying a sequence of partitioning or cutting operations. This is an important issue for visualizing partitioning results in real-time. 2.2 Intersection Intersection calculations are fundamental for the partitioning algorithms but basically consist of mathematical methods. Therefore, most techniques are well known and a fast implementation is the only difficult part. Additionally, most calculations rely on floating point arithmetic where roundoff errors may occur which have to be avoided or minimized. 8

16 2.3. Collision Detection Related Work Determination whether a point lies inside a convex polyhedron is straight-forward and achieved by testing if the point lies on the negative side of each face plane (see [23, p. 708 ]). Rewriting the point in barycentric coordinates relative to the convex polyhedron is another fast technique [23, p. 708 ]. In addition, line segment and plane intersections are implementations of ordinary mathematical equations, for a detailed description see Eberly [23, p. 481 et sqq. ]. The efficient and consistent intersection point calculation of triangular faces is a nontrivial task. Several publications present efficient approaches: most of them use techniques where projected intervals are tested for overlapping. State of the art, due to their efficiency, are the algorithms by Möller [48] and Held [37]. Möller starts by comparing the intersection of each triangle with the supporting plane of the other. If all vertices of one triangle lie on the same side of the plane, then the intersection is rejected. Otherwise, the triangles intersect the line of intersection of the two planes. These intersections form intervals on the line of intersection, and the triangles overlap iff these intervals overlap as well. The last part of the algorithm determines the intervals where the line of intersection lies inside the triangle. A derived method is introduced by Guige et al. [35] where the complete algorithm only relies on the sign of 4 4 determinants. Therefore, an orientation test, where predicates guarantee exact arithmetic, can be applied (described in Section 6.1). 2.3 Collision Detection Effective collision detection is an essential tool in order to overcome the problem of testing each tetrahedron against each partitioning shape face (resulting in O(n 2 ) asymptotic runtime). Although our objects are rigid and stationary, collision detection algorithms of moving or deformable objects are discussed which can be important for future work. Collision detection is a well researched topic and thus only a few techniques are mentioned. A general description of 3D collision detection can be found in [40]. Teschner et al. [62] provide a detailed survey for collision detection of deformable objects. Eberly [22, p. 487 et sqq. ] discusses basic collision detection and intersection calculations for stationary and moving objects. At the lowest level these techniques are divided in intersection-based methods and distance-based methods. The intersection-based method chooses, equates, and solves representations of two objects (e.g. equating the algebraic representation of a plane with the parametric representation of a line segment) whereas a distance-based method uses parametric representation of all objects, trying to minimize the distance function for all parameters. 9

17 2.4. Mesh Optimization Related Work Bounding-volume hierarchies have proven to be the most efficient data structures for collision detection [62]. Generally, a discussion of bounding-volume hierarchies is found in [67]. Several bounding volumes like spheres [39], axis-aligned bounding boxes (AABB) [63, 43], oriented bounding boxes (OBB) [32], discrete oriented polytopes (DOP) [65], and boxtrees [66] were explored. OBB and k-dops are the most adequate approaches for our requirements. OBB trees give good approximation of the object s boundary and k-dops approximate the convex hull arbitrarily by increasing k. AABB trees and octrees are special cases of k-dops. An octree is generated efficiently and the collision detection is fast enough for our requirements (i.e. less than 10 ms to detect 1000 collisions). Octrees can easily be extended to bucket trees, an octree enhancement for deformable objects proposed by Ganovelli et al. [28], if collision detection for deformable objects is required. Usually, a bounding-volume tree is built in a top-down fashion. Subsequently, a collision test between two objects is accomplished by traversing the bounding-volume trees top-down and testing pairs of nodes. If the overlapping nodes are leaves, an exact overlap test is performed. If only one node is a leaf, it is tested against each child of the internal node. Otherwise, if both nodes are internal nodes, the node with the smaller volume is tested against the children of the other node [63]. Spatial subdivision is a simple but efficient technique to accelerate collision detection. Algorithms based on spatial subdivision are independent of topology changes of objects. The difficulty using spatial techniques lies in the choice of the appropriate data structure. Zhang et al. [68] proposed a method based on uniform grids and Melax [47] used a binary space partitioning (BSP) approach. In [61], a hash-table is used for efficient collision detection of deformable tetrahedral meshes. Image-space techniques do not require any preprocessing and are commonly implemented using graphics hardware. Lombardo et al. [44] introduced an image-space collision detection approach in a medical system. Heidelberger et al. [36] computes a layered deep image of an object to approximate its volume. The approach can be applied to arbitrarily shaped deformable objects and also detects self intersections. Several methods mentioned in [62] are not applicable for interactive partitioning. In order to ensure consistency, all potentially overlapping objects must be determined. Stochastic algorithms are not exact (the error depends on the method) and only useful in real-time applications where exact collision detection is not required. Distance fields specify the minimum distance to closed surfaces for all points in the field. However, the generation of distance fields is not fast enough for interactive applications. 2.4 Mesh Optimization Splitting tetrahedra close to original vertices can produce degeneracies. In order to improve the quality of the mesh, optimization algorithms are applied which remove badly shaped elements by modification of the mesh geometry or topology. 10

18 2.4. Mesh Optimization Related Work An introduction of mesh optimization techniques can be found in [3]. Optimization techniques can be divided into mesh smoothing algorithms which adjust the vertex positions while the mesh connectivity is preserved whereas mesh simplification and refinement algorithms change the connectivity of the primitives to improve mesh quality. According to a survey by Owen [54], smoothing methods can generally be classified as follows: Averaging methods move the current vertex to the average position of adjacent vertices. The most common technique is Laplacian smoothing which is efficient but heuristic. An overview over a variety of the most common averaging methods is provided in [11]. Optimization-based methods are more expensive than averaging methods but better results are achieved. Vertices are repositioned based on a gradient of element quality to minimize a given distortion metric. Several optimization-based methods rely on optimal Delaunay triangulation or Voronoi tessellation (see [12, 21]). A combination of averaging and the more expensive optimization algorithms is recommended. As demonstrated in [11], the optimization-based smoother is only used if the mesh quality drops below a certain threshold. Physical-based methods move vertices based on physically attraction or repulsion forces (see [69, 58]). Most effective algorithms for improving the mesh quality are based on either refinement strategies or decimation strategies. Decimation strategies (simplification) remove primitives or edges from the mesh whereas refinement strategies add points to improve the mesh quality. Detailed descriptions of existing simplification and refinement methods can be found in several publications [30, 17, 45, 15]. A technique based on Delaunay refinement was proposed by Cignogni et al. [16]. Grosso et al. [34, 33] introduced a different approach: starting from a coarse triangulation covering the domain, a hierarchical representation of volume approximations is created by a sequence of adaptive mesh refinement steps. Clustering techniques can also be categorized as refinement strategies [18, 9]. All algorithms based on a refinement strategy share a common problem: the domain of the data set has to be convex or it has to be defined as a warping of a regular grid [16]. Decimation algorithms are usually based on edge collapsing techniques which are described in detail by Cignogni et al. [15, 14]: a general framework for mesh simplification is provided and various techniques to evaluate simplification errors are discussed. 11

19 2.5. Floating Point Calculations Related Work Staadt and Gross [60] introduced various cost functions to control the edge collapsing process. Additionally, a technique to avoid self intersections of the mesh boundary was presented. Cignogni et al. [16] use an error metric to control the domain error. Based on [16], the strategy was enhanced in [14], providing efficient error estimators for the domain and the field error. Ganovelli and O Sullivan [29] presented a method which is also based on an edge collapsing strategy to improve the primitive quality on-the-fly during scalpel cutting. An approach mainly focusing on efficiency, was presented by Chopra and Meyer [13]. The algorithm is based on iteratively collapsing tetrahedra whereas the mesh boundary is not simplified. 2.5 Floating Point Calculations Geometrical tests and computations may require exact results. For instance, orientation tests determine the position of a point relative to a plane or line segment based on the sign of a determinant. Several former algorithms providing techniques for exact arithmetic were based on integers or fixed point numbers (using integer hardware units). Modern processors and graphics cards are highly optimized for floating point arithmetic where the performance is faster compared to fixed point arithmetic [57]. Floating point computations use the IEEE floating point standard which provides 16 decimal bits accuracy. Due to the finite representation of the standard, roundoff errors can occur. A complete survey of the floating point theory, including detailed description of the IEEE standard and the problem of roundoff errors, can be found in [31]. Additionally, an overview of up-to-date high precision floating point arithmetic libraries and techniques in scientific computation is given by Bailey et al. [2]. Methods which achieve exact floating point calculations are classified in multiple-digit and multiple-term algorithms. In multiple-digit formats, numbers are stored as a sequence of digits and a single exponent. In the multiple-term format, a number is expressed as a sum of ordinary floating point numbers. Usually, multiple-term algorithms are more efficient. Priest [55] was one of the first introducing efficient techniques for arbitrary precision floating point arithmetic. The algorithms are based on ordinary floating point operations and are designed to run on a wide range of architectures. Shewchuk [56, 57] enhanced the methods of Priest, providing a simplified and more efficient algorithm for exact and adaptive floating point calculations. Additionally, geometric predicates were introduced in order to demonstrate that the technique is well suited for geometric algorithms. Although robust floating point computations are well researched, different techniques may be used dependent on the area of application. 12

20 Chapter 3 Mesh Representation Efficient data structures for representing 2-dimensional triangular meshes and 3-dimensional tetrahedral meshes are required by the partitioning algorithms. Therefore, a generic data structure is used, able to represent n-dimensional meshes where modifications can be performed efficiently. Storage and visualization of different partitions is a non-trivial task. A hierarchical labeling schema is presented where a single mesh can store consecutive partitioning operations. A boundary extraction algorithm is described which is able to visualize the hierarchical mesh data structure. Basic bit vector arithmetic allows for fast rendering of different partitions. The hierarchical approach has several features like the ability to group partitions, toggling between boundaries interactively, or combining different surfaces. 3.1 Formal Mesh Model The mesh model relies on so-called simplices and further on the definition of simplicial complexes. Simplices are also used to describe triangulations in the field of algebraic topology. The topology of a mesh is given by a set of n-simplices where n is called the dimension of the simplex. A simplex S n is defined by the convex hull of affinely independent vertices p 1,..., p n+1 R 3 : conv{p 1,..., p n+1 }, where n is the dimension of S n. Less formally, a simplex is the generalization of a tetrahedral region of space to n dimensions and represents the simplest possible polytope in any given space. A one-dimensional simplex is called edge, a 2-simplex is a triangle, and a 3-simplex is a tetrahedron. 13

21 3.1. Formal Mesh Model Mesh Representation The boundary of an n-simplex S n has n + 1 faces. A face f j, j {1,..., n + 1} of a simplex S n = conv{p 1,..., p n+1 } is defined as f j = conv{p 1,..., p j 1, p j+1,... p n+1 }. An explicit definition of the mesh connectivity gives the possibility to specify the correctness of the data structure: Definition of two properly connected simplices: Two n-dimensional simplices P n and Q n with corresponding vertices p 1... p n+1 R 3 and q 1... q n+1 R 3 are properly connected iff conv{p 1,..., p n+1 } conv{q 1,..., q n+1 } = conv C, where conv C is a face of P n and Q n. Examples of incorrectly and properly joined simplices are shown in Figure 3.1. Properly connected simplices are characterized by their set of vertices. It is sufficient to consider these discrete sets of vertices and disregard the continuity of convex sets (the type and value of the vertices itself are not relevant). Therefore, it will be assumed that points are stored in a vertex buffer V and the type of the vertices is unspecified. (a) Two properly connected simplices. (b) Incorrectly connected simplices. Figure 3.1: Examples of incorrectly and properly connected simplices. An n-simplex has an orientation based on the permutation of its vertices [51]. For instance, a 2-simplex is oriented based on the normal of the supporting plane. The orientation relies on the order of the vertices (e.g. if two vertices of a 2-simplex are swapped, the normal vector is flipped and the orientation changes). Formally, the orientation of an n-simplex is defined as: Orientation of a simplex: Let p 1,..., p n+1 be a sequence of n + 1 vertices of a simplex S n. A permutation π(p 1,..., p n+1 ) of the vertices may be decomposed into a number of swaps. If the number of swaps is even, then π is an even permutation, otherwise it is an odd permutation and thus S n is called positive or negative oriented, respectively. 14

22 3.2. Entities Mesh Representation Based on a set of simplices which are properly connected, a simplicial complex (cf. [24]) is introduced which defines the overall topology of a mesh: Definition of a simplicial complex: A simplicial complex K of R n is a collection of simplices in R n such that Every face of a simplex of K is in K. The intersection of any two simplices of K is a face of each of them. Each simplex K has the same, valid orientation. Thus, a mesh is defined by a simplicial complex forming the mesh topology and a set of vertices representing the geometry of the mesh. More precisely, an n-dimensional mesh is a tuple M n = (K, V) where K is a simplicial complex of R n and V is a vertex buffer which stores the vertices of M n. In order to provide connections between V and K, two additional mapping functions are used: VSC : V K sub K, where each vertex p V is mapped to a subset K sub of K containing all simplices wherein p is part of the convex hull of each simplex. SSC : S K sub K, where each simplex s is mapped to a subset K sub of K, containing all adjacent simplices of s. 3.2 Entities Since each performed partitioning divides the underlying volumetric mesh into two disjoint parts (by definition), a data structure is introduced which allows for efficient storage and visualization of partitions. Assuming that a tetrahedral mesh M 3 covers a certain volume Ω 1 R 3, a partitioning operator γ can be defined which divides a volume Ω i into two disjoint parts (i.e. Ω 2i, Ω 2i+1 ). If applying a sequence of partitioning operations Γ = γ 0,..., γ n, this sequence can be represented by a binary tree with depth n. A sub-volume Ω i is denoted by a node in the binary tree (see Figure 3.2). By definition, the first operation γ 0 generates the tetrahedral mesh itself which represents the volume Ω 1 (the root node of the binary tree). If γ 1 is applied to Ω 1, two additional nodes (Ω 2, Ω 3 ) are created, splitting the volume into two disjoint parts (shown in Figure 3.2). If further partitioning operations are performed, an additional tree level is created by splitting each leaf node Ω i into two child nodes Ω 2i and Ω 2i+1. The path of the binary tree from the root node to a given leaf node is encoded into its index and represents the complete sequence Γ (so-called location code). For efficiency, the index is stored in binary representation in form of a bit vector where each bit corresponds to either a left or right 15

23 3.2. Entities Mesh Representation initial tetrahedral mesh 1 Ω 1 2 new subvolumes 10 Ω 2 11 Ω 3 γ 1 4 new subvolumes Ω 4 Ω 5 Ω 6 Ω 7 γ 2 Figure 3.2: Example of a binary tree storing γ, a sequence of partitioning operations. Each leaf node Ω i is divided into two child nodes by partition operations γ 1 and γ 2. link in the tree. Additionally, each tetrahedron of the mesh contains the index of the corresponding leaf node, storing its relation to different partitions. A node in the binary tree with index i at depth d = ln(i), belonging to the partitions γ 0,..., γ d, is called entity. For efficient rendering, each leaf node contains the indices of its associated tetrahedra. An example of an object which contains different partitions is shown in Figure 3.3: the initial model consists of one entity representing the tetrahedral mesh itself. After the first partitioning operation, two leaf nodes are created, splitting the domain into two pieces. The indices of the newly created entities are 2 and 3 (10 and 11 in binary representation). If applying a second partitioning operation, the algorithm is repeated which results in 7 entities with 4 leaf node entities. Ω 1 e=1 Ω 2 e=10 Ω 4 e=100 Ω 5 e=101 (a) Initial mesh Ω 3 e=11 (b) A plane partitioning (denoted by the red line) divides the mesh into two entities. Ω 7 e=111 Ω 6 e=110 (c) Additionally, a shape partitioning is applied, creating four entities. Figure 3.3: Example of a mesh whereon a sequence of partitioning operations is applied to. Each partitioning operation creates further entities. 16

24 3.3. Boundary Extraction Mesh Representation 3.3 Boundary Extraction A mesh M 3, covering the volume Ω 1, is defined by a set of tetrahedra. As mentioned above, a partitioning operation splits M 3 into further entities and creates additional leaf nodes. Each tetrahedron of M 3 contains the index of the corresponding leaf node in the tree. This index is represented by a bit vector e called entity bit vector. The entity bit vector e corresponds to the according leaf node index and is defined as e = (e 0,..., e n ), where n denotes the depth of the binary tree. For visualization, boundaries between entities are target for rendering, because they represent the actual information being shown. For each entity Ω k of M 3, an interface Ω k denoting its boundary can be extracted. The interface is described by a surface mesh M 2 containing a set of properly connected triangles which are the faces of the tetrahedral mesh M 3. An operator is introduced which is required for the boundary extraction: let len(a) be the length of a given bit vector a and len(b) the length of a bit vector b, where len(a) len(b). A trim-to-equal operator can be defined as tr(a, b) = b len(b) len(a), removing the most-right bits of b. Further, is defined as a bit-wise XOR operation of two equally sized bit vectors. The ˆ0 bit vector represents the bit vector which only contains zero bits. Assuming that an entity, specified by its index r, should be extracted: the binary tree is traversed by comparing the trimmed node index tr(r, i) (where i is the binary representation of the current index). If the compared bit masks are equal and r is an intermediate node, all its child leaf nodes are target for extraction. For each tetrahedron, stored in a target leaf, the face diff vectors to the neighboring tetrahedra are calculated in order to extract the correct boundary of intermediate entities: A face diff vector d j is defined as d j = tr(r, e j ) r, j : 1 j 4, where each e j specifies the entity bit vector of an adjacent tetrahedron. The face diff vector denotes the bit difference to adjacent simplices. If d j ˆ0, the corresponding face must be extracted as triangle which will be part of the interface Ω i. An example is shown in Figure 3.4, including a triangular mesh which contains the result after two different partitioning operations γ 0 and γ 1. The currently inspected triangle is colored yellow (see Figure 3.4(a)). Assuming that the entity, specified by r = 111, should be visualized: if applying the previous bit operations, the face diff vectors of adjacent triangles d 1 = 001, d 2 = 000, and d 3 = 101 are calculated. The example shows that two faces are extracted which are part of the specified entity. Since only bit operations are required for extracting interfaces, the algorithm works efficiently and fast. This allows integration into a real-time environment, enabling interactively toggling between several partitions. 17

25 3.3. Boundary Extraction Mesh Representation d 1=001 d = d = Ω Ω 2 Ω 3 γ γ 2 Ω 4 Ω 5 Ω 6 Ω 7 (a) Entity 111 should be visualized. Therefore, face diff vectors d 1, d 2, and d 3 are used to extract the boundary. target for rendering (b) Binary tree representation of the mesh shown in Figure (a). Figure 3.4: Example of a mesh showing the boundary extraction technique. The triangular mesh is outlined in Figure (a) and the corresponding binary tree is shown in Figure (b). Two partitioning operations γ 0 and γ 1 are performed, creating seven entities. Entity 111 is target for rendering and d 1, d 2, and d 3 denote the face diff vectors. By using a binary tree as representation of entities in the model, some restrictions must be taken into account. Since links of the tree only split current entities of the model into two regions, no high level information can be added. Let us assume that two specific entities should form a separate entity due to high level knowledge (e.g. a tumor which was divided into two pieces), and the boundary between these two entities should not be extracted. The current model is not able to handle such situations because this would contradict the concept of a binary tree. Therefore, a data structure called clustered entity is introduced: it permits the creation of meta entities which are not explicitly stored in the tree. These meta entities are stored in the mesh data structure and group single entities of the binary tree. In order to extract the joint boundary of clustered entities, the simplices of these cluster are traversed. Each adjacent face which is not part of the cluster is extracted, being a target for rendering. Boundary Extraction Algorithm extract( Binary tree T, entity id r ) //let F be a triangular mesh storing a set of face for ( leaf nodes l i T being child of r ) for ( simplex s j l i ) for ( simplex b k s j ) 18

26 3.4. Rendering Mesh Representation if ( r is intermediate node ) if ( r is parent of l i and b k r ) //add f jk to F F.add( f jk ) else //r is leaf node if ( b k r ) //add f jk to F F.add( f jk ) endif endif endif endfor endfor endfor return F end 3.4 Rendering By using the extraction algorithm explained above, a triangular mesh is generated for each entity with shared vertices (using the vertex buffer V from the parent tetrahedral mesh). This mesh can be rendered using standard surface rendering techniques. In common meshes a lot of attributes are associated with a single vertex position (e.g. normals (n x, n y, n z ), texture coordinates (u, v), or color (r, g, b, a)) which specify the local parameters for rendering. However, this leads to problems if vertices are shared between adjacent faces which are colored differently. Therefore, the corner concept is used [38]: a corner acts as a wrapper for vertices and has additional local parameters associated with exactly one primitive. This has the benefit of allocating multiple corners, each indexing a similar vertex but storing additional attributes (e.g. different color and normal vector information for each vertex). 19