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

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)
+
 
 
 # =============================================================================
@@ -556,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":
@@ -599,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()
@@ -615,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)
@@ -616,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)
@@ -627,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)
 
@@ -715,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)
@@ -758,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
@@ -777,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)
@@ -794,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)
@@ -812,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."))

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):
         """
@@ -1048,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)
@@ -1220,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():
@@ -1678,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 = []
@@ -1748,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)
@@ -2379,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]
+                ptsN = [(0.0, 0.0), (1.0, 1.0)]
 
-        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):