transformnd 0.5.0__tar.gz → 0.7.0__tar.gz

{transformnd-0.5.0 → transformnd-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transformnd
-Version: 0.5.0
+Version: 0.7.0
 Summary: ND coordinate transformations
 Author: Chris Barnes
 Author-email: Chris Barnes <chris.barnes@gerbi-gmb.de>
@@ -99,10 +99,10 @@ All transforms are accessed under the `transformnd.transforms` subpackage.
 | `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 |
+| `MovingLeastSquares` | `movingleastsquares` | Landmark-based transformation. |
+| `ThinPlateSplines` | `thinplatesplines` | Landmark-based transformation. |
+| `Coordinates` | `vectorfield` for in-memory, `vectorfield-dask` for chunked | Look up output coordinates in a vector field indexed by the input coordinates |
+| `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`.
@@ -110,13 +110,12 @@ A graph of transforms between defined spaces can be traversed using the `Transfo
 ## 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`)
+- Geometries from `shapely` (`transformnd.adapters.shapely.ShapelyAdapter`)
 - Objects composed of transformable attributes (`transformnd.adapters.AttrAdapter`).
 
 ## Additional transforms and adapters

{transformnd-0.5.0 → transformnd-0.7.0}/README.md

@@ -44,10 +44,10 @@ All transforms are accessed under the `transformnd.transforms` subpackage.
 | `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 |
+| `MovingLeastSquares` | `movingleastsquares` | Landmark-based transformation. |
+| `ThinPlateSplines` | `thinplatesplines` | Landmark-based transformation. |
+| `Coordinates` | `vectorfield` for in-memory, `vectorfield-dask` for chunked | Look up output coordinates in a vector field indexed by the input coordinates |
+| `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`.
@@ -55,13 +55,12 @@ A graph of transforms between defined spaces can be traversed using the `Transfo
 ## 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`)
+- Geometries from `shapely` (`transformnd.adapters.shapely.ShapelyAdapter`)
 - Objects composed of transformable attributes (`transformnd.adapters.AttrAdapter`).
 
 ## Additional transforms and adapters

{transformnd-0.5.0 → transformnd-0.7.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "transformnd"
-version = "0.5.0"
+version = "0.7.0"
 description = "ND coordinate transformations"
 readme = "README.md"
 authors = [{ name = "Chris Barnes", email = "chris.barnes@gerbi-gmb.de" }]

{transformnd-0.5.0 → transformnd-0.7.0}/src/transformnd/adapters/__init__.py

@@ -12,7 +12,6 @@ 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 (
@@ -23,6 +22,9 @@ from .base import (
     ReshapeAdapter,
     SimpleAdapter,
 )
+from .pandas import PandasAdapter
+from .polars import PolarsAdapter
+from .shapely import ShapelyAdapter
 
 __all__ = [
     "BaseAdapter",
@@ -31,4 +33,7 @@ __all__ = [
     "FnAdapter",
     "AttrAdapter",
     "ReshapeAdapter",
+    "PandasAdapter",
+    "PolarsAdapter",
+    "ShapelyAdapter",
 ]

{transformnd-0.5.0 → transformnd-0.7.0}/src/transformnd/adapters/pandas.py

@@ -1,15 +1,18 @@
 """Adapt pandas DataFrames for transformation."""
 
 from collections.abc import Hashable
+from typing import TYPE_CHECKING
 
-import pandas as pd
 import numpy as np
 
 from ..base import Transform
 from .base import BaseAdapter
 
+if TYPE_CHECKING:
+    import pandas as pd
 
-class PandasAdapter(BaseAdapter[pd.DataFrame, np.ndarray]):
+
+class PandasAdapter(BaseAdapter["pd.DataFrame", np.ndarray]):
     def __init__(self, columns: list[Hashable]):
         """Adapt transformation for coordinates stored in a pandas DataFrame.
 
@@ -21,8 +24,8 @@ class PandasAdapter(BaseAdapter[pd.DataFrame, np.ndarray]):
         self.columns = columns
 
     def apply(
-        self, transform: Transform, df: pd.DataFrame, in_place: bool = False
-    ) -> pd.DataFrame:
+        self, transform: Transform, df: "pd.DataFrame", in_place: bool = False
+    ) -> "pd.DataFrame":
         """Transform the dataframe, optionally in-place.
 
         Parameters

{transformnd-0.5.0 → transformnd-0.7.0}/src/transformnd/adapters/polars.py

@@ -1,13 +1,16 @@
 """Adapt polars DataFrames for transformation."""
 
-import polars as pl
+from typing import TYPE_CHECKING
 import numpy as np
 
 from ..base import Transform
 from .base import BaseAdapter
 
+if TYPE_CHECKING:
+    import polars as pl
 
-class PolarsAdapter(BaseAdapter[pl.DataFrame, np.ndarray]):
+
+class PolarsAdapter(BaseAdapter["pl.DataFrame", np.ndarray]):
     def __init__(self, columns: list[str]):
         """Adapt transformation for coordinates stored in a polars DataFrame.
 
@@ -19,8 +22,8 @@ class PolarsAdapter(BaseAdapter[pl.DataFrame, np.ndarray]):
         self.columns = columns
 
     def apply(
-        self, transform: Transform, df: pl.DataFrame, in_place: bool = False
-    ) -> pl.DataFrame:
+        self, transform: Transform, df: "pl.DataFrame", in_place: bool = False
+    ) -> "pl.DataFrame":
         """Transform the dataframe, optionally in-place.
 
         Parameters

{transformnd-0.5.0 → transformnd-0.7.0}/src/transformnd/adapters/shapely.py

@@ -1,21 +1,24 @@
 import logging
+from typing import TYPE_CHECKING
 
 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
 
+if TYPE_CHECKING:
+    from shapely.geometry.base import BaseGeometry
+    from shapely.coords import CoordinateSequence
+
+
 logger = logging.getLogger(__name__)
 
 
-def as_numpy(coords: CoordinateSequence) -> np.ndarray:
+def as_numpy(coords: "CoordinateSequence") -> np.ndarray:
     return np.asarray(coords)
 
 
-class GeometryAdapter(BaseAdapter[BaseGeometry, ArrayT]):
+class ShapelyAdapter(BaseAdapter["BaseGeometry", ArrayT]):
     """Transform shapely geometries.
 
     As well as the generic `apply()`,
@@ -27,7 +30,7 @@ class GeometryAdapter(BaseAdapter[BaseGeometry, ArrayT]):
     N.B. shapely geometries' coordinates are in `XY(Z)` order
     """
 
-    def apply[T: BaseGeometry](
+    def apply[T: "BaseGeometry"](
         self,
         transform: Transform,
         obj: T,
@@ -51,6 +54,7 @@ class GeometryAdapter(BaseAdapter[BaseGeometry, ArrayT]):
         T
             An object of the same type as the input.
         """
+        import shapely
 
         def fn(coords: np.ndarray) -> np.ndarray:
             c = coords.copy()

transformnd-0.7.0/src/transformnd/transforms/__init__.py

@@ -0,0 +1,31 @@
+"""Implementations of some common transforms."""
+
+from .affine import Affine
+from .reflection import Reflect
+from .simple import Identity, Scale, Translate
+from .map_axis import MapAxis
+from .bijection import Bijection
+from .project_axis import ProjectAxis, Insert, Remove
+from .by_dimension import ByDimension, SubTransform
+from .vector_field import Coordinates, Displacements
+from .moving_least_squares import MovingLeastSquares
+from .thinplate import ThinPlateSplines
+
+__all__ = [
+    "Affine",
+    "Identity",
+    "ProjectAxis",
+    "Insert",
+    "Remove",
+    "Reflect",
+    "Scale",
+    "Translate",
+    "MapAxis",
+    "Bijection",
+    "ByDimension",
+    "SubTransform",
+    "Coordinates",
+    "Displacements",
+    "MovingLeastSquares",
+    "ThinPlateSplines",
+]

{transformnd-0.5.0 → transformnd-0.7.0}/src/transformnd/transforms/affine.py

@@ -42,7 +42,7 @@ class Affine(Transform[ArrayT]):
         ----------
         matrix
             Affine transformation matrix,
-            i.e. a 2D array-like with shape `(Di + 1, Do + 1)`,
+            i.e. a 2D array-like with shape `(Do + 1, Di + 1)`,
             where the bottom row is all 0s except in the rightmost column, which is 1.
         spaces
             Optional source and target spaces
@@ -64,7 +64,7 @@ class Affine(Transform[ArrayT]):
                 f"Transformation matrix is not affine (expected bottom row {expected}, got {bottom_row})."
             )
 
-        super().__init__(NDims(m.shape[0] - 1, m.shape[1] - 1), spaces=spaces)
+        super().__init__(NDims(m.shape[1] - 1, m.shape[0] - 1), spaces=spaces)
 
         self.matrix: np.ndarray = m
 

{transformnd-0.5.0 → transformnd-0.7.0}/src/transformnd/transforms/by_dimension.py

@@ -8,7 +8,10 @@ from ..types import NDims, Spaces
 
 
 class SubTransform[ArrayT]:
-    """Transformation to apply to subsets of the input dimensions and which output dimensions they calculate."""
+    """Component of the `ByDimension` transformation.
+
+    Transformation to apply to subsets of the input dimensions and which output dimensions they calculate.
+    """
 
     def __init__(
         self,
@@ -16,6 +19,24 @@ class SubTransform[ArrayT]:
         input_axes: list[int],
         output_axes: list[int] | None = None,
     ):
+        """
+        Parameters
+        ----------
+        transform
+            Transformation to apply to the subset of axes.
+        input_axes
+            Which axes to apply the transformation to, in order.
+            The length must match the input dimensionality of `transform`.
+        output_axes
+            Which axes to apply the transformation to, in order.
+            The length must match the input dimensionality of `transform`.
+            If None, re-use the input axes.
+
+        Raises
+        ------
+        ValueError
+            `transform`'s dimensionality does not match the input/output axes.
+        """
 
         self.input_axes = input_axes
         if output_axes is None:

{transformnd-0.5.0 → transformnd-0.7.0}/src/transformnd/transforms/moving_least_squares.py

@@ -7,7 +7,6 @@ Requires the `movingleastsquares` extra.
 from array_api_compat import array_namespace
 import numpy as np
 from typing import Self
-from molesq.transform import Transformer as _Transformer
 
 from ..base import Transform
 from ..types import NDims, Spaces
@@ -18,6 +17,8 @@ class MovingLeastSquares(Transform[np.ndarray]):
     """Moving least squares transformation.
 
     Deform based on a matched pairs of source and target control points; see <https://dl.acm.org/doi/10.1145/1141911.1141920>
+
+    REQUIRES: `movingleastsquares` extra.
     """
 
     def __init__(
@@ -39,9 +40,11 @@ class MovingLeastSquares(Transform[np.ndarray]):
         spaces
             Optional source and target spaces
         """
+        from molesq.transform import Transformer
+
         s = as_floats(source_control_points)
         t = as_floats(target_control_points)
-        self._transformer = _Transformer(s, t)
+        self._transformer = Transformer(s, t)
         super().__init__(
             NDims(
                 s.shape[1],

transformnd-0.7.0/src/transformnd/transforms/project_axis.py

@@ -0,0 +1,173 @@
+from __future__ import annotations
+from abc import ABC, abstractmethod
+from copy import copy
+from typing import Self, Sequence
+
+import numpy as np
+from array_api_compat import array_namespace
+from transformnd.transforms import Affine
+from transformnd.types import NDims, Spaces
+from dataclasses import dataclass
+from ..base import Transform
+from ..types import ArrayT
+
+
+@dataclass(frozen=True, eq=True)
+class BaseOperation(ABC):
+    idx: int
+    """Which axis to apply the operation to."""
+
+    def __post_init__(self):
+        if self.idx < 0:
+            raise ValueError("insert/remove idx must be positive")
+
+    @abstractmethod
+    def check(self, ndim: int) -> int: ...
+
+    @abstractmethod
+    def invert(self) -> BaseOperation: ...
+
+
+@dataclass(frozen=True, eq=True)
+class Insert(BaseOperation):
+    """Component of the `ProjectAxis` transform which inserts a new axis."""
+
+    def check(self, ndim: int) -> int:
+        if self.idx > ndim or self.idx <= -ndim:
+            raise ValueError(
+                f"Index {self.idx} is out of range for dimensionality {ndim}"
+            )
+        return ndim + 1
+
+    def invert(self) -> Remove:
+        return Remove(self.idx)
+
+
+@dataclass(frozen=True, eq=True)
+class Remove(BaseOperation):
+    """Component of the `ProjectAxis` transform which removes an existing axis."""
+
+    def check(self, ndim: int) -> int:
+        if self.idx >= ndim or self.idx <= -ndim:
+            raise ValueError(
+                f"Index {self.idx} is out of range for dimensionality {ndim}"
+            )
+        return ndim - 1
+
+    def invert(self) -> Insert:
+        if self.idx == -1:
+            raise ValueError("Removal of the -1th axis is not invertible")
+        return Insert(self.idx)
+
+
+Operation = Insert | Remove
+"""Insert or remove an axis."""
+
+
+class ProjectAxis(Transform):
+    """Transform for adding and removing axes.
+
+    WARNING: inverting this transformation may be lossy.
+    """
+
+    def __init__(
+        self,
+        operations: Sequence[Operation],
+        source_ndim: int | None = None,
+        target_ndim: int | None = None,
+        *,
+        spaces: Spaces = Spaces(None, None),
+    ):
+        """Create a transform for adding and dropping axes.
+
+        At least one of source_ndim and target_ndim must be given.
+
+        Parameters
+        ----------
+        operations
+            Sequence of operations to apply.
+        source_ndim
+            If omitted, can be inferred from `target_ndim`.
+        target_ndim
+            If omitted, can be inferred from `source_ndim`.
+        spaces
+            Identifiers for source and target spaces, by default Spaces(None, None)
+
+        Raises
+        ------
+        ValueError
+            Operations are inconsistent with given dimensionality,
+            or insufficient dimensionality information was given.
+        """
+        self.operations = []
+        self._has_inserts = False
+
+        if source_ndim is not None:
+            nd = source_ndim
+            for op in operations:
+                nd = op.check(nd)
+            if target_ndim is None:
+                target_ndim = nd
+            elif target_ndim != nd:
+                raise ValueError("Operations do not match expected target ndim")
+
+        elif target_ndim is not None:
+            nd = target_ndim
+            for op in reversed(operations):
+                nd = op.invert().check(nd)
+            if source_ndim is None:
+                source_ndim = nd
+            elif source_ndim != nd:
+                raise ValueError("Operations do not match expected source ndim")
+
+        else:
+            raise ValueError("At least one of source_ndim or target_ndim must be given")
+
+        idxs: list[int | None] = list(range(source_ndim))
+        for op in operations:
+            if isinstance(op, Insert):
+                self._has_inserts = True
+                idxs.insert(op.idx, None)
+            elif isinstance(op, Remove):
+                idxs.pop(op.idx)
+            self.operations.append(op)
+        self._idxs = idxs
+
+        super().__init__(NDims(source_ndim, target_ndim), spaces=spaces)
+
+    def apply(self, coords: ArrayT) -> ArrayT:
+        coords = self._validate_coords(coords)
+        if self._has_inserts:
+            xp = array_namespace(coords)
+            out = xp.zeros_like(coords, shape=(xp.shape(coords)[0], self.ndims.target))
+            for idx, orig_idx in enumerate(self._idxs):
+                if orig_idx is not None:
+                    out[:, idx] = coords[:, orig_idx]  # type:ignore
+
+        else:
+            out = coords[:, self._idxs]  # type:ignore
+        return out
+
+    def is_identity(self) -> bool:
+        orig: list[int | None] = list(range(self.ndims.source))
+        dims = copy(orig)
+        for op in self.operations:
+            if isinstance(op, Insert):
+                dims.insert(op.idx, None)
+            elif isinstance(op, Remove):
+                dims.pop(op.idx)
+
+        return dims == orig
+
+    def to_affine(self) -> Affine | None:
+        m = np.eye(self.ndims.source)
+        out_m = self.apply(m)
+        return Affine.from_linear_map(out_m.T)
+
+    def invert(self) -> Self | None:
+        return type(self)(
+            [op.invert() for op in reversed(self.operations)],
+            source_ndim=self.ndims.target,
+            target_ndim=self.ndims.source,
+            spaces=self.spaces.invert(),
+        )

{transformnd-0.5.0 → transformnd-0.7.0}/src/transformnd/transforms/thinplate.py

@@ -6,7 +6,6 @@ Requires the `thinplatesplines` extra.
 
 import logging
 
-import morphops as mops
 import numpy as np
 
 from ..base import Transform
@@ -20,6 +19,8 @@ class ThinPlateSplines(Transform[np.ndarray]):
     """Thin plate splines transforms.
 
     Deform based on matched pairs of control points.
+
+    REQUIRES: `thinplatesplines` extra.
     """
 
     def __init__(
@@ -48,6 +49,8 @@ class ThinPlateSplines(Transform[np.ndarray]):
         ValueError
             Invalid control points.
         """
+        import morphops
+
         self.source_control_points = as_floats(source_control_points)
         self.target_control_points = as_floats(target_control_points)
 
@@ -59,7 +62,7 @@ class ThinPlateSplines(Transform[np.ndarray]):
 
         ndim = self.source_control_points.shape[1]
 
-        self.W, self.A = mops.tps_coefs(
+        self.W, self.A = morphops.tps_coefs(
             self.source_control_points,
             self.target_control_points,
         )
@@ -73,8 +76,10 @@ class ThinPlateSplines(Transform[np.ndarray]):
         )
 
     def apply(self, coords: np.ndarray) -> np.ndarray:
+        import morphops
+
         coords = self._validate_coords(coords)
-        U = mops.K_matrix(coords, self.source_control_points)
-        P = mops.P_matrix(coords)
+        U = morphops.K_matrix(coords, self.source_control_points)
+        P = morphops.P_matrix(coords)
         # The warped pts are the affine part + the non-uniform part
         return P @ self.A + U @ self.W

{transformnd-0.5.0 → transformnd-0.7.0}/src/transformnd/transforms/vector_field.py

@@ -10,8 +10,6 @@ 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"]
 
 
@@ -95,6 +93,8 @@ class BaseVectorField(Transform[ArrayT], ABC):
 
         set_scipy_array_api()
         xp = array_namespace(index_coords_t)
+
+        # make columnar output array so that each dimension can be written contiguously
         out = xp.zeros_like(
             self.vector_field, shape=(self.ndims.target, xp.shape(index_coords_t)[1])
         )
@@ -133,6 +133,9 @@ class Coordinates(BaseVectorField[ArrayT]):
     the output coordinate is `vector_field[a, b, c, :].
 
     Input coordinates outside the vector field return NaN.
+
+    REQUIRES: `vectorfield` extra for in-memory,
+    or `vectorfield-dask` extra for lazy chunked vector fields.
     """
 
     def __init__(
@@ -182,6 +185,9 @@ class Displacements(BaseVectorField[ArrayT]):
     the output coordinate is `(a, b, c) + vector_field[a, b, c, :].
 
     Input coordinates outside the vector field return NaN.
+
+    REQUIRES: `vectorfield` extra for in-memory,
+    or `vectorfield-dask` extra for lazy chunked vector fields.
     """
 
     def __init__(

transformnd-0.5.0/src/transformnd/transforms/__init__.py

@@ -1,19 +0,0 @@
-"""Implementations of some common transforms."""
-
-from .affine import Affine
-from .reflection import Reflect
-from .simple import Identity, Scale, Translate
-from .map_axis import MapAxis
-from .bijection import Bijection
-from .by_dimension import ByDimension
-
-__all__ = [
-    "Affine",
-    "Identity",
-    "Reflect",
-    "Scale",
-    "Translate",
-    "MapAxis",
-    "Bijection",
-    "ByDimension",
-]