nettracer3d 0.4.8__py3-none-any.whl → 0.4.9__py3-none-any.whl

nettracer3d/nettracer_gui.py

@@ -4,7 +4,7 @@ from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QVBoxLayout,
                             QHBoxLayout, QSlider, QMenuBar, QMenu, QDialog, 
                             QFormLayout, QLineEdit, QPushButton, QFileDialog,
                             QLabel, QComboBox, QMessageBox, QTableView, QInputDialog,
-                            QMenu, QTabWidget)
+                            QMenu, QTabWidget, QGroupBox)
 from PyQt6.QtCore import (QPoint, Qt, QAbstractTableModel, QTimer,  QThread, pyqtSignal)
 import numpy as np
 import time
@@ -196,6 +196,17 @@ class ImageViewerWindow(QMainWindow):
         buttons_layout.addWidget(self.high_button)
         self.highlight = True
 
+        self.pen_button = QPushButton("🖊️")
+        self.pen_button.setCheckable(True)
+        self.pen_button.setFixedSize(40, 40)
+        self.pen_button.clicked.connect(self.toggle_brush_mode)
+        buttons_layout.addWidget(self.pen_button)
+
+        self.thresh_button = QPushButton("✏️")
+        self.thresh_button.setFixedSize(40, 40)
+        self.thresh_button.clicked.connect(self.show_thresh_dialog)
+        buttons_layout.addWidget(self.thresh_button)
+
         control_layout.addWidget(buttons_widget)
 
         self.preview = False #Whether in preview mode or not
@@ -1451,6 +1462,7 @@ class ImageViewerWindow(QMainWindow):
         self.zoom_mode = self.zoom_button.isChecked()
         if self.zoom_mode:
             self.pan_button.setChecked(False)
+            self.pen_button.setChecked(False)
             self.pan_mode = False
             self.brush_mode = False
             if self.machine_window is not None:
@@ -1468,6 +1480,7 @@ class ImageViewerWindow(QMainWindow):
         self.pan_mode = self.pan_button.isChecked()
         if self.pan_mode:
             self.zoom_button.setChecked(False)
+            self.pen_button.setChecked(False)
             self.zoom_mode = False
             self.brush_mode = False
             if self.machine_window is not None:
@@ -1479,6 +1492,17 @@ class ImageViewerWindow(QMainWindow):
             else:
                 self.machine_window.toggle_brush_button()
 
+    def toggle_brush_mode(self):
+        """Toggle brush mode on/off"""
+        self.brush_mode = self.pen_button.isChecked()
+        if self.brush_mode:
+            self.pan_button.setChecked(False)
+            self.zoom_button.setChecked(False)
+            self.pan_mode = False
+            self.zoom_mode = False
+            self.update_brush_cursor()
+        else:
+            self.canvas.setCursor(Qt.CursorShape.ArrowCursor)
 
 
     def on_mpl_scroll(self, event):
@@ -1666,7 +1690,10 @@ class ImageViewerWindow(QMainWindow):
                 x, y = int(event.xdata), int(event.ydata)
                 self.last_paint_pos = (x, y)
 
-                channel = 2
+                if self.pen_button.isChecked():
+                    channel = self.active_channel
+                else:
+                    channel = 2
 
                 # Paint at initial position
                 self.paint_at_position(x, y, self.erase, channel)
@@ -1705,6 +1732,8 @@ class ImageViewerWindow(QMainWindow):
             
         if erase:
             val = 0
+        elif self.machine_window is None:
+            val = 255
         elif self.foreground:
             val = 1
         else:
@@ -1789,13 +1818,16 @@ class ImageViewerWindow(QMainWindow):
                 
             x, y = int(event.xdata), int(event.ydata)
 
-            channel = 2
+            if self.pen_button.isChecked():
+                channel = self.active_channel
+            else:
+                channel = 2
 
             
-            if self.channel_data[2] is not None:
+            if self.channel_data[channel] 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
+                height, width = self.channel_data[channel][self.current_slice].shape
                 
                 if hasattr(self, 'last_paint_pos'):
                     last_x, last_y = self.last_paint_pos
@@ -1888,8 +1920,11 @@ class ImageViewerWindow(QMainWindow):
 
         if self.brush_mode:
             self.painting = False
-            for i in self.restore_channels:
-                self.channel_visible[i] = True
+            try:
+                for i in self.restore_channels:
+                    self.channel_visible[i] = True
+            except:
+                pass
             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))
@@ -2223,6 +2258,8 @@ class ImageViewerWindow(QMainWindow):
         skeletonize_action.triggered.connect(self.show_skeletonize_dialog)
         watershed_action = image_menu.addAction("Watershed")
         watershed_action.triggered.connect(self.show_watershed_dialog)
+        invert_action = image_menu.addAction("Invert")
+        invert_action.triggered.connect(self.show_invert_dialog)
         z_proj_action = image_menu.addAction("Z Project")
         z_proj_action.triggered.connect(self.show_z_dialog)
 
@@ -2254,8 +2291,6 @@ class ImageViewerWindow(QMainWindow):
         idoverlay_action = overlay_menu.addAction("Create ID Overlay")
         idoverlay_action.triggered.connect(self.show_idoverlay_dialog)
         searchoverlay_action = overlay_menu.addAction("Show Search Regions")
-        white_action = overlay_menu.addAction("White Background Overlay")
-        white_action.triggered.connect(self.show_white_dialog)
         searchoverlay_action.triggered.connect(self.show_search_dialog)
         shuffle_action = overlay_menu.addAction("Shuffle")
         shuffle_action.triggered.connect(self.show_shuffle_dialog)
@@ -2389,6 +2424,11 @@ class ImageViewerWindow(QMainWindow):
         dialog = WatershedDialog(self)
         dialog.exec()
 
+    def show_invert_dialog(self):
+        """Show the watershed parameter dialog."""
+        dialog = InvertDialog(self)
+        dialog.exec()
+
     def show_z_dialog(self):
         """Show the z-proj dialog."""
         dialog = ZDialog(self)
@@ -2431,6 +2471,9 @@ class ImageViewerWindow(QMainWindow):
 
     def show_thresh_dialog(self):
         """Show threshold dialog"""
+        if self.machine_window is not None:
+            return
+
         dialog = ThresholdDialog(self)
         dialog.exec()
 
@@ -2532,11 +2575,6 @@ class ImageViewerWindow(QMainWindow):
         dialog = SearchOverlayDialog(self)
         dialog.exec()
 
-    def show_white_dialog(self):
-        """Show the white dialog"""
-        dialog = WhiteDialog(self)
-        dialog.exec()
-
     def show_shuffle_dialog(self):
         """Show the shuffle dialog"""
         dialog = ShuffleDialog(self)
@@ -4622,40 +4660,6 @@ class IdOverlayDialog(QDialog):
 
         self.accept()
 
-class WhiteDialog(QDialog):
-
-    def __init__(self, parent=None):
-
-        super().__init__(parent)
-        self.setWindowTitle("Generate White Overlay?")
-        self.setModal(True)
-
-        layout = QFormLayout(self)
-
-        # Add Run button
-        run_button = QPushButton("Generate (Will go to Overlay 2)")
-        run_button.clicked.connect(self.white_overlay)
-        layout.addWidget(run_button)
-
-    def white_overlay(self):
-
-        try:
-            if isinstance(my_network.nodes, np.ndarray) :
-                overlay = np.ones_like(my_network.nodes).astype(np.uint8) * 255
-            elif isinstance(my_network.edges, np.ndarray): 
-                overlay = np.ones_like(my_network.edges).astype(np.uint8) * 255
-            elif isinstance(my_network.network_overlay, np.ndarray):
-                overlay = np.ones_like(my_network.network_overlay).astype(np.uint8) * 255
-
-            my_network.id_overlay = overlay
-
-            self.parent().load_channel(3, channel_data = my_network.id_overlay, data = True)
-
-            self.accept()
-
-        except Exception as e:
-            print(f"Error making white background: {e}")
-
 
 class ShuffleDialog(QDialog):
 
@@ -5820,6 +5824,11 @@ class MachineWindow(QMainWindow):
 
         layout.addLayout(form_layout)
 
+        if self.parent().pen_button.isChecked(): #Disable the pen mode if the user is in it because the segmenter pen forks it
+            self.parent().pen_button.click()
+
+        self.parent().pen_button.setEnabled(False)
+
 
         if self.parent().active_channel == 0:
             if self.parent().channel_data[0] is not None:
@@ -5848,56 +5857,85 @@ class MachineWindow(QMainWindow):
 
         self.parent().update_display()
         
-        # Set a reasonable default size
-        self.setMinimumWidth(400)
-        self.setMinimumHeight(400)
+        # Set a reasonable default size for the window
+        self.setMinimumWidth(600)  # Increased to accommodate grouped buttons
+        self.setMinimumHeight(500)
 
-        # Create zoom button and pan button
-        buttons_widget = QWidget()
-        buttons_layout = QHBoxLayout(buttons_widget)
+        # Create main layout container
+        main_widget = QWidget()
+        main_layout = QVBoxLayout(main_widget)
 
-        # Create zoom button
+        # Group 1: Drawing tools (Brush + Foreground/Background)
+        drawing_group = QGroupBox("Drawing Tools")
+        drawing_layout = QHBoxLayout()
+
+        # Brush 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()
 
+        # Foreground/Background buttons in their own horizontal layout
+        fb_layout = QHBoxLayout()
         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)
 
+        fb_layout.addWidget(self.fore_button)
+        fb_layout.addWidget(self.back_button)
+
+        drawing_layout.addWidget(self.brush_button)
+        drawing_layout.addLayout(fb_layout)
+        drawing_group.setLayout(drawing_layout)
+
+        # Group 2: Processing Options (GPU)
+        processing_group = QGroupBox("Processing Options")
+        processing_layout = QHBoxLayout()
         self.GPU = QPushButton("GPU")
         self.GPU.setCheckable(True)
         self.GPU.setChecked(False)
         self.GPU.clicked.connect(self.toggle_GPU)
-        form_layout.addWidget(self.GPU)
         self.use_gpu = False
-
-        train_button = QPushButton("Train Quick Model")
-        train_button.clicked.connect(lambda: self.train_model(speed = True))
-        form_layout.addRow(train_button)
-
-        train_button = QPushButton("Train More Detailed Model")
-        train_button.clicked.connect(lambda: self.train_model(speed = False))
-        form_layout.addRow(train_button)
-
+        processing_layout.addWidget(self.GPU)
+        processing_group.setLayout(processing_layout)
+
+        # Group 3: Training Options
+        training_group = QGroupBox("Training")
+        training_layout = QVBoxLayout()
+        train_quick = QPushButton("Train Quick Model")
+        train_quick.clicked.connect(lambda: self.train_model(speed=True))
+        train_detailed = QPushButton("Train More Detailed Model")
+        train_detailed.clicked.connect(lambda: self.train_model(speed=False))
+        training_layout.addWidget(train_quick)
+        training_layout.addWidget(train_detailed)
+        training_group.setLayout(training_layout)
+
+        # Group 4: Segmentation Options
+        segmentation_group = QGroupBox("Segmentation")
+        segmentation_layout = QVBoxLayout()
         seg_button = QPushButton("Preview Segment")
         seg_button.clicked.connect(self.start_segmentation)
-        form_layout.addRow(seg_button)
-
         full_button = QPushButton("Segment All")
         full_button.clicked.connect(self.segment)
-        form_layout.addRow(full_button)
+        segmentation_layout.addWidget(seg_button)
+        segmentation_layout.addWidget(full_button)
+        segmentation_group.setLayout(segmentation_layout)
+
+        # Add all groups to main layout
+        main_layout.addWidget(drawing_group)
+        main_layout.addWidget(processing_group)
+        main_layout.addWidget(training_group)
+        main_layout.addWidget(segmentation_group)
+
+        # Set the main widget as the central widget
+        self.setCentralWidget(main_widget)
 
         self.trained = False
 
@@ -5988,7 +6026,25 @@ class MachineWindow(QMainWindow):
             self.segmenter.update_position(self.parent().current_slice, int((current_ylim[0] - current_ylim[1])/2), int((current_xlim[1] - current_xlim[0])/2))
             self.segmentation_worker.start()
 
+    def confirm_seg_dialog(self):
+        """Shows a dialog asking user to confirm segment all"""
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Icon.Question)
+        msg.setText("Alert")
+        msg.setInformativeText("Segment Entire Image? (Window will freeze for processing)")
+        msg.setWindowTitle("Confirm")
+        msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        return msg.exec() == QMessageBox.StandardButton.Yes
 
+    def confirm_close_dialog(self):
+        """Shows a dialog asking user to confirm segment all"""
+        msg = QMessageBox()
+        msg.setIcon(QMessageBox.Icon.Question)
+        msg.setText("Alert")
+        msg.setInformativeText("Close Window?")
+        msg.setWindowTitle("Confirm")
+        msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+        return msg.exec() == QMessageBox.StandardButton.Yes
 
     def update_display(self):
         if not hasattr(self, '_last_update'):
@@ -6030,6 +6086,8 @@ class MachineWindow(QMainWindow):
 
         if not self.trained:
             return
+        elif not self.confirm_seg_dialog():
+            return
         else:
             self.kill_segmentation()
             time.sleep(0.1)
@@ -6066,13 +6124,19 @@ class MachineWindow(QMainWindow):
         print("Finished segmentation moved to Overlay 2. Use File -> Save(As) for disk saving.")
 
     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
-        self.kill_segmentation()
-        time.sleep(0.1)
+        if self.parent().isVisible():
+            if self.confirm_close_dialog():
+
+                if self.brush_button.isChecked():
+                    self.silence_button()
+                    self.toggle_brush_mode()
+                self.parent().pen_button.setEnabled(True)
+                self.parent().brush_mode = False
+                self.parent().machine_window = None
+                self.kill_segmentation()
+                time.sleep(0.1)
+            else:
+                event.ignore()
 
 
 
@@ -6946,6 +7010,65 @@ class WatershedDialog(QDialog):
                 f"Error running watershed: {str(e)}"
             )
 
+class InvertDialog(QDialog):
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Invert Active Channel?")
+        self.setModal(True)
+        
+        layout = QFormLayout(self)
+
+       # Add Run button
+        run_button = QPushButton("Run Invert")
+        run_button.clicked.connect(self.run_invert)
+        layout.addRow(run_button)
+
+    def run_invert(self):
+
+        try:
+
+            # Get the active channel data from parent
+            active_data = self.parent().channel_data[self.parent().active_channel]
+            if active_data is None:
+                raise ValueError("No active image selected")
+
+            try:
+                # Call binarize method with parameters
+                if active_data.dtype == 'uint8' or 'int8':
+                    num = 255
+                elif active_data.dtype == 'uint16' or 'int16':
+                    num = 65,535
+                elif active_data.dtype == 'uint32' or 'int32':
+                    num = 2,147,483,647
+
+                result = (num - active_data
+                    )
+
+                # Update both the display data and the network object
+                self.parent().channel_data[self.parent().active_channel] = result
+
+
+                # Update the corresponding property in my_network
+                setattr(my_network, network_properties[self.parent().active_channel], result)
+
+                self.parent().update_display()
+                self.accept()
+                
+            except Exception as e:
+                QMessageBox.critical(
+                    self,
+                    "Error",
+                    f"Error running invert: {str(e)}"
+                )
+
+        except Exception as e:
+            QMessageBox.critical(
+                self,
+                "Error",
+                f"Error running invert: {str(e)}"
+            )
+
 class ZDialog(QDialog):
 
     def __init__(self, parent=None):

nettracer3d/segmenter.py

@@ -11,6 +11,7 @@ import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor
 import threading
 from scipy import ndimage
+import multiprocessing
 
 
 class InteractiveSegmenter:
@@ -18,11 +19,7 @@ class InteractiveSegmenter:
         self.image_3d = image_3d
         self.patterns = []
 
-        try:
-            self.use_gpu = use_gpu and cp.cuda.is_available()
-        except:
-            self.use_gpu = False
-            
+        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)
@@ -350,23 +347,6 @@ class InteractiveSegmenter:
 
         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_GPU(self, chunk_coords):
         """Process a chunk of coordinates using GPU acceleration"""
         coords = np.array(chunk_coords)
@@ -409,20 +389,40 @@ class InteractiveSegmenter:
         
         return foreground, background
 
-    def segment_volume(self, chunk_size=32, gpu = False):
+    def segment_volume(self, chunk_size=64, gpu=False):
         """Segment volume using parallel processing of chunks with vectorized chunk creation"""
+        #Change the above chunk size to None to have it auto-compute largest chunks (not sure which is faster, 64 seems reasonable in test cases)
 
         try:
             from cuml.ensemble import RandomForestClassifier as cuRandomForestClassifier
         except:
-            print("Cannot find cuml, using CPU to segment instead...")
+            print("Cannot find cuML, using CPU to segment instead...")
             gpu = False
-
-
+        
         if self.feature_cache is None:
             with self.lock:
                 if self.feature_cache is None:
                     self.feature_cache = self.compute_feature_maps()
+
+        print("Chunking data...")
+        
+        # Determine optimal chunk size based on number of cores if not specified
+        if chunk_size is None:
+            total_cores = multiprocessing.cpu_count()
+            
+            # Calculate total volume and target volume per core
+            total_volume = np.prod(self.image_3d.shape)
+            target_volume_per_chunk = total_volume / total_cores
+            
+            # Calculate chunk size that would give us roughly one chunk per core
+            # Using cube root since we want roughly equal sizes in all dimensions
+            chunk_size = int(np.cbrt(target_volume_per_chunk))
+            
+            # Ensure chunk size is at least 32 (minimum reasonable size) and not larger than smallest dimension
+            chunk_size = max(32, min(chunk_size, min(self.image_3d.shape)))
+            
+            # Round to nearest multiple of 32 for better memory alignment
+            chunk_size = ((chunk_size + 15) // 32) * 32
         
         # Calculate number of chunks in each dimension
         z_chunks = (self.image_3d.shape[0] + chunk_size - 1) // chunk_size
@@ -455,6 +455,9 @@ class InteractiveSegmenter:
         
         foreground_coords = set()
         background_coords = set()
+
+        print("Segmenting chunks...")
+
         
         with ThreadPoolExecutor() as executor:
             if gpu:
@@ -482,7 +485,7 @@ class InteractiveSegmenter:
         self.current_y = y
 
 
-    def get_realtime_chunks(self, chunk_size = 32):
+    def get_realtime_chunks(self, chunk_size = 64):
         print("Computing some overhead...")
 
 
@@ -553,7 +556,7 @@ class InteractiveSegmenter:
         try:
             from cuml.ensemble import RandomForestClassifier as cuRandomForestClassifier
         except:
-            print("Cannot find cuml, using CPU to segment instead...")
+            print("Cannot find cuML, using CPU to segment instead...")
             gpu = False
 
 

{nettracer3d-0.4.8.dist-info → nettracer3d-0.4.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.4.8
+Version: 0.4.9
 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
@@ -12,20 +12,20 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: numpy==1.26.4
-Requires-Dist: scipy
-Requires-Dist: scikit-image
-Requires-Dist: Pillow
-Requires-Dist: matplotlib
-Requires-Dist: networkx
-Requires-Dist: opencv-python-headless
-Requires-Dist: openpyxl
-Requires-Dist: pandas
-Requires-Dist: napari
-Requires-Dist: python-louvain
-Requires-Dist: tifffile
-Requires-Dist: qtrangeslider
-Requires-Dist: PyQt6
-Requires-Dist: scikit-learn
+Requires-Dist: scipy==1.14.1
+Requires-Dist: scikit-image==0.25.0
+Requires-Dist: Pillow==11.1.0
+Requires-Dist: matplotlib==3.9.2
+Requires-Dist: networkx==3.2.1
+Requires-Dist: opencv-python-headless==4.10.0.84
+Requires-Dist: openpyxl==3.1.2
+Requires-Dist: pandas==2.2.0
+Requires-Dist: napari==0.5.5
+Requires-Dist: python-louvain==0.16
+Requires-Dist: tifffile==2023.7.18
+Requires-Dist: qtrangeslider==0.1.5
+Requires-Dist: PyQt6==6.8.0
+Requires-Dist: scikit-learn==1.6.1
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
 Provides-Extra: cuda12

{nettracer3d-0.4.8.dist-info → nettracer3d-0.4.9.dist-info}/RECORD

@@ -4,18 +4,18 @@ nettracer3d/hub_getter.py,sha256=KiNtxdajLkwB1ftslvrh1FE1Ch9ZCFEmHSEEotwR-To,829
 nettracer3d/modularity.py,sha256=V1f3s_vGd8EuVz27mzq6ycIGr0BWIpH7c7NU4QjgAHU,30247
 nettracer3d/morphology.py,sha256=CsRWB0DY-vBBlKdF9IQwgfYYZswuE7n1Iu_Osxgmxnw,13042
 nettracer3d/nettracer.py,sha256=hDccGy6RybSJFvY6dsN1l5eM3wKZW93CizlTvgEeyNs,209690
-nettracer3d/nettracer_gui.py,sha256=HIjUaLPGEwtk-2nkRrgrX-l0vSv1aJC-BEinw4hibek,334463
+nettracer3d/nettracer_gui.py,sha256=5HbJjPiOzT6ufIHE_g6SwQrdqNPZKUaISCCq_v2Mv2Q,339562
 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=tBaNXJMkacpHb37LQzMJIRzlfILH3h9jCJE1NqsABWs,28816
+nettracer3d/segmenter.py,sha256=EUH7KEiYhET_D6j0T-wKqZaohcvIGYYIEwUU2Dzl51Q,29502
 nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
 nettracer3d/smart_dilate.py,sha256=dvbG2UhWzMQrtDqSj281rixNRgwUHOFGlJZ9RSl6rKs,24590
-nettracer3d-0.4.8.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.4.8.dist-info/METADATA,sha256=FxmRDLIhjeVd8vGkHqBPk44SpuQ7LmI5R6J5nK2OPXU,2921
-nettracer3d-0.4.8.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-nettracer3d-0.4.8.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.4.8.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.4.8.dist-info/RECORD,,
+nettracer3d-0.4.9.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.4.9.dist-info/METADATA,sha256=ndi_uTzboPrc49eHe78BRzGLyZrWVrYfYsCjoXzIEVM,3029
+nettracer3d-0.4.9.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+nettracer3d-0.4.9.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.4.9.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.4.9.dist-info/RECORD,,