setiastrosuitepro 1.7.1.post2__py3-none-any.whl → 1.7.4__py3-none-any.whl

setiastro/saspro/serviewer.py

@@ -9,7 +9,7 @@ from PyQt6.QtGui import QImage, QPixmap, QPainter, QPen, QColor
 from PyQt6.QtWidgets import (
     QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QFileDialog,
     QScrollArea, QSlider, QCheckBox, QGroupBox, QFormLayout, QSpinBox,
-    QMessageBox, QRubberBand, QComboBox, QDoubleSpinBox
+    QMessageBox, QRubberBand, QComboBox, QDoubleSpinBox, QWidget
 )
 
 from setiastro.saspro.imageops.serloader import open_planetary_source, PlanetaryFrameSource
@@ -323,9 +323,80 @@ class SERViewer(QDialog):
 
         self.btn_stack = QPushButton("Open Stacker…", self)
         self.btn_stack.setEnabled(False)   # enabled once SER loaded
+        self.chk_planet_norm = QCheckBox("Normalize for planetary centroid detect")
+        self.chk_planet_norm.setChecked(True)
+        self.chk_planet_norm.setToolTip("Detection-only normalization (does not change stacking pixels). Helps dim planets.")
+
+        self.spin_planet_thresh = QDoubleSpinBox()
+        self.spin_planet_thresh.setRange(50.0, 99.9)
+        self.spin_planet_thresh.setDecimals(1)
+        self.spin_planet_thresh.setSingleStep(0.5)
+        self.spin_planet_thresh.setValue(92.0)
+        self.spin_planet_thresh.setToolTip("Percentile used to threshold the blob for centroid detection.")
+        self.spin_planet_min = QDoubleSpinBox()
+        self.spin_planet_min.setRange(0.0, 0.5)     # abs floor in [0..1]
+        self.spin_planet_min.setDecimals(3)
+        self.spin_planet_min.setSingleStep(0.005)
+        self.spin_planet_min.setValue(0.02)
+        self.spin_planet_min.setToolTip(
+            "Minimum normalized intensity (0..1) allowed for detection thresholding.\n"
+            "If percentile threshold is too low on dim planets, this prevents the mask from vanishing.\n"
+            "Typical: 0.01–0.05."
+        )
+
+        self.spin_planet_smooth = QDoubleSpinBox()
+        self.spin_planet_smooth.setRange(0.0, 10.0)
+        self.spin_planet_smooth.setDecimals(2)
+        self.spin_planet_smooth.setSingleStep(0.25)
+        self.spin_planet_smooth.setValue(1.5)
+        self.spin_planet_smooth.setToolTip("Gaussian blur sigma used before thresholding. 1.0–2.0 is typical.")
+
+        self.spin_norm_lo = QDoubleSpinBox(); self.spin_norm_lo.setRange(0.0, 20.0); self.spin_norm_lo.setValue(1.0)
+        self.spin_norm_hi = QDoubleSpinBox(); self.spin_norm_hi.setRange(80.0, 100.0); self.spin_norm_hi.setValue(99.5)
+       
+        # -----------------------------
+        # Advanced detection settings
+        # -----------------------------
+        adv = QGroupBox("Advanced detection settings", self)
+        adv.setCheckable(True)
+        adv.setChecked(False)
+
+        adv_body = QWidget(adv)                 # <- content container
+        adv_form = QFormLayout(adv_body)
+        adv_form.setContentsMargins(8, 8, 8, 8)
+        adv_form.setVerticalSpacing(6)
+        adv_form.setHorizontalSpacing(10)
+
+        adv_form.addRow("", self.chk_planet_norm)
+        adv_form.addRow("Planet detect thresh (%)", self.spin_planet_thresh)
+        adv_form.addRow("Norm low pct", self.spin_norm_lo)
+        adv_form.addRow("Norm high pct", self.spin_norm_hi)
+        adv_form.addRow("Planet min val", self.spin_planet_min)
+        adv_form.addRow("Planet smooth σ", self.spin_planet_smooth)
+
+        # Put the body into the groupbox layout
+        adv_layout = QVBoxLayout(adv)
+        adv_layout.setContentsMargins(8, 8, 8, 8)
+        adv_layout.addWidget(adv_body)
+
+        # show/hide only the body
+        adv_body.setVisible(False)
+        adv.toggled.connect(adv_body.setVisible)
 
         sform.addRow("Tracking", self.cmb_track)
         sform.addRow("Keep %", self.spin_keep)
+
+        # instead of adding the detection rows directly:
+        # sform.addRow("", self.chk_planet_norm)
+        # sform.addRow("Planet detect thresh (%)", self.spin_planet_thresh)
+        # sform.addRow("Norm low pct", self.spin_norm_lo)
+        # sform.addRow("Norm high pct", self.spin_norm_hi)
+        # sform.addRow("Planet min val", self.spin_planet_min)
+        # sform.addRow("Planet smooth σ", self.spin_planet_smooth)
+
+        # add the advanced groupbox as a single row spanning the form
+        sform.addRow(adv)
+
         sform.addRow("", self.lbl_anchor)
         sform.addRow("", self.btn_stack)
 
@@ -354,7 +425,8 @@ class SERViewer(QDialog):
                 w.toggled.connect(self._refresh)
             if hasattr(w, "valueChanged"):
                 w.valueChanged.connect(self._refresh)
-
+        for s in (self.spin_x, self.spin_y, self.spin_w, self.spin_h):
+            s.valueChanged.connect(self._sanitize_roi_controls)
         self.cmb_track.currentIndexChanged.connect(self._on_track_mode_changed)
         self.btn_stack.clicked.connect(self._open_stacker_clicked)
         self.cmb_bayer.currentIndexChanged.connect(self._refresh)
@@ -746,16 +818,23 @@ class SERViewer(QDialog):
                                             x, y, w, h = rect_disp
                                             x_full = int(rx + x)
                                             y_full = int(ry + y)
+                                            w = int(w)
+                                            h = int(h)
+
+                                            x_full, y_full, w, h = self._even_roi(x_full, y_full, w, h)
+
                                             self.spin_x.setValue(x_full)
                                             self.spin_y.setValue(y_full)
-                                            self.spin_w.setValue(int(w))
-                                            self.spin_h.setValue(int(h))
+                                            self.spin_w.setValue(w)
+                                            self.spin_h.setValue(h)
                                         else:
                                             x, y, w, h = rect_disp
-                                            self.spin_x.setValue(int(x))
-                                            self.spin_y.setValue(int(y))
-                                            self.spin_w.setValue(int(w))
-                                            self.spin_h.setValue(int(h))
+                                            x, y, w, h = self._even_roi(int(x), int(y), int(w), int(h))
+
+                                            self.spin_x.setValue(x)
+                                            self.spin_y.setValue(y)
+                                            self.spin_w.setValue(w)
+                                            self.spin_h.setValue(h)
 
                                         self.chk_roi.setChecked(True)
                                         self._refresh()
@@ -844,10 +923,16 @@ class SERViewer(QDialog):
             track_mode=self._track_mode_value(),
             surface_anchor=anchor,
             debayer=debayer,
-            bayer_pattern=bp,                 # ✅ THIS IS THE FIX
+            bayer_pattern=bp,
             keep_percent=float(self.spin_keep.value()),
-        )
 
+            # ✅ planetary detect knobs
+            planet_min_val=float(self.spin_planet_min.value()),
+            planet_use_norm=bool(self.chk_planet_norm.isChecked()),
+            planet_norm_hi_pct=float(self.spin_norm_hi.value()),   # <-- you already have this
+            planet_thresh_pct=float(self.spin_planet_thresh.value()),
+            planet_smooth_sigma=float(self.spin_planet_smooth.value()),
+        )          
 
         dlg.stackProduced.connect(self._on_stacker_produced)
         dlg.show()
@@ -1090,10 +1175,10 @@ class SERViewer(QDialog):
             dlg.setDirectory(start_dir)
         dlg.setFileMode(QFileDialog.FileMode.ExistingFiles)
         dlg.setNameFilters([
-            "Planetary Sources (*.ser *.avi *.mp4 *.mov *.mkv *.png *.tif *.tiff *.jpg *.jpeg *.bmp *.webp)",
+            "Planetary Sources (*.ser *.avi *.mp4 *.mov *.mkv *.png *.tif *.tiff *.jpg *.jpeg *.bmp *.webp *.fit *.fits)",
             "SER Videos (*.ser)",
             "AVI/Video (*.avi *.mp4 *.mov *.mkv)",
-            "Images (*.png *.tif *.tiff *.jpg *.jpeg *.bmp *.webp)",
+            "Images (*.png *.tif *.tiff *.jpg *.jpeg *.bmp *.webp *.fit *.fits)",
             "All Files (*)",
         ])
 
@@ -1217,12 +1302,65 @@ class SERViewer(QDialog):
         self._refresh()
 
     # ---------------- rendering ----------------
+    def _even_roi(self, x: int, y: int, w: int, h: int):
+        """Force ROI x,y,w,h to even numbers (preserves Bayer phase)."""
+        if self.reader is None:
+            return x, y, w, h
+
+        m = self.reader.meta
+        W = int(m.width)
+        H = int(m.height)
+
+        # Clamp first
+        x = max(0, min(W - 1, int(x)))
+        y = max(0, min(H - 1, int(y)))
+        w = max(1, int(w))
+        h = max(1, int(h))
+
+        # Make origin even (keep Bayer phase)
+        x &= ~1
+        y &= ~1
+
+        # Make size even
+        w &= ~1
+        h &= ~1
+        if w < 2: w = 2
+        if h < 2: h = 2
+
+        # Fit inside image (keep evenness)
+        if x + w > W:
+            w = (W - x) & ~1
+            if w < 2:
+                x = max(0, (W - 2) & ~1)
+                w = 2
+        if y + h > H:
+            h = (H - y) & ~1
+            if h < 2:
+                y = max(0, (H - 2) & ~1)
+                h = 2
+
+        return int(x), int(y), int(w), int(h)
+
+    def _sanitize_roi_controls(self):
+        if self.reader is None:
+            return
+        x = int(self.spin_x.value()); y = int(self.spin_y.value())
+        w = int(self.spin_w.value()); h = int(self.spin_h.value())
+        ex, ey, ew, eh = self._even_roi(x, y, w, h)
+        if (ex, ey, ew, eh) != (x, y, w, h):
+            self.spin_x.blockSignals(True); self.spin_y.blockSignals(True)
+            self.spin_w.blockSignals(True); self.spin_h.blockSignals(True)
+            self.spin_x.setValue(ex); self.spin_y.setValue(ey)
+            self.spin_w.setValue(ew); self.spin_h.setValue(eh)
+            self.spin_x.blockSignals(False); self.spin_y.blockSignals(False)
+            self.spin_w.blockSignals(False); self.spin_h.blockSignals(False)
 
     def _roi_tuple(self):
         if not self.chk_roi.isChecked():
             return None
-        return (int(self.spin_x.value()), int(self.spin_y.value()),
-                int(self.spin_w.value()), int(self.spin_h.value()))
+        x, y, w, h = (int(self.spin_x.value()), int(self.spin_y.value()),
+                    int(self.spin_w.value()), int(self.spin_h.value()))
+        return self._even_roi(x, y, w, h)
 
     def _on_trim_changed(self):
         if self.reader is None:
@@ -1542,18 +1680,28 @@ class SERViewer(QDialog):
 
     def _to_qimage(self, arr: np.ndarray) -> QImage:
         a = np.clip(arr, 0.0, 1.0)
+
         if a.ndim == 2:
-            u = (a * 255.0).astype(np.uint8)
+            u = (a * 255.0).astype(np.uint8, copy=False)
+            # ✅ FITS/memmap correction: ensure C-contiguous rows
+            if not u.flags["C_CONTIGUOUS"]:
+                u = np.ascontiguousarray(u)
+
             h, w = u.shape
             return QImage(u.data, w, h, w, QImage.Format.Format_Grayscale8).copy()
 
         if a.ndim == 3 and a.shape[2] >= 3:
-            u = (a[..., :3] * 255.0).astype(np.uint8)
+            u = (a[..., :3] * 255.0).astype(np.uint8, copy=False)
+            # ✅ FITS/memmap correction: ensure C-contiguous packed RGB
+            if not u.flags["C_CONTIGUOUS"]:
+                u = np.ascontiguousarray(u)
+
             h, w, _ = u.shape
             return QImage(u.data, w, h, w * 3, QImage.Format.Format_RGB888).copy()
 
         raise ValueError(f"Unexpected image shape: {a.shape}")
 
+
     def _roi_bounds(self):
         """
         Returns (rx, ry, rw, rh) in full-frame coords if ROI enabled,

setiastro/saspro/sfcc.py

@@ -20,6 +20,12 @@ from datetime import datetime
 from typing import List, Tuple, Optional
 
 import numpy as np
+
+try:
+    _trapz = np.trapezoid
+except AttributeError:
+    _trapz = np.trapz
+
 import numpy.ma as ma
 import pandas as pd
 
@@ -313,8 +319,8 @@ class SaspViewer(QMainWindow):
             for color in ("red","green","blue"):
                 data = rgb_data[color]
                 if data is not None:
-                    S_star = np.trapezoid(data["response"], x=common_wl)
-                    S_veg  = np.trapezoid(fl_veg_c * data["T_sys"], x=common_wl)
+                    S_star = _trapz(data["response"], x=common_wl)
+                    S_veg  = _trapz(fl_veg_c * data["T_sys"], x=common_wl)
                     if S_veg>0 and S_star>0:
                         mag = -2.5 * np.log10(S_star / S_veg)
                         mag_texts.append(f"{color[0].upper()}→{data['filter_name']}: {mag:.2f}")
@@ -1485,9 +1491,9 @@ class SFCCDialog(QDialog):
         wl_ref, fl_ref = load_sed(ref_sed_name)
         fr_i = np.interp(wl_grid, wl_ref, fl_ref, left=0.0, right=0.0)
 
-        S_ref_R = np.trapezoid(fr_i * T_sys_R, x=wl_grid)
-        S_ref_G = np.trapezoid(fr_i * T_sys_G, x=wl_grid)
-        S_ref_B = np.trapezoid(fr_i * T_sys_B, x=wl_grid)
+        S_ref_R = _trapz(fr_i * T_sys_R, x=wl_grid)
+        S_ref_G = _trapz(fr_i * T_sys_G, x=wl_grid)
+        S_ref_B = _trapz(fr_i * T_sys_B, x=wl_grid)
 
         diag_meas_RG, diag_exp_RG = [], []
         diag_meas_BG, diag_exp_BG = [], []
@@ -1510,9 +1516,9 @@ class SFCCDialog(QDialog):
             try:
                 wl_s, fl_s = load_sed(pname)
                 fs_i = np.interp(wl_grid, wl_s, fl_s, left=0.0, right=0.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)
+                S_sr = _trapz(fs_i * T_sys_R, x=wl_grid)
+                S_sg = _trapz(fs_i * T_sys_G, x=wl_grid)
+                S_sb = _trapz(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}")