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

nettracer3d/nettracer_gui.py

@@ -18,14 +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
+#from nettracer3d import segmenter_GPU <--- couldn't get this faster than CPU ¯\_(ツ)_/¯
 
 
 
@@ -118,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
@@ -815,6 +818,8 @@ class ImageViewerWindow(QMainWindow):
                         link_nodes.triggered.connect(self.handle_link)
                         delink_nodes = highlight_menu.addAction("Split Nodes")
                         delink_nodes.triggered.connect(self.handle_split)
+                    override_obj = highlight_menu.addAction("Override Channel with Selection")
+                    override_obj.triggered.connect(self.handle_override)
                     context_menu.addMenu(highlight_menu)
 
                 # Create measure menu
@@ -1659,7 +1664,9 @@ class ImageViewerWindow(QMainWindow):
             print(f"An error has occurred: {e}")
 
 
-
+    def handle_override(self):
+        dialog = OverrideDialog(self)
+        dialog.exec()
 
 
 
@@ -1712,6 +1719,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)
@@ -1729,6 +1739,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()
@@ -1749,14 +1762,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
 
@@ -1793,6 +1861,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:
@@ -1800,28 +1877,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)
@@ -1860,6 +1974,28 @@ class ImageViewerWindow(QMainWindow):
         points.append((x, y))
         return points
 
+    def get_current_mouse_position(self):
+        # Get the main application's current mouse position
+        cursor_pos = QCursor.pos()
+        
+        # Convert global screen coordinates to canvas widget coordinates
+        canvas_pos = self.canvas.mapFromGlobal(cursor_pos)
+        
+        # Check if the position is within the canvas bounds
+        if not (0 <= canvas_pos.x() < self.canvas.width() and 
+                0 <= canvas_pos.y() < self.canvas.height()):
+            return 0, 0  # Mouse is outside of the matplotlib canvas
+        
+        # Convert from canvas widget coordinates to matplotlib data coordinates
+        x = canvas_pos.x()
+        y = canvas_pos.y()
+        
+        # Transform display coordinates to data coordinates
+        inv = self.ax.transData.inverted()
+        data_coords = inv.transform((x, y))
+        
+        return data_coords[0], data_coords[1]
+
     def on_mouse_press(self, event):
         """Handle mouse press events."""
         if event.inaxes != self.ax:
@@ -1929,13 +2065,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():
@@ -1995,7 +2138,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."""
@@ -2082,6 +2295,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)
@@ -2770,8 +2984,11 @@ class ImageViewerWindow(QMainWindow):
 
     def show_type_dialog(self):
         """Show the type dialog"""
-        dialog = TypeDialog(self)
-        dialog.exec()
+        try:
+            dialog = TypeDialog(self)
+            dialog.exec()
+        except:
+            pass
 
     def show_skeletonize_dialog(self):
         """show the skeletonize dialog"""
@@ -4720,10 +4937,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)
@@ -4762,10 +4979,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, network = network, xy_scale = xy_scale, z_scale = z_scale)
+            self.parent().reset(nodes = nodes, edges = edges, search_region = search_region, network_overlay = network_overlay, id_overlay = id_overlay, network = network, xy_scale = xy_scale, z_scale = z_scale)
             
             self.accept()
 
@@ -5769,7 +5986,7 @@ class RandomDialog(QDialog):
     def __init__(self, parent=None):
 
         super().__init__(parent)
-        self.setWindowTitle("Degree Distribution Parameters")
+        self.setWindowTitle("Random Parameters")
         self.setModal(True)
 
         layout = QFormLayout(self)
@@ -5813,10 +6030,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
@@ -5827,7 +6044,7 @@ class RadDialog(QDialog):
     def rads(self):
 
         try:
-            #GPU = self.GPU.isChecked() # <- I can never get these to be faster than parallel CPU *shrugs*
+            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]
 
@@ -5854,7 +6071,7 @@ class InteractionDialog(QDialog):
     def __init__(self, parent=None):
 
         super().__init__(parent)
-        self.setWindowTitle("Partition Parameters")
+        self.setWindowTitle("Interaction Parameters")
         self.setModal(True)
 
         layout = QFormLayout(self)
@@ -5874,7 +6091,7 @@ class InteractionDialog(QDialog):
         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)
+        layout.addRow("Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.fastdil)
 
         # Add Run button
         run_button = QPushButton("Calculate")
@@ -5929,7 +6146,7 @@ class DegreeDialog(QDialog):
         layout.addRow("Execution Mode:", self.mode_selector)
 
         self.mask_limiter = QLineEdit("1")
-        layout.addRow("Masks smaller high degree proportion of nodes (ignore if only returning degrees)", self.mask_limiter)
+        layout.addRow("Proportion of high degree nodes to keep (ignore if only returning degrees)", self.mask_limiter)
 
         self.down_factor = QLineEdit("1")
         layout.addRow("down_factor (for speeding up overlay generation - ignore if only returning degrees:", self.down_factor)
@@ -6474,6 +6691,116 @@ class ResizeDialog(QDialog):
             QMessageBox.critical(self, "Error", f"Failed to resize: {str(e)}")
 
 
+class OverrideDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Override Parameters")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        layout.addRow(QLabel("Use Highlight Overlay to Place Data From: "))
+
+        # Add mode selection dropdown
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["Nodes", "Edges"])
+        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("Overrider:", self.mode_selector)
+
+        layout.addRow(QLabel("To Override Corresponding Data In: "))
+
+        # Add mode selection dropdown
+        self.target_selector = QComboBox()
+        self.target_selector.addItems(["Nodes", "Edges", "Overlay 1", "Overlay 2"])
+        self.target_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("To be overwritten:", self.target_selector)
+
+        layout.addRow(QLabel("Place output in: "))
+
+        # Add mode selection dropdown
+        self.output_selector = QComboBox()
+        self.output_selector.addItems(["Nodes", "Edges", "Overlay 1", "Overlay 2", "Highlight Overlay"])
+        self.output_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("Output Location:", self.output_selector)
+
+        # Add Run button
+        run_button = QPushButton("Override")
+        run_button.clicked.connect(self.override)
+        layout.addWidget(run_button)
+
+    def override(self):
+
+        try:
+
+            accepted_mode = self.mode_selector.currentIndex()
+            accepted_target = self.target_selector.currentIndex()
+            output_target = self.output_selector.currentIndex()
+
+            if accepted_mode == accepted_target:
+                return
+
+            active_data = self.parent().channel_data[accepted_mode]
+
+            if accepted_mode == 0:
+                self.parent().create_highlight_overlay(node_indices=self.parent().clicked_values['nodes'])
+            else:
+                self.parent().create_highlight_overlay(edge_indices=self.parent().clicked_values['edges'])
+
+            target_data = self.parent().channel_data[accepted_target]
+
+            if target_data is None:
+                target_data = np.zeros_like(active_data)
+
+
+
+            try:
+
+                self.parent().highlight_overlay = self.parent().highlight_overlay > 0 #What we want in override image
+                inv = n3d.invert_boolean(self.parent().highlight_overlay) #what we want to keep in target image
+
+                target_data = target_data * inv #Cut out what we don't want in target image
+                max_val = np.max(target_data) #Ensure non-val overlap
+                other_max = np.max(active_data)
+                true_max = max_val + other_max
+                if true_max < 256:
+                    dtype = np.uint8
+                elif true_max < 65536:
+                    dtype = np.uint16
+                else:
+                    dtype = np.uint32
+
+                active_data = active_data.astype(dtype)
+
+                active_data = active_data + max_val #Transpose override image
+
+                active_data = self.parent().highlight_overlay * active_data #Cut out what we want from old image image
+
+                target_data = target_data.astype(dtype)
+
+                target_data = target_data + active_data #Insert new selection
+
+                if output_target == 4:
+
+                    self.parent().highlight_overlay = result
+
+                else:
+
+
+                    # Update both the display data and the network object
+                    self.parent().load_channel(output_target, channel_data = target_data, data = True)
+
+                self.parent().update_display()
+
+                self.accept()
+
+            except Exception as e:
+                print(f"Error overriding: {e}")
+
+        except Exception as e:
+            print(f"Error overriding: {e}")
+
+
+
 class BinarizeDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
@@ -6735,7 +7062,7 @@ class ThresholdDialog(QDialog):
         try:
             import cupy as cp
         except:
-            print("Cupy import failed, using CPU version")
+            #print("Cupy import failed, using CPU version")
             GPU = False
 
         if self.parent().mini_overlay_data is not None:
@@ -6776,6 +7103,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)
 
@@ -6792,8 +7122,12 @@ class MachineWindow(QMainWindow):
                 active_data = self.parent().channel_data[1]
                 act_channel = 1
 
+        try:
+            array1 = np.zeros_like(active_data).astype(np.uint8)
+        except:
+            print("No data in nodes channel")
+            return
 
-        array1 = np.zeros_like(active_data).astype(np.uint8)
         array3 = np.zeros_like(active_data).astype(np.uint8)
         self.parent().highlight_overlay = array3 #Clear this out for the segmenter to use
 
@@ -7002,6 +7336,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):
@@ -7034,6 +7370,7 @@ class MachineWindow(QMainWindow):
             )
 
 
+
     def start_segmentation(self):
 
         self.kill_segmentation()
@@ -7062,7 +7399,11 @@ class MachineWindow(QMainWindow):
             self.segmentation_worker.finished.connect(self.segmentation_finished)
             current_xlim = self.parent().ax.get_xlim()
             current_ylim = self.parent().ax.get_ylim()
-            self.segmenter.update_position(self.parent().current_slice, int((current_ylim[0] - current_ylim[1])/2), int((current_xlim[1] - current_xlim[0])/2))
+            try:
+                x, y = self.parent().get_current_mouse_position()
+            except:
+                x, y = 0, 0
+            self.segmenter.update_position(self.parent().current_slice, x, y)
             self.segmentation_worker.start()
 
     def confirm_seg_dialog(self):
@@ -7128,7 +7469,12 @@ class MachineWindow(QMainWindow):
                 current_xlim = self.parent().ax.get_xlim()
                 current_ylim = self.parent().ax.get_ylim()
 
-                self.segmenter.update_position(self.parent().current_slice, int((current_ylim[0] - current_ylim[1])/2), int((current_xlim[1] - current_xlim[0])/2))
+                try:
+                    x, y = self.parent().get_current_mouse_position()
+                except:
+                    x, y = 0, 0
+                self.segmenter.update_position(self.parent().current_slice, x, y)
+
                 if not self.parent().painting:
                     # Only update if view limits are valid
                     self.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -7423,6 +7769,8 @@ class ThresholdWindow(QMainWindow):
             self.bounds = True
             self.parent().bounds = True
 
+        self.chan = self.parent().active_channel
+
             
         # Create matplotlib figure
         fig = Figure(figsize=(5, 4))
@@ -7491,6 +7839,45 @@ class ThresholdWindow(QMainWindow):
         self.parent().preview = False
         self.parent().targs = None
         self.parent().bounds = False
+        try: # could probably be refactored but this just handles keeping the highlight elements if the user presses X
+            if self.chan == 0:
+                if not self.bounds:
+                    self.parent().clicked_values['nodes'] = self.get_values_in_range_all_vols(self.chan, float(self.min.text()), float(self.max.text()))
+                else:
+                    vals = np.unique(self.parent().channel_data[self.chan])
+                    self.parent().clicked_values['nodes'] = (vals[(vals >= float(self.min.text())) & (vals <= float(self.max.text()))]).tolist()
+
+                if self.parent().channel_data[0].shape[0] * self.parent().channel_data[0].shape[1] * self.parent().channel_data[0].shape[2] > self.parent().mini_thresh:
+                    self.parent().mini_overlay = True
+                    self.parent().create_mini_overlay(node_indices = self.parent().clicked_values['nodes'])
+                else:
+                    self.parent().create_highlight_overlay(
+                        node_indices=self.parent().clicked_values['nodes']
+                    )
+            elif self.chan == 1:
+                if not self.bounds:
+                    self.parent().clicked_values['edges'] = self.get_values_in_range_all_vols(self.chan, float(self.min.text()), float(self.max.text()))
+                else:
+                    vals = np.unique(self.parent().channel_data[self.chan])
+                    self.parent().clicked_values['edges'] = (vals[(vals >= float(self.min.text())) & (vals <= float(self.max.text()))]).tolist()
+
+                if self.parent().channel_data[1].shape[0] * self.parent().channel_data[1].shape[1] * self.parent().channel_data[1].shape[2] > self.parent().mini_thresh:
+                    self.parent().mini_overlay = True
+                    self.parent().create_mini_overlay(edge_indices = self.parent().clicked_values['edges'])
+                else:
+                    self.parent().create_highlight_overlay(
+                        node_indices=self.parent().clicked_values['edges']
+                    )
+        except:
+            pass
+
+
+    def get_values_in_range_all_vols(self, chan, min_val, max_val):
+        output = []
+        for node, vol in self.parent().volume_dict[chan].items():
+            if min_val <= vol <= max_val:
+                output.append(node)
+        return output
 
     def get_values_in_range(self, lst, min_val, max_val):
         values = [x for x in lst if min_val <= x <= max_val]
@@ -7689,10 +8076,10 @@ class SmartDilateDialog(QDialog):
         layout.addRow("Use GPU:", self.GPU)
 
         # dt checkbox (default False)
-        self.predt = QPushButton("Pre-DT")
+        self.predt = QPushButton("Fast Dilation")
         self.predt.setCheckable(True)
         self.predt.setChecked(False)
-        layout.addRow("Use Distance Transform for Predilation (Better at Large Dilations):", self.predt)
+        layout.addRow("Use Fast Dilation (Higher speed, less accurate with search regions much larger than nodes):", self.predt)
 
         self.down_factor = QLineEdit("")
         layout.addRow("Internal Downsample for GPU (if needed):", self.down_factor)
@@ -7708,7 +8095,7 @@ 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()
+        predt = 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)
@@ -7807,7 +8194,8 @@ class DilateDialog(QDialog):
                     active_data,
                     amount,
                     xy_scale = xy_scale,
-                    z_scale = z_scale)
+                    z_scale = z_scale,
+                    fast_dil = True)
 
             result = result * 255
 
@@ -8057,6 +8445,7 @@ class MaskDialog(QDialog):
             print(f"Error masking: {e}")
 
 
+
 class TypeDialog(QDialog):
 
     def __init__(self, parent=None):
@@ -8075,7 +8464,7 @@ class TypeDialog(QDialog):
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["8bit int", "16bit int", "32bit int", "32bit float", "64bit float"])
+        self.mode_selector.addItems(["8bit uint", "16bit uint", "32bit uint", "32bit float", "64bit float"])
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Change to?:", self.mode_selector)
 
@@ -8086,33 +8475,38 @@ class TypeDialog(QDialog):
 
     def run_type(self, active_data):
 
-        mode = self.mode_selector.currentIndex()
+        try:
 
-        if mode == 0:
+            mode = self.mode_selector.currentIndex()
 
-            active_data = active_data.astype(np.uint8)
+            if mode == 0:
 
-        elif mode == 1:
+                active_data = active_data.astype(np.uint8)
 
-            active_data = active_data.astype(np.uint16)
+            elif mode == 1:
 
-        elif mode == 2:
+                active_data = active_data.astype(np.uint16)
 
-            active_data = active_data.astype(np.uint32)
+            elif mode == 2:
 
-        elif mode == 3:
+                active_data = active_data.astype(np.uint32)
 
-            active_data = active_data.astype(np.float32)
+            elif mode == 3:
 
-        elif mode == 4:
+                active_data = active_data.astype(np.float32)
 
-            active_data = active_data.astype(np.float64)
+            elif mode == 4:
 
-        self.parent().load_channel(self.active_chan, active_data, True)
+                active_data = active_data.astype(np.float64)
 
+            self.parent().load_channel(self.active_chan, active_data, True)
 
-        print(f"Channel {self.active_chan}) dtype now: {self.parent().channel_data[self.active_chan].dtype}")
-        self.accept()
+
+            print(f"Channel {self.active_chan}) dtype now: {self.parent().channel_data[self.active_chan].dtype}")
+            self.accept()
+
+        except Exception as E:
+            print(f"Error: {e}")
 
 
 
@@ -8230,7 +8624,7 @@ class WatershedDialog(QDialog):
         # Predownsample (empty by default)
         self.predownsample = QLineEdit()
         self.predownsample.setPlaceholderText("Leave empty for None")
-        layout.addRow("Smart Dilate GPU Downsample:", self.predownsample)
+        layout.addRow("Kernel Obtainment GPU Downsample:", self.predownsample)
         
         # Predownsample2 (empty by default)
         self.predownsample2 = QLineEdit()
@@ -8465,9 +8859,9 @@ class GenNodesDialog(QDialog):
         layout = QFormLayout(self)
         self.called = called
 
-        self.directory = QLineEdit()
-        self.directory.setPlaceholderText("Leave empty to save in active dir")
-        layout.addRow("Output Directory:", self.directory)
+        #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
@@ -8477,7 +8871,7 @@ class GenNodesDialog(QDialog):
             self.cubic = QPushButton("Cubic Downsample")
             self.cubic.setCheckable(True)
             self.cubic.setChecked(False)
-            layout.addRow("(if downsampling): Use cubic dilation? (Slower but can preserve structure better)", self.cubic)
+            layout.addRow("(if downsampling): Use cubic downsample? (Slower but can preserve structure better)", self.cubic)
         else:
             self.down_factor = down_factor[0]
             self.cubic = down_factor[1]
@@ -8521,7 +8915,7 @@ class GenNodesDialog(QDialog):
 
         try:
             # Get directory (None if empty)
-            directory = self.directory.text() if self.directory.text() else None
+            #directory = self.directory.text() if self.directory.text() else None
             
             # Get branch_removal
             try:
@@ -8667,7 +9061,7 @@ class BranchDialog(QDialog):
         self.cubic = QPushButton("Cubic Downsample")
         self.cubic.setCheckable(True)
         self.cubic.setChecked(False)
-        layout.addRow("(if downsampling): Use cubic dilation? (Slower but can preserve structure better)", self.cubic)
+        layout.addRow("(if downsampling): Use cubic downsample? (Slower but can preserve structure better)", self.cubic)
 
         # Add Run button
         run_button = QPushButton("Run Branch Label")
@@ -9090,20 +9484,23 @@ class CentroidDialog(QDialog):
                 my_network.calculate_node_centroids(
                     down_factor = downsample
                 )
-                my_network.save_node_centroids(directory = directory)
+                if directory:
+                    my_network.save_node_centroids(directory = directory)
 
             elif chan == 2:
                 my_network.calculate_edge_centroids(
                     down_factor = downsample
                 )
-                my_network.save_edge_centroids(directory = directory)
+                if directory:
+                    my_network.save_edge_centroids(directory = directory)
 
             elif chan == 0:
                 try:
                     my_network.calculate_node_centroids(
                         down_factor = downsample
                     )
-                    my_network.save_node_centroids(directory = directory)
+                    if directory:
+                        my_network.save_node_centroids(directory = directory)
                 except:
                     pass
 
@@ -9112,7 +9509,8 @@ class CentroidDialog(QDialog):
                     my_network.calculate_edge_centroids(
                         down_factor = downsample
                     )
-                    my_network.save_edge_centroids(directory = directory)
+                    if directory:
+                        my_network.save_edge_centroids(directory = directory)
 
                 except:
                     pass
@@ -9153,7 +9551,7 @@ class CalcAllDialog(QDialog):
     prev_GPU_downsample = ""
     prev_other_nodes = ""
     prev_remove_trunk = ""
-    prev_gpu = True
+    prev_gpu = False
     prev_label_nodes = True
     prev_inners = True
     prev_fastdil = False
@@ -9185,7 +9583,7 @@ class CalcAllDialog(QDialog):
 
         self.diledge = QLineEdit(self.prev_diledge)
         self.diledge.setPlaceholderText("Leave empty for None")
-        layout.addRow("Edge Reconnection Distance (int):", self.diledge)
+        layout.addRow("Edge Reconnection Distance (float):", self.diledge)
 
         self.down_factor = QLineEdit(self.prev_down_factor)
         self.down_factor.setPlaceholderText("Leave empty for None")
@@ -9212,7 +9610,7 @@ class CalcAllDialog(QDialog):
         self.label_nodes = QPushButton("Label")
         self.label_nodes.setCheckable(True)
         self.label_nodes.setChecked(self.prev_label_nodes)
-        layout.addRow("Label Nodes:", self.label_nodes)
+        layout.addRow("Re-Label Nodes (WARNING - OVERRIDES ANY CURRENT LABELS):", self.label_nodes)
 
         self.inners = QPushButton("Inner Edges")
         self.inners.setCheckable(True)
@@ -9551,13 +9949,13 @@ class ProxDialog(QDialog):
                     return
                     
                 if populate:
-                    my_network.nodes = my_network.kd_network(distance = search, targets = targets)
+                    my_network.nodes = my_network.kd_network(distance = search, targets = targets, make_array = True)
                     self.parent().load_channel(0, channel_data = my_network.nodes, data = True)
                 else:
                     my_network.kd_network(distance = search, targets = targets)
 
-
-            my_network.dump(directory = directory)
+            if directory is not None:
+                my_network.dump(directory = directory)
 
 
             # Then handle overlays