/// <summary> /// Return vector from the hull point at index to next point /// </summary> public void VectorToNext(int index, out double dx, out double dy) { DelaunayVertex et = this[index], en = this[NextIndex(index)]; dx = en.x - et.x; dy = en.y - et.y; }
public double distance2To(DelaunayVertex other) { double dx = x - other.x; double dy = y - other.y; return(dx * dx + dy * dy); }
/// <summary> /// Return true iff Vertex p is inside the circumcircle of this triangle /// </summary> public bool InsideCircumcircle(DelaunayVertex p) { double dx = circumcircleX - p.x; double dy = circumcircleY - p.y; double r2 = dx * dx + dy * dy; return(r2 < circumcircleR2); }
/// <summary> /// Return whether the hull vertex at index is visible from the point /// </summary> public bool EdgeVisibleFrom(int index, DelaunayVertex point) { double idx, idy; VectorToNext(index, out idx, out idy); double dx = point.x - this[index].x; double dy = point.y - this[index].y; double crossProduct = -dy * idx + dx * idy; return(crossProduct < 0); }
/// <summary> /// Find location and radius ^2 of the circumcircle (through all 3 points) /// This is the most critical routine in the entire set of code. It must /// be numerically stable when the points are nearly collinear. /// </summary> public bool FindCircumcirclePrecisely(List <DelaunayVertex> points) { // Use coordinates relative to point `a' of the triangle DelaunayVertex pa = points[a], pb = points[b], pc = points[c]; double xba = pb.x - pa.x; double yba = pb.y - pa.y; double xca = pc.x - pa.x; double yca = pc.y - pa.y; // Squares of lengths of the edges incident to `a' double balength = xba * xba + yba * yba; double calength = xca * xca + yca * yca; // Calculate the denominator of the formulae. double D = xba * yca - yba * xca; if (D == 0) { circumcircleX = 0; circumcircleY = 0; circumcircleR2 = -1; return(false); } double denominator = 0.5 / D; // Calculate offset (from pa) of circumcenter double xC = (yca * balength - yba * calength) * denominator; double yC = (xba * calength - xca * balength) * denominator; double radius2 = xC * xC + yC * yC; if ((radius2 > 1e10 * balength || radius2 > 1e10 * calength)) { circumcircleX = 0; circumcircleY = 0; circumcircleR2 = -1; return(false); } circumcircleR2 = (double)radius2; circumcircleX = (double)(pa.x + xC); circumcircleY = (double)(pa.y + yC); return(true); }
public double distanceTo(DelaunayVertex other) { return (double)Math.Sqrt(distance2To(other)); }
public double distance2To(DelaunayVertex other) { double dx = x - other.x; double dy = y - other.y; return dx * dx + dy * dy; }
/// <summary> /// Return true iff Vertex p is inside the circumcircle of this triangle /// </summary> public bool InsideCircumcircle(DelaunayVertex p) { double dx = circumcircleX - p.x; double dy = circumcircleY - p.y; double r2 = dx * dx + dy * dy; return r2 < circumcircleR2; }
private void Analyse(List <DelaunayVertex> suppliedPoints, Hull hull, List <Triad> triads, bool rejectDuplicatePoints, bool hullOnly) { if (suppliedPoints.Count < 3) { throw new ArgumentException("Number of points supplied must be >= 3"); } this.points = suppliedPoints; int nump = points.Count; double[] distance2ToCentre = new double[nump]; int[] sortedIndices = new int[nump]; // Choose first point as the seed for (int k = 0; k < nump; k++) { distance2ToCentre[k] = points[0].distance2To(points[k]); sortedIndices[k] = k; } // Sort by distance to seed point Array.Sort(distance2ToCentre, sortedIndices); // Duplicates are more efficiently rejected now we have sorted the vertices if (rejectDuplicatePoints) { // Search backwards so each removal is independent of any other for (int k = nump - 2; k >= 0; k--) { // If the points are identical then their distances will be the same, // so they will be adjacent in the sorted list if ((points[sortedIndices[k]].x == points[sortedIndices[k + 1]].x) && (points[sortedIndices[k]].y == points[sortedIndices[k + 1]].y)) { // Duplicates are expected to be rare, so this is not particularly efficient Array.Copy(sortedIndices, k + 2, sortedIndices, k + 1, nump - k - 2); Array.Copy(distance2ToCentre, k + 2, distance2ToCentre, k + 1, nump - k - 2); nump--; } } } Debug.WriteLine((points.Count - nump).ToString() + " duplicate points rejected"); if (nump < 3) { throw new ArgumentException("Number of unique points supplied must be >= 3"); } int mid = -1; double romin2 = double.MaxValue, circumCentreX = 0, circumCentreY = 0; // Find the point which, with the first two points, creates the triangle with the smallest circumcircle Triad tri = new Triad(sortedIndices[0], sortedIndices[1], 2); for (int kc = 2; kc < nump; kc++) { tri.c = sortedIndices[kc]; if (tri.FindCircumcirclePrecisely(points) && tri.circumcircleR2 < romin2) { mid = kc; // Centre of the circumcentre of the seed triangle romin2 = tri.circumcircleR2; circumCentreX = tri.circumcircleX; circumCentreY = tri.circumcircleY; } else if (romin2 * 4 < distance2ToCentre[kc]) { break; } } // Change the indices, if necessary, to make the 2th point produce the smallest circumcircle with the 0th and 1th if (mid != 2) { int indexMid = sortedIndices[mid]; double distance2Mid = distance2ToCentre[mid]; Array.Copy(sortedIndices, 2, sortedIndices, 3, mid - 2); Array.Copy(distance2ToCentre, 2, distance2ToCentre, 3, mid - 2); sortedIndices[2] = indexMid; distance2ToCentre[2] = distance2Mid; } // These three points are our seed triangle tri.c = sortedIndices[2]; tri.MakeClockwise(points); tri.FindCircumcirclePrecisely(points); // Add tri as the first triad, and the three points to the convex hull triads.Add(tri); hull.Add(new HullVertex(points, tri.a)); hull.Add(new HullVertex(points, tri.b)); hull.Add(new HullVertex(points, tri.c)); // Sort the remainder according to their distance from its centroid // Re-measure the points' distances from the centre of the circumcircle DelaunayVertex centre = new DelaunayVertex(circumCentreX, circumCentreY); for (int k = 3; k < nump; k++) { distance2ToCentre[k] = points[sortedIndices[k]].distance2To(centre); } // Sort the _other_ points in order of distance to circumcentre Array.Sort(distance2ToCentre, sortedIndices, 3, nump - 3); // Add new points into hull (removing obscured ones from the chain) // and creating triangles.... int numt = 0; for (int k = 3; k < nump; k++) { int pointsIndex = sortedIndices[k]; HullVertex ptx = new HullVertex(points, pointsIndex); double dx = ptx.x - hull[0].x, dy = ptx.y - hull[0].y; // outwards pointing from hull[0] to pt. int numh = hull.Count, numh_old = numh; List <int> pidx = new List <int>(), tridx = new List <int>(); int hidx; // new hull point location within hull..... if (hull.EdgeVisibleFrom(0, dx, dy)) { // starting with a visible hull facet !!! int e2 = numh; hidx = 0; // check to see if segment numh is also visible if (hull.EdgeVisibleFrom(numh - 1, dx, dy)) { // visible. pidx.Add(hull[numh - 1].pointsIndex); tridx.Add(hull[numh - 1].triadIndex); for (int h = 0; h < numh - 1; h++) { // if segment h is visible delete h pidx.Add(hull[h].pointsIndex); tridx.Add(hull[h].triadIndex); if (hull.EdgeVisibleFrom(h, ptx)) { hull.RemoveAt(h); h--; numh--; } else { // quit on invisibility hull.Insert(0, ptx); numh++; break; } } // look backwards through the hull structure for (int h = numh - 2; h > 0; h--) { // if segment h is visible delete h + 1 if (hull.EdgeVisibleFrom(h, ptx)) { pidx.Insert(0, hull[h].pointsIndex); tridx.Insert(0, hull[h].triadIndex); hull.RemoveAt(h + 1); // erase end of chain } else { break; // quit on invisibility } } } else { hidx = 1; // keep pt hull[0] tridx.Add(hull[0].triadIndex); pidx.Add(hull[0].pointsIndex); for (int h = 1; h < numh; h++) { // if segment h is visible delete h pidx.Add(hull[h].pointsIndex); tridx.Add(hull[h].triadIndex); if (hull.EdgeVisibleFrom(h, ptx)) { // visible hull.RemoveAt(h); h--; numh--; } else { // quit on invisibility hull.Insert(h, ptx); break; } } } } else { int e1 = -1, e2 = numh; for (int h = 1; h < numh; h++) { if (hull.EdgeVisibleFrom(h, ptx)) { if (e1 < 0) { e1 = h; // first visible } } else { if (e1 > 0) { // first invisible segment. e2 = h; break; } } } // triangle pidx starts at e1 and ends at e2 (inclusive). if (e2 < numh) { for (int e = e1; e <= e2; e++) { pidx.Add(hull[e].pointsIndex); tridx.Add(hull[e].triadIndex); } } else { for (int e = e1; e < e2; e++) { pidx.Add(hull[e].pointsIndex); tridx.Add(hull[e].triadIndex); // there are only n-1 triangles from n hull pts. } pidx.Add(hull[0].pointsIndex); } // erase elements e1+1 : e2-1 inclusive. if (e1 < e2 - 1) { hull.RemoveRange(e1 + 1, e2 - e1 - 1); } // insert ptx at location e1+1. hull.Insert(e1 + 1, ptx); hidx = e1 + 1; } // If we're only computing the hull, we're done with this point if (hullOnly) { continue; } int a = pointsIndex, T0; int npx = pidx.Count - 1; numt = triads.Count; T0 = numt; for (int p = 0; p < npx; p++) { Triad trx = new Triad(a, pidx[p], pidx[p + 1]); trx.FindCircumcirclePrecisely(points); trx.bc = tridx[p]; if (p > 0) { trx.ab = numt - 1; } trx.ac = numt + 1; // index back into the triads. Triad txx = triads[tridx[p]]; if ((trx.b == txx.a && trx.c == txx.b) | (trx.b == txx.b && trx.c == txx.a)) { txx.ab = numt; } else if ((trx.b == txx.a && trx.c == txx.c) | (trx.b == txx.c && trx.c == txx.a)) { txx.ac = numt; } else if ((trx.b == txx.b && trx.c == txx.c) | (trx.b == txx.c && trx.c == txx.b)) { txx.bc = numt; } triads.Add(trx); numt++; } // Last edge is on the outside triads[numt - 1].ac = -1; hull[hidx].triadIndex = numt - 1; if (hidx > 0) { hull[hidx - 1].triadIndex = T0; } else { numh = hull.Count; hull[numh - 1].triadIndex = T0; } } }
public double distanceTo(DelaunayVertex other) { return((double)Math.Sqrt(distance2To(other))); }