petpal 0.5.6__py3-none-any.whl → 0.5.8__py3-none-any.whl

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):
     """

petpal/preproc/motion_target.py

@@ -0,0 +1,90 @@
+"""Module with function to get a motion target for motion correction and registration"""
+import os
+import tempfile
+import ants
+
+from ..utils.useful_functions import get_average_of_timeseries
+from .standard_uptake_value import weighted_sum_for_suv
+
+
+def determine_motion_target(motion_target_option: str | tuple | list,
+                            input_image_path: str = 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_path (str): Path to the PET image. This is intended to
+            be supplied by the parent method employing this function. Default
+            value None.
+
+    Returns:
+        out_image_file (str): File to use as a target to compute
+            transformations on.
+
+    Raises:
+        ValueError: If ``motion_target_option`` is not a string, list, or tuple. If it is a string,
+            but does not match one of the preset options or path to a file, the error will also be
+            raised.
+        TypeError: If start and end time are incompatible with ``float`` type.
+    """
+    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_sum_for_suv(input_image_path=input_image_path,
+                                output_image_path=out_image_file)
+            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_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_sum_for_suv(input_image_path=input_image_path,
+                                output_image_path=out_image_file,
+                                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.')

petpal/preproc/regional_tac_extraction.py

@@ -192,7 +192,7 @@ def write_tacs(input_image_path: str,
         print('Finished writing TACs.')
 
 
-def roi_tac(input_image_4d_path: str,
+def roi_tac(input_image_path: str,
             roi_image_path: str,
             region: list[int] | int,
             out_tac_path: str | None = None,
@@ -223,8 +223,8 @@ 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_numpy = ants.image_read(input_image_4d_path).numpy()
+    pet_meta = image_io.load_metadata_for_nifti_with_same_filename(input_image_path)
+    pet_numpy = ants.image_read(input_image_path).numpy()
     seg_numpy = ants.image_read(roi_image_path).numpy()
 
     region_mask = combine_regions_as_mask(segmentation_img=seg_numpy,

petpal/preproc/register.py

@@ -10,7 +10,7 @@ import nibabel
 import numpy as np
 from nibabel.processing import resample_from_to
 
-from .image_operations_4d import determine_motion_target
+from .motion_target import determine_motion_target
 from ..utils import image_io
 from ..utils.useful_functions import check_physical_space_for_ants_image_pair
 
@@ -29,15 +29,10 @@ def register_pet_to_pet(input_image_path: str,
     Returns:
         ants.ANTsImage: ANTsImage containing input image registered to reference image.
     """
-
-    half_life = image_io.get_half_life_from_nifti(image_path=input_image_path)
-
     wss_input = determine_motion_target(motion_target_option='weighted_series_sum',
-                                        input_image_4d_path=input_image_path,
-                                        half_life=half_life)
+                                        input_image_path=input_image_path)
     wss_reference = determine_motion_target(motion_target_option='weighted_series_sum',
-                                            input_image_4d_path=reference_pet_image_path,
-                                            half_life=half_life)
+                                            input_image_path=reference_pet_image_path)
 
     wss_input_ants = ants.image_read(wss_input)
     wss_reference_ants = ants.image_read(wss_reference)
@@ -67,7 +62,6 @@ def register_pet(input_reg_image_path: str,
                  motion_target_option: Union[str, tuple],
                  verbose: bool,
                  type_of_transform: str = 'DenseRigid',
-                 half_life: float = None,
                  **kwargs):
     """
     Computes and runs rigid registration of 4D PET image series to 3D anatomical image, typically
@@ -91,8 +85,7 @@ def register_pet(input_reg_image_path: str,
         kwargs (keyword arguments): Additional arguments passed to :py:func:`ants.registration`.
     """
     motion_target = determine_motion_target(motion_target_option=motion_target_option,
-                                            input_image_4d_path=input_reg_image_path,
-                                            half_life=half_life)
+                                            input_image_path=input_reg_image_path)
     motion_target_image = ants.image_read(motion_target)
     mri_image = ants.image_read(reference_image_path)
     pet_image_ants = ants.image_read(input_reg_image_path)

petpal/preproc/segmentation_tools.py

@@ -14,7 +14,7 @@ import nibabel
 from nibabel import processing
 import pandas as pd
 
-from . import motion_corr
+from ..utils.useful_functions import gen_nd_image_based_on_image_list
 from ..utils import math_lib
 
 
@@ -203,7 +203,7 @@ def replace_probabilistic_region(segmentation_numpy: np.ndarray,
     return segmentation_numpy
 
 
-def resample_segmentation(input_image_4d_path: str,
+def resample_segmentation(input_image_path: str,
                           segmentation_image_path: str,
                           out_seg_path: str,
                           verbose: bool):
@@ -215,7 +215,7 @@ def resample_segmentation(input_image_4d_path: str,
     PET and ROI data are registered to the same space, but have different resolutions.
 
     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, to which the segmentation file is resampled.
         segmentation_image_path (str): Path to a .nii or .nii.gz file containing a 3D segmentation
             image, where integer indices label specific regions.
@@ -223,7 +223,7 @@ def resample_segmentation(input_image_4d_path: str,
             image is written.
         verbose (bool): Set to ``True`` to output processing information.
     """
-    pet_image = nibabel.load(input_image_4d_path)
+    pet_image = nibabel.load(input_image_path)
     seg_image = nibabel.load(segmentation_image_path)
     pet_series = pet_image.get_fdata()
     image_first_frame = pet_series[:, :, :, 0]
@@ -363,7 +363,7 @@ def gw_segmentation(freesurfer_path: str,
                              origin=freesurfer.origin,
                              spacing=freesurfer.spacing,
                              direction=freesurfer.direction)
-    gw_map_template = motion_corr.gen_nd_image_based_on_image_list([gm_img, wm_img])
+    gw_map_template = gen_nd_image_based_on_image_list([gm_img, wm_img])
     gw_map_4d = ants.list_to_ndimage(image=gw_map_template,image_list=[gm_img,wm_img])
     ants.image_write(gw_map_4d,output_path)