@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,87 @@
+// Copyright 2005 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+//
+// There are several notions of the "centroid" of a triangle.  First, there
+// is the planar centroid, which is simply the centroid of the ordinary
+// (non-spherical) triangle defined by the three vertices.  Second, there is
+// the surface centroid, which is defined as the intersection of the three
+// medians of the spherical triangle.  It is possible to show that this
+// point is simply the planar centroid projected to the surface of the
+// sphere.  Finally, there is the true centroid (mass centroid), which is
+// defined as the surface integral over the spherical triangle of (x,y,z)
+// divided by the triangle area.  This is the point that the triangle would
+// rotate around if it was spinning in empty space.
+//
+// The best centroid for most purposes is the true centroid.  Unlike the
+// planar and surface centroids, the true centroid behaves linearly as
+// regions are added or subtracted.  That is, if you split a triangle into
+// pieces and compute the average of their centroids (weighted by triangle
+// area), the result equals the centroid of the original triangle.  This is
+// not true of the other centroids.
+//
+// Also note that the surface centroid may be nowhere near the intuitive
+// "center" of a spherical triangle.  For example, consider the triangle
+// with vertices A=(1,eps,0), B=(0,0,1), C=(-1,eps,0) (a quarter-sphere).
+// The surface centroid of this triangle is at S=(0, 2*eps, 1), which is
+// within a distance of 2*eps of the vertex B.  Note that the median from A
+// (the segment connecting A to the midpoint of BC) passes through S, since
+// this is the shortest path connecting the two endpoints.  On the other
+// hand, the true centroid is at M=(0, 0.5, 0.5), which when projected onto
+// the surface is a much more reasonable interpretation of the "center" of
+// this triangle.
+
+#ifndef S2_S2CENTROIDS_H_
+#define S2_S2CENTROIDS_H_
+
+#include "s2/s2point.h"
+
+namespace S2 {
+
+// Returns the centroid of the planar triangle ABC.  This can be normalized to
+// unit length to obtain the "surface centroid" of the corresponding spherical
+// triangle, i.e. the intersection of the three medians.  However, note that
+// for large spherical triangles the surface centroid may be nowhere near the
+// intuitive "center" (see example above).
+S2Point PlanarCentroid(const S2Point& a, const S2Point& b, const S2Point& c);
+
+// Returns the true centroid of the spherical triangle ABC multiplied by the
+// signed area of spherical triangle ABC.  The reasons for multiplying by the
+// signed area are (1) this is the quantity that needs to be summed to compute
+// the centroid of a union or difference of triangles, and (2) it's actually
+// easier to calculate this way.  All points must have unit length.
+//
+// Note that the result of this function is defined to be S2Point(0, 0, 0) if
+// the triangle is degenerate (and that this is intended behavior).
+S2Point TrueCentroid(const S2Point& a, const S2Point& b, const S2Point& c);
+
+// Returns the true centroid of the spherical geodesic edge AB multiplied by
+// the length of the edge AB.  As with triangles, the true centroid of a
+// collection of edges may be computed simply by summing the result of this
+// method for each edge.
+//
+// Note that the planar centroid of a geodesic edge simply 0.5 * (a + b),
+// while the surface centroid is (a + b).Normalize().  However neither of
+// these values is appropriate for computing the centroid of a collection of
+// edges (such as a polyline).
+//
+// Also note that the result of this function is defined to be S2Point(0, 0, 0)
+// if the edge is degenerate (and that this is intended behavior).
+S2Point TrueCentroid(const S2Point& a, const S2Point& b);
+
+}  // namespace S2
+
+#endif  // S2_S2CENTROIDS_H_

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

@@ -0,0 +1,82 @@
+// Copyright 2005 Google Inc. All Rights Reserved.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS-IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+
+// Author: ericv@google.com (Eric Veach)
+
+#include "s2/s2centroids.h"
+
+#include <gtest/gtest.h>
+#include "s2/s2testing.h"
+
+namespace {
+
+TEST(TriangleTrueCentroid, SmallTriangles) {
+  // Test TrueCentroid() with very small triangles.  This test assumes that
+  // the triangle is small enough so that it is nearly planar.
+  for (int iter = 0; iter < 100; ++iter) {
+    Vector3_d p, x, y;
+    S2Testing::GetRandomFrame(&p, &x, &y);
+    double d = 1e-4 * pow(1e-4, S2Testing::rnd.RandDouble());
+    S2Point p0 = (p - d * x).Normalize();
+    S2Point p1 = (p + d * x).Normalize();
+    S2Point p2 = (p + 3 * d * y).Normalize();
+    S2Point centroid = S2::TrueCentroid(p0, p1, p2).Normalize();
+
+    // The centroid of a planar triangle is at the intersection of its
+    // medians, which is two-thirds of the way along each median.
+    S2Point expected_centroid = (p + d * y).Normalize();
+    EXPECT_LE(centroid.Angle(expected_centroid), 2e-8);
+  }
+}
+
+TEST(EdgeTrueCentroid, SemiEquator) {
+  // Test the centroid of polyline ABC that follows the equator and consists
+  // of two 90 degree edges (i.e., C = -A).  The centroid (multiplied by
+  // length) should point toward B and have a norm of 2.0.  (The centroid
+  // itself has a norm of 2/Pi, and the total edge length is Pi.)
+  S2Point a(0, -1, 0), b(1, 0, 0), c(0, 1, 0);
+  S2Point centroid = S2::TrueCentroid(a, b) + S2::TrueCentroid(b, c);
+  EXPECT_TRUE(S2::ApproxEquals(b, centroid.Normalize()));
+  EXPECT_DOUBLE_EQ(2.0, centroid.Norm());
+}
+
+TEST(EdgeTrueCentroid, GreatCircles) {
+  // Construct random great circles and divide them randomly into segments.
+  // Then make sure that the centroid is approximately at the center of the
+  // sphere.  Note that because of the way the centroid is computed, it does
+  // not matter how we split the great circle into segments.
+  //
+  // Note that this is a direct test of the properties that the centroid
+  // should have, rather than a test that it matches a particular formula.
+
+  for (int iter = 0; iter < 100; ++iter) {
+    // Choose a coordinate frame for the great circle.
+    S2Point x, y, z, centroid;
+    S2Testing::GetRandomFrame(&x, &y, &z);
+
+    S2Point v0 = x;
+    for (double theta = 0; theta < 2 * M_PI;
+         theta += pow(S2Testing::rnd.RandDouble(), 10)) {
+      S2Point v1 = cos(theta) * x + sin(theta) * y;
+      centroid += S2::TrueCentroid(v0, v1);
+      v0 = v1;
+    }
+    // Close the circle.
+    centroid += S2::TrueCentroid(v0, x);
+    EXPECT_LE(centroid.Norm(), 2e-14);
+  }
+}
+
+}  // namespace

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

@@ -0,0 +1,123 @@
+// 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/s2closest_cell_query.h"
+
+#include <memory>
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/s1angle.h"
+#include "s2/s2cap.h"
+#include "s2/s2cell.h"
+#include "s2/s2cell_id.h"
+#include "s2/s2cell_union.h"
+#include "s2/s2edge_distances.h"
+#include "s2/s2region_coverer.h"
+#include "s2/s2shape_index_region.h"
+
+void S2ClosestCellQuery::Options::set_conservative_max_distance(
+    S1ChordAngle max_distance) {
+  set_max_distance(Distance(max_distance.PlusError(
+      S2::GetUpdateMinDistanceMaxError(max_distance)).Successor()));
+}
+
+void S2ClosestCellQuery::Options::set_conservative_max_distance(
+    S1Angle max_distance) {
+  set_conservative_max_distance(S1ChordAngle(max_distance));
+}
+
+// The thresholds for using the brute force algorithm are generally tuned to
+// optimize IsDistanceLess (which compares the distance against a threshold)
+// rather than FindClosest (which actually computes the minimum distance).
+// This is because the former operation is (1) more common, (2) inherently
+// faster, and (3) closely related to finding all cells within a given
+// distance, which is also very common.
+
+int S2ClosestCellQuery::PointTarget::max_brute_force_index_size() const {
+  // Break-even points:                   Point cloud      Cap coverings
+  // BM_FindClosest                                18                 16
+  // BM_IsDistanceLess                              8                  9
+  return 9;
+}
+
+int S2ClosestCellQuery::EdgeTarget::max_brute_force_index_size() const {
+  // Break-even points:                   Point cloud      Cap coverings
+  // BM_FindClosestToLongEdge                      14                 16
+  // BM_IsDistanceLessToLongEdge                    5                  5
+  return 5;
+}
+
+int S2ClosestCellQuery::CellTarget::max_brute_force_index_size() const {
+  // Break-even points:                   Point cloud      Cap coverings
+  // BM_FindClosestToSmallCell                     12                 13
+  // BM_IsDistanceLessToSmallCell                   6                  6
+  //
+  // Note that the primary use of CellTarget is to implement CellUnionTarget,
+  // and therefore it is very important to optimize for the case where a
+  // distance limit has been specified.
+  return 6;
+}
+
+int S2ClosestCellQuery::CellUnionTarget::max_brute_force_index_size() const {
+  // Break-even points:                   Point cloud      Cap coverings
+  // BM_FindClosestToSmallCoarseCellUnion          12                 10
+  // BM_IsDistanceLessToSmallCoarseCellUnion        7                  6
+  return 8;
+}
+
+int S2ClosestCellQuery::ShapeIndexTarget::max_brute_force_index_size() const {
+  // Break-even points:                   Point cloud      Cap coverings
+  // BM_FindClosestToSmallCoarseShapeIndex         10                  8
+  // BM_IsDistanceLessToSmallCoarseShapeIndex       7                  6
+  return 7;
+}
+
+S2ClosestCellQuery::S2ClosestCellQuery() {
+  // Prevent inline constructor bloat by defining here.
+}
+
+S2ClosestCellQuery::~S2ClosestCellQuery() {
+  // Prevent inline destructor bloat by defining here.
+}
+
+bool S2ClosestCellQuery::IsDistanceLess(Target* target, S1ChordAngle limit) {
+  static_assert(sizeof(Options) <= 32, "Consider not copying Options here");
+  Options tmp_options = options_;
+  tmp_options.set_max_results(1);
+  tmp_options.set_max_distance(limit);
+  tmp_options.set_max_error(S1ChordAngle::Straight());
+  return !base_.FindClosestCell(target, tmp_options).is_empty();
+}
+
+bool S2ClosestCellQuery::IsDistanceLessOrEqual(Target* target,
+                                               S1ChordAngle limit) {
+  static_assert(sizeof(Options) <= 32, "Consider not copying Options here");
+  Options tmp_options = options_;
+  tmp_options.set_max_results(1);
+  tmp_options.set_inclusive_max_distance(limit);
+  tmp_options.set_max_error(S1ChordAngle::Straight());
+  return !base_.FindClosestCell(target, tmp_options).is_empty();
+}
+
+bool S2ClosestCellQuery::IsConservativeDistanceLessOrEqual(
+    Target* target, S1ChordAngle limit) {
+  static_assert(sizeof(Options) <= 32, "Consider not copying Options here");
+  Options tmp_options = options_;
+  tmp_options.set_max_results(1);
+  tmp_options.set_conservative_max_distance(limit);
+  tmp_options.set_max_error(S1ChordAngle::Straight());
+  return !base_.FindClosestCell(target, tmp_options).is_empty();
+}

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

@@ -0,0 +1,385 @@
+// 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)
+
+#ifndef S2_S2CLOSEST_CELL_QUERY_H_
+#define S2_S2CLOSEST_CELL_QUERY_H_
+
+#include <vector>
+
+#include "s2/base/logging.h"
+#include "s2/_fp_contract_off.h"
+#include "s2/s1angle.h"
+#include "s2/s1chord_angle.h"
+#include "s2/s2cell.h"
+#include "s2/s2cell_id.h"
+#include "s2/s2closest_cell_query_base.h"
+#include "s2/s2min_distance_targets.h"
+
+// S2ClosestCellQuery is a helper class for finding the closest cell(s) to a
+// given point, edge, S2Cell, S2CellUnion, or geometry collection.  A typical
+// use case would be to add a collection of S2Cell coverings to an S2CellIndex
+// (representing a collection of original geometry), and then use
+// S2ClosestCellQuery to find all coverings that are within a given distance
+// of some target geometry (which could be represented exactly, or could also
+// be a covering).  The distance to the original geometry corresponding to
+// each covering could then be measured more precisely if desired.
+//
+// For example, here is how to find all cells that are closer than
+// "distance_limit" to a given target point:
+//
+//   S2ClosestCellQuery query(&cell_index);
+//   query.mutable_options()->set_max_distance(distance_limit);
+//   S2ClosestCellQuery::PointTarget target(target_point);
+//   for (const auto& result : query.FindClosestCells(&target)) {
+//     // result.distance() is the distance to the target.
+//     // result.cell_id() is the indexed S2CellId.
+//     // result.label() is the integer label associated with the S2CellId.
+//     DoSomething(target_point, result);
+//   }
+//
+// You can find either the k closest cells, or all cells within a given
+// radius, or both (i.e., the k closest cells up to a given maximum radius).
+// By default *all* cells are returned, so you should always specify either
+// max_results() or max_distance() or both.  You can also restrict the results
+// to cells that intersect a given S2Region; for example:
+//
+//   S2LatLngRect rect(...);
+//   query.mutable_options()->set_region(&rect);  // Does *not* take ownership.
+//
+// There is a FindClosestCell() convenience method that returns the closest
+// cell.  However, if you only need to test whether the distance is above or
+// below a given threshold (e.g., 10 km), it is typically much faster to use
+// the IsDistanceLess() method instead.  Unlike FindClosestCell(), this method
+// stops as soon as it can prove that the minimum distance is either above or
+// below the threshold.  Example usage:
+//
+//   if (query.IsDistanceLess(&target, limit_distance)) ...
+//
+// To find the closest cells to a query edge rather than a point, use:
+//
+//   S2ClosestCellQuery::EdgeTarget target(v0, v1);
+//   query.FindClosestCells(&target);
+//
+// Similarly you can find the closest cells to an S2Cell using an
+// S2ClosestCellQuery::CellTarget, you can find the closest cells to an
+// S2CellUnion using an S2ClosestCellQuery::CellUnionTarget, and you can find
+// the closest cells to an arbitrary collection of points, polylines, and
+// polygons by using an S2ClosestCellQuery::ShapeIndexTarget.
+//
+// The implementation is designed to be fast for both simple and complex
+// geometric objects.
+class S2ClosestCellQuery {
+ public:
+  // See S2ClosestCellQueryBase for full documentation.
+
+  // S2MinDistance is a thin wrapper around S1ChordAngle that implements the
+  // Distance concept required by S2ClosestCellQueryBase.
+  using Distance = S2MinDistance;
+  using Base = S2ClosestCellQueryBase<Distance>;
+
+  // Each "Result" object represents a closest (s2cell_id, label) pair.  Here
+  // are its main methods (see S2ClosestCellQueryBase::Result for details):
+  //
+  //   // The distance from the target to this point.
+  //   S1ChordAngle distance() const;
+  //
+  //   // The S2CellId itself.
+  //   S2CellId cell_id() const;
+  //
+  //   // The label associated with this S2CellId.
+  //   const Label& label() const;
+  using Result = Base::Result;
+
+  // Options that control the set of cells returned.  Note that by default
+  // *all* cells are returned, so you will always want to set either the
+  // max_results() option or the max_distance() option (or both).
+  class Options : public Base::Options {
+   public:
+    // See S2ClosestCellQueryBase::Options for the full set of options.
+
+    // Specifies that only cells whose distance to the target is less than
+    // "max_distance" should be returned.
+    //
+    // Note that cells whose distance is exactly equal to "max_distance" are
+    // not returned.  Normally this doesn't matter, because distances are not
+    // computed exactly in the first place, but if such cells are needed then
+    // see set_inclusive_max_distance() below.
+    //
+    // DEFAULT: Distance::Infinity()
+    void set_max_distance(S1ChordAngle max_distance);
+
+    // Like set_max_distance(), except that cells whose distance is exactly
+    // equal to "max_distance" are also returned.  Equivalent to calling
+    // set_max_distance(max_distance.Successor()).
+    void set_inclusive_max_distance(S1ChordAngle max_distance);
+
+    // Like set_inclusive_max_distance(), except that "max_distance" is also
+    // increased by the maximum error in the distance calculation.  This
+    // ensures that all cells whose true distance is less than or equal to
+    // "max_distance" will be returned (along with some cells whose true
+    // distance is slightly greater).
+    //
+    // Algorithms that need to do exact distance comparisons can use this
+    // option to find a set of candidate cells that can then be filtered
+    // further (e.g., using s2pred::CompareDistance).
+    void set_conservative_max_distance(S1ChordAngle max_distance);
+
+    // Versions of set_max_distance that take an S1Angle argument.  (Note that
+    // these functions require a conversion, and that the S1ChordAngle versions
+    // are preferred.)
+    void set_max_distance(S1Angle max_distance);
+    void set_inclusive_max_distance(S1Angle max_distance);
+    void set_conservative_max_distance(S1Angle max_distance);
+
+    // See S2ClosestCellQueryBase::Options for documentation.
+    using Base::Options::set_max_error;     // S1Chordangle version
+    void set_max_error(S1Angle max_error);  // S1Angle version
+
+    // Inherited options (see s2closest_cell_query_base.h for details):
+    using Base::Options::set_max_results;
+    using Base::Options::set_region;
+    using Base::Options::set_use_brute_force;
+  };
+
+  // "Target" represents the geometry to which the distance is measured.
+  // There are subtypes for measuring the distance to a point, an edge, an
+  // S2Cell, or an S2ShapeIndex (an arbitrary collection of geometry).
+  using Target = S2MinDistanceTarget;
+
+  // Target subtype that computes the closest distance to a point.
+  class PointTarget final : public S2MinDistancePointTarget {
+   public:
+    explicit PointTarget(const S2Point& point);
+    int max_brute_force_index_size() const override;
+  };
+
+  // Target subtype that computes the closest distance to an edge.
+  class EdgeTarget final : public S2MinDistanceEdgeTarget {
+   public:
+    explicit EdgeTarget(const S2Point& a, const S2Point& b);
+    int max_brute_force_index_size() const override;
+  };
+
+  // Target subtype that computes the closest distance to an S2Cell
+  // (including the interior of the cell).
+  class CellTarget final : public S2MinDistanceCellTarget {
+   public:
+    explicit CellTarget(const S2Cell& cell);
+    int max_brute_force_index_size() const override;
+  };
+
+  // Target subtype that computes the closest distance to an S2CellUnion.
+  class CellUnionTarget final : public S2MinDistanceCellUnionTarget {
+   public:
+    explicit CellUnionTarget(S2CellUnion cell_union);
+    int max_brute_force_index_size() const override;
+  };
+
+  // Target subtype that computes the closest distance to an S2ShapeIndex
+  // (an arbitrary collection of points, polylines, and/or polygons).
+  //
+  // By default, distances are measured to the boundary and interior of
+  // polygons in the S2ShapeIndex rather than to polygon boundaries only.
+  // If you wish to change this behavior, you may call
+  //
+  //   target.set_include_interiors(false);
+  //
+  // (see S2MinDistanceShapeIndexTarget for details).
+  class ShapeIndexTarget final : public S2MinDistanceShapeIndexTarget {
+   public:
+    explicit ShapeIndexTarget(const S2ShapeIndex* index);
+    int max_brute_force_index_size() const override;
+  };
+
+  // Convenience constructor that calls Init().  Options may be specified here
+  // or changed at any time using the mutable_options() accessor method.
+  //
+  // REQUIRES: "index" must persist for the lifetime of this object.
+  // REQUIRES: ReInit() must be called if "index" is modified.
+  explicit S2ClosestCellQuery(const S2CellIndex* index,
+                              const Options& options = Options());
+
+  // Default constructor; requires Init() to be called.
+  S2ClosestCellQuery();
+  ~S2ClosestCellQuery();
+
+  // Initializes the query.  Options may be specified here or changed at any
+  // time using the mutable_options() accessor method.
+  //
+  // REQUIRES: "index" must persist for the lifetime of this object.
+  // REQUIRES: ReInit() must be called if "index" is modified.
+  void Init(const S2CellIndex* index, const Options& options = Options());
+
+  // Reinitializes the query.  This method must be called if the underlying
+  // S2CellIndex is modified (by calling Clear() and Build() again).
+  void ReInit();
+
+  // Returns a reference to the underlying S2CellIndex.
+  const S2CellIndex& index() const;
+
+  // Returns the query options.  Options can be modified between queries.
+  const Options& options() const;
+  Options* mutable_options();
+
+  // Returns the closest cells to the given target that satisfy the current
+  // options.  This method may be called multiple times.
+  std::vector<Result> FindClosestCells(Target* target);
+
+  // This version can be more efficient when this method is called many times,
+  // since it does not require allocating a new vector on each call.
+  void FindClosestCells(Target* target, std::vector<Result>* results);
+
+  //////////////////////// Convenience Methods ////////////////////////
+
+  // Returns the closest cell to the target.  If no cell satisfies the search
+  // criteria, then the Result object will have distance == Infinity() and
+  // is_empty() == true.
+  Result FindClosestCell(Target* target);
+
+  // Returns the minimum distance to the target.  If the index or target is
+  // empty, returns S1ChordAngle::Infinity().
+  //
+  // Use IsDistanceLess() if you only want to compare the distance against a
+  // threshold value, since it is often much faster.
+  S1ChordAngle GetDistance(Target* target);
+
+  // Returns true if the distance to "target" is less than "limit".
+  //
+  // This method is usually much faster than GetDistance(), since it is much
+  // less work to determine whether the minimum distance is above or below a
+  // threshold than it is to calculate the actual minimum distance.
+  bool IsDistanceLess(Target* target, S1ChordAngle limit);
+
+  // Like IsDistanceLess(), but also returns true if the distance to "target"
+  // is exactly equal to "limit".
+  bool IsDistanceLessOrEqual(Target* target, S1ChordAngle limit);
+
+  // Like IsDistanceLessOrEqual(), except that "limit" is increased by the
+  // maximum error in the distance calculation.  This ensures that this
+  // function returns true whenever the true, exact distance is less than
+  // or equal to "limit".
+  bool IsConservativeDistanceLessOrEqual(Target* target, S1ChordAngle limit);
+
+ private:
+  Options options_;
+  Base base_;
+
+  S2ClosestCellQuery(const S2ClosestCellQuery&) = delete;
+  void operator=(const S2ClosestCellQuery&) = delete;
+};
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+inline void S2ClosestCellQuery::Options::set_max_distance(
+    S1ChordAngle max_distance) {
+  Base::Options::set_max_distance(Distance(max_distance));
+}
+
+inline void S2ClosestCellQuery::Options::set_max_distance(
+    S1Angle max_distance) {
+  Base::Options::set_max_distance(Distance(max_distance));
+}
+
+inline void S2ClosestCellQuery::Options::set_inclusive_max_distance(
+    S1ChordAngle max_distance) {
+  set_max_distance(max_distance.Successor());
+}
+
+inline void S2ClosestCellQuery::Options::set_inclusive_max_distance(
+    S1Angle max_distance) {
+  set_inclusive_max_distance(S1ChordAngle(max_distance));
+}
+
+inline void S2ClosestCellQuery::Options::set_max_error(S1Angle max_error) {
+  Base::Options::set_max_error(S1ChordAngle(max_error));
+}
+
+inline S2ClosestCellQuery::PointTarget::PointTarget(const S2Point& point)
+    : S2MinDistancePointTarget(point) {
+}
+
+inline S2ClosestCellQuery::EdgeTarget::EdgeTarget(const S2Point& a,
+                                                  const S2Point& b)
+    : S2MinDistanceEdgeTarget(a, b) {
+}
+
+inline S2ClosestCellQuery::CellTarget::CellTarget(const S2Cell& cell)
+    : S2MinDistanceCellTarget(cell) {
+}
+
+inline S2ClosestCellQuery::CellUnionTarget::CellUnionTarget(
+    S2CellUnion cell_union)
+    : S2MinDistanceCellUnionTarget(std::move(cell_union)) {
+}
+
+inline S2ClosestCellQuery::ShapeIndexTarget::ShapeIndexTarget(
+    const S2ShapeIndex* index)
+    : S2MinDistanceShapeIndexTarget(index) {
+}
+
+inline S2ClosestCellQuery::S2ClosestCellQuery(const S2CellIndex* index,
+                                              const Options& options) {
+  Init(index, options);
+}
+
+inline void S2ClosestCellQuery::Init(const S2CellIndex* index,
+                                     const Options& options) {
+  options_ = options;
+  base_.Init(index);
+}
+
+inline void S2ClosestCellQuery::ReInit() {
+  base_.ReInit();
+}
+
+inline const S2CellIndex& S2ClosestCellQuery::index() const {
+  return base_.index();
+}
+
+inline const S2ClosestCellQuery::Options& S2ClosestCellQuery::options() const {
+  return options_;
+}
+
+inline S2ClosestCellQuery::Options* S2ClosestCellQuery::mutable_options() {
+  return &options_;
+}
+
+inline std::vector<S2ClosestCellQuery::Result>
+S2ClosestCellQuery::FindClosestCells(Target* target) {
+  return base_.FindClosestCells(target, options_);
+}
+
+inline void S2ClosestCellQuery::FindClosestCells(Target* target,
+                                                 std::vector<Result>* results) {
+  base_.FindClosestCells(target, options_, results);
+}
+
+inline S2ClosestCellQuery::Result S2ClosestCellQuery::FindClosestCell(
+    Target* target) {
+  static_assert(sizeof(Options) <= 32, "Consider not copying Options here");
+  Options tmp_options = options_;
+  tmp_options.set_max_results(1);
+  return base_.FindClosestCell(target, tmp_options);
+}
+
+inline S1ChordAngle S2ClosestCellQuery::GetDistance(Target* target) {
+  return FindClosestCell(target).distance();
+}
+
+#endif  // S2_S2CLOSEST_CELL_QUERY_H_