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

nettracer3d/cellpose_manager.py

@@ -0,0 +1,161 @@
+import subprocess
+import sys
+import threading
+from pathlib import Path
+from PyQt6.QtWidgets import QMessageBox, QWidget
+
+class CellposeGUILauncher:
+    """Simple launcher for cellpose GUI in PyQt6 applications."""
+    
+    def __init__(self, parent_widget=None):
+        """
+        Initialize the launcher.
+        
+        Args:
+            parent_widget: PyQt6 widget for showing message boxes (optional)
+        """
+        self.parent_widget = parent_widget
+        self.cellpose_process = None
+    
+    def launch_cellpose_gui(self, image_path=None, working_directory=None):
+        """
+        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
+        
+        Returns:
+            bool: True if launch was initiated successfully
+        """
+        def run_cellpose():
+            """Function to run in separate thread."""
+            try:
+                # Build command
+                cmd = [sys.executable, "-m", "cellpose"]
+                
+                # Add image path if provided
+                if image_path and Path(image_path).exists():
+                    cmd.extend(["--image_path", str(image_path)])
+                
+                # Set working directory
+                cwd = working_directory if working_directory else None
+                
+                # Launch cellpose GUI
+                self.cellpose_process = subprocess.Popen(
+                    cmd,
+                    cwd=cwd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE
+                )
+                
+                # Optional: wait for process to complete
+                # self.cellpose_process.wait()
+                
+            except Exception as e:
+                if self.parent_widget:
+                    # Show error in main thread
+                    self.show_error(f"Failed to launch cellpose GUI: {str(e)}")
+                else:
+                    print(f"Failed to launch cellpose 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!")
+            
+            return True
+            
+        except Exception as e:
+            if self.parent_widget:
+                self.show_error(f"Failed to start cellpose thread: {str(e)}")
+            else:
+                print(f"Failed to start cellpose thread: {str(e)}")
+            return False
+    
+    def launch_with_directory(self, directory_path):
+        """
+        Launch cellpose GUI with a specific directory.
+        
+        Args:
+            directory_path (str): Directory containing images
+        """
+        cmd_args = ["--dir", str(directory_path)]
+        return self.launch_cellpose_gui_with_args(cmd_args, working_directory=directory_path)
+    
+    def launch_cellpose_gui_with_args(self, additional_args=None, working_directory=None):
+        """
+        Launch cellpose GUI with custom arguments.
+        
+        Args:
+            additional_args (list): List of additional command line arguments
+            working_directory (str): Working directory for cellpose
+        """
+        def run_cellpose_custom():
+            try:
+                cmd = [sys.executable, "-m", "cellpose"]
+                
+                if additional_args:
+                    cmd.extend(additional_args)
+                
+                cwd = working_directory if working_directory else None
+                
+                self.cellpose_process = subprocess.Popen(
+                    cmd,
+                    cwd=cwd,
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE
+                )
+                
+            except Exception as e:
+                if self.parent_widget:
+                    self.show_error(f"Failed to launch cellpose GUI: {str(e)}")
+                else:
+                    print(f"Failed to launch cellpose GUI: {str(e)}")
+        
+        try:
+            thread = threading.Thread(target=run_cellpose_custom, daemon=True)
+            thread.start()
+            return True
+        except Exception as e:
+            if self.parent_widget:
+                self.show_error(f"Failed to start cellpose: {str(e)}")
+            return False
+    
+    def is_cellpose_running(self):
+        """
+        Check if cellpose process is still running.
+        
+        Returns:
+            bool: True if cellpose is still running
+        """
+        if self.cellpose_process is None:
+            return False
+        
+        return self.cellpose_process.poll() is None
+    
+    def close_cellpose(self):
+        """Terminate the cellpose process if running."""
+        if self.cellpose_process and self.is_cellpose_running():
+            try:
+                self.cellpose_process.terminate()
+                self.cellpose_process.wait(timeout=5)  # Wait up to 5 seconds
+            except subprocess.TimeoutExpired:
+                self.cellpose_process.kill()  # Force kill if it doesn't terminate
+            except Exception as e:
+                print(f"Error closing cellpose: {e}")
+    
+    def show_info(self, message):
+        """Show info message if parent widget available."""
+        if self.parent_widget:
+            QMessageBox.information(self.parent_widget, "Cellpose Launcher", message)
+    
+    def show_error(self, message):
+        """Show error message if parent widget available."""
+        if self.parent_widget:
+            QMessageBox.critical(self.parent_widget, "Cellpose Error", message)

nettracer3d/community_extractor.py

@@ -393,28 +393,105 @@ def find_hub_nodes(G: nx.Graph, proportion: float = 0.1) -> List:
     return output
 
 def get_color_name_mapping():
-    """Return a dictionary of common colors and their RGB values."""
+    """Return a dictionary of descriptive color names and their RGB values."""
     return {
-        'red': (255, 0, 0),
-        'green': (0, 255, 0),
-        'blue': (0, 0, 255),
-        'yellow': (255, 255, 0),
-        'cyan': (0, 255, 255),
+        # Reds
+        'crimson_red': (220, 20, 60),
+        'bright_red': (255, 0, 0),
+        'dark_red': (139, 0, 0),
+        'coral_red': (255, 127, 80),
+        'rose_red': (255, 102, 102),
+        'burgundy': (128, 0, 32),
+        'cherry_red': (222, 49, 99),
+        
+        # Greens
+        'forest_green': (34, 139, 34),
+        'lime_green': (50, 205, 50),
+        'bright_green': (0, 255, 0),
+        'dark_green': (0, 100, 0),
+        'mint_green': (152, 255, 152),
+        'sage_green': (159, 183, 121),
+        'emerald_green': (80, 200, 120),
+        'olive_green': (128, 128, 0),
+        
+        # Blues
+        'royal_blue': (65, 105, 225),
+        'bright_blue': (0, 0, 255),
+        'navy_blue': (0, 0, 128),
+        'sky_blue': (135, 206, 235),
+        'steel_blue': (70, 130, 180),
+        'powder_blue': (176, 224, 230),
+        'midnight_blue': (25, 25, 112),
+        'cobalt_blue': (0, 71, 171),
+        
+        # Purples
+        'deep_purple': (75, 0, 130),
+        'royal_purple': (120, 81, 169),
+        'lavender': (230, 230, 250),
+        'plum_purple': (221, 160, 221),
+        'violet_purple': (238, 130, 238),
         'magenta': (255, 0, 255),
-        'purple': (128, 0, 128),
-        'orange': (255, 165, 0),
-        'brown': (165, 42, 42),
-        'pink': (255, 192, 203),
-        'navy': (0, 0, 128),
-        'teal': (0, 128, 128),
-        'olive': (128, 128, 0),
-        'maroon': (128, 0, 0),
-        'lime': (50, 205, 50),
-        'indigo': (75, 0, 130),
-        'violet': (238, 130, 238),
-        'coral': (255, 127, 80),
+        'orchid': (218, 112, 214),
+        
+        # Yellows & Golds
+        'bright_yellow': (255, 255, 0),
+        'golden_yellow': (255, 215, 0),
+        'lemon_yellow': (255, 247, 0),
+        'amber': (255, 191, 0),
+        'mustard_yellow': (255, 219, 88),
+        'cream': (255, 253, 208),
+        'wheat': (245, 222, 179),
+        
+        # Oranges
+        'bright_orange': (255, 165, 0),
+        'burnt_orange': (204, 85, 0),
+        'peach': (255, 218, 185),
+        'tangerine': (255, 163, 67),
+        'pumpkin_orange': (255, 117, 24),
+        'apricot': (251, 206, 177),
+        
+        # Pinks
+        'hot_pink': (255, 105, 180),
+        'light_pink': (255, 192, 203),
+        'deep_pink': (255, 20, 147),
+        'salmon_pink': (250, 128, 114),
+        'blush_pink': (255, 182, 193),
+        'fuchsia': (255, 0, 255),
+        
+        # Cyans & Teals
+        'bright_cyan': (0, 255, 255),
+        'dark_teal': (0, 128, 128),
         'turquoise': (64, 224, 208),
-        'gold': (255, 215, 0)
+        'aqua': (0, 255, 255),
+        'seafoam': (159, 226, 191),
+        'teal_blue': (54, 117, 136),
+        
+        # Browns & Earth Tones
+        'chocolate_brown': (210, 105, 30),
+        'saddle_brown': (139, 69, 19),
+        'light_brown': (205, 133, 63),
+        'tan': (210, 180, 140),
+        'beige': (245, 245, 220),
+        'coffee_brown': (111, 78, 55),
+        'rust_brown': (183, 65, 14),
+        
+        # Grays & Neutrals
+        'charcoal_gray': (54, 69, 79),
+        'light_gray': (211, 211, 211),
+        'silver': (192, 192, 192),
+        'slate_gray': (112, 128, 144),
+        'ash_gray': (178, 190, 181),
+        'smoke_gray': (152, 152, 152),
+        
+        # Additional Distinctive Colors
+        'lime_yellow': (191, 255, 0),
+        'electric_blue': (125, 249, 255),
+        'neon_green': (57, 255, 20),
+        'wine_red': (114, 47, 55),
+        'copper': (184, 115, 51),
+        'ivory': (255, 255, 240),
+        'periwinkle': (204, 204, 255),
+        'mint': (189, 252, 201)
     }
 
 def rgb_to_color_name(rgb: Tuple[int, int, int]) -> str:
@@ -440,21 +517,90 @@ def rgb_to_color_name(rgb: Tuple[int, int, int]) -> str:
         distance = np.sqrt(np.sum((rgb_array - np.array(color_rgb)) ** 2))
         if distance < min_distance:
             min_distance = distance
+            #closest_color = color_name + f" {str(rgb_array)}" # <- if we want RGB names
             closest_color = color_name
-            
+
     return closest_color
 
-def convert_node_colors_to_names(node_to_color: Dict[int, Tuple[int, int, int]]) -> Dict[int, str]:
+def convert_node_colors_to_names(node_to_color: Dict[int, Tuple[int, int, int]], 
+                                show_legend: bool = True,
+                                figsize: Tuple[int, int] = (10, 8),
+                                save_path: str = None) -> Dict[int, str]:
     """
     Convert a dictionary of node-to-RGB mappings to node-to-color-name mappings.
+    Optionally displays a matplotlib legend showing the mappings.
     
     Args:
         node_to_color: Dictionary mapping node IDs to RGB tuples
+        show_legend: Whether to display the color legend plot
+        figsize: Figure size as (width, height) for the legend
+        save_path: Optional path to save the legend figure
         
     Returns:
         Dictionary mapping node IDs to color names
     """
-    return {node: rgb_to_color_name(color) for node, color in node_to_color.items()}
+    # Convert colors to names
+    node_to_names = {node: rgb_to_color_name(color) for node, color in node_to_color.items()}
+    
+    # Create legend if requested
+    if show_legend:
+        import matplotlib.pyplot as plt
+        from matplotlib.patches import Rectangle
+        
+        num_entries = len(node_to_color)
+        
+        # Calculate dynamic spacing based on number of entries
+        entry_height = 0.8
+        total_height = num_entries * entry_height + 1.5  # Extra space for title and margins
+        
+        # Create figure and axis with proper scaling
+        fig, ax = plt.subplots(figsize=figsize)
+        ax.set_xlim(0, 10)
+        ax.set_ylim(0, total_height)
+        ax.axis('off')
+        
+        # Title
+        ax.text(5, total_height - 0.5, 'Color Legend', 
+                fontsize=16, fontweight='bold', ha='center')
+        
+        # Sort nodes for consistent display
+        sorted_nodes = sorted(node_to_color.keys())
+        
+        # Create legend entries
+        for i, node in enumerate(sorted_nodes):
+            y_pos = total_height - (i + 1) * entry_height - 0.8
+            rgb = node_to_color[node]
+            color_name = node_to_names[node]
+            
+            # Normalize RGB values for matplotlib (0-1 range)
+            norm_rgb = tuple(c/255.0 for c in rgb)
+            
+            # Draw color swatch (using actual RGB values)
+            swatch = Rectangle((1.0, y_pos - 0.15), 0.8, 0.3, 
+                              facecolor=norm_rgb, edgecolor='black', linewidth=1)
+            ax.add_patch(swatch)
+            
+            # Node ID (exactly as it appears in dict keys)
+            ax.text(0.2, y_pos, str(node), fontsize=12, fontweight='bold', 
+                    va='center', ha='left')
+            
+            # Color name (mapped name, nicely formatted)
+            ax.text(2.2, y_pos, color_name.replace('_', ' ').title(), 
+                    fontsize=11, va='center', ha='left')
+        
+        # Add border around the legend
+        border = Rectangle((0.1, 0.1), 9.8, total_height - 0.2, 
+                          fill=False, edgecolor='gray', linewidth=2)
+        ax.add_patch(border)
+        
+        plt.tight_layout()
+        
+        if save_path:
+            plt.savefig(save_path, dpi=300, bbox_inches='tight')
+            
+        plt.show()
+    
+    return node_to_names
 
 def generate_distinct_colors(n_colors: int) -> List[Tuple[int, int, int]]:
     """
@@ -519,7 +665,7 @@ def assign_node_colors(node_list: List[int], labeled_array: np.ndarray) -> Tuple
     
     # Convert colors for naming
     node_to_color_rgb = {k: tuple(v[:3]) for k, v in node_to_color.items()}
-    node_to_color_names = convert_node_colors_to_names(node_to_color_rgb)
+    node_to_color_names = convert_node_colors_to_names(node_to_color_rgb, show_legend = False)
     
     return rgba_array, node_to_color_names