nettracer3d 0.7.6__py3-none-any.whl → 0.7.8__py3-none-any.whl

nettracer3d/proximity.py

@@ -9,6 +9,7 @@ import multiprocessing as mp
 import pandas as pd
 import matplotlib.pyplot as plt
 from typing import Dict, Union, Tuple, List, Optional
+from collections import defaultdict
 
 
 # Related to morphological border searching:
@@ -142,15 +143,17 @@ def find_shared_value_pairs(input_dict):
 
 #Related to kdtree centroid searching:
 
-def populate_array(centroids):
+def populate_array(centroids, clip=False):
     """
     Create a 3D array from centroid coordinates.
     
     Args:
         centroids: Dictionary where keys are object IDs and values are [z,y,x] coordinates
+        clip: Boolean, if True, transpose all centroids so minimum values become 0
     
     Returns:
-        3D numpy array where values are object IDs at their centroid locations
+        If clip=False: 3D numpy array where values are object IDs at their centroid locations
+        If clip=True: Tuple of (3D numpy array, dictionary with clipped centroids)
     """
     # Input validation
     if not centroids:
@@ -163,21 +166,39 @@ def populate_array(centroids):
     min_coords = coords.min(axis=0)
     max_coords = coords.max(axis=0)
     
-    # Check for negative coordinates
-    if np.any(min_coords < 0):
+    # Check for negative coordinates only if not clipping
+    if not clip and np.any(min_coords < 0):
         raise ValueError("Negative coordinates found in centroids")
     
+    # Apply clipping if requested
+    clipped_centroids = {}
+    if clip:
+        # Transpose all coordinates so minimum becomes 0
+        coords = coords - min_coords
+        max_coords = max_coords - min_coords
+        min_coords = np.zeros_like(min_coords)
+        
+        # Create dictionary with clipped centroids
+        for i, obj_id in enumerate(centroids.keys()):
+            clipped_centroids[obj_id] = coords[i].tolist()
+    
     # Create array
     array = np.zeros((max_coords[0] + 1, 
                      max_coords[1] + 1, 
                      max_coords[2] + 1), dtype=int)
     
-    # Populate array with rounded coordinates
-    for obj_id, coord in centroids.items():
-        z, y, x = np.round([coord[0], coord[1], coord[2]]).astype(int)
+    # Populate array with (possibly clipped) rounded coordinates
+    for i, (obj_id, coord) in enumerate(centroids.items()):
+        if clip:
+            z, y, x = coords[i]  # Use pre-computed clipped coordinates
+        else:
+            z, y, x = np.round([coord[0], coord[1], coord[2]]).astype(int)
         array[z, y, x] = obj_id
         
-    return array
+    if clip:
+        return array, clipped_centroids
+    else:
+        return array
 
 def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None):
     # Get coordinates of nonzero points
@@ -646,4 +667,63 @@ def plot_ripley_functions(r_values, k_values, h_values, dimension=2, figsize=(12
     
     plt.tight_layout()
     plt.show()
-    #plt.clf()
+    #plt.clf()
+
+
+
+
+def partition_objects_into_cells(object_centroids, cell_size):
+    """
+    Partition objects into 3D grid cells based on their centroids.
+    
+    Args:
+        object_centroids (dict): Dictionary with object labels as keys and [z,y,x] coordinates as values
+        cell_size (tuple or int): Size of each cell. If int, creates cubic cells. If tuple, (z_size, y_size, x_size)
+    
+    Returns:
+        dict: Dictionary with cell numbers as keys and lists of object labels as values
+    """
+    
+    if not object_centroids:
+        return {}
+    
+    # Handle cell_size input
+    if isinstance(cell_size, (int, float)):
+        cell_size = (cell_size, cell_size, cell_size)
+    elif len(cell_size) == 1:
+        cell_size = (cell_size[0], cell_size[0], cell_size[0])
+    
+    # Extract centroids and find bounds
+    centroids = np.array(list(object_centroids.values()))
+    labels = list(object_centroids.keys())
+    
+    # Find the bounding box of all centroids
+    min_coords = np.min(centroids, axis=0)  # [min_z, min_y, min_x]
+    max_coords = np.max(centroids, axis=0)  # [max_z, max_y, max_x]
+    
+    # Calculate number of cells in each dimension
+    dimensions = max_coords - min_coords
+    num_cells = np.ceil(dimensions / np.array(cell_size)).astype(int)
+    
+    # Initialize result dictionary
+    cell_assignments = defaultdict(list)
+    
+    # Assign each object to a cell
+    for i, (label, centroid) in enumerate(object_centroids.items()):
+        # Calculate which cell this centroid belongs to
+        relative_pos = np.array(centroid) - min_coords
+        cell_indices = np.floor(relative_pos / np.array(cell_size)).astype(int)
+        
+        # Ensure indices don't exceed bounds (handles edge cases)
+        cell_indices = np.minimum(cell_indices, num_cells - 1)
+        cell_indices = np.maximum(cell_indices, 0)
+        
+        # Convert 3D cell indices to a single cell number
+        cell_number = (cell_indices[0] * num_cells[1] * num_cells[2] + 
+                      cell_indices[1] * num_cells[2] + 
+                      cell_indices[2])
+        
+        cell_assignments[int(cell_number)].append(int(label))
+    
+    # Convert defaultdict to regular dict and sort keys
+    return dict(sorted(cell_assignments.items()))

nettracer3d/smart_dilate.py

@@ -108,6 +108,8 @@ def dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z):
 
     num_cores = mp.cpu_count()
 
+
+
     with ThreadPoolExecutor(max_workers=num_cores) as executor:
         futures = {executor.submit(process_slice, z): z for z in range(tiff_array.shape[0])}
 
@@ -246,14 +248,14 @@ def invert_array(array):
     return np.logical_not(array).astype(np.uint8)
 
 def process_chunk(start_idx, end_idx, nodes, ring_mask, nearest_label_indices):
-    nodes_chunk = nodes[start_idx:end_idx]
-    ring_mask_chunk = ring_mask[start_idx:end_idx]
+    nodes_chunk = nodes[:, start_idx:end_idx, :]
+    ring_mask_chunk = ring_mask[:, start_idx:end_idx, :]
     dilated_nodes_with_labels_chunk = np.copy(nodes_chunk)
     ring_indices = np.argwhere(ring_mask_chunk)
 
     for index in ring_indices:
         z, y, x = index
-        nearest_z, nearest_y, nearest_x = nearest_label_indices[:, z + start_idx, y, x]
+        nearest_z, nearest_y, nearest_x = nearest_label_indices[:, z, y + start_idx, x]
         try: #There was an index error here once on the highest val of the second axis. I could not understand why because it usually doesnt hence the try block.
             dilated_nodes_with_labels_chunk[z, y, x] = nodes[nearest_z, nearest_y, nearest_x]
         except:
@@ -332,10 +334,10 @@ def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_
 
     # Step 5: Process in parallel chunks using ThreadPoolExecutor
     num_cores = mp.cpu_count()  # Use all available CPU cores
-    chunk_size = nodes.shape[0] // num_cores  # Divide the array into chunks along the z-axis
+    chunk_size = nodes.shape[1] // num_cores  # Divide the array into chunks along the y-axis
 
     with ThreadPoolExecutor(max_workers=num_cores) as executor:
-        args_list = [(i * chunk_size, (i + 1) * chunk_size if i != num_cores - 1 else nodes.shape[0], nodes, ring_mask, nearest_label_indices) for i in range(num_cores)]
+        args_list = [(i * chunk_size, (i + 1) * chunk_size if i != num_cores - 1 else nodes.shape[1], nodes, ring_mask, nearest_label_indices) for i in range(num_cores)]
         results = list(executor.map(lambda args: process_chunk(*args), args_list))
 
     del ring_mask
@@ -343,7 +345,7 @@ def smart_dilate(nodes, dilate_xy, dilate_z, directory = None, GPU = True, fast_
     del nearest_label_indices
 
     # Combine results from chunks
-    dilated_nodes_with_labels = np.concatenate(results, axis=0)
+    dilated_nodes_with_labels = np.concatenate(results, axis=1)
 
 
     if (dilated_nodes_with_labels.shape[1] < original_shape[1]) and fast_dil: #If downsample was used, upsample output
@@ -368,7 +370,7 @@ def round_to_odd(number):
             rounded -= 1
     return rounded
 
-def smart_label(binary_array, label_array, directory = None, GPU = True, predownsample = None):
+def smart_label(binary_array, label_array, directory = None, GPU = True, predownsample = None, remove_template = False):
 
     original_shape = binary_array.shape
 
@@ -419,12 +421,11 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
                         break
                     except cp.cuda.memory.OutOfMemoryError:
                         down_factor += 1
-                binary_mask = binary_array #Need this for later to stamp out the correct output
                 binary_core = binarize(small_array)
                 label_array = small_array
-                binary_array = nettracer.downsample(binary_array, downsample_needed)
-                binary_array = nettracer.dilate_3D_old(binary_array)
-                ring_mask = binary_array & invert_array(binary_core)
+                binary_small = nettracer.downsample(binary_array, downsample_needed)
+                binary_small = nettracer.dilate_3D_old(binary_small)
+                ring_mask = binary_small & invert_array(binary_core)
 
         else:
             goto_except = 1/0
@@ -440,18 +441,21 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
 
     # Step 5: Process in parallel chunks using ThreadPoolExecutor
     num_cores = mp.cpu_count()  # Use all available CPU cores
-    chunk_size = label_array.shape[0] // num_cores  # Divide the array into chunks along the z-axis
+    chunk_size = label_array.shape[1] // num_cores  # Divide the array into chunks along the z-axis
+
 
     with ThreadPoolExecutor(max_workers=num_cores) as executor:
-        args_list = [(i * chunk_size, (i + 1) * chunk_size if i != num_cores - 1 else label_array.shape[0], label_array, ring_mask, nearest_label_indices) for i in range(num_cores)]
+        args_list = [(i * chunk_size, (i + 1) * chunk_size if i != num_cores - 1 else label_array.shape[1], label_array, ring_mask, nearest_label_indices) for i in range(num_cores)]
         results = list(executor.map(lambda args: process_chunk(*args), args_list))
 
     # Combine results from chunks
-    dilated_nodes_with_labels = np.concatenate(results, axis=0)
+    dilated_nodes_with_labels = np.concatenate(results, axis=1)
 
     if label_array.shape[1] < original_shape[1]: #If downsample was used, upsample output
         dilated_nodes_with_labels = nettracer.upsample_with_padding(dilated_nodes_with_labels, downsample_needed, original_shape)
-        dilated_nodes_with_labels = dilated_nodes_with_labels * binary_mask
+        dilated_nodes_with_labels = dilated_nodes_with_labels * binary_array
+    elif remove_template:
+        dilated_nodes_with_labels = dilated_nodes_with_labels * binary_array
 
     if string_bool:
         if directory is not None:
@@ -465,6 +469,7 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
             except Exception as e:
                 print(f"Could not save search region file to active directory")
 
+
     return dilated_nodes_with_labels
 
 def compute_distance_transform_GPU(nodes, return_dists = False, sampling = [1, 1, 1]):

{nettracer3d-0.7.6.dist-info → nettracer3d-0.7.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.7.6
+Version: 0.7.8
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
@@ -28,6 +28,7 @@ Requires-Dist: PyQt6
 Requires-Dist: scikit-learn
 Requires-Dist: nibabel
 Requires-Dist: setuptools
+Requires-Dist: umap-learn
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
 Provides-Extra: cuda12
@@ -72,6 +73,14 @@ NetTracer3D is free to use/fork for academic/nonprofit use so long as citation i
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.7.6 Updates -- 
+-- Version 0.7.8 (and 0.7.7) Updates -- 
 
 	* Bug Fixes
+	* Added the excel helper loader for better automated loading from QuPath exports specifically
+	* Added the ability to cluster communities into broader neighborhoods (with KMeans) based on their compositions.
+	* Added heatmap and UMAP graph displays based on community compositions.
+	* Added the ability to show heatmaps of nodes based on their density within their communities
+	* Added the ability to cluster nodes into communities based on spatial grouping in arbitrarily-sized cells (rather than just using the network)
+	* Added function to crop the current image
+	* More options under 'Modify Network'
+	* 'Show 3D' method now can render a bounding box.

nettracer3d-0.7.8.dist-info/RECORD

@@ -0,0 +1,23 @@
+nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nettracer3d/community_extractor.py,sha256=BrONCLRLYUdMfLe_018AQi0k0J7xwVahc_lmsOO5Pwo,23086
+nettracer3d/excelotron.py,sha256=lS5vnpoOGZWp7fdqVpTPqeC-mUKrfwDrWHfx4PQ7Uzg,71384
+nettracer3d/modularity.py,sha256=O9OeKbjD3v6gSFz9K2GzP6LsxlpQaPfeJbM1pyIEigw,21788
+nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
+nettracer3d/neighborhoods.py,sha256=kkKR8m6Gjw34cDd_mytAIwLxqvuNBtQb2hU4JuBY9pI,12301
+nettracer3d/nettracer.py,sha256=M1KFIPg7WCzm8BXQOreuEVhgjg0PpLKRg4Y88DyVuK8,225843
+nettracer3d/nettracer_gui.py,sha256=WTcN-tOk4vzDLhnVN4un5PEkC90GDp3sxZZhgLifMOM,468787
+nettracer3d/network_analysis.py,sha256=h-5yzUWdE0hcWYy8wcBA5LV1bRhdqiMnKbQLrRzb1Sw,41443
+nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
+nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
+nettracer3d/proximity.py,sha256=5n8qxqxmmMtq5bqVpSkqw3EefuZIyGdLybVs18D3ZNg,27996
+nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
+nettracer3d/segmenter.py,sha256=BD9vxnblDKXfmR8hLP_iVqqfVngH6opz4Q7V6sxc2KM,60062
+nettracer3d/segmenter_GPU.py,sha256=Fqr0Za6X2ss4rfaziqOhvhBfbGDPHkHw6fVxs39lZaU,53862
+nettracer3d/simple_network.py,sha256=Ft_81VhVQ3rqoXvuYnsckXuxCcQSJfakhOfkFaclxZY,9340
+nettracer3d/smart_dilate.py,sha256=DOEOQq9ig6-AO4MpqAG0CqrGDFqw5_UBeqfSedqHk28,25933
+nettracer3d-0.7.8.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.7.8.dist-info/METADATA,sha256=GFylr691RVFXgRMrrEhOEW6ySL5vUW-8-bK8qQ4hr9A,4797
+nettracer3d-0.7.8.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-0.7.8.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.7.8.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.7.8.dist-info/RECORD,,

{nettracer3d-0.7.6.dist-info → nettracer3d-0.7.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

nettracer3d-0.7.6.dist-info/RECORD

@@ -1,21 +0,0 @@
-nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-nettracer3d/community_extractor.py,sha256=vzckLJfubplcQUAIr4UNgezxUJIdeFmH6CTWk8jYjOw,23739
-nettracer3d/modularity.py,sha256=1Qg8Vc7Cl8nkkJxz_Z8tNR8hK1b-ZrFrMVUl4SKGLY8,21825
-nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
-nettracer3d/nettracer.py,sha256=2xAImidzKkYEA_5Ja18v9vMUYgFUEwJB8v8-QCKfi8A,213593
-nettracer3d/nettracer_gui.py,sha256=7L0xeR4aENPppT9YQcc7U8EPYUQMq3pfREP_iWEzawk,436234
-nettracer3d/network_analysis.py,sha256=h-5yzUWdE0hcWYy8wcBA5LV1bRhdqiMnKbQLrRzb1Sw,41443
-nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
-nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
-nettracer3d/proximity.py,sha256=nlVBXzJ6r84TlP8UaLcdamWifYn-jfVIF0uB-56k_Js,24752
-nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
-nettracer3d/segmenter.py,sha256=BD9vxnblDKXfmR8hLP_iVqqfVngH6opz4Q7V6sxc2KM,60062
-nettracer3d/segmenter_GPU.py,sha256=Fqr0Za6X2ss4rfaziqOhvhBfbGDPHkHw6fVxs39lZaU,53862
-nettracer3d/simple_network.py,sha256=Ft_81VhVQ3rqoXvuYnsckXuxCcQSJfakhOfkFaclxZY,9340
-nettracer3d/smart_dilate.py,sha256=69z9Bn8xtA7rkhcVpqd1PxRSxxRFnIQse9lc2-LU4TU,25879
-nettracer3d-0.7.6.dist-info/licenses/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.7.6.dist-info/METADATA,sha256=YO0kmThsnywdo9NJhnGxQFvmAkUdhMlEKHS-gFgCRvY,4093
-nettracer3d-0.7.6.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-nettracer3d-0.7.6.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.7.6.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.7.6.dist-info/RECORD,,