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

setiastro/saspro/curve_editor_pro.py

@@ -1769,14 +1769,38 @@ class CurvesDialogPro(QDialog):
         name, ok = QInputDialog.getText(self, self.tr("Save Curves Preset"), self.tr("Preset name:"))
         if not ok or not name.strip():
             return
-        pts_norm = self._collect_points_norm_from_editor()
-        mode = self._current_mode()
-        if save_custom_preset(name.strip(), mode, pts_norm):
-            self._set_status(self.tr("Saved preset “{0}”.").format(name.strip()))
+        name = name.strip()
+
+        # 0) flush active editor -> store (CRITICAL)
+        try:
+            self._curves_store[self._current_mode_key] = self._editor_points_norm()
+        except Exception:
+            pass
+
+        # 1) build a full multi-curve payload
+        modes = {}
+        for k, pts in self._curves_store.items():
+            if not isinstance(pts, (list, tuple)) or len(pts) < 2:
+                continue
+            # ensure floats (QSettings/JSON safety)
+            modes[k] = [(float(x), float(y)) for (x, y) in pts]
+
+        preset = {
+            "name": name,
+            "version": 2,
+            "kind": "curves_multi",
+            "active": self._current_mode_key,  # "K", "R", ...
+            "modes": modes,
+        }
+
+        # 2) save via your existing persistence
+        if save_custom_preset(name, preset):   # <-- change signature (see section 3)
+            self._set_status(self.tr("Saved preset “{0}”.").format(name))
             self._rebuild_presets_menu()
         else:
             QMessageBox.warning(self, self.tr("Save failed"), self.tr("Could not save preset."))
 
+
     def _rebuild_presets_menu(self):
         m = QMenu(self)
         # Built-in shapes under K (Brightness)
@@ -2400,43 +2424,69 @@ class CurvesDialogPro(QDialog):
     def _apply_preset_dict(self, preset: dict):
         preset = preset or {}
 
-        # 1) set mode radio
+        # -------- MULTI-CURVE (v2) --------
+        if preset.get("kind") == "curves_multi" or ("modes" in preset and isinstance(preset.get("modes"), dict)):
+            modes = preset.get("modes", {}) or {}
+
+            # 0) load all curves into store (fill missing keys with linear)
+            for k in self._curves_store.keys():
+                pts = modes.get(k)
+                if isinstance(pts, (list, tuple)) and len(pts) >= 2:
+                    self._curves_store[k] = [(float(x), float(y)) for (x, y) in pts]
+                else:
+                    self._curves_store[k] = [(0.0, 0.0), (1.0, 1.0)]
+
+            # 1) choose active key (default to K)
+            active = str(preset.get("active") or "K")
+            if active not in self._curves_store:
+                active = "K"
+            self._current_mode_key = active
+
+            # 2) set radio button that corresponds to active key
+            # map internal key -> radio label
+            key_to_label = {v: k for (k, v) in self._mode_key_map.items()}  # "K"->"K (Brightness)"
+            want_label = key_to_label.get(active, "K (Brightness)")
+            for b in self.mode_group.buttons():
+                if b.text() == want_label:
+                    b.setChecked(True)
+                    break
+
+            # 3) push active curve into editor
+            self._editor_set_from_norm(self._curves_store[active])
+
+            # 4) refresh overlays + preview
+            self._refresh_overlays()
+            self._quick_preview()
+
+            self._set_status(self.tr("Preset: {0}  [multi]").format(preset.get("name", self.tr("(built-in)"))))
+            return
+
+        # -------- LEGACY SINGLE-CURVE --------
+        # your existing single-curve behavior (slightly adjusted: store it too)
         want = _norm_mode(preset.get("mode"))
         for b in self.mode_group.buttons():
             if b.text().lower() == want.lower():
                 b.setChecked(True)
                 break
 
-        # 2) get points_norm — if absent, build from shape/amount (built-ins)
         ptsN = preset.get("points_norm")
-        shape = preset.get("shape")  # may be None for custom presets
+        shape = preset.get("shape")
         amount = float(preset.get("amount", 1.0))
 
         if not (isinstance(ptsN, (list, tuple)) and len(ptsN) >= 2):
             try:
-                # build from a named shape (built-ins); default to linear
                 ptsN = _shape_points_norm(str(shape or "linear"), amount)
             except Exception:
-                ptsN = [(0.0, 0.0), (1.0, 1.0)]  # safe fallback
-
-        # 3) apply handles to the editor (strip exact endpoints)
-        pts_scene = _points_norm_to_scene(ptsN)
-        filt = [(x, y) for (x, y) in pts_scene if 1e-6 < x < 360.0 - 1e-6]
-
-        if hasattr(self.editor, "clearSymmetryLine"):
-            self.editor.clearSymmetryLine()
+                ptsN = [(0.0, 0.0), (1.0, 1.0)]
 
-        self.editor.setControlHandles(filt)
-        self.editor.updateCurve()   # ensure redraw
-
-        # persist into store & refresh
+        self._editor_set_from_norm(ptsN)
         self._curves_store[self._current_mode_key] = self._editor_points_norm()
         self._refresh_overlays()
         self._quick_preview()
 
-        # 4) status: don’t assume shape exists
         shape_tag = f"[{shape}]" if shape else "[custom]"
-        self._set_status(self.tr("Preset: {0}  {1}").format(preset.get('name', self.tr('(built-in)')), shape_tag))
+        self._set_status(self.tr("Preset: {0}  {1}").format(preset.get("name", self.tr("(built-in)")), shape_tag))
+
 
 
 def apply_curves_ops(doc, op: dict):

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

@@ -2276,6 +2276,7 @@ class DocManager(QObject):
         bit_depth: str | None = None,
         *,
         bit_depth_override: str | None = None,
+        jpeg_quality: int | None = None,   # <-- NEW
     ):
         """
         Save the given ImageDocument to 'path'.
@@ -2289,7 +2290,8 @@ class DocManager(QObject):
         ext = _normalize_ext(os.path.splitext(path)[1])
         img = doc.image
         meta = doc.metadata or {}
-
+        if jpeg_quality is not None:
+            meta["jpeg_quality"] = int(jpeg_quality)
         # ── MASSIVE DEBUG: show everything we know coming in ───────────────
         debug_dump_metadata_print(meta, context="save_document: BEFORE HEADER PICK")
 
@@ -2359,6 +2361,7 @@ class DocManager(QObject):
             image_meta=meta.get("image_meta"),
             file_meta=meta.get("file_meta"),
             wcs_header=meta.get("wcs_header"),
+            jpeg_quality=jpeg_quality,
         )
 
         # ── Update metadata in memory to match what we just wrote ─────────