@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,131 @@
+// 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/s2pointutil.h"
+
+#include <cfloat>
+#include <cmath>
+
+using std::fabs;
+
+namespace S2 {
+
+bool IsUnitLength(const S2Point& p) {
+  // Normalize() is guaranteed to return a vector whose L2-norm differs from 1
+  // by less than 2 * DBL_EPSILON.  Thus the squared L2-norm differs by less
+  // than 4 * DBL_EPSILON.  The actual calculated Norm2() can have up to 1.5 *
+  // DBL_EPSILON of additional error.  The total error of 5.5 * DBL_EPSILON
+  // can then be rounded down since the result must be a representable
+  // double-precision value.
+  return fabs(p.Norm2() - 1) <= 5 * DBL_EPSILON;  // About 1.11e-15
+}
+
+bool ApproxEquals(const S2Point& a, const S2Point& b, S1Angle max_error) {
+  S2_DCHECK_NE(a, S2Point());
+  S2_DCHECK_NE(b, S2Point());
+  return S1Angle(a, b) <= max_error;
+}
+
+S2Point Ortho(const S2Point& a) {
+#ifdef S2_TEST_DEGENERACIES
+  // Vector3::Ortho() always returns a point on the X-Y, Y-Z, or X-Z planes.
+  // This leads to many more degenerate cases in polygon operations.
+  return a.Ortho();
+#else
+  int k = a.LargestAbsComponent() - 1;
+  if (k < 0) k = 2;
+  S2Point temp(0.012, 0.0053, 0.00457);
+  temp[k] = 1;
+  return a.CrossProd(temp).Normalize();
+#endif
+}
+
+Vector3_d RobustCrossProd(const S2Point& a, const S2Point& b) {
+  // The direction of a.CrossProd(b) becomes unstable as (a + b) or (a - b)
+  // approaches zero.  This leads to situations where a.CrossProd(b) is not
+  // very orthogonal to "a" and/or "b".  We could fix this using Gram-Schmidt,
+  // but we also want b.RobustCrossProd(a) == -a.RobustCrossProd(b).
+  //
+  // The easiest fix is to just compute the cross product of (b+a) and (b-a).
+  // Mathematically, this cross product is exactly twice the cross product of
+  // "a" and "b", but it has the numerical advantage that (b+a) and (b-a)
+  // are always perpendicular (since "a" and "b" are unit length).  This
+  // yields a result that is nearly orthogonal to both "a" and "b" even if
+  // these two values differ only in the lowest bit of one component.
+
+  S2_DCHECK(IsUnitLength(a));
+  S2_DCHECK(IsUnitLength(b));
+  Vector3_d x = (b + a).CrossProd(b - a);
+  if (x != S2Point(0, 0, 0)) return x;
+
+  // The only result that makes sense mathematically is to return zero, but
+  // we find it more convenient to return an arbitrary orthogonal vector.
+  return Ortho(a);
+}
+
+S2Point Rotate(const S2Point& p, const S2Point& axis, S1Angle angle) {
+  S2_DCHECK(IsUnitLength(p));
+  S2_DCHECK(IsUnitLength(axis));
+  // Let M be the plane through P that is perpendicular to "axis", and let
+  // "center" be the point where M intersects "axis".  We construct a
+  // right-handed orthogonal frame (dx, dy, center) such that "dx" is the
+  // vector from "center" to P, and "dy" has the same length as "dx".  The
+  // result can then be expressed as (cos(angle)*dx + sin(angle)*dy + center).
+  S2Point center = p.DotProd(axis) * axis;
+  S2Point dx = p - center;
+  S2Point dy = axis.CrossProd(p);
+  // Mathematically the result is unit length, but normalization is necessary
+  // to ensure that numerical errors don't accumulate.
+  return (cos(angle) * dx + sin(angle) * dy + center).Normalize();
+}
+
+Matrix3x3_d GetFrame(const S2Point& z) {
+  Matrix3x3_d m;
+  GetFrame(z, &m);
+  return m;
+}
+
+void GetFrame(const S2Point& z, Matrix3x3_d* m) {
+  S2_DCHECK(IsUnitLength(z));
+  m->SetCol(2, z);
+  m->SetCol(1, Ortho(z));
+  m->SetCol(0, m->Col(1).CrossProd(z));  // Already unit-length.
+}
+
+S2Point ToFrame(const Matrix3x3_d& m, const S2Point& p) {
+  // The inverse of an orthonormal matrix is its transpose.
+  return m.Transpose() * p;
+}
+
+S2Point FromFrame(const Matrix3x3_d& m, const S2Point& q) {
+  return m * q;
+}
+
+bool SimpleCCW(const S2Point& a, const S2Point& b, const S2Point& c) {
+  // We compute the signed volume of the parallelepiped ABC.  The usual
+  // formula for this is (AxB).C, but we compute it here using (CxA).B
+  // in order to ensure that ABC and CBA are not both CCW.  This follows
+  // from the following identities (which are true numerically, not just
+  // mathematically):
+  //
+  //     (1) x.CrossProd(y) == -(y.CrossProd(x))
+  //     (2) (-x).DotProd(y) == -(x.DotProd(y))
+
+  return c.CrossProd(a).DotProd(b) > 0;
+}
+
+}  // namespace S2

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

@@ -0,0 +1,138 @@
+// 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 additional operations for points on the unit sphere (in addition to
+// the standard vector operations defined in "util/math/vector.h").
+
+#ifndef S2_S2POINTUTIL_H_
+#define S2_S2POINTUTIL_H_
+
+#include "s2/_fp_contract_off.h"
+#include "s2/s1angle.h"
+#include "s2/s2point.h"
+#include "s2/util/math/matrix3x3.h"
+
+// S2 is a namespace for constants and simple utility functions that are used
+// throughout the S2 library.  The name "S2" is derived from the mathematical
+// symbol for the two-dimensional unit sphere (note that the "2" refers to the
+// dimension of the surface, not the space it is embedded in).
+namespace S2 {
+
+// Return a unique "origin" on the sphere for operations that need a fixed
+// reference point.  In particular, this is the "point at infinity" used for
+// point-in-polygon testing (by counting the number of edge crossings).
+inline S2Point Origin();
+
+// Return true if the given point is approximately unit length
+// (this is mainly useful for assertions).
+bool IsUnitLength(const S2Point& p);
+
+// Return true if two points are within the given distance of each other (this
+// is mainly useful for testing). It is an error if either point is a
+// zero-length vector (default S2Point), but this is only checked in debug mode.
+// In non-debug mode it will always return true.
+bool ApproxEquals(const S2Point& a, const S2Point& b,
+                  S1Angle max_error = S1Angle::Radians(1e-15));
+
+// Return a unit-length vector that is orthogonal to "a".  Satisfies
+// Ortho(-a) = -Ortho(a) for all a.
+//
+// Note that Vector3_d also defines an "Ortho" method, but this one is
+// preferred for use in S2 code because it explicitly tries to avoid result
+// result coordinates that are zero.  (This is a performance optimization that
+// reduces the amount of time spent in functions which handle degeneracies.)
+S2Point Ortho(const S2Point& a);
+
+// Return a vector "c" that is orthogonal to the given unit-length vectors
+// "a" and "b".  This function is similar to a.CrossProd(b) except that it
+// does a better job of ensuring orthogonality when "a" is nearly parallel
+// to "b", and it returns a non-zero result even when a == b or a == -b.
+//
+// It satisfies the following properties (RCP == RobustCrossProd):
+//
+//   (1) RCP(a,b) != 0 for all a, b
+//   (2) RCP(b,a) == -RCP(a,b) unless a == b or a == -b
+//   (3) RCP(-a,b) == -RCP(a,b) unless a == b or a == -b
+//   (4) RCP(a,-b) == -RCP(a,b) unless a == b or a == -b
+//
+// The result is not guaranteed to be unit length.
+S2Point RobustCrossProd(const S2Point& a, const S2Point& b);
+
+// Rotate the given point about the given axis by the given angle.  "p" and
+// "axis" must be unit length; "angle" has no restrictions (e.g., it can be
+// positive, negative, greater than 360 degrees, etc).
+S2Point Rotate(const S2Point& p, const S2Point& axis, S1Angle angle);
+
+// Extend the given point "z" on the unit sphere into a right-handed
+// coordinate frame of unit-length column vectors m = (x,y,z).  Note that the
+// vectors (x,y) are an orthonormal frame for the tangent space at "z", while
+// "z" itself is an orthonormal frame for the normal space at "z".
+Matrix3x3_d GetFrame(const S2Point& z);
+void GetFrame(const S2Point& z, Matrix3x3_d* m);
+
+// Given an orthonormal basis "m" of column vectors and a point "p", return
+// the coordinates of "p" with respect to the basis "m".  The resulting
+// point "q" satisfies the identity (m * q == p).
+S2Point ToFrame(const Matrix3x3_d& m, const S2Point& p);
+
+// Given an orthonormal basis "m" of column vectors and a point "q" with
+// respect to that basis, return the equivalent point "p" with respect to
+// the standard axis-aligned basis.  The result satisfies (p == m * q).
+S2Point FromFrame(const Matrix3x3_d& m, const S2Point& q);
+
+// Return true if the points A, B, C are strictly counterclockwise.  Return
+// false if the points are clockwise or collinear (i.e. if they are all
+// contained on some great circle).
+//
+// Due to numerical errors, situations may arise that are mathematically
+// impossible, e.g. ABC may be considered strictly CCW while BCA is not.
+// However, the implementation guarantees the following:
+//
+//   If SimpleCCW(a,b,c), then !SimpleCCW(c,b,a) for all a,b,c.
+ABSL_DEPRECATED("Use s2pred::Sign instead.")
+bool SimpleCCW(const S2Point& a, const S2Point& b, const S2Point& c);
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+// Uncomment the following line for testing purposes only.
+// #define S2_TEST_DEGENERACIES
+
+inline S2Point Origin() {
+#ifdef S2_TEST_DEGENERACIES
+  // This value makes polygon operations much slower, because it greatly
+  // increases the number of degenerate cases that need to be handled using
+  // s2pred::ExpensiveSign().
+  return S2Point(0, 0, 1);
+#else
+  // The origin should not be a point that is commonly used in edge tests in
+  // order to avoid triggering code to handle degenerate cases.  (This rules
+  // out the north and south poles.)  It should also not be on the boundary of
+  // any low-level S2Cell for the same reason.
+  //
+  // The point chosen here is about 66km from the north pole towards the East
+  // Siberian Sea.  See the unittest for more details.  It is written out
+  // explicitly using floating-point literals because the optimizer doesn't
+  // seem willing to evaluate Normalize() at compile time.
+  return S2Point(-0.0099994664350250197, 0.0025924542609324121,
+                 0.99994664350250195);
+#endif
+}
+
+}  // namespace S2
+
+#endif  // S2_S2POINTUTIL_H_

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

@@ -0,0 +1,157 @@
+// 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/s2pointutil.h"
+
+#include <gtest/gtest.h>
+#include "s2/s2cell.h"
+#include "s2/s2coords.h"
+#include "s2/s2edge_distances.h"
+#include "s2/s2latlng.h"
+#include "s2/s2measures.h"
+#include "s2/s2predicates.h"
+#include "s2/s2testing.h"
+
+TEST(S2, Frames) {
+  Matrix3x3_d m;
+  S2Point z = S2Point(0.2, 0.5, -3.3).Normalize();
+  S2::GetFrame(z, &m);
+  EXPECT_TRUE(S2::ApproxEquals(m.Col(2), z));
+  EXPECT_TRUE(S2::IsUnitLength(m.Col(0)));
+  EXPECT_TRUE(S2::IsUnitLength(m.Col(1)));
+  EXPECT_DOUBLE_EQ(m.Det(), 1);
+
+  EXPECT_TRUE(S2::ApproxEquals(S2::ToFrame(m, m.Col(0)), S2Point(1, 0, 0)));
+  EXPECT_TRUE(S2::ApproxEquals(S2::ToFrame(m, m.Col(1)), S2Point(0, 1, 0)));
+  EXPECT_TRUE(S2::ApproxEquals(S2::ToFrame(m, m.Col(2)), S2Point(0, 0, 1)));
+
+  EXPECT_TRUE(S2::ApproxEquals(S2::FromFrame(m, S2Point(1, 0, 0)), m.Col(0)));
+  EXPECT_TRUE(S2::ApproxEquals(S2::FromFrame(m, S2Point(0, 1, 0)), m.Col(1)));
+  EXPECT_TRUE(S2::ApproxEquals(S2::FromFrame(m, S2Point(0, 0, 1)), m.Col(2)));
+}
+
+static void TestRotate(const S2Point& p, const S2Point& axis, S1Angle angle) {
+  S2Point result = S2::Rotate(p, axis, angle);
+
+  // "result" should be unit length.
+  EXPECT_TRUE(S2::IsUnitLength(result));
+
+  // "result" and "p" should be the same distance from "axis".
+  double kMaxPositionError = 1e-15;
+  EXPECT_LE((S1Angle(result, axis) - S1Angle(p, axis)).abs().radians(),
+            kMaxPositionError);
+
+  // Check that the rotation angle is correct.  We allow a fixed error in the
+  // *position* of the result, so we need to convert this into a rotation
+  // angle.  The allowable error can be very large as "p" approaches "axis".
+  double axis_distance = p.CrossProd(axis).Norm();
+  double max_rotation_error;
+  if (axis_distance < kMaxPositionError) {
+    max_rotation_error = 2 * M_PI;
+  } else {
+    max_rotation_error = asin(kMaxPositionError / axis_distance);
+  }
+  double actual_rotation = S2::TurnAngle(p, axis, result) + M_PI;
+  double rotation_error = remainder(angle.radians() - actual_rotation,
+                                    2 * M_PI);
+  EXPECT_LE(rotation_error, max_rotation_error);
+}
+
+TEST(S2, Rotate) {
+  for (int iter = 0; iter < 1000; ++iter) {
+    S2Point axis = S2Testing::RandomPoint();
+    S2Point target = S2Testing::RandomPoint();
+    // Choose a distance whose logarithm is uniformly distributed.
+    double distance = M_PI * pow(1e-15, S2Testing::rnd.RandDouble());
+    // Sometimes choose points near the far side of the axis.
+    if (S2Testing::rnd.OneIn(5)) distance = M_PI - distance;
+    S2Point p = S2::InterpolateAtDistance(S1Angle::Radians(distance),
+                                                  axis, target);
+    // Choose the rotation angle.
+    double angle = 2 * M_PI * pow(1e-15, S2Testing::rnd.RandDouble());
+    if (S2Testing::rnd.OneIn(3)) angle = -angle;
+    if (S2Testing::rnd.OneIn(10)) angle = 0;
+    TestRotate(p, axis, S1Angle::Radians(angle));
+  }
+}
+
+// Given a point P, return the minimum level at which an edge of some S2Cell
+// parent of P is nearly collinear with S2::Origin().  This is the minimum
+// level for which Sign() may need to resort to expensive calculations in
+// order to determine which side of an edge the origin lies on.
+static int GetMinExpensiveLevel(const S2Point& p) {
+  S2CellId id(p);
+  for (int level = 0; level <= S2CellId::kMaxLevel; ++level) {
+    S2Cell cell(id.parent(level));
+    for (int k = 0; k < 4; ++k) {
+      S2Point a = cell.GetVertex(k);
+      S2Point b = cell.GetVertex(k + 1);
+      if (s2pred::TriageSign(a, b, S2::Origin(), a.CrossProd(b)) == 0) {
+        return level;
+      }
+    }
+  }
+  return S2CellId::kMaxLevel + 1;
+}
+
+TEST(S2, OriginTest) {
+  // To minimize the number of expensive Sign() calculations,
+  // S2::Origin() should not be nearly collinear with any commonly used edges.
+  // Two important categories of such edges are:
+  //
+  //  - edges along a line of longitude (reasonably common geographically)
+  //  - S2Cell edges (used extensively when computing S2Cell coverings)
+  //
+  // This implies that the origin:
+  //
+  //  - should not be too close to either pole (since all lines of longitude
+  //    converge at the poles)
+  //  - should not be colinear with edges of any S2Cell except for very small
+  //    ones (which are used less frequently)
+  //
+  // The point chosen below is about 66km from the north pole towards the East
+  // Siberian Sea.  The purpose of the STtoUV(2/3) calculation is to keep the
+  // origin as far away as possible from the longitudinal edges of large
+  // S2Cells.  (The line of longitude through the chosen point is always 1/3
+  // or 2/3 of the way across any S2Cell with longitudinal edges that it
+  // passes through.)
+
+  EXPECT_EQ(S2Point(-0.01, 0.01 * S2::STtoUV(2./3), 1).Normalize(),
+            S2::Origin());
+
+  // Check that the origin is not too close to either pole.  (We don't use
+  // S2Earth because we don't want to depend on that package.)
+  double distance_km = acos(S2::Origin().z()) * S2Testing::kEarthRadiusKm;
+  EXPECT_GE(distance_km, 50.0);
+  S2_LOG(INFO) << "\nS2::Origin() coordinates: " << S2LatLng(S2::Origin())
+            << ", distance from pole: " << distance_km << " km";
+
+  // Check that S2::Origin() is not collinear with the edges of any large
+  // S2Cell.  We do this is two parts.  For S2Cells that belong to either
+  // polar face, we simply need to check that S2::Origin() is not nearly
+  // collinear with any edge of any cell that contains it (except for small
+  // cells < 3 meters across).
+  EXPECT_GE(GetMinExpensiveLevel(S2::Origin()), 22);
+
+  // For S2Cells that belong to the four non-polar faces, only longitudinal
+  // edges can possibly be colinear with S2::Origin().  We check these edges
+  // by projecting S2::Origin() onto the equator, and then testing all S2Cells
+  // that contain this point to make sure that none of their edges are nearly
+  // colinear with S2::Origin() (except for small cells < 3 meters across).
+  S2Point equator_point(S2::Origin().x(), S2::Origin().y(), 0);
+  EXPECT_GE(GetMinExpensiveLevel(equator_point), 22);
+}