transformnd 0.1.0__tar.gz

transformnd-0.1.0/PKG-INFO

@@ -0,0 +1,133 @@
+Metadata-Version: 2.4
+Name: transformnd
+Version: 0.1.0
+Summary: ND coordinate transformations
+Author: Chris Barnes
+Author-email: Chris Barnes <chris.barnes@gerbi-gmb.de>
+License-Expression: MIT
+Requires-Dist: numpy>=2
+Requires-Dist: networkx>=3
+Requires-Dist: array-api-compat>=1.14
+Requires-Dist: typing-extensions>=4.15.0
+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-Python: >=3.12, <4.0
+Provides-Extra: movingleastsquares
+Provides-Extra: pandas
+Provides-Extra: polars
+Provides-Extra: shapely
+Provides-Extra: thinplatesplines
+Description-Content-Type: text/markdown
+
+# transformnd
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![GitHub](https://img.shields.io/github/license/clbarnes/transformnd)](https://github.com/clbarnes/transformnd/blob/main/LICENSE)
+[![Test Status](https://img.shields.io/github/workflow/status/clbarnes/transformnd/ci)](https://github.com/clbarnes/transformnd/actions/workflows/ci.yaml)
+[![Docs Status](https://img.shields.io/github/workflow/status/clbarnes/transformnd/docs?label=docs)](https://clbarnes.github.io/transformnd/)
+
+A library providing an API for coordinate transformations,
+as well as some common transforms.
+The goal is to allow downstream applications which require such transformations
+(e.g. image registration) to be generic over anything inheriting from `transformnd.Transform`.
+
+The base classes and utilities are very lightweight with few dependencies, for use as an API; additional transforms and features use extras.
+
+Heavily inspired by/ cribbed directly from
+[Philipp Schlegel's work in navis](https://github.com/schlegelp/navis/tree/master/navis/transforms);
+co-developed with [xform](https://github.com/schlegelp/xform/) as a red team prototype.
+
+`N` coordinates in `D` dimensions are given as a numpy array of shape `(N, D)`.
+
+`Transform` subclasses which are restricted to certain dimensionalities
+can specify this in their `ndim` class variable.
+Instances of `Transform` subclasses can further restrict their `ndim`.
+Use `self._validate_coords(coords)` in `__call__` to ensure the coordinates
+are of valid type and dimensions.
+
+Additionally, `transformnd` provides an interface for transforming types other than NxD numpy arrays,
+and implements these adapters for a few common types.
+
+See the [tutorial here](https://github.com/clbarnes/transformnd/blob/main/examples/tutorial.py).
+It is a [marimo](https://marimo.io) notebook.
+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
+
+Arbitrary transforms can be composed into a `TransformSequence` with `transform1 | transform2`.
+A graph of transforms between defined spaces can be traversed using the `TransformGraph`.
+
+## Implemented adapters
+
+- Numpy arrays of shape `(..., D, ...)` (`transformnd.adapters.ReshapeAdapter`)
+- `meshio.Mesh` (`transformnd.adapters.meshio.MeshAdapter`)
+- `pandas.DataFrame` (`transformnd.adapters.pandas.PandasAdapter`)
+  - Takes a subset of columns as a coordinate array
+- `polars.DataFrame` (`transformnd.adapters.polars.PolarsAdapter`)
+  - Similar to the pandas adapter
+  - Currently, only scalar columns are supported (e.g. not a single struct column with fields `x`, `y`, `z`)
+- Geometries from `shapely` (`transformnd.adapters.shapely.GeometryAdapter`)
+- Objects composed of transformable attributes (`transformnd.adapters.AttrAdapter`).
+
+## Additional transforms and adapters
+
+Contributions of additional transforms and adapters are welcome!
+Even if they're only thin wrappers around an external library,
+the downstream ecosystem benefits from a consistent API.
+
+Such external transformation libraries should be specified as "extras",
+and be contained in a submodule so that they are not immediately imported
+with `transformnd`.
+Dependencies for new adapters do not need to be included in `transformnd`'s dependencies,
+but should be specified in the `requirements.txt` for tests.
+
+Alternatively, consider adopting `transformnd`'s base classes in your own library,
+and have your transformation instantly compatible for downstream users.
+
+Methods which MUST be implemented:
+
+- `__init__`: should validate parameters and set `self.ndim` if the parameters constrain the dimensionality
+- `apply`: should call `_validate_coords` method early to check that the given coordinates are the correct shape
+
+Methods which SHOULD be implemented if applicable:
+
+- `to_device`: if any of the transformation's parameters need to be placed on a specific device (e.g. affine matrices on the GPU)
+- `is_identity`: if you can cheaply check whether your transformation is an identity transformation. The base class implementation returns `False`.
+- `into_affine`: if your transformation can be represented as an affine matrix. The base class implementation returns `None`.
+- `invert`: if your transformation can be inverted (default None if not)
+  - This automatically implements `__invert__` (the `~my_transform` operator), which raises NotImplemented if `invert` would return `None`.
+
+## Contributing
+
+- Use [`uv`](https://docs.astral.sh/uv/) for environment and dependency management.
+  - `uv sync` to set up the environment.
+- Use [`prek`](https://prek.j178.dev/) for running pre-commit hooks.
+  - `prek install-hooks && prek run --all-files` to get started.
+- Use [`just`](https://github.com/casey/just) for common development tasks (format, lint, test, generate docs, run benchmarks).
+  - `just` to list commands.
+- Docs are generated with `pdoc` (use `just doc`) and hosted on ReadTheDocs
+
+## Thanks
+
+Thanks to contributors
+
+- [Francesca Drummer](https://github.com/FrancescaDr)
+- [Lorenzo Cerrone](https://github.com/lorenzocerrone)
+- [Maks Hess](https://github.com/MaksHess)
+- [Silvia Maria Macrì](https://github.com/SilviaMariaMacri)

transformnd-0.1.0/README.md

@@ -0,0 +1,109 @@
+# transformnd
+
+[![Code style: black](https://img.shields.io/badge/code%20style-black-000000.svg)](https://github.com/psf/black)
+[![GitHub](https://img.shields.io/github/license/clbarnes/transformnd)](https://github.com/clbarnes/transformnd/blob/main/LICENSE)
+[![Test Status](https://img.shields.io/github/workflow/status/clbarnes/transformnd/ci)](https://github.com/clbarnes/transformnd/actions/workflows/ci.yaml)
+[![Docs Status](https://img.shields.io/github/workflow/status/clbarnes/transformnd/docs?label=docs)](https://clbarnes.github.io/transformnd/)
+
+A library providing an API for coordinate transformations,
+as well as some common transforms.
+The goal is to allow downstream applications which require such transformations
+(e.g. image registration) to be generic over anything inheriting from `transformnd.Transform`.
+
+The base classes and utilities are very lightweight with few dependencies, for use as an API; additional transforms and features use extras.
+
+Heavily inspired by/ cribbed directly from
+[Philipp Schlegel's work in navis](https://github.com/schlegelp/navis/tree/master/navis/transforms);
+co-developed with [xform](https://github.com/schlegelp/xform/) as a red team prototype.
+
+`N` coordinates in `D` dimensions are given as a numpy array of shape `(N, D)`.
+
+`Transform` subclasses which are restricted to certain dimensionalities
+can specify this in their `ndim` class variable.
+Instances of `Transform` subclasses can further restrict their `ndim`.
+Use `self._validate_coords(coords)` in `__call__` to ensure the coordinates
+are of valid type and dimensions.
+
+Additionally, `transformnd` provides an interface for transforming types other than NxD numpy arrays,
+and implements these adapters for a few common types.
+
+See the [tutorial here](https://github.com/clbarnes/transformnd/blob/main/examples/tutorial.py).
+It is a [marimo](https://marimo.io) notebook.
+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
+
+Arbitrary transforms can be composed into a `TransformSequence` with `transform1 | transform2`.
+A graph of transforms between defined spaces can be traversed using the `TransformGraph`.
+
+## Implemented adapters
+
+- Numpy arrays of shape `(..., D, ...)` (`transformnd.adapters.ReshapeAdapter`)
+- `meshio.Mesh` (`transformnd.adapters.meshio.MeshAdapter`)
+- `pandas.DataFrame` (`transformnd.adapters.pandas.PandasAdapter`)
+  - Takes a subset of columns as a coordinate array
+- `polars.DataFrame` (`transformnd.adapters.polars.PolarsAdapter`)
+  - Similar to the pandas adapter
+  - Currently, only scalar columns are supported (e.g. not a single struct column with fields `x`, `y`, `z`)
+- Geometries from `shapely` (`transformnd.adapters.shapely.GeometryAdapter`)
+- Objects composed of transformable attributes (`transformnd.adapters.AttrAdapter`).
+
+## Additional transforms and adapters
+
+Contributions of additional transforms and adapters are welcome!
+Even if they're only thin wrappers around an external library,
+the downstream ecosystem benefits from a consistent API.
+
+Such external transformation libraries should be specified as "extras",
+and be contained in a submodule so that they are not immediately imported
+with `transformnd`.
+Dependencies for new adapters do not need to be included in `transformnd`'s dependencies,
+but should be specified in the `requirements.txt` for tests.
+
+Alternatively, consider adopting `transformnd`'s base classes in your own library,
+and have your transformation instantly compatible for downstream users.
+
+Methods which MUST be implemented:
+
+- `__init__`: should validate parameters and set `self.ndim` if the parameters constrain the dimensionality
+- `apply`: should call `_validate_coords` method early to check that the given coordinates are the correct shape
+
+Methods which SHOULD be implemented if applicable:
+
+- `to_device`: if any of the transformation's parameters need to be placed on a specific device (e.g. affine matrices on the GPU)
+- `is_identity`: if you can cheaply check whether your transformation is an identity transformation. The base class implementation returns `False`.
+- `into_affine`: if your transformation can be represented as an affine matrix. The base class implementation returns `None`.
+- `invert`: if your transformation can be inverted (default None if not)
+  - This automatically implements `__invert__` (the `~my_transform` operator), which raises NotImplemented if `invert` would return `None`.
+
+## Contributing
+
+- Use [`uv`](https://docs.astral.sh/uv/) for environment and dependency management.
+  - `uv sync` to set up the environment.
+- Use [`prek`](https://prek.j178.dev/) for running pre-commit hooks.
+  - `prek install-hooks && prek run --all-files` to get started.
+- Use [`just`](https://github.com/casey/just) for common development tasks (format, lint, test, generate docs, run benchmarks).
+  - `just` to list commands.
+- Docs are generated with `pdoc` (use `just doc`) and hosted on ReadTheDocs
+
+## Thanks
+
+Thanks to contributors
+
+- [Francesca Drummer](https://github.com/FrancescaDr)
+- [Lorenzo Cerrone](https://github.com/lorenzocerrone)
+- [Maks Hess](https://github.com/MaksHess)
+- [Silvia Maria Macrì](https://github.com/SilviaMariaMacri)

transformnd-0.1.0/pyproject.toml

@@ -0,0 +1,64 @@
+[project]
+name = "transformnd"
+version = "0.1.0"
+description = "ND coordinate transformations"
+readme = "README.md"
+authors = [{ name = "Chris Barnes", email = "chris.barnes@gerbi-gmb.de" }]
+requires-python = ">=3.12, <4.0"
+dependencies = [
+    "numpy>=2",
+    "networkx>=3",
+    "array_api_compat>=1.14",
+    "typing-extensions>=4.15.0",
+]
+license = "MIT"
+
+[project.optional-dependencies]
+thinplatesplines = [
+    "morphops>=0.1.13",
+]
+movingleastsquares = ["molesq>=0.4.0"]
+pandas = ["pandas>=3.0.2"]
+shapely = ["shapely>=2.1.2"]
+polars = [
+    "polars>=1.40.1",
+]
+
+[dependency-groups]
+dev = [
+    {include-group = "test"},
+    {include-group = "lint"},
+    {include-group = "doc"},
+    {include-group = "tutorial"},
+    {include-group = "bench"},
+]
+test = ["pytest", "jax"]
+lint = [
+    "ruff",
+    "mypy",
+    "prek>=0.3.9",
+    "types-shapely>=2.1.0.20260408",
+]
+doc = [
+    "pdoc>=16.0.0",
+]
+tutorial = [
+    "marimo>=0.9",
+    "matplotlib>=3.10.8",
+    "pandas>=3.0.2",
+]
+bench = [
+    "pytest-benchmark>=5.2.3",
+]
+
+[build-system]
+requires = ["uv_build>=0.11.0,<0.12.0"]
+build-backend = "uv_build"
+
+[tool.mypy]
+ignore_missing_imports = true
+check_untyped_defs = true
+
+[tool.pytest]
+testpaths = ["tests", "bench"]
+addopts = ["--benchmark-skip"]

transformnd-0.1.0/src/transformnd/__init__.py

@@ -0,0 +1,24 @@
+"""
+.. include:: ../../README.md
+"""
+
+from .base import Transform, TransformSequence, TransformWrapper
+from .util import SpaceRef, TransformSignature, check_ndim
+from . import transforms
+from . import adapters
+from .graph import TransformGraph
+from importlib.metadata import version as _version
+
+__version__ = _version("transformnd")
+
+__all__ = [
+    "Transform",
+    "TransformGraph",
+    "TransformSequence",
+    "TransformWrapper",
+    "TransformSignature",
+    "SpaceRef",
+    "check_ndim",
+    "transforms",
+    "adapters",
+]

transformnd-0.1.0/src/transformnd/adapters/__init__.py

@@ -0,0 +1,34 @@
+"""Adapters for transforming objects which are not well-behaved numpy arrays.
+
+Adapter instances are callables which take the transform to be applied,
+the object to apply it to, and optionally some other arguments.
+The adapter knows how to get coordinates out of the object,
+and then create a new object with those transformed coordinates.
+
+Classes which compose over transformable objects can be adapted with the
+`AttrAdapter` class.
+See the `SimpleAdapter` or `FnAdapter` for wrapping simple adapting functions.
+Implement your own adapter by inheriting from `BaseAdapter`.
+
+See `.pandas.DataFrameAdapter` for an example of creating an adapter
+for an external type.
+
+"""
+
+from .base import (
+    AttrAdapter,
+    BaseAdapter,
+    FnAdapter,
+    NullAdapter,
+    ReshapeAdapter,
+    SimpleAdapter,
+)
+
+__all__ = [
+    "BaseAdapter",
+    "SimpleAdapter",
+    "NullAdapter",
+    "FnAdapter",
+    "AttrAdapter",
+    "ReshapeAdapter",
+]

transformnd-0.1.0/src/transformnd/adapters/base.py

@@ -0,0 +1,167 @@
+"""Simple adapter cases."""
+
+from abc import ABC, abstractmethod
+from copy import deepcopy
+from functools import partial
+from collections.abc import Callable
+from typing import TypeVar, Any
+
+from array_api_compat import array_namespace
+
+from ..base import Transform, ArrayT
+
+ObjectT = TypeVar("ObjectT")
+
+
+class BaseAdapter[ObjectT, ArrayT](ABC):
+    @abstractmethod
+    def apply(self, transform: Transform[ArrayT], obj: ObjectT) -> ObjectT:
+        """Apply the given transformation to a non-array object.
+
+        Parameters
+        ----------
+        transform : Transform
+        obj : T
+
+        Returns
+        -------
+        T
+        """
+        pass
+
+    def partial(self, *args, **kwargs) -> Callable[..., ObjectT]:
+        """Create a partial function with frozen arguments.
+
+        Useful for applying the same transform to many objects,
+        or many transforms to the same object,
+        or for adapters with additional arguments,
+        using the same config repeatedly.
+
+        Returns
+        -------
+        Callable
+        """
+        return partial(self.apply, *args, **kwargs)
+
+
+class NullAdapter(BaseAdapter[ArrayT, ArrayT]):
+    """Adapter which simply applies the transform."""
+
+    def apply(self, transform: Transform[ArrayT], obj: ArrayT) -> ArrayT:
+        return transform.apply(obj)
+
+
+class FnAdapter(BaseAdapter[ObjectT, ArrayT]):
+    def __init__(self, fn: Callable[[Transform[ArrayT], ObjectT], ObjectT]):
+        """Adapter which simply wraps a function, for typing purposes.
+
+        Parameters
+        ----------
+        fn : Callable[[Transform, T], T]
+            Function which takes the object,
+            and applies the transformation to it.
+        """
+        self.fn = fn
+
+    def apply(self, transform: Transform[ArrayT], obj: ObjectT) -> ObjectT:
+        return self.fn(transform, obj)
+
+
+class AttrAdapter(BaseAdapter[ObjectT, ArrayT]):
+    def __init__(self, **kwargs: BaseAdapter[Any, ArrayT] | None) -> None:
+        """Adapter which transforms an object by applying transforms to its attributes.
+
+        Parameters
+        ----------
+        adapters : Dict[str, Optional[BaseAdapter]]
+            Keys are attribute names, values are adapters with which
+            to apply the transform to those attributes.
+            `None` is shorthand for `NullAdapter()`;
+            i.e. the attribute is an array and can be transformed
+            without being adapted.
+        """
+        self.adapters = {
+            k: NullAdapter[ArrayT]() if v is None else v for k, v in kwargs.items()
+        }
+
+    def apply(
+        self, transform: Transform[ArrayT], obj: ObjectT, in_place: bool = False
+    ) -> ObjectT:
+        """Apply the given transformation to the object, via its attributes.
+
+        Parameters
+        ----------
+        transform : Transform
+        obj : T
+        in_place : bool, optional
+            Whether to mutate the given object in place,
+            by default False (i.e. make a deep copy of it).
+
+        Returns
+        -------
+        T
+        """
+        if not in_place:
+            obj = deepcopy(obj)
+
+        for k, v in self.adapters.items():
+            member = getattr(obj, k)
+            try:
+                transformed = v.apply(transform, member, in_place=True)  # type: ignore
+            except TypeError as e:
+                if "got an unexpected keyword argument 'in_place'" in str(e):
+                    transformed = v.apply(transform, member)
+                else:
+                    raise e
+            setattr(obj, k, transformed)
+
+        return obj
+
+
+class SimpleAdapter(BaseAdapter[ObjectT, ArrayT], ABC):
+    """
+    Helper class for cases with simple conversion methods.
+    """
+
+    @abstractmethod
+    def _to_array(self, obj: ObjectT) -> ArrayT:
+        """Convert the object into an array of coordinates."""
+        pass
+
+    @abstractmethod
+    def _from_array(self, coords: ArrayT) -> ObjectT:
+        """Convert an array of coordinates into the correct type."""
+        pass
+
+    def apply(self, transform: Transform[ArrayT], obj: ObjectT) -> ObjectT:
+        coords: ArrayT = self._to_array(obj)
+        transformed = transform.apply(coords)
+        return self._from_array(transformed)
+
+
+class ReshapeAdapter(BaseAdapter[ArrayT, ArrayT]):
+    """Adapter which reshapes a numpy.ndarray"""
+
+    def __init__(self, dim_axis: int = -1) -> None:
+        """Adapt numpy arrays which are not of the correct shape.
+
+        Parameters
+        ----------
+        dim_axis : int, optional
+            Which axis contains the coordinates' dimensions,
+            by default -1 (last)
+        """
+        self.dim_axis: int = dim_axis
+
+    def apply(self, transform: Transform[ArrayT], obj: ArrayT) -> ArrayT:
+        xp = array_namespace(obj)
+        dim_axis = self.dim_axis
+        if self.dim_axis < 0:
+            dim_axis += xp.ndim(obj)
+
+        moved = xp.moveaxis(obj, dim_axis, -1)
+        m_shape = moved.shape
+
+        flattened = xp.reshape(moved, (-1, m_shape[-1]))
+        transformed = transform.apply(flattened)
+        return xp.moveaxis(xp.reshape(transformed, m_shape), -1, dim_axis)

transformnd-0.1.0/src/transformnd/adapters/bounding_box.py

@@ -0,0 +1,16 @@
+from array_api_compat import array_namespace
+from transformnd.base import Transform
+from .base import BaseAdapter
+from ..extents.bounding_box import BoundingBox
+from ..base import ArrayT
+
+
+class BoundingBoxAdapter(BaseAdapter[BoundingBox[ArrayT], ArrayT]):
+    def apply(
+        self, transform: Transform[ArrayT], obj: BoundingBox[ArrayT]
+    ) -> BoundingBox[ArrayT]:
+        xp = array_namespace(obj.mins)
+        stacked = xp.stack([obj.mins, obj.maxes])
+        transformed = transform.apply(stacked)
+        mins, maxes = xp.unstack(transformed)
+        return BoundingBox(mins, maxes)

transformnd-0.1.0/src/transformnd/adapters/pandas.py

@@ -0,0 +1,46 @@
+"""Adapt pandas DataFrames for transformation."""
+
+from collections.abc import Hashable
+
+import pandas as pd
+import numpy as np
+
+from ..base import Transform
+from .base import BaseAdapter
+
+
+class PandasAdapter(BaseAdapter[pd.DataFrame, np.ndarray]):
+    def __init__(self, columns: list[Hashable]):
+        """Adapt transformation for coordinates stored in a pandas DataFrame.
+
+        Parameters
+        ----------
+        columns : list of keys
+            Keys for columns containing coordinates, e.g. `["x", "y", "z"]`
+        """
+        self.columns = columns
+
+    def apply(
+        self, transform: Transform, df: pd.DataFrame, in_place: bool = False
+    ) -> pd.DataFrame:
+        """Transform the dataframe, optionally in-place.
+
+        Parameters
+        ----------
+        transform : Transform
+        df : pd.DataFrame
+
+        in_place : bool, optional
+            Whether to mutate the dataframe in place,
+            by default False (i.e. make a copy of it).
+
+        Returns
+        -------
+        pandas.DataFrame
+        """
+        coords = df[self.columns].to_numpy()
+        transformed = transform.apply(coords)
+        if not in_place:
+            df = df.copy()
+        df[self.columns] = transformed
+        return df

transformnd-0.1.0/src/transformnd/adapters/polars.py

@@ -0,0 +1,44 @@
+"""Adapt polars DataFrames for transformation."""
+
+import polars as pl
+import numpy as np
+
+from ..base import Transform
+from .base import BaseAdapter
+
+
+class PolarsAdapter(BaseAdapter[pl.DataFrame, np.ndarray]):
+    def __init__(self, columns: list[str]):
+        """Adapt transformation for coordinates stored in a polars DataFrame.
+
+        Parameters
+        ----------
+        columns : list of keys
+            Keys for columns containing coordinates, e.g. `["x", "y", "z"]`
+        """
+        self.columns = columns
+
+    def apply(
+        self, transform: Transform, df: pl.DataFrame, in_place: bool = False
+    ) -> pl.DataFrame:
+        """Transform the dataframe, optionally in-place.
+
+        Parameters
+        ----------
+        transform : Transform
+        df : pl.DataFrame
+
+        in_place : bool, optional
+            Whether to mutate the dataframe in place,
+            by default False (i.e. make a copy of it).
+
+        Returns
+        -------
+        pandas.DataFrame
+        """
+        coords = df[self.columns].to_numpy()
+        transformed = transform.apply(coords)
+        if not in_place:
+            df = df.clone()
+        df[self.columns] = transformed
+        return df