@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/s2/s2edge_clipping.h

@@ -0,0 +1,183 @@
+// Copyright 2005 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+//
+// Defines a collection of functions for:
+//
+//   (1) Robustly clipping geodesic edges to the faces of the S2 biunit cube
+//       (see s2coords.h), and
+//
+//   (2) Robustly clipping 2D edges against 2D rectangles.
+//
+// These functions can be used to efficiently find the set of S2CellIds that
+// are intersected by a geodesic edge (e.g., see S2CrossingEdgeQuery).
+
+#ifndef S2_S2EDGE_CLIPPING_H_
+#define S2_S2EDGE_CLIPPING_H_
+
+#include <cmath>
+
+#include "s2/base/logging.h"
+#include "s2/third_party/absl/container/inlined_vector.h"
+#include "s2/_fp_contract_off.h"
+#include "s2/r2.h"
+#include "s2/r2rect.h"
+#include "s2/s2point.h"
+
+namespace S2 {
+
+// FaceSegment represents an edge AB clipped to an S2 cube face.  It is
+// represented by a face index and a pair of (u,v) coordinates.
+struct FaceSegment {
+  int face;
+  R2Point a, b;
+};
+using FaceSegmentVector = absl::InlinedVector<FaceSegment, 6>;
+
+// Subdivides the given edge AB at every point where it crosses the boundary
+// between two S2 cube faces and returns the corresponding FaceSegments.  The
+// segments are returned in order from A toward B.  The input points must be
+// unit length.
+//
+// This method guarantees that the returned segments form a continuous path
+// from A to B, and that all vertices are within kFaceClipErrorUVDist of the
+// line AB.  All vertices lie within the [-1,1]x[-1,1] cube face rectangles.
+// The results are consistent with s2pred::Sign(), i.e. the edge is
+// well-defined even its endpoints are antipodal.  [TODO(ericv): Extend the
+// implementation of S2::RobustCrossProd so that this statement is true.]
+void GetFaceSegments(const S2Point& a, const S2Point& b,
+                     FaceSegmentVector* segments);
+
+// Given an edge AB and a face, returns the (u,v) coordinates for the portion
+// of AB that intersects that face.  This method guarantees that the clipped
+// vertices lie within the [-1,1]x[-1,1] cube face rectangle and are within
+// kFaceClipErrorUVDist of the line AB, but the results may differ from
+// those produced by GetFaceSegments.  Returns false if AB does not
+// intersect the given face.
+bool ClipToFace(const S2Point& a, const S2Point& b, int face,
+                R2Point* a_uv, R2Point* b_uv);
+
+// Like ClipToFace, but rather than clipping to the square [-1,1]x[-1,1]
+// in (u,v) space, this method clips to [-R,R]x[-R,R] where R=(1+padding).
+bool ClipToPaddedFace(const S2Point& a, const S2Point& b, int face,
+                      double padding, R2Point* a_uv, R2Point* b_uv);
+
+// The maximum error in the vertices returned by GetFaceSegments and
+// ClipToFace (compared to an exact calculation):
+//
+//  - kFaceClipErrorRadians is the maximum angle between a returned vertex
+//    and the nearest point on the exact edge AB.  It is equal to the
+//    maximum directional error in S2::RobustCrossProd, plus the error when
+//    projecting points onto a cube face.
+//
+//  - kFaceClipErrorDist is the same angle expressed as a maximum distance
+//    in (u,v)-space.  In other words, a returned vertex is at most this far
+//    from the exact edge AB projected into (u,v)-space.
+
+//  - kFaceClipErrorUVCoord is the same angle expressed as the maximum error
+//    in an individual u- or v-coordinate.  In other words, for each
+//    returned vertex there is a point on the exact edge AB whose u- and
+//    v-coordinates differ from the vertex by at most this amount.
+
+extern const double kFaceClipErrorRadians;
+extern const double kFaceClipErrorUVDist;
+extern const double kFaceClipErrorUVCoord;
+
+// Returns true if the edge AB intersects the given (closed) rectangle to
+// within the error bound below.
+bool IntersectsRect(const R2Point& a, const R2Point& b, const R2Rect& rect);
+
+// The maximum error in IntersectRect.  If some point of AB is inside the
+// rectangle by at least this distance, the result is guaranteed to be true;
+// if all points of AB are outside the rectangle by at least this distance,
+// the result is guaranteed to be false.  This bound assumes that "rect" is
+// a subset of the rectangle [-1,1]x[-1,1] or extends slightly outside it
+// (e.g., by 1e-10 or less).
+extern const double kIntersectsRectErrorUVDist;
+
+// Given an edge AB, returns the portion of AB that is contained by the given
+// rectangle "clip".  Returns false if there is no intersection.
+bool ClipEdge(const R2Point& a, const R2Point& b, const R2Rect& clip,
+              R2Point* a_clipped, R2Point* b_clipped);
+
+// Given an edge AB and a rectangle "clip", returns the bounding rectangle of
+// the portion of AB intersected by "clip".  The resulting bound may be
+// empty.  This is a convenience function built on top of ClipEdgeBound.
+R2Rect GetClippedEdgeBound(const R2Point& a, const R2Point& b,
+                           const R2Rect& clip);
+
+// This function can be used to clip an edge AB to sequence of rectangles
+// efficiently.  It represents the clipped edges by their bounding boxes
+// rather than as a pair of endpoints.  Specifically, let A'B' be some
+// portion of an edge AB, and let "bound" be a tight bound of A'B'.  This
+// function updates "bound" (in place) to be a tight bound of A'B'
+// intersected with a given rectangle "clip".  If A'B' does not intersect
+// "clip", returns false and does not necessarily update "bound".
+//
+// REQUIRES: "bound" is a tight bounding rectangle for some portion of AB.
+// (This condition is automatically satisfied if you start with the bounding
+// box of AB and clip to a sequence of rectangles, stopping when the method
+// returns false.)
+bool ClipEdgeBound(const R2Point& a, const R2Point& b,
+                   const R2Rect& clip, R2Rect* bound);
+
+// The maximum error in the vertices generated by ClipEdge and the bounds
+// generated by ClipEdgeBound (compared to an exact calculation):
+//
+//  - kEdgeClipErrorUVCoord is the maximum error in a u- or v-coordinate
+//    compared to the exact result, assuming that the points A and B are in
+//    the rectangle [-1,1]x[1,1] or slightly outside it (by 1e-10 or less).
+//
+//  - kEdgeClipErrorUVDist is the maximum distance from a clipped point to
+//    the corresponding exact result.  It is equal to the error in a single
+//    coordinate because at most one coordinate is subject to error.
+
+extern const double kEdgeClipErrorUVCoord;
+extern const double kEdgeClipErrorUVDist;
+
+// Given a value x that is some linear combination of a and b, returns the
+// value x1 that is the same linear combination of a1 and b1.  This function
+// makes the following guarantees:
+//  - If x == a, then x1 = a1 (exactly).
+//  - If x == b, then x1 = b1 (exactly).
+//  - If a <= x <= b, then a1 <= x1 <= b1 (even if a1 == b1).
+// REQUIRES: a != b
+double InterpolateDouble(double x, double a, double b, double a1, double b1);
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+inline bool ClipToFace(const S2Point& a, const S2Point& b, int face,
+                       R2Point* a_uv, R2Point* b_uv) {
+  return ClipToPaddedFace(a, b, face, 0.0, a_uv, b_uv);
+}
+
+inline double InterpolateDouble(double x, double a, double b,
+                                double a1, double b1) {
+  S2_DCHECK_NE(a, b);
+  // To get results that are accurate near both A and B, we interpolate
+  // starting from the closer of the two points.
+  if (std::fabs(a - x) <= std::fabs(b - x)) {
+    return a1 + (b1 - a1) * (x - a) / (b - a);
+  } else {
+    return b1 + (a1 - b1) * (x - b) / (a - b);
+  }
+}
+
+}  // namespace S2
+
+#endif  // S2_S2EDGE_CLIPPING_H_

package/third_party/s2geometry/src/s2/s2edge_clipping_test.cc

@@ -0,0 +1,335 @@
+// Copyright 2005 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s2edge_clipping.h"
+
+#include <algorithm>
+#include <cfloat>
+#include <cmath>
+#include <string>
+
+#include "s2/base/logging.h"
+#include <gtest/gtest.h>
+#include "s2/third_party/absl/strings/str_cat.h"
+#include "s2/r1interval.h"
+#include "s2/r2rect.h"
+#include "s2/s1chord_angle.h"
+#include "s2/s1interval.h"
+#include "s2/s2coords.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2testing.h"
+
+using absl::StrCat;
+using std::fabs;
+using std::max;
+
+void TestFaceClipping(const S2Point& a_raw, const S2Point& b_raw) {
+  S2Point a = a_raw.Normalize();
+  S2Point b = b_raw.Normalize();
+  // TODO(ericv): Remove the following line once S2::RobustCrossProd is
+  // extended to use simulation of simplicity.
+  if (a == -b) return;
+
+  // First we test GetFaceSegments.
+  S2::FaceSegmentVector segments;
+  S2::GetFaceSegments(a, b, &segments);
+  int n = segments.size();
+  EXPECT_GE(n, 1);
+
+  ::testing::Message msg;
+  msg << "\nA=" << a_raw << "\nB=" << b_raw;
+  msg << "\nN=" << S2::RobustCrossProd(a, b) << "\nSegments:\n";
+  int i = 0;
+  for (const S2::FaceSegment& s : segments) {
+    msg << i++ << ": face=" << s.face << ", a=" << s.a << ", b=" << s.b << "\n";
+  }
+  SCOPED_TRACE(msg);
+
+  R2Rect biunit(R1Interval(-1, 1), R1Interval(-1, 1));
+  const double kErrorRadians = S2::kFaceClipErrorRadians;
+
+  // The first and last vertices should approximately equal A and B.
+  EXPECT_LE(a.Angle(S2::FaceUVtoXYZ(segments[0].face, segments[0].a)),
+            kErrorRadians);
+  EXPECT_LE(b.Angle(S2::FaceUVtoXYZ(segments[n-1].face, segments[n-1].b)),
+            kErrorRadians);
+
+  S2Point norm = S2::RobustCrossProd(a, b).Normalize();
+  S2Point a_tangent = norm.CrossProd(a);
+  S2Point b_tangent = b.CrossProd(norm);
+  for (int i = 0; i < n; ++i) {
+    // Vertices may not protrude outside the biunit square.
+    EXPECT_TRUE(biunit.Contains(segments[i].a));
+    EXPECT_TRUE(biunit.Contains(segments[i].b));
+    if (i == 0) continue;
+
+    // The two representations of each interior vertex (on adjacent faces)
+    // must correspond to exactly the same S2Point.
+    EXPECT_NE(segments[i-1].face, segments[i].face);
+    EXPECT_EQ(S2::FaceUVtoXYZ(segments[i-1].face, segments[i-1].b),
+              S2::FaceUVtoXYZ(segments[i].face, segments[i].a));
+
+    // Interior vertices should be in the plane containing A and B, and should
+    // be contained in the wedge of angles between A and B (i.e., the dot
+    // products with a_tangent and b_tangent should be non-negative).
+    S2Point p = S2::FaceUVtoXYZ(segments[i].face, segments[i].a).Normalize();
+    EXPECT_LE(fabs(p.DotProd(norm)), kErrorRadians);
+    EXPECT_GE(p.DotProd(a_tangent), -kErrorRadians);
+    EXPECT_GE(p.DotProd(b_tangent), -kErrorRadians);
+  }
+
+  // Now we test ClipToPaddedFace (sometimes with a padding of zero).  We do
+  // this by defining an (x,y) coordinate system for the plane containing AB,
+  // and converting points along the great circle AB to angles in the range
+  // [-Pi, Pi].  We then accumulate the angle intervals spanned by each
+  // clipped edge; the union over all 6 faces should approximately equal the
+  // interval covered by the original edge.
+  S2Testing::Random* rnd = &S2Testing::rnd;
+  double padding = rnd->OneIn(10) ? 0.0 : 1e-10 * pow(1e-5, rnd->RandDouble());
+  S2Point x_axis = a, y_axis = a_tangent;
+  S1Interval expected_angles(0, a.Angle(b));
+  S1Interval max_angles = expected_angles.Expanded(kErrorRadians);
+  S1Interval actual_angles;
+  for (int face = 0; face < 6; ++face) {
+    R2Point a_uv, b_uv;
+    if (S2::ClipToPaddedFace(a, b, face, padding, &a_uv, &b_uv)) {
+      S2Point a_clip = S2::FaceUVtoXYZ(face, a_uv).Normalize();
+      S2Point b_clip = S2::FaceUVtoXYZ(face, b_uv).Normalize();
+      EXPECT_LE(fabs(a_clip.DotProd(norm)), kErrorRadians);
+      EXPECT_LE(fabs(b_clip.DotProd(norm)), kErrorRadians);
+      if (a_clip.Angle(a) > kErrorRadians) {
+        EXPECT_DOUBLE_EQ(1 + padding, max(fabs(a_uv[0]), fabs(a_uv[1])));
+      }
+      if (b_clip.Angle(b) > kErrorRadians) {
+        EXPECT_DOUBLE_EQ(1 + padding, max(fabs(b_uv[0]), fabs(b_uv[1])));
+      }
+      double a_angle = atan2(a_clip.DotProd(y_axis), a_clip.DotProd(x_axis));
+      double b_angle = atan2(b_clip.DotProd(y_axis), b_clip.DotProd(x_axis));
+      // Rounding errors may cause b_angle to be slightly less than a_angle.
+      // We handle this by constructing the interval with FromPointPair(),
+      // which is okay since the interval length is much less than M_PI.
+      S1Interval face_angles = S1Interval::FromPointPair(a_angle, b_angle);
+      EXPECT_TRUE(max_angles.Contains(face_angles));
+      actual_angles = actual_angles.Union(face_angles);
+    }
+  }
+  EXPECT_TRUE(actual_angles.Expanded(kErrorRadians).Contains(expected_angles));
+}
+
+void TestFaceClippingEdgePair(const S2Point& a, const S2Point& b) {
+  TestFaceClipping(a, b);
+  TestFaceClipping(b, a);
+}
+
+// This function is designed to choose line segment endpoints that are difficult
+// to handle correctly.  Given two adjacent cube vertices P and Q, it returns
+// either an edge midpoint, face midpoint, or corner vertex along the edge PQ
+// and then perturbs it slightly.  It also sometimes returns a random point from
+// anywhere on the sphere.
+S2Point PerturbedCornerOrMidpoint(const S2Point& p, const S2Point& q) {
+  S2Testing::Random* rnd = &S2Testing::rnd;
+  S2Point a = (rnd->Uniform(3) - 1) * p + (rnd->Uniform(3) - 1) * q;
+  if (rnd->OneIn(10)) {
+    // This perturbation often has no effect except on coordinates that are
+    // zero, in which case the perturbed value is so small that operations on
+    // it often result in underflow.
+    a += pow(1e-300, rnd->RandDouble()) * S2Testing::RandomPoint();
+  } else if (rnd->OneIn(2)) {
+    // For coordinates near 1 (say > 0.5), this perturbation yields values
+    // that are only a few representable values away from the initial value.
+    a += 4 * DBL_EPSILON * S2Testing::RandomPoint();
+  } else {
+    // A perturbation whose magnitude is in the range [1e-25, 1e-10].
+    a += 1e-10 * pow(1e-15, rnd->RandDouble()) * S2Testing::RandomPoint();
+  }
+  if (a.Norm2() < DBL_MIN) {
+    // If a.Norm2() is denormalized, Normalize() loses too much precision.
+    return PerturbedCornerOrMidpoint(p, q);
+  }
+  return a;
+}
+
+TEST(S2EdgeUtil, FaceClipping) {
+  // Start with a few simple cases.
+  // An edge that is entirely contained within one cube face:
+  TestFaceClippingEdgePair(S2Point(1, -0.5, -0.5), S2Point(1, 0.5, 0.5));
+  // An edge that crosses one cube edge:
+  TestFaceClippingEdgePair(S2Point(1, 0, 0), S2Point(0, 1, 0));
+  // An edge that crosses two opposite edges of face 0:
+  TestFaceClippingEdgePair(S2Point(0.75, 0, -1), S2Point(0.75, 0, 1));
+  // An edge that crosses two adjacent edges of face 2:
+  TestFaceClippingEdgePair(S2Point(1, 0, 0.75), S2Point(0, 1, 0.75));
+  // An edge that crosses three cube edges (four faces):
+  TestFaceClippingEdgePair(S2Point(1, 0.9, 0.95), S2Point(-1, 0.95, 0.9));
+
+  // Comprehensively test edges that are difficult to handle, especially those
+  // that nearly follow one of the 12 cube edges.
+  S2Testing::Random* rnd = &S2Testing::rnd;
+  R2Rect biunit(R1Interval(-1, 1), R1Interval(-1, 1));
+  const int kIters = 1000;  // Test passes with 1e6 iterations
+  for (int iter = 0; iter < kIters; ++iter) {
+    SCOPED_TRACE(StrCat("Iteration ", iter));
+    // Choose two adjacent cube corners P and Q.
+    int face = rnd->Uniform(6);
+    int i = rnd->Uniform(4);
+    int j = (i + 1) & 3;
+    S2Point p = S2::FaceUVtoXYZ(face, biunit.GetVertex(i));
+    S2Point q = S2::FaceUVtoXYZ(face, biunit.GetVertex(j));
+
+    // Now choose two points that are nearly on the edge PQ, preferring points
+    // that are near cube corners, face midpoints, or edge midpoints.
+    S2Point a = PerturbedCornerOrMidpoint(p, q);
+    S2Point b = PerturbedCornerOrMidpoint(p, q);
+    TestFaceClipping(a, b);
+  }
+}
+
+// Choose a random point in the rectangle defined by points A and B, sometimes
+// returning a point on the edge AB or the points A and B themselves.
+R2Point ChooseRectPoint(const R2Point& a, const R2Point& b) {
+  S2Testing::Random* rnd = &S2Testing::rnd;
+  if (rnd->OneIn(5)) {
+    return rnd->OneIn(2) ? a : b;
+  } else if (rnd->OneIn(3)) {
+    return a + rnd->RandDouble() * (b - a);
+  } else {
+    // a[i] may be >, <, or == b[i], so we write it like this instead
+    // of using UniformDouble.
+    return R2Point(a[0] + rnd->RandDouble() * (b[0] - a[0]),
+                   a[1] + rnd->RandDouble() * (b[1] - a[1]));
+  }
+}
+
+// Given a point X on the line AB (which is checked), return the fraction "t"
+// such that x = (1-t)*a + t*b.  Return 0 if A = B.
+double GetFraction(const R2Point& x, const R2Point& a, const R2Point& b) {
+  // A bound for the error in edge clipping plus the error in the calculation
+  // below (which is similar to IntersectsRect).
+  const double kError = (S2::kEdgeClipErrorUVDist +
+                         S2::kIntersectsRectErrorUVDist);
+  if (a == b) return 0.0;
+  R2Point dir = (b - a).Normalize();
+  EXPECT_LE(fabs((x - a).DotProd(dir.Ortho())), kError);
+  return (x - a).DotProd(dir);
+}
+
+// Given a point P representing a possibly clipped endpoint A of an edge AB,
+// verify that "clip" contains P, and that if clipping occurred (i.e., P != A)
+// then P is on the boundary of "clip".
+void CheckPointOnBoundary(const R2Point& p, const R2Point& a,
+                          const R2Rect& clip) {
+  EXPECT_TRUE(clip.Contains(p));
+  if (p != a) {
+    EXPECT_FALSE(clip.Contains(R2Point(nextafter(p[0], a[0]),
+                                       nextafter(p[1], a[1]))));
+  }
+}
+
+// Given an edge AB and a rectangle "clip", verify that IntersectsRect(),
+// ClipEdge(), and ClipEdgeBound() produce consistent results.
+void TestClipEdge(const R2Point& a, const R2Point& b, const R2Rect& clip) {
+  // A bound for the error in edge clipping plus the error in the
+  // IntersectsRect calculation below.
+  const double kError = (S2::kEdgeClipErrorUVDist +
+                         S2::kIntersectsRectErrorUVDist);
+  R2Point a_clipped, b_clipped;
+  if (!S2::ClipEdge(a, b, clip, &a_clipped, &b_clipped)) {
+    EXPECT_FALSE(S2::IntersectsRect(a, b, clip.Expanded(-kError)));
+  } else {
+    EXPECT_TRUE(S2::IntersectsRect(a, b, clip.Expanded(kError)));
+    // Check that the clipped points lie on the edge AB, and that the points
+    // have the expected order along the segment AB.
+    EXPECT_LE(GetFraction(a_clipped, a, b), GetFraction(b_clipped, a, b));
+    // Check that the clipped portion of AB is as large as possible.
+    CheckPointOnBoundary(a_clipped, a, clip);
+    CheckPointOnBoundary(b_clipped, b, clip);
+  }
+  // Choose a random initial bound to pass to ClipEdgeBound.
+  R2Rect initial_clip = R2Rect::FromPointPair(ChooseRectPoint(a, b),
+                                              ChooseRectPoint(a, b));
+  R2Rect bound = S2::GetClippedEdgeBound(a, b, initial_clip);
+  if (bound.is_empty()) return;  // Precondition of ClipEdgeBound not met
+  R2Rect max_bound = bound.Intersection(clip);
+  if (!S2::ClipEdgeBound(a, b, clip, &bound)) {
+    EXPECT_FALSE(S2::IntersectsRect(a, b, max_bound.Expanded(-kError)));
+  } else {
+    EXPECT_TRUE(S2::IntersectsRect(a, b, max_bound.Expanded(kError)));
+    // Check that the bound is as large as possible.
+    int ai = (a[0] > b[0]), aj = (a[1] > b[1]);
+    CheckPointOnBoundary(bound.GetVertex(ai, aj), a, max_bound);
+    CheckPointOnBoundary(bound.GetVertex(1-ai, 1-aj), b, max_bound);
+  }
+}
+
+// Given an interval "clip", randomly choose either a value in the interval, a
+// value outside the interval, or one of the two interval endpoints, ensuring
+// that all cases have reasonable probability for any interval "clip".
+double ChooseEndpoint(const R1Interval& clip) {
+  S2Testing::Random* rnd = &S2Testing::rnd;
+  if (rnd->OneIn(5)) {
+    return rnd->OneIn(2) ? clip.lo() : clip.hi();
+  } else {
+    switch (rnd->Uniform(3)) {
+      case 0:  return clip.lo() - rnd->RandDouble();
+      case 1:  return clip.hi() + rnd->RandDouble();
+      default: return clip.lo() + rnd->RandDouble() * clip.GetLength();
+    }
+  }
+}
+
+// Given a rectangle "clip", choose a point that may lie in the rectangle
+// interior, along an extended edge, exactly at a vertex, or in one of the
+// eight regions exterior to "clip" that are separated by its extended edges.
+// Also sometimes return points that are exactly on one of the extended
+// diagonals of "clip".  All cases are reasonably likely to occur for any
+// given rectangle "clip".
+R2Point ChooseEndpoint(const R2Rect& clip) {
+  if (S2Testing::rnd.OneIn(10)) {
+    // Return a point on one of the two extended diagonals.
+    int diag = S2Testing::rnd.Uniform(2);
+    double t = S2Testing::rnd.UniformDouble(-1, 2);
+    return (1 - t) * clip.GetVertex(diag) + t * clip.GetVertex(diag + 2);
+  } else {
+    return R2Point(ChooseEndpoint(clip[0]), ChooseEndpoint(clip[1]));
+  }
+}
+
+// Given a rectangle "clip", test the S2EdgeUtil edge clipping methods using
+// many edges that are randomly constructed to trigger special cases.
+void TestEdgeClipping(const R2Rect& clip) {
+  const int kIters = 1000;  // Test passes with 1e6 iterations
+  for (int iter = 0; iter < kIters; ++iter) {
+    SCOPED_TRACE(StrCat("Iteration ", iter));
+    TestClipEdge(ChooseEndpoint(clip), ChooseEndpoint(clip), clip);
+  }
+}
+
+TEST(S2EdgeUtil, EdgeClipping) {
+  S2Testing::Random* rnd = &S2Testing::rnd;
+  // Test clipping against random rectangles.
+  for (int i = 0; i < 5; ++i) {
+    TestEdgeClipping(R2Rect::FromPointPair(
+        R2Point(rnd->UniformDouble(-1, 1), rnd->UniformDouble(-1, 1)),
+        R2Point(rnd->UniformDouble(-1, 1), rnd->UniformDouble(-1, 1))));
+  }
+  // Also clip against one-dimensional, singleton, and empty rectangles.
+  TestEdgeClipping(R2Rect(R1Interval(-0.7, -0.7), R1Interval(0.3, 0.35)));
+  TestEdgeClipping(R2Rect(R1Interval(0.2, 0.5), R1Interval(0.3, 0.3)));
+  TestEdgeClipping(R2Rect(R1Interval(-0.7, 0.3), R1Interval(0, 0)));
+  TestEdgeClipping(R2Rect::FromPoint(R2Point(0.3, 0.8)));
+  TestEdgeClipping(R2Rect::Empty());
+}

package/third_party/s2geometry/src/s2/s2edge_crosser.cc

@@ -0,0 +1,85 @@
+// Copyright 2005 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s2edge_crosser.h"
+
+#include "s2/base/logging.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2predicates.h"
+
+int S2EdgeCrosser::CrossingSignInternal(const S2Point* d) {
+  // Compute the actual result, and then save the current vertex D as the next
+  // vertex C, and save the orientation of the next triangle ACB (which is
+  // opposite to the current triangle BDA).
+  int result = CrossingSignInternal2(*d);
+  c_ = d;
+  acb_ = -bda_;
+  return result;
+}
+
+inline int S2EdgeCrosser::CrossingSignInternal2(const S2Point& d) {
+  // At this point, a very common situation is that A,B,C,D are four points on
+  // a line such that AB does not overlap CD.  (For example, this happens when
+  // a line or curve is sampled finely, or when geometry is constructed by
+  // computing the union of S2CellIds.)  Most of the time, we can determine
+  // that AB and CD do not intersect by computing the two outward-facing
+  // tangents at A and B (parallel to AB) and testing whether AB and CD are on
+  // opposite sides of the plane perpendicular to one of these tangents.  This
+  // is moderately expensive but still much cheaper than s2pred::ExpensiveSign.
+  if (!have_tangents_) {
+    S2Point norm = S2::RobustCrossProd(*a_, *b_).Normalize();
+    a_tangent_ = a_->CrossProd(norm);
+    b_tangent_ = norm.CrossProd(*b_);
+    have_tangents_ = true;
+  }
+  // The error in RobustCrossProd() is insignificant.  The maximum error in
+  // the call to CrossProd() (i.e., the maximum norm of the error vector) is
+  // (0.5 + 1/sqrt(3)) * DBL_EPSILON.  The maximum error in each call to
+  // DotProd() below is DBL_EPSILON.  (There is also a small relative error
+  // term that is insignificant because we are comparing the result against a
+  // constant that is very close to zero.)
+  static const double kError = (1.5 + 1/sqrt(3)) * DBL_EPSILON;
+  if ((c_->DotProd(a_tangent_) > kError && d.DotProd(a_tangent_) > kError) ||
+      (c_->DotProd(b_tangent_) > kError && d.DotProd(b_tangent_) > kError)) {
+    return -1;
+  }
+
+  // Otherwise, eliminate the cases where two vertices from different edges
+  // are equal.  (These cases could be handled in the code below, but we would
+  // rather avoid calling ExpensiveSign whenever possible.)
+  if (*a_ == *c_ || *a_ == d || *b_ == *c_ || *b_ == d) return 0;
+
+  // Eliminate cases where an input edge is degenerate.  (Note that in most
+  // cases, if CD is degenerate then this method is not even called because
+  // acb_ and bda have different signs.)
+  if (*a_ == *b_ || *c_ == d) return -1;
+
+  // Otherwise it's time to break out the big guns.
+  if (acb_ == 0) acb_ = -s2pred::ExpensiveSign(*a_, *b_, *c_);
+  S2_DCHECK_NE(acb_, 0);
+  if (bda_ == 0) bda_ = s2pred::ExpensiveSign(*a_, *b_, d);
+  S2_DCHECK_NE(bda_, 0);
+  if (bda_ != acb_) return -1;
+
+  Vector3_d c_cross_d = c_->CrossProd(d);
+  int cbd = -s2pred::Sign(*c_, d, *b_, c_cross_d);
+  S2_DCHECK_NE(cbd, 0);
+  if (cbd != acb_) return -1;
+  int dac = s2pred::Sign(*c_, d, *a_, c_cross_d);
+  S2_DCHECK_NE(dac, 0);
+  return (dac != acb_) ? -1 : 1;
+}