nettracer3d 0.8.9__py3-none-any.whl → 0.9.1__py3-none-any.whl

nettracer3d/cellpose_manager.py

@@ -16,14 +16,15 @@ class CellposeGUILauncher:
         """
         self.parent_widget = parent_widget
         self.cellpose_process = None
-    
-    def launch_cellpose_gui(self, image_path=None, working_directory=None):
+        
+    def launch_cellpose_gui(self, image_path=None, working_directory=None, use_3d=False):
         """
         Launch cellpose GUI in a separate thread.
         
         Args:
             image_path (str, optional): Path to image file to load automatically
             working_directory (str, optional): Directory to start cellpose in
+            use_3d (bool, optional): Whether to launch cellpose 3D version (default: False)
         
         Returns:
             bool: True if launch was initiated successfully
@@ -34,6 +35,10 @@ class CellposeGUILauncher:
                 # Build command
                 cmd = [sys.executable, "-m", "cellpose"]
                 
+                # Add 3D flag if requested
+                if use_3d:
+                    cmd.append("--Zstack")
+                
                 # Add image path if provided
                 if image_path and Path(image_path).exists():
                     cmd.extend(["--image_path", str(image_path)])
@@ -55,29 +60,35 @@ class CellposeGUILauncher:
             except Exception as e:
                 if self.parent_widget:
                     # Show error in main thread
-                    self.show_error(f"Failed to launch cellpose GUI: {str(e)}")
+                    version_str = "3D " if use_3d else ""
+                    self.show_error(f"Failed to launch cellpose {version_str}GUI: {str(e)}")
                 else:
-                    print(f"Failed to launch cellpose GUI: {str(e)}")
+                    version_str = "3D " if use_3d else ""
+                    print(f"Failed to launch cellpose {version_str}GUI: {str(e)}")
         
         try:
             # Start cellpose in separate thread
             thread = threading.Thread(target=run_cellpose, daemon=True)
             thread.start()
             
-            if self.parent_widget:
-                self.show_info("Cellpose GUI launched!")
-            else:
-                print("Cellpose GUI launched!")
+            #if self.parent_widget:
+                #version_str = "3D " if use_3d else ""
+                #self.show_info(f"Cellpose {version_str}GUI launched!")
+            #else:
+                #version_str = "3D " if use_3d else ""
+                #print(f"Cellpose {version_str}GUI launched!")
             
             return True
             
         except Exception as e:
             if self.parent_widget:
-                self.show_error(f"Failed to start cellpose thread: {str(e)}")
+                version_str = "3D " if use_3d else ""
+                self.show_error(f"Failed to start cellpose {version_str}thread: {str(e)}")
             else:
-                print(f"Failed to start cellpose thread: {str(e)}")
+                version_str = "3D " if use_3d else ""
+                print(f"Failed to start cellpose {version_str}thread: {str(e)}")
             return False
-    
+        
     def launch_with_directory(self, directory_path):
         """
         Launch cellpose GUI with a specific directory.

nettracer3d/modularity.py

@@ -103,7 +103,7 @@ def read_excel_to_lists(file_path, sheet_name=0):
 
 
 
-def show_communities_flex(G, master_list, normalized_weights, geo_info = None, geometric=False, directory=None, weighted=True, partition=None, style=0):
+def show_communities_flex(G, master_list, normalized_weights, geo_info=None, geometric=False, directory=None, weighted=True, partition=None, style=0):
 
     if normalized_weights is None:
         G, edge_weights = network_analysis.weighted_network(master_list)
@@ -137,10 +137,25 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info = None, g
 
     # Create a mapping of community IDs to sequential indices
     unique_communities = sorted(set(partition.values()))
-    community_to_index = {comm: idx for idx, comm in enumerate(unique_communities)}
-
-    # Prepare colors using the number of unique communities
-    colors = [plt.cm.jet(i / len(unique_communities)) for i in range(len(unique_communities))]
+    
+    # Use the same color generation method as the overlay system
+    # Get community sizes for sorting (largest first)
+    from collections import Counter
+    community_sizes = Counter(partition.values())
+    sorted_communities = sorted(unique_communities, key=lambda x: community_sizes[x], reverse=True)
+    
+    from . import community_extractor
+
+    # Generate distinct colors using the same method as assign_community_colors
+    colors_rgb = community_extractor.generate_distinct_colors(len(unique_communities))
+    
+    # Create community to color mapping (same order as the overlay system)
+    community_to_color = {comm: colors_rgb[i] for i, comm in enumerate(sorted_communities)}
+    
+    # Convert RGB tuples to matplotlib format (0-1 range)
+    colors_matplotlib = {}
+    for comm, rgb in community_to_color.items():
+        colors_matplotlib[comm] = tuple(c/255.0 for c in rgb)
 
     if weighted:
         G = nx.Graph()
@@ -156,7 +171,7 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info = None, g
             for community_id, nodes in communities.items():
                 node_sizes_list = [z_pos[node] for node in nodes]
                 nx.draw_networkx_nodes(G, pos, nodelist=nodes, 
-                                     node_color=[colors[community_to_index[community_id]]], 
+                                     node_color=[colors_matplotlib[community_id]], 
                                      node_size=node_sizes_list, alpha=0.8)
 
             # Draw edges with normalized weights
@@ -172,7 +187,7 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info = None, g
             # Draw the nodes, coloring them according to their community
             for community_id, nodes in communities.items():
                 nx.draw_networkx_nodes(G, pos, nodelist=nodes, 
-                                     node_color=[colors[community_to_index[community_id]]], 
+                                     node_color=[colors_matplotlib[community_id]], 
                                      node_size=100, alpha=0.8)
 
             # Draw edges with normalized weights
@@ -183,8 +198,8 @@ def show_communities_flex(G, master_list, normalized_weights, geo_info = None, g
             nx.draw_networkx_labels(G, pos)
 
     else:
-        # Create node color list based on partition and mapping
-        node_colors = [colors[community_to_index[partition[node]]] for node in G.nodes()]
+        # Create node color list based on partition and the same color mapping
+        node_colors = [colors_matplotlib[partition[node]] for node in G.nodes()]
 
         if geometric:
             pos, z_pos = simple_network.geometric_positions(geo_info[0], geo_info[1])

nettracer3d/neighborhoods.py

@@ -346,7 +346,8 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
                                      random_state: int = 42,
                                      id_dictionary: Optional[Dict[int, str]] = None, 
                                      graph_label = "Community ID",
-                                     title = 'UMAP Visualization of Community Compositions'):
+                                     title = 'UMAP Visualization of Community Compositions',
+                                     neighborhoods: Optional[Dict[int, int]] = None):
     """
     Convert cluster composition data to UMAP visualization.
     
@@ -366,6 +367,9 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
     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.
+    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.
     
     Returns:
     --------
@@ -389,25 +393,70 @@ 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)
+    # Determine coloring scheme based on parameters
+    if neighborhoods is not None:
+        # Use neighborhood coloring - import the community extractor methods
+        from . import community_extractor
+        
+        # Filter neighborhoods to only include cluster_ids that exist in our data
+        filtered_neighborhoods = {node_id: neighborhood_id 
+                                for node_id, neighborhood_id in neighborhoods.items() 
+                                if node_id in cluster_ids}
+        
+        # Create a dummy labeled array just for the coloring function
+        # We only need the coloring logic, not actual clustering
+        dummy_array = np.array(cluster_ids)
+        
+        # Get colors using the community coloration method
+        _, neighborhood_color_names = community_extractor.assign_community_colors(
+            filtered_neighborhoods, dummy_array
+        )
+        
+        # Create color mapping for our points
+        unique_neighborhoods = sorted(list(set(filtered_neighborhoods.values())))
+        colors = community_extractor.generate_distinct_colors(len(unique_neighborhoods))
+        neighborhood_to_color = {neighborhood: colors[i] for i, neighborhood in enumerate(unique_neighborhoods)}
+        
+        # Map each cluster to its neighborhood color
+        point_colors = []
+        neighborhood_labels = []
+        for cluster_id in cluster_ids:
+            if cluster_id in filtered_neighborhoods:
+                neighborhood_id = filtered_neighborhoods[cluster_id]
+                point_colors.append(neighborhood_to_color[neighborhood_id])
+                neighborhood_labels.append(neighborhood_id)
+            else:
+                # Default color for nodes not in any neighborhood
+                point_colors.append((128, 128, 128))  # Gray
+                neighborhood_labels.append("Unknown")
+        
+        # Normalize RGB values for matplotlib (0-1 range)
+        point_colors = [(r/255.0, g/255.0, b/255.0) for r, g, b in point_colors]
+        use_neighborhood_coloring = True
+        
+    elif id_dictionary is not None:
+        # Use identity coloring (existing logic)
         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
+        use_neighborhood_coloring = False
     else:
         # Use default cluster ID coloring
         point_colors = cluster_ids
         use_identity_coloring = False
+        use_neighborhood_coloring = False
     
     # Create visualization
     plt.figure(figsize=(12, 8))
     
     if n_components == 2:
-        if use_identity_coloring:
+        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:
@@ -418,7 +467,10 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
             # Add cluster ID labels
             for i, cluster_id in enumerate(cluster_ids):
                 display_label = f'{cluster_id}'
-                if id_dictionary is not None:
+                if use_neighborhood_coloring and cluster_id in filtered_neighborhoods:
+                    neighborhood_id = filtered_neighborhoods[cluster_id]
+                    display_label = f'{cluster_id}\n(N{neighborhood_id})'
+                elif id_dictionary is not None:
                     identity = id_dictionary.get(cluster_id, "Unknown")
                     display_label = f'{cluster_id}\n({identity})'
                 
@@ -428,7 +480,20 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
                             fontsize=9, alpha=0.8, ha='left')
         
         # Add appropriate legend/colorbar
-        if use_identity_coloring:
+        if use_neighborhood_coloring:
+            # Create custom legend for neighborhoods
+            legend_elements = []
+            for neighborhood_id in unique_neighborhoods:
+                color = neighborhood_to_color[neighborhood_id]
+                norm_color = (color[0]/255.0, color[1]/255.0, color[2]/255.0)
+                legend_elements.append(
+                    plt.Line2D([0], [0], marker='o', color='w', 
+                              markerfacecolor=norm_color, 
+                              markersize=10, label=f'Neighborhood {neighborhood_id}')
+                )
+            plt.legend(handles=legend_elements, title='Neighborhoods', 
+                      bbox_to_anchor=(1.05, 1), loc='upper left')
+        elif use_identity_coloring:
             # Create custom legend for identities
             legend_elements = [plt.Line2D([0], [0], marker='o', color='w', 
                                         markerfacecolor=identity_to_color[identity], 
@@ -441,7 +506,9 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         
         plt.xlabel('UMAP Component 1')
         plt.ylabel('UMAP Component 2')
-        if use_identity_coloring:
+        if use_neighborhood_coloring:
+            title += ' (Colored by Neighborhood)'
+        elif use_identity_coloring:
             title += ' (Colored by Identity)'
         plt.title(title)
         
@@ -449,7 +516,10 @@ 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_identity_coloring:
+        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:
@@ -460,7 +530,10 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
             # Add cluster ID labels
             for i, cluster_id in enumerate(cluster_ids):
                 display_label = f'C{cluster_id}'
-                if id_dictionary is not None:
+                if use_neighborhood_coloring and cluster_id in filtered_neighborhoods:
+                    neighborhood_id = filtered_neighborhoods[cluster_id]
+                    display_label = f'C{cluster_id}\n(N{neighborhood_id})'
+                elif id_dictionary is not None:
                     identity = id_dictionary.get(cluster_id, "Unknown")
                     display_label = f'C{cluster_id}\n({identity})'
                 
@@ -471,12 +544,27 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         ax.set_ylabel('UMAP Component 2')
         ax.set_zlabel('UMAP Component 3')
         title = '3D UMAP Visualization of Cluster Compositions'
-        if use_identity_coloring:
+        if use_neighborhood_coloring:
+            title += ' (Colored by Neighborhood)'
+        elif use_identity_coloring:
             title += ' (Colored by Identity)'
         ax.set_title(title)
         
         # Add appropriate legend/colorbar
-        if use_identity_coloring:
+        if use_neighborhood_coloring:
+            # Create custom legend for neighborhoods
+            legend_elements = []
+            for neighborhood_id in unique_neighborhoods:
+                color = neighborhood_to_color[neighborhood_id]
+                norm_color = (color[0]/255.0, color[1]/255.0, color[2]/255.0)
+                legend_elements.append(
+                    plt.Line2D([0], [0], marker='o', color='w', 
+                              markerfacecolor=norm_color, 
+                              markersize=10, label=f'Neighborhood {neighborhood_id}')
+                )
+            ax.legend(handles=legend_elements, title='Neighborhoods', 
+                     bbox_to_anchor=(1.05, 1), loc='upper left')
+        elif use_identity_coloring:
             # Create custom legend for identities
             legend_elements = [plt.Line2D([0], [0], marker='o', color='w', 
                                         markerfacecolor=identity_to_color[identity], 
@@ -496,12 +584,15 @@ def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray],
         print(f"Classes: {class_labels}")
         for i, cluster_id in enumerate(cluster_ids):
             composition = compositions[i]
-            identity_info = ""
-            if id_dictionary is not None:
+            additional_info = ""
+            if use_neighborhood_coloring and cluster_id in filtered_neighborhoods:
+                neighborhood_id = filtered_neighborhoods[cluster_id]
+                additional_info = f" (Neighborhood: {neighborhood_id})"
+            elif id_dictionary is not None:
                 identity = id_dictionary.get(cluster_id, "Unknown")
-                identity_info = f" (Identity: {identity})"
+                additional_info = f" (Identity: {identity})"
             
-            print(f"Cluster {cluster_id}{identity_info}: {composition}")
+            print(f"Cluster {cluster_id}{additional_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]
@@ -644,25 +735,41 @@ def create_community_heatmap(community_intensity, node_community, node_centroids
         
         # Create colormap function (RdBu_r - red for high, blue for low, yellow/white for middle)
         def intensity_to_rgb(intensity, min_val, max_val):
-            """Convert intensity value to RGB using RdBu_r colormap logic"""
+            """Convert intensity value to RGB using RdBu_r colormap logic, centered at 0"""
+            
+            # Handle edge case where all values are the same
             if max_val == min_val:
-                # All same value, use neutral color
+                if intensity == 0:
+                    return np.array([255, 255, 255], dtype=np.uint8)  # White for 0
+                elif intensity > 0:
+                    return np.array([255, 200, 200], dtype=np.uint8)  # Light red for positive
+                else:
+                    return np.array([200, 200, 255], dtype=np.uint8)  # Light blue for negative
+            
+            # Find the maximum absolute value for symmetric scaling around 0
+            max_abs = max(abs(min_val), abs(max_val))
+            
+            # If max_abs is 0, everything is 0, so return white
+            if max_abs == 0:
                 return np.array([255, 255, 255], dtype=np.uint8)  # White
             
-            # Normalize to -1 to 1 range (like RdBu_r colormap)
-            normalized = 2 * (intensity - min_val) / (max_val - min_val) - 1
+            # Normalize intensity to -1 to 1 range, centered at 0
+            normalized = intensity / max_abs
             normalized = np.clip(normalized, -1, 1)
             
             if normalized > 0:
-                # Positive values: white to red
+                # Positive values: white to red (intensity 0 = white, max positive = red)
                 r = 255
                 g = int(255 * (1 - normalized))
                 b = int(255 * (1 - normalized))
-            else:
-                # Negative values: white to blue
+            elif normalized < 0:
+                # Negative values: white to blue (intensity 0 = white, max negative = blue)  
                 r = int(255 * (1 + normalized))
                 g = int(255 * (1 + normalized))
                 b = 255
+            else:
+                # Exactly 0: white
+                r, g, b = 255, 255, 255
             
             return np.array([r, g, b], dtype=np.uint8)
         
@@ -868,25 +975,41 @@ def create_node_heatmap(node_intensity, node_centroids, shape=None, is_3d=True,
         
         # Create colormap function (RdBu_r - red for high, blue for low, yellow/white for middle)
         def intensity_to_rgb(intensity, min_val, max_val):
-            """Convert intensity value to RGB using RdBu_r colormap logic"""
+            """Convert intensity value to RGB using RdBu_r colormap logic, centered at 0"""
+            
+            # Handle edge case where all values are the same
             if max_val == min_val:
-                # All same value, use neutral color
+                if intensity == 0:
+                    return np.array([255, 255, 255], dtype=np.uint8)  # White for 0
+                elif intensity > 0:
+                    return np.array([255, 200, 200], dtype=np.uint8)  # Light red for positive
+                else:
+                    return np.array([200, 200, 255], dtype=np.uint8)  # Light blue for negative
+            
+            # Find the maximum absolute value for symmetric scaling around 0
+            max_abs = max(abs(min_val), abs(max_val))
+            
+            # If max_abs is 0, everything is 0, so return white
+            if max_abs == 0:
                 return np.array([255, 255, 255], dtype=np.uint8)  # White
             
-            # Normalize to -1 to 1 range (like RdBu_r colormap)
-            normalized = 2 * (intensity - min_val) / (max_val - min_val) - 1
+            # Normalize intensity to -1 to 1 range, centered at 0
+            normalized = intensity / max_abs
             normalized = np.clip(normalized, -1, 1)
             
             if normalized > 0:
-                # Positive values: white to red
+                # Positive values: white to red (intensity 0 = white, max positive = red)
                 r = 255
                 g = int(255 * (1 - normalized))
                 b = int(255 * (1 - normalized))
-            else:
-                # Negative values: white to blue
+            elif normalized < 0:
+                # Negative values: white to blue (intensity 0 = white, max negative = blue)  
                 r = int(255 * (1 + normalized))
                 g = int(255 * (1 + normalized))
                 b = 255
+            else:
+                # Exactly 0: white
+                r, g, b = 255, 255, 255
             
             return np.array([r, g, b], dtype=np.uint8)