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

setiastro/saspro/mfdeconv.py

@@ -250,14 +250,20 @@ def _probe_hw(path: str) -> tuple[int, int, int | None]:
     raise ValueError(f"Unsupported ndim={a.ndim} for {path}")
 
 def _common_hw_from_paths(paths: list[str]) -> tuple[int, int]:
-    """
-    Replacement for the old FITS-only version: min(H), min(W) across files.
-    """
     Hs, Ws = [], []
     for p in paths:
         h, w, _ = _probe_hw(p)
-        Hs.append(int(h)); Ws.append(int(w))
-    return int(min(Hs)), int(min(Ws))
+        h = int(h); w = int(w)
+        if h > 0 and w > 0:
+            Hs.append(h); Ws.append(w)
+
+    if not Hs:
+        raise ValueError("Could not determine any valid frame sizes.")
+    Ht = min(Hs); Wt = min(Ws)
+    if Ht < 8 or Wt < 8:
+        raise ValueError(f"Intersection too small: {Ht}x{Wt}")
+    return Ht, Wt
+
 
 def _to_chw_float32(img: np.ndarray, color_mode: str) -> np.ndarray:
     """
@@ -367,22 +373,36 @@ def _compute_frame_assets(i, arr, hdr, *, make_masks, make_varmaps,
         f_whm = 2.5
     k_auto = _auto_ksize_from_fwhm(f_whm)
 
-    # --- Star-derived PSF with retries ---
-    tried, psf = [], None
-    for k_try in [k_auto, max(k_auto - 4, 11), 21, 17, 15, 13, 11]:
-        if k_try in tried: continue
-        tried.append(k_try)
-        try:
-            out = compute_psf_kernel_for_image(arr, ksize=k_try, det_sigma=6.0, max_stars=80)
-            psf_try = out[0] if (isinstance(out, tuple) and len(out) >= 1) else out
-            if psf_try is not None:
-                psf = psf_try
-                break
-        except Exception:
-            psf = None
+    # --- Star-derived PSF with retries (dynamic det_sigma ladder) ---
+    psf = None
+
+    # Your existing ksize ladder
+    k_ladder = [k_auto, max(k_auto - 4, 11), 21, 17, 15, 13, 11]
+
+    # New: start high to avoid detecting 10k stars; step down only if needed
+    sigma_ladder = [50.0, 25.0, 12.0, 6.0]
+
+    tried = set()
+    for det_sigma in sigma_ladder:
+        for k_try in k_ladder:
+            if (det_sigma, k_try) in tried:
+                continue
+            tried.add((det_sigma, k_try))
+            try:
+                out = compute_psf_kernel_for_image(arr, ksize=k_try, det_sigma=det_sigma, max_stars=80)
+                psf_try = out[0] if (isinstance(out, tuple) and len(out) >= 1) else out
+                if psf_try is not None:
+                    psf = psf_try
+                    break
+            except Exception:
+                psf = None
+        if psf is not None:
+            break
+
     if psf is None:
         psf = _gaussian_psf(f_whm, ksize=k_auto)
-    psf = _soften_psf(_normalize_psf(psf.astype(np.float32, copy=False)), sigma_px=0.0)
+
+    psf = _soften_psf(_normalize_psf(psf.astype(np.float32, copy=False)), sigma_px=0.25)
 
     mask = None
     var  = None
@@ -425,6 +445,7 @@ def _compute_frame_assets(i, arr, hdr, *, make_masks, make_varmaps,
 
     return i, psf, mask, var, logs
 
+
 def _compute_one_worker(args):
     """
     Top-level picklable worker for ProcessPoolExecutor.
@@ -1039,25 +1060,82 @@ SOFT_SIGMA          = 2.0
 ELLIPSE_SCALE       = 1.2
 
 def _sep_background_precompute(img_2d: np.ndarray, bw: int = 64, bh: int = 64):
-    """One-time SEP background build; returns (sky_map, rms_map, err_scalar)."""
+    """
+    One-time SEP background build; returns (sky_map, rms_map, err_scalar).
+
+    Guarantees:
+      - Always returns a 3-tuple (sky, rms, err)
+      - sky/rms are float32 and same shape as img_2d
+      - Robust to sep missing, sep errors, NaNs/Infs, and tiny frames
+    """
+    a = np.asarray(img_2d, dtype=np.float32)
+    if a.ndim != 2:
+        # be strict; callers expect 2D
+        raise ValueError(f"_sep_background_precompute expects 2D, got shape={a.shape}")
+
+    H, W = int(a.shape[0]), int(a.shape[1])
+    if H == 0 or W == 0:
+        # should never happen, but don't return empty tuple
+        sky = np.zeros((H, W), dtype=np.float32)
+        rms = np.ones((H, W), dtype=np.float32)
+        return sky, rms, 1.0
+
+    # --- robust fallback builder (works for any input) ---
+    def _fallback():
+        # Use finite-only stats if possible
+        finite = np.isfinite(a)
+        if finite.any():
+            vals = a[finite]
+            med = float(np.median(vals))
+            mad = float(np.median(np.abs(vals - med))) + 1e-6
+        else:
+            med = 0.0
+            mad = 1.0
+        sky = np.full((H, W), med, dtype=np.float32)
+        rms = np.full((H, W), 1.4826 * mad, dtype=np.float32)
+        err = float(np.median(rms))
+        return sky, rms, err
+
+    # If sep isn't available, always fallback
     if sep is None:
-        # robust fallback
-        med = float(np.median(img_2d))
-        mad = float(np.median(np.abs(img_2d - med))) + 1e-6
-        sky  = np.full_like(img_2d, med, dtype=np.float32)
-        rmsm = np.full_like(img_2d, 1.4826 * mad, dtype=np.float32)
-        return sky, rmsm, float(np.median(rmsm))
-
-    a = np.ascontiguousarray(img_2d.astype(np.float32))
-    b = sep.Background(a, bw=int(bw), bh=int(bh), fw=3, fh=3)
-    sky  = np.asarray(b.back(), dtype=np.float32)
+        return _fallback()
+
+    # SEP is present: sanitize input and clamp tile sizes
+    # sep can choke on NaNs/Infs
+    if not np.isfinite(a).all():
+        # replace non-finite with median of finite values (or 0)
+        finite = np.isfinite(a)
+        fill = float(np.median(a[finite])) if finite.any() else 0.0
+        a = np.where(finite, a, fill).astype(np.float32, copy=False)
+
+    a = np.ascontiguousarray(a, dtype=np.float32)
+
+    # Clamp bw/bh to image size; SEP doesn't like bw/bh > dims
+    bw = int(max(8, min(int(bw), W)))
+    bh = int(max(8, min(int(bh), H)))
+
     try:
-        rmsm = np.asarray(b.rms(), dtype=np.float32)
-        err  = float(b.globalrms)
+        b = sep.Background(a, bw=bw, bh=bh, fw=3, fh=3)
+
+        sky = np.asarray(b.back(), dtype=np.float32)
+        rms = np.asarray(b.rms(), dtype=np.float32)
+
+        # Ensure shape sanity (SEP should match, but be paranoid)
+        if sky.shape != a.shape or rms.shape != a.shape:
+            return _fallback()
+
+        # globalrms sometimes isn't available depending on SEP build
+        err = float(getattr(b, "globalrms", np.nan))
+        if not np.isfinite(err) or err <= 0:
+            # robust scalar: median rms
+            err = float(np.median(rms)) if rms.size else 1.0
+
+        return sky, rms, err
+
     except Exception:
-        rmsm = np.full_like(a, float(np.median(b.rms())), dtype=np.float32)
-        err  = float(np.median(rmsm))
-    return sky, rmsm, err
+        # If SEP blows up for any reason, degrade gracefully
+        return _fallback()
+
 
 
 def _auto_star_mask_sep(

setiastro/saspro/mfdeconvcudnn.py

@@ -311,14 +311,20 @@ def _probe_hw(path: str) -> tuple[int, int, int | None]:
     raise ValueError(f"Unsupported ndim={a.ndim} for {path}")
 
 def _common_hw_from_paths(paths: list[str]) -> tuple[int, int]:
-    """
-    Replacement for the old FITS-only version: min(H), min(W) across files.
-    """
     Hs, Ws = [], []
     for p in paths:
         h, w, _ = _probe_hw(p)
-        Hs.append(int(h)); Ws.append(int(w))
-    return int(min(Hs)), int(min(Ws))
+        h = int(h); w = int(w)
+        if h > 0 and w > 0:
+            Hs.append(h); Ws.append(w)
+
+    if not Hs:
+        raise ValueError("Could not determine any valid frame sizes.")
+    Ht = min(Hs); Wt = min(Ws)
+    if Ht < 8 or Wt < 8:
+        raise ValueError(f"Intersection too small: {Ht}x{Wt}")
+    return Ht, Wt
+
 
 def _to_chw_float32(img: np.ndarray, color_mode: str) -> np.ndarray:
     """
@@ -395,15 +401,12 @@ def _safe_primary_header(path: str) -> fits.Header:
     except Exception:
         return fits.Header()
 
-
 def _compute_frame_assets(i, arr, hdr, *, make_masks, make_varmaps,
                           star_mask_cfg, varmap_cfg, status_sink=lambda s: None):
     """
     Worker function: compute PSF and optional star mask / varmap for one frame.
-    Returns (index, psf, mask_or_None, var_or_None, var_path_or_None, log_lines)
+    Returns (index, psf, mask_or_None, var_or_None, log_lines)
     """
-
-
     logs = []
     def log(s): logs.append(s)
 
@@ -415,36 +418,48 @@ def _compute_frame_assets(i, arr, hdr, *, make_masks, make_varmaps,
         f_whm = 2.5
     k_auto = _auto_ksize_from_fwhm(f_whm)
 
-    # --- Star-derived PSF with retries ---
-    tried, psf = [], None
-    for k_try in [k_auto, max(k_auto - 4, 11), 21, 17, 15, 13, 11]:
-        if k_try in tried:
-            continue
-        tried.append(k_try)
-        try:
-            out = compute_psf_kernel_for_image(arr, ksize=k_try, det_sigma=6.0, max_stars=80)
-            psf_try = out[0] if (isinstance(out, tuple) and len(out) >= 1) else out
-            if psf_try is not None:
-                psf = psf_try
-                break
-        except Exception:
-            psf = None
+    # --- Star-derived PSF with retries (dynamic det_sigma ladder) ---
+    psf = None
+
+    # Your existing ksize ladder
+    k_ladder = [k_auto, max(k_auto - 4, 11), 21, 17, 15, 13, 11]
+
+    # New: start high to avoid detecting 10k stars; step down only if needed
+    sigma_ladder = [50.0, 25.0, 12.0, 6.0]
+
+    tried = set()
+    for det_sigma in sigma_ladder:
+        for k_try in k_ladder:
+            if (det_sigma, k_try) in tried:
+                continue
+            tried.add((det_sigma, k_try))
+            try:
+                out = compute_psf_kernel_for_image(arr, ksize=k_try, det_sigma=det_sigma, max_stars=80)
+                psf_try = out[0] if (isinstance(out, tuple) and len(out) >= 1) else out
+                if psf_try is not None:
+                    psf = psf_try
+                    break
+            except Exception:
+                psf = None
+        if psf is not None:
+            break
+
     if psf is None:
         psf = _gaussian_psf(f_whm, ksize=k_auto)
+
     psf = _soften_psf(_normalize_psf(psf.astype(np.float32, copy=False)), sigma_px=0.25)
 
     mask = None
     var  = None
-    var_path = None
 
     if make_masks or make_varmaps:
+        # one background per frame (reused by both)
         luma = _to_luma_local(arr)
         vmc = (varmap_cfg or {})
         sky_map, rms_map, err_scalar = _sep_background_precompute(
             luma, bw=int(vmc.get("bw", 64)), bh=int(vmc.get("bh", 64))
         )
 
-        # ---------- Star mask ----------
         if make_masks:
             smc = star_mask_cfg or {}
             mask = _star_mask_from_precomputed(
@@ -459,44 +474,22 @@ def _compute_frame_assets(i, arr, hdr, *, make_masks, make_varmaps,
                 max_side     = smc.get("max_side", STAR_MASK_MAXSIDE),
                 status_cb    = log,
             )
-            # keep masks compact
-            if mask is not None and mask.dtype != np.uint8:
-                mask = (mask > 0.5).astype(np.uint8, copy=False)
 
-        # ---------- Variance map (memmap path; Option B) ----------
         if make_varmaps:
             vmc = varmap_cfg or {}
-            def _vprog(frac: float, msg: str = ""):
-                try: log(f"__PROGRESS__ {0.16 + 0.02*float(frac):.4f} {msg}")
-                except Exception as e:
-                    import logging
-                    logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
-
-            var_path = _variance_map_from_precomputed_memmap(
+            var = _variance_map_from_precomputed(
                 luma, sky_map, rms_map, hdr,
-                smooth_sigma = float(vmc.get("smooth_sigma", 1.0)),
-                floor        = float(vmc.get("floor", 1e-8)),
-                tile_hw      = tuple(vmc.get("tile_hw", (512, 512))),
-                scratch_dir  = vmc.get("scratch_dir", None),
-                tag          = f"varmap_{i:04d}",
+                smooth_sigma = vmc.get("smooth_sigma", 1.0),
+                floor        = vmc.get("floor", 1e-8),
                 status_cb    = log,
-                progress_cb  = _vprog,
             )
-            var = None  # Option B: don't keep an open memmap handle
-
-        # 🔻 free heavy temporaries immediately
-        try:
-            del luma
-            del sky_map
-            del rms_map
-        except Exception:
-            pass
-        gc.collect()
 
-    # per-frame summary
+    # small per-frame summary
     fwhm_est = _psf_fwhm_px(psf)
     logs.insert(0, f"MFDeconv: PSF{i}: ksize={psf.shape[0]} | FWHM≈{fwhm_est:.2f}px")
-    return i, psf, mask, var, var_path, logs
+
+    return i, psf, mask, var, logs
+
 
 def _compute_one_worker(args):
     """
@@ -1186,25 +1179,81 @@ SOFT_SIGMA          = 2.0
 ELLIPSE_SCALE       = 1.2
 
 def _sep_background_precompute(img_2d: np.ndarray, bw: int = 64, bh: int = 64):
-    """One-time SEP background build; returns (sky_map, rms_map, err_scalar)."""
+    """
+    One-time SEP background build; returns (sky_map, rms_map, err_scalar).
+
+    Guarantees:
+      - Always returns a 3-tuple (sky, rms, err)
+      - sky/rms are float32 and same shape as img_2d
+      - Robust to sep missing, sep errors, NaNs/Infs, and tiny frames
+    """
+    a = np.asarray(img_2d, dtype=np.float32)
+    if a.ndim != 2:
+        # be strict; callers expect 2D
+        raise ValueError(f"_sep_background_precompute expects 2D, got shape={a.shape}")
+
+    H, W = int(a.shape[0]), int(a.shape[1])
+    if H == 0 or W == 0:
+        # should never happen, but don't return empty tuple
+        sky = np.zeros((H, W), dtype=np.float32)
+        rms = np.ones((H, W), dtype=np.float32)
+        return sky, rms, 1.0
+
+    # --- robust fallback builder (works for any input) ---
+    def _fallback():
+        # Use finite-only stats if possible
+        finite = np.isfinite(a)
+        if finite.any():
+            vals = a[finite]
+            med = float(np.median(vals))
+            mad = float(np.median(np.abs(vals - med))) + 1e-6
+        else:
+            med = 0.0
+            mad = 1.0
+        sky = np.full((H, W), med, dtype=np.float32)
+        rms = np.full((H, W), 1.4826 * mad, dtype=np.float32)
+        err = float(np.median(rms))
+        return sky, rms, err
+
+    # If sep isn't available, always fallback
     if sep is None:
-        # robust fallback
-        med = float(np.median(img_2d))
-        mad = float(np.median(np.abs(img_2d - med))) + 1e-6
-        sky  = np.full_like(img_2d, med, dtype=np.float32)
-        rmsm = np.full_like(img_2d, 1.4826 * mad, dtype=np.float32)
-        return sky, rmsm, float(np.median(rmsm))
-
-    a = np.ascontiguousarray(img_2d.astype(np.float32))
-    b = sep.Background(a, bw=int(bw), bh=int(bh), fw=3, fh=3)
-    sky  = np.asarray(b.back(), dtype=np.float32)
+        return _fallback()
+
+    # SEP is present: sanitize input and clamp tile sizes
+    # sep can choke on NaNs/Infs
+    if not np.isfinite(a).all():
+        # replace non-finite with median of finite values (or 0)
+        finite = np.isfinite(a)
+        fill = float(np.median(a[finite])) if finite.any() else 0.0
+        a = np.where(finite, a, fill).astype(np.float32, copy=False)
+
+    a = np.ascontiguousarray(a, dtype=np.float32)
+
+    # Clamp bw/bh to image size; SEP doesn't like bw/bh > dims
+    bw = int(max(8, min(int(bw), W)))
+    bh = int(max(8, min(int(bh), H)))
+
     try:
-        rmsm = np.asarray(b.rms(), dtype=np.float32)
-        err  = float(b.globalrms)
+        b = sep.Background(a, bw=bw, bh=bh, fw=3, fh=3)
+
+        sky = np.asarray(b.back(), dtype=np.float32)
+        rms = np.asarray(b.rms(), dtype=np.float32)
+
+        # Ensure shape sanity (SEP should match, but be paranoid)
+        if sky.shape != a.shape or rms.shape != a.shape:
+            return _fallback()
+
+        # globalrms sometimes isn't available depending on SEP build
+        err = float(getattr(b, "globalrms", np.nan))
+        if not np.isfinite(err) or err <= 0:
+            # robust scalar: median rms
+            err = float(np.median(rms)) if rms.size else 1.0
+
+        return sky, rms, err
+
     except Exception:
-        rmsm = np.full_like(a, float(np.median(b.rms())), dtype=np.float32)
-        err  = float(np.median(rmsm))
-    return sky, rmsm, err
+        # If SEP blows up for any reason, degrade gracefully
+        return _fallback()
 
 
 def _star_mask_from_precomputed(

setiastro/saspro/mfdeconvsport.py

@@ -278,14 +278,20 @@ def _probe_hw(path: str) -> tuple[int, int, int | None]:
     raise ValueError(f"Unsupported ndim={a.ndim} for {path}")
 
 def _common_hw_from_paths(paths: list[str]) -> tuple[int, int]:
-    """
-    Replacement for the old FITS-only version: min(H), min(W) across files.
-    """
     Hs, Ws = [], []
     for p in paths:
         h, w, _ = _probe_hw(p)
-        Hs.append(int(h)); Ws.append(int(w))
-    return int(min(Hs)), int(min(Ws))
+        h = int(h); w = int(w)
+        if h > 0 and w > 0:
+            Hs.append(h); Ws.append(w)
+
+    if not Hs:
+        raise ValueError("Could not determine any valid frame sizes.")
+    Ht = min(Hs); Wt = min(Ws)
+    if Ht < 8 or Wt < 8:
+        raise ValueError(f"Intersection too small: {Ht}x{Wt}")
+    return Ht, Wt
+
 
 def _to_chw_float32(img: np.ndarray, color_mode: str) -> np.ndarray:
     """
@@ -362,7 +368,6 @@ def _safe_primary_header(path: str) -> fits.Header:
     except Exception:
         return fits.Header()
 
-
 def _compute_frame_assets(i, arr, hdr, *, make_masks, make_varmaps,
                           star_mask_cfg, varmap_cfg, status_sink=lambda s: None):
     """
@@ -380,21 +385,35 @@ def _compute_frame_assets(i, arr, hdr, *, make_masks, make_varmaps,
         f_whm = 2.5
     k_auto = _auto_ksize_from_fwhm(f_whm)
 
-    # --- Star-derived PSF with retries ---
-    tried, psf = [], None
-    for k_try in [k_auto, max(k_auto - 4, 11), 21, 17, 15, 13, 11]:
-        if k_try in tried: continue
-        tried.append(k_try)
-        try:
-            out = compute_psf_kernel_for_image(arr, ksize=k_try, det_sigma=6.0, max_stars=80)
-            psf_try = out[0] if (isinstance(out, tuple) and len(out) >= 1) else out
-            if psf_try is not None:
-                psf = psf_try
-                break
-        except Exception:
-            psf = None
+    # --- Star-derived PSF with retries (dynamic det_sigma ladder) ---
+    psf = None
+
+    # Your existing ksize ladder
+    k_ladder = [k_auto, max(k_auto - 4, 11), 21, 17, 15, 13, 11]
+
+    # New: start high to avoid detecting 10k stars; step down only if needed
+    sigma_ladder = [50.0, 25.0, 12.0, 6.0]
+
+    tried = set()
+    for det_sigma in sigma_ladder:
+        for k_try in k_ladder:
+            if (det_sigma, k_try) in tried:
+                continue
+            tried.add((det_sigma, k_try))
+            try:
+                out = compute_psf_kernel_for_image(arr, ksize=k_try, det_sigma=det_sigma, max_stars=80)
+                psf_try = out[0] if (isinstance(out, tuple) and len(out) >= 1) else out
+                if psf_try is not None:
+                    psf = psf_try
+                    break
+            except Exception:
+                psf = None
+        if psf is not None:
+            break
+
     if psf is None:
         psf = _gaussian_psf(f_whm, ksize=k_auto)
+
     psf = _soften_psf(_normalize_psf(psf.astype(np.float32, copy=False)), sigma_px=0.25)
 
     mask = None
@@ -438,6 +457,7 @@ def _compute_frame_assets(i, arr, hdr, *, make_masks, make_varmaps,
 
     return i, psf, mask, var, logs
 
+
 def _compute_one_worker(args):
     """
     Top-level picklable worker for ProcessPoolExecutor.
@@ -1026,25 +1046,82 @@ SOFT_SIGMA          = 2.0
 ELLIPSE_SCALE       = 1.2
 
 def _sep_background_precompute(img_2d: np.ndarray, bw: int = 64, bh: int = 64):
-    """One-time SEP background build; returns (sky_map, rms_map, err_scalar)."""
+    """
+    One-time SEP background build; returns (sky_map, rms_map, err_scalar).
+
+    Guarantees:
+      - Always returns a 3-tuple (sky, rms, err)
+      - sky/rms are float32 and same shape as img_2d
+      - Robust to sep missing, sep errors, NaNs/Infs, and tiny frames
+    """
+    a = np.asarray(img_2d, dtype=np.float32)
+    if a.ndim != 2:
+        # be strict; callers expect 2D
+        raise ValueError(f"_sep_background_precompute expects 2D, got shape={a.shape}")
+
+    H, W = int(a.shape[0]), int(a.shape[1])
+    if H == 0 or W == 0:
+        # should never happen, but don't return empty tuple
+        sky = np.zeros((H, W), dtype=np.float32)
+        rms = np.ones((H, W), dtype=np.float32)
+        return sky, rms, 1.0
+
+    # --- robust fallback builder (works for any input) ---
+    def _fallback():
+        # Use finite-only stats if possible
+        finite = np.isfinite(a)
+        if finite.any():
+            vals = a[finite]
+            med = float(np.median(vals))
+            mad = float(np.median(np.abs(vals - med))) + 1e-6
+        else:
+            med = 0.0
+            mad = 1.0
+        sky = np.full((H, W), med, dtype=np.float32)
+        rms = np.full((H, W), 1.4826 * mad, dtype=np.float32)
+        err = float(np.median(rms))
+        return sky, rms, err
+
+    # If sep isn't available, always fallback
     if sep is None:
-        # robust fallback
-        med = float(np.median(img_2d))
-        mad = float(np.median(np.abs(img_2d - med))) + 1e-6
-        sky  = np.full_like(img_2d, med, dtype=np.float32)
-        rmsm = np.full_like(img_2d, 1.4826 * mad, dtype=np.float32)
-        return sky, rmsm, float(np.median(rmsm))
-
-    a = np.ascontiguousarray(img_2d.astype(np.float32))
-    b = sep.Background(a, bw=int(bw), bh=int(bh), fw=3, fh=3)
-    sky  = np.asarray(b.back(), dtype=np.float32)
+        return _fallback()
+
+    # SEP is present: sanitize input and clamp tile sizes
+    # sep can choke on NaNs/Infs
+    if not np.isfinite(a).all():
+        # replace non-finite with median of finite values (or 0)
+        finite = np.isfinite(a)
+        fill = float(np.median(a[finite])) if finite.any() else 0.0
+        a = np.where(finite, a, fill).astype(np.float32, copy=False)
+
+    a = np.ascontiguousarray(a, dtype=np.float32)
+
+    # Clamp bw/bh to image size; SEP doesn't like bw/bh > dims
+    bw = int(max(8, min(int(bw), W)))
+    bh = int(max(8, min(int(bh), H)))
+
     try:
-        rmsm = np.asarray(b.rms(), dtype=np.float32)
-        err  = float(b.globalrms)
+        b = sep.Background(a, bw=bw, bh=bh, fw=3, fh=3)
+
+        sky = np.asarray(b.back(), dtype=np.float32)
+        rms = np.asarray(b.rms(), dtype=np.float32)
+
+        # Ensure shape sanity (SEP should match, but be paranoid)
+        if sky.shape != a.shape or rms.shape != a.shape:
+            return _fallback()
+
+        # globalrms sometimes isn't available depending on SEP build
+        err = float(getattr(b, "globalrms", np.nan))
+        if not np.isfinite(err) or err <= 0:
+            # robust scalar: median rms
+            err = float(np.median(rms)) if rms.size else 1.0
+
+        return sky, rms, err
+
     except Exception:
-        rmsm = np.full_like(a, float(np.median(b.rms())), dtype=np.float32)
-        err  = float(np.median(rmsm))
-    return sky, rmsm, err
+        # If SEP blows up for any reason, degrade gracefully
+        return _fallback()
+
 
 
 def _star_mask_from_precomputed(

setiastro/saspro/morphology.py

@@ -94,6 +94,10 @@ class MorphologyDialogPro(QDialog):
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions        
         if icon:
             try: self.setWindowIcon(icon)
             except Exception as e: