h3 3.6.2 → 3.7.1

data/ext/h3/src/src/h3lib/lib/linkedGeo.c

@@ -18,8 +18,11 @@
  */
 
 #include "linkedGeo.h"
+
 #include <assert.h>
 #include <stdlib.h>
+
+#include "alloc.h"
 #include "geoCoord.h"
 #include "h3api.h"
 
@@ -30,7 +33,7 @@
  */
 LinkedGeoPolygon* addNewLinkedPolygon(LinkedGeoPolygon* polygon) {
     assert(polygon->next == NULL);
-    LinkedGeoPolygon* next = calloc(1, sizeof(*next));
+    LinkedGeoPolygon* next = H3_MEMORY(calloc)(1, sizeof(*next));
     assert(next != NULL);
     polygon->next = next;
     return next;
@@ -42,7 +45,7 @@ LinkedGeoPolygon* addNewLinkedPolygon(LinkedGeoPolygon* polygon) {
  * @return         Pointer to loop
  */
 LinkedGeoLoop* addNewLinkedLoop(LinkedGeoPolygon* polygon) {
-    LinkedGeoLoop* loop = calloc(1, sizeof(*loop));
+    LinkedGeoLoop* loop = H3_MEMORY(calloc)(1, sizeof(*loop));
     assert(loop != NULL);
     return addLinkedLoop(polygon, loop);
 }
@@ -71,7 +74,7 @@ LinkedGeoLoop* addLinkedLoop(LinkedGeoPolygon* polygon, LinkedGeoLoop* loop) {
  * @return        Pointer to the coordinate
  */
 LinkedGeoCoord* addLinkedCoord(LinkedGeoLoop* loop, const GeoCoord* vertex) {
-    LinkedGeoCoord* coord = malloc(sizeof(*coord));
+    LinkedGeoCoord* coord = H3_MEMORY(malloc)(sizeof(*coord));
     assert(coord != NULL);
     *coord = (LinkedGeoCoord){.vertex = *vertex, .next = NULL};
     LinkedGeoCoord* last = loop->last;
@@ -95,7 +98,7 @@ void destroyLinkedGeoLoop(LinkedGeoLoop* loop) {
     for (LinkedGeoCoord* currentCoord = loop->first; currentCoord != NULL;
          currentCoord = nextCoord) {
         nextCoord = currentCoord->next;
-        free(currentCoord);
+        H3_MEMORY(free)(currentCoord);
     }
 }
 
@@ -115,14 +118,14 @@ void H3_EXPORT(destroyLinkedPolygon)(LinkedGeoPolygon* polygon) {
              currentLoop != NULL; currentLoop = nextLoop) {
             destroyLinkedGeoLoop(currentLoop);
             nextLoop = currentLoop->next;
-            free(currentLoop);
+            H3_MEMORY(free)(currentLoop);
         }
         nextPolygon = currentPolygon->next;
         if (skip) {
             // do not free the input polygon
             skip = false;
         } else {
-            free(currentPolygon);
+            H3_MEMORY(free)(currentPolygon);
         }
     }
 }
@@ -242,9 +245,10 @@ static const LinkedGeoPolygon* findPolygonForHole(
     }
     // Initialize arrays for candidate loops and their bounding boxes
     const LinkedGeoPolygon** candidates =
-        malloc(polygonCount * sizeof(LinkedGeoPolygon*));
+        H3_MEMORY(malloc)(polygonCount * sizeof(LinkedGeoPolygon*));
     assert(candidates != NULL);
-    const BBox** candidateBBoxes = malloc(polygonCount * sizeof(BBox*));
+    const BBox** candidateBBoxes =
+        H3_MEMORY(malloc)(polygonCount * sizeof(BBox*));
     assert(candidateBBoxes != NULL);
 
     // Find all polygons that contain the loop
@@ -267,8 +271,8 @@ static const LinkedGeoPolygon* findPolygonForHole(
         findDeepestContainer(candidates, candidateBBoxes, candidateCount);
 
     // Free allocated memory
-    free(candidates);
-    free(candidateBBoxes);
+    H3_MEMORY(free)(candidates);
+    H3_MEMORY(free)(candidateBBoxes);
 
     return parent;
 }
@@ -308,11 +312,12 @@ int normalizeMultiPolygon(LinkedGeoPolygon* root) {
     // Create an array to hold all of the inner loops. Note that
     // this array will never be full, as there will always be fewer
     // inner loops than outer loops.
-    LinkedGeoLoop** innerLoops = malloc(loopCount * sizeof(LinkedGeoLoop*));
+    LinkedGeoLoop** innerLoops =
+        H3_MEMORY(malloc)(loopCount * sizeof(LinkedGeoLoop*));
     assert(innerLoops != NULL);
 
     // Create an array to hold the bounding boxes for the outer loops
-    BBox* bboxes = malloc(loopCount * sizeof(BBox));
+    BBox* bboxes = H3_MEMORY(malloc)(loopCount * sizeof(BBox));
     assert(bboxes != NULL);
 
     // Get the first loop and unlink it from root
@@ -349,14 +354,14 @@ int normalizeMultiPolygon(LinkedGeoPolygon* root) {
             // been unlinked from the root and the caller will no longer have
             // a way to destroy it with destroyLinkedPolygon.
             destroyLinkedGeoLoop(innerLoops[i]);
-            free(innerLoops[i]);
+            H3_MEMORY(free)(innerLoops[i]);
             resultCode = NORMALIZATION_ERR_UNASSIGNED_HOLES;
         }
     }
 
     // Free allocated memory
-    free(innerLoops);
-    free(bboxes);
+    H3_MEMORY(free)(innerLoops);
+    H3_MEMORY(free)(bboxes);
 
     return resultCode;
 }

data/ext/h3/src/src/h3lib/lib/localij.c

@@ -20,11 +20,11 @@
  * an origin index.
  */
 #include <assert.h>
-#include <faceijk.h>
 #include <inttypes.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "baseCells.h"
 #include "faceijk.h"
 #include "h3Index.h"

data/ext/h3/src/src/h3lib/lib/polygon.c

@@ -18,9 +18,11 @@
  */
 
 #include "polygon.h"
+
 #include <float.h>
 #include <math.h>
 #include <stdbool.h>
+
 #include "bbox.h"
 #include "constants.h"
 #include "geoCoord.h"

data/ext/h3/src/src/h3lib/lib/vec2d.c

@@ -18,6 +18,7 @@
  */
 
 #include "vec2d.h"
+
 #include <math.h>
 #include <stdio.h>
 

data/ext/h3/src/src/h3lib/lib/vec3d.c

@@ -18,6 +18,7 @@
  */
 
 #include "vec3d.h"
+
 #include <math.h>
 
 /**

data/ext/h3/src/src/h3lib/lib/vertex.c

@@ -0,0 +1,134 @@
+/*
+ * 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  vertex.h
+ *  @brief Functions for working with cell vertexes.
+ */
+
+#include "vertex.h"
+
+#include "baseCells.h"
+#include "faceijk.h"
+#include "geoCoord.h"
+#include "h3Index.h"
+
+#define DIRECTION_INDEX_OFFSET 2
+
+/** @brief Table of direction-to-face mapping for each pentagon
+ *
+ * Note that faces are in directional order, starting at J_AXES_DIGIT.
+ * This table is generated by the generatePentagonDirectionFaces script.
+ */
+static const PentagonDirectionFaces pentagonDirectionFaces[NUM_PENTAGONS] = {
+    {4, {4, 0, 2, 1, 3}},       {14, {6, 11, 2, 7, 1}},
+    {24, {5, 10, 1, 6, 0}},     {38, {7, 12, 3, 8, 2}},
+    {49, {9, 14, 0, 5, 4}},     {58, {8, 13, 4, 9, 3}},
+    {63, {11, 6, 15, 10, 16}},  {72, {12, 7, 16, 11, 17}},
+    {83, {10, 5, 19, 14, 15}},  {97, {13, 8, 17, 12, 18}},
+    {107, {14, 9, 18, 13, 19}}, {117, {15, 19, 17, 18, 16}},
+};
+
+/**
+ * Get the number of CCW rotations of the cell's vertex numbers
+ * compared to the directional layout of its neighbors.
+ * @return Number of CCW rotations for the cell
+ */
+int vertexRotations(H3Index cell) {
+    // Get the face and other info for the origin
+    FaceIJK fijk;
+    _h3ToFaceIjk(cell, &fijk);
+    int baseCell = H3_EXPORT(h3GetBaseCell)(cell);
+    int cellLeadingDigit = _h3LeadingNonZeroDigit(cell);
+
+    // get the base cell face
+    FaceIJK baseFijk;
+    _baseCellToFaceIjk(baseCell, &baseFijk);
+
+    int ccwRot60 = _baseCellToCCWrot60(baseCell, fijk.face);
+
+    if (_isBaseCellPentagon(baseCell)) {
+        // Find the appropriate direction-to-face mapping
+        PentagonDirectionFaces dirFaces;
+        for (int p = 0; p < NUM_PENTAGONS; p++) {
+            if (pentagonDirectionFaces[p].baseCell == baseCell) {
+                dirFaces = pentagonDirectionFaces[p];
+                break;
+            }
+        }
+
+        // additional CCW rotation for polar neighbors or IK neighbors
+        if (fijk.face != baseFijk.face &&
+            (_isBaseCellPolarPentagon(baseCell) ||
+             fijk.face ==
+                 dirFaces.faces[IK_AXES_DIGIT - DIRECTION_INDEX_OFFSET])) {
+            ccwRot60 = (ccwRot60 + 1) % 6;
+        }
+
+        // Check whether the cell crosses a deleted pentagon subsequence
+        if (cellLeadingDigit == JK_AXES_DIGIT &&
+            fijk.face ==
+                dirFaces.faces[IK_AXES_DIGIT - DIRECTION_INDEX_OFFSET]) {
+            // Crosses from JK to IK: Rotate CW
+            ccwRot60 = (ccwRot60 + 5) % 6;
+        } else if (cellLeadingDigit == IK_AXES_DIGIT &&
+                   fijk.face ==
+                       dirFaces.faces[JK_AXES_DIGIT - DIRECTION_INDEX_OFFSET]) {
+            // Crosses from IK to JK: Rotate CCW
+            ccwRot60 = (ccwRot60 + 1) % 6;
+        }
+    }
+    return ccwRot60;
+}
+
+/** @brief Hexagon direction to vertex number relationships (same face).
+ *         Note that we don't use direction 0 (center).
+ */
+static const int directionToVertexNumHex[NUM_DIGITS] = {
+    INVALID_DIGIT, 3, 1, 2, 5, 4, 0};
+
+/** @brief Pentagon direction to vertex number relationships (same face).
+ *         Note that we don't use directions 0 (center) or 1 (deleted K axis).
+ */
+static const int directionToVertexNumPent[NUM_DIGITS] = {
+    INVALID_DIGIT, INVALID_DIGIT, 1, 2, 4, 3, 0};
+
+/**
+ * Get the first vertex number for a given direction. The neighbor in this
+ * direction is located between this vertex number and the next number in
+ * sequence.
+ * @returns The number for the first topological vertex, or INVALID_VERTEX_NUM
+ *          if the direction is not valid for this cell
+ */
+int vertexNumForDirection(const H3Index origin, const Direction direction) {
+    int isPentagon = H3_EXPORT(h3IsPentagon)(origin);
+    // Check for invalid directions
+    if (direction == CENTER_DIGIT || direction >= INVALID_DIGIT ||
+        (isPentagon && direction == K_AXES_DIGIT))
+        return INVALID_VERTEX_NUM;
+
+    // Determine the vertex rotations for this cell
+    int rotations = vertexRotations(origin);
+
+    // Find the appropriate vertex, rotating CCW if necessary
+    if (isPentagon) {
+        return (directionToVertexNumPent[direction] + NUM_PENT_VERTS -
+                rotations) %
+               NUM_PENT_VERTS;
+    } else {
+        return (directionToVertexNumHex[direction] + NUM_HEX_VERTS -
+                rotations) %
+               NUM_HEX_VERTS;
+    }
+}

data/ext/h3/src/src/h3lib/lib/vertexGraph.c

@@ -18,11 +18,14 @@
  */
 
 #include "vertexGraph.h"
+
 #include <assert.h>
 #include <math.h>
 #include <stdint.h>
 #include <stdio.h>
 #include <stdlib.h>
+
+#include "alloc.h"
 #include "geoCoord.h"
 
 /**
@@ -33,7 +36,7 @@
  */
 void initVertexGraph(VertexGraph* graph, int numBuckets, int res) {
     if (numBuckets > 0) {
-        graph->buckets = calloc(numBuckets, sizeof(VertexNode*));
+        graph->buckets = H3_MEMORY(calloc)(numBuckets, sizeof(VertexNode*));
         assert(graph->buckets != NULL);
     } else {
         graph->buckets = NULL;
@@ -53,7 +56,7 @@ void destroyVertexGraph(VertexGraph* graph) {
     while ((node = firstVertexNode(graph)) != NULL) {
         removeVertexNode(graph, node);
     }
-    free(graph->buckets);
+    H3_MEMORY(free)(graph->buckets);
 }
 
 /**
@@ -91,7 +94,7 @@ void _initVertexNode(VertexNode* node, const GeoCoord* fromVtx,
 VertexNode* addVertexNode(VertexGraph* graph, const GeoCoord* fromVtx,
                           const GeoCoord* toVtx) {
     // Make the new node
-    VertexNode* node = malloc(sizeof(VertexNode));
+    VertexNode* node = H3_MEMORY(malloc)(sizeof(VertexNode));
     assert(node != NULL);
     _initVertexNode(node, fromVtx, toVtx);
     // Determine location
@@ -108,7 +111,7 @@ VertexNode* addVertexNode(VertexGraph* graph, const GeoCoord* fromVtx,
             if (geoAlmostEqual(&currentNode->from, fromVtx) &&
                 geoAlmostEqual(&currentNode->to, toVtx)) {
                 // already exists, bail
-                free(node);
+                H3_MEMORY(free)(node);
                 return currentNode;
             }
             if (currentNode->next != NULL) {
@@ -150,7 +153,7 @@ int removeVertexNode(VertexGraph* graph, VertexNode* node) {
         }
     }
     if (found) {
-        free(node);
+        H3_MEMORY(free)(node);
         graph->size--;
         return 0;
     }

data/ext/h3/src/website/.eslintignore

@@ -0,0 +1,2 @@
+dist/
+node_modules/

data/ext/h3/src/website/.gitignore

@@ -0,0 +1,57 @@
+### Node ###
+# Logs
+logs
+*.log
+npm-debug.log*
+
+# Runtime data
+pids
+*.pid
+*.seed
+*.pid.lock
+
+# Directory for instrumented libs generated by jscoverage/JSCover
+lib-cov
+
+# Coverage directory used by tools like istanbul
+coverage
+
+# nyc test coverage
+.nyc_output
+
+# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
+.grunt
+
+# node-waf configuration
+.lock-wscript
+
+# Compiled binary addons (http://nodejs.org/api/addons.html)
+build/Release
+
+# Dependency directories
+node_modules
+jspm_packages
+
+# Optional npm cache directory
+.npm
+
+# Optional eslint cache
+.eslintcache
+
+# Optional REPL history
+.node_repl_history
+
+# Output of 'npm pack'
+*.tgz
+
+# Yarn Integrity file
+.yarn-integrity
+
+
+# Gatsby context
+.gatsby-context.js
+
+# Bundle stats
+bundle-stats.json
+
+package-lock.json

data/ext/h3/src/website/.nvmrc

@@ -0,0 +1 @@
+v10.17.0

data/ext/h3/src/website/README.md

@@ -1,24 +1,26 @@
 # H3 Documentation Website
 
-This is the source for the [H3 documentation website](https://uber.github.io/h3/).
+This is the source for the [H3 documentation website](https://h3geo.org/).
 
 The source of the pages in the documentation is in the [docs](../docs) directory.
 
 ## Building Locally
 
-Building the documentation requires Node.js. To build and view the H3 documentation, 
+Building the documentation requires Node.js. To build and view the H3 documentation,
 run the following from `./website`:
 
 ```
-npm install
-npm run build
-npm start
+yarn
+yarn run build
 ```
 
+You will then be able to open `public/index.html` in your browser. Note that images
+will not render because they expect a `/h3/` path prefix.
+
 ## Updating the H3 Website
 
 Make sure your `gh-pages` branch has its remote set to the upstream repo, then
 
 ```
 make publish-website
-```
+```