nettracer3d 0.5.7__tar.gz → 0.5.9__tar.gz

{nettracer3d-0.5.7/src/nettracer3d.egg-info → nettracer3d-0.5.9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.5.7
+Version: 0.5.9
 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.7 updates --
+-- Version 0.5.9 updates --
 
-1. Minor change - Can now export network as .gexf (Gephi), .GraphML, or .net (Pajek) for other network analysis softwares to use.
+1. Bug fixes

{nettracer3d-0.5.7 → nettracer3d-0.5.9}/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.7 updates --
+-- Version 0.5.9 updates --
 
-1. Minor change - Can now export network as .gexf (Gephi), .GraphML, or .net (Pajek) for other network analysis softwares to use.
+1. Bug fixes

{nettracer3d-0.5.7 → nettracer3d-0.5.9}/pyproject.toml

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

{nettracer3d-0.5.7 → nettracer3d-0.5.9}/src/nettracer3d/nettracer_gui.py

@@ -6546,9 +6546,10 @@ class MachineWindow(QMainWindow):
                 # Reset any processing flags in the segmenter
                 if hasattr(self.segmenter, '_currently_processing'):
                     self.segmenter._currently_processing = None
-                    
-                # Create a new worker after a brief delay
-                QTimer.singleShot(500, self.start_segmentation)
+                
+                if 0 in self.parent().highlight_overlay[current_z, :, :]:
+                    # Create a new worker after a brief delay
+                    QTimer.singleShot(500, self.start_segmentation)
 
 
 
@@ -6665,7 +6666,7 @@ class SegmentationWorker(QThread):
         self._stop = True
 
     def get_poked(self):
-        self.poked = True
+        self.machine_window.poke_segmenter()
         
     def run(self):
         try:
@@ -6680,6 +6681,9 @@ class SegmentationWorker(QThread):
                 
                 # Process the slice with chunked generator
                 for foreground, background in self.segmenter.segment_slice_chunked(current_z):
+                    if foreground == None and background == None:
+                        self.get_poked()
+
                     if self._stop:
                         break
                     

{nettracer3d-0.5.7 → nettracer3d-0.5.9}/src/nettracer3d/segmenter.py

@@ -18,6 +18,7 @@ from concurrent.futures import ThreadPoolExecutor
 import threading
 from scipy import ndimage
 import multiprocessing
+from collections import defaultdict
 
 
 class InteractiveSegmenter:
@@ -98,24 +99,41 @@ class InteractiveSegmenter:
             # First attempt to get the feature map
             feature_map = None
             
-            if slice_z in self.feature_cache:
-                feature_map = self.feature_cache[slice_z]
-            elif hasattr(self, 'map_slice') and self.map_slice is not None and slice_z == self.current_z:
-                feature_map = self.map_slice
-            else:
+            try:
+                if slice_z in self.feature_cache:
+                    feature_map = self.feature_cache[slice_z]
+                elif hasattr(self, 'map_slice') and self.map_slice is not None and slice_z == self.current_z:
+                    feature_map = self.map_slice
+                else:
+                    # Generate new feature map
+                    try:
+                        feature_map = self.get_feature_map_slice(slice_z, self.current_speed, False)
+                        self.map_slice = feature_map
+                        # Cache the feature map for future use
+                        #if not hasattr(self, 'feature_cache'):
+                            #self.feature_cache = {}
+                        #self.feature_cache[slice_z] = feature_map
+                    except Exception as e:
+                        print(f"Error generating feature map: {e}")
+                        import traceback
+                        traceback.print_exc()
+                        return  # Exit if we can't generate the feature map
+            except:
                 # Generate new feature map
+                #self.feature_cache = {}
                 try:
                     feature_map = self.get_feature_map_slice(slice_z, self.current_speed, False)
                     self.map_slice = feature_map
                     # Cache the feature map for future use
-                    if not hasattr(self, 'feature_cache'):
-                        self.feature_cache = {}
-                    self.feature_cache[slice_z] = feature_map
+                    #if not hasattr(self, 'feature_cache'):
+                        #self.feature_cache = {}
+                    #self.feature_cache[slice_z] = feature_map
                 except Exception as e:
                     print(f"Error generating feature map: {e}")
                     import traceback
                     traceback.print_exc()
                     return  # Exit if we can't generate the feature map
+
             
             # Check that we have a valid feature map
             if feature_map is None:
@@ -152,7 +170,12 @@ class InteractiveSegmenter:
                     
                     # Predict
                     try:
-                        predictions = self.model.predict(features)
+                        try:
+                            predictions = self.model.predict(features)
+                        except ValueError:
+                            self.feature_cache = None
+                            self.map_slice = None
+                            return None, None
                         
                         # Split results
                         foreground = set()
@@ -692,18 +715,12 @@ class InteractiveSegmenter:
         Returns:
             Dictionary with z-values as keys and lists of corresponding [y, x] coordinates as values
         """
-        z_dict = {}
+        z_dict = defaultdict(list)
         
-        for coord in coordinates:
-            z, y, x = coord  # Unpack the coordinates
-            
-            # Add the y, x coordinate to the appropriate z-value group
-            if z not in z_dict:
-                z_dict[z] = []
-            
-            z_dict[z].append((y, x))  # Store as tuple, not list, so it's hashable
+        for z, y, x in coordinates:
+            z_dict[z].append((y, x))
         
-        return z_dict
+        return dict(z_dict)  # Convert back to regular dict
 
     def process_chunk(self, chunk_coords):
         """Process a chunk of coordinates"""
@@ -727,10 +744,13 @@ class InteractiveSegmenter:
             chunk_by_z = self.organize_by_z(chunk_coords)
             for z, coords in chunk_by_z.items():
 
-                if z not in self.feature_cache and not self.previewing:
+                if self.feature_cache is None:
+                    features = self.get_feature_map_slice(z, self.speed, self.cur_gpu)
+                    features = [features[y, x] for y, x in coords]
+                elif z not in self.feature_cache and not self.previewing:
                     features = self.get_feature_map_slice(z, self.speed, self.cur_gpu)
                     features = [features[y, x] for y, x in coords]
-                elif z not in self.feature_cache and self.previewing:
+                elif z not in self.feature_cache or self.feature_cache is None and self.previewing:
                     features = self.map_slice
                     try:
                         features = [features[y, x] for y, x in coords]
@@ -850,6 +870,7 @@ class InteractiveSegmenter:
                 chunks.append(list(map(tuple, coords)))
         else:
             chunks = create_2d_chunks()
+            self.feature_cache = None #Decided this should not maintain training data for segmenting 2D
         
         foreground_coords = set()
         background_coords = set()
@@ -904,8 +925,9 @@ class InteractiveSegmenter:
         # Only clear map_slice if z changes and we're not already generating a new one
         if self.current_z != self.prev_z:
             # Instead of setting to None, check if we already have it in the cache
-            if hasattr(self, 'feature_cache') and self.current_z not in self.feature_cache:
-                self.map_slice = None
+            if hasattr(self, 'feature_cache') and self.feature_cache is not None:
+                if self.current_z not in self.feature_cache:
+                    self.map_slice = None
             self._currently_segmenting = None
         
         # Update previous z
@@ -1077,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"""
@@ -1088,60 +1113,88 @@ class InteractiveSegmenter:
 
         if self.current_speed != speed:
             self.feature_cache = None
+            if use_gpu:
+                try:
+                    self.model = cuRandomForestClassifier(
+                        n_estimators=100,
+                        max_depth=None
+                    )
+                except:
+                    self.model = RandomForestClassifier(
+                        n_estimators=100,
+                        n_jobs=-1,
+                        max_depth=None
+                    )
+            else:
+                self.model = RandomForestClassifier(
+                    n_estimators=100,
+                    n_jobs=-1,
+                    max_depth=None
+                )
+
 
         if use_two:
 
-            changed = [] #Track which slices need feature maps
+            #changed = [] #Track which slices need feature maps
 
             if not self.use_two: #Clarifies if we need to redo feature cache for 2D
                 self.feature_cache = None
                 self.use_two = True
 
+            self.feature_cache = None #Decided this should reset, can remove this line to have it retain prev feature maps
+            self.two_slices = []
+
             if self.feature_cache == None:
                 self.feature_cache = {}
 
             # Get foreground coordinates and features
             z_fore, y_fore, x_fore = np.where(foreground_array == 1)
+
+
+            fore_coords = list(zip(z_fore, y_fore, x_fore))
             
             # Get background coordinates and features
             z_back, y_back, x_back = np.where(foreground_array == 2)
 
-            slices = set(list(z_back) + list(z_fore))
+            back_coords = list(zip(z_back, y_back, x_back))
 
-            for z in slices:
-                if z not in self.two_slices:
-                    changed.append(z)
-                    self.two_slices.append(z) #Tracks assigning coords to feature map slices
+
+            #slices = set(list(z_back) + list(z_fore))
+
+            #for z in slices:
+                #if z not in self.two_slices:
+                    #changed.append(z)
+                    #self.two_slices.append(z) #Tracks assigning coords to feature map slices
 
             foreground_features = []
             background_features = []
 
-            for i, z in enumerate(z_fore):
-                if z in changed:  # Means this slice needs a feature map
-                    new_map = self.get_feature_map_slice(z, speed, use_gpu)
-                    self.feature_cache[z] = new_map
-                    changed.remove(z)
-                
-                current_map = self.feature_cache[z]
-                
-                # Get the feature vector for this foreground point
-                feature_vector = current_map[y_fore[i], x_fore[i]]
-                
-                # Add to our collection
-                foreground_features.append(feature_vector)
+            z_fores = self.organize_by_z(fore_coords)
+            z_backs = self.organize_by_z(back_coords)
+            slices = set(list(z_fores.keys()) + list(z_backs.keys()))
 
-            for i, z in enumerate(z_back):
-                if z in changed:  # Means this slice needs a feature map
-                    new_map = self.get_feature_map_slice(z, speed, use_gpu)
-                    self.feature_cache[z] = new_map
-                
-                current_map = self.feature_cache[z]
+            for z in slices:
+
+
+                current_map = self.get_feature_map_slice(z, speed, use_gpu)
+
+                if z in z_fores:
                 
-                # Get the feature vector for this foreground point
-                feature_vector = current_map[y_back[i], x_back[i]]
+                    for y, x in z_fores[z]:
+                        # Get the feature vector for this foreground point
+                        feature_vector = current_map[y, x]
+                        
+                        # Add to our collection
+                        foreground_features.append(feature_vector)
+
+                if z in z_backs:
                 
-                # Add to our collection
-                background_features.append(feature_vector)
+                    for y, x in z_backs[z]:
+                        # Get the feature vector for this foreground point
+                        feature_vector = current_map[y, x]
+                    
+                        # Add to our collection
+                        background_features.append(feature_vector)
 
 
         else:

{nettracer3d-0.5.7 → nettracer3d-0.5.9/src/nettracer3d.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.5.7
+Version: 0.5.9
 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.7 updates --
+-- Version 0.5.9 updates --
 
-1. Minor change - Can now export network as .gexf (Gephi), .GraphML, or .net (Pajek) for other network analysis softwares to use.
+1. Bug fixes