nettracer3d 0.7.9__py3-none-any.whl → 0.8.1__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -30,6 +30,9 @@ try:
 except:
     pass
 from nettracer3d import excelotron
+import threading
+import queue
+from threading import Lock
 
 
 
@@ -44,6 +47,7 @@ class ImageViewerWindow(QMainWindow):
         self.channel_visible = [False] * 4
         self.current_slice = 0
         self.active_channel = 0  # Initialize active channel
+        self.node_name = "Root_Nodes"
 
         self.color_dictionary = {
         # Reds
@@ -108,6 +112,9 @@ class ImageViewerWindow(QMainWindow):
         self.selection_rect = None
         self.click_start_time = None  # Add this to track when click started
         self.selection_threshold = 1.0  # Time in seconds before starting rectangle selection
+        self.background = None
+        self.last_update_time = 0
+        self.update_interval = 0.016  # 60 FPS
         
         # Initialize zoom mode state
         self.zoom_mode = False
@@ -119,6 +126,15 @@ class ImageViewerWindow(QMainWindow):
         self.pan_mode = False
         self.panning = False
         self.pan_start = None
+        self.img_width = None
+        self.img_height = None
+        self.pre_pan_channel_state = None  # Store which channels were visible before pan
+        self.pan_background = None         # Store the static background image during pan
+        self.is_pan_preview = False        # Track if we're in pan preview mode
+        self.pre_pan_channel_state = None    # Store which channels were visible before pan
+        self.pan_background_image = None     # Store the rendered composite image
+        self.pan_zoom_state = None           # Store zoom state when pan began
+        self.is_pan_preview = False          # Track if we're in pan preview mode
 
         #For ML segmenting mode
         self.brush_mode = False
@@ -157,7 +173,9 @@ class ImageViewerWindow(QMainWindow):
 
         self.radii_dict = {
             0: None,
-            1: None
+            1: None,
+            2: None,
+            3: None
         }
 
         self.original_shape = None #For undoing resamples
@@ -423,6 +441,25 @@ class ImageViewerWindow(QMainWindow):
         self.excel_manager.data_received.connect(self.handle_excel_data)
         self.prev_coms = None
 
+        self.paint_timer = QTimer()
+        self.paint_timer.timeout.connect(self.flush_paint_updates)
+        self.paint_timer.setSingleShot(True)
+        self.pending_paint_update = False
+        
+        # Threading for paint operations
+        self.paint_queue = queue.Queue()
+        self.paint_lock = Lock()
+        self.paint_worker = threading.Thread(target=self.paint_worker_loop, daemon=True)
+        self.paint_worker.start()
+        
+        # Background caching for blitting
+        self.paint_background = None
+        self.paint_session_active = False
+        
+        # Batch paint operations
+        self.paint_batch = []
+        self.last_paint_pos = None
+
     def start_left_scroll(self):
         """Start scrolling left when left arrow is pressed."""
         # Single increment first
@@ -794,6 +831,9 @@ class ImageViewerWindow(QMainWindow):
             try:
                 # Create context menu
                 context_menu = QMenu(self)
+
+                find = context_menu.addAction("Find Node/Edge")
+                find.triggered.connect(self.handle_find)
                 
                 # Create "Show Neighbors" submenu
                 neighbors_menu = QMenu("Show Neighbors", self)
@@ -1450,6 +1490,109 @@ class ImageViewerWindow(QMainWindow):
         except Exception as e:
             print(f"Error showing identities: {e}")
 
+    def handle_find(self):
+
+        class FindDialog(QDialog):
+            def __init__(self, parent=None):
+                super().__init__(parent)
+                self.setWindowTitle("Find Node (or edge?)")
+                self.setModal(True)
+                
+                layout = QFormLayout(self)
+
+                self.targ = QLineEdit("")
+                layout.addRow("Node/Edge ID:", self.targ)
+
+                run_button = QPushButton("Enter")
+                run_button.clicked.connect(self.run)
+                layout.addWidget(run_button)
+
+            def run(self):
+
+                try:
+
+                    value = int(self.targ.text()) if self.targ.text().strip() else None
+
+                    if value is None:
+                        return
+
+                    if self.parent().active_channel == 1:
+
+                        mode = 'edges'
+
+                        if my_network.edge_centroids is None:
+                            self.parent().show_centroid_dialog()
+
+                        num = (self.parent().channel_data[1].shape[0] * self.parent().channel_data[1].shape[1] * self.parent().channel_data[1].shape[2])
+
+                        if value in my_network.edge_centroids:
+
+                            # Get centroid coordinates (Z, Y, X)
+                            centroid = my_network.edge_centroids[value]
+                            # Set the active channel to edges (1)
+                            self.parent().set_active_channel(1)
+                            # Toggle on the edges channel if it's not already visible
+                            if not self.parent().channel_visible[1]:
+                                self.parent().channel_buttons[1].setChecked(True)
+                                self.parent().toggle_channel(1)
+                            # Navigate to the Z-slice
+                            self.parent().slice_slider.setValue(int(centroid[0]))
+                            print(f"Found edge {value} at Z-slice {centroid[0]}")
+
+                        else:
+                            print(f"Edge {value} not found in centroids dictionary")
+
+
+                    else:
+
+                        mode = 'nodes'
+
+                        if my_network.node_centroids is None:
+                            self.parent().show_centroid_dialog()
+
+                        num = (self.parent().channel_data[0].shape[0] * self.parent().channel_data[0].shape[1] * self.parent().channel_data[0].shape[2])
+
+                        if value in my_network.node_centroids:
+                            # Get centroid coordinates (Z, Y, X)
+                            centroid = my_network.node_centroids[value]
+                            # Set the active channel to nodes (0)
+                            self.parent().set_active_channel(0)
+                            # Toggle on the nodes channel if it's not already visible
+                            if not self.parent().channel_visible[0]:
+                                self.parent().channel_buttons[0].setChecked(True)
+                                self.parent().toggle_channel(0)
+                            # Navigate to the Z-slice
+                            self.parent().slice_slider.setValue(int(centroid[0]))
+                            print(f"Found node {value} at Z-slice {centroid[0]}")
+                            
+                        else:
+                            print(f"Node {value} not found in centroids dictionary")
+
+                    self.parent().clicked_values[mode] = [value]
+
+                    if num > self.parent().mini_thresh:
+                        self.parent().mini_overlay = True
+                        self.parent().create_mini_overlay(node_indices = self.parent().clicked_values['nodes'], edge_indices = self.parent().clicked_values['edges'])
+                    else:
+                        self.parent().create_highlight_overlay(
+                            node_indices=self.parent().clicked_values['nodes'], 
+                            edge_indices=self.parent().clicked_values['edges']
+                        )
+
+
+                    
+                    # Close the dialog after processing
+                    self.accept()
+
+                except Exception as e:
+
+                    print(f"Error: {e}")
+                
+        dialog = FindDialog(self)
+        dialog.exec()
+
+
+
 
     def handle_select_all(self, nodes = True, edges = False):
 
@@ -1630,63 +1773,32 @@ class ImageViewerWindow(QMainWindow):
         except Exception as e:
             print(f"An error has occured: {e}")
 
-    def handle_seperate(self):
+    def separate_nontouching_objects(self, input_array, max_val=0):
+        """
+        optimized version using advanced indexing.
+        """
+
+        print("Splitting nontouching objects")
+
+        binary_mask = input_array > 0
+        labeled_array, _ = n3d.label_objects(binary_mask)
+        
+        # Create a compound key for each (original_label, connected_component) pair
+        # This avoids the need for explicit mapping
+        mask = binary_mask
+        compound_key = input_array[mask] * (labeled_array.max() + 1) + labeled_array[mask]
+        
+        # Get unique compound keys and create new labels
+        unique_keys, inverse_indices = np.unique(compound_key, return_inverse=True)
+        new_labels = np.arange(max_val + 1, max_val + 1 + len(unique_keys))
+        
+        # Create output array
+        output_array = np.zeros_like(input_array)
+        output_array[mask] = new_labels[inverse_indices]
+        
+        return output_array
 
-        import scipy.ndimage as ndi
-        from scipy.sparse import csr_matrix
-
-        print("Note, this method is a tad slow...")
-
-        def separate_nontouching_objects(input_array, max_val = 0):
-            """
-            Efficiently separate non-touching objects in a labeled array.
-            
-            Parameters:
-            -----------
-            input_array : numpy.ndarray
-                Input labeled array where each object has a unique label value > 0
-                
-            Returns:
-            --------
-            output_array : numpy.ndarray
-                Array with new labels where non-touching components have different labels
-            """
-            # Step 1: Perform connected component labeling on the entire binary mask
-            binary_mask = input_array > 0
-            structure = np.ones((3,) * input_array.ndim, dtype=bool)  # 3x3x3 connectivity for 3D or 3x3 for 2D
-            labeled_array, num_features = ndi.label(binary_mask, structure=structure)
-            
-            # Step 2: Map the original labels to the new connected components
-            # Create a sparse matrix to efficiently store label mappings
-            coords = np.nonzero(input_array)
-            original_values = input_array[coords]
-            new_labels = labeled_array[coords]
-            
-            # Create a mapping of (original_label, new_connected_component) pairs
-            label_mapping = {}
-            for orig, new in zip(original_values, new_labels):
-                if orig not in label_mapping:
-                    label_mapping[orig] = []
-                if new not in label_mapping[orig]:
-                    label_mapping[orig].append(new)
-            
-            # Step 3: Create a new output array with unique labels for each connected component
-            output_array = np.zeros_like(input_array)
-            next_label = 1 + max_val
-            
-            # Map of (original_label, connected_component) -> new_unique_label
-            unique_label_map = {}
-            
-            for orig_label, cc_list in label_mapping.items():
-                for cc in cc_list:
-                    unique_label_map[(orig_label, cc)] = next_label
-                    # Create a mask for this original label and connected component
-                    mask = (input_array == orig_label) & (labeled_array == cc)
-                    # Assign the new unique label
-                    output_array[mask] = next_label
-                    next_label += 1
-            
-            return output_array
+    def handle_seperate(self):
 
         try:
             # Handle nodes
@@ -1708,7 +1820,7 @@ class ImageViewerWindow(QMainWindow):
                     max_val = np.max(non_highlighted)
                 
                 # Process highlighted part
-                processed_highlights = separate_nontouching_objects(highlighted_nodes, max_val)
+                processed_highlights = self.separate_nontouching_objects(highlighted_nodes, max_val)
                 
                 # Combine back with non-highlighted parts
                 my_network.nodes = non_highlighted + processed_highlights
@@ -1729,13 +1841,13 @@ class ImageViewerWindow(QMainWindow):
                 # Get non-highlighted part of the array
                 non_highlighted = my_network.edges * (~self.highlight_overlay)
 
-                if (highlighted_nodes==non_highlighted).all():
+                if (highlighted_edges==non_highlighted).all():
                     max_val = 0
                 else:
                     max_val = np.max(non_highlighted)
                 
                 # Process highlighted part
-                processed_highlights = separate_nontouching_objects(highlighted_edges, max_val)
+                processed_highlights = self.separate_nontouching_objects(highlighted_edges, max_val)
                 
                 # Combine back with non-highlighted parts
                 my_network.edges = non_highlighted + processed_highlights
@@ -2074,8 +2186,11 @@ class ImageViewerWindow(QMainWindow):
             
             self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
+
     def keyPressEvent(self, event):
 
+        """Key press shortcuts for main class"""
+
         if event.key() == Qt.Key_Z and event.modifiers() & Qt.ControlModifier:
             try:
                 self.load_channel(self.last_change[1], self.last_change[0], True)
@@ -2091,6 +2206,8 @@ class ImageViewerWindow(QMainWindow):
                 self.machine_window.switch_foreground()
         if event.key() == Qt.Key_X:
             self.high_button.click()
+        if event.key() == Qt.Key_F and event.modifiers() == Qt.ShiftModifier:
+            self.handle_find()
         if self.brush_mode and self.machine_window is None:
             if event.key() == Qt.Key_F:
                 self.toggle_can()
@@ -2098,6 +2215,7 @@ class ImageViewerWindow(QMainWindow):
                 self.toggle_threed()
 
 
+
     def update_brush_cursor(self):
         """Update the cursor to show brush size"""
         if not self.brush_mode:
@@ -2158,7 +2276,7 @@ class ImageViewerWindow(QMainWindow):
         painter.end()
 
     def get_line_points(self, x0, y0, x1, y1):
-        """Get all points in a line between (x0,y0) and (x1,y1) using Bresenham's algorithm"""
+        """Get all points in a line between (x0,y0) and (x1,y1) using Bresenham's algorithm."""
         points = []
         dx = abs(x1 - x0)
         dy = abs(y1 - y0)
@@ -2211,7 +2329,7 @@ class ImageViewerWindow(QMainWindow):
         return data_coords[0], data_coords[1]
 
     def on_mouse_press(self, event):
-        """Handle mouse press events."""
+        """Handle mouse press events - OPTIMIZED VERSION."""
         if event.inaxes != self.ax:
             return
 
@@ -2249,7 +2367,6 @@ class ImageViewerWindow(QMainWindow):
                 new_xlim = [xdata - x_range, xdata + x_range]
                 new_ylim = [ydata - y_range, ydata + y_range]
                 
-                
                 if (new_xlim[0] <= self.original_xlim[0] or 
                     new_xlim[1] >= self.original_xlim[1] or
                     new_ylim[0] <= self.original_ylim[0] or
@@ -2271,22 +2388,31 @@ class ImageViewerWindow(QMainWindow):
             self.panning = True
             self.pan_start = (event.xdata, event.ydata)
             self.canvas.setCursor(Qt.CursorShape.ClosedHandCursor)
+            
+            # Store current channel visibility state
+            self.pre_pan_channel_state = self.channel_visible.copy()
+            
+            # Create static background from currently visible channels
+            self.create_pan_background()
+            
+            # Hide all channels and show only the background
+            self.channel_visible = [False] * 4
+            self.is_pan_preview = True
+            
+            # Update display to show only background
+            self.update_display_pan_mode()
 
         elif self.brush_mode:
             if event.inaxes != self.ax:
                 return
             
-
             if event.button == 1 or event.button == 3:
-
                 x, y = int(event.xdata), int(event.ydata)
 
-
                 if event.button == 1 and self.can:
                     self.handle_can(x, y)
                     return
 
-
                 if event.button == 3:
                     self.erase = True
                 else:
@@ -2300,27 +2426,24 @@ class ImageViewerWindow(QMainWindow):
                 else:
                     channel = 2
 
-                # Paint at initial position
-                self.paint_at_position(x, y, self.erase, channel)
-                
+                # Get current zoom to preserve it
                 current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
                 current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
 
-            
+                # Paint at initial position
+                self.paint_at_position(x, y, self.erase, channel)
+                                
                 self.canvas.draw()
-                #self.update_display(preserve_zoom=(current_xlim, current_ylim))
-                self.restore_channels = []
 
+                self.restore_channels = []
+                if not self.channel_visible[channel]:
+                    self.channel_visible[channel] = True
 
-                for i in range(4):
-                    if i == channel:
-                        self.channel_visible[i] = True
-                    elif self.channel_data[i] is not None and self.channel_visible[i] == True:
-                        self.channel_visible[i] = False
-                        self.restore_channels.append(i)
-                self.update_display(preserve_zoom = (current_xlim, current_ylim), begin_paint = True)
-                self.update_display_slice(channel, preserve_zoom=(current_xlim, current_ylim))
-
+                # No need to hide other channels or track restore_channels
+                self.restore_channels = []
+                        
+                self.update_display(preserve_zoom=(current_xlim, current_ylim), begin_paint=True)
+                self.update_display_slice_optimized(channel, preserve_zoom=(current_xlim, current_ylim))
         
         elif event.button == 3:  # Right click (for context menu)
             self.create_context_menu(event)
@@ -2334,7 +2457,7 @@ class ImageViewerWindow(QMainWindow):
         """Paint pixels within brush radius at given position"""
         if self.channel_data[channel] is None:
             return
-            
+
         if erase:
             val = 0
         elif self.machine_window is None:
@@ -2343,26 +2466,74 @@ class ImageViewerWindow(QMainWindow):
             val = 1
         else:
             val = 2
-
         height, width = self.channel_data[channel][self.current_slice].shape
         radius = self.brush_size // 2
-        
+
         # Calculate brush area
         for y in range(max(0, center_y - radius), min(height, center_y + radius + 1)):
             for x in range(max(0, center_x - radius), min(width, center_x + radius + 1)):
                 # Check if point is within circular brush area
-                if (x - center_x) ** 2 + (y - center_y) ** 2 <= radius ** 2:
-
+                if (x - center_x) * 2 + (y - center_y) * 2 <= radius ** 2:
                     if self.threed and self.threedthresh > 1:
                         amount = (self.threedthresh - 1) / 2
                         low = max(0, self.current_slice - amount)
                         high = min(self.channel_data[channel].shape[0] - 1, self.current_slice + amount)
-
                         for i in range(int(low), int(high + 1)):
                             self.channel_data[channel][i][y, x] = val
                     else:
                         self.channel_data[channel][self.current_slice][y, x] = val
 
+    def paint_at_position_vectorized(self, center_x, center_y, erase=False, channel=2, 
+                                   slice_idx=None, brush_size=None, threed=False, 
+                                   threedthresh=1, foreground=True, machine_window=None):
+        """Vectorized paint operation for better performance."""
+        if self.channel_data[channel] is None:
+            return
+        
+        # Use provided parameters or fall back to instance variables
+        slice_idx = slice_idx if slice_idx is not None else self.current_slice
+        brush_size = brush_size if brush_size is not None else getattr(self, 'brush_size', 5)
+        
+        # Determine paint value
+        if erase:
+            val = 0
+        elif machine_window is None:
+            val = 255
+        elif foreground:
+            val = 1
+        else:
+            val = 2
+        
+        height, width = self.channel_data[channel][slice_idx].shape
+        radius = brush_size // 2
+        
+        # Calculate affected region bounds
+        y_min = max(0, center_y - radius)
+        y_max = min(height, center_y + radius + 1)
+        x_min = max(0, center_x - radius)
+        x_max = min(width, center_x + radius + 1)
+        
+        if y_min >= y_max or x_min >= x_max:
+            return  # No valid region to paint
+        
+        # Create coordinate grids for the affected region
+        y_coords, x_coords = np.mgrid[y_min:y_max, x_min:x_max]
+        
+        # Calculate distances squared (avoid sqrt for performance)
+        distances_sq = (x_coords - center_x) ** 2 + (y_coords - center_y) ** 2
+        mask = distances_sq <= radius ** 2
+        
+        # Apply paint to affected slices
+        if threed and threedthresh > 1:
+            amount = (threedthresh - 1) / 2
+            low = max(0, int(slice_idx - amount))
+            high = min(self.channel_data[channel].shape[0] - 1, int(slice_idx + amount))
+            
+            for i in range(low, high + 1):
+                self.channel_data[channel][i][y_min:y_max, x_min:x_max][mask] = val
+        else:
+            self.channel_data[channel][slice_idx][y_min:y_max, x_min:x_max][mask] = val
+
     def handle_can(self, x, y):
 
 
@@ -2425,33 +2596,42 @@ class ImageViewerWindow(QMainWindow):
 
 
     def on_mouse_move(self, event):
-        """Handle mouse movement events."""
-        if event.inaxes != self.ax:
+        if not event.inaxes or event.xdata is None or event.ydata is None:
             return
-                
+            
+        current_time = time.time()
+        
         if self.selection_start and not self.selecting and not self.pan_mode and not self.zoom_mode and not self.brush_mode:
-            # If mouse has moved more than a tiny amount while button is held, start selection
             if (abs(event.xdata - self.selection_start[0]) > 1 or 
                 abs(event.ydata - self.selection_start[1]) > 1):
                 self.selecting = True
+                self.background = self.canvas.copy_from_bbox(self.ax.bbox)
+                
                 self.selection_rect = plt.Rectangle(
                     (self.selection_start[0], self.selection_start[1]), 0, 0,
-                    fill=False, color='white', linestyle='--'
+                    fill=False, color='white', linestyle='--', animated=True
                 )
                 self.ax.add_patch(self.selection_rect)
                 
         if self.selecting and self.selection_rect is not None:
-            # Update selection rectangle
-            x0 = min(self.selection_start[0], event.xdata)
-            y0 = min(self.selection_start[1], event.ydata)
+            # Throttle updates
+            if current_time - self.last_update_time < self.update_interval:
+                return
+            self.last_update_time = current_time
+            
+            # Use blitting
+            self.canvas.restore_region(self.background)
+            
+            x_min = min(self.selection_start[0], event.xdata)
+            y_min = min(self.selection_start[1], event.ydata)
             width = abs(event.xdata - self.selection_start[0])
             height = abs(event.ydata - self.selection_start[1])
             
-            self.selection_rect.set_bounds(x0, y0, width, height)
-            self.canvas.draw()
+            self.selection_rect.set_bounds(x_min, y_min, width, height)
+            self.ax.draw_artist(self.selection_rect)
+            self.canvas.blit(self.ax.bbox)
 
         elif self.panning and self.pan_start is not None:
-
             # Calculate the movement
             dx = event.xdata - self.pan_start[0]
             dy = event.ydata - self.pan_start[1]
@@ -2464,25 +2644,23 @@ class ImageViewerWindow(QMainWindow):
             new_xlim = [xlim[0] - dx, xlim[1] - dx]
             new_ylim = [ylim[0] - dy, ylim[1] - dy]
             
-            # Get image bounds
-            if self.channel_data[0] is not None:  # Use first channel as reference
-                img_height, img_width = self.channel_data[0][self.current_slice].shape
-                
+            # Get image bounds using cached dimensions
+            if self.img_width is not None:  # Changed from self.channel_data[0] check
                 # Ensure new limits don't go beyond image bounds
                 if new_xlim[0] < 0:
                     new_xlim = [0, xlim[1] - xlim[0]]
-                elif new_xlim[1] > img_width:
-                    new_xlim = [img_width - (xlim[1] - xlim[0]), img_width]
+                elif new_xlim[1] > self.img_width:  # Changed from img_width variable lookup
+                    new_xlim = [self.img_width - (xlim[1] - xlim[0]), self.img_width]
                     
                 if new_ylim[0] < 0:
                     new_ylim = [0, ylim[1] - ylim[0]]
-                elif new_ylim[1] > img_height:
-                    new_ylim = [img_height - (ylim[1] - ylim[0]), img_height]
+                elif new_ylim[1] > self.img_height:  # Changed from img_height variable lookup
+                    new_ylim = [self.img_height - (ylim[1] - ylim[0]), self.img_height]
             
             # Apply new limits
             self.ax.set_xlim(new_xlim)
             self.ax.set_ylim(new_ylim)
-            self.canvas.draw()
+            self.canvas.draw_idle()  # Changed from draw() to draw_idle()
             
             # Update pan start position
             self.pan_start = (event.xdata, event.ydata)
@@ -2490,43 +2668,365 @@ class ImageViewerWindow(QMainWindow):
         elif self.painting and self.brush_mode:
             if event.inaxes != self.ax:
                 return
-                
-            x, y = int(event.xdata), int(event.ydata)
+            
+            # OPTIMIZED: Queue paint operation instead of immediate execution
+            self.queue_paint_operation(event)
+            
+            # OPTIMIZED: Schedule display update at controlled frequency
+            if not self.pending_paint_update:
+                self.pending_paint_update = True
+                self.paint_timer.start(16)  # ~60fps max update rate
 
-            if self.pen_button.isChecked():
-                channel = self.active_channel
-            else:
-                channel = 2
+    def queue_paint_operation(self, event):
+        """Queue a paint operation for background processing."""
+        x, y = int(event.xdata), int(event.ydata)
+
+        if self.pen_button.isChecked():
+            channel = self.active_channel
+        else:
+            channel = 2
+
+        if self.channel_data[channel] is not None:
+            # Prepare paint session if needed
+            if not self.paint_session_active:
+                self.prepare_paint_session(channel)
+            
+            # Create paint operation
+            paint_op = {
+                'type': 'stroke',
+                'x': x,
+                'y': y,
+                'last_pos': getattr(self, 'last_paint_pos', None),
+                'brush_size': self.brush_size,
+                'erase': self.erase,
+                'channel': channel,
+                'slice': self.current_slice,
+                'threed': getattr(self, 'threed', False),
+                'threedthresh': getattr(self, 'threedthresh', 1),
+                'foreground': getattr(self, 'foreground', True),
+                'machine_window': getattr(self, 'machine_window', None)
+            }
+            
+            # Queue the operation
+            try:
+                self.paint_queue.put_nowait(paint_op)
+            except queue.Full:
+                pass  # Skip if queue is full to avoid blocking
+            
+            self.last_paint_pos = (x, y)
 
+    def prepare_paint_session(self, channel):
+        """Prepare optimized background for blitting during paint session."""
+        if self.paint_session_active:
+            return
             
-            if self.channel_data[channel] is not None:
-                current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
-                current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
-                height, width = self.channel_data[channel][self.current_slice].shape
+        # IMPORTANT: Don't capture background here - let the main display update handle it
+        # We'll capture the background after the proper channel visibility setup
+        self.paint_session_active = True
+
+    def end_paint_session(self):
+        """Clean up after paint session."""
+        self.paint_session_active = False
+        self.paint_background = None
+        self.last_paint_pos = None
+
+    def paint_worker_loop(self):
+        """Background thread for processing paint operations."""
+        while True:
+            try:
+                paint_op = self.paint_queue.get(timeout=1.0)
+                if paint_op is None:  # Shutdown signal
+                    break
                 
-                if hasattr(self, 'last_paint_pos'):
-                    last_x, last_y = self.last_paint_pos
-                    points = self.get_line_points(last_x, last_y, x, y)
+                with self.paint_lock:
+                    self.execute_paint_operation(paint_op)
                     
-                    # Paint at each point along the line
+            except queue.Empty:
+                continue
+
+    def shutdown(self):
+        """Clean shutdown of worker thread."""
+        self.paint_queue.put(None)  # Signal worker to stop
+        if hasattr(self, 'paint_worker'):
+            self.paint_worker.join(timeout=1.0)
+
+    def execute_paint_operation(self, paint_op):
+        """Execute a single paint operation on the data arrays."""
+        if paint_op['type'] == 'stroke':
+            channel = paint_op['channel']
+            x, y = paint_op['x'], paint_op['y']
+            last_pos = paint_op['last_pos']
+            
+            if last_pos is not None:
+                # Paint line from last position to current
+                points = self.get_line_points(last_pos[0], last_pos[1], x, y)
+                for px, py in points:
+                    height, width = self.channel_data[channel][paint_op['slice']].shape
+                    if 0 <= px < width and 0 <= py < height:
+                        self.paint_at_position_vectorized(
+                            px, py, paint_op['erase'], paint_op['channel'],
+                            paint_op['slice'], paint_op['brush_size'],
+                            paint_op['threed'], paint_op['threedthresh'],
+                            paint_op['foreground'], paint_op['machine_window']
+                        )
+            else:
+                # Single point paint
+                height, width = self.channel_data[channel][paint_op['slice']].shape
+                if 0 <= x < width and 0 <= y < height:
+                    self.paint_at_position_vectorized(
+                        x, y, paint_op['erase'], paint_op['channel'],
+                        paint_op['slice'], paint_op['brush_size'],
+                        paint_op['threed'], paint_op['threedthresh'],
+                        paint_op['foreground'], paint_op['machine_window']
+                    )
 
-                    for px, py in points:
-                        if 0 <= px < width and 0 <= py < height:
-                            self.paint_at_position(px, py, self.erase, channel)
+    def flush_paint_updates(self):
+        """Update the display with batched paint changes."""
+        self.pending_paint_update = False
+        
+        # Determine which channel to update
+        channel = self.active_channel if hasattr(self, 'pen_button') and self.pen_button.isChecked() else 2
+        
+        # Get current zoom to preserve it
+        current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
+        current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
+        
+        # Update display
+        self.update_display_slice_optimized(channel, preserve_zoom=(current_xlim, current_ylim))
+
+    def create_pan_background(self):
+        """Create a static background image from currently visible channels with proper rendering"""
+        # Store current zoom state
+        current_xlim = self.ax.get_xlim()
+        current_ylim = self.ax.get_ylim()
+        
+        # Render all visible channels with proper colors/brightness into a single composite
+        self.pan_background_image = self.create_composite_for_pan()
+        self.pan_zoom_state = (current_xlim, current_ylim)
+
+    def create_composite_for_pan(self):
+        """Create a properly rendered composite image for panning"""
+        # Get active channels and dimensions (copied from update_display)
+        active_channels = [i for i in range(4) if self.channel_data[i] is not None]
+        if active_channels:
+            dims = [(self.channel_data[i].shape[1:3] if len(self.channel_data[i].shape) >= 3 else 
+                    self.channel_data[i].shape) for i in active_channels]
+            min_height = min(d[0] for d in dims)
+            min_width = min(d[1] for d in dims)
+        else:
+            return None
+        
+        # Create a blank RGBA composite to accumulate all channels
+        composite = np.zeros((min_height, min_width, 4), dtype=np.float32)
+        
+        # Process each visible channel exactly like update_display does
+        for channel in range(4):
+            if (self.channel_visible[channel] and 
+                self.channel_data[channel] is not None):
                 
-                self.last_paint_pos = (x, y)
+                # Get current slice data (same logic as update_display)
+                is_rgb = len(self.channel_data[channel].shape) == 4 and (self.channel_data[channel].shape[-1] == 3 or self.channel_data[channel].shape[-1] == 4)
                 
-                self.canvas.draw()
-                #self.update_display(preserve_zoom=(current_xlim, current_ylim))
-                self.update_display_slice(channel, preserve_zoom=(current_xlim, current_ylim))
+                if len(self.channel_data[channel].shape) == 3 and not is_rgb:
+                    current_image = self.channel_data[channel][self.current_slice, :, :]
+                elif is_rgb:
+                    current_image = self.channel_data[channel][self.current_slice]
+                else:
+                    current_image = self.channel_data[channel]
+
+                if is_rgb and self.channel_data[channel].shape[-1] == 3:
+                    # RGB image - convert to RGBA and blend
+                    rgb_alpha = np.ones((*current_image.shape[:2], 4), dtype=np.float32)
+                    rgb_alpha[:, :, :3] = current_image.astype(np.float32) / 255.0
+                    rgb_alpha[:, :, 3] = 0.7  # Same alpha as update_display
+                    composite = self.blend_layers(composite, rgb_alpha)
+                    
+                elif is_rgb and self.channel_data[channel].shape[-1] == 4:
+                    # RGBA image - blend directly
+                    rgba_image = current_image.astype(np.float32) / 255.0
+                    composite = self.blend_layers(composite, rgba_image)
+                    
+                else:
+                    # Regular channel processing (same logic as update_display)
+                    if self.min_max[channel][0] == None:
+                        self.min_max[channel][0] = np.min(current_image)
+                    if self.min_max[channel][1] == None:
+                        self.min_max[channel][1] = np.max(current_image)
+
+                    img_min = self.min_max[channel][0]
+                    img_max = self.min_max[channel][1]
+                    
+                    if img_min == img_max:
+                        vmin = img_min
+                        vmax = img_min + 1
+                    else:
+                        vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
+                        vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
+                    
+                    # Normalize the image
+                    if vmin == vmax:
+                        normalized_image = np.zeros_like(current_image)
+                    else:
+                        normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
+                    
+                    # Apply channel color and alpha
+                    if channel == 2 and self.machine_window is not None:
+                        # Special case for machine window channel 2
+                        channel_rgba = self.apply_machine_colormap(current_image)
+                    else:
+                        # Regular channel with custom color
+                        color = self.base_colors[channel]
+                        channel_rgba = np.zeros((*normalized_image.shape, 4), dtype=np.float32)
+                        channel_rgba[:, :, 0] = normalized_image * color[0]  # R
+                        channel_rgba[:, :, 1] = normalized_image * color[1]  # G  
+                        channel_rgba[:, :, 2] = normalized_image * color[2]  # B
+                        channel_rgba[:, :, 3] = normalized_image * 0.7       # A (same alpha as update_display)
+                    
+                    # Blend this channel into the composite
+                    composite = self.blend_layers(composite, channel_rgba)
+        
+        # Add highlight overlays if they exist (same logic as update_display)
+        if self.mini_overlay and self.highlight and self.machine_window is None:
+            highlight_rgba = self.create_highlight_rgba(self.mini_overlay_data, yellow=True)
+            composite = self.blend_layers(composite, highlight_rgba)
+        elif self.highlight_overlay is not None and self.highlight:
+            highlight_slice = self.highlight_overlay[self.current_slice]
+            if self.machine_window is None:
+                highlight_rgba = self.create_highlight_rgba(highlight_slice, yellow=True)
+            else:
+                highlight_rgba = self.create_highlight_rgba(highlight_slice, yellow=False)
+            composite = self.blend_layers(composite, highlight_rgba)
+        
+        # Convert to 0-255 range for display
+        return (composite * 255).astype(np.uint8)
+
+    def apply_machine_colormap(self, image):
+        """Apply the special machine window colormap for channel 2"""
+        rgba = np.zeros((*image.shape, 4), dtype=np.float32)
+        
+        # Transparent for 0
+        mask_0 = (image == 0)
+        rgba[mask_0] = [0, 0, 0, 0]
+        
+        # Light green for 1
+        mask_1 = (image == 1)
+        rgba[mask_1] = [0.5, 1, 0.5, 0.7]
+        
+        # Light red for 2
+        mask_2 = (image == 2)
+        rgba[mask_2] = [1, 0.5, 0.5, 0.7]
+        
+        return rgba
 
+    def create_highlight_rgba(self, highlight_data, yellow=True):
+        """Create RGBA highlight overlay"""
+        rgba = np.zeros((*highlight_data.shape, 4), dtype=np.float32)
+        
+        if yellow:
+            # Yellow highlight
+            mask = highlight_data > 0
+            rgba[mask] = [1, 1, 0, 0.5]  # Yellow with alpha 0.5
+        else:
+            # Multi-color highlight for machine window
+            mask_1 = (highlight_data == 1)
+            mask_2 = (highlight_data == 2)
+            rgba[mask_1] = [1, 1, 0, 0.5]      # Yellow for 1
+            rgba[mask_2] = [0, 0.7, 1, 0.5]    # Blue for 2
+        
+        return rgba
+
+    def blend_layers(self, base, overlay):
+        """Alpha blend two RGBA layers"""
+        # Standard alpha blending formula
+        alpha_overlay = overlay[:, :, 3:4]
+        alpha_base = base[:, :, 3:4]
+        
+        # Calculate output alpha
+        alpha_out = alpha_overlay + alpha_base * (1 - alpha_overlay)
+        
+        # Calculate output RGB
+        rgb_out = np.zeros_like(base[:, :, :3])
+        mask = alpha_out[:, :, 0] > 0
+        
+        rgb_out[mask] = (overlay[mask, :3] * alpha_overlay[mask] + 
+                         base[mask, :3] * alpha_base[mask] * (1 - alpha_overlay[mask])) / alpha_out[mask]
+        
+        # Combine RGB and alpha
+        result = np.zeros_like(base)
+        result[:, :, :3] = rgb_out
+        result[:, :, 3:4] = alpha_out
+        
+        return result
+
+    def update_display_pan_mode(self):
+        """Lightweight display update for pan preview mode"""
+        if self.is_pan_preview and self.pan_background_image is not None:
+            # Clear and setup axes
+            self.ax.clear()
+            self.ax.set_facecolor('black')
+            
+            # Get dimensions
+            height, width = self.pan_background_image.shape[:2]
+            
+            # Display the composite background with preserved zoom
+            self.ax.imshow(self.pan_background_image, 
+                          extent=(-0.5, width-0.5, height-0.5, -0.5),
+                          aspect='equal')
+            
+            # Restore the zoom state from when pan began
+            if hasattr(self, 'pan_zoom_state'):
+                self.ax.set_xlim(self.pan_zoom_state[0])
+                self.ax.set_ylim(self.pan_zoom_state[1])
+            
+            # Style the axes (same as update_display)
+            self.ax.set_xlabel('X')
+            self.ax.set_ylabel('Y') 
+            self.ax.set_title(f'Slice {self.current_slice}')
+            self.ax.xaxis.label.set_color('black')
+            self.ax.yaxis.label.set_color('black')
+            self.ax.title.set_color('black')
+            self.ax.tick_params(colors='black')
+            for spine in self.ax.spines.values():
+                spine.set_color('black')
+                
+            # Add measurement points if they exist (same as update_display)
+            for point in self.measurement_points:
+                x1, y1, z1 = point['point1']
+                x2, y2, z2 = point['point2']
+                pair_idx = point['pair_index']
+                
+                if z1 == self.current_slice:
+                    self.ax.plot(x1, y1, 'yo', markersize=8)
+                    self.ax.text(x1, y1+5, str(pair_idx), 
+                                color='white', ha='center', va='bottom')
+                if z2 == self.current_slice:
+                    self.ax.plot(x2, y2, 'yo', markersize=8)
+                    self.ax.text(x2, y2+5, str(pair_idx), 
+                                color='white', ha='center', va='bottom')
+                        
+                if z1 == z2 == self.current_slice:
+                    self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
+            
+            self.canvas.draw_idle()
 
     def on_mouse_release(self, event):
-        """Handle mouse release events."""
+        """Handle mouse release events - OPTIMIZED VERSION."""
         if self.pan_mode:
+            # Get current view limits before restoring channels
+            current_xlim = self.ax.get_xlim()
+            current_ylim = self.ax.get_ylim()
+            
             self.panning = False
             self.pan_start = None
             self.canvas.setCursor(Qt.CursorShape.OpenHandCursor)
+            
+            # Restore previously visible channels
+            self.channel_visible = self.pre_pan_channel_state.copy()
+            self.is_pan_preview = False
+            self.pan_background = None
+            
+            # Update display with preserved zoom at new position
+            self.update_display(preserve_zoom=(current_xlim, current_ylim))
         elif event.button == 1:  # Left button release
             if self.selecting and self.selection_rect is not None:
                 # Get the rectangle bounds
@@ -2585,18 +3085,15 @@ class ImageViewerWindow(QMainWindow):
                         # Try to highlight the last selected value in tables
                         if self.clicked_values['edges']:
                             self.highlight_value_in_tables(self.clicked_values['edges'][-1])
-
             
             elif not self.selecting and self.selection_start:  # If we had a click but never started selection
                 # Handle as a normal click
                 self.on_mouse_click(event)
-
             
-            # Clean up
+            # Clean up selection
             self.selection_start = None
             self.selecting = False
 
-
             if self.selection_rect is not None:
                 try:
                     self.selection_rect.remove()
@@ -2605,13 +3102,28 @@ class ImageViewerWindow(QMainWindow):
                 self.selection_rect = None
                 self.canvas.draw()
 
-        if self.brush_mode:
+        # OPTIMIZED: Handle brush mode cleanup with paint session management
+        if self.brush_mode and hasattr(self, 'painting') and self.painting:
             self.painting = False
+            
+            # Restore hidden channels
             try:
                 for i in self.restore_channels:
                     self.channel_visible[i] = True
+                self.restore_channels = []
             except:
                 pass
+            
+            # OPTIMIZED: End paint session and ensure all operations complete
+            self.end_paint_session()
+            
+            # OPTIMIZED: Stop timer and process any pending paint operations
+            if hasattr(self, 'paint_timer'):
+                self.paint_timer.stop()
+            if hasattr(self, 'pending_paint_update') and self.pending_paint_update:
+                self.flush_paint_updates()
+            
+            # Get current zoom and do final display update
             current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
             current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
             self.update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -2886,6 +3398,8 @@ class ImageViewerWindow(QMainWindow):
         load_action.triggered.connect(lambda: self.load_misc('Edge Centroids'))
         load_action = misc_menu.addAction("Merge Nodes")
         load_action.triggered.connect(lambda: self.load_misc('Merge Nodes'))
+        load_action = misc_menu.addAction("Merge Node IDs from Images")
+        load_action.triggered.connect(self.show_merge_node_id_dialog)
 
         
         # Analysis menu
@@ -2918,6 +3432,8 @@ class ImageViewerWindow(QMainWindow):
         ripley_action.triggered.connect(self.show_ripley_dialog)
         heatmap_action = stats_menu.addAction("Community Cluster Heatmap")
         heatmap_action.triggered.connect(self.show_heatmap_dialog)
+        nearneigh_action = stats_menu.addAction("Average Nearest Neighbors")
+        nearneigh_action.triggered.connect(self.show_nearneigh_dialog)
         vol_action = stats_menu.addAction("Calculate Volumes")
         vol_action.triggered.connect(self.volumes)
         rad_action = stats_menu.addAction("Calculate Radii")
@@ -3267,6 +3783,11 @@ class ImageViewerWindow(QMainWindow):
         except:
             pass
 
+    def show_merge_node_id_dialog(self):
+
+        dialog = MergeNodeIdDialog(self)
+        dialog.exec()
+
 
     def show_watershed_dialog(self):
         """Show the watershed parameter dialog."""
@@ -3585,7 +4106,7 @@ class ImageViewerWindow(QMainWindow):
                     f"Failed to load {sort}: {str(e)}"
                 )
 
-        else:
+        elif sort == 'Merge Nodes':
             try:
 
                 if len(np.unique(my_network.nodes)) < 3:
@@ -3623,7 +4144,7 @@ class ImageViewerWindow(QMainWindow):
                     if dialog.exec() == QFileDialog.DialogCode.Accepted:
                         selected_path = dialog.directory().absolutePath()
 
-                my_network.merge_nodes(selected_path)
+                my_network.merge_nodes(selected_path, root_id = self.node_name)
                 self.load_channel(0, my_network.nodes, True)
 
 
@@ -3641,6 +4162,7 @@ class ImageViewerWindow(QMainWindow):
                 )
 
 
+
     # Modify load_from_network_obj method
     def load_from_network_obj(self):
         try: 
@@ -3952,11 +4474,15 @@ class ImageViewerWindow(QMainWindow):
                     return
                     
                 file_extension = filename.lower().split('.')[-1]
+
+                if channel_index == 0:
+                    self.node_name = filename
                 
                 try:
                     if file_extension in ['tif', 'tiff']:
                         import tifffile
                         self.channel_data[channel_index] = tifffile.imread(filename)
+
                         
                     elif file_extension == 'nii':
                         import nibabel as nib
@@ -4094,6 +4620,9 @@ class ImageViewerWindow(QMainWindow):
 
             self.shape = self.channel_data[channel_index].shape
 
+            self.img_height, self.img_width = self.shape[1], self.shape[2]
+
+
             self.update_display(reset_resize = reset_resize)
 
 
@@ -4554,36 +5083,55 @@ class ImageViewerWindow(QMainWindow):
             import traceback
             print(traceback.format_exc())
 
-    def update_display_slice(self, channel, preserve_zoom=None):
-        """Ultra minimal update that only changes the paint channel's data"""
+    def update_display_slice_optimized(self, channel, preserve_zoom=None):
+        """Ultra minimal update that only changes the paint channel's data - OPTIMIZED VERSION"""
         if not self.channel_visible[channel]:
             return
-
+            
         if preserve_zoom:
             current_xlim, current_ylim = preserve_zoom
             if current_xlim is not None and current_ylim is not None:
                 self.ax.set_xlim(current_xlim)
                 self.ax.set_ylim(current_ylim)
-
-
+        
         # Find the existing image for channel (paint channel)
         channel_image = None
         for img in self.ax.images:
             if img.cmap.name == f'custom_{channel}':
                 channel_image = img
                 break
-
+                
         if channel_image is not None:
-            # Update the data of the existing image
-            channel_image.set_array(self.channel_data[channel][self.current_slice])
+            # Update the data of the existing image with thread safety
+            with self.paint_lock:
+                channel_image.set_array(self.channel_data[channel][self.current_slice])
             
             # Restore the static background (all other channels) at current zoom level
-            self.canvas.restore_region(self.static_background)
-            # Draw just our paint channel
-            self.ax.draw_artist(channel_image)
-            # Blit everything
-            self.canvas.blit(self.ax.bbox)
-            self.canvas.flush_events()
+            # This is the key - use static_background from update_display, not paint_background
+            if hasattr(self, 'static_background') and self.static_background is not None:
+                self.canvas.restore_region(self.static_background)
+                # Draw just our paint channel
+                self.ax.draw_artist(channel_image)
+                # Blit everything
+                self.canvas.blit(self.ax.bbox)
+                self.canvas.flush_events()
+            else:
+                # Fallback to full draw if no static background
+                self.canvas.draw()
+        else:
+            # Fallback if channel image not found
+            self.canvas.draw()
+
+    def get_channel_image(self, channel):
+        """Find the matplotlib image object for a specific channel."""
+        if not hasattr(self.ax, 'images'):
+            return None
+            
+        for img in self.ax.images:
+            if hasattr(img, 'cmap') and hasattr(img.cmap, 'name'):
+                if img.cmap.name == f'custom_{channel}':
+                    return img
+        return None
 
     def show_netshow_dialog(self):
         dialog = NetShowDialog(self)
@@ -4666,6 +5214,10 @@ class ImageViewerWindow(QMainWindow):
         dialog = HeatmapDialog(self)
         dialog.exec()
 
+    def show_nearneigh_dialog(self):
+        dialog = NearNeighDialog(self)
+        dialog.exec()
+
     def show_random_dialog(self):
         dialog = RandomDialog(self)
         dialog.exec()
@@ -5480,6 +6032,10 @@ class PropertiesDialog(QDialog):
         run_button.clicked.connect(self.run_properties)
         layout.addWidget(run_button)
 
+        report_button = QPushButton("Report Properties (Show in Top Right Tables)")
+        report_button.clicked.connect(self.report)
+        layout.addWidget(report_button)
+
     def check_checked(self, ques):
 
         if ques is None:
@@ -5517,11 +6073,35 @@ class PropertiesDialog(QDialog):
         except Exception as e:
             print(f"Error: {e}")
 
-class BrightnessContrastDialog(QDialog):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle("Brightness/Contrast Controls")
-        self.setModal(False)  # Allows interaction with main window while open
+    def report(self):
+
+        try:
+
+            self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+        except:
+            pass
+        try:
+
+            self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+        except:
+            pass
+
+        try:
+            self.parent().format_for_upperright_table(my_network.edge_centroids, 'EdgeID', ['Z', 'Y', 'X'], 'Edge Centroids')
+        except:
+            pass
+        try:
+            self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'Community', 'Node Communities')
+        except:
+            pass
+
+
+
+class BrightnessContrastDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Brightness/Contrast Controls")
+        self.setModal(False)  # Allows interaction with main window while open
         
         layout = QVBoxLayout(self)
         
@@ -5896,6 +6476,72 @@ class ArbitraryDialog(QDialog):
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Error processing selections: {str(e)}")
 
+class MergeNodeIdDialog(QDialog):
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Merging Node Identities From Folder Dialog.\nNote that you should prelabel or prewatershed your current node objects before doing this. (See Process -> Image) It does not label them for you.")
+        self.setModal(True)
+        
+        layout = QFormLayout(self)
+
+        self.search = QLineEdit("")
+        layout.addRow("Step-out distance (from current nodes image - ignore if you dilated them previously or don't want):", self.search)
+
+        self.xy_scale = QLineEdit(f"{my_network.xy_scale}")
+        layout.addRow("xy_scale:", self.xy_scale)
+
+        self.z_scale = QLineEdit(f"{my_network.z_scale}")
+        layout.addRow("z_scale:", self.z_scale)
+
+        # Add Run button
+        run_button = QPushButton("Get Directory")
+        run_button.clicked.connect(self.run)
+        layout.addWidget(run_button)
+
+    def run(self):
+
+        try:
+
+            search = float(self.search.text()) if self.search.text().strip() else 0
+            xy_scale = float(self.xy_scale.text()) if self.xy_scale.text().strip() else 1
+            z_scale = float(self.z_scale.text()) if self.z_scale.text().strip() else 1
+
+
+            data = self.parent().channel_data[0]
+
+            if data is None:
+                return
+
+
+
+            dialog = QFileDialog(self)
+            dialog.setOption(QFileDialog.Option.DontUseNativeDialog)
+            dialog.setOption(QFileDialog.Option.ReadOnly)
+            dialog.setFileMode(QFileDialog.FileMode.Directory)
+            dialog.setViewMode(QFileDialog.ViewMode.Detail)
+
+            if dialog.exec() == QFileDialog.DialogCode.Accepted:
+                selected_path = dialog.directory().absolutePath()
+
+            if search > 0:
+                data = sdl.smart_dilate(data, 1, 1, GPU = False, fast_dil = False, use_dt_dil_amount = search, xy_scale = xy_scale, z_scale = z_scale)
+
+            my_network.merge_node_ids(selected_path, data)
+
+            self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
+
+            QMessageBox.critical(
+                self,
+                "Success",
+                "Node Identities Merged. New IDs represent presence of corresponding img foreground with +, absence with -. Please save your new identities as csv, then use File -> Load -> Load From Excel Helper to bulk search and rename desired combinations. (Press Help [above] for more info)"
+            )
+
+            self.accept()
+
+        except Exception as e:
+            print(f"Error: {e}")
+
 
 class Show3dDialog(QDialog):
     def __init__(self, parent=None):
@@ -6629,6 +7275,174 @@ class DegreeDistDialog(QDialog):
         except Exception as e:
             print(f"An error occurred: {e}")
 
+class NearNeighDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(f"Nearest Neighborhood Averages (Using Centroids)")
+        self.setModal(True)
+        
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        
+        # Identities group box (only if node_identities exists)
+        identities_group = QGroupBox("Identities")
+        identities_layout = QFormLayout(identities_group)
+        
+        if my_network.node_identities is not None:
+
+            self.root = QComboBox()
+            self.root.addItems(list(set(my_network.node_identities.values())))  
+            self.root.setCurrentIndex(0)
+            identities_layout.addRow("Root Identity to Search for Neighbor's IDs?", self.root)
+            
+            self.targ = QComboBox()
+            neighs = list(set(my_network.node_identities.values()))
+            neighs.append("All Others (Excluding Self)")
+            self.targ.addItems(neighs)  
+            self.targ.setCurrentIndex(0)
+            identities_layout.addRow("Neighbor Identities to Search For?", self.targ)
+        else:
+            self.root = None
+            self.targ = None
+
+        self.num = QLineEdit("1")
+        identities_layout.addRow("Number of Nearest Neighbors to Evaluate Per Node?:", self.num)
+
+        
+        main_layout.addWidget(identities_group)
+
+        
+        # Optional Heatmap group box
+        heatmap_group = QGroupBox("Optional Heatmap")
+        heatmap_layout = QFormLayout(heatmap_group)
+        
+        self.map = QPushButton("(If getting distribution): Generate Heatmap?")
+        self.map.setCheckable(True)
+        self.map.setChecked(False)
+        heatmap_layout.addRow("Heatmap:", self.map)
+        
+        self.threed = QPushButton("(For above): Return 3D map? (uncheck for 2D): ")
+        self.threed.setCheckable(True)
+        self.threed.setChecked(True)
+        heatmap_layout.addRow("3D:", self.threed)
+        
+        self.numpy = QPushButton("(For heatmap): Return image overlay instead of graph? (Goes in Overlay 2): ")
+        self.numpy.setCheckable(True)
+        self.numpy.setChecked(False)
+        self.numpy.clicked.connect(self.toggle_map)
+        heatmap_layout.addRow("Overlay:", self.numpy)
+        
+        main_layout.addWidget(heatmap_group)
+        
+        # Get Distribution group box
+        distribution_group = QGroupBox("Get Distribution")
+        distribution_layout = QVBoxLayout(distribution_group)
+        
+        run_button = QPushButton("Get Average Nearest Neighbor (Plus Distribution)")
+        run_button.clicked.connect(self.run)
+        distribution_layout.addWidget(run_button)
+        
+        main_layout.addWidget(distribution_group)
+        
+        # Get All Averages group box (only if node_identities exists)
+        if my_network.node_identities is not None:
+            averages_group = QGroupBox("Get All Averages")
+            averages_layout = QVBoxLayout(averages_group)
+            
+            run_button2 = QPushButton("Get Average Nearest All ID Combinations (No Distribution, No Heatmap)")
+            run_button2.clicked.connect(self.run2)
+            averages_layout.addWidget(run_button2)
+            
+            main_layout.addWidget(averages_group)
+
+    def toggle_map(self):
+
+        if self.numpy.isChecked():
+
+            if not self.map.isChecked():
+
+                self.map.click()
+
+    def run(self):
+
+        try:
+
+            try:
+                root = self.root.currentText()
+            except:
+                root = None
+            try:
+                targ = self.targ.currentText()
+            except:
+                targ = None
+
+            heatmap = self.map.isChecked()
+            threed = self.threed.isChecked()
+            numpy = self.numpy.isChecked()
+            num = int(self.num.text()) if self.num.text().strip() else 1
+
+            if root is not None and targ is not None:
+                title = f"Nearest {num} Neighbor(s) Distance of {targ} from {root}"
+                header = f"Shortest Distance to Closest {num} {targ}(s)"
+                header2 = f"{root} Node ID"
+            else:
+                title = f"Nearest {num} Neighbor(s) Distance Between Nodes"
+                header = f"Shortest Distance to Closest {num} Nodes"
+                header2 = "Root Node ID"
+
+            if my_network.node_centroids is None:
+                self.parent().show_centroid_dialog()
+                if my_network.node_centroids is None:
+                    return
+
+            if not numpy:
+                avg, output = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed)
+            else:
+                avg, output, overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True)
+                self.parent().load_channel(3, overlay, data = True)
+
+            self.parent().format_for_upperright_table([avg], metric = f'Avg {title}', title = f'Avg {title}')
+            self.parent().format_for_upperright_table(output, header2, header, title = title)
+
+            self.accept()
+
+        except Exception as e:
+            import traceback
+            print(traceback.format_exc())
+
+            print(f"Error: {e}")
+
+    def run2(self):
+
+        try:
+
+            available = list(set(my_network.node_identities.values()))
+
+            num = int(self.num.text()) if self.num.text().strip() else 1
+
+            output_dict = {}
+
+            while len(available) > 1:
+
+                root = available[0]
+
+                for targ in available:
+
+                    avg, _ = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num)
+
+                    output_dict[f"{root} vs {targ}"] = avg
+
+                del available[0]
+
+            self.parent().format_for_upperright_table(output_dict, "ID Combo", "Avg Distance to Nearest", title = "Average Distance to Nearest Neighbors for All ID Combos")
+
+            self.accept()
+
+        except Exception as e:
+
+            print(f"Error: {e}")
+
+
 class NeighborIdentityDialog(QDialog):
 
     def __init__(self, parent=None):
@@ -6815,8 +7629,7 @@ class RipleyDialog(QDialog):
                 "Error:",
                 f"Failed to preform cluster analysis: {str(e)}"
             )
-            import traceback
-            print(traceback.format_exc())
+
             print(f"Error: {e}")
 
 class HeatmapDialog(QDialog):
@@ -6839,6 +7652,11 @@ class HeatmapDialog(QDialog):
         self.is3d.setChecked(True)
         layout.addRow("Use 3D Plot (uncheck for 2D)?:", self.is3d)
 
+        self.numpy = QPushButton("(For heatmap): Return image overlay instead of graph? (Goes in Overlay 2): ")
+        self.numpy.setCheckable(True)
+        self.numpy.setChecked(False)
+        layout.addRow("Overlay:", self.numpy)
+
 
         # Add Run button
         run_button = QPushButton("Run")
@@ -6847,25 +7665,40 @@ class HeatmapDialog(QDialog):
 
     def run(self):
 
-        nodecount = int(self.nodecount.text()) if self.nodecount.text().strip() else None
+        try:
 
-        is3d = self.is3d.isChecked()
+            nodecount = int(self.nodecount.text()) if self.nodecount.text().strip() else None
+
+            is3d = self.is3d.isChecked()
 
 
-        if my_network.communities is None:
-            if my_network.network is not None:
-                self.parent().show_partition_dialog()
-            else:
-                self.parent().handle_com_cell()
             if my_network.communities is None:
-                return
+                if my_network.network is not None:
+                    self.parent().show_partition_dialog()
+                else:
+                    self.parent().handle_com_cell()
+                if my_network.communities is None:
+                    return
 
-        heat_dict = my_network.community_heatmap(num_nodes = nodecount, is3d = is3d)
+            numpy = self.numpy.isChecked()
 
-        self.parent().format_for_upperright_table(heat_dict, metric='Community', value='ln(Predicted Community Nodecount/Actual)', title="Community Heatmap")
+            if not numpy:
 
-        self.accept()
+                heat_dict = my_network.community_heatmap(num_nodes = nodecount, is3d = is3d)
+
+            else:
 
+                heat_dict, overlay = my_network.community_heatmap(num_nodes = nodecount, is3d = is3d, numpy = True)
+                self.parent().load_channel(3, overlay, data = True)
+
+
+            self.parent().format_for_upperright_table(heat_dict, metric='Community', value='ln(Predicted Community Nodecount/Actual)', title="Community Heatmap")
+
+            self.accept()
+
+        except Exception as e:
+
+            print(f"Error: {e}")
 
 
 
@@ -7018,6 +7851,10 @@ class RadDialog(QDialog):
                 self.parent().radii_dict[0] = radii
             elif self.parent().active_channel == 1:
                 self.parent().radii_dict[1] = radii
+            elif self.parent().active_channel == 2:
+                self.parent().radii_dict[2] = radii
+            elif self.parent().active_channel == 3:
+                self.parent().radii_dict[3] = radii
 
             self.parent().format_for_upperright_table(radii, title = 'Largest Radii of Objects', metric='ObjectID', value='Largest Radius (Scaled)')
 
@@ -7105,7 +7942,7 @@ class DegreeDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Just make table", "Draw degree of node as overlay (literally draws 1, 2, 3, etc... faster)", "Label nodes by degree (nodes will take on the value 1, 2, 3, etc, based on their degree, to export for array based analysis... slower)"])
+        self.mode_selector.addItems(["Just make table", "Draw degree of node as overlay (literally draws 1, 2, 3, etc... faster)", "Label nodes by degree (nodes will take on the value 1, 2, 3, etc, based on their degree, to export for array based analysis)", "Create Heatmap of Degrees"])
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
@@ -7126,6 +7963,14 @@ class DegreeDialog(QDialog):
 
             accepted_mode = self.mode_selector.currentIndex()
 
+            if accepted_mode == 3:
+                degree_dict, overlay = my_network.get_degrees(heatmap = True)
+                self.parent().format_for_upperright_table(degree_dict, 'Node ID', 'Degree', title = 'Degrees of nodes')
+                self.parent().load_channel(3, channel_data = overlay, data = True)
+                self.accept()
+                return
+
+
             try:
                 down_factor = float(self.down_factor.text()) if self.down_factor.text() else 1
             except ValueError:
@@ -7964,7 +8809,7 @@ class ThresholdDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Using Label/Brightness", "Using Volumes"])
+        self.mode_selector.addItems(["Using Label/Brightness", "Using Volumes", "Using Radii", "Using Node Degree"])
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
@@ -7997,6 +8842,22 @@ class ThresholdDialog(QDialog):
                 if self.parent().volume_dict[self.parent().active_channel] is None:
                     self.parent().volumes()
 
+            elif accepted_mode == 2:
+                if len(np.unique(self.parent().channel_data[self.parent().active_channel])) < 3:
+                    self.parent().show_label_dialog()
+
+                if self.parent().radii_dict[self.parent().active_channel] is None:
+                    self.parent().show_rad_dialog()
+
+                    if self.parent().radii_dict[self.parent().active_channel] is None:
+                        return
+
+            elif accepted_mode == 3:
+
+                if my_network.nodes is None or my_network.network is None:
+                    print("Error - please calculate network first")
+                    return
+
             if self.parent().mini_overlay_data is not None:
                 self.parent().mini_overlay_data = None
 
@@ -8005,6 +8866,8 @@ class ThresholdDialog(QDialog):
             self.highlight_overlay = None
             self.accept()
         except:
+            import traceback
+            traceback.print_exc()   
             pass
 
     def start_ml(self, GPU = False):
@@ -8696,7 +9559,11 @@ class MachineWindow(QMainWindow):
 
             print("Segmenting entire volume with model...")
             #foreground_coords, background_coords = self.segmenter.segment_volume(array = self.parent().highlight_overlay)
-            self.parent().highlight_overlay = self.segmenter.segment_volume(array = self.parent().highlight_overlay)
+            try:
+                self.parent().highlight_overlay = self.segmenter.segment_volume(array = self.parent().highlight_overlay)
+            except Exception as e:
+                print(f"Error segmenting (Perhaps retrain the model...): {e}")
+                return
 
             # Clean up when done
             self.segmenter.cleanup()
@@ -8717,23 +9584,27 @@ class MachineWindow(QMainWindow):
         print("Finished segmentation moved to Overlay 2. Use File -> Save(As) for disk saving.")
 
     def closeEvent(self, event):
-        if self.parent().isVisible():
-            if self.confirm_close_dialog():
-                # Clean up resources before closing
-                if self.brush_button.isChecked():
-                    self.silence_button()
-                    self.toggle_brush_mode()
-                
-                self.parent().pen_button.setEnabled(True)
-                self.parent().brush_mode = False
-                
-                # Kill the segmentation thread and wait for it to finish
-                self.kill_segmentation()
-                time.sleep(0.2)  # Give additional time for cleanup
-                
-                self.parent().machine_window = None
-            else:
-                event.ignore()
+
+        try:
+            if self.parent().isVisible():
+                if self.confirm_close_dialog():
+                    # Clean up resources before closing
+                    if self.brush_button.isChecked():
+                        self.silence_button()
+                        self.toggle_brush_mode()
+                    
+                    self.parent().pen_button.setEnabled(True)
+                    self.parent().brush_mode = False
+                    
+                    # Kill the segmentation thread and wait for it to finish
+                    self.kill_segmentation()
+                    time.sleep(0.2)  # Give additional time for cleanup
+                    
+                    self.parent().machine_window = None
+                else:
+                    event.ignore()
+        except:
+            pass
 
 
 
@@ -8846,6 +9717,8 @@ class ThresholdWindow(QMainWindow):
     def __init__(self, parent=None, accepted_mode=0):
         super().__init__(parent)
         self.setWindowTitle("Threshold")
+
+        self.accepted_mode = accepted_mode
         
         # Create central widget and layout
         central_widget = QWidget()
@@ -8857,6 +9730,27 @@ class ThresholdWindow(QMainWindow):
             self.histo_list = list(self.parent().volume_dict[self.parent().active_channel].values())
             self.bounds = False
             self.parent().bounds = False
+        elif accepted_mode == 2:
+            self.histo_list = list(self.parent().radii_dict[self.parent().active_channel].values())
+            self.bounds = False
+            self.parent().bounds = False
+        elif accepted_mode == 3:
+            self.parent().degree_dict = {}
+            self.parent().set_active_channel(0)
+            nodes = list(my_network.network.nodes())
+            img_nodes = list(np.unique(my_network.nodes))
+            if 0 in img_nodes:
+                del img_nodes[0]
+            for node in img_nodes:
+                if node in nodes:
+                    self.parent().degree_dict[int(node)] = my_network.network.degree(node)
+                else:
+                    self.parent().degree_dict[int(node)] = 0
+
+            self.histo_list = list(self.parent().degree_dict.values())
+            self.bounds = False
+            self.parent().bounds = False
+
         elif accepted_mode == 0:
             targ_shape = self.parent().channel_data[self.parent().active_channel].shape
             if (targ_shape[0] + targ_shape[1] + targ_shape[2]) > 2500: #Take a simpler histogram on big arrays
@@ -8976,17 +9870,35 @@ class ThresholdWindow(QMainWindow):
 
     def get_values_in_range_all_vols(self, chan, min_val, max_val):
         output = []
-        for node, vol in self.parent().volume_dict[chan].items():
-            if min_val <= vol <= max_val:
-                output.append(node)
+        if self.accepted_mode == 1:
+            for node, vol in self.parent().volume_dict[chan].items():
+                if min_val <= vol <= max_val:
+                    output.append(node)
+        elif self.accepted_mode == 2:
+            for node, vol in self.parent().radii_dict[chan].items():
+                if min_val <= vol <= max_val:
+                    output.append(node)
+        elif self.accepted_mode == 3:
+            for node, vol in self.parent().degree_dict.items():
+                if min_val <= vol <= max_val:
+                    output.append(node)
         return output
 
     def get_values_in_range(self, lst, min_val, max_val):
         values = [x for x in lst if min_val <= x <= max_val]
         output = []
-        for item in self.parent().volume_dict[self.parent().active_channel]:
-            if self.parent().volume_dict[self.parent().active_channel][item] in values:
-                output.append(item)
+        if self.accepted_mode == 1:
+            for item in self.parent().volume_dict[self.parent().active_channel]:
+                if self.parent().volume_dict[self.parent().active_channel][item] in values:
+                    output.append(item)
+        elif self.accepted_mode == 2:
+            for item in self.parent().radii_dict[self.parent().active_channel]:
+                if self.parent().radii_dict[self.parent().active_channel][item] in values:
+                    output.append(item)
+        elif self.accepted_mode == 3:
+            for item in self.parent().degree_dict:
+                if self.parent().degree_dict[item] in values:
+                    output.append(item)
         return output
 
 
@@ -9421,15 +10333,20 @@ class HoleDialog(QDialog):
         # auto checkbox (default True)
         self.headon = QPushButton("Head-on")
         self.headon.setCheckable(True)
-        self.headon.setChecked(False)
+        self.headon.setChecked(True)
         layout.addRow("Only Use 2D Slicing Dimension:", self.headon)
 
         # auto checkbox (default True)
         self.borders = QPushButton("Borders")
         self.borders.setCheckable(True)
-        self.borders.setChecked(True)
+        self.borders.setChecked(False)
         layout.addRow("Fill Small Holes Along Borders:", self.borders)
 
+        self.sep_holes = QPushButton("Seperate Hole Mask")
+        self.sep_holes.setCheckable(True)
+        self.sep_holes.setChecked(False)
+        layout.addRow("Place Hole Mask in Overlay 2 (Instead of Filling):", self.sep_holes)
+
        # Add Run button
         run_button = QPushButton("Run Fill Holes")
         run_button.clicked.connect(self.run_holes)
@@ -9446,6 +10363,7 @@ class HoleDialog(QDialog):
 
             borders = self.borders.isChecked()
             headon = self.headon.isChecked()
+            sep_holes = self.sep_holes.isChecked()
             
             # Call dilate method with parameters
             result = n3d.fill_holes_3d(
@@ -9454,7 +10372,11 @@ class HoleDialog(QDialog):
                 fill_borders = borders
             )
 
-            self.parent().load_channel(self.parent().active_channel, result, True)
+            if not sep_holes:
+                self.parent().load_channel(self.parent().active_channel, result, True)
+            else:
+                self.parent().load_channel(3, active_data - result, True)
+
 
             self.parent().update_display()
             self.accept()
@@ -9553,7 +10475,7 @@ class CropDialog(QDialog):
         try:
 
             super().__init__(parent)
-            self.setWindowTitle("Crop Image?")
+            self.setWindowTitle("Crop Image (Will transpose any centroids)?")
             self.setModal(True)
 
             layout = QFormLayout(self)
@@ -9609,10 +10531,70 @@ class CropDialog(QDialog):
 
                     self.parent().load_channel(i, array, data = True)
 
+            print("Transposing centroids...")
+
+            try:
+
+                if my_network.node_centroids is not None:
+                    nodes = list(my_network.node_centroids.keys())
+                    centroids = np.array(list(my_network.node_centroids.values()))
+                    
+                    # Transform all at once
+                    transformed = centroids - np.array([zmin, ymin, xmin])
+                    transformed = transformed.astype(int)
+                    
+                    # Boolean mask for valid coordinates
+                    valid_mask = ((transformed >= 0) & 
+                                  (transformed <= np.array([zmax, ymax, xmax]))).all(axis=1)
+                    
+                    # Rebuild dictionary with only valid entries
+                    my_network.node_centroids = {
+                        nodes[int(i)]: [int(transformed[i, 0]), int(transformed[i, 1]), int(transformed[i, 2])]
+                        for i in range(len(nodes)) if valid_mask[i]
+                    }
+                    
+                    self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+
+            except Exception as e:
+
+                print(f"Error transposing node centroids: {e}")
+
+            try:
+
+                if my_network.edge_centroids is not None:
+
+                    if my_network.edge_centroids is not None:
+                        nodes = list(my_network.edge_centroids.keys())
+                        centroids = np.array(list(my_network.edge_centroids.values()))
+                        
+                        # Transform all at once
+                        transformed = centroids - np.array([zmin, ymin, xmin])
+                        transformed = transformed.astype(int)
+                        
+                        # Boolean mask for valid coordinates
+                        valid_mask = ((transformed >= 0) & 
+                                      (transformed <= np.array([zmax, ymax, xmax]))).all(axis=1)
+                        
+                        # Rebuild dictionary with only valid entries
+                        my_network.edge_centroids = {
+                            nodes[int(i)]: [int(transformed[i, 0]), int(transformed[i, 1]), int(transformed[i, 2])]
+                            for i in range(len(nodes)) if valid_mask[i]
+                        }
+                        
+                        self.parent().format_for_upperright_table(my_network.edge_centroids, 'EdgeID', ['Z', 'Y', 'X'], 'Edge Centroids')
+
+            except Exception as e:
+
+                print(f"Error transposing edge centroids: {e}")
+
+
             self.accept()
 
         except Exception as e:
 
+            import traceback
+            print(traceback.format_exc())
+
             print(f"Error cropping: {e}")
 
 
@@ -10037,7 +11019,7 @@ class CentroidNodeDialog(QDialog):
 
             else:
 
-                my_network.nodes, my_network.centroids = my_network.centroid_array(clip = True)
+                my_network.nodes, my_network.node_centroids = my_network.centroid_array(clip = True)
 
                 self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
 
@@ -10315,6 +11297,12 @@ class BranchDialog(QDialog):
         self.fix2.setChecked(True)
         correction_layout.addWidget(QLabel("Auto-Correct Branches by Collapsing Internal Labels: "), 3, 0)
         correction_layout.addWidget(self.fix2, 3, 1)
+
+        self.fix3 = QPushButton("Split Nontouching Branches?")
+        self.fix3.setCheckable(True)
+        self.fix3.setChecked(True)
+        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(self.fix3, 4, 1)
         
         correction_group.setLayout(correction_layout)
         main_layout.addWidget(correction_group)
@@ -10385,6 +11373,7 @@ class BranchDialog(QDialog):
             cubic = self.cubic.isChecked()
             fix = self.fix.isChecked()
             fix2 = self.fix2.isChecked()
+            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
 
@@ -10434,6 +11423,10 @@ class BranchDialog(QDialog):
 
                     output = temp_network.nodes
 
+                if fix3:
+
+                    output = self.parent().separate_nontouching_objects(output, max_val=np.max(output))
+
 
                 if down_factor is not None:
 
@@ -10946,11 +11939,11 @@ class CalcAllDialog(QDialog):
         
         self.search = QLineEdit(self.prev_search)
         self.search.setPlaceholderText("Leave empty for None")
-        important_layout.addRow("Node Search (float):", self.search)
+        important_layout.addRow("Node Search (float - Does not merge nodes):", self.search)
         
         self.diledge = QLineEdit(self.prev_diledge)
         self.diledge.setPlaceholderText("Leave empty for None")
-        important_layout.addRow("Edge Reconnection Distance (float):", self.diledge)
+        important_layout.addRow("Edge Search (float - Note that edges that find each other will merge):", self.diledge)
         
         self.label_nodes = QPushButton("Label")
         self.label_nodes.setCheckable(True)