petpal 0.5.10__py3-none-any.whl → 0.6.1__py3-none-any.whl

petpal/__init__.py

@@ -5,6 +5,7 @@ from . import utils
 from . import visualizations
 from . import pipelines
 from . import meta
+from . import io
 
 def main():
     print("PET-PAL (Positron Emission Tomography Processing and Analysis Library)")

petpal/cli/cli_preproc.py

@@ -83,7 +83,12 @@ Examples:
    .. code-block:: bash
 
        petpal-preproc warp-pet-atlas -i /path/to/input_img.nii.gz -o petpal_reg-atlas.nii.gz --anatomical /path/to/anat.nii.gz --reference-atlas /path/to/atlas.nii.gz
- 
+
+    * Crop segmentation to PET FOV:
+
+    .. code-block:: bash
+
+        petpal-preproc seg-crop -i /path/to/input_img.nii.gz -o petpal_cropped_seg.nii.gz --segmentation /path/to/segmentation.nii.gz
 
 See Also:
     * :mod:`~petpal.preproc.image_operations_4d` - module used for operations on 4D images.
@@ -99,7 +104,8 @@ from ..preproc import (image_operations_4d,
                        motion_corr,
                        register,
                        regional_tac_extraction,
-                       standard_uptake_value)
+                       standard_uptake_value,
+                       segmentation_tools)
 
 
 _PREPROC_EXAMPLES_ = r"""
@@ -126,6 +132,10 @@ Examples:
     petpal-preproc warp-pet-atlas -i /path/to/input_img.nii.gz -o petpal_reg-atlas.nii.gz --anatomical /path/to/anat.nii.gz --reference-atlas /path/to/atlas.nii.gz
   - SUV:
     petpal-preproc suv -i /path/to/input_img.nii.gz -o petpal_suv.nii.gz --weight 75 --dose 250 --start-time 1200 --end-time 3600
+  - Crop segmentation image to PET FOV:
+    petpal-preproc seg-crop -i /path/to/input_img.nii.gz -o petpal_cropped_seg.nii.gz --segmentation /path/to/segmentation.nii.gz
+  - Add eroded white matter region to segmentation image:
+    petpal-preproc eroded-wm -i /path/to/input_segmentation.nii.gz -o petpal_seg_with_eroded_wm.nii.gz
 """
 
 
@@ -311,12 +321,11 @@ def _generate_args() -> argparse.ArgumentParser:
                                                help='Windowed motion correction for 4D PET'
                                                     ' using ANTS')
     _add_common_args(parser_window_moco)
-    parser_window_moco.add_argument('-t',
-                                    '--motion-target',
-                                    default='weighted_series_sum',
-                                    type=str,
-                                    help="Motion target option. Can be an image path , "
-                                         "'weighted_series_sum' or 'mean_image'")
+    parser_window_moco.add_argument('--motion-target', default=None, nargs='+',
+                            help="Motion target option. Can be an image path, "
+                                 "'weighted_series_sum' or a tuple "
+                                 "(i.e. '--motion-target 0 600' for first ten minutes).",
+                            required=True)
     parser_window_moco.add_argument('-w', '--window-size', default=60.0, type=float,
                                     help="Window size in seconds.",)
     xfm_types = ['QuickRigid', 'Rigid', 'DenseRigid', 'Affine', 'AffineFast']
@@ -357,6 +366,19 @@ def _generate_args() -> argparse.ArgumentParser:
                             required=True,
                             help='End time for SUV calculation in seconds from scan start',
                             type=float)
+
+    parser_seg_crop = subparsers.add_parser('seg-crop',help='Crop segmentation image to PET FOV')
+    _add_common_args(parser_seg_crop)
+    parser_seg_crop.add_argument('-s',
+                                 '--segmentation',
+                                 required=True,
+                                 help='Path to segmentation image',
+                                 type=str)
+
+    parser_eroded_wm = subparsers.add_parser('eroded-wm',
+                                             help='Add eroded white matter region to segmentation image')
+    _add_common_args(parser_eroded_wm)
+
     return parser
 
 
@@ -437,11 +459,11 @@ def main():
                                        start_time=args.start_time,
                                        end_time=args.end_time)
         case 'windowed_motion_corr':
-            motion_corr.windowed_motion_corr_to_target(input_image_path=args.input_img,
-                                                    out_image_path=args.out_img,
-                                                    motion_target_option=motion_target,
-                                                    w_size=args.window_size,
-                                                    type_of_transform=args.transform_type)
+            motion_corrector = motion_corr.MotionCorrect()
+            motion_corrector(input_image_path=args.input_img,
+                             output_image_path=args.out_img,
+                             motion_target_option=motion_target,
+                             window_duration=args.window_size)
         case 'rescale_image':
             input_img = ants.image_read(filename=args.input_img)
             out_img = image_operations_4d.rescale_image(input_image=input_img,
@@ -454,6 +476,15 @@ def main():
                                       end_time=args.end_time,
                                       weight=args.weight,
                                       dose=args.dose)
+        case 'seg_crop':
+            input_img = ants.image_read(filename=args.input_img)
+            seg_img = ants.image_read(filename=args.segmentation)
+            seg_cropped = segmentation_tools.seg_crop_to_pet_fov(pet_img=input_img,
+                                                                 segmentation_img=seg_img)
+            ants.image_write(seg_cropped,args.out_img)
+        case 'eroded_wm':
+            segmentation_tools.eroded_wm_segmentation(input_segmentation_path=args.input_img,
+                                                      out_segmentation_path=args.out_img)
 
 if __name__ == "__main__":
     main()

petpal/io/__init__.py

@@ -0,0 +1,9 @@
+from . import table
+from . import image
+
+def main():
+    print("PETPAL - Load and Save Module")
+
+
+if __name__ == "__main__":
+    main()

petpal/io/image.py

@@ -0,0 +1,39 @@
+"""
+Module for loading and saving images
+"""
+from typing import Optional
+from collections.abc import Callable
+import ants
+
+
+class ImageLoader:
+    """Class for reading image files, with extensions such as Nifti or MGZ.
+
+    See also: :py:docs:`~ants.image_read`.
+
+    Example:
+
+        .. code-block:: python
+
+            from petpal.io.image import ImageLoader
+
+            image_loader = ImageLoader()
+            my_img = image_loader.load('/path/to/img.nii.gz')
+
+    :ivar _loader: Function that loads an image file as an ants.ANTsImage object.
+    """
+    def __init__(self, loader: Optional[Callable[[str], ants.ANTsImage]] = None):
+        self._loader = loader or ants.image_read
+
+    def load(self, filename: str) -> ants.ANTsImage:
+        """Public read API that delegates to the configured reader.
+        
+        Args:
+            filename (str): Path to file that will be loaded as ANTsImage.
+    
+        Returns:
+            img (ants.ANTsImage): Image object loaded into Python."""
+        return self._loader(filename)
+
+    def __call__(self, filename: str) -> ants.ANTsImage:
+        return self.load(filename=filename)

petpal/io/table.py

@@ -0,0 +1,94 @@
+"""
+Module for reading and writing tables as TSV and CSV files.
+"""
+import os
+import tempfile
+from typing import Optional
+from collections.abc import Callable
+from pathlib import Path
+import dataclasses
+import pandas as pd
+
+
+def get_tabular_separator(ext: str) -> str:
+    """Get the separator corresponding to a given tabular data filetype.
+    
+    '.csv' will return ',' while '.tsv' and '.txt' will return '\t'. Any other input will raise a
+    ValueError.
+    
+    Args:
+        ext (str): Extension to get matching separator for.
+    
+    Returns:
+        sep (str): Separator matched from extension.
+    
+    Raises:
+        ValueError: If extension is not .csv or .tsv.
+    """
+    matching_separators = {'.csv': ',', '.tsv': '\t', '.txt': '\t'}
+    try:
+        return matching_separators[ext]
+    except ValueError as exc:
+        error_msg = f"Only accepted extensions are {matching_separators.keys()}. Got {ext}."
+        raise ValueError(error_msg) from exc
+
+
+@dataclasses.dataclass
+class TableSaver:
+    """
+    Class for saving Pandas Database objects as CSV or TSV files based on a provided path.
+
+    - Default behavior writes atomically (write temp file + os.replace) to avoid partial files.
+    - Accepts an injectable writer callable for testing or alternative persistence backends.
+
+    Example:
+
+        .. code-block:: python
+
+            import pandas as pd
+            from petpal.io.table import TableSaver
+
+            table_saver = TableSaver()
+            my_data = pd.DataFrame(data={'time': [0, 1, 2], 'value': [1, 4, 9]})
+            
+            # when file extension is .csv, uses commas to separate values
+            table_saver.save(my_data, 'table.csv')
+
+            # when file extension is .tsv or .txt, uses tabs to separate values
+            table_saver.save(my_data, 'table.txt')
+
+    :ivar _saver: Injectable tabular data saving function that saves a dataframe to a file.
+    """
+    def __init__(self, saver: Optional[Callable[[pd.DataFrame, str], None]] = None):
+        self._saver = saver or self._atomic_save
+
+    def _atomic_save(self, df: pd.DataFrame, path: str):
+        """Saves the data from a Pandas DataFrame object as a tabular file, such as CSV or TSV.
+        
+        Args:
+            df (pd.DataFrame): Pandas DataFrame with data to be saved.
+            path (str): Path to file where data is saved.
+        """
+        dirpath = os.path.dirname(os.path.abspath(path)) or "."
+        suffix = Path(path).suffix
+        sep = get_tabular_separator(ext=suffix)
+        fd, tmp_path = tempfile.mkstemp(prefix="tmp_petpal_", dir=dirpath, suffix=suffix)
+        os.close(fd)
+        try:
+            df.to_csv(tmp_path, sep=sep)
+            os.replace(tmp_path, path)
+        finally:
+            if os.path.exists(tmp_path):
+                try:
+                    os.remove(tmp_path)
+                except OSError:
+                    pass
+
+    def save(self, df: pd.DataFrame, path: str) -> None:
+        """API that applies the table saving function assigned to `self._saver`.
+        
+        Args:
+            df (pd.DataFrame): Pandas DataFrame with data to be saved.
+            path (str): Path to file where data is saved.
+        """
+        self._saver(df, path)

petpal/pipelines/preproc_steps.py

@@ -642,7 +642,7 @@ class ImageToImageStep(FunctionBasedStep):
         """
         defaults = dict(name=name, function=windowed_motion_corr_to_target,
                         input_image_path='', output_image_path='',
-                        motion_target_option='weighted_series_sum', w_size=60.0,
+                        motion_target_option='weighted_series_sum', window_duration=60.0,
                         verbose=verbose)
         override_dict = defaults | overrides
         try:

petpal/preproc/motion_corr.py

@@ -4,17 +4,23 @@ Provides methods to motion correct 4D PET data. Includes method
 4D input data to optimize contrast when computing motion correction or
 registration.
 """
+from typing import Optional
 import ants
 import numpy as np
+import pandas as pd
+from scipy.spatial.transform import Rotation
 
 from petpal.utils.useful_functions import gen_nd_image_based_on_image_list
-
-
 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
+from ..utils.scan_timing import (ScanTimingInfo,
+                                 get_window_index_pairs_from_durations,
+                                 get_window_index_pairs_for_image)
+from ..utils.useful_functions import (weighted_series_sum_over_window_indices,
+                                      coerce_outpath_extension)
+from ..utils.image_io import get_half_life_from_nifti, safe_copy_meta
+from ..io.table import TableSaver
+from ..io.image import ImageLoader
 
 
 def motion_corr(input_image_path: str,
@@ -425,11 +431,230 @@ def motion_corr_frames_above_mean_value_to_t1(input_image_path: str,
                                  type_of_transform=type_of_transform,
                                  transform_metric=transform_metric)
 
+class MotionCorrect:
+    """Run windowed motion correction on an image and save the result"""
+    def __init__(self,
+                 image_loader: Optional[ImageLoader] = None,
+                 table_saver: Optional[TableSaver] = None):
+        self.image_loader = image_loader or ImageLoader()
+        self.table_saver = table_saver or TableSaver()
+        self.input_img = None
+        self.target_img = None
+        self.scan_timing = None
+        self.half_life = None
+        self.reg_kwargs = self.default_reg_kwargs
+
+    @property
+    def default_reg_kwargs(self) -> dict:
+        """Default registration arguments passed on to :py:func:`~ants.registration`."""
+        reg_kwargs_default = {'aff_metric'               : 'mattes',
+                              'write_composite_transform': True,
+                              'interpolator'             : 'linear',
+                              'type_of_transform'        : 'DenseRigid'}
+        return reg_kwargs_default
+
+    def set_reg_kwargs(self, **reg_kwargs):
+        """Modify the registration arguments passed on to :py:func:`~ants.registration`."""
+        self.reg_kwargs.update(**reg_kwargs)
+
+    def get_input_scan_properties(self, input_image_path: str):
+        """Load input image and get half life and scan timing."""
+        self.input_img = self.image_loader.load(filename=input_image_path)
+        self.half_life = get_half_life_from_nifti(image_path=input_image_path)
+        self.scan_timing = ScanTimingInfo.from_nifti(image_path=input_image_path)
+
+    def get_target_img(self, input_image_path: str, motion_target_option: str | tuple):
+        """Get the motion target and load it as an image."""
+        motion_target_path = determine_motion_target(motion_target_option=motion_target_option,
+                                                     input_image_path=input_image_path)
+        self.target_img = self.image_loader.load(filename=motion_target_path)
+
+    def window_index_pairs(self, window_duration: float=300):
+        """The pair of indices corresponding to each window in the image."""
+        return get_window_index_pairs_from_durations(frame_durations=self.scan_timing.duration,
+                                                     window_duration=window_duration)
+
+    def window_target_img(self, start_index: int, end_index: int):
+        """Calculates the sum over frames in the target image within the provided time window."""
+        return weighted_series_sum_over_window_indices(input_image_4d=self.input_img,
+                                                        output_image_path=None,
+                                                        window_start_id=start_index,
+                                                        window_end_id=end_index,
+                                                        half_life=self.half_life,
+                                                        image_frame_info=self.scan_timing)
+
+    @staticmethod
+    def ants_xfm_to_rigid_pars(ants_xfm: ants.ANTsTransform):
+        """Convert an ants transform object to six parameters (3 translation, 3 rotation) and the
+        center reference point."""
+        xfm_in = np.reshape(ants_xfm.parameters,(4,3))
+        rot_matrix = xfm_in[:3,:]
+        translate_matrix = xfm_in[3,:]
+
+        scipy_rotation = Rotation.from_matrix(rot_matrix)
+        rot_pars = -scipy_rotation.as_euler('xyz',degrees=True)
+
+        xfm_out = list(rot_pars)+list(translate_matrix)+list(ants_xfm.fixed_parameters)
+        return xfm_out
+
+    def run_motion_correct(self, window_duration: float=300):
+        """Run motion correction on the input image to the target image."""
+        moco_img_stack = []
+        window_xfm_stack = []
+        input_img_list = ants.ndimage_to_list(self.input_img)
+        for _, (st_id, end_id) in enumerate(zip(*self.window_index_pairs(window_duration=window_duration))):
+            window_target_img = self.window_target_img(start_index=st_id, end_index=end_id)
+            window_registration = ants.registration(fixed=self.target_img,
+                                                    moving=window_target_img,
+                                                    **self.reg_kwargs)
+            window_xfm = ants.read_transform(window_registration['fwdtransforms'])
+            window_xfm_stack.append(self.ants_xfm_to_rigid_pars(window_xfm))
+            for frm_id in range(st_id, end_id):
+                moco_img_stack.append(ants.apply_transforms(fixed=self.target_img,
+                                      moving=input_img_list[frm_id],
+                                      transformlist=window_registration['fwdtransforms']))
+        moco_img = gen_timeseries_from_image_list(moco_img_stack)
+        return moco_img, np.asarray(window_xfm_stack)
+
+    def save_xfm_parameters(self, window_xfms: np.ndarray, filename: str):
+        """Save window transform parameters as a table.
+
+        Args:
+            window_xfms (np.ndarray): Rigid transform parameters ordered as rotation, translation,
+                centerpoint, then X, Y, Z axis, totalling 9 parameters for each window.
+            filename (str): Path to where table will be saved, including extension.
+
+        Raises:
+            ValueError: If transform type does not containt 'Rigid'. Saving transform parameters is
+                currently only available for rigid transforms."""
+        if 'Rigid' not in self.reg_kwargs['type_of_transform']:
+            raise ValueError("Saving transform parameters is only available for rigid "
+                             "registrations. Current transform type: "
+                             f"{self.reg_kwargs['type_of_transform']}")
+        xfm_columns = ['rot_x',
+                       'rot_y',
+                       'rot_z',
+                       'tra_x',
+                       'tra_y',
+                       'tra_z',
+                       'cen_x',
+                       'cen_y',
+                       'cen_z']
+        xfms_df = pd.DataFrame(data=window_xfms,
+                               columns=xfm_columns)
+        xfms_df.index.name = 'window'
+        csv_filename = coerce_outpath_extension(path=filename, ext='.csv')
+        self.table_saver.save(xfms_df,csv_filename)
+
+    def __call__(self, input_image_path: str,
+                 output_image_path: str,
+                 motion_target_option: str | tuple,
+                 window_duration: float = 300,
+                 copy_metadata: bool = True,
+                 save_xfm: bool = True,
+                 **reg_kwargs):
+        """Motion correct a dynamic PET image.
+
+        Divides image into segments of duration in seconds `window_duration` and register each frame
+        to a target image, using the same transformation on for every frame in each window.
+
+        Args:
+            input_image_path (str): Path to dynamic PET image.
+            output_image_path (str): Path to which motion corrected image is saved.
+            motion_target_option (str | tuple): Path to motion target image, or specify time window
+                such as (0,600) or preset option such as 'mean_image'. See
+                :py:func:`~petpal.preproc.motion_target.determine_motion_target`.
+            window_duration (float): Duration of each window in seconds. Default 300.
+            copy_metadata (bool): Copies metadata info from input image to output image. Default
+                True.
+            save_xfm (bool): Saves motion correction transform parameters for translation,
+                rotation, and rotation center point. Only compatible with rigid transforms. Default
+                True.
+        """
+        self.get_input_scan_properties(input_image_path=input_image_path)
+        self.get_target_img(input_image_path=input_image_path,
+                            motion_target_option=motion_target_option)
+
+        self.set_reg_kwargs(**reg_kwargs)
+
+        moco_img, window_xfms = self.run_motion_correct(window_duration=window_duration)
+
+        if save_xfm:
+            self.save_xfm_parameters(window_xfms=window_xfms, filename=output_image_path)
+        ants.image_write(image=moco_img, filename=output_image_path)
+        if copy_metadata:
+            safe_copy_meta(input_image_path=input_image_path, out_image_path=output_image_path)
+
+        return moco_img
+
+def gen_timeseries_from_image_list(image_list: list[ants.core.ANTsImage]) -> ants.core.ANTsImage:
+    r"""
+    Takes a list of ANTs ndimages, and generates a 4D ndimage. Undoes :func:`ants.ndimage_to_list`
+    so that we take a list of 3D images and generates a 4D image.
+
+    Args:
+        image_list (list[ants.core.ANTsImage]): A list of ndimages.
+
+    Returns:
+        ants.core.ANTsImage: 4D ndimage.
+    """
+    tmp_image = gen_nd_image_based_on_image_list(image_list)
+    return ants.list_to_ndimage(tmp_image, image_list)
+
+
+def _get_list_of_frames_above_total_mean(image_4d_path: str,
+                                         scale_factor: float = 1.0):
+    """
+    Get the frame indices where the frame mean is higher than the total mean of a 4D image.
+
+    This function calculates the mean voxel value of each frame in a 4D image and returns the
+        indices of the frames whose mean voxel value is greater than or equal to the mean voxel
+        value of the entire image, optionally scaled by a provided factor.
+
+    Args:
+        image_4d_path (str): Path to the input 4D PET image file.
+        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.
+
+    Returns:
+        list: A list of frame indices where the frame mean voxel value is greater than or equal to
+            the scaled total mean voxel value.
+
+    Example:
+
+        .. code-block:: python
+
+            from petpal.preproc.motion_corr import _get_list_of_frames_above_total_mean
+
+            frame_ids = _get_list_of_frames_above_total_mean(image_4d_path='/path/to/image.nii.gz',
+                                                                                  scale_factor=1.2)
+
+            print(frame_ids)  # Output: [0, 3, 5, ...]
+
+    Notes:
+        - The :func:`ants.image_read` from ANTsPy is used to read the 4D image into memory.
+        - The mean voxel value of the entire image is scaled by `scale_factor` for comparison with
+            individual frame means.
+        - The function uses the :func:`ants.ndimage_to_list` method from ANTsPy to convert the 4D
+            image into a list of 3D frames.
+
+    """
+    assert scale_factor > 0
+    image = ants.image_read(image_4d_path)
+    total_mean = scale_factor * image.mean()
+
+    frames_list = []
+    for frame_id, a_frame in enumerate(image.ndimage_to_list()):
+        if a_frame.mean() >= total_mean:
+            frames_list.append(frame_id)
+
+    return frames_list
+
 
 def windowed_motion_corr_to_target(input_image_path: str,
                                    out_image_path: str | None,
                                    motion_target_option: str | tuple,
-                                   w_size: float,
+                                   window_duration: float,
                                    type_of_transform: str = 'QuickRigid',
                                    interpolator: str = 'linear',
                                    copy_metadata: bool = True,
@@ -445,6 +670,10 @@ def windowed_motion_corr_to_target(input_image_path: str,
         The motion-target will determine the space of the output image. If we provide a T1 image
         as the `motion_target_option`, the output image will be in T1-space.
 
+    Note:
+        This function is deprecated. Use :py:func:`~petpal.preproc.motion_corr.MotionCorrect`
+        instead.
+
     Args:
         input_image_path (str): Path to the input 4D PET image file.
         out_image_path (str | None): Path to save the resulting motion-corrected image. If
@@ -452,7 +681,7 @@ def windowed_motion_corr_to_target(input_image_path: str,
         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`.
-        w_size (float): Window size in seconds for dividing the image into time sections.
+        window_duration (float): Window size in seconds for dividing the image into time sections.
         type_of_transform (str): Type of transformation to use in registration (default: 'QuickRigid').
         interpolator (str): Interpolation method for the transformation (default: 'linear').
         **kwargs: Additional arguments passed to :func:`ants.registration`.
@@ -462,7 +691,7 @@ def windowed_motion_corr_to_target(input_image_path: str,
 
     Workflow:
         1. Reads the input 4D image and splits it into individual frames.
-        2. Computes index windows based on the specified window size (`w_size`).
+        2. Computes index windows based on the specified window size (`window_duration`).
         3. Extracts necessary frame timing information and the tracer's half-life.
         4. For each window:
             - Calculates a weighted sum image for the window.
@@ -477,7 +706,7 @@ def windowed_motion_corr_to_target(input_image_path: str,
     """
     input_image = ants.image_read(filename=input_image_path)
     input_image_list = ants.ndimage_to_list(input_image)
-    window_idx_pairs = get_window_index_pairs_for_image(image_path=input_image_path, w_size=w_size)
+    window_idx_pairs = get_window_index_pairs_for_image(image_path=input_image_path, window_duration=window_duration)
     half_life = get_half_life_from_nifti(image_path=input_image_path)
     frame_timing_info = ScanTimingInfo.from_nifti(image_path=input_image_path)
 
@@ -490,13 +719,13 @@ def windowed_motion_corr_to_target(input_image_path: str,
     reg_kwargs = {**reg_kwargs_default, **kwargs}
 
     out_image = []
-    for win_id, (st_id, end_id) in enumerate(zip(*window_idx_pairs)):
-        window_tgt_image = weighted_series_sum_over_window_indecies(input_image_4d=input_image,
-                                                                    output_image_path=None,
-                                                                    window_start_id=st_id,
-                                                                    window_end_id=end_id,
-                                                                    half_life=half_life,
-                                                                    image_frame_info=frame_timing_info)
+    for _, (st_id, end_id) in enumerate(zip(*window_idx_pairs)):
+        window_tgt_image = weighted_series_sum_over_window_indices(input_image_4d=input_image,
+                                                                   output_image_path=None,
+                                                                   window_start_id=st_id,
+                                                                   window_end_id=end_id,
+                                                                   half_life=half_life,
+                                                                   image_frame_info=frame_timing_info)
         window_registration = ants.registration(fixed=target_image,
                                                 moving=window_tgt_image,
                                                 type_of_transform=type_of_transform,
@@ -516,66 +745,3 @@ def windowed_motion_corr_to_target(input_image_path: str,
         image_io.safe_copy_meta(input_image_path=input_image_path,
                                 out_image_path=out_image_path)
     return out_image
-
-def gen_timeseries_from_image_list(image_list: list[ants.core.ANTsImage]) -> ants.core.ANTsImage:
-    r"""
-    Takes a list of ANTs ndimages, and generates a 4D ndimage. Undoes :func:`ants.ndimage_to_list`
-    so that we take a list of 3D images and generates a 4D image.
-
-    Args:
-        image_list (list[ants.core.ANTsImage]): A list of ndimages.
-
-    Returns:
-        ants.core.ANTsImage: 4D ndimage.
-    """
-    tmp_image = gen_nd_image_based_on_image_list(image_list)
-    return ants.list_to_ndimage(tmp_image, image_list)
-
-
-def _get_list_of_frames_above_total_mean(image_4d_path: str,
-                                         scale_factor: float = 1.0):
-    """
-    Get the frame indices where the frame mean is higher than the total mean of a 4D image.
-
-    This function calculates the mean voxel value of each frame in a 4D image and returns the
-        indices of the frames whose mean voxel value is greater than or equal to the mean voxel
-        value of the entire image, optionally scaled by a provided factor.
-
-    Args:
-        image_4d_path (str): Path to the input 4D PET image file.
-        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.
-
-    Returns:
-        list: A list of frame indices where the frame mean voxel value is greater than or equal to
-            the scaled total mean voxel value.
-
-    Example:
-
-        .. code-block:: python
-
-            from petpal.preproc.motion_corr import _get_list_of_frames_above_total_mean
-
-            frame_ids = _get_list_of_frames_above_total_mean(image_4d_path='/path/to/image.nii.gz',
-                                                                                  scale_factor=1.2)
-
-            print(frame_ids)  # Output: [0, 3, 5, ...]
-
-    Notes:
-        - The :func:`ants.image_read` from ANTsPy is used to read the 4D image into memory.
-        - The mean voxel value of the entire image is scaled by `scale_factor` for comparison with
-            individual frame means.
-        - The function uses the :func:`ants.ndimage_to_list` method from ANTsPy to convert the 4D
-            image into a list of 3D frames.
-
-    """
-    assert scale_factor > 0
-    image = ants.image_read(image_4d_path)
-    total_mean = scale_factor * image.mean()
-
-    frames_list = []
-    for frame_id, a_frame in enumerate(image.ndimage_to_list()):
-        if a_frame.mean() >= total_mean:
-            frames_list.append(frame_id)
-
-    return frames_list

petpal/preproc/segmentation_tools.py

@@ -84,7 +84,9 @@ def segmentations_merge(segmentation_primary: np.ndarray,
             regions added.
     """
     for region in regions:
-        region_mask = (segmentation_secondary > region - 0.1) & (segmentation_secondary < region + 0.1)
+        condition_above = segmentation_secondary > region - 0.1
+        condition_below = segmentation_secondary < region + 0.1
+        region_mask = condition_above & condition_below
         segmentation_primary[region_mask] = region
     return segmentation_primary
 
@@ -229,8 +231,9 @@ def resample_segmentation(input_image_path: str,
     seg_image = nibabel.load(segmentation_image_path)
     pet_series = pet_image.get_fdata()
     image_first_frame = pet_series[:, :, :, 0]
+    to_vox_map_tuple = (image_first_frame.shape, pet_image.affine)
     seg_resampled = processing.resample_from_to(from_img=seg_image,
-                                                to_vox_map=(image_first_frame.shape, pet_image.affine),
+                                                to_vox_map=to_vox_map_tuple,
                                                 order=0)
     nibabel.save(seg_resampled, out_seg_path)
     if verbose:
@@ -238,23 +241,30 @@ def resample_segmentation(input_image_path: str,
 
 
 def vat_wm_ref_region(input_segmentation_path: str,
-                      out_segmentation_path: str):
+                      out_segmentation_path: str | None) -> ants.ANTsImage:
     """
     Generates the cortical white matter reference region described in O'Donnell
-    JL et al. (2024) PET Quantification of [18F]VAT in Human Brain and Its 
+    JL et al. (2024).
+     
+    Reference: O'Donnell JL et al. (2024). PET Quantification of [18F]VAT in Human Brain and Its 
     Test-Retest Reproducibility and Age Dependence. J Nucl Med. 2024 Jun 
     3;65(6):956-961. doi: 10.2967/jnumed.123.266860. PMID: 38604762; PMCID:
-    PMC11149597. Requires FreeSurfer segmentation with original label mappings.
+    PMC11149597.
+    
+    Requires FreeSurfer segmentation with original label mappings. 
 
     Args:
         input_segmentation_path (str): Path to segmentation on which white
             matter reference region is computed.
         out_segmentation_path (str): Path to which white matter reference
             region mask image is saved.
+
+    Returns:
+        wm_erode (ants.ANTsImage): Eroded white matter reference region mask image.
     """
     wm_regions = [2,41,251,252,253,254,255,77,3000,3001,3002,3003,3004,3005,
                   3006,3007,3008,3009,3010,3011,3012,3013,3014,3015,3016,3017,
-                  3018,3019,3020,3021,3022,3023,3024,3025,3026,3027,3018,3029,
+                  3018,3019,3020,3021,3022,3023,3024,3025,3026,3027,3028,3029,
                   3030,3031,3032,3033,3034,3035,4000,4001,4002,4003,4004,4005,
                   4006,4007,4008,4009,4010,4011,4012,4013,4014,4015,4016,4017,
                   4018,4019,4020,4021,4022,4023,4024,4025,4026,4027,4028,4029,
@@ -277,7 +287,45 @@ def vat_wm_ref_region(input_segmentation_path: str,
     wm_csf_eroded = ants.threshold_image(image=wm_csf_blurred, low_thresh=0.95, binary=True)
     wm_erode = ants.mask_image(image=wm_merged, mask=wm_csf_eroded)
 
-    ants.image_write(image=wm_erode, filename=out_segmentation_path)
+    if out_segmentation_path is not None:
+        ants.image_write(image=wm_erode, filename=out_segmentation_path)
+
+    return wm_erode
+
+
+def eroded_wm_segmentation(input_segmentation_path: str,
+                           out_segmentation_path: str | None,
+                           eroded_wm_region_mapping: int = 1) -> ants.ANTsImage:
+    """
+    Generates eroded white matter region on a segmentation image and merges it into the image,
+    saving result as a new segmentation image.
+
+    Requires FreeSurfer segmentation with original label mappings.
+    
+    Args:
+        input_segmentation_path (str): Path to input freesurfer segmentation, such as aparc+aseg or
+            wmparc.
+        out_segmentation_path (str): Path to output segmentation image with replaced values in
+            eroded whited matter region.
+        eroded_wm_region_mapping (int): Segmentation mapping for the eroded white matter region in
+            the output image. Default "1".
+
+    Returns:
+        seg_img (ants.ANTsImage): Input segmentation image with values in eroded white matter
+            replaced with `eroded_wm_region_mapping`.
+
+    See also:
+        :meth:`~petpal.preproc.segmentation_tools.vat_wm_ref_region` - function that generates the
+            eroded white matter region.
+    """
+    wm_erode = vat_wm_ref_region(input_segmentation_path=input_segmentation_path,
+                                 out_segmentation_path=None)
+    seg_img = ants.image_read(input_segmentation_path)
+    seg_img[wm_erode==1] = int(eroded_wm_region_mapping)
+    if out_segmentation_path is not None:
+        ants.image_write(image=seg_img, filename=out_segmentation_path)
+
+    return seg_img
 
 
 def vat_wm_region_merge(wmparc_segmentation_path: str,
@@ -500,7 +548,8 @@ def calc_vesselness_mask_from_quantiled_vesselness(input_image: ants.core.ANTsIm
                                                    morph_dil_radius: int = 0,
                                                    z_crop: int = 3) -> ants.core.ANTsImage:
     """
-    Generates a binary vesselness mask from a given vesselness image using quantile-based thresholding.
+    Generates a binary vesselness mask from a given vesselness image using quantile-based
+    thresholding.
 
     This function creates a binary mask by thresholding a vesselness image at a specified
     quantile of non-zero voxel values. Additionally, it allows for optional z-axis cropping

petpal/utils/scan_timing.py

@@ -248,62 +248,64 @@ class ScanTimingInfo:
                    decay=frame_decay)
 
 
-def get_window_index_pairs_from_durations(frame_durations: np.ndarray, w_size: float):
+def get_window_index_pairs_from_durations(frame_durations: np.ndarray, window_duration: float):
     r"""
     Computes start and end index pairs for windows of a given size based on frame durations.
 
     Args:
         frame_durations (np.ndarray): Array of frame durations in seconds.
-        w_size (float): Window size in seconds.
+        window_duration (float): Window size in seconds.
 
     Returns:
         np.ndarray: Array of shape (2, N), where the first row contains start indices,
             and the second row contains end indices for each window.
 
     Raises:
-        ValueError: If `w_size` is less than or equal to 0.
-        ValueError: If `w_size` is greater than the total duration of all frames.
+        ValueError: If `window_duration` is less than or equal to 0.
+        ValueError: If `window_duration` is greater than the total duration of all frames.
     """
-    if w_size <= 0:
-        raise ValueError("Window size has to be > 0")
-    if w_size > np.sum(frame_durations):
-        raise ValueError("Window size is larger than the whole scan.")
-    _tmp_w_ids = [0]
-    _w_dur_sum = 0
-    for frm_id, frm_dur in enumerate(frame_durations):
-        _w_dur_sum += frm_dur
-        if _w_dur_sum >= w_size:
-            _tmp_w_ids.append(frm_id + 1)
-            _w_dur_sum = 0
-    w_start_ids = np.asarray(_tmp_w_ids[:-1])
-    w_end_ids = np.asarray(_tmp_w_ids[1:])
-    id_pairs = np.vstack((w_start_ids, w_end_ids))
-    return id_pairs
-
-
-def get_window_index_pairs_for_image(image_path: str, w_size: float):
+    if window_duration <= 0:
+        raise ValueError("Window duration has to be > 0")
+    if window_duration > np.sum(frame_durations):
+        raise ValueError("Window duration is longer than the whole scan.")
+    window_edge_indices = [0]
+    window_duration_rolling_sum = 0
+    for frame_index, frame_dur in enumerate(frame_durations):
+        window_duration_rolling_sum += frame_dur
+        if window_duration_rolling_sum >= window_duration:
+            window_edge_indices.append(frame_index + 1)
+            window_duration_rolling_sum = 0
+    if window_edge_indices[-1]!=len(frame_durations):
+        window_edge_indices.append(len(frame_durations))
+    window_start_indices = np.asarray(window_edge_indices[:-1])
+    window_end_indices = np.asarray(window_edge_indices[1:])
+    index_pairs = np.vstack((window_start_indices, window_end_indices))
+    return index_pairs
+
+
+def get_window_index_pairs_for_image(image_path: str, window_duration: float):
     """
     Computes start and end index pairs for windows of a given size
     based on the frame durations of a NIfTI image.
 
     Args:
         image_path (str): Path to the NIfTI image file.
-        w_size (float): Window size in seconds.
+        window_duration (float): Window size in seconds.
 
     Returns:
         np.ndarray: Array of shape (2, N), where the first row contains start indices,
             and the second row contains end indices for each window.
 
     Raises:
-        ValueError: If `w_size` is less than or equal to 0.
-        ValueError: If `w_size` is greater than the total duration of all frames.
+        ValueError: If `window_duration` is less than or equal to 0.
+        ValueError: If `window_duration` is greater than the total duration of all frames.
 
     See Also:
         :func:`get_window_index_pairs_from_durations`
     """
     image_frame_info = ScanTimingInfo.from_nifti(image_path=image_path)
     return get_window_index_pairs_from_durations(frame_durations=image_frame_info.duration,
-                                                 w_size=w_size)
+                                                 window_duration=window_duration)
 
 
 def calculate_frame_reference_time(frame_duration: np.ndarray,

petpal/utils/useful_functions.py

@@ -2,13 +2,14 @@
 Module to handle abstracted functionalities
 """
 from collections.abc import Callable
+from pathlib import Path
+import re
 import os
 import nibabel
 import numpy as np
 import pandas as pd
 from scipy.interpolate import interp1d
 import ants
-import re
 
 from . import image_io, math_lib, scan_timing
 
@@ -208,12 +209,12 @@ def weighted_series_sum(input_image_path: str,
 
     return image_weighted_sum
 
-def weighted_series_sum_over_window_indecies(input_image_4d: ants.core.ANTsImage | str,
-                                             output_image_path: str | None,
-                                             window_start_id: int,
-                                             window_end_id: int,
-                                             half_life: float,
-                                             image_frame_info: scan_timing.ScanTimingInfo) -> ants.core.ANTsImage | None:
+def weighted_series_sum_over_window_indices(input_image_4d: ants.core.ANTsImage | str,
+                                            output_image_path: str | None,
+                                            window_start_id: int,
+                                            window_end_id: int,
+                                            half_life: float,
+                                            image_frame_info: scan_timing.ScanTimingInfo) -> ants.core.ANTsImage | None:
     r"""
     Computes a weighted series sum over a specified window of indices for a 4D PET image.
 
@@ -236,7 +237,7 @@ def weighted_series_sum_over_window_indecies(input_image_4d: ants.core.ANTsImage
     Note:
         If `output_image_path` is provided, the computed image will be saved to the specified path.
         This allows us to utilize ANTs pipelines
-        ``weighted_series_sum_over_window_indecies(...).get_center_of_mass()`` for example.
+        ``weighted_series_sum_over_window_indices(...).get_center_of_mass()`` for example.
 
     """
     if isinstance(input_image_4d, str):
@@ -532,3 +533,30 @@ def gen_nd_image_based_on_image_list(image_list: list[ants.ANTsImage]) -> ants.A
                                 origin=origin_4d,
                                 direction=direction_4d)
     return tmp_image
+
+def coerce_outpath_extension(path: str, ext: str) -> str:
+    """Coerce a path to the same absolute path with a provided filetype extension.
+    
+    Args:
+        path (str): Path to a file.
+        ext (str): Desired output extension.
+    
+    Returns:
+        abs_path_with_extension (str): Absolute path of the input file with the modified extension.
+    
+    Example:
+
+        .. code-block:: python
+
+            from petpal.utils.useful_functions import coerce_outpath_extension
+            
+            my_path = 'my_file.nii.gz'
+            my_csv_file = coerce_outpath_extension(my_path, '.csv')
+            print(my_csv_file) # prints '/current/working/directory/my_file.csv'
+
+    """
+    path_obj = Path(path)
+    while path_obj.suffix!='':
+        path_obj = path_obj.with_suffix('')
+    path_obj_with_suffix = path_obj.with_suffix(ext)
+    return str(path_obj_with_suffix.absolute())

{petpal-0.5.10.dist-info → petpal-0.6.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: petpal
-Version: 0.5.10
+Version: 0.6.1
 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.10.dist-info → petpal-0.6.1.dist-info}/RECORD

@@ -1,4 +1,4 @@
-petpal/__init__.py,sha256=rYYNkBkSkHGE18JIZPeVK8YBP7Z9c4mpQfKN0cdS75k,318
+petpal/__init__.py,sha256=4s4cfSb6_kjQZfP3yvxGU8DahC7aW1MO3eoMlyzbY-M,335
 petpal/cli/__init__.py,sha256=RiQTAOhSeqw5BTVvdancX3JQj4CG8F9Qe4qWZR9nKio,434
 petpal/cli/cli_graphical_analysis.py,sha256=L-YhkKkjmf6WLaAt8GDt1VmXaJXOsjMrbVvPhiTViYM,5386
 petpal/cli/cli_graphical_plots.py,sha256=_2tlGtZ0hIVyEYtGviEzGZMNhFymUPg4ZvSVyMtT_dA,3211
@@ -6,7 +6,7 @@ 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=ye_yw0ZQ4cSrMNemGR7cU9v6epD7Wbq1xaNAJwLzV_8,6889
 petpal/cli/cli_plot_tacs.py,sha256=XycaYQQl9Jp5jqDp3QXOlVT2sXHYYpYSraEArxsfJec,6479
-petpal/cli/cli_preproc.py,sha256=y5YvRliXC3zNY8oBJgTkzwPH9YNwWnEUWgiltUAv7AU,21850
+petpal/cli/cli_preproc.py,sha256=HSIKjUweRFGVkZH-7MtkaMQUOE8iTFCdkc9Sei2KedI,23473
 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
@@ -17,6 +17,9 @@ petpal/input_function/__init__.py,sha256=mWdwuVdMSgaHE0wviNE7TGGoOI9Y3sEKfKpBqLS
 petpal/input_function/blood_input.py,sha256=TNx3hL7M8Z_ZaZoTpt8LgLQhXnNyW0BOhgVZompwgxA,9206
 petpal/input_function/idif_necktangle.py,sha256=o5kyAqyT4C6o7zELY4EjyHrkJyX1BWcxvBqYiMjNyn4,7863
 petpal/input_function/pca_guided_idif.py,sha256=MPB59K5Z5oyIunIWFqFQts61z647xawLNkv8wICrKYM,44821
+petpal/io/__init__.py,sha256=Jh4Q4Zh9tBEorKAn3HqsIco1oSIv_bO8O-RZAS15u0Q,135
+petpal/io/image.py,sha256=C6wUUA7LyomrUE_EJi_SzLlrYMF4vUb76PixBLcR7j0,1140
+petpal/io/table.py,sha256=b3SUg9m1_q_1c7EBjvhVxKFio5TKiB7GSTlhFPmaM9E,3237
 petpal/kinetic_modeling/__init__.py,sha256=tW4yRH3TwaXPwKPqdkrbQmSk9hjrF1yRkV_C59PPboQ,382
 petpal/kinetic_modeling/fit_tac_with_rtms.py,sha256=HpK7VWVCCNoSQABY9i28vYpZsMRmvgs4vdcM_ZbdaYE,20971
 petpal/kinetic_modeling/graphical_analysis.py,sha256=e3ZXP8jA3ZgvC2T718-gukeBPlxCmOedCb2KlcGTUp8,51003
@@ -33,18 +36,18 @@ petpal/pipelines/__init__.py,sha256=Qt9VwqAvVjadHR6Lsja05XIVQONHTCs30NFxiBvf_2k,
 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=2KgeOvrXmjNrecTQMqIKMPv4tzvaRjr1FhvntVyvHX0,38391
-petpal/pipelines/preproc_steps.py,sha256=VC-KoMwxnfv0BxUEGneDjDy6HUYAub6JztaRHm3gm4M,37987
+petpal/pipelines/preproc_steps.py,sha256=woYBhOV18YG9ILfap-uqRPH6SLVltpEXSChsfS0cf9Y,37996
 petpal/pipelines/steps_base.py,sha256=W7GVN5-tsXe_7fvhoMRIlOk5ggY8V2wpSSmDONphLnQ,18311
 petpal/pipelines/steps_containers.py,sha256=TV4LkPK48OnAds10vLcsPI3qtWjHsmwr6XGu3hup59Q,33767
 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=UEaMw9YwnX-TOvmKxsA2qsU5GRR1Tq46l7gQz7TVzdk,31372
-petpal/preproc/motion_corr.py,sha256=dz10qjXBVTF_RH5RPZ68drUVX2qyj-MnZ674_Ccwz2Y,28670
+petpal/preproc/motion_corr.py,sha256=ke0pjh_jxlECjINwrGv-TZEM8geU7SnCDzrH8oViWTc,37454
 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=ZXo2u-EAUg5wZj7GGYLMEaOAfLv8OCOR-Gd0xvih6Y4,22358
 petpal/preproc/register.py,sha256=NKg8mt_XMGa5HBdxYZh3sMu_KMJ0W41VHlX4Zl8wlyE,14171
-petpal/preproc/segmentation_tools.py,sha256=Xi1ZnBs3sp23MHWPPOLjuXi6qp4-igwIPXFJ4B_Yzsk,27186
+petpal/preproc/segmentation_tools.py,sha256=CDD0NWV23rkNB56HjZGLsO4HbV61O57KsNzQsR4d06g,29106
 petpal/preproc/standard_uptake_value.py,sha256=YJIt0fl3fwMLl0tRYHpPPprMTaN4Q5JjQ5dx_CQX1nI,7494
 petpal/preproc/symmetric_geometric_transfer_matrix.py,sha256=Sr5qMTiNC76ZRKiGG5So7fceV_Lr0ql7UybO_kJgmNo,20360
 petpal/utils/__init__.py,sha256=PlxBIKUtNvtSFnNZqz8myszOysaYzS8nSILMK4haVGg,412
@@ -55,18 +58,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=CYtYuFquAnOQ2QfjXdeLjWrBDPM_k4vBI9oHQdpmVZ0,13908
+petpal/utils/scan_timing.py,sha256=tIx8t9Xc1bfVtVeagfHlGG6dRRjMKS2_Fzac2YfAATg,14304
 petpal/utils/stats.py,sha256=paFdwVPIjlAi0wh5xU4x5WeydjKsEHuwzMLcDG_WzPc,6449
 petpal/utils/testing_utils.py,sha256=eMt1kklxK3rl8tm74I3yVNDotKh1CnYWLINDT7rzboM,9557
 petpal/utils/time_activity_curve.py,sha256=ZjirIVy6rxG1cEZhYzFhbi9FEixlgdBpVqcZXXz6c3U,40379
-petpal/utils/useful_functions.py,sha256=md2kTLbs45MhrjdMhvDYcbflPTRNPspRSIHiOeIxEqY,21361
+petpal/utils/useful_functions.py,sha256=veHeGP1B2E7FhiY86tGL145T_SZiPgyLzJWZ0XKdra8,22277
 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.10.dist-info/METADATA,sha256=QadOtBFu8TbKNi-WDticmziZXkREKywO0pP4F-AxAcI,2618
-petpal-0.5.10.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-petpal-0.5.10.dist-info/entry_points.txt,sha256=0SZmyXqBxKzQg2eerDA16n2BdUEXyixEm0_AUo2dFns,653
-petpal-0.5.10.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-petpal-0.5.10.dist-info/RECORD,,
+petpal-0.6.1.dist-info/METADATA,sha256=vUbDCSqzh7gdYg10pJonUsmvowIzs9V0YkzE8b9sOqA,2617
+petpal-0.6.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+petpal-0.6.1.dist-info/entry_points.txt,sha256=0SZmyXqBxKzQg2eerDA16n2BdUEXyixEm0_AUo2dFns,653
+petpal-0.6.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+petpal-0.6.1.dist-info/RECORD,,