h3 3.6.0 → 3.7.2

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

@@ -21,6 +21,7 @@
 #define LINKED_GEO_H
 
 #include <stdlib.h>
+
 #include "bbox.h"
 #include "geoCoord.h"
 #include "h3api.h"

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

@@ -21,6 +21,7 @@
 #define POLYGON_H
 
 #include <stdbool.h>
+
 #include "bbox.h"
 #include "geoCoord.h"
 #include "h3api.h"

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

@@ -25,6 +25,7 @@
 #include <float.h>
 #include <math.h>
 #include <stdbool.h>
+
 #include "bbox.h"
 #include "constants.h"
 #include "geoCoord.h"

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

@@ -0,0 +1,44 @@
+/*
+ * Copyright 2020 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.
+ */
+/** @file  vertex.h
+ *  @brief Functions for working with cell vertexes.
+ */
+
+#ifndef H3VERTEX_H
+#define H3VERTEX_H
+
+#include "h3Index.h"
+#include "faceijk.h"
+
+/** @struct PentagonDirectionFaces
+ *  @brief  The faces in each axial direction of a given pentagon base cell
+ */
+typedef struct {
+    int baseCell;               ///< base cell number
+    int faces[NUM_PENT_VERTS];  ///< face numbers for each axial direction,
+                                ///  in order, starting with J
+} PentagonDirectionFaces;
+
+/** Invalid vertex number */
+#define INVALID_VERTEX_NUM -1
+
+/** Max number of faces a base cell's descendants may appear on */
+#define MAX_BASE_CELL_FACES 5
+
+int vertexRotations(H3Index cell);
+int vertexNumForDirection(const H3Index origin, const Direction direction);
+
+#endif

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

@@ -22,6 +22,7 @@
 
 #include <stdint.h>
 #include <stdlib.h>
+
 #include "geoCoord.h"
 
 /** @struct VertexNode

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

@@ -18,12 +18,15 @@
  */
 
 #include "algos.h"
+
 #include <assert.h>
 #include <float.h>
 #include <math.h>
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
+
+#include "alloc.h"
 #include "baseCells.h"
 #include "bbox.h"
 #include "faceijk.h"
@@ -41,6 +44,9 @@
 #define HEX_RANGE_SUCCESS 0
 #define HEX_RANGE_PENTAGON 1
 #define HEX_RANGE_K_SUBSEQUENCE 2
+#define MAX_ONE_RING_SIZE 7
+#define HEX_HASH_OVERFLOW -1
+#define POLYFILL_BUFFER 12
 
 /**
  * Directions used for traversing a hexagonal ring counterclockwise around
@@ -150,74 +156,86 @@ static const Direction NEW_ADJUSTMENT_III[7][7] = {
      CENTER_DIGIT, IJ_AXES_DIGIT}};
 
 /**
- * Maximum number of indices that result from the kRing algorithm with the given
+ * Maximum number of cells that result from the kRing algorithm with the given
  * k. Formula source and proof: https://oeis.org/A003215
  *
- * @param k k value, k >= 0.
+ * @param  k   k value, k >= 0.
  */
 int H3_EXPORT(maxKringSize)(int k) { return 3 * k * (k + 1) + 1; }
 
 /**
- * k-rings produces indices within k distance of the origin index.
+ * Produce cells within grid distance k of the origin cell.
  *
- * k-ring 0 is defined as the origin index, k-ring 1 is defined as k-ring 0 and
- * all neighboring indices, and so on.
+ * k-ring 0 is defined as the origin cell, k-ring 1 is defined as k-ring 0 and
+ * all neighboring cells, and so on.
  *
  * Output is placed in the provided array in no particular order. Elements of
  * the output array may be left zero, as can happen when crossing a pentagon.
  *
- * @param origin Origin location.
- * @param k k >= 0
- * @param out Zero-filled array which must be of size maxKringSize(k).
+ * @param  origin   origin cell
+ * @param  k        k >= 0
+ * @param  out      zero-filled array which must be of size maxKringSize(k)
  */
 void H3_EXPORT(kRing)(H3Index origin, int k, H3Index* out) {
-    int maxIdx = H3_EXPORT(maxKringSize)(k);
-    int* distances = malloc(maxIdx * sizeof(int));
-    H3_EXPORT(kRingDistances)(origin, k, out, distances);
-    free(distances);
+    H3_EXPORT(kRingDistances)(origin, k, out, NULL);
 }
 
 /**
- * k-rings produces indices within k distance of the origin index.
+ * Produce cells and their distances from the given origin cell, up to
+ * distance k.
  *
- * k-ring 0 is defined as the origin index, k-ring 1 is defined as k-ring 0 and
- * all neighboring indices, and so on.
+ * k-ring 0 is defined as the origin cell, k-ring 1 is defined as k-ring 0 and
+ * all neighboring cells, and so on.
  *
  * Output is placed in the provided array in no particular order. Elements of
  * the output array may be left zero, as can happen when crossing a pentagon.
  *
- * @param origin Origin location.
- * @param k k >= 0
- * @param out Zero-filled array which must be of size maxKringSize(k).
- * @param distances Zero-filled array which must be of size maxKringSize(k).
+ * @param  origin      origin cell
+ * @param  k           k >= 0
+ * @param  out         zero-filled array which must be of size maxKringSize(k)
+ * @param  distances   NULL or a zero-filled array which must be of size
+ *                     maxKringSize(k)
  */
 void H3_EXPORT(kRingDistances)(H3Index origin, int k, H3Index* out,
                                int* distances) {
-    const int maxIdx = H3_EXPORT(maxKringSize)(k);
     // Optimistically try the faster hexRange algorithm first
     const bool failed = H3_EXPORT(hexRangeDistances)(origin, k, out, distances);
     if (failed) {
+        const int maxIdx = H3_EXPORT(maxKringSize)(k);
         // Fast algo failed, fall back to slower, correct algo
         // and also wipe out array because contents untrustworthy
-        memset(out, 0, maxIdx * sizeof(out[0]));
-        memset(distances, 0, maxIdx * sizeof(distances[0]));
-        _kRingInternal(origin, k, out, distances, maxIdx, 0);
+        memset(out, 0, maxIdx * sizeof(H3Index));
+
+        if (distances == NULL) {
+            distances = H3_MEMORY(calloc)(maxIdx, sizeof(int));
+            if (!distances) {
+                // TODO: Return an error code when this is not void
+                return;
+            }
+            _kRingInternal(origin, k, out, distances, maxIdx, 0);
+            H3_MEMORY(free)(distances);
+        } else {
+            memset(distances, 0, maxIdx * sizeof(int));
+            _kRingInternal(origin, k, out, distances, maxIdx, 0);
+        }
     }
 }
 
 /**
  * Internal helper function called recursively for kRingDistances.
  *
- * Adds the origin index to the output set (treating it as a hash set)
+ * Adds the origin cell to the output set (treating it as a hash set)
  * and recurses to its neighbors, if needed.
  *
- * @param origin
- * @param k Maximum distance to move from the origin.
- * @param out Array treated as a hash set, elements being either H3Index or 0.
- * @param distances Scratch area, with elements paralleling the out array.
- * Elements indicate ijk distance from the origin index to the output index.
- * @param maxIdx Size of out and scratch arrays (must be maxKringSize(k))
- * @param curK Current distance from the origin.
+ * @param  origin      Origin cell
+ * @param  k           Maximum distance to move from the origin
+ * @param  out         Array treated as a hash set, elements being either
+ *                     H3Index or 0.
+ * @param  distances   Scratch area, with elements paralleling the out array.
+ *                     Elements indicate ijk distance from the origin cell to
+ *                     the output cell
+ * @param  maxIdx      Size of out and scratch arrays (must be maxKringSize(k))
+ * @param  curK        Current distance from the origin
  */
 void _kRingInternal(H3Index origin, int k, H3Index* out, int* distances,
                     int maxIdx, int curK) {
@@ -260,7 +278,7 @@ void _kRingInternal(H3Index origin, int k, H3Index* out, int* distances,
  * @param rotations Number of ccw rotations to perform to reorient the
  *                  translation vector. Will be modified to the new number of
  *                  rotations to perform (such as when crossing a face edge.)
- * @return H3Index of the specified neighbor or 0 if deleted k-subsequence
+ * @return H3Index of the specified neighbor or H3_NULL if deleted k-subsequence
  *         distortion is encountered.
  */
 H3Index h3NeighborRotations(H3Index origin, Direction dir, int* rotations) {
@@ -299,7 +317,10 @@ H3Index h3NeighborRotations(H3Index origin, Direction dir, int* rotations) {
         } else {
             Direction oldDigit = H3_GET_INDEX_DIGIT(out, r + 1);
             Direction nextDir;
-            if (isResClassIII(r + 1)) {
+            if (oldDigit == INVALID_DIGIT) {
+                // Only possible on invalid input
+                return H3_NULL;
+            } else if (isResClassIII(r + 1)) {
                 H3_SET_INDEX_DIGIT(out, r + 1, NEW_DIGIT_II[oldDigit][dir]);
                 nextDir = NEW_ADJUSTMENT_II[oldDigit][dir];
             } else {
@@ -345,7 +366,7 @@ H3Index h3NeighborRotations(H3Index origin, Direction dir, int* rotations) {
                 // base cell.
                 if (oldLeadingDigit == CENTER_DIGIT) {
                     // Undefined: the k direction is deleted from here
-                    return H3_INVALID_INDEX;
+                    return H3_NULL;
                 } else if (oldLeadingDigit == JK_AXES_DIGIT) {
                     // Rotate out of the deleted k subsequence
                     // We also need an additional change to the direction we're
@@ -360,7 +381,7 @@ H3Index h3NeighborRotations(H3Index origin, Direction dir, int* rotations) {
                     *rotations = *rotations + 5;
                 } else {
                     // Should never occur
-                    return H3_INVALID_INDEX;  // LCOV_EXCL_LINE
+                    return H3_NULL;  // LCOV_EXCL_LINE
                 }
             }
         }
@@ -410,7 +431,7 @@ H3Index h3NeighborRotations(H3Index origin, Direction dir, int* rotations) {
  * @return 0 if no pentagon or pentagonal distortion area was encountered.
  */
 int H3_EXPORT(hexRange)(H3Index origin, int k, H3Index* out) {
-    return H3_EXPORT(hexRangeDistances)(origin, k, out, 0);
+    return H3_EXPORT(hexRangeDistances)(origin, k, out, NULL);
 }
 
 /**
@@ -623,9 +644,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 +654,23 @@ 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;
+    // When the polygon is very small, near an icosahedron edge and is an odd
+    // resolution, the line tracing needs an extra buffer than the estimator
+    // function provides (but beefing that up to cover causes most situations to
+    // overallocate memory)
+    numHexagons += POLYFILL_BUFFER;
+    return numHexagons;
 }
 
 /**
@@ -647,15 +678,109 @@ 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_NULL;
+    }
+    // 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 HEX_HASH_OVERFLOW;  // 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
@@ -674,39 +799,142 @@ void H3_EXPORT(polyfill)(const GeoPolygon* geoPolygon, int res, H3Index* out) {
     // This first part is identical to the maxPolyfillSize above.
 
     // Get the bounding boxes for the polygon and any holes
-    BBox* bboxes = malloc((geoPolygon->numHoles + 1) * sizeof(BBox));
+    BBox* bboxes = H3_MEMORY(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 = H3_MEMORY(calloc)(numHexagons, sizeof(H3Index));
+    H3Index* found = H3_MEMORY(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) {
+        H3_MEMORY(free)(search);
+        H3_MEMORY(free)(found);
+        H3_MEMORY(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) {
+            H3_MEMORY(free)(search);
+            H3_MEMORY(free)(found);
+            H3_MEMORY(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_NULL) {
+                    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) {
+                        H3_MEMORY(free)(search);
+                        H3_MEMORY(free)(found);
+                        H3_MEMORY(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
     }
-    free(bboxes);
+    // The out memory structure should be complete, end it here
+    H3_MEMORY(free)(bboxes);
+    H3_MEMORY(free)(search);
+    H3_MEMORY(free)(found);
+    return 0;
 }
 
 /**