nettracer3d 0.5.2__tar.gz → 0.5.4__tar.gz

{nettracer3d-0.5.2/src/nettracer3d.egg-info → nettracer3d-0.5.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.2
 Name: nettracer3d
-Version: 0.5.2
+Version: 0.5.4
 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
@@ -26,6 +26,7 @@ Requires-Dist: tifffile==2023.7.18
 Requires-Dist: qtrangeslider==0.1.5
 Requires-Dist: PyQt6==6.8.0
 Requires-Dist: scikit-learn==1.6.1
+Requires-Dist: nibabel==5.2.0
 Provides-Extra: cuda11
 Requires-Dist: cupy-cuda11x; extra == "cuda11"
 Provides-Extra: cuda12
@@ -42,3 +43,11 @@ for a video tutorial on using the GUI.
 NetTracer3D is free to use/fork for academic/nonprofit use so long as citation is provided, and is available for commercial use at a fee (see license file for information).
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
+
+-- Version 0.5.4 updates --
+
+1. Added new function to GUI in image -> overlays -> color nodes/edges. Generates a rgb array corresponding to the nodes/edge labels where each node/edge (depending which array is selected) is randomly assigned a unique rgb color in an overlay channel. This can be used, for example, to color code labeled branches for easy identification of which branch is which.
+
+2. Improved highlight overlay general functionality (for selecting nodes/edges). Previously selecting a node/edge had the program attempting to create an equal sized array as an overlay, find all objects corresponding to the selected ones, fill those into the new highlight overlay, then overlay that image. This was understandably quite slow in big arrays where the system was wasting a lot of time searching the entire array every time something was selected. New version retains this functionality for arrays below 125 million voxels, since search time is rather manageable at that size. For larger arrays, it instead draws the highlight for the selected objects only into the current slice, rendering a new slice whenever the user scrolls in the stack (although the entire highlight overlay is still initialized as a placeholder). Functions that require the use of the entire highlight overlay (such as masking) are correspondingly updated to draw the entirety of the highlight overlay before executing (when the system has up until that point been drawing slices one at a time). This will likely be the retained behavior moving forward, although to eliminate this behavior, one can open nettracer_gui.py and set self.mini_thresh to some comically large value. The new highlight overlay seems to work effectively the same but faster in my testing although it is possible a bug slipped through, which I will fix if informed about (or if I find it myself).
+
+3. For the machine learning segmenter, changed the system to attempt to segment the image by chunking the array into the largest possible chunks that can be divided across all CPU cores. Previously the system split the array into 64^3 voxel sized chunks and passed those to the CPU cores until everything was processed. I am not sure which version is more efficient/faster so this is somewhat of a test. In theory the new behavior could be faster because it asking Python to interpret less stuff. 

nettracer3d-0.5.4/README.md

@@ -0,0 +1,17 @@
+NetTracer3D is a python package developed for both 2D and 3D analysis of microscopic images in the .tif file format. It supports generation of 3D networks showing the relationships between objects (or nodes) in three dimensional space, either based on their own proximity or connectivity via connecting objects such as nerves or blood vessels. In addition to these functionalities are several advanced 3D data processing algorithms, such as labeling of branched structures or abstraction of branched structures into networks. Note that nettracer3d uses segmented data, which can be segmented from other softwares such as ImageJ and imported into NetTracer3D, although it does offer its own segmentation via intensity and volumetric thresholding, or random forest machine learning segmentation. NetTracer3D currently has a fully functional GUI. To use the GUI, after installing the nettracer3d package via pip, enter the command 'nettracer3d' in your command prompt:
+
+
+This gui is built from the PyQt6 package and therefore may not function on dockers or virtual envs that are unable to support PyQt6 displays. More advanced documentation is coming down the line, but for now please see: https://www.youtube.com/watch?v=cRatn5VTWDY
+for a video tutorial on using the GUI.
+
+NetTracer3D is free to use/fork for academic/nonprofit use so long as citation is provided, and is available for commercial use at a fee (see license file for information).
+
+NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
+
+-- Version 0.5.4 updates --
+
+1. Added new function to GUI in image -> overlays -> color nodes/edges. Generates a rgb array corresponding to the nodes/edge labels where each node/edge (depending which array is selected) is randomly assigned a unique rgb color in an overlay channel. This can be used, for example, to color code labeled branches for easy identification of which branch is which.
+
+2. Improved highlight overlay general functionality (for selecting nodes/edges). Previously selecting a node/edge had the program attempting to create an equal sized array as an overlay, find all objects corresponding to the selected ones, fill those into the new highlight overlay, then overlay that image. This was understandably quite slow in big arrays where the system was wasting a lot of time searching the entire array every time something was selected. New version retains this functionality for arrays below 125 million voxels, since search time is rather manageable at that size. For larger arrays, it instead draws the highlight for the selected objects only into the current slice, rendering a new slice whenever the user scrolls in the stack (although the entire highlight overlay is still initialized as a placeholder). Functions that require the use of the entire highlight overlay (such as masking) are correspondingly updated to draw the entirety of the highlight overlay before executing (when the system has up until that point been drawing slices one at a time). This will likely be the retained behavior moving forward, although to eliminate this behavior, one can open nettracer_gui.py and set self.mini_thresh to some comically large value. The new highlight overlay seems to work effectively the same but faster in my testing although it is possible a bug slipped through, which I will fix if informed about (or if I find it myself).
+
+3. For the machine learning segmenter, changed the system to attempt to segment the image by chunking the array into the largest possible chunks that can be divided across all CPU cores. Previously the system split the array into 64^3 voxel sized chunks and passed those to the CPU cores until everything was processed. I am not sure which version is more efficient/faster so this is somewhat of a test. In theory the new behavior could be faster because it asking Python to interpret less stuff. 

{nettracer3d-0.5.2 → nettracer3d-0.5.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.5.2"
+version = "0.5.4"
 authors = [
   { name="Liam McLaughlin", email="mclaughlinliam99@gmail.com" },
 ]
@@ -20,7 +20,8 @@ dependencies = [
     "tifffile == 2023.7.18",
     "qtrangeslider == 0.1.5",
     "PyQt6 == 6.8.0",
-    "scikit-learn == 1.6.1"
+    "scikit-learn == 1.6.1",
+    "nibabel == 5.2.0"
 ]
 
 readme = "README.md"

{nettracer3d-0.5.2 → nettracer3d-0.5.4}/src/nettracer3d/community_extractor.py

@@ -9,6 +9,7 @@ from scipy import ndimage
 from scipy.ndimage import zoom
 from networkx.algorithms import community
 from community import community_louvain
+import random
 from . import node_draw
 
 
@@ -781,6 +782,47 @@ def generate_distinct_colors(n_colors: int) -> List[Tuple[int, int, int]]:
         colors.append(rgb)
     return colors
 
+def assign_node_colors(node_list: List[int], labeled_array: np.ndarray) -> Tuple[np.ndarray, Dict[int, str]]:
+    """
+    Assign distinct colors to nodes and create an RGBA image.
+    
+    Args:
+        node_list: List of node IDs
+        labeled_array: 3D numpy array with labels corresponding to node IDs
+    
+    Returns:
+        Tuple of (RGBA-coded numpy array (H, W, D, 4), dictionary mapping nodes to color names)
+    """
+    
+    # Sort communities by size (descending)
+    sorted_nodes= sorted(node_list, reverse=True)
+    
+    # Generate distinct colors
+    colors = generate_distinct_colors(len(node_list))
+    random.shuffle(colors) #Randomly sorted to make adjacent structures likely stand out
+    
+    # Convert RGB colors to RGBA by adding alpha channel
+    colors_rgba = [(r, g, b, 255) for r, g, b in colors]  # Full opacity for colored regions
+    
+    # Create mapping from community to color
+    node_to_color = {node: colors_rgba[i] for i, node in enumerate(sorted_nodes)}
+    
+    # Create RGBA array (initialize with transparent background)
+    rgba_array = np.zeros((*labeled_array.shape, 4), dtype=np.uint8)
+    
+    # Assign colors to each voxel based on its label
+    for label in np.unique(labeled_array):
+        if label in node_to_color:  # Skip background (usually label 0)
+            mask = labeled_array == label
+            for i in range(4):  # RGBA channels
+                rgba_array[mask, i] = node_to_color[label][i]
+
+    # Convert the RGB portion of community_to_color back to RGB for color naming
+    node_to_color_rgb = {k: tuple(v[:3]) for k, v in node_to_color.items()}
+    node_to_color_names = convert_node_colors_to_names(node_to_color_rgb)
+    
+    return rgba_array, node_to_color_names
+
 def assign_community_colors(community_dict: Dict[int, int], labeled_array: np.ndarray) -> Tuple[np.ndarray, Dict[int, str]]:
     """
     Assign distinct colors to communities and create an RGBA image.

{nettracer3d-0.5.2 → nettracer3d-0.5.4}/src/nettracer3d/morphology.py

@@ -7,46 +7,37 @@ from concurrent.futures import ThreadPoolExecutor, as_completed
 import tifffile
 from functools import partial
 import pandas as pd
+from scipy import ndimage
 
-def get_reslice_indices(args):
-    """Internal method used for the secondary algorithm that finds dimensions for subarrays around nodes"""
-
-    indices, dilate_xy, dilate_z, array_shape = args
-    try:
-        max_indices = np.amax(indices, axis = 0) #Get the max/min of each index.
-    except ValueError: #Return Nones if this error is encountered
+def get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape):
+    """Convert slice object to padded indices accounting for dilation and boundaries"""
+    if slice_obj is None:
         return None, None, None
-    min_indices = np.amin(indices, axis = 0)
-
-    z_max, y_max, x_max = max_indices[0], max_indices[1], max_indices[2]
-
-    z_min, y_min, x_min = min_indices[0], min_indices[1], min_indices[2]
-
-    y_max = y_max + ((dilate_xy-1)/2) + 1 #Establish dimensions of intended subarray, expanding the max/min indices to include
-    y_min = y_min - ((dilate_xy-1)/2) - 1 #the future dilation space (by adding/subtracting half the dilation kernel for each axis)
-    x_max = x_max + ((dilate_xy-1)/2) + 1 #an additional index is added in each direction to make sure nothing is discluded.
+        
+    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 dilation padding
+    y_max = y_max + ((dilate_xy-1)/2) + 1
+    y_min = y_min - ((dilate_xy-1)/2) - 1
+    x_max = x_max + ((dilate_xy-1)/2) + 1
     x_min = x_min - ((dilate_xy-1)/2) - 1
     z_max = z_max + ((dilate_z-1)/2) + 1
     z_min = z_min - ((dilate_z-1)/2) - 1
 
-    if y_max > (array_shape[1] - 1): #Some if statements to make sure the subarray will not cause an indexerror
-        y_max = (array_shape[1] - 1)
-    if x_max > (array_shape[2] - 1):
-        x_max = (array_shape[2] - 1)
-    if z_max > (array_shape[0] - 1):
-        z_max = (array_shape[0] - 1)
-    if y_min < 0:
-        y_min = 0
-    if x_min < 0:
-        x_min = 0
-    if z_min < 0:
-        z_min = 0
-
-    y_vals = [y_min, y_max] #Return the subarray dimensions as lists
-    x_vals = [x_min, x_max]
-    z_vals = [z_min, z_max]
-
-    return z_vals, y_vals, x_vals
+    # 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_3d_array(args):
     """Internal method used for the secondary algorithm to reslice subarrays around nodes."""
@@ -97,39 +88,46 @@ def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z, cor
     return args
 
 def process_label(args):
-    """Internal method used for the secondary algorithm to process a particular node."""
-    nodes, edges, label, dilate_xy, dilate_z, array_shape = args
+    """Modified to use pre-computed bounding boxes instead of argwhere"""
+    nodes, edges, label, dilate_xy, dilate_z, array_shape, bounding_boxes = args
     print(f"Processing node {label}")
-    indices = np.argwhere(nodes == label)
-    if len(indices) == 0:
+    
+    # Get the pre-computed bounding box for this label
+    slice_obj = bounding_boxes[label-1]  # -1 because label numbers start at 1
+    if slice_obj is None:
         return None, None, None
-    z_vals, y_vals, x_vals = get_reslice_indices((indices, dilate_xy, dilate_z, array_shape))
-    if z_vals is None: #If get_reslice_indices ran into a ValueError, nothing is returned.
+        
+    z_vals, y_vals, x_vals = get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape)
+    if z_vals is None:
         return None, None, None
+        
     sub_nodes = reslice_3d_array((nodes, z_vals, y_vals, x_vals))
     sub_edges = reslice_3d_array((edges, z_vals, y_vals, x_vals))
     return label, sub_nodes, sub_edges
 
 
-def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores = 0):
-    """Internal method used for the secondary algorithm to process nodes in parallel."""
-    # Initialize the dictionary to be returned
-    node_dict = {}
 
+def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z, cores=0):
+    """Modified to 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)
+    
     # Use ThreadPoolExecutor for parallel execution
     with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
-        # First parallel section to process labels
-        # List of arguments for each parallel task
-        args_list = [(nodes, edges, i, dilate_xy, dilate_z, array_shape) for i in range(1, num_nodes + 1)]
+        # Create args list with bounding_boxes included
+        args_list = [(nodes, edges, i, dilate_xy, dilate_z, array_shape, bounding_boxes) 
+                    for i in range(1, num_nodes + 1)]
 
         # Execute parallel tasks to process labels
         results = executor.map(process_label, args_list)
 
-        # Second parallel section to create dictionary entries
+        # Process results in parallel
         for label, sub_nodes, sub_edges in results:
-            executor.submit(create_dict_entry, node_dict, label, sub_nodes, sub_edges, dilate_xy, dilate_z, cores)
+            executor.submit(create_dict_entry, node_dict, label, sub_nodes, sub_edges, 
+                          dilate_xy, dilate_z, cores)
 
     return node_dict
 
@@ -193,10 +191,10 @@ def quantify_edge_node(nodes, edges, search = 0, xy_scale = 1, z_scale = 1, core
         return edge_quants
 
 
+
 def calculate_voxel_volumes(array, xy_scale=1, z_scale=1):
     """
-    Calculate voxel volumes for each uniquely labelled object in a 3D numpy array
-    using parallel processing.
+    Calculate voxel volumes for each uniquely labelled object in a 3D numpy array.
     
     Args:
         array: 3D numpy array where different objects are marked with different integer labels
@@ -207,69 +205,25 @@ def calculate_voxel_volumes(array, xy_scale=1, z_scale=1):
         Dictionary mapping object labels to their voxel volumes
     """
 
-    def process_volume_chunk(chunk_data, labels, xy_scale, z_scale):
-        """
-        Calculate volumes for a chunk of the array.
-        
-        Args:
-            chunk_data: 3D numpy array chunk
-            labels: Array of unique labels to process
-            xy_scale: Scale factor for x and y dimensions
-            z_scale: Scale factor for z dimension
-            
-        Returns:
-            Dictionary of label: volume pairs for this chunk
-        """
-        chunk_volumes = {}
-        for label in labels:
-            volume = np.count_nonzero(chunk_data == label) * (xy_scale**2) * z_scale
-            if volume > 0:  # Only include if object exists in this chunk
-                chunk_volumes[label] = volume
-        return chunk_volumes
-
-    # Get unique labels (excluding 0 which typically represents background)
     labels = np.unique(array)
     if len(labels) == 2:
         array, _ = nettracer.label_objects(array)
-        labels = np.unique(array)
-    labels = labels[labels != 0]  # Remove background label if present
-    
-    if len(labels) == 0:
-        return {}
-        
-    # Get number of CPU cores
-    num_cores = mp.cpu_count()
-    
-    # Calculate chunk size along y-axis
-    chunk_size = array.shape[1] // num_cores
-    if chunk_size < 1:
-        chunk_size = 1
-    
-    # Create chunks along y-axis
-    chunks = []
-    for i in range(0, array.shape[1], chunk_size):
-        end = min(i + chunk_size, array.shape[1])
-        chunks.append(array[:, i:end, :])
+
+    del labels
     
-    # Process chunks in parallel
-    process_func = partial(process_volume_chunk, 
-                         labels=labels, 
-                         xy_scale=xy_scale, 
-                         z_scale=z_scale)
+    # Get volumes using bincount
+    if 0 in array:
+        volumes = np.bincount(array.ravel())[1:]
+    else:
+        volumes = np.bincount(array.ravel())
+
     
-    volumes = {}
-    with ThreadPoolExecutor(max_workers=num_cores) as executor:
-        chunk_results = list(executor.map(process_func, chunks))
-        
-        # Combine results from all chunks
-        for chunk_volumes in chunk_results:
-            for label, volume in chunk_volumes.items():
-                if label in volumes:
-                    volumes[label] += volume
-                else:
-                    volumes[label] = volume
+    # Apply scaling
+    volumes = volumes * (xy_scale**2) * z_scale
     
-    return volumes
+    # Create dictionary with label:volume pairs
+    return {label: volume for label, volume in enumerate(volumes, start=1) if volume > 0}
+
 
 
 def search_neighbor_ids(nodes, targets, id_dict, neighborhood_dict, totals, search, xy_scale, z_scale, root):

{nettracer3d-0.5.2 → nettracer3d-0.5.4}/src/nettracer3d/nettracer.py

@@ -5,6 +5,7 @@ from scipy import ndimage
 from skimage import measure
 import cv2
 import concurrent.futures
+from concurrent.futures import ThreadPoolExecutor, as_completed
 from scipy.ndimage import zoom
 import multiprocessing as mp
 import os
@@ -23,7 +24,6 @@ except:
 from . import node_draw
 from . import network_draw
 from skimage import morphology as mpg
-from concurrent.futures import ThreadPoolExecutor, as_completed
 from . import smart_dilate
 from . import modularity
 from . import simple_network
@@ -37,45 +37,35 @@ from . import proximity
 #These next several methods relate to searching with 3D objects by dilating each one in a subarray around their neighborhood although I don't explicitly use this anywhere... can call them deprecated although I may want to use them later again so I have them still written out here.
 
 
-def get_reslice_indices(args):
-    """Internal method used for the secondary algorithm that finds dimensions for subarrays around nodes"""
-
-    indices, dilate_xy, dilate_z, array_shape = args
-    try:
-        max_indices = np.amax(indices, axis = 0) #Get the max/min of each index.
-    except ValueError: #Return Nones if this error is encountered
+def get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape):
+    """Convert slice object to padded indices accounting for dilation and boundaries"""
+    if slice_obj is None:
         return None, None, None
-    min_indices = np.amin(indices, axis = 0)
-
-    z_max, y_max, x_max = max_indices[0], max_indices[1], max_indices[2]
-
-    z_min, y_min, x_min = min_indices[0], min_indices[1], min_indices[2]
-
-    y_max = y_max + ((dilate_xy-1)/2) + 1 #Establish dimensions of intended subarray, expanding the max/min indices to include
-    y_min = y_min - ((dilate_xy-1)/2) - 1 #the future dilation space (by adding/subtracting half the dilation kernel for each axis)
-    x_max = x_max + ((dilate_xy-1)/2) + 1 #an additional index is added in each direction to make sure nothing is discluded.
+        
+    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 dilation padding
+    y_max = y_max + ((dilate_xy-1)/2) + 1
+    y_min = y_min - ((dilate_xy-1)/2) - 1
+    x_max = x_max + ((dilate_xy-1)/2) + 1
     x_min = x_min - ((dilate_xy-1)/2) - 1
     z_max = z_max + ((dilate_z-1)/2) + 1
     z_min = z_min - ((dilate_z-1)/2) - 1
 
-    if y_max > (array_shape[1] - 1): #Some if statements to make sure the subarray will not cause an indexerror
-        y_max = (array_shape[1] - 1)
-    if x_max > (array_shape[2] - 1):
-        x_max = (array_shape[2] - 1)
-    if z_max > (array_shape[0] - 1):
-        z_max = (array_shape[0] - 1)
-    if y_min < 0:
-        y_min = 0
-    if x_min < 0:
-        x_min = 0
-    if z_min < 0:
-        z_min = 0
-
-    y_vals = [y_min, y_max] #Return the subarray dimensions as lists
-    x_vals = [x_min, x_max]
-    z_vals = [z_min, z_max]
-
-    return z_vals, y_vals, x_vals
+    # 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_3d_array(args):
     """Internal method used for the secondary algorithm to reslice subarrays around nodes."""
@@ -110,37 +100,45 @@ def _get_node_edge_dict(label_array, edge_array, label, dilate_xy, dilate_z):
     return edge_array
 
 def process_label(args):
-    """Internal method used for the secondary algorithm to process a particular node."""
-    nodes, edges, label, dilate_xy, dilate_z, array_shape = args
+    """Modified to use pre-computed bounding boxes instead of argwhere"""
+    nodes, edges, label, dilate_xy, dilate_z, array_shape, bounding_boxes = args
     print(f"Processing node {label}")
-    indices = np.argwhere(nodes == label)
-    z_vals, y_vals, x_vals = get_reslice_indices((indices, dilate_xy, dilate_z, array_shape))
-    if z_vals is None: #If get_reslice_indices ran into a ValueError, nothing is returned.
+    
+    # Get the pre-computed bounding box for this label
+    slice_obj = bounding_boxes[label-1]  # -1 because label numbers start at 1
+    if slice_obj is None:
         return None, None, None
+        
+    z_vals, y_vals, x_vals = get_reslice_indices(slice_obj, dilate_xy, dilate_z, array_shape)
+    if z_vals is None:
+        return None, None, None
+        
     sub_nodes = reslice_3d_array((nodes, z_vals, y_vals, x_vals))
     sub_edges = reslice_3d_array((edges, z_vals, y_vals, x_vals))
     return label, sub_nodes, sub_edges
 
 
 def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z):
-    """Internal method used for the secondary algorithm to process nodes in parallel."""
-    # Initialize the dictionary to be returned
+    """Modified to 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)
+    
     # Use ThreadPoolExecutor for parallel execution
     with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
-        # First parallel section to process labels
-        # List of arguments for each parallel task
-        args_list = [(nodes, edges, i, dilate_xy, dilate_z, array_shape) for i in range(1, num_nodes + 1)]
+        # Create args list with bounding_boxes included
+        args_list = [(nodes, edges, i, dilate_xy, dilate_z, array_shape, bounding_boxes) 
+                    for i in range(1, num_nodes + 1)]
 
         # Execute parallel tasks to process labels
         results = executor.map(process_label, args_list)
 
-        # Second parallel section to create dictionary entries
+        # Process results in parallel
         for label, sub_nodes, sub_edges in results:
-            executor.submit(create_dict_entry, node_dict, label, sub_nodes, sub_edges, dilate_xy, dilate_z)
+            executor.submit(create_dict_entry, node_dict, label, sub_nodes, sub_edges, 
+                          dilate_xy, dilate_z)
 
     return node_dict
 
@@ -4093,6 +4091,29 @@ class Network_3D:
 
 
         return image, output
+
+    def node_to_color(self, down_factor = None, mode = 0):
+
+        if mode == 0:
+            array = self._nodes
+        elif mode == 1:
+            array = self._edges
+
+        items = list(np.unique(array))
+        if 0 in items:
+            del items[0]
+
+
+        if down_factor is not None:
+            original_shape = array.shape
+            array = downsample(array, down_factor)
+
+        array, output = community_extractor.assign_node_colors(items, array)
+
+        if down_factor is not None:
+            array = upsample_with_padding(array, down_factor, original_shape)
+
+        return array, output