vector2dggs 0.10.0__tar.gz → 0.11.0__tar.gz

{vector2dggs-0.10.0 → vector2dggs-0.11.0}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.1
 Name: vector2dggs
-Version: 0.10.0
+Version: 0.11.0
 Summary: CLI DGGS indexer for vector geospatial data
+Home-page: https://github.com/manaakiwhenua/vector2dggs
 License: LGPL-3.0-or-later
 Keywords: dggs,vector,h3,rHEALPix,cli
 Author: James Ardo
@@ -12,8 +13,6 @@ Requires-Python: >=3.11,<4.0
 Classifier: License :: OSI Approved :: GNU Lesser General Public License v3 or later (LGPLv3+)
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Scientific/Engineering :: GIS
 Classifier: Topic :: Scientific/Engineering :: Information Analysis
@@ -30,6 +29,7 @@ Requires-Dist: psycopg2 (>=2.9.9,<3.0.0)
 Requires-Dist: pyarrow (>=20.0,<21.0)
 Requires-Dist: pyproj (>=3.7,<4.0)
 Requires-Dist: python-geohash (>=0.8.5,<0.9.0)
+Requires-Dist: rhealpixdggs (>=0.5.12,<0.6.0)
 Requires-Dist: rhppandas (>=0.2.0,<0.3.0)
 Requires-Dist: rusty-polygon-geohasher (>=0.2.3,<0.3.0)
 Requires-Dist: s2geometry (>=0.9.0,<0.10.0)
@@ -121,12 +121,17 @@ Options:
                                   used for cutting large geometries (see
                                   `--cut_threshold`). Defaults to the same CRS
                                   as the input. Should be a valid EPSG code.
-  -c, --cut_threshold INTEGER     Cutting up large geometries into smaller
-                                  geometries based on a target length. Units
-                                  are assumed to match the input CRS units
-                                  unless the `--cut_crs` is also given, in
-                                  which case units match the units of the
-                                  supplied CRS.  [default: 5000; required]
+  -c, --cut_threshold FLOAT       Cutting up large geometries into smaller
+                                  geometries based on a target area. Units are
+                                  assumed to match the input CRS units unless
+                                  the `--cut_crs` is also given, in which case
+                                  units match the units of the supplied CRS.
+                                  If left unspecified, the threshold will be
+                                  the maximum area of a cell at the parent
+                                  resolution, in square metres or feet
+                                  according to the CRS. A threshold of 0 will
+                                  skip bissection entirely (effectively
+                                  ignoring --cut_crs).
   -t, --threads INTEGER           Amount of threads used for operation
                                   [default: NUM_CPUS - 1]
   -cp, --compression TEXT         Compression method to use for the output
@@ -239,6 +244,17 @@ Alternatively, it is also possible to install using pip with `pip install -e .`,
 
 Please run `black .` before committing.
 
+#### Tests
+
+Tests are included. To run them, set up a poetry environment, then follow these instructons:
+
+```bash
+cd tests
+python ./test_vector2dggs.py
+```
+
+Test data are included at `tests/data/`.
+
 ## Example commands
 
 With a local GPKG:
@@ -261,14 +277,14 @@ vector2dggs h3 -v DEBUG -id ogc_fid -r 9 -p 5 -t 4 --overwrite -lyr topo50_lake
   title={{vector2dggs}},
   author={Ardo, James and Law, Richard},
   url={https://github.com/manaakiwhenua/vector2dggs},
-  version={0.10.0},
+  version={0.11.0},
   date={2023-04-20}
 }
 ```
 
 APA/Harvard
 
-> Ardo, J., & Law, R. (2023). vector2dggs (0.10.0) [Computer software]. https://github.com/manaakiwhenua/vector2dggs
+> Ardo, J., & Law, R. (2023). vector2dggs (0.11.0) [Computer software]. https://github.com/manaakiwhenua/vector2dggs
 
 [![manaakiwhenua-standards](https://github.com/manaakiwhenua/vector2dggs/workflows/manaakiwhenua-standards/badge.svg)](https://github.com/manaakiwhenua/manaakiwhenua-standards)
 

{vector2dggs-0.10.0 → vector2dggs-0.11.0}/README.md

@@ -80,12 +80,17 @@ Options:
                                   used for cutting large geometries (see
                                   `--cut_threshold`). Defaults to the same CRS
                                   as the input. Should be a valid EPSG code.
-  -c, --cut_threshold INTEGER     Cutting up large geometries into smaller
-                                  geometries based on a target length. Units
-                                  are assumed to match the input CRS units
-                                  unless the `--cut_crs` is also given, in
-                                  which case units match the units of the
-                                  supplied CRS.  [default: 5000; required]
+  -c, --cut_threshold FLOAT       Cutting up large geometries into smaller
+                                  geometries based on a target area. Units are
+                                  assumed to match the input CRS units unless
+                                  the `--cut_crs` is also given, in which case
+                                  units match the units of the supplied CRS.
+                                  If left unspecified, the threshold will be
+                                  the maximum area of a cell at the parent
+                                  resolution, in square metres or feet
+                                  according to the CRS. A threshold of 0 will
+                                  skip bissection entirely (effectively
+                                  ignoring --cut_crs).
   -t, --threads INTEGER           Amount of threads used for operation
                                   [default: NUM_CPUS - 1]
   -cp, --compression TEXT         Compression method to use for the output
@@ -198,6 +203,17 @@ Alternatively, it is also possible to install using pip with `pip install -e .`,
 
 Please run `black .` before committing.
 
+#### Tests
+
+Tests are included. To run them, set up a poetry environment, then follow these instructons:
+
+```bash
+cd tests
+python ./test_vector2dggs.py
+```
+
+Test data are included at `tests/data/`.
+
 ## Example commands
 
 With a local GPKG:
@@ -220,13 +236,13 @@ vector2dggs h3 -v DEBUG -id ogc_fid -r 9 -p 5 -t 4 --overwrite -lyr topo50_lake
   title={{vector2dggs}},
   author={Ardo, James and Law, Richard},
   url={https://github.com/manaakiwhenua/vector2dggs},
-  version={0.10.0},
+  version={0.11.0},
   date={2023-04-20}
 }
 ```
 
 APA/Harvard
 
-> Ardo, J., & Law, R. (2023). vector2dggs (0.10.0) [Computer software]. https://github.com/manaakiwhenua/vector2dggs
+> Ardo, J., & Law, R. (2023). vector2dggs (0.11.0) [Computer software]. https://github.com/manaakiwhenua/vector2dggs
 
 [![manaakiwhenua-standards](https://github.com/manaakiwhenua/vector2dggs/workflows/manaakiwhenua-standards/badge.svg)](https://github.com/manaakiwhenua/manaakiwhenua-standards)

{vector2dggs-0.10.0 → vector2dggs-0.11.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "vector2dggs"
-version = "0.10.0"
+version = "0.11.0"
 description = "CLI DGGS indexer for vector geospatial data"
 authors = ["James Ardo <ardoj@landcareresearch.co.nz>"]
 maintainers = ["Richard Law <lawr@landcareresearch.co.nz>"]
@@ -35,6 +35,7 @@ pillow = "^11.2.1"
 s2geometry = "^0.9.0"
 rusty-polygon-geohasher = "^0.2.3"
 python-geohash = "^0.8.5"
+rhealpixdggs = "^0.5.12"
 
 [tool.poetry.group.dev.dependencies]
 pytest = "^7.2.2"

vector2dggs-0.11.0/vector2dggs/__init__.py

@@ -0,0 +1 @@
+__version__: str = "0.11.0"

{vector2dggs-0.10.0 → vector2dggs-0.11.0}/vector2dggs/common.py

@@ -18,7 +18,7 @@ from pathlib import Path, PurePath
 from urllib.parse import urlparse
 from tqdm import tqdm
 from tqdm.dask import TqdmCallback
-from multiprocessing.dummy import Pool
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor, as_completed
 from shapely.geometry import GeometryCollection
 
 import vector2dggs.constants as const
@@ -313,6 +313,47 @@ def polyfill(
 def polyfill_star(args) -> None:
     return polyfill(*args)
 
+def bisection_preparation(df: pd.DataFrame, dggs: str, parent_res: int, cut_crs: pyproj.CRS = None, cut_threshold: Union[None, float] = None) -> tuple[pd.DataFrame, pyproj.CRS, Union[None, float]]:
+    cut_threshold = float(cut_threshold) if cut_threshold != None else None
+    
+    if cut_threshold and cut_crs:
+        df = df.to_crs(cut_crs)
+    else:
+        cut_crs = df.crs
+
+    if cut_crs is None:
+        LOGGER.warning("Input has no defined CRS, and cut_crs is not specified")
+    elif cut_threshold != 0:
+        LOGGER.debug("Cutting with CRS: %s", df.crs)
+
+    if not cut_crs.is_projected and cut_threshold != 0:
+        LOGGER.warning(
+            f"CRS {cut_crs} is not a projected coordinate system. (units: {cut_crs.axis_info[0].unit_name}) Bisection will result in sections of varying area"
+        )
+    elif cut_threshold != 0:
+        LOGGER.debug(
+            f"Using CRS units for input polygon bisection: {cut_crs.axis_info[0].unit_name}"
+        )
+
+    if cut_threshold == None:
+        unit_name = cut_crs.axis_info[0].unit_name
+        cut_threshold_m2 = const.DEFAULT_AREA_THRESHOLD_M2(dggs, (int(parent_res)))
+        if unit_name == "metre":
+            cut_threshold = cut_threshold_m2
+        elif unit_name == "feet":
+            cut_threshold = cut_threshold_m2 * 3.28084
+        else:
+            cut_threshold = 100000000 if cut_crs.is_projected else 0.5
+            LOGGER.warning(
+                f'Unspecified cut_threshold for {"projected" if cut_crs.is_projected else "geographic"} CRS: {cut_crs}, with squared units: {unit_name}'
+            )
+        LOGGER.debug(f"Using default cut_threshold of {cut_threshold} ({unit_name}^2)")
+    
+    return df, cut_crs, cut_threshold
+
+def bisect_geometry(geometry, cut_threshold):
+    return GeometryCollection(katana.katana(geometry, cut_threshold))
+
 
 def index(
     dggs: str,
@@ -326,7 +367,7 @@ def index(
     keep_attributes: bool,
     chunksize: int,
     spatial_sorting: str,
-    cut_threshold: int,
+    cut_threshold: Union[None, float],
     processes: int,
     compression: str = "snappy",
     id_field: str = None,
@@ -356,9 +397,7 @@ def index(
         # Read file
         df = gpd.read_file(input_file, layer=layer)
 
-    if cut_crs:
-        df = df.to_crs(cut_crs)
-    LOGGER.debug("Cutting with CRS: %s", df.crs)
+    df, cut_crs, cut_threshold = bisection_preparation(df, dggs, parent_res, cut_crs, cut_threshold)
 
     if id_field:
         df = df.set_index(id_field)
@@ -370,13 +409,21 @@ def index(
         # Remove all attributes except the geometry
         df = df.loc[:, ["geometry"]]
 
-    LOGGER.debug("Cutting large geometries")
-    with tqdm(total=df.shape[0], desc="Splitting") as pbar:
-        for index, row in df.iterrows():
-            df.loc[index, "geometry"] = GeometryCollection(
-                katana.katana(row.geometry, cut_threshold)
-            )
-            pbar.update(1)
+    LOGGER.debug("Bisecting large geometries")
+
+    if cut_threshold is not None and cut_threshold > 0:
+        with ThreadPoolExecutor(max_workers=max(1, processes)) as executor:
+            futures = []
+            for index, row in df.iterrows():
+                future = executor.submit(bisect_geometry, row.geometry, cut_threshold)
+                futures.append((index, future))
+
+            with tqdm(total=len(futures), desc="Bisection") as pbar:
+                for index, future in futures:
+                    df.at[index, "geometry"] = future.result()
+                    pbar.update(1)
+    else:
+        LOGGER.debug("No bisection applied to input.")
 
     LOGGER.debug("Exploding geometry collections and multipolygons")
     df = (
@@ -427,28 +474,33 @@ def index(
             resolution,
         )
         with tempfile.TemporaryDirectory(suffix=".parquet") as tmpdir2:
-            with Pool(processes=processes) as pool:
-                args = [
-                    (
-                        dggs,
-                        dggsfunc,
-                        secondary_index_func,
-                        filepath,
-                        spatial_sort_col,
-                        resolution,
-                        parent_res,
-                        tmpdir2,
-                        compression,
-                    )
-                    for filepath in filepaths
-                ]
-                list(
-                    tqdm(
-                        pool.imap(polyfill_star, args),
-                        total=len(args),
-                        desc="DGGS indexing",
-                    )
+
+            args = [
+                (
+                    dggs,
+                    dggsfunc,
+                    secondary_index_func,
+                    filepath,
+                    spatial_sort_col,
+                    resolution,
+                    parent_res,
+                    tmpdir2,
+                    compression,
                 )
+                for filepath in filepaths
+            ]
+
+            with ProcessPoolExecutor(max_workers=processes) as executor:
+                futures = {executor.submit(polyfill_star, arg): arg for arg in args}
+
+                for future in tqdm(
+                    as_completed(futures), total=len(futures), desc="DGGS indexing"
+                ):
+                    try:
+                        future.result()
+                    except Exception as e:
+                        LOGGER.error(f"Task failed with {e}")
+                        raise (e)
 
             parent_partitioning(
                 dggs,

{vector2dggs-0.10.0 → vector2dggs-0.11.0}/vector2dggs/constants.py

@@ -8,20 +8,6 @@ MIN_RHP, MAX_RHP = 0, 15
 MIN_S2, MAX_S2 = 0, 30
 MIN_GEOHASH, MAX_GEOHASH = 1, 12
 
-DEFAULTS = {
-    "id": None,
-    "k": False,
-    "ch": 50,
-    "s": "none",
-    "crs": None,
-    "c": 5000,
-    "t": (multiprocessing.cpu_count() - 1),
-    "cp": "snappy",
-    "lyr": None,
-    "g": "geom",
-    "tempdir": tempfile.tempdir,
-}
-
 SPATIAL_SORTING_METHODS = ["hilbert", "morton", "geohash", "none"]
 
 DEFAULT_DGGS_PARENT_RES = {
@@ -70,6 +56,86 @@ S2_CELLS_MAX_AREA_M2_BY_LEVEL = {
     30: 0.93 * 1e-4,
 }
 
+# https://h3geo.org/docs/core-library/restable/
+H3_CELLS_MAX_AREA_KM2_BY_LEVEL = {
+    0: 4977807.027442012,
+    1: 729486.875275344,
+    2: 104599.807218925,
+    3: 14950.773301379,
+    4: 2135.986983965,
+    5: 305.144308779,
+    6: 43.592111685,
+    7: 6.227445905,
+    8: 0.889635157,
+    9: 0.127090737,
+    10: 0.018155820,
+    11: 0.002593689,
+    12: 0.000370527,
+    13: 0.000052932,
+    14: 0.000007562,
+    15: 0.000001080,
+}
+
+RHP_CELLS_AREA_KM2_BY_LEVEL = {
+    0: 100151150.62856922,
+    1: 11127905.62539658,
+    2: 1236433.9583773974,
+    3: 137381.55093082195,
+    4: 15264.616770091328,
+    5: 1696.0685300101482,
+    6: 188.4520588900164,
+    7: 20.939117654446267,
+    8: 2.326568628271808,
+    9: 0.25850762536353417,
+    10: 0.02872306948483713,
+    11: 0.003191452164981904,
+    12: 0.0003546057961091004,
+    13: 3.940064401212227 * 1e-5,
+    14: 4.377849334680252 * 1e-6,
+    15: 4.864277038533613 * 1e-7,
+}
+
+# https://www.movable-type.co.uk/scripts/geohash.html
+GEOHASH_MAX_CELL_AREA_KM2_BY_LEVEL = {
+    1: 5000 * 5000,
+    2: 1250 * 625,
+    3: 156 * 156,
+    4: 39.1 * 19.5,
+    5: 4.89 * 4.89,
+    6: 1.22 * 0.61,
+    7: 153 * 153 / 1e6,
+    8: 38.2 * 19.1 / 1e6,
+    9: 4.77 * 4.77 / 1e6,
+    10: 1.19 * 0.596 / 1e6,
+    11: 149 * 149 / 1e9,
+    12: 37.2 * 18.6 / 1e9,
+}
+
+DGGS_CELL_AREA_M2_BY_RES = {
+    "s2": lambda res: S2_CELLS_MAX_AREA_M2_BY_LEVEL[res],
+    "h3": lambda res: H3_CELLS_MAX_AREA_KM2_BY_LEVEL[res] * 1e6,
+    "rhp": lambda res: RHP_CELLS_AREA_KM2_BY_LEVEL[res] * 1e6,
+    "geohash": lambda res: GEOHASH_MAX_CELL_AREA_KM2_BY_LEVEL[res] * 1e6,
+}
+
+DEFAULT_AREA_THRESHOLD_M2 = lambda dggs, parent_res: DGGS_CELL_AREA_M2_BY_RES[dggs](
+    parent_res
+)
+
+DEFAULTS = {
+    "id": None,
+    "k": False,
+    "ch": 50,
+    "s": "none",
+    "crs": None,
+    "c": None,
+    "t": (multiprocessing.cpu_count() - 1),
+    "cp": "snappy",
+    "lyr": None,
+    "g": "geom",
+    "tempdir": tempfile.tempdir,
+}
+
 
 warnings.filterwarnings(
     "ignore"

{vector2dggs-0.10.0 → vector2dggs-0.11.0}/vector2dggs/geohash.py

@@ -217,10 +217,10 @@ def gh_compaction(
 @click.option(
     "-c",
     "--cut_threshold",
-    required=True,
+    required=False,
     default=const.DEFAULTS["c"],
-    type=int,
-    help="Cutting up large geometries into smaller geometries based on a target length. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS.",
+    type=float,
+    help="Cutting up large geometries into smaller geometries based on a target area. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS. If left unspecified, the threshold will be the maximum area of a cell at the parent resolution, in square metres or feet according to the CRS. A threshold of 0 will skip bissection entirely (effectively ignoring --cut_crs).",
     nargs=1,
 )
 @click.option(
@@ -333,5 +333,3 @@ def geohash(
         )
     except:
         raise
-    else:
-        sys.exit(0)

{vector2dggs-0.10.0 → vector2dggs-0.11.0}/vector2dggs/h3.py

@@ -136,10 +136,10 @@ def h3compaction(
 @click.option(
     "-c",
     "--cut_threshold",
-    required=True,
+    required=False,
     default=const.DEFAULTS["c"],
-    type=int,
-    help="Cutting up large geometries into smaller geometries based on a target length. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS.",
+    type=float,
+    help="Cutting up large geometries into smaller geometries based on a target area. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS. If left unspecified, the threshold will be the maximum area of a cell at the parent resolution, in square metres or feet according to the CRS. A threshold of 0 will skip bissection entirely (effectively ignoring --cut_crs).",
     nargs=1,
 )
 @click.option(
@@ -253,5 +253,3 @@ def h3(
         )
     except:
         raise
-    else:
-        sys.exit(0)

{vector2dggs-0.10.0 → vector2dggs-0.11.0}/vector2dggs/katana.py

@@ -30,14 +30,17 @@ def katana(
     geometry: Union[BaseGeometry, None],
     threshold: float,
     count: int = 0,
+    max_recursion_depth: int = 250,
     check_2D: bool = True,
 ) -> List[BaseGeometry]:
     """
     Recursively split a geometry into two parts across its shortest dimension.
     Invalid input `geometry` will silently be made valid (if possible).
     Any LinearRings will be converted to Polygons.
+    `threshold`: maximum acceptable area of the bounding box for any output geometry.
+    `count`: used to track recursion depth
     """
-    if geometry is None:
+    if (geometry is None) or (geometry.is_empty):
         return []
     if isinstance(geometry, LinearRing):
         geometry = Polygon(geometry)
@@ -52,9 +55,7 @@ def katana(
     bounds = geometry.bounds
     width = bounds[2] - bounds[0]
     height = bounds[3] - bounds[1]
-    if max(width, height) <= threshold or count == 250:
-        # either the polygon is smaller than the threshold, or the maximum
-        # number of recursions has been reached
+    if ((width * height) <= threshold) or (count >= max_recursion_depth):
         return [geometry]
     if height >= width:
         # split left to right
@@ -64,6 +65,8 @@ def katana(
         # split top to bottom
         a = box(bounds[0], bounds[1], bounds[0] + width / 2, bounds[3])
         b = box(bounds[0] + width / 2, bounds[1], bounds[2], bounds[3])
+    # Add additional vertices to help prevent indexing errors from use of EPSG:4386 later under the presence of long edges
+    a, b = map(lambda g: g.segmentize(min(width, height) / 4), [a, b])
     result = []
     for d in (
         a,

{vector2dggs-0.10.0 → vector2dggs-0.11.0}/vector2dggs/rHP.py

@@ -12,13 +12,9 @@ import geopandas as gpd
 from typing import Union
 from pathlib import Path
 from rhealpixdggs.conversion import compress_order_cells
+from rhealpixdggs.rhp_wrappers import rhp_to_center_child
 from rhppandas.util.const import COLUMNS
 
-# from rhealpixdggs.rhp_wrappers import rhp_to_center_child, rhp_is_valid
-from rhealpixdggs.rhp_wrappers import rhp_is_valid
-from rhealpixdggs.dggs import RHEALPixDGGS
-from rhealpixdggs.dggs import WGS84_003
-
 import vector2dggs.constants as const
 import vector2dggs.common as common
 
@@ -57,54 +53,6 @@ def rhppolyfill(df: gpd.GeoDataFrame, resolution: int) -> pd.DataFrame:
     )
 
 
-# TODO replace when merged https://github.com/manaakiwhenua/rhealpixdggs-py/pull/37
-def rhp_to_center_child(
-    rhpindex: str, res: int = None, dggs: RHEALPixDGGS = WGS84_003
-) -> str:
-    """
-    Returns central child of rhpindex at resolution res (immediate central
-    child if res == None).
-
-    Returns None if the cell index is invalid.
-
-    Returns None if the DGGS has an even number of cells on a side.
-
-    EXAMPLES::
-
-        >>> rhp_to_center_child('S001450634')
-        'S0014506344'
-        >>> rhp_to_center_child('S001450634', res=13)
-        'S001450634444'
-        >>> rhp_to_center_child('INVALID')
-    """
-    # Stop early if the cell index is invalid
-    if not rhp_is_valid(rhpindex, dggs):
-        return None
-
-    # DGGSs with even numbers of cells on a side never have a cell at the centre
-    if (dggs.N_side % 2) == 0:
-        return None
-
-    # Handle mismatch between cell resolution and requested child resolution
-    parent_res = len(rhpindex) - 1
-    if res is not None and res < parent_res:
-        return rhpindex
-
-    # Standard case (including parent_res == res)
-    else:
-        # res == None returns the central child from one level down (by convention)
-        added_levels = 1 if res is None else res - parent_res
-
-        # Derive index of centre child and append that to rhpindex
-        # NOTE: only works for odd values of N_side
-        c_index = int((dggs.N_side**2 - 1) / 2)
-
-        # Append the required number of child digits to cell index
-        child_index = rhpindex + "".join(str(c_index) for _ in range(0, added_levels))
-
-        return child_index
-
-
 def compact_cells(cells: set[str]) -> set[str]:
     """
     Compact a set of rHEALPix DGGS cells.
@@ -205,17 +153,17 @@ def rhpcompaction(
 @click.option(
     "-c",
     "--cut_threshold",
-    required=True,
+    required=False,
     default=const.DEFAULTS["c"],
-    type=int,
-    help="Cutting up large geometries into smaller geometries based on a target length. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS.",
+    type=float,
+    help="Cutting up large geometries into smaller geometries based on a target area. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS. If left unspecified, the threshold will be the maximum area of a cell at the parent resolution, in square metres or feet according to the CRS. A threshold of 0 will skip bissection entirely (effectively ignoring --cut_crs).",
     nargs=1,
 )
 @click.option(
     "-t",
     "--threads",
     required=False,
-    default=const.DEFAULTS["t"],
+    default=1,
     type=int,
     help="Amount of threads used for operation",
     nargs=1,
@@ -322,5 +270,3 @@ def rhp(
         )
     except:
         raise
-    else:
-        sys.exit(0)

{vector2dggs-0.10.0 → vector2dggs-0.11.0}/vector2dggs/s2.py

@@ -9,6 +9,7 @@ from s2geometry import pywraps2 as S2
 
 import pandas as pd
 import geopandas as gpd
+from shapely import force_2d
 from shapely.geometry import box, Polygon, LineString, Point
 from shapely.ops import transform
 from pyproj import CRS, Transformer
@@ -71,6 +72,7 @@ def s2_polyfill_polygons(df: gpd.GeoDataFrame, level: int) -> gpd.GeoDataFrame:
     def generate_s2_covering(
         geom: Polygon, level: int, centroid_inside: bool = True
     ) -> set[S2.S2CellId]:
+        geom = force_2d(geom)
         # Prepare loops: first the exterior loop, then the interior loops
         loops = []
         # Exterior ring
@@ -296,10 +298,10 @@ def s2_compaction(
 @click.option(
     "-c",
     "--cut_threshold",
-    required=True,
+    required=False,
     default=const.DEFAULTS["c"],
-    type=int,
-    help="Cutting up large geometries into smaller geometries based on a target length. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS.",
+    type=float,
+    help="Cutting up large geometries into smaller geometries based on a target area. Units are assumed to match the input CRS units unless the `--cut_crs` is also given, in which case units match the units of the supplied CRS. If left unspecified, the threshold will be the maximum area of a cell at the parent resolution, in square metres or feet according to the CRS. A threshold of 0 will skip bissection entirely (effectively ignoring --cut_crs).",
     nargs=1,
 )
 @click.option(
@@ -412,5 +414,3 @@ def s2(
         )
     except:
         raise
-    else:
-        sys.exit(0)