nettracer3d 1.1.1__py3-none-any.whl → 1.2.4__py3-none-any.whl

nettracer3d/network_draw.py

@@ -77,7 +77,12 @@ def draw_line_inplace(start, end, array):
     """
     
     # Calculate the distances between start and end coordinates
-    distances = end - start
+    try:
+        distances = end - start
+    except:
+        end = np.array(end)
+        start = np.array(start)
+        distances = end - start
 
     # Determine the number of steps along the line
     num_steps = int(max(np.abs(distances)) + 1)
@@ -242,7 +247,8 @@ def draw_network_from_centroids(nodes, network, centroids, twod_bool, directory
             centroid_dic[item] = centroid
 
         except KeyError:
-            print(f"Centroid {item} missing")
+            pass
+            #print(f"Centroid {item} missing")
     output_stack = np.zeros(np.shape(nodes), dtype=np.uint8)
 
     for i, pair1_val in enumerate(pair1):
@@ -253,7 +259,7 @@ def draw_network_from_centroids(nodes, network, centroids, twod_bool, directory
             pair2_centroid = centroid_dic[pair2_val]
             draw_line_inplace(pair1_centroid, pair2_centroid, output_stack)
         except KeyError:
-            print(f"Missing centroid {i}")
+            #print(f"Missing centroid {i}")
             pass
 
     if twod_bool:

nettracer3d/node_draw.py

@@ -3,7 +3,7 @@ import tifffile
 from scipy import ndimage
 from PIL import Image, ImageDraw, ImageFont
 from scipy.ndimage import zoom
-
+import cv2
 
 def downsample(data, factor, directory=None, order=0):
     """
@@ -121,83 +121,66 @@ def draw_nodes(nodes, num_nodes):
     # Save the draw_array as a 3D TIFF file
     tifffile.imwrite("labelled_nodes.tif", draw_array)
 
-def draw_from_centroids(nodes, num_nodes, centroids, twod_bool, directory = None):
-    """Presumes a centroid dictionary has been obtained"""
-    print("Drawing node IDs. (Must find all centroids. Network lattice itself may be drawn from network_draw script with fewer centroids)")
-    # Create a new 3D array to draw on with the same dimensions as the original array
+def draw_from_centroids(nodes, num_nodes, centroids, twod_bool, directory=None):
+    """Optimized version using OpenCV"""
+    print("Drawing node IDs...")
     draw_array = np.zeros_like(nodes, dtype=np.uint8)
-
-    # Use the default font from ImageFont
-
-    # Iterate through each centroid
+    
+    # Draw text using OpenCV (no PIL conversions needed)
     for idx in centroids.keys():
         centroid = centroids[idx]
-        z, y, x = centroid.astype(int)
-
-        try:
-            draw_array = _draw_at_plane(z, y, x, draw_array, idx)
-        except IndexError:
-            pass
 
         try:
-            draw_array = _draw_at_plane(z + 1, y, x, draw_array, idx)
-        except IndexError:
-            pass
-
-        try:
-            draw_array = _draw_at_plane(z - 1, y, x, draw_array, idx)
-        except IndexError:
-            pass
-
+            z, y, x = centroid.astype(int)
+        except:
+            z, y, x = centroid
+        
+        for z_offset in [0, 1, -1]:
+            z_target = z + z_offset
+            if 0 <= z_target < draw_array.shape[0]:
+                cv2.putText(draw_array[z_target], str(idx), (x, y), 
+                           cv2.FONT_HERSHEY_SIMPLEX, 0.4, 255, 1, cv2.LINE_AA)
+    
     if twod_bool:
         draw_array = draw_array[0,:,:] | draw_array[1,:,:]
-
-
-    if directory is None:
-        filename = 'labelled_node_indices.tif'
-    else:
-        filename = f'{directory}/labelled_node_indices.tif'
-
+    
+    filename = f'{directory}/labelled_node_indices.tif' if directory else 'labelled_node_indices.tif'
     try:
-
-        # Save the draw_array as a 3D TIFF file
         tifffile.imwrite(filename, draw_array)
-
     except Exception as e:
         print(f"Could not save node indices to {filename}")
-
+    
     return draw_array
 
 def degree_draw(degree_dict, centroid_dict, nodes):
+    """Draw node degrees at centroid locations using OpenCV"""
     # Create a new 3D array to draw on with the same dimensions as the original array
     draw_array = np.zeros_like(nodes, dtype=np.uint8)
-    #font_size = 24
-
+    
     for node in centroid_dict:
-
-        try:
-            degree = degree_dict[node]
-        except:
+        # Skip if node not in degree_dict
+        if node not in degree_dict:
             continue
             
+        degree = degree_dict[node]
         z, y, x = centroid_dict[node].astype(int)
-
-        try:
-            draw_array = _draw_at_plane(z, y, x, draw_array, degree)
-        except IndexError:
-            pass
-
-        try:
-            draw_array = _draw_at_plane(z + 1, y, x, draw_array, degree)
-        except IndexError:
-            pass
-
-        try:
-            draw_array = _draw_at_plane(z - 1, y, x, draw_array, degree)
-        except IndexError:
-            pass
-
-
+        
+        # Draw on current z-plane and adjacent planes
+        for z_offset in [0, 1, -1]:
+            z_target = z + z_offset
+            # Check bounds
+            if 0 <= z_target < draw_array.shape[0]:
+                cv2.putText(
+                    draw_array[z_target],  # Image to draw on
+                    str(degree),            # Text to draw
+                    (x, y),                 # Position (x, y)
+                    cv2.FONT_HERSHEY_SIMPLEX,  # Font
+                    0.4,                    # Font scale
+                    255,                    # Color (white)
+                    1,                      # Thickness
+                    cv2.LINE_AA             # Anti-aliasing
+                )
+    
     return draw_array
 
 def degree_infect(degree_dict, nodes, make_floats = False):

nettracer3d/proximity.py

@@ -12,6 +12,7 @@ from typing import Dict, Union, Tuple, List, Optional
 from collections import defaultdict
 from multiprocessing import Pool, cpu_count
 import functools
+from . import smart_dilate as sdl
 
 # Related to morphological border searching:
 
@@ -104,7 +105,6 @@ def create_node_dictionary(nodes, num_nodes, dilate_xy, dilate_z, targets=None,
     """pre-compute all bounding boxes using find_objects"""
     node_dict = {}
     array_shape = nodes.shape
-
     
     # Get all bounding boxes at once
     bounding_boxes = ndimage.find_objects(nodes)
@@ -1056,4 +1056,125 @@ def create_dict_entry_id(node_dict, label, sub_nodes, sub_edges):
     if label is None:
         pass
     else:
-        node_dict[label] = _get_node_edge_dict_id(sub_nodes, sub_edges, label)
+        node_dict[label] = _get_node_edge_dict_id(sub_nodes, sub_edges, label)
+
+
+# For the continuous structure labeler:
+
+def get_reslice_space(slice_obj, array_shape):
+    z_slice, y_slice, x_slice = slice_obj
+    
+    # Extract min/max from slices
+    z_min, z_max = z_slice.start, z_slice.stop - 1
+    y_min, y_max = y_slice.start, y_slice.stop - 1
+    x_min, x_max = x_slice.start, x_slice.stop - 1
+    # Add padding
+    y_max = y_max + 1
+    y_min = y_min - 1
+    x_max = x_max + 1
+    x_min = x_min - 1
+    z_max = z_max + 1
+    z_min = z_min - 1
+    # Boundary checks
+    y_max = min(y_max, array_shape[1] - 1)
+    x_max = min(x_max, array_shape[2] - 1)
+    z_max = min(z_max, array_shape[0] - 1)
+    y_min = max(y_min, 0)
+    x_min = max(x_min, 0)
+    z_min = max(z_min, 0)
+    return [z_min, z_max], [y_min, y_max], [x_min, x_max]
+
+def reslice_array(args):
+    """Internal method used for the secondary algorithm to reslice subarrays."""
+    input_array, z_range, y_range, x_range = args
+    z_start, z_end = z_range
+    z_start, z_end = int(z_start), int(z_end)
+    y_start, y_end = y_range
+    y_start, y_end = int(y_start), int(y_end)
+    x_start, x_end = x_range
+    x_start, x_end = int(x_start), int(x_end)
+    
+    # Reslice the array
+    resliced_array = input_array[z_start:z_end + 1, y_start:y_end + 1, x_start:x_end + 1]
+    
+    return resliced_array
+
+def _reassign_label_by_continuous_proximity(sub_to_assign, sub_labels, label):
+    """Internal method used for the secondary algorithm to find pixel involvement of component to be labeled based on nearby labels."""
+    
+    # Create a boolean mask where elements with the specified label are True
+    sub_to_assign = sub_to_assign == label
+    sub_to_assign = nettracer.dilate_3D_old(sub_to_assign, 3, 3, 3) #Dilate the label by 1 to see where the dilated label overlaps
+    sub_to_assign = sub_to_assign != 0
+    sub_labels = sub_labels * sub_to_assign # Isolate only adjacent label
+    sub_to_assign = sdl.smart_label_single(sub_to_assign, sub_labels) # Assign labeling schema from 'sub_to_assign' to 'sub_labels'
+    return sub_to_assign
+
+def process_and_write_voxels(args):
+    """Optimized version using vectorized operations"""
+    to_assign, labels, label, array_shape, bounding_boxes, result_array = 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
+    
+    z_vals, y_vals, x_vals = get_reslice_space(slice_obj, array_shape)
+    z_start, z_end = z_vals
+    y_start, y_end = y_vals
+    x_start, x_end = x_vals
+    
+    # Extract subarrays
+    sub_to_assign = reslice_array((to_assign, z_vals, y_vals, x_vals))
+    sub_labels = reslice_array((labels, z_vals, y_vals, x_vals))
+    
+    # Create mask for this label BEFORE relabeling (critical!)
+    label_mask = (sub_to_assign == label)
+    
+    # Get local coordinates of voxels belonging to this label
+    local_coords = np.where(label_mask)
+    
+    # Do the relabeling on the subarray
+    # Note: relabeled may contain multiple different label values now
+    relabeled = _reassign_label_by_continuous_proximity(sub_to_assign, sub_labels, label)
+
+    # Apply offsets (vectorized)
+    global_coords = (
+        local_coords[0] + z_start,
+        local_coords[1] + y_start,
+        local_coords[2] + x_start
+    )
+    
+    # Single vectorized write operation
+    # This copies all new label values (potentially multiple different labels)
+    # for voxels that originally belonged to 'label'
+    result_array[global_coords] = relabeled[local_coords]
+
+def create_label_map(to_assign, labels, num_labels, array_shape):
+    """Modified to pre-compute all bounding boxes and write voxels in parallel"""
+    
+    # Get all bounding boxes at once
+    bounding_boxes = ndimage.find_objects(to_assign)
+    
+    # Clone to_assign for modifications (original used for reading subarrays)
+    result_array = to_assign.copy()
+    
+    # Use ThreadPoolExecutor for parallel execution
+    with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
+        # Create args list with bounding_boxes and result_array included
+        args_list = [(to_assign, labels, i, array_shape, bounding_boxes, result_array) 
+                    for i in range(1, num_labels + 1)]
+        
+        # Execute parallel tasks - each writes directly to result_array
+        futures = [executor.submit(process_and_write_voxels, args) for args in args_list]
+        
+        # Wait for all to complete
+        for future in futures:
+            future.result()
+    
+    return result_array
+
+def label_continuous(to_assign, labels):
+    array_shape = to_assign.shape
+    num_labels = np.max(to_assign)
+    result = create_label_map(to_assign, labels, num_labels, array_shape)
+    return result

nettracer3d/smart_dilate.py

@@ -495,6 +495,42 @@ def smart_label(binary_array, label_array, directory = None, GPU = True, predown
 
     return dilated_nodes_with_labels
 
+def smart_label_single(binary_array, label_array):
+
+    # Step 1: Binarize the labeled array
+    binary_core = binarize(label_array)
+    binary_array = binarize(binary_array)
+
+    # Step 3: Isolate the ring (binary dilated mask minus original binary mask)
+    ring_mask = binary_array & invert_array(binary_core)
+
+    nearest_label_indices = compute_distance_transform(invert_array(label_array))
+
+    # Step 5: Process the entire array without parallelization
+    dilated_nodes_with_labels = process_chunk(0, label_array.shape[1], label_array, ring_mask, nearest_label_indices)
+
+    dilated_nodes_with_labels = dilated_nodes_with_labels * binary_array
+
+
+    return dilated_nodes_with_labels
+
+def neighbor_label(binary_array, label_array):
+
+    binary_array = binary_array != 0
+
+    targets = binary_array - binarize(label_array)
+
+    label_array = smart_dilate(label_array, 3, 3, GPU = False, fast_dil = False, xy_scale = 1, z_scale = 1)
+
+    return None 
+
+    #TBD: This requires the serial dilation strategy methinks, unfortunately. Get labeled components of all outer regions of the binary array to be labeled. For each, cut out a sub array from the old label array and pad by one in all dimensions. Apply boolean threshold to get just the label we want. Apply binary dilation on the binary subarray of just one and multiply that against the labeled sub array - we have isolated the available labelers. Finally do smart dilate on this sub array region. 
+
+
+
+
+
+
 def compute_distance_transform_GPU(nodes, return_dists = False, sampling = [1, 1, 1]):
     is_pseudo_3d = nodes.shape[0] == 1
     if is_pseudo_3d: