@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,122 @@
+// Copyright 2016 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_S2POINT_VECTOR_LAYER_H_
+#define S2_S2BUILDERUTIL_S2POINT_VECTOR_LAYER_H_
+
+#include <memory>
+#include <vector>
+#include "s2/base/logging.h"
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/id_set_lexicon.h"
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s2builder.h"
+#include "s2/s2builder_graph.h"
+#include "s2/s2builder_layer.h"
+#include "s2/s2error.h"
+#include "s2/s2point_vector_shape.h"
+
+namespace s2builderutil {
+
+// A layer type that collects degenerate edges as points.
+// This layer expects all edges to be degenerate. In case of finding
+// non-degenerate edges it sets S2Error but it still generates the
+// output with degenerate edges.
+class S2PointVectorLayer : public S2Builder::Layer {
+ public:
+  class Options {
+   public:
+    using DuplicateEdges = GraphOptions::DuplicateEdges;
+    Options();
+    explicit Options(DuplicateEdges duplicate_edges);
+
+    // DEFAULT: DuplicateEdges::MERGE
+    DuplicateEdges duplicate_edges() const;
+    void set_duplicate_edges(DuplicateEdges duplicate_edges);
+
+   private:
+    DuplicateEdges duplicate_edges_;
+  };
+
+  explicit S2PointVectorLayer(std::vector<S2Point>* points,
+                              const Options& options = Options());
+
+  using LabelSetIds = std::vector<LabelSetId>;
+  S2PointVectorLayer(std::vector<S2Point>* points, LabelSetIds* label_set_ids,
+                     IdSetLexicon* label_set_lexicon,
+                     const Options& options = Options());
+
+  // Layer interface:
+  GraphOptions graph_options() const override;
+  void Build(const Graph& g, S2Error* error) override;
+
+ private:
+  std::vector<S2Point>* points_;
+  LabelSetIds* label_set_ids_;
+  IdSetLexicon* label_set_lexicon_;
+  Options options_;
+};
+
+// Like S2PointVectorLayer, but adds the points to a MutableS2ShapeIndex (if
+// the point vector is non-empty).
+class IndexedS2PointVectorLayer : public S2Builder::Layer {
+ public:
+  using Options = S2PointVectorLayer::Options;
+  explicit IndexedS2PointVectorLayer(MutableS2ShapeIndex* index,
+                                     const Options& options = Options())
+      : index_(index), layer_(&points_, options) {}
+
+  GraphOptions graph_options() const override {
+    return layer_.graph_options();
+  }
+
+  void Build(const Graph& g, S2Error* error) override {
+    layer_.Build(g, error);
+    if (error->ok() && !points_.empty()) {
+      index_->Add(absl::make_unique<S2PointVectorShape>(std::move(points_)));
+    }
+  }
+
+ private:
+  MutableS2ShapeIndex* index_;
+  std::vector<S2Point> points_;
+  S2PointVectorLayer layer_;
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+inline S2PointVectorLayer::Options::Options()
+    : duplicate_edges_(DuplicateEdges::MERGE) {}
+
+inline S2PointVectorLayer::Options::Options(DuplicateEdges duplicate_edges)
+    : duplicate_edges_(duplicate_edges) {}
+
+inline S2Builder::GraphOptions::DuplicateEdges
+S2PointVectorLayer::Options::duplicate_edges() const {
+  return duplicate_edges_;
+}
+
+inline void S2PointVectorLayer::Options::set_duplicate_edges(
+    S2Builder::GraphOptions::DuplicateEdges duplicate_edges) {
+  duplicate_edges_ = duplicate_edges;
+}
+
+}  // namespace s2builderutil
+
+#endif  // S2_S2BUILDERUTIL_S2POINT_VECTOR_LAYER_H_

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

@@ -0,0 +1,167 @@
+// Copyright 2016 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_s2point_vector_layer.h"
+
+#include <memory>
+#include <string>
+#include "s2/base/casts.h"
+#include "s2/base/integral_types.h"
+#include <gtest/gtest.h>
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s2text_format.h"
+
+using absl::make_unique;
+using s2builderutil::IndexedS2PointVectorLayer;
+using s2builderutil::S2PointVectorLayer;
+using s2textformat::MakePointOrDie;
+using std::vector;
+
+using EdgeType = S2Builder::EdgeType;
+
+namespace {
+
+void VerifyS2PointVectorLayerResults(
+    const S2PointVectorLayer::LabelSetIds& label_set_ids,
+    const IdSetLexicon& label_set_lexicon, const vector<S2Point>& output,
+    const string& str_expected_points,
+    const vector<vector<int32>>& expected_labels) {
+  vector<S2Point> expected_points =
+      s2textformat::ParsePoints(str_expected_points);
+
+  ASSERT_EQ(expected_labels.size(), label_set_ids.size());
+  for (int i = 0; i < output.size(); ++i) {
+    EXPECT_EQ(expected_points[i], output[i]);
+    ASSERT_EQ(expected_labels[i].size(),
+              label_set_lexicon.id_set(label_set_ids[i]).size());
+    int k = 0;
+    for (int32 label : label_set_lexicon.id_set(label_set_ids[i])) {
+      EXPECT_EQ(expected_labels[i][k++], label);
+    }
+  }
+}
+
+void AddPoint(S2Point p, S2Builder* builder) { builder->AddEdge(p, p); }
+
+TEST(S2PointVectorLayer, MergeDuplicates) {
+  S2Builder builder{S2Builder::Options()};
+  vector<S2Point> output;
+  IdSetLexicon label_set_lexicon;
+  S2PointVectorLayer::LabelSetIds label_set_ids;
+  builder.StartLayer(make_unique<S2PointVectorLayer>(
+      &output, &label_set_ids, &label_set_lexicon,
+      S2PointVectorLayer::Options(
+          S2Builder::GraphOptions::DuplicateEdges::MERGE)));
+
+  builder.set_label(1);
+  AddPoint(MakePointOrDie("0:1"), &builder);
+  AddPoint(MakePointOrDie("0:2"), &builder);
+  builder.set_label(2);
+  AddPoint(MakePointOrDie("0:1"), &builder);
+  AddPoint(MakePointOrDie("0:4"), &builder);
+  AddPoint(MakePointOrDie("0:5"), &builder);
+  builder.clear_labels();
+  AddPoint(MakePointOrDie("0:5"), &builder);
+  AddPoint(MakePointOrDie("0:6"), &builder);
+  S2Error error;
+  ASSERT_TRUE(builder.Build(&error));
+
+  vector<vector<int32>> expected_labels = {{1, 2}, {1}, {2}, {2}, {}};
+  string expected_points = "0:1, 0:2, 0:4, 0:5, 0:6";
+
+  VerifyS2PointVectorLayerResults(label_set_ids, label_set_lexicon, output,
+                                  expected_points, expected_labels);
+}
+
+TEST(S2PointVectorLayer, KeepDuplicates) {
+  S2Builder builder{S2Builder::Options()};
+  vector<S2Point> output;
+  IdSetLexicon label_set_lexicon;
+  S2PointVectorLayer::LabelSetIds label_set_ids;
+  builder.StartLayer(make_unique<S2PointVectorLayer>(
+      &output, &label_set_ids, &label_set_lexicon,
+      S2PointVectorLayer::Options(
+          S2Builder::GraphOptions::DuplicateEdges::KEEP)));
+
+  builder.set_label(1);
+  AddPoint(MakePointOrDie("0:1"), &builder);
+  AddPoint(MakePointOrDie("0:2"), &builder);
+  builder.set_label(2);
+  AddPoint(MakePointOrDie("0:1"), &builder);
+  AddPoint(MakePointOrDie("0:4"), &builder);
+  AddPoint(MakePointOrDie("0:5"), &builder);
+  builder.clear_labels();
+  AddPoint(MakePointOrDie("0:5"), &builder);
+  AddPoint(MakePointOrDie("0:6"), &builder);
+  S2Error error;
+  ASSERT_TRUE(builder.Build(&error));
+
+  vector<vector<int32>> expected_labels = {{1}, {2}, {1}, {2}, {2}, {}, {}};
+  string expected_points = "0:1, 0:1, 0:2, 0:4, 0:5, 0:5, 0:6";
+
+  VerifyS2PointVectorLayerResults(label_set_ids, label_set_lexicon, output,
+                                  expected_points, expected_labels);
+}
+
+TEST(S2PointVectorLayer, Error) {
+  S2Builder builder{S2Builder::Options()};
+  vector<S2Point> output;
+  builder.StartLayer(make_unique<S2PointVectorLayer>(
+      &output, S2PointVectorLayer::Options(
+                   S2Builder::GraphOptions::DuplicateEdges::KEEP)));
+
+  AddPoint(MakePointOrDie("0:1"), &builder);
+  builder.AddEdge(MakePointOrDie("0:3"), MakePointOrDie("0:4"));
+  AddPoint(MakePointOrDie("0:5"), &builder);
+  S2Error error;
+  EXPECT_FALSE(builder.Build(&error));
+  EXPECT_EQ(error.code(), S2Error::INVALID_ARGUMENT);
+  EXPECT_EQ(error.text(), "Found non-degenerate edges");
+
+  EXPECT_EQ(2, output.size());
+  EXPECT_EQ(MakePointOrDie("0:1"), output[0]);
+  EXPECT_EQ(MakePointOrDie("0:5"), output[1]);
+}
+
+TEST(IndexedS2PointVectorLayer, AddsShapes) {
+  S2Builder builder{S2Builder::Options()};
+  MutableS2ShapeIndex index;
+  builder.StartLayer(make_unique<IndexedS2PointVectorLayer>(&index));
+  string point0_str = "0:0";
+  string point1_str = "2:2";
+  builder.AddPoint(s2textformat::MakePointOrDie(point0_str));
+  builder.AddPoint(s2textformat::MakePointOrDie(point1_str));
+  S2Error error;
+  ASSERT_TRUE(builder.Build(&error));
+  EXPECT_EQ(1, index.num_shape_ids());
+  auto shape = down_cast<S2PointVectorShape*>(index.shape(0));
+  EXPECT_EQ(2, shape->num_points());
+  EXPECT_EQ(point0_str, s2textformat::ToString(shape->point(0)));
+  EXPECT_EQ(point1_str, s2textformat::ToString(shape->point(1)));
+}
+
+TEST(IndexedS2PointVectorLayer, AddsEmptyShape) {
+  S2Builder builder{S2Builder::Options()};
+  MutableS2ShapeIndex index;
+  builder.StartLayer(make_unique<IndexedS2PointVectorLayer>(&index));
+  S2Error error;
+  ASSERT_TRUE(builder.Build(&error));
+  EXPECT_EQ(0, index.num_shape_ids());
+}
+
+}  // namespace

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

@@ -0,0 +1,191 @@
+// Copyright 2016 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_s2polygon_layer.h"
+
+#include <algorithm>
+#include <memory>
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/s2debug.h"
+
+using absl::make_unique;
+using std::make_pair;
+using std::pair;
+using std::unique_ptr;
+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 LoopType = Graph::LoopType;
+
+namespace s2builderutil {
+
+S2PolygonLayer::S2PolygonLayer(S2Polygon* polygon, const Options& options) {
+  Init(polygon, nullptr, nullptr, options);
+}
+
+S2PolygonLayer::S2PolygonLayer(
+    S2Polygon* polygon, LabelSetIds* label_set_ids,
+    IdSetLexicon* label_set_lexicon, const Options& options) {
+  Init(polygon, label_set_ids, label_set_lexicon, options);
+}
+
+void S2PolygonLayer::Init(
+    S2Polygon* 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;
+
+  if (options_.validate()) {
+    polygon_->set_s2debug_override(S2Debug::DISABLE);
+  }
+}
+
+GraphOptions S2PolygonLayer::graph_options() const {
+  // Prevent degenerate edges and sibling edge pairs.  There should not be any
+  // duplicate edges if the input is valid, but if there are then we keep them
+  // since this tends to produce more comprehensible errors.
+  return GraphOptions(options_.edge_type(), DegenerateEdges::DISCARD,
+                      DuplicateEdges::KEEP, SiblingPairs::DISCARD);
+}
+
+void S2PolygonLayer::AppendS2Loops(const Graph& g,
+                                   const vector<Graph::EdgeLoop>& edge_loops,
+                                   vector<unique_ptr<S2Loop>>* loops) const {
+  vector<S2Point> vertices;
+  for (const auto& edge_loop : edge_loops) {
+    vertices.reserve(edge_loop.size());
+    for (auto edge_id : edge_loop) {
+      vertices.push_back(g.vertex(g.edge(edge_id).first));
+    }
+    loops->push_back(
+        make_unique<S2Loop>(vertices, polygon_->s2debug_override()));
+    vertices.clear();
+  }
+}
+
+void S2PolygonLayer::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));
+  }
+}
+
+void S2PolygonLayer::InitLoopMap(const vector<unique_ptr<S2Loop>>& loops,
+                                 LoopMap* loop_map) const {
+  if (!label_set_ids_) return;
+  for (const auto& loop : loops) {
+    (*loop_map)[&*loop] =
+        make_pair(&loop - &loops[0], loop->contains_origin());
+  }
+}
+
+void S2PolygonLayer::ReorderEdgeLabels(const LoopMap& loop_map) {
+  if (!label_set_ids_) return;
+  LabelSetIds new_ids(label_set_ids_->size());
+  for (int i = 0; i < polygon_->num_loops(); ++i) {
+    S2Loop* loop = polygon_->loop(i);
+    const pair<int, bool>& old = loop_map.find(loop)->second;
+    new_ids[i].swap((*label_set_ids_)[old.first]);
+    if (loop->contains_origin() != old.second) {
+      // S2Loop::Invert() reverses the order of the vertices, which leaves
+      // the last edge unchanged.  For example, the loop ABCD (with edges
+      // AB, BC, CD, DA) becomes the loop DCBA (with edges DC, CB, BA, AD).
+      std::reverse(new_ids[i].begin(), new_ids[i].end() - 1);
+    }
+  }
+  label_set_ids_->swap(new_ids);
+}
+
+void S2PolygonLayer::Build(const Graph& g, S2Error* error) {
+  if (label_set_ids_) label_set_ids_->clear();
+
+  // It's tricky to compute the edge labels for S2Polygons because the
+  // S2Polygon::Init methods can reorder and/or invert the loops.  We handle
+  // this by remembering the original vector index of each loop and whether or
+  // not the loop contained S2::Origin().  By comparing this with the final
+  // S2Polygon loops we can fix up the edge labels appropriately.
+  LoopMap loop_map;
+  if (g.num_edges() == 0) {
+    // The polygon is either full or empty.
+    if (g.IsFullPolygon(error)) {
+      polygon_->Init(make_unique<S2Loop>(S2Loop::kFull()));
+    } else {
+      polygon_->InitNested(vector<unique_ptr<S2Loop>>{});
+    }
+  } else if (g.options().edge_type() == EdgeType::DIRECTED) {
+    vector<Graph::EdgeLoop> edge_loops;
+    if (!g.GetDirectedLoops(LoopType::SIMPLE, &edge_loops, error)) {
+      return;
+    }
+    vector<unique_ptr<S2Loop>> loops;
+    AppendS2Loops(g, edge_loops, &loops);
+    AppendEdgeLabels(g, edge_loops);
+    vector<Graph::EdgeLoop>().swap(edge_loops);  // Release memory
+    InitLoopMap(loops, &loop_map);
+    polygon_->InitOriented(std::move(loops));
+  } else {
+    vector<Graph::UndirectedComponent> components;
+    if (!g.GetUndirectedComponents(LoopType::SIMPLE, &components, error)) {
+      return;
+    }
+    // It doesn't really matter which complement of each component we use,
+    // since below we normalize all the loops so that they enclose at most
+    // half of the sphere (to ensure that the loops can always be nested).
+    //
+    // The only reason to prefer one over the other is that when there are
+    // multiple loops that touch, only one of the two complements matches the
+    // structure of the input loops.  GetUndirectedComponents() tries to
+    // ensure that this is always complement 0 of each component.
+    vector<unique_ptr<S2Loop>> loops;
+    for (const auto& component : components) {
+      AppendS2Loops(g, component[0], &loops);
+      AppendEdgeLabels(g, component[0]);
+    }
+    vector<Graph::UndirectedComponent>().swap(components);  // Release memory
+    InitLoopMap(loops, &loop_map);
+    for (const auto& loop : loops) loop->Normalize();
+    polygon_->InitNested(std::move(loops));
+  }
+  ReorderEdgeLabels(loop_map);
+  if (options_.validate()) {
+    polygon_->FindValidationError(error);
+  }
+}
+
+}  // namespace s2builderutil

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

@@ -0,0 +1,211 @@
+// Copyright 2016 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 there are two supported output types for polygons: S2Polygon and
+// S2LaxPolygonShape.  Use S2Polygon if you need the full range of operations
+// that S2Polygon implements.  Use S2LaxPolygonShape if you want to represent
+// polygons with zero-area degenerate regions, or if you need a type that has
+// low memory overhead and fast initialization.  However, be aware that to
+// convert from a S2LaxPolygonShape to an S2Polygon you will need to use
+// S2Builder again.
+//
+// Similarly, there are two supported output formats for polygon meshes:
+// S2LaxPolygonShapeVector and S2PolygonMesh.  Use S2PolygonMesh if you need
+// to be able to determine which polygons are adjacent to each edge or vertex;
+// otherwise use S2LaxPolygonShapeVector, which uses less memory and is faster
+// to construct.
+
+#ifndef S2_S2BUILDERUTIL_S2POLYGON_LAYER_H_
+#define S2_S2BUILDERUTIL_S2POLYGON_LAYER_H_
+
+#include <memory>
+#include <utility>
+#include <vector>
+#include "s2/base/logging.h"
+#include "s2/util/gtl/btree_map.h"
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/id_set_lexicon.h"
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s2builder.h"
+#include "s2/s2builder_graph.h"
+#include "s2/s2builder_layer.h"
+#include "s2/s2error.h"
+#include "s2/s2loop.h"
+#include "s2/s2polygon.h"
+
+namespace s2builderutil {
+
+// A layer type that assembles edges (directed or undirected) into an
+// S2Polygon.  Returns an error if the edges cannot be assembled into loops.
+//
+// If the input edges are directed, they must be oriented such that the
+// polygon interior is to the left of all edges.  Directed edges are always
+// preferred (see S2Builder::EdgeType).
+//
+// Before the edges are assembled into loops, "sibling pairs" consisting of an
+// edge and its reverse edge are automatically removed.  Such edge pairs
+// represent zero-area degenerate regions, which S2Polygon does not allow.
+// (If you need to build polygons with degeneracies, use LaxPolygonLayer
+// instead.)
+//
+// S2PolygonLayer is implemented such that if the input to S2Builder is a
+// polygon and is not modified, then the output has the same cyclic ordering
+// of loop vertices and the same loop ordering as the input polygon.
+//
+// If the polygon has no edges, then the graph's IsFullPolygonPredicate is
+// called to determine whether the output polygon should be empty (containing
+// no points) or full (containing all points).  This predicate can be
+// specified as part of the S2Builder input geometry.
+class S2PolygonLayer : public S2Builder::Layer {
+ public:
+  class Options {
+   public:
+    // Constructor that uses the default options (listed below).
+    Options();
+
+    // Constructor that specifies the edge type.
+    explicit Options(S2Builder::EdgeType edge_type);
+
+    // Indicates whether the input edges provided to S2Builder are directed or
+    // undirected.  Directed edges should be used whenever possible (see
+    // S2Builder::EdgeType for details).
+    //
+    // If the input edges are directed, they should be oriented so that the
+    // polygon interior is to the left of all edges.  This means that for a
+    // polygon with holes, the outer loops ("shells") should be directed
+    // counter-clockwise while the inner loops ("holes") should be directed
+    // clockwise.  Note that S2Builder::AddPolygon() does this automatically.
+    //
+    // DEFAULT: S2Builder::EdgeType::DIRECTED
+    S2Builder::EdgeType edge_type() const;
+    void set_edge_type(S2Builder::EdgeType edge_type);
+
+    // If true, calls FindValidationError() on the output polygon.  If any
+    // error is found, it will be returned by S2Builder::Build().
+    //
+    // Note that this option calls set_s2debug_override(S2Debug::DISABLE) in
+    // order to turn off the default error checking in debug builds.
+    //
+    // DEFAULT: false
+    bool validate() const;
+    void set_validate(bool validate);
+
+   private:
+    S2Builder::EdgeType edge_type_;
+    bool validate_;
+  };
+
+  // Specifies that a polygon should be constructed using the given options.
+  explicit S2PolygonLayer(S2Polygon* polygon,
+                          const Options& options = Options());
+
+  // Specifies that a polygon should be constructed using the given options,
+  // and that any labels attached to the input edges should be returned in
+  // "label_set_ids" and "label_set_lexicion".
+  //
+  // The labels associated with the edge "polygon.loop(i).vertex({j, j+1})"
+  // can be retrieved as follows:
+  //
+  //   for (int32 label : label_set_lexicon.id_set(label_set_ids[i][j])) {...}
+  using LabelSetIds = std::vector<std::vector<LabelSetId>>;
+  S2PolygonLayer(S2Polygon* polygon, LabelSetIds* label_set_ids,
+                 IdSetLexicon* label_set_lexicon,
+                 const Options& options = Options());
+
+  // Layer interface:
+  GraphOptions graph_options() const override;
+  void Build(const Graph& g, S2Error* error) override;
+
+ private:
+  void Init(S2Polygon* polygon, LabelSetIds* label_set_ids,
+            IdSetLexicon* label_set_lexicon, const Options& options);
+  void AppendS2Loops(const Graph& g,
+                     const std::vector<Graph::EdgeLoop>& edge_loops,
+                     std::vector<std::unique_ptr<S2Loop>>* loops) const;
+  void AppendEdgeLabels(const Graph& g,
+                        const std::vector<Graph::EdgeLoop>& edge_loops);
+  using LoopMap = gtl::btree_map<S2Loop*, std::pair<int, bool>>;
+  void InitLoopMap(const std::vector<std::unique_ptr<S2Loop>>& loops,
+                   LoopMap* loop_map) const;
+  void ReorderEdgeLabels(const LoopMap& loop_map);
+
+  S2Polygon* polygon_;
+  LabelSetIds* label_set_ids_;
+  IdSetLexicon* label_set_lexicon_;
+  Options options_;
+};
+
+// Like S2PolygonLayer, but adds the polygon to a MutableS2ShapeIndex (if the
+// polygon is non-empty).
+class IndexedS2PolygonLayer : public S2Builder::Layer {
+ public:
+  using Options = S2PolygonLayer::Options;
+  explicit IndexedS2PolygonLayer(MutableS2ShapeIndex* index,
+                                 const Options& options = Options())
+      : index_(index), polygon_(new S2Polygon),
+        layer_(polygon_.get(), options) {}
+
+  GraphOptions graph_options() const override {
+    return layer_.graph_options();
+  }
+
+  void Build(const Graph& g, S2Error* error) override {
+    layer_.Build(g, error);
+    if (error->ok() && !polygon_->is_empty()) {
+      index_->Add(
+          absl::make_unique<S2Polygon::OwningShape>(std::move(polygon_)));
+    }
+  }
+
+ private:
+  MutableS2ShapeIndex* index_;
+  std::unique_ptr<S2Polygon> polygon_;
+  S2PolygonLayer layer_;
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+inline S2PolygonLayer::Options::Options()
+    : edge_type_(S2Builder::EdgeType::DIRECTED), validate_(false) {
+}
+
+inline S2PolygonLayer::Options::Options(S2Builder::EdgeType edge_type)
+    : edge_type_(edge_type), validate_(false) {
+}
+
+inline S2Builder::EdgeType S2PolygonLayer::Options::edge_type() const {
+  return edge_type_;
+}
+
+inline void S2PolygonLayer::Options::set_edge_type(
+    S2Builder::EdgeType edge_type) {
+  edge_type_ = edge_type;
+}
+
+inline bool S2PolygonLayer::Options::validate() const {
+  return validate_;
+}
+
+inline void S2PolygonLayer::Options::set_validate(bool validate) {
+  validate_ = validate;
+}
+
+}  // namespace s2builderutil
+
+#endif  // S2_S2BUILDERUTIL_S2POLYGON_LAYER_H_