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

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)
 

petpal/preproc/standard_uptake_value.py

@@ -0,0 +1,159 @@
+"""
+Module for functions calculating standard uptake value (SUV) and related measures, such as standard
+uptake value ratio (SUVR).
+"""
+import ants
+
+from ..utils.stats import mean_value_in_region
+from ..utils.math_lib import weighted_sum_computation
+from ..utils.useful_functions import gen_3d_img_from_timeseries, nearest_frame_to_timepoint
+from ..utils.image_io import (get_half_life_from_nifti,
+                              load_metadata_for_nifti_with_same_filename,
+                              safe_copy_meta)
+
+
+def weighted_sum_for_suv(input_image_path: str,
+                         output_image_path: str | None,
+                         start_time: float=0,
+                         end_time: float=-1) -> ants.ANTsImage:
+    """Function that calculates the weighted series sum for a PET image specifically for
+    calculating the standard uptake value (SUV) of the image.
+    
+    Args:
+        input_image_path (str): Path to a 4D PET image which we calculate the sum on.
+        output_image_path (str): Path to which output image is saved. If None, returns
+            calculated image without saving.
+        start_time: Time in seconds from the start of the scan from which to begin sum calculation.
+            Only frames after selected time will be included in the sum. Default 0.
+        end_time: Time in seconds from the start of the scan from which to end sum calculation.
+            Only frames before selected time will be included in the sum. If -1, use all frames
+            after `start_time` in the calculation. Default -1.
+            
+    Returns:
+        weighted_sum_img (ants.ANTsImage): 3D image resulting from the sum calculation.
+    """
+    half_life = get_half_life_from_nifti(image_path=input_image_path)
+    if half_life <= 0:
+        raise ValueError('(ImageOps4d): Radioisotope half life is zero or negative.')
+    pet_meta = load_metadata_for_nifti_with_same_filename(input_image_path)
+    pet_img = ants.image_read(input_image_path)
+    frame_start = pet_meta['FrameTimesStart']
+    frame_duration = pet_meta['FrameDuration']
+
+    if 'DecayCorrectionFactor' in pet_meta.keys():
+        decay_correction = pet_meta['DecayCorrectionFactor']
+    elif 'DecayFactor' in pet_meta.keys():
+        decay_correction = pet_meta['DecayFactor']
+    else:
+        raise ValueError("Neither 'DecayCorrectionFactor' nor 'DecayFactor' exist in meta-data "
+                         "file")
+
+    last_frame_time = frame_start[-1]
+    if end_time!=-1:
+        last_frame_time = end_time
+    scan_start = frame_start[0]
+    nearest_frame = nearest_frame_to_timepoint(frame_times=frame_start)
+    calc_first_frame = int(nearest_frame(start_time+scan_start))
+    calc_last_frame = int(nearest_frame(last_frame_time+scan_start))
+    if calc_first_frame==calc_last_frame:
+        calc_last_frame += 1
+    pet_series_adjusted = pet_img[:,:,:,calc_first_frame:calc_last_frame]
+    frame_start_adjusted = frame_start[calc_first_frame:calc_last_frame]
+    frame_duration_adjusted = frame_duration[calc_first_frame:calc_last_frame]
+    decay_correction_adjusted = decay_correction[calc_first_frame:calc_last_frame]
+
+    weighted_sum_arr = weighted_sum_computation(frame_duration=frame_duration_adjusted,
+                                                half_life=half_life,
+                                                pet_series=pet_series_adjusted,
+                                                frame_start=frame_start_adjusted,
+                                                decay_correction=decay_correction_adjusted)
+    weighted_sum_img = ants.from_numpy_like(weighted_sum_arr,gen_3d_img_from_timeseries(pet_img))
+
+    if output_image_path is not None:
+        ants.image_write(weighted_sum_img, output_image_path)
+        safe_copy_meta(input_image_path=input_image_path,
+                       out_image_path=output_image_path)
+
+    return weighted_sum_img
+
+
+def suv(input_image_path: str,
+        output_image_path: str | None,
+        weight: float,
+        dose: float,
+        start_time: float,
+        end_time: float) -> ants.ANTsImage:
+    """Compute standard uptake value (SUV) over a pet image. Calculate the weighted image sum
+    then divide by the dose and multiplying by the weight of the participant.
+
+    Args:
+        input_image_path: Path to input PET image.
+        output_image_path: Path to which SUV image is saved.
+        weight: Weight of the participant in kg.
+        dose: Dose injected during the scan in MBq.
+        start_time: Start time for the SUV calculation in seconds.
+        end_time: End time for the SUV calculation in seconds.
+        
+    Returns:
+        suv_img (ants.ANTsImage): The standard uptake value calculated on the input image."""
+    wss_img = weighted_sum_for_suv(input_image_path=input_image_path,
+                                   output_image_path=None,
+                                   start_time=start_time,
+                                   end_time=end_time)
+    suv_img = wss_img / (dose*1000) * weight
+
+    if output_image_path is not None:
+        ants.image_write(suv_img, output_image_path)
+        safe_copy_meta(input_image_path=input_image_path,
+                       out_image_path=output_image_path)
+
+    return suv_img
+
+
+def suvr(input_image_path: str,
+         output_image_path: str | None,
+         segmentation_image_path: str,
+         ref_region: int | list[int],
+         start_time: float,
+         end_time: float) -> 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 4D PET image.
+        output_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 or list of region mappings over which to compute average SUV. If a
+            list is provided, combines all regions in the list as one reference region.
+        start_time: Time in seconds from the start of the scan from which to begin sum calculation.
+            Only frames after selected time will be included in the sum. Default 0.
+        end_time: Time in seconds from the start of the scan from which to end sum calculation.
+            Only frames before selected time will be included in the sum. If -1, use all frames
+            after `start_time` in the calculation. Default -1.
+
+    Returns:
+        ants.ANTsImage: SUVR parametric image
+    """
+    sum_img = weighted_sum_for_suv(input_image_path=input_image_path,
+                                   output_image_path=None,
+                                   start_time=start_time,
+                                   end_time=end_time)
+    segmentation_img = ants.image_read(filename=segmentation_image_path)
+
+    ref_region_avg = mean_value_in_region(input_img=sum_img,
+                                          seg_img=segmentation_img,
+                                          mappings=ref_region)
+
+    suvr_img = sum_img / ref_region_avg
+
+    if output_image_path is not None:
+        ants.image_write(image=suvr_img,
+                         filename=output_image_path)
+        safe_copy_meta(input_image_path=input_image_path,
+                       out_image_path=output_image_path)
+
+    return suvr_img

petpal/utils/stats.py

@@ -6,6 +6,27 @@ import ants
 from ..meta.label_maps import LabelMapLoader
 from .useful_functions import check_physical_space_for_ants_image_pair
 
+def mean_value_in_region(input_img: ants.ANTsImage,
+                         seg_img: ants.ANTsImage,
+                         mappings: int | list[int]) -> float:
+    """Calculate the mean value in a 3D PET image over a region based on one or more integer
+    mappings corresponding to regions in a segmentation image.
+    
+    Args:
+        input_img (ants.ANTsImage): 3D PET image over which to calculate the mean.
+        seg_img (ants.ANTsImage): Segmentation image in same space as `input_img`.
+        mappings (int | list[int]): One or more mappings to mask input_image over.
+
+    Returns:
+        region_mean (float): Mean PET value over voxels in the regions corresponding to
+            `mappings`."""
+    region_mask = ants.mask_image(input_img, seg_img, level=mappings)
+    region_arr = region_mask.numpy().flatten()
+    region_arr_nonzero = region_arr.nonzero()
+    voxel_arr = region_arr[region_arr_nonzero]
+    return voxel_arr.mean()
+
+
 class RegionalStats:
     """Run statistics on each region in a parametric 3D PET kinetic model or other image.
     

petpal/utils/useful_functions.py

@@ -1,6 +1,7 @@
 """
 Module to handle abstracted functionalities
 """
+from collections.abc import Callable
 import os
 import nibabel
 import numpy as np
@@ -88,7 +89,7 @@ def build_label_map(region_names: list[str]):
     return abbreviated_names
 
 
-def weighted_series_sum(input_image_4d_path: str,
+def weighted_series_sum(input_image_path: str,
                         out_image_path: str,
                         half_life: float,
                         verbose: bool=False,
@@ -124,7 +125,7 @@ def weighted_series_sum(input_image_4d_path: str,
     # TODO: Determine half_life from .json rather than passing as argument.
 
     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 on which the weighted sum is calculated. Assume a metadata
             file exists with the same path and file name, but with extension .json,
             and follows BIDS standard.
@@ -147,8 +148,8 @@ def weighted_series_sum(input_image_4d_path: str,
     """
     if half_life <= 0:
         raise ValueError('(ImageOps4d): Radioisotope half life is zero or negative.')
-    pet_meta = image_io.load_metadata_for_nifti_with_same_filename(input_image_4d_path)
-    pet_image = nibabel.load(input_image_4d_path)
+    pet_meta = image_io.load_metadata_for_nifti_with_same_filename(input_image_path)
+    pet_image = nibabel.load(input_image_path)
     pet_series = pet_image.get_fdata()
     frame_start = pet_meta['FrameTimesStart']
     frame_duration = pet_meta['FrameDuration']
@@ -202,7 +203,7 @@ def weighted_series_sum(input_image_4d_path: str,
         nibabel.save(pet_sum_image, out_image_path)
         if verbose:
             print(f"(ImageOps4d): weighted sum image saved to {out_image_path}")
-        image_io.safe_copy_meta(input_image_path=input_image_4d_path,
+        image_io.safe_copy_meta(input_image_path=input_image_path,
                                 out_image_path=out_image_path)
 
     return image_weighted_sum
@@ -431,3 +432,103 @@ def get_frame_from_timeseries(input_img: ants.ANTsImage, frame: int) -> ants.ANT
     ants.set_direction( img_3d, subdirection )
 
     return img_3d
+
+
+def nearest_frame_to_timepoint(frame_times: np.ndarray) -> Callable[[float],float]:
+    """Returns a step function that gets the index of the frame closest to a provided timepoint
+    based on an array of frame times, such as the frame starts or reference times.
+
+    Args:
+        frame_times (np.ndarray): The frame times on which to generate the step function.
+
+    Returns:
+        nearest_frame_func (Callable[[float],float]): A function that returns the time closest to
+            the provided timepoint.
+    """
+    nearest_frame_func = interp1d(x=frame_times,
+                                  y=range(len(frame_times)),
+                                  kind='nearest',
+                                  bounds_error=False,
+                                  fill_value='extrapolate')
+    return nearest_frame_func
+
+
+def get_average_of_timeseries(input_image: ants.ANTsImage) -> ants.ANTsImage:
+    """
+    Get average of a 4D ANTsImage and return as a 3D ANTsImage.
+
+    Args:
+        input_image (ants.ANTsImage): 4D PET image over which to compute timeseries average.
+
+    Returns:
+        mean_image (ants.ANTsImage): 3D mean over time in the PET image.
+    """
+    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 gen_nd_image_based_on_image_list(image_list: list[ants.ANTsImage]) -> ants.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.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

{petpal-0.5.5.dist-info → petpal-0.5.7.dist-info}/METADATA

@@ -1,10 +1,9 @@
 Metadata-Version: 2.4
 Name: petpal
-Version: 0.5.5
+Version: 0.5.7
 Summary: PET-PAL (Positron Emission Tomography Processing and Analysis Library)
 Project-URL: Repository, https://github.com/PETPAL-WUSM/PETPAL.git
-Author: Bradley Judge
-Author-email: Furqan Dar <dar@wustl.edu>, Noah Goldman <noahg@wustl.edu>, Kenan Oestreich <kenan.oestreich@wustl.edu>
+Author-email: Noah Goldman <noahg@wustl.edu>, Bradley Judge <bjudge@wustl.edu>, Furqan Dar <dar@wustl.edu>, Kenan Oestreich <kenan.oestreich@wustl.edu>
 License-File: LICENSE
 Classifier: Development Status :: 2 - Pre-Alpha
 Classifier: Intended Audience :: Science/Research
@@ -45,7 +44,17 @@ Description-Content-Type: text/markdown
 
 ## Installation
 
-Currently, we only support building the package directly from source. Clone the repository using your preferred method. After navigating to the top-level directory (where `pyproject.toml` exists), we run the following command in the terminal:
+### Using Pip
+
+The simplest way to install PETPAL is using pip. First, ensure you are using Python version >=3.12. Then, run the following:
+
+```shell
+pip install petpal
+```
+
+### Build from source
+
+Clone the repository using your preferred method. After navigating to the top-level directory (where `pyproject.toml` exists), we run the following command in the terminal:
 
 ```shell
 pip install .  # Installs the package

{petpal-0.5.5.dist-info → petpal-0.5.7.dist-info}/RECORD

@@ -4,15 +4,15 @@ petpal/cli/cli_graphical_analysis.py,sha256=nGb0afMAigJgvbyEj5EXOCt6WNU35LNo3h3K
 petpal/cli/cli_graphical_plots.py,sha256=_2tlGtZ0hIVyEYtGviEzGZMNhFymUPg4ZvSVyMtT_dA,3211
 petpal/cli/cli_idif.py,sha256=6lh_kJHcGjlHDXZOvbiuHrNqpk5FovVV5_j7_dPHTHU,5145
 petpal/cli/cli_parametric_images.py,sha256=JBFb8QlxZoGOzqvCJPFuZ7czzGWntJP5ZcfeM5-QF4Y,7385
-petpal/cli/cli_pib_processing.py,sha256=6EjoY0wSJZ7PImgjV9PxlGPgcZkcZISvFh9ctsZW3Gw,6935
+petpal/cli/cli_pib_processing.py,sha256=ye_yw0ZQ4cSrMNemGR7cU9v6epD7Wbq1xaNAJwLzV_8,6889
 petpal/cli/cli_plot_tacs.py,sha256=XycaYQQl9Jp5jqDp3QXOlVT2sXHYYpYSraEArxsfJec,6479
-petpal/cli/cli_preproc.py,sha256=H8yfAa_fGzhLcyAU8JSOEAxsIF_DN81Ek8iWGkGj63Q,20106
+petpal/cli/cli_preproc.py,sha256=y5YvRliXC3zNY8oBJgTkzwPH9YNwWnEUWgiltUAv7AU,21850
 petpal/cli/cli_pvc.py,sha256=DC0JZ6p1pkc5BDgQ006bi9y0Mz32ENrjUaOtSvFobP4,3967
 petpal/cli/cli_reference_tissue_models.py,sha256=18BlKN4rMehyFbdq_yr88oztqR99_gBtWKImhwf7CQY,13283
 petpal/cli/cli_stats.py,sha256=Mqbzc9yYo9SVAfxzaYbAbk7EheW472l1PY_ptlD1DOI,2050
 petpal/cli/cli_tac_fitting.py,sha256=bCYwFAbxIKwnYBteAKnot5vOsk9F4Z1EJw2Xk0tZ9oo,14989
 petpal/cli/cli_tac_interpolation.py,sha256=Nwf0CAfyEATLeiwuPSirS0DWDeerrIH2P-U0lpXpKWk,5734
-petpal/cli/cli_vat_processing.py,sha256=Zr76hISMVCCwjGKp8zk0CiPdewzSOeUO2zaFZJ3yGl0,12346
+petpal/cli/cli_vat_processing.py,sha256=XrWcjZqgc5JAtp4fZ94ZLJ7h6fvdMhZvR30nh7GCD4w,12404
 petpal/input_function/__init__.py,sha256=mWdwuVdMSgaHE0wviNE7TGGoOI9Y3sEKfKpBqLS-Ph4,151
 petpal/input_function/blood_input.py,sha256=TNx3hL7M8Z_ZaZoTpt8LgLQhXnNyW0BOhgVZompwgxA,9206
 petpal/input_function/idif_necktangle.py,sha256=o5kyAqyT4C6o7zELY4EjyHrkJyX1BWcxvBqYiMjNyn4,7863
@@ -32,18 +32,20 @@ petpal/meta/label_maps.py,sha256=cifp_KXQAgIbdWoinMpOQstEK4-pasSXlgML6xoEjHM,227
 petpal/pipelines/__init__.py,sha256=Qt9VwqAvVjadHR6Lsja05XIVQONHTCs30NFxiBvf_2k,266
 petpal/pipelines/kinetic_modeling_steps.py,sha256=G6FyfhR0MJ83b4pnww_FhZcAY8PwAIXSYglyoj1mPoQ,32717
 petpal/pipelines/pca_guided_idif_steps.py,sha256=tuL3stKDlUQsHBTTzlYx_WgBKwaS8eHpieUjzB90Mq4,20550
-petpal/pipelines/pipelines.py,sha256=lyvXp7qGP859D9e-F9FUuRKvEKEMj1dVxMH-NiyUHJc,38633
-petpal/pipelines/preproc_steps.py,sha256=bKrBTsPuQlpr76UPlbbBlAS8tohTD45QUIabTn1eNmY,38119
+petpal/pipelines/pipelines.py,sha256=2KgeOvrXmjNrecTQMqIKMPv4tzvaRjr1FhvntVyvHX0,38391
+petpal/pipelines/preproc_steps.py,sha256=VC-KoMwxnfv0BxUEGneDjDy6HUYAub6JztaRHm3gm4M,37987
 petpal/pipelines/steps_base.py,sha256=W7GVN5-tsXe_7fvhoMRIlOk5ggY8V2wpSSmDONphLnQ,18311
 petpal/pipelines/steps_containers.py,sha256=TV4LkPK48OnAds10vLcsPI3qtWjHsmwr6XGu3hup59Q,33767
-petpal/preproc/__init__.py,sha256=OCYUXxPiQOCENQuzUSrtJaRZKj8dAnOQcq4kOn6N2i4,440
+petpal/preproc/__init__.py,sha256=HmTVnCiKMxetDT_w-qU_62UOC39_A83LHXhZm07Q81I,504
 petpal/preproc/decay_correction.py,sha256=QCA_QcB6pqAD_wYSqtRKSvO6qWCaEzgL_qrAcSczRtw,6829
-petpal/preproc/image_operations_4d.py,sha256=qYCndoBO4eJwlgqzvMkN12ftlEc4NNayLhtqSNZC29I,38714
-petpal/preproc/motion_corr.py,sha256=UVNFII1-Z8cYEHc27xFl4tqEjo5c6Q3pLDksPoP-RM0,32301
+petpal/preproc/image_operations_4d.py,sha256=IqzwxaWxoWC1gmK00uuHIwlhx8e_eQ44C6yVFuu73W4,31371
+petpal/preproc/motion_corr.py,sha256=dz10qjXBVTF_RH5RPZ68drUVX2qyj-MnZ674_Ccwz2Y,28670
+petpal/preproc/motion_target.py,sha256=_OJp3NoYcyD3Ke3wl2KbfOhbJ6dp6ZduR9LLz0rIaC0,3945
 petpal/preproc/partial_volume_corrections.py,sha256=J06j_Y_lhj3b3b9M5FbB2r2EPWQvoymG3GRUffSlYdE,6799
-petpal/preproc/regional_tac_extraction.py,sha256=9B7LrVmVFfMCC5cl3ACamvJEsCU49iu_3Z8lugS_eUc,19713
-petpal/preproc/register.py,sha256=K_hvcV47ZRBfJF8QC6EM3bQXzkPdpN3xXYer_lqyZuE,14500
-petpal/preproc/segmentation_tools.py,sha256=Z2tZxDXRQkQhWtRkoWRs2VOwwLMDXnP5xJ_Z_52CN5c,25680
+petpal/preproc/regional_tac_extraction.py,sha256=qQDD9Z9p21DVUKokh_en2chOGP7F01wnDN156_74X8Q,19704
+petpal/preproc/register.py,sha256=NKg8mt_XMGa5HBdxYZh3sMu_KMJ0W41VHlX4Zl8wlyE,14171
+petpal/preproc/segmentation_tools.py,sha256=BUy8ij45mmetenvWzODVwNIThDkYiEtY6gTAqI8sIak,25703
+petpal/preproc/standard_uptake_value.py,sha256=YJIt0fl3fwMLl0tRYHpPPprMTaN4Q5JjQ5dx_CQX1nI,7494
 petpal/preproc/symmetric_geometric_transfer_matrix.py,sha256=ELkr7Mo233to1Rwml5YJ-aBvmTSk3LHNSdRhnX0WBDw,17575
 petpal/utils/__init__.py,sha256=PlxBIKUtNvtSFnNZqz8myszOysaYzS8nSILMK4haVGg,412
 petpal/utils/bids_utils.py,sha256=3eZAzwGpOBUQ5ShVBUJJpmUBUhr3VcOikR-KpGCsdE0,7664
@@ -54,17 +56,17 @@ petpal/utils/image_io.py,sha256=2Dj2U-OaGL15lwt8KVyl_RZZZdRYdvzUahQWegO_JrA,1799
 petpal/utils/math_lib.py,sha256=DYt80lB1je-wFqHGuzOwfTOM1tPugomB889xBUdr99U,4725
 petpal/utils/metadata.py,sha256=O9exRDlqAmPAEcO9v7dsqzkYcSVLgRA207owEvNXXJ8,6129
 petpal/utils/scan_timing.py,sha256=j7i66Nt0Qs3fnQLUaycLHQTfVsNOqS7YS-xUJKm7nYk,11795
-petpal/utils/stats.py,sha256=W-6sMnZoKbp9zEp7CWl3iWLyly4948gmLbK7P3Q2YW4,5496
+petpal/utils/stats.py,sha256=paFdwVPIjlAi0wh5xU4x5WeydjKsEHuwzMLcDG_WzPc,6449
 petpal/utils/testing_utils.py,sha256=eMt1kklxK3rl8tm74I3yVNDotKh1CnYWLINDT7rzboM,9557
 petpal/utils/time_activity_curve.py,sha256=gX3PDYbeWblycvtvyiuFtnv1mBml_-93sIXKh2EmglM,39137
-petpal/utils/useful_functions.py,sha256=IziQ6DnB5CcxRlk9_14QWXdDzDACw7WKIAsKQ2rBbQg,17526
+petpal/utils/useful_functions.py,sha256=md2kTLbs45MhrjdMhvDYcbflPTRNPspRSIHiOeIxEqY,21361
 petpal/visualizations/__init__.py,sha256=bd0NHDVl6Z2BDhisEcob2iIcqfxUfgKJ4DEmlrXJRP4,205
 petpal/visualizations/graphical_plots.py,sha256=ZCKUeLX2TAQscuHjA4bzlFm1bACHIyCwDuNnjCakVWU,47297
 petpal/visualizations/image_visualization.py,sha256=Ob6TD4Q0pIrxi0m9SznK1TRWbX1Ea9Pt4wNMdRrTfTs,9124
 petpal/visualizations/qc_plots.py,sha256=iaCPe-LWWyM3OZzDPZodHZhP-z5fRdpUgaH7QS9VxPM,1243
 petpal/visualizations/tac_plots.py,sha256=zSGdptL-EnqhfDViAX8LFunln5a1b-NJ5ft7ZDcxQ38,15116
-petpal-0.5.5.dist-info/METADATA,sha256=RPzJJzXXau935KVTE1i0V7VsfqJJNmGyWWcEzROuivc,2478
-petpal-0.5.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-petpal-0.5.5.dist-info/entry_points.txt,sha256=-AAg5GCaTRuwcLR7QWKPuKyBo8mTEMzspRmcBwaPdLo,692
-petpal-0.5.5.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-petpal-0.5.5.dist-info/RECORD,,
+petpal-0.5.7.dist-info/METADATA,sha256=9fNNCPhSznboKgTX9xPVDIDTJXquMiPoh66Bq-PN9lg,2617
+petpal-0.5.7.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+petpal-0.5.7.dist-info/entry_points.txt,sha256=0SZmyXqBxKzQg2eerDA16n2BdUEXyixEm0_AUo2dFns,653
+petpal-0.5.7.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+petpal-0.5.7.dist-info/RECORD,,

{petpal-0.5.5.dist-info → petpal-0.5.7.dist-info}/entry_points.txt

@@ -1,5 +1,4 @@
 [console_scripts]
-petpal-bids = petpal.cli.cli_bids:main
 petpal-graph-analysis = petpal.cli.cli_graphical_analysis:main
 petpal-graph-plot = petpal.cli.cli_graphical_plots:main
 petpal-parametric-image = petpal.cli.cli_parametric_images:main