nettracer3d 0.6.5__py3-none-any.whl → 0.6.7__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -25,6 +25,7 @@ import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor
 from functools import partial
 from nettracer3d import segmenter
+#from nettracer3d import segmenter_GPU
 
 
 
@@ -147,6 +148,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 +1318,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 +1336,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')
 
@@ -2485,7 +2497,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 +2563,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 +2899,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 +2951,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 +3068,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)
+                self.reset(network = True, xy_scale = 1, z_scale = 1, edges = True, network_overlay = True, id_overlay = True)
 
-            # 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
+                my_network.assemble(directory)
 
-            # 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:
+                # 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 +3503,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 +3517,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 +3527,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 +3725,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 +3740,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 +3871,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 +4720,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 +4762,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 +5715,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 +5740,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 +5813,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 +5827,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)
-
-            for key, val in radii.items():
+            radii = n3d.estimate_object_radii(active_data, gpu=False, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale)
 
-                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 +5871,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 +5891,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 +5903,9 @@ class InteractionDialog(QDialog):
 
         except Exception as e:
 
+            import traceback
+            print(traceback.format_exc())
+
             print(f"Error finding interactions: {e}")
 
 
@@ -6198,6 +6262,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 +6282,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 +6297,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 +6399,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 +6684,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 +6716,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 +6732,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 +6758,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")
@@ -6743,21 +6851,18 @@ 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.two = QPushButton("Train By 2D Slice Patterns (Cheaper - CPU only)")
+
+        self.use_gpu = GPU
+        self.two = QPushButton("Train By 2D Slice Patterns")
         self.two.setCheckable(True)
-        self.two.setChecked(True)
+        self.two.setChecked(False)
         self.two.clicked.connect(self.toggle_two)
-        self.use_two = True
+        self.use_two = False
         self.three = QPushButton("Train by 3D Patterns")
         self.three.setCheckable(True)
-        self.three.setChecked(False)
+        self.three.setChecked(True)
         self.three.clicked.connect(self.toggle_three)
-        processing_layout.addWidget(self.GPU)
+        #processing_layout.addWidget(self.GPU)   [Decided to hold off on this until its more robust]
         processing_layout.addWidget(self.two)
         processing_layout.addWidget(self.three)
         processing_group.setLayout(processing_layout)
@@ -6790,13 +6895,14 @@ class MachineWindow(QMainWindow):
         full_button.clicked.connect(self.segment)
         segmentation_layout.addWidget(seg_button)
         #segmentation_layout.addWidget(self.pause_button)   # <--- for some reason the segmenter preview is still running even when killed, may be regenerating itself somewhere. May or may not actually try to resolve this because this feature isnt that necessary.
-        segmentation_layout.addWidget(self.lock_button)
+        #segmentation_layout.addWidget(self.lock_button)   # Also turned this off
         segmentation_layout.addWidget(full_button)
         segmentation_group.setLayout(segmentation_layout)
 
         # 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 +6912,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 +6947,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
@@ -6918,6 +7024,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 +7688,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 +7708,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 +7749,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 +7799,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 +7853,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 +7889,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 +7903,7 @@ class ErodeDialog(QDialog):
                 amount,
                 xy_scale = xy_scale,
                 z_scale = z_scale,
+                mode = mode
             )
 
 
@@ -7805,6 +7928,18 @@ class HoleDialog(QDialog):
         
         layout = QFormLayout(self)
 
+        # auto checkbox (default True)
+        self.headon = QPushButton("Head-on")
+        self.headon.setCheckable(True)
+        self.headon.setChecked(False)
+        layout.addRow("Only Use 2D Slicing Dimension:", self.headon)
+
+        # auto checkbox (default True)
+        self.borders = QPushButton("Borders")
+        self.borders.setCheckable(True)
+        self.borders.setChecked(True)
+        layout.addRow("Fill Small Holes Along Borders:", self.borders)
+
        # Add Run button
         run_button = QPushButton("Run Fill Holes")
         run_button.clicked.connect(self.run_holes)
@@ -7818,10 +7953,15 @@ class HoleDialog(QDialog):
             active_data = self.parent().channel_data[self.parent().active_channel]
             if active_data is None:
                 raise ValueError("No active image selected")
+
+            borders = self.borders.isChecked()
+            headon = self.headon.isChecked()
             
             # Call dilate method with parameters
             result = n3d.fill_holes_3d(
-                active_data
+                active_data,
+                head_on = headon,
+                fill_borders = borders
             )
 
             self.parent().load_channel(self.parent().active_channel, result, True)
@@ -8165,8 +8305,7 @@ class WatershedDialog(QDialog):
             self.accept()
             
         except Exception as e:
-            import traceback
-            print(traceback.format_exc())
+
             QMessageBox.critical(
                 self,
                 "Error",
@@ -8326,20 +8465,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
@@ -8354,16 +8482,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
 
@@ -8419,6 +8564,8 @@ class GenNodesDialog(QDialog):
 
             auto = self.auto.isChecked()
 
+            fastdil = self.fast_dil.isChecked()
+
 
             if auto:
                 my_network.edges = n3d.skeletonize(my_network.edges)
@@ -8432,7 +8579,8 @@ class GenNodesDialog(QDialog):
                 comp_dil=comp_dil,
                 down_factor=down_factor,
                 order = order,
-                return_skele = True
+                return_skele = True,
+                fastdil = fastdil
 
             )
 
@@ -8459,7 +8607,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)
 
 
@@ -8470,6 +8618,9 @@ class GenNodesDialog(QDialog):
             
         except Exception as e:
 
+            import traceback
+            print(traceback.format_exc())
+
 
             QMessageBox.critical(
                 self,
@@ -8564,7 +8715,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
 
@@ -8996,8 +9147,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 = ""
@@ -9007,7 +9156,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
 
@@ -9024,10 +9173,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)
@@ -9070,10 +9219,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)
@@ -9144,7 +9293,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()
 
@@ -9167,13 +9316,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()
@@ -9183,22 +9330,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
@@ -9211,8 +9358,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)
@@ -9298,6 +9445,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
@@ -9361,7 +9513,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
@@ -9372,7 +9525,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: