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

setiastro/saspro/acv_exporter.py

@@ -0,0 +1,379 @@
+# src/setiastro/saspro/acv_exporter.py
+from __future__ import annotations
+
+import os
+import re
+from pathlib import Path
+
+from PyQt6.QtCore import Qt, QCoreApplication
+from PyQt6.QtWidgets import (
+    QDialog, QVBoxLayout, QHBoxLayout, QGridLayout, QGroupBox,
+    QLabel, QLineEdit, QPushButton, QFileDialog, QComboBox,
+    QMessageBox, QWidget
+)
+
+# If you have a canonical place for "global save_as", wire it here.
+# Example placeholders (change to your actual import):
+# from setiastro.saspro.actions.save_as import save_as
+# from setiastro.saspro.fileio.save_as import save_as
+
+
+def _tr(s: str) -> str:
+    return QCoreApplication.translate("AstroCatalogueViewerExporter", s)
+
+
+class AstroCatalogueViewerExporterDialog(QDialog):
+    """
+    Astro Catalogue Viewer Exporter
+    - Persist folders in QSettings
+    - Export current active document/view via your global save_as
+    - Route by name prefix: M -> Messier, NGC -> NGC, IC -> IC, C -> Caldwell, else Master
+    """
+
+    # QSettings keys
+    K_MASTER = "acv_export/master_folder"
+    K_M      = "acv_export/messier_folder"
+    K_NGC    = "acv_export/ngc_folder"
+    K_IC     = "acv_export/ic_folder"
+    K_C      = "acv_export/caldwell_folder"
+    K_FMT    = "acv_export/format"
+
+    def __init__(self, parent, dm, doc):
+        super().__init__(parent)
+        self.dm = dm
+        self.doc = doc
+        self.setObjectName("acv_exporter_dialog")
+        self.setWindowTitle(_tr("Astro Catalogue Viewer Exporter"))
+
+        # Prefer not using WA_DeleteOnClose if that’s a Linux landmine for you.
+        # (You can still set it from caller if you want.)
+        self._main = parent
+        self._settings = getattr(parent, "settings", None)  # typical SASpro pattern
+
+        root = QVBoxLayout(self)
+        root.setContentsMargins(12, 12, 12, 12)
+        root.setSpacing(10)
+
+        # -------------------------
+        # Folder section
+        # -------------------------
+        gb = QGroupBox(_tr("Image folders"), self)
+        g = QGridLayout(gb)
+        g.setContentsMargins(10, 10, 10, 10)
+        g.setHorizontalSpacing(10)
+        g.setVerticalSpacing(8)
+
+        self.ed_master = QLineEdit(self)
+        self.btn_master = QPushButton(_tr("Browse…"), self)
+        self.btn_master.clicked.connect(lambda: self._browse_folder(self.ed_master))
+
+        g.addWidget(QLabel(_tr("Master Image Folder")), 0, 0)
+        g.addWidget(self.ed_master, 0, 1)
+        g.addWidget(self.btn_master, 0, 2)
+
+        gb2 = QGroupBox(_tr("Image folder per catalog"), self)
+        gg = QGridLayout(gb2)
+        gg.setContentsMargins(10, 10, 10, 10)
+        gg.setHorizontalSpacing(10)
+        gg.setVerticalSpacing(8)
+
+        self.ed_m = QLineEdit(self)
+        self.ed_ngc = QLineEdit(self)
+        self.ed_ic = QLineEdit(self)
+        self.ed_c = QLineEdit(self)
+
+        bm = QPushButton(_tr("Browse…"), self); bm.clicked.connect(lambda: self._browse_folder(self.ed_m))
+        bn = QPushButton(_tr("Browse…"), self); bn.clicked.connect(lambda: self._browse_folder(self.ed_ngc))
+        bi = QPushButton(_tr("Browse…"), self); bi.clicked.connect(lambda: self._browse_folder(self.ed_ic))
+        bc = QPushButton(_tr("Browse…"), self); bc.clicked.connect(lambda: self._browse_folder(self.ed_c))
+
+        gg.addWidget(QLabel(_tr("Messier")), 0, 0); gg.addWidget(self.ed_m,   0, 1); gg.addWidget(bm, 0, 2)
+        gg.addWidget(QLabel(_tr("NGC")),     1, 0); gg.addWidget(self.ed_ngc, 1, 1); gg.addWidget(bn, 1, 2)
+        gg.addWidget(QLabel(_tr("IC")),      2, 0); gg.addWidget(self.ed_ic,  2, 1); gg.addWidget(bi, 2, 2)
+        gg.addWidget(QLabel(_tr("Caldwell")),3, 0); gg.addWidget(self.ed_c,   3, 1); gg.addWidget(bc, 3, 2)
+
+        root.addWidget(gb)
+        root.addWidget(gb2)
+
+        # -------------------------
+        # Export controls
+        # -------------------------
+        row = QHBoxLayout()
+        row.setSpacing(10)
+
+        self.ed_name = QLineEdit(self)
+        self.ed_name.setPlaceholderText(_tr("e.g. M31, NGC5060, M31_HaOnly…"))
+
+        self.cmb_fmt = QComboBox(self)
+        # keep these lower-case as “extensions”
+        self.cmb_fmt.addItems(["jpg", "png", "tif"])
+
+        self.btn_export = QPushButton(_tr("Export"), self)
+        self.btn_export.clicked.connect(self._on_export)
+
+        row.addWidget(QLabel(_tr("Image Name")), 0)
+        row.addWidget(self.ed_name, 2)
+        row.addWidget(QLabel(_tr("Type")), 0)
+        row.addWidget(self.cmb_fmt, 0)
+        row.addWidget(self.btn_export, 0)
+
+        root.addLayout(row)
+
+        # Load persisted settings
+        self._load_settings()
+
+        # Save on edits (lightweight)
+        self.ed_master.textChanged.connect(self._save_settings)
+        self.ed_m.textChanged.connect(self._save_settings)
+        self.ed_ngc.textChanged.connect(self._save_settings)
+        self.ed_ic.textChanged.connect(self._save_settings)
+        self.ed_c.textChanged.connect(self._save_settings)
+        self.cmb_fmt.currentTextChanged.connect(self._save_settings)
+
+    # -------------------------
+    # Settings
+    # -------------------------
+    def _load_settings(self):
+        s = self._settings
+        if s is None:
+            return
+        self.ed_master.setText(s.value(self.K_MASTER, "", type=str) or "")
+        self.ed_m.setText(s.value(self.K_M, "", type=str) or "")
+        self.ed_ngc.setText(s.value(self.K_NGC, "", type=str) or "")
+        self.ed_ic.setText(s.value(self.K_IC, "", type=str) or "")
+        self.ed_c.setText(s.value(self.K_C, "", type=str) or "")
+        fmt = (s.value(self.K_FMT, "png", type=str) or "png").lower()
+        idx = self.cmb_fmt.findText(fmt)
+        if idx >= 0:
+            self.cmb_fmt.setCurrentIndex(idx)
+
+    def _save_settings(self):
+        s = self._settings
+        if s is None:
+            return
+        s.setValue(self.K_MASTER, self.ed_master.text().strip())
+        s.setValue(self.K_M, self.ed_m.text().strip())
+        s.setValue(self.K_NGC, self.ed_ngc.text().strip())
+        s.setValue(self.K_IC, self.ed_ic.text().strip())
+        s.setValue(self.K_C, self.ed_c.text().strip())
+        s.setValue(self.K_FMT, self.cmb_fmt.currentText().strip().lower())
+        try:
+            s.sync()
+        except Exception:
+            pass
+
+    # -------------------------
+    # Folder helpers
+    # -------------------------
+    def _browse_folder(self, target_edit: QLineEdit):
+        start = target_edit.text().strip() or os.path.expanduser("~")
+        path = QFileDialog.getExistingDirectory(self, _tr("Select folder"), start)
+        if path:
+            target_edit.setText(path)
+
+    # -------------------------
+    # Active doc resolution (ROI aware)
+    # -------------------------
+    def _get_active_doc(self):
+        mw = self._main
+        mdi = getattr(mw, "mdi", None)
+        dm  = getattr(mw, "doc_manager", None) or getattr(mw, "docman", None)
+
+        if mdi is None or not hasattr(mdi, "activeSubWindow"):
+            return None
+
+        sw = mdi.activeSubWindow()
+        if not sw:
+            return None
+
+        view = sw.widget()
+
+        # Prefer ROI-aware doc lookup via DocManager
+        if dm is not None and hasattr(dm, "get_document_for_view"):
+            try:
+                doc = dm.get_document_for_view(view)
+                if doc is not None:
+                    return doc
+            except Exception:
+                pass
+
+        # Fallback: view.document
+        return getattr(view, "document", None)
+
+    # -------------------------
+    # Routing logic
+    # -------------------------
+    @staticmethod
+    def _pick_target_folder(name: str, master: str, m: str, ngc: str, ic: str, c: str) -> str:
+        raw = (name or "").strip().upper()
+
+        # routing normalization: remove spaces (optionally also "_" and "-" if you want)
+        u = re.sub(r"\s+", "", raw)
+
+        if re.match(r"^M\d+", u):
+            return m or master
+        if re.match(r"^NGC\d+", u):     # optional tighten
+            return ngc or master
+        if re.match(r"^IC\d+", u):      # optional tighten
+            return ic or master
+        if re.match(r"^C\d+", u):
+            return c or master
+        return master
+
+    def _normalize_for_routing(self, name: str) -> str:
+        # Uppercase + remove spaces only (routing only)
+        u = (name or "").strip().upper()
+        u = re.sub(r"\s+", "", u)
+        return u
+
+    def _sanitize_filename(self, s: str) -> str:
+        # Keep it simple + safe across OSes
+        s = (s or "").strip()
+        s = s.replace("\\", "_").replace("/", "_").replace(":", "_")
+        s = re.sub(r"\s+", " ", s)                 # keep single spaces
+        s = re.sub(r"[^\w\-\.\(\) ]+", "", s)      # drop odd chars
+        return s.strip() or "export"
+
+    # -------------------------
+    # Export action
+    # -------------------------
+    def _on_export(self):
+        fmt = self.cmb_fmt.currentText().strip().lower()
+
+        # -------------------------
+        # Name (raw + routing-normalized)
+        # -------------------------
+        raw_name = self.ed_name.text().strip()
+        if not raw_name:
+            QMessageBox.information(
+                self, _tr("Export"),
+                _tr("Please enter an Image Name (e.g. M31, NGC5060…).")
+            )
+            return
+
+        route_name = self._normalize_for_routing(raw_name)
+
+        # -------------------------
+        # Active doc (passed in)
+        # -------------------------
+        doc = self.doc
+        if doc is None or getattr(doc, "image", None) is None:
+            QMessageBox.information(self, _tr("Export"), _tr("No active image. Open an image first."))
+            return
+
+        # -------------------------
+        # Folder config
+        # -------------------------
+        master_dir = self.ed_master.text().strip()
+        if not master_dir:
+            QMessageBox.information(self, _tr("Export"), _tr("Please set a Master Image Folder."))
+            return
+
+        messier_dir  = self.ed_m.text().strip()   or master_dir
+        ngc_dir      = self.ed_ngc.text().strip() or master_dir
+        ic_dir       = self.ed_ic.text().strip()  or master_dir
+        caldwell_dir = self.ed_c.text().strip()   or master_dir
+
+        # -------------------------
+        # Route by prefix (digit-guard)
+        # -------------------------
+        if route_name.startswith("M") and route_name[1:2].isdigit():
+            base_dir = messier_dir
+        elif route_name.startswith("NGC") and route_name[3:4].isdigit():
+            base_dir = ngc_dir
+        elif route_name.startswith("IC") and route_name[2:3].isdigit():
+            base_dir = ic_dir
+        elif route_name.startswith("C") and route_name[1:2].isdigit():
+            base_dir = caldwell_dir
+        else:
+            base_dir = master_dir
+
+        # Ensure folder exists
+        try:
+            Path(base_dir).mkdir(parents=True, exist_ok=True)
+        except Exception as e:
+            QMessageBox.critical(
+                self, _tr("Export"),
+                _tr("Could not create folder:\n{0}\n\n{1}").format(base_dir, str(e))
+            )
+            return
+
+        # Filename uses user's raw name (sanitized for filesystem)
+        file_stem = self._sanitize_filename(raw_name)
+        out_path = str(Path(base_dir) / f"{file_stem}.{fmt}")
+
+        # -------------------------
+        # Save
+        # -------------------------
+        ok, err = self._save_current_doc_to_path(doc, out_path, fmt)
+        if ok:
+            QMessageBox.information(self, _tr("Export"), _tr("Exported:\n{0}").format(out_path))
+        else:
+            QMessageBox.critical(self, _tr("Export"), _tr("Export failed:\n{0}").format(err or "Unknown error"))
+
+
+    def _save_current_doc_to_path(self, doc, out_path: str, fmt: str) -> tuple[bool, str]:
+        try:
+            import numpy as np
+            from astropy.io import fits
+            from astropy.wcs import WCS
+
+            from setiastro.saspro.legacy.image_manager import save_image as legacy_save_image
+
+            img = getattr(doc, "image", None)
+            if img is None:
+                return False, "Active document has no image data."
+
+            # Ensure numpy array
+            img_array = np.asarray(img)
+
+            # Mono detection (your saver uses this for RAW/XISF paths; safe to provide anyway)
+            is_mono = (img_array.ndim == 2) or (img_array.ndim == 3 and img_array.shape[2] == 1)
+
+            # Preserve bit depth for tif/fit if the doc has it; PNG/JPG ignore bit depth anyway.
+            bit_depth = (
+                getattr(doc, "bit_depth", None)
+                or getattr(doc, "bitdepth", None)
+                or (getattr(doc, "metadata", None) or {}).get("bit_depth")
+                or (getattr(doc, "metadata", None) or {}).get("bitDepth")
+            )
+
+            # Pull headers/WCS from metadata (matches your SASv2->SASpro WCS preference)
+            md = getattr(doc, "metadata", None) or {}
+
+            original_header = md.get("original_header", None)
+            wcs_header = None
+
+            # If wcs is stored as astropy.wcs.WCS, convert to Header
+            wcs_obj = md.get("wcs", None)
+            if wcs_obj is not None:
+                try:
+                    if isinstance(wcs_obj, WCS):
+                        wcs_header = wcs_obj.to_header(relax=True)
+                    elif isinstance(wcs_obj, fits.Header):
+                        wcs_header = wcs_obj
+                except Exception:
+                    wcs_header = None
+
+            # Optional passthroughs (safe if missing)
+            image_meta = md.get("image_meta", None) or md.get("image_metadata", None)
+            file_meta  = md.get("file_meta", None)  or md.get("xisf_metadata", None)
+
+            # IMPORTANT:
+            # legacy_save_image expects original_format to be the desired output format,
+            # and will normalize extension itself.
+            legacy_save_image(
+                img_array=img_array,
+                filename=out_path,
+                original_format=fmt,          # "jpg","png","tif","fit"
+                bit_depth=bit_depth,          # keep same depth for tif/fit when possible
+                original_header=original_header,
+                is_mono=is_mono,
+                image_meta=image_meta,
+                file_meta=file_meta,
+                wcs_header=wcs_header,        # merged into FITS header (your saver supports this)
+            )
+            return True, ""
+
+        except Exception as e:
+            return False, f"{type(e).__name__}: {e}"

setiastro/saspro/add_stars.py

@@ -231,7 +231,10 @@ class AddStarsDialog(QDialog):
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
-
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
         self.main = main
         self.starless = None
         self.stars_only = None
@@ -575,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):
@@ -603,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)
@@ -251,9 +291,19 @@ class BackgroundNeutralizationDialog(QDialog):
         self._main = parent
         self.doc = doc
 
-        # Connect to active document change signal
+        self._connected_current_doc_changed = False
         if hasattr(self._main, "currentDocumentChanged"):
-            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+            try:
+                self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+                self._connected_current_doc_changed = True
+            except Exception:
+                self._connected_current_doc_changed = False
+
+        self.finished.connect(self._cleanup_connections)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
 
         if icon:
             self.setWindowIcon(icon)
@@ -316,7 +366,7 @@ class BackgroundNeutralizationDialog(QDialog):
 
         # Events
         self.btn_apply.clicked.connect(self._on_apply)
-        self.btn_cancel.clicked.connect(self.reject)
+        self.btn_cancel.clicked.connect(self.close)
         self.btn_toggle_stretch.clicked.connect(self._toggle_auto_stretch)
         self.btn_find_bg.clicked.connect(self._on_find_background)
         self.btn_zoom_out.clicked.connect(self.zoom_out)
@@ -536,15 +586,33 @@ class BackgroundNeutralizationDialog(QDialog):
         )
         # Dialog stays open so user can apply to other images
         # Refresh to use the now-active document for next operation
-        self.accept()   # or: self.close()
+        self.close()
 
-    def closeEvent(self, e):
+    def closeEvent(self, ev):
+        self._cleanup_connections()
+        super().closeEvent(ev)
+
+    def _cleanup_connections(self):
+        # Disconnect active-doc tracking (Fabio hook)
         try:
-            if hasattr(self._main, "currentDocumentChanged"):
+            if self._connected_current_doc_changed and hasattr(self._main, "currentDocumentChanged"):
                 self._main.currentDocumentChanged.disconnect(self._on_active_doc_changed)
         except Exception:
             pass
-        super().closeEvent(e)
+        self._connected_current_doc_changed = False
+
+        # If you ever add threads/workers later, stop them here too (safe no-ops now)
+        try:
+            if getattr(self, "_worker", None) is not None:
+                try:
+                    self._worker.requestInterruption()
+                except Exception:
+                    pass
+            if getattr(self, "_thread", None) is not None:
+                self._thread.quit()
+                self._thread.wait(500)
+        except Exception:
+            pass
 
 
     def _refresh_document_from_active(self):

setiastro/saspro/blemish_blaster.py

@@ -43,7 +43,10 @@ class _BlemishWorker(QRunnable):
         self.opacity = float(opacity)
         self.channels_to_process = channels_to_process
         self.signals = _BBWorkerSignals()
-
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
     @pyqtSlot()
     def run(self):
         out = self._remove_blemish(