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

setiastro/saspro/rgb_combination.py

@@ -42,8 +42,9 @@ class RGBCombinationDialogPro(QDialog):
     """
     def __init__(self, parent, list_open_docs_fn=None, doc_manager=None):
         super().__init__(parent)
-        self.setWindowTitle("RGB Combination")
+        self.setWindowTitle(self.tr("RGB Combination"))
         self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
         self._list_open_docs = list_open_docs_fn or (lambda: [])
@@ -55,28 +56,28 @@ class RGBCombinationDialogPro(QDialog):
         self.b_path = None
 
         # ── mode choose
-        self.load_files_radio = QRadioButton("Load Individual Files")
-        self.use_views_radio  = QRadioButton("Use Open Views")
+        self.load_files_radio = QRadioButton(self.tr("Load Individual Files"))
+        self.use_views_radio  = QRadioButton(self.tr("Use Open Views"))
         self.use_views_radio.setChecked(True)
 
         self.mode_group = QButtonGroup(self)
         self.mode_group.addButton(self.load_files_radio)
         self.mode_group.addButton(self.use_views_radio)
 
-        mode_box = QGroupBox("Select RGB Combination Mode")
+        mode_box = QGroupBox(self.tr("Select RGB Combination Mode"))
         ml = QVBoxLayout(mode_box)
         ml.addWidget(self.use_views_radio)
         ml.addWidget(self.load_files_radio)
 
         # ── file mode widgets
-        self.r_label = QLabel("Red: Not selected")
-        self.g_label = QLabel("Green: Not selected")
-        self.b_label = QLabel("Blue: Not selected")
-        self.btn_load_r = QPushButton("Load Red…");   self.btn_load_r.clicked.connect(lambda: self._pick_file("R"))
-        self.btn_load_g = QPushButton("Load Green…"); self.btn_load_g.clicked.connect(lambda: self._pick_file("G"))
-        self.btn_load_b = QPushButton("Load Blue…");  self.btn_load_b.clicked.connect(lambda: self._pick_file("B"))
-
-        file_box = QGroupBox("Files")
+        self.r_label = QLabel(self.tr("Red: Not selected"))
+        self.g_label = QLabel(self.tr("Green: Not selected"))
+        self.b_label = QLabel(self.tr("Blue: Not selected"))
+        self.btn_load_r = QPushButton(self.tr("Load Red…"));   self.btn_load_r.clicked.connect(lambda: self._pick_file("R"))
+        self.btn_load_g = QPushButton(self.tr("Load Green…")); self.btn_load_g.clicked.connect(lambda: self._pick_file("G"))
+        self.btn_load_b = QPushButton(self.tr("Load Blue…"));  self.btn_load_b.clicked.connect(lambda: self._pick_file("B"))
+
+        file_box = QGroupBox(self.tr("Files"))
         fl = QVBoxLayout(file_box)
         for lab, btn in [(self.r_label, self.btn_load_r),
                          (self.g_label, self.btn_load_g),
@@ -85,16 +86,16 @@ class RGBCombinationDialogPro(QDialog):
             fl.addLayout(row)
 
         # ── open-views widgets
-        views_box = QGroupBox("Select Open Views for R / G / B")
+        views_box = QGroupBox(self.tr("Select Open Views for R / G / B"))
         vl = QHBoxLayout(views_box)
         self.cmb_r = QComboBox(); self.cmb_g = QComboBox(); self.cmb_b = QComboBox()
-        vl.addLayout(self._labeled("Red:",   self.cmb_r))
-        vl.addLayout(self._labeled("Green:", self.cmb_g))
-        vl.addLayout(self._labeled("Blue:",  self.cmb_b))
+        vl.addLayout(self._labeled(self.tr("Red:"),   self.cmb_r))
+        vl.addLayout(self._labeled(self.tr("Green:"), self.cmb_g))
+        vl.addLayout(self._labeled(self.tr("Blue:"),  self.cmb_b))
 
         # ── buttons
-        self.btn_combine = QPushButton("Combine")
-        self.btn_cancel  = QPushButton("Cancel")
+        self.btn_combine = QPushButton(self.tr("Combine"))
+        self.btn_cancel  = QPushButton(self.tr("Cancel"))
         self.btn_cancel.clicked.connect(self.reject)
         self.btn_combine.clicked.connect(self._combine)
 

setiastro/saspro/rgbalign.py

@@ -324,15 +324,12 @@ class RGBAlignWorker(QThread):
     def _warp_channel(self, ch: np.ndarray, kind: str, X, ref_shape):
         H, W = ref_shape[:2]
         if kind == "affine":
-            if cv2 is None:
-                return ch
+            # Just assume cv2 is available (standard dependency) for perf
             A = np.asarray(X, dtype=np.float32).reshape(2, 3)
             return cv2.warpAffine(ch, A, (W, H), flags=cv2.INTER_LANCZOS4,
                                   borderMode=cv2.BORDER_CONSTANT, borderValue=0)
 
         if kind == "homography":
-            if cv2 is None:
-                return ch
             Hm = np.asarray(X, dtype=np.float32).reshape(3, 3)
             return cv2.warpPerspective(ch, Hm, (W, H), flags=cv2.INTER_LANCZOS4,
                                        borderMode=cv2.BORDER_CONSTANT, borderValue=0)
@@ -349,7 +346,10 @@ class RGBAlignWorker(QThread):
 class RGBAlignDialog(QDialog):
     def __init__(self, parent=None, document=None):
         super().__init__(parent)
-        self.setWindowTitle("RGB Align")
+        self.setWindowTitle(self.tr("RGB Align"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.parent = parent
         # document could be a view; try to unwrap
         self.doc_view = document
@@ -361,7 +361,7 @@ class RGBAlignDialog(QDialog):
                              "Select model and run."))
 
         hl = QHBoxLayout()
-        hl.addWidget(QLabel("Alignment model:"))
+        hl.addWidget(QLabel(self.tr("Alignment model:")))
         self.model_combo = QComboBox()
         self.model_combo.addItems([
             "EDGE",           # ← first, new default
@@ -410,7 +410,7 @@ class RGBAlignDialog(QDialog):
 
         # ── SEP controls ─────────────────────────
         sep_row = QHBoxLayout()
-        sep_row.addWidget(QLabel("SEP sigma:"))
+        sep_row.addWidget(QLabel(self.tr("SEP sigma:")))
 
         self.sep_spin = QSpinBox()
         self.sep_spin.setRange(1, 100)
@@ -419,7 +419,7 @@ class RGBAlignDialog(QDialog):
                                  "Higher = fewer stars, lower = more stars.")
         sep_row.addWidget(self.sep_spin)
 
-        self.btn_trial_sep = QPushButton("Trial detect stars")
+        self.btn_trial_sep = QPushButton(self.tr("Trial detect stars"))
         self.btn_trial_sep.setToolTip("Run SEP on the green channel with this sigma and report how many "
                                       "stars it finds and how many are in the EDGE ring.")
         self.btn_trial_sep.clicked.connect(self._trial_sep_detect)
@@ -428,7 +428,7 @@ class RGBAlignDialog(QDialog):
         lay.addLayout(sep_row)
 
 
-        self.chk_new_doc = QCheckBox("Create new document (keep original)")
+        self.chk_new_doc = QCheckBox(self.tr("Create new document (keep original)"))
         self.chk_new_doc.setChecked(True)
         lay.addWidget(self.chk_new_doc)
 
@@ -449,8 +449,8 @@ class RGBAlignDialog(QDialog):
         lay.addWidget(self.summary_box)
 
         btns = QHBoxLayout()
-        self.btn_run = QPushButton("Align")
-        self.btn_close = QPushButton("Close")
+        self.btn_run = QPushButton(self.tr("Align"))
+        self.btn_close = QPushButton(self.tr("Close"))
         btns.addWidget(self.btn_run)
         btns.addWidget(self.btn_close)
         lay.addLayout(btns)

setiastro/saspro/save_options.py

@@ -18,8 +18,9 @@ _BIT_DEPTHS = {
 class SaveOptionsDialog(QDialog):
     def __init__(self, parent, target_ext: str, current_bit_depth: str | None):
         super().__init__(parent)
-        self.setWindowTitle("Save Options")
+        self.setWindowTitle(self.tr("Save Options"))
         self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
         #self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
 
@@ -48,11 +49,11 @@ class SaveOptionsDialog(QDialog):
         if current_bit_depth in allowed:
             self.combo.setCurrentText(current_bit_depth)
 
-        lbl = QLabel(f"Choose bit depth for *.{self._ext}* export:")
+        lbl = QLabel(self.tr("Choose bit depth for export:"))
         lbl.setWordWrap(True)
 
-        btn_ok = QPushButton("OK")
-        btn_cancel = QPushButton("Cancel")
+        btn_ok = QPushButton(self.tr("OK"))
+        btn_cancel = QPushButton(self.tr("Cancel"))
         btn_ok.clicked.connect(self.accept)
         btn_cancel.clicked.connect(self.reject)
 

setiastro/saspro/selective_color.py

@@ -455,7 +455,7 @@ class SelectiveColorCorrection(QDialog):
     """
     def __init__(self, doc_manager=None, document=None, parent=None, window_icon: QIcon | None = None):
         super().__init__(parent)
-        self.setWindowTitle("Selective Color Correction")
+        self.setWindowTitle(self.tr("Selective Color Correction"))
         if window_icon:
             self.setWindowIcon(window_icon)
 
@@ -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
@@ -536,7 +536,7 @@ class SelectiveColorCorrection(QDialog):
         left.setSpacing(8)
 
         # ===== Mask group
-        gb_mask = QGroupBox("Mask")
+        gb_mask = QGroupBox(self.tr("Mask"))
         gl = QGridLayout(gb_mask)
         gl.setContentsMargins(8, 8, 8, 8)
         gl.setHorizontalSpacing(10)
@@ -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)
 
@@ -652,7 +683,7 @@ class SelectiveColorCorrection(QDialog):
 
         # ===== Adjustments
         # CMY
-        gb_cmy = QGroupBox("Complementary colors (CMY)")
+        gb_cmy = QGroupBox(self.tr("Complementary colors (CMY)"))
         glc = QGridLayout(gb_cmy)
         self.sl_c, self.ds_c = self._slider_pair(glc, "Cyan:",    0)
         self.sl_m, self.ds_m = self._slider_pair(glc, "Magenta:", 1)
@@ -660,7 +691,7 @@ class SelectiveColorCorrection(QDialog):
         left.addWidget(gb_cmy)
 
         # RGB
-        gb_rgb = QGroupBox("RGB Colors")
+        gb_rgb = QGroupBox(self.tr("RGB Colors"))
         glr = QGridLayout(gb_rgb)
         self.sl_r, self.ds_r = self._slider_pair(glr, "Red:",   0)
         self.sl_g, self.ds_g = self._slider_pair(glr, "Green:", 1)
@@ -668,7 +699,7 @@ class SelectiveColorCorrection(QDialog):
         left.addWidget(gb_rgb)
 
         # LSC
-        gb_lsc = QGroupBox("Luminance, Chroma/Saturation, Contrast")
+        gb_lsc = QGroupBox(self.tr("Luminance, Chroma/Saturation, Contrast"))
         gll = QGridLayout(gb_lsc)
         self.sl_l, self.ds_l           = self._slider_pair(gll, "Luminance:",  0)
         self.sl_chroma, self.ds_chroma = self._slider_pair(gll, "Chroma (L-preserving):", 1)
@@ -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)