nettracer3d 0.8.9__tar.gz → 0.9.1__tar.gz

{nettracer3d-0.8.9/src/nettracer3d.egg-info → nettracer3d-0.9.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.8.9
+Version: 0.9.1
 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,6 +110,9 @@ 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.8.9 Updates -- 
-
-	* See Documentation Once Updated
+-- Version 0.9.1 Updates --
+	* Adjusted the segment by 3D function to now show the 3D chunks in the preview mode. Previously it showed 2D segmentations in the preview which finished the current plane faster but didn't show accurate training data.
+	* Adjusted the neighborhood heatmap predicted range value to now just simulate a uniform distribution rather than trying to use a mathematical algorithm. 
+	* The image display window now uses image pyramids and cropping for zoom ins so it should run a lot faster on bigger images.
+	* The community UMAP can now color them by neighborhood.
+	* No longer zooms all the way out by default with right click in zoom mode. Now user needs to Shift + Right Click.

{nettracer3d-0.8.9 → nettracer3d-0.9.1}/README.md

@@ -65,6 +65,9 @@ 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.8.9 Updates -- 
-
-	* See Documentation Once Updated
+-- Version 0.9.1 Updates --
+	* Adjusted the segment by 3D function to now show the 3D chunks in the preview mode. Previously it showed 2D segmentations in the preview which finished the current plane faster but didn't show accurate training data.
+	* Adjusted the neighborhood heatmap predicted range value to now just simulate a uniform distribution rather than trying to use a mathematical algorithm. 
+	* The image display window now uses image pyramids and cropping for zoom ins so it should run a lot faster on bigger images.
+	* The community UMAP can now color them by neighborhood.
+	* No longer zooms all the way out by default with right click in zoom mode. Now user needs to Shift + Right Click.

{nettracer3d-0.8.9 → nettracer3d-0.9.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nettracer3d"
-version = "0.8.9"
+version = "0.9.1"
 authors = [
   { name="Liam McLaughlin", email="liamm@wustl.edu" },
 ]

{nettracer3d-0.8.9 → nettracer3d-0.9.1}/src/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-0.8.9 → nettracer3d-0.9.1}/src/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-0.8.9 → nettracer3d-0.9.1}/src/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)