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

nettracer3d/nettracer_gui.py

@@ -25,7 +25,7 @@ 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 ¯\_(ツ)_/¯
 
 
 
@@ -818,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
@@ -1244,7 +1246,7 @@ class ImageViewerWindow(QMainWindow):
             except:
                 pass
 
-            print(f"Found {len(filtered_df)} direct connections between nodes of ID {sort} and their neighbors (of any ID)")
+            #print(f"Found {len(filtered_df)} direct connections between nodes of ID {sort} and their neighbors (of any ID)")
 
             if self.channel_data[0].shape[0] * self.channel_data[0].shape[1] * self.channel_data[0].shape[2] > self.mini_thresh:
                 self.mini_overlay = True
@@ -1662,7 +1664,9 @@ class ImageViewerWindow(QMainWindow):
             print(f"An error has occurred: {e}")
 
 
-
+    def handle_override(self):
+        dialog = OverrideDialog(self)
+        dialog.exec()
 
 
 
@@ -1970,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:
@@ -2661,8 +2687,8 @@ class ImageViewerWindow(QMainWindow):
         degree_dist_action.triggered.connect(self.show_degree_dist_dialog)
         neighbor_id_action = stats_menu.addAction("Identity Distribution of Neighbors")
         neighbor_id_action.triggered.connect(self.show_neighbor_id_dialog)
-        random_action = stats_menu.addAction("Generate Equivalent Random Network")
-        random_action.triggered.connect(self.show_random_dialog)
+        ripley_action = stats_menu.addAction("Clustering Analysis")
+        ripley_action.triggered.connect(self.show_ripley_dialog)
         vol_action = stats_menu.addAction("Calculate Volumes")
         vol_action.triggered.connect(self.volumes)
         rad_action = stats_menu.addAction("Calculate Radii")
@@ -2681,6 +2707,13 @@ class ImageViewerWindow(QMainWindow):
         id_code_action = overlay_menu.addAction("Code Identities")
         id_code_action.triggered.connect(lambda: self.show_code_dialog(sort = 'Identity'))
 
+        rand_menu = analysis_menu.addMenu("Randomize")
+        random_action = rand_menu.addAction("Generate Equivalent Random Network")
+        random_action.triggered.connect(self.show_random_dialog)
+        random_nodes = rand_menu.addAction("Scramble Nodes (Centroids)")
+        random_nodes.triggered.connect(self.show_randnode_dialog)
+
+
 
         # Process menu
         process_menu = menubar.addMenu("Process")
@@ -2958,8 +2991,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"""
@@ -3472,8 +3508,8 @@ class ImageViewerWindow(QMainWindow):
                         nii_img = nib.load(filename)
                         # Get data and transpose to match TIFF orientation
                         # If X needs to become Z, we move axis 2 (X) to position 0 (Z)
-                        data = nii_img.get_fdata()
-                        self.channel_data[channel_index] = np.transpose(data, (2, 1, 0))
+                        arraydata = nii_img.get_fdata()
+                        self.channel_data[channel_index] = np.transpose(arraydata, (2, 1, 0))
                         
                     elif file_extension in ['jpg', 'jpeg', 'png']:
                         from PIL import Image
@@ -4128,10 +4164,18 @@ class ImageViewerWindow(QMainWindow):
         dialog = NeighborIdentityDialog(self)
         dialog.exec()
 
+    def show_ripley_dialog(self):
+        dialog = RipleyDialog(self)
+        dialog.exec()
+
     def show_random_dialog(self):
         dialog = RandomDialog(self)
         dialog.exec()
 
+    def show_randnode_dialog(self):
+        dialog = RandNodeDialog(self)
+        dialog.exec()
+
     def show_rad_dialog(self):
         dialog = RadDialog(self)
         dialog.exec()
@@ -4908,10 +4952,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)
@@ -4950,10 +4994,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()
 
@@ -5948,16 +5992,128 @@ class NeighborIdentityDialog(QDialog):
 
 
 
+class RipleyDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle(f"Find Ripley's H Function From Centroids")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        if my_network.node_identities is not None:
+            self.root = QComboBox()
+            self.root.addItems(list(set(my_network.node_identities.values())))  
+            self.root.setCurrentIndex(0)
+            layout.addRow("Root Identity to Search for Neighbors", self.root)
+        else:
+            self.root = None
+
+        if my_network.node_identities is not None:
+            self.targ = QComboBox()
+            self.targ.addItems(list(set(my_network.node_identities.values())))  
+            self.targ.setCurrentIndex(0)
+            layout.addRow("Targ Identity to be Searched For", self.targ)
+        else:
+            self.targ = None
+
+        self.distance = QLineEdit("5")
+        layout.addRow("Bucket Distance for Searching For Clusters (automatically scaled by xy and z scales):", self.distance)
+
+
+        self.proportion = QLineEdit("0.5")
+        layout.addRow("Proportion of image to search? (0-1, high vals increase border artifacts): ", self.proportion)
+
+        self.edgecorrect = QPushButton("Border Correction")
+        self.edgecorrect.setCheckable(True)
+        self.edgecorrect.setChecked(False)
+        layout.addRow("Use Border Correction (Extrapolate for points beyond the border):", self.edgecorrect)
+
+        self.ignore = QPushButton("Ignore Border Roots")
+        self.ignore.setCheckable(True)
+        self.ignore.setChecked(False)
+        layout.addRow("Exclude Root Nodes Near Borders?:", self.ignore)
+
+        # Add Run button
+        run_button = QPushButton("Get Ripley's H")
+        run_button.clicked.connect(self.ripley)
+        layout.addWidget(run_button)
+
+    def ripley(self):
+
+        try:
+
+            if my_network.node_centroids is None:
+                self.parent().show_centroid_dialog()
+
+            try:
+                root = self.root.currentText()
+            except:
+                root = None
+
+            try:
+                targ = self.targ.currentText()
+            except:
+                targ = None
+
+            try:
+                distance = float(self.distance.text())
+            except:
+                return
+
+
+            try:
+                proportion = abs(float(self.proportion.text()))
+            except:
+                proportion = 0.5
+
+            if proportion > 1 or proportion <= 0:
+                print("Utilizing proportion = 0.5")
+                proportion = 0.5
 
 
+            edgecorrect = self.edgecorrect.isChecked()
 
+            ignore = self.ignore.isChecked()
+
+            if my_network.nodes is not None:
+
+                if my_network.nodes.shape[0] == 1:
+                    bounds = (np.array([0, 0]), np.array([my_network.nodes.shape[2], my_network.nodes.shape[1]]))
+                else:
+                    bounds = (np.array([0, 0, 0]), np.array([my_network.nodes.shape[2], my_network.nodes.shape[1], my_network.nodes.shape[0]]))
+            else:
+                bounds = None
+
+            r_vals, k_vals, h_vals = my_network.get_ripley(root, targ, distance, edgecorrect, bounds, ignore, proportion)
+            
+            k_dict = dict(zip(r_vals, k_vals))
+            h_dict = dict(zip(r_vals, h_vals))
+
+
+            self.parent().format_for_upperright_table(k_dict, metric='Radius (scaled)', value='L Value', title="Ripley's K")
+            self.parent().format_for_upperright_table(h_dict, metric='Radius (scaled)', value='L Normed', title="Ripley's H")
+
+
+            self.accept()
+
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                "Error:",
+                f"Failed to preform cluster analysis: {str(e)}"
+            )
+            import traceback
+            print(traceback.format_exc())
+            print(f"Error: {e}")
 
 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)
@@ -5990,6 +6146,79 @@ class RandomDialog(QDialog):
 
         self.accept()
 
+class RandNodeDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Random Node Parameters")
+        self.setModal(True)
+        layout = QFormLayout(self)
+
+
+        self.mode = QComboBox()
+        self.mode.addItems(["Anywhere", "Within Dimensional Bounds of Nodes", "Within Masked Bounds of Edges", "Within Masked Bounds of Overlay1", "Within Masked Bounds of Overlay2"])
+        self.mode.setCurrentIndex(0)
+        layout.addRow("Mode", self.mode)
+
+        # Add Run button
+        run_button = QPushButton("Get Random Nodes (Will go in Nodes)")
+        run_button.clicked.connect(self.random)
+        layout.addWidget(run_button)
+
+    def random(self):
+
+        try:
+
+            if my_network.node_centroids is None:
+                self.parent().show_centroid_dialog()
+
+            bounds = None
+            mask = None
+
+            mode = self.mode.currentIndex()
+
+            if mode == 0 and not (my_network.nodes is None and my_network.edges is None and my_network.network_overlay is None and my_network.id_overlay is None):
+                pass
+            elif mode == 1 or (my_network.nodes is None and my_network.edges is None and my_network.network_overlay is None and my_network.id_overlay is None):
+                print("HELLO")
+                # Convert string labels to integers if necessary
+                if any(isinstance(k, str) for k in my_network.node_centroids.keys()):
+                    label_map = {label: idx for idx, label in enumerate(my_network.node_centroids.keys())}
+                    my_network.node_centroids = {label_map[k]: v for k, v in my_network.node_centroids.items()}
+                
+                # Convert centroids to array and keep track of labels
+                labels = np.array(list(my_network.node_centroids.keys()), dtype=np.uint32)
+                centroid_points = np.array([my_network.node_centroids[label] for label in labels])
+                
+                # Calculate shape if not provided
+                max_coords = centroid_points.max(axis=0)
+                max_shape = tuple(max_coord + 1 for max_coord in max_coords)
+                min_coords = centroid_points.min(axis=0)
+                min_shape = tuple(min_coord + 1 for min_coord in min_coords)
+                bounds = (min_shape, max_shape)
+            else:
+                mask = n3d.binarize(self.parent().channel_data[mode - 1])
+
+            centroids, array = my_network.random_nodes(bounds = bounds, mask = mask)
+
+            if my_network.nodes is not None:
+                try:
+                    self.parent().load_channel(0, array, data = True)
+                except:
+                    pass
+
+            self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                "Error:",
+                f"Failed to randomize: {str(e)}"
+            )
+            print(f"Error: {e}")
+
+
 class RadDialog(QDialog):
 
     def __init__(self, parent=None):
@@ -6001,10 +6230,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
@@ -6015,7 +6244,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]
 
@@ -6042,7 +6271,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)
@@ -6062,7 +6291,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")
@@ -6117,7 +6346,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)
@@ -6662,6 +6891,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)
@@ -6923,7 +7262,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:
@@ -6983,8 +7322,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
 
@@ -7065,8 +7408,14 @@ class MachineWindow(QMainWindow):
         train_quick.clicked.connect(lambda: self.train_model(speed=True))
         train_detailed = QPushButton("Train More Detailed Model")
         train_detailed.clicked.connect(lambda: self.train_model(speed=False))
+        save = QPushButton("Save Model")
+        save.clicked.connect(self.save_model)
+        load = QPushButton("Load Model")
+        load.clicked.connect(self.load_model)
         training_layout.addWidget(train_quick)
         training_layout.addWidget(train_detailed)
+        training_layout.addWidget(save)
+        training_layout.addWidget(load)
         training_group.setLayout(training_layout)
 
         # Group 4: Segmentation Options
@@ -7137,6 +7486,33 @@ class MachineWindow(QMainWindow):
             except:
                 pass
 
+    def save_model(self):
+
+        filename, _ = QFileDialog.getSaveFileName(
+            self,
+            f"Save Model As",
+            "",  # Default directory
+            "numpy data (*.npz);;All Files (*)"  # File type filter
+        )
+        
+        if filename:  # Only proceed if user didn't cancel
+            # If user didn't type an extension, add .tif
+            if not filename.endswith(('.npz')):
+                filename += '.npz'
+
+        self.segmenter.save_model(filename, self.parent().channel_data[2])
+
+    def load_model(self):
+
+        filename, _ = QFileDialog.getOpenFileName(
+            self,
+            f"Load Model",
+            "",
+            "numpy data (*.npz)"
+        )
+
+        self.segmenter.load_model(filename)
+        self.trained = True
 
     def toggle_two(self):
         if self.two.isChecked():
@@ -7227,6 +7603,7 @@ class MachineWindow(QMainWindow):
             )
 
 
+
     def start_segmentation(self):
 
         self.kill_segmentation()
@@ -7255,7 +7632,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):
@@ -7321,7 +7702,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))
@@ -7616,6 +8002,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))
@@ -7684,6 +8072,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]
@@ -7882,10 +8309,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)
@@ -7901,7 +8328,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)
@@ -8000,7 +8427,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
 
@@ -8250,6 +8678,7 @@ class MaskDialog(QDialog):
             print(f"Error masking: {e}")
 
 
+
 class TypeDialog(QDialog):
 
     def __init__(self, parent=None):
@@ -8268,7 +8697,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)
 
@@ -8279,33 +8708,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}")
 
 
 
@@ -8423,7 +8857,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()
@@ -8658,9 +9092,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
@@ -8670,7 +9104,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]
@@ -8714,7 +9148,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:
@@ -8860,7 +9294,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")
@@ -9283,20 +9717,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
 
@@ -9305,7 +9742,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
@@ -9346,7 +9784,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
@@ -9378,7 +9816,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")
@@ -9405,7 +9843,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)
@@ -9744,13 +10182,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