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

nettracer3d/neighborhoods.py

@@ -347,8 +347,7 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
                                      id_dictionary: Optional[Dict[int, str]] = None, 
                                      graph_label = "Community ID",
                                      title = 'UMAP Visualization of Community Compositions',
-                                     neighborhoods: Optional[Dict[int, int]] = None,
-                                     draw_lines: bool = False):
+                                     neighborhoods: Optional[Dict[int, int]] = None):
     """
     Convert cluster composition data to UMAP visualization.
     
@@ -371,8 +370,6 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     neighborhoods : dict, optional
         Dictionary mapping node IDs to neighborhood IDs {node_id: neighborhood_id}.
         If provided, points will be colored by neighborhood using community coloration methods.
-    draw_lines : bool
-        Whether to draw lines between nodes that share identities (default: False)
     
     Returns:
     --------
@@ -456,111 +453,15 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     plt.figure(figsize=(12, 8))
     
     if n_components == 2:
-        # Draw scatter with different markers for multi-identity nodes if draw_lines is enabled
-        if draw_lines:
-            # Separate multi-identity and singleton nodes for different markers
-            singleton_indices = []
-            multi_indices = []
-            singleton_colors = []
-            multi_colors = []
-            
-            for i, cluster_id in enumerate(cluster_ids):
-                vec = cluster_data[cluster_id]
-                if np.sum(vec) > 1:  # Multi-identity
-                    multi_indices.append(i)
-                    multi_colors.append(point_colors[i] if isinstance(point_colors, list) else point_colors)
-                else:  # Singleton
-                    singleton_indices.append(i)
-                    singleton_colors.append(point_colors[i] if isinstance(point_colors, list) else point_colors)
-            
-            # Draw singleton nodes as circles
-            if singleton_indices:
-                if use_neighborhood_coloring or use_identity_coloring:
-                    scatter1 = plt.scatter(embedding[singleton_indices, 0], embedding[singleton_indices, 1], 
-                                         c=singleton_colors, s=100, alpha=0.7, marker='o')
-                else:
-                    scatter1 = plt.scatter(embedding[singleton_indices, 0], embedding[singleton_indices, 1], 
-                                         c=[point_colors[i] for i in singleton_indices], cmap='viridis', s=100, alpha=0.7, marker='o')
-            
-            # Draw multi-identity nodes as squares
-            if multi_indices:
-                if use_neighborhood_coloring or use_identity_coloring:
-                    scatter2 = plt.scatter(embedding[multi_indices, 0], embedding[multi_indices, 1], 
-                                         c=multi_colors, s=100, alpha=0.7, marker='s')
-                else:
-                    scatter2 = plt.scatter(embedding[multi_indices, 0], embedding[multi_indices, 1], 
-                                         c=[point_colors[i] for i in multi_indices], cmap='viridis', s=100, alpha=0.7, marker='s')
-                scatter = scatter2  # For colorbar reference
-            else:
-                scatter = scatter1 if singleton_indices else None
+        if use_neighborhood_coloring:
+            scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
+                                c=point_colors, s=100, alpha=0.7)
+        elif use_identity_coloring:
+            scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
+                                c=point_colors, s=100, alpha=0.7)
         else:
-            # Original behavior when draw_lines is False
-            if use_neighborhood_coloring:
-                scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
-                                    c=point_colors, s=100, alpha=0.7)
-            elif use_identity_coloring:
-                scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
-                                    c=point_colors, s=100, alpha=0.7)
-            else:
-                scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
-                                    c=point_colors, cmap='viridis', s=100, alpha=0.7)
-        
-        # Draw lines between nodes with shared identities (only if draw_lines=True)
-        if draw_lines:
-            # First pass: identify unique multi-identity configurations and their representatives
-            multi_config_map = {}  # Maps tuple(config) -> {'count': int, 'representative_idx': int}
-            
-            for i, cluster_id in enumerate(cluster_ids):
-                vec = cluster_data[cluster_id]
-                if np.sum(vec) > 1:  # Multi-identity node
-                    config = tuple(vec)  # Convert to hashable tuple
-                    if config not in multi_config_map:
-                        multi_config_map[config] = {'count': 1, 'representative_idx': i}
-                    else:
-                        multi_config_map[config]['count'] += 1
-            
-            # Second pass: draw lines for each unique configuration
-            for config, info in multi_config_map.items():
-                i = info['representative_idx']
-                count = info['count']
-                vec1 = np.array(config)
-                
-                # For each identity this configuration has, find the closest representative
-                identity_indices = np.where(vec1 == 1)[0]
-                
-                for identity_idx in identity_indices:
-                    best_target = None
-                    best_distance = float('inf')
-                    backup_target = None
-                    backup_distance = float('inf')
-                    
-                    # Find closest node with this specific identity
-                    for j, cluster_id2 in enumerate(cluster_ids):
-                        if i != j:  # Don't connect to self
-                            vec2 = cluster_data[cluster_id2]
-                            if vec2[identity_idx] == 1:  # Shares this specific identity
-                                distance = np.linalg.norm(embedding[i] - embedding[j])
-                                
-                                # Prefer singleton nodes
-                                if np.sum(vec2) == 1:  # Singleton
-                                    if distance < best_distance:
-                                        best_distance = distance
-                                        best_target = j
-                                else:  # Multi-identity node (backup)
-                                    if distance < backup_distance:
-                                        backup_distance = distance
-                                        backup_target = j
-                    
-                    # Draw line to best target (prefer singleton, fallback to multi)
-                    target = best_target if best_target is not None else backup_target
-                    if target is not None:
-                        # Calculate relative line weight with reasonable cap
-                        max_count = max(info['count'] for info in multi_config_map.values())
-                        relative_weight = count / max_count  # Normalize to 0-1
-                        line_weight = 0.3 + relative_weight * 1.2  # Scale to 0.3-1.5 range
-                        plt.plot([embedding[i, 0], embedding[target, 0]], 
-                               [embedding[i, 1], embedding[target, 1]], 
-                               alpha=0.3, color='gray', linewidth=line_weight)
+            scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
+                                c=point_colors, cmap='viridis', s=100, alpha=0.7)
         
         if label:
             # Add cluster ID labels
@@ -615,112 +516,15 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         fig = plt.figure(figsize=(14, 10))
         ax = fig.add_subplot(111, projection='3d')
         
-        # Draw scatter with different markers for multi-identity nodes if draw_lines is enabled
-        if draw_lines:
-            # Separate multi-identity and singleton nodes for different markers
-            singleton_indices = []
-            multi_indices = []
-            singleton_colors = []
-            multi_colors = []
-            
-            for i, cluster_id in enumerate(cluster_ids):
-                vec = cluster_data[cluster_id]
-                if np.sum(vec) > 1:  # Multi-identity
-                    multi_indices.append(i)
-                    multi_colors.append(point_colors[i] if isinstance(point_colors, list) else point_colors)
-                else:  # Singleton
-                    singleton_indices.append(i)
-                    singleton_colors.append(point_colors[i] if isinstance(point_colors, list) else point_colors)
-            
-            # Draw singleton nodes as circles
-            if singleton_indices:
-                if use_neighborhood_coloring or use_identity_coloring:
-                    scatter1 = ax.scatter(embedding[singleton_indices, 0], embedding[singleton_indices, 1], embedding[singleton_indices, 2],
-                                        c=singleton_colors, s=100, alpha=0.7, marker='o')
-                else:
-                    scatter1 = ax.scatter(embedding[singleton_indices, 0], embedding[singleton_indices, 1], embedding[singleton_indices, 2],
-                                        c=[point_colors[i] for i in singleton_indices], cmap='viridis', s=100, alpha=0.7, marker='o')
-            
-            # Draw multi-identity nodes as squares
-            if multi_indices:
-                if use_neighborhood_coloring or use_identity_coloring:
-                    scatter2 = ax.scatter(embedding[multi_indices, 0], embedding[multi_indices, 1], embedding[multi_indices, 2],
-                                        c=multi_colors, s=100, alpha=0.7, marker='s')
-                else:
-                    scatter2 = ax.scatter(embedding[multi_indices, 0], embedding[multi_indices, 1], embedding[multi_indices, 2],
-                                        c=[point_colors[i] for i in multi_indices], cmap='viridis', s=100, alpha=0.7, marker='s')
-                scatter = scatter2  # For colorbar reference
-            else:
-                scatter = scatter1 if singleton_indices else None
+        if use_neighborhood_coloring:
+            scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
+                               c=point_colors, s=100, alpha=0.7)
+        elif use_identity_coloring:
+            scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
+                               c=point_colors, s=100, alpha=0.7)
         else:
-            # Original behavior when draw_lines is False
-            if use_neighborhood_coloring:
-                scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
-                                   c=point_colors, s=100, alpha=0.7)
-            elif use_identity_coloring:
-                scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
-                                   c=point_colors, s=100, alpha=0.7)
-            else:
-                scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
-                                   c=point_colors, cmap='viridis', s=100, alpha=0.7)
-        
-        # Draw lines between nodes with shared identities (only if draw_lines=True)
-        if draw_lines:
-            # First pass: identify unique multi-identity configurations and their representatives
-            multi_config_map = {}  # Maps tuple(config) -> {'count': int, 'representative_idx': int}
-            
-            for i, cluster_id in enumerate(cluster_ids):
-                vec = cluster_data[cluster_id]
-                if np.sum(vec) > 1:  # Multi-identity node
-                    config = tuple(vec)  # Convert to hashable tuple
-                    if config not in multi_config_map:
-                        multi_config_map[config] = {'count': 1, 'representative_idx': i}
-                    else:
-                        multi_config_map[config]['count'] += 1
-            
-            # Second pass: draw lines for each unique configuration
-            for config, info in multi_config_map.items():
-                i = info['representative_idx']
-                count = info['count']
-                vec1 = np.array(config)
-                
-                # For each identity this configuration has, find the closest representative
-                identity_indices = np.where(vec1 == 1)[0]
-                
-                for identity_idx in identity_indices:
-                    best_target = None
-                    best_distance = float('inf')
-                    backup_target = None
-                    backup_distance = float('inf')
-                    
-                    # Find closest node with this specific identity
-                    for j, cluster_id2 in enumerate(cluster_ids):
-                        if i != j:  # Don't connect to self
-                            vec2 = cluster_data[cluster_id2]
-                            if vec2[identity_idx] == 1:  # Shares this specific identity
-                                distance = np.linalg.norm(embedding[i] - embedding[j])
-                                
-                                # Prefer singleton nodes
-                                if np.sum(vec2) == 1:  # Singleton
-                                    if distance < best_distance:
-                                        best_distance = distance
-                                        best_target = j
-                                else:  # Multi-identity node (backup)
-                                    if distance < backup_distance:
-                                        backup_distance = distance
-                                        backup_target = j
-                    
-                    # Draw line to best target (prefer singleton, fallback to multi)
-                    target = best_target if best_target is not None else backup_target
-                    if target is not None:
-                        # Calculate relative line weight with reasonable cap
-                        max_count = max(info['count'] for info in multi_config_map.values())
-                        relative_weight = count / max_count  # Normalize to 0-1
-                        line_weight = 0.3 + relative_weight * 1.2  # Scale to 0.3-1.5 range
-                        ax.plot([embedding[i, 0], embedding[target, 0]], 
-                               [embedding[i, 1], embedding[target, 1]], 
-                               [embedding[i, 2], embedding[target, 2]], 
-                               alpha=0.3, color='gray', linewidth=line_weight)
+            scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
+                               c=point_colors, cmap='viridis', s=100, alpha=0.7)
         
         if label:
             # Add cluster ID labels

nettracer3d/nettracer.py

@@ -1735,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"""
     
@@ -3925,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
@@ -3945,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.
@@ -3972,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...")
 
@@ -5505,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)
@@ -5895,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):
 
@@ -5920,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():