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

setiastro/saspro/stacking_suite.py

@@ -1715,11 +1715,20 @@ class _MMFits:
             raise ValueError(f"Unsupported ndim={self.ndim} for {path}")
 
     def _apply_fixed_fits_scale(self, arr: np.ndarray) -> np.ndarray:
+        """
+        Map 8/16-bit FITS integer samples to [0,1] using a fixed divisor.
+        IMPORTANT: Only do this for integer dtypes. If Astropy already returned
+        float (e.g. BSCALE/BZERO applied), do NOT divide again.
+        """
+        # Only scale raw integer pixel arrays
+        if arr.dtype.kind not in ("u", "i"):
+            return arr
+
         bitpix = getattr(self, "_bitpix", 0)
         if bitpix == 8:
-            arr /= 255.0
+            return arr / 255.0
         elif bitpix == 16:
-            arr /= 65535.0
+            return arr / 65535.0
         return arr
 
     def read_tile(self, y0, y1, x0, x1) -> np.ndarray:
@@ -1847,9 +1856,9 @@ class ReferenceFrameReviewDialog(QDialog):
         self.initUI()
         self.loadImageArray()  # Load the image into self.original_image
         if self.original_image is not None:
-            self.updatePreview(self.original_image)  # Ensure the first image is shown
-        if self.original_image is not None:
-            QTimer.singleShot(0, self.zoomIn)            
+            QTimer.singleShot(0, lambda: self.updatePreview(self.original_image, fit=True))
+        #if self.original_image is not None:
+        #    QTimer.singleShot(0, self.zoomIn)            
 
 
     def initUI(self):
@@ -1907,6 +1916,89 @@ class ReferenceFrameReviewDialog(QDialog):
         self.setLayout(main_layout)
         self.zoomIn()
     
+    def _ensure_hwc(self, x: np.ndarray) -> np.ndarray:
+        """Ensure HWC for RGB, HW for mono."""
+        if x is None:
+            return None
+        x = np.asarray(x)
+        # CHW -> HWC
+        if x.ndim == 3 and x.shape[0] == 3 and x.shape[-1] != 3:
+            x = np.transpose(x, (1, 2, 0))
+        # squeeze HWC with singleton
+        if x.ndim == 3 and x.shape[-1] == 1:
+            x = np.squeeze(x, axis=-1)
+        return x
+
+
+    def _robust_preview_stretch(self, img: np.ndarray,
+                            lo_pct: float = 0.25,
+                            hi_pct: float = 99.75,
+                            gamma: float = 0.65) -> np.ndarray:
+        """
+        Robust preview stretch:
+        - nan/inf safe
+        - pedestal remove per channel (img - min)
+        - percentile clip to kill outliers
+        - scale to 0..1
+        - gentle gamma (default <1 brightens)
+        Returns float32 in [0,1] and preserves mono vs RGB.
+        """
+        x = self._ensure_hwc(img)
+        if x is None:
+            return None
+
+        x = np.asarray(x, dtype=np.float32)
+        x = np.nan_to_num(x, nan=0.0, posinf=0.0, neginf=0.0)
+
+        # Mono
+        if x.ndim == 2:
+            x = x - float(x.min())
+            # percentile clip on non-flat data
+            p_lo = float(np.percentile(x, lo_pct))
+            p_hi = float(np.percentile(x, hi_pct))
+            if p_hi > p_lo:
+                x = np.clip(x, p_lo, p_hi)
+                x = (x - p_lo) / (p_hi - p_lo)
+            else:
+                mx = float(x.max())
+                if mx > 0:
+                    x = x / mx
+            if gamma is not None and gamma > 0:
+                x = np.power(np.clip(x, 0.0, 1.0), gamma)
+            return np.clip(x, 0.0, 1.0).astype(np.float32, copy=False)
+
+        # RGB (HWC)
+        if x.ndim == 3 and x.shape[2] == 3:
+            out = np.empty_like(x, dtype=np.float32)
+            for c in range(3):
+                ch = x[..., c]
+                ch = ch - float(ch.min())
+                p_lo = float(np.percentile(ch, lo_pct))
+                p_hi = float(np.percentile(ch, hi_pct))
+                if p_hi > p_lo:
+                    ch = np.clip(ch, p_lo, p_hi)
+                    ch = (ch - p_lo) / (p_hi - p_lo)
+                else:
+                    mx = float(ch.max())
+                    if mx > 0:
+                        ch = ch / mx
+                out[..., c] = ch
+
+            if gamma is not None and gamma > 0:
+                out = np.power(np.clip(out, 0.0, 1.0), gamma)
+
+            return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
+        # Fallback: treat as scalar field
+        x = x - float(x.min())
+        mx = float(x.max())
+        if mx > 0:
+            x = x / mx
+        if gamma is not None and gamma > 0:
+            x = np.power(np.clip(x, 0.0, 1.0), gamma)
+        return np.clip(x, 0.0, 1.0).astype(np.float32, copy=False)
+
+
     def fitToPreview(self):
         """Calculate and set the zoom factor so that the image fills the preview area."""
         if self.original_image is None:
@@ -1933,32 +2025,46 @@ class ReferenceFrameReviewDialog(QDialog):
 
     def _normalize_preview_01(self, img: np.ndarray) -> np.ndarray:
         """
-        Normalize image to [0,1] for preview/stretch:
-
-        1. Handle NaNs/inf safely.
-        2. If min < 0 or max > 1, do (img - min) / (max - min).
-        3. Always return float32 in [0,1].
+        Always normalize to [0,1]:
+        img = img - min(img)
+        img = img / max(img)
+        Per-channel if RGB, global if mono.
         """
         if img is None:
             return None
 
-        img = np.asarray(img, dtype=np.float32)
-        img = np.nan_to_num(img, nan=0.0, posinf=0.0, neginf=0.0)
-
-        finite = np.isfinite(img)
-        if not finite.any():
-            return np.zeros_like(img, dtype=np.float32)
-
-        mn = float(img[finite].min())
-        mx = float(img[finite].max())
-        if mx == mn:
-            # flat frame → just zero it
-            return np.zeros_like(img, dtype=np.float32)
+        x = np.asarray(img, dtype=np.float32)
+        x = np.nan_to_num(x, nan=0.0, posinf=0.0, neginf=0.0)
 
-        if mn < 0.0 or mx > 1.0:
-            img = (img - mn) / (mx - mn)
+        if x.ndim == 2:
+            mn = float(x.min())
+            x = x - mn
+            mx = float(x.max())
+            if mx > 0:
+                x = x / mx
+            return np.clip(x, 0.0, 1.0).astype(np.float32, copy=False)
+
+        if x.ndim == 3 and x.shape[2] == 3:
+            # per-channel pedestal remove + normalize
+            out = x.copy()
+            for c in range(3):
+                ch = out[..., c]
+                mn = float(ch.min())
+                ch = ch - mn
+                mx = float(ch.max())
+                if mx > 0:
+                    ch = ch / mx
+                out[..., c] = ch
+            return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
+        # fallback
+        mn = float(x.min())
+        x = x - mn
+        mx = float(x.max())
+        if mx > 0:
+            x = x / mx
+        return np.clip(x, 0.0, 1.0).astype(np.float32, copy=False)
 
-        return np.clip(img, 0.0, 1.0)
 
 
     def loadImageArray(self):
@@ -1981,22 +2087,44 @@ class ReferenceFrameReviewDialog(QDialog):
 
         self.original_image = img
 
+    def _fit_zoom_to_viewport(self, image: np.ndarray):
+        """Set zoom_factor so image fits inside the scrollArea viewport."""
+        if image is None:
+            return
+
+        img = self._ensure_hwc(image)
+
+        if img.ndim == 2:
+            h, w = img.shape
+        elif img.ndim == 3 and img.shape[2] == 3:
+            h, w = img.shape[:2]
+        else:
+            return
+
+        vp = self.scrollArea.viewport().size()
+        if vp.width() <= 0 or vp.height() <= 0 or w <= 0 or h <= 0:
+            return
+
+        # Fit-to-viewport zoom
+        self.zoom_factor = min(vp.width() / w, vp.height() / h)
     
-    def updatePreview(self, image):
-        """
-        Convert a given image array to a QPixmap and update the preview label.
-        """
+    def updatePreview(self, image, *, fit: bool = False):
         self.current_preview_image = image
+
+        if fit:
+            self._fit_zoom_to_viewport(image)
+
         pixmap = self.convertArrayToPixmap(image)
         if pixmap is None or pixmap.isNull():
             self.previewLabel.setText(self.tr("Unable to load preview."))
-        else:
-            available_size = self.scrollArea.viewport().size()
-            new_size = QSize(int(available_size.width() * self.zoom_factor),
-                             int(available_size.height() * self.zoom_factor))
-            scaled_pixmap = pixmap.scaled(new_size, Qt.AspectRatioMode.KeepAspectRatio,
-                                          Qt.TransformationMode.SmoothTransformation)
-            self.previewLabel.setPixmap(scaled_pixmap)
+            return
+
+        scaled = pixmap.scaled(
+            pixmap.size() * self.zoom_factor,
+            Qt.AspectRatioMode.KeepAspectRatio,
+            Qt.TransformationMode.SmoothTransformation
+        )
+        self.previewLabel.setPixmap(scaled)
     
     def _preview_boost(self, img: np.ndarray) -> np.ndarray:
         """Robust, very gentle stretch for display when image would quantize to black."""
@@ -2014,62 +2142,48 @@ class ReferenceFrameReviewDialog(QDialog):
         if image is None:
             return None
 
-        img = image.astype(np.float32, copy=False)
-
-        # If image is so dim or flat that 8-bit will zero-out, boost for preview
-        ptp = float(img.max() - img.min())
-        needs_boost = (float(img.max()) <= (1.0 / 255.0)) or (ptp < 1e-6) or (not np.isfinite(img).all())
-        if needs_boost:
-            img = self._preview_boost(np.nan_to_num(img, nan=0.0, posinf=0.0, neginf=0.0))
+        # ALWAYS normalize to [0,1]
+        img = self._normalize_preview_01(image)
 
         # Convert to 8-bit for QImage
         display_image = (img * 255.0).clip(0, 255).astype(np.uint8)
 
+        # IMPORTANT: ensure contiguous memory
+        display_image = np.ascontiguousarray(display_image)
+
+        # Keep a reference so Qt's QImage always has valid backing memory
+        self._last_preview_u8 = display_image
+
         if display_image.ndim == 2:
             h, w = display_image.shape
-            q_image = QImage(display_image.data, w, h, w, QImage.Format.Format_Grayscale8)
+            q_image = QImage(self._last_preview_u8.data, w, h, w, QImage.Format.Format_Grayscale8)
+            q_image = q_image.copy()  # detach from numpy buffer (extra safety)
         elif display_image.ndim == 3 and display_image.shape[2] == 3:
             h, w, _ = display_image.shape
-            q_image = QImage(display_image.data, w, h, 3 * w, QImage.Format.Format_RGB888)
+            q_image = QImage(self._last_preview_u8.data, w, h, 3 * w, QImage.Format.Format_RGB888)
+            q_image = q_image.copy()  # detach
         else:
             return None
+
         return QPixmap.fromImage(q_image)
-    
+
     def toggleAutostretch(self):
         if self.original_image is None:
             QMessageBox.warning(self, self.tr("Error"), self.tr("Reference image not loaded."))
             return
 
-        # 🔹 Ensure the image we feed to Statistical Stretch is in [0,1]
-        base = self._normalize_preview_01(self.original_image)
-
         self.autostretch_enabled = not self.autostretch_enabled
+
         if self.autostretch_enabled:
-            if base.ndim == 2:
-                new_image = stretch_mono_image(
-                    base,
-                    target_median=0.3,
-                    normalize=True,
-                    apply_curves=False
-                )
-            elif base.ndim == 3 and base.shape[2] == 3:
-                new_image = stretch_color_image(
-                    base,
-                    target_median=0.3,
-                    linked=False,
-                    normalize=True,
-                    apply_curves=False
-                )
-            else:
-                new_image = base
+            new_image = self._robust_preview_stretch(self.original_image)
             self.toggleAutoStretchButton.setText(self.tr("Disable Autostretch"))
         else:
-            new_image = base
+            new_image = self._normalize_preview_01(self.original_image)
             self.toggleAutoStretchButton.setText(self.tr("Enable Autostretch"))
 
-        self.updatePreview(new_image)
+        self.updatePreview(new_image, fit=True)
 
-    
+        
     def zoomIn(self):
         self.zoom_factor *= 1.2
         if self.current_preview_image is not None:
@@ -3532,7 +3646,8 @@ class _MMImage:
         self._orig_dtype = None
         self._color_axis = None
         self._spat_axes = (0, 1)
-
+        self._dbg = bool(os.environ.get("SASPRO_MMIMAGE_DEBUG", "0") == "1")
+        self._dbg_count = 0
         self._xisf = None
         self._xisf_memmap = None   # np.memmap when possible
         self._xisf_arr = None      # decompressed ndarray when needed
@@ -3554,6 +3669,11 @@ class _MMImage:
             self._open_fits(path)
             self._kind = "fits"
 
+    def _dbg_log(self, msg: str):
+        if not getattr(self, "_dbg", False):
+            return
+        print(msg)  # or your logger
+
     # ---------------- FITS ----------------
     def _open_fits(self, path: str):
         """
@@ -3659,17 +3779,27 @@ class _MMImage:
     # ---------------- common API ----------------
     def _apply_fixed_fits_scale(self, arr: np.ndarray) -> np.ndarray:
         """
-        Map 8/16-bit FITS (already BZERO/BSCALE-scaled by Astropy) to [0,1]
-        using a fixed divisor. No per-frame img/max(img) normalization.
+        Map 8/16-bit FITS integer samples to [0,1] using a fixed divisor.
+        IMPORTANT: Only do this for integer dtypes. If Astropy already returned
+        float (e.g. BSCALE/BZERO applied), do NOT divide again.
         """
+        # Only scale raw integer pixel arrays
+        if arr.dtype.kind not in ("u", "i"):
+            return arr
+
         bitpix = getattr(self, "_bitpix", 0)
         if bitpix == 8:
-            arr /= 255.0
+            return arr / 255.0
         elif bitpix == 16:
-            arr /= 65535.0
+            return arr / 65535.0
         return arr
 
+
     def read_tile(self, y0, y1, x0, x1) -> np.ndarray:
+        import os
+        import numpy as np
+
+        # ---- FITS / XISF tile read (unchanged) ----
         if self._kind == "fits":
             d = self._fits_data
             if self.ndim == 2:
@@ -3683,23 +3813,23 @@ class _MMImage:
                     tile = np.moveaxis(tile, self._color_axis, -1)
         else:
             if self._xisf_memmap is not None:
-                # memmapped (C,H,W) → slice, then move to (H,W,C)
                 C = 1 if self.ndim == 2 else self.shape[2]
                 if C == 1:
                     tile = self._xisf_memmap[0, y0:y1, x0:x1]
                 else:
-                    tile = np.moveaxis(
-                        self._xisf_memmap[:, y0:y1, x0:x1], 0, -1
-                    )
+                    tile = np.moveaxis(self._xisf_memmap[:, y0:y1, x0:x1], 0, -1)
             else:
                 tile = self._xisf_arr[y0:y1, x0:x1]
 
-        # Cast to float32
+        # Cast to float32 copy (what you actually feed the stacker)
         out = np.array(tile, dtype=np.float32, copy=True, order="C")
 
-        # For FITS, apply fixed 8/16-bit normalization
+
+        # ---- APPLY FIXED SCALE (your real suspect) ----
         if self._kind == "fits":
-            out = self._apply_fixed_fits_scale(out)
+            out2 = self._apply_fixed_fits_scale(out)
+
+            out = out2
 
         # ensure (h,w,3) or (h,w)
         if out.ndim == 3 and out.shape[-1] not in (1, 3):
@@ -3707,6 +3837,7 @@ class _MMImage:
                 out = np.moveaxis(out, 0, -1)
         if out.ndim == 3 and out.shape[-1] == 1:
             out = np.squeeze(out, axis=-1)
+
         return out
 
     def read_full(self) -> np.ndarray:
@@ -4177,6 +4308,94 @@ def _temp_to_stem_tag(temp_c: float, *, prefix: str = "") -> str:
     s = s.replace(".", "p")     # e.g. "10p0"
     return f"{prefix}{sign}{s}C"
 
+
+def _arr_stats(a: np.ndarray):
+    a = np.asarray(a)
+    fin = np.isfinite(a)
+    if fin.any():
+        v = a[fin]
+        return dict(
+            dtype=str(a.dtype),
+            shape=tuple(a.shape),
+            finite=int(fin.sum()),
+            nan=int(np.isnan(a).sum()),
+            inf=int(np.isinf(a).sum()),
+            min=float(v.min()),
+            max=float(v.max()),
+            p01=float(np.percentile(v, 1)),
+            p50=float(np.percentile(v, 50)),
+        )
+    return dict(dtype=str(a.dtype), shape=tuple(a.shape), finite=0, nan=int(np.isnan(a).sum()), inf=int(np.isinf(a).sum()))
+
+def _print_stats(tag: str, a: np.ndarray, *, bit_depth=None, hdr=None):
+    s = _arr_stats(a)
+    bd = f", bit_depth={bit_depth}" if bit_depth is not None else ""
+    print(f"🧪 {tag}{bd} dtype={s['dtype']} shape={s['shape']} finite={s['finite']} nan={s['nan']} inf={s['inf']}")
+    if s["finite"] > 0:
+        print(f"    min={s['min']:.6f}  p01={s['p01']:.6f}  p50={s['p50']:.6f}  max={s['max']:.6f}")
+    # Header hints (best-effort)
+    if hdr is not None:
+        try:
+            # FITS-ish
+            if hasattr(hdr, "get"):
+                print(f"    hdr: BITPIX={hdr.get('BITPIX', 'NA')}  BSCALE={hdr.get('BSCALE', 'NA')}  BZERO={hdr.get('BZERO', 'NA')}")
+        except Exception:
+            pass
+
+def _warn_if_units_mismatch(light: np.ndarray, dark: np.ndarray | None, flat: np.ndarray | None):
+    # Heuristic: if one is ~0..1 and another is hundreds/thousands, you’ve got mixed scaling.
+    def _range_kind(a):
+        if a is None:
+            return None
+        fin = np.isfinite(a)
+        if not fin.any():
+            return None
+        mx = float(np.max(a[fin]))
+        mn = float(np.min(a[fin]))
+        return (mn, mx)
+
+    lr = _range_kind(light)
+    dr = _range_kind(dark)
+    fr = _range_kind(flat)
+
+    def _is_01(r):
+        if r is None: return False
+        mn, mx = r
+        return mx <= 2.5 and mn >= -0.5
+
+    def _is_aduish(r):
+        if r is None: return False
+        mn, mx = r
+        return mx >= 50.0  # conservative
+
+    if lr and dr and _is_01(lr) and _is_aduish(dr):
+        print("🚨 UNITS MISMATCH: light looks ~0–1, but dark looks like ADU (tens/hundreds/thousands). Expect huge negatives after subtraction.")
+    if lr and fr and _is_01(lr) and _is_aduish(fr):
+        print("🚨 UNITS MISMATCH: light looks ~0–1, but flat looks like ADU. Flat division will be wrong unless normalized to ~1 first.")
+
+def _maybe_normalize_16bit_float(a: np.ndarray, *, name: str = "") -> np.ndarray:
+    """
+    Fast guard:
+    - If float array has max > 10, assume it's really 16-bit ADU data stored as float,
+      and normalize to 0..1 by dividing by 65535.
+    """
+    if a is None:
+        return a
+    if not np.issubdtype(a.dtype, np.floating):
+        return a
+
+    fin = np.isfinite(a)
+    if not fin.any():
+        return a
+
+    mx = float(a[fin].max())  # fast reduction
+
+    if mx > 10.0:
+        print(f"🛡️ Units-guard: {name or 'array'} max={mx:.3f} (>10). Assuming 16-bit ADU-in-float; normalizing /65535.")
+        return (a / 65535.0).astype(np.float32, copy=False)
+
+    return a
+
 class StackingSuiteDialog(QDialog):
     requestRelaunch = pyqtSignal(str, str)  # old_dir, new_dir
     status_signal = pyqtSignal(str)
@@ -5362,6 +5581,20 @@ class StackingSuiteDialog(QDialog):
 
         left_col.addWidget(gb_general)
 
+        self.temp_group_step_spin = QDoubleSpinBox()
+        self.temp_group_step_spin.setRange(0.0, 20.0)          # 0 disables grouping-by-temp (optional behavior)
+        self.temp_group_step_spin.setDecimals(2)
+        self.temp_group_step_spin.setSingleStep(0.1)
+        self.temp_group_step_spin.setValue(
+            self.settings.value("stacking/temp_group_step", 1.0, type=float)
+        )
+        self.temp_group_step_spin.setToolTip(
+            self.tr("Temperature grouping tolerance in °C.\n"
+                    "Frames within ±step are grouped together.\n"
+                    "Set 0 to disable temperature-based grouping.")
+        )
+        fl_general.addRow(self.tr("Temp grouping step (°C):"), self.temp_group_step_spin)
+
         # --- Distortion / Transform model ---
         # --- Distortion / Transform model ---
         disto_box  = QGroupBox(self.tr("Distortion / Transform"))
@@ -6139,7 +6372,8 @@ class StackingSuiteDialog(QDialog):
         self.settings.setValue("stacking/chunk_width", self.chunk_width)
         self.settings.setValue("stacking/autocrop_enabled", self.autocrop_cb.isChecked())
         self.settings.setValue("stacking/autocrop_pct", float(self.autocrop_pct.value()))
-
+        self.temp_group_step = float(self.temp_group_step_spin.value())
+        self.settings.setValue("stacking/temp_group_step", self.temp_group_step)
         # ----- alignment model (affine | homography | poly3 | poly4) -----
         model_idx = self.align_model_combo.currentIndex()
         if   model_idx == 0: model_name = "affine"
@@ -10607,7 +10841,8 @@ class StackingSuiteDialog(QDialog):
                 set_t = _get_key_float(header, "SET-TEMP")
                 chosen_t = ccd_t if ccd_t is not None else set_t
 
-                temp_step = self.settings.value("stacking/temp_group_step", 1.0, type=float)
+                temp_step = float(self.settings.value("stacking/temp_group_step", 1.0, type=float) or 1.0)
+                temp_step = max(0.0, temp_step)
                 temp_bucket = self._bucket_temp(chosen_t, step=temp_step)
                 temp_label = self._temp_label(temp_bucket, step=temp_step)
 
@@ -10836,7 +11071,8 @@ class StackingSuiteDialog(QDialog):
         # Group darks by (exposure +/- tolerance, image size, session, temp_bucket)
         # TEMP_STEP is the rounding bucket (1.0C default)
         # -------------------------------------------------------------------------
-        TEMP_STEP = self.settings.value("stacking/temp_group_step", 1.0, type=float)
+        TEMP_STEP = float(self.settings.value("stacking/temp_group_step", 1.0, type=float) or 1.0)
+        TEMP_STEP = max(0.0, TEMP_STEP)
 
         dark_files_by_group: dict[tuple[float, str, str, float | None], list[str]] = {}  # (exp,size,session,temp)->list
 
@@ -13178,6 +13414,7 @@ class StackingSuiteDialog(QDialog):
 
                     # ---------- LOAD LIGHT ----------
                     light_data, hdr, bit_depth, is_mono = load_image(light_file)
+                    #_print_stats("LIGHT raw", light_data, bit_depth=bit_depth, hdr=hdr)
                     if light_data is None or hdr is None:
                         self.update_status(self.tr(f"❌ ERROR: Failed to load {os.path.basename(light_file)}"))
                         continue
@@ -13202,7 +13439,10 @@ class StackingSuiteDialog(QDialog):
 
                     # ---------- APPLY DARK (if resolved) ----------
                     if master_dark_path:
-                        dark_data, _, _, dark_is_mono = load_image(master_dark_path)
+                        dark_data, _, dark_bit_depth, dark_is_mono = load_image(master_dark_path)
+                        #_print_stats("DARK raw", dark_data, bit_depth=dark_bit_depth)
+                        dark_data = _maybe_normalize_16bit_float(dark_data, name=os.path.basename(master_dark_path))
+                        #_print_stats("DARK normalized", dark_data, bit_depth=dark_bit_depth)
                         if dark_data is not None:
                             if not dark_is_mono and dark_data.ndim == 3 and dark_data.shape[-1] == 3:
                                 dark_data = dark_data.transpose(2, 0, 1)  # HWC -> CHW
@@ -13218,7 +13458,10 @@ class StackingSuiteDialog(QDialog):
 
                     # ---------- APPLY FLAT (if resolved) ----------
                     if master_flat_path:
-                        flat_data, _, _, flat_is_mono = load_image(master_flat_path)
+                        flat_data, _, flat_bit_depth, flat_is_mono = load_image(master_flat_path)
+                        #_print_stats("FLAT raw", flat_data, bit_depth=flat_bit_depth)
+                        flat_data = _maybe_normalize_16bit_float(flat_data, name=os.path.basename(master_flat_path))
+                        #_print_stats("FLAT normalized", flat_data, bit_depth=flat_bit_depth)
                         if flat_data is not None:
 
                             # Make flat layout match your working light layout:
@@ -13332,8 +13575,10 @@ class StackingSuiteDialog(QDialog):
                     max_val = float(np.max(light_data))
                     self.update_status(self.tr(f"Before saving: min = {min_val:.4f}, max = {max_val:.4f}"))
                     print(f"Before saving: min = {min_val:.4f}, max = {max_val:.4f}")
+                    
+                    _warn_if_units_mismatch(light_data, dark_data if master_dark_path else None, flat_data if master_flat_path else None)
+                    _print_stats("LIGHT final", light_data)
                     QApplication.processEvents()
-
                     # Annotate header
                     try:
                         if hasattr(hdr, "add_history"):