smoothify 0.1.1__tar.gz

smoothify-0.1.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 DPIRD-DMA
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

smoothify-0.1.1/PKG-INFO

@@ -0,0 +1,182 @@
+Metadata-Version: 2.4
+Name: smoothify
+Version: 0.1.1
+Summary: Transform pixelated geometries from raster data into smooth natural looking features
+Author-email: Nick Wright <nicholas.wright@dpird.wa.gov.au>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/DPIRD-DMA/Smoothify
+Keywords: geometry,smoothing,smooth,GIS,raster,vector,chaikin,shapely,geopandas
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: geopandas>=1.0.0
+Requires-Dist: joblib>=1.4.0
+Requires-Dist: numpy>=1.27.0
+Requires-Dist: scipy>=1.11.0
+Requires-Dist: shapely>=2.0.2
+Dynamic: license-file
+
+<p align="left">
+  <img src="https://raw.githubusercontent.com/DPIRD-DMA/Smoothify/main/images/smoothify_logo.png" alt="Smoothify Text" width="600">
+</p>
+
+[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green)](https://github.com/DPIRD-DMA/Smoothify/blob/main/LICENSE)
+[![PyPI version](https://img.shields.io/pypi/v/smoothify.svg)](https://pypi.org/project/smoothify/)
+[![Tutorials](https://img.shields.io/badge/Tutorials-Learn-brightgreen)](https://github.com/DPIRD-DMA/Smoothify/tree/main/examples)
+
+📋 [View Changelog](https://github.com/DPIRD-DMA/Smoothify/blob/main/CHANGELOG.md)
+
+A Python package for smoothing and refining geometries derived from raster data classifications. Smoothify transforms jagged polygons and lines resulting from raster-to-vector conversion into smooth, visually appealing features using an optimized implementation of Chaikin's corner-cutting algorithm.
+
+## Problem
+
+Polygons and lines derived from classified raster data (e.g., ML model predictions, spectral indices, or remote sensing classifications) often have unnatural "stair-stepped" or "pixelated" edges that:
+
+- Are visually unappealing in maps and GIS applications
+- Can be difficult to work with in downstream vector processing
+- Don't represent the real-world features they're meant to depict
+
+## Solution
+
+Smoothify applies an optimized implementation of Chaikin's corner-cutting algorithm along with other geometric processing to create smooth, natural-looking features while:
+
+- Preserving the general shape and area of polygons
+- Supporting all shapley geometry types
+- Handling shapes with interior holes
+- Efficiently processing large datasets with multiprocessing
+
+<p align="left">
+  <img src="https://raw.githubusercontent.com/DPIRD-DMA/Smoothify/main/images/smoothify_hero.png" alt="Smoothify Hero Image" width="600">
+</p>
+
+## Installation
+
+```bash
+uv add smoothify
+```
+or 
+```bash
+pip install smoothify
+```
+
+## Quick Start
+
+```python
+import geopandas as gpd
+from smoothify import smoothify
+
+# Load your polygonized raster data
+polygon_gdf = gpd.read_file("path/to/your/polygons.gpkg")
+
+# Apply smoothing (segment_length auto-detected from geometry)
+smoothed_gdf = smoothify(
+    geom=polygon_gdf,
+    smooth_iterations=3,  # More iterations = smoother result
+    num_cores=4  # Use parallel processing for large datasets
+)
+
+# Or specify segment_length explicitly (generally recommended)
+smoothed_gdf = smoothify(
+    geom=polygon_gdf,
+    segment_length=10.0,  # Use the original raster resolution
+    smooth_iterations=3,
+    num_cores=4
+)
+
+# Save the result
+smoothed_gdf.to_file("smoothed_polygons.gpkg")
+```
+
+## General Usage
+
+The `smoothify()` function accepts three types of input:
+
+### 1. GeoDataFrame
+```python
+import geopandas as gpd
+from smoothify import smoothify
+
+gdf = gpd.read_file("polygons.gpkg")
+smoothed_gdf = smoothify(
+    geom=gdf,
+    segment_length=10.0,
+    smooth_iterations=3,
+    num_cores=4
+)
+```
+
+### 2. Single Geometry
+```python
+from shapely.geometry import Polygon
+from smoothify import smoothify
+
+polygon = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])
+smoothed_polygon = smoothify(
+    geom=polygon,
+    smooth_iterations=3
+)
+```
+
+### 3. List of Geometries or GeometryCollection
+```python
+from shapely.geometry import Polygon, LineString
+from smoothify import smoothify
+
+geometries = [
+    Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]),
+    LineString([(0, 0), (5, 5), (10, 0)])
+]
+smoothed = smoothify(
+    geom=geometries,
+    segment_length=1.0,
+    smooth_iterations=3
+)
+```
+
+## Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `geom` | GeoDataFrame, BaseGeometry, or list[BaseGeometry] | Required | The geometry/geometries to smooth |
+| `segment_length` | float | None | Resolution of the original raster data in map units. If None (default), automatically detects by finding the minimum segment length (from a data sample). Recommended to specify explicitly when known |
+| `smooth_iterations` | int | 3 | Number of Chaikin corner-cutting iterations (typically 3-5). Higher values = smoother output with more vertices |
+| `num_cores` | int | 0 | Number of CPU cores for parallel processing (0 = all available cores, 1 = serial) |
+| `merge_collection` | bool | True | Whether to merge/dissolve adjacent geometries in collections before smoothing |
+| `merge_multipolygons` | bool | True | Whether to merge adjacent polygons within MultiPolygons before smoothing |
+| `preserve_area` | bool | True | Whether to restore original area after smoothing via buffering (applies to Polygons only) |
+| `area_tolerance` | float | 0.01 | Percentage of original area allowed as error (e.g., 0.01 = 0.01% error = 99.99% preservation). Only affects Polygons when preserve_area=True |
+
+## How It Works
+
+Smoothify uses an advanced multi-step smoothing pipeline:
+
+
+1. Adds intermediate vertices along line segments (segmentize)
+2. Generates multiple rotated variants (for Polygons) to avoid artifacts
+3. Simplifies each variant to remove noise
+4. Applies Chaikin corner cutting to smooth
+5. Merges all variants via union to eliminate start-point artifacts
+6. Applies final smoothing pass
+7. Optionally restores original area via buffering (for Polygons)
+
+## Performance Considerations
+
+- **Parallel Processing**: For large GeoDataFrames or collections, use `num_cores` = 0 to enable parallel processing
+- **Smoothing Iterations**: Values of 3-5 typically provide good results. Higher values create smoother output but increase processing time and vertex count
+- **Memory Usage**: Scales with geometry complexity. The algorithm creates multiple variants during smoothing
+- **Optimal segment_length**: Should match the original raster cell size (pixel size) or be slightly larger for best results
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/DPIRD-DMA/Smoothify/blob/main/LICENSE) file for details.

smoothify-0.1.1/README.md

@@ -0,0 +1,164 @@
+<p align="left">
+  <img src="https://raw.githubusercontent.com/DPIRD-DMA/Smoothify/main/images/smoothify_logo.png" alt="Smoothify Text" width="600">
+</p>
+
+[![Python Version](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/downloads/)
+[![License](https://img.shields.io/badge/license-MIT-green)](https://github.com/DPIRD-DMA/Smoothify/blob/main/LICENSE)
+[![PyPI version](https://img.shields.io/pypi/v/smoothify.svg)](https://pypi.org/project/smoothify/)
+[![Tutorials](https://img.shields.io/badge/Tutorials-Learn-brightgreen)](https://github.com/DPIRD-DMA/Smoothify/tree/main/examples)
+
+📋 [View Changelog](https://github.com/DPIRD-DMA/Smoothify/blob/main/CHANGELOG.md)
+
+A Python package for smoothing and refining geometries derived from raster data classifications. Smoothify transforms jagged polygons and lines resulting from raster-to-vector conversion into smooth, visually appealing features using an optimized implementation of Chaikin's corner-cutting algorithm.
+
+## Problem
+
+Polygons and lines derived from classified raster data (e.g., ML model predictions, spectral indices, or remote sensing classifications) often have unnatural "stair-stepped" or "pixelated" edges that:
+
+- Are visually unappealing in maps and GIS applications
+- Can be difficult to work with in downstream vector processing
+- Don't represent the real-world features they're meant to depict
+
+## Solution
+
+Smoothify applies an optimized implementation of Chaikin's corner-cutting algorithm along with other geometric processing to create smooth, natural-looking features while:
+
+- Preserving the general shape and area of polygons
+- Supporting all shapley geometry types
+- Handling shapes with interior holes
+- Efficiently processing large datasets with multiprocessing
+
+<p align="left">
+  <img src="https://raw.githubusercontent.com/DPIRD-DMA/Smoothify/main/images/smoothify_hero.png" alt="Smoothify Hero Image" width="600">
+</p>
+
+## Installation
+
+```bash
+uv add smoothify
+```
+or 
+```bash
+pip install smoothify
+```
+
+## Quick Start
+
+```python
+import geopandas as gpd
+from smoothify import smoothify
+
+# Load your polygonized raster data
+polygon_gdf = gpd.read_file("path/to/your/polygons.gpkg")
+
+# Apply smoothing (segment_length auto-detected from geometry)
+smoothed_gdf = smoothify(
+    geom=polygon_gdf,
+    smooth_iterations=3,  # More iterations = smoother result
+    num_cores=4  # Use parallel processing for large datasets
+)
+
+# Or specify segment_length explicitly (generally recommended)
+smoothed_gdf = smoothify(
+    geom=polygon_gdf,
+    segment_length=10.0,  # Use the original raster resolution
+    smooth_iterations=3,
+    num_cores=4
+)
+
+# Save the result
+smoothed_gdf.to_file("smoothed_polygons.gpkg")
+```
+
+## General Usage
+
+The `smoothify()` function accepts three types of input:
+
+### 1. GeoDataFrame
+```python
+import geopandas as gpd
+from smoothify import smoothify
+
+gdf = gpd.read_file("polygons.gpkg")
+smoothed_gdf = smoothify(
+    geom=gdf,
+    segment_length=10.0,
+    smooth_iterations=3,
+    num_cores=4
+)
+```
+
+### 2. Single Geometry
+```python
+from shapely.geometry import Polygon
+from smoothify import smoothify
+
+polygon = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])
+smoothed_polygon = smoothify(
+    geom=polygon,
+    smooth_iterations=3
+)
+```
+
+### 3. List of Geometries or GeometryCollection
+```python
+from shapely.geometry import Polygon, LineString
+from smoothify import smoothify
+
+geometries = [
+    Polygon([(0, 0), (10, 0), (10, 10), (0, 10)]),
+    LineString([(0, 0), (5, 5), (10, 0)])
+]
+smoothed = smoothify(
+    geom=geometries,
+    segment_length=1.0,
+    smooth_iterations=3
+)
+```
+
+## Parameters
+
+| Parameter | Type | Default | Description |
+|-----------|------|---------|-------------|
+| `geom` | GeoDataFrame, BaseGeometry, or list[BaseGeometry] | Required | The geometry/geometries to smooth |
+| `segment_length` | float | None | Resolution of the original raster data in map units. If None (default), automatically detects by finding the minimum segment length (from a data sample). Recommended to specify explicitly when known |
+| `smooth_iterations` | int | 3 | Number of Chaikin corner-cutting iterations (typically 3-5). Higher values = smoother output with more vertices |
+| `num_cores` | int | 0 | Number of CPU cores for parallel processing (0 = all available cores, 1 = serial) |
+| `merge_collection` | bool | True | Whether to merge/dissolve adjacent geometries in collections before smoothing |
+| `merge_multipolygons` | bool | True | Whether to merge adjacent polygons within MultiPolygons before smoothing |
+| `preserve_area` | bool | True | Whether to restore original area after smoothing via buffering (applies to Polygons only) |
+| `area_tolerance` | float | 0.01 | Percentage of original area allowed as error (e.g., 0.01 = 0.01% error = 99.99% preservation). Only affects Polygons when preserve_area=True |
+
+## How It Works
+
+Smoothify uses an advanced multi-step smoothing pipeline:
+
+
+1. Adds intermediate vertices along line segments (segmentize)
+2. Generates multiple rotated variants (for Polygons) to avoid artifacts
+3. Simplifies each variant to remove noise
+4. Applies Chaikin corner cutting to smooth
+5. Merges all variants via union to eliminate start-point artifacts
+6. Applies final smoothing pass
+7. Optionally restores original area via buffering (for Polygons)
+
+## Performance Considerations
+
+- **Parallel Processing**: For large GeoDataFrames or collections, use `num_cores` = 0 to enable parallel processing
+- **Smoothing Iterations**: Values of 3-5 typically provide good results. Higher values create smoother output but increase processing time and vertex count
+- **Memory Usage**: Scales with geometry complexity. The algorithm creates multiple variants during smoothing
+- **Optimal segment_length**: Should match the original raster cell size (pixel size) or be slightly larger for best results
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+1. Fork the repository
+2. Create your feature branch (`git checkout -b feature/amazing-feature`)
+3. Commit your changes (`git commit -m 'Add some amazing feature'`)
+4. Push to the branch (`git push origin feature/amazing-feature`)
+5. Open a Pull Request
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](https://github.com/DPIRD-DMA/Smoothify/blob/main/LICENSE) file for details.

smoothify-0.1.1/pyproject.toml

@@ -0,0 +1,43 @@
+[build-system]
+requires = ["setuptools >= 61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "smoothify"
+authors = [{name = "Nick Wright", email = "nicholas.wright@dpird.wa.gov.au"}]
+dynamic = ["version"]
+description = "Transform pixelated geometries from raster data into smooth natural looking features"
+requires-python = ">=3.10"
+dependencies = [
+    "geopandas>=1.0.0",
+    "joblib>=1.4.0",
+    "numpy>=1.27.0",
+    "scipy>=1.11.0",
+    "shapely>=2.0.2",
+]
+
+license = "MIT"
+readme = {file = "README.md", content-type = "text/markdown"}
+keywords = ["geometry", "smoothing", "smooth", "GIS", "raster", "vector", "chaikin", "shapely", "geopandas"]
+
+
+[tool.setuptools.dynamic]
+version = {attr = "smoothify.__version__.__version__"}
+
+[dependency-groups]
+dev = [
+    "descartes>=1.1.0",
+    "ipykernel>=6.29.5",
+    "matplotlib>=3.9.4",
+    "pytest>=8.4.2",
+    "pytest-cov>=6.0.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/DPIRD-DMA/Smoothify"
+
+[tool.setuptools]
+packages = ["smoothify"]
+
+[tool.ruff.lint]
+select = ["E", "F", "B"]

smoothify-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

smoothify-0.1.1/smoothify/__init__.py

@@ -0,0 +1,28 @@
+"""
+Smoothify - Geometry Smoothing Package
+
+A Python package for smoothing and refining geometries derived from raster data
+classifications. Transforms jagged polygons and lines resulting from raster-to-vector
+conversion into smooth, visually appealing features using an optimized implementation
+of Chaikin's corner-cutting algorithm.
+
+Supports:
+    - Polygons (including those with holes)
+    - LineStrings
+    - MultiPolygons
+    - MultiLineStrings
+    - GeometryCollections
+    - GeoDataFrames
+
+Main function:
+    smoothify() - Apply Chaikin corner-cutting smoothing to geometries
+"""
+
+from .__version__ import __version__
+from .coordinator import smoothify
+
+# Package-wide exports
+__all__ = [
+    "smoothify",
+    "__version__",
+]

smoothify-0.1.1/smoothify/__version__.py

@@ -0,0 +1 @@
+__version__ = "0.1.1"

smoothify-0.1.1/smoothify/coordinator.py

@@ -0,0 +1,173 @@
+from multiprocessing import cpu_count
+from typing import Optional, Sequence, overload
+
+import geopandas as gpd
+from shapely.geometry import (
+    GeometryCollection,
+    LinearRing,
+    LineString,
+    MultiLineString,
+    MultiPolygon,
+    Polygon,
+)
+from shapely.geometry.base import BaseGeometry
+
+from smoothify.geometry_ops import (
+    _auto_detect_segment_length,
+    _smoothify_bulk,
+    _smoothify_geodataframe,
+    _smoothify_single,
+)
+
+
+@overload
+def smoothify(
+    geom: gpd.GeoDataFrame,
+    segment_length: Optional[float] = None,
+    num_cores: int = 0,
+    smooth_iterations: int = 3,
+    merge_collection: bool = True,
+    merge_multipolygons: bool = True,
+    preserve_area: bool = True,
+    area_tolerance: float = 0.01,
+) -> gpd.GeoDataFrame: ...
+
+
+@overload
+def smoothify(
+    geom: Sequence[BaseGeometry],
+    segment_length: Optional[float] = None,
+    num_cores: int = 0,
+    smooth_iterations: int = 3,
+    merge_collection: bool = True,
+    merge_multipolygons: bool = True,
+    preserve_area: bool = True,
+    area_tolerance: float = 0.01,
+) -> BaseGeometry: ...
+
+
+@overload
+def smoothify(
+    geom: BaseGeometry,
+    segment_length: Optional[float] = None,
+    num_cores: int = 0,
+    smooth_iterations: int = 3,
+    merge_collection: bool = True,
+    merge_multipolygons: bool = True,
+    preserve_area: bool = True,
+    area_tolerance: float = 0.01,
+) -> BaseGeometry: ...
+
+
+def smoothify(
+    geom: BaseGeometry | Sequence[BaseGeometry] | gpd.GeoDataFrame,
+    segment_length: Optional[float] = None,
+    num_cores: int = 0,
+    smooth_iterations: int = 3,
+    merge_collection: bool = True,
+    merge_multipolygons: bool = True,
+    preserve_area: bool = True,
+    area_tolerance: float = 0.01,
+) -> BaseGeometry | Sequence[BaseGeometry] | gpd.GeoDataFrame:
+    """Smooth geometries derived from raster data using Chaikin's corner-cutting algorithm.
+
+    Main entry point for smoothing jagged polygons and lines resulting from
+    raster-to-vector conversion. Transforms pixelated edges into smooth, natural-looking
+    curves while preserving general shape and area characteristics.
+
+    Supports multiple input types:
+    - Single geometries (Polygon, LineString, LinearRing, MultiPolygon, MultiLineString)
+    - Lists of geometries or GeometryCollections
+    - GeoDataFrames
+
+    Args:
+        geom: Geometry, list of geometries, or GeoDataFrame to smooth.
+        segment_length: Resolution of the original raster data in map units. Used for
+            adding intermediate vertices and simplification. Should match or exceed
+            the original raster pixel size. If None (default), automatically detects
+            segment length by finding the minimum segment length, which represents the
+            true pixel size in pixelated geometries (corners retain minimum length even
+            when straight edges are simplified during polygonization).
+        num_cores: Number of CPU cores for parallel processing (0 = all available cores,
+            1 = serial processing). Only applies to GeoDataFrames and collections.
+        smooth_iterations: Number of Chaikin corner-cutting iterations (typically 3-5).
+            Higher values produce smoother results but add more vertices.
+        merge_collection: Whether to merge/dissolve adjacent geometries in collections
+            before smoothing. Useful for joining polygons from adjacent raster cells.
+        merge_multipolygons: Whether to merge adjacent polygons within MultiPolygons
+            before smoothing.
+        preserve_area: Whether to restore original area after smoothing via buffering.
+            Applied to Polygons only.
+        area_tolerance: Percentage of original area allowed as error
+            (e.g., 0.01 = 0.01% error). Default is 0.01% (99.99% area preservation).
+            Smaller values = more accurate area preservation but slower.
+            Only affects Polygons when preserve_area=True.
+
+    Returns:
+        Smoothed geometry matching the input type:
+        - BaseGeometry for single geometry inputs
+        - list[BaseGeometry] for list inputs
+        - GeoDataFrame for GeoDataFrame inputs
+
+    Raises:
+        ValueError: If input is not a supported geometry type.
+
+    Examples:
+        >>> from smoothify import smoothify
+        >>> import geopandas as gpd
+        >>> from shapely.geometry import Polygon
+        >>>
+        >>> # Smooth a single polygon with default area tolerance (0.01%)
+        >>> polygon = Polygon([(0, 0), (10, 0), (10, 10), (0, 10)])
+        >>> smoothed = smoothify(polygon, segment_length=1.0, smooth_iterations=3)
+        >>>
+        >>> # Smooth with stricter area preservation (0.001% error)
+        >>> smoothed = smoothify(polygon, segment_length=1.0, area_tolerance=0.001)
+        >>>
+        >>> # Smooth a GeoDataFrame in parallel
+        >>> gdf = gpd.read_file("water_bodies.gpkg")
+        >>> smoothed_gdf = smoothify(gdf, segment_length=10.0, num_cores=4)
+    """  # noqa: E501
+    if num_cores <= 0:
+        num_cores = cpu_count()
+    if isinstance(geom, list):
+        geom = GeometryCollection(geom)
+
+    if segment_length is None:
+        segment_length = _auto_detect_segment_length(geom)
+
+    if isinstance(geom, GeometryCollection | MultiPolygon | MultiLineString):
+        return _smoothify_bulk(
+            geom=geom,
+            segment_length=segment_length,
+            num_cores=num_cores,
+            smooth_iterations=smooth_iterations,
+            merge_collection=merge_collection,
+            merge_multipolygons=merge_multipolygons,
+            preserve_area=preserve_area,
+            area_tolerance=area_tolerance,
+        )
+    elif isinstance(geom, Polygon | LineString | LinearRing):
+        return _smoothify_single(
+            geom=geom,
+            segment_length=segment_length,
+            smooth_iterations=smooth_iterations,
+            merge_multipolygons=merge_multipolygons,
+            preserve_area=preserve_area,
+            area_tolerance=area_tolerance,
+        )
+    elif isinstance(geom, gpd.GeoDataFrame):
+        return _smoothify_geodataframe(
+            gdf=geom,
+            segment_length=segment_length,
+            num_cores=num_cores,
+            smooth_iterations=smooth_iterations,
+            merge_collection=merge_collection,
+            merge_multipolygons=merge_multipolygons,
+            preserve_area=preserve_area,
+            area_tolerance=area_tolerance,
+        )
+    else:
+        raise ValueError(
+            f"Input geometry must be a BaseGeometry or list of BaseGeometry. Got {type(geom)}."  # noqa: E501
+        )