antspymm 1.4.8__py3-none-any.whl → 1.5.0__py3-none-any.whl

antspymm/__init__.py

@@ -5,6 +5,7 @@ except:
     pass
 
 from .mm import get_data
+from .mm import ants_to_nibabel_affine
 from .mm import get_dti
 from .mm import triangular_to_tensor
 from .mm import dti_numpy_to_image

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")
@@ -3642,7 +3675,7 @@ def dipy_dti_recon(
         return tenfit, FA, MD1, RGB
 
     bvecs = repair_bvecs( bvecs )
-    gtab = gradient_table(bvals, bvecs, atol=2.0 )
+    gtab = gradient_table(bvals, bvecs=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 )
@@ -4204,16 +4237,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 +4255,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 +4314,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 +4416,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 +4460,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 +4496,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 +4556,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 +4648,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 +4738,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 +7510,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 +10697,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 +10864,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 +10872,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 +10889,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.8.dist-info → antspymm-1.5.0.dist-info}/METADATA

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

antspymm-1.5.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+antspymm/__init__.py,sha256=3t4jqSbQVRfecm1ekc02ytWlZ3yAGcPyB_kzQAcg4Bc,4566
+antspymm/mm.py,sha256=UdmKcS4wYazBdC8DUchdnzXZzM4tetFx3RfDS9zH4ys,519104
+antspymm-1.5.0.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+antspymm-1.5.0.dist-info/METADATA,sha256=fXgNR7g8l0I1AFjAPIZwTRpN_RBrW5FiaBtdjg5z0Mc,25939
+antspymm-1.5.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+antspymm-1.5.0.dist-info/top_level.txt,sha256=iyD1sRhCKzfwKRJLq5ZUeV9xsv1cGQl8Ejp6QwXM1Zg,9
+antspymm-1.5.0.dist-info/RECORD,,

antspymm-1.4.8.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.8.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-antspymm-1.4.8.dist-info/METADATA,sha256=ETYrQeMwhaF6LkNzhXZrN2htysVl3rvUmUX2yJymHsw,25781
-antspymm-1.4.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-antspymm-1.4.8.dist-info/top_level.txt,sha256=iyD1sRhCKzfwKRJLq5ZUeV9xsv1cGQl8Ejp6QwXM1Zg,9
-antspymm-1.4.8.dist-info/RECORD,,