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

setiastro/saspro/psf_viewer.py

@@ -13,7 +13,7 @@ from PyQt6.QtWidgets import (
 )
 from setiastro.saspro.widgets.themed_buttons import themed_toolbtn
 
-from PyQt6.QtCore import Qt, QTimer, QThread, pyqtSignal, QObject
+from PyQt6.QtCore import QThread, pyqtSignal, QObject
 from PyQt6.QtWidgets import QWidget
 
 class _ProcessingOverlay(QWidget):
@@ -108,7 +108,10 @@ class PSFViewer(QDialog):
         # Accept either a view (with .document) or a doc directly
         doc = getattr(view_or_doc, "document", None)
         self.doc = doc if doc is not None else view_or_doc
-
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
         # Image + state
         self.image = self._grab_image()
         self.zoom_factor = 1.0
@@ -124,12 +127,19 @@ class PSFViewer(QDialog):
         self.threshold_timer.timeout.connect(self._applyThreshold)
 
         # Auto-update when the document changes
+
+        self._psf_thread = None
+        self._psf_worker = None
+        self._doc_conn = False
         if hasattr(self.doc, "changed"):
             try:
                 self.doc.changed.connect(self._on_doc_changed)
+                self._doc_conn = True
             except Exception:
-                pass
+                self._doc_conn = False
 
+        # cleanup no matter how the dialog is dismissed (accept/reject/done)
+        self.finished.connect(self._cleanup)
         self._build_ui()
         # Defer first compute until after the dialog is shown/layouted
         QTimer.singleShot(0, self._applyThreshold)
@@ -235,7 +245,7 @@ class PSFViewer(QDialog):
 
         # Close
         close_btn = QPushButton("Close", self)
-        close_btn.clicked.connect(self.accept)
+        close_btn.clicked.connect(self.close)
         main_layout.addWidget(close_btn)
 
         self.setLayout(main_layout)
@@ -279,7 +289,6 @@ class PSFViewer(QDialog):
         self.hist_label.resize(scaled.size())
 
     def _applyThreshold(self):
-        # kick off worker
         if self.image is None:
             self.star_list = None
             self.status_label.setText("Status: No image.")
@@ -288,46 +297,72 @@ class PSFViewer(QDialog):
 
         self._show_processing("Processing… extracting stars / PSFs")
 
-        # kill previous run if any
-        if hasattr(self, "_psf_thread") and self._psf_thread is not None:
-            try:
-                self._psf_thread.quit()
-                self._psf_thread.wait(50)
-            except Exception:
-                pass
+        # stop any previous run cleanly
+        self._stop_psf_worker()
 
         self._psf_thread = QThread(self)
         self._psf_worker = _PSFWorker(self.image, self.detection_threshold)
         self._psf_worker.moveToThread(self._psf_thread)
 
         self._psf_thread.started.connect(self._psf_worker.run)
+        self._psf_worker.finished.connect(self._on_psf_done)
+        self._psf_worker.failed.connect(self._on_psf_fail)
 
-        def _done(tbl, status):
-            self.star_list = tbl
-            self.status_label.setText(status)
-            self._hide_processing()
-            self.drawHistogram()
-            self._psf_thread.quit()
-            self._psf_thread.wait(100)
-
-        def _fail(msg):
-            self.star_list = None
-            self.status_label.setText(f"Status: {msg}")
-            self._hide_processing()
-            self.drawHistogram()
-            self._psf_thread.quit()
-            self._psf_thread.wait(100)
+        # ensure thread quits once worker reports anything
+        self._psf_worker.finished.connect(lambda *_: self._stop_psf_worker(quit_only=False))
+        self._psf_worker.failed.connect(lambda *_: self._stop_psf_worker(quit_only=False))
 
-        self._psf_worker.finished.connect(_done)
-        self._psf_worker.failed.connect(_fail)
 
         self._psf_thread.start()
 
+    def _stop_psf_worker(self, quit_only: bool = False):
+        thr = getattr(self, "_psf_thread", None)
+        wkr = getattr(self, "_psf_worker", None)
+
+        if thr is None:
+            return
+
+        try:
+            thr.quit()
+        except Exception:
+            pass
+        try:
+            thr.wait(250)
+        except Exception:
+            pass
+
+        if not quit_only:
+            try:
+                if wkr is not None:
+                    wkr.deleteLater()
+            except Exception:
+                pass
+            try:
+                thr.deleteLater()
+            except Exception:
+                pass
+            self._psf_worker = None
+            self._psf_thread = None
+
+    def _on_psf_done(self, tbl, status: str):
+        # tbl is an astropy Table or None
+        self.star_list = tbl
+        self.status_label.setText(status)
+        self._hide_processing()
+        self.drawHistogram()
+
+    def _on_psf_fail(self, msg: str):
+        self.star_list = None
+        self.status_label.setText(f"Status: {msg}")
+        self._hide_processing()
+        self.drawHistogram()
+
 
     def updateImage(self, new_image):
         self.image = np.asarray(new_image) if new_image is not None else None
-        self.compute_star_list()
-        self.drawHistogram()
+        if self.threshold_timer.isActive():
+            self.threshold_timer.stop()
+        self.threshold_timer.start()
 
     def updateZoom(self, _=None):
         self._apply_hist_zoom()
@@ -538,12 +573,59 @@ class PSFViewer(QDialog):
                 it.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
                 self.stats_table.setItem(ri, ci, it)
 
+
+    def _cleanup(self):
+        # stop debounce timer
+        try:
+            if getattr(self, "threshold_timer", None) is not None:
+                self.threshold_timer.stop()
+        except Exception:
+            pass
+
+        # disconnect doc listener
+        try:
+            if self._doc_conn and hasattr(self.doc, "changed"):
+                self.doc.changed.disconnect(self._on_doc_changed)
+        except Exception:
+            pass
+        self._doc_conn = False
+
+        # stop worker/thread
+        try:
+            thr = getattr(self, "_psf_thread", None)
+            wkr = getattr(self, "_psf_worker", None)
+
+            if wkr is not None:
+                try:
+                    wkr.deleteLater()
+                except Exception:
+                    pass
+
+            if thr is not None:
+                try:
+                    thr.requestInterruption()
+                except Exception:
+                    pass
+                try:
+                    thr.quit()
+                except Exception:
+                    pass
+                try:
+                    thr.wait(250)
+                except Exception:
+                    pass
+                try:
+                    thr.deleteLater()
+                except Exception:
+                    pass
+        except Exception:
+            pass
+
+        self._psf_worker = None
+        self._psf_thread = None
+
     # ---------- lifecycle ----------
     def closeEvent(self, e):
-        # Best-effort disconnect
-        if hasattr(self.doc, "changed"):
-            try:
-                self.doc.changed.disconnect(self._on_doc_changed)
-            except Exception:
-                pass
+        self._cleanup()
         super().closeEvent(e)
+

setiastro/saspro/resources.py

@@ -245,6 +245,39 @@ class Icons:
     LIVE_STACKING = property(lambda self: _resource_path('livestacking.png'))
     IMAGE_COMBINE = property(lambda self: _resource_path('imagecombine.png'))
     
+    # Moon phase (WIMS)
+    MOON_NEW            = property(lambda self: _resource_path('new_moon.png'))
+    MOON_WAXING_CRES_1  = property(lambda self: _resource_path('waxing_crescent_1.png'))
+    MOON_WAXING_CRES_2  = property(lambda self: _resource_path('waxing_crescent_2.png'))
+    MOON_WAXING_CRES_3  = property(lambda self: _resource_path('waxing_crescent_3.png'))
+    MOON_WAXING_CRES_4  = property(lambda self: _resource_path('waxing_crescent_4.png'))
+    MOON_WAXING_CRES_5  = property(lambda self: _resource_path('waxing_crescent_5.png'))
+
+    MOON_FIRST_QUARTER  = property(lambda self: _resource_path('first_quarter.png'))
+
+    MOON_WAXING_GIB_1   = property(lambda self: _resource_path('waxing_gibbous_1.png'))
+    MOON_WAXING_GIB_2   = property(lambda self: _resource_path('waxing_gibbous_2.png'))
+    MOON_WAXING_GIB_3   = property(lambda self: _resource_path('waxing_gibbous_3.png'))
+    MOON_WAXING_GIB_4   = property(lambda self: _resource_path('waxing_gibbous_4.png'))
+    MOON_WAXING_GIB_5   = property(lambda self: _resource_path('waxing_gibbous_5.png'))
+
+    MOON_FULL           = property(lambda self: _resource_path('full_moon.png'))
+
+    MOON_WANING_GIB_1   = property(lambda self: _resource_path('waning_gibbous_1.png'))
+    MOON_WANING_GIB_2   = property(lambda self: _resource_path('waning_gibbous_2.png'))
+    MOON_WANING_GIB_3   = property(lambda self: _resource_path('waning_gibbous_3.png'))
+    MOON_WANING_GIB_4   = property(lambda self: _resource_path('waning_gibbous_4.png'))
+    MOON_WANING_GIB_5   = property(lambda self: _resource_path('waning_gibbous_5.png'))
+
+    MOON_LAST_QUARTER   = property(lambda self: _resource_path('last_quarter.png'))
+
+    MOON_WANING_CRES_1  = property(lambda self: _resource_path('waning_crescent_1.png'))
+    MOON_WANING_CRES_2  = property(lambda self: _resource_path('waning_crescent_2.png'))
+    MOON_WANING_CRES_3  = property(lambda self: _resource_path('waning_crescent_3.png'))
+    MOON_WANING_CRES_4  = property(lambda self: _resource_path('waning_crescent_4.png'))
+    MOON_WANING_CRES_5  = property(lambda self: _resource_path('waning_crescent_5.png'))
+
+
     # Special features
     SUPERNOVA = property(lambda self: _resource_path('supernova.png'))
     PEDESTAL = property(lambda self: _resource_path('pedestal.png'))
@@ -284,6 +317,7 @@ class Icons:
     CSV = property(lambda self: _resource_path('cvs.png'))
     PPP = property(lambda self: _resource_path('ppp.png'))
     SCRIPT = property(lambda self: _resource_path('script.png'))
+    ACV = property(lambda self: _resource_path('acv_icon.png'))
     
     # Blink & comparison
     BLINK = property(lambda self: _resource_path('blink.png'))
@@ -393,6 +427,39 @@ def _init_legacy_paths():
         'slot7_path': get_icon_path('slot7.png'),
         'slot8_path': get_icon_path('slot8.png'),
         'slot9_path': get_icon_path('slot9.png'),
+        'acv_icon_path': get_icon_path('acv_icon.png'),
+
+        'moon_new_path': get_icon_path('new_moon.png'),
+        'moon_waxing_crescent_1_path': get_icon_path('waxing_crescent_1.png'),
+        'moon_waxing_crescent_2_path': get_icon_path('waxing_crescent_2.png'),
+        'moon_waxing_crescent_3_path': get_icon_path('waxing_crescent_3.png'),
+        'moon_waxing_crescent_4_path': get_icon_path('waxing_crescent_4.png'),
+        'moon_waxing_crescent_5_path': get_icon_path('waxing_crescent_5.png'),
+
+        'moon_first_quarter_path': get_icon_path('first_quarter.png'),
+
+        'moon_waxing_gibbous_1_path': get_icon_path('waxing_gibbous_1.png'),
+        'moon_waxing_gibbous_2_path': get_icon_path('waxing_gibbous_2.png'),
+        'moon_waxing_gibbous_3_path': get_icon_path('waxing_gibbous_3.png'),
+        'moon_waxing_gibbous_4_path': get_icon_path('waxing_gibbous_4.png'),
+        'moon_waxing_gibbous_5_path': get_icon_path('waxing_gibbous_5.png'),
+
+        'moon_full_path': get_icon_path('full_moon.png'),
+
+        'moon_waning_gibbous_1_path': get_icon_path('waning_gibbous_1.png'),
+        'moon_waning_gibbous_2_path': get_icon_path('waning_gibbous_2.png'),
+        'moon_waning_gibbous_3_path': get_icon_path('waning_gibbous_3.png'),
+        'moon_waning_gibbous_4_path': get_icon_path('waning_gibbous_4.png'),
+        'moon_waning_gibbous_5_path': get_icon_path('waning_gibbous_5.png'),
+
+        'moon_last_quarter_path': get_icon_path('last_quarter.png'),
+
+        'moon_waning_crescent_1_path': get_icon_path('waning_crescent_1.png'),
+        'moon_waning_crescent_2_path': get_icon_path('waning_crescent_2.png'),
+        'moon_waning_crescent_3_path': get_icon_path('waning_crescent_3.png'),
+        'moon_waning_crescent_4_path': get_icon_path('waning_crescent_4.png'),
+        'moon_waning_crescent_5_path': get_icon_path('waning_crescent_5.png'),
+
         'rgbcombo_path': get_icon_path('rgbcombo.png'),
         'rgbextract_path': get_icon_path('rgbextract.png'),
         'copyslot_path': get_icon_path('copyslot.png'),

setiastro/saspro/rgbalign.py

@@ -350,6 +350,10 @@ class RGBAlignDialog(QDialog):
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions        
         self.parent = parent
         # document could be a view; try to unwrap
         self.doc_view = document

setiastro/saspro/selective_color.py

@@ -458,7 +458,10 @@ class SelectiveColorCorrection(QDialog):
         self.setWindowTitle(self.tr("Selective Color Correction"))
         if window_icon:
             self.setWindowIcon(window_icon)
-
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions
         self.docman = doc_manager
         self.document = document
         if self.document is None or getattr(self.document, "image", None) is None:

setiastro/saspro/sfcc.py

@@ -349,6 +349,10 @@ class SFCCDialog(QDialog):
         self.setWindowFlag(Qt.WindowType.Window, True)
         self.setWindowModality(Qt.WindowModality.NonModal)
         self.setModal(False)
+        try:
+            self.setAttribute(Qt.WidgetAttribute.WA_DeleteOnClose, True)
+        except Exception:
+            pass  # older PyQt6 versions        
         self.setMinimumSize(800, 600)
 
         self.doc_manager = doc_manager
@@ -375,6 +379,7 @@ class SFCCDialog(QDialog):
         self.lp_filter_combo2.currentIndexChanged.connect(self.save_lp2_setting)
         self.sens_combo.currentIndexChanged.connect(self.save_sensor_setting)
         self.star_combo.currentIndexChanged.connect(self.save_star_setting)
+        self.finished.connect(lambda *_: self._cleanup())
 
         self.grad_method = "poly3"
         self.grad_method_combo.currentTextChanged.connect(lambda m: setattr(self, "grad_method", m))
@@ -528,12 +533,12 @@ class SFCCDialog(QDialog):
         self.remove_curve_btn = QPushButton(self.tr("Remove Filter/Sensor Curve…"))
         self.remove_curve_btn.clicked.connect(self.remove_custom_curve); row4.addWidget(self.remove_curve_btn)
         row4.addStretch()
-        self.close_btn = QPushButton(self.tr("Close")); self.close_btn.clicked.connect(self.close); row4.addWidget(self.close_btn)
+        self.close_btn = QPushButton(self.tr("Close")); self.close_btn.clicked.connect(self.reject); row4.addWidget(self.close_btn)
 
         self.count_label = QLabel(""); layout.addWidget(self.count_label)
 
         self.figure = Figure(figsize=(6, 4)); self.canvas = FigureCanvas(self.figure); self.canvas.setVisible(False); layout.addWidget(self.canvas, stretch=1)
-        self.reset_btn = QPushButton(self.tr("Reset View/Close")); self.reset_btn.clicked.connect(self.close); layout.addWidget(self.reset_btn)
+        self.reset_btn = QPushButton(self.tr("Reset View/Close")); self.reset_btn.clicked.connect(self.reject); layout.addWidget(self.reset_btn)
 
         # hide gradient controls by default (enable if you like)
         self.run_grad_btn.hide(); self.grad_method_combo.hide()
@@ -1454,11 +1459,64 @@ class SFCCDialog(QDialog):
         self.sasp_viewer_window.show()
         self.sasp_viewer_window.destroyed.connect(self._on_sasp_closed)
 
+    def _cleanup(self):
+        # 1) Close/cleanup child window (SaspViewer)
+        try:
+            if getattr(self, "sasp_viewer_window", None) is not None:
+                try:
+                    self.sasp_viewer_window.destroyed.disconnect(self._on_sasp_closed)
+                except Exception:
+                    pass
+                try:
+                    self.sasp_viewer_window.close()
+                except Exception:
+                    pass
+                self.sasp_viewer_window = None
+        except Exception:
+            pass
+
+        # 2) Disconnect any long-lived external signals (add these if/when used)
+        # Example patterns:
+        try:
+            self.doc_manager.activeDocumentChanged.disconnect(self._on_active_doc_changed)
+        except Exception:
+            pass
+        try:
+            self.main_win.currentDocumentChanged.disconnect(self._on_active_doc_changed)
+        except Exception:
+            pass
+
+        # 3) Release large caches/refs (important since dialog may not be deleted)
+        try:
+            self.current_image = None
+            self.current_header = None
+            self.star_list = []
+            self._last_matched = []
+            if hasattr(self, "wcs"):
+                self.wcs = None
+            if hasattr(self, "wcs_header"):
+                self.wcs_header = None
+        except Exception:
+            pass
+
+        # 4) Matplotlib cleanup
+        try:
+            if getattr(self, "figure", None) is not None:
+                self.figure.clf()
+            if getattr(self, "canvas", None) is not None:
+                self.canvas.setVisible(False)
+                self.canvas.draw_idle()
+        except Exception:
+            pass
+
+
     def _on_sasp_closed(self, _=None):
         # Called when the SaspViewer window is destroyed
         self.sasp_viewer_window = None
+        self._cleanup()
 
     def closeEvent(self, event):
+        self._cleanup()
         super().closeEvent(event)
 
 

setiastro/saspro/shortcuts.py

@@ -493,7 +493,8 @@ class DraggableToolBar(QToolBar):
         cid = self._action_id(act)
         if cid:
             m.addSeparator()
-            m.addAction(self.tr("Hide this icon"), lambda: self._set_action_hidden(act, True))
+            m.addAction(self.tr("Hide this icon"), lambda: self.window()._hide_action_to_hidden_toolbar(act))
+
 
         # (Optional) teach users about Alt+Drag:
         m.addSeparator()
@@ -521,16 +522,19 @@ class DraggableToolBar(QToolBar):
         m.addSeparator()
 
         # Submenu listing hidden actions for this toolbar
-        hidden = self._load_hidden_set()
         sub = m.addMenu(self.tr("Show hidden…"))
 
-        # Build list from actions that are currently invisible
+        mw = self.window()
+        tb_hidden = getattr(mw, "_hidden_toolbar", lambda: None)()
         any_hidden = False
-        for act in self.actions():
-            cid = self._action_id(act)
-            if cid and (cid in hidden) and (not act.isVisible()):
+        if tb_hidden:
+            for act in tb_hidden.actions():
+                # Skip separators
+                if act.isSeparator():
+                    continue
                 any_hidden = True
-                sub.addAction(act.text() or cid, lambda a=act: self._set_action_hidden(a, False))
+                sub.addAction(act.text() or (act.property("command_id") or act.objectName() or "item"),
+                              lambda a=act: mw._unhide_action_from_hidden_toolbar(a))
 
         if not any_hidden:
             sub.setEnabled(False)
@@ -541,10 +545,15 @@ class DraggableToolBar(QToolBar):
         m.exec(ev.globalPos())
 
     def _reset_hidden_icons(self):
-        # Show everything and clear hidden list
-        for act in self.actions():
-            act.setVisible(True)
-        self._save_hidden_set(set())
+        mw = self.window()
+        tb_hidden = getattr(mw, "_hidden_toolbar", lambda: None)()
+        if not tb_hidden:
+            return
+        # copy list because we'll mutate
+        acts = [a for a in tb_hidden.actions() if not a.isSeparator()]
+        for a in acts:
+            mw._unhide_action_from_hidden_toolbar(a)
+
 
 
 _PRESET_UI_IDS = {
@@ -1910,50 +1919,160 @@ class ShortcutManager:
         # legacy single-remove (kept for callers)
         self.delete_by_id(sid, persist=True)
 
-
 class _StatStretchPresetDialog(QDialog):
+    """
+    Preset editor for headless replay: command_id="stat_stretch"
+
+    Keys supported:
+      target_median: float
+      linked: bool
+      normalize: bool
+      apply_curves: bool
+      curves_boost: float            # 0..1
+      blackpoint_sigma: float        # 0..1 (matches your slider/100)
+      no_black_clip: bool
+      hdr_compress: bool
+      hdr_amount: float              # 0..1
+      hdr_knee: float                # 0..1
+      luma_only: bool
+      luma_mode: str                 # e.g. "rec709"
+    """
     def __init__(self, parent=None, initial: dict | None = None):
         super().__init__(parent)
         self.setWindowTitle("Statistical Stretch — Preset")
         init = dict(initial or {})
 
+        # --- Target median ---
         self.spin_target = QDoubleSpinBox()
-        self.spin_target.setRange(0.0, 1.0); self.spin_target.setDecimals(3)
+        self.spin_target.setRange(0.0, 1.0)
+        self.spin_target.setDecimals(3)
         self.spin_target.setSingleStep(0.01)
         self.spin_target.setValue(float(init.get("target_median", 0.25)))
 
+        # --- Linked / Normalize ---
         self.chk_linked = QCheckBox("Linked RGB channels")
         self.chk_linked.setChecked(bool(init.get("linked", False)))
 
         self.chk_normalize = QCheckBox("Normalize to [0..1]")
         self.chk_normalize.setChecked(bool(init.get("normalize", False)))
 
+        # --- Curves ---
+        self.chk_curves = QCheckBox("Apply Curves")
+        self.chk_curves.setChecked(bool(init.get("apply_curves", False)))
+
         self.spin_curves = QDoubleSpinBox()
-        self.spin_curves.setRange(0.0, 1.0); self.spin_curves.setDecimals(2)
+        self.spin_curves.setRange(0.0, 1.0)
+        self.spin_curves.setDecimals(2)
         self.spin_curves.setSingleStep(0.05)
-        self.spin_curves.setValue(float(init.get("curves_boost", 0.0 if not init.get("apply_curves") else 0.20)))
+        self.spin_curves.setValue(float(init.get("curves_boost", 0.0)))
+        self.spin_curves.setEnabled(self.chk_curves.isChecked())
+        self.chk_curves.toggled.connect(self.spin_curves.setEnabled)
+
+        # --- Blackpoint sigma ---
+        self.spin_bp = QDoubleSpinBox()
+        self.spin_bp.setRange(0.0, 1.0)
+        self.spin_bp.setDecimals(2)
+        self.spin_bp.setSingleStep(0.05)
+        self.spin_bp.setValue(float(init.get("blackpoint_sigma", 0.0)))
+
+        self.chk_no_black_clip = QCheckBox("No black clip")
+        self.chk_no_black_clip.setChecked(bool(init.get("no_black_clip", False)))
+
+        # --- HDR compress ---
+        self.chk_hdr = QCheckBox("HDR compression")
+        self.chk_hdr.setChecked(bool(init.get("hdr_compress", False)))
+
+        self.spin_hdr_amt = QDoubleSpinBox()
+        self.spin_hdr_amt.setRange(0.0, 1.0)
+        self.spin_hdr_amt.setDecimals(2)
+        self.spin_hdr_amt.setSingleStep(0.05)
+        self.spin_hdr_amt.setValue(float(init.get("hdr_amount", 0.0)))
+
+        self.spin_hdr_knee = QDoubleSpinBox()
+        self.spin_hdr_knee.setRange(0.0, 1.0)
+        self.spin_hdr_knee.setDecimals(2)
+        self.spin_hdr_knee.setSingleStep(0.05)
+        self.spin_hdr_knee.setValue(float(init.get("hdr_knee", 0.5)))
+
+        def _set_hdr_enabled(on: bool):
+            on = bool(on)
+            self.spin_hdr_amt.setEnabled(on)
+            self.spin_hdr_knee.setEnabled(on)
+
+        _set_hdr_enabled(self.chk_hdr.isChecked())
+        self.chk_hdr.toggled.connect(_set_hdr_enabled)
+
+        # --- Luma only ---
+        self.chk_luma_only = QCheckBox("Luma-only mode")
+        self.chk_luma_only.setChecked(bool(init.get("luma_only", False)))
+
+        self.cmb_luma = QComboBox()
+        # keep in sync with your tool’s supported modes
+        self.cmb_luma.addItems(["rec709", "avg", "hsp", "max"])
+        init_mode = str(init.get("luma_mode", "rec709") or "rec709")
+        idx = self.cmb_luma.findText(init_mode)
+        if idx >= 0:
+            self.cmb_luma.setCurrentIndex(idx)
+
+        self.cmb_luma.setEnabled(self.chk_luma_only.isChecked())
+        self.chk_luma_only.toggled.connect(self.cmb_luma.setEnabled)
+
+        # --- Layout ---
+        form = QFormLayout()
 
-        form = QFormLayout(self)
         form.addRow("Target median:", self.spin_target)
         form.addRow("", self.chk_linked)
         form.addRow("", self.chk_normalize)
+
+        form.addRow("", QLabel("— Tone shaping —"))
+        form.addRow("", self.chk_curves)
         form.addRow("Curves boost (0–1):", self.spin_curves)
-        form.addRow(QLabel("Curves are applied only if boost > 0."))
 
-        btns = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel, parent=self)
-        btns.accepted.connect(self.accept); btns.rejected.connect(self.reject)
+        form.addRow("", QLabel("— Blackpoint / HDR —"))
+        form.addRow("Blackpoint σ (0–1):", self.spin_bp)
+        form.addRow("", self.chk_no_black_clip)
+
+        form.addRow("", self.chk_hdr)
+        form.addRow("HDR amount (0–1):", self.spin_hdr_amt)
+        form.addRow("HDR knee (0–1):", self.spin_hdr_knee)
+
+        form.addRow("", QLabel("— Luma mode —"))
+        form.addRow("", self.chk_luma_only)
+        form.addRow("Luma mode:", self.cmb_luma)
+
+        btns = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel,
+            parent=self
+        )
+        btns.accepted.connect(self.accept)
+        btns.rejected.connect(self.reject)
         form.addRow(btns)
 
+        self.setLayout(form)
+
     def result_dict(self) -> dict:
-        boost = float(self.spin_curves.value())
+        hdr_on = bool(self.chk_hdr.isChecked())
+        curves_on = bool(self.chk_curves.isChecked())
+        luma_on = bool(self.chk_luma_only.isChecked())
+
         return {
             "target_median": float(self.spin_target.value()),
             "linked": bool(self.chk_linked.isChecked()),
             "normalize": bool(self.chk_normalize.isChecked()),
-            "apply_curves": bool(boost > 0.0),
-            "curves_boost": boost,
+
+            "apply_curves": curves_on,
+            "curves_boost": float(self.spin_curves.value()) if curves_on else 0.0,
+
+            "blackpoint_sigma": float(self.spin_bp.value()),
+            "no_black_clip": bool(self.chk_no_black_clip.isChecked()),
+
+            "hdr_compress": hdr_on,
+            "hdr_amount": float(self.spin_hdr_amt.value()) if hdr_on else 0.0,
+            "hdr_knee": float(self.spin_hdr_knee.value()) if hdr_on else 0.0,
+
+            "luma_only": luma_on,
+            "luma_mode": str(self.cmb_luma.currentText()) if luma_on else "rec709",
         }
-    
 
 class _StarStretchPresetDialog(QDialog):
     def __init__(self, parent=None, initial: dict | None = None):