transformnd 0.3.0__tar.gz → 0.4.1__tar.gz

{transformnd-0.3.0 → transformnd-0.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transformnd
-Version: 0.3.0
+Version: 0.4.1
 Summary: ND coordinate transformations
 Author: Chris Barnes
 Author-email: Chris Barnes <chris.barnes@gerbi-gmb.de>
@@ -20,20 +20,37 @@ Requires-Dist: numpy>=2
 Requires-Dist: networkx>=3
 Requires-Dist: array-api-compat>=1.14
 Requires-Dist: typing-extensions>=4.15.0
+Requires-Dist: transformnd[pandas] ; extra == 'adapters'
+Requires-Dist: transformnd[shapely] ; extra == 'adapters'
+Requires-Dist: transformnd[polars] ; extra == 'adapters'
+Requires-Dist: transformnd[transforms] ; extra == 'all'
+Requires-Dist: transformnd[adapters] ; extra == 'all'
 Requires-Dist: molesq>=0.4.0 ; extra == 'movingleastsquares'
 Requires-Dist: pandas>=3.0.2 ; extra == 'pandas'
 Requires-Dist: polars>=1.40.1 ; extra == 'polars'
 Requires-Dist: shapely>=2.1.2 ; extra == 'shapely'
 Requires-Dist: morphops>=0.1.13 ; extra == 'thinplatesplines'
+Requires-Dist: transformnd[thinplatesplines] ; extra == 'transforms'
+Requires-Dist: transformnd[movingleastsquares] ; extra == 'transforms'
+Requires-Dist: transformnd[vectorfield] ; extra == 'transforms'
+Requires-Dist: transformnd[vectorfield-dask] ; extra == 'transforms'
+Requires-Dist: scipy>=1.17.1 ; extra == 'vectorfield'
+Requires-Dist: dask>=2026.3.0 ; extra == 'vectorfield-dask'
+Requires-Dist: dask-image>=2026.5.0 ; extra == 'vectorfield-dask'
 Requires-Python: >=3.12, <4.0
 Project-URL: documentation, https://transformnd.readthedocs.io/en/latest/
 Project-URL: source, https://github.com/clbarnes/transformnd
 Project-URL: issues, https://github.com/clbarnes/transformnd/issues
+Provides-Extra: adapters
+Provides-Extra: all
 Provides-Extra: movingleastsquares
 Provides-Extra: pandas
 Provides-Extra: polars
 Provides-Extra: shapely
 Provides-Extra: thinplatesplines
+Provides-Extra: transforms
+Provides-Extra: vectorfield
+Provides-Extra: vectorfield-dask
 Description-Content-Type: text/markdown
 
 # transformnd
@@ -71,18 +88,21 @@ Open it with `uv run --group tutorial marimo edit examples/tutorial.py`.
 
 ## Implemented transforms
 
-- Identity (`transformnd.transforms.Identity`)
-- Translation (`transformnd.transforms.Translate`)
-- Scale (`transformnd.transforms.Scale`)
-- Reflection (`transformnd.transforms.Reflect`)
-- Affine (`transformnd.transforms.Affine`)
-  - Can be composed efficiently with `@` operator; the right hand operand is effectively applied first
-- MapAxis (`transformnd.transforms.MapAxis`): permute coordinate axes
-- ByDimension (`transformnd.transforms.ByDimension`): apply transformations to subsets of coordinate axes
-- Moving Least Squares, affine (`transformnd.transforms.moving_least_squares.MovingLeastSquares`)
-  - uses `movingleastsquares` extra
-- Thin Plate Splines (`transformnd.transforms.thinplate.ThinPlateSplines`)
-  - uses `thinplatesplines` extra
+All transforms are accessed under the `transformnd.transforms` subpackage.
+
+| Transform | Extra | Description |
+| --------- | ----- | ----------- |
+| `Identity` | | No-op transformation |
+| `Translation` | | Add a constant translation to the input coordinates |
+| `Scale` | | Multiply the input coordinates by constant scale factor |
+| `Reflection` | | Reflect coordinates about arbitrary planes |
+| `MapAxis` | | Rearrange axes of the input coordinates |
+| `Affine` | | Multiply augmented coordinates by an affine transformation matrix. Can represent all of the above transformations. Can be composed with matrix multiplication `aff2 @ aff1`. |
+| `ByDimension` | | Apply different transformations to subsets of the input coordinates' dimensions |
+| `moving_least_squares.MovingLeastSquares` | `movingleastsquares` | Landmark-based transformation. |
+| `thin_plate_splines.ThinPlateSplines` | `thinplatesplines` | Landmark-based transformation. |
+| `vector_field.Coordinates` | `vectorfield` for in-memory, `vectorfield-dask` for chunked | Look up output coordinates in a vector field indexed by the input coordinates |
+| `vector_field.Displacements` | `vectorfield`, `vectorfield-dask` for chunked | Look up translations in a vector field indexed by the input coordinates, and add them to input coordinates |
 
 Arbitrary transforms can be composed into a `TransformSequence` with `transform1 | transform2`.
 A graph of transforms between defined spaces can be traversed using the `TransformGraph`.
@@ -135,12 +155,14 @@ Methods which SHOULD be implemented if applicable:
   - `just` to list commands.
 - Docs are generated with [`pdoc`](https://pdoc.dev/) (use `just doc`) and hosted on ReadTheDocs
 - `just bump` bumps the version, commits, and tags (but does not push); depends on [`schpet/changelog`](https://github.com/schpet/changelog)
+- `just repl` starts an IPython shell with all dependencies installed
 
 ## Thanks
 
 Thanks to contributors
 
 - [Francesca Drummer](https://github.com/FrancescaDr)
+- [Johannes Soltwedel](https://github.com/jo-mueller)
 - [Lorenzo Cerrone](https://github.com/lorenzocerrone)
 - [Maks Hess](https://github.com/MaksHess)
 - [Silvia Maria Macrì](https://github.com/SilviaMariaMacri)

{transformnd-0.3.0 → transformnd-0.4.1}/README.md

@@ -33,18 +33,21 @@ Open it with `uv run --group tutorial marimo edit examples/tutorial.py`.
 
 ## Implemented transforms
 
-- Identity (`transformnd.transforms.Identity`)
-- Translation (`transformnd.transforms.Translate`)
-- Scale (`transformnd.transforms.Scale`)
-- Reflection (`transformnd.transforms.Reflect`)
-- Affine (`transformnd.transforms.Affine`)
-  - Can be composed efficiently with `@` operator; the right hand operand is effectively applied first
-- MapAxis (`transformnd.transforms.MapAxis`): permute coordinate axes
-- ByDimension (`transformnd.transforms.ByDimension`): apply transformations to subsets of coordinate axes
-- Moving Least Squares, affine (`transformnd.transforms.moving_least_squares.MovingLeastSquares`)
-  - uses `movingleastsquares` extra
-- Thin Plate Splines (`transformnd.transforms.thinplate.ThinPlateSplines`)
-  - uses `thinplatesplines` extra
+All transforms are accessed under the `transformnd.transforms` subpackage.
+
+| Transform | Extra | Description |
+| --------- | ----- | ----------- |
+| `Identity` | | No-op transformation |
+| `Translation` | | Add a constant translation to the input coordinates |
+| `Scale` | | Multiply the input coordinates by constant scale factor |
+| `Reflection` | | Reflect coordinates about arbitrary planes |
+| `MapAxis` | | Rearrange axes of the input coordinates |
+| `Affine` | | Multiply augmented coordinates by an affine transformation matrix. Can represent all of the above transformations. Can be composed with matrix multiplication `aff2 @ aff1`. |
+| `ByDimension` | | Apply different transformations to subsets of the input coordinates' dimensions |
+| `moving_least_squares.MovingLeastSquares` | `movingleastsquares` | Landmark-based transformation. |
+| `thin_plate_splines.ThinPlateSplines` | `thinplatesplines` | Landmark-based transformation. |
+| `vector_field.Coordinates` | `vectorfield` for in-memory, `vectorfield-dask` for chunked | Look up output coordinates in a vector field indexed by the input coordinates |
+| `vector_field.Displacements` | `vectorfield`, `vectorfield-dask` for chunked | Look up translations in a vector field indexed by the input coordinates, and add them to input coordinates |
 
 Arbitrary transforms can be composed into a `TransformSequence` with `transform1 | transform2`.
 A graph of transforms between defined spaces can be traversed using the `TransformGraph`.
@@ -97,12 +100,14 @@ Methods which SHOULD be implemented if applicable:
   - `just` to list commands.
 - Docs are generated with [`pdoc`](https://pdoc.dev/) (use `just doc`) and hosted on ReadTheDocs
 - `just bump` bumps the version, commits, and tags (but does not push); depends on [`schpet/changelog`](https://github.com/schpet/changelog)
+- `just repl` starts an IPython shell with all dependencies installed
 
 ## Thanks
 
 Thanks to contributors
 
 - [Francesca Drummer](https://github.com/FrancescaDr)
+- [Johannes Soltwedel](https://github.com/jo-mueller)
 - [Lorenzo Cerrone](https://github.com/lorenzocerrone)
 - [Maks Hess](https://github.com/MaksHess)
 - [Silvia Maria Macrì](https://github.com/SilviaMariaMacri)

{transformnd-0.3.0 → transformnd-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "transformnd"
-version = "0.3.0"
+version = "0.4.1"
 description = "ND coordinate transformations"
 readme = "README.md"
 authors = [{ name = "Chris Barnes", email = "chris.barnes@gerbi-gmb.de" }]
@@ -41,6 +41,21 @@ shapely = ["shapely>=2.1.2"]
 polars = [
     "polars>=1.40.1",
 ]
+vectorfield = [
+    "scipy>=1.17.1",
+]
+vectorfield-dask = [
+    "dask>=2026.3.0",
+    "dask-image>=2026.5.0",
+]
+transforms = [
+    "transformnd[thinplatesplines]",
+    "transformnd[movingleastsquares]",
+    "transformnd[vectorfield]",
+    "transformnd[vectorfield-dask]",
+]
+adapters = ["transformnd[pandas]", "transformnd[shapely]", "transformnd[polars]"]
+all = ["transformnd[transforms]", "transformnd[adapters]"]
 
 [dependency-groups]
 dev = [
@@ -50,7 +65,11 @@ dev = [
     {include-group = "tutorial"},
     {include-group = "bench"},
 ]
-test = ["pytest", "jax"]
+test = [
+    "pytest",
+    "jax",
+    "dask>=2026.3.0",
+]
 lint = [
     "ruff",
     "mypy",

transformnd-0.4.1/src/transformnd/adapters/shapely.py

@@ -0,0 +1,64 @@
+import logging
+
+import numpy as np
+import shapely
+from shapely.geometry.base import BaseGeometry
+from shapely.coords import CoordinateSequence
+
+from ..base import Transform, ArrayT
+from .base import BaseAdapter
+
+logger = logging.getLogger(__name__)
+
+
+def as_numpy(coords: CoordinateSequence) -> np.ndarray:
+    return np.asarray(coords)
+
+
+class GeometryAdapter(BaseAdapter[BaseGeometry, ArrayT]):
+    """Transform shapely geometries.
+
+    As well as the generic `apply()`,
+    there are `apply_*()` methods for transforming different geometry subclasses.
+
+    N.B. some transforms may create invalid topologies
+    (incorrect winding, self-intersections etc.).
+
+    N.B. shapely geometries' coordinates are in `XY(Z)` order
+    """
+
+    def apply[T: BaseGeometry](
+        self,
+        transform: Transform,
+        obj: T,
+        *,
+        include_z: bool | None = None,
+    ) -> T:
+        """Transform the shapely geometry.
+
+        Parameters
+        ----------
+        transform
+            The transformation to apply.
+        obj
+            Some shapely geometry in 2 or 3D
+        include_z
+            Force inclusion/ exclusion of Z coordinate.
+            By default (None), checks whether the given geometry has Z coordinates.
+
+        Returns
+        -------
+        T
+            An object of the same type as the input.
+        """
+
+        def fn(coords: np.ndarray) -> np.ndarray:
+            c = coords.copy()
+            return transform.apply(c)
+
+        if include_z is None:
+            inc_z = bool(shapely.has_z(obj))
+        else:
+            inc_z = include_z
+
+        return shapely.transform(obj, fn, include_z=inc_z)

{transformnd-0.3.0 → transformnd-0.4.1}/src/transformnd/graph.py

@@ -1,7 +1,6 @@
 """Bridging transforms between known spaces."""
 
 from __future__ import annotations
-from dataclasses import dataclass
 from functools import lru_cache
 from collections.abc import Iterable, Iterator
 import logging
@@ -47,41 +46,6 @@ def split_sequence(seq: TransformSequence[ArrayT]) -> Iterator[Transform[ArrayT]
             this_seq = []
 
 
-@dataclass(frozen=True, eq=True)
-class SimplifyConfig:
-    ndim: int | None = None
-    """Force specific dimensionality, allowing conversion to affines."""
-
-    drop_inverse: bool = False
-    """Drop explicit inverses in bijection transformations."""
-
-
-class NDimRegistries:
-    def __init__(self, perm: dict[SpaceRef, int]) -> None:
-        self.perm = perm
-        self.temp: dict[SpaceRef, int] = dict()
-
-    def _check_inner(
-        self, space: SpaceRef, ndim: int, reg: dict[SpaceRef, int], add: bool = False
-    ):
-        val = reg.get(space)
-        if val is None:
-            if add:
-                reg[space] = ndim
-            return None
-        if val != ndim:
-            raise ValueError(
-                f"New transform implies space {space} is {ndim}D, but it is already registered as {val}D"
-            )
-
-    def merge(self):
-        self.perm.update(self.temp)
-
-    def check(self, space: SpaceRef, ndim: int):
-        self._check_inner(space, ndim, self.perm)
-        self._check_inner(space, ndim, self.temp, True)
-
-
 class TransformGraph[ArrayT]:
     """Transform between any number of arbitrary spaces/ coordinate systems.
 

transformnd-0.4.1/src/transformnd/transforms/vector_field.py

@@ -0,0 +1,229 @@
+from abc import ABC
+from collections.abc import Iterable
+from types import ModuleType
+from typing import Self
+
+import numpy as np
+from array_api_compat import array_namespace, is_dask_array
+
+from ..types import NDims, Spaces
+from ..base import Transform, ArrayT
+from ..util import set_scipy_array_api, as_floats
+
+set_scipy_array_api()
+
+__all__ = ["Coordinates", "Displacements"]
+
+
+class BaseVectorField(Transform[ArrayT], ABC):
+    def __init__(
+        self,
+        vector_field: ArrayT,
+        index_transform: Transform[ArrayT] | None = None,
+        interpolation_order: int = 3,
+        vector_axis: int = -1,
+        *,
+        spaces: Spaces = Spaces(None, None),
+    ):
+        """Look up a vector in array.
+
+        Parameters
+        ----------
+        vector_field
+            Array with `Di + 1` dimensions, where `Di` is the input dimensionality.
+        index_transform
+            Transformation from source coordinate to array indices.
+        interpolation_order
+            Order of the spline interpolation used for coordinates which are not integer array indices.
+        vector_axis
+            Which axis of the `vector_field` contains the vector values; defaults to the last (`-1`).
+        spaces
+            References for source and target spaces
+
+        Raises
+        ------
+        ValueError
+            If index_transform's output dimensionality is not exactly one less than the vector field's number of dimensions.
+        """
+        self.vector_field: ArrayT = as_floats(vector_field)  # type: ignore
+        xp = array_namespace(vector_field)
+        sh = xp.shape(vector_field)
+        in_ndim = len(sh) - 1
+        tgt_ndim = sh[vector_axis]
+        self.vector_field = vector_field
+        if index_transform is None:
+            source_ndim = in_ndim
+        else:
+            if in_ndim != index_transform.ndims.target:
+                raise ValueError(
+                    "If index_transform is given, its output dimensionality must match the vector field's shape"
+                )
+            source_ndim = index_transform.ndims.source
+        self.index_transform = index_transform
+        self.vector_axis = vector_axis % len(sh)
+        self._mode = "constant"
+        self._cval = np.nan
+        self._order = interpolation_order
+        super().__init__(NDims(source_ndim, tgt_ndim), spaces=spaces)
+
+    def _vf_slices(self) -> Iterable[ArrayT]:
+        slicing: list[slice | int] = [slice(None)] * (self.ndims.source + 1)
+        for v_idx in range(self.ndims.target):
+            slicing[self.vector_axis] = v_idx
+            yield self.vector_field[tuple(slicing)]  # type: ignore
+
+    def _get_vectors_inner_dask(self, index_coords_t: ArrayT) -> ArrayT:
+        import dask.array as da
+        from dask_image.ndinterp import map_coordinates
+
+        out = []
+        for vf in self._vf_slices():
+            out.append(
+                map_coordinates(
+                    vf,
+                    index_coords_t,
+                    order=self._order,
+                    mode=self._mode,
+                    cval=self._cval,
+                )
+            )
+        stacked = da.stack(out)
+        return da.transpose(stacked)
+
+    def _get_vectors_inner_scipy(self, index_coords_t: ArrayT) -> ArrayT:
+        from scipy.ndimage import map_coordinates
+
+        set_scipy_array_api()
+        xp = array_namespace(index_coords_t)
+        out = xp.zeros_like(
+            self.vector_field, shape=(self.ndims.target, xp.shape(index_coords_t)[1])
+        )
+        for idx, vf in enumerate(self._vf_slices()):
+            map_coordinates(
+                vf,
+                index_coords_t,
+                order=self._order,
+                mode=self._mode,
+                cval=self._cval,
+                output=out[idx, :],
+            )
+        return xp.transpose(out)
+
+    def _get_vectors(self, coords: ArrayT) -> ArrayT:
+        if self.index_transform is not None:
+            coords = self.index_transform.apply(coords)
+        else:
+            coords = self._validate_coords(coords)
+        xp = array_namespace(coords)
+        c = xp.transpose(coords)
+        if is_dask_array(self.vector_field):
+            return self._get_vectors_inner_dask(c)
+        else:
+            return self._get_vectors_inner_scipy(c)
+
+    def to_device(self, xp: ModuleType, device: str | None = None) -> Self:
+        coords = xp.asarray(self.vector_field, device)
+        return type(self)(coords, spaces=self.spaces)
+
+
+class Coordinates(BaseVectorField[ArrayT]):
+    """Look up the output coordinates in an array.
+
+    For input coordinate `(a, b, c)` and `vector_axis=-1`,
+    the output coordinate is `vector_field[a, b, c, :].
+
+    Input coordinates outside the vector field return NaN.
+    """
+
+    def __init__(
+        self,
+        vector_field: ArrayT,
+        index_transform: Transform[ArrayT] | None = None,
+        interpolation_order: int = 3,
+        vector_axis: int = -1,
+        *,
+        spaces: Spaces = Spaces(None, None),
+    ):
+        """Use the input coordinates as array indices to look up output coordinates.
+
+        For input coordinate `(a, b, c)`, the output coordinate is `coordinates[a, b, c, :]`.
+
+        Input coordinates outside of the `vector_field` array return `NaN` output coordinates.
+
+        Parameters
+        ----------
+        vector_field
+            Array with `Di + 1` dimensions, where `Di` is the input dimensionality.
+        index_transform
+            Transform the source coordinates into an array index
+        interpolation_order
+            Order of the spline interpolation used for coordinates which are not integer array indices.
+        vector_axis
+            Which axis of the `vector_field` contains the vector values; defaults to the last (`-1`).
+        spaces
+            References for source and target spaces
+        """
+        super().__init__(
+            vector_field,
+            index_transform,
+            interpolation_order,
+            vector_axis,
+            spaces=spaces,
+        )
+
+    def apply(self, coords: ArrayT) -> ArrayT:
+        return self._get_vectors(coords)
+
+
+class Displacements(BaseVectorField[ArrayT]):
+    """Look up a translation in an array and apply it to the input coordinates.
+
+    For input coordinate `(a, b, c)` and `vector_axis=-1`,
+    the output coordinate is `(a, b, c) + vector_field[a, b, c, :].
+
+    Input coordinates outside the vector field return NaN.
+    """
+
+    def __init__(
+        self,
+        vector_field: ArrayT,
+        index_transform: Transform[ArrayT] | None = None,
+        interpolation_order: int = 3,
+        vector_axis: int = -1,
+        *,
+        spaces: Spaces = Spaces(None, None),
+    ):
+        """
+        Parameters
+        ----------
+        vector_field
+            Array with `Di + 1` dimensions, where `Di` is the input dimensionality.
+        index_transform
+            Transformation from source coordinate to array indices.
+        interpolation_order
+            Order of the spline interpolation used for coordinates which are not integer array indices.
+        vector_axis
+            Which axis of the `vector_field` contains the vector values; defaults to the last (`-1`).
+        spaces
+            References for source and target spaces
+
+        Raises
+        ------
+        ValueError
+            If the index transform and vector field would change the coordinates' dimensionality,
+            or the index transform's dimensionality does not match the vector field's.
+        """
+        super().__init__(
+            vector_field,
+            index_transform,
+            interpolation_order,
+            vector_axis,
+            spaces=spaces,
+        )
+        if self.ndims.source != self.ndims.target:
+            raise ValueError("Displacements cannot change dimensionality")
+
+    def apply(self, coords: ArrayT) -> ArrayT:
+        coords = self._validate_coords(coords)
+        vecs = self._get_vectors(coords)
+        return coords + vecs  # type:ignore

{transformnd-0.3.0 → transformnd-0.4.1}/src/transformnd/util.py

@@ -1,12 +1,22 @@
 """Utilities used elsewhere in the package."""
 
-from array_api_compat import array_namespace
-from numpy.typing import ArrayLike
+import os
+from types import ModuleType
+import warnings
+import logging
+
+from array_api_compat import (
+    array_namespace,
+    is_dask_namespace,
+    is_jax_namespace,
+)
 import numpy as np
 
 from .types import SpaceRef, ArrayT
 from .constants import UNSPECIFIED_SPACE_NAME
 
+logger = logging.getLogger(__name__)
+
 
 def none_eq[T](a: T | None, b: T | None) -> bool:
     """Check whether either is None or both are equal.
@@ -161,9 +171,56 @@ def to_single_ndim(ndim: None | int = None, ndims: None | set[int] = None) -> in
     raise ValueError(f"dimensionality conflict: {ndim} not in {ndims}")
 
 
-def as_floats(arr: ArrayLike):
-    """Get array-like as a numpy array, casting to float if integral."""
-    arr = np.asarray(arr)
-    if not np.issubdtype(arr.dtype, np.floating):
-        arr = arr.astype(np.float64)
-    return arr
+def as_floats(arr, *, namespace: ModuleType | None = None, device: str | None = None):
+    """Get array-like as an array of floats.
+
+    Convert to a particular array namespace if given;
+    default to keeping the same namespace one exists,
+    or numpy otherwise.
+
+    Cast to a float if integral.
+    """
+    try:
+        orig_namespace = array_namespace(arr)
+    except TypeError:
+        orig_namespace = None
+
+    if namespace is None:
+        namespace = orig_namespace or np
+
+    kwargs = dict()
+    if is_dask_namespace(namespace):
+        if isinstance(device, str) and device != "cpu":
+            logger.warning(f"Ignoring unsupported dask device: {device}")
+    elif device is not None:
+        kwargs["device"] = device
+
+    arr = namespace.asarray(arr, **kwargs)  # type: ignore
+
+    # dask does not have isdtype
+    isdtype = getattr(namespace, "isdtype", np.isdtype)
+
+    if not isdtype(arr.dtype, "real floating"):  # type:ignore
+        if is_jax_namespace(namespace):
+            dt = "float32"
+        else:
+            dt = "float64"
+        # N.B. a dask array wrapping over jax arrays will warn here
+        arr = arr.astype(dt, **kwargs)  # type:ignore
+
+    return arr  # type:ignore
+
+
+def set_scipy_array_api() -> bool:
+    curr = os.environ.get("SCIPY_ARRAY_API")
+    match curr:
+        case None:
+            os.environ["SCIPY_ARRAY_API"] = "1"
+            return True
+        case "1":
+            return True
+        case _:
+            warnings.warn(
+                "SCIPY_ARRAY_API environment set but not '1'; certain transforms may not work with certain array types"
+            )
+            return False

transformnd-0.3.0/src/transformnd/adapters/shapely.py

@@ -1,130 +0,0 @@
-import numpy as np
-from typing import Callable
-from shapely.geometry import (
-    LinearRing,
-    LineString,
-    MultiLineString,
-    MultiPoint,
-    MultiPolygon,
-    Point,
-    Polygon,
-    GeometryCollection,
-)
-from shapely.geometry.base import BaseGeometry, BaseMultipartGeometry
-from shapely.coords import CoordinateSequence
-
-from ..base import Transform, ArrayT
-from .base import BaseAdapter
-
-
-def as_numpy(coords: CoordinateSequence) -> np.ndarray:
-    return np.asarray(coords)
-
-
-class GeometryAdapter(BaseAdapter[BaseGeometry, ArrayT]):
-    """Transform shapely geometries.
-
-    As well as the generic `apply()`,
-    there are `apply_*()` methods for transforming different geometry subclasses.
-
-    N.B. some transforms may create invalid topologies
-    (incorrect winding, self-intersections etc.)
-    """
-
-    def __init__(
-        self,
-        array_fn: Callable[[CoordinateSequence], ArrayT] = as_numpy,  # type:ignore
-    ) -> None:
-        self.array_fn = array_fn
-
-    def apply_point(self, transform: Transform, point: Point) -> Point:
-        return Point(*transform.apply(self.array_fn(point.coords))[0])
-
-    def apply_linestring(
-        self, transform: Transform, linestring: LineString
-    ) -> LineString:
-        return LineString(transform.apply(self.array_fn(linestring.coords)))
-
-    def apply_linear_ring(
-        self, transform: Transform, linear_ring: LinearRing
-    ) -> LinearRing:
-        return LinearRing(transform.apply(self.array_fn(linear_ring.coords)))
-
-    def apply_polygon(self, transform: Transform, polygon: Polygon) -> Polygon:
-        return Polygon(
-            self.apply_linear_ring(transform, polygon.exterior),
-            [self.apply_linear_ring(transform, i) for i in polygon.interiors],
-        )
-
-    def apply_multipoint(self, transform: Transform, obj: MultiPoint) -> MultiPoint:
-        return MultiPoint([self.apply_point(transform, o) for o in obj.geoms])
-
-    def apply_multilinestring(
-        self, transform: Transform, obj: MultiLineString
-    ) -> MultiLineString:
-        return MultiLineString([self.apply_linestring(transform, o) for o in obj.geoms])
-
-    def apply_multipolygon(
-        self, transform: Transform, obj: MultiPolygon
-    ) -> MultiPolygon:
-        return MultiPolygon([self.apply_polygon(transform, o) for o in obj.geoms])
-
-    def apply_multipart(
-        self, transform: Transform, obj: BaseMultipartGeometry
-    ) -> BaseMultipartGeometry:
-        """Apply the transform to any shapely multipart geometry."""
-        if isinstance(obj, MultiPoint):
-            return self.apply_multipoint(transform, obj)
-        elif isinstance(obj, MultiLineString):
-            return self.apply_multilinestring(transform, obj)
-        elif isinstance(obj, MultiPolygon):
-            return self.apply_multipolygon(transform, obj)
-        elif isinstance(obj, GeometryCollection):
-            return self.apply_collection(transform, obj)
-        else:
-            raise ValueError(f"Unknown multipart geometry type {type(obj)}")
-
-    def apply_collection(
-        self, transform: Transform, obj: GeometryCollection
-    ) -> GeometryCollection:
-        return GeometryCollection([self.apply(transform, o) for o in obj.geoms])
-
-    def apply(
-        self,
-        transform: Transform,
-        obj: BaseGeometry,
-    ) -> BaseGeometry:
-        """Transform the shapely geometry.
-
-        See the other `apply_*` methods if you already know what type of geometry
-        you're working with; this may be a bit faster.
-
-        Parameters
-        ----------
-        transform
-            The transformation to apply.
-        obj
-            Some shapely geometry in 2 or 3D
-
-        Returns
-        -------
-        BaseGeometry
-            An object of the same type as the input.
-
-        Raises
-        ------
-        ValueError
-            If the geometry type is not supported.
-        """
-        if isinstance(obj, BaseMultipartGeometry):
-            return self.apply_multipart(transform, obj)
-        elif isinstance(obj, Point):
-            return self.apply_point(transform, obj)
-        elif isinstance(obj, LineString):
-            return self.apply_linestring(transform, obj)
-        elif isinstance(obj, LinearRing):
-            return self.apply_linear_ring(transform, obj)
-        elif isinstance(obj, Polygon):
-            return self.apply_polygon(transform, obj)
-        else:
-            raise ValueError(f"Unknown geometry type {type(obj)}")