h3 3.6.0 → 3.7.2

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};
@@ -221,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
@@ -237,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.
 

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-2018 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,13 +184,27 @@ 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(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 - H3_EXPORT(pointDistRads)(&negativeLongitude,
+                                                        &zero)) < EPSILON_RAD,
+                 "Distance with wrapped longitude");
+        t_assert(fabs(M_PI_2 - H3_EXPORT(pointDistRads)(
+                                   &zero, &negativeLongitude)) < EPSILON_RAD,
+                 "Distance with wrapped longitude and swapped arguments");
     }
 
     TEST(doubleConstants) {

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"

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

@@ -20,6 +20,7 @@
  */
 
 #include <math.h>
+
 #include "geoCoord.h"
 #include "h3api.h"
 #include "test.h"

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

@@ -0,0 +1,47 @@
+/*
+ * 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 cell area functions on a few specific cases
+ *
+ *  usage: `testH3CellArea`
+ */
+
+#include <math.h>
+
+#include "h3Index.h"
+#include "test.h"
+
+static const double areasKm2[] = {
+    2.562182162955496e+06, 4.476842018179411e+05, 6.596162242711056e+04,
+    9.228872919002590e+03, 1.318694490797110e+03, 1.879593512281298e+02,
+    2.687164354763186e+01, 3.840848847060638e+00, 5.486939641329893e-01,
+    7.838600808637444e-02, 1.119834221989390e-02, 1.599777169186614e-03,
+    2.285390931423380e-04, 3.264850232091780e-05, 4.664070326136774e-06,
+    6.662957615868888e-07};
+
+SUITE(h3CellArea) {
+    TEST(specific_cell_area) {
+        GeoCoord gc = {0.0, 0.0};
+        for (int res = 0; res <= MAX_H3_RES - 1; res++) {
+            H3Index cell = H3_EXPORT(geoToH3)(&gc, res);
+            double area = H3_EXPORT(cellAreaKm2)(cell);
+
+            t_assert(fabs(area - areasKm2[res]) < 1e-8,
+                     "cell area should match expectation");
+        }
+    }
+}

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

@@ -0,0 +1,180 @@
+/*
+ * 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 cell area functions using tests over a large number
+ *        of indexes.
+ *
+ *  usage: `testH3CellAreaExhaustive`
+ */
+
+#include <math.h>
+
+#include "h3Index.h"
+#include "test.h"
+#include "utility.h"
+
+/**
+ * Basic checks around the great circle distance between the centers of two
+ * neighboring cells. Tests positivity and commutativity.
+ *
+ * Tests the functions:
+ *     pointDistRads
+ *     pointDistKm
+ *     pointDistM
+ *
+ * @param  edge  H3 unidirectional edge denoting neighboring cells
+ */
+static void haversine_assert(H3Index edge) {
+    GeoCoord a, b;
+    H3Index origin, destination;
+
+    origin = H3_EXPORT(getOriginH3IndexFromUnidirectionalEdge)(edge);
+    H3_EXPORT(h3ToGeo)(origin, &a);
+
+    destination = H3_EXPORT(getDestinationH3IndexFromUnidirectionalEdge)(edge);
+    H3_EXPORT(h3ToGeo)(destination, &b);
+
+    char pos[] = "distance between cell centers should be positive";
+    char comm[] = "pairwise cell distances should be commutative";
+
+    double ab, ba;
+
+    ab = H3_EXPORT(pointDistRads)(&a, &b);
+    ba = H3_EXPORT(pointDistRads)(&b, &a);
+    t_assert(ab > 0, pos);
+    t_assert(ab == ba, comm);
+
+    ab = H3_EXPORT(pointDistKm)(&a, &b);
+    ba = H3_EXPORT(pointDistKm)(&b, &a);
+    t_assert(ab > 0, pos);
+    t_assert(ab == ba, comm);
+
+    ab = H3_EXPORT(pointDistM)(&a, &b);
+    ba = H3_EXPORT(pointDistM)(&b, &a);
+    t_assert(ab > 0, pos);
+    t_assert(ab == ba, comm);
+
+    t_assert(H3_EXPORT(pointDistKm)(&a, &b) > H3_EXPORT(pointDistRads)(&a, &b),
+             "measurement in kilometers should be greater than in radians");
+    t_assert(H3_EXPORT(pointDistM)(&a, &b) > H3_EXPORT(pointDistKm)(&a, &b),
+             "measurement in meters should be greater than in kilometers");
+}
+
+/**
+ * Tests positivity of edge length calculation for the functions:
+ *
+ *      exactEdgeLengthRads
+ *      exactEdgeLengthKm
+ *      exactEdgeLengthM
+ *
+ * @param  edge  edge to compute the length of
+ */
+static void edge_length_assert(H3Index edge) {
+    char msg[] = "edge has positive length";
+
+    t_assert(H3_EXPORT(exactEdgeLengthRads)(edge) > 0, msg);
+    t_assert(H3_EXPORT(exactEdgeLengthKm)(edge) > 0, msg);
+    t_assert(H3_EXPORT(exactEdgeLengthM)(edge) > 0, msg);
+}
+
+/**
+ * Test that cell area calculations are positive for the functions:
+ *
+ *      cellAreaRads2
+ *      cellAreaKm2
+ *      cellAreaM2
+ *
+ * @param  cell  cell to compute the area of
+ */
+static void cell_area_assert(H3Index cell) {
+    char msg[] = "cell has positive area";
+
+    t_assert(H3_EXPORT(cellAreaRads2)(cell) > 0, msg);
+    t_assert(H3_EXPORT(cellAreaKm2)(cell) > 0, msg);
+    t_assert(H3_EXPORT(cellAreaM2)(cell) > 0, msg);
+}
+
+/**
+ * Apply a cell area calculation function to every cell on the earth at a given
+ * resolution, and check that it sums up the total earth area.
+ *
+ * @param  res        resolution of the cells
+ * @param  cell_area  callback to compute area of each cell
+ * @param  target     expected earth area in some units
+ * @param  tol        error tolerance allowed between expected and actual
+ */
+static void earth_area_test(int res, double (*cell_area)(H3Index),
+                            double target, double tol) {
+    double area = mapSumAllCells_double(res, cell_area);
+
+    t_assert(fabs(area - target) < tol,
+             "sum of all cells should give earth area");
+}
+
+SUITE(h3CellAreaExhaustive) {
+    TEST(haversine_distances) {
+        iterateAllUnidirectionalEdgesAtRes(0, haversine_assert);
+        iterateAllUnidirectionalEdgesAtRes(1, haversine_assert);
+        iterateAllUnidirectionalEdgesAtRes(2, haversine_assert);
+        iterateAllUnidirectionalEdgesAtRes(3, haversine_assert);
+    }
+
+    TEST(edge_length) {
+        iterateAllUnidirectionalEdgesAtRes(0, edge_length_assert);
+        iterateAllUnidirectionalEdgesAtRes(1, edge_length_assert);
+        iterateAllUnidirectionalEdgesAtRes(2, edge_length_assert);
+        iterateAllUnidirectionalEdgesAtRes(3, edge_length_assert);
+    }
+
+    TEST(cell_area_positive) {
+        iterateAllIndexesAtRes(0, cell_area_assert);
+        iterateAllIndexesAtRes(1, cell_area_assert);
+        iterateAllIndexesAtRes(2, cell_area_assert);
+        iterateAllIndexesAtRes(3, cell_area_assert);
+    }
+
+    TEST(cell_area_earth) {
+        // earth area in different units
+        double rads2 = 4 * M_PI;
+        double km2 = rads2 * EARTH_RADIUS_KM * EARTH_RADIUS_KM;
+        double m2 = km2 * 1000 * 1000;
+
+        // Notice the drop in accuracy at resolution 1.
+        // I think this has something to do with Class II vs Class III
+        // resolutions.
+
+        earth_area_test(0, H3_EXPORT(cellAreaRads2), rads2, 1e-14);
+        earth_area_test(0, H3_EXPORT(cellAreaKm2), km2, 1e-6);
+        earth_area_test(0, H3_EXPORT(cellAreaM2), m2, 1e0);
+
+        earth_area_test(1, H3_EXPORT(cellAreaRads2), rads2, 1e-9);
+        earth_area_test(1, H3_EXPORT(cellAreaKm2), km2, 1e-1);
+        earth_area_test(1, H3_EXPORT(cellAreaM2), m2, 1e5);
+
+        earth_area_test(2, H3_EXPORT(cellAreaRads2), rads2, 1e-12);
+        earth_area_test(2, H3_EXPORT(cellAreaKm2), km2, 1e-5);
+        earth_area_test(2, H3_EXPORT(cellAreaM2), m2, 1e0);
+
+        earth_area_test(3, H3_EXPORT(cellAreaRads2), rads2, 1e-11);
+        earth_area_test(3, H3_EXPORT(cellAreaKm2), km2, 1e-3);
+        earth_area_test(3, H3_EXPORT(cellAreaM2), m2, 1e3);
+
+        earth_area_test(4, H3_EXPORT(cellAreaRads2), rads2, 1e-11);
+        earth_area_test(4, H3_EXPORT(cellAreaKm2), km2, 1e-3);
+        earth_area_test(4, H3_EXPORT(cellAreaM2), m2, 1e2);
+    }
+}