nettracer3d 0.8.8__py3-none-any.whl → 0.9.0__py3-none-any.whl

nettracer3d/segmenter_GPU.py

@@ -70,67 +70,170 @@ class InteractiveSegmenter:
         self.previous_z_back = None
 
 
-    def process_chunk(self, chunk_coords):
-        """Process a chunk staying in CuPy as much as possible"""
+    def get_minimal_chunks_for_coordinates(self, coordinates_by_z):
+        """
+        Get minimal set of 2D chunks needed to cover the given coordinates
+        Uses same chunking logic as create_2d_chunks()
+        """
+        MAX_CHUNK_SIZE = self.twod_chunk_size
+        needed_chunks = {}
         
-        foreground_coords = []  # Keep as list of CuPy coordinates
-        background_coords = []
+        for z in coordinates_by_z:
+            y_coords = [coord[0] for coord in coordinates_by_z[z]]
+            x_coords = [coord[1] for coord in coordinates_by_z[z]]
+            
+            # Find bounding box of coordinates in this Z-slice
+            y_min, y_max = min(y_coords), max(y_coords)
+            x_min, x_max = min(x_coords), max(x_coords)
+            
+            # Create chunks using same logic as create_2d_chunks
+            y_dim = self.image_3d.shape[1]
+            x_dim = self.image_3d.shape[2]
+            total_pixels = y_dim * x_dim
+            
+            if total_pixels <= MAX_CHUNK_SIZE:
+                # Single chunk for entire Z slice
+                needed_chunks[z] = [[z, 0, y_dim, 0, x_dim]]
+            else:
+                # Multiple chunks - find which ones contain our coordinates
+                largest_dim = 'y' if y_dim >= x_dim else 'x'
+                num_divisions = int(cp.ceil(total_pixels / MAX_CHUNK_SIZE))
+                
+                chunks_for_z = []
+                
+                if largest_dim == 'y':
+                    div_size = int(cp.ceil(y_dim / num_divisions))
+                    for i in range(0, y_dim, div_size):
+                        end_i = min(i + div_size, y_dim)
+                        # Check if this chunk contains any of our coordinates
+                        if any(i <= y <= end_i-1 for y in y_coords):
+                            chunks_for_z.append([z, i, end_i, 0, x_dim])
+                else:
+                    div_size = int(cp.ceil(x_dim / num_divisions))
+                    for i in range(0, x_dim, div_size):
+                        end_i = min(i + div_size, x_dim)
+                        # Check if this chunk contains any of our coordinates
+                        if any(i <= x <= end_i-1 for x in x_coords):
+                            chunks_for_z.append([z, 0, y_dim, i, end_i])
+                
+                needed_chunks[z] = chunks_for_z
+        
+        return needed_chunks
 
+    def compute_features_for_chunk_2d(self, chunk_coords, speed):
+        """
+        Compute features for a 2D chunk
+        chunk_coords: [z, y_start, y_end, x_start, x_end]
+        """
+        z, y_start, y_end, x_start, x_end = chunk_coords
         
+        # Extract 2D subarray for this chunk
+        subarray_2d = self.image_3d[z, y_start:y_end, x_start:x_end]
+        
+        # Compute features for this chunk
+        if speed:
+            feature_map = self.compute_feature_maps_gpu_2d(image_2d=subarray_2d)
+        else:
+            feature_map = self.compute_deep_feature_maps_gpu_2d(image_2d=subarray_2d)
+        
+        return feature_map, (y_start, x_start)  # Return offset for coordinate mapping
+
+
+    def process_chunk_updated(self, chunk_coords):
+        """Updated process_chunk with proper 2D chunking"""
+        
+        foreground_coords = []
+        background_coords = []
+
         if self.realtimechunks is None:
+            # 3D processing (original logic unchanged)
             z_min, z_max = chunk_coords[0], chunk_coords[1]
             y_min, y_max = chunk_coords[2], chunk_coords[3]
             x_min, x_max = chunk_coords[4], chunk_coords[5]
             
-            # Create meshgrid using CuPy - already good
             z_range = cp.arange(z_min, z_max)
             y_range = cp.arange(y_min, y_max)
             x_range = cp.arange(x_min, x_max)
             
-            # More efficient way to create coordinates
             chunk_coords_array = cp.stack(cp.meshgrid(
                 z_range, y_range, x_range, indexing='ij'
             )).reshape(3, -1).T
             
-            # Keep as CuPy array instead of converting to list
             chunk_coords_gpu = chunk_coords_array
+            
+            subarray = self.image_3d[z_min:z_max+1, y_min:y_max+1, x_min:x_max+1]
+            
+            if self.use_two:
+                subarray = cp.squeeze(subarray)
+
+            if self.use_two and self.speed:
+                feature_map = self.compute_feature_maps_gpu_2d(image_2d=subarray)
+            elif self.use_two:
+                feature_map = self.compute_deep_feature_maps_gpu_2d(image_2d=subarray)
+            elif self.speed:
+                feature_map = self.compute_feature_maps_gpu(subarray)
+            else:
+                feature_map = self.compute_deep_feature_maps_gpu(subarray)
+            
+            if self.use_two:
+                feature_map = cp.expand_dims(feature_map, axis=0)
+
+            local_coords = chunk_coords_gpu.copy()
+            local_coords[:, 0] -= z_min
+            local_coords[:, 1] -= y_min
+            local_coords[:, 2] -= x_min
+            
+            features_gpu = feature_map[local_coords[:, 0], local_coords[:, 1], local_coords[:, 2]]
+            
+            features_cpu = cp.asnumpy(features_gpu)
+            predictions = self.model.predict(features_cpu)
+            
+            pred_mask = cp.array(predictions, dtype=bool)
+            foreground_coords = chunk_coords_gpu[pred_mask]
+            background_coords = chunk_coords_gpu[~pred_mask]
+            
         else:
-            # Convert list to CuPy array once
+            # 2D processing - compute features for chunk only (not full Z-slice)
             chunk_coords_gpu = cp.array(chunk_coords)
             z_coords = chunk_coords_gpu[:, 0]
             y_coords = chunk_coords_gpu[:, 1]
             x_coords = chunk_coords_gpu[:, 2]
             
-            z_min, z_max = cp.min(z_coords).item(), cp.max(z_coords).item()
-            y_min, y_max = cp.min(y_coords).item(), cp.max(y_coords).item()
-            x_min, x_max = cp.min(x_coords).item(), cp.max(x_coords).item()
-        
-        # Extract subarray - already good
-        subarray = self.image_3d[z_min:z_max+1, y_min:y_max+1, x_min:x_max+1]
-        
-        # Compute features
-        if self.speed:
-            feature_map = self.compute_feature_maps_gpu(subarray)
-        else:
-            feature_map = self.compute_deep_feature_maps_gpu(subarray)
-        
-        # Extract features more efficiently
-        local_coords = chunk_coords_gpu.copy()
-        local_coords[:, 0] -= z_min
-        local_coords[:, 1] -= y_min
-        local_coords[:, 2] -= x_min
-        
-        # Vectorized feature extraction
-        features_gpu = feature_map[local_coords[:, 0], local_coords[:, 1], local_coords[:, 2]]
-        
-        features_cpu = cp.asnumpy(features_gpu)
-        predictions = self.model.predict(features_cpu)
-        
-        # Keep coordinates as CuPy arrays
-        pred_mask = cp.array(predictions, dtype=bool)
-        foreground_coords = chunk_coords_gpu[pred_mask]
-        background_coords = chunk_coords_gpu[~pred_mask]
-        
+            z = int(cp.unique(z_coords)[0])  # All coordinates should have same Z
+            
+            # Get chunk bounds
+            y_min, y_max = int(cp.min(y_coords)), int(cp.max(y_coords))
+            x_min, x_max = int(cp.min(x_coords)), int(cp.max(x_coords))
+            
+            # Expand bounds slightly to ensure we capture the chunk properly
+            y_min = max(0, y_min)
+            x_min = max(0, x_min)
+            y_max = min(self.image_3d.shape[1], y_max + 1)
+            x_max = min(self.image_3d.shape[2], x_max + 1)
+            
+            # Extract 2D subarray for this chunk
+            subarray_2d = self.image_3d[z, y_min:y_max, x_min:x_max]
+            
+            # Compute features for just this chunk
+            if self.speed:
+                feature_map = self.compute_feature_maps_gpu_2d(image_2d=subarray_2d)
+            else:
+                feature_map = self.compute_deep_feature_maps_gpu_2d(image_2d=subarray_2d)
+            
+            # Convert global coordinates to local chunk coordinates
+            local_y_coords = y_coords - y_min
+            local_x_coords = x_coords - x_min
+            
+            # Extract features using local coordinates
+            features_gpu = feature_map[local_y_coords, local_x_coords]
+            
+            features_cpu = cp.asnumpy(features_gpu)
+            predictions = self.model.predict(features_cpu)
+            
+            pred_mask = cp.array(predictions, dtype=bool)
+            foreground_coords = chunk_coords_gpu[pred_mask]
+            background_coords = chunk_coords_gpu[~pred_mask]
+            
         return foreground_coords, background_coords
 
     def twodim_coords(self, z, y_start, y_end, x_start, x_end):
@@ -373,7 +476,7 @@ class InteractiveSegmenter:
             
             # Stack all channel features
             return cp.concatenate(features_per_channel, axis=-1)
-        
+
         # Pre-allocate result array
         num_features = len(self.sigmas) + len(self.dogs) + 2  # +2 for original image + gradient
         features = cp.empty(image_2d.shape + (num_features,), dtype=image_2d.dtype)
@@ -495,30 +598,25 @@ class InteractiveSegmenter:
             hyy = cupy_ndimage.gaussian_filter(gaussian_img, sigma=0, order=[2, 0], mode='reflect')
             hxy = cupy_ndimage.gaussian_filter(gaussian_img, sigma=0, order=[1, 1], mode='reflect')
             
-            # Vectorized eigenvalue computation using cupy broadcasting
-            # Create arrays with shape (d0, d1, 2, 2) for all 2D Hessian matrices
-            shape = image_2d.shape
-            hessian_matrices = cp.zeros(shape + (2, 2))
+            # Analytical eigenvalue computation for 2x2 symmetric matrices
+            # For matrix [[hxx, hxy], [hxy, hyy]], eigenvalues are:
+            # λ = (trace ± sqrt(trace² - 4*det)) / 2
             
-            # Fill the symmetric 2D Hessian matrices
-            hessian_matrices[..., 0, 0] = hxx
-            hessian_matrices[..., 1, 1] = hyy
-            hessian_matrices[..., 0, 1] = hessian_matrices[..., 1, 0] = hxy
+            trace = hxx + hyy
+            det = hxx * hyy - hxy * hxy
             
-            # Reshape for batch eigenvalue computation
-            original_shape = hessian_matrices.shape[:-2]  # (d0, d1)
-            batch_size = int(cp.prod(cp.array(original_shape)))
-            hessian_batch = hessian_matrices.reshape(batch_size, 2, 2)
+            # Calculate discriminant and ensure it's non-negative
+            discriminant = trace * trace - 4 * det
+            discriminant = cp.maximum(discriminant, 0)  # Handle numerical errors
             
-            # Compute eigenvalues for all matrices at once using CuPy
-            # Since Hessian matrices are symmetric, we can use eigvalsh
-            eigenvalues_batch = cp.linalg.eigvalsh(hessian_batch)
+            sqrt_discriminant = cp.sqrt(discriminant)
             
-            # Get only the largest eigenvalue for each matrix
-            largest_eigenvalues = cp.max(eigenvalues_batch, axis=1)
+            # Calculate both eigenvalues
+            eigenval1 = (trace + sqrt_discriminant) / 2
+            eigenval2 = (trace - sqrt_discriminant) / 2
             
-            # Reshape back to original spatial dimensions
-            largest_eigenvalues = largest_eigenvalues.reshape(original_shape)
+            # Take the larger eigenvalue (most positive/least negative)
+            largest_eigenvalues = cp.maximum(eigenval1, eigenval2)
             
             # Add the largest eigenvalue as a feature
             features[..., feature_idx] = largest_eigenvalues
@@ -678,12 +776,12 @@ class InteractiveSegmenter:
             
     def extract_chunk_features_gpu(self, chunk_coords):
         """
-        GPU version of feature extraction without prediction
-        Returns CPU features and GPU coordinates for efficient batch processing
+        Updated GPU version of feature extraction with chunked 2D processing
+        Returns GPU features and GPU coordinates for efficient batch processing
         """
         
-        if self.previewing or not self.use_two:
-            # 3D processing
+        if not self.use_two:
+            # 3D processing (unchanged)
             if self.realtimechunks is None:
                 z_min, z_max = chunk_coords[0], chunk_coords[1]
                 y_min, y_max = chunk_coords[2], chunk_coords[3]
@@ -723,14 +821,10 @@ class InteractiveSegmenter:
             
             features_gpu = feature_map[local_coords[:, 0], local_coords[:, 1], local_coords[:, 2]]
             
-            # Convert features to CPU for sklearn, convert coordinates to NumPy for final assignment
-            #features_cpu = cp.asnumpy(features_gpu)
-            #coords_cpu = cp.asnumpy(chunk_coords_gpu)
-            
             return features_gpu, chunk_coords_gpu
         
         else:
-            # 2D processing
+            # 2D processing - Updated to use chunked feature computation
             if len(chunk_coords) == 5:
                 z = chunk_coords[0]
                 y_start = chunk_coords[1]
@@ -738,20 +832,25 @@ class InteractiveSegmenter:
                 x_start = chunk_coords[3]
                 x_end = chunk_coords[4]
                 
-                # Generate coordinates for this slice
+                # Generate coordinates for this chunk
                 coords_array = self.twodim_coords(z, y_start, y_end, x_start, x_end)
                 
-                # Get feature map for this z-slice
-                feature_map = self.get_feature_map_slice(z, self.speed, True)
+                # NEW: Compute features for just this chunk instead of full Z-slice
+                # Extract 2D subarray for this chunk
+                subarray_2d = self.image_3d[z, y_start:y_end, x_start:x_end]
                 
-                # Extract features using GPU operations
-                y_indices = coords_array[:, 1]
-                x_indices = coords_array[:, 2]
-                features_gpu = feature_map[y_indices, x_indices]
+                # Compute features for this chunk only
+                if self.speed:
+                    feature_map = self.compute_feature_maps_gpu_2d(image_2d=subarray_2d)
+                else:
+                    feature_map = self.compute_deep_feature_maps_gpu_2d(image_2d=subarray_2d)
+                
+                # Convert global coordinates to local chunk coordinates
+                y_indices = coords_array[:, 1] - y_start  # Local Y coordinates
+                x_indices = coords_array[:, 2] - x_start  # Local X coordinates
                 
-                # Convert features to CPU for sklearn, convert coordinates to NumPy for final assignment
-                #features_cpu = cp.asnumpy(features_gpu)
-                #coords_cpu = cp.asnumpy(coords_array)
+                # Extract features using local coordinates
+                features_gpu = feature_map[y_indices, x_indices]
                 
                 return features_gpu, coords_array
         
@@ -790,51 +889,54 @@ class InteractiveSegmenter:
 
     def get_realtime_chunks_2d(self, chunk_size=None):
         """
-        Create square chunks with 1 z-thickness (2D chunks across XY planes)
+        Create chunks with 1 z-thickness (2D chunks across XY planes)
+        Now uses the same logic as create_2d_chunks for consistency
         """
         
-        if chunk_size is None:
-            chunk_size = int(cp.sqrt(self.twod_chunk_size))
-
-        # Determine if we need to chunk XY planes
-        small_dims = (self.image_3d.shape[1] <= chunk_size and 
-                     self.image_3d.shape[2] <= chunk_size)
-        few_z = self.image_3d.shape[0] <= 100  # arbitrary threshold
-        
-        # If small enough, each Z is one chunk
-        if small_dims and few_z:
-            chunk_size_xy = max(self.image_3d.shape[1], self.image_3d.shape[2])
-        else:
-            chunk_size_xy = chunk_size
-        
-        # Calculate chunks for XY plane
-        y_chunks = (self.image_3d.shape[1] + chunk_size_xy - 1) // chunk_size_xy
-        x_chunks = (self.image_3d.shape[2] + chunk_size_xy - 1) // chunk_size_xy
+        MAX_CHUNK_SIZE = self.twod_chunk_size
         
         # Populate chunk dictionary
         chunk_dict = {}
         
-        # Create chunks for each Z plane (single Z thickness)
+        # Create chunks for each Z plane using the same logic as create_2d_chunks
         for z in range(self.image_3d.shape[0]):
-            if small_dims:
+            y_dim = self.image_3d.shape[1]
+            x_dim = self.image_3d.shape[2]
+            total_pixels = y_dim * x_dim
+            
+            if total_pixels <= MAX_CHUNK_SIZE:
+                # Single chunk for entire Z slice
                 chunk_dict[(z, 0, 0)] = {
-                    'coords': [0, self.image_3d.shape[1], 0, self.image_3d.shape[2]],
+                    'coords': [0, y_dim, 0, x_dim],  # [y_start, y_end, x_start, x_end]
                     'processed': False,
-                    'z': z  # Keep for backward compatibility
+                    'z': z
                 }
             else:
-                # Multiple chunks per Z plane
-                for y_chunk in range(y_chunks):
-                    for x_chunk in range(x_chunks):
-                        y_start = y_chunk * chunk_size_xy
-                        x_start = x_chunk * chunk_size_xy
-                        y_end = min(y_start + chunk_size_xy, self.image_3d.shape[1])
-                        x_end = min(x_start + chunk_size_xy, self.image_3d.shape[2])
-                        
-                        chunk_dict[(z, y_start, x_start)] = {
-                            'coords': [y_start, y_end, x_start, x_end],
+                # Multiple chunks per Z plane - divide along largest dimension
+                largest_dim = 'y' if y_dim >= x_dim else 'x'
+                num_divisions = int(cp.ceil(total_pixels / MAX_CHUNK_SIZE))
+                
+                if largest_dim == 'y':
+                    # Divide along Y dimension
+                    div_size = int(cp.ceil(y_dim / num_divisions))
+                    for i in range(0, y_dim, div_size):
+                        end_i = min(i + div_size, y_dim)
+                        # Use (z, y_start, x_start) as key for consistency
+                        chunk_dict[(z, i, 0)] = {
+                            'coords': [i, end_i, 0, x_dim],  # [y_start, y_end, x_start, x_end]
                             'processed': False,
-                            'z': z  # Keep for backward compatibility
+                            'z': z
+                        }
+                else:
+                    # Divide along X dimension
+                    div_size = int(cp.ceil(x_dim / num_divisions))
+                    for i in range(0, x_dim, div_size):
+                        end_i = min(i + div_size, x_dim)
+                        # Use (z, y_start, x_start) as key for consistency
+                        chunk_dict[(z, 0, i)] = {
+                            'coords': [0, y_dim, i, end_i],  # [y_start, y_end, x_start, x_end]
+                            'processed': False,
+                            'z': z
                         }
         
         self.realtimechunks = chunk_dict
@@ -890,24 +992,16 @@ class InteractiveSegmenter:
 
 
     def segment_volume_realtime(self, gpu=True):
-        """Segment volume in realtime using CuPy for GPU acceleration"""
+        """Updated realtime segmentation - no more feature map caching needed"""
         import cupy as cp
         
-        #try:
-            #from cuml.ensemble import RandomForestClassifier as cuRandomForestClassifier
-            #gpu_ml_available = True
-        #except:
-            #print("Cannot find cuML, using CPU to segment instead...")
-            #gpu_ml_available = False
-            #gpu = False
-
         if self.realtimechunks is None:
             if not self.use_two:
                 self.get_realtime_chunks()
             else:
                 self.get_realtime_chunks_2d()
         else:
-            for chunk_pos in self.realtimechunks:  # chunk_pos is the (z, y_start, x_start) tuple
+            for chunk_pos in self.realtimechunks:
                 self.realtimechunks[chunk_pos]['processed'] = False
 
         chunk_dict = self.realtimechunks
@@ -923,7 +1017,6 @@ class InteractiveSegmenter:
                               if pos[0] == curr_z and not info['processed']]
             
             if current_z_chunks:
-                # Find nearest chunk in current Z plane using the chunk positions from the key
                 nearest = min(current_z_chunks, 
                             key=lambda x: ((x[0][1] - curr_y) ** 2 + 
                                          (x[0][2] - curr_x) ** 2))
@@ -938,7 +1031,6 @@ class InteractiveSegmenter:
             
             if available_z:
                 target_z = available_z[0][0]
-                # Find nearest chunk in target Z plane
                 z_chunks = [(pos, info) for pos, info in chunk_dict.items() 
                            if pos[0] == target_z and not info['processed']]
                 nearest = min(z_chunks, 
@@ -949,31 +1041,24 @@ class InteractiveSegmenter:
             return None
         
         while True:
-            # Find nearest unprocessed chunk using class attributes
             chunk_idx = get_nearest_unprocessed_chunk(self)
             if chunk_idx is None:
                 break
                 
-            # Process the chunk directly
             chunk = chunk_dict[chunk_idx]
             chunk['processed'] = True
-            coords = chunk['coords']
+            coords = chunk['coords']  # [y_start, y_end, x_start, x_end]
+            z = chunk['z']
 
-            # Use CuPy for meshgrid
-            coords_array = cp.stack(cp.meshgrid(
-                cp.array([chunk['z']]),
-                cp.arange(coords[0], coords[1]),
-                cp.arange(coords[2], coords[3]),
-                indexing='ij'
-            )).reshape(3, -1).T
-
-            # Convert to CPU for further processing - add cp.asnumpy() here
-            coords = list(map(tuple, cp.asnumpy(coords_array)))
+            # Generate coordinates for this chunk
+            coords_array = self.twodim_coords(z, coords[0], coords[1], coords[2], coords[3])
+            
+            # Convert to CPU for processing
+            coords_list = list(map(tuple, cp.asnumpy(coords_array)))
             
-            # Process the chunk directly based on whether GPU is available
-            fore, back = self.process_chunk(coords)
+            # Process the chunk - now computes features only for this chunk
+            fore, back = self.process_chunk_updated(coords_list)
             
-            # Yield the results
             yield cp.asnumpy(fore), cp.asnumpy(back)
 
 
@@ -1028,42 +1113,73 @@ class InteractiveSegmenter:
             self.use_two = False
 
         if use_two:
-            if not self.use_two: #Clarifies if we need to redo feature cache for 2D
+            if not self.use_two:
                 self.use_two = True
             self.two_slices = []
             foreground_array = cp.asarray(foreground_array)
             
             # Get foreground coordinates and features
             z_fore, y_fore, x_fore = cp.where(foreground_array == 1)
-            # Keep as CuPy arrays but convert to regular Python types for dictionary keys
             fore_coords = [(int(z), int(y), int(x)) for z, y, x in zip(z_fore, y_fore, x_fore)]
             
             # Get background coordinates and features
             z_back, y_back, x_back = cp.where(foreground_array == 2)
-            # Keep as CuPy arrays but convert to regular Python types for dictionary keys
             back_coords = [(int(z), int(y), int(x)) for z, y, x in zip(z_back, y_back, x_back)]
             
             foreground_features = []
             background_features = []
+            
+            # Organize coordinates by Z
             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 z in slices:
-                current_map = self.get_feature_map_slice(z, speed, use_gpu)
-                if z in z_fores:
-                    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(cp.asnumpy(feature_vector))
-                if z in z_backs:
-                    for y, x in z_backs[z]:
-                        # Get the feature vector for this background point
-                        feature_vector = current_map[y, x]
-                        # Add to our collection
-                        background_features.append(cp.asnumpy(feature_vector))
-
+            
+            # Combine all Z-slices that have coordinates
+            all_z_coords = {}
+            for z in z_fores:
+                if z not in all_z_coords:
+                    all_z_coords[z] = []
+                all_z_coords[z].extend(z_fores[z])
+            for z in z_backs:
+                if z not in all_z_coords:
+                    all_z_coords[z] = []
+                all_z_coords[z].extend(z_backs[z])
+            
+            # Get minimal chunks needed to cover all coordinates
+            needed_chunks = self.get_minimal_chunks_for_coordinates(all_z_coords)
+            
+            # Process each chunk and extract features
+            for z in needed_chunks:
+                for chunk_coords in needed_chunks[z]:
+                    # Compute features for this chunk
+                    feature_map, (y_offset, x_offset) = self.compute_features_for_chunk_2d(chunk_coords, speed)
+                    
+                    # Extract foreground features from this chunk
+                    if z in z_fores:
+                        for y, x in z_fores[z]:
+                            # Check if this coordinate is in the current chunk
+                            y_start, y_end = chunk_coords[1], chunk_coords[2]
+                            x_start, x_end = chunk_coords[3], chunk_coords[4]
+                            
+                            if y_start <= y < y_end and x_start <= x < x_end:
+                                # Convert global coordinates to local chunk coordinates
+                                local_y = y - y_offset
+                                local_x = x - x_offset
+                                feature_vector = feature_map[local_y, local_x]
+                                foreground_features.append(cp.asnumpy(feature_vector))
+                    
+                    # Extract background features from this chunk
+                    if z in z_backs:
+                        for y, x in z_backs[z]:
+                            # Check if this coordinate is in the current chunk
+                            y_start, y_end = chunk_coords[1], chunk_coords[2]
+                            x_start, x_end = chunk_coords[3], chunk_coords[4]
+                            
+                            if y_start <= y < y_end and x_start <= x < x_end:
+                                # Convert global coordinates to local chunk coordinates
+                                local_y = y - y_offset
+                                local_x = x - x_offset
+                                feature_vector = feature_map[local_y, local_x]
+                                background_features.append(cp.asnumpy(feature_vector))
         else:
         
             box_size = self.master_chunk

{nettracer3d-0.8.8.dist-info → nettracer3d-0.9.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.8.8
+Version: 0.9.0
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
@@ -110,6 +110,16 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.8.8 Updates -- 
-
-	* See Documentation Once Updated
+-- Version 0.9.0 Updates --
+	* Note that this includes updates for 0.8.3 - 0.9.0
+	* Bug Fixes
+	* Updated network histogram statistics menu, and moved degree distribution here
+	* Added gray watershed
+	* Updated binary watershed
+	* Improved branch labelling method
+	* Updated branch removal in skeletonization method to no longer trim branches that do not reach their node.
+	* Added default branchpoint and branch-adjacency calculation options.
+	* Improved speed of painting and panning.
+	* Enabled the nearest neighbor method to handle non-centroid objects, for the first neighbor at least. And updated it to actually predict theoretical clustering when coloring the heatmap.
+	* Improved segmenter.
+	* Added centroids UMAP method.

nettracer3d-0.9.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nettracer3d/cellpose_manager.py,sha256=NfRqW6Zl7yRU4qHCS_KjmR0R6QANSSgCO0_dr-eivxg,6694
+nettracer3d/community_extractor.py,sha256=QG2v2y9lKb07LRU0zXCAlA_z-96BNqLHh5xP17KLmYA,28147
+nettracer3d/excelotron.py,sha256=X9v_mte8gJBPNGdj6NJNUYja0Z6eorVoKAFx4nHiMnU,72058
+nettracer3d/modularity.py,sha256=pborVcDBvICB2-g8lNoSVZbIReIBlfeBmjFbPYmtq7Y,22443
+nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
+nettracer3d/neighborhoods.py,sha256=qOmN8gDZM-J5zsFFaQ772obj6PzsiISXzVZgnlmGGS8,41349
+nettracer3d/nettracer.py,sha256=cuHc0djb6auNgZ6c38kow9N4zTN7ve00gGBnBSUgEAc,263183
+nettracer3d/nettracer_gui.py,sha256=_JcvHLqb68TooYWu8yFkDLWSJ8wMc6IZ7VFMBzmwenE,568388
+nettracer3d/network_analysis.py,sha256=kBzsVaq4dZkMe0k-VGvQIUvM-tK0ZZ8bvb-wtsugZRQ,46150
+nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
+nettracer3d/node_draw.py,sha256=kZcR1PekLg0riioNeGcALIXQyZ5PtHA_9MT6z7Zovdk,10401
+nettracer3d/painting.py,sha256=K_dwngivw80r-Yyg4btKMsWGn566ZE9PnrQl986uxJE,23497
+nettracer3d/proximity.py,sha256=ZCfthYpQbDBwXBcVioxyzgO9PZACu6mQ8pSXdldP1TM,38592
+nettracer3d/run.py,sha256=xYeaAc8FCx8MuzTGyL3NR3mK7WZzffAYAH23bNRZYO4,127
+nettracer3d/segmenter.py,sha256=_ZBLe2eqV9c5yxuyfN69XR5mBoc_OD-CZjwdTCUV0YQ,67045
+nettracer3d/segmenter_GPU.py,sha256=SGOsy8tSRlxAnD1OrJmjhiQ3k6CWiUFZZdrN6pkkgeU,69057
+nettracer3d/simple_network.py,sha256=dkG4jpc4zzdeuoaQobgGfL3PNo6N8dGKQ5hEEubFIvA,9947
+nettracer3d/smart_dilate.py,sha256=TvRUh6B4q4zIdCO1BWH-xgTdND5OUNmo99eyxG9oIAU,27145
+nettracer3d-0.9.0.dist-info/licenses/LICENSE,sha256=jnNT-yBeIAKAHpYthPvLeqCzJ6nSurgnKmloVnfsjCI,764
+nettracer3d-0.9.0.dist-info/METADATA,sha256=ZmAGzdynu4-irBp2Duk0AsBo7y5U4TDG9cPJHRsOYno,7684
+nettracer3d-0.9.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-0.9.0.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.9.0.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.9.0.dist-info/RECORD,,