nettracer3d 0.3.4__tar.gz → 0.3.5__tar.gz

{nettracer3d-0.3.4/src/nettracer3d.egg-info → nettracer3d-0.3.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.3.4
+Version: 0.3.5
 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

{nettracer3d-0.3.4 → nettracer3d-0.3.5}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.3.4"
+version = "0.3.5"
 authors = [
   { name="Liam McLaughlin", email="boom2449@gmail.com" },
 ]

{nettracer3d-0.3.4 → nettracer3d-0.3.5}/src/nettracer3d/nettracer.py

@@ -1524,7 +1524,7 @@ def skeletonize(arrayimage, directory = None):
 
     return arrayimage
 
-def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True):
+def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None):
     """
     Can be used to label branches 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.
     :param array: (Mandatory, string or ndarray) - If string, a path to a tif file to label. Note that the ndarray alternative is for internal use mainly and will not save its output.
@@ -1546,7 +1546,7 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
         array = downsample(array, down_factor)
         arrayshape = array.shape
     else:
-        arrayshape = bonus_array.shape
+        arrayshape = arrayshape
 
 
     if nodes is None:
@@ -1564,6 +1564,7 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
         array = upsample_with_padding(array, down_factor, arrayshape)
 
 
+
     if nodes is None:
 
         array = smart_dilate.smart_label(array, other_array, GPU = GPU)
@@ -1594,7 +1595,7 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
     return array
 
-def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = 0, directory = None, return_skele = False):
+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.
     Note that this can be used in tandem with an edge segmentation to create an image containing 'pseudo-nodes', meaning we can make a network out of just a single edge file.
@@ -1616,7 +1617,9 @@ def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
 
     if down_factor > 0:
         array_shape = array.shape
-        array = downsample(array, down_factor)
+        array = downsample(array, down_factor, order)
+        if order == 3:
+            array = binarize(array)
 
     array = array > 0
 

{nettracer3d-0.3.4 → nettracer3d-0.3.5}/src/nettracer3d/nettracer_gui.py

@@ -2514,17 +2514,10 @@ class ImageViewerWindow(QMainWindow):
         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, preserve_zoom = None):
+    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:
-            # Store current zoom limits if they exist and weren't provided
-            if preserve_zoom is None and hasattr(self, 'ax'):
-                current_xlim = None
-                current_ylim = None
-            else:
-                current_xlim, current_ylim = preserve_zoom if preserve_zoom else (None, None)
-
             if not data:  # For solo loading
                 import tifffile
                 filename, _ = QFileDialog.getOpenFileName(
@@ -2605,13 +2598,7 @@ class ImageViewerWindow(QMainWindow):
             if assign_shape: #keep original shape tracked to undo resampling.
                 self.original_shape = self.channel_data[channel_index].shape
 
-            # 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)
-                self.update_display(preserve_zoom = (current_xlim, current_ylim))
-            else:
-                self.update_display()
+            self.update_display()
 
 
                 
@@ -2835,137 +2822,160 @@ class ImageViewerWindow(QMainWindow):
         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):
-            """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
+    def update_display(self, preserve_zoom=None, dims = None):
+        """Update the display with currently visible channels and highlight overlay."""
+
+        self.figure.clear()
+
+        # Get active channels and their dimensions
+        active_channels = [i for i in range(4) if self.channel_data[i] is not None]
+        if dims is None:
+            if active_channels:
+                dims = [(self.channel_data[i].shape[1:3] if len(self.channel_data[i].shape) >= 3 else 
+                        self.channel_data[i].shape) for i in active_channels]
+                min_height = min(d[0] for d in dims)
+                min_width = min(d[1] for d in dims)
             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 or self.channel_data[channel].shape[-1] == 4)
-                    
-                    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]
+                min_height = 1
+                min_width = 1
+        else:
+            min_height = dims[0]
+            min_width = dims[1]
 
-                    if is_rgb and self.channel_data[channel].shape[-1] == 3:
-                        # For RGB images, just display directly without colormap
-                        self.ax.imshow(current_image,
-                                     alpha=0.7)
-                    elif is_rgb and self.channel_data[channel].shape[-1] == 4:
-                        self.ax.imshow(current_image) #For images that already have an alpha value and RGB, don't update alpha
+        # Set axes limits before displaying any images
+        self.ax.set_xlim(-0.5, min_width - 0.5)
+        self.ax.set_ylim(min_height - 0.5, -0.5)
+        
+        # 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 or self.channel_data[channel].shape[-1] == 4)
+                
+                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 and self.channel_data[channel].shape[-1] == 3:
+                    # For RGB images, just display directly without colormap
+                    self.ax.imshow(current_image,
+                                 alpha=0.7)
+                elif is_rgb and self.channel_data[channel].shape[-1] == 4:
+                    self.ax.imshow(current_image) #For images that already have an alpha value and RGB, don't update alpha
 
+                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:
-                        # 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']
-                
-                # 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')
+                        vmin = img_min + (img_max - img_min) * self.channel_brightness[channel]['min']
+                        vmax = img_min + (img_max - img_min) * self.channel_brightness[channel]['max']
                     
-                # 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)
+                    # 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,
+                                 extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+
+        # 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)
+    
+        if active_channels:
+            self.ax.set_xlim(-0.5, min_width - 0.5)
+            self.ax.set_ylim(min_height - 0.5, -0.5)
         
-            self.canvas.draw()
-
+        self.canvas.draw()
     def show_netshow_dialog(self):
         dialog = NetShowDialog(self)
         dialog.exec()
@@ -4969,6 +4979,7 @@ class ResizeDialog(QDialog):
                         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:
@@ -4990,8 +5001,8 @@ class ResizeDialog(QDialog):
                 # 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)
-
-                my_network.search_region = n3d.upsample_with_padding(my_network.search_region, original_shape = self.parent().original_shape)
+                if my_network.search_region is not None:
+                    my_network.search_region = n3d.upsample_with_padding(my_network.search_region, original_shape = self.parent().original_shape)
 
             
             # Update slider range based on new z-dimension
@@ -5417,7 +5428,7 @@ class DilateDialog(QDialog):
             )
 
             # Update both the display data and the network object
-            self.parent().load_channel(self.parent().active_channel, result, True, preserve_zoom=(current_xlim, current_ylim))
+            self.parent().load_channel(self.parent().active_channel, result, True)
 
             self.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
             self.accept()
@@ -5503,7 +5514,7 @@ class ErodeDialog(QDialog):
             )
 
 
-            self.parent().load_channel(self.parent().active_channel, result, True, preserve_zoom=(current_xlim, current_ylim))
+            self.parent().load_channel(self.parent().active_channel, result, True)
 
 
             self.parent().update_display(preserve_zoom=(current_xlim, current_ylim))
@@ -5908,8 +5919,13 @@ class GenNodesDialog(QDialog):
         if down_factor is None:
             self.down_factor = QLineEdit("0")
             layout.addRow("Downsample Factor (Speeds up calculation at the cost of fidelity):", self.down_factor)
+            self.cubic = QPushButton("Cubic Downsample")
+            self.cubic.setCheckable(True)
+            self.cubic.setChecked(False)
+            layout.addRow("(if downsampling): Use cubic dilation? (Slower but can preserve structure better)", self.cubic)
         else:
-            self.down_factor = down_factor
+            self.down_factor = down_factor[0]
+            self.cubic = down_factor[1]
 
         self.directory = QLineEdit()
         self.directory.setPlaceholderText("Leave empty to save in active dir")
@@ -5922,7 +5938,7 @@ class GenNodesDialog(QDialog):
             self.retain.setChecked(True)
             layout.addRow("Retain Original Edges? (Will be moved to overlay 2):", self.retain)
         else:
-            self.retain = True
+            self.retain = False
 
         # Add Run button
         run_button = QPushButton("Run Node Generation")
@@ -5956,17 +5972,24 @@ class GenNodesDialog(QDialog):
             # Get down_factor
             if type(self.down_factor) is int:
                 down_factor = self.down_factor
+                cubic = self.cubic
             else:
                 try:
                     down_factor = int(self.down_factor.text()) if self.down_factor.text() else 0
                 except ValueError:
                     down_factor = 0
+                cubic = self.cubic.isChecked()
                 
             try:
                 retain = self.retain.isChecked()
             except:
                 retain = True
 
+            if cubic:
+                order = 3
+            else:
+                order = 0
+
             
             result, skele = n3d.label_vertices(
                 my_network.edges,
@@ -5974,12 +5997,14 @@ class GenNodesDialog(QDialog):
                 branch_removal=branch_removal,
                 comp_dil=comp_dil,
                 down_factor=down_factor,
+                order = order,
                 return_skele = True
 
             )
 
             if down_factor > 0 and not self.called:
-                my_network.edges = n3d.downsample(my_network.edges, down_factor)
+
+                my_network.edges = n3d.downsample(my_network.edges, down_factor, order = order)
                 my_network.xy_scale = my_network.xy_scale * down_factor
                 my_network.z_scale = my_network.z_scale * down_factor
                 print("xy_scales and z_scales have been adjusted per downsample. Check image -> properties to manually reset them to 1 if desired.")
@@ -5995,13 +6020,14 @@ class GenNodesDialog(QDialog):
             except:
                 pass
 
+            self.parent().load_channel(1, channel_data = skele, data = True)
+
+            self.parent().load_channel(0, channel_data = result, data = True)
 
             if retain:
                 self.parent().load_channel(3, channel_data = my_network.edges, data = True)
 
-            self.parent().load_channel(1, channel_data = skele, data = True)
 
-            self.parent().load_channel(0, channel_data = result, data = True)
 
             self.parent().update_display()
             self.accept()
@@ -6040,6 +6066,12 @@ class BranchDialog(QDialog):
         self.down_factor = QLineEdit("0")
         layout.addRow("Internal downsample (will have to recompute nodes)?:", self.down_factor)
 
+        # cubic checkbox (default False)
+        self.cubic = QPushButton("Cubic Downsample")
+        self.cubic.setCheckable(True)
+        self.cubic.setChecked(False)
+        layout.addRow("(if downsampling): Use cubic dilation? (Slower but can preserve structure better)", self.cubic)
+
         # Add Run button
         run_button = QPushButton("Run Branch Label")
         run_button.clicked.connect(self.branch_label)
@@ -6056,25 +6088,29 @@ class BranchDialog(QDialog):
 
             nodes = self.nodes.isChecked()
             GPU = self.GPU.isChecked()
+            cubic = self.cubic.isChecked()
+
 
             original_shape = my_network.edges.shape
+            original_array = copy.deepcopy(my_network.edges)
 
             if down_factor > 0:
-                self.parent().show_gennodes_dialog(down_factor = down_factor, called = True)
+                self.parent().show_gennodes_dialog(down_factor = [down_factor, cubic], called = True)
             elif nodes:
                 self.parent().show_gennodes_dialog(called = True)
                 down_factor = None
 
             if my_network.edges is not None and my_network.nodes is not None and my_network.id_overlay is not None:
 
-                output = n3d.label_branches(my_network.edges, nodes = my_network.nodes, bonus_array = my_network.id_overlay, GPU = GPU, down_factor = down_factor)
+                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 down_factor is not None:
 
-                    self.parent().reset(nodes = True, id_overlay = True)
+                    self.parent().reset(nodes = True, id_overlay = True, edges = True)
 
                 else:
                     self.parent().reset(id_overlay = True)
+                self.parent().update_display(dims = (output.shape[1], output.shape[2]))
 
                 self.parent().load_channel(1, channel_data = output, data = True)
 

{nettracer3d-0.3.4 → nettracer3d-0.3.5/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.3.4
+Version: 0.3.5
 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