h3 3.5.0 → 3.7.1

data/ext/h3/src/src/apps/benchmarks/benchmarkH3Api.c

@@ -17,7 +17,7 @@
 #include "geoCoord.h"
 #include "h3api.h"
 
-// Fixtures
+// Fixtures (arbitrary res 9 hexagon)
 GeoCoord coord = {0.659966917655, -2.1364398519396};
 H3Index hex = 0x89283080ddbffff;
 

data/ext/h3/src/{website/html.config.js → src/apps/benchmarks/benchmarkH3UniEdge.c}

@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 Uber Technologies, Inc.
+ * 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.
@@ -13,19 +13,22 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+#include "benchmark.h"
+#include "geoCoord.h"
+#include "h3api.h"
 
-module.exports = {
+// Fixtures (arbitrary res 9 hexagon)
+H3Index edges[6] = {0};
+H3Index hex = 0x89283080ddbffff;
 
-  title: 'H3',
+BEGIN_BENCHMARKS();
 
-  meta: [{
-    name: 'description',
-    content: 'A hexagonal hierarchical geospatial indexing system'
-  }],
+GeoBoundary outBoundary;
+H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(hex, edges);
 
-  scripts: [
-    // Adds Mathjax support
-    'https://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.5/MathJax.js?config=TeX-MML-AM_CHTML'
-  ]
+BENCHMARK(getH3UnidirectionalEdgeBoundary, 10000, {
+    for (int i = 0; i < 6; i++)
+        H3_EXPORT(getH3UnidirectionalEdgeBoundary)(edges[i], &outBoundary);
+});
 
-};
+END_BENCHMARKS();

data/ext/h3/src/src/apps/filters/h3ToComponents.c

@@ -24,6 +24,7 @@
  */
 
 #include <inttypes.h>
+
 #include "args.h"
 #include "h3Index.h"
 #include "utility.h"

data/ext/h3/src/src/apps/filters/h3ToGeo.c

@@ -41,6 +41,7 @@
  */
 
 #include <inttypes.h>
+
 #include "args.h"
 #include "h3api.h"
 #include "kml.h"

data/ext/h3/src/src/apps/filters/h3ToGeoBoundary.c

@@ -43,6 +43,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "args.h"
 #include "h3api.h"
 #include "kml.h"

data/ext/h3/src/src/apps/filters/h3ToLocalIj.c

@@ -33,6 +33,7 @@
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "args.h"
 #include "h3api.h"
 #include "utility.h"

data/ext/h3/src/src/apps/filters/hexRange.c

@@ -31,6 +31,7 @@
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "args.h"
 #include "h3api.h"
 #include "utility.h"

data/ext/h3/src/src/apps/filters/kRing.c

@@ -30,6 +30,7 @@
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "args.h"
 #include "h3api.h"
 #include "utility.h"

data/ext/h3/src/src/apps/filters/localIjToH3.c

@@ -33,6 +33,7 @@
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "args.h"
 #include "h3api.h"
 #include "utility.h"

data/ext/h3/src/src/apps/miscapps/generateBaseCellNeighbors.c

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2018 Uber Technologies, Inc.
+ * Copyright 2016-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.
@@ -87,7 +87,7 @@ static void generate() {
 
     for (int i = 0; i < NUM_BASE_CELLS; i++) {
         if (!_isBaseCellPentagon(i)) {
-            for (int dir = 0; dir <= NUM_DIRS; dir++) {
+            for (int dir = CENTER_DIGIT; dir <= NUM_DIRS; dir++) {
                 FaceIJK fijk;
                 _baseCellToFaceIjk(i, &fijk);
                 _neighbor(&fijk.coord, dir);

data/ext/h3/src/src/apps/miscapps/generateFaceCenterPoint.c

@@ -20,6 +20,7 @@
  */
 
 #include <stdlib.h>
+
 #include "faceijk.h"
 #include "vec3d.h"
 

data/ext/h3/src/src/apps/miscapps/generateNumHexagons.c

@@ -26,9 +26,8 @@
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "constants.h"
 
-#define NUM_PENTAGONS 12
+#include "constants.h"
 
 /**
  * Generates and prints the numHexagons table.

data/ext/h3/src/src/apps/miscapps/generatePentagonDirectionFaces.c

@@ -0,0 +1,67 @@
+/*
+ * 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 generatePentagonDirectionFaces.c
+ * @brief Generates the pentagonDirectionFaces table
+ *
+ *  usage: `generatePentagonDirectionFaces`
+ */
+
+#include <stdlib.h>
+
+#include "algos.h"
+#include "baseCells.h"
+#include "h3Index.h"
+
+static void generate() {
+    H3Index pentagons[NUM_PENTAGONS] = {0};
+    // Get the res 2 pentagons, whose neighbors have the same base cell
+    // and are unambiguously on the correct faces
+    H3_EXPORT(getPentagonIndexes)(2, pentagons);
+
+    printf(
+        "static const PentagonDirectionFaces "
+        "pentagonDirectionFaces[NUM_PENTAGONS] = "
+        "{\n");
+
+    for (int i = 0; i < NUM_PENTAGONS; i++) {
+        H3Index pentagon = pentagons[i];
+        int baseCell = H3_EXPORT(h3GetBaseCell)(pentagon);
+        printf("    {%d, {", baseCell);
+        // Get the neighbors in each direction, in order
+        FaceIJK fijk;
+        for (Direction dir = J_AXES_DIGIT; dir < NUM_DIGITS; dir++) {
+            int r = 0;
+            H3Index neighbor = h3NeighborRotations(pentagon, dir, &r);
+            _h3ToFaceIjk(neighbor, &fijk);
+
+            if (dir > J_AXES_DIGIT) printf(", ");
+            printf("%d", fijk.face);
+        }
+        printf("}},\n");
+    }
+
+    printf("};\n");
+}
+
+int main(int argc, char* argv[]) {
+    // check command line args
+    if (argc > 1) {
+        fprintf(stderr, "usage: %s\n", argv[0]);
+        exit(1);
+    }
+
+    generate();
+}

data/ext/h3/src/src/apps/miscapps/h3ToGeoBoundaryHier.c

@@ -53,6 +53,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "args.h"
 #include "baseCells.h"
 #include "h3Index.h"

data/ext/h3/src/src/apps/miscapps/h3ToGeoHier.c

@@ -53,6 +53,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "args.h"
 #include "baseCells.h"
 #include "h3Index.h"

data/ext/h3/src/src/apps/miscapps/h3ToHier.c

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

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

@@ -25,6 +25,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "args.h"
 #include "utility.h"
 

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

@@ -24,6 +24,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "args.h"
 #include "utility.h"
 

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

@@ -16,6 +16,7 @@
 
 #include <math.h>
 #include <stdlib.h>
+
 #include "bbox.h"
 #include "constants.h"
 #include "geoCoord.h"

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2017-2019 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.
@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+#include "baseCells.h"
 #include "h3api.h"
 #include "test.h"
 
@@ -27,4 +28,17 @@ SUITE(baseCells) {
         t_assert(indexes[121] == 0x80f3fffffffffff, "correct last basecell");
         free(indexes);
     }
+
+    TEST(baseCellToCCWrot60) {
+        // a few random spot-checks
+        t_assert(_baseCellToCCWrot60(16, 0) == 0, "got expected rotation");
+        t_assert(_baseCellToCCWrot60(32, 0) == 3, "got expected rotation");
+        t_assert(_baseCellToCCWrot60(7, 3) == 1, "got expected rotation");
+    }
+
+    TEST(baseCellToCCWrot60_invalid) {
+        t_assert(_baseCellToCCWrot60(16, 42) == INVALID_ROTATIONS, "should return invalid rotation for invalid face");
+        t_assert(_baseCellToCCWrot60(16, -1) == INVALID_ROTATIONS, "should return invalid rotation for invalid face (negative)");
+        t_assert(_baseCellToCCWrot60(1, 0) == INVALID_ROTATIONS, "should return invalid rotation for base cell not appearing on face");
+    }
 }

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.
@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+
 #include "constants.h"
 #include "h3Index.h"
 #include "test.h"
@@ -152,6 +153,105 @@ SUITE(compact) {
                  "compact fails on duplicate input");
     }
 
+    TEST(compact_duplicateMinimum) {
+        // Test that the minimum number of duplicate hexagons causes failure
+        H3Index h3;
+        int res = 10;
+        // Arbitrary index
+        setH3Index(&h3, res, 0, 2);
+
+        int arrSize = H3_EXPORT(maxH3ToChildrenSize)(h3, res + 1) + 1;
+        H3Index* children = calloc(arrSize, sizeof(H3Index));
+
+        H3_EXPORT(h3ToChildren)(h3, res + 1, children);
+        // duplicate one index
+        children[arrSize - 1] = children[0];
+
+        H3Index* output = calloc(arrSize, sizeof(H3Index));
+
+        int compactResult = H3_EXPORT(compact)(children, output, arrSize);
+        t_assert(compactResult == COMPACT_DUPLICATE,
+                 "compact fails on duplicate input (single duplicate)");
+
+        free(output);
+        free(children);
+    }
+
+    TEST(compact_duplicatePentagonLimit) {
+        // Test that the minimum number of duplicate hexagons causes failure
+        H3Index h3;
+        int res = 10;
+        // Arbitrary pentagon parent cell
+        setH3Index(&h3, res, 4, 0);
+
+        int arrSize = H3_EXPORT(maxH3ToChildrenSize)(h3, res + 1) + 1;
+        H3Index* children = calloc(arrSize, sizeof(H3Index));
+
+        H3_EXPORT(h3ToChildren)(h3, res + 1, children);
+        // duplicate one index
+        children[arrSize - 1] = H3_EXPORT(h3ToCenterChild)(h3, res + 1);
+
+        H3Index* output = calloc(arrSize, sizeof(H3Index));
+
+        int compactResult = H3_EXPORT(compact)(children, output, arrSize);
+        t_assert(compactResult == COMPACT_DUPLICATE,
+                 "compact fails on duplicate input (pentagon parent)");
+
+        free(output);
+        free(children);
+    }
+
+    TEST(compact_duplicateIgnored) {
+        // Test that duplicated cells are not rejected by compact.
+        // This is not necessarily desired - just asserting the
+        // existing behavior.
+        H3Index h3;
+        int res = 10;
+        // Arbitrary index
+        setH3Index(&h3, res, 0, 2);
+
+        int arrSize = H3_EXPORT(maxH3ToChildrenSize)(h3, res + 1);
+        H3Index* children = calloc(arrSize, sizeof(H3Index));
+
+        H3_EXPORT(h3ToChildren)(h3, res + 1, children);
+        // duplicate one index
+        children[arrSize - 1] = children[0];
+
+        H3Index* output = calloc(arrSize, sizeof(H3Index));
+
+        int compactResult = H3_EXPORT(compact)(children, output, arrSize);
+        t_assert(compactResult == COMPACT_SUCCESS,
+                 "compact succeeds on duplicate input (correct count)");
+
+        free(output);
+        free(children);
+    }
+
+    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};
@@ -165,6 +265,10 @@ SUITE(compact) {
         sizeResult = H3_EXPORT(maxUncompactSize)(someHexagons, numHex, -1);
         t_assert(sizeResult < 0,
                  "maxUncompactSize fails when given illegal resolutions");
+        sizeResult =
+            H3_EXPORT(maxUncompactSize)(someHexagons, numHex, MAX_H3_RES + 1);
+        t_assert(sizeResult < 0,
+                 "maxUncompactSize fails when given resolutions beyond max");
 
         H3Index uncompressed[] = {0, 0, 0};
         int uncompactResult =
@@ -180,6 +284,14 @@ SUITE(compact) {
         t_assert(
             uncompactResult != 0,
             "uncompact fails when given too little buffer (same resolution)");
+
+        for (int i = 0; i < numHex; i++) {
+            setH3Index(&someHexagons[i], MAX_H3_RES, i, 0);
+        }
+        uncompactResult = H3_EXPORT(uncompact)(
+            someHexagons, numHex, uncompressed, numHex * 7, MAX_H3_RES + 1);
+        t_assert(uncompactResult != 0,
+                 "uncompact fails when given resolutions beyond max");
     }
 
     TEST(someHexagon) {
@@ -209,6 +321,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
@@ -225,7 +344,7 @@ SUITE(compact) {
         free(children);
     }
 
-    TEST(uncompactZero) {
+    TEST(uncompact_withZero) {
         // maxUncompactSize and uncompact both permit 0 indexes
         // in the input array, and skip them.