sty: pacify flake8

Author: oesteban

nitransforms/base.py

@@ -177,7 +177,10 @@ def __ne__(self, other):
 class TransformBase:
     """Abstract image class to represent transforms."""
 
-    __slots__ = ("_reference", "_ndim",)
+    __slots__ = (
+        "_reference",
+        "_ndim",
+    )
 
     def __init__(self, reference=None):
         """Instantiate a transform."""
@@ -283,6 +286,7 @@ def _as_homogeneous(xyz, dtype="float32", dim=3):
 
     return np.hstack((xyz, np.ones((xyz.shape[0], 1), dtype=dtype)))
 
+
 def _apply_affine(x, affine, dim):
     """Get the image array's indexes corresponding to coordinates."""
     return np.tensordot(

nitransforms/linear.py

@@ -10,16 +10,12 @@
 import warnings
 import numpy as np
 from pathlib import Path
-from scipy import ndimage as ndi
 
-from nibabel.loadsave import load as _nbload
 from nibabel.affines import from_matvec
-from nibabel.arrayproxy import get_obj_dtype
 
 from nitransforms.base import (
     ImageGrid,
     TransformBase,
-    SpatialReference,
     _as_homogeneous,
     EQUALITY_TOL,
 )
@@ -112,7 +108,7 @@ def __invert__(self):
 
         """
         return self.__class__(self._inverse)
-    
+
     def __len__(self):
         """Enable using len()."""
         return 1 if self._matrix.ndim == 2 else len(self._matrix)

nitransforms/nonlinear.py

@@ -14,12 +14,10 @@
 from nitransforms import io
 from nitransforms.io.base import _ensure_image
 from nitransforms.interp.bspline import grid_bspline_weights, _cubic_bspline
-from nitransforms.resampling import apply
 from nitransforms.base import (
     TransformBase,
     TransformError,
     ImageGrid,
-    SpatialReference,
     _as_homogeneous,
 )
 from scipy.ndimage import map_coordinates
@@ -77,14 +75,12 @@ def __init__(self, field=None, is_deltas=True, reference=None):
             is_deltas = True
 
         try:
-            self.reference = ImageGrid(
-                reference if reference is not None else field
-            )
+            self.reference = ImageGrid(reference if reference is not None else field)
         except AttributeError:
             raise TransformError(
                 "Field must be a spatial image if reference is not provided"
-                if reference is None else
-                "Reference is not a spatial image"
+                if reference is None
+                else "Reference is not a spatial image"
             )
 
         if self._field.shape[-1] != self.ndim:
@@ -175,16 +171,19 @@ def map(self, x, inverse=False):
             indexes = tuple(tuple(i) for i in indexes)
             return self._field[indexes]
 
-        return np.vstack(tuple(
-            map_coordinates(
-                self._field[..., i],
-                ijk.T,
-                order=3,
-                mode="constant",
-                cval=0,
-                prefilter=True,
-            ) for i in range(self.reference.ndim)
-        )).T
+        return np.vstack(
+            tuple(
+                map_coordinates(
+                    self._field[..., i],
+                    ijk.T,
+                    order=3,
+                    mode="constant",
+                    cval=0,
+                    prefilter=True,
+                )
+                for i in range(self.reference.ndim)
+            )
+        ).T
 
     def __matmul__(self, b):
         """
@@ -206,9 +205,9 @@ def __matmul__(self, b):
         True
 
         """
-        retval = b.map(
-            self._field.reshape((-1, self._field.shape[-1]))
-        ).reshape(self._field.shape)
+        retval = b.map(self._field.reshape((-1, self._field.shape[-1]))).reshape(
+            self._field.shape
+        )
         return DenseFieldTransform(retval, is_deltas=False, reference=self.reference)
 
     def __eq__(self, other):
@@ -247,12 +246,12 @@ def from_filename(cls, filename, fmt="X5"):
 class BSplineFieldTransform(TransformBase):
     """Represent a nonlinear transform parameterized by BSpline basis."""
 
-    __slots__ = ['_coeffs', '_knots', '_weights', '_order', '_moving']
+    __slots__ = ["_coeffs", "_knots", "_weights", "_order", "_moving"]
 
     @property
     def ndim(self):
         """Access the dimensions of this BSpline."""
-        #return ndim = self._coeffs.shape[-1]
+        # return ndim = self._coeffs.shape[-1]
         return self._coeffs.ndim - 1
 
     def __init__(self, coefficients, reference=None, order=3):
@@ -270,8 +269,9 @@ def __init__(self, coefficients, reference=None, order=3):
 
             if coefficients.shape[-1] != self.reference.ndim:
                 raise TransformError(
-                    'Number of components of the coefficients does '
-                    'not match the number of dimensions')
+                    "Number of components of the coefficients does "
+                    "not match the number of dimensions"
+                )
 
     @property
     def ndim(self):
@@ -281,8 +281,7 @@ def ndim(self):
     def to_field(self, reference=None, dtype="float32"):
         """Generate a displacements deformation field from this B-Spline field."""
         _ref = (
-            self.reference if reference is None else
-            ImageGrid(_ensure_image(reference))
+            self.reference if reference is None else ImageGrid(_ensure_image(reference))
         )
         if _ref is None:
             raise TransformError("A reference must be defined")
@@ -350,9 +349,9 @@ def _map_xyz(x, reference, knots, coeffs):
     # Probably this will change if the order of the B-Spline is different
     w_start, w_end = np.ceil(ijk - 2).astype(int), np.floor(ijk + 2).astype(int)
     # Generate a grid of indexes corresponding to the window
-    nonzero_knots = tuple([
-        np.arange(start, end + 1) for start, end in zip(w_start, w_end)
-    ])
+    nonzero_knots = tuple(
+        [np.arange(start, end + 1) for start, end in zip(w_start, w_end)]
+    )
     nonzero_knots = tuple(np.meshgrid(*nonzero_knots, indexing="ij"))
     window = np.array(nonzero_knots).reshape((ndim, -1))
 

nitransforms/resampling.py

@@ -77,7 +77,9 @@ def apply(
         reference = _nbload(str(reference))
 
     _ref = (
-        transform.reference if reference is None else SpatialReference.factory(reference)
+        transform.reference
+        if reference is None
+        else SpatialReference.factory(reference)
     )
 
     if _ref is None:
@@ -89,20 +91,25 @@ def apply(
     data = np.asanyarray(spatialimage.dataobj)
 
     if data.ndim == 4 and data.shape[-1] != len(transform):
-        raise ValueError("The fourth dimension of the data does not match the tranform's shape.")
+        raise ValueError(
+            "The fourth dimension of the data does not match the tranform's shape."
+        )
 
     if data.ndim < transform.ndim:
         data = data[..., np.newaxis]
-    
-    if hasattr(transform, 'to_field') and callable(transform.to_field):
+
+    if hasattr(transform, "to_field") and callable(transform.to_field):
         targets = ImageGrid(spatialimage).index(
-            _as_homogeneous(transform.to_field(reference=reference).map(_ref.ndcoords.T), dim=_ref.ndim)
+            _as_homogeneous(
+                transform.to_field(reference=reference).map(_ref.ndcoords.T),
+                dim=_ref.ndim,
+            )
         )
     else:
         targets = ImageGrid(spatialimage).index(  # data should be an image
             _as_homogeneous(transform.map(_ref.ndcoords.T), dim=_ref.ndim)
         )
- 
+
     if transform.ndim == 4:
         targets = _as_homogeneous(targets.reshape(-2, targets.shape[0])).T
 
@@ -115,14 +122,14 @@ def apply(
         cval=cval,
         prefilter=prefilter,
     )
-     
+
     if isinstance(_ref, ImageGrid):  # If reference is grid, reshape
         hdr = None
         if _ref.header is not None:
             hdr = _ref.header.copy()
             hdr.set_data_dtype(output_dtype or spatialimage.get_data_dtype())
         moved = spatialimage.__class__(
-            resampled.reshape(_ref.shape if data.ndim < 4 else _ref.shape + (-1, )),
+            resampled.reshape(_ref.shape if data.ndim < 4 else _ref.shape + (-1,)),
             _ref.affine,
             hdr,
         )

nitransforms/tests/test_base.py

@@ -4,7 +4,12 @@
 import pytest
 import h5py
 
-from ..base import SpatialReference, SampledSpatialData, ImageGrid, TransformBase, _as_homogeneous
+from ..base import (
+    SpatialReference,
+    SampledSpatialData,
+    ImageGrid,
+    TransformBase,
+)
 from .. import linear as nitl
 from ..resampling import apply
 
@@ -104,15 +109,11 @@ def _to_hdf5(klass, x5_root):
     xfm = nitl.Affine()
     xfm.reference = fname
     moved = apply(xfm, fname, order=0)
-    assert np.all(
-        imgdata == np.asanyarray(moved.dataobj, dtype=moved.get_data_dtype())
-    )
+    assert np.all(imgdata == np.asanyarray(moved.dataobj, dtype=moved.get_data_dtype()))
 
     # Test ndim returned by affine
     assert nitl.Affine().ndim == 3
-    assert nitl.LinearTransformsMapping(
-        [nitl.Affine(), nitl.Affine()]
-    ).ndim == 4
+    assert nitl.LinearTransformsMapping([nitl.Affine(), nitl.Affine()]).ndim == 4
 
     # Test applying to Gifti
     gii = nb.gifti.GiftiImage(
@@ -127,7 +128,7 @@ def _to_hdf5(klass, x5_root):
     assert np.allclose(giimoved.reshape(xfm.reference.shape), moved.get_fdata())
 
     # Test to_filename
-    xfm.to_filename("data.xfm", fmt='itk')
+    xfm.to_filename("data.xfm", fmt="itk")
 
 
 def test_SampledSpatialData(testdata_path):

nitransforms/tests/test_nonlinear.py

@@ -29,7 +29,7 @@
 3dNwarpApply -nwarp {transform} -source {moving} \
 -master {reference} -interp NN -prefix {output} {extra}\
 """.format,
-    'fsl': """\
+    "fsl": """\
 applywarp -i {moving} -r {reference} -o {output} {extra}\
 -w {transform} --interp=nn""".format,
 }
@@ -39,7 +39,9 @@
 def test_itk_disp_load(size):
     """Checks field sizes."""
     with pytest.raises(TransformFileError):
-        ITKDisplacementsField.from_image(nb.Nifti1Image(np.zeros(size), np.eye(4), None))
+        ITKDisplacementsField.from_image(
+            nb.Nifti1Image(np.zeros(size), np.eye(4), None)
+        )
 
 
 @pytest.mark.parametrize("size", [(20, 20, 20), (20, 20, 20, 2, 3), (20, 20, 20, 1, 4)])
@@ -98,15 +100,16 @@ def test_bsplines_references(testdata_path):
 
     with pytest.raises(TransformError):
         apply(
-            BSplineFieldTransform(testdata_path / "someones_bspline_coefficients.nii.gz"),
+            BSplineFieldTransform(
+                testdata_path / "someones_bspline_coefficients.nii.gz"
+            ),
             testdata_path / "someones_anatomy.nii.gz",
         )
 
     apply(
-        BSplineFieldTransform(
-        testdata_path / "someones_bspline_coefficients.nii.gz"),
+        BSplineFieldTransform(testdata_path / "someones_bspline_coefficients.nii.gz"),
         testdata_path / "someones_anatomy.nii.gz",
-        reference=testdata_path / "someones_anatomy.nii.gz"
+        reference=testdata_path / "someones_anatomy.nii.gz",
     )
 
 
@@ -170,7 +173,7 @@ def test_displacements_field1(
     nt_moved_mask.set_data_dtype(msk.get_data_dtype())
     diff = np.asanyarray(sw_moved_mask.dataobj) - np.asanyarray(nt_moved_mask.dataobj)
 
-    assert np.sqrt((diff ** 2).mean()) < RMSE_TOL
+    assert np.sqrt((diff**2).mean()) < RMSE_TOL
     brainmask = np.asanyarray(nt_moved_mask.dataobj, dtype=bool)
 
     # Then apply the transform and cross-check with software
@@ -179,7 +182,7 @@ def test_displacements_field1(
         reference=tmp_path / "reference.nii.gz",
         moving=tmp_path / "reference.nii.gz",
         output=tmp_path / "resampled.nii.gz",
-        extra="--output-data-type uchar" if sw_tool == "itk" else ""
+        extra="--output-data-type uchar" if sw_tool == "itk" else "",
     )
 
     exit_code = check_call([cmd], shell=True)
@@ -190,10 +193,9 @@ def test_displacements_field1(
     nt_moved.set_data_dtype(nii.get_data_dtype())
     nt_moved.to_filename("nt_resampled.nii.gz")
     sw_moved.set_data_dtype(nt_moved.get_data_dtype())
-    diff = (
-        np.asanyarray(sw_moved.dataobj, dtype=sw_moved.get_data_dtype())
-        - np.asanyarray(nt_moved.dataobj, dtype=nt_moved.get_data_dtype())
-    )
+    diff = np.asanyarray(
+        sw_moved.dataobj, dtype=sw_moved.get_data_dtype()
+    ) - np.asanyarray(nt_moved.dataobj, dtype=nt_moved.get_data_dtype())
     # A certain tolerance is necessary because of resampling at borders
     assert np.sqrt((diff[brainmask] ** 2).mean()) < RMSE_TOL
 
@@ -230,12 +232,11 @@ def test_displacements_field2(tmp_path, testdata_path, sw_tool):
     nt_moved = xfm.apply(img_fname, order=0)
     nt_moved.to_filename("nt_resampled.nii.gz")
     sw_moved.set_data_dtype(nt_moved.get_data_dtype())
-    diff = (
-        np.asanyarray(sw_moved.dataobj, dtype=sw_moved.get_data_dtype())
-        - np.asanyarray(nt_moved.dataobj, dtype=nt_moved.get_data_dtype())
-    )
+    diff = np.asanyarray(
+        sw_moved.dataobj, dtype=sw_moved.get_data_dtype()
+    ) - np.asanyarray(nt_moved.dataobj, dtype=nt_moved.get_data_dtype())
     # A certain tolerance is necessary because of resampling at borders
-    assert np.sqrt((diff ** 2).mean()) < RMSE_TOL
+    assert np.sqrt((diff**2).mean()) < RMSE_TOL
 
 
 def test_bspline(tmp_path, testdata_path):
@@ -249,12 +250,16 @@ def test_bspline(tmp_path, testdata_path):
     bsplxfm = BSplineFieldTransform(bs_name, reference=img_name)
     dispxfm = DenseFieldTransform(disp_name)
 
-    out_disp = apply(dispxfm,img_name)
-    out_bspl = apply(bsplxfm,img_name)
+    out_disp = apply(dispxfm, img_name)
+    out_bspl = apply(bsplxfm, img_name)
 
     out_disp.to_filename("resampled_field.nii.gz")
     out_bspl.to_filename("resampled_bsplines.nii.gz")
 
-    assert np.sqrt(
-        (out_disp.get_fdata(dtype="float32") - out_bspl.get_fdata(dtype="float32")) ** 2
-    ).mean() < 0.2
+    assert (
+        np.sqrt(
+            (out_disp.get_fdata(dtype="float32") - out_bspl.get_fdata(dtype="float32"))
+            ** 2
+        ).mean()
+        < 0.2
+    )