nettracer3d 0.9.9__py3-none-any.whl → 1.1.5__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -4,7 +4,7 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QG
                             QHBoxLayout, QSlider, QMenuBar, QMenu, QDialog, 
                             QFormLayout, QLineEdit, QPushButton, QFileDialog,
                             QLabel, QComboBox, QMessageBox, QTableView, QInputDialog,
-                            QMenu, QTabWidget, QGroupBox)
+                            QMenu, QTabWidget, QGroupBox, QCheckBox)
 from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal, QObject, QCoreApplication, QEvent, QEventLoop)
 import numpy as np
 import time
@@ -36,6 +36,7 @@ from threading import Lock
 from scipy import ndimage
 import os
 from . import painting
+from . import stats as net_stats
 
 
 
@@ -183,6 +184,12 @@ class ImageViewerWindow(QMainWindow):
             3: None
         }
 
+        self.branch_dict = {
+            0: None,
+            1: None
+
+        }
+
         self.original_shape = None #For undoing resamples
         
         # Create control panel
@@ -425,8 +432,6 @@ class ImageViewerWindow(QMainWindow):
         self.canvas.mpl_connect('button_release_event', self.on_mouse_release)
         self.canvas.mpl_connect('motion_notify_event', self.on_mouse_move)
 
-        #self.canvas.mpl_connect('button_press_event', self.on_mouse_click)
-
         # Initialize measurement tracking
         self.measurement_points = []  # List to store point pairs
         self.angle_measurements = []  # NEW: List to store angle trios
@@ -462,9 +467,8 @@ class ImageViewerWindow(QMainWindow):
         self.last_paint_pos = None
 
         self.resume = False
-
-        self.hold_update = False
         self._first_pan_done = False
+        self.thresh_window_ref = None
 
 
     def load_file(self):
@@ -511,12 +515,8 @@ class ImageViewerWindow(QMainWindow):
                 data = df.iloc[:, 0].tolist()  # First column as list
                 value = None
                 
-                self.format_for_upperright_table(
-                    data=data,
-                    metric=metric,
-                    value=value,
-                    title=title
-                )
+                df = self.format_for_upperright_table(data=data, metric=metric, value=value, title=title)
+                return df
             else:
                 # Multiple columns: create dictionary as before
                 # First column header (for metric parameter)
@@ -542,12 +542,8 @@ class ImageViewerWindow(QMainWindow):
                     value = value[0]
                 
                 # Call the parent method
-                self.format_for_upperright_table(
-                    data=data_dict,
-                    metric=metric,
-                    value=value,
-                    title=title
-                )
+                df = self.format_for_upperright_table(data=data_dict, metric=metric, value=value, title=title)
+                return df
             
             QMessageBox.information(
                 self,
@@ -887,6 +883,21 @@ class ImageViewerWindow(QMainWindow):
         elif self.scroll_direction > 0 and new_value <= self.slice_slider.maximum():
             self.slice_slider.setValue(new_value)
 
+
+    def confirm_mini_thresh(self):
+
+        if self.shape[0] * self.shape[1] * self.shape[2] > self.mini_thresh:
+            self.mini_overlay = True
+            return True
+        else:
+            return False
+
+    def evaluate_mini(self, mode = 'nodes'):
+        if self.confirm_mini_thresh():
+            self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+        else:
+            self.create_highlight_overlay(node_indices=self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+
     def create_highlight_overlay(self, node_indices=None, edge_indices=None, overlay1_indices = None, overlay2_indices = None, bounds = False):
         """
         Create a binary overlay highlighting specific nodes and/or edges using parallel processing.
@@ -1012,13 +1023,13 @@ class ImageViewerWindow(QMainWindow):
             
         # Combine results
         if node_overlay is not None:
-            self.highlight_overlay = np.maximum(self.highlight_overlay, node_overlay)
+            self.highlight_overlay = np.maximum(self.highlight_overlay, node_overlay).astype(np.uint8)
         if edge_overlay is not None:
-            self.highlight_overlay = np.maximum(self.highlight_overlay, edge_overlay)
+            self.highlight_overlay = np.maximum(self.highlight_overlay, edge_overlay).astype(np.uint8)
         if overlay1_overlay is not None:
-            self.highlight_overlay = np.maximum(self.highlight_overlay, overlay1_overlay)
+            self.highlight_overlay = np.maximum(self.highlight_overlay, overlay1_overlay).astype(np.uint8)
         if overlay2_overlay is not None:
-            self.highlight_overlay = np.maximum(self.highlight_overlay, overlay2_overlay)
+            self.highlight_overlay = np.maximum(self.highlight_overlay, overlay2_overlay).astype(np.uint8)
         
         # Update display
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -1027,6 +1038,8 @@ class ImageViewerWindow(QMainWindow):
 
         """Highlight overlay generation method specific for the segmenter interactive mode"""
 
+        self.mini_overlay_data = None
+        self.highlight_overlay = None
 
         def process_chunk_bounds(chunk_data, indices_to_check):
             """Process a single chunk of the array to create highlight mask"""
@@ -1106,6 +1119,30 @@ class ImageViewerWindow(QMainWindow):
             current_ylim = self.ax.get_ylim()
             self.update_display_pan_mode(current_xlim, current_ylim)
 
+        if my_network.network is not None:
+            try:
+                if self.active_channel == 0:
+
+                    # Get the existing DataFrame from the model
+                    original_df = self.network_table.model()._data
+                    
+                    # Create mask for rows where one column is any original node AND the other column is any neighbor
+                    mask = (
+                        (original_df.iloc[:, 0].isin(indices)) &
+                        (original_df.iloc[:, 1].isin(indices)))
+                    
+                    # Filter the DataFrame to only include direct connections
+                    filtered_df = original_df[mask].copy()
+                    
+                    # Create new model with filtered DataFrame and update selection table
+                    new_model = PandasModel(filtered_df)
+                    self.selection_table.setModel(new_model)
+                    
+                    # Switch to selection table
+                    self.selection_button.click()
+            except:
+                pass
+
 
 
     def create_mini_overlay(self, node_indices = None, edge_indices = None):
@@ -1265,7 +1302,9 @@ class ImageViewerWindow(QMainWindow):
 
                 if my_network.node_identities is not None:
                     identity_menu = QMenu("Show Identity", self)
-                    for item in set(my_network.node_identities.values()):
+                    idens = list(set(my_network.node_identities.values()))
+                    idens.sort()
+                    for item in idens:
                         show_identity = identity_menu.addAction(f"ID: {item}")
                         show_identity.triggered.connect(lambda checked, item=item: self.handle_show_identities(sort=item))
                     context_menu.addMenu(identity_menu)
@@ -1274,6 +1313,9 @@ class ImageViewerWindow(QMainWindow):
                 select_nodes = select_all_menu.addAction("Nodes")
                 select_both = select_all_menu.addAction("Nodes + Edges")
                 select_edges = select_all_menu.addAction("Edges")
+                select_net_nodes = select_all_menu.addAction("Nodes in Network")
+                select_net_both = select_all_menu.addAction("Nodes + Edges in Network")
+                select_net_edges = select_all_menu.addAction("Edges in Network")
                 context_menu.addMenu(select_all_menu)
 
                 if len(self.clicked_values['nodes']) > 0 or len(self.clicked_values['edges']) > 0:
@@ -1297,32 +1339,40 @@ class ImageViewerWindow(QMainWindow):
                 # Create measurement submenu
                 measure_menu = context_menu.addMenu("Measurements")
                 
-                # Distance measurement options
                 distance_menu = measure_menu.addMenu("Distance")
                 if self.current_point is None:
                     show_point_menu = distance_menu.addAction("Place First Point")
                     show_point_menu.triggered.connect(
                         lambda: self.place_distance_point(x_idx, y_idx, self.current_slice))
-                else:
+                elif (self.current_point is not None and 
+                      hasattr(self, 'measurement_mode') and 
+                      self.measurement_mode == "distance"):
                     show_point_menu = distance_menu.addAction("Place Second Point")
                     show_point_menu.triggered.connect(
                         lambda: self.place_distance_point(x_idx, y_idx, self.current_slice))
-                
+
                 # Angle measurement options
                 angle_menu = measure_menu.addMenu("Angle")
                 if self.current_point is None:
                     angle_first = angle_menu.addAction("Place First Point (A)")
                     angle_first.triggered.connect(
                         lambda: self.place_angle_point(x_idx, y_idx, self.current_slice))
-                elif self.current_second_point is None:
+                elif (self.current_point is not None and 
+                      self.current_second_point is None and 
+                      hasattr(self, 'measurement_mode') and 
+                      self.measurement_mode == "angle"):
                     angle_second = angle_menu.addAction("Place Second Point (B - Vertex)")
                     angle_second.triggered.connect(
                         lambda: self.place_angle_point(x_idx, y_idx, self.current_slice))
-                else:
+                elif (self.current_point is not None and 
+                      self.current_second_point is not None and 
+                      hasattr(self, 'measurement_mode') and 
+                      self.measurement_mode == "angle"):
                     angle_third = angle_menu.addAction("Place Third Point (C)")
                     angle_third.triggered.connect(
                         lambda: self.place_angle_point(x_idx, y_idx, self.current_slice))
                 
+                
                 show_remove_menu = measure_menu.addAction("Remove All Measurements")
                 show_remove_menu.triggered.connect(self.handle_remove_all_measurements)
                 
@@ -1340,6 +1390,9 @@ class ImageViewerWindow(QMainWindow):
                 select_nodes.triggered.connect(lambda: self.handle_select_all(edges = False, nodes = True))
                 select_both.triggered.connect(lambda: self.handle_select_all(edges = True))
                 select_edges.triggered.connect(lambda: self.handle_select_all(edges = True, nodes = False))
+                select_net_nodes.triggered.connect(lambda: self.handle_select_all(edges = False, nodes = True, network = True))
+                select_net_both.triggered.connect(lambda: self.handle_select_all(edges = True, network = True))
+                select_net_edges.triggered.connect(lambda: self.handle_select_all(edges = True, nodes = False, network = True))
                 if self.highlight_overlay is not None or self.mini_overlay_data is not None:
                     highlight_select = context_menu.addAction("Add highlight in network selection")
                     highlight_select.triggered.connect(self.handle_highlight_select)
@@ -1350,15 +1403,22 @@ class ImageViewerWindow(QMainWindow):
             except IndexError:
                 pass
 
-
     def place_distance_point(self, x, y, z):
         """Place a measurement point for distance measurement."""
         if self.current_point is None:
             # This is the first point
             self.current_point = (x, y, z)
-            self.ax.plot(x, y, 'yo', markersize=8)
-            self.ax.text(x, y+5, f"D{self.current_pair_index}", 
+            
+            # Create and store the artists
+            pt = self.ax.plot(x, y, 'yo', markersize=8)[0]
+            txt = self.ax.text(x, y+5, f"D{self.current_pair_index}", 
                         color='yellow', ha='center', va='bottom')
+            
+            # Add to measurement_artists so they can be managed by update_display
+            if not hasattr(self, 'measurement_artists'):
+                self.measurement_artists = []
+            self.measurement_artists.extend([pt, txt])
+            
             self.canvas.draw()
             self.measurement_mode = "distance"
         else:
@@ -1372,21 +1432,28 @@ class ImageViewerWindow(QMainWindow):
                               ((z2-z1)*my_network.z_scale)**2)
             distance2 = np.sqrt(((x2-x1))**2 + ((y2-y1))**2 + ((z2-z1))**2)
             
-            # Store the point pair
+            # Store the point pair with type indicator
             self.measurement_points.append({
                 'pair_index': self.current_pair_index,
                 'point1': self.current_point,
                 'point2': (x2, y2, z2),
                 'distance': distance,
-                'distance2': distance2
+                'distance2': distance2,
+                'type': 'distance'  # Added type tracking
             })
             
-            # Draw second point and line
-            self.ax.plot(x2, y2, 'yo', markersize=8)
-            self.ax.text(x2, y2+5, f"D{self.current_pair_index}", 
+            # Draw second point and line, storing the artists
+            pt2 = self.ax.plot(x2, y2, 'yo', markersize=8)[0]
+            txt2 = self.ax.text(x2, y2+5, f"D{self.current_pair_index}", 
                         color='yellow', ha='center', va='bottom')
+            
+            # Add to measurement_artists
+            self.measurement_artists.extend([pt2, txt2])
+            
             if z1 == z2:  # Only draw line if points are on same slice
-                self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
+                line = self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)[0]
+                self.measurement_artists.append(line)
+                
             self.canvas.draw()
             
             # Update measurement display
@@ -1399,12 +1466,19 @@ class ImageViewerWindow(QMainWindow):
 
     def place_angle_point(self, x, y, z):
         """Place a measurement point for angle measurement."""
+        if not hasattr(self, 'measurement_artists'):
+            self.measurement_artists = []
+            
         if self.current_point is None:
             # First point (A)
             self.current_point = (x, y, z)
-            self.ax.plot(x, y, 'go', markersize=8)
-            self.ax.text(x, y+5, f"A{self.current_trio_index}", 
+            
+            # Create and store artists
+            pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+            txt = self.ax.text(x, y+5, f"A{self.current_trio_index}", 
                         color='green', ha='center', va='bottom')
+            self.measurement_artists.extend([pt, txt])
+            
             self.canvas.draw()
             self.measurement_mode = "angle"
             
@@ -1413,13 +1487,16 @@ class ImageViewerWindow(QMainWindow):
             self.current_second_point = (x, y, z)
             x1, y1, z1 = self.current_point
             
-            self.ax.plot(x, y, 'go', markersize=8)
-            self.ax.text(x, y+5, f"B{self.current_trio_index}", 
+            # Create and store artists
+            pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+            txt = self.ax.text(x, y+5, f"B{self.current_trio_index}", 
                         color='green', ha='center', va='bottom')
+            self.measurement_artists.extend([pt, txt])
             
             # Draw line from A to B
             if z1 == z:
-                self.ax.plot([x1, x], [y1, y], 'g--', alpha=0.7)
+                line = self.ax.plot([x1, x], [y1, y], 'g--', alpha=0.7)[0]
+                self.measurement_artists.append(line)
             self.canvas.draw()
             
         else:
@@ -1442,7 +1519,7 @@ class ImageViewerWindow(QMainWindow):
                 **angle_data
             })
             
-            # Also add the two distances as separate pairs
+            # Also add the two distances as separate pairs with type indicator
             dist_ab = np.sqrt(((x2-x1)*my_network.xy_scale)**2 + 
                              ((y2-y1)*my_network.xy_scale)**2 + 
                              ((z2-z1)*my_network.z_scale)**2)
@@ -1459,24 +1536,28 @@ class ImageViewerWindow(QMainWindow):
                     'point1': (x1, y1, z1),
                     'point2': (x2, y2, z2),
                     'distance': dist_ab,
-                    'distance2': dist_ab_voxel
+                    'distance2': dist_ab_voxel,
+                    'type': 'angle'  # Added type tracking
                 },
                 {
                     'pair_index': f"B{self.current_trio_index}-C{self.current_trio_index}",
                     'point1': (x2, y2, z2),
                     'point2': (x3, y3, z3),
                     'distance': dist_bc,
-                    'distance2': dist_bc_voxel
+                    'distance2': dist_bc_voxel,
+                    'type': 'angle'  # Added type tracking
                 }
             ])
             
-            # Draw third point and line
-            self.ax.plot(x3, y3, 'go', markersize=8)
-            self.ax.text(x3, y3+5, f"C{self.current_trio_index}", 
+            # Draw third point and line, storing artists
+            pt3 = self.ax.plot(x3, y3, 'go', markersize=8)[0]
+            txt3 = self.ax.text(x3, y3+5, f"C{self.current_trio_index}", 
                         color='green', ha='center', va='bottom')
+            self.measurement_artists.extend([pt3, txt3])
             
             if z2 == z3:  # Draw line from B to C if on same slice
-                self.ax.plot([x2, x3], [y2, y3], 'g--', alpha=0.7)
+                line = self.ax.plot([x2, x3], [y2, y3], 'g--', alpha=0.7)[0]
+                self.measurement_artists.append(line)
             self.canvas.draw()
             
             # Update measurement display
@@ -1488,6 +1569,7 @@ class ImageViewerWindow(QMainWindow):
             self.current_trio_index += 1
             self.measurement_mode = "angle"
 
+
     def calculate_3d_angle(self, point_a, point_b, point_c):
         """Calculate 3D angle at vertex B between points A-B-C."""
         x1, y1, z1 = point_a
@@ -1651,28 +1733,12 @@ class ImageViewerWindow(QMainWindow):
                 if edges:
                     edge_indices = filtered_df.iloc[:, 2].unique().tolist()
                     self.clicked_values['edges'] = edge_indices
-
-                    if self.channel_data[1].shape[0] * self.channel_data[1].shape[1] * self.channel_data[1].shape[2] > self.mini_thresh:
-                        self.mini_overlay = True
-                        self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-                    else:
-                        self.create_highlight_overlay(
-                            node_indices=self.clicked_values['nodes'], 
-                            edge_indices=self.clicked_values['edges']
-                        )
+                    self.evaluate_mini(mode = 'edges')
                 else:
-                    if self.channel_data[0].shape[0] * self.channel_data[0].shape[1] * self.channel_data[0].shape[2] > self.mini_thresh:
-                        self.mini_overlay = True
-                        self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-                    else:
-                        self.create_highlight_overlay(
-                            node_indices=self.clicked_values['nodes'],
-                            edge_indices = self.clicked_values['edges']
-                    )
-            
+                    self.evaluate_mini()
                 
         except Exception as e:
-            print(f"Error processing neighbors: {e}")
+            print(f"Error showing neighbors: {e}")
 
     
     def handle_show_component(self, edges = False, nodes = True):
@@ -1743,23 +1809,10 @@ class ImageViewerWindow(QMainWindow):
             if edges:
                 edge_indices = filtered_df.iloc[:, 2].unique().tolist()
                 self.clicked_values['edges'] = edge_indices
-                if self.channel_data[1].shape[0] * self.channel_data[1].shape[1] * self.channel_data[1].shape[2] > self.mini_thresh:
-                    self.mini_overlay = True
-                    self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-                else:
-                    self.create_highlight_overlay(
-                        node_indices=self.clicked_values['nodes'],
-                        edge_indices=edge_indices
-                    )
+                self.evaluate_mini(mode = 'edges')
             else:
-                if self.channel_data[0].shape[0] * self.channel_data[0].shape[1] * self.channel_data[0].shape[2] > self.mini_thresh:
-                    self.mini_overlay = True
-                    self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-                else:
-                    self.create_highlight_overlay(
-                        node_indices = self.clicked_values['nodes'],
-                        edge_indices = self.clicked_values['edges']
-                )
+                self.evaluate_mini()
+
 
         except Exception as e:
 
@@ -1802,23 +1855,27 @@ class ImageViewerWindow(QMainWindow):
 
                 nodes = list(set(nodes))
 
-                # Get the existing DataFrame from the model
-                original_df = self.network_table.model()._data
+                try:
 
-                # Create mask for rows for nodes in question
-                mask = (
-                    (original_df.iloc[:, 0].isin(nodes) & original_df.iloc[:, 1].isin(nodes))
-                    )
-                
-                # Filter the DataFrame to only include direct connections
-                filtered_df = original_df[mask].copy()
-                
-                # Create new model with filtered DataFrame and update selection table
-                new_model = PandasModel(filtered_df)
-                self.selection_table.setModel(new_model)
-                
-                # Switch to selection table
-                self.selection_button.click()
+                    # Get the existing DataFrame from the model
+                    original_df = self.network_table.model()._data
+
+                    # Create mask for rows for nodes in question
+                    mask = (
+                        (original_df.iloc[:, 0].isin(nodes) & original_df.iloc[:, 1].isin(nodes))
+                        )
+                    
+                    # Filter the DataFrame to only include direct connections
+                    filtered_df = original_df[mask].copy()
+                    
+                    # Create new model with filtered DataFrame and update selection table
+                    new_model = PandasModel(filtered_df)
+                    self.selection_table.setModel(new_model)
+                    
+                    # Switch to selection table
+                    self.selection_button.click()
+                except:
+                    pass
 
                 if edges:
                     edge_indices = filtered_df.iloc[:, 2].unique().tolist()
@@ -1951,7 +2008,7 @@ class ImageViewerWindow(QMainWindow):
                                 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]}")
+                            print(f"Found edge {value} at [Z,Y,X] -> {centroid}")
 
                         else:
                             print(f"Edge {value} not found in centroids dictionary")
@@ -1987,9 +2044,9 @@ class ImageViewerWindow(QMainWindow):
                             # Navigate to the Z-slice
                             self.parent().slice_slider.setValue(int(centroid[0]))
                             if mode == 0:
-                                print(f"Found node {value} at Z-slice {centroid[0]}")
+                                print(f"Found node {value} at [Z,Y,X] -> {centroid}")
                             elif mode == 2:
-                                print(f"Found node {value} from community {com} at Z-slice {centroid[0]}")
+                                print(f"Found node {value} from community {com} at [Z,Y,X] -> {centroid}")
 
                             
                         else:
@@ -2020,12 +2077,15 @@ class ImageViewerWindow(QMainWindow):
 
 
 
-    def handle_select_all(self, nodes = True, edges = False):
+    def handle_select_all(self, nodes = True, edges = False, network = False):
 
         try:
 
             if nodes:
-                nodes = list(np.unique(my_network.nodes))
+                if not network:
+                    nodes = list(np.unique(my_network.nodes))
+                else:
+                    nodes = list(set(my_network.network_lists[0] + my_network.network_lists[1]))
                 if nodes[0] == 0:
                     del nodes[0]
                 num = (self.channel_data[0].shape[0] * self.channel_data[0].shape[1] * self.channel_data[0].shape[2])
@@ -2033,7 +2093,10 @@ class ImageViewerWindow(QMainWindow):
             else:
                 nodes = []
             if edges:
-                edges = list(np.unique(my_network.edges))
+                if not network:
+                    edges = list(np.unique(my_network.edges))
+                else:
+                    edges = my_network.network_lists[2]
                 num = (self.channel_data[1].shape[0] * self.channel_data[1].shape[1] * self.channel_data[1].shape[2])
                 if edges[0] == 0:
                     del edges[0]
@@ -2111,6 +2174,16 @@ class ImageViewerWindow(QMainWindow):
                     except:
                         pass
 
+                if self.branch_dict[0] is not None:
+                    try:
+                        info_dict['Branch Length'] = self.branch_dict[0][0][label]
+                    except:
+                        pass
+                    try:
+                        info_dict['Branch Tortuosity'] = self.branch_dict[0][1][label]
+                    except:
+                        pass
+
 
             elif sort == 'edge':
 
@@ -2156,7 +2229,17 @@ class ImageViewerWindow(QMainWindow):
                     except:
                         pass
 
-            self.format_for_upperright_table(info_dict, title = f'Info on Object')
+                if self.branch_dict[1] is not None:
+                    try:
+                        info_dict['Branch Length'] = self.branch_dict[1][0][label]
+                    except:
+                        pass
+                    try:
+                        info_dict['Branch Tortuosity'] = self.branch_dict[1][1][label]
+                    except:
+                        pass
+
+            self.format_for_upperright_table(info_dict, title = f'Info on Object', sort = False)
 
         except:
             pass
@@ -2274,7 +2357,7 @@ class ImageViewerWindow(QMainWindow):
         unique_labels = np.unique(input_array[binary_mask])
         print(f"Processing {len(unique_labels)} unique labels")
         
-        # Get all bounding boxes at once - this is very fast
+        # Get all bounding boxes at once
         bounding_boxes = ndimage.find_objects(input_array)
         
         # Prepare work items - just check if bounding box exists for each label
@@ -2290,7 +2373,7 @@ class ImageViewerWindow(QMainWindow):
                 bbox = bounding_boxes[bbox_index]
                 work_items.append((orig_label, bbox))
         
-        print(f"Created {len(work_items)} work items")
+        #print(f"Created {len(work_items)} work items")
         
         # If we have work items, process them
         if len(work_items) == 0:
@@ -2310,7 +2393,7 @@ class ImageViewerWindow(QMainWindow):
                 return orig_label, bbox, labeled_sub, num_cc
                 
             except Exception as e:
-                print(f"Error processing label {orig_label}: {e}")
+                #print(f"Error processing label {orig_label}: {e}")
                 return orig_label, bbox, None, 0
         
         # Execute in parallel
@@ -2326,7 +2409,7 @@ class ImageViewerWindow(QMainWindow):
         
         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")
+                #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
@@ -2339,7 +2422,7 @@ class ImageViewerWindow(QMainWindow):
 
     def handle_seperate(self):
         """
-        Fixed version with proper mask handling and debugging
+        Seperate objects in an array that share a label but do not touch
         """
         try:
             # Handle nodes
@@ -2348,7 +2431,6 @@ class ImageViewerWindow(QMainWindow):
                 # 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
                 
@@ -2358,7 +2440,7 @@ class ImageViewerWindow(QMainWindow):
                 # Get non-highlighted part of the array
                 non_highlighted = np.where(highlight_mask, 0, my_network.nodes)
                 
-                # Calculate max_val properly
+                # Calculate max_val
                 max_val = np.max(non_highlighted) if np.any(non_highlighted) else 0
                                 
                 # Process highlighted part
@@ -2583,9 +2665,9 @@ class ImageViewerWindow(QMainWindow):
                     self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
                     self.needs_mini = False
                 else:
-                    self.create_highlight_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+                    self.evaluate_mini()
             else:
-                self.create_highlight_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+                self.evaluate_mini()
 
         
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -3650,17 +3732,23 @@ class ImageViewerWindow(QMainWindow):
         
         # Add highlight overlays if they exist (with downsampling)
         if self.mini_overlay and self.highlight and self.machine_window is None:
-            display_overlay = crop_and_downsample_image(self.mini_overlay_data, y_min_padded, y_max_padded, x_min_padded, x_max_padded, downsample_factor)
-            highlight_rgba = self.create_highlight_rgba(display_overlay, yellow=True)
-            composite = self.blend_layers(composite, highlight_rgba)
+            try:
+                display_overlay = crop_and_downsample_image(self.mini_overlay_data, y_min_padded, y_max_padded, x_min_padded, x_max_padded, downsample_factor)
+                highlight_rgba = self.create_highlight_rgba(display_overlay, yellow=True)
+                composite = self.blend_layers(composite, highlight_rgba)
+            except:
+                pass
         elif self.highlight_overlay is not None and self.highlight:
-            highlight_slice = self.highlight_overlay[self.current_slice]
-            display_highlight = crop_and_downsample_image(highlight_slice, y_min_padded, y_max_padded, x_min_padded, x_max_padded, downsample_factor)
-            if self.machine_window is None:
-                highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=True)
-            else:
-                highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=False)
-            composite = self.blend_layers(composite, highlight_rgba)
+            try:
+                highlight_slice = self.highlight_overlay[self.current_slice]
+                display_highlight = crop_and_downsample_image(highlight_slice, y_min_padded, y_max_padded, x_min_padded, x_max_padded, downsample_factor)
+                if self.machine_window is None:
+                    highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=True)
+                else:
+                    highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=False)
+                composite = self.blend_layers(composite, highlight_rgba)
+            except:
+                pass
         
         # Convert to 0-255 range for display
         return (composite * 255).astype(np.uint8)
@@ -3755,6 +3843,12 @@ class ImageViewerWindow(QMainWindow):
             self.ax.clear()
             self.ax.set_facecolor('black')
             
+            # Reset measurement artists since we cleared the axes
+            if not hasattr(self, 'measurement_artists'):
+                self.measurement_artists = []
+            else:
+                self.measurement_artists = []  # Reset since ax.clear() removed all artists
+            
             # Get original dimensions (before downsampling)
             if hasattr(self, 'original_dims') and self.original_dims:
                 height, width = self.original_dims
@@ -3836,23 +3930,129 @@ class ImageViewerWindow(QMainWindow):
             for spine in self.ax.spines.values():
                 spine.set_color('black')
                 
-            # Add measurement points if they exist (coordinates remain in original space)
-            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')
+            # Add measurement points if they exist (using the same logic as main update_display)
+            if hasattr(self, 'measurement_points') and self.measurement_points:
+                for point in self.measurement_points:
+                    x1, y1, z1 = point['point1']
+                    x2, y2, z2 = point['point2']
+                    pair_idx = point['pair_index']
+                    point_type = point.get('type', 'distance')  # Default to distance for backward compatibility
+                    
+                    # Determine colors based on type
+                    if point_type == 'angle':
+                        marker_color = 'go'
+                        text_color = 'green'
+                        line_color = 'g--'
+                    else:  # distance
+                        marker_color = 'yo'
+                        text_color = 'yellow'
+                        line_color = 'r--'
+                    
+                    # Check if points are in visible region and on current slice
+                    point1_visible = (z1 == self.current_slice and 
+                                    current_xlim[0] <= x1 <= current_xlim[1] and 
+                                    current_ylim[1] <= y1 <= current_ylim[0])
+                    point2_visible = (z2 == self.current_slice and 
+                                    current_xlim[0] <= x2 <= current_xlim[1] and 
+                                    current_ylim[1] <= y2 <= current_ylim[0])
+                    
+                    # Draw individual points if they're on the current slice
+                    if point1_visible:
+                        pt1 = self.ax.plot(x1, y1, marker_color, markersize=8)[0]
+                        txt1 = self.ax.text(x1, y1+5, str(pair_idx), color=text_color, ha='center', va='bottom')
+                        self.measurement_artists.extend([pt1, txt1])
+                        
+                    if point2_visible:
+                        pt2 = self.ax.plot(x2, y2, marker_color, markersize=8)[0]
+                        txt2 = self.ax.text(x2, y2+5, str(pair_idx), color=text_color, ha='center', va='bottom')
+                        self.measurement_artists.extend([pt2, txt2])
+                        
+                    # Draw connecting line if both points are on the same slice
+                    if z1 == z2 == self.current_slice and (point1_visible or point2_visible):
+                        line = self.ax.plot([x1, x2], [y1, y2], line_color, alpha=0.5)[0]
+                        self.measurement_artists.append(line)
+
+            # Handle angle measurements if they exist
+            if hasattr(self, 'angle_measurements') and self.angle_measurements:
+                for angle in self.angle_measurements:
+                    xa, ya, za = angle['point_a']
+                    xb, yb, zb = angle['point_b']  # vertex
+                    xc, yc, zc = angle['point_c']
+                    trio_idx = angle['trio_index']
+                    
+                    # Check if points are on current slice and visible
+                    point_a_visible = (za == self.current_slice and 
+                                     current_xlim[0] <= xa <= current_xlim[1] and 
+                                     current_ylim[1] <= ya <= current_ylim[0])
+                    point_b_visible = (zb == self.current_slice and 
+                                     current_xlim[0] <= xb <= current_xlim[1] and 
+                                     current_ylim[1] <= yb <= current_ylim[0])
+                    point_c_visible = (zc == self.current_slice and 
+                                     current_xlim[0] <= xc <= current_xlim[1] and 
+                                     current_ylim[1] <= yc <= current_ylim[0])
+                    
+                    # Draw points
+                    if point_a_visible:
+                        pt_a = self.ax.plot(xa, ya, 'go', markersize=8)[0]
+                        txt_a = self.ax.text(xa, ya+5, f"A{trio_idx}", color='green', ha='center', va='bottom')
+                        self.measurement_artists.extend([pt_a, txt_a])
                         
-                if z1 == z2 == self.current_slice:
-                    self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
+                    if point_b_visible:
+                        pt_b = self.ax.plot(xb, yb, 'go', markersize=8)[0]
+                        txt_b = self.ax.text(xb, yb+5, f"B{trio_idx}", color='green', ha='center', va='bottom')
+                        self.measurement_artists.extend([pt_b, txt_b])
+                        
+                    if point_c_visible:
+                        pt_c = self.ax.plot(xc, yc, 'go', markersize=8)[0]
+                        txt_c = self.ax.text(xc, yc+5, f"C{trio_idx}", color='green', ha='center', va='bottom')
+                        self.measurement_artists.extend([pt_c, txt_c])
+                    
+                    # Draw lines only if points are on current slice
+                    if za == zb == self.current_slice and (point_a_visible or point_b_visible):
+                        line_ab = self.ax.plot([xa, xb], [ya, yb], 'g--', alpha=0.7)[0]
+                        self.measurement_artists.append(line_ab)
+                        
+                    if zb == zc == self.current_slice and (point_b_visible or point_c_visible):
+                        line_bc = self.ax.plot([xb, xc], [yb, yc], 'g--', alpha=0.7)[0]
+                        self.measurement_artists.append(line_bc)
+
+            # Handle any partial measurements in progress (individual points without pairs yet)
+            if hasattr(self, 'current_point') and self.current_point is not None:
+                x, y, z = self.current_point
+                if z == self.current_slice:
+                    if hasattr(self, 'measurement_mode') and self.measurement_mode == "angle":
+                        # Show green for angle mode
+                        pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+                        if hasattr(self, 'current_trio_index'):
+                            txt = self.ax.text(x, y+5, f"A{self.current_trio_index}", color='green', ha='center', va='bottom')
+                        else:
+                            txt = self.ax.text(x, y+5, "A", color='green', ha='center', va='bottom')
+                    else:
+                        # Show yellow for distance mode (default)
+                        pt = self.ax.plot(x, y, 'yo', markersize=8)[0]
+                        if hasattr(self, 'current_pair_index'):
+                            txt = self.ax.text(x, y+5, f"D{self.current_pair_index}", color='yellow', ha='center', va='bottom')
+                        else:
+                            txt = self.ax.text(x, y+5, "D", color='yellow', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt, txt])
+
+            # Handle second point in angle measurements
+            if hasattr(self, 'current_second_point') and self.current_second_point is not None:
+                x, y, z = self.current_second_point
+                if z == self.current_slice:
+                    pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+                    if hasattr(self, 'current_trio_index'):
+                        txt = self.ax.text(x, y+5, f"B{self.current_trio_index}", color='green', ha='center', va='bottom')
+                    else:
+                        txt = self.ax.text(x, y+5, "B", color='green', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt, txt])
+                    
+                    # Draw line from A to B if both are on current slice
+                    if (hasattr(self, 'current_point') and self.current_point is not None and 
+                        self.current_point[2] == self.current_slice):
+                        x1, y1, z1 = self.current_point
+                        line = self.ax.plot([x1, x], [y1, y], 'g--', alpha=0.7)[0]
+                        self.measurement_artists.append(line)
             
             #self.canvas.setCursor(Qt.CursorShape.ClosedHandCursor)
 
@@ -3968,7 +4168,34 @@ class ImageViewerWindow(QMainWindow):
                         if len(self.clicked_values['edges']):
                             self.highlight_value_in_tables(self.clicked_values['edges'][-1])
                             self.handle_info('edge')
-            
+
+                    try:
+                        if len(self.clicked_values['nodes']) > 0 or len(self.clicked_values['edges']) > 0:  # Check if we have any nodes selected
+
+                            old_nodes = copy.deepcopy(self.clicked_values['nodes']) 
+
+                            # Get the existing DataFrame from the model
+                            original_df = self.network_table.model()._data
+                            
+                            # Create mask for rows where one column is any original node AND the other column is any neighbor
+                            mask = (
+                                ((original_df.iloc[:, 0].isin(self.clicked_values['nodes'])) &
+                                (original_df.iloc[:, 1].isin(self.clicked_values['nodes']))) |
+                                (original_df.iloc[:, 2].isin(self.clicked_values['edges']))
+                                )
+                            
+                            # Filter the DataFrame to only include direct connections
+                            filtered_df = original_df[mask].copy()
+                            
+                            # Create new model with filtered DataFrame and update selection table
+                            new_model = PandasModel(filtered_df)
+                            self.selection_table.setModel(new_model)
+                            
+                            # Switch to selection table
+                            self.selection_button.click()
+                    except:
+                        pass
+                
             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)
@@ -3991,10 +4218,8 @@ class ImageViewerWindow(QMainWindow):
         elif self.zoom_mode:
             # Handle zoom mode press
             if self.original_xlim is None:
-                self.original_xlim = self.ax.get_xlim()
-                #print(self.original_xlim)
-                self.original_ylim = self.ax.get_ylim()
-                #print(self.original_ylim)
+                self.original_xlim = (-0.5, self.shape[2] - 0.5)
+                self.original_ylim = (self.shape[1] + 0.5, -0.5)
             
             current_xlim = self.ax.get_xlim()
             current_ylim = self.ax.get_ylim()
@@ -4156,8 +4381,8 @@ class ImageViewerWindow(QMainWindow):
         if self.zoom_mode:
             # Existing zoom functionality
             if self.original_xlim is None:
-                self.original_xlim = self.ax.get_xlim()
-                self.original_ylim = self.ax.get_ylim()
+                self.original_xlim = (-0.5, self.shape[2] - 0.5)
+                self.original_ylim = (self.shape[1] + 0.5, -0.5)
             
             current_xlim = self.ax.get_xlim()
             current_ylim = self.ax.get_ylim()
@@ -4333,6 +4558,8 @@ class ImageViewerWindow(QMainWindow):
         for i in range(4):
             load_action = load_menu.addAction(f"Load {self.channel_names[i]}")
             load_action.triggered.connect(lambda checked, ch=i: self.load_channel(ch))
+        load_action = load_menu.addAction("Load Full-Sized Highlight Overlay")
+        load_action.triggered.connect(lambda: self.load_channel(channel_index = 4, load_highlight = True))
         load_action = load_menu.addAction("Load Network")
         load_action.triggered.connect(self.load_network)
         load_action = load_menu.addAction("Load From Excel Helper")
@@ -4373,6 +4600,8 @@ class ImageViewerWindow(QMainWindow):
         allstats_action.triggered.connect(self.stats)
         histos_action = stats_menu.addAction("Network Statistic Histograms")
         histos_action.triggered.connect(self.histos)
+        sig_action = stats_menu.addAction("Significance Testing")
+        sig_action.triggered.connect(self.sig_test)
         radial_action = stats_menu.addAction("Radial Distribution Analysis")
         radial_action.triggered.connect(self.show_radial_dialog)
         neighbor_id_action = stats_menu.addAction("Identity Distribution of Neighbors")
@@ -4387,8 +4616,12 @@ class ImageViewerWindow(QMainWindow):
         vol_action.triggered.connect(self.volumes)
         rad_action = stats_menu.addAction("Calculate Radii")
         rad_action.triggered.connect(self.show_rad_dialog)
+        branch_stats = stats_menu.addAction("Calculate Branch Stats (Lengths, Tortuosities)")
+        branch_stats.triggered.connect(self.show_branchstat_dialog)
         inter_action = stats_menu.addAction("Calculate Node < > Edge Interaction")
         inter_action.triggered.connect(self.show_interaction_dialog)
+        violin_action = stats_menu.addAction("Show Identity Violins/UMAP/Assign Intensity Neighborhoods")
+        violin_action.triggered.connect(self.show_violin_dialog)
         overlay_menu = analysis_menu.addMenu("Data/Overlays")
         degree_action = overlay_menu.addAction("Get Degree Information")
         degree_action.triggered.connect(self.show_degree_dialog)
@@ -4422,12 +4655,16 @@ class ImageViewerWindow(QMainWindow):
         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)
+        #calc_id_net_action = calculate_menu.addAction("Calculate Identity Network (beta)")
+        #calc_id_net_action.triggered.connect(self.handle_identity_net_calc)
         centroid_action = calculate_menu.addAction("Calculate Centroids (Active Image)")
         centroid_action.triggered.connect(self.show_centroid_dialog)
 
         image_menu = process_menu.addMenu("Image")
         resize_action = image_menu.addAction("Resize (Up/Downsample)")
         resize_action.triggered.connect(self.show_resize_dialog)
+        clean_action = image_menu.addAction("Clean Segmentation")
+        clean_action.triggered.connect(self.show_clean_dialog)
         dilate_action = image_menu.addAction("Dilate")
         dilate_action.triggered.connect(self.show_dilate_dialog)
         erode_action = image_menu.addAction("Erode")
@@ -4438,7 +4675,7 @@ class ImageViewerWindow(QMainWindow):
         binarize_action.triggered.connect(self.show_binarize_dialog)
         label_action = image_menu.addAction("Label Objects")
         label_action.triggered.connect(self.show_label_dialog)
-        slabel_action = image_menu.addAction("Neighborhood Labels")
+        slabel_action = image_menu.addAction("Neighbor Labels")
         slabel_action.triggered.connect(self.show_slabel_dialog)
         thresh_action = image_menu.addAction("Threshold/Segment")
         thresh_action.triggered.connect(self.show_thresh_dialog)
@@ -4514,7 +4751,7 @@ class ImageViewerWindow(QMainWindow):
         
         
         # Add after your other buttons
-        self.popup_button = QPushButton("⤴")  # or "🔗" or "⤴"
+        self.popup_button = QPushButton("⤴") 
         self.popup_button.setFixedSize(40, 40)
         self.popup_button.setToolTip("Pop out canvas")
         self.popup_button.clicked.connect(self.popup_canvas)
@@ -4582,7 +4819,10 @@ class ImageViewerWindow(QMainWindow):
                 # Invalid input - reset to default
                 self.downsample_factor = 1
 
-        self.throttle = self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor
+        try:
+            self.throttle = self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor
+        except:
+            self.throttle = False
         
         # Optional: Trigger display update if you want immediate effect
         if update:
@@ -4667,8 +4907,11 @@ class ImageViewerWindow(QMainWindow):
             self.cellpose_launcher.launch_cellpose_gui(use_3d = use_3d)
 
         except:
-            import traceback
-            print(traceback.format_exc())
+            QMessageBox.critical(
+                self,
+                "Error",
+                f"Error starting cellpose: {str(e)}\nNote: You may need to install cellpose with corresponding torch first - in your environment, please call 'pip install cellpose'. Please see: 'https://pytorch.org/get-started/locally/' to see what torch install command corresponds to your NVIDIA GPU"
+            )
             pass
 
 
@@ -4715,6 +4958,16 @@ class ImageViewerWindow(QMainWindow):
         except Exception as e:
             print(f"Error creating histogram selector: {e}")
 
+    def sig_test(self):
+        # Get the existing QApplication instance
+        app = QApplication.instance()
+        
+        # Create the statistical GUI window without starting a new event loop
+        stats_window = net_stats.main(app)
+        
+        # Keep a reference so it doesn't get garbage collected
+        self.stats_window = stats_window
+
     def volumes(self):
 
 
@@ -4740,7 +4993,7 @@ class ImageViewerWindow(QMainWindow):
 
         
 
-    def format_for_upperright_table(self, data, metric='Metric', value='Value', title=None):
+    def format_for_upperright_table(self, data, metric='Metric', value='Value', title=None, sort = True):
        """
        Format dictionary or list data for display in upper right table.
        
@@ -4826,11 +5079,12 @@ class ImageViewerWindow(QMainWindow):
            table = CustomTableView(self)
            table.setModel(PandasModel(df))
 
-           try:
-               first_column_name = table.model()._data.columns[0]
-               table.sort_table(first_column_name, ascending=True)
-           except:
-                pass
+           if sort:
+               try:
+                   first_column_name = table.model()._data.columns[0]
+                   table.sort_table(first_column_name, ascending=True)
+               except:
+                    pass
            
            # Add to tabbed widget
            if title is None:
@@ -4844,6 +5098,8 @@ class ImageViewerWindow(QMainWindow):
            for column in range(table.model().columnCount(None)):
                table.resizeColumnToContents(column)
 
+           return df
+
        except:
             pass
 
@@ -4860,6 +5116,10 @@ class ImageViewerWindow(QMainWindow):
             dialog = MergeNodeIdDialog(self)
             dialog.exec()
 
+    def show_multichan_dialog(self, data):
+        dialog = MultiChanDialog(self, data)
+        dialog.show()
+
     def show_gray_water_dialog(self):
         """Show the gray watershed parameter dialog."""
         dialog = GrayWaterDialog(self)
@@ -4962,7 +5222,7 @@ class ImageViewerWindow(QMainWindow):
 
             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)
+            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, 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)
@@ -4996,6 +5256,12 @@ class ImageViewerWindow(QMainWindow):
 
             self.load_channel(0, my_network.edges, data = True)
 
+            try:
+                self.branch_dict[0] = self.branch_dict[1]
+                self.branch_dict[1] = None
+            except:
+                pass
+
             self.delete_channel(1, False)
 
             my_network.morph_proximity(search = [3,3], fastdil = True)
@@ -5012,14 +5278,51 @@ class ImageViewerWindow(QMainWindow):
         dialog = CentroidDialog(self)
         dialog.exec()
 
-    def show_dilate_dialog(self):
+    def handle_identity_net_calc(self):
+
+        try:
+
+            def confirm_dialog():
+                """Shows a dialog asking user to confirm and input connection limit"""
+                from PyQt6.QtWidgets import QInputDialog
+                
+                value, ok = QInputDialog.getInt(
+                    None,  # parent widget
+                    "Confirm",  # window title
+                    "Calculate Identity Network\n\n"
+                    "Connect nodes that share an identity - useful for nodes that\n"
+                    "overlap in identity to some degree.\n\n"
+                    "Enter maximum connections per node within same identity:",
+                    5,  # default value
+                    1,  # minimum value
+                    1000,  # maximum value
+                    1   # step
+                )
+                
+                if ok:
+                    return True, value
+                else:
+                    return False, None
+
+            confirm, val = confirm_dialog()
+
+            if confirm:
+                my_network.create_id_network(val)
+                self.table_load_attrs()
+            else:
+                return
+
+        except:
+            pass
+
+    def show_dilate_dialog(self, args = None):
         """show the dilate dialog"""
-        dialog = DilateDialog(self)
+        dialog = DilateDialog(self, args)
         dialog.exec()
 
-    def show_erode_dialog(self):
+    def show_erode_dialog(self, args = None):
         """show the erode dialog"""
-        dialog = ErodeDialog(self)
+        dialog = ErodeDialog(self, args)
         dialog.exec()
 
     def show_hole_dialog(self):
@@ -5118,6 +5421,9 @@ class ImageViewerWindow(QMainWindow):
         dialog = ResizeDialog(self)
         dialog.exec()
 
+    def show_clean_dialog(self):
+        dialog = CleanDialog(self)
+        dialog.show()
 
     def show_properties_dialog(self):
         """Show the properties dialog"""
@@ -5272,7 +5578,6 @@ class ImageViewerWindow(QMainWindow):
 
         elif sort == 'Merge Nodes':
             try:
-
                 if my_network.nodes is None:
                     QMessageBox.critical(
                         self,
@@ -5280,72 +5585,118 @@ class ImageViewerWindow(QMainWindow):
                         "Please load your first set of nodes into the 'Nodes' channel first"
                     )
                     return
-
                 if len(np.unique(my_network.nodes)) < 3:
                     self.show_label_dialog()
-
-                # First ask user what they want to select
-                msg = QMessageBox()
-                msg.setWindowTitle("Selection Type")
-                msg.setText("Would you like to select a TIFF file or a directory?")
-                tiff_button = msg.addButton("TIFF File", QMessageBox.ButtonRole.AcceptRole)
-                dir_button = msg.addButton("Directory", QMessageBox.ButtonRole.AcceptRole)
-                msg.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
-
-                msg.exec()
-
-                # Also if they want centroids:
-                msg2 = QMessageBox()
-                msg2.setWindowTitle("Selection Type")
-                msg2.setText("Would you like to compute node centroids for each image prior to merging?")
-                yes_button = msg2.addButton("Yes", QMessageBox.ButtonRole.AcceptRole)
-                no_button = msg2.addButton("No", QMessageBox.ButtonRole.AcceptRole)
-                msg2.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
-
-                msg2.exec()
-
-                if msg2.clickedButton() == yes_button:
-                    centroids = True
-                else:
-                    centroids = False
-
-                if msg.clickedButton() == tiff_button:
-                    # Code for selecting TIFF files
-                    filename, _ = QFileDialog.getOpenFileName(
-                        self,
-                        "Select TIFF file",
-                        "",
-                        "TIFF files (*.tiff *.tif)"
-                    )
-                    if filename:
-                        selected_path = filename
-
-                elif msg.clickedButton() == dir_button:
-                    # Code for selecting directories
-                    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()
-
-                my_network.merge_nodes(selected_path, root_id = self.node_name, centroids = centroids)
-                self.load_channel(0, my_network.nodes, True)
-
-
-                if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
+                
+                # Create custom dialog
+                dialog = QDialog(self)
+                dialog.setWindowTitle("Merge Nodes Configuration")
+                dialog.setModal(True)
+                dialog.resize(400, 200)
+                
+                layout = QVBoxLayout(dialog)
+                
+                # Selection type
+                type_layout = QHBoxLayout()
+                type_label = QLabel("Selection Type:")
+                type_combo = QComboBox()
+                type_combo.addItems(["TIFF File", "Directory"])
+                type_layout.addWidget(type_label)
+                type_layout.addWidget(type_combo)
+                layout.addLayout(type_layout)
+                
+                # Centroids checkbox
+                centroids_layout = QHBoxLayout()
+                centroids_check = QCheckBox("Compute node centroids for each image prior to merging")
+                centroids_layout.addWidget(centroids_check)
+                layout.addLayout(centroids_layout)
+                
+                # Down factor for centroid calculation
+                down_factor_layout = QHBoxLayout()
+                down_factor_label = QLabel("Down Factor (for centroid calculation downsampling):")
+                down_factor_edit = QLineEdit()
+                down_factor_edit.setText("1")  # Default value
+                down_factor_edit.setPlaceholderText("Enter down factor (e.g., 1, 2, 4)")
+                down_factor_layout.addWidget(down_factor_label)
+                down_factor_layout.addWidget(down_factor_edit)
+                layout.addLayout(down_factor_layout)
+                
+                # Buttons
+                button_layout = QHBoxLayout()
+                accept_button = QPushButton("Accept")
+                cancel_button = QPushButton("Cancel")
+                button_layout.addWidget(accept_button)
+                button_layout.addWidget(cancel_button)
+                layout.addLayout(button_layout)
+                
+                # Connect buttons
+                accept_button.clicked.connect(dialog.accept)
+                cancel_button.clicked.connect(dialog.reject)
+                
+                # Execute dialog
+                if dialog.exec() == QDialog.DialogCode.Accepted:
+                    # Get values from dialog
+                    selection_type = type_combo.currentText()
+                    centroids = centroids_check.isChecked()
+                    
+                    # Validate and get down_factor
                     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 centroids:
-                    self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
-
-
+                        down_factor = int(down_factor_edit.text())
+                        if down_factor <= 0:
+                            raise ValueError("Down factor must be positive")
+                    except ValueError as e:
+                        QMessageBox.critical(
+                            self,
+                            "Invalid Input",
+                            f"Invalid down factor: {str(e)}"
+                        )
+                        return
+                    
+                    # Handle file/directory selection based on combo box choice
+                    if selection_type == "TIFF File":
+                        filename, _ = QFileDialog.getOpenFileName(
+                            self,
+                            "Select TIFF file",
+                            "",
+                            "TIFF files (*.tiff *.tif)"
+                        )
+                        if filename:
+                            selected_path = filename
+                        else:
+                            return  # User cancelled file selection
+                    else:  # Directory
+                        file_dialog = QFileDialog(self)
+                        file_dialog.setOption(QFileDialog.Option.DontUseNativeDialog)
+                        file_dialog.setOption(QFileDialog.Option.ReadOnly)
+                        file_dialog.setFileMode(QFileDialog.FileMode.Directory)
+                        file_dialog.setViewMode(QFileDialog.ViewMode.Detail)
+                        if file_dialog.exec() == QFileDialog.DialogCode.Accepted:
+                            selected_path = file_dialog.directory().absolutePath()
+                        else:
+                            return  # User cancelled directory selection
+                    
+                    if down_factor == 1:
+                        down_factor = None
+                    # Call merge_nodes with all parameters
+                    my_network.merge_nodes(
+                        selected_path, 
+                        root_id=self.node_name, 
+                        centroids=centroids,
+                        down_factor=down_factor
+                    )
+                    
+                    self.load_channel(0, my_network.nodes, True)
+                    
+                    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 centroids:
+                        self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+                
             except Exception as e:
-
                 QMessageBox.critical(
                     self,
                     "Error Merging",
@@ -5368,8 +5719,10 @@ class ImageViewerWindow(QMainWindow):
                     )
 
             self.last_load = directory
-            
+            self.last_saved = os.path.dirname(directory)
+            self.last_save_name = directory            
 
+            self.channel_data = [None] * 5
             if directory != "":
 
                 self.reset(network = True, xy_scale = 1, z_scale = 1, nodes = True, edges = True, network_overlay = True, id_overlay = True, update = False)
@@ -5672,6 +6025,16 @@ class ImageViewerWindow(QMainWindow):
         msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         return msg.exec() == QMessageBox.StandardButton.Yes
 
+    def confirm_multichan_dialog(self):
+        """Shows a dialog asking user to confirm if image is multichan"""
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Icon.Question)
+        msg.setText("Image Format Alert")
+        msg.setInformativeText("Is this a Multi-Channel (4D) image?")
+        msg.setWindowTitle("Confirm Image Format")
+        msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        return msg.exec() == QMessageBox.StandardButton.Yes
+
     def confirm_resize_dialog(self):
         """Shows a dialog asking user to resize image"""
         msg = QMessageBox()
@@ -5682,12 +6045,41 @@ class ImageViewerWindow(QMainWindow):
         msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         return msg.exec() == QMessageBox.StandardButton.Yes
 
-    def load_channel(self, channel_index, channel_data=None, data=False, assign_shape = True, preserve_zoom = None, end_paint = False, begin_paint = False, color = False):
+    def get_scaling_metadata_only(self, filename):
+        # This only reads headers/metadata, not image data
+        with tifffile.TiffFile(filename) as tif:
+            x_scale = y_scale = z_scale = unit = None
+            
+            # ImageJ metadata (very lightweight)
+            if hasattr(tif, 'imagej_metadata') and tif.imagej_metadata:
+                metadata = tif.imagej_metadata
+                z_scale = metadata.get('spacing')
+                unit = metadata.get('unit')
+            
+            # TIFF tags (also lightweight - just header info)
+            page = tif.pages[0]  # This doesn't load image data
+            tags = page.tags
+            
+            if 'XResolution' in tags:
+                x_res = tags['XResolution'].value
+                x_scale = x_res[1] / x_res[0] if isinstance(x_res, tuple) else 1.0 / x_res
+                
+            if 'YResolution' in tags:
+                y_res = tags['YResolution'].value
+                y_scale = y_res[1] / y_res[0] if isinstance(y_res, tuple) else 1.0 / y_res
+        
+        if x_scale is None:
+            x_scale = 1
+        if z_scale is None:
+            z_scale = 1
+
+        return x_scale, z_scale
+
+    def load_channel(self, channel_index, channel_data=None, data=False, assign_shape = True, preserve_zoom = None, end_paint = False, begin_paint = False, color = False, load_highlight = False):
         """Load a channel and enable active channel selection if needed."""
 
         try:
 
-            self.hold_update = True
             if not data:  # For solo loading
                 filename, _ = QFileDialog.getOpenFileName(
                     self,
@@ -5707,8 +6099,19 @@ class ImageViewerWindow(QMainWindow):
                 try:
                     if file_extension in ['tif', 'tiff']:
                         import tifffile
-                        self.channel_data[channel_index] = tifffile.imread(filename)
-
+                        self.channel_data[channel_index] = None
+                        if (self.channel_data[0] is None and self.channel_data[1] is None) and (channel_index == 0 or channel_index == 1):
+                            try:
+                                my_network.xy_scale, my_network.z_scale = self.get_scaling_metadata_only(filename)
+                                print(f"xy_scale property set to {my_network.xy_scale}; z_scale property set to {my_network.z_scale}")
+                            except:
+                                pass
+                        test_channel_data = tifffile.imread(filename)
+                        if len(test_channel_data.shape) not in (2, 3, 4):
+                            print("Invalid Shape")
+                            return 
+                        self.channel_data[channel_index] = test_channel_data
+
                     elif file_extension == 'nii':
                         import nibabel as nib
                         nii_img = nib.load(filename)
@@ -5755,7 +6158,7 @@ class ImageViewerWindow(QMainWindow):
             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
-                        if not data and self.shape is None:
+                        if not data:
                             if self.confirm_rgb_dialog():
                                 # User confirmed it's 2D RGB, expand to 4D
                                 self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
@@ -5765,12 +6168,18 @@ class ImageViewerWindow(QMainWindow):
             except:
                 pass
 
-            if not color:
-                try:
-                    if len(self.channel_data[channel_index].shape) == 4 and (channel_index == 0 or channel_index == 1):
+            if len(self.channel_data[channel_index].shape) == 4:
+                if not self.channel_data[channel_index].shape[-1] in (3, 4):
+                    if self.confirm_multichan_dialog(): # User is trying to load 4D channel stack:
+                        my_data = copy.deepcopy(self.channel_data[channel_index])
+                        self.channel_data[channel_index] = None 
+                        self.show_multichan_dialog(data = my_data)
+                        return
+                elif not color and (channel_index == 0 or channel_index == 1):
+                    try:
                         self.channel_data[channel_index] = self.reduce_rgb_dimension(self.channel_data[channel_index], 'weight')
-                except:
-                    pass
+                    except:
+                        pass
 
             reset_resize = False
 
@@ -5779,7 +6188,6 @@ class ImageViewerWindow(QMainWindow):
                     if self.highlight_overlay is not None: #Make sure highlight overlay is always the same shape as new images
                         try:
                             if self.channel_data[i].shape[:3] != self.highlight_overlay.shape:
-                                self.resizing = True
                                 reset_resize = True
                                 self.highlight_overlay = None
                         except:
@@ -5806,51 +6214,52 @@ class ImageViewerWindow(QMainWindow):
                     my_network.id_overlay = self.channel_data[channel_index]
             
             # Enable the channel button
-            self.channel_buttons[channel_index].setEnabled(True)
-            self.delete_buttons[channel_index].setEnabled(True) 
+            if channel_index != 4:
+                self.channel_buttons[channel_index].setEnabled(True)
+                self.delete_buttons[channel_index].setEnabled(True) 
 
             
-            # Enable active channel selector if this is the first channel loaded
-            if not self.active_channel_combo.isEnabled():
-                self.active_channel_combo.setEnabled(True)
+                # Enable active channel selector if this is the first channel loaded
+                if not self.active_channel_combo.isEnabled():
+                    self.active_channel_combo.setEnabled(True)
             
-            # Update slider range if this is the first channel loaded
-            try:
-                if len(self.channel_data[channel_index].shape) == 3 or len(self.channel_data[channel_index].shape) == 4:
-                    if not self.slice_slider.isEnabled():
-                        self.slice_slider.setEnabled(True)
-                        self.slice_slider.setMinimum(0)
-                        self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
-                        if self.slice_slider.value() < self.channel_data[channel_index].shape[0] - 1:
-                            self.current_slice = self.slice_slider.value()
+                # Update slider range if this is the first channel loaded
+                try:
+                    if len(self.channel_data[channel_index].shape) == 3 or len(self.channel_data[channel_index].shape) == 4:
+                        if not self.slice_slider.isEnabled():
+                            self.slice_slider.setEnabled(True)
+                            self.slice_slider.setMinimum(0)
+                            self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
+                            if self.slice_slider.value() < self.channel_data[channel_index].shape[0] - 1:
+                                self.current_slice = self.slice_slider.value()
+                            else:
+                                self.slice_slider.setValue(0)
+                                self.current_slice = 0
                         else:
-                            self.slice_slider.setValue(0)
-                            self.current_slice = 0
+                            self.slice_slider.setEnabled(True)
+                            self.slice_slider.setMinimum(0)
+                            self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
+                            if self.slice_slider.value() < self.channel_data[channel_index].shape[0] - 1:
+                                self.current_slice = self.slice_slider.value()
+                            else:
+                                self.current_slice = 0
+                                self.slice_slider.setValue(0)
                     else:
-                        self.slice_slider.setEnabled(True)
-                        self.slice_slider.setMinimum(0)
-                        self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
-                        if self.slice_slider.value() < self.channel_data[channel_index].shape[0] - 1:
-                            self.current_slice = self.slice_slider.value()
-                        else:
-                            self.current_slice = 0
-                            self.slice_slider.setValue(0)
-                else:
-                    self.slice_slider.setEnabled(False)
-            except:
-                pass
+                        self.slice_slider.setEnabled(False)
+                except:
+                    pass
 
-            
-            # If this is the first channel loaded, make it active
-            if all(not btn.isEnabled() for btn in self.channel_buttons[:channel_index]):
-                self.set_active_channel(channel_index)
+                
+                # If this is the first channel loaded, make it active
+                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 not 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
+                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
 
             try:
                 if assign_shape: #keep original shape tracked to undo resampling.
@@ -5865,7 +6274,13 @@ class ImageViewerWindow(QMainWindow):
 
             if self.shape == self.channel_data[channel_index].shape:
                 preserve_zoom = (self.ax.get_xlim(), self.ax.get_ylim())
-            self.shape = self.channel_data[channel_index].shape
+                self.shape = (self.channel_data[channel_index].shape[0], self.channel_data[channel_index].shape[1], self.channel_data[channel_index].shape[2])
+            else:
+                if self.shape is not None:
+                    self.resizing = True
+                self.shape = (self.channel_data[channel_index].shape[0], self.channel_data[channel_index].shape[1], self.channel_data[channel_index].shape[2])
+                ylim, xlim = (self.shape[1] + 0.5, -0.5), (-0.5, self.shape[2] - 0.5)
+                preserve_zoom = (xlim, ylim)
             if self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor:
                 self.throttle = True
             else:
@@ -5873,8 +6288,6 @@ class ImageViewerWindow(QMainWindow):
 
 
             self.img_height, self.img_width = self.shape[1], self.shape[2]
-            self.original_ylim, self.original_xlim = (self.shape[1] + 0.5, -0.5), (-0.5, self.shape[2] - 0.5)
-            #print(self.original_xlim)
 
             self.completed_paint_strokes = [] #Reset pending paint operations
             self.current_stroke_points = []
@@ -5884,6 +6297,12 @@ class ImageViewerWindow(QMainWindow):
             self.current_operation = []
             self.current_operation_type = None
 
+            if load_highlight:
+                self.highlight_overlay = n3d.binarize(self.channel_data[4].astype(np.uint8))
+                self.mini_overlay_data = None
+                self.mini_overlay = False
+                self.channel_data[4] = None
+
             if self.pan_mode:
                 self.pan_button.click()
                 if self.show_channels:
@@ -5892,7 +6311,6 @@ class ImageViewerWindow(QMainWindow):
             elif not end_paint:
 
                 self.update_display(reset_resize = reset_resize, preserve_zoom = preserve_zoom)
-
                 
         except Exception as e:
 
@@ -5901,7 +6319,7 @@ class ImageViewerWindow(QMainWindow):
                 QMessageBox.critical(
                     self,
                     "Error Loading File",
-                    f"Failed to load tiff file: {str(e)}"
+                    f"Failed to load file: {str(e)}"
                 )
 
     def delete_channel(self, channel_index, called = True, update = True):
@@ -6103,12 +6521,9 @@ class ImageViewerWindow(QMainWindow):
     def update_slice(self):
         """Queue a slice update when slider moves."""
         # Store current view settings
-        if not self.resizing:
-            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
-        else:
-            current_xlim = None
-            current_ylim = 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
+
         
         # Store the pending slice and view settings
         self.pending_slice = (self.slice_slider.value(), (current_xlim, current_ylim))
@@ -6130,15 +6545,19 @@ class ImageViewerWindow(QMainWindow):
                 self.pm.convert_virtual_strokes_to_data()
             self.current_slice = slice_value
             if self.preview:
+                 self.highlight_overlay = None
+                 self.mini_overlay_data = None
+                 self.mini_overlay = False
                  self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
             elif self.mini_overlay == True: #If we are rendering the highlight overlay for selected values one at a time.
                 self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-            if not self.hold_update:
-                self.update_display(preserve_zoom=view_settings)
-            else:
-                self.hold_update = False
-            #if self.machine_window is not None:
-                #self.machine_window.poke_segmenter()
+
+            if self.resizing:
+                print('hello')
+                self.highlight_overlay = None
+                view_settings = ((-0.5, self.shape[2] - 0.5), (self.shape[1] - 0.5, -0.5))
+                self.resizing = False
+            self.update_display(preserve_zoom=view_settings)
             if self.pan_mode:
                 self.pan_button.click()
             self.pending_slice = None
@@ -6155,7 +6574,6 @@ class ImageViewerWindow(QMainWindow):
         self.channel_brightness[channel_index]['max'] = max_val / 65535
         self.update_display(preserve_zoom = (current_xlim, current_ylim))
 
-
     def update_display(self, preserve_zoom=None, dims=None, called=False, reset_resize=False, skip=False):
         """Optimized display update with view-based cropping for performance."""
         try:
@@ -6175,8 +6593,6 @@ class ImageViewerWindow(QMainWindow):
                 if self.resume:
                     self.machine_window.segmentation_worker.resume()
                     self.resume = False
-                if self.prev_down != self.downsample_factor:
-                    self.validate_downsample_input(text = self.prev_down)
            
             if self.static_background is not None:
                 # Your existing virtual strokes conversion logic
@@ -6233,10 +6649,13 @@ class ImageViewerWindow(QMainWindow):
                 for img in list(self.ax.get_images()):
                     img.remove()
                 # Clear measurement points
-                for artist in self.measurement_artists:
-                    artist.remove()
-                self.measurement_artists.clear()
-
+                if hasattr(self, 'measurement_artists'):
+                    for artist in self.measurement_artists:
+                        try:
+                            artist.remove()
+                        except:
+                            pass  # Artist might already be removed
+                self.measurement_artists = []  # Reset the list
             # Determine the current view bounds (either from preserve_zoom or current state)
             if preserve_zoom:
                 current_xlim, current_ylim = preserve_zoom
@@ -6303,7 +6722,6 @@ class ImageViewerWindow(QMainWindow):
                     return cropped[::factor, ::factor, :]
                 else:
                     return cropped
-
             
             # Update channel images efficiently with cropping and downsampling
             for channel in range(4):
@@ -6378,13 +6796,10 @@ class ImageViewerWindow(QMainWindow):
                             
                             im = self.ax.imshow(normalized_image, alpha=0.7, cmap=custom_cmap,
                                               vmin=0, vmax=1, extent=crop_extent)
-
             # Handle preview, overlays, and measurements (apply cropping here too)
-            #if self.preview and not called:
-             #   self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
 
             # Overlay handling (optimized with cropping and downsampling)
-            if self.mini_overlay and self.highlight and self.machine_window is None:
+            if self.mini_overlay and self.highlight and self.machine_window is None and not self.preview:
                 highlight_cmap = LinearSegmentedColormap.from_list('highlight', [(0, 0, 0, 0), (1, 1, 0, 1)])
                 display_overlay = crop_and_downsample_image(
                     self.mini_overlay_data, y_min_padded, y_max_padded, 
@@ -6403,34 +6818,88 @@ class ImageViewerWindow(QMainWindow):
                         [(0, 0, 0, 0), (1, 1, 0, 1), (0, 0.7, 1, 1)])
                     self.ax.imshow(display_highlight, cmap=highlight_cmap, vmin=0, vmax=2, alpha=0.3, extent=crop_extent)
 
-            # Redraw measurement points efficiently (no cropping needed - these are vector graphics)
+            # Redraw measurement points efficiently
             # Only draw points that are within the visible region for additional performance
-            for point in self.measurement_points:
-                x1, y1, z1 = point['point1']
-                x2, y2, z2 = point['point2']
-                pair_idx = point['pair_index']
-                
-                # Check if points are in visible region
-                point1_visible = (z1 == self.current_slice and 
-                                current_xlim[0] <= x1 <= current_xlim[1] and 
-                                current_ylim[1] <= y1 <= current_ylim[0])
-                point2_visible = (z2 == self.current_slice and 
-                                current_xlim[0] <= x2 <= current_xlim[1] and 
-                                current_ylim[1] <= y2 <= current_ylim[0])
-                
-                if point1_visible:
-                    pt1 = self.ax.plot(x1, y1, 'yo', markersize=8)[0]
-                    txt1 = self.ax.text(x1, y1+5, str(pair_idx), color='white', ha='center', va='bottom')
-                    self.measurement_artists.extend([pt1, txt1])
+
+            if hasattr(self, 'measurement_points') and self.measurement_points:
+                for point in self.measurement_points:
+                    x1, y1, z1 = point['point1']
+                    x2, y2, z2 = point['point2']
+                    pair_idx = point['pair_index']
+                    point_type = point.get('type', 'distance')  # Default to distance for backward compatibility
                     
-                if point2_visible:
-                    pt2 = self.ax.plot(x2, y2, 'yo', markersize=8)[0]
-                    txt2 = self.ax.text(x2, y2+5, str(pair_idx), color='white', ha='center', va='bottom')
-                    self.measurement_artists.extend([pt2, txt2])
+                    # Determine colors based on type
+                    if point_type == 'angle':
+                        marker_color = 'go'
+                        text_color = 'green'
+                        line_color = 'g--'
+                    else:  # distance
+                        marker_color = 'yo'
+                        text_color = 'yellow'
+                        line_color = 'r--'
+                    
+                    # Check if points are in visible region and on current slice
+                    point1_visible = (z1 == self.current_slice and 
+                                    current_xlim[0] <= x1 <= current_xlim[1] and 
+                                    current_ylim[1] <= y1 <= current_ylim[0])
+                    point2_visible = (z2 == self.current_slice and 
+                                    current_xlim[0] <= x2 <= current_xlim[1] and 
+                                    current_ylim[1] <= y2 <= current_ylim[0])
+                    
+                    # Always draw individual points if they're on the current slice (even without lines)
+                    if point1_visible:
+                        pt1 = self.ax.plot(x1, y1, marker_color, markersize=8)[0]
+                        txt1 = self.ax.text(x1, y1+5, str(pair_idx), color=text_color, ha='center', va='bottom')
+                        self.measurement_artists.extend([pt1, txt1])
+                        
+                    if point2_visible:
+                        pt2 = self.ax.plot(x2, y2, marker_color, markersize=8)[0]
+                        txt2 = self.ax.text(x2, y2+5, str(pair_idx), color=text_color, ha='center', va='bottom')
+                        self.measurement_artists.extend([pt2, txt2])
+                        
+                    # Only draw connecting line if both points are on the same slice AND visible
+                    if z1 == z2 == self.current_slice and (point1_visible or point2_visible):
+                        line = self.ax.plot([x1, x2], [y1, y2], line_color, alpha=0.5)[0]
+                        self.measurement_artists.append(line)
+
+            # Also handle any partial measurements in progress (individual points without pairs yet)
+            # This shows individual points even when a measurement isn't complete
+            if hasattr(self, 'current_point') and self.current_point is not None:
+                x, y, z = self.current_point
+                if z == self.current_slice:
+                    if hasattr(self, 'measurement_mode') and self.measurement_mode == "angle":
+                        # Show green for angle mode
+                        pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+                        if hasattr(self, 'current_trio_index'):
+                            txt = self.ax.text(x, y+5, f"A{self.current_trio_index}", color='green', ha='center', va='bottom')
+                        else:
+                            txt = self.ax.text(x, y+5, "A", color='green', ha='center', va='bottom')
+                    else:
+                        # Show yellow for distance mode (default)
+                        pt = self.ax.plot(x, y, 'yo', markersize=8)[0]
+                        if hasattr(self, 'current_pair_index'):
+                            txt = self.ax.text(x, y+5, f"D{self.current_pair_index}", color='yellow', ha='center', va='bottom')
+                        else:
+                            txt = self.ax.text(x, y+5, "D", color='yellow', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt, txt])
+
+            # Handle second point in angle measurements
+            if hasattr(self, 'current_second_point') and self.current_second_point is not None:
+                x, y, z = self.current_second_point
+                if z == self.current_slice:
+                    pt = self.ax.plot(x, y, 'go', markersize=8)[0]
+                    if hasattr(self, 'current_trio_index'):
+                        txt = self.ax.text(x, y+5, f"B{self.current_trio_index}", color='green', ha='center', va='bottom')
+                    else:
+                        txt = self.ax.text(x, y+5, "B", color='green', ha='center', va='bottom')
+                    self.measurement_artists.extend([pt, txt])
                     
-                if z1 == z2 == self.current_slice and (point1_visible or point2_visible):
-                    line = self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)[0]
-                    self.measurement_artists.append(line)
+                    # Draw line from A to B if both are on current slice
+                    if (hasattr(self, 'current_point') and self.current_point is not None and 
+                        self.current_point[2] == self.current_slice):
+                        x1, y1, z1 = self.current_point
+                        line = self.ax.plot([x1, x], [y1, y], 'g--', alpha=0.7)[0]
+                        self.measurement_artists.append(line)
 
             # Store current view limits for next update
             self.ax._current_xlim = current_xlim
@@ -6449,15 +6918,12 @@ class ImageViewerWindow(QMainWindow):
             if reset_resize:
                 self.resizing = False
             
-            # Use draw_idle for better performance
+            # draw_idle
             self.canvas.draw_idle()
 
+
         except Exception as e:
             pass
-            #import traceback
-            #print(traceback.format_exc())
-
-
 
 
     def get_channel_image(self, channel):
@@ -6567,10 +7033,18 @@ class ImageViewerWindow(QMainWindow):
         dialog = RadDialog(self)
         dialog.exec()
 
+    def show_branchstat_dialog(self):
+        dialog = BranchStatDialog(self)
+        dialog.exec()
+
     def show_interaction_dialog(self):
         dialog = InteractionDialog(self)
         dialog.exec()
 
+    def show_violin_dialog(self):
+        dialog = ViolinDialog(self)
+        dialog.show()
+
     def show_degree_dialog(self):
         dialog = DegreeDialog(self)
         dialog.exec()
@@ -7904,11 +8378,6 @@ class MergeNodeIdDialog(QDialog):
         self.mode_selector.addItems(["Auto-Binarize(Otsu)/Presegmented", "Manual (Interactive Thresholder)"])
         self.mode_selector.setCurrentIndex(1)  # Default to Mode 1
         layout.addRow("Binarization Strategy:", self.mode_selector)
-
-        self.umap = QPushButton("If using manual threshold: Also generate identity UMAP?")
-        self.umap.setCheckable(True)
-        self.umap.setChecked(True)
-        layout.addWidget(self.umap)
         
         self.include = QPushButton("Include When a Node is Negative for an ID?")
         self.include.setCheckable(True)
@@ -7965,7 +8434,7 @@ class MergeNodeIdDialog(QDialog):
             z_scale = float(self.z_scale.text()) if self.z_scale.text().strip() else 1
             data = self.parent().channel_data[0]
             include = self.include.isChecked()
-            umap = self.umap.isChecked()
+            umap = True
             
             if data is None:
                 return
@@ -8101,15 +8570,13 @@ class MergeNodeIdDialog(QDialog):
                 result = {key: np.array([d[key] for d in id_dicts]) for key in all_keys}
 
 
-                self.parent().format_for_upperright_table(result, 'NodeID', good_list, 'Mean Intensity')
-                if umap:
-                    my_network.identity_umap(result)
+                self.parent().format_for_upperright_table(result, 'NodeID', good_list, 'Mean Intensity (Save this Table for "Analyze -> Stats -> Show Violins")')
 
 
                 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)"
+                    "Node Identities Merged. New IDs represent presence of corresponding img foreground with +, absence with -. If desired, please save your new identities as csv, then use File -> Load -> Load From Excel Helper to bulk search and rename desired combinations. If desired, please save the outputted mean intensity table to use with 'Analyze -> Stats -> Show Violins'. (Press Help [above] for more info)"
                 )
 
                 self.accept()
@@ -8131,6 +8598,89 @@ class MergeNodeIdDialog(QDialog):
             print(traceback.format_exc())
             #print(f"Error: {e}")
 
+class MultiChanDialog(QDialog):
+
+    def __init__(self, parent=None, data = None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Channel Loading")
+        self.setModal(False)
+        
+        layout = QFormLayout(self)
+
+        self.data = data
+
+        self.nodes = QComboBox()
+        self.edges = QComboBox()
+        self.overlay1 = QComboBox()
+        self.overlay2 = QComboBox()
+        options = ["None"]
+        for i in range(self.data.shape[0]):
+            options.append(str(i))
+        self.nodes.addItems(options)
+        self.edges.addItems(options)
+        self.overlay1.addItems(options)
+        self.overlay2.addItems(options)
+        self.nodes.setCurrentIndex(0)
+        self.edges.setCurrentIndex(0)
+        self.overlay1.setCurrentIndex(0)
+        self.overlay2.setCurrentIndex(0)
+        layout.addRow("Load this channel into nodes?", self.nodes)
+        layout.addRow("Load this channel into edges?", self.edges)
+        layout.addRow("Load this channel into overlay1?", self.overlay1)
+        layout.addRow("Load this channel into overlay2?", self.overlay2)
+
+        run_button = QPushButton("Load Channels")
+        run_button.clicked.connect(self.run)
+        layout.addWidget(run_button)
+
+        run_button2 = QPushButton("Save Channels to Directory")
+        run_button2.clicked.connect(self.run2)
+        layout.addWidget(run_button2)
+
+
+    def run(self):
+
+        try:
+            node_chan = int(self.nodes.currentText())
+            self.parent().load_channel(0, self.data[node_chan, :, :, :], data = True)
+        except:
+            pass
+        try:
+            edge_chan = int(self.edges.currentText())
+            self.parent().load_channel(1, self.data[edge_chan, :, :, :], data = True)
+        except:
+            pass
+        try:
+            overlay1_chan = int(self.overlay1.currentText())
+            self.parent().load_channel(2, self.data[overlay1_chan, :, :, :], data = True)
+        except:
+            pass
+        try:
+            overlay2_chan = int(self.overlay2.currentText())
+            self.parent().load_channel(3, self.data[overlay2_chan, :, :, :], data = True)
+        except:
+            pass
+
+    def run2(self):
+
+        try:
+            # First let user select parent directory
+            parent_dir = QFileDialog.getExistingDirectory(
+                self,
+                "Select Location to Save Channels",
+                "",
+                QFileDialog.Option.ShowDirsOnly
+            )
+
+            for i in range(self.data.shape[0]):
+                try:
+                    tifffile.imwrite(f'{parent_dir}/C{i}.tif', self.data[i, :, :, :])
+                except:
+                    continue
+        except:
+            pass
+
 
 class Show3dDialog(QDialog):
     def __init__(self, parent=None):
@@ -8198,6 +8748,9 @@ class Show3dDialog(QDialog):
                         if visible:
                             arrays_4d.append(channel)
 
+            if self.parent().thresh_window_ref is not None:
+                self.parent().thresh_window_ref.make_full_highlight()
+
             if self.parent().highlight_overlay is not None or self.parent().mini_overlay_data is not None:
                 if self.parent().mini_overlay == True:
                     self.parent().create_highlight_overlay(node_indices = self.parent().clicked_values['nodes'], edge_indices = self.parent().clicked_values['edges'])
@@ -8209,6 +8762,11 @@ class Show3dDialog(QDialog):
             self.accept()
 
         except Exception as e:
+            QMessageBox.critical(
+                self,
+                "Error",
+                f"Error showing 3D: {str(e)}\nNote: You may need to install napari first - in your environment, please call 'pip install napari'"
+            )
             print(f"Error: {e}")
             import traceback
             print(traceback.format_exc())
@@ -8224,6 +8782,9 @@ class NetOverlayDialog(QDialog):
 
         layout = QFormLayout(self)
 
+        self.downsample = QLineEdit("")
+        layout.addRow("Downsample Factor While Drawing? (Int - Makes the outputted lines larger):", self.downsample)
+
         # Add Run button
         run_button = QPushButton("Generate (Will go to Overlay 1)")
         run_button.clicked.connect(self.netoverlay)
@@ -8240,7 +8801,16 @@ class NetOverlayDialog(QDialog):
             if my_network.node_centroids is None:
                 return
 
-            my_network.network_overlay = my_network.draw_network()
+            try:
+                downsample = float(self.downsample.text()) if self.downsample.text() else None
+            except ValueError:
+                downsample = None
+
+            my_network.network_overlay = my_network.draw_network(down_factor = downsample)
+
+            if downsample is not None: 
+                my_network.network_overlay = n3d.upsample_with_padding(my_network.network_overlay, original_shape = self.parent().shape)
+
 
             self.parent().load_channel(2, channel_data = my_network.network_overlay, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
@@ -8267,6 +8837,9 @@ class IdOverlayDialog(QDialog):
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
+        self.downsample = QLineEdit("")
+        layout.addRow("Downsample Factor While Drawing? (Int - Makes the outputted numbers larger):", self.downsample)
+
         # Add Run button
         run_button = QPushButton("Generate (Will go to Overlay 2)")
         run_button.clicked.connect(self.idoverlay)
@@ -8274,38 +8847,51 @@ class IdOverlayDialog(QDialog):
 
     def idoverlay(self):
 
-        accepted_mode = self.mode_selector.currentIndex()
+        try:
 
-        if accepted_mode == 0:
+            accepted_mode = self.mode_selector.currentIndex()
 
-            if my_network.node_centroids is None:
+            try:
+                downsample = float(self.downsample.text()) if self.downsample.text() else None
+            except ValueError:
+                downsample = None
 
-                self.parent().show_centroid_dialog()
+            if accepted_mode == 0:
 
-            if my_network.node_centroids is None:
-                return
+                if my_network.node_centroids is None:
 
-        elif accepted_mode == 1:
+                    self.parent().show_centroid_dialog()
 
-            if my_network.edge_centroids is None:
+                if my_network.node_centroids is None:
+                    return
 
-                self.parent().show_centroid_dialog()
+            elif accepted_mode == 1:
 
-            if my_network.edge_centroids is None:
-                return
+                if my_network.edge_centroids is None:
 
-        if accepted_mode == 0:
+                    self.parent().show_centroid_dialog()
 
-            my_network.id_overlay = my_network.draw_node_indices()
+                if my_network.edge_centroids is None:
+                    return
 
-        elif accepted_mode == 1:
+            if accepted_mode == 0:
 
-            my_network.id_overlay = my_network.draw_edge_indices()
+                my_network.id_overlay = my_network.draw_node_indices(down_factor = downsample)
 
+            elif accepted_mode == 1:
 
-        self.parent().load_channel(3, channel_data = my_network.id_overlay, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
+                my_network.id_overlay = my_network.draw_edge_indices(down_factor = downsample)
+
+            if downsample is not None:
+                my_network.id_overlay = n3d.upsample_with_padding(my_network.id_overlay, original_shape = self.parent().shape)
+
+            self.parent().load_channel(3, channel_data = my_network.id_overlay, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
+
+            self.accept()
+
+        except:
+            print(f"Error with Overlay Generation: {e}")
 
-        self.accept()
 
 class ColorOverlayDialog(QDialog):
 
@@ -8327,7 +8913,7 @@ class ColorOverlayDialog(QDialog):
         layout.addRow("Execution Mode:", self.mode_selector)
 
         self.down_factor = QLineEdit("")
-        layout.addRow("down_factor (for speeding up overlay generation - optional):", self.down_factor)
+        layout.addRow("down_factor (int - for speeding up overlay generation - optional):", self.down_factor)
 
         # Add Run button
         run_button = QPushButton("Generate (Will go to Overlay 2)")
@@ -8481,11 +9067,6 @@ class NetShowDialog(QDialog):
         self.weighted.setCheckable(True)
         self.weighted.setChecked(True)
         layout.addRow("Use Weighted Network (Only for community graphs):", self.weighted)
-
-        # Optional saving:
-        self.directory = QLineEdit()
-        self.directory.setPlaceholderText("Does not save when empty")
-        layout.addRow("Output Directory:", self.directory)
         
         # Add Run button
         run_button = QPushButton("Show Network")
@@ -8501,7 +9082,7 @@ class NetShowDialog(QDialog):
                 self.parent().show_centroid_dialog()
         accepted_mode = self.mode_selector.currentIndex()  # Convert to 1-based index
         # Get directory (None if empty)
-        directory = self.directory.text() if self.directory.text() else None
+        directory = None
 
         weighted = self.weighted.isChecked()
 
@@ -8544,7 +9125,7 @@ class PartitionDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Label Propogation", "Louvain"])
+        self.mode_selector.addItems(["Louvain", "Label Propogation"])
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
@@ -8567,6 +9148,10 @@ class PartitionDialog(QDialog):
         self.parent().prev_coms = None
 
         accepted_mode = self.mode_selector.currentIndex()
+        if accepted_mode == 0: #I switched where these are in the selection box
+            accepted_mode = 1
+        elif accepted_mode == 1:
+            accepted_mode = 0
         weighted = self.weighted.isChecked()
         dostats = self.stats.isChecked()
 
@@ -8738,7 +9323,7 @@ class ComNeighborDialog(QDialog):
 
             mode = self.mode.currentIndex()
 
-            seed = float(self.seed.text()) if self.seed.text().strip() else 42
+            seed = int(self.seed.text()) if self.seed.text().strip() else 42
 
             limit = int(self.limit.text()) if self.limit.text().strip() else None
 
@@ -8843,9 +9428,6 @@ class RadialDialog(QDialog):
         self.distance = QLineEdit("50")
         layout.addRow("Bucket Distance for Searching For Node Neighbors (automatically scaled by xy and z scales):", self.distance)
 
-        self.directory = QLineEdit("")
-        layout.addRow("Output Directory:", self.directory)
-
         # Add Run button
         run_button = QPushButton("Get Radial Distribution")
         run_button.clicked.connect(self.radial)
@@ -8857,7 +9439,7 @@ class RadialDialog(QDialog):
 
             distance = float(self.distance.text()) if self.distance.text().strip() else 50
 
-            directory = str(self.distance.text()) if self.directory.text().strip() else None
+            directory = None
 
             if my_network.node_centroids is None:
                 self.parent().show_centroid_dialog()
@@ -8888,12 +9470,16 @@ class NearNeighDialog(QDialog):
         if my_network.node_identities is not None:
 
             self.root = QComboBox()
-            self.root.addItems(list(set(my_network.node_identities.values())))  
+            roots = list(set(my_network.node_identities.values()))
+            roots.sort()
+            roots.append("All (Excluding Targets)")
+            self.root.addItems(roots)  
             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.sort()
             neighs.append("All Others (Excluding Self)")
             self.targ.addItems(neighs)  
             self.targ.setCurrentIndex(0)
@@ -8931,6 +9517,11 @@ class NearNeighDialog(QDialog):
         self.numpy.setChecked(False)
         self.numpy.clicked.connect(self.toggle_map)
         heatmap_layout.addRow("Overlay:", self.numpy)
+
+        self.mode = QComboBox()
+        self.mode.addItems(["Anywhere", "Within Masked Bounds of Edges", "Within Masked Bounds of Overlay1", "Within Masked Bounds of Overlay2"])
+        self.mode.setCurrentIndex(0)
+        heatmap_layout.addRow("For heatmap, measure theoretical point distribution how?", self.mode)
         
         main_layout.addWidget(heatmap_group)
 
@@ -9018,35 +9609,52 @@ class NearNeighDialog(QDialog):
             except:
                 targ = None
 
+            if root == "All (Excluding Targets)" and targ == 'All Others (Excluding Self)':
+                root = None
+                targ = None
+
+            mode = self.mode.currentIndex()
+
+            if mode == 0:
+                mask = None
+            else:
+                try:
+                    mask = self.parent().channel_data[mode] != 0
+                except:
+                    print("Could not binarize mask")
+                    mask = 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
             quant = self.quant.isChecked()
             centroids = self.centroids.isChecked()
+
             if not centroids:
+                print("Using 1 nearest neighbor due to not using centroids")
                 num = 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)"
+                header = f"Avg Shortest Distance to Closest {num} {targ}(s)"
                 header2 = f"{root} Node ID"
                 header3 = f'Theoretical Uniform Distance to Closest {num} {targ}(s)'
             else:
                 title = f"Nearest {num} Neighbor(s) Distance Between Nodes"
-                header = f"Shortest Distance to Closest {num} Nodes"
+                header = f"Avg Shortest Distance to Closest {num} Nodes"
                 header2 = "Root Node ID"
                 header3 = f'Simulated Theoretical Uniform Distance to Closest {num} Nodes'
 
-            if centroids and my_network.node_centroids is None:
+            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, quant_overlay, pred = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant, centroids = centroids)
+                avg, output, quant_overlay, pred = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant, centroids = centroids, mask = mask)
             else:
-                avg, output, overlay, quant_overlay, pred = 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, centroids = centroids)
+                avg, output, overlay, quant_overlay, pred = 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, centroids = centroids, mask = mask)
                 self.parent().load_channel(3, overlay, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
             if quant_overlay is not None:
@@ -9115,9 +9723,6 @@ class NeighborIdentityDialog(QDialog):
         else:
             self.root = None
 
-        self.directory = QLineEdit("")
-        layout.addRow("Output Directory:", self.directory)
-
         self.mode = QComboBox()
         self.mode.addItems(["From Network - Based on Absolute Connectivity", "Use Labeled Nodes - Based on Morphological Neighborhood Densities"])
         self.mode.setCurrentIndex(0)
@@ -9145,7 +9750,7 @@ class NeighborIdentityDialog(QDialog):
             except:
                 pass
 
-            directory = self.directory.text() if self.directory.text().strip() else None
+            directory = None
 
             mode = self.mode.currentIndex()
 
@@ -9599,6 +10204,22 @@ class InteractionDialog(QDialog):
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
+        self.length = QPushButton("Return Lengths")
+        self.length.setCheckable(True)
+        self.length.setChecked(False)
+        layout.addRow("(Will Skeletonize the Edge Mirror and use that to calculate adjacent length of edges, as opposed to default volumes):", self.length)
+
+        self.auto = QPushButton("Auto")
+        self.auto.setCheckable(True)
+        try:
+            if self.parent().shape[0] == 1:
+                self.auto.setChecked(False)
+            else:
+                self.auto.setChecked(True)
+        except:
+            self.auto.setChecked(False)
+        layout.addRow("(If Above): Attempt to Auto Correct Skeleton Looping:", self.auto)
+
         self.fastdil = QPushButton("Fast Dilate")
         self.fastdil.setCheckable(True)
         self.fastdil.setChecked(False)
@@ -9622,10 +10243,16 @@ class InteractionDialog(QDialog):
                 
 
             fastdil = self.fastdil.isChecked()
+            length = self.length.isChecked()
+            auto = self.auto.isChecked()
 
-            result = my_network.interactions(search = node_search, cores = accepted_mode, fastdil = fastdil)
+            result = my_network.interactions(search = node_search, cores = accepted_mode, skele = length, length = length, auto = auto, fastdil = fastdil)
+
+            if not length:
+                self.parent().format_for_upperright_table(result, 'Node ID', ['Volume of Nearby Edge (Scaled)', 'Volume of Search Region (Scaled)'], title = 'Node/Edge Interactions')
+            else:
+                self.parent().format_for_upperright_table(result, 'Node ID', ['~Length of Nearby Edge (Scaled)', 'Volume of Search Region (Scaled)'], title = 'Node/Edge Interactions')
 
-            self.parent().format_for_upperright_table(result, 'Node ID', ['Volume of Nearby Edge (Scaled)', 'Volume of Search Region'], title = 'Node/Edge Interactions')
 
             self.accept()
 
@@ -9637,70 +10264,471 @@ class InteractionDialog(QDialog):
             print(f"Error finding interactions: {e}")
 
 
-class DegreeDialog(QDialog):
-
+class ViolinDialog(QDialog):
 
     def __init__(self, parent=None):
 
         super().__init__(parent)
-        self.setWindowTitle("Degree Parameters")
-        self.setModal(True)
 
-        layout = QFormLayout(self)
+        QMessageBox.critical(
+            self,
+            "Notice",
+            "Please select spreadsheet (Should be table output of 'File -> Images -> Node Identities -> Assign Node Identities from Overlap with Other Images'. Make sure to save that table as .csv/.xlsx and then load it here to use this.)"
+        )
 
-        layout.addRow("Note:", QLabel(f"This operation will be executed on the image in 'Active Image', unless it is set to edges in which case it will use the nodes. \n (This is because you may want to run it on isolated nodes that have been placed in the Overlay channels)\nWe can draw optional overlays to Overlay 2 as described below:"))
+        try:
+            try:
+                self.df = self.parent().load_file()
+            except:
+                return
 
-        # 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)", "Create Heatmap of Degrees"])
-        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
-        layout.addRow("Execution Mode:", self.mode_selector)
+            self.backup_df = copy.deepcopy(self.df)
+            try:
+                # Get all identity lists and normalize the dataframe
+                identity_lists = self.get_all_identity_lists()
+                self.df = self.normalize_df_with_identity_centerpoints(self.df, identity_lists)
+            except:
+                pass
 
-        self.mask_limiter = QLineEdit("1")
-        layout.addRow("Proportion of high degree nodes to keep (ignore if only returning degrees)", self.mask_limiter)
+            self.setWindowTitle("Violin Parameters")
+            self.setModal(False)
 
-        self.down_factor = QLineEdit("1")
-        layout.addRow("down_factor (for speeding up overlay generation - ignore if only returning degrees:", self.down_factor)
+            layout = QFormLayout(self)
 
-        # Add Run button
-        run_button = QPushButton("Get Degrees")
-        run_button.clicked.connect(self.degs)
-        layout.addWidget(run_button)
+            if my_network.node_identities is not None:
+
+                self.idens = QComboBox()
+                all_idens = list(set(my_network.node_identities.values()))
+                idens = []
+                for iden in all_idens:
+                    if '[' not in iden:
+                        idens.append(iden)
+                idens.sort()
+                idens.insert(0, "None")
+                self.idens.addItems(idens)  
+                self.idens.setCurrentIndex(0)
+                layout.addRow("Return Identity Violin Plots?", self.idens)
+            
+            if my_network.communities is not None:
+                self.coms = QComboBox()
+                coms = list(set(my_network.communities.values()))
+                coms.sort()
+                coms.insert(0, "None")
+                coms = [str(x) for x in coms]
+                self.coms.addItems(coms)  
+                self.coms.setCurrentIndex(0)
+                layout.addRow("Return Neighborhood/Community Violin Plots?", self.coms)
 
-    def degs(self):
+            # Add Run button
+            run_button = QPushButton("Show Z-score-like Violin")
+            run_button.clicked.connect(self.run)
+            layout.addWidget(run_button)
 
-        try:
+            run_button2 = QPushButton("Show Z-score UMAP")
+            run_button2.clicked.connect(self.run2)
 
-            accepted_mode = self.mode_selector.currentIndex()
+            self.mode_selector = QComboBox()
+            self.mode_selector.addItems(["Label UMAP By Identity", "Label UMAP By Neighborhood/Community"])
+            self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+            layout.addRow("Execution Mode:", self.mode_selector)
 
-            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
+            layout.addRow(self.mode_selector, run_button2)
 
+            # Button in left column, input in right column
+            run_button3 = QPushButton("Assign Neighborhoods via KMeans Clustering")
+            run_button3.clicked.connect(self.run3)
 
-            try:
-                down_factor = float(self.down_factor.text()) if self.down_factor.text() else 1
-            except ValueError:
-                down_factor = 1
+            self.kmeans_num_input = QLineEdit()
+            self.kmeans_num_input.setPlaceholderText("Auto (num neighborhoods)")
+            self.kmeans_num_input.setMaximumWidth(150)
+            from PyQt6.QtGui import QIntValidator
+            self.kmeans_num_input.setValidator(QIntValidator(1, 1000))
 
-            try:
-                mask_limiter = float(self.mask_limiter.text()) if self.mask_limiter.text() else 1
-            except ValueError:
-                mask_limiter = 1
+            # QFormLayout's addRow takes (label/widget, field/widget)
+            layout.addRow(run_button3, self.kmeans_num_input)
 
-            if self.parent().active_channel == 1:
-                active_data = self.parent().channel_data[0]
-            else:
-                # Get the active channel data from parent
-                active_data = self.parent().channel_data[self.parent().active_channel]
-                if active_data is None:
-                    raise ValueError("No active image selected")
+        except:
+            import traceback
+            print(traceback.format_exc())
+            QTimer.singleShot(0, self.close)
 
-            if my_network.node_centroids is None and accepted_mode > 0:
-                self.parent().show_centroid_dialog()
+    def get_all_identity_lists(self):
+        """
+        Get all identity lists for normalization purposes.
+        
+        Returns:
+        dict: Dictionary where keys are identity names and values are lists of node IDs
+        """
+        identity_lists = {}
+        
+        # Get all unique identities
+        all_identities = set()
+        import ast
+        for item in my_network.node_identities:
+            try:
+                parse = ast.literal_eval(my_network.node_identities[item])
+                if isinstance(parse, (list, tuple, set)):
+                    all_identities.update(parse)
+                else:
+                    all_identities.add(str(parse))
+            except:
+                all_identities.add(str(my_network.node_identities[item]))
+        
+        # For each identity, get the list of nodes that have it
+        for identity in all_identities:
+            iden_list = []
+            for item in my_network.node_identities:
+                try:
+                    parse = ast.literal_eval(my_network.node_identities[item])
+                    if identity in parse:
+                        iden_list.append(item)
+                except:
+                    if identity == str(my_network.node_identities[item]):
+                        iden_list.append(item)
+            
+            if iden_list:  # Only add if we found nodes
+                identity_lists[identity] = iden_list
+        
+        return identity_lists
+
+    def prepare_data_for_umap(self, df, node_identities=None):
+        """
+        Prepare data for UMAP visualization by z-score normalizing columns.
+        
+        Args:
+            df: DataFrame with first column as NodeID, rest as marker intensities
+            node_identities: Optional dict mapping node_id (int) -> identity (string).
+                            If provided, only nodes present as keys will be kept.
+            
+        Returns:
+            dict: {node_id: [normalized_marker_values]}
+        """
+        from sklearn.preprocessing import StandardScaler
+        import numpy as np
+        
+        # Filter dataframe if node_identities is provided
+        if my_network.node_identities is not None:
+            # Get the valid node IDs from node_identities keys
+            valid_node_ids = set(my_network.node_identities.keys())
+            
+            # Filter df to only keep rows where first column value is in valid_node_ids
+            mask = df.iloc[:, 0].isin(valid_node_ids)
+            df = df[mask].copy()
+            
+            # Optional: Check if any rows remain after filtering
+            if len(df) == 0:
+                raise ValueError("No matching nodes found between df and node_identities")
+        
+        # Extract node IDs from first column
+        node_ids = df.iloc[:, 0].values
+        
+        # Extract marker data (all columns except first)
+        X = df.iloc[:, 1:].values
+        
+        # Z-score normalization (column-wise)
+        scaler = StandardScaler()
+        X_normalized = scaler.fit_transform(X)
+        
+        # Create dictionary mapping node_id -> normalized row
+        result_dict = {
+            int(node_ids[i]): X_normalized[i].tolist() 
+            for i in range(len(node_ids))
+        }
+        
+        return result_dict
+
+
+    def normalize_df_with_identity_centerpoints(self, df, identity_lists):
+        """
+        Normalize the entire dataframe using identity-specific centerpoints.
+        Uses Z-score-like normalization with identity centerpoint as the "mean".
+        
+        Parameters:
+        df (pd.DataFrame): Original dataframe
+        identity_lists (dict): Dictionary where keys are identity names and values are lists of node IDs
+        
+        Returns:
+        pd.DataFrame: Normalized dataframe
+        """
+        # Make a copy to avoid modifying the original dataframe
+        df_copy = df.copy()
+        
+        # Set the first column as the index (row headers)
+        df_copy = df_copy.set_index(df_copy.columns[0])
+        
+        # Convert all remaining columns to float type (batch conversion)
+        df_copy = df_copy.astype(float)
+        
+        # First, calculate the centerpoint for each column by finding the min across all identity groups
+        column_centerpoints = {}
+        
+        for column in df_copy.columns:
+            centerpoint = None
+            
+            for identity, node_list in identity_lists.items():
+                # Get nodes that exist in both the identity list and the dataframe
+                valid_nodes = [node for node in node_list if node in df_copy.index]
+                if valid_nodes and ((str(identity) == str(column)) or str(identity) == f'{str(column)}+'):
+                    # Get the min value for this identity in this column
+                    identity_min = df_copy.loc[valid_nodes, column].min()
+                    centerpoint = identity_min
+                    break  # Found the match, no need to continue
+            
+            if centerpoint is not None:
+                # Use the identity-specific centerpoint
+                column_centerpoints[column] = centerpoint
+            else:
+                # Fallback: if no matching identity, use column median
+                print(f"Could not find {str(column)} in node identities. As a fallback, using the median of all values in this channel rather than the minimum of user-designated valid values.")
+                column_centerpoints[column] = df_copy[column].median()
+        
+        # Now normalize each column using Z-score-like calculation with identity centerpoint
+        df_normalized = df_copy.copy()
+        for column in df_copy.columns:
+            centerpoint = column_centerpoints[column]
+            # Calculate standard deviation of the column
+            std_dev = df_copy[column].std()
+            
+            if std_dev > 0:  # Avoid division by zero
+                # Z-score-like: (value - centerpoint) / std_dev
+                df_normalized[column] = (df_copy[column] - centerpoint) / std_dev
+            else:
+                # If std_dev is 0, just subtract centerpoint
+                df_normalized[column] = df_copy[column] - centerpoint
+        
+        # Convert back to original format with first column as regular column
+        df_normalized = df_normalized.reset_index()
+        
+        return df_normalized
+
+    def show_in_table(self, df, metric, title):
+
+        # Create new table
+        table = CustomTableView(self.parent())
+        table.setModel(PandasModel(df))
+
+        try:
+            first_column_name = table.model()._data.columns[0]
+            table.sort_table(first_column_name, ascending=True)
+        except:
+             pass
+        
+        # Add to tabbed widget
+        if title is None:
+            self.parent().tabbed_data.add_table(f"{metric} Analysis", table)
+        else:
+            self.parent().tabbed_data.add_table(f"{title}", table)
+        
+
+
+        # Adjust column widths to content
+        for column in range(table.model().columnCount(None)):
+            table.resizeColumnToContents(column)
+
+    def run(self):
+
+        def df_to_dict_by_rows(df, row_indices, title):
+            """
+            Convert a pandas DataFrame to a dictionary by selecting specific rows.
+            No normalization - dataframe is already normalized.
+            
+            Parameters:
+            df (pd.DataFrame): DataFrame with first column as row headers, remaining columns contain floats
+            row_indices (list): List of values from the first column representing rows to include
+            
+            Returns:
+            dict: Dictionary where keys are column headers and values are lists of column values (as floats)
+                  for the specified rows
+            """
+            # Make a copy to avoid modifying the original dataframe
+            df_copy = df.copy()
+            
+            # Set the first column as the index (row headers)
+            df_copy = df_copy.set_index(df_copy.columns[0])
+            
+            # Mask the dataframe to include only the specified rows
+            masked_df = df_copy.loc[row_indices]
+            
+            # Create empty dictionary
+            result_dict = {}
+            
+            # For each column, add the column header as key and column values as list
+            for column in masked_df.columns:
+                result_dict[column] = masked_df[column].tolist()
+            
+            masked_df.insert(0, "NodeIDs", row_indices)
+            self.show_in_table(masked_df, metric = "NodeID", title = title)
+
+
+            return result_dict
+
+        from . import neighborhoods
+
+        try:
+
+            if self.idens.currentIndex() != 0:
+
+                iden = self.idens.currentText()
+                iden_list = []
+                import ast
+
+                for item in my_network.node_identities:
+
+                    try:
+                        parse = ast.literal_eval(my_network.node_identities[item])
+                        if iden in parse:
+                            iden_list.append(item)
+                    except:
+                        if (iden == my_network.node_identities[item]):
+                            iden_list.append(item)
+
+                violin_dict = df_to_dict_by_rows(self.df, iden_list, f"Z-Score-like Channel Intensities of Identity {iden}, {len(iden_list)} Nodes")
+
+                neighborhoods.create_violin_plots(violin_dict, graph_title=f"Z-Score-like Channel Intensities of Identity {iden}, {len(iden_list)} Nodes")
+        except:
+            pass
+
+        try:
+            if self.coms.currentIndex() != 0:
+
+                com = self.coms.currentText()
+
+                com_dict = n3d.invert_dict(my_network.communities)
+
+                com_list = com_dict[int(com)]
+
+                violin_dict = df_to_dict_by_rows(self.df, com_list, f"Z-Score-like Channel Intensities of Community/Neighborhood {com}, {len(com_list)} Nodes")
+
+                neighborhoods.create_violin_plots(violin_dict, graph_title=f"Z-Score-like Channel Intensities of Community/Neighborhood {com}, {len(com_list)} Nodes")
+        except:
+            pass
+
+    """
+    def run2(self):
+        def df_to_dict(df):
+            # Make a copy to avoid modifying the original dataframe
+            df_copy = df.copy()
+            
+            # Set the first column as the index (row headers)
+            df_copy = df_copy.set_index(df_copy.columns[0])
+            
+            # Convert all remaining columns to float type (batch conversion)
+            df_copy = df_copy.astype(float)
+            
+            # Create the result dictionary
+            result_dict = {}
+            for row_idx in df_copy.index:
+                result_dict[row_idx] = df_copy.loc[row_idx].tolist()
+            
+            return result_dict
+        
+        try:
+            umap_dict = df_to_dict(self.backup_df)
+            my_network.identity_umap(umap_dict)
+        except:
+            pass
+    """
+
+    def run2(self):
+        
+        try:
+            umap_dict = self.prepare_data_for_umap(self.backup_df)
+            mode = self.mode_selector.currentIndex()
+            my_network.identity_umap(umap_dict, mode)
+        except:
+            import traceback
+            print(traceback.format_exc())
+            pass
+
+    def run3(self):
+
+        num_clusters_text = self.kmeans_num_input.text()
+        
+        if num_clusters_text:
+            num_clusters = int(num_clusters_text)
+            # Use specified number of clusters
+            print(f"Using {num_clusters} clusters")
+        else:
+            num_clusters = None  # Auto-determine
+            print("Auto-determining number of clusters")
+
+        try:
+            cluster_dict = self.prepare_data_for_umap(self.backup_df)
+            my_network.group_nodes_by_intensity(cluster_dict, count = num_clusters)
+            self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'Community')
+            self.accept()
+        except:
+            import traceback
+            print(traceback.format_exc())
+            pass
+
+
+
+
+class DegreeDialog(QDialog):
+
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Degree Parameters")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        layout.addRow("Note:", QLabel(f"This operation will be executed on the image in 'Active Image', unless it is set to edges in which case it will use the nodes. \n (This is because you may want to run it on isolated nodes that have been placed in the Overlay channels)\nWe can draw optional overlays to Overlay 2 as described below:"))
+
+        # 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)", "Create Heatmap of Degrees"])
+        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("Execution Mode:", self.mode_selector)
+
+        self.mask_limiter = QLineEdit("1")
+        layout.addRow("Proportion of high degree nodes to keep (ignore if only returning degrees)", self.mask_limiter)
+
+        self.down_factor = QLineEdit("1")
+        layout.addRow("down_factor (for speeding up overlay generation - ignore if only returning degrees:", self.down_factor)
+
+        # Add Run button
+        run_button = QPushButton("Get Degrees")
+        run_button.clicked.connect(self.degs)
+        layout.addWidget(run_button)
+
+    def degs(self):
+
+        try:
+
+            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:
+                down_factor = 1
+
+            try:
+                mask_limiter = float(self.mask_limiter.text()) if self.mask_limiter.text() else 1
+            except ValueError:
+                mask_limiter = 1
+
+            if self.parent().active_channel == 1:
+                active_data = self.parent().channel_data[0]
+            else:
+                # Get the active channel data from parent
+                active_data = self.parent().channel_data[self.parent().active_channel]
+                if active_data is None:
+                    raise ValueError("No active image selected")
+
+            if my_network.node_centroids is None and accepted_mode > 0:
+                self.parent().show_centroid_dialog()
                 if my_network.node_centroids is None:
                     accepted_mode == 0
                     print("Error retrieving centroids")
@@ -9892,6 +10920,9 @@ class MotherDialog(QDialog):
 
         except Exception as e:
 
+            import traceback
+            print(traceback.format_exc())
+
             print(f"Error finding mothers: {e}")
 
 
@@ -10010,7 +11041,7 @@ class ResizeDialog(QDialog):
 
     def run_resize(self, undo = False, upsize = True, special = False):
         try:
-            self.parent().resizing = False
+            self.parent().resizing = True
             # Get parameters
             try:
                 resize = float(self.resize.text()) if self.resize.text() else None
@@ -10125,6 +11156,7 @@ class ResizeDialog(QDialog):
                 if channel is not None:
                     self.parent().slice_slider.setMinimum(0)
                     self.parent().slice_slider.setMaximum(channel.shape[0] - 1)
+                    self.parent().shape = channel.shape
                     break
 
             if not special:
@@ -10194,10 +11226,7 @@ class ResizeDialog(QDialog):
                 except Exception as e:
                     print(f"Error loading edge centroid table: {e}")
 
-                    
             self.parent().update_display()
-            self.reset_fields()
-            self.parent().resizing = False
             self.accept()
             
         except Exception as e:
@@ -10206,6 +11235,79 @@ class ResizeDialog(QDialog):
             print(traceback.format_exc())
             QMessageBox.critical(self, "Error", f"Failed to resize: {str(e)}")
 
+class CleanDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Some options for cleaning segmentation")
+        self.setModal(False)
+
+        layout = QFormLayout(self)
+
+        # Add Run button
+        run_button = QPushButton("Close")
+        run_button.clicked.connect(self.close)
+        layout.addRow("Close (Fill Small Gaps - Dilate then Erode by same amount):", run_button)
+
+        # Add Run button
+        run_button = QPushButton("Open")
+        run_button.clicked.connect(self.open)
+        layout.addRow("Open (Eliminate Noise, Jagged Borders, and Small Connections Between Objects - Erode then Dilate by same amount):", run_button)
+
+        # Add Run button
+        run_button = QPushButton("Fill Holes")
+        run_button.clicked.connect(self.holes)
+        layout.addRow("Call the fill holes function:", run_button)
+
+        # Add Run button
+        run_button = QPushButton("Threshold Noise")
+        run_button.clicked.connect(self.thresh)
+        layout.addRow("Threshold Noise By Volume:", run_button)
+
+    def close(self):
+
+        try:
+            self.parent().show_dilate_dialog(args = [1])
+            self.parent().show_erode_dialog(args = [self.parent().last_dil])
+        except:
+            pass
+
+    def open(self):
+
+        try:
+            self.parent().show_erode_dialog(args = [1])
+            self.parent().show_dilate_dialog(args = [self.parent().last_ero])
+        except:
+            pass
+
+    def holes(self):
+
+        try:
+            self.parent().show_hole_dialog()
+        except:
+            pass
+
+    def thresh(self):
+        try:
+            if len(np.unique(self.parent().channel_data[self.parent().active_channel])) < 3:
+                self.parent().show_label_dialog()
+
+            if self.parent().volume_dict[self.parent().active_channel] is None:
+                self.parent().volumes()
+
+            thresh_window = ThresholdWindow(self.parent(), 1)
+            thresh_window.show()  # Non-modal window
+            self.parent().highlight_overlay = None
+            #self.mini_overlay = False
+            self.parent().mini_overlay_data = None
+        except:
+            import traceback
+            print(traceback.format_exc())
+            pass
+
+
+
+
+
 
 class OverrideDialog(QDialog):
     def __init__(self, parent=None):
@@ -10439,7 +11541,7 @@ class LabelDialog(QDialog):
 class SLabelDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.setWindowTitle("Smart Label (Use label array to assign label neighborhoods to binary array)?")
+        self.setWindowTitle("Label a binary image based on it's voxels proximity to labeled components of a second image?")
         self.setModal(True)
         
         layout = QFormLayout(self)
@@ -10451,7 +11553,7 @@ class SLabelDialog(QDialog):
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Prelabeled Array:", self.mode_selector)
 
-        layout.addRow(QLabel("Will Label Neighborhoods in: "))
+        layout.addRow(QLabel("Will Label Binary Foreground Voxels in: "))
 
         # Add mode selection dropdown
         self.target_selector = QComboBox()
@@ -10497,10 +11599,6 @@ class SLabelDialog(QDialog):
                 # Update both the display data and the network object
                 binary_array = sdl.smart_label(binary_array, label_array, directory = None, GPU = GPU, predownsample = down_factor, remove_template = True)
 
-                label_array = sdl.invert_array(label_array)
-
-                binary_array = binary_array * label_array
-
                 self.parent().load_channel(accepted_target, binary_array, True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
 
                 self.accept()
@@ -10579,12 +11677,11 @@ class ThresholdDialog(QDialog):
                     print("Error - please calculate network first")
                     return
 
-            if self.parent().mini_overlay_data is not None:
-                self.parent().mini_overlay_data = None
-
             thresh_window = ThresholdWindow(self.parent(), accepted_mode)
             thresh_window.show()  # Non-modal window
             self.highlight_overlay = None
+            #self.mini_overlay = False
+            self.mini_overlay_data = None
             self.accept()
         except:
             import traceback
@@ -11517,6 +12614,7 @@ class ThresholdWindow(QMainWindow):
 
     def __init__(self, parent=None, accepted_mode=0):
         super().__init__(parent)
+        self.parent().thresh_window_ref = self
         self.setWindowTitle("Threshold")
 
         self.accepted_mode = accepted_mode
@@ -11558,16 +12656,23 @@ class ThresholdWindow(QMainWindow):
             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
-                temp_max = np.max(self.parent().channel_data[self.parent().active_channel])
-                temp_min = np.min(self.parent().channel_data[self.parent().active_channel])
-                temp_array = n3d.downsample(self.parent().channel_data[self.parent().active_channel], 5)
-                self.histo_list = temp_array.flatten().tolist()
-                self.histo_list.append(temp_min)
-                self.histo_list.append(temp_max)
-            else: #Otherwise just use full array data
-                self.histo_list = self.parent().channel_data[self.parent().active_channel].flatten().tolist()
+            data = self.parent().channel_data[self.parent().active_channel]
+            nonzero_data = data[data != 0]
+
+            if nonzero_data.size > 578009537:
+                # For large arrays, use numpy histogram directly
+                counts, bin_edges = np.histogram(nonzero_data, bins= min(int(np.sqrt(nonzero_data.size)), 500), density=False)
+                # Store min/max separately if needed elsewhere
+                self.data_min = np.min(nonzero_data)
+                self.data_max = np.max(nonzero_data)
+                self.histo_list = [self.data_min, self.data_max]
+            else:
+                # For smaller arrays, can still use histogram method for consistency
+                counts, bin_edges = np.histogram(nonzero_data, bins='auto', density=False)
+                self.data_min = np.min(nonzero_data)
+                self.data_max = np.max(nonzero_data)
+                self.histo_list = [self.data_min, self.data_max]
+            
             self.bounds = True
             self.parent().bounds = True
 
@@ -11580,16 +12685,26 @@ class ThresholdWindow(QMainWindow):
         layout.addWidget(self.canvas)
         
         # Pre-compute histogram with numpy
-        counts, bin_edges = np.histogram(self.histo_list, bins=50)
-        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+        if accepted_mode != 0:
+            counts, bin_edges = np.histogram(self.histo_list, bins=50)
+            bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+                    # Store histogram bounds
+            if self.bounds:
+                self.data_min = 0
+            else:
+                self.data_min = min(self.histo_list)
+            self.data_max = max(self.histo_list)
+        else:
+            bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+            bin_width = bin_edges[1] - bin_edges[0]
         
         # Plot pre-computed histogram
         self.ax = fig.add_subplot(111)
         self.ax.bar(bin_centers, counts, width=bin_edges[1] - bin_edges[0], alpha=0.5)
         
         # Add vertical lines for thresholds
-        self.min_line = self.ax.axvline(min(self.histo_list), color='r')
-        self.max_line = self.ax.axvline(max(self.histo_list), color='b')
+        self.min_line = self.ax.axvline(self.data_min, color='r')
+        self.max_line = self.ax.axvline(self.data_max, color='b')
         
         # Connect events for dragging
         self.canvas.mpl_connect('button_press_event', self.on_press)
@@ -11597,13 +12712,6 @@ class ThresholdWindow(QMainWindow):
         self.canvas.mpl_connect('button_release_event', self.on_release)
         
         self.dragging = None
-        
-        # Store histogram bounds
-        if self.bounds:
-            self.data_min = 0
-        else:
-            self.data_min = min(self.histo_list)
-        self.data_max = max(self.histo_list)
 
         # Create form layout for inputs
         form_layout = QFormLayout()
@@ -11636,7 +12744,7 @@ class ThresholdWindow(QMainWindow):
         button_layout.addWidget(run_button)
         
         # Add Cancel button for external dialog use
-        cancel_button = QPushButton("Cancel/Skip")
+        cancel_button = QPushButton("Cancel/Skip (Retains Selection)")
         cancel_button.clicked.connect(self.cancel_processing)
         button_layout.addWidget(cancel_button)
         
@@ -11660,10 +12768,8 @@ class ThresholdWindow(QMainWindow):
         self.processing_cancelled.emit()
         self.close()
 
-    def closeEvent(self, event):
-        self.parent().preview = False
-        self.parent().targs = None
-        self.parent().bounds = False
+    def make_full_highlight(self):
+
         try: # could probably be refactored but this just handles keeping the highlight elements if the user presses X
             if self.chan == 0:
                 if not self.bounds:
@@ -11697,6 +12803,14 @@ class ThresholdWindow(QMainWindow):
             pass
 
 
+    def closeEvent(self, event):
+        self.parent().preview = False
+        self.parent().targs = None
+        self.parent().bounds = False
+        self.parent().thresh_window_ref = None
+        self.make_full_highlight()
+
+
     def get_values_in_range_all_vols(self, chan, min_val, max_val):
         output = []
         if self.accepted_mode == 1:
@@ -11963,36 +13077,33 @@ class SmartDilateDialog(QDialog):
 
 
 class DilateDialog(QDialog):
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, args = None):
         super().__init__(parent)
         self.setWindowTitle("Dilate Parameters")
         self.setModal(True)
         
         layout = QFormLayout(self)
 
-        self.amount = QLineEdit("1")
-        layout.addRow("Dilation Radius:", self.amount)
-
-        if my_network.xy_scale is not None:
-            xy_scale = f"{my_network.xy_scale}"
+        if args:
+            self.parent().last_dil = args[0]
+            self.index = 1
         else:
-            xy_scale = "1"
+            self.parent().last_dil = 1
+            self.index = 0
 
-        self.xy_scale = QLineEdit(xy_scale)
-        layout.addRow("xy_scale:", self.xy_scale)
+        self.amount = QLineEdit(f"{self.parent().last_dil}")
+        layout.addRow("Dilation Radius:", self.amount)
 
-        if my_network.z_scale is not None:
-            z_scale = f"{my_network.z_scale}"
-        else:
-            z_scale = "1"
+        self.xy_scale = QLineEdit("1")
+        layout.addRow("xy_scale:", self.xy_scale)
 
-        self.z_scale = QLineEdit(z_scale)
+        self.z_scale = QLineEdit("1")
         layout.addRow("z_scale:", self.z_scale)
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Pseudo3D Binary Kernels (For Fast, small dilations)", "Preserve Labels (slower)", "Distance Transform-Based (Slower but more accurate at larger dilations)"])
-        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        self.mode_selector.addItems(["Distance Transform-Based (Slower but more accurate at larger dilations)", "Preserve Labels (slower)", "Pseudo3D Binary Kernels (For Fast, small dilations)"])
+        self.mode_selector.setCurrentIndex(self.index)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
        # Add Run button
@@ -12034,13 +13145,15 @@ class DilateDialog(QDialog):
             if active_data is None:
                 raise ValueError("No active image selected")
 
+            self.parent().last_dil = amount
+
             if accepted_mode == 1:
                 dialog = SmartDilateDialog(self.parent(), [active_data, amount, xy_scale, z_scale])
                 dialog.exec()
                 self.accept()
                 return
 
-            if accepted_mode == 2:
+            if accepted_mode == 0:
                 result = n3d.dilate_3D_dt(active_data, amount, xy_scaling = xy_scale, z_scaling = z_scale)
             else:
 
@@ -12070,36 +13183,33 @@ class DilateDialog(QDialog):
             )
 
 class ErodeDialog(QDialog):
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, args = None):
         super().__init__(parent)
         self.setWindowTitle("Erosion Parameters")
         self.setModal(True)
         
         layout = QFormLayout(self)
 
-        self.amount = QLineEdit("1")
-        layout.addRow("Erosion Radius:", self.amount)
-
-        if my_network.xy_scale is not None:
-            xy_scale = f"{my_network.xy_scale}"
+        if args:
+            self.parent().last_ero = args[0]
+            self.index = 1
         else:
-            xy_scale = "1"
+            self.parent().last_ero = 1
+            self.index = 0
 
-        self.xy_scale = QLineEdit(xy_scale)
-        layout.addRow("xy_scale:", self.xy_scale)
+        self.amount = QLineEdit(f"{self.parent().last_ero}")
+        layout.addRow("Erosion Radius:", self.amount)
 
-        if my_network.z_scale is not None:
-            z_scale = f"{my_network.z_scale}"
-        else:
-            z_scale = "1"
+        self.xy_scale = QLineEdit("1")
+        layout.addRow("xy_scale:", self.xy_scale)
 
-        self.z_scale = QLineEdit(z_scale)
+        self.z_scale = QLineEdit("1")
         layout.addRow("z_scale:", self.z_scale)
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Pseudo3D Binary Kernels (For Fast, small erosions)", "Distance Transform-Based (Slower but more accurate at larger dilations)", "Preserve Labels (Slower)"])
-        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        self.mode_selector.addItems(["Distance Transform-Based (Slower but more accurate at larger erosions)", "Preserve Labels (Slower)", "Pseudo3D Binary Kernels (For Fast, small erosions)"])
+        self.mode_selector.setCurrentIndex(self.index)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
        # Add Run button
@@ -12135,8 +13245,7 @@ class ErodeDialog(QDialog):
 
             mode = self.mode_selector.currentIndex()
 
-            if mode == 2:
-                mode = 1
+            if mode == 1:
                 preserve_labels = True
             else:
                 preserve_labels = False
@@ -12158,7 +13267,7 @@ class ErodeDialog(QDialog):
 
 
             self.parent().load_channel(self.parent().active_channel, result, True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
-
+            self.parent().last_ero = amount
             self.accept()
             
         except Exception as e:
@@ -12188,6 +13297,11 @@ class HoleDialog(QDialog):
         self.borders.setChecked(False)
         layout.addRow("Fill Small Holes Along Borders:", self.borders)
 
+        self.preserve_labels = QPushButton("Preserve Labels")
+        self.preserve_labels.setCheckable(True)
+        self.preserve_labels.setChecked(False)
+        layout.addRow("Preserve Labels (Slower):", self.preserve_labels)
+
         self.sep_holes = QPushButton("Seperate Hole Mask")
         self.sep_holes.setCheckable(True)
         self.sep_holes.setChecked(False)
@@ -12210,15 +13324,32 @@ class HoleDialog(QDialog):
             borders = self.borders.isChecked()
             headon = self.headon.isChecked()
             sep_holes = self.sep_holes.isChecked()
+            preserve_labels = self.preserve_labels.isChecked()
+            if preserve_labels:
+                label_copy = np.copy(active_data)
+
+            if borders:
             
-            # Call dilate method with parameters
-            result = n3d.fill_holes_3d(
-                active_data,
-                head_on = headon,
-                fill_borders = borders
-            )
+                # Call dilate method with parameters
+                result = n3d.fill_holes_3d_old(
+                    active_data,
+                    head_on = headon,
+                    fill_borders = borders
+                )
+
+            else:
+                # Call dilate method with parameters
+                result = n3d.fill_holes_3d(
+                    active_data,
+                    head_on = headon,
+                    fill_borders = borders
+                )
+
 
             if not sep_holes:
+                if preserve_labels:
+                    result = sdl.smart_label(result, label_copy, directory = None, GPU = False, remove_template = True)
+
                 self.parent().load_channel(self.parent().active_channel, result, True)
             else:
                 self.parent().load_channel(3, active_data - result, True)
@@ -12563,7 +13694,13 @@ class SkeletonizeDialog(QDialog):
         # auto checkbox (default True)
         self.auto = QPushButton("Auto")
         self.auto.setCheckable(True)
-        self.auto.setChecked(False)
+        try:
+            if self.shape[0] == 1:
+                self.auto.setChecked(False)
+            else:
+                self.auto.setChecked(True)
+        except:
+            self.auto.setChecked(True)
         layout.addRow("Attempt to Auto Correct Skeleton Looping:", self.auto)
 
        # Add Run button
@@ -12619,6 +13756,86 @@ class SkeletonizeDialog(QDialog):
                 f"Error running skeletonize: {str(e)}"
             )   
 
+
+class BranchStatDialog(QDialog):
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Make sure branches are labeled first (Image -> Generate -> Label Branches)")
+        self.setModal(True)
+        
+        layout = QFormLayout(self)
+
+        info_label = QLabel("Skeletonization Params for Getting Branch Stats, Make sure xy and z scale are set correctly in properties")
+        layout.addRow(info_label)
+
+        self.remove = QLineEdit("0")
+        layout.addRow("Remove Branches Pixel Length (int):", self.remove)
+
+        # auto checkbox (default True)
+        self.auto = QPushButton("Auto")
+        self.auto.setCheckable(True)
+        try:
+            if self.shape[0] == 1:
+                self.auto.setChecked(False)
+            else:
+                self.auto.setChecked(True)
+        except:
+            self.auto.setChecked(True)
+        layout.addRow("Attempt to Auto Correct Skeleton Looping:", self.auto)
+
+       # Add Run button
+        run_button = QPushButton("Get Branchstats (For Active Image)")
+        run_button.clicked.connect(self.run)
+        layout.addRow(run_button)
+
+    def run(self):
+
+        try:
+            
+            # Get branch removal
+            try:
+                remove = int(self.remove.text()) if self.remove.text() else 0
+            except ValueError:
+                remove = 0
+
+            auto = self.auto.isChecked()
+            
+            # Get the active channel data from parent
+            active_data = np.copy(self.parent().channel_data[self.parent().active_channel])
+            if active_data is None:
+                raise ValueError("No active image selected")
+
+            if auto:
+                active_data = n3d.skeletonize(active_data)
+                active_data = n3d.fill_holes_3d(active_data)
+            
+            active_data = n3d.skeletonize(
+                active_data
+            )
+
+            if remove > 0:
+                active_data = n3d.remove_branches_new(active_data, remove)
+                active_data = n3d.dilate_3D(active_data, 3, 3, 3)
+                active_data = n3d.skeletonize(active_data)
+
+            active_data = active_data * self.parent().channel_data[self.parent().active_channel]
+            len_dict, tortuosity_dict, angle_dict = n3d.compute_optional_branchstats(None, active_data, None, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale)
+
+            if self.parent().active_channel == 0:
+                self.parent().branch_dict[0] = [len_dict, tortuosity_dict]
+            elif self.parent().active_channel == 1:
+                self.parent().branch_dict[1] = [len_dict, tortuosity_dict]
+
+            self.parent().format_for_upperright_table(len_dict, 'BranchID', 'Length (Scaled)', 'Branch Lengths')
+            self.parent().format_for_upperright_table(tortuosity_dict, 'BranchID', 'Tortuosity', 'Branch Tortuosities')
+
+
+            self.accept()
+            
+        except Exception as e:
+            print(f"Error: {e}")
+
 class DistanceDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
@@ -12666,16 +13883,58 @@ class GrayWaterDialog(QDialog):
         run_button.clicked.connect(self.run_watershed)
         layout.addRow(run_button)
 
+    def wait_for_threshold_processing(self):
+        """
+        Opens ThresholdWindow and waits for user to process the image.
+        Returns True if completed, False if cancelled.
+        The thresholded image will be available in the main window after completion.
+        """
+        # Create event loop to wait for user
+        loop = QEventLoop()
+        result = {'completed': False}
+        
+        # Create the threshold window
+        thresh_window = ThresholdWindow(self.parent(), 0)
+
+        
+        # Connect signals
+        def on_processing_complete():
+            result['completed'] = True
+            loop.quit()
+            
+        def on_processing_cancelled():
+            result['completed'] = False
+            loop.quit()
+        
+        thresh_window.processing_complete.connect(on_processing_complete)
+        thresh_window.processing_cancelled.connect(on_processing_cancelled)
+        
+        # Show window and wait
+        thresh_window.show()
+        thresh_window.raise_()
+        thresh_window.activateWindow()
+        
+        # Block until user clicks "Apply Threshold & Continue" or "Cancel"
+        loop.exec()
+        
+        # Clean up
+        thresh_window.deleteLater()
+        
+        return result['completed']
+
     def run_watershed(self):
 
         try:
 
+            self.accept()
+            print("Please threshold foreground, or press cancel/skip if not desired:")
+            self.wait_for_threshold_processing()
+            data = self.parent().channel_data[self.parent().active_channel]
+
             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, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
@@ -12695,11 +13954,6 @@ class WatershedDialog(QDialog):
         self.setModal(True)
         
         layout = QFormLayout(self)
-        
-        # Directory (empty by default)
-        self.directory = QLineEdit()
-        self.directory.setPlaceholderText("Leave empty for None")
-        layout.addRow("Output Directory:", self.directory)
 
         try:
 
@@ -12750,7 +14004,7 @@ class WatershedDialog(QDialog):
     def run_watershed(self):
         try:
             # Get directory (None if empty)
-            directory = self.directory.text() if self.directory.text() else None
+            directory = None
             
             # Get proportion (0.1 if empty or invalid)
             try:
@@ -13108,7 +14362,7 @@ class GenNodesDialog(QDialog):
 
             if my_network.edges is None and my_network.nodes is not None:
                 self.parent().load_channel(1, my_network.nodes, data = True)
-                self.parent().delete_channel(0, True)
+                self.parent().delete_channel(0, False)
             # Get directory (None if empty)
             #directory = self.directory.text() if self.directory.text() else None
             
@@ -13170,7 +14424,6 @@ class GenNodesDialog(QDialog):
                 order = order,
                 return_skele = True,
                 fastdil = fastdil
-
             )
 
             if down_factor > 0 and not self.called:
@@ -13262,7 +14515,7 @@ class BranchDialog(QDialog):
             self.fix3.setChecked(True)
         else:
             self.fix3.setChecked(False)
-        correction_layout.addWidget(QLabel("Split Nontouching Branches? (Useful if branch pruning - may want to threshold out small, split branches after): "), 4, 0)
+        correction_layout.addWidget(QLabel("Split Nontouching Branches?: "), 4, 0)
         correction_layout.addWidget(self.fix3, 4, 1)
         
         correction_group.setLayout(correction_layout)
@@ -13290,20 +14543,27 @@ class BranchDialog(QDialog):
         # --- Misc Options Group ---
         misc_group = QGroupBox("Misc Options")
         misc_layout = QGridLayout()
+
+        # optional computation checkbox
+        self.compute = QPushButton("Branch Stats")
+        self.compute.setCheckable(True)
+        self.compute.setChecked(True)
+        misc_layout.addWidget(QLabel("Compute Branch Stats (Branch Lengths, Tortuosity. Set xy_scale and z_scale in properties first if real distances are desired.):"), 0, 0)
+        misc_layout.addWidget(self.compute, 0, 1)
         
         # Nodes checkbox
         self.nodes = QPushButton("Generate Nodes")
         self.nodes.setCheckable(True)
         self.nodes.setChecked(True)
-        misc_layout.addWidget(QLabel("Generate nodes from edges? (Skip if already completed):"), 0, 0)
-        misc_layout.addWidget(self.nodes, 0, 1)
+        misc_layout.addWidget(QLabel("Generate nodes from edges? (Skip if already completed):"), 1, 0)
+        misc_layout.addWidget(self.nodes, 1, 1)
         
         # GPU checkbox
         self.GPU = QPushButton("GPU")
         self.GPU.setCheckable(True)
         self.GPU.setChecked(False)
-        misc_layout.addWidget(QLabel("Use GPU (May downsample large images):"), 1, 0)
-        misc_layout.addWidget(self.GPU, 1, 1)
+        misc_layout.addWidget(QLabel("Use GPU (May downsample large images):"), 2, 0)
+        misc_layout.addWidget(self.GPU, 2, 1)
         
         misc_group.setLayout(misc_layout)
         main_layout.addWidget(misc_group)
@@ -13337,10 +14597,11 @@ class BranchDialog(QDialog):
             fix3 = self.fix3.isChecked()
             fix_val = float(self.fix_val.text()) if self.fix_val.text() else None
             seed = int(self.seed.text()) if self.seed.text() else None
+            compute = self.compute.isChecked()
 
             if my_network.edges is None and my_network.nodes is not None:
                 self.parent().load_channel(1, my_network.nodes, data = True)
-                self.parent().delete_channel(0, True)
+                self.parent().delete_channel(0, False)
 
             original_shape = my_network.edges.shape
             original_array = copy.deepcopy(my_network.edges)
@@ -13353,7 +14614,7 @@ class BranchDialog(QDialog):
 
             if my_network.edges is not None and my_network.nodes is not None and my_network.id_overlay is not None:
 
-                output = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = original_array, GPU = GPU, down_factor = down_factor, arrayshape = original_shape)
+                output, verts, skeleton, endpoints = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = original_array, GPU = GPU, down_factor = down_factor, arrayshape = original_shape, compute = compute, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale)
 
                 if fix2:
 
@@ -13392,6 +14653,19 @@ class BranchDialog(QDialog):
 
                     output = self.parent().separate_nontouching_objects(output, max_val=np.max(output))
 
+                if compute:
+                    labeled_image = (skeleton != 0) * output
+                    len_dict, tortuosity_dict, angle_dict = n3d.compute_optional_branchstats(verts, labeled_image, endpoints, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale)
+                    self.parent().branch_dict[1] = [len_dict, tortuosity_dict]
+                    #max_length = max(len(v) for v in angle_dict.values())
+                    #title = [str(i+1) if i < 2 else i+1 for i in range(max_length)]
+
+                    #del labeled_image
+
+                    self.parent().format_for_upperright_table(len_dict, 'BranchID', 'Length (Scaled)', 'Branch Lengths')
+                    self.parent().format_for_upperright_table(tortuosity_dict, 'BranchID', 'Tortuosity', 'Branch Tortuosities')
+                    #self.parent().format_for_upperright_table(angle_dict, 'Vertex ID', title, 'Branch Angles')
+
 
                 if down_factor is not None:
 
@@ -13791,10 +15065,6 @@ class CentroidDialog(QDialog):
 
         layout = QFormLayout(self)
 
-        self.directory = QLineEdit()
-        self.directory.setPlaceholderText("Leave empty for active directory")
-        layout.addRow("Output Directory:", self.directory)
-
         self.downsample = QLineEdit("1")
         layout.addRow("Downsample Factor:", self.downsample)
 
@@ -13824,7 +15094,7 @@ class CentroidDialog(QDialog):
             ignore_empty = self.ignore_empty.isChecked()
 
             # Get directory (None if empty)
-            directory = self.directory.text() if self.directory.text() else None
+            directory = None
             
             # Get downsample
             try:
@@ -13905,7 +15175,6 @@ class CentroidDialog(QDialog):
 
 class CalcAllDialog(QDialog):
     # Class variables to store previous settings
-    prev_directory = ""
     prev_search = ""
     prev_diledge = ""
     prev_down_factor = ""
@@ -13977,7 +15246,7 @@ class CalcAllDialog(QDialog):
         
         self.down_factor = QLineEdit(self.prev_down_factor)
         self.down_factor.setPlaceholderText("Leave empty for None")
-        speedup_layout.addRow("Downsample for Centroids (int):", self.down_factor)
+        speedup_layout.addRow("Downsample for Centroids/Overlays (int):", self.down_factor)
         
         self.GPU_downsample = QLineEdit(self.prev_GPU_downsample)
         self.GPU_downsample.setPlaceholderText("Leave empty for None")
@@ -13999,10 +15268,6 @@ class CalcAllDialog(QDialog):
         output_group = QGroupBox("Output Options")
         output_layout = QFormLayout(output_group)
         
-        self.directory = QLineEdit(self.prev_directory)
-        self.directory.setPlaceholderText("Will Have to Save Manually If Empty")
-        output_layout.addRow("Output Directory:", self.directory)
-        
         self.overlays = QPushButton("Overlays")
         self.overlays.setCheckable(True)
         self.overlays.setChecked(self.prev_overlays)
@@ -14024,7 +15289,7 @@ class CalcAllDialog(QDialog):
 
         try:
             # Get directory (None if empty)
-            directory = self.directory.text() if self.directory.text() else None
+            directory = None
             
             # Get xy_scale and z_scale (1 if empty or invalid)
             try:
@@ -14101,7 +15366,6 @@ class CalcAllDialog(QDialog):
             )
 
             # Store current values as previous values
-            CalcAllDialog.prev_directory = self.directory.text()
             CalcAllDialog.prev_search = self.search.text()
             CalcAllDialog.prev_diledge = self.diledge.text()
             CalcAllDialog.prev_down_factor = self.down_factor.text()
@@ -14135,8 +15399,12 @@ class CalcAllDialog(QDialog):
                     directory = 'my_network'
                 
                 # Generate and update overlays
-                my_network.network_overlay = my_network.draw_network(directory=directory)
-                my_network.id_overlay = my_network.draw_node_indices(directory=directory)
+                my_network.network_overlay = my_network.draw_network(directory=directory, down_factor = down_factor)
+                my_network.id_overlay = my_network.draw_node_indices(directory=directory, down_factor = down_factor)
+
+                if down_factor is not None:
+                    my_network.id_overlay = n3d.upsample_with_padding(my_network.id_overlay, original_shape = self.parent().shape)
+                    my_network.network_overlay = n3d.upsample_with_padding(my_network.network_overlay, original_shape = self.parent().shape)
                 
                 # Update channel data
                 self.parent().load_channel(2, my_network.network_overlay, True)
@@ -14249,14 +15517,13 @@ class ProxDialog(QDialog):
         output_group = QGroupBox("Output Options")
         output_layout = QFormLayout(output_group)
         
-        self.directory = QLineEdit('')
-        self.directory.setPlaceholderText("Leave empty for 'my_network'")
-        output_layout.addRow("Output Directory:", self.directory)
-        
         self.overlays = QPushButton("Overlays")
         self.overlays.setCheckable(True)
         self.overlays.setChecked(True)
         output_layout.addRow("Generate Overlays:", self.overlays)
+
+        self.downsample = QLineEdit()
+        output_layout.addRow("(If above): Downsample factor for drawing overlays (Int - Makes Overlay Elements Larger):", self.downsample)
         
         self.populate = QPushButton("Populate Nodes from Centroids?")
         self.populate.setCheckable(True)
@@ -14301,10 +15568,8 @@ class ProxDialog(QDialog):
             else:
                 targets = None
 
-            try:
-                directory = self.directory.text() if self.directory.text() else None
-            except:
-                directory = None
+            directory = None
+
 
             # Get xy_scale and z_scale (1 if empty or invalid)
             try:
@@ -14328,6 +15593,12 @@ class ProxDialog(QDialog):
             except:
                 max_neighbors = None
 
+
+            try:
+                downsample = int(self.downsample.text()) if self.downsample.text() else None
+            except:
+                downsample = None
+
             overlays = self.overlays.isChecked()  
             fastdil = self.fastdil.isChecked()
 
@@ -14383,8 +15654,12 @@ class ProxDialog(QDialog):
                         directory = 'my_network'
                     
                     # Generate and update overlays
-                    my_network.network_overlay = my_network.draw_network(directory=directory)
-                    my_network.id_overlay = my_network.draw_node_indices(directory=directory)
+                    my_network.network_overlay = my_network.draw_network(directory=directory, down_factor = downsample)
+                    my_network.id_overlay = my_network.draw_node_indices(directory=directory, down_factor = downsample)
+
+                    if downsample is not None:
+                        my_network.id_overlay = n3d.upsample_with_padding(my_network.id_overlay, original_shape = self.parent().shape)
+                        my_network.network_overlay = n3d.upsample_with_padding(my_network.network_overlay, original_shape = self.parent().shape)
                     
                     # Update channel data
                     self.parent().load_channel(2, channel_data = my_network.network_overlay, data = True)
@@ -14506,31 +15781,81 @@ class HistogramSelector(QWidget):
         """)
         layout.addWidget(button)
 
+
     def shortest_path_histogram(self):
         try:
-            shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(self.G))
-            diameter = max(nx.eccentricity(self.G, sp=shortest_path_lengths).values())
-            path_lengths = np.zeros(diameter + 1, dtype=int)
-
-            for pls in shortest_path_lengths.values():
-                pl, cnts = np.unique(list(pls.values()), return_counts=True)
+            # Check if graph has multiple disconnected components
+            components = list(nx.connected_components(self.G))
+            
+            if len(components) > 1:
+                print(f"Warning: Graph has {len(components)} disconnected components. Computing shortest paths within each component separately.")
+                
+                # Initialize variables to collect data from all components
+                all_path_lengths = []
+                max_diameter = 0
+                
+                # Process each component separately
+                for i, component in enumerate(components):
+                    subgraph = self.G.subgraph(component)
+                    
+                    if len(component) < 2:
+                        # Skip single-node components (no paths to compute)
+                        continue
+                    
+                    # Compute shortest paths for this component
+                    shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(subgraph))
+                    component_diameter = max(nx.eccentricity(subgraph, sp=shortest_path_lengths).values())
+                    max_diameter = max(max_diameter, component_diameter)
+                    
+                    # Collect path lengths from this component
+                    for pls in shortest_path_lengths.values():
+                        all_path_lengths.extend(list(pls.values()))
+                
+                # Remove self-paths (length 0) and create histogram
+                all_path_lengths = [pl for pl in all_path_lengths if pl > 0]
+                
+                if not all_path_lengths:
+                    print("No paths found across components (only single-node components)")
+                    return
+                    
+                # Create combined histogram
+                path_lengths = np.zeros(max_diameter + 1, dtype=int)
+                pl, cnts = np.unique(all_path_lengths, return_counts=True)
                 path_lengths[pl] += cnts
-
+                
+                title_suffix = f" (across {len(components)} components)"
+                
+            else:
+                # Single component
+                shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(self.G))
+                diameter = max(nx.eccentricity(self.G, sp=shortest_path_lengths).values())
+                path_lengths = np.zeros(diameter + 1, dtype=int)
+                for pls in shortest_path_lengths.values():
+                    pl, cnts = np.unique(list(pls.values()), return_counts=True)
+                    path_lengths[pl] += cnts
+                max_diameter = diameter
+                title_suffix = ""
+            
+            # Generate visualization and results (same for both cases)
             freq_percent = 100 * path_lengths[1:] / path_lengths[1:].sum()
-
             fig, ax = plt.subplots(figsize=(15, 8))
-            ax.bar(np.arange(1, diameter + 1), height=freq_percent)
+            ax.bar(np.arange(1, max_diameter + 1), height=freq_percent)
             ax.set_title(
-                "Distribution of shortest path length in G", fontdict={"size": 35}, loc="center"
+                f"Distribution of shortest path length in G{title_suffix}", 
+                fontdict={"size": 35}, loc="center"
             )
             ax.set_xlabel("Shortest Path Length", fontdict={"size": 22})
             ax.set_ylabel("Frequency (%)", fontdict={"size": 22})
             plt.show()
             
             freq_dict = {freq: length for length, freq in enumerate(freq_percent, start=1)}
-            self.network_analysis.format_for_upperright_table(freq_dict, metric='Frequency (%)', 
-                                                            value='Shortest Path Length', 
-                                                            title="Distribution of shortest path length in G")
+            self.network_analysis.format_for_upperright_table(
+                freq_dict, 
+                metric='Frequency (%)', 
+                value='Shortest Path Length', 
+                title=f"Distribution of shortest path length in G{title_suffix}"
+            )
+            
         except Exception as e:
             print(f"Error generating shortest path histogram: {e}")
     
@@ -14549,20 +15874,62 @@ class HistogramSelector(QWidget):
                                                             title="Degree Centrality Table")
         except Exception as e:
             print(f"Error generating degree centrality histogram: {e}")
-    
+
     def betweenness_centrality_histogram(self):
         try:
-            betweenness_centrality = nx.centrality.betweenness_centrality(self.G)
+            # Check if graph has multiple disconnected components
+            components = list(nx.connected_components(self.G))
+            
+            if len(components) > 1:
+                print(f"Warning: Graph has {len(components)} disconnected components. Computing betweenness centrality within each component separately.")
+                
+                # Initialize dictionary to collect betweenness centrality from all components
+                combined_betweenness_centrality = {}
+                
+                # Process each component separately
+                for i, component in enumerate(components):
+                    if len(component) < 2:
+                        # For single-node components, betweenness centrality is 0
+                        for node in component:
+                            combined_betweenness_centrality[node] = 0.0
+                        continue
+                    
+                    # Create subgraph for this component
+                    subgraph = self.G.subgraph(component)
+                    
+                    # Compute betweenness centrality for this component
+                    component_betweenness = nx.centrality.betweenness_centrality(subgraph)
+                    
+                    # Add to combined results
+                    combined_betweenness_centrality.update(component_betweenness)
+                
+                betweenness_centrality = combined_betweenness_centrality
+                title_suffix = f" (across {len(components)} components)"
+                
+            else:
+                # Single component
+                betweenness_centrality = nx.centrality.betweenness_centrality(self.G)
+                title_suffix = ""
+            
+            # Generate visualization and results (same for both cases)
             plt.figure(figsize=(15, 8))
             plt.hist(betweenness_centrality.values(), bins=100)
             plt.xticks(ticks=[0, 0.02, 0.1, 0.2, 0.3, 0.4, 0.5])
-            plt.title("Betweenness Centrality Histogram ", fontdict={"size": 35}, loc="center")
+            plt.title(
+                f"Betweenness Centrality Histogram{title_suffix}", 
+                fontdict={"size": 35}, loc="center"
+            )
             plt.xlabel("Betweenness Centrality", fontdict={"size": 20})
             plt.ylabel("Counts", fontdict={"size": 20})
             plt.show()
-            self.network_analysis.format_for_upperright_table(betweenness_centrality, metric='Node', 
-                                                            value='Betweenness Centrality', 
-                                                            title="Betweenness Centrality Table")
+            
+            self.network_analysis.format_for_upperright_table(
+                betweenness_centrality, 
+                metric='Node', 
+                value='Betweenness Centrality', 
+                title=f"Betweenness Centrality Table{title_suffix}"
+            )
+            
         except Exception as e:
             print(f"Error generating betweenness centrality histogram: {e}")
     
@@ -14615,7 +15982,27 @@ class HistogramSelector(QWidget):
     def bridges_analysis(self):
         try:
             bridges = list(nx.bridges(self.G))
-            self.network_analysis.format_for_upperright_table(bridges, metric='Node Pair', 
+            try:
+                # Get the existing DataFrame from the model
+                original_df = self.network_analysis.network_table.model()._data
+                
+                # Create boolean mask
+                mask = pd.Series([False] * len(original_df))
+                
+                for u, v in bridges:
+                    # Check for both (u,v) and (v,u) orientations
+                    bridge_mask = (
+                        ((original_df.iloc[:, 0] == u) & (original_df.iloc[:, 1] == v)) |
+                        ((original_df.iloc[:, 0] == v) & (original_df.iloc[:, 1] == u))
+                    )
+                    mask |= bridge_mask
+                # Filter the DataFrame to only include bridge connections
+                filtered_df = original_df[mask].copy()
+                df_dict = {i: row.tolist() for i, row in enumerate(filtered_df.values)}
+                self.network_analysis.format_for_upperright_table(df_dict, metric='Bridge ID', value = ['NodeA', 'NodeB', 'EdgeC'],
+                                                            title="Bridges")
+            except:
+                self.network_analysis.format_for_upperright_table(bridges, metric='Node Pair', 
                                                             title="Bridges")
         except Exception as e:
             print(f"Error generating bridges analysis: {e}")
@@ -14642,7 +16029,7 @@ class HistogramSelector(QWidget):
     def node_connectivity_histogram(self):
         """Local node connectivity - minimum number of nodes that must be removed to disconnect neighbors"""
         try:
-            if self.G.number_of_nodes() > 500:  # Skip for large networks (computationally expensive)
+            if self.G.number_of_nodes() > 500:
                 print("Note this analysis may be slow for large network (>500 nodes)")
                 #return
                 
@@ -14720,7 +16107,7 @@ class HistogramSelector(QWidget):
     def load_centrality_histogram(self):
         """Load centrality - fraction of shortest paths passing through each node"""
         try:
-            if self.G.number_of_nodes() > 1000:  # Skip for very large networks
+            if self.G.number_of_nodes() > 1000:
                 print("Note this analysis may be slow for large network (>1000 nodes)")
                 #return
                 
@@ -14739,21 +16126,67 @@ class HistogramSelector(QWidget):
     def communicability_centrality_histogram(self):
         """Communicability centrality - based on communicability between nodes"""
         try:
-            if self.G.number_of_nodes() > 500:  # Skip for large networks (memory intensive)
+            if self.G.number_of_nodes() > 500:
                 print("Note this analysis may be slow for large network (>500 nodes)")
                 #return
+            
+            # Check if graph has multiple disconnected components
+            components = list(nx.connected_components(self.G))
+            
+            if len(components) > 1:
+                print(f"Warning: Graph has {len(components)} disconnected components. Computing communicability centrality within each component separately.")
+                
+                # Initialize dictionary to collect communicability centrality from all components
+                combined_comm_centrality = {}
+                
+                # Process each component separately
+                for i, component in enumerate(components):
+                    if len(component) < 2:
+                        # For single-node components, communicability betweenness centrality is 0
+                        for node in component:
+                            combined_comm_centrality[node] = 0.0
+                        continue
+                    
+                    # Create subgraph for this component
+                    subgraph = self.G.subgraph(component)
+                    
+                    # Compute communicability betweenness centrality for this component
+                    try:
+                        component_comm_centrality = nx.communicability_betweenness_centrality(subgraph)
+                        # Add to combined results
+                        combined_comm_centrality.update(component_comm_centrality)
+                    except Exception as comp_e:
+                        print(f"Error computing communicability centrality for component {i+1}: {comp_e}")
+                        # Set centrality to 0 for nodes in this component if computation fails
+                        for node in component:
+                            combined_comm_centrality[node] = 0.0
+                
+                comm_centrality = combined_comm_centrality
+                title_suffix = f" (across {len(components)} components)"
                 
-            # Use the correct function name - it's in the communicability module
-            comm_centrality = nx.communicability_betweenness_centrality(self.G)
+            else:
+                # Single component
+                comm_centrality = nx.communicability_betweenness_centrality(self.G)
+                title_suffix = ""
+            
+            # Generate visualization and results (same for both cases)
             plt.figure(figsize=(15, 8))
             plt.hist(comm_centrality.values(), bins=50, alpha=0.7)
-            plt.title("Communicability Betweenness Centrality Distribution", fontdict={"size": 35}, loc="center")
+            plt.title(
+                f"Communicability Betweenness Centrality Distribution{title_suffix}", 
+                fontdict={"size": 35}, loc="center"
+            )
             plt.xlabel("Communicability Betweenness Centrality", fontdict={"size": 20})
             plt.ylabel("Frequency", fontdict={"size": 20})
             plt.show()
-            self.network_analysis.format_for_upperright_table(comm_centrality, metric='Node', 
-                                                            value='Communicability Betweenness Centrality', 
-                                                            title="Communicability Betweenness Centrality Table")
+            
+            self.network_analysis.format_for_upperright_table(
+                comm_centrality, 
+                metric='Node', 
+                value='Communicability Betweenness Centrality', 
+                title=f"Communicability Betweenness Centrality Table{title_suffix}"
+            )
+            
         except Exception as e:
             print(f"Error generating communicability betweenness centrality histogram: {e}")
     
@@ -14776,20 +16209,67 @@ class HistogramSelector(QWidget):
     def current_flow_betweenness_histogram(self):
         """Current flow betweenness - models network as electrical circuit"""
         try:
-            if self.G.number_of_nodes() > 500:  # Skip for large networks (computationally expensive)
+            if self.G.number_of_nodes() > 500:  
                 print("Note this analysis may be slow for large network (>500 nodes)")
                 #return
+            
+            # Check if graph has multiple disconnected components
+            components = list(nx.connected_components(self.G))
+            
+            if len(components) > 1:
+                print(f"Warning: Graph has {len(components)} disconnected components. Computing current flow betweenness centrality within each component separately.")
+                
+                # Initialize dictionary to collect current flow betweenness from all components
+                combined_current_flow = {}
                 
-            current_flow = nx.current_flow_betweenness_centrality(self.G)
+                # Process each component separately
+                for i, component in enumerate(components):
+                    if len(component) < 2:
+                        # For single-node components, current flow betweenness centrality is 0
+                        for node in component:
+                            combined_current_flow[node] = 0.0
+                        continue
+                    
+                    # Create subgraph for this component
+                    subgraph = self.G.subgraph(component)
+                    
+                    # Compute current flow betweenness centrality for this component
+                    try:
+                        component_current_flow = nx.current_flow_betweenness_centrality(subgraph)
+                        # Add to combined results
+                        combined_current_flow.update(component_current_flow)
+                    except Exception as comp_e:
+                        print(f"Error computing current flow betweenness for component {i+1}: {comp_e}")
+                        # Set centrality to 0 for nodes in this component if computation fails
+                        for node in component:
+                            combined_current_flow[node] = 0.0
+                
+                current_flow = combined_current_flow
+                title_suffix = f" (across {len(components)} components)"
+                
+            else:
+                # Single component
+                current_flow = nx.current_flow_betweenness_centrality(self.G)
+                title_suffix = ""
+            
+            # Generate visualization and results (same for both cases)
             plt.figure(figsize=(15, 8))
             plt.hist(current_flow.values(), bins=50, alpha=0.7)
-            plt.title("Current Flow Betweenness Centrality Distribution", fontdict={"size": 35}, loc="center")
+            plt.title(
+                f"Current Flow Betweenness Centrality Distribution{title_suffix}", 
+                fontdict={"size": 35}, loc="center"
+            )
             plt.xlabel("Current Flow Betweenness Centrality", fontdict={"size": 20})
             plt.ylabel("Frequency", fontdict={"size": 20})
             plt.show()
-            self.network_analysis.format_for_upperright_table(current_flow, metric='Node', 
-                                                            value='Current Flow Betweenness', 
-                                                            title="Current Flow Betweenness Table")
+            
+            self.network_analysis.format_for_upperright_table(
+                current_flow, 
+                metric='Node', 
+                value='Current Flow Betweenness', 
+                title=f"Current Flow Betweenness Table{title_suffix}"
+            )
+            
         except Exception as e:
             print(f"Error generating current flow betweenness histogram: {e}")