@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,343 @@
+// 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)
+
+#ifndef S2_S2EDGE_CROSSER_H_
+#define S2_S2EDGE_CROSSER_H_
+
+#include "s2/base/logging.h"
+#include "s2/_fp_contract_off.h"
+#include "s2/s2edge_crossings.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2predicates.h"
+
+class S2CopyingEdgeCrosser;  // Forward declaration
+
+// This class allows edges to be efficiently tested for intersection with a
+// given fixed edge AB.  It is especially efficient when testing for
+// intersection with an edge chain connecting vertices v0, v1, v2, ...
+//
+// Example usage:
+//
+//   void CountIntersections(const S2Point& a, const S2Point& b,
+//                           const vector<pair<S2Point, S2Point>>& edges) {
+//     int count = 0;
+//     S2EdgeCrosser crosser(&a, &b);
+//     for (const auto& edge : edges) {
+//       if (crosser.CrossingSign(&edge.first, &edge.second) >= 0) {
+//         ++count;
+//       }
+//     }
+//     return count;
+//   }
+//
+// This class expects that the client already has all the necessary vertices
+// stored in memory, so that this class can refer to them with pointers and
+// does not need to make its own copies.  If this is not the case (e.g., you
+// want to pass temporary objects as vertices), see S2CopyingEdgeCrosser.
+class S2EdgeCrosser {
+ public:
+  // Default constructor; must be followed by a call to Init().
+  S2EdgeCrosser() {}
+
+  // Convenience constructor that calls Init() with the given fixed edge AB.
+  // The arguments "a" and "b" must point to values that persist for the
+  // lifetime of the S2EdgeCrosser object (or until the next Init() call).
+  S2EdgeCrosser(const S2Point* a, const S2Point* b);
+
+  // Accessors for the constructor arguments.
+  const S2Point* a() { return a_; }
+  const S2Point* b() { return b_; }
+
+  // Initialize the S2EdgeCrosser with the given fixed edge AB.  The arguments
+  // "a" and "b" must point to values that persist for the lifetime of the
+  // S2EdgeCrosser object (or until the next Init() call).
+  void Init(const S2Point* a, const S2Point* b);
+
+  // This function determines whether the edge AB intersects the edge CD.
+  // Returns +1 if AB crosses CD at a point that is interior to both edges.
+  // Returns  0 if any two vertices from different edges are the same.
+  // Returns -1 otherwise.
+  //
+  // Note that if an edge is degenerate (A == B or C == D), the return value
+  // is 0 if two vertices from different edges are the same and -1 otherwise.
+  //
+  // Properties of CrossingSign:
+  //
+  //  (1) CrossingSign(b,a,c,d) == CrossingSign(a,b,c,d)
+  //  (2) CrossingSign(c,d,a,b) == CrossingSign(a,b,c,d)
+  //  (3) CrossingSign(a,b,c,d) == 0 if a==c, a==d, b==c, b==d
+  //  (3) CrossingSign(a,b,c,d) <= 0 if a==b or c==d (see above)
+  //
+  // This function implements an exact, consistent perturbation model such
+  // that no three points are ever considered to be collinear.  This means
+  // that even if you have 4 points A, B, C, D that lie exactly in a line
+  // (say, around the equator), C and D will be treated as being slightly to
+  // one side or the other of AB.  This is done in a way such that the
+  // results are always consistent (see s2pred::Sign).
+  //
+  // Note that if you want to check an edge against a chain of other edges,
+  // it is slightly more efficient to use the single-argument version of
+  // CrossingSign below.
+  //
+  // The arguments must point to values that persist until the next call.
+  int CrossingSign(const S2Point* c, const S2Point* d);
+
+  // This method extends the concept of a "crossing" to the case where AB
+  // and CD have a vertex in common.  The two edges may or may not cross,
+  // according to the rules defined in VertexCrossing() below.  The rules
+  // are designed so that point containment tests can be implemented simply
+  // by counting edge crossings.  Similarly, determining whether one edge
+  // chain crosses another edge chain can be implemented by counting.
+  //
+  // Returns true if CrossingSign(c, d) > 0, or AB and CD share a vertex
+  // and VertexCrossing(a, b, c, d) returns true.
+  //
+  // The arguments must point to values that persist until the next call.
+  bool EdgeOrVertexCrossing(const S2Point* c, const S2Point* d);
+
+  ///////////////////////// Edge Chain Methods ///////////////////////////
+  //
+  // You don't need to use these unless you're trying to squeeze out every
+  // last drop of performance.  Essentially all you are saving is a test
+  // whether the first vertex of the current edge is the same as the second
+  // vertex of the previous edge.  Example usage:
+  //
+  //   vector<S2Point> chain;
+  //   crosser.RestartAt(&chain[0]);
+  //   for (int i = 1; i < chain.size(); ++i) {
+  //     if (crosser.EdgeOrVertexCrossing(&chain[i])) { ++count; }
+  //   }
+
+  // Convenience constructor that uses AB as the fixed edge, and C as the
+  // first vertex of the vertex chain (equivalent to calling RestartAt(c)).
+  //
+  // The arguments must point to values that persist until the next call.
+  S2EdgeCrosser(const S2Point* a, const S2Point* b, const S2Point* c);
+
+  // Call this method when your chain 'jumps' to a new place.
+  // The argument must point to a value that persists until the next call.
+  void RestartAt(const S2Point* c);
+
+  // Like CrossingSign above, but uses the last vertex passed to one of
+  // the crossing methods (or RestartAt) as the first vertex of the current
+  // edge.
+  //
+  // The argument must point to a value that persists until the next call.
+  int CrossingSign(const S2Point* d);
+
+  // Like EdgeOrVertexCrossing above, but uses the last vertex passed to one
+  // of the crossing methods (or RestartAt) as the first vertex of the
+  // current edge.
+  //
+  // The argument must point to a value that persists until the next call.
+  bool EdgeOrVertexCrossing(const S2Point* d);
+
+  // Returns the last vertex of the current edge chain being tested, i.e. the
+  // C vertex that will be used to construct the edge CD when one of the
+  // methods above is called.
+  const S2Point* c() { return c_; }
+
+ private:
+  friend class S2CopyingEdgeCrosser;
+
+  // These functions handle the "slow path" of CrossingSign().
+  int CrossingSignInternal(const S2Point* d);
+  int CrossingSignInternal2(const S2Point& d);
+
+  // Used internally by S2CopyingEdgeCrosser.  Updates "c_" only.
+  void set_c(const S2Point* c) { c_ = c; }
+
+  // The fields below are constant after the call to Init().
+  const S2Point* a_;
+  const S2Point* b_;
+  Vector3_d a_cross_b_;
+
+  // To reduce the number of calls to s2pred::ExpensiveSign(), we compute an
+  // outward-facing tangent at A and B if necessary.  If the plane
+  // perpendicular to one of these tangents separates AB from CD (i.e., one
+  // edge on each side) then there is no intersection.
+  bool have_tangents_;  // True if the tangents have been computed.
+  S2Point a_tangent_;   // Outward-facing tangent at A.
+  S2Point b_tangent_;   // Outward-facing tangent at B.
+
+  // The fields below are updated for each vertex in the chain.
+  const S2Point* c_;       // Previous vertex in the vertex chain.
+  int acb_;                // The orientation of triangle ACB.
+
+  // The field below is a temporary used by CrossingSignInternal().
+  int bda_;                // The orientation of triangle BDA.
+
+  S2EdgeCrosser(const S2EdgeCrosser&) = delete;
+  void operator=(const S2EdgeCrosser&) = delete;
+};
+
+// S2CopyingEdgeCrosser is exactly like S2EdgeCrosser, except that it makes its
+// own copy of all arguments so that they do not need to persist between
+// calls.  This is less efficient, but makes it possible to use points that
+// are generated on demand and cannot conveniently be stored by the client.
+class S2CopyingEdgeCrosser {
+ public:
+  // These methods are all exactly like S2EdgeCrosser, except that the
+  // arguments can be temporaries.
+  S2CopyingEdgeCrosser() {}
+  S2CopyingEdgeCrosser(const S2Point& a, const S2Point& b);
+  const S2Point& a() { return a_; }
+  const S2Point& b() { return b_; }
+  const S2Point& c() { return c_; }
+  void Init(const S2Point& a, const S2Point& b);
+  int CrossingSign(const S2Point& c, const S2Point& d);
+  bool EdgeOrVertexCrossing(const S2Point& c, const S2Point& d);
+  S2CopyingEdgeCrosser(const S2Point& a, const S2Point& b, const S2Point& c);
+  void RestartAt(const S2Point& c);
+  int CrossingSign(const S2Point& d);
+  bool EdgeOrVertexCrossing(const S2Point& d);
+
+ private:
+  S2Point a_, b_, c_;
+  // TODO(ericv): It would be more efficient to implement S2CopyingEdgeCrosser
+  // directly rather than as a wrapper around S2EdgeCrosser.
+  S2EdgeCrosser crosser_;
+
+  S2CopyingEdgeCrosser(const S2CopyingEdgeCrosser&) = delete;
+  void operator=(const S2CopyingEdgeCrosser&) = delete;
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+inline S2EdgeCrosser::S2EdgeCrosser(const S2Point* a, const S2Point* b)
+    : a_(a), b_(b), a_cross_b_(a_->CrossProd(*b_)), have_tangents_(false),
+      c_(nullptr) {
+  S2_DCHECK(S2::IsUnitLength(*a));
+  S2_DCHECK(S2::IsUnitLength(*b));
+}
+
+inline void S2EdgeCrosser::Init(const S2Point* a, const S2Point* b) {
+  a_ = a;
+  b_ = b;
+  a_cross_b_ = a->CrossProd(*b_);
+  have_tangents_ = false;
+  c_ = nullptr;
+}
+
+inline int S2EdgeCrosser::CrossingSign(const S2Point* c, const S2Point* d) {
+  if (c != c_) RestartAt(c);
+  return CrossingSign(d);
+}
+
+inline bool S2EdgeCrosser::EdgeOrVertexCrossing(const S2Point* c,
+                                                const S2Point* d) {
+  if (c != c_) RestartAt(c);
+  return EdgeOrVertexCrossing(d);
+}
+
+inline S2EdgeCrosser::S2EdgeCrosser(
+    const S2Point* a, const S2Point* b, const S2Point* c)
+    : a_(a), b_(b), a_cross_b_(a_->CrossProd(*b_)), have_tangents_(false) {
+  S2_DCHECK(S2::IsUnitLength(*a));
+  S2_DCHECK(S2::IsUnitLength(*b));
+  RestartAt(c);
+}
+
+inline void S2EdgeCrosser::RestartAt(const S2Point* c) {
+  S2_DCHECK(S2::IsUnitLength(*c));
+  c_ = c;
+  acb_ = -s2pred::TriageSign(*a_, *b_, *c_, a_cross_b_);
+}
+
+inline int S2EdgeCrosser::CrossingSign(const S2Point* d) {
+  S2_DCHECK(S2::IsUnitLength(*d));
+  // For there to be an edge crossing, the triangles ACB, CBD, BDA, DAC must
+  // all be oriented the same way (CW or CCW).  We keep the orientation of ACB
+  // as part of our state.  When each new point D arrives, we compute the
+  // orientation of BDA and check whether it matches ACB.  This checks whether
+  // the points C and D are on opposite sides of the great circle through AB.
+
+  // Recall that TriageSign is invariant with respect to rotating its
+  // arguments, i.e. ABD has the same orientation as BDA.
+  int bda = s2pred::TriageSign(*a_, *b_, *d, a_cross_b_);
+  if (acb_ == -bda && bda != 0) {
+    // The most common case -- triangles have opposite orientations.  Save the
+    // current vertex D as the next vertex C, and also save the orientation of
+    // the new triangle ACB (which is opposite to the current triangle BDA).
+    c_ = d;
+    acb_ = -bda;
+    return -1;
+  }
+  bda_ = bda;
+  return CrossingSignInternal(d);
+}
+
+inline bool S2EdgeCrosser::EdgeOrVertexCrossing(const S2Point* d) {
+  // We need to copy c_ since it is clobbered by CrossingSign().
+  const S2Point* c = c_;
+  int crossing = CrossingSign(d);
+  if (crossing < 0) return false;
+  if (crossing > 0) return true;
+  return S2::VertexCrossing(*a_, *b_, *c, *d);
+}
+
+inline S2CopyingEdgeCrosser::S2CopyingEdgeCrosser(const S2Point& a,
+                                                  const S2Point& b)
+    : a_(a), b_(b), c_(S2Point()), crosser_(&a_, &b_) {
+}
+
+inline void S2CopyingEdgeCrosser::Init(const S2Point& a, const S2Point& b) {
+  a_ = a;
+  b_ = b;
+  c_ = S2Point();
+  crosser_.Init(&a_, &b_);
+}
+
+inline int S2CopyingEdgeCrosser::CrossingSign(const S2Point& c,
+                                              const S2Point& d) {
+  if (c != c_ || crosser_.c_ == nullptr) RestartAt(c);
+  return CrossingSign(d);
+}
+
+inline bool S2CopyingEdgeCrosser::EdgeOrVertexCrossing(
+    const S2Point& c, const S2Point& d) {
+  if (c != c_ || crosser_.c_ == nullptr) RestartAt(c);
+  return EdgeOrVertexCrossing(d);
+}
+
+inline S2CopyingEdgeCrosser::S2CopyingEdgeCrosser(
+    const S2Point& a, const S2Point& b, const S2Point& c)
+    : a_(a), b_(b), c_(c), crosser_(&a_, &b_, &c) {
+}
+
+inline void S2CopyingEdgeCrosser::RestartAt(const S2Point& c) {
+  c_ = c;
+  crosser_.RestartAt(&c_);
+}
+
+inline int S2CopyingEdgeCrosser::CrossingSign(const S2Point& d) {
+  int result = crosser_.CrossingSign(&d);
+  c_ = d;
+  crosser_.set_c(&c_);
+  return result;
+}
+
+inline bool S2CopyingEdgeCrosser::EdgeOrVertexCrossing(const S2Point& d) {
+  bool result = crosser_.EdgeOrVertexCrossing(&d);
+  c_ = d;
+  crosser_.set_c(&c_);
+  return result;
+}
+
+#endif  // S2_S2EDGE_CROSSER_H_

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

@@ -0,0 +1,264 @@
+// 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 <limits>
+#include <string>
+#include <vector>
+
+#include "s2/base/logging.h"
+#include <gtest/gtest.h>
+#include "s2/s2edge_crossings.h"
+#include "s2/s2edge_distances.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2testing.h"
+
+using std::vector;
+
+#ifdef NDEBUG
+
+// In non-debug builds, check that default-constructed and/or NaN S2Point
+// arguments don't cause crashes, especially on the very first method call
+// (since S2CopyingEdgeCrosser checks whether the first vertex of each edge is
+// the same as the last vertex of the previous edged when deciding whether or
+// not to call Restart).
+
+void TestCrossingSignInvalid(const S2Point& point, int expected) {
+  S2EdgeCrosser crosser(&point, &point);
+  EXPECT_EQ(expected, crosser.CrossingSign(&point, &point));
+  S2CopyingEdgeCrosser crosser2(point, point);
+  EXPECT_EQ(expected, crosser2.CrossingSign(point, point));
+}
+
+void TestEdgeOrVertexCrossingInvalid(const S2Point& point, bool expected) {
+  S2EdgeCrosser crosser(&point, &point);
+  EXPECT_EQ(expected, crosser.EdgeOrVertexCrossing(&point, &point));
+  S2CopyingEdgeCrosser crosser2(point, point);
+  EXPECT_EQ(expected, crosser2.EdgeOrVertexCrossing(point, point));
+}
+
+TEST(S2EdgeUtil, InvalidDefaultPoints) {
+  // Check that default-constructed S2Point arguments don't cause crashes.
+  S2Point point(0, 0, 0);
+  TestCrossingSignInvalid(point, 0);
+  TestEdgeOrVertexCrossingInvalid(point, false);
+}
+
+TEST(S2EdgeUtil, InvalidNanPoints) {
+  // Check that NaN S2Point arguments don't cause crashes.
+  const double nan = std::numeric_limits<double>::quiet_NaN();
+  S2Point point(nan, nan, nan);
+  TestCrossingSignInvalid(point, -1);
+  TestEdgeOrVertexCrossingInvalid(point, false);
+}
+
+#endif
+
+void TestCrossing(const S2Point& a, const S2Point& b,
+                  const S2Point& c, const S2Point& d,
+                  int robust, bool edge_or_vertex) {
+  // Modify the expected result if two vertices from different edges match.
+  if (a == c || a == d || b == c || b == d) robust = 0;
+  EXPECT_EQ(robust, S2::CrossingSign(a, b, c, d));
+  S2EdgeCrosser crosser(&a, &b, &c);
+  EXPECT_EQ(robust, crosser.CrossingSign(&d));
+  EXPECT_EQ(robust, crosser.CrossingSign(&c));
+  EXPECT_EQ(robust, crosser.CrossingSign(&d, &c));
+  EXPECT_EQ(robust, crosser.CrossingSign(&c, &d));
+
+  EXPECT_EQ(edge_or_vertex, S2::EdgeOrVertexCrossing(a, b, c, d));
+  crosser.RestartAt(&c);
+  EXPECT_EQ(edge_or_vertex, crosser.EdgeOrVertexCrossing(&d));
+  EXPECT_EQ(edge_or_vertex, crosser.EdgeOrVertexCrossing(&c));
+  EXPECT_EQ(edge_or_vertex, crosser.EdgeOrVertexCrossing(&d, &c));
+  EXPECT_EQ(edge_or_vertex, crosser.EdgeOrVertexCrossing(&c, &d));
+
+  // Check that the crosser can be re-used.
+  crosser.Init(&c, &d);
+  crosser.RestartAt(&a);
+  EXPECT_EQ(robust, crosser.CrossingSign(&b));
+  EXPECT_EQ(robust, crosser.CrossingSign(&a));
+
+  // Now try all the same tests with CopyingEdgeCrosser.
+  S2CopyingEdgeCrosser crosser2(a, b, c);
+  EXPECT_EQ(robust, crosser2.CrossingSign(d));
+  EXPECT_EQ(robust, crosser2.CrossingSign(c));
+  EXPECT_EQ(robust, crosser2.CrossingSign(d, c));
+  EXPECT_EQ(robust, crosser2.CrossingSign(c, d));
+
+  EXPECT_EQ(edge_or_vertex, S2::EdgeOrVertexCrossing(a, b, c, d));
+  crosser2.RestartAt(c);
+  EXPECT_EQ(edge_or_vertex, crosser2.EdgeOrVertexCrossing(d));
+  EXPECT_EQ(edge_or_vertex, crosser2.EdgeOrVertexCrossing(c));
+  EXPECT_EQ(edge_or_vertex, crosser2.EdgeOrVertexCrossing(d, c));
+  EXPECT_EQ(edge_or_vertex, crosser2.EdgeOrVertexCrossing(c, d));
+
+  // Check that the crosser can be re-used.
+  crosser2.Init(c, d);
+  crosser2.RestartAt(a);
+  EXPECT_EQ(robust, crosser2.CrossingSign(b));
+  EXPECT_EQ(robust, crosser2.CrossingSign(a));
+}
+
+void TestCrossings(S2Point a, S2Point b, S2Point c, S2Point d,
+                   int robust, bool edge_or_vertex) {
+  a = a.Normalize();
+  b = b.Normalize();
+  c = c.Normalize();
+  d = d.Normalize();
+  TestCrossing(a, b, c, d, robust, edge_or_vertex);
+  TestCrossing(b, a, c, d, robust, edge_or_vertex);
+  TestCrossing(a, b, d, c, robust, edge_or_vertex);
+  TestCrossing(b, a, d, c, robust, edge_or_vertex);
+  TestCrossing(a, a, c, d, -1, false);
+  TestCrossing(a, b, c, c, -1, false);
+  TestCrossing(a, a, c, c, -1, false);
+  TestCrossing(a, b, a, b, 0, true);
+  TestCrossing(c, d, a, b, robust, edge_or_vertex != (robust == 0));
+}
+
+TEST(S2EdgeUtil, Crossings) {
+  // The real tests of edge crossings are in s2{loop,polygon}_test,
+  // but we do a few simple tests here.
+
+  // Two regular edges that cross.
+  TestCrossings(S2Point(1, 2, 1), S2Point(1, -3, 0.5),
+                S2Point(1, -0.5, -3), S2Point(0.1, 0.5, 3), 1, true);
+
+  // Two regular edges that intersect antipodal points.
+  TestCrossings(S2Point(1, 2, 1), S2Point(1, -3, 0.5),
+                S2Point(-1, 0.5, 3), S2Point(-0.1, -0.5, -3), -1, false);
+
+  // Two edges on the same great circle that start at antipodal points.
+  TestCrossings(S2Point(0, 0, -1), S2Point(0, 1, 0),
+                S2Point(0, 0, 1), S2Point(0, 1, 1), -1, false);
+
+  // Two edges that cross where one vertex is S2::Origin().
+  TestCrossings(S2Point(1, 0, 0), S2::Origin(),
+                S2Point(1, -0.1, 1), S2Point(1, 1, -0.1), 1, true);
+
+  // Two edges that intersect antipodal points where one vertex is
+  // S2::Origin().
+  TestCrossings(S2Point(1, 0, 0), S2::Origin(),
+                S2Point(-1, 0.1, -1), S2Point(-1, -1, 0.1), -1, false);
+
+  // Two edges that share an endpoint.  The Ortho() direction is (-4,0,2),
+  // and edge CD is further CCW around (2,3,4) than AB.
+  TestCrossings(S2Point(2, 3, 4), S2Point(-1, 2, 5),
+                S2Point(7, -2, 3), S2Point(2, 3, 4), 0, false);
+
+  // Two edges that barely cross each other near the middle of one edge.  The
+  // edge AB is approximately in the x=y plane, while CD is approximately
+  // perpendicular to it and ends exactly at the x=y plane.
+  TestCrossings(S2Point(1, 1, 1), S2Point(1, nextafter(1, 0), -1),
+                S2Point(11, -12, -1), S2Point(10, 10, 1), 1, true);
+
+  // In this version, the edges are separated by a distance of about 1e-15.
+  TestCrossings(S2Point(1, 1, 1), S2Point(1, nextafter(1, 2), -1),
+                S2Point(1, -1, 0), S2Point(1, 1, 0), -1, false);
+
+  // Two edges that barely cross each other near the end of both edges.  This
+  // example cannot be handled using regular double-precision arithmetic due
+  // to floating-point underflow.
+  TestCrossings(S2Point(0, 0, 1), S2Point(2, -1e-323, 1),
+                S2Point(1, -1, 1), S2Point(1e-323, 0, 1), 1, true);
+
+  // In this version, the edges are separated by a distance of about 1e-640.
+  TestCrossings(S2Point(0, 0, 1), S2Point(2, 1e-323, 1),
+                S2Point(1, -1, 1), S2Point(1e-323, 0, 1), -1, false);
+
+  // Two edges that barely cross each other near the middle of one edge.
+  // Computing the exact determinant of some of the triangles in this test
+  // requires more than 2000 bits of precision.
+  TestCrossings(S2Point(1, -1e-323, -1e-323), S2Point(1e-323, 1, 1e-323),
+                S2Point(1, -1, 1e-323), S2Point(1, 1, 0),
+                1, true);
+
+  // In this version, the edges are separated by a distance of about 1e-640.
+  TestCrossings(S2Point(1, 1e-323, -1e-323), S2Point(-1e-323, 1, 1e-323),
+                S2Point(1, -1, 1e-323), S2Point(1, 1, 0),
+                -1, false);
+}
+
+TEST(S2EdgeUtil, CollinearEdgesThatDontTouch) {
+  const int kIters = 500;
+  for (int iter = 0; iter < kIters; ++iter) {
+    S2Point a = S2Testing::RandomPoint();
+    S2Point d = S2Testing::RandomPoint();
+    S2Point b = S2::Interpolate(0.05, a, d);
+    S2Point c = S2::Interpolate(0.95, a, d);
+    EXPECT_GT(0, S2::CrossingSign(a, b, c, d));
+    EXPECT_GT(0, S2::CrossingSign(a, b, c, d));
+    S2EdgeCrosser crosser(&a, &b, &c);
+    EXPECT_GT(0, crosser.CrossingSign(&d));
+    EXPECT_GT(0, crosser.CrossingSign(&c));
+  }
+}
+
+
+TEST(S2EdgeUtil, CoincidentZeroLengthEdgesThatDontTouch) {
+  // It is important that the edge primitives can handle vertices that exactly
+  // exactly proportional to each other, i.e. that are not identical but are
+  // nevertheless exactly coincident when projected onto the unit sphere.
+  // There are various ways that such points can arise.  For example,
+  // Normalize() itself is not idempotent: there exist distinct points A,B
+  // such that Normalize(A) == B  and Normalize(B) == A.  Another issue is
+  // that sometimes calls to Normalize() are skipped when the result of a
+  // calculation "should" be unit length mathematically (e.g., when computing
+  // the cross product of two orthonormal vectors).
+  //
+  // This test checks pairs of edges AB and CD where A,B,C,D are exactly
+  // coincident on the sphere and the norms of A,B,C,D are monotonically
+  // increasing.  Such edge pairs should never intersect.  (This is not
+  // obvious, since it depends on the particular symbolic perturbations used
+  // by s2pred::Sign().  It would be better to replace this with a test that
+  // says that the CCW results must be consistent with each other.)
+  const int kIters = 1000;
+  for (int iter = 0; iter < kIters; ++iter) {
+    // Construct a point P where every component is zero or a power of 2.
+    S2Point p;
+    for (int i = 0; i < 3; ++i) {
+      int binary_exp = S2Testing::rnd.Skewed(11);
+      p[i] = (binary_exp > 1022) ? 0 : pow(2, -binary_exp);
+    }
+    // If all components were zero, try again.  Note that normalization may
+    // convert a non-zero point into a zero one due to underflow (!)
+    p = p.Normalize();
+    if (p == S2Point(0, 0, 0)) { --iter; continue; }
+
+    // Now every non-zero component should have exactly the same mantissa.
+    // This implies that if we scale the point by an arbitrary factor, every
+    // non-zero component will still have the same mantissa.  Scale the points
+    // so that they are all distinct and are still very likely to satisfy
+    // S2::IsUnitLength (which allows for a small amount of error in the norm).
+    S2Point a = (1-3e-16) * p;
+    S2Point b = (1-1e-16) * p;
+    S2Point c = p;
+    S2Point d = (1+2e-16) * p;
+    if (!S2::IsUnitLength(a) || !S2::IsUnitLength(d)) {
+      --iter;
+      continue;
+    }
+    // Verify that the expected edges do not cross.
+    EXPECT_GT(0, S2::CrossingSign(a, b, c, d));
+    S2EdgeCrosser crosser(&a, &b, &c);
+    EXPECT_GT(0, crosser.CrossingSign(&d));
+    EXPECT_GT(0, crosser.CrossingSign(&c));
+  }
+}
+