fix: formatting and undefined variables

Author: oesteban

nitransforms/io/__init__.py

@@ -1,6 +1,7 @@
 # emacs: -*- mode: python-mode; py-indent-offset: 4; indent-tabs-mode: nil -*-
 # vi: set ft=python sts=4 ts=4 sw=4 et:
 """Read and write transforms."""
+
 from nitransforms.io import afni, fsl, itk, lta, x5
 from nitransforms.io.base import TransformIOError, TransformFileError
 
@@ -22,7 +23,7 @@
     "fs": (lta, "FSLinearTransform"),
     "fsl": (fsl, "FSLLinearTransform"),
     "afni": (afni, "AFNILinearTransform"),
-    "x5": (x5, "X5Transform")
+    "x5": (x5, "X5LinearTransform"),
 }
 
 

nitransforms/io/base.py

@@ -1,137 +1,11 @@
 """Read/write linear transforms."""
 from pathlib import Path
 import numpy as np
-import nibabel as nb
 from nibabel import load as loadimg
 
-import h5py
-
 from ..patched import LabeledWrapStruct
 
 
-def get_xfm_filetype(xfm_file):
-    path = Path(xfm_file)
-    ext = path.suffix
-    if ext == '.gz' and path.name.endswith('.nii.gz'):
-        return 'nifti'
-    
-    file_types = {
-        '.nii': 'nifti',
-        '.h5': 'hdf5',
-        '.x5': 'x5',
-        '.txt': 'txt',
-        '.mat': 'txt'
-    }
-    return file_types.get(ext, 'unknown')
-
-def gather_fields(x5=None, hdf5=None, nifti=None, shape=None, affine=None, header=None):
-    xfm_fields = {
-        "x5": x5,
-        "hdf5": hdf5,
-        "nifti": nifti,
-        "header": header,
-        "shape": shape,
-        "affine": affine
-    }
-    return xfm_fields
-
-def load_nifti(nifti_file):
-    nifti_xfm = nb.load(nifti_file)
-    xfm_data = nifti_xfm.get_fdata()
-    shape = nifti_xfm.shape
-    affine = nifti_xfm.affine
-    header = getattr(nifti_xfm, "header", None)
-    return gather_fields(nifti=xfm_data, shape=shape, affine=affine, header=header)
-
-def load_hdf5(hdf5_file):
-    storage = {}
-
-    def get_hdf5_items(name, x5_root):
-        if isinstance(x5_root, h5py.Dataset):
-            storage[name] = {
-                'type': 'dataset',
-                'attrs': dict(x5_root.attrs),
-                'shape': x5_root.shape,
-                'data': x5_root[()]
-            } 
-        elif isinstance(x5_root, h5py.Group):
-            storage[name] = {
-                'type': 'group',
-                'attrs': dict(x5_root.attrs),
-                'members': {}
-            }
-
-    with h5py.File(hdf5_file, 'r') as f:
-        f.visititems(get_hdf5_items)
-    if storage:
-        hdf5_storage = {'hdf5': storage}
-    return hdf5_storage
-
-def load_x5(x5_file):
-    load_hdf5(x5_file)
-
-def load_mat(mat_file):
-    affine_matrix = np.loadtxt(mat_file)
-    affine = nb.affines.from_matvec(affine_matrix[:,:3], affine_matrix[:,3])
-    return gather_fields(affine=affine)
-
-def xfm_loader(xfm_file):
-    loaders = {
-        'nifti': load_nifti,
-        'hdf5': load_hdf5,
-        'x5': load_x5,
-        'txt': load_mat,
-        'mat': load_mat
-    }
-    xfm_filetype = get_xfm_filetype(xfm_file)
-    loader = loaders.get(xfm_filetype)
-    if loader is None:
-        raise ValueError(f"Unsupported file type: {xfm_filetype}")
-    return loader(xfm_file)
-
-def to_filename(self, filename, fmt="X5"):
-    """Store the transform in BIDS-Transforms HDF5 file format (.x5)."""
-    with h5py.File(filename, "w") as out_file:
-        out_file.attrs["Format"] = "X5"
-        out_file.attrs["Version"] = np.uint16(1)
-        root = out_file.create_group("/0")
-        self._to_hdf5(root)
-
-    return filename
-
-def _to_hdf5(self, x5_root):
-    """Serialize this object into the x5 file format."""
-    transform_group = x5_root.create_group("TransformGroup")
-
-    """Group '0' containing Affine transform"""
-    transform_0 = transform_group.create_group("0")
-    
-    transform_0.attrs["Type"] = "Affine"
-    transform_0.create_dataset("Transform", data=self._affine)
-    transform_0.create_dataset("Inverse", data=np.linalg.inv(self._affine))
-
-    metadata = {"key": "value"}
-    transform_0.attrs["Metadata"] = str(metadata)
-
-    """sub-group 'Domain' contained within group '0' """
-    domain_group = transform_0.create_group("Domain")
-    #domain_group.attrs["Grid"] = self._grid
-    #domain_group.create_dataset("Size", data=_as_homogeneous(self._reference.shape))
-    #domain_group.create_dataset("Mapping", data=self.mapping)
-    
-def _from_x5(self, x5_root):
-    variables = {}
-
-    x5_root.visititems(lambda name, x5_root: loader(name, x5_root, variables))
-
-    _transform = variables["TransformGroup/0/Transform"]
-    _inverse = variables["TransformGroup/0/Inverse"]
-    _size = variables["TransformGroup/0/Domain/Size"]
-    _mapping = variables["TransformGroup/0/Domain/Mapping"]
-
-    return _transform, _inverse, _size, _map
-    
-
 class TransformIOError(IOError):
     """General I/O exception while reading/writing transforms."""
 

nitransforms/io/x5.py

@@ -1,55 +1,39 @@
+# emacs: -*- mode: python-mode; py-indent-offset: 4; indent-tabs-mode: nil -*-
+# vi: set ft=python sts=4 ts=4 sw=4 et:
+### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
+#
+#   See COPYING file distributed along with the NiBabel package for the
+#   copyright and license terms.
+#
+### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ### ##
 """Read/write x5 transforms."""
-import warnings
+
 import numpy as np
-from scipy.io import loadmat as _read_mat, savemat as _save_mat
 from h5py import File as H5File
-from nibabel import Nifti1Header, Nifti1Image
-from nibabel.affines import from_matvec
-from nitransforms.io.base import (
-    BaseLinearTransformList,
-    DisplacementsField,
-    LinearParameters,
-    TransformIOError,
-    TransformFileError,
-)
-
-class X5Transform:
-    """A string-based structure for X5 linear transforms."""
-
-    _transform = None
-
-    def __init__(self, parameters=None, offset=None):
-        return
-
-    def __str__(self):
-        return
-
-    @classmethod
-    def from_filename(cls, filename):
-        """Read the struct from a X5 file given its path."""
-        if str(filename).endswith(".h5"):
-            with H5File(str(filename), 'r') as hdf:
-                return cls.from_h5obj(hdf)
-            
-    @classmethod
-    def from_h5obj(cls, h5obj):
-        """Read the transformations in an X5 file."""
-        xfm_list = list(h5obj.keys())
-
-        xfm = xfm_list["Transform"]
-        inv = xfm_list["Inverse"]
-        coords = xfm_list["Size"]
-        map = xfm_list["Mapping"]
-
-        return xfm, inv, coords, map
-
-
-class X5LinearTransformArray(BaseLinearTransformList):
-    """A string-based structure for series of X5 linear transforms."""
-
-    _inner_type = X5Transform
-
-    @property
-    def xforms(self):
-        """Get the list of internal X5LinearTransforms."""
-        return self._xforms
+
+
+def to_filename(fname, xfm, moving=None):
+    """Store the transform in BIDS-Transforms HDF5 file format (.x5)."""
+    with H5File(fname, "w") as out_file:
+        out_file.attrs["Format"] = "X5"
+        out_file.attrs["Version"] = np.uint16(1)
+        x5_root = out_file.create_group("/0")
+
+        # Serialize this object into the x5 file format.
+        transform_group = x5_root.create_group("TransformGroup")
+
+        # Group '0' containing Affine transform
+        transform_0 = transform_group.create_group("0")
+
+        transform_0.attrs["Type"] = "Affine"
+        transform_0.create_dataset("Transform", data=xfm.matrix)
+        transform_0.create_dataset("Inverse", data=~xfm)
+
+        metadata = {"key": "value"}
+        transform_0.attrs["Metadata"] = str(metadata)
+
+        # sub-group 'Domain' contained within group '0'
+        transform_0.create_group("Domain")
+        # domain_group.attrs["Grid"] = self._grid
+        # domain_group.create_dataset("Size", data=_as_homogeneous(self._reference.shape))
+        # domain_group.create_dataset("Mapping", data=self.mapping)