@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,57 @@
+// Copyright 2018 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/s2polyline_measures.h"
+
+#include <cmath>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/s1angle.h"
+#include "s2/s2testing.h"
+
+using std::fabs;
+using std::vector;
+
+namespace {
+
+TEST(GetLengthAndCentroid, GreatCircles) {
+  // Construct random great circles and divide them randomly into segments.
+  // Then make sure that the length and centroid are correct.  Note that
+  // because of the way the centroid is computed, it does not matter how
+  // we split the great circle into segments.
+
+  for (int iter = 0; iter < 100; ++iter) {
+    // Choose a coordinate frame for the great circle.
+    S2Point x, y, z;
+    S2Testing::GetRandomFrame(&x, &y, &z);
+
+    vector<S2Point> line;
+    for (double theta = 0; theta < 2 * M_PI;
+         theta += pow(S2Testing::rnd.RandDouble(), 10)) {
+      line.push_back(cos(theta) * x + sin(theta) * y);
+    }
+    // Close the circle.
+    line.push_back(line[0]);
+    S1Angle length = S2::GetLength(line);
+    EXPECT_LE(fabs(length.radians() - 2 * M_PI), 2e-14);
+    S2Point centroid = S2::GetCentroid(line);
+    EXPECT_LE(centroid.Norm(), 2e-14);
+  }
+}
+
+}  // namespace

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

@@ -0,0 +1,187 @@
+// Copyright 2016 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/s2polyline_simplifier.h"
+
+#include <cfloat>
+
+#include "s2/s1chord_angle.h"
+#include "s2/s1interval.h"
+
+void S2PolylineSimplifier::Init(const S2Point& src) {
+  src_ = src;
+  window_ = S1Interval::Full();
+
+  // Precompute basis vectors for the tangent space at "src".  This is similar
+  // to GetFrame() except that we don't normalize the vectors.  As it turns
+  // out, the two basis vectors below have the same magnitude (up to the
+  // length error in S2Point::Normalize).
+
+  // Find the index of the component whose magnitude is smallest.
+  S2Point tmp = src.Abs();
+  int i = (tmp[0] < tmp[1] ?
+           (tmp[0] < tmp[2] ? 0 : 2) : (tmp[1] < tmp[2] ? 1 : 2));
+
+  // We define the "y" basis vector as the cross product of "src" and the
+  // basis vector for axis "i".  Let "j" and "k" be the indices of the other
+  // two components in cyclic order.
+  int j = (i == 2 ? 0 : i + 1), k = (i == 0 ? 2 : i - 1);
+  y_dir_[i] = 0;
+  y_dir_[j] = src[k];
+  y_dir_[k] = -src[j];
+
+  // Compute the cross product of "y_dir" and "src".  We write out the cross
+  // product here mainly for documentation purposes; it also happens to save a
+  // few multiplies because unfortunately the optimizer does *not* get rid of
+  // multiplies by zero (since these multiplies propagate NaN, for example).
+  x_dir_[i] = src[j] * src[j] + src[k] * src[k];
+  x_dir_[j] = -src[j] * src[i];
+  x_dir_[k] = -src[k] * src[i];
+}
+
+bool S2PolylineSimplifier::Extend(const S2Point& dst) const {
+  // We limit the maximum edge length to 90 degrees in order to simplify the
+  // error bounds.  (The error gets arbitrarily large as the edge length
+  // approaches 180 degrees.)
+  if (S1ChordAngle(src_, dst) > S1ChordAngle::Right()) return false;
+
+  // Otherwise check whether this vertex is in the acceptable angle range.
+  return window_.Contains(GetAngle(dst));
+}
+
+bool S2PolylineSimplifier::TargetDisc(const S2Point& p, S1ChordAngle r) {
+  // Shrink the target interval by the maximum error from all sources.  This
+  // guarantees that the output edge will intersect the given disc.
+  double semiwidth = GetSemiwidth(p, r, -1 /*round down*/);
+  if (semiwidth >= M_PI) {
+    // The target disc contains "src", so there is nothing to do.
+    return true;
+  }
+  if (semiwidth < 0) {
+    window_ = S1Interval::Empty();
+    return false;
+  }
+  // Otherwise compute the angle interval corresponding to the target disc and
+  // intersect it with the current window.
+  double center = GetAngle(p);
+  S1Interval target = S1Interval::FromPoint(center).Expanded(semiwidth);
+  window_ = window_.Intersection(target);
+  return !window_.is_empty();
+}
+
+bool S2PolylineSimplifier::AvoidDisc(const S2Point& p, S1ChordAngle r,
+                                     bool disc_on_left) {
+  // Expand the interval by the maximum error from all sources.  This
+  // guarantees that the final output edge will avoid the given disc.
+  double semiwidth = GetSemiwidth(p, r, 1 /*round up*/);
+  if (semiwidth >= M_PI) {
+    // The avoidance disc contains "src", so it is impossible to avoid.
+    window_ = S1Interval::Empty();
+    return false;
+  }
+  double center = GetAngle(p);
+  double opposite = (center > 0) ? center - M_PI : center + M_PI;
+  S1Interval target = (disc_on_left ? S1Interval(opposite, center) :
+                       S1Interval(center, opposite));
+  window_ = window_.Intersection(target.Expanded(-semiwidth));
+  return !window_.is_empty();
+}
+
+double S2PolylineSimplifier::GetAngle(const S2Point& p) const {
+  return atan2(p.DotProd(y_dir_), p.DotProd(x_dir_));
+}
+
+double S2PolylineSimplifier::GetSemiwidth(const S2Point& p, S1ChordAngle r,
+                                          int round_direction) const {
+  double constexpr DBL_ERR = 0.5 * DBL_EPSILON;
+
+  // Using spherical trigonometry,
+  //
+  //   sin(semiwidth) = sin(r) / sin(a)
+  //
+  // where "a" is the angle between "src" and "p".  Rather than measuring
+  // these angles, instead we measure the squared chord lengths through the
+  // interior of the sphere (i.e., Cartersian distance).  Letting "r2" be the
+  // squared chord distance corresponding to "r", and "a2" be the squared
+  // chord distance corresponding to "a", we use the relationships
+  //
+  //    sin^2(r) = r2 (1 - r2 / 4)
+  //    sin^2(a) = d2 (1 - d2 / 4)
+  //
+  // which follow from the fact that r2 = (2 * sin(r / 2)) ^ 2, etc.
+
+  // "a2" has a relative error up to 5 * DBL_ERR, plus an absolute error of up
+  // to 64 * DBL_ERR^2 (because "src" and "p" may differ from unit length by
+  // up to 4 * DBL_ERR).  We can correct for the relative error later, but for
+  // the absolute error we use "round_direction" to account for it now.
+  double r2 = r.length2();
+  double a2 = S1ChordAngle(src_, p).length2();
+  a2 -= 64 * DBL_ERR * DBL_ERR * round_direction;
+  if (a2 <= r2) return M_PI;  // The given disc contains "src".
+
+  double sin2_r = r2 * (1 - 0.25 * r2);
+  double sin2_a = a2 * (1 - 0.25 * a2);
+  double semiwidth = asin(sqrt(sin2_r / sin2_a));
+
+  // We compute bounds on the errors from all sources:
+  //
+  //   - The call to GetSemiwidth (this call).
+  //   - The call to GetAngle that computes the center of the interval.
+  //   - The call to GetAngle in Extend that tests whether a given point
+  //     is an acceptable destination vertex.
+  //
+  // Summary of the errors in GetAngle:
+  //
+  // y_dir_ has no error.
+  //
+  // x_dir_ has a relative error of DBL_ERR in two components, a relative
+  // error of 2 * DBL_ERR in the other component, plus an overall relative
+  // length error of 4 * DBL_ERR (compared to y_dir_) because "src" is assumed
+  // to be normalized only to within the tolerances of S2Point::Normalize().
+  //
+  // p.DotProd(y_dir_) has a relative error of 1.5 * DBL_ERR and an
+  // absolute error of 1.5 * DBL_ERR * y_dir_.Norm().
+  //
+  // p.DotProd(x_dir_) has a relative error of 5.5 * DBL_ERR and an absolute
+  // error of 3.5 * DBL_ERR * y_dir_.Norm() (noting that x_dir_ and y_dir_
+  // have the same length to within a relative error of 4 * DBL_ERR).
+  //
+  // It's possible to show by taking derivatives that these errors can affect
+  // the angle atan2(y, x) by up 7.093 * DBL_ERR radians.  Rounding up and
+  // including the call to atan2 gives a final error bound of 10 * DBL_ERR.
+  //
+  // Summary of the errors in GetSemiwidth:
+  //
+  // The distance a2 has a relative error of 5 * DBL_ERR plus an absolute
+  // error of 64 * DBL_ERR^2 because the points "src" and "p" may differ from
+  // unit length (by up to 4 * DBL_ERR).  We have already accounted for the
+  // absolute error above, leaving only the relative error.
+  //
+  // sin2_r has a relative error of 2 * DBL_ERR.
+  //
+  // sin2_a has a relative error of 12 * DBL_ERR assuming that a2 <= 2,
+  // i.e. distance(src, p) <= 90 degrees.  (The relative error gets
+  // arbitrarily larger as this distance approaches 180 degrees.)
+  //
+  // semiwidth has a relative error of 17 * DBL_ERR.
+  //
+  // Finally, (center +/- semiwidth) has a rounding error of up to 4 * DBL_ERR
+  // because in theory, the result magnitude may be as large as 1.5 * M_PI
+  // which is larger than 4.0.  This gives a total error of:
+  double error = (2 * 10 + 4) * DBL_ERR + 17 * DBL_ERR * semiwidth;
+  return semiwidth + round_direction * error;
+}

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

@@ -0,0 +1,109 @@
+// Copyright 2016 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)
+//
+// This is a helper class for simplifying polylines.  It allows you to compute
+// a maximal edge that intersects a sequence of discs, and that optionally
+// avoids a different sequence of discs.  The results are conservative in that
+// the edge is guaranteed to intersect or avoid the specified discs using
+// exact arithmetic (see s2predicates.h).
+//
+// Note that S2Builder can also simplify polylines and supports more features
+// (e.g., snapping to S2CellId centers), so it is only recommended to use this
+// class if S2Builder does not meet your needs.
+//
+// Here is a simple example showing how to simplify a polyline into a sequence
+// of edges that stay within "max_error" of the original edges:
+//
+//   vector<S2Point> v = { ... };
+//   S2PolylineSimplifier simplifier;
+//   simplifier.Init(v[0]);
+//   for (int i = 1; i < v.size(); ++i) {
+//     if (!simplifier.Extend(v[i])) {
+//       OutputEdge(simplifier.src(), v[i-1]);
+//       simplifier.Init(v[i-1]);
+//     }
+//     simplifier.TargetDisc(v[i], max_error);
+//   }
+//   OutputEdge(simplifer.src(), v.back());
+//
+// Note that the points targeted by TargetDisc do not need to be the same as
+// the candidate endpoints passed to Extend.  So for example, you could target
+// the original vertices of a polyline, but only consider endpoints that are
+// snapped to E7 coordinates or S2CellId centers.
+//
+// Please be aware that this class works by maintaining a range of acceptable
+// angles (bearings) from the start vertex to the hypothetical destination
+// vertex.  It does not keep track of distances to any of the discs to be
+// targeted or avoided.  Therefore to use this class correctly, constraints
+// should be added in increasing order of distance.  (The actual requirement
+// is slightly weaker than this, which is why it is not enforced, but
+// basically you should only call TargetDisc() and AvoidDisc() with arguments
+// that you want to constrain the immediately following call to Extend().)
+
+#ifndef S2_S2POLYLINE_SIMPLIFIER_H_
+#define S2_S2POLYLINE_SIMPLIFIER_H_
+
+#include "s2/_fp_contract_off.h"
+#include "s2/s1chord_angle.h"
+#include "s2/s1interval.h"
+
+class S2PolylineSimplifier {
+ public:
+  S2PolylineSimplifier() {}
+
+  // Starts a new simplified edge at "src".
+  void Init(const S2Point& src);
+
+  // Returns the source vertex of the output edge.
+  S2Point src() const;
+
+  // Returns true if the edge (src, dst) satisfies all of the targeting
+  // requirements so far.  Returns false if the edge would be longer than
+  // 90 degrees (such edges are not supported).
+  bool Extend(const S2Point& dst) const;
+
+  // Requires that the output edge must pass through the given disc.
+  bool TargetDisc(const S2Point& point, S1ChordAngle radius);
+
+  // Requires that the output edge must avoid the given disc.  "disc_on_left"
+  // specifies whether the disc must be to the left or right of the edge.
+  // (This feature allows the simplified edge to preserve the topology of the
+  // original polyline with respect to other nearby points.)
+  //
+  // If your input is a polyline, you can compute "disc_on_left" as follows.
+  // Let the polyline be ABCDE and assume that it already avoids a set of
+  // points X_i.  Suppose that you have aleady added ABC to the simplifer, and
+  // now want to extend the edge chain to D.  First find the X_i that are near
+  // the edge CD, then discard the ones such that AX_i <= AC or AX_i >= AD
+  // (since these points have either already been considered or aren't
+  // relevant yet).  Now X_i is to the left of the polyline if and only if
+  // s2pred::OrderedCCW(A, D, X, C) (in other words, if X_i is to the left of
+  // the angle wedge ACD).
+  bool AvoidDisc(const S2Point& point, S1ChordAngle radius,
+                 bool disc_on_left);
+
+ private:
+  double GetAngle(const S2Point& p) const;
+  double GetSemiwidth(const S2Point& p, S1ChordAngle r,
+                      int round_direction) const;
+
+  S2Point src_;
+  S2Point x_dir_, y_dir_;
+  S1Interval window_;
+};
+
+#endif  // S2_S2POLYLINE_SIMPLIFIER_H_

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

@@ -0,0 +1,165 @@
+// Copyright 2016 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/s2polyline_simplifier.h"
+
+#include <cfloat>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/s1angle.h"
+#include "s2/s1chord_angle.h"
+#include "s2/s2edge_distances.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2testing.h"
+#include "s2/s2text_format.h"
+
+void CheckSimplify(const char* src, const char* dst,
+                   const char* target, const char* avoid,
+                   const std::vector<bool>& disc_on_left,
+                   double radius_degrees, bool expected_result) {
+  S1ChordAngle radius(S1Angle::Degrees(radius_degrees));
+  S2PolylineSimplifier s;
+  s.Init(s2textformat::MakePoint(src));
+  for (const S2Point& p : s2textformat::ParsePoints(target)) {
+    s.TargetDisc(p, radius);
+  }
+  int i = 0;
+  for (const S2Point& p : s2textformat::ParsePoints(avoid)) {
+    s.AvoidDisc(p, radius, disc_on_left[i++]);
+  }
+  EXPECT_EQ(expected_result, s.Extend(s2textformat::MakePoint(dst)))
+      << "\nsrc = " << src << "\ndst = " << dst
+      << "\ntarget = " << target << "\navoid = " << avoid;
+}
+
+TEST(S2PolylineSimplifier, Reuse) {
+  // Check that Init() can be called more than once.
+  S2PolylineSimplifier s;
+  S1ChordAngle radius(S1Angle::Degrees(10));
+  s.Init(S2Point(1, 0, 0));
+  EXPECT_TRUE(s.TargetDisc(S2Point(1, 1, 0).Normalize(), radius));
+  EXPECT_TRUE(s.TargetDisc(S2Point(1, 1, 0.1).Normalize(), radius));
+  EXPECT_FALSE(s.Extend(S2Point(1, 1, 0.4).Normalize()));
+
+  // s.Init(S2Point(0, 1, 0));
+  EXPECT_TRUE(s.TargetDisc(S2Point(1, 1, 0.3).Normalize(), radius));
+  EXPECT_TRUE(s.TargetDisc(S2Point(1, 1, 0.2).Normalize(), radius));
+  EXPECT_FALSE(s.Extend(S2Point(1, 1, 0).Normalize()));
+}
+
+TEST(S2PolylineSimplifier, NoConstraints) {
+  // No constraints, dst == src.
+  CheckSimplify("0:1", "0:1", "", "", {}, 0, true);
+
+  // No constraints, dst != src.
+  CheckSimplify("0:1", "1:0", "", "", {}, 0, true);
+
+  // No constraints, (src, dst) longer than 90 degrees (not supported).
+  CheckSimplify("0:0", "0:91", "", "", {}, 0, false);
+}
+
+TEST(S2PolylineSimplifier, TargetOnePoint) {
+  // Three points on a straight line.  In theory zero tolerance should work,
+  // but in practice there are floating point errors.
+  CheckSimplify("0:0", "0:2", "0:1", "", {}, 1e-10, true);
+
+  // Three points where the middle point is too far away.
+  CheckSimplify("0:0", "0:2", "1:1", "", {}, 0.9, false);
+
+  // A target disc that contains the source vertex.
+  CheckSimplify("0:0", "0:2", "0:0.1", "", {}, 1.0, true);
+
+  // A target disc that contains the destination vertex.
+  CheckSimplify("0:0", "0:2", "0:2.1", "", {}, 1.0, true);
+}
+
+TEST(S2PolylineSimplifier, AvoidOnePoint) {
+  // Three points on a straight line, attempting to avoid the middle point.
+  CheckSimplify("0:0", "0:2", "", "0:1", {true}, 1e-10, false);
+
+  // Three points where the middle point can be successfully avoided.
+  CheckSimplify("0:0", "0:2", "", "1:1", {true}, 0.9, true);
+
+  // Three points where the middle point is on the left, but where the client
+  // requires the point to be on the right of the edge.
+  CheckSimplify("0:0", "0:2", "", "1:1", {false}, 1e-10, false);
+}
+
+TEST(S2PolylineSimplifier, TargetAndAvoid) {
+  // Target several points that are separated from the proposed edge by about
+  // 0.7 degrees, and avoid several points that are separated from the
+  // proposed edge by about 1.4 degrees.
+  CheckSimplify("0:0", "10:10", "2:3, 4:3, 7:8",
+                "4:2, 7:5, 7:9", {true, true, false}, 1.0, true);
+
+  // The same example, but one point to be targeted is 1.4 degrees away.
+  CheckSimplify("0:0", "10:10", "2:3, 4:6, 7:8",
+                "4:2, 7:5, 7:9", {true, true, false}, 1.0, false);
+
+  // The same example, but one point to be avoided is 0.7 degrees away.
+  CheckSimplify("0:0", "10:10", "2:3, 4:3, 7:8",
+                "4:2, 6:5, 7:9", {true, true, false}, 1.0, false);
+}
+
+TEST(S2PolylineSimplifier, Precision) {
+  // This is a rough upper bound on both the error in constructing the disc
+  // locations (i.e., S2::InterpolateAtDistance, etc), and also on the
+  // padding that S2PolylineSimplifier uses to ensure that its results are
+  // conservative (i.e., the error calculated by GetSemiwidth).
+  const S1Angle kMaxError = S1Angle::Radians(25 * DBL_EPSILON);
+
+  // We repeatedly generate a random edge.  We then target several discs that
+  // barely overlap the edge, and avoid several discs that barely miss the
+  // edge.  About half the time, we choose one disc and make it slightly too
+  // large or too small so that targeting fails.
+  const int kIters = 1000;  // Passes with 1 million iterations.
+  S2PolylineSimplifier simplifier;
+  for (int iter = 0; iter < kIters; ++iter) {
+    S2Testing::rnd.Reset(iter + 1);  // Easier to reproduce a specific case.
+    S2Point src = S2Testing::RandomPoint();
+    simplifier.Init(src);
+    S2Point dst = S2::InterpolateAtDistance(
+        S1Angle::Radians(S2Testing::rnd.RandDouble()),
+        src, S2Testing::RandomPoint());
+    S2Point n = S2::RobustCrossProd(src, dst).Normalize();
+
+    // If bad_disc >= 0, then we make targeting fail for that disc.
+    const int kNumDiscs = 5;
+    int bad_disc = S2Testing::rnd.Uniform(2 * kNumDiscs) - kNumDiscs;
+    for (int i = 0; i < kNumDiscs; ++i) {
+      double f = S2Testing::rnd.RandDouble();
+      S2Point a = ((1 - f) * src + f * dst).Normalize();
+      S1Angle r = S1Angle::Radians(S2Testing::rnd.RandDouble());
+      bool on_left = S2Testing::rnd.OneIn(2);
+      S2Point x = S2::InterpolateAtDistance(r, a, on_left ? n : -n);
+      // We grow the radius slightly if we want to target the disc and shrink
+      // it otherwise, *unless* we want targeting to fail for this disc, in
+      // which case these actions are reversed.
+      bool avoid = S2Testing::rnd.OneIn(2);
+      bool grow_radius = (avoid == (i == bad_disc));
+      S1ChordAngle radius(grow_radius ? r + kMaxError : r - kMaxError);
+      if (avoid) {
+        simplifier.AvoidDisc(x, radius, on_left);
+      } else {
+        simplifier.TargetDisc(x, radius);
+      }
+    }
+    // The result is true iff all the disc constraints were satisfiable.
+    EXPECT_EQ(bad_disc < 0, simplifier.Extend(dst));
+  }
+}