@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,283 @@
+// 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)
+//
+// Helper functions for encoding/decoding S2Shapes and S2Shape vectors.
+// Design goals:
+//
+//  - Allow control over encoding tradeoffs (i.e., speed vs encoding size).
+//
+//  - Allow control over decoding tradeoffs (e.g., whether to decode data
+//    immediately or lazily).
+//
+//  - Don't force all S2Shape types to have the same Encode() method.  Some
+//    implementations may want extra parameters.
+//
+//  - Support custom encodings of shape vectors; e.g., if all shapes are
+//    of a known type, then there is no need to tag them individually.
+//
+//  - Support client-defined S2Shape types.
+//
+//  - Support client-defined encodings of standard S2Shape types.
+
+#ifndef S2_S2SHAPEUTIL_CODING_H_
+#define S2_S2SHAPEUTIL_CODING_H_
+
+#include <functional>
+#include <memory>
+#include "s2/util/coding/coder.h"
+#include "s2/encoded_string_vector.h"
+#include "s2/s2shape.h"
+#include "s2/s2shape_index.h"
+
+namespace s2shapeutil {
+
+// A function that appends a serialized representation of the given shape to
+// the given Encoder.  The encoding should *not* include any type information
+// (e.g., shape->type_tag()); the caller is responsible for encoding this
+// separately if necessary.
+//
+// Note that you can add your own encodings and/or shape types by wrapping one
+// of the standard functions and adding exceptions:
+//
+// void MyShapeEncoder(const S2Shape& shape, Encoder* encoder) {
+//   if (shape.type_tag() == MyShape::kTypeTag) {
+//     down_cast<const MyShape*>(&shape)->Encode(encoder);
+//     return true;
+//   } else {
+//     return CompactEncodeShape(shape, encoder);
+//   }
+// }
+//
+// REQUIRES: "encoder" uses the default constructor, so that its buffer
+//           can be enlarged as necessary by calling Ensure(int).
+using ShapeEncoder =
+    std::function<bool (const S2Shape& shape, Encoder* encoder)>;
+
+// A ShapeEncoder that can encode all standard S2Shape types, preferring fast
+// (but larger) encodings.  For example, points are typically represented as
+// uncompressed S2Point values (24 bytes each).
+//
+// REQUIRES: "encoder" uses the default constructor, so that its buffer
+//           can be enlarged as necessary by calling Ensure(int).
+bool FastEncodeShape(const S2Shape& shape, Encoder* encoder);
+
+// A ShapeEncoder that encode all standard S2Shape types, preferring
+// compact (but slower) encodings.  For example, points that have been snapped
+// to S2CellId centers will be encoded using at most 8 bytes.
+//
+// REQUIRES: "encoder" uses the default constructor, so that its buffer
+//           can be enlarged as necessary by calling Ensure(int).
+bool CompactEncodeShape(const S2Shape& shape, Encoder* encoder);
+
+// A function that decodes an S2Shape of the given type, consuming data from
+// the given Decoder.  Returns nullptr on errors.
+using ShapeDecoder =
+    std::function<std::unique_ptr<S2Shape>(S2Shape::TypeTag tag,
+                                           Decoder* decoder)>;
+
+// A ShapeDecoder that fully decodes an S2Shape of the given type.  After this
+// function returns, the underlying Decoder data is no longer needed.
+std::unique_ptr<S2Shape> FullDecodeShape(S2Shape::TypeTag tag,
+                                         Decoder* decoder);
+
+// A ShapeDecoder that prefers to decode the given S2Shape lazily (as data is
+// accessed).  This is only possible when the given shape type (e.g.,
+// LaxPolygonShape) has an alternate implementation that can work directly
+// with encoded data (e.g., EncodedLaxPolygonShape).  All other shape types
+// are handled by decoding them fully (e.g., S2Polygon::Shape).
+std::unique_ptr<S2Shape> LazyDecodeShape(S2Shape::TypeTag tag,
+                                         Decoder* decoder);
+
+// Encodes the shapes in the given S2ShapeIndex.  Each shape is encoded with a
+// type tag allows it to be decoded into an S2Shape of the appropriate type.
+// "shape_encoder" allows control over the encoding strategy.  Note that when
+// an S2ShapeIndex is also being encoded, it should be encoded *after* the
+// shape vector, like this:
+//
+//   s2shapeutil::CompactEncodeTaggedShapes(index, encoder);
+//   index.Encode(encoder);
+//
+// This is because when the index is decoded, the shape vector is required as
+// a parameter.
+//
+// REQUIRES: "encoder" uses the default constructor, so that its buffer
+//           can be enlarged as necessary by calling Ensure(int).
+bool EncodeTaggedShapes(const S2ShapeIndex& index,
+                        const ShapeEncoder& shape_encoder,
+                        Encoder* encoder);
+
+// Convenience function that calls EncodeTaggedShapes using FastEncodeShape as
+// the ShapeEncoder.
+//
+// REQUIRES: "encoder" uses the default constructor, so that its buffer
+//           can be enlarged as necessary by calling Ensure(int).
+bool FastEncodeTaggedShapes(const S2ShapeIndex& index, Encoder* encoder);
+
+// Convenience function that calls EncodeTaggedShapes using CompactEncodeShape
+// as the ShapeEncoder.
+//
+// REQUIRES: "encoder" uses the default constructor, so that its buffer
+//           can be enlarged as necessary by calling Ensure(int).
+bool CompactEncodeTaggedShapes(const S2ShapeIndex& index, Encoder* encoder);
+
+// A ShapeFactory that decodes a vector generated by EncodeTaggedShapes()
+// above.  Example usage:
+//
+//   index.Init(decoder, s2shapeutil::FullDecodeShapeFactory(decoder));
+//
+// Note that the S2Shape vector must be encoded *before* the S2ShapeIndex
+// (like the example code for EncodeTaggedShapes), since the shapes need to be
+// decoded before the index.
+//
+// REQUIRES: The Decoder data buffer must outlive all calls to the given
+//           ShapeFactory (not including its destructor).
+class TaggedShapeFactory : public S2ShapeIndex::ShapeFactory {
+ public:
+  // Returns an empty vector and/or null S2Shapes on decoding errors.
+  TaggedShapeFactory(const ShapeDecoder& shape_decoder, Decoder* decoder);
+
+  int size() const override { return encoded_shapes_.size(); }
+
+  std::unique_ptr<S2Shape> operator[](int shape_id) const override;
+
+  std::unique_ptr<ShapeFactory> Clone() const override {
+    return absl::make_unique<TaggedShapeFactory>(*this);
+  }
+
+ private:
+  ShapeDecoder shape_decoder_;
+  s2coding::EncodedStringVector encoded_shapes_;
+};
+
+// Convenience function that calls TaggedShapeFactory using FullDecodeShape
+// as the ShapeDecoder.
+TaggedShapeFactory FullDecodeShapeFactory(Decoder* decoder);
+
+// Convenience function that calls TaggedShapeFactory using LazyDecodeShape
+// as the ShapeDecoder.
+TaggedShapeFactory LazyDecodeShapeFactory(Decoder* decoder);
+
+// A ShapeFactory that simply returns shapes from the given vector.
+//
+// REQUIRES: Each shape is requested at most once.  (This implies that when
+// the ShapeFactory is passed to an S2ShapeIndex, S2ShapeIndex::Minimize must
+// not be called.)  Additional requests for the same shape return nullptr.
+class VectorShapeFactory : public S2ShapeIndex::ShapeFactory {
+ public:
+  explicit VectorShapeFactory(std::vector<std::unique_ptr<S2Shape>> shapes);
+
+  int size() const override { return shared_shapes_->size(); }
+
+  std::unique_ptr<S2Shape> operator[](int shape_id) const override;
+
+  std::unique_ptr<ShapeFactory> Clone() const override {
+    return absl::make_unique<VectorShapeFactory>(*this);
+  }
+
+ private:
+  // Since this class is copyable, we need to access the shape vector through
+  // a shared pointer.
+  std::shared_ptr<std::vector<std::unique_ptr<S2Shape>>> shared_shapes_;
+};
+
+// A ShapeFactory that returns the single given S2Shape.  Useful for testing.
+VectorShapeFactory SingletonShapeFactory(std::unique_ptr<S2Shape> shape);
+
+// A ShapeFactory that wraps the shapes from the given index.  Used for testing.
+class WrappedShapeFactory : public S2ShapeIndex::ShapeFactory {
+ public:
+  // REQUIRES: The given index must persist for the lifetime of this object.
+  explicit WrappedShapeFactory(const S2ShapeIndex* index) : index_(*index) {}
+
+  int size() const override { return index_.num_shape_ids(); }
+
+  std::unique_ptr<S2Shape> operator[](int shape_id) const override;
+
+  std::unique_ptr<ShapeFactory> Clone() const override {
+    return absl::make_unique<WrappedShapeFactory>(*this);
+  }
+
+ private:
+  const S2ShapeIndex& index_;
+};
+
+
+// Encodes the shapes in the given index, which must all have the same type.
+// The given Shape type does *not* need to have a "type tag" assigned.
+// This is useful for encoding experimental or locally defined types, or when
+// the S2Shape type in a given index is known in advance.
+//
+// REQUIRES: The Shape class must have an Encode(Encoder*) method.
+// REQUIRES: "encoder" uses the default constructor, so that its buffer
+//           can be enlarged as necessary by calling Ensure(int).
+template <class Shape>
+void EncodeHomogeneousShapes(const S2ShapeIndex& index, Encoder* encoder);
+
+// A ShapeFactory that decodes shapes of a given fixed type (e.g.,
+// EncodedS2LaxPolylineShape).  Example usage:
+//
+// REQUIRES: The Shape type must have an Init(Decoder*) method.
+// REQUIRES: The Decoder data buffer must outlive the returned ShapeFactory
+//           and all shapes returned by that factory.
+template <class Shape>
+class HomogeneousShapeFactory : public S2ShapeIndex::ShapeFactory {
+ public:
+  // Returns an empty vector and/or null S2Shapes on decoding errors.
+  explicit HomogeneousShapeFactory(Decoder* decoder);
+
+  int size() const override { return encoded_shapes_.size(); }
+
+  std::unique_ptr<S2Shape> operator[](int shape_id) const override;
+
+  std::unique_ptr<ShapeFactory> Clone() const override {
+    return absl::make_unique<HomogeneousShapeFactory>(*this);
+  }
+
+ private:
+  s2coding::EncodedStringVector encoded_shapes_;
+};
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+template <class Shape>
+void EncodeHomogeneousShapes(const S2ShapeIndex& index, Encoder* encoder) {
+  s2coding::StringVectorEncoder shape_vector;
+  for (S2Shape* shape : index) {
+    S2_DCHECK(shape != nullptr);
+    down_cast<Shape*>(shape)->Encode(shape_vector.AddViaEncoder());
+  }
+  shape_vector.Encode(encoder);
+}
+
+template <class Shape>
+HomogeneousShapeFactory<Shape>::HomogeneousShapeFactory(Decoder* decoder) {
+  if (!encoded_shapes_.Init(decoder)) encoded_shapes_.Clear();
+}
+
+template <class Shape>
+std::unique_ptr<S2Shape> HomogeneousShapeFactory<Shape>::operator[](
+    int shape_id) const {
+  Decoder decoder = encoded_shapes_.GetDecoder(shape_id);
+  auto shape = absl::make_unique<Shape>();
+  if (!shape->Init(&decoder)) return nullptr;
+  return std::move(shape);  // Converts from Shape to S2Shape.
+}
+
+}  // namespace s2shapeutil
+
+#endif  // S2_S2SHAPEUTIL_CODING_H_

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

@@ -0,0 +1,54 @@
+// 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/s2shapeutil_coding.h"
+
+#include <gtest/gtest.h>
+#include "s2/util/coding/coder.h"
+#include "s2/s2polygon.h"
+#include "s2/s2text_format.h"
+
+using absl::make_unique;
+
+namespace s2shapeutil {
+
+TEST(FastEncodeShape, S2Polygon) {
+  auto polygon = s2textformat::MakePolygonOrDie("0:0, 0:1, 1:0");
+  auto shape = make_unique<S2Polygon::Shape>(polygon.get());
+  Encoder encoder;
+  FastEncodeShape(*shape, &encoder);
+  Decoder decoder(encoder.base(), encoder.length());
+  auto shape2 = FullDecodeShape(S2Polygon::Shape::kTypeTag, &decoder);
+  EXPECT_TRUE(shape->polygon()->Equals(
+      down_cast<S2Polygon::Shape*>(shape2.get())->polygon()));
+}
+
+TEST(FastEncodeTaggedShapes, MixedShapes) {
+  // Tests encoding/decoding a collection of points, polylines, and polygons.
+  auto index = s2textformat::MakeIndexOrDie(
+      "0:0 | 0:1 # 1:1, 1:2, 1:3 # 2:2; 2:3, 2:4, 3:3");
+  Encoder encoder;
+  s2shapeutil::FastEncodeTaggedShapes(*index, &encoder);
+  index->Encode(&encoder);
+  Decoder decoder(encoder.base(), encoder.length());
+  MutableS2ShapeIndex decoded_index;
+  decoded_index.Init(&decoder, s2shapeutil::FullDecodeShapeFactory(&decoder));
+  EXPECT_EQ(s2textformat::ToString(*index),
+            s2textformat::ToString(decoded_index));
+}
+
+}  // namespace s2shapeutil

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

@@ -0,0 +1,40 @@
+// Copyright 2017 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/s2shapeutil_contains_brute_force.h"
+
+#include <utility>
+#include "s2/s2edge_crosser.h"
+
+namespace s2shapeutil {
+
+bool ContainsBruteForce(const S2Shape& shape, const S2Point& point) {
+  if (shape.dimension() < 2) return false;
+
+  S2Shape::ReferencePoint ref_point = shape.GetReferencePoint();
+  if (ref_point.point == point) return ref_point.contained;
+
+  S2CopyingEdgeCrosser crosser(ref_point.point, point);
+  bool inside = ref_point.contained;
+  for (int e = 0; e < shape.num_edges(); ++e) {
+    auto edge = shape.edge(e);
+    inside ^= crosser.EdgeOrVertexCrossing(edge.v0, edge.v1);
+  }
+  return inside;
+}
+
+}  // namespace s2shapeutil

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

@@ -0,0 +1,41 @@
+// Copyright 2017 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_S2SHAPEUTIL_CONTAINS_BRUTE_FORCE_H_
+#define S2_S2SHAPEUTIL_CONTAINS_BRUTE_FORCE_H_
+
+#include "s2/s2point.h"
+#include "s2/s2shape_index.h"
+
+namespace s2shapeutil {
+
+// Returns true if the given shape contains the given point.  Most clients
+// should not use this method, since its running time is linear in the number
+// of shape edges.  Instead clients should create an S2ShapeIndex and use
+// S2ContainsPointQuery, since this strategy is much more efficient when many
+// points need to be tested.
+//
+// Polygon boundaries are treated as being semi-open (see S2ContainsPointQuery
+// and S2VertexModel for other options).
+//
+// CAVEAT: Typically this method is only used internally.  Its running time is
+//         linear in the number of shape edges.
+bool ContainsBruteForce(const S2Shape& shape, const S2Point& point);
+
+}  // namespace s2shapeutil
+
+#endif  // S2_S2SHAPEUTIL_CONTAINS_BRUTE_FORCE_H_

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

@@ -0,0 +1,55 @@
+// Copyright 2017 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/s2shapeutil_contains_brute_force.h"
+
+#include <gtest/gtest.h>
+#include "s2/s2lax_polygon_shape.h"
+#include "s2/s2lax_polyline_shape.h"
+#include "s2/s2text_format.h"
+
+using s2textformat::MakeLaxPolygon;
+using s2textformat::MakeLaxPolyline;
+using s2textformat::MakePoint;
+
+namespace s2shapeutil {
+
+TEST(ContainsBruteForce, NoInterior) {
+  // Defines a polyline that almost entirely encloses the point 0:0.
+  auto polyline = MakeLaxPolyline("0:0, 0:1, 1:-1, -1:-1, -1e9:1");
+  EXPECT_FALSE(ContainsBruteForce(*polyline, MakePoint("0:0")));
+}
+
+TEST(ContainsBruteForce, ContainsReferencePoint) {
+  // Checks that ContainsBruteForce agrees with GetReferencePoint.
+  auto polygon = MakeLaxPolygon("0:0, 0:1, 1:-1, -1:-1, -1e9:1");
+  auto ref = polygon->GetReferencePoint();
+  EXPECT_EQ(ref.contained, ContainsBruteForce(*polygon, ref.point));
+}
+
+TEST(ContainsBruteForce, ConsistentWithS2Loop) {
+  // Checks that ContainsBruteForce agrees with S2Loop::Contains().
+  auto loop = S2Loop::MakeRegularLoop(MakePoint("89:-179"),
+                                      S1Angle::Degrees(10), 100);
+  S2Loop::Shape shape(loop.get());
+  for (int i = 0; i < loop->num_vertices(); ++i) {
+    EXPECT_EQ(loop->Contains(loop->vertex(i)),
+              ContainsBruteForce(shape, loop->vertex(i)));
+  }
+}
+
+}  // namespace s2shapeutil

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

@@ -0,0 +1,57 @@
+// 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_S2SHAPEUTIL_COUNT_EDGES_H_
+#define S2_S2SHAPEUTIL_COUNT_EDGES_H_
+
+#include "s2/s2shape_index.h"
+
+namespace s2shapeutil {
+
+// Returns the total number of edges in all indexed shapes.  This method takes
+// time linear in the number of shapes.
+template <class S2ShapeIndexType>
+int CountEdges(const S2ShapeIndexType& index);
+
+// Like CountEdges(), but stops once "max_edges" edges have been found (in
+// which case the current running total is returned).
+template <class S2ShapeIndexType>
+int CountEdgesUpTo(const S2ShapeIndexType& index, int max_edges);
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+template <class S2ShapeIndexType>
+inline int CountEdges(const S2ShapeIndexType& index) {
+  return CountEdgesUpTo(index, std::numeric_limits<int>::max());
+}
+
+template <class S2ShapeIndexType>
+int CountEdgesUpTo(const S2ShapeIndexType& index, int max_edges) {
+  int num_edges = 0;
+  for (S2Shape* shape : index) {
+    if (shape == nullptr) continue;
+    num_edges += shape->num_edges();
+    if (num_edges >= max_edges) break;
+  }
+  return num_edges;
+}
+
+}  // namespace s2shapeutil
+
+#endif  // S2_S2SHAPEUTIL_COUNT_EDGES_H_

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

@@ -0,0 +1,43 @@
+// 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/s2shapeutil_count_edges.h"
+
+#include <gtest/gtest.h>
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s2text_format.h"
+
+namespace {
+
+TEST(CountEdgesUpTo, StopsEarly) {
+  auto index = s2textformat::MakeIndex(
+      "0:0 | 0:1 | 0:2 | 0:3 | 0:4 # 1:0, 1:1 | 1:2, 1:3 | 1:4, 1:5, 1:6 #");
+  // Verify the test parameters.
+  ASSERT_EQ(index->num_shape_ids(), 4);
+  ASSERT_EQ(index->shape(0)->num_edges(), 5);
+  ASSERT_EQ(index->shape(1)->num_edges(), 1);
+  ASSERT_EQ(index->shape(2)->num_edges(), 1);
+  ASSERT_EQ(index->shape(3)->num_edges(), 2);
+
+  EXPECT_EQ(s2shapeutil::CountEdges(*index), 9);
+  EXPECT_EQ(s2shapeutil::CountEdgesUpTo(*index, 1), 5);
+  EXPECT_EQ(s2shapeutil::CountEdgesUpTo(*index, 5), 5);
+  EXPECT_EQ(s2shapeutil::CountEdgesUpTo(*index, 6), 6);
+  EXPECT_EQ(s2shapeutil::CountEdgesUpTo(*index, 8), 9);
+}
+
+}  // namespace

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

@@ -0,0 +1,45 @@
+// Copyright 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.
+//
+
+#include "s2/s2shapeutil_edge_iterator.h"
+
+#include "s2/third_party/absl/strings/str_cat.h"
+
+namespace s2shapeutil {
+
+EdgeIterator::EdgeIterator(const S2ShapeIndex* index)
+    : index_(index), shape_id_(-1), num_edges_(0), edge_id_(-1) {
+  Next();
+}
+
+S2Shape::Edge EdgeIterator::edge() const {
+  S2_DCHECK(!Done());
+  return index_->shape(shape_id_)->edge(edge_id_);
+}
+
+void EdgeIterator::Next() {
+  while (++edge_id_ >= num_edges_) {
+    if (++shape_id_ >= index_->num_shape_ids()) break;
+    S2Shape* shape = index_->shape(shape_id_);
+    num_edges_ = (shape == nullptr) ? 0 : shape->num_edges();
+    edge_id_ = -1;
+  }
+}
+
+string EdgeIterator::DebugString() const {
+  return absl::StrCat("(shape=", shape_id_, ", edge=", edge_id_, ")");
+}
+
+}  // namespace s2shapeutil