nettracer3d 0.2.5__py3-none-any.whl → 0.2.7__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -13,11 +13,17 @@ from matplotlib.figure import Figure
 import matplotlib.pyplot as plt
 from qtrangeslider import QRangeSlider
 from nettracer3d import nettracer as n3d
+from nettracer3d import smart_dilate as sdl
+from nettracer3d import proximity as pxt
 from matplotlib.colors import LinearSegmentedColormap
 import pandas as pd
 from PyQt6.QtGui import (QFont, QCursor, QColor)
 import tifffile
 import copy
+import multiprocessing as mp
+from concurrent.futures import ThreadPoolExecutor
+from functools import partial
+
 
 class ImageViewerWindow(QMainWindow):
     def __init__(self):
@@ -120,6 +126,15 @@ class ImageViewerWindow(QMainWindow):
             2: [0,0],
             3: [0,0]
         }
+
+        self.volume_dict = {
+            0: None,
+            1: None,
+            2: None,
+            3: None
+        } #For storing thresholding information
+
+        self.original_shape = None #For undoing resamples
         
         # Create control panel
         control_panel = QWidget()
@@ -379,23 +394,44 @@ class ImageViewerWindow(QMainWindow):
         elif self.scroll_direction > 0 and new_value <= self.slice_slider.maximum():
             self.slice_slider.setValue(new_value)
         
-    def create_highlight_overlay(self, node_indices=None, edge_indices=None):
+
+    def create_highlight_overlay(self, node_indices=None, edge_indices=None, overlay1_indices = None, overlay2_indices = None):
         """
-        Create a binary overlay highlighting specific nodes and/or edges using boolean indexing.
+        Create a binary overlay highlighting specific nodes and/or edges using parallel processing.
         
         Args:
             node_indices (list): List of node indices to highlight
             edge_indices (list): List of edge indices to highlight
         """
+
+        def process_chunk(chunk_data, indices_to_check):
+            """Process a single chunk of the array to create highlight mask"""
+            mask = np.isin(chunk_data, indices_to_check)
+            return mask * 255
+
+        if node_indices is not None:
+            if 0 in node_indices:
+                node_indices.remove(0)
+        if edge_indices is not None:
+            if 0 in edge_indices:
+                edge_indices.remove(0)
+        if overlay1_indices is not None:
+            if 0 in overlay1_indices:
+                overlay1_indices.remove(0)
+
         if node_indices is None:
             node_indices = []
         if edge_indices is None:
             edge_indices = []
+        if overlay1_indices is None:
+            overlay1_indices = []
+        if overlay2_indices is None:
+            overlay2_indices = []
             
-        current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None #Preserve zoom
+        current_xlim = self.ax.get_xlim() if hasattr(self, 'ax') and self.ax.get_xlim() != (0, 1) else None
         current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
-
-        if not node_indices and not edge_indices:
+        
+        if not node_indices and not edge_indices and not overlay1_indices and not overlay2_indices:
             self.highlight_overlay = None
             self.highlight_bounds = None
             self.update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -412,22 +448,62 @@ class ImageViewerWindow(QMainWindow):
         # Initialize full-size overlay
         self.highlight_overlay = np.zeros(full_shape, dtype=np.uint8)
         
-        # Add nodes to highlight using boolean indexing
-        if node_indices and self.channel_data[0] is not None:
-            mask = np.isin(self.channel_data[0], node_indices)
-            self.highlight_overlay[mask] = 255
+        # Get number of CPU cores
+        num_cores = mp.cpu_count()
+        
+        # Calculate chunk size along y-axis
+        chunk_size = full_shape[0] // num_cores
+        if chunk_size < 1:
+            chunk_size = 1
+        
+        def process_channel(channel_data, indices, array_shape):
+            if channel_data is None or not indices:
+                return None
+                
+            # Create chunks
+            chunks = []
+            for i in range(0, array_shape[0], chunk_size):
+                end = min(i + chunk_size, array_shape[0])
+                chunks.append(channel_data[i:end])
                 
-        # Add edges to highlight using boolean indexing
-        if edge_indices and self.channel_data[1] is not None:
-            mask = np.isin(self.channel_data[1], edge_indices)
-            self.highlight_overlay[mask] = 255
+            # Process chunks in parallel using ThreadPoolExecutor
+            process_func = partial(process_chunk, indices_to_check=indices)
             
-
+            with ThreadPoolExecutor(max_workers=num_cores) as executor:
+                chunk_results = list(executor.map(process_func, chunks))
+                
+            # Reassemble the chunks
+            return np.vstack(chunk_results)
+        
+        # Process nodes and edges in parallel using multiprocessing
+        with ThreadPoolExecutor(max_workers=2) as executor:
+            future_nodes = executor.submit(process_channel, self.channel_data[0], node_indices, full_shape)
+            future_edges = executor.submit(process_channel, self.channel_data[1], edge_indices, full_shape)
+            future_overlay1 = executor.submit(process_channel, self.channel_data[2], overlay1_indices, full_shape)
+            future_overlay2 = executor.submit(process_channel, self.channel_data[3], overlay2_indices, full_shape)
+            
+            # Get results
+            node_overlay = future_nodes.result()
+            edge_overlay = future_edges.result()
+            overlay1_overlay = future_overlay1.result()
+            overlay2_overlay = future_overlay2.result()
+            
+        # Combine results
+        if node_overlay is not None:
+            self.highlight_overlay = np.maximum(self.highlight_overlay, node_overlay)
+        if edge_overlay is not None:
+            self.highlight_overlay = np.maximum(self.highlight_overlay, edge_overlay)
+        if overlay1_overlay is not None:
+            self.highlight_overlay = np.maximum(self.highlight_overlay, overlay1_overlay)
+        if overlay2_overlay is not None:
+            self.highlight_overlay = np.maximum(self.highlight_overlay, overlay2_overlay)
+                
         # Update display
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
 
 
+
 #METHODS RELATED TO RIGHT CLICK:
     
     def create_context_menu(self, event):
@@ -474,6 +550,20 @@ class ImageViewerWindow(QMainWindow):
                 select_edges = select_all_menu.addAction("Edges")
                 context_menu.addMenu(select_all_menu)
 
+                if len(self.clicked_values['nodes']) > 0 or len(self.clicked_values['edges']) > 0:
+                    highlight_menu = QMenu("Selection", self)
+                    if len(self.clicked_values['nodes']) > 1 or len(self.clicked_values['edges']) > 1:
+                        combine_obj = highlight_menu.addAction("Combine Object Labels")
+                        combine_obj.triggered.connect(self.handle_combine)
+                    delete_obj = highlight_menu.addAction("Delete Selection")
+                    delete_obj.triggered.connect(self.handle_delete)
+                    if len(self.clicked_values['nodes']) > 1:
+                        link_nodes = highlight_menu.addAction("Link Nodes")
+                        link_nodes.triggered.connect(self.handle_link)
+                        delink_nodes = highlight_menu.addAction("Split Nodes")
+                        delink_nodes.triggered.connect(self.handle_split)
+                context_menu.addMenu(highlight_menu)
+
                 # Create measure menu
                 measure_menu = QMenu("Measure", self)
 
@@ -901,6 +991,186 @@ class ImageViewerWindow(QMainWindow):
         except Exception as e:
             print(f"Error: {e}")
 
+    def handle_combine(self):
+
+        try:
+
+            self.clicked_values['nodes'].sort()
+            nodes = copy.deepcopy(self.clicked_values['nodes'])
+            self.clicked_values['edges'].sort()
+            edges = copy.deepcopy(self.clicked_values['edges'])
+
+            if len(nodes) > 1:
+                new_nodes = nodes[0]
+
+                mask = np.isin(self.channel_data[0], nodes)
+                my_network.nodes[mask] = new_nodes
+                self.load_channel(0, my_network.nodes, True)
+                self.clicked_values['nodes'] = new_nodes
+
+            if len(edges) > 1:
+                new_edges = edges[0]
+
+                mask = np.isin(self.channel_data[1], edges)
+                my_network.edges[mask] = new_edges
+                self.load_channel(1, my_network.edges, True)
+                self.clicked_values['edges'] = new_edges
+
+            try:
+
+                for i in range(len(my_network.network_lists[0])):
+                    if my_network.network_lists[0][i] in nodes and len(nodes) > 1:
+                        my_network.network_lists[0][i] = new_nodes
+                    if my_network.network_lists[1][i] in nodes and len(nodes) > 1:
+                        my_network.network_lists[1][i] = new_nodes    
+                    if my_network.network_lists[2][i] in edges and len(edges) > 1:
+                        my_network.network_lists[2][i] = new_edges
+
+
+                my_network.network_lists = my_network.network_lists
+
+                if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
+                    empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+                    model = PandasModel(empty_df)
+                    self.network_table.setModel(model)
+                else:
+                    model = PandasModel(my_network.network_lists)
+                    self.network_table.setModel(model)
+                    # Adjust column widths to content
+                    for column in range(model.columnCount(None)):
+                        self.network_table.resizeColumnToContents(column)
+
+            except Exception as e:
+                print(f"Error, could not update network: {e}")
+
+        except Exception as e:
+            print(f"An error has occured: {e}")
+
+    def handle_delete(self):
+
+        try:
+            if len(self.clicked_values['nodes']) > 0:
+                self.create_highlight_overlay(node_indices = self.clicked_values['nodes'])
+                mask = self.highlight_overlay == 0
+                my_network.nodes = my_network.nodes * mask
+                self.load_channel(0, my_network.nodes, True)
+
+                for i in range(len(my_network.network_lists[0]) - 1, -1, -1):
+                    if my_network.network_lists[0][i] in self.clicked_values['nodes'] or my_network.network_lists[0][i] in self.clicked_values['nodes']:
+                        del my_network.network_lists[0][i]
+                        del my_network.network_lists[1][i]
+                        del my_network.network_lists[2][i]
+
+
+
+            if len(self.clicked_values['edges']) > 0:
+                self.create_highlight_overlay(node_indices = self.clicked_values['edges'])
+                mask = self.highlight_overlay == 0
+                my_network.edges = my_network.edges * mask
+                self.load_channel(1, my_network.edges, True)
+
+                for i in range(len(my_network.network_lists[1]) - 1, -1, -1):
+                    if my_network.network_lists[2][i] in self.clicked_values['edges']:
+                        del my_network.network_lists[0][i]
+                        del my_network.network_lists[1][i]
+                        del my_network.network_lists[2][i]
+
+            my_network.network_lists = my_network.network_lists
+
+
+            if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
+                empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+                model = PandasModel(empty_df)
+                self.network_table.setModel(model)
+            else:
+                model = PandasModel(my_network.network_lists)
+                self.network_table.setModel(model)
+                # Adjust column widths to content
+                for column in range(model.columnCount(None)):
+                    self.network_table.resizeColumnToContents(column)
+
+            self.show_centroid_dialog()
+        except Exception as e:
+            print(f"Error: {e}")
+
+    def handle_link(self):
+
+        try:
+            nodes = self.clicked_values['nodes']
+            from itertools import combinations
+            pairs = list(combinations(nodes, 2))
+            
+            # Convert existing connections to a set of tuples for efficient lookup
+            existing_connections = set()
+            for n1, n2 in zip(my_network.network_lists[0], my_network.network_lists[1]):
+                existing_connections.add((n1, n2))
+                existing_connections.add((n2, n1))  # Add reverse pair too
+            
+            # Filter out existing connections
+            new_pairs = []
+            for pair in pairs:
+                if pair not in existing_connections:
+                    new_pairs.append(pair)
+            
+            # Add new connections
+            for pair in new_pairs:
+                my_network.network_lists[0].append(pair[0])
+                my_network.network_lists[1].append(pair[1])
+                my_network.network_lists[2].append(0)
+            
+            # Update the table
+            if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
+                empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+                model = PandasModel(empty_df)
+                self.network_table.setModel(model)
+            else:
+                model = PandasModel(my_network.network_lists)
+                self.network_table.setModel(model)
+                # Adjust column widths to content
+                for column in range(model.columnCount(None)):
+                    self.network_table.resizeColumnToContents(column)
+        except Exception as e:
+            print(f"An error has occurred: {e}")
+
+
+    def handle_split(self):
+        try:
+            nodes = self.clicked_values['nodes']
+
+            from itertools import combinations
+
+            pairs = list(combinations(nodes, 2))
+
+            print(pairs)
+
+
+            for i in range(len(my_network.network_lists[0]) - 1, -1, -1):
+                print((my_network.network_lists[0][i], my_network.network_lists[1][i]))
+                if (my_network.network_lists[0][i], my_network.network_lists[1][i]) in pairs or (my_network.network_lists[1][i], my_network.network_lists[0][i]) in pairs:
+                    del my_network.network_lists[0][i]
+                    del my_network.network_lists[1][i]
+                    del my_network.network_lists[2][i]
+
+            my_network.network_lists = my_network.network_lists
+
+            if not hasattr(my_network, 'network_lists') or my_network.network_lists is None:
+                empty_df = pd.DataFrame(columns=['Node 1A', 'Node 1B', 'Edge 1C'])
+                model = PandasModel(empty_df)
+                self.network_table.setModel(model)
+            else:
+                model = PandasModel(my_network.network_lists)
+                self.network_table.setModel(model)
+                # Adjust column widths to content
+                for column in range(model.columnCount(None)):
+                    self.network_table.resizeColumnToContents(column)
+        except Exception as e:
+            print(f"An error has occurred: {e}")
+
+
+
+
+
+
 
     def handle_highlight_select(self):
 
@@ -1264,18 +1534,19 @@ class ImageViewerWindow(QMainWindow):
                     # Get clicked value
                     x_idx = int(round(event.xdata))
                     y_idx = int(round(event.ydata))
+                    # Check if Ctrl key is pressed (using matplotlib's key_press system)
+                    ctrl_pressed = 'ctrl' in event.modifiers  # Note: changed from 'control' to 'ctrl'
                     if self.channel_data[self.active_channel][self.current_slice, y_idx, x_idx] != 0:
                         clicked_value = self.channel_data[self.active_channel][self.current_slice, y_idx, x_idx]
                     else:
-                        self.clicked_values = {
-                            'nodes': [],
-                            'edges': []
-                        }
-                        self.create_highlight_overlay()
+                        if not ctrl_pressed:
+                            self.clicked_values = {
+                                'nodes': [],
+                                'edges': []
+                            }
+                            self.create_highlight_overlay()
                         return
                     
-                    # Check if Ctrl key is pressed (using matplotlib's key_press system)
-                    ctrl_pressed = 'ctrl' in event.modifiers  # Note: changed from 'control' to 'ctrl'
 
                     starting_vals = copy.deepcopy(self.clicked_values)
                     
@@ -1384,6 +1655,8 @@ class ImageViewerWindow(QMainWindow):
         load_action.triggered.connect(lambda: self.load_misc('Node Centroids'))
         load_action = misc_menu.addAction("Load Edge Centroids")
         load_action.triggered.connect(lambda: self.load_misc('Edge Centroids'))
+        load_action = misc_menu.addAction("Merge Nodes")
+        load_action.triggered.connect(lambda: self.load_misc('Merge Nodes'))
 
         
         # Analysis menu
@@ -1391,11 +1664,19 @@ 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")
+        partition_action = network_menu.addAction("Community Partition + Community Stats")
         partition_action.triggered.connect(self.show_partition_dialog)
         stats_menu = analysis_menu.addMenu("Stats")
         allstats_action = stats_menu.addAction("Calculate Generic Network Stats")
         allstats_action.triggered.connect(self.stats)
+        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)
+        random_action = stats_menu.addAction("Generate Equivalent Random Network")
+        random_action.triggered.connect(self.show_random_dialog)
         vol_action = stats_menu.addAction("Calculate Volumes")
         vol_action.triggered.connect(self.volumes)
         inter_action = stats_menu.addAction("Calculate Node < > Edge Interaction")
@@ -1403,8 +1684,13 @@ class ImageViewerWindow(QMainWindow):
         overlay_menu = analysis_menu.addMenu("Data/Overlays")
         degree_action = overlay_menu.addAction("Get Degree Information")
         degree_action.triggered.connect(self.show_degree_dialog)
+        hub_action = overlay_menu.addAction("Get Hub Information")
+        hub_action.triggered.connect(self.show_hub_dialog)
         mother_action = overlay_menu.addAction("Get Mother Nodes")
         mother_action.triggered.connect(self.show_mother_dialog)
+        community_code_action = overlay_menu.addAction("Code Communities")
+        community_code_action.triggered.connect(self.show_code_dialog)
+
 
         # Process menu
         process_menu = menubar.addMenu("Process")
@@ -1421,25 +1707,37 @@ class ImageViewerWindow(QMainWindow):
         resize_action.triggered.connect(self.show_resize_dialog)
         dilate_action = image_menu.addAction("Dilate")
         dilate_action.triggered.connect(self.show_dilate_dialog)
+        erode_action = image_menu.addAction("Erode")
+        erode_action.triggered.connect(self.show_erode_dialog)
+        hole_action = image_menu.addAction("Fill Holes")
+        hole_action.triggered.connect(self.show_hole_dialog)
         binarize_action = image_menu.addAction("Binarize")
         binarize_action.triggered.connect(self.show_binarize_dialog)
         label_action = image_menu.addAction("Label Objects")
         label_action.triggered.connect(self.show_label_dialog)
+        thresh_action = image_menu.addAction("Threshold/Segment")
+        thresh_action.triggered.connect(self.show_thresh_dialog)
         mask_action = image_menu.addAction("Mask Channel")
         mask_action.triggered.connect(self.show_mask_dialog)
         skeletonize_action = image_menu.addAction("Skeletonize")
         skeletonize_action.triggered.connect(self.show_skeletonize_dialog)
         watershed_action = image_menu.addAction("Watershed")
         watershed_action.triggered.connect(self.show_watershed_dialog)
+        z_proj_action = image_menu.addAction("Z Project")
+        z_proj_action.triggered.connect(self.show_z_dialog)
 
-        centroid_node_action = process_menu.addAction("Generate Nodes (From Node Centroids)")
+        generate_menu = process_menu.addMenu("Generate")
+        centroid_node_action = generate_menu.addAction("Generate Nodes (From Node Centroids)")
         centroid_node_action.triggered.connect(self.show_centroid_node_dialog)
-
-
-        gennodes_action = process_menu.addAction("Generate Nodes (From 'Edge' Vertices)")
+        gennodes_action = generate_menu.addAction("Generate Nodes (From 'Edge' Vertices)")
         gennodes_action.triggered.connect(self.show_gennodes_dialog)
-        branch_action = process_menu.addAction("Label Branches")
+        branch_action = generate_menu.addAction("Label Branches")
         branch_action.triggered.connect(self.show_branch_dialog)
+        genvor_action = generate_menu.addAction("Generate Voronoi Diagram (From Node Centroids) - goes in Overlay2")
+        genvor_action.triggered.connect(self.voronoi)
+
+        modify_action = process_menu.addAction("Modify Network")
+        modify_action.triggered.connect(self.show_modify_dialog)
 
         
         # Image menu
@@ -1477,17 +1775,26 @@ class ImageViewerWindow(QMainWindow):
 
     def volumes(self):
 
-        print(self.active_channel)
 
         if self.active_channel == 1:
             output = my_network.volumes('edges')
             self.format_for_upperright_table(output, metric='Edge ID', value = 'Voxel Volume (Scaled)', title = 'Edge Volumes')
+            self.volume_dict[1] = output
 
-        else:
+        elif self.active_channel == 0:
             output = my_network.volumes('nodes')
             self.format_for_upperright_table(output, metric='Node ID', value = 'Voxel Volume (Scaled)', title = 'Node Volumes')
+            self.volume_dict[0] = output
 
+        elif self.active_channel == 2:
+            output = my_network.volumes('network_overlay')
+            self.format_for_upperright_table(output, metric='Object ID', value = 'Voxel Volume (Scaled)', title = 'Overlay 1 Volumes')
+            self.volume_dict[2] = output
 
+        elif self.active_channel == 3:
+            output = my_network.volumes('id_overlay')
+            self.format_for_upperright_table(output, metric='Object ID', value = 'Voxel Volume (Scaled)', title = 'Overlay 2 Volumes')
+            self.volume_dict[3] = output
 
         
 
@@ -1582,6 +1889,11 @@ class ImageViewerWindow(QMainWindow):
         dialog = WatershedDialog(self)
         dialog.exec()
 
+    def show_z_dialog(self):
+        """Show the z-proj dialog."""
+        dialog = ZDialog(self)
+        dialog.exec()
+
     def show_calc_all_dialog(self):
         """Show the calculate all parameter dialog."""
         dialog = CalcAllDialog(self)
@@ -1602,11 +1914,26 @@ class ImageViewerWindow(QMainWindow):
         dialog = DilateDialog(self)
         dialog.exec()
 
+    def show_erode_dialog(self):
+        """show the erode dialog"""
+        dialog = ErodeDialog(self)
+        dialog.exec()
+
+    def show_hole_dialog(self):
+        """show the hole dialog"""
+        dialog = HoleDialog(self)
+        dialog.exec()
+
     def show_label_dialog(self):
         """Show the label dialog"""
         dialog = LabelDialog(self)
         dialog.exec()
 
+    def show_thresh_dialog(self):
+        """Show threshold dialog"""
+        thresh_window = ThresholdWindow(self)
+        thresh_window.show()  # Non-modal window
+
     def show_mask_dialog(self):
         """Show the mask dialog"""
         dialog = MaskDialog(self)
@@ -1633,6 +1960,33 @@ class ImageViewerWindow(QMainWindow):
         dialog = BranchDialog(self)
         dialog.exec()
 
+    def voronoi(self):
+
+        try:
+
+            if my_network.nodes is not None:
+                shape = my_network.nodes.shape
+            else:
+                shape = None
+
+            if my_network.node_centroids is None:
+                self.show_centroid_dialog()
+                if my_network.node_centroids is None:
+                    print("Node centroids must be set")
+                    return
+
+            array = pxt.create_voronoi_3d_kdtree(my_network.node_centroids, shape)
+            self.load_channel(3, array, True)
+
+        except Exception as e:
+            print(f"Error generating voronoi: {e}")
+
+
+    def show_modify_dialog(self):
+        """Show the network modify dialog"""
+        dialog = ModifyDialog(self)
+        dialog.exec()
+
 
     def show_binarize_dialog(self):
         """show the binarize dialog"""
@@ -1696,53 +2050,110 @@ class ImageViewerWindow(QMainWindow):
     def load_misc(self, sort):
         """Loads various things"""
 
-        try:
-
-            filename, _ = QFileDialog.getOpenFileName(
-                self,
-                f"Load {sort}",
-                "",
-                "Spreadsheets (*.xlsx *.csv)"
-            )
+        if sort != 'Merge Nodes':
 
             try:
-                if sort == 'Node Identities':
-                    my_network.load_node_identities(file_path = filename)
 
-                    if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
-                        try:
-                            self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
-                        except Exception as e:
-                            print(f"Error loading node identity table: {e}")
+                filename, _ = QFileDialog.getOpenFileName(
+                    self,
+                    f"Load {sort}",
+                    "",
+                    "Spreadsheets (*.xlsx *.csv)"
+                )
 
-                elif sort == 'Node Centroids':
-                    my_network.load_node_centroids(file_path = filename)
+                try:
+                    if sort == 'Node Identities':
+                        my_network.load_node_identities(file_path = filename)
 
-                    if hasattr(my_network, 'node_centroids') and my_network.node_centroids is not None:
-                        try:
-                            self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
-                        except Exception as e:
-                            print(f"Error loading node centroid table: {e}")
+                        if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
+                            try:
+                                self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+                            except Exception as e:
+                                print(f"Error loading node identity table: {e}")
 
-                elif sort == 'Edge Centroids':
-                    my_network.load_edge_centroids(file_path = filename)
+                    elif sort == 'Node Centroids':
+                        my_network.load_node_centroids(file_path = filename)
 
-                    if hasattr(my_network, 'edge_centroids') and my_network.edge_centroids is not None:
-                        try:
-                            self.format_for_upperright_table(my_network.edge_centroids, 'EdgeID', ['Z', 'Y', 'X'], 'Edge Centroids')
-                        except Exception as e:
-                            print(f"Error loading edge centroid table: {e}")
+                        if hasattr(my_network, 'node_centroids') and my_network.node_centroids is not None:
+                            try:
+                                self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+                            except Exception as e:
+                                print(f"Error loading node centroid table: {e}")
+
+                    elif sort == 'Edge Centroids':
+                        my_network.load_edge_centroids(file_path = filename)
 
+                        if hasattr(my_network, 'edge_centroids') and my_network.edge_centroids is not None:
+                            try:
+                                self.format_for_upperright_table(my_network.edge_centroids, 'EdgeID', ['Z', 'Y', 'X'], 'Edge Centroids')
+                            except Exception as e:
+                                print(f"Error loading edge centroid table: {e}")
+
+
+                except Exception as e:
+                    print(f"An error has occured: {e}")
 
             except Exception as e:
-                print(f"An error has occured: {e}")
+                QMessageBox.critical(
+                    self,
+                    "Error Loading",
+                    f"Failed to load {sort}: {str(e)}"
+                )
 
-        except Exception as e:
-            QMessageBox.critical(
-                self,
-                "Error Loading",
-                f"Failed to load {sort}: {str(e)}"
-            )
+        else:
+            try:
+
+                if len(np.unique(my_network.nodes)) < 3:
+                    self.show_label_dialog()
+
+                # First ask user what they want to select
+                msg = QMessageBox()
+                msg.setWindowTitle("Selection Type")
+                msg.setText("Would you like to select a TIFF file or a directory?")
+                tiff_button = msg.addButton("TIFF File", QMessageBox.ButtonRole.AcceptRole)
+                dir_button = msg.addButton("Directory", QMessageBox.ButtonRole.AcceptRole)
+                msg.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
+
+                msg.exec()
+
+                if msg.clickedButton() == tiff_button:
+                    # Code for selecting TIFF files
+                    filename, _ = QFileDialog.getOpenFileName(
+                        self,
+                        "Select TIFF file",
+                        "",
+                        "TIFF files (*.tiff *.tif)"
+                    )
+                    if filename:
+                        selected_path = filename
+
+                elif msg.clickedButton() == dir_button:
+                    # Code for selecting directories
+                    dialog = QFileDialog(self)
+                    dialog.setOption(QFileDialog.Option.DontUseNativeDialog)
+                    dialog.setOption(QFileDialog.Option.ReadOnly)
+                    dialog.setFileMode(QFileDialog.FileMode.Directory)
+                    dialog.setViewMode(QFileDialog.ViewMode.Detail)
+
+                    if dialog.exec() == QFileDialog.DialogCode.Accepted:
+                        selected_path = dialog.directory().absolutePath()
+
+                my_network.merge_nodes(selected_path)
+                self.load_channel(0, my_network.nodes, True)
+
+
+                if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
+                    try:
+                        self.format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+                    except Exception as e:
+                        print(f"Error loading node identity table: {e}")
+
+            except Exception as e:
+                QMessageBox.critical(
+                    self,
+                    "Error Merging",
+                    f"Failed to load {sort}: {str(e)}"
+                )
 
 
     # Modify load_from_network_obj method
@@ -1870,7 +2281,7 @@ class ImageViewerWindow(QMainWindow):
             else:
                 btn.setStyleSheet("")
 
-    def load_channel(self, channel_index, channel_data=None, data=False):
+    def load_channel(self, channel_index, channel_data=None, data=False, assign_shape = True):
         """Load a channel and enable active channel selection if needed."""
 
         try:
@@ -1883,8 +2294,10 @@ class ImageViewerWindow(QMainWindow):
                     "TIFF Files (*.tif *.tiff)"
                 )
                 self.channel_data[channel_index] = tifffile.imread(filename)
+                print(self.channel_data[channel_index].shape)
                 if len(self.channel_data[channel_index].shape) == 2:
-                    self.channel_data[channel_index] = np.stack((self.channel_data[channel_index], self.channel_data[channel_index]), axis = 0) #currently handle 2d arrays by just making them 3d
+                    #self.channel_data[channel_index] = np.stack((self.channel_data[channel_index], self.channel_data[channel_index]), axis = 0) #currently handle 2d arrays by just making them 3d
+                    self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
 
 
             else:
@@ -1910,18 +2323,21 @@ class ImageViewerWindow(QMainWindow):
                 self.active_channel_combo.setEnabled(True)
             
             # Update slider range if this is the first channel loaded
-            if not self.slice_slider.isEnabled():
-                self.slice_slider.setEnabled(True)
-                self.slice_slider.setMinimum(0)
-                self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
-                self.slice_slider.setValue(0)
-                self.current_slice = 0
+            if len(self.channel_data[channel_index].shape) == 3:
+                if not self.slice_slider.isEnabled():
+                    self.slice_slider.setEnabled(True)
+                    self.slice_slider.setMinimum(0)
+                    self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
+                    self.slice_slider.setValue(0)
+                    self.current_slice = 0
+                else:
+                    self.slice_slider.setEnabled(True)
+                    self.slice_slider.setMinimum(0)
+                    self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
+                    self.slice_slider.setValue(0)
+                    self.current_slice = 0
             else:
-                self.slice_slider.setEnabled(True)
-                self.slice_slider.setMinimum(0)
-                self.slice_slider.setMaximum(self.channel_data[channel_index].shape[0] - 1)
-                self.slice_slider.setValue(0)
-                self.current_slice = 0
+                self.slice_slider.setEnabled(False)
 
             
             # If this is the first channel loaded, make it active
@@ -1932,6 +2348,10 @@ class ImageViewerWindow(QMainWindow):
                 self.channel_buttons[channel_index].click()
             self.min_max[channel_index][0] = np.min(self.channel_data[channel_index])
             self.min_max[channel_index][1] = np.max(self.channel_data[channel_index])
+            self.volume_dict[channel_index] = None #reset volumes
+
+            if assign_shape: #keep original shape tracked to undo resampling.
+                self.original_shape = self.channel_data[channel_index].shape
             
             self.update_display()
 
@@ -2157,117 +2577,132 @@ class ImageViewerWindow(QMainWindow):
         self.update_display(preserve_zoom = (current_xlim, current_ylim))
     
     def update_display(self, preserve_zoom=None):
-        """Update the display with currently visible channels and highlight overlay."""
-        self.figure.clear()
-        
-        # Create subplot with tight layout and white figure background
-        self.figure.patch.set_facecolor('white')
-        self.ax = self.figure.add_subplot(111)
-        
-        # Store current zoom limits if they exist and weren't provided
-        if preserve_zoom is None and hasattr(self, 'ax'):
-            current_xlim = self.ax.get_xlim() if self.ax.get_xlim() != (0, 1) else None
-            current_ylim = self.ax.get_ylim() if self.ax.get_ylim() != (0, 1) else None
-        else:
-            current_xlim, current_ylim = preserve_zoom if preserve_zoom else (None, None)
-        
-        # Define base colors for each channel with increased intensity
-        base_colors = self.base_colors
-        # Set only the axes (image area) background to black
-        self.ax.set_facecolor('black')
-        
-        # Display each visible channel
-        for channel in range(4):
-            if (self.channel_visible[channel] and 
-                self.channel_data[channel] is not None):
-                current_image = self.channel_data[channel][self.current_slice, :, :]
-                
-                # Calculate brightness/contrast limits from entire volume
-                img_min = self.min_max[channel][0]
-                img_max = self.min_max[channel][1]
-                
-                # Calculate vmin and vmax, ensuring we don't get a zero range
-                if img_min == img_max:
-                    vmin = img_min
-                    vmax = img_min + 1
-                else:
-                    vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
-                    vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
-                
-                # Normalize the image safely
-                if vmin == vmax:
-                    normalized_image = np.zeros_like(current_image)
-                else:
-                    normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
-                
-                # Create custom colormap with higher intensity
-                color = base_colors[channel]
-                custom_cmap = LinearSegmentedColormap.from_list(
-                    f'custom_{channel}',
-                    [(0,0,0,0), (*color,1)]
+            """Update the display with currently visible channels and highlight overlay."""
+            self.figure.clear()
+            
+            # Create subplot with tight layout and white figure background
+            self.figure.patch.set_facecolor('white')
+            self.ax = self.figure.add_subplot(111)
+            
+            # Store current zoom limits if they exist and weren't provided
+            if preserve_zoom is None and hasattr(self, 'ax'):
+                current_xlim = self.ax.get_xlim() if self.ax.get_xlim() != (0, 1) else None
+                current_ylim = self.ax.get_ylim() if self.ax.get_ylim() != (0, 1) else None
+            else:
+                current_xlim, current_ylim = preserve_zoom if preserve_zoom else (None, None)
+            
+            # Define base colors for each channel with increased intensity
+            base_colors = self.base_colors
+            # Set only the axes (image area) background to black
+            self.ax.set_facecolor('black')
+            
+            # Display each visible channel
+            for channel in range(4):
+                if (self.channel_visible[channel] and 
+                    self.channel_data[channel] is not None):
+                    
+                    # Check if we're dealing with RGB data
+                    is_rgb = len(self.channel_data[channel].shape) == 4 and self.channel_data[channel].shape[-1] == 3
+                    
+                    if len(self.channel_data[channel].shape) == 3 and not is_rgb:
+                        current_image = self.channel_data[channel][self.current_slice, :, :]
+                    elif is_rgb:
+                        current_image = self.channel_data[channel][self.current_slice]  # Already has RGB channels
+                    else:
+                        current_image = self.channel_data[channel]
+
+                    if is_rgb:
+                        # For RGB images, just display directly without colormap
+                        self.ax.imshow(current_image,
+                                     alpha=0.7)
+                    else:
+                        # Regular channel processing with colormap
+                        # Calculate brightness/contrast limits from entire volume
+                        img_min = self.min_max[channel][0]
+                        img_max = self.min_max[channel][1]
+                        
+                        # Calculate vmin and vmax, ensuring we don't get a zero range
+                        if img_min == img_max:
+                            vmin = img_min
+                            vmax = img_min + 1
+                        else:
+                            vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
+                            vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
+                        
+                        # Normalize the image safely
+                        if vmin == vmax:
+                            normalized_image = np.zeros_like(current_image)
+                        else:
+                            normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
+                        
+                        # Create custom colormap with higher intensity
+                        color = base_colors[channel]
+                        custom_cmap = LinearSegmentedColormap.from_list(
+                            f'custom_{channel}',
+                            [(0,0,0,0), (*color,1)]
+                        )
+                        
+                        # Display the image with slightly higher alpha
+                        self.ax.imshow(normalized_image,
+                                     alpha=0.7,
+                                     cmap=custom_cmap,
+                                     vmin=0,
+                                     vmax=1)
+
+            # Rest of the code remains the same...
+            # Add highlight overlay if it exists
+            if self.highlight_overlay is not None:
+                highlight_slice = self.highlight_overlay[self.current_slice]
+                highlight_cmap = LinearSegmentedColormap.from_list(
+                    'highlight',
+                    [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
                 )
+                self.ax.imshow(highlight_slice,
+                             cmap=highlight_cmap,
+                             alpha=0.5)
+
+            # Restore zoom limits if they existed
+            if current_xlim is not None and current_ylim is not None:
+                self.ax.set_xlim(current_xlim)
+                self.ax.set_ylim(current_ylim)
+            
+            # Style the axes
+            self.ax.set_xlabel('X')
+            self.ax.set_ylabel('Y')
+            self.ax.set_title(f'Slice {self.current_slice}')
+
+            # Make axis labels and ticks black for visibility against white background
+            self.ax.xaxis.label.set_color('black')
+            self.ax.yaxis.label.set_color('black')
+            self.ax.title.set_color('black')
+            self.ax.tick_params(colors='black')
+            for spine in self.ax.spines.values():
+                spine.set_color('black')
+
+            # Adjust the layout to ensure the plot fits well in the figure
+            self.figure.tight_layout()
+
+            # Redraw measurement points and their labels
+            for point in self.measurement_points:
+                x1, y1, z1 = point['point1']
+                x2, y2, z2 = point['point2']
+                pair_idx = point['pair_index']
                 
-                # Display the image with slightly higher alpha
-                self.ax.imshow(normalized_image,
-                             alpha=0.7,
-                             cmap=custom_cmap,
-                             vmin=0,
-                             vmax=1)
-
-        # Add highlight overlay if it exists
-        if self.highlight_overlay is not None:
-            highlight_slice = self.highlight_overlay[self.current_slice]
-            highlight_cmap = LinearSegmentedColormap.from_list(
-                'highlight',
-                [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
-            )
-            self.ax.imshow(highlight_slice,
-                         cmap=highlight_cmap,
-                         alpha=0.5)
-
-        # Restore zoom limits if they existed
-        if current_xlim is not None and current_ylim is not None:
-            self.ax.set_xlim(current_xlim)
-            self.ax.set_ylim(current_ylim)
-        
-        # Style the axes
-        self.ax.set_xlabel('X')
-        self.ax.set_ylabel('Y')
-        self.ax.set_title(f'Slice {self.current_slice}')
-
-        # Make axis labels and ticks black for visibility against white background
-        self.ax.xaxis.label.set_color('black')
-        self.ax.yaxis.label.set_color('black')
-        self.ax.title.set_color('black')
-        self.ax.tick_params(colors='black')
-        for spine in self.ax.spines.values():
-            spine.set_color('black')
-
-        # Adjust the layout to ensure the plot fits well in the figure
-        self.figure.tight_layout()
-
-        # Redraw measurement points and their labels
-        for point in self.measurement_points:
-            x1, y1, z1 = point['point1']
-            x2, y2, z2 = point['point2']
-            pair_idx = point['pair_index']
-            
-            # Draw points and labels if they're on current slice
-            if z1 == self.current_slice:
-                self.ax.plot(x1, y1, 'yo', markersize=8)
-                self.ax.text(x1, y1+5, str(pair_idx), 
-                            color='white', ha='center', va='bottom')
-            if z2 == self.current_slice:
-                self.ax.plot(x2, y2, 'yo', markersize=8)
-                self.ax.text(x2, y2+5, str(pair_idx), 
-                            color='white', ha='center', va='bottom')
-                
-            # Draw line if both points are on current slice
-            if z1 == z2 == self.current_slice:
-                self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
-    
+                # Draw points and labels if they're on current slice
+                if z1 == self.current_slice:
+                    self.ax.plot(x1, y1, 'yo', markersize=8)
+                    self.ax.text(x1, y1+5, str(pair_idx), 
+                                color='white', ha='center', va='bottom')
+                if z2 == self.current_slice:
+                    self.ax.plot(x2, y2, 'yo', markersize=8)
+                    self.ax.text(x2, y2+5, str(pair_idx), 
+                                color='white', ha='center', va='bottom')
+                    
+                # Draw line if both points are on current slice
+                if z1 == z2 == self.current_slice:
+                    self.ax.plot([x1, x2], [y1, y2], 'r--', alpha=0.5)
         
-        self.canvas.draw()
+            self.canvas.draw()
 
     def show_netshow_dialog(self):
         dialog = NetShowDialog(self)
@@ -2277,6 +2712,23 @@ class ImageViewerWindow(QMainWindow):
         dialog = PartitionDialog(self)
         dialog.exec()
 
+    def show_radial_dialog(self):
+        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()
+
+    def show_random_dialog(self):
+        dialog = RandomDialog(self)
+        dialog.exec()
+
+
     def show_interaction_dialog(self):
         dialog = InteractionDialog(self)
         dialog.exec()
@@ -2285,10 +2737,19 @@ class ImageViewerWindow(QMainWindow):
         dialog = DegreeDialog(self)
         dialog.exec()
 
+
+    def show_hub_dialog(self):
+        dialog = HubDialog(self)
+        dialog.exec()
+
     def show_mother_dialog(self):
         dialog = MotherDialog(self)
         dialog.exec()
 
+    def show_code_dialog(self):
+        dialog = CodeDialog(self)
+        dialog.exec()
+
 
 
 #TABLE RELATED: 
@@ -3509,6 +3970,9 @@ class NetShowDialog(QDialog):
     def show_network(self):
         # Get parameters and run analysis
         geo = self.geo_layout.isChecked()
+        if geo:
+            if my_network.node_centroids is None:
+                self.parent().show_centroid_dialog()
         accepted_mode = self.mode_selector.currentIndex()  # Convert to 1-based index
         # Get directory (None if empty)
         directory = self.directory.text() if self.directory.text() else None
@@ -3533,6 +3997,8 @@ class NetShowDialog(QDialog):
             self.accept()
         except Exception as e:
             print(f"Error showing network: {e}")
+            import traceback
+            print(traceback.format_exc())
 
 class PartitionDialog(QDialog):
     def __init__(self, parent=None):
@@ -3555,6 +4021,12 @@ class PartitionDialog(QDialog):
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
+        # stats checkbox (default True)
+        self.stats = QPushButton("Stats")
+        self.stats.setCheckable(True)
+        self.stats.setChecked(True)
+        layout.addRow("Community Stats:", self.stats)
+
         # Add Run button
         run_button = QPushButton("Partition")
         run_button.clicked.connect(self.partition)
@@ -3564,18 +4036,189 @@ class PartitionDialog(QDialog):
 
         accepted_mode = self.mode_selector.currentIndex()
         weighted = self.weighted.isChecked()
+        dostats = self.stats.isChecked()
+
+        my_network.communities = None
 
         try:
-            my_network.community_partition(weighted = weighted, style = accepted_mode)
+            stats = my_network.community_partition(weighted = weighted, style = accepted_mode, dostats = dostats)
             print(f"Discovered communities: {my_network.communities}")
 
-            self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'CommunityID')
+            self.parent().format_for_upperright_table(my_network.communities, 'NodeID', 'CommunityID', title = 'Community Partition')
+
+            if len(stats.keys()) > 0:
+                self.parent().format_for_upperright_table(stats, title = 'Community Stats')
 
             self.accept()
 
         except Exception as e:
             print(f"Error creating communities: {e}")
 
+class RadialDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Radial Parameters")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        self.distance = QLineEdit("50")
+        layout.addRow("Bucket Distance for Searching For Node Neighbors (automatically scaled by xy and z scales):", self.distance)
+
+        self.directory = QLineEdit("")
+        layout.addRow("Output Directory:", self.directory)
+
+        # Add Run button
+        run_button = QPushButton("Get Radial Distribution")
+        run_button.clicked.connect(self.radial)
+        layout.addWidget(run_button)
+
+    def radial(self):
+
+        distance = float(self.distance.text()) if self.distance.text().strip() else 50
+
+        directory = str(self.distance.text()) if self.directory.text().strip() else None
+
+        if my_network.node_centroids is None:
+            self.parent().show_centroid_dialog()
+
+        radial = my_network.radial_distribution(distance, directory = directory)
+
+        self.parent().format_for_upperright_table(radial, 'Radial Distance From Any Node', 'Average Number of Neighboring Nodes', title = 'Radial Distribution Analysis')
+
+        self.accept()
+
+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 Excpetion as e:
+            print(f"An error occurred: {e}")
+
+class NeighborIdentityDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle(f"Neighborhood Identity Distribution Parameters \n(Note - the same node is not included more than once as a neighbor even if it borders multiple nodes of the root ID)")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        self.root = QComboBox()
+        self.root.addItems(list(set(my_network.node_identities.values())))  
+        self.root.setCurrentIndex(0)
+        layout.addRow("Root Identity to Search for Neighbor's IDs (search uses nodes of this ID, finds what IDs they connect to", self.root)
+
+        self.directory = QLineEdit("")
+        layout.addRow("Output Directory:", self.directory)
+
+        self.mode = QComboBox()
+        self.mode.addItems(["From Network - Based on Absolute Connectivity", "Use Labeled Nodes - Based on Neighborhood Densities"])
+        self.mode.setCurrentIndex(0)
+        layout.addRow("Mode", self.mode)
+
+        self.search = QLineEdit("")
+        layout.addRow("Search Radius (Ignore if using network):", self.search)
+
+        # Add Run button
+        run_button = QPushButton("Get Neighborhood Identity Distribution")
+        run_button.clicked.connect(self.neighborids)
+        layout.addWidget(run_button)
+
+    def neighborids(self):
+
+        root = self.root.currentText()
+
+        directory = self.directory.text() if self.directory.text().strip() else None
+
+        mode = self.mode.currentIndex()
+
+        search = float(self.search.text()) if self.search.text().strip() else 0
+
+
+        result, result2, title1, title2 = my_network.neighborhood_identities(root = root, directory = directory, mode = mode, search = search)
+
+        self.parent().format_for_upperright_table(result, 'Node Identity', 'Amount', title = title1)
+        self.parent().format_for_upperright_table(result2, 'Node Identity', 'Proportion', title = title2)
+
+        self.accept()
+
+
+
+
+
+
+
+
+class RandomDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Degree Distribution Parameters")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+
+        # stats checkbox (default True)
+        self.weighted = QPushButton("weighted")
+        self.weighted.setCheckable(True)
+        self.weighted.setChecked(True)
+        layout.addRow("Allow Random Network to be weighted? (Whether or not edges can be repeatedly assigned between the same set of nodes to increase their weights, or if they must always find a new partner):", self.weighted)
+        
+
+        # Add Run button
+        run_button = QPushButton("Get Random Network (Will go in Selection Table)")
+        run_button.clicked.connect(self.random)
+        layout.addWidget(run_button)
+
+    def random(self):
+
+        weighted = self.weighted.isChecked()
+
+        _, df = my_network.assign_random(weighted = weighted)
+
+        # Create new model with filtered DataFrame and update selection table
+        new_model = PandasModel(df)
+        self.parent().selection_table.setModel(new_model)
+        
+        # Switch to selection table
+        self.parent().selection_button.click()
+
+        self.accept()
+
+
 
 class InteractionDialog(QDialog):
 
@@ -3645,6 +4288,9 @@ class DegreeDialog(QDialog):
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
+        self.mask_limiter = QLineEdit("1")
+        layout.addRow("Masks smaller high degree proportion of nodes (ignore if only returning degrees)", self.mask_limiter)
+
         self.down_factor = QLineEdit("1")
         layout.addRow("down_factor (for speeding up overlay generation - ignore if only returning degrees:", self.down_factor)
 
@@ -3664,6 +4310,11 @@ class DegreeDialog(QDialog):
             except ValueError:
                 down_factor = 1
 
+            try:
+                mask_limiter = float(self.mask_limiter.text()) if self.mask_limiter.text() else 1
+            except ValueError:
+                mask_limiter = 1
+
             if self.parent().active_channel == 1:
                 active_data = self.parent().channel_data[0]
             else:
@@ -3680,9 +4331,47 @@ class DegreeDialog(QDialog):
 
             original_shape = copy.deepcopy(active_data.shape)
 
-            temp_network = n3d.Network_3D(nodes = active_data, node_centroids = my_network.node_centroids, network = my_network.network, network_lists = my_network.network_lists)
 
-            result, nodes = temp_network.get_degrees(called = True, no_img = accepted_mode, down_factor = down_factor)
+            if mask_limiter < 1 and accepted_mode != 0:
+
+                if len(np.unique(active_data)) < 3:
+                    active_data, _ = n3d.label_objects(active_data)
+
+                node_list = list(my_network.network.nodes)
+                node_dict = {}
+
+                for node in node_list:
+                    node_dict[node] = (my_network.network.degree(node))
+
+                # Calculate the number of top proportion% entries
+                num_items = len(node_dict)
+                num_top_10_percent = max(1, int(num_items * mask_limiter))  # Ensure at least one item
+
+                # Sort the dictionary by values in descending order and get the top 10%
+                sorted_items = sorted(node_dict.items(), key=lambda item: item[1], reverse=True)
+                top_10_percent_items = sorted_items[:num_top_10_percent]
+
+                # Extract the keys from the top proportion% items
+                top_10_percent_keys = [key for key, value in top_10_percent_items]
+
+                mask = np.isin(active_data, top_10_percent_keys)
+                nodes = mask * active_data
+                new_centroids = {}
+                for node in my_network.node_centroids:
+                    if node in top_10_percent_keys:
+                        new_centroids[node] = my_network.node_centroids[node]
+                del mask
+
+                temp_network = n3d.Network_3D(nodes = nodes, node_centroids = new_centroids, network = my_network.network, network_lists = my_network.network_lists)
+
+                result, nodes = temp_network.get_degrees(called = True, no_img = accepted_mode, down_factor = down_factor)
+
+            else:
+                temp_network = n3d.Network_3D(nodes = active_data, node_centroids = my_network.node_centroids, network = my_network.network, network_lists = my_network.network_lists)
+
+                result, nodes = temp_network.get_degrees(called = True, no_img = accepted_mode, down_factor = down_factor)
+
+
 
             self.parent().format_for_upperright_table(result, 'Node ID', 'Degree', title = 'Degrees of nodes')
 
@@ -3698,9 +4387,75 @@ class DegreeDialog(QDialog):
 
         except Exception as e:
 
+            import traceback
+            print(traceback.format_exc())
+
             print(f"Error finding degrees: {e}")
 
 
+class HubDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Hub Parameters")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        layout.addRow("Note:", QLabel(f"Finds hubs, which are nodes in the network that have the shortest number of steps to the other nodes\nWe can draw optional overlays to Overlay 2 as described below:"))
+
+        # Overlay checkbox (default True)
+        self.overlay = QPushButton("Overlay")
+        self.overlay.setCheckable(True)
+        self.overlay.setChecked(True)
+        layout.addRow("Make Overlay?:", self.overlay)
+
+
+        self.proportion = QLineEdit("0.15")
+        layout.addRow("Proportion of most connected hubs to keep (1 would imply returning entire network)", self.proportion)
+
+
+        # Add Run button
+        run_button = QPushButton("Get hubs")
+        run_button.clicked.connect(self.hubs)
+        layout.addWidget(run_button)
+
+    def hubs(self):
+
+        try:
+
+            try:
+                proportion = float(self.proportion.text()) if self.proportion.text() else 1
+            except ValueError:
+                proportion = 1
+
+            overlay = self.overlay.isChecked()
+
+            result, img = my_network.isolate_hubs(proportion = proportion, retimg = overlay)
+
+            hub_dict = {}
+
+            for node in result:
+                hub_dict[node] = my_network.network.degree(node)
+
+            self.parent().format_for_upperright_table(hub_dict, 'NodeID', 'Degree', title = f'Upper {proportion} Hub Nodes')
+
+            if img is not None:
+
+                self.parent().load_channel(3, channel_data = img, data = True)
+
+
+            self.accept()
+
+        except Exception as e:
+
+            import traceback
+            print(traceback.format_exc())
+
+            print(f"Error finding hubs: {e}")
+
+
 
 class MotherDialog(QDialog):
 
@@ -3749,7 +4504,12 @@ class MotherDialog(QDialog):
                 G, result = my_network.isolate_mothers(self, louvain = my_network.communities, ret_nodes = False, called = True)
                 self.parent().load_channel(2, channel_data = result, data = True)
 
-            self.parent().format_for_upperright_table(G.nodes(), 'Mothers', title = 'Mother Nodes')
+            degree_dict = {}
+
+            for node in G.nodes():
+                degree_dict[node] = my_network.network.degree(node)
+
+            self.parent().format_for_upperright_table(degree_dict, 'Mother ID', 'Degree', title = 'Mother Nodes')
 
 
             self.accept()
@@ -3759,6 +4519,58 @@ class MotherDialog(QDialog):
             print(f"Error finding mothers: {e}")
 
 
+class CodeDialog(QDialog):
+
+    def __init__(self, parent=None):
+
+        super().__init__(parent)
+        self.setWindowTitle("Community Code Parameters (Will go to Overlay2)")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        self.down_factor = QLineEdit("")
+        layout.addRow("down_factor (for speeding up overlay generation - optional):", self.down_factor)
+
+        # Add mode selection dropdown
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["Color Coded", "Grayscale Coded"])
+        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("Execution Mode:", self.mode_selector)
+
+
+        # Add Run button
+        run_button = QPushButton("Community Code")
+        run_button.clicked.connect(self.code)
+        layout.addWidget(run_button)
+
+    def code(self):
+
+        try:
+
+            mode = self.mode_selector.currentIndex()
+
+            down_factor = float(self.down_factor.text()) if self.down_factor.text().strip() else None
+
+
+
+            if my_network.communities is None:
+                self.parent().show_partition_dialog()
+                if my_network.communities is None:
+                    return
+
+            if mode == 0:
+                image = my_network.extract_communities(down_factor = down_factor)
+            elif mode == 1:
+                image = my_network.extract_communities(color_code = False, down_factor = down_factor)
+
+
+            self.parent().load_channel(3, image, True)
+            self.accept()
+
+        except Exception as e:
+            print(f"An error has occurred: {e}")
+
 
 
 
@@ -3790,7 +4602,11 @@ class ResizeDialog(QDialog):
         self.cubic.setChecked(False)
         layout.addRow("Use cubic algorithm:", self.cubic)
         
-        
+        if self.parent().original_shape is not None:
+            undo_button = QPushButton(f"Resample to original shape: {self.parent().original_shape}")
+            undo_button.clicked.connect(lambda: self.run_resize(undo = True))
+            layout.addRow(undo_button)
+
         run_button = QPushButton("Run Resize")
         run_button.clicked.connect(self.run_resize)
         layout.addRow(run_button)
@@ -3800,9 +4616,9 @@ class ResizeDialog(QDialog):
         self.resize.clear()
         self.zsize.setText("1")
         self.xsize.setText("1")
-        self.ysize.setText("1")
+        self.ysize.setText("1")        
 
-    def run_resize(self):
+    def run_resize(self, undo = False):
         try:
             # Get parameters
             try:
@@ -3851,16 +4667,31 @@ class ResizeDialog(QDialog):
             self.parent().slice_slider.setValue(0)
             self.parent().current_slice = 0
             
-            # Process each channel
-            for channel in range(4):
-                if self.parent().channel_data[channel] is not None:
-                    resized_data = n3d.resize(self.parent().channel_data[channel], resize, order)
-                    self.parent().load_channel(channel, channel_data=resized_data, data=True)
+            if not undo:
+                # Process each channel
+                for channel in range(4):
+                    if self.parent().channel_data[channel] is not None:
+                        resized_data = n3d.resize(self.parent().channel_data[channel], resize, order)
+                        self.parent().load_channel(channel, channel_data=resized_data, data=True, assign_shape = False)
+
+                
+                # Process highlight overlay if it exists
+                if self.parent().highlight_overlay is not None:
+                    self.parent().highlight_overlay = n3d.resize(self.parent().highlight_overlay, resize, order)
+            else:
+                # Process each channel
+                if array_shape == self.parent().original_shape:
+                    return
+                for channel in range(4):
+                    if self.parent().channel_data[channel] is not None:
+                        resized_data = n3d.upsample_with_padding(self.parent().channel_data[channel], original_shape = self.parent().original_shape)
+                        self.parent().load_channel(channel, channel_data=resized_data, data=True, assign_shape = False)
+
+                
+                # Process highlight overlay if it exists
+                if self.parent().highlight_overlay is not None:
+                    self.parent().highlight_overlay = n3d.upsample_with_padding(self.parent().highlight_overlay, original_shape = self.parent().original_shape)
 
-            
-            # Process highlight overlay if it exists
-            if self.parent().highlight_overlay is not None:
-                self.parent().highlight_overlay = n3d.resize(self.parent().highlight_overlay, resize, order)
             
             # Update slider range based on new z-dimension
             for channel in self.parent().channel_data:
@@ -3984,78 +4815,317 @@ class BinarizeDialog(QDialog):
                     f"Error running binarize: {str(e)}"
                 )
 
-        except Exception as e:
-            QMessageBox.critical(
-                self,
-                "Error",
-                f"Error running binarize: {str(e)}"
-            )
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                "Error",
+                f"Error running binarize: {str(e)}"
+            )
+
+class LabelDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Label Active Channel?")
+        self.setModal(True)
+        
+        layout = QFormLayout(self)
+
+       # Add Run button
+        run_button = QPushButton("Run Label")
+        run_button.clicked.connect(self.run_label)
+        layout.addRow(run_button)
+
+    def run_label(self):
+
+        try:
+
+            # Get the active channel data from parent
+            active_data = self.parent().channel_data[self.parent().active_channel]
+            if active_data is None:
+                raise ValueError("No active image selected")
+
+            try:
+                # Call watershed method with parameters
+                result, _ = n3d.label_objects(
+                    active_data
+                    )
+
+                # Update both the display data and the network object
+                self.parent().channel_data[self.parent().active_channel] = result
+
+
+                # Update the corresponding property in my_network
+                setattr(my_network, network_properties[self.parent().active_channel], result)
+
+                self.parent().update_display()
+                self.accept()
+                
+            except Exception as e:
+                QMessageBox.critical(
+                    self,
+                    "Error",
+                    f"Error running label: {str(e)}"
+                )
+
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                "Error",
+                f"Error running label: {str(e)}"
+            )
+
+class ThresholdWindow(QMainWindow):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Threshold Params (Active Image)")
+        
+        # Create central widget and layout
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        layout = QFormLayout(central_widget)
+
+        self.min = QLineEdit("")
+        layout.addRow("Minimum Value to retain:", self.min)
+        
+        # Create widgets
+        self.max = QLineEdit("")
+        layout.addRow("Maximum Value to retain:", self.max)
+
+        # Add mode selection dropdown
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["Using Volumes", "Using Label/Brightness"])
+        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("Execution Mode:", self.mode_selector)
+
+        # Add Run button
+        prev_button = QPushButton("Preview")
+        prev_button.clicked.connect(self.run_preview)
+        layout.addRow(prev_button)
+        
+        # Add Run button
+        run_button = QPushButton("Apply Threshold")
+        run_button.clicked.connect(self.thresh)
+        layout.addRow(run_button)
+        
+        # Set a reasonable default size
+        self.setMinimumWidth(300)
+        
+    def run_preview(self):
+
+        def get_valid_float(text, default_value):
+            try:
+                return float(text) if text.strip() else default_value
+            except ValueError:
+                print(f"Invalid input: {text}")
+                return default_value
+
+        try:
+            channel = self.parent().active_channel
+            accepted_mode = self.mode_selector.currentIndex()
+            
+            if accepted_mode == 0:
+                if len(np.unique(self.parent().channel_data[self.parent().active_channel])) < 3:
+                    self.parent().show_label_dialog()
+
+                if self.parent().volume_dict[channel] is None:
+                    self.parent().volumes()
+                    
+                volumes = self.parent().volume_dict[channel]
+                default_max = max(volumes.values())
+                default_min = min(volumes.values())
+                
+                max_val = get_valid_float(self.max.text(), default_max)
+                min_val = get_valid_float(self.min.text(), default_min)
+                
+                valid_indices = [item for item in volumes 
+                                if min_val <= volumes[item] <= max_val]
+                                
+            elif accepted_mode == 1:
+                channel_data = self.parent().channel_data[self.parent().active_channel]
+                default_max = np.max(channel_data)
+                default_min = np.min(channel_data)
+                
+                max_val = int(get_valid_float(self.max.text(), default_max))
+                min_val = int(get_valid_float(self.min.text(), default_min))
+                
+                if min_val > max_val:
+                    min_val, max_val = max_val, min_val
+                    
+                valid_indices = list(range(min_val, max_val + 1))
+            
+            if channel == 0:
+                self.parent().create_highlight_overlay(node_indices = valid_indices)
+            elif channel == 1:
+                self.parent().create_highlight_overlay(edge_indices = valid_indices)
+            elif channel == 2:
+                self.parent().create_highlight_overlay(overlay1_indices = valid_indices)
+            elif channel == 3:
+                self.parent().create_highlight_overlay(overlay2_indices = valid_indices)
+
+        except Exception as e:
+            print(f"Error showing preview: {e}")
+
+    def thresh(self):
+        try:
+
+            self.run_preview()
+            channel_data = self.parent().channel_data[self.parent().active_channel]
+            mask = self.parent().highlight_overlay > 0
+            channel_data = channel_data * mask
+            self.parent().load_channel(self.parent().active_channel, channel_data, True)
+            self.parent().update_display()
+            self.close()
+            
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                "Error",
+                f"Error running threshold: {str(e)}"
+            )
+
+
+class SmartDilateDialog(QDialog):
+    def __init__(self, parent, params):
+        super().__init__(parent)
+        self.setWindowTitle("Additional Smart Dilate Parameters")
+        self.setModal(True)
+
+        layout = QFormLayout(self)
+
+        # GPU checkbox (default True)
+        self.GPU = QPushButton("GPU")
+        self.GPU.setCheckable(True)
+        self.GPU.setChecked(True)
+        layout.addRow("Use GPU:", self.GPU)
+
+        self.down_factor = QLineEdit("")
+        layout.addRow("Internal Downsample for GPU (if needed):", self.down_factor)
+
+        self.params = params
+
+        # Add Run button
+        run_button = QPushButton("Dilate")
+        run_button.clicked.connect(self.smart_dilate)
+        layout.addRow(run_button)
+
+    def smart_dilate(self):
+
+        GPU = self.GPU.isChecked()
+        down_factor = float(self.down_factor.text()) if self.down_factor.text().strip() else None
+        active_data, amount, xy_scale, z_scale = self.params
+
+        dilate_xy, dilate_z = n3d.dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
+
+        result = sdl.smart_dilate(active_data, dilate_xy, dilate_z, GPU = GPU, predownsample = down_factor)
+
+        self.parent().load_channel(self.parent().active_channel, result, True)
+        self.accept()
+
+
+
+class DilateDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Dilate Parameters")
+        self.setModal(True)
+        
+        layout = QFormLayout(self)
+
+        self.amount = QLineEdit("1")
+        layout.addRow("Dilation Radius:", self.amount)
+
+        if my_network.xy_scale is not None:
+            xy_scale = f"{my_network.xy_scale}"
+        else:
+            xy_scale = "1"
+
+        self.xy_scale = QLineEdit(xy_scale)
+        layout.addRow("xy_scale:", self.xy_scale)
+
+        if my_network.z_scale is not None:
+            z_scale = f"{my_network.z_scale}"
+        else:
+            z_scale = "1"
+
+        self.z_scale = QLineEdit(z_scale)
+        layout.addRow("z_scale:", self.z_scale)
 
-class LabelDialog(QDialog):
-    def __init__(self, parent=None):
-        super().__init__(parent)
-        self.setWindowTitle("Label Active Channel?")
-        self.setModal(True)
-        
-        layout = QFormLayout(self)
+        # Add mode selection dropdown
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["Binary Dilation", "Preserve Labels (slower)"])
+        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("Execution Mode:", self.mode_selector)
 
        # Add Run button
-        run_button = QPushButton("Run Label")
-        run_button.clicked.connect(self.run_label)
+        run_button = QPushButton("Run Dilate")
+        run_button.clicked.connect(self.run_dilate)
         layout.addRow(run_button)
 
-    def run_label(self):
-
+    def run_dilate(self):
         try:
 
+            accepted_mode = self.mode_selector.currentIndex()
+            
+            # Get amount
+            try:
+                amount = float(self.amount.text()) if self.amount.text() else 1
+            except ValueError:
+                amount = 1
+
+            try:
+                xy_scale = float(self.xy_scale.text()) if self.xy_scale.text() else 1
+            except ValueError:
+                xy_scale = 1
+
+            try:
+                z_scale = float(self.z_scale.text()) if self.z_scale.text() else 1
+            except ValueError:
+                z_scale = 1
+            
             # Get the active channel data from parent
             active_data = self.parent().channel_data[self.parent().active_channel]
             if active_data is None:
                 raise ValueError("No active image selected")
 
-            try:
-                # Call watershed method with parameters
-                result, _ = n3d.label_objects(
-                    active_data
-                    )
-
-                # Update both the display data and the network object
-                self.parent().channel_data[self.parent().active_channel] = result
-
+            if accepted_mode == 1:
+                dialog = SmartDilateDialog(self.parent(), [active_data, amount, xy_scale, z_scale])
+                dialog.exec()
+                self.accept()
+                return
 
-                # Update the corresponding property in my_network
-                setattr(my_network, network_properties[self.parent().active_channel], result)
+            # Call dilate method with parameters
+            result = n3d.dilate(
+                active_data,
+                amount,
+                xy_scale = xy_scale,
+                z_scale = z_scale,
+            )
 
-                self.parent().update_display()
-                self.accept()
-                
-            except Exception as e:
-                QMessageBox.critical(
-                    self,
-                    "Error",
-                    f"Error running label: {str(e)}"
-                )
+            # Update both the display data and the network object
+            self.parent().load_channel(self.parent().active_channel, result, True)
 
+            self.parent().update_display()
+            self.accept()
+            
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
             QMessageBox.critical(
                 self,
                 "Error",
-                f"Error running label: {str(e)}"
+                f"Error running dilate: {str(e)}"
             )
 
-
-
-
-class DilateDialog(QDialog):
+class ErodeDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.setWindowTitle("Dilate Parameters")
+        self.setWindowTitle("Erosion Parameters")
         self.setModal(True)
         
         layout = QFormLayout(self)
 
         self.amount = QLineEdit("1")
-        layout.addRow("Dilation Radius:", self.amount)
+        layout.addRow("Erosion Radius:", self.amount)
 
         if my_network.xy_scale is not None:
             xy_scale = f"{my_network.xy_scale}"
@@ -4074,11 +5144,11 @@ class DilateDialog(QDialog):
         layout.addRow("z_scale:", self.z_scale)
 
        # Add Run button
-        run_button = QPushButton("Run Dilate")
-        run_button.clicked.connect(self.run_dilate)
+        run_button = QPushButton("Run Erode")
+        run_button.clicked.connect(self.run_erode)
         layout.addRow(run_button)
 
-    def run_dilate(self):
+    def run_erode(self):
         try:
             
             # Get amount
@@ -4103,7 +5173,7 @@ class DilateDialog(QDialog):
                 raise ValueError("No active image selected")
             
             # Call dilate method with parameters
-            result = n3d.dilate(
+            result = n3d.erode(
                 active_data,
                 amount,
                 xy_scale = xy_scale,
@@ -4124,7 +5194,46 @@ class DilateDialog(QDialog):
             QMessageBox.critical(
                 self,
                 "Error",
-                f"Error running dilate: {str(e)}"
+                f"Error running erode: {str(e)}"
+            )
+
+class HoleDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Fill Holes? (Active Image)")
+        self.setModal(True)
+        
+        layout = QFormLayout(self)
+
+       # Add Run button
+        run_button = QPushButton("Run Fill Holes")
+        run_button.clicked.connect(self.run_holes)
+        layout.addRow(run_button)
+
+    def run_holes(self):
+        try:
+            
+            
+            # Get the active channel data from parent
+            active_data = self.parent().channel_data[self.parent().active_channel]
+            if active_data is None:
+                raise ValueError("No active image selected")
+            
+            # Call dilate method with parameters
+            result = n3d.fill_holes_3d(
+                active_data
+            )
+
+            self.parent().load_channel(self.parent().active_channel, result, True)
+
+            self.parent().update_display()
+            self.accept()
+            
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                "Error",
+                f"Error running fill holes: {str(e)}"
             )
 
 class MaskDialog(QDialog):
@@ -4372,6 +5481,40 @@ class WatershedDialog(QDialog):
                 f"Error running watershed: {str(e)}"
             )
 
+class ZDialog(QDialog):
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Z Parameters (Save your network first - this will alter all channels into 2D versions)")
+        self.setModal(True)
+        
+        layout = QFormLayout(self)
+
+        # Add mode selection dropdown
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["max", "mean", "min", "sum", "std"])
+        self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
+        layout.addRow("Execution Mode:", self.mode_selector)
+
+        # Add Run button
+        run_button = QPushButton("Run Z Project")
+        run_button.clicked.connect(self.run_z)
+        layout.addRow(run_button)
+
+    def run_z(self):
+
+        mode = self.mode_selector.currentText()
+
+        for i in range(len(self.parent().channel_data)):
+            try:
+                self.parent().channel_data[i] = n3d.z_project(self.parent().channel_data[i], mode)
+                self.parent().load_channel(i, self.parent().channel_data[i], True)
+            except:
+                pass
+
+        self.accept()
+
+
 class CentroidNodeDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
@@ -4624,6 +5767,275 @@ class BranchDialog(QDialog):
 
 
 
+class IsolateDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Select Node types to isolate")
+        self.setModal(True)
+        layout = QFormLayout(self)
+        
+        self.combo1 = QComboBox()
+        self.combo1.addItems(list(set(my_network.node_identities.values())))  
+        self.combo1.setCurrentIndex(0)
+        layout.addRow("ID 1:", self.combo1)
+        
+        self.combo2 = QComboBox()
+        self.combo2.addItems(list(set(my_network.node_identities.values())))      
+        self.combo2.setCurrentIndex(1)
+        layout.addRow("ID 2:", self.combo2)
+        
+        # Add submit button
+        sub_button = QPushButton("Submit")
+        sub_button.clicked.connect(self.submit_ids)
+        layout.addRow(sub_button)
+
+    def submit_ids(self):
+        try:
+            id1 = self.combo1.currentText()
+            id2 = self.combo2.currentText()
+            if id1 == id2:
+                print("Please select different identities")
+                self.parent().show_isolate_dialog()
+                return
+            else:
+                my_network.isolate_internode_connections(id1, id2)
+                self.accept()
+        except Exception as e:
+            print(f"An error occurred: {e}")
+
+class AlterDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Enter Node/Edge groups to add/remove")
+        self.setModal(True)
+        layout = QFormLayout(self)
+        
+        # Node 1
+        self.node1 = QLineEdit()
+        self.node1.setPlaceholderText("Enter integer")
+        layout.addRow("Node1:", self.node1)
+        
+        # Node 2
+        self.node2 = QLineEdit()
+        self.node2.setPlaceholderText("Enter integer")
+        layout.addRow("Node2:", self.node2)
+        
+        # Edge
+        self.edge = QLineEdit()
+        self.edge.setPlaceholderText("Optional - Enter integer")
+        layout.addRow("Edge:", self.edge)
+        
+        # Add add button
+        addbutton = QPushButton("Add pair")
+        addbutton.clicked.connect(self.add)
+        layout.addRow(addbutton)
+        
+        # Add remove button
+        removebutton = QPushButton("Remove pair")
+        removebutton.clicked.connect(self.remove)
+        layout.addRow(removebutton)
+
+    def add(self):
+        try:
+            node1 = int(self.node1.text()) if self.node1.text().strip() else None
+            node2 = int(self.node2.text()) if self.node2.text().strip() else None
+            edge = int(self.edge.text()) if self.edge.text().strip() else None
+            
+            # Check if we have valid node pairs
+            if node1 is not None and node2 is not None:
+                # Add the node pair and its reverse
+                my_network.network_lists[0].append(node1)
+                my_network.network_lists[1].append(node2)
+                # Add edge value (0 if none provided)
+                my_network.network_lists[2].append(edge if edge is not None else 0)
+                
+                # Add reverse pair with same edge value
+                my_network.network_lists[0].append(node2)
+                my_network.network_lists[1].append(node1)
+                my_network.network_lists[2].append(edge if edge is not None else 0)
+            try:
+                if hasattr(my_network, 'network_lists'):
+                    model = PandasModel(my_network.network_lists)
+                    self.parent().network_table.setModel(model)
+                    # Adjust column widths to content
+                    for column in range(model.columnCount(None)):
+                        self.parent().network_table.resizeColumnToContents(column)
+            except Exception as e:
+                print(f"Error showing network table: {e}")
+        except ValueError:
+            import traceback
+            print(traceback.format_exc())
+            pass  # Invalid input - do nothing
+
+    def remove(self):
+        try:
+            node1 = int(self.node1.text()) if self.node1.text().strip() else None
+            node2 = int(self.node2.text()) if self.node2.text().strip() else None
+            edge = int(self.edge.text()) if self.edge.text().strip() else None
+            
+            # Check if we have valid node pairs
+            if node1 is not None and node2 is not None:
+                # Create lists for indices to remove
+                indices_to_remove = []
+                
+                # Loop through the lists to find matching pairs
+                for i in range(len(my_network.network_lists[0])):
+                    forward_match = (my_network.network_lists[0][i] == node1 and 
+                                   my_network.network_lists[1][i] == node2)
+                    reverse_match = (my_network.network_lists[0][i] == node2 and 
+                                   my_network.network_lists[1][i] == node1)
+                    
+                    if forward_match or reverse_match:
+                        # If edge value specified, only remove if edge matches
+                        if edge is not None:
+                            if my_network.network_lists[2][i] == edge:
+                                indices_to_remove.append(i)
+                        else:
+                            # If no edge specified, remove all matching pairs
+                            indices_to_remove.append(i)
+                
+                # Remove elements in reverse order to maintain correct indices
+                for i in sorted(indices_to_remove, reverse=True):
+                    my_network.network_lists[0].pop(i)
+                    my_network.network_lists[1].pop(i)
+                    my_network.network_lists[2].pop(i)
+
+            try:
+                if hasattr(my_network, 'network_lists'):
+                    model = PandasModel(my_network.network_lists)
+                    self.parent().network_table.setModel(model)
+                    # Adjust column widths to content
+                    for column in range(model.columnCount(None)):
+                        self.parent().network_table.resizeColumnToContents(column)
+            except Exception as e:
+                print(f"Error showing network table: {e}")
+                    
+        except ValueError:
+            import traceback
+            print(traceback.format_exc())
+            pass  # Invalid input - do nothing
+
+
+class ModifyDialog(QDialog):
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Create Nodes from Edge Vertices")
+        self.setModal(True)
+        layout = QFormLayout(self)
+        
+        # trunk checkbox (default false)
+        self.trunk = QPushButton("Remove Trunk")
+        self.trunk.setCheckable(True)
+        self.trunk.setChecked(False)
+        layout.addRow("Remove Trunk? (Most connected edge - overrides below):", self.trunk)
+        
+        # trunk checkbox (default false)
+        self.trunknode = QPushButton("Trunk -> Node")
+        self.trunknode.setCheckable(True)
+        self.trunknode.setChecked(False)
+        layout.addRow("Convert Trunk to Node? (Most connected edge):", self.trunknode)
+        
+        # edgenode checkbox (default false)
+        self.edgenode = QPushButton("Edges -> Nodes")
+        self.edgenode.setCheckable(True)
+        self.edgenode.setChecked(False)
+        layout.addRow("Convert 'Edges (Labeled objects)' to node objects?:", self.edgenode)
+        
+        # edgeweight checkbox (default false)
+        self.edgeweight = QPushButton("Remove weights")
+        self.edgeweight.setCheckable(True)
+        self.edgeweight.setChecked(False)
+        layout.addRow("Remove network weights?:", self.edgeweight)
+        
+        # prune checkbox (default false)
+        self.prune = QPushButton("Prune Same Type")
+        self.prune.setCheckable(True)
+        self.prune.setChecked(False)
+        layout.addRow("Prune connections between nodes of the same type (if assigned)?:", self.prune)
+        
+        # isolate checkbox (default false)
+        self.isolate = QPushButton("Isolate Two Types")
+        self.isolate.setCheckable(True)
+        self.isolate.setChecked(False)
+        layout.addRow("Isolate connections between two specific node types (if assigned)?:", self.isolate)
+
+        #change button
+        change_button = QPushButton("Add/Remove Network Pairs")
+        change_button.clicked.connect(self.show_alter_dialog)
+        layout.addRow(change_button)
+                
+        # Add Run button
+        run_button = QPushButton("Make Changes")
+        run_button.clicked.connect(self.run_changes)
+        layout.addRow(run_button)
+
+    def show_isolate_dialog(self):
+
+        dialog = IsolateDialog(self)
+        dialog.exec()
+
+    def show_alter_dialog(self):
+
+        dialog = AlterDialog(self.parent())
+        dialog.exec()
+
+    def run_changes(self):
+
+        try:
+
+            trunk = self.trunk.isChecked()
+            if not trunk:
+                trunknode = self.trunknode.isChecked()
+            else:
+                trunknode = False
+            edgenode = self.edgenode.isChecked()
+            edgeweight = self.edgeweight.isChecked()
+            prune = self.prune.isChecked()
+            isolate = self.isolate.isChecked()
+
+            if isolate and my_network.node_identities is not None:
+                self.show_isolate_dialog()
+
+            if edgeweight:
+                my_network.remove_edge_weights()
+            if prune and my_network.node_identities is not None:
+                my_network.prune_samenode_connections()
+            if trunk:
+                my_network.remove_trunk_post()
+            if trunknode:
+                if my_network.node_centroids is None or my_network.edge_centroids is None:
+                    self.parent().show_centroid_dialog()
+                my_network.trunk_to_node()
+                self.parent().load_channel(0, my_network.nodes, True)
+            if edgenode:
+                if my_network.node_centroids is None or my_network.edge_centroids is None:
+                    self.parent().show_centroid_dialog()
+                my_network.edge_to_node()
+                self.parent().load_channel(0, my_network.nodes, True)
+                self.parent().load_channel(1, my_network.edges, True)
+
+            try:
+                if hasattr(my_network, 'network_lists'):
+                    model = PandasModel(my_network.network_lists)
+                    self.parent().network_table.setModel(model)
+                    # Adjust column widths to content
+                    for column in range(model.columnCount(None)):
+                        self.parent().network_table.resizeColumnToContents(column)
+            except Exception as e:
+                print(f"Error showing network table: {e}")
+
+            if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
+                try:
+                    self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+                except Exception as e:
+                    print(f"Error loading node identity table: {e}")
+
+            self.parent().update_display()
+            self.accept()
+
+        except Exception as e:
+            print(f"An error occurred: {e}")
+
 
 
 
@@ -5031,6 +6443,15 @@ class ProxDialog(QDialog):
         self.mode_selector.setCurrentIndex(0)  # Default to Mode 1
         layout.addRow("Execution Mode:", self.mode_selector)
 
+        if my_network.node_identities is not None:
+            self.id_selector = QComboBox()
+            # Add all options from id dictionary
+            self.id_selector.addItems(['None'] + list(set(my_network.node_identities.values())))
+            self.id_selector.setCurrentIndex(0)  # Default to Mode 1
+            layout.addRow("Create Networks only from a specific node identity?:", self.id_selector)
+        else:
+            self.id_selector = None
+
         self.overlays = QPushButton("Overlays")
         self.overlays.setCheckable(True)
         self.overlays.setChecked(True)
@@ -5054,6 +6475,15 @@ class ProxDialog(QDialog):
 
             mode = self.mode_selector.currentIndex()
 
+            if self.id_selector is not None and self.id_selector.currentText() != 'None':
+                target = self.id_selector.currentText()
+                targets = []
+                for node in my_network.node_identities:
+                    if target == my_network.node_identities[node]:
+                        targets.append(int(node))
+            else:
+                targets = None
+
             try:
                 directory = self.directory.text() if self.directory.text() else None
             except:
@@ -5087,7 +6517,7 @@ class ProxDialog(QDialog):
                     my_network.nodes, _ = n3d.label_objects(my_network.nodes)
                 if my_network.node_centroids is None:
                     self.parent().show_centroid_dialog()
-                my_network.morph_proximity(search = search)
+                my_network.morph_proximity(search = search, targets = targets)
 
                 self.parent().load_channel(0, channel_data = my_network.nodes, data = True)
             elif mode == 0:
@@ -5113,10 +6543,10 @@ class ProxDialog(QDialog):
                     return
                     
                 if populate:
-                    my_network.nodes = my_network.kd_network(distance = search)
+                    my_network.nodes = my_network.kd_network(distance = search, targets = targets)
                     self.parent().load_channel(0, channel_data = my_network.nodes, data = True)
                 else:
-                    my_network.kd_network(distance = search)
+                    my_network.kd_network(distance = search, targets = targets)
 
 
             my_network.dump(directory = directory)