setiastrosuitepro 1.6.0__py3-none-any.whl → 1.6.4.post1__py3-none-any.whl

setiastro/saspro/live_stacking.py

@@ -48,6 +48,9 @@ class LiveStackSettingsDialog(QDialog):
     def __init__(self, parent):
         super().__init__(parent)
         self.setWindowTitle("Live Stack & Culling Settings")
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
 
         # — Live Stack Settings —
         # Bootstrap frames (int)
@@ -290,8 +293,16 @@ def estimate_global_snr(
 
     # 1) Collapse to simple 2D float array (grayscale)
     if stack_image.ndim == 3 and stack_image.shape[2] == 3:
-        # RGB → grayscale by averaging channels
-        gray = stack_image.mean(axis=2).astype(np.float32)
+        try:
+            import cv2
+            # cv2.cvtColor is significantly faster than mean(axis=2)
+            # Assuming RGB input, but even if BGR, for SNR estimation luma difference is negligible
+            gray = cv2.cvtColor(stack_image, cv2.COLOR_RGB2GRAY)
+            if gray.dtype != np.float32:
+                gray = gray.astype(np.float32)
+        except ImportError:
+            # Fallback
+            gray = stack_image.mean(axis=2).astype(np.float32)
     else:
         # Already mono: just cast to float32
         gray = stack_image.astype(np.float32)

setiastro/saspro/mask_creation.py

@@ -17,7 +17,7 @@ except Exception:
 from PyQt6.QtCore import Qt, QPointF, QRectF, QTimer, QEvent
 from PyQt6.QtGui import (
     QImage, QPixmap, QPainter, QColor, QPen, QBrush,
-    QPainterPath, QWheelEvent, QPolygonF
+    QPainterPath, QWheelEvent, QPolygonF, QMouseEvent
 )
 from PyQt6.QtWidgets import (
     QInputDialog, QMessageBox, QFileDialog,   # QFileDialog only used if you later add “export”
@@ -32,7 +32,7 @@ from PyQt6.QtWidgets import (
 
 from .masks_core import MaskLayer
 from setiastro.saspro.widgets.themed_buttons import themed_toolbtn
-
+from setiastro.saspro.imageops.stretch import stretch_color_image
 
 # ---------- small utils ----------
 
@@ -48,6 +48,38 @@ def _to_qpixmap01(img01: np.ndarray) -> QPixmap:
         qimg = QImage(buf.data, w, h, buf.strides[0], QImage.Format.Format_RGB888)
     return QPixmap.fromImage(qimg)
 
+def _display_stretch(img01: np.ndarray) -> np.ndarray:
+    """
+    Display-only stretch. Does NOT modify underlying data used for mask creation.
+    Returns float32 in [0,1].
+    """
+    a = np.asarray(img01, dtype=np.float32)
+    a = np.clip(a, 0.0, 1.0)
+
+    # Color: use your existing stretch if available
+    if a.ndim == 3 and a.shape[2] == 3 and stretch_color_image is not None:
+        try:
+            return np.clip(stretch_color_image(a, 0.25, linked=False, normalize=False), 0.0, 1.0).astype(np.float32)
+        except Exception:
+            pass
+
+    # Mono (or fallback): simple robust stretch around median
+    # (keeps it predictable and fast; display-only)
+    m = float(np.nanmedian(a))
+    if not np.isfinite(m):
+        return a.astype(np.float32, copy=False)
+
+    # Simple gamma-like lift using median anchor
+    # If median is tiny, boost; if already bright, minimal change.
+    target = 0.25
+    eps = 1e-8
+    scale = target / max(m, eps)
+    out = np.clip(a * scale, 0.0, 1.0)
+
+    # Gentle midtone curve
+    out = np.sqrt(out)
+    return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
 
 def _find_main_window(w):
     p = w
@@ -248,10 +280,14 @@ class MaskCanvas(QGraphicsView):
         super().__init__(parent)
         self.setRenderHint(QPainter.RenderHint.Antialiasing)
 
+        self._base_image01 = np.asarray(image01, dtype=np.float32)
+        self._display_stretch_enabled = False
+
         # scene + background image
         self.scene = QGraphicsScene(self)
         self.setScene(self.scene)
-        self.bg_item = QGraphicsPixmapItem(_to_qpixmap01(image01))
+
+        self.bg_item = QGraphicsPixmapItem(_to_qpixmap01(self._base_image01))
         self.scene.addItem(self.bg_item)
 
         # --- NEW: basic zoom state ---
@@ -306,6 +342,38 @@ class MaskCanvas(QGraphicsView):
         super().wheelEvent(ev)
     # ----------------- END: Zoom API ---------------------
 
+    def set_display_stretch_enabled(self, enabled: bool):
+        enabled = bool(enabled)
+        if enabled == self._display_stretch_enabled:
+            return
+        self._display_stretch_enabled = enabled
+        self._refresh_background_pixmap(keep_view=True)
+
+    def display_stretch_enabled(self) -> bool:
+        return bool(self._display_stretch_enabled)
+
+    def current_display_image01(self) -> np.ndarray:
+        """Returns the image currently used for *display* (not for mask math)."""
+        if self._display_stretch_enabled:
+            return _display_stretch(self._base_image01)
+        return self._base_image01
+
+    def _refresh_background_pixmap(self, keep_view: bool = True):
+        # Preserve current view transform/center so toggling doesn't “jump”
+        old_transform = self.transform()
+        old_center = self.mapToScene(self.viewport().rect().center())
+
+        disp = self.current_display_image01()
+        self.bg_item.setPixmap(_to_qpixmap01(disp))
+
+        # Ensure scene rect still matches image pixels
+        self.setSceneRect(self.bg_item.boundingRect())
+
+        if keep_view:
+            self.setTransform(old_transform)
+            self.centerOn(old_center)
+
+
     def set_mode(self, mode: str):
         assert mode in ('polygon', 'ellipse', 'select')
         self.mode = mode
@@ -432,7 +500,7 @@ class MaskCanvas(QGraphicsView):
 class LivePreviewDialog(QDialog):
     def __init__(self, original_image01: np.ndarray, parent=None):
         super().__init__(parent)
-        self.setWindowTitle("Live Mask Preview")
+        self.setWindowTitle(self.tr("Live Mask Preview"))
         self.label = QLabel(alignment=Qt.AlignmentFlag.AlignCenter)
         lay = QVBoxLayout(self); lay.addWidget(self.label)
         self.resize(300, 300)
@@ -453,39 +521,61 @@ class LivePreviewDialog(QDialog):
                                            Qt.AspectRatioMode.KeepAspectRatio,
                                            Qt.TransformationMode.SmoothTransformation))
 
+    def set_base_image(self, image01: np.ndarray):
+        self.base_pixmap = _to_qpixmap01(image01)
 
 # ---------- Preview (push-as-doc) ----------
-
 class MaskPreviewDialog(QDialog):
     """Scrollable preview + 'Push as New Document…'."""
     def __init__(self, mask01: np.ndarray, parent=None):
         super().__init__(parent)
-        self.setWindowTitle("Mask Preview")
+        self.setWindowTitle(self.tr("Mask Preview"))
         self.mask = np.clip(mask01, 0, 1).astype(np.float32)
 
-        self.scroll = QScrollArea(self); self.scroll.setWidgetResizable(False)
+        # --- drag-pan state ---
+        self._dragging = False
+        self._drag_start = None
+        self._h_start = 0
+        self._v_start = 0
+
+        # Build UI first
+        self.scroll = QScrollArea(self)
+        self.scroll.setWidgetResizable(False)
         self.scroll.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
         self.label = QLabel(alignment=Qt.AlignmentFlag.AlignCenter)
         self.label.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
-        self.pixmap = self._to_pixmap(self.mask); self.label.setPixmap(self.pixmap)
+
+        self.pixmap = self._to_pixmap(self.mask)
+        self.label.setPixmap(self.pixmap)
+        self.label.resize(self.pixmap.size())
+
         self.scroll.setWidget(self.label)
 
+        # Enable mouse drag panning on the label (NOW label exists)
+        self.label.setMouseTracking(True)
+        self.label.installEventFilter(self)
+
         btns = QHBoxLayout()
         b_in   = themed_toolbtn("zoom-in", "Zoom In")
         b_out  = themed_toolbtn("zoom-out", "Zoom Out")
         b_fit  = themed_toolbtn("zoom-fit-best", "Fit to Preview")
+        b_push = QPushButton(self.tr("Push as New Document…"))
 
-
-        b_push = QPushButton("Push as New Document…")
         b_in.clicked.connect(lambda: self._zoom(1.2))
         b_out.clicked.connect(lambda: self._zoom(1/1.2))
         b_fit.clicked.connect(self._fit)
         b_push.clicked.connect(self.push_as_new_document)
+
         for b in (b_in, b_out, b_fit, b_push):
             btns.addWidget(b)
 
-        lay = QVBoxLayout(self); lay.addWidget(self.scroll); lay.addLayout(btns)
-        self.scale = 1.0; self.setMinimumSize(600, 400)
+        lay = QVBoxLayout(self)
+        lay.addWidget(self.scroll)
+        lay.addLayout(btns)
+
+        self.scale = 1.0
+        self.setMinimumSize(600, 400)
 
     def _to_pixmap(self, mask01: np.ndarray) -> QPixmap:
         m8 = (np.clip(mask01, 0, 1) * 255).astype(np.uint8)
@@ -495,17 +585,52 @@ class MaskPreviewDialog(QDialog):
 
     def _zoom(self, factor: float):
         self.scale *= factor
-        scaled = self.pixmap.scaled(self.pixmap.size() * self.scale,
-                                    Qt.AspectRatioMode.KeepAspectRatio,
-                                    Qt.TransformationMode.SmoothTransformation)
-        self.label.setPixmap(scaled); self.label.resize(scaled.size())
+        scaled = self.pixmap.scaled(
+            self.pixmap.size() * self.scale,
+            Qt.AspectRatioMode.KeepAspectRatio,
+            Qt.TransformationMode.SmoothTransformation
+        )
+        self.label.setPixmap(scaled)
+        self.label.resize(scaled.size())
 
     def _fit(self):
         vp = self.scroll.viewport().size()
         if self.pixmap.width() and self.pixmap.height():
             s = min(vp.width()/self.pixmap.width(), vp.height()/self.pixmap.height())
             self.scale = max(0.05, s)
-            self._zoom(1.0)
+            # re-render at the new scale (don’t multiply again)
+            scaled = self.pixmap.scaled(
+                self.pixmap.size() * self.scale,
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation
+            )
+            self.label.setPixmap(scaled)
+            self.label.resize(scaled.size())
+
+    def eventFilter(self, obj, ev):
+        if obj is self.label:
+            if ev.type() == QEvent.Type.MouseButtonPress and ev.button() == Qt.MouseButton.LeftButton:
+                self._dragging = True
+                self._drag_start = ev.globalPosition().toPoint()
+                self._h_start = self.scroll.horizontalScrollBar().value()
+                self._v_start = self.scroll.verticalScrollBar().value()
+                self.setCursor(Qt.CursorShape.ClosedHandCursor)
+                return True
+
+            if ev.type() == QEvent.Type.MouseMove and self._dragging:
+                p = ev.globalPosition().toPoint()
+                d = p - self._drag_start
+                self.scroll.horizontalScrollBar().setValue(self._h_start - d.x())
+                self.scroll.verticalScrollBar().setValue(self._v_start - d.y())
+                return True
+
+            if ev.type() == QEvent.Type.MouseButtonRelease and ev.button() == Qt.MouseButton.LeftButton:
+                self._dragging = False
+                self._drag_start = None
+                self.unsetCursor()
+                return True
+
+        return super().eventFilter(obj, ev)
 
     def push_as_new_document(self):
         if self.mask is None:
@@ -554,7 +679,10 @@ class MaskCreationDialog(QDialog):
     """Mask creation UI for SASpro documents (returns a np mask on OK)."""
     def __init__(self, image01: np.ndarray, parent=None, auto_push_on_ok: bool = True):
         super().__init__(parent)
-        self.setWindowTitle("Mask Creation")
+        self.setWindowTitle(self.tr("Mask Creation"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.image = np.asarray(image01, dtype=np.float32).copy()
         self.mask: np.ndarray | None = None
         self.live_preview = LivePreviewDialog(self.image, parent=self)
@@ -572,9 +700,9 @@ class MaskCreationDialog(QDialog):
 
         # Mode toolbar
         mode_bar = QHBoxLayout()
-        self.free_btn = QPushButton("Freehand"); self.free_btn.setCheckable(True)
-        self.ellipse_btn = QPushButton("Ellipse"); self.ellipse_btn.setCheckable(True)
-        self.select_btn = QPushButton("Select Entire Image"); self.select_btn.setCheckable(True)
+        self.free_btn = QPushButton(self.tr("Freehand")); self.free_btn.setCheckable(True)
+        self.ellipse_btn = QPushButton(self.tr("Ellipse")); self.ellipse_btn.setCheckable(True)
+        self.select_btn = QPushButton(self.tr("Select Entire Image")); self.select_btn.setCheckable(True)
         group = QButtonGroup(self); group.setExclusive(True)
         for b in (self.free_btn, self.ellipse_btn, self.select_btn):
             b.setAutoExclusive(True); group.addButton(b)
@@ -598,6 +726,18 @@ class MaskCreationDialog(QDialog):
         zoom_bar.addWidget(z_out); zoom_bar.addWidget(z_in); zoom_bar.addWidget(z_fit)
         layout.addLayout(zoom_bar)
 
+        # Display stretch toggle (display-only; never modifies image data)
+        self.btn_disp_stretch = QPushButton(self.tr("Toggle Display Stretch"))
+        self.btn_disp_stretch.setCheckable(True)
+        self.btn_disp_stretch.setToolTip(
+            "Display-only stretch for easier masking on linear images.\n"
+            "This does NOT change the image data or the generated mask."
+        )
+        self.btn_disp_stretch.toggled.connect(self._toggle_display_stretch)
+        self.btn_disp_stretch.setChecked(False)
+        self.btn_disp_stretch.setText("Enable Display Stretch")
+        zoom_bar.addWidget(self.btn_disp_stretch)
+
         # Canvas
         self.canvas = MaskCanvas(self.image)
         layout.addWidget(self.canvas, 1)
@@ -614,7 +754,7 @@ class MaskCreationDialog(QDialog):
         self.type_dd.currentTextChanged.connect(lambda t: setattr(self, 'mask_type', t))
         controls.addWidget(self.type_dd)
 
-        controls.addWidget(QLabel("Edge Blur (px):"))
+        controls.addWidget(QLabel(self.tr("Edge Blur (px):")))
         self.blur_slider = QSlider(Qt.Orientation.Horizontal); self.blur_slider.setRange(0, 300)
         self.blur_slider.valueChanged.connect(lambda v: setattr(self, 'blur_amount', int(v)))
         controls.addWidget(self.blur_slider)
@@ -704,6 +844,24 @@ class MaskCreationDialog(QDialog):
         if self.link_cb.isChecked():
             self.upper_sl.setValue(v)
 
+    def _toggle_display_stretch(self, enabled: bool):
+        try:
+            self.canvas.set_display_stretch_enabled(bool(enabled))
+
+            # keep button label in sync
+            self.btn_disp_stretch.setText(
+                self.tr("Disable Display Stretch") if enabled else self.tr("Enable Display Stretch")
+            )
+
+            # Keep the live preview background in sync (Range Selection uses it)
+            if hasattr(self, "live_preview") and self.live_preview is not None:
+                self.live_preview.set_base_image(self.canvas.current_display_image01())
+                if self.live_preview.isVisible():
+                    self._update_live_preview()
+        except Exception:
+            pass
+
+
     # ---- generators
     def _component_lightness(self) -> np.ndarray:
         if self.image.ndim == 3:

setiastro/saspro/mfdeconv.py

@@ -822,6 +822,11 @@ def _to_luma_local(a: np.ndarray) -> np.ndarray:
         return a
     # (H,W,3) or (3,H,W)
     if a.ndim == 3 and a.shape[-1] == 3:
+        try:
+            import cv2
+            return cv2.cvtColor(a, cv2.COLOR_RGB2GRAY).astype(np.float32, copy=False)
+        except Exception:
+            pass
         r, g, b = a[..., 0], a[..., 1], a[..., 2]
         return (0.2126*r + 0.7152*g + 0.0722*b).astype(np.float32, copy=False)
     if a.ndim == 3 and a.shape[0] == 3:

setiastro/saspro/morphology.py

@@ -46,10 +46,9 @@ def apply_morphology(image: np.ndarray, *, operation: str = "erosion",
 
     if img.ndim == 3 and img.shape[2] == 3:
         u8 = (img * 255.0).astype(np.uint8)
-        ch = cv2.split(u8)
-        ch = [_do(c) for c in ch]
-        out = cv2.merge(ch).astype(np.float32) / 255.0
-        return np.clip(out, 0.0, 1.0)
+        # OpenCV morphology functions handle multi-channel images natively (independent channels)
+        out_u8 = _do(u8)
+        return (out_u8.astype(np.float32) / 255.0).clip(0.0, 1.0)
 
     raise ValueError("Input image must be mono (H,W)/(H,W,1) or RGB (H,W,3).")
 
@@ -91,7 +90,10 @@ class MorphologyDialogPro(QDialog):
 
     def __init__(self, parent, doc, icon: QIcon | None = None, initial: dict | None = None):
         super().__init__(parent)
-        self.setWindowTitle("Morphological Operations")
+        self.setWindowTitle(self.tr("Morphological Operations"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if icon:
             try: self.setWindowIcon(icon)
             except Exception as e:
@@ -109,7 +111,7 @@ class MorphologyDialogPro(QDialog):
         v = QVBoxLayout(self)
 
         # ---- Params (unchanged) ----
-        grp = QGroupBox("Morphological Parameters")
+        grp = QGroupBox(self.tr("Morphological Parameters"))
         grid = QGridLayout(grp)
         self.cb_op = QComboBox(); self.cb_op.addItems(self.OPS)
         self.sp_kernel = QSpinBox(); self.sp_kernel.setRange(1, 31); self.sp_kernel.setSingleStep(2)
@@ -125,9 +127,9 @@ class MorphologyDialogPro(QDialog):
         self.sp_kernel.valueChanged.connect(self._debounce)
         self.sp_iter.valueChanged.connect(self._debounce)
 
-        grid.addWidget(QLabel("Operation:"), 0, 0); grid.addWidget(self.cb_op, 0, 1, 1, 2)
-        grid.addWidget(QLabel("Kernel size:"), 1, 0); grid.addWidget(self.sp_kernel, 1, 1)
-        grid.addWidget(QLabel("Iterations:"), 2, 0); grid.addWidget(self.sp_iter, 2, 1)
+        grid.addWidget(QLabel(self.tr("Operation:")), 0, 0); grid.addWidget(self.cb_op, 0, 1, 1, 2)
+        grid.addWidget(QLabel(self.tr("Kernel size:")), 1, 0); grid.addWidget(self.sp_kernel, 1, 1)
+        grid.addWidget(QLabel(self.tr("Iterations:")), 2, 0); grid.addWidget(self.sp_iter, 2, 1)
         v.addWidget(grp)
 
         # ---- Preview with zoom/pan ----
@@ -158,9 +160,9 @@ class MorphologyDialogPro(QDialog):
 
         # ---- Buttons (unchanged) ----
         row = QHBoxLayout()
-        btn_apply = QPushButton("Apply");  btn_apply.clicked.connect(self._apply)
-        btn_reset = QPushButton("Reset");  btn_reset.clicked.connect(self._reset)
-        btn_cancel= QPushButton("Cancel"); btn_cancel.clicked.connect(self.reject)
+        btn_apply = QPushButton(self.tr("Apply"));  btn_apply.clicked.connect(self._apply)
+        btn_reset = QPushButton(self.tr("Reset"));  btn_reset.clicked.connect(self._reset)
+        btn_cancel= QPushButton(self.tr("Cancel")); btn_cancel.clicked.connect(self.reject)
         row.addStretch(1); row.addWidget(btn_apply); row.addWidget(btn_reset); row.addWidget(btn_cancel)
         v.addLayout(row)
 
@@ -258,10 +260,33 @@ class MorphologyDialogPro(QDialog):
                 pass
             # ────────────────────────────────────────────────────────────
 
-            self.accept()
+            # Dialog stays open so user can apply to other images
+            # Refresh document reference for next operation
+            self._refresh_document_from_active()
         except Exception as e:
             QMessageBox.critical(self, "Morphology", f"Failed to apply:\n{e}")
 
+    def _refresh_document_from_active(self):
+        """
+        Refresh the dialog's document reference to the currently active document.
+        This allows reusing the same dialog on different images.
+        """
+        try:
+            main = self.parent()
+            if main and hasattr(main, "_active_doc"):
+                new_doc = main._active_doc()
+                if new_doc is not None and new_doc is not self.doc:
+                    self.doc = new_doc
+                    # Refresh preview for new document
+                    self.orig = np.clip(np.asarray(new_doc.image, dtype=np.float32), 0.0, 1.0)
+                    disp = self.orig
+                    if disp.ndim == 2: disp = disp[..., None].repeat(3, axis=2)
+                    elif disp.ndim == 3 and disp.shape[2] == 1: disp = disp.repeat(3, axis=2)
+                    self._disp_base = disp
+                    self._update_preview()
+        except Exception:
+            pass
+
 
 
     def _reset(self):