Editing Delaunay triangulation (section)

==Algorithms==
[[File:Point inside circle - Delaunay condition broken - Labelled.svg|thumb|We need a robust and fast way to detect if point {{mvar|D}} lies in the circumcircle of {{mvar|A, B, C}}]]
Many algorithms for computing Delaunay triangulations rely on fast operations for detecting when a point is within a triangle's circumcircle and an efficient data structure for storing triangles and edges.  In two dimensions, one way to detect if point {{mvar|D}} lies in the circumcircle of {{mvar|A, B, C}} is to evaluate the [[determinant]]:{{r|GS1985}}

: <math>
\begin{align}
& \begin{vmatrix}
A_x & A_y & A_x^2 + A_y^2 & 1\\
B_x & B_y & B_x^2 + B_y^2 & 1\\
C_x & C_y & C_x^2 + C_y^2 & 1\\
D_x & D_y & D_x^2 + D_y^2 & 1
\end{vmatrix} \\[8pt]
= {} & \begin{vmatrix}
A_x - D_x & A_y - D_y & (A_x - D_x)^2 + (A_y - D_y)^2 \\
B_x - D_x & B_y - D_y & (B_x - D_x)^2 + (B_y - D_y)^2 \\
C_x - D_x & C_y - D_y & (C_x - D_x)^2 + (C_y - D_y)^2
\end{vmatrix} > 0
\end{align}
</math>

When {{mvar|A, B, C}} are sorted in a [[counterclockwise]] order, this determinant is positive only if {{mvar|D}} lies inside the circumcircle.

===Flip algorithms===
As mentioned above, if a triangle is non-Delaunay, we can flip one of its edges.  This leads to a straightforward algorithm: construct any triangulation of the points, and then flip edges until no triangle is non-Delaunay. Unfortunately, this can take {{math|Ω(''n''<sup>2</sup>)}} edge flips.{{r|Hurtado}} While this algorithm can be generalised to three and higher dimensions, its convergence is not guaranteed in these cases, as it is conditioned to the connectedness of the underlying [[flip graph]]: this graph is connected for two-dimensional sets of points, but may be disconnected in higher dimensions.{{r|DRS}}

===Incremental===
The most straightforward way of efficiently computing the Delaunay triangulation is to repeatedly add one vertex at a time, retriangulating the affected parts of the graph.  When a vertex {{mvar|v}} is added, we split in three the triangle that contains {{mvar|v}}, then we apply the flip algorithm.  Done naïvely, this will take {{math|O(''n'')}} time: we search through all the triangles to find the one that contains {{mvar|v}}, then we potentially flip away every triangle.  Then the overall runtime is {{math|O(''n''<sup>2</sup>)}}.

If we insert vertices in random order, it turns out (by a somewhat intricate proof) that each insertion will flip, on average, only {{math|O(1)}} triangles – although sometimes it will flip many more.{{r|GKS1992}} This still leaves the point location time to improve.  We can store the history of the splits and flips performed: each triangle stores a pointer to the two or three triangles that replaced it.  To find the triangle that contains {{mvar|v}}, we start at a root triangle, and follow the pointer that points to a triangle that contains {{mvar|v}}, until we find a triangle that has not yet been replaced.  On average, this will also take {{math|O(log ''n'')}} time.  Over all vertices, then, this takes {{math|O(''n'' log ''n'')}} time.{{r|deBerg}}  While the technique extends to higher dimension (as proved by Edelsbrunner and Shah{{r|ES1996}}), the runtime can be exponential in the dimension even if the final Delaunay triangulation is small.

The [[Bowyer–Watson algorithm]] provides another approach for incremental construction.  It gives an alternative to edge flipping for computing the Delaunay triangles containing a newly inserted vertex.

Unfortunately the flipping-based algorithms are generally hard to parallelize, since adding some certain point (e.g. the center point of a wagon wheel) can lead to up to {{math|O(''n'')}} consecutive flips.  Blelloch et al.{{r|Parallel}} proposed another version of incremental algorithm based on rip-and-tent, which is practical and highly parallelized with polylogarithmic [[Analysis of parallel algorithms|span]].

===Divide and conquer===
A [[divide and conquer algorithm]] for triangulations in two dimensions was developed by Lee and Schachter and improved by [[Leonidas J. Guibas|Guibas]] and [[Jorge Stolfi|Stolfi]]{{r|GS1985}}{{r|Peterson}} and later by Dwyer.{{r|Dwyer1987}}  In this algorithm, one recursively draws a line to split the vertices into two sets. The Delaunay triangulation is computed for each set, and then the two sets are merged along the splitting line.  Using some clever tricks, the merge operation can be done in time {{math|O(''n'')}}, so the total running time is {{math|O(''n'' log ''n'')}}.{{r|Leach1992}}

For certain types of point sets, such as a uniform random distribution, by intelligently picking the splitting lines the expected time can be reduced to {{math|O(''n'' log log ''n'')}} while still maintaining worst-case performance.

A divide and conquer paradigm to performing a triangulation in {{mvar|d}} dimensions is presented in "DeWall: A fast divide and conquer Delaunay triangulation algorithm in E<sup>''d''</sup>" by P. Cignoni, C. Montani, R. Scopigno.{{r|CMS1998}}

The divide and conquer algorithm has been shown to be the fastest DT generation technique sequentially.<ref>A Comparison of Sequential Delaunay Triangulation Algorithms {{cite web |url=http://www.cs.berkeley.edu/~jrs/meshpapers/SuDrysdale.pdf |title=Archived copy |access-date=2010-08-18 |url-status=dead |archive-url=https://web.archive.org/web/20120308043808/http://www.cs.berkeley.edu/%7Ejrs/meshpapers/SuDrysdale.pdf |archive-date=2012-03-08 }}</ref><ref>{{cite web|url=https://www.cs.cmu.edu/~quake/tripaper/triangle2.html|title=Triangulation Algorithms and Data Structures|website=www.cs.cmu.edu|access-date=25 April 2018|url-status=live|archive-url=https://web.archive.org/web/20171010072746/https://www.cs.cmu.edu/~quake/tripaper/triangle2.html|archive-date=10 October 2017}}</ref>

===Sweephull===

Sweephull<ref>{{cite web|url=http://www.s-hull.org/paper/s_hull.pdf |archive-url=https://web.archive.org/web/20131027221354/http://www.s-hull.org/paper/s_hull.pdf |archive-date=2013-10-27 |url-status=live|title=S-hull|website=s-hull.org|access-date=25 April 2018}}</ref> is a hybrid technique for 2D Delaunay triangulation that uses a radially propagating sweep-hull, and a flipping algorithm. The sweep-hull is created sequentially by iterating a radially-sorted set of 2D points, and connecting triangles to the visible part of the convex hull, which gives a non-overlapping triangulation. One can build a convex hull in this manner so long as the order of points guarantees no point would fall within the triangle. But, radially sorting should minimize flipping by being highly Delaunay to start. This is then paired with a final iterative triangle flipping step.