nettracer3d 0.5.8__tar.gz → 0.6.0__tar.gz

{nettracer3d-0.5.8/src/nettracer3d.egg-info → nettracer3d-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.5.8
+Version: 0.6.0
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <mclaughlinliam99@gmail.com>
 Project-URL: User_Tutorial, https://www.youtube.com/watch?v=cRatn5VTWDY
@@ -44,6 +44,6 @@ NetTracer3D is free to use/fork for academic/nonprofit use so long as citation i
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.5.8 updates --
+-- Version 0.6.0 updates --
 
-1. Bug fixes and improvements on the 2d segmenter.
+1. Bug fixes

{nettracer3d-0.5.8 → nettracer3d-0.6.0}/README.md

@@ -8,6 +8,6 @@ NetTracer3D is free to use/fork for academic/nonprofit use so long as citation i
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.5.8 updates --
+-- Version 0.6.0 updates --
 
-1. Bug fixes and improvements on the 2d segmenter.
+1. Bug fixes

{nettracer3d-0.5.8 → nettracer3d-0.6.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.5.8"
+version = "0.6.0"
 authors = [
   { name="Liam McLaughlin", email="mclaughlinliam99@gmail.com" },
 ]

{nettracer3d-0.5.8 → nettracer3d-0.6.0}/src/nettracer3d/nettracer_gui.py

@@ -840,7 +840,7 @@ class ImageViewerWindow(QMainWindow):
                 select_nodes.triggered.connect(lambda: self.handle_select_all(edges = False, nodes = True))
                 select_both.triggered.connect(lambda: self.handle_select_all(edges = True))
                 select_edges.triggered.connect(lambda: self.handle_select_all(edges = True, nodes = False))
-                if self.highlight_overlay is not None:
+                if self.highlight_overlay is not None or self.mini_overlay_data is not None:
                     highlight_select = context_menu.addAction("Add highlight in network selection")
                     highlight_select.triggered.connect(self.handle_highlight_select)
                 show_remove_menu.triggered.connect(self.handle_remove_points)
@@ -3514,206 +3514,211 @@ class ImageViewerWindow(QMainWindow):
     def update_display(self, preserve_zoom=None, dims = None, called = False, reset_resize = False, begin_paint = False):
         """Update the display with currently visible channels and highlight overlay."""
 
-        if begin_paint:
-            # Store/update the static background with current zoom level
-            self.static_background = self.canvas.copy_from_bbox(self.ax.bbox)
+        try:
 
+            if begin_paint:
+                # Store/update the static background with current zoom level
+                self.static_background = self.canvas.copy_from_bbox(self.ax.bbox)
 
-        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:
-                min_height = 1
-                min_width = 1
-        else:
-            min_height = dims[0]
-            min_width = dims[1]
+            self.figure.clear()
 
-        # 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
- 
-        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
+            # 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_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
+                    min_height = 1
+                    min_width = 1
+            else:
+                min_height = dims[0]
+                min_width = dims[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]
+            # 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
+     
+            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):
                     
-                    # 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']
+                    # 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)
                     
-                    # Normalize the image safely
-                    if vmin == vmax:
-                        normalized_image = np.zeros_like(current_image)
+                    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:
-                        normalized_image = np.clip((current_image - vmin) / (vmax - vmin), 0, 1)
-                    
-                    if channel == 2 and self.machine_window is not None:
-                        custom_cmap = LinearSegmentedColormap.from_list(
-                            f'custom_{channel}',
-                            [(0, 0, 0, 0),          # transparent for 0
-                             (0.5, 1, 0.5, 1),      # light green for 1
-                             (1, 0.5, 0.5, 1)]      # light red for 2
-                        )
+                        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,
-                                     cmap=custom_cmap,
-                                     vmin=0,
-                                     vmax=2,
-                                     alpha=0.7,
-                                     interpolation='nearest',
-                                     extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+                                     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:
-                        # Create custom colormap with higher intensity
-                        color = base_colors[channel]
-                        custom_cmap = LinearSegmentedColormap.from_list(
-                            f'custom_{channel}',
-                            [(0,0,0,0), (*color,1)]
-                        )
+                        # 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]
                         
-                        # 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))
-
-        if self.preview and not called:
-            self.create_highlight_overlay_slice(self.targs, bounds = self.bounds)
-
-        # Add highlight overlay if it exists
-        if self.mini_overlay and self.highlight and self.machine_window is None:
-            highlight_cmap = LinearSegmentedColormap.from_list(
-                'highlight',
-                [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
-            )
-            self.ax.imshow(self.mini_overlay_data,
-                         cmap=highlight_cmap,
-                         alpha=0.5)
-        elif self.highlight_overlay is not None and self.highlight and self.machine_window is 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)
-        elif self.highlight_overlay is not None and self.highlight:
-            highlight_slice = self.highlight_overlay[self.current_slice]
-            highlight_cmap = LinearSegmentedColormap.from_list(
-                'highlight',
-                [(0, 0, 0, 0),          # transparent for 0
-                 (1, 1, 0, 1),          # bright yellow for 1
-                 (0, 0.7, 1, 1)]        # cool blue for 2
-            )
-            self.ax.imshow(highlight_slice,
-                         cmap=highlight_cmap,
-                         vmin=0,
-                         vmax=2,         # Important: set vmax to 2 to accommodate both values
-                         alpha=0.5)
-
-
-
-        
-        # 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)
+                        # 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)
+                        
+                        if channel == 2 and self.machine_window is not None:
+                            custom_cmap = LinearSegmentedColormap.from_list(
+                                f'custom_{channel}',
+                                [(0, 0, 0, 0),          # transparent for 0
+                                 (0.5, 1, 0.5, 1),      # light green for 1
+                                 (1, 0.5, 0.5, 1)]      # light red for 2
+                            )
+                            self.ax.imshow(current_image,
+                                         cmap=custom_cmap,
+                                         vmin=0,
+                                         vmax=2,
+                                         alpha=0.7,
+                                         interpolation='nearest',
+                                         extent=(-0.5, min_width-0.5, min_height-0.5, -0.5))
+                        else:
+                            # 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))
+
+            if self.preview and not called:
+                self.create_highlight_overlay_slice(self.targs, bounds = self.bounds)
+
+            # Add highlight overlay if it exists
+            if self.mini_overlay and self.highlight and self.machine_window is None:
+                highlight_cmap = LinearSegmentedColormap.from_list(
+                    'highlight',
+                    [(0, 0, 0, 0), (1, 1, 0, 1)]  # yellow
+                )
+                self.ax.imshow(self.mini_overlay_data,
+                             cmap=highlight_cmap,
+                             alpha=0.5)
+            elif self.highlight_overlay is not None and self.highlight and self.machine_window is 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)
+            elif self.highlight_overlay is not None and self.highlight:
+                highlight_slice = self.highlight_overlay[self.current_slice]
+                highlight_cmap = LinearSegmentedColormap.from_list(
+                    'highlight',
+                    [(0, 0, 0, 0),          # transparent for 0
+                     (1, 1, 0, 1),          # bright yellow for 1
+                     (0, 0.7, 1, 1)]        # cool blue for 2
+                )
+                self.ax.imshow(highlight_slice,
+                             cmap=highlight_cmap,
+                             vmin=0,
+                             vmax=2,         # Important: set vmax to 2 to accommodate both values
+                             alpha=0.5)
 
-        if self.resizing:
-            self.original_xlim = self.ax.get_xlim()
-            self.original_ylim = self.ax.get_ylim()
-        # 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)
-        if reset_resize:
-            self.resizing = False
+
+
+            
+            # 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)
         
-        self.canvas.draw()
+            if active_channels:
+                self.ax.set_xlim(-0.5, min_width - 0.5)
+                self.ax.set_ylim(min_height - 0.5, -0.5)
+
+            if self.resizing:
+                self.original_xlim = self.ax.get_xlim()
+                self.original_ylim = self.ax.get_ylim()
+            # 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)
+            if reset_resize:
+                self.resizing = False
+            
+            self.canvas.draw()
+
+        except:
+            pass
 
     def update_display_slice(self, channel, preserve_zoom=None):
         """Ultra minimal update that only changes the paint channel's data"""
@@ -4818,7 +4823,7 @@ class Show3dDialog(QDialog):
                         if visible:
                             arrays_4d.append(channel)
 
-            if self.parent().highlight_overlay is not None:
+            if self.parent().highlight_overlay is not None or self.parent().mini_overlay_data is not None:
                 if self.parent().mini_overlay == True:
                     self.parent().create_highlight_overlay(node_indices = self.parent().clicked_values['nodes'], edge_indices = self.parent().clicked_values['edges'])
                 arrays_3d.append(self.parent().highlight_overlay)
@@ -5048,19 +5053,24 @@ class ShuffleDialog(QDialog):
                 target_data = self.parent().channel_data[accepted_target]
 
 
-            if accepted_mode == 4:
-
-                self.parent().highlight_overlay = n3d.binarize(target_data)
-            else:
-                self.parent().load_channel(accepted_mode, channel_data = target_data, data = True)
+            try:
+                if accepted_mode == 4:
 
+                    self.parent().highlight_overlay = n3d.binarize(target_data)
+                else:
+                    self.parent().load_channel(accepted_mode, channel_data = target_data, data = True)
+            except:
+                pass
 
 
-            if accepted_target == 4:
-                try:
-                    self.parent().highlight_overlay = n3d.binarize(active_data)
-                except:
-                    self.parent().highlight_overlay = None
+            try:
+                if accepted_target == 4:
+                    try:
+                        self.parent().highlight_overlay = n3d.binarize(active_data)
+                    except:
+                        self.parent().highlight_overlay = None
+            except:
+                pass
 
             else:
                 self.parent().load_channel(accepted_target, channel_data = active_data, data = True)
@@ -5862,6 +5872,9 @@ class ResizeDialog(QDialog):
 
                 
                 # Process highlight overlay if it exists
+                if self.parent().mini_overlay_data is not None:
+                    self.parent().create_highlight_overlay(self.parent().clicked_values['nodes'],  self.parent().clicked_values['edges'])
+
                 if self.parent().highlight_overlay is not None:
                     self.parent().highlight_overlay = n3d.resize(self.parent().highlight_overlay, resize, order)
                 if my_network.search_region is not None:
@@ -5877,6 +5890,10 @@ class ResizeDialog(QDialog):
                         resized_data = n3d.upsample_with_padding(self.parent().channel_data[channel], original_shape = self.parent().original_shape)
                         self.parent().load_channel(channel, channel_data=resized_data, data=True, assign_shape = False)
 
+                if self.parent().mini_overlay_data is not None:
+
+                    self.parent().create_highlight_overlay(self.parent().clicked_values['nodes'],  self.parent().clicked_values['edges'])
+
                 
                 # Process highlight overlay if it exists
                 if self.parent().highlight_overlay is not None:
@@ -6105,6 +6122,9 @@ class ThresholdDialog(QDialog):
                 if self.parent().volume_dict[self.parent().active_channel] is None:
                     self.parent().volumes()
 
+            if self.parent().mini_overlay_data is not None:
+                self.parent().mini_overlay_data = None
+
             thresh_window = ThresholdWindow(self.parent(), accepted_mode)
             thresh_window.show()  # Non-modal window
             self.highlight_overlay = None
@@ -6128,6 +6148,8 @@ class ThresholdDialog(QDialog):
             )
             return
 
+        if self.parent().mini_overlay_data is not None:
+            self.parent().mini_overlay_data = None
 
         self.parent().machine_window = MachineWindow(self.parent())
         self.parent().machine_window.show()  # Non-modal window
@@ -6774,6 +6796,7 @@ class ThresholdWindow(QMainWindow):
                 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))

{nettracer3d-0.5.8 → nettracer3d-0.6.0}/src/nettracer3d/segmenter.py

@@ -1099,8 +1099,11 @@ class InteractiveSegmenter:
     def cleanup(self):
         """Clean up GPU memory"""
         if self.use_gpu:
-            cp.get_default_memory_pool().free_all_blocks()
-            torch.cuda.empty_cache()
+            try:
+                cp.get_default_memory_pool().free_all_blocks()
+                torch.cuda.empty_cache()
+            except:
+                pass
 
     def train_batch(self, foreground_array, speed = True, use_gpu = False, use_two = False):
         """Train directly on foreground and background arrays"""

{nettracer3d-0.5.8 → nettracer3d-0.6.0/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.5.8
+Version: 0.6.0
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <mclaughlinliam99@gmail.com>
 Project-URL: User_Tutorial, https://www.youtube.com/watch?v=cRatn5VTWDY
@@ -44,6 +44,6 @@ NetTracer3D is free to use/fork for academic/nonprofit use so long as citation i
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.5.8 updates --
+-- Version 0.6.0 updates --
 
-1. Bug fixes and improvements on the 2d segmenter.
+1. Bug fixes