h3 3.6.0 → 3.6.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4344398c78a4d188c270838673195d9e16e1a400ab157ec34fa45a006fc17c2b
-  data.tar.gz: 0ee405d8aefdb3fa062079903ae586da85598b2a12e87c4b029c11aa3d1c73f2
+  metadata.gz: 32f9595b2e8746f59aaef1c082fc3527a7eb3d7594d7eac1a59cb5875df6af3d
+  data.tar.gz: 8fd9c4ed2317a0211b4d3fa6360aede580bff5db691605b7fdd33b299720ba3f
 SHA512:
-  metadata.gz: c385c0805d7b8e59c2610048ff71aacaf9e4b5a8aae21385a36ae42d47f036eab812296752ff108146655ed2fc1b87800246889d3393bf1a6940dfce43e34a4e
-  data.tar.gz: f8aeaf98281a57718266fb5eb259d269e1dbf4804c02fb0af25327c39594084eba87fbdb504446066330b5c57368aaedab856c45bf0a437726fd6d95d7b159b0
+  metadata.gz: 4e0a51a2bdcf92096406af99d3823359768b99291f96be9ac6d113363c09efb71513cf09944eca1155549b63bbab4c628e2a6f89f8d77817df4029155375072e
+  data.tar.gz: 1c672e3d6d2262dee4bae5bf65587a870c9053b1815ec7ee34798fae228aed5bd338d57883ebb594f81b6c959006af86c460ddca473e4db401631e2400a11dcd

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    h3 (3.6.0)
+    h3 (3.6.1)
       ffi (~> 1.9)
       rgeo-geojson (~> 2.1)
       zeitwerk (~> 2.1)
@@ -17,10 +17,10 @@ GEM
       tins (~> 1.6)
     diff-lcs (1.3)
     docile (1.3.1)
-    ffi (1.11.1)
+    ffi (1.11.2)
     json (2.1.0)
     rake (12.3.2)
-    rgeo (2.1.0)
+    rgeo (2.1.1)
     rgeo-geojson (2.1.1)
       rgeo (>= 1.0.0)
     rspec (3.8.0)
@@ -46,7 +46,7 @@ GEM
     thor (0.19.4)
     tins (1.20.2)
     yard (0.9.20)
-    zeitwerk (2.1.9)
+    zeitwerk (2.2.1)
 
 PLATFORMS
   ruby

data/ext/h3/src/CHANGELOG.md

@@ -7,6 +7,13 @@ The public API of this library consists of the functions declared in file
 
 ## [Unreleased]
 
+## [3.6.1] - 2019-11-11
+### Fixed
+- `compact` handles zero length input correctly. (#278)
+- `bboxHexRadius` scaling factor adjusted to guarantee containment for `polyfill`. (#279)
+- `polyfill` new algorithm for up to 3x perf boost. (#282)
+- Fix CMake targets for KML generation. (#285)
+
 ## [3.6.0] - 2019-08-12
 ### Added
 - `h3ToCenterChild` function to find center child at given resolution (#267)

data/ext/h3/src/CMakeLists.txt

@@ -143,6 +143,7 @@ set(OTHER_SOURCE_FILES
     src/apps/testapps/testVertexGraph.c
     src/apps/testapps/testCompact.c
     src/apps/testapps/testPolyfill.c
+    src/apps/testapps/testPolyfill_GH136.c
     src/apps/testapps/testPentagonIndexes.c
     src/apps/testapps/testKRing.c
     src/apps/testapps/testH3ToGeoBoundary.c
@@ -349,11 +350,11 @@ if(BUILD_FILTERS)
         set_property(DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES "KML/res${resolution}cells.kml")
         set_property(DIRECTORY APPEND PROPERTY ADDITIONAL_MAKE_CLEAN_FILES "KML/res${resolution}centers.kml")
         add_custom_target(kml_cells_${resolution}
-            COMMAND ${SHELL} "$<TARGET_FILE:h3ToHier> ${resolution} | $<TARGET_FILE:h3ToGeoBoundary> 1 res${resolution}cells.kml \"Res ${resolution} Cells\" > KML/res${resolution}cells.kml"
+            COMMAND ${SHELL} "$<TARGET_FILE:h3ToHier> -r ${resolution} | $<TARGET_FILE:h3ToGeoBoundary> --kml --kml-name res${resolution}cells.kml --kml-description \"Res ${resolution} Cells\" > KML/res${resolution}cells.kml"
             VERBATIM
             DEPENDS create-kml-dir)
         add_custom_target(kml_centers_${resolution}
-            COMMAND ${SHELL} "$<TARGET_FILE:h3ToHier> ${resolution} | $<TARGET_FILE:h3ToGeo> 1 res${resolution}centers.kml \"Res ${resolution} Centers\" > KML/res${resolution}centers.kml"
+            COMMAND ${SHELL} "$<TARGET_FILE:h3ToHier> -r ${resolution} | $<TARGET_FILE:h3ToGeo> --kml --kml-name res${resolution}centers.kml --kml-description \"Res ${resolution} Centers\" > KML/res${resolution}centers.kml"
             VERBATIM
             DEPENDS create-kml-dir)
         add_dependencies(kml
@@ -506,6 +507,7 @@ if(BUILD_TESTING)
     add_h3_test(testH3SetToVertexGraph src/apps/testapps/testH3SetToVertexGraph.c)
     add_h3_test(testLinkedGeo src/apps/testapps/testLinkedGeo.c)
     add_h3_test(testPolyfill src/apps/testapps/testPolyfill.c)
+    add_h3_test(testPolyfill_GH136 src/apps/testapps/testPolyfill_GH136.c)
     add_h3_test(testVertexGraph src/apps/testapps/testVertexGraph.c)
     add_h3_test(testH3UniEdge src/apps/testapps/testH3UniEdge.c)
     add_h3_test(testGeoCoord src/apps/testapps/testGeoCoord.c)

data/ext/h3/src/README.md

@@ -1,4 +1,4 @@
-<img align="right" src="https://uber.github.io/res/h3Logo-color.svg" alt="H3 Logo" width="200">
+<img align="right" src="https://uber.github.io/img/h3Logo-color.svg" alt="H3 Logo" width="200">
 
 # H3: A Hexagonal Hierarchical Geospatial Indexing System
 

data/ext/h3/src/VERSION

@@ -1 +1 @@
-3.6.0
+3.6.1

data/ext/h3/src/docs/community/bindings.md

@@ -2,6 +2,10 @@
 
 As a C library, bindings can be made to call H3 functions from different programming languages. This page lists different bindings currently available. Contributions to this list are welcome, please feel free to open a [pull request](https://github.com/uber/h3/tree/master/docs/community/bindings.md).
 
+## BigQuery
+  
+- [cartodb/bigquery-jslibs](https://github.com/CartoDB/bigquery-jslibs)
+
 ## C#
 
 - [entrepreneur-interet-general/h3.standard](https://github.com/entrepreneur-interet-general/H3.Standard)

data/ext/h3/src/src/apps/testapps/testCompact.c

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 Uber Technologies, Inc.
+ * Copyright 2017-2019 Uber Technologies, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -152,6 +152,31 @@ SUITE(compact) {
                  "compact fails on duplicate input");
     }
 
+    TEST(compact_empty) {
+        t_assert(H3_EXPORT(compact)(NULL, NULL, 0) == 0,
+                 "compact succeeds on empty input");
+    }
+
+    TEST(compact_disparate) {
+        // Exercises a case where compaction needs to be tested but none is
+        // possible
+        const int numHex = 7;
+        H3Index disparate[] = {0, 0, 0, 0, 0, 0, 0};
+        for (int i = 0; i < numHex; i++) {
+            setH3Index(&disparate[i], 1, i, CENTER_DIGIT);
+        }
+        H3Index output[] = {0, 0, 0, 0, 0, 0, 0};
+
+        t_assert(H3_EXPORT(compact)(disparate, output, numHex) == 0,
+                 "compact succeeds on disparate input");
+
+        // Assumes that `output` is an exact copy of `disparate`, including
+        // the ordering (which may not necessarily be the case)
+        for (int i = 0; i < numHex; i++) {
+            t_assert(disparate[i] == output[i], "output set equals input set");
+        }
+    }
+
     TEST(uncompact_wrongRes) {
         int numHex = 3;
         H3Index someHexagons[] = {0, 0, 0};
@@ -221,6 +246,13 @@ SUITE(compact) {
         free(result);
     }
 
+    TEST(uncompact_empty) {
+        int uncompactSz = H3_EXPORT(maxUncompactSize)(NULL, 0, 0);
+        t_assert(uncompactSz == 0, "maxUncompactSize accepts empty input");
+        t_assert(H3_EXPORT(uncompact)(NULL, 0, NULL, 0, 0) == 0,
+                 "uncompact accepts empty input");
+    }
+
     TEST(uncompact_onlyZero) {
         // maxUncompactSize and uncompact both permit 0 indexes
         // in the input array, and skip them. When only a zero is
@@ -237,7 +269,7 @@ SUITE(compact) {
         free(children);
     }
 
-    TEST(uncompactZero) {
+    TEST(uncompact_withZero) {
         // maxUncompactSize and uncompact both permit 0 indexes
         // in the input array, and skip them.
 

data/ext/h3/src/src/apps/testapps/testGeoCoord.c

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 Uber Technologies, Inc.
+ * Copyright 2017-2019 Uber Technologies, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -168,6 +168,18 @@ SUITE(geoCoord) {
         t_assert(_geoDistRads(&start, &out) < 0.01, "moved back to origin");
     }
 
+    TEST(_geoDistRads_wrappedLongitude) {
+        const GeoCoord negativeLongitude = {.lat = 0, .lon = -(M_PI + M_PI_2)};
+        const GeoCoord zero = {.lat = 0, .lon = 0};
+
+        t_assert(fabs(M_PI_2 - _geoDistRads(&negativeLongitude, &zero)) <
+                     EPSILON_RAD,
+                 "Distance with wrapped longitude");
+        t_assert(fabs(M_PI_2 - _geoDistRads(&zero, &negativeLongitude)) <
+                     EPSILON_RAD,
+                 "Distance with wrapped longitude and swapped arguments");
+    }
+
     TEST(doubleConstants) {
         // Simple checks for ordering of values
         testDecreasingFunction(H3_EXPORT(hexAreaKm2), "hexAreaKm2 ordering");

data/ext/h3/src/src/apps/testapps/testH3ToLocalIj.c

@@ -86,10 +86,12 @@ SUITE(h3ToLocalIj) {
     }
 
     TEST(ijOutOfRange) {
-        const int numCoords = 5;
-        const CoordIJ coords[] = {{0, 0}, {1, 0}, {2, 0}, {3, 0}, {4, 0}};
+        const int numCoords = 7;
+        const CoordIJ coords[] = {{0, 0}, {1, 0},  {2, 0}, {3, 0},
+                                  {4, 0}, {-4, 0}, {0, 4}};
         const H3Index expected[] = {0x81283ffffffffff, 0x81293ffffffffff,
                                     0x8150bffffffffff, 0x8151bffffffffff,
+                                    H3_INVALID_INDEX,  H3_INVALID_INDEX,
                                     H3_INVALID_INDEX};
 
         for (int i = 0; i < numCoords; i++) {

data/ext/h3/src/src/apps/testapps/testPolyfill.c

@@ -64,13 +64,13 @@ SUITE(polyfill) {
 
     TEST(maxPolyfillSize) {
         int numHexagons = H3_EXPORT(maxPolyfillSize)(&sfGeoPolygon, 9);
-        t_assert(numHexagons == 3169, "got expected max polyfill size");
+        t_assert(numHexagons == 3457, "got expected max polyfill size");
 
         numHexagons = H3_EXPORT(maxPolyfillSize)(&holeGeoPolygon, 9);
-        t_assert(numHexagons == 3169, "got expected max polyfill size (hole)");
+        t_assert(numHexagons == 3457, "got expected max polyfill size (hole)");
 
         numHexagons = H3_EXPORT(maxPolyfillSize)(&emptyGeoPolygon, 9);
-        t_assert(numHexagons == 1, "got expected max polyfill size (empty)");
+        t_assert(numHexagons == 3, "got expected max polyfill size (empty)");
     }
 
     TEST(polyfill) {

data/ext/h3/src/src/apps/testapps/testPolyfill_GH136.c

@@ -0,0 +1,58 @@
+/*
+ * Copyright 2017-2019 Uber Technologies, Inc.
+ *
+ * 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 <stdlib.h>
+#include "algos.h"
+#include "constants.h"
+#include "geoCoord.h"
+#include "h3Index.h"
+#include "test.h"
+
+// https://github.com/uber/h3/issues/136
+
+static GeoCoord testVerts[] = {{0.10068990369902957, 0.8920772174196191},
+                               {0.10032914690616246, 0.8915914753447348},
+                               {0.10033349237998787, 0.8915860128746426},
+                               {0.10069496685903621, 0.8920742194546231}};
+static Geofence testGeofence = {.numVerts = 4, .verts = testVerts};
+static GeoPolygon testPolygon;
+
+static int countActualHexagons(H3Index* hexagons, int numHexagons) {
+    int actualNumHexagons = 0;
+    for (int i = 0; i < numHexagons; i++) {
+        if (hexagons[i] != 0) {
+            actualNumHexagons++;
+        }
+    }
+    return actualNumHexagons;
+}
+
+SUITE(polyfill_gh136) {
+    testPolygon.geofence = testGeofence;
+    testPolygon.numHoles = 0;
+
+    TEST(gh136) {
+        int res = 13;
+        int numHexagons = H3_EXPORT(maxPolyfillSize)(&testPolygon, res);
+        H3Index* hexagons = calloc(numHexagons, sizeof(H3Index));
+
+        H3_EXPORT(polyfill)(&testPolygon, res, hexagons);
+        int actualNumHexagons = countActualHexagons(hexagons, numHexagons);
+
+        t_assert(actualNumHexagons == 4353, "got expected polyfill size");
+        free(hexagons);
+    }
+}

data/ext/h3/src/src/apps/testapps/testPolygon.c

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 Uber Technologies, Inc.
+ * Copyright 2017-2019 Uber Technologies, Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -553,4 +553,29 @@ SUITE(polygon) {
 
         H3_EXPORT(destroyLinkedPolygon)(&polygon);
     }
+
+    TEST(normalizeMultiPolygon_unassignedHole) {
+        GeoCoord verts[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}};
+
+        LinkedGeoLoop* outer = malloc(sizeof(*outer));
+        assert(outer != NULL);
+        createLinkedLoop(outer, &verts[0], 4);
+
+        GeoCoord verts2[] = {{2, 2}, {3, 3}, {2, 3}};
+
+        LinkedGeoLoop* inner = malloc(sizeof(*inner));
+        assert(inner != NULL);
+        createLinkedLoop(inner, &verts2[0], 3);
+
+        LinkedGeoPolygon polygon = {0};
+        addLinkedLoop(&polygon, inner);
+        addLinkedLoop(&polygon, outer);
+
+        int result = normalizeMultiPolygon(&polygon);
+
+        t_assert(result == NORMALIZATION_ERR_UNASSIGNED_HOLES,
+                 "Expected error code returned");
+
+        H3_EXPORT(destroyLinkedPolygon)(&polygon);
+    }
 }

data/ext/h3/src/src/h3lib/include/algos.h

@@ -40,4 +40,12 @@ void h3SetToVertexGraph(const H3Index* h3Set, const int numHexes,
 // Create a LinkedGeoPolygon from a vertex graph
 void _vertexGraphToLinkedGeo(VertexGraph* graph, LinkedGeoPolygon* out);
 
+// Internal function for polyfill that traces a geofence with hexagons of a
+// specific size
+int _getEdgeHexagons(const Geofence* geofence, int numHexagons, int res,
+                     int* numSearchHexes, H3Index* search, H3Index* found);
+
+// The new polyfill algorithm. Separated out because it can theoretically fail
+int _polyfillInternal(const GeoPolygon* geoPolygon, int res, H3Index* out);
+
 #endif

data/ext/h3/src/src/h3lib/include/bbox.h

@@ -37,6 +37,8 @@ bool bboxIsTransmeridian(const BBox* bbox);
 void bboxCenter(const BBox* bbox, GeoCoord* center);
 bool bboxContains(const BBox* bbox, const GeoCoord* point);
 bool bboxEquals(const BBox* b1, const BBox* b2);
-int bboxHexRadius(const BBox* bbox, int res);
+int bboxHexEstimate(const BBox* bbox, int res);
+int lineHexEstimate(const GeoCoord* origin, const GeoCoord* destination,
+                    int res);
 
 #endif

data/ext/h3/src/src/h3lib/lib/algos.c

@@ -41,6 +41,7 @@
 #define HEX_RANGE_SUCCESS 0
 #define HEX_RANGE_PENTAGON 1
 #define HEX_RANGE_K_SUBSEQUENCE 2
+#define MAX_ONE_RING_SIZE 7
 
 /**
  * Directions used for traversing a hexagonal ring counterclockwise around
@@ -623,9 +624,8 @@ int H3_EXPORT(hexRing)(H3Index origin, int k, H3Index* out) {
  * maxPolyfillSize returns the number of hexagons to allocate space for when
  * performing a polyfill on the given GeoJSON-like data structure.
  *
- * Currently a laughably padded response, being a k-ring that wholly contains
- * a bounding box of the GeoJSON, but still less wasted memory than initializing
- * a Python application? ;)
+ * The size is the maximum of either the number of points in the geofence or the
+ * number of hexagons in the bounding box of the geofence.
  *
  * @param geoPolygon A GeoJSON-like data structure indicating the poly to fill
  * @param res Hexagon resolution (0-15)
@@ -634,12 +634,18 @@ int H3_EXPORT(hexRing)(H3Index origin, int k, H3Index* out) {
 int H3_EXPORT(maxPolyfillSize)(const GeoPolygon* geoPolygon, int res) {
     // Get the bounding box for the GeoJSON-like struct
     BBox bbox;
-    bboxFromGeofence(&geoPolygon->geofence, &bbox);
-    int minK = bboxHexRadius(&bbox, res);
-
-    // The total number of hexagons to allocate can now be determined by
-    // the k-ring hex allocation helper function.
-    return H3_EXPORT(maxKringSize)(minK);
+    const Geofence geofence = geoPolygon->geofence;
+    bboxFromGeofence(&geofence, &bbox);
+    int numHexagons = bboxHexEstimate(&bbox, res);
+    // This algorithm assumes that the number of vertices is usually less than
+    // the number of hexagons, but when it's wrong, this will keep it from
+    // failing
+    int totalVerts = geofence.numVerts;
+    for (int i = 0; i < geoPolygon->numHoles; i++) {
+        totalVerts += geoPolygon->holes[i].numVerts;
+    }
+    if (numHexagons < totalVerts) numHexagons = totalVerts;
+    return numHexagons;
 }
 
 /**
@@ -647,15 +653,108 @@ int H3_EXPORT(maxPolyfillSize)(const GeoPolygon* geoPolygon, int res) {
  * zeroed memory, and fills it with the hexagons that are contained by
  * the GeoJSON-like data structure.
  *
- * The current implementation is very primitive and slow, but correct,
- * performing a point-in-poly operation on every hexagon in a k-ring defined
- * around the given geofence.
+ * This implementation traces the GeoJSON geofence(s) in cartesian space with
+ * hexagons, tests them and their neighbors to be contained by the geofence(s),
+ * and then any newly found hexagons are used to test again until no new
+ * hexagons are found.
  *
  * @param geoPolygon The geofence and holes defining the relevant area
  * @param res The Hexagon resolution (0-15)
  * @param out The slab of zeroed memory to write to. Assumed to be big enough.
  */
 void H3_EXPORT(polyfill)(const GeoPolygon* geoPolygon, int res, H3Index* out) {
+    // TODO: Eliminate this wrapper with the H3 4.0.0 release
+    int failure = _polyfillInternal(geoPolygon, res, out);
+    // The polyfill algorithm can theoretically fail if the allocated memory is
+    // not large enough for the polygon, but this should be impossible given the
+    // conservative overestimation of the number of hexagons possible.
+    // LCOV_EXCL_START
+    if (failure) {
+        int numHexagons = H3_EXPORT(maxPolyfillSize)(geoPolygon, res);
+        for (int i = 0; i < numHexagons; i++) out[i] = H3_INVALID_INDEX;
+    }
+    // LCOV_EXCL_STOP
+}
+
+/**
+ * _getEdgeHexagons takes a given geofence ring (either the main geofence or
+ * one of the holes) and traces it with hexagons and updates the search and
+ * found memory blocks. This is used for determining the initial hexagon set
+ * for the polyfill algorithm to execute on.
+ *
+ * @param geofence The geofence (or hole) to be traced
+ * @param numHexagons The maximum number of hexagons possible for the geofence
+ *                    (also the bounds of the search and found arrays)
+ * @param res The hexagon resolution (0-15)
+ * @param numSearchHexes The number of hexagons found so far to be searched
+ * @param search The block of memory containing the hexagons to search from
+ * @param found The block of memory containing the hexagons found from the
+ * search
+ *
+ * @return An error code if the hash function cannot insert a found hexagon
+ *         into the found array.
+ */
+int _getEdgeHexagons(const Geofence* geofence, int numHexagons, int res,
+                     int* numSearchHexes, H3Index* search, H3Index* found) {
+    for (int i = 0; i < geofence->numVerts; i++) {
+        GeoCoord origin = geofence->verts[i];
+        GeoCoord destination = i == geofence->numVerts - 1
+                                   ? geofence->verts[0]
+                                   : geofence->verts[i + 1];
+        const int numHexesEstimate =
+            lineHexEstimate(&origin, &destination, res);
+        for (int j = 0; j < numHexesEstimate; j++) {
+            GeoCoord interpolate;
+            interpolate.lat =
+                (origin.lat * (numHexesEstimate - j) / numHexesEstimate) +
+                (destination.lat * j / numHexesEstimate);
+            interpolate.lon =
+                (origin.lon * (numHexesEstimate - j) / numHexesEstimate) +
+                (destination.lon * j / numHexesEstimate);
+            H3Index pointHex = H3_EXPORT(geoToH3)(&interpolate, res);
+            // A simple hash to store the hexagon, or move to another place if
+            // needed
+            int loc = (int)(pointHex % numHexagons);
+            int loopCount = 0;
+            while (found[loc] != 0) {
+                // If this conditional is reached, the `found` memory block is
+                // too small for the given polygon. This should not happen.
+                if (loopCount > numHexagons) return -1;  // LCOV_EXCL_LINE
+                if (found[loc] == pointHex)
+                    break;  // At least two points of the geofence index to the
+                            // same cell
+                loc = (loc + 1) % numHexagons;
+                loopCount++;
+            }
+            if (found[loc] == pointHex)
+                continue;  // Skip this hex, already exists in the found hash
+            // Otherwise, set it in the found hash for now
+            found[loc] = pointHex;
+
+            search[*numSearchHexes] = pointHex;
+            (*numSearchHexes)++;
+        }
+    }
+    return 0;
+}
+
+/**
+ * _polyfillInternal traces the provided geoPolygon data structure with hexagons
+ * and then iteratively searches through these hexagons and their immediate
+ * neighbors to see if they are contained within the polygon or not. Those that
+ * are found are added to the out array as well as the found array. Once all
+ * hexagons to search are checked, the found hexagons become the new search
+ * array and the found array is wiped and the process repeats until no new
+ * hexagons can be found.
+ *
+ * @param geoPolygon The geofence and holes defining the relevant area
+ * @param res The Hexagon resolution (0-15)
+ * @param out The slab of zeroed memory to write to. Assumed to be big enough.
+ *
+ * @return An error code if any of the hash operations fails to insert a hexagon
+ *         into an array of memory.
+ */
+int _polyfillInternal(const GeoPolygon* geoPolygon, int res, H3Index* out) {
     // One of the goals of the polyfill algorithm is that two adjacent polygons
     // with zero overlap have zero overlapping hexagons. That the hexagons are
     // uniquely assigned. There are a few approaches to take here, such as
@@ -677,36 +776,139 @@ void H3_EXPORT(polyfill)(const GeoPolygon* geoPolygon, int res, H3Index* out) {
     BBox* bboxes = malloc((geoPolygon->numHoles + 1) * sizeof(BBox));
     assert(bboxes != NULL);
     bboxesFromGeoPolygon(geoPolygon, bboxes);
-    int minK = bboxHexRadius(&bboxes[0], res);
-    int numHexagons = H3_EXPORT(maxKringSize)(minK);
-
-    // Get the center hex
-    GeoCoord center;
-    bboxCenter(&bboxes[0], &center);
-    H3Index centerH3 = H3_EXPORT(geoToH3)(&center, res);
-
-    // From here on it works differently, first we get all potential
-    // hexagons inserted into the available memory
-    H3_EXPORT(kRing)(centerH3, minK, out);
-
-    // Next we iterate through each hexagon, and test its center point to see if
-    // it's contained in the GeoJSON-like struct
-    for (int i = 0; i < numHexagons; i++) {
-        // Skip records that are already zeroed
-        if (out[i] == 0) {
-            continue;
+
+    // Get the estimated number of hexagons and allocate some temporary memory
+    // for the hexagons
+    int numHexagons = H3_EXPORT(maxPolyfillSize)(geoPolygon, res);
+    H3Index* search = calloc(numHexagons, sizeof(H3Index));
+    H3Index* found = calloc(numHexagons, sizeof(H3Index));
+
+    // Some metadata for tracking the state of the search and found memory
+    // blocks
+    int numSearchHexes = 0;
+    int numFoundHexes = 0;
+
+    // 1. Trace the hexagons along the polygon defining the outer geofence and
+    // add them to the search hash. The hexagon containing the geofence point
+    // may or may not be contained by the geofence (as the hexagon's center
+    // point may be outside of the boundary.)
+    const Geofence geofence = geoPolygon->geofence;
+    int failure = _getEdgeHexagons(&geofence, numHexagons, res, &numSearchHexes,
+                                   search, found);
+    // If this branch is reached, we have exceeded the maximum number of
+    // hexagons possible and need to clean up the allocated memory.
+    // LCOV_EXCL_START
+    if (failure) {
+        free(search);
+        free(found);
+        free(bboxes);
+        return failure;
+    }
+    // LCOV_EXCL_STOP
+
+    // 2. Iterate over all holes, trace the polygons defining the holes with
+    // hexagons and add to only the search hash. We're going to temporarily use
+    // the `found` hash to use for dedupe purposes and then re-zero it once
+    // we're done here, otherwise we'd have to scan the whole set on each insert
+    // to make sure there's no duplicates, which is very inefficient.
+    for (int i = 0; i < geoPolygon->numHoles; i++) {
+        Geofence* hole = &(geoPolygon->holes[i]);
+        failure = _getEdgeHexagons(hole, numHexagons, res, &numSearchHexes,
+                                   search, found);
+        // If this branch is reached, we have exceeded the maximum number of
+        // hexagons possible and need to clean up the allocated memory.
+        // LCOV_EXCL_START
+        if (failure) {
+            free(search);
+            free(found);
+            free(bboxes);
+            return failure;
         }
-        // Check if hexagon is inside of polygon
-        GeoCoord hexCenter;
-        H3_EXPORT(h3ToGeo)(out[i], &hexCenter);
-        hexCenter.lat = constrainLat(hexCenter.lat);
-        hexCenter.lon = constrainLng(hexCenter.lon);
-        // And remove from list if not
-        if (!pointInsidePolygon(geoPolygon, bboxes, &hexCenter)) {
-            out[i] = H3_INVALID_INDEX;
+        // LCOV_EXCL_STOP
+    }
+
+    // 3. Re-zero the found hash so it can be used in the main loop below
+    for (int i = 0; i < numHexagons; i++) found[i] = 0;
+
+    // 4. Begin main loop. While the search hash is not empty do the following
+    while (numSearchHexes > 0) {
+        // Iterate through all hexagons in the current search hash, then loop
+        // through all neighbors and test Point-in-Poly, if point-in-poly
+        // succeeds, add to out and found hashes if not already there.
+        int currentSearchNum = 0;
+        int i = 0;
+        while (currentSearchNum < numSearchHexes) {
+            H3Index ring[MAX_ONE_RING_SIZE] = {0};
+            H3Index searchHex = search[i];
+            H3_EXPORT(kRing)(searchHex, 1, ring);
+            for (int j = 0; j < MAX_ONE_RING_SIZE; j++) {
+                if (ring[j] == H3_INVALID_INDEX) {
+                    continue;  // Skip if this was a pentagon and only had 5
+                               // neighbors
+                }
+
+                H3Index hex = ring[j];
+
+                // A simple hash to store the hexagon, or move to another place
+                // if needed. This MUST be done before the point-in-poly check
+                // since that's far more expensive
+                int loc = (int)(hex % numHexagons);
+                int loopCount = 0;
+                while (out[loc] != 0) {
+                    // If this branch is reached, we have exceeded the maximum
+                    // number of hexagons possible and need to clean up the
+                    // allocated memory.
+                    // LCOV_EXCL_START
+                    if (loopCount > numHexagons) {
+                        free(search);
+                        free(found);
+                        free(bboxes);
+                        return -1;
+                    }
+                    // LCOV_EXCL_STOP
+                    if (out[loc] == hex) break;  // Skip duplicates found
+                    loc = (loc + 1) % numHexagons;
+                    loopCount++;
+                }
+                if (out[loc] == hex) {
+                    continue;  // Skip this hex, already exists in the out hash
+                }
+
+                // Check if the hexagon is in the polygon or not
+                GeoCoord hexCenter;
+                H3_EXPORT(h3ToGeo)(hex, &hexCenter);
+
+                // If not, skip
+                if (!pointInsidePolygon(geoPolygon, bboxes, &hexCenter)) {
+                    continue;
+                }
+
+                // Otherwise set it in the output array
+                out[loc] = hex;
+
+                // Set the hexagon in the found hash
+                found[numFoundHexes] = hex;
+                numFoundHexes++;
+            }
+            currentSearchNum++;
+            i++;
         }
+
+        // Swap the search and found pointers, copy the found hex count to the
+        // search hex count, and zero everything related to the found memory.
+        H3Index* temp = search;
+        search = found;
+        found = temp;
+        for (int j = 0; j < numSearchHexes; j++) found[j] = 0;
+        numSearchHexes = numFoundHexes;
+        numFoundHexes = 0;
+        // Repeat until no new hexagons are found
     }
+    // The out memory structure should be complete, end it here
     free(bboxes);
+    free(search);
+    free(found);
+    return 0;
 }
 
 /**

data/ext/h3/src/src/h3lib/lib/bbox.c

@@ -88,34 +88,59 @@ double _hexRadiusKm(H3Index h3Index) {
 }
 
 /**
- * Get the radius of the bbox in hexagons - i.e. the radius of a k-ring centered
- * on the bbox center and covering the entire bbox.
- * @param  bbox Bounding box to measure
- * @param  res  Resolution of hexagons to use in measurement
- * @return      Radius in hexagons
+ * bboxHexEstimate returns an estimated number of hexagons that fit
+ *                 within the cartesian-projected bounding box
+ *
+ * @param bbox the bounding box to estimate the hexagon fill level
+ * @param res the resolution of the H3 hexagons to fill the bounding box
+ * @return the estimated number of hexagons to fill the bounding box
  */
-int bboxHexRadius(const BBox* bbox, int res) {
-    // Determine the center of the bounding box
-    GeoCoord center;
-    bboxCenter(bbox, &center);
+int bboxHexEstimate(const BBox* bbox, int res) {
+    // Get the area of the pentagon as the maximally-distorted area possible
+    H3Index pentagons[12] = {0};
+    H3_EXPORT(getPentagonIndexes)(res, pentagons);
+    double pentagonRadiusKm = _hexRadiusKm(pentagons[0]);
+    // Area of a regular hexagon is 3/2*sqrt(3) * r * r
+    // The pentagon has the most distortion (smallest edges) and shares its
+    // edges with hexagons, so the most-distorted hexagons have this area
+    double pentagonAreaKm2 =
+        2.59807621135 * pentagonRadiusKm * pentagonRadiusKm;
 
-    // Use a vertex on the side closest to the equator, to ensure the longest
-    // radius in cases with significant distortion. East/west is arbitrary.
-    double lat =
-        fabs(bbox->north) > fabs(bbox->south) ? bbox->south : bbox->north;
-    GeoCoord vertex = {lat, bbox->east};
+    // Then get the area of the bounding box of the geofence in question
+    GeoCoord p1, p2;
+    p1.lat = bbox->north;
+    p1.lon = bbox->east;
+    p2.lat = bbox->south;
+    p2.lon = bbox->east;
+    double h = _geoDistKm(&p1, &p2);
+    p2.lat = bbox->north;
+    p2.lon = bbox->west;
+    double w = _geoDistKm(&p1, &p2);
 
-    // Determine the length of the bounding box "radius" to then use
-    // as a circle on the earth that the k-rings must be greater than
-    double bboxRadiusKm = _geoDistKm(&center, &vertex);
+    // Divide the two to get an estimate of the number of hexagons needed
+    int estimate = (int)ceil(w * h / pentagonAreaKm2);
+    if (estimate == 0) estimate = 1;
+    return estimate;
+}
 
-    // Determine the radius of the center hexagon
-    double centerHexRadiusKm = _hexRadiusKm(H3_EXPORT(geoToH3)(&center, res));
+/**
+ * lineHexEstimate returns an estimated number of hexagons that trace
+ *                 the cartesian-projected line
+ *
+ *  @param origin the origin coordinates
+ *  @param destination the destination coordinates
+ *  @param res the resolution of the H3 hexagons to trace the line
+ *  @return the estimated number of hexagons required to trace the line
+ */
+int lineHexEstimate(const GeoCoord* origin, const GeoCoord* destination,
+                    int res) {
+    // Get the area of the pentagon as the maximally-distorted area possible
+    H3Index pentagons[12] = {0};
+    H3_EXPORT(getPentagonIndexes)(res, pentagons);
+    double pentagonRadiusKm = _hexRadiusKm(pentagons[0]);
 
-    // The closest point along a hexagon drawn through the center points
-    // of a k-ring aggregation is exactly 1.5 radii of the hexagon. For
-    // any orientation of the GeoJSON encased in a circle defined by the
-    // bounding box radius and center, it is guaranteed to fit in this k-ring
-    // Rounded *up* to guarantee containment
-    return (int)ceil(bboxRadiusKm / (1.5 * centerHexRadiusKm));
+    double dist = _geoDistKm(origin, destination);
+    int estimate = (int)ceil(dist / (2 * pentagonRadiusKm));
+    if (estimate == 0) estimate = 1;
+    return estimate;
 }

data/ext/h3/src/src/h3lib/lib/h3Index.c

@@ -266,6 +266,9 @@ H3Index H3_EXPORT(h3ToCenterChild)(H3Index h, int childRes) {
  */
 int H3_EXPORT(compact)(const H3Index* h3Set, H3Index* compactedSet,
                        const int numHexes) {
+    if (numHexes == 0) {
+        return 0;
+    }
     int res = H3_GET_RESOLUTION(h3Set[0]);
     if (res == 0) {
         // No compaction possible, just copy the set to output

data/lib/h3/version.rb

@@ -1,3 +1,3 @@
 module H3
-  VERSION = "3.6.0".freeze
+  VERSION = "3.6.1".freeze
 end

data/spec/region_spec.rb

@@ -42,7 +42,7 @@ RSpec.describe H3 do
       File.read(File.join(File.dirname(__FILE__), "support/fixtures/banbury.json"))
     end
     let(:resolution) { 9 }
-    let(:expected_count) { 33_391 }
+    let(:expected_count) { 36_193 }
 
     subject(:max_polyfill_size) { H3.max_polyfill_size(geojson, resolution) }
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: h3
 version: !ruby/object:Gem::Version
-  version: 3.6.0
+  version: 3.6.1
 platform: ruby
 authors:
 - Lachlan Laycock
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-08-14 00:00:00.000000000 Z
+date: 2019-11-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: ffi
@@ -248,6 +248,7 @@ files:
 - ext/h3/src/src/apps/testapps/testMaxH3ToChildrenSize.c
 - ext/h3/src/src/apps/testapps/testPentagonIndexes.c
 - ext/h3/src/src/apps/testapps/testPolyfill.c
+- ext/h3/src/src/apps/testapps/testPolyfill_GH136.c
 - ext/h3/src/src/apps/testapps/testPolygon.c
 - ext/h3/src/src/apps/testapps/testVec2d.c
 - ext/h3/src/src/apps/testapps/testVec3d.c