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

setiastro/saspro/blink_comparator_pro.py

@@ -150,45 +150,75 @@ class MetricsPanel(QWidget):
         orig_back = entry.get('orig_background', np.nan)
         return idx, fwhm, ecc, orig_back, star_cnt
 
-
-    def compute_all_metrics(self, loaded_images):
-        """Run SEP over the full list in parallel using threads and cache results."""
+    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.
+        """
         n = len(loaded_images)
         if n == 0:
-            # Clear any previous state and bail
             self._orig_images = []
-            self.metrics_data = [np.array([])]*4
+            self.metrics_data = [np.array([])] * 4
             self.flags = []
-            self._threshold_initialized = [False]*4
-            return
+            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
 
-        # Heads-up dialog (as you already had)
         settings = QSettings()
-        show = settings.value("metrics/showWarning", True, type=bool)
-        if show:
+        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)
+            msg.setStandardButtons(
+                QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+            )
             cb = QCheckBox(self.tr("Don't show again"), msg)
             msg.setCheckBox(cb)
-            if msg.exec() != QMessageBox.StandardButton.Yes:
-                return
+
+            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)
 
-        # pre-allocate result arrays
+        # If show_warning is False, we compute with no prompt.
+
+        # ----------------------------
+        # 2) Allocate result arrays
+        # ----------------------------
         m0 = np.full(n, np.nan, dtype=np.float32)  # FWHM
         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]
 
-        # progress dialog
+        # ----------------------------
+        # 3) Progress dialog
+        # ----------------------------
         prog = QProgressDialog(self.tr("Computing frame metrics…"), self.tr("Cancel"), 0, n, self)
         prog.setWindowModality(Qt.WindowModality.WindowModal)
         prog.setMinimumDuration(0)
@@ -198,32 +228,43 @@ class MetricsPanel(QWidget):
 
         workers = min(os.cpu_count() or 1, 60)
         tasks = [(i, loaded_images[i]) for i in range(n)]
-        done = 0  # <-- FIX: initialize before incrementing
+        done = 0
+        canceled = False
 
         try:
             with ThreadPoolExecutor(max_workers=workers) as exe:
                 futures = {exe.submit(self._compute_one, t): t[0] for t in tasks}
                 for fut in as_completed(futures):
                     if prog.wasCanceled():
+                        canceled = True
                         break
                     try:
                         idx, fwhm, ecc, orig_back, star_cnt = fut.result()
                     except Exception:
-                        # On failure, leave NaNs/sentinels and continue
-                        idx, fwhm, ecc, orig_back, star_cnt = futures[fut], np.nan, np.nan, np.nan, 0
-                    m0[idx], m1[idx], m2[idx], m3[idx] = fwhm, ecc, orig_back, float(star_cnt)
+                        idx = futures.get(fut, 0)
+                        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)
+
                     done += 1
                     prog.setValue(done)
                     QApplication.processEvents()
         finally:
             prog.close()
 
-        # stash results
+        if canceled:
+            # IMPORTANT: leave caches alone; caller will clear/return
+            return False
+
+        # ----------------------------
+        # 4) Stash results
+        # ----------------------------
         self._orig_images = loaded_images
         self.metrics_data = [m0, m1, m2, m3]
         self.flags = flags
-        self._threshold_initialized = [False]*4
-
+        self._threshold_initialized = [False] * 4
+        return True
 
     def plot(self, loaded_images, indices=None):
         """
@@ -242,7 +283,16 @@ class MetricsPanel(QWidget):
 
         # compute & cache on first call or new image list
         if self._orig_images is not loaded_images or self.metrics_data is None:
-            self.compute_all_metrics(loaded_images)
+            ok = self.compute_all_metrics(loaded_images)
+            if not ok or self.metrics_data is None:
+                # user declined/canceled -> clear plots and exit cleanly
+                for pw, scat, line in zip(self.plots, self.scats, self.lines):
+                    scat.setData(x=[], y=[])
+                    line.setPos(0)
+                    pw.getPlotItem().getViewBox().update()
+                    pw.repaint()
+                return
+
 
         # default to all indices
         if indices is None:

setiastro/saspro/clahe.py

@@ -122,7 +122,10 @@ class CLAHEDialogPro(QDialog):
             except Exception as e:
                 import logging
                 logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
-
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
         self.doc = doc
         self.orig = np.clip(np.asarray(doc.image, dtype=np.float32), 0.0, 1.0)
         disp = self.orig

setiastro/saspro/continuum_subtract.py

@@ -105,7 +105,10 @@ class ContinuumSubtractTab(QWidget):
         self.processing_thread = None
         self.original_header = None
         self._clickable_images = {}
-
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
 
     def initUI(self):
         self.spinnerLabel = QLabel("")                # starts empty

setiastro/saspro/convo.py

@@ -151,7 +151,10 @@ class ConvoDeconvoDialog(QDialog):
         # Only follow global active-doc changes if we *weren't* given a doc
         if hasattr(self._main, "currentDocumentChanged") and self._doc_override is None:
             self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
-
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
         self.setWindowTitle(self.tr("Convolution / Deconvolution"))
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
@@ -1115,13 +1118,14 @@ class ConvoDeconvoDialog(QDialog):
         if img is None:
             QMessageBox.warning(self, "No Image", "Please select an image before estimating PSF.")
             return
+
         img_gray = img.mean(axis=2).astype(np.float32) if (img.ndim == 3) else img.astype(np.float32)
 
-        sigma   = self.sep_threshold_slider.value()
-        minarea = self.sep_minarea_spin.value
-        sat     = self.sep_sat_slider.value()
-        maxstars= self.sep_maxstars_spin.value
-        half_w  = self.sep_stamp_spin.value
+        sigma    = float(self.sep_threshold_slider.value())
+        minarea  = int(self.sep_minarea_spin.value())     # ✅
+        sat      = float(self.sep_sat_slider.value())
+        maxstars = int(self.sep_maxstars_spin.value())    # ✅
+        half_w   = int(self.sep_stamp_spin.value())       # ✅
 
         try:
             psf_kernel = estimate_psf_from_image(
@@ -1133,11 +1137,13 @@ class ConvoDeconvoDialog(QDialog):
                 stamp_half_width=half_w
             )
         except RuntimeError as e:
-            QMessageBox.critical(self, "PSF Error", str(e)); return
+            QMessageBox.critical(self, "PSF Error", str(e))
+            return
 
         self._last_stellar_psf = psf_kernel
         self._show_stellar_psf_preview(psf_kernel)
 
+
     def _show_stellar_psf_preview(self, psf_kernel: np.ndarray):
         h, w = psf_kernel.shape
         img8 = ((psf_kernel / max(psf_kernel.max(), 1e-12)) * 255.0).astype(np.uint8)

setiastro/saspro/cosmicclarity.py

@@ -228,21 +228,116 @@ class WaitForFileWorker(QThread):
     fileFound = pyqtSignal(str)
     cancelled = pyqtSignal()
     error     = pyqtSignal(str)
-    def __init__(self, glob_pat: str, timeout_sec=1800, parent=None):
+
+    def __init__(
+        self,
+        glob_pat: str,
+        timeout_sec: int = 1800,
+        parent=None,
+        *,
+        poll_ms: int = 200,
+        stable_polls: int = 6,          # 6 * 200ms = ~1.2s of stability
+        stable_timeout_sec: int = 120,  # extra time after first detection
+    ):
         super().__init__(parent)
         self._glob = glob_pat
-        self._timeout = timeout_sec
+        self._timeout = int(timeout_sec)
+        self._poll_ms = int(poll_ms)
+        self._stable_polls = int(stable_polls)
+        self._stable_timeout = int(stable_timeout_sec)
         self._running = True
+
+    def stop(self):
+        self._running = False
+
+    def _best_candidate(self, paths: list[str]) -> str | None:
+        if not paths:
+            return None
+        # prefer biggest file; tie-break by newest mtime
+        def key(p):
+            try:
+                st = os.stat(p)
+                return (st.st_size, st.st_mtime)
+            except Exception:
+                return (-1, -1)
+        paths.sort(key=key, reverse=True)
+        return paths[0]
+
+    def _is_stable_and_readable(self, path: str) -> bool:
+        """
+        Consider stable when size+mtime unchanged for N polls in a row AND file is readable.
+        Handles slow writers + Windows "file still locked" issues.
+        """
+        stable = 0
+        last = None
+
+        t0 = time.monotonic()
+        while self._running and (time.monotonic() - t0) < self._stable_timeout:
+            try:
+                st = os.stat(path)
+                cur = (st.st_size, st.st_mtime)
+                if st.st_size <= 0:
+                    stable = 0
+                    last = cur
+                elif cur == last:
+                    stable += 1
+                else:
+                    stable = 0
+                    last = cur
+
+                if stable >= self._stable_polls:
+                    # extra “is it readable?” check (important on Windows)
+                    try:
+                        with open(path, "rb") as f:
+                            f.read(64)
+                        return True
+                    except PermissionError:
+                        # still locked by writer, keep waiting
+                        stable = 0
+                    except Exception:
+                        # transient weirdness: keep waiting, don’t declare failure yet
+                        stable = 0
+
+            except FileNotFoundError:
+                stable = 0
+                last = None
+            except Exception:
+                # don't crash the worker for stat weirdness
+                stable = 0
+
+            time.sleep(self._poll_ms / 1000.0)
+
+        return False
+
     def run(self):
-        start = time.time()
-        while self._running and (time.time() - start < self._timeout):
-            m = glob.glob(self._glob)
-            if m:
-                self.fileFound.emit(m[0]); return
-            time.sleep(1)
-        if self._running: self.error.emit("Output file not found within timeout.")
-        else:             self.cancelled.emit()
-    def stop(self): self._running = False
+        t_start = time.monotonic()
+        seen_first_candidate_at = None
+
+        while self._running and (time.monotonic() - t_start) < self._timeout:
+            matches = glob.glob(self._glob)
+            cand = self._best_candidate(matches)
+
+            if cand:
+                if seen_first_candidate_at is None:
+                    seen_first_candidate_at = time.monotonic()
+
+                if self._is_stable_and_readable(cand):
+                    self.fileFound.emit(cand)
+                    return
+
+                # If we've been seeing candidates for a while but none stabilize,
+                # keep looping until global timeout. (This is common on slow disks.)
+
+            time.sleep(self._poll_ms / 1000.0)
+
+        if not self._running:
+            self.cancelled.emit()
+        else:
+            extra = ""
+            if seen_first_candidate_at is not None:
+                extra = " (output appeared but never stabilized)"
+            self.error.emit("Output file not found within timeout." + extra)
+
 
 
 # =============================================================================
@@ -274,6 +369,10 @@ class CosmicClarityDialogPro(QDialog):
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions        
         if icon: 
             try: self.setWindowIcon(icon)
             except Exception as e:
@@ -552,6 +651,12 @@ class CosmicClarityDialogPro(QDialog):
             QMessageBox.critical(self, "Cosmic Clarity", f"Executable not found:\n{exe_path}")
             return
 
+        # ✅ compute base early (we need it for purge + glob)
+        base = self._base_name()
+
+        # ✅ purge any stale outputs for THIS base name (avoids matching old files)
+        _purge_cc_io(self.cosmic_root, clear_input=False, clear_output=True, prefix=base)
+
         # Build args (SASv2 flags mirrored)
         args = []
         if mode == "sharpen":
@@ -595,7 +700,7 @@ class CosmicClarityDialogPro(QDialog):
 
         # Wait for output file
         base = self._base_name()
-        out_glob = os.path.join(self.cosmic_root, "output", f"{base}{suffix}.*")
+        out_glob = os.path.join(self.cosmic_root, "output", f"{base}*{suffix}*.*")
         self._wait = WaitDialog(f"Cosmic Clarity – {mode.title()}", self)
         self._wait.cancelled.connect(self._cancel_all)
         self._wait.show()
@@ -611,19 +716,25 @@ class CosmicClarityDialogPro(QDialog):
 
     def _read_proc_output(self, proc: QProcess, which="main"):
         out = proc.readAllStandardOutput().data().decode("utf-8", errors="replace")
-        if not self._wait: return
+        if not self._wait:
+            return
+
         for line in out.splitlines():
             line = line.strip()
-            if not line: continue
+            if not line:
+                continue
+
             if line.startswith("Progress:"):
                 try:
-                    pct = float(line.split()[1].replace("%",""))
+                    pct = float(line.split()[1].replace("%", ""))
                     self._wait.set_progress(int(pct))
                 except Exception:
                     pass
-            else:
-                self._wait.append_output(line)
-        print(f"[CC] {line}")        
+                continue  # <- skip echo
+
+            # non-progress lines: keep showing + printing
+            self._wait.append_output(line)
+            print(f"[CC] {line}")       
 
     def _on_proc_finished(self, mode, suffix, code, status):
         if code != 0:

setiastro/saspro/crop_dialog_pro.py

@@ -58,7 +58,8 @@ class ResizableRotatableRectItem(QGraphicsRectItem):
         self._rotating = False
         self._angle0 = 0.0
         self._pivot_scene = QPointF()
-
+        self._bounds_scene: QRectF | None = None
+        self._clamp_eps_deg = 0.25  # treat as "unrotated" if |angle| < eps (deg)
         self._grab_pad = 20              # ← extra hit slop in screen px
         self._edge_pad_px = EDGE_GRAB_PX
         self.setZValue(100)             # ← keep above pixmap
@@ -83,7 +84,26 @@ class ResizableRotatableRectItem(QGraphicsRectItem):
         dx = p1.x() - p0.x()
         dy = p1.y() - p0.y()
         return math.hypot(dx, dy)
-
+    def setBoundsSceneRect(self, r: QRectF | None):
+        """Set the scene-rect bounds we should stay within when unrotated."""
+        self._bounds_scene = QRectF(r) if r is not None else None
+
+    def _is_unrotated(self) -> bool:
+        # normalize angle to [-180, 180]
+        a = float(self.rotation()) % 360.0
+        if a > 180.0:
+            a -= 360.0
+        return abs(a) < self._clamp_eps_deg
+
+    def _bounds_local(self) -> QRectF | None:
+        """Bounds rect mapped into the item's local coordinates (only valid when unrotated)."""
+        if self._bounds_scene is None:
+            return None
+        # When unrotated, this is safe and stable.
+        tl = self.mapFromScene(self._bounds_scene.topLeft())
+        br = self.mapFromScene(self._bounds_scene.bottomRight())
+        return QRectF(tl, br).normalized()
+    
     def _edge_under_cursor(self, scene_pos: QPointF) -> Optional[str]:
         """
         Return 'l', 'r', 't', or 'b' if the pointer is near an edge (within px-tolerance),
@@ -218,12 +238,52 @@ class ResizableRotatableRectItem(QGraphicsRectItem):
             QGraphicsItem.GraphicsItemChange.ItemTransformHasChanged,
         ):
             self._sync_handles()
+
+        if change == QGraphicsItem.GraphicsItemChange.ItemPositionChange:
+            if self._bounds_scene is not None and self._is_unrotated():
+                new_pos = QPointF(value)
+
+                # current scene rect of the item (at current pos)
+                sr0 = self.mapRectToScene(self.rect())  # QRectF in scene coords
+
+                # shift it by the delta between proposed pos and current pos
+                d = new_pos - self.pos()
+                sr = sr0.translated(d)
+
+                b = self._bounds_scene
+                dx = 0.0
+                dy = 0.0
+
+                if sr.left() < b.left():
+                    dx = b.left() - sr.left()
+                elif sr.right() > b.right():
+                    dx = b.right() - sr.right()
+
+                if sr.top() < b.top():
+                    dy = b.top() - sr.top()
+                elif sr.bottom() > b.bottom():
+                    dy = b.bottom() - sr.bottom()
+
+                if dx != 0.0 or dy != 0.0:
+                    return new_pos + QPointF(dx, dy)
+
+                return new_pos
+
         return super().itemChange(change, value)
 
     def _resize_via_handle(self, scene_pt: QPointF):
         r = self.rect()
         p = self.mapFromScene(scene_pt)
 
+        # Clamp handle drag to bounds only when unrotated.
+        if self._bounds_scene is not None and self._is_unrotated():
+            bL = self._bounds_local()
+            if bL is not None:
+                # NOTE: bL is in the same local coordinate space as r/p.
+                px = min(max(p.x(), bL.left()),  bL.right())
+                py = min(max(p.y(), bL.top()),   bL.bottom())
+                p = QPointF(px, py)
+
         # Corners
         if   self._active == "tl": r.setTopLeft(p)
         elif self._active == "tr": r.setTopRight(p)
@@ -277,10 +337,19 @@ class CropDialogPro(QDialog):
         self._main = parent
         self.doc = document
 
-        # Connect to active document change signal
+        self._follow_conn = 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._follow_conn = True
+            except Exception:
+                self._follow_conn = False
 
+        self.finished.connect(self._cleanup_connections)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
         self._rect_item: Optional[ResizableRotatableRectItem] = None
         self._pix_item: Optional[QGraphicsPixmapItem] = None
         self._drawing = False
@@ -415,7 +484,7 @@ class CropDialogPro(QDialog):
         self.btn_prev.clicked.connect(self._load_previous)
         self.btn_apply.clicked.connect(self._apply_one)
         self.btn_batch.clicked.connect(self._apply_batch)
-        self.btn_close.clicked.connect(self.accept)
+        self.btn_close.clicked.connect(self.close)
 
         # seed image
         self._load_from_doc()
@@ -607,6 +676,7 @@ class CropDialogPro(QDialog):
                 if e.type() == QEvent.Type.MouseMove and self._drawing:
                     r = QRectF(self._origin, scene_pt).normalized()
                     r = self._apply_ar_to_rect(r, live=True, scene_pt=scene_pt)
+                    r = self._clamp_rect_to_pixmap(r)
                     self._draw_live_rect(r)
 
                     # ⬇️ live dims from the temporary rect (axis-aligned TL,TR,BR,BL)
@@ -618,9 +688,12 @@ class CropDialogPro(QDialog):
                     self._drawing = False
                     r = QRectF(self._origin, scene_pt).normalized()
                     r = self._apply_ar_to_rect(r, live=False, scene_pt=scene_pt)
+                    r = self._clamp_rect_to_pixmap(r)
                     self._clear_live_rect()
+
                     self._rect_item = ResizableRotatableRectItem(r)
                     self._rect_item.setZValue(10)
+                    self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
                     self._rect_item.setFixedAspectRatio(self._current_ar_value())
                     self.scene.addItem(self._rect_item)
 
@@ -706,6 +779,7 @@ class CropDialogPro(QDialog):
         if self._rect_item is None:
             self._rect_item = ResizableRotatableRectItem(r)
             self._rect_item.setZValue(10)
+            self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
             self.scene.addItem(self._rect_item)
         else:
             self._rect_item.setRotation(0.0)
@@ -749,6 +823,32 @@ class CropDialogPro(QDialog):
         if hasattr(self, "_live_rect") and self._live_rect:
             self.scene.removeItem(self._live_rect); self._live_rect = None
 
+    def _pixmap_scene_rect(self) -> QRectF | None:
+        """Scene rect occupied by the pixmap (image) item."""
+        if not self._pix_item:
+            return None
+        return self._pix_item.mapRectToScene(self._pix_item.boundingRect())
+
+    def _clamp_rect_to_pixmap(self, r: QRectF) -> QRectF:
+        """Intersect an axis-aligned QRectF with the pixmap scene rect."""
+        bounds = self._pixmap_scene_rect()
+        if bounds is None:
+            return r.normalized()
+        rr = r.normalized().intersected(bounds)
+        # avoid empty rects (keep at least 1x1 scene unit)
+        if rr.isNull() or rr.width() <= 1e-6 or rr.height() <= 1e-6:
+            # fallback: clamp to a 1x1 rect at the nearest point inside bounds
+            x = min(max(r.center().x(), bounds.left()),  bounds.right())
+            y = min(max(r.center().y(), bounds.top()),   bounds.bottom())
+            rr = QRectF(x, y, 1.0, 1.0)
+        return rr.normalized()
+
+    def _bounds_scene_rect(self) -> QRectF | None:
+        if not self._pix_item:
+            return None
+        return self._pix_item.mapRectToScene(self._pix_item.boundingRect())
+
+
     # ---------- preview toggles ----------
     def _toggle_autostretch(self):
         self._autostretch_on = not self._autostretch_on
@@ -768,6 +868,7 @@ class CropDialogPro(QDialog):
         r, ang, pos = state
         self._rect_item = ResizableRotatableRectItem(r)
         self._rect_item.setZValue(10)
+        self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
         self._rect_item.setFixedAspectRatio(self._current_ar_value())
         self._rect_item.setRotation(ang)
         self._rect_item.setPos(pos)
@@ -785,6 +886,7 @@ class CropDialogPro(QDialog):
         r = QRectF(CropDialogPro._prev_rect)
         self._rect_item = ResizableRotatableRectItem(r)
         self._rect_item.setZValue(10)
+        self._rect_item.setBoundsSceneRect(self._bounds_scene_rect())
         self._rect_item.setFixedAspectRatio(self._current_ar_value())
         self._rect_item.setRotation(CropDialogPro._prev_angle)
         self._rect_item.setPos(CropDialogPro._prev_pos)
@@ -803,6 +905,7 @@ class CropDialogPro(QDialog):
         sx, sy = w_img / pm.width(), h_img / pm.height()
         return np.array([pt_scene.x() * sx, pt_scene.y() * sy], dtype=np.float32)
 
+
     def _apply_one(self):
         if not self._rect_item:
             QMessageBox.warning(self, self.tr("No Selection"), self.tr("Draw & finalize a crop first."))
@@ -865,7 +968,7 @@ class CropDialogPro(QDialog):
             self.doc.apply_edit(out.copy(), metadata={**new_meta, "step_name": "Crop"}, step_name="Crop")
             self._maybe_notify_wcs_update(new_meta)
             self.crop_applied.emit(out)
-            self.accept()
+            self.close()
         except Exception as e:
             QMessageBox.critical(self, self.tr("Apply failed"), str(e))
 
@@ -951,7 +1054,7 @@ class CropDialogPro(QDialog):
         QMessageBox.information(self, self.tr("Batch Crop"), self.tr("Applied crop to all open images. Any Astrometric Solutions has been updated."))
         if last_cropped is not None:
             self.crop_applied.emit(last_cropped)
-        self.accept()
+        self.close()
 
     def _maybe_notify_wcs_update(self, meta: dict, batch_note: str | None = None):
         dbg = (meta or {}).get("__wcs_debug__")
@@ -981,3 +1084,16 @@ class CropDialogPro(QDialog):
         except Exception:
             # Be quiet if formatting fails
             pass
+
+    def _cleanup_connections(self):
+        try:
+            if self._follow_conn and hasattr(self._main, "currentDocumentChanged"):
+                self._main.currentDocumentChanged.disconnect(self._on_active_doc_changed)
+        except Exception:
+            pass
+        self._follow_conn = False
+
+
+    def closeEvent(self, ev):
+        self._cleanup_connections()
+        super().closeEvent(ev)