setiastrosuitepro 1.6.1__py3-none-any.whl

setiastro/saspro/imageops/__init__.py

@@ -0,0 +1,37 @@
+# imageops/__init__.py
+
+from .stretch import (
+    stretch_mono_image,
+    stretch_color_image,
+    apply_curves_adjustment,
+)
+
+# --- Backward-compatible aliases (old SASv2-style names) ---
+def stretch_color_image_linked(img, target_median, normalize=False,
+                               apply_curves=False, curves_boost=0.0):
+    return stretch_color_image(
+        img, target_median,
+        linked=True,
+        normalize=normalize,
+        apply_curves=apply_curves,
+        curves_boost=curves_boost,
+    )
+
+def stretch_color_image_unlinked(img, target_median, normalize=False,
+                                 apply_curves=False, curves_boost=0.0):
+    return stretch_color_image(
+        img, target_median,
+        linked=False,
+        normalize=normalize,
+        apply_curves=apply_curves,
+        curves_boost=curves_boost,
+    )
+
+__all__ = [
+    "stretch_mono_image",
+    "stretch_color_image",
+    "apply_curves_adjustment",
+    "stretch_color_image_linked",
+    "stretch_color_image_unlinked",
+    "apply_average_neutral_scnr",
+]

setiastro/saspro/imageops/mdi_snap.py

@@ -0,0 +1,292 @@
+# pro/mdi_snap.py
+from __future__ import annotations
+from PyQt6.QtCore import Qt, QRect, QPoint, QObject, QEvent, QSize
+from PyQt6.QtGui import QPainter, QPen, QPalette
+from PyQt6.QtWidgets import QWidget, QMdiArea, QMdiSubWindow
+
+def _dpi_scaled(widget: QWidget, px: int) -> int:
+    try:
+        ratio = float(widget.devicePixelRatioF())
+    except Exception:
+        ratio = 1.0
+    return max(1, int(round(px * ratio)))
+
+class _GuideOverlay(QWidget):
+    """Thin, non-interactive overlay that draws snap guides on the MDI viewport."""
+    def __init__(self, parent: QWidget):
+        super().__init__(parent)
+        self.setAttribute(Qt.WidgetAttribute.WA_TransparentForMouseEvents, True)
+        self.setAttribute(Qt.WidgetAttribute.WA_NoSystemBackground, True)
+        self._rects: list[QRect] = []
+        self.hide()
+
+    def set_guides(self, rects: list[QRect]):
+        self._rects = rects or []
+        if self._rects:
+            if self.isHidden():
+                self.show()
+        else:
+            if self.isVisible():
+                self.hide()
+        self.update()
+
+    def paintEvent(self, _ev):
+        if not self._rects:
+            return
+        p = QPainter(self)
+        pen = QPen()
+        pen.setWidth(1)
+        pen.setColor(self.palette().color(QPalette.ColorRole.Highlight))
+        pen.setStyle(Qt.PenStyle.SolidLine)
+        p.setPen(pen)
+        for r in self._rects:
+            p.drawRect(r)
+
+class MdiSnapController(QObject):
+    """
+    Adds 'sticky' snapping for QMdiSubWindow edges inside a QMdiArea (Qt6-safe).
+    - Snaps to sibling subwindow edges and viewport edges.
+    - Shows faint guide lines while snapping.
+    - Hold Alt to temporarily disable snapping.
+    """
+    def __init__(self, mdi: QMdiArea, threshold_px: int = 8, show_guides: bool = False):
+        super().__init__(mdi)
+        self.mdi = mdi
+        self.view = mdi.viewport()  # geometry space of subwindows
+        self.overlay = _GuideOverlay(self.view)
+        self.threshold = max(1, int(threshold_px))
+        self._active: QMdiSubWindow | None = None
+        self._snap_enabled = True
+        self._show_guides = bool(show_guides)
+        self._install()
+
+    def set_show_guides(self, enabled: bool):
+        self._show_guides = bool(enabled)
+        if not self._show_guides:
+            self.overlay.set_guides([])
+
+    # --- public knobs ---
+    def set_threshold(self, px: int):
+        self.threshold = max(1, int(px))
+
+    def install_on(self, sub: QMdiSubWindow):
+        # Avoid double-install
+        sub.removeEventFilter(self)
+        sub.installEventFilter(self)
+
+    # --- internals ---
+    def _install(self):
+        # Track active subwindow
+        self.mdi.subWindowActivated.connect(self._on_activated)
+
+        # Watch existing subs
+        for sw in self.mdi.subWindowList():
+            self.install_on(sw)
+
+        # Keep overlay matched to viewport size/visibility
+        self.view.installEventFilter(self)
+        self.overlay.setGeometry(self.view.rect())
+
+        # Periodically re-check list on activation (new windows)
+        self.mdi.subWindowActivated.connect(lambda _sw: self._refresh_watch_list())
+
+    def _refresh_watch_list(self):
+        for sw in self.mdi.subWindowList():
+            self.install_on(sw)
+
+    def _on_activated(self, sw: QMdiSubWindow | None):
+        self._active = sw
+
+    # Gather candidate snap edges (x/y positions) from siblings & viewport
+    def _collect_edges(self, ignore: QMdiSubWindow | None):
+        siblings = [s for s in self.mdi.subWindowList() if s is not ignore]
+        vp = self.view.rect()
+
+        xs, ys = set(), set()
+        rects = []
+        for s in siblings:
+            r = s.geometry()  # already in viewport coords
+            rects.append(r)
+            xs.update([r.left(), r.right()])
+            ys.update([r.top(), r.bottom()])
+
+        # viewport edges (no center)
+        xs.update([vp.left(), vp.right()])
+        ys.update([vp.top(), vp.bottom()])
+        return sorted(xs), sorted(ys), rects, vp
+
+    @staticmethod
+    def _nearest(value: int, candidates: list[int], tol: int) -> tuple[bool, int]:
+        """
+        Return (True, snapped_value) if any candidate is within tol of value,
+        otherwise (False, value).
+        """
+        best_val = value
+        best_d = tol + 1
+        for c in candidates:
+            d = abs(c - value)
+            if d < best_d:
+                best_d = d
+                best_val = c
+        if best_d <= tol:
+            return True, best_val
+        return False, value
+
+    def _build_guides(self, snap_rect: QRect, vp: QRect) -> list[QRect]:
+        """Horizontal and vertical guides along the snapped rect edges."""
+        lines: list[QRect] = []
+        w = _dpi_scaled(self.view, 2)
+        # horizontal
+        lines.append(QRect(vp.left(), snap_rect.top(), vp.width(), w))
+        lines.append(QRect(vp.left(), snap_rect.bottom(), vp.width(), w))
+        # vertical
+        lines.append(QRect(snap_rect.left(), vp.top(), w, vp.height()))
+        lines.append(QRect(snap_rect.right(), vp.top(), w, vp.height()))
+        return lines
+
+    def _snap_geometry(
+        self,
+        g: QRect,
+        xs: list[int],
+        ys: list[int],
+        tol: int,
+        size_snap: bool
+    ) -> tuple[QRect, list[QRect]]:
+        """
+        - If size_snap is False (Move): keep W/H fixed and move the rect so the
+          nearest edges line up with candidates.
+        - If size_snap is True (Resize): keep top/left fixed and adjust W/H so
+          right/bottom edges snap to nearby candidates.
+        """
+        L, T = g.left(), g.top()
+        W, H = g.width(), g.height()
+        R, B = L + W - 1, T + H - 1
+
+        vp = self.view.rect()
+        snapped = False
+
+        if not size_snap:
+            # --- MOVE MODE: translate the rect, no size change ---
+            okL, snapL = self._nearest(L, xs, tol)
+            okR, snapR = self._nearest(R, xs, tol)
+
+            dx = 0
+            if okL and okR:
+                dL = snapL - L
+                dR = snapR - R
+                dx = dL if abs(dL) <= abs(dR) else dR
+                snapped = True
+            elif okL:
+                dx = snapL - L
+                snapped = True
+            elif okR:
+                dx = snapR - R
+                snapped = True
+
+            okT, snapT = self._nearest(T, ys, tol)
+            okB, snapB = self._nearest(B, ys, tol)
+
+            dy = 0
+            if okT and okB:
+                dT = snapT - T
+                dB = snapB - B
+                dy = dT if abs(dT) <= abs(dB) else dB
+                snapped = True
+            elif okT:
+                dy = snapT - T
+                snapped = True
+            elif okB:
+                dy = snapB - B
+                snapped = True
+
+            new_L = L + dx
+            new_T = T + dy
+            g2 = QRect(QPoint(new_L, new_T), QSize(W, H))
+
+        else:
+            # --- RESIZE MODE: keep L/T fixed, snap R/B by changing W/H ---
+            okR, snapR = self._nearest(R, xs, tol)
+            okB, snapB = self._nearest(B, ys, tol)
+
+            new_W = W
+            new_H = H
+
+            if okR:
+                new_W = max(1, (snapR - L + 1))
+                snapped = True
+            if okB:
+                new_H = max(1, (snapB - T + 1))
+                snapped = True
+
+            g2 = QRect(QPoint(L, T), QSize(new_W, new_H))
+
+        guides = (
+            self._build_guides(g2, vp)
+            if (snapped and self._show_guides)
+            else []
+        )
+        return g2, guides
+    
+    # --- Event filter on each subwindow + viewport ---
+    def eventFilter(self, obj: QObject, ev: QEvent) -> bool:
+        t = ev.type()
+
+        # Keep overlay sized to the viewport
+        if obj is self.view:
+            if t == QEvent.Type.Resize:
+                self.overlay.setGeometry(self.view.rect())
+                self.overlay.update()
+            elif t in _CLEAR_EVENTS:
+                self.overlay.set_guides([])
+            return False
+
+        if not isinstance(obj, QMdiSubWindow):
+            return super().eventFilter(obj, ev)
+
+        # Alt disables snapping while held
+        try:
+            mods = obj.window().keyboardModifiers()
+            self._snap_enabled = not bool(mods & Qt.KeyboardModifier.AltModifier)
+        except Exception:
+            self._snap_enabled = True
+
+        if t in (QEvent.Type.Move, QEvent.Type.Resize):
+            if not self._snap_enabled:
+                self.overlay.set_guides([])
+                return super().eventFilter(obj, ev)
+
+            xs, ys, _rects, _vp = self._collect_edges(ignore=obj)
+            tol = _dpi_scaled(self.view, self.threshold)
+            cur = obj.geometry()
+
+            # <<< key change: size_snap only during Resize >>>
+            size_snap = (t == QEvent.Type.Resize)
+            snapped_rect, guides = self._snap_geometry(
+                cur, xs, ys, tol, size_snap=size_snap
+            )
+
+            if snapped_rect != cur:
+                # Minimize feedback loops
+                obj.blockSignals(True)
+                try:
+                    obj.setGeometry(snapped_rect)
+                finally:
+                    obj.blockSignals(False)
+
+            self.overlay.set_guides(guides if (self._show_guides and guides) else [])
+            return False
+
+        # Qt6-safe "clear overlay" conditions
+        if t in (QEvent.Type.Hide, QEvent.Type.Leave):
+            if self._show_guides:
+                self.overlay.set_guides([])
+
+        return super().eventFilter(obj, ev)
+
+
+# ---- Qt6-safe clear events set (no MoveAboutToBeAnimated) -------------------
+_CLEAR_EVENTS = set()
+for _name in ("Hide", "Leave", "MouseButtonRelease", "WindowDeactivate", "FocusOut"):
+    _val = getattr(QEvent.Type, _name, None)
+    if _val is not None:
+        _CLEAR_EVENTS.add(_val)

setiastro/saspro/imageops/scnr.py

@@ -0,0 +1,36 @@
+# pro/imageops/scnr.py
+from __future__ import annotations
+import numpy as np
+
+def apply_average_neutral_scnr(image: np.ndarray, amount: float = 1.0) -> np.ndarray:
+    """
+    Average Neutral SCNR (green removal).
+    Expects an RGB image normalized to [0, 1]. Returns float32 in [0, 1].
+
+    amount: 0.0 → no effect, 1.0 → full SCNR
+    """
+    if not isinstance(image, np.ndarray):
+        raise TypeError("Input image must be a NumPy array.")
+    if image.ndim != 3 or image.shape[2] != 3:
+        raise ValueError("Input image must have three channels (RGB).")
+    if not (0.0 <= amount <= 1.0):
+        raise ValueError("Amount parameter must be between 0.0 and 1.0.")
+
+    img = image.astype(np.float32, copy=False)
+
+    R = img[..., 0]
+    G = img[..., 1]
+    B = img[..., 2]
+
+    # G' = min(G, 0.5*(R + B)) - optimized: compute blended G directly without full array copy
+    G_scnr = np.minimum(G, 0.5 * (R + B))
+    
+    # Blend original G and SCNR G directly: avoids allocating a full copy of the image
+    G_blended = G + amount * (G_scnr - G)  # Equivalent to (1-amount)*G + amount*G_scnr
+    
+    # Build output array only once
+    out = np.empty_like(img, dtype=np.float32)
+    out[..., 0] = R
+    out[..., 1] = np.clip(G_blended, 0.0, 1.0)
+    out[..., 2] = B
+    return out

setiastro/saspro/imageops/starbasedwhitebalance.py

@@ -0,0 +1,210 @@
+# imageops/starbasedwhitebalance.py
+from __future__ import annotations
+
+import numpy as np
+
+# Optional deps
+try:
+    import cv2  # for ellipse overlay
+except Exception:  # pragma: no cover
+    cv2 = None
+
+try:
+    import sep  # Source Extractor
+except Exception as e:  # pragma: no cover
+    sep = None
+    _sep_import_error = e
+else:
+    _sep_import_error = None
+
+from typing import Tuple, Optional
+from .stretch import stretch_color_image
+
+# Shared utilities
+from setiastro.saspro.widgets.image_utils import to_float01 as _to_float01
+
+__all__ = ["apply_star_based_white_balance"]
+
+# simple cache (reused when reuse_cached_sources=True)
+cached_star_sources: Optional[np.ndarray] = None
+cached_flux_radii: Optional[np.ndarray] = None
+
+
+def _tone_preserve_bg_neutralize(rgb: np.ndarray) -> np.ndarray:
+    """
+    Neutralize background using the darkest grid patch in a tone-preserving way.
+    Operates in-place on a copy; returns the neutralized image (float32 [0,1]).
+    """
+    h, w = rgb.shape[:2]
+    patch_size = 10
+    ph = max(1, h // patch_size)
+    pw = max(1, w // patch_size)
+
+    best = None
+    best_sum = float("inf")
+    for i in range(patch_size):
+        for j in range(patch_size):
+            y0, x0 = i * ph, j * pw
+            y1, x1 = min(y0 + ph, h), min(x0 + pw, w)
+            patch = rgb[y0:y1, x0:x1, :]
+            med = np.median(patch, axis=(0, 1))
+            s = float(np.sum(med))
+            if s < best_sum:
+                best_sum = s
+                best = med
+
+    out = rgb.copy()
+    if best is not None:
+        avg = float(np.mean(best))
+        # “tone-preserving” shift+scale channel-wise toward avg
+        for c in range(3):
+            diff = float(best[c] - avg)
+            denom = (1.0 - diff) if abs(1.0 - diff) > 1e-8 else 1e-8
+            out[:, :, c] = np.clip((out[:, :, c] - diff) / denom, 0.0, 1.0)
+    return out
+
+
+def apply_star_based_white_balance(
+    image: np.ndarray,
+    threshold: float = 1.5,
+    autostretch: bool = True,
+    reuse_cached_sources: bool = False,
+    return_star_colors: bool = False
+) -> Tuple[np.ndarray, int, np.ndarray, np.ndarray, np.ndarray] | Tuple[np.ndarray, int, np.ndarray]:
+    """
+    Star-based white balance with background neutralization and an RGB overlay of detected stars.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        RGB image (any dtype). Assumed RGB ordering.
+    threshold : float
+        SExtractor detection threshold (in background sigma).
+    autostretch : bool
+        If True, overlay is built from an autostretched view for visibility.
+    reuse_cached_sources : bool
+        If True, reuses star positions measured on a previous call (same scene).
+    return_star_colors : bool
+        If True, also returns (raw_star_pixels, after_star_pixels).
+
+    Returns
+    -------
+    balanced_rgb : float32 RGB in [0,1]
+    star_count   : int
+    overlay_rgb  : float32 RGB in [0,1] with star ellipses drawn
+    (optional) raw_star_pixels : (N,3) float array, colors sampled from ORIGINAL image
+    (optional) after_star_pixels : (N,3) float array, colors sampled after WB
+    """
+    if image.ndim != 3 or image.shape[2] != 3:
+        raise ValueError("apply_star_based_white_balance: input must be an RGB image (H,W,3).")
+
+    # 0) normalize
+    img_rgb = _to_float01(image)
+
+    # 1) first background neutralization (tone-preserving)
+    bg_neutral = _tone_preserve_bg_neutralize(img_rgb)
+
+    # 2) detect / reuse star positions
+    if sep is None:
+        raise ImportError(
+            "apply_star_based_white_balance requires the 'sep' package. "
+            f"Import error was: {_sep_import_error!r}"
+        )
+
+    gray = np.mean(bg_neutral, axis=2).astype(np.float32, copy=False)
+    bkg = sep.Background(gray)
+    data_sub = gray - bkg.back()
+    err_val = float(bkg.globalrms)
+
+    global cached_star_sources, cached_flux_radii
+
+    if reuse_cached_sources and cached_star_sources is not None:
+        sources = cached_star_sources
+        r = cached_flux_radii
+    else:
+        sources = sep.extract(data_sub, threshold, err=err_val)
+        if sources is None or len(sources) == 0:
+            raise ValueError("No sources detected for Star-Based White Balance.")
+        r, _ = sep.flux_radius(
+            gray,
+            sources["x"], sources["y"],
+            2.0 * sources["a"], 0.2,
+            normflux=sources["flux"],
+            subpix=5
+        )
+        cached_star_sources = sources
+        cached_flux_radii = r
+
+    # filter: small-ish, star-like
+    mask = (r > 0) & (r <= 10)
+    sources = sources[mask]
+    r = r[mask]
+    if len(sources) == 0:
+        raise ValueError("All detected sources were rejected as non-stellar (too large).")
+
+    h, w = gray.shape
+    # raw colors from ORIGINAL image - optimized vectorized extraction
+    xs = sources["x"].astype(np.int32)
+    ys = sources["y"].astype(np.int32)
+    valid = (xs >= 0) & (xs < w) & (ys >= 0) & (ys < h)
+    raw_star_pixels = img_rgb[ys[valid], xs[valid], :]
+
+    # 3) build overlay (autostretched if requested) and draw ellipses
+    disp = stretch_color_image(bg_neutral.copy(), 0.25) if autostretch else bg_neutral.copy()
+
+    if cv2 is not None:
+        overlay_bgr = cv2.cvtColor((disp * 255).astype(np.uint8), cv2.COLOR_RGB2BGR)
+        for i in range(len(sources)):
+            cx = float(sources["x"][i]); cy = float(sources["y"][i])
+            a = float(sources["a"][i]); b = float(sources["b"][i])
+            theta_deg = float(sources["theta"][i] * 180.0 / np.pi)
+            center = (int(round(cx)), int(round(cy)))
+            axes = (max(1, int(round(3 * a))), max(1, int(round(3 * b))))
+            # red ellipse in BGR
+            cv2.ellipse(overlay_bgr, center, axes, angle=theta_deg, startAngle=0, endAngle=360,
+                        color=(0, 0, 255), thickness=1)
+        overlay_rgb = cv2.cvtColor(overlay_bgr, cv2.COLOR_BGR2RGB).astype(np.float32) / 255.0
+    else:
+        # fallback: no ellipses, just the display image
+        overlay_rgb = disp.astype(np.float32, copy=False)
+
+    # 4) compute WB scale using star colors sampled on bg_neutral image
+    # Optimized: vectorized extraction instead of Python loop (10-50x faster)
+    xs = sources["x"].astype(np.int32)
+    ys = sources["y"].astype(np.int32)
+    valid_mask = (xs >= 0) & (xs < w) & (ys >= 0) & (ys < h)
+    
+    if not np.any(valid_mask):
+        raise ValueError("No stellar samples available for white balance.")
+    
+    star_pixels = bg_neutral[ys[valid_mask], xs[valid_mask], :].astype(np.float32)
+    avg_color = np.mean(star_pixels, axis=0)
+    max_val = float(np.max(avg_color))
+    # protect against divide-by-zero
+    avg_color = np.where(avg_color <= 1e-8, 1e-8, avg_color)
+    scaling = max_val / avg_color
+
+    balanced = (bg_neutral * scaling.reshape((1, 1, 3))).clip(0.0, 1.0)
+
+    # 5) second background neutralization pass on balanced image
+    balanced = _tone_preserve_bg_neutralize(balanced)
+
+    # 6) collect after-WB star samples - optimized vectorized extraction
+    after_star_pixels = balanced[ys[valid_mask], xs[valid_mask], :]
+
+    if return_star_colors:
+        return (
+            balanced.astype(np.float32, copy=False),
+            int(len(star_pixels)),
+            overlay_rgb.astype(np.float32, copy=False),
+            np.asarray(raw_star_pixels, dtype=np.float32),
+            np.asarray(after_star_pixels, dtype=np.float32),
+        )
+
+    return (
+        balanced.astype(np.float32, copy=False),
+        int(len(star_pixels)),
+        overlay_rgb.astype(np.float32, copy=False),
+    )
+
+