h3 3.6.0 → 3.7.2

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"
@@ -350,4 +351,22 @@ SUITE(kRing) {
             }
         }
     }
+
+    TEST(kRingInvalid) {
+        int k = 1000;
+        int kSz = H3_EXPORT(maxKringSize)(k);
+        H3Index *neighbors = calloc(kSz, sizeof(H3Index));
+        H3_EXPORT(kRing)(0x7fffffffffffffff, k, neighbors);
+        // Assertion is should not crash - should return an error in the future
+        free(neighbors);
+    }
+
+    TEST(kRingInvalidDigit) {
+        int k = 2;
+        int kSz = H3_EXPORT(maxKringSize)(k);
+        H3Index *neighbors = calloc(kSz, sizeof(H3Index));
+        H3_EXPORT(kRing)(0x4d4b00fe5c5c3030, k, neighbors);
+        // Assertion is should not crash - should return an error in the future
+        free(neighbors);
+    }
 }

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 == 3169, "got expected max polyfill size");
+        t_assert(numHexagons == 5613, "got expected max polyfill size");
 
         numHexagons = H3_EXPORT(maxPolyfillSize)(&holeGeoPolygon, 9);
-        t_assert(numHexagons == 3169, "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);
+    }
 }

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

@@ -0,0 +1,157 @@
+/*
+ * 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"
+#include "utility.h"
+
+// Tests for specific polyfill examples
+
+SUITE(polyfill_reported) {
+    // https://github.com/uber/h3-js/issues/76#issuecomment-561204505
+    TEST(entireWorld) {
+        // TODO: Fails for a single worldwide polygon
+        GeoCoord worldVerts[] = {
+            {-M_PI_2, -M_PI}, {M_PI_2, -M_PI}, {M_PI_2, 0}, {-M_PI_2, 0}};
+        Geofence worldGeofence = {.numVerts = 4, .verts = worldVerts};
+        GeoPolygon worldGeoPolygon = {.geofence = worldGeofence, .numHoles = 0};
+        GeoCoord worldVerts2[] = {
+            {-M_PI_2, 0}, {M_PI_2, 0}, {M_PI_2, M_PI}, {-M_PI_2, M_PI}};
+        Geofence worldGeofence2 = {.numVerts = 4, .verts = worldVerts2};
+        GeoPolygon worldGeoPolygon2 = {.geofence = worldGeofence2,
+                                       .numHoles = 0};
+
+        for (int res = 0; res < 3; res++) {
+            int polyfillSize =
+                H3_EXPORT(maxPolyfillSize)(&worldGeoPolygon, res);
+            H3Index* polyfillOut = calloc(polyfillSize, sizeof(H3Index));
+
+            H3_EXPORT(polyfill)(&worldGeoPolygon, res, polyfillOut);
+            int actualNumHexagons =
+                countActualHexagons(polyfillOut, polyfillSize);
+
+            int polyfillSize2 =
+                H3_EXPORT(maxPolyfillSize)(&worldGeoPolygon2, res);
+            H3Index* polyfillOut2 = calloc(polyfillSize2, sizeof(H3Index));
+
+            H3_EXPORT(polyfill)(&worldGeoPolygon2, res, polyfillOut2);
+            int actualNumHexagons2 =
+                countActualHexagons(polyfillOut2, polyfillSize2);
+
+            t_assert(actualNumHexagons + actualNumHexagons2 ==
+                         H3_EXPORT(numHexagons)(res),
+                     "got expected polyfill size (entire world)");
+
+            // Sets should be disjoint
+            for (int i = 0; i < polyfillSize; i++) {
+                if (polyfillOut[i] == 0) continue;
+
+                bool found = false;
+                for (int j = 0; j < polyfillSize2; j++) {
+                    if (polyfillOut[i] == polyfillOut2[j]) {
+                        found = true;
+                        break;
+                    }
+                }
+                t_assert(!found,
+                         "Index found more than once when polyfilling the "
+                         "entire world");
+            }
+
+            free(polyfillOut);
+            free(polyfillOut2);
+        }
+    }
+
+    // https://github.com/uber/h3-js/issues/67
+    TEST(h3js_67) {
+        double east = H3_EXPORT(degsToRads)(-56.25);
+        double north = H3_EXPORT(degsToRads)(-33.13755119234615);
+        double south = H3_EXPORT(degsToRads)(-34.30714385628804);
+        double west = H3_EXPORT(degsToRads)(-57.65625);
+
+        GeoCoord testVerts[] = {
+            {north, east}, {south, east}, {south, west}, {north, west}};
+        Geofence testGeofence = {.numVerts = 4, .verts = testVerts};
+        GeoPolygon testPolygon;
+        testPolygon.geofence = testGeofence;
+        testPolygon.numHoles = 0;
+
+        int res = 7;
+        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 == 4499,
+                 "got expected polyfill size (h3-js#67)");
+        free(hexagons);
+    }
+
+    // 2nd test case from h3-js#67
+    TEST(h3js_67_2nd) {
+        double east = H3_EXPORT(degsToRads)(-57.65625);
+        double north = H3_EXPORT(degsToRads)(-34.30714385628804);
+        double south = H3_EXPORT(degsToRads)(-35.4606699514953);
+        double west = H3_EXPORT(degsToRads)(-59.0625);
+
+        GeoCoord testVerts[] = {
+            {north, east}, {south, east}, {south, west}, {north, west}};
+        Geofence testGeofence = {.numVerts = 4, .verts = testVerts};
+        GeoPolygon testPolygon;
+        testPolygon.geofence = testGeofence;
+        testPolygon.numHoles = 0;
+
+        int res = 7;
+        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 == 4609,
+                 "got expected polyfill size (h3-js#67, 2nd case)");
+        free(hexagons);
+    }
+
+    // https://github.com/uber/h3/issues/136
+    TEST(h3_136) {
+        GeoCoord testVerts[] = {{0.10068990369902957, 0.8920772174196191},
+                                {0.10032914690616246, 0.8915914753447348},
+                                {0.10033349237998787, 0.8915860128746426},
+                                {0.10069496685903621, 0.8920742194546231}};
+        Geofence testGeofence = {.numVerts = 4, .verts = testVerts};
+        GeoPolygon testPolygon;
+        testPolygon.geofence = testGeofence;
+        testPolygon.numHoles = 0;
+
+        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);
+    }
+}