nettracer3d 0.6.8__py3-none-any.whl → 0.7.0__py3-none-any.whl

nettracer3d/proximity.py

@@ -7,6 +7,7 @@ from scipy import ndimage
 import concurrent.futures
 import multiprocessing as mp
 import pandas as pd
+import matplotlib.pyplot as plt
 from typing import Dict, Union, Tuple, List, Optional
 
 
@@ -178,9 +179,31 @@ def populate_array(centroids):
         
     return array
 
-def find_neighbors_kdtree(array, radius, targets=None):
+def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None):
     # Get coordinates of nonzero points
-    points = np.transpose(np.nonzero(array))
+    if centroids:
+        # If centroids is a dictionary mapping node IDs to coordinates
+        if isinstance(centroids, dict):
+            # Extract the node IDs and points
+            node_ids = list(centroids.keys())
+            points_list = list(centroids.values())
+            points = np.array(points_list, dtype=np.int32)
+        else:
+            # If centroids is just a list of points
+            points = np.array(centroids, dtype=np.int32)
+            node_ids = list(range(1, len(points) + 1))  # Default sequential IDs
+        
+        # Create a temporary array only if we need it for lookups
+        if array is None:
+            max_coords = np.max(points, axis=0) + 1
+            array = np.zeros(tuple(max_coords), dtype=np.int32)
+            for i, point in enumerate(points):
+                array[tuple(point)] = node_ids[i]  # Use the actual node ID
+    elif array is not None:
+        points = np.transpose(np.nonzero(array))
+        node_ids = None  # Not used in array-based mode
+    else:
+        return []
     
     # Create KD-tree from all nonzero points
     tree = KDTree(points)
@@ -188,19 +211,29 @@ def find_neighbors_kdtree(array, radius, targets=None):
     if targets is None:
         # Original behavior: find neighbors for all points
         query_points = points
-        query_indices = range(len(points))  # Add this line
+        query_indices = range(len(points))
     else:
         # Find coordinates of target values
         target_points = []
-        target_indices = []  # Add this line
-        for idx, point in enumerate(points):
-            if array[tuple(point)] in targets:
-                target_points.append(point)
-                target_indices.append(idx)  # Add this line
+        target_indices = []
+        
+        if array is not None:
+            # Standard array-based filtering
+            for idx, point in enumerate(points):
+                point_tuple = tuple(point)
+                if array[point_tuple] in targets:
+                    target_points.append(point)
+                    target_indices.append(idx)
+        else:
+            # Filter based on node IDs directly
+            for idx, node_id in enumerate(node_ids):
+                if node_id in targets:
+                    target_points.append(points[idx])
+                    target_indices.append(idx)
         
         # Convert to numpy array for querying
         query_points = np.array(target_points)
-        query_indices = target_indices  # Add this line
+        query_indices = target_indices
         
         # Handle case where no target values were found
         if len(query_points) == 0:
@@ -214,17 +247,21 @@ def find_neighbors_kdtree(array, radius, targets=None):
     
     # Generate pairs
     for i, neighbors in enumerate(neighbor_indices):
-        query_idx = query_indices[i]  # Modified this line
+        query_idx = query_indices[i]
         for neighbor_idx in neighbors:
             # Skip self-pairing
             if neighbor_idx != query_idx:
-                query_value = array[tuple(points[query_idx])]
-                neighbor_value = array[tuple(points[neighbor_idx])]
+                # Use node IDs from the dictionary if available
+                if array is not None:
+                    query_value = array[tuple(points[query_idx])]
+                    neighbor_value = array[tuple(points[neighbor_idx])]
+                else:
+                    query_value = node_ids[query_idx]
+                    neighbor_value = node_ids[neighbor_idx]
                 output.append([query_value, neighbor_value, 0])
     
     return output
 
-
 def extract_pairwise_connections(connections):
     output = []
 
@@ -252,7 +289,6 @@ def create_voronoi_3d_kdtree(centroids: Dict[Union[int, str], Union[Tuple[int, i
     Returns:
         3D numpy array where each cell contains the label of the closest centroid as uint32
     """
-    from scipy.spatial import cKDTree
     
     # Convert string labels to integers if necessary
     if any(isinstance(k, str) for k in centroids.keys()):
@@ -269,7 +305,7 @@ def create_voronoi_3d_kdtree(centroids: Dict[Union[int, str], Union[Tuple[int, i
         shape = tuple(max_coord + 1 for max_coord in max_coords)
     
     # Create KD-tree
-    tree = cKDTree(centroid_points)
+    tree = KDTree(centroid_points)
     
     # Create coordinate arrays
     coords = np.array(np.meshgrid(
@@ -286,4 +322,328 @@ def create_voronoi_3d_kdtree(centroids: Dict[Union[int, str], Union[Tuple[int, i
     label_array = labels[indices].astype(np.uint32)
     
     # Reshape to final shape
-    return label_array.reshape(shape)
+    return label_array.reshape(shape)
+
+
+
+#Ripley cluster analysis:
+
+def convert_centroids_to_array(centroids_list, xy_scale = 1, z_scale = 1):
+    """
+    Convert a dictionary of centroids to a numpy array suitable for Ripley's K calculation.
+    
+    Parameters:
+    centroids_list: List of centroid coordinate arrays
+    
+    Returns:
+    numpy array of shape (n, d) where n is number of points and d is dimensionality
+    """
+    # Determine how many centroids we have
+    n_points = len(centroids_list)
+    
+    # Get dimensionality from the first centroid
+    dim = len(list(centroids_list)[0])
+    
+    # Create empty array
+    points_array = np.zeros((n_points, dim))
+    
+    # Fill array with coordinates
+    for i, coords in enumerate(centroids_list):
+        points_array[i] = coords
+
+    points_array[:, 1:] = points_array[:, 1:] * xy_scale #account for scaling
+
+    points_array[:, 0] = points_array[:, 0] * z_scale #account for scaling
+        
+    return points_array
+
+def generate_r_values(points_array, step_size, bounds = None, dim = 2, max_proportion=0.5):
+    """
+    Generate an array of r values based on point distribution and step size.
+    
+    Parameters:
+    points_array: numpy array of shape (n, d) with point coordinates
+    step_size: user-defined step size for r values
+    max_proportion: maximum proportion of the study area extent to use (default 0.5)
+                   This prevents analyzing at distances where edge effects dominate
+    
+    Returns:
+    numpy array of r values
+    """
+
+    if bounds is None:
+        if dim == 2:
+            min_coords = np.array([0,0])
+        else:
+            min_coords = np.array([0,0,0])
+        max_coords = np.max(points_array, axis=0)
+        max_coords = np.flip(max_coords)
+    else:
+        min_coords, max_coords = bounds
+
+    
+    # Calculate the longest dimension
+    dimensions = max_coords - min_coords
+    max_dimension = np.max(dimensions)
+    
+    # Calculate maximum r value (typically half the shortest side for 2D,
+    # or scaled by max_proportion for general use)
+    max_r = max_dimension * max_proportion
+    
+    # Generate r values from 0 to max_r with step_size increments
+    num_steps = int(max_r / step_size)
+    r_values = np.linspace(step_size, max_r, num_steps)
+
+    if r_values[0] == 0:
+        np.delete(r_values, 0)
+    
+    return r_values
+
+def convert_augmented_array_to_points(augmented_array):
+    """
+    Convert an array where first column is 1 and remaining columns are coordinates.
+    
+    Parameters:
+    augmented_array: 2D array where first column is 1 and rest are coordinates
+    
+    Returns:
+    numpy array with just the coordinate columns
+    """
+    # Extract just the coordinate columns (all except first column)
+    return augmented_array[:, 1:]
+
+def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None, edge_correction=True, dim = 2, is_subset = False):
+    """
+    Optimized computation of Ripley's K function using KD-Tree with simplified but effective edge correction.
+    
+    Parameters:
+    reference_points: numpy array of shape (n, d) containing coordinates (d=2 or d=3)
+    subset_points: numpy array of shape (m, d) containing coordinates
+    r_values: numpy array of distances at which to compute K
+    bounds: tuple of (min_coords, max_coords) defining the study area boundaries
+    edge_correction: Boolean indicating whether to apply edge correction
+    
+    Returns:
+    K_values: numpy array of K values corresponding to r_values
+    """
+    n_ref = len(reference_points)
+    n_subset = len(subset_points)
+    
+    # Determine bounds if not provided
+    if bounds is None:
+        min_coords = np.min(reference_points, axis=0)
+        max_coords = np.max(reference_points, axis=0)
+        bounds = (min_coords, max_coords)
+    
+    # Calculate volume of study area
+    min_bounds, max_bounds = bounds
+    sides = max_bounds - min_bounds
+    volume = np.prod(sides)
+    
+    # Point intensity (points per unit volume)
+    intensity = n_ref / volume
+    
+    # Build KD-Tree for efficient nearest neighbor search
+    tree = KDTree(reference_points)
+    
+    # Initialize K values
+    K_values = np.zeros(len(r_values))
+    
+    # For each r value, compute cumulative counts
+    for i, r in enumerate(r_values):
+        total_count = 0
+        
+        # Query the tree for all points within radius r of each subset point
+        for j, point in enumerate(subset_points):
+            # Find all reference points within radius r
+            indices = tree.query_ball_point(point, r)
+            count = len(indices)
+            
+            # Apply edge correction if needed
+            if edge_correction:
+                # Calculate edge correction weight
+                weight = 1.0
+                
+                if dim == 2:
+                    # For 2D - check all four boundaries
+                    x, y = point
+                    
+                    # Distances to all boundaries
+                    x_min_dist = x - min_bounds[0]
+                    x_max_dist = max_bounds[0] - x
+                    y_min_dist = y - min_bounds[1]
+                    y_max_dist = max_bounds[1] - y
+                    
+                    proportion_in = 1.0
+                    # Apply correction for each boundary if needed
+                    if x_min_dist < r:
+                        proportion_in -= 0.5 * (1 - x_min_dist/r)
+                    if x_max_dist < r:
+                        proportion_in -= 0.5 * (1 - x_max_dist/r)
+                    if y_min_dist < r:
+                        proportion_in -= 0.5 * (1 - y_min_dist/r)
+                    if y_max_dist < r:
+                        proportion_in -= 0.5 * (1 - y_max_dist/r)
+                    
+                    # Corner correction
+                    if ((x_min_dist < r and y_min_dist < r) or 
+                        (x_min_dist < r and y_max_dist < r) or
+                        (x_max_dist < r and y_min_dist < r) or
+                        (x_max_dist < r and y_max_dist < r)):
+                        proportion_in += 0.1  # Add a small boost for corners
+                    
+                elif dim == 3:
+                    # For 3D - check all six boundaries
+                    x, y, z = point
+                    
+                    # Distances to all boundaries
+                    x_min_dist = x - min_bounds[0]
+                    x_max_dist = max_bounds[0] - x
+                    y_min_dist = y - min_bounds[1]
+                    y_max_dist = max_bounds[1] - y
+                    z_min_dist = z - min_bounds[2]
+                    z_max_dist = max_bounds[2] - z
+                    
+                    proportion_in = 1.0
+                    # Apply correction for each boundary if needed
+                    if x_min_dist < r:
+                        proportion_in -= 0.25 * (1 - x_min_dist/r)
+                    if x_max_dist < r:
+                        proportion_in -= 0.25 * (1 - x_max_dist/r)
+                    if y_min_dist < r:
+                        proportion_in -= 0.25 * (1 - y_min_dist/r)
+                    if y_max_dist < r:
+                        proportion_in -= 0.25 * (1 - y_max_dist/r)
+                    if z_min_dist < r:
+                        proportion_in -= 0.25 * (1 - z_min_dist/r)
+                    if z_max_dist < r:
+                        proportion_in -= 0.25 * (1 - z_max_dist/r)
+                    
+                    # Corner correction for 3D (if point is near a corner)
+                    num_close_edges = (
+                        (x_min_dist < r) + (x_max_dist < r) +
+                        (y_min_dist < r) + (y_max_dist < r) +
+                        (z_min_dist < r) + (z_max_dist < r)
+                    )
+                    if num_close_edges >= 2:
+                        proportion_in += 0.05 * num_close_edges  # Stronger boost for more edges
+                
+                # Ensure proportion_in stays within reasonable bounds
+                proportion_in = max(0.1, min(1.0, proportion_in))
+                weight = 1.0 / proportion_in
+                
+                count *= weight
+            
+            total_count += count
+        
+        # Subtract self-counts if points appear in both sets
+        if is_subset or np.array_equal(reference_points, subset_points):
+            total_count -= n_ref  # Subtract all self-counts
+        
+        # Normalize
+        K_values[i] = total_count / (n_subset * intensity)
+    
+    return K_values
+
+def ripleys_h_function_3d(k_values, r_values):
+    """
+    Convert K values to H values for 3D point patterns with edge correction.
+    
+    Parameters:
+    k_values: numpy array of K function values
+    r_values: numpy array of distances at which K was computed
+    edge_weights: optional array of edge correction weights
+    
+    Returns:
+    h_values: numpy array of H function values
+    """
+    h_values = np.cbrt(k_values / (4/3 * np.pi)) - r_values
+    
+    return h_values
+
+def ripleys_h_function_2d(k_values, r_values):
+    """
+    Convert K values to H values for 2D point patterns with edge correction.
+    
+    Parameters:
+    k_values: numpy array of K function values
+    r_values: numpy array of distances at which K was computed
+    edge_weights: optional array of edge correction weights
+    
+    Returns:
+    h_values: numpy array of H function values
+    """
+    h_values = np.sqrt(k_values / np.pi) - r_values
+    
+    return h_values
+
+def compute_ripleys_h(k_values, r_values, dimension=2):
+    """
+    Compute Ripley's H function (normalized K) with edge correction.
+    
+    Parameters:
+    k_values: numpy array of K function values
+    r_values: numpy array of distances at which K was computed
+    edge_weights: optional array of edge correction weights
+    dimension: dimensionality of the point pattern (2 for 2D, 3 for 3D)
+    
+    Returns:
+    h_values: numpy array of H function values
+    """
+    if dimension == 2:
+        return ripleys_h_function_2d(k_values, r_values)
+    elif dimension == 3:
+        return ripleys_h_function_3d(k_values, r_values)
+    else:
+        raise ValueError("Dimension must be 2 or 3")
+
+def plot_ripley_functions(r_values, k_values, h_values, dimension=2, figsize=(12, 5)):
+    """
+    Plot Ripley's K and H functions with theoretical Poisson distribution references
+    adjusted for edge effects.
+    
+    Parameters:
+    r_values: numpy array of distances at which K and H were computed
+    k_values: numpy array of K function values
+    h_values: numpy array of H function values (normalized K)
+    edge_weights: optional array of edge correction weights
+    dimension: dimensionality of the point pattern (2 for 2D, 3 for 3D)
+    figsize: tuple specifying figure size (width, height)
+    """
+
+    #plt.figure()
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=figsize)
+    
+    # Theoretical values for complete spatial randomness (CSR)
+    if dimension == 2:
+        theo_k = np.pi * r_values**2  # πr² for 2D
+    elif dimension == 3:
+        theo_k = (4/3) * np.pi * r_values**3  # (4/3)πr³ for 3D
+    else:
+        raise ValueError("Dimension must be 2 or 3")
+    
+    # Theoretical H values are always 0 for CSR
+    theo_h = np.zeros_like(r_values)
+    
+    # Plot K function
+    ax1.plot(r_values, k_values, 'b-', label='Observed K(r)')
+    ax1.plot(r_values, theo_k, 'r--', label='Theoretical K(r) for CSR')
+    ax1.set_xlabel('Distance (r)')
+    ax1.set_ylabel('L(r)')
+    ax1.set_title("Ripley's K Function")
+    ax1.legend()
+    ax1.grid(True, alpha=0.3)
+    
+    # Plot H function
+    ax2.plot(r_values, h_values, 'b-', label='Observed H(r)')
+    ax2.plot(r_values, theo_h, 'r--', label='Theoretical H(r) for CSR')
+    ax2.set_xlabel('Distance (r)')
+    ax2.set_ylabel('L(r) Normalized')
+    ax2.set_title("Ripley's H Function")
+    ax2.axhline(y=0, color='k', linestyle='-', alpha=0.3)
+    ax2.legend()
+    ax2.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    plt.show()
+    #plt.clf()

nettracer3d/segmenter.py

@@ -75,6 +75,12 @@ class InteractiveSegmenter:
         self.dogs = [(1, 2), (2, 4), (4, 8)]
         self.master_chunk = 49
 
+        #Data when loading prev model:
+        self.previous_foreground = None
+        self.previous_background = None
+        self.previous_z_fore = None
+        self.previous_z_back = None
+
     def segment_slice_chunked(self, slice_z, block_size = 49):
         """
         A completely standalone method to segment a single z-slice in chunks
@@ -1011,7 +1017,7 @@ class InteractiveSegmenter:
                 futures.append(future)
             
             def compute_dog_local(img, s1, s2):
-                g1 = ndimage.gaussian_filter(img, s1)
+                g1 = ndimage.gaussian_filter(img, s1) # Consider just having this return the gaussians to
                 g2 = ndimage.gaussian_filter(img, s2)
                 return g1 - g2
 
@@ -1757,10 +1763,11 @@ class InteractiveSegmenter:
             except:
                 pass
 
-    def train_batch(self, foreground_array, speed = True, use_gpu = False, use_two = False, mem_lock = False):
+    def train_batch(self, foreground_array, speed = True, use_gpu = False, use_two = False, mem_lock = False, saving = False):
         """Train directly on foreground and background arrays"""
 
-        print("Training model...")
+        if not saving:
+            print("Training model...")
         self.speed = speed
         self.cur_gpu = use_gpu
         if mem_lock != self.mem_lock:
@@ -1969,12 +1976,40 @@ class InteractiveSegmenter:
                 z_back, y_back, x_back = np.where(foreground_array == 2)
                 background_features = self.feature_cache[z_back, y_back, x_back]
             except:
-                print("Features maps computed, but no segmentation examples were provided so the model was not trained")
+                pass
+
+
+        if self.previous_foreground is not None:
+            failed = True
+            try:
+                foreground_features = np.vstack([self.previous_foreground, foreground_features])
+                failed = False
+            except:
+                pass
+            try:
+                background_features = np.vstack([self.previous_background, background_features])
+                failed = False
+            except:
+                pass
+            try:
+                z_fore = np.concatenate([self.previous_z_fore, z_fore])
+            except:
+                pass
+            try:
+                z_back = np.concatenate([self.previous_z_back, z_back])
+            except:
+                pass
+            if failed:
+                print("Could not combine new model with old loaded model. Perhaps you are trying to combine a quick model with a deep model? I cannot combine these...")
+
+        if saving:
 
+            return foreground_features, background_features, z_fore, z_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
         try:
@@ -1988,6 +2023,54 @@ class InteractiveSegmenter:
 
 
 
+        print("Done")
+
+
+    def save_model(self, file_name, foreground_array):
+
+        print("Saving model data")
+
+        foreground_features, background_features, z_fore, z_back = self.train_batch(foreground_array, speed = self.speed, use_gpu = self.use_gpu, use_two = self.use_two, mem_lock = self.mem_lock, saving = True)
+
+
+        np.savez(file_name, 
+                 foreground_features=foreground_features,
+                 background_features=background_features,
+                 z_fore=z_fore,
+                 z_back=z_back,
+                 speed=self.speed,
+                 use_gpu=self.use_gpu,
+                 use_two=self.use_two,
+                 mem_lock=self.mem_lock)
+
+        print(f"Model data saved to {file_name}")
+
+
+    def load_model(self, file_name):
+
+        print("Loading model data")
+
+        data = np.load(file_name)
+
+        # Unpack the arrays
+        self.previous_foreground = data['foreground_features']
+        self.previous_background = data['background_features']
+        self.previous_z_fore = data['z_fore']
+        self.previous_z_back = data['z_back']
+        self.speed = bool(data['speed'])
+        self.use_gpu = bool(data['use_gpu'])
+        self.use_two = bool(data['use_two'])
+        self.mem_lock = bool(data['mem_lock'])
+
+        X = np.vstack([self.previous_foreground, self.previous_background])
+        y = np.hstack([np.ones(len(self.previous_z_fore)), np.zeros(len(self.previous_z_back))])
+
+        try:
+            self.model.fit(X, y)
+        except:
+            print(X)
+            print(y)
+
         print("Done")
 
     def get_feature_map_slice(self, z, speed, use_gpu):