@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,220 @@
+// 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_R1INTERVAL_H_
+#define S2_R1INTERVAL_H_
+
+#include <algorithm>
+#include <cmath>
+#include <iosfwd>
+#include <iostream>
+
+#include "s2/base/logging.h"
+#include "s2/_fp_contract_off.h"
+#include "s2/util/math/vector.h"  // IWYU pragma: export
+
+// An R1Interval represents a closed, bounded interval on the real line.
+// It is capable of representing the empty interval (containing no points)
+// and zero-length intervals (containing a single point).
+//
+// This class is intended to be copied by value as desired.  It uses
+// the default copy constructor and assignment operator.
+class R1Interval {
+ public:
+  // Constructor.  If lo > hi, the interval is empty.
+  R1Interval(double lo, double hi) : bounds_(lo, hi) {}
+
+  // The default constructor creates an empty interval.  (Any interval where
+  // lo > hi is considered to be empty.)
+  //
+  // Note: Don't construct an interval using the default constructor and
+  // set_lo()/set_hi(), since this technique doesn't work with S1Interval and
+  // is bad programming style anyways.  If you need to set both endpoints, use
+  // the constructor above:
+  //
+  //   lat_bounds_ = R1Interval(lat_lo, lat_hi);
+  R1Interval() : bounds_(1, 0) {}
+
+  // Returns an empty interval.
+  static R1Interval Empty() { return R1Interval(); }
+
+  // Convenience method to construct an interval containing a single point.
+  static R1Interval FromPoint(double p) { return R1Interval(p, p); }
+
+  // Convenience method to construct the minimal interval containing
+  // the two given points.  This is equivalent to starting with an empty
+  // interval and calling AddPoint() twice, but it is more efficient.
+  static R1Interval FromPointPair(double p1, double p2) {
+    if (p1 <= p2) {
+      return R1Interval(p1, p2);
+    } else {
+      return R1Interval(p2, p1);
+    }
+  }
+
+  // Accessors methods.
+  double lo() const { return bounds_[0]; }
+  double hi() const { return bounds_[1]; }
+
+  // Methods to modify one endpoint of an existing R1Interval.  Do not use
+  // these methods if you want to replace both endpoints of the interval; use
+  // a constructor instead.  For example:
+  //
+  //   *lat_bounds = R1Interval(lat_lo, lat_hi);
+  void set_lo(double p) { bounds_[0] = p; }
+  void set_hi(double p) { bounds_[1] = p; }
+
+  // Methods that allow the R1Interval to be accessed as a vector.  (The
+  // recommended style is to use lo() and hi() whenever possible, but these
+  // methods are useful when the endpoint to be selected is not constant.)
+  double operator[](int i) const { return bounds_[i]; }
+  double& operator[](int i) { return bounds_[i]; }
+  const Vector2_d& bounds() const { return bounds_; }
+  Vector2_d* mutable_bounds() { return &bounds_; }
+
+  // Return true if the interval is empty, i.e. it contains no points.
+  bool is_empty() const { return lo() > hi(); }
+
+  // Return the center of the interval.  For empty intervals,
+  // the result is arbitrary.
+  double GetCenter() const { return 0.5 * (lo() + hi()); }
+
+  // Return the length of the interval.  The length of an empty interval
+  // is negative.
+  double GetLength() const { return hi() - lo(); }
+
+  bool Contains(double p) const {
+    return p >= lo() && p <= hi();
+  }
+
+  bool InteriorContains(double p) const {
+    return p > lo() && p < hi();
+  }
+
+  // Return true if this interval contains the interval 'y'.
+  bool Contains(const R1Interval& y) const {
+    if (y.is_empty()) return true;
+    return y.lo() >= lo() && y.hi() <= hi();
+  }
+
+  // Return true if the interior of this interval contains the entire
+  // interval 'y' (including its boundary).
+  bool InteriorContains(const R1Interval& y) const {
+    if (y.is_empty()) return true;
+    return y.lo() > lo() && y.hi() < hi();
+  }
+
+  // Return true if this interval intersects the given interval,
+  // i.e. if they have any points in common.
+  bool Intersects(const R1Interval& y) const {
+    if (lo() <= y.lo()) {
+      return y.lo() <= hi() && y.lo() <= y.hi();
+    } else {
+      return lo() <= y.hi() && lo() <= hi();
+    }
+  }
+
+  // Return true if the interior of this interval intersects
+  // any point of the given interval (including its boundary).
+  bool InteriorIntersects(const R1Interval& y) const {
+    return y.lo() < hi() && lo() < y.hi() && lo() < hi() && y.lo() <= y.hi();
+  }
+
+  // Return the Hausdorff distance to the given interval 'y'. For two
+  // R1Intervals x and y, this distance is defined as
+  //     h(x, y) = max_{p in x} min_{q in y} d(p, q).
+  double GetDirectedHausdorffDistance(const R1Interval& y) const {
+    if (is_empty()) return 0.0;
+    if (y.is_empty()) return HUGE_VAL;
+    return std::max(0.0, std::max(hi() - y.hi(), y.lo() - lo()));
+  }
+
+  // Expand the interval so that it contains the given point "p".
+  void AddPoint(double p) {
+    if (is_empty()) { set_lo(p); set_hi(p); }
+    else if (p < lo()) { set_lo(p); }  // NOLINT
+    else if (p > hi()) { set_hi(p); }  // NOLINT
+  }
+
+  // Expand the interval so that it contains the given interval "y".
+  void AddInterval(const R1Interval& y) {
+    if (y.is_empty()) return;
+    if (is_empty()) { *this = y; return; }
+    if (y.lo() < lo()) set_lo(y.lo());
+    if (y.hi() > hi()) set_hi(y.hi());
+  }
+
+  // Return the closest point in the interval to the given point "p".
+  // The interval must be non-empty.
+  double Project(double p) const {
+    S2_DCHECK(!is_empty());
+    return std::max(lo(), std::min(hi(), p));
+  }
+
+  // Return an interval that has been expanded on each side by the given
+  // distance "margin".  If "margin" is negative, then shrink the interval on
+  // each side by "margin" instead.  The resulting interval may be empty.  Any
+  // expansion of an empty interval remains empty.
+  R1Interval Expanded(double margin) const {
+    if (is_empty()) return *this;
+    return R1Interval(lo() - margin, hi() + margin);
+  }
+
+  // Return the smallest interval that contains this interval and the
+  // given interval "y".
+  R1Interval Union(const R1Interval& y) const {
+    if (is_empty()) return y;
+    if (y.is_empty()) return *this;
+    return R1Interval(std::min(lo(), y.lo()), std::max(hi(), y.hi()));
+  }
+
+  // Return the intersection of this interval with the given interval.
+  // Empty intervals do not need to be special-cased.
+  R1Interval Intersection(const R1Interval& y) const {
+    return R1Interval(std::max(lo(), y.lo()), std::min(hi(), y.hi()));
+  }
+
+  // Return true if two intervals contain the same set of points.
+  bool operator==(const R1Interval& y) const {
+    return (lo() == y.lo() && hi() == y.hi()) || (is_empty() && y.is_empty());
+  }
+
+  // Return true if two intervals do not contain the same set of points.
+  bool operator!=(const R1Interval& y) const {
+    return !operator==(y);
+  }
+
+  // Return true if this interval can be transformed into the given interval
+  // by moving each endpoint by at most "max_error".  The empty interval is
+  // considered to be positioned arbitrarily on the real line, thus any
+  // interval with (length <= 2*max_error) matches the empty interval.
+  bool ApproxEquals(const R1Interval& y, double max_error = 1e-15) const {
+    if (is_empty()) return y.GetLength() <= 2 * max_error;
+    if (y.is_empty()) return GetLength() <= 2 * max_error;
+    return (std::fabs(y.lo() - lo()) <= max_error &&
+            std::fabs(y.hi() - hi()) <= max_error);
+  }
+
+ private:
+  Vector2_d bounds_;
+};
+
+inline std::ostream& operator<<(std::ostream& os, const R1Interval& x) {
+  return os << "[" << x.lo() << ", " << x.hi() << "]";
+}
+
+#endif  // S2_R1INTERVAL_H_

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

@@ -0,0 +1,185 @@
+// 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/r1interval.h"
+
+#include <cfloat>
+
+#include <gtest/gtest.h>
+
+static void TestIntervalOps(const R1Interval& x, const R1Interval& y,
+                            const char* expected) {
+  // Test all of the interval operations on the given pair of intervals.
+  // "expected" is a sequence of "T" and "F" characters corresponding to
+  // the expected results of Contains(), InteriorContains(), Intersects(),
+  // and InteriorIntersects() respectively.
+
+  EXPECT_EQ(expected[0] == 'T', x.Contains(y));
+  EXPECT_EQ(expected[1] == 'T', x.InteriorContains(y));
+  EXPECT_EQ(expected[2] == 'T', x.Intersects(y));
+  EXPECT_EQ(expected[3] == 'T', x.InteriorIntersects(y));
+
+  EXPECT_EQ(x.Contains(y), x.Union(y) == x);
+  EXPECT_EQ(x.Intersects(y), !x.Intersection(y).is_empty());
+
+  R1Interval z = x;
+  z.AddInterval(y);
+  EXPECT_EQ(x.Union(y), z);
+}
+
+TEST(R1Interval, TestBasic) {
+  // Constructors and accessors.
+  R1Interval unit(0, 1);
+  R1Interval negunit(-1, 0);
+  EXPECT_EQ(0, unit.lo());
+  EXPECT_EQ(1, unit.hi());
+  EXPECT_EQ(-1, negunit[0]);
+  EXPECT_EQ(0, negunit[1]);
+  R1Interval ten(0, 0);
+  ten.set_hi(10);
+  EXPECT_EQ(R1Interval(0, 10), ten);
+  ten[0] = -10;
+  EXPECT_EQ(R1Interval(-10, 10), ten);
+  ten[1] = 0;
+  EXPECT_EQ(Vector2_d(-10, 0), ten.bounds());
+  *ten.mutable_bounds() = Vector2_d(0, 10);
+  EXPECT_EQ(R1Interval(0, 10), ten);
+
+  // is_empty()
+  R1Interval half(0.5, 0.5);
+  EXPECT_FALSE(unit.is_empty());
+  EXPECT_FALSE(half.is_empty());
+  R1Interval empty = R1Interval::Empty();
+  EXPECT_TRUE(empty.is_empty());
+
+  // == and !=
+  EXPECT_TRUE(empty == empty);
+  EXPECT_TRUE(unit == unit);
+  EXPECT_TRUE(unit != empty);
+  EXPECT_TRUE(R1Interval(1, 2) != R1Interval(1, 3));
+
+  // Check that the default R1Interval is identical to Empty().
+  R1Interval default_empty;
+  EXPECT_TRUE(default_empty.is_empty());
+  EXPECT_EQ(empty.lo(), default_empty.lo());
+  EXPECT_EQ(empty.hi(), default_empty.hi());
+
+  // GetCenter(), GetLength()
+  EXPECT_EQ(unit.GetCenter(), 0.5);
+  EXPECT_EQ(half.GetCenter(), 0.5);
+  EXPECT_EQ(negunit.GetLength(), 1.0);
+  EXPECT_EQ(half.GetLength(), 0);
+  EXPECT_LT(empty.GetLength(), 0);
+
+  // Contains(double), InteriorContains(double)
+  EXPECT_TRUE(unit.Contains(0.5));
+  EXPECT_TRUE(unit.InteriorContains(0.5));
+  EXPECT_TRUE(unit.Contains(0));
+  EXPECT_FALSE(unit.InteriorContains(0));
+  EXPECT_TRUE(unit.Contains(1));
+  EXPECT_FALSE(unit.InteriorContains(1));
+
+  // Contains(R1Interval), InteriorContains(R1Interval)
+  // Intersects(R1Interval), InteriorIntersects(R1Interval)
+  { SCOPED_TRACE(""); TestIntervalOps(empty, empty, "TTFF"); }
+  { SCOPED_TRACE(""); TestIntervalOps(empty, unit, "FFFF"); }
+  { SCOPED_TRACE(""); TestIntervalOps(unit, half, "TTTT"); }
+  { SCOPED_TRACE(""); TestIntervalOps(unit, unit, "TFTT"); }
+  { SCOPED_TRACE(""); TestIntervalOps(unit, empty, "TTFF"); }
+  { SCOPED_TRACE(""); TestIntervalOps(unit, negunit, "FFTF"); }
+  { SCOPED_TRACE(""); TestIntervalOps(unit, R1Interval(0, 0.5), "TFTT"); }
+  { SCOPED_TRACE(""); TestIntervalOps(half, R1Interval(0, 0.5), "FFTF"); }
+
+  // AddPoint()
+  R1Interval r = empty;
+  r.AddPoint(5);
+  EXPECT_EQ(5, r.lo());
+  EXPECT_EQ(5, r.hi());
+  r.AddPoint(-1);
+  EXPECT_EQ(-1, r.lo());
+  EXPECT_EQ(5, r.hi());
+  r.AddPoint(0);
+  EXPECT_EQ(-1, r.lo());
+  EXPECT_EQ(5, r.hi());
+
+  // Project()
+  EXPECT_EQ(0.3, R1Interval(0.1, 0.4).Project(0.3));
+  EXPECT_EQ(0.1, R1Interval(0.1, 0.4).Project(-7.0));
+  EXPECT_EQ(0.4, R1Interval(0.1, 0.4).Project(0.6));
+
+  // FromPointPair()
+  EXPECT_EQ(R1Interval(4, 4), R1Interval::FromPointPair(4, 4));
+  EXPECT_EQ(R1Interval(-2, -1), R1Interval::FromPointPair(-1, -2));
+  EXPECT_EQ(R1Interval(-5, 3), R1Interval::FromPointPair(-5, 3));
+
+  // Expanded()
+  EXPECT_EQ(empty, empty.Expanded(0.45));
+  EXPECT_EQ(R1Interval(-0.5, 1.5), unit.Expanded(0.5));
+  EXPECT_EQ(R1Interval(0.5, 0.5), unit.Expanded(-0.5));
+  EXPECT_TRUE(unit.Expanded(-0.51).is_empty());
+  EXPECT_TRUE(unit.Expanded(-0.51).Expanded(0.51).is_empty());
+
+  // Union(), Intersection()
+  EXPECT_EQ(R1Interval(99, 100), R1Interval(99, 100).Union(empty));
+  EXPECT_EQ(R1Interval(99, 100), empty.Union(R1Interval(99, 100)));
+  EXPECT_TRUE(R1Interval(5, 3).Union(R1Interval(0, -2)).is_empty());
+  EXPECT_TRUE(R1Interval(0, -2).Union(R1Interval(5, 3)).is_empty());
+  EXPECT_EQ(unit, unit.Union(unit));
+  EXPECT_EQ(R1Interval(-1, 1), unit.Union(negunit));
+  EXPECT_EQ(R1Interval(-1, 1), negunit.Union(unit));
+  EXPECT_EQ(unit, half.Union(unit));
+  EXPECT_EQ(half, unit.Intersection(half));
+  EXPECT_EQ(R1Interval(0, 0), unit.Intersection(negunit));
+  EXPECT_TRUE(negunit.Intersection(half).is_empty());
+  EXPECT_TRUE(unit.Intersection(empty).is_empty());
+  EXPECT_TRUE(empty.Intersection(unit).is_empty());
+}
+
+TEST(R1Interval, ApproxEquals) {
+  // Choose two values kLo and kHi such that it's okay to shift an endpoint by
+  // kLo (i.e., the resulting interval is equivalent) but not by kHi.
+  static const double kLo = 4 * DBL_EPSILON;  // < max_error default
+  static const double kHi = 6 * DBL_EPSILON;  // > max_error default
+
+  // Empty intervals.
+  R1Interval empty = R1Interval::Empty();
+  EXPECT_TRUE(empty.ApproxEquals(empty));
+  EXPECT_TRUE(R1Interval(0, 0).ApproxEquals(empty));
+  EXPECT_TRUE(empty.ApproxEquals(R1Interval(0, 0)));
+  EXPECT_TRUE(R1Interval(1, 1).ApproxEquals(empty));
+  EXPECT_TRUE(empty.ApproxEquals(R1Interval(1, 1)));
+  EXPECT_FALSE(empty.ApproxEquals(R1Interval(0, 1)));
+  EXPECT_TRUE(empty.ApproxEquals(R1Interval(1, 1 + 2*kLo)));
+  EXPECT_FALSE(empty.ApproxEquals(R1Interval(1, 1 + 2*kHi)));
+
+  // Singleton intervals.
+  EXPECT_TRUE(R1Interval(1, 1).ApproxEquals(R1Interval(1, 1)));
+  EXPECT_TRUE(R1Interval(1, 1).ApproxEquals(R1Interval(1 - kLo, 1 - kLo)));
+  EXPECT_TRUE(R1Interval(1, 1).ApproxEquals(R1Interval(1 + kLo, 1 + kLo)));
+  EXPECT_FALSE(R1Interval(1, 1).ApproxEquals(R1Interval(1 - kHi, 1)));
+  EXPECT_FALSE(R1Interval(1, 1).ApproxEquals(R1Interval(1, 1 + kHi)));
+  EXPECT_TRUE(R1Interval(1, 1).ApproxEquals(R1Interval(1 - kLo, 1 + kLo)));
+  EXPECT_FALSE(R1Interval(0, 0).ApproxEquals(R1Interval(1, 1)));
+
+  // Other intervals.
+  EXPECT_TRUE(R1Interval(1 - kLo, 2 + kLo).ApproxEquals(R1Interval(1, 2)));
+  EXPECT_TRUE(R1Interval(1 + kLo, 2 - kLo).ApproxEquals(R1Interval(1, 2)));
+  EXPECT_FALSE(R1Interval(1 - kHi, 2 + kLo).ApproxEquals(R1Interval(1, 2)));
+  EXPECT_FALSE(R1Interval(1 + kHi, 2 - kLo).ApproxEquals(R1Interval(1, 2)));
+  EXPECT_FALSE(R1Interval(1 - kLo, 2 + kHi).ApproxEquals(R1Interval(1, 2)));
+  EXPECT_FALSE(R1Interval(1 + kLo, 2 - kHi).ApproxEquals(R1Interval(1, 2)));
+}

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

@@ -0,0 +1,26 @@
+// Copyright 2012 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_R2_H_
+#define S2_R2_H_
+
+#include "s2/_fp_contract_off.h"
+#include "s2/util/math/vector.h"  // IWYU pragma: export
+
+using R2Point = Vector2_d;
+
+#endif  // S2_R2_H_

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

@@ -0,0 +1,93 @@
+// Copyright 2012 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/r2rect.h"
+
+#include <iosfwd>
+
+#include "s2/base/logging.h"
+#include "s2/r1interval.h"
+#include "s2/r2.h"
+
+R2Rect R2Rect::FromCenterSize(const R2Point& center, const R2Point& size) {
+  return R2Rect(R1Interval(center.x() - 0.5 * size.x(),
+                           center.x() + 0.5 * size.x()),
+                R1Interval(center.y() - 0.5 * size.y(),
+                           center.y() + 0.5 * size.y()));
+}
+
+R2Rect R2Rect::FromPointPair(const R2Point& p1, const R2Point& p2) {
+  return R2Rect(R1Interval::FromPointPair(p1.x(), p2.x()),
+                R1Interval::FromPointPair(p1.y(), p2.y()));
+}
+
+bool R2Rect::Contains(const R2Rect& other) const {
+  return x().Contains(other.x()) && y().Contains(other.y());
+}
+
+bool R2Rect::InteriorContains(const R2Rect& other) const {
+  return x().InteriorContains(other.x()) && y().InteriorContains(other.y());
+}
+
+bool R2Rect::Intersects(const R2Rect& other) const {
+  return x().Intersects(other.x()) && y().Intersects(other.y());
+}
+
+bool R2Rect::InteriorIntersects(const R2Rect& other) const {
+  return x().InteriorIntersects(other.x()) && y().InteriorIntersects(other.y());
+}
+
+void R2Rect::AddPoint(const R2Point& p) {
+  bounds_[0].AddPoint(p[0]);
+  bounds_[1].AddPoint(p[1]);
+}
+
+void R2Rect::AddRect(const R2Rect& other) {
+  bounds_[0].AddInterval(other[0]);
+  bounds_[1].AddInterval(other[1]);
+}
+
+R2Point R2Rect::Project(const R2Point& p) const {
+  return R2Point(x().Project(p.x()), y().Project(p.y()));
+}
+
+R2Rect R2Rect::Expanded(const R2Point& margin) const {
+  R1Interval xx = x().Expanded(margin.x());
+  R1Interval yy = y().Expanded(margin.y());
+  if (xx.is_empty() || yy.is_empty()) return Empty();
+  return R2Rect(xx, yy);
+}
+
+R2Rect R2Rect::Union(const R2Rect& other) const {
+  return R2Rect(x().Union(other.x()), y().Union(other.y()));
+}
+
+R2Rect R2Rect::Intersection(const R2Rect& other) const {
+  R1Interval xx = x().Intersection(other.x());
+  R1Interval yy = y().Intersection(other.y());
+  if (xx.is_empty() || yy.is_empty()) return Empty();
+  return R2Rect(xx, yy);
+}
+
+bool R2Rect::ApproxEquals(const R2Rect& other, double max_error) const {
+  return (x().ApproxEquals(other.x(), max_error) &&
+          y().ApproxEquals(other.y(), max_error));
+}
+
+std::ostream& operator<<(std::ostream& os, const R2Rect& r) {
+  return os << "[Lo" << r.lo() << ", Hi" << r.hi() << "]";
+}