setiastrosuitepro 1.6.0__py3-none-any.whl → 1.6.4.post1__py3-none-any.whl

setiastro/saspro/star_spikes.py

@@ -1,7 +1,7 @@
 # pro/tools/star_spikes.py
 from __future__ import annotations
 import numpy as np
-
+import math
 from PyQt6.QtCore import Qt
 from PyQt6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, QPushButton, QSplitter, QSizePolicy, QWidget, QApplication,
                              QFormLayout, QGroupBox, QDoubleSpinBox, QSpinBox, 
@@ -49,7 +49,10 @@ class StarSpikesDialogPro(QDialog):
                  aperture_help_path: str | None = None,
                  spinner_path: str | None = None):
         super().__init__(parent)
-        self.setWindowTitle("Diffraction Spikes")
+        self.setWindowTitle(self.tr("Diffraction Spikes"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
         self.docman = doc_manager
         self.doc = initial_doc or (self.docman.get_active_document() if self.docman else None)
         self.jwstpupil_path = jwstpupil_path
@@ -97,7 +100,7 @@ class StarSpikesDialogPro(QDialog):
             return sp
 
         # --- Group: Star Detection ---
-        grp_detect = QGroupBox("Star Detection")
+        grp_detect = QGroupBox(self.tr("Star Detection"))
         f_detect = QFormLayout(grp_detect)
         f_detect.setLabelAlignment(Qt.AlignmentFlag.AlignRight)
         f_detect.setFormAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
@@ -108,11 +111,11 @@ class StarSpikesDialogPro(QDialog):
         # keep self.advanced in sync if user edits
         self.detect_thresh.valueChanged.connect(lambda v: self.advanced.__setitem__("detect_thresh", float(v)))
 
-        f_detect.addRow("Flux Min:", self.flux_min)
-        f_detect.addRow("Detection Threshold (σ):", self.detect_thresh)
+        f_detect.addRow(self.tr("Flux Min:"), self.flux_min)
+        f_detect.addRow(self.tr("Detection Threshold (σ):"), self.detect_thresh)
 
         # --- Group: Aperture (Geometry) ---
-        grp_ap = QGroupBox("Aperture")
+        grp_ap = QGroupBox(self.tr("Aperture"))
         f_ap = QFormLayout(grp_ap)
         f_ap.setLabelAlignment(Qt.AlignmentFlag.AlignRight)
         f_ap.setFormAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
@@ -127,7 +130,7 @@ class StarSpikesDialogPro(QDialog):
                           border-radius: 14px; background:#ccc; border:1px solid #999;}
             QPushButton:checked { background:#66bb6a; }
         """)
-        f_ap.addRow("Aperture Type:", self.pupil_jwst)
+        f_ap.addRow(self.tr("Aperture Type:"), self.pupil_jwst)
 
         self.radius      = dspin(1.0, 512.0, 1.0, 128.0, decimals=1)
         self.obstruction = dspin(0.0, 0.99, 0.01, 0.2, decimals=2)
@@ -135,14 +138,14 @@ class StarSpikesDialogPro(QDialog):
         self.vane_width  = dspin(0.0, 50.0, 0.5, 4.0, decimals=2)
         self.rotation    = dspin(0.0, 360.0, 1.0, 0.0, decimals=1)
 
-        f_ap.addRow("Pupil Radius:", self.radius)
-        f_ap.addRow("Obstruction:", self.obstruction)
-        f_ap.addRow("Number of Vanes:", self.num_vanes)
-        f_ap.addRow("Vane Width:", self.vane_width)
-        f_ap.addRow("Rotation (deg):", self.rotation)
+        f_ap.addRow(self.tr("Pupil Radius:"), self.radius)
+        f_ap.addRow(self.tr("Obstruction:"), self.obstruction)
+        f_ap.addRow(self.tr("Number of Vanes:"), self.num_vanes)
+        f_ap.addRow(self.tr("Vane Width:"), self.vane_width)
+        f_ap.addRow(self.tr("Rotation (deg):"), self.rotation)
 
         # --- Group: PSF & Synthesis ---
-        grp_psf = QGroupBox("PSF & Synthesis")
+        grp_psf = QGroupBox(self.tr("PSF & Synthesis"))
         f_psf = QFormLayout(grp_psf)
         f_psf.setLabelAlignment(Qt.AlignmentFlag.AlignRight)
         f_psf.setFormAlignment(Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter)
@@ -150,18 +153,18 @@ class StarSpikesDialogPro(QDialog):
         self.color_boost = dspin(0.1, 10.0, 0.1, 1.5, decimals=2)
         self.blur_sigma  = dspin(0.1, 10.0, 0.1, 2.0, decimals=2)
 
-        f_psf.addRow("Spike Boost:", self.color_boost)
-        f_psf.addRow("PSF Blur Sigma:", self.blur_sigma)
+        f_psf.addRow(self.tr("Spike Boost:"), self.color_boost)
+        f_psf.addRow(self.tr("PSF Blur Sigma:"), self.blur_sigma)
 
         # --- Actions ---
         row_actions = QHBoxLayout()
         row_actions.setSpacing(8)
-        self.btn_run = QPushButton("Generate Spikes")
+        self.btn_run = QPushButton(self.tr("Generate Spikes"))
         self.btn_run.clicked.connect(self._run)
-        self.btn_apply = QPushButton("Apply to Active Document")
+        self.btn_apply = QPushButton(self.tr("Apply to Active Document"))
         self.btn_apply.clicked.connect(self._apply_to_doc)
         self.btn_apply.setEnabled(False)
-        self.btn_help = QPushButton("Aperture Help")
+        self.btn_help = QPushButton(self.tr("Aperture Help"))
         self.btn_help.clicked.connect(self._show_help)
         row_actions.addWidget(self.btn_run)
         row_actions.addWidget(self.btn_apply)
@@ -169,7 +172,7 @@ class StarSpikesDialogPro(QDialog):
         row_actions.addStretch(1)
 
         # --- Status ---
-        self.status = QLabel("Ready")
+        self.status = QLabel(self.tr("Ready"))
         self.status.setAlignment(Qt.AlignmentFlag.AlignCenter)
         self.status.setWordWrap(True)
 
@@ -189,9 +192,9 @@ class StarSpikesDialogPro(QDialog):
 
         # zoom toolbar
         zrow = QHBoxLayout()
-        self.btn_zoom_in = QPushButton("Zoom In")
-        self.btn_zoom_out = QPushButton("Zoom Out")
-        self.btn_fit = QPushButton("Fit to Preview")
+        self.btn_zoom_in = QPushButton(self.tr("Zoom In"))
+        self.btn_zoom_out = QPushButton(self.tr("Zoom Out"))
+        self.btn_fit = QPushButton(self.tr("Fit to Preview"))
         self.btn_zoom_in.clicked.connect(self._zoom_in)
         self.btn_zoom_out.clicked.connect(self._zoom_out)
         self.btn_fit.clicked.connect(self._fit_to_preview)
@@ -381,6 +384,13 @@ class StarSpikesDialogPro(QDialog):
         shrink_max = self.advanced["shrink_max"]
         color_boost = self.color_boost.value()
 
+        # Try OpenCV for faster zoom/blur
+        try:
+            import cv2
+            _HAS_CV2 = True
+        except ImportError:
+            _HAS_CV2 = False
+
         from concurrent.futures import ThreadPoolExecutor, as_completed
         def star_runner(x, y, flux, a, b):
             brightness = np.clip(np.log1p(flux)/8.0, 0.1, 3.0)
@@ -388,39 +398,79 @@ class StarSpikesDialogPro(QDialog):
             tile_size  = min(tile_size, 768)
             tile_size += tile_size % 2
             pad = tile_size // 2
-            if not (pad <= x < W - pad and pad <= y < H - pad):
+
+            # Guard against fully out-of-bounds, but allow partial overlaps
+            if not (0 <= x < W and 0 <= y < H):
                 return None
 
+            # Measure star color
             r_ratio, g_ratio, b_ratio = self._measure_star_color(img, x, y, sampling_radius=3)
+            
+            # Extract PSF tiles
             tile_r = self._extract_center_tile(psf_r, tile_size) * brightness * r_ratio * color_boost
             tile_g = self._extract_center_tile(psf_g, tile_size) * brightness * g_ratio * color_boost
             tile_b = self._extract_center_tile(psf_b, tile_size) * brightness * b_ratio * color_boost
 
+            # Boost/Shrink
             b_scale, s_factor = self._boost_shrink_from_flux(flux, self.flux_min.value(), flux_max,
                                                              bscale_min, bscale_max, shrink_min, shrink_max)
-            final_r = self._shrink_and_boost(tile_r, b_scale, s_factor)
-            final_g = self._shrink_and_boost(tile_g, b_scale, s_factor)
-            final_b = self._shrink_and_boost(tile_b, b_scale, s_factor)
-
-            new_size = final_r.shape[0]
-            pad_new  = new_size // 2
-            y0, y1   = y - pad_new, y - pad_new + new_size
-            x0, x1   = x - pad_new, x - pad_new + new_size
-            if (y0 < 0 or y1 > H or x0 < 0 or x1 > W):
-                return None
 
-            part = np.zeros((H, W, 3), dtype=np.float32)
-            part[y0:y1, x0:x1, 0] = final_r
-            part[y0:y1, x0:x1, 1] = final_g
-            part[y0:y1, x0:x1, 2] = final_b
-            return part
+            # --- Fast Resize (Zoom) ---
+            def _fast_zoom(arr, z):
+                if z == 1.0: return arr
+                if _HAS_CV2:
+                     h, w = arr.shape
+                     nw, nh = int(round(w * z)), int(round(h * z))
+                     if nw <= 0 or nh <= 0: return np.zeros((2,2), dtype=np.float32)
+                     return cv2.resize(arr, (nw, nh), interpolation=cv2.INTER_LINEAR)
+                else:
+                    return ndi.zoom(arr, z, order=1)
+
+            final_r = np.clip(_fast_zoom(tile_r * b_scale, 1.0/s_factor), 0.0, 1.0)
+            final_g = np.clip(_fast_zoom(tile_g * b_scale, 1.0/s_factor), 0.0, 1.0)
+            final_b = np.clip(_fast_zoom(tile_b * b_scale, 1.0/s_factor), 0.0, 1.0)
+
+            # --- Return Patch Data (y, x, patch) ---
+            new_h, new_w = final_r.shape
+            
+            # Coords of the *patch top-left* relative to the image
+            # The star is at (x,y), and the patch center is approx (new_w//2, new_h//2)
+            # We want to center the patch on the star.
+            py0 = y - (new_h // 2)
+            px0 = x - (new_w // 2)
+            
+            # Combine channels
+            patch = np.dstack((final_r, final_g, final_b)).astype(np.float32)
+            return (int(py0), int(px0), patch)
 
         with ThreadPoolExecutor() as ex:
             futs = [ex.submit(star_runner, *s) for s in stars]
             for f in as_completed(futs):
-                part = f.result()
-                if part is not None:
-                    canvas += part
+                res = f.result()
+                if res is None:
+                    continue
+                
+                py0, px0, patch = res
+                ph, pw, _ = patch.shape
+                
+                # Calculate intersection with canvas
+                y_start = max(0, py0)
+                y_end   = min(H, py0 + ph)
+                x_start = max(0, px0)
+                x_end   = min(W, px0 + pw)
+                
+                # If no overlap, skip
+                if y_start >= y_end or x_start >= x_end:
+                    continue
+
+                # Offsets into the patch
+                patch_y_start = y_start - py0
+                patch_y_end   = patch_y_start + (y_end - y_start)
+                patch_x_start = x_start - px0
+                patch_x_end   = patch_x_start + (x_end - x_start)
+
+                # Add to canvas
+                canvas[y_start:y_end, x_start:x_end] += patch[patch_y_start:patch_y_end, patch_x_start:patch_x_end]
 
         self.status.setText("Compositing…")
         QApplication.processEvents()
@@ -543,14 +593,56 @@ class StarSpikesDialogPro(QDialog):
         return img
 
     def _simulate_psf(self, pupil, wavelength_scale=1.0, blur_sigma=1.0):
-        sp = gaussian_filter(pupil, sigma=0.1 * wavelength_scale)
+        # Try to use OpenCV for speed
+        if getattr(self, "_cv2_checked", False):
+            has_cv2 = True
+            import cv2
+        else:
+            try:
+                import cv2
+                has_cv2 = True
+            except ImportError:
+                has_cv2 = False
+            self._cv2_checked = has_cv2
+
+        if has_cv2:
+            # Gaussian blur on pupil
+            # kernel size usually ~6*sigma, must be odd
+            k_pupil = int(math.ceil(6 * (0.1 * wavelength_scale))) | 1
+            sp = cv2.GaussianBlur(pupil, (k_pupil, k_pupil), 0.1 * wavelength_scale)
+        else:
+            sp = gaussian_filter(pupil, sigma=0.1 * wavelength_scale)
+        
         fft = np.fft.fftshift(np.fft.fft2(np.fft.ifftshift(sp)))
         intensity = np.abs(fft)**2
         intensity /= (intensity.max() + 1e-8)
-        blurred = gaussian_filter(intensity, sigma=blur_sigma)
+        
+        if has_cv2 and blur_sigma > 0:
+            k_blur = int(math.ceil(6 * blur_sigma)) | 1
+            blurred = cv2.GaussianBlur(intensity, (k_blur, k_blur), blur_sigma)
+        else:
+            blurred = gaussian_filter(intensity, sigma=blur_sigma)
+            
         psf = blurred / max(blurred.max(), 1e-8)
+        
         if wavelength_scale != 1.0:
-            psf = ndi.zoom(psf, zoom=wavelength_scale, order=1)
+            if has_cv2:
+                h, w = psf.shape
+                # Zoom uses size, NOT scale factor in resize(..., dsize=(w,h))
+                # wavelength_scale > 1 => zoom in => crop middle? or simply scale?
+                # The original used ndi.zoom(psf, zoom=wavelength_scale).
+                # New size:
+                nw, nh = int(round(w * wavelength_scale)), int(round(h * wavelength_scale))
+                if nw > 0 and nh > 0:
+                    scaled = cv2.resize(psf, (nw, nh), interpolation=cv2.INTER_LINEAR)
+                    # We might need to crop back to original size or pad?
+                    # ndi.zoom changes the array size.
+                    # The simulator seems to assume we handle whatever size comes out?
+                    # Let's check _extract_center_tile usage.
+                    psf = scaled
+            else:
+                 psf = ndi.zoom(psf, zoom=wavelength_scale, order=1)
+            
             psf /= psf.max() + 1e-12
         return psf
 
@@ -591,15 +683,7 @@ class StarSpikesDialogPro(QDialog):
                 stars.append((int(obj['x']), int(obj['y']), float(flux), float(a), float(b)))
         return stars
 
-    @staticmethod
-    def _shrink_and_boost(tile, brightness_scale=2.0, shrink_factor=1.5):
-        tile = np.clip(tile * float(brightness_scale), 0.0, 1.0)
-        in_sz = tile.shape[0]
-        out_sz = int(in_sz // float(shrink_factor))
-        out_sz += out_sz % 2
-        if out_sz <= 0: out_sz = 2
-        z = out_sz / float(in_sz)
-        return np.clip(ndi.zoom(tile, z, order=1), 0.0, 1.0)
+    # _shrink_and_boost removed (replaced by inline _fast_zoom for performance)
 
     @staticmethod
     def _boost_shrink_from_flux(flux, flux_min, flux_max, bmin, bmax, smin, smax):

setiastro/saspro/star_stretch.py

@@ -126,9 +126,17 @@ class StarStretchDialog(QDialog):
     """
     def __init__(self, parent, document):
         super().__init__(parent)
-        self.setWindowTitle("Star Stretch")
+        self.setWindowTitle(self.tr("Star Stretch"))
+        self.setWindowFlag(Qt.WindowType.Window, True)
+        self.setWindowModality(Qt.WindowModality.NonModal)
+        self.setModal(False)
+        self._main = parent
         self.doc = document
         self._preview: np.ndarray | None = None
+
+        # Connect to active document change signal
+        if hasattr(self._main, "currentDocumentChanged"):
+            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
         self._pix: QPixmap | None = None
         self._zoom = 0.25
         self._panning = False
@@ -150,7 +158,7 @@ class StarStretchDialog(QDialog):
         left.addWidget(info)
 
         # Stretch slider (0..8.00)
-        self.lbl_st = QLabel("Stretch Amount: 5.00")
+        self.lbl_st = QLabel(self.tr("Stretch Amount:") + " 5.00")
         self.sld_st = QSlider(Qt.Orientation.Horizontal)
         self.sld_st.setRange(0, 800)
         self.sld_st.setValue(500)
@@ -159,7 +167,7 @@ class StarStretchDialog(QDialog):
         left.addWidget(self.sld_st)
 
         # Saturation slider (0..2.00)
-        self.lbl_sat = QLabel("Color Boost: 1.00")
+        self.lbl_sat = QLabel(self.tr("Color Boost:") + " 1.00")
         self.sld_sat = QSlider(Qt.Orientation.Horizontal)
         self.sld_sat.setRange(0, 200)
         self.sld_sat.setValue(100)
@@ -168,13 +176,13 @@ class StarStretchDialog(QDialog):
         left.addWidget(self.sld_sat)
 
         # SCNR checkbox
-        self.chk_scnr = QCheckBox("Remove Green via SCNR (Optional)")
+        self.chk_scnr = QCheckBox(self.tr("Remove Green via SCNR (Optional)"))
         left.addWidget(self.chk_scnr)
 
         # Buttons row
         rowb = QHBoxLayout()
-        self.btn_preview = QPushButton("Preview")
-        self.btn_apply = QPushButton("Apply to Document")
+        self.btn_preview = QPushButton(self.tr("Preview"))
+        self.btn_apply = QPushButton(self.tr("Apply to Document"))
         rowb.addWidget(self.btn_preview)
         rowb.addWidget(self.btn_apply)
         left.addLayout(rowb)
@@ -198,9 +206,9 @@ class StarStretchDialog(QDialog):
         # Right column (preview with zoom/pan)
         right = QVBoxLayout()
         zoombar = QHBoxLayout()
-        b_out = QPushButton("Zoom Out")
-        b_in  = QPushButton("Zoom In")
-        b_fit = QPushButton("Fit to Preview")
+        b_out = QPushButton(self.tr("Zoom Out"))
+        b_in  = QPushButton(self.tr("Zoom In"))
+        b_fit = QPushButton(self.tr("Fit to Preview"))
         b_out.clicked.connect(self._zoom_out)
         b_in.clicked.connect(self._zoom_in)
         b_fit.clicked.connect(self._fit)
@@ -225,6 +233,15 @@ class StarStretchDialog(QDialog):
         # initialize preview with current doc image
         self._update_preview_pix(self.doc.image)
 
+    # --- active document change ---
+    def _on_active_doc_changed(self, doc):
+        """Called when user clicks a different image window."""
+        if doc is None or getattr(doc, "image", None) is None:
+            return
+        self.doc = doc
+        self._preview = None
+        self._update_preview_pix(self.doc.image)
+
     # --- UI change handlers ---
     def _on_stretch_changed(self, v: int):
         self.lbl_st.setText(f"Stretch Amount: {v/100.0:.2f}")
@@ -325,7 +342,27 @@ class StarStretchDialog(QDialog):
         except Exception as e:
             QMessageBox.critical(self, "Apply failed", str(e))
             return
-        self.accept()
+        
+        # Dialog stays open so user can apply to other images
+        # Refresh document reference for next operation
+        self._refresh_document_from_active()
+
+    def _refresh_document_from_active(self):
+        """
+        Refresh the dialog's document reference to the currently active document.
+        This allows reusing the same dialog on different images.
+        """
+        try:
+            main = self._find_main_window()
+            if main and hasattr(main, "_active_doc"):
+                new_doc = main._active_doc()
+                if new_doc is not None and new_doc is not self.doc:
+                    self.doc = new_doc
+                    # Reset preview for new document
+                    self._preview = None
+                    self._compute_and_show_preview()
+        except Exception:
+            pass
 
 
     # --- preview rendering ---

setiastro/saspro/stat_stretch.py

@@ -20,18 +20,23 @@ class StatisticalStretchDialog(QDialog):
     """
     def __init__(self, parent, document: ImageDocument):
         super().__init__(parent)
-        self.setWindowTitle("Statistical Stretch")
+        self.setWindowTitle(self.tr("Statistical Stretch"))
 
         # --- IMPORTANT: avoid “attached modal” behavior on some Linux WMs ---
         # Make this a proper top-level window (tool-style) rather than an attached sheet.
         self.setWindowFlag(Qt.WindowType.Window, True)
-        # Block the app if you want, but don't use WindowModal
-        self.setWindowModality(Qt.WindowModality.ApplicationModal)
+        # Non-modal: allow user to switch between images while dialog is open
+        self.setWindowModality(Qt.WindowModality.NonModal)
         # Don’t let the generic modal flag override the explicit modality
         self.setModal(False)
 
+        self._main = parent
         self.doc = document
         self._last_preview = None
+
+        # Connect to active document change signal
+        if hasattr(self._main, "currentDocumentChanged"):
+            self._main.currentDocumentChanged.connect(self._on_active_doc_changed)
         self._panning = False
         self._pan_last = None  # QPoint
         self._preview_scale = 1.0       # NEW: zoom factor for preview
@@ -45,20 +50,20 @@ class StatisticalStretchDialog(QDialog):
         self.spin_target.setValue(0.25)
         self.spin_target.setDecimals(3)
 
-        self.chk_linked = QCheckBox("Linked channels")
+        self.chk_linked = QCheckBox(self.tr("Linked channels"))
         self.chk_linked.setChecked(False)
 
-        self.chk_normalize = QCheckBox("Normalize to [0..1]")
+        self.chk_normalize = QCheckBox(self.tr("Normalize to [0..1]"))
         self.chk_normalize.setChecked(False)
 
         # NEW: Curves boost
-        self.chk_curves = QCheckBox("Curves boost")
+        self.chk_curves = QCheckBox(self.tr("Curves boost"))
         self.chk_curves.setChecked(False)
 
         self.curves_row = QWidget()
         cr_lay = QHBoxLayout(self.curves_row); cr_lay.setContentsMargins(0,0,0,0)
         cr_lay.setSpacing(8)
-        cr_lay.addWidget(QLabel("Strength:"))
+        cr_lay.addWidget(QLabel(self.tr("Strength:")))
         self.sld_curves = QSlider(Qt.Orientation.Horizontal)
         self.sld_curves.setRange(0, 100)           # 0.00 … 1.00 mapped to 0…100
         self.sld_curves.setSingleStep(1)
@@ -84,11 +89,15 @@ class StatisticalStretchDialog(QDialog):
         self._fit_mode = True       # NEW: start in Fit mode
 
         # --- Zoom buttons row (place before the main layout or right above preview) ---
+        # --- Zoom buttons row ---
         zoom_row = QHBoxLayout()
-        self.btn_zoom_out = QToolButton(); self.btn_zoom_out.setText("−")
-        self.btn_zoom_in  = QToolButton(); self.btn_zoom_in.setText("+")
-        self.btn_zoom_100 = QToolButton(); self.btn_zoom_100.setText("100%")
-        self.btn_zoom_fit = QToolButton(); self.btn_zoom_fit.setText("Fit")
+
+        # Use themed tool buttons (consistent with the rest of SASpro)
+        self.btn_zoom_out = themed_toolbtn("zoom-out", "Zoom Out")
+        self.btn_zoom_in  = themed_toolbtn("zoom-in", "Zoom In")
+        self.btn_zoom_100 = themed_toolbtn("zoom-original", "1:1")
+        self.btn_zoom_fit = themed_toolbtn("zoom-fit-best", "Fit")
+
 
         zoom_row.addStretch(1)
         for b in (self.btn_zoom_out, self.btn_zoom_in, self.btn_zoom_100, self.btn_zoom_fit):
@@ -96,9 +105,9 @@ class StatisticalStretchDialog(QDialog):
         zoom_row.addStretch(1)
 
         # Buttons
-        self.btn_preview = QPushButton("Preview")
-        self.btn_apply   = QPushButton("Apply")
-        self.btn_close   = QPushButton("Close")
+        self.btn_preview = QPushButton(self.tr("Preview"))
+        self.btn_apply   = QPushButton(self.tr("Apply"))
+        self.btn_close   = QPushButton(self.tr("Close"))
 
         self.btn_preview.clicked.connect(self._do_preview)
         self.btn_apply.clicked.connect(self._do_apply)
@@ -106,7 +115,7 @@ class StatisticalStretchDialog(QDialog):
 
         # --- Layout ---
         form = QFormLayout()
-        form.addRow("Target median:", self.spin_target)
+        form.addRow(self.tr("Target median:"), self.spin_target)
         form.addRow("", self.chk_linked)
         form.addRow("", self.chk_normalize)
         form.addRow("", self.chk_curves)
@@ -325,6 +334,14 @@ class StatisticalStretchDialog(QDialog):
         self._preview_qimg = qimg
         self._apply_current_zoom() 
 
+    # ----- active document change -----
+    def _on_active_doc_changed(self, doc):
+        """Called when user clicks a different image window."""
+        if doc is None or getattr(doc, "image", None) is None:
+            return
+        self.doc = doc
+        self._populate_initial_preview()
+
     # ----- slots -----
     def _populate_initial_preview(self):
         # show the current (unstretched) image as baseline
@@ -429,12 +446,31 @@ class StatisticalStretchDialog(QDialog):
                 # optional debug
                 print("Statistical Stretch: replay recording suppressed for this apply()")
 
-            self.accept()
+            # Dialog stays open so user can apply to other images
+            # Update the document reference to reflect the now-active document
+            self._refresh_document_from_active()
 
 
         except Exception as e:
             QMessageBox.critical(self, "Apply failed", str(e))
 
+    def _refresh_document_from_active(self):
+        """
+        Refresh the dialog's document reference to the currently active document.
+        This allows reusing the same dialog on different images.
+        """
+        try:
+            main = self.parent()
+            if main and hasattr(main, "_active_doc"):
+                new_doc = main._active_doc()
+                if new_doc is not None and new_doc is not self.doc:
+                    self.doc = new_doc
+                    # Reset preview state for new document
+                    self._last_preview = None
+                    self._preview_qimg = None
+        except Exception:
+            pass
+
 
     def _update_preview_scaled(self):
         if self._preview_qimg is None:

setiastro/saspro/status_log_dock.py

@@ -9,7 +9,7 @@ class StatusLogDock(QDockWidget):
     MAX_BLOCKS = 2000
 
     def __init__(self, parent=None):
-        super().__init__("Stacking Log", parent)
+        super().__init__(self.tr("Stacking Log"), parent)
         self.setObjectName("StackingLogDock")
         self.setAllowedAreas(
             Qt.DockWidgetArea.BottomDockWidgetArea