senoquant 1.0.0b3__py3-none-any.whl → 1.0.0b4__py3-none-any.whl

senoquant/tabs/visualization/plots/__init__.py

@@ -0,0 +1,80 @@
+"""Visualization plot UI components."""
+
+from __future__ import annotations
+
+import importlib
+import pkgutil
+from typing import Iterable
+
+from .base import PlotConfig, PlotData, SenoQuantPlot
+from .spatialplot import SpatialPlotData
+from .umap import UMAPData
+
+
+def _iter_subclasses(cls: type[SenoQuantPlot]) -> Iterable[type[SenoQuantPlot]]:
+    """Yield all subclasses of a plot class recursively.
+
+    Parameters
+    ----------
+    cls : type[SenoQuantPlot]
+        Base class whose subclasses should be discovered.
+
+    Yields
+    ------
+    type[SenoQuantPlot]
+        Plot subclass types.
+    """
+    for subclass in cls.__subclasses__():
+        yield subclass
+        yield from _iter_subclasses(subclass)
+
+
+def get_feature_registry() -> dict[str, type[SenoQuantPlot]]:
+    """Discover plot classes and return a registry by name."""
+    for module in pkgutil.walk_packages(__path__, f"{__name__}."):
+        importlib.import_module(module.name)
+
+    registry: dict[str, type[SenoQuantPlot]] = {}
+    for plot_cls in _iter_subclasses(SenoQuantPlot):
+        feature_type = getattr(plot_cls, "feature_type", "")
+        if not feature_type:
+            continue
+        registry[feature_type] = plot_cls
+
+    return dict(
+        sorted(
+            registry.items(),
+            key=lambda item: getattr(item[1], "order", 0),
+        )
+    )
+
+FEATURE_DATA_FACTORY: dict[str, type[PlotData]] = {
+    "UMAP": UMAPData,
+    "Spatial Plot": SpatialPlotData,
+}
+
+
+def build_feature_data(feature_type: str) -> PlotData:
+    """Create a plot data instance for the specified plot type.
+
+    Parameters
+    ----------
+    feature_type : str
+        Plot type name.
+
+    Returns
+    -------
+    PlotData
+        Plot-specific configuration instance.
+    """
+    data_cls = FEATURE_DATA_FACTORY.get(feature_type, PlotData)
+    return data_cls()
+
+
+__all__ = [
+    "PlotConfig",
+    "PlotData",
+    "SenoQuantPlot",
+    "build_feature_data",
+    "get_feature_registry",
+]

senoquant/tabs/visualization/plots/base.py

@@ -0,0 +1,152 @@
+"""Feature UI base classes for visualization."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import TYPE_CHECKING, Iterable
+import uuid
+
+from qtpy.QtWidgets import QComboBox
+
+if TYPE_CHECKING:
+    from ..frontend import VisualizationTab
+    from ..frontend import PlotUIContext
+
+
+class PlotData:
+    """Base class for plot-specific configuration data.
+
+    Notes
+    -----
+    Concrete plot data classes should inherit from this class so they can
+    be stored on :class:`PlotConfig`.
+    """
+
+
+@dataclass
+class PlotConfig:
+    """Configuration for a single visualization plot.
+
+    Attributes
+    ----------
+    plot_id : str
+        Unique identifier for the plot instance.
+    type_name : str
+        Plot type name (e.g., ``"UMAP"``).
+    data : PlotData
+        Plot-specific configuration payload.
+    """
+
+    plot_id: str = field(default_factory=lambda: uuid.uuid4().hex)
+    type_name: str = ""
+    data: PlotData = field(default_factory=PlotData)
+
+
+class SenoQuantPlot:
+    """Base class for visualization plot UI."""
+
+    feature_type: str = ""
+    order: int = 0
+
+    def __init__(self, tab: "VisualizationTab", context: "PlotUIContext") -> None:
+        """Initialize a plot with shared tab context.
+
+        Parameters
+        ----------
+        tab : VisualizationTab
+            Parent visualization tab instance.
+        context : PlotUIContext
+            Plot UI context with configuration state.
+        """
+        self._tab = tab
+        self._context = context
+        self._state = context.state
+        self._ui: dict[str, object] = {}
+
+    def build(self) -> None:
+        """Build the UI for this plot."""
+        raise NotImplementedError
+
+    def plot(
+        self, 
+        temp_dir: Path, 
+        input_path: Path, 
+        export_format: str,
+        markers: list[str] | None = None,
+        thresholds: dict[str, float] | None = None,
+    ) -> Iterable[Path]:
+        """Generate plot outputs into a temporary directory.
+
+        Parameters
+        ----------
+        temp_dir : Path
+            Temporary directory where outputs should be written.
+        input_path : Path
+            Path to the folder containing CSV or Excel files for plotting.
+        export_format : str
+            File format requested by the user (``"png"``, ``"svg"``, or ``"pdf"``).
+        markers : list of str, optional
+            List of selected markers to include.
+        thresholds : dict, optional
+            Dictionary of {marker_name: threshold_value} for filtering.
+
+        Returns
+        -------
+        iterable of Path
+            Paths to files produced by the plot routine.
+
+        Notes
+        -----
+        Implementations may either return explicit file paths or simply
+        write outputs into ``temp_dir`` and return an empty iterable.
+        """
+        return []
+
+    def on_features_changed(self, configs: list["PlotUIContext"]) -> None:
+        """Handle updates when the plot list changes.
+
+        Parameters
+        ----------
+        configs : list of PlotUIContext
+            Current plot contexts.
+        """
+        return
+
+    @classmethod
+    def update_type_options(
+        cls, tab: "VisualizationTab", configs: list["PlotUIContext"]
+    ) -> None:
+        """Update type availability in plot selectors.
+
+        Parameters
+        ----------
+        tab : VisualizationTab
+            Parent visualization tab instance.
+        configs : list of PlotUIContext
+            Current plot contexts.
+        """
+        return
+
+
+class RefreshingComboBox(QComboBox):
+    """Combo box that refreshes its items when opened."""
+
+    def __init__(self, refresh_callback=None, parent=None) -> None:
+        """Create a combo box that refreshes before showing its popup.
+
+        Parameters
+        ----------
+        refresh_callback : callable or None
+            Callback invoked before showing the popup.
+        parent : QWidget or None
+            Optional parent widget.
+        """
+        super().__init__(parent)
+        self._refresh_callback = refresh_callback
+
+    def showPopup(self) -> None:
+        """Refresh items before showing the popup."""
+        if self._refresh_callback is not None:
+            self._refresh_callback()
+        super().showPopup()

senoquant/tabs/visualization/plots/double_expression.py

@@ -0,0 +1,187 @@
+"""Double expression plot handler for visualization."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterable
+
+try:
+    from napari.utils.notifications import show_error
+except ImportError:
+    def show_error(message: str) -> None:
+        pass
+
+from .base import PlotData, SenoQuantPlot
+
+
+class DoubleExpressionData(PlotData):
+    """Configuration data for double expression plot."""
+
+    pass
+
+
+class DoubleExpressionPlot(SenoQuantPlot):
+    """Spatial scatter plot highlighting double positive cells."""
+
+    feature_type = "Double Expression"
+    order = 2
+
+    def build(self) -> None:
+        """Build the UI for double expression plot configuration."""
+        pass
+
+    def plot(
+        self, 
+        temp_dir: Path, 
+        input_path: Path, 
+        export_format: str,
+        markers: list[str] | None = None,
+        thresholds: dict[str, float] | None = None,
+    ) -> Iterable[Path]:
+        """Generate double expression plot from input CSV.
+
+        Parameters
+        ----------
+        temp_dir : Path
+            Temporary directory to write plot output.
+        input_path : Path
+            Path to input CSV file or folder containing CSV files.
+        export_format : str
+            Output format ("png", "svg", or "pdf").
+        markers : list of str, optional
+            List of selected markers. Must contain exactly 2 markers.
+        thresholds : dict, optional
+            Dictionary of {marker_name: threshold_value}.
+
+        Returns
+        -------
+        iterable of Path
+            Paths to generated plot files.
+        """
+        try:
+            try:
+                import pandas as pd
+            except ImportError:
+                msg = (
+                    "[DoubleExpressionPlot] pandas is not installed; "
+                    "skipping plot generation."
+                )
+                print(msg)
+                show_error(msg)
+                return []
+            try:
+                import matplotlib.pyplot as plt
+            except ImportError:
+                msg = (
+                    "[DoubleExpressionPlot] matplotlib is not installed; "
+                    "skipping plot generation."
+                )
+                print(msg)
+                show_error(msg)
+                return []
+
+            print(f"[DoubleExpressionPlot] Starting with input_path={input_path}")
+            
+            if not markers or len(markers) != 2:
+                msg = f"Double Expression Plot requires exactly 2 markers. Got {len(markers) if markers else 0}."
+                print(f"[DoubleExpressionPlot] {msg}")
+                show_error(msg)
+                return []
+
+            # Find data file
+            data_files = list(input_path.glob("*.csv")) + list(input_path.glob("*.xlsx")) + list(input_path.glob("*.xls"))
+            if not data_files:
+                print(f"[DoubleExpressionPlot] No data files found")
+                return []
+            
+            data_file = data_files[0]
+            if data_file.suffix.lower() in ('.xlsx', '.xls'):
+                df = pd.read_excel(data_file)
+            else:
+                df = pd.read_csv(data_file)
+            
+            if df.empty:
+                return []
+
+            # Identify columns (alphabetical order from frontend)
+            m1, m2 = markers[0], markers[1]
+            col1 = f"{m1}_mean_intensity"
+            col2 = f"{m2}_mean_intensity"
+            
+            if col1 not in df.columns or col2 not in df.columns:
+                msg = f"Missing columns for markers: {m1}, {m2}"
+                print(f"[DoubleExpressionPlot] {msg}")
+                show_error(msg)
+                return []
+
+            # Get thresholds
+            t1 = thresholds.get(m1, 0.0) if thresholds else 0.0
+            t2 = thresholds.get(m2, 0.0) if thresholds else 0.0
+            
+            print(f"[DoubleExpressionPlot] Using thresholds: {m1}>{t1}, {m2}>{t2}")
+
+            # Find X, Y
+            x_col = None
+            y_col = None
+            for col in df.columns:
+                col_lower = col.lower()
+                if "x" in col_lower and x_col is None:
+                    x_col = col
+                elif "y" in col_lower and y_col is None:
+                    y_col = col
+
+            if x_col is None or y_col is None:
+                msg = "[DoubleExpressionPlot] Could not find X/Y columns in the data file."
+                print(msg)
+                show_error(msg)
+                return []
+
+            # Plotting
+            fig, ax = plt.subplots(figsize=(10, 10))
+            
+            # 1. Background (All cells - Negative appearance)
+            ax.scatter(df[x_col], df[y_col], c="#f0f0f0", s=1, label="Negative")
+
+            # 2. Layer 1: M1 ONLY (Red)
+            # Logic: (M1 > T1) AND (M2 <= T2)
+            m1_only = df[(df[col1] > t1) & (df[col2] <= t2)]
+            ax.scatter(m1_only[x_col], m1_only[y_col], c="red", s=3, alpha=0.8, label=f"{m1}+ only")
+
+            # 3. Layer 2: M2 ONLY (Blue)
+            # Logic: (M2 > T2) AND (M1 <= T1)
+            m2_only = df[(df[col2] > t2) & (df[col1] <= t1)]
+            ax.scatter(m2_only[x_col], m2_only[y_col], c="blue", s=3, alpha=0.8, label=f"{m2}+ only")
+
+            # 4. Layer 3: DOUBLE POSITIVE (Green)
+            # Logic: (M1 > T1) AND (M2 > T2)
+            both_pos = df[(df[col1] > t1) & (df[col2] > t2)]
+            ax.scatter(both_pos[x_col], both_pos[y_col], c="green", s=4, alpha=1.0, label="Double Positive")
+
+            ax.set_aspect('equal')
+            ax.set_title(f"Spatial Distribution\n{m1} (Red) | {m2} (Blue) | Both (Green)", fontsize=15)
+            ax.set_xlabel(x_col)
+            ax.set_ylabel(y_col)
+
+            # Custom Legend
+            ax.legend(markerscale=4, loc='upper right', frameon=False)
+
+            # Print Counts
+            print(f"[DoubleExpressionPlot] {m1}+ only: {len(m1_only)}")
+            print(f"[DoubleExpressionPlot] {m2}+ only: {len(m2_only)}")
+            print(f"[DoubleExpressionPlot] Double + : {len(both_pos)}")
+
+            # Save
+            safe_name = f"{m1}_{m2}_double_expression"
+            safe_name = "".join(c if c.isalnum() else "_" for c in safe_name)
+            output_file = temp_dir / f"{safe_name}.{export_format}"
+            fig.savefig(str(output_file), dpi=150, bbox_inches="tight")
+            plt.close(fig)
+
+            return [output_file]
+
+        except Exception as e:
+            import traceback
+            print(f"[DoubleExpressionPlot] Error: {e}")
+            print(traceback.format_exc())
+            show_error(f"Error in Double Expression Plot: {e}")
+            return []

senoquant/tabs/visualization/plots/spatialplot.py

@@ -0,0 +1,156 @@
+"""Spatial plot handler for visualization."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Iterable
+
+from .base import PlotData, SenoQuantPlot
+
+
+class SpatialPlotData(PlotData):
+    """Configuration data for spatial plot."""
+
+    pass
+
+
+class SpatialPlot(SenoQuantPlot):
+    """Spatial scatter plot handler for coordinate and intensity data."""
+
+    feature_type = "Spatial Plot"
+    order = 0
+
+    def build(self) -> None:
+        """Build the UI for spatial plot configuration."""
+        # Minimal UI for now; can add controls for marker selection, colormaps, etc. later
+        pass
+
+    def plot(
+        self, 
+        temp_dir: Path, 
+        input_path: Path, 
+        export_format: str,
+        markers: list[str] | None = None,
+        thresholds: dict[str, float] | None = None,
+    ) -> Iterable[Path]:
+        """Generate spatial plot from input CSV.
+
+        Parameters
+        ----------
+        temp_dir : Path
+            Temporary directory to write plot output.
+        input_path : Path
+            Path to input CSV file or folder containing CSV files.
+        export_format : str
+            Output format ("png", "svg", or "pdf").
+        markers : list of str, optional
+            List of selected markers to include.
+        thresholds : dict, optional
+            Dictionary of {marker_name: threshold_value} for filtering.
+
+        Returns
+        -------
+        iterable of Path
+            Paths to generated plot files.
+        """
+        try:
+            try:
+                import pandas as pd
+            except ImportError:
+                print("[SpatialPlot] pandas is not installed; skipping plot generation.")
+                return []
+            try:
+                import matplotlib.pyplot as plt
+            except ImportError:
+                print(
+                    "[SpatialPlot] matplotlib is not installed; skipping plot generation."
+                )
+                return []
+
+            print(f"[SpatialPlot] Starting with input_path={input_path}")
+            # Find the first data file (CSV or Excel) in the input folder
+            data_files = list(input_path.glob("*.csv")) + list(input_path.glob("*.xlsx")) + list(input_path.glob("*.xls"))
+            print(f"[SpatialPlot] Found {len(data_files)} data files")
+            if not data_files:
+                print(f"[SpatialPlot] No CSV/Excel files found in {input_path}")
+                return []
+            
+            data_file = data_files[0]
+            print(f"[SpatialPlot] Reading {data_file}")
+            if data_file.suffix.lower() in ('.xlsx', '.xls'):
+                df = pd.read_excel(data_file)
+            else:
+                df = pd.read_csv(data_file)
+            print(f"[SpatialPlot] Loaded dataframe with shape {df.shape}")
+            if df.empty:
+                print(f"[SpatialPlot] DataFrame is empty")
+                return []
+            
+            print(df.head())
+
+            # Apply thresholds if provided
+            if thresholds:
+                for marker, thresh in thresholds.items():
+                    col_name = f"{marker}_mean_intensity"
+                    if col_name in df.columns:
+                        # Clip values below threshold to 0
+                        df.loc[df[col_name] < thresh, col_name] = 0
+
+            # Filter columns based on selected markers (optional, but good for cleanup)
+            if markers is not None:
+                # We want to ensure we don't pick a deselected marker as the intensity column
+                valid_marker_cols = [f"{m}_mean_intensity" for m in markers]
+                # Keep non-marker columns (like coords) + valid marker columns
+                cols_to_keep = [c for c in df.columns if "_mean_intensity" not in c or c in valid_marker_cols]
+                df = df[cols_to_keep]
+                print(f"[SpatialPlot] Filtered columns using {len(valid_marker_cols)} selected markers")
+
+            # Look for X, Y coordinate columns
+            x_col = None
+            y_col = None
+            for col in df.columns:
+                col_lower = col.lower()
+                if "x" in col_lower and x_col is None:
+                    x_col = col
+                elif "y" in col_lower and y_col is None:
+                    y_col = col
+
+            if x_col is None or y_col is None:
+                return []
+
+            x = df[x_col].values
+            y = df[y_col].values
+
+            # Get first numeric column (intensity) for coloring
+            numeric_cols = df.select_dtypes(include=["number"]).columns
+            intensity_col = None
+            for col in numeric_cols:
+                if col not in [x_col, y_col]:
+                    intensity_col = col
+                    break
+
+            # Create plot
+            fig, ax = plt.subplots(figsize=(8, 6))
+            if intensity_col is not None:
+                c = df[intensity_col].values
+                scatter = ax.scatter(x, y, c=c, cmap="viridis", alpha=0.6, s=20)
+                plt.colorbar(scatter, ax=ax, label=intensity_col)
+            else:
+                ax.scatter(x, y, alpha=0.6, s=20)
+
+            ax.set_xlabel(x_col)
+            ax.set_ylabel(y_col)
+            ax.set_title("Spatial Distribution")
+
+            # Save plot
+            output_file = temp_dir / f"spatial_plot.{export_format}"
+            fig.savefig(str(output_file), dpi=150, bbox_inches="tight")
+            plt.close(fig)
+
+            return [output_file]
+
+        except Exception as e:
+            import traceback
+            print(f"[SpatialPlot] ERROR generating spatial plot: {e}")
+            print(traceback.format_exc())
+            return []