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

setiastro/saspro/stacking_suite.py

@@ -16,6 +16,7 @@ import hashlib
 from numpy.lib.format import open_memmap 
 import tzlocal
 import weakref
+import ast
 import re
 import unicodedata
 import math            # used in compute_safe_chunk
@@ -1714,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:
@@ -1846,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):
@@ -1906,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:
@@ -1932,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):
@@ -1980,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."""
@@ -2013,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:
@@ -3531,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
@@ -3553,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):
         """
@@ -3658,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:
@@ -3682,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):
@@ -3706,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:
@@ -4107,6 +4239,162 @@ def _read_center_patch_via_mmimage(path: str, y0: int, y1: int, x0: int, x1: int
         except Exception:
             pass
 
+def _get_key_float(hdr: fits.Header, key: str):
+    try:
+        v = hdr.get(key, None)
+        if v is None:
+            return None
+        # handle strings like "-10.0" or "-10 C"
+        if isinstance(v, str):
+            v = v.strip().replace("C", "").replace("°", "").strip()
+        return float(v)
+    except Exception:
+        return None
+
+def _collect_temp_stats(file_list: list[str]):
+    ccd = []
+    setp = []
+    n_ccd = 0
+    n_set = 0
+
+    for p in file_list:
+        try:
+            hdr = fits.getheader(p, memmap=True)
+        except Exception:
+            continue
+
+        v1 = _get_key_float(hdr, "CCD-TEMP")
+        v2 = _get_key_float(hdr, "SET-TEMP")
+
+        if v1 is not None:
+            ccd.append(v1); n_ccd += 1
+        if v2 is not None:
+            setp.append(v2); n_set += 1
+
+    def _stats(arr):
+        if not arr:
+            return None, None, None, None
+        a = np.asarray(arr, dtype=np.float32)
+        return float(np.median(a)), float(np.min(a)), float(np.max(a)), float(np.std(a))
+
+    c_med, c_min, c_max, c_std = _stats(ccd)
+    s_med, s_min, s_max, s_std = _stats(setp)
+
+    return {
+        "ccd_med": c_med, "ccd_min": c_min, "ccd_max": c_max, "ccd_std": c_std, "ccd_n": n_ccd,
+        "set_med": s_med, "set_min": s_min, "set_max": s_max, "set_std": s_std, "set_n": n_set,
+        "n_files": len(file_list),
+    }
+
+def _temp_to_stem_tag(temp_c: float, *, prefix: str = "") -> str:
+    """
+    Filename-safe temperature token:
+      -10.0  -> 'm10p0C'
+      +5.25  -> 'p5p3C' (rounded to 0.1C if you pass that in)
+    Uses:
+      m = minus, p = plus/decimal separator
+    Never produces '_-' which your _normalize_master_stem would collapse.
+    """
+    try:
+        t = float(temp_c)
+    except Exception:
+        return ""
+
+    sign = "m" if t < 0 else "p"
+    t_abs = abs(t)
+
+    # keep one decimal place (match your earlier plan)
+    s = f"{t_abs:.1f}"          # e.g. "10.0"
+    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
@@ -5293,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"))
@@ -6070,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"
@@ -6659,6 +6962,22 @@ class StackingSuiteDialog(QDialog):
 
         return tab
     
+    def _bucket_temp(self, t: float | None, step: float = 3.0) -> float | None:
+        """Round to stable bucket. Example: -10.2 -> -10.0 when step=1.0"""
+        if t is None:
+            return None
+        try:
+            return round(float(t) / float(step)) * float(step)
+        except Exception:
+            return None
+
+    def _temp_label(self, t: float | None, step: float = 1.0) -> str:
+        if t is None:
+            return "Temp: Unknown"
+        # show fewer decimals if step is 1.0
+        return f"Temp: {t:+.0f}C" if step >= 1.0 else f"Temp: {t:+.1f}C"
+
+
     def _tree_for_type(self, t: str):
         t = (t or "").upper()
         if t == "LIGHT": return getattr(self, "light_tree", None)
@@ -10485,24 +10804,86 @@ class StackingSuiteDialog(QDialog):
                 keyword = self.settings.value("stacking/session_keyword", "Default", type=str)
                 session_tag = self._session_from_manual_keyword(path, keyword) or "Default"
 
+            # --- Temperature (fast: header already loaded) ---
+            ccd_temp = header.get("CCD-TEMP", None)
+            set_temp = header.get("SET-TEMP", None)
+
+            def _to_float_temp(v):
+                try:
+                    if v is None:
+                        return None
+                    if isinstance(v, (int, float)):
+                        return float(v)
+                    s = str(v).strip()
+                    s = s.replace("°", "").replace("C", "").replace("c", "").strip()
+                    return float(s)
+                except Exception:
+                    return None
+
+            ccd_temp_f = _to_float_temp(ccd_temp)
+            set_temp_f = _to_float_temp(set_temp)
+            use_temp_f = ccd_temp_f if ccd_temp_f is not None else set_temp_f
+
+            # --- Common metadata string for leaf rows ---
+            meta_text = f"Size: {image_size} | Session: {session_tag}"
+            if use_temp_f is not None:
+                meta_text += f" | Temp: {use_temp_f:.1f}C"
+                if set_temp_f is not None:
+                    meta_text += f" (Set: {set_temp_f:.1f}C)"
+
             # --- Common metadata string for leaf rows ---
             meta_text = f"Size: {image_size} | Session: {session_tag}"
 
             # === DARKs ===
             if expected_type_u == "DARK":
-                key = f"{exposure_text} ({image_size})"
-                self.dark_files.setdefault(key, []).append(path)
+                # --- temperature for grouping (prefer CCD-TEMP else SET-TEMP) ---
+                ccd_t = _get_key_float(header, "CCD-TEMP")
+                set_t = _get_key_float(header, "SET-TEMP")
+                chosen_t = ccd_t if ccd_t is not None else set_t
+
+                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)
+
+                # --- tree grouping: exposure/size -> temp bucket -> files ---
+                base_key = f"{exposure_text} ({image_size})"
 
-                exposure_item = self._dark_group_item.get(key)
+                # ensure caches exist
+                if not hasattr(self, "_dark_group_item") or self._dark_group_item is None:
+                    self._dark_group_item = {}
+                if not hasattr(self, "_dark_temp_item") or self._dark_temp_item is None:
+                    self._dark_temp_item = {}  # (base_key, temp_label) -> QTreeWidgetItem
+
+                # top-level exposure group
+                exposure_item = self._dark_group_item.get(base_key)
                 if exposure_item is None:
-                    exposure_item = QTreeWidgetItem([key])
+                    exposure_item = QTreeWidgetItem([base_key, ""])
                     tree.addTopLevelItem(exposure_item)
-                    self._dark_group_item[key] = exposure_item
-
-                leaf = QTreeWidgetItem([os.path.basename(path), meta_text])
+                    self._dark_group_item[base_key] = exposure_item
+
+                # second-level temp group under that exposure group
+                temp_key = (base_key, temp_label)
+                temp_item = self._dark_temp_item.get(temp_key)
+                if temp_item is None:
+                    temp_item = QTreeWidgetItem([temp_label, ""])
+                    exposure_item.addChild(temp_item)
+                    self._dark_temp_item[temp_key] = temp_item
+
+                # --- store in dict for stacking ---
+                # Key includes session + temp bucket so create_master_dark can split properly.
+                # (We keep compatibility: your create_master_dark already handles tuple keys.)
+                composite_key = (base_key, session_tag, temp_bucket)
+                self.dark_files.setdefault(composite_key, []).append(path)
+
+                # --- leaf row ---
+                # Also add temp info to metadata text so user can see it per file
+                meta_text_dark = f"Size: {image_size} | Session: {session_tag} | {temp_label}"
+                leaf = QTreeWidgetItem([os.path.basename(path), meta_text_dark])
                 leaf.setData(0, Qt.ItemDataRole.UserRole, path)
                 leaf.setData(0, Qt.ItemDataRole.UserRole + 1, session_tag)
-                exposure_item.addChild(leaf)
+                leaf.setData(0, Qt.ItemDataRole.UserRole + 2, temp_bucket)   # handy later
+                temp_item.addChild(leaf)
 
             # === FLATs ===
             elif expected_type_u == "FLAT":
@@ -10664,14 +11045,40 @@ class StackingSuiteDialog(QDialog):
         exposure_tolerance = self.exposure_tolerance_spinbox.value()
 
         # -------------------------------------------------------------------------
-        # Group darks by (exposure +/- tolerance, image size string, session)
-        # self.dark_files can be either:
-        #   legacy:  exposure_key -> [paths]
-        #   session: (exposure_key, session) -> [paths]
+        # Temp helpers
         # -------------------------------------------------------------------------
-        dark_files_by_group: dict[tuple[float, str, str], list[str]] = {}  # (exp, size, session)->list
+        def _bucket_temp(t: float | None, step: float = 3.0) -> float | None:
+            """Round temperature to a stable bucket (e.g. -10.2 -> -10.0 if step=1.0)."""
+            if t is None:
+                return None
+            try:
+                return round(float(t) / step) * step
+            except Exception:
+                return None
+
+        def _read_temp_quick(path: str) -> tuple[float | None, float | None, float | None]:
+            """Fast temp read (CCD, SET, chosen). Uses fits.getheader(memmap=True)."""
+            try:
+                hdr = fits.getheader(path, memmap=True)
+            except Exception:
+                return None, None, None
+            ccd = _get_key_float(hdr, "CCD-TEMP")
+            st  = _get_key_float(hdr, "SET-TEMP")
+            chosen = ccd if ccd is not None else st
+            return ccd, st, chosen
+
+        # -------------------------------------------------------------------------
+        # Group darks by (exposure +/- tolerance, image size, session, temp_bucket)
+        # TEMP_STEP is the rounding bucket (1.0C default)
+        # -------------------------------------------------------------------------
+        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
 
         for key, file_list in (self.dark_files or {}).items():
+            # Support both legacy dark_files (key=str) and newer tuple keys.
+            # We DO NOT assume dark_files already contains temp in key — we re-bucket from headers anyway.
             if isinstance(key, tuple) and len(key) >= 2:
                 exposure_key = str(key[0])
                 session = str(key[1]) if str(key[1]).strip() else "Default"
@@ -10683,10 +11090,9 @@ class StackingSuiteDialog(QDialog):
                 exposure_time_str, image_size = exposure_key.split(" (", 1)
                 image_size = image_size.rstrip(")")
             except ValueError:
-                # If some malformed key got in, skip safely
                 continue
 
-            if "Unknown" in exposure_time_str:
+            if "Unknown" in (exposure_time_str or ""):
                 exposure_time = 0.0
             else:
                 try:
@@ -10694,21 +11100,31 @@ class StackingSuiteDialog(QDialog):
                 except Exception:
                     exposure_time = 0.0
 
-            matched_group = None
-            for (existing_exposure, existing_size, existing_session) in list(dark_files_by_group.keys()):
-                if (
-                    existing_session == session
-                    and existing_size == image_size
-                    and abs(existing_exposure - exposure_time) <= exposure_tolerance
-                ):
-                    matched_group = (existing_exposure, existing_size, existing_session)
-                    break
+            # Split the incoming list by temp bucket so mixed temps do not merge.
+            bucketed: dict[float | None, list[str]] = {}
+            for p in (file_list or []):
+                _, _, chosen = _read_temp_quick(p)
+                tb = _bucket_temp(chosen, step=TEMP_STEP)
+                bucketed.setdefault(tb, []).append(p)
+
+            # Apply exposure tolerance grouping PER temp bucket
+            for temp_bucket, paths_in_bucket in bucketed.items():
+                matched_group = None
+                for (existing_exposure, existing_size, existing_session, existing_temp) in list(dark_files_by_group.keys()):
+                    if (
+                        existing_session == session
+                        and existing_size == image_size
+                        and existing_temp == temp_bucket
+                        and abs(existing_exposure - exposure_time) <= exposure_tolerance
+                    ):
+                        matched_group = (existing_exposure, existing_size, existing_session, existing_temp)
+                        break
 
-            if matched_group is None:
-                matched_group = (exposure_time, image_size, session)
-                dark_files_by_group[matched_group] = []
+                if matched_group is None:
+                    matched_group = (exposure_time, image_size, session, temp_bucket)
+                    dark_files_by_group[matched_group] = []
 
-            dark_files_by_group[matched_group].extend(file_list or [])
+                dark_files_by_group[matched_group].extend(paths_in_bucket)
 
         master_dir = os.path.join(self.stacking_directory, "Master_Calibration_Files")
         os.makedirs(master_dir, exist_ok=True)
@@ -10717,11 +11133,11 @@ class StackingSuiteDialog(QDialog):
         # Informative status about discovery
         # -------------------------------------------------------------------------
         try:
-            n_groups = sum(1 for _, v in dark_files_by_group.items() if len(v) >= 2)
+            n_groups_eligible = sum(1 for _, v in dark_files_by_group.items() if len(v) >= 2)
             total_files = sum(len(v) for v in dark_files_by_group.values())
             self.update_status(self.tr(
                 f"🔎 Discovered {len(dark_files_by_group)} grouped exposures "
-                f"({n_groups} eligible to stack) — {total_files} files total."
+                f"({n_groups_eligible} eligible to stack) — {total_files} files total."
             ))
         except Exception:
             pass
@@ -10731,12 +11147,12 @@ class StackingSuiteDialog(QDialog):
         # Pre-count tiles for progress bar (per-group safe chunk sizes)
         # -------------------------------------------------------------------------
         total_tiles = 0
-        group_shapes: dict[tuple[float, str, str], tuple[int, int, int, int, int]] = {}  # (exp,size,session)->(H,W,C,ch,cw)
+        group_shapes: dict[tuple[float, str, str, float | None], tuple[int, int, int, int, int]] = {}
         pref_chunk_h = self.chunk_height
         pref_chunk_w = self.chunk_width
         DTYPE = np.float32
 
-        for (exposure_time, image_size, session), file_list in dark_files_by_group.items():
+        for (exposure_time, image_size, session, temp_bucket), file_list in dark_files_by_group.items():
             if len(file_list) < 2:
                 continue
 
@@ -10754,7 +11170,8 @@ class StackingSuiteDialog(QDialog):
             except MemoryError:
                 chunk_h, chunk_w = pref_chunk_h, pref_chunk_w
 
-            group_shapes[(exposure_time, image_size, session)] = (H, W, C, chunk_h, chunk_w)
+            gk = (exposure_time, image_size, session, temp_bucket)
+            group_shapes[gk] = (H, W, C, chunk_h, chunk_w)
             total_tiles += _count_tiles(H, W, chunk_h, chunk_w)
 
         if total_tiles == 0:
@@ -10767,7 +11184,7 @@ class StackingSuiteDialog(QDialog):
         QApplication.processEvents()
 
         # -------------------------------------------------------------------------
-        # Local CPU reducers (unchanged)
+        # Local CPU reducers
         # -------------------------------------------------------------------------
         def _select_reducer(kind: str, N: int):
             if kind == "dark":
@@ -10811,10 +11228,10 @@ class StackingSuiteDialog(QDialog):
             # ---------------------------------------------------------------------
             # Per-group stacking loop
             # ---------------------------------------------------------------------
-            for (exposure_time, image_size, session), file_list in dark_files_by_group.items():
+            for (exposure_time, image_size, session, temp_bucket), file_list in dark_files_by_group.items():
                 if len(file_list) < 2:
                     self.update_status(self.tr(
-                        f"⚠️ Skipping {exposure_time}s ({image_size}) [{session}] - Not enough frames to stack."
+                        f"⚠️ Skipping {exposure_time:g}s ({image_size}) [{session}] - Not enough frames to stack."
                     ))
                     QApplication.processEvents()
                     continue
@@ -10823,14 +11240,17 @@ class StackingSuiteDialog(QDialog):
                     self.update_status(self.tr("⛔ Master Dark creation cancelled."))
                     break
 
+                temp_txt = "Unknown" if temp_bucket is None else f"{float(temp_bucket):+.1f}C"
                 self.update_status(self.tr(
-                    f"🟢 Processing {len(file_list)} darks for {exposure_time}s ({image_size}) in session '{session}'…"
+                    f"🟢 Processing {len(file_list)} darks for {exposure_time:g}s ({image_size}) "
+                    f"in session '{session}' at {temp_txt}…"
                 ))
                 QApplication.processEvents()
 
                 # --- reference shape and per-group chunk size ---
-                if (exposure_time, image_size, session) in group_shapes:
-                    height, width, channels, chunk_height, chunk_width = group_shapes[(exposure_time, image_size, session)]
+                gk = (exposure_time, image_size, session, temp_bucket)
+                if gk in group_shapes:
+                    height, width, channels, chunk_height, chunk_width = group_shapes[gk]
                 else:
                     ref_data, _, _, _ = load_image(file_list[0])
                     if ref_data is None:
@@ -10870,8 +11290,11 @@ class StackingSuiteDialog(QDialog):
                     QApplication.processEvents()
                     continue
 
-                # Include session to prevent collisions
-                memmap_path = os.path.join(master_dir, f"temp_dark_{session}_{exposure_time}_{image_size}.dat")
+                # Create temp memmap (stem-safe normalization)
+                tb_tag = "notemp" if temp_bucket is None else _temp_to_stem_tag(float(temp_bucket))
+                memmap_base = f"temp_dark_{session}_{exposure_time:g}s_{image_size}_{tb_tag}.dat"
+                memmap_base = self._normalize_master_stem(memmap_base)
+                memmap_path = os.path.join(master_dir, memmap_base)
 
                 self.update_status(self.tr(
                     f"🗂️ Creating temp memmap: {os.path.basename(memmap_path)} "
@@ -10883,6 +11306,7 @@ class StackingSuiteDialog(QDialog):
 
                 tiles = _tile_grid(height, width, chunk_height, chunk_width)
                 total_tiles_group = len(tiles)
+
                 self.update_status(self.tr(
                     f"📦 {total_tiles_group} tiles to process for this group (chunk {chunk_height}×{chunk_width})."
                 ))
@@ -10924,7 +11348,7 @@ class StackingSuiteDialog(QDialog):
                         fut = tp.submit(_read_tile_into, (buf1 if use0 else buf0), ny0, ny1, nx0, nx1)
 
                     pd.set_label(
-                        f"{int(exposure_time)}s ({image_size}) [{session}] — "
+                        f"{int(exposure_time)}s ({image_size}) [{session}] [{temp_txt}] — "
                         f"tile {t_idx}/{total_tiles_group} y:{y0}-{y1} x:{x0}-{x1}"
                     )
 
@@ -10954,6 +11378,7 @@ class StackingSuiteDialog(QDialog):
 
                     if tile_result.ndim == 2:
                         tile_result = tile_result[:, :, None]
+
                     expected_shape = (th, tw, channels)
                     if tile_result.shape != expected_shape:
                         if tile_result.shape[:2] == (th, tw):
@@ -10988,37 +11413,115 @@ class StackingSuiteDialog(QDialog):
                         pass
                     break
 
+                # -------------------------------------------------------------
+                # Materialize final memmap to ndarray for save
+                # -------------------------------------------------------------
                 master_dark_data = np.asarray(final_stacked, dtype=np.float32)
-                del final_stacked
+                try:
+                    del final_stacked
+                except Exception:
+                    pass
                 gc.collect()
+
                 try:
                     os.remove(memmap_path)
                 except Exception:
                     pass
 
-                # Include session in output name
-                master_dark_stem = f"MasterDark_{session}_{int(exposure_time)}s_{image_size}"
+                # -------------------------------------------------------------
+                # Collect temperature stats from input dark headers
+                # -------------------------------------------------------------
+                temp_info = {}
+                try:
+                    temp_info = _collect_temp_stats(file_list) or {}
+                except Exception:
+                    temp_info = {}
+
+                # -------------------------------------------------------------
+                # Build output filename (include session + exposure + size + temp bucket tag)
+                # -------------------------------------------------------------
+                temp_tag = ""
+                try:
+                    if temp_bucket is not None:
+                        temp_tag = "_" + _temp_to_stem_tag(float(temp_bucket))
+                    elif temp_info.get("ccd_med") is not None:
+                        temp_tag = "_" + _temp_to_stem_tag(float(temp_info["ccd_med"]))
+                    elif temp_info.get("set_med") is not None:
+                        temp_tag = "_" + _temp_to_stem_tag(float(temp_info["set_med"]), prefix="set")
+                except Exception:
+                    temp_tag = ""
+
+                master_dark_stem = f"MasterDark_{session}_{int(exposure_time)}s_{image_size}{temp_tag}"
+                master_dark_stem = self._normalize_master_stem(master_dark_stem)
                 master_dark_path = self._build_out(master_dir, master_dark_stem, "fit")
 
+                # -------------------------------------------------------------
+                # Header
+                # -------------------------------------------------------------
                 master_header = fits.Header()
                 master_header["IMAGETYP"] = "DARK"
-                master_header["EXPTIME"] = (exposure_time, "User-specified or from grouping")
-                master_header["SESSION"] = (session, "User session tag")  # optional but useful
-                master_header["NAXIS"] = 3 if channels == 3 else 2
-                master_header["NAXIS1"] = master_dark_data.shape[1]
-                master_header["NAXIS2"] = master_dark_data.shape[0]
+                master_header["EXPTIME"]  = (float(exposure_time), "Exposure time (s)")
+                master_header["SESSION"]  = (str(session), "User session tag")
+                master_header["NCOMBINE"] = (int(N), "Number of darks combined")
+                master_header["NSTACK"]   = (int(N), "Alias of NCOMBINE (SetiAstro)")
+
+                # Temperature provenance (only write keys that exist)
+                if temp_info.get("ccd_med") is not None:
+                    master_header["CCD-TEMP"] = (float(temp_info["ccd_med"]), "Median CCD temp of input darks (C)")
+                    if temp_info.get("ccd_min") is not None:
+                        master_header["CCDTMIN"] = (float(temp_info["ccd_min"]), "Min CCD temp in input darks (C)")
+                    if temp_info.get("ccd_max") is not None:
+                        master_header["CCDTMAX"] = (float(temp_info["ccd_max"]), "Max CCD temp in input darks (C)")
+                    if temp_info.get("ccd_std") is not None:
+                        master_header["CCDTSTD"] = (float(temp_info["ccd_std"]), "Std CCD temp in input darks (C)")
+                    if temp_info.get("ccd_n") is not None:
+                        master_header["CCDTN"] = (int(temp_info["ccd_n"]), "Count of frames with CCD-TEMP")
+
+                if temp_info.get("set_med") is not None:
+                    master_header["SET-TEMP"] = (float(temp_info["set_med"]), "Median setpoint temp of input darks (C)")
+                    if temp_info.get("set_min") is not None:
+                        master_header["SETTMIN"] = (float(temp_info["set_min"]), "Min setpoint in input darks (C)")
+                    if temp_info.get("set_max") is not None:
+                        master_header["SETTMAX"] = (float(temp_info["set_max"]), "Max setpoint in input darks (C)")
+                    if temp_info.get("set_std") is not None:
+                        master_header["SETTSTD"] = (float(temp_info["set_std"]), "Std setpoint in input darks (C)")
+                    if temp_info.get("set_n") is not None:
+                        master_header["SETTN"] = (int(temp_info["set_n"]), "Count of frames with SET-TEMP")
+
+                # Dimensions (save_image usually writes these, but keep your existing behavior)
+                master_header["NAXIS"]  = 3 if channels == 3 else 2
+                master_header["NAXIS1"] = int(master_dark_data.shape[1])
+                master_header["NAXIS2"] = int(master_dark_data.shape[0])
                 if channels == 3:
                     master_header["NAXIS3"] = 3
 
-                save_image(master_dark_data, master_dark_path, "fit", "32-bit floating point", master_header, is_mono=(channels == 1))
+                save_image(
+                    master_dark_data,
+                    master_dark_path,
+                    "fit",
+                    "32-bit floating point",
+                    master_header,
+                    is_mono=(channels == 1)
+                )
+
+                # Tree label includes temp for visibility
+                tree_label = f"{exposure_time:g}s ({image_size}) [{session}]"
+                if temp_info.get("ccd_med") is not None:
+                    tree_label += f" [CCD {float(temp_info['ccd_med']):+.1f}C]"
+                elif temp_info.get("set_med") is not None:
+                    tree_label += f" [SET {float(temp_info['set_med']):+.1f}C]"
+                elif temp_bucket is not None:
+                    tree_label += f" [TEMP {float(temp_bucket):+.1f}C]"
 
-                self.add_master_dark_to_tree(f"{exposure_time}s ({image_size}) [{session}]", master_dark_path)
+                self.add_master_dark_to_tree(tree_label, master_dark_path)
                 self.update_status(self.tr(f"✅ Master Dark saved: {master_dark_path}"))
                 QApplication.processEvents()
 
+                # Refresh assignments + persistence
                 self.assign_best_master_files()
                 self.save_master_paths_to_settings()
 
+            # Post pass refresh (unchanged behavior)
             self.assign_best_master_dark()
             self.update_override_dark_combo()
             self.assign_best_master_files()
@@ -11031,7 +11534,6 @@ class StackingSuiteDialog(QDialog):
                 logging.debug(f"Exception suppressed: {type(e).__name__}: {e}")
             pd.close()
 
-      
     def add_master_dark_to_tree(self, exposure_label: str, master_dark_path: str):
         """
         Adds the newly created Master Dark to the Master Dark TreeBox and updates the dropdown.
@@ -12079,6 +12581,140 @@ class StackingSuiteDialog(QDialog):
         master_item = QTreeWidgetItem([os.path.basename(master_flat_path)])
         filter_item.addChild(master_item)
 
+    def _parse_float(self, v):
+        try:
+            if v is None:
+                return None
+            if isinstance(v, (int, float)):
+                return float(v)
+            s = str(v).strip()
+            # handle " -10.0 C" or "-10.0C"
+            s = s.replace("°", "").replace("C", "").replace("c", "").strip()
+            return float(s)
+        except Exception:
+            return None
+
+
+    def _read_ccd_set_temp_from_fits(self, path: str) -> tuple[float|None, float|None]:
+        """Read CCD-TEMP and SET-TEMP from FITS header (primary HDU)."""
+        try:
+            with fits.open(path) as hdul:
+                hdr = hdul[0].header
+                ccd = self._parse_float(hdr.get("CCD-TEMP", None))
+                st  = self._parse_float(hdr.get("SET-TEMP", None))
+                return ccd, st
+        except Exception:
+            return None, None
+
+
+    def _temp_for_matching(self, ccd: float|None, st: float|None) -> float|None:
+        """Prefer CCD-TEMP; else SET-TEMP; else None."""
+        return ccd if ccd is not None else (st if st is not None else None)
+
+
+    def _parse_masterdark_name(self, stem: str):
+        """
+        From filename like:
+        MasterDark_Session_300s_4144x2822_m10p0C.fit
+        Return dict fields; temp is optional.
+        """
+        out = {"session": None, "exp": None, "size": None, "temp": None}
+
+        base = os.path.basename(stem)
+        base = os.path.splitext(base)[0]
+
+        # session is between MasterDark_ and _<exp>s_
+        # exp is <num>s
+        # size is <WxH> like 4144x2822
+        m = re.match(r"^MasterDark_(?P<session>.+?)_(?P<exp>[\d._]+)s_(?P<size>\d+x\d+)(?:_(?P<temp>.*))?$", base)
+        if not m:
+            return out
+
+        out["session"] = (m.group("session") or "").strip()
+        # exp might be "2_5" from _normalize_master_stem; convert back
+        exp_txt = (m.group("exp") or "").replace("_", ".")
+        try:
+            out["exp"] = float(exp_txt)
+        except Exception:
+            out["exp"] = None
+
+        out["size"] = m.group("size")
+
+        # temp token like m10p0C / p5p0C / setm10p0C
+        t = (m.group("temp") or "").strip()
+        if t:
+            # pick the first temp-ish token ending in C
+            mt = re.search(r"(set)?([mp])(\d+)p(\d)C", t)
+            if mt:
+                sign = -1.0 if mt.group(2) == "m" else 1.0
+                whole = float(mt.group(3))
+                frac = float(mt.group(4)) / 10.0
+                out["temp"] = sign * (whole + frac)
+
+        return out
+
+
+    def _get_master_dark_meta(self, path: str) -> dict:
+        """
+        Cached metadata for a master dark.
+        Prefers FITS header for temp; falls back to filename temp token.
+        """
+        if not hasattr(self, "_master_dark_meta_cache"):
+            self._master_dark_meta_cache = {}
+        cache = self._master_dark_meta_cache
+
+        p = os.path.normpath(path)
+        if p in cache:
+            return cache[p]
+
+        meta = {"path": p, "session": None, "exp": None, "size": None,
+                "ccd": None, "set": None, "temp": None}
+
+        # filename parse (fast)
+        fn = self._parse_masterdark_name(p)
+        meta["session"] = fn.get("session") or None
+        meta["exp"]     = fn.get("exp")
+        meta["size"]    = fn.get("size")
+        meta["temp"]    = fn.get("temp")
+
+        # header parse (authoritative for temps)
+        ccd, st = self._read_ccd_set_temp_from_fits(p)
+        meta["ccd"] = ccd
+        meta["set"] = st
+        meta["temp"] = self._temp_for_matching(ccd, st) if (ccd is not None or st is not None) else meta["temp"]
+
+        # size from header if missing
+        if not meta["size"]:
+            try:
+                with fits.open(p) as hdul:
+                    data = hdul[0].data
+                    if data is not None:
+                        meta["size"] = f"{data.shape[1]}x{data.shape[0]}"
+            except Exception:
+                pass
+
+        cache[p] = meta
+        return meta
+
+
+    def _get_light_temp(self, light_path: str) -> tuple[float|None, float|None, float|None]:
+        """Return (ccd, set, chosen) with caching."""
+        if not hasattr(self, "_light_temp_cache"):
+            self._light_temp_cache = {}
+        cache = self._light_temp_cache
+
+        p = os.path.normpath(light_path or "")
+        if not p:
+            return None, None, None
+        if p in cache:
+            return cache[p]
+
+        ccd, st = self._read_ccd_set_temp_from_fits(p)
+        chosen = self._temp_for_matching(ccd, st)
+        cache[p] = (ccd, st, chosen)
+        return cache[p]
+
+
     def assign_best_master_files(self, fill_only: bool = True):
         """
         Assign best matching Master Dark and Flat to each Light leaf.
@@ -12138,32 +12774,57 @@ class StackingSuiteDialog(QDialog):
                         if fill_only and curr_dark and curr_dark.lower() != "none":
                             dark_choice = curr_dark
                         else:
-                            # 3) Auto-pick by size+closest exposure
-                            best_dark_match = None
-                            best_dark_diff = float("inf")
-                            for master_key, master_path in self.master_files.items():
-                                dmatch = re.match(r"^([\d.]+)s\b", master_key)  # darks start with "<exp>s"
-                                if not dmatch:
+                            # 3) Auto-pick by size + closest exposure + closest temperature (and prefer same session)
+                            light_path = leaf_item.data(0, Qt.ItemDataRole.UserRole)
+                            l_ccd, l_set, l_temp = self._get_light_temp(light_path)
+
+                            best_path = None
+                            best_score = None
+
+                            for mk, mp in (self.master_files or {}).items():
+                                if not mp:
                                     continue
-                                master_dark_exposure_time = float(dmatch.group(1))
 
-                                # Ensure size known/cached
-                                md_size = master_sizes.get(master_path)
-                                if not md_size:
-                                    try:
-                                        with fits.open(master_path) as hdul:
-                                            md_size = f"{hdul[0].data.shape[1]}x{hdul[0].data.shape[0]}"
-                                    except Exception:
-                                        md_size = "Unknown"
-                                    master_sizes[master_path] = md_size
+                                bn = os.path.basename(mp)
+                                # Only consider MasterDark_* files (cheap gate)
+                                if not bn.startswith("MasterDark_"):
+                                    continue
+
+                                md = self._get_master_dark_meta(mp)
+                                md_size = md.get("size") or "Unknown"
+                                if md_size != image_size:
+                                    continue
+
+                                md_exp = md.get("exp")
+                                if md_exp is None:
+                                    continue
 
-                                if md_size == image_size:
-                                    diff = abs(master_dark_exposure_time - exposure_time)
-                                    if diff < best_dark_diff:
-                                        best_dark_diff = diff
-                                        best_dark_match = master_path
+                                # exposure closeness
+                                exp_diff = abs(float(md_exp) - float(exposure_time))
 
-                            dark_choice = os.path.basename(best_dark_match) if best_dark_match else ("None" if not curr_dark else curr_dark)
+                                # session preference: exact match beats mismatch
+                                md_sess = (md.get("session") or "Default").strip()
+                                sess_mismatch = 0 if md_sess == session_name else 1
+
+                                # temperature closeness (if both known)
+                                md_temp = md.get("temp")
+                                if (l_temp is not None) and (md_temp is not None):
+                                    temp_diff = abs(float(md_temp) - float(l_temp))
+                                    temp_unknown = 0
+                                else:
+                                    # if light has temp but dark doesn't (or vice versa), penalize
+                                    temp_diff = 9999.0
+                                    temp_unknown = 1
+
+                                # Score tuple: lower is better
+                                # Priority: session match -> exposure diff -> temp availability -> temp diff
+                                score = (sess_mismatch, exp_diff, temp_unknown, temp_diff)
+
+                                if best_score is None or score < best_score:
+                                    best_score = score
+                                    best_path = mp
+
+                            dark_choice = os.path.basename(best_path) if best_path else ("None" if not curr_dark else curr_dark)
 
                     # ---------- FLAT RESOLUTION ----------
                     flat_key_full  = f"{filter_name_raw} - {exposure_text}"
@@ -12753,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
@@ -12777,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
@@ -12793,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:
@@ -12907,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"):
@@ -16328,6 +16998,10 @@ class StackingSuiteDialog(QDialog):
             hdr_orig["CREATOR"]  = "SetiAstroSuite"
             hdr_orig["DATE-OBS"] = datetime.utcnow().isoformat()
 
+            n_frames_group = len(file_list)
+            hdr_orig["NCOMBINE"] = (int(n_frames_group), "Number of frames combined")
+            hdr_orig["NSTACK"]   = (int(n_frames_group), "Alias of NCOMBINE (SetiAstro)")
+
             is_mono_orig = (integrated_image.ndim == 2)
             if is_mono_orig:
                 hdr_orig["NAXIS"]  = 2
@@ -16447,6 +17121,8 @@ class StackingSuiteDialog(QDialog):
                     scale=1.0,
                     rect_override=group_rect if group_rect is not None else global_rect
                 )
+                hdr_crop["NCOMBINE"] = (int(n_frames_group), "Number of frames combined")
+                hdr_crop["NSTACK"]   = (int(n_frames_group), "Alias of NCOMBINE (SetiAstro)")
                 is_mono_crop = (cropped_img.ndim == 2)
                 Hc, Wc = (cropped_img.shape[:2] if cropped_img.ndim >= 2 else (H, W))
                 display_group_crop = self._label_with_dims(group_key, Wc, Hc)
@@ -16590,6 +17266,12 @@ class StackingSuiteDialog(QDialog):
                         algo_override=COMET_ALGO  # << comet-friendly reducer
                     )
 
+                    n_usable = int(len(usable))
+                    ref_header_c = ref_header_c or ref_header or fits.Header()
+                    ref_header_c["NCOMBINE"] = (n_usable, "Number of frames combined (comet)")
+                    ref_header_c["NSTACK"]   = (n_usable, "Alias of NCOMBINE (SetiAstro)")
+                    ref_header_c["COMETFR"]  = (n_usable, "Frames used for comet-aligned stack")
+
                     # Save CometOnly
                     Hc, Wc = comet_only.shape[:2]
                     display_group_c = self._label_with_dims(group_key, Wc, Hc)
@@ -16614,6 +17296,10 @@ class StackingSuiteDialog(QDialog):
                             scale=1.0,
                             rect_override=group_rect if group_rect is not None else global_rect
                         )
+                        comet_only_crop, hdr_c_crop = self._apply_autocrop(...)
+                        hdr_c_crop["NCOMBINE"] = (n_usable, "Number of frames combined (comet)")
+                        hdr_c_crop["NSTACK"]   = (n_usable, "Alias of NCOMBINE (SetiAstro)")
+                        hdr_c_crop["COMETFR"]  = (n_usable, "Frames used for comet-aligned stack")                        
                         Hcc, Wcc = comet_only_crop.shape[:2]
                         display_group_cc = self._label_with_dims(group_key, Wcc, Hcc)
                         comet_path_crop = self._build_out(
@@ -17201,246 +17887,6 @@ class StackingSuiteDialog(QDialog):
             views[p] = np.load(npy, mmap_mode="r")  # returns numpy.memmap
         return views
 
-
-    def stack_registered_images_chunked(
-        self,
-        grouped_files,
-        frame_weights,
-        chunk_height=2048,
-        chunk_width=2048
-    ):
-        self.update_status(self.tr(f"✅ Chunked stacking {len(grouped_files)} group(s)..."))
-        QApplication.processEvents()
-
-        all_rejection_coords = []
-
-        for group_key, file_list in grouped_files.items():
-            num_files = len(file_list)
-            self.update_status(self.tr(f"📊 Group '{group_key}' has {num_files} aligned file(s)."))
-            QApplication.processEvents()
-            if num_files < 2:
-                self.update_status(self.tr(f"⚠️ Group '{group_key}' does not have enough frames to stack."))
-                continue
-
-            # Reference shape/header (unchanged)
-            ref_file = file_list[0]
-            if not os.path.exists(ref_file):
-                self.update_status(self.tr(f"⚠️ Reference file '{ref_file}' not found, skipping group."))
-                continue
-
-            ref_data, ref_header, _, _ = load_image(ref_file)
-            if ref_data is None:
-                self.update_status(self.tr(f"⚠️ Could not load reference '{ref_file}', skipping group."))
-                continue
-
-            is_color = (ref_data.ndim == 3 and ref_data.shape[2] == 3)
-            height, width = ref_data.shape[:2]
-            channels = 3 if is_color else 1
-
-            # Final output memmap (unchanged)
-            memmap_path = self._build_out(self.stacking_directory, f"chunked_{group_key}", "dat")
-            final_stacked = np.memmap(memmap_path, dtype=np.float32, mode='w+', shape=(height, width, channels))
-
-            # Valid files + weights
-            aligned_paths, weights_list = [], []
-            for fpath in file_list:
-                if os.path.exists(fpath):
-                    aligned_paths.append(fpath)
-                    weights_list.append(frame_weights.get(fpath, 1.0))
-                else:
-                    self.update_status(self.tr(f"⚠️ File not found: {fpath}, skipping."))
-            if len(aligned_paths) < 2:
-                self.update_status(self.tr(f"⚠️ Not enough valid frames in group '{group_key}' to stack."))
-                continue
-
-            weights_list = np.array(weights_list, dtype=np.float32)
-
-            # ⬇️ NEW: open read-only memmaps for all aligned frames (float32 [0..1], HxWxC)
-            mm_views = self._open_memmaps_readonly(aligned_paths)
-
-            self.update_status(self.tr(f"📊 Stacking group '{group_key}' with {self.rejection_algorithm}"))
-            QApplication.processEvents()
-
-            rejection_coords = []
-            N = len(aligned_paths)
-            DTYPE  = self._dtype()
-            pref_h = self.chunk_height
-            pref_w = self.chunk_width
-
-            try:
-                chunk_h, chunk_w = compute_safe_chunk(height, width, N, channels, DTYPE, pref_h, pref_w)
-                self.update_status(self.tr(f"🔧 Using chunk size {chunk_h}×{chunk_w} for {self._dtype()}"))
-            except MemoryError as e:
-                self.update_status(self.tr(f"⚠️ {e}"))
-                return None, {}, None
-
-            # Tile loop (same structure, but tile loading reads from memmaps)
-            from concurrent.futures import ThreadPoolExecutor, as_completed
-            LOADER_WORKERS = min(max(2, (os.cpu_count() or 4) // 2), 8)  # tuned for memory bw
-
-            for y_start in range(0, height, chunk_h):
-                y_end  = min(y_start + chunk_h, height)
-                tile_h = y_end - y_start
-
-                for x_start in range(0, width, chunk_w):
-                    x_end  = min(x_start + chunk_w, width)
-                    tile_w = x_end - x_start
-
-                    # Preallocate tile stack
-                    tile_stack = np.empty((N, tile_h, tile_w, channels), dtype=np.float32)
-
-                    # ⬇️ NEW: fill tile_stack from the memmaps (parallel copy)
-                    def _copy_one(i, path):
-                        v = mm_views[path][y_start:y_end, x_start:x_end]  # view on disk
-                        if v.ndim == 2:
-                            # mono memmap stored as (H,W,1); but if legacy mono npy exists as (H,W),
-                            # make it (H,W,1) here:
-                            vv = v[..., None]
-                        else:
-                            vv = v
-                        if vv.shape[2] == 1 and channels == 3:
-                            vv = np.repeat(vv, 3, axis=2)
-                        tile_stack[i] = vv
-
-                    with ThreadPoolExecutor(max_workers=LOADER_WORKERS) as exe:
-                        futs = {exe.submit(_copy_one, i, p): i for i, p in enumerate(aligned_paths)}
-                        for _ in as_completed(futs):
-                            pass
-
-                    # Rejection (unchanged – uses your Numba kernels)
-                    algo = self.rejection_algorithm
-                    if algo == "Simple Median (No Rejection)":
-                        tile_result  = np.median(tile_stack, axis=0)
-                        tile_rej_map = np.zeros(tile_stack.shape[1:3], dtype=np.bool_)
-                    elif algo == "Simple Average (No Rejection)":
-                        tile_result  = np.average(tile_stack, axis=0, weights=weights_list)
-                        tile_rej_map = np.zeros(tile_stack.shape[1:3], dtype=np.bool_)
-                    elif algo == "Weighted Windsorized Sigma Clipping":
-                        tile_result, tile_rej_map = windsorized_sigma_clip_weighted(
-                            tile_stack, weights_list, lower=self.sigma_low, upper=self.sigma_high
-                        )
-                    elif algo == "Kappa-Sigma Clipping":
-                        tile_result, tile_rej_map = kappa_sigma_clip_weighted(
-                            tile_stack, weights_list, kappa=self.kappa, iterations=self.iterations
-                        )
-                    elif algo == "Trimmed Mean":
-                        tile_result, tile_rej_map = trimmed_mean_weighted(
-                            tile_stack, weights_list, trim_fraction=self.trim_fraction
-                        )
-                    elif algo == "Extreme Studentized Deviate (ESD)":
-                        tile_result, tile_rej_map = esd_clip_weighted(
-                            tile_stack, weights_list, threshold=self.esd_threshold
-                        )
-                    elif algo == "Biweight Estimator":
-                        tile_result, tile_rej_map = biweight_location_weighted(
-                            tile_stack, weights_list, tuning_constant=self.biweight_constant
-                        )
-                    elif algo == "Modified Z-Score Clipping":
-                        tile_result, tile_rej_map = modified_zscore_clip_weighted(
-                            tile_stack, weights_list, threshold=self.modz_threshold
-                        )
-                    elif algo == "Max Value":
-                        tile_result, tile_rej_map = max_value_stack(
-                            tile_stack, weights_list
-                        )
-                    else:
-                        tile_result, tile_rej_map = windsorized_sigma_clip_weighted(
-                            tile_stack, weights_list, lower=self.sigma_low, upper=self.sigma_high
-                        )
-
-                    # Ensure tile_result has correct shape
-                    if tile_result.ndim == 2:
-                        tile_result = tile_result[:, :, None]
-                    expected_shape = (tile_h, tile_w, channels)
-                    if tile_result.shape != expected_shape:
-                        if tile_result.shape[2] == 0:
-                            tile_result = np.zeros(expected_shape, dtype=np.float32)
-                        elif tile_result.shape[:2] == (tile_h, tile_w):
-                            if tile_result.shape[2] > channels:
-                                tile_result = tile_result[:, :, :channels]
-                            else:
-                                tile_result = np.repeat(tile_result, channels, axis=2)[:, :, :channels]
-
-                    # Commit tile
-                    final_stacked[y_start:y_end, x_start:x_end, :] = tile_result
-
-                    # Collect per-tile rejection coords (unchanged logic)
-                    if tile_rej_map.ndim == 3:          # (N, tile_h, tile_w)
-                        combined_rej = np.any(tile_rej_map, axis=0)
-                    elif tile_rej_map.ndim == 4:        # (N, tile_h, tile_w, C)
-                        combined_rej = np.any(tile_rej_map, axis=0)
-                        combined_rej = np.any(combined_rej, axis=-1)
-                    else:
-                        combined_rej = np.zeros((tile_h, tile_w), dtype=np.bool_)
-
-                    ys_tile, xs_tile = np.where(combined_rej)
-                    for dy, dx in zip(ys_tile, xs_tile):
-                        rejection_coords.append((x_start + dx, y_start + dy))
-
-            # Finish/save (unchanged from your version) …
-            final_array = np.array(final_stacked)
-            del final_stacked
-
-            final_array = self._normalize_stack_01(final_array)
-
-            if final_array.ndim == 3 and final_array.shape[-1] == 1:
-                final_array = final_array[..., 0]
-            is_mono = (final_array.ndim == 2)
-
-            if ref_header is None:
-                ref_header = fits.Header()
-            ref_header["IMAGETYP"] = "MASTER STACK"
-            ref_header["BITPIX"] = -32
-            ref_header["STACKED"] = (True, "Stacked using chunked approach")
-            ref_header["CREATOR"] = "SetiAstroSuite"
-            ref_header["DATE-OBS"] = datetime.utcnow().isoformat()
-            if is_mono:
-                ref_header["NAXIS"]  = 2
-                ref_header["NAXIS1"] = final_array.shape[1]
-                ref_header["NAXIS2"] = final_array.shape[0]
-                if "NAXIS3" in ref_header: del ref_header["NAXIS3"]
-            else:
-                ref_header["NAXIS"]  = 3
-                ref_header["NAXIS1"] = final_array.shape[1]
-                ref_header["NAXIS2"] = final_array.shape[0]
-                ref_header["NAXIS3"] = 3
-
-            output_stem = f"MasterLight_{group_key}_{len(aligned_paths)}stacked"
-            output_path  = self._build_out(self.stacking_directory, output_stem, "fit")
-
-            save_image(
-                img_array=final_array,
-                filename=output_path,
-                original_format="fit",
-                bit_depth="32-bit floating point",
-                original_header=ref_header,
-                is_mono=is_mono
-            )
-
-            self.update_status(self.tr(f"✅ Group '{group_key}' stacked {len(aligned_paths)} frame(s)! Saved: {output_path}"))
-
-            print(f"✅ Master Light saved for group '{group_key}': {output_path}")
-
-            # Optionally, you might want to store or log 'rejection_coords' (here appended to all_rejection_coords)
-            all_rejection_coords.extend(rejection_coords)
-
-            # Clean up memmap file
-            try:
-                os.remove(memmap_path)
-            except OSError:
-                pass
-
-        QMessageBox.information(
-            self,
-            "Stacking Complete",
-            f"All stacking finished successfully.\n"
-            f"Frames per group:\n" +
-            "\n".join([f"{group_key}: {len(files)} frame(s)" for group_key, files in grouped_files.items()])
-        )
-
-        # Optionally, you could return the global rejection coordinate list.
-        return all_rejection_coords        
-
     def _start_after_align_worker(self, aligned_light_files: dict[str, list[str]]):
         # Snapshot UI settings
         if getattr(self, "_suppress_normal_integration_once", False):
@@ -18455,6 +18901,10 @@ class StackingSuiteDialog(QDialog):
         hdr_orig["CREATOR"]    = "SetiAstroSuite"
         hdr_orig["DATE-OBS"]   = datetime.utcnow().isoformat()
 
+        n_frames = int(len(file_list))
+        hdr_orig["NCOMBINE"] = (n_frames, "Number of frames combined")
+        hdr_orig["NSTACK"]   = (n_frames, "Alias of NCOMBINE (SetiAstro)")
+
         if final_drizzle.ndim == 2:
             hdr_orig["NAXIS"]  = 2
             hdr_orig["NAXIS1"] = final_drizzle.shape[1]
@@ -18484,10 +18934,12 @@ class StackingSuiteDialog(QDialog):
             cropped_drizzle, hdr_crop = self._apply_autocrop(
                 final_drizzle,
                 file_list,
-                hdr.copy() if hdr is not None else fits.Header(),
+                hdr_orig.copy(),
                 scale=float(scale_factor),
                 rect_override=rect_override
             )
+            hdr_crop["NCOMBINE"] = (n_frames, "Number of frames combined")
+            hdr_crop["NSTACK"]   = (n_frames, "Alias of NCOMBINE (SetiAstro)")            
             is_mono_crop = (cropped_drizzle.ndim == 2)
             display_group_driz_crop = self._label_with_dims(group_key, cropped_drizzle.shape[1], cropped_drizzle.shape[0])
             base_crop = f"MasterLight_{display_group_driz_crop}_{len(file_list)}stacked_drizzle_autocrop"