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

setiastro/saspro/curves_preset.py

@@ -12,18 +12,96 @@ except Exception:
     _HAS_PCHIP = False
 
 
-
 # ---------------------- preset schema ----------------------
+# Legacy (v1 single-curve) preset:
 # {
+#   "name": "MyPreset",
 #   "mode": "K (Brightness)" | "R" | "G" | "B" | "L*" | "a*" | "b*" | "Chroma" | "Saturation" | aliases ("rgb","k","lum"…),
-#   "shape": "linear" | "s_mild" | "s_med" | "s_strong" | "lift_shadows" | "crush_shadows"
-#            | "fade_blacks" | "rolloff_highlights" | "flatten" | "custom",
-#   "amount": 0..1  (intensity, ignored for custom),
-#   "points_norm": [[x,y], ...]  # optional when shape="custom" (normalized 0..1 domain/range)
+#   "shape": "linear" | "s_mild" | ... | "custom",
+#   "amount": 0..1,
+#   "points_norm": [[x,y], ...]  # normalized 0..1 domain/range
 # }
 #
-# Default if missing: mode="K (Brightness)", shape="linear", amount=0.5
+# New (v2 multi-curve) preset:
+# {
+#   "name": "MyPreset",
+#   "kind": "curves_multi",
+#   "version": 2,
+#   "active": "K" | "R" | "G" | "B" | "L*" | "a*" | "b*" | "Chroma" | "Saturation",
+#   "modes": {
+#       "K": [[x,y], ...],
+#       "R": [[x,y], ...],
+#       ...
+#   }
+# }
+
+_MODE_KEY_TO_LABEL = {
+    "K": "K (Brightness)",
+    "R": "R",
+    "G": "G",
+    "B": "B",
+    "L*": "L*",
+    "a*": "a*",
+    "b*": "b*",
+    "Chroma": "Chroma",
+    "Saturation": "Saturation",
+}
 
+
+_LABEL_TO_MODE_KEY = {v: k for k, v in _MODE_KEY_TO_LABEL.items()}
+
+_APPLY_ORDER_KEYS = ["K", "R", "G", "B", "L*", "a*", "b*", "Chroma", "Saturation"]
+
+def _is_linear_points_norm(pts) -> bool:
+    try:
+        return (
+            isinstance(pts, (list, tuple)) and len(pts) == 2
+            and tuple(pts[0]) == (0.0, 0.0)
+            and tuple(pts[1]) == (1.0, 1.0)
+        )
+    except Exception:
+        return False
+    
+def _coerce_points_norm(raw) -> List[Tuple[float, float]] | None:
+    if not isinstance(raw, (list, tuple)) or len(raw) < 2:
+        return None
+    out: List[Tuple[float, float]] = []
+    for e in raw:
+        if isinstance(e, (list, tuple)) and len(e) >= 2:
+            x, y = e[0], e[1]
+        elif isinstance(e, dict):
+            x, y = e.get("x"), e.get("y")
+        else:
+            continue
+        if x is None or y is None:
+            continue
+        out.append((float(x), float(y)))
+    return out if len(out) >= 2 else None
+
+def _coerce_modes_dict(raw) -> Dict[str, List[Tuple[float, float]]]:
+    """
+    Return {mode_key: points_norm}, filtering junk but keeping backward-compat.
+    Accepts keys as internal mode keys ("K") or labels ("K (Brightness)").
+    """
+    modes: Dict[str, List[Tuple[float, float]]] = {}
+    if not isinstance(raw, dict):
+        return modes
+
+    for k, v in raw.items():
+        key = str(k)
+        # allow labels or keys
+        if key in _MODE_KEY_TO_LABEL:
+            mode_key = key
+        else:
+            mode_label = _norm_mode(key)  # converts aliases -> proper label
+            mode_key = _LABEL_TO_MODE_KEY.get(mode_label, "K")
+
+        pts = _coerce_points_norm(v)
+        if pts is None:
+            continue
+        modes[mode_key] = pts
+
+    return modes
 # ---------------------- shape library (normalized) ----------------------
 def _shape_points_norm(shape: str, amount: float) -> List[Tuple[float, float]]:
     a = float(max(0.0, min(1.0, amount)))
@@ -141,32 +219,38 @@ def _unwrap_preset_dict(preset: Dict) -> Dict:
     """
     Accept a variety of containers and peel down to the actual curve data.
 
-    Examples we handle:
-      {"step_name":"Curves","mode":..., "preset":{...}}
-      {"curves": {...}}
-      {"state": {...}}   # if state contains curve points
+    Handles:
+      - {"preset": {...}}
+      - {"curves": {...}}
+      - {"state": {...}}
+      - multi presets with {"modes": {...}}
     """
     p = dict(preset or {})
 
-    # Case 1: full metadata from doc.apply_edit: {"step_name":"Curves", "mode":..., "preset": {...}}
+    def _looks_like_curve_dict(d: dict) -> bool:
+        return (
+            isinstance(d, dict)
+            and (
+                "points_norm" in d
+                or "handles" in d
+                or "points_scene" in d
+                or "scene_points" in d
+                or "modes" in d  # <-- multi
+            )
+        )
+
     inner = p.get("preset")
-    if isinstance(inner, dict) and ("points_norm" in inner or "handles" in inner
-                                    or "points_scene" in inner or "scene_points" in inner):
+    if _looks_like_curve_dict(inner):
         return inner
 
-    # Case 2: payloads like {"curves": {...}}
     inner = p.get("curves")
-    if isinstance(inner, dict) and ("points_norm" in inner or "handles" in inner
-                                    or "points_scene" in inner or "scene_points" in inner):
+    if _looks_like_curve_dict(inner):
         return inner
 
-    # Case 3: {"state": {...}} (if you stored the curve state under that key)
     inner = p.get("state")
-    if isinstance(inner, dict) and ("points_norm" in inner or "handles" in inner
-                                    or "points_scene" in inner or "scene_points" in inner):
+    if _looks_like_curve_dict(inner):
         return inner
 
-    # Otherwise assume p already *is* the preset
     return p
 
 
@@ -179,7 +263,9 @@ def _settings() -> QSettings | None:
         return None
 
 def list_custom_presets() -> list[dict]:
-    """Return a list of dicts: {"name", "mode", "shape":"custom", "points_norm":[[x,y],...]}"""
+    """
+    Returns a list of preset dicts (v1 single-curve or v2 multi-curve).
+    """
     s = _settings()
     if not s:
         return []
@@ -187,29 +273,82 @@ def list_custom_presets() -> list[dict]:
     try:
         lst = json.loads(raw)
         if isinstance(lst, list):
-            return [p for p in lst if isinstance(p, dict)]
+            out = [p for p in lst if isinstance(p, dict)]
+            # normalize missing name fields (defensive)
+            for p in out:
+                if "name" not in p:
+                    p["name"] = "(unnamed)"
+            return out
     except Exception:
         pass
     return []
 
-def save_custom_preset(name: str, mode: str, points_norm: list[tuple[float,float]]) -> bool:
-    """Create/overwrite by name."""
+def save_custom_preset(name: str, mode_or_preset, points_norm: list[tuple[float, float]] | None = None) -> bool:
+    """
+    Save a custom preset. Supports:
+      - legacy: save_custom_preset(name, mode, points_norm)
+      - new:    save_custom_preset(name, preset_dict)
+    """
     s = _settings()
     if not s:
         return False
+
     name = (name or "").strip()
     if not name:
         return False
-    preset = {
-        "name": name,
-        "mode": _norm_mode(mode),
-        "shape": "custom",
-        "amount": 1.0,
-        "points_norm": [(float(x), float(y)) for (x, y) in points_norm],
-    }
+
+    # --- build preset dict ---
+    preset: dict
+
+    if isinstance(mode_or_preset, dict):
+        # v2 (or v1 dict passed directly)
+        preset = dict(mode_or_preset)
+        preset["name"] = name  # enforce
+
+        # If it's a multi preset, sanitize modes
+        if preset.get("kind") == "curves_multi" or isinstance(preset.get("modes"), dict):
+            modes = _coerce_modes_dict(preset.get("modes", {}))
+            # fill missing keys with linear so UI always has a full set
+            full_modes = {}
+            for k in _MODE_KEY_TO_LABEL.keys():
+                full_modes[k] = modes.get(k, [(0.0, 0.0), (1.0, 1.0)])
+            preset = {
+                "name": name,
+                "kind": "curves_multi",
+                "version": 2,
+                "active": str(preset.get("active") or "K"),
+                "modes": {k: [(float(x), float(y)) for (x, y) in v] for k, v in full_modes.items()},
+            }
+
+        else:
+            # treat as v1 single-curve dict
+            mode_label = _norm_mode(preset.get("mode"))
+            pts = _coerce_points_norm(preset.get("points_norm")) or [(0.0, 0.0), (1.0, 1.0)]
+            preset = {
+                "name": name,
+                "mode": mode_label,
+                "shape": str(preset.get("shape", "custom")),
+                "amount": float(preset.get("amount", 1.0)),
+                "points_norm": [(float(x), float(y)) for (x, y) in pts],
+            }
+
+    else:
+        # legacy signature
+        mode = _norm_mode(str(mode_or_preset))
+        pts = points_norm or [(0.0, 0.0), (1.0, 1.0)]
+        preset = {
+            "name": name,
+            "mode": mode,
+            "shape": "custom",
+            "amount": 1.0,
+            "points_norm": [(float(x), float(y)) for (x, y) in pts],
+        }
+
+    # --- upsert by name (case-insensitive) ---
     lst = list_custom_presets()
-    lst = [p for p in lst if (p.get("name","").lower() != name.lower())]
+    lst = [p for p in lst if (p.get("name", "").lower() != name.lower())]
     lst.append(preset)
+
     s.setValue(_SETTINGS_KEY, json.dumps(lst))
     s.sync()
     return True
@@ -218,8 +357,11 @@ def delete_custom_preset(name: str) -> bool:
     s = _settings()
     if not s:
         return False
+    nm = (name or "").strip().lower()
+    if not nm:
+        return False
     lst = list_custom_presets()
-    lst = [p for p in lst if (p.get("name","").lower() != (name or "").strip().lower())]
+    lst = [p for p in lst if (p.get("name", "").strip().lower() != nm)]
     s.setValue(_SETTINGS_KEY, json.dumps(lst))
     s.sync()
     return True
@@ -228,7 +370,7 @@ def delete_custom_preset(name: str) -> bool:
 # ---------------------- headless apply ----------------------
 def apply_curves_via_preset(main_window, doc, preset: Dict):
     import numpy as _np
-    from setiastro.saspro.curves_preset import _lut_from_preset, _unwrap_preset_dict  # self
+    from setiastro.saspro.curves_preset import _unwrap_preset_dict  # self
     # lazy import to avoid cycle
     from setiastro.saspro.curve_editor_pro import _apply_mode_any
 
@@ -236,8 +378,7 @@ def apply_curves_via_preset(main_window, doc, preset: Dict):
     if img is None:
         return
 
-    # Accept full last-action dicts and unwrap down to the actual curve definition
-    core_preset = _unwrap_preset_dict(preset or {})
+    core = _unwrap_preset_dict(preset or {})
 
     arr = _np.asarray(img)
     if arr.dtype.kind in "ui":
@@ -248,18 +389,52 @@ def apply_curves_via_preset(main_window, doc, preset: Dict):
     else:
         arr01 = arr.astype(_np.float32)
 
-    lut01, mode = _lut_from_preset(core_preset)
+    # -------- MULTI --------
+    if core.get("kind") == "curves_multi" or isinstance(core.get("modes"), dict):
+        modes = _coerce_modes_dict(core.get("modes", {}))
+
+        out01 = arr01
+        used_any = False
+
+        for mode_key in _APPLY_ORDER_KEYS:
+            pts = modes.get(mode_key)
+            if not pts:
+                continue
+            if _is_linear_points_norm(pts):
+                continue
+
+            pts_scene = _points_norm_to_scene(pts)
+            fn = _interpolator_from_scene_points(pts_scene)
+            lut01 = build_curve_lut(fn, size=65536)
+
+            mode_label = _MODE_KEY_TO_LABEL.get(mode_key, "K (Brightness)")
+            out01 = _apply_mode_any(out01, mode_label, lut01)
+            used_any = True
+
+        if not used_any:
+            return
+
+        meta = {
+            "step_name": "Curves",
+            "mode": _MODE_KEY_TO_LABEL.get(str(core.get("active") or "K"), "K (Brightness)"),
+            "preset": dict(core),
+        }
+        doc.apply_edit(out01, metadata=meta, step_name="Curves")
+        return
+
+    # -------- LEGACY SINGLE --------
+    lut01, mode = _lut_from_preset(core)
     out01 = _apply_mode_any(arr01, mode, lut01)
 
     meta = {
         "step_name": "Curves",
         "mode": mode,
-        "preset": dict(core_preset),  # store the normalized core preset
+        "preset": dict(core),
     }
     doc.apply_edit(out01, metadata=meta, step_name="Curves")
 
 
-# ---------------------- open UI with preset ----------------------
+
 # ---------------------- open UI with preset ----------------------
 def open_curves_with_preset(main_window, preset: Dict | None = None):
     # lazy import UI to avoid cycle
@@ -274,20 +449,47 @@ def open_curves_with_preset(main_window, preset: Dict | None = None):
 
     dlg = CurvesDialogPro(main_window, doc)
 
-    # Peel down any wrapper (metadata / last-action container) to the actual curve definition
-    core_preset = _unwrap_preset_dict(preset or {})
+    core = _unwrap_preset_dict(preset or {})
+
+    # -------- MULTI --------
+    if core.get("kind") == "curves_multi" or isinstance(core.get("modes"), dict):
+        modes = _coerce_modes_dict(core.get("modes", {}))
+
+        # Fill dialog store for every key
+        for k in getattr(dlg, "_curves_store", {}).keys():
+            dlg._curves_store[k] = modes.get(k, [(0.0, 0.0), (1.0, 1.0)])
+
+        # Choose active key
+        active_key = str(core.get("active") or "K")
+        if active_key not in dlg._curves_store:
+            active_key = "K"
+        dlg._current_mode_key = active_key
+
+        # Set the radio to match active
+        want_label = _MODE_KEY_TO_LABEL.get(active_key, "K (Brightness)")
+        for b in dlg.mode_group.buttons():
+            if b.text().lower() == want_label.lower():
+                b.setChecked(True)
+                break
+
+        # Push active curve into editor
+        dlg._editor_set_from_norm(dlg._curves_store.get(active_key, [(0.0, 0.0), (1.0, 1.0)]))
+        dlg._refresh_overlays()
+        dlg._quick_preview()
+
+        dlg.show()
+        dlg.raise_()
+        dlg.activateWindow()
+        return
 
-    # set mode radio from the *core* preset
-    want = _norm_mode(core_preset.get("mode"))
+    # -------- LEGACY SINGLE --------
+    want = _norm_mode(core.get("mode"))
     for b in dlg.mode_group.buttons():
         if b.text().lower() == want.lower():
             b.setChecked(True)
             break
 
-    # Seed control handles from the same logic used by LUT building
-    pts_scene = _scene_points_from_preset(core_preset)
-
-    # remove exact endpoints if present; editor expects control handles only
+    pts_scene = _scene_points_from_preset(core)
     filt = [(x, y) for (x, y) in pts_scene if x > 0.0 + 1e-6 and x < 360.0 - 1e-6]
     dlg.editor.setControlHandles(filt)
 

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)
@@ -2433,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:
@@ -2450,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):