shapely 2.1.2__cp314-cp314-win_amd64.whl

shapely/__init__.py

@@ -0,0 +1,48 @@
+"""Manipulation and analysis of geometric objects in the Cartesian plane."""
+
+
+# start delvewheel patch
+def _delvewheel_patch_1_11_1():
+    import os
+    if os.path.isdir(libs_dir := os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, 'shapely.libs'))):
+        os.add_dll_directory(libs_dir)
+
+
+_delvewheel_patch_1_11_1()
+del _delvewheel_patch_1_11_1
+# end delvewheel patch
+
+from shapely.lib import GEOSException
+from shapely.lib import Geometry
+from shapely.lib import geos_version, geos_version_string
+from shapely.lib import geos_capi_version, geos_capi_version_string
+from shapely.errors import setup_signal_checks
+from shapely._geometry import *
+from shapely.creation import *
+from shapely.constructive import *
+from shapely.predicates import *
+from shapely.measurement import *
+from shapely.set_operations import *
+from shapely.linear import *
+from shapely.coordinates import *
+from shapely.strtree import *
+from shapely.io import *
+from shapely._coverage import *
+
+# Submodule always needs to be imported to ensure Geometry subclasses are registered
+from shapely.geometry import (
+    Point,
+    LineString,
+    Polygon,
+    MultiPoint,
+    MultiLineString,
+    MultiPolygon,
+    GeometryCollection,
+    LinearRing,
+)
+
+from shapely import _version
+
+__version__ = _version.get_versions()["version"]
+
+setup_signal_checks()

shapely/_coverage.py

@@ -0,0 +1,168 @@
+import numpy as np
+
+from shapely import Geometry, GeometryType, lib
+from shapely._geometry import get_parts
+from shapely.decorators import multithreading_enabled, requires_geos
+
+__all__ = ["coverage_invalid_edges", "coverage_is_valid", "coverage_simplify"]
+
+
+@requires_geos("3.12.0")
+@multithreading_enabled
+def coverage_is_valid(geometry, gap_width=0.0, **kwargs):
+    """Verify if a coverage is valid.
+
+    The coverage is represented by an array of polygonal geometries with
+    exactly matching edges and no overlap.
+
+    A valid coverage may contain holes (regions of no coverage). However,
+    sometimes it might be desirable to detect narrow gaps as invalidities in
+    the coverage. The `gap_width` parameter allows to specify the maximum
+    width of gaps to detect. When gaps are detected, this function will
+    return False and the `coverage_invalid_edges` function can be used to
+    find the edges of those gaps.
+
+    Geometries that are not Polygon or MultiPolygon are ignored.
+
+    .. versionadded:: 2.1.0
+
+    Parameters
+    ----------
+    geometry : array_like
+        Array of geometries to verify.
+    gap_width : float, default 0.0
+        The maximum width of gaps to detect.
+    **kwargs
+        See :ref:`NumPy ufunc docs <ufuncs.kwargs>` for other keyword arguments.
+
+    Returns
+    -------
+    bool
+
+    See Also
+    --------
+    coverage_invalid_edges, coverage_simplify
+
+    """
+    geometries = np.asarray(geometry)
+    # we always consider the full array as a single coverage -> ravel the input
+    # to pass a 1D array
+    return lib.coverage_is_valid(geometries.ravel(order="K"), gap_width, **kwargs)
+
+
+@requires_geos("3.12.0")
+@multithreading_enabled
+def coverage_invalid_edges(geometry, gap_width=0.0, **kwargs):
+    """Verify if a coverage is valid and return invalid edges.
+
+    This functions returns linear indicators showing the location of invalid
+    edges (if any) in each polygon in the input array.
+
+    The coverage is represented by an array of polygonal geometries with
+    exactly matching edges and no overlap.
+
+    A valid coverage may contain holes (regions of no coverage). However,
+    sometimes it might be desirable to detect narrow gaps as invalidities in
+    the coverage. The `gap_width` parameter allows to specify the maximum
+    width of gaps to detect. When gaps are detected, the `coverage_is_valid`
+    function will return False and this function can be used to find the
+    edges of those gaps.
+
+    Geometries that are not Polygon or MultiPolygon are ignored.
+
+    .. versionadded:: 2.1.0
+
+    Parameters
+    ----------
+    geometry : array_like
+        Array of geometries to verify.
+    gap_width : float, default 0.0
+        The maximum width of gaps to detect.
+    **kwargs
+        See :ref:`NumPy ufunc docs <ufuncs.kwargs>` for other keyword arguments.
+
+    Returns
+    -------
+    numpy.ndarray | shapely.Geometry
+
+    See Also
+    --------
+    coverage_is_valid, coverage_simplify
+
+    """
+    geometries = np.asarray(geometry)
+    # we always consider the full array as a single coverage -> ravel the input
+    # to pass a 1D array
+    return lib.coverage_invalid_edges(geometries.ravel(order="K"), gap_width, **kwargs)
+
+
+@requires_geos("3.12.0")
+@multithreading_enabled
+def coverage_simplify(geometry, tolerance, *, simplify_boundary=True):
+    """Return a simplified version of an input geometry using coverage simplification.
+
+    Assumes that the geometry forms a polygonal coverage. Under this assumption, the
+    function simplifies the edges using the Visvalingam-Whyatt algorithm, while
+    preserving a valid coverage. In the most simplified case, polygons are reduced to
+    triangles.
+
+    A collection of valid polygons is considered a coverage if the polygons are:
+
+    * **Non-overlapping** - polygons do not overlap (their interiors do not intersect)
+    * **Edge-Matched** - vertices along shared edges are identical
+
+    The function allows simplification of all edges including the outer boundaries of
+    the coverage or simplification of only the inner (shared) edges.
+
+    If there are other geometry types than Polygons or MultiPolygons present,
+    the function will raise an error.
+
+    If the geometry is polygonal but does not form a valid coverage due to overlaps,
+    it will be simplified but it may result in invalid topology.
+
+    .. versionadded:: 2.1.0
+
+    Parameters
+    ----------
+    geometry : Geometry or array_like
+    tolerance : float or array_like
+        The degree of simplification roughly equal to the square root of the area
+        of triangles that will be removed.
+    simplify_boundary : bool, optional
+        By default (True), simplifies both internal edges of the coverage as well
+        as its boundary. If set to False, only simplifies internal edges.
+
+    Returns
+    -------
+    numpy.ndarray | shapely.Geometry
+
+    See Also
+    --------
+    coverage_is_valid, coverage_invalid_edges
+
+    Examples
+    --------
+    >>> import shapely
+    >>> from shapely import Polygon
+    >>> poly = Polygon([(0, 0), (20, 0), (20, 10), (10, 5), (0, 10), (0, 0)])
+    >>> shapely.coverage_simplify(poly, tolerance=2)
+    <POLYGON ((0 0, 20 0, 20 10, 10 5, 0 10, 0 0))>
+    """
+    scalar = False
+    if isinstance(geometry, Geometry):
+        scalar = True
+
+    geometries = np.asarray(geometry)
+    shape = geometries.shape
+    geometries = geometries.ravel()
+
+    # create_collection acts on the inner axis
+    collections = lib.create_collection(
+        geometries, np.intc(GeometryType.GEOMETRYCOLLECTION)
+    )
+
+    simplified = lib.coverage_simplify(collections, tolerance, simplify_boundary)
+    parts = get_parts(simplified).reshape(shape)
+    if scalar:
+        return parts.item()
+    return parts

shapely/_enum.py

@@ -0,0 +1,23 @@
+from enum import IntEnum
+
+
+class ParamEnum(IntEnum):
+    """Wraps IntEnum to provide validation of a requested item.
+
+    Intended for enums used for function parameters.
+
+    Use enum.get_value(item) for this behavior instead of builtin enum[item].
+    """
+
+    @classmethod
+    def get_value(cls, item):
+        """Validate item and raise a ValueError with valid options if not present."""
+        try:
+            return cls[item].value
+        except KeyError:
+            valid_options = {e.name for e in cls}
+            raise ValueError(
+                "'{}' is not a valid option, must be one of '{}'".format(
+                    item, "', '".join(valid_options)
+                )
+            )