nettracer3d 1.2.4__py3-none-any.whl → 1.2.7__py3-none-any.whl

nettracer3d/network_analysis.py

@@ -601,42 +601,35 @@ def _find_centroids_old(nodes, node_list = None, down_factor = None):
 
 
 def _find_centroids(nodes, node_list=None, down_factor=None):
-    """Internal use version to get centroids without saving"""
-    
+    """Parallel version using sum accumulation instead of storing coordinates"""
     
-    def compute_indices_in_chunk(chunk, y_offset):
-        """
-        Alternative approach using np.where for even better performance on sparse arrays.
-        """
-        indices_dict_chunk = {}
+    def compute_sums_in_chunk(chunk, y_offset):
+        """Accumulate sums and counts - much less memory than storing coords"""
+        sums_dict = {}
+        counts_dict = {}
         
-        # Get all coordinates where chunk is non-zero
         z_coords, y_coords, x_coords = np.where(chunk != 0)
         
         if len(z_coords) == 0:
-            return indices_dict_chunk
+            return sums_dict, counts_dict
         
-        # Adjust Y coordinates
         y_coords_adjusted = y_coords + y_offset
-        
-        # Get labels at these coordinates
         labels = chunk[z_coords, y_coords, x_coords]
-        
-        # Group by unique labels
         unique_labels = np.unique(labels)
         
         for label in unique_labels:
-            if label == 0:  # Skip background
+            if label == 0:
                 continue
             mask = (labels == label)
-            # Stack coordinates into the expected format [z, y, x]
-            indices_dict_chunk[label] = np.column_stack((
-                z_coords[mask], 
-                y_coords_adjusted[mask], 
-                x_coords[mask]
-            ))
+            # Just store sums and counts - O(1) memory per label
+            sums_dict[label] = np.array([
+                z_coords[mask].sum(dtype=np.float64),
+                y_coords_adjusted[mask].sum(dtype=np.float64),
+                x_coords[mask].sum(dtype=np.float64)
+            ])
+            counts_dict[label] = mask.sum()
         
-        return indices_dict_chunk
+        return sums_dict, counts_dict
     
     def chunk_3d_array(array, num_chunks):
         """Split the 3D array into smaller chunks along the y-axis."""
@@ -644,49 +637,44 @@ def _find_centroids(nodes, node_list=None, down_factor=None):
         return y_slices
     
     # Handle input processing
-    if isinstance(nodes, str):  # Open into numpy array if filepath
+    if isinstance(nodes, str):
         nodes = tifffile.imread(nodes)
-        if len(np.unique(nodes)) == 2:  # Label if binary
+        if len(np.unique(nodes)) == 2:
             structure_3d = np.ones((3, 3, 3), dtype=int)
             nodes, num_nodes = ndimage.label(nodes)
     
     if down_factor is not None:
         nodes = downsample(nodes, down_factor)
-    else:
-        down_factor = 1
     
-    indices_dict = {}
+    sums_total = {}
+    counts_total = {}
     num_cpus = mp.cpu_count()
     
-    # Chunk the 3D array along the y-axis
     node_chunks = chunk_3d_array(nodes, num_cpus)
-    
-    # Calculate Y offset for each chunk
     chunk_sizes = [chunk.shape[1] for chunk in node_chunks]
     y_offsets = np.cumsum([0] + chunk_sizes[:-1])
     
-    # Parallel computation using the optimized single-pass approach
     with ThreadPoolExecutor(max_workers=num_cpus) as executor:
-        futures = {executor.submit(compute_indices_in_chunk, chunk, y_offset): chunk_id
-                  for chunk_id, (chunk, y_offset) in enumerate(zip(node_chunks, y_offsets))}
+        futures = [executor.submit(compute_sums_in_chunk, chunk, y_offset)
+                  for chunk, y_offset in zip(node_chunks, y_offsets)]
         
         for future in as_completed(futures):
-            indices_chunk = future.result()
-            # Merge indices for each label
-            for label, indices in indices_chunk.items():
-                if label in indices_dict:
-                    indices_dict[label] = np.vstack((indices_dict[label], indices))
+            sums_chunk, counts_chunk = future.result()
+            
+            # Merge is now just addition - O(1) instead of vstack
+            for label in sums_chunk:
+                if label in sums_total:
+                    sums_total[label] += sums_chunk[label]
+                    counts_total[label] += counts_chunk[label]
                 else:
-                    indices_dict[label] = indices
-    
-    # Compute centroids from collected indices
-    centroid_dict = {}
-    for label, indices in indices_dict.items():
-        centroid = np.round(np.mean(indices, axis=0)).astype(int)
-        centroid_dict[label] = centroid
-    
-    # Remove background label if it exists
-    centroid_dict.pop(0, None)
+                    sums_total[label] = sums_chunk[label]
+                    counts_total[label] = counts_chunk[label]
+    
+    # Compute centroids from accumulated sums
+    centroid_dict = {
+        label: np.round(sums_total[label] / counts_total[label]).astype(int)
+        for label in sums_total if label != 0
+    }
     
     return centroid_dict
 

nettracer3d/network_draw.py

@@ -264,20 +264,20 @@ def draw_network_from_centroids(nodes, network, centroids, twod_bool, directory
 
     if twod_bool:
         output_stack = output_stack[0,:,:] | output_stack[0,:,:]
-
-    if directory is None:
-        try:
-            tifffile.imwrite("drawn_network.tif", output_stack)
-        except Exception as e:
-            print("Could not save network lattice to active directory")
-            print("Network lattice saved as drawn_network.tif")
-
-    if directory is not None:
-        try:
-            tifffile.imwrite(f"{directory}/drawn_network.tif", output_stack)
-            print(f"Network lattice saved to {directory}/drawn_network.tif")
-        except Exception as e:
-            print(f"Could not save network lattice to {directory}")
+    
+    #if directory is None:
+     #   try:
+      #      tifffile.imwrite("drawn_network.tif", output_stack)
+       # except Exception as e:
+        #    print("Could not save network lattice to active directory")
+         #   print("Network lattice saved as drawn_network.tif")
+
+    #if directory is not None:
+     #   try:
+      #      tifffile.imwrite(f"{directory}/drawn_network.tif", output_stack)
+       #     print(f"Network lattice saved to {directory}/drawn_network.tif")
+        #except Exception as e:
+         #   print(f"Could not save network lattice to {directory}")
 
     return output_stack
 
@@ -340,6 +340,7 @@ def draw_network_from_centroids_GPU(nodes, network, centroids, twod_bool, direct
 
     output_stack = cp.asnumpy(output_stack)
 
+    """
     if directory is None:
         try:
             tifffile.imwrite("drawn_network.tif", output_stack)
@@ -353,7 +354,7 @@ def draw_network_from_centroids_GPU(nodes, network, centroids, twod_bool, direct
             print(f"Network lattice saved to {directory}/drawn_network.tif")
         except Exception as e:
             print(f"Could not save network lattice to {directory}")
-
+    """
 
 if __name__ == '__main__':
 

nettracer3d/node_draw.py

@@ -145,10 +145,10 @@ def draw_from_centroids(nodes, num_nodes, centroids, twod_bool, directory=None):
         draw_array = draw_array[0,:,:] | draw_array[1,:,:]
     
     filename = f'{directory}/labelled_node_indices.tif' if directory else 'labelled_node_indices.tif'
-    try:
-        tifffile.imwrite(filename, draw_array)
-    except Exception as e:
-        print(f"Could not save node indices to {filename}")
+    #try:
+     #   tifffile.imwrite(filename, draw_array)
+    #except Exception as e:
+     #   print(f"Could not save node indices to {filename}")
     
     return draw_array
 

nettracer3d/proximity.py

@@ -86,7 +86,7 @@ def _get_node_node_dict(label_array, label, dilate_xy, dilate_z, fastdil = False
 def process_label(args):
     """Modified to use pre-computed bounding boxes instead of argwhere"""
     nodes, label, dilate_xy, dilate_z, array_shape, bounding_boxes = args
-    print(f"Processing node {label}")
+    #print(f"Processing node {label}")
     
     # Get the pre-computed bounding box for this label
     slice_obj = bounding_boxes[int(label)-1]  # -1 because label numbers start at 1
@@ -213,83 +213,9 @@ def populate_array(centroids, clip=False, shape = None):
     else:
         return array
 
-def _process_chunk_centroids(args):
-    """Process a chunk of neighbor indices for centroids mode"""
-    chunk_data, idx_to_node, query_indices, tree, points, max_neighbors = args
-    output = []
-    
-    for i, neighbors in chunk_data:
-        query_idx = query_indices[i]
-        query_value = idx_to_node[query_idx]
-        query_point = points[query_idx]
-        
-        # Filter out self-reference
-        filtered_neighbors = [n for n in neighbors if n != query_idx]
-        
-        # If max_neighbors is specified and we have more neighbors than allowed
-        if max_neighbors is not None and len(filtered_neighbors) > max_neighbors:
-            # Use KDTree to get distances efficiently - query for more than we need
-            # to ensure we get the exact closest ones
-            k = min(len(filtered_neighbors), max_neighbors + 1)  # +1 in case query point is included
-            distances, indices = tree.query(query_point, k=k)
-            
-            # Filter out self and limit to max_neighbors
-            selected_neighbors = []
-            for dist, idx in zip(distances, indices):
-                if idx != query_idx and idx in filtered_neighbors:
-                    selected_neighbors.append(idx)
-                    if len(selected_neighbors) >= max_neighbors:
-                        break
-            
-            filtered_neighbors = selected_neighbors
-        
-        # Add all selected neighbors to output
-        for neighbor_idx in filtered_neighbors:
-            neighbor_value = idx_to_node[neighbor_idx]
-            output.append([query_value, neighbor_value, 0])
-    
-    return output
-
-def _process_chunk_array(args):
-    """Process a chunk of neighbor indices for array mode"""
-    chunk_data, array, point_tuples, query_indices, tree, points, max_neighbors = args
-    output = []
-    
-    for i, neighbors in chunk_data:
-        query_idx = query_indices[i]
-        query_value = array[point_tuples[query_idx]]
-        query_point = points[query_idx]
-        
-        # Filter out self-reference
-        filtered_neighbors = [n for n in neighbors if n != query_idx]
-        
-        # If max_neighbors is specified and we have more neighbors than allowed
-        if max_neighbors is not None and len(filtered_neighbors) > max_neighbors:
-            # Use KDTree to get distances efficiently - query for more than we need
-            # to ensure we get the exact closest ones
-            k = min(len(filtered_neighbors), max_neighbors + 1)  # +1 in case query point is included
-            distances, indices = tree.query(query_point, k=k)
-            
-            # Filter out self and limit to max_neighbors
-            selected_neighbors = []
-            for dist, idx in zip(distances, indices):
-                if idx != query_idx and idx in filtered_neighbors:
-                    selected_neighbors.append(idx)
-                    if len(selected_neighbors) >= max_neighbors:
-                        break
-            
-            filtered_neighbors = selected_neighbors
-        
-        # Add all selected neighbors to output
-        for neighbor_idx in filtered_neighbors:
-            neighbor_value = array[point_tuples[neighbor_idx]]
-            output.append([query_value, neighbor_value, 0])
-    
-    return output
-
-def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, n_jobs=None, chunk_size=None, max_neighbors=None):
+def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, max_neighbors=None):
     """
-    Find neighbors using KDTree with optional parallelization.
+    Find neighbors using KDTree.
     
     Parameters:
     -----------
@@ -301,10 +227,6 @@ def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, n_jo
         Array to search for nonzero points
     targets : list, optional
         Specific targets to query for neighbors
-    n_jobs : int, optional
-        Number of parallel jobs. If None, uses cpu_count(). Set to 1 to disable parallelization.
-    chunk_size : int, optional
-        Size of chunks for parallel processing. If None, auto-calculated based on data size.
     max_neighbors : int, optional
         Maximum number of nearest neighbors to return per query point within the radius.
         If None, returns all neighbors within radius (original behavior).
@@ -378,81 +300,45 @@ def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, n_jo
     
     print("Sorting Through Output...")
 
-    # Determine parallelization parameters
-    if n_jobs is None:
-        n_jobs = cpu_count()
-    
-    # Skip parallelization for small datasets or when n_jobs=1
-    if n_jobs == 1 or len(neighbor_indices) < 100:
-    #if True:
-        # Sequential processing (original logic with max_neighbors support)
-        output = []
-        for i, neighbors in enumerate(neighbor_indices):
-            query_idx = query_indices[i]
-            query_point = points[query_idx]
-            
-            # Filter out self-reference
-            filtered_neighbors = [n for n in neighbors if n != query_idx]
+    # Sequential processing
+    output = []
+    for i, neighbors in enumerate(neighbor_indices):
+        query_idx = query_indices[i]
+        query_point = points[query_idx]
+        
+        # Filter out self-reference
+        filtered_neighbors = [n for n in neighbors if n != query_idx]
+        
+        # If max_neighbors is specified and we have more neighbors than allowed
+        if max_neighbors is not None and len(filtered_neighbors) > max_neighbors:
+            # Use KDTree to get distances efficiently - query for more than we need
+            # to ensure we get the exact closest ones
+            k = min(len(filtered_neighbors), max_neighbors + 1)  # +1 in case query point is included
+            distances, indices = tree.query(query_point, k=k)
             
-            # If max_neighbors is specified and we have more neighbors than allowed
-            if max_neighbors is not None and len(filtered_neighbors) > max_neighbors:
-                # Use KDTree to get distances efficiently - query for more than we need
-                # to ensure we get the exact closest ones
-                k = min(len(filtered_neighbors), max_neighbors + 1)  # +1 in case query point is included
-                distances, indices = tree.query(query_point, k=k)
-                
-                # Filter out self and limit to max_neighbors
-                selected_neighbors = []
-                for dist, idx in zip(distances, indices):
-                    if idx != query_idx and idx in filtered_neighbors:
-                        selected_neighbors.append(idx)
-                        if len(selected_neighbors) >= max_neighbors:
-                            break
-                
-                filtered_neighbors = selected_neighbors
+            # Filter out self and limit to max_neighbors
+            selected_neighbors = []
+            for dist, idx in zip(distances, indices):
+                if idx != query_idx and idx in filtered_neighbors:
+                    selected_neighbors.append(idx)
+                    if len(selected_neighbors) >= max_neighbors:
+                        break
             
-            # Process the selected neighbors
-            if centroids:
-                query_value = idx_to_node[query_idx]
-                for neighbor_idx in filtered_neighbors:
-                    neighbor_value = idx_to_node[neighbor_idx]
-                    output.append([query_value, neighbor_value, 0])
-            else:
-                query_value = array[point_tuples[query_idx]]
-                for neighbor_idx in filtered_neighbors:
-                    neighbor_value = array[point_tuples[neighbor_idx]]
-                    output.append([query_value, neighbor_value, 0])
-        return output
-    
-    # Parallel processing
-    if chunk_size is None:
-        # Auto-calculate chunk size: aim for ~4x more chunks than processes
-        chunk_size = max(1, len(neighbor_indices) // (n_jobs * 4))
-    
-    # Create chunks of (index, neighbors) pairs
-    chunks = []
-    for i in range(0, len(neighbor_indices), chunk_size):
-        chunk = [(j, neighbor_indices[j]) for j in range(i, min(i + chunk_size, len(neighbor_indices)))]
-        chunks.append(chunk)
-    
-    # Process chunks in parallel
-    with Pool(processes=n_jobs) as pool:
+            filtered_neighbors = selected_neighbors
+        
+        # Process the selected neighbors
         if centroids:
-            # Prepare arguments for centroids mode
-            chunk_args = [(chunk, idx_to_node, query_indices, tree, points, max_neighbors) for chunk in chunks]
-            chunk_results = pool.map(_process_chunk_centroids, chunk_args)
+            query_value = idx_to_node[query_idx]
+            for neighbor_idx in filtered_neighbors:
+                neighbor_value = idx_to_node[neighbor_idx]
+                output.append([query_value, neighbor_value, 0])
         else:
-            # Prepare arguments for array mode
-            chunk_args = [(chunk, array, point_tuples, query_indices, tree, points, max_neighbors) for chunk in chunks]
-            chunk_results = pool.map(_process_chunk_array, chunk_args)
-    
-    # Flatten results
-    output = []
-    for chunk_result in chunk_results:
-        output.extend(chunk_result)
+            query_value = array[point_tuples[query_idx]]
+            for neighbor_idx in filtered_neighbors:
+                neighbor_value = array[point_tuples[neighbor_idx]]
+                output.append([query_value, neighbor_value, 0])
 
     print("Organizing Network...")
-
     
     return output
 

nettracer3d/simple_network.py

@@ -119,7 +119,7 @@ def geometric_positions(centroids, shape):
     return xy_pos, z_pos
 
 
-def show_simple_network(excel_file_path, geometric = False, geo_info = None, directory = None):
+def show_simple_network(excel_file_path, geometric = False, geo_info = None, directory = None, show_labels = True):
 
     if type(excel_file_path) == str:
         master_list = read_excel_to_lists(excel_file_path)
@@ -142,11 +142,11 @@ def show_simple_network(excel_file_path, geometric = False, geo_info = None, dir
 
         pos, z_pos  = geometric_positions(geo_info[0], geo_info[1])
         node_sizes_list = [z_pos[node] for node in G.nodes()]
-        nx.draw(G, pos, with_labels=True, font_color='black', font_weight='bold', node_size= node_sizes_list, alpha=0.8, font_size = 12)
+        nx.draw(G, pos, with_labels=show_labels, font_color='black', font_weight='bold', node_size= node_sizes_list, alpha=0.8, font_size = 12)
     else:
         # Visualize the graph with different edge colors for each community
         pos = nx.spring_layout(G, iterations = 15)
-        nx.draw(G, pos, with_labels=True, font_color='red', font_weight='bold', node_size=10)
+        nx.draw(G, pos, with_labels=show_labels, font_color='red', font_weight='bold', node_size=10)
 
     if directory is not None:
         plt.savefig(f'{directory}/network_plot.png')
@@ -154,7 +154,7 @@ def show_simple_network(excel_file_path, geometric = False, geo_info = None, dir
     plt.show()
 
 
-def show_identity_network(excel_file_path, node_identities, geometric=False, geo_info=None, directory=None):
+def show_identity_network(excel_file_path, node_identities, geometric=False, geo_info=None, directory=None, show_labels = True):
     if type(node_identities) == str:
         # Read the Excel file into a DataFrame
         df = pd.read_excel(node_identities)
@@ -220,9 +220,16 @@ def show_identity_network(excel_file_path, node_identities, geometric=False, geo
     color_map = dict(zip(unique_categories, colors))
 
     # Node size handling
-    node_dict = {node: 30 if identity_dict[node] == 'Edge' else 100 
-                 for node in G.nodes()}
-    
+    node_dict = {}
+    for node in G.nodes():
+        try:
+            if identity_dict[node] == 'Edge':
+                node_dict[node] = 30
+            else:
+                node_dict[node] = 100
+        except:
+            node_dict[node] = 100
+
     if geometric:
         # Handle geometric positioning
         for node in list(G.nodes()):
@@ -244,14 +251,26 @@ def show_identity_network(excel_file_path, node_identities, geometric=False, geo
     graph_ax = plt.gca()
     
     # Draw the network with enhanced font styling
-    node_colors = [color_map[identity_dict[node]] for node in G.nodes()]
-    nx.draw(G, pos, ax=graph_ax, with_labels=True, font_color='black', 
+    misc = False
+    node_colors = []
+    for node in G.nodes():
+        try:
+            node_colors.append(color_map[identity_dict[node]])
+        except:
+            misc = True
+            node_colors.append((1, 1, 1))
+
+    #node_colors = [color_map[identity_dict[node]] for node in G.nodes()]
+    nx.draw(G, pos, ax=graph_ax, with_labels=show_labels, font_color='black', 
             font_weight='bold', node_size=node_sizes_list, 
             node_color=node_colors, alpha=0.8, font_size=11, font_family='sans-serif')
 
     # Create custom legend with multiple columns if needed
     legend_handles = [Patch(color=color, label=category) 
                      for category, color in color_map.items()]
+
+    if misc:
+        legend_handles.append(Patch(color = (1, 1, 1,), label = 'Unassigned'))
     
     # Adjust number of columns based on number of categories
     if len(unique_categories) > 20: