@sentryware/s2-node 0.0.6

package/third_party/s2geometry/src/python/pywraps2_test.py

@@ -0,0 +1,786 @@
+#
+# Copyright 2006 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.
+#
+
+import unittest
+from collections import defaultdict
+
+import pywraps2 as s2
+
+
+class PyWrapS2TestCase(unittest.TestCase):
+
+  def testContainsIsWrappedCorrectly(self):
+    london = s2.S2LatLngRect(s2.S2LatLng.FromDegrees(51.3368602, 0.4931979),
+                             s2.S2LatLng.FromDegrees(51.7323965, 0.1495211))
+    e14lj = s2.S2LatLngRect(s2.S2LatLng.FromDegrees(51.5213527, -0.0476026),
+                            s2.S2LatLng.FromDegrees(51.5213527, -0.0476026))
+    self.assertTrue(london.Contains(e14lj))
+
+  def testS2CellIdEqualsIsWrappedCorrectly(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    cell = s2.S2CellId(london)
+    same_cell = s2.S2CellId(london)
+    self.assertEqual(cell, same_cell)
+
+  def testS2CellIdComparsionIsWrappedCorrectly(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    cell = s2.S2CellId(london)
+    self.assertLess(cell, cell.next())
+    self.assertGreater(cell.next(), cell)
+
+  def testS2CellIdFromToTokenIsWrappedCorrectly(self):
+    cell = s2.S2CellId.FromToken("487604c489f841c3")
+    self.assertEqual(cell.ToToken(), "487604c489f841c3")
+    self.assertEqual(cell.id(), 0x487604c489f841c3)
+
+    cell = s2.S2CellId.FromToken("487")
+    self.assertEqual(cell.ToToken(), "487")
+    self.assertEqual(cell.id(), 0x4870000000000000)
+
+    cell = s2.S2CellId.FromToken("this is invalid")
+    self.assertEqual(cell.ToToken(), "X")
+    self.assertEqual(cell.id(), 0)
+
+  def testS2CellIdGetEdgeNeighborsIsWrappedCorrectly(self):
+    cell = s2.S2CellId(0x466d319000000000)
+    expected_neighbors = [s2.S2CellId(0x466d31b000000000),
+                          s2.S2CellId(0x466d317000000000),
+                          s2.S2CellId(0x466d323000000000),
+                          s2.S2CellId(0x466d31f000000000)]
+    neighbors = cell.GetEdgeNeighbors()
+    self.assertEqual(neighbors, expected_neighbors)
+
+  def testS2CellIdGetAllNeighborsIsWrappedCorrectly(self):
+    cell = s2.S2CellId(0x6aa7590000000000)
+    expected_neighbors = (s2.S2CellId(0x2ab3530000000000),
+                          s2.S2CellId(0x2ab34b0000000000),
+                          s2.S2CellId(0x2ab34d0000000000),
+                          s2.S2CellId(0x6aa75b0000000000),
+                          s2.S2CellId(0x6aa7570000000000),
+                          s2.S2CellId(0x6aa75f0000000000),
+                          s2.S2CellId(0x6aa7510000000000),
+                          s2.S2CellId(0x6aa75d0000000000))
+    neighbors = cell.GetAllNeighbors(cell.level())
+    self.assertEqual(neighbors, expected_neighbors)
+
+  def testS2CellIdIntersectsIsTrueForOverlap(self):
+    cell1 = s2.S2CellId(0x89c259c000000000)
+    cell2 = s2.S2CellId(0x89c2590000000000)
+    self.assertTrue(cell1.intersects(cell2))
+
+  def testS2CellIdIntersectsIsFalseForNonOverlap(self):
+    cell1 = s2.S2CellId(0x89c259c000000000)
+    cell2 = s2.S2CellId(0x89e83d0000000000)
+    self.assertFalse(cell1.intersects(cell2))
+
+  def testS2HashingIsWrappedCorrectly(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    cell = s2.S2CellId(london)
+    same_cell = s2.S2CellId(london)
+    self.assertEqual(hash(cell), hash(same_cell))
+
+  def testCovererIsWrappedCorrectly(self):
+    london = s2.S2LatLngRect(s2.S2LatLng.FromDegrees(51.3368602, 0.4931979),
+                             s2.S2LatLng.FromDegrees(51.7323965, 0.1495211))
+    e14lj = s2.S2LatLngRect(s2.S2LatLng.FromDegrees(51.5213527, -0.0476026),
+                            s2.S2LatLng.FromDegrees(51.5213527, -0.0476026))
+    coverer = s2.S2RegionCoverer()
+    coverer.set_max_cells(6)
+    self.assertEqual(6, coverer.max_cells())
+    covering = coverer.GetCovering(e14lj)
+    self.assertLessEqual(len(covering), 6)
+    for cellid in covering:
+      self.assertTrue(london.Contains(s2.S2Cell(cellid)))
+    interior = coverer.GetInteriorCovering(e14lj)
+    for cellid in interior:
+      self.assertTrue(london.Contains(s2.S2Cell(cellid)))
+
+  def testS2CellUnionIsWrappedCorrectly(self):
+    cell_union = s2.S2CellUnion()
+    cell_union.Init([0x466d319000000000, 0x466d31b000000000])
+    self.assertEqual(cell_union.num_cells(), 2)
+    trondheim = s2.S2LatLng.FromDegrees(63.431052, 10.395083)
+    self.assertTrue(cell_union.Contains(s2.S2CellId(trondheim)))
+
+    # Init() calls Normalized, so cell_ids() are normalized.
+    cell_union2 = s2.S2CellUnion.FromNormalized(cell_union.cell_ids())
+    # There is no S2CellUnion::Equals, and cell_ids is a non-iterable
+    # SWIG object, so just perform the same checks again.
+    self.assertEqual(cell_union2.num_cells(), 2)
+    self.assertTrue(cell_union2.Contains(s2.S2CellId(trondheim)))
+
+  def testS2PolygonIsWrappedCorrectly(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    polygon = s2.S2Polygon(s2.S2Cell(s2.S2CellId(london)))
+    self.assertEqual(polygon.num_loops(), 1)
+    point = london.ToPoint()
+    self.assertTrue(polygon.Contains(point))
+
+  def testS2LoopIsWrappedCorrectly(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    polygon = s2.S2Polygon(s2.S2Cell(s2.S2CellId(london)))
+    loop = polygon.loop(0)
+    self.assertTrue(loop.IsValid())
+    self.assertEqual(0, loop.depth())
+    self.assertFalse(loop.is_hole())
+    self.assertEqual(4, loop.num_vertices())
+    self.assertTrue(loop.IsNormalized())
+    point = london.ToPoint()
+    self.assertTrue(loop.Contains(point))
+
+  def testS2LoopUsesValueEquality(self):
+    self.assertEqual(s2.S2Loop(), s2.S2Loop())
+
+  def testS2PolygonCopiesLoopInConstructorBecauseItTakesOwnership(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    loop = s2.S2Loop(s2.S2Cell(s2.S2CellId(london)))
+    s2.S2Polygon(loop)
+
+  def testS2PolygonInitNestedIsWrappedCorrectly(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    small_loop = s2.S2Loop(s2.S2Cell(s2.S2CellId(london)))
+    big_loop = s2.S2Loop(s2.S2Cell(s2.S2CellId(london).parent(1)))
+    polygon = s2.S2Polygon()
+    polygon.InitNested([big_loop, small_loop])
+
+  def testS2PolygonInitNestedWithIncorrectTypeIsWrappedCorrectly(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    loop = s2.S2Loop(s2.S2Cell(s2.S2CellId(london)))
+    polygon = s2.S2Polygon()
+    with self.assertRaises(TypeError):
+      polygon.InitNested([loop, s2.S2CellId()])
+
+  def testS2PolygonGetAreaIsWrappedCorrectly(self):
+    # Cell at level 10 containing central London.
+
+    london_level_10 = s2.S2CellId(
+        s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)).parent(10)
+    polygon = s2.S2Polygon(s2.S2Cell(london_level_10))
+    # Because S2Cell.ExactArea() isn't swigged, compare S2Polygon.GetArea() with
+    # S2CellUnion.ExactArea().
+    cell_union = s2.S2CellUnion()
+    cell_union.Init([london_level_10.id()])
+    self.assertAlmostEqual(cell_union.ExactArea(), polygon.GetArea(), places=10)
+
+  def testS2PolygonGetOverlapFractions(self):
+    # Matches S2Polygon, OverlapFractions test from cs/s2polygon_test.cc
+    a = s2.S2Polygon()
+    b = s2.S2Polygon()
+    r1, r2 = s2.S2Polygon.GetOverlapFractions(a, b)
+    self.assertAlmostEqual(1.0, r1)
+    self.assertAlmostEqual(1.0, r2)
+
+    def verts2loop(vs):
+      loop = s2.S2Loop()
+      loop.Init([s2.S2LatLng.FromDegrees(*v).ToPoint() for v in vs])
+      return loop
+
+    loop1verts = [(-10, 10), (0, 10), (0, -10), (-10, -10), (-10, 0)]
+    b = s2.S2Polygon(verts2loop(loop1verts))
+    r1, r2 = s2.S2Polygon.GetOverlapFractions(a, b)
+    self.assertAlmostEqual(1.0, r1)
+    self.assertAlmostEqual(0.0, r2)
+
+    loop2verts = [(-10, 0), (10, 0), (10, -10), (-10, -10)]
+    a = s2.S2Polygon(verts2loop(loop2verts))
+    r1, r2 = s2.S2Polygon.GetOverlapFractions(a, b)
+    self.assertAlmostEqual(0.5, r1)
+    self.assertAlmostEqual(0.5, r2)
+
+  def testGetS2LatLngVertexIsWrappedCorrectly(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    polygon = s2.S2Polygon(s2.S2Cell(s2.S2CellId(london)))
+    loop = polygon.loop(0)
+    first_vertex = loop.GetS2LatLngVertex(0)
+    self.assertIsInstance(first_vertex, s2.S2LatLng)
+    self.assertEqual("51.500152,-0.126235", first_vertex.ToStringInDegrees())
+    second_vertex = loop.GetS2LatLngVertex(1)
+    self.assertIsInstance(second_vertex, s2.S2LatLng)
+    self.assertEqual("51.500153,-0.126235", second_vertex.ToStringInDegrees())
+
+  def testS2PolylineInitFromS2LatLngs(self):
+    e7_10deg = 0x5f5e100
+    list_ll = []
+    for lat, lng in [(0, 0), (0, e7_10deg), (e7_10deg, e7_10deg)]:
+      list_ll.append(s2.S2LatLng.FromE7(lat, lng))
+    line = s2.S2Polyline()
+    line.InitFromS2LatLngs(list_ll)
+    self.assertAlmostEqual(20.0, line.GetLength().degrees())
+
+  def testS2PolylineInitFromS2Points(self):
+    e7_10deg = 0x5f5e100
+    list_points = []
+    for lat, lng in [(0, 0), (0, e7_10deg), (e7_10deg, e7_10deg)]:
+      list_points.append(s2.S2LatLng.FromE7(lat, lng).ToPoint())
+    line = s2.S2Polyline()
+    line.InitFromS2Points(list_points)
+    self.assertAlmostEqual(20.0, line.GetLength().degrees())
+
+  def testS2PolylineUsesValueEquality(self):
+    self.assertEqual(s2.S2Polyline(), s2.S2Polyline())
+
+  def testS2PointsCanBeNormalized(self):
+    line = s2.S2Polyline()
+    line.InitFromS2LatLngs([s2.S2LatLng.FromDegrees(37.794484, -122.394871),
+                            s2.S2LatLng.FromDegrees(37.762699, -122.435158)])
+    self.assertNotAlmostEqual(line.GetCentroid().Norm(), 1.0)
+    self.assertAlmostEqual(line.GetCentroid().Normalize().Norm(), 1.0)
+
+  def testS1AngleComparsionIsWrappedCorrectly(self):
+    ten_degrees = s2.S1Angle.Degrees(10)
+    one_hundred_degrees = s2.S1Angle.Degrees(100)
+    self.assertLess(ten_degrees, one_hundred_degrees)
+    self.assertGreater(one_hundred_degrees, ten_degrees)
+
+  def testS2PolygonIntersectsWithPolyline(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    polygon = s2.S2Polygon(s2.S2Cell(s2.S2CellId(london).parent(15)))
+    line = s2.S2Polyline()
+    line.InitFromS2LatLngs([s2.S2LatLng.FromDegrees(51.5, -0.128),
+                            s2.S2LatLng.FromDegrees(51.5, -0.125)])
+    intersections = polygon.IntersectWithPolyline(line)
+    self.assertEqual(1, len(intersections))
+
+  def testS2PolygonUsesValueEquality(self):
+    self.assertEqual(s2.S2Polygon(), s2.S2Polygon())
+
+  def testCrossingSign(self):
+    a = s2.S2LatLng.FromDegrees(-1, 0).ToPoint()
+    b = s2.S2LatLng.FromDegrees(1, 0).ToPoint()
+    c = s2.S2LatLng.FromDegrees(0, -1).ToPoint()
+    d = s2.S2LatLng.FromDegrees(0, 1).ToPoint()
+    # SWIG flattens namespaces, so this is just s2.CrossingSign,
+    # not s2.S2.CrossingSign.
+    self.assertEqual(1, s2.CrossingSign(a, b, c, d))
+
+  def testGetIntersection(self):
+    a = s2.S2LatLng.FromDegrees(-1, 0).ToPoint()
+    b = s2.S2LatLng.FromDegrees(1, 0).ToPoint()
+    c = s2.S2LatLng.FromDegrees(0, -1).ToPoint()
+    d = s2.S2LatLng.FromDegrees(0, 1).ToPoint()
+    # SWIG namespace flattening as above.
+    intersection = s2.GetIntersection(a, b, c, d)
+    self.assertEqual(
+        "0.000000,0.000000", s2.S2LatLng(intersection).ToStringInDegrees())
+
+  def testS2CellDistance(self):
+    # Level-0 cell (i.e. face) centered at (0, 0)
+    cell = s2.S2Cell(s2.S2CellId(0x1000000000000000))
+
+    p1 = s2.S2LatLng.FromDegrees(0, 0).ToPoint()
+    self.assertTrue(cell.Contains(p1))
+    d1 = cell.GetDistance(p1).ToAngle().degrees()
+    # Inside, so distance is 0, but boundary distance is not.
+    self.assertEqual(0.0, d1)
+    bd1 = cell.GetBoundaryDistance(p1).ToAngle().degrees()
+    self.assertEqual(45.0, bd1)
+
+    p2 = s2.S2LatLng.FromDegrees(0, 90).ToPoint()
+    self.assertFalse(cell.Contains(p2))
+    d2 = cell.GetDistance(p2).ToAngle().degrees()
+    self.assertAlmostEqual(45.0, d2)
+    bd2 = cell.GetBoundaryDistance(p2).ToAngle().degrees()
+    # Outside, so distance and boundary distance are the same.
+    self.assertAlmostEqual(45.0, bd2)
+
+  def testS2Rotate(self):
+    mtv_a = s2.S2LatLng.FromDegrees(37.4402777, -121.9638888).ToPoint()
+    mtv_b = s2.S2LatLng.FromDegrees(37.3613888, -121.9283333).ToPoint()
+    angle = s2.S1Angle.Radians(0.039678)
+    point = s2.Rotate(mtv_a, mtv_b, angle)
+    self.assertEqual("37.439095,-121.967802",
+                     s2.S2LatLng(point).ToStringInDegrees())
+
+  def testS2TurnAngle(self):
+    mtv_a = s2.S2LatLng.FromDegrees(37.4402777, -121.9638888).ToPoint()
+    mtv_b = s2.S2LatLng.FromDegrees(37.3613888, -121.9283333).ToPoint()
+    mtv_c = s2.S2LatLng.FromDegrees(37.3447222, -122.0308333).ToPoint()
+    angle = s2.TurnAngle(mtv_a, mtv_b, mtv_c)
+    self.assertAlmostEqual(-1.7132025, angle)
+
+  def testEncodeDecode(self):
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    polygon = s2.S2Polygon(s2.S2Cell(s2.S2CellId(london).parent(15)))
+    self.assertEqual(polygon.num_loops(), 1)
+
+    encoder = s2.Encoder()
+    polygon.Encode(encoder)
+
+    encoded = encoder.buffer()
+    decoder = s2.Decoder(encoded)
+    decoded_polygon = s2.S2Polygon()
+    self.assertTrue(decoded_polygon.Decode(decoder))
+
+    self.assertEqual(decoded_polygon.num_loops(), 1)
+    self.assertTrue(decoded_polygon.Equals(polygon))
+
+  def testS2CapRegion(self):
+    center = s2.S2LatLng.FromDegrees(2.0, 3.0).ToPoint()
+    cap = s2.S2Cap(center, s2.S1Angle.Degrees(1.0))
+
+    inside = s2.S2LatLng.FromDegrees(2.1, 2.9).ToPoint()
+    outside = s2.S2LatLng.FromDegrees(0.0, 0.0).ToPoint()
+    self.assertTrue(cap.Contains(inside))
+    self.assertFalse(cap.Contains(outside))
+    self.assertTrue(cap.Contains(s2.S2Cell(inside)))
+    self.assertFalse(cap.Contains(s2.S2Cell(outside)))
+    self.assertTrue(cap.MayIntersect(s2.S2Cell(inside)))
+    self.assertFalse(cap.MayIntersect(s2.S2Cell(outside)))
+
+    self.assertTrue(cap.ApproxEquals(cap.GetCapBound()))
+
+    rect_bound = cap.GetRectBound()
+    self.assertTrue(rect_bound.Contains(inside))
+    self.assertFalse(rect_bound.Contains(outside))
+
+  def testS2LatLngRectRegion(self):
+    rect = s2.S2LatLngRect(s2.S2LatLng.FromDegrees(1.0, 2.0),
+                           s2.S2LatLng.FromDegrees(3.0, 4.0))
+
+    inside = s2.S2LatLng.FromDegrees(2.0, 3.0).ToPoint()
+    outside = s2.S2LatLng.FromDegrees(0.0, 0.0).ToPoint()
+
+    self.assertTrue(rect.Contains(inside))
+    self.assertFalse(rect.Contains(outside))
+    self.assertTrue(rect.Contains(s2.S2Cell(inside)))
+    self.assertFalse(rect.Contains(s2.S2Cell(outside)))
+    self.assertTrue(rect.MayIntersect(s2.S2Cell(inside)))
+    self.assertFalse(rect.MayIntersect(s2.S2Cell(outside)))
+
+    cap_bound = rect.GetCapBound()
+    self.assertTrue(cap_bound.Contains(inside))
+    self.assertFalse(cap_bound.Contains(outside))
+
+    self.assertTrue(rect.ApproxEquals(rect.GetRectBound()))
+
+  def testS2CellRegion(self):
+    cell = s2.S2Cell(s2.S2CellId(s2.S2LatLng.FromDegrees(3.0, 4.0)).parent(8))
+
+    inside = s2.S2LatLng.FromDegrees(3.0, 4.0).ToPoint()
+    outside = s2.S2LatLng.FromDegrees(30.0, 40.0).ToPoint()
+
+    self.assertTrue(cell.Contains(inside))
+    self.assertFalse(cell.Contains(outside))
+    self.assertTrue(cell.Contains(s2.S2Cell(inside)))
+    self.assertFalse(cell.Contains(s2.S2Cell(outside)))
+    self.assertTrue(cell.MayIntersect(s2.S2Cell(inside)))
+    self.assertFalse(cell.MayIntersect(s2.S2Cell(outside)))
+
+    cap_bound = cell.GetCapBound()
+    self.assertTrue(cap_bound.Contains(inside))
+    self.assertFalse(cap_bound.Contains(outside))
+
+    rect_bound = cell.GetRectBound()
+    self.assertTrue(rect_bound.Contains(inside))
+    self.assertFalse(rect_bound.Contains(outside))
+
+  def testS2CellUnionRegion(self):
+    cell_id = s2.S2CellId(s2.S2LatLng.FromDegrees(3.0, 4.0)).parent(8)
+    cell_union = s2.S2CellUnion()
+    cell_union.Init([cell_id.id()])
+
+    inside = s2.S2LatLng.FromDegrees(3.0, 4.0).ToPoint()
+    outside = s2.S2LatLng.FromDegrees(30.0, 40.0).ToPoint()
+
+    self.assertTrue(cell_union.Contains(inside))
+    self.assertFalse(cell_union.Contains(outside))
+    self.assertTrue(cell_union.Contains(s2.S2Cell(inside)))
+    self.assertFalse(cell_union.Contains(s2.S2Cell(outside)))
+    self.assertTrue(cell_union.MayIntersect(s2.S2Cell(inside)))
+    self.assertFalse(cell_union.MayIntersect(s2.S2Cell(outside)))
+
+    cap_bound = cell_union.GetCapBound()
+    self.assertTrue(cap_bound.Contains(inside))
+    self.assertFalse(cap_bound.Contains(outside))
+
+    rect_bound = cell_union.GetRectBound()
+    self.assertTrue(rect_bound.Contains(inside))
+    self.assertFalse(rect_bound.Contains(outside))
+
+  def testS2CellUnionEmpty(self):
+    empty_cell_union = s2.S2CellUnion()
+    self.assertTrue(empty_cell_union.empty())
+
+    cell_id = s2.S2CellId(s2.S2LatLng.FromDegrees(3.0, 4.0)).parent(8)
+    cell_union = s2.S2CellUnion()
+    cell_union.Init([cell_id.id()])
+    self.assertFalse(cell_union.empty())
+
+  def testS2CellUnionIntersectionWithS2CellUnion(self):
+    cell_id = s2.S2CellId(s2.S2LatLng.FromDegrees(3.0, 4.0))
+    cell_union = s2.S2CellUnion()
+    cell_union.Init([cell_id.id()])
+
+    # No intersection.
+    outside_cell_id = s2.S2CellId(s2.S2LatLng.FromDegrees(5.0, 6.0))
+    outside_cell_union = s2.S2CellUnion()
+    outside_cell_union.Init([outside_cell_id.id()])
+    empty_intersection = cell_union.Intersection(outside_cell_union)
+    self.assertTrue(empty_intersection.empty())
+
+    # Complete overlap.
+    self_intersection = cell_union.Intersection(cell_union)
+    self.assertTrue(self_intersection.Contains(cell_union))
+    self.assertTrue(cell_union.Contains(self_intersection))
+
+    # Some intersection.
+    joint_cell_union = s2.S2CellUnion()
+    joint_cell_union.Init([cell_id.id(), outside_cell_id.id()])
+    outside_intersection = joint_cell_union.Intersection(outside_cell_union)
+    self.assertTrue(outside_intersection.Contains(outside_cell_id))
+    self.assertFalse(outside_intersection.Contains(cell_id))
+
+  def testS2CellUnionIntersectionWithS2CellId(self):
+    cell_id = s2.S2CellId(s2.S2LatLng.FromDegrees(3.0, 4.0))
+    cell_union = s2.S2CellUnion()
+    cell_union.Init([cell_id.id()])
+
+    # No intersection.
+    outside_cell_id = s2.S2CellId(s2.S2LatLng.FromDegrees(4.0, 5.0))
+    empty_intersection = cell_union.Intersection(outside_cell_id)
+    self.assertTrue(empty_intersection.empty())
+
+    # Complete overlap.
+    intersection = cell_union.Intersection(cell_id)
+    self.assertTrue(intersection.Contains(cell_id))
+
+    # Some intersection.
+    joint_cell_union = s2.S2CellUnion()
+    joint_cell_union.Init([cell_id.id(), outside_cell_id.id()])
+    outside_intersection = joint_cell_union.Intersection(outside_cell_id)
+    self.assertTrue(outside_intersection.Contains(outside_cell_id))
+    self.assertFalse(outside_intersection.Contains(cell_id))
+
+  def testS2CellUnionIsNormalized(self):
+    empty_cell_union = s2.S2CellUnion()
+    self.assertTrue(empty_cell_union.IsNormalized())
+
+    london = s2.S2LatLng.FromDegrees(51.5001525, -0.1262355)
+    london_cell_id = s2.S2CellId(london)
+    normalized_union = s2.S2CellUnion()
+    normalized_union.Init([london_cell_id.id()])
+    self.assertTrue(normalized_union.IsNormalized())
+
+  def testS2CellUnionNormalizeS2CellUnion(self):
+    empty_cell_union = s2.S2CellUnion()
+    empty_cell_union.NormalizeS2CellUnion()
+    self.assertTrue(empty_cell_union.IsNormalized())
+
+    cell_id = s2.S2CellId(s2.S2LatLng.FromDegrees(3.0, 4.0)).parent(8)
+    cell_union = s2.S2CellUnion()
+    cell_union.Init([cell_id.id()])
+    cell_union.NormalizeS2CellUnion()
+    self.assertTrue(cell_union.IsNormalized())
+
+  def testS2LoopRegion(self):
+    cell = s2.S2Cell(s2.S2CellId(s2.S2LatLng.FromDegrees(3.0, 4.0)).parent(8))
+    loop = s2.S2Loop(cell)
+
+    inside = s2.S2LatLng.FromDegrees(3.0, 4.0).ToPoint()
+    outside = s2.S2LatLng.FromDegrees(30.0, 40.0).ToPoint()
+
+    self.assertTrue(loop.Contains(inside))
+    self.assertFalse(loop.Contains(outside))
+    self.assertTrue(loop.Contains(s2.S2Cell(inside)))
+    self.assertFalse(loop.Contains(s2.S2Cell(outside)))
+    self.assertTrue(loop.MayIntersect(s2.S2Cell(inside)))
+    self.assertFalse(loop.MayIntersect(s2.S2Cell(outside)))
+
+    cap_bound = loop.GetCapBound()
+    self.assertTrue(cap_bound.Contains(inside))
+    self.assertFalse(cap_bound.Contains(outside))
+
+    rect_bound = loop.GetRectBound()
+    self.assertTrue(rect_bound.Contains(inside))
+    self.assertFalse(rect_bound.Contains(outside))
+
+  def testS2PolygonRegion(self):
+    cell = s2.S2Cell(s2.S2CellId(s2.S2LatLng.FromDegrees(3.0, 4.0)).parent(8))
+    polygon = s2.S2Polygon(cell)
+
+    inside = s2.S2LatLng.FromDegrees(3.0, 4.0).ToPoint()
+    outside = s2.S2LatLng.FromDegrees(30.0, 40.0).ToPoint()
+
+    self.assertTrue(polygon.Contains(inside))
+    self.assertFalse(polygon.Contains(outside))
+    self.assertTrue(polygon.Contains(s2.S2Cell(inside)))
+    self.assertFalse(polygon.Contains(s2.S2Cell(outside)))
+    self.assertTrue(polygon.MayIntersect(s2.S2Cell(inside)))
+    self.assertFalse(polygon.MayIntersect(s2.S2Cell(outside)))
+
+    cap_bound = polygon.GetCapBound()
+    self.assertTrue(cap_bound.Contains(inside))
+    self.assertFalse(cap_bound.Contains(outside))
+
+    rect_bound = polygon.GetRectBound()
+    self.assertTrue(rect_bound.Contains(inside))
+    self.assertFalse(rect_bound.Contains(outside))
+
+  def testS2PolylineRegion(self):
+    polyline = s2.S2Polyline()
+    polyline.InitFromS2LatLngs([s2.S2LatLng.FromDegrees(0.0, 0.0),
+                                s2.S2LatLng.FromDegrees(1.0, 1.0)])
+
+    # Contains(S2Point) always return false.
+    self.assertFalse(
+        polyline.Contains(s2.S2LatLng.FromDegrees(0.0, 0.0).ToPoint()))
+    self.assertFalse(
+        polyline.Contains(s2.S2Cell(s2.S2LatLng.FromDegrees(0.0, 0.0))))
+
+    self.assertTrue(
+        polyline.MayIntersect(s2.S2Cell(s2.S2LatLng.FromDegrees(0.0, 0.0))))
+    self.assertFalse(
+        polyline.MayIntersect(s2.S2Cell(s2.S2LatLng.FromDegrees(3.0, 4.0))))
+
+    cap_bound = polyline.GetCapBound()
+    self.assertTrue(
+        cap_bound.Contains(s2.S2LatLng.FromDegrees(0.0, 0.0).ToPoint()))
+    self.assertFalse(
+        cap_bound.Contains(s2.S2LatLng.FromDegrees(2.0, 2.0).ToPoint()))
+
+    rect_bound = polyline.GetRectBound()
+    self.assertTrue(
+        rect_bound.Contains(s2.S2LatLng.FromDegrees(0.0, 0.0).ToPoint()))
+    self.assertFalse(
+        rect_bound.Contains(s2.S2LatLng.FromDegrees(2.0, 2.0).ToPoint()))
+
+  def testS2CellIdCenterSiTi(self):
+    cell = s2.S2CellId.FromFacePosLevel(3, 0x12345678, s2.S2CellId.kMaxLevel)
+
+    # Check that the (si, ti) coordinates of the center end in a
+    # 1 followed by (30 - level) 0s.
+
+    # Leaf level, 30.
+    face, si, ti = cell.GetCenterSiTi()
+    self.assertEqual(3, face)
+    self.assertEqual(1 << 0, si & 1)
+    self.assertEqual(1 << 0, ti & 1)
+
+    # Level 29.
+    face, si, ti = cell.parent(s2.S2CellId.kMaxLevel - 1).GetCenterSiTi()
+    self.assertEqual(3, face)
+    self.assertEqual(1 << 1, si & 3)
+    self.assertEqual(1 << 1, ti & 3)
+
+    # Level 28.
+    face, si, ti = cell.parent(s2.S2CellId.kMaxLevel - 2).GetCenterSiTi()
+    self.assertEqual(3, face)
+    self.assertEqual(1 << 2, si & 7)
+    self.assertEqual(1 << 2, ti & 7)
+
+    # Level 20.
+    face, si, ti = cell.parent(s2.S2CellId.kMaxLevel - 10).GetCenterSiTi()
+    self.assertEqual(3, face)
+    self.assertEqual(1 << 10, si & ((1 << 11) - 1))
+    self.assertEqual(1 << 10, ti & ((1 << 11) - 1))
+
+    # Level 10.
+    face, si, ti = cell.parent(s2.S2CellId.kMaxLevel - 20).GetCenterSiTi()
+    self.assertEqual(3, face)
+    self.assertEqual(1 << 20, si & ((1 << 21) - 1))
+    self.assertEqual(1 << 20, ti & ((1 << 21) - 1))
+
+    # Level 0.
+    face, si, ti = cell.parent(0).GetCenterSiTi()
+    self.assertEqual(3, face)
+    self.assertEqual(1 << 30, si & ((1 << 31) - 1))
+    self.assertEqual(1 << 30, ti & ((1 << 31) - 1))
+
+  def testS2CellIdToFromFaceIJ(self):
+    cell = s2.S2CellId.FromFaceIJ(3, 1234, 5678)
+    face, i, j, _ = cell.ToFaceIJOrientation()
+    self.assertEqual(3, face)
+    self.assertEqual(1234, i)
+    self.assertEqual(5678, j)
+
+  def testS2EarthMetricRadians(self):
+    radius_rad = s2.S2Earth.KmToRadians(12.34)
+    self.assertAlmostEqual(radius_rad, 0.0019368985451286374)
+    angle = s2.S1Angle.Radians(radius_rad)
+    radius_m = s2.S2Earth.RadiansToMeters(angle.radians())
+    self.assertEqual(radius_m, 12340.0)
+
+
+class RegionTermIndexerTest(unittest.TestCase):
+  def _randomCaps(self, query_type, **indexer_options):
+    # This function creates an index consisting either of points (if
+    # options.index_contains_points_only() is true) or S2Caps of random size.
+    # It then executes queries consisting of points (if query_type == POINT)
+    # or S2Caps of random size (if query_type == CAP).
+    #
+    # indexer_options are set on both the indexer & coverer (if relevant)
+    # eg. _randomCaps('cap', min_level=0) calls indexer.set_min_level(0)
+    ITERATIONS = 400
+
+    indexer = s2.S2RegionTermIndexer()
+    coverer = s2.S2RegionCoverer()
+
+    # set indexer options
+    for opt_key, opt_value in indexer_options.items():
+      setter = "set_%s" % opt_key
+      getattr(indexer, setter)(opt_value)
+      if hasattr(coverer, setter):
+        getattr(coverer, setter)(opt_value)
+
+    caps = []
+    coverings = []
+    index = defaultdict(set)
+
+    index_terms = 0
+    query_terms = 0
+    for i in range(ITERATIONS):
+      # Choose the region to be indexed: either a single point or a cap
+      # of random size (up to a full sphere).
+      terms = []
+      if indexer.index_contains_points_only():
+        cap = s2.S2Cap.FromPoint(s2.S2Testing.RandomPoint())
+        terms = indexer.GetIndexTerms(cap.center(), "")
+      else:
+        cap = s2.S2Testing.GetRandomCap(
+          0.3 * s2.S2Cell.AverageArea(indexer.max_level()),
+          4.0 * s2.S2Cell.AverageArea(indexer.min_level())
+        )
+        terms = indexer.GetIndexTerms(cap, "")
+
+      caps.append(cap)
+      coverings.append(s2.S2CellUnion(coverer.GetCovering(cap)))
+      for term in terms:
+        index[term].add(i)
+
+      index_terms += len(terms)
+
+    for i in range(ITERATIONS):
+      # Choose the region to be queried: either a random point or a cap of
+      # random size.
+      terms = []
+
+      if query_type == 'cap':
+        cap = s2.S2Cap.FromPoint(s2.S2Testing.RandomPoint())
+        terms = indexer.GetQueryTerms(cap.center(), "")
+      else:
+        cap = s2.S2Testing.GetRandomCap(
+          0.3 * s2.S2Cell.AverageArea(indexer.max_level()),
+          4.0 * s2.S2Cell.AverageArea(indexer.min_level())
+        )
+        terms = indexer.GetQueryTerms(cap, "")
+
+      # Compute the expected results of the S2Cell query by brute force.
+      covering = s2.S2CellUnion(coverer.GetCovering(cap))
+      expected, actual = set(), set()
+      for j in range(len(caps)):
+        if covering.Intersects(coverings[j]):
+          expected.add(j)
+      
+      for term in terms:
+        actual |= index[term]
+
+      self.assertEqual(expected, actual)
+      query_terms += len(terms)
+
+      print("Index terms/doc: %0.2f, Query terms/doc: %0.2f" % (
+        float(index_terms) / ITERATIONS,
+        float(query_terms) / ITERATIONS)
+      )
+
+  # We run one test case for each combination of space vs. time optimization,
+  # and indexing regions vs. only points.
+
+  def testIndexRegionsQueryRegionsOptimizeTime(self):
+    self._randomCaps("cap",
+      optimize_for_space=False,
+      min_level=0,
+      max_level=16,
+      max_cells=20,
+    )
+
+  def testIndexRegionsQueryPointsOptimizeTime(self):
+    self._randomCaps("point",
+      optimize_for_space=False,
+      min_level=0,
+      max_level=16,
+      max_cells=20,
+    )
+
+  def testIndexRegionsQueryRegionsOptimizeTimeWithLevelMod(self):
+    self._randomCaps("cap",
+      optimize_for_space=False,
+      min_level=6,
+      max_level=12,
+      level_mod=3,
+    )
+
+  def testIndexRegionsQueryRegionsOptimizeSpace(self):
+    self._randomCaps("cap",
+      optimize_for_space=True,
+      min_level=4,
+      max_level=s2.S2CellId.kMaxLevel,
+      max_cells=8,
+    )
+
+  def testIndexPointsQueryRegionsOptimizeTime(self):
+    self._randomCaps("cap",
+      optimize_for_space=False,
+      min_level=0,
+      max_level=s2.S2CellId.kMaxLevel,
+      level_mod=2,
+      max_cells=20,
+      index_contains_points_only=True,
+    )
+
+  def testIndexPointsQueryRegionsOptimizeSpace(self):
+    self._randomCaps("cap",
+      optimize_for_space=True,
+      index_contains_points_only=True,
+    )
+
+  def testMaxLevelSetLoosely(self):
+    # Test that correct terms are generated even when (max_level - min_level)
+    # is not a multiple of level_mod.
+    indexer1 = s2.S2RegionTermIndexer()
+    indexer1.set_min_level(1)
+    indexer1.set_level_mod(2)
+    indexer1.set_max_level(19)
+
+    indexer2 = s2.S2RegionTermIndexer()
+    indexer2.set_min_level(1)
+    indexer2.set_level_mod(2)
+    indexer2.set_max_level(19)
+    indexer2.set_max_level(20)
+
+    point = s2.S2Testing.RandomPoint()
+
+    self.assertEqual(
+      indexer1.GetIndexTerms(point, ""),
+      indexer2.GetIndexTerms(point, "")
+    )
+    self.assertEqual(
+      indexer1.GetQueryTerms(point, ""),
+      indexer2.GetQueryTerms(point, "")
+    )
+
+    cap = s2.S2Testing.GetRandomCap(0.0, 1.0)
+    self.assertEqual(
+      indexer1.GetIndexTerms(cap, ""),
+      indexer2.GetIndexTerms(cap, "")
+    )
+    self.assertEqual(
+      indexer1.GetQueryTerms(cap, ""),
+      indexer2.GetQueryTerms(cap, "")
+    )
+
+
+if __name__ == "__main__":
+  unittest.main()