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

nettracer3d/nettracer.py

@@ -384,6 +384,13 @@ def invert_dict(d):
         inverted.setdefault(value, []).append(key)
     return inverted
 
+def revert_dict(d):
+    inverted = {}
+    for key, value_list in d.items():
+        for value in value_list:
+            inverted[value] = key
+    return inverted
+
 def invert_dict_special(d):
 
     d = invert_dict(d)
@@ -626,6 +633,10 @@ def remove_branches_new(skeleton, length):
     image_copy = (image_copy[1:-1, 1:-1, 1:-1]).astype(np.uint8)
     return image_copy
 
+import numpy as np
+from collections import deque, defaultdict
+
+    
 def remove_branches(skeleton, length):
     """Used to compensate for overly-branched skeletons resulting from the scipy 3d skeletonization algorithm"""
 
@@ -737,8 +748,42 @@ def estimate_object_radii(labeled_array, gpu=False, n_jobs=None, xy_scale = 1, z
     else:
         return morphology.estimate_object_radii_cpu(labeled_array, n_jobs, xy_scale = xy_scale, z_scale = z_scale)
 
+def get_surface_areas(labeled, xy_scale=1, z_scale=1):
+    labels = np.unique(labeled)
+    labels = labels[labels > 0]
+    max_label = int(np.max(labeled))
+    
+    surface_areas = np.zeros(max_label + 1, dtype=np.float64)
+    
+    for axis in range(3):
+        if axis == 2:
+            face_area = xy_scale * xy_scale
+        else:
+            face_area = xy_scale * z_scale
+        
+        for direction in [-1, 1]:
+            # Pad with zeros only on the axis we're checking
+            pad_width = [(1, 1) if i == axis else (0, 0) for i in range(3)]
+            padded = np.pad(labeled, pad_width, mode='constant', constant_values=0)
+            
+            # Roll the padded array
+            shifted = np.roll(padded, direction, axis=axis)
+            
+            # Extract the center region (original size) from shifted
+            slices = [slice(1, -1) if i == axis else slice(None) for i in range(3)]
+            shifted_cropped = shifted[tuple(slices)]
+            
+            # Find exposed faces
+            exposed_faces = (labeled != shifted_cropped) & (labeled > 0)
+            
+            face_counts = np.bincount(labeled[exposed_faces], 
+                                     minlength=max_label + 1)
+            surface_areas += face_counts * face_area
+    
+    result = {int(label): float(surface_areas[label]) for label in labels}
+    return result
 
-def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil = 0, max_vol = 0, directory = None, return_skele = False, nodes = None):
+def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil = 0, max_vol = 0, directory = None, return_skele = False, nodes = None, compute = True, unify = False, xy_scale = 1, z_scale = 1):
     """Internal method to break open a skeleton at its branchpoints and label the remaining components, for an 8bit binary array"""
 
     if type(skeleton) == str:
@@ -747,18 +792,28 @@ def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil =
     else:
         broken_skele = None
 
-    #old_skeleton = copy.deepcopy(skeleton) # The skeleton might get modified in label_vertices so we can make a preserved copy of it to use later
-
     if nodes is None:
 
-        verts = label_vertices(skeleton, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, return_skele = return_skele)
+        verts = label_vertices(skeleton, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, return_skele = return_skele, compute = compute)
 
     else:
         verts = nodes
 
     verts = invert_array(verts)
 
-    #skeleton = old_skeleton
+    """
+    if compute: # We are interested in the endpoints if we are doing the optional computation later
+        endpoints = []
+        image_copy = np.pad(skeleton, pad_width=1, mode='constant', constant_values=0)
+        nonzero_coords = np.transpose(np.nonzero(image_copy))
+        for x, y, z in nonzero_coords:
+            mini = image_copy[x-1:x+2, y-1:y+2, z-1:z+2]
+            nearby_sum = np.sum(mini)
+            threshold = 2 * image_copy[x, y, z]
+            
+            if nearby_sum <= threshold:
+                endpoints.append((x, y, z))
+    """
 
     image_copy = skeleton * verts
 
@@ -776,9 +831,147 @@ def break_and_label_skeleton(skeleton, peaks = 1, branch_removal = 0, comp_dil =
         tifffile.imwrite(filename, labeled_image, photometric='minisblack')
         print(f"Broken skeleton saved to {filename}")
 
-    return labeled_image
+    if not unify:
+        verts = None
+    else:
+        verts = invert_array(verts)
+
+    if compute:
+
+        return labeled_image, verts, skeleton, None
+
+    return labeled_image, verts, None, None
+
+def compute_optional_branchstats(verts, labeled_array, endpoints, xy_scale = 1, z_scale = 1):
+
+    #Lengths:
+    # Get all non-background coordinates and their labels in one pass
+    z, y, x = np.where(labeled_array != 0)
+    labels = labeled_array[z, y, x]
+
+    # Sort by label
+    sort_idx = np.argsort(labels)
+    labels_sorted = labels[sort_idx]
+    z_sorted = z[sort_idx]
+    y_sorted = y[sort_idx]
+    x_sorted = x[sort_idx]
+
+    # Find where each label starts
+    unique_labels, split_idx = np.unique(labels_sorted, return_index=True)
+    split_idx = split_idx[1:]  # Remove first index for np.split
+
+    # Split into groups
+    z_split = np.split(z_sorted, split_idx)
+    y_split = np.split(y_sorted, split_idx)
+    x_split = np.split(x_sorted, split_idx)
+
+    # Build dict
+    coords_dict = {label: np.column_stack([z, y, x]) 
+                   for label, z, y, x in zip(unique_labels, z_split, y_split, x_split)}
+
+    from sklearn.neighbors import NearestNeighbors
+    from scipy.spatial.distance import pdist, squareform
+    len_dict = {}
+    tortuosity_dict = {}
+    angle_dict = {}
+    for label, coords in coords_dict.items():
+        len_dict[label] = morphology.calculate_skeleton_lengths(labeled_array.shape, xy_scale=xy_scale, z_scale=z_scale, skeleton_coords=coords)
+        
+        # Find neighbors for all points at once
+        nbrs = NearestNeighbors(radius=1.74, algorithm='kd_tree').fit(coords)
+        neighbor_counts = nbrs.radius_neighbors(coords, return_distance=False)
+        neighbor_counts = np.array([len(n) - 1 for n in neighbor_counts])  # -1 to exclude self
+        
+        # Endpoints have exactly 1 neighbor
+        endpoints = coords[neighbor_counts == 1]
+        
+        if len(endpoints) > 1:
+            # Scale endpoints
+            scaled_endpoints = endpoints.copy().astype(float)
+            scaled_endpoints[:, 0] *= z_scale  # z dimension
+            scaled_endpoints[:, 1] *= xy_scale  # y dimension
+            scaled_endpoints[:, 2] *= xy_scale  # x dimension
+            
+            # calculate distances on scaled coordinates
+            distances = pdist(scaled_endpoints, metric='euclidean')
+            max_distance = distances.max()
+            
+            tortuosity_dict[label] = len_dict[label]/max_distance
+
+        for branch, length in len_dict.items():
+            if length == 0: # This can happen for branches that are 1 pixel which shouldn't have '0' length technically, so we just set them to the length of a pixel
+                len_dict[branch] = xy_scale
+                tortuosity_dict[branch] = 1
 
+    """
+    verts = invert_array(verts)
+    for x, y, z in endpoints:
+        try:
+            verts[z,y,x] = 1
+        except IndexError:
+            print(x, y, z)
+
+    temp_network = Network_3D(nodes = verts, edges = labeled_array, xy_scale = xy_scale, z_scale = z_scale)
+    temp_network.calculate_all(temp_network.nodes, temp_network.edges, xy_scale = temp_network.xy_scale, z_scale = temp_network.z_scale, search = None, diledge = None, inners = False, remove_trunk = 0, ignore_search_region = True, other_nodes = None, label_nodes = True, directory = None, GPU = False, fast_dil = False, skeletonize = False, GPU_downsample = None)
+    temp_network.calculate_node_centroids()
+    from itertools import combinations
+    for node in temp_network.network.nodes:
+        neighbors = list(temp_network.network.neighbors(node))
+        
+        # Skip if fewer than 2 neighbors (endpoints or isolated nodes)
+        if len(neighbors) < 2:
+            continue
+        
+        # Get all unique pairs of neighbors
+        neighbor_pairs = combinations(neighbors, 2)
+        
+        angles = []
+        for neighbor1, neighbor2 in neighbor_pairs:
+            # Get coordinates from centroids
+            point_a = temp_network.node_centroids[neighbor1]
+            point_b = temp_network.node_centroids[node]  # vertex
+            point_c = temp_network.node_centroids[neighbor2]
+            
+            # Calculate angle
+            angle_result = calculate_3d_angle(point_a, point_b, point_c, xy_scale = xy_scale, z_scale = z_scale)
+            angles.append(angle_result)
+        
+        angle_dict[node] = angles
+    """
 
+    return len_dict, tortuosity_dict, angle_dict
+
+def calculate_3d_angle(point_a, point_b, point_c, xy_scale = 1, z_scale = 1):
+    """Calculate 3D angle at vertex B between points A-B-C."""
+    z1, y1, x1 = point_a
+    z2, y2, x2 = point_b  # vertex
+    z3, y3, x3 = point_c
+    
+    # Apply scaling
+    scaled_a = np.array([x1 * xy_scale, y1 * xy_scale, z1 * z_scale])
+    scaled_b = np.array([x2 * xy_scale, y2 * xy_scale, z2 * z_scale])
+    scaled_c = np.array([x3 * xy_scale, y3 * xy_scale, z3 * z_scale])
+    
+    # Create vectors from vertex B
+    vec_ba = scaled_a - scaled_b
+    vec_bc = scaled_c - scaled_b
+    
+    # Calculate angle using dot product
+    dot_product = np.dot(vec_ba, vec_bc)
+    magnitude_ba = np.linalg.norm(vec_ba)
+    magnitude_bc = np.linalg.norm(vec_bc)
+    
+    # Avoid division by zero
+    if magnitude_ba == 0 or magnitude_bc == 0:
+        return {'angle_degrees': 0}
+    
+    cos_angle = dot_product / (magnitude_ba * magnitude_bc)
+    cos_angle = np.clip(cos_angle, -1.0, 1.0)  # Handle numerical errors
+    
+    angle_radians = np.arccos(cos_angle)
+    angle_degrees = np.degrees(angle_radians)
+
+    return angle_degrees
 
 def threshold(arr, proportion, custom_rad = None):
 
@@ -907,9 +1100,12 @@ def show_3d(arrays_3d=None, arrays_4d=None, down_factor=None, order=0, xy_scale=
         # Downsample arrays if specified
         arrays_3d = [downsample(array, down_factor, order=order) for array in arrays_3d] if arrays_3d is not None else None
         arrays_4d = [downsample(array, down_factor, order=order) for array in arrays_4d] if arrays_4d is not None else None
+        scale = [z_scale * down_factor, xy_scale * down_factor, xy_scale * down_factor]
+    else:
+        scale = [z_scale, xy_scale, xy_scale]
+
     
     viewer = napari.Viewer(ndisplay=3)
-    scale = [z_scale, xy_scale, xy_scale]  # [z, y, x] order for napari
     
     # Add 3D arrays if provided
     if arrays_3d is not None:
@@ -2067,8 +2263,6 @@ def binarize(arrayimage, directory = None):
 
     arrayimage = arrayimage != 0
 
-    arrayimage = arrayimage.astype(np.uint8)
-
     arrayimage = arrayimage * 255
 
     if type(arrayimage) == str:
@@ -2079,7 +2273,7 @@ def binarize(arrayimage, directory = None):
             tifffile.imwrite(f"{directory}/binary.tif", arrayimage)
 
 
-    return arrayimage
+    return arrayimage.astype(np.uint8)
 
 def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast_dil = False, recursive = False, dilate_xy = None, dilate_z = None):
     """
@@ -2129,7 +2323,7 @@ def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0, preserve_labe
         arrayimage = binarize(arrayimage)
     erode_xy, erode_z = dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
 
-    if mode == 0:
+    if mode == 2:
         arrayimage = (erode_3D(arrayimage, erode_xy, erode_xy, erode_z)) * 255
     else:
         arrayimage = erode_3D_dt(arrayimage, amount, xy_scaling=xy_scale, z_scaling=z_scale, preserve_labels = preserve_labels)
@@ -2184,7 +2378,7 @@ def skeletonize(arrayimage, directory = None):
 
     return arrayimage
 
-def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None):
+def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol = 0, down_factor = None, directory = None, nodes = None, bonus_array = None, GPU = True, arrayshape = None, compute = False, unify = False, union_val = 10, xy_scale = 1, z_scale = 1):
     """
     Can be used to label branches a binary image. Labelled output will be saved to the active directory if none is specified. Note this works better on already thin filaments and may over-divide larger trunkish objects.
     :param array: (Mandatory, string or ndarray) - If string, a path to a tif file to label. Note that the ndarray alternative is for internal use mainly and will not save its output.
@@ -2208,26 +2402,31 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
     else:
         arrayshape = arrayshape
 
-
     if nodes is None:
 
         array = array > 0
 
         other_array = skeletonize(array)
 
-        other_array = break_and_label_skeleton(other_array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes)
+        other_array, verts, skele, endpoints = break_and_label_skeleton(other_array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes, compute = compute, unify = unify, xy_scale = xy_scale, z_scale = z_scale)
 
     else:
-        array = break_and_label_skeleton(array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes)
+        if down_factor is not None:
+            bonus_array = downsample(bonus_array, down_factor)
+        array, verts, skele, endpoints = break_and_label_skeleton(array, peaks = peaks, branch_removal = branch_removal, comp_dil = comp_dil, max_vol = max_vol, nodes = nodes, compute = compute, unify = unify, xy_scale = xy_scale, z_scale = z_scale)
+
+    if unify is True and nodes is not None:
+        from . import branch_stitcher
+        verts = dilate_3D_old(verts, 3, 3, 3,)
+        verts, _ = label_objects(verts)
+        array = branch_stitcher.trace(bonus_array, array, verts, score_thresh = union_val)
+        verts = None
 
-    if nodes is not None and down_factor is not None:
-        array = upsample_with_padding(array, down_factor, arrayshape)
 
     if nodes is None:
 
         array = smart_dilate.smart_label(array, other_array, GPU = GPU, remove_template = True)
         #distance = smart_dilate.compute_distance_transform_distance(array)
-        print("Watershedding result...")
         #array = water(-distance, other_array, mask=array) #Tried out skimage watershed as shown and found it did not label branches as well as smart_label (esp combined combined with post-processing label splitting if needed)
 
     else:
@@ -2256,8 +2455,11 @@ def label_branches(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
     else:
         print("Branches labelled")
 
+    if nodes is not None and down_factor is not None:
+        array = upsample_with_padding(array, down_factor, arrayshape)
 
-    return array
+
+    return array, verts, skele, endpoints
 
 def fix_branches_network(array, G, communities, fix_val = None):
 
@@ -2377,7 +2579,7 @@ def label_vertices(array, peaks = 0, branch_removal = 0, comp_dil = 0, max_vol =
     else:
         broken_skele = None
 
-    if down_factor > 0:
+    if down_factor > 1:
         array_shape = array.shape
         array = downsample(array, down_factor, order)
         if order == 3:
@@ -2927,7 +3129,7 @@ class Network_3D:
                 for _ in range(weight):
                     lista.append(u)
                     listb.append(v)
-                    listc.append(weight)
+                    listc.append(0)
             
             self._network_lists = [lista, listb, listc]
 
@@ -3161,7 +3363,14 @@ class Network_3D:
             if directory is None:
                 try:
                     if len(self._nodes.shape) == 3:
-                        tifffile.imwrite(f"{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                        try:
+                            tifffile.imwrite(f"{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                        except:
+                            try:
+                                tifffile.imwrite(f"{filename}", self._nodes)
+                            except:
+                                self._nodes = binarize(self._nodes)
+                                tifffile.imwrite(f"{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                     else:
                         tifffile.imwrite(f"{filename}", self._nodes)
                     print(f"Nodes saved to {filename}")
@@ -3170,9 +3379,16 @@ class Network_3D:
             if directory is not None:
                 try:
                     if len(self._nodes.shape) == 3:
-                        tifffile.imwrite(f"{directory}/{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                        try:
+                            tifffile.imwrite(f"{directory}/{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                        except:
+                            try:
+                                tifffile.imwrite(f"{directory}/{filename}", self._nodes)
+                            except:
+                                self._nodes = binarize(self._nodes)
+                                tifffile.imwrite(f"{directory}/{filename}", self._nodes, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                     else:
-                        tifffile.imwrite(f"{directory}/{filename}")
+                        tifffile.imwrite(f"{directory}/{filename}", self._nodes)
                     print(f"Nodes saved to {directory}/{filename}")
                 except Exception as e:
                     print(f"Could not save nodes to {directory}")
@@ -3202,11 +3418,25 @@ class Network_3D:
 
         if self._edges is not None:
             if directory is None:
-                tifffile.imwrite(f"{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                try:
+                    tifffile.imwrite(f"{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                except:
+                    try:
+                        tifffile.imwrite(f"{filename}", self._edges)
+                    except:
+                        self._edges = binarize(self._edges)
+                        tifffile.imwrite(f"{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 print(f"Edges saved to {filename}")
 
             if directory is not None:
-                tifffile.imwrite(f"{directory}/{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                try:
+                    tifffile.imwrite(f"{directory}/{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                except:
+                    try:
+                        tifffile.imwrite(f"{directory}/{filename}", self._edges)
+                    except:
+                        self._edges = binarize(self._edges)
+                        tifffile.imwrite(f"{directory}/{filename}", self._edges, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 print(f"Edges saved to {directory}/{filename}")
 
         if self._edges is None:
@@ -3379,14 +3609,28 @@ class Network_3D:
         if self._network_overlay is not None:
             if directory is None:
                 if len(self._network_overlay.shape) == 3:
-                    tifffile.imwrite(f"{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    try:
+                        tifffile.imwrite(f"{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    except:
+                        try:
+                            tifffile.imwrite(f"{filename}", self._network_overlay)
+                        except:
+                            self._network_overlay = binarize(self._network_overlay)
+                            tifffile.imwrite(f"{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 else:
                     tifffile.imwrite(f"{filename}", self._network_overlay)
                 print(f"Network overlay saved to {filename}")
 
             if directory is not None:
                 if len(self._network_overlay.shape) == 3:
-                    tifffile.imwrite(f"{directory}/{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    try:
+                        tifffile.imwrite(f"{directory}/{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    except:
+                        try:
+                            tifffile.imwrite(f"{directory}/{filename}", self._network_overlay)
+                        except:
+                            self._network_overlay = binarize(self._network_overlay)
+                            tifffile.imwrite(f"{directory}/{filename}", self._network_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 else:
                     tifffile.imwrite(f"{directory}/{filename}", self._network_overlay)
                 print(f"Network overlay saved to {directory}/{filename}")
@@ -3410,14 +3654,28 @@ class Network_3D:
         if self._id_overlay is not None:
             if directory is None:
                 if len(self._id_overlay.shape) == 3:
-                    tifffile.imwrite(f"{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    try:
+                        tifffile.imwrite(f"{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    except:
+                        try:
+                            tifffile.imwrite(f"{filename}", self._id_overlay)
+                        except:                            
+                            self._id_overlay = binarize(self._id_overlay)
+                            tifffile.imwrite(f"{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 else:
                     tifffile.imwrite(f"{filename}", self._id_overlay, imagej=True)
                 print(f"Network overlay saved to {filename}")
 
             if directory is not None:
                 if len(self._id_overlay.shape) == 3:
-                    tifffile.imwrite(f"{directory}/{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    try:
+                        tifffile.imwrite(f"{directory}/{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
+                    except:
+                        try:
+                            tifffile.imwrite(f"{directory}/{filename}", self._id_overlay)
+                        except:
+                            self._id_overlay = binarize(self._id_overlay)
+                            tifffile.imwrite(f"{directory}/{filename}", self._id_overlay, imagej=True, metadata=imagej_metadata, resolution=(resolution_value, resolution_value))
                 else:
                     tifffile.imwrite(f"{directory}/{filename}", self._id_overlay)
                 print(f"ID overlay saved to {directory}/{filename}")
@@ -4153,6 +4411,88 @@ class Network_3D:
             self._network_lists = network_analysis.read_excel_to_lists(df)
             self._network, net_weights = network_analysis.weighted_network(df)
 
+    def create_id_network(self, n=5):
+        import ast
+        import random
+        
+        if self.node_identities is None:
+            return
+        
+        def invert_dict(d):
+            inverted = {}
+            for key, value in d.items():
+                inverted.setdefault(value, []).append(key)
+            return inverted
+        
+        # Invert to get identity -> list of nodes
+        identity_to_nodes = invert_dict(self.node_identities)
+        
+        G = nx.Graph()
+        edge_set = set()
+        
+        # Step 1: Connect nodes within same exact identity
+        for identity, nodes in identity_to_nodes.items():
+            if len(nodes) <= 1:
+                continue
+            
+            # Each node chooses n random neighbors from its identity group
+            for node in nodes:
+                available = [other for other in nodes if other != node]
+                num_to_choose = min(n, len(available))
+                neighbors = random.sample(available, num_to_choose)
+                
+                for neighbor in neighbors:
+                    edge = tuple(sorted([node, neighbor]))
+                    edge_set.add(edge)
+        
+        # Step 2: For list-like identities, connect across groups with shared sub-identities
+        for identity, nodes in identity_to_nodes.items():
+            if identity.startswith('['):
+                try:
+                    sub_identities = ast.literal_eval(identity)
+                    
+                    # For each sub-identity in this list-like identity
+                    for sub_id in sub_identities:
+                        # Find all OTHER identity groups that contain this sub-identity
+                        for other_identity, other_nodes in identity_to_nodes.items():
+                            if other_identity == identity:
+                                continue  # Skip connecting to same exact identity (already done in Step 1)
+                            
+                            # Check if other_identity contains sub_id
+                            contains_sub_id = False
+                            
+                            if other_identity.startswith('['):
+                                try:
+                                    other_sub_ids = ast.literal_eval(other_identity)
+                                    if sub_id in other_sub_ids:
+                                        contains_sub_id = True
+                                except (ValueError, SyntaxError):
+                                    pass
+                            elif other_identity == sub_id:
+                                # Single identity that matches our sub-identity
+                                contains_sub_id = True
+                            
+                            if contains_sub_id:
+                                # Each node from current identity connects to n nodes from other_identity
+                                for node in nodes:
+                                    num_to_choose = min(n, len(other_nodes))
+                                    if num_to_choose > 0:
+                                        neighbors = random.sample(other_nodes, num_to_choose)
+                                        
+                                        for neighbor in neighbors:
+                                            edge = tuple(sorted([node, neighbor]))
+                                            edge_set.add(edge)
+                
+                except (ValueError, SyntaxError):
+                    pass  # Not a valid list, treat as already handled in Step 1
+        
+        G.add_edges_from(edge_set)
+        self.network = G
+
+
+
+
+
     def calculate_all(self, nodes, edges, xy_scale = 1, z_scale = 1, down_factor = None, search = None, diledge = None, inners = True, remove_trunk = 0, ignore_search_region = False, other_nodes = None, label_nodes = True, directory = None, GPU = True, fast_dil = True, skeletonize = False, GPU_downsample = None):
         """
         Method to calculate and save to mem all properties of a Network_3D object. In general, after initializing a Network_3D object, this method should be called on the node and edge masks that will be used to calculate the network.
@@ -5222,14 +5562,14 @@ class Network_3D:
                 except:
                     pass
 
-            title1 = f'Neighborhood Distribution of Nodes in Network from Nodes: {root}'
-            title2 = f'Neighborhood Distribution of Nodes in Network from Nodes {root} as a proportion of total nodes of that ID'
+            title1 = f'Neighborhood Distribution of Nodes in Network from Node Type: {root}'
+            title2 = f'Neighborhood Distribution of Nodes in Network from Node Type {root} as a Proportion (# neighbors with ID x / Total # ID x)'
 
 
         elif mode == 1: #Search neighborhoods morphologically, obtain densities
             neighborhood_dict, total_dict, densities = morphology.search_neighbor_ids(self._nodes, targets, node_identities, neighborhood_dict, total_dict, search, self._xy_scale, self._z_scale, root, fastdil = fastdil)
-            title1 = f'Volumetric Neighborhood Distribution of Nodes in image that are {search} from nodes: {root}'
-            title2 = f'Density Distribution of Nodes in image that are {search} from Nodes {root} as a proportion of total node volume of that ID'
+            title1 = f'Volumetric Neighborhood Distribution of Nodes in image that are {search} from Node Type: {root}'
+            title2 = f'Density Distribution of Nodes in image that are {search} from Node Type {root} as a proportion (Vol neighors with ID x / Total vol ID x)'
 
 
         for identity in neighborhood_dict:
@@ -5240,7 +5580,7 @@ class Network_3D:
         network_analysis.create_bar_graph(proportion_dict, title2, "Node Identity", "Proportion", directory=directory)
 
         try:
-            network_analysis.create_bar_graph(densities, f'Clustering Factor of Node Identities with {search} from nodes {root}', "Node Identity", "Density Search/Density Total", directory=directory)
+            network_analysis.create_bar_graph(densities, f'Relative Density of Node Identities with {search} from Node Type {root}', "Node Identity", "Density within search region/Density within entire image", directory=directory)
         except:
             densities = None
 
@@ -5470,7 +5810,6 @@ class Network_3D:
         else:
             search_x, search_z = dilation_length_to_pixels(self._xy_scale, self._z_scale, search, search)
 
-
         num_nodes = int(np.max(self._nodes))
 
         my_dict = proximity.create_node_dictionary(self._nodes, num_nodes, search_x, search_z, targets = targets, fastdil = fastdil, xy_scale = self._xy_scale, z_scale = self._z_scale, search = search)
@@ -5630,7 +5969,7 @@ class Network_3D:
         neighborhoods.visualize_cluster_composition_umap(self.node_centroids, None, id_dictionary = self.node_identities, graph_label = "Node ID", title = 'UMAP Visualization of Node Centroids') 
 
 
-    def identity_umap(self, data):
+    def identity_umap(self, data, mode = 0):
 
         try:
 
@@ -5650,16 +5989,18 @@ class Network_3D:
                 else:
                     del umap_dict[item]
 
-            from scipy.stats import zscore
+            #from scipy.stats import zscore
 
             # Z-score normalize each marker (column)
-            for key in umap_dict:
-                umap_dict[key] = zscore(umap_dict[key])
-
+            #for key in umap_dict:
+                #umap_dict[key] = zscore(umap_dict[key])
 
             from . import neighborhoods
 
-            neighborhoods.visualize_cluster_composition_umap(umap_dict, None, id_dictionary = neighbor_classes, graph_label = "Node ID", title = 'UMAP Visualization of Node Identities by Z-Score') 
+            if mode == 0:
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, None, id_dictionary = neighbor_classes, graph_label = "Node ID", title = 'UMAP Visualization of Node Identities by Z-Score') 
+            else:
+                neighborhoods.visualize_cluster_composition_umap(umap_dict, None, id_dictionary = neighbor_classes, graph_label = "Node ID", title = 'UMAP Visualization of Node Identities by Z-Score', neighborhoods = self.communities, original_communities = self.communities) 
 
         except Exception as e:
             import traceback
@@ -5778,7 +6119,6 @@ class Network_3D:
                         neighbor_group[com] = neighbors[node]
                     except:
                         neighbor_group[com] = 0
-                print(neighbors)
                 neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, neighborhoods = neighbor_group, original_communities = neighbors)
             elif label == 1:
                 neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, label = True) 
@@ -5791,6 +6131,19 @@ class Network_3D:
         return output, id_set
 
 
+    def group_nodes_by_intensity(self, data, count = None):
+
+        from . import neighborhoods
+
+        clusters = neighborhoods.cluster_arrays(data, count, seed = 42)
+
+        coms = {}
+
+        for i, cluster in enumerate(clusters):
+            coms[i + 1] = cluster
+
+        self.communities = revert_dict(coms)
+
     def assign_neighborhoods(self, seed, count, limit = None, prev_coms = None, proportional = False, mode = 0):
 
         from . import neighborhoods
@@ -5882,14 +6235,14 @@ class Network_3D:
         if proportional:
 
             identities2, id_set2 = self.community_id_info_per_com(proportional = True)
-            output = neighborhoods.plot_dict_heatmap(identities2, id_set2, title = "Neighborhood Heatmap by Proportional Composition of Nodes in Neighborhood vs All Nodes")
+            output = neighborhoods.plot_dict_heatmap(identities2, id_set2, title = "Neighborhood Heatmap by Proportional Composition of Nodes in Neighborhood vs All Nodes in Image")
             matrixes.append(output)
 
             identities3 = {}
             for iden in identities2:
                 identities3[iden] = identities2[iden]/len_dict[iden][1]
 
-            output = neighborhoods.plot_dict_heatmap(identities3, id_set2, title = "Neighborhood Heatmap by Proportional Composition of Nodes in Neighborhood vs All Nodes Divided by Neighborhood Total Proportion of All Nodes (val < 1 = underrepresented, val > 1 = overrepresented)", center_at_one = True)
+            output = neighborhoods.plot_dict_heatmap(identities3, id_set2, title = "Over/Underrepresentation of Node Identities per Neighborhood (val < 1 = underrepresented, val > 1 = overrepresented)", center_at_one = True)
             matrixes.append(output)
 
         return len_dict, matrixes, id_set
@@ -5941,13 +6294,6 @@ class Network_3D:
 
     def community_cells(self, size = 32, xy_scale = 1, z_scale = 1):
 
-        def revert_dict(d):
-            inverted = {}
-            for key, value_list in d.items():
-                for value in value_list:
-                    inverted[value] = key
-            return inverted
-
         size_x = int(size * xy_scale)
         size_z = int(size * z_scale)