@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,198 @@
+// Copyright 2015 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)
+//
+// This implement Andrew's monotone chain algorithm, which is a variant of the
+// Graham scan (see https://en.wikipedia.org/wiki/Graham_scan).  The time
+// complexity is O(n log n), and the space required is O(n).  In fact only the
+// call to "sort" takes O(n log n) time; the rest of the algorithm is linear.
+//
+// Demonstration of the algorithm and code:
+// en.wikibooks.org/wiki/Algorithm_Implementation/Geometry/Convex_hull/Monotone_chain
+
+#include "s2/s2convex_hull_query.h"
+
+#include "s2/third_party/absl/memory/memory.h"
+#include "s2/s2pointutil.h"
+#include "s2/s2predicates.h"
+
+using absl::make_unique;
+using std::unique_ptr;
+using std::vector;
+
+S2ConvexHullQuery::S2ConvexHullQuery()
+    : bound_(S2LatLngRect::Empty()), points_() {
+}
+
+void S2ConvexHullQuery::AddPoint(const S2Point& point) {
+  bound_.AddPoint(point);
+  points_.push_back(point);
+}
+
+void S2ConvexHullQuery::AddPolyline(const S2Polyline& polyline) {
+  bound_ = bound_.Union(polyline.GetRectBound());
+  for (int i = 0; i < polyline.num_vertices(); ++i) {
+    points_.push_back(polyline.vertex(i));
+  }
+}
+
+void S2ConvexHullQuery::AddLoop(const S2Loop& loop) {
+  bound_ = bound_.Union(loop.GetRectBound());
+  if (loop.is_empty_or_full()) {
+    // The empty and full loops consist of a single fake "vertex" that should
+    // not be added to our point collection.
+    return;
+  }
+  for (int i = 0; i < loop.num_vertices(); ++i) {
+    points_.push_back(loop.vertex(i));
+  }
+}
+
+void S2ConvexHullQuery::AddPolygon(const S2Polygon& polygon) {
+  for (int i = 0; i < polygon.num_loops(); ++i) {
+    const S2Loop& loop = *polygon.loop(i);
+    // Only loops at depth 0 can contribute to the convex hull.
+    if (loop.depth() == 0) {
+      AddLoop(loop);
+    }
+  }
+}
+
+S2Cap S2ConvexHullQuery::GetCapBound() {
+  // We keep track of a rectangular bound rather than a spherical cap because
+  // it is easy to compute a tight bound for a union of rectangles, whereas it
+  // is quite difficult to compute a tight bound around a union of caps.
+  // Also, polygons and polylines implement GetCapBound() in terms of
+  // GetRectBound() for this same reason, so it is much better to keep track
+  // of a rectangular bound as we go along and convert it at the end.
+  //
+  // TODO(ericv): We could compute an optimal bound by implementing Welzl's
+  // algorithm.  However we would still need to have special handling of loops
+  // and polygons, since if a loop spans more than 180 degrees in any
+  // direction (i.e., if it contains two antipodal points), then it is not
+  // enough just to bound its vertices.  In this case the only convex bounding
+  // cap is S2Cap::Full(), and the only convex bounding loop is the full loop.
+  return bound_.GetCapBound();
+}
+
+// A comparator for sorting points in CCW around a central point "center".
+class OrderedCcwAround {
+ public:
+  explicit OrderedCcwAround(const S2Point& center) : center_(center) {}
+  bool operator()(const S2Point& x, const S2Point& y) const {
+    // If X and Y are equal, this will return false (as desired).
+    return s2pred::Sign(center_, x, y) > 0;
+  }
+ private:
+  S2Point center_;
+};
+
+unique_ptr<S2Loop> S2ConvexHullQuery::GetConvexHull() {
+  S2Cap cap = GetCapBound();
+  if (cap.height() >= 1) {
+    // The bounding cap is not convex.  The current bounding cap
+    // implementation is not optimal, but nevertheless it is likely that the
+    // input geometry itself is not contained by any convex polygon.  In any
+    // case, we need a convex bounding cap to proceed with the algorithm below
+    // (in order to construct a point "origin" that is definitely outside the
+    // convex hull).
+    return make_unique<S2Loop>(S2Loop::kFull());
+  }
+  // This code implements Andrew's monotone chain algorithm, which is a simple
+  // variant of the Graham scan.  Rather than sorting by x-coordinate, instead
+  // we sort the points in CCW order around an origin O such that all points
+  // are guaranteed to be on one side of some geodesic through O.  This
+  // ensures that as we scan through the points, each new point can only
+  // belong at the end of the chain (i.e., the chain is monotone in terms of
+  // the angle around O from the starting point).
+  S2Point origin = cap.center().Ortho();
+  std::sort(points_.begin(), points_.end(), OrderedCcwAround(origin));
+
+  // Remove duplicates.  We need to do this before checking whether there are
+  // fewer than 3 points.
+  points_.erase(std::unique(points_.begin(), points_.end()), points_.end());
+
+  // Special cases for fewer than 3 points.
+  if (points_.size() < 3) {
+    if (points_.empty()) {
+      return make_unique<S2Loop>(S2Loop::kEmpty());
+    } else if (points_.size() == 1) {
+      return GetSinglePointLoop(points_[0]);
+    } else {
+      return GetSingleEdgeLoop(points_[0], points_[1]);
+    }
+  }
+
+  // Verify that all points lie within a 180 degree span around the origin.
+  S2_DCHECK_GE(s2pred::Sign(origin, points_.front(), points_.back()), 0);
+
+  // Generate the lower and upper halves of the convex hull.  Each half
+  // consists of the maximal subset of vertices such that the edge chain makes
+  // only left (CCW) turns.
+  vector<S2Point> lower, upper;
+  GetMonotoneChain(&lower);
+  std::reverse(points_.begin(), points_.end());
+  GetMonotoneChain(&upper);
+
+  // Remove the duplicate vertices and combine the chains.
+  S2_DCHECK_EQ(lower.front(), upper.back());
+  S2_DCHECK_EQ(lower.back(), upper.front());
+  lower.pop_back();
+  upper.pop_back();
+  lower.insert(lower.end(), upper.begin(), upper.end());
+  return make_unique<S2Loop>(lower);
+}
+
+// Iterate through the given points, selecting the maximal subset of points
+// such that the edge chain makes only left (CCW) turns.
+void S2ConvexHullQuery::GetMonotoneChain(vector<S2Point>* output) {
+  S2_DCHECK(output->empty());
+  for (const S2Point& p : points_) {
+    // Remove any points that would cause the chain to make a clockwise turn.
+    while (output->size() >= 2 &&
+           s2pred::Sign(output->end()[-2], output->back(), p) <= 0) {
+      output->pop_back();
+    }
+    output->push_back(p);
+  }
+}
+
+unique_ptr<S2Loop> S2ConvexHullQuery::GetSinglePointLoop(const S2Point& p) {
+  // Construct a 3-vertex polygon consisting of "p" and two nearby vertices.
+  // Note that Contains(p) may be false for the resulting loop (see comments
+  // in header file).
+  static const double kOffset = 1e-15;
+  S2Point d0 = S2::Ortho(p);
+  S2Point d1 = p.CrossProd(d0);
+  vector<S2Point> vertices;
+  vertices.push_back(p);
+  vertices.push_back((p + kOffset * d0).Normalize());
+  vertices.push_back((p + kOffset * d1).Normalize());
+  return make_unique<S2Loop>(vertices);
+}
+
+unique_ptr<S2Loop> S2ConvexHullQuery::GetSingleEdgeLoop(const S2Point& a,
+                                                        const S2Point& b) {
+  // Construct a loop consisting of the two vertices and their midpoint.
+  vector<S2Point> vertices;
+  vertices.push_back(a);
+  vertices.push_back(b);
+  vertices.push_back((a + b).Normalize());
+  auto loop = make_unique<S2Loop>(vertices);
+  // The resulting loop may be clockwise, so invert it if necessary.
+  loop->Normalize();
+  return loop;
+}

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

@@ -0,0 +1,110 @@
+// Copyright 2015 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_S2CONVEX_HULL_QUERY_H_
+#define S2_S2CONVEX_HULL_QUERY_H_
+
+#include <memory>
+#include <vector>
+
+#include "s2/_fp_contract_off.h"
+#include "s2/s2cap.h"
+#include "s2/s2latlng_rect.h"
+#include "s2/s2loop.h"
+#include "s2/s2polygon.h"
+#include "s2/s2polyline.h"
+
+// S2ConvexHullQuery builds the convex hull of any collection of points,
+// polylines, loops, and polygons.  It returns a single convex loop.
+//
+// The convex hull is defined as the smallest convex region on the sphere that
+// contains all of your input geometry.  Recall that a region is "convex" if
+// for every pair of points inside the region, the straight edge between them
+// is also inside the region.  In our case, a "straight" edge is a geodesic,
+// i.e. the shortest path on the sphere between two points.
+//
+// Containment of input geometry is defined as follows:
+//
+//  - Each input loop and polygon is contained by the convex hull exactly
+//    (i.e., according to S2Polygon::Contains(S2Polygon)).
+//
+//  - Each input point is either contained by the convex hull or is a vertex
+//    of the convex hull. (Recall that S2Loops do not necessarily contain their
+//    vertices.)
+//
+//  - For each input polyline, the convex hull contains all of its vertices
+//    according to the rule for points above.  (The definition of convexity
+//    then ensures that the convex hull also contains the polyline edges.)
+//
+// To use this class, call the Add*() methods to add your input geometry, and
+// then call GetConvexHull().  Note that GetConvexHull() does *not* reset the
+// state; you can continue adding geometry if desired and compute the convex
+// hull again.  If you want to start from scratch, simply declare a new
+// S2ConvexHullQuery object (they are cheap to create).
+//
+// This class is not thread-safe.  There are no "const" methods.
+class S2ConvexHullQuery {
+ public:
+  S2ConvexHullQuery();
+
+  // Add a point to the input geometry.
+  void AddPoint(const S2Point& point);
+
+  // Add a polyline to the input geometry.
+  void AddPolyline(const S2Polyline& polyline);
+
+  // Add a loop to the input geometry.
+  void AddLoop(const S2Loop& loop);
+
+  // Add a polygon to the input geometry.
+  void AddPolygon(const S2Polygon& polygon);
+
+  // Compute a bounding cap for the input geometry provided.
+  //
+  // Note that this method does not clear the geometry; you can continue
+  // adding to it and call this method again if desired.
+  S2Cap GetCapBound();
+
+  // Compute the convex hull of the input geometry provided.
+  //
+  // If there is no geometry, this method returns an empty loop containing no
+  // points (see S2Loop::is_empty()).
+  //
+  // If the geometry spans more than half of the sphere, this method returns a
+  // full loop containing the entire sphere (see S2Loop::is_full()).
+  //
+  // If the geometry contains 1 or 2 points, or a single edge, this method
+  // returns a very small loop consisting of three vertices (which are a
+  // superset of the input vertices).
+  //
+  // Note that this method does not clear the geometry; you can continue
+  // adding to it and call this method again if desired.
+  std::unique_ptr<S2Loop> GetConvexHull();
+
+ private:
+  void GetMonotoneChain(std::vector<S2Point>* output);
+  std::unique_ptr<S2Loop> GetSinglePointLoop(const S2Point& p);
+  std::unique_ptr<S2Loop> GetSingleEdgeLoop(const S2Point& a, const S2Point& b);
+
+  S2LatLngRect bound_;
+  std::vector<S2Point> points_;
+
+  S2ConvexHullQuery(const S2ConvexHullQuery&) = delete;
+  void operator=(const S2ConvexHullQuery&) = delete;
+};
+
+#endif  // S2_S2CONVEX_HULL_QUERY_H_

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

@@ -0,0 +1,208 @@
+// Copyright 2015 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/s2convex_hull_query.h"
+
+#include <cmath>
+#include <memory>
+
+#include <gtest/gtest.h>
+#include "s2/s2testing.h"
+#include "s2/s2text_format.h"
+
+using std::fabs;
+using std::unique_ptr;
+using std::vector;
+
+namespace {
+
+TEST(S2ConvexHullQueryTest, NoPoints) {
+  S2ConvexHullQuery query;
+  unique_ptr<S2Loop> result(query.GetConvexHull());
+  EXPECT_TRUE(result->is_empty());
+}
+
+static bool LoopHasVertex(const S2Loop& loop, const S2Point& p) {
+  for (int i = 0; i < loop.num_vertices(); ++i) {
+    if (loop.vertex(i) == p) return true;
+  }
+  return false;
+}
+
+TEST(S2ConvexHullQueryTest, OnePoint) {
+  S2ConvexHullQuery query;
+  S2Point p(0, 0, 1);
+  query.AddPoint(p);
+  unique_ptr<S2Loop> result(query.GetConvexHull());
+  EXPECT_EQ(3, result->num_vertices());
+  EXPECT_TRUE(result->IsNormalized());
+  EXPECT_TRUE(LoopHasVertex(*result, p));
+  // Add some duplicate points and check that the result is the same.
+  query.AddPoint(p);
+  query.AddPoint(p);
+  unique_ptr<S2Loop> result2(query.GetConvexHull());
+  EXPECT_TRUE(result2->Equals(result.get()));
+}
+
+TEST(S2ConvexHullQueryTest, TwoPoints) {
+  S2ConvexHullQuery query;
+  S2Point p(0, 0, 1);
+  S2Point q(0, 1, 0);
+  query.AddPoint(p);
+  query.AddPoint(q);
+  unique_ptr<S2Loop> result(query.GetConvexHull());
+  EXPECT_EQ(3, result->num_vertices());
+  EXPECT_TRUE(result->IsNormalized());
+  EXPECT_TRUE(LoopHasVertex(*result, p));
+  EXPECT_TRUE(LoopHasVertex(*result, q));
+  // Add some duplicate points and check that the result is the same.
+  query.AddPoint(q);
+  query.AddPoint(p);
+  query.AddPoint(p);
+  unique_ptr<S2Loop> result2(query.GetConvexHull());
+  EXPECT_TRUE(result2->Equals(result.get()));
+}
+
+TEST(S2ConvexHullQueryTest, EmptyLoop) {
+  S2ConvexHullQuery query;
+  S2Loop empty(S2Loop::kEmpty());
+  query.AddLoop(empty);
+  unique_ptr<S2Loop> result(query.GetConvexHull());
+  EXPECT_TRUE(result->is_empty());
+}
+
+TEST(S2ConvexHullQueryTest, FullLoop) {
+  S2ConvexHullQuery query;
+  S2Loop full(S2Loop::kFull());
+  query.AddLoop(full);
+  unique_ptr<S2Loop> result(query.GetConvexHull());
+  EXPECT_TRUE(result->is_full());
+}
+
+TEST(S2ConvexHullQueryTest, EmptyPolygon) {
+  S2ConvexHullQuery query;
+  vector<unique_ptr<S2Loop>> loops;
+  S2Polygon empty(std::move(loops));
+  query.AddPolygon(empty);
+  unique_ptr<S2Loop> result(query.GetConvexHull());
+  EXPECT_TRUE(result->is_empty());
+}
+
+TEST(S2ConvexHullQueryTest, NonConvexPoints) {
+  // Generate a point set such that the only convex region containing them is
+  // the entire sphere.  In other words, you can generate any point on the
+  // sphere by repeatedly linearly interpolating between the points.  (The
+  // four points of a tetrahedron would also work, but this is easier.)
+  S2ConvexHullQuery query;
+  for (int face = 0; face < 6; ++face) {
+    query.AddPoint(S2CellId::FromFace(face).ToPoint());
+  }
+  unique_ptr<S2Loop> result(query.GetConvexHull());
+  EXPECT_TRUE(result->is_full());
+}
+
+TEST(S2ConvexHullQueryTest, SimplePolyline) {
+  // A polyline is handling identically to a point set, so there is no need
+  // for special testing other than code coverage.
+  unique_ptr<S2Polyline> polyline(s2textformat::MakePolyline(
+      "0:1, 0:9, 1:6, 2:6, 3:10, 4:10, 5:5, 4:0, 3:0, 2:5, 1:5"));
+  S2ConvexHullQuery query;
+  query.AddPolyline(*polyline);
+  unique_ptr<S2Loop> result(query.GetConvexHull());
+  unique_ptr<S2Loop> expected_result(
+      s2textformat::MakeLoop("0:1, 0:9, 3:10, 4:10, 5:5, 4:0, 3:0"));
+  EXPECT_TRUE(result->BoundaryEquals(expected_result.get()));
+}
+
+void TestNorthPoleLoop(S1Angle radius, int num_vertices) {
+  // If the radius is very close to 90, then it's hard to predict whether the
+  // result will be the full loop or not.
+  S2_DCHECK_GE(fabs(radius.radians() - M_PI_2), 1e-15);
+
+  S2ConvexHullQuery query;
+  unique_ptr<S2Loop> loop(
+      S2Loop::MakeRegularLoop(S2Point(0, 0, 1), radius, num_vertices));
+  query.AddLoop(*loop);
+  unique_ptr<S2Loop> result(query.GetConvexHull());
+  if (radius > S1Angle::Radians(M_PI_2)) {
+    EXPECT_TRUE(result->is_full());
+  } else {
+    EXPECT_TRUE(result->BoundaryEquals(loop.get()));
+  }
+}
+
+
+TEST(S2ConvexHullQueryTest, LoopsAroundNorthPole) {
+  // Test loops of various sizes around the north pole.
+  TestNorthPoleLoop(S1Angle::Degrees(1), 3);
+  TestNorthPoleLoop(S1Angle::Degrees(89), 3);
+
+  // The following two loops should yield the full loop.
+  TestNorthPoleLoop(S1Angle::Degrees(91), 3);
+  TestNorthPoleLoop(S1Angle::Degrees(179), 3);
+
+  TestNorthPoleLoop(S1Angle::Degrees(10), 100);
+  TestNorthPoleLoop(S1Angle::Degrees(89), 1000);
+}
+
+TEST(S2ConvexHullQueryTest, PointsInsideHull) {
+  // Repeatedly build the convex hull of a set of points, then add more points
+  // inside that loop and build the convex hull again.  The result should
+  // always be the same.
+  const int kIters = 1000;
+  for (int iter = 0; iter < kIters; ++iter) {
+    S2Testing::rnd.Reset(iter + 1);  // Easier to reproduce a specific case.
+
+    // Choose points from within a cap of random size, up to but not including
+    // an entire hemisphere.
+    S2Cap cap = S2Testing::GetRandomCap(1e-15, 1.999 * M_PI);
+    S2ConvexHullQuery query;
+    int num_points1 = S2Testing::rnd.Uniform(100) + 3;
+    for (int i = 0; i < num_points1; ++i) {
+      query.AddPoint(S2Testing::SamplePoint(cap));
+    }
+    unique_ptr<S2Loop> hull(query.GetConvexHull());
+
+    // When the convex hull is nearly a hemisphere, the algorithm sometimes
+    // returns a full cap instead.  This is because it first computes a
+    // bounding rectangle for all the input points/edges and then converts it
+    // to a bounding cap, which sometimes yields a non-convex cap (radius
+    // larger than 90 degrees).  This should not be a problem in practice
+    // (since most convex hulls are not hemispheres), but in order make this
+    // test pass reliably it means that we need to reject convex hulls whose
+    // bounding cap (when computed from a bounding rectangle) is not convex.
+    //
+    // TODO(ericv): This test can still fail (about 1 iteration in 500,000)
+    // because the S2LatLngRect::GetCapBound implementation does not guarantee
+    // that A.Contains(B) implies A.GetCapBound().Contains(B.GetCapBound()).
+    if (hull->GetCapBound().height() >= 1) continue;
+
+    // Otherwise, add more points inside the convex hull.
+    const int num_points2 = 1000;
+    for (int i = 0; i < num_points2; ++i) {
+      S2Point p = S2Testing::SamplePoint(cap);
+      if (hull->Contains(p)) {
+        query.AddPoint(p);
+      }
+    }
+    // Finally, build a new convex hull and check that it hasn't changed.
+    unique_ptr<S2Loop> hull2(query.GetConvexHull());
+    EXPECT_TRUE(hull2->BoundaryEquals(hull.get())) << "Iteration: " << iter;
+  }
+}
+
+}  // namespace

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

@@ -0,0 +1,146 @@
+// 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/s2coords.h"
+
+#include "s2/util/bits/bits.h"
+
+namespace S2 {
+
+namespace internal {
+
+// Define the "extern" constants in s2coords_internal.h.
+
+static_assert(kSwapMask == 0x01 && kInvertMask == 0x02, "masks changed");
+
+// kIJtoPos[orientation][ij] -> pos
+const int kIJtoPos[4][4] = {
+  // (0,0) (0,1) (1,0) (1,1)
+  {     0,    1,    3,    2  },  // canonical order
+  {     0,    3,    1,    2  },  // axes swapped
+  {     2,    3,    1,    0  },  // bits inverted
+  {     2,    1,    3,    0  },  // swapped & inverted
+};
+
+// kPosToIJ[orientation][pos] -> ij
+const int kPosToIJ[4][4] = {
+  // 0  1  2  3
+  {  0, 1, 3, 2 },    // canonical order:    (0,0), (0,1), (1,1), (1,0)
+  {  0, 2, 3, 1 },    // axes swapped:       (0,0), (1,0), (1,1), (0,1)
+  {  3, 2, 0, 1 },    // bits inverted:      (1,1), (1,0), (0,0), (0,1)
+  {  3, 1, 0, 2 },    // swapped & inverted: (1,1), (0,1), (0,0), (1,0)
+};
+
+// kPosToOrientation[pos] -> orientation_modifier
+const int kPosToOrientation[4] = {
+  kSwapMask,
+  0,
+  0,
+  kInvertMask + kSwapMask,
+};
+
+const int kFaceUVWFaces[6][3][2] = {
+  { { 4, 1 }, { 5, 2 }, { 3, 0 } },
+  { { 0, 3 }, { 5, 2 }, { 4, 1 } },
+  { { 0, 3 }, { 1, 4 }, { 5, 2 } },
+  { { 2, 5 }, { 1, 4 }, { 0, 3 } },
+  { { 2, 5 }, { 3, 0 }, { 1, 4 } },
+  { { 4, 1 }, { 3, 0 }, { 2, 5 } }
+};
+
+const double kFaceUVWAxes[6][3][3] = {
+  {
+    { 0,  1,  0 },
+    { 0,  0,  1 },
+    { 1,  0,  0 }
+  },
+  {
+    {-1,  0,  0 },
+    { 0,  0,  1 },
+    { 0,  1,  0 }
+  },
+  {
+    {-1,  0,  0 },
+    { 0, -1,  0 },
+    { 0,  0,  1 }
+  },
+  {
+    { 0,  0, -1 },
+    { 0, -1,  0 },
+    {-1,  0,  0 }
+  },
+  {
+    { 0,  0, -1 },
+    { 1,  0,  0 },
+    { 0, -1,  0 }
+  },
+  {
+    { 0,  1,  0 },
+    { 1,  0,  0 },
+    { 0,  0, -1 }
+  }
+};
+
+} // namespace internal
+
+
+
+S2Point FaceXYZtoUVW(int face, const S2Point& p) {
+  // The result coordinates are simply the dot products of P with the (u,v,w)
+  // axes for the given face (see kFaceUVWAxes).
+  switch (face) {
+    case 0:  return S2Point( p.y(),  p.z(),  p.x());
+    case 1:  return S2Point(-p.x(),  p.z(),  p.y());
+    case 2:  return S2Point(-p.x(), -p.y(),  p.z());
+    case 3:  return S2Point(-p.z(), -p.y(), -p.x());
+    case 4:  return S2Point(-p.z(),  p.x(), -p.y());
+    default: return S2Point( p.y(),  p.x(), -p.z());
+  }
+}
+
+int XYZtoFaceSiTi(const S2Point& p, int* face, unsigned int* si,
+                  unsigned int* ti) {
+  double u, v;
+  *face = XYZtoFaceUV(p, &u, &v);
+  *si = STtoSiTi(UVtoST(u));
+  *ti = STtoSiTi(UVtoST(v));
+  // If the levels corresponding to si,ti are not equal, then p is not a cell
+  // center.  The si,ti values 0 and kMaxSiTi need to be handled specially
+  // because they do not correspond to cell centers at any valid level; they
+  // are mapped to level -1 by the code below.
+  int level = kMaxCellLevel - Bits::FindLSBSetNonZero(*si | kMaxSiTi);
+  if (level < 0 ||
+      level != kMaxCellLevel - Bits::FindLSBSetNonZero(*ti | kMaxSiTi)) {
+    return -1;
+  }
+  S2_DCHECK_LE(level, kMaxCellLevel);
+  // In infinite precision, this test could be changed to ST == SiTi. However,
+  // due to rounding errors, UVtoST(XYZtoFaceUV(FaceUVtoXYZ(STtoUV(...)))) is
+  // not idempotent. On the other hand, center_raw is computed exactly the same
+  // way p was originally computed (if it is indeed the center of an S2Cell):
+  // the comparison can be exact.
+  S2Point center = FaceSiTitoXYZ(*face, *si, *ti).Normalize();
+  return p == center ? level : -1;
+}
+
+S2Point FaceSiTitoXYZ(int face, unsigned int si, unsigned int ti) {
+  double u = STtoUV(SiTitoST(si));
+  double v = STtoUV(SiTitoST(ti));
+  return FaceUVtoXYZ(face, u, v);
+}
+
+}  // namespace S2