setiastrosuitepro 1.6.2__py3-none-any.whl → 1.6.4__py3-none-any.whl

setiastro/saspro/stacking_suite.py

@@ -154,64 +154,107 @@ _FITS_EXTS = ('.fits', '.fit', '.fts', '.fits.gz', '.fit.gz', '.fts.gz', '.fz')
 
 def get_valid_header(path: str):
     """
-    Return a robust FITS header for both normal and compressed FITS.
+    Fast header-only FITS peek with a targeted fallback:
 
-    - Opens the HDU list and picks the first image-like HDU (ndim >= 2).
-    - Forces NAXIS, NAXIS1, NAXIS2 from the actual data.shape if possible.
-    - Falls back to ZNAXIS1/2 for tile-compressed images.
+    1) Header-only scan (lazy_load_hdus=True, never touches .data)
+    2) If NAXIS1/2 still missing/invalid, fallback to reading ONE image HDU's data
+       to get shape, then patch NAXIS/NAXIS1/NAXIS2.
+
+    Returns: (hdr, ok_bool)
     """
     try:
         from astropy.io import fits
 
-        with fits.open(path, memmap=False) as hdul:
+        def _is_good_dim(v):
+            try:
+                return int(v) > 0
+            except Exception:
+                return False
+
+        # ---------------------------
+        # Pass 1: header-only
+        # ---------------------------
+        with fits.open(path, mode="readonly", memmap=True, lazy_load_hdus=True) as hdul:
             science_hdu = None
 
-            # Prefer the first HDU that actually has 2D+ image data
             for hdu in hdul:
-                data = getattr(hdu, "data", None)
-                if data is None:
-                    continue
-                if getattr(data, "ndim", 0) >= 2:
+                hdr = hdu.header
+
+                # Prefer HDUs that *declare* 2D+ via header
+                naxis = hdr.get("NAXIS", None)
+                znaxis = hdr.get("ZNAXIS", None)
+
+                looks_2d = False
+                try:
+                    if naxis is not None and int(naxis) >= 2:
+                        looks_2d = True
+                except Exception:
+                    pass
+                try:
+                    if znaxis is not None and int(znaxis) >= 2:
+                        looks_2d = True
+                except Exception:
+                    pass
+
+                if looks_2d:
                     science_hdu = hdu
                     break
 
             if science_hdu is None:
-                # Fallback: just use primary
                 science_hdu = hdul[0]
 
             hdr = science_hdu.header.copy()
-            data = science_hdu.data
 
-            # --- Ensure NAXIS / NAXIS1 / NAXIS2 are real numbers ---
-            try:
-                if data is not None and getattr(data, "ndim", 0) >= 2:
-                    shape = data.shape
-                    # FITS: final axes are X, Y
-                    ny, nx = shape[-2], shape[-1]
-                    hdr["NAXIS"] = int(data.ndim)
-                    hdr["NAXIS1"] = int(nx)
-                    hdr["NAXIS2"] = int(ny)
-            except Exception:
-                pass
+            # Prefer normal NAXISn; fallback to ZNAXISn for tile-compressed
+            if not _is_good_dim(hdr.get("NAXIS1")) and _is_good_dim(hdr.get("ZNAXIS1")):
+                hdr["NAXIS1"] = int(hdr["ZNAXIS1"])
+            if not _is_good_dim(hdr.get("NAXIS2")) and _is_good_dim(hdr.get("ZNAXIS2")):
+                hdr["NAXIS2"] = int(hdr["ZNAXIS2"])
 
-            # --- Extra fallback from ZNAXISn (tile-compressed FITS) ---
-            for ax in (1, 2):
-                key = f"NAXIS{ax}"
-                zkey = f"ZNAXIS{ax}"
-                val = hdr.get(key, None)
-                if (val is None or (isinstance(val, str) and not val.strip())) and zkey in hdr:
-                    try:
-                        hdr[key] = int(hdr[zkey])
-                    except Exception:
-                        pass
+            # If we already have good dims, we are done (FAST PATH)
+            if _is_good_dim(hdr.get("NAXIS1")) and _is_good_dim(hdr.get("NAXIS2")):
+                return hdr, True
 
-        return hdr, True
+        # ---------------------------
+        # Pass 2: slow fallback (ONLY if needed)
+        # ---------------------------
+        # Re-open without lazy semantics and read ONE image-like HDU's data to infer shape.
+        with fits.open(path, mode="readonly", memmap=False) as hdul:
+            target_hdu = None
+            for hdu in hdul:
+                # data access is expensive; try to choose wisely by header first
+                naxis = hdu.header.get("NAXIS", 0)
+                znaxis = hdu.header.get("ZNAXIS", 0)
 
-    except Exception:
-        return None, False
+                try:
+                    if int(naxis) >= 2 or int(znaxis) >= 2:
+                        target_hdu = hdu
+                        break
+                except Exception:
+                    continue
 
+            if target_hdu is None:
+                target_hdu = hdul[0]
 
+            # Now (and only now) touch data
+            data = getattr(target_hdu, "data", None)
+
+            hdr2 = target_hdu.header.copy()
+            if data is not None and getattr(data, "ndim", 0) >= 2:
+                try:
+                    ny, nx = data.shape[-2], data.shape[-1]
+                    hdr2["NAXIS"] = int(getattr(data, "ndim", hdr2.get("NAXIS", 2)))
+                    hdr2["NAXIS1"] = int(nx)
+                    hdr2["NAXIS2"] = int(ny)
+                    return hdr2, True
+                except Exception:
+                    pass
 
+            # If still unknown, return header anyway (caller can show "Unknown")
+            return hdr2, True
+
+    except Exception:
+        return None, False
 
 def _read_tile_stack(file_list, y0, y1, x0, x1, channels, out_buf):
     """
@@ -3916,7 +3959,11 @@ class StackingSuiteDialog(QDialog):
         self._wrench_path = wrench_path
         self._spinner_path = spinner_path
         self._post_progress_label = None
-
+        self._dark_group_item = {}   # key -> QTreeWidgetItem
+        self._flat_filter_item = {}  # filter_name -> QTreeWidgetItem
+        self._flat_exp_item = {}     # (filter_name, want_label) -> QTreeWidgetItem
+        self._light_filter_item = {} # filter_name -> QTreeWidgetItem
+        self._light_exp_item = {}    # (filter_name, want_label) -> QTreeWidgetItem
 
         self.setWindowTitle(self.tr("Stacking Suite"))
         self.setGeometry(300, 200, 800, 600)
@@ -5123,8 +5170,9 @@ class StackingSuiteDialog(QDialog):
         disto_form.addRow(self.tr("Max control points:"), self.align_max_cp)
 
         self.align_downsample = QSpinBox()
-        self.align_downsample.setRange(1, 8)
-        self.align_downsample.setValue(self.settings.value("stacking/align/downsample", 2, type=int))
+        self.align_downsample.setRange(1, 64)  # or 1..32; 64 if you want “any integer”
+        self.align_downsample.setValue(self.settings.value("stacking/align/downsample", 3, type=int))
+        self.align_downsample.setToolTip(self.tr("Alignment solve downsample. 1 = full res; higher = faster but less accurate."))
         disto_form.addRow(self.tr("Solve downsample:"), self.align_downsample)
 
         # Homography / Similarity-specific RANSAC reprojection threshold
@@ -6012,12 +6060,19 @@ class StackingSuiteDialog(QDialog):
                 w.blockSignals(True); w.setValue(v); w.blockSignals(False)
 
     def _get_drizzle_scale(self) -> float:
-        # Accepts "1x/2x/3x" or numeric
-        val = self.settings.value("stacking/drizzle_scale", "2x", type=str)
-        if isinstance(val, str) and val.endswith("x"):
-            try: return float(val[:-1])
-            except: return 2.0
-        return float(val)
+        val = self.settings.value("stacking/drizzle_scale", "2x")
+        if isinstance(val, (int, float)):
+            return float(val)
+        if isinstance(val, str):
+            s = val.strip().lower()
+            if s.endswith("x"):
+                s = s[:-1]
+            try:
+                return float(s)
+            except Exception:
+                return 2.0
+        return 2.0
+
 
     def _set_drizzle_scale(self, r: float | str) -> None:
         if isinstance(r, str):
@@ -6033,6 +6088,25 @@ class StackingSuiteDialog(QDialog):
                 self.drizzle_scale_combo.setCurrentText(txt)
                 self.drizzle_scale_combo.blockSignals(False)
 
+    def _get_drizzle_enabled(self) -> bool:
+        # UI checkbox wins if it exists (most “live” truth)
+        cb = getattr(self, "drizzle_checkbox", None)
+        if cb is not None:
+            try:
+                return bool(cb.isChecked())
+            except Exception:
+                pass
+        # fallback to settings (headless / older flows)
+        return bool(self.settings.value("stacking/drizzle_enabled", False, type=bool))
+
+    def _set_drizzle_enabled(self, on: bool) -> None:
+        on = bool(on)
+        self.settings.setValue("stacking/drizzle_enabled", on)
+        cb = getattr(self, "drizzle_checkbox", None)
+        if cb is not None and cb.isChecked() != on:
+            cb.blockSignals(True)
+            cb.setChecked(on)
+            cb.blockSignals(False)
 
     def closeEvent(self, e):
         # Graceful shutdown for any running workers
@@ -8873,9 +8947,13 @@ class StackingSuiteDialog(QDialog):
         # ensure attrs exist
         if not hasattr(self, "_reg_excluded_files"):
             self._reg_excluded_files = set()
-        if not hasattr(self, "deleted_calibrated_files"):
-            self.deleted_calibrated_files = []
 
+        # Track "removed from Registration tab" for this session so stacking won't use them
+        if (not hasattr(self, "deleted_calibrated_files")) or (self.deleted_calibrated_files is None):
+            self.deleted_calibrated_files = set()
+        elif isinstance(self.deleted_calibrated_files, list):
+            # backward compat if you previously used list
+            self.deleted_calibrated_files = set(self.deleted_calibrated_files)
         removed_paths = []
 
         for item in selected_items:
@@ -8931,18 +9009,23 @@ class StackingSuiteDialog(QDialog):
         # If you want a separate "Exclude" feature later, keep _reg_excluded_files for that.
         # For now, removing should be reversible via "Add Light Files".
 
+        # Persist "removed from registration" list (session)
+        dead = {os.path.normcase(os.path.abspath(p)) for p in removed_paths if isinstance(p, str)}
+        if dead:
+            self.deleted_calibrated_files |= dead
+
         # Also prune manual list so it doesn't re-inject removed files *in this session*
         if hasattr(self, "manual_light_files") and self.manual_light_files:
-            dead = {os.path.normcase(os.path.abspath(p)) for p in removed_paths if isinstance(p, str)}
             self.manual_light_files = [
                 p for p in self.manual_light_files
                 if os.path.normcase(os.path.abspath(p)) not in dead
             ]
 
         # refresh UI
-        self.populate_calibrated_lights()
+        # IMPORTANT: do NOT call populate_calibrated_lights() here, it can resurrect removed items
         self._refresh_reg_tree_summaries()
 
+
     def rebuild_flat_tree(self):
         """Regroup flat frames in the flat_tree based on the exposure tolerance."""
         self.flat_tree.clear()
@@ -9287,6 +9370,22 @@ class StackingSuiteDialog(QDialog):
         return (f"Drizzle: True, Scale: {scale:g}x, Drop: {drop:.2f}"
                 if enabled else "Drizzle: False")
 
+    def _get_group_key(self, top_item) -> str:
+        """Stable key for a group item; survives UI text decoration."""
+        key = top_item.data(0, Qt.ItemDataRole.UserRole)
+        if key:
+            return str(key)
+        # fallback to visible text if older items don't have it yet
+        return str(top_item.text(0)).strip()
+
+    def _ensure_group_key(self, top_item, group_key: str | None = None) -> str:
+        """Set canonical key on item if missing."""
+        if group_key is None:
+            group_key = str(top_item.text(0)).strip()
+        if not top_item.data(0, Qt.ItemDataRole.UserRole):
+            top_item.setData(0, Qt.ItemDataRole.UserRole, group_key)
+        return str(group_key)
+
     def _set_drizzle_on_items(self, items, enabled: bool, scale: float, drop: float):
         txt_on  = self._format_drizzle_text(True,  scale, drop)
         txt_off = self._format_drizzle_text(False, scale, drop)
@@ -9294,7 +9393,8 @@ class StackingSuiteDialog(QDialog):
             # dedupe child selection → parent group
             if it.parent() is not None:
                 it = it.parent()
-            group_key = it.text(0)
+            # Canonical key stored on the item (NOT display label)
+            group_key = self._ensure_group_key(it)
             it.setText(2, txt_on if enabled else txt_off)
             self.per_group_drizzle[group_key] = {
                 "enabled": bool(enabled),
@@ -9319,11 +9419,10 @@ class StackingSuiteDialog(QDialog):
             return
 
         for item in selected_items:
-            # If the user selected a child row, go up to its parent group
             if item.parent() is not None:
                 item = item.parent()
 
-            group_key = item.text(0)
+            group_key = self._ensure_group_key(item)  # ✅ stable key
 
             if drizzle_enabled:
                 # Show scale + drop shrink
@@ -9355,7 +9454,7 @@ class StackingSuiteDialog(QDialog):
             seen, targets = set(), []
             for it in sel:
                 top = it if it.parent() is None else it.parent()
-                key = top.text(0)
+                key = self._ensure_group_key(top)
                 if key not in seen:
                     seen.add(key); targets.append(top)
         else:
@@ -9378,7 +9477,7 @@ class StackingSuiteDialog(QDialog):
 
         out = {}
         for top in self._iter_group_items():
-            group_key = top.text(0)
+            group_key = self._ensure_group_key(top)   # ✅ stable key
             state = self.per_group_drizzle.get(group_key)
             if not state:
                 state = {"enabled": global_enabled, "scale": global_scale, "drop": global_drop}
@@ -10000,24 +10099,32 @@ class StackingSuiteDialog(QDialog):
             manual_session_name = self._resolve_manual_session_name_for_ingest()
 
         added = 0
-        for i, path in enumerate(paths, start=1):
-            if dlg.wasCanceled():
-                break
-            try:
-                base = os.path.basename(path)
-                dlg.setLabelText(f"{base}  ({i}/{total})")
-                QCoreApplication.processEvents()
+        tree.setUpdatesEnabled(False)
+        tree.blockSignals(True)
+        try:        
+            for i, path in enumerate(paths, start=1):
+                if dlg.wasCanceled():
+                    break
+                try:
+                    base = os.path.basename(path)
+                    dlg.setLabelText(f"{base}  ({i}/{total})")
+                    QCoreApplication.processEvents()
 
-                self.process_fits_header(
-                    path, tree, expected_type,
-                    manual_session_name=manual_session_name
-                )
-                added += 1
-            except Exception:
-                pass
+                    self.process_fits_header(
+                        path, tree, expected_type,
+                        manual_session_name=manual_session_name
+                    )
+                    added += 1
+                except Exception:
+                    pass
+
+                dlg.setValue(i)
+                QCoreApplication.processEvents()
+        finally:
+            tree.blockSignals(False)
+            tree.setUpdatesEnabled(True)
+            tree.viewport().update()
 
-            dlg.setValue(i)
-            QCoreApplication.processEvents()
 
         dlg.setValue(total)
         QCoreApplication.processEvents()
@@ -10220,16 +10327,16 @@ class StackingSuiteDialog(QDialog):
             if expected_type_u == "DARK":
                 key = f"{exposure_text} ({image_size})"
                 self.dark_files.setdefault(key, []).append(path)
-                self.session_tags[path] = session_tag  # not strictly needed, but consistent
 
-                items = tree.findItems(key, Qt.MatchFlag.MatchExactly, 0)
-                exposure_item = items[0] if items else QTreeWidgetItem([key])
-                if not items:
+                exposure_item = self._dark_group_item.get(key)
+                if exposure_item is None:
+                    exposure_item = QTreeWidgetItem([key])
                     tree.addTopLevelItem(exposure_item)
+                    self._dark_group_item[key] = exposure_item
 
                 leaf = QTreeWidgetItem([os.path.basename(path), meta_text])
                 leaf.setData(0, Qt.ItemDataRole.UserRole, path)
-                leaf.setData(0, Qt.ItemDataRole.UserRole + 1, session_tag)  # ✅ helpful later for retag/rekey
+                leaf.setData(0, Qt.ItemDataRole.UserRole + 1, session_tag)
                 exposure_item.addChild(leaf)
 
             # === FLATs ===
@@ -10239,20 +10346,20 @@ class StackingSuiteDialog(QDialog):
                 self.flat_files.setdefault(composite_key, []).append(path)
                 self.session_tags[path] = session_tag
 
-                filter_items = tree.findItems(filter_name, Qt.MatchFlag.MatchExactly, 0)
-                filter_item = filter_items[0] if filter_items else QTreeWidgetItem([filter_name])
-                if not filter_items:
+                filter_item = self._flat_filter_item.get(filter_name)
+                if filter_item is None:
+                    filter_item = QTreeWidgetItem([filter_name])
                     tree.addTopLevelItem(filter_item)
+                    self._flat_filter_item[filter_name] = filter_item
 
                 want_label = f"{exposure_text} ({image_size})"
-                exposure_item = None
-                for i in range(filter_item.childCount()):
-                    if filter_item.child(i).text(0) == want_label:
-                        exposure_item = filter_item.child(i)
-                        break
+                exp_key = (filter_name, want_label)
+
+                exposure_item = self._flat_exp_item.get(exp_key)
                 if exposure_item is None:
                     exposure_item = QTreeWidgetItem([want_label])
                     filter_item.addChild(exposure_item)
+                    self._flat_exp_item[exp_key] = exposure_item
 
                 leaf = QTreeWidgetItem([os.path.basename(path), meta_text])
                 leaf.setData(0, Qt.ItemDataRole.UserRole, path)
@@ -10266,23 +10373,25 @@ class StackingSuiteDialog(QDialog):
                 self.light_files.setdefault(composite_key, []).append(path)
                 self.session_tags[path] = session_tag
 
-                filter_items = tree.findItems(filter_name, Qt.MatchFlag.MatchExactly, 0)
-                filter_item = filter_items[0] if filter_items else QTreeWidgetItem([filter_name])
-                if not filter_items:
+                # Cached filter item
+                filter_item = self._light_filter_item.get(filter_name)
+                if filter_item is None:
+                    filter_item = QTreeWidgetItem([filter_name])
                     tree.addTopLevelItem(filter_item)
+                    self._light_filter_item[filter_name] = filter_item
 
                 want_label = f"{exposure_text} ({image_size})"
-                exposure_item = None
-                for i in range(filter_item.childCount()):
-                    if filter_item.child(i).text(0) == want_label:
-                        exposure_item = filter_item.child(i)
-                        break
+                exp_key = (filter_name, want_label)
+
+                # Cached exposure item
+                exposure_item = self._light_exp_item.get(exp_key)
                 if exposure_item is None:
                     exposure_item = QTreeWidgetItem([want_label])
                     filter_item.addChild(exposure_item)
+                    self._light_exp_item[exp_key] = exposure_item
 
                 leaf = QTreeWidgetItem([os.path.basename(path), meta_text])
-                leaf.setData(0, Qt.ItemDataRole.UserRole, path)          # ✅ needed for date-aware flat fallback
+                leaf.setData(0, Qt.ItemDataRole.UserRole, path)          # ✅ keep this
                 leaf.setData(0, Qt.ItemDataRole.UserRole + 1, session_tag)
                 exposure_item.addChild(leaf)
 
@@ -12816,6 +12925,20 @@ class StackingSuiteDialog(QDialog):
             "drop": float(self.drizzle_drop_shrink_spin.value())
         }
 
+    def _global_drizzle_state(self) -> dict:
+        # UI is the source of truth at runtime
+        enabled = bool(self.drizzle_checkbox.isChecked())
+
+        # Scale from combo text like "1x", "2x", "3x"
+        try:
+            scale = float(self.drizzle_scale_combo.currentText().replace("x", "", 1).strip())
+        except Exception:
+            scale = 1.0
+
+        drop = float(self.drizzle_drop_shrink_spin.value())
+
+        return {"enabled": enabled, "scale": scale, "drop": drop}
+
     def _split_dual_band_osc(self, selected_groups=None):
         """
         Create mono Ha/SII/OIII frames from dual-band OSC files and
@@ -13578,6 +13701,24 @@ class StackingSuiteDialog(QDialog):
             self.update_status(self.tr("🔄 Image Registration Started..."))
             self.extract_light_files_from_tree(debug=True)
 
+            # --- Apply "removed from Registration tab" exclusions (session-level) ---
+            dead = set()
+            if hasattr(self, "deleted_calibrated_files") and self.deleted_calibrated_files:
+                dead = set(self.deleted_calibrated_files)
+
+            if dead:
+                for g in list(self.light_files.keys()):
+                    self.light_files[g] = [
+                        p for p in self.light_files[g]
+                        if os.path.normcase(os.path.abspath(p)) not in dead
+                    ]
+                    if not self.light_files[g]:
+                        del self.light_files[g]
+
+                self.update_status(self.tr(f"🚫 Excluding {len(dead)} removed frame(s) from registration/stacking."))
+                QApplication.processEvents()
+
+
             comet_mode = bool(getattr(self, "comet_cb", None) and self.comet_cb.isChecked())
             if comet_mode:
                 self.update_status(self.tr("🌠 Comet mode: please click the comet center to continue…"))
@@ -15190,6 +15331,14 @@ class StackingSuiteDialog(QDialog):
             # Snapshot UI-dependent settings (your existing code)
             # ----------------------------
             drizzle_dict = self.gather_drizzle_settings_from_tree()
+            try:
+                self.update_status(self.tr(
+                    "🧾 Drizzle dict: " + ", ".join(f"{k}:{'ON' if v.get('drizzle_enabled') else 'off'}"
+                                                for k, v in drizzle_dict.items())
+                ))
+            except Exception:
+                pass
+            QApplication.processEvents()
             try:
                 autocrop_enabled = self.autocrop_cb.isChecked()
                 autocrop_pct = float(self.autocrop_pct.value())
@@ -15604,6 +15753,22 @@ class StackingSuiteDialog(QDialog):
 
         self._set_registration_busy(False)
 
+    def _on_after_align_finished(self, success: bool, message: str):
+        # Stop thread/progress UI first (whatever you already do)
+
+        if success:
+            QMessageBox.information(
+                self,
+                self.tr("Stacking Complete"),
+                message
+            )
+        else:
+            QMessageBox.critical(
+                self,
+                self.tr("Stacking Failed"),
+                message
+            )
+
     def _on_mf_progress(self, s: str):
         # Mirror non-token messages
         if not s.startswith("__PROGRESS__"):
@@ -15632,25 +15797,48 @@ class StackingSuiteDialog(QDialog):
 
     @pyqtSlot(bool, str)
     def _on_post_pipeline_finished(self, ok: bool, message: str):
+        # ---- close progress dialog ----
         try:
-            if getattr(self, "post_progress", None):
+            if getattr(self, "post_progress", None) is not None:
                 self.post_progress.close()
+                self.post_progress.deleteLater()
                 self.post_progress = None
         except Exception:
             pass
 
+        # ---- stop thread ----
+        try:
+            if getattr(self, "post_thread", None) is not None:
+                self.post_thread.quit()
+                self.post_thread.wait()
+        except Exception:
+            pass
+
+        # ---- cleanup objects ----
         try:
-            self.post_thread.quit()
-            self.post_thread.wait()
+            if getattr(self, "post_worker", None) is not None:
+                self.post_worker.deleteLater()
+                self.post_worker = None
+            if getattr(self, "post_thread", None) is not None:
+                self.post_thread.deleteLater()
+                self.post_thread = None
         except Exception:
             pass
+
+        # ---- update status (keep this behavior) ----
         try:
-            self.post_worker.deleteLater()
-            self.post_thread.deleteLater()
+            # message already includes "Post-alignment complete..." text
+            self.update_status(self.tr(message))
         except Exception:
             pass
 
-        self.update_status(self.tr(message))
+        # ---- popup summary ----
+        # (Do this after progress dialog is gone so it doesn't hide behind it)
+        if ok:
+            QMessageBox.information(self, self.tr("Post-Alignment Complete"), message)
+        else:
+            QMessageBox.critical(self, self.tr("Post-Alignment Failed"), message)
+
         self._cfa_for_this_run = None
         QApplication.processEvents()
 
@@ -15757,6 +15945,8 @@ class StackingSuiteDialog(QDialog):
         log(f"📁 Post-align: {n_groups} group(s), {n_frames} aligned frame(s).")
         QApplication.processEvents()
 
+        drizzle_enabled_global = self._get_drizzle_enabled()
+
         # Precompute a single global crop rect if enabled (pure computation, no UI).
         global_rect = None
         if autocrop_enabled:
@@ -16190,8 +16380,7 @@ class StackingSuiteDialog(QDialog):
                             log(f"✂️ Saved CometBlend (auto-cropped) → {blend_path_crop}")
 
             # ---- Drizzle bookkeeping for this group ----
-            dconf = drizzle_dict.get(group_key, {})
-            if dconf.get("drizzle_enabled", False):
+            if drizzle_enabled_global:
                 sasr_path = os.path.join(self.stacking_directory, f"{group_key}_rejections.sasr")
                 self.save_rejection_map_sasr(rejection_map, sasr_path)
                 log(f"✅ Saved rejection map to {sasr_path}")
@@ -16223,17 +16412,17 @@ class StackingSuiteDialog(QDialog):
             originals_by_group[group] = orig_list
         # ---- Drizzle pass (only for groups with drizzle enabled) ----
         for group_key, file_list in grouped_files.items():
-            dconf = drizzle_dict.get(group_key)
-            if not (dconf and dconf.get("drizzle_enabled", False)):
-                log(f"✅ Group '{group_key}' not set for drizzle. Integrated image already saved.")
+            if not drizzle_enabled_global:
+                log(f"✅ Drizzle disabled (checkbox off). Group '{group_key}' integrated image already saved.")
                 continue
 
+            # Use your existing getters (they can read UI/settings)
             scale_factor = self._get_drizzle_scale()
             drop_shrink  = self._get_drizzle_pixfrac()
 
-            # Optional: also read kernel for logging/branching
             kernel = (self.settings.value("stacking/drizzle_kernel", "square", type=str) or "square").lower()
-            status_cb(f"Drizzle cfg → scale={scale_factor}×, pixfrac={drop_shrink:.3f}, kernel={kernel}")
+            log(f"Drizzle cfg → scale={scale_factor}×, pixfrac={drop_shrink:.3f}, kernel={kernel}")
+
             rejections_for_group = group_integration_data[group_key]["rejection_map"]
             n_frames_group = group_integration_data[group_key]["n_frames"]
 
@@ -16241,8 +16430,8 @@ class StackingSuiteDialog(QDialog):
 
             self.drizzle_stack_one_group(
                 group_key=group_key,
-                file_list=file_list,                          # registered (for headers/labels)
-                original_list=originals_by_group.get(group_key, []),  # <-- NEW
+                file_list=file_list,
+                original_list=originals_by_group.get(group_key, []),
                 transforms_dict=transforms_dict,
                 frame_weights=frame_weights,
                 scale_factor=scale_factor,