nettracer3d 0.8.3__py3-none-any.whl → 0.8.4__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -22,7 +22,7 @@ from PyQt6.QtGui import (QFont, QCursor, QColor, QPixmap, QFontMetrics, QPainter
 import tifffile
 import copy
 import multiprocessing as mp
-from concurrent.futures import ThreadPoolExecutor
+from concurrent.futures import ProcessPoolExecutor, ThreadPoolExecutor
 from functools import partial
 from nettracer3d import segmenter
 try:
@@ -33,6 +33,8 @@ from nettracer3d import excelotron
 import threading
 import queue
 from threading import Lock
+from scipy import ndimage
+import os
 
 
 
@@ -291,6 +293,14 @@ class ImageViewerWindow(QMainWindow):
             
             control_layout.addWidget(channel_container)
 
+        self.show_channels = QPushButton("✓")
+        self.show_channels.setCheckable(True)
+        self.show_channels.setChecked(True)
+        self.show_channels.setFixedSize(20, 20)
+        self.show_channels.clicked.connect(self.toggle_chan_load)
+        control_layout.addWidget(self.show_channels)
+        self.chan_load = True
+
         # Create the main widget and layout
         main_widget = QWidget()
         self.setCentralWidget(main_widget)
@@ -386,7 +396,7 @@ class ImageViewerWindow(QMainWindow):
         # Create both table views
         self.network_table = CustomTableView(self)
         self.selection_table = CustomTableView(self)
-        empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+        empty_df = pd.DataFrame(columns=['Node A', 'Node B', 'Edge C'])
         self.selection_table.setModel(PandasModel(empty_df))
         self.network_table.setAlternatingRowColors(True)
         self.selection_table.setAlternatingRowColors(True)
@@ -1773,7 +1783,7 @@ class ImageViewerWindow(QMainWindow):
                 my_network.network_lists = my_network.network_lists
 
                 if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
-                    empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+                    empty_df = pd.DataFrame(columns=['Node A', 'Node B', 'Edge C'])
                     model = PandasModel(empty_df)
                     self.network_table.setModel(model)
                 else:
@@ -1795,58 +1805,149 @@ class ImageViewerWindow(QMainWindow):
         except Exception as e:
             print(f"An error has occured: {e}")
 
-    def separate_nontouching_objects(self, input_array, max_val=0):
+
+    def process_single_label_bbox(args):
         """
-        optimized version using advanced indexing.
+        Worker function to process a single label within its bounding box
+        This function will run in parallel
         """
+        label_subarray, original_label, bbox_slices, start_new_label = args
+        
+        try:
+            # Create binary mask for this label only
+            binary_mask = label_subarray == original_label
+            
+            if not np.any(binary_mask):
+                return None, start_new_label, bbox_slices
+            
+            # Find connected components in the subarray
+            labeled_cc, num_cc = n3d.label_objects(binary_mask)
+            
+            if num_cc == 0:
+                return None, start_new_label, bbox_slices
+            
+            # Create output subarray with new labels
+            output_subarray = np.zeros_like(label_subarray)
+            
+            # Assign new consecutive labels starting from start_new_label
+            for cc_id in range(1, num_cc + 1):
+                cc_mask = labeled_cc == cc_id
+                new_label = start_new_label + cc_id - 1
+                output_subarray[cc_mask] = new_label
+            
+            # Return the processed subarray, number of components created, and bbox info
+            return output_subarray, start_new_label + num_cc, bbox_slices
+            
+        except Exception as e:
+            print(f"Error processing label {original_label}: {e}")
+            return None, start_new_label, bbox_slices
 
+    def separate_nontouching_objects(self, input_array, max_val=0):
+        """
+        Ultra-optimized version using find_objects directly without remapping
+        """
         print("Splitting nontouching objects")
-
+        
         binary_mask = input_array > 0
-        labeled_array, _ = n3d.label_objects(binary_mask)
+        if not np.any(binary_mask):
+            return np.zeros_like(input_array)
         
-        # 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]
+        unique_labels = np.unique(input_array[binary_mask])
+        print(f"Processing {len(unique_labels)} unique labels")
         
-        # 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))
+        # Get all bounding boxes at once - this is very fast
+        bounding_boxes = ndimage.find_objects(input_array)
         
-        # Create output array
-        output_array = np.zeros_like(input_array)
-        output_array[mask] = new_labels[inverse_indices]
+        # Prepare work items - just check if bounding box exists for each label
+        work_items = []
+        for orig_label in unique_labels:
+            # find_objects returns list where index = label - 1
+            bbox_index = orig_label - 1
+            
+            if (bbox_index >= 0 and 
+                bbox_index < len(bounding_boxes) and 
+                bounding_boxes[bbox_index] is not None):
+                
+                bbox = bounding_boxes[bbox_index]
+                work_items.append((orig_label, bbox))
         
+        print(f"Created {len(work_items)} work items")
+        
+        # If we have work items, process them
+        if len(work_items) == 0:
+            print("No valid work items found!")
+            return np.zeros_like(input_array)
+        
+        def process_label_minimal(item):
+            orig_label, bbox = item
+            try:
+                subarray = input_array[bbox]
+                binary_sub = subarray == orig_label
+                
+                if not np.any(binary_sub):
+                    return orig_label, bbox, None, 0
+                    
+                labeled_sub, num_cc = n3d.label_objects(binary_sub)
+                return orig_label, bbox, labeled_sub, num_cc
+                
+            except Exception as e:
+                print(f"Error processing label {orig_label}: {e}")
+                return orig_label, bbox, None, 0
+        
+        # Execute in parallel
+        max_workers = min(mp.cpu_count(), len(work_items))
+        
+        with ThreadPoolExecutor(max_workers=max_workers) as executor:
+            results = list(executor.map(process_label_minimal, work_items))
+        
+        # Reconstruct output array
+        output_array = np.zeros_like(input_array)
+        current_label = max_val + 1
+        total_components = 0
+        
+        for orig_label, bbox, labeled_sub, num_cc in results:
+            if num_cc > 0 and labeled_sub is not None:
+                print(f"Label {orig_label}: {num_cc} components")
+                # Remap labels and place in output
+                for cc_id in range(1, num_cc + 1):
+                    mask = labeled_sub == cc_id
+                    output_array[bbox][mask] = current_label
+                    current_label += 1
+                    total_components += 1
+        
+        print(f"Total components created: {total_components}")
         return output_array
 
     def handle_seperate(self):
-
+        """
+        Fixed version with proper mask handling and debugging
+        """
         try:
             # Handle nodes
             if len(self.clicked_values['nodes']) > 0:
-                self.create_highlight_overlay(node_indices=self.clicked_values['nodes'])
                 
-                # Create a boolean mask for highlighted values
-                self.highlight_overlay = self.highlight_overlay != 0
-                
-                # Create array with just the highlighted values
-                highlighted_nodes = self.highlight_overlay * my_network.nodes
+                # Create highlight overlay (this should preserve original label values)
+                self.create_highlight_overlay(node_indices=self.clicked_values['nodes'])
+                                
+                # DON'T convert to boolean yet - we need the original labels!
+                # Create a boolean mask for where we have highlighted values
+                highlight_mask = self.highlight_overlay != 0
                 
+                # Create array with just the highlighted values (preserving original labels)
+                highlighted_nodes = np.where(highlight_mask, my_network.nodes, 0)
+                                
                 # Get non-highlighted part of the array
-                non_highlighted = my_network.nodes * (~self.highlight_overlay)
-
-                if (highlighted_nodes==non_highlighted).all():
-                    max_val = 0
-                else:
-                    max_val = np.max(non_highlighted)
+                non_highlighted = np.where(highlight_mask, 0, my_network.nodes)
                 
+                # Calculate max_val properly
+                max_val = np.max(non_highlighted) if np.any(non_highlighted) else 0
+                                
                 # Process highlighted part
                 processed_highlights = self.separate_nontouching_objects(highlighted_nodes, max_val)
-                
+                                
                 # Combine back with non-highlighted parts
                 my_network.nodes = non_highlighted + processed_highlights
-                
+                                
                 self.load_channel(0, my_network.nodes, True)
             
             # Handle edges
@@ -1855,18 +1956,15 @@ class ImageViewerWindow(QMainWindow):
                 self.create_highlight_overlay(edge_indices=self.clicked_values['edges'])
                 
                 # Create a boolean mask for highlighted values
-                self.highlight_overlay = self.highlight_overlay != 0
+                highlight_mask = self.highlight_overlay != 0
                 
                 # Create array with just the highlighted values
-                highlighted_edges = self.highlight_overlay * my_network.edges
+                highlighted_edges = np.where(highlight_mask, my_network.edges, 0)
                 
                 # Get non-highlighted part of the array
-                non_highlighted = my_network.edges * (~self.highlight_overlay)
+                non_highlighted = np.where(highlight_mask, 0, my_network.edges)
 
-                if (highlighted_edges==non_highlighted).all():
-                    max_val = 0
-                else:
-                    max_val = np.max(non_highlighted)
+                max_val = np.max(non_highlighted) if np.any(non_highlighted) else 0
                 
                 # Process highlighted part
                 processed_highlights = self.separate_nontouching_objects(highlighted_edges, max_val)
@@ -1920,7 +2018,7 @@ class ImageViewerWindow(QMainWindow):
 
 
             if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
-                empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+                empty_df = pd.DataFrame(columns=['Node A', 'Node B', 'Edge C'])
                 model = PandasModel(empty_df)
                 self.network_table.setModel(model)
             else:
@@ -1961,7 +2059,7 @@ class ImageViewerWindow(QMainWindow):
             
             # Update the table
             if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
-                empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+                empty_df = pd.DataFrame(columns=['Node A', 'Node B', 'Edge C'])
                 model = PandasModel(empty_df)
                 self.network_table.setModel(model)
             else:
@@ -1993,7 +2091,7 @@ class ImageViewerWindow(QMainWindow):
             my_network.network_lists = my_network.network_lists
 
             if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
-                empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+                empty_df = pd.DataFrame(columns=['Node A', 'Node B', 'Edge C'])
                 model = PandasModel(empty_df)
                 self.network_table.setModel(model)
             else:
@@ -2044,6 +2142,12 @@ class ImageViewerWindow(QMainWindow):
             print(f"Error: {e}")
 
 
+    def toggle_chan_load(self):
+
+        if self.show_channels.isChecked():
+            self.chan_load = True
+        else:
+            self.chan_load = False
 
     def toggle_highlight(self):
         self.highlight = self.high_button.isChecked()
@@ -2648,6 +2752,7 @@ class ImageViewerWindow(QMainWindow):
             return
             
         current_time = time.time()
+        self.rect_time = current_time
         
         if self.selection_start and not self.selecting and not self.pan_mode and not self.brush_mode:
             if (abs(event.xdata - self.selection_start[0]) > 1 or 
@@ -3062,6 +3167,12 @@ class ImageViewerWindow(QMainWindow):
 
     def on_mouse_release(self, event):
         """Handle mouse release events"""
+
+        if self.zoom_mode:
+            rect_condition = (time.time() - self.rect_time) > 0.01 # This is just to prevent non-deliberate rectangle zooming
+        else:
+            rect_condition = True
+
         if self.pan_mode:
             
             self.panning = False
@@ -3069,7 +3180,7 @@ class ImageViewerWindow(QMainWindow):
             self.canvas.setCursor(Qt.CursorShape.OpenHandCursor)
             
         elif event.button == 1:  # Left button release
-            if self.selecting and self.selection_rect is not None:
+            if rect_condition and self.selecting and self.selection_rect is not None:
                 # Get the rectangle bounds
                 x0 = min(self.selection_start[0], event.xdata)
                 y0 = min(self.selection_start[1], event.ydata)
@@ -3077,7 +3188,13 @@ class ImageViewerWindow(QMainWindow):
                 height = abs(event.ydata - self.selection_start[1])
                 shift_pressed = 'shift' in event.modifiers
 
-                if shift_pressed or self.zoom_mode: #Optional targeted zoom
+                if shift_pressed:
+
+                    args = int(x0), int(x0 + width), int(y0), int(y0 + height)
+
+                    self.show_crop_dialog(args)
+
+                elif self.zoom_mode: #Optional targeted zoom
                     
                     self.ax.set_xlim([x0, x0 + width])
                     self.ax.set_ylim([y0 + height, y0])
@@ -3539,7 +3656,7 @@ 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 = stats_menu.addAction("Average Nearest Neighbors (With Clustering Heatmaps)")
         nearneigh_action.triggered.connect(self.show_nearneigh_dialog)
         vol_action = stats_menu.addAction("Calculate Volumes")
         vol_action.triggered.connect(self.volumes)
@@ -3574,6 +3691,10 @@ class ImageViewerWindow(QMainWindow):
         calc_all_action.triggered.connect(self.show_calc_all_dialog)
         calc_prox_action = calculate_menu.addAction("Calculate Proximity Network (connect nodes by distance)")
         calc_prox_action.triggered.connect(self.show_calc_prox_dialog)
+        calc_branch_action = calculate_menu.addAction("Calculate Branchpoint Network (Connect Branchpoints of Edge Image - Good for Nerves/Vessels)")
+        calc_branch_action.triggered.connect(self.handle_calc_branch)
+        calc_branchprox_action = calculate_menu.addAction("Calculate Branch Adjacency Network (Of Edges)")
+        calc_branchprox_action.triggered.connect(self.handle_branchprox_calc)
         centroid_action = calculate_menu.addAction("Calculate Centroids (Active Image)")
         centroid_action.triggered.connect(self.show_centroid_dialog)
 
@@ -3597,13 +3718,17 @@ class ImageViewerWindow(QMainWindow):
         mask_action = image_menu.addAction("Mask Channel")
         mask_action.triggered.connect(self.show_mask_dialog)
         crop_action = image_menu.addAction("Crop Channels")
-        crop_action.triggered.connect(self.show_crop_dialog)
+        crop_action.triggered.connect(lambda: self.show_crop_dialog(args = None))
         type_action = image_menu.addAction("Channel dtype")
         type_action.triggered.connect(self.show_type_dialog)
         skeletonize_action = image_menu.addAction("Skeletonize")
         skeletonize_action.triggered.connect(self.show_skeletonize_dialog)
-        watershed_action = image_menu.addAction("Watershed")
+        dt_action = image_menu.addAction("Distance Transform (For binary images)")
+        dt_action.triggered.connect(self.show_dt_dialog)
+        watershed_action = image_menu.addAction("Binary Watershed")
         watershed_action.triggered.connect(self.show_watershed_dialog)
+        gray_water_action = image_menu.addAction("Gray Watershed")
+        gray_water_action.triggered.connect(self.show_gray_water_dialog)
         invert_action = image_menu.addAction("Invert")
         invert_action.triggered.connect(self.show_invert_dialog)
         z_proj_action = image_menu.addAction("Z Project")
@@ -3615,7 +3740,7 @@ class ImageViewerWindow(QMainWindow):
         gennodes_action = generate_menu.addAction("Generate Nodes (From 'Edge' Vertices)")
         gennodes_action.triggered.connect(self.show_gennodes_dialog)
         branch_action = generate_menu.addAction("Label Branches")
-        branch_action.triggered.connect(self.show_branch_dialog)
+        branch_action.triggered.connect(lambda: self.show_branch_dialog())
         genvor_action = generate_menu.addAction("Generate Voronoi Diagram (From Node Centroids) - goes in Overlay2")
         genvor_action.triggered.connect(self.voronoi)
 
@@ -3919,6 +4044,10 @@ class ImageViewerWindow(QMainWindow):
         dialog = MergeNodeIdDialog(self)
         dialog.exec()
 
+    def show_gray_water_dialog(self):
+        """Show the gray watershed parameter dialog."""
+        dialog = GrayWaterDialog(self)
+        dialog.exec()
 
     def show_watershed_dialog(self):
         """Show the watershed parameter dialog."""
@@ -3950,6 +4079,110 @@ class ImageViewerWindow(QMainWindow):
         dialog = ProxDialog(self)
         dialog.exec()
 
+    def table_load_attrs(self):
+
+        # Display network_lists in the network table
+        try:
+            if hasattr(my_network, 'network_lists'):
+                model = PandasModel(my_network.network_lists)
+                self.network_table.setModel(model)
+                # Adjust column widths to content
+                for column in range(model.columnCount(None)):
+                    self.network_table.resizeColumnToContents(column)
+        except Exception as e:
+            print(f"Error loading network_lists: {e}")
+
+        #Display the other things if they exist
+        try:
+
+            if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
+                try:
+                    self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+                except Exception as e:
+                    print(f"Error loading node identity table: {e}")
+
+            if hasattr(my_network, 'node_centroids') and my_network.node_centroids is not None:
+                try:
+                    self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+                except Exception as e:
+                    print(f"Error loading node centroid table: {e}")
+
+
+            if hasattr(my_network, 'edge_centroids') and my_network.edge_centroids is not None:
+                try:
+                    self.format_for_upperright_table(my_network.edge_centroids, 'EdgeID', ['Z', 'Y', 'X'], 'Edge Centroids')
+                except Exception as e:
+                    print(f"Error loading edge centroid table: {e}")
+
+
+        except Exception as e:
+            print(f"An error has occured: {e}")
+
+    def confirm_calcbranch_dialog(self, message):
+        """Shows a dialog asking user to confirm if they want to proceed below"""
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Icon.Question)
+        msg.setText("Alert")
+        msg.setInformativeText(message)
+        msg.setWindowTitle("Proceed?")
+        msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        return msg.exec() == QMessageBox.StandardButton.Yes
+
+    def handle_calc_branch(self):
+
+        try:
+
+            if self.channel_data[0] is not None or self.channel_data[3] is not None:
+                if not self.confirm_calcbranch_dialog("Use of this feature will require additional use of the Nodes and Overlay 2 channels. Please save any data and return, or proceed if you do not need those channels' data"):
+                    return
+
+            my_network.id_overlay = my_network.edges.copy()
+
+            self.show_gennodes_dialog()
+
+            my_network.edges = (my_network.nodes == 0) * my_network.edges
+
+            my_network.calculate_all(my_network.nodes, my_network.edges, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale, search = None, diledge = None, inners = False, hash_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)
+
+            self.load_channel(1, my_network.edges, data = True)
+            self.load_channel(0, my_network.nodes, data = True)
+            self.load_channel(3, my_network.id_overlay, data = True)
+
+            self.table_load_attrs()
+
+        except Exception as e:
+
+            try:
+                my_network.edges = my_network.id_overlay
+                my_network.id_overlay = None
+            except:
+                pass
+
+            print(f"Error calculating branchpoint network: {e}")
+
+    def handle_branchprox_calc(self):
+
+        try:
+
+            if self.channel_data[0] is not None:
+                if not self.confirm_calcbranch_dialog("Use of this feature will require additional use of the Nodes and Overlay 2 channels. Please save any data and return, or proceed if you do not need those channels' data"):
+                    return
+
+            self.show_branch_dialog(called = True)
+
+            self.load_channel(0, my_network.edges, data = True)
+
+            self.delete_channel(1, False)
+
+            my_network.morph_proximity(search = [3,3], fastdil = True)
+
+            self.table_load_attrs()
+
+        except Exception as e:
+
+            print(f"Error calculating network: {e}")
+
+
     def show_centroid_dialog(self):
         """show the centroid dialog"""
         dialog = CentroidDialog(self)
@@ -3994,9 +4227,9 @@ class ImageViewerWindow(QMainWindow):
         dialog = MaskDialog(self)
         dialog.exec()
 
-    def show_crop_dialog(self):
+    def show_crop_dialog(self, args = None):
         """Show the crop dialog"""
-        dialog = CropDialog(self)
+        dialog = CropDialog(self, args = args)
         dialog.exec()
 
     def show_type_dialog(self):
@@ -4012,6 +4245,11 @@ class ImageViewerWindow(QMainWindow):
         dialog = SkeletonizeDialog(self)
         dialog.exec()
 
+    def show_dt_dialog(self):
+        """show the dt dialog"""
+        dialog = DistanceDialog(self)
+        dialog.exec()
+
     def show_centroid_node_dialog(self):
         """show the centroid node dialog"""
         dialog = CentroidNodeDialog(self)
@@ -4023,9 +4261,9 @@ class ImageViewerWindow(QMainWindow):
         gennodes = GenNodesDialog(self, down_factor = down_factor, called = called)
         gennodes.exec()
 
-    def show_branch_dialog(self):
+    def show_branch_dialog(self, called = False):
         """Show the branch label dialog"""
-        dialog = BranchDialog(self)
+        dialog = BranchDialog(self, called = called)
         dialog.exec()
 
     def voronoi(self):
@@ -4178,6 +4416,7 @@ class ImageViewerWindow(QMainWindow):
                     if sort == 'Node Identities':
                         my_network.load_node_identities(file_path = filename)
 
+                        """
                         first_value = list(my_network.node_identities.values())[0]  # Check that there are not multiple IDs
                         if isinstance(first_value, (list, tuple)):
                             trump_value, ok = QInputDialog.getText(
@@ -4199,7 +4438,7 @@ class ImageViewerWindow(QMainWindow):
                         else:
                             trump_value = None
                             my_network.node_identities = uncork(my_network.node_identities, trump_value)
-
+                        """
 
                         if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
                             try:
@@ -4354,7 +4593,7 @@ class ImageViewerWindow(QMainWindow):
                 # Display network_lists in the network table
                 # Create empty DataFrame for network table if network_lists is None
                 if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
-                    empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+                    empty_df = pd.DataFrame(columns=['Node A', 'Node B', 'Edge C'])
                     model = PandasModel(empty_df)
                     self.network_table.setModel(model)
                 else:
@@ -4439,7 +4678,7 @@ class ImageViewerWindow(QMainWindow):
         """Method to close Excelotron"""
         self.excel_manager.close()
     
-    def handle_excel_data(self, data_dict, property_name):
+    def handle_excel_data(self, data_dict, property_name, add):
         """Handle data received from Excelotron"""
         print(f"Received data for property: {property_name}")
         print(f"Data keys: {list(data_dict.keys())}")
@@ -4448,12 +4687,19 @@ class ImageViewerWindow(QMainWindow):
 
             try:
 
+                if not add or my_network.node_centroids is None:
+                    centroids = {}
+                    max_val = 0
+                else:
+                    centroids = my_network.node_centroids
+                    max_val = max(list(my_network.node_centroids.keys()))
+
                 ys = data_dict['Y']
                 xs = data_dict['X']
                 if 'Numerical IDs' in data_dict:
                     nodes = data_dict['Numerical IDs']
                 else:
-                    nodes = np.arange(1, len(ys) + 1)
+                    nodes = np.arange(max_val + 1, max_val + len(ys) + 1)
 
 
                 if 'Z' in data_dict:
@@ -4461,8 +4707,6 @@ class ImageViewerWindow(QMainWindow):
                 else:
                     zs = np.zeros(len(ys))
 
-                centroids = {}
-
                 for i in range(len(nodes)):
 
                     centroids[nodes[i]] = [int(zs[i]), int(ys[i]), int(xs[i])]
@@ -4480,15 +4724,26 @@ class ImageViewerWindow(QMainWindow):
 
             try:
 
+                if not add or my_network.node_identities is None:
+                    identities = {}
+                    max_val = 0
+                else:
+                    identities = my_network.node_identities
+                    if my_network.node_centroids is not None:
+                        max_val = max(list(my_network.node_centroids.keys()))
+                    else:
+                        max_val = max(list(my_network.node_identities.keys()))
+
                 idens = data_dict['Identity Column']
 
                 if 'Numerical IDs' in data_dict:
                     nodes = data_dict['Numerical IDs']
-                else:
-                    nodes = np.arange(1, len(idens) + 1)
-
-                identities = {}
+                    if add:
+                        for i, node in enumerate(nodes):
+                            nodes[i] = node + max_val
 
+                else:
+                    nodes = np.arange(max_val + 1, max_val + len(data_dict['Identity Column']) + 1)
 
                 for i in range(len(nodes)):
 
@@ -4507,14 +4762,20 @@ class ImageViewerWindow(QMainWindow):
 
             try:
 
+                if not add or my_network.communities is None:
+                    communities = {}
+                    max_val = 0
+                else:
+                    communities = my_network.communities
+                    max_val = max(list(my_network.communities.keys()))
+
+
                 coms = data_dict['Community Identifier']
 
                 if 'Numerical IDs' in data_dict:
                     nodes = data_dict['Numerical IDs']
                 else:
-                    nodes = np.arange(1, len(coms) + 1)
-
-                communities = {}
+                    nodes = np.arange(max_val + 1, max_val + len(data_dict['Community Identifier']) + 1)
 
                 for i in range(len(nodes)):
 
@@ -4627,7 +4888,6 @@ class ImageViewerWindow(QMainWindow):
                         import tifffile
                         self.channel_data[channel_index] = tifffile.imread(filename)
 
-                        
                     elif file_extension == 'nii':
                         import nibabel as nib
                         nii_img = nib.load(filename)
@@ -4657,9 +4917,20 @@ class ImageViewerWindow(QMainWindow):
                     self.channel_buttons[channel_index].setEnabled(False)
                     self.delete_buttons[channel_index].setEnabled(False) 
 
+            try:
+                #if len(self.channel_data[channel_index].shape) == 4:
+                if 1 in self.channel_data[channel_index].shape:
+                    print("Removing singleton dimension (I am assuming this is a channel dimension?)")
+                    self.channel_data[channel_index] = np.squeeze(self.channel_data[channel_index])
+            except:
+                pass
+
             if len(self.channel_data[channel_index].shape) == 2:  # handle 2d data
                 self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
 
+            if self.channel_data[channel_index].dtype == np.bool_: #Promote boolean arrays if they somehow get loaded
+                self.channel_data[channel_index] = self.channel_data[channel_index].astype(np.uint8)
+
             try:
                 if len(self.channel_data[channel_index].shape) == 3:  # potentially 2D RGB
                     if self.channel_data[channel_index].shape[-1] in (3, 4):  # last dim is 3 or 4
@@ -4668,6 +4939,7 @@ class ImageViewerWindow(QMainWindow):
                             self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
             except:
                 pass
+
             
             try:
                 if len(self.channel_data[channel_index].shape) == 4 and (channel_index == 0 or channel_index == 1):
@@ -4748,8 +5020,13 @@ class ImageViewerWindow(QMainWindow):
             if all(not btn.isEnabled() for btn in self.channel_buttons[:channel_index]):
                 self.set_active_channel(channel_index)
 
-            if not self.channel_buttons[channel_index].isChecked():
-                self.channel_buttons[channel_index].click()
+            if self.chan_load:
+                if not self.channel_buttons[channel_index].isChecked():
+                    self.channel_buttons[channel_index].click()
+            else:
+                if self.channel_buttons[channel_index].isChecked():
+                    self.channel_buttons[channel_index].click()
+
             self.min_max[channel_index][0] = np.min(self.channel_data[channel_index])
             self.min_max[channel_index][1] = np.max(self.channel_data[channel_index])
             self.volume_dict[channel_index] = None #reset volumes
@@ -4849,7 +5126,7 @@ class ImageViewerWindow(QMainWindow):
             my_network.communities = None
 
             # Create empty DataFrame
-            empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+            empty_df = pd.DataFrame(columns=['Node A', 'Node B', 'Edge C'])
             
             # Clear network table
             self.network_table.setModel(PandasModel(empty_df))
@@ -6009,9 +6286,9 @@ class PandasModel(QAbstractTableModel):
         if data is None:
             # Create an empty DataFrame with default columns
             import pandas as pd
-            data = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+            data = pd.DataFrame(columns=['Node A', 'Node B', 'Edge C'])
         elif type(data) == list:
-            data = self.lists_to_dataframe(data[0], data[1], data[2], column_names=['Node 1A', 'Node 1B', 'Edge 1C'])
+            data = self.lists_to_dataframe(data[0], data[1], data[2], column_names=['Node A', 'Node B', 'Edge C'])
         self._data = data
         self.bold_cells = set()
         self.highlighted_cells = set()
@@ -6752,7 +7029,7 @@ class MergeNodeIdDialog(QDialog):
 
             self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
 
-            QMessageBox.critical(
+            QMessageBox.information(
                 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)"
@@ -7211,6 +7488,8 @@ class PartitionDialog(QDialog):
 
     def partition(self):
 
+        self.parent().prev_coms = None
+
         accepted_mode = self.mode_selector.currentIndex()
         weighted = self.weighted.isChecked()
         dostats = self.stats.isChecked()
@@ -7393,7 +7672,7 @@ class ComNeighborDialog(QDialog):
                 self.parent().format_for_upperright_table(matrix, 'NeighborhoodID', id_set, title = f'Neighborhood Heatmap {i + 1}')
 
 
-            self.parent().format_for_upperright_table(len_dict, 'NeighborhoodID', 'Proportion of Total Nodes', title = 'Neighborhood Counts')
+            self.parent().format_for_upperright_table(len_dict, 'NeighborhoodID', ['Number of Communities', 'Proportion of Total Nodes'], title = 'Neighborhood Counts')
             self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'NeighborhoodID', title = 'Neighborhood Partition')
 
             print("Neighborhoods have been assigned to communities based on similarity")
@@ -7435,6 +7714,8 @@ class ComCellDialog(QDialog):
 
         try:
 
+            self.parent().prev_coms = None
+
             size = float(self.size.text()) if self.size.text().strip() else None
             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
@@ -7596,6 +7877,16 @@ class NearNeighDialog(QDialog):
         heatmap_layout.addRow("Overlay:", self.numpy)
         
         main_layout.addWidget(heatmap_group)
+
+        quant_group = QGroupBox("Quantifiable Overlay")
+        quant_layout = QFormLayout(quant_group)
+
+        self.quant = QPushButton("Return quantifiable overlay? (Labels nodes by distance, good with intensity-thresholding to isolate targets. Requires labeled nodes image.)")
+        self.quant.setCheckable(True)
+        self.quant.setChecked(False)
+        quant_layout.addRow("Overlay:", self.quant)
+
+        main_layout.addWidget(quant_group)
         
         # Get Distribution group box
         distribution_group = QGroupBox("Get Distribution")
@@ -7643,6 +7934,7 @@ class NearNeighDialog(QDialog):
             threed = self.threed.isChecked()
             numpy = self.numpy.isChecked()
             num = int(self.num.text()) if self.num.text().strip() else 1
+            quant = self.quant.isChecked()
 
             if root is not None and targ is not None:
                 title = f"Nearest {num} Neighbor(s) Distance of {targ} from {root}"
@@ -7659,11 +7951,14 @@ class NearNeighDialog(QDialog):
                     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)
+                avg, output, quant_overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant)
             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)
+                avg, output, overlay, quant_overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True, quant = quant)
                 self.parent().load_channel(3, overlay, data = True)
 
+            if quant_overlay is not None:
+                self.parent().load_channel(2, quant_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)
 
@@ -7691,7 +7986,7 @@ class NearNeighDialog(QDialog):
 
                 for targ in available:
 
-                    avg, _ = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num)
+                    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
 
@@ -7781,52 +8076,86 @@ class NeighborIdentityDialog(QDialog):
 
 
 class RipleyDialog(QDialog):
-
     def __init__(self, parent=None):
-
         super().__init__(parent)
         self.setWindowTitle(f"Find Ripley's H Function From Centroids")
         self.setModal(True)
-
-        layout = QFormLayout(self)
-
+        
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        
+        # Node Parameters Group (only if node_identities exist)
         if my_network.node_identities is not None:
+            node_group = QGroupBox("Node Parameters")
+            node_layout = QFormLayout(node_group)
+            
             self.root = QComboBox()
             self.root.addItems(list(set(my_network.node_identities.values())))  
             self.root.setCurrentIndex(0)
-            layout.addRow("Root Identity to Search for Neighbors", self.root)
-        else:
-            self.root = None
-
-        if my_network.node_identities is not None:
+            node_layout.addRow("Root Identity to Search for Neighbors:", self.root)
+            
             self.targ = QComboBox()
             self.targ.addItems(list(set(my_network.node_identities.values())))  
             self.targ.setCurrentIndex(0)
-            layout.addRow("Targ Identity to be Searched For", self.targ)
+            node_layout.addRow("Target Identity to be Searched For:", self.targ)
+            
+            main_layout.addWidget(node_group)
         else:
+            self.root = None
             self.targ = None
-
+        
+        # Search Parameters Group
+        search_group = QGroupBox("Search Parameters")
+        search_layout = QFormLayout(search_group)
+        
         self.distance = QLineEdit("5")
-        layout.addRow("Bucket Distance for Searching For Clusters (automatically scaled by xy and z scales):", self.distance)
-
-
+        search_layout.addRow("1. Bucket Distance for Searching For Clusters\n(automatically scaled by xy and z scales):", self.distance)
+        
         self.proportion = QLineEdit("0.5")
-        layout.addRow("Proportion of image to search? (0-1, high vals increase border artifacts): ", self.proportion)
-
+        search_layout.addRow("2. Proportion of image to search?\n(0-1, high vals increase border artifacts):", self.proportion)
+        
+        main_layout.addWidget(search_group)
+        
+        # Border Safety Group
+        border_group = QGroupBox("Border Safety")
+        border_layout = QFormLayout(border_group)
+        
+        self.ignore = QPushButton("Ignore Border Roots")
+        self.ignore.setCheckable(True)
+        self.ignore.setChecked(True)
+        border_layout.addRow("3. Exclude Root Nodes Near Borders?:", self.ignore)
+        
+        self.factor = QLineEdit("0.5")
+        border_layout.addRow("4. (If param 3): Proportion of most internal nodes to use? (0 < n < 1) (Higher = more internal)?:", self.factor)
+        
+        self.mode = QComboBox()
+        self.mode.addItems(["Boundaries of Entire Image", "Boundaries of Edge Image Mask", 
+                           "Boundaries of Overlay1 Mask", "Boundaries of Overlay2 Mask"])
+        self.mode.setCurrentIndex(0)
+        border_layout.addRow("5. (If param 3): Define Boundaries How?:", self.mode)
+        
+        self.safe = QPushButton("Ignore Border Radii")
+        self.safe.setCheckable(True)
+        self.safe.setChecked(True)
+        border_layout.addRow("6. (If param 3): Keep search radii within border (overrides Param 2, also assigns volume to that of mask)?:", self.safe)
+        
+        main_layout.addWidget(border_group)
+        
+        # Experimental Border Safety Group
+        experimental_group = QGroupBox("Aggressive Border Safety (Creates duplicate centroids reflected across the image border - if you really need to search there for whatever reason - Not meant to be used if confining search to a masked object)")
+        experimental_layout = QFormLayout(experimental_group)
+        
         self.edgecorrect = QPushButton("Border Correction")
         self.edgecorrect.setCheckable(True)
         self.edgecorrect.setChecked(False)
-        layout.addRow("Use Border Correction (Extrapolate for points beyond the border):", self.edgecorrect)
-
-        self.ignore = QPushButton("Ignore Border Roots")
-        self.ignore.setCheckable(True)
-        self.ignore.setChecked(False)
-        layout.addRow("Exclude Root Nodes Near Borders?:", self.ignore)
-
+        experimental_layout.addRow("7. Use Border Correction\n(Extrapolate for points beyond the border):", self.edgecorrect)
+        
+        main_layout.addWidget(experimental_group)
+        
         # Add Run button
         run_button = QPushButton("Get Ripley's H")
         run_button.clicked.connect(self.ripley)
-        layout.addWidget(run_button)
+        main_layout.addWidget(run_button)
 
     def ripley(self):
 
@@ -7856,6 +8185,16 @@ class RipleyDialog(QDialog):
             except:
                 proportion = 0.5
 
+            try:
+                factor = abs(float(self.factor.text()))
+
+            except:
+                factor = 0.25
+
+            if factor > 1 or factor <= 0:
+                print("Utilizing factor = 0.25")
+                factor = 0.25
+
             if proportion > 1 or proportion <= 0:
                 print("Utilizing proportion = 0.5")
                 proportion = 0.5
@@ -7865,6 +8204,13 @@ class RipleyDialog(QDialog):
 
             ignore = self.ignore.isChecked()
 
+            safe = self.safe.isChecked()
+
+            mode = self.mode.currentIndex()
+
+            if mode == 0:
+                factor = factor/2 #The logic treats this as distance to border later, only if mode is 0, but its supposed to represent proportion internal.
+
             if my_network.nodes is not None:
 
                 if my_network.nodes.shape[0] == 1:
@@ -7874,7 +8220,7 @@ class RipleyDialog(QDialog):
             else:
                 bounds = None
 
-            r_vals, k_vals, h_vals = my_network.get_ripley(root, targ, distance, edgecorrect, bounds, ignore, proportion)
+            r_vals, k_vals, h_vals = my_network.get_ripley(root, targ, distance, edgecorrect, bounds, ignore, proportion, mode, safe, factor)
             
             k_dict = dict(zip(r_vals, k_vals))
             h_dict = dict(zip(r_vals, h_vals))
@@ -7887,6 +8233,9 @@ class RipleyDialog(QDialog):
             self.accept()
 
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
+
             QMessageBox.critical(
                 self,
                 "Error:",
@@ -8629,10 +8978,10 @@ class ResizeDialog(QDialog):
             else:
                 new_shape = tuple(int(dim * factor) for dim, factor in zip(array_shape, resize))
                 
-            if any(dim < 1 for dim in new_shape):
-                QMessageBox.critical(self, "Error", f"Resize would result in invalid dimensions: {new_shape}")
-                self.reset_fields()
-                return
+            #if any(dim < 1 for dim in new_shape):
+                #QMessageBox.critical(self, "Error", f"Resize would result in invalid dimensions: {new_shape}")
+                #self.reset_fields()
+                #return
 
             cubic = self.cubic.isChecked()
             order = 3 if cubic else 0
@@ -8706,7 +9055,12 @@ class ResizeDialog(QDialog):
                     centroids = copy.deepcopy(my_network.node_centroids)
                     if isinstance(resize, (int, float)):
                         for item in my_network.node_centroids:
-                            centroids[item] = np.round((my_network.node_centroids[item]) * resize)
+                            try:
+                                centroids[item] = np.round((my_network.node_centroids[item]) * resize)
+                            except:
+                                temp = np.array(my_network.node_centroids[item])
+                                centroids[item] = np.round((temp) * resize)
+
                     else:
                         for item in my_network.node_centroids:
                             centroids[item][0] = int(np.round((my_network.node_centroids[item][0]) * resize[0]))
@@ -9188,13 +9542,14 @@ class ThresholdDialog(QDialog):
 
 class ExcelotronManager(QObject):
     # Signal to emit when data is received from Excelotron
-    data_received = pyqtSignal(dict, str)  # dictionary, property_name
+    data_received = pyqtSignal(dict, str, bool)  # dictionary, property_name
     
     def __init__(self, parent=None):
         super().__init__(parent)
         self.excelotron_window = None
         self.last_data = None
         self.last_property = None
+        self.last_add = None
     
     def launch(self):
         """Launch the Excelotron window"""
@@ -9243,12 +9598,13 @@ class ExcelotronManager(QObject):
         is_open = self.excelotron_window is not None
         return is_open
     
-    def _on_data_exported(self, data_dict, property_name):
+    def _on_data_exported(self, data_dict, property_name, add):
         """Internal slot to handle data from Excelotron"""
         self.last_data = data_dict
         self.last_property = property_name
+        self.last_add = add
         # Re-emit the signal for parent to handle
-        self.data_received.emit(data_dict, property_name)
+        self.data_received.emit(data_dict, property_name, add)
     
     def _on_window_destroyed(self):
         """Handle when the Excelotron window is destroyed/closed"""
@@ -9256,7 +9612,7 @@ class ExcelotronManager(QObject):
     
     def get_last_data(self):
         """Get the last exported data"""
-        return self.last_data, self.last_property
+        return self.last_data, self.last_property, self.last_add
 
 class MachineWindow(QMainWindow):
 
@@ -10780,7 +11136,7 @@ class MaskDialog(QDialog):
 
 class CropDialog(QDialog):
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, args = None):
 
         try:
 
@@ -10788,18 +11144,26 @@ class CropDialog(QDialog):
             self.setWindowTitle("Crop Image (Will transpose any centroids)?")
             self.setModal(True)
 
+            if args is None:
+                xmin = 0
+                xmax = self.parent().shape[2]
+                ymin = 0
+                ymax = self.parent().shape[1]
+            else:
+                xmin, xmax, ymin, ymax = args
+
             layout = QFormLayout(self)
 
-            self.xmin = QLineEdit("0")
+            self.xmin = QLineEdit(f"{xmin}")
             layout.addRow("X Min", self.xmin)
 
-            self.xmax = QLineEdit(f"{self.parent().shape[2]}")
+            self.xmax = QLineEdit(f"{xmax}")
             layout.addRow("X Max", self.xmax)
 
-            self.ymin = QLineEdit("0")
+            self.ymin = QLineEdit(f"{ymin}")
             layout.addRow("Y Min", self.ymin)
 
-            self.ymax = QLineEdit(f"{self.parent().shape[1]}")
+            self.ymax = QLineEdit(f"{ymax}")
             layout.addRow("Y Max", self.ymax)
 
             self.zmin = QLineEdit("0")
@@ -10853,10 +11217,16 @@ class CropDialog(QDialog):
                     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)
+                    # Create upper bounds array with same shape
+                    upper_bounds = np.array([zmax - zmin, ymax - ymin, xmax - xmin])
+                    
+                    # Boolean mask for valid coordinates - check each dimension separately
+                    z_valid = (transformed[:, 0] >= 0) & (transformed[:, 0] <= upper_bounds[0])
+                    y_valid = (transformed[:, 1] >= 0) & (transformed[:, 1] <= upper_bounds[1])
+                    x_valid = (transformed[:, 2] >= 0) & (transformed[:, 2] <= upper_bounds[2])
                     
+                    valid_mask = z_valid & y_valid & x_valid
+
                     # 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])]
@@ -10865,6 +11235,15 @@ class CropDialog(QDialog):
                     
                     self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
 
+                if my_network.node_identities is not None:
+                    new_idens = {}
+                    for node, iden in my_network.node_identities.items():
+                        if node in my_network.node_centroids:
+                            new_idens[node] = iden
+                    my_network.node_identities = new_idens
+
+                    self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+
             except Exception as e:
 
                 print(f"Error transposing node centroids: {e}")
@@ -11058,6 +11437,74 @@ class SkeletonizeDialog(QDialog):
                 f"Error running skeletonize: {str(e)}"
             )   
 
+class DistanceDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Compute Distance Transform (Applies xy and z scaling, set them to 1 if you want voxel correspondence)?")
+        self.setModal(True)
+        
+        layout = QFormLayout(self)
+
+        # Add Run button
+        run_button = QPushButton("Run")
+        run_button.clicked.connect(self.run)
+        layout.addRow(run_button)
+
+    def run(self):
+
+        try:
+
+            data = self.parent().channel_data[self.parent().active_channel]
+
+            data = sdl.compute_distance_transform_distance(data, sampling = [my_network.z_scale, my_network.xy_scale, my_network.xy_scale])
+
+            self.parent().load_channel(self.parent().active_channel, data, data = True)
+
+        except Exception as e:
+
+            print(f"Error: {e}")
+
+class GrayWaterDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle(f"Gray Watershed - Please segment out your background first (ie with intensity thresholding) or this will not work correctly. \nAt the moment, this is designed for similarly sized objects. Having mixed large/small objects may not work correctly.")
+        self.setModal(True)
+        
+        layout = QFormLayout(self)
+
+        self.min_peak_distance = QLineEdit("1")
+        layout.addRow("Minimum Peak Distance (To any other peak - Recommended) (This is true voxel distance here)", self.min_peak_distance)
+
+        # Minimum Intensity
+        self.min_intensity = QLineEdit("")
+        layout.addRow("Minimum Peak Intensity (Optional):", self.min_intensity)
+
+        # Add Run button
+        run_button = QPushButton("Run Watershed")
+        run_button.clicked.connect(self.run_watershed)
+        layout.addRow(run_button)
+
+    def run_watershed(self):
+
+        try:
+
+            min_intensity = float(self.min_intensity.text()) if self.min_intensity.text().strip() else None
+
+            min_peak_distance = int(self.min_peak_distance.text()) if self.min_peak_distance.text().strip() else 1
+
+            data = self.parent().channel_data[self.parent().active_channel]
+
+            data = n3d.gray_watershed(data, min_peak_distance, min_intensity)
+
+            self.parent().load_channel(self.parent().active_channel, data, data = True)
+
+            self.accept()
+
+        except Exception as e:
+            print(f"Error: {e}")
+
+
+
 
 class WatershedDialog(QDialog):
     def __init__(self, parent=None):
@@ -11084,10 +11531,14 @@ class WatershedDialog(QDialog):
         except:
             self.default = 0.05
 
+        # Smallest radius (empty by default)
+        self.smallest_rad = QLineEdit()
+        self.smallest_rad.setPlaceholderText("Leave empty for None")
+        layout.addRow(f"Smallest Radius (Objects any smaller may get thresholded out - this value always overrides below 'proportion' param). \n Somewhat more intuitive param then below, use a conservative value a bit smaller than your smallest object's radius:", self.smallest_rad)
         
         # Proportion (default 0.1)
         self.proportion = QLineEdit(f"{self.default}")
-        layout.addRow("Proportion:", self.proportion)
+        layout.addRow(f"Proportion (0-1) of distance transform value set [ie unique elements] to exclude (ie 0.2 = 20% of the set of all values of the distance transform get excluded).\n Essentially, vals closer to 0 are less likely to split objects but also won't kick out small objects from the output, vals slightly further from 0 will split more aggressively, but vals closer to 1 become unstable, leading to objects being evicted or labelling errors. \nRecommend something between 0.05 and 0.4, but it depends on the data (Or just enter a smallest radius above to avoid using this). \nWill tell you in command window what equivalent 'smallest radius' this is):", self.proportion)
         
         # GPU checkbox (default True)
         self.gpu = QPushButton("GPU")
@@ -11095,10 +11546,6 @@ class WatershedDialog(QDialog):
         self.gpu.setChecked(False)
         layout.addRow("Use GPU:", self.gpu)
         
-        # Smallest radius (empty by default)
-        self.smallest_rad = QLineEdit()
-        self.smallest_rad.setPlaceholderText("Leave empty for None")
-        layout.addRow("Smallest Radius:", self.smallest_rad)
         
         # Predownsample (empty by default)
         self.predownsample = QLineEdit()
@@ -11106,11 +11553,11 @@ class WatershedDialog(QDialog):
         layout.addRow("Kernel Obtainment GPU Downsample:", self.predownsample)
         
         # Predownsample2 (empty by default)
-        self.predownsample2 = QLineEdit()
-        self.predownsample2.setPlaceholderText("Leave empty for None")
-        layout.addRow("Smart Label GPU Downsample:", self.predownsample2)
+        #self.predownsample2 = QLineEdit()
+        #self.predownsample2.setPlaceholderText("Leave empty for None")
+        #layout.addRow("Smart Label GPU Downsample:", self.predownsample2)
         
-        layout.addRow("Note:", QLabel(f"If the optimal proportion watershed output is still labeling spatially seperated objects with the same label, try right placing the result in nodes or edges\nthen right click the image and choose 'select all', followed by right clicking and 'selection' -> 'split non-touching labels'."))
+        #layout.addRow("Note:", QLabel(f"If the optimal proportion watershed output is still labeling spatially seperated objects with the same label, try right placing the result in nodes or edges\nthen right click the image and choose 'select all', followed by right clicking and 'selection' -> 'split non-touching labels'."))
 
 
         # Add Run button
@@ -11147,7 +11594,7 @@ class WatershedDialog(QDialog):
             # Get predownsample2 (None if empty)
             try:
                 predownsample2 = float(self.predownsample2.text()) if self.predownsample2.text() else None
-            except ValueError:
+            except:
                 predownsample2 = None
             
             # Get the active channel data from parent
@@ -11325,7 +11772,22 @@ class CentroidNodeDialog(QDialog):
 
             if mode == 0:
 
-                my_network.nodes = my_network.centroid_array()
+                try:
+                    shape = my_network.nodes.shape
+
+                except:
+                    try:
+                        shape = my_network.edges.shape
+                    except:
+                        try:
+                            shape = my_network.network_overlay.shape
+                        except:
+                            try:
+                                shape = my_network.id_overlay.shape
+                            except:
+                                shape = None
+
+                my_network.nodes = my_network.centroid_array(shape = shape)
 
             else:
 
@@ -11439,7 +11901,7 @@ class GenNodesDialog(QDialog):
         
         # Component dilation
         self.comp_dil = QLineEdit("0")
-        opt_layout.addWidget(QLabel("Voxel distance to merge nearby nodes (Compensates for multi-branch regions):"), 1, 0)
+        opt_layout.addWidget(QLabel("Amount to expand nodes (Merges nearby nodes, say if they are overassigned, good for broader branch breaking):"), 1, 0)
         opt_layout.addWidget(self.comp_dil, 1, 1)
         
         opt_group.setLayout(opt_layout)
@@ -11573,11 +12035,11 @@ class GenNodesDialog(QDialog):
 
 class BranchDialog(QDialog):
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, called = False):
         super().__init__(parent)
         self.setWindowTitle("Label Branches (of edges)")
         self.setModal(True)
-        
+
         # Main layout
         main_layout = QVBoxLayout(self)
         
@@ -11610,7 +12072,10 @@ class BranchDialog(QDialog):
 
         self.fix3 = QPushButton("Split Nontouching Branches?")
         self.fix3.setCheckable(True)
-        self.fix3.setChecked(True)
+        if called:
+            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(self.fix3, 4, 1)
         
@@ -12137,6 +12602,8 @@ class CentroidDialog(QDialog):
 
         try:
 
+            print("Calculating centroids...")
+
             chan = self.mode_selector.currentIndex()
 
             # Get directory (None if empty)
@@ -12499,6 +12966,9 @@ class CalcAllDialog(QDialog):
 
             
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
+
             QMessageBox.critical(
                 self,
                 "Error",
@@ -12506,6 +12976,7 @@ class CalcAllDialog(QDialog):
             )
 
 
+
 class ProxDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
@@ -12744,11 +13215,6 @@ class ProxDialog(QDialog):
 
 
 
-
-
-
-
-
 # Initiating this program from the script line:
 
 def run_gui():