setiastrosuitepro 1.7.0__py3-none-any.whl → 1.7.0.post2__py3-none-any.whl

setiastro/saspro/_generated/build_info.py

@@ -1,3 +1,3 @@
 # Auto-generated at build time. Do not edit.
-BUILD_TIMESTAMP = "2026-01-13T20:26:44Z"
-APP_VERSION = "1.7.0"
+BUILD_TIMESTAMP = "2026-01-14T17:12:34Z"
+APP_VERSION = "1.7.0.post2"

setiastro/saspro/gui/main_window.py

@@ -4430,6 +4430,93 @@ class AstroSuiteProMainWindow(
             except Exception:
                 pass
 
+    def _swap_rb_active(self):
+        """
+        Swap R and B channels in the active RGB document (undoable).
+        Intended for debayer/channel-order mismatches.
+        """
+        dm = getattr(self, "docman", None)
+        if dm is None:
+            return
+
+        try:
+            doc = dm.get_active_document()
+        except Exception:
+            doc = None
+        if doc is None:
+            return
+
+        img = getattr(doc, "image", None)
+        if img is None:
+            return
+
+        import numpy as np
+        x = np.asarray(img)
+
+        # Must be RGB
+        if not (x.ndim == 3 and x.shape[-1] == 3):
+            try:
+                name = getattr(doc, "display_name", lambda: None)() or getattr(doc, "name", "") or "Active"
+            except Exception:
+                name = "Active"
+
+            if hasattr(self, "_log"):
+                self._log(f"Swap R/B: '{name}' is not RGB (shape={getattr(x,'shape',None)}).")
+            return
+
+        before_shape = x.shape
+        before_dtype = x.dtype
+
+        # swap channels without changing dtype
+        # (copy is safest so we don't mutate shared views)
+        out = x.copy()
+        out[..., 0], out[..., 2] = x[..., 2], x[..., 0]
+
+        # metadata: preserve existing, but annotate operation
+        try:
+            md = dict(getattr(doc, "metadata", None) or {})
+        except Exception:
+            md = {}
+
+        md["color_model"] = md.get("color_model", "RGB")
+        md["channels"] = 3
+        md["is_mono"] = False
+        md["source"] = (md.get("source") or "Edit")
+
+        # If you track op params for history explorer
+        md["__op_params__"] = {
+            "op": "swap_rb",
+            "from_shape": tuple(before_shape),
+            "to_shape": tuple(out.shape),
+            "dtype": str(before_dtype),
+        }
+
+        try:
+            name = getattr(doc, "display_name", lambda: None)() or getattr(doc, "name", "") or "Active"
+        except Exception:
+            name = "Active"
+
+        try:
+            dm.update_active_document(
+                out,
+                metadata=md,
+                step_name="Swap R ↔ B",
+                doc=doc,
+            )
+
+            if hasattr(self, "_log"):
+                self._log(
+                    f"Swap R/B: '{name}' swapped channels "
+                    f"(shape={before_shape}, dtype={before_dtype})."
+                )
+
+        except Exception:
+            import traceback
+            try:
+                from PyQt6.QtWidgets import QMessageBox
+                QMessageBox.critical(self, "Swap R/B", traceback.format_exc())
+            except Exception:
+                pass
 
 
     def _on_stackingsuite_relaunch(self, old_dir: str, new_dir: str):

setiastro/saspro/gui/mixins/menu_mixin.py

@@ -123,6 +123,7 @@ class MenuMixin:
         m_edit.addAction(self.act_redo)
         m_edit.addSeparator()
         m_edit.addAction(self.act_mono_to_rgb)
+        m_edit.addAction(self.act_swap_rb)  
 
 
         # Functions

setiastro/saspro/gui/mixins/toolbar_mixin.py

@@ -836,7 +836,9 @@ class ToolbarMixin:
         self.act_mono_to_rgb = QAction(self.tr("Convert Mono to RGB"), self)
         self.act_mono_to_rgb.setStatusTip(self.tr("Convert a mono image to RGB by duplicating the channel"))
         self.act_mono_to_rgb.triggered.connect(self._convert_mono_to_rgb_active)
-
+        self.act_swap_rb = QAction(self.tr("Swap R and B Channels"), self)
+        self.act_swap_rb.setStatusTip(self.tr("Swap red and blue channels on the active RGB image"))
+        self.act_swap_rb.triggered.connect(self._swap_rb_active)
         # Functions
         self.act_crop = QAction(QIcon(cropicon_path), self.tr("Crop..."), self)
         self.act_crop.setStatusTip(self.tr("Crop / rotate with handles"))

setiastro/saspro/imageops/serloader.py

@@ -31,20 +31,44 @@ SER_HEADER_SIZE = 178
 SER_SIGNATURE_LEN = 14
 
 # Common SER color IDs (seen in the wild)
+# NOTE: Many SER writers use:
+#   0 = MONO
+#   8..11 = Bayer (RGGB/GRBG/GBRG/BGGR)
+#   24..27 = RGB/BGR/RGBA/BGRA
 SER_COLOR = {
-    0: "MONO",       # mono
-    8: "RGB",        # RGB24/RGB48 depending pixel depth
-    9: "BGR",        # BGR24/BGR48
-    10: "RGBA",
-    11: "BGRA",
-    12: "BAYER_RGGB",
-    13: "BAYER_GRBG",
-    14: "BAYER_GBRG",
-    15: "BAYER_BGGR",
+    0: "MONO",
+
+    # Bayer (most common in planetary SER)
+    8:  "BAYER_RGGB",
+    9:  "BAYER_GRBG",
+    10: "BAYER_GBRG",
+    11: "BAYER_BGGR",
+
+    # Packed color
+    24: "RGB",
+    25: "BGR",
+    26: "RGBA",
+    27: "BGRA",
 }
 
 BAYER_NAMES = {"BAYER_RGGB", "BAYER_GRBG", "BAYER_GBRG", "BAYER_BGGR"}
-
+BAYER_PATTERNS = ("BAYER_RGGB", "BAYER_GRBG", "BAYER_GBRG", "BAYER_BGGR")
+
+def _normalize_bayer_pattern(p: Optional[str]) -> Optional[str]:
+    if not p:
+        return None
+    p = str(p).strip().upper()
+    if p == "AUTO":
+        return None
+    if p.startswith("BAYER_"):
+        if p in BAYER_PATTERNS:
+            return p
+        return None
+    # allow short names like "RGGB"
+    p2 = "BAYER_" + p
+    if p2 in BAYER_PATTERNS:
+        return p2
+    return None
 
 @dataclass
 class SerMeta:
@@ -112,6 +136,37 @@ def _cv2_debayer(mosaic: np.ndarray, pattern: str) -> np.ndarray:
         raise ValueError(f"Unknown Bayer pattern: {pattern}")
     return cv2.cvtColor(mosaic, code)
 
+def _maybe_swap_rb_to_match_cv2(mosaic: np.ndarray, pattern: str, out: np.ndarray) -> np.ndarray:
+    """
+    Ensure debayer output channel order matches OpenCV's RGB output.
+    Some fast debayers return BGR. We detect by comparing against cv2 on a small crop.
+    """
+    if out is None or out.ndim != 3 or out.shape[2] < 3:
+        return out
+
+    # Compare on a small center crop for speed
+    H, W = mosaic.shape[:2]
+    cs = min(96, H, W)
+    y0 = max(0, (H - cs) // 2)
+    x0 = max(0, (W - cs) // 2)
+    m = mosaic[y0:y0+cs, x0:x0+cs]
+
+    ref = _cv2_debayer(m, pattern)  # RGB
+
+    o = out[y0:y0+cs, x0:x0+cs, :3]
+    if o.dtype != ref.dtype:
+        # compare in float to avoid overflow
+        o_f = o.astype(np.float32)
+        ref_f = ref.astype(np.float32)
+    else:
+        o_f = o.astype(np.float32)
+        ref_f = ref.astype(np.float32)
+
+    d_same = float(np.mean(np.abs(o_f - ref_f)))
+    d_swap = float(np.mean(np.abs(o_f[..., ::-1] - ref_f)))
+
+    return out[..., ::-1].copy() if d_swap < d_same else out
+
 
 def _try_numba_debayer(mosaic: np.ndarray, pattern: str) -> Optional[np.ndarray]:
     """
@@ -194,6 +249,7 @@ class SERReader:
         self.meta = self._parse_header(self._mm)
         self.meta.path = self.path
         self._cache = _LRUCache(max_items=cache_items)
+        self._fast_debayer_is_bgr: Optional[bool] = None
 
     def close(self):
         try:
@@ -216,7 +272,6 @@ class SERReader:
         self.close()
 
     # ---------------- header parsing ----------------
-
     @staticmethod
     def _parse_header(mm: mmap.mmap) -> SerMeta:
         if mm.size() < SER_HEADER_SIZE:
@@ -228,27 +283,12 @@ class SERReader:
         sig_txt = _decode_cstr(sig)
 
         # Be permissive: many SERs start with LUCAM-RECORDER
-        if "LUCAM" not in sig_txt.upper():
-            # still try parsing; some writers differ, but fields often match
-            pass
+        # If not, still try parsing.
+        # (Some writers use other signatures but the v3 field layout often matches.)
 
-        # Layout (little-endian) commonly:
-        # 0: 14 bytes signature
-        # 14: uint32 LuID
-        # 18: uint32 ColorID
-        # 22: uint32 LittleEndian (0/1)
-        # 26: uint32 ImageWidth
-        # 30: uint32 ImageHeight
-        # 34: uint32 PixelDepth
-        # 38: uint32 FrameCount
-        # 42: char[40] Observer
-        # 82: char[40] Instrument
-        # 122: char[40] Telescope
-        # 162: uint64 DateTime
-        # 170: uint64 DateTimeUTC
         try:
             (lu_id, color_id, little_endian_u32,
-             w, h, pixel_depth, frames) = struct.unpack_from("<7I", hdr, SER_SIGNATURE_LEN)
+            w, h, pixel_depth, frames) = struct.unpack_from("<7I", hdr, SER_SIGNATURE_LEN)
         except Exception as e:
             raise ValueError(f"Failed to parse SER header fields: {e}")
 
@@ -261,26 +301,113 @@ class SERReader:
         color_name = SER_COLOR.get(int(color_id), f"UNKNOWN({color_id})")
 
         bps = _bytes_per_sample(int(pixel_depth))
+        data_offset = SER_HEADER_SIZE
+        file_size = mm.size()
+
+        def expected_size(frame_bytes: int, with_ts: bool) -> int:
+            base = data_offset + int(frames) * int(frame_bytes)
+            return base + (int(frames) * 8 if with_ts else 0)
 
-        # channels per pixel:
-        # - MONO or BAYER: 1 sample per pixel
-        # - RGB/BGR: 3
-        # - RGBA/BGRA: 4 (rare in SER)
+        # --- candidate interpretations ---
+        # Bayer/MONO: 1 sample per pixel
+        fb_1 = int(w) * int(h) * 1 * int(bps)
+
+        # RGB/BGR: 3 samples per pixel
+        fb_3 = int(w) * int(h) * 3 * int(bps)
+
+        # RGBA/BGRA: 4 samples per pixel
+        fb_4 = int(w) * int(h) * 4 * int(bps)
+
+        # Decide initial channels from color_name
         if color_name in {"RGB", "BGR"}:
             channels = 3
+            frame_bytes = fb_3
         elif color_name in {"RGBA", "BGRA"}:
             channels = 4
+            frame_bytes = fb_4
         else:
+            # MONO + Bayer variants should land here
             channels = 1
+            frame_bytes = fb_1
 
-        frame_bytes = int(w) * int(h) * int(channels) * int(bps)
-        data_offset = SER_HEADER_SIZE
+        # --- sanity check against file size ---
+        # If the header mapping is wrong (very common culprit), infer channels by file size.
+        # We consider both "no timestamps" and "with timestamps".
+        def matches(frame_bytes: int) -> tuple[bool, bool]:
+            no_ts = (file_size == expected_size(frame_bytes, with_ts=False))
+            yes_ts = (file_size == expected_size(frame_bytes, with_ts=True))
+            return no_ts, yes_ts
+
+        m1_no, m1_ts = matches(fb_1)
+        m3_no, m3_ts = matches(fb_3)
+        m4_no, m4_ts = matches(fb_4)
+
+        # Prefer an exact match if one exists.
+        # Tie-break: if header says Bayer-ish, prefer 1ch; if header says RGB-ish, prefer 3/4ch.
+        picked = None  # (channels, frame_bytes, has_ts)
+
+        # If our current interpretation matches, keep it
+        cur_no, cur_ts = matches(frame_bytes)
+        if cur_no or cur_ts:
+            picked = (channels, frame_bytes, bool(cur_ts))
 
-        # timestamps detection
-        expected_no_ts = data_offset + frames * frame_bytes
-        expected_with_ts = expected_no_ts + frames * 8
-        size = mm.size()
-        has_ts = (size == expected_with_ts)
+        else:
+            # Try to infer by file size
+            # Unique matches:
+            candidates = []
+            if m1_no: candidates.append((1, fb_1, False))
+            if m1_ts: candidates.append((1, fb_1, True))
+            if m3_no: candidates.append((3, fb_3, False))
+            if m3_ts: candidates.append((3, fb_3, True))
+            if m4_no: candidates.append((4, fb_4, False))
+            if m4_ts: candidates.append((4, fb_4, True))
+
+            if len(candidates) == 1:
+                picked = candidates[0]
+            elif len(candidates) > 1:
+                # tie-break using header hint
+                if _is_bayer(color_name) or color_name == "MONO":
+                    # choose first 1ch match
+                    for c in candidates:
+                        if c[0] == 1:
+                            picked = c
+                            break
+                elif color_name in {"RGB", "BGR"}:
+                    for c in candidates:
+                        if c[0] == 3:
+                            picked = c
+                            break
+                elif color_name in {"RGBA", "BGRA"}:
+                    for c in candidates:
+                        if c[0] == 4:
+                            picked = c
+                            break
+                # still ambiguous: just pick the first (rare)
+                if picked is None:
+                    picked = candidates[0]
+
+        if picked is None:
+            # Couldn’t reconcile sizes; fall back to header interpretation and best-effort ts flag
+            expected_no_ts = expected_size(frame_bytes, with_ts=False)
+            expected_with_ts = expected_size(frame_bytes, with_ts=True)
+            has_ts = (file_size == expected_with_ts)
+        else:
+            channels, frame_bytes, has_ts = picked
+
+            # If we inferred channels that contradict the header color_name, adjust color_name
+            # so the rest of the pipeline (debayer, etc.) behaves sensibly.
+            if channels == 1:
+                # If header said RGB but file is clearly 1ch, it's almost certainly Bayer.
+                # Keep UNKNOWN(...) if we truly don't know the Bayer order.
+                if color_name in {"RGB", "BGR", "RGBA", "BGRA"}:
+                    # safest default: treat as RGGB if we have no better info
+                    color_name = "BAYER_RGGB"
+            elif channels == 3:
+                if color_name not in {"RGB", "BGR"}:
+                    color_name = "RGB"
+            elif channels == 4:
+                if color_name not in {"RGBA", "BGRA"}:
+                    color_name = "RGBA"
 
         return SerMeta(
             path="",
@@ -291,7 +418,7 @@ class SERReader:
             color_id=int(color_id),
             color_name=color_name,
             little_endian=little_endian,
-            data_offset=data_offset,
+            data_offset=int(data_offset),
             frame_bytes=int(frame_bytes),
             has_timestamps=bool(has_ts),
             observer=observer,
@@ -299,6 +426,7 @@ class SERReader:
             telescope=telescope,
         )
 
+
     # ---------------- core access ----------------
 
     def frame_offset(self, i: int) -> int:
@@ -311,10 +439,11 @@ class SERReader:
         self,
         i: int,
         *,
-        roi: Optional[Tuple[int, int, int, int]] = None,  # x,y,w,h
+        roi: Optional[Tuple[int, int, int, int]] = None,
         debayer: bool = True,
         to_float01: bool = False,
         force_rgb: bool = False,
+        bayer_pattern: Optional[str] = None,   # ✅ NEW
     ) -> np.ndarray:
         """
         Returns:
@@ -324,10 +453,13 @@ class SERReader:
         roi is applied before debayer (and ROI origin evenized for Bayer).
         """
         meta = self.meta
+        color_name = meta.color_name
+        user_pat = _normalize_bayer_pattern(bayer_pattern)
+        active_bayer = user_pat if user_pat is not None else (color_name if _is_bayer(color_name) else None)
 
         # Cache key includes ROI + flags
         roi_key = None if roi is None else tuple(int(v) for v in roi)
-        key = (int(i), roi_key, bool(debayer), bool(to_float01), bool(force_rgb))
+        key = (int(i), roi_key, bool(debayer), active_bayer, bool(to_float01), bool(force_rgb))
         cached = self._cache.get(key)
         if cached is not None:
             return cached
@@ -342,7 +474,6 @@ class SERReader:
             dtype = np.uint16
 
         # Determine channels stored
-        color_name = meta.color_name
         if color_name in {"RGB", "BGR"}:
             ch = 3
         elif color_name in {"RGBA", "BGRA"}:
@@ -369,7 +500,7 @@ class SERReader:
             w = max(1, min(meta.width - x, w))
             h = max(1, min(meta.height - y, h))
 
-            if _is_bayer(color_name) and debayer:
+            if (active_bayer is not None) and debayer:
                 x, y = _roi_evenize_for_bayer(x, y)
                 w = max(1, min(meta.width - x, w))
                 h = max(1, min(meta.height - y, h))
@@ -384,14 +515,19 @@ class SERReader:
         if _is_bayer(color_name):
             if debayer:
                 mosaic = img if img.ndim == 2 else img[..., 0]
-                out = _try_numba_debayer(mosaic, color_name)
+                pat = active_bayer or color_name  # active_bayer will usually be set here
+
+                out = _try_numba_debayer(mosaic, pat)
                 if out is None:
-                    out = _cv2_debayer(mosaic, color_name)
+                    out = _cv2_debayer(mosaic, pat)  # already RGB
+                else:
+                    out = _maybe_swap_rb_to_match_cv2(mosaic, pat, out)
+
                 img = out
             else:
-                # keep mosaic as mono
                 img = img if img.ndim == 2 else img[..., 0]
 
+
         # Force RGB for mono (useful for consistent preview pipeline)
         if force_rgb and img.ndim == 2:
             img = np.stack([img, img, img], axis=-1)
@@ -468,6 +604,7 @@ class PlanetaryFrameSource:
         debayer: bool = True,
         to_float01: bool = False,
         force_rgb: bool = False,
+        bayer_pattern: Optional[str] = None,   # ✅ NEW
     ) -> np.ndarray:
         raise NotImplementedError
 
@@ -548,38 +685,102 @@ class AVIReader(PlanetaryFrameSource):
         debayer: bool = True,
         to_float01: bool = False,
         force_rgb: bool = False,
+        bayer_pattern: Optional[str] = None,
     ) -> np.ndarray:
+
         roi_key = None if roi is None else tuple(int(v) for v in roi)
-        key = ("avi", int(i), roi_key, bool(to_float01), bool(force_rgb))
+
+        # User pattern:
+        # - None means AUTO (do not force debayer on 3-channel video)
+        # - A real value means: user explicitly wants debayering
+        user_pat = _normalize_bayer_pattern(bayer_pattern)  # None == AUTO
+        pat_for_key = user_pat or "AUTO"
+
+        key = ("avi", int(i), roi_key, bool(debayer), pat_for_key, bool(to_float01), bool(force_rgb))
         cached = self._cache.get(key)
         if cached is not None:
             return cached
 
-        bgr = self._read_raw_frame_bgr(i)
+        frame = self._read_raw_frame_bgr(i)  # usually (H,W,3) uint8 BGR
 
-        # ROI
+        # ROI first (but if we are going to debayer mosaic, ROI origin must be even-even)
         if roi is not None:
             x, y, w, h = [int(v) for v in roi]
-            H, W = bgr.shape[:2]
+            H, W = frame.shape[:2]
             x = max(0, min(W - 1, x))
             y = max(0, min(H - 1, y))
             w = max(1, min(W - x, w))
             h = max(1, min(H - y, h))
-            bgr = bgr[y:y + h, x:x + w]
 
-        # BGR -> RGB
-        rgb = bgr[..., ::-1].copy()
+            # If user explicitly requests debayering, preserve Bayer phase
+            # (even-even origin) exactly like SER
+            if debayer and user_pat is not None:
+                x, y = _roi_evenize_for_bayer(x, y)
+                w = max(1, min(W - x, w))
+                h = max(1, min(H - y, h))
+
+            frame = frame[y:y + h, x:x + w]
+
+        img: np.ndarray
+
+        # ---------------------------------------------------------
+        # RAW MOSAIC AVI SUPPORT
+        #
+        # OpenCV often returns 3-channel frames even when the AVI is
+        # conceptually "raw mosaic". In that case, ONLY debayer when
+        # the user explicitly selected a Bayer pattern (not AUTO).
+        # ---------------------------------------------------------
+
+        # True mosaic frame decoded as single-channel
+        is_true_mosaic = (frame.ndim == 2) or (frame.ndim == 3 and frame.shape[2] == 1)
+
+        if debayer and (is_true_mosaic or (user_pat is not None)):
+            # If it's 3-channel but user requested debayer, treat as packed mosaic:
+            # take one channel (they should be identical if it's really mosaic-packed).
+            if frame.ndim == 3 and frame.shape[2] >= 3:
+                mosaic = frame[..., 0]  # any channel is fine for packed mosaic
+            else:
+                mosaic = frame if frame.ndim == 2 else frame[..., 0]
+
+            # Choose pattern:
+            # - user_pat is guaranteed not None here if it's forced on 3ch
+            # - if it’s true mosaic and user left AUTO, default RGGB
+            pat = user_pat or "BAYER_RGGB"
 
-        img: np.ndarray = rgb
+            out = _try_numba_debayer(mosaic, pat)
+            if out is None:
+                out = _cv2_debayer(mosaic, pat)          # RGB
+            else:
+                out = _maybe_swap_rb_to_match_cv2(mosaic, pat, out)
+
+            img = out  # RGB
 
-        # force_rgb no-op (already rgb)
+        else:
+            # Normal video path: decoded BGR -> RGB
+            if frame.ndim == 3 and frame.shape[2] >= 3:
+                img = frame[..., ::-1].copy()
+            else:
+                # Rare: frame came out mono but debayer is off
+                img = frame if frame.ndim == 2 else frame[..., 0]
+                if force_rgb:
+                    img = np.stack([img, img, img], axis=-1)
+
+        # Normalize
         if to_float01:
-            img = img.astype(np.float32) / 255.0
+            if img.dtype == np.uint8:
+                img = img.astype(np.float32) / 255.0
+            elif img.dtype == np.uint16:
+                img = img.astype(np.float32) / 65535.0
+            else:
+                img = np.clip(img.astype(np.float32), 0.0, 1.0)
+
+        # Optional force_rgb (mostly relevant if debayer=False and frame is mono)
+        if force_rgb and img.ndim == 2:
+            img = np.stack([img, img, img], axis=-1)
 
         self._cache.put(key, img)
         return img
 
-
 # -----------------------------
 # Image-sequence reader
 # -----------------------------
@@ -687,7 +888,9 @@ class ImageSequenceReader(PlanetaryFrameSource):
         debayer: bool = True,
         to_float01: bool = False,
         force_rgb: bool = False,
+        bayer_pattern: Optional[str] = None,
     ) -> np.ndarray:
+        _ = debayer, bayer_pattern  # unused for sequences (for now)
         i = int(i)
         if i < 0 or i >= self.meta.frames:
             raise IndexError(f"Frame index {i} out of range (0..{self.meta.frames-1})")

setiastro/saspro/ser_stack_config.py

@@ -15,6 +15,7 @@ class SERStackConfig:
     track_mode: TrackMode = "planetary"
     surface_anchor: Optional[Tuple[int, int, int, int]] = None
     keep_percent: float = 20.0
+    bayer_pattern: Optional[str] = None
 
     # AP / alignment
     ap_size: int = 64
@@ -38,7 +39,12 @@ class SERStackConfig:
         self.track_mode = kwargs.pop("track_mode", "planetary")
         self.surface_anchor = kwargs.pop("surface_anchor", None)
         self.keep_percent = float(kwargs.pop("keep_percent", 20.0))
-
+        self.bayer_pattern = kwargs.pop("bayer_pattern", None)
+        if isinstance(self.bayer_pattern, str):
+            s = self.bayer_pattern.strip().upper()
+            self.bayer_pattern = s if s in ("RGGB", "BGGR", "GRBG", "GBRG") else None
+        else:
+            self.bayer_pattern = None
         self.ap_size = int(kwargs.pop("ap_size", 64))
         self.ap_spacing = int(kwargs.pop("ap_spacing", 48))
         self.ap_min_mean = float(kwargs.pop("ap_min_mean", 0.03))

setiastro/saspro/ser_stacker.py

@@ -18,6 +18,44 @@ from setiastro.saspro.ser_stack_config import SERStackConfig
 from setiastro.saspro.ser_tracking import PlanetaryTracker, SurfaceTracker, _to_mono01
 from setiastro.saspro.imageops.serloader import open_planetary_source, PlanetaryFrameSource
 
+_BAYER_TO_CV2 = {
+    "RGGB": cv2.COLOR_BayerRG2RGB,
+    "BGGR": cv2.COLOR_BayerBG2RGB,
+    "GRBG": cv2.COLOR_BayerGR2RGB,
+    "GBRG": cv2.COLOR_BayerGB2RGB,
+}
+
+def _cfg_bayer_pattern(cfg) -> str | None:
+    # cfg.bayer_pattern might be missing in older saved projects; be defensive
+    return getattr(cfg, "bayer_pattern", None)
+
+
+def _get_frame(src, idx: int, *, roi, debayer: bool, to_float01: bool, force_rgb: bool, bayer_pattern: str | None):
+    """
+    Drop-in wrapper:
+    - passes cfg.bayer_pattern down to sources that support it
+    - stays compatible with sources whose get_frame() doesn't accept bayer_pattern yet
+    """
+    try:
+        return src.get_frame(
+            int(idx),
+            roi=roi,
+            debayer=debayer,
+            to_float01=to_float01,
+            force_rgb=force_rgb,
+            bayer_pattern=bayer_pattern,
+        )
+    except TypeError:
+        # Back-compat: older PlanetaryFrameSource implementations
+        return src.get_frame(
+            int(idx),
+            roi=roi,
+            debayer=debayer,
+            to_float01=to_float01,
+            force_rgb=force_rgb,
+        )
+
+
 @dataclass
 class AnalyzeResult:
     frames_total: int
@@ -490,6 +528,7 @@ def _coarse_surface_ref_locked(
     roi_used=None,
     debayer: bool,
     to_rgb: bool,
+    bayer_pattern: Optional[str] = None,
     progress_cb=None,
     progress_every: int = 25,
     # tuning:
@@ -553,7 +592,8 @@ def _coarse_surface_ref_locked(
     # ---------------------------
     src0, owns0 = _ensure_source(source_obj, cache_items=2)
     try:
-        img0 = src0.get_frame(0, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb))
+        img0 = _get_frame(src0, 0, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb), bayer_pattern=bayer_pattern)
+
         ref0 = _to_mono01(img0).astype(np.float32, copy=False)
         ref0 = _downN(ref0)
         ref0p = _bandpass(ref0) if bandpass else (ref0 - float(ref0.mean()))
@@ -644,7 +684,8 @@ def _coarse_surface_ref_locked(
     try:
         pred_x, pred_y = float(rx0), float(ry0)
         for b in boundaries[1:]:
-            img = srck.get_frame(b, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb))
+            img = _get_frame(srck, b, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb), bayer_pattern=bayer_pattern)
+
             cur = _to_mono01(img).astype(np.float32, copy=False)
             cur = _downN(cur)
             curp = _bandpass(cur) if bandpass else (cur - float(cur.mean()))
@@ -682,15 +723,17 @@ def _coarse_surface_ref_locked(
             pred_x, pred_y = start_pred.get(b, (float(rx0), float(ry0)))
             # if boundary already computed above, keep it; start after b
             i0 = b
+            if b in start_pred and b != 0:
+                i0 = b + 1   # boundary already solved with r_key
+
             if i0 == 0:
-                i0 = 1  # frame0 is fixed
+                i0 = 1
             for i in range(i0, e):
-                # if this is exactly a boundary we already filled, use its pred and continue
-                if i in start_pred and i != b:
+                if i in start_pred:
                     pred_x, pred_y = start_pred[i]
                     continue
 
-                img = src.get_frame(i, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb))
+                img = _get_frame(src, i, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb), bayer_pattern=bayer_pattern)
                 cur = _to_mono01(img).astype(np.float32, copy=False)
                 cur = _downN(cur)
                 curp = _bandpass(cur) if bandpass else (cur - float(cur.mean()))
@@ -720,7 +763,7 @@ def _coarse_surface_ref_locked(
         try:
             pred_x, pred_y = float(rx0), float(ry0)
             for i in range(1, n):
-                img = src.get_frame(i, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb))
+                img = _get_frame(src, i, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb), bayer_pattern=bayer_pattern)
                 cur = _to_mono01(img).astype(np.float32, copy=False)
                 cur = _downN(cur)
                 curp = _bandpass(cur) if bandpass else (cur - float(cur.mean()))
@@ -854,6 +897,8 @@ def stack_ser(
     keep_percent: float = 20.0,
     track_mode: str = "planetary",
     surface_anchor=None,
+    to_rgb: bool = False,                 # ✅ add this
+    bayer_pattern: Optional[str] = None,  # ✅ strongly recommended since dialog passes it    
     analysis: AnalyzeResult | None = None,
     local_warp: bool = True,
     max_dim: int = 512,
@@ -866,6 +911,7 @@ def stack_ser(
     drizzle_pixfrac: float = 0.80,
     drizzle_kernel: str = "gaussian",
     drizzle_sigma: float = 0.0,
+
 ) -> tuple[np.ndarray, dict]:
     source_obj = source
 
@@ -908,7 +954,7 @@ def stack_ser(
         ap_size = int(getattr(analysis, "ap_size", 64) or 64)
 
         # frame shape for accumulator
-        first = src0.get_frame(int(keep_idx[0]), roi=roi, debayer=debayer, to_float01=True, force_rgb=False)
+        first = _get_frame(src0, int(keep_idx[0]), roi=roi, debayer=debayer, to_float01=True, force_rgb=False, bayer_pattern=bayer_pattern)
         acc_shape = first.shape  # (H,W) or (H,W,3)
     finally:
         if owns0:
@@ -986,7 +1032,7 @@ def stack_ser(
                 wacc = 0.0
 
             for i in chunk:
-                img = src.get_frame(int(i), roi=roi, debayer=debayer, to_float01=True, force_rgb=False).astype(np.float32, copy=False)
+                img = _get_frame(src, int(i), roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb), bayer_pattern=bayer_pattern).astype(np.float32, copy=False)
 
                 # Global prior (from Analyze)
                 gdx = float(analysis.dx[int(i)]) if (analysis.dx is not None) else 0.0
@@ -1127,6 +1173,7 @@ def _build_reference(
     to_rgb: bool,
     ref_mode: str,
     ref_count: int,
+    bayer_pattern=None,
 ) -> np.ndarray:
     """
     ref_mode:
@@ -1134,7 +1181,7 @@ def _build_reference(
       - "best_stack": return mean of best ref_count frames
     """
     best_idx = int(order[0])
-    f0 = src.get_frame(best_idx, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb))
+    f0 = _get_frame(src, best_idx, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb), bayer_pattern=bayer_pattern)
     if ref_mode != "best_stack" or ref_count <= 1:
         return f0.astype(np.float32, copy=False)
 
@@ -1142,7 +1189,7 @@ def _build_reference(
     acc = np.zeros_like(f0, dtype=np.float32)
     for j in range(k):
         idx = int(order[j])
-        fr = src.get_frame(idx, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb))
+        fr = _get_frame(src, idx, roi=roi, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb), bayer_pattern=bayer_pattern)
         acc += fr.astype(np.float32, copy=False)
     ref = acc / float(k)
     return np.clip(ref, 0.0, 1.0).astype(np.float32, copy=False)
@@ -1168,6 +1215,7 @@ def analyze_ser(
     smooth_sigma: float = 1.5,   # kept for API compat
     thresh_pct: float = 92.0,    # kept for API compat
     ref_mode: str = "best_frame",    # "best_frame" or "best_stack"
+    bayer_pattern: Optional[str] = None,
     ref_count: int = 5,
     max_dim: int = 512,
     progress_cb=None,
@@ -1187,7 +1235,10 @@ def analyze_ser(
             (B) AP search+refine that follows coarse, with outlier rejection,
             (C) robust median -> final dx/dy/conf
     """
+
     source_obj = _cfg_get_source(cfg)
+    bpat = bayer_pattern or _cfg_bayer_pattern(cfg)
+
     if not source_obj:
         raise ValueError("SERStackConfig.source/ser_path is empty")
 
@@ -1254,12 +1305,13 @@ def analyze_ser(
         src, owns = _ensure_source(source_obj, cache_items=0)
         try:
             for i in chunk.tolist():
-                img = src.get_frame(
-                    int(i),
+                img = _get_frame(
+                    src, int(i),
                     roi=roi_used,
                     debayer=debayer,
                     to_float01=True,
                     force_rgb=bool(to_rgb),
+                    bayer_pattern=bpat,
                 )
                 m = _downsample_mono01(img, max_dim=max_dim)
 
@@ -1305,9 +1357,12 @@ def analyze_ser(
     try:
         if cfg.track_mode == "surface":
             # Surface ref must be frame 0 in roi_used coords
-            ref_img = src_ref.get_frame(
-                0, roi=roi_used, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb)
+            ref_img = _get_frame(
+                src_ref, 0,
+                roi=roi_used, debayer=debayer, to_float01=True, force_rgb=bool(to_rgb),
+                bayer_pattern=bpat,
             ).astype(np.float32, copy=False)
+
             ref_mode = "first_frame"
             ref_count = 1
         else:
@@ -1319,7 +1374,9 @@ def analyze_ser(
                 to_rgb=to_rgb,
                 ref_mode=ref_mode,
                 ref_count=ref_count,
+                bayer_pattern=bpat,   # ✅ add this
             ).astype(np.float32, copy=False)
+
     finally:
         if owns_ref:
             try:
@@ -1384,6 +1441,7 @@ def analyze_ser(
             roi_used=roi_used,   # ✅ NEW
             debayer=debayer,
             to_rgb=to_rgb,
+            bayer_pattern=bpat,
             progress_cb=progress_cb,
             progress_every=25,
             down=2,
@@ -1426,12 +1484,13 @@ def analyze_ser(
             src, owns = _ensure_source(source_obj, cache_items=0)
             try:
                 for i in chunk.tolist():
-                    img = src.get_frame(
-                        int(i),
+                    img = _get_frame(
+                        src, int(i),
                         roi=roi_used,
                         debayer=debayer,
                         to_float01=True,
                         force_rgb=bool(to_rgb),
+                        bayer_pattern=bpat,
                     )
                     cur_m = _to_mono01(img).astype(np.float32, copy=False)
 
@@ -1554,12 +1613,13 @@ def analyze_ser(
             src, owns = _ensure_source(source_obj, cache_items=0)
             try:
                 for i in chunk.tolist():
-                    img = src.get_frame(
-                        int(i),
+                    img = _get_frame(
+                        src, int(i),
                         roi=roi_used,
                         debayer=debayer,
                         to_float01=True,
                         force_rgb=bool(to_rgb),
+                        bayer_pattern=bpat,
                     )
 
                     dx_i, dy_i, cf_i = tracker.shift_to_ref(img, ref_center)
@@ -1647,6 +1707,8 @@ def realign_ser(
       - recompute coarse drift (ref-locked) on roi_track
       - refine via AP search+refine FOLLOWING coarse + outlier rejection
     """
+    bpat = bayer_pattern or _cfg_bayer_pattern(cfg)
+
     if analysis is None:
         raise ValueError("analysis is None")
     if analysis.ref_image is None:
@@ -1748,6 +1810,7 @@ def realign_ser(
             roi_used=roi_used,   # ✅ NEW
             debayer=debayer,
             to_rgb=to_rgb,
+            bayer_pattern=bpat,
             progress_cb=progress_cb,
             progress_every=25,
             down=2,
@@ -1776,12 +1839,13 @@ def realign_ser(
             src, owns = _ensure_source(source_obj, cache_items=0)
             try:
                 for i in chunk.tolist():
-                    img = src.get_frame(
-                        int(i),
+                    img = _get_frame(
+                        src, int(i),
                         roi=roi_used,
                         debayer=debayer,
                         to_float01=True,
                         force_rgb=bool(to_rgb),
+                        bayer_pattern=bpat,
                     )
                     cur_m = _to_mono01(img).astype(np.float32, copy=False)
 
@@ -1902,12 +1966,13 @@ def realign_ser(
             src, owns = _ensure_source(source_obj, cache_items=0)
             try:
                 for i in chunk.tolist():
-                    img = src.get_frame(
-                        int(i),
+                    img = _get_frame(
+                        src, int(i),
                         roi=roi_used,
                         debayer=debayer,
                         to_float01=True,
                         force_rgb=bool(to_rgb),
+                        bayer_pattern=bpat,
                     )
 
                     dx_i, dy_i, cf_i = tracker.shift_to_ref(img, ref_center)

setiastro/saspro/ser_stacker_dialog.py

@@ -252,6 +252,12 @@ class APEditorDialog(QDialog):
         self.spin_ap_spacing.setRange(8, 256)
         self.spin_ap_spacing.setSingleStep(8)
         self.spin_ap_spacing.setValue(int(self._ap_spacing))
+        self.spin_ap_min_mean = QDoubleSpinBox(self)
+        self.spin_ap_min_mean.setRange(0.0, 1.0)
+        self.spin_ap_min_mean.setDecimals(3)
+        self.spin_ap_min_mean.setSingleStep(0.005)
+        self.spin_ap_min_mean.setValue(float(self._ap_min_mean))
+        self.spin_ap_min_mean.setToolTip("Minimum mean intensity (0..1) required for an AP tile to be placed.")
 
         ap_row.addWidget(self.lbl_ap)
         ap_row.addSpacing(6)
@@ -260,6 +266,9 @@ class APEditorDialog(QDialog):
         ap_row.addSpacing(10)
         ap_row.addWidget(QLabel("Spacing", self))
         ap_row.addWidget(self.spin_ap_spacing)
+        ap_row.addSpacing(10)
+        ap_row.addWidget(QLabel("Min mean", self))
+        ap_row.addWidget(self.spin_ap_min_mean)        
         ap_row.addStretch(1)
 
         outer.addLayout(ap_row, 0)
@@ -295,6 +304,7 @@ class APEditorDialog(QDialog):
         self._ap_debounce.setSingleShot(True)
         self._ap_debounce.setInterval(250)  # ms
         self._ap_debounce.timeout.connect(self._apply_ap_params_and_relayout)
+        self.spin_ap_min_mean.valueChanged.connect(self._schedule_ap_relayout)
 
         # apply redraw when changed
         self.spin_ap_size.valueChanged.connect(self._schedule_ap_relayout)
@@ -331,11 +341,13 @@ class APEditorDialog(QDialog):
         # Commit params
         self._ap_size = int(self.spin_ap_size.value())
         self._ap_spacing = int(self.spin_ap_spacing.value())
+        self._ap_min_mean = float(self.spin_ap_min_mean.value())
 
         # Re-autoplace using the updated params
         self._do_autoplace()
 
 
+
     def showEvent(self, e):
         super().showEvent(e)
         if self._fit_pending:
@@ -706,6 +718,7 @@ class _AnalyzeWorker(QThread):
                 self.cfg,
                 debayer=self.debayer,
                 to_rgb=self.to_rgb,
+                bayer_pattern=getattr(self.cfg, "bayer_pattern", None),
                 ref_mode=self.ref_mode,
                 ref_count=self.ref_count,
                 progress_cb=cb,
@@ -737,19 +750,21 @@ class _StackWorker(QThread):
                 self.cfg.source,
                 roi=self.cfg.roi,
                 debayer=self.debayer,
+                to_rgb=self.to_rgb,
+                bayer_pattern=getattr(self.cfg, "bayer_pattern", None),  # ✅ add this
                 keep_percent=float(getattr(self.cfg, "keep_percent", 20.0)),
                 track_mode=str(getattr(self.cfg, "track_mode", "planetary")),
                 surface_anchor=getattr(self.cfg, "surface_anchor", None),
                 analysis=self.analysis,
                 local_warp=True,
                 progress_cb=cb,
-
                 drizzle_scale=float(getattr(self.cfg, "drizzle_scale", 1.0)),
                 drizzle_pixfrac=float(getattr(self.cfg, "drizzle_pixfrac", 0.80)),
                 drizzle_kernel=str(getattr(self.cfg, "drizzle_kernel", "gaussian")),
                 drizzle_sigma=float(getattr(self.cfg, "drizzle_sigma", 0.0)),
             )
 
+
             self.finished_ok.emit(out, diag)
         except Exception as e:
             msg = f"{e}\n\n{traceback.format_exc()}"
@@ -810,12 +825,14 @@ class SERStackerDialog(QDialog):
         surface_anchor=None,
         debayer: bool = True,
         keep_percent: float = 20.0,
+        bayer_pattern: Optional[str] = None,
     ):
         super().__init__(parent)
         self.setWindowTitle("Planetary Stacker - Beta")
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+        self._bayer_pattern = bayer_pattern
         # ---- Normalize inputs ------------------------------------------------
         # If caller provided only `source`, treat string-source as ser_path too.
         if source is None:
@@ -1185,6 +1202,7 @@ class SERStackerDialog(QDialog):
                 try:
                     self.spin_ap_size.setValue(int(dlg.ap_size()))
                     self.spin_ap_spacing.setValue(int(dlg.ap_spacing()))
+                    self.spin_ap_min.setValue(float(dlg.ap_min_mean()))
                 except Exception:
                     pass
 
@@ -1377,6 +1395,7 @@ class SERStackerDialog(QDialog):
             track_mode=self._track_mode_value(),
             surface_anchor=self._surface_anchor,
             keep_percent=float(self.spin_keep.value()),
+            bayer_pattern=self._bayer_pattern,
 
             ap_size=int(self.spin_ap_size.value()),
             ap_spacing=int(self.spin_ap_spacing.value()),

setiastro/saspro/serviewer.py

@@ -163,6 +163,9 @@ class SERViewer(QDialog):
 
         self.chk_debayer = QCheckBox("Debayer (Bayer SER)", self)
         self.chk_debayer.setChecked(True)
+        self.cmb_bayer = QComboBox(self)
+        self.cmb_bayer.addItems(["AUTO", "RGGB", "GRBG", "GBRG", "BGGR"])
+        self.cmb_bayer.setCurrentText("AUTO")  # ✅ default for raw mosaic AVI
 
         self.chk_autostretch = QCheckBox("Autostretch preview (linked)", self)
         self.chk_autostretch.setChecked(False)
@@ -188,6 +191,7 @@ class SERViewer(QDialog):
         form.addRow("ROI size", row2)
 
         form.addRow("", self.chk_debayer)
+        form.addRow("Bayer pattern", self.cmb_bayer)        
         form.addRow("", self.chk_autostretch)
 
         # --- Preview tone controls (DISPLAY ONLY) ---
@@ -264,7 +268,9 @@ class SERViewer(QDialog):
 
         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)
+        self.chk_debayer.toggled.connect(lambda v: self.cmb_bayer.setEnabled(bool(v)))
+        self.cmb_bayer.setEnabled(self.chk_debayer.isChecked())
         self.resize(1200, 800)
 
 
@@ -728,19 +734,28 @@ class SERViewer(QDialog):
         except Exception:
             current_doc = None
 
+        debayer = bool(self.chk_debayer.isChecked())
+
+        # Normalize: "AUTO" means "let the loader decide"
+        bp = self.cmb_bayer.currentText().strip().upper()
+        if not debayer or bp == "AUTO":
+            bp = None
+
         dlg = SERStackerDialog(
             parent=self,
             main=main,
             source_doc=current_doc,
-            ser_path=ser_path,          # optional; OK if None
-            source=source,              # ✅ list[str] for PNG sequences
+            ser_path=ser_path,
+            source=source,
             roi=roi,
             track_mode=self._track_mode_value(),
             surface_anchor=anchor,
-            debayer=bool(self.chk_debayer.isChecked()),
+            debayer=debayer,
+            bayer_pattern=bp,                 # ✅ THIS IS THE FIX
             keep_percent=float(self.spin_keep.value()),
         )
 
+
         dlg.stackProduced.connect(self._on_stacker_produced)
         dlg.show()
         dlg.raise_()
@@ -1119,8 +1134,9 @@ class SERViewer(QDialog):
                 self._cur,
                 roi=roi,
                 debayer=debayer,
-                to_float01=True,    # float32 [0..1]
+                to_float01=True,
                 force_rgb=False,
+                bayer_pattern=self.cmb_bayer.currentText(),  # ✅ NEW
             )
         except Exception as e:
             QMessageBox.warning(self, "SER Viewer", f"Frame read failed:\n{e}")

{setiastrosuitepro-1.7.0.dist-info → setiastrosuitepro-1.7.0.post2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: setiastrosuitepro
-Version: 1.7.0
+Version: 1.7.0.post2
 Summary: Seti Astro Suite Pro - Advanced astrophotography toolkit for image calibration, stacking, registration, photometry, and visualization
 License: GPL-3.0
 License-File: LICENSE

{setiastrosuitepro-1.7.0.dist-info → setiastrosuitepro-1.7.0.post2.dist-info}/RECORD

@@ -180,7 +180,7 @@ setiastro/qml/ResourceMonitor.qml,sha256=k9_qXKAZLi8vj-5BffJTJu_UkRnxunZKn53Hthd
 setiastro/saspro/__init__.py,sha256=C6Puq5PQr3n0aJ-2i_YAaUhTjPI-pcSzie3_tij3hhw,608
 setiastro/saspro/__main__.py,sha256=eghNEGSQqHQjNp0BY84T-nhQMPYSnWdIN_eRFvbLj3Q,38487
 setiastro/saspro/_generated/__init__.py,sha256=HbruQfKNbbVL4kh_t4oVG3UeUieaW8MUaqIcDCmnTvA,197
-setiastro/saspro/_generated/build_info.py,sha256=kQnJZOy40C_W1DU5MsPeb6omw-IxFqtehqjwaOcdg3w,111
+setiastro/saspro/_generated/build_info.py,sha256=AzyXhiQpAdluKi6-5HJ5_ryjz9slXCnNho7W4Ff0wB4,117
 setiastro/saspro/abe.py,sha256=ao9UiOneVvgubI19TCE4gk2FNfW_E3D8rr0D_bmQOwI,59779
 setiastro/saspro/abe_preset.py,sha256=u9t16yTb9v98tLjhvh496Fsp3Z-dNiBSs5itnAaJwh8,7750
 setiastro/saspro/aberration_ai.py,sha256=o-l0NQFy8YJXqCUAnp_fT7pjxfYgrCAGircjw3KtMuU,37196
@@ -234,16 +234,16 @@ setiastro/saspro/ghs_preset.py,sha256=Zw3MJH5rEz7nqLdlmRBm3vYXgyopoupyDGAhM-PRXq
 setiastro/saspro/graxpert.py,sha256=XSLeBhlAY2DkYUw93j2OEOuPLOPfzWYcT5Dz3JhhpW8,22579
 setiastro/saspro/graxpert_preset.py,sha256=ESds2NPMPfsBHWNBfyYZ1rFpQxZ9gPOtxwz8enHfFfc,10719
 setiastro/saspro/gui/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-setiastro/saspro/gui/main_window.py,sha256=zrDla3zdhpdsGLEf29ZCrqiMiRDbP8VX1_EYs8_vJG8,370052
+setiastro/saspro/gui/main_window.py,sha256=_2BS65Q10AXCtoZXkX4cSi-_XnxMkJtpW35Onil0yM0,372789
 setiastro/saspro/gui/mixins/__init__.py,sha256=ubdTIri0xoRs6MwDnEaVsAHbMxuPqz0CZcYcue3Mkcc,836
 setiastro/saspro/gui/mixins/dock_mixin.py,sha256=C6IWKM-uP2ekqO7ozVQQcTnEgAkUL_OaRZbncIdrh8g,23893
 setiastro/saspro/gui/mixins/file_mixin.py,sha256=ZzKzJhnNKjbi7UQHFhq4Nr2tNLRbB_fQeMHcOj09BU8,17714
 setiastro/saspro/gui/mixins/geometry_mixin.py,sha256=x-HyLXGFhEs8SJuXT8EF6tS3XJaH8IhAP-ZFJ2BS2Lw,19038
 setiastro/saspro/gui/mixins/header_mixin.py,sha256=kfZUJviB61c8NBXFB3MVBEcRPX_36ZV8tUZNJkDmMJ0,17253
 setiastro/saspro/gui/mixins/mask_mixin.py,sha256=hrC5jLWxUZgQiYUXp7nvECo2uiarK7_HKgawG4HGB9w,15711
-setiastro/saspro/gui/mixins/menu_mixin.py,sha256=nVuJbNZdVTYgq11nOxxCbbqjN6ugBI1QnPULhU3fdXo,16590
+setiastro/saspro/gui/mixins/menu_mixin.py,sha256=7vDRszE6Q7w9odRzoBxmn_gBQBTuRAwEQcdFDPLzt3I,16636
 setiastro/saspro/gui/mixins/theme_mixin.py,sha256=td6hYnZn17lXlFxQOXgK7-qfKo6CIJACF8_zrULlEkc,20740
-setiastro/saspro/gui/mixins/toolbar_mixin.py,sha256=8n1kkruEaAYSMm_jZUtaxQnyfn4AnJZcapqqTY5qhFU,91938
+setiastro/saspro/gui/mixins/toolbar_mixin.py,sha256=m4qGqiQolMqqipdrKseXc0-eW7GeD0keBkjrrHhz6Ys,92180
 setiastro/saspro/gui/mixins/update_mixin.py,sha256=rq7J0Pcn_gO8UehCGVtcSvf-MDbmeGf796h0JBGr0sM,16545
 setiastro/saspro/gui/mixins/view_mixin.py,sha256=EacXxtoAvkectGgLiahf3rHv2AaqKDQUteocVV_P834,17850
 setiastro/saspro/gui/statistics_dialog.py,sha256=celhcsHcp3lNpox_X0ByAiYE80qFaF-dYyP8StzgrcU,1955
@@ -259,7 +259,7 @@ setiastro/saspro/imageops/__init__.py,sha256=CE9mHOsruHOQ5bYOHr1_fhxd9sdK1W9BpAi
 setiastro/saspro/imageops/mdi_snap.py,sha256=Xyogrv3N0KRAKcfC65hy_PKG6ZktjmwDBisCQ_cP9pY,10117
 setiastro/saspro/imageops/narrowband_normalization.py,sha256=q1KdHS7bjRYW-N0Jbszxf0TF38tNNgXKknM80lrzUsA,26793
 setiastro/saspro/imageops/scnr.py,sha256=jLHxBU4KQ9Mu61Cym5YUq0pwxajJmGrPQRV2pug9LXE,1330
-setiastro/saspro/imageops/serloader.py,sha256=EyrvI8IKugP_U3JQI7Cm63qw3iBk52ssUw05pOrrOEk,23576
+setiastro/saspro/imageops/serloader.py,sha256=OBLD0G4UJuHgY946NE7ViYiarPKOKWfWw9uCxBlZYsM,32374
 setiastro/saspro/imageops/starbasedwhitebalance.py,sha256=urssLdgKD7J_LOuscjbf9zFImnUWoH-sotGvtbxfxTo,6589
 setiastro/saspro/imageops/stretch.py,sha256=E_Ydh5VxUHrehwivhvVDvF8y89U6SRyjIFUQgJjHWXI,27113
 setiastro/saspro/isophote.py,sha256=eSzlyBN_tZJSJTKlnBjwHY0zdw0SXPV6BRk_jt9TlVU,53753
@@ -320,11 +320,11 @@ setiastro/saspro/runtime_imports.py,sha256=tgIHH10cdAEbCTOmcs7retQhAww2dEc_3mKrv
 setiastro/saspro/runtime_torch.py,sha256=IEVqD8jgn6la8t3R9ngZ2egSGMAC_tr1im3R8BnvXTQ,33497
 setiastro/saspro/save_options.py,sha256=HPMXl5ya7HlCgDle9mPUrthzIFVJWXQGrea_OkcHg6c,2722
 setiastro/saspro/selective_color.py,sha256=hx-9X4jeso797ifoBmwp9hNagPW4cvNPs9-T0JLHce0,64804
-setiastro/saspro/ser_stack_config.py,sha256=nmeowk9I3a4gCFfhddd-etYGIhaS1_5zWG1LOY6c7JE,2864
-setiastro/saspro/ser_stacker.py,sha256=JGFLZ0XRsuotd320dkP5sEIQqSA-kafwPxjbbkZF2Rk,82048
-setiastro/saspro/ser_stacker_dialog.py,sha256=SkecUJHp3BG1PrNF2XDj5n2PkqQTWs4SCf4sKVLlBh8,54663
+setiastro/saspro/ser_stack_config.py,sha256=s5eaxMB6wuCButMkSyz1-VlOysJZ_vmGC4IA6ZPmiSw,3209
+setiastro/saspro/ser_stacker.py,sha256=I2nHACDtvfeSeDxg6rfWvfMYBZ_7XcAly1XfVEso7bQ,84259
+setiastro/saspro/ser_stacker_dialog.py,sha256=QLrD6-wD4oCyXV6gmtXrZP0jh7hq9WyOeoswqG3zm2A,55743
 setiastro/saspro/ser_tracking.py,sha256=z5jHJIs0t3kK3p5C330vwz0c6zJ9KXtKIh1FlJ1LljU,7141
-setiastro/saspro/serviewer.py,sha256=q8cLpXvoZLJEcDcUtkaqzhQrrLmHXwGtMLV0zMZBlWY,47678
+setiastro/saspro/serviewer.py,sha256=HkRPKq9sTX-NEVGS5bf32VtbcJRXJh7SA4ZokfZ1e_Q,48413
 setiastro/saspro/sfcc.py,sha256=mKdNfbMxl4fgqyZnuAlkzNNIU3huYOHgqw0FGjtVhUs,89097
 setiastro/saspro/shortcuts.py,sha256=QvFBXN_S8jqEwaP9m4pJMLVqzBmxo5HrjWhVCV9etQg,138256
 setiastro/saspro/signature_insert.py,sha256=pWDxUO1Rxm27_fHSo2Y99bdOD2iG9q4AUjGR20x6TiA,70401
@@ -403,9 +403,9 @@ setiastro/saspro/wimi.py,sha256=CNo833Pur9P-A1DUSntlAaQWekf6gzWIvetOMvLDrOw,3146
 setiastro/saspro/wims.py,sha256=HDfVI3Ckf5OJEJLH8NI36pFc2USZnETpb4UDIvweNX4,27450
 setiastro/saspro/window_shelf.py,sha256=jQUifB3uJ9tkzXqmscWj8lHQN5E8yleuRc7hDnes4-k,7453
 setiastro/saspro/xisf.py,sha256=Ah1CXDAohN__ej1Lq7LPU8vGLnDz8fluLQTGE71aUoc,52669
-setiastrosuitepro-1.7.0.dist-info/entry_points.txt,sha256=vJfnZaV6Uj3laETakqT8-D-aJZI_nYIicrhSoL0uuko,227
-setiastrosuitepro-1.7.0.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-setiastrosuitepro-1.7.0.dist-info/licenses/license.txt,sha256=KCwYZ9VpVwmzjelDq1BzzWqpBvt9nbbapa-woz47hfQ,123930
-setiastrosuitepro-1.7.0.dist-info/METADATA,sha256=mPXJiGyemn95E0TPqW0gpRKFSO70MR9EJgceMJVcY30,9834
-setiastrosuitepro-1.7.0.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
-setiastrosuitepro-1.7.0.dist-info/RECORD,,
+setiastrosuitepro-1.7.0.post2.dist-info/entry_points.txt,sha256=vJfnZaV6Uj3laETakqT8-D-aJZI_nYIicrhSoL0uuko,227
+setiastrosuitepro-1.7.0.post2.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+setiastrosuitepro-1.7.0.post2.dist-info/licenses/license.txt,sha256=KCwYZ9VpVwmzjelDq1BzzWqpBvt9nbbapa-woz47hfQ,123930
+setiastrosuitepro-1.7.0.post2.dist-info/METADATA,sha256=ObLW50Nm7d43lX3bqkwNRrRjwv51_0dEY52ebyNFHW0,9840
+setiastrosuitepro-1.7.0.post2.dist-info/WHEEL,sha256=zp0Cn7JsFoX2ATtOhtaFYIiE2rmFAD4OcMhtUki8W3U,88
+setiastrosuitepro-1.7.0.post2.dist-info/RECORD,,