@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,86 @@
+// 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_S2BUILDERUTIL_FIND_POLYGON_DEGENERACIES_H_
+#define S2_S2BUILDERUTIL_FIND_POLYGON_DEGENERACIES_H_
+
+#include <vector>
+
+#include "s2/base/integral_types.h"
+#include "s2/s2builder_graph.h"
+#include "s2/s2error.h"
+
+namespace s2builderutil {
+
+// A polygon degeneracy is either a degenerate edge (an edge from a vertex to
+// itself) or a sibling edge pair (consisting of an edge and its corresponding
+// reverse edge).  "is_hole" indicates whether the degeneracy corresponds to a
+// polygon hole (as opposed to a polygon shell).
+//
+// Degeneracies are not allowed to coincide with any non-degenerate portions
+// of the polygon's boundary (since that would make it impossible to classify
+// the degeneracy as a shell or hole).  Specifically, degenerate edges must
+// coincide only with other degenerate edges, and sibling pairs must coincide
+// only with other sibling pairs.  (Below we require a slightly stronger
+// condition, namely that sibling pairs cannot coincide with any other edges.)
+struct PolygonDegeneracy {
+  uint32 edge_id : 31;
+  uint32 is_hole : 1;
+
+  PolygonDegeneracy() : edge_id(0), is_hole(false) {}
+  PolygonDegeneracy(S2Builder::Graph::EdgeId _edge_id, bool _is_hole)
+      : edge_id(_edge_id), is_hole(_is_hole) {
+  }
+  bool operator==(PolygonDegeneracy y) const {
+    return edge_id == y.edge_id && is_hole == y.is_hole;
+  }
+  bool operator<(PolygonDegeneracy y) const {
+    return edge_id < y.edge_id || (edge_id == y.edge_id && is_hole < y.is_hole);
+  }
+};
+
+// Given a graph representing a polygon, finds all degenerate edges and
+// sibling pairs and classifies them as being either shells or holes.  The
+// result vector is sorted by edge id.
+//
+// REQUIRES: g.options().edge_type() == DIRECTED
+// REQUIRES: g.options().sibling_pairs() == DISCARD_EXCESS (or DISCARD)
+// REQUIRES: g.options().degenerate_edges() == DISCARD_EXCESS (or DISCARD)
+//
+// Usually callers will want to specify SiblingPairs::DISCARD_EXCESS and
+// DegenerateEdges::DISCARD_EXCESS in order to remove all redundant
+// degeneracies.  DISCARD is also allowed in case you want to keep only one
+// type of degeneracy (i.e., degenerate edges or sibling pairs).
+//
+// If the graph edges cannot be assembled into loops, the result is undefined.
+// (An error may or may not be returned.)
+std::vector<PolygonDegeneracy> FindPolygonDegeneracies(
+    const S2Builder::Graph& g, S2Error* error);
+
+// Given a graph representing a polygon, returns true the graph consists
+// entirely of degenerate edges and/or sibling pairs.  Such a graph represents
+// either the empty polygon together with a collection of degenerate shells,
+// or the full polygon together with a collection of degenerate holes.
+//
+// REQUIRES: g.options().edge_type() == DIRECTED
+// REQUIRES: g.options().sibling_pairs() == DISCARD_EXCESS (or DISCARD)
+// REQUIRES: g.options().degenerate_edges() == DISCARD_EXCESS (or DISCARD)
+bool IsFullyDegenerate(const S2Builder::Graph& g);
+
+}  // namespace s2builderutil
+
+#endif  // S2_S2BUILDERUTIL_FIND_POLYGON_DEGENERACIES_H_

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

@@ -0,0 +1,182 @@
+// 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/s2builderutil_find_polygon_degeneracies.h"
+
+#include <iosfwd>
+#include <memory>
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/s2builder.h"
+#include "s2/s2builder_graph.h"
+#include "s2/s2builder_layer.h"
+#include "s2/s2cap.h"
+#include "s2/s2lax_polygon_shape.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2testing.h"
+#include "s2/s2text_format.h"
+
+using absl::make_unique;
+using std::vector;
+
+using EdgeType = S2Builder::EdgeType;
+using Graph = S2Builder::Graph;
+using GraphOptions = S2Builder::GraphOptions;
+
+using DegenerateEdges = GraphOptions::DegenerateEdges;
+using DuplicateEdges = GraphOptions::DuplicateEdges;
+using SiblingPairs = GraphOptions::SiblingPairs;
+
+namespace s2builderutil {
+
+struct TestDegeneracy {
+  string edge_str;
+  bool is_hole;
+  TestDegeneracy(string _edge_str, bool _is_hole)
+      : edge_str(_edge_str), is_hole(_is_hole) {
+  }
+};
+
+bool operator<(const TestDegeneracy& x, const TestDegeneracy& y) {
+  if (x.edge_str < y.edge_str) return true;
+  if (y.edge_str < x.edge_str) return false;
+  return x.is_hole < y.is_hole;
+}
+
+bool operator==(const TestDegeneracy& x, const TestDegeneracy& y) {
+  return x.edge_str == y.edge_str && x.is_hole == y.is_hole;
+}
+
+class DegeneracyCheckingLayer : public S2Builder::Layer {
+ public:
+  explicit DegeneracyCheckingLayer(const vector<TestDegeneracy>& expected)
+      : expected_(expected) {
+  }
+  GraphOptions graph_options() const override {
+    return GraphOptions(EdgeType::DIRECTED, DegenerateEdges::DISCARD_EXCESS,
+                        DuplicateEdges::KEEP, SiblingPairs::DISCARD_EXCESS);
+  }
+  void Build(const Graph& g, S2Error* error) override;
+
+ private:
+  vector<TestDegeneracy> expected_;
+};
+
+std::ostream& operator<<(std::ostream& os, const vector<TestDegeneracy>& v) {
+  for (const auto& degeneracy : v) {
+    os << (degeneracy.is_hole ? "Hole(" : "Shell(");
+    os << degeneracy.edge_str + ") ";
+  }
+  return os;
+}
+
+void DegeneracyCheckingLayer::Build(const Graph& g, S2Error* error) {
+  auto degeneracies = FindPolygonDegeneracies(g, error);
+  // Convert the output into a human-readable format.
+  vector<TestDegeneracy> actual;
+  for (const auto& degeneracy : degeneracies) {
+    Graph::Edge edge = g.edge(degeneracy.edge_id);
+    vector<S2Point> points { g.vertex(edge.first), g.vertex(edge.second) };
+    actual.push_back(TestDegeneracy(s2textformat::ToString(points),
+                                    degeneracy.is_hole));
+  }
+  std::sort(actual.begin(), actual.end());
+  std::sort(expected_.begin(), expected_.end());
+  EXPECT_TRUE(expected_ == actual) << "\nExpected: " << expected_
+                                   << "\nActual: " << actual;
+  EXPECT_EQ(IsFullyDegenerate(g), degeneracies.size() == g.num_edges());
+}
+
+void ExpectDegeneracies(const string& polygon_str,
+                        const vector<TestDegeneracy>& expected) {
+  S2Builder builder{S2Builder::Options()};
+  builder.StartLayer(make_unique<DegeneracyCheckingLayer>(expected));
+  auto polygon = s2textformat::MakeLaxPolygonOrDie(polygon_str);
+  builder.AddIsFullPolygonPredicate(
+      [&polygon](const Graph& graph, S2Error* error) {
+        return polygon->GetReferencePoint().contained;
+      });
+  for (int i = 0; i < polygon->num_edges(); ++i) {
+    auto edge = polygon->edge(i);
+    builder.AddEdge(edge.v0, edge.v1);
+  }
+  S2Error error;
+  EXPECT_TRUE(builder.Build(&error)) << error;
+}
+
+TEST(FindPolygonDegeneracies, EmptyPolygon) {
+  ExpectDegeneracies("", {});
+}
+
+TEST(FindPolygonDegeneracies, NoDegeneracies) {
+  ExpectDegeneracies("0:0, 0:1, 1:0", {});
+}
+
+TEST(FindPolygonDegeneracies, PointShell) {
+  ExpectDegeneracies("0:0", {{"0:0, 0:0", false}});
+}
+
+TEST(FindPolygonDegeneracies, SiblingPairShells) {
+  ExpectDegeneracies("0:0, 0:1, 1:0; 1:0, 0:1, 0:0", {
+      {"0:0, 0:1", false}, {"0:1, 0:0", false}, {"0:1, 1:0", false},
+      {"1:0, 0:1", false}, {"0:0, 1:0", false}, {"1:0, 0:0", false}
+    });
+}
+
+TEST(FindPolygonDegeneracies, AttachedSiblingPairShells) {
+  ExpectDegeneracies("0:0, 0:1, 1:0; 1:0, 2:0",
+                     {{"1:0, 2:0", false}, {"2:0, 1:0", false}});
+}
+
+TEST(FindPolygonDegeneracies, AttachedSiblingPairHoles) {
+  ExpectDegeneracies("0:0, 0:3, 3:0; 0:0, 1:1",
+                     {{"0:0, 1:1", true}, {"1:1, 0:0", true}});
+}
+
+TEST(FindPolygonDegeneracies, AttachedSiblingPairShellsAndHoles) {
+  ExpectDegeneracies("0:0, 0:3, 3:0; 3:0, 1:1; 3:0, 5:5", {
+      {"3:0, 1:1", true}, {"1:1, 3:0", true},
+      {"3:0, 5:5", false}, {"5:5, 3:0", false},
+    });
+}
+
+TEST(FindPolygonDegeneracies, DegenerateShellsOutsideLoop) {
+  ExpectDegeneracies("0:0, 0:3, 3:3, 3:0; 4:4, 5:5; 6:6", {
+      {"4:4, 5:5", false}, {"5:5, 4:4", false}, {"6:6, 6:6", false}
+    });
+}
+
+TEST(FindPolygonDegeneracies, DegenerateHolesWithinLoop) {
+  ExpectDegeneracies("0:0, 0:5, 5:5, 5:0; 1:1, 2:2; 3:3", {
+      {"1:1, 2:2", true}, {"2:2, 1:1", true}, {"3:3, 3:3", true}
+    });
+}
+
+TEST(FindPolygonDegeneracies, PointHoleWithinFull) {
+  ExpectDegeneracies("full; 0:0", {{"0:0, 0:0", true}});
+}
+
+TEST(FindPolygonDegeneracies, SiblingPairHolesWithinFull) {
+  ExpectDegeneracies("full; 0:0, 0:1, 1:0; 1:0, 0:1, 0:0", {
+      {"0:0, 0:1", true}, {"0:1, 0:0", true}, {"0:1, 1:0", true},
+      {"1:0, 0:1", true}, {"0:0, 1:0", true}, {"1:0, 0:0", true}
+    });
+}
+
+}  // namespace s2builderutil

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

@@ -0,0 +1,57 @@
+// 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_S2BUILDERUTIL_GRAPH_SHAPE_H_
+#define S2_S2BUILDERUTIL_GRAPH_SHAPE_H_
+
+#include <vector>
+
+#include "s2/s2builder_graph.h"
+
+namespace s2builderutil {
+
+// An S2Shape representing the edges in an S2Builder::Graph.
+class GraphShape final : public S2Shape {
+ public:
+  using Graph = S2Builder::Graph;
+  explicit GraphShape(const Graph* g) : g_(*g) {}
+  int num_edges() const override { return g_.num_edges(); }
+  Edge edge(int e) const override {
+    Graph::Edge g_edge = g_.edge(e);
+    return Edge(g_.vertex(g_edge.first), g_.vertex(g_edge.second));
+  }
+  int dimension() const override { return 1; }
+  ReferencePoint GetReferencePoint() const override {
+    return ReferencePoint::Contained(false);
+  }
+  int num_chains() const override { return g_.num_edges(); }
+  Chain chain(int i) const override { return Chain(i, 1); }
+  Edge chain_edge(int i, int j) const override {
+    S2_DCHECK_EQ(j, 0);
+    return edge(i);
+  }
+  ChainPosition chain_position(int e) const override {
+    return ChainPosition(e, 0);
+  }
+
+ private:
+  const Graph& g_;
+};
+
+}  // namespace s2builderutil
+
+#endif  // S2_S2BUILDERUTIL_GRAPH_SHAPE_H_

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

@@ -0,0 +1,212 @@
+// 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/s2builderutil_lax_polygon_layer.h"
+
+#include <algorithm>
+#include <memory>
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/s2builderutil_find_polygon_degeneracies.h"
+#include "s2/s2debug.h"
+
+using std::vector;
+
+using EdgeType = S2Builder::EdgeType;
+using Graph = S2Builder::Graph;
+using GraphOptions = S2Builder::GraphOptions;
+using Label = S2Builder::Label;
+
+using DegenerateEdges = GraphOptions::DegenerateEdges;
+using DuplicateEdges = GraphOptions::DuplicateEdges;
+using SiblingPairs = GraphOptions::SiblingPairs;
+
+using Edge = Graph::Edge;
+using EdgeId = Graph::EdgeId;
+using InputEdgeIdSetId = Graph::InputEdgeIdSetId;
+using LoopType = Graph::LoopType;
+
+namespace s2builderutil {
+
+using DegenerateBoundaries = LaxPolygonLayer::Options::DegenerateBoundaries;
+
+LaxPolygonLayer::LaxPolygonLayer(S2LaxPolygonShape* polygon,
+                                 const Options& options) {
+  Init(polygon, nullptr, nullptr, options);
+}
+
+LaxPolygonLayer::LaxPolygonLayer(
+    S2LaxPolygonShape* polygon, LabelSetIds* label_set_ids,
+    IdSetLexicon* label_set_lexicon, const Options& options) {
+  Init(polygon, label_set_ids, label_set_lexicon, options);
+}
+
+void LaxPolygonLayer::Init(
+    S2LaxPolygonShape* polygon, LabelSetIds* label_set_ids,
+    IdSetLexicon* label_set_lexicon, const Options& options) {
+  S2_DCHECK_EQ(label_set_ids == nullptr, label_set_lexicon == nullptr);
+  polygon_ = polygon;
+  label_set_ids_ = label_set_ids;
+  label_set_lexicon_ = label_set_lexicon;
+  options_ = options;
+}
+
+GraphOptions LaxPolygonLayer::graph_options() const {
+  if (options_.degenerate_boundaries() == DegenerateBoundaries::DISCARD) {
+    // There should not be any duplicate edges, but if there are then we keep
+    // them since this yields more comprehensible error messages.
+    return GraphOptions(options_.edge_type(), DegenerateEdges::DISCARD,
+                        DuplicateEdges::KEEP, SiblingPairs::DISCARD);
+  } else {
+    // Keep at most one copy of each sibling pair and each isolated vertex.
+    // We need DuplicateEdges::MERGE because DegenerateEdges::DISCARD_EXCESS
+    // can still keep multiple copies (it only discards degenerate edges that
+    // are connected to non-degenerate edges).
+    return GraphOptions(options_.edge_type(), DegenerateEdges::DISCARD_EXCESS,
+                        DuplicateEdges::MERGE, SiblingPairs::DISCARD_EXCESS);
+  }
+}
+
+void LaxPolygonLayer::AppendPolygonLoops(
+    const Graph& g, const vector<Graph::EdgeLoop>& edge_loops,
+    vector<vector<S2Point>>* loops) const {
+  for (const auto& edge_loop : edge_loops) {
+    vector<S2Point> vertices;
+    vertices.reserve(edge_loop.size());
+    for (auto edge_id : edge_loop) {
+      vertices.push_back(g.vertex(g.edge(edge_id).first));
+    }
+    loops->push_back(std::move(vertices));
+  }
+}
+
+void LaxPolygonLayer::AppendEdgeLabels(
+    const Graph& g,
+    const vector<Graph::EdgeLoop>& edge_loops) {
+  if (!label_set_ids_) return;
+
+  vector<Label> labels;  // Temporary storage for labels.
+  Graph::LabelFetcher fetcher(g, options_.edge_type());
+  for (const auto& edge_loop : edge_loops) {
+    vector<LabelSetId> loop_label_set_ids;
+    loop_label_set_ids.reserve(edge_loop.size());
+    for (auto edge_id : edge_loop) {
+      fetcher.Fetch(edge_id, &labels);
+      loop_label_set_ids.push_back(label_set_lexicon_->Add(labels));
+    }
+    label_set_ids_->push_back(std::move(loop_label_set_ids));
+  }
+}
+
+// Returns all edges of "g" except for those identified by "edges_to_discard".
+static void DiscardEdges(const Graph& g, const vector<EdgeId>& edges_to_discard,
+                         vector<Edge>* new_edges,
+                         vector<InputEdgeIdSetId>* new_input_edge_id_set_ids) {
+  S2_DCHECK(std::is_sorted(edges_to_discard.begin(), edges_to_discard.end()));
+  new_edges->clear();
+  new_input_edge_id_set_ids->clear();
+  new_edges->reserve(g.num_edges());
+  new_input_edge_id_set_ids->reserve(g.num_edges());
+  auto it = edges_to_discard.begin();
+  for (int e = 0; e < g.num_edges(); ++e) {
+    if (it != edges_to_discard.end() && e == *it) {
+      ++it;
+    } else {
+      new_edges->push_back(g.edge(e));
+      new_input_edge_id_set_ids->push_back(g.input_edge_id_set_id(e));
+    }
+  }
+  S2_DCHECK(it == edges_to_discard.end());
+}
+
+static void MaybeAddFullLoop(
+    const Graph& g, vector<vector<S2Point>>* loops, S2Error* error) {
+  if (g.IsFullPolygon(error)) {
+    loops->push_back({});  // Full loop.
+  }
+}
+void LaxPolygonLayer::BuildDirected(Graph g, S2Error* error) {
+  // Some cases are implemented by constructing a new graph with certain
+  // degenerate edges removed (overwriting "g").  "new_edges" is where the
+  // edges for the new graph are stored.
+  vector<Edge> new_edges;
+  vector<InputEdgeIdSetId> new_input_edge_id_set_ids;
+  vector<vector<S2Point>> loops;
+  auto degenerate_boundaries = options_.degenerate_boundaries();
+  if (degenerate_boundaries == DegenerateBoundaries::DISCARD) {
+    // This is the easiest case, since there are no degeneracies.
+    if (g.num_edges() == 0) MaybeAddFullLoop(g, &loops, error);
+  } else if (degenerate_boundaries == DegenerateBoundaries::KEEP) {
+    // S2LaxPolygonShape doesn't need to distinguish degenerate shells from
+    // holes except when the entire graph is degenerate, in which case we need
+    // to decide whether it represents an empty polygons possibly with
+    // degenerate shells, or a full polygon possibly with degenerate holes.
+    if (s2builderutil::IsFullyDegenerate(g)) {
+      MaybeAddFullLoop(g, &loops, error);
+    }
+  } else {
+    // For DISCARD_SHELLS and DISCARD_HOLES we first determine whether any
+    // degenerate loops of the given type exist, and if so we construct a new
+    // graph with those edges removed (overwriting "g").
+    bool discard_holes =
+        (degenerate_boundaries == DegenerateBoundaries::DISCARD_HOLES);
+    auto degeneracies = s2builderutil::FindPolygonDegeneracies(g, error);
+    if (!error->ok()) return;
+    if (degeneracies.size() == g.num_edges()) {
+      if (degeneracies.empty()) {
+        MaybeAddFullLoop(g, &loops, error);
+      } else if (degeneracies[0].is_hole) {
+        loops.push_back({});  // Full loop.
+      }
+    }
+    vector<EdgeId> edges_to_discard;
+    for (auto degeneracy : degeneracies) {
+      if (degeneracy.is_hole == discard_holes) {
+        edges_to_discard.push_back(degeneracy.edge_id);
+      }
+    }
+    if (!edges_to_discard.empty()) {
+      // Construct a new graph that discards the unwanted edges.
+      std::sort(edges_to_discard.begin(), edges_to_discard.end());
+      DiscardEdges(g, edges_to_discard, &new_edges, &new_input_edge_id_set_ids);
+      g = Graph(g.options(), &g.vertices(),
+                &new_edges, &new_input_edge_id_set_ids,
+                &g.input_edge_id_set_lexicon(), &g.label_set_ids(),
+                &g.label_set_lexicon(), g.is_full_polygon_predicate());
+    }
+  }
+  vector<Graph::EdgeLoop> edge_loops;
+  if (!g.GetDirectedLoops(LoopType::CIRCUIT, &edge_loops, error)) {
+    return;
+  }
+  AppendPolygonLoops(g, edge_loops, &loops);
+  AppendEdgeLabels(g, edge_loops);
+  vector<Graph::EdgeLoop>().swap(edge_loops);  // Release memory
+  vector<Edge>().swap(new_edges);
+  vector<InputEdgeIdSetId>().swap(new_input_edge_id_set_ids);
+  polygon_->Init(loops);
+}
+
+void LaxPolygonLayer::Build(const Graph& g, S2Error* error) {
+  if (label_set_ids_) label_set_ids_->clear();
+  if (g.options().edge_type() == EdgeType::DIRECTED) {
+    BuildDirected(g, error);
+  } else {
+    error->Init(S2Error::UNIMPLEMENTED, "Undirected edges not supported yet");
+  }
+}
+
+}  // namespace s2builderutil