h3 3.6.2 → 3.7.1

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

@@ -29,6 +29,7 @@
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "algos.h"
 #include "baseCells.h"
 #include "h3Index.h"

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

@@ -15,6 +15,7 @@
  */
 
 #include <stdio.h>
+
 #include "algos.h"
 #include "test.h"
 #include "utility.h"

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

@@ -15,6 +15,7 @@
  */
 
 #include <stdio.h>
+
 #include "algos.h"
 #include "test.h"
 #include "utility.h"

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

@@ -16,6 +16,7 @@
 
 #include <inttypes.h>
 #include <stdlib.h>
+
 #include "h3Index.h"
 #include "test.h"
 

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

@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+
 #include "h3Index.h"
 #include "test.h"
 

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

@@ -26,6 +26,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "constants.h"
 #include "geoCoord.h"
 #include "h3Index.h"

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

@@ -27,6 +27,7 @@
 #include <math.h>
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "baseCells.h"
 #include "geoCoord.h"
 #include "h3Index.h"

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

@@ -23,6 +23,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "algos.h"
 #include "baseCells.h"
 #include "constants.h"
@@ -89,16 +90,19 @@ SUITE(h3ToLocalIj) {
         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};
+        const H3Index expected[] = {0x81283ffffffffff,
+                                    0x81293ffffffffff,
+                                    0x8150bffffffffff,
+                                    0x8151bffffffffff,
+                                    H3_NULL,
+                                    H3_NULL,
+                                    H3_NULL};
 
         for (int i = 0; i < numCoords; i++) {
             H3Index result;
             const int err = H3_EXPORT(experimentalLocalIjToH3)(
                 expected[0], &coords[i], &result);
-            if (expected[i] == H3_INVALID_INDEX) {
+            if (expected[i] == H3_NULL) {
                 t_assert(err != 0, "coordinates out of range");
             } else {
                 t_assert(err == 0, "coordinates in range");

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

@@ -24,6 +24,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "algos.h"
 #include "baseCells.h"
 #include "constants.h"

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

@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+
 #include "h3Index.h"
 #include "test.h"
 

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2018 Uber Technologies, Inc.
+ * Copyright 2017-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.
@@ -20,10 +20,12 @@
  */
 
 #include <stdlib.h>
+
 #include "constants.h"
 #include "geoCoord.h"
 #include "h3Index.h"
 #include "test.h"
+#include "utility.h"
 
 // Fixtures
 static GeoCoord sfGeo = {0.659966917655, -2.1364398519396};
@@ -123,13 +125,31 @@ SUITE(h3UniEdge) {
     }
 
     TEST(getH3UnidirectionalEdgeFromPentagon) {
+        H3Index pentagons[NUM_PENTAGONS] = {0};
+        H3Index ring[7] = {0};
         H3Index pentagon;
-        setH3Index(&pentagon, 0, 4, 0);
-        H3Index adjacent;
-        setH3Index(&adjacent, 0, 8, 0);
-
-        H3Index edge = H3_EXPORT(getH3UnidirectionalEdge)(pentagon, adjacent);
-        t_assert(edge != 0, "Produces a valid edge");
+        H3Index edge;
+
+        for (int res = 0; res < MAX_H3_RES; res++) {
+            H3_EXPORT(getPentagonIndexes)(res, pentagons);
+            for (int p = 0; p < NUM_PENTAGONS; p++) {
+                pentagon = pentagons[p];
+                H3_EXPORT(kRing)(pentagon, 1, ring);
+
+                for (int i = 0; i < 7; i++) {
+                    H3Index neighbor = ring[i];
+                    if (neighbor == pentagon || neighbor == H3_NULL) continue;
+                    edge =
+                        H3_EXPORT(getH3UnidirectionalEdge)(pentagon, neighbor);
+                    t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(edge),
+                             "pentagon-to-neighbor is a valid edge");
+                    edge =
+                        H3_EXPORT(getH3UnidirectionalEdge)(neighbor, pentagon);
+                    t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(edge),
+                             "neighbor-to-pentagon is a valid edge");
+                }
+            }
+        }
     }
 
     TEST(h3UnidirectionalEdgeIsValid) {
@@ -166,6 +186,11 @@ SUITE(h3UniEdge) {
         H3_SET_RESERVED_BITS(badPentagonalEdge, 1);
         t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(badPentagonalEdge) == 0,
                  "missing pentagonal edge does not validate");
+
+        H3Index highBitEdge = edge;
+        H3_SET_HIGH_BIT(highBitEdge, 1);
+        t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(highBitEdge) == 0,
+                 "high bit set edge does not validate");
     }
 
     TEST(getH3UnidirectionalEdgesFromHexagon) {
@@ -222,9 +247,7 @@ SUITE(h3UniEdge) {
         const int expectedVertices[][2] = {{3, 4}, {1, 2}, {2, 3},
                                            {5, 0}, {4, 5}, {0, 1}};
 
-        // TODO: The current implementation relies on lat/lon comparison and
-        // fails on resolutions finer than 12
-        for (int res = 0; res < 13; res++) {
+        for (int res = 0; res < MAX_H3_RES; res++) {
             sf = H3_EXPORT(geoToH3)(&sfGeo, res);
             H3_EXPORT(h3ToGeoBoundary)(sf, &boundary);
             H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(sf, edges);
@@ -253,9 +276,7 @@ SUITE(h3UniEdge) {
         const int expectedVertices[][3] = {{-1, -1, -1}, {2, 3, 4}, {4, 5, 6},
                                            {8, 9, 0},    {6, 7, 8}, {0, 1, 2}};
 
-        // TODO: The current implementation relies on lat/lon comparison and
-        // fails on resolutions finer than 12
-        for (int res = 1; res < 13; res += 2) {
+        for (int res = 1; res < MAX_H3_RES; res += 2) {
             setH3Index(&pentagon, res, 24, 0);
             H3_EXPORT(h3ToGeoBoundary)(pentagon, &boundary);
             H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(pentagon, edges);
@@ -293,9 +314,7 @@ SUITE(h3UniEdge) {
         const int expectedVertices[][3] = {{-1, -1}, {1, 2}, {2, 3},
                                            {4, 0},   {3, 4}, {0, 1}};
 
-        // TODO: The current implementation relies on lat/lon comparison and
-        // fails on resolutions finer than 12
-        for (int res = 0; res < 12; res += 2) {
+        for (int res = 0; res < MAX_H3_RES; res += 2) {
             setH3Index(&pentagon, res, 24, 0);
             H3_EXPORT(h3ToGeoBoundary)(pentagon, &boundary);
             H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(pentagon, edges);
@@ -323,4 +342,14 @@ SUITE(h3UniEdge) {
                      "Only one edge was deleted for the pentagon");
         }
     }
+
+    TEST(exactEdgeLength_invalid) {
+        // Test that invalid inputs do not cause crashes.
+        t_assert(H3_EXPORT(exactEdgeLengthRads)(0) == 0,
+                 "Invalid edge has zero length");
+        GeoCoord zero = {0, 0};
+        H3Index h3 = H3_EXPORT(geoToH3)(&zero, 0);
+        t_assert(H3_EXPORT(exactEdgeLengthRads)(h3) == 0,
+                 "Non-edge (cell) has zero edge length");
+    }
 }

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

@@ -0,0 +1,111 @@
+/*
+ * 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
+ * @brief tests H3 unidirectional edge functions using tests over a large number
+ *        of indexes.
+ *
+ *  usage: `testH3UniEdgeExhaustive`
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "baseCells.h"
+#include "constants.h"
+#include "geoCoord.h"
+#include "h3Index.h"
+#include "test.h"
+#include "utility.h"
+
+static void h3UniEdge_correctness_assertions(H3Index h3) {
+    H3Index edges[6] = {H3_NULL};
+    int isPentagon = H3_EXPORT(h3IsPentagon)(h3);
+    H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(h3, edges);
+    H3Index destination;
+
+    for (int i = 0; i < 6; i++) {
+        if (isPentagon && i == 0) {
+            t_assert(edges[i] == H3_NULL, "last pentagon edge is empty");
+            continue;
+        }
+        t_assert(H3_EXPORT(h3UnidirectionalEdgeIsValid)(edges[i]) == 1,
+                 "edge is an edge");
+        t_assert(
+            H3_EXPORT(getOriginH3IndexFromUnidirectionalEdge)(edges[i]) == h3,
+            "origin matches input origin");
+
+        destination =
+            H3_EXPORT(getDestinationH3IndexFromUnidirectionalEdge)(edges[i]);
+        t_assert(H3_EXPORT(h3IndexesAreNeighbors)(h3, destination),
+                 "destination is a neighbor");
+    }
+}
+
+static void h3UniEdge_boundary_assertions(H3Index h3) {
+    H3Index edges[6] = {H3_NULL};
+    H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(h3, edges);
+    H3Index destination;
+    H3Index revEdge;
+    GeoBoundary edgeBoundary;
+    GeoBoundary revEdgeBoundary;
+
+    for (int i = 0; i < 6; i++) {
+        if (edges[i] == H3_NULL) continue;
+        H3_EXPORT(getH3UnidirectionalEdgeBoundary)(edges[i], &edgeBoundary);
+        destination =
+            H3_EXPORT(getDestinationH3IndexFromUnidirectionalEdge)(edges[i]);
+        revEdge = H3_EXPORT(getH3UnidirectionalEdge)(destination, h3);
+        H3_EXPORT(getH3UnidirectionalEdgeBoundary)(revEdge, &revEdgeBoundary);
+
+        t_assert(edgeBoundary.numVerts == revEdgeBoundary.numVerts,
+                 "numVerts is equal for edge and reverse");
+
+        for (int j = 0; j < edgeBoundary.numVerts; j++) {
+            int almostEqual = geoAlmostEqualThreshold(
+                &edgeBoundary.verts[j],
+                &revEdgeBoundary.verts[revEdgeBoundary.numVerts - 1 - j],
+                0.000001);
+            t_assert(almostEqual, "Got expected vertex");
+        }
+    }
+}
+
+SUITE(h3UniEdge) {
+    TEST(h3UniEdge_correctness) {
+        iterateAllIndexesAtRes(0, h3UniEdge_correctness_assertions);
+        iterateAllIndexesAtRes(1, h3UniEdge_correctness_assertions);
+        iterateAllIndexesAtRes(2, h3UniEdge_correctness_assertions);
+        iterateAllIndexesAtRes(3, h3UniEdge_correctness_assertions);
+        iterateAllIndexesAtRes(4, h3UniEdge_correctness_assertions);
+    }
+
+    TEST(h3UniEdge_boundary) {
+        iterateAllIndexesAtRes(0, h3UniEdge_boundary_assertions);
+        iterateAllIndexesAtRes(1, h3UniEdge_boundary_assertions);
+        iterateAllIndexesAtRes(2, h3UniEdge_boundary_assertions);
+        iterateAllIndexesAtRes(3, h3UniEdge_boundary_assertions);
+        iterateAllIndexesAtRes(4, h3UniEdge_boundary_assertions);
+        // Res 5: normal base cell
+        iterateBaseCellIndexesAtRes(5, h3UniEdge_boundary_assertions, 0);
+        // Res 5: pentagon base cell
+        iterateBaseCellIndexesAtRes(5, h3UniEdge_boundary_assertions, 14);
+        // Res 5: polar pentagon base cell
+        iterateBaseCellIndexesAtRes(5, h3UniEdge_boundary_assertions, 117);
+        // Res 6: Test one pentagon just to check for new edge cases
+        iterateBaseCellIndexesAtRes(6, h3UniEdge_boundary_assertions, 14);
+    }
+}

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

@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+
 #include "algos.h"
 #include "test.h"
 

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

@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+
 #include "algos.h"
 #include "constants.h"
 #include "h3Index.h"

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

@@ -20,6 +20,7 @@
  */
 
 #include <stdlib.h>
+
 #include "algos.h"
 #include "baseCells.h"
 #include "h3Index.h"

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

@@ -16,6 +16,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "geoCoord.h"
 #include "h3api.h"
 #include "linkedGeo.h"

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

@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+
 #include "h3Index.h"
 #include "test.h"
 

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

@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+
 #include "h3api.h"
 #include "test.h"
 

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

@@ -15,11 +15,13 @@
  */
 
 #include <stdlib.h>
+
 #include "algos.h"
 #include "constants.h"
 #include "geoCoord.h"
 #include "h3Index.h"
 #include "test.h"
+#include "utility.h"
 
 // Fixtures
 static GeoCoord sfVerts[] = {
@@ -41,14 +43,69 @@ static GeoCoord emptyVerts[] = {{0.659966917655, -2.1364398519394},
 static Geofence emptyGeofence = {.numVerts = 3, .verts = emptyVerts};
 static GeoPolygon emptyGeoPolygon;
 
-static int countActualHexagons(H3Index* hexagons, int numHexagons) {
-    int actualNumHexagons = 0;
-    for (int i = 0; i < numHexagons; i++) {
-        if (hexagons[i] != 0) {
-            actualNumHexagons++;
+/**
+ * Return true if the cell crosses the meridian.
+ */
+static bool isTransmeridianCell(H3Index h) {
+    GeoBoundary bndry;
+    H3_EXPORT(h3ToGeoBoundary)(h, &bndry);
+
+    double minLon = M_PI, maxLon = -M_PI;
+    for (int i = 0; i < bndry.numVerts; i++) {
+        if (bndry.verts[i].lon < minLon) minLon = bndry.verts[i].lon;
+        if (bndry.verts[i].lon > maxLon) maxLon = bndry.verts[i].lon;
+    }
+
+    return maxLon - minLon > M_PI - (M_PI / 4);
+}
+
+static void fillIndex_assertions(H3Index h) {
+    if (isTransmeridianCell(h)) {
+        // TODO: these do not work correctly
+        return;
+    }
+
+    int currentRes = H3_EXPORT(h3GetResolution)(h);
+    // TODO: Not testing more than one depth because the assertions fail.
+    for (int nextRes = currentRes; nextRes <= currentRes + 1; nextRes++) {
+        GeoBoundary bndry;
+        H3_EXPORT(h3ToGeoBoundary)(h, &bndry);
+        GeoPolygon polygon = {
+            .geofence = {.numVerts = bndry.numVerts, .verts = bndry.verts},
+            .numHoles = 0,
+            .holes = 0};
+
+        int polyfillSize = H3_EXPORT(maxPolyfillSize)(&polygon, nextRes);
+        H3Index* polyfillOut = calloc(polyfillSize, sizeof(H3Index));
+        H3_EXPORT(polyfill)(&polygon, nextRes, polyfillOut);
+
+        int polyfillCount = countActualHexagons(polyfillOut, polyfillSize);
+
+        int childrenSize = H3_EXPORT(maxH3ToChildrenSize)(h, nextRes);
+        H3Index* children = calloc(childrenSize, sizeof(H3Index));
+        H3_EXPORT(h3ToChildren)(h, nextRes, children);
+
+        int h3ToChildrenCount = countActualHexagons(children, childrenSize);
+
+        t_assert(polyfillCount == h3ToChildrenCount,
+                 "Polyfill count matches h3ToChildren count");
+
+        for (int i = 0; i < childrenSize; i++) {
+            bool found = false;
+            if (children[i] == H3_NULL) continue;
+            for (int j = 0; j < polyfillSize; j++) {
+                if (polyfillOut[j] == children[i]) {
+                    found = true;
+                    break;
+                }
+            }
+            t_assert(found,
+                     "All indexes match between polyfill and h3ToChildren");
         }
+
+        free(polyfillOut);
+        free(children);
     }
-    return actualNumHexagons;
 }
 
 SUITE(polyfill) {
@@ -64,13 +121,13 @@ SUITE(polyfill) {
 
     TEST(maxPolyfillSize) {
         int numHexagons = H3_EXPORT(maxPolyfillSize)(&sfGeoPolygon, 9);
-        t_assert(numHexagons == 7057, "got expected max polyfill size");
+        t_assert(numHexagons == 5613, "got expected max polyfill size");
 
         numHexagons = H3_EXPORT(maxPolyfillSize)(&holeGeoPolygon, 9);
-        t_assert(numHexagons == 7057, "got expected max polyfill size (hole)");
+        t_assert(numHexagons == 5613, "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 == 15, "got expected max polyfill size (empty)");
     }
 
     TEST(polyfill) {
@@ -300,4 +357,10 @@ SUITE(polyfill) {
         t_assert(numPentagons == 1, "one pentagon found");
         free(hexagons);
     }
+
+    TEST(fillIndex) {
+        iterateAllIndexesAtRes(0, fillIndex_assertions);
+        iterateAllIndexesAtRes(1, fillIndex_assertions);
+        iterateAllIndexesAtRes(2, fillIndex_assertions);
+    }
 }