nettracer3d 0.4.2__py3-none-any.whl → 0.4.3__py3-none-any.whl

nettracer3d/morphology.py

@@ -101,6 +101,8 @@ def process_label(args):
     nodes, edges, label, dilate_xy, dilate_z, array_shape = args
     print(f"Processing node {label}")
     indices = np.argwhere(nodes == label)
+    if len(indices) == 0:
+        return None, None, None
     z_vals, y_vals, x_vals = get_reslice_indices((indices, dilate_xy, dilate_z, array_shape))
     if z_vals is None: #If get_reslice_indices ran into a ValueError, nothing is returned.
         return None, None, None

nettracer3d/nettracer.py

@@ -1003,6 +1003,8 @@ def dilate_3D_recursive(tiff_array, dilated_x, dilated_y, dilated_z, step_size=N
     max_dilation = max(dilated_x, dilated_y, dilated_z)
     if max_dilation < (0.2 * min_dim):
         return dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z)
+    elif dilated_x == 1 and dilated_y == 1 and dilated_z == 1: #Also if there is only a single dilation don't do it
+        return dilate_3D(tiff_array, dilated_x, dilated_y, dilated_z)
     
     # Initialize step_size for first call
     if step_size is None:
@@ -1587,6 +1589,51 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
     return array
 
+def fix_branches(array, G, communities, fix_val = None):
+
+    def invert_dict(d):
+        inverted = {}
+        for key, value in d.items():
+            inverted.setdefault(value, []).append(key)
+        return inverted
+
+    def get_degree_threshold(community_degrees):
+        degrees = np.array(community_degrees, dtype=float)
+        hist, bins = np.histogram(degrees, bins='auto')        
+        peaks, _ = find_peaks(hist)
+        if len(peaks) > 1:
+            # Get bin value after first peak as threshold
+            return bins[peaks[0] + 1]
+        return 4  # Default fallback
+
+    avg_degree = G.number_of_edges() * 2 / G.number_of_nodes()
+
+    targs = []
+
+    inverted = invert_dict(communities)
+
+    community_degrees = {}
+
+    for com in inverted:
+        subgraph = G.subgraph(inverted[com])
+        sub_degree = subgraph.number_of_edges() * 2/ subgraph.number_of_nodes()
+        community_degrees[com] = sub_degree
+
+
+    if fix_val is None:
+        threshold = get_degree_threshold(list(community_degrees.values()))
+    else:
+        threshold = fix_val
+
+    for com in community_degrees:
+        if community_degrees[com] > threshold: #This method of comparison could possibly be more nuanced. 
+            targs.append(com)
+
+
+    return targs
+
+
+
 def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = 0, directory = None, return_skele = False, order = 0):
     """
     Can be used to label vertices (where multiple branches connect) a binary image. Labelled output will be saved to the active directory if none is specified. Note this works better on already thin filaments and may over-divide larger trunkish objects.
@@ -3417,6 +3464,92 @@ class Network_3D:
             self._nodes = self._nodes.astype(np.uint16)
 
 
+    def com_to_node(self, targets = None):
+
+        def invert_dict(d):
+            inverted = {}
+            for key, value in d.items():
+                inverted.setdefault(value, []).append(key)
+            return inverted
+
+        def update_array(array_3d, value_dict, targets = None):
+            ref_array = copy.deepcopy(array_3d)
+            if targets is None:
+                for key, value_list in value_dict.items():
+                    for value in value_list:
+                        array_3d[ref_array == value] = key
+            else:
+                max_val = np.max(array_3d) + 1
+                for key, value_list in value_dict.items():
+                    for value in value_list:
+                        array_3d[ref_array == value] = max_val
+                    max_val += 1
+
+            return array_3d
+
+        if 0 in self.communities.values():
+            self.communities = {k: v + 1 for k, v in self.communities.items()} 
+            if targets is not None:
+                for item in targets:
+                    item = item + 1
+
+        inverted = invert_dict(self.communities)
+
+
+        if targets is not None:
+            new_inverted = copy.deepcopy(inverted)
+            for com in inverted:
+                if com not in targets:
+                    del new_inverted[com]
+            inverted = new_inverted
+
+
+        if self._node_identities is not None:
+            new_identities = {}
+            for com in inverted:
+                new_identities[com] = ""
+
+        list1 = self._network_lists[0] #Get network lists to change
+        list2 = self._network_lists[1]
+        list3 = self._network_lists[2]
+
+        for i in range(len(list1)):
+            list1[i] = self.communities[list1[i]] #Set node at network list spot to its community instead
+            list2[i] = self.communities[list2[i]]
+            if list1[i] == list2[i]: #If the  edge corresponding there joins different communities, it will not be set to 0
+                list3[i] = 0
+
+
+        self.network_lists = [list1, list2, list3]
+
+        if self._nodes is not None:
+            self._nodes = update_array(self._nodes, inverted, targets = targets) #Set the array to match the new network
+
+        try:
+
+            if self._node_identities is not None:
+
+                for key, value_list in inverted.items():
+                    temp_dict = {}
+                    for value in value_list:
+                        if self._node_identities[value] in temp_dict:
+                            temp_dict[self._node_identities[value]] += 1
+                        else:
+                            temp_dict[self._node_identities[value]] = 1
+                    for id_type, num in temp_dict.items():
+                        new_identities[key] += f'ID {id_type}:{num}, '
+
+                self.node_identities = new_identities
+        except:
+            pass
+
+
+
+
+
+
+
+
     def trunk_to_node(self):
         """
         Converts the edge 'trunk' into a node. In this case, the trunk is the edge that creates the most node-node connections. There may be times when many nodes are connected by a single, expansive edge that obfuscates the rest of the edges. Converting the trunk to a node can better reveal these edges.

nettracer3d/nettracer_gui.py

@@ -16,6 +16,7 @@ from nettracer3d import nettracer as n3d
 from nettracer3d import smart_dilate as sdl
 from nettracer3d import proximity as pxt
 from matplotlib.colors import LinearSegmentedColormap
+from matplotlib.backends.backend_qt5agg import FigureCanvasQTAgg as FigureCanvas
 import pandas as pd
 from PyQt6.QtGui import (QFont, QCursor, QColor)
 import tifffile
@@ -176,6 +177,9 @@ class ImageViewerWindow(QMainWindow):
         buttons_layout.addWidget(self.pan_button)
 
         control_layout.addWidget(buttons_widget)
+
+        self.preview = False #Whether in preview mode or not
+        self.targs = None #Targets for preview mode
                 
         # Create channel buttons
         self.channel_buttons = []
@@ -396,7 +400,7 @@ class ImageViewerWindow(QMainWindow):
             self.slice_slider.setValue(new_value)
         
 
-    def create_highlight_overlay(self, node_indices=None, edge_indices=None, overlay1_indices = None, overlay2_indices = None):
+    def create_highlight_overlay(self, node_indices=None, edge_indices=None, overlay1_indices = None, overlay2_indices = None, bounds = False):
         """
         Create a binary overlay highlighting specific nodes and/or edges using parallel processing.
         
@@ -410,6 +414,12 @@ class ImageViewerWindow(QMainWindow):
             mask = np.isin(chunk_data, indices_to_check)
             return mask * 255
 
+        def process_chunk_bounds(chunk_data, indices_to_check):
+            """Process a single chunk of the array to create highlight mask"""
+
+            mask = (chunk_data >= indices_to_check[0]) & (chunk_data <= indices_to_check[1])
+            return mask * 255
+
         if node_indices is not None:
             if 0 in node_indices:
                 node_indices.remove(0)
@@ -453,7 +463,7 @@ class ImageViewerWindow(QMainWindow):
         num_cores = mp.cpu_count()
         
         # Calculate chunk size along y-axis
-        chunk_size = full_shape[0] // num_cores
+        chunk_size = full_shape[1] // num_cores
         if chunk_size < 1:
             chunk_size = 1
         
@@ -463,25 +473,32 @@ class ImageViewerWindow(QMainWindow):
                 
             # 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])
+            for i in range(0, array_shape[1], chunk_size):
+                end = min(i + chunk_size, array_shape[1])
+                chunks.append(channel_data[:, i:end, :])
                 
             # Process chunks in parallel using ThreadPoolExecutor
-            process_func = partial(process_chunk, indices_to_check=indices)
+            if not bounds:
+                process_func = partial(process_chunk, indices_to_check=indices)
+            else:
+                if len(indices) == 1:
+                    indices.insert(0, 0)
+                process_func = partial(process_chunk_bounds, 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)
+            return np.concatenate(chunk_results, axis=1)
         
         # Process nodes and edges in parallel using multiprocessing
-        with ThreadPoolExecutor(max_workers=2) as executor:
+        with ThreadPoolExecutor(max_workers=num_cores) 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()
@@ -502,6 +519,84 @@ class ImageViewerWindow(QMainWindow):
         # Update display
         self.update_display(preserve_zoom=(current_xlim, current_ylim))
 
+    def create_highlight_overlay_slice(self, indices, bounds = False):
+
+
+        def process_chunk_bounds(chunk_data, indices_to_check):
+            """Process a single chunk of the array to create highlight mask"""
+            mask = (chunk_data >= indices_to_check[0]) & (chunk_data <= indices_to_check[1])
+            return mask * 255
+
+        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
+
+        array = self.channel_data[self.active_channel]
+        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
+
+        current_slice = array[self.current_slice, :, :]
+        full_shape = array.shape
+        slice_shape = current_slice.shape
+
+        if self.highlight_overlay is None:
+
+            self.highlight_overlay = np.zeros(full_shape, dtype=np.uint8)
+
+        # Get number of CPU cores
+        num_cores = mp.cpu_count()
+        
+        # Calculate chunk size along y-axis
+        chunk_size = slice_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])
+                
+            # Process chunks in parallel using ThreadPoolExecutor
+            if not bounds:
+                process_func = partial(process_chunk, indices_to_check=indices)
+            else:
+                if len(indices) == 1:
+                    indices.insert(0, 0)
+                process_func = partial(process_chunk_bounds, 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=num_cores) as executor:
+            future_highlight = executor.submit(process_channel, current_slice, indices, slice_shape)
+            
+            # Get results
+            overlay = future_highlight.result()
+
+        try:
+
+            self.highlight_overlay[self.current_slice, :, :] = overlay
+        except:
+            pass
+
+        # Update display
+        self.update_display(preserve_zoom=(current_xlim, current_ylim), called = True)
+
+
+
+        
 
 
 
@@ -1529,6 +1624,7 @@ class ImageViewerWindow(QMainWindow):
                 self.selection_rect = None
                 self.canvas.draw()
 
+
     def highlight_value_in_tables(self, clicked_value):
         """Helper method to find and highlight a value in both tables."""
         
@@ -2055,8 +2151,9 @@ class ImageViewerWindow(QMainWindow):
 
     def show_thresh_dialog(self):
         """Show threshold dialog"""
-        thresh_window = ThresholdWindow(self)
-        thresh_window.show()  # Non-modal window
+        dialog = ThresholdDialog(self)
+        dialog.exec()
+
 
     def show_mask_dialog(self):
         """Show the mask dialog"""
@@ -2265,13 +2362,10 @@ class ImageViewerWindow(QMainWindow):
 
 
                 except Exception as e:
-                    import traceback
-                    print(traceback.format_exc())
                     print(f"An error has occured: {e}")
 
             except Exception as e:
-                import traceback
-                print(traceback.format_exc())
+
                 QMessageBox.critical(
                     self,
                     "Error Loading",
@@ -2513,12 +2607,22 @@ class ImageViewerWindow(QMainWindow):
         """Shows a dialog asking user to confirm if image is 2D RGB"""
         msg = QMessageBox()
         msg.setIcon(QMessageBox.Icon.Question)
-        msg.setText("Image Format Detection")
+        msg.setText("Image Format Alert")
         msg.setInformativeText("Is this a 2D color (RGB/CMYK) image?")
         msg.setWindowTitle("Confirm Image Format")
         msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
         return msg.exec() == QMessageBox.StandardButton.Yes
 
+    def confirm_resize_dialog(self):
+        """Shows a dialog asking user to resize image"""
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Icon.Question)
+        msg.setText("Image Format Alert")
+        msg.setInformativeText(f"This image is a different shape than the ones loaded into the viewer window. Trying to run processes with images of different sizes has a high probability of crashing the program.\nPress yes to resize the new image to the other images. Press no to load it anyway.")
+        msg.setWindowTitle("Resize")
+        msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        return msg.exec() == QMessageBox.StandardButton.Yes
+
     def load_channel(self, channel_index, channel_data=None, data=False, assign_shape = True):
         """Load a channel and enable active channel selection if needed."""
 
@@ -2547,6 +2651,19 @@ class ImageViewerWindow(QMainWindow):
             if len(self.channel_data[channel_index].shape) == 4 and (channel_index == 0 or channel_index == 1):
                 self.channel_data[channel_index] = self.reduce_rgb_dimension(self.channel_data[channel_index])
 
+            for i in range(4): #Try to ensure users don't load in different sized arrays
+                if self.channel_data[i] is None or i == channel_index or data:
+                    if self.highlight_overlay is not None: #Make sure highlight overlay is always the same shape as new images
+                        if self.channel_data[i].shape[:3] != self.highlight_overlay.shape:
+                            self.highlight_overlay = None
+                    continue
+                else:
+                    old_shape = self.channel_data[i].shape[:3] #Ask user to resize images that are shaped differently
+                    if old_shape != self.channel_data[channel_index].shape[:3]:
+                        if self.confirm_resize_dialog():
+                            self.channel_data[channel_index] = n3d.upsample_with_padding(self.channel_data[channel_index], original_shape = old_shape)
+                            break
+
 
             if channel_index == 0:
                 my_network.nodes = self.channel_data[channel_index]
@@ -2601,7 +2718,10 @@ class ImageViewerWindow(QMainWindow):
             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
+                if self.original_shape is None:
+                    self.original_shape = self.channel_data[channel_index].shape
+                elif self.original_shape[0] < self.channel_data[channel_index].shape[0] or self.original_shape[1] < self.channel_data[channel_index].shape[1] or self.original_shape[2] < self.channel_data[channel_index].shape[2]:
+                    self.original_shape = self.channel_data[channel_index].shape
                 if len(self.original_shape) == 4:
                     self.original_shape = (self.original_shape[0], self.original_shape[1], self.original_shape[2])
 
@@ -2829,11 +2949,11 @@ class ImageViewerWindow(QMainWindow):
         current_ylim = self.ax.get_ylim() if hasattr(self, 'ax') and self.ax.get_ylim() != (0, 1) else None
         # Convert slider values (0-100) to data values (0-1)
         min_val, max_val = values
-        self.channel_brightness[channel_index]['min'] = min_val / 255
+        self.channel_brightness[channel_index]['min'] = min_val / 255 #Accomodate 32 bit data?
         self.channel_brightness[channel_index]['max'] = max_val / 255
         self.update_display(preserve_zoom = (current_xlim, current_ylim))
     
-    def update_display(self, preserve_zoom=None, dims = None):
+    def update_display(self, preserve_zoom=None, dims = None, called = False):
         """Update the display with currently visible channels and highlight overlay."""
 
         self.figure.clear()
@@ -2927,6 +3047,9 @@ class ImageViewerWindow(QMainWindow):
                                  vmax=1,
                                  extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
 
+        if self.preview and not called:
+            self.create_highlight_overlay_slice(self.targs, bounds = self.bounds)
+
         # Add highlight overlay if it exists
         if self.highlight_overlay is not None:
             highlight_slice = self.highlight_overlay[self.current_slice]
@@ -2939,6 +3062,7 @@ class ImageViewerWindow(QMainWindow):
                          alpha=0.5)
 
 
+
         
         # Style the axes
         self.ax.set_xlabel('X')
@@ -4162,17 +4286,18 @@ class WhiteDialog(QDialog):
     def white_overlay(self):
 
         try:
-
-            try:
+            if isinstance(my_network.nodes, np.ndarray) :
                 overlay = np.ones_like(my_network.nodes).astype(np.uint8) * 255
-            except:
+            elif isinstance(my_network.edges, np.ndarray): 
                 overlay = np.ones_like(my_network.edges).astype(np.uint8) * 255
-            finally:
-                my_network.id_overlay = overlay
+            elif isinstance(my_network.network_overlay, np.ndarray):
+                overlay = np.ones_like(my_network.network_overlay).astype(np.uint8) * 255
 
-                self.parent().load_channel(3, channel_data = my_network.id_overlay, data = True)
+            my_network.id_overlay = overlay
 
-                self.accept()
+            self.parent().load_channel(3, channel_data = my_network.id_overlay, data = True)
+
+            self.accept()
 
         except Exception as e:
             print(f"Error making white background: {e}")
@@ -4274,7 +4399,7 @@ class NetShowDialog(QDialog):
         self.geo_layout = QPushButton("geo_layout")
         self.geo_layout.setCheckable(True)
         self.geo_layout.setChecked(False)
-        layout.addRow("Use Geometric Layout:", self.geo_layout)
+        layout.addRow("Use Geographic Layout:", self.geo_layout)
         
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
@@ -5246,101 +5371,303 @@ class LabelDialog(QDialog):
                 f"Error running label: {str(e)}"
             )
 
-class ThresholdWindow(QMainWindow):
+class ThresholdDialog(QDialog):
     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)
+        self.setWindowTitle("Choose Threshold Mode")
+        self.setModal(True)
         
-        # Create widgets
-        self.max = QLineEdit("")
-        layout.addRow("Maximum Value to retain:", self.max)
+        layout = QFormLayout(self)
 
         # Add mode selection dropdown
         self.mode_selector = QComboBox()
-        self.mode_selector.addItems(["Using Volumes", "Using Label/Brightness"])
+        self.mode_selector.addItems(["Using Label/Brightness", "Using Volumes"])
         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)
+        run_button = QPushButton("Select")
+        run_button.clicked.connect(self.thresh_mode)
+        layout.addRow(run_button)
+
+    def thresh_mode(self):
+
+        try:
+
+            accepted_mode = self.mode_selector.currentIndex()
+
+            if accepted_mode == 1:
+                if len(np.unique(self.parent().channel_data[self.parent().active_channel])) < 3:
+                    self.parent().show_label_dialog()
+
+                if self.parent().volume_dict[self.parent().active_channel] is None:
+                    self.parent().volumes()
+
+            thresh_window = ThresholdWindow(self.parent(), accepted_mode)
+            thresh_window.show()  # Non-modal window
+            self.highlight_overlay = None
+            self.accept()
+        except:
+            pass
+
+
+
+
+
+class ThresholdWindow(QMainWindow):
+    def __init__(self, parent=None, accepted_mode=0):
+        super().__init__(parent)
+        self.setWindowTitle("Threshold")
         
-        # Add Run button
+        # Create central widget and layout
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        layout = QVBoxLayout(central_widget)
+        
+        # Get histogram data
+        if accepted_mode == 1:
+            self.histo_list = list(self.parent().volume_dict[self.parent().active_channel].values())
+            self.bounds = False
+            self.parent().bounds = False
+        elif accepted_mode == 0:
+            self.histo_list = self.parent().channel_data[self.parent().active_channel].flatten().tolist()
+            self.bounds = True
+            self.parent().bounds = True
+            
+        # Create matplotlib figure
+        fig = Figure(figsize=(5, 4))
+        self.canvas = FigureCanvas(fig)
+        layout.addWidget(self.canvas)
+        
+        # Pre-compute histogram with numpy
+        counts, bin_edges = np.histogram(self.histo_list, bins=50)
+        bin_centers = (bin_edges[:-1] + bin_edges[1:]) / 2
+        
+        # Plot pre-computed histogram
+        self.ax = fig.add_subplot(111)
+        self.ax.bar(bin_centers, counts, width=bin_edges[1] - bin_edges[0], alpha=0.5)
+        
+        # Add vertical lines for thresholds
+        self.min_line = self.ax.axvline(min(self.histo_list), color='r')
+        self.max_line = self.ax.axvline(max(self.histo_list), color='b')
+        
+        # Connect events for dragging
+        self.canvas.mpl_connect('button_press_event', self.on_press)
+        self.canvas.mpl_connect('motion_notify_event', self.on_motion)
+        self.canvas.mpl_connect('button_release_event', self.on_release)
+        
+        self.dragging = None
+        
+        # Store histogram bounds
+        if self.bounds:
+            self.data_min = 0
+        else:
+            self.data_min = min(self.histo_list)
+        self.data_max = max(self.histo_list)
+
+        # Create form layout for inputs
+        form_layout = QFormLayout()
+        
+        self.min = QLineEdit(f"{self.data_min}")
+        self.min.editingFinished.connect(self.min_value_changed)
+        form_layout.addRow("Minimum Value to retain:", self.min)
+        self.prev_min = self.data_min
+        
+        self.max = QLineEdit(f"{self.data_max}")
+        self.max.editingFinished.connect(self.max_value_changed)
+        form_layout.addRow("Maximum Value to retain:", self.max)
+        self.prev_max = self.data_max
+
+        self.targs = [self.prev_min, self.prev_max]
+        
+        # preview checkbox (default False)
+        self.preview = QPushButton("Preview")
+        self.preview.setCheckable(True)
+        self.preview.setChecked(False)
+        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)
-        layout.addRow(run_button)
+        form_layout.addRow(run_button)
         
-        # Set a reasonable default size
-        self.setMinimumWidth(300)
+        layout.addLayout(form_layout)
         
-    def run_preview(self):
+        # Set a reasonable default size
+        self.setMinimumWidth(400)
+        self.setMinimumHeight(400)
 
-        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
+    def closeEvent(self, event):
+        self.parent().preview = False
+        self.parent().targs = None
+        self.parent().bounds = False
 
+    def get_values_in_range(self, lst, min_val, max_val):
+        values = [x for x in lst if min_val <= x <= max_val]
+        output = []
+        for item in self.parent().volume_dict[self.parent().active_channel]:
+            if self.parent().volume_dict[self.parent().active_channel][item] in values:
+                output.append(item)
+        return output
+
+
+    def min_value_changed(self):
         try:
-            channel = self.parent().active_channel
-            accepted_mode = self.mode_selector.currentIndex()
+            text = self.min.text()
+            if not text:  # If empty, ignore
+                return
             
-            if accepted_mode == 0:
-                if len(np.unique(self.parent().channel_data[self.parent().active_channel])) < 3:
-                    self.parent().show_label_dialog()
+            try:
+                value = float(text)
+                
+                # Bound check against data limits
+                value = max(self.data_min, value)
+
+                # Check against max line
+                max_val = float(self.max.text()) if self.max.text() else self.data_max
+                if value > max_val:
+                    # If min would exceed max, set max to its highest possible value
+                    self.max.setText(str(round(self.data_max, 2)))
+                    self.max_line.set_xdata([self.data_max, self.data_max])
+                    # And set min to the previous max value
+                    value = max_val
+                    self.min.setText(str(round(value, 2)))
+
+                if value == self.prev_min:
+                    return
+                else:
+                    self.prev_min = value
+                    if self.bounds:
+                        self.targs = [self.prev_min, self.prev_max]
+                    else:
+                        self.targs = self.get_values_in_range(self.histo_list, self.prev_min, self.prev_max)
+                    self.parent().targs = self.targs
+                    if self.preview.isChecked():
+                        self.parent().highlight_overlay = None
+                        self.parent().create_highlight_overlay_slice(self.targs, bounds = self.bounds)
+                
+                # Update the line
+                self.min_line.set_xdata([value, value])
+                self.canvas.draw()
+
 
-                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)
+            except ValueError:
+                # If invalid number, reset to current line position
+                self.min.setText(str(round(self.min_line.get_xself.data_mindata()[0], 2)))
+        except:
+            pass
+
+    def max_value_changed(self):
+        try:
+            text = self.max.text()
+            if not text:  # If empty, ignore
+                return
                 
-                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)
+            try:
+                value = float(text)
                 
-                max_val = int(get_valid_float(self.max.text(), default_max))
-                min_val = int(get_valid_float(self.min.text(), default_min))
+                # Bound check against data limits
+                value = min(self.data_max, value)
                 
-                if min_val > max_val:
-                    min_val, max_val = max_val, min_val
-                    
-                valid_indices = list(range(min_val, max_val + 1))
+                # Check against min line
+                min_val = float(self.min.text()) if self.min.text() else self.data_min
+                if value < min_val:
+                    # If max would go below min, set min to its lowest possible value
+                    self.min.setText(str(round(self.data_min, 2)))
+                    self.min_line.set_xdata([self.data_min, self.data_min])
+                    # And set max to the previous min value
+                    value = min_val
+                    self.max.setText(str(round(value, 2)))
+
+                if value == self.prev_max:
+                    return
+                else:
+                    self.prev_max = value
+                    if self.bounds:
+                        self.targs = [self.prev_min, self.prev_max]
+                    else:
+                        self.targs = self.get_values_in_range(self.histo_list, self.prev_min, self.prev_max)
+                    self.parent().targs = self.targs
+                    if self.preview.isChecked():
+                        self.parent().highlight_overlay = None
+                        self.parent().create_highlight_overlay_slice(self.targs, bounds = self.bounds)
+                
+                # Update the line
+                self.max_line.set_xdata([value, value])
+                self.canvas.draw()
+
+
+
+
+
+                
+            except ValueError:
+                # If invalid number, reset to current line position
+                self.max.setText(str(round(self.max_line.get_xdata()[0], 2)))
+        except:
+            pass
+        
+    def on_press(self, event):
+        try:
+            if event.inaxes != self.ax:
+                return
             
-            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)
+            # Left click controls left line
+            if event.button == 1:  # Left click
+                self.dragging = 'min'
+            # Right click controls right line
+            elif event.button == 3:  # Right click
+                self.dragging = 'max'
+        except:
+            pass
+                
+    def on_motion(self, event):
+        try:
+            if not self.dragging or event.inaxes != self.ax:
+                return
+                
+            if self.dragging == 'min':
+                if event.xdata < self.max_line.get_xdata()[0]:
+                    self.min_line.set_xdata([event.xdata, event.xdata])
+                    self.min.setText(str(round(event.xdata, 2)))
+            else:
+                if event.xdata > self.min_line.get_xdata()[0]:
+                    self.max_line.set_xdata([event.xdata, event.xdata])
+                    self.max.setText(str(round(event.xdata, 2)))
+                    
+            self.canvas.draw()
+        except:
+            pass
+        
+    def on_release(self, event):
+        self.min_value_changed()
+        self.max_value_changed()
+        self.dragging = None
 
-        except Exception as e:
-            print(f"Error showing preview: {e}")
+    def preview_mode(self):
+        try:
+            preview = self.preview.isChecked()
+            self.parent().preview = preview
+            self.parent().targs = self.targs
+
+            if preview and self.targs is not None:
+                self.parent().create_highlight_overlay_slice(self.parent().targs, bounds = self.bounds)
+        except:
+            pass      
 
     def thresh(self):
         try:
 
-            self.run_preview()
+            if self.parent().active_channel == 0:
+                self.parent().create_highlight_overlay(node_indices = self.targs, bounds = self.bounds)
+            elif self.parent().active_channel == 1:
+                self.parent().create_highlight_overlay(edge_indices = self.targs, bounds = self.bounds)
+            elif self.parent().active_channel == 2:
+                self.parent().create_highlight_overlay(overlay1_indices = self.targs, bounds = self.bounds)
+            elif self.parent().active_channel == 3:
+                self.parent().create_highlight_overlay(overlay2_indices = self.targs, bounds = self.bounds)
+
             channel_data = self.parent().channel_data[self.parent().active_channel]
             mask = self.parent().highlight_overlay > 0
             channel_data = channel_data * mask
@@ -5349,6 +5676,8 @@ class ThresholdWindow(QMainWindow):
             self.close()
             
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
             QMessageBox.critical(
                 self,
                 "Error",
@@ -6119,11 +6448,21 @@ class BranchDialog(QDialog):
         self.nodes.setChecked(True)
         layout.addRow("Generate nodes from edges? (Skip if already completed - presumes your edge skeleton from generate nodes is in Edges and that your original Edges are in Overlay 2):", self.nodes)
 
-        # GPU checkbox (default True)
+        # GPU checkbox (default False)
         self.GPU = QPushButton("GPU")
         self.GPU.setCheckable(True)
         self.GPU.setChecked(False)
-        layout.addRow("Use GPU (Note this may need to temporarily downsample your large images which may simplify outputs - Only memory errors but not permission errors for accessing GRAM are handled by default - CPU will never try to downsample):", self.GPU)
+        layout.addRow("Use GPU (Note this may need to temporarily downsample your large images which may simplify outputs - Only memory errors but not permission errors for accessing VRAM are handled by default - CPU will never try to downsample):", self.GPU)
+
+        # Branch Fix checkbox (default False)
+        self.fix = QPushButton("Auto-Correct Branches")
+        self.fix.setCheckable(True)
+        self.fix.setChecked(False)
+        layout.addRow("Attempt to auto-correct branch labels:", self.fix)
+
+        self.fix_val = QLineEdit()
+        self.fix_val.setPlaceholderText("Empty = default value...")
+        layout.addRow("If checked above - Avg Degree of Nearby Branch Communities to Merge (Attempt to fix branch labeling - try 4 to 6 to start or leave empty):", self.fix_val)
 
         self.down_factor = QLineEdit("0")
         layout.addRow("Internal downsample (will have to recompute nodes)?:", self.down_factor)
@@ -6151,6 +6490,9 @@ class BranchDialog(QDialog):
             nodes = self.nodes.isChecked()
             GPU = self.GPU.isChecked()
             cubic = self.cubic.isChecked()
+            fix = self.fix.isChecked()
+            fix_val = float(self.fix_val.text()) if self.fix_val.text() else None
+
 
 
             original_shape = my_network.edges.shape
@@ -6158,7 +6500,7 @@ class BranchDialog(QDialog):
 
             if down_factor > 0:
                 self.parent().show_gennodes_dialog(down_factor = [down_factor, cubic], called = True)
-            elif nodes:
+            elif nodes or my_network.nodes is None:
                 self.parent().show_gennodes_dialog(called = True)
                 down_factor = None
 
@@ -6166,6 +6508,21 @@ class BranchDialog(QDialog):
 
                 output = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = original_array, GPU = GPU, down_factor = down_factor, arrayshape = original_shape)
 
+                if fix:
+
+                    temp_network = n3d.Network_3D(nodes = output)
+
+                    temp_network.morph_proximity(search = 1) #Detect network of nearby branches
+
+                    temp_network.community_partition(weighted = False, style = 1, dostats = False) #Find communities with louvain, unweighted params
+
+                    targs = n3d.fix_branches(temp_network.nodes, temp_network.network, temp_network.communities, fix_val)
+
+                    temp_network.com_to_node(targs)
+
+                    output = temp_network.nodes
+
+
                 if down_factor is not None:
 
                     self.parent().reset(nodes = True, id_overlay = True, edges = True)
@@ -6181,6 +6538,8 @@ class BranchDialog(QDialog):
 
         except Exception as e:
             print(f"Error labeling branches: {e}")
+            import traceback
+            print(traceback.format_exc())
 
 
 
@@ -6336,7 +6695,7 @@ class AlterDialog(QDialog):
 class ModifyDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
-        self.setWindowTitle("Create Nodes from Edge Vertices")
+        self.setWindowTitle("Modify Network Qualities")
         self.setModal(True)
         layout = QFormLayout(self)
         
@@ -6376,6 +6735,12 @@ class ModifyDialog(QDialog):
         self.isolate.setChecked(False)
         layout.addRow("Isolate connections between two specific node types (if assigned)?:", self.isolate)
 
+        # Community collapse checkbox (default False)
+        self.comcollapse = QPushButton("Communities -> nodes")
+        self.comcollapse.setCheckable(True)
+        self.comcollapse.setChecked(False)
+        layout.addRow("Convert communities to nodes?:", self.comcollapse)
+
         #change button
         change_button = QPushButton("Add/Remove Network Pairs")
         change_button.clicked.connect(self.show_alter_dialog)
@@ -6409,6 +6774,8 @@ class ModifyDialog(QDialog):
             edgeweight = self.edgeweight.isChecked()
             prune = self.prune.isChecked()
             isolate = self.isolate.isChecked()
+            comcollapse = self.comcollapse.isChecked()
+
 
             if isolate and my_network.node_identities is not None:
                 self.show_isolate_dialog()
@@ -6434,6 +6801,15 @@ class ModifyDialog(QDialog):
                     self.parent().format_for_upperright_table(my_network.node_centroids, 'NodeID', ['Z', 'Y', 'X'], 'Node Centroids')
                 except:
                     pass
+            if comcollapse:
+                if my_network.communities is None:
+                    self.parent().show_partition_dialog()
+                    if my_network.communities is None:
+                        return
+                my_network.com_to_node()
+                self.parent().load_channel(0, my_network.nodes, True)
+                my_network.communities = None
+
             try:
                 if hasattr(my_network, 'network_lists'):
                     model = PandasModel(my_network.network_lists)
@@ -6552,8 +6928,7 @@ class CentroidDialog(QDialog):
                 "Error",
                 f"Error finding centroids: {str(e)}"
             )
-            import traceback
-            print(traceback.format_exc())
+
 
 
 

nettracer3d/proximity.py

@@ -89,9 +89,11 @@ def process_label(args):
     nodes, label, dilate_xy, dilate_z, array_shape = args
     print(f"Processing node {label}")
     indices = np.argwhere(nodes == label)
+    if len(indices) == 0:
+        return None, None
     z_vals, y_vals, x_vals = get_reslice_indices((indices, dilate_xy, dilate_z, array_shape))
     if z_vals is None: #If get_reslice_indices ran into a ValueError, nothing is returned.
-        return None, None, None
+        return None, None
     sub_nodes = reslice_3d_array((nodes, z_vals, y_vals, x_vals))
     return label, sub_nodes
 

{nettracer3d-0.4.2.dist-info → nettracer3d-0.4.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.4.2
+Version: 0.4.3
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <boom2449@gmail.com>
 Project-URL: User_Manual, https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
@@ -23,6 +23,7 @@ Requires-Dist: pandas
 Requires-Dist: napari
 Requires-Dist: python-louvain
 Requires-Dist: tifffile
+Requires-Dist: qtrangeslider
 Requires-Dist: PyQt6
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
@@ -31,15 +32,8 @@ Requires-Dist: cupy-cuda12x; extra == "cuda12"
 Provides-Extra: cupy
 Requires-Dist: cupy; extra == "cupy"
 
-NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity or volumetric thresholding. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, run a python script in your env with the following commands:
+NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity or volumetric thresholding. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, enter the command 'nettracer3d' in your command prompt:
 
-#Start
-
-from nettracer3d import nettracer_gui
-
-nettracer_gui.run_gui()
-
-#End
 
 This gui is built from the PyQt6 package and therefore may not function on dockers or virtual envs that are unable to support PyQt6 displays. More advanced documentation (especially for the GUI) is coming down the line, but for now please see: https://drive.google.com/drive/folders/1fTkz3n4LN9_VxKRKC8lVQSlrz_wq0bVn?usp=drive_link
 for a user manual that provides older documentation.

{nettracer3d-0.4.2.dist-info → nettracer3d-0.4.3.dist-info}/RECORD

@@ -2,19 +2,19 @@ nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nettracer3d/community_extractor.py,sha256=8bRDJOfZhOFLtpkJVaDQrQ4O8wUywyr-EfVvW5fxyPs,31700
 nettracer3d/hub_getter.py,sha256=KiNtxdajLkwB1ftslvrh1FE1Ch9ZCFEmHSEEotwR-To,8298
 nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
-nettracer3d/morphology.py,sha256=wv7v06YUcn5lMyefcc_znQlXF5iDxvUdoc0fXOKlGTw,12982
-nettracer3d/nettracer.py,sha256=sFwHz-Ghoft3nNS3H691EcMTpoeLKT3I_X-6m6vXpyg,203264
-nettracer3d/nettracer_gui.py,sha256=GSTICp2V0MAwMpw6RcUrR0kdF721bpBOGMHnOK2LHLM,290039
+nettracer3d/morphology.py,sha256=CsRWB0DY-vBBlKdF9IQwgfYYZswuE7n1Iu_Osxgmxnw,13042
+nettracer3d/nettracer.py,sha256=eMQtt6vjhxLYhzIh91pKt3L-K6kKM55FWS-rOu72Vwc,207727
+nettracer3d/nettracer_gui.py,sha256=ceVgsuIbWTQO8KqiNHrGJDPWQtMAH2NM-4sMdvYeKGY,305658
 nettracer3d/network_analysis.py,sha256=MJBBjslA1k_R8ymid77U-qGSgzxFVfzGVQhE0IdhnbE,48046
 nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
 nettracer3d/node_draw.py,sha256=BMiD_FrlOHeGD4AQZ_Emd152PfxFuMgGf2x4S0TOTnw,9752
-nettracer3d/proximity.py,sha256=KYs4QUbt1U79RLzTvt8BmrxeGVaeKOQ2brtzTjjA78c,11011
+nettracer3d/proximity.py,sha256=B1pmFegx5Wb0JKI5rvpILv2VRU09f6M2iljAQAqBja0,11059
 nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
 nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
 nettracer3d/smart_dilate.py,sha256=howfO6Lw5PxNjkaOBSCjkmf7fyau_-_8iTct2mAuTAQ,22083
-nettracer3d-0.4.2.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.4.2.dist-info/METADATA,sha256=ffklpH2f0M7A5xOTDE9blsCn-yZnCXhe0GaBpgUQcEI,2894
-nettracer3d-0.4.2.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nettracer3d-0.4.2.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.4.2.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.4.2.dist-info/RECORD,,
+nettracer3d-0.4.3.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.4.3.dist-info/METADATA,sha256=mVVm2Jw0nwFcMa-fyk8ZuHS60qhFVDG2kqm9jUfbiIM,2835
+nettracer3d-0.4.3.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nettracer3d-0.4.3.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.4.3.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.4.3.dist-info/RECORD,,