nettracer3d 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

nettracer3d/proximity.py

@@ -88,7 +88,7 @@ def process_label(args):
     print(f"Processing node {label}")
     
     # Get the pre-computed bounding box for this label
-    slice_obj = bounding_boxes[label-1]  # -1 because label numbers start at 1
+    slice_obj = bounding_boxes[int(label)-1]  # -1 because label numbers start at 1
     if slice_obj is None:
         return None, None
         
@@ -113,7 +113,7 @@ def create_node_dictionary(nodes, num_nodes, dilate_xy, dilate_z, targets=None,
     with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
         # Create args list with bounding_boxes included
         args_list = [(nodes, i, dilate_xy, dilate_z, array_shape, bounding_boxes) 
-                    for i in range(1, num_nodes + 1)]
+                    for i in range(1, int(num_nodes) + 1)]
 
         if targets is not None:
             args_list = [tup for tup in args_list if tup[1] in targets]
@@ -144,7 +144,7 @@ def find_shared_value_pairs(input_dict):
 
 #Related to kdtree centroid searching:
 
-def populate_array(centroids, clip=False):
+def populate_array(centroids, clip=False, shape = None):
     """
     Create a 3D array from centroid coordinates.
     
@@ -164,12 +164,16 @@ def populate_array(centroids, clip=False):
     coords = np.array(list(centroids.values()))
     # Round coordinates to nearest integer
     coords = np.round(coords).astype(int)
-    min_coords = coords.min(axis=0)
-    max_coords = coords.max(axis=0)
+    if shape is None:
+        min_coords = coords.min(axis=0)
+        max_coords = coords.max(axis=0)
+    else:
+        min_coords = [0, 0, 0]
+        max_coords = shape
     
     # Check for negative coordinates only if not clipping
-    if not clip and np.any(min_coords < 0):
-        raise ValueError("Negative coordinates found in centroids")
+    #if not clip and np.any(min_coords < 0):
+        #raise ValueError("Negative coordinates found in centroids")
     
     # Apply clipping if requested
     clipped_centroids = {}
@@ -183,10 +187,15 @@ def populate_array(centroids, clip=False):
         for i, obj_id in enumerate(centroids.keys()):
             clipped_centroids[obj_id] = coords[i].tolist()
     
-    # Create array
-    array = np.zeros((max_coords[0] + 1, 
-                     max_coords[1] + 1, 
-                     max_coords[2] + 1), dtype=int)
+    if shape is None:
+        # Create array
+        array = np.zeros((max_coords[0] + 1, 
+                         max_coords[1] + 1, 
+                         max_coords[2] + 1), dtype=int)
+    else:
+        array = np.zeros((max_coords[0], 
+                         max_coords[1], 
+                         max_coords[2]), dtype=int)
     
     # Populate array with (possibly clipped) rounded coordinates
     for i, (obj_id, coord) in enumerate(centroids.items()):
@@ -194,7 +203,10 @@ def populate_array(centroids, clip=False):
             z, y, x = coords[i]  # Use pre-computed clipped coordinates
         else:
             z, y, x = np.round([coord[0], coord[1], coord[2]]).astype(int)
-        array[z, y, x] = obj_id
+        try:
+            array[z, y, x] = obj_id
+        except:
+            pass
         
     if clip:
         return array, clipped_centroids
@@ -328,7 +340,7 @@ def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, n_jo
     
     if targets is None:
         # Original behavior: find neighbors for all points
-        query_points = points
+        query_points = np.array(points)
         query_indices = list(range(len(points)))
     else:
         # Convert targets to set for O(1) lookup
@@ -354,7 +366,6 @@ def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, n_jo
         # Convert to numpy array for querying
         query_points = np.array(target_points)
         query_indices = target_indices
-
         
         # Handle case where no target values were found
         if len(query_points) == 0:
@@ -373,6 +384,7 @@ def find_neighbors_kdtree(radius, centroids=None, array=None, targets=None, n_jo
     
     # Skip parallelization for small datasets or when n_jobs=1
     if n_jobs == 1 or len(neighbor_indices) < 100:
+    #if True:
         # Sequential processing (original logic with max_neighbors support)
         output = []
         for i, neighbors in enumerate(neighbor_indices):
@@ -599,10 +611,10 @@ def convert_centroids_to_array(centroids_list, xy_scale = 1, z_scale = 1):
     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):
+def generate_r_values(points_array, step_size, bounds = None, dim = 2, max_proportion=0.5, max_r = None):
     """
     Generate an array of r values based on point distribution and step size.
     
@@ -634,18 +646,27 @@ def generate_r_values(points_array, step_size, bounds = None, dim = 2, max_propo
         min_coords = np.array([0,0,0])
         dimensions = max_coords - min_coords
 
-    max_dimension = np.max(dimensions)
+    if 1 in dimensions:
+        dimensions = np.delete(dimensions, 0) #Presuming 2D data 
+
+    min_dimension = np.min(dimensions) #Biased for smaller dimension now for safety
     
     # 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
+    if max_r is None:
+        max_r = min_dimension * max_proportion
+        if max_proportion < 1:
+            print(f"Omitting search radii beyond {max_r}")
+    else:
+        print(f"Omitting search radii beyond {max_r} (to keep analysis within the mask)")
+
     
     # 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)
+        r_values = np.delete(r_values, 0)
     
     return r_values
 
@@ -662,7 +683,7 @@ def convert_augmented_array_to_points(augmented_array):
     # 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):
+def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None, dim = 2, is_subset = False, volume = None, n_subset = None):
     """
     Optimized computation of Ripley's K function using KD-Tree with simplified but effective edge correction.
     
@@ -677,7 +698,8 @@ def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None,
     K_values: numpy array of K values corresponding to r_values
     """
     n_ref = len(reference_points)
-    n_subset = len(subset_points)
+    if n_subset is None:
+        n_subset = len(subset_points)
 
     # Determine bounds if not provided
     if bounds is None:
@@ -688,10 +710,12 @@ def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None,
     # Calculate volume of study area
     min_bounds, max_bounds = bounds
     sides = max_bounds - min_bounds
-    if dim == 2:
-        volume = sides[0] * sides[1]
-    else:
-        volume = np.prod(sides)
+
+    if volume is None:
+        if dim == 2:
+            volume = sides[0] * sides[1]
+        else:
+            volume = np.prod(sides)
     
     # Point intensity (points per unit volume)
     intensity = n_ref / volume
@@ -705,94 +729,19 @@ def optimized_ripleys_k(reference_points, subset_points, r_values, bounds=None,
     # 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)