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

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/scan_timing.py

@@ -1,7 +1,7 @@
 """
 Module to handle timing information of PET scans.
 """
-import math
+from typing import Self
 from dataclasses import dataclass
 import numpy as np
 
@@ -82,8 +82,8 @@ class ScanTimingInfo:
 
     """
     duration: np.ndarray[float]
-    end: np.ndarray[float]
     start: np.ndarray[float]
+    end: np.ndarray[float]
     center: np.ndarray[float]
     decay: np.ndarray[float]
 
@@ -130,7 +130,7 @@ class ScanTimingInfo:
 
 
     @classmethod
-    def from_metadata(cls, metadata_dict: dict):
+    def from_metadata(cls, metadata_dict: dict) -> Self:
         r"""
         Extracts frame timing information and decay factors from a json metadata.
         Expects that the JSON metadata has ``FrameDuration`` and ``DecayFactor`` or
@@ -155,13 +155,13 @@ class ScanTimingInfo:
         """
         frm_dur = np.asarray(metadata_dict['FrameDuration'], float)
         try:
-            frm_ends = np.asarray(metadata_dict['FrameTimesEnd'], float)
+            frm_starts = np.asarray(metadata_dict['FrameTimesStart'], float)
         except KeyError:
-            frm_ends = np.cumsum(frm_dur)
+            frm_starts = np.cumsum(frm_dur)-frm_dur
         try:
-            frm_starts = np.asarray(metadata_dict['FrameTimesStart'], float)
+            frm_ends = np.asarray(metadata_dict['FrameTimesEnd'], float)
         except KeyError:
-            frm_starts = np.diff(frm_ends)
+            frm_ends = frm_starts+frm_dur
         try:
             decay = np.asarray(metadata_dict['DecayCorrectionFactor'], float)
         except KeyError:
@@ -178,7 +178,7 @@ class ScanTimingInfo:
                    decay=decay)
 
     @classmethod
-    def from_nifti(cls, image_path: str):
+    def from_nifti(cls, image_path: str) -> Self:
         r"""
         Extracts frame timing information and decay factors from a NIfTI image metadata.
         Expects that the JSON metadata file has ``FrameDuration`` and ``DecayFactor`` or
@@ -204,6 +204,49 @@ class ScanTimingInfo:
         _meta_data = load_metadata_for_nifti_with_same_filename(image_path=image_path)
         return cls.from_metadata(metadata_dict=_meta_data)
 
+    @classmethod
+    def from_start_end(cls,
+                       frame_starts: np.ndarray,
+                       frame_ends: np.ndarray,
+                       decay_correction_factor: np.ndarray | None=None) -> Self:
+        """Infer timing properties based on start and end time.
+        
+        Args:
+            frame_starts (np.ndarray): Start time of each frame.
+            frame_ends (np.ndarray): End time of each frame.
+            decay_correction_factor (np.ndarray | None): Decay correction factor, which can be
+                optionally provided based on the type of analysis being done. If None, frame decay
+                will be set to ones. Default None.
+
+        Returns:
+            scan_timing_info (ScanTimingInfo): ScanTimingInfo object with the correct start, end,
+                duration, midpoint, and (optionally) decay correction for each frame.
+
+        Raises:
+            ValueError: If frame_starts, frame_ends, and decay_correction_factor (if provided) are
+                not of identical shape.
+
+        """
+        if frame_starts.shape != frame_ends.shape:
+            raise ValueError("frame_ends must have the same shape as frame_starts")
+
+        frame_duration = frame_ends - frame_starts
+        frame_midpoint = frame_starts + frame_duration / 2
+        frame_decay = np.ones_like(frame_starts)
+
+        if decay_correction_factor is None:
+            frame_decay = np.ones_like(frame_starts, dtype=float)
+        else:
+            frame_decay = np.asarray(decay_correction_factor, dtype=float)
+            if frame_decay.shape != frame_starts.shape:
+                raise ValueError("decay_correction_factor must have the same shape as frame_starts")
+
+        return cls(duration=frame_duration,
+                   start=frame_starts,
+                   end=frame_ends,
+                   center=frame_midpoint,
+                   decay=frame_decay)
+
 
 def get_window_index_pairs_from_durations(frame_durations: np.ndarray, w_size: float):
     r"""
@@ -263,25 +306,29 @@ def get_window_index_pairs_for_image(image_path: str, w_size: float):
                                                  w_size=w_size)
 
 
-def calculate_frame_reference_time(frame_duration: float,
-                                   frame_start: float,
-                                   half_life: float) -> float:
+def calculate_frame_reference_time(frame_duration: np.ndarray,
+                                   frame_start: np.ndarray,
+                                   half_life: float) -> np.ndarray:
     r"""Compute frame reference time as the time at which the average activity occurs.
     
-    Equation comes from the `DICOM standard documentation <https://dicom.innolitics.com/ciods/positron-emission-tomography-image/pet-image/00541300>`_
+    Equation comes from the `DICOM standard documentation
+    <https://dicom.innolitics.com/ciods/positron-emission-tomography-image/pet-image/00541300>`_
 
     :math:`T_{ave}=\frac{1}{\lambda}ln\frac{\lambda T}{1-e^{-\lambda T}}`
 
-    where lambda is the decay constant, :math:`\frac{ln2}{T_{1/2}}`, :math:`T_{1/2}` is the half life, and :math:`T` is the frame duration.
+    where lambda is the decay constant, :math:`\frac{ln2}{T_{1/2}}`, :math:`T_{1/2}` is the half
+    life, and :math:`T` is the frame duration.
 
     Args:
-        frame_duration (float): Frame Duration in seconds
-        frame_start (float): Start time of frame relative to scan start, in seconds
-        half_life (float): Radionuclide half life
+        frame_duration (np.ndarray): Duration of each frame in seconds.
+        frame_start (np.ndarray): Start time of each frame relative to scan start, in seconds.
+        half_life (float): Radionuclide half life in seconds.
 
     Returns: 
-        float: Frame reference time
+        np.ndarray: Frame reference time for each frame in the scan in seconds.
     """
-    decay_constant = math.log(2)/half_life
-    frame_reference_time = frame_start + math.log((decay_constant*frame_duration)/(1-math.exp(-decay_constant*frame_duration)))/decay_constant
+    decay_constant = np.log(2)/half_life
+    decay_over_frame = decay_constant*frame_duration
+    reference_time_delay = np.log((decay_over_frame)/(1-np.exp(-decay_over_frame)))/decay_constant
+    frame_reference_time = frame_start + reference_time_delay
     return frame_reference_time

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.6.dist-info → petpal-0.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: petpal
-Version: 0.5.6
+Version: 0.5.8
 Summary: PET-PAL (Positron Emission Tomography Processing and Analysis Library)
 Project-URL: Repository, https://github.com/PETPAL-WUSM/PETPAL.git
 Author-email: Noah Goldman <noahg@wustl.edu>, Bradley Judge <bjudge@wustl.edu>, Furqan Dar <dar@wustl.edu>, Kenan Oestreich <kenan.oestreich@wustl.edu>

{petpal-0.5.6.dist-info → petpal-0.5.8.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=_l4OoOnKUTgu0T5lT9ctZK1h5qj7yBZgtf0m0PK_HS0,20355
+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/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/__init__.py,sha256=HmTVnCiKMxetDT_w-qU_62UOC39_A83LHXhZm07Q81I,504
+petpal/preproc/decay_correction.py,sha256=jT8X2lmMrdGf9-lo1ooKul_yomPqm1p24gB9On_GHl0,6872
+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
@@ -53,18 +55,18 @@ petpal/utils/decorators.py,sha256=9CVT4rXnSUqryNL83jmhQHiI6IGDr2E8jBqPD-KhYGA,49
 petpal/utils/image_io.py,sha256=2Dj2U-OaGL15lwt8KVyl_RZZZdRYdvzUahQWegO_JrA,17995
 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/scan_timing.py,sha256=CYtYuFquAnOQ2QfjXdeLjWrBDPM_k4vBI9oHQdpmVZ0,13908
+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.6.dist-info/METADATA,sha256=W0Fo_jDNeBMUBbXybn9HymGcieOEqygaZDqETObBvrw,2617
-petpal-0.5.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-petpal-0.5.6.dist-info/entry_points.txt,sha256=0SZmyXqBxKzQg2eerDA16n2BdUEXyixEm0_AUo2dFns,653
-petpal-0.5.6.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-petpal-0.5.6.dist-info/RECORD,,
+petpal-0.5.8.dist-info/METADATA,sha256=p2q6Rl726zTvyMW39Uw3j4jw0dXYKFhIDvkGG9nXqKk,2617
+petpal-0.5.8.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+petpal-0.5.8.dist-info/entry_points.txt,sha256=0SZmyXqBxKzQg2eerDA16n2BdUEXyixEm0_AUo2dFns,653
+petpal-0.5.8.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+petpal-0.5.8.dist-info/RECORD,,