nettracer3d 0.7.5__py3-none-any.whl → 0.7.7__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -5,7 +5,7 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QG
                             QFormLayout, QLineEdit, QPushButton, QFileDialog,
                             QLabel, QComboBox, QMessageBox, QTableView, QInputDialog,
                             QMenu, QTabWidget, QGroupBox)
-from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal)
+from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal, QObject, QCoreApplication)
 import numpy as np
 import time
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
@@ -26,6 +26,7 @@ from concurrent.futures import ThreadPoolExecutor
 from functools import partial
 from nettracer3d import segmenter
 from nettracer3d import segmenter_GPU
+from nettracer3d import excelotron
 
 
 
@@ -409,6 +410,11 @@ class ImageViewerWindow(QMainWindow):
         self.mini_overlay = False # If the program is currently drawing the overlay by frame this will be true
         self.mini_overlay_data = None #Actual data for mini overlay
         self.mini_thresh = (500*500*500) # Array volume to start using mini overlays for
+        self.shape = None
+
+        self.excel_manager = ExcelotronManager(self)
+        self.excel_manager.data_received.connect(self.handle_excel_data)
+        self.prev_coms = None
 
     def start_left_scroll(self):
         """Start scrolling left when left arrow is pressed."""
@@ -1448,7 +1454,7 @@ class ImageViewerWindow(QMainWindow):
 
         print("Note, this method is a tad slow...")
 
-        def separate_nontouching_objects(input_array):
+        def separate_nontouching_objects(input_array, max_val = 0):
             """
             Efficiently separate non-touching objects in a labeled array.
             
@@ -1483,7 +1489,7 @@ class ImageViewerWindow(QMainWindow):
             
             # Step 3: Create a new output array with unique labels for each connected component
             output_array = np.zeros_like(input_array)
-            next_label = 1
+            next_label = 1 + max_val
             
             # Map of (original_label, connected_component) -> new_unique_label
             unique_label_map = {}
@@ -1512,9 +1518,14 @@ class ImageViewerWindow(QMainWindow):
                 
                 # Get non-highlighted part of the array
                 non_highlighted = my_network.nodes * (~self.highlight_overlay)
+
+                if (highlighted_nodes==non_highlighted).all():
+                    max_val = 0
+                else:
+                    max_val = np.max(non_highlighted)
                 
                 # Process highlighted part
-                processed_highlights = separate_nontouching_objects(highlighted_nodes)
+                processed_highlights = separate_nontouching_objects(highlighted_nodes, max_val)
                 
                 # Combine back with non-highlighted parts
                 my_network.nodes = non_highlighted + processed_highlights
@@ -1534,9 +1545,14 @@ class ImageViewerWindow(QMainWindow):
                 
                 # Get non-highlighted part of the array
                 non_highlighted = my_network.edges * (~self.highlight_overlay)
+
+                if (highlighted_nodes==non_highlighted).all():
+                    max_val = 0
+                else:
+                    max_val = np.max(non_highlighted)
                 
                 # Process highlighted part
-                processed_highlights = separate_nontouching_objects(highlighted_edges)
+                processed_highlights = separate_nontouching_objects(highlighted_edges, max_val)
                 
                 # Combine back with non-highlighted parts
                 my_network.edges = non_highlighted + processed_highlights
@@ -1545,7 +1561,7 @@ class ImageViewerWindow(QMainWindow):
             
             self.highlight_overlay = None
             self.update_display()
-            print("Network is not updated automatically, please recompute if necessary. Identities are not automatically updated.")
+            print("Network is not updated automatically, please recompute if necessary - this method has a high chance of disrupting the network. Identities are not automatically updated.")
             self.show_centroid_dialog()
         except Exception as e:
             print(f"Error separating: {e}")
@@ -2670,6 +2686,8 @@ class ImageViewerWindow(QMainWindow):
             load_action.triggered.connect(lambda checked, ch=i: self.load_channel(ch))
         load_action = load_menu.addAction("Load Network")
         load_action.triggered.connect(self.load_network)
+        load_action = load_menu.addAction("Load From Excel Helper")
+        load_action.triggered.connect(self.launch_excelotron)
         misc_menu = load_menu.addMenu("Load Misc Properties")
         load_action = misc_menu.addAction("Load Node IDs")
         load_action.triggered.connect(lambda: self.load_misc('Node Identities'))
@@ -2686,10 +2704,14 @@ class ImageViewerWindow(QMainWindow):
         network_menu = analysis_menu.addMenu("Network")
         netshow_action = network_menu.addAction("Show Network")
         netshow_action.triggered.connect(self.show_netshow_dialog)
-        partition_action = network_menu.addAction("Community Partition +Generic Community Stats")
+        partition_action = network_menu.addAction("Community Partition + Generic Community Stats")
         partition_action.triggered.connect(self.show_partition_dialog)
-        com_identity_action = network_menu.addAction("Identity Makeup of Network Communities (Weighted avg by community size)")
+        com_identity_action = network_menu.addAction("Identity Makeup of Network Communities (and UMAP)")
         com_identity_action.triggered.connect(self.handle_com_id)
+        com_neighbor_action = network_menu.addAction("Convert Network Communities into Neighborhoods?")
+        com_neighbor_action.triggered.connect(self.handle_com_neighbor)
+        com_cell_action = network_menu.addAction("Create Communities Based on Cuboidal Proximity Cells?")
+        com_cell_action.triggered.connect(self.handle_com_cell)
         stats_menu = analysis_menu.addMenu("Stats")
         allstats_action = stats_menu.addAction("Calculate Generic Network Stats")
         allstats_action.triggered.connect(self.stats)
@@ -2758,6 +2780,8 @@ class ImageViewerWindow(QMainWindow):
         thresh_action.triggered.connect(self.show_thresh_dialog)
         mask_action = image_menu.addAction("Mask Channel")
         mask_action.triggered.connect(self.show_mask_dialog)
+        crop_action = image_menu.addAction("Crop Channels")
+        crop_action.triggered.connect(self.show_crop_dialog)
         type_action = image_menu.addAction("Channel dtype")
         type_action.triggered.connect(self.show_type_dialog)
         skeletonize_action = image_menu.addAction("Skeletonize")
@@ -2837,99 +2861,103 @@ class ImageViewerWindow(QMainWindow):
 
         """from networkx documentation"""
 
-        G = my_network.network
+        try:
 
-        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)
+            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()
+            # 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
 
-        # 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")
+            # 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")
+            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")
+            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")
+            bridges = list(nx.bridges(G))
+            self.format_for_upperright_table(bridges, metric = 'Node Pair', title="Bridges")
 
+        except Exception as e:
+            print(f"Error generating histograms: {e}")
 
     def volumes(self):
 
@@ -3121,6 +3149,11 @@ class ImageViewerWindow(QMainWindow):
         dialog = MaskDialog(self)
         dialog.exec()
 
+    def show_crop_dialog(self):
+        """Show the crop dialog"""
+        dialog = CropDialog(self)
+        dialog.exec()
+
     def show_type_dialog(self):
         """Show the type dialog"""
         try:
@@ -3539,6 +3572,103 @@ class ImageViewerWindow(QMainWindow):
                 f"Failed to load network: {str(e)}"
             )
 
+    def launch_excelotron(self):
+        """Method to launch Excelotron - call this from a button or menu"""
+        self.excel_manager.launch()
+    
+    def close_excelotron(self):
+        """Method to close Excelotron"""
+        self.excel_manager.close()
+    
+    def handle_excel_data(self, data_dict, property_name):
+        """Handle data received from Excelotron"""
+        print(f"Received data for property: {property_name}")
+        print(f"Data keys: {list(data_dict.keys())}")
+
+        if property_name == 'Node Centroids':
+
+            try:
+
+                ys = data_dict['Y']
+                xs = data_dict['X']
+                if 'Numerical IDs' in data_dict:
+                    nodes = data_dict['Numerical IDs']
+                else:
+                    nodes = np.arange(1, len(ys) + 1)
+
+
+                if 'Z' in data_dict:
+                    zs = data_dict['Z']
+                else:
+                    zs = np.zeros(len(ys))
+
+                centroids = {}
+
+                for i in range(len(nodes)):
+
+                    centroids[nodes[i]] = [int(zs[i]), int(ys[i]), int(xs[i])]
+
+                my_network.node_centroids = centroids
+
+                self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+
+                print("Centroids succesfully set")
+
+            except Exception as e:
+                print(f"Error: {e}")
+
+        elif property_name == 'Node Identities':
+
+            try:
+
+                idens = data_dict['Identity Column']
+
+                if 'Numerical IDs' in data_dict:
+                    nodes = data_dict['Numerical IDs']
+                else:
+                    nodes = np.arange(1, len(idens) + 1)
+
+                identities = {}
+
+
+                for i in range(len(nodes)):
+
+                    identities[nodes[i]] = str(idens[i])
+
+                my_network.node_identities = identities
+
+                self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', title = 'Node Identities')
+
+                print("Identities succesfully set")
+
+            except Exception as e:
+                print(f"Error: {e}")
+
+        elif property_name == 'Node Communities':
+
+            try:
+
+                coms = data_dict['Community Identifier']
+
+                if 'Numerical IDs' in data_dict:
+                    nodes = data_dict['Numerical IDs']
+                else:
+                    nodes = np.arange(1, len(coms) + 1)
+
+                communities = {}
+
+                for i in range(len(nodes)):
+
+                    communities[nodes[i]] = [str(coms[i])]
+
+                my_network.communities = communities
+
+                self.format_for_upperright_table(my_network.communities, 'NodeID', 'CommunityID', title = 'Community Partition')
+
+                print("Communities succesfully set")
+
+            except Exception as e:
+                print(f"Error: {e}")
 
 
     def set_active_channel(self, index):
@@ -3769,6 +3899,8 @@ class ImageViewerWindow(QMainWindow):
             except:
                 pass
 
+            self.shape = self.channel_data[channel_index].shape
+
             self.update_display(reset_resize = reset_resize)
 
 
@@ -4269,19 +4401,19 @@ class ImageViewerWindow(QMainWindow):
         dialog.exec()
 
     def handle_com_id(self):
-        if my_network.node_identities is None:
-            print("Node identities must be set")
 
-        if my_network.communities is None:
-            self.show_partition_dialog()
+        dialog = ComIdDialog(self)
+        dialog.exec()
 
-            if my_network.communities is None:
-                return
+    def handle_com_neighbor(self):
 
-        info = my_network.community_id_info()
+        dialog = ComNeighborDialog(self)
+        dialog.exec()
 
-        self.format_for_upperright_table(info, 'Node Identity Type', 'Weighted Proportion in Communities', 'Weighted Average of Community Makeup')
+    def handle_com_cell(self):
 
+        dialog = ComCellDialog(self)
+        dialog.exec()
 
     def show_radial_dialog(self):
         dialog = RadialDialog(self)
@@ -4332,6 +4464,21 @@ class ImageViewerWindow(QMainWindow):
         dialog = CodeDialog(self, sort = sort)
         dialog.exec()
 
+    def closeEvent(self, event):
+        """Override closeEvent to close all windows when main window closes"""
+        
+        # Close all Qt windows
+        QApplication.closeAllWindows()
+        
+        # Close all matplotlib figures
+        plt.close('all')
+        
+        # Accept the close event
+        event.accept()
+        
+        # Force quit the application
+        QCoreApplication.quit()
+
 
 
 #TABLE RELATED: 
@@ -5528,10 +5675,15 @@ class Show3dDialog(QDialog):
         layout.addRow("Downsample Factor (Optional to speed up display):", self.downsample)
 
         # Network Overlay checkbox (default True)
-        self.cubic = QPushButton("cubic")
+        self.cubic = QPushButton("Cubic")
         self.cubic.setCheckable(True)
         self.cubic.setChecked(False)
         layout.addRow("Use cubic downsample (Slower but preserves shape better potentially)?", self.cubic)
+
+        self.box = QPushButton("Box")
+        self.box.setCheckable(True)
+        self.box.setChecked(False)
+        layout.addRow("Include bounding box?", self.box)
         
         # Add Run button
         run_button = QPushButton("Show 3D")
@@ -5550,6 +5702,7 @@ class Show3dDialog(QDialog):
                 downsample = None
 
             cubic = self.cubic.isChecked()
+            box = self.box.isChecked()
 
             if cubic:
                 order = 3
@@ -5582,7 +5735,7 @@ class Show3dDialog(QDialog):
                 arrays_3d.append(self.parent().highlight_overlay)
                 colors.append(color_template[4])
         
-            n3d.show_3d(arrays_3d, arrays_4d, down_factor = downsample, order = order, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale, colors = colors)
+            n3d.show_3d(arrays_3d, arrays_4d, down_factor = downsample, order = order, xy_scale = my_network.xy_scale, z_scale = my_network.z_scale, colors = colors, box = box)
             
             self.accept()
 
@@ -5958,7 +6111,7 @@ class PartitionDialog(QDialog):
         dostats = self.stats.isChecked()
 
         try:
-            seed = int(self.seed.text()) if self.seed.text() else None
+            seed = int(self.seed.text()) if self.seed.text() else 42
         except:
             seed = None
 
@@ -5979,6 +6132,184 @@ class PartitionDialog(QDialog):
         except Exception as e:
             print(f"Error creating communities: {e}")
 
+class ComIdDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Select Mode")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        self.mode = QComboBox()
+        self.mode.addItems(["Average Identities Per Community", "Weighted Average Identity of All Communities", ])
+        self.mode.setCurrentIndex(0)
+        layout.addRow("Mode", self.mode)
+
+        # umap checkbox (default True)
+        self.umap = QPushButton("UMAP")
+        self.umap.setCheckable(True)
+        self.umap.setChecked(True)
+        layout.addRow("Generate UMAP?:", self.umap)
+
+        # weighted checkbox (default True)
+        self.label = QPushButton("Label")
+        self.label.setCheckable(True)
+        self.label.setChecked(False)
+        layout.addRow("If using above - label UMAP points?:", self.label)
+
+
+        # Add Run button
+        run_button = QPushButton("Get Community ID Info")
+        run_button.clicked.connect(self.run)
+        layout.addWidget(run_button)
+
+    def run(self):
+
+        try:
+
+            if my_network.node_identities is None:
+                print("Node identities must be set")
+
+            if my_network.communities is None:
+                self.parent().show_partition_dialog()
+
+                if my_network.communities is None:
+                    return
+
+            mode = self.mode.currentIndex()
+
+            umap = self.umap.isChecked()
+            label = self.label.isChecked()
+
+            if mode == 1:
+
+                info = my_network.community_id_info()
+
+                self.parent().format_for_upperright_table(info, 'Node Identity Type', 'Weighted Proportion in Communities', 'Weighted Average of Community Makeup')
+
+            else:
+
+                info, names = my_network.community_id_info_per_com(umap = umap, label = label)
+
+                self.parent().format_for_upperright_table(info, 'Community', names, 'Average of Community Makeup')
+
+            self.accept()
+
+        except Exception as e:
+
+            print(f"Error: {e}")
+
+
+
+class ComNeighborDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Reassign Communities Based on Identity Similarity?")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        self.neighborcount = QLineEdit("5")
+        layout.addRow("Num Neighborhoods:", self.neighborcount)
+
+        self.seed = QLineEdit("")
+        layout.addRow("Clustering Seed:", self.seed)
+
+        self.limit = QLineEdit("")
+        layout.addRow("Min Community Size to be grouped (Smaller communities will be placed in neighborhood 0 - does not apply if empty)", self.limit)
+
+        # Add Run button
+        run_button = QPushButton("Get Neighborhoods (Note this overwrites current communities - save your coms first)")
+        run_button.clicked.connect(self.run)
+        layout.addWidget(run_button)
+
+    def run(self):
+
+        try:
+
+            if my_network.node_identities is None:
+                print("Node identities must be set")
+
+            if my_network.communities is None:
+                self.parent().show_partition_dialog()
+
+                if my_network.communities is None:
+                    return
+
+            seed = float(self.seed.text()) if self.seed.text().strip() else 42
+
+            limit = int(self.limit.text()) if self.limit.text().strip() else None
+
+
+            neighborcount = int(self.neighborcount.text()) if self.neighborcount.text().strip() else 5
+
+            if self.parent().prev_coms is None:
+
+                self.parent().prev_coms = copy.deepcopy(my_network.communities)
+                my_network.assign_neighborhoods(seed, neighborcount, limit = limit)
+            else:
+                my_network.assign_neighborhoods(seed, neighborcount, limit = limit, prev_coms = self.parent().prev_coms)
+
+            self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'NeighborhoodID', title = 'Neighborhood Partition')
+
+            print("Neighborhoods have been assigned to communities based on similarity")
+
+            self.accept()
+
+        except Exception as e:
+
+            print(f"Error assigning neighborhoods: {e}")
+
+class ComCellDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Assign Communities Based on Proximity Within Cuboidal Cells?")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        self.size = QLineEdit("")
+        layout.addRow("Cell Size:", self.size)
+
+        # Add Run button
+        run_button = QPushButton("Get Neighborhoods (Note this overwrites current communities - save your coms first)")
+        run_button.clicked.connect(self.run)
+        layout.addWidget(run_button)
+
+    def run(self):
+
+        try:
+
+            size = int(self.size.text()) if self.size.text().strip() else None
+
+            if size is None:
+                return
+
+            if my_network.node_centroids is None:
+                self.parent().show_centroid_dialog()
+            if my_network.node_centroids is None:
+                return
+
+            my_network.community_cells(size = size)
+
+            self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'CommunityID')
+
+            self.accept()
+
+        except Exception as e:
+
+            print(f"Error: {e}")
+
+
+
+
+
 
 
 class RadialDialog(QDialog):
@@ -7302,7 +7633,7 @@ class SLabelDialog(QDialog):
             try:
 
                 # Update both the display data and the network object
-                binary_array = sdl.smart_label(binary_array, label_array, directory = None, GPU = GPU, predownsample = down_factor)
+                binary_array = sdl.smart_label(binary_array, label_array, directory = None, GPU = GPU, predownsample = down_factor, remove_template = True)
 
                 label_array = sdl.invert_array(label_array)
 
@@ -7419,12 +7750,101 @@ class ThresholdDialog(QDialog):
         msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         return msg.exec() == QMessageBox.StandardButton.Yes
 
+class ExcelotronManager(QObject):
+    # Signal to emit when data is received from Excelotron
+    data_received = pyqtSignal(dict, str)  # dictionary, property_name
+    
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.excelotron_window = None
+        self.last_data = None
+        self.last_property = None
+    
+    def launch(self):
+        """Launch the Excelotron window"""
+        
+        if self.excelotron_window is None:
+            ExcelGUIClass = excelotron.main(standalone=False)
+            self.excelotron_window = ExcelGUIClass()
+            self.excelotron_window.data_exported.connect(self._on_data_exported)
+            # Connect to both close event and destroyed signal
+            self.excelotron_window.destroyed.connect(self._on_window_destroyed)
+            self.excelotron_window.closeEvent = self._create_close_handler(self.excelotron_window.closeEvent)
+            self.excelotron_window.show()
+        else:
+            self.excelotron_window.raise_()
+            self.excelotron_window.activateWindow()
+    
+    def _create_close_handler(self, original_close_event):
+        """Create a close event handler that cleans up properly"""
+        def close_handler(event):
+            self._cleanup_window()
+            original_close_event(event)
+        return close_handler
+    
+    def close(self):
+        """Close the Excelotron window"""
+        if self.excelotron_window is not None:
+            self.excelotron_window.close()
+            self._cleanup_window()
+    
+    def _cleanup_window(self):
+        """Properly cleanup the window reference"""
+        if self.excelotron_window is not None:
+            try:
+                # Disconnect all signals to prevent issues
+                self.excelotron_window.data_exported.disconnect()
+                self.excelotron_window.destroyed.disconnect()
+            except:
+                pass  # Ignore if already disconnected
+            
+            # Schedule for deletion
+            self.excelotron_window.deleteLater()
+            self.excelotron_window = None
+    
+    def is_open(self):
+        """Check if Excelotron window is open"""
+        is_open = self.excelotron_window is not None
+        return is_open
+    
+    def _on_data_exported(self, data_dict, property_name):
+        """Internal slot to handle data from Excelotron"""
+        self.last_data = data_dict
+        self.last_property = property_name
+        # Re-emit the signal for parent to handle
+        self.data_received.emit(data_dict, property_name)
+    
+    def _on_window_destroyed(self):
+        """Handle when the Excelotron window is destroyed/closed"""
+        self.excelotron_window = None
+    
+    def get_last_data(self):
+        """Get the last exported data"""
+        return self.last_data, self.last_property
 
 class MachineWindow(QMainWindow):
 
     def __init__(self, parent=None, GPU = False):
         super().__init__(parent)
 
+        if self.parent().active_channel == 0:
+            if self.parent().channel_data[0] is not None:
+                try:
+                    active_data = self.parent().channel_data[0]
+                    act_channel = 0
+                except:
+                    active_data = self.parent().channel_data[1]
+                    act_channel = 1
+            else:
+                active_data = self.parent().channel_data[1]
+                act_channel = 1
+
+        try:
+            array1 = np.zeros_like(active_data).astype(np.uint8)
+        except:
+            print("No data in nodes channel")
+            return
+
         self.setWindowTitle("Threshold")
         
         # Create central widget and layout
@@ -7446,25 +7866,6 @@ class MachineWindow(QMainWindow):
 
         self.parent().pen_button.setEnabled(False)
 
-
-        if self.parent().active_channel == 0:
-            if self.parent().channel_data[0] is not None:
-                try:
-                    active_data = self.parent().channel_data[0]
-                    act_channel = 0
-                except:
-                    active_data = self.parent().channel_data[1]
-                    act_channel = 1
-            else:
-                active_data = self.parent().channel_data[1]
-                act_channel = 1
-
-        try:
-            array1 = np.zeros_like(active_data).astype(np.uint8)
-        except:
-            print("No data in nodes channel")
-            return
-
         array3 = np.zeros_like(active_data).astype(np.uint8)
         self.parent().highlight_overlay = array3 #Clear this out for the segmenter to use
 
@@ -8849,6 +9250,91 @@ class MaskDialog(QDialog):
         except Exception as e:
             print(f"Error masking: {e}")
 
+class CropDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        try:
+
+            super().__init__(parent)
+            self.setWindowTitle("Crop Image?")
+            self.setModal(True)
+
+            layout = QFormLayout(self)
+
+            self.xmin = QLineEdit("0")
+            layout.addRow("X Min", self.xmin)
+
+            self.xmax = QLineEdit(f"{self.parent().shape[2]}")
+            layout.addRow("X Max", self.xmax)
+
+            self.ymin = QLineEdit("0")
+            layout.addRow("Y Min", self.ymin)
+
+            self.ymax = QLineEdit(f"{self.parent().shape[1]}")
+            layout.addRow("Y Max", self.ymax)
+
+            self.zmin = QLineEdit("0")
+            layout.addRow("Z Min", self.zmin)
+
+            self.zmax = QLineEdit(f"{self.parent().shape[0]}")
+            layout.addRow("Z Max", self.zmax)
+
+            # Add Run button
+            run_button = QPushButton("Run")
+            run_button.clicked.connect(self.run)
+            layout.addRow(run_button)
+
+        except:
+            pass
+
+    def run(self):
+
+        try:
+
+            xmin = int(self.xmin.text()) if self.xmin.text() else 0
+            ymin = int(self.ymin.text()) if self.ymin.text() else 0
+            zmin = int(self.zmin.text()) if self.zmin.text() else 0
+            xmax = int(self.xmax.text()) if self.xmax.text() else self.parent().shape[2]
+            ymax = int(self.ymax.text()) if self.xmax.text() else self.parent().shape[1]
+            zmax = int(self.zmax.text()) if self.xmax.text() else self.parent().shape[0]
+
+            args = xmin, ymin, zmin, xmax, ymax, zmax
+
+            for i, array in enumerate(self.parent().channel_data):
+
+                if array is None:
+
+                    continue
+
+                else:
+
+                    array = self.reslice_3d_array(array, args)
+
+                    self.parent().load_channel(i, array, data = True)
+
+            self.accept()
+
+        except Exception as e:
+
+            print(f"Error cropping: {e}")
+
+
+
+
+
+
+
+
+    def reslice_3d_array(self, array, args):
+        """Internal method used for the secondary algorithm to reslice subarrays around nodes."""
+
+        x_start, y_start, z_start, x_end, y_end, z_end = args
+        
+        # Reslice the array
+        array = array[z_start:z_end+1, y_start:y_end+1, x_start:x_end+1]
+        
+        return array
 
 
 class TypeDialog(QDialog):
@@ -9212,6 +9698,12 @@ class CentroidNodeDialog(QDialog):
         
         layout = QFormLayout(self)
 
+        # Add mode selection dropdown
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["Starting at 0", "Starting at Min Centroids (will transpose centroids)"])
+        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("Execution Mode:", self.mode_selector)
+
         # Add Run button
         run_button = QPushButton("Run Node Generation? (Will override current nodes). Note it is presumed your nodes begin at 1, not 0.")
         run_button.clicked.connect(self.run_nodes)
@@ -9241,7 +9733,18 @@ class CentroidNodeDialog(QDialog):
                 )
                 return
 
-            my_network.nodes = my_network.centroid_array()
+            mode = self.mode_selector.currentIndex()
+
+            if mode == 0:
+
+                my_network.nodes = my_network.centroid_array()
+
+            else:
+
+                my_network.nodes, my_network.centroids = my_network.centroid_array(clip = True)
+
+                self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+
 
             self.parent().load_channel(0, channel_data = my_network.nodes, data = True)
 
@@ -9324,7 +9827,13 @@ class GenNodesDialog(QDialog):
         # Auto checkbox
         self.auto = QPushButton("Auto")
         self.auto.setCheckable(True)
-        self.auto.setChecked(True)
+        try:
+            if my_network.edges.shape[0] == 1:
+                self.auto.setChecked(False)
+            else:
+                self.auto.setChecked(True)
+        except:
+            self.auto.setChecked(True)
         rec_layout.addWidget(QLabel("Attempt to Auto Correct Skeleton Looping:"), 1, 0)
         rec_layout.addWidget(self.auto, 1, 1)
         
@@ -9489,10 +9998,10 @@ class BranchDialog(QDialog):
         correction_layout = QGridLayout()
         
         # Branch Fix checkbox
-        self.fix = QPushButton("Auto-Correct Branches")
+        self.fix = QPushButton("Auto-Correct 1")
         self.fix.setCheckable(True)
         self.fix.setChecked(False)
-        correction_layout.addWidget(QLabel("Attempt to auto-correct branch labels:"), 0, 0)
+        correction_layout.addWidget(QLabel("Auto-Correct Branches by Collapsing Busy Neighbors: "), 0, 0)
         correction_layout.addWidget(self.fix, 0, 1)
         
         # Fix value
@@ -9504,6 +10013,12 @@ class BranchDialog(QDialog):
         self.seed = QLineEdit('')
         correction_layout.addWidget(QLabel("Random seed for auto correction (int - optional):"), 2, 0)
         correction_layout.addWidget(self.seed, 2, 1)
+
+        self.fix2 = QPushButton("Auto-Correct 2")
+        self.fix2.setCheckable(True)
+        self.fix2.setChecked(True)
+        correction_layout.addWidget(QLabel("Auto-Correct Branches by Collapsing Internal Labels: "), 3, 0)
+        correction_layout.addWidget(self.fix2, 3, 1)
         
         correction_group.setLayout(correction_layout)
         main_layout.addWidget(correction_group)
@@ -9573,6 +10088,7 @@ class BranchDialog(QDialog):
             GPU = self.GPU.isChecked()
             cubic = self.cubic.isChecked()
             fix = self.fix.isChecked()
+            fix2 = self.fix2.isChecked()
             fix_val = float(self.fix_val.text()) if self.fix_val.text() else None
             seed = int(self.seed.text()) if self.seed.text() else None
 
@@ -9589,6 +10105,25 @@ class BranchDialog(QDialog):
 
                 output = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = original_array, GPU = GPU, down_factor = down_factor, arrayshape = original_shape)
 
+                if fix2:
+
+                    temp_network = n3d.Network_3D(nodes = output)
+
+                    max_val = np.max(temp_network.nodes)
+
+                    background = temp_network.nodes == 0
+
+                    background = background * max_val
+
+                    temp_network.nodes = temp_network.nodes + background
+
+                    del background
+
+                    temp_network.morph_proximity(search = [3,3], fastdil = True) #Detect network of nearby branches
+
+                    output = n3d.fix_branches(output, temp_network.network, max_val)
+
+
                 if fix:
 
                     temp_network = n3d.Network_3D(nodes = output)
@@ -9597,7 +10132,7 @@ class BranchDialog(QDialog):
 
                     temp_network.community_partition(weighted = False, style = 1, dostats = False, seed = seed) #Find communities with louvain, unweighted params
 
-                    targs = n3d.fix_branches(temp_network.nodes, temp_network.network, temp_network.communities, fix_val)
+                    targs = n3d.fix_branches_network(temp_network.nodes, temp_network.network, temp_network.communities, fix_val)
 
                     temp_network.com_to_node(targs)
 
@@ -9784,6 +10319,11 @@ class ModifyDialog(QDialog):
         self.revid.setCheckable(True)
         self.revid.setChecked(False)
         layout.addRow("Remove Unassigned IDs from Centroid List?:", self.revid)
+
+        self.remove = QPushButton("Remove Missing")
+        self.remove.setCheckable(True)
+        self.remove.setChecked(False)
+        layout.addRow("Remove Any Nodes Not in Nodes Channel From Properties?:", self.remove)
         
         # trunk checkbox (default false)
         self.trunk = QPushButton("Remove Trunk")
@@ -9862,6 +10402,7 @@ class ModifyDialog(QDialog):
             prune = self.prune.isChecked()
             isolate = self.isolate.isChecked()
             comcollapse = self.comcollapse.isChecked()
+            remove = self.remove.isChecked()
 
 
             if isolate and my_network.node_identities is not None:
@@ -9875,6 +10416,21 @@ class ModifyDialog(QDialog):
                     pass
 
 
+            if remove:
+                my_network.purge_properties()
+                try:
+                    self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+                except:
+                    pass
+                try:
+                    self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+                except:
+                    pass
+                try:
+                    self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'Community', 'Node Communities')
+                except:
+                    pass
+
 
             if edgeweight:
                 my_network.remove_edge_weights()
@@ -10469,14 +11025,9 @@ class ProxDialog(QDialog):
                     my_network.id_overlay = my_network.draw_node_indices(directory=directory)
                     
                     # Update channel data
-                    self.parent().channel_data[2] = my_network.network_overlay
-                    self.parent().channel_data[3] = my_network.id_overlay
+                    self.parent().load_channel(2, channel_data = my_network.network_overlay, data = True)
+                    self.parent().load_channel(3, channel_data = my_network.id_overlay, data = True)
                     
-                    # Enable the overlay channel buttons
-                    self.parent().channel_buttons[2].setEnabled(True)
-                    self.parent().channel_buttons[3].setEnabled(True)
-
-
             self.parent().update_display()
             self.accept()