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

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,16 +193,26 @@ 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) -> bool:
-        """Run SEP over the full list in parallel using threads and cache results.
-        Returns True if metrics were computed, False if user declined/canceled.
         """
+        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:
             self._orig_images = []
@@ -162,62 +221,17 @@ class MetricsPanel(QWidget):
             self._threshold_initialized = [False] * 4
             return True
 
-        def _has_metrics(md):
-            try:
-                return md is not None and len(md) == 4 and md[0] is not None and len(md[0]) > 0
-            except Exception:
-                return False
-
-        settings = QSettings()
-        show_warning = settings.value("metrics/showWarning", True, type=bool)
-
-        if (not show_warning) and (not _has_metrics(getattr(self, "metrics_data", None))):
-            settings.setValue("metrics/showWarning", True)
-            show_warning = True
-
-        # ----------------------------
-        # 1) Optional warning gate
-        # ----------------------------
-        if show_warning:
-            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)
-
-            clicked = msg.exec()
-            clicked_yes = (clicked == QMessageBox.StandardButton.Yes)
-
-            if not clicked_yes:
-                # If they said NO, never allow "Don't show again" to lock them out.
-                # Keep the warning enabled so they can opt-in later.
-                if cb.isChecked():
-                    settings.setValue("metrics/showWarning", True)
-                return False
-
-            # They said YES: now it's safe to honor "Don't show again"
-            if cb.isChecked():
-                settings.setValue("metrics/showWarning", False)
-
-        # If show_warning is False, we compute with no prompt.
-
         # ----------------------------
-        # 2) Allocate result arrays
+        # 1) Allocate result arrays
         # ----------------------------
-        m0 = np.full(n, np.nan, dtype=np.float32)  # FWHM
+        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]
 
         # ----------------------------
-        # 3) Progress dialog
+        # 2) Progress dialog (Cancel)
         # ----------------------------
         prog = QProgressDialog(self.tr("Computing frame metrics…"), self.tr("Cancel"), 0, n, self)
         prog.setWindowModality(Qt.WindowModality.WindowModal)
@@ -226,7 +240,34 @@ 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
         canceled = False
@@ -238,6 +279,7 @@ class MetricsPanel(QWidget):
                     if prog.wasCanceled():
                         canceled = True
                         break
+
                     try:
                         idx, fwhm, ecc, orig_back, star_cnt = fut.result()
                     except Exception:
@@ -245,7 +287,10 @@ class MetricsPanel(QWidget):
                         fwhm, ecc, orig_back, star_cnt = np.nan, np.nan, np.nan, 0
 
                     if 0 <= idx < n:
-                        m0[idx], m1[idx], m2[idx], m3[idx] = fwhm, ecc, orig_back, float(star_cnt)
+                        m0[idx] = fwhm
+                        m1[idx] = ecc
+                        m2[idx] = orig_back
+                        m3[idx] = float(star_cnt)
 
                     done += 1
                     prog.setValue(done)
@@ -254,7 +299,7 @@ class MetricsPanel(QWidget):
             prog.close()
 
         if canceled:
-            # IMPORTANT: leave caches alone; caller will clear/return
+            # IMPORTANT: leave caches alone; caller handles clear/return
             return False
 
         # ----------------------------

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)

setiastro/saspro/curve_editor_pro.py

@@ -1769,14 +1769,38 @@ class CurvesDialogPro(QDialog):
         name, ok = QInputDialog.getText(self, self.tr("Save Curves Preset"), self.tr("Preset name:"))
         if not ok or not name.strip():
             return
-        pts_norm = self._collect_points_norm_from_editor()
-        mode = self._current_mode()
-        if save_custom_preset(name.strip(), mode, pts_norm):
-            self._set_status(self.tr("Saved preset “{0}”.").format(name.strip()))
+        name = name.strip()
+
+        # 0) flush active editor -> store (CRITICAL)
+        try:
+            self._curves_store[self._current_mode_key] = self._editor_points_norm()
+        except Exception:
+            pass
+
+        # 1) build a full multi-curve payload
+        modes = {}
+        for k, pts in self._curves_store.items():
+            if not isinstance(pts, (list, tuple)) or len(pts) < 2:
+                continue
+            # ensure floats (QSettings/JSON safety)
+            modes[k] = [(float(x), float(y)) for (x, y) in pts]
+
+        preset = {
+            "name": name,
+            "version": 2,
+            "kind": "curves_multi",
+            "active": self._current_mode_key,  # "K", "R", ...
+            "modes": modes,
+        }
+
+        # 2) save via your existing persistence
+        if save_custom_preset(name, preset):   # <-- change signature (see section 3)
+            self._set_status(self.tr("Saved preset “{0}”.").format(name))
             self._rebuild_presets_menu()
         else:
             QMessageBox.warning(self, self.tr("Save failed"), self.tr("Could not save preset."))
 
+
     def _rebuild_presets_menu(self):
         m = QMenu(self)
         # Built-in shapes under K (Brightness)
@@ -2400,43 +2424,69 @@ class CurvesDialogPro(QDialog):
     def _apply_preset_dict(self, preset: dict):
         preset = preset or {}
 
-        # 1) set mode radio
+        # -------- MULTI-CURVE (v2) --------
+        if preset.get("kind") == "curves_multi" or ("modes" in preset and isinstance(preset.get("modes"), dict)):
+            modes = preset.get("modes", {}) or {}
+
+            # 0) load all curves into store (fill missing keys with linear)
+            for k in self._curves_store.keys():
+                pts = modes.get(k)
+                if isinstance(pts, (list, tuple)) and len(pts) >= 2:
+                    self._curves_store[k] = [(float(x), float(y)) for (x, y) in pts]
+                else:
+                    self._curves_store[k] = [(0.0, 0.0), (1.0, 1.0)]
+
+            # 1) choose active key (default to K)
+            active = str(preset.get("active") or "K")
+            if active not in self._curves_store:
+                active = "K"
+            self._current_mode_key = active
+
+            # 2) set radio button that corresponds to active key
+            # map internal key -> radio label
+            key_to_label = {v: k for (k, v) in self._mode_key_map.items()}  # "K"->"K (Brightness)"
+            want_label = key_to_label.get(active, "K (Brightness)")
+            for b in self.mode_group.buttons():
+                if b.text() == want_label:
+                    b.setChecked(True)
+                    break
+
+            # 3) push active curve into editor
+            self._editor_set_from_norm(self._curves_store[active])
+
+            # 4) refresh overlays + preview
+            self._refresh_overlays()
+            self._quick_preview()
+
+            self._set_status(self.tr("Preset: {0}  [multi]").format(preset.get("name", self.tr("(built-in)"))))
+            return
+
+        # -------- LEGACY SINGLE-CURVE --------
+        # your existing single-curve behavior (slightly adjusted: store it too)
         want = _norm_mode(preset.get("mode"))
         for b in self.mode_group.buttons():
             if b.text().lower() == want.lower():
                 b.setChecked(True)
                 break
 
-        # 2) get points_norm — if absent, build from shape/amount (built-ins)
         ptsN = preset.get("points_norm")
-        shape = preset.get("shape")  # may be None for custom presets
+        shape = preset.get("shape")
         amount = float(preset.get("amount", 1.0))
 
         if not (isinstance(ptsN, (list, tuple)) and len(ptsN) >= 2):
             try:
-                # build from a named shape (built-ins); default to linear
                 ptsN = _shape_points_norm(str(shape or "linear"), amount)
             except Exception:
-                ptsN = [(0.0, 0.0), (1.0, 1.0)]  # safe fallback
-
-        # 3) apply handles to the editor (strip exact endpoints)
-        pts_scene = _points_norm_to_scene(ptsN)
-        filt = [(x, y) for (x, y) in pts_scene if 1e-6 < x < 360.0 - 1e-6]
-
-        if hasattr(self.editor, "clearSymmetryLine"):
-            self.editor.clearSymmetryLine()
+                ptsN = [(0.0, 0.0), (1.0, 1.0)]
 
-        self.editor.setControlHandles(filt)
-        self.editor.updateCurve()   # ensure redraw
-
-        # persist into store & refresh
+        self._editor_set_from_norm(ptsN)
         self._curves_store[self._current_mode_key] = self._editor_points_norm()
         self._refresh_overlays()
         self._quick_preview()
 
-        # 4) status: don’t assume shape exists
         shape_tag = f"[{shape}]" if shape else "[custom]"
-        self._set_status(self.tr("Preset: {0}  {1}").format(preset.get('name', self.tr('(built-in)')), shape_tag))
+        self._set_status(self.tr("Preset: {0}  {1}").format(preset.get("name", self.tr("(built-in)")), shape_tag))
+
 
 
 def apply_curves_ops(doc, op: dict):