@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,292 @@
+// 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_S2R2RECT_H_
+#define S2_S2R2RECT_H_
+
+#include <iosfwd>
+
+#include "s2/base/logging.h"
+#include "s2/_fp_contract_off.h"
+#include "s2/r1interval.h"
+#include "s2/r2.h"
+#include "s2/r2rect.h"
+#include "s2/s1angle.h"
+#include "s2/s2region.h"
+
+class Decoder;
+class Encoder;
+class R1Interval;
+class S2Cap;
+class S2Cell;
+class S2CellId;
+class S2LatLngRect;
+
+// This class is a stopgap measure that allows some of the S2 spherical
+// geometry machinery to be applied to planar geometry.  An S2R2Rect
+// represents a closed axis-aligned rectangle in the (x,y) plane (an R2Rect),
+// but it also happens to be a subtype of S2Region, which means that you can
+// use an S2RegionCoverer to approximate it as a collection of S2CellIds.
+//
+// With respect to the S2Cell decomposition, an S2R2Rect is interpreted as a
+// region of (s,t)-space on face 0.  In particular, the rectangle [0,1]x[0,1]
+// corresponds to the S2CellId that covers all of face 0.  This means that
+// only rectangles that are subsets of [0,1]x[0,1] can be approximated using
+// the S2RegionCoverer interface.
+//
+// The S2R2Rect class is also a convenient way to find the (s,t)-region
+// covered by a given S2CellId (see the FromCell and FromCellId methods).
+//
+// TODO(ericv): If the geometry library is extended to have better support
+// for planar geometry, then this class should no longer be necessary.
+//
+// This class is intended to be copied by value as desired.  It uses
+// the default copy constructor and assignment operator, however it is
+// not a "plain old datatype" (POD) because it has virtual functions.
+class S2R2Rect final : public S2Region {
+ public:
+  // Construct a rectangle from an R2Rect.
+  explicit S2R2Rect(const R2Rect& rect);
+
+  // Construct a rectangle from the given lower-left and upper-right points.
+  S2R2Rect(const R2Point& lo, const R2Point& hi);
+
+  // Construct a rectangle from the given intervals in x and y.  The two
+  // intervals must either be both empty or both non-empty.
+  S2R2Rect(const R1Interval& x, const R1Interval& y);
+
+  // The canonical empty rectangle.  Use is_empty() to test for empty
+  // rectangles, since they have more than one representation.
+  static S2R2Rect Empty();
+
+  // Construct a rectangle that corresponds to the boundary of the given cell
+  // is (s,t)-space.  Such rectangles are always a subset of [0,1]x[0,1].
+  static S2R2Rect FromCell(const S2Cell& cell);
+  static S2R2Rect FromCellId(S2CellId id);
+
+  // Construct a rectangle from a center point and size in each dimension.
+  // Both components of size should be non-negative, i.e. this method cannot
+  // be used to create an empty rectangle.
+  static S2R2Rect FromCenterSize(const R2Point& center, const R2Point& size);
+
+  // Convenience method to construct a rectangle containing a single point.
+  static S2R2Rect FromPoint(const R2Point& p);
+
+  // Convenience method to construct the minimal bounding rectangle containing
+  // the two given points.  This is equivalent to starting with an empty
+  // rectangle and calling AddPoint() twice.  Note that it is different than
+  // the S2R2Rect(lo, hi) constructor, where the first point is always
+  // used as the lower-left corner of the resulting rectangle.
+  static S2R2Rect FromPointPair(const R2Point& p1, const R2Point& p2);
+
+  // Accessor methods.
+  const R1Interval& x() const;
+  const R1Interval& y() const;
+  R2Point lo() const;
+  R2Point hi() const;
+
+  // Methods that allow the S2R2Rect to be accessed as a vector.
+  const R1Interval& operator[](int i) const;
+  R1Interval& operator[](int i);
+
+  // Return true if the rectangle is valid, which essentially just means
+  // that if the bound for either axis is empty then both must be.
+  bool is_valid() const;
+
+  // Return true if the rectangle is empty, i.e. it contains no points at all.
+  bool is_empty() const;
+
+  // Return the k-th vertex of the rectangle (k = 0,1,2,3) in CCW order.
+  // Vertex 0 is in the lower-left corner.  For convenience, the argument is
+  // reduced modulo 4 to the range [0..3].
+  R2Point GetVertex(int k) const;
+
+  // Return the vertex in direction "i" along the x-axis (0=left, 1=right) and
+  // direction "j" along the y-axis (0=down, 1=up).  Equivalently, return the
+  // vertex constructed by selecting endpoint "i" of the x-interval (0=lo,
+  // 1=hi) and vertex "j" of the y-interval.
+  R2Point GetVertex(int i, int j) const;
+
+  // Return the center of the rectangle in (x,y)-space
+  // (in general this is not the center of the region on the sphere).
+  R2Point GetCenter() const;
+
+  // Return the width and height of this rectangle in (x,y)-space.  Empty
+  // rectangles have a negative width and height.
+  R2Point GetSize() const;
+
+  // Return true if the rectangle contains the given point.  Note that
+  // rectangles are closed regions, i.e. they contain their boundary.
+  bool Contains(const R2Point& p) const;
+
+  // Return true if and only if the given point is contained in the interior
+  // of the region (i.e. the region excluding its boundary).
+  bool InteriorContains(const R2Point& p) const;
+
+  // Return true if and only if the rectangle contains the given other
+  // rectangle.
+  bool Contains(const S2R2Rect& other) const;
+
+  // Return true if and only if the interior of this rectangle contains all
+  // points of the given other rectangle (including its boundary).
+  bool InteriorContains(const S2R2Rect& other) const;
+
+  // Return true if this rectangle and the given other rectangle have any
+  // points in common.
+  bool Intersects(const S2R2Rect& other) const;
+
+  // Return true if and only if the interior of this rectangle intersects
+  // any point (including the boundary) of the given other rectangle.
+  bool InteriorIntersects(const S2R2Rect& other) const;
+
+  // Increase the size of the bounding rectangle to include the given point.
+  // The rectangle is expanded by the minimum amount possible.
+  void AddPoint(const R2Point& p);
+
+  // Return the closest point in the rectangle to the given point "p".
+  // The rectangle must be non-empty.
+  R2Point Project(const R2Point& p) const;
+
+  // Return a rectangle that has been expanded on each side in the x-direction
+  // by margin.x(), and on each side in the y-direction by margin.y().  If
+  // either margin is negative, then shrink the interval on the corresponding
+  // sides instead.  The resulting rectangle may be empty.  Any expansion of
+  // an empty rectangle remains empty.
+  S2R2Rect Expanded(const R2Point& margin) const;
+  S2R2Rect Expanded(double margin) const;
+
+  // Return the smallest rectangle containing the union of this rectangle and
+  // the given rectangle.
+  S2R2Rect Union(const S2R2Rect& other) const;
+
+  // Return the smallest rectangle containing the intersection of this
+  // rectangle and the given rectangle.
+  S2R2Rect Intersection(const S2R2Rect& other) const;
+
+  // Return true if two rectangles contains the same set of points.
+  bool operator==(const S2R2Rect& other) const;
+
+  // Return true if the x- and y-intervals of the two rectangles are the same
+  // up to the given tolerance (see r1interval.h for details).
+  bool ApproxEquals(const S2R2Rect& other,
+                    S1Angle max_error = S1Angle::Radians(1e-15)) const;
+
+  // Return the unit-length S2Point corresponding to the given point "p" in
+  // the (s,t)-plane.  "p" need not be restricted to the range [0,1]x[0,1].
+  static S2Point ToS2Point(const R2Point& p);
+
+  ////////////////////////////////////////////////////////////////////////
+  // S2Region interface (see s2region.h for details):
+
+  S2R2Rect* Clone() const override;
+  S2Cap GetCapBound() const override;
+  S2LatLngRect GetRectBound() const override;
+  bool Contains(const S2Point& p) const override;
+  bool Contains(const S2Cell& cell) const override;
+  bool MayIntersect(const S2Cell& cell) const override;
+
+ private:
+  R2Rect rect_;
+};
+
+std::ostream& operator<<(std::ostream& os, const S2R2Rect& r);
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+inline S2R2Rect::S2R2Rect(const R2Rect& rect) : rect_(rect) {}
+
+inline S2R2Rect::S2R2Rect(const R2Point& lo, const R2Point& hi)
+    : rect_(lo, hi) {}
+
+inline S2R2Rect::S2R2Rect(const R1Interval& x, const R1Interval& y)
+    : rect_(x, y) {}
+
+inline S2R2Rect S2R2Rect::FromCenterSize(const R2Point& center,
+                                         const R2Point& size) {
+  return S2R2Rect(R2Rect::FromCenterSize(center, size));
+}
+
+inline S2R2Rect S2R2Rect::FromPoint(const R2Point& p) {
+  return S2R2Rect(R2Rect::FromPoint(p));
+}
+
+inline S2R2Rect S2R2Rect::FromPointPair(const R2Point& p1, const R2Point& p2) {
+  return S2R2Rect(R2Rect::FromPointPair(p1, p2));
+}
+
+inline const R1Interval& S2R2Rect::x() const { return rect_.x(); }
+inline const R1Interval& S2R2Rect::y() const { return rect_.y(); }
+inline R2Point S2R2Rect::lo() const { return rect_.lo(); }
+inline R2Point S2R2Rect::hi() const { return rect_.hi(); }
+inline const R1Interval& S2R2Rect::operator[](int i) const { return rect_[i]; }
+inline R1Interval& S2R2Rect::operator[](int i) { return rect_[i]; }
+inline S2R2Rect S2R2Rect::Empty() { return S2R2Rect(R2Rect::Empty()); }
+inline bool S2R2Rect::is_valid() const { return rect_.is_valid(); }
+inline bool S2R2Rect::is_empty() const { return rect_.is_empty(); }
+inline R2Point S2R2Rect::GetVertex(int k) const { return rect_.GetVertex(k); }
+inline R2Point S2R2Rect::GetVertex(int i, int j) const {
+  return rect_.GetVertex(i, j);
+}
+inline R2Point S2R2Rect::GetCenter() const { return rect_.GetCenter(); }
+inline R2Point S2R2Rect::GetSize() const { return rect_.GetSize(); }
+inline bool S2R2Rect::Contains(const R2Point& p) const {
+  return rect_.Contains(p);
+}
+inline bool S2R2Rect::InteriorContains(const R2Point& p) const {
+  return rect_.InteriorContains(p);
+}
+inline bool S2R2Rect::Contains(const S2R2Rect& other) const {
+  return rect_.Contains(other.rect_);
+}
+inline bool S2R2Rect::InteriorContains(const S2R2Rect& other) const {
+  return rect_.InteriorContains(other.rect_);
+}
+inline bool S2R2Rect::Intersects(const S2R2Rect& other) const {
+  return rect_.Intersects(other.rect_);
+}
+inline bool S2R2Rect::InteriorIntersects(const S2R2Rect& other) const {
+  return rect_.InteriorIntersects(other.rect_);
+}
+inline void S2R2Rect::AddPoint(const R2Point& p) {
+  rect_.AddPoint(p);
+}
+inline R2Point S2R2Rect::Project(const R2Point& p) const {
+  return rect_.Project(p);
+}
+inline S2R2Rect S2R2Rect::Expanded(const R2Point& margin) const {
+  return S2R2Rect(rect_.Expanded(margin));
+}
+inline S2R2Rect S2R2Rect::Expanded(double margin) const {
+  return S2R2Rect(rect_.Expanded(margin));
+}
+inline S2R2Rect S2R2Rect::Union(const S2R2Rect& other) const {
+  return S2R2Rect(rect_.Union(other.rect_));
+}
+inline S2R2Rect S2R2Rect::Intersection(const S2R2Rect& other) const {
+  return S2R2Rect(rect_.Intersection(other.rect_));
+}
+inline bool S2R2Rect::operator==(const S2R2Rect& other) const {
+  return rect_ == other.rect_;
+}
+inline bool S2R2Rect::ApproxEquals(const S2R2Rect& other,
+                                   S1Angle max_error) const {
+  return rect_.ApproxEquals(other.rect_, max_error.radians());
+}
+
+#endif  // S2_S2R2RECT_H_

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

@@ -0,0 +1,312 @@
+// 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)
+//
+// Most of the S2R2Rect methods have trivial implementations in terms of the
+// R1Interval class, so most of the testing is done in that unit test.
+
+#include "s2/s2r2rect.h"
+
+#include <gtest/gtest.h>
+
+#include "s2/base/integral_types.h"
+#include "s2/r1interval.h"
+#include "s2/s2cap.h"
+#include "s2/s2cell.h"
+#include "s2/s2cell_id.h"
+#include "s2/s2coords.h"
+#include "s2/s2latlng.h"
+#include "s2/s2latlng_rect.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2testing.h"
+#include "s2/third_party/absl/strings/str_cat.h"
+
+using absl::StrCat;
+
+static void TestIntervalOps(const S2R2Rect& x, const S2R2Rect& y,
+                            const char* expected_rexion,
+                            const S2R2Rect& expected_union,
+                            const S2R2Rect& expected_intersection) {
+  // Test all of the interval operations on the given pair of intervals.
+  // "expected_rexion" is a sequence of "T" and "F" characters corresponding
+  // to the expected results of Contains(), InteriorContains(), Intersects(),
+  // and InteriorIntersects() respectively.
+
+  EXPECT_EQ(expected_rexion[0] == 'T', x.Contains(y));
+  EXPECT_EQ(expected_rexion[1] == 'T', x.InteriorContains(y));
+  EXPECT_EQ(expected_rexion[2] == 'T', x.Intersects(y));
+  EXPECT_EQ(expected_rexion[3] == 'T', x.InteriorIntersects(y));
+
+  EXPECT_EQ(x.Union(y) == x, x.Contains(y));
+  EXPECT_EQ(!x.Intersection(y).is_empty(), x.Intersects(y));
+
+  EXPECT_EQ(expected_union, x.Union(y));
+  EXPECT_EQ(expected_intersection, x.Intersection(y));
+
+  if (y.GetSize() == R2Point(0, 0)) {
+    S2R2Rect r = x;
+    r.AddPoint(y.lo());
+    EXPECT_EQ(expected_union, r);
+  }
+}
+
+static void TestCellOps(const S2R2Rect& r, const S2Cell& cell, int level) {
+  // Test the relationship between the given rectangle and cell:
+  // 0 == no intersection, 2 == Intersects,
+  // 3 == Intersects and one region contains a vertex of the other,
+  // 4 == Contains
+
+  bool vertex_contained = false;
+  for (int i = 0; i < 4; ++i) {
+    // This would be easier to do by constructing an S2R2Rect from the cell,
+    // but that would defeat the purpose of testing this code independently.
+    double u, v;
+    if (S2::FaceXYZtoUV(0, cell.GetVertexRaw(i), &u, &v)) {
+      if (r.Contains(R2Point(S2::UVtoST(u), S2::UVtoST(v))))
+        vertex_contained = true;
+    }
+    if (!r.is_empty() && cell.Contains(S2R2Rect::ToS2Point(r.GetVertex(i))))
+      vertex_contained = true;
+  }
+  EXPECT_EQ(level >= 2, r.MayIntersect(cell));
+  EXPECT_EQ(level >= 3, vertex_contained);
+  EXPECT_EQ(level >= 4, r.Contains(cell));
+}
+
+TEST(S2R2Rect, EmptyRectangles) {
+  // Test basic properties of empty rectangles.
+  S2R2Rect empty = S2R2Rect::Empty();
+  EXPECT_TRUE(empty.is_valid());
+  EXPECT_TRUE(empty.is_empty());
+}
+
+TEST(S2R2Rect, ConstructorsAndAccessors) {
+  // Check various constructors and accessor methods.
+  S2R2Rect d1 = S2R2Rect(R2Point(0.1, 0), R2Point(0.25, 1));
+  EXPECT_EQ(0.1, d1.x().lo());
+  EXPECT_EQ(0.25, d1.x().hi());
+  EXPECT_EQ(0.0, d1.y().lo());
+  EXPECT_EQ(1.0, d1.y().hi());
+  EXPECT_EQ(R1Interval(0.1, 0.25), d1.x());
+  EXPECT_EQ(R1Interval(0, 1), d1.y());
+}
+
+TEST(S2R2Rect, FromCell) {
+  // FromCell, FromCellId
+  EXPECT_EQ(S2R2Rect(R2Point(0, 0), R2Point(0.5, 0.5)),
+            S2R2Rect::FromCell(S2Cell::FromFacePosLevel(0, 0, 1)));
+  EXPECT_EQ(S2R2Rect(R2Point(0, 0), R2Point(1, 1)),
+            S2R2Rect::FromCellId(S2CellId::FromFacePosLevel(0, 0, 0)));
+}
+
+TEST(S2R2Rect, FromCenterSize) {
+  // FromCenterSize()
+  EXPECT_TRUE(S2R2Rect::FromCenterSize(R2Point(0.3, 0.5), R2Point(0.2, 0.4)).
+              ApproxEquals(S2R2Rect(R2Point(0.2, 0.3), R2Point(0.4, 0.7))));
+  EXPECT_TRUE(S2R2Rect::FromCenterSize(R2Point(1, 0.1), R2Point(0, 2)).
+              ApproxEquals(S2R2Rect(R2Point(1, -0.9), R2Point(1, 1.1))));
+}
+
+TEST(S2R2Rect, FromPoint) {
+  // FromPoint(), FromPointPair()
+  S2R2Rect d1 = S2R2Rect(R2Point(0.1, 0), R2Point(0.25, 1));
+  EXPECT_EQ(S2R2Rect(d1.lo(), d1.lo()), S2R2Rect::FromPoint(d1.lo()));
+  EXPECT_EQ(S2R2Rect(R2Point(0.15, 0.3), R2Point(0.35, 0.9)),
+            S2R2Rect::FromPointPair(R2Point(0.15, 0.9), R2Point(0.35, 0.3)));
+  EXPECT_EQ(S2R2Rect(R2Point(0.12, 0), R2Point(0.83, 0.5)),
+            S2R2Rect::FromPointPair(R2Point(0.83, 0), R2Point(0.12, 0.5)));
+}
+
+TEST(S2R2Rect, SimplePredicates) {
+  // GetCenter(), GetVertex(), Contains(R2Point), InteriorContains(R2Point).
+  R2Point sw1 = R2Point(0, 0.25);
+  R2Point ne1 = R2Point(0.5, 0.75);
+  S2R2Rect r1(sw1, ne1);
+
+  EXPECT_EQ(R2Point(0.25, 0.5), r1.GetCenter());
+  EXPECT_EQ(R2Point(0, 0.25), r1.GetVertex(0));
+  EXPECT_EQ(R2Point(0.5, 0.25), r1.GetVertex(1));
+  EXPECT_EQ(R2Point(0.5, 0.75), r1.GetVertex(2));
+  EXPECT_EQ(R2Point(0, 0.75), r1.GetVertex(3));
+  EXPECT_TRUE(r1.Contains(R2Point(0.2, 0.4)));
+  EXPECT_FALSE(r1.Contains(R2Point(0.2, 0.8)));
+  EXPECT_FALSE(r1.Contains(R2Point(-0.1, 0.4)));
+  EXPECT_FALSE(r1.Contains(R2Point(0.6, 0.1)));
+  EXPECT_TRUE(r1.Contains(sw1));
+  EXPECT_TRUE(r1.Contains(ne1));
+  EXPECT_FALSE(r1.InteriorContains(sw1));
+  EXPECT_FALSE(r1.InteriorContains(ne1));
+
+  // Make sure that GetVertex() returns vertices in CCW order.
+  for (int k = 0; k < 4; ++k) {
+    SCOPED_TRACE(StrCat("k=", k));
+    EXPECT_TRUE(S2::SimpleCCW(S2R2Rect::ToS2Point(r1.GetVertex(k - 1)),
+                              S2R2Rect::ToS2Point(r1.GetVertex(k)),
+                              S2R2Rect::ToS2Point(r1.GetVertex(k + 1))));
+  }
+}
+
+TEST(S2R2Rect, IntervalOperations) {
+  // Contains(S2R2Rect), InteriorContains(S2R2Rect),
+  // Intersects(), InteriorIntersects(), Union(), Intersection().
+  //
+  // Much more testing of these methods is done in s1interval_test
+  // and r1interval_test.
+
+  S2R2Rect empty = S2R2Rect::Empty();
+  R2Point sw1 = R2Point(0, 0.25);
+  R2Point ne1 = R2Point(0.5, 0.75);
+  S2R2Rect r1(sw1, ne1);
+  S2R2Rect r1_mid = S2R2Rect(R2Point(0.25, 0.5), R2Point(0.25, 0.5));
+  S2R2Rect r_sw1(sw1, sw1);
+  S2R2Rect r_ne1(ne1, ne1);
+
+  TestIntervalOps(r1, r1_mid, "TTTT", r1, r1_mid);
+  TestIntervalOps(r1, r_sw1, "TFTF", r1, r_sw1);
+  TestIntervalOps(r1, r_ne1, "TFTF", r1, r_ne1);
+
+  EXPECT_EQ(S2R2Rect(R2Point(0, 0.25), R2Point(0.5, 0.75)), r1);
+  TestIntervalOps(r1, S2R2Rect(R2Point(0.45, 0.1), R2Point(0.75, 0.3)), "FFTT",
+                  S2R2Rect(R2Point(0, 0.1), R2Point(0.75, 0.75)),
+                  S2R2Rect(R2Point(0.45, 0.25), R2Point(0.5, 0.3)));
+  TestIntervalOps(r1, S2R2Rect(R2Point(0.5, 0.1), R2Point(0.7, 0.3)), "FFTF",
+                  S2R2Rect(R2Point(0, 0.1), R2Point(0.7, 0.75)),
+                  S2R2Rect(R2Point(0.5, 0.25), R2Point(0.5, 0.3)));
+  TestIntervalOps(r1, S2R2Rect(R2Point(0.45, 0.1), R2Point(0.7, 0.25)), "FFTF",
+                  S2R2Rect(R2Point(0, 0.1), R2Point(0.7, 0.75)),
+                  S2R2Rect(R2Point(0.45, 0.25), R2Point(0.5, 0.25)));
+
+  TestIntervalOps(S2R2Rect(R2Point(0.1, 0.2), R2Point(0.1, 0.3)),
+                  S2R2Rect(R2Point(0.15, 0.7), R2Point(0.2, 0.8)), "FFFF",
+                  S2R2Rect(R2Point(0.1, 0.2), R2Point(0.2, 0.8)),
+                  empty);
+
+  // Check that the intersection of two rectangles that overlap in x but not y
+  // is valid, and vice versa.
+  TestIntervalOps(S2R2Rect(R2Point(0.1, 0.2), R2Point(0.4, 0.5)),
+                  S2R2Rect(R2Point(0, 0), R2Point(0.2, 0.1)), "FFFF",
+                  S2R2Rect(R2Point(0, 0), R2Point(0.4, 0.5)), empty);
+  TestIntervalOps(S2R2Rect(R2Point(0, 0), R2Point(0.1, 0.3)),
+                  S2R2Rect(R2Point(0.2, 0.1), R2Point(0.3, 0.4)), "FFFF",
+                  S2R2Rect(R2Point(0, 0), R2Point(0.3, 0.4)), empty);
+}
+
+TEST(S2R2Rect, AddPoint) {
+  // AddPoint()
+  R2Point sw1 = R2Point(0, 0.25);
+  R2Point ne1 = R2Point(0.5, 0.75);
+  S2R2Rect r1(sw1, ne1);
+
+  S2R2Rect r2 = S2R2Rect::Empty();
+  r2.AddPoint(R2Point(0, 0.25));
+  r2.AddPoint(R2Point(0.5, 0.25));
+  r2.AddPoint(R2Point(0, 0.75));
+  r2.AddPoint(R2Point(0.1, 0.4));
+  EXPECT_EQ(r1, r2);
+}
+
+TEST(S2R2Rect, Project) {
+  S2R2Rect r1(R1Interval(0, 0.5), R1Interval(0.25, 0.75));
+
+  EXPECT_EQ(R2Point(0, 0.25), r1.Project(R2Point(-0.01, 0.24)));
+  EXPECT_EQ(R2Point(0, 0.48), r1.Project(R2Point(-5.0, 0.48)));
+  EXPECT_EQ(R2Point(0, 0.75), r1.Project(R2Point(-5.0, 2.48)));
+  EXPECT_EQ(R2Point(0.19, 0.75), r1.Project(R2Point(0.19, 2.48)));
+  EXPECT_EQ(R2Point(0.5, 0.75), r1.Project(R2Point(6.19, 2.48)));
+  EXPECT_EQ(R2Point(0.5, 0.53), r1.Project(R2Point(6.19, 0.53)));
+  EXPECT_EQ(R2Point(0.5, 0.25), r1.Project(R2Point(6.19, -2.53)));
+  EXPECT_EQ(R2Point(0.33, 0.25), r1.Project(R2Point(0.33, -2.53)));
+  EXPECT_EQ(R2Point(0.33, 0.37), r1.Project(R2Point(0.33, 0.37)));
+}
+
+TEST(S2R2Rect, Expanded) {
+  // Expanded()
+  EXPECT_TRUE(S2R2Rect::Empty().Expanded(R2Point(0.1, 0.3)).is_empty());
+  EXPECT_TRUE(S2R2Rect::Empty().Expanded(R2Point(-0.1, -0.3)).is_empty());
+  EXPECT_TRUE(S2R2Rect(R2Point(0.2, 0.4), R2Point(0.3, 0.7)).
+              Expanded(R2Point(0.1, 0.3)).
+              ApproxEquals(S2R2Rect(R2Point(0.1, 0.1), R2Point(0.4, 1.0))));
+  EXPECT_TRUE(S2R2Rect(R2Point(0.2, 0.4), R2Point(0.3, 0.7)).
+              Expanded(R2Point(-0.1, 0.3)).is_empty());
+  EXPECT_TRUE(S2R2Rect(R2Point(0.2, 0.4), R2Point(0.3, 0.7)).
+              Expanded(R2Point(0.1, -0.2)).is_empty());
+  EXPECT_TRUE(S2R2Rect(R2Point(0.2, 0.4), R2Point(0.3, 0.7)).
+              Expanded(R2Point(0.1, -0.1)).
+              ApproxEquals(S2R2Rect(R2Point(0.1, 0.5), R2Point(0.4, 0.6))));
+  EXPECT_TRUE(S2R2Rect(R2Point(0.2, 0.4), R2Point(0.3, 0.7)).Expanded(0.1).
+              ApproxEquals(S2R2Rect(R2Point(0.1, 0.3), R2Point(0.4, 0.8))));
+}
+
+TEST(S2R2Rect, Bounds) {
+  // GetCapBound(), GetRectBound()
+  S2R2Rect empty = S2R2Rect::Empty();
+  EXPECT_TRUE(empty.GetCapBound().is_empty());
+  EXPECT_TRUE(empty.GetRectBound().is_empty());
+  EXPECT_EQ(S2Cap::FromPoint(S2Point(1, 0, 0)),
+            S2R2Rect(R2Point(0.5, 0.5), R2Point(0.5, 0.5)).GetCapBound());
+  EXPECT_EQ(S2LatLngRect::FromPoint(S2LatLng::FromDegrees(0, 0)),
+            S2R2Rect(R2Point(0.5, 0.5), R2Point(0.5, 0.5)).GetRectBound());
+
+  for (int i = 0; i < 10; ++i) {
+    SCOPED_TRACE(StrCat("i=", i));
+    S2R2Rect rect = S2R2Rect::FromCellId(S2Testing::GetRandomCellId());
+    S2Cap cap = rect.GetCapBound();
+    S2LatLngRect llrect = rect.GetRectBound();
+    for (int k = 0; k < 4; ++k) {
+      S2Point v = S2R2Rect::ToS2Point(rect.GetVertex(k));
+      // v2 is a point that is well outside the rectangle.
+      S2Point v2 = (cap.center() + 3 * (v - cap.center())).Normalize();
+      EXPECT_TRUE(cap.Contains(v));
+      EXPECT_FALSE(cap.Contains(v2));
+      EXPECT_TRUE(llrect.Contains(v));
+      EXPECT_FALSE(llrect.Contains(v2));
+    }
+  }
+}
+
+TEST(S2R2Rect, CellOperations) {
+  // Contains(S2Cell), MayIntersect(S2Cell)
+
+  S2R2Rect empty = S2R2Rect::Empty();
+  TestCellOps(empty, S2Cell::FromFace(3), 0);
+
+  // This rectangle includes the first quadrant of face 0.  It's expanded
+  // slightly because cell bounding rectangles are slightly conservative.
+  S2R2Rect r4 = S2R2Rect(R2Point(0, 0), R2Point(0.5, 0.5));
+  TestCellOps(r4, S2Cell::FromFacePosLevel(0, 0, 0), 3);
+  TestCellOps(r4, S2Cell::FromFacePosLevel(0, 0, 1), 4);
+  TestCellOps(r4, S2Cell::FromFacePosLevel(1, 0, 1), 0);
+
+  // This rectangle intersects the first quadrant of face 0.
+  S2R2Rect r5 = S2R2Rect(R2Point(0, 0.45), R2Point(0.5, 0.55));
+  TestCellOps(r5, S2Cell::FromFacePosLevel(0, 0, 0), 3);
+  TestCellOps(r5, S2Cell::FromFacePosLevel(0, 0, 1), 3);
+  TestCellOps(r5, S2Cell::FromFacePosLevel(1, 0, 1), 0);
+
+  // Rectangle consisting of a single point.
+  TestCellOps(S2R2Rect(R2Point(0.51, 0.51), R2Point(0.51, 0.51)),
+              S2Cell::FromFace(0), 3);
+
+  // Rectangle that intersects the bounding rectangle of face 0
+  // but not the face itself.
+  TestCellOps(S2R2Rect(R2Point(0.01, 1.001), R2Point(0.02, 1.002)),
+              S2Cell::FromFace(0), 0);
+
+  // Rectangle that intersects one corner of face 0.
+  TestCellOps(S2R2Rect(R2Point(0.99, -0.01), R2Point(1.01, 0.01)),
+              S2Cell::FromFacePosLevel(0, ~uint64{0} >> S2CellId::kFaceBits, 5),
+              3);
+}

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

@@ -0,0 +1,26 @@
+// 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/s2region.h"
+
+#include <vector>
+
+#include "s2/s2cap.h"
+
+void S2Region::GetCellUnionBound(std::vector<S2CellId> *cell_ids) const {
+  return GetCapBound().GetCellUnionBound(cell_ids);
+}