h3 3.6.0 → 3.7.2

data/ext/h3/src/src/apps/applib/lib/utility.c

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2019 Uber Technologies, Inc.
+ * Copyright 2016-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.
@@ -18,12 +18,14 @@
  */
 
 #include "utility.h"
+
 #include <assert.h>
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
+
 #include "coordijk.h"
 #include "h3Index.h"
 #include "h3api.h"
@@ -175,6 +177,122 @@ int readBoundary(FILE* f, GeoBoundary* b) {
     return 0;
 }
 
+/**
+ * Move nonzero elements to the front of array `a` of length `n`.
+ *
+ * Loop invariant: Everything *before* `i` or *after* `j` is "done".
+ * Move `i` and `j` inwards until they equal, and exit.
+ * You can move `i` forward until there's a zero in front of it.
+ * You can move `j` backward until there's a nonzero to the left of it.
+ * Anything to the right of `j` is "junk" that can be reallocated.
+ *
+ * Before:
+ *   | a | b | 0 | c | d | ... |
+ *           ^           ^
+ *           i           j
+ * After:
+ *   | a | b | d | c | d | ... |
+ *           ^       ^
+ *           i       j
+ *
+ * todo: should this function be in the public API?
+ * todo: add tests for this function
+ *
+ * @param   a  H3Index array to whose elements will be moved
+ * @param   n  length of the input array
+ * @return     number of nonzero elements (length of new array); can reallocate
+ *             memory after this point
+ */
+size_t packNonzeros(H3Index* a, size_t n) {
+    size_t i = 0;
+    size_t j = n;
+
+    while (i < j) {
+        // move j to the left until the first nonzero
+        if (a[j - 1] == 0) {
+            j -= 1;
+            continue;
+        }
+
+        // move i to the right until the first zero
+        if (a[i] != 0) {
+            i += 1;
+            continue;
+        }
+
+        // if we get to this point, we know:
+        // a[i] == 0
+        // a[j-1] != 0
+        // i < j
+        // so we can swap! (actually, move a[j-1] -> a[i])
+        a[i] = a[j - 1];
+        j -= 1;
+    }
+
+    return i;
+}
+
+/**
+ * Array of all cells at a given resolution.
+ *
+ * @param   res  resolution
+ *
+ * @return       array of H3 cells at resolution res
+ */
+H3Index* getCellsAtRes(int res) {
+    int num0 = H3_EXPORT(res0IndexCount)();
+    H3Index* cells0 = calloc(num0, sizeof(H3Index));
+    H3_EXPORT(getRes0Indexes)(cells0);
+
+    int numRes = H3_EXPORT(maxUncompactSize)(cells0, num0, res);
+
+    H3Index* cellsRes = calloc(numRes, sizeof(H3Index));
+    H3_EXPORT(uncompact)(cells0, num0, cellsRes, numRes, res);
+
+    free(cells0);
+
+    numRes = packNonzeros(cellsRes, numRes);
+    cellsRes = realloc(cellsRes, numRes * sizeof(H3Index));
+
+    return cellsRes;
+}
+
+/**
+ * Apply callback to every cell for a given resolution, and sum the results.
+ */
+double mapSumAllCells_double(int res, double (*callback)(H3Index)) {
+    H3Index* cells = getCellsAtRes(res);
+    int N = H3_EXPORT(numHexagons)(res);
+
+    double total = 0.0;
+    for (int i = 0; i < N; i++) {
+        total += (*callback)(cells[i]);
+    }
+    free(cells);
+
+    return total;
+}
+
+/**
+ * Apply callback for every unidirectional edge at the given resolution.
+ */
+void iterateAllUnidirectionalEdgesAtRes(int res, void (*callback)(H3Index)) {
+    H3Index* cells = getCellsAtRes(res);
+    int N = H3_EXPORT(numHexagons)(res);
+
+    for (int i = 0; i < N; i++) {
+        H3Index edges[6] = {H3_NULL};
+        int isPentagon = H3_EXPORT(h3IsPentagon)(cells[i]);
+        H3_EXPORT(getH3UnidirectionalEdgesFromHexagon)(cells[i], edges);
+
+        for (int j = 0; j < 6; j++) {
+            if (isPentagon && j == 0) continue;
+            (*callback)(edges[j]);
+        }
+    }
+    free(cells);
+}
+
 /**
  * Call the callback for every index at the given resolution.
  */
@@ -207,7 +325,7 @@ void iterateBaseCellIndexesAtRes(int res, void (*callback)(H3Index),
     H3_EXPORT(uncompact)(&bc, 1, children, childrenSz, res);
 
     for (int j = 0; j < childrenSz; j++) {
-        if (children[j] == 0) {
+        if (children[j] == H3_NULL) {
             continue;
         }
 
@@ -233,3 +351,16 @@ void randomGeo(GeoCoord* g) {
         (((float)rand() / (float)(RAND_MAX)) * 180.0) - 90.0);
     g->lon = H3_EXPORT(degsToRads)((float)rand() / (float)(RAND_MAX)) * 360.0;
 }
+
+/**
+ * Returns the number of non-invalid indexes in the array.
+ */
+int countActualHexagons(H3Index* hexagons, int numHexagons) {
+    int actualNumHexagons = 0;
+    for (int i = 0; i < numHexagons; i++) {
+        if (hexagons[i] != H3_NULL) {
+            actualNumHexagons++;
+        }
+    }
+    return actualNumHexagons;
+}

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/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,6 +26,7 @@
 #include <inttypes.h>
 #include <stdio.h>
 #include <stdlib.h>
+
 #include "constants.h"
 
 /**

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");
+    }
 }