nettracer3d 0.8.1__py3-none-any.whl → 0.8.2__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,7 +517,7 @@ 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
+            closest_color = color_name + f" {str(rgb_array)}"
             
     return closest_color
 

nettracer3d/neighborhoods.py

@@ -1,52 +1,176 @@
 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
 import umap
-
+from matplotlib.colors import LinearSegmentedColormap
+from sklearn.cluster import DBSCAN
+from sklearn.neighbors import NearestNeighbors
 
 
 import os
 os.environ['LOKY_MAX_CPU_COUNT'] = '4'
 
-def cluster_arrays(data_input, n_clusters, seed = 42):
+def cluster_arrays_dbscan(data_input, seed=42):
     """
-    Simple clustering of 1D arrays with key tracking.
+    Simple DBSCAN clustering of 1D arrays with sensible defaults.
     
     Parameters:
     -----------
     data_input : dict or List[List[float]]
         Dictionary {key: array} or list of arrays to cluster
-    n_clusters : int  
-        How many groups you want
+    seed : int
+        Random seed for reproducibility (used for parameter estimation)
         
     Returns:
     --------
-    dict: {cluster_id: {'keys': [keys], 'arrays': [arrays]}}
+    list: [[key1, key2], [key3, key4, key5]] - List of clusters, each containing keys/indices
+          Note: Outliers are excluded from the output
     """
     
     # Handle both dict and list inputs
     if isinstance(data_input, dict):
         keys = list(data_input.keys())
-        array_values = list(data_input.values())  # Use .values() to get the arrays
+        array_values = list(data_input.values())
     else:
-        keys = list(range(len(data_input)))  # Use indices as keys for lists
+        keys = list(range(len(data_input)))
         array_values = data_input
     
-    # Convert to numpy and cluster
+    # Convert to numpy
     data = np.array(array_values)
-    kmeans = KMeans(n_clusters=n_clusters, random_state=seed)
-    labels = kmeans.fit_predict(data)
+    n_samples = len(data)
+    
+    # Simple heuristics for DBSCAN parameters
+    min_samples = max(3, int(np.sqrt(n_samples) * 0.2))  # Roughly sqrt(n)/5, minimum 3
+    
+    # Estimate eps using 4th nearest neighbor distance (common heuristic)
+    k = min(4, n_samples - 1)
+    if k > 0:
+        nbrs = NearestNeighbors(n_neighbors=k + 1)
+        nbrs.fit(data)
+        distances, _ = nbrs.kneighbors(data)
+        # Use 80th percentile of k-nearest distances as eps
+        eps = np.percentile(distances[:, k], 80)
+    else:
+        eps = 0.1  # fallback
+    
+    print(f"Using DBSCAN with eps={eps:.4f}, min_samples={min_samples}")
+    
+    # Perform DBSCAN clustering
+    dbscan = DBSCAN(eps=eps, min_samples=min_samples)
+    labels = dbscan.fit_predict(data)
+    
+    # Organize results into clusters (excluding outliers)
+    clusters = []
+    
+    # Add only the main clusters (non-noise points)
+    unique_labels = np.unique(labels)
+    main_clusters = [label for label in unique_labels if label != -1]
+    
+    for label in main_clusters:
+        cluster_indices = np.where(labels == label)[0]
+        cluster_keys = [keys[i] for i in cluster_indices]
+        clusters.append(cluster_keys)
+    
+    n_main_clusters = len(main_clusters)
+    n_outliers = np.sum(labels == -1)
     
+    print(f"Found {n_main_clusters} main clusters and {n_outliers} outliers (go in neighborhood 0)")
+    
+    return clusters
 
+def cluster_arrays(data_input, n_clusters=None, seed=42):
+    """
+    Simple clustering of 1D arrays with key tracking and automatic cluster count detection.
+    
+    Parameters:
+    -----------
+    data_input : dict or List[List[float]]
+        Dictionary {key: array} or list of arrays to cluster
+    n_clusters : int or None
+        How many groups you want. If None, will automatically determine optimal k
+    seed : int
+        Random seed for reproducibility
+    max_k : int
+        Maximum number of clusters to consider when auto-detecting (default: 10)
+        
+    Returns:
+    --------
+    list: [[key1, key2], [key3, key4, key5]] - List of clusters, each containing keys/indices
+    """
+    
+    # Handle both dict and list inputs
+    if isinstance(data_input, dict):
+        keys = list(data_input.keys())
+        array_values = list(data_input.values())
+    else:
+        keys = list(range(len(data_input)))
+        array_values = data_input
+    
+    # Convert to numpy
+    data = np.array(array_values)
+    
+    # Auto-detect optimal number of clusters if not specified
+    if n_clusters is None:
+        n_clusters = _find_optimal_clusters(data, seed, max_k = (len(keys) // 3))
+        print(f"Auto-detected optimal number of clusters: {n_clusters}")
+    
+    # Perform clustering
+    kmeans = KMeans(n_clusters=n_clusters, random_state=seed, n_init=10)
+    labels = kmeans.fit_predict(data)
+    
+    # Organize results into clusters - simple list of lists with keys only
     clusters = [[] for _ in range(n_clusters)]
-
     for i, label in enumerate(labels):
         clusters[label].append(keys[i])
-
+    
     return clusters
+
+def _find_optimal_clusters(data, seed, max_k):
+    """
+    Find optimal number of clusters using Calinski-Harabasz index.
+    """
+    n_samples = len(data)
+    
+    # Need at least 2 samples to cluster
+    if n_samples < 2:
+        return 1
+    
+    # Limit max_k to reasonable bounds
+    max_k = min(max_k, n_samples - 1, 20)
+    print(f"Max_k: {max_k}, n_samples: {n_samples}")
+    
+    if max_k < 2:
+        return 1
+    
+    # Use Calinski-Harabasz index to find optimal k
+    ch_scores = []
+    k_range = range(2, max_k + 1)
+    
+    for k in k_range:
+        try:
+            kmeans = KMeans(n_clusters=k, random_state=seed, n_init=10)
+            labels = kmeans.fit_predict(data)
+            
+            # Check if we got the expected number of clusters
+            if len(np.unique(labels)) == k:
+                score = calinski_harabasz_score(data, labels)
+                ch_scores.append(score)
+            else:
+                ch_scores.append(0)  # Penalize solutions that didn't achieve k clusters
+                
+        except Exception:
+            ch_scores.append(0)
     
-def plot_dict_heatmap(unsorted_data_dict, id_set, figsize=(12, 8), title="Neighborhood Heatmap"):
+    # Find k with highest Calinski-Harabasz score
+    if ch_scores and max(ch_scores) > 0:
+        optimal_k = k_range[np.argmax(ch_scores)]
+        print(f"Using {optimal_k} neighborhoods")
+        return optimal_k
+    
+def plot_dict_heatmap(unsorted_data_dict, id_set, figsize=(12, 8), title="Neighborhood Heatmap", 
+                     center_at_one=False):
     """
     Create a heatmap from a dictionary of numpy arrays.
     
@@ -60,6 +184,11 @@ def plot_dict_heatmap(unsorted_data_dict, id_set, figsize=(12, 8), title="Neighb
         Figure size (width, height)
     title : str, optional
         Title for the heatmap
+    center_at_one : bool, optional
+        If True, uses a diverging colormap centered at 1 with nonlinear scaling:
+        - 0 to 1: blue to white (underrepresentation to normal)
+        - 1+: white to red (overrepresentation)
+        If False (default), uses standard white-to-red scaling from 0 to 1
     
     Returns:
     --------
@@ -67,7 +196,6 @@ def plot_dict_heatmap(unsorted_data_dict, id_set, figsize=(12, 8), title="Neighb
     """
     
     data_dict = {k: unsorted_data_dict[k] for k in sorted(unsorted_data_dict.keys())}
-
     # Convert dict to 2D array for heatmap
     # Each row represents one key from the dict
     keys = list(data_dict.keys())
@@ -76,8 +204,70 @@ def plot_dict_heatmap(unsorted_data_dict, id_set, figsize=(12, 8), title="Neighb
     # Create the plot
     fig, ax = plt.subplots(figsize=figsize)
     
-    # Create heatmap with white-to-red colormap
-    im = ax.imshow(data_matrix, cmap='Reds', aspect='auto', vmin=0, vmax=1)
+    if center_at_one:
+        # Custom colormap and scaling for center_at_one mode
+        # Find the actual data range
+        data_min = np.min(data_matrix)
+        data_max = np.max(data_matrix)
+        
+        # Create a custom colormap: blue -> white -> red
+        colors = ['#2166ac', '#4393c3', '#92c5de', '#d1e5f0', '#f7f7f7', 
+                 '#fddbc7', '#f4a582', '#d6604d', '#b2182b']
+        n_bins = 256
+        cmap = LinearSegmentedColormap.from_list('custom_diverging', colors, N=n_bins)
+        
+        # Create nonlinear transformation
+        # Map 0->1 with more resolution, 1+ with less resolution
+        def transform_data(data):
+            transformed = np.zeros_like(data)
+            
+            # For values 0 to 1: use square root for faster approach to middle
+            mask_low = data <= 1
+            transformed[mask_low] = 0.5 * np.sqrt(data[mask_low])
+            
+            # For values > 1: use slower logarithmic scaling
+            mask_high = data > 1
+            if np.any(mask_high):
+                # Scale from 0.5 to 1.0 based on log of excess above 1
+                max_excess = np.max(data[mask_high] - 1) if np.any(mask_high) else 0
+                if max_excess > 0:
+                    excess_normalized = np.log1p(data[mask_high] - 1) / np.log1p(max_excess)
+                    transformed[mask_high] = 0.5 + 0.5 * excess_normalized
+                else:
+                    transformed[mask_high] = 0.5
+            
+            return transformed
+        
+        # Transform the data for visualization
+        transformed_matrix = transform_data(data_matrix)
+        
+        # Create heatmap with custom colormap
+        im = ax.imshow(transformed_matrix, cmap=cmap, aspect='auto', vmin=0, vmax=1)
+        
+        # Create custom colorbar with original values
+        cbar = ax.figure.colorbar(im, ax=ax)
+        
+        # Set colorbar ticks to show meaningful values
+        if data_max > 1:
+            tick_values = [0, 0.25, 0.5, 0.75, 1.0, 1.25, 1.5, 2.0]
+            tick_values = [v for v in tick_values if data_min <= v <= data_max]
+        else:
+            tick_values = [0, 0.25, 0.5, 0.75, 1.0]
+            tick_values = [v for v in tick_values if data_min <= v <= data_max]
+        
+        # Transform tick values for colorbar positioning
+        transformed_ticks = transform_data(np.array(tick_values))
+        cbar.set_ticks(transformed_ticks)
+        cbar.set_ticklabels([f'{v:.2f}' for v in tick_values])
+        cbar.ax.set_ylabel('Representation Ratio', rotation=-90, va="bottom")
+        
+    else:
+        # Default behavior: white-to-red colormap
+        im = ax.imshow(data_matrix, cmap='Reds', aspect='auto', vmin=0, vmax=1)
+        
+        # Add standard colorbar
+        cbar = ax.figure.colorbar(im, ax=ax)
+        cbar.ax.set_ylabel('Intensity', rotation=-90, va="bottom")
     
     # Set ticks and labels
     ax.set_xticks(np.arange(len(id_set)))
@@ -91,23 +281,32 @@ def plot_dict_heatmap(unsorted_data_dict, id_set, figsize=(12, 8), title="Neighb
     # Add text annotations showing the actual values
     for i in range(len(keys)):
         for j in range(len(id_set)):
+            # Use original data values for annotations
             text = ax.text(j, i, f'{data_matrix[i, j]:.3f}',
                           ha="center", va="center", color="black", fontsize=8)
-    
-    # Add colorbar
-    cbar = ax.figure.colorbar(im, ax=ax)
-    cbar.ax.set_ylabel('Intensity', rotation=-90, va="bottom")
+
+
+    ret_dict = {}
+
+    for i, row in enumerate(data_matrix):
+        ret_dict[keys[i]] = row
     
     # Set labels and title
-    ax.set_xlabel('Proportion of Node Type')
+    if center_at_one:
+        ax.set_xlabel('Representation Factor of Node Type')
+    else:
+        ax.set_xlabel('Proportion of Node Type')
+
     ax.set_ylabel('Neighborhood')
     ax.set_title(title)
     
     # Adjust layout to prevent label cutoff
     plt.tight_layout()
-
     plt.show()
 
+    return ret_dict
+    
+
 
 def visualize_cluster_composition_umap(cluster_data: Dict[int, np.ndarray], 
                                      class_names: Set[str],