An Efficient Query Structure for Mesh Refinement

Transcription

1 An Efficient Query Structure for Mesh Refinement Benoît Hudson Duru Türkoğlu September 18, 2008 Abstract We are interested in the following mesh refinement problem: given an input set of points P in R d, we would like to produce a good-quality triangulation by adding new points in P. Algorithms for mesh refinement are typically incremental: they compute the Delaunay triangulation of the input, and insert points one by one. However, retriangulating after each insertion can take linear time. In this work we develop a query structure that maintains the mesh without paying the full cost of retriangulating. Assuming that the meshing algorithm processes bad-quality elements in increasing order of their size, our structure allows inserting new points and computing a restriction of the Voronoi cell of a point, both in constant time. We develop an example of such a meshing algorithm, and show that it produces a provably small mesh in time as fast as sorting the input plus writing the output. 1 Introduction A central task in scientific computing is to discretize a domain of interest into a simplicial mesh. Concretely, we investigate the following setting: we are given a point cloud P in [0, 1] d, typically with d = 2 or 3. A meshing algorithm must produce a simplicial decomposition of [0, 1] d (a triangulation in d = 2), in which all of the input points appear as vertices of the decomposition. Each simplex should have good aspect ratio (quality), since that is a necessary or at least sufficient condition for many scientific computing applications. To ensure this, the algorithm must refine the point set, creating new (Steiner) vertices. But it should not add too many vertices: if the smallest possible mesh of good aspect ratio has m vertices, the algorithm should output at most O(m) vertices. There are two categories of mesh refinement algorithms with provable guarantees: those based on quadtrees [BEG94, MV00], and those based on Delaunay triangulations [Rup95, She98]. Quadtree-based meshes can be constructed in O(n log n + m) time [BET99]: the first term is due to sorting the input, the second term is due to Toyota Technological Institute at Chicago University of Chicago 1

2 computing and reporting the output. Traditional Delaunay methods produce substantially smaller meshes in practice, but can be quadratically slow (or worse) in the worst case. The runtime behaviour of these algorithms is dominated by the cost of maintaining the mesh while the output is incrementally computed. Two Delaunay refinement algorithms sidestep this cost and match the quadtree runtime: Har-Peled and Üngör [HPÜ05] hybridize Delaunay and quadtree methods, while Hudson, Miller, and Phillips [HMP06] carefully maintain a triangulation that is always sparse. The hybrid approach works in two dimensions only, whereas the always-sparse approach works in any fixed dimension. Here, we extend the hybrid approach to three or more dimensions. Our key contribution is a data structure that, in the context of a class of algorithms we call bottom-up meshing algorithms, can compute what we call the clipped Voronoi cell of a vertex (see Definitions 1 and 2). We prove the clipped Voronoi cell is sufficient for finding appropriate positions to place Steiner vertices as needed to produce a quality mesh. The user of our data structure can then add said Steiner vertex to the structure, again in constant time. In the final output, our data structure computes the entire Voronoi cell of any vertex in constant time, which is sufficient information for computing a good aspect ratio simplicial decomposition. 2 Preliminaries In a mesh where all simplices have good aspect ratio, the vertices of the mesh are wellspaced in a technical sense (defined below); conversely, a well-spaced set of points induces a mesh of good aspect ratio when we use the weight pumping technique to compute a triangulation [CD03]. Therefore, this paper deals almost exclusively with point sets and their Voronoi diagram. For the sake of clarity, we use u and v to denote vertices of the mesh, whereas arbitrary points in R d are denoted x and y. Our results all hold in arbitrary dimension. We assume the dimension is a constant, which allows us to hide in the big-o notation terms that are exponential in the dimension. In practice, we expect the techniques of this paper to mostly be applied to physical simulation problems in two or three dimensions, and rarely in even as many as four to six dimensions. Given a mesh M (which is a set of vertices), denote by NN M (v) the distance from v to the nearest other vertex in M, and by R M (v) the distance from v to the farthest node of its Voronoi cell; see Figure 1. Equivalently, R M (v) is the maximum circumradius of any Delaunay simplex around v. We say that v is ρ-well-spaced if R M (v) ρ NN M (v). One important consequence of well-spacedness is that the Delaunay triangulation of the vertices has bounded degree; therefore, we can talk of the size of the mesh either in terms of vertices or in terms of simplices, and be only off by a constant factor from each other. Since Ruppert s work [Rup95], one key tool to understanding the performance of Delaunay meshing algorithms has been the local feature size function. On a point set P, the function lfs(x) returns the distance from an arbitrary point x R d to its secondnearest vertex of P ; or, equivalently, it returns the minimum radius centered at x that encloses two or more vertices. The triangle inequality guarantees that the local feature 2

3 R(v) v NN(v) Figure 1: The vertex v is not 2-well-spaced, though it is 5-well-spaced. size is 1-Lipschitz: lfs(x) lfs(y) + xy for any x and y in space. At a vertex v P, the local feature size is the distance to the nearest neighbour: lfs(v) = NN P (v). In essence, then, lfs is an extension of NN P from being defined only on the vertices of the input to being defined on the entire space. Many meshing algorithms produce what we term a size-conforming mesh. That is, at every output vertex v M, NN M (v) Θ(lfs(v)). Notice here that while the nearest neighbour is taken over the output vertices M, the local feature size is defined over only the input points P. Ruppert showed that in two dimensions, even the smallest possible mesh of good aspect ratio is size-conforming; and furthermore, all size-conforming meshes have size within a constant factor of each other. In the present setting, where the input is a point cloud, his proof easily extends to higher dimension. We now have all the terminology needed to define what types of meshing algorithms can productively make use of our result. The definition refers to three values that are constants defined by the algorithm: γ, ρ, and β. That is, the values do not depend on the input P, though they may depend on the dimension of the input. Our proofs hold as long as γ > 0, ρ > 1, and β ρ. Definition 1 Consider an algorithm that starts with M = P and incrementally inserts Steiner vertices to M. When the algorithm produces a Steiner vertex s, the vertex lies within the Voronoi cell of some vertex v. We say the algorithm is a bottom-up mesh refinement algorithm if just before adding s, the following two conditions hold: (1) ρ NN M (v) vs β NN M (v). (2) For all other vertices u M, either NN M (u) γ NN M (v), or u is ρ-well-spaced: R M (u) ρ NN M (u). 3 Choosing Steiner Points Regardless of runtime considerations, the fundamental question in mesh refinement is: where should we put the Steiner points? Traditional solutions place Steiner points at the 3

4 u 2 u 3 u u 4 1 v βnn(v) Figure 2: The β-clipped Voronoi cell of v and its certificate region, bounded by neighbours u 1 through u 4. circumcenters of Delaunay simplices (equivalently, at nodes of the Voronoi diagram) that is, as far from any other vertex as possible. Har-Peled and Üngör instead place points at a particular location, the off-center, that is sufficiently far from a vertex, but still close to it. This locality allows them to produce a data structure that can find the off-center in constant time. Our goal is to generalize their result. We begin by defining a region, again, close to a vertex, that gives us a variety of choices of Steiner point: Definition 2 The β-clipped Voronoi cell of a vertex v in a mesh M, denoted V β M (v), is the intersection of the Voronoi cell of v with the ball centered at v of radius β NN M (v). Having computed V β M (v) for some β ρ, an algorithm can check whether v is ρ-well-spaced: is there any point of V β M (v) that is farther than ρ NN M (v)? If so, even without knowing the precise shape of the Voronoi cell, we can deduce that R M (v) is large, and thus v is not well-spaced. Therefore, it will be necessary to add a Steiner point. It is safe to insert any point in the Voronoi cell at distance at least ρ NN M (v) from v. For concreteness, we prove the following procedure, run until quiescence, terminates with a mesh no more than a constant factor larger than necessary: Take any vertex v M. Compute V β M (v). Let x be a point in V β M (v) such that vx > ρ NN M (v). If some such x exists, make it a vertex: add x to M. Lemma 3 Assume β ρ > 1. At any point during this procedure, for all vertices v M, we have the relation NN M (v) lfs(v)/c for some constant c that depends only on ρ and on the dimension. As a corollary, the final mesh has O(m) vertices. Proof: The proof follows Ruppert s original proof [Rup95] and is by induction. In the base case, before any vertex is inserted, M = P and thus NN M (v) = lfs(v). In the inductive case, the procedure is about to insert a new vertex at a point x. The 4

5 INITIALIZE(P ) O(n log n + m) APPROXIMATENN(v) O(1) CLIPPEDVORONOI(v, β) O(1) ADDVERTEX(v, p) O(1) Figure 3: The interface of our data structure, and runtimes. APPROXIMATENN is always fast but only accurate if used in the context of a bottom-up mesh refinement algorithm. CLIPPEDVORONOI and ADDVERTEX are always accurate but only fast in a bottom-up algorithm. See Theorem 10. current mesh is M, and let M be the new mesh, M = M {x}. We want to show that lfs(x) c NN M (x). We know that lfs is 1-Lipschitz, so lfs(x) lfs(v) + vx. The inductive hypothesis is that lfs(v) c NN M (v). Finally, we chose x such that NN M (v) vx /ρ, which means that lfs(x) (1 + c/ρ) vx. Since x is in the Voronoi cell of v, vx = NN M (x). In other words, we have shown that lfs(x) (1 + c/ρ) NN M (x). This satisfies what we need to show if 1 + c/ρ c. As long as ρ > 1, the choice of c = (ρ 1) 1 satisfies the condition and proves the lemma. Since the mesh is size-conforming, the corollary follows. If an algorithm correctly computes V β M (v), it must certify two things. First, a point x in V β M (v) is in the Voronoi cell of v; therefore, the open ball centered at x with radius vx is empty of any mesh vertices. The algorithm must, in some way or another, certify that said ball is empty otherwise, it might report that x is in the (clipped) Voronoi cell when in fact it is in the Voronoi cell of some other vertex. We call these the certificate balls, and define the certificate region of V β M (v) as their union (Figure 2). Second, an algorithm must verify that for all x on the boundary, either x is equidistant to v and another vertex, or x is at the clipping distance β NN(v) from v; otherwise, the algorithm could falsely report the clipped Voronoi cell is smaller than it truly is. 4 Query Interface Our main result is to present a data structure that can be used to maintain the mesh M as it is built, and quickly compute the clipped Voronoi cell of the vertices. Figure 3 presents the interface to our structure: after preprocessing the points, our structure can return the approximate distance to the nearest neighbour of any vertex; it can compute the clipped Voronoi cell of a vertex; and it can add a new Steiner vertex p near v. To better explain the query interface, we present an example bottom-up meshing algorithm in Figure 4. The idea is to perform the same procedure as in the prior section, but ordering vertices according to their distance to the nearest neighbour, smallest distance first. Strictly ordering the vertices by nearest neighbour distance is unnecessary, and in any case difficult since we would not known when to schedule the initial vertices from the input P. Therefore, we bucket the vertices into what we call a schedule, S, which is an array of sets of vertices. In set S[i], all vertices have NN M (v) Θ(2 i ). 5

6 REFINE(P, ρ) 1: INITIALIZE(P ) 2: Let S be an array of sets of vertices 3: for each v P do 4: Add v to the set S[ log APPROXIMATENN(v) ] 5: while S is non-empty do 6: Let v be a vertex from the set with the least index i 7: Compute V β M (v) = CLIPPEDVORONOI(2ρ, v) 8: if v is well-spaced then 9: Remove v from S[i] 10: else 11: Let x be some point in V β M (v) with vx ρ NN M (v) 12: ADDVERTEX(v, x) 13: Compute the neighbours U of x using CLIPPEDVORONOI(2ρ, x) 14: For each u U, add u to S[ log ux ] 15: Add x to S[ log vx ] Figure 4: A bottom-up mesh refinement algorithm using our structure At the end of REFINE, every vertex must be well-spaced, because otherwise the algorithm would not have terminated yet. It also produces a size-conforming mesh, of size O(m), as proved in Lemma 3. Finally, it runs quickly: Lemma 4 The algorithm of Figure 4 runs in time O(n log n + m). Proof: Initializing the data structure takes O(n log n + m) time. Scheduling each input point takes O(1) time, a total of O(n) time, since APPROXIMATENN is constant time (assuming we can take logarithms in constant time). To analyze the loop starting at line 5, we need to prove our algorithm is indeed a bottom-up refinement algorithm (definition 1). Condition (1) is explicitly guaranteed by Line 11: the point x chosen as a Steiner point is no more than β NN M (v) from v since it lies in the β-clipped Voronoi cell of v, and it is by construction farther than ρ NN M (v). Condition (2) is guaranteed because i is the least index. Therefore, when v is processed, any vertex that is not ρ-well-spaced has nearest neighbour in Ω(2 i ). The loop starting at line 5 iterates once each time a vertex was scheduled. A vertex may be scheduled for three reasons: because it is an input point; because it was just inserted; or because it neighbours a vertex that was just inserted. The first reason occurs exactly n times. The second reason occurs exactly m n times. As for the third reason, notice that the runtime on CLIPPEDVORONOI implies that a new vertex has O(1) neighbours therefore, the third reason occurs (m n) O(1) times. Each iteration involves either one or two calls to CLIPPEDVORONOI, and perhaps one call to ADDVERTEX; each takes O(1) time. Finding some x is constant time under any reasonable method to find it since V β M (v) has constant description length. The remainder of the work each iteration is to take a few logarithms and perform random access in an array, at constant time each. 6

7 All in all, there are O(m) iterations, each of which takes O(1) time, plus the initialization cost. These sum to O(n log n + m), as claimed. 5 Data Structure Our data structure is based on the leaves of a quadtree (a 2 d tree in arbitrary dimension). Each leaf square (or hypercube) stores the set of vertices contained in the square, and pointers to the neighbouring squares. Also, each vertex v stores a pointer to the square in which it lies, which we denote square(v). Our proofs of fast runtime depend on the quadtree having certain properties: (A) Each leaf square should only have a bounded number of neighbours. (B) Each leaf square should be sized in proportion to the local feature size of the points in the cell. That is, if a quadtree square has sides of length l, then for all x in the square, lfs(x) Θ(l). The balanced quadtree of Bern, Eppstein, and Gilbert [BEG94] satisfies our requirements, though in practice it will be preferable to split the squares more coarsely. Implementing much of the interface is very straightforward: We can implement INITIALIZE in O(n log n + m) time using the technique of Bern et al [BET99]. The mesh spacing requirement on the meshing algorithm, and requirement (B) on the quadtree, together guarantee that the square size is within a constant factor of NN(v). This allows APPROXIMATENN(v) to return the size of square(v), in constant time. To implement ADDVERTEX(p, v), we first look up square(v), then walk from square to square along the segment pv. Upon reaching the square that contains p, we add p to its list of vertices; the runtime analysis is treated in Theorem 10. Implementing CLIPPED- VORONOI is much more interesting and merits its own section. 6 Clipped Voronoi Computation We represent the β-clipped Voronoi cell of a vertex v using a set U of mesh vertices: for example, in Figure 2, U = {u 1, u 2, u 3, u 4 }. To find them, we perform a scan starting at v and growing a ball outward up to a maximum radius: at time t the ball has radius u 2 q t < t max = β NN M (v). When the scan reaches a vertex d v u 1 u, we add u to U if it is a Voronoi neighbour. In the analysis p it helps to define U t as the vertices of U with time at most t. For efficiency, we need to ensure that the scan does not exceed the certificate region. Therefore, we use a distance function different from the Euclidean one. For Figure 5: The thick curve any point p, we define the distance d M is the set of points p with v (p) as the diameter of the smallest certificate ball for p. If no such ball exists distance d U v (p) = d. No then we say d M empty ball reaches q, so v (p) =. It is not clear how to compute d M d U v (q) =. v (p) exactly without a prohibitive runtime overhead. However, we can relax the requirement that the balls be empty of any mesh vertices, and instead at time t compute d Ut v (p) the diameter of 7

8 CLIPPEDVORONOI(v, β) 1: t max 2: Q {square(v)} 3: U 4: while Q contains an element q with d U v (q) < t max do 5: q Minimum of Q with respect to d U v 6: if q is a vertex then 7: Add q to U 8: if q is the first vertex then t max β vq 9: if q is a quadtree square then 10: Add each vertex in the square to Q 11: Add every unvisited neighbouring square to Q 12: return U Figure 6: The CLIPPEDVORONOI algorithm, which performs a scan through the quadtree and mesh vertices. the smallest ball with v and p on its surface that includes no vertex of U t in its interior. Over time during the scan, this distance function is non-decreasing: adding vertices can only make it harder for a ball to be empty. Therefore, d Ut v (p) d M v (p) for all t. Interestingly, when the scan reaches p, the efficiently-computed lower bound is tight: Lemma 5 If point p has d Ut v (p) t, then d Ut v (p) = d M v (p). Proof: The assumption of the lemma implies that there exists a ball B of diameter d Ut v (p) that contains no vertex of U t. Consider a point q strictly inside B. It has a strictly smaller ball that is empty: d Ut v (q) < t. Because the computed distance function is nondecreasing in t, we must already have visited q, and discovered whether or not q is a vertex of M. In fact, we know it is not because if it were it would be both a vertex in U t and inside B, contradicting that B is empty. This applies for all q B: all of B is in fact empty of vertices of M. Monotonicity further implies that B is the smallest empty ball, which proves d Ut v (p) = d M v (p). As a corollary, this shows that the U tmax computed by the scan faithfully represents the β-clipped Voronoi cell: The scan visits the entire certificate region, because all points in the certificate region have distance less than t max. It also visits no more than the certificate region, because any point we visit has an empty ball with its center in V β (v). Implementation (see Figure 6): We discretize the scan using quadtree squares. Starting at square(v), we explore outward from v using a queue Q of events vertices and squares. Upon processing a vertex, we update the current Voronoi cell U; and upon processing a square, we enqueue the vertices it contains, and the squares it neighbours. To compute d U v (p), we find a point c that is the center of an empty ball of minimum radius. This gives rise to the following convex program: minimize cv subject to cv = xp cv cu i for all u i U 8

9 For a quadtree square, the distance is the minimum distance to any p in the square; this corresponds to letting p be free variables in the above program, and adding a box constraint (2d linear constraints in dimension d) on the coordinates of p. This leaves us with a quadratic program rather than a convex one, but it remains a program with O(1) variables and constraints. 7 Runtime Proof We prove that CLIPPEDVORONOI and ADDVERTEX are fast in two parts. First, we present a basic geometric fact about empty balls in partially-constructed meshes. This then implies that the certificate region intersects a bounded number of quadtree squares. From there it is an easy corollary to show that CLIPPEDVORONOI and ADDVERTEX run in constant time. 7.1 Points in an empty ball have large lfs We first show that empty balls do not contain points with small local feature size. We adapt a prior argument that assumed the entire mesh was well-spaced [HMP06, technical report, pp ]. In the present version, we only require that vertices with small nearest neighbour distance are well-spaced, so that our result will apply in the intermediate stages of a bottom-up algorithm. For clarity, we define a local mesh size function induced by the set of vertices the algorithm has output so far (including all of the input points). We say that lms M (p) is the distance from p to the second-nearest vertex of the partial mesh M. This differs from the local feature size lfs(p) in Figure 7: Setup for the proofs of Section 7.1. that the local feature size only considers input points, not output vertices. In particular, lfs(p) lms M (p). Theorem 6 Given a mesh M and an empty ball of radius r, assume every vertex u in M with NN(u) γr is ρ-well-spaced. Then there is a constant ɛ that depends only on γ and ρ such that at any point p in the empty ball, lms M (p) ɛr. Proof: If p is at distance at least ɛr from all vertices, we are done. Otherwise, we have the situation in Figure 7. Let c be the center of the empty ball in question. We identify two points on the ray from c to p: q is at distance r/2 from the center, and b is on the boundary. Finally, u is the vertex nearest q: that is, q is in the Voronoi cell of u. Lemma 7 will show that NN(u) ηr for some constant η. This then implies Lemma 8: for appropriate ɛ, which happens to be less than η/2, u is also the vertex nearest p. The distance from any point in the Voronoi cell of u to a second vertex is minimized at the point x equidistant between u and its nearest neighbour; there, lms M (x) = NN(u)/2. Therefore, lms M (p) η 2 r > ɛr. Lemma 7 The vertex nearest u is at distance NN(u) ηr, where η = min(γ, 1 2ρ ). 9

10 Proof: If NN(u) γr, we are done. Otherwise, we know that u is well-spaced: NN(u) R(u)/ρ. At the same time, we know that R(u) qu since q is in the Voronoi cell; and that qu r/2 because u is outside the empty ball. Lemma 8 If there is some vertex within ɛr of p, then u, the nearest vertex to q, is also the nearest vertex to p. Proof: We know there is a vertex u within distance ɛr of p, and we know that pq r/2. By the triangle inequality, qu (1/2 + ɛ)r. Then u lies somewhere within the ball centered at q, of radius (1/2 + ɛ)r, since u is nearer to q than is u. We also know that u must be outside the ball centered at c, of radius r. These two constraints define a crescent, shown shaded in Figure 7. Consider the plane that goes through c, b, and u. Said plane also contains q since c, b, and q are collinear. We can conformally transform the plane so that c is the origin, q = 0.5, 0, b = 1, 0, and u = x, y. Under this transformation, r = 1. The farthest u can be while still lying in the crescent is the point of the crescent where cu = 1 and qu = 1/2 + ɛ. We rewrite the first equality as x 2 + y 2 = 1, while the second gives us that x = 1 ɛ ɛ 2. Then we can conclude that bu 2 2 2x = 2(ɛ + ɛ 2 ). Recall from the prior lemma that the nearest neighbour of u is at distance η; therefore, every point at distance η/2 from u is within the Voronoi cell of u. Solving for bu = η/2 we see that by setting ɛ = η2 1/2, we ensure that b lies in the Voronoi cell of u. Since both b and q lie in the same convex set, p also lies in it. 7.2 Queries and updates are fast Lemma 9 Assume we are given a size-conforming mesh M, a value r with the guarantee that every vertex u in M with NN(u) γr is ρ-well-spaced, and a quadtree that satisfies condition (B). Then the certificate region of any vertex v with NN(v) r intersects O(1) leaf squares of the quadtree. Proof: At any x in the certificate region, there is an empty ball containing x that has diameter at least NN(v). Therefore, Theorem 6 shows that lfs(x) Ω(NN(v)). Any quadtree square that intersects the query region necessarily includes at least one such x, which, conjoined with condition (B) on the quadtree, implies that the squares each have side length in Ω(NN(v)). Finally, a volume packing argument applies: within a ball of volume (2β NN(v)) d, every visited quadtree square consumes at least Ω(NN(v)) d volume. Theorem 10 When a bottom-up mesh refinement algorithm calls ADDVERTEX or CLIPPEDVORONOI, our data structure responds in constant time. Proof: In ADDVERTEX(p, v), if p lies within the β-clipped Voronoi cell of v, then every square visited by the call intersects the certificate region. Upon finding the destination square, ADDVERTEX simply appends to a list. Thus ADDVERTEX does constant work. When the CLIPPEDVORONOI algorithm visits a quadtree square, that square either intersects the certificate region, or is a neighbour of a square that intersects the certificate region. Thanks to the guarantee that squares have a bounded number 10

11 of neighbours, the latter outnumber the former by at most a constant factor. Thus CLIPPEDVORONOI visits only O(1) squares. The function also does work iterating over the vertices each square contains. By the mesh spacing requirement, a mesh vertex v has a nearest neighbour no closer than Ω(lfs(x)); meanwhile, the quadtree square that contains v has sides of length O(lfs(v)). Therefore, each square only hosts O(1) mesh vertices, and the total work is O(1). 8 Higher-dimensional input features In the present work, we showed how to support a class of mesh refinement algorithms with a search structure that could find appropriate new Steiner points in constant time, assuming the input is a point cloud. Typically, engineers and graphic artists will want the mesh to respect more than just a point cloud: it should respect some meaningful segments and polygons, and perhaps also curves and curved surfaces. Of course, the client application could simply specify a denser packing of points on the surfaces, but ideally the meshing algorithm could handle the features directly. Nothing fundamental blocks the extension of our structure to handle the case of higher-dimensional features (even curved, and with small input angles), although we would need need to enrich the interface our data structure presents. References [BEG94] Marshall Bern, David Eppstein, and John R. Gilbert. Provably good mesh generation. J. Computer and System Sciences, 48(3): , [BET99] [CD03] Marshall Bern, David Eppstein, and Shang-Hua Teng. Parallel construction of quadtrees and quality triangulations. IJCGA, 9(6): , Siu-Wing Cheng and Tamal K. Dey. Quality meshing with weighted delaunay refinement. SIAM J. Comput., 33(1):69 93, [HMP06] Benoît Hudson, Gary L. Miller, and Todd Phillips. Sparse Voronoi Refinement. In IMR, pages , See also CMU Tech. Report CMU- CS [HPÜ05] Sariel Har-Peled and Alper Üngör. A time-optimal Delaunay refinement algorithm in two dimensions. In SoCG, pages , [MV00] [Rup95] Scott A. Mitchell and Stephen A. Vavasis. Quality mesh generation in higher dimensions. SIAM J. Computing, 29(4): , Jim Ruppert. A Delaunay refinement algorithm for quality 2-dimensional mesh generation. J. Algorithms, 18(3): , [She98] Jonathan Richard Shewchuk. Tetrahedral Mesh Generation by Delaunay Refinement. In SoCG, pages 86 95,