petpal 0.5.6__tar.gz → 0.5.8__tar.gz

{petpal-0.5.6 → petpal-0.5.8}/.gitignore

@@ -236,4 +236,7 @@ fabric.properties
 .idea/caches/build_file_checksums.ser
 
 # notebooks for testing new things
-debug_notebooks
+debug_notebooks
+
+# vscode
+.vscode

{petpal-0.5.6 → petpal-0.5.8}/PKG-INFO

@@ -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 → petpal-0.5.8}/petpal/cli/cli_pib_processing.py

@@ -94,12 +94,11 @@ def main():
 
     # Configure steps for kinetic modeling container
     suvr_step = ImageToImageStep(name='suvr',
-                                 function=petpal.preproc.image_operations_4d.suvr,
+                                 function=petpal.preproc.standard_uptake_value.suvr,
                                  input_image_path='',
                                  output_image_path='',
                                  ref_region=ref_region_label,
-                                 segmentation_image_path=seg_path,
-                                 verbose=False)
+                                 segmentation_image_path=seg_path)
 
     # Add steps to kinetic modeling container
     kinetic_modeling_container.add_step(step=suvr_step)

{petpal-0.5.6 → petpal-0.5.8}/petpal/cli/cli_preproc.py

@@ -33,7 +33,7 @@ Examples:
 
    .. code-block:: bash
 
-       petpal-preproc register-pet -i /path/to/input_img.nii.gz -o petpal_reg.nii.gz --motion-target 0 600 --anatomical /path/to/anat.nii.gz --half-life 6584
+       petpal-preproc register-pet -i /path/to/input_img.nii.gz -o petpal_reg.nii.gz --motion-target 0 600 --anatomical /path/to/anat.nii.gz
 
 
     * Write regional tacs:
@@ -54,7 +54,7 @@ Examples:
 
    .. code-block:: bash
 
-       petpal-preproc weighted-series-sum -i /path/to/input_img.nii.gz -o petpal_wss.nii.gz --half-life 6584 --start-time 1800 --end-time 7200
+       petpal-preproc weighted-series-sum -i /path/to/input_img.nii.gz -o petpal_wss.nii.gz --start-time 1800 --end-time 7200
 
 
    * SUVR Image:
@@ -95,8 +95,11 @@ import argparse
 import ants
 
 
-from ..utils import useful_functions
-from ..preproc import image_operations_4d, motion_corr, register, regional_tac_extraction
+from ..preproc import (image_operations_4d,
+                       motion_corr,
+                       register,
+                       regional_tac_extraction,
+                       standard_uptake_value)
 
 
 _PREPROC_EXAMPLES_ = r"""
@@ -106,13 +109,13 @@ Examples:
   - Windowed moco:
     petpal-preproc windowed-motion-corr -i /path/to/input_img.nii.gz -o petpal_moco.nii.gz --window-size 120 --transform-type QuickRigid
   - Register to anatomical:
-    petpal-preproc register-pet -i /path/to/input_img.nii.gz -o petpal_reg.nii.gz --motion-target 0 600 --anatomical /path/to/anat.nii.gz --half-life 6584
+    petpal-preproc register-pet -i /path/to/input_img.nii.gz -o petpal_reg.nii.gz --motion-target 0 600 --anatomical /path/to/anat.nii.gz
   - Write regional tacs:
     petpal-preproc write-tacs -i /path/to/input_img.nii.gz -p sub-001 -o /tmp/petpal_tacs -s /path/to/segmentation.nii.gz -l perlcyno -x
   - Write tacs, deprecated:
     petpal-preproc write-tacs-old -i /path/to/input_img.nii.gz -o /tmp/petpal_tacs --segmentation /path/to/segmentation.nii.gz --label-map-path /path/to/dseg.tsv
   - Half life weighted sum of series:
-    petpal-preproc weighted-series-sum -i /path/to/input_img.nii.gz -o petpal_wss.nii.gz --half-life 6584 --start-time 1800 --end-time 7200
+    petpal-preproc weighted-series-sum -i /path/to/input_img.nii.gz -o petpal_wss.nii.gz --start-time 1800 --end-time 7200
   - SUVR:
     petpal-preproc suvr -i /path/to/input_img.nii.gz -o petpal_suvr.nii.gz --segmentation /path/to/segmentation.nii.gz --ref-region 1
   - Gauss blur:
@@ -121,6 +124,8 @@ Examples:
     petpal-preproc rescale-image -i /path/to/input_img.nii.gz -o petpal_rescale.nii.gz --scale-factor 1000
   - Warp to atlas:
     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
 """
 
 
@@ -159,7 +164,7 @@ def _add_common_args(parser: argparse.ArgumentParser) -> None:
     """
     parser.add_argument('-o',
                         '--out-img',
-                        default='petpal_wss_output.nii.gz',
+                        default='petpal_preproc_output.nii.gz',
                         help='Output image filename')
     parser.add_argument('-i', '--input-img',required=True,help='Path to input image.',type=str)
 
@@ -183,10 +188,6 @@ def _generate_args() -> argparse.ArgumentParser:
     parser_wss = subparsers.add_parser('weighted-series-sum',
                                        help='Half-life weighted sum of 4D PET series.')
     _add_common_args(parser_wss)
-    parser_wss.add_argument('--half-life',
-                            required=True,
-                            help='Half life of radioisotope in seconds.',
-                            type=float)
     parser_wss.add_argument('--start-time',
                             required=False,
                             help='Start time of sum in seconds.',
@@ -215,9 +216,6 @@ def _generate_args() -> argparse.ArgumentParser:
                             required=True)
     parser_moco.add_argument('--transform-type', required=False,default='Rigid',
                              help='Transformation type (Rigid or Affine).',type=str)
-    parser_moco.add_argument('--half-life', required=False,
-                             help='Half life of radioisotope in seconds.'
-                                  'Required for some motion targets.',type=float)
 
     parser_tac = subparsers.add_parser('write-tacs',
                                        help='Write ROI TACs from 4D PET using segmentation masks.')
@@ -279,9 +277,19 @@ def _generate_args() -> argparse.ArgumentParser:
                             help='Path to segmentation image in anatomical space.')
     parser_suvr.add_argument('-r',
                              '--ref-region',
-                             help='Reference region to normalize SUVR to.',
+                             help='Reference region to normalize SUVR to. List multiple regions to '
+                                  'combine as one reference.',
                              required=True,
-                             type=int)
+                             type=int,
+                             nargs='+')
+    parser_suvr.add_argument('--start-time',
+                            required=True,
+                            help='Start time for SUVR calculation in seconds from scan start',
+                            type=float)
+    parser_suvr.add_argument('--end-time',
+                            required=True,
+                            help='End time for SUVR calculation in seconds from scan start',
+                            type=float)
 
     parser_blur = subparsers.add_parser('gauss-blur',help='Perform 3D gaussian blurring.')
     _add_common_args(parser_blur)
@@ -328,9 +336,27 @@ def _generate_args() -> argparse.ArgumentParser:
                             help="Motion target option. Can be an image path, "
                                  "'weighted_series_sum' or a tuple (i.e. '-t 0 600' for first "
                                  "ten minutes).")
-    parser_reg.add_argument('-l', '--half-life', help='Half life of radioisotope in seconds.',
-                            type=float)
 
+    parser_suv = subparsers.add_parser('suv',help='Standard Uptake Value (SUV) calculation')
+    _add_common_args(parser_suv)
+    parser_suv.add_argument('-w',
+                            '--weight',
+                            required=True,
+                            help='Weight of the participant in kg',
+                            type=float)
+    parser_suv.add_argument('-d',
+                            '--dose',
+                            required=True,
+                            help='Dose of radiotracer injected in MBq',
+                            type=float)
+    parser_suv.add_argument('--start-time',
+                            required=True,
+                            help='Start time for SUV calculation in seconds from scan start',
+                            type=float)
+    parser_suv.add_argument('--end-time',
+                            required=True,
+                            help='End time for SUV calculation in seconds from scan start',
+                            type=float)
     return parser
 
 
@@ -357,31 +383,27 @@ def main():
 
     match command:
         case 'weighted_series_sum':
-            useful_functions.weighted_series_sum(input_image_4d_path=args.input_img,
-                                                 out_image_path=args.out_img,
-                                                 half_life=args.half_life,
-                                                 start_time=args.start_time,
-                                                 end_time=args.end_time,
-                                                 verbose=True)
+            standard_uptake_value.weighted_sum_for_suv(input_image_path=args.input_img,
+                                                       output_image_path=args.out_img,
+                                                       start_time=args.start_time,
+                                                       end_time=args.end_time)
         case 'auto_crop':
             image_operations_4d.SimpleAutoImageCropper(input_image_path=args.input_img,
                                                     out_image_path=args.out_img,
                                                     thresh_val=args.thresh_val,
                                                     verbose=True)
         case 'motion_correction':
-            motion_corr.motion_corr(input_image_4d_path=args.input_img,
+            motion_corr.motion_corr(input_image_path=args.input_img,
                                     out_image_path=args.out_img,
                                     motion_target_option=motion_target,
                                     verbose=True,
-                                    type_of_transform=args.transform_type,
-                                    half_life=args.half_life)
+                                    type_of_transform=args.transform_type)
         case 'register_pet':
             register.register_pet(input_reg_image_path=args.input_img,
                                 out_image_path=args.out_img,
                                 reference_image_path=args.anatomical,
                                 motion_target_option=motion_target,
-                                verbose=True,
-                                half_life=args.half_life)
+                                verbose=True)
         case 'write_tacs_old':
             regional_tac_extraction.write_tacs(input_image_path=args.input_img,
                                             out_tac_dir=args.out_tac_dir,
@@ -408,10 +430,12 @@ def main():
                                         verbose=True,
                                         use_fwhm=True)
         case 'suvr':
-            image_operations_4d.suvr(input_image_path=args.input_img,
-                                     out_image_path=args.out_img,
-                                     segmentation_image_path=args.segmentation,
-                                     ref_region=args.ref_region)
+            standard_uptake_value.suvr(input_image_path=args.input_img,
+                                       output_image_path=args.out_img,
+                                       segmentation_image_path=args.segmentation,
+                                       ref_region=args.ref_region,
+                                       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,
@@ -423,6 +447,13 @@ def main():
             out_img = image_operations_4d.rescale_image(input_image=input_img,
                                                         rescale_constant=args.scale_factor)
             ants.image_write(image=out_img, filename=args.out_img)
+        case 'suv':
+            standard_uptake_value.suv(input_image_path=args.input_img,
+                                      output_image_path=args.out_img,
+                                      start_time=args.start_time,
+                                      end_time=args.end_time,
+                                      weight=args.weight,
+                                      dose=args.dose)
 
 if __name__ == "__main__":
     main()

{petpal-0.5.6 → petpal-0.5.8}/petpal/cli/cli_vat_processing.py

@@ -7,6 +7,7 @@ from petpal.kinetic_modeling import graphical_analysis,rtm_analysis
 from petpal.preproc import image_operations_4d, motion_corr, register, segmentation_tools
 from petpal.preproc import symmetric_geometric_transfer_matrix as sgtm
 import petpal.preproc.regional_tac_extraction
+import petpal.preproc.standard_uptake_value
 from petpal.utils.bids_utils import gen_bids_like_dir_path, gen_bids_like_filename, gen_bids_like_filepath
 from petpal.utils.image_io import km_regional_fits_to_tsv
 from petpal.utils import useful_functions
@@ -199,13 +200,13 @@ def vat_protocol(subjstring: str,
     wss_file_path = vat_bids_filepath(suffix='pet',folder='pet',space='mpr',desc='WSS')
     suvr_file_path = vat_bids_filepath(suffix='pet',folder='pet',space='mpr',desc='SUVR')
     if 'suvr' not in skip:
-        useful_functions.weighted_series_sum(input_image_4d_path=pet_reg_anat_file,
+        useful_functions.weighted_series_sum(input_image_path=pet_reg_anat_file,
                                              half_life=half_life,
                                              verbose=True,
                                              start_time=suvr_start,
                                              end_time=suvr_end,
                                              out_image_path=wss_file_path)
-        image_operations_4d.suvr(input_image_path=wss_file_path,
+        petpal.preproc.standard_uptake_value.suvr(input_image_path=wss_file_path,
                                  out_image_path=suvr_file_path,
                                  segmentation_image_path=vat_wm_ref_segmentation_file,
                                  ref_region=1,

{petpal-0.5.6 → petpal-0.5.8}/petpal/pipelines/pipelines.py

@@ -4,7 +4,6 @@ import copy
 from typing import Union
 from .steps_base import *
 from .steps_containers import StepsContainer, StepsPipeline
-from ..utils.image_io import get_half_life_from_nifti
 from ..utils.bids_utils import gen_bids_like_dir_path, gen_bids_like_filepath
 
 
@@ -805,9 +804,7 @@ class BIDS_Pipeline(BIDSyPathsForPipelines, StepsPipeline):
         containers = obj.step_containers
         
         containers["preproc"][0].input_image_path = obj.pet_path
-        containers["preproc"][1].kwargs['half_life'] = get_half_life_from_nifti(obj.pet_path)
         containers["preproc"][2].kwargs['reference_image_path'] = obj.anat_path
-        containers["preproc"][2].kwargs['half_life'] = get_half_life_from_nifti(obj.pet_path)
         containers["preproc"][3].segmentation_label_map_path = obj.seg_table
         containers["preproc"][3].segmentation_image_path = obj.seg_img
         containers["preproc"][4].raw_blood_tac_path = obj.blood_path

{petpal-0.5.6 → petpal-0.5.8}/petpal/pipelines/preproc_steps.py

@@ -612,9 +612,12 @@ class ImageToImageStep(FunctionBasedStep):
         Returns:
             ImageToImageStep: A new instance for motion correction frames above mean value.
         """
-        defaults = dict(name=name, function=motion_corr_frames_above_mean_value,
-                        input_image_path='', output_image_path='', motion_target_option='mean_image', verbose=verbose,
-                        half_life=None, )
+        defaults = dict(name=name,
+                        function=motion_corr_frames_above_mean_value,
+                        input_image_path='',
+                        output_image_path='',
+                        motion_target_option='mean_image',
+                        verbose=verbose)
         override_dict = defaults | overrides
         try:
             return cls(**override_dict)
@@ -649,7 +652,7 @@ class ImageToImageStep(FunctionBasedStep):
             return cls(**defaults)
 
     @classmethod
-    def default_register_pet_to_t1(cls, name:str = 'register_pet_to_t1', reference_image_path='', half_life:float=None, verbose=False, **overrides):
+    def default_register_pet_to_t1(cls, name:str = 'register_pet_to_t1', reference_image_path='', verbose=False, **overrides):
         """
         Creates a default instance for registering PET to T1 image using :func:`register_pet<petpal.preproc.register.register_pet>`.
         All paths are empty-strings.
@@ -657,8 +660,6 @@ class ImageToImageStep(FunctionBasedStep):
         Args:
             name (str): Name of the step. Defaults to 'register_pet_to_t1'
             reference_image_path (str): Path to the reference image.
-            half_life (float): Half-life value, in seconds, for the radiotracer. Used to
-                generate a weighted_series_sum image.
             verbose (bool): Whether to run in verbose mode.
             **overrides: Override default parameters.
 
@@ -668,7 +669,7 @@ class ImageToImageStep(FunctionBasedStep):
         """
         defaults = dict(name=name, function=register_pet, input_image_path='', output_image_path='',
                         reference_image_path=reference_image_path, motion_target_option='weighted_series_sum',
-                        verbose=verbose, half_life=half_life)
+                        verbose=verbose)
         override_dict = defaults | overrides
         try:
             return cls(**override_dict)

{petpal-0.5.6 → petpal-0.5.8}/petpal/preproc/__init__.py

@@ -1,8 +1,10 @@
 """Tools for preparing PET data for kinetic modeling and visualization"""
+from . import motion_target
 from . import image_operations_4d
 from . import motion_corr
 from . import partial_volume_corrections
 from . import register
+from . import standard_uptake_value
 from . import symmetric_geometric_transfer_matrix
 from . import segmentation_tools
 from . import decay_correction

{petpal-0.5.6 → petpal-0.5.8}/petpal/preproc/decay_correction.py

@@ -129,21 +129,22 @@ def decay_correct(input_image_path: str,
     return corrected_image
 
 
-def calculate_frame_decay_factor(frame_reference_time: float,
-                                 half_life: float) -> float:
-    """Calculate decay factor for a single frame, given the frame reference time and half life.
+def calculate_frame_decay_factor(frame_reference_time: np.ndarray,
+                                 half_life: float) -> np.ndarray:
+    """Calculate decay correction factors for a scan given the frame reference time and half life.
     
     Important: 
         The frame reference time should be the time at which average activity occurs,
-        not simply the midpoint. See preproc.scan_timing.calculate_frame_reference_time for more info.
-        
+        not simply the midpoint. See
+        :meth:`~petpal.utils.scan_timing.calculate_frame_reference_time` for more info.
+
     Args: 
-        frame_reference_time (float): Time at which the average activity occurs for the frame.
+        frame_reference_time (np.ndarray): Time at which the average activity occurs for the frame.
         half_life (float): Radionuclide half life.
 
     Returns: 
-        float: Decay Correction Factor for the frame.     
+        np.ndarray: Decay Correction Factors for each frame in the scan.
     """
-    decay_constant = math.log(2)/half_life
-    frame_decay_factor = math.exp((decay_constant)*frame_reference_time)
-    return frame_decay_factor
+    decay_constant = np.log(2)/half_life
+    frame_decay_factor = np.exp((decay_constant)*frame_reference_time)
+    return frame_decay_factor

{petpal-0.5.6 → petpal-0.5.8}/petpal/preproc/image_operations_4d.py

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