nettracer3d 0.6.6__py3-none-any.whl → 0.6.8__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -18,13 +18,14 @@ from nettracer3d import smart_dilate as sdl
 from matplotlib.colors import LinearSegmentedColormap
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import pandas as pd
-from PyQt6.QtGui import (QFont, QCursor, QColor, QPixmap, QPainter, QPen)
+from PyQt6.QtGui import (QFont, QCursor, QColor, QPixmap, QFontMetrics, QPainter, QPen)
 import tifffile
 import copy
 import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor
 from functools import partial
 from nettracer3d import segmenter
+#from nettracer3d import segmenter_GPU
 
 
 
@@ -117,6 +118,9 @@ class ImageViewerWindow(QMainWindow):
 
         #For ML segmenting mode
         self.brush_mode = False
+        self.can = False
+        self.threed = False
+        self.threedthresh = 5
         self.painting = False
         self.foreground = True
         self.machine_window = None
@@ -147,6 +151,11 @@ class ImageViewerWindow(QMainWindow):
             3: None
         } #For storing thresholding information
 
+        self.radii_dict = {
+            0: None,
+            1: None
+        }
+
         self.original_shape = None #For undoing resamples
         
         # Create control panel
@@ -1312,7 +1321,10 @@ class ImageViewerWindow(QMainWindow):
                     info_dict['Centroid'] = my_network.node_centroids[label]
 
                 if self.volume_dict[0] is not None:
-                    info_dict['Volume'] = self.volume_dict[0][label]
+                    info_dict['Volume (Scaled)'] = self.volume_dict[0][label]
+
+                if self.radii_dict[0] is not None:
+                    info_dict['Max Radius (Scaled)'] = self.radii_dict[0][label]
 
 
             elif sort == 'edge':
@@ -1327,7 +1339,10 @@ class ImageViewerWindow(QMainWindow):
                     info_dict['Centroid'] = my_network.edge_centroids[label]
 
                 if self.volume_dict[1] is not None:
-                    info_dict['Volume'] = self.volume_dict[1][label]
+                    info_dict['Volume (Scaled)'] = self.volume_dict[1][label]
+
+                if self.radii_dict[1] is not None:
+                    info_dict['~Radius (Scaled)'] = self.radii_dict[1][label]
 
             self.format_for_upperright_table(info_dict, title = f'Info on Object')
 
@@ -1700,6 +1715,9 @@ class ImageViewerWindow(QMainWindow):
             self.pen_button.setChecked(False)
             self.pan_mode = False
             self.brush_mode = False
+            self.can = False
+            self.threed = False
+            self.last_change = None
             if self.machine_window is not None:
                 self.machine_window.silence_button()
             self.canvas.setCursor(Qt.CursorShape.CrossCursor)
@@ -1717,6 +1735,9 @@ class ImageViewerWindow(QMainWindow):
             self.zoom_button.setChecked(False)
             self.pen_button.setChecked(False)
             self.zoom_mode = False
+            self.can = False
+            self.threed = False
+            self.last_change = None
             self.brush_mode = False
             if self.machine_window is not None:
                 self.machine_window.silence_button()
@@ -1737,14 +1758,69 @@ class ImageViewerWindow(QMainWindow):
             self.zoom_mode = False
             self.update_brush_cursor()
         else:
+            self.last_change = None
+            self.can = False
+            self.threed = False
             self.canvas.setCursor(Qt.CursorShape.ArrowCursor)
 
+    def toggle_can(self):
+
+        if not self.can:
+            self.can = True
+            self.update_brush_cursor()
+        else:
+            self.can = False
+            self.last_change = None
+            self.update_brush_cursor()
+
+    def toggle_threed(self):
+
+        if not self.threed:
+            self.threed = True
+            self.threedthresh = 5
+            self.update_brush_cursor()
+        else:
+            self.threed = False
+            self.update_brush_cursor()
+
 
     def on_mpl_scroll(self, event):
         """Handle matplotlib canvas scroll events"""
         #Wheel events
         if self.brush_mode and event.inaxes == self.ax:
+
+            # Get modifiers
+            modifiers = event.guiEvent.modifiers()
+            ctrl_pressed = bool(modifiers & Qt.ControlModifier)
+            shift_pressed = bool(modifiers & Qt.ShiftModifier)
+            alt_pressed = bool(modifiers & Qt.AltModifier)
+            
+            # Check if threed is enabled and ONLY if no specific modifiers are pressed
+            if self.threed and not ctrl_pressed and not shift_pressed and not alt_pressed:
+                import math
+                step = 1 if event.button == 'up' else -1
+                self.threedthresh += step
+                
+                # Round to appropriate odd integer based on scroll direction
+                if event.button == 'up':
+                    # Round up to nearest odd
+                    self.threedthresh = math.ceil(self.threedthresh)
+                    if self.threedthresh % 2 == 0:
+                        self.threedthresh += 1
+                else:  # event.button == 'down'
+                    # Round down to nearest odd, but not below 1
+                    self.threedthresh = math.floor(self.threedthresh)
+                    if self.threedthresh % 2 == 0:
+                        self.threedthresh -= 1
+                    # Ensure not below minimum value of 1
+                    self.threedthresh = max(1, self.threedthresh)
+                
+                # Update the brush cursor to show the new threshold
+                self.update_brush_cursor()
+                return
+                
             # Check if Ctrl is pressed
+
             if event.guiEvent.modifiers() & Qt.ShiftModifier:
                 pass
 
@@ -1781,6 +1857,15 @@ class ImageViewerWindow(QMainWindow):
             self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
     def keyPressEvent(self, event):
+
+        if event.key() == Qt.Key_Z and event.modifiers() & Qt.ControlModifier:
+            try:
+                self.load_channel(self.last_change[1], self.last_change[0], True)
+            except:
+                pass
+
+            return  # Return to prevent triggering the regular Z key action below
+
         if event.key() == Qt.Key_Z:
             self.zoom_button.click()
         if self.machine_window is not None:
@@ -1788,28 +1873,65 @@ class ImageViewerWindow(QMainWindow):
                 self.machine_window.switch_foreground()
         if event.key() == Qt.Key_X:
             self.high_button.click()
+        if self.brush_mode and self.machine_window is None:
+            if event.key() == Qt.Key_F:
+                self.toggle_can()
+            elif event.key() == Qt.Key_D:
+                self.toggle_threed()
 
 
     def update_brush_cursor(self):
         """Update the cursor to show brush size"""
         if not self.brush_mode:
             return
-            
-        # Create a pixmap for the cursor
-        size = self.brush_size * 2 + 2  # Add padding for border
-        pixmap = QPixmap(size, size)
+        
+        # Get font metrics first to determine text size
+        font = QFont()
+        font.setPointSize(14)
+        font_metrics = QFontMetrics(font)
+        thresh_text = str(self.threedthresh)
+        text_rect = font_metrics.boundingRect(thresh_text)
+        
+        # Create a pixmap for the cursor - ensure it's large enough for text
+        brush_size = self.brush_size * 2 + 2  # Add padding for border
+        extra_width = max(0, text_rect.width() + 4 - brush_size)  # Extra width for text if needed
+        extra_height = max(0, text_rect.height() + 4 - brush_size)  # Extra height for text if needed
+        
+        # Make sure pixmap is large enough for both brush and text
+        total_width = brush_size + extra_width
+        total_height = brush_size + extra_height
+        pixmap = QPixmap(total_width, total_height)
         pixmap.fill(Qt.transparent)
         
         # Create painter for the pixmap
         painter = QPainter(pixmap)
         painter.setRenderHint(QPainter.RenderHint.Antialiasing) 
         
+        # Calculate center offset for brush ellipse to accommodate text
+        x_offset = extra_width // 2
+        y_offset = extra_height // 2
+        
         # Draw circle
-        pen = QPen(Qt.white)
+        if not self.threed:
+            pen = QPen(Qt.white)
+        else:
+            pen = QPen(Qt.red)
         pen.setWidth(1)
         painter.setPen(pen)
         painter.setBrush(Qt.transparent)
-        painter.drawEllipse(1, 1, size-2, size-2)
+        if not self.can:
+            painter.drawEllipse(1 + x_offset, 1 + y_offset, brush_size-2, brush_size-2)
+            
+            # Draw threshold number when threed is True and can is False
+            if self.threed:
+                # Set text properties
+                painter.setFont(font)
+                painter.setPen(QPen(Qt.white))  # White text for visibility
+                
+                # Draw the text
+                painter.drawText(2, font_metrics.ascent() + 2, thresh_text)
+        else:
+            painter.drawRect(1 + x_offset, 1 + y_offset, 8, 8) 
         
         # Create cursor from pixmap
         cursor = QCursor(pixmap)
@@ -1917,13 +2039,20 @@ class ImageViewerWindow(QMainWindow):
 
             if event.button == 1 or event.button == 3:
 
+                x, y = int(event.xdata), int(event.ydata)
+
+
+                if event.button == 1 and self.can:
+                    self.handle_can(x, y)
+                    return
+
+
                 if event.button == 3:
                     self.erase = True
                 else:
                     self.erase = False
 
                 self.painting = True
-                x, y = int(event.xdata), int(event.ydata)
                 self.last_paint_pos = (x, y)
 
                 if self.pen_button.isChecked():
@@ -1983,7 +2112,77 @@ class ImageViewerWindow(QMainWindow):
             for x in range(max(0, center_x - radius), min(width, center_x + radius + 1)):
                 # Check if point is within circular brush area
                 if (x - center_x) ** 2 + (y - center_y) ** 2 <= radius ** 2:
-                    self.channel_data[channel][self.current_slice][y, x] = val
+
+                    if self.threed and self.threedthresh > 1:
+                        amount = (self.threedthresh - 1) / 2
+                        low = max(0, self.current_slice - amount)
+                        high = min(self.channel_data[channel].shape[0] - 1, self.current_slice + amount)
+
+                        for i in range(int(low), int(high + 1)):
+                            self.channel_data[channel][i][y, x] = val
+                    else:
+                        self.channel_data[channel][self.current_slice][y, x] = val
+
+    def handle_can(self, x, y):
+
+
+        if self.threed:
+            ref = copy.deepcopy(self.channel_data[self.active_channel])
+            the_slice = self.channel_data[self.active_channel]
+            
+            # First invert the boolean array
+            inv = n3d.invert_boolean(the_slice)
+            
+            # Label the connected components in the inverted array
+            labeled_array, num_features = n3d.label_objects(inv)
+            
+            # Get the target label at the clicked point
+            target_label = labeled_array[self.current_slice][y][x]
+            
+            # Only fill if we clicked on a valid region (target_label > 0)
+            if target_label > 0:
+                # Create a mask of the connected component we clicked on
+                fill_mask = (labeled_array == target_label) * 255
+
+                self.last_change = [ref, self.active_channel]
+
+                # Add this mask to the original slice
+                the_slice = the_slice | fill_mask  # Use logical OR to add the filled region
+            
+            # Update the channel data
+            self.load_channel(self.active_channel, the_slice, True)
+        else:
+
+            ref = copy.deepcopy(self.channel_data[self.active_channel])
+
+            the_slice = self.channel_data[self.active_channel][self.current_slice]
+
+            # First invert the boolean array
+            inv = n3d.invert_boolean(the_slice)
+            
+            # Label the connected components in the inverted array
+            labeled_array, num_features = n3d.label_objects(inv)
+            
+            # Get the target label at the clicked point
+            target_label = labeled_array[y][x]
+            
+            # Only fill if we clicked on a valid region (target_label > 0)
+            if target_label > 0:
+                # Create a mask of the connected component we clicked on
+                fill_mask = (labeled_array == target_label) * 255
+
+                self.last_change = [ref, self.active_channel]
+                
+                # Add this mask to the original slice
+                the_slice = the_slice | fill_mask  # Use logical OR to add the filled region
+            
+            # Update the channel data
+            self.channel_data[self.active_channel][self.current_slice] = the_slice
+            self.load_channel(self.active_channel, self.channel_data[self.active_channel], True)
+
+
+
+
 
     def on_mouse_move(self, event):
         """Handle mouse movement events."""
@@ -2070,6 +2269,7 @@ class ImageViewerWindow(QMainWindow):
                     points = self.get_line_points(last_x, last_y, x, y)
                     
                     # Paint at each point along the line
+
                     for px, py in points:
                         if 0 <= px < width and 0 <= py < height:
                             self.paint_at_position(px, py, self.erase, channel)
@@ -2485,7 +2685,7 @@ class ImageViewerWindow(QMainWindow):
         # Process menu
         process_menu = menubar.addMenu("Process")
         calculate_menu = process_menu.addMenu("Calculate")
-        calc_all_action = calculate_menu.addAction("Calculate All (Find Node-Edge-Node Network)")
+        calc_all_action = calculate_menu.addAction("Calculate Connectivity Network (Find Node-Edge-Node Network)")
         calc_all_action.triggered.connect(self.show_calc_all_dialog)
         calc_prox_action = calculate_menu.addAction("Calculate Proximity Network (connect nodes by distance)")
         calc_prox_action.triggered.connect(self.show_calc_prox_dialog)
@@ -2551,8 +2751,8 @@ class ImageViewerWindow(QMainWindow):
         idoverlay_action.triggered.connect(self.show_idoverlay_dialog)
         coloroverlay_action = overlay_menu.addAction("Color Nodes (or Edges)")
         coloroverlay_action.triggered.connect(self.show_coloroverlay_dialog)
-        searchoverlay_action = overlay_menu.addAction("Show Search Regions")
-        searchoverlay_action.triggered.connect(self.show_search_dialog)
+        #searchoverlay_action = overlay_menu.addAction("Show Search Regions")
+        #searchoverlay_action.triggered.connect(self.show_search_dialog)
         shuffle_action = overlay_menu.addAction("Shuffle")
         shuffle_action.triggered.connect(self.show_shuffle_dialog)
         arbitrary_action = image_menu.addAction("Select Objects")
@@ -2887,6 +3087,20 @@ class ImageViewerWindow(QMainWindow):
             elif trumper == '-':
                 for key, value in my_dict.items():
                     my_dict[key] = value[0]
+            elif trumper == '/':
+                new_dict = {}
+                max_val = max(my_dict.keys()) + 1
+                for key, value in my_dict.items():
+                    new_dict[key] = f'{value[0]}'
+                    if len(value) > 1:
+                        for i in range(1, len(value)):
+                            new_dict[max_val] = f'{value[i]}'
+                            try:
+                                my_network.node_centroids[max_val] = my_network.node_centroids[key]
+                            except:
+                                pass
+                            max_val += 1
+                return new_dict
             else:
                 for thing in my_dict:
                     val = my_dict[thing]
@@ -2925,12 +3139,16 @@ class ImageViewerWindow(QMainWindow):
                                 'Multiple IDs Detected',
                                 'The node identities appear to contain multiple ids per node in a list.\n'
                                 'If you desire one node ID to trump all others, enter it here.\n'
-                                '(Enter "-" to have the first IDs trump all others or press x to skip)'
+                                '(Enter "-" to have the first IDs trump all others)\n'
+                                '(Enter "/" to have multi-ID nodes be split into many nodes sharing a centroid)\n'
+                                '(Close this window to continue with multi-ID nodes)'
                             )
                             if not ok or trump_value.strip() == '':
                                 trump_value = None
                             elif trump_value.upper() == '-':
                                 trump_value = '-'
+                            elif trump_value.upper() == "/":
+                                trump_value = '/'
                             my_network.node_identities = uncork(my_network.node_identities, trump_value)
                         else:
                             trump_value = None
@@ -3038,76 +3256,78 @@ class ImageViewerWindow(QMainWindow):
                 "",
                 QFileDialog.Option.ShowDirsOnly
                 )
-            self.reset(nodes = True, network = True, xy_scale = 1, z_scale = 1, edges = True, search_region = True, network_overlay = True, id_overlay = True)
 
+            if directory != "":
 
-            my_network.assemble(directory)
-
-            # Load image channels
-            try:
-                self.load_channel(0, my_network.nodes, True)
-            except Exception as e:
-                print(e)
-            try:
-                self.load_channel(1, my_network.edges, True)
-            except Exception as e:
-                print(e)
-            try:
-                self.load_channel(2, my_network.network_overlay, True)
-            except Exception as e:
-                print(e)
-            try:
-                self.load_channel(3, my_network.id_overlay, True)
-            except Exception as e:
-                print(e)
-
-            # Update slider range based on new data
-            for channel in self.channel_data:
-                if channel is not None:
-                    self.slice_slider.setEnabled(True)
-                    self.slice_slider.setMinimum(0)
-                    self.slice_slider.setMaximum(channel.shape[0] - 1)
-                    self.slice_slider.setValue(0)
-                    self.current_slice = 0
-                    break
+                self.reset(network = True, xy_scale = 1, z_scale = 1, edges = True, network_overlay = True, id_overlay = True)
 
-            # Display network_lists in the network table
-            # Create empty DataFrame for network table if network_lists is None
-            if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
-                empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
-                model = PandasModel(empty_df)
-                self.network_table.setModel(model)
-            else:
-                model = PandasModel(my_network.network_lists)
-                self.network_table.setModel(model)
-                # Adjust column widths to content
-                for column in range(model.columnCount(None)):
-                    self.network_table.resizeColumnToContents(column)
+                my_network.assemble(directory)
 
-            if hasattr(my_network, 'node_centroids') and my_network.node_centroids is not None:
+                # Load image channels
                 try:
-                    self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+                    self.load_channel(0, my_network.nodes, True)
                 except Exception as e:
-                    print(f"Error loading node centroid table: {e}")
-
-            if hasattr(my_network, 'edge_centroids') and my_network.edge_centroids is not None:
+                    print(e)
                 try:
-                    self.format_for_upperright_table(my_network.edge_centroids, 'EdgeID', ['Z', 'Y', 'X'], 'Edge Centroids')
+                    self.load_channel(1, my_network.edges, True)
                 except Exception as e:
-                    print(f"Error loading edge centroid table: {e}")
-
-            if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
+                    print(e)
                 try:
-                    self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+                    self.load_channel(2, my_network.network_overlay, True)
                 except Exception as e:
-                    print(f"Error loading node identity table: {e}")
-
-
-            if hasattr(my_network, 'communities') and my_network.communities is not None:
+                    print(e)
                 try:
-                    self.format_for_upperright_table(my_network.communities, 'NodeID', 'Community', 'Node Communities')
+                    self.load_channel(3, my_network.id_overlay, True)
                 except Exception as e:
-                    print(f"Error loading node community table: {e}")
+                    print(e)
+
+                # Update slider range based on new data
+                for channel in self.channel_data:
+                    if channel is not None:
+                        self.slice_slider.setEnabled(True)
+                        self.slice_slider.setMinimum(0)
+                        self.slice_slider.setMaximum(channel.shape[0] - 1)
+                        self.slice_slider.setValue(0)
+                        self.current_slice = 0
+                        break
+
+                # Display network_lists in the network table
+                # Create empty DataFrame for network table if network_lists is None
+                if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
+                    empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+                    model = PandasModel(empty_df)
+                    self.network_table.setModel(model)
+                else:
+                    model = PandasModel(my_network.network_lists)
+                    self.network_table.setModel(model)
+                    # Adjust column widths to content
+                    for column in range(model.columnCount(None)):
+                        self.network_table.resizeColumnToContents(column)
+
+                if hasattr(my_network, 'node_centroids') and my_network.node_centroids is not None:
+                    try:
+                        self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+                    except Exception as e:
+                        print(f"Error loading node centroid table: {e}")
+
+                if hasattr(my_network, 'edge_centroids') and my_network.edge_centroids is not None:
+                    try:
+                        self.format_for_upperright_table(my_network.edge_centroids, 'EdgeID', ['Z', 'Y', 'X'], 'Edge Centroids')
+                    except Exception as e:
+                        print(f"Error loading edge centroid table: {e}")
+
+                if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
+                    try:
+                        self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+                    except Exception as e:
+                        print(f"Error loading node identity table: {e}")
+
+
+                if hasattr(my_network, 'communities') and my_network.communities is not None:
+                    try:
+                        self.format_for_upperright_table(my_network.communities, 'NodeID', 'Community', 'Node Communities')
+                    except Exception as e:
+                        print(f"Error loading node community table: {e}")
 
         except Exception as e:
             QMessageBox.critical(
@@ -3471,9 +3691,11 @@ class ImageViewerWindow(QMainWindow):
 
         if edges:
             self.delete_channel(1, False)
-
-        if search_region:
-            my_network.search_region = None
+        try:
+            if search_region:
+                my_network.search_region = None
+        except:
+            pass
 
         if network_overlay:
             self.delete_channel(2, False)
@@ -3483,8 +3705,7 @@ class ImageViewerWindow(QMainWindow):
 
 
 
-    def save_network_3d(self, asbool = True):
-
+    def save_network_3d(self, asbool=True):
         try:
             if asbool:  # Save As
                 # First let user select parent directory
@@ -3494,25 +3715,28 @@ class ImageViewerWindow(QMainWindow):
                     "",
                     QFileDialog.Option.ShowDirsOnly
                 )
-
-                if parent_dir:  # If user didn't cancel
-                    # Prompt user for new folder name
-                    new_folder_name, ok = QInputDialog.getText(
-                        self,
-                        "New Folder",
-                        "Enter name for new output folder:"
-                    )
+                if not parent_dir:  # If user canceled the directory selection
+                    return  # Exit the method early
+                    
+                # Prompt user for new folder name
+                new_folder_name, ok = QInputDialog.getText(
+                    self,
+                    "New Folder",
+                    "Enter name for new output folder:"
+                )
                 
+                # Check if user canceled the folder name dialog
+                if not ok or not new_folder_name:
+                    return  # Exit the method early
+            
             else:  # Save
                 parent_dir = None  # Let the backend handle default save location
             
             # Call appropriate save method
-            if parent_dir is not None or not asbool:  # Proceed if we have a filename OR if it's a regular save
-                if asbool:
-                    my_network.dump(parent_dir = parent_dir, name = new_folder_name)
-                else:
-                    my_network.dump(name = 'my_network')
-                
+            if asbool:
+                my_network.dump(parent_dir=parent_dir, name=new_folder_name)
+            else:
+                my_network.dump(name='my_network')
                 
         except Exception as e:
             QMessageBox.critical(
@@ -3689,6 +3913,11 @@ class ImageViewerWindow(QMainWindow):
                     else:
                         # Regular channel processing with colormap
                         # Calculate brightness/contrast limits from entire volume
+                        if self.min_max[channel][0] == None:
+                            self.min_max[channel][0] = np.min(channel)
+                        if self.min_max[channel][1] == None:
+                            self.min_max[channel][1] = np.max(channel)
+
                         img_min = self.min_max[channel][0]
                         img_max = self.min_max[channel][1]
                         
@@ -3699,6 +3928,9 @@ class ImageViewerWindow(QMainWindow):
                         else:
                             vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
                             vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
+
+
+
                         
                         # Normalize the image safely
                         if vmin == vmax:
@@ -3827,7 +4059,8 @@ class ImageViewerWindow(QMainWindow):
             self.canvas.draw()
 
         except:
-            pass
+            import traceback
+            print(traceback.format_exc())
 
     def update_display_slice(self, channel, preserve_zoom=None):
         """Ultra minimal update that only changes the paint channel's data"""
@@ -4675,10 +4908,10 @@ class PropertiesDialog(QDialog):
         self.id_overlay.setChecked(self.check_checked(my_network.id_overlay))
         layout.addRow("Overlay 2 Status", self.id_overlay)
 
-        self.search_region = QPushButton("search region")
-        self.search_region.setCheckable(True)
-        self.search_region.setChecked(self.check_checked(my_network.search_region))
-        layout.addRow("Node Search Region Status", self.search_region)
+        #self.search_region = QPushButton("search region")
+        #self.search_region.setCheckable(True)
+        #self.search_region.setChecked(self.check_checked(my_network.search_region))
+        #layout.addRow("Node Search Region Status", self.search_region)
 
         self.network = QPushButton("Network")
         self.network.setCheckable(True)
@@ -4717,10 +4950,10 @@ class PropertiesDialog(QDialog):
             edges = not self.edges.isChecked()
             network_overlay = not self.network_overlay.isChecked()
             id_overlay = not self.id_overlay.isChecked()
-            search_region = not self.search_region.isChecked()
+            #search_region = not self.search_region.isChecked()
             network = not self.network.isChecked()
 
-            self.parent().reset(nodes = nodes, edges = edges, network_overlay = network_overlay, id_overlay = id_overlay, search_region = search_region, network = network, xy_scale = xy_scale, z_scale = z_scale)
+            self.parent().reset(nodes = nodes, edges = edges, network_overlay = network_overlay, id_overlay = id_overlay, network = network, xy_scale = xy_scale, z_scale = z_scale)
             
             self.accept()
 
@@ -5670,6 +5903,11 @@ class NeighborIdentityDialog(QDialog):
         self.search = QLineEdit("")
         layout.addRow("Search Radius (Ignore if using network):", self.search)
 
+        self.fastdil = QPushButton("Fast Dilate")
+        self.fastdil.setCheckable(True)
+        self.fastdil.setChecked(False)
+        layout.addRow("(If not using network) Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.fastdil)
+
         # Add Run button
         run_button = QPushButton("Get Neighborhood Identity Distribution")
         run_button.clicked.connect(self.neighborids)
@@ -5690,8 +5928,10 @@ class NeighborIdentityDialog(QDialog):
 
             search = float(self.search.text()) if self.search.text().strip() else 0
 
+            fastdil = self.fastdil.isChecked()
+
 
-            result, result2, title1, title2, densities = my_network.neighborhood_identities(root = root, directory = directory, mode = mode, search = search)
+            result, result2, title1, title2, densities = my_network.neighborhood_identities(root = root, directory = directory, mode = mode, search = search, fastdil = fastdil)
 
             self.parent().format_for_upperright_table(result, 'Node Identity', 'Amount', title = title1)
             self.parent().format_for_upperright_table(result2, 'Node Identity', 'Proportion', title = title2)
@@ -5761,10 +6001,10 @@ class RadDialog(QDialog):
         layout = QFormLayout(self)
 
         # GPU checkbox (default False)
-        self.GPU = QPushButton("GPU")
-        self.GPU.setCheckable(True)
-        self.GPU.setChecked(False)
-        layout.addRow("Use GPU:", self.GPU)
+        #self.GPU = QPushButton("GPU")
+        #self.GPU.setCheckable(True)
+        #self.GPU.setChecked(False)
+        #layout.addRow("Use GPU:", self.GPU)
 
 
         # Add Run button
@@ -5775,17 +6015,18 @@ class RadDialog(QDialog):
     def rads(self):
 
         try:
-            GPU = self.GPU.isChecked()
+            #GPU = self.GPU.isChecked() # <- I can never get these to be faster than parallel CPU *shrugs*
 
             active_data = self.parent().channel_data[self.parent().active_channel]
 
-            radii = n3d.estimate_object_radii(active_data, gpu=GPU)
+            radii = n3d.estimate_object_radii(active_data, gpu=False, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale)
 
-            for key, val in radii.items():
-
-                radii[key] = [val, val * (my_network.xy_scale**2) * my_network.z_scale]
+            if self.parent().active_channel == 0:
+                self.parent().radii_dict[0] = radii
+            elif self.parent().active_channel == 1:
+                self.parent().radii_dict[1] = radii
 
-            self.parent().format_for_upperright_table(radii, title = '~Radii of Objects', metric='ObjectID', value=['Largest Radius (Voxels)', 'Largest Radius (Scaled)'])
+            self.parent().format_for_upperright_table(radii, title = 'Largest Radii of Objects', metric='ObjectID', value='Largest Radius (Scaled)')
 
             self.accept()
 
@@ -5818,6 +6059,11 @@ class InteractionDialog(QDialog):
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
+        self.fastdil = QPushButton("Fast Dilate")
+        self.fastdil.setCheckable(True)
+        self.fastdil.setChecked(False)
+        layout.addRow("(If not using network) Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.fastdil)
+
         # Add Run button
         run_button = QPushButton("Calculate")
         run_button.clicked.connect(self.interaction)
@@ -5833,8 +6079,11 @@ class InteractionDialog(QDialog):
                 node_search = float(self.node_search.text()) if self.node_search.text() else 0
             except ValueError:
                 node_search = 0
+                
+
+            fastdil = self.fastdil.isChecked()
 
-            result = my_network.interactions(search = node_search, cores = accepted_mode)
+            result = my_network.interactions(search = node_search, cores = accepted_mode, fastdil = fastdil)
 
             self.parent().format_for_upperright_table(result, 'Node ID', ['Volume of Nearby Edge (Scaled)', 'Volume of Search Region'], title = 'Node/Edge Interactions')
 
@@ -5842,6 +6091,9 @@ class InteractionDialog(QDialog):
 
         except Exception as e:
 
+            import traceback
+            print(traceback.format_exc())
+
             print(f"Error finding interactions: {e}")
 
 
@@ -6198,6 +6450,15 @@ class ResizeDialog(QDialog):
             undo_button.clicked.connect(lambda: self.run_resize(undo = True))
             layout.addRow(undo_button)
 
+        if my_network.xy_scale != my_network.z_scale:
+            norm_button_upsize = QPushButton(f"Normalize Scaling with Upsample")
+            norm_button_upsize.clicked.connect(lambda: self.run_resize(upsize = True, special = True))
+            layout.addRow(norm_button_upsize)
+
+            norm_button_downsize = QPushButton("Normalize Scaling with Downsample")
+            norm_button_downsize.clicked.connect(lambda: self.run_resize(upsize = False, special = True))
+            layout.addRow(norm_button_downsize)
+
         run_button = QPushButton("Run Resize")
         run_button.clicked.connect(self.run_resize)
         layout.addRow(run_button)
@@ -6209,7 +6470,7 @@ class ResizeDialog(QDialog):
         self.xsize.setText("1")
         self.ysize.setText("1")        
 
-    def run_resize(self, undo = False):
+    def run_resize(self, undo = False, upsize = True, special = False):
         try:
             self.parent().resizing = True
             # Get parameters
@@ -6224,7 +6485,27 @@ class ResizeDialog(QDialog):
                 return
             
             resize = resize if resize is not None else (zsize, ysize, xsize)
-            
+
+            if special:
+                if upsize:
+                    if (my_network.z_scale > my_network.xy_scale):
+                        # Z dimension needs to be stretched
+                        resize = [my_network.z_scale/my_network.xy_scale, 1, 1]  # Scale factor for [z, y, x]
+                        cardinal = my_network.xy_scale
+                    elif (my_network.xy_scale > my_network.z_scale):
+                        # XY dimensions need to be stretched
+                        resize = [1, my_network.xy_scale/my_network.z_scale, my_network.xy_scale/my_network.z_scale]  # Scale factor for [z, y, x]
+                        cardinal = my_network.z_scale
+                else:
+                    if (my_network.z_scale > my_network.xy_scale):
+                        # XY dimension needs to be shrunk
+                        resize = [1, my_network.xy_scale/my_network.z_scale, my_network.xy_scale/my_network.z_scale]  # Scale factor for [z, y, x]
+                        cardinal = my_network.z_scale
+                    elif (my_network.xy_scale > my_network.z_scale):
+                        # Z dimensions need to be shrunk
+                        resize = [my_network.z_scale/my_network.xy_scale, 1, 1]  # Scale factor for [z, y, x]
+                        cardinal = my_network.xy_scale
+
             # Get the shape from whichever array exists
             array_shape = None
             if my_network.nodes is not None:
@@ -6306,14 +6587,18 @@ class ResizeDialog(QDialog):
                     self.parent().slice_slider.setMaximum(channel.shape[0] - 1)
                     break
 
-            if isinstance(resize, (int, float)):
-                my_network.xy_scale = my_network.xy_scale/resize
-                my_network.z_scale = my_network.z_scale/resize
-                print("xy_scales and z_scales have been adjusted per resample. Check image -> properties to manually reset them to 1 if desired.")
+            if not special:
+                if isinstance(resize, (int, float)):
+                    my_network.xy_scale = my_network.xy_scale/resize
+                    my_network.z_scale = my_network.z_scale/resize
+                    print("xy_scales and z_scales have been adjusted per resample. Check image -> properties to manually reset them to 1 if desired.")
+                else:
+                    my_network.xy_scale = my_network.xy_scale/resize[1]
+                    my_network.z_scale = my_network.z_scale/resize[0]
+                    print("xy_scales and z_scales have been adjusted per resample. Check image -> properties to manually reset them to 1 if desired. Note that xy_scale will not correspond if you made your XY plane a non-square.")
             else:
-                my_network.xy_scale = my_network.xy_scale/resize[1]
-                my_network.z_scale = my_network.z_scale/resize[0]
-                print("xy_scales and z_scales have been adjusted per resample. Check image -> properties to manually reset them to 1 if desired. Note that xy_scale will not correspond if you made your XY plane a non-square.")
+                my_network.xy_scale = cardinal
+                my_network.z_scale = cardinal
 
             try:
                 if my_network.node_centroids is not None:
@@ -6587,9 +6872,14 @@ class ThresholdDialog(QDialog):
 
         # Add ML button
         ML = QPushButton("Machine Learning")
-        ML.clicked.connect(self.start_ml)
+        ML.clicked.connect(lambda: self.start_ml(GPU = False))
         layout.addRow(ML)
 
+        # Add ML button
+        #ML2 = QPushButton("Machine Learning (GPU)")
+        #ML2.clicked.connect(lambda: self.start_ml(GPU = True))
+        #layout.addRow(ML2)
+
 
     def thresh_mode(self):
 
@@ -6614,7 +6904,7 @@ class ThresholdDialog(QDialog):
         except:
             pass
 
-    def start_ml(self):
+    def start_ml(self, GPU = False):
 
 
         if self.parent().channel_data[2] is not None or self.parent().channel_data[3] is not None or self.parent().highlight_overlay is not None:
@@ -6630,10 +6920,16 @@ class ThresholdDialog(QDialog):
             )
             return
 
+        try:
+            import cupy as cp
+        except:
+            print("Cupy import failed, using CPU version")
+            GPU = False
+
         if self.parent().mini_overlay_data is not None:
             self.parent().mini_overlay_data = None
 
-        self.parent().machine_window = MachineWindow(self.parent())
+        self.parent().machine_window = MachineWindow(self.parent(), GPU = GPU)
         self.parent().machine_window.show()  # Non-modal window
         self.accept()
 
@@ -6650,7 +6946,7 @@ class ThresholdDialog(QDialog):
 
 class MachineWindow(QMainWindow):
 
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, GPU = False):
         super().__init__(parent)
 
         self.setWindowTitle("Threshold")
@@ -6668,6 +6964,9 @@ class MachineWindow(QMainWindow):
 
         if self.parent().pen_button.isChecked(): #Disable the pen mode if the user is in it because the segmenter pen forks it
             self.parent().pen_button.click()
+        self.parent().threed = False
+        self.parent().can = False
+        self.parent().last_change = None
 
         self.parent().pen_button.setEnabled(False)
 
@@ -6743,11 +7042,8 @@ class MachineWindow(QMainWindow):
         # Group 2: Processing Options (GPU)
         processing_group = QGroupBox("Processing Options")
         processing_layout = QHBoxLayout()
-        self.GPU = QPushButton("GPU (Beta)")
-        self.GPU.setCheckable(True)
-        self.GPU.setChecked(False)
-        self.GPU.clicked.connect(self.toggle_GPU)
-        self.use_gpu = False
+
+        self.use_gpu = GPU
         self.two = QPushButton("Train By 2D Slice Patterns")
         self.two.setCheckable(True)
         self.two.setChecked(False)
@@ -6796,7 +7092,8 @@ class MachineWindow(QMainWindow):
 
         # Add all groups to main layout
         main_layout.addWidget(drawing_group)
-        main_layout.addWidget(processing_group)
+        if not GPU:
+            main_layout.addWidget(processing_group)
         main_layout.addWidget(training_group)
         main_layout.addWidget(segmentation_group)
 
@@ -6806,10 +7103,16 @@ class MachineWindow(QMainWindow):
         self.trained = False
         self.previewing = False
 
+        if not GPU:
+            self.segmenter = segmenter.InteractiveSegmenter(active_data, use_gpu=False)
+        else:
+            self.segmenter = segmenter_GPU.InteractiveSegmenter(active_data)
 
-        self.segmenter = segmenter.InteractiveSegmenter(active_data, use_gpu=True)
         self.segmentation_worker = None
 
+        self.fore_button.click()
+        self.fore_button.click()
+
     def toggle_lock(self):
 
         self.mem_lock = self.lock_button.isChecked()
@@ -6835,12 +7138,6 @@ class MachineWindow(QMainWindow):
                 pass
 
 
-
-    def toggle_GPU(self):
-
-
-        self.use_gpu = self.GPU.isChecked()
-
     def toggle_two(self):
         if self.two.isChecked():
             # If button two is checked, ensure button three is unchecked
@@ -6896,6 +7193,8 @@ class MachineWindow(QMainWindow):
             self.parent().zoom_mode = False
             self.parent().update_brush_cursor()
         else:
+            self.threed = False
+            self.can = False
             self.parent().zoom_button.click()
 
     def silence_button(self):
@@ -6918,6 +7217,8 @@ class MachineWindow(QMainWindow):
                 self.trained = True
             except Exception as e:
                 print("Error training. Perhaps you forgot both foreground and background markers? I need both!")
+                import traceback
+                traceback.print_exc()
         except MemoryError:
             QMessageBox.critical(
                 self,
@@ -7580,6 +7881,12 @@ class SmartDilateDialog(QDialog):
         self.GPU.setChecked(False)
         layout.addRow("Use GPU:", self.GPU)
 
+        # dt checkbox (default False)
+        self.predt = QPushButton("Pre-DT")
+        self.predt.setCheckable(True)
+        self.predt.setChecked(False)
+        layout.addRow("Use Distance Transform for Predilation (Better at Large Dilations):", self.predt)
+
         self.down_factor = QLineEdit("")
         layout.addRow("Internal Downsample for GPU (if needed):", self.down_factor)
 
@@ -7594,11 +7901,12 @@ class SmartDilateDialog(QDialog):
 
         GPU = self.GPU.isChecked()
         down_factor = float(self.down_factor.text()) if self.down_factor.text().strip() else None
+        predt = not self.predt.isChecked()
         active_data, amount, xy_scale, z_scale = self.params
 
         dilate_xy, dilate_z = n3d.dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
 
-        result = sdl.smart_dilate(active_data, dilate_xy, dilate_z, GPU = GPU, predownsample = down_factor)
+        result = sdl.smart_dilate(active_data, dilate_xy, dilate_z, GPU = GPU, predownsample = down_factor, fast_dil = predt, use_dt_dil_amount = amount, xy_scale = xy_scale, z_scale = z_scale)
 
         self.parent().load_channel(self.parent().active_channel, result, True)
         self.accept()
@@ -7634,7 +7942,7 @@ class DilateDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Binary Dilation", "Preserve Labels (slower)", "Recursive Binary Dilation (Use if the dilation radius is much larger than your objects)"])
+        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
         layout.addRow("Execution Mode:", self.mode_selector)
 
@@ -7684,18 +7992,17 @@ class DilateDialog(QDialog):
                 return
 
             if accepted_mode == 2:
-                recursive = True
+                result = n3d.dilate_3D_dt(active_data, amount, xy_scaling = xy_scale, z_scaling = z_scale)
             else:
-                recursive = False
 
-            # Call dilate method with parameters
-            result = n3d.dilate(
-                active_data,
-                amount,
-                xy_scale = xy_scale,
-                z_scale = z_scale,
-                recursive = recursive
-            )
+                # Call dilate method with parameters
+                result = n3d.dilate(
+                    active_data,
+                    amount,
+                    xy_scale = xy_scale,
+                    z_scale = z_scale)
+
+            result = result * 255
 
             # Update both the display data and the network object
             self.parent().load_channel(self.parent().active_channel, result, True)
@@ -7739,6 +8046,12 @@ class ErodeDialog(QDialog):
         self.z_scale = QLineEdit(z_scale)
         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)"])
+        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("Execution Mode:", self.mode_selector)
+
        # Add Run button
         run_button = QPushButton("Run Erode")
         run_button.clicked.connect(self.run_erode)
@@ -7769,6 +8082,8 @@ class ErodeDialog(QDialog):
                 z_scale = float(self.z_scale.text()) if self.z_scale.text() else 1
             except ValueError:
                 z_scale = 1
+
+            mode = self.mode_selector.currentIndex()
             
             # Get the active channel data from parent
             active_data = self.parent().channel_data[self.parent().active_channel]
@@ -7781,6 +8096,7 @@ class ErodeDialog(QDialog):
                 amount,
                 xy_scale = xy_scale,
                 z_scale = z_scale,
+                mode = mode
             )
 
 
@@ -8182,8 +8498,7 @@ class WatershedDialog(QDialog):
             self.accept()
             
         except Exception as e:
-            import traceback
-            print(traceback.format_exc())
+
             QMessageBox.critical(
                 self,
                 "Error",
@@ -8343,20 +8658,9 @@ class GenNodesDialog(QDialog):
         layout = QFormLayout(self)
         self.called = called
 
-        self.branch_removal = QLineEdit("0")
-        layout.addRow("Skeleton Voxel Branch Length to Remove (int) (Compensates for spines off medial axis):", self.branch_removal)
-
-        self.comp_dil = QLineEdit("0")
-        layout.addRow("Voxel distance to merge nearby nodes (Int - compensates for multi-branch identification along thick branch regions):", self.comp_dil)
-
-        self.max_vol = QLineEdit("0")
-        layout.addRow("Maximum Voxel Volume of Vertices to Retain (int - Compensates for skeleton looping - occurs before any node merging - the smallest objects are always 27 voxels):", self.max_vol)
-
-        # auto checkbox (default True)
-        self.auto = QPushButton("Auto")
-        self.auto.setCheckable(True)
-        self.auto.setChecked(False)
-        layout.addRow("Attempt to Auto Correct Skeleton Looping:", self.auto)
+        self.directory = QLineEdit()
+        self.directory.setPlaceholderText("Leave empty to save in active dir")
+        layout.addRow("Output Directory:", self.directory)
 
         if not down_factor:
             down_factor = None
@@ -8371,16 +8675,33 @@ class GenNodesDialog(QDialog):
             self.down_factor = down_factor[0]
             self.cubic = down_factor[1]
 
-        self.directory = QLineEdit()
-        self.directory.setPlaceholderText("Leave empty to save in active dir")
-        layout.addRow("Output Directory:", self.directory)
+        self.branch_removal = QLineEdit("0")
+        layout.addRow("Skeleton Voxel Branch Length to Remove (int) (Compensates for spines off medial axis):", self.branch_removal)
+
+        self.max_vol = QLineEdit("0")
+        layout.addRow("Maximum Voxel Volume of Vertices to Retain (int - Compensates for skeleton looping - occurs before any node merging - the smallest objects are always 27 voxels):", self.max_vol)
+
+        self.comp_dil = QLineEdit("0")
+        layout.addRow("Voxel distance to merge nearby nodes (Int - compensates for multi-branch identification along thick branch regions):", self.comp_dil)
+
+        self.fast_dil = QPushButton("Fast-Dil")
+        self.fast_dil.setCheckable(True)
+        self.fast_dil.setChecked(True)
+        layout.addRow("(If using above) Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.fast_dil)
+
+        # auto checkbox (default True)
+        self.auto = QPushButton("Auto")
+        self.auto.setCheckable(True)
+        self.auto.setChecked(True)
+        layout.addRow("Attempt to Auto Correct Skeleton Looping:", self.auto)
+
 
         # retain checkbox (default True)
         if not called:
             self.retain = QPushButton("Retain")
             self.retain.setCheckable(True)
             self.retain.setChecked(True)
-            layout.addRow("Retain Original Edges? (Will be moved to overlay 2):", self.retain)
+            #layout.addRow("Retain Original Edges? (Will be moved to overlay 2):", self.retain)
         else:
             self.retain = False
 
@@ -8436,6 +8757,8 @@ class GenNodesDialog(QDialog):
 
             auto = self.auto.isChecked()
 
+            fastdil = self.fast_dil.isChecked()
+
 
             if auto:
                 my_network.edges = n3d.skeletonize(my_network.edges)
@@ -8449,7 +8772,8 @@ class GenNodesDialog(QDialog):
                 comp_dil=comp_dil,
                 down_factor=down_factor,
                 order = order,
-                return_skele = True
+                return_skele = True,
+                fastdil = fastdil
 
             )
 
@@ -8476,7 +8800,7 @@ class GenNodesDialog(QDialog):
 
             self.parent().load_channel(0, channel_data = result, data = True)
 
-            if retain:
+            if retain and self.called:
                 self.parent().load_channel(3, channel_data = my_network.edges, data = True)
 
 
@@ -8487,6 +8811,9 @@ class GenNodesDialog(QDialog):
             
         except Exception as e:
 
+            import traceback
+            print(traceback.format_exc())
+
 
             QMessageBox.critical(
                 self,
@@ -8581,7 +8908,7 @@ class BranchDialog(QDialog):
 
                     temp_network = n3d.Network_3D(nodes = output)
 
-                    temp_network.morph_proximity(search = 1) #Detect network of nearby branches
+                    temp_network.morph_proximity(search = [3,3], fastdil = True) #Detect network of nearby branches
 
                     temp_network.community_partition(weighted = False, style = 1, dostats = False) #Find communities with louvain, unweighted params
 
@@ -9013,8 +9340,6 @@ class CentroidDialog(QDialog):
 class CalcAllDialog(QDialog):
     # Class variables to store previous settings
     prev_directory = ""
-    prev_xy_scale = "1"
-    prev_z_scale = "1"
     prev_search = ""
     prev_diledge = ""
     prev_down_factor = ""
@@ -9024,7 +9349,7 @@ class CalcAllDialog(QDialog):
     prev_gpu = True
     prev_label_nodes = True
     prev_inners = True
-    prev_skeletonize = False
+    prev_fastdil = False
     prev_overlays = False
     prev_updates = True
 
@@ -9041,10 +9366,10 @@ class CalcAllDialog(QDialog):
         layout.addRow("Output Directory:", self.directory)
         
         # Load previous values for all inputs
-        self.xy_scale = QLineEdit(self.prev_xy_scale)
+        self.xy_scale = QLineEdit(f'{my_network.xy_scale}')
         layout.addRow("xy_scale:", self.xy_scale)
         
-        self.z_scale = QLineEdit(self.prev_z_scale)
+        self.z_scale = QLineEdit(f'{my_network.z_scale}')
         layout.addRow("z_scale:", self.z_scale)
 
         self.search = QLineEdit(self.prev_search)
@@ -9087,10 +9412,10 @@ class CalcAllDialog(QDialog):
         self.inners.setChecked(self.prev_inners)
         layout.addRow("Use Inner Edges:", self.inners)
 
-        self.skeletonize = QPushButton("Skeletonize")
-        self.skeletonize.setCheckable(True)
-        self.skeletonize.setChecked(self.prev_skeletonize)
-        layout.addRow("Skeletonize Edges:", self.skeletonize)
+        self.fastdil = QPushButton("Fast Dilate")
+        self.fastdil.setCheckable(True)
+        self.fastdil.setChecked(self.prev_fastdil)
+        layout.addRow("Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.fastdil)
 
         self.overlays = QPushButton("Overlays")
         self.overlays.setCheckable(True)
@@ -9161,7 +9486,7 @@ class CalcAllDialog(QDialog):
             gpu = self.gpu.isChecked()
             label_nodes = self.label_nodes.isChecked()
             inners = self.inners.isChecked()
-            skeletonize = self.skeletonize.isChecked()
+            fastdil = self.fastdil.isChecked()
             overlays = self.overlays.isChecked()
             update = self.update.isChecked()
 
@@ -9184,13 +9509,11 @@ class CalcAllDialog(QDialog):
                 GPU=gpu,
                 label_nodes=label_nodes,
                 inners=inners,
-                skeletonize=skeletonize
+                fast_dil=fastdil
             )
 
             # Store current values as previous values
             CalcAllDialog.prev_directory = self.directory.text()
-            CalcAllDialog.prev_xy_scale = self.xy_scale.text()
-            CalcAllDialog.prev_z_scale = self.z_scale.text()
             CalcAllDialog.prev_search = self.search.text()
             CalcAllDialog.prev_diledge = self.diledge.text()
             CalcAllDialog.prev_down_factor = self.down_factor.text()
@@ -9200,22 +9523,22 @@ class CalcAllDialog(QDialog):
             CalcAllDialog.prev_gpu = self.gpu.isChecked()
             CalcAllDialog.prev_label_nodes = self.label_nodes.isChecked()
             CalcAllDialog.prev_inners = self.inners.isChecked()
-            CalcAllDialog.prev_skeletonize = self.skeletonize.isChecked()
+            CalcAllDialog.prev_fastdil = self.fastdil.isChecked()
             CalcAllDialog.prev_overlays = self.overlays.isChecked()
             CalcAllDialog.prev_updates = self.update.isChecked()
 
 
             # Update both the display data and the network object
             if update:
-                self.parent().channel_data[0] = my_network.nodes
-                self.parent().channel_data[1] = my_network.edges
+                self.parent().load_channel(0, my_network.nodes, True)
+                self.parent().load_channel(1, my_network.edges, True)
             else:
                 my_network.nodes = temp_nodes.copy()
                 del temp_nodes
                 my_network.edges = temp_edges.copy()
                 del temp_edges
-                self.parent().channel_data[0] = my_network.nodes
-                self.parent().channel_data[1] = my_network.edges
+                self.parent().load_channel(0, my_network.nodes, True)
+                self.parent().load_channel(1, my_network.edges, True)
 
 
             # Then handle overlays
@@ -9228,8 +9551,8 @@ class CalcAllDialog(QDialog):
                 my_network.id_overlay = my_network.draw_node_indices(directory=directory)
                 
                 # Update channel data
-                self.parent().channel_data[2] = my_network.network_overlay
-                self.parent().channel_data[3] = my_network.id_overlay
+                self.parent().load_channel(2, my_network.network_overlay, True)
+                self.parent().load_channel(3, my_network.id_overlay, True)
                 
                 # Enable the overlay channel buttons
                 self.parent().channel_buttons[2].setEnabled(True)
@@ -9315,6 +9638,11 @@ class ProxDialog(QDialog):
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
+        self.fastdil = QPushButton("Fast Dilate")
+        self.fastdil.setCheckable(True)
+        self.fastdil.setChecked(False)
+        layout.addRow("(If using morphological) Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.fastdil)
+
         if my_network.node_identities is not None:
             self.id_selector = QComboBox()
             # Add all options from id dictionary
@@ -9378,7 +9706,8 @@ class ProxDialog(QDialog):
             except ValueError:
                 search = None
 
-            overlays = self.overlays.isChecked()        
+            overlays = self.overlays.isChecked()  
+            fastdil = self.fastdil.isChecked()
 
             my_network.xy_scale = xy_scale
             my_network.z_scale = z_scale
@@ -9389,7 +9718,7 @@ class ProxDialog(QDialog):
                     my_network.nodes, _ = n3d.label_objects(my_network.nodes)
                 if my_network.node_centroids is None:
                     self.parent().show_centroid_dialog()
-                my_network.morph_proximity(search = search, targets = targets)
+                my_network.morph_proximity(search = search, targets = targets, fastdil = fastdil)
 
                 self.parent().load_channel(0, channel_data = my_network.nodes, data = True)
             elif mode == 0: