brainles-preprocessing 0.3.6__tar.gz → 0.4.0__tar.gz

{brainles_preprocessing-0.3.6 → brainles_preprocessing-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: brainles_preprocessing
-Version: 0.3.6
+Version: 0.4.0
 Summary: Tool for preprocessing tasks in biomedical imaging, with a focus on (but not limited to) multi-modal brain MRI
 License: Apache-2.0
 Keywords: brain tumor,glioma,BraTS,skullstripping,brain extraction
@@ -19,10 +19,10 @@ Classifier: Programming Language :: Python :: 3.13
 Provides-Extra: all
 Provides-Extra: itk-elastix
 Provides-Extra: picsl-greedy
-Requires-Dist: antspyx (>=0.4.2,<0.5.0)
+Requires-Dist: antspyx (>=0.5.4,<1.0.0)
 Requires-Dist: auxiliary (>=0.0.42)
 Requires-Dist: black (>=22.1.0,<23.0.0)
-Requires-Dist: brainles_hd_bet (>=0.0.10)
+Requires-Dist: brainles_hd_bet (>=0.0.10,<1.0.0)
 Requires-Dist: itk-elastix (>=0.20.0,<0.21.0) ; extra == "all" or extra == "itk-elastix"
 Requires-Dist: nibabel (>=3.2.1)
 Requires-Dist: numpy (>=1.23.0,<2.0.0)
@@ -30,6 +30,7 @@ Requires-Dist: path (>=16.10.0,<17.0.0)
 Requires-Dist: pathlib (>=1.0.1,<2.0.0)
 Requires-Dist: picsl_greedy (>=0.0.6,<0.0.7) ; extra == "all" or extra == "picsl-greedy"
 Requires-Dist: rich (>=13.6.0,<14.0.0)
+Requires-Dist: scipy (<1.14)
 Requires-Dist: tqdm (>=4.64.1,<5.0.0)
 Requires-Dist: ttictoc (>=0.5.6,<0.6.0)
 Requires-Dist: typer (>=0.15.0,<0.16.0)

brainles_preprocessing-0.4.0/brainles_preprocessing/back_to_native.py

@@ -0,0 +1,100 @@
+from pathlib import Path
+from typing import List, Optional, Union
+
+from brainles_preprocessing.constants import Atlas, PreprocessorSteps
+from brainles_preprocessing.defacing import Defacer, QuickshearDefacer
+from brainles_preprocessing.modality import CenterModality, Modality
+from brainles_preprocessing.registration import ANTsRegistrator
+from brainles_preprocessing.registration.registrator import Registrator
+from brainles_preprocessing.utils.logging_utils import LoggingManager
+from brainles_preprocessing.utils.zenodo import verify_or_download_atlases
+
+logging_man = LoggingManager(name=__name__)
+logger = logging_man.get_logger()
+
+
+class BackToNativeSpace:
+
+    def __init__(
+        self,
+        transformations_dir: Union[str, Path],
+        registrator: Optional[Registrator] = None,
+    ):
+
+        self.transformations_dir = Path(transformations_dir)
+
+        if registrator is None:
+            logger.warning(
+                "No registrator provided, using default ANTsRegistrator for registration."
+            )
+        self.registrator: Registrator = registrator or ANTsRegistrator()
+
+    def transform(
+        self,
+        target_modality_name: str,
+        target_modality_img: Union[str, Path],
+        moving_image: Union[str, Path],
+        output_img_path: Union[str, Path],
+        log_file_path: Union[str, Path],
+        interpolator: Optional[str] = None,
+    ):
+        """
+        Apply inverse transformation to a moving image to align it with a target modality.
+
+        Args:
+            target_modality_name (str): Name of the target modality. Must match the name used to create the transformations.
+            target_modality_img (Union[str, Path]): Path to the target modality image.
+            moving_image (Union[str, Path]): Path to the moving image. E.g., this could be a segmentation in atlas space.
+            output_img_path (Union[str, Path]): Path where the transformed image will be saved.
+            log_file_path (Union[str, Path]): Path to the log file where transformation details will be written.
+            interpolator (Optional[str]): Interpolation method used during transformation.
+                Available options depend on the chosen registrator:
+
+                - **ANTsRegistrator**:
+                    - "linear" (default)
+                    - "nearestNeighbor"
+                    - "multiLabel" (deprecated, prefer "genericLabel")
+                    - "gaussian"
+                    - "bSpline"
+                    - "cosineWindowedSinc"
+                    - "welchWindowedSinc"
+                    - "hammingWindowedSinc"
+                    - "lanczosWindowedSinc"
+                    - "genericLabel" (recommended for label images)
+
+                - **NiftyReg**:
+                    - "0": nearest neighbor
+                    - "1": linear (default)
+                    - "3": cubic spline
+                    - "4": sinc
+
+        Raises:
+            AssertionError: If the transformations directory for the given modality does not exist.
+        """
+        logger.info(
+            f"Applying inverse transformation for {target_modality_name} using {self.registrator.__class__.__name__}."
+        )
+
+        # assert modality name eixsts in transformations_dir
+        modality_transformations_dir = (
+            self.transformations_dir / f"{target_modality_name}"
+        )
+
+        assert (
+            modality_transformations_dir.exists()
+        ), f"Transformations directory for {target_modality_name} does not exist: {modality_transformations_dir}"
+
+        transforms = list(modality_transformations_dir.iterdir())
+        transforms.sort()  # sort by name to get order for forward transform
+        transforms = transforms[::-1]  # inverse order for inverse transform
+
+        kwargs = {
+            "fixed_image_path": target_modality_img,
+            "moving_image_path": moving_image,
+            "transformed_image_path": output_img_path,
+            "matrix_path": transforms,
+            "log_file_path": str(log_file_path),
+        }
+        if interpolator is not None:
+            kwargs["interpolator"] = interpolator
+        self.registrator.inverse_transform(**kwargs)

{brainles_preprocessing-0.3.6 → brainles_preprocessing-0.4.0}/brainles_preprocessing/modality.py

@@ -2,13 +2,18 @@ import logging
 import shutil
 import warnings
 from pathlib import Path
-from typing import Optional, Union
+from typing import Dict, Optional, Union
 
 from auxiliary.nifti.io import read_nifti, write_nifti
+
 from brainles_preprocessing.brain_extraction.brain_extractor import BrainExtractor
 from brainles_preprocessing.constants import PreprocessorSteps
 from brainles_preprocessing.defacing import Defacer, QuickshearDefacer
 from brainles_preprocessing.normalization.normalizer_base import Normalizer
+from brainles_preprocessing.registration import (  # TODO: this will throw warnings if ANTs or NiftyReg are not installed, not ideal
+    ANTsRegistrator,
+    NiftyRegRegistrator,
+)
 from brainles_preprocessing.registration.registrator import Registrator
 
 logger = logging.getLogger(__name__)
@@ -42,6 +47,7 @@ class Modality:
         normalized_defaced_output_path (str or Path, optional): Path to save the normalized defaced modality data. Requires a normalizer.
         bet (bool): Indicates whether brain extraction is enabled.
         atlas_correction (bool): Indicates whether atlas correction should be performed.
+        coregistration_transform_path (str or None): Path to the coregistration transformation matrix, will be set after coregistration.
 
     Example:
         >>> t1_modality = Modality(
@@ -73,6 +79,7 @@ class Modality:
         self.current = self.input_path
         self.normalizer = normalizer
         self.atlas_correction = atlas_correction
+        self.transformation_paths: Dict[PreprocessorSteps, Path | None] = {}
 
         # Check that atleast one output is generated
         if not any(
@@ -128,6 +135,7 @@ class Modality:
             self.normalized_defaced_output_path = None
 
         self.steps = {k: None for k in PreprocessorSteps}
+        self.steps[PreprocessorSteps.INPUT] = self.input_path
 
     @property
     def bet(self) -> bool:
@@ -197,6 +205,26 @@ class Modality:
         else:
             logger.info("No normalizer specified; skipping normalization.")
 
+    def _find_transformation_matrix(
+        self, transform_incomplete_path: Path
+    ) -> Optional[Path]:
+        possible_Files = list(
+            transform_incomplete_path.parent.glob(f"{transform_incomplete_path.stem}.*")
+        )
+        if len(possible_Files) == 0:
+            logger.warning(
+                f"No transformation matrix found for {transform_incomplete_path}. "
+                "Returning None."
+            )
+            return None
+        elif len(possible_Files) > 1:
+            # TODO: Handle this case more gracefully, e.g., try to find proper extension based on the registrator
+            logger.warning(
+                f"Multiple transformation matrices found for {transform_incomplete_path}. "
+                "Returning the first one."
+            )
+        return possible_Files[0]
+
     def register(
         self,
         registrator: Registrator,
@@ -213,6 +241,7 @@ class Modality:
             fixed_image_path (str or Path): Path to the fixed image.
             registration_dir (str or Path): Directory to store registration results.
             moving_image_name (str): Name of the moving image.
+            step (PreprocessorSteps): The current preprocessing step.
 
         Returns:
             Path: Path to the registration matrix.
@@ -224,7 +253,7 @@ class Modality:
         registered_log = registration_dir / f"{moving_image_name}.log"
 
         # Note, add file ending depending on registration backend!
-        registered_matrix = registration_dir / f"{moving_image_name}"
+        registered_matrix = registration_dir / f"M_{moving_image_name}"
 
         registrator.register(
             fixed_image_path=fixed_image_path,
@@ -235,6 +264,11 @@ class Modality:
         )
         self.current = registered
         self.steps[step] = registered
+
+        self.transformation_paths[step] = self._find_transformation_matrix(
+            transform_incomplete_path=registered_matrix
+        )
+
         return registered_matrix
 
     def apply_bet_mask(
@@ -320,7 +354,7 @@ class Modality:
             registration_dir_path (str or Path): Directory to store transformation results.
             moving_image_name (str): Name of the moving image.
             transformation_matrix_path (str or Path): Path to the transformation matrix.
-
+            step (PreprocessorSteps): The current preprocessing step.
         Returns:
             None
         """
@@ -331,15 +365,42 @@ class Modality:
         transformed = registration_dir_path / f"{moving_image_name}.nii.gz"
         transformed_log = registration_dir_path / f"{moving_image_name}.log"
 
-        registrator.transform(
-            fixed_image_path=fixed_image_path,
-            moving_image_path=self.current,
-            transformed_image_path=transformed,
-            matrix_path=transformation_matrix_path,
-            log_file_path=transformed_log,
-        )
+        if (
+            isinstance(registrator, (ANTsRegistrator, NiftyRegRegistrator))
+            and step == PreprocessorSteps.ATLAS_REGISTERED
+        ):
+            # we test uniting transforms for these registrators
+            assert (
+                self.transformation_paths.get(PreprocessorSteps.COREGISTERED, None)
+                is not None
+            ), "Coregistration must be performed before applying atlas registration."
+
+            registrator.transform(
+                fixed_image_path=fixed_image_path,
+                moving_image_path=self.steps[PreprocessorSteps.INPUT],
+                transformed_image_path=transformed,
+                matrix_path=[
+                    self.transformation_paths[
+                        PreprocessorSteps.COREGISTERED
+                    ],  # coregistration matrix
+                    transformation_matrix_path,  # atlas registration matrix
+                ],
+                log_file_path=transformed_log,
+            )
+        else:
+            registrator.transform(
+                fixed_image_path=fixed_image_path,
+                moving_image_path=self.current,
+                transformed_image_path=transformed,
+                matrix_path=transformation_matrix_path,
+                log_file_path=transformed_log,
+            )
+
         self.current = transformed
         self.steps[step] = transformed
+        self.transformation_paths[step] = self._find_transformation_matrix(
+            transform_incomplete_path=transformation_matrix_path
+        )
 
     def extract_brain_region(
         self,

{brainles_preprocessing-0.3.6 → brainles_preprocessing-0.4.0}/brainles_preprocessing/preprocessor.py

@@ -164,6 +164,7 @@ class Preprocessor:
         save_dir_atlas_correction: Optional[Union[str, Path]] = None,
         save_dir_brain_extraction: Optional[Union[str, Path]] = None,
         save_dir_defacing: Optional[Union[str, Path]] = None,
+        save_dir_transformations: Optional[Union[str, Path]] = None,
         log_file: Optional[Union[str, Path]] = None,
     ):
         """
@@ -176,6 +177,7 @@ class Preprocessor:
             save_dir_atlas_correction (str or Path, optional): Directory path to save intermediate atlas correction results.
             save_dir_brain_extraction (str or Path, optional): Directory path to save intermediate brain extraction results.
             save_dir_defacing (str or Path, optional): Directory path to save intermediate defacing results.
+            save_dir_transformations (str or Path, optional): Directory path to save transformation matrices. Defaults to None.
             log_file (str or Path, optional): Path to save the log file. Defaults to a timestamped file in the current directory.
 
         This method orchestrates the entire preprocessing workflow by sequentially performing:
@@ -250,6 +252,28 @@ class Preprocessor:
             save_dir_defacing=save_dir_defacing,
         )
 
+        # move to separate method
+        if save_dir_transformations:
+            save_dir_transformations = Path(save_dir_transformations)
+
+            # Save transformation matrices
+            logger.info(f"Saving transformation matrices to {save_dir_transformations}")
+            for modality in self.all_modalities:
+
+                modality_transformations_dir = (
+                    save_dir_transformations / modality.modality_name
+                )
+                modality_transformations_dir.mkdir(exist_ok=True, parents=True)
+                for step, path in modality.transformation_paths.items():
+                    if path is not None:
+                        shutil.copyfile(
+                            src=str(path.absolute()),
+                            dst=str(
+                                modality_transformations_dir
+                                / f"{step.value}_{path.name}"
+                            ),
+                        )
+
         # End
         logger.info(f"{' Preprocessing complete ':=^80}")
 

{brainles_preprocessing-0.3.6 → brainles_preprocessing-0.4.0}/brainles_preprocessing/registration/ANTs/ANTs.py

@@ -1,13 +1,28 @@
 # TODO add typing and docs
+from __future__ import annotations
+
 import datetime
 import shutil
 from pathlib import Path
-from typing import Any, Dict, Optional, Union
+from typing import Any, Dict, List, Optional, Union
 
 import ants
 
 from brainles_preprocessing.registration.registrator import Registrator
 
+VALID_INTERPOLATORS = [
+    "linear",
+    "nearestNeighbor",
+    "multiLabel",  # for label images (deprecated, prefer genericLabel)
+    "gaussian",
+    "bSpline",
+    "cosineWindowedSinc",
+    "welchWindowedSinc",
+    "hammingWindowedSinc",
+    "lanczosWindowedSinc",
+    "genericLabel",  # use this for label images
+]
+
 
 class ANTsRegistrator(Registrator):
     def __init__(
@@ -58,6 +73,9 @@ class ANTsRegistrator(Registrator):
             matrix_path (str or Path): Path to the transformation matrix (output).
             log_file_path (str or Path): Path to the log file.
             **kwargs: Additional registration parameters to update the instantiated defaults.
+
+        Raises:
+            FileNotFoundError: If the fixed or moving image paths do not exist.
         """
         start_time = datetime.datetime.now()
 
@@ -122,8 +140,9 @@ class ANTsRegistrator(Registrator):
         fixed_image_path: Union[str, Path],
         moving_image_path: Union[str, Path],
         transformed_image_path: Union[str, Path],
-        matrix_path: Union[str, Path],
+        matrix_path: str | Path | List[str | Path],
         log_file_path: Union[str, Path],
+        interpolator: str = "linear",
         **kwargs,
     ) -> None:
         """
@@ -133,12 +152,21 @@ class ANTsRegistrator(Registrator):
             fixed_image_path (str or Path): Path to the fixed image.
             moving_image_path (str or Path): Path to the moving image.
             transformed_image_path (str or Path): Path to the transformed image (output).
-            matrix_path (str or Path): Path to the transformation matrix.
+            matrix_path (str or Path or List[str | Path]): Path to the transformation matrix or a list of matrices.
             log_file_path (str or Path): Path to the log file.
+            interpolator (str): Interpolator to use for the transformation. Default is 'linear'.
             **kwargs: Additional transformation parameters to update the instantiated defaults.
+        Raises:
+            AssertionError: If the interpolator is not valid.
+            FileNotFoundError: If the fixed or moving image paths do not exist.
         """
         start_time = datetime.datetime.now()
 
+        assert interpolator in VALID_INTERPOLATORS, (
+            f"Invalid interpolator: {interpolator}. "
+            f"Valid options are: {', '.join(VALID_INTERPOLATORS)}."
+        )
+
         # TODO - self.transformation_params
         # we update the transformation parameters with the provided kwargs
         transform_kwargs = {**self.transformation_params, **kwargs}
@@ -147,7 +175,16 @@ class ANTsRegistrator(Registrator):
         fixed_image_path = Path(fixed_image_path)
         moving_image_path = Path(moving_image_path)
         transformed_image_path = Path(transformed_image_path)
-        matrix_path = Path(matrix_path)
+
+        if not isinstance(matrix_path, list):
+            matrix_path = [matrix_path]
+
+        matrix_path = [str(Path(p).with_suffix(".mat")) for p in matrix_path]
+
+        matrix_path = matrix_path[
+            ::-1
+        ]  # Ants expects the last matrix to be the first one applied
+
         log_file_path = Path(log_file_path)
 
         if not fixed_image_path.is_file():
@@ -161,14 +198,11 @@ class ANTsRegistrator(Registrator):
         # Ensure output directory exist
         transformed_image_path.parent.mkdir(parents=True, exist_ok=True)
 
-        # Ensure matrix_path has .mat suffix
-        if matrix_path.suffix != ".mat":
-            matrix_path = matrix_path.with_suffix(".mat")
-
         transformed_image = ants.apply_transforms(
             fixed=fixed_image,
             moving=moving_image,
-            transformlist=[str(matrix_path)],
+            transformlist=matrix_path,
+            interpolator=interpolator,
             **transform_kwargs,
         )
         ants.image_write(transformed_image, str(transformed_image_path))
@@ -183,12 +217,48 @@ class ANTsRegistrator(Registrator):
             fixed_image_path=fixed_image_path,
             moving_image_path=moving_image_path,
             transformed_image_path=transformed_image_path,
+            interpolator=interpolator,
             matrix_path=matrix_path,
             operation_name="transformation",
             start_time=start_time,
             end_time=end_time,
         )
 
+    def inverse_transform(
+        self,
+        fixed_image_path: Union[str, Path],
+        moving_image_path: Union[str, Path],
+        transformed_image_path: Union[str, Path],
+        matrix_path: str | Path | List[str | Path],
+        log_file_path: Union[str, Path],
+        interpolator: str = "linear",
+        **kwargs,
+    ) -> None:
+        """
+        Apply an inverse transformation using ANTs.
+
+        Args:
+            fixed_image_path (str or Path): Path to the fixed image.
+            moving_image_path (str or Path): Path to the moving image.
+            transformed_image_path (str or Path): Path to the transformed image (output).
+            matrix_path (str or Path): Path to the transformation matrix.
+            log_file_path (str or Path): Path to the log file.
+            interpolator (str): Interpolator to use for the transformation. Default is 'linear'.
+            **kwargs: Additional transformation parameters to update the instantiated defaults.
+        """
+        if not isinstance(matrix_path, list):
+            matrix_path = [matrix_path]
+        self.transform(
+            fixed_image_path=fixed_image_path,
+            moving_image_path=moving_image_path,
+            transformed_image_path=transformed_image_path,
+            matrix_path=matrix_path,
+            log_file_path=log_file_path,
+            whichtoinvert=[True] * len(matrix_path),  # Invert all matrices
+            interpolator=interpolator,
+            **kwargs,
+        )
+
     @staticmethod
     def _log_to_file(
         log_file_path: Union[str, Path],
@@ -199,6 +269,7 @@ class ANTsRegistrator(Registrator):
         operation_name: str,
         start_time: datetime.datetime,
         end_time: datetime.datetime,
+        interpolator: Optional[str] = None,
     ) -> None:
         """
         Log the operation details to a file.
@@ -212,6 +283,7 @@ class ANTsRegistrator(Registrator):
             operation_name (str): Name of the operation ('registration' or 'transformation').
             start_time (datetime.datetime): Start time of the operation.
             end_time (datetime.datetime): End time of the operation.
+            interpolator (Optional[str]): Interpolator used for the transformation, if applicable.
         """
 
         # Calculate the duration and make it human readable
@@ -231,27 +303,29 @@ class ANTsRegistrator(Registrator):
             f.write(f"fixed image: {fixed_image_path} \n")
             f.write(f"moving image: {moving_image_path} \n")
             f.write(f"transformed image: {transformed_image_path} \n")
+            if interpolator is not None:
+                f.write(f"interpolator: {interpolator} \n")
             f.write(f"matrix: {matrix_path} \n")
             f.write(f"end time: {end_time} \n")
             f.write(f"duration: {duration_formatted}\n")
 
 
-if __name__ == "__main__":
-    # TODO move this into unit tests
-    reg = ANTsRegistrator()
-
-    reg.register(
-        fixed_image_path="example/example_data/TCGA-DU-7294/AX_T1_POST_GD_FLAIR_TCGA-DU-7294_TCGA-DU-7294_GE_TCGA-DU-7294_AX_T1_POST_GD_FLAIR_RM_13_t1c.nii.gz",
-        moving_image_path="example/example_data/TCGA-DU-7294/AX_T2_FR-FSE_RF2_150_TCGA-DU-7294_TCGA-DU-7294_GE_TCGA-DU-7294_AX_T2_FR-FSE_RF2_150_RM_4_t2.nii.gz",
-        transformed_image_path="example/example_ants/transformed_image.nii.gz",
-        matrix_path="example/example_ants_matrix/matrix",
-        log_file_path="example/example_ants/log.txt",
-    )
-
-    reg.transform(
-        fixed_image_path="example/example_data/TCGA-DU-7294/AX_T1_POST_GD_FLAIR_TCGA-DU-7294_TCGA-DU-7294_GE_TCGA-DU-7294_AX_T1_POST_GD_FLAIR_RM_13_t1c.nii.gz",
-        moving_image_path="example/example_data/OtherEXampleFromTCIA/T1_AX_OtherEXampleTCIA_TCGA-FG-6692_Si_TCGA-FG-6692_T1_AX_SE_10_se2d1_t1.nii.gz",
-        transformed_image_path="example/example_ants_transformed/transformed_image.nii.gz",
-        matrix_path="example/example_ants_matrix/matrix.mat",
-        log_file_path="example/example_ants/log.txt",
-    )
+# if __name__ == "__main__":
+#     # TODO move this into unit tests
+#     reg = ANTsRegistrator()
+
+#     reg.register(
+#         fixed_image_path="example/example_data/TCGA-DU-7294/AX_T1_POST_GD_FLAIR_TCGA-DU-7294_TCGA-DU-7294_GE_TCGA-DU-7294_AX_T1_POST_GD_FLAIR_RM_13_t1c.nii.gz",
+#         moving_image_path="example/example_data/TCGA-DU-7294/AX_T2_FR-FSE_RF2_150_TCGA-DU-7294_TCGA-DU-7294_GE_TCGA-DU-7294_AX_T2_FR-FSE_RF2_150_RM_4_t2.nii.gz",
+#         transformed_image_path="example/example_ants/transformed_image.nii.gz",
+#         matrix_path="example/example_ants_matrix/matrix",
+#         log_file_path="example/example_ants/log.txt",
+#     )
+
+#     reg.transform(
+#         fixed_image_path="example/example_data/TCGA-DU-7294/AX_T1_POST_GD_FLAIR_TCGA-DU-7294_TCGA-DU-7294_GE_TCGA-DU-7294_AX_T1_POST_GD_FLAIR_RM_13_t1c.nii.gz",
+#         moving_image_path="example/example_data/OtherEXampleFromTCIA/T1_AX_OtherEXampleTCIA_TCGA-FG-6692_Si_TCGA-FG-6692_T1_AX_SE_10_se2d1_t1.nii.gz",
+#         transformed_image_path="example/example_ants_transformed/transformed_image.nii.gz",
+#         matrix_path="example/example_ants_matrix/matrix.mat",
+#         log_file_path="example/example_ants/log.txt",
+#     )

{brainles_preprocessing-0.3.6 → brainles_preprocessing-0.4.0}/brainles_preprocessing/registration/elastix/elastix.py

@@ -78,6 +78,8 @@ class ElastixRegistrator(Registrator):
         transformed_image_path: str,
         matrix_path: str,
         log_file_path: Optional[str] = None,
+        interpolator: str = "linear",
+        **kwargs
     ) -> None:
         """
         Apply a transformation using elastix.
@@ -117,3 +119,16 @@ class ElastixRegistrator(Registrator):
         default_rigid_parameter_map = parameter_object.GetDefaultParameterMap("rigid")
         parameter_object.AddParameterMap(default_rigid_parameter_map)
         return parameter_object
+
+    def inverse_transform(
+        self,
+        fixed_image_path: str,
+        moving_image_path: str,
+        transformed_image_path: str,
+        matrix_path: str,
+        log_file_path: Optional[str] = None,
+        interpolator: str = "linear",
+    ) -> None:
+        raise NotImplementedError(
+            "Inverse transform is not yet implemented for elastix"
+        )

{brainles_preprocessing-0.3.6 → brainles_preprocessing-0.4.0}/brainles_preprocessing/registration/greedy/greedy.py

@@ -57,8 +57,9 @@ class GreedyRegistrator(Registrator):
         moving_image_path: str,
         transformed_image_path: str,
         matrix_path: str,
-        interpolator: Optional[str] = "LINEAR",
         log_file_path: Optional[str] = None,
+        interpolator: str = "LINEAR",
+        **kwargs: Optional[dict],
     ) -> None:
         """
         Apply a transformation using greedy.
@@ -68,8 +69,8 @@ class GreedyRegistrator(Registrator):
             moving_image_path (str): Path to the moving image.
             transformed_image_path (str): Path to the transformed image (output).
             matrix_path (str): Path to the transformation matrix (output). This gets overwritten if it already exists.
-            interpolator (Optional[str]): The interpolator to use; one of NN, LINEAR or LABEL.
             log_file_path (Optional[str]): Path to the log file, which is not used.
+            interpolator (Optional[str]): The interpolator to use; one of NN, LINEAR or LABEL. Defaults to LINEAR.
         """
         registor = Greedy3D()
         interpolator_upper = interpolator.upper()
@@ -94,3 +95,16 @@ class GreedyRegistrator(Registrator):
                     registor.execute(command_to_run)
         else:
             registor.execute(command_to_run)
+
+    def inverse_transform(
+        self,
+        fixed_image_path: str,
+        moving_image_path: str,
+        transformed_image_path: str,
+        matrix_path: str,
+        log_file_path: Optional[str] = None,
+        interpolator: str = "linear",
+    ) -> None:
+        raise NotImplementedError(
+            "Inverse transform is not yet implemented for greedy."
+        )