nettracer3d 0.9.4__py3-none-any.whl → 0.9.6__py3-none-any.whl

nettracer3d/nettracer.py

@@ -1267,31 +1267,6 @@ def dilate_2D(array, search, scaling = 1):
 
     return inv
 
-def erode_2D(array, search, scaling=1):
-    """
-    Erode a 2D array using distance transform method.
-    
-    Parameters:
-    array -- Input 2D binary array
-    search -- Distance within which to erode
-    scaling -- Scaling factor (default: 1)
-    
-    Returns:
-    Eroded 2D array
-    """
-    # For erosion, we work directly with the foreground
-    # No need to invert the array
-    
-    # Compute distance transform on the foreground
-    dt = smart_dilate.compute_distance_transform_distance(array)
-    
-    # Apply scaling
-    dt = dt * scaling
-    
-    # Threshold to keep only points that are at least 'search' distance from the boundary
-    eroded = dt >= search
-    
-    return eroded
 
 def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     """
@@ -1353,7 +1328,42 @@ def dilate_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     
     return inv.astype(np.uint8)
 
-def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
+def erode_2D(array, search, scaling=1, preserve_labels = False):
+    """
+    Erode a 2D array using distance transform method.
+    
+    Parameters:
+    array -- Input 2D binary array
+    search -- Distance within which to erode
+    scaling -- Scaling factor (default: 1)
+    
+    Returns:
+    Eroded 2D array
+    """
+    # For erosion, we work directly with the foreground
+    # No need to invert the array
+
+    if preserve_labels:
+        from skimage.segmentation import find_boundaries
+        borders = find_boundaries(array, mode='thick')
+        mask = array * invert_array(borders)
+        mask = smart_dilate.compute_distance_transform_distance(mask)
+        mask = mask * scaling
+        mask = mask >= search
+        array = mask * array
+    else:
+        # Compute distance transform on the foreground
+        dt = smart_dilate.compute_distance_transform_distance(array)
+        
+        # Apply scaling
+        dt = dt * scaling
+        
+        # Threshold to keep only points that are at least 'search' distance from the boundary
+        array = dt > search
+    
+    return array
+
+def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0, preserve_labels = False):
     """
     Erode a 3D array using distance transform method. DT erosion produces perfect results 
     with Euclidean geometry, but may be slower for large arrays.
@@ -1371,43 +1381,24 @@ def erode_3D_dt(array, search_distance, xy_scaling=1.0, z_scaling=1.0):
     
     if array.shape[0] == 1:
         # Handle 2D case
-        return erode_2D(array, search_distance, scaling=xy_scaling)
+        return erode_2D(array, search_distance, scaling=xy_scaling, preserve_labels = True)
     
-    # For erosion, we work directly with the foreground (no inversion needed)
-    
-    """
-    # Determine which dimension needs resampling
-    if (z_scaling > xy_scaling):
-        # Z dimension needs to be stretched
-        zoom_factor = [z_scaling/xy_scaling, 1, 1]  # Scale factor for [z, y, x]
-        rev_factor = [xy_scaling/z_scaling, 1, 1] 
-        cardinal = xy_scaling
-    elif (xy_scaling > z_scaling):
-        # XY dimensions need to be stretched
-        zoom_factor = [1, xy_scaling/z_scaling, xy_scaling/z_scaling]  # Scale factor for [z, y, x]
-        rev_factor = [1, z_scaling/xy_scaling, z_scaling/xy_scaling]  # Scale factor for [z, y, x]
-        cardinal = z_scaling
-    else:
-        # Already uniform scaling, no need to resample
-        zoom_factor = None
-        rev_factor = None
-        cardinal = xy_scaling
-    
-    # Resample the mask if needed
-    if zoom_factor:
-        array = ndimage.zoom(array, zoom_factor, order=0)  # Use order=0 for binary masks
-    """
-    
-    print("Computing a distance transform for a perfect erosion...")
 
-    array = smart_dilate.compute_distance_transform_distance(array, sampling = [z_scaling, xy_scaling, xy_scaling])
-    
-    # Apply scaling factor
-    #array = array * cardinal
-    
-    # Threshold the distance transform to get eroded result
-    # For erosion, we keep only the points that are at least search_distance from the boundary
-    array = array >= search_distance
+    if preserve_labels:
+
+
+        from skimage.segmentation import find_boundaries
+
+        borders = find_boundaries(array, mode='thick')
+        mask = array * invert_array(borders)
+        mask = smart_dilate.compute_distance_transform_distance(mask, sampling = [z_scaling, xy_scaling, xy_scaling])
+        mask = mask >= search_distance
+        array = mask * array
+    else:
+        array = smart_dilate.compute_distance_transform_distance(array, sampling = [z_scaling, xy_scaling, xy_scaling])
+        # Threshold the distance transform to get eroded result
+        # For erosion, we keep only the points that are at least search_distance from the boundary
+        array = array > search_distance
     
     # Resample back to original dimensions if needed
     #if rev_factor:
@@ -1574,7 +1565,7 @@ def dilate_3D_old(tiff_array, dilated_x=3, dilated_y=3, dilated_z=3):
 
 
 def erode_3D(tiff_array, eroded_x, eroded_y, eroded_z):
-    """Internal method to erode an array in 3D. Erosion this way is much faster than using a distance transform although the latter is theoretically more accurate.
+    """Internal method to erode an array in 3D. Erosion this way is faster than using a distance transform although the latter is theoretically more accurate.
     Arguments are an array, and the desired pixel erosion amounts in X, Y, Z."""
 
     if tiff_array.shape[0] == 1:
@@ -1744,54 +1735,6 @@ def combine_edges(edge_labels_1, edge_labels_2):
     
     return np.where(mask, offset_labels, edge_labels_1)
 
-def combine_nodes(root_nodes, other_nodes, other_ID, identity_dict, root_ID = None):
-
-    """Internal method to merge two labelled node arrays into one"""
-
-    print("Combining node arrays")
-
-    mask = (root_nodes == 0) & (other_nodes > 0)
-    if np.any(mask):
-        max_val = np.max(root_nodes)
-        other_nodes[:] = np.where(mask, other_nodes + max_val, 0)
-
-    if root_ID is not None:
-        rootIDs = list(np.unique(root_nodes)) #Sets up adding these vals to the identitiy dictionary. Gets skipped if this has already been done.
-
-        if rootIDs[0] == 0: #np unique can include 0 which we don't want.
-            del rootIDs[0]
-
-    otherIDs = list(np.unique(other_nodes)) #Sets up adding other vals to the identity dictionary.
-
-    if otherIDs[0] == 0:
-        del otherIDs[0]
-
-    if root_ID is not None: #Adds the root vals to the dictionary if it hasn't already
-
-        if other_ID.endswith('.tiff'):
-            other_ID = other_ID[:-5]
-        elif other_ID.endswith('.tif'):
-            other_ID = other_ID[:-4]
-
-        for item in rootIDs:
-            identity_dict[item] = root_ID
-
-    for item in otherIDs: #Always adds the other vals to the dictionary
-        try:
-            other_ID = os.path.basename(other_ID)
-        except:
-            pass
-        if other_ID.endswith('.tiff'):
-            other_ID = other_ID[:-5]
-        elif other_ID.endswith('.tif'):
-            other_ID = other_ID[:-4]
-
-        identity_dict[item] = other_ID
-
-    nodes = root_nodes + other_nodes #Combine the outer edges with the inner edges modified via the above steps
-
-    return nodes, identity_dict
-
 def directory_info(directory = None):
     """Internal method to get the files in a directory, optionally the current directory if nothing passed"""
     
@@ -2124,15 +2067,15 @@ def dilate(arrayimage, amount, xy_scale = 1, z_scale = 1, directory = None, fast
 
     return arrayimage
 
-def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0):
-    if len(np.unique(arrayimage)) > 2: #binarize
+def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0, preserve_labels = False):
+    if not preserve_labels and len(np.unique(arrayimage)) > 2: #binarize
         arrayimage = binarize(arrayimage)
     erode_xy, erode_z = dilation_length_to_pixels(xy_scale, z_scale, amount, amount)
 
     if mode == 0:
         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)
+        arrayimage = erode_3D_dt(arrayimage, amount, xy_scaling=xy_scale, z_scaling=z_scale, preserve_labels = preserve_labels)
 
     if np.max(arrayimage) == 1:
         arrayimage = arrayimage * 255
@@ -3847,7 +3790,7 @@ class Network_3D:
 
             self._search_region = self._nodes
 
-    def calculate_edges(self, binary_edges, diledge = None, inners = True, hash_inner_edges = True, search = None, remove_edgetrunk = 0, GPU = True, fast_dil = False, skeletonized = False):
+    def calculate_edges(self, binary_edges, diledge = None, inners = True, search = None, remove_edgetrunk = 0, GPU = True, fast_dil = False, skeletonized = False):
         """
         Method to calculate the edges that are used to directly connect nodes. May be done with or without the search region, however using search_region is recommended. 
         The search_region property must be set to use the search region, otherwise the nodes property must be set. Sets the edges property
@@ -3856,7 +3799,6 @@ class Network_3D:
         so some amount of dilation is recommended if there are any, but  not so much to create overconnectivity. This is a value that needs to be tuned by the user.
         :param inners: (Optional - Val = True; boolean). Will use inner edges if True, will not if False. Inner edges are parts of the edge mask that exist within search regions. If search regions overlap, 
         any edges that exist within the overlap will only assert connectivity if 'inners' is True.
-        :param hash_inner_edges: (Optional - Val = True; boolean). If False, all search regions that contain an edge object connecting multiple nodes will be assigned as connected.
         If True, an extra processing step is used to sort the correct connectivity amongst these search_regions. Can only be computed when search_regions property is set.
         :param search: (Optional - Val = None; int). Amount for nodes to search for connections, assuming the search_regions are not being used. Assigning a value to this param will utilize the secondary algorithm and not the search_regions.
         :param remove_edgetrunk: (Optional - Val = 0; int). Amount of times to remove the 'Trunk' from the edges. A trunk in this case is the largest (by vol) edge object remaining after nodes have broken up the edges.
@@ -3909,11 +3851,7 @@ class Network_3D:
         labelled_edges, num_edge = label_objects(outer_edges)
 
         if inners:
-
-            if search is None and hash_inner_edges is True:
-                inner_edges = hash_inners(self._search_region, binary_edges, GPU = GPU)
-            else:
-                inner_edges = establish_inner_edges(search_region, binary_edges)
+            inner_edges = hash_inners(self._search_region, binary_edges, GPU = GPU)
 
             del binary_edges
 
@@ -3939,7 +3877,58 @@ class Network_3D:
         """
         self._nodes, num_nodes = label_objects(nodes, structure_3d)
 
-    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes"):
+    def combine_nodes(self, root_nodes, other_nodes, other_ID, identity_dict, root_ID = None, centroids = False):
+
+        """Internal method to merge two labelled node arrays into one"""
+
+        print("Combining node arrays")
+
+        mask = (root_nodes == 0) & (other_nodes > 0)
+        if np.any(mask):
+            max_val = np.max(root_nodes)
+            other_nodes[:] = np.where(mask, other_nodes + max_val, 0)
+        if centroids:
+            new_dict = network_analysis._find_centroids(other_nodes)
+            self.node_centroids.update(new_dict)
+
+        if root_ID is not None:
+            rootIDs = list(np.unique(root_nodes)) #Sets up adding these vals to the identitiy dictionary. Gets skipped if this has already been done.
+
+            if rootIDs[0] == 0: #np unique can include 0 which we don't want.
+                del rootIDs[0]
+
+        otherIDs = list(np.unique(other_nodes)) #Sets up adding other vals to the identity dictionary.
+
+        if otherIDs[0] == 0:
+            del otherIDs[0]
+
+        if root_ID is not None: #Adds the root vals to the dictionary if it hasn't already
+
+            if other_ID.endswith('.tiff'):
+                other_ID = other_ID[:-5]
+            elif other_ID.endswith('.tif'):
+                other_ID = other_ID[:-4]
+
+            for item in rootIDs:
+                identity_dict[item] = root_ID
+
+        for item in otherIDs: #Always adds the other vals to the dictionary
+            try:
+                other_ID = os.path.basename(other_ID)
+            except:
+                pass
+            if other_ID.endswith('.tiff'):
+                other_ID = other_ID[:-5]
+            elif other_ID.endswith('.tif'):
+                other_ID = other_ID[:-4]
+
+            identity_dict[item] = other_ID
+
+        nodes = root_nodes + other_nodes #Combine the outer edges with the inner edges modified via the above steps
+
+        return nodes, identity_dict
+
+    def merge_nodes(self, addn_nodes_name, label_nodes = True, root_id = "Root_Nodes", centroids = False):
         """
         Merges the self._nodes attribute with alternate labelled node images. The alternate nodes can be inputted as a string for a filepath to a tif,
         or as a directory address containing only tif images, which will merge the _nodes attribute with all tifs in the folder. The _node_identities attribute
@@ -3959,16 +3948,20 @@ class Network_3D:
             
         identity_dict = {} #A dictionary to deliniate the node identities
 
+        if centroids:
+            self.node_centroids = network_analysis._find_centroids(self._nodes)
+
+
         try: #Try presumes the input is a tif
             addn_nodes = tifffile.imread(addn_nodes_name) #If not this will fail and activate the except block
 
             if label_nodes is True:
                 addn_nodes, num_nodes2 = label_objects(addn_nodes) # Label the node objects. Note this presumes no overlap between node masks.
-                node_labels, identity_dict = combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name) #This method stacks labelled arrays
+                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids) #This method stacks labelled arrays
                 num_nodes = np.max(node_labels)
 
             else: #If nodes already labelled
-                node_labels, identity_dict = combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name)
+                node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_name, identity_dict, nodes_name, centroids = centroids)
                 num_nodes = int(np.max(node_labels))
 
         except: #Exception presumes the input is a directory containing multiple tifs, to allow multi-node stackage.
@@ -3986,16 +3979,15 @@ class Network_3D:
                     if label_nodes is True:
                         addn_nodes, num_nodes2 = label_objects(addn_nodes)  # Label the node objects. Note this presumes no overlap between node masks.
                         if i == 0:
-                            node_labels, identity_dict = combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name)
-
+                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids)
                         else:
-                            node_labels, identity_dict = combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict)
+                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids)
 
                     else:
                         if i == 0:
-                            node_labels, identity_dict = combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name)
+                            node_labels, identity_dict = self.combine_nodes(self._nodes, addn_nodes, addn_nodes_ID, identity_dict, nodes_name, centroids = centroids)
                         else:
-                            node_labels, identity_dict = combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict)
+                            node_labels, identity_dict = self.combine_nodes(node_labels, addn_nodes, addn_nodes_ID, identity_dict, centroids = centroids)
                 except Exception as e:
                     print("Could not open additional nodes, verify they are being inputted correctly...")
 
@@ -4045,7 +4037,7 @@ class Network_3D:
             self._network_lists = network_analysis.read_excel_to_lists(df)
             self._network, net_weights = network_analysis.weighted_network(df)
 
-    def calculate_all(self, nodes, edges, xy_scale = 1, z_scale = 1, down_factor = None, search = None, diledge = None, inners = True, hash_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):
+    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.
         :param nodes: (Mandatory; String or ndarray). Filepath to segmented nodes mask or a numpy array containing the same.
@@ -4058,7 +4050,6 @@ class Network_3D:
         so some amount of dilation is recommended if there are any, but not so much to create overconnectivity. This is a value that needs to be tuned by the user.
         :param inners: (Optional - Val = True; boolean). Will use inner edges if True, will not if False. Inner edges are parts of the edge mask that exist within search regions. If search regions overlap, 
         any edges that exist within the overlap will only assert connectivity if 'inners' is True.
-        :param hash_inners: (Optional - Val = True; boolean). If False, all search regions that contain an edge object connecting multiple nodes will be assigned as connected.
         If True, an extra processing step is used to sort the correct connectivity amongst these search_regions. Can only be computed when search_regions property is set.
         :param remove_trunk: (Optional - Val = 0; int). Amount of times to remove the 'Trunk' from the edges. A trunk in this case is the largest (by vol) edge object remaining after nodes have broken up the edges.
         Any 'Trunks' removed will be absent for connection calculations.
@@ -4120,7 +4111,7 @@ class Network_3D:
                 except:
                     pass
 
-            self.calculate_edges(edges, diledge = diledge, inners = inners, hash_inner_edges = hash_inners, search = search, remove_edgetrunk = remove_trunk, GPU = GPU, fast_dil = fast_dil, skeletonized = skeletonize) #Will have to be moved out if the second method becomes more directly implemented
+            self.calculate_edges(edges, diledge = diledge, inners = inners, search = search, remove_edgetrunk = remove_trunk, GPU = GPU, fast_dil = fast_dil, skeletonized = skeletonize) #Will have to be moved out if the second method becomes more directly implemented
         else:
             self._edges, _ = label_objects(edges)
 
@@ -5104,13 +5095,16 @@ class Network_3D:
 
 
             for node in G.nodes():
-                nodeid = node_identities[node]
-                neighbors = list(G.neighbors(node))
-                for subnode in neighbors:
-                    subnodeid = node_identities[subnode]
-                    if subnodeid == root:
-                        neighborhood_dict[nodeid] += 1
-                        break
+                try:
+                    nodeid = node_identities[node]
+                    neighbors = list(G.neighbors(node))
+                    for subnode in neighbors:
+                        subnodeid = node_identities[subnode]
+                        if subnodeid == root:
+                            neighborhood_dict[nodeid] += 1
+                            break
+                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'
@@ -5219,34 +5213,22 @@ class Network_3D:
                     bounds = (min_coords, max_coords)
                     dim_list = max_coords - min_coords
 
-
-                if dim == 3:
-
-                    """
-                    if self.xy_scale > self.z_scale: # xy will be 'expanded' more so its components will be arbitrarily further from the border than z ones
-                        factor_xy = (self.z_scale/self.xy_scale) * factor # So 'factor' in the xy dim has to get smaller
-                        factor_z = factor
-                    elif self.z_scale > self.xy_scale: # Same idea
-                        factor_z = (self.xy_scale/self.z_scale) * factor
-                        factor_xy = factor
-                    else:
-                        factor_z = factor
-                        factor_xy = factor
-                    """
-
-                    for centroid in roots:
-
-                        if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor) and ((centroid[0] - min_coords[2]) > dim_list[2] * factor) and ((max_coords[2] - centroid[0]) > dim_list[2] * factor):
+                for centroid in roots:
+                    # Assuming centroid is [z, y, x] based on your indexing
+                    z, y, x = centroid[0], centroid[1], centroid[2]
+                    
+                    # Check x-dimension
+                    x_ok = (x - min_coords[0]) > dim_list[0] * factor and (max_coords[0] - x) > dim_list[0] * factor
+                    # Check y-dimension  
+                    y_ok = (y - min_coords[1]) > dim_list[1] * factor and (max_coords[1] - y) > dim_list[1] * factor
+                    
+                    if dim == 3:  # 3D case
+                        # Check z-dimension
+                        z_ok = (z - min_coords[2]) > dim_list[2] * factor and (max_coords[2] - z) > dim_list[2] * factor
+                        if x_ok and y_ok and z_ok:
                             new_list.append(centroid)
-
-
-                        #if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor) and ((centroid[0] - min_coords[2]) > dim_list[2] * factor) and ((max_coords[2] - centroid[0]) > dim_list[2] * factor):
-                            #new_list.append(centroid)
-                            #print(f"dim_list: {dim_list}, centroid: {centroid}, min_coords: {min_coords}, max_coords: {max_coords}")
-                else:
-                    for centroid in roots:
-
-                        if ((centroid[2] - min_coords[0]) > dim_list[0] * factor) and ((max_coords[0] - centroid[2]) > dim_list[0]  * factor) and ((centroid[1] - min_coords[1]) > dim_list[1] * factor) and ((max_coords[1] - centroid[1]) > dim_list[1] * factor):
+                    else:  # 2D case
+                        if x_ok and y_ok:
                             new_list.append(centroid)
 
             else:
@@ -5299,8 +5281,6 @@ class Network_3D:
             print(f"Utilizing {len(roots)} root points. Note that low n values are unstable.")
             is_subset = True
 
-
-
         roots = proximity.convert_centroids_to_array(roots, xy_scale = self.xy_scale, z_scale = self.z_scale)
 
         n_subset = len(targs)
@@ -5531,55 +5511,42 @@ 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):
+    def identity_umap(self, data):
 
         try:
 
-            id_set = iden_set(self.node_identities.values())
-
-            template = np.zeros(len(id_set))
+            neighbor_classes = {}
+            import random
 
-            id_dict = {}
-            for i, iden in enumerate(id_set):
-                id_dict[iden] = i
+            umap_dict = copy.deepcopy(data)
 
-            umap_dict = {}
+            for item in data.keys():
+                if item in self.node_identities:
+                    try:
+                        parse = ast.literal_eval(self.node_identities[item])
+                        neighbor_classes[item] = random.choice(parse)
+                    except:
+                        neighbor_classes[item] = self.node_identities[item]
 
-            for node in self.node_identities.keys():
-                umap_dict[node] = copy.deepcopy(template)
-                try:
-                    idens = ast.literal_eval(self.node_identities[node])
-                    for iden in idens:
-                        index = id_dict[iden]
-                        ref = umap_dict[node]
-                        ref[index] = 1
-                        umap_dict[node] = ref
-                except:
-                    index = id_dict[self.node_identities[node]]
-                    ref = umap_dict[node]
-                    ref[index] = 1
-                    umap_dict[node] = ref
+                else:
+                    del umap_dict[item]
 
-            neighbor_classes = {}
-            import random
+            from scipy.stats import zscore
 
-            for node, iden in self.node_identities.items():
-                try:
-                    idens = ast.literal_eval(iden)
-                    neighbor_classes[node] = random.choice(idens)
-                except:
-                    neighbor_classes[node] = iden
+            # Z-score normalize each marker (column)
+            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', draw_lines = True) 
+            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') 
 
         except Exception as e:
+            import traceback
+            print(traceback.format_exc())
             print(f"Error: {e}")
 
-
     def community_id_info_per_com(self, umap = False, label = 0, limit = 0, proportional = False, neighbors = None):
 
         community_dict = invert_dict(self.communities)
@@ -5608,7 +5575,10 @@ class Network_3D:
                         for iden in idens:
                             counter[id_dict[iden]] += 1
                     except:
-                        counter[id_dict[self.node_identities[node]]] += 1 # Keep them as arrays
+                        try:
+                            counter[id_dict[self.node_identities[node]]] += 1 # Keep them as arrays
+                        except:
+                            pass
 
                 for i in range(len(counter)): # Translate them into proportions out of 1
 
@@ -5645,7 +5615,10 @@ class Network_3D:
                         for iden in idents:
                             iden_tracker[iden] += 1
                     except:
-                        iden_tracker[self.node_identities[node]] += 1 
+                        try:
+                            iden_tracker[self.node_identities[node]] += 1
+                        except:
+                            pass
 
                 i = 0
 
@@ -5915,6 +5888,23 @@ class Network_3D:
             overlay = neighborhoods.create_community_heatmap(heat_dict, self.communities, self.node_centroids, shape = shape, is_3d=is3d, labeled_array = self.nodes)
             return heat_dict, overlay
 
+    def get_merge_node_dictionaries(self, path, data):
+
+        img_list = directory_info(path)
+        id_dicts = []
+        num_nodes = np.max(data)
+
+        for i, img in enumerate(img_list):
+            if img.endswith('.tiff') or img.endswith('.tif'):
+                print(f"Processing image {img}")
+                mask = tifffile.imread(f'{path}/{img}')
+                if len(mask.shape) == 2:
+                    mask = np.expand_dims(mask, axis = 0)
+
+                id_dict = proximity.create_node_dictionary_id(data, mask, num_nodes)
+                id_dicts.append(id_dict)
+
+        return id_dicts
 
     def merge_node_ids(self, path, data, include = True):
 
@@ -5940,46 +5930,49 @@ class Network_3D:
         img_list = directory_info(path)
 
         for i, img in enumerate(img_list):
-            mask = tifffile.imread(f'{path}/{img}')
 
-            if len(np.unique(mask)) != 2:
+            if img.endswith('.tiff') or img.endswith('.tif'):
 
-                mask = otsu_binarize(mask)
-            else:
-                mask = mask != 0
+                mask = tifffile.imread(f'{path}/{img}')
 
-            nodes = data * mask
-            nodes = np.unique(nodes)
-            nodes = nodes.tolist()
-            if 0 in nodes:
-                del nodes[0]
+                if len(np.unique(mask)) != 2:
 
-            if img.endswith('.tiff'):
-                base_name = img[:-5]
-            elif img.endswith('.tif'):
-                base_name = img[:-4]
-            else:
-                base_name = img
+                    mask = otsu_binarize(mask)
+                else:
+                    mask = mask != 0
+
+                nodes = data * mask
+                nodes = np.unique(nodes)
+                nodes = nodes.tolist()
+                if 0 in nodes:
+                    del nodes[0]
+
+                if img.endswith('.tiff'):
+                    base_name = img[:-5]
+                elif img.endswith('.tif'):
+                    base_name = img[:-4]
+                else:
+                    base_name = img
 
-            assigned = {}
+                assigned = {}
 
 
-            for node in self.node_identities.keys():
+                for node in self.node_identities.keys():
 
-                try:
+                    try:
 
-                    if int(node) in nodes:
+                        if int(node) in nodes:
 
-                        self.node_identities[node].append(f'{base_name}+')
+                            self.node_identities[node].append(f'{base_name}+')
 
-                    elif include:
+                        elif include:
 
-                        self.node_identities[node].append(f'{base_name}-')
+                            self.node_identities[node].append(f'{base_name}-')
 
-                except:
-                    pass
+                    except:
+                        pass
 
-            modify_dict = copy.deepcopy(self.node_identities)
+        modify_dict = copy.deepcopy(self.node_identities)
 
         for node, iden in self.node_identities.items():