Convex decomposition of Polyhedra for AVAL

Transcription

1 Convex decomposition of Polyhedra for AVAL Henrik Nyberg February 16, 2010 Master s Thesis in Computing Science, 2*10 credits Supervisor at CS-UmU: Jerry Eriksson Supervisor at BAE Systems: Martin Sjöberg Examiner: Per Lindström Umeå University Department of Computing Science SE UMEÅ SWEDEN

2

3 Abstract In order to perform vulnerability and lethality simulations of vehicles it is necessary to describe their geometry in terms suitable for simulation. AVAL is a piece of software used for such simulations, and a main requirement for input geometry is convexity. Manual decomposition is highly time consuming, and in this thesis, a complete algorithm to perform an automatic convex decomposition is presented and described in more detail than previously done. A proof of concept implementation of the algorithm has been made and tested, and example decompositions are shown. The algorithm is based strongly on earlier work in the field by Bajaj and Dey, but contains solutions to previously undescribed subproblems. As a result the feasibility of using automatic convex decomposition of vehicle-type geometry as a pre-processing aid is shown.

4 ii

5 Contents 1 Introduction AVAL Problem Description Goals Methods Convex Decomposition Topological Preliminaries Neighborhood, interior, exterior, closure Solid Convexity Homeomorphism Manifolds Representing solids Boundary representations Star-edge data structure Convex decomposition algorithms Algorithm description Preliminaries Edge-plane intersection Special notches Overview Removing special notches Type I Type II Type III Splitting a solid polyhedron Classifying polyhedral features Computing Cr and Cr iii

6 iv CONTENTS Separating S by a cut Covering the cut Heuristics for choosing split plane Trivial heuristic Scoring heuristic Handling inconsistent geometries and errors Improved radial sorting Error handling Results Work-flow Convex decomposition implementation Limitations and future improvement Polygons with holes Robust sorting of intersection points Algorithmic limitations Parallelism User interface Automatic filtering Example decompositions Conclusions 41 References 43

7 List of Figures 2.1 Current work-flow employed at BAE Systems Hägglunds Intended new work-flow A rectangle defined by the intersection of four half-spaces. Each line separates the space into two half-spaces, one considered inside and the other outside. In this case, the intersection of all inside half-spaces form the shape of a rectangle A concave and a convex geometry Example non-manifold polyhedra Simple boundary representation primitives Star-edge representation details UML diagram for Star-edge representation Sub-notches produced by a split operation Special non-manifold example Before and after removal of Type II notch Cross-sections of a cut Geometric reasoning for vertex classification Finding which edges lie on the cut plane for a specific face. The desired edges are the already existing edges between (v 1, v 2 ), (v 2, v 3 ), (v 6, v 7 ) and (v 9, v 10 ), as well as generating new edges between (v 3, v 4 ) and (v 7, v 8 ) New elements created during a cut Insertion of vertex and edge during a cut Example decomposition Example decomposition Example decomposition Example decomposition Example decomposition Example decomposition Example decomposition v

8 vi LIST OF FIGURES 5.8 Example decomposition Example decomposition Example decomposition Example decomposition Example decomposition

9 Chapter 1 Introduction This thesis has been produced in cooperation with BAE Systems Hägglunds, a defense company developing and producing combat vehicles and all-terrain tracked vehicles for both military and civilian use. An important aspect of vehicles that will possibly be used in hostile environments is their level of protection. During the developmenet phase of a vehicle, it is important to make sure that the vehicle s level of protection lives up to the customers demands. Live firing testing on actual vehicles is not feasible to carry out on a large scale, due to the high cost of the vehicles involved. For this reason, simulations are often used to approximately determine a vehicle s vulnerabilities. 1.1 AVAL AVAL, short for Assessment of Vulnerability and Lethality, is a piece of software used by BAE Systems Hägglunds for the purpose outlined above. Development of AVAL has been continuous since 1994, when it was initially created by the Swedish Defense Materiel Administration, FMV. It has since been developed in cooperation with the Swedish Defense Research Agency, FOI 1, BAE Systems Bofors, and Dynamec Research AB [1]. The simulation model is based on Monte Carlo simulations using target geometry, projectile geometry, material properties, statistics from live firing tests, together with a graph of the target vehicle s functional dependencies, to produce a detailed view of a vehicle s vulnerability to any projectile at any angle. The functional dependency graph allows the software to accurately determine which systems of the vehicle that might get damaged by an impact. This software is used at BAE Systems Hägglunds for simulating the protection and vulnerability of their vehicles. 1 Known as FOA prior to

10 2 Chapter 1. Introduction

11 Chapter 2 Problem Description Describing a vehicle for use in an AVAL simulation is currently a very tedious and time consuming task, often taking months for a single person to perform. Vehicle geometry created for production purposes is excessively detailed and defined by implicit parametric surfaces, while AVAL mainly supports solid convex polyhedral geometry. For this reason, it is necessary to filter the source geometry to get rid of excessive detail (such as removing small drill holes and screws) and then to remodel the vehicle into polyhedral objects. Most CAD software allows for polyhedral geometry to be generated from the parametric definitions, however, the output is not guaranteed to be convex this property is described in more detail in Section 3.1 as AVAL needs, and very rarely is. In the current workflow of making production geomety ready for use in AVAL, the geometry is remodelled manually using AutoCAD, which is both slow and prone to errors and artifacts in the final result. An estimation from the main user of AVAL at BAE Systems Hägglunds, who has worked manually according to the previously described manner, is that a vehicle similar to a CV90 (an infantry fighting vehicle produced within the company) can take in excess of fourteen weeks by a skilled user to rework into being suitable for usage in AVAL. For algorithms performed on polyhedral objects, convexity of the input is a highly desired property, and even required by many. A great number of simplifying assumptions can be made when the input is known to be convex, resulting in a significantly faster, and easier to implement algorithm. For instance, testing for intersection between two convex polygons can be done in logarithmic time, while solving the same problem for concave polygons has a linear lower bound. This was demonstrated by Chazelle in [8], and serves as a good example for the efficiency advantages given by convex geometry. Another example is testing whether a solid geometry contains a point. A convex geometry can be defined by the intersection of a set of closed half-spaces [10], making a containment test as simple as testing whether the point in question is within all the half-spaces defining the geometry. An algorithm to perform the same test for concave geometries is more involved. AVAL s requirement of input geometry to be convex thus stems from the fact that it lets them use much faster and simpler algorithms to perform the vulnerability simulation. 3

12 4 Chapter 2. Problem Description 2.1 Goals Generally speaking, the goal is to reduce the time necessary to move from a vehicle s production geometry to a format suitable for vulnerability simulation. To obtain this goal, the currently used work-flow should be altered. In Figure 2.1 the current work-flow is outlined. Vehicle production geometry is stored in a database called PDA, and is from there exported into either CATIA or I-deas for manual remodelling into polygonal geometry with less details. After that step is performed, the geometry is moved into AutoCAD where it is again remodelled into convex pieces. When that step is done, material parameters are assigned to the pieces by using an AVAL plug-in for AutoCAD. Simplify Make Parameterize convex I-deas PDA AutoCAD AutoCAD Simulate Catia Figure 2.1: Current work-flow employed at BAE Systems Hägglunds. The intended goal is being able to use a somewhat altered work-flow with more automation built into it. On the surface it looks very similar to the manual workflow, as it has to perform the same basic steps. Vehicle geometry is meant to be taken from PDA into CATIA, where a user removes excessive detail both manually and with assistance of a script. Things like small holes and rounded edges can easily be removed by automated means. The geometry is then supposed to be exported from CATIA in a polygonal format, and decomposed into convex pieces by the algorithm described herein. As with the previous work-flow, material parameters are then assigned to the generated pieces within AutoCAD. Figure 2.2 illustrates the expected new work-flow. PDA Simplify Catia + Script Make convex Parameterize Decomp. AutoCAD Simulate Figure 2.2: Intended new work-flow. The major piece of the altered work-flow is the automated convex decomposition, the implementation of which will be the main goal of this thesis. Taken together, these measures are expected to reduce the time of moving from a production geometry to vulnerability simulation by more than three times. That is, a reduction from approximately fourteen weeks for a CV90-type vehicle, to about four. The reduction is mainly

13 2.2. Methods 5 expected in the decomposition step (estimated from ten weeks to one), and some gain in the simplification step by the scripting functionality. 2.2 Methods A literary study was carried out prior to the implementation, where a few key papers containing the best known algorithmic solutions to the decomposition problem. C++ was chosen as the implementation language, as the problem requires heavy numerical computation and somewhat complex data structures.

14 6 Chapter 2. Problem Description

15 Chapter 3 Convex Decomposition This chapter contains a brief study of the basic methods used to algorithmically perform a convex decomposition. Some useful topological concepts are covered first, followed by methods of representing real-world objects in a computer, and finally the current state of affairs when it comes to actual decomposition algorithms. Actual algorithm details will not be covered here, but the algorithm chosen for implementation for this thesis will be expounded upon in a later chapter. 3.1 Topological Preliminaries In order to give the concepts that will later be used in this thesis a more theoretical basis, some definitions regarding topology and solids will be given here. The definitions will in general be constrained to their usage in this thesis, and will thereby naturally be limited to R 3 to keep things more intuitive. However, they can be generalized to any topological space Neighborhood, interior, exterior, closure A neighbourhood of a point p in an open set of points containing p. A point p S is an interior point of S if and only if there is an open ball with radius ɛ centered on p that is also contained in S. The set of all such interior points is called the interior of S, and is denoted int(s). Similarly, the exterior, ext(s), is defined as the set of all points that has an open ball with a radius ɛ that does not intersect S. The points that are neither in int(s) nor ext(s) are the boundary of S. This can also be defined as all points in S for which all neighborhoods intersect both S and S. The union of the boundary and the interior is called the closure of S, cl(s). A convex polytope P is a bounded set of points defined by the intersection of a finite number of half-spaces. For this thesis all polytopes are considered regular, meaning that they contain no points with no neighborhood interesecting Int(P ). Likewise, the set operations are considered regularized, meaning that they output only regular polytopes. Figure 3.1 gives a two-dimensional example of how a set of points can be defined by a set of half-spaces. In three dimensions the half spaces are naturally represented by planes instead of lines. The regularization is necessary to avoid cases of infinitesimally thin features from being allowed by the definition. 7

16 8 Chapter 3. Convex Decomposition L 3 L 4 L 1 L 2 Figure 3.1: A rectangle defined by the intersection of four half-spaces. Each line separates the space into two half-spaces, one considered inside and the other outside. In this case, the intersection of all inside half-spaces form the shape of a rectangle Solid Now, with the above definitions in place, we can finally define a solid as a combination of convex polytopes under the regular set operations, union, intersection and complement. The above definitions will also be used later in the decomposition algorithm description. By this definition, a solid is an object which surface can be defined by flat pieces, generally referred to as faces in common parlance Convexity A solid S is convex if and only if, for all points a, b S, the set of points along a straight line, γa+(1 γ)b, with 0 γ 1, is a subset of S. This is more intuitively illustrated in Figure 3.2. It is evident that a solid can only be non-convex if there exists an edge with an inner dihedral angle > π between incident faces. Such edges will be called notches or reflex edges, interchangeably Homeomorphism A space S is homeomorphic to S if there exists a continuous bijection with a continuous inverse between them. That means that it is possible to map one to the other in a continuous invertible manner Manifolds An important matter when dealing with geometrical objects is the topological concept of a manifold space. A space is considered to be n-manifold if on a small enough scale, it is homeomorphic to an Euclidean space of the same dimension [9]. For example the surface of a sphere is 2-manifold, since it has a ɛ-neighborhood homeomorphic to R 2. The same property holds for the boundary of all convex solids, as they are homeomorphic to a sphere. For instance, a solid that is manifold can not have incidences where two or more convex cells intersect only at a shared edge, or at a shared vertex, since the shared

17 3.2. Representing solids 9 a a b R b (a) (b) Figure 3.2: The geometry in (a) is convex, as any conceivable line created from points within it is also contained within. Conversely, the geometry in (b) is concave as it is possible to find a line between two points that itself is not wholly contained. Note that this is caused by the dihedral angle at R being > π. boundary points would not have a neighbourhood homeomorphic to R 2. example solids are shown in Figure 3.3. Two such R 1 R 2 Figure 3.3: Example non-manifold polyhedra. They are non-manifold at point R 1 and along edge R 2 respectively. The manifold property turns out to be of importance when choosing a suitable data structure for representing a solid during the decomposition process, as many common data structures are limited to representing 2-manifolds. 3.2 Representing solids Before any operation can be implemented over a solid we need a way to represent it that allows us to efficiently traverse its topological structure, and which permits all classes of objects that are of interest for the intended application. In [18], Requicha describes three distinct types of solid representations: 1. Spatial occupancy enumerations, 2. Constructive Solid Geometry, and

18 10 Chapter 3. Convex Decomposition 3. Boundary representations. The first refers to representations defining a solid by listing which spatial cells are occupied by the solid. Cubes are commonly used as the volume elements in these representations, but other primitives are also possible. For example, an octtree representation can describe a solid by decomposing space into progressively smaller cubes. Constructive Solid Geometry uses a set-theoretic combination (unions, intersections, subtraction, difference) of geometric primitives such as spheres, cubes, etc. to represent a geometry. These first two representation methods will not be discussed further, as they are not directly applicable to the problem discussed in this paper. The input geometry that will be used for the decomposition process will be based on the third kind of representations, a boundary representation Boundary representations Boundary representations are the most commonly ones used in graphics and CAD applications, as they are very flexible and allow for efficient rendering. A three dimensional B-rep consists of the likely familiar components vertices, edges and faces. We shall limit ourselves to representing solids of our definition, meaning that edges are straight and faces are flat and connected. Figure 3.4 illustrates how a tetrahedron is represented with these components. A formal definition of them are available in [5]. v 1 e 1 F1 e 3 v 4 v 2 e 2 Figure 3.4: The elements defining a three dimensional solid in a boundary representation. The elements of face F 1 are named: edges e 1,e 2,e 3, and vertices v 1,v 2,v 3. For clarity, other edges and faces have been left unmarked. However, algorithms need to be able to traverse the solid s topological structure to carry out their operations, requiring a representation to also include adjacency information describing how the parts are connected. That is, which faces neighbour each other, which edges are connected to a specific vertex, and so on. This is where the various boundary representations diverge. For instance, a simple boundary representation might include the topological relations face-to-edge, edge-to-edge and edge-to-face, as shown in Table 3.1, allowing for constant time neighbour face lookup. Many common data structures such as the Winged-edge data structure[4], Halfedge data structure[17], the Doubly-Connected edge list[16] and the Quad-edge data structure[11] are unsuitable for the decomposition algorithm implemented, since they v 3

19 3.2. Representing solids 11 Face-to-edge: Edge-to-edge: Edge-to-Face f 1 : (e 1, e 2, e 3 ) e 1 : (e 2, e 3, e 4, e 5 ) e 1 : (f 1,f 3 ) f 2 : (e 3, e 6, e 4 ) e 2 : (e 1, e 3, e 5, e 6 ) e 2 : (f 1,f 4 ) f 3 : (e 1, e 4, e 5 ) e 3 : (e 1, e 2, e 4, e 6 ) e 3 : (f 1,f 2 ) f 4 : (e 2, e 5, e 6 ) e 4 : (e 1, e 3, e 5, e 6 ) e 4 : (f 2,f 3 ) e 5 : (e 1, e 2, e 4, e 6 ) e 5 : (f 3,f 4 ) e 6 : (e 2, e 3, e 4, e 5 ) e 6 : (f 2,f 4 ) Table 3.1: Example adjacency information for a tetrahedron in a simple B-rep. It shows which edges delimit a face, which edges are reachable from other edges, and which faces are adjacent to each edge. are limited to representing 2-manifolds, and thus cannot represent certain kinds of nonmanifold solids that might occur during the algorithm s operations, even if the input was originally manifold. The representations mentioned above are based on edge adjacencies, and hold pointers to incident vertices, edges and faces in various configurations. For instance, the Half-edge structure splits edges into half-edges, each one belonging to one of the two faces incident on the edge 1, and containing a pointer to its twin half-edge on the opposite side of the edge, as well as a previous and/or a next pointer to neighboring half-edges in the face loop. Half-edges need not store both initial and terminal vertices of the represented edge, as one can be derived from the other by looking up the opposite half-edge s vertex. Various data structures for non-manifold solids have been proposed, early ones being the Radial-edge data structure by Weiler [19] and Karasick s Star-edge data structure [13]. More recently the Partial entity structure [14] was presented by Lee et al. All these structures are capable of representing the class of non-manifold solids of interest for this thesis. The Star-edge structure was chosen for the implementation on grounds that it was recommended by the decomposition algorithm authors, and because it can represent all geometry that is of interest for the application as well as special cases arising in the decomposition process itself. The next section describes this data structure in more detail Star-edge data structure Beside vertices, faces and edges, the Star-edge representation adds directed edges and edge cycles. Edge cycles are the loops of edges that define a face, and they are defined by linked directed edges pointing from one vertex to the other. The cycles allow for easy traversal around the boundaries of a face. Figure 3.6 shows the relationships that are maintained between these entities. Edges An edge is bounded by two vertices, which are arbitrarily labelled v 1 and v 2. Additionally, for each face incident upon an edge, the edge keeps a directed edge record, representing the direction of the face with relation to the edge when traversing the edge from v 1 to v 2, as seen from outside the solid. Figure 3.5a illustrates the directed edges incident on an edge. If there are more than two incident directed edges, such as there 1 In a manifold solid, an edge has exactly two incident faces.

20 12 Chapter 3. Convex Decomposition would be for edge R 2 in Figure 3.3, they are sorted radially and grouped in pairs of two, representing each incident cell complex. Directed edges A directed edge contains four records: a pointer to the associated edge, a pointer to the containing edge cycle, an orientation which can be either left or right, as well as a pointer to the next directed edge within the cycle. From these, we can define a few further properties. If a directed edge is right oriented, we say that v 1 is its initial vertex and v 2 its terminal vertex. Conversely, if the directed edge is left oriented, the definition is reversed. The unit vector pointing from the directed edge s initial vertex to its terminal vertex, is called the tangent vector. Finally, the unit vector pointing from the edge towards the interior of the face is called the face vector, and is computed as the cross product between the face normal vector and the tangent vector. v 2 next( e 1 ) e1 f 1 e 1 f 2 e1 c 1 c 2 next( e 1 ) v 1 (a) (b) Figure 3.5: (a) Edge e 1 is associated with directed edges e 1 and e 1, which determine the traversal order between v 1 and v 2 along e 1. The successor of e 1 is the next directed edge in the counter-clockwise ordering of directed edges around its terminal vertex, v 2. Likewise, the successor of e 1 is determined by the counter-clockwise radial ordering of directed edges around v 1. (b) Face with two edge cycles. The outer boundary is defined by c 1, while c 2 defines an inner hole. Vertices Each vertex contains a point specifying its position in R 3. Also, for each face incident on a vertex, records are kept for each directed edge incident on the vertex, ordered radially around the vertex, counter-clockwise as seen from the solid s outside. Edge cycles With the radial ordering of directed edges around each vertex, edge cycles can be inductively defined. For a directed edge e 1 on a face f, the successor is defined as the next directed edge e 2 in the counter-clockwise ordering of f s directed edges around the terminal vertex of e 1. An edge cycle only stores a pointer to an arbitrarily chosen directed edge in the induced cycle. An edge cycle might also consist of only an isolated vertex.

21 3.3. Convex decomposition algorithms 13 Faces A face consists of a set of edge cycles, that define its boundary, as well as a plane equation. An edge cycle either defines the outer boundary, or an inner hole. Figure 3.5b shows a face with two edge cycles. Shell * * * Edge 1 2..* * DEdge orientation v 1, v 2 DEdgesOnAdjFace * Vertex pos: Point AdjFaces 1 Face plane: Plane 1 1..* EdgeCycle next Figure 3.6: Simplified UML class diagram of the Star-edge representation. 3.3 Convex decomposition algorithms The problem of decomposing concave structures into convex pieces is not limited to three dimensional objects. Various planar decompositions are well studied and understood, such as triangulating different classes of polygons into non-overlapping triangles, and optimal algorithms have been found. However, the move from the two-dimensional case to three dimensions significantly increases the complexity of the problem, and previous algorithms are not directly generalizable to three dimensions. Chazelle, et al. observes in [7] that the theoretical work which has been done in the area has not seen much practical use, pointing at the implementation challenges of even the most naive implementations as the possible culprit. Before Chazelle published his doctoral thesis [8], little information was available regarding three dimensional convex decompositions. The method introduced by Chazelle is based on successive cutting of notches to resolve their reflex angles. He proves that the worst case tight bound in a naive implementation can result in up to O(2 N ) pieces, where N is the number of reflex edges, or notches, present in the geometry. However, this exponential increase is unlikely in most practical cases, but it is still a significant weakness that needed addressing. The undesirable exponential increase arises from the possibility that when resolving one notch, another might be intersected, resulting in two subnotches, as shown in Figure 3.7. At worst, each cut intersects every other notch, leading directly to the exponential increase. Thankfully, avoiding the worst case turns out to be easy. If a notch R is intersected, creating subnotches s 1 and s 2, they should both be resolved by the same plane in the next step of the algorithm. With that small change, the upper bound of the number of resulting pieces instead becomes O(N 2 ). In [6], Chazelle, describes a decomposition algorithm based on the notch-cutting paradigm, with a O(nN 3 ) runtime, requiring O(nN 2 ) space, where n is the total number of edges. However, his algorithm is limited to manifold solids. In [3],

22 14 Chapter 3. Convex Decomposition s 1 s 2 R 1 R 2 Figure 3.7: Cutting through notch R 1, as illustrated by the dashed lines, splits the solid into two polyhedra, each containing a subnotch, s 1 or s 2, of R 2. When the algorithm proceeds, these should be resolved by the same plane. Bajaj and Dey improve upon Chazelle s algorithm by presenting an algorithm with runtime O(nN 2 + N 7/2 ) and a space requirement of O(nN + N 5/2 ), that also handles certain classes of non-manifold geometry. Unfortunately, a recurring problem for algorithms such as these is numerical inaccuracies arising from finite precision arithmetic. Using geometric reasoning concepts from [13], Bajaj and Dey devised a modified algorithm to increase numerical robustness, but it comes at a cost in time complexity, which is increased to O(nN 2 +nn log n+n 4 ), but keeps the same space requirements. The results in this paper are based on a slightly limited and modified implementation of Bajaj and Dey s algorithm with increased numerical robustness. Their algorithm was chosen since it appears to be the best available, and because it attempts to address the robustness issues that will undoubtedly arise. A more detailed description of my implementation is available in Chapter 4. Other developments in convex decomposition is an approximate convex decomposition algorithm by Lien and Amato [15], that aims to decompose a solid into a much smaller number of nearly convex pieces. Their algorithm identifies the most concave features and deals with them first, until the total concavity is reduced to an acceptable level. However, in this paper we need an exact convex decomposition. Beside the algorithms already presented no other advances of any significance have been found in this study, and neither have any extant implementations been found.

23 Chapter 4 Algorithm description In this chapter the algorithm as implemented will be described. As previously mentioned, the implemented algorithm is strongly based on the one presented by Bajaj and Dey in [3], but with some minor differences, and some limitations. Care will be taken to point out key areas where my implementation differs from the original algorithm, and my solutions to subproblems undescribed by the original authors will also be presented. They might obviously differ from the original intent, but serve as workable solutions nonetheless. Since the algorithm works by manipulating a polyhedral boundary representation of the solid to be decomposed, the term polyhedron will be used predominantly. The input is assumed to be a solid as previously defined, and have only non-manifold features that fit into the definition of special notches given in the following section. 4.1 Preliminaries Edge-plane intersection A necessary piece of the decomposition process is to determine whether an edge of the geometry being decomposed is intersected by the splitting plane, and if it is, where the actual point of intersection is. There are more than one way to determine the intersection point between an edge e and a plane P. For an accurate solution, one can set up an equation system to find the point of intersection between two planes incident upon e, and P itself, and solve it by Gaussian elimination and partial pivoting. However, there is no single point solution to that equation system if the faces that are incident upon e are coplanar or nearly so. The current implementation makes no guarantees that no such case will never occur, and for that reason, a regular ray-plane intersection test is used when the plane equation system is too poorly conditioned. Either of those methods will yield an intersection point Ie P. Afterwards, a slight adjustment should be made to Ie P when it happens to end up outside of e due to numerical inaccuracies. If that is the case, Ie P is moved to the nearest point within e that is at distance of δ from the vertex of e closest to Ie P. 15

24 16 Chapter 4. Algorithm description Special notches In addition to notches, as defined in Section 3.1.3, there are other concavity features that must be taken care of as they might arise in the decomposition process. These are called special notches, and are caused by areas where the solid is non-manifold, whereas a manifold solid can only have regular notches. Special notches, as defined by Bajaj and Dey, come in the following varieties: Type I Where a feature is attached to an isolated vertex or edge on a face. Type II At edges where the number of incident faces is greater than two 1. Type III A number of features that are connected at a single vertex. A Type III special notch is shown at R 1 in Figure 3.3, and a Type II at R 2. Type I notches are closely related to Type III, but arise where a feature is connected on an isolated vertex on a face. At all special notches, note that the number of features that meet at a shared vertex or edge is not limited to two. Also keep in mind that these special notches do not represent all possible non-manifold configurations of a polyhedron. For instance, a polyhedron with an edge having an inner dihedral angle of 2π is nonmanifold, such as edge R in Figure 4.1. Such cases are not special notches, but they give rise to problems which will be discussed later. A plane P is called a notch plane if it contains a notch edge and resolves its reflex angle by cutting it into two pieces where each angle is less than π. There are an infinite number of possible notch planes, and a method is needed for selecting one. R Figure 4.1: Non-manifold polyhedron that is not caused by special notches. Edge R has an inner dihedral angle of 2π, and its two incident faces coincide. 4.2 Overview The algorithm, given a solid polyhedron S, begins by first disconnecting all features incident on special notches, producing a number of manifold polyhedra 2. Then, all notches in S are identified and a notch plane is assigned to each one. It then proceeds 1 Note that an edge can only have an even number of face incidences, or the polyhedron would not be solid. 2 Save non-manifold cases such as in Figure 4.1

25 4.3. Removing special notches 17 by repeatedly selecting a notch edge and splitting the polyhedra by the assigned notch plane. After each iteration, special notches are removed as they can be introduced by the splitting operation and the pieces resulting from the split are identified. Algorithm 1 outlines the top level of the decomposition algorithm in pseudocode. Assigning notch planes can be done trivially in linear time, for example by choosing the plane of either face incident on the notch edge, or optionally by using more involved heuristics to get a better decomposition by some metric. In the following sections, the process of removing special notches, splitting a polyhedron, and other considerations will be covered. Input: Solid polyhedron S Output: Set of convex polyhedra concave separate isolated(make manifold(s)) assign notch planes(manifold) repeat S i pop(concave) if P get notch plane(s i ) then manifold make manifold(split(s i, P )) concave concave separate isolated(manifold) else convex convex S i until concave = ; return convex Algorithm 1: Outline of the convex decomposition algorithm. 4.3 Removing special notches Type I Type I notches are the easiest to handle. An edge cycle c f of face f contains this special notch type if it contains only (i) an isolated vertex or (ii) a single edge with no neighbouring edges. To resolve the notch, c f is deleted, and in case (ii) the edge cycle s associated directed edges are removed from the isolated edge s adjacency list Type II A Type II notch is caused by an edge having more than two incident faces. Since an edge stores a directed edge record for each incident face, the number of incident faces is trivially determined. Let e i be an edge with more than two incident faces. The Star-edge representation mandates that the directed edges incident upon an edge are ordered radially by face direction, and grouped as (d 1, d 2 ), (d 3, d 4 ),..., (d i 1, d i ), where each pair represents an enclosed volume of S. For each such pair, a new edge, between the same vertices as the original edge is created, and the pair s directed edges are added to it. The old edge e i is deleted, as it is superseded by the edges newly created in its place, each with a subset of e i s directed edges. The above operation does not fully separate the features incident on e i, as all new edges are still counted as adjacent to the original two vertices of e i. It is unclear how

26 18 Chapter 4. Algorithm description Bajaj and Dey intended to fully perform this separation. In my implementation, all vertices incident upon Type II notches are remembered, and after all such notches are removed, the remembered vertices are for simplicity s sake treated as potential Type III notches, which completes the separation of all features incident on e i. v 1 e i v 2 v 1 Remove notch e i v 2 (a) (b) Figure 4.2: Removal of a Type II notch. The situation at (a) is before removing the Type II notch at e i. In (b), two new overlapping edges are created in place of e i. They are shown as curved for illustrative purposes only. Vertices v 1 and v 2 now constitute Type III notches, and will be handled as such Type III This special notch type requires a slightly more involved algorithm to identify and resolve. Recall that the notch type is caused by two polyhedral features meeting at a single vertex, as in Figure 3.3. To determine whether a vertex v i of S is a Type III notch, we need to find all groups of faces incident upon v i that cannot be reached from one another without crossing v i. If more than one group is found, the vertex is a Type III notch. Again, Bajaj and Dey left the details to the reader and did not fully describe this process. The solution given here might be different, but works nonetheless. To compute all disjoint sets of faces that constitute the separate features incident upon v i, the algorithm proceeds as follows: Let F vi be the set of all faces incident upon v i. To extract a group of faces, G, representing one feature: 1. Select any face from F vi and transfer it to G. 2. For each face f i in G, transfer all faces from F vi that are adjacent to f i to G. 3. Continue the loop until all faces transferred to G are themselves tested against the faces remaining in F vi. Now G contains the faces of a single feature group, and F vi is left with the remaining faces. Repeat this process to extract feature groups until no face remains in F vi. When complete, all faces incident upon v i are grouped as G 1, G 2,..., G i. If the number of groups is one, the vertex does not constitute a Type III notch. Otherwise, the groups of features need to be separated. For each group G i, a new vertex v n is inserted into S, at the same geometric location as the original vertex v i, and all directed edges of faces in G i are added to v n s adjacency list. The edges connecting to v n are updated by substituting v n for v i.

27 4.4. Splitting a solid polyhedron 19 P r r r Figure 4.3: Resolving notch r by cutting along P r. To perform the actual cut, the cross-sections for the upper and lower pieces must be generated (shown on the right). A unique polygon in the cross-section is called a cut. It is only necessary to split S along the cut containing r. 4.4 Splitting a solid polyhedron This operation is the central part of the decomposition algorithm, as it is based on repeated cutting of the concave polyhedron by planes passing through the notch edges. Given a concave polyhedron S that is assumed to be manifold (with special notches removed), a notch edge r, and a plane P r resolving the reflex angle at r, we need to compute the two parts of S residing on either side of P r. P r, as described by the plane equation Ax+By+Cz+D = 0, defines two closed half-spaces: P r : Ax+By+Cz+D 0 and P r : Ax + By + Cz + D 0. The quantities we are looking to obtain are: S = cl(int(s) int(p r )) S = cl(int(s) int(p r )) That is, the two pieces of S defined as the closure of the intersection between the solid s interior and the interior of respective half-space. To reach that goal it is necessary to compute the cross-sectional boundary between S and S, as defined by C r = P r S and C r = P r S. It is not uncommon that C r and C r are different, as evident in Figure 4.3. Note also that it is not necessary to split along the entire cross-sectional boundary to resolve the notch at r, as doing so might in some situations cause unnecessary and avoidable pieces to be created. Thus, we call distinct polygons of C r and C r cuts, and a better approach is to split only along the cut containing r. Strictly speaking, doing so does not result in S and S as defined above, but makes a more limited cut. The process of cutting S by P r can be summarized in four steps: 1. Classifying all vertices, faces and edges of S with respect to P r. 2. Computing the C r and C r between S and P r. 3. Separating S by the chosen cut. 4. Creating a new face to cover the open cut. A section will be devoted to each of these steps below. After the cut is performed, the S might be split into multiple pieces, or remain in one piece. In any case, a depth first traversal over the faces of S identifies the connected sub-solids that remain after the split.

28 20 Chapter 4. Algorithm description Classifying polyhedral features Before any cutting can be performed, it is necessary to know which features are are above the splitting plane, which are below, and which are intersected by it. With exact arithmetic this step would be trivial, as there would not be room for inconsistencies. However, as we are limited to finite precision arithmetic, a great deal of focus must be put on the algorithm s numerical robustness. Many decisions during the algorithm can be based solely on topological considerations, but care must be taken in all situations where numerical computations are performed, and the classification of features is one of those situations. Some assumptions have to be made regarding the input polyhedron in order to robustly classify its features. A common assumption that will be used here as well is the minimum feature criterion, which requires a minimum distance δ between any two features in the polyhedron. Two separate vertices must be separated by a distance at least δ from each other, and the same must hold for the distance between a vertex and an edge (except the edges it is directly incident upon). Also, the polyhedron is assumed to be manifold, as the special notches are expected to have been removed at this point. Generally, vertices are classified by determining which half-space they belong to with respect to P r. This is easily computed by finding the orthogonal distance between the point and the plane, by inserting the point s coordinates into the P r s plane equation, and looking at the sign of the resulting distance. If the sign is positive, the point is situated in the positive half-space of P r, or above P r, and respectively below for the negative half-space. However, with the numerical limitations of the distance computation, the distance cannot be trusted unless it is greater than δ. If the distance is less than δ, special heuristics must be used to guarantee a consistent result. These heuristics were laid out by Bajaj and Dey in the same paper as the main algorithm. First, the vertices of S are classified to the extent that is possible, followed by the classification of faces, which will also determine the classification of remaining unclassified vertices. Lastly, the edges are trivially classified, as only the vertices bounding an edge are relevant to the edge classification, and they are classified in the previous steps. Classifying vertices The possible final vertex classifications are either above, below or on, though a vertex might be assigned a temporary maybe on classification until the face classification algorithm finally determines the vertex final classification. If the distance between vertex v and P r is greater than δ, the sign determines whether v is classified as being above or below. If that condition fails, it is not enough to classify v as being on P r, and the classification will either depend on the previous classification of vertices connected to v by edges, or it will be deferred to the face classification step by temporarily marking v as being maybe on. When it cannot be unambiguously determined that v is above or below P r, it is necessary to look at the features connected to v to make a consistent classification choice. For each edge e incident upon v, the point of intersection with relation to P r is computed. Let the intersection point be called I e, and the vertex opposite to v on e be called w. If I e lies at a distance greater than δ from both v and w, we classify v as follows: If I e lies in between v and w, v is given the opposite classification of w, and otherwise v gets the same classification as w. This presupposes that w can be classified as being either above or below, with a δ margin. If not, e is not considered, and the next edge is inspected. If no edge is found that allows us to classify v, it is marked as

29 4.4. Splitting a solid polyhedron 21 being maybe on P r, and deferred to the face classification algorithm. Figure 4.4 shows an example where a vertex gets classified by its adjacent vertices. w 1 P r δ δ l > δ I r v w 2 w 3 Figure 4.4: Vertex v is not far enough from P r to classify it by sign comparison. The intersection point I e between v and w 1 is at a distance greater than δ from both v and w 1, and it lies between v and w 1, thus v is assigned the classification opposite to w 1. Using the edge going to w 2 is not possible, as it also cannot be classified by sign comparison. The choice is consistent with the classification of w 3 as well, as the algorithm would assign v the same classification as w 3 if that edge was used. Face classification Face classification is somewhat more involved, as it must also handle the classification of remaining vertices that are maybe on P r. A face f can be classified as either on, not intersected, or intersected. Whether it is above or below is trivial to determine from its vertices, but not of interest for the splitting operation. The classification of all vertices that up until now are classified as being maybe on P r will also be determined. By iterating over all vertices in all edge cycles of f, counters are updated with the number of vertices that are above, below, and maybe on, as well as the number of edges that cross P r, going from one side to the other. Also, if available, a reference vertex v ref classified either as above or below is picked for later use. The algorithm proceeds by applying the following cases: Case I All vertices of f are maybe on (or classified as on while classifying another face. Classify f and all its vertices of as on. Case II There are no vertices classified to be maybe on P r. Classify f as intersected unless all vertices of f are above or below P r, in which case f is not intersected. Case III No edges cross P r, and there is at least one vertex above or below P r. If less than three vertices are maybe on P r, reclassify them as on and f as intersected. Otherwise, choose any two maybe on vertices m 1, m 2 classify them as on, then form a line L between m 1 and m 2, and classify the remaining maybe on vertices depending on their relative position to v ref and L as follows: Let m i be a remaining vertex of f classified as maybe on. If m i is at a distance greater than δ from L, then assign the same classification to m i as to v ref if they are on the same side of L, or opposite to v r if they are on opposite sides. Finally, if any vertices remain classified as being maybe on, they are now classified as on. Classify f as intersected.

30 22 Chapter 4. Algorithm description Case IV An edge e crosses P r, and there are no other such edges. Let the intersection point of e and P r, together with any maybe on vertex m define a line L. Classify m as on, f as intersected, and the remaining maybe on vertices relative to L in the same manner as in Case III. Case V More than one edge crosses P r. Define L as the best line fitting all intersection points of the crossed edges in a total least square sense, and classify the remaining maybe on vertices relative to L and v ref like in Case III. Vertices that are classified as on in this process will be within a distance of δ from the intersection between P r and f, as defined by the chosen L, and will yield a more consistent classification than an arbitrary one. After the face classification is complete, all vertices will be classified as being either above, below, or on P r, and the edges of S can now be unambiguously classified. Edge classification As the classification of an edge e depends only on the previous classification of its bounding vertices, edges can be classified without further numerical computation: (i) both vertices of e are on P r, then e is also on P r. (ii) Only one vertex of e is on, define it as the intersection between e and P r, and classify e as intersected. (iii) One vertex is below, and the other above P r, then e is intersected. (iv) Both vertices of e are on the same side of P r, then e is not intersected Computing C r and C r With all vertices, faces and edges classified, the next step of the algorithm is to compute the boundary of the cross-section between S and P r, as previously shown in Figure 4.3. In order to do this, we begin by generating C r = C r C r, and later refine it to obtain the constituent parts. First, for every face f i marked as intersected by P r, all points of intersection are computed. For some edges in f i, the intersection points are one of the end points (as determined in the edge classification process), and will be called old intersection vertices. Others must be computed as described in Section 4.1.1, and will be referred to as new intersection vertices. The intersection points are sorted along the line of intersection between S and P r. For increased robustness, the sorting should take the local topology at the intersections into account, as the computed intersection points contain numerical inaccuracies which could result in an incorrect ordering, and thus result in an erroneously computed cross-section. The current implementation does not make such considerations, and is strictly a standard comparison-based O(n log n) sort, risking loss of robustness. However, an algorithm presented in [12] can perform a robust sorting in O(n) time, and is a logical improvement to the current state of the implementation. Finding the edges of C r With all intersection points sorted along f i P r, the next step is to generate edges between them where appropriate. This step can be carried out without any further numerical considerations, and thus has no bearing on the algorithm s robustness. Let v 1, v 2,..., v n be the sorted list of intersection vertices. The task is to determine between which consecutive vertices v i, v i+1 an edge needs to be inserted. By iterating over the sorted sequence, keeping track whether one is currently inside or outside f i, it is possible