setiastrosuitepro 1.7.5__py3-none-any.whl → 1.8.0__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-22T14:55:21Z"
-APP_VERSION = "1.7.5"
+BUILD_TIMESTAMP = "2026-01-26T16:03:43Z"
+APP_VERSION = "1.8.0"

setiastro/saspro/accel_installer.py

@@ -1,4 +1,4 @@
-# pro/accel_installer.py
+# saspro/accel_installer.py
 from __future__ import annotations
 import platform
 import subprocess
@@ -77,21 +77,34 @@ def _nvidia_driver_ok(log_cb: LogCB) -> bool:
         return False
 
 
-def ensure_torch_installed(prefer_gpu: bool, log_cb: LogCB) -> tuple[bool, Optional[str]]:
+def ensure_torch_installed(prefer_gpu: bool, log_cb: LogCB, preferred_backend: str = "auto") -> tuple[bool, Optional[str]]:
+
     try:
+        preferred_backend = (preferred_backend or "auto").lower()
         is_windows = platform.system() == "Windows"
+
         has_nv = _has_nvidia() and platform.system() in ("Windows", "Linux")
         has_intel = (not has_nv) and _has_intel_arc() and platform.system() in ("Windows", "Linux")
 
-        prefer_cuda = prefer_gpu and has_nv
-        prefer_xpu  = prefer_gpu and (not has_nv) and has_intel
+        prefer_cuda = prefer_gpu and (preferred_backend in ("auto", "cuda")) and has_nv
+        prefer_xpu  = prefer_gpu and (preferred_backend in ("auto", "xpu")) and (not has_nv) and has_intel
 
-        if prefer_cuda and not _nvidia_driver_ok(log_cb):
-            log_cb("CUDA requested but NVIDIA driver not detected/working; CUDA wheels may not initialize.")
-        log_cb(f"PyTorch install preference: prefer_cuda={prefer_cuda}, prefer_xpu={prefer_xpu} (OS={platform.system()})")
+        # NEW: DirectML preference is ONLY meaningful on Windows with no NVIDIA
+        prefer_dml = (
+            is_windows
+            and (not has_nv)
+            and preferred_backend in ("directml", "auto")
+            and prefer_gpu
+            and (not prefer_xpu)   # if Intel XPU actually works, prefer that over DML
+        )
+
+        # If user forced CPU, disable everything
+        if preferred_backend == "cpu":
+            prefer_cuda = prefer_xpu = prefer_dml = False
 
         # Install torch (tries CUDA → XPU → CPU)
-        torch = import_torch(prefer_cuda=prefer_cuda, prefer_xpu=prefer_xpu, status_cb=log_cb)
+        torch = import_torch(prefer_cuda=prefer_cuda, prefer_xpu=prefer_xpu, prefer_dml=prefer_dml, status_cb=log_cb)
+
 
         cuda_ok = bool(getattr(torch, "cuda", None) and torch.cuda.is_available())
         xpu_ok  = bool(hasattr(torch, "xpu") and torch.xpu.is_available())

setiastro/saspro/accel_workers.py

@@ -1,25 +1,24 @@
-# pro/accel_workers.py
+# saspro/accel_workers.py
 from __future__ import annotations
 from PyQt6.QtCore import QObject, pyqtSignal, QThread
 from setiastro.saspro.accel_installer import ensure_torch_installed
 
 class AccelInstallWorker(QObject):
-    progress = pyqtSignal(str)        # emitted from worker thread; GUI updates must connect with QueuedConnection
+    progress = pyqtSignal(str)        # emitted from worker thread
     finished = pyqtSignal(bool, str)  # (ok, message)
 
-    def __init__(self, prefer_gpu: bool = True):
+    def __init__(self, prefer_gpu: bool = True, preferred_backend: str = "auto"):
         super().__init__()
-        self.prefer_gpu = prefer_gpu
-
-    def _log(self, s: str):
-        # Never touch widgets here; just emit text
-        self.progress.emit(s)
+        self.prefer_gpu = bool(prefer_gpu)
+        self.preferred_backend = (preferred_backend or "auto").lower()
 
     def run(self):
-        # pure backend work; no QWidget/QMessageBox etc. in this method
-        ok, msg = ensure_torch_installed(self.prefer_gpu, self._log)
+        ok, msg = ensure_torch_installed(
+            prefer_gpu=self.prefer_gpu,
+            preferred_backend=self.preferred_backend,
+            log_cb=self.progress.emit
+        )
 
-        # honor cancellation if requested
         if QThread.currentThread().isInterruptionRequested():
             self.finished.emit(False, "Canceled.")
             return
@@ -27,4 +26,4 @@ class AccelInstallWorker(QObject):
         if ok:
             self.finished.emit(True, "PyTorch installed and ready.")
         else:
-            self.finished.emit(False, msg or "Installation failed.")
+            self.finished.emit(False, msg or "Installation failed.")

setiastro/saspro/blink_comparator_pro.py

@@ -63,6 +63,7 @@ class MetricsPanel(QWidget):
         self.flags = None              # list of bools
         self._threshold_initialized = [False]*4
         self._open_previews = []
+        self._show_guides = True  # default on (or False if you prefer)
 
         self.plots, self.scats, self.lines = [], [], []
         titles = [self.tr("FWHM (px)"), self.tr("Eccentricity"), self.tr("Background"), self.tr("Star Count")]
@@ -86,11 +87,101 @@ class MetricsPanel(QWidget):
                 lambda ln, m=idx: self._on_line_move(m, ln))
             pw.addItem(line)
 
+            # --- dashed reference lines: median + ±3σ (robust) ---
+            median_ln = pg.InfiniteLine(pos=0, angle=0, movable=False,
+                                        pen=pg.mkPen((220, 220, 220, 170), width=1, style=Qt.PenStyle.DashLine))
+            sigma_lo  = pg.InfiniteLine(pos=0, angle=0, movable=False,
+                                        pen=pg.mkPen((220, 220, 220, 120), width=1, style=Qt.PenStyle.DashLine))
+            sigma_hi  = pg.InfiniteLine(pos=0, angle=0, movable=False,
+                                        pen=pg.mkPen((220, 220, 220, 120), width=1, style=Qt.PenStyle.DashLine))
+
+            # keep them behind points/threshold visually
+            median_ln.setZValue(-10)
+            sigma_lo.setZValue(-10)
+            sigma_hi.setZValue(-10)
+
+            pw.addItem(median_ln)
+            pw.addItem(sigma_lo)
+            pw.addItem(sigma_hi)
+
+            # create the lists once
+            if not hasattr(self, "median_lines"):
+                self.median_lines = []
+                self.sigma_lines = []   # list of (lo, hi)
+
+            self.median_lines.append(median_ln)
+            self.sigma_lines.append((sigma_lo, sigma_hi))
             grid.addWidget(pw, idx//2, idx%2)
             self.plots.append(pw)
             self.scats.append(scat)
             self.lines.append(line)
 
+    def set_guides_visible(self, on: bool):
+        self._show_guides = bool(on)
+
+        if not self._show_guides:
+            # ✅ hide immediately
+            if hasattr(self, "median_lines"):
+                for ln in self.median_lines:
+                    ln.hide()
+            if hasattr(self, "sigma_lines"):
+                for lo, hi in self.sigma_lines:
+                    lo.hide()
+                    hi.hide()
+            return
+
+        # ✅ turning ON: recompute/restore based on what’s currently plotted
+        self._refresh_guides_from_current_plot()
+
+    def _refresh_guides_from_current_plot(self):
+        """Recompute/position guide lines using current plot data (if any)."""
+        if not getattr(self, "_show_guides", True):
+            return
+        if not hasattr(self, "median_lines") or not hasattr(self, "sigma_lines"):
+            return
+        # Use the scatter data already in each panel
+        for m, scat in enumerate(self.scats):
+            x, y = scat.getData()[:2]
+            if y is None or len(y) == 0:
+                self.median_lines[m].hide()
+                lo, hi = self.sigma_lines[m]
+                lo.hide(); hi.hide()
+                continue
+
+            med, sig = self._median_and_robust_sigma(np.asarray(y, dtype=np.float32))
+            mline = self.median_lines[m]
+            lo_ln, hi_ln = self.sigma_lines[m]
+
+            if np.isfinite(med):
+                mline.setPos(med); mline.show()
+            else:
+                mline.hide()
+
+            if np.isfinite(med) and np.isfinite(sig) and sig > 0:
+                lo = med - 3.0 * sig
+                hi = med + 3.0 * sig
+                if m == 3:
+                    lo = max(0.0, lo)
+                lo_ln.setPos(lo); hi_ln.setPos(hi)
+                lo_ln.show(); hi_ln.show()
+            else:
+                lo_ln.hide(); hi_ln.hide()
+
+
+    @staticmethod
+    def _median_and_robust_sigma(y: np.ndarray):
+        """Return (median, sigma) using MAD-based robust sigma. Ignores NaN/Inf."""
+        y = np.asarray(y, dtype=np.float32)
+        finite = np.isfinite(y)
+        if not finite.any():
+            return np.nan, np.nan
+        v = y[finite]
+        med = float(np.nanmedian(v))
+        mad = float(np.nanmedian(np.abs(v - med)))
+        sigma = 1.4826 * mad  # robust sigma estimate
+        return med, float(sigma)
+
+
     @staticmethod
     def _compute_one(i_entry):
         """
@@ -324,6 +415,15 @@ class MetricsPanel(QWidget):
                 line.setPos(0)
                 pw.getPlotItem().getViewBox().update()
                 pw.repaint()
+
+            # ✅ hide guides too
+            if hasattr(self, "median_lines"):
+                for ln in self.median_lines:
+                    ln.hide()
+            if hasattr(self, "sigma_lines"):
+                for lo, hi in self.sigma_lines:
+                    lo.hide()
+                    hi.hide()
             return
 
         # compute & cache on first call or new image list
@@ -358,6 +458,41 @@ class MetricsPanel(QWidget):
             ]
             scat.setData(x=x, y=y, brush=brushes, pen=pg.mkPen(None), size=8)
 
+            # --- update dashed reference lines (median + ±3σ) ---
+            if getattr(self, "_show_guides", True):
+                try:
+                    med, sig = self._median_and_robust_sigma(y)
+                    mline = self.median_lines[m]
+                    lo_ln, hi_ln = self.sigma_lines[m]
+
+                    if np.isfinite(med):
+                        mline.setPos(med)
+                        mline.show()
+                    else:
+                        mline.hide()
+
+                    if np.isfinite(med) and np.isfinite(sig) and sig > 0:
+                        lo = med - 3.0 * sig
+                        hi = med + 3.0 * sig
+                        if m == 3:
+                            lo = max(0.0, lo)
+                        lo_ln.setPos(lo); hi_ln.setPos(hi)
+                        lo_ln.show(); hi_ln.show()
+                    else:
+                        lo_ln.hide(); hi_ln.hide()
+                except Exception:
+                    if hasattr(self, "median_lines") and m < len(self.median_lines):
+                        self.median_lines[m].hide()
+                        a, b = self.sigma_lines[m]
+                        a.hide(); b.hide()
+            else:
+                # guides disabled -> force-hide
+                if hasattr(self, "median_lines") and m < len(self.median_lines):
+                    self.median_lines[m].hide()
+                    a, b = self.sigma_lines[m]
+                    a.hide(); b.hide()
+
+
             # initialize threshold line once
             if not self._threshold_initialized[m]:
                 mx, mn = np.nanmax(y), np.nanmin(y)
@@ -456,7 +591,10 @@ class MetricsWindow(QWidget):
         instr.setWordWrap(True)
         instr.setStyleSheet("color: #ccc; font-size: 12px;")
         vbox.addWidget(instr)
-
+        self.chk_guides = QCheckBox(self.tr("Show median and ±3σ guides"), self)
+        self.chk_guides.setChecked(True)  # default on
+        self.chk_guides.toggled.connect(self._on_toggle_guides)
+        vbox.addWidget(self.chk_guides)
         # → filter selector
         self.group_combo = QComboBox(self)
         self.group_combo.addItem(self.tr("All"))
@@ -479,6 +617,10 @@ class MetricsWindow(QWidget):
         self._all_images = []
         self._current_indices: Optional[List[int]] = None
 
+    def _on_toggle_guides(self, on: bool):
+        if hasattr(self, "metrics_panel") and self.metrics_panel is not None:
+            self.metrics_panel.set_guides_visible(on)
+
 
     def _update_status(self, *args):
         """Recompute and show: Flagged Items X / Y (Z%).  Robust to stale indices."""
@@ -537,6 +679,7 @@ class MetricsWindow(QWidget):
         self._current_indices = self._order_all
         self._apply_thresholds("All")
         self.metrics_panel.plot(self._all_images, indices=self._current_indices)
+        self.metrics_panel.set_guides_visible(self.chk_guides.isChecked())
         self._update_status()
 
     def _reindex_list_after_remove(self, lst: List[int] | None, removed: List[int]) -> List[int] | None:
@@ -666,7 +809,8 @@ class MetricsWindow(QWidget):
         grp = self.group_combo.currentText()
         # save it for this group
         self._thresholds_per_group[grp][metric_idx] = new_val
-
+        self.metrics_panel.plot(self._all_images, indices=self._current_indices)
+        self.metrics_panel.set_guides_visible(self.chk_guides.isChecked())
         # (if you also want immediate re-flagging in the tree, keep your BlinkTab logic hooked here)
 
     def _apply_thresholds(self, group_name: str):

setiastro/saspro/comet_stacking.py

@@ -13,15 +13,52 @@ from functools import lru_cache
 from astropy.io import fits
 from astropy.stats import sigma_clipped_stats
 import sep
-from setiastro.saspro.remove_stars import (
-    _get_setting_any,
-    _mtf_params_linked, _apply_mtf_linked_rgb, _invert_mtf_linked_rgb,
-    _resolve_darkstar_exe, _ensure_exec_bit, _purge_darkstar_io
-
+from setiastro.saspro.cosmicclarity_engines.darkstar_engine import (
+    darkstar_starremoval_rgb01,
+    DarkStarParams,
 )
+
+
 from setiastro.saspro.legacy.image_manager import (load_image, save_image)
 from setiastro.saspro.imageops.stretch import stretch_color_image, stretch_mono_image
 
+def _get_setting_any(settings, keys, default=None):
+    """
+    Try multiple keys against QSettings-like or dict-like settings.
+    keys: iterable of strings
+    """
+    if settings is None:
+        return default
+
+    # QSettings / object with .value()
+    if hasattr(settings, "value") and callable(getattr(settings, "value")):
+        for k in keys:
+            try:
+                v = settings.value(k, None)
+            except Exception:
+                v = None
+            if v not in (None, "", "None"):
+                return v
+        return default
+
+    # dict-like
+    if isinstance(settings, dict):
+        for k in keys:
+            if k in settings and settings[k] not in (None, "", "None"):
+                return settings[k]
+        return default
+
+    # fallback: attribute lookup
+    for k in keys:
+        try:
+            v = getattr(settings, k)
+        except Exception:
+            v = None
+        if v not in (None, "", "None"):
+            return v
+    return default
+
+
 def _blackpoint_nonzero(img_norm: np.ndarray, p: float = 0.1) -> float:
     """Scalar blackpoint from non-zero pixels across all channels (linked).
        p in [0..100]: small percentile to resist outliers; use 0 for strict min."""
@@ -66,6 +103,18 @@ def _u16_to_float01(x: np.ndarray) -> np.ndarray:
 
 # comet_stacking.py (or wherever this lives)
 
+def _ensure_exec_bit(path: str) -> None:
+    try:
+        if os.name == "nt":
+            return
+        p = os.path.realpath(path)
+        st = os.stat(p)
+        if not (st.st_mode & 0o111):
+            os.chmod(p, st.st_mode | 0o111)
+    except Exception:
+        return
+
+
 def starnet_starless_pair_from_array(
     src_rgb01,
     settings,
@@ -211,78 +260,42 @@ def starnet_starless_pair_from_array(
     return np.clip(protected_unstretch, 0.0, 1.0), np.clip(protected_unstretch, 0.0, 1.0)
 
 
-
-def darkstar_starless_from_array(src_rgb01: np.ndarray, settings, **_ignored) -> np.ndarray:
+def darkstar_starless_from_array(
+    src_rgb01: np.ndarray,
+    settings,
+    *,
+    use_gpu: bool = True,
+    chunk_size: int = 512,
+    overlap_frac: float = 0.125,
+    mode: str = "unscreen",
+    progress_cb=None,
+    status_cb=None,
+) -> np.ndarray:
     """
-    Headless CosmicClarity DarkStar run for a single RGB frame.
-    Returns starless RGB in [0..1]. Uses CC’s input/output folders.
+    In-process Dark Star removal via darkstar_engine.py
+    Input:  float32 [0..1], HxW or HxWx1 or HxWx3
+    Output: float32 [0..1], same "mono-ness" behavior as engine (HxWx1 if mono input)
     """
-    # normalize channels
-    img = src_rgb01.astype(np.float32, copy=False)
-    # Delay expansion: if it's 2D/Mono, send it as-is if DarkStar supports it, 
-    # but DarkStar expects 3-channel TIF usually. 
-    # We'll just expand for the save call, not "in place" if possible.
-    # Actually DarkStar runner saves `img` directly.
-    # So we'll expand just for that save to avoid holding 2 copies in memory.
-    if img.ndim == 2: 
-        img_to_save = np.stack([img]*3, axis=-1)
-    elif img.ndim == 3 and img.shape[2] == 1: 
-        img_to_save = np.repeat(img, 3, axis=2)
-    else:
-        img_to_save = img
-
-    # resolve exe and base folder
-    exe, base = _resolve_darkstar_exe(type("Dummy", (), {"settings": settings})())
-    if not exe or not base:
-        raise RuntimeError("Cosmic Clarity DarkStar executable path is not set.")
-
-    _ensure_exec_bit(exe)
-
-    input_dir  = os.path.join(base, "input")
-    output_dir = os.path.join(base, "output")
-    os.makedirs(input_dir, exist_ok=True)
-    os.makedirs(output_dir, exist_ok=True)
-
-    # purge any prior files (safe; scoped to imagetoremovestars*)
-    _purge_darkstar_io(base, prefix="imagetoremovestars", clear_input=True, clear_output=True)
-
-    in_path  = os.path.join(input_dir, "imagetoremovestars.tif")
-    out_path = os.path.join(output_dir, "imagetoremovestars_starless.tif")
-
-    # save input as float32 TIFF
-    # save input as float32 TIFF
-    save_image(img_to_save, in_path, original_format="tif", bit_depth="32-bit floating point",
-                   original_header=None, is_mono=False, image_meta=None, file_meta=None)
-
-    # build command (SASv2 parity): default unscreen, show extracted stars off, stride 512
-    cmd = [exe, "--star_removal_mode", "unscreen", "--chunk_size", "512"]
-
-    rc = subprocess.call(cmd, cwd=output_dir)
-    if rc != 0 or not os.path.exists(out_path):
-        try: os.remove(in_path)
-        except Exception as e:
-            import logging
-            logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
-        raise RuntimeError(f"DarkStar failed (rc={rc}).")
-
-    starless, _, _, _ = load_image(out_path)
-    # cleanup
-    try:
-        os.remove(in_path)
-        os.remove(out_path)
-        _purge_darkstar_io(base, prefix="imagetoremovestars", clear_input=True, clear_output=True)
-    except Exception:
-        pass
-
-    if starless is None:
-        raise RuntimeError("DarkStar produced no output.")
+    if progress_cb is None:
+        progress_cb = lambda done, total, stage: None
+    if status_cb is None:
+        status_cb = lambda msg: None
+
+    img = np.asarray(src_rgb01, np.float32)
+    params = DarkStarParams(
+        use_gpu=bool(use_gpu),
+        chunk_size=int(chunk_size),
+        overlap_frac=float(overlap_frac),
+        mode=str(mode),
+        output_stars_only=False,
+    )
 
-    # Delayed expansion
-    if starless.ndim == 2: 
-        starless = np.stack([starless]*3, axis=-1)
-    elif starless.ndim == 3 and starless.shape[2] == 1: 
-        starless = np.repeat(starless, 3, axis=2)
-        
+    starless, _stars_only, _was_mono = darkstar_starremoval_rgb01(
+        img,
+        params=params,
+        progress_cb=progress_cb,
+        status_cb=status_cb,
+    )
     return np.clip(starless.astype(np.float32, copy=False), 0.0, 1.0)
 
 # ---------- small helpers ----------
@@ -1106,16 +1119,37 @@ def _starless_frame_for_comet(img: np.ndarray,
 
     # run
     if tool == "CosmicClarityDarkStar":
-        # DarkStar returns in the same domain we fed in.
-        base_for_mask = src
-        starless = darkstar_starless_from_array(src, settings)
+        base_for_mask = src  # RGB [0..1]
+
+        # optional: forward progress from comet stacking if you want
+        def _ds_progress(done, total, stage):
+            # stage is like "Dark Star removal"
+            # you can route to log or status_cb; keep lightweight
+            pass
+
+        starless = darkstar_starless_from_array(
+            src,
+            settings,
+            use_gpu=True,
+            chunk_size=512,
+            overlap_frac=0.125,
+            mode="unscreen",
+            progress_cb=_ds_progress,
+            status_cb=None,  # or log
+        )
+
+        # DarkStar may return HxWx1 for mono-ish inputs — expand to RGB for nucleus protection
+        if starless.ndim == 2:
+            starless = np.repeat(starless[..., None], 3, axis=2)
+        elif starless.ndim == 3 and starless.shape[2] == 1:
+            starless = np.repeat(starless, 3, axis=2)
 
-        # protect nucleus (blend original back where mask=1), in *current* domain
         m = core_mask.astype(np.float32)
         m3 = np.repeat(m[..., None], 3, axis=2)
         protected = starless * (1.0 - m3) + base_for_mask * m3
         return np.clip(protected, 0.0, 1.0)
 
+
     else:
         # StarNet path: do mask-blend inside the function (in its stretched domain)
         protected, _ = starnet_starless_pair_from_array(
@@ -1302,13 +1336,7 @@ class CometCentroidPreview(QDialog):
     def _prep_slider(self, s, lo, hi, val):
         s.setRange(lo, hi); s.setValue(val); s.setSingleStep(1); s.setPageStep(5)
 
-    def eventFilter(self, obj, ev):
-        if obj is self.view.viewport() and ev.type() == QEvent.Type.MouseButtonPress:
-            if ev.button() == Qt.MouseButton.LeftButton:
-                pos = self.view.mapToScene(ev.position().toPoint())
-                self._set_xy_current(pos.x(), pos.y())
-                return True
-        return super().eventFilter(obj, ev)
+
 
     def keyPressEvent(self, ev):
         k = ev.key()