@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,239 @@
+// Copyright 2013 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/s2min_distance_targets.h"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/util/gtl/btree_set.h"
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s1angle.h"
+#include "s2/s2cap.h"
+#include "s2/s2cell.h"
+#include "s2/s2edge_distances.h"
+#include "s2/s2shape_index.h"
+#include "s2/s2text_format.h"
+
+using s2textformat::MakeIndexOrDie;
+using s2textformat::MakePointOrDie;
+using s2textformat::ParsePointsOrDie;
+using std::vector;
+
+TEST(PointTarget, UpdateMinDistanceToEdgeWhenEqual) {
+  // Verifies that UpdateMinDistance only returns true when the new distance
+  // is less than the old distance (not less than or equal to).
+  S2MinDistancePointTarget target(MakePointOrDie("1:0"));
+  S2MinDistance dist(S1ChordAngle::Infinity());
+  auto edge = ParsePointsOrDie("0:-1, 0:1");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+}
+
+TEST(PointTarget, UpdateMinDistanceToCellWhenEqual) {
+  // Verifies that UpdateMinDistance only returns true when the new distance
+  // is less than the old distance (not less than or equal to).
+  S2MinDistancePointTarget target(MakePointOrDie("1:0"));
+  S2MinDistance dist(S1ChordAngle::Infinity());
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist));
+}
+
+TEST(EdgeTarget, UpdateMinDistanceToEdgeWhenEqual) {
+  S2MinDistanceEdgeTarget target(MakePointOrDie("1:0"), MakePointOrDie("1:1"));
+  S2MinDistance dist(S1ChordAngle::Infinity());
+  auto edge = ParsePointsOrDie("0:-1, 0:1");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+}
+
+TEST(EdgeTarget, UpdateMinDistanceToCellWhenEqual) {
+  S2MinDistanceEdgeTarget target(MakePointOrDie("1:0"), MakePointOrDie("1:1"));
+  S2MinDistance dist(S1ChordAngle::Infinity());
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist));
+}
+
+TEST(CellTarget, UpdateMinDistanceToEdgeWhenEqual) {
+  S2MinDistanceCellTarget target{S2Cell{S2CellId{MakePointOrDie("0:1")}}};
+  S2MinDistance dist(S1ChordAngle::Infinity());
+  auto edge = ParsePointsOrDie("0:-1, 0:1");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+}
+
+TEST(CellTarget, UpdateMinDistanceToCellWhenEqual) {
+  S2MinDistanceCellTarget target{S2Cell{S2CellId{MakePointOrDie("0:1")}}};
+  S2MinDistance dist(S1ChordAngle::Infinity());
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist));
+}
+
+TEST(CellUnionTarget, UpdateMinDistanceToEdgeWhenEqual) {
+  S2MinDistanceCellUnionTarget
+      target{S2CellUnion({S2CellId{MakePointOrDie("0:1")}})};
+  S2MinDistance dist(S1ChordAngle::Infinity());
+  auto edge = ParsePointsOrDie("0:-1, 0:1");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+}
+
+TEST(CellUnionTarget, UpdateMinDistanceToCellWhenEqual) {
+  S2MinDistanceCellUnionTarget
+      target{S2CellUnion({S2CellId{MakePointOrDie("0:1")}})};
+  S2MinDistance dist(S1ChordAngle::Infinity());
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist));
+}
+
+TEST(ShapeIndexTarget, UpdateMinDistanceToEdgeWhenEqual) {
+  auto target_index = MakeIndexOrDie("1:0 # #");
+  S2MinDistanceShapeIndexTarget target(target_index.get());
+  S2MinDistance dist(S1ChordAngle::Infinity());
+  auto edge = ParsePointsOrDie("0:-1, 0:1");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+}
+
+TEST(ShapeIndexTarget, UpdateMinDistanceToCellWhenEqual) {
+  auto target_index = MakeIndexOrDie("1:0 # #");
+  S2MinDistanceShapeIndexTarget target(target_index.get());
+  S2MinDistance dist(S1ChordAngle::Infinity());
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist));
+}
+
+vector<int> GetContainingShapes(S2MinDistanceTarget* target,
+                                const S2ShapeIndex& index, int max_shapes) {
+  gtl::btree_set<int32> shape_ids;
+  (void) target->VisitContainingShapes(
+      index, [&shape_ids, max_shapes](S2Shape* containing_shape,
+                                      const S2Point& target_point) {
+        shape_ids.insert(containing_shape->id());
+        return shape_ids.size() < max_shapes;
+      });
+  return vector<int>(shape_ids.begin(), shape_ids.end());
+}
+
+// Given two sorted vectors "x" and "y", returns true if x is a subset of y
+// and x.size() == x_size.
+bool IsSubsetOfSize(const vector<int>& x, const vector<int>& y,
+                    int x_size) {
+  if (x.size() != x_size) return false;
+  return std::includes(y.begin(), y.end(), x.begin(), x.end());
+}
+
+TEST(PointTarget, VisitContainingShapes) {
+  // Only shapes 2 and 4 should contain the target point.
+  auto index = MakeIndexOrDie(
+      "1:1 # 1:1, 2:2 # 0:0, 0:3, 3:0 | 6:6, 6:9, 9:6 | 0:0, 0:4, 4:0");
+  S2MinDistancePointTarget target(MakePointOrDie("1:1"));
+  EXPECT_TRUE(IsSubsetOfSize(GetContainingShapes(&target, *index, 1),
+                             vector<int>{2, 4}, 1));
+  EXPECT_EQ((vector<int>{2, 4}), GetContainingShapes(&target, *index, 5));
+}
+
+TEST(EdgeTarget, VisitContainingShapes) {
+  // Only shapes 2 and 4 should contain the target point.
+  auto index = MakeIndexOrDie(
+      "1:1 # 1:1, 2:2 # 0:0, 0:3, 3:0 | 6:6, 6:9, 9:6 | 0:0, 0:4, 4:0");
+  S2MinDistanceEdgeTarget target(MakePointOrDie("1:2"), MakePointOrDie("2:1"));
+  EXPECT_TRUE(IsSubsetOfSize(GetContainingShapes(&target, *index, 1),
+                             vector<int>{2, 4}, 1));
+  EXPECT_EQ((vector<int>{2, 4}), GetContainingShapes(&target, *index, 5));
+}
+
+TEST(CellTarget, VisitContainingShapes) {
+  auto index = MakeIndexOrDie(
+      "1:1 # 1:1, 2:2 # 0:0, 0:3, 3:0 | 6:6, 6:9, 9:6 | -1:-1, -1:5, 5:-1");
+  // Only shapes 2 and 4 should contain a very small cell near 1:1.
+  S2CellId cellid1(MakePointOrDie("1:1"));
+  S2MinDistanceCellTarget target1{S2Cell(cellid1)};
+  EXPECT_TRUE(IsSubsetOfSize(GetContainingShapes(&target1, *index, 1),
+                             vector<int>{2, 4}, 1));
+  EXPECT_EQ((vector<int>{2, 4}), GetContainingShapes(&target1, *index, 5));
+
+  // For a larger cell that properly contains one or more index cells, all
+  // shapes that intersect the first such cell in S2CellId order are returned.
+  // In the test below, this happens to again be the 1st and 3rd polygons
+  // (whose shape_ids are 2 and 4).
+  S2CellId cellid2 = cellid1.parent(5);
+  S2MinDistanceCellTarget target2{S2Cell(cellid2)};
+  EXPECT_EQ((vector<int>{2, 4}), GetContainingShapes(&target2, *index, 5));
+}
+
+TEST(CellUnionTarget, VisitContainingShapes) {
+  auto index = MakeIndexOrDie(
+      "1:1 # 1:1, 2:2 # 0:0, 0:3, 3:0 | 6:6, 6:9, 9:6 | -1:-1, -1:5, 5:-1");
+  // Shapes 2 and 4 contain the leaf cell near 1:1, while shape 3 contains the
+  // leaf cell near 7:7.
+  S2CellId cellid1(MakePointOrDie("1:1")), cellid2(MakePointOrDie("7:7"));
+  S2MinDistanceCellUnionTarget target1{S2CellUnion({cellid1, cellid2})};
+  EXPECT_TRUE(IsSubsetOfSize(GetContainingShapes(&target1, *index, 1),
+                             vector<int>{2, 3, 4}, 1));
+  EXPECT_EQ((vector<int>{2, 3, 4}), GetContainingShapes(&target1, *index, 5));
+}
+
+TEST(ShapeIndexTarget, VisitContainingShapes) {
+  // Create an index containing a repeated grouping of one point, one
+  // polyline, and one polygon.
+  auto index = MakeIndexOrDie(
+      "1:1 | 4:4 | 7:7 | 10:10 # "
+      "1:1, 1:2 | 4:4, 4:5 | 7:7, 7:8 | 10:10, 10:11 # "
+      "0:0, 0:3, 3:0 | 3:3, 3:6, 6:3 | 6:6, 6:9, 9:6 | 9:9, 9:12, 12:9");
+
+  // Construct a target consisting of one point, one polyline, and one polygon
+  // with two loops where only the second loop is contained by a polygon in
+  // the index above.
+  auto target_index = MakeIndexOrDie(
+      "1:1 # 4:5, 5:4 # 20:20, 20:21, 21:20; 10:10, 10:11, 11:10");
+
+  S2MinDistanceShapeIndexTarget target(target_index.get());
+  // These are the shape_ids of the 1st, 2nd, and 4th polygons of "index"
+  // (noting that the 4 points are represented by one S2PointVectorShape).
+  EXPECT_EQ((vector<int>{5, 6, 8}), GetContainingShapes(&target, *index, 5));
+}
+
+TEST(ShapeIndexTarget, VisitContainingShapesEmptyAndFull) {
+  // Verify that VisitContainingShapes never returns empty polygons and always
+  // returns full polygons (i.e., those containing the entire sphere).
+
+  // Creating an index containing one empty and one full polygon.
+  auto index = MakeIndexOrDie("# # empty | full");
+
+  // Check only the full polygon is returned for a point target.
+  auto point_index = MakeIndexOrDie("1:1 # #");
+  S2MinDistanceShapeIndexTarget point_target(point_index.get());
+  EXPECT_EQ((vector<int>{1}), GetContainingShapes(&point_target, *index, 5));
+
+  // Check only the full polygon is returned for a full polygon target.
+  auto full_polygon_index = MakeIndexOrDie("# # full");
+  S2MinDistanceShapeIndexTarget full_target(full_polygon_index.get());
+  EXPECT_EQ((vector<int>{1}), GetContainingShapes(&full_target, *index, 5));
+
+  // Check that nothing is returned for an empty polygon target.  (An empty
+  // polygon has no connected components and does not intersect anything, so
+  // according to the API of GetContainingShapes nothing should be returned.)
+  auto empty_polygon_index = MakeIndexOrDie("# # empty");
+  S2MinDistanceShapeIndexTarget empty_target(empty_polygon_index.get());
+  EXPECT_EQ((vector<int>{}), GetContainingShapes(&empty_target, *index, 5));
+}

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

@@ -0,0 +1,162 @@
+// Copyright 2013 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/s2padded_cell.h"
+
+#include <algorithm>
+#include <cfloat>
+
+#include "s2/util/bits/bits.h"
+#include "s2/r1interval.h"
+#include "s2/s2coords.h"
+
+using std::max;
+using std::min;
+using S2::internal::kSwapMask;
+using S2::internal::kInvertMask;
+using S2::internal::kIJtoPos;
+using S2::internal::kPosToOrientation;
+
+S2PaddedCell::S2PaddedCell(S2CellId id, double padding)
+    : id_(id), padding_(padding) {
+  if (id_.is_face()) {
+    // Fast path for constructing a top-level face (the most common case).
+    double limit = 1 + padding;
+    bound_ = R2Rect(R1Interval(-limit, limit), R1Interval(-limit, limit));
+    middle_ = R2Rect(R1Interval(-padding, padding),
+                     R1Interval(-padding, padding));
+    ij_lo_[0] = ij_lo_[1] = 0;
+    orientation_ = id_.face() & 1;
+    level_ = 0;
+  } else {
+    int ij[2];
+    id.ToFaceIJOrientation(&ij[0], &ij[1], &orientation_);
+    level_ = id.level();
+    bound_ = S2CellId::IJLevelToBoundUV(ij, level_).Expanded(padding);
+    int ij_size = S2CellId::GetSizeIJ(level_);
+    ij_lo_[0] = ij[0] & -ij_size;
+    ij_lo_[1] = ij[1] & -ij_size;
+  }
+}
+
+S2PaddedCell::S2PaddedCell(const S2PaddedCell& parent, int i, int j)
+    : padding_(parent.padding_),
+      bound_(parent.bound_),
+      level_(parent.level_ + 1) {
+  // Compute the position and orientation of the child incrementally from the
+  // orientation of the parent.
+  int pos = kIJtoPos[parent.orientation_][2*i+j];
+  id_ = parent.id_.child(pos);
+  int ij_size = S2CellId::GetSizeIJ(level_);
+  ij_lo_[0] = parent.ij_lo_[0] + i * ij_size;
+  ij_lo_[1] = parent.ij_lo_[1] + j * ij_size;
+  orientation_ = parent.orientation_ ^ kPosToOrientation[pos];
+  // For each child, one corner of the bound is taken directly from the parent
+  // while the diagonally opposite corner is taken from middle().
+  const R2Rect& middle = parent.middle();
+  bound_[0][1-i] = middle[0][1-i];
+  bound_[1][1-j] = middle[1][1-j];
+}
+
+const R2Rect& S2PaddedCell::middle() const {
+  // We compute this field lazily because it is not needed the majority of the
+  // time (i.e., for cells where the recursion terminates).
+  if (middle_.is_empty()) {
+    int ij_size = S2CellId::GetSizeIJ(level_);
+    double u = S2::STtoUV(S2::SiTitoST(2 * ij_lo_[0] + ij_size));
+    double v = S2::STtoUV(S2::SiTitoST(2 * ij_lo_[1] + ij_size));
+    middle_ = R2Rect(R1Interval(u - padding_, u + padding_),
+                     R1Interval(v - padding_, v + padding_));
+  }
+  return middle_;
+}
+
+S2Point S2PaddedCell::GetCenter() const {
+  int ij_size = S2CellId::GetSizeIJ(level_);
+  unsigned int si = 2 * ij_lo_[0] + ij_size;
+  unsigned int ti = 2 * ij_lo_[1] + ij_size;
+  return S2::FaceSiTitoXYZ(id_.face(), si, ti).Normalize();
+}
+
+S2Point S2PaddedCell::GetEntryVertex() const {
+  // The curve enters at the (0,0) vertex unless the axis directions are
+  // reversed, in which case it enters at the (1,1) vertex.
+  unsigned int i = ij_lo_[0];
+  unsigned int j = ij_lo_[1];
+  if (orientation_ & kInvertMask) {
+    int ij_size = S2CellId::GetSizeIJ(level_);
+    i += ij_size;
+    j += ij_size;
+  }
+  return S2::FaceSiTitoXYZ(id_.face(), 2 * i, 2 * j).Normalize();
+}
+
+S2Point S2PaddedCell::GetExitVertex() const {
+  // The curve exits at the (1,0) vertex unless the axes are swapped or
+  // inverted but not both, in which case it exits at the (0,1) vertex.
+  unsigned int i = ij_lo_[0];
+  unsigned int j = ij_lo_[1];
+  int ij_size = S2CellId::GetSizeIJ(level_);
+  if (orientation_ == 0 || orientation_ == kSwapMask + kInvertMask) {
+    i += ij_size;
+  } else {
+    j += ij_size;
+  }
+  return S2::FaceSiTitoXYZ(id_.face(), 2 * i, 2 * j).Normalize();
+}
+
+S2CellId S2PaddedCell::ShrinkToFit(const R2Rect& rect) const {
+  S2_DCHECK(bound().Intersects(rect));
+
+  // Quick rejection test: if "rect" contains the center of this cell along
+  // either axis, then no further shrinking is possible.
+  int ij_size = S2CellId::GetSizeIJ(level_);
+  if (level_ == 0) {
+    // Fast path (most calls to this function start with a face cell).
+    if (rect[0].Contains(0) || rect[1].Contains(0)) return id();
+  } else {
+    if (rect[0].Contains(S2::STtoUV(S2::SiTitoST(2 * ij_lo_[0] + ij_size))) ||
+        rect[1].Contains(S2::STtoUV(S2::SiTitoST(2 * ij_lo_[1] + ij_size)))) {
+      return id();
+    }
+  }
+  // Otherwise we expand "rect" by the given padding() on all sides and find
+  // the range of coordinates that it spans along the i- and j-axes.  We then
+  // compute the highest bit position at which the min and max coordinates
+  // differ.  This corresponds to the first cell level at which at least two
+  // children intersect "rect".
+
+  // Increase the padding to compensate for the error in S2::UVtoST().
+  // (The constant below is a provable upper bound on the additional error.)
+  R2Rect padded = rect.Expanded(padding() + 1.5 * DBL_EPSILON);
+  int ij_min[2];  // Min i- or j- coordinate spanned by "padded"
+  int ij_xor[2];  // XOR of the min and max i- or j-coordinates
+  for (int d = 0; d < 2; ++d) {
+    ij_min[d] = max(ij_lo_[d], S2::STtoIJ(S2::UVtoST(padded[d][0])));
+    int ij_max = min(ij_lo_[d] + ij_size - 1,
+                     S2::STtoIJ(S2::UVtoST(padded[d][1])));
+    ij_xor[d] = ij_min[d] ^ ij_max;
+  }
+  // Compute the highest bit position where the two i- or j-endpoints differ,
+  // and then choose the cell level that includes both of these endpoints.  So
+  // if both pairs of endpoints are equal we choose kMaxLevel; if they differ
+  // only at bit 0, we choose (kMaxLevel - 1), and so on.
+  int level_msb = ((ij_xor[0] | ij_xor[1]) << 1) + 1;
+  int level = S2CellId::kMaxLevel - Bits::FindMSBSetNonZero(level_msb);
+  if (level <= level_) return id();
+  return S2CellId::FromFaceIJ(id().face(), ij_min[0], ij_min[1]).parent(level);
+}

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

@@ -0,0 +1,108 @@
+// Copyright 2013 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_S2PADDED_CELL_H_
+#define S2_S2PADDED_CELL_H_
+
+#include "s2/_fp_contract_off.h"
+#include "s2/r2rect.h"
+#include "s2/s2cell_id.h"
+
+// S2PaddedCell represents an S2Cell whose (u,v)-range has been expanded on
+// all sides by a given amount of "padding".  Unlike S2Cell, its methods and
+// representation are optimized for clipping edges against S2Cell boundaries
+// to determine which cells are intersected by a given set of edges.
+//
+// This class is intended to be copied by value as desired.
+class S2PaddedCell {
+ public:
+  // Construct an S2PaddedCell for the given cell id and padding.
+  S2PaddedCell(S2CellId id, double padding);
+
+  // Construct the child of "parent" with the given (i,j) index.  The four
+  // child cells have indices of (0,0), (0,1), (1,0), (1,1), where the i and j
+  // indices correspond to increasing u- and v-values respectively.
+  S2PaddedCell(const S2PaddedCell& parent, int i, int j);
+
+  S2CellId id() const { return id_; }
+  double padding() const { return padding_; }
+  int level() const { return level_; }
+
+  // Return the bound for this cell (including padding).
+  const R2Rect& bound() const { return bound_; }
+
+  // Return the "middle" of the padded cell, defined as the rectangle that
+  // belongs to all four children.
+  //
+  // Note that this method is *not* thread-safe, because the return value is
+  // computed on demand and cached.  (It is expected that this class will be
+  // mainly useful in the context of single-threaded recursive algorithms.)
+  const R2Rect& middle() const;
+
+  // Return the (i,j) coordinates for the child cell at the given traversal
+  // position.  The traversal position corresponds to the order in which child
+  // cells are visited by the Hilbert curve.
+  void GetChildIJ(int pos, int* i, int* j) const;
+
+  // Return the smallest cell that contains all descendants of this cell whose
+  // bounds intersect "rect".  For algorithms that use recursive subdivision
+  // to find the cells that intersect a particular object, this method can be
+  // used to skip all the initial subdivision steps where only one child needs
+  // to be expanded.
+  //
+  // Note that this method is not the same as returning the smallest cell that
+  // contains the intersection of this cell with "rect".  Because of the
+  // padding, even if one child completely contains "rect" it is still
+  // possible that a neighboring child also intersects "rect".
+  //
+  // REQUIRES: bound().Intersects(rect)
+  S2CellId ShrinkToFit(const R2Rect& rect) const;
+
+  // Return the center of this cell.
+  S2Point GetCenter() const;
+
+  // Return the vertex where the S2 space-filling curve enters this cell.
+  S2Point GetEntryVertex() const;
+
+  // Return the vertex where the S2 space-filling curve exits this cell.
+  S2Point GetExitVertex() const;
+
+ private:
+  S2CellId id_;
+  double padding_;
+  R2Rect bound_;     // Bound in (u,v)-space
+
+  // The rectangle in (u,v)-space that belongs to all four padded children.
+  // It is computed on demand by the middle() accessor method.
+  mutable R2Rect middle_;
+
+  int ij_lo_[2];     // Minimum (i,j)-coordinates of this cell, before padding
+  int orientation_;  // Hilbert curve orientation of this cell (see s2coords.h)
+  int level_;        // Level of this cell (see s2coords.h)
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+inline void S2PaddedCell::GetChildIJ(int pos, int* i, int* j) const {
+  int ij = S2::internal::kPosToIJ[orientation_][pos];
+  *i = ij >> 1;
+  *j = ij & 1;
+}
+
+#endif  // S2_S2PADDED_CELL_H_

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

@@ -0,0 +1,138 @@
+// Copyright 2013 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/s2padded_cell.h"
+
+#include <algorithm>
+#include <cmath>
+
+#include <gtest/gtest.h>
+#include "s2/r1interval.h"
+#include "s2/r2.h"
+#include "s2/s2cell.h"
+#include "s2/s2testing.h"
+
+using std::min;
+
+namespace {
+
+void CompareS2CellToPadded(const S2Cell& cell, const S2PaddedCell& pcell,
+                           double padding) {
+  EXPECT_EQ(cell.id(), pcell.id());
+  EXPECT_EQ(cell.level(), pcell.level());
+  EXPECT_EQ(padding, pcell.padding());
+  EXPECT_EQ(cell.GetBoundUV().Expanded(padding), pcell.bound());
+  R2Point center_uv = cell.id().GetCenterUV();
+  EXPECT_EQ(R2Rect::FromPoint(center_uv).Expanded(padding), pcell.middle());
+  EXPECT_EQ(cell.GetCenter(), pcell.GetCenter());
+}
+
+TEST(S2PaddedCell, S2CellMethods) {
+  // Test the S2PaddedCell methods that have approximate S2Cell equivalents.
+  const int kIters = 1000;
+  for (int iter = 0; iter < kIters; ++iter) {
+    S2CellId id = S2Testing::GetRandomCellId();
+    double padding = pow(1e-15, S2Testing::rnd.RandDouble());
+    S2Cell cell(id);
+    S2PaddedCell pcell(id, padding);
+    CompareS2CellToPadded(cell, pcell, padding);
+    if (!id.is_leaf()) {
+      S2Cell children[4];
+      EXPECT_TRUE(cell.Subdivide(children));
+      for (int pos = 0; pos < 4; ++pos) {
+        int i, j;
+        pcell.GetChildIJ(pos, &i, &j);
+        CompareS2CellToPadded(children[pos], S2PaddedCell(pcell, i, j),
+                              padding);
+      }
+    }
+  }
+}
+
+TEST(S2PaddedCell, GetEntryExitVertices) {
+  const int kIters = 1000;
+  for (int iter = 0; iter < kIters; ++iter) {
+    S2CellId id = S2Testing::GetRandomCellId();
+    // Check that entry/exit vertices do not depend on padding.
+    EXPECT_EQ(S2PaddedCell(id, 0).GetEntryVertex(),
+              S2PaddedCell(id, 0.5).GetEntryVertex());
+    EXPECT_EQ(S2PaddedCell(id, 0).GetExitVertex(),
+              S2PaddedCell(id, 0.5).GetExitVertex());
+
+    // Check that the exit vertex of one cell is the same as the entry vertex
+    // of the immediately following cell.  (This also tests wrapping from the
+    // end to the start of the S2CellId curve with high probability.)
+    EXPECT_EQ(S2PaddedCell(id, 0).GetExitVertex(),
+              S2PaddedCell(id.next_wrap(), 0).GetEntryVertex());
+
+    // Check that the entry vertex of a cell is the same as the entry vertex
+    // of its first child, and similarly for the exit vertex.
+    if (!id.is_leaf()) {
+      EXPECT_EQ(S2PaddedCell(id, 0).GetEntryVertex(),
+                S2PaddedCell(id.child(0), 0).GetEntryVertex());
+      EXPECT_EQ(S2PaddedCell(id, 0).GetExitVertex(),
+                S2PaddedCell(id.child(3), 0).GetExitVertex());
+    }
+  }
+}
+
+static double SampleInterval(const R1Interval& x) {
+  return S2Testing::rnd.UniformDouble(x.lo(), x.hi());
+}
+
+TEST(S2PaddedCell, ShrinkToFit) {
+  const int kIters = 1000;
+  S2Testing::Random* rnd = &S2Testing::rnd;
+  for (int iter = 0; iter < kIters; ++iter) {
+    // Start with the desired result and work backwards.
+    S2CellId result = S2Testing::GetRandomCellId();
+    R2Rect result_uv = result.GetBoundUV();
+    R2Point size_uv = result_uv.GetSize();
+
+    // Find the biggest rectangle that fits in "result" after padding.
+    // (These calculations ignore numerical errors.)
+    double max_padding = 0.5 * min(size_uv[0], size_uv[1]);
+    double padding = max_padding * rnd->RandDouble();
+    R2Rect max_rect = result_uv.Expanded(-padding);
+
+    // Start with a random subset of the maximum rectangle.
+    R2Point a(SampleInterval(max_rect[0]), SampleInterval(max_rect[1]));
+    R2Point b(SampleInterval(max_rect[0]), SampleInterval(max_rect[1]));
+    if (!result.is_leaf()) {
+      // If the result is not a leaf cell, we must ensure that no child of
+      // "result" also satisfies the conditions of ShrinkToFit().  We do this
+      // by ensuring that "rect" intersects at least two children of "result"
+      // (after padding).
+      int axis = rnd->Uniform(2);
+      double center = result.GetCenterUV()[axis];
+
+      // Find the range of coordinates that are shared between child cells
+      // along that axis.
+      R1Interval shared(center - padding, center + padding);
+      double mid = SampleInterval(shared.Intersection(max_rect[axis]));
+      a[axis] = SampleInterval(R1Interval(max_rect[axis].lo(), mid));
+      b[axis] = SampleInterval(R1Interval(mid, max_rect[axis].hi()));
+    }
+    R2Rect rect = R2Rect::FromPointPair(a, b);
+
+    // Choose an arbitrary ancestor as the S2PaddedCell.
+    S2CellId initial_id = result.parent(rnd->Uniform(result.level() + 1));
+    EXPECT_EQ(result, S2PaddedCell(initial_id, padding).ShrinkToFit(rect));
+  }
+}
+
+}  // namespace

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

@@ -0,0 +1,38 @@
+// 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_S2POINT_H_
+#define S2_S2POINT_H_
+
+#include "s2/_fp_contract_off.h"
+#include "s2/util/math/vector.h"  // IWYU pragma: export
+#include "s2/util/math/vector3_hash.h"
+
+// An S2Point represents a point on the unit sphere as a 3D vector.  Usually
+// points are normalized to be unit length, but some methods do not require
+// this.  See util/math/vector.h for the methods available.  Among other
+// things, there are overloaded operators that make it convenient to write
+// arithmetic expressions (e.g. (1-x)*p1 + x*p2).
+using S2Point = Vector3_d;
+
+// S2PointHash can be used with standard containers (e.g., unordered_set) or
+// nonstandard extensions (e.g., hash_map).  It is defined such that if two
+// S2Points compare equal to each other, they have the same hash.  (This
+// requires that positive and negative zero hash to the same value.)
+using S2PointHash = GoodFastHash<S2Point>;
+
+#endif  // S2_S2POINT_H_