antspymm 1.4.9__py3-none-any.whl → 1.5.1__py3-none-any.whl

antspymm/__init__.py

@@ -5,7 +5,10 @@ except:
     pass
 
 from .mm import get_data
+from .mm import ants_to_nibabel_affine
 from .mm import get_dti
+from .mm import efficient_tensor_fit
+from .mm import efficient_dwi_fit
 from .mm import triangular_to_tensor
 from .mm import dti_numpy_to_image
 from .mm import transform_and_reorient_dti

antspymm/mm.py

@@ -93,6 +93,7 @@ __all__ = ['version',
     'loop_timeseries_censoring',
     'clean_tmp_directory',
     'validate_nrg_file_format',
+    'ants_to_nibabel_affine',
     'dict_to_dataframe']
 
 from pathlib import Path
@@ -288,12 +289,44 @@ def get_antsimage_keys(dictionary):
     """
     return [key for key, value in dictionary.items() if isinstance(value, ants.core.ants_image.ANTsImage)]
 
-def to_nibabel(img: "ants.core.ants_image.ANTsImage"):
-    with tempfile.TemporaryDirectory() as tmp:
-        temp_file_name = os.path.join(tmp, str(uuid.uuid1()) + '.nii.gz')
-        ants.image_write(img, temp_file_name)
-        nibabel_image = nib.load(temp_file_name)
-        return(nibabel_image)
+def to_nibabel(img: "ants.core.ants_image.ANTsImage") -> nib.Nifti1Image:
+    """
+    Convert an ANTsPy image to a Nibabel Nifti1Image in-memory, using correct spatial affine.
+
+    Parameters:
+        img (ants.ANTsImage): An image from ANTsPy.
+
+    Returns:
+        nib.Nifti1Image: The corresponding Nibabel image with spatial orientation in RAS.
+    """
+    array_data = img.numpy()  # get voxel data as NumPy array
+    affine = ants_to_nibabel_affine(img)
+    return nib.Nifti1Image(array_data, affine)
+
+def ants_to_nibabel_affine(ants_img):
+    """
+    Convert an ANTsPy image (in LPS space) to a Nibabel-compatible affine (in RAS space).
+    Handles 2D, 3D, 4D input (only spatial dimensions are encoded in the affine).
+    
+    Returns:
+        4x4 np.ndarray affine matrix in RAS space.
+    """
+    spatial_dim = ants_img.dimension
+    spacing = np.array(ants_img.spacing)
+    origin = np.array(ants_img.origin)
+    direction = np.array(ants_img.direction).reshape((spatial_dim, spatial_dim))
+    # Compute rotation-scale matrix
+    affine_linear = direction @ np.diag(spacing)
+    # Build full 4x4 affine with identity in homogeneous bottom row
+    affine = np.eye(4)
+    affine[:spatial_dim, :spatial_dim] = affine_linear
+    affine[:spatial_dim, 3] = origin
+    affine[3, 3]=1
+    # Convert LPS -> RAS by flipping x and y
+    lps_to_ras = np.diag([-1, -1, 1, 1])
+    affine = lps_to_ras @ affine
+    return affine
+
 
 def dict_to_dataframe(data_dict, convert_lists=True, convert_arrays=True, convert_images=True, verbose=False):
     """
@@ -2195,7 +2228,7 @@ def transform_and_reorient_dti( fixed, moving_dti, composite_transform, py_based
     if verbose:
         print("reorient tensors locally: compose and get reo image")
     locrot = ants.deformation_gradient( ants.image_read(composite_transform), 
-        to_rotation = True, py_based=py_based )
+        to_rotation = True, py_based=py_based ).numpy()
     rebaser = np.dot( np.transpose( fixed.direction  ), moving_dti.direction )
     if verbose:
         print("convert UT to full tensor")
@@ -3522,6 +3555,239 @@ def trim_dti_mask( fa, mask, param=4.0 ):
     trim_mask = ants.iMath(trim_mask,"MD",paramVox-1)
     return trim_mask
 
+
+
+def efficient_tensor_fit( gtab, fit_method, imagein, maskin, diffusion_model='DTI', 
+                         chunk_size=10, num_threads=1, verbose=True):
+    """
+    Efficient and optionally parallelized tensor reconstruction using DiPy.
+
+    Parameters
+    ----------
+    gtab : GradientTable
+        Dipy gradient table.
+    fit_method : str
+        Tensor fitting method (e.g. 'WLS', 'OLS', 'RESTORE').
+    imagein : ants.ANTsImage
+        4D diffusion-weighted image.
+    maskin : ants.ANTsImage
+        Binary brain mask image.
+    diffusion_model : string, optional
+        DTI, FreeWater, DKI.
+    chunk_size : int, optional
+        Number of slices (along z-axis) to process at once.
+    num_threads : int, optional
+        Number of threads to use (1 = single-threaded).
+    verbose : bool, optional
+        Print status updates.
+    
+    Returns
+    -------
+    tenfit : TensorFit or FreeWaterTensorFit
+        Fitted tensor model.
+    FA : ants.ANTsImage
+        Fractional anisotropy image.
+    MD : ants.ANTsImage
+        Mean diffusivity image.
+    RGB : ants.ANTsImage
+        RGB FA map.
+    """
+    assert imagein.dimension == 4, "Input image must be 4D"
+
+    import ants
+    import numpy as np
+    import dipy.reconst.dti as dti
+    import dipy.reconst.fwdti as fwdti
+    from dipy.reconst.dti import fractional_anisotropy
+    from dipy.reconst.dti import color_fa
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+
+    img_data = imagein.numpy()
+    mask = maskin.numpy().astype(bool)
+    X, Y, Z, N = img_data.shape
+    if verbose:
+        print(f"Input shape: {img_data.shape}, Processing in chunks of {chunk_size} slices.")
+
+    model = fwdti.FreeWaterTensorModel(gtab) if diffusion_model == 'FreeWater' else dti.TensorModel(gtab, fit_method=fit_method)
+
+    def process_chunk(z_start):
+        z_end = min(Z, z_start + chunk_size)
+        local_data = img_data[:, :, z_start:z_end, :]
+        local_mask = mask[:, :, z_start:z_end]
+        masked_data = local_data * local_mask[..., None]
+        masked_data = np.nan_to_num(masked_data, nan=0)
+        fit = model.fit(masked_data)
+        FA_chunk = fractional_anisotropy(fit.evals)
+        FA_chunk[np.isnan(FA_chunk)] = 1
+        FA_chunk = np.clip(FA_chunk, 0, 1)
+        MD_chunk = dti.mean_diffusivity(fit.evals)
+        RGB_chunk = color_fa(FA_chunk, fit.evecs)
+        return z_start, z_end, FA_chunk, MD_chunk, RGB_chunk
+
+    FA_vol = np.zeros((X, Y, Z), dtype=np.float32)
+    MD_vol = np.zeros((X, Y, Z), dtype=np.float32)
+    RGB_vol = np.zeros((X, Y, Z, 3), dtype=np.float32)
+
+    chunks = range(0, Z, chunk_size)
+    if num_threads > 1:
+        with ThreadPoolExecutor(max_workers=num_threads) as executor:
+            futures = {executor.submit(process_chunk, z): z for z in chunks}
+            for f in as_completed(futures):
+                z_start, z_end, FA_chunk, MD_chunk, RGB_chunk = f.result()
+                FA_vol[:, :, z_start:z_end] = FA_chunk
+                MD_vol[:, :, z_start:z_end] = MD_chunk
+                RGB_vol[:, :, z_start:z_end, :] = RGB_chunk
+    else:
+        for z in chunks:
+            z_start, z_end, FA_chunk, MD_chunk, RGB_chunk = process_chunk(z)
+            FA_vol[:, :, z_start:z_end] = FA_chunk
+            MD_vol[:, :, z_start:z_end] = MD_chunk
+            RGB_vol[:, :, z_start:z_end, :] = RGB_chunk
+
+    b0 = ants.slice_image(imagein, axis=3, idx=0)
+    FA = ants.copy_image_info(b0, ants.from_numpy(FA_vol))
+    MD = ants.copy_image_info(b0, ants.from_numpy(MD_vol))
+    RGB_channels = [ants.copy_image_info(b0, ants.from_numpy(RGB_vol[..., i])) for i in range(3)]
+    RGB = ants.merge_channels(RGB_channels)
+
+    return model.fit(img_data * mask[..., None]), FA, MD, RGB
+
+
+
+def efficient_dwi_fit(gtab, diffusion_model, imagein, maskin,
+                  model_params=None, bvals_to_use=None,
+                  chunk_size=10, num_threads=1, verbose=True):
+    """
+    Efficient and optionally parallelized diffusion model reconstruction using DiPy.
+
+    Parameters
+    ----------
+    gtab : GradientTable
+        DiPy gradient table.
+    diffusion_model : str
+        One of ['DTI', 'FreeWater', 'DKI'].
+    imagein : ants.ANTsImage
+        4D diffusion-weighted image.
+    maskin : ants.ANTsImage
+        Binary brain mask image.
+    model_params : dict, optional
+        Additional parameters passed to model constructors.
+    bvals_to_use : list of int, optional
+        Subset of b-values to use for the fit (e.g., [0, 1000, 2000]).
+    chunk_size : int, optional
+        Z-axis slice chunk size.
+    num_threads : int, optional
+        Number of parallel threads.
+    verbose : bool, optional
+        Whether to print status messages.
+
+    Returns
+    -------
+    fit : dipy ModelFit
+        The fitted model object.
+    FA : ants.ANTsImage or None
+        Fractional anisotropy image (if applicable).
+    MD : ants.ANTsImage or None
+        Mean diffusivity image (if applicable).
+    RGB : ants.ANTsImage or None
+        Color FA image (if applicable).
+    """
+    import ants
+    import numpy as np
+    import dipy.reconst.dti as dti
+    import dipy.reconst.fwdti as fwdti
+    import dipy.reconst.dki as dki
+    from dipy.core.gradients import gradient_table
+    from dipy.reconst.dti import fractional_anisotropy, color_fa, mean_diffusivity
+    from concurrent.futures import ThreadPoolExecutor, as_completed
+
+    assert imagein.dimension == 4, "Input image must be 4D"
+    model_params = model_params or {}
+
+    img_data = imagein.numpy()
+    mask = maskin.numpy().astype(bool)
+    X, Y, Z, N = img_data.shape
+
+    if verbose:
+        print(f"[INFO] Image shape: {img_data.shape}")
+        print(f"[INFO] Using model: {diffusion_model}")
+        print(f"[INFO] Chunk size: {chunk_size} | Threads: {num_threads}")
+
+    # Filter shells if specified
+    if bvals_to_use is not None:
+        bvals_to_use = set(bvals_to_use)
+        sel = np.isin(gtab.bvals, list(bvals_to_use))
+        img_data = img_data[..., sel]
+        gtab = gradient_table(gtab.bvals[sel], gtab.bvecs[sel])
+        if verbose:
+            print(f"[INFO] Selected b-values: {sorted(bvals_to_use)}")
+            print(f"[INFO] Selected volumes: {sel.sum()} / {N}")
+
+    # Choose model
+    def get_model(name, gtab, **params):
+        if name == 'DTI':
+            return dti.TensorModel(gtab, **params)
+        elif name == 'FreeWater':
+            return fwdti.FreeWaterTensorModel(gtab)
+        elif name == 'DKI':
+            return dki.DiffusionKurtosisModel(gtab, **params)
+        else:
+            raise ValueError(f"Unsupported model: {name}")
+
+    model = get_model(diffusion_model, gtab, **model_params)
+
+    # Output volumes initialized to zero
+    FA_vol = np.zeros((X, Y, Z), dtype=np.float32)
+    MD_vol = np.zeros((X, Y, Z), dtype=np.float32)
+    RGB_vol = np.zeros((X, Y, Z, 3), dtype=np.float32)
+    has_tensor_metrics = diffusion_model in ['DTI', 'FreeWater']
+
+    def process_chunk(z_start):
+        z_end = min(Z, z_start + chunk_size)
+        local_data = img_data[:, :, z_start:z_end, :]
+        local_mask = mask[:, :, z_start:z_end]
+        masked_data = local_data * local_mask[..., None]
+        masked_data = np.nan_to_num(masked_data, nan=0)
+        fit = model.fit(masked_data)
+        if has_tensor_metrics and hasattr(fit, 'evals') and hasattr(fit, 'evecs'):
+            FA = fractional_anisotropy(fit.evals)
+            FA[np.isnan(FA)] = 1
+            FA = np.clip(FA, 0, 1)
+            MD = mean_diffusivity(fit.evals)
+            RGB = color_fa(FA, fit.evecs)
+            return z_start, z_end, FA, MD, RGB
+        return z_start, z_end, None, None, None
+
+    # Run processing
+    chunks = range(0, Z, chunk_size)
+    if num_threads > 1:
+        with ThreadPoolExecutor(max_workers=num_threads) as executor:
+            futures = {executor.submit(process_chunk, z): z for z in chunks}
+            for f in as_completed(futures):
+                z_start, z_end, FA, MD, RGB = f.result()
+                if FA is not None:
+                    FA_vol[:, :, z_start:z_end] = FA
+                    MD_vol[:, :, z_start:z_end] = MD
+                    RGB_vol[:, :, z_start:z_end, :] = RGB
+    else:
+        for z in chunks:
+            z_start, z_end, FA, MD, RGB = process_chunk(z)
+            if FA is not None:
+                FA_vol[:, :, z_start:z_end] = FA
+                MD_vol[:, :, z_start:z_end] = MD
+                RGB_vol[:, :, z_start:z_end, :] = RGB
+
+    b0 = ants.slice_image(imagein, axis=3, idx=0)
+    FA_img = ants.copy_image_info(b0, ants.from_numpy(FA_vol)) if has_tensor_metrics else None
+    MD_img = ants.copy_image_info(b0, ants.from_numpy(MD_vol)) if has_tensor_metrics else None
+    RGB_img = (ants.merge_channels([
+        ants.copy_image_info(b0, ants.from_numpy(RGB_vol[..., i])) for i in range(3)
+    ]) if has_tensor_metrics else None)
+
+    full_fit = model.fit(img_data * mask[..., None])
+    return full_fit, FA_img, MD_img, RGB_img
+
+
 def dipy_dti_recon(
     image,
     bvalsfn,
@@ -3532,7 +3798,7 @@ def dipy_dti_recon(
     mask_closing = 5,
     fit_method='WLS',
     trim_the_mask=2.0,
-    free_water=False,
+    diffusion_model='DTI',
     verbose=False ):
     """
     DiPy DTI reconstruction - building on the DiPy basic DTI example
@@ -3559,7 +3825,8 @@ def dipy_dti_recon(
 
     trim_the_mask : float >=0 post-hoc method for trimming the mask
 
-    free_water : boolean
+    diffusion_model : string
+        DTI, FreeWater, DKI
 
     verbose : boolean
 
@@ -3612,47 +3879,22 @@ def dipy_dti_recon(
     if verbose:
         print("recon dti.TensorModel",flush=True)
 
-    def justthefit( gtab, fit_method, imagein, maskin, free_water=False ):
-        if fit_method is None:
-            return None, None, None, None
-        maskedimage=[]
-        for myidx in range(imagein.shape[3]):
-            b0 = ants.slice_image( imagein, axis=3, idx=myidx)
-            maskedimage.append( b0 * maskin )
-        maskedimage = ants.list_to_ndimage( imagein, maskedimage )
-        maskdata = maskedimage.numpy()
-        if free_water:
-            tenmodel = fwdti.FreeWaterTensorModel(gtab)
-        else:
-            tenmodel = dti.TensorModel(gtab,fit_method=fit_method)
-        tenfit = tenmodel.fit(maskdata)
-        FA = fractional_anisotropy(tenfit.evals)
-        FA[np.isnan(FA)] = 1
-        FA = np.clip(FA, 0, 1)
-        MD1 = dti.mean_diffusivity(tenfit.evals)
-        MD1 = ants.copy_image_info( b0, ants.from_numpy( MD1.astype(np.float32) ) )
-        FA = ants.copy_image_info(  b0, ants.from_numpy( FA.astype(np.float32) ) )
-        FA, MD1 = impute_fa( FA, MD1 )
-        RGB = color_fa(FA.numpy(), tenfit.evecs)
-        RGB = ants.from_numpy( RGB.astype(np.float32) )
-        RGB0 = ants.copy_image_info( b0, ants.slice_image( RGB, axis=3, idx=0 ) )
-        RGB1 = ants.copy_image_info( b0, ants.slice_image( RGB, axis=3, idx=1 ) )
-        RGB2 = ants.copy_image_info( b0, ants.slice_image( RGB, axis=3, idx=2 ) )
-        RGB = ants.merge_channels( [RGB0,RGB1,RGB2] )
-        return tenfit, FA, MD1, RGB
-
     bvecs = repair_bvecs( bvecs )
-    gtab = gradient_table(bvals, bvecs, atol=2.0 )
-    if free_water:
-        free_water=len( np.unique( bvals ) ) >= 3
-    tenfit, FA, MD1, RGB = justthefit( gtab, fit_method, image, maskdil, free_water=free_water )
+    gtab = gradient_table(bvals, bvecs=bvecs, atol=2.0 )
+    mynt=1
+    threads_env = os.environ.get("ITK_GLOBAL_DEFAULT_NUMBER_OF_THREADS")
+    if threads_env is not None:
+        mynt = int(threads_env)
+    tenfit, FA, MD1, RGB = efficient_dwi_fit( gtab, diffusion_model, image, maskdil,
+                                             num_threads=mynt )
     if verbose:
         print("recon dti.TensorModel done",flush=True)
 
     # change the brain mask based on high FA values
     if trim_the_mask > 0 and fit_method is not None:
         mask = trim_dti_mask( FA, mask, trim_the_mask )
-        tenfit, FA, MD1, RGB = justthefit( gtab, fit_method, image, mask, free_water=free_water  )
+        tenfit, FA, MD1, RGB = efficient_dwi_fit( gtab, diffusion_model, image, maskdil,
+                                             num_threads=mynt )
 
     return {
         'tensormodel' : tenfit,
@@ -3736,7 +3978,7 @@ def joint_dti_recon(
     fit_method='WLS',
     impute = False,
     censor = True,
-    free_water = False,
+    diffusion_model = 'DTI',
     verbose = False ):
     """
     1. pass in subject data and 1mm JHU atlas/labels
@@ -3791,7 +4033,8 @@ def joint_dti_recon(
 
     censor : boolean
 
-    free_water : boolean
+    diffusion_model : string
+        DTI, FreeWater, DKI
 
     verbose : boolean
 
@@ -3911,7 +4154,7 @@ def joint_dti_recon(
             img_LRdwp, bval_LR, bvec_LR,
             mask = brain_mask,
             fit_method=fit_method,
-            mask_dilation=0, free_water=free_water, verbose=True )
+            mask_dilation=0, diffusion_model=diffusion_model, verbose=True )
     if verbose:
         print("recon done", flush=True)
 
@@ -4204,16 +4447,15 @@ def dwi_deterministic_tracking(
     if verbose:
         print("begin tracking",flush=True)
 
-    dwi_img = to_nibabel(dwi)
-    affine = dwi_img.affine
+    affine = ants_to_nibabel_affine(dwi)
 
     if isinstance( bvals, str ) or isinstance( bvecs, str ):
         bvals, bvecs = read_bvals_bvecs(bvals, bvecs)
     bvecs = repair_bvecs( bvecs )
-    gtab = gradient_table(bvals, bvecs, atol=2.0 )
+    gtab = gradient_table(bvals, bvecs=bvecs, atol=2.0 )
     if mask is None:
         mask = ants.threshold_image( fa, fa_thresh, 2.0 ).iMath("GetLargestComponent")
-    dwi_data = dwi_img.get_fdata()
+    dwi_data = dwi.numpy() # dwi_img.get_fdata()
     dwi_mask = mask.numpy() == 1
     dti_model = dti.TensorModel(gtab,fit_method=fit_method)
     if verbose:
@@ -4223,7 +4465,7 @@ def dwi_deterministic_tracking(
     from dipy.tracking.stopping_criterion import ThresholdStoppingCriterion
     stopping_criterion = ThresholdStoppingCriterion(fa.numpy(), fa_thresh)
     from dipy.data import get_sphere
-    sphere = get_sphere('symmetric362')
+    sphere = get_sphere(name='symmetric362')
     from dipy.direction import peaks_from_model
     if peak_indices is None:
         # problems with multi-threading ...
@@ -4282,7 +4524,7 @@ def dwi_deterministic_tracking(
     streamlines = Streamlines(streamlines_generator)
     from dipy.io.stateful_tractogram import Space, StatefulTractogram
     from dipy.io.streamline import save_tractogram
-    sft = StatefulTractogram(streamlines, dwi_img, Space.RASMM)
+    sft = None # StatefulTractogram(streamlines, dwi_img, Space.RASMM)
     if verbose:
         print("streamlines done", flush=True)
     return {
@@ -4384,15 +4626,14 @@ def dwi_closest_peak_tracking(
     if verbose:
         print("begin tracking",flush=True)
 
-    dwi_img = to_nibabel(dwi)
-    affine = dwi_img.affine
+    affine = ants_to_nibabel_affine(dwi)
     if isinstance( bvals, str ) or isinstance( bvecs, str ):
         bvals, bvecs = read_bvals_bvecs(bvals, bvecs)
     bvecs = repair_bvecs( bvecs )
-    gtab = gradient_table(bvals, bvecs, atol=2.0 )
+    gtab = gradient_table(bvals, bvecs=bvecs, atol=2.0 )
     if mask is None:
         mask = ants.threshold_image( fa, fa_thresh, 2.0 ).iMath("GetLargestComponent")
-    dwi_data = dwi_img.get_fdata()
+    dwi_data = dwi.numpy()
     dwi_mask = mask.numpy() == 1
 
 
@@ -4429,7 +4670,7 @@ def dwi_closest_peak_tracking(
     streamlines = Streamlines(streamlines_generator)
     from dipy.io.stateful_tractogram import Space, StatefulTractogram
     from dipy.io.streamline import save_tractogram
-    sft = StatefulTractogram(streamlines, dwi_img, Space.RASMM)
+    sft = None # StatefulTractogram(streamlines, dwi_img, Space.RASMM)
     if verbose:
         print("streamlines done", flush=True)
     return {
@@ -4465,8 +4706,7 @@ def dwi_streamline_pairwise_connectivity( streamlines, label_image, labels_to_co
     from dipy.tracking.streamline import Streamlines
     keep_streamlines = Streamlines()
 
-
-    affine = to_nibabel(label_image).affine
+    affine = ants_to_nibabel_affine(label_image) # to_nibabel(label_image).affine
 
     lin_T, offset = utils._mapping_to_voxel(affine)
     label_image_np = label_image.numpy()
@@ -4526,7 +4766,7 @@ def dwi_streamline_pairwise_connectivity_old(
     volUnit = np.prod( ants.get_spacing( label_image ) )
     labels = label_image.numpy()
 
-    affine = to_nibabel(label_image).affine
+    affine = ants_to_nibabel_affine(label_image) # to_nibabel(label_image).affine
 
     import numpy as np
     from dipy.io.image import load_nifti_data, load_nifti, save_nifti
@@ -4618,7 +4858,7 @@ def dwi_streamline_connectivity(
     volUnit = np.prod( ants.get_spacing( label_image ) )
     labels = label_image.numpy()
 
-    affine = to_nibabel(label_image).affine
+    affine = ants_to_nibabel_affine(label_image) # to_nibabel(label_image).affine
 
     import numpy as np
     from dipy.io.image import load_nifti_data, load_nifti, save_nifti
@@ -4708,7 +4948,7 @@ def dwi_streamline_connectivity_old(
     volUnit = np.prod( ants.get_spacing( label_image ) )
     labels = label_image.numpy()
 
-    affine = to_nibabel(label_image).affine
+    affine = ants_to_nibabel_affine(label_image) # to_nibabel(label_image).affine
 
     if verbose:
         print("path length begin ... volUnit = " + str( volUnit ) )
@@ -7480,7 +7720,8 @@ def write_mm( output_prefix, mm, mm_norm=None, t1wide=None, separator='_', verbo
     if 'tractography' in mm:
         if mm['tractography'] is not None:
             ofn = output_prefix + separator + 'tractogram.trk'
-            save_tractogram( mm['tractography']['tractogram'], ofn )
+            if mm['tractography']['tractogram'] is not None:
+                save_tractogram( mm['tractography']['tractogram'], ofn )
     cnxderk = None
     if 'tractography_connectivity' in mm:
         if mm['tractography_connectivity'] is not None:
@@ -10666,94 +10907,104 @@ def calculate_loop_scores_full(flattened_series, n_neighbors=20, verbose=True ):
     return m.local_outlier_probabilities[:]
 
 
-def calculate_loop_scores(flattened_series, n_neighbors=20, 
-                                           n_features_sample=10000, seed=42, verbose=True):
+def calculate_loop_scores(
+    flattened_series,
+    n_neighbors=20,
+    n_features_sample=0.02,
+    n_feature_repeats=5,
+    seed=42,
+    use_approx_knn=True,
+    verbose=True,
+):
     """
-    Approximate LoOP scores using a random subset of features to reduce memory usage.
+    Memory-efficient and robust LoOP score estimation with optional approximate KNN
+    and averaging over multiple random feature subsets.
 
     Parameters:
-        flattened_series (np.ndarray): 2D array of shape (n_samples, n_features)
-        n_neighbors (int): Number of neighbors for LOF/LoOP computation
-        n_features_sample (int): Number of features to sample for approximation
-        seed (int): Random seed for reproducible feature sampling
-        verbose (bool): If True, print detailed progress and dimensions
+        flattened_series (np.ndarray): 2D array (n_samples x n_features)
+        n_neighbors (int): Number of neighbors for LoOP
+        n_features_sample (int or float): Number or fraction of features to sample
+        n_feature_repeats (int): How many independent feature subsets to sample and average over
+        seed (int): Random seed
+        use_approx_knn (bool): Whether to use fast approximate KNN (via pynndescent)
+        verbose (bool): Verbose output
 
     Returns:
-        np.ndarray: 1D array of local outlier probabilities (length n_samples)
+        np.ndarray: Averaged local outlier probabilities (length n_samples)
     """
     import numpy as np
     from sklearn.preprocessing import StandardScaler
-    from sklearn.neighbors import NearestNeighbors
     from PyNomaly import loop
 
-    # -------------------------------
-    # Step 1: Input stats and cleanup
-    # -------------------------------
+    # Optional approximate nearest neighbors
+    try:
+        from pynndescent import NNDescent
+        has_nn_descent = True
+    except ImportError:
+        has_nn_descent = False
+
+    rng = np.random.default_rng(seed)
     X = np.nan_to_num(flattened_series, nan=0).astype(np.float32)
     n_samples, n_features = X.shape
 
-    if verbose:
-        print("\n[LoOP Approximation - Verbose Mode]")
-        print(f"- Original input shape: {X.shape} (samples x features)")
-        print(f"- Requested sampled features: {n_features_sample}")
-    
-    if n_features_sample > n_features:
-        n_features_sample = n_features
-        if verbose:
-            print(f"- Requested n_features_sample exceeds available features. Using all {n_features} features.")
+    # Handle feature sampling
+    if isinstance(n_features_sample, float):
+        if 0 < n_features_sample <= 1.0:
+            n_features_sample = max(1, int(n_features_sample * n_features))
+        else:
+            raise ValueError("If float, n_features_sample must be in (0, 1].")
 
-    # -------------------------------
-    # Step 2: Feature sampling
-    # -------------------------------
-    rng = np.random.default_rng(seed)
-    sampled_indices = rng.choice(n_features, n_features_sample, replace=False)
-    X_sampled = X[:, sampled_indices]
+    n_features_sample = min(n_features, n_features_sample)
 
-    if verbose:
-        print(f"- Sampled feature shape: {X_sampled.shape} (samples x sampled_features)")
-        print(f"- Random seed for reproducibility: {seed}")
-
-    # -------------------------------
-    # Step 3: Standardization
-    # -------------------------------
-    scaler = StandardScaler(copy=False)
-    X_sampled = scaler.fit_transform(X_sampled)
-    X_sampled = np.nan_to_num(X_sampled, nan=0)
-
-    # -------------------------------
-    # Step 4: KNN setup for LoOP
-    # -------------------------------
     if n_neighbors >= n_samples:
         n_neighbors = max(1, n_samples // 2)
-        if verbose:
-            print(f"- Adjusted n_neighbors to {n_neighbors} (was too large for available samples).")
 
     if verbose:
-        print(f"- Performing KNN using Minkowski distance (default p=2, Euclidean)")
-        print(f"- Each point will use its {n_neighbors} nearest neighbors for local density estimation")
+        print(f"[LoOP] Input shape: {X.shape}")
+        print(f"[LoOP] Sampling {n_features_sample} features per repeat, {n_feature_repeats} repeats")
+        print(f"[LoOP] Using {n_neighbors} neighbors")
 
-    neigh = NearestNeighbors(n_neighbors=n_neighbors)
-    neigh.fit(X_sampled)
-    dists, indices = neigh.kneighbors(X_sampled, return_distance=True)
+    loop_scores = []
 
-    # -------------------------------
-    # Step 5: LoOP probability calculation
-    # -------------------------------
-    if verbose:
-        print(f"- Distance matrix shape: {dists.shape} (samples x n_neighbors)")
-        print(f"- Neighbor index matrix shape: {indices.shape}")
-        print("- Estimating Local Outlier Probabilities (LoOP)...")
+    for rep in range(n_feature_repeats):
+        feature_idx = rng.choice(n_features, n_features_sample, replace=False)
+        X_sub = X[:, feature_idx]
 
-    model = loop.LocalOutlierProbability(
-        distance_matrix=dists,
-        neighbor_matrix=indices,
-        n_neighbors=n_neighbors
-    ).fit()
+        scaler = StandardScaler(copy=False)
+        X_sub = scaler.fit_transform(X_sub)
+        X_sub = np.nan_to_num(X_sub, nan=0)
+
+        # Approximate or exact KNN
+        if use_approx_knn and has_nn_descent and n_samples > 1000:
+            if verbose:
+                print(f"  [Rep {rep+1}] Using NNDescent (approximate KNN)")
+            ann = NNDescent(X_sub, n_neighbors=n_neighbors, random_state=seed + rep)
+            indices, dists = ann.neighbor_graph
+        else:
+            from sklearn.neighbors import NearestNeighbors
+            if verbose:
+                print(f"  [Rep {rep+1}] Using NearestNeighbors (exact KNN)")
+            nn = NearestNeighbors(n_neighbors=n_neighbors)
+            nn.fit(X_sub)
+            dists, indices = nn.kneighbors(X_sub)
+
+        # LoOP score for this repeat
+        model = loop.LocalOutlierProbability(
+            distance_matrix=dists,
+            neighbor_matrix=indices,
+            n_neighbors=n_neighbors
+        ).fit()
+        loop_scores.append(model.local_outlier_probabilities[:])
+
+    # Average over repeats
+    loop_scores = np.stack(loop_scores)
+    loop_scores_mean = loop_scores.mean(axis=0)
 
     if verbose:
-        print("- LoOP scoring complete.\n")
+        print(f"[LoOP] Averaged over {n_feature_repeats} feature subsets. Final shape: {loop_scores_mean.shape}")
+
+    return loop_scores_mean
 
-    return model.local_outlier_probabilities[:]
 
 
 def score_fmri_censoring(cbfts, csf_seg, gm_seg, wm_seg ):
@@ -10823,7 +11074,7 @@ def score_fmri_censoring(cbfts, csf_seg, gm_seg, wm_seg ):
     cbfts_recon_ants = ants.copy_image_info(cbfts, cbfts_recon_ants)
     return cbfts_recon_ants, indx
 
-def loop_timeseries_censoring(x, threshold=0.5, mask=None, n_features_sample=10000, verbose=True):
+def loop_timeseries_censoring(x, threshold=0.5, mask=None, n_features_sample=0.02, seed=42, verbose=True):
     """
     Censor high leverage volumes from a time series using Local Outlier Probabilities (LoOP).
 
@@ -10831,7 +11082,8 @@ def loop_timeseries_censoring(x, threshold=0.5, mask=None, n_features_sample=100
     x (ANTsImage): A 4D time series image.
     threshold (float): Threshold for determining high leverage volumes based on LoOP scores.
     mask (antsImage): restricts to a ROI
-    n_features_sample (int): feature sample size default 5000
+    n_features_sample (int/float): feature sample size default 0.01; if less than one then this is interpreted as a percentage of the total features otherwise it sets the number of features to be used
+    seed (int): random seed
     verbose (bool)
 
     Returns:
@@ -10847,7 +11099,7 @@ def loop_timeseries_censoring(x, threshold=0.5, mask=None, n_features_sample=100
         flattened_series = ants.timeseries_to_matrix( x, mask )
     if verbose:
         print("loop_timeseries_censoring: flattened")
-    loop_scores = calculate_loop_scores(flattened_series, n_features_sample=n_features_sample, verbose=verbose )
+    loop_scores = calculate_loop_scores(flattened_series, n_features_sample=n_features_sample, seed=seed, verbose=verbose )
     high_leverage_volumes = np.where(loop_scores > threshold)[0]
     if verbose:
         print("loop_timeseries_censoring: High Leverage Volumes:", high_leverage_volumes)

{antspymm-1.4.9.dist-info → antspymm-1.5.1.dist-info}/METADATA

@@ -1,13 +1,13 @@
 Metadata-Version: 2.4
 Name: antspymm
-Version: 1.4.9
+Version: 1.5.1
 Summary: multi-channel/time-series medical image processing with antspyx
 Author-email: "Avants, Gosselin, Tustison, Reardon" <stnava@gmail.com>
 License: Apache-2.0
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
 Classifier: Operating System :: OS Independent
-Requires-Python: >=3.10
+Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: h5py>=2.10.0

antspymm-1.5.1.dist-info/RECORD

@@ -0,0 +1,7 @@
+antspymm/__init__.py,sha256=DnkidUfEu3Dl0tuWNTA-9VOUkBtH_cROKiPGNNXNagU,4637
+antspymm/mm.py,sha256=oPHhV70IhFXCKI26rP5HgKpkb2OjqCWkqoy4cSxJXqA,526866
+antspymm-1.5.1.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+antspymm-1.5.1.dist-info/METADATA,sha256=_I4UmZGWLM6KkmTJc21wKW1DrjT2TY723C1jr7LA3Fw,25939
+antspymm-1.5.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+antspymm-1.5.1.dist-info/top_level.txt,sha256=iyD1sRhCKzfwKRJLq5ZUeV9xsv1cGQl8Ejp6QwXM1Zg,9
+antspymm-1.5.1.dist-info/RECORD,,

antspymm-1.4.9.dist-info/RECORD

@@ -1,7 +0,0 @@
-antspymm/__init__.py,sha256=ZdNJyHwS6rzq59v0OK3tE3qSTD0za2iULzSLGkM_0uc,4527
-antspymm/mm.py,sha256=tJXaT-81XEjNjCOhmGKCjSRB7HEM2z_mlAWxKwJlc3M,517529
-antspymm-1.4.9.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-antspymm-1.4.9.dist-info/METADATA,sha256=6uEIRuATG8mqBBCQxdXHyd15xDeVBcyFOH3T-OnFYHw,25940
-antspymm-1.4.9.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-antspymm-1.4.9.dist-info/top_level.txt,sha256=iyD1sRhCKzfwKRJLq5ZUeV9xsv1cGQl8Ejp6QwXM1Zg,9
-antspymm-1.4.9.dist-info/RECORD,,