nettracer3d 0.5.9__py3-none-any.whl → 0.6.1__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -840,7 +840,7 @@ class ImageViewerWindow(QMainWindow):
                 select_nodes.triggered.connect(lambda: self.handle_select_all(edges = False, nodes = True))
                 select_both.triggered.connect(lambda: self.handle_select_all(edges = True))
                 select_edges.triggered.connect(lambda: self.handle_select_all(edges = True, nodes = False))
-                if self.highlight_overlay is not None:
+                if self.highlight_overlay is not None or self.mini_overlay_data is not None:
                     highlight_select = context_menu.addAction("Add highlight in network selection")
                     highlight_select.triggered.connect(self.handle_highlight_select)
                 show_remove_menu.triggered.connect(self.handle_remove_points)
@@ -1259,19 +1259,28 @@ class ImageViewerWindow(QMainWindow):
                 nodes = list(np.unique(my_network.nodes))
                 if nodes[0] == 0:
                     del nodes[0]
+                num = (self.channel_data[0].shape[0] * self.channel_data[0].shape[1] * self.channel_data[0].shape[2])
+                print(f"Found {len(nodes)} node objects")
             else:
                 nodes = []
             if edges:
                 edges = list(np.unique(my_network.edges))
+                num = (self.channel_data[1].shape[0] * self.channel_data[1].shape[1] * self.channel_data[1].shape[2])
                 if edges[0] == 0:
                     del edges[0]
+                print(f"Found {len(edges)} edge objects")
             else:
                 edges = []
 
-            self.clicked_values['nodes'] += nodes
-            self.clicked_values['edges'] += edges
+            self.clicked_values['nodes'] = nodes
+            self.clicked_values['edges'] = edges
 
-            self.create_highlight_overlay(edge_indices = self.clicked_values['edges'], node_indices = self.clicked_values['nodes'])
+
+            if num > self.mini_thresh:
+                self.mini_overlay = True
+                self.create_mini_overlay(node_indices = nodes, edge_indices = edges)
+            else:
+                self.create_highlight_overlay(edge_indices = self.clicked_values['edges'], node_indices = self.clicked_values['nodes'])
 
         except Exception as e:
             print(f"Error: {e}")
@@ -2466,6 +2475,8 @@ class ImageViewerWindow(QMainWindow):
         searchoverlay_action.triggered.connect(self.show_search_dialog)
         shuffle_action = overlay_menu.addAction("Shuffle")
         shuffle_action.triggered.connect(self.show_shuffle_dialog)
+        arbitrary_action = image_menu.addAction("Select Objects")
+        arbitrary_action.triggered.connect(self.show_arbitrary_dialog)
         show3d_action = image_menu.addAction("Show 3D (Napari)")
         show3d_action.triggered.connect(self.show3d_dialog)
 
@@ -2596,6 +2607,11 @@ class ImageViewerWindow(QMainWindow):
         dialog = WatershedDialog(self)
         dialog.exec()
 
+    def show_arbitrary_dialog(self):
+        """Show the arbitrary selection dialog."""
+        dialog = ArbitraryDialog(self)
+        dialog.exec()
+
     def show_invert_dialog(self):
         """Show the watershed parameter dialog."""
         dialog = InvertDialog(self)
@@ -3504,8 +3520,8 @@ class ImageViewerWindow(QMainWindow):
         current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
         # Convert slider values (0-100) to data values (0-1)
         min_val, max_val = values
-        self.channel_brightness[channel_index]['min'] = min_val / 255 #Accomodate 32 bit data?
-        self.channel_brightness[channel_index]['max'] = max_val / 255
+        self.channel_brightness[channel_index]['min'] = min_val / 65535 #Accomodate 32 bit data?
+        self.channel_brightness[channel_index]['max'] = max_val / 65535
         self.update_display(preserve_zoom = (current_xlim, current_ylim))
 
 
@@ -3514,206 +3530,211 @@ class ImageViewerWindow(QMainWindow):
     def update_display(self, preserve_zoom=None, dims = None, called = False, reset_resize = False, begin_paint = False):
         """Update the display with currently visible channels and highlight overlay."""
 
-        if begin_paint:
-            # Store/update the static background with current zoom level
-            self.static_background = self.canvas.copy_from_bbox(self.ax.bbox)
+        try:
 
+            if begin_paint:
+                # Store/update the static background with current zoom level
+                self.static_background = self.canvas.copy_from_bbox(self.ax.bbox)
 
-        self.figure.clear()
 
-        # Get active channels and their dimensions
-        active_channels = [i for i in range(4) if self.channel_data[i] is not None]
-        if dims is None:
-            if active_channels:
-                dims = [(self.channel_data[i].shape[1:3] if len(self.channel_data[i].shape) >= 3 else 
-                        self.channel_data[i].shape) for i in active_channels]
-                min_height = min(d[0] for d in dims)
-                min_width = min(d[1] for d in dims)
-            else:
-                min_height = 1
-                min_width = 1
-        else:
-            min_height = dims[0]
-            min_width = dims[1]
+            self.figure.clear()
 
-        # Set axes limits before displaying any images
-        self.ax.set_xlim(-0.5, min_width - 0.5)
-        self.ax.set_ylim(min_height - 0.5, -0.5)
-        
-        # Create subplot with tight layout and white figure background
-        self.figure.patch.set_facecolor('white')
-        self.ax = self.figure.add_subplot(111)
-        
-        # Store current zoom limits if they exist and weren't provided
- 
-        current_xlim, current_ylim = preserve_zoom if preserve_zoom else (None, None)
-        
-        # Define base colors for each channel with increased intensity
-        base_colors = self.base_colors
-        # Set only the axes (image area) background to black
-        self.ax.set_facecolor('black')
-        
-        # Display each visible channel
-        for channel in range(4):
-            if (self.channel_visible[channel] and 
-                self.channel_data[channel] is not None):
-                
-                # Check if we're dealing with RGB data
-                is_rgb = len(self.channel_data[channel].shape) == 4 and (self.channel_data[channel].shape[-1] == 3 or self.channel_data[channel].shape[-1] == 4)
-                
-                if len(self.channel_data[channel].shape) == 3 and not is_rgb:
-                    current_image = self.channel_data[channel][self.current_slice, :, :]
-                elif is_rgb:
-                    current_image = self.channel_data[channel][self.current_slice]  # Already has RGB channels
+            # Get active channels and their dimensions
+            active_channels = [i for i in range(4) if self.channel_data[i] is not None]
+            if dims is None:
+                if active_channels:
+                    dims = [(self.channel_data[i].shape[1:3] if len(self.channel_data[i].shape) >= 3 else 
+                            self.channel_data[i].shape) for i in active_channels]
+                    min_height = min(d[0] for d in dims)
+                    min_width = min(d[1] for d in dims)
                 else:
-                    current_image = self.channel_data[channel]
-
-                if is_rgb and self.channel_data[channel].shape[-1] == 3:
-                    # For RGB images, just display directly without colormap
-                    self.ax.imshow(current_image,
-                                 alpha=0.7)
-                elif is_rgb and self.channel_data[channel].shape[-1] == 4:
-                    self.ax.imshow(current_image) #For images that already have an alpha value and RGB, don't update alpha
+                    min_height = 1
+                    min_width = 1
+            else:
+                min_height = dims[0]
+                min_width = dims[1]
 
-                else:
-                    # Regular channel processing with colormap
-                    # Calculate brightness/contrast limits from entire volume
-                    img_min = self.min_max[channel][0]
-                    img_max = self.min_max[channel][1]
+            # Set axes limits before displaying any images
+            self.ax.set_xlim(-0.5, min_width - 0.5)
+            self.ax.set_ylim(min_height - 0.5, -0.5)
+            
+            # Create subplot with tight layout and white figure background
+            self.figure.patch.set_facecolor('white')
+            self.ax = self.figure.add_subplot(111)
+            
+            # Store current zoom limits if they exist and weren't provided
+     
+            current_xlim, current_ylim = preserve_zoom if preserve_zoom else (None, None)
+            
+            # Define base colors for each channel with increased intensity
+            base_colors = self.base_colors
+            # Set only the axes (image area) background to black
+            self.ax.set_facecolor('black')
+            
+            # Display each visible channel
+            for channel in range(4):
+                if (self.channel_visible[channel] and 
+                    self.channel_data[channel] is not None):
                     
-                    # Calculate vmin and vmax, ensuring we don't get a zero range
-                    if img_min == img_max:
-                        vmin = img_min
-                        vmax = img_min + 1
-                    else:
-                        vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
-                        vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
+                    # Check if we're dealing with RGB data
+                    is_rgb = len(self.channel_data[channel].shape) == 4 and (self.channel_data[channel].shape[-1] == 3 or self.channel_data[channel].shape[-1] == 4)
                     
-                    # Normalize the image safely
-                    if vmin == vmax:
-                        normalized_image = np.zeros_like(current_image)
+                    if len(self.channel_data[channel].shape) == 3 and not is_rgb:
+                        current_image = self.channel_data[channel][self.current_slice, :, :]
+                    elif is_rgb:
+                        current_image = self.channel_data[channel][self.current_slice]  # Already has RGB channels
                     else:
-                        normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
-                    
-                    if channel == 2 and self.machine_window is not None:
-                        custom_cmap = LinearSegmentedColormap.from_list(
-                            f'custom_{channel}',
-                            [(0, 0, 0, 0),          # transparent for 0
-                             (0.5, 1, 0.5, 1),      # light green for 1
-                             (1, 0.5, 0.5, 1)]      # light red for 2
-                        )
+                        current_image = self.channel_data[channel]
+
+                    if is_rgb and self.channel_data[channel].shape[-1] == 3:
+                        # For RGB images, just display directly without colormap
                         self.ax.imshow(current_image,
-                                     cmap=custom_cmap,
-                                     vmin=0,
-                                     vmax=2,
-                                     alpha=0.7,
-                                     interpolation='nearest',
-                                     extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+                                     alpha=0.7)
+                    elif is_rgb and self.channel_data[channel].shape[-1] == 4:
+                        self.ax.imshow(current_image) #For images that already have an alpha value and RGB, don't update alpha
+
                     else:
-                        # Create custom colormap with higher intensity
-                        color = base_colors[channel]
-                        custom_cmap = LinearSegmentedColormap.from_list(
-                            f'custom_{channel}',
-                            [(0,0,0,0), (*color,1)]
-                        )
+                        # Regular channel processing with colormap
+                        # Calculate brightness/contrast limits from entire volume
+                        img_min = self.min_max[channel][0]
+                        img_max = self.min_max[channel][1]
                         
-                        # Display the image with slightly higher alpha
-                        self.ax.imshow(normalized_image,
-                                     alpha=0.7,
-                                     cmap=custom_cmap,
-                                     vmin=0,
-                                     vmax=1,
-                                     extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
-
-        if self.preview and not called:
-            self.create_highlight_overlay_slice(self.targs, bounds = self.bounds)
-
-        # Add highlight overlay if it exists
-        if self.mini_overlay and self.highlight and self.machine_window is None:
-            highlight_cmap = LinearSegmentedColormap.from_list(
-                'highlight',
-                [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
-            )
-            self.ax.imshow(self.mini_overlay_data,
-                         cmap=highlight_cmap,
-                         alpha=0.5)
-        elif self.highlight_overlay is not None and self.highlight and self.machine_window is None:
-            highlight_slice = self.highlight_overlay[self.current_slice]
-            highlight_cmap = LinearSegmentedColormap.from_list(
-                'highlight',
-                [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
-            )
-            self.ax.imshow(highlight_slice,
-                         cmap=highlight_cmap,
-                         alpha=0.5)
-        elif self.highlight_overlay is not None and self.highlight:
-            highlight_slice = self.highlight_overlay[self.current_slice]
-            highlight_cmap = LinearSegmentedColormap.from_list(
-                'highlight',
-                [(0, 0, 0, 0),          # transparent for 0
-                 (1, 1, 0, 1),          # bright yellow for 1
-                 (0, 0.7, 1, 1)]        # cool blue for 2
-            )
-            self.ax.imshow(highlight_slice,
-                         cmap=highlight_cmap,
-                         vmin=0,
-                         vmax=2,         # Important: set vmax to 2 to accommodate both values
-                         alpha=0.5)
-
-
-
-        
-        # Style the axes
-        self.ax.set_xlabel('X')
-        self.ax.set_ylabel('Y')
-        self.ax.set_title(f'Slice {self.current_slice}')
-
-        # Make axis labels and ticks black for visibility against white background
-        self.ax.xaxis.label.set_color('black')
-        self.ax.yaxis.label.set_color('black')
-        self.ax.title.set_color('black')
-        self.ax.tick_params(colors='black')
-        for spine in self.ax.spines.values():
-            spine.set_color('black')
-
-        # Adjust the layout to ensure the plot fits well in the figure
-        self.figure.tight_layout()
-
-        # Redraw measurement points and their labels
-        for point in self.measurement_points:
-            x1, y1, z1 = point['point1']
-            x2, y2, z2 = point['point2']
-            pair_idx = point['pair_index']
-            
-            # Draw points and labels if they're on current slice
-            if z1 == self.current_slice:
-                self.ax.plot(x1, y1, 'yo', markersize=8)
-                self.ax.text(x1, y1+5, str(pair_idx), 
-                            color='white', ha='center', va='bottom')
-            if z2 == self.current_slice:
-                self.ax.plot(x2, y2, 'yo', markersize=8)
-                self.ax.text(x2, y2+5, str(pair_idx), 
-                            color='white', ha='center', va='bottom')
-                
-            # Draw line if both points are on current slice
-            if z1 == z2 == self.current_slice:
-                self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
-    
-        if active_channels:
-            self.ax.set_xlim(-0.5, min_width - 0.5)
-            self.ax.set_ylim(min_height - 0.5, -0.5)
+                        # Calculate vmin and vmax, ensuring we don't get a zero range
+                        if img_min == img_max:
+                            vmin = img_min
+                            vmax = img_min + 1
+                        else:
+                            vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
+                            vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
+                        
+                        # Normalize the image safely
+                        if vmin == vmax:
+                            normalized_image = np.zeros_like(current_image)
+                        else:
+                            normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
+                        
+                        if channel == 2 and self.machine_window is not None:
+                            custom_cmap = LinearSegmentedColormap.from_list(
+                                f'custom_{channel}',
+                                [(0, 0, 0, 0),          # transparent for 0
+                                 (0.5, 1, 0.5, 1),      # light green for 1
+                                 (1, 0.5, 0.5, 1)]      # light red for 2
+                            )
+                            self.ax.imshow(current_image,
+                                         cmap=custom_cmap,
+                                         vmin=0,
+                                         vmax=2,
+                                         alpha=0.7,
+                                         interpolation='nearest',
+                                         extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+                        else:
+                            # Create custom colormap with higher intensity
+                            color = base_colors[channel]
+                            custom_cmap = LinearSegmentedColormap.from_list(
+                                f'custom_{channel}',
+                                [(0,0,0,0), (*color,1)]
+                            )
+                            
+                            # Display the image with slightly higher alpha
+                            self.ax.imshow(normalized_image,
+                                         alpha=0.7,
+                                         cmap=custom_cmap,
+                                         vmin=0,
+                                         vmax=1,
+                                         extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+
+            if self.preview and not called:
+                self.create_highlight_overlay_slice(self.targs, bounds = self.bounds)
+
+            # Add highlight overlay if it exists
+            if self.mini_overlay and self.highlight and self.machine_window is None:
+                highlight_cmap = LinearSegmentedColormap.from_list(
+                    'highlight',
+                    [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
+                )
+                self.ax.imshow(self.mini_overlay_data,
+                             cmap=highlight_cmap,
+                             alpha=0.5)
+            elif self.highlight_overlay is not None and self.highlight and self.machine_window is None:
+                highlight_slice = self.highlight_overlay[self.current_slice]
+                highlight_cmap = LinearSegmentedColormap.from_list(
+                    'highlight',
+                    [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
+                )
+                self.ax.imshow(highlight_slice,
+                             cmap=highlight_cmap,
+                             alpha=0.5)
+            elif self.highlight_overlay is not None and self.highlight:
+                highlight_slice = self.highlight_overlay[self.current_slice]
+                highlight_cmap = LinearSegmentedColormap.from_list(
+                    'highlight',
+                    [(0, 0, 0, 0),          # transparent for 0
+                     (1, 1, 0, 1),          # bright yellow for 1
+                     (0, 0.7, 1, 1)]        # cool blue for 2
+                )
+                self.ax.imshow(highlight_slice,
+                             cmap=highlight_cmap,
+                             vmin=0,
+                             vmax=2,         # Important: set vmax to 2 to accommodate both values
+                             alpha=0.5)
 
-        if self.resizing:
-            self.original_xlim = self.ax.get_xlim()
-            self.original_ylim = self.ax.get_ylim()
-        # Restore zoom limits if they existed
-        if current_xlim is not None and current_ylim is not None:
-            self.ax.set_xlim(current_xlim)
-            self.ax.set_ylim(current_ylim)
-        if reset_resize:
-            self.resizing = False
+
+
+            
+            # Style the axes
+            self.ax.set_xlabel('X')
+            self.ax.set_ylabel('Y')
+            self.ax.set_title(f'Slice {self.current_slice}')
+
+            # Make axis labels and ticks black for visibility against white background
+            self.ax.xaxis.label.set_color('black')
+            self.ax.yaxis.label.set_color('black')
+            self.ax.title.set_color('black')
+            self.ax.tick_params(colors='black')
+            for spine in self.ax.spines.values():
+                spine.set_color('black')
+
+            # Adjust the layout to ensure the plot fits well in the figure
+            self.figure.tight_layout()
+
+            # Redraw measurement points and their labels
+            for point in self.measurement_points:
+                x1, y1, z1 = point['point1']
+                x2, y2, z2 = point['point2']
+                pair_idx = point['pair_index']
+                
+                # Draw points and labels if they're on current slice
+                if z1 == self.current_slice:
+                    self.ax.plot(x1, y1, 'yo', markersize=8)
+                    self.ax.text(x1, y1+5, str(pair_idx), 
+                                color='white', ha='center', va='bottom')
+                if z2 == self.current_slice:
+                    self.ax.plot(x2, y2, 'yo', markersize=8)
+                    self.ax.text(x2, y2+5, str(pair_idx), 
+                                color='white', ha='center', va='bottom')
+                    
+                # Draw line if both points are on current slice
+                if z1 == z2 == self.current_slice:
+                    self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
         
-        self.canvas.draw()
+            if active_channels:
+                self.ax.set_xlim(-0.5, min_width - 0.5)
+                self.ax.set_ylim(min_height - 0.5, -0.5)
+
+            if self.resizing:
+                self.original_xlim = self.ax.get_xlim()
+                self.original_ylim = self.ax.get_ylim()
+            # Restore zoom limits if they existed
+            if current_xlim is not None and current_ylim is not None:
+                self.ax.set_xlim(current_xlim)
+                self.ax.set_ylim(current_ylim)
+            if reset_resize:
+                self.resizing = False
+            
+            self.canvas.draw()
+
+        except:
+            pass
 
     def update_display_slice(self, channel, preserve_zoom=None):
         """Ultra minimal update that only changes the paint channel's data"""
@@ -4631,14 +4652,14 @@ class BrightnessContrastDialog(QDialog):
             # Create range slider
             slider = QRangeSlider(Qt.Orientation.Horizontal)
             slider.setMinimum(0)
-            slider.setMaximum(255)
-            slider.setValue((0, 255))
+            slider.setMaximum(65535)
+            slider.setValue((0, 65535))
             self.brightness_sliders.append(slider)
             
             # Create max value input
             max_input = QLineEdit()
             max_input.setFixedWidth(50)
-            max_input.setText("255")
+            max_input.setText("65535")
             self.max_inputs.append(max_input)
             
             # Add all components to slider container
@@ -4687,8 +4708,8 @@ class BrightnessContrastDialog(QDialog):
             max_val = self.parse_input_value(self.max_inputs[channel].text())
             current_min, current_max = self.brightness_sliders[channel].value()
             
-            if max_val > 255:
-                max_val = 255
+            if max_val > 65535:
+                max_val = 65535
             # Ensure max doesn't go below min
             max_val = max(max_val, current_min + 1)
             
@@ -4708,8 +4729,8 @@ class BrightnessContrastDialog(QDialog):
             value = float(text)
             # Round to nearest integer
             value = int(round(value))
-            # Clamp between 0 and 255
-            return max(0, min(255, value))
+            # Clamp between 0 and 65535
+            return max(0, min(65535, value))
         except ValueError:
             raise ValueError("Invalid input")
 
@@ -4756,7 +4777,168 @@ class ColorDialog(QDialog):
         
         # Update the display
         self.parent().update_display()
-        self.accept()    
+        self.accept()
+
+class ArbitraryDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Arbitrary Selector")
+        self.setModal(True)
+        
+        # Main layout
+        main_layout = QVBoxLayout(self)
+        
+        # Form layout for inputs
+        layout = QFormLayout()
+        main_layout.addLayout(layout)
+        
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["nodes", "edges"])
+        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("Type to select:", self.mode_selector)
+        
+        # Selection section
+        excel_button = QPushButton("Import selection from spreadsheet (Col 1)")
+        excel_button.clicked.connect(self.import_excel)
+        layout.addWidget(excel_button)
+        
+        self.select = QLineEdit("")
+        layout.addRow("Select the following? (Use this format - '1,2,3,4' etc:", self.select)
+        
+        # Deselection section
+        deexcel_button = QPushButton("Import deselection from spreadsheet (Col 1)")
+        deexcel_button.clicked.connect(self.import_deexcel)
+        layout.addWidget(deexcel_button)
+        
+        self.deselect = QLineEdit("")
+        layout.addRow("Deselect the following? (Use this format - '1,2,3,4' etc:", self.deselect)
+        
+        # Run button
+        run_button = QPushButton("Run")
+        run_button.clicked.connect(self.process_selections)
+        main_layout.addWidget(run_button)
+
+    def import_excel(self):
+        """Import selection from Excel/CSV and populate the select QLineEdit."""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Select File", "", "Spreadsheet Files (*.xlsx *.xls *.csv)"
+        )
+        
+        if file_path:
+            try:
+                selection_list = self.read_selection_from_file(file_path)
+                selection_string = ",".join(map(str, selection_list))
+                self.select.setText(selection_string)
+            except Exception as e:
+                QMessageBox.critical(self, "Error", f"Failed to import: {str(e)}")
+    
+    def import_deexcel(self):
+        """Import deselection from Excel/CSV and populate the deselect QLineEdit."""
+        file_path, _ = QFileDialog.getOpenFileName(
+            self, "Select File", "", "Spreadsheet Files (*.xlsx *.xls *.csv)"
+        )
+        
+        if file_path:
+            try:
+                deselection_list = self.read_selection_from_file(file_path)
+                deselection_string = ",".join(map(str, deselection_list))
+                self.deselect.setText(deselection_string)
+            except Exception as e:
+                QMessageBox.critical(self, "Error", f"Failed to import: {str(e)}")
+    
+    def read_selection_from_file(self, file_path):
+        """Read selection IDs from Excel/CSV file and return as a list."""
+        # Determine file type and read accordingly
+        if file_path.lower().endswith('.csv'):
+            # Read CSV file
+            df = pd.read_csv(file_path, header=None)
+        else:
+            # Read Excel file
+            df = pd.read_excel(file_path, header=None)
+        
+        # Check if first row looks like a header
+        first_row = df.iloc[0]
+        if all(isinstance(x, str) for x in first_row):
+            # First row is likely a header, skip it
+            values = df.iloc[1:, 0].dropna().tolist()
+        else:
+            # No header, use all rows
+            values = df.iloc[:, 0].dropna().tolist()
+        
+        # Convert to integers when possible, keep floats when necessary
+        processed_values = []
+        for val in values:
+            try:
+                # Try to convert to int first
+                processed_values.append(int(val))
+            except ValueError:
+                try:
+                    # If int fails, try float
+                    processed_values.append(float(val))
+                except ValueError:
+                    # Skip values that can't be converted to numbers
+                    continue
+        
+        return processed_values
+    
+    def process_selections(self):
+        """Process the selection and deselection inputs."""
+        try:
+            from ast import literal_eval
+            # Get values from QLineEdit fields
+            select_text = self.select.text()
+            deselect_text = self.deselect.text()
+            
+            # Format text for literal_eval by adding brackets
+            if select_text:
+                select_list = literal_eval(f"[{select_text}]")
+            else:
+                select_list = []
+                
+            if deselect_text:
+                deselect_list = literal_eval(f"[{deselect_text}]")
+            else:
+                deselect_list = []
+            
+            # Get the current mode
+            mode = self.mode_selector.currentText()
+            
+            if mode == 'nodes':
+                num = self.parent().channel_data[0].shape[0] * self.parent().channel_data[0].shape[1] * self.parent().channel_data[0].shape[2]
+            else:
+                num = self.parent().channel_data[1].shape[0] * self.parent().channel_data[1].shape[1] * self.parent().channel_data[1].shape[2]
+            
+
+            for item in deselect_list:
+                try:
+                    self.parent().clicked_values[mode].remove(item)
+                except:
+                    pass #Forgive mistakes
+
+            for item in select_list:
+                try:
+                    self.parent().clicked_values[mode].append(item)
+                except:
+                    pass
+
+            self.parent().clicked_values[mode] = list(set(self.parent().clicked_values[mode]))
+
+            if num > self.parent().mini_thresh:
+                self.parent().mini_overlay = True
+                self.parent().create_mini_overlay(node_indices = self.parent().clicked_values['nodes'], edge_indices = self.parent().clicked_values['edges'])
+            else:
+                self.parent().create_highlight_overlay(
+                    node_indices=self.parent().clicked_values['nodes'], 
+                    edge_indices=self.parent().clicked_values['edges']
+                )
+
+
+            
+            # Close the dialog after processing
+            self.accept()
+            
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Error processing selections: {str(e)}")
 
 class Show3dDialog(QDialog):
     def __init__(self, parent=None):
@@ -4818,7 +5000,7 @@ class Show3dDialog(QDialog):
                         if visible:
                             arrays_4d.append(channel)
 
-            if self.parent().highlight_overlay is not None:
+            if self.parent().highlight_overlay is not None or self.parent().mini_overlay_data is not None:
                 if self.parent().mini_overlay == True:
                     self.parent().create_highlight_overlay(node_indices = self.parent().clicked_values['nodes'], edge_indices = self.parent().clicked_values['edges'])
                 arrays_3d.append(self.parent().highlight_overlay)
@@ -5048,19 +5230,24 @@ class ShuffleDialog(QDialog):
                 target_data = self.parent().channel_data[accepted_target]
 
 
-            if accepted_mode == 4:
-
-                self.parent().highlight_overlay = n3d.binarize(target_data)
-            else:
-                self.parent().load_channel(accepted_mode, channel_data = target_data, data = True)
+            try:
+                if accepted_mode == 4:
 
+                    self.parent().highlight_overlay = n3d.binarize(target_data)
+                else:
+                    self.parent().load_channel(accepted_mode, channel_data = target_data, data = True)
+            except:
+                pass
 
 
-            if accepted_target == 4:
-                try:
-                    self.parent().highlight_overlay = n3d.binarize(active_data)
-                except:
-                    self.parent().highlight_overlay = None
+            try:
+                if accepted_target == 4:
+                    try:
+                        self.parent().highlight_overlay = n3d.binarize(active_data)
+                    except:
+                        self.parent().highlight_overlay = None
+            except:
+                pass
 
             else:
                 self.parent().load_channel(accepted_target, channel_data = active_data, data = True)
@@ -5862,6 +6049,9 @@ class ResizeDialog(QDialog):
 
                 
                 # Process highlight overlay if it exists
+                if self.parent().mini_overlay_data is not None:
+                    self.parent().create_highlight_overlay(self.parent().clicked_values['nodes'],  self.parent().clicked_values['edges'])
+
                 if self.parent().highlight_overlay is not None:
                     self.parent().highlight_overlay = n3d.resize(self.parent().highlight_overlay, resize, order)
                 if my_network.search_region is not None:
@@ -5877,6 +6067,10 @@ class ResizeDialog(QDialog):
                         resized_data = n3d.upsample_with_padding(self.parent().channel_data[channel], original_shape = self.parent().original_shape)
                         self.parent().load_channel(channel, channel_data=resized_data, data=True, assign_shape = False)
 
+                if self.parent().mini_overlay_data is not None:
+
+                    self.parent().create_highlight_overlay(self.parent().clicked_values['nodes'],  self.parent().clicked_values['edges'])
+
                 
                 # Process highlight overlay if it exists
                 if self.parent().highlight_overlay is not None:
@@ -6105,6 +6299,9 @@ class ThresholdDialog(QDialog):
                 if self.parent().volume_dict[self.parent().active_channel] is None:
                     self.parent().volumes()
 
+            if self.parent().mini_overlay_data is not None:
+                self.parent().mini_overlay_data = None
+
             thresh_window = ThresholdWindow(self.parent(), accepted_mode)
             thresh_window.show()  # Non-modal window
             self.highlight_overlay = None
@@ -6128,6 +6325,8 @@ class ThresholdDialog(QDialog):
             )
             return
 
+        if self.parent().mini_overlay_data is not None:
+            self.parent().mini_overlay_data = None
 
         self.parent().machine_window = MachineWindow(self.parent())
         self.parent().machine_window.show()  # Non-modal window
@@ -6240,7 +6439,7 @@ class MachineWindow(QMainWindow):
         # Group 2: Processing Options (GPU)
         processing_group = QGroupBox("Processing Options")
         processing_layout = QHBoxLayout()
-        self.GPU = QPushButton("GPU")
+        self.GPU = QPushButton("GPU (Beta)")
         self.GPU.setCheckable(True)
         self.GPU.setChecked(False)
         self.GPU.clicked.connect(self.toggle_GPU)
@@ -6276,9 +6475,15 @@ class MachineWindow(QMainWindow):
         seg_button = QPushButton("Preview Segment")
         self.seg_button = seg_button
         seg_button.clicked.connect(self.start_segmentation)
+        self.lock_button = QPushButton("🔒 Memory lock - (Prioritize RAM. Recommended unless you have a lot)")
+        self.lock_button.setCheckable(True)
+        self.lock_button.setChecked(True)
+        self.lock_button.clicked.connect(self.toggle_lock)
+        self.mem_lock = True
         full_button = QPushButton("Segment All")
         full_button.clicked.connect(self.segment)
         segmentation_layout.addWidget(seg_button)
+        segmentation_layout.addWidget(self.lock_button)
         segmentation_layout.addWidget(full_button)
         segmentation_group.setLayout(segmentation_layout)
 
@@ -6298,6 +6503,9 @@ class MachineWindow(QMainWindow):
         self.segmenter = segmenter.InteractiveSegmenter(active_data, use_gpu=True)
         self.segmentation_worker = None
 
+    def toggle_lock(self):
+
+        self.mem_lock = self.lock_button.isChecked()
 
 
     def toggle_GPU(self):
@@ -6377,13 +6585,16 @@ class MachineWindow(QMainWindow):
         if not self.use_two:
             self.previewing = False
         try:
-            self.segmenter.train_batch(self.parent().channel_data[2], speed = speed, use_gpu = self.use_gpu, use_two = self.use_two)
-            self.trained = True
+            try:
+                self.segmenter.train_batch(self.parent().channel_data[2], speed = speed, use_gpu = self.use_gpu, use_two = self.use_two, mem_lock = self.mem_lock)
+                self.trained = True
+            except Exception as e:
+                print("Error training. Perhaps you forgot both foreground and background markers? I need both!")
         except MemoryError:
             QMessageBox.critical(
                 self,
                 "Alert",
-                "Out of memory computing feature maps. Note these for 3D require 7x the RAM of the active image (or 9x for the detailed map).\n Please use 2D slice models if you do not have enough RAM."
+                "Out of memory computing feature maps. Note these for 3D require 7x the RAM of the active image (or 9x for the detailed map).\n Please use 2D slice models or RAM lock if you do not have enough RAM."
             )
 
 
@@ -6410,7 +6621,7 @@ class MachineWindow(QMainWindow):
         if not self.trained:
             return
         else:
-            self.segmentation_worker = SegmentationWorker(self.parent().highlight_overlay, self.segmenter, self.use_gpu, self.use_two, self.previewing, self)
+            self.segmentation_worker = SegmentationWorker(self.parent().highlight_overlay, self.segmenter, self.use_gpu, self.use_two, self.previewing, self, self.mem_lock)
             self.segmentation_worker.chunk_processed.connect(self.update_display)  # Just update display
             self.segmentation_worker.finished.connect(self.segmentation_finished)
             current_xlim = self.parent().ax.get_xlim()
@@ -6647,7 +6858,7 @@ class SegmentationWorker(QThread):
     finished = pyqtSignal()
     chunk_processed = pyqtSignal()
     
-    def __init__(self, highlight_overlay, segmenter, use_gpu, use_two, previewing, machine_window):
+    def __init__(self, highlight_overlay, segmenter, use_gpu, use_two, previewing, machine_window, mem_lock):
         super().__init__()
         self.overlay = highlight_overlay
         self.segmenter = segmenter
@@ -6655,6 +6866,7 @@ class SegmentationWorker(QThread):
         self.use_two = use_two
         self.previewing = previewing
         self.machine_window = machine_window
+        self.mem_lock = mem_lock
         self._stop = False
         self.update_interval = 1  # Increased to 500ms
         self.chunks_since_update = 0
@@ -6774,6 +6986,7 @@ class ThresholdWindow(QMainWindow):
                 self.histo_list = self.parent().channel_data[self.parent().active_channel].flatten().tolist()
             self.bounds = True
             self.parent().bounds = True
+
             
         # Create matplotlib figure
         fig = Figure(figsize=(5, 4))
@@ -7589,9 +7802,9 @@ class InvertDialog(QDialog):
                 if active_data.dtype == 'uint8' or 'int8':
                     num = 255
                 elif active_data.dtype == 'uint16' or 'int16':
-                    num = 65,535
+                    num = 65535
                 elif active_data.dtype == 'uint32' or 'int32':
-                    num = 2,147,483,647
+                    num = 2147483647
 
                 result = (num - active_data
                     )