mrid-python 0.1.3__py3-none-any.whl

mrid/__init__.py

@@ -0,0 +1,5 @@
+from . import utils
+from .atlas import get_mni152, get_sri24
+from .preprocessing import *
+from .loading import *
+from .study import Study

mrid/atlas/MNI152/__init__.py

@@ -0,0 +1,80 @@
+# https://zenodo.org/api/records/15470657/files-archive
+
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Literal
+
+__all__ = [
+    "get_mni152",
+]
+
+_ROOT = Path(os.path.dirname(__file__))
+
+_URLS = {
+    "2006 T1w symmetric": (
+        "https://zenodo.org/records/15470657/files/icbm_mni152_t1_06_sym.nii.gz?download=1",
+        "https://zenodo.org/records/15470657/files/icbm_mni152_t1_06_sym_bet.nii.gz?download=1",
+    ),
+    "2009a T1w symmetric": (
+        "https://zenodo.org/records/15470657/files/icbm_mni152_t1_09a_sym.nii.gz?download=1",
+        "https://zenodo.org/records/15470657/files/icbm_mni152_t1_09a_sym_bet.nii.gz?download=1",
+    ),
+    "2009a T2w symmetric": (
+        "https://zenodo.org/records/15470657/files/icbm_mni152_t2_09a_sym.nii.gz?download=1",
+        "https://zenodo.org/records/15470657/files/icbm_mni152_t2_09a_sym_bet.nii.gz?download=1",
+    ),
+    "2009a T1w asymmetric": (
+        "https://zenodo.org/records/15470657/files/icbm_mni152_t1_09a_asym.nii.gz?download=1",
+        "https://zenodo.org/records/15470657/files/icbm_mni152_t1_09a_asym_bet.nii.gz?download=1",
+    ),
+    "2009a T2w asymmetric": (
+        "https://zenodo.org/records/15470657/files/icbm_mni152_t2_09a_asym.nii.gz?download=1",
+        "https://zenodo.org/records/15470657/files/icbm_mni152_t2_09a_asym_bet.nii.gz?download=1",
+    ),
+}
+
+_mni152_url = "https://zenodo.org/records/15470657/files/icbm_mni152_t1_06_sym_bet.nii.gz?download=1"
+
+def _download_template(type: str, bet:bool):
+    filename = f"{type} {bool(bet)}.nii.gz"
+    if filename in os.listdir(_ROOT):
+        raise RuntimeError(f"Template {type} is already downloaded")
+
+    import requests
+
+    response = requests.get(_URLS[type][bet], stream=True, timeout=30)
+    response.raise_for_status()
+
+    with open(_ROOT / f"{filename}", 'wb') as file:
+        shutil.copyfileobj(response.raw, file) # type:ignore
+
+def get_mni152(
+    type: Literal[
+        "2006 T1w symmetric",
+        "2009a T1w symmetric",
+        "2009a T2w symmetric",
+        "2009a T1w asymmetric",
+        "2009a T2w asymmetric",
+    ],
+    skullstripped: bool = False,
+):
+    """Returns path to .nii.gz file of specified MNI-152 template.
+
+    Descriptions of templates are available here https://zenodo.org/records/15470657
+    """
+    filename = f"{type} {bool(skullstripped)}.nii.gz"
+
+    if filename in os.listdir(_ROOT):
+        return str(_ROOT / filename)
+
+    print(f"{filename} will be downloaded from https://zenodo.org/records/15470657, this may take a few minutes.")
+    _download_template(type, skullstripped)
+
+    if filename not in os.listdir(_ROOT):
+        raise RuntimeError(
+            f"Failed to download {filename}; try downloading it manually from https://zenodo.org/records/15470657"
+        )
+
+    return str(_ROOT / filename)

mrid/atlas/SRI24/__init__.py

@@ -0,0 +1,77 @@
+"""This subpackage allows one to download SRI-24 brain atlas files from https://www.nitrc.org/projects/sri24/.
+
+The SRI24 atlas is licensed under the terms of the
+
+  Creative Commons Attribution-ShareAlike 3.0 Unported (CC BY-SA 3.0)
+
+license (https://creativecommons.org/licenses/by-...).
+
+In publications using the SRI24 atlas, please cite the following paper:
+
+  T. Rohlfing, N.M. Zahr, E.V. Sullivan, A. Pfefferbaum, "The SRI24
+  Multichannel Atlas of Normal Adult Human Brain Structure," Human
+  Brain Mapping, vol. 31, no. 5, pp. 798-819, 2010.
+
+  http://dx.doi.org/10.1002/hbm.20906
+
+"""
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Literal
+
+__all__ = [
+    "get_sri24",
+]
+
+_ROOT = Path(os.path.dirname(__file__))
+
+_sri24_url = "https://www.nitrc.org/frs/download.php/4841/sri24_spm8.zip//?i_agree=1&download_now=1"
+
+def _download_sri24() -> None:
+    import requests
+
+    response = requests.get(_sri24_url, stream=True, timeout=30)
+    response.raise_for_status()
+
+    with tempfile.TemporaryDirectory() as tmpdir:
+        tmpdir = Path(tmpdir)
+        with open(tmpdir / "sri24_spm8.zip", 'wb') as file:
+            shutil.copyfileobj(response.raw, file) # type:ignore
+
+        shutil.unpack_archive(tmpdir / "sri24_spm8.zip", tmpdir / "sri24_spm8")
+
+        for file in os.listdir(tmpdir / "sri24_spm8" / "templates"):
+            shutil.copyfile(tmpdir / "sri24_spm8" / "templates" / file, _ROOT / file)
+
+
+def get_sri24(type: Literal["EPI", "EPI_brain", "PD", "PD_brain", "T1", "T1_brain", "T2", "T2_brain"]) -> str:
+    """Returns path to .nii file of specified SRI-24 template. Templates are downloaded if they haven't been downloaded already.
+
+    The following templates are available:
+    - `"T1"`: post-contrast T1-weighted MRI with skull;
+    - `"T1_brain"`: post-contrast T1-weighted MRI without skull;
+    - `"T2"`: T2-weighted MRI with skull;
+    - `"T2_brain"`: T2-weighted MRI without skull;
+    - `"EPI"`: echo-planar imaging MRI with skull;
+    - `"EPI_brain"`: echo-planar imaging MRU without skull;
+    - `"PD"`: proton density weighted spin-echo imaging MRI with skull;
+    - `"PD_brain"`: proton density weighted spin-echo imaging MRI without skull;
+
+    """
+    filename = f"{type}.nii"
+    if filename in os.listdir(_ROOT):
+        return str(_ROOT / filename)
+
+    print("SRI24 will be downloaded from https://www.nitrc.org/projects/sri24/, this may take a few minutes.")
+    _download_sri24()
+
+    if filename not in os.listdir(_ROOT):
+        raise RuntimeError(
+            f"Failed to download {filename}; try downloading it manually from https://www.nitrc.org/projects/sri24/, "
+            "then unpack the zip file, open it, open `templates` folder, you will see files such as `EPI.nii`. "
+            f"Copy all of those files to {_ROOT}."
+        )
+
+    return str(_ROOT / filename)

mrid/atlas/__init__.py

@@ -0,0 +1,7 @@
+from . MNI152 import get_mni152
+from .SRI24 import get_sri24
+
+__all__ = [
+    "get_mni152",
+    "get_sri24",
+]

mrid/loading/__init__.py

@@ -0,0 +1 @@
+from .convert import tonumpy, tositk, totensor, ImageLike

mrid/loading/convert.py

@@ -0,0 +1,68 @@
+import importlib.util
+import os
+from typing import TYPE_CHECKING, TypeAlias
+
+import numpy as np
+import SimpleITK as sitk
+
+from ..utils.torch_utils import TORCH_INSTALLED
+
+if TYPE_CHECKING:
+    import torch
+
+PREFER_DCM2NIIX = False
+ImageLike: TypeAlias = "np.ndarray | sitk.Image | torch.Tensor | str | os.PathLike"
+
+def read_dicoms(dir: str | os.PathLike) -> sitk.Image:
+    """reads a directory of DICOM files and returns a ``sitk.Image``"""
+    # load with dcm2niix
+    if PREFER_DCM2NIIX and importlib.util.find_spec("dcm2niix") is not None:
+        from ..utils.dcm2niix import dcm2sitk
+        return dcm2sitk(dir)
+
+    # load with SimpleITK
+    reader = sitk.ImageSeriesReader()
+    dicom_names = reader.GetGDCMSeriesFileNames(str(dir))
+
+    if not dicom_names:
+        raise FileNotFoundError(f"No DICOM series found in directory: {dir}")
+
+    reader.SetFileNames(dicom_names)
+    return reader.Execute()
+
+def _read_sitk(path: str | os.PathLike) -> sitk.Image:
+    if os.path.isfile(path): return sitk.ReadImage(str(path))
+    if os.path.isdir(path): return read_dicoms(str(path))
+    raise FileNotFoundError(f"{path} doesn't exist")
+
+def tositk(x: ImageLike) -> sitk.Image:
+    """Load an image into an ``sitk.Image`` object.
+    ``x`` can be a numpy array, a ``sitk.Image``, a ``torch.Tensor`` or a string (path to an image file)."""
+    if isinstance(x, np.ndarray): return sitk.GetImageFromArray(x)
+    if isinstance(x, sitk.Image): return x
+    if isinstance(x, (str, os.PathLike)): return _read_sitk(x)
+    if TORCH_INSTALLED:
+        import torch
+        if isinstance(x, torch.Tensor): return sitk.GetImageFromArray(x.numpy())
+    raise TypeError(f"Unsupported type {type(x)}")
+
+def tonumpy(x: ImageLike) -> np.ndarray:
+    """Load an image into a numpy.ndarray.
+    ``x`` can be a numpy array, a ``sitk.Image``, a ``torch.Tensor`` or a string (path to an image file)."""
+    if isinstance(x, np.ndarray): return x
+    if isinstance(x, sitk.Image): return sitk.GetArrayFromImage(x)
+    if isinstance(x, (str, os.PathLike)): return sitk.GetArrayFromImage(_read_sitk(x))
+    if TORCH_INSTALLED:
+        import torch
+        if isinstance(x, torch.Tensor): return x.numpy()
+    raise TypeError(f"Unsupported type {type(x)}")
+
+def totensor(x: ImageLike) -> "torch.Tensor":
+    """Load an image into a torch.Tensor.
+    ``x`` can be a numpy array, a ``sitk.Image``, a ``torch.Tensor`` or a string (path to an image file)."""
+    import torch
+    if isinstance(x, np.ndarray): return torch.from_numpy(x)
+    if isinstance(x, sitk.Image): return torch.from_numpy(sitk.GetArrayFromImage(x))
+    if isinstance(x, (str, os.PathLike)): return  torch.from_numpy(sitk.GetArrayFromImage(_read_sitk(x)))
+    if isinstance(x, torch.Tensor): return x
+    raise TypeError(f"Unsupported type {type(x)}")

mrid/preprocessing/__init__.py

@@ -0,0 +1,12 @@
+from .bias_field_correction import n4_bias_field_correction
+from .cropping import crop_bg, crop_bg_D
+from .registration import resample_to, register, register_D, register_each, resize, downsample, Registration
+from .skullstripping import skullstrip, skullstrip_D, run_hd_bet, predict_brain_mask
+
+__all__ = [
+    "n4_bias_field_correction",
+    "crop_bg", "crop_bg_D",
+    "resample_to", "register", "register_D", "register_each", "resize", "downsample",
+    "skullstrip", "skullstrip_D", "run_hd_bet", "predict_brain_mask"
+
+]

mrid/preprocessing/bias_field_correction.py

@@ -0,0 +1,28 @@
+import SimpleITK as sitk
+from ..loading.convert import tositk, ImageLike
+
+def n4_bias_field_correction(image: ImageLike, shrink: int = 4) -> sitk.Image:
+    """Perform N4 Bias Field Correction to correct low frequency intensity non-uniformity present in MRI image.
+
+    Args:
+        image (ImageLike): Input MRI image to be corrected. Can be any format supported by tositk conversion.
+        shrink (int, optional): Shrink factor for reducing image size before correction to speed up computation.
+                               Default is 4. If set to 1 or less, no shrinking is performed.
+
+    """
+    image = tositk(image)
+
+    norm_image = sitk.RescaleIntensity(image, 0, 255)
+    mask = sitk.OtsuThreshold(norm_image, 0, 1)
+
+    if shrink > 1:
+        reduced = sitk.Shrink(image, [shrink] * image.GetDimension())
+        mask = sitk.Shrink(mask, [shrink] * mask.GetDimension())
+
+    else: reduced = image
+
+    corrector = sitk.N4BiasFieldCorrectionImageFilter()
+    corrector.Execute(reduced, mask)
+    log_bias_field = corrector.GetLogBiasFieldAsImage(image)
+
+    return image / sitk.Cast(sitk.Exp(log_bias_field), image.GetPixelID())

mrid/preprocessing/cropping.py

@@ -0,0 +1,36 @@
+from collections.abc import Mapping
+from typing import Any
+import SimpleITK as sitk
+
+from ..loading.convert import tositk, ImageLike
+
+def _get_bbox(image: sitk.Image):
+    rescaled = sitk.RescaleIntensity(image, 0, 255)
+    filt = sitk.LabelShapeStatisticsImageFilter()
+    filt.Execute(sitk.OtsuThreshold(rescaled, 0, 255))
+    return filt.GetBoundingBox(255)
+
+
+def crop_bg(image: ImageLike) -> sitk.Image:
+    """Crops black background of a single 3D image via Otsu's thresholding.
+
+    Args:
+        image (ImageLike): Input 3D image to be cropped. Can be any format supported by tositk conversion.
+
+    Returns:
+        sitk.Image: Cropped image with black background removed, maintaining the same pixel type as input.
+    """
+    image = tositk(image)
+    bbox = _get_bbox(image)
+    return sitk.RegionOfInterest( image, bbox[int(len(bbox) / 2) :],  bbox[0 : int(len(bbox) / 2)],)
+
+def crop_bg_D(images: Mapping[str, ImageLike], key: str) -> dict[str, sitk.Image]:
+    """Finds the bounding box of ``images[key]`` and crops all images in ``images`` to that bounding box."""
+    images = {k: tositk(v) for k,v in images.items()}
+    reference = images[key]
+
+    bbox = _get_bbox(reference)
+
+    ret = {k: sitk.RegionOfInterest(v, bbox[int(len(bbox) / 2) :],  bbox[0 : int(len(bbox) / 2)]) for k,v in images.items()}
+    return ret
+

mrid/preprocessing/registration.py

@@ -0,0 +1,251 @@
+from collections.abc import Mapping, Sequence
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+import SimpleITK as sitk
+
+from ..loading.convert import tositk, ImageLike
+
+def resample_to(input: ImageLike, to: ImageLike, interpolation=sitk.sitkNearestNeighbor) -> sitk.Image:
+    """Resample ``input`` to ``reference``.
+
+    Resampling uses spatial information embedded in the sitk.Image - size, origin, spacing and direction.
+
+    Note that this information is only available when certain imaging formats are loaded, such as DICOM and NIfTI.
+
+    ``input`` is transformed in such a way that those attributes will match ``reference``.
+    """
+    return sitk.Resample(tositk(input), tositk(to), sitk.Transform(), interpolation)
+
+
+def _default_pmap():
+    """Default parameter maps for registration"""
+    euler = sitk.GetDefaultParameterMap('translation')
+    euler['Transform'] = ['EulerTransform']
+    pmap = sitk.VectorOfParameterMap()
+    pmap.append(sitk.GetDefaultParameterMap("translation"))
+    pmap.append(euler)
+    pmap.append(sitk.GetDefaultParameterMap("rigid"))
+    pmap.append(sitk.GetDefaultParameterMap("affine"))
+    return pmap
+
+class Registration:
+    """Class for image registration.
+
+    Args:
+        pmap (Any, optional): parameter map, if None, uses default parameter map. Defaults to None.
+        log_to_console (bool, optional): if False, disables SimpleElastix logging a lot of stuff to your console. Defaults to False.
+    """
+    def __init__(self, pmap: Any = None, log_to_console=False):
+        if pmap is None: pmap = _default_pmap()
+        self.pmap: sitk.VectorOfParameterMap = pmap
+        self.log_to_console = log_to_console
+
+        # create elastix filter
+        self.elastix = sitk.ElastixImageFilter()
+        if log_to_console: self.elastix.LogToConsoleOn()
+        else: self.elastix.LogToConsoleOff()
+
+        self.elastix.SetParameterMap(self.pmap)
+
+        self._moving = None
+        self._transformed = None
+        self.inverse: "Registration | None" = None
+
+    def find_transform(self, input: ImageLike, to: ImageLike) -> sitk.Image:
+        """Find a transform that transforms ``input`` to ``to`` and save it to this ``Registration`` object.
+        Returns ``input`` registered to ``to``.
+
+        Args:
+            input (ImageLike): Moving image.
+            to (ImageLike): Fixed image.
+        """
+        if self._transformed is not None:
+            raise RuntimeError("`find_transform` has already been called on this Registration object.")
+        self._moving = tositk(input)
+        to = tositk(to)
+
+        self.elastix.SetFixedImage(to)
+        self.elastix.SetMovingImage(self._moving)
+        self.elastix.Execute()
+
+        self._transformed = self.elastix.GetResultImage()
+        return self.elastix.GetResultImage() # return copy
+
+    def apply_transform(self, input: ImageLike, use_nearest_interpolation: bool = False) -> sitk.Image:
+        """Applies transform stored in this ``Registration`` object to ``input``.
+
+        You have to use ``find_transform`` method first to find the transform.
+
+        Args:
+            input (ImageLike): Moving image to apply transform to.
+            use_nearest_interpolation (bool, optional):
+                whether to use nearest interpolation, enable when transforming segmentations. Defaults to False.
+
+        Returns:
+            sitk.Image: transformed ``input``.
+        """
+        if self._transformed is None:
+            raise RuntimeError("First find transform parameters using `find_transform` method.")
+
+        transform = sitk.TransformixImageFilter()
+        tmap = self.elastix.GetTransformParameterMap()
+        if use_nearest_interpolation:
+            for t in tmap:
+                t["ResampleInterpolator"] = ["FinalNearestNeighborInterpolator"]
+
+        transform.SetTransformParameterMap(tmap)
+        transform.SetMovingImage(input)
+        if not self.log_to_console: transform.LogToConsoleOff()
+
+        return transform.Execute()
+
+    def apply_inverse_transform(self, input: ImageLike, use_nearest_interpolation: bool = False) -> sitk.Image:
+        """Applies inverse of the transform stored in this ``Registration`` object to ``input``.
+
+        This is done by finding another transform that undoes the current one. Note that this may not be as robust as
+        using other tools like freesurfer (because in SimpleElastix transform inverse is not implemented, and
+        "DisplacementMagnitudePenalty" metric is not included in python build).
+
+        Args:
+            input (ImageLike): input image to apply inverse transform to.
+            use_nearest_interpolation (bool, optional):
+                whether to use nearest interpolation, enable when transforming segmentations. Defaults to False.
+        """
+        if self.inverse is None:
+            if (self._transformed is None) or (self._moving is None):
+                raise RuntimeError("First find transform parameters using `find_transform` method.")
+            inverse_pmap = self.elastix.GetParameterMap() # this returns a copy
+            # for p in inverse_pmap:
+            #     p["Metric"] = "MeanSquaredDifference" # not implemented
+            self.inverse = Registration(pmap=inverse_pmap, log_to_console=self.log_to_console)
+            self.inverse.find_transform(
+                input=self._transformed,
+                to=self._moving
+            )
+
+        return self.inverse.apply_transform(input, use_nearest_interpolation=use_nearest_interpolation)
+
+
+def register(input: ImageLike, to: ImageLike, pmap: Any = None, log_to_console=False):
+    """Register ``input`` to ``reference``. Returns ``input`` with the same shape and spatial position as ``reference``
+
+    Registering means finding a transform which alligns ``input`` to match with ``reference``,
+    it will have the same size, orientation, etc. By default this used affine transform.
+
+    This uses ``SimpleITK-SimpleElastix`` which is very robust.
+    Note that if you don't have it installed, you need to uninstall normal SimpleITK
+    and install https://pypi.org/project/SimpleITK-SimpleElastix/, don't worry, it's
+    the same as SimpleITK but it additionally includes SimpleElastix.
+    """
+    reg = Registration(pmap=pmap, log_to_console=log_to_console)
+    return reg.find_transform(input=input, to=to)
+
+
+def register_D(
+    images: Mapping[str, ImageLike],
+    key: str,
+    to: ImageLike,
+    pmap: Any = None,
+    log_to_console=False,
+) -> dict[str, sitk.Image]:
+    """Register ``images[key]`` to ``reference``, then use that transformation
+    to transform other values in ``images`` that are assumed to be aligned with ``images[key]`` (e.g. segmentation).
+
+    Make sure segmentation with hard edges is under a key that starts with ``"seg"``,
+    it will use nearest neighbour interpolation, otherwise it will mess up the edges.
+    """
+    reg = Registration(pmap=pmap, log_to_console=log_to_console)
+    registered = {key: reg.find_transform(images[key], to)}
+
+    # process segs last because it sets resample interpolator to nearest
+    for k,v in sorted(list(images.items()), key = lambda x: 1 if x[0].startswith('seg') else 0):
+        if k != key:
+            use_nearest_interpolation = k.startswith('seg')
+            registered[k] = reg.apply_transform(v, use_nearest_interpolation=use_nearest_interpolation)
+
+    return registered
+
+def register_each(
+    images: Mapping[str, ImageLike],
+    key: str,
+    to: ImageLike,
+    pmap: Any = None,
+    log_to_console=False,
+) -> dict[str, sitk.Image]:
+    """Register ``images[key]`` to ``reference``, then register all other values in ``images`` to registered ``images[key]``.
+
+    Use this when you have multiple modalities that do not align."""
+    images = {k: tositk(v) for k,v in images.items()}
+    to = tositk(to)
+
+    input = images[key]
+    input_reg = register(input=input, to=to, pmap=pmap, log_to_console=log_to_console)
+
+    registered = {key: input_reg}
+    for k,v in images.items():
+        if k != key:
+            registered[k] = register(input=v, to=input_reg, pmap=pmap, log_to_console=log_to_console)
+
+    return registered
+
+def resize(img: ImageLike, new_size: Sequence[int], interpolator=sitk.sitkLinear) -> sitk.Image:
+    """Resize ``sitk.Image`` to ``new_size``. Retains correct spatial information.
+    source: https://gist.github.com/lixinqi98/1bbd3596492f20b776fed2778f7cd48c"""
+    img = tositk(img)
+    new_size = list(reversed(new_size))
+
+    # img = sitk.ReadImage(img)
+    dimension = img.GetDimension()
+
+    # Physical image size corresponds to the largest physical size in the training set, or any other arbitrary size.
+    reference_physical_size = np.zeros(dimension)
+
+    reference_physical_size[:] = [(sz - 1) * spc if sz * spc > mx else mx for sz, spc, mx in
+                                  zip(img.GetSize(), img.GetSpacing(), reference_physical_size)]
+
+    # Create the reference image with a zero origin, identity direction cosine matrix and dimension
+    reference_origin = np.zeros(dimension)
+    reference_direction = np.identity(dimension).flatten()
+    reference_size = new_size
+    reference_spacing = [phys_sz / (sz - 1) for sz, phys_sz in zip(reference_size, reference_physical_size)]
+
+    reference_image = sitk.Image(reference_size, img.GetPixelIDValue())
+    reference_image.SetOrigin(reference_origin)
+    reference_image.SetSpacing(reference_spacing)
+    reference_image.SetDirection(reference_direction)
+
+    # Always use the TransformContinuousIndexToPhysicalPoint to compute an indexed point's physical coordinates as
+    # this takes into account size, spacing and direction cosines. For the vast majority of images the direction
+    # cosines are the identity matrix, but when this isn't the case simply multiplying the central index by the
+    # spacing will not yield the correct coordinates resulting in a long debugging session.
+    reference_center = np.array(
+        reference_image.TransformContinuousIndexToPhysicalPoint(np.array(reference_image.GetSize()) / 2.0))
+
+    # Transform which maps from the reference_image to the current img with the translation mapping the image
+    # origins to each other.
+    transform = sitk.AffineTransform(dimension)
+    transform.SetMatrix(img.GetDirection())
+    transform.SetTranslation(np.array(img.GetOrigin()) - reference_origin)
+    # Modify the transformation to align the centers of the original and reference image instead of their origins.
+    centering_transform = sitk.TranslationTransform(dimension)
+    img_center = np.array(img.TransformContinuousIndexToPhysicalPoint(np.array(img.GetSize()) / 2.0))
+    centering_transform.SetOffset(np.array(transform.GetInverse().TransformPoint(img_center) - reference_center))
+
+    # centered_transform = sitk.Transform(transform)
+    # centered_transform.AddTransform(centering_transform)
+
+    centered_transform = sitk.CompositeTransform([transform, centering_transform])
+
+    # Using the linear interpolator as these are intensity images, if there is a need to resample a ground truth
+    # segmentation then the segmentation image should be resampled using the NearestNeighbor interpolator so that
+    # no new labels are introduced.
+
+    return sitk.Resample(img, reference_image, centered_transform, interpolator, 0.0)
+
+def downsample(image:ImageLike, factor:float, dims: Sequence[int] | None, interpolator=sitk.sitkLinear) -> sitk.Image:
+    """factor = 2 for 2x downsampling"""
+    image = tositk(image)
+    size = sitk.GetArrayFromImage(image).shape
+    size = [round(s/factor) if (dims is None or i in dims) else s for i,s in enumerate(size)]
+    return resize(image, size, interpolator=interpolator)