@sentryware/s2-node 0.0.6

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

@@ -0,0 +1,367 @@
+// Copyright 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.
+//
+
+#include "s2/s2max_distance_targets.h"
+
+#include <vector>
+
+#include <gtest/gtest.h>
+#include "s2/util/gtl/btree_set.h"
+#include "s2/mutable_s2shape_index.h"
+#include "s2/s1angle.h"
+#include "s2/s2cap.h"
+#include "s2/s2cell.h"
+#include "s2/s2edge_distances.h"
+#include "s2/s2lax_polygon_shape.h"
+#include "s2/s2point_vector_shape.h"
+#include "s2/s2polygon.h"
+#include "s2/s2shape_index.h"
+#include "s2/s2testing.h"
+#include "s2/s2text_format.h"
+
+using absl::make_unique;
+using s2textformat::MakeIndexOrDie;
+using s2textformat::MakePointOrDie;
+using s2textformat::ParsePointsOrDie;
+using std::vector;
+
+TEST(CellTarget, GetCapBound) {
+  for (int i = 0; i < 100; i++) {
+    S2Cell cell = S2Cell{S2Testing::GetRandomCellId()};
+    S2MaxDistanceCellTarget target(cell);
+    S2Cap cap = target.GetCapBound();
+
+    for (int j = 0; j < 100; j++) {
+      S2Point p_test = S2Testing::RandomPoint();
+      // Check points outside of cap to be away from S2MaxDistance::Zero().
+      if (!(cap.Contains(p_test))) {
+        S1ChordAngle dist = cell.GetMaxDistance(p_test);
+        EXPECT_TRUE(S2MaxDistance::Zero() < S2MaxDistance(dist));
+      }
+    }
+  }
+}
+
+TEST(IndexTarget, GetCapBound) {
+  auto index = make_unique<MutableS2ShapeIndex>();
+
+  S2Polygon polygon(S2Cell{S2Testing::GetRandomCellId()});
+  index->Add(make_unique<S2Polygon::Shape>(&polygon));
+
+  S2Point p = S2Testing::RandomPoint();
+  vector<S2Point> pts = {p};
+  index->Add(make_unique<S2PointVectorShape>(pts));
+
+  S2MaxDistanceShapeIndexTarget target(index.get());
+  S2Cap cap = target.GetCapBound();
+
+  for (int j = 0; j < 100; j++) {
+    S2Point p_test = S2Testing::RandomPoint();
+    // Check points outside of cap to be away from S2MaxDistance::Zero().
+    if (!(cap.Contains(p_test))) {
+      S2MaxDistance cur_dist = S2MaxDistance::Infinity();
+      EXPECT_TRUE(target.UpdateMinDistance(p_test, &cur_dist));
+      EXPECT_TRUE(S2MaxDistance::Zero() < cur_dist);
+    }
+  }
+}
+
+TEST(PointTarget, UpdateMaxDistance) {
+  S2MaxDistancePointTarget target(MakePointOrDie("0:0"));
+  S2MaxDistance dist0 = S2MaxDistance(S1ChordAngle::Degrees(0));
+  S2MaxDistance dist10 = S2MaxDistance(S1ChordAngle::Degrees(10));
+
+  // Update max distance target to point.
+  S2Point p = MakePointOrDie("1:0");
+  EXPECT_TRUE(target.UpdateMinDistance(p, &dist0));
+  EXPECT_NEAR(1.0, S1ChordAngle(dist0).degrees(), 1e-15);
+  EXPECT_FALSE(target.UpdateMinDistance(p, &dist10));
+
+  // Reset dist0 which was updated.
+  dist0 = S2MaxDistance(S1ChordAngle::Degrees(0));
+  // Test for edges.
+  auto edge = ParsePointsOrDie("0:-1, 0:1");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist0));
+  EXPECT_NEAR(1.0, S1ChordAngle(dist0).degrees(), 1e-15);
+  EXPECT_FALSE(target.UpdateMinDistance(p, &dist10));
+
+  // Reset dist0 which was updated.
+  dist0 = S2MaxDistance(S1ChordAngle::Degrees(0));
+  // Test for cell.
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist0));
+  // Leaf cell will be tiny compared to 10 degrees - expect no update.
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist10));
+}
+
+TEST(PointTarget, UpdateMaxDistanceToEdgeWhenEqual) {
+  // Verifies that UpdateMinDistance only returns true when the new distance
+  // is greater than the old distance (not greater than or equal to).
+  S2MaxDistancePointTarget target(MakePointOrDie("1:0"));
+  auto dist = S2MaxDistance::Infinity();
+  auto edge = ParsePointsOrDie("0:-1, 0:1");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+}
+
+TEST(PointTarget, UpdateMaxDistanceToCellWhenEqual) {
+  S2MaxDistancePointTarget target(MakePointOrDie("1:0"));
+  auto dist = S2MaxDistance::Infinity();
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist));
+}
+
+TEST(EdgeTarget, UpdateMaxDistance) {
+  auto target_edge = ParsePointsOrDie("0:-1, 0:1");
+  S2MaxDistanceEdgeTarget target(target_edge[0], target_edge[1]);
+  S2MaxDistance dist0 = S2MaxDistance(S1ChordAngle::Degrees(0));
+  S2MaxDistance dist10 = S2MaxDistance(S1ChordAngle::Degrees(10));
+
+  // Update max distance target to point.
+  S2Point p = MakePointOrDie("0:2");
+  EXPECT_TRUE(target.UpdateMinDistance(p, &dist0));
+  EXPECT_NEAR(3.0, S1ChordAngle(dist0).degrees(), 1e-15);
+  EXPECT_FALSE(target.UpdateMinDistance(p, &dist10));
+
+  // Reset dist0 which was updated.
+  dist0 = S2MaxDistance(S1ChordAngle::Degrees(0));
+  // Test for edges.
+  auto test_edge = ParsePointsOrDie("0:2, 0:3");
+  EXPECT_TRUE(target.UpdateMinDistance(test_edge[0], test_edge[1], &dist0));
+  EXPECT_NEAR(4.0, S1ChordAngle(dist0).degrees(), 1e-15);
+  EXPECT_FALSE(target.UpdateMinDistance(p, &dist10));
+
+  // Reset dist0 which was updated.
+  dist0 = S2MaxDistance(S1ChordAngle::Degrees(0));
+  // Test for cell.
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist0));
+  // Leaf cell will be tiny compared to 10 degrees - expect no update.
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist10));
+}
+
+TEST(EdgeTarget, UpdateMaxDistanceToEdgeWhenEqual) {
+  S2MaxDistanceEdgeTarget target(MakePointOrDie("1:0"), MakePointOrDie("1:1"));
+  S2MaxDistance dist = S2MaxDistance::Infinity();
+  auto edge = ParsePointsOrDie("0:-1, 0:1");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+}
+
+TEST(EdgeTarget, UpdateMaxDistanceToEdgeAntipodal) {
+  S2MaxDistanceEdgeTarget target(MakePointOrDie("0:89"),
+                                 MakePointOrDie("0:91"));
+  S2MaxDistance dist = S2MaxDistance::Infinity();
+  auto edge = ParsePointsOrDie("1:-90, -1:-90");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+  EXPECT_EQ(S1ChordAngle(dist), S1ChordAngle::Straight());
+}
+
+TEST(EdgeTarget, UpdateMaxDistanceToCellWhenEqual) {
+  S2MaxDistanceEdgeTarget target(MakePointOrDie("1:0"), MakePointOrDie("1:1"));
+  S2MaxDistance dist = S2MaxDistance::Infinity();
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist));
+}
+
+TEST(CellTarget, UpdateMaxDistance) {
+  S2MaxDistanceCellTarget target{S2Cell{S2CellId{MakePointOrDie("0:1")}}};
+  S2MaxDistance dist0 = S2MaxDistance(S1ChordAngle::Degrees(0));
+  S2MaxDistance dist10 = S2MaxDistance(S1ChordAngle::Degrees(10));
+
+  // Update max distance target to point.
+  S2Point p = MakePointOrDie("0:0");
+  EXPECT_TRUE(target.UpdateMinDistance(p, &dist0));
+  EXPECT_FALSE(target.UpdateMinDistance(p, &dist10));
+
+  // Reset dist0 which was updated.
+  dist0 = S2MaxDistance(S1ChordAngle::Degrees(0));
+  // Test for edges.
+  auto test_edge = ParsePointsOrDie("0:2, 0:3");
+  EXPECT_TRUE(target.UpdateMinDistance(test_edge[0], test_edge[1], &dist0));
+  EXPECT_FALSE(target.UpdateMinDistance(p, &dist10));
+
+  // Reset dist0 which was updated.
+  dist0 = S2MaxDistance(S1ChordAngle::Degrees(0));
+  // Test for cell.
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist0));
+  // Leaf cell extent will be tiny compared to 10 degrees - expect no update.
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist10));
+}
+
+TEST(CellTarget, UpdateMaxDistanceToEdgeWhenEqual) {
+  S2MaxDistanceCellTarget target{S2Cell{S2CellId{MakePointOrDie("0:1")}}};
+  S2MaxDistance dist = S2MaxDistance::Infinity();
+  auto edge = ParsePointsOrDie("0:-1, 0:1");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+}
+
+TEST(CellTarget, UpdateMaxDistanceToCellWhenEqual) {
+  S2MaxDistanceCellTarget target{S2Cell{S2CellId{MakePointOrDie("0:1")}}};
+  S2MaxDistance dist = S2MaxDistance::Infinity();
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist));
+}
+
+TEST(ShapeIndexTarget, UpdateMaxDistanceToEdgeWhenEqual) {
+  auto target_index = MakeIndexOrDie("1:0 # #");
+  S2MaxDistanceShapeIndexTarget target(target_index.get());
+  S2MaxDistance dist = S2MaxDistance::Infinity();
+  auto edge = ParsePointsOrDie("0:-1, 0:1");
+  EXPECT_TRUE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(edge[0], edge[1], &dist));
+}
+
+TEST(ShapeIndexTarget, UpdateMaxDistanceToCellWhenEqual) {
+  auto target_index = MakeIndexOrDie("1:0 # #");
+  S2MaxDistanceShapeIndexTarget target(target_index.get());
+  S2MaxDistance dist = S2MaxDistance::Infinity();
+  S2Cell cell{S2CellId(MakePointOrDie("0:0"))};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist));
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist));
+}
+
+TEST(CellTarget, UpdateMaxDistanceToCellAntipodal) {
+  S2Point p = MakePointOrDie("0:0");
+  S2MaxDistanceCellTarget target{S2Cell{p}};
+  S2MaxDistance dist = S2MaxDistance::Infinity();
+  S2Cell cell{-p};
+  EXPECT_TRUE(target.UpdateMinDistance(cell, &dist));
+  EXPECT_EQ(S1ChordAngle(dist), S1ChordAngle::Straight());
+  // Expect a second update to do nothing.
+  EXPECT_FALSE(target.UpdateMinDistance(cell, &dist));
+}
+
+vector<int> GetContainingShapes(S2MaxDistanceTarget* target,
+                                const S2ShapeIndex& index, int max_shapes) {
+  gtl::btree_set<int32> shape_ids;
+  (void) target->VisitContainingShapes(
+      index, [&shape_ids, max_shapes](S2Shape* containing_shape,
+                                      const S2Point& target_point) {
+        shape_ids.insert(containing_shape->id());
+        return shape_ids.size() < max_shapes;
+      });
+  return vector<int>(shape_ids.begin(), shape_ids.end());
+}
+
+TEST(PointTarget, VisitContainingShapes) {
+  // Only shapes 2 and 4 should contain the target point.
+  auto index = MakeIndexOrDie(
+      "1:1 # 1:1, 2:2 # 0:0, 0:3, 3:0 | 6:6, 6:9, 9:6 | 0:0, 0:4, 4:0");
+  S2Point p = MakePointOrDie("1:1");
+  // Test against antipodal point.
+  S2MaxDistancePointTarget target(-p);
+  EXPECT_EQ((vector<int>{2}), GetContainingShapes(&target, *index, 1));
+  EXPECT_EQ((vector<int>{2, 4}), GetContainingShapes(&target, *index, 5));
+}
+
+TEST(EdgeTarget, VisitContainingShapes) {
+  // Only shapes 2 and 4 should contain the target point.
+  auto index = MakeIndexOrDie(
+      "1:1 # 1:1, 2:2 # 0:0, 0:3, 3:0 | 6:6, 6:9, 9:6 | 0:0, 0:4, 4:0");
+  // Test against antipodal edge.
+  auto edge = ParsePointsOrDie("1:2, 2:1");
+  S2MaxDistanceEdgeTarget target(-edge[0], -edge[1]);
+  EXPECT_EQ((vector<int>{2}), GetContainingShapes(&target, *index, 1));
+  EXPECT_EQ((vector<int>{2, 4}), GetContainingShapes(&target, *index, 5));
+}
+
+TEST(CellTarget, VisitContainingShapes) {
+  auto index = MakeIndexOrDie(
+      "1:1 # 1:1, 2:2 # 0:0, 0:3, 3:0 | 6:6, 6:9, 9:6 | -1:-1, -1:5, 5:-1");
+  // Only shapes 2 and 4 should contain a very small cell near
+  // the antipode of 1:1.
+  S2CellId cellid1(-MakePointOrDie("1:1"));
+  S2MaxDistanceCellTarget target1{S2Cell(cellid1)};
+  EXPECT_EQ((vector<int>{2}), GetContainingShapes(&target1, *index, 1));
+  EXPECT_EQ((vector<int>{2, 4}), GetContainingShapes(&target1, *index, 5));
+
+  // For a larger antipodal cell that properly contains one or more index
+  // cells, all shapes that intersect the first such cell in S2CellId order are
+  // returned.  In the test below, this happens to again be the 1st and 3rd
+  // polygons (whose shape_ids are 2 and 4).
+  S2CellId cellid2 = cellid1.parent(5);
+  S2MaxDistanceCellTarget target2{S2Cell(cellid2)};
+  EXPECT_EQ((vector<int>{2, 4}), GetContainingShapes(&target2, *index, 5));
+}
+
+// Negates S2 points to reflect them through the sphere.
+static vector<S2Point> Reflect(const vector<S2Point>& pts) {
+  vector<S2Point> negative_pts;
+  for (const auto& p : pts) {
+    negative_pts.push_back(-p);
+  }
+  return negative_pts;
+}
+
+TEST(ShapeIndexTarget, VisitContainingShapes) {
+  // Create an index containing a repeated grouping of one point, one
+  // polyline, and one polygon.
+  auto index = MakeIndexOrDie(
+      "1:1 | 4:4 | 7:7 | 10:10 # "
+      "1:1, 1:2 | 4:4, 4:5 | 7:7, 7:8 | 10:10, 10:11 # "
+      "0:0, 0:3, 3:0 | 3:3, 3:6, 6:3 | 6:6, 6:9, 9:6 | 9:9, 9:12, 12:9");
+
+  // Construct a target consisting of one point, one polyline, and one polygon
+  // with two loops where only the second loop is contained by a polygon in
+  // the index above.
+  auto target_index = make_unique<MutableS2ShapeIndex>();
+
+  auto pts = Reflect(ParsePointsOrDie("1:1"));
+  target_index->Add(make_unique<S2PointVectorShape>(pts));
+
+  S2Polyline line(Reflect(ParsePointsOrDie("4:5, 5:4")));
+  target_index->Add(make_unique<S2Polyline::Shape>(&line));
+
+  vector<S2Point> loop1 = Reflect(ParsePointsOrDie("20:20, 20:21, 21:20"));
+  vector<S2Point> loop2 = Reflect(ParsePointsOrDie("10:10, 10:11, 11:10"));
+  vector<vector<S2Point>> loops = {loop1, loop2};
+  target_index->Add(make_unique<S2LaxPolygonShape>(loops));
+
+  S2MaxDistanceShapeIndexTarget target(target_index.get());
+  // These are the shape_ids of the 1st, 2nd, and 4th polygons of "index"
+  // (noting that the 4 points are represented by one S2PointVectorShape).
+  EXPECT_EQ((vector<int>{5, 6, 8}), GetContainingShapes(&target, *index, 5));
+}
+
+TEST(ShapeIndexTarget, VisitContainingShapesEmptyAndFull) {
+  // Verify that VisitContainingShapes never returns empty polygons and always
+  // returns full polygons (i.e., those containing the entire sphere).
+
+  // Creating an index containing one empty and one full polygon.
+  auto index = MakeIndexOrDie("# # empty | full");
+
+  // Check only the full polygon is returned for a point target.
+  auto point_index = MakeIndexOrDie("1:1 # #");
+  S2MaxDistanceShapeIndexTarget point_target(point_index.get());
+  EXPECT_EQ((vector<int>{1}), GetContainingShapes(&point_target, *index, 5));
+
+  // Check only the full polygon is returned for a full polygon target.
+  auto full_polygon_index = MakeIndexOrDie("# # full");
+  S2MaxDistanceShapeIndexTarget full_target(full_polygon_index.get());
+  EXPECT_EQ((vector<int>{1}), GetContainingShapes(&full_target, *index, 5));
+
+  // Check that nothing is returned for an empty polygon target.  (An empty
+  // polygon has no connected components and does not intersect anything, so
+  // according to the API of GetContainingShapes nothing should be returned.)
+  auto empty_polygon_index = MakeIndexOrDie("# # empty");
+  S2MaxDistanceShapeIndexTarget empty_target(empty_polygon_index.get());
+  EXPECT_EQ((vector<int>{}), GetContainingShapes(&empty_target, *index, 5));
+}

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

@@ -0,0 +1,128 @@
+// 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 <algorithm>
+#include <cmath>
+
+#include "s2/s2pointutil.h"
+#include "s2/s2predicates.h"
+
+// TODO(ericv): Convert to using s2pred::Sign().
+//#include "util/geometry/s2predicates.h"
+
+using std::atan;
+using std::max;
+using std::sqrt;
+using std::tan;
+
+namespace S2 {
+
+double Angle(const S2Point& a, const S2Point& b, const S2Point& c) {
+  // RobustCrossProd() is necessary to get good accuracy when two of the input
+  // points are very close together.
+  return RobustCrossProd(a, b).Angle(RobustCrossProd(c, b));
+}
+
+double TurnAngle(const S2Point& a, const S2Point& b, const S2Point& c) {
+  // We use RobustCrossProd() to get good accuracy when two points are very
+  // close together, and Sign() to ensure that the sign is correct for
+  // turns that are close to 180 degrees.
+  //
+  // Unfortunately we can't save RobustCrossProd(a, b) and pass it as the
+  // optional 4th argument to Sign(), because Sign() requires a.CrossProd(b)
+  // exactly (the robust version differs in magnitude).
+  double angle = RobustCrossProd(a, b).Angle(RobustCrossProd(b, c));
+
+  // Don't return Sign() * angle because it is legal to have (a == c).
+  return (s2pred::Sign(a, b, c) > 0) ? angle : -angle;
+}
+
+double Area(const S2Point& a, const S2Point& b, const S2Point& c) {
+  S2_DCHECK(IsUnitLength(a));
+  S2_DCHECK(IsUnitLength(b));
+  S2_DCHECK(IsUnitLength(c));
+  // This method is based on l'Huilier's theorem,
+  //
+  //   tan(E/4) = sqrt(tan(s/2) tan((s-a)/2) tan((s-b)/2) tan((s-c)/2))
+  //
+  // where E is the spherical excess of the triangle (i.e. its area),
+  //       a, b, c, are the side lengths, and
+  //       s is the semiperimeter (a + b + c) / 2 .
+  //
+  // The only significant source of error using l'Huilier's method is the
+  // cancellation error of the terms (s-a), (s-b), (s-c).  This leads to a
+  // *relative* error of about 1e-16 * s / min(s-a, s-b, s-c).  This compares
+  // to a relative error of about 1e-15 / E using Girard's formula, where E is
+  // the true area of the triangle.  Girard's formula can be even worse than
+  // this for very small triangles, e.g. a triangle with a true area of 1e-30
+  // might evaluate to 1e-5.
+  //
+  // So, we prefer l'Huilier's formula unless dmin < s * (0.1 * E), where
+  // dmin = min(s-a, s-b, s-c).  This basically includes all triangles
+  // except for extremely long and skinny ones.
+  //
+  // Since we don't know E, we would like a conservative upper bound on
+  // the triangle area in terms of s and dmin.  It's possible to show that
+  // E <= k1 * s * sqrt(s * dmin), where k1 = 2*sqrt(3)/Pi (about 1).
+  // Using this, it's easy to show that we should always use l'Huilier's
+  // method if dmin >= k2 * s^5, where k2 is about 1e-2.  Furthermore,
+  // if dmin < k2 * s^5, the triangle area is at most k3 * s^4, where
+  // k3 is about 0.1.  Since the best case error using Girard's formula
+  // is about 1e-15, this means that we shouldn't even consider it unless
+  // s >= 3e-4 or so.
+  //
+  // TODO(ericv): Implement rigorous error bounds (analysis already done).
+  double sa = b.Angle(c);
+  double sb = c.Angle(a);
+  double sc = a.Angle(b);
+  double s = 0.5 * (sa + sb + sc);
+  if (s >= 3e-4) {
+    // Consider whether Girard's formula might be more accurate.
+    double s2 = s * s;
+    double dmin = s - max(sa, max(sb, sc));
+    if (dmin < 1e-2 * s * s2 * s2) {
+      // This triangle is skinny enough to consider using Girard's formula.
+      // We increase the area by the approximate maximum error in the Girard
+      // calculation in order to ensure that this test is conservative.
+      double area = GirardArea(a, b, c);
+      if (dmin < s * (0.1 * (area + 5e-15))) return area;
+    }
+  }
+  // Use l'Huilier's formula.
+  return 4 * atan(sqrt(max(0.0, tan(0.5 * s) * tan(0.5 * (s - sa)) *
+                           tan(0.5 * (s - sb)) * tan(0.5 * (s - sc)))));
+}
+
+double GirardArea(const S2Point& a, const S2Point& b, const S2Point& c) {
+  // This is equivalent to the usual Girard's formula but is slightly more
+  // accurate, faster to compute, and handles a == b == c without a special
+  // case.  RobustCrossProd() is necessary to get good accuracy when two of
+  // the input points are very close together.
+
+  Vector3_d ab = RobustCrossProd(a, b);
+  Vector3_d bc = RobustCrossProd(b, c);
+  Vector3_d ac = RobustCrossProd(a, c);
+  return max(0.0, ab.Angle(ac) - ab.Angle(bc) + bc.Angle(ac));
+}
+
+double SignedArea(const S2Point& a, const S2Point& b, const S2Point& c) {
+  return s2pred::Sign(a, b, c) * Area(a, b, c);
+}
+
+}  // namespace S2

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

@@ -0,0 +1,78 @@
+// 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)
+//
+// Defines various angle and area measures on the sphere.  Also see
+// s2edge_distances.h, s2loop_measures.h, and s2polyline_measures.h.
+
+#ifndef S2_S2MEASURES_H_
+#define S2_S2MEASURES_H_
+
+#include "s2/s2point.h"
+
+namespace S2 {
+
+// Return the interior angle at the vertex B in the triangle ABC.  The
+// return value is always in the range [0, Pi].  All points should be
+// normalized.  Ensures that Angle(a,b,c) == Angle(c,b,a) for all a,b,c.
+//
+// The angle is undefined if A or C is diametrically opposite from B, and
+// becomes numerically unstable as the length of edge AB or BC approaches
+// 180 degrees.
+double Angle(const S2Point& a, const S2Point& b, const S2Point& c);
+
+// Return the exterior angle at vertex B in the triangle ABC.  The return
+// value is positive if ABC is counterclockwise and negative otherwise.  If
+// you imagine an ant walking from A to B to C, this is the angle that the
+// ant turns at vertex B (positive = left = CCW, negative = right = CW).
+// This quantity is also known as the "geodesic curvature" at B.
+//
+// Ensures that TurnAngle(a,b,c) == -TurnAngle(c,b,a) for all distinct
+// a,b,c. The result is undefined if (a == b || b == c), but is either
+// -Pi or Pi if (a == c).  All points should be normalized.
+double TurnAngle(const S2Point& a, const S2Point& b, const S2Point& c);
+
+// Return the area of triangle ABC.  This method combines two different
+// algorithms to get accurate results for both large and small triangles.
+// The maximum error is about 5e-15 (about 0.25 square meters on the Earth's
+// surface), the same as GirardArea() below, but unlike that method it is
+// also accurate for small triangles.  Example: when the true area is 100
+// square meters, Area() yields an error about 1 trillion times smaller than
+// GirardArea().
+//
+// All points should be unit length, and no two points should be antipodal.
+// The area is always positive.
+double Area(const S2Point& a, const S2Point& b, const S2Point& c);
+
+// Return the area of the triangle computed using Girard's formula.  All
+// points should be unit length, and no two points should be antipodal.
+//
+// This method is about twice as fast as Area() but has poor relative
+// accuracy for small triangles.  The maximum error is about 5e-15 (about
+// 0.25 square meters on the Earth's surface) and the average error is about
+// 1e-15.  These bounds apply to triangles of any size, even as the maximum
+// edge length of the triangle approaches 180 degrees.  But note that for
+// such triangles, tiny perturbations of the input points can change the
+// true mathematical area dramatically.
+double GirardArea(const S2Point& a, const S2Point& b, const S2Point& c);
+
+// Like Area(), but returns a positive value for counterclockwise triangles
+// and a negative value otherwise.
+double SignedArea(const S2Point& a, const S2Point& b, const S2Point& c);
+
+}  // namespace S2
+
+#endif  // S2_S2MEASURES_H_