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

setiastro/saspro/sfcc.py

@@ -20,6 +20,7 @@ from datetime import datetime
 from typing import List, Tuple, Optional
 
 import numpy as np
+import numpy.ma as ma
 import pandas as pd
 
 # ── SciPy bits
@@ -32,6 +33,7 @@ from astropy.wcs import WCS
 import astropy.units as u
 from astropy.coordinates import SkyCoord
 from astroquery.simbad import Simbad
+from astropy.wcs.wcs import NoConvergence
 
 # ── SEP (Source Extractor)
 import sep
@@ -48,6 +50,9 @@ from PyQt6.QtWidgets import (QToolBar, QWidget, QToolButton, QMenu, QApplication
                              QInputDialog, QMessageBox, QDialog, QFileDialog,
     QFormLayout, QDialogButtonBox, QDoubleSpinBox, QCheckBox, QLabel, QRubberBand, QRadioButton, QMainWindow, QPushButton)
 
+from setiastro.saspro.backgroundneutral import run_background_neutral_via_preset
+from setiastro.saspro.backgroundneutral import background_neutralize_rgb, auto_rect_50x50
+
 
 # ──────────────────────────────────────────────────────────────────────────────
 # Utilities
@@ -188,6 +193,12 @@ def compute_gradient_map(sources, delta_flux, shape, method="poly2"):
     else:
         raise ValueError("method must be one of 'poly2','poly3','rbf'")
 
+def _pivot_scale_channel(ch: np.ndarray, gain: np.ndarray | float, pivot: float) -> np.ndarray:
+    """
+    Apply gain around a pivot: pivot + (x - pivot)*gain.
+    gain can be scalar or per-pixel array.
+    """
+    return pivot + (ch - pivot) * gain
 
 # ──────────────────────────────────────────────────────────────────────────────
 # Simple responses viewer (unchanged core logic; useful for diagnostics)
@@ -875,32 +886,190 @@ class SFCCDialog(QDialog):
         return self.wcs.all_pix2world(x, y, 0)
 
     # ── Background neutralization ───────────────────────────────────────
+    def _neutralize_background(self, rgb_f: np.ndarray, *, remove_pedestal: bool = False) -> np.ndarray:
+        img = np.asarray(rgb_f, dtype=np.float32)
 
-    def _neutralize_background(self, rgb_img: np.ndarray, patch_size: int = 50) -> np.ndarray:
-        img = rgb_img.copy()
+        if img.ndim != 3 or img.shape[2] != 3:
+            raise ValueError("Expected RGB image (H,W,3)")
+
+        img = np.clip(img, 0.0, 1.0)
+
+        try:
+            rect = auto_rect_50x50(img)  # same SASv2-ish auto finder
+            out = background_neutralize_rgb(
+                img,
+                rect,
+                mode="pivot1",                # or "offset" if you prefer
+                remove_pedestal=remove_pedestal,
+            )
+            return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
+        except Exception as e:
+            print(f"[SFCC] BN preset failed, falling back to simple neutralization: {e}")
+            return self._neutralize_background_simple(img, patch_size=10)
+
+    def _neutralize_background_simple(self, rgb_f: np.ndarray, patch_size: int = 50) -> np.ndarray:
+        """
+        Simple neutralization: find darkest patch by summed medians,
+        then equalize channel medians around the mean.
+        Assumes rgb_f is float in [0,1] with no negatives.
+        """
+        img = np.asarray(rgb_f, dtype=np.float32).copy()
         h, w = img.shape[:2]
-        ph, pw = h // patch_size, w // patch_size
+        ph, pw = max(1, h // patch_size), max(1, w // patch_size)
+
         min_sum, best_med = np.inf, None
         for i in range(patch_size):
             for j in range(patch_size):
                 y0, x0 = i * ph, j * pw
-                patch = img[y0:min(y0+ph, h), x0:min(x0+pw, w), :]
-                med   = np.median(patch, axis=(0, 1))
-                s     = med.sum()
+                patch = img[y0:min(y0 + ph, h), x0:min(x0 + pw, w), :]
+                if patch.size == 0:
+                    continue
+                med = np.median(patch, axis=(0, 1))
+                s = float(med.sum())
                 if s < min_sum:
                     min_sum, best_med = s, med
+
         if best_med is None:
-            return img
-        target = float(best_med.mean()); eps = 1e-8
+            return np.clip(img, 0.0, 1.0)
+
+        target = float(best_med.mean())
+        eps = 1e-8
         for c in range(3):
             diff = float(best_med[c] - target)
-            if abs(diff) < eps: continue
+            if abs(diff) < eps:
+                continue
+            # Preserve [0,1] scale; keep the same form you were using.
             img[..., c] = np.clip((img[..., c] - diff) / (1.0 - diff), 0.0, 1.0)
-        return img
+
+        return np.clip(img, 0.0, 1.0)
+
+    def _make_working_base_for_sep(self, img_float: np.ndarray) -> np.ndarray:
+        """
+        Build a working copy for SEP + calibration.
+
+        Pedestal removal (per channel):
+            ch <- ch - min(ch)
+
+        Then clamp to [0,1] for stability.
+        """
+        base = np.asarray(img_float, dtype=np.float32).copy()
+
+        if base.ndim != 3 or base.shape[2] != 3:
+            raise ValueError("Expected RGB image (H,W,3)")
+
+        # --- Per-channel pedestal removal: ch -= min(ch) ---
+        mins = base.reshape(-1, 3).min(axis=0)  # (3,)
+        base[..., 0] -= float(mins[0])
+        base[..., 1] -= float(mins[1])
+        base[..., 2] -= float(mins[2])
+
+        # Stability clamp (SEP likes non-negative; your pipeline assumes [0,1])
+        base = np.clip(base, 0.0, 1.0)
+
+        return base
+
 
     # ── SIMBAD/Star fetch ──────────────────────────────────────────────
+    def initialize_wcs_from_header(self, header):
+        """
+        Build a robust 2D celestial WCS from the provided header.
+
+        - Normalizes deprecated RADECSYS/EPOCH keywords.
+        - Uses relax=True.
+        - Stores:
+            self.wcs (WCS)
+            self.wcs_header (fits.Header)
+            self.pixscale (arcsec/pixel approx)
+            self.center_ra, self.center_dec (deg)
+            self.orientation (deg, if derivable)
+        """
+        if header is None:
+            print("[SFCC] No FITS header available; cannot build WCS.")
+            self.wcs = None
+            return
+
+        try:
+            hdr = header.copy()
+
+            # --- normalize deprecated keywords ---
+            if "RADECSYS" in hdr and "RADESYS" not in hdr:
+                radesys_val = str(hdr["RADECSYS"]).strip()
+                hdr["RADESYS"] = radesys_val
+                try:
+                    del hdr["RADECSYS"]
+                except Exception:
+                    pass
+
+                # Carry to alternate WCS letters if present (CTYPE1A, CTYPE2A, etc.)
+                alt_letters = {
+                    k[-1]
+                    for k in hdr.keys()
+                    if re.match(r"^CTYPE[12][A-Z]$", k)
+                }
+                for a in alt_letters:
+                    key = f"RADESYS{a}"
+                    if key not in hdr:
+                        hdr[key] = radesys_val
+
+            if "EPOCH" in hdr and "EQUINOX" not in hdr:
+                hdr["EQUINOX"] = hdr["EPOCH"]
+                try:
+                    del hdr["EPOCH"]
+                except Exception:
+                    pass
+
+            # Build WCS
+            self.wcs = WCS(hdr, naxis=2, relax=True)
+
+            # Pixel scale estimate (arcsec/px) from pixel_scale_matrix if available
+            try:
+                psm = self.wcs.pixel_scale_matrix
+                self.pixscale = float(np.hypot(psm[0, 0], psm[1, 0]) * 3600.0)
+            except Exception:
+                self.pixscale = None
+
+            # CRVAL center
+            try:
+                self.center_ra, self.center_dec = [float(x) for x in self.wcs.wcs.crval]
+            except Exception:
+                self.center_ra, self.center_dec = None, None
+
+            # Save normalized header form
+            try:
+                self.wcs_header = self.wcs.to_header(relax=True)
+            except Exception:
+                self.wcs_header = None
+
+            # Orientation (optional)
+            if "CROTA2" in hdr:
+                try:
+                    self.orientation = float(hdr["CROTA2"])
+                except Exception:
+                    self.orientation = None
+            else:
+                self.orientation = self.calculate_orientation(hdr)
+
+            if getattr(self, "orientation_label", None) is not None:
+                if self.orientation is not None:
+                    self.orientation_label.setText(f"Orientation: {self.orientation:.2f}°")
+                else:
+                    self.orientation_label.setText("Orientation: N/A")
+
+        except Exception as e:
+            print("[SFCC] WCS initialization error:\n", e)
+            self.wcs = None
+
 
     def fetch_stars(self):
+        import time
+        from astropy.coordinates import SkyCoord
+        import astropy.units as u
+        from astropy.wcs.wcs import NoConvergence
+        from astroquery.simbad import Simbad
+        from astropy.io import fits
+        from PyQt6.QtWidgets import QMessageBox, QApplication
+
         # 0) Grab current image + header from the active document
         img, hdr, _meta = self._get_active_image_and_header()
         self.current_image = img
@@ -916,7 +1085,7 @@ class SFCCDialog(QDialog):
             self.pickles_templates = []
             for p in (self.user_custom_path, self.sasp_data_path):
                 try:
-                    with fits.open(p) as hd:
+                    with fits.open(p, memmap=False) as hd:
                         for hdu in hd:
                             if (isinstance(hdu, fits.BinTableHDU)
                                     and hdu.header.get("CTYPE", "").upper() == "SED"):
@@ -924,118 +1093,252 @@ class SFCCDialog(QDialog):
                                 if extname and extname not in self.pickles_templates:
                                     self.pickles_templates.append(extname)
                 except Exception as e:
-                    print(f"[fetch_stars] Could not load Pickles templates from {p}: {e}")
+                    print(f"[SFCC] [fetch_stars] Could not load Pickles templates from {p}: {e}")
+            self.pickles_templates.sort()
 
         # Build WCS
         try:
             self.initialize_wcs_from_header(self.current_header)
         except Exception:
-            QMessageBox.critical(self, "WCS Error", "Could not build a 2D WCS from header."); return
+            QMessageBox.critical(self, "WCS Error", "Could not build a 2D WCS from header.")
+            return
+
+        if not getattr(self, "wcs", None):
+            QMessageBox.critical(self, "WCS Error", "Could not build a 2D WCS from header.")
+            return
+
+        # Use celestial WCS if possible (safe when WCS has extra axes)
+        wcs2 = self.wcs.celestial if hasattr(self.wcs, "celestial") else self.wcs
 
         H, W = self.current_image.shape[:2]
-        pix = np.array([[W/2, H/2], [0,0], [W,0], [0,H], [W,H]])
+
+        # --- original radius method (center + 4 corners) ---
+        pix = np.array([[W / 2, H / 2], [0, 0], [W, 0], [0, H], [W, H]], dtype=float)
         try:
-            sky = self.wcs.all_pix2world(pix, 0)
+            sky = wcs2.all_pix2world(pix, 0)
         except Exception as e:
-            QMessageBox.critical(self, "WCS Conversion Error", str(e)); return
-        center_sky  = SkyCoord(ra=sky[0,0]*u.deg, dec=sky[0,1]*u.deg, frame="icrs")
-        corners_sky = SkyCoord(ra=sky[1:,0]*u.deg, dec=sky[1:,1]*u.deg, frame="icrs")
-        radius_deg  = center_sky.separation(corners_sky).max().deg
+            QMessageBox.critical(self, "WCS Conversion Error", str(e))
+            return
 
-        # Simbad fields
+        center_sky = SkyCoord(ra=float(sky[0, 0]) * u.deg, dec=float(sky[0, 1]) * u.deg, frame="icrs")
+        corners_sky = SkyCoord(ra=sky[1:, 0] * u.deg, dec=sky[1:, 1] * u.deg, frame="icrs")
+        radius = center_sky.separation(corners_sky).max() * 1.05  # small margin
+
+        # --- SIMBAD fields (NEW first, fallback to legacy) ---
         Simbad.reset_votable_fields()
-        for attempt in range(1, 6):
+
+        def _try_new_fields():
+            # new names: B,V,R + ra,dec
+            Simbad.add_votable_fields("sp", "B", "V", "R", "ra", "dec")
+
+        def _try_legacy_fields():
+            # legacy names
+            Simbad.add_votable_fields("sp", "flux(B)", "flux(V)", "flux(R)", "ra(d)", "dec(d)")
+
+        ok = False
+        for _ in range(5):
             try:
-                Simbad.add_votable_fields('sp', 'flux(B)', 'flux(V)', 'flux(R)')
+                _try_new_fields()
+                ok = True
                 break
             except Exception:
                 QApplication.processEvents()
-                time.sleep(1.2)
+                time.sleep(0.8)
+
+        if not ok:
+            for _ in range(5):
+                try:
+                    _try_legacy_fields()
+                    ok = True
+                    break
+                except Exception:
+                    QApplication.processEvents()
+                    time.sleep(0.8)
+
+        if not ok:
+            QMessageBox.critical(self, "SIMBAD Error", "Could not configure SIMBAD votable fields.")
+            return
+
         Simbad.ROW_LIMIT = 10000
 
+        # --- Query SIMBAD ---
+        result = None
         for attempt in range(1, 6):
             try:
-                result = Simbad.query_region(center_sky, radius=radius_deg * u.deg)
+                if getattr(self, "count_label", None) is not None:
+                    self.count_label.setText(f"Attempt {attempt}/5 to query SIMBAD…")
+                QApplication.processEvents()
+                result = Simbad.query_region(center_sky, radius=radius)
                 break
-            except Exception as e:
-                self.count_label.setText(f"Attempt {attempt}/5 to query SIMBAD…")
-                QApplication.processEvents(); time.sleep(1.2)
+            except Exception:
+                QApplication.processEvents()
+                time.sleep(1.2)
                 result = None
+
         if result is None or len(result) == 0:
             QMessageBox.information(self, "No Stars", "SIMBAD returned zero objects in that region.")
-            self.star_list = []; self.star_combo.clear(); self.star_combo.addItem("Vega (A0V)", userData="A0V"); return
+            self.star_list = []
+            if getattr(self, "star_combo", None) is not None:
+                self.star_combo.clear()
+                self.star_combo.addItem("Vega (A0V)", userData="A0V")
+            return
 
-        def infer_letter(bv):
-            if bv is None or (isinstance(bv, float) and np.isnan(bv)): return None
-            if   bv < 0.00: return "B"
-            elif bv < 0.30: return "A"
-            elif bv < 0.58: return "F"
-            elif bv < 0.81: return "G"
-            elif bv < 1.40: return "K"
-            elif bv > 1.40: return "M"
-            else: return "U"
-
-        self.star_list = []; templates_for_hist = []
-        for row in result:
-            raw_sp = row['sp_type']
-            bmag, vmag, rmag = row['B'], row['V'], row['R']
-            ra_deg, dec_deg  = float(row['ra']), float(row['dec'])
+        # --- helpers ---
+        def _unmask_num(x):
             try:
-                sc = SkyCoord(ra=ra_deg*u.deg, dec=dec_deg*u.deg, frame="icrs")
+                if x is None:
+                    return None
+                if ma.isMaskedArray(x) and ma.is_masked(x):
+                    return None
+                return float(x)
             except Exception:
-                continue
+                return None
+
+        def infer_letter(bv):
+            if bv is None or (isinstance(bv, float) and np.isnan(bv)):
+                return None
+            if bv < 0.00:
+                return "B"
+            elif bv < 0.30:
+                return "A"
+            elif bv < 0.58:
+                return "F"
+            elif bv < 0.81:
+                return "G"
+            elif bv < 1.40:
+                return "K"
+            elif bv > 1.40:
+                return "M"
+            return None
 
-            def _unmask_num(x):
+        def safe_world2pix(ra_deg, dec_deg):
+            try:
+                xpix, ypix = wcs2.all_world2pix(ra_deg, dec_deg, 0)
+                xpix, ypix = float(xpix), float(ypix)
+                if np.isfinite(xpix) and np.isfinite(ypix):
+                    return xpix, ypix
+                return None
+            except NoConvergence as e:
                 try:
-                    if x is None or np.ma.isMaskedArray(x) and np.ma.is_masked(x):
-                        return None
-                    return float(x)
+                    xpix, ypix = e.best_solution
+                    xpix, ypix = float(xpix), float(ypix)
+                    if np.isfinite(xpix) and np.isfinite(ypix):
+                        return xpix, ypix
                 except Exception:
-                    return None
+                    pass
+                return None
+            except Exception:
+                return None
 
-            # inside your SIMBAD row loop:
-            bmag = _unmask_num(row['B'])
-            vmag = _unmask_num(row['V'])
+        # Column names (astroquery changed these)
+        cols_lower = {c.lower(): c for c in result.colnames}
+
+        # RA/Dec in degrees:
+        ra_col = cols_lower.get("ra", None) or cols_lower.get("ra(d)", None) or cols_lower.get("ra_d", None)
+        dec_col = cols_lower.get("dec", None) or cols_lower.get("dec(d)", None) or cols_lower.get("dec_d", None)
+
+        # Mag columns:
+        b_col = cols_lower.get("b", None) or cols_lower.get("flux_b", None)
+        v_col = cols_lower.get("v", None) or cols_lower.get("flux_v", None)
+        r_col = cols_lower.get("r", None) or cols_lower.get("flux_r", None)
+
+        if ra_col is None or dec_col is None:
+            QMessageBox.critical(
+                self,
+                "SIMBAD Columns",
+                "SIMBAD result did not include degree RA/Dec columns (ra/dec).\n"
+                "Print result.colnames to see what's returned."
+            )
+            return
+
+        # --- main loop ---
+        self.star_list = []
+        templates_for_hist = []
+
+        for row in result:
+            # spectral type column name in table
+            raw_sp = None
+            if "SP_TYPE" in result.colnames:
+                raw_sp = row["SP_TYPE"]
+            elif "sp_type" in result.colnames:
+                raw_sp = row["sp_type"]
+
+            bmag = _unmask_num(row[b_col]) if b_col is not None else None
+            vmag = _unmask_num(row[v_col]) if v_col is not None else None
+            rmag = _unmask_num(row[r_col]) if r_col is not None else None
+
+            # ra/dec degrees
+            ra_deg = _unmask_num(row[ra_col])
+            dec_deg = _unmask_num(row[dec_col])
+            if ra_deg is None or dec_deg is None:
+                continue
+
+            try:
+                sc = SkyCoord(ra=ra_deg * u.deg, dec=dec_deg * u.deg, frame="icrs")
+            except Exception:
+                continue
 
             sp_clean = None
             if raw_sp and str(raw_sp).strip():
                 sp = str(raw_sp).strip().upper()
                 if not (sp.startswith("SN") or sp.startswith("KA")):
                     sp_clean = sp
-            elif bmag is not None and vmag is not None:
-                bv = bmag - vmag
-                sp_clean = infer_letter(bv)
-            if not sp_clean: continue
+            elif (bmag is not None) and (vmag is not None):
+                sp_clean = infer_letter(bmag - vmag)
+
+            if not sp_clean:
+                continue
 
             match_list = pickles_match_for_simbad(sp_clean, self.pickles_templates)
             best_template = match_list[0] if match_list else None
-            xpix, ypix = self.wcs.all_world2pix(sc.ra.deg, sc.dec.deg, 0)
+
+            xy = safe_world2pix(sc.ra.deg, sc.dec.deg)
+            if xy is None:
+                continue
+
+            xpix, ypix = xy
             if 0 <= xpix < W and 0 <= ypix < H:
                 self.star_list.append({
-                    "ra": sc.ra.deg, "dec": sc.dec.deg, "sp_clean": sp_clean,
-                    "pickles_match": best_template, "x": xpix, "y": ypix,
-                    "Bmag": float(bmag) if bmag else None,
-                    "Vmag": float(vmag) if vmag else None,
-                    "Rmag": float(rmag) if rmag else None,
+                    "ra": sc.ra.deg, "dec": sc.dec.deg,
+                    "sp_clean": sp_clean,
+                    "pickles_match": best_template,
+                    "x": xpix, "y": ypix,
+                    # IMPORTANT: do not use "if bmag" (0.0 becomes None)
+                    "Bmag": float(bmag) if bmag is not None else None,
+                    "Vmag": float(vmag) if vmag is not None else None,
+                    "Rmag": float(rmag) if rmag is not None else None,
                 })
-                if best_template is not None: templates_for_hist.append(best_template)
+                if best_template is not None:
+                    templates_for_hist.append(best_template)
+
+        # --- plot / UI feedback (unchanged) ---
+        if getattr(self, "figure", None) is not None:
+            self.figure.clf()
 
-        self.figure.clf()
         if templates_for_hist:
             uniq, cnt = np.unique(templates_for_hist, return_counts=True)
-            types_str = ", ".join(uniq)
-            self.count_label.setText(f"Found {len(templates_for_hist)} stars; templates: {types_str}")
-            ax = self.figure.add_subplot(111)
-            ax.bar(uniq, cnt, edgecolor="black")
-            ax.set_xlabel("Spectral Type"); ax.set_ylabel("Count"); ax.set_title("Spectral Distribution")
-            ax.tick_params(axis='x', rotation=90); ax.grid(axis="y", linestyle="--", alpha=0.3)
-            self.canvas.setVisible(True); self.canvas.draw()
+            types_str = ", ".join([str(u) for u in uniq])
+            if getattr(self, "count_label", None) is not None:
+                self.count_label.setText(f"Found {len(self.star_list)} stars; templates: {types_str}")
+
+            if getattr(self, "figure", None) is not None and getattr(self, "canvas", None) is not None:
+                ax = self.figure.add_subplot(111)
+                ax.bar(uniq, cnt, edgecolor="black")
+                ax.set_xlabel("Spectral Type")
+                ax.set_ylabel("Count")
+                ax.set_title("Spectral Distribution")
+                ax.tick_params(axis='x', rotation=90)
+                ax.grid(axis="y", linestyle="--", alpha=0.3)
+                self.canvas.setVisible(True)
+                self.canvas.draw()
         else:
-            self.count_label.setText("Found 0 stars with Pickles matches.")
-            self.canvas.setVisible(False); self.canvas.draw()
+            if getattr(self, "count_label", None) is not None:
+                self.count_label.setText(f"Found {len(self.star_list)} in-frame SIMBAD stars (0 with Pickles matches).")
+            if getattr(self, "canvas", None) is not None:
+                self.canvas.setVisible(False)
+                self.canvas.draw()
 
     # ── Core SFCC ───────────────────────────────────────────────────────
-
     def run_spcc(self):
         ref_sed_name = self.star_combo.currentData()
         r_filt = self.r_filter_combo.currentText()
@@ -1046,13 +1349,15 @@ class SFCCDialog(QDialog):
         lp_filt2 = self.lp_filter_combo2.currentText()
 
         if not ref_sed_name:
-            QMessageBox.warning(self, "Error", "Select a reference spectral type (e.g. A0V)."); return
+            QMessageBox.warning(self, "Error", "Select a reference spectral type (e.g. A0V).")
+            return
         if r_filt == "(None)" and g_filt == "(None)" and b_filt == "(None)":
-            QMessageBox.warning(self, "Error", "Pick at least one of R, G or B filters."); return
+            QMessageBox.warning(self, "Error", "Pick at least one of R, G or B filters.")
+            return
         if sens_name == "(None)":
-            QMessageBox.warning(self, "Error", "Select a sensor QE curve."); return
+            QMessageBox.warning(self, "Error", "Select a sensor QE curve.")
+            return
 
-        # -- Step 1A: get active image as float32 in [0..1]
         doc = self.doc_manager.get_active_document()
         if doc is None or doc.image is None:
             QMessageBox.critical(self, "Error", "No active document.")
@@ -1064,29 +1369,32 @@ class SFCCDialog(QDialog):
             QMessageBox.critical(self, "Error", "Active document must be RGB (3 channels).")
             return
 
+        # ---- Convert to float working space ----
         if img.dtype == np.uint8:
-            base = img.astype(np.float32) / 255.0
+            img_float = img.astype(np.float32) / 255.0
         else:
-            base = img.astype(np.float32, copy=True)
+            img_float = img.astype(np.float32, copy=False)
 
-        # pedestal removal
-        base = np.clip(base - np.min(base, axis=(0,1)), 0.0, None)
-        # light neutralization
-        base = self._neutralize_background(base, patch_size=10)
+        # ---- Build SEP working copy (ONE pedestal handling only) ----
+        base = self._make_working_base_for_sep(img_float)
+
+        # Optional BN after calibration:
+        # IMPORTANT: do NOT remove pedestal here either (avoid double pedestal removal).
+        if self.neutralize_chk.isChecked():
+            base = self._neutralize_background(base, remove_pedestal=False)
 
         # SEP on grayscale
-        gray = np.mean(base, axis=2)
-        
+        gray = np.mean(base, axis=2).astype(np.float32)
+
         bkg = sep.Background(gray)
         data_sub = gray - bkg.back()
-        err = bkg.globalrms
+        err = float(bkg.globalrms)
+
+        # User threshold
+        sep_sigma = float(self.sep_thr_spin.value()) if hasattr(self, "sep_thr_spin") else 5.0
+        self.count_label.setText(f"Detecting stars (SEP σ={sep_sigma:.1f})…")
+        QApplication.processEvents()
 
-        # 👇 get user threshold (default 5.0)
-        if hasattr(self, "sep_thr_spin"):
-            sep_sigma = float(self.sep_thr_spin.value())
-        else:
-            sep_sigma = 5.0
-        self.count_label.setText(f"Detecting stars (SEP σ={sep_sigma:.1f})…"); QApplication.processEvents()
         sources = sep.extract(data_sub, sep_sigma, err=err)
 
         MAX_SOURCES = 300_000
@@ -1100,32 +1408,51 @@ class SFCCDialog(QDialog):
             return
 
         if sources.size == 0:
-            QMessageBox.critical(self, "SEP Error", "SEP found no sources."); return
-        r_fluxrad, _ = sep.flux_radius(gray, sources["x"], sources["y"], 2.0*sources["a"], 0.5, normflux=sources["flux"], subpix=5)
-        mask = (r_fluxrad > .2) & (r_fluxrad <= 10); sources = sources[mask]
+            QMessageBox.critical(self, "SEP Error", "SEP found no sources.")
+            return
+
+        # Radius filtering (unchanged)
+        r_fluxrad, _ = sep.flux_radius(
+            gray, sources["x"], sources["y"],
+            2.0 * sources["a"], 0.5,
+            normflux=sources["flux"], subpix=5
+        )
+        mask = (r_fluxrad > 0.2) & (r_fluxrad <= 10)
+        sources = sources[mask]
         if sources.size == 0:
-            QMessageBox.critical(self, "SEP Error", "All SEP detections rejected by radius filter."); return
+            QMessageBox.critical(self, "SEP Error", "All SEP detections rejected by radius filter.")
+            return
 
         if not getattr(self, "star_list", None):
-            QMessageBox.warning(self, "Error", "Fetch Stars (with WCS) before running SFCC."); return
+            QMessageBox.warning(self, "Error", "Fetch Stars (with WCS) before running SFCC.")
+            return
 
+        # ---- Match SIMBAD stars to SEP detections ----
         raw_matches = []
         for i, star in enumerate(self.star_list):
-            dx = sources["x"] - star["x"]; dy = sources["y"] - star["y"]
-            j = np.argmin(dx*dx + dy*dy)
-            if (dx[j]**2 + dy[j]**2) < 3.0**2:
-                xi, yi = int(round(sources["x"][j])), int(round(sources["y"][j]))
+            dx = sources["x"] - star["x"]
+            dy = sources["y"] - star["y"]
+            j = int(np.argmin(dx * dx + dy * dy))
+            if (dx[j] * dx[j] + dy[j] * dy[j]) < (3.0 ** 2):
+                xi, yi = int(round(float(sources["x"][j]))), int(round(float(sources["y"][j])))
                 if 0 <= xi < W and 0 <= yi < H:
-                    raw_matches.append({"sim_index": i, "template": star.get("pickles_match") or star["sp_clean"], "x_pix": xi, "y_pix": yi})
+                    raw_matches.append({
+                        "sim_index": i,
+                        "template": star.get("pickles_match") or star["sp_clean"],
+                        "x_pix": xi,
+                        "y_pix": yi
+                    })
+
         if not raw_matches:
-            QMessageBox.warning(self, "No Matches", "No SIMBAD star matched to SEP detections."); return
+            QMessageBox.warning(self, "No Matches", "No SIMBAD star matched to SEP detections.")
+            return
 
         wl_min, wl_max = 3000, 11000
-        wl_grid = np.arange(wl_min, wl_max+1)
+        wl_grid = np.arange(wl_min, wl_max + 1)
 
         def load_curve(ext):
             for p in (self.user_custom_path, self.sasp_data_path):
-                with fits.open(p) as hd:
+                with fits.open(p, memmap=False) as hd:
                     if ext in hd:
                         d = hd[ext].data
                         wl = _ensure_angstrom(d["WAVELENGTH"].astype(float))
@@ -1135,7 +1462,7 @@ class SFCCDialog(QDialog):
 
         def load_sed(ext):
             for p in (self.user_custom_path, self.sasp_data_path):
-                with fits.open(p) as hd:
+                with fits.open(p, memmap=False) as hd:
                     if ext in hd:
                         d = hd[ext].data
                         wl = _ensure_angstrom(d["WAVELENGTH"].astype(float))
@@ -1143,18 +1470,21 @@ class SFCCDialog(QDialog):
                         return wl, fl
             raise KeyError(f"SED '{ext}' not found")
 
-        interp = lambda wl_o, tp_o: np.interp(wl_grid, wl_o, tp_o, left=0., right=0.)
-        T_R = interp(*load_curve(r_filt)) if r_filt!="(None)" else np.ones_like(wl_grid)
-        T_G = interp(*load_curve(g_filt)) if g_filt!="(None)" else np.ones_like(wl_grid)
-        T_B = interp(*load_curve(b_filt)) if b_filt!="(None)" else np.ones_like(wl_grid)
-        QE  = interp(*load_curve(sens_name)) if sens_name!="(None)" else np.ones_like(wl_grid)
-        LP1 = interp(*load_curve(lp_filt))   if lp_filt != "(None)"  else np.ones_like(wl_grid)
-        LP2 = interp(*load_curve(lp_filt2))  if lp_filt2!= "(None)"  else np.ones_like(wl_grid)
+        interp = lambda wl_o, tp_o: np.interp(wl_grid, wl_o, tp_o, left=0.0, right=0.0)
+
+        T_R = interp(*load_curve(r_filt)) if r_filt != "(None)" else np.ones_like(wl_grid)
+        T_G = interp(*load_curve(g_filt)) if g_filt != "(None)" else np.ones_like(wl_grid)
+        T_B = interp(*load_curve(b_filt)) if b_filt != "(None)" else np.ones_like(wl_grid)
+        QE  = interp(*load_curve(sens_name)) if sens_name != "(None)" else np.ones_like(wl_grid)
+        LP1 = interp(*load_curve(lp_filt))   if lp_filt  != "(None)" else np.ones_like(wl_grid)
+        LP2 = interp(*load_curve(lp_filt2))  if lp_filt2 != "(None)" else np.ones_like(wl_grid)
         LP  = LP1 * LP2
-        T_sys_R, T_sys_G, T_sys_B = T_R*QE*LP, T_G*QE*LP, T_B*QE*LP
+
+        T_sys_R, T_sys_G, T_sys_B = T_R * QE * LP, T_G * QE * LP, T_B * QE * LP
 
         wl_ref, fl_ref = load_sed(ref_sed_name)
-        fr_i = np.interp(wl_grid, wl_ref, fl_ref, left=0., right=0.)
+        fr_i = np.interp(wl_grid, wl_ref, fl_ref, left=0.0, right=0.0)
+
         S_ref_R = np.trapezoid(fr_i * T_sys_R, x=wl_grid)
         S_ref_G = np.trapezoid(fr_i * T_sys_G, x=wl_grid)
         S_ref_B = np.trapezoid(fr_i * T_sys_B, x=wl_grid)
@@ -1163,155 +1493,207 @@ class SFCCDialog(QDialog):
         diag_meas_BG, diag_exp_BG = [], []
         enriched = []
 
-        # --- Optimization: Pre-calculate integrals for unique templates ---
+        # ---- Pre-calc integrals for unique templates ----
         unique_simbad_types = set(m["template"] for m in raw_matches)
-        
-        # Map simbad_type -> pickles_template_name
+
         simbad_to_pickles = {}
         pickles_templates_needed = set()
-        
         for sp in unique_simbad_types:
             cands = pickles_match_for_simbad(sp, getattr(self, "pickles_templates", []))
             if cands:
-                pickles_name = cands[0]
-                simbad_to_pickles[sp] = pickles_name
-                pickles_templates_needed.add(pickles_name)
+                pname = cands[0]
+                simbad_to_pickles[sp] = pname
+                pickles_templates_needed.add(pname)
 
-        # Pre-calc integrals for each unique Pickles template
-        # Cache structure: template_name -> (S_sr, S_sg, S_sb)
         template_integrals = {}
-
-        # Cache for load_sed to avoid re-reading even across different calls if desired, 
-        # but here we just optimize the loop.
-        
         for pname in pickles_templates_needed:
             try:
                 wl_s, fl_s = load_sed(pname)
-                fs_i = np.interp(wl_grid, wl_s, fl_s, left=0., right=0.)
-                
+                fs_i = np.interp(wl_grid, wl_s, fl_s, left=0.0, right=0.0)
                 S_sr = np.trapezoid(fs_i * T_sys_R, x=wl_grid)
                 S_sg = np.trapezoid(fs_i * T_sys_G, x=wl_grid)
                 S_sb = np.trapezoid(fs_i * T_sys_B, x=wl_grid)
-                
                 template_integrals[pname] = (S_sr, S_sg, S_sb)
             except Exception as e:
                 print(f"[SFCC] Warning: failed to load/integrate template {pname}: {e}")
 
-        # --- Main Match Loop ---
+        # ---- Main match loop (measure from 'base' only) ----
         for m in raw_matches:
             xi, yi, sp = m["x_pix"], m["y_pix"], m["template"]
-            Rm = float(base[yi, xi, 0]); Gm = float(base[yi, xi, 1]); Bm = float(base[yi, xi, 2])
-            if Gm <= 0: continue
 
-            # 1. Resolve Simbad -> Pickles
+            # measure on the SEP working copy (already BN’d, only one pedestal handling)
+            Rm = float(base[yi, xi, 0])
+            Gm = float(base[yi, xi, 1])
+            Bm = float(base[yi, xi, 2])
+            if Gm <= 0:
+                continue
+
             pname = simbad_to_pickles.get(sp)
-            if not pname: continue
-            
-            # 2. Retrieve pre-calced integrals
+            if not pname:
+                continue
+
             integrals = template_integrals.get(pname)
-            if not integrals: continue
-            
+            if not integrals:
+                continue
+
             S_sr, S_sg, S_sb = integrals
-            
-            if S_sg <= 0: continue
+            if S_sg <= 0:
+                continue
 
-            exp_RG = S_sr / S_sg; exp_BG = S_sb / S_sg
-            meas_RG = Rm / Gm;    meas_BG = Bm / Gm
+            exp_RG = S_sr / S_sg
+            exp_BG = S_sb / S_sg
+            meas_RG = Rm / Gm
+            meas_BG = Bm / Gm
 
             diag_meas_RG.append(meas_RG); diag_exp_RG.append(exp_RG)
             diag_meas_BG.append(meas_BG); diag_exp_BG.append(exp_BG)
 
             enriched.append({
-                **m, "R_meas": Rm, "G_meas": Gm, "B_meas": Bm,
+                **m,
+                "R_meas": Rm, "G_meas": Gm, "B_meas": Bm,
                 "S_star_R": S_sr, "S_star_G": S_sg, "S_star_B": S_sb,
                 "exp_RG": exp_RG, "exp_BG": exp_BG
             })
-            
+
         self._last_matched = enriched
-        diag_meas_RG = np.array(diag_meas_RG); diag_exp_RG = np.array(diag_exp_RG)
-        diag_meas_BG = np.array(diag_meas_BG); diag_exp_BG = np.array(diag_exp_BG)
+        diag_meas_RG = np.asarray(diag_meas_RG, dtype=np.float64)
+        diag_exp_RG  = np.asarray(diag_exp_RG,  dtype=np.float64)
+        diag_meas_BG = np.asarray(diag_meas_BG, dtype=np.float64)
+        diag_exp_BG  = np.asarray(diag_exp_BG,  dtype=np.float64)
+
         if diag_meas_RG.size == 0 or diag_meas_BG.size == 0:
-            QMessageBox.information(self, "No Valid Stars", "No stars with valid measured vs expected ratios."); return
-        n_stars = diag_meas_RG.size
+            QMessageBox.information(self, "No Valid Stars", "No stars with valid measured vs expected ratios.")
+            return
+
+        n_stars = int(diag_meas_RG.size)
 
-        def rms_frac(pred, exp): return np.sqrt(np.mean(((pred/exp) - 1.0) ** 2))
-        slope_only = lambda x, m: m*x
-        affine     = lambda x, m, b: m*x + b
-        quad       = lambda x, a, b, c: a*x**2 + b*x + c
+        def rms_frac(pred, exp):
+            return float(np.sqrt(np.mean(((pred / exp) - 1.0) ** 2)))
 
-        denR = np.sum(diag_meas_RG**2); denB = np.sum(diag_meas_BG**2)
-        mR_s = (np.sum(diag_meas_RG * diag_exp_RG) / denR) if denR > 0 else 1.0
-        mB_s = (np.sum(diag_meas_BG * diag_exp_BG) / denB) if denB > 0 else 1.0
+        slope_only = lambda x, m: m * x
+        affine     = lambda x, m, b: m * x + b
+        quad       = lambda x, a, b, c: a * x**2 + b * x + c
+
+        denR = float(np.sum(diag_meas_RG**2))
+        denB = float(np.sum(diag_meas_BG**2))
+        mR_s = (float(np.sum(diag_meas_RG * diag_exp_RG)) / denR) if denR > 0 else 1.0
+        mB_s = (float(np.sum(diag_meas_BG * diag_exp_BG)) / denB) if denB > 0 else 1.0
         rms_s = rms_frac(slope_only(diag_meas_RG, mR_s), diag_exp_RG) + rms_frac(slope_only(diag_meas_BG, mB_s), diag_exp_BG)
 
-        mR_a, bR_a = np.linalg.lstsq(np.vstack([diag_meas_RG, np.ones_like(diag_meas_RG)]).T, diag_exp_RG, rcond=None)[0]
-        mB_a, bB_a = np.linalg.lstsq(np.vstack([diag_meas_BG, np.ones_like(diag_meas_BG)]).T, diag_exp_BG, rcond=None)[0]
+        mR_a, bR_a = np.linalg.lstsq(
+            np.vstack([diag_meas_RG, np.ones_like(diag_meas_RG)]).T, diag_exp_RG, rcond=None
+        )[0]
+        mB_a, bB_a = np.linalg.lstsq(
+            np.vstack([diag_meas_BG, np.ones_like(diag_meas_BG)]).T, diag_exp_BG, rcond=None
+        )[0]
         rms_a = rms_frac(affine(diag_meas_RG, mR_a, bR_a), diag_exp_RG) + rms_frac(affine(diag_meas_BG, mB_a, bB_a), diag_exp_BG)
 
         aR_q, bR_q, cR_q = np.polyfit(diag_meas_RG, diag_exp_RG, 2)
         aB_q, bB_q, cB_q = np.polyfit(diag_meas_BG, diag_exp_BG, 2)
         rms_q = rms_frac(quad(diag_meas_RG, aR_q, bR_q, cR_q), diag_exp_RG) + rms_frac(quad(diag_meas_BG, aB_q, bB_q, cB_q), diag_exp_BG)
 
-        idx = np.argmin([rms_s, rms_a, rms_q])
-        if idx == 0: coeff_R, coeff_B, model_choice = (0, mR_s, 0), (0, mB_s, 0), "slope-only"
-        elif idx == 1: coeff_R, coeff_B, model_choice = (0, mR_a, bR_a), (0, mB_a, bB_a), "affine"
-        else: coeff_R, coeff_B, model_choice = (aR_q, bR_q, cR_q), (aB_q, bB_q, cB_q), "quadratic"
+        idx = int(np.argmin([rms_s, rms_a, rms_q]))
+        if idx == 0:
+            coeff_R, coeff_B, model_choice = (0.0, float(mR_s), 0.0), (0.0, float(mB_s), 0.0), "slope-only"
+        elif idx == 1:
+            coeff_R, coeff_B, model_choice = (0.0, float(mR_a), float(bR_a)), (0.0, float(mB_a), float(bB_a)), "affine"
+        else:
+            coeff_R, coeff_B, model_choice = (float(aR_q), float(bR_q), float(cR_q)), (float(aB_q), float(bB_q), float(cB_q)), "quadratic"
+
+        poly = lambda c, x: c[0] * x**2 + c[1] * x + c[2]
 
-        poly = lambda c, x: c[0]*x**2 + c[1]*x + c[2]
+        # ---- Diagnostics plot (unchanged) ----
         self.figure.clf()
-        #ax1 = self.figure.add_subplot(1, 3, 1); bins=20
-        #ax1.hist(diag_meas_RG, bins=bins, alpha=.65, label="meas R/G", color="firebrick", edgecolor="black")
-        #ax1.hist(diag_exp_RG,  bins=bins, alpha=.55, label="exp R/G",  color="salmon",   edgecolor="black")
-        #ax1.hist(diag_meas_BG, bins=bins, alpha=.65, label="meas B/G", color="royalblue", edgecolor="black")
-        #ax1.hist(diag_exp_BG,  bins=bins, alpha=.55, label="exp B/G",  color="lightskyblue", edgecolor="black")
-        #ax1.set_xlabel("Ratio (band / G)"); ax1.set_ylabel("Count"); ax1.set_title("Measured vs expected"); ax1.legend(fontsize=7, frameon=False)
-
         res0_RG = (diag_meas_RG / diag_exp_RG) - 1.0
         res0_BG = (diag_meas_BG / diag_exp_BG) - 1.0
         res1_RG = (poly(coeff_R, diag_meas_RG) / diag_exp_RG) - 1.0
         res1_BG = (poly(coeff_B, diag_meas_BG) / diag_exp_BG) - 1.0
 
-        ymin = np.min(np.concatenate([res0_RG, res0_BG])); ymax = np.max(np.concatenate([res0_RG, res0_BG]))
-        pad  = 0.05 * (ymax - ymin) if ymax > ymin else 0.02; y_lim = (ymin - pad, ymax + pad)
+        ymin = float(np.min(np.concatenate([res0_RG, res0_BG])))
+        ymax = float(np.max(np.concatenate([res0_RG, res0_BG])))
+        pad  = 0.05 * (ymax - ymin) if ymax > ymin else 0.02
+        y_lim = (ymin - pad, ymax + pad)
+
         def shade(ax, yvals, color):
-            q1, q3 = np.percentile(yvals, [25,75]); ax.axhspan(q1, q3, color=color, alpha=.10, zorder=0)
+            q1, q3 = np.percentile(yvals, [25, 75])
+            ax.axhspan(q1, q3, color=color, alpha=0.10, zorder=0)
 
         ax2 = self.figure.add_subplot(1, 2, 1)
-        ax2.axhline(0, color="0.65", ls="--", lw=1); shade(ax2, res0_RG, "firebrick"); shade(ax2, res0_BG, "royalblue")
-        ax2.scatter(diag_exp_RG, res0_RG, c="firebrick",  marker="o", alpha=.7, label="R/G residual")
-        ax2.scatter(diag_exp_BG, res0_BG, c="royalblue", marker="s", alpha=.7, label="B/G residual")
-        ax2.set_ylim(*y_lim); ax2.set_xlabel("Expected (band/G)"); ax2.set_ylabel("Frac residual (meas/exp − 1)")
-        ax2.set_title("Residuals • BEFORE"); ax2.legend(frameon=False, fontsize=7, loc="lower right")
+        ax2.axhline(0, color="0.65", ls="--", lw=1)
+        shade(ax2, res0_RG, "firebrick"); shade(ax2, res0_BG, "royalblue")
+        ax2.scatter(diag_exp_RG, res0_RG, c="firebrick", marker="o", alpha=0.7, label="R/G residual")
+        ax2.scatter(diag_exp_BG, res0_BG, c="royalblue", marker="s", alpha=0.7, label="B/G residual")
+        ax2.set_ylim(*y_lim)
+        ax2.set_xlabel("Expected (band/G)")
+        ax2.set_ylabel("Frac residual (meas/exp − 1)")
+        ax2.set_title("Residuals • BEFORE")
+        ax2.legend(frameon=False, fontsize=7, loc="lower right")
 
         ax3 = self.figure.add_subplot(1, 2, 2)
-        ax3.axhline(0, color="0.65", ls="--", lw=1); shade(ax3, res1_RG, "firebrick"); shade(ax3, res1_BG, "royalblue")
-        ax3.scatter(diag_exp_RG, res1_RG, c="firebrick",  marker="o", alpha=.7)
-        ax3.scatter(diag_exp_BG, res1_BG, c="royalblue", marker="s", alpha=.7)
-        ax3.set_ylim(*y_lim); ax3.set_xlabel("Expected (band/G)"); ax3.set_ylabel("Frac residual (corrected/exp − 1)")
+        ax3.axhline(0, color="0.65", ls="--", lw=1)
+        shade(ax3, res1_RG, "firebrick"); shade(ax3, res1_BG, "royalblue")
+        ax3.scatter(diag_exp_RG, res1_RG, c="firebrick", marker="o", alpha=0.7)
+        ax3.scatter(diag_exp_BG, res1_BG, c="royalblue", marker="s", alpha=0.7)
+        ax3.set_ylim(*y_lim)
+        ax3.set_xlabel("Expected (band/G)")
+        ax3.set_ylabel("Frac residual (corrected/exp − 1)")
         ax3.set_title("Residuals • AFTER")
-        self.canvas.setVisible(True); self.figure.tight_layout(w_pad=2.); self.canvas.draw()
-
-        self.count_label.setText("Applying SFCC color scales to image…"); QApplication.processEvents()
-        if img.dtype == np.uint8: img_float = img.astype(np.float32) / 255.0
-        else:                     img_float = img.astype(np.float32)
-
-        RG = img_float[..., 0] / np.maximum(img_float[..., 1], 1e-8)
-        BG = img_float[..., 2] / np.maximum(img_float[..., 1], 1e-8)
-        aR, bR, cR = coeff_R; aB, bB, cB = coeff_B
-        RG_corr = aR*RG**2 + bR*RG + cR
-        BG_corr = aB*BG**2 + bB*BG + cB
-        calibrated = img_float.copy()
-        calibrated[..., 0] = RG_corr * img_float[..., 1]
-        calibrated[..., 2] = BG_corr * img_float[..., 1]
-        calibrated = np.clip(calibrated, 0, 1)
 
+        self.canvas.setVisible(True)
+        self.figure.tight_layout(w_pad=2.0)
+        self.canvas.draw()
+
+        # ---- Apply SFCC correction to ORIGINAL floats (not the SEP base) ----
+        self.count_label.setText("Applying SFCC color scales to image…")
+        QApplication.processEvents()
+
+        eps = 1e-8
+        calibrated = base.copy()
+
+        R = calibrated[..., 0]
+        G = calibrated[..., 1]
+        B = calibrated[..., 2]
+
+        RG = R / np.maximum(G, eps)
+        BG = B / np.maximum(G, eps)
+
+        aR, bR, cR = coeff_R
+        aB, bB, cB = coeff_B
+
+        mR = aR * RG**2 + bR * RG + cR
+        mB = aB * BG**2 + bB * BG + cB
+
+        mR = np.clip(mR, 0.25, 4.0)
+        mB = np.clip(mB, 0.25, 4.0)
+
+        pR = float(np.median(R))
+        pB = float(np.median(B))
+
+        calibrated[..., 0] = _pivot_scale_channel(R, mR, pR)
+        calibrated[..., 2] = _pivot_scale_channel(B, mB, pB)
+
+        calibrated = np.clip(calibrated, 0.0, 1.0)
+
+        # --- OPTIONAL: apply BN/pedestal to the FINAL calibrated image, not just SEP base ---
         if self.neutralize_chk.isChecked():
-            calibrated = self._neutralize_background(calibrated, patch_size=10)
+            try:
+                print("[SFCC] Applying background neutralization to final calibrated image...")
+                _debug_probe_channels(calibrated, "final_before_BN")
 
+                # If you want pedestal removal as part of BN, set remove_pedestal=True here
+                # (and/or make this a checkbox)
+                calibrated = self._neutralize_background(calibrated, remove_pedestal=True)
+
+                _debug_probe_channels(calibrated, "final_after_BN")
+            except Exception as e:
+                print(f"[SFCC] Final BN failed: {e}")
+
+
+        # Convert back to original dtype
         if img.dtype == np.uint8:
-            calibrated = (np.clip(calibrated, 0, 1) * 255.0).astype(np.uint8)
+            out_img = (np.clip(calibrated, 0.0, 1.0) * 255.0).astype(np.uint8)
         else:
-            calibrated = np.clip(calibrated, 0, 1).astype(np.float32)
+            out_img = np.clip(calibrated, 0.0, 1.0).astype(np.float32)
 
         new_meta = dict(doc.metadata or {})
         new_meta.update({
@@ -1323,25 +1705,31 @@ class SFCCDialog(QDialog):
         })
 
         self.doc_manager.update_active_document(
-            calibrated,
+            out_img,
             metadata=new_meta,
             step_name="SFCC Calibrated",
-            doc=doc,   # 👈 pin to the document we started from
+            doc=doc,
         )
 
         self.count_label.setText(f"Applied SFCC color calibration using {n_stars} stars")
         QApplication.processEvents()
 
-        def pretty(coeff): return coeff[0] + coeff[1] + coeff[2]
-        ratio_R, ratio_B = pretty(coeff_R), pretty(coeff_B)
-        QMessageBox.information(self, "SFCC Complete",
-                                f"Applied SFCC using {n_stars} stars\n"
-                                f"Model: {model_choice}\n"
-                                f"R ratio @ x=1: {ratio_R:.4f}\n"
-                                f"B ratio @ x=1: {ratio_B:.4f}\n"
-                                f"Background neutralisation: {'ON' if self.neutralize_chk.isChecked() else 'OFF'}")
+        def pretty(coeff):
+            # coefficient sum gives you f(1) for quadratic form a*x^2+b*x+c at x=1
+            return float(coeff[0] + coeff[1] + coeff[2])
+
+        QMessageBox.information(
+            self,
+            "SFCC Complete",
+            f"Applied SFCC using {n_stars} stars\n"
+            f"Model: {model_choice}\n"
+            f"R ratio @ x=1: {pretty(coeff_R):.4f}\n"
+            f"B ratio @ x=1: {pretty(coeff_B):.4f}\n"
+            f"Background neutralisation: {'ON' if self.neutralize_chk.isChecked() else 'OFF'}"
+        )
+
+        self.current_image = out_img  # keep for gradient step
 
-        self.current_image = calibrated  # keep for gradient step
 
     # ── Chromatic gradient (optional) ──────────────────────────────────