h3 3.6.0 → 3.7.2

data/ext/h3/src/src/apps/testapps/testPolygon.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.
@@ -16,6 +16,7 @@
 
 #include <assert.h>
 #include <stdlib.h>
+
 #include "bbox.h"
 #include "constants.h"
 #include "geoCoord.h"
@@ -553,4 +554,29 @@ SUITE(polygon) {
 
         H3_EXPORT(destroyLinkedPolygon)(&polygon);
     }
+
+    TEST(normalizeMultiPolygon_unassignedHole) {
+        GeoCoord verts[] = {{0, 0}, {0, 1}, {1, 1}, {1, 0}};
+
+        LinkedGeoLoop* outer = malloc(sizeof(*outer));
+        assert(outer != NULL);
+        createLinkedLoop(outer, &verts[0], 4);
+
+        GeoCoord verts2[] = {{2, 2}, {3, 3}, {2, 3}};
+
+        LinkedGeoLoop* inner = malloc(sizeof(*inner));
+        assert(inner != NULL);
+        createLinkedLoop(inner, &verts2[0], 3);
+
+        LinkedGeoPolygon polygon = {0};
+        addLinkedLoop(&polygon, inner);
+        addLinkedLoop(&polygon, outer);
+
+        int result = normalizeMultiPolygon(&polygon);
+
+        t_assert(result == NORMALIZATION_ERR_UNASSIGNED_HOLES,
+                 "Expected error code returned");
+
+        H3_EXPORT(destroyLinkedPolygon)(&polygon);
+    }
 }

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

data/ext/h3/src/src/h3lib/include/h3api.h.in

@@ -1,5 +1,5 @@
 /*
- * Copyright 2016-2019 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.
@@ -150,7 +150,7 @@ typedef struct {
  * Functions for geoToH3
  * @{
  */
-/** @brief find the H3 index of the resolution res cell containing the lat/lon g
+/** @brief find the H3 index of the resolution res cell containing the lat/lng
  */
 H3Index H3_EXPORT(geoToH3)(const GeoCoord *g, int res);
 /** @} */
@@ -183,8 +183,7 @@ int H3_EXPORT(hexRange)(H3Index origin, int k, H3Index *out);
 /** @} */
 
 /** @brief hexagons neighbors in all directions, assuming no pentagons,
- * reporting
- * distance from origin */
+ * reporting distance from origin */
 int H3_EXPORT(hexRangeDistances)(H3Index origin, int k, H3Index *out,
                                  int *distances);
 
@@ -252,33 +251,77 @@ double H3_EXPORT(degsToRads)(double degrees);
 double H3_EXPORT(radsToDegs)(double radians);
 /** @} */
 
+/** @defgroup pointDist pointDist
+ * Functions for pointDist
+ * @{
+ */
+/** @brief "great circle distance" between pairs of GeoCoord points in radians*/
+double H3_EXPORT(pointDistRads)(const GeoCoord *a, const GeoCoord *b);
+
+/** @brief "great circle distance" between pairs of GeoCoord points in
+ * kilometers*/
+double H3_EXPORT(pointDistKm)(const GeoCoord *a, const GeoCoord *b);
+
+/** @brief "great circle distance" between pairs of GeoCoord points in meters*/
+double H3_EXPORT(pointDistM)(const GeoCoord *a, const GeoCoord *b);
+/** @} */
+
 /** @defgroup hexArea hexArea
  * Functions for hexArea
  * @{
  */
-/** @brief hexagon area in square kilometers */
+/** @brief average hexagon area in square kilometers (excludes pentagons) */
 double H3_EXPORT(hexAreaKm2)(int res);
 
-/** @brief hexagon area in square meters */
+/** @brief average hexagon area in square meters (excludes pentagons) */
 double H3_EXPORT(hexAreaM2)(int res);
 /** @} */
 
+/** @defgroup cellArea cellArea
+ * Functions for cellArea
+ * @{
+ */
+/** @brief exact area for a specific cell (hexagon or pentagon) in radians^2 */
+double H3_EXPORT(cellAreaRads2)(H3Index h);
+
+/** @brief exact area for a specific cell (hexagon or pentagon) in kilometers^2
+ */
+double H3_EXPORT(cellAreaKm2)(H3Index h);
+
+/** @brief exact area for a specific cell (hexagon or pentagon) in meters^2 */
+double H3_EXPORT(cellAreaM2)(H3Index h);
+/** @} */
+
 /** @defgroup edgeLength edgeLength
  * Functions for edgeLength
  * @{
  */
-/** @brief hexagon edge length in kilometers */
+/** @brief average hexagon edge length in kilometers (excludes pentagons) */
 double H3_EXPORT(edgeLengthKm)(int res);
 
-/** @brief hexagon edge length in meters */
+/** @brief average hexagon edge length in meters (excludes pentagons) */
 double H3_EXPORT(edgeLengthM)(int res);
 /** @} */
 
+/** @defgroup exactEdgeLength exactEdgeLength
+ * Functions for exactEdgeLength
+ * @{
+ */
+/** @brief exact length for a specific unidirectional edge in radians*/
+double H3_EXPORT(exactEdgeLengthRads)(H3Index edge);
+
+/** @brief exact length for a specific unidirectional edge in kilometers*/
+double H3_EXPORT(exactEdgeLengthKm)(H3Index edge);
+
+/** @brief exact length for a specific unidirectional edge in meters*/
+double H3_EXPORT(exactEdgeLengthM)(H3Index edge);
+/** @} */
+
 /** @defgroup numHexagons numHexagons
  * Functions for numHexagons
  * @{
  */
-/** @brief number of hexagons for a given resolution */
+/** @brief number of cells (hexagons and pentagons) for a given resolution */
 int64_t H3_EXPORT(numHexagons)(int res);
 /** @} */
 
@@ -286,10 +329,10 @@ int64_t H3_EXPORT(numHexagons)(int res);
  * Functions for getRes0Indexes
  * @{
  */
-/** @brief returns the number of resolution 0 indexes */
+/** @brief returns the number of resolution 0 cells (hexagons and pentagons) */
 int H3_EXPORT(res0IndexCount)();
 
-/** @brief provides all base cells */
+/** @brief provides all base cells in H3Index format*/
 void H3_EXPORT(getRes0Indexes)(H3Index *out);
 /** @} */
 
@@ -308,7 +351,8 @@ void H3_EXPORT(getPentagonIndexes)(int res, H3Index *out);
  * Functions for h3GetResolution
  * @{
  */
-/** @brief returns the resolution of the provided hexagon */
+/** @brief returns the resolution of the provided H3 index
+ * Works on both cells and unidirectional edges. */
 int H3_EXPORT(h3GetResolution)(H3Index h);
 /** @} */
 
@@ -316,7 +360,10 @@ int H3_EXPORT(h3GetResolution)(H3Index h);
  * Functions for h3GetBaseCell
  * @{
  */
-/** @brief returns the base cell of the provided hexagon */
+/** @brief returns the base cell "number" (0 to 121) of the provided H3 cell
+ *
+ * Note: Technically works on H3 edges, but will return base cell of the
+ * origin cell. */
 int H3_EXPORT(h3GetBaseCell)(H3Index h);
 /** @} */
 
@@ -340,7 +387,9 @@ void H3_EXPORT(h3ToString)(H3Index h, char *str, size_t sz);
  * Functions for h3IsValid
  * @{
  */
-/** @brief confirms if an H3Index is valid */
+/** @brief confirms if an H3Index is a valid cell (hexagon or pentagon)
+ * In particular, returns 0 (False) for H3 unidirectional edges or invalid data
+ */
 int H3_EXPORT(h3IsValid)(H3Index h);
 /** @} */
 
@@ -358,8 +407,7 @@ H3Index H3_EXPORT(h3ToParent)(H3Index h, int parentRes);
  * @{
  */
 /** @brief determines the maximum number of children (or grandchildren, etc)
- * that
- * could be returned for the given hexagon */
+ * that could be returned for the given hexagon */
 int H3_EXPORT(maxH3ToChildrenSize)(H3Index h, int childRes);
 
 /** @brief provides the children (or grandchildren, etc) of the given hexagon */
@@ -410,7 +458,7 @@ int H3_EXPORT(h3IsResClassIII)(H3Index h);
  * Functions for h3IsPentagon
  * @{
  */
-/** @brief determines if a hexagon is actually a pentagon */
+/** @brief determines if an H3 cell is a pentagon */
 int H3_EXPORT(h3IsPentagon)(H3Index h);
 /** @} */