nettracer3d 0.8.9__py3-none-any.whl → 0.9.0__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -102,7 +102,7 @@ class ImageViewerWindow(QMainWindow):
         "WHITE": (1, 1, 1),
         "GRAY": (0.5, 0.5, 0.5),
         "LIGHT_GRAY": (0.8, 0.8, 0.8),
-        "DARK_GRAY": (0.2, 0.2, 0.2)
+        "DARK_GRAY": (0.2, 0.2, 0.2),
         }
 
         self.base_colors = [ #Channel colors
@@ -3471,12 +3471,10 @@ class ImageViewerWindow(QMainWindow):
         stats_menu = analysis_menu.addMenu("Stats")
         allstats_action = stats_menu.addAction("Calculate Generic Network Stats")
         allstats_action.triggered.connect(self.stats)
-        histos_action = stats_menu.addAction("Calculate Generic Network Histograms")
+        histos_action = stats_menu.addAction("Network Statistic Histograms")
         histos_action.triggered.connect(self.histos)
         radial_action = stats_menu.addAction("Radial Distribution Analysis")
         radial_action.triggered.connect(self.show_radial_dialog)
-        degree_dist_action = stats_menu.addAction("Degree Distribution Analysis")
-        degree_dist_action.triggered.connect(self.show_degree_dist_dialog)
         neighbor_id_action = stats_menu.addAction("Identity Distribution of Neighbors")
         neighbor_id_action.triggered.connect(self.show_neighbor_id_dialog)
         ripley_action = stats_menu.addAction("Ripley Clustering Analysis")
@@ -3515,7 +3513,7 @@ class ImageViewerWindow(QMainWindow):
 
         # Process menu
         process_menu = menubar.addMenu("Process")
-        calculate_menu = process_menu.addMenu("Calculate")
+        calculate_menu = process_menu.addMenu("Calculate Network")
         calc_all_action = calculate_menu.addAction("Calculate Connectivity Network (Find Node-Edge-Node Network)")
         calc_all_action.triggered.connect(self.show_calc_all_dialog)
         calc_prox_action = calculate_menu.addAction("Calculate Proximity Network (connect nodes by distance)")
@@ -3615,46 +3613,75 @@ class ImageViewerWindow(QMainWindow):
         menubar.setCornerWidget(cam_button, Qt.Corner.TopRightCorner)
 
     def snap(self):
-
         try:
-
+            # Check if we have any data to save
+            data = False
             for thing in self.channel_data:
                 if thing is not None:
                     data = True
+                    break
             if not data:
                 return
-
-            snap = self.create_composite_for_pan()
-
+            
+            # Get filename from user
             filename, _ = QFileDialog.getSaveFileName(
                 self,
                 f"Save Image As",
-                "",  # Default directory
-                "TIFF Files (*.tif *.tiff);;All Files (*)"  # File type filter
+                "",
+                "PNG Files (*.png);;TIFF Files (*.tif *.tiff);;JPEG Files (*.jpg *.jpeg);;All Files (*)"
             )
             
-            if filename:  # Only proceed if user didn't cancel
-                # If user didn't type an extension, add .tif
-                if not filename.endswith(('.tif', '.tiff')):
-                    filename += '.tif'
-
-            import tifffile
-            tifffile.imwrite(filename, snap)
-
-        except:
-            pass
+            if filename:
+                # Determine file extension
+                if filename.lower().endswith(('.tif', '.tiff')):
+                    format_type = 'tiff'
+                elif filename.lower().endswith(('.jpg', '.jpeg')):
+                    format_type = 'jpeg'
+                elif filename.lower().endswith('.png'):
+                    format_type = 'png'
+                else:
+                    filename += '.png'
+                    format_type = 'png'
+                
+                # Method 1: Save with axes bbox (recommended)
+                bbox = self.ax.get_window_extent().transformed(self.figure.dpi_scale_trans.inverted())
+                self.figure.savefig(filename,
+                                  dpi=300,
+                                  bbox_inches=bbox,
+                                  facecolor='black',
+                                  edgecolor='none',
+                                  format=format_type,
+                                  pad_inches=0)
+                
+                print(f"Axes snapshot saved: {filename}")
+                
+        except Exception as e:
+            print(f"Error saving snapshot: {e}")
 
 
     def open_cellpose(self):
 
+        try:
+            if self.shape[0] == 1:
+                use_3d = False
+                print("Launching 2D cellpose GUI")
+            else:
+                use_3d = True
+                print("Launching 3D cellpose GUI")
+        except:
+            use_3d = True
+            print("Launching 3D cellpose GUI")
+
         try:
 
             from . import cellpose_manager
             self.cellpose_launcher = cellpose_manager.CellposeGUILauncher(parent_widget=self)
 
-            self.cellpose_launcher.launch_cellpose_gui()
+            self.cellpose_launcher.launch_cellpose_gui(use_3d = use_3d)
 
         except:
+            import traceback
+            print(traceback.format_exc())
             pass
 
 
@@ -3680,106 +3707,26 @@ class ImageViewerWindow(QMainWindow):
             print(f"Error finding stats: {e}")
 
     def histos(self):
-
-        """from networkx documentation"""
-
+        """
+        Show a PyQt6 window with buttons to select which histogram to generate.
+        Only calculates the histogram that the user selects.
+        """
         try:
-
-            G = my_network.network
-
-            shortest_path_lengths = dict(nx.all_pairs_shortest_path_length(G))
-            diameter = max(nx.eccentricity(G, sp=shortest_path_lengths).values())
-            # We know the maximum shortest path length (the diameter), so create an array
-            # to store values from 0 up to (and including) diameter
-            path_lengths = np.zeros(diameter + 1, dtype=int)
-
-
-
-            # Extract the frequency of shortest path lengths between two nodes
-            for pls in shortest_path_lengths.values():
-                pl, cnts = np.unique(list(pls.values()), return_counts=True)
-                path_lengths[pl] += cnts
-
-            # Express frequency distribution as a percentage (ignoring path lengths of 0)
-            freq_percent = 100 * path_lengths[1:] / path_lengths[1:].sum()
-
-            # Plot the frequency distribution (ignoring path lengths of 0) as a percentage
-            fig, ax = plt.subplots(figsize=(15, 8))
-            ax.bar(np.arange(1, diameter + 1), height=freq_percent)
-            ax.set_title(
-                "Distribution of shortest path length in G", 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.format_for_upperright_table(freq_dict, metric='Frequency (%)', value='Shortest Path Length', title="Distribution of shortest path length in G")
-
-            degree_centrality = nx.centrality.degree_centrality(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])  # set the x axis ticks
-            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.format_for_upperright_table(degree_centrality, metric='Node', value='Degree Centrality', title="Degree Centrality Table")
-
-
-            betweenness_centrality = nx.centrality.betweenness_centrality(
-                G
-            )
-            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])  # set the x axis ticks
-            plt.title("Betweenness Centrality Histogram ", fontdict={"size": 35}, loc="center")
-            plt.xlabel("Betweenness Centrality", fontdict={"size": 20})
-            plt.ylabel("Counts", fontdict={"size": 20})
-            plt.show()
-            self.format_for_upperright_table(betweenness_centrality, metric='Node', value='Betweenness Centrality', title="Betweenness Centrality Table")
-
-
-            closeness_centrality = nx.centrality.closeness_centrality(
-                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.format_for_upperright_table(closeness_centrality, metric='Node', value='Closeness Centrality', title="Closeness Centrality Table")
-
-
-            eigenvector_centrality = nx.centrality.eigenvector_centrality(
-                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])  # set the x axis ticks
-            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.format_for_upperright_table(eigenvector_centrality, metric='Node', value='Eigenvector Centrality', title="Eigenvector Centrality Table")
-
-
-
-            clusters = nx.clustering(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.format_for_upperright_table(clusters, metric='Node', value='Clustering Coefficient', title="Clustering Coefficient Table")
-
-            bridges = list(nx.bridges(G))
-            self.format_for_upperright_table(bridges, metric = 'Node Pair', title="Bridges")
-
+            # Create QApplication if it doesn't exist
+            app = QApplication.instance()
+            if app is None:
+                app = QApplication(sys.argv)
+            
+            # Create and show the histogram selector window
+            self.histogram_selector = HistogramSelector(self)
+            self.histogram_selector.show()
+            
+            # Keep the window open (you might want to handle this differently based on your application structure)
+            if not app.exec():
+                pass  # Window was closed
+                
         except Exception as e:
-            print(f"Error generating histograms: {e}")
+            print(f"Error creating histogram selector: {e}")
 
     def volumes(self):
 
@@ -5271,21 +5218,38 @@ class ImageViewerWindow(QMainWindow):
                     else:
                         current_image = self.channel_data[channel]
 
-                    if is_rgb and self.channel_data[channel].shape[-1] == 3:
-                        # For RGB images, just display directly without colormap
-                        self.ax.imshow(current_image,
-                                     alpha=0.7)
-                    elif is_rgb and self.channel_data[channel].shape[-1] == 4:
-                        self.ax.imshow(current_image) #For images that already have an alpha value and RGB, don't update alpha
-
+                    if is_rgb and self.channel_data[channel].shape[-1] in [3, 4]:
+                        # For RGB/RGBA images, use brightness/contrast to control alpha instead
+                        
+                        # Calculate alpha based on brightness settings
+                        brightness_min = self.channel_brightness[channel]['min']
+                        brightness_max = self.channel_brightness[channel]['max']
+                        
+                        # Map brightness range to alpha range (0.0 to 1.0)
+                        # brightness_min controls minimum alpha, brightness_max controls maximum alpha
+                        alpha_range = brightness_max - brightness_min
+                        base_alpha = brightness_min                        
+                        # You can adjust these multipliers to control the alpha range
+                        final_alpha = base_alpha + alpha_range  # Scale to reasonable alpha range
+                        final_alpha = np.clip(final_alpha, 0.0, 1.0)  # Ensure valid alpha range
+                        
+                        # Display the image with brightness-controlled alpha
+                        if current_image.shape[-1] == 4:
+                            # For RGBA, multiply existing alpha by our brightness-controlled alpha
+                            img_with_alpha = current_image.copy()
+                            img_with_alpha[..., 3] = img_with_alpha[..., 3] * final_alpha
+                            self.ax.imshow(img_with_alpha)
+                        else:
+                            # For RGB, apply brightness-controlled alpha directly
+                            self.ax.imshow(current_image, alpha=final_alpha)
+                            
                     else:
-                        # Regular channel processing with colormap
+                        # Regular channel processing with colormap (your existing code)
                         # Calculate brightness/contrast limits from entire volume
-                        if self.min_max[channel][0] == None:
-                            self.min_max[channel][0] = np.min(channel)
-                        if self.min_max[channel][1] == None:
-                            self.min_max[channel][1] = np.max(channel)
-
+                        if self.min_max[channel][0] is None:
+                            self.min_max[channel][0] = np.min(self.channel_data[channel])
+                        if self.min_max[channel][1] is None:
+                            self.min_max[channel][1] = np.max(self.channel_data[channel])
                         img_min = self.min_max[channel][0]
                         img_max = self.min_max[channel][1]
                         
@@ -5344,7 +5308,7 @@ class ImageViewerWindow(QMainWindow):
                 )
                 self.ax.imshow(self.mini_overlay_data,
                              cmap=highlight_cmap,
-                             alpha=0.5)
+                             alpha=0.8)
             elif self.highlight_overlay is not None and self.highlight and self.machine_window is None:
                 highlight_slice = self.highlight_overlay[self.current_slice]
                 highlight_cmap = LinearSegmentedColormap.from_list(
@@ -5353,7 +5317,7 @@ class ImageViewerWindow(QMainWindow):
                 )
                 self.ax.imshow(highlight_slice,
                              cmap=highlight_cmap,
-                             alpha=0.5)
+                             alpha=0.8)
             elif self.highlight_overlay is not None and self.highlight:
                 highlight_slice = self.highlight_overlay[self.current_slice]
                 highlight_cmap = LinearSegmentedColormap.from_list(
@@ -5366,7 +5330,7 @@ class ImageViewerWindow(QMainWindow):
                              cmap=highlight_cmap,
                              vmin=0,
                              vmax=2,         # Important: set vmax to 2 to accommodate both values
-                             alpha=0.5)
+                             alpha=0.3)
 
             if self.channel_data[4] is not None:
 
@@ -5534,10 +5498,6 @@ class ImageViewerWindow(QMainWindow):
         dialog = RadialDialog(self)
         dialog.exec()
 
-    def show_degree_dist_dialog(self):
-        dialog = DegreeDistDialog(self)
-        dialog.exec()
-
     def show_neighbor_id_dialog(self):
         dialog = NeighborIdentityDialog(self)
         dialog.exec()
@@ -7122,6 +7082,15 @@ class ColorOverlayDialog(QDialog):
 
         layout = QFormLayout(self)
 
+        # Add mode selection dropdown
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["Nodes", "Edges"])
+        if self.parent().active_channel == 0 and self.parent().channel_data[0] is not None:
+            self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        else:
+            self.mode_selector.setCurrentIndex(1)  # Default to Mode 1
+        layout.addRow("Execution Mode:", self.mode_selector)
+
         self.down_factor = QLineEdit("")
         layout.addRow("down_factor (for speeding up overlay generation - optional):", self.down_factor)
 
@@ -7136,11 +7105,10 @@ class ColorOverlayDialog(QDialog):
 
             down_factor = float(self.down_factor.text()) if self.down_factor.text().strip() else None
 
-            if self.parent().active_channel == 0:
-                mode = 0
+            mode = self.mode_selector.currentIndex()
+            if mode == 0:
                 self.sort = 'Node'
             else:
-                mode = 1
                 self.sort = 'Edge'
 
 
@@ -7658,39 +7626,6 @@ class RadialDialog(QDialog):
         except Exception as e:
             print(f"An error occurred: {e}")
 
-class DegreeDistDialog(QDialog):
-
-    def __init__(self, parent=None):
-
-        super().__init__(parent)
-        self.setWindowTitle("Degree Distribution Parameters")
-        self.setModal(True)
-
-        layout = QFormLayout(self)
-
-        self.directory = QLineEdit("")
-        layout.addRow("Output Directory:", self.directory)
-
-        # Add Run button
-        run_button = QPushButton("Get Degree Distribution")
-        run_button.clicked.connect(self.degreedist)
-        layout.addWidget(run_button)
-
-    def degreedist(self):
-
-        try:
-
-            directory = str(self.distance.text()) if self.directory.text().strip() else None
-
-            degrees = my_network.degree_distribution(directory = directory)
-
-
-            self.parent().format_for_upperright_table(degrees, 'Degree (k)', 'Proportion of nodes with degree (p(k))', title = 'Degree Distribution Analysis')
-
-            self.accept()
-
-        except Exception as e:
-            print(f"An error occurred: {e}")
 
 class NearNeighDialog(QDialog):
     def __init__(self, parent=None):
@@ -7725,9 +7660,12 @@ class NearNeighDialog(QDialog):
         self.num = QLineEdit("1")
         identities_layout.addRow("Number of Nearest Neighbors to Evaluate Per Node?:", self.num)
 
-        
-        main_layout.addWidget(identities_group)
+        self.centroids = QPushButton("Centroids")
+        self.centroids.setCheckable(True)
+        self.centroids.setChecked(True)
+        identities_layout.addRow("Use Centroids? (Recommended for spheroids) Deselecting finds true nearest neighbors for mask but will be slower, and will only support a single nearest neighbor calculation for each root (rather than an avg)", self.centroids)
 
+        main_layout.addWidget(identities_group)
         
         # Optional Heatmap group box
         heatmap_group = QGroupBox("Optional Heatmap")
@@ -7761,39 +7699,71 @@ class NearNeighDialog(QDialog):
 
         main_layout.addWidget(quant_group)
         
-        # Get Distribution group box
+        # Get Distribution group box - ENHANCED STYLING
         distribution_group = QGroupBox("Get Distribution")
         distribution_layout = QVBoxLayout(distribution_group)
         
-        run_button = QPushButton("Get Average Nearest Neighbor (Plus Distribution)")
+        run_button = QPushButton("🔍 Get Average Nearest Neighbor (Plus Distribution)")
+        # Style for primary action - blue with larger font
+        run_button.setStyleSheet("""
+            QPushButton {
+                background-color: #2196F3;
+                color: white;
+                border: none;
+                padding: 12px 20px;
+                font-size: 14px;
+                font-weight: bold;
+                border-radius: 6px;
+            }
+            QPushButton:hover {
+                background-color: #1976D2;
+            }
+            QPushButton:pressed {
+                background-color: #0D47A1;
+            }
+        """)
         run_button.clicked.connect(self.run)
         distribution_layout.addWidget(run_button)
         
         main_layout.addWidget(distribution_group)
         
-        # Get All Averages group box (only if node_identities exists)
+        # Get All Averages group box - ENHANCED STYLING (only if node_identities exists)
         if my_network.node_identities is not None:
             averages_group = QGroupBox("Get All Averages")
             averages_layout = QVBoxLayout(averages_group)
             
-            run_button2 = QPushButton("Get Average Nearest All ID Combinations (No Distribution, No Heatmap)")
+            run_button2 = QPushButton("📊 Get Average Nearest All ID Combinations (No Distribution, No Heatmap)")
+            # Style for secondary action - green with different styling
+            run_button2.setStyleSheet("""
+                QPushButton {
+                    background-color: #4CAF50;
+                    color: white;
+                    border: 2px solid #45a049;
+                    padding: 10px 16px;
+                    font-size: 13px;
+                    font-weight: normal;
+                    border-radius: 8px;
+                }
+                QPushButton:hover {
+                    background-color: #45a049;
+                    border-color: #3d8b40;
+                }
+                QPushButton:pressed {
+                    background-color: #3d8b40;
+                }
+            """)
             run_button2.clicked.connect(self.run2)
             averages_layout.addWidget(run_button2)
             
             main_layout.addWidget(averages_group)
 
     def toggle_map(self):
-
         if self.numpy.isChecked():
-
             if not self.map.isChecked():
-
                 self.map.click()
 
     def run(self):
-
         try:
-
             try:
                 root = self.root.currentText()
             except:
@@ -7808,6 +7778,9 @@ class NearNeighDialog(QDialog):
             numpy = self.numpy.isChecked()
             num = int(self.num.text()) if self.num.text().strip() else 1
             quant = self.quant.isChecked()
+            centroids = self.centroids.isChecked()
+            if not centroids:
+                num = 1
 
             if root is not None and targ is not None:
                 title = f"Nearest {num} Neighbor(s) Distance of {targ} from {root}"
@@ -7818,15 +7791,15 @@ class NearNeighDialog(QDialog):
                 header = f"Shortest Distance to Closest {num} Nodes"
                 header2 = "Root Node ID"
 
-            if my_network.node_centroids is None:
+            if centroids and my_network.node_centroids is None:
                 self.parent().show_centroid_dialog()
                 if my_network.node_centroids is None:
                     return
 
             if not numpy:
-                avg, output, quant_overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant)
+                avg, output, quant_overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, quant = quant, centroids = centroids)
             else:
-                avg, output, overlay, quant_overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True, quant = quant)
+                avg, output, overlay, quant_overlay = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, heatmap = heatmap, threed = threed, numpy = True, quant = quant, centroids = centroids)
                 self.parent().load_channel(3, overlay, data = True)
 
             if quant_overlay is not None:
@@ -7840,27 +7813,24 @@ class NearNeighDialog(QDialog):
         except Exception as e:
             import traceback
             print(traceback.format_exc())
-
             print(f"Error: {e}")
 
     def run2(self):
-
         try:
-
             available = list(set(my_network.node_identities.values()))
-
             num = int(self.num.text()) if self.num.text().strip() else 1
 
+            centroids = self.centroids.isChecked()
+            if not centroids:
+                num = 1
+
             output_dict = {}
 
             while len(available) > 1:
-
                 root = available[0]
 
                 for targ in available:
-
-                    avg, _, _ = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num)
-
+                    avg, _, _ = my_network.nearest_neighbors_avg(root, targ, my_network.xy_scale, my_network.z_scale, num = num, centroids = centroids)
                     output_dict[f"{root} vs {targ}"] = avg
 
                 del available[0]
@@ -7870,7 +7840,6 @@ class NearNeighDialog(QDialog):
             self.accept()
 
         except Exception as e:
-
             print(f"Error: {e}")
 
 
@@ -10264,7 +10233,14 @@ class SegmentationWorker(QThread):
                     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.finished.emit()
+
             
         except Exception as e:
             print(f"Error in segmentation: {e}")
@@ -11331,7 +11307,7 @@ class SkeletonizeDialog(QDialog):
             )
 
             if remove > 0:
-                result = n3d.remove_branches(result, remove)
+                result = n3d.remove_branches_new(result, remove)
 
 
             # Update both the display data and the network object
@@ -13128,6 +13104,409 @@ class ProxDialog(QDialog):
             print(traceback.format_exc())
 
 
+class HistogramSelector(QWidget):
+    def __init__(self, network_analysis_instance):
+        super().__init__()
+        self.network_analysis = network_analysis_instance
+        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:
+            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
+
+            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.set_title(
+                "Distribution of shortest path length in G", 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")
+        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.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:
+            betweenness_centrality = nx.centrality.betweenness_centrality(self.G)
+            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.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")
+        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.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.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.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))
+            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:  # Skip for large networks (computationally expensive)
+                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.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.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.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.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:  # Skip for very large networks
+                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.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:  # Skip for large networks (memory intensive)
+                print("Note this analysis may be slow for large network (>500 nodes)")
+                #return
+                
+            # Use the correct function name - it's in the communicability module
+            comm_centrality = nx.communicability_betweenness_centrality(self.G)
+            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.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")
+        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.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:  # Skip for large networks (computationally expensive)
+                print("Note this analysis may be slow for large network (>500 nodes)")
+                #return
+                
+            current_flow = nx.current_flow_betweenness_centrality(self.G)
+            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.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")
+        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.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}")
+
+
 
 # Initiating this program from the script line: