enh: manual revision

Author: oesteban

nitransforms/io/x5.py

@@ -61,9 +61,7 @@ def to_filename(fname: str, x5_list: List[X5Transform]):
             )
             if node.domain is not None:
                 dgrp = g.create_group("Domain")
-                dgrp.create_dataset(
-                    "Grid", data=np.uint8(1 if node.domain.grid else 0)
-                )
+                dgrp.create_dataset("Grid", data=np.uint8(1 if node.domain.grid else 0))
                 dgrp.create_dataset("Size", data=np.asarray(node.domain.size))
                 dgrp.create_dataset("Mapping", data=node.domain.mapping)
                 if node.domain.coordinates is not None:
@@ -77,4 +75,4 @@ def to_filename(fname: str, x5_list: List[X5Transform]):
                 g.create_dataset(
                     "AdditionalParameters", data=node.additional_parameters
                 )
-    return str(fname)
+    return fname

nitransforms/linear.py

@@ -7,12 +7,14 @@
 #
 ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Linear transforms."""
+
 import warnings
 import numpy as np
 from pathlib import Path
 
 from nibabel.affines import from_matvec
 
+from nitransforms import __version__
 from nitransforms.base import (
     ImageGrid,
     TransformBase,
@@ -80,6 +82,23 @@ def __init__(self, matrix=None, reference=None):
             self._matrix[3, :] = (0, 0, 0, 1)
             self._inverse = np.linalg.inv(self._matrix)
 
+    def __repr__(self):
+        """
+        Change representation to the internal matrix.
+
+        Example
+        -------
+        >>> Affine([
+        ...     [1, 0, 0, 4], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]
+        ... ])  # doctest: +NORMALIZE_WHITESPACE
+        array([[1, 0, 0, 4],
+               [0, 1, 0, 0],
+               [0, 0, 1, 0],
+               [0, 0, 0, 1]])
+
+        """
+        return repr(self.matrix)
+
     def __eq__(self, other):
         """
         Overload equals operator.
@@ -149,62 +168,6 @@ def ndim(self):
         """Access the internal representation of this affine."""
         return self._matrix.ndim + 1
 
-    def map(self, x, inverse=False):
-        r"""
-        Apply :math:`y = f(x)`.
-
-        Parameters
-        ----------
-        x : N x D numpy.ndarray
-            Input RAS+ coordinates (i.e., physical coordinates).
-        inverse : bool
-            If ``True``, apply the inverse transform :math:`x = f^{-1}(y)`.
-
-        Returns
-        -------
-        y : N x D numpy.ndarray
-            Transformed (mapped) RAS+ coordinates (i.e., physical coordinates).
-
-        Examples
-        --------
-        >>> xfm = Affine([[1, 0, 0, 1], [0, 1, 0, 2], [0, 0, 1, 3], [0, 0, 0, 1]])
-        >>> xfm.map((0,0,0))
-        array([[1., 2., 3.]])
-
-        >>> xfm.map((0,0,0), inverse=True)
-        array([[-1., -2., -3.]])
-
-        """
-        affine = self._matrix
-        coords = _as_homogeneous(x, dim=affine.shape[0] - 1).T
-        if inverse is True:
-            affine = self._inverse
-        return affine.dot(coords).T[..., :-1]
-
-    def _to_hdf5(self, x5_root):
-        """Serialize this object into the x5 file format."""
-        xform = x5_root.create_dataset("Transform", data=[self._matrix])
-        xform.attrs["Type"] = "affine"
-        x5_root.create_dataset("Inverse", data=[(~self).matrix])
-
-        if self._reference:
-            self.reference._to_hdf5(x5_root.create_group("Reference"))
-
-    def to_filename(self, filename, fmt="X5", moving=None):
-        """Store the transform in the requested output format."""
-        writer = get_linear_factory(fmt, is_array=False)
-
-        if fmt.lower() in ("itk", "ants", "elastix"):
-            writer.from_ras(self.matrix).to_filename(filename)
-        else:
-            # Rest of the formats peek into moving and reference image grids
-            writer.from_ras(
-                self.matrix,
-                reference=self.reference,
-                moving=ImageGrid(moving) if moving is not None else self.reference,
-            ).to_filename(filename)
-        return filename
-
     @classmethod
     def from_filename(cls, filename, fmt=None, reference=None, moving=None):
         """Create an affine from a transform file."""
@@ -260,40 +223,75 @@ def from_matvec(cls, mat=None, vec=None, reference=None):
         vec = vec if vec is not None else np.zeros((3,))
         return cls(from_matvec(mat, vector=vec), reference=reference)
 
-    def __repr__(self):
-        """
-        Change representation to the internal matrix.
+    def map(self, x, inverse=False):
+        r"""
+        Apply :math:`y = f(x)`.
 
-        Example
+        Parameters
+        ----------
+        x : N x D numpy.ndarray
+            Input RAS+ coordinates (i.e., physical coordinates).
+        inverse : bool
+            If ``True``, apply the inverse transform :math:`x = f^{-1}(y)`.
+
+        Returns
         -------
-        >>> Affine([
-        ...     [1, 0, 0, 4], [0, 1, 0, 0], [0, 0, 1, 0], [0, 0, 0, 1]
-        ... ])  # doctest: +NORMALIZE_WHITESPACE
-        array([[1, 0, 0, 4],
-               [0, 1, 0, 0],
-               [0, 0, 1, 0],
-               [0, 0, 0, 1]])
+        y : N x D numpy.ndarray
+            Transformed (mapped) RAS+ coordinates (i.e., physical coordinates).
+
+        Examples
+        --------
+        >>> xfm = Affine([[1, 0, 0, 1], [0, 1, 0, 2], [0, 0, 1, 3], [0, 0, 0, 1]])
+        >>> xfm.map((0,0,0))
+        array([[1., 2., 3.]])
+
+        >>> xfm.map((0,0,0), inverse=True)
+        array([[-1., -2., -3.]])
 
         """
-        return repr(self.matrix)
+        affine = self._matrix
+        coords = _as_homogeneous(x, dim=affine.shape[0] - 1).T
+        if inverse is True:
+            affine = self._inverse
+        return affine.dot(coords).T[..., :-1]
+
+    def to_filename(self, filename, fmt="X5", moving=None):
+        """Store the transform in the requested output format."""
+        writer = get_linear_factory(fmt, is_array=False)
+
+        if fmt.lower() in ("itk", "ants", "elastix"):
+            writer.from_ras(self.matrix).to_filename(filename)
+        else:
+            # Rest of the formats peek into moving and reference image grids
+            writer.from_ras(
+                self.matrix,
+                reference=self.reference,
+                moving=ImageGrid(moving) if moving is not None else self.reference,
+            ).to_filename(filename)
+        return filename
 
-    def to_x5(self):
+    def to_x5(self, store_inverse=False, metadata=None):
         """Return an :class:`~nitransforms.io.x5.X5Transform` representation."""
+        metadata = {"WrittenBy": f"NiTransforms {__version__}"} | (metadata or {})
+
         domain = None
-        if self._reference is not None:
+        if (reference := self.reference) is not None:
             domain = X5Domain(
                 grid=True,
-                size=self.reference.shape,
-                mapping=self.reference.affine,
+                size=getattr(reference or {}, "shape", (0, 0, 0)),
+                mapping=reference.affine,
             )
         kinds = tuple("space" for _ in range(self.ndim)) + ("vector",)
         return X5Transform(
             type="linear",
             subtype="affine",
+            representation="matrix",
+            metadata=metadata,
             transform=self.matrix,
             dimension_kinds=kinds,
             domain=domain,
-            inverse=(~self).matrix,
+            inverse=(~self).matrix if store_inverse else None,
+            array_length=len(self),
         )
 
 
@@ -350,26 +348,6 @@ def __getitem__(self, i):
         """Enable indexed access to the series of matrices."""
         return Affine(self.matrix[i, ...], reference=self._reference)
 
-    def to_x5(self):
-        """Return an :class:`~nitransforms.io.x5.X5Transform` object."""
-        domain = None
-        if self._reference is not None:
-            domain = X5Domain(
-                grid=True,
-                size=self.reference.shape,
-                mapping=self.reference.affine,
-            )
-        kinds = tuple("space" for _ in range(self.ndim - 1)) + ("vector",)
-        return X5Transform(
-            type="linear",
-            subtype="affine",
-            transform=self.matrix,
-            dimension_kinds=kinds,
-            domain=domain,
-            inverse=self._inverse,
-            array_length=len(self),
-        )
-
     def map(self, x, inverse=False):
         r"""
         Apply :math:`y = f(x)`.

nitransforms/tests/test_linear.py

@@ -4,7 +4,6 @@
 
 import pytest
 import numpy as np
-import h5py
 
 from pathlib import Path
 
@@ -246,15 +245,20 @@ def test_linear_save(tmpdir, data_path, get_testdata, image_orientation, sw_tool
     assert_affines_by_filename(xfm_fname1, xfm_fname2)
 
 
-def test_Affine_to_x5(tmpdir):
+@pytest.mark.parametrize("store_inverse", [True, False])
+def test_Affine_to_x5(tmpdir, store_inverse):
     """Test affine's operations."""
     tmpdir.chdir()
     aff = nitl.Affine()
-    node = aff.to_x5()
+    node = aff.to_x5(
+        metadata={"GeneratedBy": "FreeSurfer 8"}, store_inverse=store_inverse
+    )
     assert node.type == "linear"
+    assert node.subtype == "matrix"
     assert node.domain is None
     assert node.transform.shape == (4, 4)
     assert node.array_length == 1
+    assert (node.metadata or {}).get("GeneratedBy") == "FreeSurfer 8"
 
     img = nb.Nifti1Image(np.zeros((2, 2, 2), dtype="float32"), np.eye(4))
     img_path = Path(tmpdir) / "ref.nii.gz"