nettracer3d 0.7.2__py3-none-any.whl → 0.7.4__py3-none-any.whl

nettracer3d/nettracer.py

@@ -2913,6 +2913,7 @@ class Network_3D:
 
         if file_path is not None:
             self._node_centroids = network_analysis.read_centroids_to_dict(file_path)
+            self._node_centroids = self.clear_null(self._node_centroids)
             print("Succesfully loaded node centroids")
             return
 
@@ -2922,10 +2923,12 @@ class Network_3D:
             if item == 'node_centroids.xlsx' or item == 'node_centroids.csv':
                 if directory is not None:
                     self._node_centroids = network_analysis.read_centroids_to_dict(f'{directory}/{item}')
+                    self._node_centroids = self.clear_null(self._node_centroids)
                     print("Succesfully loaded node centroids")
                     return
                 else:
                     self._node_centroids = network_analysis.read_centroids_to_dict(item)
+                    self._node_centroids = self.clear_null(self._node_centroids)
                     print("Succesfully loaded node centroids")
                     return
 
@@ -2941,6 +2944,7 @@ class Network_3D:
 
         if file_path is not None:
             self._node_identities = network_analysis.read_excel_to_singval_dict(file_path)
+            self._node_identities = self.clear_null(self._node_identities)
             print("Succesfully loaded node identities")
             return
 
@@ -2950,10 +2954,12 @@ class Network_3D:
             if item == 'node_identities.xlsx' or item == 'node_identities.csv':
                 if directory is not None:
                     self._node_identities = network_analysis.read_excel_to_singval_dict(f'{directory}/{item}')
+                    self._node_identities = self.clear_null(self._node_identities)
                     print("Succesfully loaded node identities")
                     return
                 else:
                     self._node_identities = network_analysis.read_excel_to_singval_dict(item)
+                    self._node_identities = self.clear_null(self._node_identities)
                     print("Succesfully loaded node identities")
                     return
 
@@ -2968,7 +2974,8 @@ class Network_3D:
         """
 
         if file_path is not None:
-            self._node_identities = network_analysis.read_excel_to_singval_dict(file_path)
+            self._communities = network_analysis.read_excel_to_singval_dict(file_path)
+            self._communities = self.clear_null(self._communities)
             print("Succesfully loaded communities")
             return
 
@@ -2978,15 +2985,23 @@ class Network_3D:
             if item == 'node_communities.xlsx' or item == 'node_communities.csv':
                 if directory is not None:
                     self._communities = network_analysis.read_excel_to_singval_dict(f'{directory}/{item}')
+                    self._communities = self.clear_null(self._communities)
                     print("Succesfully loaded communities")
                     return
                 else:
                     self._communities = network_analysis.read_excel_to_singval_dict(item)
+                    self._communities = self.clear_null(self._communities)
                     print("Succesfully loaded communities")
                     return
 
         print("Could not find communities. They must be in the specified directory and named 'node_communities.xlsx'")
 
+    def clear_null(self, some_dict):
+
+        if some_dict == {}:
+            some_dict = None
+        return some_dict
+
     def load_edge_centroids(self, directory = None, file_path = None):
         """
         Can be called on a Network_3D object to load a .xlsx into the edge_centroids property as a dictionary. It will look for a file called 'edge_centroids.xlsx' in the specified directory,
@@ -2997,6 +3012,7 @@ class Network_3D:
 
         if file_path is not None:
             self._edge_centroids = network_analysis.read_centroids_to_dict(file_path)
+            self._edge_centroids = self.clear_null(self._edge_centroids)
             print("Succesfully loaded edge centroids")
             return
 
@@ -3006,10 +3022,12 @@ class Network_3D:
             if item == 'edge_centroids.xlsx' or item == 'edge_centroids.csv':
                 if directory is not None:
                     self._edge_centroids = network_analysis.read_centroids_to_dict(f'{directory}/{item}')
+                    self._edge_centroids = self.clear_null(self._edge_centroids)
                     print("Succesfully loaded edge centroids")
                     return
                 else:
                     self._edge_centroids = network_analysis.read_centroids_to_dict(item)
+                    self._edge_centroids = self.clear_null(self._edge_centroids)
                     print("Succesfully loaded edge centroids")
                     return
 
@@ -3427,10 +3445,11 @@ class Network_3D:
             self.calculate_search_region(search, GPU = GPU, fast_dil = fast_dil, GPU_downsample = GPU_downsample)
             #self._nodes = None # I originally put this here to micromanage RAM a little bit (it writes it to disk so I wanted to purge it from mem briefly but now idt thats necessary and I'd rather give it flexibility when lacking write permissions)
             search = None
-            try:
-                self.save_search_region(directory)
-            except:
-                pass
+            if directory is not None:
+                try:
+                    self.save_search_region(directory)
+                except:
+                    pass
 
         self.calculate_edges(edges, diledge = diledge, inners = inners, hash_inner_edges = hash_inners, search = search, remove_edgetrunk = remove_trunk, GPU = GPU, fast_dil = fast_dil, skeletonized = skeletonize)
         del edges

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 <--- couldn't get this faster than CPU ¯\_(ツ)_/¯
+from nettracer3d import segmenter_GPU
 
 
 
@@ -2870,67 +2870,72 @@ class ImageViewerWindow(QMainWindow):
                     return val
             return val
         
-        if isinstance(data, (list, tuple, np.ndarray)):
-            # Handle list input - create single column DataFrame
-            df = pd.DataFrame({
-                metric: [convert_to_numeric(val) for val in data]
-            })
-            
-            # Format floating point numbers
-            df[metric] = df[metric].apply(lambda x: f"{x:.3f}" if isinstance(x, (float, np.float64)) else str(x))
-            
-        else:  # Dictionary input
-            # Get sample value to determine structure
-            sample_value = next(iter(data.values()))
-            is_multi_value = isinstance(sample_value, (list, tuple, np.ndarray))
-            
-            if is_multi_value:
-                # Handle multi-value case
-                if isinstance(value, str):
-                    # If single string provided for multi-values, generate numbered headers
-                    n_cols = len(sample_value)
-                    value_headers = [f"{value}_{i+1}" for i in range(n_cols)]
-                else:
-                    # Use provided list of headers
-                    value_headers = value
-                    if len(value_headers) != len(sample_value):
-                        raise ValueError("Number of headers must match number of values per key")
-                
-                # Create lists for each column
-                dict_data = {metric: list(data.keys())}
-                for i, header in enumerate(value_headers):
-                    # Convert values to numeric when possible before adding to DataFrame
-                    dict_data[header] = [convert_to_numeric(data[key][i]) for key in data.keys()]
-                
-                df = pd.DataFrame(dict_data)
-                
-                # Format floating point numbers in all value columns
-                for header in value_headers:
-                    df[header] = df[header].apply(lambda x: f"{x:.3f}" if isinstance(x, (float, np.float64)) else str(x))
-                    
-            else:
-                # Single-value case
+        try:
+
+            if isinstance(data, (list, tuple, np.ndarray)):
+                # Handle list input - create single column DataFrame
                 df = pd.DataFrame({
-                    metric: data.keys(),
-                    value: [convert_to_numeric(val) for val in data.values()]
+                    metric: [convert_to_numeric(val) for val in data]
                 })
                 
                 # Format floating point numbers
-                df[value] = df[value].apply(lambda x: f"{x:.3f}" if isinstance(x, (float, np.float64)) else str(x))
-        
-        # Create new table
-        table = CustomTableView(self)
-        table.setModel(PandasModel(df))
-        
-        # Add to tabbed widget
-        if title is None:
-            self.tabbed_data.add_table(f"{metric} Analysis", table)
-        else:
-            self.tabbed_data.add_table(f"{title}", table)
-        
-        # Adjust column widths to content
-        for column in range(table.model().columnCount(None)):
-            table.resizeColumnToContents(column)
+                df[metric] = df[metric].apply(lambda x: f"{x:.3f}" if isinstance(x, (float, np.float64)) else str(x))
+                
+            else:  # Dictionary input
+                # Get sample value to determine structure
+                sample_value = next(iter(data.values()))
+                is_multi_value = isinstance(sample_value, (list, tuple, np.ndarray))
+                
+                if is_multi_value:
+                    # Handle multi-value case
+                    if isinstance(value, str):
+                        # If single string provided for multi-values, generate numbered headers
+                        n_cols = len(sample_value)
+                        value_headers = [f"{value}_{i+1}" for i in range(n_cols)]
+                    else:
+                        # Use provided list of headers
+                        value_headers = value
+                        if len(value_headers) != len(sample_value):
+                            raise ValueError("Number of headers must match number of values per key")
+                    
+                    # Create lists for each column
+                    dict_data = {metric: list(data.keys())}
+                    for i, header in enumerate(value_headers):
+                        # Convert values to numeric when possible before adding to DataFrame
+                        dict_data[header] = [convert_to_numeric(data[key][i]) for key in data.keys()]
+                    
+                    df = pd.DataFrame(dict_data)
+                    
+                    # Format floating point numbers in all value columns
+                    for header in value_headers:
+                        df[header] = df[header].apply(lambda x: f"{x:.3f}" if isinstance(x, (float, np.float64)) else str(x))
+                        
+                else:
+                    # Single-value case
+                    df = pd.DataFrame({
+                        metric: data.keys(),
+                        value: [convert_to_numeric(val) for val in data.values()]
+                    })
+                    
+                    # Format floating point numbers
+                    df[value] = df[value].apply(lambda x: f"{x:.3f}" if isinstance(x, (float, np.float64)) else str(x))
+            
+            # Create new table
+            table = CustomTableView(self)
+            table.setModel(PandasModel(df))
+            
+            # Add to tabbed widget
+            if title is None:
+                self.tabbed_data.add_table(f"{metric} Analysis", table)
+            else:
+                self.tabbed_data.add_table(f"{title}", table)
+            
+            # Adjust column widths to content
+            for column in range(table.model().columnCount(None)):
+                table.resizeColumnToContents(column)
+
+        except:
+            pass
 
 
     def show_watershed_dialog(self):
@@ -7412,7 +7417,11 @@ class MachineWindow(QMainWindow):
         self.three.setCheckable(True)
         self.three.setChecked(True)
         self.three.clicked.connect(self.toggle_three)
-        #processing_layout.addWidget(self.GPU)   [Decided to hold off on this until its more robust]
+        self.GPU = QPushButton("GPU")
+        self.GPU.setCheckable(True)
+        self.GPU.setChecked(False)
+        self.GPU.clicked.connect(self.toggle_GPU)
+        processing_layout.addWidget(self.GPU)
         processing_layout.addWidget(self.two)
         processing_layout.addWidget(self.three)
         processing_group.setLayout(processing_layout)
@@ -7550,6 +7559,35 @@ class MachineWindow(QMainWindow):
             self.two.setChecked(True)
             self.use_two = True
 
+    def toggle_GPU(self):
+
+        if self.parent().active_channel == 0:
+            if self.parent().channel_data[0] is not None:
+                try:
+                    active_data = self.parent().channel_data[0]
+                    act_channel = 0
+                except:
+                    active_data = self.parent().channel_data[1]
+                    act_channel = 1
+            else:
+                active_data = self.parent().channel_data[1]
+                act_channel = 1
+
+        if self.GPU.isChecked():
+
+            try:
+                self.segmenter = segmenter_GPU.InteractiveSegmenter(active_data)
+                print("Using GPU")
+            except:
+                self.GPU.setChecked(False)
+                print("Could not detect GPU")
+                import traceback
+                traceback.print_exc()
+
+        else:
+            self.segmenter = segmenter.InteractiveSegmenter(active_data, use_gpu=False)
+            print("Using CPU")
+
 
 
     def toggle_foreground(self):
@@ -7836,18 +7874,12 @@ class MachineWindow(QMainWindow):
             self.parent().highlight_overlay = array3 #Clear this out for the segmenter to use
 
             print("Segmenting entire volume with model...")
-            foreground_coords, background_coords = self.segmenter.segment_volume(gpu = self.use_gpu)
+            #foreground_coords, background_coords = self.segmenter.segment_volume(array = self.parent().highlight_overlay)
+            self.parent().highlight_overlay = self.segmenter.segment_volume(array = self.parent().highlight_overlay)
 
             # Clean up when done
             self.segmenter.cleanup()
 
-        fg_array = np.array(list(foreground_coords))
-        if len(fg_array) > 0:  # Check if we have any foreground coordinates
-            # Unpack into separate coordinate arrays
-            z_coords, y_coords, x_coords = fg_array[:, 0], fg_array[:, 1], fg_array[:, 2]
-            # Assign values in a single vectorized operation
-            self.parent().highlight_overlay[z_coords, y_coords, x_coords] = 255
-
         self.parent().load_channel(3, self.parent().highlight_overlay, True)
 
         # Not exactly sure why we need all this but the channel buttons weren't loading like they normally do when load_channel() is called: