nettracer3d 0.6.1__py3-none-any.whl → 0.6.2__py3-none-any.whl

nettracer3d/segmenter.py

@@ -1290,41 +1290,99 @@ class InteractiveSegmenter:
         #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)
 
         if self.mem_lock:
-            chunk_size = 64 #memory efficient chunk
+            chunk_size = 32 #memory efficient chunk
 
 
         def create_2d_chunks():
             """
             Create chunks by z-slices for 2D processing.
-            Each chunk is a complete z-slice with all y,x coordinates.
+            Each chunk is a complete z-slice with all y,x coordinates,
+            unless the slice exceeds 32768 pixels, in which case it's divided into subchunks.
             
             Returns:
-                List of chunks, where each chunk contains the coordinates for one z-slice
+                List of chunks, where each chunk contains the coordinates for one z-slice or subchunk
             """
-            # Pre-calculate the number of coordinates per z-slice
-            coords_per_slice = self.image_3d.shape[1] * self.image_3d.shape[2]
-
-            # Create all coordinates at once
+            MAX_CHUNK_SIZE = 32768000
             chunks = []
+            
             for z in range(self.image_3d.shape[0]):
-                # Create y, x meshgrid once
-                y_coords, x_coords = np.meshgrid(
-                    np.arange(self.image_3d.shape[1]),
-                    np.arange(self.image_3d.shape[2]),
-                    indexing='ij'
-                )
+                # Get the dimensions of this z-slice
+                y_dim = self.image_3d.shape[1]
+                x_dim = self.image_3d.shape[2]
+                total_pixels = y_dim * x_dim
                 
-                # Create the slice coordinates more efficiently
-                slice_coords = np.column_stack((
-                    np.full(coords_per_slice, z),
-                    y_coords.ravel(),
-                    x_coords.ravel()
-                ))
-                
-                # Convert to list of tuples
-                chunks.append(list(map(tuple, slice_coords)))
-
+                # If the slice is small enough, do not subchunk
+                if total_pixels <= MAX_CHUNK_SIZE or not self.mem_lock:
+                    y_coords, x_coords = np.meshgrid(
+                        np.arange(y_dim),
+                        np.arange(x_dim),
+                        indexing='ij'
+                    )
+                    
+                    slice_coords = np.column_stack((
+                        np.full(total_pixels, z),
+                        y_coords.ravel(),
+                        x_coords.ravel()
+                    ))
+                    
+                    chunks.append(list(map(tuple, slice_coords)))
+                else:
+                    # Determine which dimension to divide (the largest one)
+                    largest_dim = 'y' if y_dim >= x_dim else 'x'
+                    
+                    # Calculate how many divisions we need
+                    num_divisions = int(np.ceil(total_pixels / MAX_CHUNK_SIZE))
+                    
+                    # Calculate the approx size of each division along the largest dimension
+                    if largest_dim == 'y':
+                        div_size = int(np.ceil(y_dim / num_divisions))
+                        # Create subchunks by dividing the y-dimension
+                        for i in range(0, y_dim, div_size):
+                            end_i = min(i + div_size, y_dim)
+                            y_subrange = np.arange(i, end_i)
+                            
+                            # Create meshgrid for this subchunk
+                            y_sub, x_sub = np.meshgrid(
+                                y_subrange,
+                                np.arange(x_dim),
+                                indexing='ij'
+                            )
+                            
+                            # Create coordinates for this subchunk
+                            subchunk_size = len(y_subrange) * x_dim
+                            subchunk_coords = np.column_stack((
+                                np.full(subchunk_size, z),
+                                y_sub.ravel(),
+                                x_sub.ravel()
+                            ))
+                            
+                            chunks.append(list(map(tuple, subchunk_coords)))
+                    else:  # largest_dim == 'x'
+                        div_size = int(np.ceil(x_dim / num_divisions))
+                        # Create subchunks by dividing the x-dimension
+                        for i in range(0, x_dim, div_size):
+                            end_i = min(i + div_size, x_dim)
+                            x_subrange = np.arange(i, end_i)
+                            
+                            # Create meshgrid for this subchunk
+                            y_sub, x_sub = np.meshgrid(
+                                np.arange(y_dim),
+                                x_subrange,
+                                indexing='ij'
+                            )
+                            
+                            # Create coordinates for this subchunk
+                            subchunk_size = y_dim * len(x_subrange)
+                            subchunk_coords = np.column_stack((
+                                np.full(subchunk_size, z),
+                                y_sub.ravel(),
+                                x_sub.ravel()
+                            ))
+                            
+                            chunks.append(list(map(tuple, subchunk_coords)))
+            
             return chunks
+
         try:
             from cuml.ensemble import RandomForestClassifier as cuRandomForestClassifier
         except:
@@ -1415,6 +1473,7 @@ class InteractiveSegmenter:
                 fore, back = self.process_chunk(chunk)
                 foreground_coords.update(fore)
                 background_coords.update(back)
+                chunk[i] = None #Help garbage collection
                 print(f"Processed {i}/{len(chunks)} chunks")
         
         return foreground_coords, background_coords

nettracer3d/smart_dilate.py

@@ -447,11 +447,11 @@ def compute_distance_transform(nodes):
 
     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
+        H, W = nearest_label_indices[0].shape
+        indices_4d = np.zeros((3, 1, H, W), dtype=nearest_label_indices.dtype)
+        indices_4d[1:, 0] = nearest_label_indices  # Copy Y and X coordinates
         # indices_4d[0] stays 0 for all Z coordinates
-        nearest_label_indices_np = indices_4d
+        nearest_label_indices = indices_4d
 
     return nearest_label_indices
 

{nettracer3d-0.6.1.dist-info → nettracer3d-0.6.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.6.1
+Version: 0.6.2
 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,10 +44,8 @@ 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.6.1 updates --
+-- Version 0.6.2 updates --
 
-1. New feature for the machine learning segmenter. Now has a RAM lock mode which will always limit it to computing 1 chunk at a time, in both the interactive segmenter and the gross-segmenter. Feature map calculation within the chunk is made parallel to compensate which should allow this to function more optimally with RAM without really sacrificing performance. This should prevent the segmenter from majorly leaking memory in large arrays.
-2. New function - 'Image' -> 'Select Objects'. Essentially just arbitrary selects/deselects lists of nodes or edges from the user in case there are some they are interested in but can't conveniently find. Allows imports from spreadsheets in case the user preorganizes some set of objects they want to select/deselect.
-3. Brightness/Contrast now shades out of 65,535 instead of 255 which should allow better brightening options to images above 8bit depth.
-4. Select all function updated to use the mini highlight overlay in larger images. Also reports the number of nodes/edges in the array in the cmd window when used.
-5. Deleted the now unused 'hub_getter.py' script from the package.
+1. Fixed bug with performing 2D distance transforms on CPU
+
+2. Updated ram_lock mode in the segmenter to use smaller chunks and garbage collect better.

{nettracer3d-0.6.1.dist-info → nettracer3d-0.6.2.dist-info}/RECORD

@@ -9,12 +9,12 @@ nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,1
 nettracer3d/node_draw.py,sha256=k3sCTfUCJs3aH1C1q1gTNxDz9EAQbBd1hsUIJajxRx8,9823
 nettracer3d/proximity.py,sha256=FnIiI_AzfXd22HwCIFIyQRZxKYJ8YscIDdPnIv-wsO4,10560
 nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
-nettracer3d/segmenter.py,sha256=YE4S2DJwLrvYpSzFkTKZLCyh14JKZmgDfGbB4_5EaU0,80163
+nettracer3d/segmenter.py,sha256=ixx6rPprP5hMwObcwJDMJ-wVVpgUn6eTKiIJohg9KE4,83313
 nettracer3d/simple_network.py,sha256=fP1gkDdtQcHruEZpUdasKdZeVacoLOxKhR3bY0L1CAQ,15426
-nettracer3d/smart_dilate.py,sha256=Kekm6YIVlJniMvJMG6_AwwNmCqK2l4Qtvg9VzzqPKMw,24600
-nettracer3d-0.6.1.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
-nettracer3d-0.6.1.dist-info/METADATA,sha256=XNg9JY1EOoiZ8g5hqcfxe4kjy4_amS8JWWsAUZyK8do,4111
-nettracer3d-0.6.1.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-nettracer3d-0.6.1.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.6.1.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.6.1.dist-info/RECORD,,
+nettracer3d/smart_dilate.py,sha256=6m03KHtRMv0zfJ2aHc1Om4Fhh2abPy-IqDzRCmIEHCY,24588
+nettracer3d-0.6.2.dist-info/LICENSE,sha256=gM207DhJjWrxLuEWXl0Qz5ISbtWDmADfjHp3yC2XISs,888
+nettracer3d-0.6.2.dist-info/METADATA,sha256=LxWDK4jsNYNErRWDsPUf_lY1rWt8y-83aB0R1cXqoOQ,3131
+nettracer3d-0.6.2.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+nettracer3d-0.6.2.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.6.2.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.6.2.dist-info/RECORD,,

{nettracer3d-0.6.1.dist-info → nettracer3d-0.6.2.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any