@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,138 @@
+// 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/s2shape_measures.h"
+
+#include <cmath>
+#include <vector>
+#include "s2/s2loop_measures.h"
+#include "s2/s2polyline_measures.h"
+
+using std::fabs;
+using std::vector;
+
+namespace S2 {
+
+S1Angle GetLength(const S2Shape& shape) {
+  if (shape.dimension() != 1) return S1Angle::Zero();
+  S1Angle length;
+  vector<S2Point> vertices;
+  int num_chains = shape.num_chains();
+  for (int chain_id = 0; chain_id < num_chains; ++chain_id) {
+    GetChainVertices(shape, chain_id, &vertices);
+    length += S2::GetLength(vertices);
+  }
+  return length;
+}
+
+S1Angle GetPerimeter(const S2Shape& shape) {
+  if (shape.dimension() != 2) return S1Angle::Zero();
+  S1Angle perimeter;
+  vector<S2Point> vertices;
+  int num_chains = shape.num_chains();
+  for (int chain_id = 0; chain_id < num_chains; ++chain_id) {
+    GetChainVertices(shape, chain_id, &vertices);
+    perimeter += S2::GetPerimeter(S2PointLoopSpan(vertices));
+  }
+  return perimeter;
+}
+
+double GetArea(const S2Shape& shape) {
+  if (shape.dimension() != 2) return 0.0;
+
+  // Since S2Shape uses the convention that the interior of the shape is to
+  // the left of all edges, in theory we could compute the area of the polygon
+  // by simply adding up all the loop areas modulo 4*Pi.  The problem with
+  // this approach is that polygons holes typically have areas near 4*Pi,
+  // which can create large cancellation errors when computing the area of
+  // small polygons with holes.  For example, a shell with an area of 4 square
+  // meters (1e-13 steradians) surrounding a hole with an area of 3 square
+  // meters (7.5e-14 sterians) would lose almost all of its accuracy if the
+  // area of the hole was computed as 12.566370614359098.
+  //
+  // So instead we use S2::GetSignedArea() to ensure that all loops have areas
+  // in the range [-2*Pi, 2*Pi].
+  double area = 0;
+  vector<S2Point> vertices;
+  int num_chains = shape.num_chains();
+  for (int chain_id = 0; chain_id < num_chains; ++chain_id) {
+    GetChainVertices(shape, chain_id, &vertices);
+    area += S2::GetSignedArea(S2PointLoopSpan(vertices));
+  }
+  // Note that S2::GetSignedArea() guarantees that the full loop (containing
+  // all points on the sphere) has a very small negative area.
+  S2_DCHECK_LE(fabs(area), 4 * M_PI);
+  if (area < 0.0) area += 4 * M_PI;
+  return area;
+}
+
+double GetApproxArea(const S2Shape& shape) {
+  if (shape.dimension() != 2) return 0.0;
+
+  double area = 0;
+  vector<S2Point> vertices;
+  int num_chains = shape.num_chains();
+  for (int chain_id = 0; chain_id < num_chains; ++chain_id) {
+    GetChainVertices(shape, chain_id, &vertices);
+    area += S2::GetApproxArea(S2PointLoopSpan(vertices));
+  }
+  // Special case to ensure that full polygons are handled correctly.
+  if (area <= 4 * M_PI) return area;
+  return fmod(area, 4 * M_PI);
+}
+
+S2Point GetCentroid(const S2Shape& shape) {
+  S2Point centroid;
+  vector<S2Point> vertices;
+  int dimension = shape.dimension();
+  int num_chains = shape.num_chains();
+  for (int chain_id = 0; chain_id < num_chains; ++chain_id) {
+    switch (dimension) {
+      case 0:
+        centroid += shape.edge(chain_id).v0;
+        break;
+      case 1:
+        GetChainVertices(shape, chain_id, &vertices);
+        centroid += S2::GetCentroid(S2PointSpan(vertices));
+        break;
+      default:
+        GetChainVertices(shape, chain_id, &vertices);
+        centroid += S2::GetCentroid(S2PointLoopSpan(vertices));
+        break;
+    }
+  }
+  return centroid;
+}
+
+void GetChainVertices(const S2Shape& shape, int chain_id,
+                      std::vector<S2Point>* vertices) {
+  S2Shape::Chain chain = shape.chain(chain_id);
+  int num_vertices = chain.length + (shape.dimension() == 1);
+  vertices->clear();
+  vertices->reserve(num_vertices);
+  int e = 0;
+  if (num_vertices & 1) {
+    vertices->push_back(shape.chain_edge(chain_id, e++).v0);
+  }
+  for (; e < num_vertices; e += 2) {
+    auto edge = shape.chain_edge(chain_id, e);
+    vertices->push_back(edge.v0);
+    vertices->push_back(edge.v1);
+  }
+}
+
+}  // namespace S2

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

@@ -0,0 +1,95 @@
+// 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)
+//
+// Defines various angle and area measures for S2Shape objects.  Unlike the
+// built-in S2Polygon and S2Polyline methods, these methods allow the
+// underlying data to be represented arbitrarily.
+
+#ifndef S2_S2SHAPE_MEASURES_H_
+#define S2_S2SHAPE_MEASURES_H_
+
+#include <vector>
+
+#include "s2/s1angle.h"
+#include "s2/s2point.h"
+#include "s2/s2shape.h"
+
+namespace S2 {
+
+// For shapes of dimension 1, returns the sum of all polyline lengths on the
+// unit sphere.  Otherwise returns zero.  (See GetPerimeter for shapes of
+// dimension 2.)
+//
+// All edges are modeled as spherical geodesics.  The result can be converted
+// to a distance on the Earth's surface (with a worst-case error of 0.562%
+// near the equator) using the functions in s2earth.h.
+S1Angle GetLength(const S2Shape& shape);
+
+// For shapes of dimension 2, returns the sum of all loop perimeters on the
+// unit sphere.  Otherwise returns zero.  (See GetLength for shapes of
+// dimension 1.)
+//
+// All edges are modeled as spherical geodesics.  The result can be converted
+// to a distance on the Earth's surface (with a worst-case error of 0.562%
+// near the equator) using the functions in s2earth.h.
+S1Angle GetPerimeter(const S2Shape& shape);
+
+// For shapes of dimension 2, returns the area of the shape on the unit
+// sphere.  The result is between 0 and 4*Pi steradians.  Otherwise returns
+// zero.  This method has good relative accuracy for both very large and very
+// small regions.
+//
+// All edges are modeled as spherical geodesics.  The result can be converted
+// to an area on the Earth's surface (with a worst-case error of 0.900% near
+// the poles) using the functions in s2earth.h.
+double GetArea(const S2Shape& shape);
+
+// Like GetArea(), except that this method is faster and has more error.  The
+// additional error is at most 2.22e-15 steradians per vertex, which works out
+// to about 0.09 square meters per vertex on the Earth's surface.  For
+// example, a loop with 100 vertices has a maximum error of about 9 square
+// meters.  (The actual error is typically much smaller than this.)
+double GetApproxArea(const S2Shape& shape);
+
+// Returns the centroid of the shape multiplied by the measure of the shape,
+// which is defined as follows:
+//
+//  - For dimension 0 shapes, the measure is shape->num_edges().
+//  - For dimension 1 shapes, the measure is GetLength(shape).
+//  - For dimension 2 shapes, the measure is GetArea(shape).
+//
+// Note that the result is not unit length, so you may need to call
+// Normalize() before passing it to other S2 functions.
+//
+// The result is scaled by the measure defined above for two reasons: (1) it
+// is cheaper to compute this way, and (2) this makes it easier to compute the
+// centroid of a collection of shapes.  (This requires simply summing the
+// centroids of all shapes in the collection whose dimension is maximal.)
+S2Point GetCentroid(const S2Shape& shape);
+
+// Overwrites "vertices" with the vertices of the given edge chain of "shape".
+// If dimension == 1, the chain will have (chain.length + 1) vertices, and
+// otherwise it will have (chain.length) vertices.
+//
+// This is a low-level helper method used in the implementations of some of
+// the methods above.
+void GetChainVertices(const S2Shape& shape, int chain_id,
+                      std::vector<S2Point>* vertices);
+
+}  // namespace S2
+
+#endif  // S2_S2SHAPE_MEASURES_H_

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

@@ -0,0 +1,139 @@
+// 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)
+//
+// Note that the "real" testing of these methods is in s2loop_measures_test
+// and s2polyline_measures_test.  This file only checks the handling of shapes
+// of different dimensions and shapes with multiple edge chains.
+
+#include "s2/s2shape_measures.h"
+
+#include <gtest/gtest.h>
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s2edge_vector_shape.h"
+#include "s2/s2lax_polygon_shape.h"
+#include "s2/s2lax_polyline_shape.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2polygon.h"
+#include "s2/s2text_format.h"
+
+using s2textformat::MakeIndexOrDie;
+using s2textformat::MakeLaxPolygonOrDie;
+using s2textformat::MakeLaxPolylineOrDie;
+using s2textformat::MakePolygonOrDie;
+using s2textformat::ParsePointsOrDie;
+
+namespace {
+
+TEST(GetLength, WrongDimension) {
+  EXPECT_EQ(S1Angle::Zero(),
+            S2::GetLength(*MakeIndexOrDie("0:0 # #")->shape(0)));
+  EXPECT_EQ(S1Angle::Zero(),
+            S2::GetLength(*MakeLaxPolygonOrDie("0:0, 0:1, 1:0")));
+}
+
+TEST(GetLength, NoPolylines) {
+  EXPECT_EQ(S1Angle::Zero(), S2::GetLength(*MakeLaxPolylineOrDie("")));
+}
+
+TEST(GetLength, ThreePolylinesInOneShape) {
+  // S2EdgeVectorShape is the only standard S2Shape that can have more than
+  // one edge chain of dimension 1.
+  auto p = ParsePointsOrDie("0:0, 1:0, 2:0, 3:0");
+  S2EdgeVectorShape shape({{p[0], p[1]}, {p[0], p[2]}, {p[0], p[3]}});
+  EXPECT_EQ(S1Angle::Degrees(6), S2::GetLength(shape));
+}
+
+TEST(GetPerimeter, WrongDimension) {
+  EXPECT_EQ(S1Angle::Zero(),
+            S2::GetPerimeter(*MakeIndexOrDie("0:0 # #")->shape(0)));
+  EXPECT_EQ(S1Angle::Zero(),
+            S2::GetPerimeter(*MakeLaxPolylineOrDie("0:0, 0:1, 1:0")));
+}
+
+TEST(GetPerimeter, EmptyPolygon) {
+  EXPECT_EQ(S1Angle::Zero(), S2::GetPerimeter(*MakeLaxPolygonOrDie("empty")));
+}
+
+TEST(GetPerimeter, FullPolygon) {
+  EXPECT_EQ(S1Angle::Zero(), S2::GetPerimeter(*MakeLaxPolygonOrDie("full")));
+}
+
+TEST(GetPerimeter, TwoLoopPolygon) {
+  // To ensure that all edges are 1 degree long, we use degenerate loops.
+  EXPECT_EQ(S1Angle::Degrees(6),
+            S2::GetPerimeter(*MakeLaxPolygonOrDie("0:0, 1:0; 0:1, 0:2, 0:3")));
+}
+
+TEST(GetArea, WrongDimension) {
+  EXPECT_EQ(0.0, S2::GetArea(*MakeIndexOrDie("0:0 # #")->shape(0)));
+  EXPECT_EQ(0.0, S2::GetArea(*MakeLaxPolylineOrDie("0:0, 0:1, 1:0")));
+}
+
+TEST(GetArea, EmptyPolygon) {
+  EXPECT_EQ(0.0, S2::GetArea(*MakeLaxPolygonOrDie("empty")));
+}
+
+TEST(GetArea, FullPolygon) {
+  EXPECT_EQ(4 * M_PI, S2::GetArea(*MakeLaxPolygonOrDie("full")));
+  EXPECT_EQ(4 * M_PI,
+            S2::GetArea(S2Polygon::OwningShape(MakePolygonOrDie("full"))));
+}
+
+TEST(GetArea, TwoTinyShells) {
+  // Two small squares with sides about 10 um (micrometers) long.
+  double side = S1Angle::Degrees(1e-10).radians();
+  EXPECT_EQ(2 * side * side, S2::GetArea(*MakeLaxPolygonOrDie(
+      "0:0, 0:1e-10, 1e-10:1e-10, 1e-10:0; "
+      "0:0, 0:-1e-10, -1e-10:-1e-10, -1e-10:0")));
+}
+
+TEST(GetArea, TinyShellAndHole) {
+  // A square about 20 um on each side with a hole 10 um on each side.
+  double side = S1Angle::Degrees(1e-10).radians();
+  EXPECT_EQ(3 * side * side, S2::GetArea(*MakeLaxPolygonOrDie(
+      "0:0, 0:2e-10, 2e-10:2e-10, 2e-10:0; "
+      "0.5e-10:0.5e-10, 1.5e-10:0.5e-10, 1.5e-10:1.5e-10, 0.5e-10:1.5e-10")));
+}
+
+TEST(GetApproxArea, LargeShellAndHolePolygon) {
+  // Make sure that GetApproxArea works well for large polygons.
+  EXPECT_NEAR(S2::GetApproxArea(*MakeLaxPolygonOrDie(
+      "0:0, 0:90, 90:0; 0:22.5, 90:0, 0:67.5")),
+              M_PI_4, 1e-12);
+}
+
+TEST(GetCentroid, Points) {
+  // GetCentroid() returns the centroid multiplied by the number of points.
+  EXPECT_EQ(S2Point(1, 1, 0),
+            S2::GetCentroid(*MakeIndexOrDie("0:0 | 0:90 # #")->shape(0)));
+}
+
+TEST(GetCentroid, Polyline) {
+  // GetCentroid returns the centroid multiplied by the length of the polyline.
+  EXPECT_TRUE(S2::ApproxEquals(
+      S2Point(1, 1, 0),
+      S2::GetCentroid(*MakeLaxPolylineOrDie("0:0, 0:90"))));
+}
+
+TEST(GetCentroid, Polygon) {
+  // GetCentroid returns the centroid multiplied by the area of the polygon.
+  EXPECT_TRUE(S2::ApproxEquals(
+      S2Point(M_PI_4, M_PI_4, M_PI_4),
+      S2::GetCentroid(*MakeLaxPolygonOrDie("0:0, 0:90, 90:0"))));
+}
+
+}  // namespace

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

@@ -0,0 +1,120 @@
+// 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 "s2/util/gtl/btree_map.h"
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s2contains_point_query.h"
+#include "s2/s2shape_index.h"
+#include "s2/s2shapeutil_contains_brute_force.h"
+
+using absl::WrapUnique;
+using std::vector;
+
+namespace s2shapeutil {
+
+void BuildPolygonBoundaries(const vector<vector<S2Shape*>>& components,
+                            vector<vector<S2Shape*>>* polygons) {
+  polygons->clear();
+  if (components.empty()) return;
+
+  // Since the loop boundaries do not cross, a loop nesting hierarchy can be
+  // defined by choosing any point on the sphere as the "point at infinity".
+  // Loop A then contains loop B if (1) A contains the boundary of B and (2)
+  // loop A does not contain the point at infinity.
+  //
+  // We choose S2::Origin() for this purpose.  The loop nesting hierarchy then
+  // determines the face structure.  Here are the details:
+  //
+  // 1. Build an S2ShapeIndex of all loops that do not contain S2::Origin().
+  //    This leaves at most one unindexed loop per connected component
+  //    (the "outer loop").
+  //
+  // 2. For each component, choose a representative vertex and determine
+  //    which indexed loops contain it.  The "depth" of this component is
+  //    defined as the number of such loops.
+  //
+  // 3. Assign the outer loop of each component to the containing loop whose
+  //    depth is one less.  This generates a set of multi-loop polygons.
+  //
+  // 4. The outer loops of all components at depth 0 become a single face.
+
+  MutableS2ShapeIndex index;
+  // A map from shape.id() to the corresponding component number.
+  vector<int> component_ids;
+  vector<S2Shape*> outer_loops;
+  for (int i = 0; i < components.size(); ++i) {
+    const auto& component = components[i];
+    for (S2Shape* loop : component) {
+      if (component.size() > 1 &&
+          !s2shapeutil::ContainsBruteForce(*loop, S2::Origin())) {
+        // Ownership is transferred back at the end of this function.
+        index.Add(WrapUnique(loop));
+        component_ids.push_back(i);
+      } else {
+        outer_loops.push_back(loop);
+      }
+    }
+    // Check that there is exactly one outer loop in each component.
+    S2_DCHECK_EQ(i + 1, outer_loops.size()) << "Component is not a subdivision";
+  }
+  // Find the loops containing each component.
+  vector<vector<S2Shape*>> ancestors(components.size());
+  auto contains_query = MakeS2ContainsPointQuery(&index);
+  for (int i = 0; i < outer_loops.size(); ++i) {
+    auto loop = outer_loops[i];
+    S2_DCHECK_GT(loop->num_edges(), 0);
+    ancestors[i] = contains_query.GetContainingShapes(loop->edge(0).v0);
+  }
+  // Assign each outer loop to the component whose depth is one less.
+  // Components at depth 0 become a single face.
+  gtl::btree_map<S2Shape*, vector<S2Shape*>> children;
+  for (int i = 0; i < outer_loops.size(); ++i) {
+    S2Shape* ancestor = nullptr;
+    int depth = ancestors[i].size();
+    if (depth > 0) {
+      for (auto candidate : ancestors[i]) {
+        if (ancestors[component_ids[candidate->id()]].size() == depth - 1) {
+          S2_DCHECK(ancestor == nullptr);
+          ancestor = candidate;
+        }
+      }
+      S2_DCHECK(ancestor != nullptr);
+    }
+    children[ancestor].push_back(outer_loops[i]);
+  }
+  // There is one face per loop that is not an outer loop, plus one for the
+  // outer loops of components at depth 0.
+  polygons->resize(index.num_shape_ids() + 1);
+  for (int i = 0; i < index.num_shape_ids(); ++i) {
+    auto polygon = &(*polygons)[i];
+    auto loop = index.shape(i);
+    auto itr = children.find(loop);
+    if (itr != children.end()) {
+      *polygon = itr->second;
+    }
+    polygon->push_back(loop);
+  }
+  polygons->back() = children[nullptr];
+
+  // Explicitly release the shapes from the index so they are not deleted.
+  for (auto& ptr : index.ReleaseAll()) ptr.release();
+}
+
+}  // namespace s2shapeutil

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

@@ -0,0 +1,66 @@
+// 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_BUILD_POLYGON_BOUNDARIES_H_
+#define S2_S2SHAPEUTIL_BUILD_POLYGON_BOUNDARIES_H_
+
+#include <vector>
+
+#include "s2/s2shape_index.h"
+
+namespace s2shapeutil {
+
+// The purpose of this function is to construct polygons consisting of
+// multiple loops.  It takes as input a collection of loops whose boundaries
+// do not cross, and groups them into polygons whose interiors do not
+// intersect (where the boundary of each polygon may consist of multiple
+// loops).
+//
+// some of those islands have lakes, then the input to this function would
+// islands, and their lakes.  Each loop would actually be present twice, once
+// in each direction (see below).  The output would consist of one polygon
+// representing each lake, one polygon representing each island not including
+// islands or their lakes, and one polygon representing the rest of the world
+//
+// This method is intended for internal use; external clients should use
+// S2Builder, which has more convenient interface.
+//
+// The input consists of a set of connected components, where each component
+// consists of one or more loops.  The components must satisfy the following
+// properties:
+//
+//  - The loops in each component must form a subdivision of the sphere (i.e.,
+//    they must cover the entire sphere without overlap), except that a
+//    component may consist of a single loop if and only if that loop is
+//    degenerate (i.e., its interior is empty).
+//
+//  - The boundaries of different components must be disjoint (i.e. no
+//    crossing edges or shared vertices).
+//
+//  - No component should be empty, and no loop should have zero edges.
+//
+// The output consists of a set of polygons, where each polygon is defined by
+// the collection of loops that form its boundary.  This function does not
+// actually construct any S2Shapes; it simply identifies the loops that belong
+// to each polygon.
+void BuildPolygonBoundaries(
+    const std::vector<std::vector<S2Shape*>>& components,
+    std::vector<std::vector<S2Shape*>>* polygons);
+
+}  // namespace s2shapeutil
+
+#endif  // S2_S2SHAPEUTIL_BUILD_POLYGON_BOUNDARIES_H_