petpal 0.5.5__py3-none-any.whl → 0.5.7__py3-none-any.whl

petpal/preproc/image_operations_4d.py

@@ -17,22 +17,19 @@ TODO:
     *   (stitch_broken_scans) Assumes non-BIDS key 'DecayFactor' instead of BIDS-required 'DecayCorrectionFactor' for
         ease-of-use with NIL data. Should be changed in the future.
     *   (stitch_broken_scans) Currently writes intermediate files even if output_image_path is None.
-    *   (suvr) Allow list to be passed as ref_region to use multiple regions together as a reference region (i.e. left
-        and right cerebellum gray matter).
 
 """
-import os
 import pathlib
 import datetime
-import tempfile
 import ants
 import nibabel
 import numpy as np
 from scipy.ndimage import center_of_mass
 
-from ..utils.useful_functions import weighted_series_sum
+from .motion_target import determine_motion_target
+
 from ..utils import image_io, math_lib
-from ..preproc.decay_correction import undo_decay_correction, decay_correct
+from .decay_correction import undo_decay_correction, decay_correct
 
 def stitch_broken_scans(input_image_path: str,
                         output_image_path: str,
@@ -220,112 +217,18 @@ def rescale_image(input_image: ants.core.ANTsImage, rescale_constant: float, op:
         return input_image * rescale_constant
 
 
-def determine_motion_target(motion_target_option: str | tuple | list,
-                            input_image_4d_path: str = None,
-                            half_life: float = None) -> str:
-    """
-    Produce a motion target given the ``motion_target_option`` from a method
-    running registrations on PET, i.e. :meth:`motion_correction` or
-    :meth:`register_pet`.
-
-    The motion target option can be a string or a tuple. If it is a string,
-    then if this string is a file, use the file as the motion target.
-
-    If it is the option ``weighted_series_sum``, then run
-    :meth:`weighted_series_sum` and return the output path.
-
-    If it is the option ``mean_image``, then compute the time-average of the
-    4D-PET image.
-
-    If it is a tuple, run a weighted sum on the PET series on a range of
-    frames. The elements of the tuple are treated as times in seconds, counted
-    from the time of the first frame, i.e. (0,300) would average all frames
-    from the first to the frame 300 seconds later. If the two elements are the
-    same, returns the one frame closest to the entered time.
-
-    Args:
-        motion_target_option (str | tuple | list): Determines how the method behaves,
-            according to the above description. Can be a file, a method
-            ('weighted_series_sum' or 'mean_image'), or a tuple range e.g. (0,600).
-        input_image_4d_path (str): Path to the PET image. This is intended to
-            be supplied by the parent method employing this function. Default
-            value None.
-        half_life (float): Half life of the radiotracer used in the image
-            located at ``input_image_4d_path``. Only used if a calculation is
-            performed.
-
-    Returns:
-        out_image_file (str): File to use as a target to compute
-            transformations on.
-
-    Raises:
-        ValueError: If ``motion_target_option`` does not match an acceptable option, or if 
-        ``half_life`` is not specifiedwhen ``motion_target_option`` is not 'mean_image'
-        TypeError: If start and end time are incompatible with ``float`` type.
-    """
-    if motion_target_option != 'mean_image' and half_life is None:
-        raise ValueError('half_life must be specified if not using "mean_image" for motion_target_option')
-
-    if isinstance(motion_target_option, str):
-        if os.path.exists(motion_target_option):
-            return motion_target_option
-
-        if motion_target_option == 'weighted_series_sum':
-            out_image_file = tempfile.mkstemp(suffix='_wss.nii.gz')[1]
-            weighted_series_sum(input_image_4d_path=input_image_4d_path,
-                                out_image_path=out_image_file,
-                                half_life=half_life,
-                                verbose=False)
-            return out_image_file
-
-        if motion_target_option == 'mean_image':
-            out_image_file = tempfile.mkstemp(suffix='_mean.nii.gz')[1]
-            input_img = ants.image_read(input_image_4d_path)
-            mean_img = get_average_of_timeseries(input_image=input_img)
-            ants.image_write(image=mean_img,filename=out_image_file)
-            return out_image_file
-
-        raise ValueError("motion_target_option did not match a file or 'weighted_series_sum'")
-
-    if isinstance(motion_target_option, (list, tuple)):
-
-        start_time = motion_target_option[0]
-        end_time = motion_target_option[1]
-
-        try:
-            float(start_time)
-            float(end_time)
-        except Exception as exc:
-            raise TypeError('Start time and end time of calculation must be '
-                            'able to be cast into float! Provided values are '
-                            f"{start_time} and {end_time}.") from exc
-
-        out_image_file = tempfile.mkstemp(suffix='_wss.nii.gz')[1]
-        weighted_series_sum(input_image_4d_path=input_image_4d_path,
-                            out_image_path=out_image_file,
-                            half_life=half_life,
-                            verbose=False,
-                            start_time=float(start_time),
-                            end_time=float(end_time))
-
-        return out_image_file
-
-    raise ValueError('motion_target_option did not match str or tuple type.')
-
-
-def brain_mask(input_image_4d_path: str,
+def brain_mask(input_image_path: str,
                out_image_path: str,
                atlas_image_path: str,
                atlas_mask_path: str,
-               motion_target_option='mean_image',
-               half_life: float=None):
+               motion_target_option='mean_image'):
     """
     Create a brain mask for a PET image. Create target PET image, which is then warped to a
     provided anatomical atlas. The transformation to atlas space is then applied to transform a
     provided mask in atlas space into PET space. This mask can then by used in various operations.
 
     Args:
-        input_image_4d_path (str): Path to input 4D PET image.
+        input_image_path (str): Path to input 4D PET image.
         out_image_path (str): Path to which brain mask in PET space is written.
         atlas_image_path (str): Path to anatomical atlas image.
         atlas_mask_path (str): Path to brain mask in atlas space.
@@ -338,11 +241,9 @@ def brain_mask(input_image_4d_path: str,
     """
     atlas = ants.image_read(atlas_image_path)
     atlas_mask = ants.image_read(atlas_mask_path)
-    pet_ref = ants.image_read(determine_motion_target(
-        motion_target_option=motion_target_option,
-        input_image_4d_path=input_image_4d_path,
-        half_life=half_life
-    ))
+    motion_target = determine_motion_target(motion_target_option=motion_target_option,
+                                            input_image_path=input_image_path)
+    pet_ref = ants.image_read(motion_target)
     xfm = ants.registration(
         fixed=atlas,
         moving=pet_ref,
@@ -370,7 +271,7 @@ def extract_mean_roi_tac_from_nifti_using_segmentation(input_image_4d_numpy: np.
     regional values. Currently, only the mean over a single region value is implemented.
 
     Args:
-        input_image_4d_path (str): Path to a .nii or .nii.gz file containing a 4D
+        input_image_path (str): Path to a .nii or .nii.gz file containing a 4D
             PET image, registered to anatomical space.
         segmentation_image_path (str): Path to a .nii or .nii.gz file containing a 3D segmentation
             image, where integer indices label specific regions. Must have same sampling as PET
@@ -447,71 +348,6 @@ def binarize_image_with_threshold(input_image_numpy: np.ndarray,
     return bounded_image
 
 
-def get_average_of_timeseries(input_image: ants.ANTsImage):
-    """
-    Get average of a 4D ANTsImage and return as a 3D ANTsImage.
-    """
-    assert len(input_image.shape) == 4, "Input image must be 4D"
-    mean_array = input_image.mean(axis=-1)
-    mean_image = ants.from_numpy(data=mean_array,
-                                 origin=input_image.origin[:-1],
-                                 spacing=input_image.spacing[:-1],
-                                 direction=input_image.direction[:-1,:-1])
-    return mean_image
-
-
-def suvr(input_image_path: str,
-         out_image_path: str | None,
-         segmentation_image_path: str,
-         ref_region: int,
-         verbose: bool=False) -> ants.ANTsImage:
-    """
-    Computes an ``SUVR`` (Standard Uptake Value Ratio) by taking the average of
-    an input image within a reference region, and dividing the input image by
-    said average value.
-
-    Args:
-        input_image_path (str): Path to 3D weighted series sum or other
-            parametric image on which we compute SUVR.
-        out_image_path (str): Path to output image file which is written to. If None, no output is written.
-        segmentation_image_path (str): Path to segmentation image, which we use
-            to compute average uptake value in the reference region.
-        ref_region (int): Region number mapping to the reference region in the
-            segmentation image.
-        verbose (bool): Set to ``True`` to output processing information. Default is False.
-
-    Returns:
-        ants.ANTsImage: SUVR parametric image
-    """
-    pet_img = ants.image_read(filename=input_image_path)
-    pet_arr = pet_img.numpy()
-    segmentation_img = ants.image_read(filename=segmentation_image_path,
-                                        pixeltype='unsigned int')
-    segmentation_arr = segmentation_img.numpy()
-
-    if len(pet_arr.shape)!=3:
-        raise ValueError("SUVR input image is not 3D. If your image is dynamic, try running 'weighted_series_sum'"
-                         " first.")
-
-    ref_region_avg = extract_mean_roi_tac_from_nifti_using_segmentation(input_image_4d_numpy=pet_arr,
-                                                                        segmentation_image_numpy=segmentation_arr,
-                                                                        region=ref_region,
-                                                                        verbose=verbose)
-    
-    suvr_arr = pet_arr / ref_region_avg[0]
-
-    out_img = ants.from_numpy_like(data=suvr_arr,
-                                     image=pet_img)
-
-    if out_image_path is not None:
-        ants.image_write(image=out_img,
-                         filename=out_image_path)
-        image_io.safe_copy_meta(input_image_path=input_image_path,
-                                out_image_path=out_image_path)
-
-    return out_img
-
-
 def gauss_blur(input_image_path: str,
                blur_size_mm: float,
                out_image_path: str,
@@ -556,7 +392,7 @@ def gauss_blur(input_image_path: str,
     return out_image
 
 
-def roi_tac(input_image_4d_path: str,
+def roi_tac(input_image_path: str,
             roi_image_path: str,
             region: int,
             out_tac_path: str,
@@ -573,9 +409,9 @@ def roi_tac(input_image_4d_path: str,
         raise ValueError("'time_frame_keyword' must be one of "
                          "'FrameReferenceTime' or 'FrameTimesStart'")
 
-    pet_meta = image_io.load_metadata_for_nifti_with_same_filename(input_image_4d_path)
+    pet_meta = image_io.load_metadata_for_nifti_with_same_filename(input_image_path)
     tac_extraction_func = extract_mean_roi_tac_from_nifti_using_segmentation
-    pet_numpy = nibabel.load(input_image_4d_path).get_fdata()
+    pet_numpy = nibabel.load(input_image_path).get_fdata()
     seg_numpy = nibabel.load(roi_image_path).get_fdata()
 
 

petpal/preproc/motion_corr.py

@@ -7,20 +7,21 @@ registration.
 import ants
 import numpy as np
 
+from petpal.utils.useful_functions import gen_nd_image_based_on_image_list
 
-from .image_operations_4d import determine_motion_target
+
+from .motion_target import determine_motion_target
 from ..utils import image_io
 from ..utils.scan_timing import ScanTimingInfo, get_window_index_pairs_for_image
 from ..utils.useful_functions import weighted_series_sum_over_window_indecies
 from ..utils.image_io import get_half_life_from_nifti
 
 
-def motion_corr(input_image_4d_path: str,
+def motion_corr(input_image_path: str,
                 motion_target_option: str | tuple,
                 out_image_path: str,
                 verbose: bool,
                 type_of_transform: str = 'DenseRigid',
-                half_life: float = None,
                 **kwargs) -> tuple[np.ndarray, list[str], list[float]]:
     """
     Correct PET image series for inter-frame motion. Runs rigid motion
@@ -28,7 +29,7 @@ def motion_corr(input_image_4d_path: str,
     inputs.
 
     Args:
-        input_image_4d_path (str): Path to a .nii or .nii.gz file containing a 4D
+        input_image_path (str): Path to a .nii or .nii.gz file containing a 4D
             PET image to be motion corrected.
         motion_target_option (str | tuple): Target image for computing
             transformation. See :meth:`determine_motion_target`.
@@ -40,8 +41,6 @@ def motion_corr(input_image_4d_path: str,
             'Translation'. Any transformation type that uses >6 degrees of
             freedom is not recommended, use with caution. See
             :py:func:`ants.registration`.
-        half_life (float): Half life of the PET radioisotope in seconds. Used
-            for certain settings of ``motion_target_option``.
         kwargs (keyword arguments): Additional arguments passed to
             :py:func:`ants.motion_correction`.
 
@@ -53,10 +52,9 @@ def motion_corr(input_image_4d_path: str,
         pet_moco_fd (list[float]): List of framewise displacement measure
             corresponding to each frame transform.
     """
-    pet_ants = ants.image_read(input_image_4d_path)
+    pet_ants = ants.image_read(input_image_path)
     motion_target_image_path = determine_motion_target(motion_target_option=motion_target_option,
-                                                       input_image_4d_path=input_image_4d_path,
-                                                       half_life=half_life)
+                                                       input_image_path=input_image_path)
 
     motion_target_image = ants.image_read(motion_target_image_path)
     pet_moco_ants_dict = ants.motion_correction(image=pet_ants,
@@ -71,21 +69,20 @@ def motion_corr(input_image_4d_path: str,
     pet_moco_fd = pet_moco_ants_dict['FD']
     pet_moco_np = pet_moco_ants.numpy()
     ants.image_write(image=pet_moco_ants,filename=out_image_path)
-    image_io.safe_copy_meta(input_image_path=input_image_4d_path, out_image_path=out_image_path)
+    image_io.safe_copy_meta(input_image_path=input_image_path, out_image_path=out_image_path)
 
     if verbose:
         print(f"(ImageOps4d): motion corrected image saved to {out_image_path}")
     return pet_moco_np, pet_moco_params, pet_moco_fd
 
 
-def motion_corr_frame_list(input_image_4d_path: str,
+def motion_corr_frame_list(input_image_path: str,
                            motion_target_option: str | tuple,
                            out_image_path: str,
                            verbose: bool,
                            frames_list: list = None,
                            type_of_transform: str = 'Affine',
                            transform_metric: str = 'mattes',
-                           half_life: float = None,
                            **kwargs):
     r"""
     Perform per-frame motion correction on a 4D PET image.
@@ -94,7 +91,7 @@ def motion_corr_frame_list(input_image_4d_path: str,
     motion target. Only the frames in ``frames_list`` are motion corrected, all else are kept as is.
 
     Args:
-        input_image_4d_path (str): Path to the input 4D PET image file.
+        input_image_path (str): Path to the input 4D PET image file.
         motion_target_option (str | tuple): Option to determine the motion target. This can
             be a path to a specific image file, a tuple of frame indices to generate a target, or
             specific options recognized by :func:`determine_motion_target`.
@@ -106,8 +103,6 @@ def motion_corr_frame_list(input_image_4d_path: str,
             is 'Affine'.
         transform_metric (str, optional): Metric to use for the transformation. Default is
             'mattes'.
-        half_life (float, optional): Half-life value used by `determine_motion_target` if
-            applicable. Default is None.
         **kwargs: Additional arguments passed to the `ants.registration` method.
 
     Returns:
@@ -119,7 +114,7 @@ def motion_corr_frame_list(input_image_4d_path: str,
 
             from petpal.preproc.motion_corr import motion_corr_frame_list
 
-            motion_corr_frame_list(input_image_4d_path='/path/to/image.nii.gz',
+            motion_corr_frame_list(input_image_path='/path/to/image.nii.gz',
                                   motion_target_option='/path/to/target_image.nii.gz',
                                   out_image_path='/path/to/output_motion_corrected.nii.gz',
                                   verbose=True)
@@ -134,11 +129,10 @@ def motion_corr_frame_list(input_image_4d_path: str,
             path.
 
     """
-    input_image = ants.image_read(input_image_4d_path)
+    input_image = ants.image_read(input_image_path)
 
     motion_target_path = determine_motion_target(motion_target_option=motion_target_option,
-                                                 input_image_4d_path=input_image_4d_path,
-                                                 half_life=half_life)
+                                                 input_image_path=input_image_path)
     motion_target = ants.image_read(motion_target_path)
 
     frames_to_correct = np.zeros(input_image.shape[-1], dtype=bool)
@@ -182,15 +176,14 @@ def motion_corr_frame_list(input_image_4d_path: str,
         print(f"(ImageOps4d): motion corrected image saved to {out_image_path}")
 
 
-def motion_corr_frame_list_to_t1(input_image_4d_path: str,
+def motion_corr_frame_list_to_t1(input_image_path: str,
                                  t1_image_path: str,
                                  motion_target_option: str | tuple,
                                  out_image_path: str,
                                  verbose: bool,
                                  frames_list: list = None,
                                  type_of_transform: str = 'AffineFast',
-                                 transform_metric: str = "mattes",
-                                 half_life: float = None):
+                                 transform_metric: str = "mattes"):
     r"""
     Perform motion correction of a 4D PET image to a T1 anatomical image.
 
@@ -203,7 +196,7 @@ def motion_corr_frame_list_to_t1(input_image_4d_path: str,
     transformed to the motion-target in T1-space.
 
     Args:
-        input_image_4d_path (str): Path to the 4D PET image to be corrected.
+        input_image_path (str): Path to the 4D PET image to be corrected.
         t1_image_path (str): Path to the 3D T1 anatomical image.
         motion_target_option (str | tuple): Option for selecting the motion target image.
             Can be a path to a file or a tuple range. If None, the average of the PET timeseries
@@ -215,8 +208,6 @@ def motion_corr_frame_list_to_t1(input_image_4d_path: str,
         type_of_transform (str): Type of transformation used in registration. Default is
             'AffineFast'.
         transform_metric (str): Metric for transformation optimization. Default is 'mattes'.
-        half_life (float, optional): Half-life of the PET radioisotope. Used if a calculation
-            is required for the motion target.
 
     Returns:
         None
@@ -230,7 +221,7 @@ def motion_corr_frame_list_to_t1(input_image_4d_path: str,
         .. code-block:: python
 
 
-            motion_corr_frame_list_to_t1(input_image_4d_path='pet_timeseries.nii.gz',
+            motion_corr_frame_list_to_t1(input_image_path='pet_timeseries.nii.gz',
                               t1_image_path='t1_image.nii.gz',
                               motion_target_option='mean_image',
                               out_image_path='pet_corrected.nii.gz',
@@ -238,12 +229,11 @@ def motion_corr_frame_list_to_t1(input_image_4d_path: str,
 
     """
 
-    input_image = ants.image_read(input_image_4d_path)
+    input_image = ants.image_read(input_image_path)
     t1_image = ants.image_read(t1_image_path)
 
     motion_target_path = determine_motion_target(motion_target_option=motion_target_option,
-                                                 input_image_4d_path=input_image_4d_path,
-                                                 half_life=half_life)
+                                                 input_image_path=input_image_path)
     motion_target = ants.image_read(motion_target_path)
 
     motion_target_to_mpr_reg = ants.registration(fixed=t1_image,
@@ -297,13 +287,12 @@ def motion_corr_frame_list_to_t1(input_image_4d_path: str,
         print(f"(ImageOps4d): motion corrected image saved to {out_image_path}")
 
 
-def motion_corr_frames_above_mean_value(input_image_4d_path: str,
+def motion_corr_frames_above_mean_value(input_image_path: str,
                                         out_image_path: str,
                                         motion_target_option: str | tuple,
                                         verbose: bool,
                                         type_of_transform: str = 'Affine',
                                         transform_metric: str = 'mattes',
-                                        half_life: float = None,
                                         scale_factor=1.0,
                                         **kwargs):
     r"""
@@ -314,7 +303,7 @@ def motion_corr_frames_above_mean_value(input_image_4d_path: str,
     utilizes the :func:`motion_corr_frame_list` function to perform the motion correction.
 
     Args:
-        input_image_4d_path (str): Path to the input 4D PET image file.
+        input_image_path (str): Path to the input 4D PET image file.
         motion_target_option (str | tuple): Option to determine the motion target. This can
             be a path to a specific image file, a tuple of frame indices to generate a target, or
             specific options recognized by :func:`determine_motion_target`.
@@ -324,8 +313,6 @@ def motion_corr_frames_above_mean_value(input_image_4d_path: str,
             Default is 'Affine'.
         transform_metric (str, optional): Metric to use for the transformation. Default is
             'mattes'.
-        half_life (float, optional): Half-life value used by `determine_motion_target`, if
-            applicable. Default is None.
         scale_factor (float, optional): Scale factor to apply to frame mean values before
             comparison. Default is 1.0.
         **kwargs: Additional arguments passed to the `ants.registration` method.
@@ -339,7 +326,7 @@ def motion_corr_frames_above_mean_value(input_image_4d_path: str,
 
             from petpal.preproc.motion_corr import motion_corr_frames_above_mean_value
 
-            motion_corr_frames_above_mean_value(input_image_4d_path='/path/to/image.nii.gz',
+            motion_corr_frames_above_mean_value(input_image_path='/path/to/image.nii.gz',
                                                 motion_target_option='/path/to/target_image.nii.gz',
                                                 out_image_path='/path/to/output_motion_corrected.nii.gz',
                                                 verbose=True,
@@ -356,28 +343,26 @@ def motion_corr_frames_above_mean_value(input_image_4d_path: str,
 
     """
 
-    frames_list = _get_list_of_frames_above_total_mean(image_4d_path=input_image_4d_path,
+    frames_list = _get_list_of_frames_above_total_mean(image_4d_path=input_image_path,
                                                        scale_factor=scale_factor)
 
-    motion_corr_frame_list(input_image_4d_path=input_image_4d_path,
+    motion_corr_frame_list(input_image_path=input_image_path,
                            motion_target_option=motion_target_option,
                            out_image_path=out_image_path,
                            verbose=verbose,
                            frames_list=frames_list,
                            type_of_transform=type_of_transform,
                            transform_metric=transform_metric,
-                           half_life=half_life,
                            **kwargs)
 
 
-def motion_corr_frames_above_mean_value_to_t1(input_image_4d_path: str,
+def motion_corr_frames_above_mean_value_to_t1(input_image_path: str,
                                               t1_image_path: str,
                                               motion_target_option: str | tuple,
                                               out_image_path: str,
                                               verbose: bool,
                                               type_of_transform: str = 'AffineFast',
                                               transform_metric: str = "mattes",
-                                              half_life: float = None,
                                               scale_factor: float = 1.0):
     """
     Perform motion correction on frames with mean values above the mean of a 4D PET image to a T1
@@ -389,7 +374,7 @@ def motion_corr_frames_above_mean_value_to_t1(input_image_4d_path: str,
     function.
 
     Args:
-        input_image_4d_path (str): Path to the input 4D PET image file.
+        input_image_path (str): Path to the input 4D PET image file.
         t1_image_path (str): Path to the 3D T1 anatomical image.
         motion_target_option (str | tuple): Option to determine the motion target. This can
             be a path to a specific image file, a tuple of frame indices to generate a target, or
@@ -399,8 +384,6 @@ def motion_corr_frames_above_mean_value_to_t1(input_image_4d_path: str,
         type_of_transform (str, optional): Type of transformation to use for registration. Default
             is 'AffineFast'.
         transform_metric (str, optional): Metric to use for the transformation. Default is 'mattes'.
-        half_life (float, optional): Half-life value used by `determine_motion_target`, if
-            applicable. Default is None.
         scale_factor (float, optional): Scale factor applied to the mean voxel value of the entire
             image for comparison. Must be greater than 0. Default is 1.0.
 
@@ -413,7 +396,7 @@ def motion_corr_frames_above_mean_value_to_t1(input_image_4d_path: str,
 
             from petpal.preproc.motion_corr import motion_corr_frames_above_mean_value_to_t1
 
-            motion_corr_frames_above_mean_value_to_t1(input_image_4d_path='/path/to/image.nii.gz',
+            motion_corr_frames_above_mean_value_to_t1(input_image_path='/path/to/image.nii.gz',
                                                       t1_image_path='/path/to/t1_image.nii.gz',
                                                       motion_target_option='/path/to/target_image.nii.gz',
                                                       out_image_path='/path/to/output_motion_corrected.nii.gz',
@@ -430,18 +413,17 @@ def motion_corr_frames_above_mean_value_to_t1(input_image_4d_path: str,
         - The :func:`_get_list_of_frames_above_total_mean` function identifies
             the frames to be motion corrected based on their mean voxel values.
     """
-    frames_list = _get_list_of_frames_above_total_mean(image_4d_path=input_image_4d_path,
+    frames_list = _get_list_of_frames_above_total_mean(image_4d_path=input_image_path,
                                                        scale_factor=scale_factor)
 
-    motion_corr_frame_list_to_t1(input_image_4d_path=input_image_4d_path,
+    motion_corr_frame_list_to_t1(input_image_path=input_image_path,
                                  t1_image_path=t1_image_path,
                                  motion_target_option=motion_target_option,
                                  out_image_path=out_image_path,
                                  verbose=verbose,
                                  frames_list=frames_list,
                                  type_of_transform=type_of_transform,
-                                 transform_metric=transform_metric,
-                                 half_life=half_life)
+                                 transform_metric=transform_metric)
 
 
 def windowed_motion_corr_to_target(input_image_path: str,
@@ -500,8 +482,7 @@ def windowed_motion_corr_to_target(input_image_path: str,
     frame_timing_info = ScanTimingInfo.from_nifti(image_path=input_image_path)
 
     target_image = determine_motion_target(motion_target_option=motion_target_option,
-                                           input_image_4d_path=input_image_path,
-                                           half_life=half_life)
+                                           input_image_path=input_image_path)
     target_image = ants.image_read(target_image)
 
     reg_kwargs_default = {'aff_metric'               : 'mattes',
@@ -551,68 +532,6 @@ def gen_timeseries_from_image_list(image_list: list[ants.core.ANTsImage]) -> ant
     return ants.list_to_ndimage(tmp_image, image_list)
 
 
-def gen_nd_image_based_on_image_list(image_list: list[ants.core.ants_image.ANTsImage]):
-    r"""
-    Generate a 4D ANTsImage based on a list of 3D ANTsImages.
-
-    This function takes a list of 3D ANTsImages and constructs a new 4D ANTsImage,
-    where the additional dimension represents the number of frames (3D images) in the list.
-    The 4D image retains the spacing, origin, direction, and shape properties of the 3D images,
-    with appropriate modifications for the additional dimension.
-
-    Args:
-        image_list (list[ants.core.ants_image.ANTsImage]):
-            List of 3D ANTsImage objects to be combined into a 4D image.
-            The list must contain at least one image, and all images must have the same
-            dimensions and properties.
-
-    Returns:
-        ants.core.ants_image.ANTsImage:
-            A 4D ANTsImage constructed from the input list of 3D images. The additional
-            dimension corresponds to the number of frames (length of the image list).
-
-    Raises:
-        AssertionError: If the `image_list` is empty or if the images in the list are not 3D.
-
-    See Also
-        * :func:`petpal.preproc.motion_corr.motion_corr_frame_list_to_t1`
-
-    Example:
-
-        .. code-block:: python
-
-
-            import ants
-            image1 = ants.image_read('frame1.nii.gz')
-            image2 = ants.image_read('frame2.nii.gz')
-            image_list = [image1, image2]
-            result = _gen_nd_image_based_on_image_list(image_list)
-            print(result.dimension)  # 4
-            image4d = ants.list_to_ndimage(result, image_list)
-
-    """
-    assert len(image_list) > 0
-    assert image_list[0].dimension == 3
-
-    num_frames = len(image_list)
-    spacing_3d = image_list[0].spacing
-    origin_3d = image_list[0].origin
-    shape_3d = image_list[0].shape
-    direction_3d = image_list[0].direction
-
-    direction_4d = np.eye(4)
-    direction_4d[:3, :3] = direction_3d
-    spacing_4d = (*spacing_3d, 1.0)
-    origin_4d = (*origin_3d, 0.0)
-    shape_4d = (*shape_3d, num_frames)
-
-    tmp_image = ants.make_image(imagesize=shape_4d,
-                                spacing=spacing_4d,
-                                origin=origin_4d,
-                                direction=direction_4d)
-    return tmp_image
-
-
 def _get_list_of_frames_above_total_mean(image_4d_path: str,
                                          scale_factor: float = 1.0):
     """