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

nettracer3d/nettracer.py

@@ -1836,6 +1836,7 @@ def watershed(image, directory = None, proportion = 0.1, GPU = True, smallest_ra
                     gotoexcept = 1/0
 
             except (cp.cuda.memory.OutOfMemoryError, ZeroDivisionError) as e:
+                
                 if predownsample is None:
                     down_factor = smart_dilate.catch_memory(e) #Obtain downsample amount based on memory missing
                 else:
@@ -1866,8 +1867,12 @@ def watershed(image, directory = None, proportion = 0.1, GPU = True, smallest_ra
 
     labels, _ = label_objects(distance)
 
+    if len(labels.shape) ==2:
+        labels = np.expand_dims(labels, axis = 0)
+
     del distance
 
+
     if labels.shape[1] < original_shape[1]: #If downsample was used, upsample output
         labels = upsample_with_padding(labels, downsample_needed, original_shape)
         labels = labels * old_mask
@@ -1876,8 +1881,7 @@ def watershed(image, directory = None, proportion = 0.1, GPU = True, smallest_ra
         labels = smart_dilate.smart_label(image, labels, GPU = GPU, predownsample = predownsample2)
 
     if directory is None:
-        tifffile.imwrite("Watershed_output.tif", labels)
-        print("Watershed saved to 'Watershed_output.tif'")
+        pass
     else:
         tifffile.imwrite(f"{directory}/Watershed_output.tif", labels)
         print(f"Watershed saved to {directory}/'Watershed_output.tif'")

nettracer3d/nettracer_gui.py

@@ -18,12 +18,13 @@ 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)
+from PyQt6.QtGui import (QFont, QCursor, QColor, QPixmap, QPainter, QPen)
 import tifffile
 import copy
 import multiprocessing as mp
 from concurrent.futures import ThreadPoolExecutor
 from functools import partial
+from nettracer3d import segmenter
 
 
 class ImageViewerWindow(QMainWindow):
@@ -106,11 +107,21 @@ class ImageViewerWindow(QMainWindow):
         self.zoom_mode = False
         self.original_xlim = None
         self.original_ylim = None
+        self.zoom_changed = False
 
         # Pan mode state
         self.pan_mode = False
         self.panning = False
         self.pan_start = None
+
+        #For ML segmenting mode
+        self.brush_mode = False
+        self.painting = False
+        self.foreground = True
+        self.machine_window = None
+        self.brush_size = 1  # Start with 1 pixel
+        self.min_brush_size = 1
+        self.max_brush_size = 10
         
         # Store brightness/contrast values for each channel
         self.channel_brightness = [{
@@ -240,6 +251,8 @@ class ImageViewerWindow(QMainWindow):
         self.ax = self.figure.add_subplot(111)
         left_layout.addWidget(self.canvas)
 
+        self.canvas.mpl_connect('scroll_event', self.on_mpl_scroll)
+
         
         left_layout.addWidget(control_panel)
 
@@ -348,6 +361,7 @@ class ImageViewerWindow(QMainWindow):
         self.canvas.mpl_connect('button_press_event', self.on_mouse_press)
         self.canvas.mpl_connect('button_release_event', self.on_mouse_release)
         self.canvas.mpl_connect('motion_notify_event', self.on_mouse_move)
+
         #self.canvas.mpl_connect('button_press_event', self.on_mouse_click)
 
         # Initialize measurement points tracking
@@ -1423,9 +1437,16 @@ class ImageViewerWindow(QMainWindow):
         if self.zoom_mode:
             self.pan_button.setChecked(False)
             self.pan_mode = False
+            self.brush_mode = False
+            if self.machine_window is not None:
+                self.machine_window.silence_button()
             self.canvas.setCursor(Qt.CursorShape.CrossCursor)
         else:
-            self.canvas.setCursor(Qt.CursorShape.ArrowCursor)
+            if self.machine_window is None:
+                self.canvas.setCursor(Qt.CursorShape.ArrowCursor)
+            else:
+                self.machine_window.toggle_brush_button()
+
 
     def toggle_pan_mode(self):
         """Toggle pan mode on/off."""
@@ -1433,14 +1454,132 @@ class ImageViewerWindow(QMainWindow):
         if self.pan_mode:
             self.zoom_button.setChecked(False)
             self.zoom_mode = False
+            self.brush_mode = False
+            if self.machine_window is not None:
+                self.machine_window.silence_button()
             self.canvas.setCursor(Qt.CursorShape.OpenHandCursor)
         else:
-            self.canvas.setCursor(Qt.CursorShape.ArrowCursor)
+            if self.machine_window is None:
+                self.canvas.setCursor(Qt.CursorShape.ArrowCursor)
+            else:
+                self.machine_window.toggle_brush_button()
+
+
+
+    def on_mpl_scroll(self, event):
+        """Handle matplotlib canvas scroll events"""
+        #Wheel events
+        if self.brush_mode and event.inaxes == self.ax:
+            # Check if Ctrl is pressed
+            if event.guiEvent.modifiers() & Qt.ShiftModifier:
+                pass
+
+            elif event.guiEvent.modifiers() & Qt.ControlModifier:
+                # Brush size adjustment code...
+                step = 1 if event.button == 'up' else -1
+                new_size = self.brush_size + step
+                    
+                if new_size < self.min_brush_size:
+                    new_size = self.min_brush_size
+                elif new_size > self.max_brush_size:
+                    new_size = self.max_brush_size
+                    
+                self.brush_size = new_size
+                self.update_brush_cursor()
+                event.guiEvent.accept()
+                return
+
+        # General scrolling code outside the brush mode condition
+        step = 1 if event.button == 'up' else -1
+
+        if event.guiEvent.modifiers() & Qt.ShiftModifier:
+            if event.guiEvent.modifiers() & Qt.ControlModifier:
+                step = step * 3
+            if (self.current_slice + step) < 0 or (self.current_slice + step) > self.slice_slider.maximum():
+                return
+                
+            self.current_slice = self.current_slice + step
+            self.slice_slider.setValue(self.current_slice + step)
+
+            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
+            
+            self.update_display(preserve_zoom=(current_xlim, current_ylim))
+
+    def keyPressEvent(self, event):
+        if event.key() == Qt.Key_Z:
+            self.zoom_button.click()
+        if self.machine_window is not None:
+            if event.key() == Qt.Key_A:
+                self.machine_window.switch_foreground()
+
+
+    def update_brush_cursor(self):
+        """Update the cursor to show brush size"""
+        if not self.brush_mode:
+            return
+            
+        # Create a pixmap for the cursor
+        size = self.brush_size * 2 + 2  # Add padding for border
+        pixmap = QPixmap(size, size)
+        pixmap.fill(Qt.transparent)
+        
+        # Create painter for the pixmap
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing) 
+        
+        # Draw circle
+        pen = QPen(Qt.white)
+        pen.setWidth(1)
+        painter.setPen(pen)
+        painter.setBrush(Qt.transparent)
+        painter.drawEllipse(1, 1, size-2, size-2)
+        
+        # Create cursor from pixmap
+        cursor = QCursor(pixmap)
+        self.canvas.setCursor(cursor)
+        
+        painter.end()
+
+    def get_line_points(self, x0, y0, x1, y1):
+        """Get all points in a line between (x0,y0) and (x1,y1) using Bresenham's algorithm"""
+        points = []
+        dx = abs(x1 - x0)
+        dy = abs(y1 - y0)
+        x, y = x0, y0
+        sx = 1 if x0 < x1 else -1
+        sy = 1 if y0 < y1 else -1
+        
+        if dx > dy:
+            err = dx / 2.0
+            while x != x1:
+                points.append((x, y))
+                err -= dy
+                if err < 0:
+                    y += sy
+                    err += dx
+                x += sx
+        else:
+            err = dy / 2.0
+            while y != y1:
+                points.append((x, y))
+                err -= dx
+                if err < 0:
+                    x += sx
+                    err += dy
+                y += sy
+                
+        points.append((x, y))
+        return points
 
     def on_mouse_press(self, event):
         """Handle mouse press events."""
         if event.inaxes != self.ax:
             return
+
+        if event.button == 2:
+            self.pan_button.click()
+            return
                 
         if self.zoom_mode:
             # Handle zoom mode press
@@ -1459,6 +1598,11 @@ class ImageViewerWindow(QMainWindow):
                 
                 self.ax.set_xlim([xdata - x_range, xdata + x_range])
                 self.ax.set_ylim([ydata - y_range, ydata + y_range])
+
+                self.zoom_changed = True  # Flag that zoom has changed
+                
+                if not hasattr(self, 'zoom_changed'):
+                    self.zoom_changed = False
                 
             elif event.button == 3:  # Right click - zoom out
                 x_range = (current_xlim[1] - current_xlim[0])
@@ -1476,6 +1620,11 @@ class ImageViewerWindow(QMainWindow):
                 else:
                     self.ax.set_xlim(new_xlim)
                     self.ax.set_ylim(new_ylim)
+
+                    self.zoom_changed = False  # Flag that zoom has changed
+                    
+                    if not hasattr(self, 'zoom_changed'):
+                        self.zoom_changed = False
             
             self.canvas.draw()
                 
@@ -1483,6 +1632,50 @@ class ImageViewerWindow(QMainWindow):
             self.panning = True
             self.pan_start = (event.xdata, event.ydata)
             self.canvas.setCursor(Qt.CursorShape.ClosedHandCursor)
+
+        elif self.brush_mode:
+            if event.inaxes != self.ax:
+                return
+            
+
+            if event.button == 1 or event.button == 3:
+
+                if event.button == 3:
+                    self.erase = True
+                else:
+                    self.erase = False
+
+                self.painting = True
+                x, y = int(event.xdata), int(event.ydata)
+                self.last_paint_pos = (x, y)
+
+                if self.foreground:
+                    channel = 2
+                else:
+                    channel = 3
+                
+
+                # Paint at initial position
+                self.paint_at_position(x, y, self.erase, 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
+
+            
+                self.canvas.draw()
+                #self.update_display(preserve_zoom=(current_xlim, current_ylim))
+                self.restore_channels = []
+
+
+                for i in range(4):
+                    if i == channel:
+                        self.channel_visible[i] = True
+                    elif self.channel_data[i] is not None and self.channel_visible[i] == True:
+                        self.channel_visible[i] = False
+                        self.restore_channels.append(i)
+                self.update_display(preserve_zoom = (current_xlim, current_ylim), begin_paint = True)
+                self.update_display_slice(channel, preserve_zoom=(current_xlim, current_ylim))
+
         
         elif event.button == 3:  # Right click (for context menu)
             self.create_context_menu(event)
@@ -1492,12 +1685,32 @@ class ImageViewerWindow(QMainWindow):
             self.selection_start = (event.xdata, event.ydata)
             self.selecting = False  # Will be set to True if the mouse moves while button is held
 
+    def paint_at_position(self, center_x, center_y, erase = False, channel = 2):
+        """Paint pixels within brush radius at given position"""
+        if self.channel_data[channel] is None:
+            return
+            
+        if erase:
+            val = 0
+        else:
+            val = 255
+
+        height, width = self.channel_data[channel][self.current_slice].shape
+        radius = self.brush_size // 2
+        
+        # Calculate brush area
+        for y in range(max(0, center_y - radius), min(height, center_y + radius + 1)):
+            for x in range(max(0, center_x - radius), min(width, center_x + radius + 1)):
+                # Check if point is within circular brush area
+                if (x - center_x) ** 2 + (y - center_y) ** 2 <= radius ** 2:
+                    self.channel_data[channel][self.current_slice][y, x] = val
+
     def on_mouse_move(self, event):
         """Handle mouse movement events."""
         if event.inaxes != self.ax:
             return
                 
-        if self.selection_start and not self.selecting and not self.pan_mode and not self.zoom_mode:
+        if self.selection_start and not self.selecting and not self.pan_mode and not self.zoom_mode and not self.brush_mode:
             # If mouse has moved more than a tiny amount while button is held, start selection
             if (abs(event.xdata - self.selection_start[0]) > 1 or 
                 abs(event.ydata - self.selection_start[1]) > 1):
@@ -1519,6 +1732,7 @@ class ImageViewerWindow(QMainWindow):
             self.canvas.draw()
 
         elif self.panning and self.pan_start is not None:
+
             # Calculate the movement
             dx = event.xdata - self.pan_start[0]
             dy = event.ydata - self.pan_start[1]
@@ -1554,6 +1768,39 @@ class ImageViewerWindow(QMainWindow):
             # Update pan start position
             self.pan_start = (event.xdata, event.ydata)
 
+        elif self.painting and self.brush_mode:
+            if event.inaxes != self.ax:
+                return
+                
+            x, y = int(event.xdata), int(event.ydata)
+
+            if self.foreground:
+                channel = 2
+            else:
+                channel = 3
+
+            
+            if self.channel_data[2] is not None:
+                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
+                height, width = self.channel_data[2][self.current_slice].shape
+                
+                if hasattr(self, 'last_paint_pos'):
+                    last_x, last_y = self.last_paint_pos
+                    points = self.get_line_points(last_x, last_y, x, y)
+                    
+                    # Paint at each point along the line
+                    for px, py in points:
+                        if 0 <= px < width and 0 <= py < height:
+                            self.paint_at_position(px, py, self.erase, channel)
+                
+                self.last_paint_pos = (x, y)
+                
+                self.canvas.draw()
+                #self.update_display(preserve_zoom=(current_xlim, current_ylim))
+                self.update_display_slice(channel, preserve_zoom=(current_xlim, current_ylim))
+
+
     def on_mouse_release(self, event):
         """Handle mouse release events."""
         if self.pan_mode:
@@ -1615,15 +1862,26 @@ class ImageViewerWindow(QMainWindow):
             elif not self.selecting and self.selection_start:  # If we had a click but never started selection
                 # Handle as a normal click
                 self.on_mouse_click(event)
+
             
             # Clean up
             self.selection_start = None
             self.selecting = False
+
+
             if self.selection_rect is not None:
                 self.selection_rect.remove()
                 self.selection_rect = None
                 self.canvas.draw()
 
+        if self.brush_mode:
+            self.painting = False
+            for i in self.restore_channels:
+                self.channel_visible[i] = True
+            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
+            self.update_display(preserve_zoom=(current_xlim, current_ylim))
+
 
     def highlight_value_in_tables(self, clicked_value):
         """Helper method to find and highlight a value in both tables."""
@@ -1718,6 +1976,11 @@ class ImageViewerWindow(QMainWindow):
                 
                 self.ax.set_xlim([xdata - x_range, xdata + x_range])
                 self.ax.set_ylim([ydata - y_range, ydata + y_range])
+
+                self.zoom_changed = True  # Flag that zoom has changed
+                
+                if not hasattr(self, 'zoom_changed'):
+                    self.zoom_changed = False
                 
             elif event.button == 3:  # Right click - zoom out
                 x_range = (current_xlim[1] - current_xlim[0])
@@ -1735,6 +1998,11 @@ class ImageViewerWindow(QMainWindow):
                 else:
                     self.ax.set_xlim(new_xlim)
                     self.ax.set_ylim(new_ylim)
+
+
+                self.zoom_changed = False  # Flag that zoom has changed
+                
+                
             
             self.canvas.draw()
         
@@ -1748,7 +2016,7 @@ class ImageViewerWindow(QMainWindow):
                     x_idx = int(round(event.xdata))
                     y_idx = int(round(event.ydata))
                     # Check if Ctrl key is pressed (using matplotlib's key_press system)
-                    ctrl_pressed = 'ctrl' in event.modifiers  # Note: changed from 'control' to 'ctrl'
+                    ctrl_pressed = 'ctrl' in event.modifiers  
                     if self.channel_data[self.active_channel][self.current_slice, y_idx, x_idx] != 0:
                         clicked_value = self.channel_data[self.active_channel][self.current_slice, y_idx, x_idx]
                     else:
@@ -2636,6 +2904,7 @@ class ImageViewerWindow(QMainWindow):
                     "TIFF Files (*.tif *.tiff)"
                 )
                 self.channel_data[channel_index] = tifffile.imread(filename)
+
                 if len(self.channel_data[channel_index].shape) == 2:  # handle 2d data
                     self.channel_data[channel_index] = np.expand_dims(self.channel_data[channel_index], axis=0)
 
@@ -2651,10 +2920,14 @@ 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])
 
+            reset_resize = False
+
             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.resizing = True
+                            reset_resize = True
                             self.highlight_overlay = None
                     continue
                 else:
@@ -2725,7 +2998,7 @@ class ImageViewerWindow(QMainWindow):
                 if len(self.original_shape) == 4:
                     self.original_shape = (self.original_shape[0], self.original_shape[1], self.original_shape[2])
 
-            self.update_display()
+            self.update_display(reset_resize = reset_resize)
 
 
                 
@@ -2952,10 +3225,18 @@ class ImageViewerWindow(QMainWindow):
         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, called = False):
+    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)
+
+
         self.figure.clear()
 
         # Get active channels and their dimensions
@@ -3111,9 +3392,42 @@ class ImageViewerWindow(QMainWindow):
         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()
 
+    def update_display_slice(self, channel, preserve_zoom=None):
+        """Ultra minimal update that only changes the paint channel's data"""
+        if not self.channel_visible[channel]:
+            return
+
+        if preserve_zoom:
+            current_xlim, current_ylim = preserve_zoom
+            if current_xlim is not None and current_ylim is not None:
+                self.ax.set_xlim(current_xlim)
+                self.ax.set_ylim(current_ylim)
+
+
+        # Find the existing image for channel (paint channel)
+        channel_image = None
+        for img in self.ax.images:
+            if img.cmap.name == f'custom_{channel}':
+                channel_image = img
+                break
+
+        if channel_image is not None:
+            # Update the data of the existing image
+            channel_image.set_array(self.channel_data[channel][self.current_slice])
+            
+            # Restore the static background (all other channels) at current zoom level
+            self.canvas.restore_region(self.static_background)
+            # Draw just our paint channel
+            self.ax.draw_artist(channel_image)
+            # Blit everything
+            self.canvas.blit(self.ax.bbox)
+            self.canvas.flush_events()
+
     def show_netshow_dialog(self):
         dialog = NetShowDialog(self)
         dialog.exec()
@@ -5390,6 +5704,12 @@ class ThresholdDialog(QDialog):
         run_button.clicked.connect(self.thresh_mode)
         layout.addRow(run_button)
 
+        # Add ML button
+        ML = QPushButton("Machine Learning")
+        ML.clicked.connect(self.start_ml)
+        layout.addRow(ML)
+
+
     def thresh_mode(self):
 
         try:
@@ -5410,6 +5730,192 @@ class ThresholdDialog(QDialog):
         except:
             pass
 
+    def start_ml(self):
+
+
+        if self.parent().channel_data[2] is not None or self.parent().channel_data[3] is not None or self.parent().highlight_overlay is not None:
+            if self.confirm_machine_dialog():
+                pass
+            else:
+                return
+        elif self.parent().channel_data[0] is None and self.parent().channel_data[1] is None:
+            QMessageBox.critical(
+                self,
+                "Alert",
+                "Requires the channel for segmentation to be loaded into either the nodes or edges channels"
+            )
+            return
+
+
+        self.parent().machine_window = MachineWindow(self.parent())
+        self.parent().machine_window.show()  # Non-modal window
+        self.accept()
+
+    def confirm_machine_dialog(self):
+        """Shows a dialog asking user to confirm if they want to start the segmenter"""
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Icon.Question)
+        msg.setText("Alert")
+        msg.setInformativeText("Use of this feature will require use of both overlay channels and the highlight overlay. Please save any data and return, or proceed if you do not need those overlays")
+        msg.setWindowTitle("Proceed?")
+        msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        return msg.exec() == QMessageBox.StandardButton.Yes
+
+
+class MachineWindow(QMainWindow):
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        self.setWindowTitle("Threshold")
+        
+        # Create central widget and layout
+        central_widget = QWidget()
+        self.setCentralWidget(central_widget)
+        layout = QVBoxLayout(central_widget)
+
+
+        # Create form layout for inputs
+        form_layout = QFormLayout()
+
+        layout.addLayout(form_layout)
+
+
+
+
+        if self.parent().active_channel == 0:
+            if self.parent().channel_data[0] is not None:
+                active_data = self.parent().channel_data[0]
+            else:
+                active_data = self.parent().channel_data[1]
+
+
+        array1 = np.zeros_like(active_data)
+        array2 = np.zeros_like(active_data)
+        array3 = np.zeros_like(active_data)
+        self.parent().highlight_overlay = array3 #Clear this out for the segmenter to use
+
+        self.parent().load_channel(2, array1, True) #Temp for debugging
+        self.parent().load_channel(3, array2, True) #Temp for debugging
+
+        self.parent().base_colors[2] = self.parent().color_dictionary['LIGHT_GREEN']
+        self.parent().base_colors[3] = self.parent().color_dictionary['LIGHT_RED']
+
+        
+        # Set a reasonable default size
+        self.setMinimumWidth(400)
+        self.setMinimumHeight(400)
+
+        # Create zoom button and pan button
+        buttons_widget = QWidget()
+        buttons_layout = QHBoxLayout(buttons_widget)
+
+        # Create zoom button
+        self.brush_button = QPushButton("🖌️")
+        self.brush_button.setCheckable(True)
+        self.brush_button.setFixedSize(40, 40)
+        self.brush_button.clicked.connect(self.toggle_brush_mode)
+        form_layout.addWidget(self.brush_button)
+        self.brush_button.click()
+
+        self.fore_button = QPushButton("Foreground")
+        self.fore_button.setCheckable(True)
+        self.fore_button.setChecked(True)
+        self.fore_button.clicked.connect(self.toggle_foreground)
+        form_layout.addWidget(self.fore_button)
+
+        self.back_button = QPushButton("Background")
+        self.back_button.setCheckable(True)
+        self.back_button.setChecked(False)
+        self.back_button.clicked.connect(self.toggle_background)
+        form_layout.addWidget(self.back_button)
+
+        train_button = QPushButton("Train Model")
+        train_button.clicked.connect(self.train_model)
+        form_layout.addRow(train_button)
+
+        seg_button = QPushButton("Segment")
+        seg_button.clicked.connect(self.segment)
+        form_layout.addRow(seg_button)
+
+        self.trained = False
+
+
+        self.segmenter = segmenter.InteractiveSegmenter(active_data, use_gpu=True)
+
+
+
+
+    def toggle_foreground(self):
+
+        self.parent().foreground = self.fore_button.isChecked()
+
+        if self.parent().foreground:
+            self.back_button.setChecked(False)
+        else:
+            self.back_button.setChecked(True)
+
+    def switch_foreground(self):
+
+        self.fore_button.click()
+
+    def toggle_background(self):
+
+        self.parent().foreground = not self.back_button.isChecked()
+
+        if not self.parent().foreground:
+            self.fore_button.setChecked(False)
+        else:
+            self.fore_button.setChecked(True)
+
+
+
+    def toggle_brush_mode(self):
+        """Toggle brush mode on/off"""
+        self.parent().brush_mode = self.brush_button.isChecked()
+        if self.parent().brush_mode:
+            self.parent().pan_button.setChecked(False)
+            self.parent().zoom_button.setChecked(False)
+            self.parent().pan_mode = False
+            self.parent().zoom_mode = False
+            self.parent().update_brush_cursor()
+        else:
+            self.parent().zoom_button.click()
+
+    def silence_button(self):
+        self.brush_button.setChecked(False)
+
+    def toggle_brush_button(self):
+
+        self.brush_button.click()
+
+    def train_model(self):
+
+        self.segmenter.train_batch(self.parent().channel_data[2], self.parent().channel_data[3])
+        self.trained = True
+
+    def segment(self):
+
+        if not self.trained:
+            return
+        else:
+            foreground_coords, background_coords = self.segmenter.segment_volume()
+
+            # Clean up when done
+            self.segmenter.cleanup()
+
+        for z,y,x in foreground_coords:
+            self.parent().highlight_overlay[z,y,x] = True
+
+        self.parent().update_display()
+
+    def closeEvent(self, event):
+        if self.brush_button.isChecked():
+            self.silence_button()
+            self.toggle_brush_mode()
+        self.parent().brush_mode = False
+        self.parent().machine_window = None
+
 
 
 
@@ -5430,7 +5936,16 @@ class ThresholdWindow(QMainWindow):
             self.bounds = False
             self.parent().bounds = False
         elif accepted_mode == 0:
-            self.histo_list = self.parent().channel_data[self.parent().active_channel].flatten().tolist()
+            targ_shape = self.parent().channel_data[self.parent().active_channel].shape
+            if (targ_shape[0] + targ_shape[1] + targ_shape[2]) > 2500: #Take a simpler histogram on big arrays
+                temp_max = np.max(self.parent().channel_data[self.parent().active_channel])
+                temp_min = np.min(self.parent().channel_data[self.parent().active_channel])
+                temp_array = n3d.downsample(self.parent().channel_data[self.parent().active_channel], 5)
+                self.histo_list = temp_array.flatten().tolist()
+                self.histo_list.append(temp_min)
+                self.histo_list.append(temp_max)
+            else: #Otherwise just use full array data
+                self.histo_list = self.parent().channel_data[self.parent().active_channel].flatten().tolist()
             self.bounds = True
             self.parent().bounds = True
             
@@ -5676,8 +6191,7 @@ class ThresholdWindow(QMainWindow):
             self.close()
             
         except Exception as e:
-            import traceback
-            print(traceback.format_exc())
+
             QMessageBox.critical(
                 self,
                 "Error",
@@ -6104,9 +6618,17 @@ class WatershedDialog(QDialog):
         self.directory = QLineEdit()
         self.directory.setPlaceholderText("Leave empty for None")
         layout.addRow("Output Directory:", self.directory)
+
+        active_shape = self.parent().channel_data[self.parent().active_channel].shape[0]
+
+        if active_shape == 1:
+            self.default = 0.2
+        else:
+            self.default = 0.05
+
         
         # Proportion (default 0.1)
-        self.proportion = QLineEdit("0.05")
+        self.proportion = QLineEdit(f"{self.default}")
         layout.addRow("Proportion:", self.proportion)
         
         # GPU checkbox (default True)
@@ -6142,9 +6664,9 @@ class WatershedDialog(QDialog):
             
             # Get proportion (0.1 if empty or invalid)
             try:
-                proportion = float(self.proportion.text()) if self.proportion.text() else 0.05
+                proportion = float(self.proportion.text()) if self.proportion.text() else self.default
             except ValueError:
-                proportion = 0.05
+                proportion = self.default
             
             # Get GPU state
             gpu = self.gpu.isChecked()
@@ -6171,7 +6693,8 @@ class WatershedDialog(QDialog):
             active_data = self.parent().channel_data[self.parent().active_channel]
             if active_data is None:
                 raise ValueError("No active image selected")
-            
+
+
             # Call watershed method with parameters
             result = n3d.watershed(
                 active_data,
@@ -6194,6 +6717,8 @@ class WatershedDialog(QDialog):
             self.accept()
             
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
             QMessageBox.critical(
                 self,
                 "Error",

nettracer3d/segmenter.py

@@ -0,0 +1,290 @@
+from sklearn.ensemble import RandomForestClassifier
+import numpy as np
+import cupy as cp
+import torch
+from concurrent.futures import ThreadPoolExecutor
+import threading
+import cupyx.scipy.ndimage as cpx
+
+
+class InteractiveSegmenter:
+    def __init__(self, image_3d, use_gpu=True):
+        self.image_3d = image_3d
+        self.patterns = []
+
+        self.use_gpu = use_gpu and cp.cuda.is_available()
+        if self.use_gpu:
+            print(f"Using GPU: {torch.cuda.get_device_name()}")
+            self.image_gpu = cp.asarray(image_3d)
+        
+        self.model = RandomForestClassifier(
+            n_estimators=100,
+            n_jobs=-1,
+            max_depth=None
+        )
+        self.feature_cache = None
+        self.lock = threading.Lock()
+
+    def compute_feature_maps(self):
+        """Compute all feature maps using GPU acceleration"""
+        if not self.use_gpu:
+            return super().compute_feature_maps()
+        
+        features = []
+        image = self.image_gpu
+        original_shape = self.image_3d.shape
+        
+        # Gaussian smoothing at different scales
+        print("Obtaining gaussians")
+        for sigma in [0.5, 1.0, 2.0, 4.0]:
+            smooth = cp.asnumpy(self.gaussian_filter_gpu(image, sigma))
+            features.append(smooth)
+        
+        print("Obtaining dif of gaussians")
+
+        # Difference of Gaussians
+        for (s1, s2) in [(1, 2), (2, 4)]:
+            g1 = self.gaussian_filter_gpu(image, s1)
+            g2 = self.gaussian_filter_gpu(image, s2)
+            dog = cp.asnumpy(g1 - g2)
+            features.append(dog)
+        
+        # Convert image to PyTorch tensor for gradient operations
+        image_torch = torch.from_numpy(self.image_3d).cuda()
+        image_torch = image_torch.float().unsqueeze(0).unsqueeze(0)
+        
+        # Calculate required padding
+        kernel_size = 3
+        padding = kernel_size // 2
+        
+        # Create a single padded version with same padding
+        pad = torch.nn.functional.pad(image_torch, (padding, padding, padding, padding, padding, padding), mode='replicate')
+        
+        print("Computing sobel kernels")
+
+        # Create sobel kernels
+        sobel_x = torch.tensor([-1, 0, 1], device='cuda').float().view(1,1,1,1,3)
+        sobel_y = torch.tensor([-1, 0, 1], device='cuda').float().view(1,1,1,3,1)
+        sobel_z = torch.tensor([-1, 0, 1], device='cuda').float().view(1,1,3,1,1)
+        
+        # Compute gradients
+        print("Computing gradiants")
+
+        gx = torch.nn.functional.conv3d(pad, sobel_x, padding=0)[:,:,:original_shape[0],:original_shape[1],:original_shape[2]]
+        gy = torch.nn.functional.conv3d(pad, sobel_y, padding=0)[:,:,:original_shape[0],:original_shape[1],:original_shape[2]]
+        gz = torch.nn.functional.conv3d(pad, sobel_z, padding=0)[:,:,:original_shape[0],:original_shape[1],:original_shape[2]]
+        
+        # Compute gradient magnitude
+        print("Computing gradiant mags")
+
+        gradient_magnitude = torch.sqrt(gx**2 + gy**2 + gz**2)
+        gradient_feature = gradient_magnitude.cpu().numpy().squeeze()
+        
+        features.append(gradient_feature)
+        
+        # Verify shapes
+        for i, feat in enumerate(features):
+            if feat.shape != original_shape:
+                raise ValueError(f"Feature {i} has shape {feat.shape}, expected {original_shape}")
+        
+        return np.stack(features, axis=-1)
+
+    def gaussian_filter_gpu(self, image, sigma):
+        """GPU-accelerated Gaussian filter"""
+        # Create Gaussian kernel
+        result = cpx.gaussian_filter(image, sigma=sigma)
+
+        return result
+
+
+    def train(self):
+        """Train random forest on accumulated patterns"""
+        if len(self.patterns) < 2:
+            return
+        
+        X = []
+        y = []
+        for pattern in self.patterns:
+            X.extend(pattern['features'])
+            y.extend([pattern['is_foreground']] * len(pattern['features']))
+        
+        X = np.array(X)
+        y = np.array(y)
+        self.model.fit(X, y)
+        self.patterns = []
+
+    def process_chunk(self, chunk_coords):
+        """Process a chunk of coordinates"""
+        features = [self.feature_cache[z, y, x] for z, y, x in chunk_coords]
+        predictions = self.model.predict(features)
+        
+        foreground = set()
+        background = set()
+        for coord, pred in zip(chunk_coords, predictions):
+            if pred:
+                foreground.add(coord)
+            else:
+                background.add(coord)
+        
+        return foreground, background
+
+    def segment_volume(self, chunk_size=32):
+        """Segment volume using parallel processing of chunks"""
+        if self.feature_cache is None:
+            with self.lock:
+                if self.feature_cache is None:
+                    self.feature_cache = self.compute_feature_maps()
+        
+        # Create chunks of coordinates
+        chunks = []
+        for z in range(0, self.image_3d.shape[0], chunk_size):
+            for y in range(0, self.image_3d.shape[1], chunk_size):
+                for x in range(0, self.image_3d.shape[2], chunk_size):
+                    chunk_coords = [
+                        (zz, yy, xx) 
+                        for zz in range(z, min(z + chunk_size, self.image_3d.shape[0]))
+                        for yy in range(y, min(y + chunk_size, self.image_3d.shape[1]))
+                        for xx in range(x, min(x + chunk_size, self.image_3d.shape[2]))
+                    ]
+                    chunks.append(chunk_coords)
+        
+        foreground_coords = set()
+        background_coords = set()
+        
+        # Process chunks in parallel
+        with ThreadPoolExecutor() as executor:
+            futures = [executor.submit(self.process_chunk, chunk) for chunk in chunks]
+            
+            for i, future in enumerate(futures):
+                fore, back = future.result()
+                foreground_coords.update(fore)
+                background_coords.update(back)
+                if i % 10 == 0:
+                    print(f"Processed {i}/{len(chunks)} chunks")
+        
+        return foreground_coords, background_coords
+
+    def cleanup(self):
+        """Clean up GPU memory"""
+        if self.use_gpu:
+            cp.get_default_memory_pool().free_all_blocks()
+            torch.cuda.empty_cache()
+
+    def train_batch(self, foreground_array, background_array):
+        """Train directly on foreground and background arrays"""
+        if self.feature_cache is None:
+            with self.lock:
+                if self.feature_cache is None:
+                    self.feature_cache = self.compute_feature_maps()
+        
+        # Get foreground coordinates and features
+        z_fore, y_fore, x_fore = np.where(foreground_array > 0)
+        foreground_features = self.feature_cache[z_fore, y_fore, x_fore]
+        
+        # Get background coordinates and features
+        z_back, y_back, x_back = np.where(background_array > 0)
+        background_features = self.feature_cache[z_back, y_back, x_back]
+        
+        # Combine features and labels
+        X = np.vstack([foreground_features, background_features])
+        y = np.hstack([np.ones(len(z_fore)), np.zeros(len(z_back))])
+        
+        # Train the model
+        self.model.fit(X, y)
+
+        print("Done")
+
+
+
+
+
+
+
+
+
+        def segment_volume_subprocess(self, chunk_size=32, current_z=None, current_x=None, current_y=None):
+            """
+            Segment volume prioritizing chunks near user location.
+            Returns chunks as they're processed.
+            """
+            if self.feature_cache is None:
+                with self.lock:
+                    if self.feature_cache is None:
+                        self.feature_cache = self.compute_feature_maps()
+            
+            # Create chunks with position information
+            chunks_info = []
+            for z in range(0, self.image_3d.shape[0], chunk_size):
+                for y in range(0, self.image_3d.shape[1], chunk_size):
+                    for x in range(0, self.image_3d.shape[2], chunk_size):
+                        chunk_coords = [
+                            (zz, yy, xx) 
+                            for zz in range(z, min(z + chunk_size, self.image_3d.shape[0]))
+                            for yy in range(y, min(y + chunk_size, self.image_3d.shape[1]))
+                            for xx in range(x, min(x + chunk_size, self.image_3d.shape[2]))
+                        ]
+                        
+                        # Store chunk with its corner position
+                        chunks_info.append({
+                            'coords': chunk_coords,
+                            'corner': (z, y, x),
+                            'processed': False
+                        })
+
+            def get_chunk_priority(chunk):
+                """Calculate priority based on distance from user position"""
+                z, y, x = chunk['corner']
+                priority = 0
+                
+                # Priority based on Z distance (always used)
+                if current_z is not None:
+                    priority += abs(z - current_z)
+                
+                # Add X/Y distance if provided
+                if current_x is not None and current_y is not None:
+                    xy_distance = ((x - current_x) ** 2 + (y - current_y) ** 2) ** 0.5
+                    priority += xy_distance
+                    
+                return priority
+
+            with ThreadPoolExecutor() as executor:
+                futures = {}  # Track active futures
+                
+                while True:
+                    # Sort unprocessed chunks by priority
+                    unprocessed_chunks = [c for c in chunks_info if not c['processed']]
+                    if not unprocessed_chunks:
+                        break
+                        
+                    # Sort by distance from current position
+                    unprocessed_chunks.sort(key=get_chunk_priority)
+                    
+                    # Submit new chunks to replace completed ones
+                    while len(futures) < executor._max_workers and unprocessed_chunks:
+                        chunk = unprocessed_chunks.pop(0)
+                        future = executor.submit(self.process_chunk, chunk['coords'])
+                        futures[future] = chunk
+                        chunk['processed'] = True
+                    
+                    # Check completed futures
+                    done, _ = concurrent.futures.wait(
+                        futures.keys(),
+                        timeout=0.1,
+                        return_when=concurrent.futures.FIRST_COMPLETED
+                    )
+                    
+                    # Process completed chunks
+                    for future in done:
+                        chunk = futures[future]
+                        fore, back = future.result()
+                        
+                        # Yield chunk results with position information
+                        yield {
+                            'foreground': fore,
+                            'background': back,
+                            'corner': chunk['corner'],
+                            'size': chunk_size
+                        }
+                        
+                        del futures[future]
+

nettracer3d/smart_dilate.py

@@ -383,42 +383,83 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
     return dilated_nodes_with_labels
 
 def compute_distance_transform_GPU(nodes):
+    is_pseudo_3d = nodes.shape[0] == 1
+    if is_pseudo_3d:
+        nodes = np.squeeze(nodes)  # Convert to 2D for processing
+    
     # Convert numpy array to CuPy array
     nodes_cp = cp.asarray(nodes)
     
     # Compute the distance transform on the GPU
-    distance, nearest_label_indices = cpx.distance_transform_edt(nodes_cp, return_indices=True)
+    _, nearest_label_indices = cpx.distance_transform_edt(nodes_cp, return_indices=True)
     
     # Convert results back to numpy arrays
     nearest_label_indices_np = cp.asnumpy(nearest_label_indices)
     
+    if is_pseudo_3d:
+        # For 2D input, we get (2, H, W) but need (3, 1, H, W)
+        H, W = nearest_label_indices_np[0].shape
+        indices_4d = np.zeros((3, 1, H, W), dtype=nearest_label_indices_np.dtype)
+        indices_4d[1:, 0] = nearest_label_indices_np  # Copy Y and X coordinates
+        # indices_4d[0] stays 0 for all Z coordinates
+        nearest_label_indices_np = indices_4d
+
+    
+
+
     return nearest_label_indices_np
 
 
 def compute_distance_transform(nodes):
+    is_pseudo_3d = nodes.shape[0] == 1
+    if is_pseudo_3d:
+        nodes = np.squeeze(nodes)  # Convert to 2D for processing
+
     distance, nearest_label_indices = distance_transform_edt(nodes, return_indices=True)
+
+    if is_pseudo_3d:
+        # For 2D input, we get (2, H, W) but need (3, 1, H, W)
+        H, W = nearest_label_indices_np[0].shape
+        indices_4d = np.zeros((3, 1, H, W), dtype=nearest_label_indices_np.dtype)
+        indices_4d[1:, 0] = nearest_label_indices_np  # Copy Y and X coordinates
+        # indices_4d[0] stays 0 for all Z coordinates
+        nearest_label_indices_np = indices_4d
+
     return nearest_label_indices
 
 
 
 def compute_distance_transform_distance_GPU(nodes):
 
+    is_pseudo_3d = nodes.shape[0] == 1
+    if is_pseudo_3d:
+        nodes = np.squeeze(nodes)  # Convert to 2D for processing
+
     # Convert numpy array to CuPy array
     nodes_cp = cp.asarray(nodes)
     
     # Compute the distance transform on the GPU
-    distance, nearest_label_indices = cpx.distance_transform_edt(nodes_cp, return_indices=True)
+    distance, _ = cpx.distance_transform_edt(nodes_cp, return_indices=True)
     
     # Convert results back to numpy arrays
     distance = cp.asnumpy(distance)
+
+    if is_pseudo_3d:
+        np.expand_dims(distance, axis = 0)
     
     return distance    
 
 
 def compute_distance_transform_distance(nodes):
 
+    is_pseudo_3d = nodes.shape[0] == 1
+    if is_pseudo_3d:
+        nodes = np.squeeze(nodes)  # Convert to 2D for processing
+
     # Fallback to CPU if there's an issue with GPU computation
-    distance, nearest_label_indices = distance_transform_edt(nodes, return_indices=True)
+    distance, _ = distance_transform_edt(nodes, return_indices=True)
+    if is_pseudo_3d:
+        np.expand_dims(distance, axis = 0)
     return distance
 
 

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.4.3
+Version: 0.4.4
 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
@@ -32,7 +32,7 @@ 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, enter the command 'nettracer3d' in your command prompt:
+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 and volumetric thresholding, or random forest machine learning segmentation. 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:
 
 
 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

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

@@ -3,18 +3,19 @@ nettracer3d/community_extractor.py,sha256=8bRDJOfZhOFLtpkJVaDQrQ4O8wUywyr-EfVvW5
 nettracer3d/hub_getter.py,sha256=KiNtxdajLkwB1ftslvrh1FE1Ch9ZCFEmHSEEotwR-To,8298
 nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
 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/nettracer.py,sha256=x-4xjEJNWzTy5gKvpGAmRzlWD3Wx-lomH_ItqRNv9v8,207727
+nettracer3d/nettracer_gui.py,sha256=1b5sFTCe3Jinc200vRTknGsY_Xm2rj-BG2CDyo-gHGU,324790
 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=B1pmFegx5Wb0JKI5rvpILv2VRU09f6M2iljAQAqBja0,11059
 nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
+nettracer3d/segmenter.py,sha256=Inp3m6ajgR03zh_JyJt3Qntb-ZXmxuxVDBbmQnhb3pM,11619
 nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
-nettracer3d/smart_dilate.py,sha256=howfO6Lw5PxNjkaOBSCjkmf7fyau_-_8iTct2mAuTAQ,22083
-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,,
+nettracer3d/smart_dilate.py,sha256=JALeAZ7LLU2psTuI5wlCZobtDx8I0CfihdoEblwfhOY,23520
+nettracer3d-0.4.4.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.4.4.dist-info/METADATA,sha256=4os3ofWdAzCFAfKt0LvFlUE4atoVKO26s0OKUq1NO7s,2884
+nettracer3d-0.4.4.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nettracer3d-0.4.4.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.4.4.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.4.4.dist-info/RECORD,,