h3 3.6.2 → 3.7.1

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

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

@@ -15,6 +15,7 @@
  */
 
 #include <stdlib.h>
+
 #include "constants.h"
 #include "h3Index.h"
 #include "test.h"
@@ -152,6 +153,80 @@ 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");

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

@@ -22,6 +22,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/testGeoCoord.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.
@@ -19,11 +19,14 @@
  * usage: `testGeoCoord`
  */
 
+#include <float.h>
 #include <math.h>
+
 #include "constants.h"
 #include "geoCoord.h"
 #include "h3api.h"
 #include "test.h"
+#include "utility.h"
 
 /**
  * Test a function for all resolutions, where the value should be decreasing as
@@ -32,7 +35,8 @@
  * @param function
  * @param message
  */
-void testDecreasingFunction(double (*function)(int), const char* message) {
+static void testDecreasingFunction(double (*function)(int),
+                                   const char* message) {
     double last = 0;
     double next;
     for (int i = MAX_H3_RES; i >= 0; i--) {
@@ -51,20 +55,41 @@ SUITE(geoCoord) {
                  "radsToDegs/degsToRads invertible");
     }
 
-    TEST(_geoDistRads) {
+    TEST(pointDistRads) {
         GeoCoord p1;
         setGeoDegs(&p1, 10, 10);
         GeoCoord p2;
         setGeoDegs(&p2, 0, 10);
 
         // TODO: Epsilon is relatively large
-        t_assert(_geoDistRads(&p1, &p1) < EPSILON_RAD * 1000,
+        t_assert(H3_EXPORT(pointDistRads)(&p1, &p1) < EPSILON_RAD * 1000,
                  "0 distance as expected");
-        t_assert(fabs(_geoDistRads(&p1, &p2) - H3_EXPORT(degsToRads)(10)) <
-                     EPSILON_RAD * 1000,
+        t_assert(fabs(H3_EXPORT(pointDistRads)(&p1, &p2) -
+                      H3_EXPORT(degsToRads)(10)) < EPSILON_RAD * 1000,
                  "distance along longitude as expected");
     }
 
+    TEST(geoAlmostEqualThreshold) {
+        GeoCoord a = {15, 10};
+        GeoCoord b = {15, 10};
+        t_assert(geoAlmostEqualThreshold(&a, &b, DBL_EPSILON), "same point");
+
+        b.lat = 15.00001;
+        b.lon = 10.00002;
+        t_assert(geoAlmostEqualThreshold(&a, &b, 0.0001),
+                 "differences under threshold");
+
+        b.lat = 15.00001;
+        b.lon = 10;
+        t_assert(!geoAlmostEqualThreshold(&a, &b, 0.000001),
+                 "lat over threshold");
+
+        b.lat = 15;
+        b.lon = 10.00001;
+        t_assert(!geoAlmostEqualThreshold(&a, &b, 0.000001),
+                 "lon over threshold");
+    }
+
     TEST(constrainLatLng) {
         t_assert(constrainLat(0) == 0, "lat 0");
         t_assert(constrainLat(1) == 1, "lat 1");
@@ -159,24 +184,26 @@ SUITE(geoCoord) {
         double distance = H3_EXPORT(degsToRads)(15);
 
         _geoAzDistanceRads(&start, azimuth, distance, &out);
-        t_assert(fabs(_geoDistRads(&start, &out) - distance) < EPSILON_RAD,
+        t_assert(fabs(H3_EXPORT(pointDistRads)(&start, &out) - distance) <
+                     EPSILON_RAD,
                  "moved distance is as expected");
 
         GeoCoord start2 = out;
         _geoAzDistanceRads(&start2, azimuth + degrees180, distance, &out);
         // TODO: Epsilon is relatively large
-        t_assert(_geoDistRads(&start, &out) < 0.01, "moved back to origin");
+        t_assert(H3_EXPORT(pointDistRads)(&start, &out) < 0.01,
+                 "moved back to origin");
     }
 
-    TEST(_geoDistRads_wrappedLongitude) {
+    TEST(pointDistRads_wrappedLongitude) {
         const GeoCoord negativeLongitude = {.lat = 0, .lon = -(M_PI + M_PI_2)};
         const GeoCoord zero = {.lat = 0, .lon = 0};
 
-        t_assert(fabs(M_PI_2 - _geoDistRads(&negativeLongitude, &zero)) <
-                     EPSILON_RAD,
+        t_assert(fabs(M_PI_2 - H3_EXPORT(pointDistRads)(&negativeLongitude,
+                                                        &zero)) < EPSILON_RAD,
                  "Distance with wrapped longitude");
-        t_assert(fabs(M_PI_2 - _geoDistRads(&zero, &negativeLongitude)) <
-                     EPSILON_RAD,
+        t_assert(fabs(M_PI_2 - H3_EXPORT(pointDistRads)(
+                                   &zero, &negativeLongitude)) < EPSILON_RAD,
                  "Distance with wrapped longitude and swapped arguments");
     }
 

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

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