@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,1084 @@
+// 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/s2builder_graph.h"
+
+#include <algorithm>
+#include <limits>
+#include <memory>
+#include <numeric>
+#include <vector>
+#include "s2/base/logging.h"
+#include "s2/util/gtl/btree_map.h"
+#include "s2/id_set_lexicon.h"
+#include "s2/s2builder.h"
+#include "s2/s2error.h"
+#include "s2/s2predicates.h"
+
+using std::make_pair;
+using std::max;
+using std::min;
+using std::pair;
+using std::vector;
+
+using Graph = S2Builder::Graph;
+using GraphOptions = S2Builder::GraphOptions;
+using DegenerateEdges = GraphOptions::DegenerateEdges;
+using DuplicateEdges = GraphOptions::DuplicateEdges;
+using SiblingPairs = GraphOptions::SiblingPairs;
+
+Graph::Graph(const GraphOptions& options,
+             const vector<S2Point>* vertices,
+             const vector<Edge>* edges,
+             const vector<InputEdgeIdSetId>* input_edge_id_set_ids,
+             const IdSetLexicon* input_edge_id_set_lexicon,
+             const vector<LabelSetId>* label_set_ids,
+             const IdSetLexicon* label_set_lexicon,
+             IsFullPolygonPredicate is_full_polygon_predicate)
+    : options_(options), num_vertices_(vertices->size()), vertices_(vertices),
+      edges_(edges), input_edge_id_set_ids_(input_edge_id_set_ids),
+      input_edge_id_set_lexicon_(input_edge_id_set_lexicon),
+      label_set_ids_(label_set_ids),
+      label_set_lexicon_(label_set_lexicon),
+      is_full_polygon_predicate_(std::move(is_full_polygon_predicate)) {
+  S2_DCHECK(std::is_sorted(edges->begin(), edges->end()));
+  S2_DCHECK_EQ(edges->size(), input_edge_id_set_ids->size());
+}
+
+vector<Graph::EdgeId> Graph::GetInEdgeIds() const {
+  vector<EdgeId> in_edge_ids(num_edges());
+  std::iota(in_edge_ids.begin(), in_edge_ids.end(), 0);
+  std::sort(in_edge_ids.begin(), in_edge_ids.end(),
+            [this](EdgeId ai, EdgeId bi) {
+      return StableLessThan(reverse(edge(ai)), reverse(edge(bi)), ai, bi);
+    });
+  return in_edge_ids;
+}
+
+vector<Graph::EdgeId> Graph::GetSiblingMap() const {
+  vector<EdgeId> in_edge_ids = GetInEdgeIds();
+  MakeSiblingMap(&in_edge_ids);
+  return in_edge_ids;
+}
+
+void Graph::MakeSiblingMap(vector<Graph::EdgeId>* in_edge_ids) const {
+  S2_DCHECK(options_.sibling_pairs() == SiblingPairs::REQUIRE ||
+         options_.sibling_pairs() == SiblingPairs::CREATE ||
+         options_.edge_type() == EdgeType::UNDIRECTED);
+  for (EdgeId e = 0; e < num_edges(); ++e) {
+    S2_DCHECK(edge(e) == reverse(edge((*in_edge_ids)[e])));
+  }
+  if (options_.edge_type() == EdgeType::DIRECTED) return;
+  if (options_.degenerate_edges() == DegenerateEdges::DISCARD) return;
+
+  for (EdgeId e = 0; e < num_edges(); ++e) {
+    VertexId v = edge(e).first;
+    if (edge(e).second == v) {
+      S2_DCHECK_LT(e + 1, num_edges());
+      S2_DCHECK_EQ(edge(e + 1).first, v);
+      S2_DCHECK_EQ(edge(e + 1).second, v);
+      S2_DCHECK_EQ((*in_edge_ids)[e], e);
+      S2_DCHECK_EQ((*in_edge_ids)[e + 1], e + 1);
+      (*in_edge_ids)[e] = e + 1;
+      (*in_edge_ids)[e + 1] = e;
+      ++e;
+    }
+  }
+}
+
+void Graph::VertexOutMap::Init(const Graph& g) {
+  edges_ = &g.edges();
+  edge_begins_.reserve(g.num_vertices() + 1);
+  EdgeId e = 0;
+  for (VertexId v = 0; v <= g.num_vertices(); ++v) {
+    while (e < g.num_edges() && g.edge(e).first < v) ++e;
+    edge_begins_.push_back(e);
+  }
+}
+
+void Graph::VertexInMap::Init(const Graph& g) {
+  in_edge_ids_ = g.GetInEdgeIds();
+  in_edge_begins_.reserve(g.num_vertices() + 1);
+  EdgeId e = 0;
+  for (VertexId v = 0; v <= g.num_vertices(); ++v) {
+    while (e < g.num_edges() && g.edge(in_edge_ids_[e]).second < v) ++e;
+    in_edge_begins_.push_back(e);
+  }
+}
+
+void Graph::LabelFetcher::Init(const Graph& g, S2Builder::EdgeType edge_type) {
+  g_ = &g;
+  edge_type_ = edge_type;
+  if (edge_type == EdgeType::UNDIRECTED) sibling_map_ = g.GetSiblingMap();
+}
+
+void Graph::LabelFetcher::Fetch(EdgeId e, vector<S2Builder::Label>* labels) {
+  labels->clear();
+  for (InputEdgeId input_edge_id : g_->input_edge_ids(e)) {
+    for (Label label : g_->labels(input_edge_id)) {
+      labels->push_back(label);
+    }
+  }
+  if (edge_type_ == EdgeType::UNDIRECTED) {
+    for (InputEdgeId input_edge_id : g_->input_edge_ids(sibling_map_[e])) {
+      for (Label label : g_->labels(input_edge_id)) {
+        labels->push_back(label);
+      }
+    }
+  }
+  if (labels->size() > 1) {
+    std::sort(labels->begin(), labels->end());
+    labels->erase(std::unique(labels->begin(), labels->end()), labels->end());
+  }
+}
+
+S2Builder::InputEdgeId Graph::min_input_edge_id(EdgeId e) const {
+  IdSetLexicon::IdSet id_set = input_edge_ids(e);
+  return (id_set.size() == 0) ? kNoInputEdgeId : *id_set.begin();
+}
+
+vector<S2Builder::InputEdgeId> Graph::GetMinInputEdgeIds() const {
+  vector<InputEdgeId> min_input_ids(num_edges());
+  for (EdgeId e = 0; e < num_edges(); ++e) {
+    min_input_ids[e] = min_input_edge_id(e);
+  }
+  return min_input_ids;
+}
+
+vector<Graph::EdgeId> Graph::GetInputEdgeOrder(
+    const vector<InputEdgeId>& input_ids) const {
+  vector<EdgeId> order(input_ids.size());
+  std::iota(order.begin(), order.end(), 0);
+  std::sort(order.begin(), order.end(), [&input_ids](EdgeId a, EdgeId b) {
+      // Comparison function ensures sort is stable.
+      return make_pair(input_ids[a], a) < make_pair(input_ids[b], b);
+    });
+  return order;
+}
+
+// A struct for sorting the incoming and outgoing edges around a vertex "v0".
+struct VertexEdge {
+  VertexEdge(bool _incoming, Graph::EdgeId _index,
+             Graph::VertexId _endpoint, int32 _rank)
+      : incoming(_incoming), index(_index),
+        endpoint(_endpoint), rank(_rank) {
+  }
+  bool incoming;             // Is this an incoming edge to "v0"?
+  Graph::EdgeId index;       // Index of this edge in "edges_" or "in_edge_ids"
+  Graph::VertexId endpoint;  // The other (not "v0") endpoint of this edge
+  int32 rank;                // Secondary key for edges with the same endpoint
+};
+
+// Given a set of duplicate outgoing edges (v0, v1) and a set of duplicate
+// incoming edges (v1, v0), this method assigns each edge an integer "rank" so
+// that the edges are sorted in a consistent order with respect to their
+// orderings around "v0" and "v1".  Usually there is just one edge, in which
+// case this is easy.  Sometimes there is one edge in each direction, in which
+// case the outgoing edge is always ordered before the incoming edge.
+//
+// In general, we allow any number of duplicate edges in each direction, in
+// which case outgoing edges are interleaved with incoming edges so as to
+// create as many degenerate (two-edge) loops as possible.  In order to get a
+// consistent ordering around "v0" and "v1", we move forwards through the list
+// of outgoing edges and backwards through the list of incoming edges.  If
+// there are more incoming edges, they go at the beginning of the ordering,
+// while if there are more outgoing edges then they go at the end.
+//
+// For example, suppose there are 2 edges "a,b" from "v0" to "v1", and 4 edges
+// "w,x,y,z" from "v1" to "v0".  Using lower/upper case letters to represent
+// incoming/outgoing edges, the clockwise ordering around v0 would be zyAxBw,
+// and the clockwise ordering around v1 would be WbXaYZ.  (Try making a
+// diagram with each edge as a separate arc.)
+static void AddVertexEdges(Graph::EdgeId out_begin, Graph::EdgeId out_end,
+                           Graph::EdgeId in_begin, Graph::EdgeId in_end,
+                           Graph::VertexId v1, vector<VertexEdge>* v0_edges) {
+  int rank = 0;
+  // Any extra incoming edges go at the beginning of the ordering.
+  while (in_end - in_begin > out_end - out_begin) {
+    v0_edges->push_back(VertexEdge(true, --in_end, v1, rank++));
+  }
+  // Next we interleave as many outgoing and incoming edges as possible.
+  while (in_end > in_begin) {
+    v0_edges->push_back(VertexEdge(false, out_begin++, v1, rank++));
+    v0_edges->push_back(VertexEdge(true, --in_end, v1, rank++));
+  }
+  // Any extra outgoing edges to at the end of the ordering.
+  while (out_end > out_begin) {
+    v0_edges->push_back(VertexEdge(false, out_begin++, v1, rank++));
+  }
+}
+
+bool Graph::GetLeftTurnMap(const vector<EdgeId>& in_edge_ids,
+                           vector<EdgeId>* left_turn_map,
+                           S2Error* error) const {
+  left_turn_map->assign(num_edges(), -1);
+  if (num_edges() == 0) return true;
+
+  // Declare vectors outside the loop to avoid reallocating them each time.
+  vector<VertexEdge> v0_edges;
+  vector<EdgeId> e_in, e_out;
+
+  // Walk through the two sorted arrays of edges (outgoing and incoming) and
+  // gather all the edges incident to each vertex.  Then we sort those edges
+  // and add an entry to the left turn map from each incoming edge to the
+  // immediately following outgoing edge in clockwise order.
+  int out = 0, in = 0;
+  const Edge* out_edge = &edge(out);
+  const Edge* in_edge = &edge(in_edge_ids[in]);
+  Edge sentinel(num_vertices(), num_vertices());
+  Edge min_edge = min(*out_edge, reverse(*in_edge));
+  while (min_edge != sentinel) {
+    // Gather all incoming and outgoing edges around vertex "v0".
+    VertexId v0 = min_edge.first;
+    for (; min_edge.first == v0; min_edge = min(*out_edge, reverse(*in_edge))) {
+      VertexId v1 = min_edge.second;
+      // Count the number of copies of "min_edge" in each direction.
+      int out_begin = out, in_begin = in;
+      while (*out_edge == min_edge) {
+        out_edge = (++out == num_edges()) ? &sentinel : &edge(out);
+      }
+      while (reverse(*in_edge) == min_edge) {
+        in_edge = (++in == num_edges()) ? &sentinel : &edge(in_edge_ids[in]);
+      }
+      if (v0 != v1) {
+        AddVertexEdges(out_begin, out, in_begin, in, v1, &v0_edges);
+      } else {
+        // Each degenerate edge becomes its own loop.
+        for (; in_begin < in; ++in_begin) {
+          (*left_turn_map)[in_begin] = in_begin;
+        }
+      }
+    }
+    if (v0_edges.empty()) continue;
+
+    // Sort the edges in clockwise order around "v0".
+    VertexId min_endpoint = v0_edges.front().endpoint;
+    std::sort(v0_edges.begin() + 1, v0_edges.end(),
+              [v0, min_endpoint, this](const VertexEdge& a,
+                                       const VertexEdge& b) {
+        if (a.endpoint == b.endpoint) return a.rank < b.rank;
+        if (a.endpoint == min_endpoint) return true;
+        if (b.endpoint == min_endpoint) return false;
+        return !s2pred::OrderedCCW(vertex(a.endpoint), vertex(b.endpoint),
+                                   vertex(min_endpoint), vertex(v0));
+      });
+    // Match incoming with outgoing edges.  We do this by keeping a stack of
+    // unmatched incoming edges.  We also keep a stack of outgoing edges with
+    // no previous incoming edge, and match these at the end by wrapping
+    // around circularly to the start of the edge ordering.
+    for (const VertexEdge& e : v0_edges) {
+      if (e.incoming) {
+        e_in.push_back(in_edge_ids[e.index]);
+      } else if (!e_in.empty()) {
+        (*left_turn_map)[e_in.back()] = e.index;
+        e_in.pop_back();
+      } else {
+        e_out.push_back(e.index);  // Matched below.
+      }
+    }
+    // Pair up additional edges using the fact that the ordering is circular.
+    std::reverse(e_out.begin(), e_out.end());
+    for (; !e_out.empty() && !e_in.empty(); e_out.pop_back(), e_in.pop_back()) {
+      (*left_turn_map)[e_in.back()] = e_out.back();
+    }
+    // We only need to process unmatched incoming edges, since we are only
+    // responsible for creating left turn map entries for those edges.
+    if (!e_in.empty() && error->ok()) {
+      error->Init(S2Error::BUILDER_EDGES_DO_NOT_FORM_LOOPS,
+                  "Given edges do not form loops (indegree != outdegree)");
+    }
+    e_in.clear();
+    e_out.clear();
+    v0_edges.clear();
+  }
+  return error->ok();
+}
+
+void Graph::CanonicalizeLoopOrder(const vector<InputEdgeId>& min_input_ids,
+                                  vector<EdgeId>* loop) {
+  if (loop->empty()) return;
+  // Find the position of the element with the highest input edge id.  If
+  // there are multiple such elements together (i.e., the edge was split
+  // into several pieces by snapping it to several vertices), then we choose
+  // the last such position in cyclic order (this attempts to preserve the
+  // original loop order even when new vertices are added).  For example, if
+  // the input edge id sequence is (7, 7, 4, 5, 6, 7) then we would rotate
+  // it to obtain (4, 5, 6, 7, 7, 7).
+
+  // The reason that we put the highest-numbered edge last, rather than the
+  // lowest-numbered edge first, is that S2Loop::Invert() reverses the loop
+  // edge order *except* for the last edge.  For example, the loop ABCD (with
+  // edges AB, BC, CD, DA) becomes DCBA (with edges DC, CB, BA, AD).  Note
+  // that the last edge is the same except for its direction (DA vs. AD).
+  // This has the advantage that if an undirected loop is assembled with the
+  // wrong orientation and later inverted (e.g. by S2Polygon::InitOriented),
+  // we still end up preserving the original cyclic vertex order.
+  int pos = 0;
+  bool saw_gap = false;
+  for (int i = 1; i < loop->size(); ++i) {
+    int cmp = min_input_ids[(*loop)[i]] - min_input_ids[(*loop)[pos]];
+    if (cmp < 0) {
+      saw_gap = true;
+    } else if (cmp > 0 || !saw_gap) {
+      pos = i;
+      saw_gap = false;
+    }
+  }
+  if (++pos == loop->size()) pos = 0;  // Convert loop end to loop start.
+  std::rotate(loop->begin(), loop->begin() + pos, loop->end());
+}
+
+void Graph::CanonicalizeVectorOrder(const vector<InputEdgeId>& min_input_ids,
+                                    vector<vector<EdgeId>>* chains) {
+  std::sort(chains->begin(), chains->end(),
+    [&min_input_ids](const vector<EdgeId>& a, const vector<EdgeId>& b) {
+      return min_input_ids[a[0]] < min_input_ids[b[0]];
+    });
+}
+
+bool Graph::GetDirectedLoops(LoopType loop_type, vector<EdgeLoop>* loops,
+                             S2Error* error) const {
+  S2_DCHECK(options_.degenerate_edges() == DegenerateEdges::DISCARD ||
+         options_.degenerate_edges() == DegenerateEdges::DISCARD_EXCESS);
+  S2_DCHECK(options_.edge_type() == EdgeType::DIRECTED);
+
+  vector<EdgeId> left_turn_map;
+  if (!GetLeftTurnMap(GetInEdgeIds(), &left_turn_map, error)) return false;
+  vector<InputEdgeId> min_input_ids = GetMinInputEdgeIds();
+
+  // If we are breaking loops at repeated vertices, we maintain a map from
+  // VertexId to its position in "path".
+  vector<int> path_index;
+  if (loop_type == LoopType::SIMPLE) path_index.assign(num_vertices(), -1);
+
+  // Visit edges in arbitrary order, and try to build a loop from each edge.
+  vector<EdgeId> path;
+  for (EdgeId start = 0; start < num_edges(); ++start) {
+    if (left_turn_map[start] < 0) continue;
+
+    // Build a loop by making left turns at each vertex until we return to
+    // "start".  We use "left_turn_map" to keep track of which edges have
+    // already been visited by setting its entries to -1 as we go along.  If
+    // we are building vertex cycles, then whenever we encounter a vertex that
+    // is already part of the path, we "peel off" a loop by removing those
+    // edges from the path so far.
+    for (EdgeId e = start, next; left_turn_map[e] >= 0; e = next) {
+      path.push_back(e);
+      next = left_turn_map[e];
+      left_turn_map[e] = -1;
+      if (loop_type == LoopType::SIMPLE) {
+        path_index[edge(e).first] = path.size() - 1;
+        int loop_start = path_index[edge(e).second];
+        if (loop_start < 0) continue;
+        // Peel off a loop from the path.
+        vector<EdgeId> loop(path.begin() + loop_start, path.end());
+        path.erase(path.begin() + loop_start, path.end());
+        for (EdgeId e2 : loop) path_index[edge(e2).first] = -1;
+        CanonicalizeLoopOrder(min_input_ids, &loop);
+        loops->push_back(std::move(loop));
+      }
+    }
+    if (loop_type == LoopType::SIMPLE) {
+      S2_DCHECK(path.empty());  // Invariant.
+    } else {
+      CanonicalizeLoopOrder(min_input_ids, &path);
+      loops->push_back(std::move(path));
+      path.clear();
+    }
+  }
+  CanonicalizeVectorOrder(min_input_ids, loops);
+  return true;
+}
+
+bool Graph::GetDirectedComponents(
+    DegenerateBoundaries degenerate_boundaries,
+    vector<DirectedComponent>* components, S2Error* error) const {
+  S2_DCHECK(options_.degenerate_edges() == DegenerateEdges::DISCARD ||
+         (options_.degenerate_edges() == DegenerateEdges::DISCARD_EXCESS &&
+          degenerate_boundaries == DegenerateBoundaries::KEEP));
+  S2_DCHECK(options_.sibling_pairs() == SiblingPairs::REQUIRE ||
+         options_.sibling_pairs() == SiblingPairs::CREATE);
+  S2_DCHECK(options_.edge_type() == EdgeType::DIRECTED);  // Implied by above.
+
+  vector<EdgeId> sibling_map = GetInEdgeIds();
+  vector<EdgeId> left_turn_map;
+  if (!GetLeftTurnMap(sibling_map, &left_turn_map, error)) return false;
+  MakeSiblingMap(&sibling_map);
+  vector<InputEdgeId> min_input_ids = GetMinInputEdgeIds();
+  vector<EdgeId> frontier;  // Unexplored sibling edges.
+
+  // A map from EdgeId to the position of that edge in "path".  Only needed if
+  // degenerate boundaries are being discarded.
+  vector<int> path_index;
+  if (degenerate_boundaries == DegenerateBoundaries::DISCARD) {
+    path_index.assign(num_edges(), -1);
+  }
+  for (EdgeId min_start = 0; min_start < num_edges(); ++min_start) {
+    if (left_turn_map[min_start] < 0) continue;  // Already used.
+
+    // Build a connected component by keeping a stack of unexplored siblings
+    // of the edges used so far.
+    DirectedComponent component;
+    frontier.push_back(min_start);
+    while (!frontier.empty()) {
+      EdgeId start = frontier.back();
+      frontier.pop_back();
+      if (left_turn_map[start] < 0) continue;  // Already used.
+
+      // Build a path by making left turns at each vertex until we return to
+      // "start".  Whenever we encounter an edge that is a sibling of an edge
+      // that is already on the path, we "peel off" a loop consisting of any
+      // edges that were between these two edges.
+      vector<EdgeId> path;
+      for (EdgeId e = start, next; left_turn_map[e] >= 0; e = next) {
+        path.push_back(e);
+        next = left_turn_map[e];
+        left_turn_map[e] = -1;
+        // If the sibling hasn't been visited yet, add it to the frontier.
+        EdgeId sibling = sibling_map[e];
+        if (left_turn_map[sibling] >= 0) {
+          frontier.push_back(sibling);
+        }
+        if (degenerate_boundaries == DegenerateBoundaries::DISCARD) {
+          path_index[e] = path.size() - 1;
+          int sibling_index = path_index[sibling];
+          if (sibling_index < 0) continue;
+
+          // Common special case: the edge and its sibling are adjacent, in
+          // which case we can simply remove them from the path and continue.
+          if (sibling_index == path.size() - 2) {
+            path.resize(sibling_index);
+            // We don't need to update "path_index" for these two edges
+            // because both edges of the sibling pair have now been used.
+            continue;
+          }
+          // Peel off a loop from the path.
+          vector<EdgeId> loop(path.begin() + sibling_index + 1, path.end() - 1);
+          path.erase(path.begin() + sibling_index, path.end());
+          // Mark the edges that are no longer part of the path.
+          for (EdgeId e2 : loop) path_index[e2] = -1;
+          CanonicalizeLoopOrder(min_input_ids, &loop);
+          component.push_back(std::move(loop));
+        }
+      }
+      // Mark the edges that are no longer part of the path.
+      if (degenerate_boundaries == DegenerateBoundaries::DISCARD) {
+        for (EdgeId e2 : path) path_index[e2] = -1;
+      }
+      CanonicalizeLoopOrder(min_input_ids, &path);
+      component.push_back(std::move(path));
+    }
+    CanonicalizeVectorOrder(min_input_ids, &component);
+    components->push_back(std::move(component));
+  }
+  // Sort the components to correspond to the input edge ordering.
+  std::sort(components->begin(), components->end(),
+            [&min_input_ids](const DirectedComponent& a,
+                             const DirectedComponent& b) {
+      return min_input_ids[a[0][0]] < min_input_ids[b[0][0]];
+    });
+  return true;
+}
+
+// Encodes the index of one of the two complements of each component
+// (a.k.a. the "slot", either 0 or 1) as a negative EdgeId.
+inline static Graph::EdgeId MarkEdgeUsed(int slot) { return -1 - slot; }
+
+bool Graph::GetUndirectedComponents(LoopType loop_type,
+                                    vector<UndirectedComponent>* components,
+                                    S2Error* error) const {
+  S2_DCHECK(options_.degenerate_edges() == DegenerateEdges::DISCARD ||
+         options_.degenerate_edges() == DegenerateEdges::DISCARD_EXCESS);
+  S2_DCHECK(options_.edge_type() == EdgeType::UNDIRECTED);
+
+  vector<EdgeId> sibling_map = GetInEdgeIds();
+  vector<EdgeId> left_turn_map;
+  if (!GetLeftTurnMap(sibling_map, &left_turn_map, error)) return false;
+  MakeSiblingMap(&sibling_map);
+  vector<InputEdgeId> min_input_ids = GetMinInputEdgeIds();
+
+  // A stack of unexplored sibling edges.  Each sibling edge has a "slot"
+  // (0 or 1) that indicates which of the two complements it belongs to.
+  vector<pair<EdgeId, int>> frontier;
+
+  // If we are breaking loops at repeated vertices, we maintain a map from
+  // VertexId to its position in "path".
+  vector<int> path_index;
+  if (loop_type == LoopType::SIMPLE) path_index.assign(num_vertices(), -1);
+
+  for (EdgeId min_start = 0; min_start < num_edges(); ++min_start) {
+    if (left_turn_map[min_start] < 0) continue;  // Already used.
+
+    // Build a connected component by keeping a stack of unexplored siblings
+    // of the edges used so far.
+    UndirectedComponent component;
+    frontier.push_back(make_pair(min_start, 0));
+    while (!frontier.empty()) {
+      EdgeId start = frontier.back().first;
+      int slot = frontier.back().second;
+      frontier.pop_back();
+      if (left_turn_map[start] < 0) continue;  // Already used.
+
+      // Build a path by making left turns at each vertex until we return to
+      // "start".  We use "left_turn_map" to keep track of which edges have
+      // already been visited, and which complement they were assigned to, by
+      // setting its entries to negative values as we go along.
+      vector<EdgeId> path;
+      for (EdgeId e = start, next; left_turn_map[e] >= 0; e = next) {
+        path.push_back(e);
+        next = left_turn_map[e];
+        left_turn_map[e] = MarkEdgeUsed(slot);
+        // If the sibling hasn't been visited yet, add it to the frontier.
+        EdgeId sibling = sibling_map[e];
+        if (left_turn_map[sibling] >= 0) {
+          frontier.push_back(make_pair(sibling, 1 - slot));
+        } else if (left_turn_map[sibling] != MarkEdgeUsed(1 - slot)) {
+          // Two siblings edges can only belong the same complement if the
+          // given undirected edges do not form loops.
+          error->Init(S2Error::BUILDER_EDGES_DO_NOT_FORM_LOOPS,
+                      "Given undirected edges do not form loops");
+          return false;
+        }
+        if (loop_type == LoopType::SIMPLE) {
+          // Whenever we encounter a vertex that is already part of the path,
+          // we "peel off" a loop by removing those edges from the path.
+          path_index[edge(e).first] = path.size() - 1;
+          int loop_start = path_index[edge(e).second];
+          if (loop_start < 0) continue;
+          vector<EdgeId> loop(path.begin() + loop_start, path.end());
+          path.erase(path.begin() + loop_start, path.end());
+          // Mark the vertices that are no longer part of the path.
+          for (EdgeId e2 : loop) path_index[edge(e2).first] = -1;
+          CanonicalizeLoopOrder(min_input_ids, &loop);
+          component[slot].push_back(std::move(loop));
+        }
+      }
+      if (loop_type == LoopType::SIMPLE) {
+        S2_DCHECK(path.empty());  // Invariant.
+      } else {
+        CanonicalizeLoopOrder(min_input_ids, &path);
+        component[slot].push_back(std::move(path));
+      }
+    }
+    CanonicalizeVectorOrder(min_input_ids, &component[0]);
+    CanonicalizeVectorOrder(min_input_ids, &component[1]);
+    // To save some work in S2PolygonLayer, we swap the two loop sets of the
+    // component so that the loop set whose first loop most closely follows
+    // the input edge ordering is first.  (If the input was a valid S2Polygon,
+    // then this component will contain normalized loops.)
+    if (min_input_ids[component[0][0][0]] > min_input_ids[component[1][0][0]]) {
+      component[0].swap(component[1]);
+    }
+    components->push_back(std::move(component));
+  }
+  // Sort the components to correspond to the input edge ordering.
+  std::sort(components->begin(), components->end(),
+       [&min_input_ids](const UndirectedComponent& a,
+                        const UndirectedComponent& b) {
+      return min_input_ids[a[0][0][0]] < min_input_ids[b[0][0][0]];
+    });
+  return true;
+}
+
+class Graph::PolylineBuilder {
+ public:
+  explicit PolylineBuilder(const Graph& g);
+  vector<EdgePolyline> BuildPaths();
+  vector<EdgePolyline> BuildWalks();
+
+ private:
+  bool is_interior(VertexId v);
+  int excess_degree(VertexId v);
+  EdgePolyline BuildPath(EdgeId e);
+  EdgePolyline BuildWalk(VertexId v);
+  void MaximizeWalk(EdgePolyline* polyline);
+
+  const Graph& g_;
+  Graph::VertexInMap in_;
+  Graph::VertexOutMap out_;
+  vector<EdgeId> sibling_map_;
+  vector<InputEdgeId> min_input_ids_;
+  bool directed_;
+  int edges_left_;
+  vector<bool> used_;
+  // A map of (outdegree(v) - indegree(v)) considering used edges only.
+  gtl::btree_map<VertexId, int> excess_used_;
+};
+
+vector<Graph::EdgePolyline> Graph::GetPolylines(
+    PolylineType polyline_type) const {
+  S2_DCHECK(options_.sibling_pairs() == SiblingPairs::DISCARD ||
+         options_.sibling_pairs() == SiblingPairs::DISCARD_EXCESS ||
+         options_.sibling_pairs() == SiblingPairs::KEEP);
+  PolylineBuilder builder(*this);
+  if (polyline_type == PolylineType::PATH) {
+    return builder.BuildPaths();
+  } else {
+    return builder.BuildWalks();
+  }
+}
+
+Graph::PolylineBuilder::PolylineBuilder(const Graph& g)
+    : g_(g), in_(g), out_(g),
+      min_input_ids_(g.GetMinInputEdgeIds()),
+      directed_(g_.options().edge_type() == EdgeType::DIRECTED),
+      edges_left_(g.num_edges() / (directed_ ? 1 : 2)),
+      used_(g.num_edges(), false) {
+  if (!directed_) {
+    sibling_map_ = in_.in_edge_ids();
+    g.MakeSiblingMap(&sibling_map_);
+  }
+}
+
+inline bool Graph::PolylineBuilder::is_interior(VertexId v) {
+  if (directed_) {
+    return in_.degree(v) == 1 && out_.degree(v) == 1;
+  } else {
+    return out_.degree(v) == 2;
+  }
+}
+
+inline int Graph::PolylineBuilder::excess_degree(VertexId v) {
+  return directed_ ? out_.degree(v) - in_.degree(v) : out_.degree(v) % 2;
+}
+
+vector<Graph::EdgePolyline> Graph::PolylineBuilder::BuildPaths() {
+  // First build polylines starting at all the vertices that cannot be in the
+  // polyline interior (i.e., indegree != 1 or outdegree != 1 for directed
+  // edges, or degree != 2 for undirected edges).  We consider the possible
+  // starting edges in input edge id order so that we preserve the input path
+  // direction even when undirected edges are used.  (Undirected edges are
+  // represented by sibling pairs where only the edge in the input direction
+  // is labeled with an input edge id.)
+  vector<EdgePolyline> polylines;
+  vector<EdgeId> edges = g_.GetInputEdgeOrder(min_input_ids_);
+  for (EdgeId e : edges) {
+    if (!used_[e] && !is_interior(g_.edge(e).first)) {
+      polylines.push_back(BuildPath(e));
+    }
+  }
+  // If there are any edges left, they form non-intersecting loops.  We build
+  // each loop and then canonicalize its edge order.  We consider candidate
+  // starting edges in input edge id order in order to preserve the input
+  // direction of undirected loops.  Even so, we still need to canonicalize
+  // the edge order to ensure that when an input edge is split into an edge
+  // chain, the loop does not start in the middle of such a chain.
+  for (EdgeId e : edges) {
+    if (edges_left_ == 0) break;
+    if (used_[e]) continue;
+    EdgePolyline polyline = BuildPath(e);
+    CanonicalizeLoopOrder(min_input_ids_, &polyline);
+    polylines.push_back(std::move(polyline));
+  }
+  S2_DCHECK_EQ(0, edges_left_);
+
+  // Sort the polylines to correspond to the input order (if possible).
+  CanonicalizeVectorOrder(min_input_ids_, &polylines);
+  return polylines;
+}
+
+Graph::EdgePolyline Graph::PolylineBuilder::BuildPath(EdgeId e) {
+  // We simply follow edges until either we reach a vertex where there is a
+  // choice about which way to go (where is_interior(v) is false), or we
+  // return to the starting vertex (if the polyline is actually a loop).
+  EdgePolyline polyline;
+  VertexId start = g_.edge(e).first;
+  for (;;) {
+    polyline.push_back(e);
+    S2_DCHECK(!used_[e]);
+    used_[e] = true;
+    if (!directed_) used_[sibling_map_[e]] = true;
+    --edges_left_;
+    VertexId v = g_.edge(e).second;
+    if (!is_interior(v) || v == start) break;
+    if (directed_) {
+      S2_DCHECK_EQ(1, out_.degree(v));
+      e = *out_.edge_ids(v).begin();
+    } else {
+      S2_DCHECK_EQ(2, out_.degree(v));
+      for (EdgeId e2 : out_.edge_ids(v)) if (!used_[e2]) e = e2;
+    }
+  }
+  return polyline;
+}
+
+vector<Graph::EdgePolyline> Graph::PolylineBuilder::BuildWalks() {
+  // Note that some of this code is worst-case quadratic in the maximum vertex
+  // degree.  This could be fixed with a few extra arrays, but it should not
+  // be a problem in practice.
+
+  // First, build polylines from all vertices where outdegree > indegree (or
+  // for undirected edges, vertices whose degree is odd).  We consider the
+  // possible starting edges in input edge id order, for idempotency in the
+  // case where multiple input polylines share vertices or edges.
+  vector<EdgePolyline> polylines;
+  vector<EdgeId> edges = g_.GetInputEdgeOrder(min_input_ids_);
+  for (EdgeId e : edges) {
+    if (used_[e]) continue;
+    VertexId v = g_.edge(e).first;
+    int excess = excess_degree(v);
+    if (excess <= 0) continue;
+    excess -= excess_used_[v];
+    if (directed_ ? (excess <= 0) : (excess % 2 == 0)) continue;
+    ++excess_used_[v];
+    polylines.push_back(BuildWalk(v));
+    --excess_used_[g_.edge(polylines.back().back()).second];
+  }
+  // Now all vertices have outdegree == indegree (or even degree if undirected
+  // edges are being used).  Therefore all remaining edges can be assembled
+  // into loops.  We first try to expand the existing polylines if possible by
+  // adding loops to them.
+  if (edges_left_ > 0) {
+    for (EdgePolyline& polyline : polylines) {
+      MaximizeWalk(&polyline);
+    }
+  }
+  // Finally, if there are still unused edges then we build loops.  If the
+  // input is a polyline that forms a loop, then for idempotency we need to
+  // start from the edge with minimum input edge id.  If the minimal input
+  // edge was split into several edges, then we start from the first edge of
+  // the chain.
+  for (int i = 0; i < edges.size() && edges_left_ > 0; ++i) {
+    EdgeId e = edges[i];
+    if (used_[e]) continue;
+
+    // Determine whether the origin of this edge is the start of an edge
+    // chain.  To do this, we test whether (outdegree - indegree == 1) for the
+    // origin, considering only unused edges with the same minimum input edge
+    // id.  (Undirected edges have input edge ids in one direction only.)
+    VertexId v = g_.edge(e).first;
+    InputEdgeId id = min_input_ids_[e];
+    int excess = 0;
+    for (int j = i; j < edges.size() && min_input_ids_[edges[j]] == id; ++j) {
+      EdgeId e2 = edges[j];
+      if (used_[e2]) continue;
+      if (g_.edge(e2).first == v) ++excess;
+      if (g_.edge(e2).second == v) --excess;
+    }
+    // It is also acceptable to start a polyline from any degenerate edge.
+    if (excess == 1 || g_.edge(e).second == v) {
+      EdgePolyline polyline = BuildWalk(v);
+      MaximizeWalk(&polyline);
+      polylines.push_back(std::move(polyline));
+    }
+  }
+  S2_DCHECK_EQ(0, edges_left_);
+
+  // Sort the polylines to correspond to the input order (if possible).
+  CanonicalizeVectorOrder(min_input_ids_, &polylines);
+  return polylines;
+}
+
+Graph::EdgePolyline Graph::PolylineBuilder::BuildWalk(VertexId v) {
+  EdgePolyline polyline;
+  for (;;) {
+    // Follow the edge with the smallest input edge id.
+    EdgeId best_edge = -1;
+    InputEdgeId best_out_id = std::numeric_limits<InputEdgeId>::max();
+    for (EdgeId e : out_.edge_ids(v)) {
+      if (used_[e] || min_input_ids_[e] >= best_out_id) continue;
+      best_out_id = min_input_ids_[e];
+      best_edge = e;
+    }
+    if (best_edge < 0) return polyline;
+    // For idempotency when there are multiple input polylines, we stop the
+    // walk early if "best_edge" might be a continuation of a different
+    // incoming edge.
+    int excess = excess_degree(v) - excess_used_[v];
+    if (directed_ ? (excess < 0) : (excess % 2) == 1) {
+      for (EdgeId e : in_.edge_ids(v)) {
+        if (!used_[e] && min_input_ids_[e] <= best_out_id) {
+          return polyline;
+        }
+      }
+    }
+    polyline.push_back(best_edge);
+    used_[best_edge] = true;
+    if (!directed_) used_[sibling_map_[best_edge]] = true;
+    --edges_left_;
+    v = g_.edge(best_edge).second;
+  }
+}
+
+void Graph::PolylineBuilder::MaximizeWalk(EdgePolyline* polyline) {
+  // Examine all vertices of the polyline and check whether there are any
+  // unused outgoing edges.  If so, then build a loop starting at that vertex
+  // and insert it into the polyline.  (The walk is guaranteed to be a loop
+  // because this method is only called when all vertices have equal numbers
+  // of unused incoming and outgoing edges.)
+  for (int i = 0; i <= polyline->size(); ++i) {
+    VertexId v = (i == 0 ? g_.edge((*polyline)[i]).first
+                  : g_.edge((*polyline)[i - 1]).second);
+    for (EdgeId e : out_.edge_ids(v)) {
+      if (!used_[e]) {
+        EdgePolyline loop = BuildWalk(v);
+        S2_DCHECK_EQ(v, g_.edge(loop.back()).second);
+        polyline->insert(polyline->begin() + i, loop.begin(), loop.end());
+        S2_DCHECK(used_[e]);  // All outgoing edges from "v" are now used.
+        break;
+      }
+    }
+  }
+}
+
+class Graph::EdgeProcessor {
+ public:
+  EdgeProcessor(const GraphOptions& options,
+                vector<Edge>* edges,
+                vector<InputEdgeIdSetId>* input_ids,
+                IdSetLexicon* id_set_lexicon);
+  void Run(S2Error* error);
+
+ private:
+  void AddEdge(const Edge& edge, InputEdgeIdSetId input_edge_id_set_id);
+  void AddEdges(int num_edges, const Edge& edge,
+                InputEdgeIdSetId input_edge_id_set_id);
+  void CopyEdges(int out_begin, int out_end);
+  InputEdgeIdSetId MergeInputIds(int out_begin, int out_end);
+
+  GraphOptions options_;
+  vector<Edge>& edges_;
+  vector<InputEdgeIdSetId>& input_ids_;
+  IdSetLexicon* id_set_lexicon_;
+  vector<EdgeId> out_edges_;
+  vector<EdgeId> in_edges_;
+
+  vector<Edge> new_edges_;
+  vector<InputEdgeIdSetId> new_input_ids_;
+
+  vector<InputEdgeId> tmp_ids_;
+};
+
+void Graph::ProcessEdges(
+    GraphOptions* options, std::vector<Edge>* edges,
+    std::vector<InputEdgeIdSetId>* input_ids, IdSetLexicon* id_set_lexicon,
+    S2Error* error) {
+  EdgeProcessor processor(*options, edges, input_ids, id_set_lexicon);
+  processor.Run(error);
+  // Certain values of sibling_pairs() discard half of the edges and change
+  // the edge_type() to DIRECTED (see the description of GraphOptions).
+  if (options->sibling_pairs() == SiblingPairs::REQUIRE ||
+      options->sibling_pairs() == SiblingPairs::CREATE) {
+    options->set_edge_type(EdgeType::DIRECTED);
+  }
+}
+
+Graph::EdgeProcessor::EdgeProcessor(const GraphOptions& options,
+                                    vector<Edge>* edges,
+                                    vector<InputEdgeIdSetId>* input_ids,
+                                    IdSetLexicon* id_set_lexicon)
+    : options_(options), edges_(*edges),
+      input_ids_(*input_ids), id_set_lexicon_(id_set_lexicon),
+      out_edges_(edges_.size()), in_edges_(edges_.size()) {
+  // Sort the outgoing and incoming edges in lexigraphic order.  We use a
+  // stable sort to ensure that each undirected edge becomes a sibling pair,
+  // even if there are multiple identical input edges.
+  std::iota(out_edges_.begin(), out_edges_.end(), 0);
+  std::sort(out_edges_.begin(), out_edges_.end(), [this](EdgeId a, EdgeId b) {
+      return StableLessThan(edges_[a], edges_[b], a, b);
+    });
+  std::iota(in_edges_.begin(), in_edges_.end(), 0);
+  std::sort(in_edges_.begin(), in_edges_.end(), [this](EdgeId a, EdgeId b) {
+      return StableLessThan(reverse(edges_[a]), reverse(edges_[b]), a, b);
+    });
+  new_edges_.reserve(edges_.size());
+  new_input_ids_.reserve(edges_.size());
+}
+
+inline void Graph::EdgeProcessor::AddEdge(
+    const Edge& edge, InputEdgeIdSetId input_edge_id_set_id) {
+  new_edges_.push_back(edge);
+  new_input_ids_.push_back(input_edge_id_set_id);
+}
+
+void Graph::EdgeProcessor::AddEdges(int num_edges, const Edge& edge,
+                                    InputEdgeIdSetId input_edge_id_set_id) {
+  for (int i = 0; i < num_edges; ++i) {
+    AddEdge(edge, input_edge_id_set_id);
+  }
+}
+
+void Graph::EdgeProcessor::CopyEdges(int out_begin, int out_end) {
+  for (int i = out_begin; i < out_end; ++i) {
+    AddEdge(edges_[out_edges_[i]], input_ids_[out_edges_[i]]);
+  }
+}
+
+S2Builder::InputEdgeIdSetId Graph::EdgeProcessor::MergeInputIds(
+    int out_begin, int out_end) {
+  if (out_end - out_begin == 1) {
+    return input_ids_[out_edges_[out_begin]];
+  }
+  tmp_ids_.clear();
+  for (int i = out_begin; i < out_end; ++i) {
+    for (auto id : id_set_lexicon_->id_set(input_ids_[out_edges_[i]])) {
+      tmp_ids_.push_back(id);
+    }
+  }
+  return id_set_lexicon_->Add(tmp_ids_);
+}
+
+void Graph::EdgeProcessor::Run(S2Error* error) {
+  int num_edges = edges_.size();
+  if (num_edges == 0) return;
+
+  // Walk through the two sorted arrays performing a merge join.  For each
+  // edge, gather all the duplicate copies of the edge in both directions
+  // (outgoing and incoming).  Then decide what to do based on "options_" and
+  // how many copies of the edge there are in each direction.
+  int out = 0, in = 0;
+  const Edge* out_edge = &edges_[out_edges_[out]];
+  const Edge* in_edge = &edges_[in_edges_[in]];
+  Edge sentinel(std::numeric_limits<VertexId>::max(),
+                std::numeric_limits<VertexId>::max());
+  for (;;) {
+    Edge edge = min(*out_edge, reverse(*in_edge));
+    if (edge == sentinel) break;
+
+    int out_begin = out, in_begin = in;
+    while (*out_edge == edge) {
+      out_edge = (++out == num_edges) ? &sentinel : &edges_[out_edges_[out]];
+    }
+    while (reverse(*in_edge) == edge) {
+      in_edge = (++in == num_edges) ? &sentinel : &edges_[in_edges_[in]];
+    }
+    int n_out = out - out_begin;
+    int n_in = in - in_begin;
+    if (edge.first == edge.second) {
+      S2_DCHECK_EQ(n_out, n_in);
+      if (options_.degenerate_edges() == DegenerateEdges::DISCARD) {
+        continue;
+      }
+      if (options_.degenerate_edges() == DegenerateEdges::DISCARD_EXCESS &&
+          ((out_begin > 0 &&
+            edges_[out_edges_[out_begin - 1]].first == edge.first) ||
+           (out < num_edges && edges_[out_edges_[out]].first == edge.first) ||
+           (in_begin > 0 &&
+            edges_[in_edges_[in_begin - 1]].second == edge.first) ||
+           (in < num_edges && edges_[in_edges_[in]].second == edge.first))) {
+        continue;  // There were non-degenerate incident edges, so discard.
+      }
+      if (options_.edge_type() == EdgeType::UNDIRECTED &&
+          (options_.sibling_pairs() == SiblingPairs::REQUIRE ||
+           options_.sibling_pairs() == SiblingPairs::CREATE)) {
+        // When we have undirected edges and are guaranteed to have siblings,
+        // we cut the number of edges in half (see s2builder.h).
+        S2_DCHECK_EQ(0, n_out & 1);  // Number of edges is always even.
+        AddEdges(options_.duplicate_edges() == DuplicateEdges::MERGE ?
+                 1 : (n_out / 2), edge, MergeInputIds(out_begin, out));
+      } else if (options_.duplicate_edges() == DuplicateEdges::MERGE) {
+        AddEdges(options_.edge_type() == EdgeType::UNDIRECTED ? 2 : 1,
+                 edge, MergeInputIds(out_begin, out));
+      } else if (options_.sibling_pairs() == SiblingPairs::DISCARD ||
+                 options_.sibling_pairs() == SiblingPairs::DISCARD_EXCESS) {
+        // Any SiblingPair option that discards edges causes the labels of all
+        // duplicate edges to be merged together (see s2builder.h).
+        AddEdges(n_out, edge, MergeInputIds(out_begin, out));
+      } else {
+        CopyEdges(out_begin, out);
+      }
+    } else if (options_.sibling_pairs() == SiblingPairs::KEEP) {
+      if (n_out > 1 && options_.duplicate_edges() == DuplicateEdges::MERGE) {
+        AddEdge(edge, MergeInputIds(out_begin, out));
+      } else {
+        CopyEdges(out_begin, out);
+      }
+    } else if (options_.sibling_pairs() == SiblingPairs::DISCARD) {
+      if (options_.edge_type() == EdgeType::DIRECTED) {
+        // If n_out == n_in: balanced sibling pairs
+        // If n_out < n_in:  unbalanced siblings, in the form AB, BA, BA
+        // If n_out > n_in:  unbalanced siblings, in the form AB, AB, BA
+        if (n_out <= n_in) continue;
+        // Any option that discards edges causes the labels of all duplicate
+        // edges to be merged together (see s2builder.h).
+        AddEdges(options_.duplicate_edges() == DuplicateEdges::MERGE ?
+                 1 : (n_out - n_in), edge, MergeInputIds(out_begin, out));
+      } else {
+        if ((n_out & 1) == 0) continue;
+        AddEdge(edge, MergeInputIds(out_begin, out));
+      }
+    } else if (options_.sibling_pairs() == SiblingPairs::DISCARD_EXCESS) {
+      if (options_.edge_type() == EdgeType::DIRECTED) {
+        // See comments above.  The only difference is that if there are
+        // balanced sibling pairs, we want to keep one such pair.
+        if (n_out < n_in) continue;
+        AddEdges(options_.duplicate_edges() == DuplicateEdges::MERGE ?
+                 1 : max(1, n_out - n_in), edge, MergeInputIds(out_begin, out));
+      } else {
+        AddEdges((n_out & 1) ? 1 : 2, edge, MergeInputIds(out_begin, out));
+      }
+    } else {
+      S2_DCHECK(options_.sibling_pairs() == SiblingPairs::REQUIRE ||
+             options_.sibling_pairs() == SiblingPairs::CREATE);
+      if (error->ok() && options_.sibling_pairs() == SiblingPairs::REQUIRE &&
+          (options_.edge_type() == EdgeType::DIRECTED ? (n_out != n_in)
+                                                      : ((n_out & 1) != 0))) {
+        error->Init(S2Error::BUILDER_MISSING_EXPECTED_SIBLING_EDGES,
+                    "Expected all input edges to have siblings, "
+                    "but some were missing");
+      }
+      if (options_.duplicate_edges() == DuplicateEdges::MERGE) {
+        AddEdge(edge, MergeInputIds(out_begin, out));
+      } else if (options_.edge_type() == EdgeType::UNDIRECTED) {
+        // Convert graph to use directed edges instead (see documentation of
+        // REQUIRE/CREATE for undirected edges).
+        AddEdges((n_out + 1) / 2, edge, MergeInputIds(out_begin, out));
+      } else {
+        CopyEdges(out_begin, out);
+        if (n_in > n_out) {
+          // Automatically created edges have no input edge ids or labels.
+          AddEdges(n_in - n_out, edge, IdSetLexicon::EmptySetId());
+        }
+      }
+    }
+  }
+  edges_.swap(new_edges_);
+  edges_.shrink_to_fit();
+  input_ids_.swap(new_input_ids_);
+  input_ids_.shrink_to_fit();
+}
+
+vector<S2Point> Graph::FilterVertices(const vector<S2Point>& vertices,
+                                      std::vector<Edge>* edges,
+                                      vector<VertexId>* tmp) {
+  // Gather the vertices that are actually used.
+  vector<VertexId> used;
+  used.reserve(2 * edges->size());
+  for (const Edge& e : *edges) {
+    used.push_back(e.first);
+    used.push_back(e.second);
+  }
+  // Sort the vertices and find the distinct ones.
+  std::sort(used.begin(), used.end());
+  used.erase(std::unique(used.begin(), used.end()), used.end());
+
+  // Build the list of new vertices, and generate a map from old vertex id to
+  // new vertex id.
+  vector<VertexId>& vmap = *tmp;
+  vmap.resize(vertices.size());
+  vector<S2Point> new_vertices(used.size());
+  for (int i = 0; i < used.size(); ++i) {
+    new_vertices[i] = vertices[used[i]];
+    vmap[used[i]] = i;
+  }
+  // Update the edges.
+  for (Edge& e : *edges) {
+    e.first = vmap[e.first];
+    e.second = vmap[e.second];
+  }
+  return new_vertices;
+}