@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,170 @@
+// 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_build_polygon_boundaries.h"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/s2lax_loop_shape.h"
+#include "s2/s2text_format.h"
+
+using std::vector;
+
+namespace s2shapeutil {
+
+class TestLaxLoop : public S2LaxLoopShape {
+ public:
+  explicit TestLaxLoop(const string& vertex_str) {
+    vector<S2Point> vertices = s2textformat::ParsePoints(vertex_str);
+    Init(vertices);
+  }
+};
+
+TEST(BuildPolygonBoundaries, NoComponents) {
+  vector<vector<S2Shape*>> faces, components;
+  BuildPolygonBoundaries(components, &faces);
+  EXPECT_EQ(0, faces.size());
+}
+
+TEST(BuildPolygonBoundaries, OneLoop) {
+  TestLaxLoop a0("0:0, 1:0, 0:1");  // Outer face
+  TestLaxLoop a1("0:0, 0:1, 1:0");
+  vector<vector<S2Shape*>> faces, components = {{&a0, &a1}};
+  BuildPolygonBoundaries(components, &faces);
+  EXPECT_EQ(2, faces.size());
+}
+
+TEST(BuildPolygonBoundaries, TwoLoopsSameComponent) {
+  TestLaxLoop a0("0:0, 1:0, 0:1");  // Outer face
+  TestLaxLoop a1("0:0, 0:1, 1:0");
+  TestLaxLoop a2("1:0, 0:1, 1:1");
+  vector<vector<S2Shape*>> faces, components = {{&a0, &a1, &a2}};
+  BuildPolygonBoundaries(components, &faces);
+  EXPECT_EQ(3, faces.size());
+}
+
+TEST(BuildPolygonBoundaries, TwoNestedLoops) {
+  TestLaxLoop a0("0:0, 3:0, 0:3");  // Outer face
+  TestLaxLoop a1("0:0, 0:3, 3:0");
+  TestLaxLoop b0("1:1, 2:0, 0:2");  // Outer face
+  TestLaxLoop b1("1:1, 0:2, 2:0");
+  vector<vector<S2Shape*>> faces, components = {{&a0, &a1}, {&b0, &b1}};
+  BuildPolygonBoundaries(components, &faces);
+  EXPECT_EQ(3, faces.size());
+  EXPECT_EQ((vector<S2Shape*>{&b0, &a1}), faces[0]);
+}
+
+TEST(BuildPolygonBoundaries, TwoLoopsDifferentComponents) {
+  TestLaxLoop a0("0:0, 1:0, 0:1");  // Outer face
+  TestLaxLoop a1("0:0, 0:1, 1:0");
+  TestLaxLoop b0("0:2, 1:2, 0:3");  // Outer face
+  TestLaxLoop b1("0:2, 0:3, 1:2");
+  vector<vector<S2Shape*>> faces, components = {{&a0, &a1}, {&b0, &b1}};
+  BuildPolygonBoundaries(components, &faces);
+  EXPECT_EQ(3, faces.size());
+  EXPECT_EQ((vector<S2Shape*>{&a0, &b0}), faces[2]);
+}
+
+TEST(BuildPolygonBoundaries, OneDegenerateLoop) {
+  TestLaxLoop a0("0:0, 1:0, 0:0");
+  vector<vector<S2Shape*>> faces, components = {{&a0}};
+  BuildPolygonBoundaries(components, &faces);
+  EXPECT_EQ(1, faces.size());
+}
+
+TEST(BuildPolygonBoundaries, TwoDegenerateLoops) {
+  TestLaxLoop a0("0:0, 1:0, 0:0");
+  TestLaxLoop b0("2:0, 3:0, 2:0");
+  vector<vector<S2Shape*>> faces, components = {{&a0}, {&b0}};
+  BuildPolygonBoundaries(components, &faces);
+  EXPECT_EQ(1, faces.size());
+  EXPECT_EQ(2, faces[0].size());
+}
+
+static void SortFaces(vector<vector<S2Shape*>>* faces) {
+  for (auto& face : *faces) {
+    std::sort(face.begin(), face.end());
+  }
+  std::sort(faces->begin(), faces->end());
+}
+
+TEST(BuildPolygonBoundaries, ComplexTest1) {
+  // Loops at index 0 are the outer (clockwise) loops.
+  // Component "a" consists of 4 adjacent squares forming a larger square.
+  TestLaxLoop a0("0:0, 25:0, 50:0, 50:25, 50:50, 25:50, 0:50, 0:50");
+  TestLaxLoop a1("0:0, 0:25, 25:25, 25:0");
+  TestLaxLoop a2("0:25, 0:50, 25:50, 25:25");
+  TestLaxLoop a3("25:0, 25:25, 50:25, 50:0");
+  TestLaxLoop a4("25:25, 25:50, 50:50, 50:25");
+  // Component "b" consists of a degenerate loop to the left of "a".
+  TestLaxLoop b0("0:-10, 10:-10");
+  // Components "a1_a", "a1_b", and "a1_c" are located within "a1".
+  TestLaxLoop a1_a0("5:5, 20:5, 20:10, 5:10");
+  TestLaxLoop a1_a1("5:5, 5:10, 10:10, 10:5");
+  TestLaxLoop a1_a2("10:5, 10:10, 15:10, 15:5");
+  TestLaxLoop a1_a3("15:5, 15:10, 20:10, 20:5");
+  TestLaxLoop a1_b0("5:15, 20:15, 20:20, 5:20");
+  TestLaxLoop a1_b1("5:15, 5:20, 20:20, 20:15");
+  TestLaxLoop a1_c0("2:5, 2:10, 2:5");
+  // Two components located inside "a1_a2" and "a1_a3".
+  TestLaxLoop a1_a2_a0("11:6, 14:6, 14:9, 11:9");
+  TestLaxLoop a1_a2_a1("11:6, 11:9, 14:9, 14:6");
+  TestLaxLoop a1_a3_a0("16:6, 19:9, 16:6");
+  // Five component located inside "a3" and "a4".
+  TestLaxLoop a3_a0("30:5, 45:5, 45:20, 30:20");
+  TestLaxLoop a3_a1("30:5, 30:20, 45:20, 45:5");
+  TestLaxLoop a4_a0("30:30, 40:30, 30:30");
+  TestLaxLoop a4_b0("30:35, 40:35, 30:35");
+  TestLaxLoop a4_c0("30:40, 40:40, 30:40");
+  TestLaxLoop a4_d0("30:45, 40:45, 30:45");
+  vector<vector<S2Shape*>> components = {
+    {&a0, &a1, &a2, &a3, &a4},
+    {&b0},
+    {&a1_a0, &a1_a1, &a1_a2, &a1_a3},
+    {&a1_b0, &a1_b1},
+    {&a1_c0},
+    {&a1_a2_a0, &a1_a2_a1},
+    {&a1_a3_a0},
+    {&a3_a0, &a3_a1},
+    {&a4_a0},
+    {&a4_b0},
+    {&a4_c0},
+    {&a4_d0}
+  };
+  vector<vector<S2Shape*>> expected_faces = {
+    {&a0, &b0},
+    {&a1, &a1_a0, &a1_b0, &a1_c0},
+    {&a1_a1},
+    {&a1_a2, &a1_a2_a0},
+    {&a1_a2_a1},
+    {&a1_a3, &a1_a3_a0},
+    {&a1_b1},
+    {&a2},
+    {&a3, &a3_a0},
+    {&a3_a1},
+    {&a4, &a4_a0, &a4_b0, &a4_c0, &a4_d0}
+  };
+  vector<vector<S2Shape*>> faces;
+  BuildPolygonBoundaries(components, &faces);
+  EXPECT_EQ(expected_faces.size(), faces.size());
+  SortFaces(&expected_faces);
+  SortFaces(&faces);
+  EXPECT_EQ(expected_faces, faces);
+}
+
+}  // namespace s2shapeutil

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

@@ -0,0 +1,253 @@
+// 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 <memory>
+
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/encoded_s2point_vector.h"
+#include "s2/encoded_string_vector.h"
+#include "s2/s2lax_polygon_shape.h"
+#include "s2/s2lax_polyline_shape.h"
+#include "s2/s2point_vector_shape.h"
+#include "s2/s2polygon.h"
+#include "s2/s2polyline.h"
+
+using absl::make_unique;
+using std::make_shared;
+using std::unique_ptr;
+using std::vector;
+
+using CodingHint = s2coding::CodingHint;
+
+namespace s2shapeutil {
+
+bool FastEncodeShape(const S2Shape& shape, Encoder* encoder) {
+  switch (shape.type_tag()) {
+    case S2Polygon::Shape::kTypeTag: {
+      down_cast<const S2Polygon::Shape*>(&shape)->EncodeUncompressed(encoder);
+      return true;
+    }
+    case S2Polyline::Shape::kTypeTag: {
+      down_cast<const S2Polyline::Shape*>(&shape)->Encode(encoder);
+      return true;
+    }
+    case S2PointVectorShape::kTypeTag: {
+      down_cast<const S2PointVectorShape*>(&shape)->Encode(
+          encoder, CodingHint::FAST);
+      return true;
+    }
+    case S2LaxPolylineShape::kTypeTag: {
+      down_cast<const S2LaxPolylineShape*>(&shape)->Encode(
+          encoder, CodingHint::FAST);
+      return true;
+    }
+    case S2LaxPolygonShape::kTypeTag: {
+      down_cast<const S2LaxPolygonShape*>(&shape)->Encode(
+          encoder, CodingHint::FAST);
+      return true;
+    }
+    default: {
+      S2_LOG(DFATAL) << "Unsupported S2Shape type: " << shape.type_tag();
+      return false;
+    }
+  }
+}
+
+bool CompactEncodeShape(const S2Shape& shape, Encoder* encoder) {
+  switch (shape.type_tag()) {
+    case S2Polygon::Shape::kTypeTag: {
+      down_cast<const S2Polygon::Shape*>(&shape)->Encode(encoder);
+      return true;
+    }
+    case S2PointVectorShape::kTypeTag: {
+      down_cast<const S2PointVectorShape*>(&shape)->Encode(
+          encoder, CodingHint::COMPACT);
+      return true;
+    }
+    case S2LaxPolylineShape::kTypeTag: {
+      down_cast<const S2LaxPolylineShape*>(&shape)->Encode(
+          encoder, CodingHint::COMPACT);
+      return true;
+    }
+    case S2LaxPolygonShape::kTypeTag: {
+      down_cast<const S2LaxPolygonShape*>(&shape)->Encode(
+          encoder, CodingHint::COMPACT);
+      return true;
+    }
+    default: {
+      return FastEncodeShape(shape, encoder);
+    }
+  }
+}
+
+// A ShapeDecoder that fully decodes an S2Shape of the given type.  After this
+// function returns, the underlying Decoder data is no longer needed.
+unique_ptr<S2Shape> FullDecodeShape(S2Shape::TypeTag tag, Decoder* decoder) {
+  switch (tag) {
+    case S2Polygon::Shape::kTypeTag: {
+      auto shape = make_unique<S2Polygon::OwningShape>();
+      if (!shape->Init(decoder)) return nullptr;
+      return std::move(shape);
+    }
+    case S2Polyline::Shape::kTypeTag: {
+      auto shape = make_unique<S2Polyline::OwningShape>();
+      if (!shape->Init(decoder)) return nullptr;
+      return std::move(shape);
+    }
+    case S2PointVectorShape::kTypeTag: {
+      auto shape = make_unique<S2PointVectorShape>();
+      if (!shape->Init(decoder)) return nullptr;
+      return std::move(shape);
+    }
+    case S2LaxPolylineShape::kTypeTag: {
+      auto shape = make_unique<S2LaxPolylineShape>();
+      if (!shape->Init(decoder)) return nullptr;
+      return std::move(shape);
+    }
+    case S2LaxPolygonShape::kTypeTag: {
+      auto shape = make_unique<S2LaxPolygonShape>();
+      if (!shape->Init(decoder)) return nullptr;
+      return std::move(shape);
+    }
+    default: {
+      S2_LOG(DFATAL) << "Unsupported S2Shape type: " << tag;
+      return nullptr;
+    }
+  }
+}
+
+unique_ptr<S2Shape> LazyDecodeShape(S2Shape::TypeTag tag, Decoder* decoder) {
+  switch (tag) {
+    case S2PointVectorShape::kTypeTag: {
+      auto shape = make_unique<EncodedS2PointVectorShape>();
+      if (!shape->Init(decoder)) return nullptr;
+      return std::move(shape);
+    }
+    case S2LaxPolylineShape::kTypeTag: {
+      auto shape = make_unique<EncodedS2LaxPolylineShape>();
+      if (!shape->Init(decoder)) return nullptr;
+      return std::move(shape);
+    }
+    case S2LaxPolygonShape::kTypeTag: {
+      auto shape = make_unique<EncodedS2LaxPolygonShape>();
+      if (!shape->Init(decoder)) return nullptr;
+      return std::move(shape);
+    }
+    default: {
+      return FullDecodeShape(tag, decoder);
+    }
+  }
+}
+
+bool EncodeTaggedShapes(const S2ShapeIndex& index,
+                        const ShapeEncoder& shape_encoder,
+                        Encoder* encoder) {
+  s2coding::StringVectorEncoder shape_vector;
+  for (S2Shape* shape : index) {
+    Encoder* sub_encoder = shape_vector.AddViaEncoder();
+    if (shape == nullptr) continue;  // Encode as zero bytes.
+
+    uint32 tag = shape->type_tag();
+    if (tag == S2Shape::kNoTypeTag) {
+      S2_LOG(DFATAL) << "Unsupported S2Shape type: " << tag;
+      return false;
+    }
+    sub_encoder->Ensure(Encoder::kVarintMax32);
+    sub_encoder->put_varint32(tag);
+    shape_encoder(*shape, sub_encoder);
+  }
+  shape_vector.Encode(encoder);
+  return true;
+}
+
+bool FastEncodeTaggedShapes(const S2ShapeIndex& index, Encoder* encoder) {
+  return EncodeTaggedShapes(index, FastEncodeShape, encoder);
+}
+
+bool CompactEncodeTaggedShapes(const S2ShapeIndex& index, Encoder* encoder) {
+  return EncodeTaggedShapes(index, CompactEncodeShape, encoder);
+}
+
+TaggedShapeFactory::TaggedShapeFactory(const ShapeDecoder& shape_decoder,
+                                       Decoder* decoder)
+    : shape_decoder_(shape_decoder) {
+  if (!encoded_shapes_.Init(decoder)) encoded_shapes_.Clear();
+}
+
+unique_ptr<S2Shape> TaggedShapeFactory::operator[](int shape_id) const {
+  Decoder decoder = encoded_shapes_.GetDecoder(shape_id);
+  S2Shape::TypeTag tag;
+  if (!decoder.get_varint32(&tag)) return nullptr;
+  return shape_decoder_(tag, &decoder);
+}
+
+TaggedShapeFactory FullDecodeShapeFactory(Decoder* decoder) {
+  return TaggedShapeFactory(FullDecodeShape, decoder);
+}
+
+TaggedShapeFactory LazyDecodeShapeFactory(Decoder* decoder) {
+  return TaggedShapeFactory(LazyDecodeShape, decoder);
+}
+
+VectorShapeFactory::VectorShapeFactory(vector<unique_ptr<S2Shape>> shapes)
+    : shared_shapes_(
+          make_shared<vector<unique_ptr<S2Shape>>>(std::move(shapes))) {
+}
+
+unique_ptr<S2Shape> VectorShapeFactory::operator[](int shape_id) const {
+  return std::move((*shared_shapes_)[shape_id]);
+}
+
+VectorShapeFactory SingletonShapeFactory(std::unique_ptr<S2Shape> shape) {
+  vector<unique_ptr<S2Shape>> shapes;
+  shapes.push_back(std::move(shape));
+  return VectorShapeFactory(std::move(shapes));
+}
+
+// An S2Shape that simply wraps some other shape.
+class WrappedShape : public S2Shape {
+ public:
+  explicit WrappedShape(S2Shape* shape) : shape_(*shape) {}
+  // S2Shape interface:
+  int num_edges() const final { return shape_.num_edges(); }
+  Edge edge(int e) const final { return shape_.edge(e); }
+  int dimension() const final { return shape_.dimension(); }
+  ReferencePoint GetReferencePoint() const final {
+    return shape_.GetReferencePoint();
+  }
+  int num_chains() const final { return shape_.num_chains(); }
+  Chain chain(int i) const final { return shape_.chain(i); }
+  Edge chain_edge(int i, int j) const final {
+    return shape_.chain_edge(i, j);
+  }
+  ChainPosition chain_position(int e) const final {
+    return shape_.chain_position(e);
+  }
+
+ private:
+  const S2Shape& shape_;
+};
+
+unique_ptr<S2Shape> WrappedShapeFactory::operator[](int shape_id) const {
+  S2Shape* shape = index_.shape(shape_id);
+  if (shape == nullptr) return nullptr;
+  return make_unique<WrappedShape>(shape);
+}
+
+}  // namespace s2shapeutil