nettracer3d 1.1.1__tar.gz → 1.1.3__tar.gz

{nettracer3d-1.1.1/src/nettracer3d.egg-info → nettracer3d-1.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.1.1
+Version: 1.1.3
 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/
@@ -110,6 +110,6 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.1.1 Updates --
+-- Version 1.1.3 Updates --
 
-	* Can now intermittently downsample while making the network and id overlays now to make their relevant elements larger in the actual rendered output.
+	* Some minor text adjustments

{nettracer3d-1.1.1 → nettracer3d-1.1.3}/README.md

@@ -65,6 +65,6 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.1.1 Updates --
+-- Version 1.1.3 Updates --
 
-	* Can now intermittently downsample while making the network and id overlays now to make their relevant elements larger in the actual rendered output.
+	* Some minor text adjustments

{nettracer3d-1.1.1 → nettracer3d-1.1.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "1.1.1"
+version = "1.1.3"
 authors = [
   { name="Liam McLaughlin", email="liamm@wustl.edu" },
 ]
@@ -37,7 +37,7 @@ classifiers = [
 # GPU options (choose one)
 CUDA11 = ["cupy-cuda11x"]
 CUDA12 = ["cupy-cuda12x"]
-cupy = ["cupy"]
+cupy = ["cupy"] 
 
 # Features
 cellpose = ["cellpose[GUI]"]

{nettracer3d-1.1.1 → nettracer3d-1.1.3}/src/nettracer3d/morphology.py

@@ -205,15 +205,20 @@ def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, core
 
 # Helper methods for counting the lens of skeletons:
 
-def calculate_skeleton_lengths(skeleton_binary, xy_scale=1.0, z_scale=1.0):
+def calculate_skeleton_lengths(skeleton_binary, xy_scale=1.0, z_scale=1.0, skeleton_coords = None):
     """
     Calculate total length of all skeletons in a 3D binary image.
     
     skeleton_binary: 3D boolean array where True = skeleton voxel
     xy_scale, z_scale: physical units per voxel
     """
-    # Find all skeleton voxels
-    skeleton_coords = np.argwhere(skeleton_binary)
+
+    if skeleton_coords is None:
+        # Find all skeleton voxels
+        skeleton_coords = np.argwhere(skeleton_binary)
+        shape = skeleton_binary.shape
+    else:
+        shape = skeleton_binary #Very professional stuff
     
     if len(skeleton_coords) == 0:
         return 0.0
@@ -222,7 +227,7 @@ def calculate_skeleton_lengths(skeleton_binary, xy_scale=1.0, z_scale=1.0):
     coord_to_idx = {tuple(coord): idx for idx, coord in enumerate(skeleton_coords)}
     
     # Build adjacency graph
-    adjacency_list = build_adjacency_graph(skeleton_coords, coord_to_idx, skeleton_binary.shape)
+    adjacency_list = build_adjacency_graph(skeleton_coords, coord_to_idx, shape)
     
     # Calculate lengths using scaled distances
     total_length = calculate_graph_length(skeleton_coords, adjacency_list, xy_scale, z_scale)

{nettracer3d-1.1.1 → nettracer3d-1.1.3}/src/nettracer3d/neighborhoods.py

@@ -793,7 +793,7 @@ def create_community_heatmap(community_intensity, node_community, node_centroids
             return np.array([r, g, b], dtype=np.uint8)
         
         # Create lookup table for RGB colors
-        max_label = max(max(labeled_array.flat), max(node_to_community_intensity.keys()) if node_to_community_intensity else 0)
+        max_label = int(max(max(labeled_array.flat), max(node_to_community_intensity.keys()) if node_to_community_intensity else 0))
         color_lut = np.zeros((max_label + 1, 3), dtype=np.uint8)  # Default to black (0,0,0)
         
         # Fill lookup table with RGB colors based on community intensity
@@ -1036,8 +1036,8 @@ def create_node_heatmap(node_intensity, node_centroids, shape=None, is_3d=True,
 
         # Modified usage in your main function:
         # Create lookup table for RGBA colors (note the 4 channels now)
-        max_label = max(max(labeled_array.flat), max(node_to_intensity.keys()) if node_to_intensity else 0)
-        color_lut = np.zeros((max_label + 1, 4), dtype=np.uint8)  # Default to transparent (0,0,0,0)
+        max_label = int(max(max(labeled_array.flat), max(node_to_intensity.keys()) if node_to_intensity else 0))
+        color_lut = np.zeros((max_label + 1, 4), dtype=np.uint8)
 
         # Fill lookup table with RGBA colors based on intensity
         for node_id, intensity in node_to_intensity.items():

{nettracer3d-1.1.1 → nettracer3d-1.1.3}/src/nettracer3d/nettracer.py

@@ -738,7 +738,7 @@ def estimate_object_radii(labeled_array, gpu=False, n_jobs=None, xy_scale = 1, z
         return morphology.estimate_object_radii_cpu(labeled_array, n_jobs, xy_scale = xy_scale, z_scale = z_scale)
 
 
-def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil = 0, max_vol = 0, directory = None, return_skele = False, nodes = None):
+def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil = 0, max_vol = 0, directory = None, return_skele = False, nodes = None, compute = True, xy_scale = 1, z_scale = 1):
     """Internal method to break open a skeleton at its branchpoints and label the remaining components, for an 8bit binary array"""
 
     if type(skeleton) == str:
@@ -747,18 +747,28 @@ def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil =
     else:
         broken_skele = None
 
-    #old_skeleton = copy.deepcopy(skeleton) # The skeleton might get modified in label_vertices so we can make a preserved copy of it to use later
-
     if nodes is None:
 
-        verts = label_vertices(skeleton, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, return_skele = return_skele)
+        verts = label_vertices(skeleton, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, return_skele = return_skele, compute = compute)
 
     else:
         verts = nodes
 
     verts = invert_array(verts)
 
-    #skeleton = old_skeleton
+    """
+    if compute: # We are interested in the endpoints if we are doing the optional computation later
+        endpoints = []
+        image_copy = np.pad(skeleton, pad_width=1, mode='constant', constant_values=0)
+        nonzero_coords = np.transpose(np.nonzero(image_copy))
+        for x, y, z in nonzero_coords:
+            mini = image_copy[x-1:x+2, y-1:y+2, z-1:z+2]
+            nearby_sum = np.sum(mini)
+            threshold = 2 * image_copy[x, y, z]
+            
+            if nearby_sum <= threshold:
+                endpoints.append((x, y, z))
+    """
 
     image_copy = skeleton * verts
 
@@ -776,9 +786,137 @@ def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil =
         tifffile.imwrite(filename, labeled_image, photometric='minisblack')
         print(f"Broken skeleton saved to {filename}")
 
-    return labeled_image
+    if compute:
+
+        return labeled_image, None, skeleton, None
+
+    return labeled_image, None, None, None
+
+def compute_optional_branchstats(verts, labeled_array, endpoints, xy_scale = 1, z_scale = 1):
 
+    #Lengths:
+    # Get all non-background coordinates and their labels in one pass
+    z, y, x = np.where(labeled_array != 0)
+    labels = labeled_array[z, y, x]
 
+    # Sort by label
+    sort_idx = np.argsort(labels)
+    labels_sorted = labels[sort_idx]
+    z_sorted = z[sort_idx]
+    y_sorted = y[sort_idx]
+    x_sorted = x[sort_idx]
+
+    # Find where each label starts
+    unique_labels, split_idx = np.unique(labels_sorted, return_index=True)
+    split_idx = split_idx[1:]  # Remove first index for np.split
+
+    # Split into groups
+    z_split = np.split(z_sorted, split_idx)
+    y_split = np.split(y_sorted, split_idx)
+    x_split = np.split(x_sorted, split_idx)
+
+    # Build dict
+    coords_dict = {label: np.column_stack([z, y, x]) 
+                   for label, z, y, x in zip(unique_labels, z_split, y_split, x_split)}
+
+    from sklearn.neighbors import NearestNeighbors
+    from scipy.spatial.distance import pdist, squareform
+    len_dict = {}
+    tortuosity_dict = {}
+    angle_dict = {}
+    for label, coords in coords_dict.items():
+        len_dict[label] = morphology.calculate_skeleton_lengths(labeled_array.shape, xy_scale=xy_scale, z_scale=z_scale, skeleton_coords=coords)
+        
+        # Find neighbors for all points at once
+        nbrs = NearestNeighbors(radius=1.74, algorithm='kd_tree').fit(coords)
+        neighbor_counts = nbrs.radius_neighbors(coords, return_distance=False)
+        neighbor_counts = np.array([len(n) - 1 for n in neighbor_counts])  # -1 to exclude self
+        
+        # Endpoints have exactly 1 neighbor
+        endpoints = coords[neighbor_counts == 1]
+        
+        if len(endpoints) > 1:
+            # Scale endpoints
+            scaled_endpoints = endpoints.copy().astype(float)
+            scaled_endpoints[:, 0] *= z_scale  # z dimension
+            scaled_endpoints[:, 1] *= xy_scale  # y dimension
+            scaled_endpoints[:, 2] *= xy_scale  # x dimension
+            
+            # calculate distances on scaled coordinates
+            distances = pdist(scaled_endpoints, metric='euclidean')
+            max_distance = distances.max()
+            
+            tortuosity_dict[label] = len_dict[label]/max_distance
+
+    """
+    verts = invert_array(verts)
+    for x, y, z in endpoints:
+        try:
+            verts[z,y,x] = 1
+        except IndexError:
+            print(x, y, z)
+
+    temp_network = Network_3D(nodes = verts, edges = labeled_array, xy_scale = xy_scale, z_scale = z_scale)
+    temp_network.calculate_all(temp_network.nodes, temp_network.edges, xy_scale = temp_network.xy_scale, z_scale = temp_network.z_scale, search = None, diledge = None, inners = False, remove_trunk = 0, ignore_search_region = True, other_nodes = None, label_nodes = True, directory = None, GPU = False, fast_dil = False, skeletonize = False, GPU_downsample = None)
+    temp_network.calculate_node_centroids()
+    from itertools import combinations
+    for node in temp_network.network.nodes:
+        neighbors = list(temp_network.network.neighbors(node))
+        
+        # Skip if fewer than 2 neighbors (endpoints or isolated nodes)
+        if len(neighbors) < 2:
+            continue
+        
+        # Get all unique pairs of neighbors
+        neighbor_pairs = combinations(neighbors, 2)
+        
+        angles = []
+        for neighbor1, neighbor2 in neighbor_pairs:
+            # Get coordinates from centroids
+            point_a = temp_network.node_centroids[neighbor1]
+            point_b = temp_network.node_centroids[node]  # vertex
+            point_c = temp_network.node_centroids[neighbor2]
+            
+            # Calculate angle
+            angle_result = calculate_3d_angle(point_a, point_b, point_c, xy_scale = xy_scale, z_scale = z_scale)
+            angles.append(angle_result)
+        
+        angle_dict[node] = angles
+    """
+
+    return len_dict, tortuosity_dict, angle_dict
+
+def calculate_3d_angle(point_a, point_b, point_c, xy_scale = 1, z_scale = 1):
+    """Calculate 3D angle at vertex B between points A-B-C."""
+    z1, y1, x1 = point_a
+    z2, y2, x2 = point_b  # vertex
+    z3, y3, x3 = point_c
+    
+    # Apply scaling
+    scaled_a = np.array([x1 * xy_scale, y1 * xy_scale, z1 * z_scale])
+    scaled_b = np.array([x2 * xy_scale, y2 * xy_scale, z2 * z_scale])
+    scaled_c = np.array([x3 * xy_scale, y3 * xy_scale, z3 * z_scale])
+    
+    # Create vectors from vertex B
+    vec_ba = scaled_a - scaled_b
+    vec_bc = scaled_c - scaled_b
+    
+    # Calculate angle using dot product
+    dot_product = np.dot(vec_ba, vec_bc)
+    magnitude_ba = np.linalg.norm(vec_ba)
+    magnitude_bc = np.linalg.norm(vec_bc)
+    
+    # Avoid division by zero
+    if magnitude_ba == 0 or magnitude_bc == 0:
+        return {'angle_degrees': 0}
+    
+    cos_angle = dot_product / (magnitude_ba * magnitude_bc)
+    cos_angle = np.clip(cos_angle, -1.0, 1.0)  # Handle numerical errors
+    
+    angle_radians = np.arccos(cos_angle)
+    angle_degrees = np.degrees(angle_radians)
+
+    return angle_degrees
 
 def threshold(arr, proportion, custom_rad = None):
 
@@ -2129,7 +2267,7 @@ def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0, preserve_labe
         arrayimage = binarize(arrayimage)
     erode_xy, erode_z = dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
 
-    if mode == 0:
+    if mode == 2:
         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, preserve_labels = preserve_labels)
@@ -2184,7 +2322,7 @@ def skeletonize(arrayimage, directory = None):
 
     return arrayimage
 
-def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None):
+def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None, compute = False, xy_scale = 1, z_scale = 1):
     """
     Can be used to label branches a binary image. Labelled output will be saved to the active directory if none is specified. Note this works better on already thin filaments and may over-divide larger trunkish objects.
     :param array: (Mandatory, string or ndarray) - If string, a path to a tif file to label. Note that the ndarray alternative is for internal use mainly and will not save its output.
@@ -2215,10 +2353,10 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
         other_array = skeletonize(array)
 
-        other_array = break_and_label_skeleton(other_array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes)
+        other_array, verts, skele, endpoints = break_and_label_skeleton(other_array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes, compute = compute, xy_scale = xy_scale, z_scale = z_scale)
 
     else:
-        array = break_and_label_skeleton(array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes)
+        array, verts, skele, endpoints = break_and_label_skeleton(array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes, compute = compute, xy_scale = xy_scale, z_scale = z_scale)
 
     if nodes is not None and down_factor is not None:
         array = upsample_with_padding(array, down_factor, arrayshape)
@@ -2257,7 +2395,7 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
         print("Branches labelled")
 
 
-    return array
+    return array, verts, skele, endpoints
 
 def fix_branches_network(array, G, communities, fix_val = None):
 

{nettracer3d-1.1.1 → nettracer3d-1.1.3}/src/nettracer3d/nettracer_gui.py

@@ -184,6 +184,12 @@ class ImageViewerWindow(QMainWindow):
             3: None
         }
 
+        self.branch_dict = {
+            0: None,
+            1: None
+
+        }
+
         self.original_shape = None #For undoing resamples
         
         # Create control panel
@@ -462,6 +468,7 @@ class ImageViewerWindow(QMainWindow):
 
         self.resume = False
         self._first_pan_done = False
+        self.thresh_window_ref = None
 
 
     def load_file(self):
@@ -2167,6 +2174,16 @@ class ImageViewerWindow(QMainWindow):
                     except:
                         pass
 
+                if self.branch_dict[0] is not None:
+                    try:
+                        info_dict['Branch Length'] = self.branch_dict[0][0][label]
+                    except:
+                        pass
+                    try:
+                        info_dict['Branch Tortuosity'] = self.branch_dict[0][1][label]
+                    except:
+                        pass
+
 
             elif sort == 'edge':
 
@@ -2212,6 +2229,16 @@ class ImageViewerWindow(QMainWindow):
                     except:
                         pass
 
+                if self.branch_dict[1] is not None:
+                    try:
+                        info_dict['Branch Length'] = self.branch_dict[1][0][label]
+                    except:
+                        pass
+                    try:
+                        info_dict['Branch Tortuosity'] = self.branch_dict[1][1][label]
+                    except:
+                        pass
+
             self.format_for_upperright_table(info_dict, title = f'Info on Object', sort = False)
 
         except:
@@ -4191,10 +4218,8 @@ class ImageViewerWindow(QMainWindow):
         elif self.zoom_mode:
             # Handle zoom mode press
             if self.original_xlim is None:
-                self.original_xlim = self.ax.get_xlim()
-                #print(self.original_xlim)
-                self.original_ylim = self.ax.get_ylim()
-                #print(self.original_ylim)
+                self.original_xlim = (-0.5, self.shape[2] - 0.5)
+                self.original_ylim = (self.shape[1] + 0.5, -0.5)
             
             current_xlim = self.ax.get_xlim()
             current_ylim = self.ax.get_ylim()
@@ -4356,8 +4381,8 @@ class ImageViewerWindow(QMainWindow):
         if self.zoom_mode:
             # Existing zoom functionality
             if self.original_xlim is None:
-                self.original_xlim = self.ax.get_xlim()
-                self.original_ylim = self.ax.get_ylim()
+                self.original_xlim = (-0.5, self.shape[2] - 0.5)
+                self.original_ylim = (self.shape[1] + 0.5, -0.5)
             
             current_xlim = self.ax.get_xlim()
             current_ylim = self.ax.get_ylim()
@@ -4634,6 +4659,8 @@ class ImageViewerWindow(QMainWindow):
         image_menu = process_menu.addMenu("Image")
         resize_action = image_menu.addAction("Resize (Up/Downsample)")
         resize_action.triggered.connect(self.show_resize_dialog)
+        clean_action = image_menu.addAction("Clean Segmentation")
+        clean_action.triggered.connect(self.show_clean_dialog)
         dilate_action = image_menu.addAction("Dilate")
         dilate_action.triggered.connect(self.show_dilate_dialog)
         erode_action = image_menu.addAction("Erode")
@@ -5225,6 +5252,12 @@ class ImageViewerWindow(QMainWindow):
 
             self.load_channel(0, my_network.edges, data = True)
 
+            try:
+                self.branch_dict[0] = self.branch_dict[1]
+                self.branch_dict[1] = None
+            except:
+                pass
+
             self.delete_channel(1, False)
 
             my_network.morph_proximity(search = [3,3], fastdil = True)
@@ -5241,14 +5274,14 @@ class ImageViewerWindow(QMainWindow):
         dialog = CentroidDialog(self)
         dialog.exec()
 
-    def show_dilate_dialog(self):
+    def show_dilate_dialog(self, args = None):
         """show the dilate dialog"""
-        dialog = DilateDialog(self)
+        dialog = DilateDialog(self, args)
         dialog.exec()
 
-    def show_erode_dialog(self):
+    def show_erode_dialog(self, args = None):
         """show the erode dialog"""
-        dialog = ErodeDialog(self)
+        dialog = ErodeDialog(self, args)
         dialog.exec()
 
     def show_hole_dialog(self):
@@ -5347,6 +5380,9 @@ class ImageViewerWindow(QMainWindow):
         dialog = ResizeDialog(self)
         dialog.exec()
 
+    def show_clean_dialog(self):
+        dialog = CleanDialog(self)
+        dialog.show()
 
     def show_properties_dialog(self):
         """Show the properties dialog"""
@@ -6029,7 +6065,11 @@ class ImageViewerWindow(QMainWindow):
                                 print(f"xy_scale property set to {my_network.xy_scale}; z_scale property set to {my_network.z_scale}")
                             except:
                                 pass
-                        self.channel_data[channel_index] = tifffile.imread(filename)
+                        test_channel_data = tifffile.imread(filename)
+                        if len(test_channel_data.shape) not in (2, 3, 4):
+                            print("Invalid Shape")
+                            return 
+                        self.channel_data[channel_index] = test_channel_data
 
                     elif file_extension == 'nii':
                         import nibabel as nib
@@ -6194,7 +6234,11 @@ class ImageViewerWindow(QMainWindow):
 
             if self.shape == self.channel_data[channel_index].shape:
                 preserve_zoom = (self.ax.get_xlim(), self.ax.get_ylim())
-            self.shape = (self.channel_data[channel_index].shape[0], self.channel_data[channel_index].shape[1], self.channel_data[channel_index].shape[2])
+                self.shape = (self.channel_data[channel_index].shape[0], self.channel_data[channel_index].shape[1], self.channel_data[channel_index].shape[2])
+            else:
+                self.shape = (self.channel_data[channel_index].shape[0], self.channel_data[channel_index].shape[1], self.channel_data[channel_index].shape[2])
+                ylim, xlim = (self.shape[1] + 0.5, -0.5), (-0.5, self.shape[2] - 0.5)
+                preserve_zoom = (xlim, ylim)
             if self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor:
                 self.throttle = True
             else:
@@ -6202,7 +6246,6 @@ class ImageViewerWindow(QMainWindow):
 
 
             self.img_height, self.img_width = self.shape[1], self.shape[2]
-            self.original_ylim, self.original_xlim = (self.shape[1] + 0.5, -0.5), (-0.5, self.shape[2] - 0.5)
 
             self.completed_paint_strokes = [] #Reset pending paint operations
             self.current_stroke_points = []
@@ -6836,8 +6879,6 @@ class ImageViewerWindow(QMainWindow):
 
         except Exception as e:
             pass
-            #import traceback
-            #print(traceback.format_exc())
 
 
     def get_channel_image(self, channel):
@@ -8665,6 +8706,9 @@ class Show3dDialog(QDialog):
                         if visible:
                             arrays_4d.append(channel)
 
+            if self.parent().thresh_window_ref is not None:
+                self.parent().thresh_window_ref.make_full_highlight()
+
             if self.parent().highlight_overlay is not None or self.parent().mini_overlay_data is not None:
                 if self.parent().mini_overlay == True:
                     self.parent().create_highlight_overlay(node_indices = self.parent().clicked_values['nodes'], edge_indices = self.parent().clicked_values['edges'])
@@ -11046,6 +11090,79 @@ class ResizeDialog(QDialog):
             print(traceback.format_exc())
             QMessageBox.critical(self, "Error", f"Failed to resize: {str(e)}")
 
+class CleanDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Some options for cleaning segmentation")
+        self.setModal(False)
+
+        layout = QFormLayout(self)
+
+        # Add Run button
+        run_button = QPushButton("Close")
+        run_button.clicked.connect(self.close)
+        layout.addRow("Close (Fill Small Gaps - Dilate then Erode by same amount):", run_button)
+
+        # Add Run button
+        run_button = QPushButton("Open")
+        run_button.clicked.connect(self.open)
+        layout.addRow("Open (Eliminate Noise, Jagged Borders, and Small Connections Between Objects - Erode then Dilate by same amount):", run_button)
+
+        # Add Run button
+        run_button = QPushButton("Fill Holes")
+        run_button.clicked.connect(self.holes)
+        layout.addRow("Call the fill holes function:", run_button)
+
+        # Add Run button
+        run_button = QPushButton("Threshold Noise")
+        run_button.clicked.connect(self.thresh)
+        layout.addRow("Threshold Noise By Volume:", run_button)
+
+    def close(self):
+
+        try:
+            self.parent().show_dilate_dialog(args = [1])
+            self.parent().show_erode_dialog(args = [self.parent().last_dil])
+        except:
+            pass
+
+    def open(self):
+
+        try:
+            self.parent().show_erode_dialog(args = [1])
+            self.parent().show_dilate_dialog(args = [self.parent().last_ero])
+        except:
+            pass
+
+    def holes(self):
+
+        try:
+            self.parent().show_hole_dialog()
+        except:
+            pass
+
+    def thresh(self):
+        try:
+            if len(np.unique(self.parent().channel_data[self.parent().active_channel])) < 3:
+                self.parent().show_label_dialog()
+
+            if self.parent().volume_dict[self.parent().active_channel] is None:
+                self.parent().volumes()
+
+            thresh_window = ThresholdWindow(self.parent(), 1)
+            thresh_window.show()  # Non-modal window
+            self.parent().highlight_overlay = None
+            #self.mini_overlay = False
+            self.parent().mini_overlay_data = None
+        except:
+            import traceback
+            print(traceback.format_exc())
+            pass
+
+
+
+
+
 
 class OverrideDialog(QDialog):
     def __init__(self, parent=None):
@@ -12356,6 +12473,7 @@ class ThresholdWindow(QMainWindow):
 
     def __init__(self, parent=None, accepted_mode=0):
         super().__init__(parent)
+        self.parent().thresh_window_ref = self
         self.setWindowTitle("Threshold")
 
         self.accepted_mode = accepted_mode
@@ -12509,10 +12627,8 @@ class ThresholdWindow(QMainWindow):
         self.processing_cancelled.emit()
         self.close()
 
-    def closeEvent(self, event):
-        self.parent().preview = False
-        self.parent().targs = None
-        self.parent().bounds = False
+    def make_full_highlight(self):
+
         try: # could probably be refactored but this just handles keeping the highlight elements if the user presses X
             if self.chan == 0:
                 if not self.bounds:
@@ -12546,6 +12662,14 @@ class ThresholdWindow(QMainWindow):
             pass
 
 
+    def closeEvent(self, event):
+        self.parent().preview = False
+        self.parent().targs = None
+        self.parent().bounds = False
+        self.parent().thresh_window_ref = None
+        self.make_full_highlight()
+
+
     def get_values_in_range_all_vols(self, chan, min_val, max_val):
         output = []
         if self.accepted_mode == 1:
@@ -12812,14 +12936,21 @@ class SmartDilateDialog(QDialog):
 
 
 class DilateDialog(QDialog):
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, args = None):
         super().__init__(parent)
         self.setWindowTitle("Dilate Parameters")
         self.setModal(True)
         
         layout = QFormLayout(self)
 
-        self.amount = QLineEdit("1")
+        if args:
+            self.parent().last_dil = args[0]
+            self.index = 1
+        else:
+            self.parent().last_dil = 1
+            self.index = 0
+
+        self.amount = QLineEdit(f"{self.parent().last_dil}")
         layout.addRow("Dilation Radius:", self.amount)
 
         if my_network.xy_scale is not None:
@@ -12840,8 +12971,8 @@ class DilateDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Pseudo3D Binary Kernels (For Fast, small dilations)", "Preserve Labels (slower)", "Distance Transform-Based (Slower but more accurate at larger dilations)"])
-        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        self.mode_selector.addItems(["Distance Transform-Based (Slower but more accurate at larger dilations)", "Preserve Labels (slower)", "Pseudo3D Binary Kernels (For Fast, small dilations)"])
+        self.mode_selector.setCurrentIndex(self.index)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
        # Add Run button
@@ -12883,13 +13014,15 @@ class DilateDialog(QDialog):
             if active_data is None:
                 raise ValueError("No active image selected")
 
+            self.parent().last_dil = amount
+
             if accepted_mode == 1:
                 dialog = SmartDilateDialog(self.parent(), [active_data, amount, xy_scale, z_scale])
                 dialog.exec()
                 self.accept()
                 return
 
-            if accepted_mode == 2:
+            if accepted_mode == 0:
                 result = n3d.dilate_3D_dt(active_data, amount, xy_scaling = xy_scale, z_scaling = z_scale)
             else:
 
@@ -12919,14 +13052,21 @@ class DilateDialog(QDialog):
             )
 
 class ErodeDialog(QDialog):
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, args = None):
         super().__init__(parent)
         self.setWindowTitle("Erosion Parameters")
         self.setModal(True)
         
         layout = QFormLayout(self)
 
-        self.amount = QLineEdit("1")
+        if args:
+            self.parent().last_ero = args[0]
+            self.index = 1
+        else:
+            self.parent().last_ero = 1
+            self.index = 0
+
+        self.amount = QLineEdit(f"{self.parent().last_ero}")
         layout.addRow("Erosion Radius:", self.amount)
 
         if my_network.xy_scale is not None:
@@ -12947,8 +13087,8 @@ class ErodeDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Pseudo3D Binary Kernels (For Fast, small erosions)", "Distance Transform-Based (Slower but more accurate at larger dilations)", "Preserve Labels (Slower)"])
-        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        self.mode_selector.addItems(["Distance Transform-Based (Slower but more accurate at larger erosions)", "Preserve Labels (Slower)", "Pseudo3D Binary Kernels (For Fast, small erosions)"])
+        self.mode_selector.setCurrentIndex(self.index)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
        # Add Run button
@@ -12984,8 +13124,7 @@ class ErodeDialog(QDialog):
 
             mode = self.mode_selector.currentIndex()
 
-            if mode == 2:
-                mode = 1
+            if mode == 1:
                 preserve_labels = True
             else:
                 preserve_labels = False
@@ -13007,7 +13146,7 @@ class ErodeDialog(QDialog):
 
 
             self.parent().load_channel(self.parent().active_channel, result, True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
-
+            self.parent().last_ero = amount
             self.accept()
             
         except Exception as e:
@@ -13037,6 +13176,11 @@ class HoleDialog(QDialog):
         self.borders.setChecked(False)
         layout.addRow("Fill Small Holes Along Borders:", self.borders)
 
+        self.preserve_labels = QPushButton("Preserve Labels")
+        self.preserve_labels.setCheckable(True)
+        self.preserve_labels.setChecked(False)
+        layout.addRow("Preserve Labels (Slower):", self.preserve_labels)
+
         self.sep_holes = QPushButton("Seperate Hole Mask")
         self.sep_holes.setCheckable(True)
         self.sep_holes.setChecked(False)
@@ -13059,6 +13203,9 @@ class HoleDialog(QDialog):
             borders = self.borders.isChecked()
             headon = self.headon.isChecked()
             sep_holes = self.sep_holes.isChecked()
+            preserve_labels = self.preserve_labels.isChecked()
+            if preserve_labels:
+                label_copy = np.copy(active_data)
 
             if borders:
             
@@ -13077,7 +13224,11 @@ class HoleDialog(QDialog):
                     fill_borders = borders
                 )
 
+
             if not sep_holes:
+                if preserve_labels:
+                    result = sdl.smart_label(result, label_copy, directory = None, GPU = False, remove_template = True)
+
                 self.parent().load_channel(self.parent().active_channel, result, True)
             else:
                 self.parent().load_channel(3, active_data - result, True)
@@ -14071,7 +14222,6 @@ class GenNodesDialog(QDialog):
                 order = order,
                 return_skele = True,
                 fastdil = fastdil
-
             )
 
             if down_factor > 0 and not self.called:
@@ -14163,7 +14313,7 @@ class BranchDialog(QDialog):
             self.fix3.setChecked(True)
         else:
             self.fix3.setChecked(False)
-        correction_layout.addWidget(QLabel("Split Nontouching Branches? (Useful if branch pruning - may want to threshold out small, split branches after): "), 4, 0)
+        correction_layout.addWidget(QLabel("Split Nontouching Branches?: "), 4, 0)
         correction_layout.addWidget(self.fix3, 4, 1)
         
         correction_group.setLayout(correction_layout)
@@ -14191,20 +14341,27 @@ class BranchDialog(QDialog):
         # --- Misc Options Group ---
         misc_group = QGroupBox("Misc Options")
         misc_layout = QGridLayout()
+
+        # optional computation checkbox
+        self.compute = QPushButton("Branch Stats")
+        self.compute.setCheckable(True)
+        self.compute.setChecked(True)
+        misc_layout.addWidget(QLabel("Compute Branch Stats (Branch Lengths, Tortuosity. Set xy_scale and z_scale in properties first if real distances are desired.):"), 0, 0)
+        misc_layout.addWidget(self.compute, 0, 1)
         
         # Nodes checkbox
         self.nodes = QPushButton("Generate Nodes")
         self.nodes.setCheckable(True)
         self.nodes.setChecked(True)
-        misc_layout.addWidget(QLabel("Generate nodes from edges? (Skip if already completed):"), 0, 0)
-        misc_layout.addWidget(self.nodes, 0, 1)
+        misc_layout.addWidget(QLabel("Generate nodes from edges? (Skip if already completed):"), 1, 0)
+        misc_layout.addWidget(self.nodes, 1, 1)
         
         # GPU checkbox
         self.GPU = QPushButton("GPU")
         self.GPU.setCheckable(True)
         self.GPU.setChecked(False)
-        misc_layout.addWidget(QLabel("Use GPU (May downsample large images):"), 1, 0)
-        misc_layout.addWidget(self.GPU, 1, 1)
+        misc_layout.addWidget(QLabel("Use GPU (May downsample large images):"), 2, 0)
+        misc_layout.addWidget(self.GPU, 2, 1)
         
         misc_group.setLayout(misc_layout)
         main_layout.addWidget(misc_group)
@@ -14238,6 +14395,7 @@ class BranchDialog(QDialog):
             fix3 = self.fix3.isChecked()
             fix_val = float(self.fix_val.text()) if self.fix_val.text() else None
             seed = int(self.seed.text()) if self.seed.text() else None
+            compute = self.compute.isChecked()
 
             if my_network.edges is None and my_network.nodes is not None:
                 self.parent().load_channel(1, my_network.nodes, data = True)
@@ -14254,7 +14412,7 @@ class BranchDialog(QDialog):
 
             if my_network.edges is not None and my_network.nodes is not None and my_network.id_overlay is not None:
 
-                output = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = original_array, GPU = GPU, down_factor = down_factor, arrayshape = original_shape)
+                output, verts, skeleton, endpoints = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = original_array, GPU = GPU, down_factor = down_factor, arrayshape = original_shape, compute = compute, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale)
 
                 if fix2:
 
@@ -14293,6 +14451,19 @@ class BranchDialog(QDialog):
 
                     output = self.parent().separate_nontouching_objects(output, max_val=np.max(output))
 
+                if compute:
+                    labeled_image = (skeleton != 0) * output
+                    len_dict, tortuosity_dict, angle_dict = n3d.compute_optional_branchstats(verts, labeled_image, endpoints, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale)
+                    self.parent().branch_dict[1] = [len_dict, tortuosity_dict]
+                    #max_length = max(len(v) for v in angle_dict.values())
+                    #title = [str(i+1) if i < 2 else i+1 for i in range(max_length)]
+
+                    #del labeled_image
+
+                    self.parent().format_for_upperright_table(len_dict, 'BranchID', 'Length (Scaled)', 'Branch Lengths')
+                    self.parent().format_for_upperright_table(tortuosity_dict, 'BranchID', 'Tortuosity', 'Branch Tortuosities')
+                    #self.parent().format_for_upperright_table(angle_dict, 'Vertex ID', title, 'Branch Angles')
+
 
                 if down_factor is not None:
 

{nettracer3d-1.1.1 → nettracer3d-1.1.3}/src/nettracer3d/node_draw.py

@@ -3,7 +3,7 @@ import tifffile
 from scipy import ndimage
 from PIL import Image, ImageDraw, ImageFont
 from scipy.ndimage import zoom
-
+import cv2
 
 def downsample(data, factor, directory=None, order=0):
     """
@@ -121,83 +121,62 @@ def draw_nodes(nodes, num_nodes):
     # Save the draw_array as a 3D TIFF file
     tifffile.imwrite("labelled_nodes.tif", draw_array)
 
-def draw_from_centroids(nodes, num_nodes, centroids, twod_bool, directory = None):
-    """Presumes a centroid dictionary has been obtained"""
-    print("Drawing node IDs. (Must find all centroids. Network lattice itself may be drawn from network_draw script with fewer centroids)")
-    # Create a new 3D array to draw on with the same dimensions as the original array
+def draw_from_centroids(nodes, num_nodes, centroids, twod_bool, directory=None):
+    """Optimized version using OpenCV"""
+    print("Drawing node IDs...")
     draw_array = np.zeros_like(nodes, dtype=np.uint8)
-
-    # Use the default font from ImageFont
-
-    # Iterate through each centroid
+    
+    # Draw text using OpenCV (no PIL conversions needed)
     for idx in centroids.keys():
         centroid = centroids[idx]
         z, y, x = centroid.astype(int)
-
-        try:
-            draw_array = _draw_at_plane(z, y, x, draw_array, idx)
-        except IndexError:
-            pass
-
-        try:
-            draw_array = _draw_at_plane(z + 1, y, x, draw_array, idx)
-        except IndexError:
-            pass
-
-        try:
-            draw_array = _draw_at_plane(z - 1, y, x, draw_array, idx)
-        except IndexError:
-            pass
-
+        
+        for z_offset in [0, 1, -1]:
+            z_target = z + z_offset
+            if 0 <= z_target < draw_array.shape[0]:
+                cv2.putText(draw_array[z_target], str(idx), (x, y), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 0.4, 255, 1, cv2.LINE_AA)
+    
     if twod_bool:
         draw_array = draw_array[0,:,:] | draw_array[1,:,:]
-
-
-    if directory is None:
-        filename = 'labelled_node_indices.tif'
-    else:
-        filename = f'{directory}/labelled_node_indices.tif'
-
+    
+    filename = f'{directory}/labelled_node_indices.tif' if directory else 'labelled_node_indices.tif'
     try:
-
-        # Save the draw_array as a 3D TIFF file
         tifffile.imwrite(filename, draw_array)
-
     except Exception as e:
         print(f"Could not save node indices to {filename}")
-
+    
     return draw_array
 
 def degree_draw(degree_dict, centroid_dict, nodes):
+    """Draw node degrees at centroid locations using OpenCV"""
     # Create a new 3D array to draw on with the same dimensions as the original array
     draw_array = np.zeros_like(nodes, dtype=np.uint8)
-    #font_size = 24
-
+    
     for node in centroid_dict:
-
-        try:
-            degree = degree_dict[node]
-        except:
+        # Skip if node not in degree_dict
+        if node not in degree_dict:
             continue
             
+        degree = degree_dict[node]
         z, y, x = centroid_dict[node].astype(int)
-
-        try:
-            draw_array = _draw_at_plane(z, y, x, draw_array, degree)
-        except IndexError:
-            pass
-
-        try:
-            draw_array = _draw_at_plane(z + 1, y, x, draw_array, degree)
-        except IndexError:
-            pass
-
-        try:
-            draw_array = _draw_at_plane(z - 1, y, x, draw_array, degree)
-        except IndexError:
-            pass
-
-
+        
+        # Draw on current z-plane and adjacent planes
+        for z_offset in [0, 1, -1]:
+            z_target = z + z_offset
+            # Check bounds
+            if 0 <= z_target < draw_array.shape[0]:
+                cv2.putText(
+                    draw_array[z_target],  # Image to draw on
+                    str(degree),            # Text to draw
+                    (x, y),                 # Position (x, y)
+                    cv2.FONT_HERSHEY_SIMPLEX,  # Font
+                    0.4,                    # Font scale
+                    255,                    # Color (white)
+                    1,                      # Thickness
+                    cv2.LINE_AA             # Anti-aliasing
+                )
+    
     return draw_array
 
 def degree_infect(degree_dict, nodes, make_floats = False):

{nettracer3d-1.1.1 → nettracer3d-1.1.3/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 1.1.1
+Version: 1.1.3
 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/
@@ -110,6 +110,6 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 1.1.1 Updates --
+-- Version 1.1.3 Updates --
 
-	* Can now intermittently downsample while making the network and id overlays now to make their relevant elements larger in the actual rendered output.
+	* Some minor text adjustments