nettracer3d 0.6.8__py3-none-any.whl → 0.6.9__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
@@ -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:
@@ -2958,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"""
@@ -4908,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)
@@ -4950,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()
 
@@ -5957,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)
@@ -6001,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
@@ -6015,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]
 
@@ -6042,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)
@@ -6062,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")
@@ -6117,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)
@@ -6662,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)
@@ -6923,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:
@@ -6983,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
 
@@ -7227,6 +7370,7 @@ class MachineWindow(QMainWindow):
             )
 
 
+
     def start_segmentation(self):
 
         self.kill_segmentation()
@@ -7255,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):
@@ -7321,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))
@@ -7616,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))
@@ -7684,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]
@@ -7882,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)
@@ -7901,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)
@@ -8000,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
 
@@ -8250,6 +8445,7 @@ class MaskDialog(QDialog):
             print(f"Error masking: {e}")
 
 
+
 class TypeDialog(QDialog):
 
     def __init__(self, parent=None):
@@ -8268,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)
 
@@ -8279,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}")
 
 
 
@@ -8423,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()
@@ -8658,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
@@ -8670,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]
@@ -8714,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:
@@ -8860,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")
@@ -9283,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
 
@@ -9305,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
@@ -9346,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
@@ -9378,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")
@@ -9405,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)
@@ -9744,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