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

setiastro/saspro/gui/mixins/file_mixin.py

@@ -7,7 +7,7 @@ import os
 from typing import TYPE_CHECKING
 
 from PyQt6.QtCore import Qt
-from PyQt6.QtWidgets import QFileDialog, QMessageBox, QProgressDialog
+from PyQt6.QtWidgets import QFileDialog, QMessageBox, QProgressDialog, QApplication
 
 if TYPE_CHECKING:
     pass
@@ -85,7 +85,6 @@ class FileMixin:
         self._save_recent_lists()
         if hasattr(self, "_rebuild_recent_menus"):
             self._rebuild_recent_menus()
-# Extracted FILE methods
 
     def open_files(self):
         # One-stop "All Supported" plus focused groups the user can switch to
@@ -114,21 +113,41 @@ class FileMixin:
         except Exception:
             pass
 
-        # open each path (doc_manager should emit documentAdded; no manual spawn)
-        for p in paths:
-            try:
-                doc = self.docman.open_path(p)   # this emits documentAdded
-                self._log(f"Opened: {p}")
-                self._add_recent_image(p)        # âœ... track in MRU
-                
-                # Increment statistics
+        # ---- BEGIN batch open (stable placement) ----
+        try:
+            self._mdi_begin_open_batch(mode="cascade")
+        except Exception:
+            pass
+
+        QApplication.setOverrideCursor(Qt.CursorShape.WaitCursor)
+        try:
+            # open each path (doc_manager should emit documentAdded; no manual spawn)
+            for p in paths:
                 try:
-                    count = self.settings.value("stats/opened_images_count", 0, type=int)
-                    self.settings.setValue("stats/opened_images_count", count + 1)
-                except Exception:
-                    pass
-            except Exception as e:
-                QMessageBox.warning(self, self.tr("Open failed"), f"{p}\n\n{e}")
+                    _ = self.docman.open_path(p)   # emits documentAdded; spawn will happen
+                    self._log(f"Opened: {p}")
+                    self._add_recent_image(p)      # track MRU
+
+                    # Increment statistics
+                    try:
+                        count = self.settings.value("stats/opened_images_count", 0, type=int)
+                        self.settings.setValue("stats/opened_images_count", count + 1)
+                    except Exception:
+                        pass
+
+                    # Let Qt paint newly spawned subwindows as we go
+                    QApplication.processEvents()
+
+                except Exception as e:
+                    QMessageBox.warning(self, self.tr("Open failed"), f"{p}\n\n{e}")
+                    QApplication.processEvents()
+        finally:
+            QApplication.restoreOverrideCursor()
+            try:
+                self._mdi_end_open_batch()
+            except Exception:
+                pass
+
 
     def save_active(self):
         from setiastro.saspro.main_helpers import (

setiastro/saspro/gui/mixins/menu_mixin.py

@@ -6,8 +6,9 @@ from __future__ import annotations
 import os
 from typing import TYPE_CHECKING
 
-from PyQt6.QtGui import QAction
+from PyQt6.QtGui import QAction, QKeySequence
 from PyQt6.QtWidgets import QMenu, QToolButton, QWidgetAction
+from PyQt6.QtCore import Qt
 
 if TYPE_CHECKING:
     pass
@@ -120,6 +121,9 @@ class MenuMixin:
         m_edit = mb.addMenu(self.tr("&Edit"))
         m_edit.addAction(self.act_undo)
         m_edit.addAction(self.act_redo)
+        m_edit.addSeparator()
+        m_edit.addAction(self.act_mono_to_rgb)
+
 
         # Functions
         m_fn = mb.addMenu(self.tr("&Functions"))
@@ -169,6 +173,7 @@ class MenuMixin:
         m_tools.addAction(self.act_freqsep)
         m_tools.addAction(self.act_image_combine)
         m_tools.addAction(self.act_multiscale_decomp)
+        m_tools.addAction(self.act_narrowband_normalization)
         m_tools.addAction(self.act_nbtorgb)
         m_tools.addAction(self.act_ppp)
         m_tools.addAction(self.act_selective_color)
@@ -199,6 +204,7 @@ class MenuMixin:
         m_star.addAction(self.act_isophote)
         m_star.addAction(self.act_live_stacking)
         m_star.addAction(self.act_mosaic_master)
+        m_star.addAction(self.act_planetary_stacker)
         m_star.addAction(self.act_plate_solve)
         m_star.addAction(self.act_psf_viewer)
         m_star.addAction(self.act_rgb_align)
@@ -267,6 +273,14 @@ class MenuMixin:
         m_view.addAction(self.act_tile_grid)        
         m_view.addSeparator()
 
+        # NEW: Minimize All Views
+        self.act_minimize_all_views = QAction(self.tr("Minimize All Views"), self)
+        self.act_minimize_all_views.setShortcut(QKeySequence("Ctrl+Shift+M"))
+        self.act_minimize_all_views.setShortcutContext(Qt.ShortcutContext.ApplicationShortcut)
+        self.act_minimize_all_views.triggered.connect(self._minimize_all_views)
+        m_view.addAction(self.act_minimize_all_views)
+
+        m_view.addSeparator()
 
         # a button that shows current group & opens a drop-down
         self._link_btn = QToolButton(self)
@@ -389,3 +403,19 @@ class MenuMixin:
             if sub is not None:
                 yield from self._iter_menu_actions(sub)
 
+    def _minimize_all_views(self):
+        mdi = getattr(self, "mdi", None)
+        if mdi is None:
+            return
+
+        try:
+            for sw in mdi.subWindowList():
+                try:
+                    if not sw.isVisible():
+                        continue
+                    # Minimize each MDI child
+                    sw.showMinimized()
+                except Exception:
+                    pass
+        except Exception:
+            pass

setiastro/saspro/gui/mixins/toolbar_mixin.py

@@ -12,6 +12,7 @@ from PyQt6.QtWidgets import QMenu, QToolButton
 
 from PyQt6.QtCore import QElapsedTimer
 
+import sys
 
 if TYPE_CHECKING:
     pass
@@ -30,10 +31,10 @@ from setiastro.saspro.resources import (
     stacking_path, pedestal_icon_path, starspike_path, astrospike_path,
     signature_icon_path, livestacking_path, convoicon_path, spcc_icon_path,
     exoicon_path, peeker_icon, dse_icon_path, isophote_path, statstretch_path,
-    starstretch_path, curves_path, disk_path, uhs_path, blink_path, ppp_path,
+    starstretch_path, curves_path, disk_path, uhs_path, blink_path, ppp_path, narrowbandnormalization_path,
     nbtorgb_path, freqsep_path, multiscale_decomp_path, contsub_path, halo_path, cosmic_path,
     satellite_path, imagecombine_path, wims_path, wimi_path, linearfit_path,
-    debayer_path, aberration_path, functionbundles_path, viewbundles_path,
+    debayer_path, aberration_path, functionbundles_path, viewbundles_path, planetarystacker_path,
     selectivecolor_path, rgbalign_path,
 )
 
@@ -255,6 +256,7 @@ class ToolbarMixin:
         tb_tl.addAction(self.act_blink)  # Tools start here; Blink shows with QIcon(blink_path)
         tb_tl.addAction(self.act_ppp)    # Perfect Palette Picker
         tb_tl.addAction(self.act_nbtorgb)
+        tb_tl.addAction(self.act_narrowband_normalization)
         tb_tl.addAction(self.act_selective_color)
         tb_tl.addAction(self.act_freqsep)
         tb_tl.addAction(self.act_multiscale_decomp)
@@ -301,6 +303,7 @@ class ToolbarMixin:
         tb_star.addAction(self.act_psf_viewer)
         tb_star.addAction(self.act_stacking_suite)
         tb_star.addAction(self.act_live_stacking)
+        tb_star.addAction(self.act_planetary_stacker)
         tb_star.addAction(self.act_plate_solve)
         tb_star.addAction(self.act_star_align)
         tb_star.addAction(self.act_star_register)
@@ -366,6 +369,7 @@ class ToolbarMixin:
         tb_hidden.setObjectName("Hidden")
         tb_hidden.setSettingsKey("Toolbar/Hidden")
         self.addToolBar(Qt.ToolBarArea.TopToolBarArea, tb_hidden)
+        #tb_hidden.addAction(self.act_narrowband_normalization)
         tb_hidden.setVisible(False)  # <- always hidden
 
         # This can move actions between toolbars, so do it after each toolbar has its base order restored.
@@ -594,7 +598,16 @@ class ToolbarMixin:
                 fit_menu.addAction(self.act_auto_fit_resize)  # use the real action
                 btn_fit.setMenu(fit_menu)
                 btn_fit.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
+        tb = self._toolbar_containing_action(self.act_autostretch)
+        if tb:
+            btn = tb.widgetForAction(self.act_autostretch)
+            if isinstance(btn, QToolButton):
+                # ... build menu ...
+                btn.setMenu(menu)
+                btn.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
 
+                # IMPORTANT: re-apply style after action moves / rebind
+                self._style_toggle_toolbutton(btn)
 
     def _bind_view_toolbar_menus(self, tb: DraggableToolBar):
         # --- Display-Stretch menu ---
@@ -650,6 +663,12 @@ class ToolbarMixin:
             btn_fit.setMenu(fit_menu)
             btn_fit.setPopupMode(QToolButton.ToolButtonPopupMode.MenuButtonPopup)
 
+    def _linux_force_text_action(self, act: QAction, text: str) -> None:
+        """On Linux, show text-only for this action (no theme icon)."""
+        if not sys.platform.startswith("linux"):
+            return
+        act.setIcon(QIcon())   # remove whatever theme icon got assigned
+        act.setText(text)      # show the glyph/text
 
     def _create_actions(self):
         # File actions
@@ -771,30 +790,30 @@ class ToolbarMixin:
         self.act_bake_display_stretch.triggered.connect(self._bake_display_stretch)
 
         # --- Zoom controls ---
-        # --- Zoom controls (themed icons) ---
         self.act_zoom_out = QAction(QIcon.fromTheme("zoom-out"), self.tr("Zoom Out"), self)
         self.act_zoom_out.setStatusTip(self.tr("Zoom out"))
         self.act_zoom_out.setShortcuts([QKeySequence("Ctrl+-")])
         self.act_zoom_out.triggered.connect(lambda: self._zoom_step_active(-1))
+        self._linux_force_text_action(self.act_zoom_out, "−")   # true minus
 
         self.act_zoom_in = QAction(QIcon.fromTheme("zoom-in"), self.tr("Zoom In"), self)
         self.act_zoom_in.setStatusTip(self.tr("Zoom in"))
-        self.act_zoom_in.setShortcuts([
-            QKeySequence("Ctrl++"),   # Ctrl + (Shift + = on many keyboards)
-            QKeySequence("Ctrl+="),   # fallback
-        ])
+        self.act_zoom_in.setShortcuts([QKeySequence("Ctrl++"), QKeySequence("Ctrl+=")])
         self.act_zoom_in.triggered.connect(lambda: self._zoom_step_active(+1))
+        self._linux_force_text_action(self.act_zoom_in, "+")
 
         self.act_zoom_1_1 = QAction(QIcon.fromTheme("zoom-original"), self.tr("1:1"), self)
         self.act_zoom_1_1.setStatusTip(self.tr("Zoom to 100% (pixel-for-pixel)"))
         self.act_zoom_1_1.setShortcut(QKeySequence("Ctrl+1"))
         self.act_zoom_1_1.triggered.connect(self._zoom_active_1_1)
+        self._linux_force_text_action(self.act_zoom_1_1, "1:1")
 
         self.act_zoom_fit = QAction(QIcon.fromTheme("zoom-fit-best"), self.tr("Fit"), self)
         self.act_zoom_fit.setStatusTip(self.tr("Fit image to current window"))
         self.act_zoom_fit.setShortcut(QKeySequence("Ctrl+0"))
         self.act_zoom_fit.triggered.connect(self._zoom_active_fit)
         self.act_zoom_fit.setCheckable(True)
+        self._linux_force_text_action(self.act_zoom_fit, "Fit")
 
         self.act_auto_fit_resize = QAction(self.tr("Auto-fit on Resize"), self)
         self.act_auto_fit_resize.setCheckable(True)
@@ -813,6 +832,10 @@ class ToolbarMixin:
         self.act_paste_view.setShortcut("Ctrl+Shift+V")
         self.act_copy_view.triggered.connect(self._copy_active_view)
         self.act_paste_view.triggered.connect(self._paste_active_view)
+        # --- Edit: Mono -> RGB (triplicate channels) ---
+        self.act_mono_to_rgb = QAction(self.tr("Convert Mono to RGB"), self)
+        self.act_mono_to_rgb.setStatusTip(self.tr("Convert a mono image to RGB by duplicating the channel"))
+        self.act_mono_to_rgb.triggered.connect(self._convert_mono_to_rgb_active)
 
         # Functions
         self.act_crop = QAction(QIcon(cropicon_path), self.tr("Crop..."), self)
@@ -877,7 +900,7 @@ class ToolbarMixin:
         self.act_linear_fit.setShortcut("Ctrl+L")
         self.act_linear_fit.triggered.connect(self._open_linear_fit)
 
-        self.act_remove_green = QAction(QIcon(green_path), self.tr("Remove Green..."), self)
+        self.act_remove_green = QAction(QIcon(green_path), self.tr("Remove Green (SCNR)..."), self)
         self.act_remove_green.setToolTip(self.tr("SCNR-style green channel removal."))
         self.act_remove_green.setIconVisibleInMenu(True)
         self.act_remove_green.triggered.connect(self._open_remove_green)
@@ -1102,6 +1125,16 @@ class ToolbarMixin:
         self.act_ppp.setStatusTip(self.tr("Pick the perfect palette for your image"))
         self.act_ppp.triggered.connect(self._open_ppp_tool) 
 
+        self.act_narrowband_normalization = QAction(QIcon(narrowbandnormalization_path), self.tr("Narrowband Normalization..."), self)
+        self.act_narrowband_normalization.setStatusTip(
+            self.tr("Normalize HOO/SHO/HSO/HOS (PixelMath port by Bill Blanshan and Mike Cranfield)")
+        )
+        self.act_narrowband_normalization.setIconVisibleInMenu(False)
+        self.act_narrowband_normalization.setShortcut(QKeySequence("Ctrl+Alt+Shift+N"))
+        self.act_narrowband_normalization.setShortcutContext(Qt.ShortcutContext.ApplicationShortcut)
+        self.addAction(self.act_narrowband_normalization)
+        self.act_narrowband_normalization.triggered.connect(self._open_narrowband_normalization_tool)
+
         self.act_nbtorgb = QAction(QIcon(nbtorgb_path), self.tr("NB->RGB Stars..."), self)
         self.act_nbtorgb.setStatusTip(self.tr("Combine narrowband to RGB with optional OSC stars"))
         self.act_nbtorgb.setIconVisibleInMenu(True)
@@ -1149,6 +1182,11 @@ class ToolbarMixin:
         self.act_live_stacking.setStatusTip(self.tr("Live monitor and stack incoming frames"))
         self.act_live_stacking.triggered.connect(self._open_live_stacking)
 
+        self.act_planetary_stacker = QAction(QIcon(planetarystacker_path), self.tr("Planetary Stacker..."), self)
+        self.act_planetary_stacker.setIconVisibleInMenu(True)
+        self.act_planetary_stacker.setStatusTip(self.tr("Stack SER videos (planetary/solar/lunar)"))
+        self.act_planetary_stacker.triggered.connect(self._open_planetary_stacker)
+
         self.act_plate_solve = QAction(QIcon(platesolve_path), self.tr("Plate Solver..."), self)
         self.act_plate_solve.setIconVisibleInMenu(True)
         self.act_plate_solve.setStatusTip(self.tr("Solve WCS/SIP for the active image or a file"))
@@ -1345,6 +1383,7 @@ class ToolbarMixin:
         reg("nbtorgb",       self.act_nbtorgb)
         reg("freqsep",       self.act_freqsep)
         reg("selective_color", self.act_selective_color)
+        reg("narrowband_normalization", self.act_narrowband_normalization)
         reg("contsub",      self.act_contsub)
         reg("abe",          self.act_abe)
         reg("create_mask", self.act_create_mask)
@@ -1369,7 +1408,7 @@ class ToolbarMixin:
         reg("pixel_math", self.act_pixelmath)
         reg("signature_insert", self.act_signature) 
         reg("halo_b_gon", self.act_halobgon)
-
+        reg("planetary_stacker", self.act_planetary_stacker)
         reg("multiscale_decomp", self.act_multiscale_decomp)        
         reg("geom_invert",                 self.act_geom_invert)
         reg("geom_flip_horizontal",        self.act_geom_flip_h)
@@ -1407,6 +1446,83 @@ class ToolbarMixin:
         reg("view_bundles", self.act_view_bundles)
         reg("function_bundles", self.act_function_bundles)
 
+    def _reset_all_toolbars_to_factory(self):
+        """
+        Clears all persisted toolbar membership/order/hidden state so the UI
+        returns to the factory layout defined in code.
+        """
+        if not hasattr(self, "settings"):
+            return
+
+        # 1) Clear global toolbar persistence
+        keys_to_clear = [
+            "Toolbar/Assignments",
+            "Toolbar/HiddenPrev",
+            "Toolbar/HiddenMigrationDone",
+
+            # Per-toolbar order lists
+            "Toolbar/View",
+            "Toolbar/Functions",
+            "Toolbar/Cosmic",
+            "Toolbar/Tools",
+            "Toolbar/Geometry",
+            "Toolbar/StarStuff",
+            "Toolbar/Masks",
+            "Toolbar/WhatsInMy",
+            "Toolbar/Bundles",
+            "Toolbar/Hidden",
+        ]
+
+        for k in keys_to_clear:
+            try:
+                self.settings.remove(k)
+            except Exception:
+                pass
+
+        # 2) Clear legacy hidden lists (old system) if they exist
+        # (These are the ones like "Toolbar/Tools/Hidden")
+        try:
+            # brute-force remove known ones
+            legacy_hidden = [
+                "Toolbar/View/Hidden",
+                "Toolbar/Functions/Hidden",
+                "Toolbar/Cosmic/Hidden",
+                "Toolbar/Tools/Hidden",
+                "Toolbar/Geometry/Hidden",
+                "Toolbar/StarStuff/Hidden",
+                "Toolbar/Masks/Hidden",
+                "Toolbar/WhatsInMy/Hidden",
+                "Toolbar/Bundles/Hidden",
+            ]
+            for k in legacy_hidden:
+                self.settings.remove(k)
+        except Exception:
+            pass
+
+        try:
+            self.settings.sync()
+        except Exception:
+            pass
+
+        # 3) Rebuild toolbars from code defaults
+        # Safest approach: remove existing toolbars and rebuild.
+        from setiastro.saspro.shortcuts import DraggableToolBar
+        for tb in self.findChildren(DraggableToolBar):
+            try:
+                self.removeToolBar(tb)
+                tb.deleteLater()
+            except Exception:
+                pass
+
+        # Build fresh
+        self._init_toolbar()
+
+        # Optional: ensure Hidden stays hidden
+        tb_hidden = self._hidden_toolbar()
+        if tb_hidden:
+            tb_hidden.setVisible(False)
+
+
     def _restore_toolbar_order(self, tb, settings_key: str):
         """
         Restore toolbar action order from QSettings, using command_id/objectName.
@@ -1821,4 +1937,10 @@ class ToolbarMixin:
         if hasattr(self, "act_hide_mask"):
             self.act_hide_mask.setEnabled(has_mask and overlay_on)
 
-
+    def _style_toggle_toolbutton(self, btn: QToolButton):
+        # Make sure the action visually shows "on" state
+        btn.setCheckable(True)  # safe even if already
+        btn.setStyleSheet("""
+            QToolButton { color: #dcdcdc; }
+            QToolButton:checked { color: #DAA520; font-weight: 600; }
+        """)

setiastro/saspro/histogram.py

@@ -4,8 +4,8 @@ import numpy as np
 
 from PyQt6.QtCore import Qt, QSettings, QTimer, QEvent, pyqtSignal
 from PyQt6.QtWidgets import (
-    QDialog, QVBoxLayout, QHBoxLayout, QLabel, QSlider, QPushButton, QScrollArea,
-    QTableWidget, QTableWidgetItem, QMessageBox, QToolButton, QInputDialog, QSplitter, QSizePolicy, QHeaderView
+    QDialog, QVBoxLayout, QHBoxLayout, QLabel, QSlider, QPushButton, QScrollArea,QWidget,
+    QTableWidget, QTableWidgetItem, QMessageBox, QToolButton, QInputDialog, QSplitter, QSizePolicy, QHeaderView, QApplication
 )
 from PyQt6.QtGui import QPixmap, QPainter, QPen, QColor, QFont, QPalette
 
@@ -125,7 +125,12 @@ class HistogramDialog(QDialog):
 
         splitter.addWidget(self.scroll_area)
 
-        # right: stats table
+        # right: stats panel (table + button under it)
+        stats_panel = QWidget(self)
+        stats_v = QVBoxLayout(stats_panel)
+        stats_v.setContentsMargins(0, 0, 0, 0)
+        stats_v.setSpacing(6)
+
         self.stats_table = QTableWidget(self)
         self.stats_table.setRowCount(7)
         self.stats_table.setColumnCount(1)
@@ -137,15 +142,21 @@ class HistogramDialog(QDialog):
         # Let it grow/shrink with the splitter
         self.stats_table.setMinimumWidth(320)
         self.stats_table.setSizePolicy(
-            QSizePolicy.Policy.Preferred,      # <- was Fixed
+            QSizePolicy.Policy.Preferred,
             QSizePolicy.Policy.Expanding,
         )
 
-        # Make the columns use available width nicely
         hdr = self.stats_table.horizontalHeader()
         hdr.setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
-        # hdr.setStretchLastSection(True)
-        splitter.addWidget(self.stats_table)
+
+        stats_v.addWidget(self.stats_table, 1)
+
+        # NEW: button directly under the table
+        self.btn_more_stats = QPushButton(self.tr("More Stats…"), self)
+        self.btn_more_stats.clicked.connect(self._show_more_stats)
+        stats_v.addWidget(self.btn_more_stats, 0)
+
+        splitter.addWidget(stats_panel)
 
         # Give more space to histogram side by default
         splitter.setStretchFactor(0, 3)
@@ -631,6 +642,167 @@ class HistogramDialog(QDialog):
 
         self._adjust_stats_width()        
 
+    def _show_more_stats(self):
+        if self.image is None:
+            return
+
+        dlg = QDialog(self)
+        dlg.setWindowTitle(self.tr("Image Statistics"))
+        dlg.setWindowModality(Qt.WindowModality.NonModal)
+        dlg.setModal(False)
+
+        root = QVBoxLayout(dlg)
+
+        info = QLabel(self.tr(
+            "Detailed robust statistics and percentiles.\n"
+            "Computed on normalized float image values in [0,1]."
+        ))
+        info.setWordWrap(True)
+        root.addWidget(info)
+
+        tbl = QTableWidget(dlg)
+        tbl.setSizePolicy(QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Expanding)
+        root.addWidget(tbl, 1)
+
+        btn_row = QHBoxLayout()
+        btn_copy = QPushButton(self.tr("Copy as Text"), dlg)
+        btn_close = QPushButton(self.tr("Close"), dlg)
+        btn_row.addStretch(1)
+        btn_row.addWidget(btn_copy)
+        btn_row.addWidget(btn_close)
+        root.addLayout(btn_row)
+
+        btn_close.clicked.connect(dlg.accept)
+
+        # ---- compute stats ----
+        img = self.image
+        if img.ndim == 3 and img.shape[2] == 3:
+            chans = [img[..., 0], img[..., 1], img[..., 2]]
+            col_names = ["R", "G", "B"]
+        else:
+            chan = img if img.ndim == 2 else img[..., 0]
+            chans = [chan]
+            col_names = ["Gray"]
+
+        row_defs = [
+            ("Min", "min"),
+            ("Max", "max"),
+            ("Mean", "mean"),
+            ("Median", "median"),
+            ("StdDev", "std"),
+            ("Variance", "var"),
+            ("MAD", "mad"),
+            ("IQR (p75-p25)", "iqr"),
+            ("p0.1", "p0.1"),
+            ("p1", "p1"),
+            ("p5", "p5"),
+            ("p25", "p25"),
+            ("p50", "p50"),
+            ("p75", "p75"),
+            ("p95", "p95"),
+            ("p99", "p99"),
+            ("p99.9", "p99.9"),
+            ("Low Clipped (<=0)", "lowclip"),
+            ("High Clipped (>=TrueMax)", "highclip"),
+        ]
+
+        tbl.setRowCount(len(row_defs))
+        tbl.setColumnCount(len(chans))
+        tbl.setHorizontalHeaderLabels(col_names)
+        tbl.setVerticalHeaderLabels([r[0] for r in row_defs])
+
+        # Precompute thresholds for clipping
+        eps = 1e-6
+        hi_thr = max(eps, float(self.sensor_max01) - eps)
+
+        def _fmt(x):
+            return f"{float(x):.6f}"
+
+        def _fmt_clip(k, n):
+            pct = 100.0 * float(k) / float(max(1, n))
+            return f"{int(k)} ({pct:.3f}%)"
+
+        # Percentiles we want
+        pct_list = [0.1, 1, 5, 25, 50, 75, 95, 99, 99.9]
+
+        # Fill table
+        for c_idx, c_arr in enumerate(chans):
+            flat = np.asarray(c_arr, dtype=np.float32).ravel()
+            if flat.size > 20_000_000:
+                idx = np.random.default_rng(0).choice(flat.size, size=5_000_000, replace=False)
+                flat = flat[idx]
+
+            n = int(flat.size) if flat.size else 1
+
+            # basic moments
+            cmin = float(np.min(flat))
+            cmax = float(np.max(flat))
+            cmean = float(np.mean(flat))
+            cmed = float(np.median(flat))
+            cstd = float(np.std(flat))
+            cvar = float(np.var(flat))
+
+            # robust
+            mad = float(np.median(np.abs(flat - cmed)))
+            pcts = np.percentile(flat, pct_list) if flat.size else np.zeros(len(pct_list), dtype=np.float32)
+            p25, p75 = float(pcts[3]), float(pcts[5])
+            iqr = float(p75 - p25)
+
+            # clipping
+            low_k = int(np.count_nonzero(flat <= eps))
+            high_k = int(np.count_nonzero(flat >= hi_thr))
+
+            values = {
+                "min": cmin,
+                "max": cmax,
+                "mean": cmean,
+                "median": cmed,
+                "std": cstd,
+                "var": cvar,
+                "mad": mad,
+                "iqr": iqr,
+                "p0.1": float(pcts[0]),
+                "p1": float(pcts[1]),
+                "p5": float(pcts[2]),
+                "p25": float(pcts[3]),
+                "p50": float(pcts[4]),
+                "p75": float(pcts[5]),
+                "p95": float(pcts[6]),
+                "p99": float(pcts[7]),
+                "p99.9": float(pcts[8]),
+                "lowclip": _fmt_clip(low_k, n),
+                "highclip": _fmt_clip(high_k, n),
+            }
+
+            for r, (_, key) in enumerate(row_defs):
+                v = values[key]
+                text = v if isinstance(v, str) else _fmt(v)
+                it = QTableWidgetItem(text)
+                it.setTextAlignment(Qt.AlignmentFlag.AlignCenter)
+                tbl.setItem(r, c_idx, it)
+
+        hdr = tbl.horizontalHeader()
+        hdr.setSectionResizeMode(QHeaderView.ResizeMode.Stretch)
+
+        def _copy_as_text():
+            # TSV with rows
+            lines = []
+            lines.append("\t" + "\t".join(col_names))
+            for r, (lab, _) in enumerate(row_defs):
+                row = [lab]
+                for c in range(len(col_names)):
+                    item = tbl.item(r, c)
+                    row.append(item.text() if item else "")
+                lines.append("\t".join(row))
+            QApplication.clipboard().setText("\n".join(lines))
+            QMessageBox.information(dlg, self.tr("Copied"), self.tr("Statistics copied to clipboard."))
+
+        btn_copy.clicked.connect(_copy_as_text)
+
+        dlg.resize(720, 520)
+        dlg.show()
+
+
     def _theoretical_native_max_from_meta(self):
         meta = getattr(self.doc, "metadata", None) or {}
         bd = str(meta.get("bit_depth", "")).lower()