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

setiastro/saspro/aberration_ai_preset.py

@@ -4,7 +4,7 @@ import os
 import time
 import numpy as np
 from PyQt6.QtCore import QTimer
-from PyQt6.QtWidgets import QDialog, QVBoxLayout, QProgressBar, QPushButton, QMessageBox, QFormLayout, QDialogButtonBox, QSpinBox, QCheckBox, QComboBox, QLabel
+from PyQt6.QtWidgets import QDialog, QVBoxLayout, QProgressBar, QPushButton, QMessageBox, QFormLayout, QDialogButtonBox, QSpinBox, QCheckBox, QComboBox, QLabel, QApplication
 
 from PyQt6.QtCore import QSettings
 # reuse everything from the UI module
@@ -91,13 +91,29 @@ def run_aberration_ai_via_preset(main, preset: dict | None = None, doc=None):
     worker = _ONNXWorker(model, img, patch, overlap, providers)
     worker.progressed.connect(bar.setValue)
 
+    def _cancel_clicked():
+        btn.setEnabled(False)
+        btn.setText("Canceling…")
+        worker.cancel()  # <-- SAFE
+        QApplication.processEvents()
+
     def _fail(msg: str):
         try:
             if hasattr(main, "_log"):
                 main._log(f"❌ Aberration AI failed: {msg}")
         except Exception:
             pass
-        QMessageBox.critical(main, "Aberration AI", msg)
+        # If canceled, don't pop an error box
+        if "Canceled" not in (msg or ""):
+            QMessageBox.critical(main, "Aberration AI", msg)
+        dlg.close()
+
+    def _canceled():
+        try:
+            if hasattr(main, "_log"):
+                main._log("⛔ Aberration AI canceled.")
+        except Exception:
+            pass
         dlg.close()
 
     def _ok(out: np.ndarray):
@@ -157,13 +173,23 @@ def run_aberration_ai_via_preset(main, preset: dict | None = None, doc=None):
             dlg.close()
 
     worker.failed.connect(_fail)
+    worker.canceled.connect(_canceled)          # <-- NEW
     worker.finished_ok.connect(_ok)
     worker.finished.connect(lambda: btn.setEnabled(False))
-    btn.clicked.connect(worker.terminate)
+
+    btn.clicked.connect(_cancel_clicked)
+
+    # If user closes dialog via window X, also cancel
+    dlg.rejected.connect(_cancel_clicked)
 
     worker.start()
     dlg.exec()
 
+    # Ensure the worker is not left running after the modal closes
+    if worker.isRunning():
+        worker.cancel()
+        worker.wait(2000)  # don't hang forever; just give it a moment
+
     # clear the guard after a brief tick so downstream signals don’t re-open UI
     def _clear():
         for k in ("_aberration_ai_headless_running", "_aberration_ai_guard"):

setiastro/saspro/add_stars.py

@@ -578,10 +578,9 @@ class AddStarsDialog(QDialog):
 
         # Emit (target_doc, blended_image)
         self.stars_added.emit(target_doc, self.blended_image.astype(np.float32, copy=False))
-        # Dialog stays open so user can apply to other images
-        # Refresh combo boxes for next operation
-        self._populate_doc_combos()
-
+        # Close UI after apply
+        self.accept()   # or: self.close()
+        return
 
     # Ensure initial fit once shown
     def showEvent(self, ev):
@@ -606,7 +605,32 @@ def add_stars(main):
 
     dlg = AddStarsDialog(main, parent=main)
     dlg.stars_added.connect(lambda target, arr: _apply_to_doc(main, target, arr))
-    dlg.exec()
+
+    # IMPORTANT: keep a strong reference (non-modal show)
+    if not hasattr(main, "_tool_dialogs"):
+        main._tool_dialogs = []
+    main._tool_dialogs.append(dlg)
+
+    # When the dialog closes, drop the reference
+    def _cleanup(_=None, d=dlg):
+        try:
+            if hasattr(main, "_tool_dialogs") and d in main._tool_dialogs:
+                main._tool_dialogs.remove(d)
+        except Exception:
+            pass
+
+    try:
+        dlg.finished.connect(_cleanup)     # QDialog signal
+    except Exception:
+        pass
+    try:
+        dlg.destroyed.connect(_cleanup)    # QObject signal (extra safety)
+    except Exception:
+        pass
+
+    dlg.show()
+    dlg.raise_()
+    dlg.activateWindow()
 
 
 def _apply_to_doc(main, doc, arr: np.ndarray):

setiastro/saspro/backgroundneutral.py

@@ -20,47 +20,75 @@ from setiastro.saspro.widgets.themed_buttons import themed_toolbtn
 # ----------------------------
 # Core neutralization function
 # ----------------------------
-def background_neutralize_rgb(img: np.ndarray, rect_xywh: tuple[int, int, int, int]) -> np.ndarray:
+def _remove_channel_pedestal(img_rgb01: np.ndarray) -> np.ndarray:
     """
-    Apply Background Neutralization to an RGB float32 image in [0,1],
-    using an image-space rectangle (x, y, w, h) as the sample region.
-    Returns a new float32 array in [0,1].
+    Remove a per-channel pedestal using the whole image:
+        out[...,c] = out[...,c] - min(out[...,c])
+    Assumes float32-ish data; returns float32 clipped to [0,1].
+    """
+    out = img_rgb01.astype(np.float32, copy=True)
+
+    mins = np.nanmin(out.reshape(-1, 3), axis=0).astype(np.float32)  # (3,)
+    # If a channel is all-NaN, nanmin returns NaN; guard it:
+    mins = np.where(np.isfinite(mins), mins, 0.0).astype(np.float32)
+
+    out -= mins.reshape(1, 1, 3)
+    return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
+
+def background_neutralize_rgb(
+    img: np.ndarray,
+    rect_xywh: tuple[int, int, int, int],
+    mode: str = "pivot1",
+    *,
+    remove_pedestal: bool = True,
+) -> np.ndarray:
+    """
+    ...
+    Step 0 (optional): whole-image pedestal removal (per-channel)
     """
     if img.ndim != 3 or img.shape[2] != 3:
         raise ValueError("Background Neutralization requires a 3-channel RGB image.")
 
-    h, w, _ = img.shape
+    # Step 0: pedestal removal on the WHOLE image (optional)
+    out = _remove_channel_pedestal(img) if remove_pedestal else img.astype(np.float32, copy=True)
+
+    # Resolve sample rect (use pedestal-free image for medians)
+    h, w, _ = out.shape
     x, y, rw, rh = rect_xywh
     x = max(0, min(int(x), w - 1))
     y = max(0, min(int(y), h - 1))
     rw = max(1, min(int(rw), w - x))
     rh = max(1, min(int(rh), h - y))
 
-    sample = img[y:y+rh, x:x+rw, :]
-    medians = np.median(sample, axis=(0, 1)).astype(np.float32)         # (3,)
-    avg_med = float(np.mean(medians))
+    sample = out[y:y + rh, x:x + rw, :]
+    m = np.median(sample, axis=(0, 1)).astype(np.float32)  # (3,)
+    t = float(np.mean(m))
 
-    out = img.copy()
     eps = 1e-8
-    
-    # Vectorized neutralization
-    # diff shape: (3,) -> (1, 1, 3) 
-    diffs = (medians - avg_med).reshape(1, 1, 3)
-    
-    # denom shape: (1, 1, 3)
-    denoms = 1.0 - diffs
-    
-    # Avoid div-by-zero (vectorized)
-    # logic: if abs(denom) < eps, set to eps (sign matched)
-    # We can do this efficiently:
-    small_mask = np.abs(denoms) < eps
-    denoms[small_mask] = np.where(denoms[small_mask] >= 0, eps, -eps)
-    
-    # Apply formula: (pixel - diff) / denom
-    out = (out - diffs) / denoms
-    out = np.clip(out, 0.0, 1.0)
 
-    return out.astype(np.float32, copy=False)
+    if mode == "offset":
+        delta = (t - m).reshape(1, 1, 3)
+
+        # cap deltas so we cannot clip
+        ch_min = out.reshape(-1, 3).min(axis=0)
+        ch_max = out.reshape(-1, 3).max(axis=0)
+        delta = np.clip(
+            delta,
+            (-ch_min + 0.0).reshape(1, 1, 3),
+            (1.0 - ch_max).reshape(1, 1, 3)
+        )
+
+        return np.clip(out + delta, 0.0, 1.0).astype(np.float32, copy=False)
+
+    # pivot around 1.0 scaling (highlight-protect)
+    denom = np.maximum(1.0 - m, eps)         # (3,)
+    g = (1.0 - t) / denom                    # (3,)
+    g = np.clip(g, 0.0, 10.0)                # sanity cap
+
+    out = 1.0 - (1.0 - out) * g.reshape(1, 1, 3)
+    return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
 
 
 # ------------------------------------
@@ -208,14 +236,26 @@ def apply_background_neutral_to_doc(doc, preset: dict | None = None):
         raise ValueError("Background Neutralization currently supports RGB images.")
 
     if mode == "rect":
-        rn = preset.get("rect_norm")
-        if not rn or len(rn) != 4:
+        rn = preset.get("rect_norm", None)
+
+        # IMPORTANT: don't do `if not rn` because rn may be a numpy array
+        if rn is None:
             raise ValueError("rect mode requires rect_norm=[x,y,w,h] in normalized coords.")
+
+        # Coerce array-like -> list
+        try:
+            rn = list(rn)
+        except Exception:
+            raise ValueError("rect_norm must be an iterable of 4 numbers.")
+
+        if len(rn) != 4:
+            raise ValueError("rect mode requires rect_norm=[x,y,w,h] (len==4).")
+
         H, W, _ = base.shape
-        x = int(np.clip(rn[0], 0, 1) * W)
-        y = int(np.clip(rn[1], 0, 1) * H)
-        w = int(np.clip(rn[2], 0, 1) * W)
-        h = int(np.clip(rn[3], 0, 1) * H)
+        x = int(np.clip(float(rn[0]), 0.0, 1.0) * W)
+        y = int(np.clip(float(rn[1]), 0.0, 1.0) * H)
+        w = int(np.clip(float(rn[2]), 0.0, 1.0) * W)
+        h = int(np.clip(float(rn[3]), 0.0, 1.0) * H)
         rect = (x, y, max(w, 1), max(h, 1))
     else:
         rect = auto_rect_50x50(base)

setiastro/saspro/blink_comparator_pro.py

@@ -93,13 +93,34 @@ class MetricsPanel(QWidget):
 
     @staticmethod
     def _compute_one(i_entry):
+        """
+        Compute (FWHM, eccentricity, star_count) using SEP on a *2x downsampled*
+        mono float32 frame.
+
+        - Downsample is fixed at 2x (linear), using AREA.
+        - FWHM is converted back to full-res pixel units by multiplying by 2.
+        Optionally multiply by sqrt(2) if you want to compensate for the
+        AREA downsample's effective smoothing (see fwhm_factor below).
+        - Eccentricity is scale-invariant.
+        - Star count should be closer to full-res if we also scale minarea
+        from 16 -> 4 (area scales by 1/4).
+        """
+
+        import cv2
+        import sep
+
         idx, entry = i_entry
-        img = entry['image_data']
+        img = entry["image_data"]
 
-        # normalize to float32 mono [0..1] exactly like live
         data = np.asarray(img)
+        h0, w0 = data.shape[:2]
+
+        # ----------------------------
+        # 1) Normalize to float32 mono [0..1]
+        # ----------------------------
         if data.ndim == 3:
             data = data.mean(axis=2)
+
         if data.dtype == np.uint8:
             data = data.astype(np.float32) / 255.0
         elif data.dtype == np.uint16:
@@ -107,35 +128,63 @@ class MetricsPanel(QWidget):
         else:
             data = data.astype(np.float32, copy=False)
 
+        # Guard: SEP expects finite values
+        if not np.isfinite(data).all():
+            data = np.nan_to_num(data, nan=0.0, posinf=1.0, neginf=0.0).astype(np.float32, copy=False)
+
+        # ----------------------------
+        # 2) Fixed 2x downsample (linear /2)
+        # ----------------------------
+        # Use integer decimation by resize to preserve speed and consistency.
+        new_w = max(16, w0 // 2)
+        new_h = max(16, h0 // 2)
+        ds = cv2.resize(data, (new_w, new_h), interpolation=cv2.INTER_AREA)
+
+        # ----------------------------
+        # 3) SEP pipeline (same as before, but minarea scaled)
+        # ----------------------------
         try:
-            # --- match old Blink’s SEP pipeline ---
-            bkg = sep.Background(data)
+            bkg = sep.Background(ds)
             back = bkg.back()
             try:
                 gr = float(bkg.globalrms)
             except Exception:
-                # some SEP builds only expose per-cell rms map
                 gr = float(np.median(np.asarray(bkg.rms(), dtype=np.float32)))
 
+            # minarea: 16 at full-res ~= 4 at 2x downsample (area /4)
+            minarea = 4
+
             cat = sep.extract(
-                data - back,
+                ds - back,
                 thresh=7.0,
                 err=gr,
-                minarea=16,
+                minarea=minarea,
                 clean=True,
                 deblend_nthresh=32,
             )
 
             if len(cat) > 0:
                 # FWHM via geometric-mean sigma (old Blink)
-                sig = np.sqrt(cat['a'] * cat['b']).astype(np.float32, copy=False)
-                fwhm = float(np.nanmedian(2.3548 * sig))
-
-                # TRUE eccentricity: e = sqrt(1 - (b/a)^2)  (old Blink)
-                # guard against divide-by-zero and NaNs
-                a = np.maximum(cat['a'].astype(np.float32, copy=False), 1e-12)
-                b = np.clip(cat['b'].astype(np.float32, copy=False), 0.0, None)
-                q = np.clip(b / a, 0.0, 1.0)  # b/a
+                sig = np.sqrt(cat["a"] * cat["b"]).astype(np.float32, copy=False)
+                fwhm_ds = float(np.nanmedian(2.3548 * sig))
+
+                # ----------------------------
+                # 4) Convert FWHM back to full-res
+                # ----------------------------
+                # Pure geometric reconversion: *2
+                # If you want the "noise reduction" compensation you mentioned:
+                #   multiply by sqrt(2) instead of 2, or 2*sqrt(2) depending on intent.
+                #
+                # Most consistent with "true full-res pixels" is factor = 2.
+                # If you insist on smoothing-compensation, set factor = 2*np.sqrt(2)
+                # (because you still have to undo scale, and then add smoothing term).
+                fwhm_factor = 2.0  # change to (2.0 * np.sqrt(2.0)) if you really want it
+                fwhm = fwhm_ds * fwhm_factor
+
+                # TRUE eccentricity
+                a = np.maximum(cat["a"].astype(np.float32, copy=False), 1e-12)
+                b = np.clip(cat["b"].astype(np.float32, copy=False), 0.0, None)
+                q = np.clip(b / a, 0.0, 1.0)
                 e_true = np.sqrt(np.maximum(0.0, 1.0 - q * q))
                 ecc = float(np.nanmedian(e_true))
 
@@ -144,51 +193,46 @@ class MetricsPanel(QWidget):
                 fwhm, ecc, star_cnt = np.nan, np.nan, 0
 
         except Exception:
-            # same sentinel behavior as before
             fwhm, ecc, star_cnt = 10.0, 1.0, 0
 
-        orig_back = entry.get('orig_background', np.nan)
+        orig_back = entry.get("orig_background", np.nan)
         return idx, fwhm, ecc, orig_back, star_cnt
 
 
-    def compute_all_metrics(self, loaded_images):
-        """Run SEP over the full list in parallel using threads and cache results."""
+
+    def compute_all_metrics(self, loaded_images) -> bool:
+        """
+        Run SEP over the full list in parallel using threads and cache results.
+        Uses *downsampled* SEP for speed + lower RAM.
+        Returns True if metrics were computed, False if user canceled.
+        """
+        from concurrent.futures import ThreadPoolExecutor, as_completed
+        import os
+        import numpy as np
+        import psutil
+        from PyQt6.QtCore import Qt
+        from PyQt6.QtWidgets import QProgressDialog, QApplication
+
         n = len(loaded_images)
         if n == 0:
-            # Clear any previous state and bail
             self._orig_images = []
-            self.metrics_data = [np.array([])]*4
+            self.metrics_data = [np.array([])] * 4
             self.flags = []
-            self._threshold_initialized = [False]*4
-            return
-
-        # Heads-up dialog (as you already had)
-        settings = QSettings()
-        show = settings.value("metrics/showWarning", True, type=bool)
-        if show:
-            msg = QMessageBox(self)
-            msg.setWindowTitle(self.tr("Heads-up"))
-            msg.setText(self.tr(
-                "This is going to use ALL your CPU cores and the UI may lock up until it finishes.\n\n"
-                "Continue?"
-            ))
-            msg.setStandardButtons(QMessageBox.StandardButton.Yes |
-                                QMessageBox.StandardButton.No)
-            cb = QCheckBox(self.tr("Don't show again"), msg)
-            msg.setCheckBox(cb)
-            if msg.exec() != QMessageBox.StandardButton.Yes:
-                return
-            if cb.isChecked():
-                settings.setValue("metrics/showWarning", False)
+            self._threshold_initialized = [False] * 4
+            return True
 
-        # pre-allocate result arrays
-        m0 = np.full(n, np.nan, dtype=np.float32)  # FWHM
+        # ----------------------------
+        # 1) Allocate result arrays
+        # ----------------------------
+        m0 = np.full(n, np.nan, dtype=np.float32)  # FWHM (full-res px units)
         m1 = np.full(n, np.nan, dtype=np.float32)  # Eccentricity
         m2 = np.full(n, np.nan, dtype=np.float32)  # Background (cached)
         m3 = np.full(n, np.nan, dtype=np.float32)  # Star count
-        flags = [e.get('flagged', False) for e in loaded_images]
+        flags = [e.get("flagged", False) for e in loaded_images]
 
-        # progress dialog
+        # ----------------------------
+        # 2) Progress dialog (Cancel)
+        # ----------------------------
         prog = QProgressDialog(self.tr("Computing frame metrics…"), self.tr("Cancel"), 0, n, self)
         prog.setWindowModality(Qt.WindowModality.WindowModal)
         prog.setMinimumDuration(0)
@@ -196,34 +240,76 @@ class MetricsPanel(QWidget):
         prog.show()
         QApplication.processEvents()
 
-        workers = min(os.cpu_count() or 1, 60)
+        cpu = os.cpu_count() or 1
+
+        # ----------------------------
+        # 3) Worker sizing by RAM (downsample-aware)
+        # ----------------------------
+        # Estimate using the same max_dim as _compute_one (default 1024).
+        # Use first frame to estimate scale.
+        max_dim = int(loaded_images[0].get("metrics_max_dim", 1024))
+        h0, w0 = loaded_images[0]["image_data"].shape[:2]
+        scale = 1.0
+        if max(h0, w0) > max_dim:
+            scale = max_dim / float(max(h0, w0))
+
+        hd = max(16, int(round(h0 * scale)))
+        wd = max(16, int(round(w0 * scale)))
+
+        # float32 mono downsample buffer
+        bytes_per = hd * wd * 4
+
+        # SEP allocates extra maps; budget ~3x to be safe.
+        budget_per_worker = int(bytes_per * 3.0)
+
+        avail = psutil.virtual_memory().available
+        max_by_mem = max(1, int(avail / max(budget_per_worker, 1)))
+
+        # Don’t exceed CPU, and don’t go crazy high even if RAM is huge
+        workers = max(1, min(cpu, max_by_mem, 24))
+
         tasks = [(i, loaded_images[i]) for i in range(n)]
-        done = 0  # <-- FIX: initialize before incrementing
+        done = 0
+        canceled = False
 
         try:
             with ThreadPoolExecutor(max_workers=workers) as exe:
                 futures = {exe.submit(self._compute_one, t): t[0] for t in tasks}
                 for fut in as_completed(futures):
                     if prog.wasCanceled():
+                        canceled = True
                         break
+
                     try:
                         idx, fwhm, ecc, orig_back, star_cnt = fut.result()
                     except Exception:
-                        # On failure, leave NaNs/sentinels and continue
-                        idx, fwhm, ecc, orig_back, star_cnt = futures[fut], np.nan, np.nan, np.nan, 0
-                    m0[idx], m1[idx], m2[idx], m3[idx] = fwhm, ecc, orig_back, float(star_cnt)
+                        idx = futures.get(fut, 0)
+                        fwhm, ecc, orig_back, star_cnt = np.nan, np.nan, np.nan, 0
+
+                    if 0 <= idx < n:
+                        m0[idx] = fwhm
+                        m1[idx] = ecc
+                        m2[idx] = orig_back
+                        m3[idx] = float(star_cnt)
+
                     done += 1
                     prog.setValue(done)
                     QApplication.processEvents()
         finally:
             prog.close()
 
-        # stash results
+        if canceled:
+            # IMPORTANT: leave caches alone; caller handles clear/return
+            return False
+
+        # ----------------------------
+        # 4) Stash results
+        # ----------------------------
         self._orig_images = loaded_images
         self.metrics_data = [m0, m1, m2, m3]
         self.flags = flags
-        self._threshold_initialized = [False]*4
-
+        self._threshold_initialized = [False] * 4
+        return True
 
     def plot(self, loaded_images, indices=None):
         """
@@ -242,7 +328,16 @@ class MetricsPanel(QWidget):
 
         # compute & cache on first call or new image list
         if self._orig_images is not loaded_images or self.metrics_data is None:
-            self.compute_all_metrics(loaded_images)
+            ok = self.compute_all_metrics(loaded_images)
+            if not ok or self.metrics_data is None:
+                # user declined/canceled -> clear plots and exit cleanly
+                for pw, scat, line in zip(self.plots, self.scats, self.lines):
+                    scat.setData(x=[], y=[])
+                    line.setPos(0)
+                    pw.getPlotItem().getViewBox().update()
+                    pw.repaint()
+                return
+
 
         # default to all indices
         if indices is None:

setiastro/saspro/convo.py

@@ -1118,13 +1118,14 @@ class ConvoDeconvoDialog(QDialog):
         if img is None:
             QMessageBox.warning(self, "No Image", "Please select an image before estimating PSF.")
             return
+
         img_gray = img.mean(axis=2).astype(np.float32) if (img.ndim == 3) else img.astype(np.float32)
 
-        sigma   = self.sep_threshold_slider.value()
-        minarea = self.sep_minarea_spin.value
-        sat     = self.sep_sat_slider.value()
-        maxstars= self.sep_maxstars_spin.value
-        half_w  = self.sep_stamp_spin.value
+        sigma    = float(self.sep_threshold_slider.value())
+        minarea  = int(self.sep_minarea_spin.value())     # ✅
+        sat      = float(self.sep_sat_slider.value())
+        maxstars = int(self.sep_maxstars_spin.value())    # ✅
+        half_w   = int(self.sep_stamp_spin.value())       # ✅
 
         try:
             psf_kernel = estimate_psf_from_image(
@@ -1136,11 +1137,13 @@ class ConvoDeconvoDialog(QDialog):
                 stamp_half_width=half_w
             )
         except RuntimeError as e:
-            QMessageBox.critical(self, "PSF Error", str(e)); return
+            QMessageBox.critical(self, "PSF Error", str(e))
+            return
 
         self._last_stellar_psf = psf_kernel
         self._show_stellar_psf_preview(psf_kernel)
 
+
     def _show_stellar_psf_preview(self, psf_kernel: np.ndarray):
         h, w = psf_kernel.shape
         img8 = ((psf_kernel / max(psf_kernel.max(), 1e-12)) * 255.0).astype(np.uint8)