nettracer3d 1.0.8__py3-none-any.whl → 1.0.9__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -461,8 +461,6 @@ class ImageViewerWindow(QMainWindow):
         self.last_paint_pos = None
 
         self.resume = False
-
-        self.hold_update = False
         self._first_pan_done = False
 
 
@@ -878,23 +876,20 @@ class ImageViewerWindow(QMainWindow):
         elif self.scroll_direction > 0 and new_value <= self.slice_slider.maximum():
             self.slice_slider.setValue(new_value)
 
-    def evaluate_mini(self, mode = 'nodes'):
-        if mode == 'nodes':
-            if self.channel_data[0].shape[0] * self.channel_data[0].shape[1] * self.channel_data[0].shape[2] > self.mini_thresh:
-                self.mini_overlay = True
-                self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-            else:
-                self.create_highlight_overlay(node_indices=self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-        elif mode == 'edges':
 
-            if self.channel_data[1].shape[0] * self.channel_data[1].shape[1] * self.channel_data[1].shape[2] > self.mini_thresh:
-                self.mini_overlay = True
-                self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-            else:
-                self.create_highlight_overlay(
-                    node_indices=self.clicked_values['nodes'], 
-                    edge_indices=self.clicked_values['edges']
-                )
+    def confirm_mini_thresh(self):
+
+        if self.shape[0] * self.shape[1] * self.shape[2] > self.mini_thresh:
+            self.mini_overlay = True
+            return True
+        else:
+            return False
+
+    def evaluate_mini(self, mode = 'nodes'):
+        if self.confirm_mini_thresh():
+            self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
+        else:
+            self.create_highlight_overlay(node_indices=self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
 
     def create_highlight_overlay(self, node_indices=None, edge_indices=None, overlay1_indices = None, overlay2_indices = None, bounds = False):
         """
@@ -1021,13 +1016,13 @@ class ImageViewerWindow(QMainWindow):
             
         # Combine results
         if node_overlay is not None:
-            self.highlight_overlay = np.maximum(self.highlight_overlay, node_overlay)
+            self.highlight_overlay = np.maximum(self.highlight_overlay, node_overlay).astype(np.uint8)
         if edge_overlay is not None:
-            self.highlight_overlay = np.maximum(self.highlight_overlay, edge_overlay)
+            self.highlight_overlay = np.maximum(self.highlight_overlay, edge_overlay).astype(np.uint8)
         if overlay1_overlay is not None:
-            self.highlight_overlay = np.maximum(self.highlight_overlay, overlay1_overlay)
+            self.highlight_overlay = np.maximum(self.highlight_overlay, overlay1_overlay).astype(np.uint8)
         if overlay2_overlay is not None:
-            self.highlight_overlay = np.maximum(self.highlight_overlay, overlay2_overlay)
+            self.highlight_overlay = np.maximum(self.highlight_overlay, overlay2_overlay).astype(np.uint8)
         
         # Update display
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -1036,6 +1031,9 @@ class ImageViewerWindow(QMainWindow):
 
         """Highlight overlay generation method specific for the segmenter interactive mode"""
 
+        self.mini_overlay_data = None
+        self.highlight_overlay = None
+
         def process_chunk_bounds(chunk_data, indices_to_check):
             """Process a single chunk of the array to create highlight mask"""
             mask = (chunk_data >= indices_to_check[0]) & (chunk_data <= indices_to_check[1])
@@ -1308,6 +1306,9 @@ class ImageViewerWindow(QMainWindow):
                 select_nodes = select_all_menu.addAction("Nodes")
                 select_both = select_all_menu.addAction("Nodes + Edges")
                 select_edges = select_all_menu.addAction("Edges")
+                select_net_nodes = select_all_menu.addAction("Nodes in Network")
+                select_net_both = select_all_menu.addAction("Nodes + Edges in Network")
+                select_net_edges = select_all_menu.addAction("Edges in Network")
                 context_menu.addMenu(select_all_menu)
 
                 if len(self.clicked_values['nodes']) > 0 or len(self.clicked_values['edges']) > 0:
@@ -1382,6 +1383,9 @@ 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))
+                select_net_nodes.triggered.connect(lambda: self.handle_select_all(edges = False, nodes = True, network = True))
+                select_net_both.triggered.connect(lambda: self.handle_select_all(edges = True, network = True))
+                select_net_edges.triggered.connect(lambda: self.handle_select_all(edges = True, nodes = False, network = True))
                 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)
@@ -2066,12 +2070,15 @@ class ImageViewerWindow(QMainWindow):
 
 
 
-    def handle_select_all(self, nodes = True, edges = False):
+    def handle_select_all(self, nodes = True, edges = False, network = False):
 
         try:
 
             if nodes:
-                nodes = list(np.unique(my_network.nodes))
+                if not network:
+                    nodes = list(np.unique(my_network.nodes))
+                else:
+                    nodes = list(set(my_network.network_lists[0] + my_network.network_lists[1]))
                 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])
@@ -2079,7 +2086,10 @@ class ImageViewerWindow(QMainWindow):
             else:
                 nodes = []
             if edges:
-                edges = list(np.unique(my_network.edges))
+                if not network:
+                    edges = list(np.unique(my_network.edges))
+                else:
+                    edges = my_network.network_lists[2]
                 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]
@@ -2202,7 +2212,7 @@ class ImageViewerWindow(QMainWindow):
                     except:
                         pass
 
-            self.format_for_upperright_table(info_dict, title = f'Info on Object')
+            self.format_for_upperright_table(info_dict, title = f'Info on Object', sort = False)
 
         except:
             pass
@@ -3695,17 +3705,23 @@ class ImageViewerWindow(QMainWindow):
         
         # Add highlight overlays if they exist (with downsampling)
         if self.mini_overlay and self.highlight and self.machine_window is None:
-            display_overlay = crop_and_downsample_image(self.mini_overlay_data, y_min_padded, y_max_padded, x_min_padded, x_max_padded, downsample_factor)
-            highlight_rgba = self.create_highlight_rgba(display_overlay, yellow=True)
-            composite = self.blend_layers(composite, highlight_rgba)
+            try:
+                display_overlay = crop_and_downsample_image(self.mini_overlay_data, y_min_padded, y_max_padded, x_min_padded, x_max_padded, downsample_factor)
+                highlight_rgba = self.create_highlight_rgba(display_overlay, yellow=True)
+                composite = self.blend_layers(composite, highlight_rgba)
+            except:
+                pass
         elif self.highlight_overlay is not None and self.highlight:
-            highlight_slice = self.highlight_overlay[self.current_slice]
-            display_highlight = crop_and_downsample_image(highlight_slice, y_min_padded, y_max_padded, x_min_padded, x_max_padded, downsample_factor)
-            if self.machine_window is None:
-                highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=True)
-            else:
-                highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=False)
-            composite = self.blend_layers(composite, highlight_rgba)
+            try:
+                highlight_slice = self.highlight_overlay[self.current_slice]
+                display_highlight = crop_and_downsample_image(highlight_slice, y_min_padded, y_max_padded, x_min_padded, x_max_padded, downsample_factor)
+                if self.machine_window is None:
+                    highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=True)
+                else:
+                    highlight_rgba = self.create_highlight_rgba(display_highlight, yellow=False)
+                composite = self.blend_layers(composite, highlight_rgba)
+            except:
+                pass
         
         # Convert to 0-255 range for display
         return (composite * 255).astype(np.uint8)
@@ -4517,6 +4533,8 @@ class ImageViewerWindow(QMainWindow):
         for i in range(4):
             load_action = load_menu.addAction(f"Load {self.channel_names[i]}")
             load_action.triggered.connect(lambda checked, ch=i: self.load_channel(ch))
+        load_action = load_menu.addAction("Load Full-Sized Highlight Overlay")
+        load_action.triggered.connect(lambda: self.load_channel(channel_index = 4, load_highlight = True))
         load_action = load_menu.addAction("Load Network")
         load_action.triggered.connect(self.load_network)
         load_action = load_menu.addAction("Load From Excel Helper")
@@ -4770,7 +4788,10 @@ class ImageViewerWindow(QMainWindow):
                 # Invalid input - reset to default
                 self.downsample_factor = 1
 
-        self.throttle = self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor
+        try:
+            self.throttle = self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor
+        except:
+            self.throttle = False
         
         # Optional: Trigger display update if you want immediate effect
         if update:
@@ -4938,7 +4959,7 @@ class ImageViewerWindow(QMainWindow):
 
         
 
-    def format_for_upperright_table(self, data, metric='Metric', value='Value', title=None):
+    def format_for_upperright_table(self, data, metric='Metric', value='Value', title=None, sort = True):
        """
        Format dictionary or list data for display in upper right table.
        
@@ -5024,11 +5045,12 @@ class ImageViewerWindow(QMainWindow):
            table = CustomTableView(self)
            table.setModel(PandasModel(df))
 
-           try:
-               first_column_name = table.model()._data.columns[0]
-               table.sort_table(first_column_name, ascending=True)
-           except:
-                pass
+           if sort:
+               try:
+                   first_column_name = table.model()._data.columns[0]
+                   table.sort_table(first_column_name, ascending=True)
+               except:
+                    pass
            
            # Add to tabbed widget
            if title is None:
@@ -5620,6 +5642,7 @@ class ImageViewerWindow(QMainWindow):
             self.last_saved = os.path.dirname(directory)
             self.last_save_name = directory            
 
+            self.channel_data = [None] * 5
             if directory != "":
 
                 self.reset(network = True, xy_scale = 1, z_scale = 1, nodes = True, edges = True, network_overlay = True, id_overlay = True, update = False)
@@ -5700,6 +5723,8 @@ class ImageViewerWindow(QMainWindow):
                 f"Failed to load Network 3D Object: {str(e)}"
             )
 
+
+
     def load_network(self):
         """Load in the network from a .xlsx (need to add .csv support)"""
 
@@ -5940,12 +5965,41 @@ class ImageViewerWindow(QMainWindow):
         msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         return msg.exec() == QMessageBox.StandardButton.Yes
 
-    def load_channel(self, channel_index, channel_data=None, data=False, assign_shape = True, preserve_zoom = None, end_paint = False, begin_paint = False, color = False):
+    def get_scaling_metadata_only(self, filename):
+        # This only reads headers/metadata, not image data
+        with tifffile.TiffFile(filename) as tif:
+            x_scale = y_scale = z_scale = unit = None
+            
+            # ImageJ metadata (very lightweight)
+            if hasattr(tif, 'imagej_metadata') and tif.imagej_metadata:
+                metadata = tif.imagej_metadata
+                z_scale = metadata.get('spacing')
+                unit = metadata.get('unit')
+            
+            # TIFF tags (also lightweight - just header info)
+            page = tif.pages[0]  # This doesn't load image data
+            tags = page.tags
+            
+            if 'XResolution' in tags:
+                x_res = tags['XResolution'].value
+                x_scale = x_res[1] / x_res[0] if isinstance(x_res, tuple) else 1.0 / x_res
+                
+            if 'YResolution' in tags:
+                y_res = tags['YResolution'].value
+                y_scale = y_res[1] / y_res[0] if isinstance(y_res, tuple) else 1.0 / y_res
+        
+        if x_scale is None:
+            x_scale = 1
+        if z_scale is None:
+            z_scale = 1
+
+        return x_scale, z_scale
+
+    def load_channel(self, channel_index, channel_data=None, data=False, assign_shape = True, preserve_zoom = None, end_paint = False, begin_paint = False, color = False, load_highlight = False):
         """Load a channel and enable active channel selection if needed."""
 
         try:
 
-            self.hold_update = True
             if not data:  # For solo loading
                 filename, _ = QFileDialog.getOpenFileName(
                     self,
@@ -5965,6 +6019,13 @@ class ImageViewerWindow(QMainWindow):
                 try:
                     if file_extension in ['tif', 'tiff']:
                         import tifffile
+                        self.channel_data[channel_index] = None
+                        if (self.channel_data[0] is None and self.channel_data[1] is None) and (channel_index == 0 or channel_index == 1):
+                            try:
+                                my_network.xy_scale, my_network.z_scale = self.get_scaling_metadata_only(filename)
+                                print(f"xy_scale property set to {my_network.xy_scale}; z_scale property set to {my_network.z_scale}")
+                            except:
+                                pass
                         self.channel_data[channel_index] = tifffile.imread(filename)
 
                     elif file_extension == 'nii':
@@ -6070,51 +6131,52 @@ class ImageViewerWindow(QMainWindow):
                     my_network.id_overlay = self.channel_data[channel_index]
             
             # Enable the channel button
-            self.channel_buttons[channel_index].setEnabled(True)
-            self.delete_buttons[channel_index].setEnabled(True) 
+            if channel_index != 4:
+                self.channel_buttons[channel_index].setEnabled(True)
+                self.delete_buttons[channel_index].setEnabled(True) 
 
             
-            # Enable active channel selector if this is the first channel loaded
-            if not self.active_channel_combo.isEnabled():
-                self.active_channel_combo.setEnabled(True)
+                # Enable active channel selector if this is the first channel loaded
+                if not self.active_channel_combo.isEnabled():
+                    self.active_channel_combo.setEnabled(True)
             
-            # Update slider range if this is the first channel loaded
-            try:
-                if len(self.channel_data[channel_index].shape) == 3 or len(self.channel_data[channel_index].shape) == 4:
-                    if not self.slice_slider.isEnabled():
-                        self.slice_slider.setEnabled(True)
-                        self.slice_slider.setMinimum(0)
-                        self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
-                        if self.slice_slider.value() < self.channel_data[channel_index].shape[0] - 1:
-                            self.current_slice = self.slice_slider.value()
+                # Update slider range if this is the first channel loaded
+                try:
+                    if len(self.channel_data[channel_index].shape) == 3 or len(self.channel_data[channel_index].shape) == 4:
+                        if not self.slice_slider.isEnabled():
+                            self.slice_slider.setEnabled(True)
+                            self.slice_slider.setMinimum(0)
+                            self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
+                            if self.slice_slider.value() < self.channel_data[channel_index].shape[0] - 1:
+                                self.current_slice = self.slice_slider.value()
+                            else:
+                                self.slice_slider.setValue(0)
+                                self.current_slice = 0
                         else:
-                            self.slice_slider.setValue(0)
-                            self.current_slice = 0
+                            self.slice_slider.setEnabled(True)
+                            self.slice_slider.setMinimum(0)
+                            self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
+                            if self.slice_slider.value() < self.channel_data[channel_index].shape[0] - 1:
+                                self.current_slice = self.slice_slider.value()
+                            else:
+                                self.current_slice = 0
+                                self.slice_slider.setValue(0)
                     else:
-                        self.slice_slider.setEnabled(True)
-                        self.slice_slider.setMinimum(0)
-                        self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
-                        if self.slice_slider.value() < self.channel_data[channel_index].shape[0] - 1:
-                            self.current_slice = self.slice_slider.value()
-                        else:
-                            self.current_slice = 0
-                            self.slice_slider.setValue(0)
-                else:
-                    self.slice_slider.setEnabled(False)
-            except:
-                pass
+                        self.slice_slider.setEnabled(False)
+                except:
+                    pass
 
-            
-            # If this is the first channel loaded, make it active
-            if all(not btn.isEnabled() for btn in self.channel_buttons[:channel_index]):
-                self.set_active_channel(channel_index)
+                
+                # If this is the first channel loaded, make it active
+                if all(not btn.isEnabled() for btn in self.channel_buttons[:channel_index]):
+                    self.set_active_channel(channel_index)
 
-            if not self.channel_buttons[channel_index].isChecked():
-                self.channel_buttons[channel_index].click()
+                if not self.channel_buttons[channel_index].isChecked():
+                    self.channel_buttons[channel_index].click()
 
-            self.min_max[channel_index][0] = np.min(self.channel_data[channel_index])
-            self.min_max[channel_index][1] = np.max(self.channel_data[channel_index])
-            self.volume_dict[channel_index] = None #reset volumes
+                self.min_max[channel_index][0] = np.min(self.channel_data[channel_index])
+                self.min_max[channel_index][1] = np.max(self.channel_data[channel_index])
+                self.volume_dict[channel_index] = None #reset volumes
 
             try:
                 if assign_shape: #keep original shape tracked to undo resampling.
@@ -6138,7 +6200,6 @@ class ImageViewerWindow(QMainWindow):
 
             self.img_height, self.img_width = self.shape[1], self.shape[2]
             self.original_ylim, self.original_xlim = (self.shape[1] + 0.5, -0.5), (-0.5, self.shape[2] - 0.5)
-            #print(self.original_xlim)
 
             self.completed_paint_strokes = [] #Reset pending paint operations
             self.current_stroke_points = []
@@ -6148,6 +6209,12 @@ class ImageViewerWindow(QMainWindow):
             self.current_operation = []
             self.current_operation_type = None
 
+            if load_highlight:
+                self.highlight_overlay = n3d.binarize(self.channel_data[4].astype(np.uint8))
+                self.mini_overlay_data = None
+                self.mini_overlay = False
+                self.channel_data[4] = None
+
             if self.pan_mode:
                 self.pan_button.click()
                 if self.show_channels:
@@ -6156,7 +6223,6 @@ class ImageViewerWindow(QMainWindow):
             elif not end_paint:
 
                 self.update_display(reset_resize = reset_resize, preserve_zoom = preserve_zoom)
-
                 
         except Exception as e:
 
@@ -6165,7 +6231,7 @@ class ImageViewerWindow(QMainWindow):
                 QMessageBox.critical(
                     self,
                     "Error Loading File",
-                    f"Failed to load tiff file: {str(e)}"
+                    f"Failed to load file: {str(e)}"
                 )
 
     def delete_channel(self, channel_index, called = True, update = True):
@@ -6394,15 +6460,13 @@ class ImageViewerWindow(QMainWindow):
                 self.pm.convert_virtual_strokes_to_data()
             self.current_slice = slice_value
             if self.preview:
+                 self.highlight_overlay = None
+                 self.mini_overlay_data = None
+                 self.mini_overlay = False
                  self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
             elif self.mini_overlay == True: #If we are rendering the highlight overlay for selected values one at a time.
                 self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
-            if not self.hold_update:
-                self.update_display(preserve_zoom=view_settings)
-            else:
-                self.hold_update = False
-            #if self.machine_window is not None:
-                #self.machine_window.poke_segmenter()
+            self.update_display(preserve_zoom=view_settings)
             if self.pan_mode:
                 self.pan_button.click()
             self.pending_slice = None
@@ -6419,7 +6483,6 @@ class ImageViewerWindow(QMainWindow):
         self.channel_brightness[channel_index]['max'] = max_val / 65535
         self.update_display(preserve_zoom = (current_xlim, current_ylim))
 
-
     def update_display(self, preserve_zoom=None, dims=None, called=False, reset_resize=False, skip=False):
         """Optimized display update with view-based cropping for performance."""
         try:
@@ -6645,7 +6708,7 @@ class ImageViewerWindow(QMainWindow):
             # Handle preview, overlays, and measurements (apply cropping here too)
 
             # Overlay handling (optimized with cropping and downsampling)
-            if self.mini_overlay and self.highlight and self.machine_window is None:
+            if self.mini_overlay and self.highlight and self.machine_window is None and not self.preview:
                 highlight_cmap = LinearSegmentedColormap.from_list('highlight', [(0, 0, 0, 0), (1, 1, 0, 1)])
                 display_overlay = crop_and_downsample_image(
                     self.mini_overlay_data, y_min_padded, y_max_padded, 
@@ -6774,8 +6837,6 @@ class ImageViewerWindow(QMainWindow):
             #print(traceback.format_exc())
 
 
-
-
     def get_channel_image(self, channel):
         """Find the matplotlib image object for a specific channel."""
         if not hasattr(self.ax, 'images'):
@@ -10028,6 +10089,22 @@ class InteractionDialog(QDialog):
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
+        self.length = QPushButton("Return Lengths")
+        self.length.setCheckable(True)
+        self.length.setChecked(False)
+        layout.addRow("(Will Skeletonize the Edge Mirror and use that to calculate adjacent length of edges, as opposed to default volumes):", self.length)
+
+        self.auto = QPushButton("Auto")
+        self.auto.setCheckable(True)
+        try:
+            if self.parent().shape[0] == 1:
+                self.auto.setChecked(False)
+            else:
+                self.auto.setChecked(True)
+        except:
+            self.auto.setChecked(False)
+        layout.addRow("(If Above): Attempt to Auto Correct Skeleton Looping:", self.auto)
+
         self.fastdil = QPushButton("Fast Dilate")
         self.fastdil.setCheckable(True)
         self.fastdil.setChecked(False)
@@ -10051,10 +10128,16 @@ class InteractionDialog(QDialog):
                 
 
             fastdil = self.fastdil.isChecked()
+            length = self.length.isChecked()
+            auto = self.auto.isChecked()
 
-            result = my_network.interactions(search = node_search, cores = accepted_mode, fastdil = fastdil)
+            result = my_network.interactions(search = node_search, cores = accepted_mode, skele = length, length = length, auto = auto, fastdil = fastdil)
+
+            if not length:
+                self.parent().format_for_upperright_table(result, 'Node ID', ['Volume of Nearby Edge (Scaled)', 'Volume of Search Region (Scaled)'], title = 'Node/Edge Interactions')
+            else:
+                self.parent().format_for_upperright_table(result, 'Node ID', ['~Length of Nearby Edge (Scaled)', 'Volume of Search Region (Scaled)'], title = 'Node/Edge Interactions')
 
-            self.parent().format_for_upperright_table(result, 'Node ID', ['Volume of Nearby Edge (Scaled)', 'Volume of Search Region'], title = 'Node/Edge Interactions')
 
             self.accept()
 
@@ -11306,12 +11389,11 @@ class ThresholdDialog(QDialog):
                     print("Error - please calculate network first")
                     return
 
-            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
+            #self.mini_overlay = False
+            self.mini_overlay_data = None
             self.accept()
         except:
             import traceback
@@ -12285,16 +12367,23 @@ class ThresholdWindow(QMainWindow):
             self.parent().bounds = False
 
         elif accepted_mode == 0:
-            targ_shape = self.parent().channel_data[self.parent().active_channel].shape
-            if (targ_shape[0] + targ_shape[1] + targ_shape[2]) > 2500: #Take a simpler histogram on big arrays
-                temp_max = np.max(self.parent().channel_data[self.parent().active_channel])
-                temp_min = np.min(self.parent().channel_data[self.parent().active_channel])
-                temp_array = n3d.downsample(self.parent().channel_data[self.parent().active_channel], 5)
-                self.histo_list = temp_array.flatten().tolist()
-                self.histo_list.append(temp_min)
-                self.histo_list.append(temp_max)
-            else: #Otherwise just use full array data
-                self.histo_list = self.parent().channel_data[self.parent().active_channel].flatten().tolist()
+            data = self.parent().channel_data[self.parent().active_channel]
+            nonzero_data = data[data != 0]
+
+            if nonzero_data.size > 578009537:
+                # For large arrays, use numpy histogram directly
+                counts, bin_edges = np.histogram(nonzero_data, bins= min(int(np.sqrt(nonzero_data.size)), 500), density=False)
+                # Store min/max separately if needed elsewhere
+                self.data_min = np.min(nonzero_data)
+                self.data_max = np.max(nonzero_data)
+                self.histo_list = [self.data_min, self.data_max]
+            else:
+                # For smaller arrays, can still use histogram method for consistency
+                counts, bin_edges = np.histogram(nonzero_data, bins='auto', density=False)
+                self.data_min = np.min(nonzero_data)
+                self.data_max = np.max(nonzero_data)
+                self.histo_list = [self.data_min, self.data_max]
+            
             self.bounds = True
             self.parent().bounds = True
 
@@ -12307,16 +12396,26 @@ class ThresholdWindow(QMainWindow):
         layout.addWidget(self.canvas)
         
         # Pre-compute histogram with numpy
-        counts, bin_edges = np.histogram(self.histo_list, bins=50)
-        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+        if accepted_mode != 0:
+            counts, bin_edges = np.histogram(self.histo_list, bins=50)
+            bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+                    # Store histogram bounds
+            if self.bounds:
+                self.data_min = 0
+            else:
+                self.data_min = min(self.histo_list)
+            self.data_max = max(self.histo_list)
+        else:
+            bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+            bin_width = bin_edges[1] - bin_edges[0]
         
         # Plot pre-computed histogram
         self.ax = fig.add_subplot(111)
         self.ax.bar(bin_centers, counts, width=bin_edges[1] - bin_edges[0], alpha=0.5)
         
         # Add vertical lines for thresholds
-        self.min_line = self.ax.axvline(min(self.histo_list), color='r')
-        self.max_line = self.ax.axvline(max(self.histo_list), color='b')
+        self.min_line = self.ax.axvline(self.data_min, color='r')
+        self.max_line = self.ax.axvline(self.data_max, color='b')
         
         # Connect events for dragging
         self.canvas.mpl_connect('button_press_event', self.on_press)
@@ -12324,13 +12423,6 @@ class ThresholdWindow(QMainWindow):
         self.canvas.mpl_connect('button_release_event', self.on_release)
         
         self.dragging = None
-        
-        # Store histogram bounds
-        if self.bounds:
-            self.data_min = 0
-        else:
-            self.data_min = min(self.histo_list)
-        self.data_max = max(self.histo_list)
 
         # Create form layout for inputs
         form_layout = QFormLayout()
@@ -15285,31 +15377,81 @@ class HistogramSelector(QWidget):
         """)
         layout.addWidget(button)
 
+
     def shortest_path_histogram(self):
         try:
-            shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(self.G))
-            diameter = max(nx.eccentricity(self.G, sp=shortest_path_lengths).values())
-            path_lengths = np.zeros(diameter + 1, dtype=int)
-
-            for pls in shortest_path_lengths.values():
-                pl, cnts = np.unique(list(pls.values()), return_counts=True)
+            # Check if graph has multiple disconnected components
+            components = list(nx.connected_components(self.G))
+            
+            if len(components) > 1:
+                print(f"Warning: Graph has {len(components)} disconnected components. Computing shortest paths within each component separately.")
+                
+                # Initialize variables to collect data from all components
+                all_path_lengths = []
+                max_diameter = 0
+                
+                # Process each component separately
+                for i, component in enumerate(components):
+                    subgraph = self.G.subgraph(component)
+                    
+                    if len(component) < 2:
+                        # Skip single-node components (no paths to compute)
+                        continue
+                    
+                    # Compute shortest paths for this component
+                    shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(subgraph))
+                    component_diameter = max(nx.eccentricity(subgraph, sp=shortest_path_lengths).values())
+                    max_diameter = max(max_diameter, component_diameter)
+                    
+                    # Collect path lengths from this component
+                    for pls in shortest_path_lengths.values():
+                        all_path_lengths.extend(list(pls.values()))
+                
+                # Remove self-paths (length 0) and create histogram
+                all_path_lengths = [pl for pl in all_path_lengths if pl > 0]
+                
+                if not all_path_lengths:
+                    print("No paths found across components (only single-node components)")
+                    return
+                    
+                # Create combined histogram
+                path_lengths = np.zeros(max_diameter + 1, dtype=int)
+                pl, cnts = np.unique(all_path_lengths, return_counts=True)
                 path_lengths[pl] += cnts
-
+                
+                title_suffix = f" (across {len(components)} components)"
+                
+            else:
+                # Single component
+                shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(self.G))
+                diameter = max(nx.eccentricity(self.G, sp=shortest_path_lengths).values())
+                path_lengths = np.zeros(diameter + 1, dtype=int)
+                for pls in shortest_path_lengths.values():
+                    pl, cnts = np.unique(list(pls.values()), return_counts=True)
+                    path_lengths[pl] += cnts
+                max_diameter = diameter
+                title_suffix = ""
+            
+            # Generate visualization and results (same for both cases)
             freq_percent = 100 * path_lengths[1:] / path_lengths[1:].sum()
-
             fig, ax = plt.subplots(figsize=(15, 8))
-            ax.bar(np.arange(1, diameter + 1), height=freq_percent)
+            ax.bar(np.arange(1, max_diameter + 1), height=freq_percent)
             ax.set_title(
-                "Distribution of shortest path length in G", fontdict={"size": 35}, loc="center"
+                f"Distribution of shortest path length in G{title_suffix}", 
+                fontdict={"size": 35}, loc="center"
             )
             ax.set_xlabel("Shortest Path Length", fontdict={"size": 22})
             ax.set_ylabel("Frequency (%)", fontdict={"size": 22})
             plt.show()
             
             freq_dict = {freq: length for length, freq in enumerate(freq_percent, start=1)}
-            self.network_analysis.format_for_upperright_table(freq_dict, metric='Frequency (%)', 
-                                                            value='Shortest Path Length', 
-                                                            title="Distribution of shortest path length in G")
+            self.network_analysis.format_for_upperright_table(
+                freq_dict, 
+                metric='Frequency (%)', 
+                value='Shortest Path Length', 
+                title=f"Distribution of shortest path length in G{title_suffix}"
+            )
+            
         except Exception as e:
             print(f"Error generating shortest path histogram: {e}")
     
@@ -15328,20 +15470,62 @@ class HistogramSelector(QWidget):
                                                             title="Degree Centrality Table")
         except Exception as e:
             print(f"Error generating degree centrality histogram: {e}")
-    
+
     def betweenness_centrality_histogram(self):
         try:
-            betweenness_centrality = nx.centrality.betweenness_centrality(self.G)
+            # Check if graph has multiple disconnected components
+            components = list(nx.connected_components(self.G))
+            
+            if len(components) > 1:
+                print(f"Warning: Graph has {len(components)} disconnected components. Computing betweenness centrality within each component separately.")
+                
+                # Initialize dictionary to collect betweenness centrality from all components
+                combined_betweenness_centrality = {}
+                
+                # Process each component separately
+                for i, component in enumerate(components):
+                    if len(component) < 2:
+                        # For single-node components, betweenness centrality is 0
+                        for node in component:
+                            combined_betweenness_centrality[node] = 0.0
+                        continue
+                    
+                    # Create subgraph for this component
+                    subgraph = self.G.subgraph(component)
+                    
+                    # Compute betweenness centrality for this component
+                    component_betweenness = nx.centrality.betweenness_centrality(subgraph)
+                    
+                    # Add to combined results
+                    combined_betweenness_centrality.update(component_betweenness)
+                
+                betweenness_centrality = combined_betweenness_centrality
+                title_suffix = f" (across {len(components)} components)"
+                
+            else:
+                # Single component
+                betweenness_centrality = nx.centrality.betweenness_centrality(self.G)
+                title_suffix = ""
+            
+            # Generate visualization and results (same for both cases)
             plt.figure(figsize=(15, 8))
             plt.hist(betweenness_centrality.values(), bins=100)
             plt.xticks(ticks=[0, 0.02, 0.1, 0.2, 0.3, 0.4, 0.5])
-            plt.title("Betweenness Centrality Histogram ", fontdict={"size": 35}, loc="center")
+            plt.title(
+                f"Betweenness Centrality Histogram{title_suffix}", 
+                fontdict={"size": 35}, loc="center"
+            )
             plt.xlabel("Betweenness Centrality", fontdict={"size": 20})
             plt.ylabel("Counts", fontdict={"size": 20})
             plt.show()
-            self.network_analysis.format_for_upperright_table(betweenness_centrality, metric='Node', 
-                                                            value='Betweenness Centrality', 
-                                                            title="Betweenness Centrality Table")
+            
+            self.network_analysis.format_for_upperright_table(
+                betweenness_centrality, 
+                metric='Node', 
+                value='Betweenness Centrality', 
+                title=f"Betweenness Centrality Table{title_suffix}"
+            )
+            
         except Exception as e:
             print(f"Error generating betweenness centrality histogram: {e}")
     
@@ -15394,7 +15578,27 @@ class HistogramSelector(QWidget):
     def bridges_analysis(self):
         try:
             bridges = list(nx.bridges(self.G))
-            self.network_analysis.format_for_upperright_table(bridges, metric='Node Pair', 
+            try:
+                # Get the existing DataFrame from the model
+                original_df = self.network_analysis.network_table.model()._data
+                
+                # Create boolean mask
+                mask = pd.Series([False] * len(original_df))
+                
+                for u, v in bridges:
+                    # Check for both (u,v) and (v,u) orientations
+                    bridge_mask = (
+                        ((original_df.iloc[:, 0] == u) & (original_df.iloc[:, 1] == v)) |
+                        ((original_df.iloc[:, 0] == v) & (original_df.iloc[:, 1] == u))
+                    )
+                    mask |= bridge_mask
+                # Filter the DataFrame to only include bridge connections
+                filtered_df = original_df[mask].copy()
+                df_dict = {i: row.tolist() for i, row in enumerate(filtered_df.values)}
+                self.network_analysis.format_for_upperright_table(df_dict, metric='Bridge ID', value = ['NodeA', 'NodeB', 'EdgeC'],
+                                                            title="Bridges")
+            except:
+                self.network_analysis.format_for_upperright_table(bridges, metric='Node Pair', 
                                                             title="Bridges")
         except Exception as e:
             print(f"Error generating bridges analysis: {e}")
@@ -15421,7 +15625,7 @@ class HistogramSelector(QWidget):
     def node_connectivity_histogram(self):
         """Local node connectivity - minimum number of nodes that must be removed to disconnect neighbors"""
         try:
-            if self.G.number_of_nodes() > 500:  # Skip for large networks (computationally expensive)
+            if self.G.number_of_nodes() > 500:
                 print("Note this analysis may be slow for large network (>500 nodes)")
                 #return
                 
@@ -15499,7 +15703,7 @@ class HistogramSelector(QWidget):
     def load_centrality_histogram(self):
         """Load centrality - fraction of shortest paths passing through each node"""
         try:
-            if self.G.number_of_nodes() > 1000:  # Skip for very large networks
+            if self.G.number_of_nodes() > 1000:
                 print("Note this analysis may be slow for large network (>1000 nodes)")
                 #return
                 
@@ -15518,21 +15722,67 @@ class HistogramSelector(QWidget):
     def communicability_centrality_histogram(self):
         """Communicability centrality - based on communicability between nodes"""
         try:
-            if self.G.number_of_nodes() > 500:  # Skip for large networks (memory intensive)
+            if self.G.number_of_nodes() > 500:
                 print("Note this analysis may be slow for large network (>500 nodes)")
                 #return
+            
+            # Check if graph has multiple disconnected components
+            components = list(nx.connected_components(self.G))
+            
+            if len(components) > 1:
+                print(f"Warning: Graph has {len(components)} disconnected components. Computing communicability centrality within each component separately.")
+                
+                # Initialize dictionary to collect communicability centrality from all components
+                combined_comm_centrality = {}
+                
+                # Process each component separately
+                for i, component in enumerate(components):
+                    if len(component) < 2:
+                        # For single-node components, communicability betweenness centrality is 0
+                        for node in component:
+                            combined_comm_centrality[node] = 0.0
+                        continue
+                    
+                    # Create subgraph for this component
+                    subgraph = self.G.subgraph(component)
+                    
+                    # Compute communicability betweenness centrality for this component
+                    try:
+                        component_comm_centrality = nx.communicability_betweenness_centrality(subgraph)
+                        # Add to combined results
+                        combined_comm_centrality.update(component_comm_centrality)
+                    except Exception as comp_e:
+                        print(f"Error computing communicability centrality for component {i+1}: {comp_e}")
+                        # Set centrality to 0 for nodes in this component if computation fails
+                        for node in component:
+                            combined_comm_centrality[node] = 0.0
+                
+                comm_centrality = combined_comm_centrality
+                title_suffix = f" (across {len(components)} components)"
                 
-            # Use the correct function name - it's in the communicability module
-            comm_centrality = nx.communicability_betweenness_centrality(self.G)
+            else:
+                # Single component
+                comm_centrality = nx.communicability_betweenness_centrality(self.G)
+                title_suffix = ""
+            
+            # Generate visualization and results (same for both cases)
             plt.figure(figsize=(15, 8))
             plt.hist(comm_centrality.values(), bins=50, alpha=0.7)
-            plt.title("Communicability Betweenness Centrality Distribution", fontdict={"size": 35}, loc="center")
+            plt.title(
+                f"Communicability Betweenness Centrality Distribution{title_suffix}", 
+                fontdict={"size": 35}, loc="center"
+            )
             plt.xlabel("Communicability Betweenness Centrality", fontdict={"size": 20})
             plt.ylabel("Frequency", fontdict={"size": 20})
             plt.show()
-            self.network_analysis.format_for_upperright_table(comm_centrality, metric='Node', 
-                                                            value='Communicability Betweenness Centrality', 
-                                                            title="Communicability Betweenness Centrality Table")
+            
+            self.network_analysis.format_for_upperright_table(
+                comm_centrality, 
+                metric='Node', 
+                value='Communicability Betweenness Centrality', 
+                title=f"Communicability Betweenness Centrality Table{title_suffix}"
+            )
+            
         except Exception as e:
             print(f"Error generating communicability betweenness centrality histogram: {e}")
     
@@ -15555,20 +15805,67 @@ class HistogramSelector(QWidget):
     def current_flow_betweenness_histogram(self):
         """Current flow betweenness - models network as electrical circuit"""
         try:
-            if self.G.number_of_nodes() > 500:  # Skip for large networks (computationally expensive)
+            if self.G.number_of_nodes() > 500:  
                 print("Note this analysis may be slow for large network (>500 nodes)")
                 #return
+            
+            # Check if graph has multiple disconnected components
+            components = list(nx.connected_components(self.G))
+            
+            if len(components) > 1:
+                print(f"Warning: Graph has {len(components)} disconnected components. Computing current flow betweenness centrality within each component separately.")
                 
-            current_flow = nx.current_flow_betweenness_centrality(self.G)
+                # Initialize dictionary to collect current flow betweenness from all components
+                combined_current_flow = {}
+                
+                # Process each component separately
+                for i, component in enumerate(components):
+                    if len(component) < 2:
+                        # For single-node components, current flow betweenness centrality is 0
+                        for node in component:
+                            combined_current_flow[node] = 0.0
+                        continue
+                    
+                    # Create subgraph for this component
+                    subgraph = self.G.subgraph(component)
+                    
+                    # Compute current flow betweenness centrality for this component
+                    try:
+                        component_current_flow = nx.current_flow_betweenness_centrality(subgraph)
+                        # Add to combined results
+                        combined_current_flow.update(component_current_flow)
+                    except Exception as comp_e:
+                        print(f"Error computing current flow betweenness for component {i+1}: {comp_e}")
+                        # Set centrality to 0 for nodes in this component if computation fails
+                        for node in component:
+                            combined_current_flow[node] = 0.0
+                
+                current_flow = combined_current_flow
+                title_suffix = f" (across {len(components)} components)"
+                
+            else:
+                # Single component
+                current_flow = nx.current_flow_betweenness_centrality(self.G)
+                title_suffix = ""
+            
+            # Generate visualization and results (same for both cases)
             plt.figure(figsize=(15, 8))
             plt.hist(current_flow.values(), bins=50, alpha=0.7)
-            plt.title("Current Flow Betweenness Centrality Distribution", fontdict={"size": 35}, loc="center")
+            plt.title(
+                f"Current Flow Betweenness Centrality Distribution{title_suffix}", 
+                fontdict={"size": 35}, loc="center"
+            )
             plt.xlabel("Current Flow Betweenness Centrality", fontdict={"size": 20})
             plt.ylabel("Frequency", fontdict={"size": 20})
             plt.show()
-            self.network_analysis.format_for_upperright_table(current_flow, metric='Node', 
-                                                            value='Current Flow Betweenness', 
-                                                            title="Current Flow Betweenness Table")
+            
+            self.network_analysis.format_for_upperright_table(
+                current_flow, 
+                metric='Node', 
+                value='Current Flow Betweenness', 
+                title=f"Current Flow Betweenness Table{title_suffix}"
+            )
+            
         except Exception as e:
             print(f"Error generating current flow betweenness histogram: {e}")