h3 3.6.2 → 3.7.1

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

@@ -0,0 +1,157 @@
+/*
+ * 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.
+ * 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.
+ */
+
+#include <stdlib.h>
+
+#include "algos.h"
+#include "constants.h"
+#include "geoCoord.h"
+#include "h3Index.h"
+#include "test.h"
+#include "utility.h"
+
+// Tests for specific polyfill examples
+
+SUITE(polyfill_reported) {
+    // https://github.com/uber/h3-js/issues/76#issuecomment-561204505
+    TEST(entireWorld) {
+        // TODO: Fails for a single worldwide polygon
+        GeoCoord worldVerts[] = {
+            {-M_PI_2, -M_PI}, {M_PI_2, -M_PI}, {M_PI_2, 0}, {-M_PI_2, 0}};
+        Geofence worldGeofence = {.numVerts = 4, .verts = worldVerts};
+        GeoPolygon worldGeoPolygon = {.geofence = worldGeofence, .numHoles = 0};
+        GeoCoord worldVerts2[] = {
+            {-M_PI_2, 0}, {M_PI_2, 0}, {M_PI_2, M_PI}, {-M_PI_2, M_PI}};
+        Geofence worldGeofence2 = {.numVerts = 4, .verts = worldVerts2};
+        GeoPolygon worldGeoPolygon2 = {.geofence = worldGeofence2,
+                                       .numHoles = 0};
+
+        for (int res = 0; res < 3; res++) {
+            int polyfillSize =
+                H3_EXPORT(maxPolyfillSize)(&worldGeoPolygon, res);
+            H3Index* polyfillOut = calloc(polyfillSize, sizeof(H3Index));
+
+            H3_EXPORT(polyfill)(&worldGeoPolygon, res, polyfillOut);
+            int actualNumHexagons =
+                countActualHexagons(polyfillOut, polyfillSize);
+
+            int polyfillSize2 =
+                H3_EXPORT(maxPolyfillSize)(&worldGeoPolygon2, res);
+            H3Index* polyfillOut2 = calloc(polyfillSize2, sizeof(H3Index));
+
+            H3_EXPORT(polyfill)(&worldGeoPolygon2, res, polyfillOut2);
+            int actualNumHexagons2 =
+                countActualHexagons(polyfillOut2, polyfillSize2);
+
+            t_assert(actualNumHexagons + actualNumHexagons2 ==
+                         H3_EXPORT(numHexagons)(res),
+                     "got expected polyfill size (entire world)");
+
+            // Sets should be disjoint
+            for (int i = 0; i < polyfillSize; i++) {
+                if (polyfillOut[i] == 0) continue;
+
+                bool found = false;
+                for (int j = 0; j < polyfillSize2; j++) {
+                    if (polyfillOut[i] == polyfillOut2[j]) {
+                        found = true;
+                        break;
+                    }
+                }
+                t_assert(!found,
+                         "Index found more than once when polyfilling the "
+                         "entire world");
+            }
+
+            free(polyfillOut);
+            free(polyfillOut2);
+        }
+    }
+
+    // https://github.com/uber/h3-js/issues/67
+    TEST(h3js_67) {
+        double east = H3_EXPORT(degsToRads)(-56.25);
+        double north = H3_EXPORT(degsToRads)(-33.13755119234615);
+        double south = H3_EXPORT(degsToRads)(-34.30714385628804);
+        double west = H3_EXPORT(degsToRads)(-57.65625);
+
+        GeoCoord testVerts[] = {
+            {north, east}, {south, east}, {south, west}, {north, west}};
+        Geofence testGeofence = {.numVerts = 4, .verts = testVerts};
+        GeoPolygon testPolygon;
+        testPolygon.geofence = testGeofence;
+        testPolygon.numHoles = 0;
+
+        int res = 7;
+        int numHexagons = H3_EXPORT(maxPolyfillSize)(&testPolygon, res);
+        H3Index* hexagons = calloc(numHexagons, sizeof(H3Index));
+
+        H3_EXPORT(polyfill)(&testPolygon, res, hexagons);
+        int actualNumHexagons = countActualHexagons(hexagons, numHexagons);
+
+        t_assert(actualNumHexagons == 4499,
+                 "got expected polyfill size (h3-js#67)");
+        free(hexagons);
+    }
+
+    // 2nd test case from h3-js#67
+    TEST(h3js_67_2nd) {
+        double east = H3_EXPORT(degsToRads)(-57.65625);
+        double north = H3_EXPORT(degsToRads)(-34.30714385628804);
+        double south = H3_EXPORT(degsToRads)(-35.4606699514953);
+        double west = H3_EXPORT(degsToRads)(-59.0625);
+
+        GeoCoord testVerts[] = {
+            {north, east}, {south, east}, {south, west}, {north, west}};
+        Geofence testGeofence = {.numVerts = 4, .verts = testVerts};
+        GeoPolygon testPolygon;
+        testPolygon.geofence = testGeofence;
+        testPolygon.numHoles = 0;
+
+        int res = 7;
+        int numHexagons = H3_EXPORT(maxPolyfillSize)(&testPolygon, res);
+        H3Index* hexagons = calloc(numHexagons, sizeof(H3Index));
+
+        H3_EXPORT(polyfill)(&testPolygon, res, hexagons);
+        int actualNumHexagons = countActualHexagons(hexagons, numHexagons);
+
+        t_assert(actualNumHexagons == 4609,
+                 "got expected polyfill size (h3-js#67, 2nd case)");
+        free(hexagons);
+    }
+
+    // https://github.com/uber/h3/issues/136
+    TEST(h3_136) {
+        GeoCoord testVerts[] = {{0.10068990369902957, 0.8920772174196191},
+                                {0.10032914690616246, 0.8915914753447348},
+                                {0.10033349237998787, 0.8915860128746426},
+                                {0.10069496685903621, 0.8920742194546231}};
+        Geofence testGeofence = {.numVerts = 4, .verts = testVerts};
+        GeoPolygon testPolygon;
+        testPolygon.geofence = testGeofence;
+        testPolygon.numHoles = 0;
+
+        int res = 13;
+        int numHexagons = H3_EXPORT(maxPolyfillSize)(&testPolygon, res);
+        H3Index* hexagons = calloc(numHexagons, sizeof(H3Index));
+
+        H3_EXPORT(polyfill)(&testPolygon, res, hexagons);
+        int actualNumHexagons = countActualHexagons(hexagons, numHexagons);
+
+        t_assert(actualNumHexagons == 4353, "got expected polyfill size");
+        free(hexagons);
+    }
+}

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

@@ -16,6 +16,7 @@
 
 #include <assert.h>
 #include <stdlib.h>
+
 #include "bbox.h"
 #include "constants.h"
 #include "geoCoord.h"

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

@@ -17,6 +17,7 @@
 #include <float.h>
 #include <math.h>
 #include <stdlib.h>
+
 #include "test.h"
 #include "vec2d.h"
 

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

@@ -17,6 +17,7 @@
 #include <float.h>
 #include <math.h>
 #include <stdlib.h>
+
 #include "test.h"
 #include "vec3d.h"
 

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

@@ -0,0 +1,66 @@
+/*
+ * 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 vertex functions.
+ *
+ *  usage: `testVertex`
+ */
+
+#include "test.h"
+#include "utility.h"
+#include "vertex.h"
+
+SUITE(Vertex) {
+    TEST(vertexNumForDirection_hex) {
+        H3Index origin = 0x823d6ffffffffff;
+        int vertexNums[NUM_HEX_VERTS] = {0};
+        for (Direction dir = K_AXES_DIGIT; dir < NUM_DIGITS; dir++) {
+            int vertexNum = vertexNumForDirection(origin, dir);
+            t_assert(vertexNum >= 0 && vertexNum < NUM_HEX_VERTS,
+                     "vertex number appears valid");
+            t_assert(!vertexNums[vertexNum], "vertex number appears only once");
+            vertexNums[vertexNum] = 1;
+        }
+    }
+
+    TEST(vertexNumForDirection_pent) {
+        H3Index pentagon = 0x823007fffffffff;
+        int vertexNums[NUM_PENT_VERTS] = {0};
+        for (Direction dir = J_AXES_DIGIT; dir < NUM_DIGITS; dir++) {
+            int vertexNum = vertexNumForDirection(pentagon, dir);
+            t_assert(vertexNum >= 0 && vertexNum < NUM_PENT_VERTS,
+                     "vertex number appears valid");
+            t_assert(!vertexNums[vertexNum], "vertex number appears only once");
+            vertexNums[vertexNum] = 1;
+        }
+    }
+
+    TEST(vertexNumForDirection_badDirections) {
+        H3Index origin = 0x823007fffffffff;
+
+        t_assert(
+            vertexNumForDirection(origin, CENTER_DIGIT) == INVALID_VERTEX_NUM,
+            "center digit should return invalid vertex");
+        t_assert(
+            vertexNumForDirection(origin, INVALID_DIGIT) == INVALID_VERTEX_NUM,
+            "invalid digit should return invalid vertex");
+
+        H3Index pentagon = 0x823007fffffffff;
+        t_assert(
+            vertexNumForDirection(pentagon, K_AXES_DIGIT) == INVALID_VERTEX_NUM,
+            "K direction on pentagon should return invalid vertex");
+    }
+}

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

@@ -16,6 +16,7 @@
 
 #include <assert.h>
 #include <stdio.h>
+
 #include "geoCoord.h"
 #include "h3api.h"
 #include "test.h"

data/ext/h3/src/src/h3lib/include/algos.h

@@ -40,4 +40,12 @@ void h3SetToVertexGraph(const H3Index* h3Set, const int numHexes,
 // Create a LinkedGeoPolygon from a vertex graph
 void _vertexGraphToLinkedGeo(VertexGraph* graph, LinkedGeoPolygon* out);
 
+// Internal function for polyfill that traces a geofence with hexagons of a
+// specific size
+int _getEdgeHexagons(const Geofence* geofence, int numHexagons, int res,
+                     int* numSearchHexes, H3Index* search, H3Index* found);
+
+// The polyfill algorithm. Separated out because it can theoretically fail
+int _polyfillInternal(const GeoPolygon* geoPolygon, int res, H3Index* out);
+
 #endif

data/ext/h3/src/src/h3lib/include/alloc.h

@@ -0,0 +1,40 @@
+/*
+ * 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 alloc.h
+ * @brief   Memory management functions
+ *
+ * This file contains macros and the necessary declarations to be able
+ * to point H3 at different memory management functions than the standard
+ * malloc/free/etc functions.
+ */
+
+#ifndef ALLOC_H
+#define ALLOC_H
+
+#include "h3api.h" // for TJOIN
+
+#ifdef H3_ALLOC_PREFIX
+#define H3_MEMORY(name) TJOIN(H3_ALLOC_PREFIX, name)
+
+void* H3_MEMORY(malloc)(size_t size);
+void* H3_MEMORY(calloc)(size_t num, size_t size);
+void* H3_MEMORY(realloc)(void* ptr, size_t size);
+void H3_MEMORY(free)(void* ptr);
+#else
+#define H3_MEMORY(name) name
+#endif
+
+#endif

data/ext/h3/src/src/h3lib/include/baseCells.h

@@ -45,11 +45,15 @@ extern const BaseCellData baseCellData[NUM_BASE_CELLS];
 /** Maximum input for any component to face-to-base-cell lookup functions */
 #define MAX_FACE_COORD 2
 
+/** Invalid number of rotations */
+#define INVALID_ROTATIONS -1
+
 // Internal functions
 int _isBaseCellPentagon(int baseCell);
 bool _isBaseCellPolarPentagon(int baseCell);
 int _faceIjkToBaseCell(const FaceIJK* h);
 int _faceIjkToBaseCellCCWrot60(const FaceIJK* h);
+int _baseCellToCCWrot60(int baseCell, int face);
 void _baseCellToFaceIjk(int baseCell, FaceIJK* h);
 bool _baseCellIsCwOffset(int baseCell, int testFace);
 int _getBaseCellNeighbor(int baseCell, Direction dir);

data/ext/h3/src/src/h3lib/include/bbox.h

@@ -21,6 +21,7 @@
 #define BBOX_H
 
 #include <stdbool.h>
+
 #include "geoCoord.h"
 
 /** @struct BBox
@@ -37,6 +38,8 @@ bool bboxIsTransmeridian(const BBox* bbox);
 void bboxCenter(const BBox* bbox, GeoCoord* center);
 bool bboxContains(const BBox* bbox, const GeoCoord* point);
 bool bboxEquals(const BBox* b1, const BBox* b2);
-int bboxHexRadius(const BBox* bbox, int res);
+int bboxHexEstimate(const BBox* bbox, int res);
+int lineHexEstimate(const GeoCoord* origin, const GeoCoord* destination,
+                    int res);
 
 #endif

data/ext/h3/src/src/h3lib/include/faceijk.h

@@ -75,9 +75,10 @@ typedef enum {
 void _geoToFaceIjk(const GeoCoord* g, int res, FaceIJK* h);
 void _geoToHex2d(const GeoCoord* g, int res, int* face, Vec2d* v);
 void _faceIjkToGeo(const FaceIJK* h, int res, GeoCoord* g);
-void _faceIjkToGeoBoundary(const FaceIJK* h, int res, int isPentagon,
+void _faceIjkToGeoBoundary(const FaceIJK* h, int res, int start, int length,
                            GeoBoundary* g);
-void _faceIjkPentToGeoBoundary(const FaceIJK* h, int res, GeoBoundary* g);
+void _faceIjkPentToGeoBoundary(const FaceIJK* h, int res, int start, int length,
+                               GeoBoundary* g);
 void _faceIjkToVerts(FaceIJK* fijk, int* res, FaceIJK* fijkVerts);
 void _faceIjkPentToVerts(FaceIJK* fijk, int* res, FaceIJK* fijkVerts);
 void _hex2dToGeo(const Vec2d* v, int face, int res, int substrate, GeoCoord* g);

data/ext/h3/src/src/h3lib/include/geoCoord.h

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2017 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.
@@ -23,6 +23,7 @@
 #include <stdbool.h>
 #include <stdint.h>
 #include <stdio.h>
+
 #include "constants.h"
 #include "h3api.h"
 
@@ -43,8 +44,6 @@ bool geoAlmostEqualThreshold(const GeoCoord* p1, const GeoCoord* p2,
 
 double _posAngleRads(double rads);
 void _setGeoRads(GeoCoord* p, double latRads, double lonRads);
-double _geoDistRads(const GeoCoord* p1, const GeoCoord* p2);
-double _geoDistKm(const GeoCoord* p1, const GeoCoord* p2);
 double _geoAzimuthRads(const GeoCoord* p1, const GeoCoord* p2);
 void _geoAzDistanceRads(const GeoCoord* p1, double az, double distance,
                         GeoCoord* p2);

data/ext/h3/src/src/h3lib/include/h3Index.h

@@ -46,6 +46,12 @@
 /** The number of bits in a single H3 resolution digit. */
 #define H3_PER_DIGIT_OFFSET 3
 
+/** 1 in the highest bit, 0's everywhere else. */
+#define H3_HIGH_BIT_MASK ((uint64_t)(1) << H3_MAX_OFFSET)
+
+/** 0 in the highest bit, 1's everywhere else. */
+#define H3_HIGH_BIT_MASK_NEGATIVE (~H3_HIGH_BIT_MASK)
+
 /** 1's in the 4 mode bits, 0's everywhere else. */
 #define H3_MODE_MASK ((uint64_t)(15) << H3_MODE_OFFSET)
 
@@ -74,11 +80,27 @@
 #define H3_DIGIT_MASK ((uint64_t)(7))
 
 /** 0's in the 7 base cell bits, 1's everywhere else. */
-#define H3_DIGIT_MASK_NEGATIVE (~H3_DIGIT_MASK_NEGATIVE)
+#define H3_DIGIT_MASK_NEGATIVE (~H3_DIGIT_MASK)
 
-/** H3 index with mode 0, res 0, base cell 0, and 7 for all index digits. */
+/**
+ * H3 index with mode 0, res 0, base cell 0, and 7 for all index digits.
+ * Typically used to initialize the creation of an H3 cell index, which
+ * expects all direction digits to be 7 beyond the cell's resolution.
+ */
 #define H3_INIT (UINT64_C(35184372088831))
 
+/**
+ * Gets the highest bit of the H3 index.
+ */
+#define H3_GET_HIGH_BIT(h3) ((int)((((h3)&H3_HIGH_BIT_MASK) >> H3_MAX_OFFSET)))
+
+/**
+ * Sets the highest bit of the h3 to v.
+ */
+#define H3_SET_HIGH_BIT(h3, v)                 \
+    (h3) = (((h3)&H3_HIGH_BIT_MASK_NEGATIVE) | \
+            (((uint64_t)(v)) << H3_MAX_OFFSET))
+
 /**
  * Gets the integer mode of h3.
  */
@@ -143,9 +165,19 @@
              << ((MAX_H3_RES - (res)) * H3_PER_DIGIT_OFFSET)))
 
 /**
- * Invalid index used to indicate an error from geoToH3 and related functions.
+ * Invalid index used to indicate an error from geoToH3 and related functions
+ * or missing data in arrays of h3 indices. Analogous to NaN in floating point.
  */
-#define H3_INVALID_INDEX 0
+#define H3_NULL 0
+
+/*
+ * Return codes for compact
+ */
+
+#define COMPACT_SUCCESS 0
+#define COMPACT_LOOP_EXCEEDED -1
+#define COMPACT_DUPLICATE -2
+#define COMPACT_ALLOC_FAILED -3
 
 void setH3Index(H3Index* h, int res, int baseCell, Direction initDigit);
 int isResClassIII(int res);
@@ -153,6 +185,7 @@ int isResClassIII(int res);
 // Internal functions
 
 int _h3ToFaceIjkWithInitializedFijk(H3Index h, FaceIJK* fijk);
+void _h3ToFaceIjk(H3Index h, FaceIJK* fijk);
 H3Index _faceIjkToH3(const FaceIJK* fijk, int res);
 Direction _h3LeadingNonZeroDigit(H3Index h);
 H3Index _h3RotatePent60ccw(H3Index h);