h3 3.6.0 → 3.7.2

data/ext/h3/src/docs/core-library/coordsystems.md

@@ -1,5 +1,6 @@
-Coordinate Systems used by the H3 Core Library
----
+# Coordinate systems
+
+The **H3 Core Library** uses the following coordinate systems internally.
 
 IJK Coordinates
 ---
@@ -9,7 +10,7 @@ Discrete hexagon planar grid systems naturally have 3 coordinate axes spaced 120
 Using an *ijk* coordinate system to address hexagon grid cells provides multiple valid addresses for each cell. *Normalizing* an *ijk* address (function `_ijkNormalize`) creates a unique address consisting of the minimal positive *ijk* components; this always results in at most two non-zero components.
 
 <div align="center">
-  <img height="300" src="images/ijkp.png" />
+  <img height="300" src="/images/ijkp.png" />
 </div>
 
 FaceIJK Coordinates
@@ -20,7 +21,7 @@ The **H3 Core Library** centers an *ijk* coordinate system on each face of the i
 Each grid resolution is rotated ~19.1&deg; relative to the next coarser resolution. The rotation alternates between counterclockwise and clockwise at each successive resolution, so that each resolution will have one of two possible orientations: *Class II* or *Class III* (using a terminology coined by R. Buckminster Fuller). The base cells, which make up resolution 0, are *Class II*.
 
 <div align="center">
-  <img height="300" src="images/classII.III.png" />
+  <img height="300" src="/images/classII.III.png" />
 </div>
 
 Hex2d Coordinates

data/ext/h3/src/docs/core-library/filters.md

@@ -1,11 +1,10 @@
-Unix-style Filters for Address Conversion
----
+# Unix-style Filters for H3
 
 The directory `src/apps/filters` contains unix-style stdin/stdout filters that perform conversions between integer **H3** indexes and other useful types. It currently contains the filters listed in the table below. See the header comments in each application source code file for more information.
 
 Filters are experimental and are not part of the semantic version of the H3 library.
 
-All latitude/longitude coordinates are in decimal degrees. See the <a href="#/documentation/core-library/h3-index-representations"> **H3** Index Representations</a> page for information on the integer `H3Index`.
+All latitude/longitude coordinates are in decimal degrees. See the [**H3** Index Representations](/docs/core-library/h3indexing) page for information on the integer `H3Index`.
 
 
 | filter           | input     | outputs
@@ -22,26 +21,26 @@ Unix Command Line Examples
 
 * find the index for coordinates at resolution 5
 
-     `echo 40.689167 -74.044444 | geoToH3 5`
+     `geoToH3 --resolution 5 --latitude 40.689167 --longitude -74.044444`
 
 * output the cell center point for `H3Index` 845ad1bffffffff
 
-     `echo 845ad1bffffffff | h3ToGeo`
+     `h3ToGeo --index 845ad1bffffffff`
 
 * output the cell boundary for `H3Index` 845ad1bffffffff
 
-     `echo 845ad1bffffffff | h3ToGeoBoundary`
+     `h3ToGeoBoundary --index 845ad1bffffffff`
 
 * find the components for the `H3Index` 845ad1bffffffff
 
-     `echo 845ad1bffffffff | h3ToComponents`
+     `h3ToComponents --index 845ad1bffffffff`
 
 * output all indexes within distance 1 of the `H3Index` 845ad1bffffffff
 
-     `echo 845ad1bffffffff | kRing 1`
+     `kRing -k 1 --origin 845ad1bffffffff`
 
 * output all hexagon indexes within distance 2 of the `H3Index` 845ad1bffffffff
 
-     `echo 845ad1bffffffff | hexRange 2`
+     `hexRange -k 2 --origin 845ad1bffffffff`
 
 Note that the filters `h3ToGeo` and `h3ToGeoBoundary` take optional arguments that allow them to generate `kml` output. See the header comments in the corresponding source code files for details.

data/ext/h3/src/docs/core-library/geoToH3desc.md

@@ -1,9 +1,8 @@
-Conversion from latitude/longitude to containing H3 cell index
----
+# Conversion from latitude/longitude to containing H3 cell index
 
 This operation is performed by function `geoToH3`. See the comments in the function for more detail.
 
-The conversion is performed as a series of coordinate system conversions described below. See the page <a href="#/documentation/core-library/coordinate-systems">Coordinate Systems used by the **H3 Core Library**</a> for more information on each of these coordinate systems.
+The conversion is performed as a series of coordinate system conversions described below. See the page [Coordinate Systems used by the **H3 Core Library**](/docs/core-library/coordsystems) for more information on each of these coordinate systems.
 
 1. The input latitude/longitude coordinate is first converted into the containing icosahedron face and a *Hex2d* coordinate on that face using function `_geoToHex2d`, which determines the correct face and then performs a face-centered gnomonic projection into face-centered polar coordinates. These polar coordinates are then scaled appropriately to a *Hex2d* coordinate on the input grid resolution *r*.
 2. The *Hex2d* coordinate is converted into resolution *r* normalized *ijk* coordinates using function `_hex2dToCoordIJK`.

data/ext/h3/src/docs/core-library/h3ToGeoBoundaryDesc.md

@@ -1,15 +1,14 @@
-Generate the cell boundary in latitude/longitude coordinates of an H3Index cell
----
+# Generate the cell boundary in latitude/longitude coordinates of an H3Index cell
 
 This operation is performed by function `h3ToGeoBoundary`. See the comments in the function source code for more detail.
 
-The conversion is performed as a series of coordinate system conversions described below. See the page <a href="#/documentation/core-library/coordinate-systems">Coordinate Systems used by the **H3 Core Library**</a> for more information on each of these coordinate systems.
+The conversion is performed as a series of coordinate system conversions described below. See the page [Coordinate Systems used by the **H3 Core Library**](/docs/core-library/coordsystems) for more information on each of these coordinate systems.
 
 * We note that the cell vertices are the center points of cells in an aperture 3 grid one resolution finer than the cell resolution, which we term a *substrate* grid. We precalculate the substrate *ijk* coordinates of a cell with *ijk* coordinates (0,0,0), adding additional aperture 3 and aperture 7 (if required, by Class III cell grid) substrate grid resolutions as required to transform the vertex coordinates into a Class II substrate grid.
 
 <div align="center">
-  <img height="300" src="images/substrate3.png" />
+  <img height="300" src="/images/substrate3.png" />
 </div>
 
-* The function `_faceIjkToGeoBoundary` calculates the *ijk* coordinates of the cell center point in the appropriate substrate grid (determined in the last step), and each of the substrate vertices is translated using the cell center point *ijk*. Each vertex *ijk* is then transformed onto the appropriate face and *Hex2d* coordinate system using the approach taken in <a href="#/documentation/core-library/walkthrough-of-h3togeo">finding a cell center point</a>. If adjacent vertices lie on different icosahedron faces a point is introduced at the intersection of the cell edge and icosahedron face edge.
+* The function `_faceIjkToGeoBoundary` calculates the *ijk* coordinates of the cell center point in the appropriate substrate grid (determined in the last step), and each of the substrate vertices is translated using the cell center point *ijk*. Each vertex *ijk* is then transformed onto the appropriate face and *Hex2d* coordinate system using the approach taken in [finding a cell center point](/docs/core-library/h3ToGeoDesc). If adjacent vertices lie on different icosahedron faces a point is introduced at the intersection of the cell edge and icosahedron face edge.
 * The *Hex2d* coordinates are then converted to latitude/longitude using `_hex2dToGeo`.

data/ext/h3/src/docs/core-library/h3ToGeoDesc.md

@@ -1,9 +1,8 @@
-Determine the latitude/longitude coordinates of the center point of an H3Index cell
----
+# Determine the latitude/longitude coordinates of the center point of an H3Index cell
 
 This operation is performed by function `h3ToGeo`. See the comments in the function source code for more detail.
 
-The conversion is performed as a series of coordinate system conversions described below. See the page <a href="#/documentation/core-library/coordinate-systems">Coordinate Systems used by the **H3 Core Library**</a> for more information on each of these coordinate systems.
+The conversion is performed as a series of coordinate system conversions described below. See the page [Coordinate Systems used by the **H3 Core Library**](/docs/core-library/coordsystems) for more information on each of these coordinate systems.
 
 *  The function `_h3ToFaceIjk` then converts the **H3** index to the appropriate icosahedron face number and normalized *ijk* coordinate's on that face's coordinate system as follows:
    * We start by assuming that the cell center point falls on the same icosahedron face as its base cell.
@@ -11,7 +10,7 @@ The conversion is performed as a series of coordinate system conversions describ
      We determine whether an overage exists by taking the sum of the *ijk* components, and if there is an overage the positive *ijk* components indicate which adjacent face the cell center lies on. A lookup operation is then performed to find the appropriate rotation and translation to transform the *ijk* coordinates into the adjacent face-centered *ijk* system.
 
 <div align="center">
-  <img height="300" src="images/triEdge.png" />
+  <img height="300" src="/images/triEdge.png" />
 </div>
 
 * The face-centered *ijk* coordinates are then converted into corresponding *Hex2d* coordinates using the function `_ijkToHex2d`.

data/ext/h3/src/docs/core-library/h3indexing.md

@@ -1,45 +1,54 @@
-H3 Index Representations
----
+# H3 Index Representations
 
-Introduction
----
+## Introduction
 
 The **H3** system assigns a unique hierarchical index to each cell. The **H3** index of a resolution *r* cell begins with the appropriate resolution 0 base cell number. This is followed by a sequence of *r* digits 0-6, where each *i*<sup>th</sup> digit *d*<sub>i</sub> specifies one of the 7 cells centered on the cell indicated by the coarser resolution digits *d*<sub>1</sub> through *d*<sub>i-1</sub>. A local hexagon coordinate system is assigned to each of the resolution 0 base cells and is used to orient all hierarchical indexing child cells of that base cell. The assignment of digits 0-6 at each resolution uses a *Central Place Indexing* arrangement (see [Sahr, 2014](http://webpages.sou.edu/~sahrk/sqspc/pubs/autocarto14.pdf)). In the case of the 12 pentagonal cells the indexing hierarchy produced by sub-digit 1 is removed at all resolutions.
 
 Child hexagons are linearly smaller than their parent hexagons.
 
 <div align="center">
-  <img height="300" src="images/cpidigits.png" />
+  <img height="300" src="/images/cpidigits.png" />
 </div>
 
 
-H3Index Representation
----
+## H3Index Representation
 
-The **H3Index** is the integer representation of an **H3** index, which can be placed into multiple modes to indicate the kind of concept being indexed. Mode 1 is an **H3** Cell (Hexagon) Index, mode 2 is an **H3** Unidirectional Edge (Hexagon A -> Hexagon B) Index, mode 3 is planned to be a bidirectional edge (Hexagon A <-> Hexagon B). Mode 0 is reserved and indicates an invalid **H3** index.
+The **H3Index** is the integer representation of an **H3** index, which can be placed into multiple modes to indicate the concept being indexed.
 
-The components of the **H3** cell index (mode 1) are packed into the lowest order 63 bits of a 64-bit integer in order as follows:
+* Mode 1 is an **H3** Cell (Hexagon/Pentagon) index.
+* Mode 2 is an **H3** Unidirectional Edge (Cell A -> Cell B) index.
+* Mode 3 is planned to be a bidirectional edge (Cell A <-> Cell B).
+* Mode 0 is reserved and indicates an invalid **H3** index.
+  * This mode remains, partially, for backwards compatibility with an older version of H3.
 
+Mode 0 contains a special index, `H3_NULL`, which is unique: it is bit-equivalent to `0`.
+This index indicates, *specifically*, an invalid, missing, or uninitialized **H3** index;
+it is analogous to `NaN` in floating point.
+It should be used instead of an arbitrary Mode 0 index, due to its uniqueness and easy identifiability.
+
+The components of the **H3** cell index (mode 1) are packed into a 64-bit integer in order, highest bit first, as follows:
+
+* 1 bit reserved and set to 0,
 * 4 bits to indicate the index mode,
-* 3 bits reserved,
+* 3 bits reserved and set to 0,
 * 4 bits to indicate the cell resolution 0-15,
 * 7 bits to indicate the base cell 0-121, and
-* 3 bits to indicate each subsequent digit 0-6 from resolution 1 up to the resolution of the cell (45 bits total is reserved for resolutions 1-15)
+* 3 bits to indicate each subsequent digit 0-6 from resolution 1 up to the resolution of the cell (45 bits total are reserved for resolutions 1-15)
 
-The components of the **H3** unidirectional edge index (mode 2) are packed into the lowest order 63 bits of a 64-bit integer in order as follows:
+The components of the **H3** unidirectional edge index (mode 2) are packed into a 64-bit integer in order, highest bit first, as follows:
 
+* 1 bit reserved and set to 0,
 * 4 bits to indicate the index mode,
 * 3 bits to indicate the edge 1-6 of the cell to traverse,
 * 4 bits to indicate the cell resolution 0-15,
 * 7 bits to indicate the base cell 0-121, and
-* 3 bits to indicate each subsequent digit 0-6 from resolution 1 up to the resolution of the cell (45 bits total is reserved for resolutions 1-15)
+* 3 bits to indicate each subsequent digit 0-6 from resolution 1 up to the resolution of the cell (45 bits total are reserved for resolutions 1-15)
 
-The canonical string representation of an **H3Index** is the hexadecimal representation of the integer.
+The canonical string representation of an **H3Index** is the hexadecimal representation of the integer, using lowercase letters. The string representation is variable length (no zero padding) and is not prefixed or suffixed.
 
 The three bits for each unused digit are set to 7.
 
-Bit layout of H3Index
----
+## Bit layout of H3Index
 
 The layout of an **H3Index** is shown below in table form. The interpretation of the "Reserved/edge" field differs depending on the mode of the index.
 
@@ -65,7 +74,7 @@ The layout of an **H3Index** is shown below in table form. The interpretation of
 </tr>
 <tr>
   <th>0x30</th>
-  <td></td>
+  <td>Reserved</td>
   <td colspan="4">Mode</td>
   <td colspan="3">Reserved/edge</td>
   <td colspan="4">Resolution</td>

data/ext/h3/src/docs/core-library/overview.md

@@ -1,5 +1,4 @@
-Overview of the H3 Geospatial Indexing System
----
+# Overview of the H3 Geospatial Indexing System
 
 The **H3** geospatial indexing system is a discrete global grid system (see [Sahr et al., 2003](http://webpages.sou.edu/~sahrk/sqspc/pubs/gdggs03.pdf)) consisting of a multi-precision hexagonal tiling of the sphere with hierarchical indexes. The hexagonal grid system is created on the planar faces of a sphere-circumscribed icosahedron, and the grid cells are then projected to the surface of the sphere using an inverse face-centered polyhedral gnomonic projection.
 
@@ -9,6 +8,6 @@ The **H3** grid is constructed on the icosahedron by recursively creating increa
 
 The first **H3** resolution (resolution 0) consists of 122 cells (110 hexagons and 12 icosahedron vertex-centered pentagons), referred to as the *base cells*. These were chosen to capture as much of the symmetry of the spherical icosahedron as possible. These base cells are assigned numbers from 0 to 121 based on the latitude of their center points; base cell 0 has the northern most center point, while base cell 121 has the southern most center point.
 
-Each subsequent resolution beyond resolution 0 is created using an aperture 7 resolution spacing (aperture refers to the number of cells in the next finer resolution grid for each cell); as resolution increases the unit length is scaled by \\(\sqrt{7}\\) and each hexagon has \\(1/7th\\) the area of a hexagon at the next coarser resolution (as measured on the icosahedron). **H3** provides 15 finer grid resolutions in addition to the resolution 0 base cells. The finest resolution, resolution 15, has cells with an area of less than 1 \\(m^2\\). A table detailing the average cell area for each H3 resolution is available <a href="#/documentation/core-library/resolution-table">here</a>.
+Each subsequent resolution beyond resolution 0 is created using an aperture 7 resolution spacing (aperture refers to the number of cells in the next finer resolution grid for each cell); as resolution increases the unit length is scaled by $\sqrt{7}$ and each hexagon has $1/7th$ the area of a hexagon at the next coarser resolution (as measured on the icosahedron). **H3** provides 15 finer grid resolutions in addition to the resolution 0 base cells. The finest resolution, resolution 15, has cells with an area of less than $1 m^2$. A table detailing the average cell area for each H3 resolution is available [here](/docs/core-library/restable).
 
 *Note:* you can create KML files to visualize the **H3** grids by running the `kml` make target. It will place the files in the `KML` output sub-directory.

data/ext/h3/src/docs/core-library/restable.md

@@ -1,5 +1,4 @@
-Table of Cell Areas for H3 Resolutions
----
+# Table of Cell Areas for H3 Resolutions
 
 | H3 Resolution | Average Hexagon Area (km<sup>2</sup>) | Average Hexagon Edge Length (km) | Number of unique indexes
 | ------------- | ------------------------------------: | -------------------------------: | -----------------------:

data/ext/h3/src/docs/core-library/usage.md

@@ -1,5 +1,4 @@
-How to use H3
----
+# How to use H3
 
 The public API of the **H3 Core Library** is defined in the file h3api.h. The functions defined in h3api.h adhere to [Semantic Versioning](http://semver.org/).
 

data/ext/h3/src/docs/table-of-contents.json

@@ -0,0 +1,47 @@
+{
+  "id": "table-of-contents",
+  "chapters": [
+    {
+      "title": "Overview",
+      "entries": [
+        {"entry": "docs/README"},
+        {"entry": "docs/usecases"}
+      ]
+    },
+    {
+      "title": "Core Library",
+      "entries": [
+        {"entry": "docs/core-library/overview"},
+        {"entry": "docs/core-library/h3indexing"},
+        {"entry": "docs/core-library/coordsystems"},
+        {"entry": "docs/core-library/geoToH3desc"},
+        {"entry": "docs/core-library/h3ToGeoDesc"},
+        {"entry": "docs/core-library/h3ToGeoBoundaryDesc"},
+        {"entry": "docs/core-library/filters"},
+        {"entry": "docs/core-library/usage"},
+        {"entry": "docs/core-library/restable"}
+      ]
+    },
+    {
+      "title": "API Reference",
+      "entries": [
+        {"entry": "docs/api/indexing"},
+        {"entry": "docs/api/inspection"},
+        {"entry": "docs/api/traversal"},
+        {"entry": "docs/api/hierarchy"},
+        {"entry": "docs/api/regions"},
+        {"entry": "docs/api/uniedge"},
+        {"entry": "docs/api/misc"}
+      ]
+    },
+    {
+      "title": "Community",
+      "entries": [
+        {"entry": "docs/community/bindings"},
+        {"entry": "docs/community/libraries"},
+        {"entry": "docs/community/tutorials"},
+        {"entry": "docs/community/applications"}
+      ]
+    }
+  ]
+}

data/ext/h3/src/docs/{overview/usecases.md → usecases.md}

@@ -1,8 +1,4 @@
-Why H3
----
-
-Use cases
----
+# Use cases
 
 Analysis of data sets of locations, such as locations of cars in a city, may be done by bucketing locations. ([Sahr et al., 2003](http://webpages.sou.edu/~sahrk/sqspc/pubs/gdggs03.pdf)) There are several options for partitioning an area into buckets, such as manually drawing regions using human knowledge, or to partition the surface using a regular grid.
 
@@ -16,7 +12,7 @@ Using a regular grid can avoid these drawbacks by providing smooth gradients and
 
 | Triangle | Square | Hexagon
 | -------- | ------ | -------
-| <img src="images/neighbors-triangle.png" style="width:400px"> | <img src="images/neighbors-square.png" style="width:400px"> | <img src="images/neighbors-hexagon.png" style="width:400px">
+| <img src="/images/neighbors-triangle.png" style="width:400px"> | <img src="/images/neighbors-square.png" style="width:400px"> | <img src="/images/neighbors-hexagon.png" style="width:400px">
 | Triangles have 12 neighbors | Squares have 8 neighbors | Hexagons have 6 neighbors
 
 In addition to indexing locations to cells, **H3** provides a number of algorithms operating on indexes.
@@ -24,14 +20,14 @@ In addition to indexing locations to cells, **H3** provides a number of algorith
 Hexagons have the property of expanding rings of neighbors (`kRing`) approximating circles:
 
 <div align="center">
-  <img src="images/neighbors.png" style="width:400px"><br>
+  <img src="/images/neighbors.png" style="width:400px"><br>
   <i>All six neighbors of a hexagon (ring 1)</i>
 </div>
 
 Squares cleanly subdivide into four finer squares. Hexagons do not cleanly subdivide into seven finer hexagons. However, by alternating the orientation of grids a subdivision into seven cells (referred to as *aperture 7*) can be approximated. This makes it possible to truncate the precision (within a fixed margin of error) of an **H3** index using a few bitwise operations (`h3ToParent`). It is also possible to determine all the children of a parent **H3** index (`h3ToChildren`). Approximate containment only applies when truncating the precision of an **H3** index. The borders of hexagons indexed at a specific resolution are not approximate.
 
 <div align="center">
-  <img src="images/parent-child.png" style="width:400px"><br>
+  <img src="/images/parent-child.png" style="width:400px"><br>
   <i>A parent hexagon approximately contains seven children</i>
 </div>
 
@@ -39,11 +35,10 @@ Hierarchical containment allows for use cases like making contiguous sets of hex
 
 | Uncompact (dense) | Compact (sparse)
 | ----------------- | ----------------
-| <img src="images/ca_uncompact_6_10633.png" style="width:500px"> | <img src="images/ca_compact_6_901.png" style="width:500px">
+| <img src="/images/ca_uncompact_6_10633.png" style="width:500px"> | <img src="/images/ca_compact_6_901.png" style="width:500px">
 | California represented by 10633 uncompact hexagons | California represented by 901 compact hexagons
 
-Comparisons
----
+## Comparisons
 
 | System    | Index representation | Cell shape | Projection system
 | --------- | -------------------- | ---------- | -----------------

data/ext/h3/src/scripts/binding_functions.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Copyright 2017 Uber Technologies, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");

data/ext/h3/src/scripts/coverage.sh.in

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 
 # Copyright 2018-2019 Uber Technologies, Inc.
 #

data/ext/h3/src/scripts/update_version.sh

@@ -1,4 +1,4 @@
-#!/bin/bash
+#!/usr/bin/env bash
 # Copyright 2019 Uber Technologies, Inc.
 #
 # Licensed under the Apache License, Version 2.0 (the "License");
@@ -13,7 +13,7 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-# This script is used interactively as part of the H3 release process 
+# This script is used interactively as part of the H3 release process
 # (RELEASE.md) to update the version number in the VERSION file. Before
 # writing the new version to the file, changelog information is presented
 # for verification. It is invoked by the make target `update-version`.

data/ext/h3/src/src/apps/applib/include/args.h

@@ -23,6 +23,7 @@
 #include <inttypes.h>
 #include <stdbool.h>
 #include <stdio.h>
+
 #include "utility.h"
 
 /** Maximum number of names an argument may have. */

data/ext/h3/src/src/apps/applib/include/test.h

@@ -21,6 +21,7 @@
 #define TEST_H
 
 #include <stdio.h>
+
 #include "geoCoord.h"
 #include "h3api.h"
 

data/ext/h3/src/src/apps/applib/include/utility.h

@@ -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.
@@ -21,6 +21,7 @@
 #define UTILITY_H
 
 #include <stdio.h>
+
 #include "coordijk.h"
 #include "h3api.h"
 
@@ -54,5 +55,10 @@ void iterateAllIndexesAtResPartial(int res, void (*callback)(H3Index),
                                    int maxBaseCell);
 void iterateBaseCellIndexesAtRes(int res, void (*callback)(H3Index),
                                  int baseCell);
+void iterateAllUnidirectionalEdgesAtRes(int res, void (*callback)(H3Index));
+double mapSumAllCells_double(int res, double (*callback)(H3Index));
+size_t packNonzeros(H3Index* a, size_t n);
+
+int countActualHexagons(H3Index* hexagons, int numHexagons);
 
 #endif

data/ext/h3/src/src/apps/applib/lib/args.c

@@ -18,10 +18,12 @@
  */
 
 #include "args.h"
+
 #include <stdbool.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+
 #include "h3api.h"
 
 /*

data/ext/h3/src/src/apps/applib/lib/kml.c

@@ -18,7 +18,9 @@
  */
 
 #include "kml.h"
+
 #include <stdio.h>
+
 #include "h3api.h"
 
 void kmlPtsHeader(const char* name, const char* desc) {

data/ext/h3/src/src/apps/applib/lib/test.c

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