transformnd 0.4.2__tar.gz → 0.6.0__tar.gz

{transformnd-0.4.2 → transformnd-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: transformnd
-Version: 0.4.2
+Version: 0.6.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.4.2 → transformnd-0.6.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.4.2 → transformnd-0.6.0}/pyproject.toml

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

{transformnd-0.4.2 → transformnd-0.6.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.4.2 → transformnd-0.6.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.4.2 → transformnd-0.6.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.4.2 → transformnd-0.6.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.4.2 → transformnd-0.6.0}/src/transformnd/base.py

@@ -370,6 +370,20 @@ class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
             spaces = [s for s in spaces if s is not None]
         return spaces
 
+    def split(self) -> Iterator[Transform[ArrayT]]:
+        """Split the sequence where an intermediate space is known."""
+        this_seq = []
+
+        for t in self.transforms:
+            if t.spaces.source is not None and t.spaces.target is not None:
+                yield t
+                continue
+
+            this_seq.append(t)
+            if t.spaces.target is not None:
+                yield type(self)(this_seq)
+                this_seq = []
+
     def __str__(self) -> str:
         cls_name = type(self).__name__
         spaces_str = "->".join(space_str(s) for s in self.list_spaces())
@@ -383,6 +397,21 @@ class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
     def is_identity(self) -> bool:
         return all(t.is_identity() for t in self)
 
+    def flatten(self, drop_inverse: bool = True) -> Self:
+        """Flatten nested sequences."""
+        from .transforms.bijection import Bijection
+
+        out: list[Transform[ArrayT]] = []
+
+        for t in self.transforms:
+            if drop_inverse and isinstance(t, Bijection):
+                t = t.forward
+            if isinstance(t, TransformSequence):
+                out.extend(t.flatten())
+            else:
+                out.append(t)
+        return TransformSequence(out, spaces=self.spaces)  # type:ignore
+
     def simplify(self, drop_inverse: bool = True):
         """Reduce the number of transformations in this sequence if possible.
 
@@ -396,14 +425,13 @@ class TransformSequence(Transform[ArrayT], Sequence[Transform[ArrayT]]):
         Does not check whether transforms invert each other,
         e.g. `Translation(1) | Translation(-1)`.
         """
-        from .transforms.bijection import Bijection
         from .transforms import Identity
 
         out: list[Transform[ArrayT]] = []
         affine = None
-        for t in self.transforms:
-            if drop_inverse and isinstance(t, Bijection):
-                t = t.forward
+        for t in self.flatten(drop_inverse):
+            if t.is_identity():
+                continue
 
             new_affine = t.to_affine()
 

{transformnd-0.4.2 → transformnd-0.6.0}/src/transformnd/graph.py

@@ -2,10 +2,11 @@
 
 from __future__ import annotations
 from functools import lru_cache
-from collections.abc import Iterable, Iterator
+from collections.abc import Callable, Iterator
 import logging
-from itertools import chain, pairwise
+from itertools import pairwise
 from types import ModuleType
+from typing import Any
 
 import networkx as nx
 
@@ -16,6 +17,9 @@ from .types import Spaces
 
 logger = logging.getLogger(__name__)
 
+TRANSFORM_KEY = "_transform"
+WeightFn = Callable[[SpaceRef, SpaceRef, dict[str, Any]], int]
+
 
 def split_sequence(seq: TransformSequence[ArrayT]) -> Iterator[Transform[ArrayT]]:
     """Split a TransformSequence into Transforms with spaces defined.
@@ -46,6 +50,15 @@ def split_sequence(seq: TransformSequence[ArrayT]) -> Iterator[Transform[ArrayT]
             this_seq = []
 
 
+def normalise_edge_weight_fn(w: str | WeightFn | None) -> WeightFn:
+    if w is None:
+        return lambda _s, _t, _d: 1
+    elif isinstance(w, str):
+        return lambda _s, _t, d: d.get(w, 1)
+    else:
+        return w
+
+
 class TransformGraph[ArrayT]:
     """Transform between any number of arbitrary spaces/ coordinate systems.
 
@@ -57,18 +70,14 @@ class TransformGraph[ArrayT]:
 
     def __init__(
         self,
-        transforms: Iterable[Transform[ArrayT]] | None = None,
-        and_inverse: bool = True,
     ):
         """Create an transform graph, optionally with some starting transforms.
 
         See the `TransformGraph.add_transforms` documentation for restrictions on the
         given transforms.
         """
-        self.graph = nx.DiGraph()
+        self.graph = nx.MultiDiGraph()
         self.space_ndims: dict[SpaceRef, int] = dict()
-        if transforms is not None:
-            self.add_transforms(transforms, and_inverse)
 
     def _update_spaces(
         self,
@@ -99,48 +108,22 @@ class TransformGraph[ArrayT]:
         transform: Transform[ArrayT],
         source: SpaceRef | None,
         target: SpaceRef | None,
-        and_inverse: bool,
+        edge_data: dict[str, Any] | None,
     ) -> list[tuple[SpaceRef, SpaceRef]]:
         """Clearing the get_sequence cache and splitting sequences and bijections should be handled outside this method."""
         out = []
 
         src, tgt = self._update_spaces(transform, source, target)
 
-        if self.graph.has_edge(src, tgt):
-            logger.warning(f"Replacing existing edge between {src} and {tgt}")
+        if edge_data is None:
+            edge_data = dict()
 
-        self.graph.add_edge(src, tgt, transform=transform)
-        out.append((src, tgt))
-        if and_inverse:
-            out.extend(self._add_inverse(transform, src, tgt))
-        return out
-
-    def _add_inverse(
-        self,
-        transform: Transform[ArrayT],
-        source: SpaceRef | None,
-        target: SpaceRef | None,
-    ) -> list[tuple[SpaceRef, SpaceRef]]:
-        src, tgt = self._update_spaces(transform, source, target)
-        out = []
+        if TRANSFORM_KEY in edge_data:
+            raise ValueError(f"Must not use the key '{TRANSFORM_KEY}' in edge_data")
 
-        if self.graph.has_edge(tgt, src):
-            logger.debug(
-                "Implicit reverse edge not added to graph as explicit edge already exists for %s->%s",
-                tgt,
-                src,
-            )
-        elif t := transform.invert():
-            if isinstance(t, Bijection):
-                t = t.forward
-            self.graph.add_edge(tgt, src, transform=t)
-            out.append((tgt, src))
-        else:
-            logger.debug(
-                "Reverse edge not added to graph for non-invertible %s->%s transform",
-                src,
-                tgt,
-            )
+        d = {TRANSFORM_KEY: transform, **edge_data}
+        self.graph.add_edge(src, tgt, **d)
+        out.append((src, tgt))
         return out
 
     def add_transform(
@@ -148,20 +131,21 @@ class TransformGraph[ArrayT]:
         transform: Transform[ArrayT],
         source: SpaceRef | None = None,
         target: SpaceRef | None = None,
-        and_inverse: bool = True,
+        *,
+        edge_data: dict[str, Any] | None = None,
     ) -> list[tuple[SpaceRef, SpaceRef]]:
-        """Add a transform to the graph, optionally with its inverse.
-
-        If the given transform is a `TransformSequence`,
-        it will be split down into subsequences where intermediate spaces are known.
+        """Add a transform to the graph.
 
         If the given transform is a `Bijection`,
-        its forward component will be added as an independent edges;
-        if `and_inverse=True`, the same will be done with the inverse component.
+        only the forward component will be added as an independent edges.
+
+        This method will NOT overwrite intermediate edges.
 
-        This method will overwrite existing edges.
-        Implicit inverses calculated from the given transform will not overwrite existing explicit edges,
-        except in the case of the `Bijection`.
+        N.B. Previously this method implicitly added inverse edges where possible.
+        Now these edges must be added explicitly by calling `add_transform(~transform)`.
+        Additionally, previously `TransformSequence`s would be split out into multiple edges
+        if any intermediate spaces were defined;
+        now these edges must be added explicitly with the `TransformSequence.split` method.
 
         Parameters
         ----------
@@ -171,8 +155,10 @@ class TransformGraph[ArrayT]:
             May be omitted if `transform` has its source space defined.
         target
             May be omitted if `transform` has its target space defined.
-        and_inverse
-            Try to add the reverse edge by inverting the transform if possible; default True
+        edge_data
+            Dict of string keys to arbitrary values to associate with an edge.
+            Used during path-finding.
+            Must not have the `"_transform"` key.
 
         Returns
         -------
@@ -180,111 +166,32 @@ class TransformGraph[ArrayT]:
             List of `(src, tgt)` edges added to the graph.
         """
         out: list[tuple[SpaceRef, SpaceRef]] = []
-        if isinstance(transform, TransformSequence):
-            # TODO: weighting of split-out sequences could be problematic
-            ts = split_sequence(transform)
-            out.extend(
-                chain.from_iterable(
-                    self.add_transform(t, None, None, and_inverse) for t in ts
-                )
-            )
-
-        elif isinstance(transform, Bijection):
+        if isinstance(transform, Bijection):
             out.extend(
                 self.add_transform(
                     transform.forward,
                     source,
                     target,
-                    False,
+                    edge_data=edge_data,
                 )
             )
-            if and_inverse:
-                out.extend(
-                    self.add_transform(
-                        transform.inverse,
-                        target,
-                        source,
-                        False,
-                    )
-                )
 
         else:
-            out.extend(self._add_transform(transform, source, target, and_inverse))
+            out.extend(self._add_transform(transform, source, target, edge_data))
 
         if out:
             self.get_sequence.cache_clear()
 
         return out
 
-    def add_transforms(
-        self,
-        transforms: Iterable[Transform[ArrayT]],
-        and_inverse: bool = True,
-    ) -> list[tuple[SpaceRef, SpaceRef]]:
-        """Bulk-add transformations to the graph.
-
-        Every given transform must have a source and target space defined;
-        these spaces are the nodes of the graph.
-
-        This method is preferred over `TransformGraph.add_transform`
-        when some reverse edges are explicitly defined
-        and you don't want them to be overridden by implicit reverse edges
-        when `and_inverse=True`.
-
-        `Bijection` s and `TransformSequence` s will be split out as documented in
-        `TransformGraph.add_transform`.
-
-        Note that a single `TransformSequence` is itself an `Iterable[Transform]`
-        and so could be used as the `transforms` argument.
-        However, a `TransformSequence` does not require that all of its members
-        have explicit source and target spaces,
-        where the `transforms` argument here does,
-        so not all `TransformSequence` s can be used directly as the argument
-        (wrap them in a list instead or use `TransformGraph.add_transform`).
-
-        Parameters
-        ----------
-        transforms
-            Transforms which must have a source and target space defined.
-        and_inverse
-            Invert the transformations and add them too.
-
-        Returns
-        -------
-        list[tuple[SpaceRef, SpaceRef]]
-            List of `(src, tgt)` edges added to the graph.
-        """
-        if isinstance(transforms, TransformSequence):
-            logger.warning(
-                "add_transforms() argument is a TransformSequence, "
-                "which allows undefined intermediate spaces, "
-                "in which case this method will fail. "
-                "Prefer the add_transform() argument for single logical transforms, "
-                "or wrap the given argument in a collection (e.g. a list)."
-            )
-
-        forwards = []
-        for t in transforms:
-            forwards.extend(self.add_transform(t, and_inverse=False))
-
-        if not and_inverse:
-            return forwards
-
-        out = list(forwards)
-
-        # add inverses in second stage to prevent implicit reverse transforms blocking explicit
-        for src, tgt in forwards:
-            t = self.graph.edges[src, tgt]["transform"]
-            out.extend(self._add_inverse(t, src, tgt))
-
-        return out
-
     @lru_cache()
     def get_sequence(
         self,
         source_space: SpaceRef,
         target_space: SpaceRef,
         full: bool = False,
+        *,
+        weight: None | str | WeightFn = None,
     ) -> TransformSequence[ArrayT]:
         """Get the shortest TransformSequence for transforming between two spaces.
 
@@ -297,25 +204,32 @@ class TransformGraph[ArrayT]:
         full
             By default, simplifies consecutive affines and drops bijections' inverse form.
             If `full` is True, keeps each transformation as-is.
+        weight
+            str key in the `edge_data` dict given when an edge was added,
+            or a function to determine a weight from the args `src_space, tgt_space, edge_data`,
+            or None (all weights are 1).
 
         Returns
         -------
         TransformSequence[ArrayT]
             The shortest transform sequence between the spaces.
         """
-        path = nx.shortest_path(self.graph, source_space, target_space)
-        if len(path) <= 1:
-            transforms = []
-        else:
-            transforms = [
-                self.graph.edges[src, tgt]["transform"] for src, tgt in pairwise(path)
-            ]
+        path = nx.shortest_path(self.graph, source_space, target_space, weight)  # type:ignore
+        transforms = []
+        wfn = normalise_edge_weight_fn(weight)
+
+        for src, tgt in pairwise(path):
+            edges = self.graph[src][tgt]
+            transforms.append(
+                min(edges.values(), key=lambda d: wfn(src, tgt, d))[TRANSFORM_KEY]
+            )
+
         seq = TransformSequence(
             transforms,
             spaces=Spaces(source_space, target_space),
         )
         if not full:
-            seq = seq.simplify(drop_inverse=False)
+            seq = seq.simplify(drop_inverse=True)
         return seq
 
     def transform(
@@ -323,6 +237,8 @@ class TransformGraph[ArrayT]:
         source_space: SpaceRef,
         target_space: SpaceRef,
         coords: ArrayT,
+        *,
+        weight: None | str | WeightFn = None,
     ) -> ArrayT:
         """Transform coordinates from one space to another,
         possibly via intermediates.
@@ -335,13 +251,18 @@ class TransformGraph[ArrayT]:
             The target coordinate space.
         coords
             The coordinates to transform.
+        weight
+            str key in the `edge_data` dict given when an edge was added,
+            or a function to determine a weight from the args `src_space, tgt_space, edge_data`,
+            or None (all weights are 1).
+
 
         Returns
         -------
         ArrayT
             The transformed coordinates.
         """
-        t = self.get_sequence(source_space, target_space)
+        t = self.get_sequence(source_space, target_space, weight=weight)
         return t.apply(coords)
 
     def __iter__(self) -> Iterator[Transform[ArrayT]]:
@@ -364,13 +285,13 @@ class TransformGraph[ArrayT]:
         >>> new_tgraph = TransformGraph([extra_transform, *old_tgraph])
 
         """
-        for _, _, t in self.graph.edges.data("transform"):
+        for _, _, t in self.graph.edges.data(TRANSFORM_KEY):
             yield t
 
     def to_device(
         self, xp: ModuleType, device: str | None = None
     ) -> TransformGraph[ArrayT]:
         result: TransformGraph[ArrayT] = TransformGraph()
-        for src, tgt, t in self.graph.edges.data("transform"):
+        for src, tgt, t in self.graph.edges.data(TRANSFORM_KEY):
             result.graph.add_edge(src, tgt, transform=t.to_device(xp, device))
         return result

transformnd-0.6.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.4.2 → transformnd-0.6.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.4.2 → transformnd-0.6.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.4.2 → transformnd-0.6.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.6.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.4.2 → transformnd-0.6.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.4.2 → transformnd-0.6.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.4.2/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",
-]