Merge branch 'google3'

New functionality:
* Add function S2ShapeIndex Dump function
* Add Init to Graph nested classes
* S2Polygon::InitToOperation: Propagate S2Error

Bug fixes:
* Fix S2BooleanOperation empty/full handling
* Minor compilation fixes for nacl
* Fix LaxPolygonLayer bug
* Fix rare bug in S2BooleanOperation
* Fix rare bug in VisitCrossingEdgePairs
* Fix UB discovered by -D_GLIBCXX_DEBUG
* S2Cap::Add: Fix bug with empty other cap
* OwningShape: Fix potential memory leak
* S2Builder: Clear layer_is_full_polygon_predicates_
* S2EdgeTesselator: Improve error estimation

Author: jmr

CMakeLists.txt

@@ -233,6 +233,7 @@ install(FILES src/s2/_fp_contract_off.h
               src/s2/s2builder_layer.h
               src/s2/s2builderutil_closed_set_normalizer.h
               src/s2/s2builderutil_find_polygon_degeneracies.h
+              src/s2/s2builderutil_graph_shape.h
               src/s2/s2builderutil_lax_polygon_layer.h
               src/s2/s2builderutil_s2point_vector_layer.h
               src/s2/s2builderutil_s2polygon_layer.h

doc/examples/term_index.cc

@@ -39,6 +39,7 @@ int main(int argc, char **argv) {
   // region types include polygons, polylines, rectangles, discs, buffered
   // geometry, etc.)
   std::vector<S2Point> documents;
+  documents.reserve(FLAGS_num_documents);
   for (int docid = 0; docid < FLAGS_num_documents; ++docid) {
     documents.push_back(S2Testing::RandomPoint());
   }

src/python/pywraps2_test.py

@@ -138,6 +138,31 @@ def testS2PolygonGetAreaIsWrappedCorrectly(self):
     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)))

src/python/s2_common.i

@@ -37,6 +37,11 @@
   $1 = temp;
 }
 
+// For S2Polygon::GetOverlapFractions
+%typemap(out) std::pair<double, double> {
+  $result = Py_BuildValue("dd", $1.first, $1.second);
+}
+
 %typemap(argout) S2CellId *OUTPUT_ARRAY_4 {
   $result = PyList_New(4);
   if ($result == nullptr) return nullptr;
@@ -447,6 +452,7 @@ class S2Point {
 %unignore S2Polygon::GetCapBound() const;
 %unignore S2Polygon::GetCentroid;
 %unignore S2Polygon::GetDistance;
+%unignore S2Polygon::GetOverlapFractions(const S2Polygon*, const S2Polygon*);
 %unignore S2Polygon::GetRectBound;
 %unignore S2Polygon::Init;
 %unignore S2Polygon::InitNested;

src/s2/base/port.h

@@ -16,9 +16,6 @@
 #ifndef S2_BASE_PORT_H_
 #define S2_BASE_PORT_H_
 
-// Users should still #include "base/port.h".  Code in //third_party/absl/base
-// is not visible for general use.
-//
 // This file contains things that are not used in third_party/absl but needed by
 // - Platform specific requirement
 //   - MSVC
@@ -39,7 +36,7 @@
 
 #include "s2/base/integral_types.h"
 #include "s2/third_party/absl/base/config.h"
-#include "s2/third_party/absl/base/port.h"  // IWYU pragma: export
+#include "s2/third_party/absl/base/port.h"
 
 #ifdef SWIG
 %include "third_party/absl/base/port.h"
@@ -892,21 +889,20 @@ inline void UnalignedCopy64(const void *src, void *dst) {
       !defined(SWIG)) ||                                                \
      ((__GNUC__ >= 3 || defined(__clang__)) && defined(__ANDROID__)) || \
      defined(__ASYLO__))
-inline void *aligned_malloc(size_t size, int minimum_alignment) {
+inline void *aligned_malloc(size_t size, size_t minimum_alignment) {
 #if defined(__ANDROID__) || defined(OS_ANDROID) || defined(__ASYLO__)
   return memalign(minimum_alignment, size);
 #else  // !__ANDROID__ && !OS_ANDROID && !__ASYLO__
-  void *ptr = nullptr;
   // posix_memalign requires that the requested alignment be at least
   // sizeof(void*). In this case, fall back on malloc which should return memory
   // aligned to at least the size of a pointer.
-  const int required_alignment = sizeof(void*);
+  const size_t required_alignment = sizeof(void*);
   if (minimum_alignment < required_alignment)
     return malloc(size);
-  if (posix_memalign(&ptr, static_cast<size_t>(minimum_alignment), size) != 0)
-    return nullptr;
-  else
+  void *ptr = nullptr;
+  if (posix_memalign(&ptr, minimum_alignment, size) == 0)
     return ptr;
+  return nullptr;
 #endif
 }
 
@@ -916,7 +912,7 @@ inline void aligned_free(void *aligned_memory) {
 
 #elif defined(_MSC_VER)  // MSVC
 
-inline void *aligned_malloc(size_t size, int minimum_alignment) {
+inline void *aligned_malloc(size_t size, size_t minimum_alignment) {
   return _aligned_malloc(size, minimum_alignment);
 }
 

src/s2/encoded_string_vector.cc

@@ -30,8 +30,9 @@ StringVectorEncoder::StringVectorEncoder() {
 void StringVectorEncoder::Encode(Encoder* encoder) {
   offsets_.push_back(data_.length());
   // We don't encode the first element of "offsets_", which is always zero.
-  EncodeUintVector<uint64>(MakeSpan(offsets_.data() + 1, &*offsets_.end()),
-                                    encoder);
+  EncodeUintVector<uint64>(
+      MakeSpan(offsets_.data() + 1, offsets_.data() + offsets_.size()),
+      encoder);
   encoder->Ensure(data_.length());
   encoder->putn(data_.base(), data_.length());
 }

src/s2/mutable_s2shape_index.cc

@@ -856,7 +856,7 @@ inline void MutableS2ShapeIndex::AddFaceEdge(
   // Otherwise we simply clip the edge to all six faces.
   for (int face = 0; face < 6; ++face) {
     if (S2::ClipToPaddedFace(edge->edge.v0, edge->edge.v1, face,
-                                     kCellPadding, &edge->a, &edge->b)) {
+                             kCellPadding, &edge->a, &edge->b)) {
       all_edges[face].push_back(*edge);
     }
   }
@@ -1329,9 +1329,8 @@ void MutableS2ShapeIndex::AbsorbIndexCell(const S2PaddedCell& pcell,
       edge.edge = shape->edge(e);
       edge.max_level = GetEdgeMaxLevel(edge.edge);
       if (edge.has_interior) tracker->TestEdge(shape_id, edge.edge);
-      if (!S2::ClipToPaddedFace(edge.edge.v0, edge.edge.v1,
-                                        pcell.id().face(), kCellPadding,
-                                        &edge.a, &edge.b)) {
+      if (!S2::ClipToPaddedFace(edge.edge.v0, edge.edge.v1, pcell.id().face(),
+                                kCellPadding, &edge.a, &edge.b)) {
         S2_LOG(DFATAL) << "Invariant failure in MutableS2ShapeIndex";
       }
       face_edges->push_back(edge);

src/s2/mutable_s2shape_index_test.cc

@@ -499,7 +499,7 @@ void LazyUpdatesTest::ReaderThread() {
     lock_.Unlock();
     for (MutableS2ShapeIndex::Iterator it(&index_, S2ShapeIndex::BEGIN);
          !it.done(); it.Next()) {
-      continue;
+      continue;  // NOLINT
     }
     lock_.Lock();
     if (--num_readers_left_ == 0) {

src/s2/s1angle.h

@@ -111,7 +111,9 @@ class S1Angle {
   // Return the angle between two points, which is also equal to the distance
   // between these points on the unit sphere.  The points do not need to be
   // normalized.  This function has a maximum error of 3.25 * DBL_EPSILON (or
-  // 2.5 * DBL_EPSILON for angles up to 1 radian).
+  // 2.5 * DBL_EPSILON for angles up to 1 radian). If either point is
+  // zero-length (e.g. an uninitialized S2Point), or almost zero-length, the
+  // resulting angle will be zero.
   S1Angle(const S2Point& x, const S2Point& y);
 
   // Like the constructor above, but return the angle (i.e., distance) between