setiastrosuitepro 1.6.10__py3-none-any.whl → 1.7.0.post2__py3-none-any.whl

setiastro/saspro/stat_stretch.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 from PyQt6.QtCore import Qt, QSize, QEvent
 from PyQt6.QtWidgets import (
     QDialog, QVBoxLayout, QHBoxLayout, QFormLayout, QLabel, QDoubleSpinBox,
-    QCheckBox, QPushButton, QScrollArea, QWidget, QMessageBox, QSlider, QToolBar, QToolButton, QComboBox
+    QCheckBox, QPushButton, QScrollArea, QWidget, QMessageBox, QSlider, QToolBar, QToolButton, QComboBox,QProgressBar, QApplication
 )
 from PyQt6.QtGui import QImage, QPixmap, QMouseEvent, QCursor
 import numpy as np
@@ -243,6 +243,32 @@ class StatisticalStretchDialog(QDialog):
         lr.addWidget(QLabel(self.tr("Mode:")))
         lr.addWidget(self.cmb_luma, 1)
 
+        # --- Luma blend row (only meaningful when Luma-only is enabled) ---
+        self.luma_blend_row = QWidget()
+        lbr = QHBoxLayout(self.luma_blend_row)
+        lbr.setContentsMargins(0, 0, 0, 0)
+        lbr.setSpacing(8)
+
+        lbr.addWidget(QLabel(self.tr("Luma blend:")))
+
+        self.sld_luma_blend = QSlider(Qt.Orientation.Horizontal)
+        self.sld_luma_blend.setRange(0, 100)   # 0=normal linked, 100=luma-only
+        self.sld_luma_blend.setValue(60)       # nice default: “mostly luma” but tame
+        lbr.addWidget(self.sld_luma_blend, 1)
+
+        self.lbl_luma_blend = QLabel(f"{self.sld_luma_blend.value()/100:.2f}")
+        lbr.addWidget(self.lbl_luma_blend)
+
+        tip = self.tr(
+            "Blend between a normal linked RGB stretch (0.00) and a luminance-only stretch (1.00).\n"
+            "Use this to tame the saturation punch of luma-only."
+        )
+        self.luma_blend_row.setToolTip(tip)
+        self.sld_luma_blend.setToolTip(tip)
+        self.lbl_luma_blend.setToolTip(tip)
+
+        self.luma_blend_row.setEnabled(False)
+
         # --- Curves boost ---
         self.chk_curves = QCheckBox(self.tr("Curves boost"))
         self.chk_curves.setChecked(False)
@@ -294,6 +320,7 @@ class StatisticalStretchDialog(QDialog):
         self.btn_preview = QPushButton(self.tr("Preview"))
         self.btn_apply   = QPushButton(self.tr("Apply"))
         self.btn_close   = QPushButton(self.tr("Close"))
+        self.btn_reset = QPushButton(self.tr("Reset ⟳"))  
 
         self.btn_clipstats = QPushButton(self.tr("Clip stats"))
         self.lbl_clipstats = QLabel("")
@@ -304,6 +331,24 @@ class StatisticalStretchDialog(QDialog):
         self.lbl_clipstats.setFrameShadow(QLabel.Shadow.Sunken)
         self.lbl_clipstats.setContentsMargins(6, 4, 6, 4)
 
+        # --- In-UI busy indicator (Wayland-friendly) ---
+        self.busy_row = QWidget()
+        br = QHBoxLayout(self.busy_row)
+        br.setContentsMargins(0, 0, 0, 0)
+        br.setSpacing(8)
+
+        self.lbl_busy = QLabel(self.tr("Processing…"))
+        self.lbl_busy.setStyleSheet("color:#888;")
+        self.pbar_busy = QProgressBar()
+        self.pbar_busy.setRange(0, 0)          # indeterminate
+        self.pbar_busy.setTextVisible(False)
+        self.pbar_busy.setFixedHeight(10)
+
+        br.addWidget(self.lbl_busy)
+        br.addWidget(self.pbar_busy, 1)
+
+        self.busy_row.setVisible(False)        # hidden until needed
+
         # ------------------------------------------------------------------
         # Layout
         # ------------------------------------------------------------------
@@ -315,6 +360,7 @@ class StatisticalStretchDialog(QDialog):
         form.addRow("", self.chk_hdr)
         form.addRow("", self.hdr_row)
         form.addRow("", self.luma_row)
+        form.addRow("", self.luma_blend_row)
         form.addRow("", self.chk_normalize)
         form.addRow("", self.chk_curves)
         form.addRow("", self.curves_row)
@@ -326,10 +372,13 @@ class StatisticalStretchDialog(QDialog):
         btn_row.addWidget(self.btn_preview)
         btn_row.addWidget(self.btn_apply)
         btn_row.addWidget(self.btn_clipstats)
+        btn_row.addStretch(1)        
+        btn_row.addWidget(self.btn_reset)  
         btn_row.addStretch(1)
         left.addLayout(btn_row)
 
         left.addWidget(self.lbl_clipstats)
+        left.addWidget(self.busy_row)
         left.addStretch(1)
 
         right = QVBoxLayout()
@@ -382,14 +431,6 @@ class StatisticalStretchDialog(QDialog):
 
         self.spin_target.valueChanged.connect(_suggest_hdr_knee_from_target)
 
-        # Luma-only: enables dropdown, disables "linked channels"
-        self.chk_luma_only.toggled.connect(self.cmb_luma.setEnabled)
-
-        def _on_luma_only_toggled(on: bool):
-            self.chk_linked.setEnabled(not on)
-
-        self.chk_luma_only.toggled.connect(_on_luma_only_toggled)
-
         # Zoom buttons
         self.btn_zoom_in.clicked.connect(lambda: self._zoom_by(1.25))
         self.btn_zoom_out.clicked.connect(lambda: self._zoom_by(1/1.25))
@@ -399,6 +440,7 @@ class StatisticalStretchDialog(QDialog):
         # Main buttons
         self.btn_preview.clicked.connect(self._do_preview)
         self.btn_apply.clicked.connect(self._do_apply)
+        self.btn_reset.clicked.connect(self._reset_defaults)   
         self.btn_close.clicked.connect(self.close)
         self.btn_clipstats.clicked.connect(self._do_clip_stats)
 
@@ -410,50 +452,191 @@ class StatisticalStretchDialog(QDialog):
 
         # Initialize UI state
         _suggest_hdr_knee_from_target()
+        self.sld_luma_blend.valueChanged.connect(
+            lambda v: self.lbl_luma_blend.setText(f"{v/100:.2f}")
+        )
+
+        # Luma-only: one unified handler for all dependent UI state
+        def _on_luma_only_toggled(on: bool):
+            # enable luma mode dropdown only when luma-only is on
+            self.cmb_luma.setEnabled(on)
+
+            # linked channels doesn't make sense in luma-only mode
+            self.chk_linked.setEnabled(not on)
+
+            # luma blend row only meaningful when luma-only is enabled
+            self.luma_blend_row.setEnabled(on)
+
+            # mode-affecting => refresh clip stats
+            self._schedule_clip_stats()
+
+        self.chk_luma_only.toggled.connect(_on_luma_only_toggled)
         _on_luma_only_toggled(self.chk_luma_only.isChecked())
 
+
         # Initial preview + clip stats
         self._populate_initial_preview()
 
 
     # ----- helpers -----
     def _show_busy(self, title: str, text: str):
-        # Avoid stacking dialogs
-        self._hide_busy()
-
-        dlg = QProgressDialog(text, None, 0, 0, self)
-        dlg.setWindowTitle(title)
-        dlg.setWindowModality(Qt.WindowModality.WindowModal)  # blocks only this tool window
-        dlg.setMinimumDuration(0)
-        dlg.setValue(0)
-        dlg.setCancelButton(None)  # no cancel button (keeps it simple)
-        dlg.setAutoClose(False)
-        dlg.setAutoReset(False)
-        dlg.setFixedWidth(320)
-        dlg.show()
-
-        # Ensure it paints before heavy work starts
-        QApplication.processEvents()
-        self._busy = dlg
+        # title kept for signature compatibility; not shown
+        try:
+            self.lbl_busy.setText(text or self.tr("Processing…"))
+            self.busy_row.setVisible(True)
+            # make sure UI repaints before thread work starts
+            QApplication.processEvents()
+        except Exception:
+            pass
 
     def _hide_busy(self):
         try:
-            if getattr(self, "_busy", None) is not None:
-                self._busy.close()
-                self._busy.deleteLater()
+            if getattr(self, "busy_row", None) is not None:
+                self.busy_row.setVisible(False)
         except Exception:
             pass
-        self._busy = None
+
 
     def _set_controls_enabled(self, enabled: bool):
         try:
             self.btn_preview.setEnabled(enabled)
             self.btn_apply.setEnabled(enabled)
+            if getattr(self, "btn_reset", None) is not None:
+                self.btn_reset.setEnabled(enabled)  # <-- NEW
             if getattr(self, "btn_clipstats", None) is not None:
                 self.btn_clipstats.setEnabled(enabled)
         except Exception:
             pass
 
+    def _reset_defaults(self):
+        """Reset all controls back to factory defaults."""
+        if getattr(self, "_job_running", False):
+            return
+
+        # Defaults (must match your __init__ setValue/setChecked calls)
+        DEFAULT_TARGET = 0.25
+        DEFAULT_LINKED = False
+        DEFAULT_NORMALIZE = False
+        DEFAULT_BP_SLIDER = 500          # 5.00
+        DEFAULT_NO_BLACK_CLIP = False
+
+        DEFAULT_HDR_ON = False
+        DEFAULT_HDR_AMT = 15             # 0.15
+        DEFAULT_HDR_KNEE = 75            # 0.75
+
+        DEFAULT_LUMA_ONLY = False
+        DEFAULT_LUMA_MODE = "rec709"
+        DEFAULT_LUMA_BLEND = 60          # 0.60
+
+        DEFAULT_CURVES_ON = False
+        DEFAULT_CURVES_STRENGTH = 20     # 0.20
+
+        # Avoid cascading signal storms while we set everything
+        widgets = [
+            self.spin_target,
+            self.chk_linked,
+            self.chk_normalize,
+            self.sld_bp,
+            self.chk_no_black_clip,
+            self.chk_hdr,
+            self.sld_hdr_amt,
+            self.sld_hdr_knee,
+            self.chk_luma_only,
+            self.cmb_luma,
+            self.sld_luma_blend,
+            self.chk_curves,
+            self.sld_curves,
+        ]
+
+        old_blocks = []
+        for w in widgets:
+            try:
+                old_blocks.append((w, w.blockSignals(True)))
+            except Exception:
+                pass
+
+        try:
+            # Reset “user locked” HDR knee behavior
+            self._hdr_knee_user_locked = False
+
+            # Core controls
+            self.spin_target.setValue(DEFAULT_TARGET)
+            self.chk_linked.setChecked(DEFAULT_LINKED)
+            self.chk_normalize.setChecked(DEFAULT_NORMALIZE)
+
+            # Black point
+            self.chk_no_black_clip.setChecked(DEFAULT_NO_BLACK_CLIP)
+            self.sld_bp.setValue(DEFAULT_BP_SLIDER)
+            self.lbl_bp.setText(f"{DEFAULT_BP_SLIDER/100:.2f}")
+
+            # HDR
+            self.chk_hdr.setChecked(DEFAULT_HDR_ON)
+            self.sld_hdr_amt.setValue(DEFAULT_HDR_AMT)
+            self.lbl_hdr_amt.setText(f"{DEFAULT_HDR_AMT/100:.2f}")
+            self.sld_hdr_knee.setValue(DEFAULT_HDR_KNEE)
+            self.lbl_hdr_knee.setText(f"{DEFAULT_HDR_KNEE/100:.2f}")
+
+            # Luma-only + mode + blend
+            self.chk_luma_only.setChecked(DEFAULT_LUMA_ONLY)
+            if DEFAULT_LUMA_MODE:
+                self.cmb_luma.setCurrentText(DEFAULT_LUMA_MODE)
+            self.sld_luma_blend.setValue(DEFAULT_LUMA_BLEND)
+            self.lbl_luma_blend.setText(f"{DEFAULT_LUMA_BLEND/100:.2f}")
+
+            # Curves
+            self.chk_curves.setChecked(DEFAULT_CURVES_ON)
+            self.sld_curves.setValue(DEFAULT_CURVES_STRENGTH)
+            self.lbl_curves_val.setText(f"{DEFAULT_CURVES_STRENGTH/100:.2f}")
+
+        finally:
+            # Restore signal states
+            for w, _prev in old_blocks:
+                try:
+                    w.blockSignals(False)
+                except Exception:
+                    pass
+
+        # Re-apply dependent enable/disable states exactly like normal interactions
+        try:
+            # no-black-clip disables BP row
+            self.row_bp.setEnabled(not self.chk_no_black_clip.isChecked())
+        except Exception:
+            pass
+
+        try:
+            # HDR enables HDR row
+            self.hdr_row.setEnabled(self.chk_hdr.isChecked())
+        except Exception:
+            pass
+
+        try:
+            # Curves enables curves row
+            self.curves_row.setEnabled(self.chk_curves.isChecked())
+        except Exception:
+            pass
+
+        try:
+            # Luma-only enables dropdown + blend row, disables linked
+            luma_on = self.chk_luma_only.isChecked()
+            self.cmb_luma.setEnabled(luma_on)
+            self.luma_blend_row.setEnabled(luma_on)
+            self.chk_linked.setEnabled(not luma_on)
+        except Exception:
+            pass
+
+        # Auto-suggest HDR knee from target (since we cleared lock)
+        try:
+            t = float(self.spin_target.value())
+            knee = float(np.clip(t + 0.10, 0.10, 0.95))
+            self.sld_hdr_knee.setValue(int(round(knee * 100)))
+            self.lbl_hdr_knee.setText(f"{knee:.2f}")
+        except Exception:
+            pass
+
+        # Refresh baseline preview + clip stats
+        self._populate_initial_preview()
+
+
     def _clip_mode_label(self, imgf: np.ndarray) -> str:
         # Mono image
         if imgf.ndim == 2 or (imgf.ndim == 3 and imgf.shape[2] == 1):
@@ -590,7 +773,8 @@ class StatisticalStretchDialog(QDialog):
         self._job_mode = mode
 
         self._set_controls_enabled(False)
-        self._show_busy("Statistical Stretch", "Processing…")
+        self._show_busy("Statistical Stretch", "Processing preview…" if mode == "preview" else "Applying stretch…")
+
 
         self._thread = QThread(self._main)
         self._worker = _StretchWorker(self)
@@ -761,6 +945,7 @@ class StatisticalStretchDialog(QDialog):
         luma_only = bool(getattr(self, "chk_luma_only", None) and self.chk_luma_only.isChecked())
         luma_mode = str(self.cmb_luma.currentText()) if getattr(self, "cmb_luma", None) else "rec709"
         no_black_clip = bool(self.chk_no_black_clip.isChecked())
+        luma_blend = float(self.sld_luma_blend.value()) / 100.0 if getattr(self, "sld_luma_blend", None) else 1.0
 
         target = float(self.spin_target.value())
         linked = bool(self.chk_linked.isChecked())
@@ -796,6 +981,7 @@ class StatisticalStretchDialog(QDialog):
                 hdr_knee=hdr_knee,
                 luma_only=luma_only,
                 luma_mode=luma_mode,
+                luma_blend=luma_blend,   # <-- NEW
             )
 
         # ✅ If a mask is active, blend stretched result with original
@@ -895,6 +1081,7 @@ class StatisticalStretchDialog(QDialog):
         luma_only = bool(getattr(self, "chk_luma_only", None) and self.chk_luma_only.isChecked())
         luma_mode = str(self.cmb_luma.currentText()) if getattr(self, "cmb_luma", None) else "rec709"
         no_black_clip = bool(self.chk_no_black_clip.isChecked())
+        luma_blend = float(self.sld_luma_blend.value()) / 100.0 if getattr(self, "sld_luma_blend", None) else 1.0
 
         parts = [f"target={target:.2f}", "linked" if linked else "unlinked"]
         if normalize:
@@ -908,6 +1095,7 @@ class StatisticalStretchDialog(QDialog):
             parts.append(f"hdr={hdr_amount:.2f}@{hdr_knee:.2f}")
         if luma_only:
             parts.append(f"luma={luma_mode}")
+            parts.append(f"blend={luma_blend:.2f}")
         if no_black_clip:
             parts.append("no_black_clip")
 
@@ -952,6 +1140,7 @@ class StatisticalStretchDialog(QDialog):
                 "hdr_knee": hdr_knee,
                 "luma_only": luma_only,
                 "luma_mode": luma_mode,
+                "luma_blend": luma_blend,
             }
 
             # ✅ Remember this as the last headless-style command

setiastro/saspro/subwindow.py

@@ -590,6 +590,7 @@ class ImageSubWindow(QWidget):
         self.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
         self.customContextMenuRequested.connect(self._show_ctx_menu)
         QShortcut(QKeySequence("F2"), self, activated=self._rename_view)
+        QShortcut(QKeySequence("F3"), self, activated=self._rename_document)
         #QShortcut(QKeySequence("A"), self, activated=self.toggle_autostretch)
         QShortcut(QKeySequence("Ctrl+Space"), self, activated=self.toggle_autostretch)
         QShortcut(QKeySequence("Alt+Shift+A"), self, activated=self.toggle_autostretch)
@@ -1726,7 +1727,7 @@ class ImageSubWindow(QWidget):
     def _show_ctx_menu(self, pos):
         menu = QMenu(self)
         a_view = menu.addAction(self.tr("Rename View… (F2)"))
-        a_doc  = menu.addAction(self.tr("Rename Document…"))
+        a_doc  = menu.addAction(self.tr("Rename Document…  (F3)"))
         menu.addSeparator()
         a_min  = menu.addAction(self.tr("Send to Shelf"))
         a_clear = menu.addAction(self.tr("Clear View Name (use doc name)"))
@@ -3081,7 +3082,6 @@ class ImageSubWindow(QWidget):
         yi = int(round(py / s))
         return xi, yi
 
-
     def _finish_preview_rect(self, vp_rect: QRect):
         if vp_rect.width() < 4 or vp_rect.height() < 4:
             self._cancel_rubber()
@@ -3187,8 +3187,6 @@ class ImageSubWindow(QWidget):
 
         super().mousePressEvent(e)
 
-
-
     def _show_readout(self, xi, yi, sample):
         mw = self._find_main_window()
         if mw is None:

setiastro/saspro/whitebalance.py

@@ -184,6 +184,30 @@ def apply_white_balance_to_doc(doc, preset: Optional[Dict] = None):
         step_name="White Balance",
     )
 
+def apply_pivot_gain(img: np.ndarray, med: np.ndarray, gains: np.ndarray) -> np.ndarray:
+    # img: HxWx3 float32 in [0,1]
+    med3 = med.reshape(1, 1, 3).astype(np.float32)
+    g3   = gains.reshape(1, 1, 3).astype(np.float32)
+
+    # pivot around median; do not scale negative deltas
+    d = img - med3
+    d = np.maximum(d, 0.0)
+    out = d * g3 + med3
+    return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
+def smoothstep(edge0, edge1, x):
+    t = np.clip((x - edge0) / (edge1 - edge0 + 1e-12), 0.0, 1.0)
+    return t * t * (3.0 - 2.0 * t)
+
+def apply_soft_protect(img: np.ndarray, out_pivot: np.ndarray, k: float = 0.02) -> np.ndarray:
+    # luminance-based fade-in above median luminance
+    L = 0.2126*img[...,0] + 0.7152*img[...,1] + 0.0722*img[...,2]
+    Lm = float(np.median(L))
+    w = smoothstep(Lm, Lm + k, L).astype(np.float32)
+    w3 = w[..., None]
+    out = img * (1.0 - w3) + out_pivot * w3
+    return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
 
 # -------------------------
 # Interactive dialog (UI)