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

setiastro/saspro/resources.py

@@ -246,6 +246,7 @@ class Icons:
     LIVE_STACKING = property(lambda self: _resource_path('livestacking.png'))
     IMAGE_COMBINE = property(lambda self: _resource_path('imagecombine.png'))
     PLANETARY_STACKER = property(lambda self: _resource_path('planetarystacker.png'))
+    PLANET_PROJECTION = property(lambda self: _resource_path('3dplanet.png'))   
     
     # Moon phase (WIMS)
     MOON_NEW            = property(lambda self: _resource_path('new_moon.png'))
@@ -551,6 +552,7 @@ def _init_legacy_paths():
         'rgbalign_path': get_icon_path('rgbalign.png'),
         'background_path': get_icon_path('background.png'), 
         'script_icon_path': get_icon_path('script.png'),
+        'planetprojection_path': get_icon_path('3dplanet.png'),
     }
 
 

setiastro/saspro/save_options.py

@@ -1,8 +1,9 @@
 # pro/save_options.py
 from __future__ import annotations
-from PyQt6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QLabel, QComboBox, QPushButton
+from PyQt6.QtWidgets import QDialog, QVBoxLayout, QHBoxLayout, QLabel, QComboBox, QPushButton, QSpinBox, QWidget
 from PyQt6.QtCore import Qt
 
+
 from setiastro.saspro.file_utils import _normalize_ext
 
 # Allowed bit depths per output format (what your saver actually supports)
@@ -16,22 +17,28 @@ _BIT_DEPTHS = {
 }
 
 class SaveOptionsDialog(QDialog):
-    def __init__(self, parent, target_ext: str, current_bit_depth: str | None):
+    def __init__(
+        self,
+        parent,
+        target_ext: str,
+        current_bit_depth: str | None,
+        current_jpeg_quality: int | None = None,
+    ):
         super().__init__(parent)
         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)
 
-        # Normalize extension aggressively so it matches _BIT_DEPTHS keys
-        raw_ext = (target_ext or "").lower().strip()
+        self.jpeg_quality_spin = None
 
-        # If it's like ".fits" or "image.fits" just keep the part after last dot
+        # -----------------------------
+        # Normalize extension FIRST
+        # -----------------------------
+        raw_ext = (target_ext or "").lower().strip()
         if "." in raw_ext:
             raw_ext = raw_ext.split(".")[-1]
 
-        # Handle common synonyms / compressed variants
         if raw_ext in ("fit", "fits", "fz", "fits.gz", "fit.gz"):
             self._ext = "fits"
         elif raw_ext in ("tif", "tiff"):
@@ -39,19 +46,42 @@ class SaveOptionsDialog(QDialog):
         elif raw_ext in ("jpg", "jpeg"):
             self._ext = "jpg"
         else:
-            # Fallback – already lowercase, no leading dot
             self._ext = raw_ext
 
         allowed = _BIT_DEPTHS.get(self._ext, ["32-bit floating point"])
 
+        # -----------------------------
+        # Build layout
+        # -----------------------------
+        lay = QVBoxLayout(self)
+
+        lbl = QLabel(self.tr("Choose bit depth for export:"))
+        lbl.setWordWrap(True)
+        lay.addWidget(lbl)
+
         self.combo = QComboBox(self)
         self.combo.addItems(allowed)
         if current_bit_depth in allowed:
             self.combo.setCurrentText(current_bit_depth)
+        lay.addWidget(self.combo)
 
-        lbl = QLabel(self.tr("Choose bit depth for export:"))
-        lbl.setWordWrap(True)
+        # -----------------------------
+        # JPEG quality (only for jpg)
+        # -----------------------------
+        if self._ext == "jpg":
+            qlbl = QLabel(self.tr("JPEG quality (1–100):"))
+            qlbl.setWordWrap(True)
+            lay.addWidget(qlbl)
+
+            self.jpeg_quality_spin = QSpinBox(self)
+            self.jpeg_quality_spin.setRange(1, 100)
+            default_q = int(current_jpeg_quality) if current_jpeg_quality is not None else 95
+            self.jpeg_quality_spin.setValue(max(1, min(100, default_q)))
+            lay.addWidget(self.jpeg_quality_spin)
 
+        # -----------------------------
+        # Buttons
+        # -----------------------------
         btn_ok = QPushButton(self.tr("OK"))
         btn_cancel = QPushButton(self.tr("Cancel"))
         btn_ok.clicked.connect(self.accept)
@@ -62,12 +92,14 @@ class SaveOptionsDialog(QDialog):
         row.addWidget(btn_ok)
         row.addWidget(btn_cancel)
 
-        lay = QVBoxLayout(self)
-        lay.addWidget(lbl)
-        lay.addWidget(self.combo)
         lay.addStretch(1)
         lay.addLayout(row)
 
+
     def selected_bit_depth(self) -> str:
         return self.combo.currentText()
 
+    def selected_jpeg_quality(self) -> int | None:
+        if self.jpeg_quality_spin is None:
+            return None
+        return int(self.jpeg_quality_spin.value())

setiastro/saspro/ser_stack_config.py

@@ -30,7 +30,12 @@ class SERStackConfig:
     ap_multiscale: bool = False
     ssd_refine_bruteforce: bool = False
     keep_mask: Optional[KeepMask] = None
-
+    planet_smooth_sigma: float = 1.5
+    planet_thresh_pct: float = 92.0
+    planet_use_norm: bool = True
+    planet_norm_lo_pct: float = 1.0
+    planet_norm_hi_pct: float = 99.5
+    planet_min_val: float = 0.02
     # ✅ Drizzle
     drizzle_scale: float = 1.0          # 1.0 = off, 1.5, 2.0
     drizzle_pixfrac: float = 0.80       # "drop shrink" in output pixels (roughly)
@@ -58,7 +63,22 @@ class SERStackConfig:
         self.ap_multiscale = bool(kwargs.pop("ap_multiscale", False))
         self.ssd_refine_bruteforce = bool(kwargs.pop("ssd_refine_bruteforce", False))
         self.keep_mask = kwargs.pop("keep_mask", None)
+        # Planetary centroid knobs (pure data, no UI references)
+        self.planet_smooth_sigma = float(kwargs.pop("planet_smooth_sigma", 1.5))
+        self.planet_thresh_pct   = float(kwargs.pop("planet_thresh_pct", 92.0))
+        self.planet_min_val      = float(kwargs.pop("planet_min_val", 0.02))
+        self.planet_use_norm     = bool(kwargs.pop("planet_use_norm", True))
+        self.planet_norm_lo_pct  = float(kwargs.pop("planet_norm_lo_pct", 1.0))
+        self.planet_norm_hi_pct  = float(kwargs.pop("planet_norm_hi_pct", 99.5))
 
+        # sanitize
+        self.planet_smooth_sigma = max(0.0, self.planet_smooth_sigma)
+        self.planet_thresh_pct   = float(np.clip(self.planet_thresh_pct, 0.0, 100.0)) if "np" in globals() else self.planet_thresh_pct
+        self.planet_min_val      = float(max(0.0, min(1.0, self.planet_min_val)))
+        self.planet_norm_lo_pct  = float(np.clip(self.planet_norm_lo_pct, 0.0, 100.0)) if "np" in globals() else self.planet_norm_lo_pct
+        self.planet_norm_hi_pct  = float(np.clip(self.planet_norm_hi_pct, 0.0, 100.0)) if "np" in globals() else self.planet_norm_hi_pct
+        if self.planet_norm_hi_pct <= self.planet_norm_lo_pct:
+            self.planet_norm_hi_pct = min(100.0, self.planet_norm_lo_pct + 1.0)
         # ✅ NEW: Drizzle params
         self.drizzle_scale = float(kwargs.pop("drizzle_scale", 1.0))
         if self.drizzle_scale not in (1.0, 1.5, 2.0):

setiastro/saspro/ser_stacker.py

@@ -1601,6 +1601,9 @@ def analyze_ser(
         tracker = PlanetaryTracker(
             smooth_sigma=float(getattr(cfg, "planet_smooth_sigma", smooth_sigma)),
             thresh_pct=float(getattr(cfg, "planet_thresh_pct", thresh_pct)),
+            min_val=float(getattr(cfg, "planet_min_val", 0.02)),
+            use_norm=bool(getattr(cfg, "planet_use_norm", False)),
+            norm_hi_pct=float(getattr(cfg, "planet_norm_hi_pct", 99.5)),
         )
 
         # IMPORTANT: reference center is computed from the SAME reference image that Analyze chose
@@ -1954,8 +1957,11 @@ def realign_ser(
     else:
         # planetary: centroid tracking (same as viewer)
         tracker = PlanetaryTracker(
-            smooth_sigma=float(getattr(cfg, "planet_smooth_sigma", 1.5)),
-            thresh_pct=float(getattr(cfg, "planet_thresh_pct", 92.0)),
+            smooth_sigma=float(getattr(cfg, "planet_smooth_sigma", smooth_sigma)),
+            thresh_pct=float(getattr(cfg, "planet_thresh_pct", thresh_pct)),
+            min_val=float(getattr(cfg, "planet_min_val", 0.02)),
+            use_norm=bool(getattr(cfg, "planet_use_norm", False)),
+            norm_hi_pct=float(getattr(cfg, "planet_norm_hi_pct", 99.5)),
         )
 
         # Reference center comes from analysis.ref_image (same anchor as analyze_ser)

setiastro/saspro/ser_stacker_dialog.py

@@ -442,22 +442,29 @@ class APEditorDialog(QDialog):
     # ---------- drawing ----------
     def _render(self):
         u8 = self._base_u8
+        # ✅ memmap/FITS-safe: QImage assumes row-major contiguous when we pass bytesPerLine=w
+        if not u8.flags["C_CONTIGUOUS"]:
+            u8 = np.ascontiguousarray(u8)
+
         h, w = u8.shape[:2]
 
-        qimg = QImage(u8.data, w, h, w, QImage.Format.Format_Grayscale8)
-        base_pm = QPixmap.fromImage(qimg.copy())  # copy so backing store persists
+        qimg = QImage(u8.data, w, h, w, QImage.Format.Format_Grayscale8).copy()
+        base_pm = QPixmap.fromImage(qimg)  # already detached above
 
         # scale to display zoom (keeps UI sane)
         zw = max(1, int(round(w * self._zoom)))
         zh = max(1, int(round(h * self._zoom)))
-        pm = base_pm.scaled(zw, zh, Qt.AspectRatioMode.IgnoreAspectRatio, Qt.TransformationMode.SmoothTransformation)
+        pm = base_pm.scaled(
+            zw, zh,
+            Qt.AspectRatioMode.IgnoreAspectRatio,
+            Qt.TransformationMode.SmoothTransformation
+        )
 
         # draw AP boxes in *display coords* so thickness doesn't scale
         p = QPainter(pm)
         p.setRenderHint(QPainter.RenderHint.Antialiasing, True)
 
         s_img = int(max(8, self._ap_size))
-        half_img = s_img // 2
         s_disp = max(2, int(round(s_img * self._zoom)))
         half_disp = s_disp // 2
 
@@ -832,6 +839,8 @@ class SERStackerDialog(QDialog):
         debayer: bool = True,
         keep_percent: float = 20.0,
         bayer_pattern: Optional[str] = None,
+        planet_min_val=0.02, planet_use_norm=False, planet_norm_hi_pct=99.5,
+        planet_thresh_pct=92.0, planet_smooth_sigma=1.5, **kwargs
     ):
         super().__init__(parent)
         self.setWindowTitle("Planetary Stacker - Beta")
@@ -840,6 +849,13 @@ class SERStackerDialog(QDialog):
         self.setModal(False)
         self._bayer_pattern = bayer_pattern
         self._keep_mask = None  # np.ndarray bool shape (N,) or None
+
+        self._planet_min_val = float(planet_min_val)
+        self._planet_use_norm = bool(planet_use_norm)
+        self._planet_norm_hi_pct = float(planet_norm_hi_pct)
+        self._planet_thresh_pct = float(planet_thresh_pct)
+        self._planet_smooth_sigma = float(planet_smooth_sigma)
+
         # ---- Normalize inputs ------------------------------------------------
         # If caller provided only `source`, treat string-source as ser_path too.
         if source is None:
@@ -1445,7 +1461,7 @@ class SERStackerDialog(QDialog):
             surface_anchor=self._surface_anchor,
             keep_percent=float(self.spin_keep.value()),
             bayer_pattern=self._bayer_pattern,
-            keep_mask=getattr(self, "_keep_mask", None), 
+            keep_mask=getattr(self, "_keep_mask", None),
 
             ap_size=int(self.spin_ap_size.value()),
             ap_spacing=int(self.spin_ap_spacing.value()),
@@ -1455,7 +1471,14 @@ class SERStackerDialog(QDialog):
                 getattr(self, "chk_ssd_bruteforce", None) and self.chk_ssd_bruteforce.isChecked()
             ),
 
-            # ✅ drizzle
+            # ✅ NEW: planetary centroid knobs (add UI controls or set defaults)
+            planet_smooth_sigma=self._planet_smooth_sigma,
+            planet_thresh_pct=self._planet_thresh_pct,
+            planet_min_val=self._planet_min_val,
+            planet_use_norm=self._planet_use_norm,
+            planet_norm_hi_pct=self._planet_norm_hi_pct,
+
+            # drizzle
             drizzle_scale=float(drizzle_scale),
             drizzle_pixfrac=float(self.spin_pixfrac.value()),
             drizzle_kernel=str(drizzle_kernel),
@@ -1783,7 +1806,7 @@ class BlinkKeepersDialog(QDialog):
         v = (mono - lo) / (hi - lo)
         v = np.clip(v, 0.0, 1.0)
         return (v * 255.0 + 0.5).astype(np.uint8)
-
+    
     def _show_index(self, i: int):
         if self.keepers.size == 0:
             return
@@ -1810,9 +1833,14 @@ class BlinkKeepersDialog(QDialog):
             img = img[..., 0]
 
         u8 = self._disp_u8(img)
+
+        # ✅ memmap/FITS-safe: guarantee tight row stride for bytesPerLine=w
+        if not u8.flags["C_CONTIGUOUS"]:
+            u8 = np.ascontiguousarray(u8)
+
         h, w = u8.shape
-        qimg = QImage(u8.data, w, h, w, QImage.Format.Format_Grayscale8)
-        pm = QPixmap.fromImage(qimg.copy())
+        qimg = QImage(u8.data, w, h, w, QImage.Format.Format_Grayscale8).copy()
+        pm = QPixmap.fromImage(qimg)
 
         self.lbl.setPixmap(pm.scaled(
             self.lbl.size(),
@@ -1821,7 +1849,6 @@ class BlinkKeepersDialog(QDialog):
         ))
         self._update_labels()
 
-
     def resizeEvent(self, e):
         super().resizeEvent(e)
         self._show_index(self.sld.value())

setiastro/saspro/ser_tracking.py

@@ -19,14 +19,22 @@ def _to_mono01(img: np.ndarray) -> np.ndarray:
 
 
 class PlanetaryTracker:
-    """
-    Tracks by centroid of the brightest connected component inside ROI.
-    Good for: planets, full disk objects.
-    """
-    def __init__(self, smooth_sigma: float = 1.5, thresh_pct: float = 92.0):
+    def __init__(
+        self,
+        *,
+        smooth_sigma: float = 1.5,
+        thresh_pct: float = 92.0,
+        min_val: float = 0.02,          # ✅ NEW
+        use_norm: bool = True,
+        norm_hi_pct: float = 99.5,
+        norm_lo_pct: float = 1.0,
+    ):
         self.smooth_sigma = float(smooth_sigma)
         self.thresh_pct = float(thresh_pct)
-        self._ref_center = None  # (cx, cy)
+        self.min_val = float(min_val)  # ✅ store
+        self.use_norm = bool(use_norm)
+        self.norm_hi_pct = float(norm_hi_pct)
+        self.norm_lo_pct = float(norm_lo_pct)
 
     def reset(self):
         self._ref_center = None
@@ -71,23 +79,20 @@ class PlanetaryTracker:
         conf = float(np.clip(mm["m00"] / float(mask.size), 0.0, 1.0))
         return (cx, cy, conf)
 
+    def _normalize_for_detect(self, m: np.ndarray) -> np.ndarray:
+        if not self.use_norm:
+            return m
 
-    def step(self, img01: np.ndarray) -> tuple[float, float, float]:
-        """
-        Returns (dx, dy, conf) where dx/dy shifts FROM current frame TO reference.
-        """
-        m = _to_mono01(img01)
-        m2 = self._blur(m)
-
-        # adaptive threshold by percentile
-        t = float(np.percentile(m2, self.thresh_pct))
-        if not np.isfinite(t):
-            return 0.0, 0.0, 0.0
+        lo = float(np.percentile(m, self.norm_lo_pct))
+        hi = float(np.percentile(m, self.norm_hi_pct))
+        if (not np.isfinite(lo)) or (not np.isfinite(hi)) or (hi <= lo + 1e-12):
+            return m
 
-        mask = (m2 >= t).astype(np.uint8) * 255
-        mask = self._largest_component_mask(mask)
+        det = (m - lo) / (hi - lo)
+        return np.clip(det, 0.0, 1.0).astype(np.float32, copy=False)
 
-        cx, cy, conf = self._centroid(m2, mask)
+    def step(self, img01: np.ndarray) -> tuple[float, float, float]:
+        cx, cy, conf = self.compute_center(img01)
         if conf <= 0.0:
             return 0.0, 0.0, 0.0
 
@@ -98,25 +103,42 @@ class PlanetaryTracker:
         rx, ry = self._ref_center
         dx = rx - cx
         dy = ry - cy
-        return float(dx), float(dy), conf
+        return float(dx), float(dy), float(conf)
+    
+    def _prep_mono01(self, img01: np.ndarray) -> np.ndarray:
+        m = _to_mono01(img01).astype(np.float32, copy=False)
+        m = np.nan_to_num(m, nan=0.0, posinf=0.0, neginf=0.0)
 
-    def compute_center(self, img01: np.ndarray) -> tuple[float, float, float]:
-        """
-        Compute (cx, cy, conf) in pixels in the provided image coordinate system.
-        Uses the same pipeline as step(): blur -> percentile thresh -> largest CC -> centroid.
-        """
-        m = _to_mono01(img01)
-        m2 = self._blur(m)
+        # match step(): blur then lo/hi percentile normalize
+        if self.smooth_sigma > 0.0 and cv2 is not None:
+            m = cv2.GaussianBlur(m, (0, 0), float(self.smooth_sigma))
 
-        t = float(np.percentile(m2, self.thresh_pct))
-        if not np.isfinite(t):
-            return 0.0, 0.0, 0.0
+        m = self._normalize_for_detect(m)
+        return np.clip(m, 0.0, 1.0).astype(np.float32, copy=False)
+
+    def compute_center(self, img01: np.ndarray):
+        m = self._prep_mono01(img01)  # already blurred + normalized
+
+        thr = float(np.percentile(m, np.clip(self.thresh_pct, 0.0, 100.0)))
+        if not np.isfinite(thr):
+            return (m.shape[1] * 0.5), (m.shape[0] * 0.5), 0.0
+
+        # ✅ critical: threshold cannot be below min_val (same domain: normalized [0..1])
+        thr = max(thr, float(self.min_val))
+
+        mask = (m >= thr).astype(np.uint8)
+        if int(mask.sum()) < 10:
+            return (m.shape[1] * 0.5), (m.shape[0] * 0.5), 0.0
+
+        ys, xs = np.nonzero(mask)
+        w = m[ys, xs]
+        sw = float(w.sum()) + 1e-12
+        cx = float((xs * w).sum() / sw)
+        cy = float((ys * w).sum() / sw)
 
-        mask = (m2 >= t).astype(np.uint8) * 255
-        mask = self._largest_component_mask(mask)
+        conf = float(np.clip((float(np.mean(w)) - thr) / max(1e-6, (1.0 - thr)), 0.0, 1.0))
+        return cx, cy, conf
 
-        cx, cy, conf = self._centroid(m2, mask)
-        return float(cx), float(cy), float(conf)
 
     def shift_to_ref(self, img01: np.ndarray, ref_center: tuple[float, float]) -> tuple[float, float, float]:
         """