mrid-python 0.1.3__tar.gz → 0.1.4__tar.gz

mrid_python-0.1.4/PKG-INFO

@@ -0,0 +1,77 @@
+Metadata-Version: 2.4
+Name: mrid-python
+Version: 0.1.4
+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 with mrid, I've included installation instructions in all notebooks.
+
+### Installation
+
+Either run
+
+```
+pip install mrid-python
+```
+
+or
+
+```
+pip install git+https://github.com/inikishev/mrid
+```
+
+### Basics
+
+The images you pass to all functions in mrid can be path to a .nii.gz file, DICOM directory, sitk.Image, numpy array or torch tensor. All functions return results as `sitk.Image`. If you need a numpy array, you can use `mrid.tonumpy(sitk_image)`.
+
+### 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 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.4/README.md

@@ -0,0 +1,63 @@
+<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 with mrid, I've included installation instructions in all notebooks.
+
+### Installation
+
+Either run
+
+```
+pip install mrid-python
+```
+
+or
+
+```
+pip install git+https://github.com/inikishev/mrid
+```
+
+### Basics
+
+The images you pass to all functions in mrid can be path to a .nii.gz file, DICOM directory, sitk.Image, numpy array or torch tensor. All functions return results as `sitk.Image`. If you need a numpy array, you can use `mrid.tonumpy(sitk_image)`.
+
+### 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 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.3 → mrid_python-0.1.4}/mrid/atlas/MNI152/__init__.py

@@ -62,6 +62,13 @@ def get_mni152(
 ):
     """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"

mrid_python-0.1.4/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.4/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.4/mrid/preprocessing/hd_bet.py

@@ -0,0 +1,242 @@
+import os
+import subprocess
+import tempfile
+from collections.abc import Mapping
+from typing import Literal
+
+import SimpleITK as sitk
+
+from ..loading.convert import ImageLike, tositk
+from ..utils.torch_utils import CUDA_IF_AVAILABLE
+from .simple_elastix import register, register_D
+from .mask import expand_binary_mask, apply_mask
+
+# hd_bet -h
+
+# -i INPUT, --input INPUT
+#                         input. Can be either a single file name or an input folder. If file: must be nifti (.nii.gz) and can only be 3D. No support for 4d images, use fslsplit to split 4d sequences into 3d images. If folder: all files ending with .nii.gz within that folder will be brain extracted.
+# -o OUTPUT, --output OUTPUT
+#                         output. Can be either a filename or a folder. If it does not exist, the folder will be created
+# -device DEVICE        used to set on which device the prediction will run. Can be 'cuda' (=GPU), 'cpu' or 'mps'. Default: cuda
+# --disable_tta         Set this flag to disable test time augmentation. This will make prediction faster at a slight decrease in prediction quality. Recommended for device cpu
+# --save_bet_mask       Set this flag to keep the bet masks. Otherwise they will be removed once HD_BET is done
+# --no_bet_image        Set this flag to disable generating the skull stripped/brain extracted image. Only makes sense if you also set --save_bet_mask
+# --verbose             Talk to me.
+
+def run_hd_bet(
+    input: str | os.PathLike,
+    output: str | os.PathLike,
+    device: Literal['cpu', 'cuda', 'mps'] = CUDA_IF_AVAILABLE,
+    disable_tta: bool = False,
+    save_bet_mask: bool = True,
+    no_bet_image: bool = False,
+    verbose: bool = False,
+) -> None:
+    """Runs HD-BET command-line routine via ``subprocess.run``.
+
+    Args:
+        input (str | os.PathLike):
+            input. Can be either a single file name or an input folder.
+            If file: must be nifti (.nii.gz) and can only be 3D.
+            No support for 4d images, use fslsplit to split 4d sequences into 3d images.
+            If folder: all files ending with .nii.gz within that folder will be brain extracted.
+        output (str | os.PathLike):
+            output. Can be either a filename or a folder. If it does not exist, the folder will be created
+        device (str, optional):
+            used to set on which device the prediction will run.
+            Can be 'cuda' (=GPU), 'cpu' or 'mps'. Default: cuda. Defaults to CUDA_IF_AVAILABLE.
+        disable_tta (bool, optional):
+            Set this flag to disable test time augmentation.
+            This will make prediction faster at a slight decrease in prediction quality.
+            Recommended for device cpu. Defaults to False.
+        save_bet_mask (bool, optional):
+            Set this flag to keep the bet masks.
+            Otherwise they will be removed once HD_BET is done. Defaults to True.
+        no_bet_image (bool, optional):
+            Set this flag to disable generating the skull stripped/brain extracted image.
+            Only makes sense if you also set --save_bet_mask. Defaults to False.
+        verbose (bool, optional): Talk to me. Defaults to False.
+    """
+
+    command = [
+        "hd-bet",
+        "-i", os.path.normpath(input),
+        "-o", os.path.normpath(output),
+        "-device", device,
+    ]
+    if disable_tta: command.append("--disable_tta")
+    if save_bet_mask: command.append("--save_bet_mask")
+    if no_bet_image: command.append("--no_bet_image")
+    if verbose: command.append("--verbose")
+
+    # run dcm2niix
+    subprocess.run(command, check=True)
+
+
+def predict_brain_mask(
+    input: ImageLike,
+    register_to_mni152: Literal["T1", "T2"] | None = None,
+    device: Literal["cpu", "cuda", "mps"] = CUDA_IF_AVAILABLE,
+    disable_tta: bool = False,
+    verbose: bool = False,
+) -> sitk.Image:
+    """Returns brain mask of ``input`` predicted by HD-BET.
+
+    Args:
+        input (ImageLike): input to skullstrip. Recommended T1-w, postcontrast T1-w, T2-w or FLAIR sequence in MNI152 space.
+        register_to_mni152 (str | None, optional):
+            Modality of MNI152 template to pre-register ``input`` to. Should be ``"T1"``, ``"T2"`` or ``None``.
+            if specified, ``input`` will be registered to specified MNI152 template,
+            then after prediction the brain mask registered back to original ``input``.
+            Note that HD-BET expects images to be in MNI152 space. Defaults to None.
+        device (str, optional):
+            used to set on which device the prediction will run. Can be 'cuda' (=GPU), 'cpu' or 'mps'.
+            Defaults to CUDA_IF_AVAILABLE.
+        disable_tta (bool, optional):
+            Set this flag to disable test time augmentation.
+            This will make prediction faster at a slight decrease in prediction quality.
+            Recommended for device cpu. Defaults to False.
+        verbose (bool, optional): Talk to me. Defaults to False.
+    """
+    input = tositk(input)
+
+    # ---------------------------- register to mni152 ---------------------------- #
+    if register_to_mni152 is not None:
+        from ..atlas.MNI152 import get_mni152
+        mni152 = get_mni152(f"2009a {register_to_mni152}w asymmetric", skullstripped=False) # type:ignore
+        input_mni = register(input, mni152)
+
+    else:
+        input_mni = input
+
+    # ---------------------------- predict brain mask ---------------------------- #
+    with tempfile.TemporaryDirectory() as tmpdir:
+        sitk.WriteImage(input_mni, os.path.join(tmpdir, "input.nii.gz"))
+
+        run_hd_bet(
+            input = os.path.join(tmpdir, "input.nii.gz"),
+            output = os.path.join(tmpdir, "output.nii.gz"),
+            device=device, disable_tta=disable_tta, save_bet_mask=True, verbose=verbose,
+        )
+
+        brain_mask_mni = tositk(os.path.join(tmpdir, "output_bet.nii.gz"))
+
+    # ------------------------- unregister mask if needed ------------------------ #
+    if register_to_mni152 is not None:
+        study_mni = dict(image=input_mni, seg_brain=brain_mask_mni)
+        study = register_D(study_mni, key="image", to=input)
+        brain_mask = study["seg_brain"]
+
+    else:
+        brain_mask = brain_mask_mni
+
+    return brain_mask
+
+def skullstrip(
+    input: ImageLike,
+    register_to_mni152: Literal["T1", "T2"] | None = None,
+    device: Literal["cpu", "cuda", "mps"] = CUDA_IF_AVAILABLE,
+    disable_tta: bool = False,
+    verbose: bool = False,
+
+    expand: int = 0,
+) -> sitk.Image:
+    """Skullstrips ``input`` using HD-BET.
+
+    Args:
+        input (ImageLike): input to skullstrip. Recommended T1-w, postcontrast T1-w, T2-w or FLAIR sequence in MNI152 space.
+        register_to_mni152 (str | None, optional):
+            Modality of MNI152 template to pre-register ``input`` to. Should be ``"T1"``, ``"T2"`` or ``None``.
+            if specified, ``input`` will be registered to specified MNI152 template,
+            then after prediction the brain mask registered back to original ``input``.
+            Note that HD-BET expects images to be in MNI152 space. Defaults to None.
+        device (str, optional):
+            used to set on which device the prediction will run. Can be 'cuda' (=GPU), 'cpu' or 'mps'.
+            Defaults to CUDA_IF_AVAILABLE.
+        disable_tta (bool, optional):
+            Set this flag to disable test time augmentation. This will make prediction faster
+            at a slight decrease in prediction quality. Recommended for device cpu. Defaults to False.
+        verbose (bool, optional): Talk to me. Defaults to False.
+        expand (int, optional):
+            Positive values expand brain mask by this many pixels, meaning inner parts of the skull will be included;
+            Negative values dilate brain mask by this many pixels, meaning outer parts of the brain will be excluded.
+
+    """
+    input = tositk(input)
+    mask = predict_brain_mask(input=input, register_to_mni152=register_to_mni152,
+                                  device=device, disable_tta=disable_tta, verbose=verbose)
+
+    if expand != 0:
+        mask = expand_binary_mask(mask, expand=expand)
+
+    return apply_mask(input, mask)
+
+
+def skullstrip_D(
+    images: Mapping[str, ImageLike],
+    key: str,
+    register_to_mni152: Literal["T1", "T2"] | None = None,
+    device: Literal["cpu", "cuda", "mps"] = CUDA_IF_AVAILABLE,
+    disable_tta: bool = False,
+    verbose: bool = False,
+
+    expand: int = 0,
+
+    include_mask: bool = False,
+    keep_original: bool = False,
+) -> dict[str, sitk.Image]:
+    """Predicts brain mask of ``images[key]`` using HD-BET, then uses this mask to skull strip all values in ``images``.
+
+    Args:
+        images (Mapping[str, ImageLike]): dictionary of images that align with each other.
+        key (str): key of the image to pass to HD-BET for brain mask prediction.
+        register_to_mni152 (str | None, optional):
+            Modality of MNI152 template to pre-register ``input`` to. Should be ``"T1"``, ``"T2"`` or ``None``.
+            if specified, ``input`` will be registered to specified MNI152 template,
+            then after prediction the brain mask registered back to original ``input``.
+            Note that HD-BET expects images to be in MNI152 space. Defaults to None.
+        device (str, optional):
+            used to set on which device the prediction will run. Can be 'cuda' (=GPU), 'cpu' or 'mps'.
+            Defaults to CUDA_IF_AVAILABLE.
+        disable_tta (bool, optional):
+            Set this flag to disable test time augmentation. This will make prediction faster
+            at a slight decrease in prediction quality. Recommended for device cpu. Defaults to False.
+        verbose (bool, optional): Talk to me. Defaults to False.
+        expand (int, optional):
+            Positive values expand brain mask by this many pixels, meaning inner parts of the skull will be included;
+            Negative values dilate brain mask by this many pixels, meaning outer parts of the brain will be excluded.
+        include_mask (bool, optional):
+            if True, adds ``"seg_seg_hd_bet"`` with brain mask predicted by HD-BET to returned dictionary.
+            This adds brain mask BEFORE expanding/dilating if ``expand`` argument is specified.
+        keep_original (bool, Optional):
+            if True, skull-stripped images are added to the dictionary
+            with ``"_hd_bet" ``postfix, rather than replacing.
+    """
+    images = {k: tositk(v) for k,v in images.items()}
+
+    mask = predict_brain_mask(input=images[key], register_to_mni152=register_to_mni152,
+                          device=device, disable_tta=disable_tta, verbose=verbose)
+
+    skullstripped = {}
+
+    # include mask before expanding
+    if include_mask:
+        mask_sitk = tositk(mask)
+        mask_sitk.CopyInformation(images[key])
+        skullstripped["seg_hd_bet"] = mask_sitk
+
+    # expand
+    if expand != 0:
+        mask = expand_binary_mask(mask, expand=expand)
+
+    # apply mask
+    for k,v in images.items():
+        skullstripped[k] = apply_mask(v, mask)
+
+    # optionally add with skullstripped postfix
+    if keep_original:
+        skullstripped = {f"{k}_hd_bet": v for k,v in skullstripped}
+        skullstripped.update(images.copy())
+
+    return skullstripped
+

mrid_python-0.1.4/mrid/preprocessing/mask.py

@@ -0,0 +1,42 @@
+import SimpleITK as sitk
+import numpy as np
+import SimpleITK as sitk
+
+from ..loading.convert import ImageLike, tositk, tonumpy
+
+
+def expand_binary_mask(binary_mask: ImageLike, expand: int) -> sitk.Image:
+    """Expand or dilate a binary mask.
+
+    Args:
+        binary_mask (ImageLike): mask
+        expand (int, optional):
+            Positive values expand the mask by this many pixels;
+            Negative values dilate the mask by this many pixels.
+    """
+    binary_mask = tositk(binary_mask)
+    if expand > 0:
+        inverted_mask = 1 - binary_mask
+        return 1 - sitk.BinaryDilate(inverted_mask, (expand, expand, expand))
+
+    if expand < 0:
+        return sitk.BinaryDilate(binary_mask, (-expand, -expand, -expand))
+
+    return binary_mask
+
+def apply_mask(image: ImageLike, mask: ImageLike) -> sitk.Image:
+    """Applies ``mask`` to ``image``, that is all values where ``mask > 0`` are kept.
+
+    This function sets all values outside of the mask to smallest value within the mask."""
+    image = tositk(image)
+    mask = tositk(mask)
+
+    mask = sitk.Cast(mask, image.GetPixelID())
+
+    image_np = sitk.GetArrayFromImage(image)
+    mask_np = (tonumpy(mask) > 0).astype(np.bool)
+    image_ma = np.ma.masked_array(image_np, ~mask_np)
+
+    image_applied = tositk(image_ma.filled(image_ma.min()))
+    image_applied.CopyInformation(image)
+    return image_applied