@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,165 @@
+// 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/s2latlng.h"
+
+#include <cmath>
+#include <cstdio>
+#include <unordered_map>
+
+#include <gtest/gtest.h>
+
+#include "s2/base/logging.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2testing.h"
+#include "s2/third_party/absl/base/macros.h"
+#include "s2/third_party/absl/strings/str_cat.h"
+
+using absl::StrCat;
+using std::fabs;
+
+TEST(S2LatLng, TestBasic) {
+  S2LatLng ll_rad = S2LatLng::FromRadians(M_PI_4, M_PI_2);
+  EXPECT_EQ(M_PI_4, ll_rad.lat().radians());
+  EXPECT_EQ(M_PI_2, ll_rad.lng().radians());
+  EXPECT_TRUE(ll_rad.is_valid());
+  S2LatLng ll_deg = S2LatLng::FromDegrees(45, 90);
+  EXPECT_EQ(ll_rad, ll_deg);
+  EXPECT_TRUE(ll_deg.is_valid());
+  EXPECT_FALSE(S2LatLng::FromDegrees(-91, 0).is_valid());
+  EXPECT_FALSE(S2LatLng::FromDegrees(0, 181).is_valid());
+
+  S2LatLng bad = S2LatLng::FromDegrees(120, 200);
+  EXPECT_FALSE(bad.is_valid());
+  S2LatLng better = bad.Normalized();
+  EXPECT_TRUE(better.is_valid());
+  EXPECT_EQ(S1Angle::Degrees(90), better.lat());
+  EXPECT_DOUBLE_EQ(S1Angle::Degrees(-160).radians(), better.lng().radians());
+
+  bad = S2LatLng::FromDegrees(-100, -360);
+  EXPECT_FALSE(bad.is_valid());
+  better = bad.Normalized();
+  EXPECT_TRUE(better.is_valid());
+  EXPECT_EQ(S1Angle::Degrees(-90), better.lat());
+  EXPECT_DOUBLE_EQ(0.0, better.lng().radians());
+
+  EXPECT_TRUE((S2LatLng::FromDegrees(10, 20) + S2LatLng::FromDegrees(20, 30)).
+              ApproxEquals(S2LatLng::FromDegrees(30, 50)));
+  EXPECT_TRUE((S2LatLng::FromDegrees(10, 20) - S2LatLng::FromDegrees(20, 30)).
+              ApproxEquals(S2LatLng::FromDegrees(-10, -10)));
+  EXPECT_TRUE((0.5 * S2LatLng::FromDegrees(10, 20)).
+              ApproxEquals(S2LatLng::FromDegrees(5, 10)));
+
+  // Check that Invalid() returns an invalid point.
+  S2LatLng invalid = S2LatLng::Invalid();
+  EXPECT_FALSE(invalid.is_valid());
+
+  // Check that the default constructor sets latitude and longitude to 0.
+  S2LatLng default_ll;
+  EXPECT_TRUE(default_ll.is_valid());
+  EXPECT_EQ(0, default_ll.lat().radians());
+  EXPECT_EQ(0, default_ll.lng().radians());
+}
+
+TEST(S2LatLng, TestConversion) {
+  // Test special cases: poles, "date line"
+  EXPECT_DOUBLE_EQ(90.0,
+                   S2LatLng(S2Point(S2LatLng::FromDegrees(90.0, 65.0)))
+                   .lat().degrees());
+  EXPECT_EQ(-M_PI_2,
+            S2LatLng(S2Point(S2LatLng::FromRadians(-M_PI_2, 1)))
+            .lat().radians());
+  EXPECT_DOUBLE_EQ(180.0,
+                   fabs(S2LatLng(S2Point(S2LatLng::FromDegrees(12.2, 180.0)))
+                        .lng().degrees()));
+  EXPECT_EQ(M_PI,
+            fabs(S2LatLng(S2Point(S2LatLng::FromRadians(0.1, -M_PI)))
+                 .lng().radians()));
+
+  // Test a bunch of random points.
+  for (int i = 0; i < 100000; ++i) {
+    S2Point p = S2Testing::RandomPoint();
+    EXPECT_TRUE(S2::ApproxEquals(p, S2Point(S2LatLng(p)))) << p;
+  }
+}
+
+TEST(S2LatLng, TestDistance) {
+  EXPECT_EQ(0.0,
+            S2LatLng::FromDegrees(90, 0).GetDistance(
+                S2LatLng::FromDegrees(90, 0)).radians());
+  EXPECT_NEAR(77.0,
+              S2LatLng::FromDegrees(-37, 25).GetDistance(
+                  S2LatLng::FromDegrees(-66, -155)).degrees(),
+              1e-13);
+  EXPECT_NEAR(115.0,
+              S2LatLng::FromDegrees(0, 165).GetDistance(
+                  S2LatLng::FromDegrees(0, -80)).degrees(),
+              1e-13);
+  EXPECT_NEAR(180.0,
+              S2LatLng::FromDegrees(47, -127).GetDistance(
+                  S2LatLng::FromDegrees(-47, 53)).degrees(),
+              2e-6);
+}
+
+TEST(S2LatLng, TestToString) {
+  struct {
+    double lat, lng;
+    double expected_lat, expected_lng;
+  } values[] = {
+    {0, 0, 0, 0},
+    {1.5, 91.7, 1.5, 91.7},
+    {9.9, -0.31, 9.9, -0.31},
+    {sqrt(2), -sqrt(5), 1.414214, -2.236068},
+    {91.3, 190.4, 90, -169.6},
+    {-100, -710, -90, 10},
+  };
+  int i = 0;
+  for (const auto& v : values) {
+    SCOPED_TRACE(StrCat("Iteration ", i++));
+    S2LatLng p = S2LatLng::FromDegrees(v.lat, v.lng);
+    string output;
+    p.ToStringInDegrees(&output);
+
+    double lat, lng;
+    ASSERT_EQ(2, std::sscanf(output.c_str(), "%lf,%lf", &lat, &lng));
+    EXPECT_NEAR(v.expected_lat, lat, 1e-8);
+    EXPECT_NEAR(v.expected_lng, lng, 1e-8);
+  }
+}
+
+// Test the variant that returns a string.
+TEST(S2LatLng, TestToStringReturnsString) {
+  string s;
+  S2LatLng::FromDegrees(0, 1).ToStringInDegrees(&s);
+  EXPECT_EQ(S2LatLng::FromDegrees(0, 1).ToStringInDegrees(), s);
+}
+
+TEST(S2LatLng, TestHashCode) {
+  std::unordered_map<S2LatLng, int, S2LatLngHash> map;
+  map[S2LatLng::FromDegrees(0, 10)] = 1;
+  map[S2LatLng::FromDegrees(2, 12)] = 2;
+  map[S2LatLng::FromDegrees(5, 15)] = 3;
+  map[S2LatLng::FromDegrees(7, 17)] = 4;
+  map[S2LatLng::FromDegrees(11, 19)] = 5;
+  EXPECT_EQ(map.size(), 5);
+  EXPECT_EQ(1, map[S2LatLng::FromDegrees(0, 10)]);
+  EXPECT_EQ(2, map[S2LatLng::FromDegrees(2, 12)]);
+  EXPECT_EQ(3, map[S2LatLng::FromDegrees(5, 15)]);
+  EXPECT_EQ(4, map[S2LatLng::FromDegrees(7, 17)]);
+  EXPECT_EQ(5, map[S2LatLng::FromDegrees(11, 19)]);
+}
+

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

@@ -0,0 +1,104 @@
+// 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/s2lax_loop_shape.h"
+
+#include <vector>
+
+#include "s2/s2loop.h"
+#include "s2/s2shapeutil_get_reference_point.h"
+
+using std::vector;
+using ReferencePoint = S2Shape::ReferencePoint;
+
+S2LaxLoopShape::S2LaxLoopShape(const vector<S2Point>& vertices) {
+  Init(vertices);
+}
+
+S2LaxLoopShape::S2LaxLoopShape(const S2Loop& loop) {
+  Init(loop);
+}
+
+void S2LaxLoopShape::Init(const vector<S2Point>& vertices) {
+  num_vertices_ = vertices.size();
+  vertices_.reset(new S2Point[num_vertices_]);
+  std::copy(vertices.begin(), vertices.end(), vertices_.get());
+}
+
+void S2LaxLoopShape::Init(const S2Loop& loop) {
+  S2_DCHECK(!loop.is_full()) << "Full loops not supported; use S2LaxPolygonShape";
+  if (loop.is_empty()) {
+    num_vertices_ = 0;
+    vertices_ = nullptr;
+  } else {
+    num_vertices_ = loop.num_vertices();
+    vertices_.reset(new S2Point[num_vertices_]);
+    std::copy(&loop.vertex(0), &loop.vertex(0) + num_vertices_,
+              vertices_.get());
+  }
+}
+
+S2Shape::Edge S2LaxLoopShape::edge(int e0) const {
+  S2_DCHECK_LT(e0, num_edges());
+  int e1 = e0 + 1;
+  if (e1 == num_vertices()) e1 = 0;
+  return Edge(vertices_[e0], vertices_[e1]);
+}
+
+S2Shape::Edge S2LaxLoopShape::chain_edge(int i, int j) const {
+  S2_DCHECK_EQ(i, 0);
+  S2_DCHECK_LT(j, num_edges());
+  int k = (j + 1 == num_vertices()) ? 0 : j + 1;
+  return Edge(vertices_[j], vertices_[k]);
+}
+
+S2Shape::ReferencePoint S2LaxLoopShape::GetReferencePoint() const {
+  return s2shapeutil::GetReferencePoint(*this);
+}
+
+S2VertexIdLaxLoopShape::S2VertexIdLaxLoopShape(
+    const std::vector<int32>& vertex_ids, const S2Point* vertex_array) {
+  Init(vertex_ids, vertex_array);
+}
+
+void S2VertexIdLaxLoopShape::Init(const std::vector<int32>& vertex_ids,
+                           const S2Point* vertex_array) {
+  num_vertices_ = vertex_ids.size();
+  vertex_ids_.reset(new int32[num_vertices_]);
+  std::copy(vertex_ids.begin(), vertex_ids.end(), vertex_ids_.get());
+  vertex_array_ = vertex_array;
+}
+
+S2Shape::Edge S2VertexIdLaxLoopShape::edge(int e0) const {
+  S2_DCHECK_LT(e0, num_edges());
+  int e1 = e0 + 1;
+  if (e1 == num_vertices()) e1 = 0;
+  return Edge(vertex(e0), vertex(e1));
+}
+
+S2Shape::Edge S2VertexIdLaxLoopShape::chain_edge(int i, int j) const {
+  S2_DCHECK_EQ(i, 0);
+  S2_DCHECK_LT(j, num_edges());
+  int k = (j + 1 == num_vertices()) ? 0 : j + 1;
+  return Edge(vertex(j), vertex(k));
+}
+
+S2Shape::ReferencePoint S2VertexIdLaxLoopShape::GetReferencePoint() const {
+  // GetReferencePoint interprets a loop with no vertices as "full".
+  if (num_vertices() == 0) return ReferencePoint::Contained(false);
+  return s2shapeutil::GetReferencePoint(*this);
+}

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

@@ -0,0 +1,153 @@
+// 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)
+//
+// This file defines various S2Shape types representing loops:
+//
+// S2LaxLoopShape
+//   - like S2Loop::Shape but allows duplicate vertices & edges, more compact
+//     representation, and faster to initialize.
+//
+// S2LaxClosedPolylineShape
+//   - like S2LaxLoopShape, but defines a loop that does not have an interior
+//     (a closed polyline).
+//
+// S2VertexIdLaxLoopShape
+//   - like S2LaxLoopShape, but vertices are specified as indices into an
+//     existing vertex array.
+
+#ifndef S2_S2LAX_LOOP_SHAPE_H_
+#define S2_S2LAX_LOOP_SHAPE_H_
+
+#include <algorithm>
+#include <memory>
+#include <vector>
+
+#include "s2/s2loop.h"
+#include "s2/s2shape.h"
+
+// S2LaxLoopShape represents a closed loop of edges surrounding an interior
+// region.  It is similar to S2Loop::Shape except that this class allows
+// duplicate vertices and edges.  Loops may have any number of vertices,
+// including 0, 1, or 2.  (A one-vertex loop defines a degenerate edge
+// consisting of a single point.)
+//
+// Note that S2LaxLoopShape is faster to initialize and more compact than
+// S2Loop::Shape, but does not support the same operations as S2Loop.
+class S2LaxLoopShape : public S2Shape {
+ public:
+  // Constructs an empty loop.
+  S2LaxLoopShape() : num_vertices_(0) {}
+
+  // Constructs an S2LaxLoopShape with the given vertices.
+  explicit S2LaxLoopShape(const std::vector<S2Point>& vertices);
+
+  // Constructs an S2LaxLoopShape from the given S2Loop, by copying its data.
+  explicit S2LaxLoopShape(const S2Loop& loop);
+
+  // Initializes an S2LaxLoopShape with the given vertices.
+  void Init(const std::vector<S2Point>& vertices);
+
+  // Initializes an S2LaxLoopShape from the given S2Loop, by copying its data.
+  //
+  // REQUIRES: !loop->is_full()
+  //           [Use S2LaxPolygonShape if you need to represent a full loop.]
+  void Init(const S2Loop& loop);
+
+  int num_vertices() const { return num_vertices_; }
+  const S2Point& vertex(int i) const { return vertices_[i]; }
+
+  // S2Shape interface:
+  int num_edges() const final { return num_vertices(); }
+  Edge edge(int e) const final;
+  // Not final; overridden by S2LaxClosedPolylineShape.
+  int dimension() const override { return 2; }
+  // Not final; overridden by S2LaxClosedPolylineShape.
+  ReferencePoint GetReferencePoint() const override;
+  int num_chains() const final { return std::min(1, num_vertices_); }
+  Chain chain(int i) const final { return Chain(0, num_vertices_); }
+  Edge chain_edge(int i, int j) const final;
+  ChainPosition chain_position(int e) const final {
+    return ChainPosition(0, e);
+  }
+
+ private:
+  // For clients that have many small loops, we save some memory by
+  // representing the vertices as an array rather than using std::vector.
+  int32 num_vertices_;
+  std::unique_ptr<S2Point[]> vertices_;
+};
+
+// S2LaxClosedPolylineShape is like S2LaxPolylineShape except that the last
+// vertex is implicitly joined to the first.  It is also like S2LaxLoopShape
+// except that it does not have an interior (which makes it more efficient to
+// index).
+class S2LaxClosedPolylineShape : public S2LaxLoopShape {
+ public:
+  // See S2LaxLoopShape for constructors.
+  using S2LaxLoopShape::S2LaxLoopShape;
+
+  int dimension() const final { return 1; }
+  ReferencePoint GetReferencePoint() const final {
+    return ReferencePoint::Contained(false);
+  }
+};
+
+// S2VertexIdLaxLoopShape is just like S2LaxLoopShape, except that vertices are
+// specified as indices into a vertex array.  This representation can be more
+// compact when many loops are arranged in a mesh structure.
+class S2VertexIdLaxLoopShape : public S2Shape {
+ public:
+  // Constructs an empty loop.
+  S2VertexIdLaxLoopShape() : num_vertices_(0) {}
+
+  // Constructs the shape from the given vertex array and indices.
+  // "vertex_ids" is a vector of indices into "vertex_array".
+  //
+  // ENSURES:  loop->vertex(i) == (*vertex_array)[vertex_ids[i]]
+  // REQUIRES: "vertex_array" persists for the lifetime of this object.
+  explicit S2VertexIdLaxLoopShape(const std::vector<int32>& vertex_ids,
+                                  const S2Point* vertex_array);
+
+  // Initializes the shape from the given vertex array and indices.
+  // "vertex_ids" is a vector of indices into "vertex_array".
+  void Init(const std::vector<int32>& vertex_ids,
+            const S2Point* vertex_array);
+
+  // Returns the number of vertices in the loop.
+  int num_vertices() const { return num_vertices_; }
+  int32 vertex_id(int i) const { return vertex_ids_[i]; }
+  const S2Point& vertex(int i) const { return vertex_array_[vertex_id(i)]; }
+
+  // S2Shape interface:
+  int num_edges() const final { return num_vertices(); }
+  Edge edge(int e) const final;
+  int dimension() const final { return 2; }
+  ReferencePoint GetReferencePoint() const final;
+  int num_chains() const final { return std::min(1, num_vertices_); }
+  Chain chain(int i) const final { return Chain(0, num_vertices_); }
+  Edge chain_edge(int i, int j) const final;
+  ChainPosition chain_position(int e) const final {
+    return ChainPosition(0, e);
+  }
+
+ private:
+  int32 num_vertices_;
+  std::unique_ptr<int32[]> vertex_ids_;
+  const S2Point* vertex_array_;
+};
+
+#endif  // S2_S2LAX_LOOP_SHAPE_H_

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

@@ -0,0 +1,101 @@
+// 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/s2lax_loop_shape.h"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/s2loop.h"
+#include "s2/s2shapeutil_contains_brute_force.h"
+#include "s2/s2text_format.h"
+
+using std::vector;
+
+TEST(S2LaxLoopShape, EmptyLoop) {
+  // Test S2Loop constructor.
+  S2LaxLoopShape shape;
+  shape.Init(S2Loop(S2Loop::kEmpty()));
+  EXPECT_EQ(0, shape.num_vertices());
+  EXPECT_EQ(0, shape.num_edges());
+  EXPECT_EQ(0, shape.num_chains());
+  EXPECT_EQ(2, shape.dimension());
+  EXPECT_TRUE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(S2LaxLoopShape, NonEmptyLoop) {
+  // Test vector<S2Point> constructor.
+  vector<S2Point> vertices = s2textformat::ParsePoints("0:0, 0:1, 1:1, 1:0");
+  S2LaxLoopShape shape(vertices);
+  EXPECT_EQ(vertices.size(), shape.num_vertices());
+  EXPECT_EQ(vertices.size(), shape.num_edges());
+  EXPECT_EQ(1, shape.num_chains());
+  EXPECT_EQ(0, shape.chain(0).start);
+  EXPECT_EQ(vertices.size(), shape.chain(0).length);
+  for (int i = 0; i < vertices.size(); ++i) {
+    EXPECT_EQ(vertices[i], shape.vertex(i));
+    auto edge = shape.edge(i);
+    EXPECT_EQ(vertices[i], edge.v0);
+    EXPECT_EQ(vertices[(i + 1) % vertices.size()], edge.v1);
+  }
+  EXPECT_EQ(2, shape.dimension());
+  EXPECT_FALSE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(S2LaxClosedPolylineShape, NoInterior) {
+  vector<S2Point> vertices = s2textformat::ParsePoints("0:0, 0:1, 1:1, 1:0");
+  S2LaxClosedPolylineShape shape(vertices);
+  EXPECT_EQ(1, shape.dimension());
+  EXPECT_FALSE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(S2VertexIdLaxLoopShape, EmptyLoop) {
+  S2VertexIdLaxLoopShape shape(vector<int32>(), nullptr);
+  EXPECT_EQ(0, shape.num_edges());
+  EXPECT_EQ(0, shape.num_vertices());
+  EXPECT_EQ(0, shape.num_chains());
+  EXPECT_EQ(2, shape.dimension());
+  EXPECT_TRUE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_FALSE(shape.GetReferencePoint().contained);
+}
+
+TEST(S2VertexIdLaxLoopShape, InvertedLoop) {
+  vector<S2Point> vertex_array =
+      s2textformat::ParsePoints("0:0, 0:1, 1:1, 1:0");
+  vector<int32> vertex_ids { 0, 3, 2, 1 };  // Inverted.
+  S2VertexIdLaxLoopShape shape(vertex_ids, &vertex_array[0]);
+  EXPECT_EQ(4, shape.num_edges());
+  EXPECT_EQ(4, shape.num_vertices());
+  EXPECT_EQ(1, shape.num_chains());
+  EXPECT_EQ(0, shape.chain(0).start);
+  EXPECT_EQ(4, shape.chain(0).length);
+  EXPECT_EQ(&vertex_array[0], &shape.vertex(0));
+  EXPECT_EQ(&vertex_array[3], &shape.vertex(1));
+  EXPECT_EQ(&vertex_array[2], &shape.vertex(2));
+  EXPECT_EQ(&vertex_array[1], &shape.vertex(3));
+  EXPECT_EQ(2, shape.dimension());
+  EXPECT_FALSE(shape.is_empty());
+  EXPECT_FALSE(shape.is_full());
+  EXPECT_TRUE(s2shapeutil::ContainsBruteForce(shape, S2::Origin()));
+}