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

senoquant/tabs/spots/models/ufish/model.py

@@ -6,6 +6,7 @@ import numpy as np
 from scipy import ndimage as ndi
 from skimage.filters import laplace
 from skimage.morphology import local_maxima
+from skimage.restoration import denoise_wavelet
 from skimage.segmentation import watershed
 
 from ..base import SenoQuantSpotDetector
@@ -15,6 +16,16 @@ from senoquant.tabs.spots.ufish_utils import UFishConfig, enhance_image
 
 DEFAULT_THRESHOLD = 0.5
 USE_LAPLACE_FOR_PEAKS = False
+DEFAULT_DENOISE_ENABLED = False
+DEFAULT_SPOT_SIZE = 1.0
+MIN_SPOT_SIZE = 0.25
+MAX_SPOT_SIZE = 4.0
+EPS = 1e-6
+NOISE_FLOOR_SIGMA = 1.5
+MIN_SCALE_SIGMA = 5.0
+SIGNAL_SCALE_QUANTILE = 99.9
+INPUT_LOW_PERCENTILE = 0.05
+INPUT_HIGH_PERCENTILE = 99.95
 
 
 def _clamp_threshold(value: float) -> float:
@@ -22,16 +33,175 @@ def _clamp_threshold(value: float) -> float:
     return float(np.clip(value, 0.0, 1.0))
 
 
-def _normalize_unit(image: np.ndarray) -> np.ndarray:
-    """Normalize to float32 in [0, 1] using 0.05/99.95 percentiles."""
+def _normalize_input_percentile(image: np.ndarray) -> np.ndarray:
+    """Normalize input image to [0, 1] via percentile clipping."""
     data = np.asarray(image, dtype=np.float32)
-    low, high = np.nanpercentile(data, [0.05, 99.95])
+    finite_mask = np.isfinite(data)
+    if not np.any(finite_mask):
+        return np.zeros_like(data, dtype=np.float32)
+
+    valid = data[finite_mask]
+    low, high = np.nanpercentile(valid, [INPUT_LOW_PERCENTILE, INPUT_HIGH_PERCENTILE])
     low = float(low)
     high = float(high)
-    if high <= low:
+    if (not np.isfinite(low)) or (not np.isfinite(high)) or high <= low:
         return np.zeros_like(data, dtype=np.float32)
+
     normalized = (data - low) / (high - low)
-    return np.clip(normalized, 0.0, 1.0).astype(np.float32, copy=False)
+    normalized = np.clip(normalized, 0.0, 1.0)
+    normalized = np.where(finite_mask, normalized, 0.0)
+    return normalized.astype(np.float32, copy=False)
+
+
+def _normalize_enhanced_unit(image: np.ndarray) -> np.ndarray:
+    """Normalize enhanced image to [0, 1] with robust background suppression."""
+    data = np.asarray(image, dtype=np.float32)
+    finite_mask = np.isfinite(data)
+    if not np.any(finite_mask):
+        return np.zeros_like(data, dtype=np.float32)
+
+    valid = data[finite_mask]
+    background = float(np.nanmedian(valid))
+    sigma = 1.4826 * float(np.nanmedian(np.abs(valid - background)))
+
+    if (not np.isfinite(sigma)) or sigma <= EPS:
+        sigma = float(np.nanstd(valid))
+        if (not np.isfinite(sigma)) or sigma <= EPS:
+            return np.zeros_like(data, dtype=np.float32)
+
+    # Gate out most background fluctuations before scaling.
+    noise_floor = background + (NOISE_FLOOR_SIGMA * sigma)
+    residual = np.clip(data - noise_floor, 0.0, None)
+    residual = np.where(finite_mask, residual, 0.0)
+
+    positive = residual[residual > 0.0]
+    if positive.size == 0:
+        return np.zeros_like(data, dtype=np.float32)
+    high = float(np.nanpercentile(positive, SIGNAL_SCALE_QUANTILE))
+    if (not np.isfinite(high)) or high <= EPS:
+        high = float(np.nanmax(positive))
+        if (not np.isfinite(high)) or high <= EPS:
+            return np.zeros_like(data, dtype=np.float32)
+
+    scale = max(high, MIN_SCALE_SIGMA * sigma, EPS)
+    normalized = np.clip(residual / scale, 0.0, 1.0)
+    return normalized.astype(np.float32, copy=False)
+
+
+def _clamp_spot_size(value: float) -> float:
+    """Clamp spot-size control to a safe positive range."""
+    return float(np.clip(value, MIN_SPOT_SIZE, MAX_SPOT_SIZE))
+
+
+def _spot_size_to_detection_scale(spot_size: float) -> float:
+    """Convert user spot-size control to internal image scaling.
+
+    spot_size > 1 means detect larger spots (zoom out input),
+    spot_size < 1 means detect smaller spots (zoom in input).
+    """
+    return 1.0 / _clamp_spot_size(spot_size)
+
+
+def _denoise_input(
+    image: np.ndarray,
+    *,
+    enabled: bool,
+) -> np.ndarray:
+    """Optionally denoise image to suppress tiny bright peaks.
+
+    Uses wavelet denoising with BayesShrink.
+    """
+    if not enabled:
+        return image.astype(np.float32, copy=False)
+    data = image.astype(np.float32, copy=False)
+    if data.ndim == 2:
+        denoised = denoise_wavelet(
+            data,
+            method="BayesShrink",
+            mode="soft",
+            rescale_sigma=True,
+            channel_axis=None,
+        )
+        return np.asarray(denoised, dtype=np.float32)
+
+    denoised = np.empty_like(data, dtype=np.float32)
+    for z in range(data.shape[0]):
+        denoised[z] = np.asarray(
+            denoise_wavelet(
+                data[z],
+                method="BayesShrink",
+                mode="soft",
+                rescale_sigma=True,
+                channel_axis=None,
+            ),
+            dtype=np.float32,
+        )
+    return denoised.astype(np.float32, copy=False)
+
+
+def _scale_image_for_detection(
+    image: np.ndarray,
+    scale: float,
+) -> np.ndarray:
+    """Rescale image before U-FISH inference.
+
+    For 3D stacks, scale is applied to y/x only and z is preserved.
+    """
+    if abs(scale - 1.0) < 1e-6:
+        return image.astype(np.float32, copy=False)
+    if image.ndim == 2:
+        target_shape = tuple(max(1, int(round(dim * scale))) for dim in image.shape)
+    else:
+        target_shape = (
+            image.shape[0],
+            max(1, int(round(image.shape[1] * scale))),
+            max(1, int(round(image.shape[2] * scale))),
+        )
+    zoom_factors = tuple(
+        target / source for target, source in zip(target_shape, image.shape)
+    )
+    scaled = ndi.zoom(
+        image.astype(np.float32, copy=False),
+        zoom=zoom_factors,
+        order=1,
+        mode="nearest",
+    )
+    return scaled.astype(np.float32, copy=False)
+
+
+def _fit_to_shape(array: np.ndarray, target_shape: tuple[int, ...]) -> np.ndarray:
+    """Crop/pad array to exactly match target shape."""
+    if array.shape == target_shape:
+        return array
+
+    src_slices = tuple(slice(0, min(src, tgt)) for src, tgt in zip(array.shape, target_shape))
+    cropped = array[src_slices]
+    if cropped.shape == target_shape:
+        return cropped
+
+    fitted = np.zeros(target_shape, dtype=array.dtype)
+    dst_slices = tuple(slice(0, dim) for dim in cropped.shape)
+    fitted[dst_slices] = cropped
+    return fitted
+
+def _restore_image_to_input_scale(
+    image: np.ndarray,
+    original_shape: tuple[int, ...],
+) -> np.ndarray:
+    """Restore floating-point image to original input scale."""
+    if image.shape == original_shape:
+        return image.astype(np.float32, copy=False)
+    zoom_factors = tuple(
+        target / source for target, source in zip(original_shape, image.shape)
+    )
+    restored = ndi.zoom(
+        image.astype(np.float32, copy=False),
+        zoom=zoom_factors,
+        order=1,
+        mode="nearest",
+    )
+    restored = _fit_to_shape(restored, original_shape)
+    return restored.astype(np.float32, copy=False)
 
 
 def _markers_from_local_maxima(
@@ -102,28 +272,56 @@ class UFishDetector(SenoQuantSpotDetector):
         settings = kwargs.get("settings", {}) or {}
         threshold = _clamp_threshold(float(settings.get("threshold", DEFAULT_THRESHOLD)))
         use_laplace = USE_LAPLACE_FOR_PEAKS
+        denoise_enabled = bool(settings.get("denoise_enabled", DEFAULT_DENOISE_ENABLED))
+        spot_size = _clamp_spot_size(
+            float(settings.get("spot_size", DEFAULT_SPOT_SIZE))
+        )
+        scale = _spot_size_to_detection_scale(spot_size)
 
         data = layer_data_asarray(layer)
         if data.ndim not in (2, 3):
             raise ValueError("U-FISH detector expects 2D images or 3D stacks.")
 
-        # Percentile normalize the data
-        data = _normalize_unit(data)
+        data = _normalize_input_percentile(data)
+        denoised = _denoise_input(
+            data,
+            enabled=denoise_enabled,
+        )
+        scaled_input = _scale_image_for_detection(denoised, scale)
 
-        enhanced = enhance_image(np.asarray(data, dtype=np.float32), config=UFishConfig())
-        enhanced = np.asarray(enhanced, dtype=np.float32)
+        enhanced_raw = enhance_image(
+            np.asarray(scaled_input, dtype=np.float32),
+            config=UFishConfig(),
+        )
+        enhanced_raw = np.asarray(enhanced_raw, dtype=np.float32)
 
         # Re-normalize after enhancement
-        enhanced = _normalize_unit(enhanced)
+        enhanced_normalized = _normalize_enhanced_unit(enhanced_raw)
+
+        # Segment in original resolution to avoid blocky label upsampling artifacts.
+        enhanced_for_seg = _restore_image_to_input_scale(
+            enhanced_normalized,
+            data.shape,
+        )
 
         markers = _markers_from_local_maxima(
-            enhanced,
+            enhanced_for_seg,
             threshold,
             use_laplace=use_laplace,
         )
         labels = _segment_from_markers(
-            enhanced,
+            enhanced_for_seg,
             markers,
             threshold,
         )
-        return {"mask": labels}
+        # debug_enhanced = _restore_image_to_input_scale(enhanced_raw, data.shape)
+        # debug_enhanced_normalized = enhanced_for_seg
+        return {
+            "mask": labels,
+            # "debug_images": {
+            #     # "debug_normalized_image": normalized.astype(np.float32, copy=False),
+            #     "debug_denoised_image": denoised.astype(np.float32, copy=False),
+            #     "debug_enhanced_image": debug_enhanced,
+            #     "debug_enhanced_image_normalized": debug_enhanced_normalized,
+            # },
+        }

senoquant/tabs/spots/ufish_utils/core.py

@@ -20,6 +20,7 @@ Weight loading priority is:
 from __future__ import annotations
 
 from dataclasses import dataclass
+import logging
 from pathlib import Path
 import sys
 from types import MethodType
@@ -92,6 +93,7 @@ class _UFishState:
 
 _UFISH_STATE = _UFishState()
 _UFISH_HF_FILENAME = "ufish.onnx"
+_LOGGER = logging.getLogger(__name__)
 
 
 def _ensure_ufish_available() -> None:
@@ -353,5 +355,33 @@ def enhance_image(
     model = _get_ufish(config)
     _ensure_weights(model, config)
     image = np.asarray(image)
-    _pred_spots, enhanced = model.predict(image)
+    model_any = cast("Any", model)
+    predict_chunks = getattr(model_any, "predict_chunks", None)
+
+    def _run_inference() -> tuple[Any, Any]:
+        if callable(predict_chunks):
+            return predict_chunks(image)
+        return model_any.predict(image)
+
+    try:
+        _pred_spots, enhanced = _run_inference()
+    except Exception as exc:
+        # If ONNX inference fails on GPU, retry once on CPU provider.
+        weight_path = getattr(model_any, "weight_path", None)
+        can_retry_on_cpu = (
+            ort is not None
+            and isinstance(weight_path, str)
+            and weight_path.endswith(".onnx")
+            and hasattr(model_any, "_load_onnx")
+            and "CPUExecutionProvider" in set(ort.get_available_providers())
+        )
+        if not can_retry_on_cpu:
+            raise
+        _LOGGER.warning(
+            "UFish inference failed; retrying with ONNX CPUExecutionProvider. "
+            "Original error: %s",
+            exc,
+        )
+        model_any._load_onnx(weight_path, providers=["CPUExecutionProvider"])
+        _pred_spots, enhanced = _run_inference()
     return np.asarray(enhanced)

senoquant/tabs/visualization/__init__.py

@@ -0,0 +1 @@
+"""Visualization tab modules."""

senoquant/tabs/visualization/backend.py

@@ -0,0 +1,306 @@
+"""Backend logic for the Visualization tab."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Iterable
+import shutil
+import tempfile
+
+from .plots import PlotConfig
+
+
+@dataclass
+class PlotExportResult:
+    """Output metadata for a single plot export.
+
+    Attributes
+    ----------
+    plot_id : str
+        Stable identifier for the exported plot instance.
+    plot_type : str
+        Plot type name used for routing (e.g., ``"UMAP"``).
+    temp_dir : Path
+        Temporary directory where the plot wrote its outputs.
+    outputs : list of Path
+        Explicit file paths returned by the plot processor.
+    """
+
+    plot_id: str
+    plot_type: str
+    temp_dir: Path
+    outputs: list[Path] = field(default_factory=list)
+
+
+@dataclass
+class VisualizationResult:
+    """Aggregated output information for a visualization run.
+
+    Attributes
+    ----------
+    input_root : Path
+        Root input directory.
+    output_root : Path
+        Root output directory for the run.
+    temp_root : Path
+        Temporary root directory used during processing.
+    plot_outputs : list of PlotExportResult
+        Per-plot export metadata for the run.
+    """
+    input_root: Path
+    output_root: Path
+    temp_root: Path
+    plot_outputs: list[PlotExportResult]
+
+
+class VisualizationBackend:
+    """Backend orchestrator for visualization exports.
+
+    Notes
+    -----
+    Feature export routines live with their feature implementations. The
+    backend iterates through configured feature contexts, asks each feature
+    handler to export into a temporary directory, and then routes those
+    outputs into a final output structure.
+    """
+
+    def __init__(self) -> None:
+        """Initialize the backend state.
+
+        Attributes
+        ----------
+        metrics : list
+            Placeholder container for computed metrics.
+        """
+        self.metrics: list[object] = []
+
+    def process(
+        self,
+        plots: Iterable[object],
+        input_path: Path,
+        output_path: str,
+        output_name: str,
+        export_format: str,
+        markers: list[str] | None = None,
+        thresholds: dict[str, float] | None = None,
+        save: bool = True,
+        cleanup: bool = True,
+    ) -> VisualizationResult:
+        """Run plot exports and route their outputs.
+
+        Parameters
+        ----------
+        plots : iterable of object
+            Plot UI contexts with ``state`` and ``plot_handler``.
+            Each handler should implement ``plot(temp_dir, input_path, export_format)``.
+        input_path : Path
+            Path to the input folder containing quantification files.
+        output_path : str
+            Base output folder path.
+        output_name : str
+            Folder name used to group exported outputs.
+        export_format : str
+            File format requested by the user (``"png"`` or ``"svg"``).
+        markers : list of str, optional
+            List of selected markers to include.
+        thresholds : dict, optional
+            Dictionary of {marker_name: threshold_value} for filtering.
+        save : bool, optional
+            Whether to save (route) the outputs to the final destination immediately.
+        cleanup : bool, optional
+            Whether to delete temporary export folders after routing.
+
+        Returns
+        -------
+        VisualizationResult
+            Output metadata for the completed run.
+
+        Notes
+        -----
+        If a plot export does not return explicit output paths, the backend
+        will move all files found in the plot's temp directory. This allows
+        plot implementations to either return specific files or simply write
+        into the provided temporary directory.
+        """
+        input_root = input_path.parent
+        # Treat `output_path` as the folder and `output_name` as an optional
+        # filename base. Resolve output_root without using output_name so
+        # output_name can be applied as a file name rather than a subfolder.
+        output_root = self._resolve_output_root(output_path, "")
+        output_root.mkdir(parents=True, exist_ok=True)
+        temp_root = Path(tempfile.mkdtemp(prefix="senoquant-plot-"))
+
+        plot_outputs: list[PlotExportResult] = []
+        for context in plots:
+            plot = getattr(context, "state", None)
+            handler = getattr(context, "plot_handler", None)
+            if not isinstance(plot, PlotConfig):
+                continue
+            print(f"[Backend] Processing plot: {plot.type_name}")
+            print(f"[Backend] Handler: {handler}")
+            print(f"[Backend] Handler has plot method: {hasattr(handler, 'plot') if handler else False}")
+            temp_dir = temp_root / plot.plot_id
+            temp_dir.mkdir(parents=True, exist_ok=True)
+            outputs: list[Path] = []
+            if handler is not None and hasattr(handler, "plot"):
+                print(f"[Backend] Calling handler.plot() with input_path={input_path}, format={export_format}")
+                outputs = [
+                    Path(path)
+                    for path in handler.plot(
+                        temp_dir, 
+                        input_path, 
+                        export_format,
+                        markers=markers,
+                        thresholds=thresholds
+                    )
+                ]
+                print(f"[Backend] Handler returned {len(outputs)} outputs: {outputs}")
+            else:
+                print(f"[Backend] Skipping: handler is None or has no plot method")
+            plot_outputs.append(
+                PlotExportResult(
+                    plot_id=plot.plot_id,
+                    plot_type=plot.type_name,
+                    temp_dir=temp_dir,
+                    outputs=outputs,
+                )
+            )
+
+        if save:
+            print(f"[Backend] About to route {len(plot_outputs)} plot outputs")
+            self._route_plot_outputs(output_root, plot_outputs, output_name)
+        if cleanup:
+            shutil.rmtree(temp_root, ignore_errors=True)
+        return VisualizationResult(
+            input_root=input_root,
+            output_root=output_root,
+            temp_root=temp_root,
+            plot_outputs=plot_outputs,
+        )
+
+    def save_result(
+        self, 
+        result: VisualizationResult, 
+        output_path: str, 
+        output_name: str
+    ) -> None:
+        """Save an existing visualization result to the specified output.
+
+        This moves/copies files from the result's temporary directory (or previous location)
+        to the new output path.
+        """
+        output_root = self._resolve_output_root(output_path, "")
+        output_root.mkdir(parents=True, exist_ok=True)
+        result.output_root = output_root
+        self._route_plot_outputs(output_root, result.plot_outputs, output_name)
+
+    def _resolve_output_root(self, output_path: str, output_name: str) -> Path:
+        """Resolve the final output root directory.
+
+        Parameters
+        ----------
+        output_path : str
+            Base output folder path.
+        output_name : str
+            Folder name used to group exported outputs.
+
+        Returns
+        -------
+        Path
+            Resolved output directory path.
+        """
+        if output_path and output_path.strip():
+            base = Path(output_path)
+        else:
+            # Default to repository root (current working directory)
+            base = Path.cwd()
+        if output_name and output_name.strip():
+            return base / output_name
+        return base
+
+    def _route_plot_outputs(
+        self,
+        output_root: Path,
+        plot_outputs: Iterable[PlotExportResult],
+        output_name: str = "",
+    ) -> None:
+        """Move plot outputs from temp folders to the final location.
+
+        Parameters
+        ----------
+        output_root : Path
+            Destination root folder.
+        plot_outputs : iterable of PlotExportResult
+            Export results to route.
+
+        Notes
+        -----
+        When a plot returns no explicit output list, all files present
+        in the temporary directory are routed instead. Subdirectories are
+        not traversed.
+        """
+        for plot_output in plot_outputs:
+            print(f"[Backend] Routing {plot_output.plot_type} to {output_root}")
+            final_paths: list[Path] = []
+            outputs = plot_output.outputs
+            # Choose source list: explicit outputs if provided, otherwise files
+            # from the temp directory.
+            source_files: list[Path] = []
+            if outputs:
+                source_files = [p for p in outputs if Path(p).exists()]
+            else:
+                source_files = [p for p in plot_output.temp_dir.glob("*") if p.is_file()]
+
+            if not source_files:
+                print(f"[Backend]   No files to route for {plot_output.plot_type}")
+                plot_output.outputs = []
+                continue
+
+            # If the caller provided output_name, use it as the base filename.
+            for idx, src in enumerate(source_files):
+                src = Path(src)
+                ext = src.suffix
+                if output_name and output_name.strip():
+                    # If multiple files, append an index to avoid collisions.
+                    if len(source_files) == 1:
+                        dest_name = f"{output_name}{ext}"
+                    else:
+                        dest_name = f"{output_name}_{idx+1}{ext}"
+                else:
+                    # Fallback: prefix with plot type for clarity
+                    safe_type = plot_output.plot_type.replace(' ', '_')
+                    dest_name = f"{safe_type}_{src.name}"
+                dest = output_root / dest_name
+                print(f"[Backend]   Copying {src} -> {dest}")
+                try:
+                    shutil.copy2(str(src), dest)
+                except shutil.SameFileError:
+                    print(f"[Backend]   Skipping copy: source and destination are the same ({dest})")
+                final_paths.append(dest)
+
+            # Update plot_output.outputs to point at final routed files
+            plot_output.outputs = final_paths
+
+    def _plot_dir_name(self, plot_output: PlotExportResult) -> str:
+        """Build a filesystem-friendly folder name for a plot.
+
+        Parameters
+        ----------
+        plot_output : PlotExportResult
+            Export result metadata.
+
+        Returns
+        -------
+        str
+            Directory name for the plot outputs.
+
+        Notes
+        -----
+        Non-alphanumeric characters are replaced to avoid filesystem issues.
+        """
+        name = plot_output.plot_type.strip()
+        safe = "".join(
+            char if char.isalnum() or char in "-_ " else "_" for char in name
+        )
+        return safe.replace(" ", "_").lower()