setiastrosuitepro 1.6.1__py3-none-any.whl → 1.6.2__py3-none-any.whl

setiastro/saspro/backgroundneutral.py

@@ -42,12 +42,23 @@ def background_neutralize_rgb(img: np.ndarray, rect_xywh: tuple[int, int, int, i
 
     out = img.copy()
     eps = 1e-8
-    for c in range(3):
-        diff = float(medians[c] - avg_med)
-        denom = 1.0 - diff
-        if abs(denom) < eps:
-            denom = eps if denom >= 0 else -eps
-        out[..., c] = np.clip((out[..., c] - diff) / denom, 0.0, 1.0)
+    
+    # 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)
 
@@ -237,14 +248,21 @@ def apply_background_neutral_to_doc(doc, preset: dict | None = None):
 class BackgroundNeutralizationDialog(QDialog):
     def __init__(self, parent, doc, icon: QIcon | None = None):
         super().__init__(parent)
+        self._main = parent
         self.doc = doc
+
+        # Connect to active document change signal
+        if hasattr(self._main, "currentDocumentChanged"):
+            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
+
         if icon:
             self.setWindowIcon(icon)
         self.setWindowTitle(self.tr("Background Neutralization"))
         self.resize(900, 600)
 
         self.setWindowFlag(Qt.WindowType.Window, True)
-        self.setWindowModality(Qt.WindowModality.ApplicationModal)
+        # Non-modal: allow user to switch between images while dialog is open
+        self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
 
@@ -313,7 +331,14 @@ class BackgroundNeutralizationDialog(QDialog):
 
         self._load_image()
 
-
+    # ---- active document change ------------------------------------
+    def _on_active_doc_changed(self, doc):
+        """Called when user clicks a different image window."""
+        if doc is None or getattr(doc, "image", None) is None:
+            return
+        self.doc = doc
+        self.selection_item = None
+        self._load_image()
 
     # ---------- image display ----------
     def _doc_image_normalized(self) -> np.ndarray:
@@ -509,8 +534,25 @@ class BackgroundNeutralizationDialog(QDialog):
             metadata=meta,
             step_name="Background Neutralization",
         )
-        self.accept()
-
+        # Dialog stays open so user can apply to other images
+        # Refresh to use the now-active document for next operation
+        self._refresh_document_from_active()
+
+    def _refresh_document_from_active(self):
+        """
+        Refresh the dialog's document reference to the currently active document.
+        This allows reusing the same dialog on different images.
+        """
+        try:
+            main = self.parent()
+            if main and hasattr(main, "_active_doc"):
+                new_doc = main._active_doc()
+                if new_doc is not None and new_doc is not self.doc:
+                    self.doc = new_doc
+                    # Refresh the preview image
+                    self._load_preview()
+        except Exception:
+            pass
 
     def _zoom(self, factor: float):
         self._user_zoomed = True

setiastro/saspro/batch_convert.py

@@ -169,6 +169,9 @@ class BatchConvertDialog(QDialog):
     def __init__(self, parent=None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Batch Convert"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.setMinimumWidth(560)
         self.worker: _BatchWorker | None = None
 

setiastro/saspro/batch_renamer.py

@@ -46,6 +46,9 @@ class BatchRenamerDialog(QDialog):
         self.setWindowFlag(Qt.WindowType.WindowTitleHint, True)
         self.setWindowFlag(Qt.WindowType.WindowMinMaxButtonsHint, True)
         self.setWindowFlag(Qt.WindowType.WindowContextHelpButtonHint, False)
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.setSizeGripEnabled(True)
 
         self._build_ui()

setiastro/saspro/blemish_blaster.py

@@ -155,6 +155,9 @@ class BlemishBlasterDialogPro(QDialog):
     def __init__(self, parent, doc):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Blemish Blaster"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.setMinimumSize(900, 650)
 
         self._doc = doc

setiastro/saspro/cheat_sheet.py

@@ -11,6 +11,7 @@ from PyQt6.QtWidgets import (
     QApplication, QMessageBox
 )
 from PyQt6.QtGui import QAction, QShortcut, QKeySequence
+from PyQt6.QtCore import Qt, QCoreApplication
 
 
 def _qs_to_str(seq: QKeySequence) -> str:
@@ -46,37 +47,68 @@ def _seqs_for_action(act: QAction):
 
 def _where_for_action(act: QAction) -> str:
     """Determine where an action is available (Menus/Toolbar or Window)."""
-    if act.parent():
-        pn = act.parent().__class__.__name__
-        if pn.startswith("QMenu") or pn.startswith("QToolBar"):
-            from PyQt6.QtCore import QCoreApplication
-            return QCoreApplication.translate("CheatSheet", "Menus/Toolbar")
+    try:
+        parent = act.parent()
+        if parent is not None:
+            pn = parent.__class__.__name__
+            if pn.startswith("QMenu") or pn.startswith("QToolBar"):
+                return QCoreApplication.translate("CheatSheet", "Menus/Toolbar")
+    except Exception:
+        pass
     return QCoreApplication.translate("CheatSheet", "Window")
 
 
 def _describe_action(act: QAction) -> str:
     """Get a human-readable description for an action."""
-    desc = _clean_text(act.statusTip() or act.toolTip() or act.text() or act.objectName() or "Action")
-    if desc == "Action":
-        from PyQt6.QtCore import QCoreApplication
+    try:
+        desc = _clean_text(
+            act.statusTip() or act.toolTip() or act.text() or act.objectName() or ""
+        )
+    except Exception:
+        desc = ""
+
+    if not desc:
         desc = QCoreApplication.translate("CheatSheet", "Action")
     return desc
 
 
 def _describe_shortcut(sc: QShortcut) -> str:
     """Get a human-readable description for a shortcut."""
-    desc = _clean_text(sc.property("hint") or sc.whatsThis() or sc.objectName() or "Shortcut")
-    if desc == "Shortcut":
-        from PyQt6.QtCore import QCoreApplication
+    try:
+        hint = sc.property("hint")
+        desc = _clean_text(hint or sc.whatsThis() or sc.objectName() or "")
+    except Exception:
+        desc = ""
+
+    if not desc:
         desc = QCoreApplication.translate("CheatSheet", "Shortcut")
     return desc
 
-
+def add_extra_shortcuts(rows):
+    """
+    Add app-level shortcuts that aren't represented by QActions/QShortcuts.
+    rows: list of (shortcut_str, action_str, where_str)
+    """
+    rows.append((
+        _clean_text("Ctrl+K"),
+        _clean_text("Toggle Show/Hide Mask"),
+        QCoreApplication.translate("CheatSheet", "Window"),
+    ))
+    rows.append((
+        _clean_text("Ctrl+Alt+M"),
+        _clean_text("SASpro Neon Invaders (Easter Egg)"),
+        QCoreApplication.translate("CheatSheet", "Window"),
+    ))
+    
 def _where_for_shortcut(sc: QShortcut) -> str:
     """Determine where a shortcut is available."""
-    par = sc.parent()
-    from PyQt6.QtCore import QCoreApplication
-    return par.__class__.__name__ if par is not None else QCoreApplication.translate("CheatSheet", "Window")
+    try:
+        par = sc.parent()
+        if par is not None:
+            return par.__class__.__name__
+    except Exception:
+        pass
+    return QCoreApplication.translate("CheatSheet", "Window")
 
 
 class CheatSheetDialog(QDialog):
@@ -91,6 +123,9 @@ class CheatSheetDialog(QDialog):
     def __init__(self, parent, keyboard_rows, gesture_rows):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Keyboard Shortcut Cheat Sheet"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.resize(780, 520)
         
         self._keyboard_rows = keyboard_rows

setiastro/saspro/clahe.py

@@ -114,6 +114,9 @@ class CLAHEDialogPro(QDialog):
     def __init__(self, parent, doc, icon: QIcon | None = None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("CLAHE"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if icon:
             try: self.setWindowIcon(icon)
             except Exception as e:
@@ -319,11 +322,34 @@ class CLAHEDialogPro(QDialog):
                 pass
             # ─────────────────────────────────────────────────────────────
 
-            self.accept()
+            # Dialog stays open so user can apply to other images
+            # Refresh document reference for next operation
+            self._refresh_document_from_active()
 
         except Exception as e:
             QMessageBox.critical(self, "CLAHE", f"Failed to apply:\n{e}")
 
+    def _refresh_document_from_active(self):
+        """
+        Refresh the dialog's document reference to the currently active document.
+        This allows reusing the same dialog on different images.
+        """
+        try:
+            main = self.parent()
+            if main and hasattr(main, "_active_doc"):
+                new_doc = main._active_doc()
+                if new_doc is not None and new_doc is not self.doc:
+                    self.doc = new_doc
+                    # Refresh original image and preview for new document
+                    self.orig = np.clip(np.asarray(new_doc.image, dtype=np.float32), 0.0, 1.0)
+                    disp = self.orig
+                    if disp.ndim == 2: disp = disp[..., None].repeat(3, axis=2)
+                    elif disp.ndim == 3 and disp.shape[2] == 1: disp = disp.repeat(3, axis=2)
+                    self._disp_base = disp
+                    self._update_preview()
+        except Exception:
+            pass
+
     def _tile_grid_from_px(self, tile_px: int, hw: tuple[int, int]) -> tuple[int, int]:
         """
         Convert desired tile size (pixels) into OpenCV tileGridSize=(n,n)

setiastro/saspro/comet_stacking.py

@@ -90,28 +90,48 @@ def starnet_starless_pair_from_array(
     # -------- normalize & shape: float32 [0..1], keep note if mono ----------
     x = np.asarray(src_rgb01, dtype=np.float32)
     was_mono = (x.ndim == 2) or (x.ndim == 3 and x.shape[2] == 1)
-    if x.ndim == 2:
-        x3 = np.stack([x]*3, axis=-1)
-    elif x.ndim == 3 and x.shape[2] == 1:
-        x3 = np.repeat(x, 3, axis=2)
-    else:
-        x3 = x
-    x3 = np.nan_to_num(x3, nan=0.0, posinf=0.0, neginf=0.0)
-
-    # -------- pre-StarNet stretch (per channel), only if the data are linear ----------
+    
+    # DELAY expansion: work with 'x' (mono or rgb) directly where possible
+    x_input = x
+    if x_input.ndim == 3 and x_input.shape[2] == 1:
+        x_input = x_input[..., 0] # collapse to 2D for processing if needed, or keep 2D
+
+    # For StarNet save, we need 3 channels usually, but check if we can save mono?
+    # Actually StarNet usually expects RGB Tiff. So we might need to expand just for saving.
+    # But let's avoid `x3 = np.repeat` globally.
+    
+    # Optimization: Create x3 ON DEMAND or virtually using broadcasting only when needed.
+    # But `save_image` might handle mono TIFs. If StarNet accepts Mono TIF, we save huge RAM.
+    # Standard StarNet typically wants RGB. We will enable "is_mono" flag in `save_image` if it is mono,
+    # but StarNet is finicky. Let's stick to RGB for StarNet input but avoid `np.repeat` for the WHOLE array 
+    # if we can just broadcast or slice. 
+    # Actually, `stretch_color_image` handles broadcasting? No.
+    # Let's simple optimize:
+    
     if is_linear:
-        # channel-wise stretch to avoid red cast; your funcs expect [0..1]
-        pre = stretch_color_image(x3, 0.25, False, False, False)
-
+         # stretch; if mono use mono stretch
+         if was_mono:
+             if x.ndim == 3: x = x[..., 0]
+             pre = stretch_mono_image(x, 0.25, False, False)
+             # expand ONLY for save
+             pre_to_save = np.dstack([pre, pre, pre])
+         else:
+             pre = stretch_color_image(x, 0.25, False, False, False)
+             pre_to_save = pre
     else:
-        pre = x3  # already non-linear; pass through
+        pre = x # floating point 0..1
+        if was_mono:
+            if pre.ndim == 3: pre = pre[..., 0]
+            pre_to_save = np.dstack([pre, pre, pre])
+        else:
+            pre_to_save = pre
 
     # -------- StarNet I/O (write float->16b TIFF; read back float) ----------
     starnet_dir = os.path.dirname(exe) or os.getcwd()
     in_path  = os.path.join(starnet_dir, "imagetoremovestars.tif")
     out_path = os.path.join(starnet_dir, "starless.tif")
 
-    save_image(pre, in_path, original_format="tif", bit_depth="16-bit",
+    save_image(pre_to_save, in_path, original_format="tif", bit_depth="16-bit",
                    original_header=None, is_mono=False, image_meta=None, file_meta=None)
 
     exe_name = os.path.basename(exe).lower()
@@ -134,32 +154,61 @@ def starnet_starless_pair_from_array(
     except Exception:
         pass
 
-    if starless_pre.ndim == 2:
-        starless_pre = np.stack([starless_pre]*3, axis=-1)
-    elif starless_pre.ndim == 3 and starless_pre.shape[2] == 1:
-        starless_pre = np.repeat(starless_pre, 3, axis=2)
+    # Don't expand starless_pre yet if we don't need to.
     starless_pre = starless_pre.astype(np.float32, copy=False)
-
+    if was_mono and starless_pre.ndim == 3:
+        # StarNet output is usually RGB even for mono input. Convert back to mono?
+        # Or just use one channel.
+        starless_pre = starless_pre[..., 0]
+    
+    # Maintain `pre` as the stretched input (mono or rgb)
+    
     # ---- mask-protect in the SAME (stretched) domain as pre/starless_pre ----
     if core_mask is not None:
         m = np.clip(core_mask.astype(np.float32), 0.0, 1.0)
-        m3 = np.repeat(m[..., None], 3, axis=2)
-        protected_stretched = starless_pre * (1.0 - m3) + pre * m3
+        # broadcast mask
+        if not was_mono:
+             if m.ndim == 2: m = m[..., None]
+        
+        protected_stretched = starless_pre * (1.0 - m) + pre * m
     else:
         protected_stretched = starless_pre
+    
+    # Return to 3-channel ONLY if requested by the caller's context? 
+    # The signature `starnet_starless_pair_from_array` implies it might return what it got.
+    # The original returned `protected_unstretch`.
+    pass # logic flow continues below...
 
     # -------- “unstretch” → shared pseudo-linear space (once, after blend) ----------
     if is_linear:
-        protected_unstretch = stretch_color_image(
-            protected_stretched, 0.05, False, False, False
-        )
+        # choose stretcher based on channels
+        if was_mono:
+             # ensure 2d
+             if protected_stretched.ndim == 3 and protected_stretched.shape[2] == 1:
+                 protected_stretched = protected_stretched[..., 0]
+             elif protected_stretched.ndim == 3:
+                 # collapse rgb to mono if needed? likely StarNet gave RGB.
+                 # Keep RGB if StarNet created color artifacts we want to keep? 
+                 # Usually for mono data we want to kill color.
+                 protected_stretched = protected_stretched.mean(axis=2)
+             
+             protected_unstretch = stretch_mono_image(
+                protected_stretched, 0.05, False, False
+             )
+             # Expand finally for return constraint? 
+             # The older function returned RGB-like. 
+             # Let's expand here at the VERY END.
+             protected_unstretch = np.dstack([protected_unstretch]*3)
+        else:
+             protected_unstretch = stretch_color_image(
+                protected_stretched, 0.05, False, False, False
+             )
     else:
         protected_unstretch = protected_stretched
+        if was_mono and protected_unstretch.ndim == 2:
+            protected_unstretch = np.dstack([protected_unstretch]*3)
 
-    protected_unstretch = np.clip(
-        protected_unstretch.astype(np.float32, copy=False), 0.0, 1.0
-    )
-    return protected_unstretch, protected_unstretch
+    return np.clip(protected_unstretch, 0.0, 1.0), np.clip(protected_unstretch, 0.0, 1.0)
 
 
 
@@ -170,8 +219,17 @@ def darkstar_starless_from_array(src_rgb01: np.ndarray, settings, **_ignored) ->
     """
     # normalize channels
     img = src_rgb01.astype(np.float32, copy=False)
-    if img.ndim == 2: img = np.stack([img]*3, axis=-1)
-    if img.ndim == 3 and img.shape[2] == 1: img = np.repeat(img, 3, axis=2)
+    # 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})())
@@ -192,7 +250,8 @@ def darkstar_starless_from_array(src_rgb01: np.ndarray, settings, **_ignored) ->
     out_path = os.path.join(output_dir, "imagetoremovestars_starless.tif")
 
     # save input as float32 TIFF
-    save_image(img, in_path, original_format="tif", bit_depth="32-bit floating point",
+    # 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
@@ -218,8 +277,12 @@ def darkstar_starless_from_array(src_rgb01: np.ndarray, settings, **_ignored) ->
     if starless is None:
         raise RuntimeError("DarkStar produced no output.")
 
-    if starless.ndim == 2: starless = np.stack([starless]*3, axis=-1)
-    if starless.shape[2] == 1: starless = np.repeat(starless, 3, axis=2)
+    # 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)
+        
     return np.clip(starless.astype(np.float32, copy=False), 0.0, 1.0)
 
 # ---------- small helpers ----------
@@ -239,6 +302,10 @@ def _inv_affine_2x3(M: np.ndarray) -> np.ndarray:
 def _to_luma(img: np.ndarray) -> np.ndarray:
     if img.ndim == 2: return img.astype(np.float32, copy=False)
     if img.ndim == 3 and img.shape[-1] == 3:
+        try:
+            return cv2.cvtColor(img, cv2.COLOR_RGB2GRAY).astype(np.float32, copy=False)
+        except Exception:
+            pass
         r,g,b = img[...,0], img[...,1], img[...,2]
         return (0.2126*r + 0.7152*g + 0.0722*b).astype(np.float32, copy=False)
     if img.ndim == 3 and img.shape[-1] == 1:
@@ -748,11 +815,9 @@ def _shift_to_comet(img: np.ndarray, xy: Tuple[float,float], ref_xy: Tuple[float
     M = np.array([[1.0, 0.0, dx], [0.0, 1.0, dy]], dtype=np.float32)
     H, W = img.shape[:2]
     interp = cv2.INTER_LANCZOS4
-    if img.ndim == 2:
-        return cv2.warpAffine(img, M, (W, H), flags=interp, borderMode=cv2.BORDER_REFLECT)
-    # 3-channel
-    ch = [cv2.warpAffine(img[...,c], M, (W, H), flags=interp, borderMode=cv2.BORDER_REFLECT) for c in range(img.shape[-1])]
-    return np.stack(ch, axis=-1)
+    
+    # Vectorized warp for both 2D (mono) and 3D (RGB)
+    return cv2.warpAffine(img, M, (W, H), flags=interp, borderMode=cv2.BORDER_REFLECT)
 
 def stack_comet_aligned(file_list: List[str],
                         comet_xy: Dict[str, Tuple[float,float]],

setiastro/saspro/convo.py

@@ -153,6 +153,9 @@ class ConvoDeconvoDialog(QDialog):
             self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
 
         self.setWindowTitle(self.tr("Convolution / Deconvolution"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.resize(1000, 650)
         self._use_custom_psf = False
         self._custom_psf: Optional[np.ndarray] = None

setiastro/saspro/copyastro.py

@@ -15,6 +15,9 @@ class CopyAstrometryDialog(QDialog):
     def __init__(self, parent=None, target=None):
         super().__init__(parent)
         self.setWindowTitle("Copy Astrometric Solution")
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.setMinimumWidth(420)
 
         self._mw = parent

setiastro/saspro/cosmicclarity.py

@@ -271,6 +271,9 @@ class CosmicClarityDialogPro(QDialog):
             QTimer.singleShot(0, self.reject)
             return        
         self.setWindowTitle(self.tr("Cosmic Clarity"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if icon: 
             try: self.setWindowIcon(icon)
             except Exception as e:
@@ -632,7 +635,53 @@ class CosmicClarityDialogPro(QDialog):
         if self._wait: self._wait.close(); self._wait = None
         if self._wait_thread: self._wait_thread.stop(); self._wait_thread = None
 
-        # Load processed image we just got
+        has_more = bool(self._op_queue)
+        
+        # --- Optimization: Chained Execution Fast Path ---
+        # If we have more steps, skip the expensive load/display/save cycle.
+        # Just move the output file to be the input for the next step.
+        if has_more:
+            if not out_path or not os.path.exists(out_path):
+                QMessageBox.critical(self, "Cosmic Clarity", "Output file missing during chain execution.")
+                self._op_queue.clear()
+                return
+
+            base     = self._base_name()
+            next_in  = os.path.join(self.cosmic_root, "input", f"{base}.tif")
+            prev_in  = getattr(self, "_current_input", None)
+
+            try:
+                # Direct move/copy instead of decode+encode
+                if os.path.abspath(out_path) != os.path.abspath(next_in):
+                    # Windows cannot atomic replace if target exists via os.rename usually,
+                    # but shutil.move is generally robust. 
+                    # We remove target first to be sure.
+                    if os.path.exists(next_in):
+                        os.remove(next_in)
+                    shutil.move(out_path, next_in)
+                
+                # Ensure stability of the *new* input
+                if not _wait_stable_file(next_in):
+                     QMessageBox.critical(self, "Cosmic Clarity", "Staged input for next step is unstable.")
+                     self._op_queue.clear()
+                     return
+
+                self._current_input = next_in
+
+                # Cleanup previous input if distinct
+                if prev_in and prev_in != next_in and os.path.exists(prev_in):
+                    os.remove(prev_in)
+
+            except Exception as e:
+                QMessageBox.critical(self, "Cosmic Clarity", f"Failed to stage next step:\n{e}")
+                self._op_queue.clear()
+                return
+
+            # Trigger next step immediately
+            QTimer.singleShot(50, self._run_next)
+            return
+
+        # --- Final Step (or Single Step): Load and Display ---
         try:
             img, hdr, bd, mono = load_image(out_path)
             if img is None:
@@ -643,61 +692,34 @@ class CosmicClarityDialogPro(QDialog):
 
         dest = img.astype(np.float32, copy=False)
 
-        # Apply to document (so the user sees the step result immediately)
+        # Apply to document
         step_title = f"Cosmic Clarity – {mode.title()}"
         create_new = (self.cmb_target.currentIndex() == 1)
 
         if create_new:
             ok = self._spawn_new_doc_from_numpy(dest, step_title)
             if not ok:
-                # fall back to overwriting if we couldn’t spawn a new doc
                 self._apply_to_active(dest, step_title)
         else:
             self._apply_to_active(dest, step_title)
 
-        # Will we run another step (i.e., we're in "Both")?
-        has_more = bool(self._op_queue)
-        base     = self._base_name()
-        next_in  = os.path.join(self.cosmic_root, "input", f"{base}.tif")
-        prev_in  = getattr(self, "_current_input", None)
-
+        # Cleanup final output
+        if out_path and os.path.exists(out_path):
+            try: os.remove(out_path)
+            except OSError: pass
+        
+        # Cleanup final input
+        prev_in = getattr(self, "_current_input", None)
+        if prev_in and os.path.exists(prev_in):
+            try: os.remove(prev_in)
+            except OSError: pass
+
+        # Final purge
         try:
-            if has_more:
-                def _writer(tmp_path, arr=dest):
-                    save_image(arr, tmp_path, "tiff", "32-bit floating point",
-                            getattr(self.doc, "original_header", None),
-                            getattr(self.doc, "is_mono", False))
-                _atomic_fsync_replace(_writer, next_in)
-                if not _wait_stable_file(next_in):
-                    QMessageBox.critical(self, "Cosmic Clarity", "Staging for next step failed (not stable).")
-                    self._op_queue.clear()
-                    return
-                self._current_input = next_in
-
-            # Now it’s safe to clean up the produced output
-            if out_path and os.path.exists(out_path):
-                os.remove(out_path)
-
-            # Remove the previous input file if it’s different from the new one
-            if prev_in and prev_in != next_in and os.path.exists(prev_in):
-                os.remove(prev_in)
-
-        except Exception as e:
-            QMessageBox.critical(self, "Cosmic Clarity", f"Failed while staging next step:\n{e}")
-            self._op_queue.clear()
-            return
-
-        # Continue or finish
-        if has_more:
-            QTimer.singleShot(100, self._run_next)
-        else:
-            # Nothing else queued — we're done
-            try:
-                # 🔸 Final cleanup: clear both input & output
-                _purge_cc_io(self.cosmic_root, clear_input=True, clear_output=True)
-            except Exception:
-                pass
-            self.accept()
+            _purge_cc_io(self.cosmic_root, clear_input=True, clear_output=True)
+        except Exception:
+            pass
+        self.accept()
 
 
     def _on_wait_error(self, msg: str):
@@ -1009,6 +1031,9 @@ class CosmicClaritySatelliteDialogPro(QDialog):
     def __init__(self, parent, doc=None, icon: QIcon | None = None):
         super().__init__(parent)
         self.setWindowTitle("Cosmic Clarity – Satellite Removal")
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if icon:
             try: self.setWindowIcon(icon)
             except Exception as e: