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

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)

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)

setiastro/saspro/curve_editor_pro.py

@@ -521,32 +521,6 @@ class CurveEditor(QGraphicsView):
             if ln is not None:
                 ln.setVisible(False)
 
-    def _scene_to_norm_points(self, pts_scene: list[tuple[float,float]]) -> list[tuple[float,float]]:
-        """(x:[0..360], y:[0..360] down) → (x,y in [0..1] up). Ensures endpoints present & strictly increasing x."""
-        out = []
-        lastx = -1e9
-        for (x, y) in sorted(pts_scene, key=lambda t: t[0]):
-            x = float(np.clip(x, 0.0, 360.0))
-            y = float(np.clip(y, 0.0, 360.0))
-            # strictly increasing X
-            if x <= lastx:
-                x = lastx + 1e-3
-            lastx = x
-            out.append((x / 360.0, 1.0 - (y / 360.0)))
-        # ensure endpoints
-        if not any(abs(px - 0.0)  < 1e-6 for px, _ in out): out.insert(0, (0.0, 0.0))
-        if not any(abs(px - 1.0)  < 1e-6 for px, _ in out): out.append((1.0, 1.0))
-        # clamp
-        return [(float(np.clip(x,0,1)), float(np.clip(y,0,1))) for (x,y) in out]
-
-    def _collect_points_norm_from_editor(self) -> list[tuple[float,float]]:
-        """Take endpoints+handles from editor => normalized points."""
-        pts_scene = []
-        for p in (self.editor.end_points + self.editor.control_points):
-            pos = p.scenePos()
-            pts_scene.append((float(pos.x()), float(pos.y())))
-        return self._scene_to_norm_points(pts_scene)
-
 
     def redistributeHandlesByPivot(self, u: float):
         """
@@ -1022,10 +996,18 @@ class CurvesDialogPro(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
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
+        self.finished.connect(self._cleanup_connections)
         self._preview_img = None     # downsampled float01
         self._full_img = None        # full-res float01
         self._pix = None
@@ -1040,7 +1022,14 @@ class CurvesDialogPro(QDialog):
         self._cdf = None
         self._cdf_bins = 1024
         self._cdf_total = 0
-
+        # Debounce: coalesce rapid curve edits into one rebuild
+        self._curve_debounce_ms = 120  # tweak: 80–200ms feels good
+        self._curve_debounce = QTimer(self)
+        self._curve_debounce.setSingleShot(True)
+        self._curve_debounce.timeout.connect(self._rebuild_preview_from_curve_debounced)
+
+        # Optional: generation counter so stale results can't “win”
+        self._curve_gen = 0
         self._clip_scale = 1.0          # preview→full multiplier
         self._cdf_total_full = 0        # total pixels in full image (H*W)
         self._cdf_total_preview = 0     # total pixels in preview (H*W)
@@ -1212,18 +1201,34 @@ class CurvesDialogPro(QDialog):
 
     def _on_editor_curve_changed(self, _lut8=None):
         """
-        Called on every editor redraw/drag. Persist the currently edited curve
-        into the store, refresh overlays, and do a realtime preview.
+        Called on every editor redraw/drag. Persist points and refresh overlays.
+        Preview rebuild is DEBOUNCED to avoid spamming.
         """
         try:
             self._curves_store[self._current_mode_key] = self._editor_points_norm()
         except Exception:
             pass
-        # show the true shapes of other channels too
+
+        # cheap: overlay redraw is fine every move (or you can debounce this too)
         self._refresh_overlays()
-        # now build from *all* current curves (including the just-edited one)
-        self._quick_preview()
 
+        # expensive: debounce the preview rebuild
+        self._curve_gen += 1
+        self._curve_debounce.start(self._curve_debounce_ms)
+
+    def _rebuild_preview_from_curve_debounced(self):
+        """
+        Runs after the user pauses dragging for _curve_debounce_ms.
+        Only rebuild if we have images loaded.
+        """
+        if self._preview_orig is None and self._preview_img is None:
+            return
+        # If your preview toggle is off, you may want to skip:
+        if not getattr(self, "btn_preview", None) or not self.btn_preview.isChecked():
+            return
+
+        # Do the real work (what you were doing before)
+        self._quick_preview()
 
     def _active_mode_key(self) -> str:
         for b in self.mode_group.buttons():
@@ -1670,29 +1675,53 @@ class CurvesDialogPro(QDialog):
 
     # 1) Put this helper inside CurvesDialogPro (near other helpers)
     def _map_label_xy_to_image_ij(self, x: float, y: float):
-        """Map label-local coords (x,y) to _preview_img pixel (i,j). Returns (ix, iy) or None."""
+        """
+        Map label-local coords (x,y) to _preview_img pixel (ix, iy).
+        Correct even when the pixmap is centered inside a larger label.
+        Returns None if cursor is outside the displayed pixmap area.
+        """
         if self._pix is None:
             return None
+
         pm_disp = self.label.pixmap()
         if pm_disp is None or pm_disp.isNull():
             return None
 
-        src_w = self._pix.width()          # size of the *source* pixmap (preview image)
-        src_h = self._pix.height()
-        disp_w = pm_disp.width()           # size of the *displayed* pixmap on the label
+        # Displayed pixmap size (after zoom)
+        disp_w = pm_disp.width()
         disp_h = pm_disp.height()
-        if src_w <= 0 or src_h <= 0 or disp_w <= 0 or disp_h <= 0:
+
+        # Label may be bigger -> pixmap is centered with margins
+        lbl_w = self.label.width()
+        lbl_h = self.label.height()
+
+        off_x = max(0, (lbl_w - disp_w) // 2)
+        off_y = max(0, (lbl_h - disp_h) // 2)
+
+        # Remove margins: label-local -> pixmap-local
+        px = float(x) - float(off_x)
+        py = float(y) - float(off_y)
+
+        if px < 0 or py < 0 or px >= disp_w or py >= disp_h:
+            return None  # outside actual image area
+
+        # Now convert displayed pixmap pixel -> source preview pixel
+        src_w = self._pix.width()
+        src_h = self._pix.height()
+        if src_w <= 0 or src_h <= 0:
             return None
 
         sx = disp_w / float(src_w)
         sy = disp_h / float(src_h)
 
-        ix = int(x / sx)
-        iy = int(y / sy)
+        ix = int(px / sx)
+        iy = int(py / sy)
+
         if ix < 0 or iy < 0 or ix >= src_w or iy >= src_h:
             return None
         return ix, iy
 
+
     def _scene_to_norm_points(self, pts_scene: list[tuple[float,float]]) -> list[tuple[float,float]]:
         """(x:[0..360], y:[0..360] down) → (x,y in [0..1] up). Ensures endpoints present & strictly increasing x."""
         out = []
@@ -2178,6 +2207,44 @@ class CurvesDialogPro(QDialog):
 
         return (m * out + (1.0 - m) * src).astype(np.float32, copy=False)
 
+    def closeEvent(self, ev):
+        self._cleanup_connections()
+        super().closeEvent(ev)
+
+    def _cleanup_connections(self):
+        # disconnect the "follow active doc" hook
+        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
+
+        # stop/kill any running worker thread(s)
+        try:
+            thr = getattr(self, "_thr", None)
+            if thr is not None:
+                try:
+                    thr.requestInterruption()
+                except Exception:
+                    pass
+                try:
+                    thr.quit()
+                except Exception:
+                    pass
+                try:
+                    thr.wait(250)
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
+        # optional: drop refs that can keep things alive
+        try:
+            self._thr = None
+        except Exception:
+            pass
+
 
     # zoom/pan
     def _apply_zoom(self):