nettracer3d 1.3.1__py3-none-any.whl → 1.3.6__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -239,14 +239,14 @@ class ImageViewerWindow(QMainWindow):
 
 
         self.toggle_scale = QPushButton("📏")
-        self.toggle_scale.setFixedSize(20, 20)
+        self.toggle_scale.setFixedSize(32, 32)
         self.toggle_scale.clicked.connect(self.toggle_scalebar)
         self.toggle_scale.setCheckable(True)
         self.toggle_scale.setChecked(False)
         control_layout.addWidget(self.toggle_scale)
 
         self.reset_view = QPushButton("🏠")
-        self.reset_view.setFixedSize(20, 20)
+        self.reset_view.setFixedSize(32, 32)
         self.reset_view.clicked.connect(self.home)
         control_layout.addWidget(self.reset_view)
 
@@ -559,24 +559,26 @@ class ImageViewerWindow(QMainWindow):
         # Create graph widgets
         self.network_graph_widget = ngw.NetworkGraphWidget(
             parent=self,
-            weight=False,
+            weight=True,
             geometric=False,
             centroids=None,
-            communities=True,
+            communities=False,
             community_dict=None,
             labels=True,
-            z_size = True
+            z_size = True,
+            popout = True
         )
 
         self.selection_graph_widget = ngw.NetworkGraphWidget(
             parent=self,
-            weight=False,
+            weight=True,
             geometric=False,
             centroids=None,
             communities=False,
             community_dict=None,
             labels=True,
-            z_size = True
+            z_size = True,
+            popout = True
         )
 
         # Create both table views
@@ -656,7 +658,11 @@ class ImageViewerWindow(QMainWindow):
         self.disable_pan = False
         self.grid_ready = False
         self.remove_scale = False
+        self.remove_grid = False
         self.original_dims = None
+        self.thresh_min = None
+        self.thresh_max = None
+        self.temp_graph_widgets = []
 
         #Deprecated:
         self.figure = Figure(figsize=(8, 8))
@@ -1283,11 +1289,13 @@ class ImageViewerWindow(QMainWindow):
                 self.selection_graph_widget.select_nodes(node_indices)
             except:
                 pass
-        try:
-            if self.temp_graph_widget.rendered:
-                self.temp_graph_widget.select_nodes(node_indices)
-        except:
-            pass
+
+        for graph in self.temp_graph_widgets:
+            try:
+                if graph.rendered:
+                    graph.select_nodes(node_indices)
+            except:
+                pass
 
     def table_subgraph(self, table_widget, table):
 
@@ -3127,7 +3135,7 @@ class ImageViewerWindow(QMainWindow):
 
                 if my_network.network_lists is not None:
                     for i in range(len(my_network.network_lists[0]) - 1, -1, -1):
-                        if my_network.network_lists[0][i] in self.clicked_values['nodes'] or my_network.network_lists[0][i] in self.clicked_values['nodes']:
+                        if my_network.network_lists[0][i] in self.clicked_values['nodes'] or my_network.network_lists[1][i] in self.clicked_values['nodes']:
                             del my_network.network_lists[0][i]
                             del my_network.network_lists[1][i]
                             del my_network.network_lists[2][i]
@@ -3319,6 +3327,7 @@ class ImageViewerWindow(QMainWindow):
                 self.update_display(preserve_zoom=(self.ax.get_xlim(), self.ax.get_ylim()))
                 self.toggle_scale.setChecked(True)
                 self.remove_scale = False
+                self.remove_grid = True
                 return
 
             if self.scale_bar:
@@ -3326,7 +3335,9 @@ class ImageViewerWindow(QMainWindow):
                 self._draw_scalebar()
                 self.update_display(preserve_zoom=(self.ax.get_xlim(), self.ax.get_ylim()))
             else:
+                self.coord_label.setText("                                                                                               ")
                 self.grid_ready = False
+                self.remove_grid = False
                 self.toggle_grid()
                 self._remove_scalebar()
                 self.update_display(preserve_zoom=(self.ax.get_xlim(), self.ax.get_ylim()))
@@ -3820,7 +3831,13 @@ class ImageViewerWindow(QMainWindow):
         
         mouse_point = self.view.mapSceneToView(pos)
         x, y = mouse_point.x(), mouse_point.y()
-        
+
+        try:
+            if self.remove_grid or self.remove_scale:
+                self.coord_label.setText(f"Z: {self.current_slice}, Y: {int(y)}, X: {int(x)}")
+        except:
+            pass
+
         try:
             # Check if within image bounds
             if self.original_dims is None:
@@ -4439,7 +4456,7 @@ class ImageViewerWindow(QMainWindow):
         allstats_action = stats_net_menu.addAction("Calculate Generic Network Stats")
         allstats_action.triggered.connect(self.stats)
         histos_action = stats_net_menu.addAction("Network Statistic Histograms")
-        histos_action.triggered.connect(self.histos)
+        histos_action.triggered.connect(self.histograms)
         radial_action = stats_net_menu.addAction("Radial Distribution Analysis")
         radial_action.triggered.connect(self.show_radial_dialog)
         heatmap_action = stats_net_menu.addAction("Community Cluster Heatmap")
@@ -4606,7 +4623,19 @@ class ImageViewerWindow(QMainWindow):
         corner_widget = QWidget()
         corner_layout = QHBoxLayout(corner_widget)
         corner_layout.setContentsMargins(5, 0, 5, 0)
-        
+
+        self.coord_label = QLabel(f"                                                                                               ")
+        self.coord_label.setText(f"                                                                                               ")
+        corner_layout.addWidget(self.coord_label)
+
+        self.xy_scale_label = QLabel(f"xy_scale: {my_network.xy_scale}                   ")
+        self.xy_scale_label.setText(f"xy_scale: {my_network.xy_scale}                   ")
+        corner_layout.addWidget(self.xy_scale_label)
+
+        self.z_scale_label = QLabel(f"z_scale: {my_network.z_scale}                   ")
+        self.z_scale_label.setText(f"z_scale: {my_network.z_scale}                   ")
+        corner_layout.addWidget(self.z_scale_label)
+
         self.z_label = QLabel(f"Slice {self.current_slice}")
         self.z_label.setText(f"Slice {self.current_slice}")
         corner_layout.addWidget(self.z_label)
@@ -4948,9 +4977,11 @@ class ImageViewerWindow(QMainWindow):
 
             self.format_for_upperright_table(stats, title = 'Network Stats')
         except Exception as e:
+            import traceback
+            traceback.print_exc()
             print(f"Error finding stats: {e}")
 
-    def histos(self):
+    def histograms(self):
         """
         Show a PyQt6 window with buttons to select which histogram to generate.
         Only calculates the histogram that the user selects.
@@ -4962,7 +4993,8 @@ class ImageViewerWindow(QMainWindow):
                 app = QApplication(sys.argv)
             
             # Create and show the histogram selector window
-            self.histogram_selector = HistogramSelector(self, self.stats_dict)
+            from . import histos
+            self.histogram_selector = histos.HistogramSelector(self, self.stats_dict, my_network.network)
             self.histogram_selector.show()
             
             # Keep the window open (you might want to handle this differently based on your application structure)
@@ -5572,7 +5604,8 @@ class ImageViewerWindow(QMainWindow):
                 try:
                     if sort == 'Node Identities':
                         my_network.load_node_identities(file_path = filename)
-
+                        self.network_graph_widget.identity_dict = my_network.node_identities
+                        self.selection_graph_widget.identity_dict = my_network.node_identities
 
                         if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
                             try:
@@ -5583,6 +5616,7 @@ class ImageViewerWindow(QMainWindow):
                     elif sort == 'Node Centroids':
                         my_network.load_node_centroids(file_path = filename)
                         self.network_graph_widget.centroids = my_network.node_centroids
+                        self.selection_graph_widget.centroids = my_network.node_centroids
 
                         if hasattr(my_network, 'node_centroids') and my_network.node_centroids is not None:
                             try:
@@ -5601,6 +5635,9 @@ class ImageViewerWindow(QMainWindow):
                     elif sort == 'Communities':
                         my_network.load_communities(file_path = filename)
 
+                        self.network_graph_widget.community_dict = my_network.communities
+                        self.selection_graph_widget.community_dict = my_network.communities
+
                         if hasattr(my_network, 'communities') and my_network.communities is not None:
                             try:
                                 self.format_for_upperright_table(my_network.communities, 'NodeID', 'Identity', 'Node Communities')
@@ -5755,11 +5792,21 @@ class ImageViewerWindow(QMainWindow):
         self.network_graph_widget.set_graph(None)
         self.network_graph_widget.community_dict = None
         self.network_graph_widget.identity_dict = None
-        self.network_graph_widget.node_centroids = None
+        self.network_graph_widget.centroids = None
         self.selection_graph_widget.set_graph(None)
         self.selection_graph_widget.community_dict = None
         self.selection_graph_widget.identity_dict = None
-        self.selection_graph_widget.node_centroids = None
+        self.selection_graph_widget.centroids = None
+
+    def update_graph_fields(self):
+
+        #self.network_graph_widget.set_graph(my_network.network)
+        self.network_graph_widget.community_dict = my_network.communities
+        self.network_graph_widget.identity_dict = my_network.node_identities
+        self.network_graph_widget.centroids = my_network.node_centroids
+        self.selection_graph_widget.community_dict = my_network.communities
+        self.selection_graph_widget.identity_dict = my_network.node_identities
+        self.selection_graph_widget.centroids = my_network.node_centroids
 
     # Modify load_from_network_obj method
     def load_from_network_obj(self, directory = None):
@@ -5776,7 +5823,8 @@ class ImageViewerWindow(QMainWindow):
 
             self.last_load = directory
             self.last_saved = os.path.dirname(directory)
-            self.last_save_name = directory            
+            self.last_save_name = directory
+            self.setWindowTitle(f"NetTracer3D - Session: {self.last_save_name}")            
 
             self.channel_data = [None] * 5
             if directory != "":
@@ -5785,8 +5833,11 @@ class ImageViewerWindow(QMainWindow):
 
                 self.clear_subgraphs()
                 my_network.assemble(directory)
+                self.xy_scale_label.setText(f"xy_scale: {my_network.xy_scale:.2e}                   ")
+                self.z_scale_label.setText(f"z_scale: {my_network.z_scale:.2e}                   ")
                 self.network_graph_widget.set_graph(my_network.network)
                 self.network_graph_widget.centroids = my_network.node_centroids
+                self.selection_graph_widget.centroids = my_network.node_centroids
                 #self.network_graph_widget.load_graph()
 
                 # Load image channelsTrue
@@ -6100,12 +6151,14 @@ class ImageViewerWindow(QMainWindow):
         msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         return msg.exec() == QMessageBox.StandardButton.Yes
 
-    def confirm_resize_dialog(self):
+    def confirm_resize_dialog(self, shapes):
         """Shows a dialog asking user to resize image"""
+        old_shape = shapes[0]
+        new_shape = shapes[1]
         msg = QMessageBox()
         msg.setIcon(QMessageBox.Icon.Question)
         msg.setText("Image Format Alert")
-        msg.setInformativeText(f"This image is a different shape than the ones loaded into the viewer window. This program is not designed to accomodate loading of differently sized images.\nPress yes to resize the new image to the other images. Press no to go back.")
+        msg.setInformativeText(f"This image is a different shape (New shape: {new_shape}) than the ones loaded into the viewer window (Current shape: {old_shape}). This program is not designed to accomodate loading of differently sized images.\nPress yes to resize the new image to the other images. Press no to go back.")
         msg.setWindowTitle("Resize")
         msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         return msg.exec() == QMessageBox.StandardButton.Yes
@@ -6174,6 +6227,8 @@ class ImageViewerWindow(QMainWindow):
                             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}")
+                                self.xy_scale_label.setText(f"xy_scale: {my_network.xy_scale:.2e}                   ")
+                                self.z_scale_label.setText(f"z_scale: {my_network.z_scale:.2e}                   ")
                             except:
                                 pass
                         test_channel_data = tifffile.imread(filename)
@@ -6211,8 +6266,8 @@ class ImageViewerWindow(QMainWindow):
             else:
                 self.channel_data[channel_index] = channel_data
                 if channel_data is None:
-                    self.channel_buttons[channel_index].setEnabled(False)
-                    self.delete_buttons[channel_index].setEnabled(False) 
+                    self.delete_channel(channel_index, called = False, update = True)
+                    return
 
             try:
                 #if len(self.channel_data[channel_index].shape) == 4:
@@ -6268,7 +6323,7 @@ class ImageViewerWindow(QMainWindow):
                 else:
                     old_shape = self.channel_data[i].shape[:3] #Ask user to resize images that are shaped differently
                     if old_shape != self.channel_data[channel_index].shape[:3]:
-                        if self.confirm_resize_dialog():
+                        if self.confirm_resize_dialog([old_shape, self.channel_data[channel_index].shape[:3]]):
                             self.channel_data[channel_index] = n3d.upsample_with_padding(self.channel_data[channel_index], original_shape = old_shape)
                             break
                         else:
@@ -6454,6 +6509,8 @@ class ImageViewerWindow(QMainWindow):
         # Set scales first before any clearing operations
         my_network.xy_scale = xy_scale
         my_network.z_scale = z_scale
+        self.xy_scale_label.setText(f"xy_scale: {my_network.xy_scale:.2e}                   ")
+        self.z_scale_label.setText(f"z_scale: {my_network.z_scale:.2e}                   ")
 
         if network:
             my_network.network = None
@@ -6495,51 +6552,67 @@ class ImageViewerWindow(QMainWindow):
     def save_network_3d(self, asbool=True):
         try:
             if asbool:  # Save As
-                # First let user select parent directory
-                parent_dir = QFileDialog.getExistingDirectory(
+                # Use getSaveFileName which allows non-existent paths
+                # This lets users navigate to parent AND type the child folder name in one step
+                full_path, _ = QFileDialog.getSaveFileName(
                     self,
-                    "Select Location for Network3D Object Outputs",
+                    "Select Location and Name for Network3D Output Folder",
                     "",
-                    QFileDialog.Option.ShowDirsOnly
-                )
-                if not parent_dir:  # If user canceled the directory selection
-                    return  # Exit the method early
-                    
-                # Prompt user for new folder name
-                new_folder_name, ok = QInputDialog.getText(
-                    self,
-                    "New Folder",
-                    "Enter name for new output folder:"
+                    "Folder (*.folder)",  # Dummy filter, we'll ignore the extension
+                    options=QFileDialog.Option.DontConfirmOverwrite  # Don't warn about overwriting
                 )
                 
-                # Check if user canceled the folder name dialog
-                if not ok or not new_folder_name:
-                    return  # Exit the method early
-            
-            else:  # Save
+                if not full_path:  # User canceled
+                    return
+                
+                # Parse the result: extract parent directory and folder name
+                import os
+                parent_dir = os.path.dirname(full_path)
+                new_folder_name = os.path.basename(full_path)
+                
+                # Remove any extension the user might have typed (from dummy filter)
+                if new_folder_name.endswith('.folder'):
+                    new_folder_name = new_folder_name[:-7]
+                
+                # Validate parent directory exists
+                if not os.path.isdir(parent_dir):
+                    QMessageBox.critical(
+                        self,
+                        "Invalid Location",
+                        f"Parent directory does not exist: {parent_dir}"
+                    )
+                    return
+                
+                # Validate folder name is not empty
+                if not new_folder_name:
+                    QMessageBox.critical(
+                        self,
+                        "Invalid Name",
+                        "Please enter a name for the output folder."
+                    )
+                    return
 
+            else:  # Save
                 if self.last_saved is None:
                     self.save_network_3d()
+                    return
                 else:
-                    if len(self.channel_data[0].shape) == 4:
-                        try:
-                            self.load_channel(0, self.reduce_rgb_dimension(self.channel_data[0], 'weight'), True)
-                        except:
-                            pass
-                    my_network.dump(parent_dir=self.last_saved, name=self.last_save_name)
-
+                    parent_dir = self.last_saved
+                    new_folder_name = self.last_save_name
+                    
+            # Handle RGB dimension reduction before saving
             if len(self.channel_data[0].shape) == 4:
                 try:
                     self.load_channel(0, self.reduce_rgb_dimension(self.channel_data[0], 'weight'), True)
                 except:
                     pass
-            
+
             # Call appropriate save method
-            if asbool:
-                my_network.dump(parent_dir=parent_dir, name=new_folder_name)
-                self.last_saved = parent_dir
-                self.last_save_name = new_folder_name
-                
+            my_network.dump(parent_dir=parent_dir, name=new_folder_name)
+            self.last_saved = parent_dir
+            self.last_save_name = new_folder_name
+            self.setWindowTitle(f"NetTracer3D - Session: {self.last_save_name}")
+
         except Exception as e:
             QMessageBox.critical(
                 self,
@@ -6565,10 +6638,24 @@ class ImageViewerWindow(QMainWindow):
                     if not filename.endswith(('.tif', '.tiff')):
                         filename += '.tif'
             else:  # Save
-                filename = None  # Let the backend handle default save location
+                if self.last_saved is None:
+                    self.save(ch_index)
+                    return
+                else:
+                    if ch_index == 0:
+                        filename = self.last_save_name + "/labelled_nodes.tif"
+                        print(filename)
+                    elif ch_index == 1:
+                        filename = self.last_save_name + "/labelled_edges.tif"
+                    elif ch_index == 2:
+                        filename = self.last_save_name + "/overlay_1.tif"
+                    elif ch_index == 3:
+                        filename = self.last_save_name + "/overlay_2.tif"
+                    elif ch_index == 4:
+                        filename = self.last_save_name + "/Highlighted_Element.tif"
             
             # Call appropriate save method
-            if filename is not None or not asbool:  # Proceed if we have a filename OR if it's a regular save
+            if (filename is not None and filename != "") or not asbool:  # Proceed if we have a filename OR if it's a regular save
                 if ch_index == 0:
                     my_network.save_nodes(filename=filename)
                 elif ch_index == 1:
@@ -6618,7 +6705,7 @@ class ImageViewerWindow(QMainWindow):
         self.pending_slice = (self.slice_slider.value(), (current_xlim, current_ylim))
         
         # Reset and restart timer
-        self._slice_update_timer.start(20)  # 20ms delay
+        self._slice_update_timer.start(1)  # 20ms delay
         
     def _do_slice_update(self):
         """Actually perform the slice update after debounce delay."""
@@ -7089,7 +7176,7 @@ class ImageViewerWindow(QMainWindow):
         try:
             # Basic graph properties
             stats['num_nodes'] = my_network.network.number_of_nodes()
-            stats['num_edges'] = my_network.network.number_of_edges()
+            stats['num_edges'] = len(my_network.network_lists[0])
         except:
             try:
                 stats['num_nodes'] = len(np.unique(my_network.nodes)) - 1
@@ -8217,7 +8304,7 @@ class BrightnessContrastDialog(QDialog):
             self.debounce_timer.setSingleShot(True)
             self.debounce_timer.timeout.connect(self._apply_pending_updates)
             self.pending_updates = {}
-            self.debounce_delay = 20  # 300ms delay
+            self.debounce_delay = 1  # 300ms delay
 
             # Connect signals
             slider.valueChanged.connect(lambda values, ch=i: self.on_slider_change(ch, values))
@@ -8688,6 +8775,7 @@ class MergeNodeIdDialog(QDialog):
 
                 # For loop example - get threshold for multiple images/data
                 results = []
+                thresh_dict = {}
 
                 img_list = n3d.directory_info(selected_path)
                 data_backup = copy.deepcopy(data)
@@ -8702,7 +8790,7 @@ class MergeNodeIdDialog(QDialog):
                     if img.endswith('.tiff') or img.endswith('.tif'):
 
                         print(f"Please threshold {img}")
-
+                        self.parent().setWindowTitle(f"NetTracer3D: Please threshold {img}")
 
                         mask = tifffile.imread(f'{selected_path}/{img}')
                         self.parent().load_channel(2, mask, data = True)
@@ -8712,6 +8800,8 @@ class MergeNodeIdDialog(QDialog):
                         processing_completed = self.wait_for_threshold_processing()
                         
                         if not processing_completed:
+                            self.parent().thresh_min = None
+                            self.parent().thresh_max = None
                             # User cancelled, ask if they want to continue
                             reply = QMessageBox.question(self, 'Continue?', 
                                                        f'Threshold cancelled for item {i+1}. Continue with remaining items?',
@@ -8720,6 +8810,7 @@ class MergeNodeIdDialog(QDialog):
                                 break
                             continue
                         
+                        thresh_dict[img] = [self.parent().thresh_min, self.parent().thresh_max]
                         # At this point, the thresholded image is in the main window's memory
                         # Get the processed/thresholded data from wherever ThresholdWindow stored it
                         thresholded_vals = list(np.unique(self.parent().channel_data[0]))
@@ -8773,8 +8864,10 @@ class MergeNodeIdDialog(QDialog):
                         pass
 
                 my_network.node_identities = modify_dict
-                
+                self.parent().setWindowTitle(f"NetTracer3D")
+
                 self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
+                self.parent().format_for_upperright_table(thresh_dict, 'Identity', ['Min Value', 'Max Value'], 'Threshold Information')
 
                 all_keys = id_dicts[0].keys()
                 result = {key: np.array([d[key] for d in id_dicts]) for key in all_keys}
@@ -9223,7 +9316,7 @@ class ShuffleDialog(QDialog):
                     except:
                         self.parent().highlight_overay = None
                 else:
-                    self.parent().load_channel(accepted_mode, channel_data = target_data, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
+                    self.parent().load_channel(accepted_mode, channel_data = target_data, data = True)
             except:
                 pass
 
@@ -9235,14 +9328,14 @@ class ShuffleDialog(QDialog):
                     except:
                         self.parent().highlight_overlay = None
                 else:
-                    self.parent().load_channel(accepted_target, channel_data = active_data, data = True, preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
+                    self.parent().load_channel(accepted_target, channel_data = active_data, data = True)
             except:
                 pass
 
 
 
 
-            self.parent().update_display(preserve_zoom = (self.parent().ax.get_xlim(), self.parent().ax.get_ylim()))
+            self.parent().update_display()
 
             self.accept()
 
@@ -9265,40 +9358,68 @@ class NetShowDialog(QDialog):
         self.setWindowTitle("Display Parameters")
         self.setModal(True)
         
-        layout = QFormLayout(self)
+        main_layout = QVBoxLayout(self)
 
         self.called = called
 
+        layout_group = QGroupBox("Layout")
+        layout_layout = QFormLayout(layout_group)
+
         # Add mode selection dropdown
         self.render_mode = QComboBox()
-        self.render_mode.addItems(["Spring Layout (Try to Logically Group Nodes)", "Centroid Layout (Place Nodes to Match Image)", "Component Layout (Separate All Nontouching Components)"])
+        self.render_mode.addItems(["Spring Layout (Try to Logically Group Nodes)", "Centroid Layout (Place Nodes to Match Image)", "Component Layout Spring (Separate All Nontouching Components)", "Component Layout Shell (Centrally Places Important Nodes)"])
         self.render_mode.setCurrentIndex(0)  # Default to Mode 1
-        layout.addRow("Render Mode:", self.render_mode)
+        layout_layout.addRow("Render Mode:", self.render_mode)
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
         self.mode_selector.addItems(["Default", "Community Coded", "Node ID Coded"])
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
-        layout.addRow("Execution Mode:", self.mode_selector)
+        layout_layout.addRow("Execution Mode:", self.mode_selector)
+
+        main_layout.addWidget(layout_group)
+
+        render_group = QGroupBox("Node/Edge Rendering")
+        render_layout = QFormLayout(render_group)
+
+        # Add mode selection dropdown
+        self.edge_color = QComboBox()
+        self.edge_color.addItems(["Translucent Gray", "Solid Black"])
+        self.edge_color.setCurrentIndex(0)  # Default to Mode 1
+        render_layout.addRow("Edge Color:", self.edge_color)
+
+        self.node_size = QLineEdit("10")
+        render_layout.addRow("Node Sizes", self.node_size)
+
+        self.edge_size = QLineEdit("1")
+        render_layout.addRow("Edge Sizes", self.edge_size)
+
+        main_layout.addWidget(render_group)
+
+        misc_group = QGroupBox("Misc")
+        misc_layout = QFormLayout(misc_group)
 
         self.show_labels = QCheckBox("Show Node Numerical IDs?")
         self.show_labels.setChecked(True)
-        layout.addRow(self.show_labels)
+        misc_layout.addRow(self.show_labels)
 
         # weighted checkbox
         self.weighted = QCheckBox("Draw weighted edges (if applicable)")
-        self.weighted.setChecked(False)
-        layout.addRow(self.weighted)
+        self.weighted.setChecked(True)
+        misc_layout.addRow(self.weighted)
 
         # weighted checkbox (default True)
         self.z_size = QCheckBox("For Centroid Layout: Scale Node Sizes by Z?")
         self.z_size.setChecked(True)
-        layout.addRow(self.z_size)
+        misc_layout.addRow(self.z_size)
+
+        main_layout.addWidget(misc_group)
+
         
         # Add Run button
         run_button = QPushButton("Show Network")
         run_button.clicked.connect(self.show_network)
-        layout.addWidget(run_button)
+        main_layout.addWidget(run_button)
     
     def show_network(self):
 
@@ -9309,12 +9430,18 @@ class NetShowDialog(QDialog):
 
             geo = False
             component = False
+            shell = False
 
             render = self.render_mode.currentIndex()
+
+            edge_color = self.edge_color.currentIndex()
+
             if render == 1:
                 geo = True
             elif render == 2:
                 component = True
+            elif render == 3:
+                shell = True
             if geo:
                 if my_network.node_centroids is None:
                     self.parent().show_centroid_dialog()
@@ -9322,6 +9449,17 @@ class NetShowDialog(QDialog):
             # Get directory (None if empty)
             directory = None
 
+            try:
+                node_size = min(abs(int(self.node_size.text())), 100)
+            except:
+                node_size = 10
+
+            try:
+                edge_size = min(abs(int(self.edge_size.text())), 100)
+            except:
+                edge_size = 1
+
+
             weighted = self.weighted.isChecked()
             z_size = self.z_size.isChecked()
 
@@ -9333,9 +9471,20 @@ class NetShowDialog(QDialog):
             elif accepted_mode == 2:
                 identities = True
 
+            if accepted_mode == 1:
+
+                if my_network.communities is None:
+                    self.parent().show_partition_dialog()
+                    if my_network.communities is None:
+                        return
+            if edge_color == 0:
+                black_edges = False
+            else:
+                black_edges = True
+
             if not self.called:
                 # Create graph widgets
-                self.parent().temp_graph_widget = ngw.NetworkGraphWidget(
+                temp_graph_widget = ngw.NetworkGraphWidget(
                     parent=self.parent(),
                     weight=weighted,
                     geometric=geo,
@@ -9346,15 +9495,20 @@ class NetShowDialog(QDialog):
                     labels=show_labels,
                     identities = identities,
                     identity_dict = my_network.node_identities,
-                    z_size = z_size
+                    z_size = z_size,
+                    shell = shell,
+                    node_size = node_size,
+                    black_edges = black_edges,
+                    edge_size = edge_size
                 )
 
-                self.parent().temp_graph_widget.set_graph(my_network.network)
-                self.parent().temp_graph_widget.show_in_window(title="Network Graph", width=1000, height=800)
-                self.parent().temp_graph_widget.load_graph()
+                temp_graph_widget.set_graph(my_network.network)
+                temp_graph_widget.show_in_window(title="Network Graph", width=1000, height=800)
+                temp_graph_widget.load_graph()
+                self.parent().temp_graph_widgets.append(temp_graph_widget)
                 self.accept()
             else:
-                self.called.weight, self.called.geometric, self.called.component, self.called.centroids, self.called.communities, self.called.community_dict, self.called.labels, self.called.identities, self.called.identity_dict, self.called.z_size = weighted, geo, component, my_network.node_centroids, communities, my_network.communities, show_labels, identities, my_network.node_identities, z_size
+                self.called.weight, self.called.geometric, self.called.component, self.called.centroids, self.called.communities, self.called.community_dict, self.called.labels, self.called.identities, self.called.identity_dict, self.called.z_size, self.called.shell, self.called.node_size, self.called.black_edges, self.called.edge_size = edge_size = weighted, geo, component, my_network.node_centroids, communities, my_network.communities, show_labels, identities, my_network.node_identities, z_size, shell, node_size, black_edges, edge_size
                 self.called._clear_graph()
                 self.called.load_graph()
                 self.accept()
@@ -9362,30 +9516,6 @@ class NetShowDialog(QDialog):
         except Exception as e:
             print(f"Error: {e}")
 
-        """
-
-        if accepted_mode == 1:
-
-            if my_network.communities is None:
-                self.parent().show_partition_dialog()
-                if my_network.communities is None:
-                    return
-
-        try:
-            if accepted_mode == 0:
-                my_network.show_network(geometric=geo, show_labels = show_labels)
-            elif accepted_mode == 1:
-                my_network.show_communities_flex(geometric=geo, weighted = weighted, partition = my_network.communities, show_labels = show_labels)
-                self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'CommunityID')
-            elif accepted_mode == 2:
-                my_network.show_identity_network(geometric=geo, show_labels = show_labels)
-            
-            self.accept()
-        except Exception as e:
-            print(f"Error showing network: {e}")
-            import traceback
-            print(traceback.format_exc())
-        """
 
 class PartitionDialog(QDialog):
     def __init__(self, parent=None):
@@ -9397,7 +9527,7 @@ class PartitionDialog(QDialog):
         layout = QFormLayout(self)
 
         # weighted checkbox (default True)
-        self.weighted = QPushButton("weighted")
+        self.weighted = QPushButton("weighted (Considers Duplicate Connections)")
         self.weighted.setCheckable(True)
         self.weighted.setChecked(True)
         layout.addRow("Use Weighted Network:", self.weighted)
@@ -11588,6 +11718,8 @@ class ResizeDialog(QDialog):
             else:
                 my_network.xy_scale = cardinal
                 my_network.z_scale = cardinal
+            self.parent().xy_scale_label.setText(f"xy_scale: {my_network.xy_scale:.2e}                   ")
+            self.parent().z_scale_label.setText(f"z_scale: {my_network.z_scale:.2e}                   ")
 
             try:
                 if my_network.node_centroids is not None:
@@ -11675,16 +11807,62 @@ class CleanDialog(QDialog):
         run_button.clicked.connect(self.holes)
         layout.addRow("Call the fill holes function:", run_button)
 
+        # Add Run button
+        run_button = QPushButton("Connect Endpoints")
+        run_button.clicked.connect(self.endpoints)
+        layout.addRow("Connect Endpoints? (Unsupervised - Weak to noise):", run_button)
+
         # Add Run button
         run_button = QPushButton("Trace Filaments")
         run_button.clicked.connect(self.fils)
-        layout.addRow("For Segmentations of Blood Vessels/Nerves: ", run_button)
+        layout.addRow("For Segmentations of Blood Vessels/Nerves:", run_button)
 
         # Add Run button
         run_button = QPushButton("Threshold Noise")
         run_button.clicked.connect(self.thresh)
         layout.addRow("Threshold Noise By Volume:", run_button)
 
+    def endpoints(self):
+
+        class CleanDialog(QDialog):
+            def __init__(self, parent=None):
+                super().__init__(parent)
+                self.setWindowTitle("Rote Endpoint Joining - Connects ALL Detectable Endpoints Within Distance")
+                self.setModal(True)
+
+                layout = QFormLayout(self)
+
+                self.amount = QLineEdit("10")
+                layout.addRow("Voxel Distance to Connect Endpoints (Will be slow if large):", self.amount)
+
+                self.spine = QLineEdit("0")
+                layout.addRow("Skeleton Spine Removal Distance:", self.spine)
+
+                run_button = QPushButton("Run")
+                run_button.clicked.connect(self.run)
+                layout.addRow(run_button)
+
+            def run(self):
+                try:
+                    amount = float(self.amount.text())
+                except:
+                    return
+                try:
+                    spine = int(self.spine.text())
+                except:
+                    spine = 0
+
+                try:
+                    from . import endpoint_joiner
+                    joined = endpoint_joiner.connect_endpoints(self.parent().channel_data[self.parent().active_channel], amount, spine)
+                    self.parent().load_channel(3, joined, data = True)
+                    self.accept()
+                except Exception as e:
+                    print(f"Error: {e}")
+
+        dialog = CleanDialog(self.parent())
+        dialog.exec()
+
     def close(self):
 
         try:
@@ -12439,8 +12617,7 @@ class MachineWindow(QMainWindow):
             full_button = QPushButton("Segment All")
             full_button.clicked.connect(self.segment)
             segmentation_layout.addWidget(seg_button)
-            segmentation_layout.addWidget(self.pause_button)   # <--- for some reason the segmenter preview is still running even when killed, may be regenerating itself somewhere. May or may not actually try to resolve this because this feature isnt that necessary.
-            #segmentation_layout.addWidget(self.lock_button)   # Also turned this off
+            segmentation_layout.addWidget(self.pause_button)
             segmentation_layout.addWidget(full_button)
             segmentation_group.setLayout(segmentation_layout)
 
@@ -12852,9 +13029,6 @@ class MachineWindow(QMainWindow):
         current_time = time.time()
         if current_time - self._last_update >= 1:  # Match worker's interval
             try:
-                # Store current view state
-                current_xlim = self.parent().ax.get_xlim()
-                current_ylim = self.parent().ax.get_ylim()
 
                 try:
                     x, y = self.parent().get_current_mouse_position()
@@ -12864,7 +13038,7 @@ class MachineWindow(QMainWindow):
 
                 if not self.parent().painting:
                     # Only update if view limits are valid
-                    self.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
+                    self.parent().update_display()
                     
                     self._last_update = current_time
             except Exception as e:
@@ -12978,7 +13152,8 @@ class MachineWindow(QMainWindow):
                             pass
                         
                         self.parent().machine_window = None
-                        event.accept()  # IMPORTANT: Accept the close event
+                        self.parent().highlight_overlay = None
+                        event.accept()
                     else:
                         event.ignore()  # User cancelled, ignore the close
                 else:
@@ -13074,17 +13249,11 @@ class SegmentationWorker(QThread):
                 current_time = time.time()
                 if (self.chunks_since_update >= self.chunks_per_update and 
                     current_time - self.last_update >= self.update_interval):
-                    #if self.machine_window.parent().shape[1] * self.machine_window.parent().shape[2] > 3000 * 3000: #arbitrary throttle for large arrays.
-                        #self.msleep(3000)
                     self.chunk_processed.emit()
                     self.chunks_since_update = 0
                     self.last_update = current_time 
-            
-            current_xlim = self.machine_window.parent().ax.get_xlim()
-
-            current_ylim = self.machine_window.parent().ax.get_ylim()
 
-            self.machine_window.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
+            self.machine_window.parent().update_display()
 
             self.finished.emit()
 
@@ -13509,6 +13678,8 @@ class ThresholdWindow(QMainWindow):
             channel_data = self.parent().channel_data[self.parent().active_channel]
             mask = self.parent().highlight_overlay > 0
             channel_data = channel_data * mask
+            self.parent().thresh_min = self.prev_min
+            self.parent().thresh_max = self.prev_max
             self.parent().load_channel(self.parent().active_channel, channel_data, True)
             self.parent().update_display()
             self.close()
@@ -13863,7 +14034,7 @@ class FilamentDialog(QDialog):
         speedup_group = QGroupBox("Speedup")
         speedup_layout = QFormLayout()
         self.kernel_spacing = QLineEdit("3")
-        speedup_layout.addRow("Kernel Spacing (1 is most accurate, can increase to speed up):", self.kernel_spacing)
+        speedup_layout.addRow("Kernel Spacing (lower is more sensitive to gaps, can increase to speed up or if too many gaps filled):", self.kernel_spacing)
         self.downsample_factor = QLineEdit("1")
         speedup_layout.addRow("Temporary Downsample Factor (Note that the below distances are not adjusted for this):", self.downsample_factor)
         speedup_group.setLayout(speedup_layout)
@@ -13874,7 +14045,7 @@ class FilamentDialog(QDialog):
         reconnection_layout = QFormLayout()
         self.max_distance = QLineEdit("20")
         reconnection_layout.addRow("Max Distance to Consider Connecting Filaments (Will Slow Down a lot if Large):", self.max_distance)
-        self.gap_tolerance = QLineEdit("5")
+        self.gap_tolerance = QLineEdit("6")
         reconnection_layout.addRow("Gap Tolerance. Higher Values Increase Likelihood of Connecting over Larger Gaps:", self.gap_tolerance)
         self.score_threshold = QLineEdit("2")
         reconnection_layout.addRow("Connection Quality Threshold. Lower Values Increase Likelihood of Connecting In General, can be Negative:", self.score_threshold)
@@ -13894,6 +14065,8 @@ class FilamentDialog(QDialog):
         artifact_layout.addRow("Remove Branch Spines Below this Length?", self.spine_removal)
         artifact_group.setLayout(artifact_layout)
         main_layout.addWidget(artifact_group)
+        self.state = None
+        self.first = True
 
     
         # Run Button
@@ -13922,8 +14095,9 @@ class FilamentDialog(QDialog):
 
             if downsample_factor and downsample_factor > 1:
                 data = n3d.downsample(data, downsample_factor)
+                self.state = None
 
-            result = filaments.trace(data, kernel_spacing, max_distance, min_component, gap_tolerance, blob_sphericity, blob_volume, spine_removal, score_threshold, my_network.xy_scale, my_network.z_scale)
+            result, self.state = filaments.trace(data, kernel_spacing, max_distance, min_component, gap_tolerance, blob_sphericity, blob_volume, spine_removal, score_threshold, my_network.xy_scale, my_network.z_scale, cached_state = self.state)
 
             if downsample_factor and downsample_factor > 1:
 
@@ -13932,51 +14106,22 @@ class FilamentDialog(QDialog):
 
             self.parent().load_channel(3, result, True)
 
-            self.accept()
+            if self.first:
+                QMessageBox.information(
+                    self,
+                    "Success",
+                    f"Filaments traced succesfully. Heavy computations are cached while this menu is open and so re-computing with different params will be fast. Feel free to try out other params. Altering kernel spacing, downsampling, or spine removal will reset this cache, however."
+                )
+                self.first = False
 
         except Exception as e:
             import traceback
             print(traceback.format_exc())
             print(f"Error: {e}")
 
-    def wait_for_threshold_processing(self):
-        """
-        Opens ThresholdWindow and waits for user to process the image.
-        Returns True if completed, False if cancelled.
-        The thresholded image will be available in the main window after completion.
-        """
-        # Create event loop to wait for user
-        loop = QEventLoop()
-        result = {'completed': False}
-        
-        # Create the threshold window
-        thresh_window = ThresholdWindow(self.parent(), 0)
-
-        
-        # Connect signals
-        def on_processing_complete():
-            result['completed'] = True
-            loop.quit()
-            
-        def on_processing_cancelled():
-            result['completed'] = False
-            loop.quit()
-        
-        thresh_window.processing_complete.connect(on_processing_complete)
-        thresh_window.processing_cancelled.connect(on_processing_cancelled)
-        
-        # Show window and wait
-        thresh_window.show()
-        thresh_window.raise_()
-        thresh_window.activateWindow()
-        
-        # Block until user clicks "Apply Threshold & Continue" or "Cancel"
-        loop.exec()
-        
-        # Clean up
-        thresh_window.deleteLater()
-        
-        return result['completed']
+    def closeEvent(self, event):
+        self.state = None
+        event.accept()
 
 
 
@@ -15064,6 +15209,8 @@ class GenNodesDialog(QDialog):
                 my_network.xy_scale = my_network.xy_scale * down_factor
                 my_network.z_scale = my_network.z_scale * down_factor
                 print("xy_scales and z_scales have been adjusted per downsample. Check image -> properties to manually reset them to 1 if desired.")
+                self.parent().xy_scale_label.setText(f"xy_scale: {my_network.xy_scale:.2e}                   ")
+                self.parent().z_scale_label.setText(f"z_scale: {my_network.z_scale:.2e}                   ")
 
             try: #Resets centroid fields
                 if my_network.node_centroids is not None:
@@ -15390,7 +15537,7 @@ class AlterDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
         self.setWindowTitle("Enter Node/Edge groups to add/remove")
-        self.setModal(True)
+        self.setModal(False)
         layout = QFormLayout(self)
         
         # Node 1
@@ -15432,10 +15579,7 @@ class AlterDialog(QDialog):
                 # Add edge value (0 if none provided)
                 my_network.network_lists[2].append(edge if edge is not None else 0)
                 
-                # Add reverse pair with same edge value
-                my_network.network_lists[0].append(node2)
-                my_network.network_lists[1].append(node1)
-                my_network.network_lists[2].append(edge if edge is not None else 0)
+                my_network.network_lists = my_network.network_lists
             try:
                 if hasattr(my_network, 'network_lists'):
                     model = PandasModel(my_network.network_lists)
@@ -15443,6 +15587,8 @@ class AlterDialog(QDialog):
                     # Adjust column widths to content
                     for column in range(model.columnCount(None)):
                         self.parent().network_table.resizeColumnToContents(column)
+                    self.parent().clear_subgraphs()
+                    self.parent().network_graph_widget.set_graph(my_network.network)
             except Exception as e:
                 print(f"Error showing network table: {e}")
         except ValueError:
@@ -15482,6 +15628,7 @@ class AlterDialog(QDialog):
                     my_network.network_lists[0].pop(i)
                     my_network.network_lists[1].pop(i)
                     my_network.network_lists[2].pop(i)
+                my_network.network_lists = my_network.network_lists
 
             try:
                 if hasattr(my_network, 'network_lists'):
@@ -15490,6 +15637,8 @@ class AlterDialog(QDialog):
                     # Adjust column widths to content
                     for column in range(model.columnCount(None)):
                         self.parent().network_table.resizeColumnToContents(column)
+                    self.parent().clear_subgraphs()
+                    self.parent().network_graph_widget.set_graph(my_network.network)
             except Exception as e:
                 print(f"Error showing network table: {e}")
                     
@@ -15544,7 +15693,7 @@ class ModifyDialog(QDialog):
         self.edgeweight = QPushButton("Remove weights")
         self.edgeweight.setCheckable(True)
         self.edgeweight.setChecked(False)
-        layout.addRow("Remove network weights?:", self.edgeweight)
+        layout.addRow("Remove network weights (Represent Duplicate Connections)?:", self.edgeweight)
         
         # prune checkbox (default false)
         self.prune = QPushButton("Prune Same Type")
@@ -15588,7 +15737,7 @@ class ModifyDialog(QDialog):
     def show_alter_dialog(self):
 
         dialog = AlterDialog(self.parent())
-        dialog.exec()
+        dialog.show()
 
     def run_changes(self):
 
@@ -15696,6 +15845,8 @@ class ModifyDialog(QDialog):
                     # Adjust column widths to content
                     for column in range(model.columnCount(None)):
                         self.parent().network_table.resizeColumnToContents(column)
+                    self.parent().clear_subgraphs()
+                    self.parent().network_graph_widget.set_graph(my_network.network)
             except Exception as e:
                 print(f"Error showing network table: {e}")
 
@@ -15773,6 +15924,8 @@ class CentroidDialog(QDialog):
                     down_factor = downsample
                 )
                 self.parent().network_graph_widget.centroids = my_network.node_centroids
+                self.parent().selection_graph_widget.centroids = my_network.node_centroids
+
 
             elif chan == 2:
                 my_network.calculate_edge_centroids(
@@ -15785,6 +15938,7 @@ class CentroidDialog(QDialog):
                         down_factor = downsample
                     )
                     self.parent().network_graph_widget.centroids = my_network.node_centroids
+                    self.parent().selection_graph_widget.centroids = my_network.node_centroids
 
                 except:
                     pass
@@ -16108,17 +16262,38 @@ class CalcAllDialog(QDialog):
 
                 from . import network_analysis
 
-                new_lists = network_analysis.combine_lists_to_sublists(temp_network.network_lists)
-                old_lists = network_analysis.combine_lists_to_sublists(my_network.network_lists)
-
-                filtered_new_lists = [pair for pair in new_lists if pair not in old_lists]
-
-                list1, list2, list3 = zip(*filtered_new_lists)
+                new_lists = network_analysis.combine_lists_to_sublists_no_edges([temp_network.network_lists[0], temp_network.network_lists[1]])
+                old_lists = network_analysis.combine_lists_to_sublists_no_edges([my_network.network_lists[0], my_network.network_lists[1]])
+                ref_lists = network_analysis.combine_lists_to_sublists(my_network.network_lists)
+                old_dict = {}
+                for i, pair in enumerate(old_lists):
+                    # Store both orientations of the pair
+                    old_dict[tuple(pair)] = i
+                    old_dict[tuple(reversed(pair))] = i
+
+                output_lists = []
+                used_indices = set()
+
+                for pair in new_lists:
+                    pair_tuple = tuple(pair)
+                    if pair_tuple in old_dict:
+                        idx = old_dict[pair_tuple]
+                        if idx not in used_indices:
+                            output_lists.append(ref_lists[idx])
+                            used_indices.add(idx)
+
+                # Clean up old_lists and ref_lists by removing used items
+                # Delete in reverse order to maintain indices
+                for idx in sorted(used_indices, reverse=True):
+                    del ref_lists[idx]
+                    del old_lists[idx]
+
+                list1, list2, list3 = zip(*output_lists)
 
                 # Convert them back to lists (zip returns tuples by default)
-                filtered_new_lists = [list(list1), list(list2), list(list3)]
+                output_lists = [list(list1), list(list2), list(list3)]
 
-                my_network.network_lists = filtered_new_lists
+                my_network.network_lists = output_lists
                 del temp_network
 
             if edge_node and not labeled_branches:
@@ -16139,6 +16314,8 @@ class CalcAllDialog(QDialog):
 
             self.parent().clear_subgraphs()
             self.parent().network_graph_widget.set_graph(my_network.network)
+            self.parent().xy_scale_label.setText(f"xy_scale: {my_network.xy_scale:.2e}                   ")
+            self.parent().z_scale_label.setText(f"z_scale: {my_network.z_scale:.2e}                   ")
             # Then handle overlays
             if overlays:
                 if directory is None:
@@ -16355,7 +16532,8 @@ class ProxDialog(QDialog):
 
             my_network.xy_scale = xy_scale
             my_network.z_scale = z_scale
-
+            self.parent().xy_scale_label.setText(f"xy_scale: {my_network.xy_scale:.2e}                   ")
+            self.parent().z_scale_label.setText(f"z_scale: {my_network.z_scale:.2e}                   ")
 
             if mode == 1:
                 if len(np.unique(my_network.nodes)) < 3:
@@ -16464,628 +16642,6 @@ class ProxDialog(QDialog):
             import traceback
             print(traceback.format_exc())
 
-
-class HistogramSelector(QWidget):
-    def __init__(self, network_analysis_instance, stats_dict):
-        super().__init__()
-        self.network_analysis = network_analysis_instance
-        self.stats_dict = stats_dict
-        self.G = my_network.network 
-        self.init_ui()
-        
-    def init_ui(self):
-        self.setWindowTitle('Network Analysis - Histogram Selector')
-        self.setGeometry(300, 300, 400, 700)  # Increased height for more buttons
-        
-        layout = QVBoxLayout()
-        
-        # Title label
-        title_label = QLabel('Select Histogram to Generate:')
-        title_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-        title_label.setStyleSheet("font-size: 16px; font-weight: bold; margin: 10px;")
-        layout.addWidget(title_label)
-        
-        # Create buttons for each histogram type
-        self.create_button(layout, "Shortest Path Length Distribution", self.shortest_path_histogram)
-        self.create_button(layout, "Degree Centrality", self.degree_centrality_histogram)
-        self.create_button(layout, "Betweenness Centrality", self.betweenness_centrality_histogram)
-        self.create_button(layout, "Closeness Centrality", self.closeness_centrality_histogram)
-        self.create_button(layout, "Eigenvector Centrality", self.eigenvector_centrality_histogram)
-        self.create_button(layout, "Clustering Coefficient", self.clustering_coefficient_histogram)
-        self.create_button(layout, "Degree Distribution", self.degree_distribution_histogram)
-        self.create_button(layout, "Node Connectivity", self.node_connectivity_histogram)
-        self.create_button(layout, "Eccentricity", self.eccentricity_histogram)
-        self.create_button(layout, "K-Core Decomposition", self.kcore_histogram)
-        self.create_button(layout, "Triangle Count", self.triangle_count_histogram)
-        self.create_button(layout, "Load Centrality", self.load_centrality_histogram)
-        self.create_button(layout, "Communicability Betweenness Centrality", self.communicability_centrality_histogram)
-        self.create_button(layout, "Harmonic Centrality", self.harmonic_centrality_histogram)
-        self.create_button(layout, "Current Flow Betweenness", self.current_flow_betweenness_histogram)
-        self.create_button(layout, "Dispersion", self.dispersion_histogram)
-        self.create_button(layout, "Network Bridges", self.bridges_analysis)
-        
-        # Close button
-        close_button = QPushButton('Close')
-        close_button.clicked.connect(self.close)
-        close_button.setStyleSheet("QPushButton { background-color: #f44336; color: white; font-weight: bold; }")
-        layout.addWidget(close_button)
-        
-        self.setLayout(layout)
-
-    def create_button(self, layout, text, callback):
-        button = QPushButton(text)
-        button.clicked.connect(callback)
-        button.setMinimumHeight(40)
-        button.setStyleSheet("""
-            QPushButton {
-                background-color: #4CAF50;
-                color: white;
-                border: none;
-                padding: 10px;
-                font-size: 14px;
-                font-weight: bold;
-                border-radius: 5px;
-            }
-            QPushButton:hover {
-                background-color: #45a049;
-            }
-            QPushButton:pressed {
-                background-color: #3d8b40;
-            }
-        """)
-        layout.addWidget(button)
-
-
-    def shortest_path_histogram(self):
-        try:
-            # 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, max_diameter + 1), height=freq_percent)
-            ax.set_title(
-                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=f"Distribution of shortest path length in G{title_suffix}"
-            )
-            
-        except Exception as e:
-            print(f"Error generating shortest path histogram: {e}")
-    
-    def degree_centrality_histogram(self):
-        try:
-            degree_centrality = nx.centrality.degree_centrality(self.G)
-            plt.figure(figsize=(15, 8))
-            plt.hist(degree_centrality.values(), bins=25)
-            plt.xticks(ticks=[0, 0.025, 0.05, 0.1, 0.15, 0.2])
-            plt.title("Degree Centrality Histogram ", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Degree Centrality", fontdict={"size": 20})
-            plt.ylabel("Counts", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['Degree Centrality'] = degree_centrality
-            self.network_analysis.format_for_upperright_table(degree_centrality, metric='Node', 
-                                                            value='Degree Centrality', 
-                                                            title="Degree Centrality Table")
-        except Exception as e:
-            print(f"Error generating degree centrality histogram: {e}")
-
-    def betweenness_centrality_histogram(self):
-        try:
-            # 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(
-                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.stats_dict['Betweenness Centrality'] = betweenness_centrality
-            
-            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}")
-    
-    def closeness_centrality_histogram(self):
-        try:
-            closeness_centrality = nx.centrality.closeness_centrality(self.G)
-            plt.figure(figsize=(15, 8))
-            plt.hist(closeness_centrality.values(), bins=60)
-            plt.title("Closeness Centrality Histogram ", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Closeness Centrality", fontdict={"size": 20})
-            plt.ylabel("Counts", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['Closeness Centrality'] = closeness_centrality
-            self.network_analysis.format_for_upperright_table(closeness_centrality, metric='Node', 
-                                                            value='Closeness Centrality', 
-                                                            title="Closeness Centrality Table")
-        except Exception as e:
-            print(f"Error generating closeness centrality histogram: {e}")
-    
-    def eigenvector_centrality_histogram(self):
-        try:
-            eigenvector_centrality = nx.centrality.eigenvector_centrality(self.G)
-            plt.figure(figsize=(15, 8))
-            plt.hist(eigenvector_centrality.values(), bins=60)
-            plt.xticks(ticks=[0, 0.01, 0.02, 0.04, 0.06, 0.08])
-            plt.title("Eigenvector Centrality Histogram ", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Eigenvector Centrality", fontdict={"size": 20})
-            plt.ylabel("Counts", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['Eigenvector Centrality'] = eigenvector_centrality
-            self.network_analysis.format_for_upperright_table(eigenvector_centrality, metric='Node', 
-                                                            value='Eigenvector Centrality', 
-                                                            title="Eigenvector Centrality Table")
-        except Exception as e:
-            print(f"Error generating eigenvector centrality histogram: {e}")
-    
-    def clustering_coefficient_histogram(self):
-        try:
-            clusters = nx.clustering(self.G)
-            plt.figure(figsize=(15, 8))
-            plt.hist(clusters.values(), bins=50)
-            plt.title("Clustering Coefficient Histogram ", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Clustering Coefficient", fontdict={"size": 20})
-            plt.ylabel("Counts", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['Clustering Coefficient'] = clusters
-            self.network_analysis.format_for_upperright_table(clusters, metric='Node', 
-                                                            value='Clustering Coefficient', 
-                                                            title="Clustering Coefficient Table")
-        except Exception as e:
-            print(f"Error generating clustering coefficient histogram: {e}")
-    
-    def bridges_analysis(self):
-        try:
-            bridges = list(nx.bridges(self.G))
-            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}")
-    
-    def degree_distribution_histogram(self):
-        """Raw degree distribution - very useful for understanding network topology"""
-        try:
-            degrees = [self.G.degree(n) for n in self.G.nodes()]
-            plt.figure(figsize=(15, 8))
-            plt.hist(degrees, bins=max(30, int(np.sqrt(len(degrees)))), alpha=0.7)
-            plt.title("Degree Distribution", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Degree", fontdict={"size": 20})
-            plt.ylabel("Frequency", fontdict={"size": 20})
-            plt.yscale('log')  # Often useful for degree distributions
-            plt.show()
-            
-            degree_dict = {node: deg for node, deg in self.G.degree()}
-            self.network_analysis.format_for_upperright_table(degree_dict, metric='Node', 
-                                                            value='Degree', title="Degree Distribution Table")
-        except Exception as e:
-            print(f"Error generating degree distribution histogram: {e}")
-    
-
-    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:
-                print("Note this analysis may be slow for large network (>500 nodes)")
-                #return
-                
-            connectivity = {}
-            for node in self.G.nodes():
-                neighbors = list(self.G.neighbors(node))
-                if len(neighbors) > 1:
-                    connectivity[node] = nx.node_connectivity(self.G, neighbors[0], neighbors[1])
-                else:
-                    connectivity[node] = 0
-            
-            plt.figure(figsize=(15, 8))
-            plt.hist(connectivity.values(), bins=20, alpha=0.7)
-            plt.title("Node Connectivity Distribution", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Node Connectivity", fontdict={"size": 20})
-            plt.ylabel("Frequency", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['Node Connectivity'] = connectivity
-            self.network_analysis.format_for_upperright_table(connectivity, metric='Node', 
-                                                            value='Connectivity', title="Node Connectivity Table")
-        except Exception as e:
-            print(f"Error generating node connectivity histogram: {e}")
-    
-    def eccentricity_histogram(self):
-        """Eccentricity - maximum distance from a node to any other node"""
-        try:
-            if not nx.is_connected(self.G):
-                print("Graph is not connected. Using largest connected component.")
-                largest_cc = max(nx.connected_components(self.G), key=len)
-                G_cc = self.G.subgraph(largest_cc)
-                eccentricity = nx.eccentricity(G_cc)
-            else:
-                eccentricity = nx.eccentricity(self.G)
-            
-            plt.figure(figsize=(15, 8))
-            plt.hist(eccentricity.values(), bins=20, alpha=0.7)
-            plt.title("Eccentricity Distribution", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Eccentricity", fontdict={"size": 20})
-            plt.ylabel("Frequency", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['Eccentricity'] = eccentricity
-            self.network_analysis.format_for_upperright_table(eccentricity, metric='Node', 
-                                                            value='Eccentricity', title="Eccentricity Table")
-        except Exception as e:
-            print(f"Error generating eccentricity histogram: {e}")
-    
-    def kcore_histogram(self):
-        """K-core decomposition - identifies cohesive subgroups"""
-        try:
-            kcore = nx.core_number(self.G)
-            plt.figure(figsize=(15, 8))
-            plt.hist(kcore.values(), bins=max(5, max(kcore.values())), alpha=0.7)
-            plt.title("K-Core Distribution", fontdict={"size": 35}, loc="center")
-            plt.xlabel("K-Core Number", fontdict={"size": 20})
-            plt.ylabel("Frequency", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['K-Core'] = kcore
-            self.network_analysis.format_for_upperright_table(kcore, metric='Node', 
-                                                            value='K-Core', title="K-Core Table")
-        except Exception as e:
-            print(f"Error generating k-core histogram: {e}")
-    
-    def triangle_count_histogram(self):
-        """Number of triangles each node participates in"""
-        try:
-            triangles = nx.triangles(self.G)
-            plt.figure(figsize=(15, 8))
-            plt.hist(triangles.values(), bins=30, alpha=0.7)
-            plt.title("Triangle Count Distribution", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Number of Triangles", fontdict={"size": 20})
-            plt.ylabel("Frequency", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['Triangle Count'] = triangles
-            self.network_analysis.format_for_upperright_table(triangles, metric='Node', 
-                                                            value='Triangle Count', title="Triangle Count Table")
-        except Exception as e:
-            print(f"Error generating triangle count histogram: {e}")
-    
-    def load_centrality_histogram(self):
-        """Load centrality - fraction of shortest paths passing through each node"""
-        try:
-            if self.G.number_of_nodes() > 1000:
-                print("Note this analysis may be slow for large network (>1000 nodes)")
-                #return
-                
-            load_centrality = nx.load_centrality(self.G)
-            plt.figure(figsize=(15, 8))
-            plt.hist(load_centrality.values(), bins=50, alpha=0.7)
-            plt.title("Load Centrality Distribution", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Load Centrality", fontdict={"size": 20})
-            plt.ylabel("Frequency", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['Load Centrality'] = load_centrality
-            self.network_analysis.format_for_upperright_table(load_centrality, metric='Node', 
-                                                            value='Load Centrality', title="Load Centrality Table")
-        except Exception as e:
-            print(f"Error generating load centrality histogram: {e}")
-    
-    def communicability_centrality_histogram(self):
-        """Communicability centrality - based on communicability between nodes"""
-        try:
-            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)"
-                
-            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(
-                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})
-            self.stats_dict['Communicability Betweenness Centrality'] = comm_centrality
-            plt.show()
-            
-            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}")
-    
-    def harmonic_centrality_histogram(self):
-        """Harmonic centrality - better than closeness for disconnected networks"""
-        try:
-            harmonic_centrality = nx.harmonic_centrality(self.G)
-            plt.figure(figsize=(15, 8))
-            plt.hist(harmonic_centrality.values(), bins=50, alpha=0.7)
-            plt.title("Harmonic Centrality Distribution", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Harmonic Centrality", fontdict={"size": 20})
-            plt.ylabel("Frequency", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['Harmonic Centrality Distribution'] = harmonic_centrality
-            self.network_analysis.format_for_upperright_table(harmonic_centrality, metric='Node', 
-                                                            value='Harmonic Centrality', 
-                                                            title="Harmonic Centrality Table")
-        except Exception as e:
-            print(f"Error generating harmonic centrality histogram: {e}")
-    
-    def current_flow_betweenness_histogram(self):
-        """Current flow betweenness - models network as electrical circuit"""
-        try:
-            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.")
-                
-                # 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(
-                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.stats_dict['Current Flow Betweenness Centrality'] = current_flow            
-            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}")
-    
-    def dispersion_histogram(self):
-        """Dispersion - measures how scattered a node's neighbors are"""
-        try:
-            if self.G.number_of_nodes() > 300:  # Skip for large networks (very computationally expensive)
-                print("Note this analysis may be slow for large network (>300 nodes)")
-                #return
-                
-            # Calculate average dispersion for each node
-            dispersion_values = {}
-            nodes = list(self.G.nodes())
-            
-            for u in nodes:
-                if self.G.degree(u) < 2:  # Need at least 2 neighbors for dispersion
-                    dispersion_values[u] = 0
-                    continue
-                    
-                # Calculate dispersion for node u with all its neighbors
-                neighbors = list(self.G.neighbors(u))
-                if len(neighbors) < 2:
-                    dispersion_values[u] = 0
-                    continue
-                
-                # Get dispersion scores for this node with all neighbors
-                disp_scores = []
-                for v in neighbors:
-                    try:
-                        disp_score = nx.dispersion(self.G, u, v)
-                        disp_scores.append(disp_score)
-                    except:
-                        continue
-                
-                # Average dispersion for this node
-                dispersion_values[u] = sum(disp_scores) / len(disp_scores) if disp_scores else 0
-            
-            plt.figure(figsize=(15, 8))
-            plt.hist(dispersion_values.values(), bins=30, alpha=0.7)
-            plt.title("Average Dispersion Distribution", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Average Dispersion", fontdict={"size": 20})
-            plt.ylabel("Frequency", fontdict={"size": 20})
-            plt.show()
-            self.stats_dict['Dispersion'] = dispersion_values            
-            self.network_analysis.format_for_upperright_table(dispersion_values, metric='Node', 
-                                                            value='Average Dispersion', 
-                                                            title="Average Dispersion Table")
-        except Exception as e:
-            print(f"Error generating dispersion histogram: {e}")
-
 class TutorialSelectionDialog(QWidget):
     """Dialog for selecting which tutorial to run"""