setiastrosuitepro 1.6.7__py3-none-any.whl → 1.7.0__py3-none-any.whl

setiastro/saspro/subwindow.py

@@ -9,6 +9,7 @@ import json
 import math
 import weakref
 import os
+import re
 try:
     from PyQt6.QtCore import QSignalBlocker
 except Exception:
@@ -136,6 +137,22 @@ DECORATION_PREFIXES = (
     "Active View: ",            # legacy
 )
 
+_GLYPH_RE = re.compile(f"[{re.escape(GLYPHS)}]")
+
+def _strip_ui_decorations(title: str) -> str:
+    if not title:
+        return ""
+    s = str(title).strip()
+
+    # Remove common prefix tag(s)
+    s = s.replace("[LINK]", "").strip()
+
+    # Remove glyphs anywhere (often used as status markers in titles)
+    s = _GLYPH_RE.sub("", s)
+
+    # Collapse repeated whitespace
+    s = re.sub(r"\s+", " ", s).strip()
+    return s
 
 from astropy.wcs import WCS as _AstroWCS
 from astropy.io.fits import Header as _FitsHeader
@@ -332,6 +349,15 @@ def _dnd_dbg_dump_state(tag: str, state: dict):
 
 _DEBUG_DND_DUP = False
 
+def _strip_ext_if_filename(s: str) -> str:
+    s = (s or "").strip()
+    if not s:
+        return s
+    base, ext = os.path.splitext(s)
+    if ext and len(ext) <= 10:
+        return base
+    return s
+
 class ImageSubWindow(QWidget):
     aboutToClose = pyqtSignal(object)
     autostretchChanged = pyqtSignal(bool)
@@ -488,6 +514,32 @@ class ImageSubWindow(QWidget):
         row.addWidget(self._btn_wcs, 0, Qt.AlignmentFlag.AlignLeft)
         # ─────────────────────────────────────────────────────────────────
 
+        # ---- Inline view title (shown when the MDI subwindow is maximized) ----
+        self._inline_title = QLabel(self)
+        self._inline_title.setText("")
+        self._inline_title.setToolTip(self.tr("Active view"))
+        self._inline_title.setVisible(False)
+        self._inline_title.setTextInteractionFlags(Qt.TextInteractionFlag.TextSelectableByMouse)
+        self._inline_title.setStyleSheet("""
+            QLabel {
+                padding-left: 8px;
+                padding-right: 6px;
+                font-size: 11px;
+                color: rgba(255,255,255,0.80);
+            }
+        """)
+        self._inline_title.setSizePolicy(
+            self._inline_title.sizePolicy().horizontalPolicy(),
+            self._inline_title.sizePolicy().verticalPolicy(),
+        )
+
+        # Push everything after this to the far right
+        row.addStretch(1)
+        row.addWidget(self._inline_title, 0, Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignRight)
+
+        # (optional) tiny spacing to the edge
+        row.addSpacing(6)
+
         row.addStretch(1)
         lyt.addLayout(row)
 
@@ -538,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)
@@ -568,6 +621,9 @@ class ImageSubWindow(QWidget):
         self._history_doc = None
         self._install_history_watchers()
 
+        QTimer.singleShot(0, self._install_mdi_state_watch)
+        QTimer.singleShot(0, self._update_inline_title_and_buttons)
+
     # ----- link drag payload -----
     def _start_link_drag(self):
         """
@@ -699,7 +755,60 @@ class ImageSubWindow(QWidget):
         except Exception:
             pass
 
-    #------ Replay helpers------
+    # ------------------------------------------------------------
+    # MDI maximize handling: show inline title + avoid duplicate buttons
+    # ------------------------------------------------------------
+    def _mdi_subwindow(self) -> QMdiSubWindow | None:
+        w = self.parentWidget()
+        while w is not None and not isinstance(w, QMdiSubWindow):
+            w = w.parentWidget()
+        return w
+
+    def _install_mdi_state_watch(self):
+        sw = self._mdi_subwindow()
+        if sw is None:
+            return
+        # Watch maximize/restore changes on the hosting QMdiSubWindow
+        sw.installEventFilter(self)
+
+    def _is_mdi_maximized(self) -> bool:
+        sw = self._mdi_subwindow()
+        if sw is None:
+            return False
+        try:
+            return sw.isMaximized()
+        except Exception:
+            return False
+
+    def _set_mdi_minmax_buttons_enabled(self, enabled: bool):
+        return  # leave Qt default buttons alone
+
+    def _current_view_title_for_inline(self) -> str:
+        # Prefer your already-pretty title (strip decorations if needed).
+        try:
+            # If you have _current_view_title_for_drag already, reuse it:
+            return self._current_view_title_for_drag()
+        except Exception:
+            pass
+        try:
+            return (self.windowTitle() or "").strip()
+        except Exception:
+            return ""
+
+    def _update_inline_title_and_buttons(self):
+        maximized = self._is_mdi_maximized()
+
+        # Show inline title only when maximized (optional)
+        try:
+            self._inline_title.setVisible(maximized)
+            if maximized:
+                self._inline_title.setText(self._current_view_title_for_inline() or "Untitled")
+        except Exception:
+            pass
+
+        # IMPORTANT: do NOT change QMdiSubWindow window flags.
+        # Leaving them alone restores the default Qt "double button" behavior.
+
     #------ Replay helpers------
     def _update_replay_button(self):
         """
@@ -829,13 +938,20 @@ class ImageSubWindow(QWidget):
         self._emit_view_transform()
 
     def set_view_transform(self, scale, hval, vval, from_link=False):
-        # Avoid storms while we mutate scrollbars/scale
         self._suppress_link_emit = True
         try:
             scale = float(max(self._min_scale, min(scale, self._max_scale)))
-            if abs(scale - self.scale) > 1e-9:
+
+            scale_changed = (abs(scale - self.scale) > 1e-9)
+            if scale_changed:
                 self.scale = scale
-                self._render(rebuild=False)
+                self._render(rebuild=False)  # fast present for responsiveness
+
+                # ✅ NEW: schedule the final smooth redraw (same as main zoom path)
+                try:
+                    self._request_zoom_redraw()
+                except Exception:
+                    pass
 
             hbar = self.scroll.horizontalScrollBar()
             vbar = self.scroll.verticalScrollBar()
@@ -847,14 +963,14 @@ class ImageSubWindow(QWidget):
         finally:
             self._suppress_link_emit = False
 
-        # IMPORTANT: if this came from a linked peer, do NOT broadcast again.
         if not from_link:
             self._schedule_emit_view_transform()
 
+
     def _on_toggle_wcs_grid(self, on: bool):
         self._show_wcs_grid = bool(on)
         QSettings().setValue("display/show_wcs_grid", self._show_wcs_grid)
-        self._render(rebuild=False)  # repaint current frame
+        self._render(rebuild=True)  # repaint current frame
 
 
 
@@ -1193,18 +1309,6 @@ class ImageSubWindow(QWidget):
         except Exception as e:
             print("[ImageSubWindow] apply_layer_stack error:", e)      
 
-    # --- add to ImageSubWindow ---
-    def _collect_layer_docs(self):
-        docs = set()
-        for L in getattr(self, "_layers", []):
-            d = getattr(L, "src_doc", None)
-            if d is not None:
-                docs.add(d)
-            md = getattr(L, "mask_doc", None)
-            if md is not None:
-                docs.add(md)
-        return docs
-
     def keyPressEvent(self, ev):
         if ev.key() == Qt.Key.Key_Space:
             # only the first time we enter probe mode
@@ -1326,51 +1430,116 @@ class ImageSubWindow(QWidget):
         except Exception as e:
             print("[ImageSubWindow] _on_layer_source_changed error:", e)
 
+    def _collect_layer_docs(self):
+        """
+        Collect unique ImageDocument objects referenced by the layer stack:
+        - layer src_doc (if doc-backed)
+        - layer mask_doc (if any)
+        Raster/baked layers may have src_doc=None; those are ignored.
+        Returns a LIST in a stable order (bottom→top traversal order), de-duped.
+        """
+        out = []
+        seen = set()
+
+        layers = getattr(self, "_layers", None) or []
+        for L in layers:
+            # 1) source doc (may be None for raster/baked layers)
+            d = getattr(L, "src_doc", None)
+            if d is not None:
+                k = id(d)
+                if k not in seen:
+                    seen.add(k)
+                    out.append(d)
+
+            # 2) mask doc (also may be None)
+            md = getattr(L, "mask_doc", None)
+            if md is not None:
+                k = id(md)
+                if k not in seen:
+                    seen.add(k)
+                    out.append(md)
+
+        return out
+
+
     def _reinstall_layer_watchers(self):
+        """
+        Reconnect layer source/mask document watchers to trigger live layer recomposite.
+        Safe against:
+        - raster/baked layers (src_doc=None)
+        - deleted docs / partially-torn-down Qt objects
+        - repeated calls
+        """
+        # Previous watchers
+        olddocs = list(getattr(self, "_watched_docs", []) or [])
+
         # Disconnect old
-        for d in list(self._watched_docs):
+        for d in olddocs:
             try:
+                # Doc may already be deleted or signal gone
                 d.changed.disconnect(self._on_layer_source_changed)
             except Exception:
                 pass
-        # Connect new
+
+        # Collect new
         newdocs = self._collect_layer_docs()
+
+        # Connect new
         for d in newdocs:
             try:
                 d.changed.connect(self._on_layer_source_changed)
             except Exception:
                 pass
+
+        # Store as list (stable)
         self._watched_docs = newdocs
 
 
+
     def toggle_mask_overlay(self):
         self.show_mask_overlay = not self.show_mask_overlay
         self._render(rebuild=True)
 
     def _rebuild_title(self, *, base: str | None = None):
         sub = self._mdi_subwindow()
-        if not sub: return
+        if not sub:
+            return
+
         if base is None:
             base = self._effective_title() or self.tr("Untitled")
 
-        # ✅ strip any carried-over glyphs (🔗, ■, “Active View: ”) from overrides/doc names
+        # Strip badges (🔗, ■, etc) AND "Active View:" prefix
         core, _ = self._strip_decorations(base)
 
-        title = core
+        # ALSO strip file extensions if it looks like a filename
+        # (this prevents .tiff/.fit coming back via any fallback path)
+        try:
+            b, ext = os.path.splitext(core)
+            if ext and len(ext) <= 10 and not core.endswith("..."):
+                core = b
+        except Exception:
+            pass
+
+        # Build the displayed title with badges
+        shown = core
         if getattr(self, "_link_badge_on", False):
-            title = f"{LINK_PREFIX}{title}"
+            shown = f"{LINK_PREFIX}{shown}"
         if self._mask_dot_enabled:
-            title = f"{MASK_GLYPH} {title}"
+            shown = f"{MASK_GLYPH} {shown}"
+
+        # Update chrome
+        if shown != sub.windowTitle():
+            sub.setWindowTitle(shown)
+            sub.setToolTip(shown)
+
+        # IMPORTANT: emit ONLY the clean core (no badges, no extensions)
+        if core != self._last_title_for_emit:
+            self._last_title_for_emit = core
+            try:
+                self.viewTitleChanged.emit(self, core)
+            except Exception:
+                pass
 
-        if title != sub.windowTitle():
-            sub.setWindowTitle(title)
-            sub.setToolTip(title)
-            if title != self._last_title_for_emit:
-                self._last_title_for_emit = title
-                try: self.viewTitleChanged.emit(self, title)
-                except Exception as e:
-                    import logging
-                    logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
 
 
     def _strip_decorations(self, title: str) -> tuple[str, bool]:
@@ -1399,21 +1568,7 @@ class ImageSubWindow(QWidget):
     def set_active_highlight(self, on: bool):
         self._is_active_flag = bool(on)
         return
-        sub = self._mdi_subwindow()
-        if not sub:
-            return
-
-        core, had_glyph = self._strip_decorations(sub.windowTitle())
-
-        if on and not getattr(self, "_suppress_active_once", False):
-            core = ACTIVE_PREFIX + core
-        self._suppress_active_once = False
 
-        # recompose: glyph (from flag), then active prefix, then base/core
-        if getattr(self, "_mask_dot_enabled", False):
-            core = "■ " + core
-        #sub.setWindowTitle(core)
-        sub.setToolTip(core)
 
     def _set_mask_highlight(self, on: bool):
         self._mask_dot_enabled = bool(on)
@@ -1521,20 +1676,58 @@ class ImageSubWindow(QWidget):
     def is_hard_autostretch(self) -> bool:
         return self.autostretch_profile == "hard"
 
-    def _mdi_subwindow(self) -> QMdiSubWindow | None:
-        w = self.parent()
-        while w is not None and not isinstance(w, QMdiSubWindow):
-            w = w.parent()
-        return w
+    #def _mdi_subwindow(self) -> QMdiSubWindow | None:
+    #    w = self.parent()
+    #    while w is not None and not isinstance(w, QMdiSubWindow):
+    #        w = w.parent()
+    #    return w
 
     def _effective_title(self) -> str:
-        # Prefer a per-view override; otherwise doc display name
-        return self._view_title_override or self.document.display_name()
+        """
+        Returns the *core* title for this view (no UI badges like 🔗/■, and no file extension).
+        Badges are added later by _rebuild_title().
+        """
+        # 1) Prefer per-view override if set
+        t = (self._view_title_override or "").strip()
+
+        # 2) Else prefer metadata display_name (what duplicate/rename should set)
+        if not t:
+            try:
+                md = getattr(self.document, "metadata", {}) or {}
+                t = (md.get("display_name") or "").strip()
+            except Exception:
+                t = ""
+
+        # 3) Else fall back to doc.display_name()
+        if not t:
+            try:
+                t = (self.document.display_name() or "").strip()
+            except Exception:
+                t = ""
+
+        t = t or self.tr("Untitled")
+
+        # Strip UI decorations (🔗, ■, Active View:, etc.)
+        try:
+            t, _ = self._strip_decorations(t)
+        except Exception:
+            pass
+
+        # Strip extension if it looks like a filename
+        try:
+            base, ext = os.path.splitext(t)
+            if ext and len(ext) <= 10:
+                t = base
+        except Exception:
+            pass
+
+        return t
+
 
     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)"))
@@ -2848,37 +3041,75 @@ class ImageSubWindow(QWidget):
                 return True
             return False
 
+        sw = self._mdi_subwindow()
+        if sw is not None and obj is sw:
+            et = ev.type()
+            if et in (QEvent.Type.WindowStateChange, QEvent.Type.Show, QEvent.Type.Resize):
+                QTimer.singleShot(0, self._update_inline_title_and_buttons)
+
         return super().eventFilter(obj, ev)
 
+    def _viewport_pos_to_image_xy(self, vp_pos: QPoint) -> tuple[int, int] | None:
+        """
+        Convert a point in viewport coordinates to FULL image pixel coordinates.
+        Returns None if the point is outside the displayed pixmap (in margins).
+        """
+        pm = self.label.pixmap()
+        if pm is None:
+            return None
+
+        # Convert viewport point into label coordinates
+        p_label = self.label.mapFrom(self.scroll.viewport(), vp_pos)
+
+        # If label is larger than pixmap, pixmap may be centered inside label.
+        pm_w, pm_h = pm.width(), pm.height()
+        lbl_w, lbl_h = self.label.width(), self.label.height()
+
+        off_x = max(0, (lbl_w - pm_w) // 2)
+        off_y = max(0, (lbl_h - pm_h) // 2)
+
+        px = p_label.x() - off_x
+        py = p_label.y() - off_y
+
+        # Outside the drawn pixmap area → clamp
+        px = max(0, min(px, pm_w - 1))
+        py = max(0, min(py, pm_h - 1))
+
+        s = max(float(self.scale), 1e-12)
+
+        # pixmap pixels -> image pixels (pm = image * scale)
+        xi = int(round(px / s))
+        yi = int(round(py / s))
+        return xi, yi
 
     def _finish_preview_rect(self, vp_rect: QRect):
-        # Map viewport rectangle into image coordinates
         if vp_rect.width() < 4 or vp_rect.height() < 4:
             self._cancel_rubber()
             return
 
-        hbar = self.scroll.horizontalScrollBar()
-        vbar = self.scroll.verticalScrollBar()
+        # Convert the two corners from viewport space to image space
+        p0 = self._viewport_pos_to_image_xy(vp_rect.topLeft())
+        p1 = self._viewport_pos_to_image_xy(vp_rect.bottomRight())
 
-        # Upper-left in label coords
-        x_label0 = hbar.value() + vp_rect.left()
-        y_label0 = vbar.value() + vp_rect.top()
-        x_label1 = hbar.value() + vp_rect.right()
-        y_label1 = vbar.value() + vp_rect.bottom()
+        if p0 is None or p1 is None:
+            # User dragged into margins; you can either cancel or clamp.
+            # Cancel is simplest:
+            self._cancel_rubber()
+            return
 
-        s = max(self.scale, 1e-12)
+        x0, y0 = p0
+        x1, y1 = p1
 
-        x0 = int(round(x_label0 / s))
-        y0 = int(round(y_label0 / s))
-        x1 = int(round(x_label1 / s))
-        y1 = int(round(y_label1 / s))
+        x = min(x0, x1)
+        y = min(y0, y1)
+        w = abs(x1 - x0)
+        h = abs(y1 - y0)
 
-        if x1 <= x0 or y1 <= y0:
+        if w < 1 or h < 1:
             self._cancel_rubber()
             return
 
-        roi = (x0, y0, x1 - x0, y1 - y0)
-        self._create_preview_from_roi(roi)
+        self._create_preview_from_roi((x, y, w, h))
         self._cancel_rubber()
 
     def _create_preview_from_roi(self, roi: tuple[int,int,int,int]):
@@ -2956,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)

setiastro/saspro/widgets/common_utilities.py

@@ -1,3 +1,4 @@
+#src/setiastro/saspro/widgets/common_utilities.py
 """
 Common UI utilities and shared components.
 
@@ -220,32 +221,38 @@ _strip_ui_decorations = strip_ui_decorations
 # ---------------------------------------------------------------------------
 
 def install_crash_handlers(app: 'QApplication') -> None:
-    """
-    Install global crash and exception handlers for the application.
-    
-    Sets up:
-    1. faulthandler for hard crashes (segfaults) → saspro_crash.log
-    2. sys.excepthook for uncaught main thread exceptions
-    3. threading.excepthook for uncaught background thread exceptions
-    
-    All exceptions are logged and displayed in a dialog to the user.
-    
-    Args:
-        app: The QApplication instance
-        
-    Example:
-        app = QApplication(sys.argv)
-        install_crash_handlers(app)
-    """
     import faulthandler
-    
-    # 1) Hard crashes (segfaults, access violations) → saspro_crash.log
+    import tempfile
+    from pathlib import Path
+
+    def _get_crash_log_path() -> str:
+        try:
+            if hasattr(sys, "_MEIPASS"):
+                if sys.platform.startswith("win"):
+                    log_dir = Path(os.path.expandvars("%APPDATA%")) / "SetiAstroSuitePro" / "logs"
+                elif sys.platform.startswith("darwin"):
+                    log_dir = Path.home() / "Library" / "Logs" / "SetiAstroSuitePro"
+                else:
+                    log_dir = Path.home() / ".local" / "share" / "SetiAstroSuitePro" / "logs"
+            else:
+                # dev fallback
+                log_dir = Path("logs")
+
+            log_dir.mkdir(parents=True, exist_ok=True)
+            return str(log_dir / "saspro_crash.log")
+        except Exception:
+            return str(Path(tempfile.gettempdir()) / "saspro_crash.log")
+
+    # 1) Hard crashes → saspro_crash.log
     try:
-        _crash_log = open("saspro_crash.log", "w", encoding="utf-8", errors="replace")
+        crash_path = _get_crash_log_path()
+        _crash_log = open(crash_path, "a", encoding="utf-8", errors="replace")
         faulthandler.enable(file=_crash_log, all_threads=True)
         atexit.register(_crash_log.close)
+        logging.info("Faulthandler crash log: %s", crash_path)
     except Exception:
         logging.exception("Failed to enable faulthandler")
+
     
     def _show_dialog(title: str, head: str, details: str) -> None:
         """Show error dialog marshaled to main thread."""
@@ -261,7 +268,7 @@ def install_crash_handlers(app: 'QApplication') -> None:
             m.setStandardButtons(QMessageBox.StandardButton.Ok)
             m.exec()
         QTimer.singleShot(0, _ui)
-    
+
     # 2) Any uncaught exception on the main thread
     def _excepthook(exc_type, exc_value, exc_tb):
         tb = "".join(traceback.format_exception(exc_type, exc_value, exc_tb))