mrid-python 0.1.3__py3-none-any.whl

mrid/utils/dcm2niix.py

@@ -0,0 +1,90 @@
+import warnings
+import os
+import shutil
+import subprocess
+import tempfile
+
+import SimpleITK as sitk
+
+
+def run_dcm2niix(
+    inpath: str | os.PathLike,
+    outfolder: str | os.PathLike,
+    outfname: str,
+    mkdirs=True,
+    save_BIDS=False,
+    allow_stacking=True,
+) -> str:
+    """Convert dicom folder to NIfTI format and return path to the output ``nii.gz`` file,
+    uses dcm2niix (https://github.com/rordenlab/dcm2niix) which needs to be installed.
+
+    This is a simple wrapper around dcm2niix command line interface using subprocess, it also handles non-ascii paths.
+
+    Args:
+        inpath (str):
+            Path to the dicom files of a single study and single modality.
+            Software like Weasis has DICOM export functionality that can be
+            used to organize DICOM files into folders by patients studies and modalities.
+
+        outfolder (str): Path to the output folder (e.g. ``D:/MRI/patient001/0``).
+
+        outname (str):
+            Output filename, excluding ``.nii.gz`` because it will be added by ``dcm2niix``.
+            Can use modifiers (e.g. `%d` will be replaced with series description string from DICOM metadata),
+            as explained here https://www.nitrc.org/plugins/mwiki/index.php/dcm2nii:MainPage#General_Usage
+
+        mkdirs (bool, optional): Whether to create ``outfolder`` if it doesn't exist, otherwise throws an error. Defaults to True.
+
+        save_BIDS (bool, optional):
+            Whether to save extra BIDS sidecar - extra info in JSON format that can't be saved into nifti. Defaults to False.
+
+        allow_stacking (bool, optional):
+            Whether to allow stacking different studies into a single file.
+            Sometimes this may help with malformed DICOMs that are recognized as separate studies.
+    """
+    # dicom2niix doesnt support non-ascii paths, so convert to temporary directory
+    with tempfile.TemporaryDirectory() as tmpdir:
+
+        # create temporary folders
+        tmp_input_dir = os.path.join(tmpdir, "mrid_dcm2niix_input")
+        tmp_output_dir = os.path.join(tmpdir, "mrid_dcm2niix_output")
+        if os.path.exists(tmp_output_dir): shutil.rmtree(tmp_output_dir)
+        os.mkdir(tmp_output_dir)
+        shutil.copytree(inpath, tmp_input_dir)
+
+        # create output dir if it doesn't exist
+        if outfolder != '':
+            if not os.path.exists(outfolder):
+                if mkdirs: os.makedirs(outfolder)
+                else: raise NotADirectoryError(f"Output path {outfolder} doesn't exist")
+
+        # run dcm2niix
+        subprocess.run(["dcm2niix",
+                        "-z", "y", # compression
+                        "-m", "y" if allow_stacking else 'n', # disable stacking images from different studies
+                        "-b", 'y' if save_BIDS else 'n', # save additional JSON info that can't be saved into nifti (https://bids.neuroimaging.io/ BIDS sidecar format)
+                        "-o", os.path.normpath(tmp_output_dir), # output folder
+                        "-f", outfname, # output filename
+                        os.path.normpath(tmp_input_dir)], # input folder
+                    check=True)
+
+        # find what new nifti files were created
+        out_files = [i for i in os.listdir(tmp_output_dir) if i.lower().strip().endswith('.nii.gz')]
+
+        # move them to output folder
+        shutil.copytree(tmp_output_dir, outfolder)
+
+        if len(out_files) > 1:
+            warnings.warn(f"More than one NIfTI file was created in {outfolder}, path to the first one will be returned. Something may be wrong.")
+
+        if len(out_files) == 0:
+            raise RuntimeError(f"No nifti files were created in {outfolder}")
+
+        # return path to the created nifti file
+        return os.path.join(outfolder, out_files[0])
+
+
+def dcm2sitk(inpath:str | os.PathLike) -> sitk.Image:
+    with tempfile.TemporaryDirectory() as tmpdir:
+        nifti_path = run_dcm2niix(inpath=inpath, outfolder=tmpdir, outfname='temp', mkdirs=False, save_BIDS=False)
+        return sitk.ReadImage(nifti_path)

mrid/utils/dicom_uid_fixer.py

@@ -0,0 +1,86 @@
+import os
+import warnings
+
+
+def fix_dicom_uids(input_folder: str | os.PathLike, output_folder: str | os.PathLike):
+    """
+    Reads DICOM files from input_folder, assigns a new common SeriesInstanceUID,
+    generates new unique SOPInstanceUIDs and sequential InstanceNumbers,
+    and saves the modified files to output_folder.
+
+    This can fix malformed DICOMs that are loaded as separate series by some software.
+
+    Args:
+        input_folder (str): Path to the folder containing the problematic DICOM files.
+        output_folder (str): Path to the folder where fixed DICOM files will be saved.
+                             It will be created if it doesn't exist.
+    """
+    import pydicom
+    from pydicom.errors import InvalidDicomError
+    from pydicom.uid import generate_uid
+
+    os.makedirs(output_folder, exist_ok=True)
+
+    dicom_files_info = []
+
+    # -------------------------------- load DICOMs ------------------------------- #
+    for filename in os.listdir(input_folder):
+        input_filepath = os.path.join(input_folder, filename)
+        if os.path.isfile(input_filepath):
+            try:
+                ds = pydicom.dcmread(input_filepath, defer_size="512 KB", stop_before_pixels=False)
+
+                if 'PixelData' in ds:
+                    dicom_files_info.append({'dataset': ds, 'original_filename': filename})
+                else:
+                    warnings.warn(f"Skipping DICOM file with no PixelData: {filename}")
+
+            # except InvalidDicomError as e:
+            #     warnings.warn(f"Failed to load {filename}, skipping, exception was: {e}")
+            except Exception as e:
+                warnings.warn(f"Failed to load {filename}, skipping, exception was: {e}")
+
+    if not dicom_files_info:
+        raise FileNotFoundError(f'No valid DICOM files with PixelData found in the "{input_folder}"')
+
+    # ------------------------- sort by instance numbers ------------------------- #
+    dicom_files_info.sort(key=lambda info: int(info['dataset'].get('InstanceNumber', 0)))
+
+    # ---------------------- make new dataset with new UIDs ---------------------- #
+    new_series_uid = generate_uid()
+
+    for i, file_info in enumerate(dicom_files_info):
+        ds = file_info['dataset']
+        original_filename = file_info['original_filename']
+        instance_number = i + 1 # Generate sequential instance number (1-based)
+
+        # Generate a NEW, UNIQUE SOP Instance UID for this specific file
+        new_sop_instance_uid = generate_uid()
+
+        # Update main DICOM tags
+        ds.SeriesInstanceUID = new_series_uid
+        ds.SOPInstanceUID = new_sop_instance_uid
+        ds.InstanceNumber = str(instance_number) # VR 'IS' (Integer String)
+
+        # Update file_meta (Group 0002)
+        # Check if file_meta exists (it should for standard DICOM files)
+        if hasattr(ds, 'file_meta') and ds.file_meta:
+            ds.file_meta.MediaStorageSOPInstanceUID = new_sop_instance_uid
+
+            # update Implementation Class UID and Version Name
+            # ds.file_meta.ImplementationClassUID = pydicom.uid.PYDICOM_IMPLEMENTATION_UID
+            # ds.file_meta.ImplementationVersionName = f"PYDICOM {pydicom.__version__}"
+        else:
+            warnings.warn(f"Warning: File Meta Information (Group 0002) missing or empty in {original_filename}. Cannot update MediaStorageSOPInstanceUID.")
+
+        # other potentially helpful tags (but avoid geometry if unsure)
+        # ds.add_new(0x00080013, 'TM', datetime.datetime.now().strftime('%H%M%S.%f')[:16]) # Instance Creation Time (dummy)
+        # ds.add_new(0x00080033, 'TM', datetime.datetime.now().strftime('%H%M%S.%f')[:16]) # Content Time (dummy)
+
+    # ----------------------------- save new dataset ----------------------------- #
+    for file_info in dicom_files_info:
+        ds = file_info['dataset']
+        output_filepath = os.path.join(output_folder, file_info['original_filename'])
+
+        os.makedirs(os.path.dirname(output_filepath), exist_ok=True)
+        ds.save_as(output_filepath, write_like_original=True)

mrid/utils/plotting.py

@@ -0,0 +1,102 @@
+from collections.abc import Mapping
+
+import matplotlib.gridspec as gridspec
+import matplotlib.pyplot as plt
+import numpy as np
+
+def visualize_3d_arrays(data: Mapping[str, np.ndarray]):
+    n_vals = len(data)
+
+    # 1. Determine layout for the Outer Grid (Modalities)
+    # We try to make it roughly square (e.g., 4 items -> 2x2, 5 items -> 2x3)
+    n_cols_outer = int(np.ceil(np.sqrt(n_vals)))
+    n_rows_outer = int(np.ceil(n_vals / n_cols_outer))
+
+    # Figure size scaling
+    fig = plt.figure(figsize=(n_cols_outer * 5, n_rows_outer * 5))
+
+    # Create the Outer Grid
+    outer_grid = gridspec.GridSpec(n_rows_outer, n_cols_outer, figure=fig, wspace=0.3, hspace=0.3)
+
+    # 2. Iterate through each modality
+    for i, (modality_name, volume) in enumerate(data.items()):
+        # Create an Inner Grid (3x3) inside the specific cell of the Outer Grid
+        inner_grid = gridspec.GridSpecFromSubplotSpec(
+            3, 3,
+            subplot_spec=outer_grid[i],
+            wspace=0.05, hspace=0.05
+        )
+
+        # Calculate slicing indices for 25%, 50%, 75%
+        shapes = volume.shape
+        percentages = [0.25, 0.50, 0.75]
+
+        # Loop through dimensions (Rows of the 3x3)
+        for dim_idx in range(3):
+
+            # Get the exact indices for this dimension
+            slice_indices = [int(shapes[dim_idx] * p) for p in percentages]
+
+            # Loop through the slices (Columns of the 3x3)
+            for col_idx, slice_loc in enumerate(slice_indices):
+
+                # Create the subplot in the inner grid
+                ax = fig.add_subplot(inner_grid[dim_idx, col_idx])
+
+                # 3. Extract the 2D Slice
+                if dim_idx == 0:
+                    img_slice = volume[slice_loc, :, :]
+                    row_label = f"Dim 0\n(Slice {slice_loc})"
+                elif dim_idx == 1:
+                    img_slice = volume[:, slice_loc, :]
+                    row_label = f"Dim 1\n(Slice {slice_loc})"
+                else: # dim_idx == 2
+                    img_slice = volume[:, :, slice_loc]
+                    row_label = f"Dim 2\n(Slice {slice_loc})"
+
+                # Plot image
+                ax.imshow(img_slice, cmap='gray', aspect='auto')
+
+                # Remove ticks for cleanliness
+                ax.set_xticks([])
+                ax.set_yticks([])
+
+                # Labels: Only add row labels to the first column
+                if col_idx == 0:
+                    ax.set_ylabel(row_label, fontsize=9, rotation=90)
+
+                # Labels: Only add col labels to the first row
+                if dim_idx == 0:
+                    ax.set_title(f"{int(percentages[col_idx]*100)}%", fontsize=10)
+
+        # Add the main Modality Name on top of the grid block
+        # We fetch the geometric center of the top row of the inner grid
+        box = outer_grid[i].get_position(fig)
+        fig.text(box.x0 + box.width/2, box.y1 + 0.02, modality_name,
+                 ha='center', va='bottom', fontsize=14, fontweight='bold')
+
+    plt.show()
+
+if __name__ == "__main__":
+
+    def dummy_data(shape, type='sphere'):
+        x, y, z = np.indices(shape)
+        cx, cy, cz = shape[0]//2, shape[1]//2, shape[2]//2
+        mask = np.zeros(shape)
+        if type == 'sphere':
+            r = min(shape)//3
+            mask[(x-cx)**2 + (y-cy)**2 + (z-cz)**2 < r**2] = 1
+        elif type == 'cube':
+            r = min(shape)//4
+            mask[cx-r:cx+r, cy-r:cy+r, cz-r:cz+r] = 1
+        elif type == 'noise':
+            mask = np.random.rand(*shape)
+
+        return mask
+
+    visualize_3d_arrays({
+        "T1 Weighted (Sphere)": dummy_data((60, 60, 60), 'sphere'),
+        "T2 Weighted (Cube)": dummy_data((60, 60, 60), 'cube'),
+        "Proton Density (Noise)": dummy_data((60, 60, 60), 'noise'),
+        "FLAIR (Sphere)": dummy_data((60, 60, 60), 'sphere'),
+    })

mrid/utils/python_utils.py

@@ -0,0 +1,48 @@
+import importlib.util
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+
+# lazy loader from https://stackoverflow.com/a/78312674/15673832
+class LazyLoader:
+    'thin shell class to wrap modules.  load real module on first access and pass thru'
+
+    def __init__(self, modname):
+        self._modname = modname
+        self._mod = None
+
+    def __getattr__(self, attr):
+        'import module on first attribute access'
+
+        try:
+            return getattr(self._mod, attr)
+
+        except Exception as e :
+            if self._mod is None :
+                # module is unset, load it
+                self._mod = importlib.import_module (self._modname)
+            else :
+                # module is set, got different exception from getattr ().  reraise it
+                raise e
+
+        # retry getattr if module was just loaded for first time
+        # call this outside exception handler in case it raises new exception
+        return getattr (self._mod, attr)
+
+
+# this allows transforms to support any kind of container
+# class _Packer[T: Sequence | Mapping]:
+#     def __init__(self, type: type[T], keys: list | None = None):
+#         self.type: Any = type
+#         self.keys = keys
+
+#     def pack(self, unpacked: Sequence) -> T:
+#         if self.keys is not None: return self.type(dict(zip(self.keys, unpacked)))
+#         return self.type(unpacked)
+
+# def unpack_struct[T: Sequence | Mapping](struct: T) -> tuple[Any, _Packer[T]]:
+#     if isinstance(struct, Sequence):
+#         return list(struct), _Packer(type(struct))
+#     if isinstance(struct, Mapping):
+#         return list(struct.values()), _Packer(type(struct), list(struct.values()))
+#     raise TypeError(f"Transformation functions accept lists and dictionaries, but received {type(struct)}")

mrid/utils/stl_utils.py

@@ -0,0 +1,70 @@
+import os
+import warnings
+
+import numpy as np
+import SimpleITK as sitk
+
+from ..loading.convert import tositk
+
+def stl2sitk(
+    stl_path: str | os.PathLike,
+    reference: str | os.PathLike | sitk.Image,
+    fix_holes: bool = False,
+):
+    """
+    Loads an STL file under ``stl_path`` and converts it to ``sitk.Image`` aligned with ``reference``.
+    Note that this might take a few minutes.
+
+    Args:
+        stl_path (str): Path to the STL segmentation file. The STL coordinates
+                        MUST be in the same coordinate system as the ``reference``.
+        reference (str | os.PathLike | sitk.Image): path to a directory of DICOM files or a NIfTI file, or a ``sitk.Image``.
+        fix_holes (bool, optional): whether to try to fix holes in STL if they are detected (this can be very slow).
+    """
+    import trimesh
+
+    # ------------------------------ load reference ------------------------------ #
+    reference = tositk(reference)
+
+    origin = np.array(reference.GetOrigin())
+    spacing = np.array(reference.GetSpacing())
+    # ct_direction = np.array(ct_image.GetDirection()).reshape(3, 3)
+    size = np.array(reference.GetSize()) # Order: x, y, z
+    shape_xyz = size
+    shape_zyx = size[::-1]
+
+    # --------------------------------- load STL --------------------------------- #
+    mesh = trimesh.load_mesh(stl_path)
+
+    if not mesh.is_watertight:
+        warnings.warn(f"Warning: STL mesh '{stl_path}' is not watertight. Voxelization using 'contains' might be inaccurate.")
+        if fix_holes:
+            mesh.fill_holes()
+            if not mesh.is_watertight:
+                print("Warning: Failed to make mesh watertight after filling holes.")
+
+    # ------------------------------- voxelize STL ------------------------------- #
+    x_coords = origin[0] + np.arange(shape_xyz[0]) * spacing[0]
+    y_coords = origin[1] + np.arange(shape_xyz[1]) * spacing[1]
+    z_coords = origin[2] + np.arange(shape_xyz[2]) * spacing[2]
+
+    # Use meshgrid to create a grid of coordinates
+    # Note the 'ij' indexing to match the z, y, x array structure
+    zz, yy, xx = np.meshgrid(z_coords, y_coords, x_coords, indexing='ij')
+
+    # Stack coordinates into a (N, 3) array where N = Z*Y*X
+    voxel_centers_xyz = np.stack([xx.ravel(), yy.ravel(), zz.ravel()], axis=-1)
+
+    # This checks which voxel center points fall inside the mesh volume
+    voxel_mask_flat = mesh.contains(voxel_centers_xyz)
+
+    # Reshape the flat boolean mask back into the 3D CT shape (z, y, x)
+    stl_array = voxel_mask_flat.reshape(shape_zyx).astype(np.uint8) # Use uint8 for masks
+
+    # ------------------------------ make sitk.Image ----------------------------- #
+    stl_sitk = sitk.GetImageFromArray(stl_array)
+
+    stl_sitk.SetOrigin(reference.GetOrigin())
+    stl_sitk.SetSpacing(reference.GetSpacing())
+    stl_sitk.SetDirection(reference.GetDirection())
+    return stl_sitk

mrid/utils/torch_utils.py

@@ -0,0 +1,16 @@
+import importlib.util
+from typing import TYPE_CHECKING, cast
+
+from .python_utils import LazyLoader
+
+lazy_torch = LazyLoader("torch")
+if TYPE_CHECKING:
+    import torch
+    lazy_torch = cast(torch, lazy_torch)
+
+TORCH_INSTALLED = importlib.util.find_spec("torch") is not None
+
+if TORCH_INSTALLED:
+    CUDA_IF_AVAILABLE = 'cuda' if lazy_torch.cuda.is_available() else 'cpu'
+else:
+    CUDA_IF_AVAILABLE = 'cpu'

mrid_python-0.1.3.dist-info/METADATA

@@ -0,0 +1,140 @@
+Metadata-Version: 2.4
+Name: mrid-python
+Version: 0.1.3
+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.
+
+`mrid.Study` provides a convenient way to work with scans and provides all the tools (skull-stripping, registration, etc). See [this notebook](https://nbviewer.org/github/inikishev/mrid/blob/main/mrid_tutorial.ipynb) for an example of how to use it ([Google Colab](https://colab.research.google.com/drive/1d1MWPaGAqfK6q_5879LpwwxPCB-tbExe?usp=sharing)).
+
+All methods are also available as separate functions, see below.
+
+## Registering a scan
+
+All methods accept scans that can be a path to NIfTI, DICOM dir, sitk Image, numpy array or torch tensor, and return sitk.Image format.
+
+For registering you need to have SimpleITK-SimpleElastix installed (<https://pypi.org/project/SimpleITK-SimpleElastix/>)
+
+```python
+registered = mrid.register(moving, fixed) # returns sitk.Image
+```
+
+mrid includes downloaders for commonly used templates - MNI152 and SRI24: `mrid.get_mni152`, and `mrid.get_sri24`.
+
+```python
+t1_sri = mrid.register(t1, mrid.get_sri24("T1")) # returns sitk.Image
+```
+
+note you can always convert anything to numpy array using `mrid.tonumpy(src)`:
+
+```python
+t1_sri_np = mrid.tonumpy(t1_sri) # np.array
+```
+
+## Registering multiple scans
+
+If you have multiple scans that are already aligned, you can register one of them and use the same transformation to transform the rest. This can also be used to register segmentations.
+
+In this example we register T1 to SRI24 T1 template, and transform the rest
+
+```python
+data = {"t1": "t1c.nii.gz", "t2": "t2w.nii.gz", "flair": "t2f.nii.gz"}
+registered_data = mrid.register_D(data, key="t1", to=mrid.get_sri24("T1"))
+# dict of sitk.Image registered to SRI24
+```
+
+If you have multiple scans that are not aligned (e.g. have different shapes, orientations), you can use `register_each`. This registers one scan to the target, and then registers all other scans to the first scan. In the example it registers T1 to SRI24, and then registers T2 and FLAIR to T1.
+
+```python
+data = {"t1": "t1c.nii.gz", "t2": "t2w.nii.gz", "flair": "t2f.nii.gz"}
+registered_data = mrid.register_each(data, key="t1", to=mrid.get_sri24("T1"))
+# dict of sitk.Image registered to SRI24
+```
+
+## Inverse transform
+
+mrid provides a simple way to compute an inverse of registration, this is also another way to perform registration in general.
+
+```python
+reg = mrid.Registration()
+
+# first we need to fit a transform
+reg.find_transform(t1, mrid.get_sri24("T1"))
+
+# now we can use `reg.apply_transform` to transform any scan (assuming it is aligned to `t1`)
+t2_sri24 = reg.apply_transform(t2) # returns sitk.Image
+
+# use `apply_inverse_transform` to transform back to original space
+t2_recovered = reg.apply_inverse_transform(t2_sri24) # returns sitk.Image
+
+# when transforming segmentations, use nearest
+# neigbour interpolation to preserve edges
+seg = (mrid.tonumpy(t2_sri24) > 100).astype(np.uint8)
+seg_orig = reg.apply_inverse_transform(seg, use_nearest_interpolation=True) # returns sitk.Image
+```
+
+## Skullstripping
+
+For skullstripping mrid uses HD-BET model (<https://github.com/MIC-DKFZ/HD-BET>), and you need to have it installed (it uses torch). It works with pre/post contrast T1, T2 and FLAIR MRIs, but it expects them to be in MNI152 space (while many new datasets like BraTS are in SRI24). If your scans aren't in MNI152, the `skullstrip` function can register specified scan to MNI152, pass it to HD-BET, and then register back to original space, if `register_to_mni152` argument is specified.
+
+```python
+t1_skullstripped = mrid.skullstrip(t1) # if t1 is in MNI152
+t1_skullstripped = mrid.skullstrip(t1, register_to_mni152="T1") # if t1 is not in MNI152
+```
+
+HD-BET is generally very robust but it can remove parts of tumors adjascent to the skull, but this is true for all skullstripping tools.
+
+## Skullstripping multiple scans
+
+If you have multiple scans that are already aligned, you can compute brain mask on one of them (ideally post-contrast T1) and apply it to all scans.
+
+```python
+data = {"t1": "t1c.nii.gz", "t2": "t2w.nii.gz", "flair": "t2f.nii.gz"}
+skullstripped_data = mrid.skullstrip_D(data, key="t1", to=mrid.get_sri24("T1"))
+# dict of skullstripped sitk.Image
+```
+
+## dcm2niix
+
+mrid provides a simple wrapper around [dcm2niix](https://github.com/rordenlab/dcm2niix), which is a very robust tool for converting DICOMs to NIfTI.
+
+```python
+# this saves output.nii.gz to output_path. It can save multiple files if there are multiple cases in "path/to/dicoms".
+mrid.utils.run_dcm2niix("path/to/dicoms", outfolder="output_path", outfname="output")
+```
+
+If you want to use it convert DICOMs directly to SimpleITK, use `dcm2sitk`:
+
+```python
+t1 = mrid.utils.dcm2sitk("path/to/dicoms") # returns sitk.Image with correct spatial information
+```
+dcm2niix is much slower compared to SimpleITK's series reader which mrid uses by default, but it's more careful about splitting different studies to different files, although it might fail with malformed DICOMs which are surprisingly common (where it would think each slice is a separate study).
+
+## Loading STL segmentations
+
+`stl2sitk` converts segmentations in STL format to `sitk.Image` given a reference `sitk.Image` that the STL should be aligned to. Basically something I encountered so I had to make this.
+
+```python
+seg = mrid.utils.stl2sitk("path/to/file.stl", reference) # returns sitk.Image (hopefully) aligned with `reference`
+```
+
+## How to install
+Either run
+```
+pip install mrid-python
+```
+or
+```
+pip install git+https://github.com/inikishev/mrid
+```

mrid_python-0.1.3.dist-info/RECORD

@@ -0,0 +1,27 @@
+mrid/__init__.py,sha256=d-h6l6e-sfPUKDo27_dXcx8IRdZ5ByDC1YtdkM6y39o,138
+mrid/study.py,sha256=fa_sipmUlDvYz9QjVvuMUj5eSc-kMjlM2PYRyJ12GAQ,19595
+mrid/atlas/__init__.py,sha256=ecOAVXUOt0TUI_wK19Ed05arF6b_G61wucVq2c8U4ZY,110
+mrid/atlas/MNI152/__init__.py,sha256=QHm0ok5EkxrWCVV5uGmMvFmlJoXxJtqr6qkGB9H-9Fo,2833
+mrid/atlas/SRI24/__init__.py,sha256=jFFY6LeJcWwCtxVJGbdWPEUGFKZjqzxu01ZTbbSAwEo,2939
+mrid/loading/__init__.py,sha256=h5uDRBxjJBuz9w95BEJIUbBpV2rYswTr12B_83GfVfw,57
+mrid/loading/convert.py,sha256=NtXRmYKdjnms7GUyHLoyV0H6ntHxvTj615PIdTUlCQY,2799
+mrid/preprocessing/__init__.py,sha256=uA2FDGBUZ2MvLqmpRAYsfQxlFOzJh_U87G2H8vXgcJE,525
+mrid/preprocessing/bias_field_correction.py,sha256=K2w75JkVIV_Gj7W-9gpHUwz2teEvgSRt5wX-CqQeRik,1143
+mrid/preprocessing/cropping.py,sha256=I26hxo7RuWqdjx8ApJ2t9FBPdi3PtRsBdMlLC2KgKTk,1336
+mrid/preprocessing/registration.py,sha256=un_dLJI0jO--huUrdRkr5t8Wsczi9erEqi91QxkACsw,11901
+mrid/preprocessing/skullstripping.py,sha256=-M3SmeeeXO3hQYur5tJhWvBirbeWE239pnMwA5Klo7Y,8294
+mrid/utils/__init__.py,sha256=9pbvafeDUmkFQghV3OPXGxg-004yO9BzmrbcgF_vgyo,121
+mrid/utils/dcm2niix.py,sha256=KHU7dgUVsU7WOEa82HFO-G0SsGIxYjeUFEBcX27mkWQ,4124
+mrid/utils/dicom_uid_fixer.py,sha256=xjjfvAF13Ni5CEgwPcr7oDT7excdEoeRGQetvjGkSRM,4046
+mrid/utils/plotting.py,sha256=lU1UqygEEAxp7hUpNHKVi5oiWCRDX_3llFqQZt4zh1I,3831
+mrid/utils/python_utils.py,sha256=IYB8-KN4d6l-5ILgUNYux0vNrK0D0vh0AbSRqWhs-fo,1793
+mrid/utils/stl_utils.py,sha256=T4qT11NgvFCERfaB3duA_O1Qi9FBW7-b3B5aZKS5UU4,2888
+mrid/utils/torch_utils.py,sha256=nKby_tPWzCGdEASkDUq7xNo-iUe9zjwmhq_chV0RCGU,407
+tests/test_loading.py,sha256=CciTvnqQ7hY-Vk2GgH2SWSu8nyS8lLeBqHu3XzClBLY,2141
+tests/test_preprocessing.py,sha256=HcoubITfmlJkgPaBbkxZiY04fJv9URBGMWDJWivDqLU,1300
+tests/test_study.py,sha256=pK__azqnMz8DSyOYaWQmBkpAqLntCIIjEz0m8oBS4RQ,3984
+tests/test_utils.py,sha256=Q4uf5dog673RDofOC6RPLYnxVN5NAIVRTiyTbf9Az74,359
+mrid_python-0.1.3.dist-info/METADATA,sha256=rUfrJuDkvNA9GaU60dsapfC4aGafIzcv6K4R8bFlV6s,6099
+mrid_python-0.1.3.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mrid_python-0.1.3.dist-info/top_level.txt,sha256=lBv75ms7UoIM4elDVX3CbKiSlh-X0vABtaUwj4TGx4o,11
+mrid_python-0.1.3.dist-info/RECORD,,

mrid_python-0.1.3.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

mrid_python-0.1.3.dist-info/top_level.txt

@@ -0,0 +1,2 @@
+mrid
+tests

tests/test_loading.py

@@ -0,0 +1,82 @@
+import numpy as np
+import pytest
+import SimpleITK as sitk
+from mrid.loading.convert import tositk, tonumpy, totensor
+
+
+def test_tositk_with_numpy():
+    data = np.random.rand(10, 20, 30).astype(np.float32)
+    sitk_img = tositk(data)
+
+    assert isinstance(sitk_img, sitk.Image)
+    assert sitk.GetArrayFromImage(sitk_img).shape == (10, 20, 30)
+
+
+def test_tositk_with_sitk_image():
+    original_img = sitk.Image(10, 20, 30, sitk.sitkFloat32)
+    result_img = tositk(original_img)
+
+    assert result_img is original_img
+
+
+def test_tositk_with_pathlike():
+    with pytest.raises(FileNotFoundError):
+        tositk("/nonexistent/path.nii.gz")
+
+
+def test_tonumpy_with_numpy():
+    data = np.random.rand(10, 20, 30).astype(np.float32)
+    result = tonumpy(data)
+
+    assert isinstance(result, np.ndarray)
+    assert np.array_equal(data, result)
+
+
+def test_tonumpy_with_sitk():
+    sitk_img = sitk.Image(10, 20, 30, sitk.sitkFloat32)
+    array = sitk.GetArrayFromImage(sitk_img)
+
+    result = tonumpy(sitk_img)
+
+    assert isinstance(result, np.ndarray)
+    assert result.shape == array.shape
+
+
+def test_tonumpy_with_pathlike():
+    with pytest.raises(FileNotFoundError):
+        tonumpy("/nonexistent/path.nii.gz")
+
+
+def test_totensor_with_numpy():
+    try:
+        import torch
+        data = np.random.rand(10, 20, 30).astype(np.float32)
+        tensor = totensor(data)
+
+        assert isinstance(tensor, torch.Tensor)
+        assert tensor.shape == torch.Size([10, 20, 30])
+    except ImportError:
+        pytest.skip("no torch")
+
+
+def test_totensor_with_sitk():
+    try:
+        import torch
+        sitk_img = sitk.Image(30, 20, 10, sitk.sitkFloat32) # note that dims are reversed in sitk
+        tensor = totensor(sitk_img)
+
+        assert isinstance(tensor, torch.Tensor)
+        assert tensor.shape == torch.Size([10, 20, 30])
+    except ImportError:
+        pytest.skip("no torch")
+
+
+def test_totensor_with_tensor():
+    try:
+        import torch
+        original_tensor = torch.rand(10, 20, 30)
+        result = totensor(original_tensor)
+
+        assert result is original_tensor
+    except ImportError:
+        pytest.skip("no torch")