setiastrosuitepro 1.6.4__py3-none-any.whl → 1.7.1.post2__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 = []
@@ -1740,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)
@@ -2178,6 +2231,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):
@@ -2333,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
+                ptsN = [(0.0, 0.0), (1.0, 1.0)]
 
-        # 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()
-
-        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):