brainles-preprocessing 0.6.4__tar.gz → 0.6.6__tar.gz

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: brainles_preprocessing
-Version: 0.6.4
+Version: 0.6.6
 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

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/brainles_preprocessing/modality.py

@@ -139,7 +139,9 @@ class Modality:
         else:
             self.normalized_defaced_output_path = None
 
-        self.steps = {k: None for k in PreprocessorSteps}
+        self.steps: Dict[PreprocessorSteps, Path | None] = {
+            k: None for k in PreprocessorSteps
+        }
         self.steps[PreprocessorSteps.INPUT] = self.input_path
 
     @property
@@ -265,7 +267,7 @@ class Modality:
             moving_image_path=self.current,
             transformed_image_path=registered,
             matrix_path=registered_matrix,
-            log_file_path=registered_log,
+            log_file_path=str(registered_log),
         )
         self.current = registered
         self.steps[step] = registered
@@ -394,24 +396,24 @@ class Modality:
             ), "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,
+                fixed_image_path=str(fixed_image_path),
+                moving_image_path=str(self.steps[PreprocessorSteps.INPUT]),
+                transformed_image_path=str(transformed),
                 matrix_path=[
                     self.transformation_paths[
                         PreprocessorSteps.COREGISTERED
                     ],  # coregistration matrix
                     transformation_matrix_path,  # atlas registration matrix
                 ],
-                log_file_path=transformed_log,
+                log_file_path=str(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,
+                fixed_image_path=str(fixed_image_path),
+                moving_image_path=str(self.current),
+                transformed_image_path=str(transformed),
+                matrix_path=str(transformation_matrix_path),
+                log_file_path=str(transformed_log),
             )
 
         self.current = transformed
@@ -638,6 +640,12 @@ class CenterModality(Modality):
 
         if self.bet:
             self.current = bet
+
+        if self.bet_mask_output_path:
+            self.save_mask(
+                mask_path=mask_path,
+                output_path=self.bet_mask_output_path,
+            )
         return mask_path
 
     def deface(
@@ -684,7 +692,7 @@ class CenterModality(Modality):
                     moving_image_path=self.steps[PreprocessorSteps.BET],
                     transformed_image_path=atlas_bet,
                     matrix_path=atlas_bet_M,
-                    log_file_path=defaced_dir_path / "atlas_bet.log",
+                    log_file_path=str(defaced_dir_path / "atlas_bet.log"),
                 )
 
                 deface_mask_atlas = defaced_dir_path / "deface_mask_atlas.nii.gz"
@@ -706,6 +714,12 @@ class CenterModality(Modality):
                     mask_image_path=mask_path,
                 )
 
+            if self.defacing_mask_output_path:
+                self.save_mask(
+                    mask_path=mask_path,
+                    output_path=self.defacing_mask_output_path,
+                )
+
             return mask_path
         else:
             logger.warning(

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/brainles_preprocessing/normalization/normalizer_base.py

@@ -1,4 +1,5 @@
 from abc import ABC, abstractmethod
+from numpy.typing import NDArray
 
 
 class Normalizer(ABC):
@@ -10,7 +11,7 @@ class Normalizer(ABC):
         super().__init__()
 
     @abstractmethod
-    def normalize(self, image):
+    def normalize(self, image) -> NDArray:
         """
         Normalize the input image based on the chosen method.
 

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/brainles_preprocessing/normalization/percentile_normalizer.py

@@ -1,5 +1,6 @@
 import numpy as np
 from .normalizer_base import Normalizer
+from numpy.typing import NDArray
 
 
 class PercentileNormalizer(Normalizer):
@@ -29,7 +30,7 @@ class PercentileNormalizer(Normalizer):
         self.lower_limit = lower_limit
         self.upper_limit = upper_limit
 
-    def normalize(self, image: np.ndarray):
+    def normalize(self, image: np.ndarray) -> NDArray:
         """
         Normalize the input image using percentile-based mapping.
 

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/brainles_preprocessing/normalization/windowing_normalizer.py

@@ -1,5 +1,6 @@
 import numpy as np
 from .normalizer_base import Normalizer
+from numpy.typing import NDArray
 
 
 class WindowingNormalizer(Normalizer):
@@ -19,7 +20,7 @@ class WindowingNormalizer(Normalizer):
         self.center = center
         self.width = width
 
-    def normalize(self, image):
+    def normalize(self, image) -> NDArray:
         """
         Normalize the input image using windowing.
 

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/brainles_preprocessing/preprocessor/atlas_centric_preprocessor.py

@@ -323,29 +323,34 @@ class AtlasCentricPreprocessor(BasePreprocessor):
         atlas_mask = self.center_modality.deface(
             defacer=self.defacer, defaced_dir_path=deface_dir
         )
-        # looping over _all_ modalities since .deface is no applying the computed mask
-        for moving_modality in self.all_modalities:
-            logger.info(f"Applying deface mask to {moving_modality.modality_name}...")
-            moving_modality.apply_deface_mask(
-                defacer=self.defacer,
-                mask_path=atlas_mask,
-                deface_dir=deface_dir,
-            )
-
-        self._save_output(
-            src=deface_dir,
-            save_dir=save_dir_defacing,
-        )
-        # now we save images that are skull-stripped
-        logger.info("Saving defaced images...")
-        for modality in self.all_modalities:
-            if modality.raw_defaced_output_path:
-                modality.save_current_image(
-                    modality.raw_defaced_output_path,
-                    normalization=False,
+        if atlas_mask is not None:
+            # looping over _all_ modalities since .deface is no applying the computed mask
+            for moving_modality in self.all_modalities:
+                logger.info(
+                    f"Applying deface mask to {moving_modality.modality_name}..."
                 )
-            if modality.normalized_defaced_output_path:
-                modality.save_current_image(
-                    modality.normalized_defaced_output_path,
-                    normalization=True,
+                moving_modality.apply_deface_mask(
+                    defacer=self.defacer,
+                    mask_path=atlas_mask,
+                    deface_dir=deface_dir,
                 )
+
+            self._save_output(
+                src=deface_dir,
+                save_dir=save_dir_defacing,
+            )
+            # now we save images that are skull-stripped
+            logger.info("Saving defaced images...")
+            for modality in self.all_modalities:
+                if modality.raw_defaced_output_path:
+                    modality.save_current_image(
+                        modality.raw_defaced_output_path,
+                        normalization=False,
+                    )
+                if modality.normalized_defaced_output_path:
+                    modality.save_current_image(
+                        modality.normalized_defaced_output_path,
+                        normalization=True,
+                    )
+        else:
+            logger.warning("Defacing was requested but no defacing mask was created.")

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/brainles_preprocessing/registration/ANTs/ANTs.py

@@ -101,24 +101,30 @@ class ANTsRegistrator(Registrator):
 
         fixed_image = ants.image_read(str(fixed_image_path))
         moving_image = ants.image_read(str(moving_image_path))
+
         registration_result = ants.registration(
             fixed=fixed_image,
             moving=moving_image,
             **registration_kwargs,
         )
-        transformed_image = registration_result["warpedmovout"]
 
         # Ensure output directories exist
         transformed_image_path.parent.mkdir(parents=True, exist_ok=True)
         matrix_path.parent.mkdir(parents=True, exist_ok=True)
 
-        ants.image_write(transformed_image, str(transformed_image_path))
-
         shutil.copyfile(
             src=registration_result["fwdtransforms"][0],
             dst=str(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,
+        )
+
         end_time = datetime.datetime.now()
 
         # TODO nicer logging
@@ -147,6 +153,7 @@ class ANTsRegistrator(Registrator):
     ) -> None:
         """
         Apply a transformation using ANTs.
+        By default the padding value corresponds to the minimum of the moving image. Can be adjusted using the defaultvalue parameter.
 
         Args:
             fixed_image_path (str or Path): Path to the fixed image.
@@ -195,6 +202,11 @@ class ANTsRegistrator(Registrator):
         fixed_image = ants.image_read(str(fixed_image_path))
         moving_image = ants.image_read(str(moving_image_path))
 
+        if "defaultvalue" not in transform_kwargs:
+            transform_kwargs["defaultvalue"] = (
+                moving_image.min()
+            )  # set out of view voxels by default to min value, i.e. air/ bg
+
         # Ensure output directory exist
         transformed_image_path.parent.mkdir(parents=True, exist_ok=True)
 

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/brainles_preprocessing/registration/niftyreg/niftyreg.py

@@ -8,6 +8,7 @@ from typing import List
 import numpy as np
 from auxiliary.runscript import ScriptRunner
 from auxiliary.turbopath import turbopath
+from auxiliary.io import read_image
 
 from brainles_preprocessing.registration.registrator import Registrator
 
@@ -79,12 +80,16 @@ class NiftyRegRegistrator(Registrator):
 
         matrix_path = Path(matrix_path).with_suffix(".txt")
 
+        # read moving image to get padding value
+        padding_value = float(read_image(moving_image_path).min())
+
         input_params = [
             turbopath(niftyreg_executable),
             turbopath(fixed_image_path),
             turbopath(moving_image_path),
             turbopath(transformed_image_path),
             str(matrix_path),
+            str(padding_value),
         ]
 
         # Call the run method to execute the script and capture the output in the log file
@@ -155,6 +160,7 @@ class NiftyRegRegistrator(Registrator):
     ) -> None:
         """
         Apply a transformation using NiftyReg.
+        By default the padding value corresponds to the minimum of the moving image.
 
         Args:
             fixed_image_path (str): Path to the fixed image.
@@ -199,13 +205,17 @@ class NiftyRegRegistrator(Registrator):
         else:
             transform_path = Path(matrix_path).with_suffix(".txt")
 
+        # read moving image to get padding value
+        padding_value = float(read_image(moving_image_path).min())
+
         input_params = [
             turbopath(niftyreg_executable),
             turbopath(fixed_image_path),
             turbopath(moving_image_path),
             turbopath(transformed_image_path),
             str(transform_path),
-            interpolator,  # interpolation method, 3 is Cubic
+            str(interpolator),  # interpolation method, 3 is Cubic
+            str(padding_value),
         ]
 
         # Call the run method to execute the script and capture the output in the log file

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/brainles_preprocessing/registration/niftyreg/niftyreg_scripts/rigid_reg.sh

@@ -10,8 +10,8 @@ file_exists() {
 }
 
 # Check if the correct number of arguments is provided
-if [ "$#" -ne 5 ]; then
-    echo "Usage: $0 <niftyreg_executable> <fixed_image> <moving_image> <transformed_image> <transformation_matrix>"
+if [ "$#" -ne 6 ]; then
+    echo "Usage: $0 <niftyreg_executable> <fixed_image> <moving_image> <transformed_image> <transformation_matrix> <padding_value>"
     exit 1
 fi
 
@@ -21,6 +21,7 @@ fixed_image="$2"
 moving_image="$3"
 transformed_image="$4"
 transformation_matrix="$5"
+padding_value="$6"
 
 # Validate the existence of input files
 if ! file_exists "$fixed_image"; then
@@ -41,6 +42,7 @@ registration_options=(
     "-flo" "$moving_image"
     "-res" "$transformed_image"
     "-aff" "$transformation_matrix"
+    "-pad" "$padding_value"
 )
 
 # Perform rigid-only registration with NiftyReg

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/brainles_preprocessing/registration/niftyreg/niftyreg_scripts/transform.sh

@@ -10,8 +10,8 @@ file_exists() {
 }
 
 # Check if the correct number of arguments is provided
-if [ "$#" -ne 6 ]; then
-    echo "Usage: $0 <niftyreg_executable> <fixed_image> <moving_image> <transformed_image> <transformation_matrix> <interpolation_method>"
+if [ "$#" -ne 7 ]; then
+    echo "Usage: $0 <niftyreg_executable> <fixed_image> <moving_image> <transformed_image> <transformation_matrix> <interpolation_method> <padding_value>"
     exit 1
 fi
 
@@ -22,6 +22,7 @@ moving_image="$3"
 transformed_image="$4"
 transformation_matrix="$5"
 interpolation_method="$6"
+padding_value="$7"
 
 # Validate the existence of input files
 if ! file_exists "$fixed_image"; then
@@ -51,6 +52,7 @@ resample_command=(
     -trans "$transformation_matrix"
     -res "$transformed_image"
     -inter "$interpolation_method"
+    -pad "$padding_value"
 )
 
 if file_exists "$niftyreg_path"; then

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/brainles_preprocessing/registration/registrator.py

@@ -36,7 +36,7 @@ class Registrator(ABC):
         transformed_image_path: Any,
         matrix_path: Any,
         log_file_path: str,
-        interpolator: str,
+        interpolator: str = "default",
         **kwargs
     ):
         """
@@ -61,7 +61,7 @@ class Registrator(ABC):
         transformed_image_path: Any,
         matrix_path: Any,
         log_file_path: str,
-        interpolator: str,
+        interpolator: str = "default",
     ):
         """
         Abstract method for inverse transforming images.

{brainles_preprocessing-0.6.4 → brainles_preprocessing-0.6.6}/pyproject.toml

@@ -14,7 +14,7 @@ exclude = [
 ]
 
 name = "brainles_preprocessing"
-version = "0.6.4"                                                                                                              # will be overwritten by poetry-dynamic-versioning but needs to be set
+version = "0.6.6"                                                                                                              # will be overwritten by poetry-dynamic-versioning but needs to be set
 description = "Tool for preprocessing tasks in biomedical imaging, with a focus on (but not limited to) multi-modal brain MRI"
 license = "Apache-2.0"