nettracer3d 0.8.8__tar.gz → 0.9.0__tar.gz

{nettracer3d-0.8.8/src/nettracer3d.egg-info → nettracer3d-0.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nettracer3d
-Version: 0.8.8
+Version: 0.9.0
 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,16 @@ 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.8 Updates -- 
-
-	* See Documentation Once Updated
+-- Version 0.9.0 Updates --
+	* Note that this includes updates for 0.8.3 - 0.9.0
+	* Bug Fixes
+	* Updated network histogram statistics menu, and moved degree distribution here
+	* Added gray watershed
+	* Updated binary watershed
+	* Improved branch labelling method
+	* Updated branch removal in skeletonization method to no longer trim branches that do not reach their node.
+	* Added default branchpoint and branch-adjacency calculation options.
+	* Improved speed of painting and panning.
+	* Enabled the nearest neighbor method to handle non-centroid objects, for the first neighbor at least. And updated it to actually predict theoretical clustering when coloring the heatmap.
+	* Improved segmenter.
+	* Added centroids UMAP method.

{nettracer3d-0.8.8 → nettracer3d-0.9.0}/README.md

@@ -65,6 +65,16 @@ 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.8 Updates -- 
-
-	* See Documentation Once Updated
+-- Version 0.9.0 Updates --
+	* Note that this includes updates for 0.8.3 - 0.9.0
+	* Bug Fixes
+	* Updated network histogram statistics menu, and moved degree distribution here
+	* Added gray watershed
+	* Updated binary watershed
+	* Improved branch labelling method
+	* Updated branch removal in skeletonization method to no longer trim branches that do not reach their node.
+	* Added default branchpoint and branch-adjacency calculation options.
+	* Improved speed of painting and panning.
+	* Enabled the nearest neighbor method to handle non-centroid objects, for the first neighbor at least. And updated it to actually predict theoretical clustering when coloring the heatmap.
+	* Improved segmenter.
+	* Added centroids UMAP method.

{nettracer3d-0.8.8 → nettracer3d-0.9.0}/pyproject.toml

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

{nettracer3d-0.8.8 → nettracer3d-0.9.0}/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.8 → nettracer3d-0.9.0}/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.8 → nettracer3d-0.9.0}/src/nettracer3d/neighborhoods.py

@@ -644,25 +644,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 +884,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)