h3 3.4.0 → 3.4.4

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2018 Uber Technologies, Inc.
+ * Copyright 2018-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.
@@ -20,15 +20,14 @@
  *  usage: `h3ToLocalIj [origin]`
  *
  *  The program reads H3 indexes from stdin and outputs the corresponding
- *  IJ coordinates to stdout, until EOF is encountered. The H3 indexes
- *  should be in integer form. `NA` is printed if the IJ coordinates
- *  could not be obtained.
+ *  IJ coordinates to stdout, until EOF is encountered. `NA` is printed if the
+ *  IJ coordinates could not be obtained.
  *
  *  `origin` indicates the origin (or anchoring) index for the IJ coordinate
  *  space.
  *
  *  This program has the same limitations as the `experimentalH3ToLocalIj`
- * function.
+ *  function.
  */
 
 #include <inttypes.h>

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

@@ -32,7 +32,6 @@
 #include <stdlib.h>
 #include "algos.h"
 #include "h3Index.h"
-#include "stackAlloc.h"
 #include "utility.h"
 
 void doCell(H3Index h, int k) {

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 Uber Technologies, Inc.
+ * Copyright 2016-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.
@@ -17,57 +17,89 @@
  * @brief stdin/stdout filter that converts from integer H3 indexes to
  * k-rings
  *
- *  usage: `kRing [k]`
+ *  usage: `kRing -k <k> [--print-distances] [--origin origin]`
  *
  *  The program reads H3 indexes from stdin until EOF and outputs
  *  the H3 indexes within k-ring `k` to stdout.
+ *
+ *  --print-distances may be specified to also print the grid distance
+ *  from the origin index.
  */
 
+#include <inttypes.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
-#include "algos.h"
-#include "h3Index.h"
-#include "stackAlloc.h"
+#include "h3api.h"
 #include "utility.h"
 
-void doCell(H3Index h, int k) {
+void doCell(H3Index h, int k, int printDistances) {
     int maxSize = H3_EXPORT(maxKringSize)(k);
     H3Index* rings = calloc(maxSize, sizeof(H3Index));
-    H3_EXPORT(kRing)(h, k, rings);
+    int* distances = calloc(maxSize, sizeof(int));
+    H3_EXPORT(kRingDistances)(h, k, rings, distances);
 
     for (int i = 0; i < maxSize; i++) {
         if (rings[i] != 0) {
-            h3Println(rings[i]);
+            h3Print(rings[i]);
+            if (printDistances) {
+                printf(" %d\n", distances[i]);
+            } else {
+                printf("\n");
+            }
         }
     }
 
+    free(distances);
     free(rings);
 }
 
 int main(int argc, char* argv[]) {
-    // check command line args
-    if (argc != 2) {
-        fprintf(stderr, "usage: %s [k]\n", argv[0]);
-        exit(1);
-    }
-
     int k = 0;
-    if (argc > 1) {
-        if (!sscanf(argv[1], "%d", &k)) error("k must be an integer");
+    H3Index origin = 0;
+
+    Arg helpArg = {.names = {"-h", "--help"},
+                   .helpText = "Show this help message."};
+    Arg kArg = {.names = {"-k", NULL},
+                .required = true,
+                .scanFormat = "%d",
+                .valueName = "k",
+                .value = &k,
+                .helpText = "Radius in hexagons."};
+    Arg printDistancesArg = {
+        .names = {"-d", "--print-distances"},
+        .helpText = "Print distance from origin after each index."};
+    Arg originArg = {
+        .names = {"-o", "--origin"},
+        .scanFormat = "%" PRIx64,
+        .valueName = "origin",
+        .value = &origin,
+        .helpText =
+            "Origin, or not specified to read origins from standard in."};
+
+    Arg* args[] = {&helpArg, &kArg, &printDistancesArg, &originArg};
+
+    if (parseArgs(argc, argv, 4, args, &helpArg,
+                  "Print indexes k distance away from the origin")) {
+        return helpArg.found ? 0 : 1;
     }
 
-    // process the indexes on stdin
-    char buff[BUFF_SIZE];
-    while (1) {
-        // get an index from stdin
-        if (!fgets(buff, BUFF_SIZE, stdin)) {
-            if (feof(stdin))
-                break;
-            else
-                error("reading H3 index from stdin");
-        }
+    if (originArg.found) {
+        doCell(origin, k, printDistancesArg.found);
+    } else {
+        // process the indexes on stdin
+        char buff[BUFF_SIZE];
+        while (1) {
+            // get an index from stdin
+            if (!fgets(buff, BUFF_SIZE, stdin)) {
+                if (feof(stdin))
+                    break;
+                else
+                    error("reading H3 index from stdin");
+            }
 
-        H3Index h3 = H3_EXPORT(stringToH3)(buff);
-        doCell(h3, k);
+            H3Index h3 = H3_EXPORT(stringToH3)(buff);
+            doCell(h3, k, printDistancesArg.found);
+        }
     }
 }

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

@@ -0,0 +1,75 @@
+/*
+ * Copyright 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.
+ */
+/** @file
+ * @brief stdin/stdout filter that converts from local IJ coordinates to
+ * H3 indexes. This is experimental.
+ *
+ *  usage: `localIjToH3 [origin]`
+ *
+ *  The program reads IJ coordinates (in the format `i j` separated by newlines)
+ *  from stdin and outputs the corresponding H3 indexes to stdout, until EOF is
+ *  encountered. `NA` is printed if the H3 index could not be obtained.
+ *
+ *  `origin` indicates the origin (or anchoring) index for the IJ coordinate
+ *  space.
+ *
+ *  This program has the same limitations as the `experimentalLocalIjToH3`
+ *  function.
+ */
+
+#include <inttypes.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include "h3api.h"
+#include "utility.h"
+
+void doCell(const CoordIJ *ij, H3Index origin) {
+    H3Index h;
+    if (H3_EXPORT(experimentalLocalIjToH3)(origin, ij, &h)) {
+        printf("NA\n");
+    } else {
+        h3Println(h);
+    }
+}
+
+int main(int argc, char *argv[]) {
+    // check command line args
+    if (argc != 2) {
+        fprintf(stderr, "usage: %s [origin]\n", argv[0]);
+        exit(1);
+    }
+
+    H3Index origin = H3_EXPORT(stringToH3(argv[1]));
+    if (!H3_EXPORT(h3IsValid)(origin)) error("origin is invalid");
+
+    // process the coordinates on stdin
+    char buff[BUFF_SIZE];
+    while (1) {
+        // get coordinates from stdin
+        if (!fgets(buff, BUFF_SIZE, stdin)) {
+            if (feof(stdin))
+                break;
+            else
+                error("reading IJ coordinates from stdin");
+        }
+
+        CoordIJ ij;
+        if (!sscanf(buff, "%d %d", &ij.i, &ij.j))
+            error("Parsing IJ coordinates. Expected `i j`.");
+
+        doCell(&ij, origin);
+    }
+}

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

@@ -161,7 +161,7 @@ static void generate() {
                         if (dir == K_AXES_DIGIT) {
                             // 4 and 117 are 'polar' type pentagons, which have
                             // some different behavior.
-                            if (i == 4 || i == 117) {
+                            if (_isBaseCellPentagon(i)) {
                                 _ijkRotate60cw(&ijk);
                                 _ijkRotate60cw(&ijk);
                             } else {
@@ -172,7 +172,7 @@ static void generate() {
 
                         // Adjust for the deleted k-subsequence distortion
                         int rotAdj = 0;
-                        if (i == 4 || i == 117) {
+                        if (_isBaseCellPolarPentagon(i)) {
                             // 'polar' type pentagon with all faces pointing
                             // towards i
                             if (dir == IK_AXES_DIGIT) {

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

@@ -219,4 +219,22 @@ SUITE(BBox) {
         t_assert(bboxIsTransmeridian(&bboxTransmeridian),
                  "Transmeridian bbox is transmeridian");
     }
+
+    TEST(bboxEquals) {
+        BBox bbox = {1.0, 0.0, 1.0, 0.0};
+        BBox north = bbox;
+        north.north += 0.1;
+        BBox south = bbox;
+        south.south += 0.1;
+        BBox east = bbox;
+        east.east += 0.1;
+        BBox west = bbox;
+        west.west += 0.1;
+
+        t_assert(bboxEquals(&bbox, &bbox), "Equals self");
+        t_assert(!bboxEquals(&bbox, &north), "Not equals different north");
+        t_assert(!bboxEquals(&bbox, &south), "Not equals different south");
+        t_assert(!bboxEquals(&bbox, &east), "Not equals different east");
+        t_assert(!bboxEquals(&bbox, &west), "Not equals different west");
+    }
 }

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

@@ -23,6 +23,8 @@ H3Index sunnyvale = 0x89283470c27ffff;
 
 H3Index uncompactable[] = {0x89283470803ffff, 0x8928347081bffff,
                            0x8928347080bffff};
+H3Index uncompactableWithZero[] = {0x89283470803ffff, 0x8928347081bffff, 0,
+                                   0x8928347080bffff};
 
 SUITE(compact) {
     TEST(roundtrip) {
@@ -207,6 +209,45 @@ SUITE(compact) {
         free(result);
     }
 
+    TEST(uncompact_onlyZero) {
+        // maxUncompactSize and uncompact both permit 0 indexes
+        // in the input array, and skip them. When only a zero is
+        // given, it's a no-op.
+
+        H3Index origin = 0;
+
+        int childrenSz = H3_EXPORT(maxUncompactSize)(&origin, 1, 2);
+        H3Index* children = calloc(childrenSz, sizeof(H3Index));
+        int uncompactResult =
+            H3_EXPORT(uncompact)(&origin, 1, children, childrenSz, 2);
+        t_assert(uncompactResult == 0, "uncompact only zero success");
+
+        free(children);
+    }
+
+    TEST(uncompactZero) {
+        // maxUncompactSize and uncompact both permit 0 indexes
+        // in the input array, and skip them.
+
+        int childrenSz =
+            H3_EXPORT(maxUncompactSize)(uncompactableWithZero, 4, 10);
+        H3Index* children = calloc(childrenSz, sizeof(H3Index));
+        int uncompactResult = H3_EXPORT(uncompact)(uncompactableWithZero, 4,
+                                                   children, childrenSz, 10);
+        t_assert(uncompactResult == 0, "uncompact with zero succeeds");
+
+        int found = 0;
+        for (int i = 0; i < childrenSz; i++) {
+            if (children[i] != 0) {
+                found++;
+            }
+        }
+        t_assert(found == childrenSz,
+                 "uncompacted with zero to expected number of hexagons");
+
+        free(children);
+    }
+
     TEST(pentagon) {
         H3Index pentagon;
         setH3Index(&pentagon, 1, 4, 0);

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

@@ -28,7 +28,6 @@
 #include "h3Index.h"
 #include "h3api.h"
 #include "localij.h"
-#include "stackAlloc.h"
 #include "test.h"
 #include "utility.h"
 

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

@@ -0,0 +1,53 @@
+/*
+ * Copyright 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.
+ */
+/** @file
+ * @brief tests IJK grid functions
+ *
+ *  usage: `testCoordIjk`
+ */
+
+#include "coordijk.h"
+#include "test.h"
+
+SUITE(coordIjk) {
+    TEST(_unitIjkToDigit) {
+        CoordIJK zero = {0};
+        CoordIJK i = {1, 0, 0};
+        CoordIJK outOfRange = {2, 0, 0};
+        CoordIJK unnormalizedZero = {2, 2, 2};
+
+        t_assert(_unitIjkToDigit(&zero) == CENTER_DIGIT, "Unit IJK to zero");
+        t_assert(_unitIjkToDigit(&i) == I_AXES_DIGIT, "Unit IJK to I axis");
+        t_assert(_unitIjkToDigit(&outOfRange) == INVALID_DIGIT,
+                 "Unit IJK out of range");
+        t_assert(_unitIjkToDigit(&unnormalizedZero) == CENTER_DIGIT,
+                 "Unnormalized unit IJK to zero");
+    }
+
+    TEST(_neighbor) {
+        CoordIJK ijk = {0};
+
+        CoordIJK zero = {0};
+        CoordIJK i = {1, 0, 0};
+
+        _neighbor(&ijk, CENTER_DIGIT);
+        t_assert(_ijkMatches(&ijk, &zero), "Center neighbor is self");
+        _neighbor(&ijk, I_AXES_DIGIT);
+        t_assert(_ijkMatches(&ijk, &i), "I neighbor as expected");
+        _neighbor(&ijk, INVALID_DIGIT);
+        t_assert(_ijkMatches(&ijk, &i), "Invalid neighbor is self");
+    }
+}

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

@@ -79,6 +79,26 @@ SUITE(h3Api) {
         t_assertBoundary(h3, &boundary);
     }
 
+    TEST(h3ToGeoBoundary_coslonConstrain) {
+        // Bug test for https://github.com/uber/h3/issues/212
+        H3Index h3 = 0x87dc6d364ffffffL;
+        GeoBoundary boundary;
+        boundary.numVerts = 6;
+        setGeoDegs(&boundary.verts[0], -52.0130533678236091,
+                   -34.6232931343713091);
+        setGeoDegs(&boundary.verts[1], -52.0041156384652012,
+                   -34.6096733160584549);
+        setGeoDegs(&boundary.verts[2], -51.9929610229502472,
+                   -34.6165157145896387);
+        setGeoDegs(&boundary.verts[3], -51.9907410568096608,
+                   -34.6369680004259877);
+        setGeoDegs(&boundary.verts[4], -51.9996738734672377,
+                   -34.6505896528323660);
+        setGeoDegs(&boundary.verts[5], -52.0108315681413629,
+                   -34.6437571897165668);
+        t_assertBoundary(h3, &boundary);
+    }
+
     TEST(version) {
         t_assert(H3_VERSION_MAJOR >= 0, "major version is set");
         t_assert(H3_VERSION_MINOR >= 0, "minor version is set");

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

@@ -28,7 +28,6 @@
 #include "h3Index.h"
 #include "h3api.h"
 #include "localij.h"
-#include "stackAlloc.h"
 #include "test.h"
 #include "utility.h"
 
@@ -44,8 +43,8 @@ static void h3Distance_kRing_assertions(H3Index h3) {
     int maxK = MAX_DISTANCES[r];
 
     int sz = H3_EXPORT(maxKringSize)(maxK);
-    STACK_ARRAY_CALLOC(H3Index, neighbors, sz);
-    STACK_ARRAY_CALLOC(int, distances, sz);
+    H3Index *neighbors = calloc(sz, sizeof(H3Index));
+    int *distances = calloc(sz, sizeof(int));
 
     H3_EXPORT(kRingDistances)(h3, maxK, neighbors, distances);
 
@@ -61,6 +60,9 @@ static void h3Distance_kRing_assertions(H3Index h3) {
         t_assert(calculatedDistance == distances[i] || calculatedDistance == -1,
                  "kRingDistances matches h3Distance");
     }
+
+    free(distances);
+    free(neighbors);
 }
 
 SUITE(h3Distance) {