nettracer3d 0.9.5__py3-none-any.whl → 0.9.6__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -5,7 +5,7 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout, QG
                             QFormLayout, QLineEdit, QPushButton, QFileDialog,
                             QLabel, QComboBox, QMessageBox, QTableView, QInputDialog,
                             QMenu, QTabWidget, QGroupBox)
-from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal, QObject, QCoreApplication, QEvent)
+from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal, QObject, QCoreApplication, QEvent, QEventLoop)
 import numpy as np
 import time
 from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
@@ -1002,7 +1002,15 @@ class ImageViewerWindow(QMainWindow):
             pass
 
         # Update display
-        self.update_display(preserve_zoom=(current_xlim, current_ylim), called = True)
+        self.update_display(preserve_zoom=(current_xlim, current_ylim))
+
+        if self.pan_mode:
+            self.create_pan_background()
+            current_xlim = self.ax.get_xlim()
+            current_ylim = self.ax.get_ylim()
+            self.update_display_pan_mode(current_xlim, current_ylim)
+
+
 
     def create_mini_overlay(self, node_indices = None, edge_indices = None):
 
@@ -2473,7 +2481,7 @@ class ImageViewerWindow(QMainWindow):
         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 self.high_button.isChecked() and self.machine_window is None:
+        if self.high_button.isChecked() and self.machine_window is None and not self.preview:
             if self.highlight_overlay is None and ((len(self.clicked_values['nodes']) + len(self.clicked_values['edges'])) > 0):
                 if self.needs_mini:
                     self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
@@ -4237,9 +4245,10 @@ class ImageViewerWindow(QMainWindow):
         load_action.triggered.connect(lambda: self.load_misc('Edge Centroids'))
         load_action = misc_menu.addAction("Load Node Communities")
         load_action.triggered.connect(lambda: self.load_misc('Communities'))
-        load_action = misc_menu.addAction("Merge Nodes")
+        node_identities = file_menu.addMenu('Images -> Node Identities')
+        load_action = node_identities.addAction("Merge Labeled Images Into Nodes")
         load_action.triggered.connect(lambda: self.load_misc('Merge Nodes'))
-        load_action = misc_menu.addAction("Merge Node IDs from Images")
+        load_action = node_identities.addAction("Assign Node Identities From Overlap With Other Images")
         load_action.triggered.connect(self.show_merge_node_id_dialog)
 
         
@@ -4292,8 +4301,6 @@ class ImageViewerWindow(QMainWindow):
         id_code_action.triggered.connect(lambda: self.show_code_dialog(sort = 'Identity'))
         umap_action = overlay_menu.addAction("Centroid UMAP")
         umap_action.triggered.connect(self.handle_centroid_umap)
-        iden_umap_action = overlay_menu.addAction("Identity UMAP (If any nodes were assigned multiple identities)")
-        iden_umap_action.triggered.connect(self.handle_iden_umap)
 
         rand_menu = analysis_menu.addMenu("Randomize")
         random_action = rand_menu.addAction("Generate Equivalent Random Network")
@@ -4363,7 +4370,7 @@ class ImageViewerWindow(QMainWindow):
         genvor_action = generate_menu.addAction("Generate Voronoi Diagram - goes in Overlay2")
         genvor_action.triggered.connect(self.voronoi)
 
-        modify_action = process_menu.addAction("Modify Network")
+        modify_action = process_menu.addAction("Modify Network/Properties")
         modify_action.triggered.connect(self.show_modify_dialog)
 
         
@@ -4711,6 +4718,12 @@ class ImageViewerWindow(QMainWindow):
            # Create new table
            table = CustomTableView(self)
            table.setModel(PandasModel(df))
+
+           try:
+               first_column_name = table.model()._data.columns[0]
+               table.sort_table(first_column_name, ascending=True)
+           except:
+                pass
            
            # Add to tabbed widget
            if title is None:
@@ -4718,17 +4731,27 @@ class ImageViewerWindow(QMainWindow):
            else:
                self.tabbed_data.add_table(f"{title}", table)
            
+
+
            # Adjust column widths to content
            for column in range(table.model().columnCount(None)):
                table.resizeColumnToContents(column)
 
        except:
-           pass
+            pass
 
     def show_merge_node_id_dialog(self):
 
-        dialog = MergeNodeIdDialog(self)
-        dialog.exec()
+        if my_network.nodes is None:
+            QMessageBox.critical(
+                self,
+                "Error",
+                "Please load your segmented cells into 'Nodes' channel first"
+            )
+            return
+        else:
+            dialog = MergeNodeIdDialog(self)
+            dialog.exec()
 
     def show_gray_water_dialog(self):
         """Show the gray watershed parameter dialog."""
@@ -5095,29 +5118,6 @@ class ImageViewerWindow(QMainWindow):
                     if sort == 'Node Identities':
                         my_network.load_node_identities(file_path = filename)
 
-                        """
-                        first_value = list(my_network.node_identities.values())[0]  # Check that there are not multiple IDs
-                        if isinstance(first_value, (list, tuple)):
-                            trump_value, ok = QInputDialog.getText(
-                                self,
-                                'Multiple IDs Detected',
-                                'The node identities appear to contain multiple ids per node in a list.\n'
-                                'If you desire one node ID to trump all others, enter it here.\n'
-                                '(Enter "-" to have the first IDs trump all others)\n'
-                                '(Enter "/" to have multi-ID nodes be split into many nodes sharing a centroid)\n'
-                                '(Close this window to continue with multi-ID nodes)'
-                            )
-                            if not ok or trump_value.strip() == '':
-                                trump_value = None
-                            elif trump_value.upper() == '-':
-                                trump_value = '-'
-                            elif trump_value.upper() == "/":
-                                trump_value = '/'
-                            my_network.node_identities = uncork(my_network.node_identities, trump_value)
-                        else:
-                            trump_value = None
-                            my_network.node_identities = uncork(my_network.node_identities, trump_value)
-                        """
 
                         if hasattr(my_network, 'node_identities') and my_network.node_identities is not None:
                             try:
@@ -5166,6 +5166,14 @@ class ImageViewerWindow(QMainWindow):
         elif sort == 'Merge Nodes':
             try:
 
+                if my_network.nodes is None:
+                    QMessageBox.critical(
+                        self,
+                        "Error",
+                        "Please load your first set of nodes into the 'Nodes' channel first"
+                    )
+                    return
+
                 if len(np.unique(my_network.nodes)) < 3:
                     self.show_label_dialog()
 
@@ -5179,6 +5187,21 @@ class ImageViewerWindow(QMainWindow):
 
                 msg.exec()
 
+                # Also if they want centroids:
+                msg2 = QMessageBox()
+                msg2.setWindowTitle("Selection Type")
+                msg2.setText("Would you like to compute node centroids for each image prior to merging?")
+                yes_button = msg2.addButton("Yes", QMessageBox.ButtonRole.AcceptRole)
+                no_button = msg2.addButton("No", QMessageBox.ButtonRole.AcceptRole)
+                msg2.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
+
+                msg2.exec()
+
+                if msg2.clickedButton() == yes_button:
+                    centroids = True
+                else:
+                    centroids = False
+
                 if msg.clickedButton() == tiff_button:
                     # Code for selecting TIFF files
                     filename, _ = QFileDialog.getOpenFileName(
@@ -5201,7 +5224,7 @@ class ImageViewerWindow(QMainWindow):
                     if dialog.exec() == QFileDialog.DialogCode.Accepted:
                         selected_path = dialog.directory().absolutePath()
 
-                my_network.merge_nodes(selected_path, root_id = self.node_name)
+                my_network.merge_nodes(selected_path, root_id = self.node_name, centroids = centroids)
                 self.load_channel(0, my_network.nodes, True)
 
 
@@ -5210,8 +5233,12 @@ class ImageViewerWindow(QMainWindow):
                         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}")
+                if centroids:
+                    self.format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
+
 
             except Exception as e:
+
                 QMessageBox.critical(
                     self,
                     "Error Merging",
@@ -5729,6 +5756,8 @@ class ImageViewerWindow(QMainWindow):
             except:
                 pass
 
+            if self.shape == self.channel_data[channel_index].shape:
+                preserve_zoom = (self.ax.get_xlim(), self.ax.get_ylim())
             self.shape = self.channel_data[channel_index].shape
             if self.shape[1] * self.shape[2] > 3000 * 3000 * self.downsample_factor:
                 self.throttle = True
@@ -5820,7 +5849,7 @@ class ImageViewerWindow(QMainWindow):
                 # Update display
                 self.update_display(preserve_zoom = (self.ax.get_xlim(), self.ax.get_ylim()))
 
-    def reset(self, nodes = False, network = False, xy_scale = 1, z_scale = 1, edges = False, search_region = False, network_overlay = False, id_overlay = False, update = True):
+    def reset(self, nodes = False, network = False, xy_scale = 1, z_scale = 1, edges = False, search_region = False, network_overlay = False, id_overlay = False, update = True, node_identities = False):
         """Method to flexibly reset certain fields to free up the RAM as desired"""
         
         # Set scales first before any clearing operations
@@ -5840,6 +5869,9 @@ class ImageViewerWindow(QMainWindow):
             # Clear selection table
             self.selection_table.setModel(PandasModel(empty_df))
 
+        if node_identities:
+            my_network.node_identities = None
+
         if nodes:
             self.delete_channel(0, False, update = update)
 
@@ -5990,7 +6022,9 @@ class ImageViewerWindow(QMainWindow):
                 # Now convert to real data
                 self.pm.convert_virtual_strokes_to_data()
             self.current_slice = slice_value
-            if self.mini_overlay == True: #If we are rendering the highlight overlay for selected values one at a time.
+            if self.preview:
+                 self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
+            elif self.mini_overlay == True: #If we are rendering the highlight overlay for selected values one at a time.
                 self.create_mini_overlay(node_indices = self.clicked_values['nodes'], edge_indices = self.clicked_values['edges'])
             if not self.hold_update:
                 self.update_display(preserve_zoom=view_settings)
@@ -6250,8 +6284,8 @@ class ImageViewerWindow(QMainWindow):
                                               vmin=0, vmax=1, extent=crop_extent)
 
             # Handle preview, overlays, and measurements (apply cropping here too)
-            if self.preview and not called:
-                self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
+            #if self.preview and not called:
+             #   self.create_highlight_overlay_slice(self.targs, bounds=self.bounds)
 
             # Overlay handling (optimized with cropping and downsampling)
             if self.mini_overlay and self.highlight and self.machine_window is None:
@@ -6465,12 +6499,6 @@ class ImageViewerWindow(QMainWindow):
 
         my_network.centroid_umap()
 
-    def handle_iden_umap(self):
-
-        if my_network.node_identities is None:
-            return
-
-        my_network.identity_umap()
 
     def closeEvent(self, event):
         """Override closeEvent to close all windows when main window closes"""
@@ -6487,6 +6515,8 @@ class ImageViewerWindow(QMainWindow):
         # Force quit the application
         QCoreApplication.quit()
 
+        exit()
+
 
 
 #TABLE RELATED: 
@@ -6729,11 +6759,7 @@ class CustomTableView(QTableView):
                 self.resizeColumnToContents(col)
                 
         except Exception as e:
-            QMessageBox.critical(
-                self,
-                "Error",
-                f"Error sorting table: {str(e)}"
-            )
+            pass
 
     def save_table_as(self, file_type):
         """Save the table data as either CSV or Excel file."""
@@ -7253,8 +7279,13 @@ class PropertiesDialog(QDialog):
         self.network.setChecked(self.check_checked(my_network.network))
         layout.addRow("Network Status", self.network)
 
+        self.node_identities = QPushButton("Node Identities")
+        self.node_identities.setCheckable(True)
+        self.node_identities.setChecked(self.check_checked(my_network.node_identities))
+        layout.addRow("Identities Status", self.node_identities)
+
         # Add Run button
-        run_button = QPushButton("Enter")
+        run_button = QPushButton("Enter (Erases Unchecked Properties)")
         run_button.clicked.connect(self.run_properties)
         layout.addWidget(run_button)
 
@@ -7291,8 +7322,9 @@ class PropertiesDialog(QDialog):
             id_overlay = not self.id_overlay.isChecked()
             search_region = not self.search_region.isChecked()
             network = not self.network.isChecked()
+            node_identities = not self.node_identities.isChecked()
 
-            self.parent().reset(nodes = nodes, edges = edges, search_region = search_region, network_overlay = network_overlay, id_overlay = id_overlay, network = network, xy_scale = xy_scale, z_scale = z_scale)
+            self.parent().reset(nodes = nodes, edges = edges, search_region = search_region, network_overlay = network_overlay, id_overlay = id_overlay, network = network, xy_scale = xy_scale, z_scale = z_scale, node_identities = node_identities)
             
             self.accept()
 
@@ -7720,78 +7752,252 @@ class ArbitraryDialog(QDialog):
         except Exception as e:
             QMessageBox.critical(self, "Error", f"Error processing selections: {str(e)}")
 
-class MergeNodeIdDialog(QDialog):
 
+class MergeNodeIdDialog(QDialog):
     def __init__(self, parent=None):
+
         super().__init__(parent)
+
         self.setWindowTitle("Merging Node Identities From Folder Dialog.\nNote that you should prelabel or prewatershed your current node objects before doing this. (See Process -> Image) It does not label them for you.")
         self.setModal(True)
         
         layout = QFormLayout(self)
-
         self.search = QLineEdit("")
         layout.addRow("Step-out distance (from current nodes image - ignore if you dilated them previously or don't want):", self.search)
-
         self.xy_scale = QLineEdit(f"{my_network.xy_scale}")
         layout.addRow("xy_scale:", self.xy_scale)
-
         self.z_scale = QLineEdit(f"{my_network.z_scale}")
         layout.addRow("z_scale:", self.z_scale)
+        self.mode_selector = QComboBox()
+        self.mode_selector.addItems(["Auto-Binarize(Otsu)/Presegmented", "Manual (Interactive Thresholder)"])
+        self.mode_selector.setCurrentIndex(1)  # Default to Mode 1
+        layout.addRow("Binarization Strategy:", self.mode_selector)
 
-        # Add Run button
-        self.include = QPushButton("Include Negative Gates?")
+        self.umap = QPushButton("If using manual threshold: Also generate identity UMAP?")
+        self.umap.setCheckable(True)
+        self.umap.setChecked(True)
+        layout.addWidget(self.umap)
+        
+        self.include = QPushButton("Include When a Node is Negative for an ID?")
         self.include.setCheckable(True)
-        self.include.setChecked(True)
+        self.include.setChecked(False)
         layout.addWidget(self.include)
-
-        # Add Run button
+        
         run_button = QPushButton("Get Directory")
         run_button.clicked.connect(self.run)
         layout.addWidget(run_button)
 
-    def run(self):
+    def wait_for_threshold_processing(self):
+        """
+        Opens ThresholdWindow and waits for user to process the image.
+        Returns True if completed, False if cancelled.
+        The thresholded image will be available in the main window after completion.
+        """
+        # Create event loop to wait for user
+        loop = QEventLoop()
+        result = {'completed': False}
+        
+        # Create the threshold window
+        thresh_window = ThresholdWindow(self.parent(), 4)
+        
+        # Connect signals
+        def on_processing_complete():
+            result['completed'] = True
+            loop.quit()
+            
+        def on_processing_cancelled():
+            result['completed'] = False
+            loop.quit()
+        
+        thresh_window.processing_complete.connect(on_processing_complete)
+        thresh_window.processing_cancelled.connect(on_processing_cancelled)
+        
+        # Show window and wait
+        thresh_window.show()
+        thresh_window.raise_()
+        thresh_window.activateWindow()
+        
+        # Block until user clicks "Apply Threshold & Continue" or "Cancel"
+        loop.exec()
+        
+        # Clean up
+        thresh_window.deleteLater()
+        
+        return result['completed']
 
+    def run(self):
         try:
 
             search = float(self.search.text()) if self.search.text().strip() else 0
             xy_scale = float(self.xy_scale.text()) if self.xy_scale.text().strip() else 1
             z_scale = float(self.z_scale.text()) if self.z_scale.text().strip() else 1
-
-
             data = self.parent().channel_data[0]
             include = self.include.isChecked()
-
+            umap = self.umap.isChecked()
+            
             if data is None:
                 return
-
-
-
+                
             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()
-
+            else:
+                return  # User cancelled directory selection
+                
             if search > 0:
-                data = sdl.smart_dilate(data, 1, 1, GPU = False, fast_dil = False, use_dt_dil_amount = search, xy_scale = xy_scale, z_scale = z_scale)
+                data = sdl.smart_dilate(data, 1, 1, GPU=False, fast_dil=False, 
+                                      use_dt_dil_amount=search, xy_scale=xy_scale, z_scale=z_scale)
+            
+            # Check if manual mode is selected
+            if self.mode_selector.currentIndex() == 1:  # Manual mode
 
-            my_network.merge_node_ids(selected_path, data, include)
+                if my_network.node_identities is None: # Prepare modular dict
 
-            self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
+                    my_network.node_identities = {}
 
-            QMessageBox.information(
-                self,
-                "Success",
-                "Node Identities Merged. New IDs represent presence of corresponding img foreground with +, absence with -. Please save your new identities as csv, then use File -> Load -> Load From Excel Helper to bulk search and rename desired combinations. (Press Help [above] for more info)"
-            )
+                    nodes = list(np.unique(data))
+                    if 0 in nodes:
+                        del nodes[0]
+                    for node in nodes:
+
+                        my_network.node_identities[node] = [] # Assign to lists at first
+                else:
+                    for node, iden in my_network.node_identities.items():
+                        try:
+                            my_network.node_identities[node] = ast.literal_eval(iden)
+                        except:
+                            my_network.node_identities[node] = [iden]
+
+                id_dicts = my_network.get_merge_node_dictionaries(selected_path, data)
+
+                # For loop example - get threshold for multiple images/data
+                results = []
+
+                img_list = n3d.directory_info(selected_path)
+                data_backup = copy.deepcopy(data)
+                self.parent().load_channel(0, data, data = True)
+                self.hide()
+                self.parent().highlight_overlay = None
+
+                good_list = []
+                
+                for i, img in enumerate(img_list):
+
+                    if img.endswith('.tiff') or img.endswith('.tif'):
+
+                        print(f"Please threshold {img}")
+
+
+                        mask = tifffile.imread(f'{selected_path}/{img}')
+                        self.parent().load_channel(2, mask, data = True)
+
+                        # Wait for user to threshold this data
+                        self.parent().special_dict = id_dicts[i]
+                        processing_completed = self.wait_for_threshold_processing()
+                        
+                        if not processing_completed:
+                            # User cancelled, ask if they want to continue
+                            reply = QMessageBox.question(self, 'Continue?', 
+                                                       f'Threshold cancelled for item {i+1}. Continue with remaining items?',
+                                                       QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+                            if reply == QMessageBox.StandardButton.No:
+                                break
+                            continue
+                        
+                        # At this point, the thresholded image is in the main window's memory
+                        # Get the processed/thresholded data from wherever ThresholdWindow stored it
+                        thresholded_vals = list(np.unique(self.parent().channel_data[0]))
+                        if 0 in thresholded_vals:
+                            del thresholded_vals[0]
+
+                        if img.endswith('.tiff'):
+                            base_name = img[:-5]
+                        elif img.endswith('.tif'):
+                            base_name = img[:-4]
+                        else:
+                            base_name = img
+
+                        assigned = {}
+
+                        for node in my_network.node_identities.keys():
+
+                            try:
+
+                                if int(node) in thresholded_vals:
+
+                                    my_network.node_identities[node].append(f'{base_name}+')
+
+                                elif include:
+
+                                    my_network.node_identities[node].append(f'{base_name}-')
+
+                            except:
+                                pass
+                        
+                        # Process the thresholded data
+                        self.parent().highlight_overlay = None
+                        self.parent().load_channel(0, data_backup, data = True)
+                        good_list.append(base_name)
+
+                modify_dict = copy.deepcopy(my_network.node_identities)
+
+                for node, iden in my_network.node_identities.items():
+
+                    try:
+
+                        if len(iden) == 1:
+
+                            modify_dict[node] = str(iden[0]) # Singleton lists become bare strings
+                        elif len(iden) == 0:
+                            del modify_dict[node]
+                        else:
+                            modify_dict[node] = str(iden) # We hold multi element lists as strings for compatibility
+
+                    except:
+                        pass
+
+                my_network.node_identities = modify_dict
+                
+                self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
+
+                all_keys = id_dicts[0].keys()
+                result = {key: np.array([d[key] for d in id_dicts]) for key in all_keys}
+
+
+                self.parent().format_for_upperright_table(result, 'NodeID', good_list, 'Mean Intensity')
+                if umap:
+                    my_network.identity_umap(result)
 
-            self.accept()
+
+                QMessageBox.information(
+                    self,
+                    "Success",
+                    "Node Identities Merged. New IDs represent presence of corresponding img foreground with +, absence with -. Please save your new identities as csv, then use File -> Load -> Load From Excel Helper to bulk search and rename desired combinations. (Press Help [above] for more info)"
+                )
+
+                self.accept()
+            else:
+                my_network.merge_node_ids(selected_path, data, include)
+
+                self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
+
+                QMessageBox.information(
+                    self,
+                    "Success",
+                    "Node Identities Merged. New IDs represent presence of corresponding img foreground with +, absence with -. Please save your new identities as csv, then use File -> Load -> Load From Excel Helper to bulk search and rename desired combinations. (Press Help [above] for more info)"
+                )
+
+                self.accept()
 
         except Exception as e:
-            print(f"Error: {e}")
+            import traceback
+            print(traceback.format_exc())
+            #print(f"Error: {e}")
 
 
 class Show3dDialog(QDialog):
@@ -11172,11 +11378,15 @@ class SegmentationWorker(QThread):
 
 
 class ThresholdWindow(QMainWindow):
+    processing_complete = pyqtSignal()  # Emitted when user finishes and images are modified
+    processing_cancelled = pyqtSignal()  # Emitted when user cancels
+
     def __init__(self, parent=None, accepted_mode=0):
         super().__init__(parent)
         self.setWindowTitle("Threshold")
 
         self.accepted_mode = accepted_mode
+        self.preview = True
         
         # Create central widget and layout
         central_widget = QWidget()
@@ -11208,6 +11418,10 @@ class ThresholdWindow(QMainWindow):
             self.histo_list = list(self.parent().degree_dict.values())
             self.bounds = False
             self.parent().bounds = False
+        elif accepted_mode == 4:
+            self.histo_list = list(self.parent().special_dict.values())
+            self.bounds = False
+            self.parent().bounds = False
 
         elif accepted_mode == 0:
             targ_shape = self.parent().channel_data[self.parent().active_channel].shape
@@ -11279,16 +11493,39 @@ class ThresholdWindow(QMainWindow):
         self.preview.clicked.connect(self.preview_mode)
         form_layout.addRow("Show Preview:", self.preview)
 
-        run_button = QPushButton("Apply Threshold")
-        run_button.clicked.connect(self.thresh)
-        form_layout.addRow(run_button)
+        button_layout = QHBoxLayout()
+
+
+        # Keep your existing Apply Threshold button, but modify its behavior
+        run_button = QPushButton("Apply Threshold/Continue")
+        run_button.clicked.connect(self.apply_and_continue)  # New method
+        button_layout.addWidget(run_button)
         
-        layout.addLayout(form_layout)
+        # Add Cancel button for external dialog use
+        cancel_button = QPushButton("Cancel/Skip")
+        cancel_button.clicked.connect(self.cancel_processing)
+        button_layout.addWidget(cancel_button)
         
+        form_layout.addRow(button_layout)
+        layout.addLayout(form_layout)
+                
         # Set a reasonable default size
         self.setMinimumWidth(400)
         self.setMinimumHeight(400)
 
+    def apply_and_continue(self):
+        """Apply threshold, modify main window images, then signal completion"""
+        self.thresh()  # This should modify the main window images
+        
+        # Signal that processing is complete
+        self.processing_complete.emit()
+        self.close()
+    
+    def cancel_processing(self):
+        """Cancel without applying changes"""
+        self.processing_cancelled.emit()
+        self.close()
+
     def closeEvent(self, event):
         self.parent().preview = False
         self.parent().targs = None
@@ -11340,6 +11577,10 @@ class ThresholdWindow(QMainWindow):
             for node, vol in self.parent().degree_dict.items():
                 if min_val <= vol <= max_val:
                     output.append(node)
+        elif self.accepted_mode == 4:
+            for node, vol in self.parent().special_dict.items():
+                if min_val <= vol <= max_val:
+                    output.append(node)
         return output
 
     def get_values_in_range(self, lst, min_val, max_val):
@@ -11357,11 +11598,18 @@ class ThresholdWindow(QMainWindow):
             for item in self.parent().degree_dict:
                 if self.parent().degree_dict[item] in values:
                     output.append(item)
+        elif self.accepted_mode == 4:
+            for item in self.parent().special_dict:
+                if self.parent().special_dict[item] in values:
+                    output.append(item)
+
         return output
 
 
     def min_value_changed(self):
         try:
+            if not self.preview.isChecked():
+                self.preview.click()
             text = self.min.text()
             if not text:  # If empty, ignore
                 return
@@ -11409,6 +11657,8 @@ class ThresholdWindow(QMainWindow):
 
     def max_value_changed(self):
         try:
+            if not self.preview.isChecked():
+                self.preview.click()
             text = self.max.text()
             if not text:  # If empty, ignore
                 return
@@ -11532,7 +11782,6 @@ class ThresholdWindow(QMainWindow):
                 f"Error running threshold: {str(e)}"
             )
 
-
 class SmartDilateDialog(QDialog):
     def __init__(self, parent, params):
         super().__init__(parent)
@@ -13191,6 +13440,12 @@ class ModifyDialog(QDialog):
         self.revid.setChecked(False)
         layout.addRow("Remove Unassigned IDs from Centroid List?:", self.revid)
 
+        self.revdupeid = QPushButton("Make Singleton IDs")
+        self.revdupeid.setCheckable(True)
+        self.revdupeid.setChecked(False)
+        layout.addRow("Force Any Multiple IDs to Pick a Random Single ID?:", self.revdupeid)
+
+
         self.remove = QPushButton("Remove Missing")
         self.remove.setCheckable(True)
         self.remove.setChecked(False)
@@ -13269,6 +13524,7 @@ class ModifyDialog(QDialog):
         try:
 
             revid = self.revid.isChecked()
+            revdupeid = self.revdupeid.isChecked()
             trunk = self.trunk.isChecked()
             if not trunk:
                 trunknode = self.trunknode.isChecked()
@@ -13293,6 +13549,20 @@ class ModifyDialog(QDialog):
                 except:
                     pass
 
+            if revdupeid:
+                try:
+                    for node, iden in my_network.node_identities.items():
+                        try:
+                            import ast
+                            import random
+                            iden = ast.literal_eval(iden)
+                            my_network.node_identities[node] = random.choice(iden)
+                        except:
+                            pass
+                    self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity', 'Node Identities')
+                except:
+                    pass
+
 
             if remove:
                 my_network.purge_properties()