From 513fb6a9d7db9c237d24464ed253e0262642bed8 Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Thu, 1 Sep 2022 16:58:16 -0700 Subject: [PATCH 01/19] initial --- src/h3lib/include/h3api.h.in | 3 ++ src/h3lib/lib/algos.c | 64 ++++++++++++++++++++++++++++++++++++ 2 files changed, 67 insertions(+) diff --git a/src/h3lib/include/h3api.h.in b/src/h3lib/include/h3api.h.in index 3f533d5de..0d9c5fca8 100644 --- a/src/h3lib/include/h3api.h.in +++ b/src/h3lib/include/h3api.h.in @@ -298,6 +298,9 @@ DECLSPEC H3Error H3_EXPORT(cellsToLinkedMultiPolygon)(const H3Index *h3Set, DECLSPEC void H3_EXPORT(destroyLinkedMultiPolygon)(LinkedGeoPolygon *polygon); /** @} */ +DECLSPEC H3Error H3_EXPORT(LinkedToGeoMultiPolygon)(const LinkedGeoPolygon *lgp, + GeoMultiPolygon *gmp); + /** @defgroup degsToRads degsToRads * Functions for degsToRads * @{ diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index 5e385bb51..a278dc210 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1155,3 +1155,67 @@ H3Error H3_EXPORT(cellsToLinkedMultiPolygon)(const H3Index *h3Set, destroyVertexGraph(&graph); return E_SUCCESS; } + +/* +typedef struct { + int numVerts; + LatLng *verts; +} GeoLoop; + + +typedef struct { + GeoLoop geoloop; ///< exterior boundary of the polygon + int numHoles; ///< number of elements in the array pointed to by holes + GeoLoop *holes; ///< interior boundaries (holes) in the polygon +} GeoPolygon; + +typedef struct { + int numPolygons; + GeoPolygon *polygons; +} GeoMultiPolygon; + +typedef struct LinkedLatLng LinkedLatLng; +struct LinkedLatLng { + LatLng vertex; + LinkedLatLng *next; +}; + +typedef struct LinkedGeoLoop LinkedGeoLoop; +struct LinkedGeoLoop { + LinkedLatLng *first; + LinkedLatLng *last; + LinkedGeoLoop *next; +}; + +typedef struct LinkedGeoPolygon LinkedGeoPolygon; +struct LinkedGeoPolygon { + LinkedGeoLoop *first; + LinkedGeoLoop *last; + LinkedGeoPolygon *next; +}; +*/ + +H3Error H3_EXPORT(LinkedToGeoMultiPolygon)(const LinkedGeoPolygon *link_poly, + GeoMultiPolygon *geo_poly) { + geo_poly->numPolygons = 0; + + LinkedGeoPolygon *L = link_poly; + while (L) { + geo_poly->numPolygons++; + L = L->next; + } + geo_poly->polygons = + H3_MEMORY(calloc)(geo_poly->numPolygons, sizeof(GeoPolygon)); + + L = link_poly; + while (L) { + // geo_poly->numPolygons++; + L = L->next; + // TODO: do something + } +} + +H3Error _LinkedGeoPolygon_to_Polygon(const LinkedGeoPolygon *link_poly, + GeoPolygon *poly) { + 1 + 1; +} From b010c6e4f56a7e5c55454674fd9db1297c093a1c Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Thu, 1 Sep 2022 17:34:57 -0700 Subject: [PATCH 02/19] all the way down. about to head back up... --- src/h3lib/lib/algos.c | 105 ++++++++++++++++++++++++++++++------------ 1 file changed, 75 insertions(+), 30 deletions(-) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index a278dc210..e945d9754 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1157,11 +1157,6 @@ H3Error H3_EXPORT(cellsToLinkedMultiPolygon)(const H3Index *h3Set, } /* -typedef struct { - int numVerts; - LatLng *verts; -} GeoLoop; - typedef struct { GeoLoop geoloop; ///< exterior boundary of the polygon @@ -1174,19 +1169,6 @@ typedef struct { GeoPolygon *polygons; } GeoMultiPolygon; -typedef struct LinkedLatLng LinkedLatLng; -struct LinkedLatLng { - LatLng vertex; - LinkedLatLng *next; -}; - -typedef struct LinkedGeoLoop LinkedGeoLoop; -struct LinkedGeoLoop { - LinkedLatLng *first; - LinkedLatLng *last; - LinkedGeoLoop *next; -}; - typedef struct LinkedGeoPolygon LinkedGeoPolygon; struct LinkedGeoPolygon { LinkedGeoLoop *first; @@ -1195,27 +1177,90 @@ struct LinkedGeoPolygon { }; */ -H3Error H3_EXPORT(LinkedToGeoMultiPolygon)(const LinkedGeoPolygon *link_poly, - GeoMultiPolygon *geo_poly) { - geo_poly->numPolygons = 0; +int num_polys(LinkedGeoPolygon *L) { + int n = 0; + while (L) { + n++; + L = L->next; + } + return n; +} - LinkedGeoPolygon *L = link_poly; +int num_loops(LinkedGeoLoop *L) { + int n = 0; while (L) { - geo_poly->numPolygons++; + n++; L = L->next; } + return n; +} + +int num_latlngs(LinkedLatLng *L) { + int n = 0; + while (L) { + n++; + L = L->next; + } + return n; +} + +H3Error H3_EXPORT(LinkedToGeoMultiPolygon)(const LinkedGeoPolygon *link_poly, + GeoMultiPolygon *geo_poly) { + geo_poly->numPolygons = num_polys(link_poly); geo_poly->polygons = H3_MEMORY(calloc)(geo_poly->numPolygons, sizeof(GeoPolygon)); - L = link_poly; + // L = link_poly; + // while (L) { + // // geo_poly->numPolygons++; + // L = L->next; + // // TODO: do something + // } +} + +GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { + GeoPolygon geo_poly; + geo_poly.numHoles = num_loops(link_poly.first) - 1; + + // do exterior loop + // do the holes loops + + return geo_poly; +} + +/* +typedef struct { + int numVerts; + LatLng *verts; +} GeoLoop; + +typedef struct LinkedGeoLoop LinkedGeoLoop; +struct LinkedGeoLoop { + LinkedLatLng *first; + LinkedLatLng *last; + LinkedGeoLoop *next; +}; + +typedef struct LinkedLatLng LinkedLatLng; +struct LinkedLatLng { + LatLng vertex; + LinkedLatLng *next; +}; + */ +GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { + int n = num_latlngs(link_loop.first); + + GeoLoop geo_loop; + geo_loop.numVerts = n; + geo_loop.verts = H3_MEMORY(calloc)(n, sizeof(LatLng)); + + LinkedLatLng *L = link_loop.first; + int i = 0; while (L) { - // geo_poly->numPolygons++; + geo_loop.verts[i] = L->vertex; L = L->next; - // TODO: do something + i++; } -} -H3Error _LinkedGeoPolygon_to_Polygon(const LinkedGeoPolygon *link_poly, - GeoPolygon *poly) { - 1 + 1; + return geo_loop; } From 18fcac6f409b0790b327862b13e558fc4c263744 Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Thu, 1 Sep 2022 17:38:56 -0700 Subject: [PATCH 03/19] comments --- src/h3lib/lib/algos.c | 15 +++++++++++++++ 1 file changed, 15 insertions(+) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index e945d9754..2b0dc3895 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1218,6 +1218,21 @@ H3Error H3_EXPORT(LinkedToGeoMultiPolygon)(const LinkedGeoPolygon *link_poly, // } } +/* + +typedef struct { + GeoLoop geoloop; ///< exterior boundary of the polygon + int numHoles; ///< number of elements in the array pointed to by holes + GeoLoop *holes; ///< interior boundaries (holes) in the polygon +} GeoPolygon; + +typedef struct LinkedGeoPolygon LinkedGeoPolygon; +struct LinkedGeoPolygon { + LinkedGeoLoop *first; + LinkedGeoLoop *last; + LinkedGeoPolygon *next; +}; + */ GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { GeoPolygon geo_poly; geo_poly.numHoles = num_loops(link_poly.first) - 1; From 5c285a31a3030e85a82b65b2fe00ab36d12d7c7d Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Thu, 1 Sep 2022 18:08:35 -0700 Subject: [PATCH 04/19] up a bit --- src/h3lib/lib/algos.c | 72 ++++++++++++++++++++++++++----------------- 1 file changed, 43 insertions(+), 29 deletions(-) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index 2b0dc3895..35c8d154f 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1218,58 +1218,31 @@ H3Error H3_EXPORT(LinkedToGeoMultiPolygon)(const LinkedGeoPolygon *link_poly, // } } -/* - -typedef struct { - GeoLoop geoloop; ///< exterior boundary of the polygon - int numHoles; ///< number of elements in the array pointed to by holes - GeoLoop *holes; ///< interior boundaries (holes) in the polygon -} GeoPolygon; - -typedef struct LinkedGeoPolygon LinkedGeoPolygon; -struct LinkedGeoPolygon { - LinkedGeoLoop *first; - LinkedGeoLoop *last; - LinkedGeoPolygon *next; -}; - */ -GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { - GeoPolygon geo_poly; - geo_poly.numHoles = num_loops(link_poly.first) - 1; - - // do exterior loop - // do the holes loops - - return geo_poly; -} - /* typedef struct { int numVerts; LatLng *verts; } GeoLoop; -typedef struct LinkedGeoLoop LinkedGeoLoop; struct LinkedGeoLoop { LinkedLatLng *first; LinkedLatLng *last; LinkedGeoLoop *next; }; -typedef struct LinkedLatLng LinkedLatLng; struct LinkedLatLng { LatLng vertex; LinkedLatLng *next; }; */ GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { - int n = num_latlngs(link_loop.first); + int n = num_latlngs(link_loop.first); // double? GeoLoop geo_loop; geo_loop.numVerts = n; geo_loop.verts = H3_MEMORY(calloc)(n, sizeof(LatLng)); - LinkedLatLng *L = link_loop.first; + LinkedLatLng *L = link_loop.first; // double? int i = 0; while (L) { geo_loop.verts[i] = L->vertex; @@ -1279,3 +1252,44 @@ GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { return geo_loop; } + +/* + +typedef struct { + GeoLoop geoloop; ///< exterior boundary of the polygon + int numHoles; ///< number of elements in the array pointed to by holes + GeoLoop *holes; ///< interior boundaries (holes) in the polygon +} GeoPolygon; + +struct LinkedGeoPolygon { + LinkedGeoLoop *first; + LinkedGeoLoop *last; + LinkedGeoPolygon *next; +}; + +struct LinkedGeoLoop { + LinkedLatLng *first; + LinkedLatLng *last; + LinkedGeoLoop *next; +}; + + */ +GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { + GeoPolygon geo_poly; + + LinkedGeoLoop *L = link_poly.first; + geo_poly.geoloop = _LinkedGeoLoop_to_GeoLoop(*L); + L = L->next; + + geo_poly.numHoles = num_loops(L); + geo_poly.holes = H3_MEMORY(calloc)(geo_poly.numHoles, sizeof(GeoLoop)); + + int i = 0; + while (L) { + geo_poly.holes[i] = _LinkedGeoLoop_to_GeoLoop(*L); + L = L->next; + i++; + } + + return geo_poly; +} From 10caa51746187a701283ccd3f233ece62b0192bf Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Thu, 1 Sep 2022 18:27:46 -0700 Subject: [PATCH 05/19] all the way up? --- src/h3lib/include/h3api.h.in | 3 --- src/h3lib/lib/algos.c | 46 +++++++++++++++++++++++++----------- 2 files changed, 32 insertions(+), 17 deletions(-) diff --git a/src/h3lib/include/h3api.h.in b/src/h3lib/include/h3api.h.in index 0d9c5fca8..3f533d5de 100644 --- a/src/h3lib/include/h3api.h.in +++ b/src/h3lib/include/h3api.h.in @@ -298,9 +298,6 @@ DECLSPEC H3Error H3_EXPORT(cellsToLinkedMultiPolygon)(const H3Index *h3Set, DECLSPEC void H3_EXPORT(destroyLinkedMultiPolygon)(LinkedGeoPolygon *polygon); /** @} */ -DECLSPEC H3Error H3_EXPORT(LinkedToGeoMultiPolygon)(const LinkedGeoPolygon *lgp, - GeoMultiPolygon *gmp); - /** @defgroup degsToRads degsToRads * Functions for degsToRads * @{ diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index 35c8d154f..426da44ff 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1204,20 +1204,6 @@ int num_latlngs(LinkedLatLng *L) { return n; } -H3Error H3_EXPORT(LinkedToGeoMultiPolygon)(const LinkedGeoPolygon *link_poly, - GeoMultiPolygon *geo_poly) { - geo_poly->numPolygons = num_polys(link_poly); - geo_poly->polygons = - H3_MEMORY(calloc)(geo_poly->numPolygons, sizeof(GeoPolygon)); - - // L = link_poly; - // while (L) { - // // geo_poly->numPolygons++; - // L = L->next; - // // TODO: do something - // } -} - /* typedef struct { int numVerts; @@ -1293,3 +1279,35 @@ GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { return geo_poly; } + +/* +struct LinkedGeoPolygon { + LinkedGeoLoop *first; + LinkedGeoLoop *last; + LinkedGeoPolygon *next; +}; + +typedef struct { + int numPolygons; + GeoPolygon *polygons; +} GeoMultiPolygon; + + */ +GeoMultiPolygon _LinkedGeoPolygon_to_GeoMultiPolygon( + LinkedGeoPolygon *link_poly) { + int n = num_polys(link_poly); + + GeoMultiPolygon geo_mpoly; + geo_mpoly.numPolygons = n; + geo_mpoly.polygons = H3_MEMORY(calloc)(n, sizeof(GeoPolygon)); + + LinkedGeoPolygon *L = link_poly; + int i = 0; + while (L) { + geo_mpoly.polygons[i] = _LinkedGeoPolygon_to_Polygon(*L); + L = L->next; + i++; + } + + return geo_mpoly; +} From a020b11087ccfd244aac71559ea74651b98245d6 Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Thu, 1 Sep 2022 18:30:35 -0700 Subject: [PATCH 06/19] clean up comments --- src/h3lib/lib/algos.c | 94 ++++++++++++++++--------------------------- 1 file changed, 34 insertions(+), 60 deletions(-) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index 426da44ff..336bddd86 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1156,26 +1156,6 @@ H3Error H3_EXPORT(cellsToLinkedMultiPolygon)(const H3Index *h3Set, return E_SUCCESS; } -/* - -typedef struct { - GeoLoop geoloop; ///< exterior boundary of the polygon - int numHoles; ///< number of elements in the array pointed to by holes - GeoLoop *holes; ///< interior boundaries (holes) in the polygon -} GeoPolygon; - -typedef struct { - int numPolygons; - GeoPolygon *polygons; -} GeoMultiPolygon; - -typedef struct LinkedGeoPolygon LinkedGeoPolygon; -struct LinkedGeoPolygon { - LinkedGeoLoop *first; - LinkedGeoLoop *last; - LinkedGeoPolygon *next; -}; -*/ int num_polys(LinkedGeoPolygon *L) { int n = 0; @@ -1205,21 +1185,20 @@ int num_latlngs(LinkedLatLng *L) { } /* -typedef struct { - int numVerts; - LatLng *verts; -} GeoLoop; - -struct LinkedGeoLoop { - LinkedLatLng *first; - LinkedLatLng *last; - LinkedGeoLoop *next; -}; - -struct LinkedLatLng { - LatLng vertex; - LinkedLatLng *next; -}; +GeoLoop: + int numVerts + LatLng *verts + + +LinkedGeoLoop: + LinkedLatLng *first + LinkedLatLng *last + LinkedGeoLoop *next + +LinkedLatLng: + LatLng vertex + LinkedLatLng *next + */ GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { int n = num_latlngs(link_loop.first); // double? @@ -1241,23 +1220,20 @@ GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { /* -typedef struct { - GeoLoop geoloop; ///< exterior boundary of the polygon - int numHoles; ///< number of elements in the array pointed to by holes - GeoLoop *holes; ///< interior boundaries (holes) in the polygon -} GeoPolygon; +GeoPolygon: + GeoLoop geoloop + int numHoles + GeoLoop *holes -struct LinkedGeoPolygon { - LinkedGeoLoop *first; - LinkedGeoLoop *last; - LinkedGeoPolygon *next; -}; +LinkedGeoPolygon: + LinkedGeoLoop *first + LinkedGeoLoop *last + LinkedGeoPolygon *next -struct LinkedGeoLoop { - LinkedLatLng *first; - LinkedLatLng *last; - LinkedGeoLoop *next; -}; +LinkedGeoLoop: + LinkedLatLng *first + LinkedLatLng *last + LinkedGeoLoop *next */ GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { @@ -1281,16 +1257,14 @@ GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { } /* -struct LinkedGeoPolygon { - LinkedGeoLoop *first; - LinkedGeoLoop *last; - LinkedGeoPolygon *next; -}; - -typedef struct { - int numPolygons; - GeoPolygon *polygons; -} GeoMultiPolygon; +LinkedGeoPolygon: + LinkedGeoLoop *first + LinkedGeoLoop *last + LinkedGeoPolygon *next + +GeoMultiPolygon: + int numPolygons + GeoPolygon *polygons */ GeoMultiPolygon _LinkedGeoPolygon_to_GeoMultiPolygon( From a811c464248f9bbdac85a1d7eb9e9b73cbd0985f Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Fri, 2 Sep 2022 13:43:33 -0700 Subject: [PATCH 07/19] jabbering on about nothing --- src/h3lib/lib/algos.c | 52 +++++++++++++++++++++++++------------------ 1 file changed, 30 insertions(+), 22 deletions(-) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index 336bddd86..898f5f1df 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1156,7 +1156,6 @@ H3Error H3_EXPORT(cellsToLinkedMultiPolygon)(const H3Index *h3Set, return E_SUCCESS; } - int num_polys(LinkedGeoPolygon *L) { int n = 0; while (L) { @@ -1185,11 +1184,6 @@ int num_latlngs(LinkedLatLng *L) { } /* -GeoLoop: - int numVerts - LatLng *verts - - LinkedGeoLoop: LinkedLatLng *first LinkedLatLng *last @@ -1199,13 +1193,17 @@ int num_latlngs(LinkedLatLng *L) { LatLng vertex LinkedLatLng *next +GeoLoop: + int numVerts + LatLng *verts */ GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { int n = num_latlngs(link_loop.first); // double? - GeoLoop geo_loop; - geo_loop.numVerts = n; - geo_loop.verts = H3_MEMORY(calloc)(n, sizeof(LatLng)); + GeoLoop geo_loop = { + .numVerts = n, + .verts = H3_MEMORY(calloc)(n, sizeof(LatLng)) // comment to make this + }; LinkedLatLng *L = link_loop.first; // double? int i = 0; @@ -1219,12 +1217,6 @@ GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { } /* - -GeoPolygon: - GeoLoop geoloop - int numHoles - GeoLoop *holes - LinkedGeoPolygon: LinkedGeoLoop *first LinkedGeoLoop *last @@ -1235,6 +1227,10 @@ GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { LinkedLatLng *last LinkedGeoLoop *next +GeoPolygon: + GeoLoop geoloop + int numHoles + GeoLoop *holes */ GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { GeoPolygon geo_poly; @@ -1243,6 +1239,11 @@ GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { geo_poly.geoloop = _LinkedGeoLoop_to_GeoLoop(*L); L = L->next; + // todo: try the struct member notation here. might be a bit triky for this + // one + // notationally, the setup here is amazing, becuase it makes it very clear + // via symmetry to the user that we are setting up the thing we are + // populating in this structure. geo_poly.numHoles = num_loops(L); geo_poly.holes = H3_MEMORY(calloc)(geo_poly.numHoles, sizeof(GeoLoop)); @@ -1267,21 +1268,28 @@ GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { GeoPolygon *polygons */ -GeoMultiPolygon _LinkedGeoPolygon_to_GeoMultiPolygon( - LinkedGeoPolygon *link_poly) { +GeoMultiPolygon _LinkedGeoPoly_to_GeoMultiPolygon(LinkedGeoPolygon *link_poly) { int n = num_polys(link_poly); - GeoMultiPolygon geo_mpoly; - geo_mpoly.numPolygons = n; - geo_mpoly.polygons = H3_MEMORY(calloc)(n, sizeof(GeoPolygon)); + GeoMultiPolygon geo_mpoly = { + .numPolygons = n, + .polygons = H3_MEMORY(calloc)(n, sizeof(GeoPolygon)) // combine this + }; LinkedGeoPolygon *L = link_poly; - int i = 0; + int i = 0; // macro here? while (L) { - geo_mpoly.polygons[i] = _LinkedGeoPolygon_to_Polygon(*L); + { + geo_mpoly.polygons[i] = _LinkedGeoPolygon_to_Polygon(*L); + } // with this? L = L->next; i++; } + // something like this: + // WALK(i, L, { geo_mpoly.polygons[i] = _LinkedGeoPolygon_to_Polygon(*L); }) + return geo_mpoly; } + +// todo: need one to delete GeoMultiPolygon From e195cecb94deca5e62534f24fee53342bd0225ce Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Fri, 2 Sep 2022 13:50:12 -0700 Subject: [PATCH 08/19] nice! --- src/h3lib/lib/algos.c | 20 ++++++++------------ 1 file changed, 8 insertions(+), 12 deletions(-) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index 898f5f1df..4ab45e56d 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1202,7 +1202,7 @@ GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { GeoLoop geo_loop = { .numVerts = n, - .verts = H3_MEMORY(calloc)(n, sizeof(LatLng)) // comment to make this + .verts = H3_MEMORY(calloc)(n, sizeof(LatLng)) }; LinkedLatLng *L = link_loop.first; // double? @@ -1233,20 +1233,16 @@ GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { GeoLoop *holes */ GeoPolygon _LinkedGeoPolygon_to_Polygon(LinkedGeoPolygon link_poly) { - GeoPolygon geo_poly; - LinkedGeoLoop *L = link_poly.first; - geo_poly.geoloop = _LinkedGeoLoop_to_GeoLoop(*L); - L = L->next; - // todo: try the struct member notation here. might be a bit triky for this - // one - // notationally, the setup here is amazing, becuase it makes it very clear - // via symmetry to the user that we are setting up the thing we are - // populating in this structure. - geo_poly.numHoles = num_loops(L); - geo_poly.holes = H3_MEMORY(calloc)(geo_poly.numHoles, sizeof(GeoLoop)); + int n = num_loops(L) - 1; + GeoPolygon geo_poly = { + .geoloop = _LinkedGeoLoop_to_GeoLoop(*L), + .numHoles = n, + .holes = H3_MEMORY(calloc)(n, sizeof(GeoLoop)), + }; + L = L->next; int i = 0; while (L) { geo_poly.holes[i] = _LinkedGeoLoop_to_GeoLoop(*L); From fbc78768170db6f4ebb953c298c545e726450adf Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Thu, 8 Sep 2022 16:03:27 -0700 Subject: [PATCH 09/19] dreams of macros --- src/h3lib/lib/algos.c | 11 +++-------- 1 file changed, 3 insertions(+), 8 deletions(-) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index 4ab45e56d..a9846af27 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1202,7 +1202,7 @@ GeoLoop _LinkedGeoLoop_to_GeoLoop(LinkedGeoLoop link_loop) { GeoLoop geo_loop = { .numVerts = n, - .verts = H3_MEMORY(calloc)(n, sizeof(LatLng)) + .verts = H3_MEMORY(calloc)(n, sizeof(LatLng)) // hello there }; LinkedLatLng *L = link_loop.first; // double? @@ -1273,18 +1273,13 @@ GeoMultiPolygon _LinkedGeoPoly_to_GeoMultiPolygon(LinkedGeoPolygon *link_poly) { }; LinkedGeoPolygon *L = link_poly; - int i = 0; // macro here? + int i = 0; while (L) { - { - geo_mpoly.polygons[i] = _LinkedGeoPolygon_to_Polygon(*L); - } // with this? + geo_mpoly.polygons[i] = _LinkedGeoPolygon_to_Polygon(*L); L = L->next; i++; } - // something like this: - // WALK(i, L, { geo_mpoly.polygons[i] = _LinkedGeoPolygon_to_Polygon(*L); }) - return geo_mpoly; } From 0fd6ee065cd464f8d75073662029d30e99558b7b Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Fri, 9 Sep 2022 22:36:18 -0400 Subject: [PATCH 10/19] expose cellsToGeoMultiPolygon --- src/h3lib/include/h3api.h.in | 3 +++ src/h3lib/lib/algos.c | 17 +++++++++++++++++ 2 files changed, 20 insertions(+) diff --git a/src/h3lib/include/h3api.h.in b/src/h3lib/include/h3api.h.in index 3f533d5de..bc3163bbf 100644 --- a/src/h3lib/include/h3api.h.in +++ b/src/h3lib/include/h3api.h.in @@ -298,6 +298,9 @@ DECLSPEC H3Error H3_EXPORT(cellsToLinkedMultiPolygon)(const H3Index *h3Set, DECLSPEC void H3_EXPORT(destroyLinkedMultiPolygon)(LinkedGeoPolygon *polygon); /** @} */ +H3Error H3_EXPORT(cellsToGeoMultiPolygon)(const H3Index *cells, + const int numCells, + GeoMultiPolygon *out); /** @defgroup degsToRads degsToRads * Functions for degsToRads * @{ diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index a9846af27..ed7106807 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1284,3 +1284,20 @@ GeoMultiPolygon _LinkedGeoPoly_to_GeoMultiPolygon(LinkedGeoPolygon *link_poly) { } // todo: need one to delete GeoMultiPolygon + +H3Error H3_EXPORT(cellsToGeoMultiPolygon)(const H3Index *cells, + const int numCells, + GeoMultiPolygon *out) { + H3Error err; + LinkedGeoPolygon lgp; + + err = H3_EXPORT(cellsToLinkedMultiPolygon)(cells, numCells, &lgp); + if (err) { + return err; + } + + *out = _LinkedGeoPoly_to_GeoMultiPolygon(&lgp); + // todo: capture errors from conversion function + + return E_SUCCESS; +} From c375a8bdc4ea8a544616f433f9d8cd5cb4ea4c9a Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Sat, 10 Sep 2022 02:24:55 -0400 Subject: [PATCH 11/19] add a simple single hexagon test --- .../testapps/testCellsToLinkedMultiPolygon.c | 17 ++++++++++++++++- 1 file changed, 16 insertions(+), 1 deletion(-) diff --git a/src/apps/testapps/testCellsToLinkedMultiPolygon.c b/src/apps/testapps/testCellsToLinkedMultiPolygon.c index 65bbdbc04..366b9bdd4 100644 --- a/src/apps/testapps/testCellsToLinkedMultiPolygon.c +++ b/src/apps/testapps/testCellsToLinkedMultiPolygon.c @@ -16,7 +16,7 @@ #include -#include "algos.h" +#include "algos.h" // not needed? prolly just need linkedGeo.h #include "test.h" #include "utility.h" @@ -47,6 +47,21 @@ SUITE(cellsToLinkedMultiPolygon) { H3_EXPORT(destroyLinkedMultiPolygon)(&polygon); } + TEST(singleHex_GMP) { + GeoMultiPolygon mpoly; + H3Index cells[] = {0x890dab6220bffff}; + int numCells = ARRAY_SIZE(cells); + + t_assertSuccess( + H3_EXPORT(cellsToGeoMultiPolygon)(cells, numCells, &mpoly)); + + t_assert(mpoly.numPolygons == 1, "only one polygon"); + t_assert(mpoly.polygons[0].numHoles == 0, "1 outer loop and no holes"); + t_assert(mpoly.polygons[0].geoloop.numVerts == 6, "6 vertices in hex"); + + // H3_EXPORT(destroyLinkedMultiPolygon)(&polygon); + } + TEST(invalid) { LinkedGeoPolygon polygon; H3Index set[] = {0xfffffffffffffff}; From 418ec020bd9abdff73906f402037da19fd90d053 Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Sat, 10 Sep 2022 23:38:43 -0400 Subject: [PATCH 12/19] some preliminary clear/free functions --- .../testapps/testCellsToLinkedMultiPolygon.c | 2 + src/h3lib/include/h3api.h.in | 9 ++-- src/h3lib/lib/algos.c | 50 ++++++++++++++++++- 3 files changed, 56 insertions(+), 5 deletions(-) diff --git a/src/apps/testapps/testCellsToLinkedMultiPolygon.c b/src/apps/testapps/testCellsToLinkedMultiPolygon.c index 366b9bdd4..f7963853a 100644 --- a/src/apps/testapps/testCellsToLinkedMultiPolygon.c +++ b/src/apps/testapps/testCellsToLinkedMultiPolygon.c @@ -60,6 +60,8 @@ SUITE(cellsToLinkedMultiPolygon) { t_assert(mpoly.polygons[0].geoloop.numVerts == 6, "6 vertices in hex"); // H3_EXPORT(destroyLinkedMultiPolygon)(&polygon); + // H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon *mpoly); // enabling + // this should fix valgrind, yeah? } TEST(invalid) { diff --git a/src/h3lib/include/h3api.h.in b/src/h3lib/include/h3api.h.in index bc3163bbf..724d7d0e6 100644 --- a/src/h3lib/include/h3api.h.in +++ b/src/h3lib/include/h3api.h.in @@ -298,9 +298,12 @@ DECLSPEC H3Error H3_EXPORT(cellsToLinkedMultiPolygon)(const H3Index *h3Set, DECLSPEC void H3_EXPORT(destroyLinkedMultiPolygon)(LinkedGeoPolygon *polygon); /** @} */ -H3Error H3_EXPORT(cellsToGeoMultiPolygon)(const H3Index *cells, - const int numCells, - GeoMultiPolygon *out); +DECLSPEC H3Error H3_EXPORT(cellsToGeoMultiPolygon)(const H3Index *cells, + const int numCells, + GeoMultiPolygon *out); + +DECLSPEC void H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon *mpoly); + /** @defgroup degsToRads degsToRads * Functions for degsToRads * @{ diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index ed7106807..adaabc87a 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1283,8 +1283,6 @@ GeoMultiPolygon _LinkedGeoPoly_to_GeoMultiPolygon(LinkedGeoPolygon *link_poly) { return geo_mpoly; } -// todo: need one to delete GeoMultiPolygon - H3Error H3_EXPORT(cellsToGeoMultiPolygon)(const H3Index *cells, const int numCells, GeoMultiPolygon *out) { @@ -1301,3 +1299,51 @@ H3Error H3_EXPORT(cellsToGeoMultiPolygon)(const H3Index *cells, return E_SUCCESS; } + +/* +GeoLoop: + int numVerts + LatLng *verts + +GeoPolygon: + GeoLoop geoloop + int numHoles + GeoLoop *holes + +GeoMultiPolygon: + int numPolygons + GeoPolygon *polygons + */ + +// destroy *internals* +// i suppose we could free the loop memory, but that feels weird.... dunno. +void freeGeoLoop(GeoLoop *loop) { + H3_MEMORY(free)(loop->verts); + loop->verts = NULL; + loop->numVerts = -1; // or zero? +} + +// destroy *internals* +void freeGeoPolygon(GeoPolygon *poly) { + freeGeoLoop(&(poly->geoloop)); // weird address of operator here... + // todo: null the pointer? + + for (int i = 0; i < poly->numHoles; i++) { + freeGeoLoop(&(poly->holes[i])); // another weird address-of operator + + // todo: null the pointer? maybe doesn't make sense in a loop? + } + H3_MEMORY(free)(poly->holes); + // todo: null the pointer? +} + +// void or H3Error? +// destroy *internals* +void H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon *mpoly) { + for (int i = 0; i < mpoly->numPolygons; i++) { + freeGeoPolygon(&(mpoly->polygons[i])); + } + // todo: null the memory? + mpoly->polygons = NULL; + mpoly->numPolygons = 0; // or negative one? +} From bcceda2954d0557e0eb18c045ba05e884359cc09 Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Sun, 11 Sep 2022 16:39:54 -0400 Subject: [PATCH 13/19] freeGeoMultiPolygon in test --- src/apps/testapps/testCellsToLinkedMultiPolygon.c | 5 ++--- src/h3lib/lib/algos.c | 2 +- 2 files changed, 3 insertions(+), 4 deletions(-) diff --git a/src/apps/testapps/testCellsToLinkedMultiPolygon.c b/src/apps/testapps/testCellsToLinkedMultiPolygon.c index f7963853a..b2d743655 100644 --- a/src/apps/testapps/testCellsToLinkedMultiPolygon.c +++ b/src/apps/testapps/testCellsToLinkedMultiPolygon.c @@ -17,6 +17,7 @@ #include #include "algos.h" // not needed? prolly just need linkedGeo.h +#include "h3api.h" // todo: don't be lazy, this file has some lax imports #include "test.h" #include "utility.h" @@ -59,9 +60,7 @@ SUITE(cellsToLinkedMultiPolygon) { t_assert(mpoly.polygons[0].numHoles == 0, "1 outer loop and no holes"); t_assert(mpoly.polygons[0].geoloop.numVerts == 6, "6 vertices in hex"); - // H3_EXPORT(destroyLinkedMultiPolygon)(&polygon); - // H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon *mpoly); // enabling - // this should fix valgrind, yeah? + H3_EXPORT(freeGeoMultiPolygon)(&mpoly); } TEST(invalid) { diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index adaabc87a..eba5da9c5 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1341,7 +1341,7 @@ void freeGeoPolygon(GeoPolygon *poly) { // destroy *internals* void H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon *mpoly) { for (int i = 0; i < mpoly->numPolygons; i++) { - freeGeoPolygon(&(mpoly->polygons[i])); + H3_EXPORT(freeGeoPolygon)(&(mpoly->polygons[i])); } // todo: null the memory? mpoly->polygons = NULL; From 57a35a557560177ed9a6c851e2177a97b2917969 Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Sun, 11 Sep 2022 19:03:57 -0400 Subject: [PATCH 14/19] don't need the H3_EXPORT --- src/h3lib/lib/algos.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index eba5da9c5..adaabc87a 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1341,7 +1341,7 @@ void freeGeoPolygon(GeoPolygon *poly) { // destroy *internals* void H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon *mpoly) { for (int i = 0; i < mpoly->numPolygons; i++) { - H3_EXPORT(freeGeoPolygon)(&(mpoly->polygons[i])); + freeGeoPolygon(&(mpoly->polygons[i])); } // todo: null the memory? mpoly->polygons = NULL; From bfbc2ad579b86371630cd1b498bb8af96c48fd4d Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Sun, 11 Sep 2022 19:36:03 -0400 Subject: [PATCH 15/19] i think that was the leak --- src/h3lib/lib/algos.c | 1 + 1 file changed, 1 insertion(+) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index adaabc87a..11b10769d 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1343,6 +1343,7 @@ void H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon *mpoly) { for (int i = 0; i < mpoly->numPolygons; i++) { freeGeoPolygon(&(mpoly->polygons[i])); } + H3_MEMORY(free)(mpoly->polygons); // todo: null the memory? mpoly->polygons = NULL; mpoly->numPolygons = 0; // or negative one? From 0e58da5aff96da660cacbbfd6d1b5ceecedbdd04 Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Sun, 11 Sep 2022 20:15:38 -0400 Subject: [PATCH 16/19] destroyLinkedMultiPolygon --- src/h3lib/lib/algos.c | 2 ++ 1 file changed, 2 insertions(+) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index 11b10769d..f29cdfcbe 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1297,6 +1297,8 @@ H3Error H3_EXPORT(cellsToGeoMultiPolygon)(const H3Index *cells, *out = _LinkedGeoPoly_to_GeoMultiPolygon(&lgp); // todo: capture errors from conversion function + H3_EXPORT(destroyLinkedMultiPolygon)(&lgp); + return E_SUCCESS; } From ecdaed8a3cf4f0144e87e23a8030537ab824605c Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Mon, 12 Sep 2022 02:31:42 -0400 Subject: [PATCH 17/19] nestedDonut_GMP --- .../testapps/testCellsToLinkedMultiPolygon.c | 40 +++++++++++++++++++ 1 file changed, 40 insertions(+) diff --git a/src/apps/testapps/testCellsToLinkedMultiPolygon.c b/src/apps/testapps/testCellsToLinkedMultiPolygon.c index b2d743655..c471cd6bd 100644 --- a/src/apps/testapps/testCellsToLinkedMultiPolygon.c +++ b/src/apps/testapps/testCellsToLinkedMultiPolygon.c @@ -63,6 +63,46 @@ SUITE(cellsToLinkedMultiPolygon) { H3_EXPORT(freeGeoMultiPolygon)(&mpoly); } + TEST(nestedDonut_GMP) { + GeoMultiPolygon mpoly; + GeoPolygon poly; + // hollow 1-ring + hollow 3-ring around the same hex + H3Index cells[] = { + 0x89283082813ffff, 0x8928308281bffff, 0x8928308280bffff, + 0x8928308280fffff, 0x89283082807ffff, 0x89283082817ffff, + 0x8928308289bffff, 0x892830828d7ffff, 0x892830828c3ffff, + 0x892830828cbffff, 0x89283082853ffff, 0x89283082843ffff, + 0x8928308284fffff, 0x8928308287bffff, 0x89283082863ffff, + 0x89283082867ffff, 0x8928308282bffff, 0x89283082823ffff, + 0x89283082837ffff, 0x892830828afffff, 0x892830828a3ffff, + 0x892830828b3ffff, 0x89283082887ffff, 0x89283082883ffff}; + int numCells = ARRAY_SIZE(cells); + + t_assertSuccess( + H3_EXPORT(cellsToGeoMultiPolygon)(cells, numCells, &mpoly)); + + t_assert(mpoly.numPolygons == 2, "Polygon count correct"); + t_assert(mpoly.polygons[0].numHoles == 1, "1 outer loop and 1 hole"); + t_assert(mpoly.polygons[1].numHoles == 1, "1 outer loop and 1 hole"); + + if (mpoly.polygons[0].geoloop.numVerts != 42) { + // Polygon order is arbitrary; Swap so that the larger ring is first + poly = mpoly.polygons[0]; + mpoly.polygons[0] = mpoly.polygons[1]; + mpoly.polygons[1] = poly; + } + + poly = mpoly.polygons[0]; + t_assert(poly.geoloop.numVerts == 42, "Got expected outer loop"); + t_assert(poly.holes[0].numVerts == 30, "Got expected inner loop"); + + poly = mpoly.polygons[1]; + t_assert(poly.geoloop.numVerts == 18, "Got expected outer loop"); + t_assert(poly.holes[0].numVerts == 6, "Got expected inner loop"); + + H3_EXPORT(freeGeoMultiPolygon)(&mpoly); + } + TEST(invalid) { LinkedGeoPolygon polygon; H3Index set[] = {0xfffffffffffffff}; From a37d3d9e9e51bfc74fe6c31f9fa17bcb9e9fc804 Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Tue, 20 Sep 2022 20:32:00 -0400 Subject: [PATCH 18/19] english --- src/h3lib/lib/algos.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index f29cdfcbe..fa5f3b359 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1345,7 +1345,10 @@ void H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon *mpoly) { for (int i = 0; i < mpoly->numPolygons; i++) { freeGeoPolygon(&(mpoly->polygons[i])); } + + // i mean, the data ain't good no more anyway H3_MEMORY(free)(mpoly->polygons); + // todo: null the memory? mpoly->polygons = NULL; mpoly->numPolygons = 0; // or negative one? From 332135b2d3dc7d44f9534056c6391c5050d4d5a6 Mon Sep 17 00:00:00 2001 From: AJ Friend Date: Tue, 20 Sep 2022 20:49:43 -0400 Subject: [PATCH 19/19] pass by value instead of reference --- .../testapps/testCellsToLinkedMultiPolygon.c | 4 +- src/h3lib/include/h3api.h.in | 2 +- src/h3lib/lib/algos.c | 39 +++++-------------- 3 files changed, 13 insertions(+), 32 deletions(-) diff --git a/src/apps/testapps/testCellsToLinkedMultiPolygon.c b/src/apps/testapps/testCellsToLinkedMultiPolygon.c index c471cd6bd..56f74eaee 100644 --- a/src/apps/testapps/testCellsToLinkedMultiPolygon.c +++ b/src/apps/testapps/testCellsToLinkedMultiPolygon.c @@ -60,7 +60,7 @@ SUITE(cellsToLinkedMultiPolygon) { t_assert(mpoly.polygons[0].numHoles == 0, "1 outer loop and no holes"); t_assert(mpoly.polygons[0].geoloop.numVerts == 6, "6 vertices in hex"); - H3_EXPORT(freeGeoMultiPolygon)(&mpoly); + H3_EXPORT(freeGeoMultiPolygon)(mpoly); } TEST(nestedDonut_GMP) { @@ -100,7 +100,7 @@ SUITE(cellsToLinkedMultiPolygon) { t_assert(poly.geoloop.numVerts == 18, "Got expected outer loop"); t_assert(poly.holes[0].numVerts == 6, "Got expected inner loop"); - H3_EXPORT(freeGeoMultiPolygon)(&mpoly); + H3_EXPORT(freeGeoMultiPolygon)(mpoly); } TEST(invalid) { diff --git a/src/h3lib/include/h3api.h.in b/src/h3lib/include/h3api.h.in index 724d7d0e6..725cf340c 100644 --- a/src/h3lib/include/h3api.h.in +++ b/src/h3lib/include/h3api.h.in @@ -302,7 +302,7 @@ DECLSPEC H3Error H3_EXPORT(cellsToGeoMultiPolygon)(const H3Index *cells, const int numCells, GeoMultiPolygon *out); -DECLSPEC void H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon *mpoly); +DECLSPEC void H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon mpoly); /** @defgroup degsToRads degsToRads * Functions for degsToRads diff --git a/src/h3lib/lib/algos.c b/src/h3lib/lib/algos.c index fa5f3b359..0d1d806e8 100644 --- a/src/h3lib/lib/algos.c +++ b/src/h3lib/lib/algos.c @@ -1317,39 +1317,20 @@ H3Error H3_EXPORT(cellsToGeoMultiPolygon)(const H3Index *cells, GeoPolygon *polygons */ -// destroy *internals* -// i suppose we could free the loop memory, but that feels weird.... dunno. -void freeGeoLoop(GeoLoop *loop) { - H3_MEMORY(free)(loop->verts); - loop->verts = NULL; - loop->numVerts = -1; // or zero? -} - -// destroy *internals* -void freeGeoPolygon(GeoPolygon *poly) { - freeGeoLoop(&(poly->geoloop)); // weird address of operator here... - // todo: null the pointer? +void freeGeoLoop(GeoLoop loop) { H3_MEMORY(free)(loop.verts); } - for (int i = 0; i < poly->numHoles; i++) { - freeGeoLoop(&(poly->holes[i])); // another weird address-of operator +void freeGeoPolygon(GeoPolygon poly) { + freeGeoLoop(poly.geoloop); - // todo: null the pointer? maybe doesn't make sense in a loop? + for (int i = 0; i < poly.numHoles; i++) { + freeGeoLoop(poly.holes[i]); } - H3_MEMORY(free)(poly->holes); - // todo: null the pointer? + H3_MEMORY(free)(poly.holes); } -// void or H3Error? -// destroy *internals* -void H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon *mpoly) { - for (int i = 0; i < mpoly->numPolygons; i++) { - freeGeoPolygon(&(mpoly->polygons[i])); +void H3_EXPORT(freeGeoMultiPolygon)(GeoMultiPolygon mpoly) { + for (int i = 0; i < mpoly.numPolygons; i++) { + freeGeoPolygon(mpoly.polygons[i]); } - - // i mean, the data ain't good no more anyway - H3_MEMORY(free)(mpoly->polygons); - - // todo: null the memory? - mpoly->polygons = NULL; - mpoly->numPolygons = 0; // or negative one? + H3_MEMORY(free)(mpoly.polygons); }