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

setiastro/saspro/remove_stars_preset.py

@@ -12,7 +12,7 @@ from setiastro.saspro.legacy.image_manager import save_image, load_image
 # Reuse helpers & plumbing from the interactive module
 from .remove_stars import (
     _ProcThread, _ProcDialog,
-    _stat_stretch_rgb, _stat_unstretch_rgb,
+    _mtf_params_unlinked, _apply_mtf_unlinked_rgb, _invert_mtf_unlinked_rgb,
     _active_mask3_from_doc, _mask_blend_with_doc_mask, _push_as_new_doc,
     _ensure_exec_bit,
 )
@@ -125,24 +125,48 @@ def _run_starnet_headless(main, doc, p):
     processing_image = processing_image.astype(np.float32, copy=False)
 
     is_linear = bool(p.get("linear", True))
-    did_stretch = False
-    stretch_params = None
+    did_stretch = is_linear
+
+    # sanitize + normalize if needed (keep exactly like interactive)
+    processing_image = np.nan_to_num(processing_image, nan=0.0, posinf=0.0, neginf=0.0).astype(np.float32, copy=False)
+
+    scale_factor = float(np.max(processing_image)) if processing_image.size else 1.0
+    processing_norm = (processing_image / scale_factor) if scale_factor > 1.0 else processing_image
+    processing_norm = np.clip(processing_norm, 0.0, 1.0)
+
+    img_for_starnet = processing_norm
+
     if is_linear:
-        processing_image, stretch_params = _stat_stretch_rgb(processing_image)
-        did_stretch = True
-        setattr(main, "_starnet_last_stretch_params", stretch_params)
+        mtf_params = _mtf_params_unlinked(processing_norm, shadows_clipping=-2.8, targetbg=0.25)
+        img_for_starnet = _apply_mtf_unlinked_rgb(processing_norm, mtf_params)
+
+        # stash for inverse step (same keys as interactive)
+        try:
+            setattr(main, "_starnet_stat_meta", {
+                "scheme": "siril_mtf",
+                "s": np.asarray(mtf_params["s"], dtype=np.float32),
+                "m": np.asarray(mtf_params["m"], dtype=np.float32),
+                "h": np.asarray(mtf_params["h"], dtype=np.float32),
+                "scale": float(scale_factor),
+            })
+        except Exception:
+            pass
     else:
-        if hasattr(main, "_starnet_last_stretch_params"):
-            delattr(main, "_starnet_last_stretch_params")
+        try:
+            if hasattr(main, "_starnet_stat_meta"):
+                delattr(main, "_starnet_stat_meta")
+        except Exception:
+            pass
+
 
     starnet_dir = os.path.dirname(exe) or os.getcwd()
     in_path  = os.path.join(starnet_dir, "imagetoremovestars.tif")
     out_path = os.path.join(starnet_dir, "starless.tif")
 
     try:
-        save_image(processing_image, in_path, original_format="tif",
-                   bit_depth="16-bit", original_header=None, is_mono=False,
-                   image_meta=None, file_meta=None)
+        save_image(img_for_starnet, in_path, original_format="tif",
+                bit_depth="16-bit", original_header=None, is_mono=False,
+                image_meta=None, file_meta=None)
     except Exception as e:
         QMessageBox.critical(main, "StarNet", f"Failed to write input TIFF:\n{e}")
         return
@@ -179,12 +203,30 @@ def _finish_starnet(main, doc, rc, dlg, in_path, out_path, did_stretch):
     starless_rgb = starless_rgb.astype(np.float32, copy=False)
 
     if did_stretch:
+        meta = getattr(main, "_starnet_stat_meta", None)
+        if isinstance(meta, dict) and meta.get("scheme") == "siril_mtf":
+            try:
+                p = {
+                    "s": np.asarray(meta.get("s"), dtype=np.float32),
+                    "m": np.asarray(meta.get("m"), dtype=np.float32),
+                    "h": np.asarray(meta.get("h"), dtype=np.float32),
+                }
+                inv = _invert_mtf_unlinked_rgb(starless_rgb, p)
+                sc = float(meta.get("scale", 1.0))
+                if sc > 1.0:
+                    inv *= sc
+                starless_rgb = np.clip(inv, 0.0, 1.0).astype(np.float32, copy=False)
+            except Exception:
+                pass
+
+        # cleanup so it can't leak
         try:
-            params = getattr(main, "_starnet_last_stretch_params", None)
-            if params: starless_rgb = _stat_unstretch_rgb(starless_rgb, params)
+            if hasattr(main, "_starnet_stat_meta"):
+                delattr(main, "_starnet_stat_meta")
         except Exception:
             pass
 
+
     # original as RGB
     orig = np.asarray(doc.image)
     if orig.ndim == 2: original_rgb = np.stack([orig]*3, axis=-1)

setiastro/saspro/resources.py

@@ -123,17 +123,31 @@ def _get_base_path() -> str:
 
 
 def _resource_path(filename: str) -> str:
-    """Get full path to a resource file."""
     base = _get_base_path()
-    
-    # Check if it's an image file - look in images/ subdirectory
-    if filename.endswith(('.png', '.ico', '.gif', '.icns', '.svg')):
-        images_path = os.path.join(base, 'images', filename)
-        if os.path.exists(images_path):
-            return images_path
-    
-    # Fallback to root directory (for data files like .csv, .fits, etc.)
-    return os.path.join(base, filename)
+    fn = filename
+
+    is_img = fn.lower().endswith(('.png','.ico','.gif','.icns','.svg','.jpg','.jpeg','.bmp'))
+    if is_img:
+        candidates = [
+            os.path.join(base, 'images', fn),
+            os.path.join(base, 'setiastro', 'images', fn),
+            os.path.join(base, 'setiastro', 'saspro', 'images', fn),
+        ]
+        for p in candidates:
+            if os.path.exists(p):
+                return p
+
+    # data / other files
+    candidates = [
+        os.path.join(base, fn),
+        os.path.join(base, 'setiastro', fn),
+        os.path.join(base, 'setiastro', 'saspro', fn),
+    ]
+    for p in candidates:
+        if os.path.exists(p):
+            return p
+
+    return os.path.join(base, fn)
 
 
 class Icons:
@@ -210,6 +224,7 @@ class Icons:
     ROTATE_CW = property(lambda self: _resource_path('rotateclockwise.png'))
     ROTATE_CCW = property(lambda self: _resource_path('rotatecounterclockwise.png'))
     ROTATE_180 = property(lambda self: _resource_path('rotate180.png'))
+    ROTATE_ANY      = property(lambda self: _resource_path('rotatearbitrary.png'))
     RESCALE = property(lambda self: _resource_path('rescale.png'))
     
     # Masks
@@ -395,6 +410,7 @@ def _init_legacy_paths():
         'rotateclockwise_path': get_icon_path('rotateclockwise.png'),
         'rotatecounterclockwise_path': get_icon_path('rotatecounterclockwise.png'),
         'rotate180_path': get_icon_path('rotate180.png'),
+        'rotatearbitrary_path': get_icon_path('rotatearbitrary.png'),
         'maskcreate_path': get_icon_path('maskcreate.png'),
         'maskapply_path': get_icon_path('maskapply.png'),
         'maskremove_path': get_icon_path('maskremove.png'),
@@ -471,9 +487,12 @@ globals().update(_legacy)
 
 
 # Background for startup
-background_startup_path = os.path.join(_get_base_path(), 'images', 'Background_startup.jpg')
+background_startup_path = _resource_path('Background_startup.jpg')
 _legacy['background_startup_path'] = background_startup_path
 
+# QML helper
+resource_monitor_qml = _resource_path(os.path.join("qml", "ResourceMonitor.qml"))
+
 # Export list for `from setiastro.saspro.resources import *`
 __all__ = [
     'Icons', 'Resources', 

setiastro/saspro/selective_color.py

@@ -467,7 +467,7 @@ class SelectiveColorCorrection(QDialog):
 
         self.img = np.clip(self.document.image.astype(np.float32), 0.0, 1.0)
         self.preview_img = self.img.copy()
-
+        self._syncing_hue = False
         self._imported_mask_full = None     # full-res mask (H x W) float32 0..1
         self._imported_mask_name = None     # nice label to show in UI
         self._use_imported_mask = False     # checkbox state mirror
@@ -555,6 +555,36 @@ class SelectiveColorCorrection(QDialog):
         self.hue_wheel.setSizePolicy(QSizePolicy.Policy.Minimum, QSizePolicy.Policy.Minimum)
         gl.addWidget(self.hue_wheel, 1, 0, 7, 2)
 
+        # Wheel -> sliders/spins (so dragging wheel updates UI and mask)
+        def _wheel_to_sliders(s: int, e: int):
+            # If user is dragging the wheel, we’re now custom
+            if not self._setting_preset and self.dd_preset.currentText() != "Custom":
+                self.dd_preset.blockSignals(True)
+                self.dd_preset.setCurrentText("Custom")
+                self.dd_preset.blockSignals(False)
+
+            # Update BOTH sliders and spins, without ping-pong
+            self._syncing_hue = True
+            try:
+                s = int(s) % 360
+                e = int(e) % 360
+
+                for w, val in (
+                    (self.sl_h1, s), (self.sp_h1, s),
+                    (self.sl_h2, e), (self.sp_h2, e),
+                ):
+                    w.blockSignals(True)
+                    w.setValue(val)
+                    w.blockSignals(False)
+            finally:
+                self._syncing_hue = False
+
+            self._schedule_mask()
+
+        self.hue_wheel.rangeChanged.connect(_wheel_to_sliders)
+
+
+
         # Helper: integer slider + spin (0..360)
         def _deg_pair(grid: QGridLayout, label: str, row: int):
             grid.addWidget(QLabel(label), row, 2)
@@ -574,7 +604,8 @@ class SelectiveColorCorrection(QDialog):
 
         # Row 3: chroma + lightness
         gl.addWidget(QLabel("Min chroma:"), 3, 2)
-        self.ds_minC = QDoubleSpinBox(); self.ds_minC.setRange(0,1); self.ds_minC.setSingleStep(0.05); self.ds_minC.setValue(0.0)
+        self.ds_minC = QDoubleSpinBox(); self.ds_minC.setRange(0,1); self.ds_minC.setSingleStep(0.05); self.ds_minC.setValue(0.05)
+
         self.ds_minC.valueChanged.connect(self._recompute_mask_and_preview)
         gl.addWidget(self.ds_minC, 3, 3)
 
@@ -741,10 +772,12 @@ class SelectiveColorCorrection(QDialog):
         right.addLayout(zoom_row)
 
         self.lbl_help = QLabel(
-            "🖱️ <b>Click</b>: pick hue  &nbsp;•&nbsp; "
+            "🖱️ <b>Click</b>: show hue  &nbsp;•&nbsp; "
+            "<b>Shift + Click</b>: select that color  &nbsp;•&nbsp; "
             "<b>Ctrl + Click & Drag</b>: pan  &nbsp;•&nbsp; "
             "<b>Ctrl + Wheel</b>: zoom"
         )
+
         self.lbl_help.setWordWrap(True)
         self.lbl_help.setTextFormat(Qt.TextFormat.RichText)
         self.lbl_help.setStyleSheet("color: #888; font-size: 11px;")
@@ -797,12 +830,20 @@ class SelectiveColorCorrection(QDialog):
             w.valueChanged.connect(self._schedule_adjustments)
 
         def _sliders_to_wheel(_=None):
+            if getattr(self, "_syncing_hue", False):
+                return
+
             if not self._setting_preset and self.dd_preset.currentText() != "Custom":
+                self.dd_preset.blockSignals(True)
                 self.dd_preset.setCurrentText("Custom")
-            s = int(self.sp_h1.value()); e = int(self.sp_h2.value())
+                self.dd_preset.blockSignals(False)
+
+            s = int(self.sp_h1.value())
+            e = int(self.sp_h2.value())
             self.hue_wheel.setRange(s, e, notify=False)
             self._schedule_mask()
 
+
         self.sp_h1.valueChanged.connect(_sliders_to_wheel)
         self.sp_h2.valueChanged.connect(_sliders_to_wheel)
         self.sl_h1.valueChanged.connect(_sliders_to_wheel)
@@ -973,7 +1014,7 @@ class SelectiveColorCorrection(QDialog):
                 w.setValue(int(val))
             w.blockSignals(False)
 
-        setv(self.ds_minC, 0.0)
+        setv(self.ds_minC, 0.05)
         setv(self.ds_minL, 0.0)
         setv(self.ds_maxL, 1.0)
         setv(self.ds_smooth, 10.0)
@@ -1018,23 +1059,27 @@ class SelectiveColorCorrection(QDialog):
         self._recompute_mask_and_preview()
 
 
-    def _schedule_adjustments(self, delay_ms: int | None = None):
+    def _schedule_adjustments(self, *_, delay_ms: int | None = None):
         if delay_ms is None:
             delay_ms = getattr(self, "_adj_delay_ms", 200)
-        # if called very early, just no-op safely
+
         if not hasattr(self, "_adj_timer"):
             return
-        self._adj_timer.stop()
-        self._adj_timer.start(int(delay_ms))
 
+        ms = max(1, int(delay_ms))  # never allow 0/negative
+        self._adj_timer.stop()
+        self._adj_timer.start(ms)
 
-    def _schedule_mask(self, delay_ms: int | None = None):
-        """Debounce mask recomputation for hue changes."""
+    def _schedule_mask(self, *_, delay_ms: int | None = None):
         if delay_ms is None:
-            delay_ms = self._mask_delay_ms
-        # restart the timer on every change
+            delay_ms = getattr(self, "_mask_delay_ms", 200)
+
+        if not hasattr(self, "_mask_timer"):
+            return
+
+        ms = max(1, int(delay_ms))
         self._mask_timer.stop()
-        self._mask_timer.start(int(delay_ms))
+        self._mask_timer.start(ms)
 
 
     def _sample_hue_deg_from_base(self, x: int, y: int) -> float | None:
@@ -1190,16 +1235,30 @@ class SelectiveColorCorrection(QDialog):
                 intervals = _PRESETS.get(txt, [])
                 if intervals:
                     lo, hi = (intervals[0][0], intervals[-1][1]) if len(intervals) > 1 else intervals[0]
-                    self.hue_wheel.setRange(int(lo), int(hi), notify=False)  # update wheel silently
-                    self.hue_wheel.update()  # ensure repaint
-                    self.sp_h1.blockSignals(True); self.sp_h2.blockSignals(True)
-                    self.sp_h1.setValue(int(lo));  self.sp_h2.setValue(int(hi))
-                    self.sp_h1.blockSignals(False); self.sp_h2.blockSignals(False)
+
+                    # --- NEW: keep wheel + sliders + spins all in sync ---
+                    self._syncing_hue = True
+                    try:
+                        # update wheel silently
+                        self.hue_wheel.setRange(int(lo), int(hi), notify=False)
+
+                        # update both sliders and spins (no ping-pong)
+                        for w, val in (
+                            (self.sl_h1, int(lo)), (self.sp_h1, int(lo)),
+                            (self.sl_h2, int(hi)), (self.sp_h2, int(hi)),
+                        ):
+                            w.blockSignals(True)
+                            w.setValue(val)
+                            w.blockSignals(False)
+
+                        self.hue_wheel.update()  # ensure repaint
+                    finally:
+                        self._syncing_hue = False
+
             self._recompute_mask_and_preview()
         finally:
             self._setting_preset = False
 
-
     def _downsample(self, img, max_dim=1024):
         h, w = img.shape[:2]
         s = max(h, w)

setiastro/saspro/shortcuts.py

@@ -209,6 +209,17 @@ class DraggableToolBar(QToolBar):
         s.setValue(self._settings_key, ids)
 
 
+    def _is_locked(self) -> bool:
+        """Check if toolbar icon movement is locked globally."""
+        s = self._settings()
+        # Default to False (unlocked)
+        return s.value("UI/ToolbarLocked", False, type=bool)
+
+    def _set_locked(self, locked: bool):
+        """Set the global lock state."""
+        s = self._settings()
+        s.setValue("UI/ToolbarLocked", locked)
+
     # install/remove our event filter when actions are added/removed
     def actionEvent(self, e):
         super().actionEvent(e)
@@ -259,6 +270,7 @@ class DraggableToolBar(QToolBar):
                     if delta.manhattanLength() > QApplication.startDragDistance():
                         mods_now = QApplication.keyboardModifiers()
                         had_mod  = self._press_had_mod.get(obj, False)
+                        
                         # CASE 1: had/has modifiers → create desktop shortcut / function-bundle drag (existing behavior)
                         if had_mod or self._mods_ok(mods_now):
                             act = self._find_action_for_button(obj)
@@ -270,6 +282,20 @@ class DraggableToolBar(QToolBar):
                             return True  # consume
                         else:
                             # CASE 2: plain drag (no modifiers) → reorder within this toolbar
+                            # CHECK LOCK STATE FIRST
+                            if self._is_locked():
+                                # Lock is active: DO NOT start drag.
+                                # Should we consume the event? 
+                                # If we consume it, the button won't feel "pressed" anymore if the user keeps dragging?
+                                # Actually, if we just return False, standard QToolButton behavior applies (it might think it's being pressed).
+                                # However, we want to prevent the *reorder* logic.
+                                # So simply doing nothing here is enough to prevent the reorder drag from starting.
+                                
+                                # But we might want to let the user know, or just silently fail distinctively?
+                                # Silently failing distinctively is what the user asked for (prevent involuntary move).
+                                # If we return False, the button keeps tracking the mouse, which is fine (it won't click unless released inside).
+                                return False 
+
                             self._start_reorder_drag_for_button(obj)
                             self._suppress_release.add(obj)
                             self._press_pos.pop(obj, None)
@@ -461,28 +487,42 @@ class DraggableToolBar(QToolBar):
     def _show_toolbutton_context_menu(self, btn: QToolButton, act: QAction, gpos: QPoint):
         m = QMenu(btn)
 
-        m.addAction("Create Desktop Shortcut", lambda: self._add_shortcut_for_action(act))
+        m.addAction(self.tr("Create Desktop Shortcut"), lambda: self._add_shortcut_for_action(act))
 
         # Hide this icon
         cid = self._action_id(act)
         if cid:
             m.addSeparator()
-            m.addAction("Hide this icon", lambda: self._set_action_hidden(act, True))
+            m.addAction(self.tr("Hide this icon"), lambda: self._set_action_hidden(act, True))
 
         # (Optional) teach users about Alt+Drag:
         m.addSeparator()
-        tip = m.addAction("Tip: Alt+Drag to create")
+        tip = m.addAction(self.tr("Tip: Alt+Drag to create"))
         tip.setEnabled(False)
 
         m.exec(gpos)
 
+
     def contextMenuEvent(self, ev):
         # Right-click on empty toolbar area
         m = QMenu(self)
 
+        # 1. Lock/Unlock Action
+        is_locked = self._is_locked()
+        act_lock = m.addAction(self.tr("Lock Toolbar Icons"))
+        act_lock.setCheckable(True)
+        act_lock.setChecked(is_locked)
+        
+        def _toggle_lock(checked):
+            self._set_locked(checked)
+            
+        act_lock.triggered.connect(_toggle_lock)
+        
+        m.addSeparator()
+
         # Submenu listing hidden actions for this toolbar
         hidden = self._load_hidden_set()
-        sub = m.addMenu("Show hidden…")
+        sub = m.addMenu(self.tr("Show hidden…"))
 
         # Build list from actions that are currently invisible
         any_hidden = False
@@ -496,7 +536,7 @@ class DraggableToolBar(QToolBar):
             sub.setEnabled(False)
 
         m.addSeparator()
-        m.addAction("Reset hidden icons", self._reset_hidden_icons)
+        m.addAction(self.tr("Reset hidden icons"), self._reset_hidden_icons)
 
         m.exec(ev.globalPos())
 
@@ -515,7 +555,7 @@ _PRESET_UI_IDS = {
     "remove_green","star_align","background_neutral","white_balance","clahe",
     "morphology","pixel_math","rgb_align","signature_insert","signature_adder",
     "signature","halo_b_gon","geom_rescale","rescale","debayer","image_combine",
-    "star_spikes","diffraction_spikes", "multiscale_decomp",
+    "star_spikes","diffraction_spikes", "multiscale_decomp","geom_rotate_any",
 }
 
 def _has_preset_editor_for_command(command_id: str) -> bool:
@@ -548,6 +588,12 @@ def _open_preset_editor_for_command(parent, command_id: str, initial: dict | Non
         })
         return dlg.result_dict() if dlg.exec() == QDialog.DialogCode.Accepted else None
 
+    if command_id == "geom_rotate_any":
+        dlg = _GeomRotateAnyPresetDialog(parent, initial=cur or {
+            "angle_deg": 0.0,
+        })
+        return dlg.result_dict() if dlg.exec() == QDialog.DialogCode.Accepted else None
+
     if command_id == "curves":
         dlg = _CurvesPresetDialog(parent, initial=cur or {"shape":"linear","amount":0.5,"mode":"K (Brightness)"})
         return dlg.result_dict() if dlg.exec() == QDialog.DialogCode.Accepted else None
@@ -741,18 +787,18 @@ class ShortcutButton(QToolButton):
     # --- Context menu (run / preset / delete) ----------------------------
     def _context_menu(self, pos):
         m = QMenu(self)
-        m.addAction("Run", lambda: self._mgr.trigger(self.command_id))
+        m.addAction(self.tr("Run"), lambda: self._mgr.trigger(self.command_id))
         m.addSeparator()
-        m.addAction("Edit Preset…", self._edit_preset_ui)
-        m.addAction("Clear Preset", lambda: self._save_preset(None))
-        m.addAction("Rename…", self._rename)                    # ← NEW
+        m.addAction(self.tr("Edit Preset…"), self._edit_preset_ui)
+        m.addAction(self.tr("Clear Preset"), lambda: self._save_preset(None))
+        m.addAction(self.tr("Rename…"), self._rename)                    # ← NEW
         m.addSeparator()
-        m.addAction("Delete", self._delete)
+        m.addAction(self.tr("Delete"), self._delete)
         m.exec(self.mapToGlobal(pos))
 
     def _rename(self):
         current = self.text()
-        new_name, ok = QInputDialog.getText(self, "Rename Shortcut", "Name:", text=current)
+        new_name, ok = QInputDialog.getText(self, self.tr("Rename Shortcut"), self.tr("Name:"), text=current)
         if not ok or not new_name.strip():
             return
         self.setText(new_name.strip())
@@ -764,21 +810,21 @@ class ShortcutButton(QToolButton):
         result = _open_preset_editor_for_command(self, cid, cur)
         if result is not None:
             self._save_preset(result)
-            QMessageBox.information(self, "Preset saved", "Preset stored on shortcut.")
+            QMessageBox.information(self, self.tr("Preset saved"), self.tr("Preset stored on shortcut."))
             return
 
         # Fallback: JSON editor
         raw = json.dumps(cur or {}, indent=2)
-        text, ok = QInputDialog.getMultiLineText(self, "Edit Preset (JSON)", "Preset:", raw)
+        text, ok = QInputDialog.getMultiLineText(self, self.tr("Edit Preset (JSON)"), self.tr("Preset:"), raw)
         if ok:
             try:
                 preset = json.loads(text or "{}")
                 if not isinstance(preset, dict):
-                    raise ValueError("Preset must be a JSON object")
+                    raise ValueError(self.tr("Preset must be a JSON object"))
                 self._save_preset(preset)
-                QMessageBox.information(self, "Preset saved", "Preset stored on shortcut.")
+                QMessageBox.information(self, self.tr("Preset saved"), self.tr("Preset stored on shortcut."))
             except Exception as e:
-                QMessageBox.warning(self, "Invalid JSON", str(e))
+                QMessageBox.warning(self, self.tr("Invalid JSON"), str(e))
 
 
     def _start_command_drag(self):
@@ -1066,11 +1112,11 @@ class ShortcutCanvas(QWidget):
     def contextMenuEvent(self, e):
         menu = QMenu(self)
         has_sel = bool(self._mgr.selected)
-        a_del = menu.addAction("Delete Selected", self._mgr.delete_selected); a_del.setEnabled(has_sel)
-        a_clr = menu.addAction("Clear Selection", self._mgr.clear_selection); a_clr.setEnabled(has_sel)
+        a_del = menu.addAction(self.tr("Delete Selected"), self._mgr.delete_selected); a_del.setEnabled(has_sel)
+        a_clr = menu.addAction(self.tr("Clear Selection"), self._mgr.clear_selection); a_clr.setEnabled(has_sel)
         menu.addSeparator()
-        a_vb = menu.addAction("View Bundles…", lambda: _open_view_bundles_from_canvas(self))
-        a_fb = menu.addAction("Function Bundles…", lambda: _open_function_bundles_from_canvas(self))
+        a_vb = menu.addAction(self.tr("View Bundles…"), lambda: _open_view_bundles_from_canvas(self))
+        a_fb = menu.addAction(self.tr("Function Bundles…"), lambda: _open_function_bundles_from_canvas(self))
         menu.exec(e.globalPos())
 
 
@@ -3041,3 +3087,30 @@ class _RGBAlignPresetDialog(QDialog):
             "new_doc": bool(self.chk_new.isChecked()),
         }
 
+class _GeomRotateAnyPresetDialog(QDialog):
+    def __init__(self, parent=None, initial: dict | None = None):
+        super().__init__(parent)
+        self.setWindowTitle("Arbitrary Rotation — Preset")
+        init = dict(initial or {})
+
+        self.spin_angle = QDoubleSpinBox()
+        self.spin_angle.setRange(-360.0, 360.0)
+        self.spin_angle.setDecimals(2)
+        self.spin_angle.setSingleStep(0.25)
+        self.spin_angle.setValue(float(init.get("angle_deg", init.get("angle", 0.0))))
+
+        form = QFormLayout(self)
+        form.addRow("Angle (degrees):", self.spin_angle)
+
+        btns = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel,
+            parent=self
+        )
+        btns.accepted.connect(self.accept)
+        btns.rejected.connect(self.reject)
+        form.addRow(btns)
+
+    def result_dict(self) -> dict:
+        return {
+            "angle_deg": float(self.spin_angle.value()),
+        }