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

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):

setiastro/saspro/doc_manager.py

@@ -310,18 +310,133 @@ class ImageDocument(QObject):
 
     def close(self):
         """
-        Explicit cleanup of swap files.
+        Free all resources held by this document:
+        - delete swap states for undo/redo
+        - clear undo/redo stacks
+        - drop in-memory image array and any in-memory history
+        - clear heavy metadata (headers/WCS)
+        - clear any cached previews/pixmaps
+        - disconnect signals to help break reference cycles
         """
-        sm = get_swap_manager()
-        # Clean up undo stack
-        for swap_id, _, _ in self._undo:
-            sm.delete_state(swap_id)
-        self._undo.clear()
-        
-        # Clean up redo stack
-        for swap_id, _, _ in self._redo:
-            sm.delete_state(swap_id)
-        self._redo.clear()
+        # --- 0) Stop emitting while we tear down (best-effort) --------------
+        try:
+            self.blockSignals(True)
+        except Exception:
+            pass
+
+        # --- 1) Swap cleanup (your existing logic) --------------------------
+        try:
+            sm = get_swap_manager()
+        except Exception:
+            sm = None
+
+        # Undo stack
+        try:
+            for item in list(getattr(self, "_undo", [])):
+                try:
+                    swap_id = item[0]  # (swap_id, ..., ...)
+                except Exception:
+                    swap_id = None
+                if sm is not None and swap_id is not None:
+                    try:
+                        sm.delete_state(swap_id)
+                    except Exception:
+                        pass
+            getattr(self, "_undo", []).clear()
+        except Exception:
+            pass
+
+        # Redo stack
+        try:
+            for item in list(getattr(self, "_redo", [])):
+                try:
+                    swap_id = item[0]
+                except Exception:
+                    swap_id = None
+                if sm is not None and swap_id is not None:
+                    try:
+                        sm.delete_state(swap_id)
+                    except Exception:
+                        pass
+            getattr(self, "_redo", []).clear()
+        except Exception:
+            pass
+
+        # ROI preview stacks if you have them (your code uses _pundo/_predo on ROI docs)
+        for attr in ("_pundo", "_predo"):
+            try:
+                lst = getattr(self, attr, None)
+                if isinstance(lst, list):
+                    # If these also store swap states, delete them too (safe even if not)
+                    if sm is not None:
+                        for item in list(lst):
+                            try:
+                                swap_id = item[0]
+                            except Exception:
+                                swap_id = None
+                            if swap_id is not None:
+                                try:
+                                    sm.delete_state(swap_id)
+                                except Exception:
+                                    pass
+                    lst.clear()
+            except Exception:
+                pass
+
+        # --- 2) Drop the big in-memory image --------------------------------
+        # This is what actually frees the 2–10GB allocations (assuming no other refs).
+        try:
+            self.image = None
+        except Exception:
+            pass
+
+        # --- 3) Clear metadata that can keep large objects alive -------------
+        # fits.Header/WCS objects aren't huge like the image, but they can keep references
+        # and add up; also helps break cycles.
+        try:
+            md = getattr(self, "metadata", None)
+            if isinstance(md, dict):
+                for k in ("wcs", "original_header", "fits_header", "wcs_header", "header"):
+                    md.pop(k, None)
+                # If you keep derived/cached headers anywhere:
+                for k in ("_header_snapshot", "_wcs_snapshot", "roi_wcs_header"):
+                    md.pop(k, None)
+        except Exception:
+            pass
+
+        # --- 4) Clear any preview/pixmap/qimage caches -----------------------
+        # Adjust these attr names to match what your view/doc uses.
+        for attr in ("_qimage_cache", "_pixmap_cache", "_preview_cache", "_render_cache"):
+            try:
+                v = getattr(self, attr, None)
+                if isinstance(v, dict):
+                    v.clear()
+                setattr(self, attr, None)
+            except Exception:
+                pass
+
+        # --- 5) Disconnect signals (helps Qt reference cycles) ---------------
+        # If you connect doc.changed to closures (like ROI docs do), this helps.
+        try:
+            self.changed.disconnect()
+        except Exception:
+            pass
+
+        # If you have other signals, disconnect them similarly:
+        for sig_name in ("imageChanged", "metadataChanged"):
+            try:
+                sig = getattr(self, sig_name, None)
+                if sig is not None:
+                    sig.disconnect()
+            except Exception:
+                pass
+
+        # --- 6) Allow signals again (optional) -------------------------------
+        try:
+            self.blockSignals(False)
+        except Exception:
+            pass
+
 
     def __del__(self):
         # Fallback cleanup if close() wasn't called (though explicit close is better)
@@ -1555,6 +1670,9 @@ def debug_dump_metadata_print(meta: dict, context: str = ""):
 
         print("===== END METADATA DUMP ({}) =====".format(context))
 
+import time
+_DEBUG_DND_DUP = False
+
 class DocManager(QObject):
     documentAdded = pyqtSignal(object)   # ImageDocument
     documentRemoved = pyqtSignal(object) # ImageDocument
@@ -2266,6 +2384,46 @@ class DocManager(QObject):
         if hasattr(doc, "changed"):
             doc.changed.emit()
 
+    def _current_view_title_for_doc(self, source_doc: ImageDocument) -> str | None:
+        """
+        If the active MDI subwindow is showing 'source_doc' (or its parent/base),
+        return the current view's title (windowTitle), otherwise None.
+        """
+        sw = self._active_subwindow()
+        if sw is None:
+            return None
+
+        try:
+            w = sw.widget()
+        except Exception:
+            w = None
+
+        # Resolve what doc the active view corresponds to (base doc)
+        try:
+            base = (
+                getattr(w, "base_document", None)
+                or getattr(w, "_base_document", None)
+                or getattr(w, "document", None)
+                or getattr(sw, "document", None)
+            )
+            parent = getattr(base, "_parent_doc", None)
+            if isinstance(parent, ImageDocument):
+                base = parent
+        except Exception:
+            base = None
+
+        if base is not source_doc:
+            return None
+
+        # Prefer the actual subwindow title (includes [View N], etc.)
+        try:
+            title = sw.windowTitle()
+            title = title.strip() if isinstance(title, str) else ""
+            return title or None
+        except Exception:
+            return None
+
+
     def duplicate_document(self, source_doc: ImageDocument, new_name: str | None = None) -> ImageDocument:
         # DEBUG: log the source doc WCS before we touch anything
         if _DEBUG_WCS:
@@ -2275,19 +2433,33 @@ class DocManager(QObject):
                 name = "<src>"
             
             _debug_log_wcs_context("  source.metadata", getattr(source_doc, "metadata", {}))
-
+        if _DEBUG_DND_DUP:
+            try:
+                src_dn = source_doc.display_name() if hasattr(source_doc, "display_name") else None
+            except Exception:
+                src_dn = None
+            print("\n[DNDDBG:DUPLICATE_DOCUMENT]")
+            print("  source_doc:", source_doc, "id:", id(source_doc), "uid:", getattr(source_doc,"uid",None))
+            print("  source_doc.display_name():", src_dn)
+            print("  new_name arg:", new_name)
         # COPY-ON-WRITE: Share the source image instead of copying immediately.
         # The duplicate's apply_edit will copy when it first modifies the image.
         # This saves memory when duplicates are created but not modified.
         img_ref = source_doc.image  # Shared reference, no copy
 
         meta = dict(source_doc.metadata or {})
-        base = source_doc.display_name()
+
+        # ✅ Use CURRENT VIEW NAME if this doc is what's active; else fall back to doc display_name()
+        base = self._current_view_title_for_doc(source_doc) or source_doc.display_name()
+
         dup_title = (new_name or f"{base}_duplicate")
+
         # 🚫 strip any lingering emojis / link markers
         dup_title = dup_title.replace("🔗", "").strip()
-        meta["display_name"] = dup_title
 
+        meta["display_name"] = dup_title
+        if _DEBUG_DND_DUP:
+            print("  dup_title computed:", dup_title)
         # Remove anything that makes the view look "linked/preview"
         imi = dict(meta.get("image_meta") or {})
         for k in ("readonly", "view_kind", "derived_from", "layer", "layer_index", "linked"):
@@ -2311,7 +2483,13 @@ class DocManager(QObject):
         # Mark this duplicate as sharing image data with source
         dup._cow_source = source_doc
         self._register_doc(dup)
-
+        if _DEBUG_DND_DUP:
+            try:
+                dn = dup.display_name() if hasattr(dup, "display_name") else None
+            except Exception:
+                dn = None
+            print("  dup.metadata.display_name:", (dup.metadata or {}).get("display_name"))
+            print("  dup.display_name():", dn)
         # DEBUG: log the duplicate doc WCS
         if _DEBUG_WCS:
             try:
@@ -2370,7 +2548,58 @@ class DocManager(QObject):
     def create_document(self, image, metadata: dict | None = None, name: str | None = None) -> ImageDocument:
         return self.open_array(image, metadata=metadata, title=name)
 
+    def _drop_all_roi_for_parent(self, parent_doc):
+        dead = [k for k in list(self._roi_doc_cache.keys()) if k[0] == id(parent_doc)]
+        for k in dead:
+            roi_doc = self._roi_doc_cache.pop(k, None)
+            if roi_doc is not None:
+                try:
+                    roi_doc.close()   # you’ll implement doc.close() to release arrays
+                except Exception:
+                    pass
+
+    def _hard_memory_cleanup(self):
+        # 1) Drop Qt pixmap cache (can hold big chunks)
+        try:
+            from PyQt6.QtGui import QPixmapCache
+            QPixmapCache.clear()
+        except Exception:
+            pass
+
+        # 2) Let pending deleteLater() actually execute
+        try:
+            from PyQt6.QtWidgets import QApplication
+            QApplication.processEvents()
+        except Exception:
+            pass
+
+        # 3) Force Python GC to collect cycles (common with Qt signal/closure cycles)
+        try:
+            import gc
+            gc.collect()
+        except Exception:
+            pass
+
+        # 4) Optional: Linux heap trim (only helps on Linux/glibc)
+        try:
+            import sys
+            if sys.platform.startswith("linux"):
+                import ctypes
+                libc = ctypes.CDLL("libc.so.6")
+                libc.malloc_trim(0)
+        except Exception:
+            pass
+
     def close_document(self, doc):
+        # If ROI wrapper, close parent; if parent, purge ROI cache
+        try:
+            parent = getattr(doc, "_parent_doc", None)
+            if parent is not None:
+                doc = parent
+        except Exception:
+            pass
+
+        self._drop_all_roi_for_parent(doc)
         if doc in self._docs:
             self._docs.remove(doc)
             try:
@@ -2387,6 +2616,7 @@ class DocManager(QObject):
                     print(f"[DocManager] Failed to close document {doc}: {e}")
                     
             self.documentRemoved.emit(doc)
+            self._hard_memory_cleanup()
             
     # --- Active-document helpers (NEW) ---------------------------------
     def all_documents(self):