nettracer3d 0.9.4__py3-none-any.whl → 0.9.5__py3-none-any.whl

nettracer3d/community_extractor.py

@@ -549,54 +549,117 @@ def convert_node_colors_to_names(node_to_color: Dict[int, Tuple[int, int, int]],
         
         num_entries = len(node_to_color)
         
-        # Calculate dynamic spacing based on number of entries
-        entry_height = 0.8
-        total_height = num_entries * entry_height + 1.5  # Extra space for title and margins
+        # Calculate text widths to determine optimal figure size
+        sorted_nodes = sorted(node_to_color.keys())
+        
+        # Create a temporary figure to measure text widths
+        temp_fig, temp_ax = plt.subplots(figsize=(1, 1))
+        
+        max_node_width = 0
+        max_color_width = 0
+        
+        for node in sorted_nodes:
+            color_name = node_to_names[node]
+            
+            # Measure node ID text width
+            node_text = temp_ax.text(0, 0, str(node), fontsize=12, fontweight='bold')
+            node_bbox = node_text.get_window_extent(renderer=temp_fig.canvas.get_renderer())
+            node_width = node_bbox.width
+            max_node_width = max(max_node_width, node_width)
+            
+            # Measure color name text width
+            color_text = temp_ax.text(0, 0, color_name.replace('_', ' ').title(), fontsize=11)
+            color_bbox = color_text.get_window_extent(renderer=temp_fig.canvas.get_renderer())
+            color_width = color_bbox.width
+            max_color_width = max(max_color_width, color_width)
+        
+        plt.close(temp_fig)
+        
+        # Convert pixel widths to figure units (approximate conversion)
+        # This is a rough conversion - matplotlib uses 72 DPI by default
+        dpi = 72
+        max_node_width_fig = max_node_width / dpi
+        max_color_width_fig = max_color_width / dpi
+        
+        # Calculate optimal figure dimensions
+        entry_height = 0.6  # Reduced for tighter spacing
+        margin = 0.3
+        swatch_width = 0.8
+        spacing = 0.2
+        
+        # Calculate total width needed
+        total_width = (margin + max_node_width_fig + spacing + 
+                       swatch_width + spacing + max_color_width_fig + margin)
         
-        # Create figure and axis with proper scaling
-        fig, ax = plt.subplots(figsize=figsize)
-        ax.set_xlim(0, 10)
+        # Ensure minimum width for readability
+        total_width = max(total_width, 4.0)
+        
+        # Calculate total height
+        title_height = 0.8
+        total_height = num_entries * entry_height + title_height + 2 * margin
+        
+        # Create the actual figure with calculated dimensions
+        fig, ax = plt.subplots(figsize=(total_width, total_height))
+        
+        # Set axis limits to match our calculated dimensions
+        ax.set_xlim(0, total_width)
         ax.set_ylim(0, total_height)
         ax.axis('off')
         
         # Title
-        ax.text(5, total_height - 0.5, 'Color Legend', 
-                fontsize=16, fontweight='bold', ha='center')
-        
-        # Sort nodes for consistent display
-        sorted_nodes = sorted(node_to_color.keys())
+        ax.text(total_width/2, total_height - margin - 0.2, 'Color Legend', 
+                fontsize=14, fontweight='bold', ha='center', va='top')
         
         # Create legend entries
         for i, node in enumerate(sorted_nodes):
-            y_pos = total_height - (i + 1) * entry_height - 0.8
+            y_pos = total_height - title_height - margin - (i + 1) * entry_height + entry_height/2
             rgb = node_to_color[node]
             color_name = node_to_names[node]
             
             # Normalize RGB values for matplotlib (0-1 range)
             norm_rgb = tuple(c/255.0 for c in rgb)
             
-            # Draw color swatch (using actual RGB values)
-            swatch = Rectangle((1.0, y_pos - 0.15), 0.8, 0.3, 
-                              facecolor=norm_rgb, edgecolor='black', linewidth=1)
-            ax.add_patch(swatch)
+            # Position calculations
+            node_x = margin
+            swatch_x = margin + max_node_width_fig + spacing
+            color_x = swatch_x + swatch_width + spacing
             
-            # Node ID (exactly as it appears in dict keys)
-            ax.text(0.2, y_pos, str(node), fontsize=12, fontweight='bold', 
+            # Node ID (left-aligned)
+            ax.text(node_x, y_pos, str(node), fontsize=12, fontweight='bold', 
                     va='center', ha='left')
             
-            # Color name (mapped name, nicely formatted)
-            ax.text(2.2, y_pos, color_name.replace('_', ' ').title(), 
+            # Draw color swatch
+            swatch_y = y_pos - entry_height/4
+            swatch = Rectangle((swatch_x, swatch_y), swatch_width, entry_height/2, 
+                              facecolor=norm_rgb, edgecolor='black', linewidth=1)
+            ax.add_patch(swatch)
+            
+            # Color name
+            formatted_name = color_name.replace('_', ' ').title()
+            # Truncate very long color names to prevent layout issues
+            if len(formatted_name) > 25:
+                formatted_name = formatted_name[:22] + "..."
+                
+            ax.text(color_x, y_pos, formatted_name, 
                     fontsize=11, va='center', ha='left')
         
-        # Add border around the legend
-        border = Rectangle((0.1, 0.1), 9.8, total_height - 0.2, 
-                          fill=False, edgecolor='gray', linewidth=2)
+        # Add a subtle border around the entire legend
+        border_margin = 0.1
+        border = Rectangle((border_margin, border_margin), 
+                          total_width - 2*border_margin, 
+                          total_height - 2*border_margin, 
+                          fill=False, edgecolor='lightgray', linewidth=1.5)
         ax.add_patch(border)
         
-        plt.tight_layout()
+        # Remove any extra whitespace
+        plt.tight_layout(pad=0.1)
+        
+        # Adjust the figure to eliminate whitespace
+        ax.margins(0)
+        fig.subplots_adjust(left=0, right=1, top=1, bottom=0)
         
         if save_path:
-            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            plt.savefig(save_path, dpi=300, bbox_inches='tight', pad_inches=0.05)
             
         plt.show()
     

nettracer3d/nettracer.py

@@ -1267,31 +1267,6 @@ def dilate_2D(array, search, scaling = 1):
 
     return inv
 
-def erode_2D(array, search, scaling=1):
-    """
-    Erode a 2D array using distance transform method.
-    
-    Parameters:
-    array -- Input 2D binary array
-    search -- Distance within which to erode
-    scaling -- Scaling factor (default: 1)
-    
-    Returns:
-    Eroded 2D array
-    """
-    # For erosion, we work directly with the foreground
-    # No need to invert the array
-    
-    # Compute distance transform on the foreground
-    dt = smart_dilate.compute_distance_transform_distance(array)
-    
-    # Apply scaling
-    dt = dt * scaling
-    
-    # Threshold to keep only points that are at least 'search' distance from the boundary
-    eroded = dt >= search
-    
-    return eroded
 
 def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     """
@@ -1353,7 +1328,42 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     
     return inv.astype(np.uint8)
 
-def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
+def erode_2D(array, search, scaling=1, preserve_labels = False):
+    """
+    Erode a 2D array using distance transform method.
+    
+    Parameters:
+    array -- Input 2D binary array
+    search -- Distance within which to erode
+    scaling -- Scaling factor (default: 1)
+    
+    Returns:
+    Eroded 2D array
+    """
+    # For erosion, we work directly with the foreground
+    # No need to invert the array
+
+    if preserve_labels:
+        from skimage.segmentation import find_boundaries
+        borders = find_boundaries(array, mode='thick')
+        mask = array * invert_array(borders)
+        mask = smart_dilate.compute_distance_transform_distance(mask)
+        mask = mask * scaling
+        mask = mask >= search
+        array = mask * array
+    else:
+        # Compute distance transform on the foreground
+        dt = smart_dilate.compute_distance_transform_distance(array)
+        
+        # Apply scaling
+        dt = dt * scaling
+        
+        # Threshold to keep only points that are at least 'search' distance from the boundary
+        array = dt > search
+    
+    return array
+
+def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, preserve_labels = False):
     """
     Erode a 3D array using distance transform method. DT erosion produces perfect results 
     with Euclidean geometry, but may be slower for large arrays.
@@ -1371,43 +1381,24 @@ def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     
     if array.shape[0] == 1:
         # Handle 2D case
-        return erode_2D(array, search_distance, scaling=xy_scaling)
-    
-    # For erosion, we work directly with the foreground (no inversion needed)
-    
-    """
-    # Determine which dimension needs resampling
-    if (z_scaling > xy_scaling):
-        # Z dimension needs to be stretched
-        zoom_factor = [z_scaling/xy_scaling, 1, 1]  # Scale factor for [z, y, x]
-        rev_factor = [xy_scaling/z_scaling, 1, 1] 
-        cardinal = xy_scaling
-    elif (xy_scaling > z_scaling):
-        # XY dimensions need to be stretched
-        zoom_factor = [1, xy_scaling/z_scaling, xy_scaling/z_scaling]  # Scale factor for [z, y, x]
-        rev_factor = [1, z_scaling/xy_scaling, z_scaling/xy_scaling]  # Scale factor for [z, y, x]
-        cardinal = z_scaling
-    else:
-        # Already uniform scaling, no need to resample
-        zoom_factor = None
-        rev_factor = None
-        cardinal = xy_scaling
+        return erode_2D(array, search_distance, scaling=xy_scaling, preserve_labels = True)
     
-    # Resample the mask if needed
-    if zoom_factor:
-        array = ndimage.zoom(array, zoom_factor, order=0)  # Use order=0 for binary masks
-    """
-    
-    print("Computing a distance transform for a perfect erosion...")
 
-    array = smart_dilate.compute_distance_transform_distance(array, sampling = [z_scaling, xy_scaling, xy_scaling])
-    
-    # Apply scaling factor
-    #array = array * cardinal
-    
-    # Threshold the distance transform to get eroded result
-    # For erosion, we keep only the points that are at least search_distance from the boundary
-    array = array >= search_distance
+    if preserve_labels:
+
+
+        from skimage.segmentation import find_boundaries
+
+        borders = find_boundaries(array, mode='thick')
+        mask = array * invert_array(borders)
+        mask = smart_dilate.compute_distance_transform_distance(mask, sampling = [z_scaling, xy_scaling, xy_scaling])
+        mask = mask >= search_distance
+        array = mask * array
+    else:
+        array = smart_dilate.compute_distance_transform_distance(array, sampling = [z_scaling, xy_scaling, xy_scaling])
+        # Threshold the distance transform to get eroded result
+        # For erosion, we keep only the points that are at least search_distance from the boundary
+        array = array > search_distance
     
     # Resample back to original dimensions if needed
     #if rev_factor:
@@ -1574,7 +1565,7 @@ def dilate_3D_old(tiff_array, dilated_x=3, dilated_y=3, dilated_z=3):
 
 
 def erode_3D(tiff_array, eroded_x, eroded_y, eroded_z):
-    """Internal method to erode an array in 3D. Erosion this way is much faster than using a distance transform although the latter is theoretically more accurate.
+    """Internal method to erode an array in 3D. Erosion this way is faster than using a distance transform although the latter is theoretically more accurate.
     Arguments are an array, and the desired pixel erosion amounts in X, Y, Z."""
 
     if tiff_array.shape[0] == 1:
@@ -2124,15 +2115,15 @@ def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast
 
     return arrayimage
 
-def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0):
-    if len(np.unique(arrayimage)) > 2: #binarize
+def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0, preserve_labels = False):
+    if not preserve_labels and len(np.unique(arrayimage)) > 2: #binarize
         arrayimage = binarize(arrayimage)
     erode_xy, erode_z = dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
 
     if mode == 0:
         arrayimage = (erode_3D(arrayimage, erode_xy, erode_xy, erode_z)) * 255
     else:
-        arrayimage = erode_3D_dt(arrayimage, amount, xy_scaling=xy_scale, z_scaling=z_scale)
+        arrayimage = erode_3D_dt(arrayimage, amount, xy_scaling=xy_scale, z_scaling=z_scale, preserve_labels = preserve_labels)
 
     if np.max(arrayimage) == 1:
         arrayimage = arrayimage * 255
@@ -3847,7 +3838,7 @@ class Network_3D:
 
             self._search_region = self._nodes
 
-    def calculate_edges(self, binary_edges, diledge = None, inners = True, hash_inner_edges = True, search = None, remove_edgetrunk = 0, GPU = True, fast_dil = False, skeletonized = False):
+    def calculate_edges(self, binary_edges, diledge = None, inners = True, search = None, remove_edgetrunk = 0, GPU = True, fast_dil = False, skeletonized = False):
         """
         Method to calculate the edges that are used to directly connect nodes. May be done with or without the search region, however using search_region is recommended. 
         The search_region property must be set to use the search region, otherwise the nodes property must be set. Sets the edges property
@@ -3856,7 +3847,6 @@ class Network_3D:
         so some amount of dilation is recommended if there are any, but  not so much to create overconnectivity. This is a value that needs to be tuned by the user.
         :param inners: (Optional - Val = True; boolean). Will use inner edges if True, will not if False. Inner edges are parts of the edge mask that exist within search regions. If search regions overlap, 
         any edges that exist within the overlap will only assert connectivity if 'inners' is True.
-        :param hash_inner_edges: (Optional - Val = True; boolean). If False, all search regions that contain an edge object connecting multiple nodes will be assigned as connected.
         If True, an extra processing step is used to sort the correct connectivity amongst these search_regions. Can only be computed when search_regions property is set.
         :param search: (Optional - Val = None; int). Amount for nodes to search for connections, assuming the search_regions are not being used. Assigning a value to this param will utilize the secondary algorithm and not the search_regions.
         :param remove_edgetrunk: (Optional - Val = 0; int). Amount of times to remove the 'Trunk' from the edges. A trunk in this case is the largest (by vol) edge object remaining after nodes have broken up the edges.
@@ -3909,11 +3899,7 @@ class Network_3D:
         labelled_edges, num_edge = label_objects(outer_edges)
 
         if inners:
-
-            if search is None and hash_inner_edges is True:
-                inner_edges = hash_inners(self._search_region, binary_edges, GPU = GPU)
-            else:
-                inner_edges = establish_inner_edges(search_region, binary_edges)
+            inner_edges = hash_inners(self._search_region, binary_edges, GPU = GPU)
 
             del binary_edges
 
@@ -4045,7 +4031,7 @@ class Network_3D:
             self._network_lists = network_analysis.read_excel_to_lists(df)
             self._network, net_weights = network_analysis.weighted_network(df)
 
-    def calculate_all(self, nodes, edges, xy_scale = 1, z_scale = 1, down_factor = None, search = None, diledge = None, inners = True, hash_inners = True, remove_trunk = 0, ignore_search_region = False, other_nodes = None, label_nodes = True, directory = None, GPU = True, fast_dil = True, skeletonize = False, GPU_downsample = None):
+    def calculate_all(self, nodes, edges, xy_scale = 1, z_scale = 1, down_factor = None, search = None, diledge = None, inners = True, remove_trunk = 0, ignore_search_region = False, other_nodes = None, label_nodes = True, directory = None, GPU = True, fast_dil = True, skeletonize = False, GPU_downsample = None):
         """
         Method to calculate and save to mem all properties of a Network_3D object. In general, after initializing a Network_3D object, this method should be called on the node and edge masks that will be used to calculate the network.
         :param nodes: (Mandatory; String or ndarray). Filepath to segmented nodes mask or a numpy array containing the same.
@@ -4058,7 +4044,6 @@ class Network_3D:
         so some amount of dilation is recommended if there are any, but not so much to create overconnectivity. This is a value that needs to be tuned by the user.
         :param inners: (Optional - Val = True; boolean). Will use inner edges if True, will not if False. Inner edges are parts of the edge mask that exist within search regions. If search regions overlap, 
         any edges that exist within the overlap will only assert connectivity if 'inners' is True.
-        :param hash_inners: (Optional - Val = True; boolean). If False, all search regions that contain an edge object connecting multiple nodes will be assigned as connected.
         If True, an extra processing step is used to sort the correct connectivity amongst these search_regions. Can only be computed when search_regions property is set.
         :param remove_trunk: (Optional - Val = 0; int). Amount of times to remove the 'Trunk' from the edges. A trunk in this case is the largest (by vol) edge object remaining after nodes have broken up the edges.
         Any 'Trunks' removed will be absent for connection calculations.
@@ -4120,7 +4105,7 @@ class Network_3D:
                 except:
                     pass
 
-            self.calculate_edges(edges, diledge = diledge, inners = inners, hash_inner_edges = hash_inners, search = search, remove_edgetrunk = remove_trunk, GPU = GPU, fast_dil = fast_dil, skeletonized = skeletonize) #Will have to be moved out if the second method becomes more directly implemented
+            self.calculate_edges(edges, diledge = diledge, inners = inners, search = search, remove_edgetrunk = remove_trunk, GPU = GPU, fast_dil = fast_dil, skeletonized = skeletonize) #Will have to be moved out if the second method becomes more directly implemented
         else:
             self._edges, _ = label_objects(edges)
 
@@ -5104,13 +5089,16 @@ class Network_3D:
 
 
             for node in G.nodes():
-                nodeid = node_identities[node]
-                neighbors = list(G.neighbors(node))
-                for subnode in neighbors:
-                    subnodeid = node_identities[subnode]
-                    if subnodeid == root:
-                        neighborhood_dict[nodeid] += 1
-                        break
+                try:
+                    nodeid = node_identities[node]
+                    neighbors = list(G.neighbors(node))
+                    for subnode in neighbors:
+                        subnodeid = node_identities[subnode]
+                        if subnodeid == root:
+                            neighborhood_dict[nodeid] += 1
+                            break
+                except:
+                    pass
 
             title1 = f'Neighborhood Distribution of Nodes in Network from Nodes: {root}'
             title2 = f'Neighborhood Distribution of Nodes in Network from Nodes {root} as a proportion of total nodes of that ID'
@@ -5219,34 +5207,22 @@ class Network_3D:
                     bounds = (min_coords, max_coords)
                     dim_list = max_coords - min_coords
 
-
-                if dim == 3:
-
-                    """
-                    if self.xy_scale > self.z_scale: # xy will be 'expanded' more so its components will be arbitrarily further from the border than z ones
-                        factor_xy = (self.z_scale/self.xy_scale) * factor # So 'factor' in the xy dim has to get smaller
-                        factor_z = factor
-                    elif self.z_scale > self.xy_scale: # Same idea
-                        factor_z = (self.xy_scale/self.z_scale) * factor
-                        factor_xy = factor
-                    else:
-                        factor_z = factor
-                        factor_xy = factor
-                    """
-
-                    for centroid in roots:
-
-                        if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor) and ((centroid[0] - min_coords[2]) > dim_list[2] * factor) and ((max_coords[2] - centroid[0]) > dim_list[2] * factor):
+                for centroid in roots:
+                    # Assuming centroid is [z, y, x] based on your indexing
+                    z, y, x = centroid[0], centroid[1], centroid[2]
+                    
+                    # Check x-dimension
+                    x_ok = (x - min_coords[0]) > dim_list[0] * factor and (max_coords[0] - x) > dim_list[0] * factor
+                    # Check y-dimension  
+                    y_ok = (y - min_coords[1]) > dim_list[1] * factor and (max_coords[1] - y) > dim_list[1] * factor
+                    
+                    if dim == 3:  # 3D case
+                        # Check z-dimension
+                        z_ok = (z - min_coords[2]) > dim_list[2] * factor and (max_coords[2] - z) > dim_list[2] * factor
+                        if x_ok and y_ok and z_ok:
                             new_list.append(centroid)
-
-
-                        #if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor) and ((centroid[0] - min_coords[2]) > dim_list[2] * factor) and ((max_coords[2] - centroid[0]) > dim_list[2] * factor):
-                            #new_list.append(centroid)
-                            #print(f"dim_list: {dim_list}, centroid: {centroid}, min_coords: {min_coords}, max_coords: {max_coords}")
-                else:
-                    for centroid in roots:
-
-                        if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor):
+                    else:  # 2D case
+                        if x_ok and y_ok:
                             new_list.append(centroid)
 
             else:
@@ -5299,8 +5275,6 @@ class Network_3D:
             print(f"Utilizing {len(roots)} root points. Note that low n values are unstable.")
             is_subset = True
 
-
-
         roots = proximity.convert_centroids_to_array(roots, xy_scale = self.xy_scale, z_scale = self.z_scale)
 
         n_subset = len(targs)
@@ -5608,7 +5582,10 @@ class Network_3D:
                         for iden in idens:
                             counter[id_dict[iden]] += 1
                     except:
-                        counter[id_dict[self.node_identities[node]]] += 1 # Keep them as arrays
+                        try:
+                            counter[id_dict[self.node_identities[node]]] += 1 # Keep them as arrays
+                        except:
+                            pass
 
                 for i in range(len(counter)): # Translate them into proportions out of 1
 
@@ -5645,7 +5622,10 @@ class Network_3D:
                         for iden in idents:
                             iden_tracker[iden] += 1
                     except:
-                        iden_tracker[self.node_identities[node]] += 1 
+                        try:
+                            iden_tracker[self.node_identities[node]] += 1
+                        except:
+                            pass
 
                 i = 0