setiastrosuitepro 1.6.12__py3-none-any.whl → 1.7.3__py3-none-any.whl

setiastro/saspro/_generated/build_info.py

@@ -1,3 +1,3 @@
 # Auto-generated at build time. Do not edit.
-BUILD_TIMESTAMP = "2026-01-07T16:45:00Z"
-APP_VERSION = "1.6.12"
+BUILD_TIMESTAMP = "2026-01-20T16:24:15Z"
+APP_VERSION = "1.7.3"

setiastro/saspro/aberration_ai.py

@@ -7,13 +7,37 @@ import numpy as np
 import sys
 import platform  # add
 import time
+import subprocess
 
 IS_APPLE_ARM = (sys.platform == "darwin" and platform.machine() == "arm64")
 
+def _has_nvidia_gpu() -> bool:
+    """Check if system has an NVIDIA GPU (Linux/Windows)."""
+    try:
+        if platform.system() == "Linux":
+            r = subprocess.run(["nvidia-smi", "-L"], capture_output=True, timeout=2)
+            return "GPU" in (r.stdout.decode("utf-8", errors="ignore") or "")
+        elif platform.system() == "Windows":
+            try:
+                ps = subprocess.run(
+                    ["powershell", "-NoProfile", "-Command",
+                     "(Get-CimInstance Win32_VideoController | Select-Object -ExpandProperty Name) -join ';'"],
+                    capture_output=True, timeout=2
+                )
+                out = (ps.stdout.decode("utf-8", errors="ignore") or "").lower()
+                return "nvidia" in out
+            except Exception:
+                w = subprocess.run(["wmic", "path", "win32_VideoController", "get", "name"],
+                                  capture_output=True, timeout=2)
+                return "nvidia" in (w.stdout.decode("utf-8", errors="ignore") or "").lower()
+    except Exception:
+        pass
+    return False
+
 from PyQt6.QtCore import Qt, QThread, pyqtSignal, QStandardPaths, QSettings
 from PyQt6.QtWidgets import (
     QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QFileDialog,
-    QComboBox, QSpinBox, QProgressBar, QMessageBox, QCheckBox, QLineEdit
+    QComboBox, QSpinBox, QProgressBar, QMessageBox, QCheckBox, QLineEdit, QApplication
 )
 from PyQt6.QtGui import QIcon
 from setiastro.saspro.config import Config
@@ -145,10 +169,13 @@ def _restore_output(arr: np.ndarray, channels_last: bool, was_uint16: bool, H: i
         arr = arr[0]                 # (H,W)
     return arr
 
-def run_onnx_tiled(session, img: np.ndarray, patch_size=512, overlap=64, progress_cb=None) -> np.ndarray:
+def run_onnx_tiled(session, img: np.ndarray, patch_size=512, overlap=64,
+                  progress_cb=None, cancel_cb=None) -> np.ndarray:
     """
     session: onnxruntime.InferenceSession
     img: mono (H,W) or RGB (H,W,3) numpy array
+
+    cancel_cb: callable -> bool, return True to cancel
     """
     arr, channels_last, was_uint16 = _prepare_input(img)      # (C,H,W)
     arr, H0, W0 = _pad_C_HW(arr, patch_size)
@@ -168,11 +195,15 @@ def run_onnx_tiled(session, img: np.ndarray, patch_size=512, overlap=64, progres
     for c in range(C):
         for i in hs:
             for j in ws:
-                patch = arr[c:c+1, i:i+patch_size, j:j+patch_size]  # (1, P, P)
+                if cancel_cb and cancel_cb():
+                    raise RuntimeError("Canceled")
+
+                patch = arr[c:c+1, i:i+patch_size, j:j+patch_size]  # (1,P,P)
                 inp = np.ascontiguousarray(patch[np.newaxis, ...], dtype=np.float32)  # (1,1,P,P)
 
                 out_patch = session.run(None, {inp_name: inp})[0]   # (1,1,P,P)
                 out_patch = np.squeeze(out_patch, axis=0)           # (1,P,P)
+
                 out[c:c+1, i:i+patch_size, j:j+patch_size] += out_patch * win
                 wgt[c:c+1, i:i+patch_size, j:j+patch_size] += win
 
@@ -184,7 +215,6 @@ def run_onnx_tiled(session, img: np.ndarray, patch_size=512, overlap=64, progres
     arr = out / wgt
     return _restore_output(arr, channels_last, was_uint16, H0, W0)
 
-
 # ---------- providers ----------
 def pick_providers(auto_gpu=True) -> list[str]:
     """
@@ -248,9 +278,11 @@ def _preserve_border(dst: np.ndarray, src: np.ndarray, px: int = 10) -> np.ndarr
 
 # ---------- worker ----------
 class _ONNXWorker(QThread):
-    progressed = pyqtSignal(int)         # 0..100
-    failed     = pyqtSignal(str)
-    finished_ok= pyqtSignal(np.ndarray)
+    progressed   = pyqtSignal(int)          # 0..100
+    failed       = pyqtSignal(str)
+    finished_ok  = pyqtSignal(np.ndarray)
+    canceled     = pyqtSignal()
+    log_message  = pyqtSignal(str)          # for console logging
 
     def __init__(self, model_path: str, image: np.ndarray, patch: int, overlap: int, providers: list[str]):
         super().__init__()
@@ -260,33 +292,115 @@ class _ONNXWorker(QThread):
         self.overlap = overlap
         self.providers = providers
         self.used_provider = None
+        self._cancel = False  # cooperative flag
+
+    def cancel(self):
+        # Safe to call from UI thread
+        self._cancel = True
+        self.requestInterruption()
+
+    def _is_canceled(self) -> bool:
+        return self._cancel or self.isInterruptionRequested()
 
     def run(self):
         if ort is None:
             self.failed.emit("onnxruntime is not installed.")
             return
+
+        # If canceled before start, exit cleanly
+        if self._is_canceled():
+            self.canceled.emit()
+            return
+
+        # Log available providers for debugging
+        avail_providers = ort.get_available_providers()
+        gpu_providers = [p for p in self.providers if p != "CPUExecutionProvider"]
+        has_nvidia = _has_nvidia_gpu()
+        
+        self.log_message.emit(f"🔍 Available ONNX providers: {', '.join(avail_providers)}")
+        self.log_message.emit(f"🔍 Attempting providers: {', '.join(self.providers)}")
+        print(f"🔍 Available ONNX providers: {', '.join(avail_providers)}")
+        print(f"🔍 Attempting providers: {', '.join(self.providers)}")
+        
+        # Check if NVIDIA GPU is present but CUDA provider is missing
+        if has_nvidia and "CUDAExecutionProvider" not in avail_providers:
+            msg = ("⚠️ GPU NVIDIA détecté mais CUDAExecutionProvider n'est pas disponible.\n"
+                   "   Vous devez installer 'onnxruntime-gpu' au lieu de 'onnxruntime'.\n"
+                   "   Commande: pip uninstall onnxruntime && pip install onnxruntime-gpu")
+            self.log_message.emit(msg)
+            print(msg)
+        
         try:
             sess = ort.InferenceSession(self.model_path, providers=self.providers)
             self.used_provider = (sess.get_providers()[0] if sess.get_providers() else None)
-        except Exception:
+            # Log successful GPU usage
+            if self.used_provider != "CPUExecutionProvider" and gpu_providers:
+                msg = f"✅ Aberration AI: Using GPU provider {self.used_provider}"
+                self.log_message.emit(msg)
+                print(msg)
+            elif has_nvidia and self.used_provider == "CPUExecutionProvider":
+                msg = ("⚠️ GPU NVIDIA détecté mais utilisation du CPU.\n"
+                       "   Installez 'onnxruntime-gpu' pour utiliser le GPU.")
+                self.log_message.emit(msg)
+                print(msg)
+        except Exception as e:
+            # Log the actual error for debugging
+            error_msg = str(e)
+            msg = f"⚠️ Aberration AI: GPU provider failed: {error_msg}"
+            self.log_message.emit(msg)
+            print(msg)
+            self.log_message.emit(f"Available providers: {', '.join(avail_providers)}")
+            print(f"Available providers: {', '.join(avail_providers)}")
+            self.log_message.emit(f"Attempted providers: {', '.join(self.providers)}")
+            print(f"Attempted providers: {', '.join(self.providers)}")
+            
+            # Check if onnxruntime-gpu is installed (CUDA provider should be available if it is)
+            if "CUDAExecutionProvider" in self.providers and "CUDAExecutionProvider" not in avail_providers:
+                if has_nvidia:
+                    msg = ("❌ CUDAExecutionProvider non disponible alors qu'un GPU NVIDIA est présent.\n"
+                           "   Installez 'onnxruntime-gpu': pip uninstall onnxruntime && pip install onnxruntime-gpu")
+                else:
+                    msg = "⚠️ CUDAExecutionProvider not available. You may need to install onnxruntime-gpu instead of onnxruntime."
+                self.log_message.emit(msg)
+                print(msg)
+            
             # fallback CPU if GPU fails
             try:
                 sess = ort.InferenceSession(self.model_path, providers=["CPUExecutionProvider"])
-                self.used_provider = "CPUExecutionProvider"  # NEW
+                self.used_provider = "CPUExecutionProvider"
+                msg = f"⚠️ Aberration AI: Falling back to CPU (GPU initialization failed: {error_msg})"
+                self.log_message.emit(msg)
+                print(msg)
             except Exception as e2:
-                self.failed.emit(f"Failed to init ONNX session:\n{e2}")
+                self.failed.emit(f"Failed to init ONNX session:\nGPU error: {error_msg}\nCPU error: {e2}")
                 return
 
         def cb(frac):
             self.progressed.emit(int(frac * 100))
 
         try:
-            out = run_onnx_tiled(sess, self.image, self.patch, self.overlap, cb)
+            out = run_onnx_tiled(
+                sess,
+                self.image,
+                self.patch,
+                self.overlap,
+                progress_cb=cb,
+                cancel_cb=self._is_canceled,
+            )
         except Exception as e:
-            self.failed.emit(str(e)); return
+            # Normalize cancel
+            msg = str(e) or "Error"
+            if "Canceled" in msg:
+                self.canceled.emit()
+            else:
+                self.failed.emit(msg)
+            return
 
-        self.finished_ok.emit(out)
+        if self._is_canceled():
+            self.canceled.emit()
+            return
 
+        self.finished_ok.emit(out)
 
 # ---------- dialog ----------
 class AberrationAIDialog(QDialog):
@@ -758,6 +872,7 @@ class AberrationAIDialog(QDialog):
         self._worker.failed.connect(self._on_failed)
         self._worker.finished_ok.connect(self._on_ok)
         self._worker.finished.connect(self._on_worker_finished)
+        self._worker.log_message.connect(self._log)  # Connect log messages to console
         self._worker.start()
 
 

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/astrospike_python.py

@@ -685,9 +685,51 @@ def render_spikes(output: np.ndarray, stars: List[Star], config: SpikeConfig, ct
         
         # Main spikes
         if config.intensity > 0:
-            for i in range(qty):
-                theta = main_angle_rad + (i * (math.pi * 2) / float(qty))
-                ...
+            rainbow_str = config.rainbow_spike_intensity if (config.enable_rainbow and config.rainbow_spikes) else 0
+            for i in range(int(config.quantity)):
+                theta = main_angle_rad + (i * (math.pi * 2) / float(config.quantity))
+                cos_t = math.cos(theta)
+                sin_t = math.sin(theta)
+                
+                start_x = star.x + cos_t * 0.5
+                start_y = star.y + sin_t * 0.5
+                end_x = star.x + cos_t * base_length
+                end_y = star.y + sin_t * base_length
+                
+                # Standard Spike
+                # Base star color, fading to zero alpha
+                c_end = (star.color.r/255.0, star.color.g/255.0, star.color.b/255.0, 0.0)
+                
+                # If rainbow enabled, standard spike is dimmed (matches preview logic)
+                opacity_mult = 0.4 if rainbow_str > 0 else 1.0
+                c_start = (color[0], color[1], color[2], color[3] * opacity_mult)
+                
+                draw_line_gradient(output, start_x, start_y, end_x, end_y,
+                                  c_start, c_end, thickness, config.sharpness)
+                
+                # Rainbow Overlay
+                if rainbow_str > 0:
+                    stops = 10
+                    for s in range(stops):
+                        p1 = s / stops
+                        p2 = (s + 1) / stops
+                        if p1 > config.rainbow_spike_length:
+                            break
+                        
+                        hue = (p1 * 360.0 * config.rainbow_spike_frequency) % 360.0
+                        a_rainbow = min(1.0, config.intensity * rainbow_str * 2.0) * (1.0 - p1)
+                        r_seg, g_seg, b_seg = hsl_to_rgb(hue / 360.0, 0.8, 0.6)
+                        c_seg = (r_seg, g_seg, b_seg, a_rainbow)
+                        
+                        # Calculate segment positions
+                        sx = start_x + (end_x - start_x) * p1
+                        sy = start_y + (end_y - start_y) * p1
+                        ex = start_x + (end_x - start_x) * p2
+                        ey = start_y + (end_y - start_y) * p2
+                        
+                        # Draw rainbow segment with constant color
+                        draw_line_gradient(output, sx, sy, ex, ey,
+                                          c_seg, c_seg, thickness, 1.0)
         
         # Secondary spikes
         if config.secondary_intensity > 0:

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
 
         # ----------------------------