h3 3.5.0 → 3.7.1

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

data/ext/h3/src/src/apps/testapps/testH3Distance.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.
@@ -22,6 +22,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "algos.h"
 #include "baseCells.h"
 #include "constants.h"
@@ -31,40 +32,6 @@
 #include "test.h"
 #include "utility.h"
 
-static const int MAX_DISTANCES[] = {1, 2, 5, 12, 19, 26};
-
-static void h3Distance_identity_assertions(H3Index h3) {
-    t_assert(H3_EXPORT(h3Distance)(h3, h3) == 0, "distance to self is 0");
-}
-
-static void h3Distance_kRing_assertions(H3Index h3) {
-    int r = H3_GET_RESOLUTION(h3);
-    t_assert(r <= 5, "resolution supported by test function (kRing)");
-    int maxK = MAX_DISTANCES[r];
-
-    int sz = H3_EXPORT(maxKringSize)(maxK);
-    H3Index *neighbors = calloc(sz, sizeof(H3Index));
-    int *distances = calloc(sz, sizeof(int));
-
-    H3_EXPORT(kRingDistances)(h3, maxK, neighbors, distances);
-
-    for (int i = 0; i < sz; i++) {
-        if (neighbors[i] == 0) {
-            continue;
-        }
-
-        int calculatedDistance = H3_EXPORT(h3Distance)(h3, neighbors[i]);
-
-        // Don't consider indexes where h3Distance reports failure to
-        // generate
-        t_assert(calculatedDistance == distances[i] || calculatedDistance == -1,
-                 "kRingDistances matches h3Distance");
-    }
-
-    free(distances);
-    free(neighbors);
-}
-
 SUITE(h3Distance) {
     // Some indexes that represent base cells. Base cells
     // are hexagons except for `pent1`.
@@ -118,21 +85,6 @@ SUITE(h3Distance) {
                  "distance in res 2 across pentagon (reversed)");
     }
 
-    TEST(h3Distance_identity) {
-        iterateAllIndexesAtRes(0, h3Distance_identity_assertions);
-        iterateAllIndexesAtRes(1, h3Distance_identity_assertions);
-        iterateAllIndexesAtRes(2, h3Distance_identity_assertions);
-    }
-
-    TEST(h3Distance_kRing) {
-        iterateAllIndexesAtRes(0, h3Distance_kRing_assertions);
-        iterateAllIndexesAtRes(1, h3Distance_kRing_assertions);
-        iterateAllIndexesAtRes(2, h3Distance_kRing_assertions);
-        // Don't iterate all of res 3, to save time
-        iterateAllIndexesAtResPartial(3, h3Distance_kRing_assertions, 27);
-        // Further resolutions aren't tested to save time.
-    }
-
     TEST(h3DistanceBaseCells) {
         t_assert(H3_EXPORT(h3Distance)(bc1, pent1) == 1,
                  "distance to neighbor is 1 (15, 4)");

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

@@ -0,0 +1,84 @@
+/*
+ * 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 H3 distance function using tests over a large number of indexes.
+ *
+ *  usage: `testH3DistanceExhaustive`
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "algos.h"
+#include "baseCells.h"
+#include "constants.h"
+#include "h3Index.h"
+#include "h3api.h"
+#include "localij.h"
+#include "test.h"
+#include "utility.h"
+
+static const int MAX_DISTANCES[] = {1, 2, 5, 12, 19, 26};
+
+static void h3Distance_identity_assertions(H3Index h3) {
+    t_assert(H3_EXPORT(h3Distance)(h3, h3) == 0, "distance to self is 0");
+}
+
+static void h3Distance_kRing_assertions(H3Index h3) {
+    int r = H3_GET_RESOLUTION(h3);
+    t_assert(r <= 5, "resolution supported by test function (kRing)");
+    int maxK = MAX_DISTANCES[r];
+
+    int sz = H3_EXPORT(maxKringSize)(maxK);
+    H3Index *neighbors = calloc(sz, sizeof(H3Index));
+    int *distances = calloc(sz, sizeof(int));
+
+    H3_EXPORT(kRingDistances)(h3, maxK, neighbors, distances);
+
+    for (int i = 0; i < sz; i++) {
+        if (neighbors[i] == 0) {
+            continue;
+        }
+
+        int calculatedDistance = H3_EXPORT(h3Distance)(h3, neighbors[i]);
+
+        // Don't consider indexes where h3Distance reports failure to
+        // generate
+        t_assert(calculatedDistance == distances[i] || calculatedDistance == -1,
+                 "kRingDistances matches h3Distance");
+    }
+
+    free(distances);
+    free(neighbors);
+}
+
+SUITE(h3Distance) {
+    TEST(h3Distance_identity) {
+        iterateAllIndexesAtRes(0, h3Distance_identity_assertions);
+        iterateAllIndexesAtRes(1, h3Distance_identity_assertions);
+        iterateAllIndexesAtRes(2, h3Distance_identity_assertions);
+    }
+
+    TEST(h3Distance_kRing) {
+        iterateAllIndexesAtRes(0, h3Distance_kRing_assertions);
+        iterateAllIndexesAtRes(1, h3Distance_kRing_assertions);
+        iterateAllIndexesAtRes(2, h3Distance_kRing_assertions);
+        // Don't iterate all of res 3, to save time
+        iterateAllIndexesAtResPartial(3, h3Distance_kRing_assertions, 27);
+        // Further resolutions aren't tested to save time.
+    }
+}