// Given a point X and an edge AB, check that the distance from X to AB is // "distanceRadians" and the closest point on AB is "expectedClosest". private static void checkDistance( S2Point x, S2Point a, S2Point b, double distanceRadians, S2Point expectedClosest) { var kEpsilon = 1e-10; x = S2Point.Normalize(x); a = S2Point.Normalize(a); b = S2Point.Normalize(b); expectedClosest = S2Point.Normalize(expectedClosest); assertEquals(distanceRadians, S2EdgeUtil.GetDistance(x, a, b).Radians, kEpsilon); var closest = S2EdgeUtil.GetClosestPoint(x, a, b); if (expectedClosest.Equals(new S2Point(0, 0, 0))) { // This special value says that the result should be A or B. assertTrue(closest == a || closest == b); } else { assertTrue(S2.ApproxEquals(closest, expectedClosest)); } }
/** * A relatively expensive calculation invoked by RobustCCW() if the sign of * the determinant is uncertain. */ private static int ExpensiveCcw(S2Point a, S2Point b, S2Point c) { // Return zero if and only if two points are the same. This ensures (1). if (a.Equals(b) || b.Equals(c) || c.Equals(a)) { return 0; } // Now compute the determinant in a stable way. Since all three points are // unit length and we know that the determinant is very close to zero, this // means that points are very nearly colinear. Furthermore, the most common // situation is where two points are nearly identical or nearly antipodal. // To get the best accuracy in this situation, it is important to // immediately reduce the magnitude of the arguments by computing either // A+B or A-B for each pair of points. Note that even if A and B differ // only in their low bits, A-B can be computed very accurately. On the // other hand we can't accurately represent an arbitrary linear combination // of two vectors as would be required for Gaussian elimination. The code // below chooses the vertex opposite the longest edge as the "origin" for // the calculation, and computes the different vectors to the other two // vertices. This minimizes the sum of the lengths of these vectors. // // This implementation is very stable numerically, but it still does not // return consistent results in all cases. For example, if three points are // spaced far apart from each other along a great circle, the sign of the // result will basically be random (although it will still satisfy the // conditions documented in the header file). The only way to return // consistent results in all cases is to compute the result using // arbitrary-precision arithmetic. I considered using the Gnu MP library, // but this would be very expensive (up to 2000 bits of precision may be // needed to store the intermediate results) and seems like overkill for // this problem. The MP library is apparently also quite particular about // compilers and compilation options and would be a pain to maintain. // We want to handle the case of nearby points and nearly antipodal points // accurately, so determine whether A+B or A-B is smaller in each case. double sab = (a.DotProd(b) > 0) ? -1 : 1; double sbc = (b.DotProd(c) > 0) ? -1 : 1; double sca = (c.DotProd(a) > 0) ? -1 : 1; var vab = a + (b * sab); var vbc = b + (c * sbc); var vca = c + (a * sca); var dab = vab.Norm2; var dbc = vbc.Norm2; var dca = vca.Norm2; // Sort the difference vectors to find the longest edge, and use the // opposite vertex as the origin. If two difference vectors are the same // length, we break ties deterministically to ensure that the symmetry // properties guaranteed in the header file will be true. double sign; if (dca < dbc || (dca == dbc && a < b)) { if (dab < dbc || (dab == dbc && a < c)) { // The "sab" factor converts A +/- B into B +/- A. sign = S2Point.CrossProd(vab, vca).DotProd(a)*sab; // BC is longest // edge } else { sign = S2Point.CrossProd(vca, vbc).DotProd(c)*sca; // AB is longest // edge } } else { if (dab < dca || (dab == dca && b < c)) { sign = S2Point.CrossProd(vbc, vab).DotProd(b)*sbc; // CA is longest // edge } else { sign = S2Point.CrossProd(vca, vbc).DotProd(c)*sca; // AB is longest // edge } } if (sign > 0) { return 1; } if (sign < 0) { return -1; } // The points A, B, and C are numerically indistinguishable from coplanar. // This may be due to roundoff error, or the points may in fact be exactly // coplanar. We handle this situation by perturbing all of the points by a // vector (eps, eps**2, eps**3) where "eps" is an infinitesmally small // positive number (e.g. 1 divided by a googolplex). The perturbation is // done symbolically, i.e. we compute what would happen if the points were // perturbed by this amount. It turns out that this is equivalent to // checking whether the points are ordered CCW around the origin first in // the Y-Z plane, then in the Z-X plane, and then in the X-Y plane. var ccw = PlanarOrderedCcw(new R2Vector(a.Y, a.Z), new R2Vector(b.Y, b.Z), new R2Vector(c.Y, c.Z)); if (ccw == 0) { ccw = PlanarOrderedCcw(new R2Vector(a.Z, a.X), new R2Vector(b.Z, b.X), new R2Vector(c.Z, c.X)); if (ccw == 0) { ccw = PlanarOrderedCcw( new R2Vector(a.X, a.Y), new R2Vector(b.X, b.Y), new R2Vector(c.X, c.Y)); // assert (ccw != 0); } } return ccw; }
/** * Given two edge chains (see WedgeRelation above), this function returns +1 * if A contains B, 0 if A and B are disjoint, and -1 if A intersects but * does not contain B. */ public int Test(S2Point a0, S2Point ab1, S2Point a2, S2Point b0, S2Point b2) { // This is similar to WedgeContainsOrCrosses, except that we want to // distinguish cases (1) [A contains B], (3) [A and B are disjoint], // and (2,4,5,6) [A intersects but does not contain B]. if (S2.OrderedCcw(a0, a2, b2, ab1)) { // We are in case 1, 5, or 6, or case 2 if a2 == b2. return S2.OrderedCcw(b2, b0, a0, ab1) ? 1 : -1; // Case 1 vs. 2,5,6. } // We are in cases 2, 3, or 4. if (!S2.OrderedCcw(a2, b0, b2, ab1)) { return 0; // Case 3. } // We are in case 2 or 4, or case 3 if a2 == b0. return (a2.Equals(b0)) ? 0 : -1; // Case 3 vs. 2,4. }
/** * Given two edge chains (see WedgeRelation above), this function returns +1 * if A contains B, 0 if B contains A or the two wedges do not intersect, * and -1 if the edge chains A and B cross each other (i.e. if A intersects * both the interior and exterior of the region to the left of B). In * degenerate cases where more than one of these conditions is satisfied, * the maximum possible result is returned. For example, if A == B then the * result is +1. */ public int Test(S2Point a0, S2Point ab1, S2Point a2, S2Point b0, S2Point b2) { // There are 6 possible edge orderings at a shared vertex (all // of these orderings are circular, i.e. abcd == bcda): // // (1) a2 b2 b0 a0: A contains B // (2) a2 a0 b0 b2: B contains A // (3) a2 a0 b2 b0: A and B are disjoint // (4) a2 b0 a0 b2: A and B intersect in one wedge // (5) a2 b2 a0 b0: A and B intersect in one wedge // (6) a2 b0 b2 a0: A and B intersect in two wedges // // In cases (4-6), the boundaries of A and B cross (i.e. the boundary // of A intersects the interior and exterior of B and vice versa). // Thus we want to distinguish cases (1), (2-3), and (4-6). // // Note that the vertices may satisfy more than one of the edge // orderings above if two or more vertices are the same. The tests // below are written so that we take the most favorable // interpretation, i.e. preferring (1) over (2-3) over (4-6). In // particular note that if orderedCCW(a,b,c,o) returns true, it may be // possible that orderedCCW(c,b,a,o) is also true (if a == b or b == c). if (S2.OrderedCcw(a0, a2, b2, ab1)) { // The cases with this vertex ordering are 1, 5, and 6, // although case 2 is also possible if a2 == b2. if (S2.OrderedCcw(b2, b0, a0, ab1)) { return 1; // Case 1 (A contains B) } // We are in case 5 or 6, or case 2 if a2 == b2. return (a2.Equals(b2)) ? 0 : -1; // Case 2 vs. 5,6. } // We are in case 2, 3, or 4. return S2.OrderedCcw(a0, b0, a2, ab1) ? 0 : -1; // Case 2,3 vs. 4. }
/** * Given a point X and an edge AB, return the distance ratio AX / (AX + BX). * If X happens to be on the line segment AB, this is the fraction "t" such * that X == Interpolate(A, B, t). Requires that A and B are distinct. */ public static double GetDistanceFraction(S2Point x, S2Point a0, S2Point a1) { Preconditions.CheckArgument(!a0.Equals(a1)); var d0 = x.Angle(a0); var d1 = x.Angle(a1); return d0/(d0 + d1); }
/** * Given two edges AB and CD where at least two vertices are identical (i.e. * robustCrossing(a,b,c,d) == 0), this function defines whether the two edges * "cross" in a such a way that point-in-polygon containment tests can be * implemented by counting the number of edge crossings. The basic rule is * that a "crossing" occurs if AB is encountered after CD during a CCW sweep * around the shared vertex starting from a fixed reference point. * * Note that according to this rule, if AB crosses CD then in general CD does * not cross AB. However, this leads to the correct result when counting * polygon edge crossings. For example, suppose that A,B,C are three * consecutive vertices of a CCW polygon. If we now consider the edge * crossings of a segment BP as P sweeps around B, the crossing number changes * parity exactly when BP crosses BA or BC. * * Useful properties of VertexCrossing (VC): * * (1) VC(a,a,c,d) == VC(a,b,c,c) == false (2) VC(a,b,a,b) == VC(a,b,b,a) == * true (3) VC(a,b,c,d) == VC(a,b,d,c) == VC(b,a,c,d) == VC(b,a,d,c) (3) If * exactly one of a,b Equals one of c,d, then exactly one of VC(a,b,c,d) and * VC(c,d,a,b) is true * * It is an error to call this method with 4 distinct vertices. */ public static bool VertexCrossing(S2Point a, S2Point b, S2Point c, S2Point d) { // If A == B or C == D there is no intersection. We need to check this // case first in case 3 or more input points are identical. if (a.Equals(b) || c.Equals(d)) { return false; } // If any other pair of vertices is equal, there is a crossing if and only // if orderedCCW() indicates that the edge AB is further CCW around the // shared vertex than the edge CD. if (a.Equals(d)) { return S2.OrderedCcw(S2.Ortho(a), c, b, a); } if (b.Equals(c)) { return S2.OrderedCcw(S2.Ortho(b), d, a, b); } if (a.Equals(c)) { return S2.OrderedCcw(S2.Ortho(a), d, b, a); } if (b.Equals(d)) { return S2.OrderedCcw(S2.Ortho(b), c, a, b); } // assert (false); return false; }
// Given a point X and an edge AB, check that the distance from X to AB is // "distanceRadians" and the closest point on AB is "expectedClosest". private static void checkDistance( S2Point x, S2Point a, S2Point b, double distanceRadians, S2Point expectedClosest) { var kEpsilon = 1e-10; x = S2Point.Normalize(x); a = S2Point.Normalize(a); b = S2Point.Normalize(b); expectedClosest = S2Point.Normalize(expectedClosest); assertEquals(distanceRadians, S2EdgeUtil.GetDistance(x, a, b).Radians, kEpsilon); var closest = S2EdgeUtil.GetClosestPoint(x, a, b); if (expectedClosest.Equals(new S2Point(0, 0, 0))) { // This special value says that the result should be A or B. assertTrue(closest == a || closest == b); } else { assertTrue(S2.ApproxEquals(closest, expectedClosest)); } }