mrid-python 0.1.5__tar.gz

mrid_python-0.1.5/PKG-INFO

@@ -0,0 +1,73 @@
+Metadata-Version: 2.4
+Name: mrid-python
+Version: 0.1.5
+Summary: Tools for working with 3D medical images and segmentations - registration, brain skull-stripping, etc.
+Author-email: Ivan Nikishev <nkshv2@gmail.com>
+Project-URL: Homepage, https://github.com/inikishev/mrid
+Project-URL: Repository, https://github.com/inikishev/mrid
+Project-URL: Issues, https://github.com/inikishev/mrid/isses
+Keywords: MRI,medical imaging
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: SimpleITK
+
+<h1 align='center'>mrid</h1>
+
+mrid is a library for preprocessing of 3D images, particularly medical images.
+
+It provide interfaces for many medical image processing tools such as [SimpleElastix](https://simpleelastix.github.io/), [HD-BET](https://github.com/MIC-DKFZ/HD-BET#Installation), [SynthStrip](https://surfer.nmr.mgh.harvard.edu/docs/synthstrip/), [CTSeg](https://github.com/WCHN/CTseg). Note that those libraries are not bundled, installation instructions are included in all examples below.
+
+### Installation
+
+Either run
+
+```
+pip install mrid-python
+```
+
+or
+
+```
+pip install git+https://github.com/inikishev/mrid
+```
+
+### Registering images with SimpleITK-SimpleElastix
+
+[SimpleElastix](https://simpleelastix.github.io/) is a robust tool for image registration which works really well out-of-the-box. It works on both Windows and Linux.
+
+See [this notebook](https://github.com/inikishev/mrid/blob/main/notebooks/SimpleElastix%20tutorial.ipynb) for how to install and use it.
+<img width="828" height="839" alt="image" src="https://github.com/user-attachments/assets/f083178a-82f0-411d-9d46-ffff774248e0" />
+
+### Skullstripping MRI scans with HD-BET
+
+[HD-BET](https://github.com/MIC-DKFZ/HD-BET) is a model that performs skullstripping of pre- and post-constrast T1, T2 and FALIR MRIs. It works on both Windows and Linux.
+
+See [this notebook](https://github.com/inikishev/mrid/blob/main/notebooks/HD-BET%20tutorial.ipynb) for how to install and use it
+<img width="828" height="840" alt="image" src="https://github.com/user-attachments/assets/ec3a8a39-0554-419f-9df9-b8e5bebc9232" />
+
+### Skullstripping with SynthStrip
+
+[SynthStrip](https://surfer.nmr.mgh.harvard.edu/docs/synthstrip/) is a skull-stripping tool that works with many different image types and modalities, including MRI, DWI, CT, PET, etc.
+
+See [this notebook](https://github.com/inikishev/mrid/blob/main/notebooks/SynthStrip%20tutorial.ipynb) for how to install and use it
+<img width="828" height="840" alt="image" src="https://github.com/user-attachments/assets/60fdca28-054d-4e62-93f1-6b84daa3fb9a" />
+
+### Skullstripping and segmentation of CT images with CTseg
+
+[CTseg](https://github.com/WCHN/CTseg) can skull-strip CT images and perform their segmentation, it also registers them to a common space (see its README). Note that it can be very slow for 512x512 series (can take few hours), but you can downsample to 256x256. If you only need to quickly skullstrip CT scans without warping them you can use SynthStrip.
+
+TODO！！！
+
+### Example workflow - preprocessing MRIs to BraTS format
+
+Many [BraTS](https://www.synapse.org/brats) datasets are provided as skullstripped images in SRI24 space. See [this notebook](https://github.com/inikishev/mrid/blob/main/notebooks/BraTS%20preprocessing%20workflow.ipynb) for how to process raw scans to this format.
+
+<img width="828" height="849" alt="image" src="https://github.com/user-attachments/assets/f1b38db3-6648-4660-a381-d68a2eb8508d" />
+
+(T1n image looks weird because that's just how it is in the zenodo dataset)
+
+### References
+The MRIs for all images above are from https://zenodo.org/records/7213153.
+
+> Colin Vanden Bulcke. (2022). Open-Access DICOM MRI session (1.0) [Data set]. Zenodo. https://doi.org/10.5281/zenodo.7213153

mrid_python-0.1.5/README.md

@@ -0,0 +1,59 @@
+<h1 align='center'>mrid</h1>
+
+mrid is a library for preprocessing of 3D images, particularly medical images.
+
+It provide interfaces for many medical image processing tools such as [SimpleElastix](https://simpleelastix.github.io/), [HD-BET](https://github.com/MIC-DKFZ/HD-BET#Installation), [SynthStrip](https://surfer.nmr.mgh.harvard.edu/docs/synthstrip/), [CTSeg](https://github.com/WCHN/CTseg). Note that those libraries are not bundled, installation instructions are included in all examples below.
+
+### Installation
+
+Either run
+
+```
+pip install mrid-python
+```
+
+or
+
+```
+pip install git+https://github.com/inikishev/mrid
+```
+
+### Registering images with SimpleITK-SimpleElastix
+
+[SimpleElastix](https://simpleelastix.github.io/) is a robust tool for image registration which works really well out-of-the-box. It works on both Windows and Linux.
+
+See [this notebook](https://github.com/inikishev/mrid/blob/main/notebooks/SimpleElastix%20tutorial.ipynb) for how to install and use it.
+<img width="828" height="839" alt="image" src="https://github.com/user-attachments/assets/f083178a-82f0-411d-9d46-ffff774248e0" />
+
+### Skullstripping MRI scans with HD-BET
+
+[HD-BET](https://github.com/MIC-DKFZ/HD-BET) is a model that performs skullstripping of pre- and post-constrast T1, T2 and FALIR MRIs. It works on both Windows and Linux.
+
+See [this notebook](https://github.com/inikishev/mrid/blob/main/notebooks/HD-BET%20tutorial.ipynb) for how to install and use it
+<img width="828" height="840" alt="image" src="https://github.com/user-attachments/assets/ec3a8a39-0554-419f-9df9-b8e5bebc9232" />
+
+### Skullstripping with SynthStrip
+
+[SynthStrip](https://surfer.nmr.mgh.harvard.edu/docs/synthstrip/) is a skull-stripping tool that works with many different image types and modalities, including MRI, DWI, CT, PET, etc.
+
+See [this notebook](https://github.com/inikishev/mrid/blob/main/notebooks/SynthStrip%20tutorial.ipynb) for how to install and use it
+<img width="828" height="840" alt="image" src="https://github.com/user-attachments/assets/60fdca28-054d-4e62-93f1-6b84daa3fb9a" />
+
+### Skullstripping and segmentation of CT images with CTseg
+
+[CTseg](https://github.com/WCHN/CTseg) can skull-strip CT images and perform their segmentation, it also registers them to a common space (see its README). Note that it can be very slow for 512x512 series (can take few hours), but you can downsample to 256x256. If you only need to quickly skullstrip CT scans without warping them you can use SynthStrip.
+
+TODO！！！
+
+### Example workflow - preprocessing MRIs to BraTS format
+
+Many [BraTS](https://www.synapse.org/brats) datasets are provided as skullstripped images in SRI24 space. See [this notebook](https://github.com/inikishev/mrid/blob/main/notebooks/BraTS%20preprocessing%20workflow.ipynb) for how to process raw scans to this format.
+
+<img width="828" height="849" alt="image" src="https://github.com/user-attachments/assets/f1b38db3-6648-4660-a381-d68a2eb8508d" />
+
+(T1n image looks weird because that's just how it is in the zenodo dataset)
+
+### References
+The MRIs for all images above are from https://zenodo.org/records/7213153.
+
+> Colin Vanden Bulcke. (2022). Open-Access DICOM MRI session (1.0) [Data set]. Zenodo. https://doi.org/10.5281/zenodo.7213153

mrid_python-0.1.5/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_python-0.1.5/mrid/atlas/MNI152/__init__.py

@@ -0,0 +1,87 @@
+# 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.
+
+    The following templates are available:
+    - ``"2006 T1w symmetric"``
+    - ``"2009a T1w symmetric"``
+    - ``"2009a T2w symmetric"``
+    - ``"2009a T1w asymmetric"``
+    - ``"2009a T2w asymmetric"``
+
+    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_python-0.1.5/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_python-0.1.5/mrid/atlas/__init__.py

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

mrid_python-0.1.5/mrid/loading/__init__.py

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

mrid_python-0.1.5/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_python-0.1.5/mrid/preprocessing/CTseg.py

@@ -0,0 +1,81 @@
+""""
+This requires CTseg docker image to be present in the system.
+
+If you haven't already, install docker to your OS following this https://docs.docker.com/engine/install/
+
+CTseg is available in the following repository: https://github.com/WCHN/CTseg
+
+Navigate to any folder, open the terminal in that folder and type in ``git clone https://github.com/WCHN/CTseg``. You might have to [install git](https://git-scm.com/install/) if you don't have it installed. This will create a new directory called ``CTseg`` in the folder and download the repository to it. Alternatively you can open the repository in your web browser, click on the green "Code" button near the top and click "Download ZIP", and unpack the archive to a folder named ``CTseg``.
+
+Then type in the command specified in "Docker" section of the read-me in https://github.com/WCHN/CTseg to build an image from the Dockerfile in this repository. I decided to not copy the command here in case it gets updated in the repository. This will download and build a docker image, usually to ``/var/lib/docker/`` on Linux, or inside the Docker Desktop virtual machine disk image on Windows. Note that this will download 3 GB of data, so it might take some time.
+
+After it is done, the CTseg functions from mrid can be used.
+"""
+import os
+import subprocess
+from pathlib import Path
+
+from ..loading import tositk
+
+def run_CTseg(
+    pth_ct: str | os.PathLike,
+    dir_out: str = "",
+    docker_image = "ubuntu:ctseg",
+) -> None:
+    """Runs ``CTseg`` command-line routine via ``subprocess.run``.
+
+    Args:
+        pth_ct (str | os.PathLike): path to a file which must be in a ``*.nii`` format.
+        dir_out (str, optional):
+            optional name of a directory that will be created next to ``path_ct`` nii file to save CTseg outputs to.
+            If empty, outputs are saved next to ``path_ct`` file. Defaults to ''.
+        docker_image (str, optional): name of the docker image that ``CTseg`` is installed in. Defaults to "ubuntu:ctseg".
+    """
+
+    # docker run --rm -it -v "/home/jj/data":/data ubuntu:ctseg function spm_CTseg '/data/CT.nii'
+    # better
+    # docker run --rm -it -v "/home/jj/data":/data ubuntu:ctseg eval "spm_CTseg('/data/CT.nii', '', true, true, true, true, 1.0)"
+    pth_ct = Path(pth_ct)
+
+    if dir_out != "":
+        if "/" in dir_out or "\\" in dir_out:
+            raise RuntimeError(
+                "dir_out should be name of directory that will be created next to `path_ct`. "
+                f"It can't be a path. Got '{dir_out}'"
+            )
+
+        dir_out = f"/data/{dir_out}"
+
+    command = [
+        "docker",
+        "run",
+
+        # --rm automatically removes the container's file system after the container exits. This is useful for running temporary containers.
+        "--rm",
+
+        # This is a combination of two flags, -i and -t:
+            # -i (interactive): Keeps the standard input (STDIN) open, allowing you to interact with the container.
+            # -t (tty): Allocates a pseudo-TTY, which makes the container behave like a normal terminal session. (doesn't work with subprocess)
+        #"-it",
+        "-i",
+
+        # -v used for mounting volumes, which allows you to connect a file path on your host machine to a path inside the container. This option requires a specific format: -v <host_path>:<container_path>.
+        "-v",
+        f"{os.path.normpath(pth_ct.parent)}:/data",
+
+        # docker image name
+        docker_image,
+
+        # evaluate matlab code
+        "eval",
+
+        # code to evaluate
+        f"spm_CTseg('/data/{pth_ct.name}', '{dir_out}', true, true, true, true, 1.0)",
+    ]
+
+    # run dcm2niix
+    subprocess.run(command, check=True)
+
+# this creates
+# wc01_1_00001_temp_CT_CTseg.nii
+# wc02_1_00001_temp_CT_CTseg

mrid_python-0.1.5/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 .spatial import downsample, resample_to, resize
+
+# lib wrappers
+from . import hd_bet, CTseg, simple_elastix, synthstrip, mask
+__all__ = [
+    "n4_bias_field_correction",
+    "crop_bg", "crop_bg_D",
+    "resample_to", "resize", "downsample",
+    "hd_bet", "CTseg", "simple_elastix", "synthstrip", "mask",
+]

mrid_python-0.1.5/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_python-0.1.5/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
+