nettracer3d 0.2.6__py3-none-any.whl → 0.2.8__py3-none-any.whl

nettracer3d/morphology.py

@@ -5,6 +5,7 @@ from scipy.ndimage import zoom
 import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor, as_completed
 import tifffile
+from functools import partial
 import pandas as pd
 
 def get_reslice_indices(args):
@@ -70,7 +71,7 @@ def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z, cor
     
     # Create a boolean mask where elements with the specified label are True
     label_array = label_array == label
-    dil_array = nettracer.dilate_3D(label_array, dilate_xy, dilate_xy, dilate_z) #Dilate the label to see where the dilated label overlaps
+    dil_array = nettracer.dilate_3D_recursive(label_array, dilate_xy, dilate_xy, dilate_z) #Dilate the label to see where the dilated label overlaps
 
     if cores == 0: #For getting the volume of objects. Cores presumes you want the 'core' included in the interaction.
         edge_array = edge_array * dil_array  # Filter the edges by the label in question
@@ -189,25 +190,166 @@ def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, core
 
         return edge_quants
 
-def calculate_voxel_volumes(array, xy_scale = 1, z_scale = 1):
+
+def calculate_voxel_volumes(array, xy_scale=1, z_scale=1):
     """
-    Calculate voxel volumes for each uniquely labelled object in a 3D numpy array.
+    Calculate voxel volumes for each uniquely labelled object in a 3D numpy array
+    using parallel processing.
     
     Args:
         array: 3D numpy array where different objects are marked with different integer labels
+        xy_scale: Scale factor for x and y dimensions
+        z_scale: Scale factor for z dimension
         
     Returns:
         Dictionary mapping object labels to their voxel volumes
     """
+
+    def process_volume_chunk(chunk_data, labels, xy_scale, z_scale):
+        """
+        Calculate volumes for a chunk of the array.
+        
+        Args:
+            chunk_data: 3D numpy array chunk
+            labels: Array of unique labels to process
+            xy_scale: Scale factor for x and y dimensions
+            z_scale: Scale factor for z dimension
+            
+        Returns:
+            Dictionary of label: volume pairs for this chunk
+        """
+        chunk_volumes = {}
+        for label in labels:
+            volume = np.count_nonzero(chunk_data == label) * (xy_scale**2) * z_scale
+            if volume > 0:  # Only include if object exists in this chunk
+                chunk_volumes[label] = volume
+        return chunk_volumes
+
     # Get unique labels (excluding 0 which typically represents background)
     labels = np.unique(array)
     if len(labels) == 2:
         array, _ = nettracer.label_objects(array)
         labels = np.unique(array)
-
     labels = labels[labels != 0]  # Remove background label if present
     
-    # Create dictionary of label: volume pairs
-    volumes = {label: (np.count_nonzero(array == label) * (xy_scale**2) * z_scale) for label in labels}
+    if len(labels) == 0:
+        return {}
+        
+    # Get number of CPU cores
+    num_cores = mp.cpu_count()
+    
+    # Calculate chunk size along y-axis
+    chunk_size = array.shape[1] // num_cores
+    if chunk_size < 1:
+        chunk_size = 1
+    
+    # Create chunks along y-axis
+    chunks = []
+    for i in range(0, array.shape[1], chunk_size):
+        end = min(i + chunk_size, array.shape[1])
+        chunks.append(array[:, i:end, :])
+    
+    # Process chunks in parallel
+    process_func = partial(process_volume_chunk, 
+                         labels=labels, 
+                         xy_scale=xy_scale, 
+                         z_scale=z_scale)
+    
+    volumes = {}
+    with ThreadPoolExecutor(max_workers=num_cores) as executor:
+        chunk_results = list(executor.map(process_func, chunks))
+        
+        # Combine results from all chunks
+        for chunk_volumes in chunk_results:
+            for label, volume in chunk_volumes.items():
+                if label in volumes:
+                    volumes[label] += volume
+                else:
+                    volumes[label] = volume
+    
+    return volumes
+
+
+def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, search, xy_scale, z_scale, root):
+
+    if 0 in targets:
+        targets.remove(0)
+    targets = np.isin(nodes, targets)
+    targets = nettracer.binarize(targets)
+    
+    dilate_xy, dilate_z = nettracer.dilation_length_to_pixels(xy_scale, z_scale, search, search)
+    
+    dilated = nettracer.dilate_3D_recursive(targets, dilate_xy, dilate_xy, dilate_z)
+    dilated = dilated - targets #technically we dont need the cores
+    search_vol = np.count_nonzero(dilated) * xy_scale * xy_scale * z_scale #need this for density
+    targets = dilated != 0
+    del dilated
+
+    
+    targets = targets * nodes
+    
+    unique, counts = np.unique(targets, return_counts=True)
+    count_dict = dict(zip(unique, counts))
+    print(count_dict)
+    
+    del count_dict[0]
+    
+    unique, counts = np.unique(nodes, return_counts=True)
+    total_dict = dict(zip(unique, counts))
+    print(total_dict)
+
+    del total_dict[0]
+    
     
-    return volumes
+    for label in total_dict:
+        if label in id_dict:
+            if label in count_dict:
+                neighborhood_dict[id_dict[label]] += count_dict[label]
+            totals[id_dict[label]] += total_dict[label]
+
+
+    try:
+        del neighborhood_dict[root]  #no good way to get this
+        del totals[root] #no good way to get this
+    except:
+        pass
+    
+    volume = nodes.shape[0] * nodes.shape[1] * nodes.shape[2] * xy_scale * xy_scale * z_scale
+    densities = {}
+    for nodeid, amount in totals.items():
+        densities[nodeid] = (neighborhood_dict[nodeid]/search_vol)/(amount/volume)
+
+    return neighborhood_dict, totals, densities
+
+
+
+
+
+
+def get_search_space_dilate(target, centroids, id_dict, search, scaling = 1):
+
+    ymax = np.max(centroids[:, 0])
+    xmax = np.max(centroids[:, 1])
+
+
+    array = np.zeros((ymax + 1, xmax + 1))
+
+    for i, row in enumerate(centroids): 
+        if i + 1 in id_dict and target in id_dict[i+1]:
+            y = row[0]  # get y coordinate
+            x = row[1]  # get x coordinate
+            array[y, x] = 1  # set value at that coordinate
+
+
+    #array = downsample(array, 3)
+    array = dilate_2D(array, search, search)
+
+    search_space = np.count_nonzero(array) * scaling * scaling
+
+    tifffile.imwrite('search_regions.tif', array)
+
+    print(f"Search space is {search_space}")
+
+
+
+    return array