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

setiastro/saspro/luminancerecombine.py

@@ -1,3 +1,4 @@
+#src/setiastro/saspro/luminancerecombine.py
 from __future__ import annotations
 import numpy as np
 import cv2
@@ -13,12 +14,184 @@ from setiastro.saspro.widgets.image_utils import (
     to_float01_strict as _to_float01_strict,
 )
 
-# Linear luma weights
 _LUMA_REC709  = np.array([0.2126, 0.7152, 0.0722], dtype=np.float32)
 _LUMA_REC601  = np.array([0.2990, 0.5870, 0.1140], dtype=np.float32)
 _LUMA_REC2020 = np.array([0.2627, 0.6780, 0.0593], dtype=np.float32)
 
+# ---- Luma profiles (UI selectable) ----
+# Key = what the UI stores in self.luma_method / preset["mode"]
+# weights must be length-3 (RGB), assumed linear
+LUMA_PROFILES: dict[str, dict] = {
+    # --- Standard ---
+    "rec709": {"method": "rec709", "weights": _LUMA_REC709, "category": "Standard", "description": "Broadband RGB (Rec.709)"},
+    "rec601": {"method": "rec601", "weights": _LUMA_REC601, "category": "Standard", "description": "Rec.601"},
+    "rec2020": {"method": "rec2020", "weights": _LUMA_REC2020, "category": "Standard", "description": "Rec.2020"},
+    "equal": {"method": "equal", "weights": None, "category": "Standard", "description": "Equal RGB"},
+    "max": {"method": "max", "weights": None, "category": "Standard", "description": "Max (Narrowband mappings)"},
+    "median": {"method": "median", "weights": None, "category": "Standard", "description": "Median RGB"},
+    "snr": {"method": "snr", "weights": None, "category": "Standard", "description": "Unequal Noise (SNR)"},
+
+    # --- Sensors (examples — paste your whole list here) ---
+    "sensor:Sony IMX571 (ASI2600/QHY268)": {
+        "method": "custom",
+        "weights": np.array([0.2944, 0.5021, 0.2035], dtype=np.float32),
+        "category": "Sensors/Sony Modern BSI",
+        "description": "Sony IMX571 26MP APS-C BSI (STARVIS)",
+        "info": "Gold standard APS-C. Excellent balance for broadband.",
+    },
+    "sensor:Sony IMX533 (ASI533)": {
+        "method": "custom",
+        "weights": np.array([0.2910, 0.5072, 0.2018], dtype=np.float32),
+        "category": "Sensors/Sony Modern BSI",
+        "description": "Sony IMX533 9MP 1\" Square BSI (STARVIS)",
+        "info": "Popular square format. Very low noise.",
+    },
+    "sensor:Sony IMX455 (ASI6200/QHY600)": {
+        "weights": (0.2987, 0.5001, 0.2013),
+        "description": "Sony IMX455 61MP Full Frame BSI (STARVIS)",
+        "info": "Full frame reference sensor.",
+        "category": "Sony / Modern BSI",
+    },
+    "sensor:Sony IMX294 (ASI294)": {
+        "weights": (0.3068, 0.5008, 0.1925),
+        "description": "Sony IMX294 11.7MP 4/3\" BSI",
+        "info": "High sensitivity 4/3 format.",
+        "category": "Sony / Modern BSI",
+    },
+    "sensor:Sony IMX183 (ASI183)": {
+        "weights": (0.2967, 0.4983, 0.2050),
+        "description": "Sony IMX183 20MP 1\" BSI",
+        "info": "High resolution 1-inch sensor.",
+        "category": "Sony / Modern BSI",
+    },
+    "sensor:Sony IMX178 (ASI178)": {
+        "weights": (0.2346, 0.5206, 0.2448),
+        "description": "Sony IMX178 6.4MP 1/1.8\" BSI",
+        "info": "High resolution entry-level sensor.",
+        "category": "Sony / Modern BSI",
+    },
+    "sensor:Sony IMX224 (ASI224)": {
+        "weights": (0.3402, 0.4765, 0.1833),
+        "description": "Sony IMX224 1.27MP 1/3\" BSI",
+        "info": "Classic planetary sensor. High Red response.",
+        "category": "Sony / Modern BSI",
+    },
+
+    # --- SONY STARVIS 2 (NIR Optimized) ---
+    "sensor:Sony IMX585 (ASI585) - STARVIS 2": {
+        "weights": (0.3431, 0.4822, 0.1747),
+        "description": "Sony IMX585 8.3MP 1/1.2\" BSI (STARVIS 2)",
+        "info": "NIR optimized. Excellent for H-Alpha/Narrowband.",
+        "category": "Sony / STARVIS 2",
+    },
+    "sensor:Sony IMX662 (ASI662) - STARVIS 2": {
+        "weights": (0.3430, 0.4821, 0.1749),
+        "description": "Sony IMX662 2.1MP 1/2.8\" BSI (STARVIS 2)",
+        "info": "Planetary/Guiding. High Red/NIR sensitivity.",
+        "category": "Sony / STARVIS 2",
+    },
+    "sensor:Sony IMX678/715 - STARVIS 2": {
+        "weights": (0.3426, 0.4825, 0.1750),
+        "description": "Sony IMX678/715 BSI (STARVIS 2)",
+        "info": "High resolution planetary/security sensors.",
+        "category": "Sony / STARVIS 2",
+    },
+
+    # --- PANASONIC / OTHERS ---
+    "sensor:Panasonic MN34230 (ASI1600/QHY163)": {
+        "weights": (0.2650, 0.5250, 0.2100),
+        "description": "Panasonic MN34230 4/3\" CMOS",
+        "info": "Classic Mono/OSC sensor. Optimized weights.",
+        "category": "Panasonic",
+    },
+
+    # --- CANON DSLR (Averaged Profiles) ---
+    "sensor:Canon EOS (Modern - 60D/6D/R)": {
+        "weights": (0.2550, 0.5250, 0.2200),
+        "description": "Canon CMOS Profile (Modern)",
+        "info": "Balanced profile for most Canon EOS cameras (60D, 6D, 5D, R-series).",
+        "category": "Canon",
+    },
+    "sensor:Canon EOS (Legacy - 300D/40D)": {
+        "weights": (0.2400, 0.5400, 0.2200),
+        "description": "Canon CMOS Profile (Legacy)",
+        "info": "For older Canon models (Digic 2/3 era).",
+        "category": "Canon",
+    },
+
+    # --- NIKON DSLR (Averaged Profiles) ---
+    "sensor:Nikon DSLR (Modern - D5300/D850)": {
+        "weights": (0.2600, 0.5100, 0.2300),
+        "description": "Nikon CMOS Profile (Modern)",
+        "info": "Balanced profile for Nikon Expeed 4+ cameras.",
+        "category": "Nikon",
+    },
+
+    # --- SMART TELESCOPES ---
+    "sensor:ZWO Seestar S50": {
+        "weights": (0.3333, 0.4866, 0.1801),
+        "description": "ZWO Seestar S50 (IMX462)",
+        "info": "Specific profile for Seestar S50 smart telescope.",
+        "category": "Smart Telescopes",
+    },
+    "sensor:ZWO Seestar S30": {
+        "weights": (0.2928, 0.5053, 0.2019),
+        "description": "ZWO Seestar S30",
+        "info": "Specific profile for Seestar S30 smart telescope.",
+        "category": "Smart Telescopes",
+    },
+}
+
+
 # ---------- helpers ----------
+def resolve_luma_profile_weights(mode: str | None):
+    """
+    Returns (resolved_method, weights_or_None, profile_name_or_None)
+
+    - Standard modes return (mode, None or standard weights, None)
+    - Sensor profiles return ("custom", weights, <profile display name>)
+    """
+    if mode is None:
+        mode = "rec709"
+    key = str(mode).strip()
+
+    # common aliases
+    alias = {
+        "rec.709": "rec709",
+        "rec-709": "rec709",
+        "rgb": "rec709",
+        "k": "rec709",
+        "rec.601": "rec601",
+        "rec-601": "rec601",
+        "rec.2020": "rec2020",
+        "rec-2020": "rec2020",
+        "nb_max": "max",
+        "narrowband": "max",
+        "snr_unequal": "snr",
+        "unequal_noise": "snr",
+    }
+    key = alias.get(key.lower(), key)
+
+    prof = LUMA_PROFILES.get(key)
+    if not prof:
+        # fallback
+        return ("rec709", _LUMA_REC709, None)
+
+    method = str(prof.get("method", "rec709")).strip().lower()
+    w = prof.get("weights", None)
+    if w is not None:
+        w = np.asarray(w, dtype=np.float32)
+
+    if key.startswith("sensor:"):
+        # Use "custom" path in compute_luminance by passing weights
+        # We'll return resolved_method="rec709" (ignored) and weights=w
+        # BUT to keep your API simple: return ("rec709", w, profile_name)
+        profile_name = key.split("sensor:", 1)[1].strip()
+        return ("rec709", w, profile_name)
+
+    # Standard modes
+    return (key, w, None)
+
 
 def _estimate_noise_sigma_per_channel(img01: np.ndarray) -> np.ndarray:
     # unchanged (but call with strict input)
@@ -83,6 +256,10 @@ def compute_luminance(
         lum = f.max(axis=2)
     elif method == "median":
         lum = np.median(f, axis=2)
+    elif method == "rec601":
+        lum = np.tensordot(f[..., :3], _LUMA_REC601, axes=([2],[0]))
+    elif method == "rec2020":
+        lum = np.tensordot(f[..., :3], _LUMA_REC2020, axes=([2],[0]))
     else:  # default rec709
         lum = np.tensordot(f[..., :3], _LUMA_REC709, axes=([2],[0]))
 
@@ -159,42 +336,66 @@ def apply_recombine_to_doc(
     """
     base = _to_float01_strict(np.asarray(target_doc.image))
 
-    # Decide weights for both compute+recombine
-    if method == "rec601":
-        w = _LUMA_REC601
-    elif method == "rec2020":
-        w = _LUMA_REC2020
-    elif weights is not None:
-        w = np.asarray(weights, dtype=np.float32)
+    # Resolve profile (sensor profiles return weights w)
+    resolved_method, w, profile_name = resolve_luma_profile_weights(method)
+
+    # Caller override for weights wins (useful for custom UI / scripts)
+    if weights is not None:
+        w = np.asarray(weights, dtype=np.float32).reshape(-1)
         if w.size != 3:
-            raise ValueError("Custom weights must be length-3.")
-    else:
-        w = _LUMA_REC709
+            raise ValueError("weights must be a 3-element RGB vector")
+    elif w is not None:
+        w = np.asarray(w, dtype=np.float32).reshape(-1)
+        if w.size != 3:
+            w = None  # ignore bad profile weights defensively
 
     # Build L (mono source passes through; RGB is weighted)
     src = _to_float01_strict(luminance_source_img)
     if src.ndim == 2 or (src.ndim == 3 and src.shape[2] == 1):
         L = src if src.ndim == 2 else src[..., 0]
+        # For mono L sources, we still want recombine weights to match the selected method/profile.
     else:
+        # Noise sigma: if caller provided, use it; otherwise estimate when needed
         ns = None
-        if method == "snr":
-            ns = _estimate_noise_sigma_per_channel(src)
-        L = compute_luminance(src, method=method, weights=w if weights is not None else None, noise_sigma=ns)
-
-    replaced = recombine_luminance_linear_scale(base, L, weights=w, blend=blend, highlight_soft_knee=soft_knee)
-
-    # destination-mask blend if active
-    m = _active_mask_array_from_doc(target_doc)
-    if m is not None:
-        m3 = np.repeat(m[..., None], 3, axis=2).astype(np.float32)
-        replaced = base * (1.0 - m3) + replaced * m3
-
-    target_doc.apply_edit(
-        replaced,
-        metadata={"step_name": "Recombine Luminance", "luma_method": method, "luma_weights": w.tolist()},
-        step_name="Recombine Luminance",
+        if resolved_method == "snr":
+            if noise_sigma is not None:
+                ns = np.asarray(noise_sigma, dtype=np.float32).reshape(-1)
+            else:
+                ns = _estimate_noise_sigma_per_channel(src)
+
+        # compute_luminance respects weights override; for sensor/custom profiles w is used
+        L = compute_luminance(src, method=resolved_method, weights=w, noise_sigma=ns)
+
+    # For scaling recombine, we need an actual RGB weight vector.
+    # If we don't have one from the chosen mode/profile, fall back sensibly.
+    if w is not None and w.size == 3:
+        recombine_w = w
+    else:
+        # If your resolver returns w=None for rec709/rec601/rec2020, fill explicitly here:
+        if resolved_method == "rec601":
+            recombine_w = _LUMA_REC601
+        elif resolved_method == "rec2020":
+            recombine_w = _LUMA_REC2020
+        else:
+            recombine_w = _LUMA_REC709
+
+    replaced = recombine_luminance_linear_scale(
+        base,
+        L,
+        weights=recombine_w,
+        blend=float(blend),
+        highlight_soft_knee=float(soft_knee),
     )
 
+    # Metadata
+    md = {"step_name": "Recombine Luminance", "luma_method": resolved_method}
+    if profile_name:
+        md["luma_profile"] = profile_name
+    if w is not None:
+        md["luma_weights"] = np.asarray(w, dtype=np.float32).tolist()
+
+    target_doc.apply_edit(replaced.astype(np.float32, copy=False), metadata=md, step_name="Recombine Luminance")
+
 
 def run_recombine_luminance_via_preset(main_or_ctx, preset=None, target_doc=None):
     """

setiastro/saspro/mask_creation.py

@@ -17,7 +17,7 @@ except Exception:
 from PyQt6.QtCore import Qt, QPointF, QRectF, QTimer, QEvent
 from PyQt6.QtGui import (
     QImage, QPixmap, QPainter, QColor, QPen, QBrush,
-    QPainterPath, QWheelEvent, QPolygonF
+    QPainterPath, QWheelEvent, QPolygonF, QMouseEvent
 )
 from PyQt6.QtWidgets import (
     QInputDialog, QMessageBox, QFileDialog,   # QFileDialog only used if you later add “export”
@@ -32,7 +32,7 @@ from PyQt6.QtWidgets import (
 
 from .masks_core import MaskLayer
 from setiastro.saspro.widgets.themed_buttons import themed_toolbtn
-
+from setiastro.saspro.imageops.stretch import stretch_color_image
 
 # ---------- small utils ----------
 
@@ -48,6 +48,38 @@ def _to_qpixmap01(img01: np.ndarray) -> QPixmap:
         qimg = QImage(buf.data, w, h, buf.strides[0], QImage.Format.Format_RGB888)
     return QPixmap.fromImage(qimg)
 
+def _display_stretch(img01: np.ndarray) -> np.ndarray:
+    """
+    Display-only stretch. Does NOT modify underlying data used for mask creation.
+    Returns float32 in [0,1].
+    """
+    a = np.asarray(img01, dtype=np.float32)
+    a = np.clip(a, 0.0, 1.0)
+
+    # Color: use your existing stretch if available
+    if a.ndim == 3 and a.shape[2] == 3 and stretch_color_image is not None:
+        try:
+            return np.clip(stretch_color_image(a, 0.25, linked=False, normalize=False), 0.0, 1.0).astype(np.float32)
+        except Exception:
+            pass
+
+    # Mono (or fallback): simple robust stretch around median
+    # (keeps it predictable and fast; display-only)
+    m = float(np.nanmedian(a))
+    if not np.isfinite(m):
+        return a.astype(np.float32, copy=False)
+
+    # Simple gamma-like lift using median anchor
+    # If median is tiny, boost; if already bright, minimal change.
+    target = 0.25
+    eps = 1e-8
+    scale = target / max(m, eps)
+    out = np.clip(a * scale, 0.0, 1.0)
+
+    # Gentle midtone curve
+    out = np.sqrt(out)
+    return np.clip(out, 0.0, 1.0).astype(np.float32, copy=False)
+
 
 def _find_main_window(w):
     p = w
@@ -248,10 +280,14 @@ class MaskCanvas(QGraphicsView):
         super().__init__(parent)
         self.setRenderHint(QPainter.RenderHint.Antialiasing)
 
+        self._base_image01 = np.asarray(image01, dtype=np.float32)
+        self._display_stretch_enabled = False
+
         # scene + background image
         self.scene = QGraphicsScene(self)
         self.setScene(self.scene)
-        self.bg_item = QGraphicsPixmapItem(_to_qpixmap01(image01))
+
+        self.bg_item = QGraphicsPixmapItem(_to_qpixmap01(self._base_image01))
         self.scene.addItem(self.bg_item)
 
         # --- NEW: basic zoom state ---
@@ -306,6 +342,38 @@ class MaskCanvas(QGraphicsView):
         super().wheelEvent(ev)
     # ----------------- END: Zoom API ---------------------
 
+    def set_display_stretch_enabled(self, enabled: bool):
+        enabled = bool(enabled)
+        if enabled == self._display_stretch_enabled:
+            return
+        self._display_stretch_enabled = enabled
+        self._refresh_background_pixmap(keep_view=True)
+
+    def display_stretch_enabled(self) -> bool:
+        return bool(self._display_stretch_enabled)
+
+    def current_display_image01(self) -> np.ndarray:
+        """Returns the image currently used for *display* (not for mask math)."""
+        if self._display_stretch_enabled:
+            return _display_stretch(self._base_image01)
+        return self._base_image01
+
+    def _refresh_background_pixmap(self, keep_view: bool = True):
+        # Preserve current view transform/center so toggling doesn't “jump”
+        old_transform = self.transform()
+        old_center = self.mapToScene(self.viewport().rect().center())
+
+        disp = self.current_display_image01()
+        self.bg_item.setPixmap(_to_qpixmap01(disp))
+
+        # Ensure scene rect still matches image pixels
+        self.setSceneRect(self.bg_item.boundingRect())
+
+        if keep_view:
+            self.setTransform(old_transform)
+            self.centerOn(old_center)
+
+
     def set_mode(self, mode: str):
         assert mode in ('polygon', 'ellipse', 'select')
         self.mode = mode
@@ -453,9 +521,10 @@ class LivePreviewDialog(QDialog):
                                            Qt.AspectRatioMode.KeepAspectRatio,
                                            Qt.TransformationMode.SmoothTransformation))
 
+    def set_base_image(self, image01: np.ndarray):
+        self.base_pixmap = _to_qpixmap01(image01)
 
 # ---------- Preview (push-as-doc) ----------
-
 class MaskPreviewDialog(QDialog):
     """Scrollable preview + 'Push as New Document…'."""
     def __init__(self, mask01: np.ndarray, parent=None):
@@ -463,29 +532,50 @@ class MaskPreviewDialog(QDialog):
         self.setWindowTitle(self.tr("Mask Preview"))
         self.mask = np.clip(mask01, 0, 1).astype(np.float32)
 
-        self.scroll = QScrollArea(self); self.scroll.setWidgetResizable(False)
+        # --- drag-pan state ---
+        self._dragging = False
+        self._drag_start = None
+        self._h_start = 0
+        self._v_start = 0
+
+        # Build UI first
+        self.scroll = QScrollArea(self)
+        self.scroll.setWidgetResizable(False)
         self.scroll.setAlignment(Qt.AlignmentFlag.AlignCenter)
+
         self.label = QLabel(alignment=Qt.AlignmentFlag.AlignCenter)
         self.label.setSizePolicy(QSizePolicy.Policy.Ignored, QSizePolicy.Policy.Ignored)
-        self.pixmap = self._to_pixmap(self.mask); self.label.setPixmap(self.pixmap)
+
+        self.pixmap = self._to_pixmap(self.mask)
+        self.label.setPixmap(self.pixmap)
+        self.label.resize(self.pixmap.size())
+
         self.scroll.setWidget(self.label)
 
+        # Enable mouse drag panning on the label (NOW label exists)
+        self.label.setMouseTracking(True)
+        self.label.installEventFilter(self)
+
         btns = QHBoxLayout()
         b_in   = themed_toolbtn("zoom-in", "Zoom In")
         b_out  = themed_toolbtn("zoom-out", "Zoom Out")
         b_fit  = themed_toolbtn("zoom-fit-best", "Fit to Preview")
-
-
         b_push = QPushButton(self.tr("Push as New Document…"))
+
         b_in.clicked.connect(lambda: self._zoom(1.2))
         b_out.clicked.connect(lambda: self._zoom(1/1.2))
         b_fit.clicked.connect(self._fit)
         b_push.clicked.connect(self.push_as_new_document)
+
         for b in (b_in, b_out, b_fit, b_push):
             btns.addWidget(b)
 
-        lay = QVBoxLayout(self); lay.addWidget(self.scroll); lay.addLayout(btns)
-        self.scale = 1.0; self.setMinimumSize(600, 400)
+        lay = QVBoxLayout(self)
+        lay.addWidget(self.scroll)
+        lay.addLayout(btns)
+
+        self.scale = 1.0
+        self.setMinimumSize(600, 400)
 
     def _to_pixmap(self, mask01: np.ndarray) -> QPixmap:
         m8 = (np.clip(mask01, 0, 1) * 255).astype(np.uint8)
@@ -495,17 +585,52 @@ class MaskPreviewDialog(QDialog):
 
     def _zoom(self, factor: float):
         self.scale *= factor
-        scaled = self.pixmap.scaled(self.pixmap.size() * self.scale,
-                                    Qt.AspectRatioMode.KeepAspectRatio,
-                                    Qt.TransformationMode.SmoothTransformation)
-        self.label.setPixmap(scaled); self.label.resize(scaled.size())
+        scaled = self.pixmap.scaled(
+            self.pixmap.size() * self.scale,
+            Qt.AspectRatioMode.KeepAspectRatio,
+            Qt.TransformationMode.SmoothTransformation
+        )
+        self.label.setPixmap(scaled)
+        self.label.resize(scaled.size())
 
     def _fit(self):
         vp = self.scroll.viewport().size()
         if self.pixmap.width() and self.pixmap.height():
             s = min(vp.width()/self.pixmap.width(), vp.height()/self.pixmap.height())
             self.scale = max(0.05, s)
-            self._zoom(1.0)
+            # re-render at the new scale (don’t multiply again)
+            scaled = self.pixmap.scaled(
+                self.pixmap.size() * self.scale,
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation
+            )
+            self.label.setPixmap(scaled)
+            self.label.resize(scaled.size())
+
+    def eventFilter(self, obj, ev):
+        if obj is self.label:
+            if ev.type() == QEvent.Type.MouseButtonPress and ev.button() == Qt.MouseButton.LeftButton:
+                self._dragging = True
+                self._drag_start = ev.globalPosition().toPoint()
+                self._h_start = self.scroll.horizontalScrollBar().value()
+                self._v_start = self.scroll.verticalScrollBar().value()
+                self.setCursor(Qt.CursorShape.ClosedHandCursor)
+                return True
+
+            if ev.type() == QEvent.Type.MouseMove and self._dragging:
+                p = ev.globalPosition().toPoint()
+                d = p - self._drag_start
+                self.scroll.horizontalScrollBar().setValue(self._h_start - d.x())
+                self.scroll.verticalScrollBar().setValue(self._v_start - d.y())
+                return True
+
+            if ev.type() == QEvent.Type.MouseButtonRelease and ev.button() == Qt.MouseButton.LeftButton:
+                self._dragging = False
+                self._drag_start = None
+                self.unsetCursor()
+                return True
+
+        return super().eventFilter(obj, ev)
 
     def push_as_new_document(self):
         if self.mask is None:
@@ -558,6 +683,10 @@ class MaskCreationDialog(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.image = np.asarray(image01, dtype=np.float32).copy()
         self.mask: np.ndarray | None = None
         self.live_preview = LivePreviewDialog(self.image, parent=self)
@@ -601,6 +730,18 @@ class MaskCreationDialog(QDialog):
         zoom_bar.addWidget(z_out); zoom_bar.addWidget(z_in); zoom_bar.addWidget(z_fit)
         layout.addLayout(zoom_bar)
 
+        # Display stretch toggle (display-only; never modifies image data)
+        self.btn_disp_stretch = QPushButton(self.tr("Toggle Display Stretch"))
+        self.btn_disp_stretch.setCheckable(True)
+        self.btn_disp_stretch.setToolTip(
+            "Display-only stretch for easier masking on linear images.\n"
+            "This does NOT change the image data or the generated mask."
+        )
+        self.btn_disp_stretch.toggled.connect(self._toggle_display_stretch)
+        self.btn_disp_stretch.setChecked(False)
+        self.btn_disp_stretch.setText("Enable Display Stretch")
+        zoom_bar.addWidget(self.btn_disp_stretch)
+
         # Canvas
         self.canvas = MaskCanvas(self.image)
         layout.addWidget(self.canvas, 1)
@@ -707,6 +848,24 @@ class MaskCreationDialog(QDialog):
         if self.link_cb.isChecked():
             self.upper_sl.setValue(v)
 
+    def _toggle_display_stretch(self, enabled: bool):
+        try:
+            self.canvas.set_display_stretch_enabled(bool(enabled))
+
+            # keep button label in sync
+            self.btn_disp_stretch.setText(
+                self.tr("Disable Display Stretch") if enabled else self.tr("Enable Display Stretch")
+            )
+
+            # Keep the live preview background in sync (Range Selection uses it)
+            if hasattr(self, "live_preview") and self.live_preview is not None:
+                self.live_preview.set_base_image(self.canvas.current_display_image01())
+                if self.live_preview.isVisible():
+                    self._update_live_preview()
+        except Exception:
+            pass
+
+
     # ---- generators
     def _component_lightness(self) -> np.ndarray:
         if self.image.ndim == 3: