setiastrosuitepro 1.6.1.post1__py3-none-any.whl → 1.6.4__py3-none-any.whl

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/sfcc.py

@@ -346,6 +346,9 @@ class SFCCDialog(QDialog):
     def __init__(self, doc_manager, sasp_data_path, parent=None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Spectral Flux Color Calibration"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.setMinimumSize(800, 600)
 
         self.doc_manager = doc_manager
@@ -1155,18 +1158,56 @@ class SFCCDialog(QDialog):
         diag_meas_BG, diag_exp_BG = [], []
         enriched = []
 
+        # --- Optimization: Pre-calculate integrals for unique templates ---
+        unique_simbad_types = set(m["template"] for m in raw_matches)
+        
+        # Map simbad_type -> pickles_template_name
+        simbad_to_pickles = {}
+        pickles_templates_needed = set()
+        
+        for sp in unique_simbad_types:
+            cands = pickles_match_for_simbad(sp, getattr(self, "pickles_templates", []))
+            if cands:
+                pickles_name = cands[0]
+                simbad_to_pickles[sp] = pickles_name
+                pickles_templates_needed.add(pickles_name)
+
+        # Pre-calc integrals for each unique Pickles template
+        # Cache structure: template_name -> (S_sr, S_sg, S_sb)
+        template_integrals = {}
+
+        # Cache for load_sed to avoid re-reading even across different calls if desired, 
+        # but here we just optimize the loop.
+        
+        for pname in pickles_templates_needed:
+            try:
+                wl_s, fl_s = load_sed(pname)
+                fs_i = np.interp(wl_grid, wl_s, fl_s, left=0., right=0.)
+                
+                S_sr = np.trapezoid(fs_i * T_sys_R, x=wl_grid)
+                S_sg = np.trapezoid(fs_i * T_sys_G, x=wl_grid)
+                S_sb = np.trapezoid(fs_i * T_sys_B, x=wl_grid)
+                
+                template_integrals[pname] = (S_sr, S_sg, S_sb)
+            except Exception as e:
+                print(f"[SFCC] Warning: failed to load/integrate template {pname}: {e}")
+
+        # --- Main Match Loop ---
         for m in raw_matches:
             xi, yi, sp = m["x_pix"], m["y_pix"], m["template"]
             Rm = float(base[yi, xi, 0]); Gm = float(base[yi, xi, 1]); Bm = float(base[yi, xi, 2])
             if Gm <= 0: continue
 
-            cands = pickles_match_for_simbad(sp, getattr(self, "pickles_templates", []))
-            if not cands: continue
-            wl_s, fl_s = load_sed(cands[0])
-            fs_i = np.interp(wl_grid, wl_s, fl_s, left=0., right=0.)
-            S_sr = np.trapezoid(fs_i * T_sys_R, x=wl_grid)
-            S_sg = np.trapezoid(fs_i * T_sys_G, x=wl_grid)
-            S_sb = np.trapezoid(fs_i * T_sys_B, x=wl_grid)
+            # 1. Resolve Simbad -> Pickles
+            pname = simbad_to_pickles.get(sp)
+            if not pname: continue
+            
+            # 2. Retrieve pre-calced integrals
+            integrals = template_integrals.get(pname)
+            if not integrals: continue
+            
+            S_sr, S_sg, S_sb = integrals
+            
             if S_sg <= 0: continue
 
             exp_RG = S_sr / S_sg; exp_BG = S_sb / S_sg
@@ -1180,7 +1221,8 @@ class SFCCDialog(QDialog):
                 "S_star_R": S_sr, "S_star_G": S_sg, "S_star_B": S_sb,
                 "exp_RG": exp_RG, "exp_BG": exp_BG
             })
-        self._last_matched = enriched  # <-- missing in SASpro
+            
+        self._last_matched = enriched
         diag_meas_RG = np.array(diag_meas_RG); diag_exp_RG = np.array(diag_exp_RG)
         diag_meas_BG = np.array(diag_meas_BG); diag_exp_BG = np.array(diag_exp_BG)
         if diag_meas_RG.size == 0 or diag_meas_BG.size == 0:

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()),
+        }

setiastro/saspro/signature_insert.py

@@ -363,6 +363,9 @@ class SignatureInsertDialogPro(QDialog):
     def __init__(self, parent, doc, icon: QIcon | None = None):
         super().__init__(parent)
         self.setWindowTitle(self.tr("Signature / Insert"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         if icon:
             try: self.setWindowIcon(icon)
             except Exception as e: