using System; using System.Collections.Generic; using System.Numerics; using CultMath; // The Delaunay triangulation of a galaxy's zone positions, as the edges Galaxy links zones along. Bowyer-Watson // (Bowyer 1981, Watson 1981): each point is inserted by removing every triangle whose circumcircle strictly holds it and // fanning the cavity's boundary to it. The orientation and in-circle predicates are exact: a double-precision // determinant answers when it clears its rounding-error bound (Shewchuk 1997), otherwise the determinant is evaluated // in BigInteger, since every double is a dyadic rational. For two or more distinct points the edge graph is connected: // collinear points link each to its neighbour along the line; duplicate or non-finite points throw. public static class Delaunay { // Each edge once, as (lower index, higher index), in ascending order. public static List<(int a, int b)> Edges(IReadOnlyList points) { var n = points.Count; var order = new int[n]; for (var i = 0; i < n; i++) { if (!float.IsFinite(points[i].x) || !float.IsFinite(points[i].y)) throw new ArgumentException($"Delaunay point {i} is not finite: ({points[i].x}, {points[i].y})"); order[i] = i; } // Lexicographic order runs along any line, and puts equal points side by side. Array.Sort(order, (i, j) => points[i].x != points[j].x ? points[i].x.CompareTo(points[j].x) : points[i].y.CompareTo(points[j].y)); for (var i = 1; i < n; i++) if (points[order[i - 1]].x == points[order[i]].x && points[order[i - 1]].y == points[order[i]].y) throw new ArgumentException($"Delaunay points {Math.Min(order[i - 1], order[i])} and {Math.Max(order[i - 1], order[i])} are the same point ({points[order[i]].x}, {points[order[i]].y})"); if (n < 2) return new List<(int a, int b)>(); var x = new double[n + 3]; var y = new double[n + 3]; double minX = double.MaxValue, minY = double.MaxValue, maxX = double.MinValue, maxY = double.MinValue; for (var i = 0; i < n; i++) { x[i] = points[i].x; y[i] = points[i].y; minX = Math.Min(minX, x[i]); minY = Math.Min(minY, y[i]); maxX = Math.Max(maxX, x[i]); maxY = Math.Max(maxY, y[i]); } var collinear = true; for (var i = 2; i < n && collinear; i++) collinear = Orientation(x, y, order[0], order[1], order[i]) == 0; if (collinear) { var line = new List<(int a, int b)>(); for (var i = 1; i < n; i++) line.Add(Ordered(order[i - 1], order[i])); line.Sort(); return line; } // A super-triangle so far outside the points that its vertices bend no edge between them: a float's coordinates // are multiples of 2^-149, so a triple of distinct non-collinear points has circumradius under extent^3 * 2^300, // which 2^700 * extent exceeds for any extent a float holds. Its triangles are dropped at the end. Its // coordinates overflow the double determinants, which then fail every comparison and fall to the exact path. var size = Math.Max(maxX - minX, maxY - minY) * Math.Pow(2, 700); double midX = (minX + maxX) / 2, midY = (minY + maxY) / 2; x[n] = midX - size; y[n] = midY - size; x[n + 1] = midX + size; y[n + 1] = midY - size; x[n + 2] = midX; y[n + 2] = midY + size; var triangles = new List { new Triangle(n, n + 1, n + 2, x, y) }; var cavity = new Dictionary<(int, int), int>(); for (var p = 0; p < n; p++) { cavity.Clear(); for (var t = triangles.Count - 1; t >= 0; t--) { var triangle = triangles[t]; if (InCircle(x, y, triangle.A, triangle.B, triangle.C, p) * triangle.Orientation <= 0) continue; Count(cavity, triangle.A, triangle.B); Count(cavity, triangle.B, triangle.C); Count(cavity, triangle.C, triangle.A); triangles[t] = triangles[triangles.Count - 1]; triangles.RemoveAt(triangles.Count - 1); } // The cavity's boundary is every edge only one removed triangle had. foreach (var edge in cavity) if (edge.Value == 1) triangles.Add(new Triangle(edge.Key.Item1, edge.Key.Item2, p, x, y)); } var edges = new SortedSet<(int a, int b)>(); foreach (var triangle in triangles) { if (triangle.A >= n || triangle.B >= n || triangle.C >= n) continue; edges.Add(Ordered(triangle.A, triangle.B)); edges.Add(Ordered(triangle.B, triangle.C)); edges.Add(Ordered(triangle.C, triangle.A)); } return new List<(int a, int b)>(edges); } private static void Count(Dictionary<(int, int), int> cavity, int a, int b) { var key = Ordered(a, b); cavity[key] = cavity.TryGetValue(key, out var seen) ? seen + 1 : 1; } private static (int a, int b) Ordered(int a, int b) => a < b ? (a, b) : (b, a); private readonly struct Triangle { public readonly int A, B, C; // +1 if A, B, C run counter-clockwise, -1 if clockwise; a triangle never has zero area. public readonly int Orientation; public Triangle(int a, int b, int c, double[] x, double[] y) { A = a; B = b; C = c; Orientation = Delaunay.Orientation(x, y, a, b, c); if (Orientation == 0) throw new InvalidOperationException($"Delaunay built a zero-area triangle on points {a}, {b}, {c}"); } } // Shewchuk's error bounds for the double-precision determinants: (3 + 16e)e and (10 + 96e)e, e = 2^-53. private const double OrientationBound = 3.3306690738754716e-16; private const double InCircleBound = 1.1102230246251577e-15; // The sign of the area a, b, c span: +1 counter-clockwise, -1 clockwise, 0 collinear. private static int Orientation(double[] x, double[] y, int a, int b, int c) { var left = (x[a] - x[c]) * (y[b] - y[c]); var right = (y[a] - y[c]) * (x[b] - x[c]); var det = left - right; var bound = OrientationBound * (Math.Abs(left) + Math.Abs(right)); if (det > bound) return 1; if (-det > bound) return -1; var exact = Exact.Of(x, y, a, b, c); return (exact[0] * exact[3] - exact[1] * exact[2]).Sign; } // The sign of the in-circle determinant: +1 when p is strictly inside the circle through a, b, c taken // counter-clockwise, -1 strictly outside, 0 on it. private static int InCircle(double[] x, double[] y, int a, int b, int c, int p) { double adx = x[a] - x[p], ady = y[a] - y[p], bdx = x[b] - x[p], bdy = y[b] - y[p], cdx = x[c] - x[p], cdy = y[c] - y[p]; double abL = adx * bdy, abR = bdx * ady, bcL = bdx * cdy, bcR = cdx * bdy, caL = cdx * ady, caR = adx * cdy; double alift = adx * adx + ady * ady, blift = bdx * bdx + bdy * bdy, clift = cdx * cdx + cdy * cdy; var det = alift * (bcL - bcR) + blift * (caL - caR) + clift * (abL - abR); var permanent = (Math.Abs(bcL) + Math.Abs(bcR)) * alift + (Math.Abs(caL) + Math.Abs(caR)) * blift + (Math.Abs(abL) + Math.Abs(abR)) * clift; var bound = InCircleBound * permanent; if (det > bound) return 1; if (-det > bound) return -1; var e = Exact.Of(x, y, a, b, c, p); BigInteger ax = e[0], ay = e[1], bx = e[2], by = e[3], cx = e[4], cy = e[5]; return (e[6] * (bx * cy - cx * by) + e[7] * (cx * ay - ax * cy) + e[8] * (ax * by - bx * ay)).Sign; } // Coordinates exactly, as integers in units of the smallest binary exponent among them. private static class Exact { // Orientation: [a.x - c.x, a.y - c.y, b.x - c.x, b.y - c.y] with the cross product the caller takes. public static BigInteger[] Of(double[] x, double[] y, int a, int b, int c) { var v = Scaled(new[] { x[a], y[a], x[b], y[b], x[c], y[c] }); return new[] { v[0] - v[4], v[1] - v[5], v[2] - v[4], v[3] - v[5] }; } // In-circle: [a - p (x, y), b - p, c - p, then each one's squared length]. public static BigInteger[] Of(double[] x, double[] y, int a, int b, int c, int p) { var v = Scaled(new[] { x[a], y[a], x[b], y[b], x[c], y[c], x[p], y[p] }); BigInteger adx = v[0] - v[6], ady = v[1] - v[7], bdx = v[2] - v[6], bdy = v[3] - v[7], cdx = v[4] - v[6], cdy = v[5] - v[7]; return new[] { adx, ady, bdx, bdy, cdx, cdy, adx * adx + ady * ady, bdx * bdx + bdy * bdy, cdx * cdx + cdy * cdy }; } private static BigInteger[] Scaled(double[] values) { var mantissa = new long[values.Length]; var exponent = new int[values.Length]; var lowest = int.MaxValue; for (var i = 0; i < values.Length; i++) { var bits = BitConverter.DoubleToInt64Bits(values[i]); var biased = (int) ((bits >> 52) & 0x7FF); var fraction = bits & 0xFFFFFFFFFFFFFL; mantissa[i] = biased == 0 ? fraction : fraction | (1L << 52); exponent[i] = biased == 0 ? -1074 : biased - 1075; if (bits < 0) mantissa[i] = -mantissa[i]; if (mantissa[i] != 0) lowest = Math.Min(lowest, exponent[i]); } var scaled = new BigInteger[values.Length]; for (var i = 0; i < values.Length; i++) scaled[i] = mantissa[i] == 0 ? BigInteger.Zero : new BigInteger(mantissa[i]) << (exponent[i] - lowest); return scaled; } } }