@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,135 @@
+// 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/s2measures.h"
+
+#include <cmath>
+
+#include <gtest/gtest.h>
+#include "s2/s2latlng.h"
+#include "s2/s2testing.h"
+
+using std::fabs;
+
+TEST(S2, AngleMethods) {
+  S2Point pz(0, 0, 1);
+  S2Point p000(1, 0, 0);
+  S2Point p045 = S2Point(1, 1, 0).Normalize();
+  S2Point p090(0, 1, 0);
+  S2Point p180(-1, 0, 0);
+
+  EXPECT_DOUBLE_EQ(S2::Angle(p000, pz, p045), M_PI_4);
+  EXPECT_DOUBLE_EQ(S2::TurnAngle(p000, pz, p045), -3 * M_PI_4);
+
+  EXPECT_DOUBLE_EQ(S2::Angle(p045, pz, p180), 3 * M_PI_4);
+  EXPECT_DOUBLE_EQ(S2::TurnAngle(p045, pz, p180), -M_PI_4);
+
+  EXPECT_DOUBLE_EQ(S2::Angle(p000, pz, p180), M_PI);
+  EXPECT_DOUBLE_EQ(S2::TurnAngle(p000, pz, p180), 0);
+
+  EXPECT_DOUBLE_EQ(S2::Angle(pz, p000, p045), M_PI_2);
+  EXPECT_DOUBLE_EQ(S2::TurnAngle(pz, p000, p045), M_PI_2);
+
+  EXPECT_DOUBLE_EQ(S2::Angle(pz, p000, pz), 0);
+  EXPECT_DOUBLE_EQ(fabs(S2::TurnAngle(pz, p000, pz)), M_PI);
+}
+
+TEST(S2, AreaMethods) {
+  S2Point pz(0, 0, 1);
+  S2Point p000(1, 0, 0);
+  S2Point p045 = S2Point(1, 1, 0).Normalize();
+  S2Point p090(0, 1, 0);
+  S2Point p180(-1, 0, 0);
+
+  EXPECT_DOUBLE_EQ(S2::Area(p000, p090, pz), M_PI_2);
+  EXPECT_DOUBLE_EQ(S2::Area(p045, pz, p180), 3 * M_PI_4);
+
+  // Make sure that Area() has good *relative* accuracy even for
+  // very small areas.
+  static const double eps = 1e-10;
+  S2Point pepsx = S2Point(eps, 0, 1).Normalize();
+  S2Point pepsy = S2Point(0, eps, 1).Normalize();
+  double expected1 = 0.5 * eps * eps;
+  EXPECT_NEAR(S2::Area(pepsx, pepsy, pz), expected1, 1e-14 * expected1);
+
+  // Make sure that it can handle degenerate triangles.
+  S2Point pr = S2Point(0.257, -0.5723, 0.112).Normalize();
+  S2Point pq = S2Point(-0.747, 0.401, 0.2235).Normalize();
+  EXPECT_EQ(S2::Area(pr, pr, pr), 0);
+  // The following test is not exact due to rounding error.
+  EXPECT_NEAR(S2::Area(pr, pq, pr), 0, 1e-15);
+  EXPECT_EQ(S2::Area(p000, p045, p090), 0);
+
+  double max_girard = 0;
+  for (int i = 0; i < 10000; ++i) {
+    S2Point p0 = S2Testing::RandomPoint();
+    S2Point d1 = S2Testing::RandomPoint();
+    S2Point d2 = S2Testing::RandomPoint();
+    S2Point p1 = (p0 + 1e-15 * d1).Normalize();
+    S2Point p2 = (p0 + 1e-15 * d2).Normalize();
+    // The actual displacement can be as much as 1.2e-15 due to roundoff.
+    // This yields a maximum triangle area of about 0.7e-30.
+    EXPECT_LE(S2::Area(p0, p1, p2), 0.7e-30);
+    max_girard = std::max(max_girard, S2::GirardArea(p0, p1, p2));
+  }
+  // This check only passes if GirardArea() uses RobustCrossProd().
+  S2_LOG(INFO) << "Worst case Girard for triangle area 1e-30: " << max_girard;
+  EXPECT_LE(max_girard, 1e-14);
+
+  // Try a very long and skinny triangle.
+  S2Point p045eps = S2Point(1, 1, eps).Normalize();
+  double expected2 = 5.8578643762690495119753e-11;  // Mathematica.
+  EXPECT_NEAR(S2::Area(p000, p045eps, p090), expected2, 1e-9 * expected2);
+
+  // Triangles with near-180 degree edges that sum to a quarter-sphere.
+  static const double eps2 = 1e-14;
+  S2Point p000eps2 = S2Point(1, 0.1*eps2, eps2).Normalize();
+  double quarter_area1 = S2::Area(p000eps2, p000, p045) +
+                         S2::Area(p000eps2, p045, p180) +
+                         S2::Area(p000eps2, p180, pz) +
+                         S2::Area(p000eps2, pz, p000);
+  EXPECT_DOUBLE_EQ(quarter_area1, M_PI);
+
+  // Four other triangles that sum to a quarter-sphere.
+  S2Point p045eps2 = S2Point(1, 1, eps2).Normalize();
+  double quarter_area2 = S2::Area(p045eps2, p000, p045) +
+                         S2::Area(p045eps2, p045, p180) +
+                         S2::Area(p045eps2, p180, pz) +
+                         S2::Area(p045eps2, pz, p000);
+  EXPECT_DOUBLE_EQ(quarter_area2, M_PI);
+
+  // Compute the area of a hemisphere using four triangles with one near-180
+  // degree edge and one near-degenerate edge.
+  for (int i = 0; i < 100; ++i) {
+    double lng = 2 * M_PI * S2Testing::rnd.RandDouble();
+    S2Point p0 = S2LatLng::FromRadians(1e-20, lng).Normalized().ToPoint();
+    S2Point p1 = S2LatLng::FromRadians(0, lng).Normalized().ToPoint();
+    double p2_lng = lng + S2Testing::rnd.RandDouble();
+    S2Point p2 = S2LatLng::FromRadians(0, p2_lng).Normalized().ToPoint();
+    S2Point p3 = S2LatLng::FromRadians(0, lng + M_PI).Normalized().ToPoint();
+    S2Point p4 = S2LatLng::FromRadians(0, lng + 5.0).Normalized().ToPoint();
+    double area = (S2::Area(p0, p1, p2) + S2::Area(p0, p2, p3) +
+                   S2::Area(p0, p3, p4) + S2::Area(p0, p4, p1));
+    EXPECT_NEAR(area, 2 * M_PI, 2e-15);
+  }
+
+  // This tests a case where the triangle has zero area, but S2::Area()
+  // computes (dmin > 0) due to rounding errors.
+  EXPECT_EQ(0.0, S2::Area(S2LatLng::FromDegrees(-45, -170).ToPoint(),
+                          S2LatLng::FromDegrees(45, -170).ToPoint(),
+                          S2LatLng::FromDegrees(0, -170).ToPoint()));
+}

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

@@ -0,0 +1,122 @@
+// 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)
+//
+// All of the values below were obtained by a combination of hand analysis and
+// Mathematica.  In general, S2_TAN_PROJECTION produces the most uniform
+// shapes and sizes of cells, S2_LINEAR_PROJECTION is considerably worse, and
+// S2_QUADRATIC_PROJECTION is somewhere in between (but generally closer to
+// the tangent projection than the linear one).
+//
+// Note that S2_LINEAR_PROJECTION can be useful for analysis even when another
+// projection is being used, since it allows many cell metrics to be bounded
+// in terms of (u,v) coordinates rather than (s,t) coordinates.  (With the
+// linear projection, u = 2 * s - 1 and similarly for v.)  Similarly,
+// S2_TAN_PROJECTION allows cell metrics to be bounded in terms of (u,v)
+// coordinate changes when they are measured as distances on the unit sphere.
+
+#include "s2/s2metrics.h"
+
+namespace S2 {
+
+const LengthMetric kMinAngleSpan(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? 1.0 :                      // 1.000
+    S2_PROJECTION == S2_TAN_PROJECTION ? M_PI / 2 :                    // 1.571
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 4. / 3 :                // 1.333
+    0);
+
+const LengthMetric kMaxAngleSpan(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? 2 :                        // 2.000
+    S2_PROJECTION == S2_TAN_PROJECTION ? M_PI / 2 :                    // 1.571
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 1.704897179199218452 :  // 1.705
+    0);
+
+const LengthMetric kAvgAngleSpan(M_PI / 2);                    // 1.571
+// This is true for all projections.
+
+const LengthMetric kMinWidth(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? sqrt(2. / 3) :             // 0.816
+    S2_PROJECTION == S2_TAN_PROJECTION ? M_PI / (2 * sqrt(2)) :        // 1.111
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 2 * sqrt(2) / 3 :       // 0.943
+    0);
+
+const LengthMetric kMaxWidth(kMaxAngleSpan.deriv());
+// This is true for all projections.
+
+const LengthMetric kAvgWidth(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? 1.411459345844456965 :     // 1.411
+    S2_PROJECTION == S2_TAN_PROJECTION ? 1.437318638925160885 :        // 1.437
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 1.434523672886099389 :  // 1.435
+    0);
+
+const LengthMetric kMinEdge(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? 2 * sqrt(2) / 3 :          // 0.943
+    S2_PROJECTION == S2_TAN_PROJECTION ? M_PI / (2 * sqrt(2)) :        // 1.111
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 2 * sqrt(2) / 3 :       // 0.943
+    0);
+
+const LengthMetric kMaxEdge(kMaxAngleSpan.deriv());
+// This is true for all projections.
+
+const LengthMetric kAvgEdge(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? 1.440034192955603643 :     // 1.440
+    S2_PROJECTION == S2_TAN_PROJECTION ? 1.461667032546739266 :        // 1.462
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 1.459213746386106062 :  // 1.459
+    0);
+
+const LengthMetric kMinDiag(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? 2 * sqrt(2) / 3 :          // 0.943
+    S2_PROJECTION == S2_TAN_PROJECTION ? M_PI * sqrt(2) / 3 :          // 1.481
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 8 * sqrt(2) / 9 :       // 1.257
+    0);
+
+const LengthMetric kMaxDiag(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? 2 * sqrt(2) :              // 2.828
+    S2_PROJECTION == S2_TAN_PROJECTION ? M_PI * sqrt(2. / 3) :         // 2.565
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 2.438654594434021032 :  // 2.439
+    0);
+
+const LengthMetric kAvgDiag(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? 2.031817866418812674 :     // 2.032
+    S2_PROJECTION == S2_TAN_PROJECTION ? 2.063623197195635753 :        // 2.064
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 2.060422738998471683 :  // 2.060
+    0);
+
+const AreaMetric kMinArea(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? 4 / (3 * sqrt(3)) :        // 0.770
+    S2_PROJECTION == S2_TAN_PROJECTION ? (M_PI*M_PI) / (4*sqrt(2)) :   // 1.745
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 8 * sqrt(2) / 9 :       // 1.257
+    0);
+
+const AreaMetric kMaxArea(
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? 4 :                        // 4.000
+    S2_PROJECTION == S2_TAN_PROJECTION ? M_PI * M_PI / 4 :             // 2.467
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 2.635799256963161491 :  // 2.636
+    0);
+
+const AreaMetric kAvgArea(4 * M_PI / 6);                       // 2.094
+// This is true for all projections.
+
+const double kMaxEdgeAspect = (
+    S2_PROJECTION == S2_LINEAR_PROJECTION ? sqrt(2) :                  // 1.414
+    S2_PROJECTION == S2_TAN_PROJECTION ?  sqrt(2) :                    // 1.414
+    S2_PROJECTION == S2_QUADRATIC_PROJECTION ? 1.442615274452682920 :  // 1.443
+    0);
+
+const double kMaxDiagAspect = sqrt(3);                             // 1.732
+// This is true for all projections.
+
+}  // namespace S2

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

@@ -0,0 +1,199 @@
+// 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)
+//
+// The following are various constants that describe the shapes and sizes of
+// S2Cells (see s2coords.h and s2cell_id.h).  They are useful for deciding
+// which cell level to use in order to satisfy a given condition (e.g. that
+// cell vertices must be no further than "x" apart).  All of the raw constants
+// are differential quantities; you can use the GetValue(level) method to
+// compute the corresponding length or area on the unit sphere for cells at a
+// given level.  The minimum and maximum bounds are valid for cells at all
+// levels, but they may be somewhat conservative for very large cells
+// (e.g. face cells).
+
+#ifndef S2_S2METRICS_H_
+#define S2_S2METRICS_H_
+
+#include <algorithm>
+#include <cmath>
+
+#include "s2/s2coords.h"
+#include "s2/util/math/mathutil.h"
+
+namespace S2 {
+
+// Defines a cell metric of the given dimension (1 == length, 2 == area).
+template <int dim> class Metric {
+ public:
+  explicit constexpr Metric(double deriv) : deriv_(deriv) {}
+
+  // The "deriv" value of a metric is a derivative, and must be multiplied by
+  // a length or area in (s,t)-space to get a useful value.
+  double deriv() const { return deriv_; }
+
+  // Return the value of a metric for cells at the given level. The value is
+  // either a length or an area on the unit sphere, depending on the
+  // particular metric.
+  double GetValue(int level) const { return ldexp(deriv_, - dim * level); }
+
+  // Return the level at which the metric has approximately the given
+  // value.  For example, S2::kAvgEdge.GetClosestLevel(0.1) returns the
+  // level at which the average cell edge length is approximately 0.1.
+  // The return value is always a valid level.
+  int GetClosestLevel(double value) const;
+
+  // Return the minimum level such that the metric is at most the given
+  // value, or S2CellId::kMaxLevel if there is no such level.  For example,
+  // S2::kMaxDiag.GetLevelForMaxValue(0.1) returns the minimum level such
+  // that all cell diagonal lengths are 0.1 or smaller.  The return value
+  // is always a valid level.
+  int GetLevelForMaxValue(double value) const;
+
+  // Return the maximum level such that the metric is at least the given
+  // value, or zero if there is no such level.  For example,
+  // S2::kMinWidth.GetLevelForMinValue(0.1) returns the maximum level such
+  // that all cells have a minimum width of 0.1 or larger.  The return value
+  // is always a valid level.
+  int GetLevelForMinValue(double value) const;
+
+ private:
+  const double deriv_;
+
+  Metric(const Metric&) = delete;
+  void operator=(const Metric&) = delete;
+};
+using LengthMetric = Metric<1>;
+using AreaMetric = Metric<2>;
+
+// Each cell is bounded by four planes passing through its four edges and
+// the center of the sphere.  These metrics relate to the angle between each
+// pair of opposite bounding planes, or equivalently, between the planes
+// corresponding to two different s-values or two different t-values.  For
+// example, the maximum angle between opposite bounding planes for a cell at
+// level k is kMaxAngleSpan.GetValue(k), and the average angle span for all
+// cells at level k is approximately kAvgAngleSpan.GetValue(k).
+extern const LengthMetric kMinAngleSpan;
+extern const LengthMetric kMaxAngleSpan;
+extern const LengthMetric kAvgAngleSpan;
+
+// The width of geometric figure is defined as the distance between two
+// parallel bounding lines in a given direction.  For cells, the minimum
+// width is always attained between two opposite edges, and the maximum
+// width is attained between two opposite vertices.  However, for our
+// purposes we redefine the width of a cell as the perpendicular distance
+// between a pair of opposite edges.  A cell therefore has two widths, one
+// in each direction.  The minimum width according to this definition agrees
+// with the classic geometric one, but the maximum width is different.  (The
+// maximum geometric width corresponds to kMaxDiag defined below.)
+//
+// For a cell at level k, the distance between opposite edges is at least
+// kMinWidth.GetValue(k) and at most kMaxWidth.GetValue(k).  The average
+// width in both directions for all cells at level k is approximately
+// kAvgWidth.GetValue(k).
+//
+// The width is useful for bounding the minimum or maximum distance from a
+// point on one edge of a cell to the closest point on the opposite edge.
+// For example, this is useful when "growing" regions by a fixed distance.
+//
+// Note that because S2Cells are not usually rectangles, the minimum width of
+// a cell is generally smaller than its minimum edge length.  (The interior
+// angles of an S2Cell range from 60 to 120 degrees.)
+extern const LengthMetric kMinWidth;
+extern const LengthMetric kMaxWidth;
+extern const LengthMetric kAvgWidth;
+
+// The minimum edge length of any cell at level k is at least
+// kMinEdge.GetValue(k), and the maximum is at most kMaxEdge.GetValue(k).
+// The average edge length is approximately kAvgEdge.GetValue(k).
+//
+// The edge length metrics can also be used to bound the minimum, maximum,
+// or average distance from the center of one cell to the center of one of
+// its edge neighbors.  In particular, it can be used to bound the distance
+// between adjacent cell centers along the space-filling Hilbert curve for
+// cells at any given level.
+extern const LengthMetric kMinEdge;
+extern const LengthMetric kMaxEdge;
+extern const LengthMetric kAvgEdge;
+
+// The minimum diagonal length of any cell at level k is at least
+// kMinDiag.GetValue(k), and the maximum is at most kMaxDiag.GetValue(k).
+// The average diagonal length is approximately kAvgDiag.GetValue(k).
+//
+// The maximum diagonal also happens to be the maximum diameter of any cell,
+// and also the maximum geometric width (see the discussion above).  So for
+// example, the distance from an arbitrary point to the closest cell center
+// at a given level is at most half the maximum diagonal length.
+extern const LengthMetric kMinDiag;
+extern const LengthMetric kMaxDiag;
+extern const LengthMetric kAvgDiag;
+
+// The minimum area of any cell at level k is at least kMinArea.GetValue(k),
+// and the maximum is at most kMaxArea.GetValue(k).  The average area of all
+// cells at level k is exactly kAvgArea.GetValue(k).
+extern const AreaMetric kMinArea;
+extern const AreaMetric kMaxArea;
+extern const AreaMetric kAvgArea;
+
+// This is the maximum edge aspect ratio over all cells at any level, where
+// the edge aspect ratio of a cell is defined as the ratio of its longest
+// edge length to its shortest edge length.
+extern const double kMaxEdgeAspect;
+
+// This is the maximum diagonal aspect ratio over all cells at any level,
+// where the diagonal aspect ratio of a cell is defined as the ratio of its
+// longest diagonal length to its shortest diagonal length.
+extern const double kMaxDiagAspect;
+
+
+//////////////////   Implementation details follow   ////////////////////
+
+
+template <int dim>
+int S2::Metric<dim>::GetLevelForMaxValue(double value) const {
+  if (value <= 0) return S2::kMaxCellLevel;
+
+  // This code is equivalent to computing a floating-point "level"
+  // value and rounding up.  ilogb() returns the exponent corresponding to a
+  // fraction in the range [1,2).
+  int level = ilogb(value / deriv_);
+  level = std::max(0, std::min(S2::kMaxCellLevel, -(level >> (dim - 1))));
+  S2_DCHECK(level == S2::kMaxCellLevel || GetValue(level) <= value);
+  S2_DCHECK(level == 0 || GetValue(level - 1) > value);
+  return level;
+}
+
+template <int dim>
+int S2::Metric<dim>::GetLevelForMinValue(double value) const {
+  if (value <= 0) return S2::kMaxCellLevel;
+
+  // This code is equivalent to computing a floating-point "level"
+  // value and rounding down.
+  int level = ilogb(deriv_ / value);
+  level = std::max(0, std::min(S2::kMaxCellLevel, level >> (dim - 1)));
+  S2_DCHECK(level == 0 || GetValue(level) >= value);
+  S2_DCHECK(level == kMaxCellLevel || GetValue(level + 1) < value);
+  return level;
+}
+
+template <int dim>
+int Metric<dim>::GetClosestLevel(double value) const {
+  return GetLevelForMaxValue((dim == 1 ? M_SQRT2 : 2) * value);
+}
+
+}  // namespace S2
+
+#endif  // S2_S2METRICS_H_

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

@@ -0,0 +1,127 @@
+// 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/s2metrics.h"
+
+#include <gtest/gtest.h>
+#include "s2/s2coords.h"
+
+// Note: obviously, I could have defined a bundle of metrics like this in the
+// S2 class itself rather than just for testing.  However, it's not clear that
+// this is useful other than for testing purposes, and I find
+// S2::kMinWidth.GetLevelForMinValue(width) to be slightly more readable than
+// than S2::kWidth.min().GetLevelForMinValue(width).  Also, there is no
+// fundamental reason that we need to analyze the minimum, maximum, and average
+// values of every metric; it would be perfectly reasonable to just define
+// one of these.
+template<int dim>
+class MetricBundle {
+ public:
+  using Metric = S2::Metric<dim>;
+  MetricBundle(const Metric& min, const Metric& max, const Metric& avg) :
+    min_(min), max_(max), avg_(avg) {}
+  const Metric& min_;
+  const Metric& max_;
+  const Metric& avg_;
+
+ private:
+  MetricBundle(const MetricBundle&) = delete;
+  void operator=(const MetricBundle&) = delete;
+};
+
+template<int dim>
+static void CheckMinMaxAvg(const MetricBundle<dim>& bundle) {
+  EXPECT_LE(bundle.min_.deriv(), bundle.avg_.deriv());
+  EXPECT_LE(bundle.avg_.deriv(), bundle.max_.deriv());
+}
+
+template<int dim>
+static void CheckLessOrEqual(const MetricBundle<dim>& a,
+                             const MetricBundle<dim>& b) {
+  EXPECT_LE(a.min_.deriv(), b.min_.deriv());
+  EXPECT_LE(a.max_.deriv(), b.max_.deriv());
+  EXPECT_LE(a.avg_.deriv(), b.avg_.deriv());
+}
+
+TEST(S2, Metrics) {
+  MetricBundle<1> angle_span(S2::kMinAngleSpan, S2::kMaxAngleSpan,
+                             S2::kAvgAngleSpan);
+  MetricBundle<1> width(S2::kMinWidth, S2::kMaxWidth, S2::kAvgWidth);
+  MetricBundle<1> edge(S2::kMinEdge, S2::kMaxEdge, S2::kAvgEdge);
+  MetricBundle<1> diag(S2::kMinDiag, S2::kMaxDiag, S2::kAvgDiag);
+  MetricBundle<2> area(S2::kMinArea, S2::kMaxArea, S2::kAvgArea);
+
+  // First, check that min <= avg <= max for each metric.
+  CheckMinMaxAvg(angle_span);
+  CheckMinMaxAvg(width);
+  CheckMinMaxAvg(edge);
+  CheckMinMaxAvg(diag);
+  CheckMinMaxAvg(area);
+
+  // Check that the maximum aspect ratio of an individual cell is consistent
+  // with the global minimums and maximums.
+  EXPECT_GE(S2::kMaxEdgeAspect, 1);
+  EXPECT_LE(S2::kMaxEdgeAspect, S2::kMaxEdge.deriv() / S2::kMinEdge.deriv());
+  EXPECT_GE(S2::kMaxDiagAspect, 1);
+  EXPECT_LE(S2::kMaxDiagAspect, S2::kMaxDiag.deriv() / S2::kMinDiag.deriv());
+
+  // Check various conditions that are provable mathematically.
+  CheckLessOrEqual(width, angle_span);
+  CheckLessOrEqual(width, edge);
+  CheckLessOrEqual(edge, diag);
+
+  EXPECT_GE(S2::kMinArea.deriv(),
+            S2::kMinWidth.deriv() * S2::kMinEdge.deriv() - 1e-15);
+  EXPECT_LE(S2::kMaxArea.deriv(),
+            S2::kMaxWidth.deriv() * S2::kMaxEdge.deriv() + 1e-15);
+
+  // GetLevelForMaxValue() and friends have built-in assertions, we just need
+  // to call these functions to test them.
+  //
+  // We don't actually check that the metrics are correct here, e.g. that
+  // GetMinWidth(10) is a lower bound on the width of cells at level 10.
+  // It is easier to check these properties in s2cell_test, since
+  // S2Cell has methods to compute the cell vertices, etc.
+
+  for (int level = -2; level <= S2::kMaxCellLevel + 3; ++level) {
+    double width = S2::kMinWidth.deriv() * pow(2, -level);
+    if (level >= S2::kMaxCellLevel + 3) width = 0;
+
+    // Check boundary cases (exactly equal to a threshold value).
+    int expected_level = std::max(0, std::min(S2::kMaxCellLevel, level));
+    EXPECT_EQ(S2::kMinWidth.GetLevelForMaxValue(width), expected_level);
+    EXPECT_EQ(S2::kMinWidth.GetLevelForMinValue(width), expected_level);
+    EXPECT_EQ(S2::kMinWidth.GetClosestLevel(width), expected_level);
+
+    // Also check non-boundary cases.
+    EXPECT_EQ(S2::kMinWidth.GetLevelForMaxValue(1.2 * width), expected_level);
+    EXPECT_EQ(S2::kMinWidth.GetLevelForMinValue(0.8 * width), expected_level);
+    EXPECT_EQ(S2::kMinWidth.GetClosestLevel(1.2 * width), expected_level);
+    EXPECT_EQ(S2::kMinWidth.GetClosestLevel(0.8 * width), expected_level);
+
+    // Same thing for area.
+    double area = S2::kMinArea.deriv() * pow(4, -level);
+    if (level <= -3) area = 0;
+    EXPECT_EQ(S2::kMinArea.GetLevelForMaxValue(area), expected_level);
+    EXPECT_EQ(S2::kMinArea.GetLevelForMinValue(area), expected_level);
+    EXPECT_EQ(S2::kMinArea.GetClosestLevel(area), expected_level);
+    EXPECT_EQ(S2::kMinArea.GetLevelForMaxValue(1.2 * area), expected_level);
+    EXPECT_EQ(S2::kMinArea.GetLevelForMinValue(0.8 * area), expected_level);
+    EXPECT_EQ(S2::kMinArea.GetClosestLevel(1.2 * area), expected_level);
+    EXPECT_EQ(S2::kMinArea.GetClosestLevel(0.8 * area), expected_level);
+  }
+}