nettracer3d 0.6.0__py3-none-any.whl → 0.6.2__py3-none-any.whl

nettracer3d/nettracer.py

@@ -27,7 +27,6 @@ from skimage import morphology as mpg
 from . import smart_dilate
 from . import modularity
 from . import simple_network
-from . import hub_getter
 from . import community_extractor
 from . import network_analysis
 from . import morphology
@@ -3934,28 +3933,6 @@ class Network_3D:
 
         return degrees, nodes
 
-    def get_hubs(self, proportion = None, down_factor = 1, directory = None):
-        """
-        Method to isolate hub regions of a network (Removing all nodes below some proportion of highest degrees), also generating overlays that relate this information to the 3D structure.
-        Overlays include a grayscale image where nodes are assigned a grayscale value corresponding to their degree, and a numerical index where numbers are drawn at nodes corresponding to their degree.
-        These will be saved to the active directory if none is specified. Note calculations will be done with node_centroids unless a down_factor is passed. Note that a down_factor must be passed if there are no node_centroids.
-        :param proportion: (Optional - Val = None; Float). A float of 0 to 1 that details what proportion of highest node degrees to include in the output. Note that this value will be set to 0.1 by default.
-        :param down_factor: (Optional - Val = 1; int). A factor to downsample nodes by while calculating centroids, assuming no node_centroids property was set.
-        :param directory: (Optional - Val = None; string). A path to a directory to save outputs.
-        :returns: A dictionary of degree values for each node above the desired proportion of highest degree nodes.
-        """
-        if down_factor > 1:
-            centroids = self._node_centroids.copy()
-            for item in self._node_centroids:
-                centroids[item] = np.round((self._node_centroids[item]) / down_factor)
-            nodes = downsample(self._nodes, down_factor)
-            hubs = hub_getter.get_hubs(nodes, self._network, proportion, directory = directory, centroids = centroids)
-
-        else:
-            hubs = hub_getter.get_hubs(self._nodes, self._network, proportion, directory = directory, centroids = self._node_centroids)
-
-        return hubs 
-
 
     def isolate_connected_component(self, key = None, directory = None, full_edges = None, gen_images = True):
         """

nettracer3d/nettracer_gui.py

@@ -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))
 
 
@@ -4636,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
@@ -4692,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)
             
@@ -4713,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")
 
@@ -4761,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):
@@ -6262,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)
@@ -6298,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)
 
@@ -6320,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):
@@ -6399,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."
             )
 
 
@@ -6432,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()
@@ -6669,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
@@ -6677,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
@@ -7612,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
                     )