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

nettracer3d/excelotron.py

@@ -4,7 +4,7 @@ import numpy as np
 from PyQt6.QtWidgets import (QApplication, QMainWindow, QHBoxLayout, QVBoxLayout, 
                            QWidget, QTableWidget, QTableWidgetItem, QPushButton, 
                            QLabel, QLineEdit, QScrollArea, QFrame, QMessageBox,
-                           QHeaderView, QAbstractItemView, QSplitter, QTabWidget)
+                           QHeaderView, QAbstractItemView, QSplitter, QTabWidget, QCheckBox)
 from PyQt6.QtCore import Qt, QMimeData, pyqtSignal
 from PyQt6.QtGui import QDragEnterEvent, QDropEvent, QDrag, QPainter, QPixmap
 import os
@@ -502,6 +502,35 @@ class ClassifierGroupWidget(QFrame):
         
         header_layout.addStretch()
         
+        # Hierarchical toggle
+        self.hierarchical_checkbox = QCheckBox("Hierarchical")
+        self.hierarchical_checkbox.setChecked(True)  # Default to hierarchical
+        self.hierarchical_checkbox.setStyleSheet("""
+            QCheckBox {
+                font-weight: bold;
+                color: #007acc;
+                padding: 5px;
+            }
+            QCheckBox::indicator {
+                width: 18px;
+                height: 18px;
+            }
+            QCheckBox::indicator:unchecked {
+                border: 2px solid #007acc;
+                background-color: white;
+                border-radius: 3px;
+            }
+            QCheckBox::indicator:checked {
+                border: 2px solid #007acc;
+                background-color: #007acc;
+                border-radius: 3px;
+            }
+            QCheckBox::indicator:checked:hover {
+                background-color: #005a9e;
+            }
+        """)
+        header_layout.addWidget(self.hierarchical_checkbox)
+        
         # Add classifier button
         add_btn = QPushButton("+ Add Classifier")
         add_btn.setStyleSheet("""
@@ -559,7 +588,7 @@ class ClassifierGroupWidget(QFrame):
         layout.addWidget(preview_btn)
         
         self.setLayout(layout)
-    
+
     def add_classifier(self):
         self.classifier_counter += 1
         classifier_id = self.classifier_counter
@@ -597,25 +626,50 @@ class ClassifierGroupWidget(QFrame):
         matched_identities = set()
         classifier_usage = {classifier_id: 0 for classifier_id in classifier_ids}  # Now classifier_ids is defined
         
+
         for identity in original_identities:
-            identity_str = str(identity)
-            
-            # Check classifiers in order
-            for classifier_id in classifier_ids:
-                classifier = self.classifiers[classifier_id]
-                
-                if classifier.matches_identity(identity_str):
-                    # This classifier matches
-                    matched_identities.add(identity)
-                    classifier_usage[classifier_id] += 1  # Track usage
+                    identity_str = str(identity)
                     
-                    # Set the new ID if provided
-                    new_id = classifier.get_new_id()
-                    if new_id and identity in self.identity_remap_widget.identity_mappings:
-                        self.identity_remap_widget.identity_mappings[identity]['new_edit'].setText(new_id)
-                    
-                    # Move to next identity (hierarchical - first match wins)
-                    break
+                    # Check classifiers in order
+                    for classifier_id in classifier_ids:
+                        classifier = self.classifiers[classifier_id]
+                        
+                        if classifier.matches_identity(identity_str):
+                            # This classifier matches
+                            matched_identities.add(identity)
+                            classifier_usage[classifier_id] += 1  # Track usage
+                            
+                            # Set the new ID if provided
+                            new_id = classifier.get_new_id()
+                            if new_id and identity in self.identity_remap_widget.identity_mappings:
+                                if self.hierarchical_checkbox.isChecked():
+                                    # Hierarchical mode - just set the new ID
+                                    self.identity_remap_widget.identity_mappings[identity]['new_edit'].setText(new_id)
+                                else:
+                                    # Non-hierarchical mode - append to existing or create new
+                                    current_text = self.identity_remap_widget.identity_mappings[identity]['new_edit'].text().strip()
+                                    if current_text:
+                                        # Parse existing text to see if it's already a list
+                                        try:
+                                            existing_list = literal_eval(current_text)
+                                            if isinstance(existing_list, list):
+                                                existing_list.append(new_id)
+                                                new_text = str(existing_list)
+                                            else:
+                                                # Current text is a single value, make it a list
+                                                new_text = str([current_text, new_id])
+                                        except:
+                                            # If parsing fails, treat as single value
+                                            new_text = str([current_text, new_id])
+                                    else:
+                                        # No existing text, just set the new ID
+                                        new_text = new_id
+                                    
+                                    self.identity_remap_widget.identity_mappings[identity]['new_edit'].setText(new_text)
+                            
+                            # Only break if hierarchical mode (first match wins)
+                            if self.hierarchical_checkbox.isChecked():
+                                break
         
         # Remove identities that didn't match any classifier
         unmatched_identities = set(original_identities) - matched_identities

nettracer3d/neighborhoods.py

@@ -347,7 +347,8 @@ 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):
+                                     neighborhoods: Optional[Dict[int, int]] = None,
+                                     draw_lines: bool = False):
     """
     Convert cluster composition data to UMAP visualization.
     
@@ -370,6 +371,8 @@ 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:
     --------
@@ -453,15 +456,111 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     plt.figure(figsize=(12, 8))
     
     if n_components == 2:
-        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)
+        # 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
         else:
-            scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
-                                c=point_colors, cmap='viridis', s=100, alpha=0.7)
+            # 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)
         
         if label:
             # Add cluster ID labels
@@ -516,15 +615,112 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         fig = plt.figure(figsize=(14, 10))
         ax = fig.add_subplot(111, projection='3d')
         
-        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)
+        # 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
         else:
-            scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
-                               c=point_colors, cmap='viridis', s=100, alpha=0.7)
+            # 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)
         
         if label:
             # Add cluster ID labels

nettracer3d/nettracer.py

@@ -4,6 +4,7 @@ import tifffile
 from scipy import ndimage
 from skimage import measure
 import cv2
+import ast
 import concurrent.futures
 from concurrent.futures import ThreadPoolExecutor, as_completed
 from scipy.ndimage import zoom
@@ -382,6 +383,27 @@ def invert_dict(d):
         inverted.setdefault(value, []).append(key)
     return inverted
 
+def invert_dict_special(d):
+
+    d = invert_dict(d)
+
+    new_dict = copy.deepcopy(d)
+
+    for key, vals in d.items():
+
+        try:
+            idens = ast.literal_eval(key)
+            for iden in idens:
+                try:
+                    new_dict[iden].extend(vals)
+                except:
+                    new_dict[iden] = vals
+            del new_dict[key]
+        except:
+            pass
+    return new_dict
+
+
 def invert_array(array):
     """Internal method used to flip node array indices. 0 becomes 255 and vice versa."""
     inverted_array = np.where(array == 0, 255, 0).astype(np.uint8)
@@ -2117,7 +2139,19 @@ def erode(arrayimage, amount, xy_scale = 1, z_scale = 1, mode = 0):
 
     return arrayimage
 
+def iden_set(idens):
+
+    idens = set(idens)
+    real_iden_set = []
+    for iden in idens:
+        try:
+            options = ast.literal_eval(iden)
+            for opt in options:
+                real_iden_set.append(opt)
+        except:
+            real_iden_set.append(iden)
 
+    return set(real_iden_set)
 
 
 
@@ -5451,7 +5485,7 @@ class Network_3D:
 
         community_dict = invert_dict(self.communities)
         summation = 0
-        id_set = set(self.node_identities.values())
+        id_set = iden_set(self.node_identities.values())
         output = {sort: 0 for sort in id_set}
         template = copy.deepcopy(output)
 
@@ -5463,7 +5497,12 @@ class Network_3D:
             
             # Count identities in this community
             for node in nodes:
-                counter[self.node_identities[node]] += 1
+                try:
+                    idens = ast.literal_eval(self.node_identities[node])
+                    for iden in idens:
+                        counter[iden] += 1
+                except:
+                    counter[self.node_identities[node]] += 1
             
             # Convert to proportions within this community and weight by size
             for sort in counter:
@@ -5492,11 +5531,60 @@ 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):
+
+        try:
+
+            id_set = iden_set(self.node_identities.values())
+
+            template = np.zeros(len(id_set))
+
+            id_dict = {}
+            for i, iden in enumerate(id_set):
+                id_dict[iden] = i
+
+            umap_dict = {}
+
+            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
+
+            neighbor_classes = {}
+            import random
+
+            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
+
+
+            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) 
+
+        except Exception as e:
+            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)
         summation = 0
-        id_set = set(self.node_identities.values())
+        id_set = iden_set(self.node_identities.values())
         id_dict = {}
         for i, iden in enumerate(id_set):
             id_dict[iden] = i
@@ -5515,7 +5603,12 @@ class Network_3D:
 
                 # Count identities in this community
                 for node in nodes:
-                    counter[id_dict[self.node_identities[node]]] += 1 # Keep them as arrays
+                    try:
+                        idens = ast.literal_eval(self.node_identities[node])
+                        for iden in idens:
+                            counter[id_dict[iden]] += 1
+                    except:
+                        counter[id_dict[self.node_identities[node]]] += 1 # Keep them as arrays
 
                 for i in range(len(counter)): # Translate them into proportions out of 1
 
@@ -5527,12 +5620,11 @@ class Network_3D:
                     umap_dict[community] = counter
 
         else:
-            idens = invert_dict(self.node_identities)
+            idens = invert_dict_special(self.node_identities)
             iden_count = {}
             template = {}
             node_count = len(list(self.communities.keys()))
 
-
             for iden in id_set:
                 template[iden] = 0
 
@@ -5548,7 +5640,12 @@ class Network_3D:
                 counter = np.zeros(len(id_set))
 
                 for node in nodes:
-                    iden_tracker[self.node_identities[node]] += 1 
+                    try:
+                        idents = ast.literal_eval(self.node_identities[node])
+                        for iden in idents:
+                            iden_tracker[iden] += 1
+                    except:
+                        iden_tracker[self.node_identities[node]] += 1 
 
                 i = 0
 
@@ -5585,7 +5682,10 @@ class Network_3D:
             if self.communities is not None and label == 2:
                 neighbor_group = {}
                 for node, com in self.communities.items():
-                    neighbor_group[com] = neighbors[node]
+                    try:
+                        neighbor_group[com] = neighbors[node]
+                    except:
+                        neighbor_group[com] = 0
                 neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, neighborhoods = neighbor_group)
             elif label == 1:
                 neighborhoods.visualize_cluster_composition_umap(umap_dict, id_set, label = True) 
@@ -5816,7 +5916,7 @@ class Network_3D:
             return heat_dict, overlay
 
 
-    def merge_node_ids(self, path, data):
+    def merge_node_ids(self, path, data, include = True):
 
         if self.node_identities is None: # Prepare modular dict
 
@@ -5825,9 +5925,17 @@ class Network_3D:
             nodes = list(np.unique(data))
             if 0 in nodes:
                 del nodes[0]
-
             for node in nodes:
-                self.node_identities[node] = ''
+
+                self.node_identities[node] = [] # Assign to lists at first
+        else:
+            for node, iden in self.node_identities.items():
+                try:
+                    self.node_identities[node] = ast.literal_eval(iden)
+                except:
+                    self.node_identities[node] = [iden]
+
+
 
         img_list = directory_info(path)
 
@@ -5837,9 +5945,12 @@ class Network_3D:
             if len(np.unique(mask)) != 2:
 
                 mask = otsu_binarize(mask)
+            else:
+                mask = mask != 0
 
             nodes = data * mask
-            nodes = list(np.unique(nodes))
+            nodes = np.unique(nodes)
+            nodes = nodes.tolist()
             if 0 in nodes:
                 del nodes[0]
 
@@ -5850,21 +5961,43 @@ class Network_3D:
             else:
                 base_name = img
 
+            assigned = {}
+
+
             for node in self.node_identities.keys():
 
                 try:
 
-                    if node in nodes:
+                    if int(node) in nodes:
 
-                        self.node_identities[node] += f" {base_name}+"
+                        self.node_identities[node].append(f'{base_name}+')
 
-                    else:
+                    elif include:
 
-                        self.node_identities[node] += f" {base_name}-"
+                        self.node_identities[node].append(f'{base_name}-')
 
                 except:
                     pass
 
+            modify_dict = copy.deepcopy(self.node_identities)
+
+        for node, iden in self.node_identities.items():
+
+            try:
+
+                if len(iden) == 1:
+
+                    modify_dict[node] = str(iden[0]) # Singleton lists become bare strings
+                elif len(iden) == 0:
+                    del modify_dict[node]
+                else:
+                    modify_dict[node] = str(iden) # We hold multi element lists as strings for compatibility
+
+            except:
+                pass
+
+        self.node_identities = modify_dict
+
 
     def nearest_neighbors_avg(self, root, targ, xy_scale = 1, z_scale = 1, num = 1, heatmap = False, threed = True, numpy = False, quant = False, centroids = True):
 

nettracer3d/nettracer_gui.py

@@ -4011,7 +4011,9 @@ class ImageViewerWindow(QMainWindow):
         id_code_action = overlay_menu.addAction("Code Identities")
         id_code_action.triggered.connect(lambda: self.show_code_dialog(sort = 'Identity'))
         umap_action = overlay_menu.addAction("Centroid UMAP")
-        umap_action.triggered.connect(self.handle_umap)
+        umap_action.triggered.connect(self.handle_centroid_umap)
+        iden_umap_action = overlay_menu.addAction("Identity UMAP (If any nodes were assigned multiple identities)")
+        iden_umap_action.triggered.connect(self.handle_iden_umap)
 
         rand_menu = analysis_menu.addMenu("Randomize")
         random_action = rand_menu.addAction("Generate Equivalent Random Network")
@@ -4542,6 +4544,10 @@ class ImageViewerWindow(QMainWindow):
                 if not self.confirm_calcbranch_dialog("Use of this feature will require additional use of the Nodes and Overlay 2 channels. Please save any data and return, or proceed if you do not need those channels' data"):
                     return
 
+            if my_network.edges is None and my_network.nodes is not None:
+                self.load_channel(1, my_network.nodes, data = True)
+                self.delete_channel(0, False)
+
             my_network.id_overlay = my_network.edges.copy()
 
             self.show_gennodes_dialog()
@@ -4574,6 +4580,10 @@ class ImageViewerWindow(QMainWindow):
                 if not self.confirm_calcbranch_dialog("Use of this feature will require additional use of the Nodes and Overlay 2 channels. Please save any data and return, or proceed if you do not need those channels' data"):
                     return
 
+            if my_network.edges is None and my_network.nodes is not None:
+                self.load_channel(1, my_network.nodes, data = True)
+                self.delete_channel(0, False)
+
             self.show_branch_dialog(called = True)
 
             self.load_channel(0, my_network.edges, data = True)
@@ -5850,8 +5860,8 @@ class ImageViewerWindow(QMainWindow):
             y_max = min(min_height, int(np.ceil(current_ylim[0] + 0.5)))
 
             if self.pan_mode:
-                box_len = (x_max - x_min)
-                box_height = (y_max - y_min)
+                box_len = int((x_max - x_min)/2)
+                box_height = int((y_max - y_min)/2)
                 x_min = max(0, x_min - box_len)
                 x_max = min(self.shape[2], x_max + box_len)
                 y_min = max(0, y_min - box_height)
@@ -6187,13 +6197,20 @@ class ImageViewerWindow(QMainWindow):
         dialog = CodeDialog(self, sort = sort)
         dialog.exec()
 
-    def handle_umap(self):
+    def handle_centroid_umap(self):
 
         if my_network.node_centroids is None:
             self.show_centroid_dialog()
 
         my_network.centroid_umap()
 
+    def handle_iden_umap(self):
+
+        if my_network.node_identities is None:
+            return
+
+        my_network.identity_umap()
+
     def closeEvent(self, event):
         """Override closeEvent to close all windows when main window closes"""
         
@@ -7460,6 +7477,12 @@ class MergeNodeIdDialog(QDialog):
         self.z_scale = QLineEdit(f"{my_network.z_scale}")
         layout.addRow("z_scale:", self.z_scale)
 
+        # Add Run button
+        self.include = QPushButton("Include Negative Gates?")
+        self.include.setCheckable(True)
+        self.include.setChecked(True)
+        layout.addWidget(self.include)
+
         # Add Run button
         run_button = QPushButton("Get Directory")
         run_button.clicked.connect(self.run)
@@ -7475,6 +7498,7 @@ class MergeNodeIdDialog(QDialog):
 
 
             data = self.parent().channel_data[0]
+            include = self.include.isChecked()
 
             if data is None:
                 return
@@ -7493,7 +7517,7 @@ class MergeNodeIdDialog(QDialog):
             if search > 0:
                 data = sdl.smart_dilate(data, 1, 1, GPU = False, fast_dil = False, use_dt_dil_amount = search, xy_scale = xy_scale, z_scale = z_scale)
 
-            my_network.merge_node_ids(selected_path, data)
+            my_network.merge_node_ids(selected_path, data, include)
 
             self.parent().format_for_upperright_table(my_network.node_identities, 'NodeID', 'Identity')
 
@@ -12453,6 +12477,10 @@ class GenNodesDialog(QDialog):
     def run_gennodes(self):
 
         try:
+
+            if my_network.edges is None and my_network.nodes is not None:
+                self.parent().load_channel(1, my_network.nodes, data = True)
+                self.parent().delete_channel(0, True)
             # Get directory (None if empty)
             #directory = self.directory.text() if self.directory.text() else None
             
@@ -12682,6 +12710,10 @@ class BranchDialog(QDialog):
             fix_val = float(self.fix_val.text()) if self.fix_val.text() else None
             seed = int(self.seed.text()) if self.seed.text() else None
 
+            if my_network.edges is None and my_network.nodes is not None:
+                self.parent().load_channel(1, my_network.nodes, data = True)
+                self.parent().delete_channel(0, True)
+
             original_shape = my_network.edges.shape
             original_array = copy.deepcopy(my_network.edges)
 

{nettracer3d-0.9.2.dist-info → nettracer3d-0.9.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.9.2
+Version: 0.9.4
 Summary: Scripts for intializing and analyzing networks from segmentations of three dimensional images.
 Author-email: Liam McLaughlin <liamm@wustl.edu>
 Project-URL: Documentation, https://nettracer3d.readthedocs.io/en/latest/
@@ -110,8 +110,6 @@ McLaughlin, L., Zhang, B., Sharma, S. et al. Three dimensional multiscalar neuro
 
 NetTracer3D was developed by Liam McLaughlin while working under Dr. Sanjay Jain at Washington University School of Medicine.
 
--- Version 0.9.2 Updates --
-	* Image viewer canvas window can now be popped out into a separate window.
-	* Image pyramid calculation is more dynamic instead of using arbitrary size thresholds.
-	* Adjusted pan mode
-	* Some bug fixes.
+-- Version 0.9.4 Updates --
+
+	* Added some compatibility for nodes being assigned 'multiple identities'

{nettracer3d-0.9.2.dist-info → nettracer3d-0.9.4.dist-info}/RECORD

@@ -1,12 +1,12 @@
 nettracer3d/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 nettracer3d/cellpose_manager.py,sha256=NfRqW6Zl7yRU4qHCS_KjmR0R6QANSSgCO0_dr-eivxg,6694
 nettracer3d/community_extractor.py,sha256=QG2v2y9lKb07LRU0zXCAlA_z-96BNqLHh5xP17KLmYA,28147
-nettracer3d/excelotron.py,sha256=X9v_mte8gJBPNGdj6NJNUYja0Z6eorVoKAFx4nHiMnU,72058
+nettracer3d/excelotron.py,sha256=aNof6k-DgMxVyFgsl3ltSCxG4vZW49cuvCBzfzhYhUY,75072
 nettracer3d/modularity.py,sha256=pborVcDBvICB2-g8lNoSVZbIReIBlfeBmjFbPYmtq7Y,22443
 nettracer3d/morphology.py,sha256=jyDjYzrZ4LvI5jOyw8DLsxmo-i5lpqHsejYpW7Tq7Mo,19786
-nettracer3d/neighborhoods.py,sha256=iIaHU1COIdRtzRpAuIQKfLGLNKYFK3dL8Vb_EeJIlEA,46459
-nettracer3d/nettracer.py,sha256=PBlvgCI65pwhMjTBuDl5CnHtv7unU8PMkyGt3Mz_a30,264443
-nettracer3d/nettracer_gui.py,sha256=RBmt--IhiUWlHy0CI_DK6GEXEREWZyQcF7FNdrUK2WA,600327
+nettracer3d/neighborhoods.py,sha256=2QzGKkQCSUerxigkcHF4iN7ys8kv-KHTbkD_9_2Krgo,58365
+nettracer3d/nettracer.py,sha256=wraH1Ba61bA0awmBfH71u_hkKcytUG_pISkJX6iP-ic,268658
+nettracer3d/nettracer_gui.py,sha256=tYg0wDV2p6b0czvozMrrpja7fbx3nSBgjR2ZV4b5vBE,601760
 nettracer3d/network_analysis.py,sha256=kBzsVaq4dZkMe0k-VGvQIUvM-tK0ZZ8bvb-wtsugZRQ,46150
 nettracer3d/network_draw.py,sha256=F7fw6Pcf4qWOhdKwLmhwqWdschbDlHzwCVolQC9imeU,14117
 nettracer3d/node_draw.py,sha256=kZcR1PekLg0riioNeGcALIXQyZ5PtHA_9MT6z7Zovdk,10401
@@ -17,9 +17,9 @@ nettracer3d/segmenter.py,sha256=-Llkhp3TlAIBXZNhcfMFQRdg0vec1xtlOm0c4_bSU9U,7576
 nettracer3d/segmenter_GPU.py,sha256=optCZ_zLIfe99rgqmyKWUZlWW5TF5jEC_C3keu1m7VQ,77771
 nettracer3d/simple_network.py,sha256=dkG4jpc4zzdeuoaQobgGfL3PNo6N8dGKQ5hEEubFIvA,9947
 nettracer3d/smart_dilate.py,sha256=TvRUh6B4q4zIdCO1BWH-xgTdND5OUNmo99eyxG9oIAU,27145
-nettracer3d-0.9.2.dist-info/licenses/LICENSE,sha256=jnNT-yBeIAKAHpYthPvLeqCzJ6nSurgnKmloVnfsjCI,764
-nettracer3d-0.9.2.dist-info/METADATA,sha256=4lxrFb_E22_2wXMY7mW32K2VvG8OJS2l5s2kJeHOd6w,7179
-nettracer3d-0.9.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nettracer3d-0.9.2.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
-nettracer3d-0.9.2.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
-nettracer3d-0.9.2.dist-info/RECORD,,
+nettracer3d-0.9.4.dist-info/licenses/LICENSE,sha256=jnNT-yBeIAKAHpYthPvLeqCzJ6nSurgnKmloVnfsjCI,764
+nettracer3d-0.9.4.dist-info/METADATA,sha256=-xNx22dCKedpkF7uLVduYpMYBCJcXv_2xssw34nEo4c,7048
+nettracer3d-0.9.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nettracer3d-0.9.4.dist-info/entry_points.txt,sha256=Nx1rr_0QhJXDBHAQg2vcqCzLMKBzSHfwy3xwGkueVyc,53
+nettracer3d-0.9.4.dist-info/top_level.txt,sha256=zsYy9rZwirfCEOubolhee4TyzqBAL5gSUeFMzhFTX8c,12
+nettracer3d-0.9.4.dist-info/RECORD,,