nifti_dynamic 0.1.0__tar.gz

nifti_dynamic-0.1.0/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: nifti_dynamic
+Version: 0.1.0
+Summary: A package for dynamic NIFTI analysis
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: nibabel
+Requires-Dist: indexed_gzip
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: tqdm
+Requires-Dist: ipython>=8.12.3
+Requires-Dist: scikit-image>=0.21.0
+Requires-Dist: matplotlib>=3.7.5
+Requires-Dist: pandas>=2.0.3
+
+# nifti_dynamic
+
+A Python package for dynamic NIFTI analysis.
+
+## Installation
+
+```bash
+pip install nifti_dynamic
+```
+
+## Usage
+
+See example.py
+
+

nifti_dynamic-0.1.0/README.md

@@ -0,0 +1,15 @@
+# nifti_dynamic
+
+A Python package for dynamic NIFTI analysis.
+
+## Installation
+
+```bash
+pip install nifti_dynamic
+```
+
+## Usage
+
+See example.py
+
+

nifti_dynamic-0.1.0/pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=42", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "nifti_dynamic"
+version = "0.1.0"
+description = "A package for dynamic NIFTI analysis"
+readme = "README.md"
+requires-python = ">=3.8"
+dependencies = [
+    "numpy",
+    "nibabel",
+    "indexed_gzip",
+    "scipy",
+    "scikit-learn",
+    "tqdm",
+    "ipython>=8.12.3",
+    "scikit-image>=0.21.0",
+    "matplotlib>=3.7.5",
+    "pandas>=2.0.3",
+]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+packages = ["nifti_dynamic"]

nifti_dynamic-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

nifti_dynamic-0.1.0/src/nifti_dynamic/__init__.py

@@ -0,0 +1,6 @@
+try:
+    import indexed_gzip
+except ImportError:
+    raise ImportError("The 'indexed_gzip' package is required for loading .nii.gz files fast. Please install it using 'pip install indexed_gzip'")
+
+from .patlak import voxel_patlak

nifti_dynamic-0.1.0/src/nifti_dynamic/aorta_rois.py

@@ -0,0 +1,339 @@
+#!/usr/bin/python
+"""
+Script for extracting volumes of interest (VOIs) from different aorta segments
+using a pre-segmented aorta mask
+"""
+
+import numpy as np
+import nibabel as nib
+from scipy.ndimage import (
+    center_of_mass, 
+    label, 
+    uniform_filter, 
+    binary_dilation, 
+    median_filter
+)
+from skimage.measure import regionprops
+from pathlib import Path
+from nifti_dynamic.utils import img_to_array_or_dataobj
+from nifti_dynamic.visualizations import plot_aorta_visualizations
+from enum import Enum
+
+class AortaSegment(Enum):
+    ASCENDING = 1
+    TOP = 2
+    DESCENDING = 3
+    DESCENDING_BOTTOM = 4
+
+
+def count_connected_components(slice_2d):
+    """Count connected components in a 2D slice"""
+    labeled, num = label(slice_2d)
+    return num
+
+
+def count_axial_components(volume):
+    """Count connected components along z-axis for each slice"""
+    return np.array([count_connected_components(volume[..., sl]) for sl in range(volume.shape[-1])])
+
+
+def find_pattern_transition(array, pattern):
+    """
+    Find index where pattern matches in array
+    Returns the middle point of the transition
+    """
+    indices = np.where(np.all(np.lib.stride_tricks.sliding_window_view(array, len(pattern)) == pattern, axis=1))[0]
+    if len(indices) != 1:
+        raise ValueError(f"Expected 1 match, found {len(indices)}")
+    
+    return indices[0] + len(pattern) // 2
+
+    
+def find_aortic_segments_boundaries(aorta_volume):
+    """
+    Identify axial indices where aorta transitions between segments
+    Returns the start and curve indices
+    """
+    # Calculate transitions between different aortic segments
+    islands = count_axial_components(aorta_volume)
+    islands = np.minimum(islands, 2)  # Cap max islands at 2
+    islands = median_filter(islands, size=5)  # Smooth counts
+    
+    # Find aortic transition points 1 -> 2 islands and 2->1 islands
+    ix_start = find_pattern_transition(islands, np.array([1, 1, 1, 1, 2, 2,2,2]))
+    ix_curve = find_pattern_transition(islands, np.array([2,2, 2, 2, 1, 1,1,1]))
+
+    return ix_start, ix_curve
+
+def maybe_fix_floaters(aorta):
+    print("WARNING: Aorta is discontinuous, discarding smallest islands. Please inspect visually")
+    labeled, _ = label(aorta)
+    if len(np.unique(labeled)) > 2:
+        frequencies = np.bincount(labeled.flatten())
+        #ignore background counts (ix=0)
+        ix_largest_island = np.argmax(frequencies[1:])+1
+        labeled = labeled==ix_largest_island
+    return labeled
+
+def segment_aorta(aorta):
+    # Segment aorta into four anatomical regions
+    aorta = aorta.copy()
+    aorta = maybe_fix_floaters(aorta)
+
+    ix_start, ix_curve = find_aortic_segments_boundaries(aorta)
+    
+    # Process pre-curve region
+    aorta_seg = aorta.copy().astype(np.int64)
+    aorta_seg[..., ix_curve:] = 0
+    
+    # Label components and determine ascending/descending parts
+    labeled, _ = label(aorta_seg)
+    
+    # Determine which label is ascending vs descending based on volume
+    if np.sum(labeled == 1) > np.sum(labeled == 2):
+        mapping = np.array([0, AortaSegment.DESCENDING.value, AortaSegment.ASCENDING.value])
+    else:
+        mapping = np.array([0, AortaSegment.ASCENDING.value, AortaSegment.DESCENDING.value])
+    
+    aorta_seg = mapping[labeled]
+    
+    # Mark top section
+    aorta_seg[..., ix_curve:] = aorta[..., ix_curve:] * AortaSegment.TOP.value
+    
+    # Mark descending bottom section
+    mask = (aorta_seg == AortaSegment.DESCENDING.value) & (np.arange(aorta.shape[-1]) < ix_start)[None, None, :]
+    aorta_seg[mask] = AortaSegment.DESCENDING_BOTTOM.value
+
+    return aorta_seg.astype(np.uint8)
+
+
+def create_cylindrical_voi(aorta_segment, pet, voxel_size, volume_ml=1.0, cylinder_width=3):
+    """
+    Create a cylindrical VOI inside the specified aorta segment
+    
+    Parameters:
+    -----------
+    aorta_segment : numpy.ndarray
+        Binary mask of the aorta segment
+    pet : numpy.ndarray
+        PET image data
+    voxel_size : tuple or array-like
+        Voxel dimensions in mm
+    volume_ml : float
+        Target volume in milliliters (default: 1.0)
+    cylinder_width : int
+        Width of the cylindrical cross-section (default: 3)
+        
+    Returns:
+    --------
+    numpy.ndarray
+        Binary mask of the VOI
+    """
+    # Calculate target volume in voxels
+    voxel_volume = np.prod(voxel_size)
+    target_voxels = int(volume_ml * 1000 / voxel_volume)
+    
+    # Create empty VOI
+    voi = np.zeros_like(aorta_segment, dtype=bool)
+    
+    # Calculate required slices for target volume
+    voxels_per_slice = cylinder_width**2
+    n_slices_needed = max(1, int(np.ceil(target_voxels / voxels_per_slice)))
+
+    # Find optimal placement based on PET uptake
+    pet_masked = np.ma.masked_array(data=pet, mask=~aorta_segment)
+    median_axial_uptake = np.ma.median(pet_masked, axis=(0,1)).filled(0)
+    median_axial_uptake = uniform_filter(median_axial_uptake, n_slices_needed)
+    
+    #Ensure that the start_slice lies sufficiently in the middle of the aorta segment
+    aorta_axial_mask_ixs = np.where(np.any(aorta_segment,axis=(0,1)))[0]
+    axial_ix_min, axial_ix_max = np.min(aorta_axial_mask_ixs), np.max(aorta_axial_mask_ixs)
+    if axial_ix_max-axial_ix_min < n_slices_needed:
+        raise Exception(f"The requested cylinder is too long {n_slices_needed} for the aorta segment {axial_ix_max-axial_ix_min}. Either reduce the cylinder volume or increase the cylinder width")
+    median_axial_uptake[:axial_ix_min + n_slices_needed//2 ] = 0
+    median_axial_uptake[ axial_ix_max - n_slices_needed//2:] = 0
+
+    start_slice = np.argmax(median_axial_uptake) - n_slices_needed//2
+
+    # Place VOI seeds at center of mass for each slice
+    pet_masked = pet_masked.filled(0)
+    for slc in range(start_slice, start_slice+n_slices_needed):
+        x, y = center_of_mass(pet_masked[..., slc])
+        x, y = int(round(x)), int(round(y))
+        voi[x, y, slc] = True
+
+    # Create cylindrical shape by dilating the seed points
+    dilation_mask = np.ones((cylinder_width, cylinder_width, 1), dtype=bool)
+    voi = binary_dilation(voi, dilation_mask)
+    
+    # Calculate actual volume achieved
+    actual_volume_ml = np.sum(voi) * voxel_volume / 1000
+    print(f"Created cylinder of length {n_slices_needed} with volume: {actual_volume_ml:.2f} ml (target: {volume_ml:.2f} ml)")
+    
+    return voi
+
+
+def average_early_pet_frames(dpet, frame_times_start, t_threshold=40):
+    """
+    Average PET frames up to the specified time threshold
+    
+    Parameters:
+    -----------
+    dpet : nibabel.Nifti1Image
+        Dynamic PET image
+    frame_times_start : numpy.ndarray
+        Start times for each frame
+    t_threshold : int
+        Time threshold in seconds (default: 40)
+        
+    Returns:
+    --------
+    numpy.ndarray
+        Averaged early PET frames
+    """
+    pet_arr = img_to_array_or_dataobj(dpet)
+    n_frames = np.sum(frame_times_start < t_threshold)
+    return pet_arr[..., :n_frames].mean(axis=-1)
+
+
+def refine_aorta_with_pet_uptake(aorta, pet):
+    """
+    Refine aorta segmentation based on PET uptake
+    Only keeps voxels with sufficient activity compared to median aorta uptake
+    """
+    pet_median_aorta = np.median(pet[aorta > 0])
+    activity_mask = pet > (2/3 * pet_median_aorta)
+    aorta_refined = aorta.copy()
+    aorta_refined[~activity_mask] = 0
+    return aorta_refined
+
+def extract_aorta_segments(aorta_mask, pet):
+    """
+    Extract VOIs from different aorta segments
+
+    Parameters:
+    -----------
+    aorta_mask : numpy.ndarray
+        Binary mask of the aorta from totalsegmentator
+    affine : numpy.ndarray
+        Affine matrix of the aorta image
+    dpet : nibabel.Nifti1Image
+        Dynamic PET image
+    frame_times_start : numpy.ndarray
+        Start times for each frame
+    t_threshold : int
+        Time threshold for early frames in seconds (default: 40)
+    volume_ml : float
+        Target volume in milliliters (default: 1.0)
+    cylinder_width : int
+        Width of the cylindrical cross-section (default: 3)
+        
+    Returns:
+    --------
+    tuple
+        (VOIs mask, segmented aorta mask)
+    """
+    affine = aorta_mask.affine
+    aorta_mask = aorta_mask.get_fdata()>0.5    
+    aorta_segments = segment_aorta(aorta_mask)
+    aorta_segments = refine_aorta_with_pet_uptake(aorta_segments, pet)
+    
+    return nib.Nifti1Image(aorta_segments.astype("int16"),affine)
+    
+
+def extract_aorta_vois(aorta_segments, pet, volume_ml=1.0, cylinder_width=3,segment=None):
+    """
+    Extract VOIs from different aorta segments
+    
+    Parameters:
+    -----------
+    aorta_mask : numpy.ndarray
+        Binary mask of the aorta from totalsegmentator
+    affine : numpy.ndarray
+        Affine matrix of the aorta image
+    dpet : nibabel.Nifti1Image
+        Dynamic PET image
+    frame_times_start : numpy.ndarray
+        Start times for each frame
+    t_threshold : int
+        Time threshold for early frames in seconds (default: 40)
+    volume_ml : float
+        Target volume in milliliters (default: 1.0)
+    cylinder_width : int
+        Width of the cylindrical cross-section (default: 3)
+        
+    Returns:
+    --------
+    tuple
+        (VOIs mask, segmented aorta mask)
+    """
+    affine = aorta_segments.affine
+        # Calculate voxel size from affine matrix
+    voxel_size = np.array(aorta_segments.header.get_zooms())
+    
+    aorta_segments_arr = aorta_segments.get_fdata().astype(np.int16)
+    # Initialize VOIs mask
+    vois = np.zeros_like(aorta_segments_arr)
+
+    # Do all Aorta Segments by default
+    if segment is None:
+        segs = AortaSegment
+    else:
+        segs = [segment]
+
+    # Create VOIs for each aorta segment
+    for seg in segs:
+        aorta_segment = aorta_segments_arr == seg.value
+        print("Extracting VOI for", seg.name)
+        if seg == AortaSegment.TOP:
+            voi = create_cylindrical_voi(aorta_segment.swapaxes(1,2), pet.swapaxes(1,2), voxel_size=voxel_size[[0,2,1]], 
+                                        volume_ml=volume_ml, cylinder_width=cylinder_width)
+            voi = voi.swapaxes(1,2)
+        else:
+            voi = create_cylindrical_voi(aorta_segment, pet, voxel_size=voxel_size, 
+                                        volume_ml=volume_ml, cylinder_width=cylinder_width)
+        vois[voi] = seg.value
+
+
+    vois = nib.Nifti1Image(vois,affine)
+    return vois
+
+
+def pipeline(aorta_mask, dpet, frame_times_start, t_threshold=40, volume_ml=1.0, cylinder_width=3, segment=None, image_path=None):
+    """
+    Extract VOIs from different aorta segments
+    
+    Parameters:
+    -----------
+    aorta_mask : numpy.ndarray
+        Binary mask of the aorta from totalsegmentator
+    affine : numpy.ndarray
+        Affine matrix of the aorta image
+    dpet : nibabel.Nifti1Image
+        Dynamic PET image
+    frame_times_start : numpy.ndarray
+        Start times for each frame
+    t_threshold : int
+        Time threshold for early frames in seconds (default: 40)
+    volume_ml : float
+        Target volume in milliliters (default: 1.0)
+    cylinder_width : int
+        Width of the cylindrical cross-section (default: 3)
+        
+    Returns:
+    --------
+    tuple
+        (VOIs mask, segmented aorta mask)
+    """
+    pet = average_early_pet_frames(dpet, frame_times_start, t_threshold)
+    aorta_segments = extract_aorta_segments(aorta_mask,pet)
+    aorta_vois = extract_aorta_vois(aorta_segments,pet,volume_ml=volume_ml,cylinder_width=cylinder_width,segment=segment)
+    
+    if image_path is not None:
+        print("Creating aorta visualization")
+        plot_aorta_visualizations(
+            pet,
+            aorta_segments,
+            aorta_vois,
+            image_path)
+    return aorta_segments, aorta_vois

nifti_dynamic-0.1.0/src/nifti_dynamic/conversion.py

@@ -0,0 +1,34 @@
+
+import os
+import subprocess
+import tempfile
+import shutil
+
+_default_dcm2niix_args = ["-m","y","-z","o","-b","y", "-ba","n"]
+
+def convert_dicom_to_nifti(dcmdir, nifti_out,sidecar_out=None):
+    assert str(nifti_out).endswith(".nii.gz"), "Output filename must be a nifti gz file e.g. (out.nii.gz)"
+    if sidecar_out is None:
+        sidecar_out = nifti_out.replace(".nii.gz",".json")
+
+    with tempfile.TemporaryDirectory() as tmp:
+        cmd = ["dcm2niix","-o", tmp] + _default_dcm2niix_args + [str(dcmdir)] 
+        subprocess.check_output(cmd)
+        nifti_tmp = _get_nifti_from_dir(tmp)
+        sidecar_tmp = _get_json_from_dir(tmp)
+
+    shutil.move(nifti_tmp,nifti_out)
+    shutil.move(sidecar_tmp,sidecar_out)
+
+def _get_nifti_from_dir(tempdir):
+    fs = os.listdir(tempdir)
+    fs = [x for x in fs if x.endswith(".nii.gz") and "ROI" not in x]
+    assert len(fs) == 1, "Too many or few output files; " + ",".join(fs)
+    return os.path.join(tempdir,fs[0])
+
+def _get_json_from_dir(tempdir):
+    fs = os.listdir(tempdir)
+    fs = [x for x in fs if x.endswith(".json") and "ROI" not in x]
+    assert len(fs) == 1, "Too many or few output files; " + ",".join(fs)
+    return os.path.join(tempdir,fs[0])
+

nifti_dynamic-0.1.0/src/nifti_dynamic/patlak.py

@@ -0,0 +1,81 @@
+from scipy.ndimage import gaussian_filter
+import numpy as np
+from tqdm import tqdm
+from scipy.integrate import cumulative_simpson
+from sklearn.linear_model import LinearRegression
+from .utils import OverlappedChunkIterator, img_to_array_or_dataobj
+
+def roi_patlak(roi_tac,if_tac,t,n_frames_linear_regression):
+    slopes, intercepts = _voxel_patlak_chunk(roi_tac,if_tac,t,n_frames_linear_regression=n_frames_linear_regression)
+    
+    with np.errstate(divide='ignore',invalid='ignore'):
+        _X = cumulative_simpson(if_tac,x=t/60,initial=0) / if_tac
+        X = _X.reshape(-1,1)
+
+    # Normalized voxel response
+    Y = roi_tac.reshape(-1, roi_tac.shape[-1]).T[:]
+    Y = Y/if_tac[:,None]
+    
+    return slopes, intercepts, X, Y
+
+
+def _voxel_patlak_chunk(arr,input_fun,t,n_frames_linear_regression=10):
+    
+    # Normalized cumsum AIF
+    with np.errstate(divide='ignore',invalid='ignore'):
+        _X = cumulative_simpson(input_fun,x=t/60,initial=0) / input_fun
+        X = _X[-n_frames_linear_regression:].reshape(-1,1)
+
+    # Normalized voxel response
+    Y = arr.reshape(-1, arr.shape[-1]).T[-n_frames_linear_regression:]
+    Y = Y/input_fun[-n_frames_linear_regression:,None]
+
+    #Linear regression
+    reg = LinearRegression().fit(X, Y)
+    slopes = reg.coef_.reshape(arr.shape[:-1])
+    intercepts = reg.intercept_.reshape(arr.shape[:-1])
+
+    return slopes, intercepts
+
+def voxel_patlak(img, input_fun, t, gaussian_filter_size=0, n_frames_linear_regression=10, axial_chunk_size=8):
+    """
+    Process image data in overlapping chunks, applying Gaussian smoothing and keeping only valid center portions.
+    
+    Args:
+        img: Input 4D image array
+        input_fun: Input function for Patlak analysis
+        t: Time points
+        gaussian_std: Standard deviation for Gaussian smoothing (default: 0)
+        n_frames_linear_regression: Number of frames for linear regression (default: 10)
+        axial_chunk_size: Size of axial chunks to process (default: 8)
+    """
+    img = img_to_array_or_dataobj(img)
+    out = np.zeros(img.shape[:-1])
+    out_intercepts = np.zeros(img.shape[:-1])
+    border_size = 3 * gaussian_filter_size if gaussian_filter_size > 0 else 0
+    
+    # Create iterator for overlapped chunks
+    chunk_iterator = OverlappedChunkIterator(
+        array_size=img.shape[-2],
+        chunk_size=axial_chunk_size,
+        border_size=border_size
+    )
+
+    # Process each chunk
+    for start_idx, end_idx, valid_start, valid_end, out_start, out_size in tqdm(chunk_iterator):
+        # Extract and process chunk
+        chunk = img[..., start_idx:end_idx, -n_frames_linear_regression:]
+        
+        # Apply Gaussian filter if needed
+        if gaussian_filter_size > 0:
+            chunk = gaussian_filter(chunk, sigma=[gaussian_filter_size, gaussian_filter_size, gaussian_filter_size, 0])
+        
+        # Process only the valid portion
+        valid_chunk = chunk[..., valid_start:valid_end, :]
+        slopes, intercepts = _voxel_patlak_chunk(valid_chunk, input_fun, t, n_frames_linear_regression)
+        
+        # Store results
+        out[..., out_start:out_start + out_size] = slopes
+        out_intercepts[..., out_start:out_start + out_size] = intercepts
+        
+    return out, out_intercepts

nifti_dynamic-0.1.0/src/nifti_dynamic/utils.py

@@ -0,0 +1,225 @@
+import numpy as np
+import nibabel as nib
+from collections import defaultdict
+from tqdm import tqdm
+from pathlib import Path
+import os 
+import csv 
+
+
+class OverlappedChunkIterator:
+    """
+    Iterator for processing array data in overlapping chunks with border handling.
+    Useful for operations that have edge effects (like Gaussian filtering).
+    """
+    def __init__(self, array_size, chunk_size, border_size):
+        """
+        Initialize the iterator.
+        
+        Args:
+            array_size: Size of the array to be chunked
+            chunk_size: Size of each chunk to process
+            border_size: Size of the border to overlap (e.g., 3 * gaussian_std)
+        """
+        self.array_size = array_size
+        self.chunk_size = chunk_size
+        self.border_size = border_size
+        self.effective_chunk_size = chunk_size - 2 * border_size
+        
+        if self.effective_chunk_size <= 0:
+            raise ValueError("Chunk size too small for given border size. "
+                           "Increase chunk_size or decrease border_size.")
+    
+    def __len__(self):
+        """
+        Calculate total number of chunks that will be processed.
+        """
+        return (self.array_size + self.effective_chunk_size - 1) // self.effective_chunk_size
+
+    def __iter__(self):
+        """
+        Returns iterator object (self).
+        """
+        self.current_pos = 0
+        return self
+    
+    def __next__(self):
+        """
+        Returns the next chunk information as a tuple:
+        (start_index, end_index, valid_start, valid_end, output_start, output_size)
+        """
+        if self.current_pos >= self.array_size:
+            raise StopIteration
+        
+        # Calculate padding sizes
+        pad_before = min(self.border_size, self.current_pos)
+        remaining_space = self.array_size - (self.current_pos + self.effective_chunk_size)
+        pad_after = min(self.border_size, max(0, remaining_space))
+        
+        # Calculate chunk indices
+        start_idx = self.current_pos - pad_before
+        end_idx = self.current_pos + self.effective_chunk_size + pad_after
+        
+        # Calculate valid region within chunk
+        valid_start = pad_before
+        valid_end = (end_idx - start_idx) - pad_after
+        
+        # Calculate output region
+        output_start = self.current_pos
+        output_size = min(self.effective_chunk_size, self.array_size - self.current_pos)
+        
+        # Prepare for next iteration
+        self.current_pos += self.effective_chunk_size
+        
+        return (start_idx, end_idx, valid_start, valid_end, output_start, output_size)
+
+def img_to_array_or_dataobj(img):
+    if isinstance(img, nib.nifti1.Nifti1Image):
+        return img.dataobj
+    elif isinstance(img, np.ndarray):
+        return img
+    elif isinstance(img,nib.arrayproxy.ArrayProxy):
+        return img
+    elif isinstance(img,Path) or isinstance(img,str):
+        return nib.load(img).dataobj
+    else:
+        raise ValueError("Input must be a Nifti1Image or a numpy array.")
+
+# def extract_tac(img, seg, max_roi_size=None):
+#     img = img_to_array_or_dataobj(img)
+#     seg = seg > 0
+#     nonzero = np.nonzero(seg)
+#     # Get min and max for each dimension
+#     xmin, xmax = np.min(nonzero[0]), np.max(nonzero[0])
+#     ymin, ymax = np.min(nonzero[1]), np.max(nonzero[1])
+#     zmin, zmax = np.min(nonzero[2]), np.max(nonzero[2])
+
+#     if max_roi_size is not None and (xmax-xmin)*(ymax-ymin)*(zmax-zmin) > max_roi_size:
+#         raise ValueError("Segmentation too big, use extract_multiple:tacs")
+
+#     seg_bb = img[xmin:xmax+1, ymin:ymax+1, zmin:zmax+1,:]
+#     tac = seg_bb[seg[xmin:xmax+1, ymin:ymax+1, zmin:zmax+1],:].mean(axis=0)
+
+#     return tac
+
+def extract_tac(img, seg, max_roi_size=None, return_std_n=False):
+    img = img_to_array_or_dataobj(img)
+    seg = seg > 0
+    nonzero = np.nonzero(seg)
+    # Get min and max for each dimension
+    xmin, xmax = np.min(nonzero[0]), np.max(nonzero[0])
+    ymin, ymax = np.min(nonzero[1]), np.max(nonzero[1])
+    zmin, zmax = np.min(nonzero[2]), np.max(nonzero[2])
+
+    ## Vectorized operations can use a lot of memory.
+    if max_roi_size is not None and (xmax-xmin)*(ymax-ymin)*(zmax-zmin)*img.shape[-1] > max_roi_size:
+        raise ValueError("Segmentation too big, use extract_multiple_tacs")
+
+    img_bb = img[xmin:xmax+1, ymin:ymax+1, zmin:zmax+1,:]
+    img_masked = img_bb[seg[xmin:xmax+1, ymin:ymax+1, zmin:zmax+1],:]
+    tac_mean = img_masked.mean(axis=0)
+
+    if return_std_n:
+        tac_std = img_masked.std(axis=0)
+        n_voxels = np.array([seg.sum()]*len(tac_mean))
+        return tac_mean, tac_std, n_voxels
+    else:
+        return tac_mean
+
+
+
+def extract_multiple_tacs(img, seg, max_roi_size_factor=2, return_std_n=False):
+    img = img_to_array_or_dataobj(img)
+
+    #handle static images
+    if img.ndim == 3:
+        img = np.asanyarray(img)
+        img = img[:,:,:,np.newaxis]
+
+    n_frames = img.shape[-1]
+    
+    targets = list(np.unique(seg))
+    if 0 in targets:
+        targets.remove(0)
+    
+    tacs_mean = {int(x):[] for x in targets}
+    tacs_std = {int(x):[] for x in targets}
+    tacs_n = {int(x):[] for x in targets}
+
+    #Try 4D cropping - faster but uses too much memory for larger organs
+
+    max_roi_size = max_roi_size_factor*np.prod(seg.shape)
+    for k in tqdm(tacs_mean):
+        try: 
+            tacs_mean[k], tacs_std[k], tacs_n[k] = extract_tac(img,seg==k,max_roi_size=max_roi_size,return_std_n=True)
+            targets.remove(k)
+        except ValueError as e:
+            print("label",k,"too large - will run without 4D cropping")
+            continue
+
+    #Iterate through each frame - slower but uses less memory
+    if len(targets) > 0:
+        for i in tqdm(range(n_frames)):
+            frame = img[...,i]
+            for k in targets:
+                seg_target = seg==k
+                arr = frame[seg_target]
+                tacs_mean[k].append(arr.mean())
+                tacs_std[k].append(arr.mean())
+                tacs_n[k].append(seg_target.sum())
+
+        for k in targets:
+            tacs_mean[k] = np.array(tacs_mean[k])
+            tacs_std[k] = np.array(tacs_std[k])
+            tacs_n[k] = np.array(tacs_n[k])
+
+    if return_std_n:
+        return tacs_mean, tacs_std, tacs_n
+    else:
+        return tacs_mean
+
+
+def save_tac(filename, tac_mean,tac_std = None, n_voxels = None):
+    filename = Path(filename)
+    os.makedirs(filename.parent,exist_ok=True)
+    data = {
+        "mu": [float(x) for x in tac_mean],
+        "std": [float(x) if tac_std is not None else None for x in tac_std],
+        "n": [int(x) if n_voxels is not None else None for x in n_voxels],
+    }
+    
+    with open(filename, 'w', newline='') as f:
+        writer = csv.writer(f)
+        writer.writerow(data.keys()) # Write headers
+        writer.writerows(zip(*data.values())) # Write data rows
+
+def load_tac(filename):
+    with open(filename, 'r', newline='') as f:
+        reader = csv.reader(f)
+        headers = next(reader) # Read header row
+        read_dict = {header: list(column) for header, column in zip(headers, zip(*reader))}
+    return np.array(read_dict["mu"]).astype(float), np.array(read_dict["std"]).astype(float), np.array(read_dict["n"]).astype(int)
+
+def _pooled_mean_variance(mu1,mu2,n1,n2,v1,v2):
+    n_comb = n1+n2
+    mu_comb = (mu1*n1+mu2*n2)/(n_comb)
+    var_comb = (n1*v1+n2*v2)/n_comb+n1*n2*np.square((mu1-mu2)/n_comb)
+    return np.nan_to_num(mu_comb), np.nan_to_num(var_comb), n_comb
+
+def combine_tacs(tacs_paths, tacs_output_path):
+    comb_mu = comb_var = comb_n = 0
+
+    for tac_p in tacs_paths:
+        mu, std, n = load_tac(tac_p)
+        comb_mu, comb_var, comb_n = _pooled_mean_variance(mu,comb_mu,n,comb_n,np.square(std),comb_var)
+
+    save_tac(tacs_output_path,comb_mu,np.sqrt(comb_var),comb_n)
+
+def load_and_combine_tacs(tacs_paths):
+    comb_mu = comb_var = comb_n = 0
+
+    for tac_p in tacs_paths:
+        mu, std, n = load_tac(tac_p)
+        comb_mu, comb_var, comb_n = _pooled_mean_variance(mu,comb_mu,n,comb_n,np.square(std),comb_var)
+
+    return comb_mu,np.sqrt(comb_var),comb_n

nifti_dynamic-0.1.0/src/nifti_dynamic/visualizations.py

@@ -0,0 +1,162 @@
+import nibabel as nib
+import numpy as np
+from pathlib import Path
+from matplotlib import pyplot as plt, colors
+from PIL import Image
+import tempfile
+import cv2
+from scipy.ndimage import median_filter
+
+_segmentation_cmap = colors.ListedColormap([
+    plt.cm.tab10(1),
+    plt.cm.tab10(0.99),
+    plt.cm.Set2(5/7),
+    plt.cm.Set2(4/7),
+])
+
+WORKING_DIR = Path("/depict/users/hinge/private/hedypet/dynamic")
+
+def _get_centerline(binary_mask_3d, projection_axis_idx):
+    true_value_coords = np.where(binary_mask_3d)
+    coords_on_last_dim_for_true = true_value_coords[-1]
+    coords_on_projection_axis_for_true = true_value_coords[projection_axis_idx]
+
+    unique_last_dim_indices = np.unique(coords_on_last_dim_for_true)
+    
+    if not unique_last_dim_indices.size:
+        return np.zeros(binary_mask_3d.shape[-1], dtype=int)
+    
+    fp_values = np.array([
+        coords_on_projection_axis_for_true[coords_on_last_dim_for_true == v_idx].mean().round()
+        for v_idx in unique_last_dim_indices
+    ])
+    
+    x_all_indices = np.arange(binary_mask_3d.shape[-1])
+    
+    interpolated_centerline = np.interp(x_all_indices, unique_last_dim_indices, fp_values)
+    
+    smoothed_interpolated_centerline = median_filter(interpolated_centerline, 5)
+    
+    return smoothed_interpolated_centerline.astype(int)
+
+def plot_aorta_visualizations(pet_array, segments_nifti, rois_nifti, save_path):
+    with tempfile.TemporaryDirectory() as tempdir:
+        tempdir_path = Path(tempdir)
+        
+        fig_sagittal, axs_sagittal = plt.subplots(1, 10, figsize=(9, 6))
+        xlim_sag, ylim_sag = _plot_single_aorta_view(
+            pet_array, segments_nifti, rois_nifti, 
+            view_axis=1, slice_definition="max", 
+            ax_raw=axs_sagittal[0], ax_overlay=axs_sagittal[1]
+        )
+        axs_sagittal[0].set_title("MIP")
+        axs_sagittal[2].set_title("Unrolled aorta segments", loc="left")
+        axs_sagittal[0].set_ylabel("Sagittal")
+        for i in range(4): 
+            _plot_single_aorta_view(
+                pet_array, segments_nifti, rois_nifti, 
+                view_axis=1, slice_definition=i + 1, 
+                ax_raw=axs_sagittal[(i + 1) * 2], ax_overlay=axs_sagittal[(i + 1) * 2 + 1], 
+                xlim=xlim_sag, ylim=ylim_sag
+            )
+        plt.subplots_adjust(wspace=0, hspace=0)
+        plt.savefig(tempdir_path / "aorta_sagittal_views.jpg", dpi=300, bbox_inches='tight')
+        plt.close(fig_sagittal)
+
+        fig_coronal, axs_coronal = plt.subplots(1, 10, figsize=(9, 6))
+        xlim_cor, ylim_cor = _plot_single_aorta_view(
+            pet_array, segments_nifti, rois_nifti, 
+            view_axis=0, slice_definition="max", 
+            ax_raw=axs_coronal[0], ax_overlay=axs_coronal[1]
+        )
+        axs_coronal[0].set_ylabel("Coronal")
+        for i in range(4): 
+            _plot_single_aorta_view(
+                pet_array, segments_nifti, rois_nifti, 
+                view_axis=0, slice_definition=i + 1, 
+                ax_raw=axs_coronal[(i + 1) * 2], ax_overlay=axs_coronal[(i + 1) * 2 + 1], 
+                xlim=xlim_cor, ylim=ylim_cor
+            )
+        plt.subplots_adjust(wspace=0, hspace=0)
+        plt.savefig(tempdir_path / "aorta_coronal_views.jpg", dpi=300, bbox_inches='tight')
+        plt.close(fig_coronal)
+
+        img_sagittal = Image.open(tempdir_path / "aorta_sagittal_views.jpg")
+        img_coronal = Image.open(tempdir_path / "aorta_coronal_views.jpg")
+        combined_img_array = np.concatenate((np.array(img_sagittal), np.array(img_coronal)), axis=0)
+        Image.fromarray(combined_img_array).save(save_path)
+
+def _plot_single_aorta_view(pet_array, segments_nifti, rois_nifti, 
+                           view_axis, slice_definition, 
+                           ax_raw, ax_overlay, xlim=None, ylim=None):
+    segments_array = segments_nifti.get_fdata()
+    rois_array = rois_nifti.get_fdata()
+    
+    roi4_mask = (rois_array == 4)
+    vmax = pet_array[roi4_mask].mean() * 1.6 if np.any(roi4_mask) else pet_array.max() * 0.5
+
+    pet_view_2d, segments_view_2d, rois_view_2d = None, None, None
+
+    if slice_definition == "max":
+        pet_view_2d = np.rot90(pet_array.max(axis=view_axis))
+        segments_view_2d = np.rot90(segments_array.max(axis=view_axis))
+        rois_view_2d = np.rot90(rois_array.max(axis=view_axis))
+    elif isinstance(slice_definition, int): 
+        centerline_coords = _get_centerline(segments_array == slice_definition, view_axis)
+        depth_indices = np.arange(pet_array.shape[2])
+        
+        if view_axis == 0: 
+            pet_view_2d = np.rot90((pet_array[centerline_coords, :, depth_indices]).T, 1)
+            rois_view_2d = np.rot90((rois_array[centerline_coords, :, depth_indices]).T, 1)
+            segments_view_2d = np.rot90((segments_array[centerline_coords, :, depth_indices]).T, 1)
+        elif view_axis == 1: 
+            pet_view_2d = np.rot90(pet_array[:, centerline_coords, depth_indices])
+            rois_view_2d = np.rot90(rois_array[:, centerline_coords, depth_indices])
+            segments_view_2d = np.rot90(segments_array[:, centerline_coords, depth_indices])
+        else:
+             raise ValueError(f"Unsupported view_axis for centerline slicing: {view_axis}")
+    else:
+        raise ValueError(f"Invalid slice_definition argument: {slice_definition}")
+    
+    active_region_coords_x, active_region_coords_y = (
+        np.where(segments_view_2d > 0) if slice_definition == "max" 
+        else np.where(segments_view_2d == slice_definition)
+    )
+
+    if not active_region_coords_x.size or not active_region_coords_y.size:
+        xmin_calc, xmax_calc = 0, pet_view_2d.shape[0]
+        ymin_calc, ymax_calc = 0, pet_view_2d.shape[1]
+    else:
+        xmin_calc = max(0, active_region_coords_x.min() - 10)
+        xmax_calc = min(pet_view_2d.shape[0], active_region_coords_x.max() + 10)
+        ymin_calc = max(0, active_region_coords_y.min() - 10)
+        ymax_calc = min(pet_view_2d.shape[1], active_region_coords_y.max() + 10)
+
+    current_xlim = xlim if xlim is not None else [xmin_calc, xmax_calc]
+    current_ylim = ylim if ylim is not None else [ymin_calc, ymax_calc]
+    
+    current_xlim = [max(0, int(current_xlim[0])), min(pet_view_2d.shape[0], int(current_xlim[1]))]
+    current_ylim = [max(0, int(current_ylim[0])), min(pet_view_2d.shape[1], int(current_ylim[1]))]
+
+    pet_cropped = pet_view_2d[current_xlim[0]:current_xlim[1], current_ylim[0]:current_ylim[1]]
+    segments_cropped = segments_view_2d[current_xlim[0]:current_xlim[1], current_ylim[0]:current_ylim[1]]
+    rois_cropped = rois_view_2d[current_xlim[0]:current_xlim[1], current_ylim[0]:current_ylim[1]]
+    
+    segment_contours_mask = np.zeros(pet_cropped.shape, dtype=np.uint8)
+    for seg_val in [1, 2, 3, 4]: 
+        binary_segment_for_contour = (segments_cropped == seg_val).astype("uint8")
+        contours, _ = cv2.findContours(binary_segment_for_contour, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        cv2.drawContours(segment_contours_mask, contours, -1, seg_val, thickness=1)
+    
+    ax_raw.imshow(pet_cropped, cmap="gray_r", vmax=vmax)
+    ax_raw.set_xticks([])
+    ax_raw.set_yticks([])
+
+    ax_overlay.imshow(pet_cropped, cmap="gray_r", vmax=vmax)
+    ax_overlay.imshow(segment_contours_mask, alpha=(segment_contours_mask > 0) * 1.0, interpolation="nearest", vmin=1, vmax=4, cmap=_segmentation_cmap)
+    ax_overlay.imshow(segments_cropped, alpha=(segments_cropped > 0) * 0.4, interpolation="nearest", vmin=1, vmax=4, cmap=_segmentation_cmap)
+    ax_overlay.imshow(rois_cropped, alpha=(rois_cropped > 0) * 1.0, interpolation="nearest", vmin=1, vmax=4, cmap=_segmentation_cmap)
+    ax_overlay.set_xticks([])
+    ax_overlay.set_yticks([])
+
+    return current_xlim, current_ylim

nifti_dynamic-0.1.0/src/nifti_dynamic.egg-info/PKG-INFO

@@ -0,0 +1,35 @@
+Metadata-Version: 2.4
+Name: nifti_dynamic
+Version: 0.1.0
+Summary: A package for dynamic NIFTI analysis
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: numpy
+Requires-Dist: nibabel
+Requires-Dist: indexed_gzip
+Requires-Dist: scipy
+Requires-Dist: scikit-learn
+Requires-Dist: tqdm
+Requires-Dist: ipython>=8.12.3
+Requires-Dist: scikit-image>=0.21.0
+Requires-Dist: matplotlib>=3.7.5
+Requires-Dist: pandas>=2.0.3
+
+# nifti_dynamic
+
+A Python package for dynamic NIFTI analysis.
+
+## Installation
+
+```bash
+pip install nifti_dynamic
+```
+
+## Usage
+
+See example.py
+
+

nifti_dynamic-0.1.0/src/nifti_dynamic.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+README.md
+pyproject.toml
+src/nifti_dynamic/__init__.py
+src/nifti_dynamic/aorta_rois.py
+src/nifti_dynamic/conversion.py
+src/nifti_dynamic/patlak.py
+src/nifti_dynamic/utils.py
+src/nifti_dynamic/visualizations.py
+src/nifti_dynamic.egg-info/PKG-INFO
+src/nifti_dynamic.egg-info/SOURCES.txt
+src/nifti_dynamic.egg-info/dependency_links.txt
+src/nifti_dynamic.egg-info/requires.txt
+src/nifti_dynamic.egg-info/top_level.txt

nifti_dynamic-0.1.0/src/nifti_dynamic.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

nifti_dynamic-0.1.0/src/nifti_dynamic.egg-info/requires.txt

@@ -0,0 +1,10 @@
+numpy
+nibabel
+indexed_gzip
+scipy
+scikit-learn
+tqdm
+ipython>=8.12.3
+scikit-image>=0.21.0
+matplotlib>=3.7.5
+pandas>=2.0.3

nifti_dynamic-0.1.0/src/nifti_dynamic.egg-info/top_level.txt

@@ -0,0 +1 @@
+nifti_dynamic