nettracer3d 0.8.4__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
@@ -654,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
@@ -684,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/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
 

nettracer3d/nettracer.py

@@ -105,7 +105,7 @@ def process_label(args):
     print(f"Processing node {label}")
     
     # Get the pre-computed bounding box for this label
-    slice_obj = bounding_boxes[label-1]  # -1 because label numbers start at 1
+    slice_obj = bounding_boxes[int(label)-1]  # -1 because label numbers start at 1
     if slice_obj is None:
         return None, None, None
         
@@ -130,7 +130,7 @@ def create_node_dictionary(nodes, edges, num_nodes, dilate_xy, dilate_z):
     with ThreadPoolExecutor(max_workers=mp.cpu_count()) as executor:
         # Create args list with bounding_boxes included
         args_list = [(nodes, edges, i, dilate_xy, dilate_z, array_shape, bounding_boxes) 
-                    for i in range(1, num_nodes + 1)]
+                    for i in range(1, int(num_nodes) + 1)]
 
         # Execute parallel tasks to process labels
         results = executor.map(process_label, args_list)
@@ -5152,7 +5152,7 @@ class Network_3D:
             search_x, search_z = dilation_length_to_pixels(self._xy_scale, self._z_scale, search, search)
 
 
-        num_nodes = np.max(self._nodes)
+        num_nodes = int(np.max(self._nodes))
 
         my_dict = proximity.create_node_dictionary(self._nodes, num_nodes, search_x, search_z, targets = targets, fastdil = fastdil, xy_scale = self._xy_scale, z_scale = self._z_scale, search = search)
 
@@ -5299,6 +5299,13 @@ class Network_3D:
 
         return output
 
+    def centroid_umap(self):
+
+        from . import neighborhoods
+
+        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 community_id_info_per_com(self, umap = False, label = False, limit = 0, proportional = False):
 
         community_dict = invert_dict(self.communities)