nettracer3d 0.8.3__py3-none-any.whl → 0.8.5__py3-none-any.whl

nettracer3d/community_extractor.py

@@ -12,6 +12,7 @@ import random
 from . import node_draw
 
 
+
 def binarize(image):
     """Convert an array from numerical values to boolean mask"""
     image = image != 0
@@ -462,7 +463,6 @@ def get_color_name_mapping():
         'bright_cyan': (0, 255, 255),
         'dark_teal': (0, 128, 128),
         'turquoise': (64, 224, 208),
-        'aqua': (0, 255, 255),
         'seafoam': (159, 226, 191),
         'teal_blue': (54, 117, 136),
         
@@ -655,7 +655,7 @@ def assign_node_colors(node_list: List[int], labeled_array: np.ndarray) -> Tuple
     
     # Create lookup table
     max_label = max(max(labeled_array.flat), max(node_list) if node_list else 0)
-    color_lut = np.zeros((max_label + 1, 4), dtype=np.uint8)  # Transparent by default
+    color_lut = np.zeros((int(max_label) + 1, 4), dtype=np.uint8)  # Transparent by default
     
     for node_id, color in node_to_color.items():
         color_lut[node_id] = color
@@ -685,7 +685,7 @@ def assign_community_colors(community_dict: Dict[int, int], labeled_array: np.nd
     
     # Create lookup table - this is the key optimization
     max_label = max(max(labeled_array.flat), max(node_to_color.keys()) if node_to_color else 0)
-    color_lut = np.zeros((max_label + 1, 4), dtype=np.uint8)  # Transparent by default
+    color_lut = np.zeros((int(max_label) + 1, 4), dtype=np.uint8)  # Transparent by default
     
     for node_id, color in node_to_color.items():
         color_lut[node_id] = color

nettracer3d/excelotron.py

@@ -1238,7 +1238,7 @@ class TabbedIdentityWidget(QFrame):
 
 class ExcelToDictGUI(QMainWindow):
     # Add this signal
-    data_exported = pyqtSignal(dict, str)  # dictionary, property_name
+    data_exported = pyqtSignal(dict, str, bool)  # dictionary, property_name, add_status
     
     def __init__(self):
         super().__init__()
@@ -1255,6 +1255,7 @@ class ExcelToDictGUI(QMainWindow):
         
         self.setWindowTitle("Excel to Python Dictionary Converter")
         self.setGeometry(100, 100, 1200, 800)
+        self.add = False
         
         self.setup_ui()
 
@@ -1414,6 +1415,14 @@ class ExcelToDictGUI(QMainWindow):
         self.export_btn.clicked.connect(self.export_dictionary)
         export_layout.addWidget(self.export_btn)
 
+        self.add_button = QPushButton("+")
+        self.add_button.setFixedSize(20, 20)
+        self.add_button.setCheckable(True)
+        self.add_button.setChecked(False)
+        self.add_button.clicked.connect(self.toggle_add)
+        export_layout.addWidget(self.add_button)
+
+
         right_layout.addLayout(export_layout)
 
         right_widget.setLayout(right_layout)
@@ -1431,6 +1440,15 @@ class ExcelToDictGUI(QMainWindow):
         # Add splitter to main layout
         main_layout.addWidget(splitter)
 
+    def toggle_add(self):
+
+        if self.add_button.isChecked():
+            print("Exported Properties will be added onto existing ones")
+            self.add = True
+        else:
+            print("Exported Properties will be override existing ones")
+            self.add = False
+
     def load_template(self, template_name):
         if template_name in self.templates:
             # Clear existing columns
@@ -1681,12 +1699,13 @@ class ExcelToDictGUI(QMainWindow):
                 return
                 
             # Emit signal to parent application
-            self.data_exported.emit(result_dict, property_name)
+            self.data_exported.emit(result_dict, property_name, self.add)
             
             # Still store in global variables for backward compatibility
             import builtins
             builtins.excel_dict = result_dict
             builtins.target_property = property_name
+            builtins.add = self.add
             
             # Show success message with preview
             preview = str(result_dict)

nettracer3d/neighborhoods.py

@@ -2,11 +2,13 @@ import numpy as np
 from sklearn.cluster import KMeans
 from sklearn.metrics import calinski_harabasz_score
 import matplotlib.pyplot as plt
-from typing import Dict, Set
+from typing import Dict, Set, List, Tuple, Optional
 import umap
 from matplotlib.colors import LinearSegmentedColormap
 from sklearn.cluster import DBSCAN
 from sklearn.neighbors import NearestNeighbors
+import matplotlib.colors as mcolors
+
 
 
 import os
@@ -308,11 +310,43 @@ def plot_dict_heatmap(unsorted_data_dict, id_set, figsize=(12, 8), title="Neighb
     
 
 
+def generate_distinct_colors(n_colors: int) -> List[str]:
+    """
+    Generate visually distinct colors using matplotlib's tab and Set colormaps.
+    Falls back to HSV generation for large numbers of colors.
+    
+    Args:
+        n_colors: Number of distinct colors needed
+    
+    Returns:
+        List of color strings compatible with matplotlib
+    """
+    if n_colors <= 10:
+        # Use tab10 colormap for up to 10 colors
+        colors = plt.cm.tab10(np.linspace(0, 1, min(n_colors, 10)))
+        return [mcolors.rgb2hex(color) for color in colors[:n_colors]]
+    elif n_colors <= 20:
+        # Use tab20 for up to 20 colors
+        colors = plt.cm.tab20(np.linspace(0, 1, min(n_colors, 20)))
+        return [mcolors.rgb2hex(color) for color in colors[:n_colors]]
+    else:
+        # For larger numbers, use HSV space
+        colors = []
+        for i in range(n_colors):
+            hue = i / n_colors
+            color = mcolors.hsv_to_rgb([hue, 0.8, 0.9])  # High saturation and value
+            colors.append(mcolors.rgb2hex(color))
+        return colors
+
+
 def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray], 
                                      class_names: Set[str],
-                                     label = False,
+                                     label: bool = False,
                                      n_components: int = 2,
-                                     random_state: int = 42):
+                                     random_state: int = 42,
+                                     id_dictionary: Optional[Dict[int, str]] = None, 
+                                     graph_label = "Community ID",
+                                     title = 'UMAP Visualization of Community Compositions'):
     """
     Convert cluster composition data to UMAP visualization.
     
@@ -323,10 +357,15 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         representing the composition of each cluster
     class_names : set
         Set of strings representing the class names (order corresponds to array indices)
+    label : bool
+        Whether to show cluster ID labels on the plot
     n_components : int
         Number of UMAP components (default: 2 for 2D visualization)
     random_state : int
         Random state for reproducibility
+    id_dictionary : dict, optional
+        Dictionary mapping cluster IDs to identity names. If provided, colors will be
+        assigned by identity rather than cluster ID, and a legend will be shown.
     
     Returns:
     --------
@@ -335,7 +374,10 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     """
     
     # Convert set to sorted list for consistent ordering
-    class_labels = sorted(list(class_names))
+    try:
+        class_labels = sorted(list(class_names))
+    except:
+        class_labels = None
     
     # Extract cluster IDs and compositions
     cluster_ids = list(cluster_data.keys())
@@ -347,57 +389,124 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     # Fit and transform the composition data
     embedding = reducer.fit_transform(compositions)
     
+    # Prepare colors and labels based on whether id_dictionary is provided
+    if id_dictionary is not None:
+        # Get unique identities and assign colors (group all unknown into single "Unknown" category)
+        identities = [id_dictionary.get(cluster_id, "Unknown") for cluster_id in cluster_ids]
+        unique_identities = sorted(list(set(identities)))
+        colors = generate_distinct_colors(len(unique_identities))
+        identity_to_color = {identity: colors[i] for i, identity in enumerate(unique_identities)}
+        point_colors = [identity_to_color[identity] for identity in identities]
+        use_identity_coloring = True
+    else:
+        # Use default cluster ID coloring
+        point_colors = cluster_ids
+        use_identity_coloring = False
+    
     # Create visualization
-    plt.figure(figsize=(10, 8))
+    plt.figure(figsize=(12, 8))
     
     if n_components == 2:
-        scatter = plt.scatter(embedding[:, 0], embedding[:, 1], 
-                            c=cluster_ids, cmap='viridis', s=100, alpha=0.7)
+        if 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)
         
         if label:
             # Add cluster ID labels
             for i, cluster_id in enumerate(cluster_ids):
-                plt.annotate(f'{cluster_id}', 
+                display_label = f'{cluster_id}'
+                if id_dictionary is not None:
+                    identity = id_dictionary.get(cluster_id, "Unknown")
+                    display_label = f'{cluster_id}\n({identity})'
+                
+                plt.annotate(display_label, 
                             (embedding[i, 0], embedding[i, 1]),
                             xytext=(5, 5), textcoords='offset points',
-                            fontsize=9, alpha=0.8)
+                            fontsize=9, alpha=0.8, ha='left')
+        
+        # Add appropriate legend/colorbar
+        if use_identity_coloring:
+            # Create custom legend for identities
+            legend_elements = [plt.Line2D([0], [0], marker='o', color='w', 
+                                        markerfacecolor=identity_to_color[identity], 
+                                        markersize=10, label=identity)
+                             for identity in unique_identities]
+            plt.legend(handles=legend_elements, title='Identity', 
+                      bbox_to_anchor=(1.05, 1), loc='upper left')
+        else:
+            plt.colorbar(scatter, label=graph_label)
         
-        plt.colorbar(scatter, label='Community ID')
         plt.xlabel('UMAP Component 1')
         plt.ylabel('UMAP Component 2')
-        plt.title('UMAP Visualization of Community Compositions')
+        if use_identity_coloring:
+            title += ' (Colored by Identity)'
+        plt.title(title)
         
     elif n_components == 3:
-        fig = plt.figure(figsize=(12, 9))
+        fig = plt.figure(figsize=(14, 10))
         ax = fig.add_subplot(111, projection='3d')
-        scatter = ax.scatter(embedding[:, 0], embedding[:, 1], embedding[:, 2],
-                           c=cluster_ids, cmap='viridis', s=100, alpha=0.7)
         
-        # Add cluster ID labels
-        for i, cluster_id in enumerate(cluster_ids):
-            ax.text(embedding[i, 0], embedding[i, 1], embedding[i, 2],
-                   f'C{cluster_id}', fontsize=8)
+        if 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)
+        
+        if label:
+            # Add cluster ID labels
+            for i, cluster_id in enumerate(cluster_ids):
+                display_label = f'C{cluster_id}'
+                if id_dictionary is not None:
+                    identity = id_dictionary.get(cluster_id, "Unknown")
+                    display_label = f'C{cluster_id}\n({identity})'
+                
+                ax.text(embedding[i, 0], embedding[i, 1], embedding[i, 2],
+                       display_label, fontsize=8)
         
         ax.set_xlabel('UMAP Component 1')
         ax.set_ylabel('UMAP Component 2')
         ax.set_zlabel('UMAP Component 3')
-        ax.set_title('3D UMAP Visualization of Cluster Compositions')
-        plt.colorbar(scatter, label='Cluster ID')
+        title = '3D UMAP Visualization of Cluster Compositions'
+        if use_identity_coloring:
+            title += ' (Colored by Identity)'
+        ax.set_title(title)
+        
+        # Add appropriate legend/colorbar
+        if use_identity_coloring:
+            # Create custom legend for identities
+            legend_elements = [plt.Line2D([0], [0], marker='o', color='w', 
+                                        markerfacecolor=identity_to_color[identity], 
+                                        markersize=10, label=identity)
+                             for identity in unique_identities]
+            ax.legend(handles=legend_elements, title='Identity', 
+                     bbox_to_anchor=(1.05, 1), loc='upper left')
+        else:
+            plt.colorbar(scatter, label='Cluster ID')
     
     plt.tight_layout()
     plt.show()
     
-    # Print composition details
-    print("Cluster Compositions:")
-    print(f"Classes: {class_labels}")
-    for i, cluster_id in enumerate(cluster_ids):
-        composition = compositions[i]
-        print(f"Cluster {cluster_id}: {composition}")
-        # Show which classes dominate this cluster
-        dominant_indices = np.argsort(composition)[::-1][:2]  # Top 2
-        dominant_classes = [class_labels[idx] for idx in dominant_indices]
-        dominant_values = [composition[idx] for idx in dominant_indices]
-        print(f"  Dominant: {dominant_classes[0]} ({dominant_values[0]:.3f}), {dominant_classes[1]} ({dominant_values[1]:.3f})")
+    if class_labels is not None:
+        # Print composition details
+        print("Cluster Compositions:")
+        print(f"Classes: {class_labels}")
+        for i, cluster_id in enumerate(cluster_ids):
+            composition = compositions[i]
+            identity_info = ""
+            if id_dictionary is not None:
+                identity = id_dictionary.get(cluster_id, "Unknown")
+                identity_info = f" (Identity: {identity})"
+            
+            print(f"Cluster {cluster_id}{identity_info}: {composition}")
+            # Show which classes dominate this cluster
+            dominant_indices = np.argsort(composition)[::-1][:2]  # Top 2
+            dominant_classes = [class_labels[idx] for idx in dominant_indices]
+            dominant_values = [composition[idx] for idx in dominant_indices]
+            print(f"  Dominant: {dominant_classes[0]} ({dominant_values[0]:.3f}), {dominant_classes[1]} ({dominant_values[1]:.3f})")
     
     return embedding