gratinglab 0.1.13__tar.gz → 0.2.0__tar.gz

{gratinglab-0.1.13/src/gratinglab.egg-info → gratinglab-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gratinglab
-Version: 0.1.13
+Version: 0.2.0
 Summary: Open platform for diffraction grating groove metrology and efficiency analysis
 Author: Jake McCoy, Aditi Gangadharan
 License: BSD-3-Clause
@@ -23,6 +23,7 @@ Requires-Dist: numpy>=1.26
 Requires-Dist: scipy>=1.11
 Requires-Dist: pydantic>=2.6
 Requires-Dist: endstation>=0.2.2
+Requires-Dist: threadpoolctl>=3.1
 Provides-Extra: dev
 Requires-Dist: pytest>=7; extra == "dev"
 Requires-Dist: pytest-qt>=4.5; extra == "dev"

{gratinglab-0.1.13 → gratinglab-0.2.0}/pyproject.toml

@@ -52,6 +52,13 @@ dependencies = [
     # so this line adds no transitive weight -- the Qt and matplotlib parts sit
     # behind its own extras, which our `gui` extra asks for by name.
     "endstation>=0.2.2",
+    # The rigorous solvers cap BLAS threads for the length of a solve
+    # (solvers/_execution.py): OpenBLAS's thread-per-core default made RCWA
+    # up to 135x slower on a busy machine, measured in benchmarks/
+    # solver_speed.py. NumPy and SciPy each load their own OpenBLAS, and
+    # this is the one maintained way to reach both. Pure Python, BSD-3, no
+    # dependencies of its own.
+    "threadpoolctl>=3.1",
 ]
 
 [project.optional-dependencies]

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/__init__.py

@@ -22,7 +22,7 @@ from .measured import MeasuredEfficiency, MeasurementProvenance
 from .resolution import ResolvingPower, resolving_power
 from .result import EfficiencyScan, OrderEfficiency, Provenance
 
-__version__ = "0.1.13"
+__version__ = "0.2.0"
 
 __all__ = [
     "Illumination",

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/checks.py

@@ -238,6 +238,9 @@ def check_energy_balance(
 
     Notes
     -----
+    Transmitted orders, when the scan records them, are added to the sum: the
+    power a lossless substrate carries away is accounted for, not lost.
+
     When the scan records an absorbed fraction (``scan.absorption``, from a
     solver that computes one independently), the conserved quantity is the
     sum plus the absorption, and that is what is checked. ``R + A = 1`` is a
@@ -253,6 +256,8 @@ def check_energy_balance(
     reached 3.6.
     """
     total = np.asarray(scan.total, dtype=np.float64)
+    if scan.transmission is not None:
+        total = total + scan.transmission.total
     if scan.absorption is not None:
         total = total + scan.absorption
     return EnergyReport(

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/gui/docs.py

@@ -44,8 +44,10 @@ __all__ = [
 #: name for anything not listed here, so a new solver still gets a menu entry
 #: before anyone remembers to add a nicer title.
 _TITLES = {
+    "cmethod": "C-method (Chandezon)",
     "scalar": "Scalar (Kirchhoff)",
     "integral": "Integral (boundary integral equation)",
+    "rcwa": "RCWA (Fourier modal method)",
 }
 
 #: Non-solver reference pages: (key, title, filename relative to docs/).
@@ -105,6 +107,17 @@ def display_title(name: str) -> str:
     return _TITLES.get(name, name)
 
 
+def short_title(name: str) -> str:
+    """A solver's tab label: its display title without the bracketed gloss.
+
+    ``"Integral (boundary integral equation)"`` becomes ``"Integral"``. The
+    full title was the tab label until 2026-10-27, and with four tabs plus the
+    geometry dock it already overflowed the bar, so every new solver made it
+    worse. The full title stays in the Help menu and the tab's tooltip.
+    """
+    return display_title(name).split(" (", 1)[0]
+
+
 def find_theory_root(start: Path | None = None) -> Path | None:
     """Search upward from ``start`` for a ``docs/theory`` directory.
 

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/gui/efficiency_plot.py

@@ -50,6 +50,14 @@ def draw_efficiency(
         scan.wavelengths, scan.total,
         color=theme.ink, ls="--", lw=1.0, alpha=0.7, label="Σ",
     )
+    transmitted = (
+        scan.transmission.total if scan.transmission is not None else 0.0
+    )
+    if scan.transmission is not None:
+        axes.plot(
+            scan.wavelengths, scan.transmission.total,
+            color=theme.ink, lw=1.0, ls=":", alpha=0.9, label="T",
+        )
     if scan.absorption is not None:
         # Under a finite-conductivity solve Σ alone is the reflected fraction
         # and sits below the unity line by exactly the absorbed one. Drawing
@@ -61,8 +69,9 @@ def draw_efficiency(
             color=theme.warn, lw=1.0, ls="-.", alpha=0.9, label="A",
         )
         axes.plot(
-            scan.wavelengths, scan.total + scan.absorption,
-            color=theme.ink, lw=1.0, ls="-", alpha=0.5, label="Σ + A",
+            scan.wavelengths, scan.total + transmitted + scan.absorption,
+            color=theme.ink, lw=1.0, ls="-", alpha=0.5,
+            label="Σ + T + A" if scan.transmission is not None else "Σ + A",
         )
     axes.axhline(1.0, color=theme.bad, lw=0.8, ls=":", alpha=0.8)
     axes.set_xlabel("wavelength (nm)")

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/gui/provenance.py

@@ -147,6 +147,16 @@ def provenance_lines(
         lines.append(Line("normalization: ", "dim"))
         lines.append(Line(f"{normalization} ({detail})\n", "dim"))
 
+    if scan.transmission is not None:
+        lines.append(Line("transmission: ", "dim"))
+        lines.append(
+            Line(
+                f"T ∈ [{scan.transmission.total.min():.4f}, "
+                f"{scan.transmission.total.max():.4f}]\n",
+                "dim",
+            )
+        )
+
     if scan.absorption is not None:
         # A physical result, not a problem: `dim`, never an alarm tag. It also
         # explains the deficit in Σ below, which would otherwise read as a
@@ -163,7 +173,9 @@ def provenance_lines(
     # `check_energy_balance` folds absorption into the total when a scan
     # carries one, so the conserved quantity is R + A there. Naming it Σ
     # anyway would collide with the Σ curve on the plot, which is R alone.
-    conserved = "Σ + A" if scan.absorption is not None else "Σ"
+    conserved = "Σ" + (" + T" if scan.transmission is not None else "") + (
+        " + A" if scan.absorption is not None else ""
+    )
     lines.append(Line("energy balance: ", "dim"))
     lines.append(
         Line(

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/gui/qt/main_window.py

@@ -26,7 +26,7 @@ from __future__ import annotations
 import threading
 
 from PySide6.QtCore import Qt, QThread, QTimer, Signal
-from PySide6.QtGui import QActionGroup, QKeySequence
+from PySide6.QtGui import QKeySequence
 from PySide6.QtWidgets import (
     QDockWidget,
     QMainWindow,
@@ -38,7 +38,6 @@ from PySide6.QtWidgets import (
 
 from .. import provenance
 from ..state import FormErrors, build, validate
-from ..theme import SYSTEM, THEMES
 from . import theming
 from .geometry_panel import GeometryPanel
 from .geometry_tab import GeometryTab
@@ -189,7 +188,7 @@ class MainWindow(QMainWindow):
         self.resizeDocks([dock], [300], Qt.Orientation.Horizontal)
 
     def _build_tabs(self) -> QWidget:
-        from ..docs import display_title
+        from ..docs import display_title, short_title
         from ...solvers import available_solvers
 
         self.tabs: dict[str, QWidget] = {}
@@ -220,7 +219,8 @@ class MainWindow(QMainWindow):
                 # has nothing to sweep and should not carry the button.
                 converge.connect(lambda _checked=False, n=name: self.solve(n, sweep=True))
             self.tabs[name] = tab
-            self._tab_widget.addTab(tab, display_title(name))
+            index = self._tab_widget.addTab(tab, short_title(name))
+            self._tab_widget.setTabToolTip(index, display_title(name))
 
         # Setup is leftmost so it is easy to find, but a solver tab -- not
         # the explanatory stub -- is what should be showing, and solving,
@@ -284,19 +284,11 @@ class MainWindow(QMainWindow):
         self._view_menu.addSeparator()
 
         # One exclusive group: System follows the OS, the rest are fixed.
-        self._theme_menu = self._view_menu.addMenu("&Theme")
-        self._theme_actions = QActionGroup(self)
-        self._theme_actions.setExclusive(True)
-        choices = [(SYSTEM, "System")] + [(k, t.label) for k, t in THEMES.items()]
-        for key, label in choices:
-            action = self._theme_menu.addAction(label)
-            action.setCheckable(True)
-            action.setData(key)
-            action.setChecked(key == self._themes.choice)
-            action.triggered.connect(lambda _checked=False, k=key: self.set_theme(k))
-            self._theme_actions.addAction(action)
-            if key == SYSTEM:
-                self._theme_menu.addSeparator()
+        # Shared with the AFM window, so both offer it and both stay checked
+        # in step whichever one the choice was made in.
+        self._theme_menu = theming.ThemeMenu(self)
+        self._view_menu.addMenu(self._theme_menu)
+        self._theme_actions = self._theme_menu._group
 
         menu = self._help_menu = self._menu_bar.addMenu("&Help")
         menu.addAction("About GratingLab", self.show_about)
@@ -320,8 +312,6 @@ class MainWindow(QMainWindow):
     def set_theme(self, choice: str) -> None:
         """Switch theme by key, or ``"system"``; the menu calls this."""
         self._themes.set_choice(choice)
-        for action in self._theme_actions.actions():
-            action.setChecked(action.data() == choice)
 
     def _start_worker(self) -> None:
         self._thread = QThread(self)

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/gui/qt/theming.py

@@ -22,14 +22,16 @@ import os
 from collections.abc import Callable
 
 from PySide6.QtCore import QObject, QSettings, Qt, Signal
-from PySide6.QtGui import QColor, QGuiApplication, QIcon, QPalette, QPixmap
-from PySide6.QtWidgets import QApplication
+from PySide6.QtGui import (QAction, QActionGroup, QColor, QGuiApplication,
+                           QIcon, QPalette, QPixmap)
+from PySide6.QtWidgets import QApplication, QMenu
 
 from ..theme import DARK, LIGHT, SYSTEM, THEMES, Theme, rc_params
 
 __all__ = [
     "QIcon",
     "SETTINGS_ENV",
+    "ThemeMenu",
     "ThemeManager",
     "current",
     "install",
@@ -187,6 +189,50 @@ def subscribe(callback: Callable[[Theme], None]) -> None:
         found.changed.connect(callback)
 
 
+class ThemeMenu(QMenu):
+    """The View > Theme submenu, one per window, all kept in step.
+
+    Every window that has a menu bar carries one, built here so that none can
+    be left without it: the AFM window had no theme choice at all while the
+    efficiency window did. Choosing in one window re-checks the others,
+    because each menu follows the manager's ``changed`` signal rather than
+    its own clicks.
+    """
+
+    def __init__(self, parent=None) -> None:
+        super().__init__("&Theme", parent)
+        self._group = QActionGroup(self)
+        self._group.setExclusive(True)
+        choices = [(SYSTEM, "System")] + [(k, t.label) for k, t in THEMES.items()]
+        for key, label in choices:
+            action = self.addAction(label)
+            action.setCheckable(True)
+            action.setData(key)
+            action.triggered.connect(self._chosen)
+            self._group.addAction(action)
+            if key == SYSTEM:
+                self.addSeparator()
+        found = manager()
+        if found is not None:
+            found.changed.connect(self._sync)
+        self._sync()
+
+    def actions_by_key(self) -> dict[str, QAction]:
+        return {a.data(): a for a in self._group.actions()}
+
+    def _chosen(self) -> None:
+        action = self.sender()
+        found = manager()
+        if found is not None and isinstance(action, QAction):
+            found.set_choice(action.data())
+
+    def _sync(self, _theme=None) -> None:
+        found = manager()
+        choice = found.choice if found is not None else SYSTEM
+        for key, action in self.actions_by_key().items():
+            action.setChecked(key == choice)
+
+
 def swatch(color: str, size: int = 12) -> QIcon:
     """A square of ``color``, for a list entry that names a plotted line."""
     pixmap = QPixmap(size, size)

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/metrology/gui/qt/boundary_view.py

@@ -27,6 +27,9 @@ from PySide6.QtWidgets import (
 from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
 
+from gratinglab.gui.qt import theming
+from gratinglab.gui.theme import style_figure
+
 from ...boundary import build_boundary_profile
 from ...core.tip import format_angles
 from ...config import RESULTS_DIR
@@ -79,6 +82,7 @@ class BoundaryView(QWidget):
         self.figure = Figure(figsize=(8, 6), tight_layout=True)
         self.canvas = FigureCanvas(self.figure)
         self._show_placeholder()
+        theming.subscribe(self._on_theme)
 
         root.addWidget(scroll)
         divider = QFrame()
@@ -291,10 +295,11 @@ class BoundaryView(QWidget):
             f"Max curvature   : {m['max_curvature']:.4f}{rotation}{tip}")
 
     def _show_placeholder(self, message="Load an AFM file in the Import tab"):
+        self._placeholder = message
         self.figure.clear()
         axes = self.figure.add_subplot(111)
         axes.text(0.5, 0.5, message, ha='center', va='center', fontsize=12,
-                  color='gray', transform=axes.transAxes)
+                  color=theming.current().muted, transform=axes.transAxes)
         axes.set_axis_off()
         self.canvas.draw()
 
@@ -310,19 +315,25 @@ class BoundaryView(QWidget):
         x_nm = p.x_avg_um * 1000
         avg_ax.plot(x_nm, p.y_avg_nm, color='crimson', linewidth=1.8,
                     label=f'Average of {p.n_used} grooves')
-        avg_ax.fill_between(x_nm, p.y_avg_nm - p.y_std_nm,
-                            p.y_avg_nm + p.y_std_nm,
-                            color='crimson', alpha=0.2, label='±1σ')
+        # The band was crimson at alpha 0.2 alone, which vanishes against a
+        # dark axes, and a narrow band hides behind the line. Edges show its
+        # width even then.
+        low, high = p.y_avg_nm - p.y_std_nm, p.y_avg_nm + p.y_std_nm
+        dark = theming.current().dark
+        avg_ax.fill_between(x_nm, low, high, color='crimson',
+                            alpha=0.35 if dark else 0.2, linewidth=0, label='±1σ')
+        for edge in (low, high):
+            avg_ax.plot(x_nm, edge, color='crimson', linewidth=0.6,
+                        alpha=0.8 if dark else 0.6)
         avg_ax.set_xlabel("Position (nm)", fontsize=10)
         avg_ax.set_ylabel("Height (nm)", fontsize=10)
-        avg_ax.set_title(
-            f"Averaged groove: {os.path.basename(self._filename)}", fontsize=10)
+        avg_ax.set_title("Averaged groove", fontsize=10)
         avg_ax.legend(fontsize=8)
         avg_ax.grid(True, alpha=0.3)
 
         # What lands in the file.
         norm_ax.plot(p.x_norm, p.y_norm, color='steelblue', linewidth=1.6)
-        norm_ax.axhline(0, color='k', linestyle='--', linewidth=0.5)
+        norm_ax.axhline(0, color=theming.current().ink, linestyle='--', linewidth=0.5)
         norm_ax.set_xlabel("Normalised position (0 to 1 = one period)", fontsize=10)
         norm_ax.set_ylabel("Height (fraction of period)", fontsize=10)
         norm_ax.set_title(
@@ -332,6 +343,19 @@ class BoundaryView(QWidget):
 
         self.canvas.draw()
 
+    def _on_theme(self, theme):
+        """Draw the figure again in the new theme.
+
+        Each draw clears the figure and builds fresh axes, which take their
+        colours from matplotlib's settings, so redrawing is the restyle. The
+        figure predates the change and needs its own background set first.
+        """
+        style_figure(self.figure, theme)
+        if self._profile is not None:
+            self._draw()
+        else:
+            self._show_placeholder(self._placeholder)
+
     def _set_actions_enabled(self, enabled: bool) -> None:
         """All four actions need only a profile, so they are enabled together."""
         self.export_btn.setEnabled(enabled)

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/metrology/gui/qt/canvas.py

@@ -6,7 +6,7 @@ nothing here is ever called from another thread.
 """
 from __future__ import annotations
 
-import os
+import functools
 
 import numpy as np
 
@@ -16,35 +16,66 @@ import matplotlib
 from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
 
+from gratinglab.gui.qt import theming
+from gratinglab.gui.theme import style_figure
+
 __all__ = ["PlotCanvas"]
 
 
+def _remembered(method):
+    """Record the call, so a theme change can draw the same plot again."""
+    @functools.wraps(method)
+    def wrapper(self, *args, **kwargs):
+        self._last = (method, args, kwargs)
+        return method(self, *args, **kwargs)
+    return wrapper
+
+
 class PlotCanvas(FigureCanvas):
     def __init__(self, parent=None):
         self.fig = Figure(figsize=(8, 5), tight_layout=True)
         super().__init__(self.fig)
         self.setParent(parent)
+        self._last = None
+        theming.subscribe(self._on_theme)
         self.show_placeholder("Load an AFM file to see the raw profile")
 
+    def _on_theme(self, theme):
+        """Redraw the last plot in the new theme.
+
+        Every plot clears the figure and builds fresh axes, which take their
+        colours from matplotlib's settings at that moment, so drawing it again
+        is the whole restyle. The figure itself predates the change and needs
+        its own background set first.
+        """
+        style_figure(self.fig, theme)
+        if self._last is not None:
+            method, args, kwargs = self._last
+            method(self, *args, **kwargs)
+        else:
+            self.draw_idle()
+
+    @_remembered
     def show_placeholder(self, message):
         self.fig.clear()
         ax = self.fig.add_subplot(111)
         ax.text(0.5, 0.5, message, ha='center', va='center', fontsize=12,
-                color='gray', transform=ax.transAxes)
+                color=theming.current().muted, transform=ax.transAxes)
         ax.set_axis_off()
         self.draw()
 
+    @_remembered
     def plot_raw(self, disp_um, profile_nm, filename, scan_size_um):
         self.fig.clear()
         ax = self.fig.add_subplot(111)
         ax.plot(disp_um, profile_nm, color='steelblue', linewidth=1.0)
         ax.set_xlabel("Position (µm)", fontsize=11)
         ax.set_ylabel("Height (nm)", fontsize=11)
-        ax.set_title(f"Raw AFM Profile: {os.path.basename(filename)}\n"
-                     f"Scan width: {scan_size_um:.3f} µm", fontsize=11)
+        ax.set_title(f"Raw profile, scan width {scan_size_um:.3f} µm", fontsize=11)
         ax.grid(True, alpha=0.3)
         self.draw()
 
+    @_remembered
     def plot_2d(self, data, scan_size_um, filename):
         self.fig.clear()
         ax = self.fig.add_subplot(111)
@@ -53,9 +84,10 @@ class PlotCanvas(FigureCanvas):
         self.fig.colorbar(im, ax=ax, label='Height (nm)')
         ax.set_xlabel("X (µm)", fontsize=11)
         ax.set_ylabel("Scan line", fontsize=11)
-        ax.set_title(f"2D AFM Topography: {os.path.basename(filename)}", fontsize=11)
+        ax.set_title("Topography", fontsize=11)
         self.draw()
 
+    @_remembered
     def plot_row_groups(self, disp_um, profiles_nm, group_info, filename, scan_size_um):
         self.fig.clear()
         ax = self.fig.add_subplot(111)
@@ -66,11 +98,11 @@ class PlotCanvas(FigureCanvas):
             ax.plot(disp_um, profile, color=cmap(i / max(n_groups - 1, 1)),
                     linewidth=0.8, alpha=0.6)
 
-        ax.plot(disp_um, np.mean(np.array(profiles_nm), axis=0), color='black',
+        ax.plot(disp_um, np.mean(np.array(profiles_nm), axis=0), color=theming.current().ink,
                 linewidth=1.8, label=f'Mean (n={n_groups})', zorder=5)
         ax.set_xlabel("Position (µm)", fontsize=11)
         ax.set_ylabel("Height (nm)", fontsize=11)
-        ax.set_title(f"Row-Group Profiles: {os.path.basename(filename)}\n"
+        ax.set_title("Row-group profiles\n"
                      f"{n_groups} groups × {group_info['rows_per_group']} rows each  |  "
                      f"Scan width: {scan_size_um:.3f} µm", fontsize=10)
         ax.legend(fontsize=10)
@@ -84,6 +116,7 @@ class PlotCanvas(FigureCanvas):
             "Image row (top → bottom)", fontsize=9)
         self.draw()
 
+    @_remembered
     def plot_groove_detection(self, result, filename, settings):
         """Flattened profile with the grooves the analysis used"""
         self.fig.clear()
@@ -91,7 +124,7 @@ class PlotCanvas(FigureCanvas):
         x, y = result['raw_x'], result['flat_y']
         centers = result['groove_centers']
 
-        ax.plot(x, y, 'k-', linewidth=0.7, label='Flattened profile')
+        ax.plot(x, y, '-', color=theming.current().ink, linewidth=0.7, label='Flattened profile')
         ax.plot(x[centers], y[centers], 'ro', markersize=9,
                 label=f'Detected grooves (N={len(centers)})')
 
@@ -107,11 +140,12 @@ class PlotCanvas(FigureCanvas):
 
         ax.set_xlabel("Position (µm)", fontsize=11)
         ax.set_ylabel("Height (nm)", fontsize=11)
-        ax.set_title(f"Groove Detection: {os.path.basename(filename)}", fontsize=11)
+        ax.set_title("Groove detection", fontsize=11)
         ax.legend(fontsize=9)
         ax.grid(True, alpha=0.3)
         self.draw()
 
+    @_remembered
     def plot_blaze_angles(self, result, filename):
         """Angle distribution, fit quality, and angle against facet width"""
         self.fig.clear()
@@ -121,7 +155,7 @@ class PlotCanvas(FigureCanvas):
         quality = result['quality']
         mean, sem = result['mean_angle'], result.get('sem', 0.0)
 
-        ax1.hist(angles, bins=20, edgecolor='black', alpha=0.75, color='steelblue')
+        ax1.hist(angles, bins=20, edgecolor=theming.current().ink, alpha=0.75, color='steelblue')
         ax1.axvline(mean, color='r', linestyle='--', linewidth=2,
                     label=f'Mean {mean:.2f}°')
         ax1.set_xlabel("Blaze angle (°)", fontsize=10)
@@ -132,7 +166,7 @@ class PlotCanvas(FigureCanvas):
         ax1.grid(True, alpha=0.3)
 
         r2 = np.array([q.get('blaze_r2', np.nan) for q in quality])
-        ax2.hist(r2, bins=20, edgecolor='black', alpha=0.75, color='seagreen')
+        ax2.hist(r2, bins=20, edgecolor=theming.current().ink, alpha=0.75, color='seagreen')
         ax2.set_xlabel("Fit R²", fontsize=10)
         ax2.set_ylabel("Count", fontsize=10)
         ax2.set_title(f"Fit quality\nworst R² = {np.nanmin(r2):.4f}", fontsize=10)
@@ -146,6 +180,5 @@ class PlotCanvas(FigureCanvas):
                       fontsize=10)
         ax3.grid(True, alpha=0.3)
 
-        self.fig.suptitle(f"{os.path.basename(filename)}: "
-                          f"{mean:.2f}° ± {sem:.3f}° (SEM)", fontsize=11)
+        self.fig.suptitle(f"Blaze angle {mean:.2f}° ± {sem:.3f}° (SEM)", fontsize=11)
         self.draw()

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/metrology/gui/qt/efficiency_dialog.py

@@ -35,6 +35,9 @@ from PySide6.QtWidgets import (
 from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
 
+from gratinglab.gui.qt import theming
+from gratinglab.gui.theme import style_figure
+
 from gratinglab import materials
 from gratinglab.illumination import Illumination
 from gratinglab.resolution import describe
@@ -89,6 +92,8 @@ class EfficiencyDialog(QDialog):
         self.figure = Figure(figsize=(6, 4.6))
         self.canvas = FigureCanvas(self.figure)
         root.addWidget(self.canvas, stretch=1)
+        self._placeholder = None
+        theming.subscribe(self._on_theme)
 
     def _build_geometry_group(self):
         group = QGroupBox("Grating")
@@ -237,14 +242,31 @@ class EfficiencyDialog(QDialog):
     # ── Draw ─────────────────────────────────────────────────────────────────
 
     def _show_placeholder(self, message):
+        self._placeholder = message
         self.figure.clear()
         axes = self.figure.add_subplot(111)
         axes.text(0.5, 0.5, message, ha='center', va='center', fontsize=11,
-                  color='gray', transform=axes.transAxes, wrap=True)
+                  color=theming.current().muted, transform=axes.transAxes, wrap=True)
         axes.set_axis_off()
         self.canvas.draw()
 
+    def _on_theme(self, theme):
+        """Draw the figure again in the new theme.
+
+        Each draw clears the figure and builds fresh axes, which take their
+        colours from matplotlib's settings, so redrawing is the restyle. The
+        figure predates the change and needs its own background set first.
+        """
+        style_figure(self.figure, theme)
+        if self._placeholder is None and getattr(self, '_scan', None) is not None:
+            self._draw()
+        elif self._placeholder is not None:
+            self._show_placeholder(self._placeholder)
+        else:
+            self.canvas.draw_idle()
+
     def _draw(self):
+        self._placeholder = None
         scan = self._scan
         self.figure.clear()
         axes = self.figure.add_subplot(111)
@@ -258,7 +280,8 @@ class EfficiencyDialog(QDialog):
 
         for m, efficiency in carried[:8]:
             axes.plot(scan.wavelengths, efficiency, lw=1.3, label=f"m = {m}")
-        axes.plot(scan.wavelengths, scan.total, 'k--', lw=1.0, alpha=0.6,
+        axes.plot(scan.wavelengths, scan.total, '--', color=theming.current().ink,
+                  lw=1.0, alpha=0.6,
                   label="total")
 
         axes.set_xlabel("Wavelength (nm)")
@@ -270,7 +293,7 @@ class EfficiencyDialog(QDialog):
             axes.legend(fontsize=8, ncol=2)
         else:
             axes.text(0.5, 0.5, "No order carries more than 0.5%",
-                      ha='center', va='center', color='gray',
+                      ha='center', va='center', color=theming.current().muted,
                       transform=axes.transAxes)
         self.figure.tight_layout()
         self.canvas.draw()

{gratinglab-0.1.13 → gratinglab-0.2.0}/src/gratinglab/metrology/gui/qt/import_view.py

@@ -27,6 +27,9 @@ from PySide6.QtWidgets import (
 )
 from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
 from matplotlib.figure import Figure
+
+from gratinglab.gui.qt import theming
+from gratinglab.gui.theme import style_figure
 from matplotlib.patches import Rectangle
 from matplotlib.widgets import RectangleSelector
 
@@ -112,6 +115,7 @@ class ImportView(QWidget):
         self.figure = Figure(figsize=(8, 6), tight_layout=True)
         self.canvas = FigureCanvas(self.figure)
         self._show_placeholder()
+        theming.subscribe(self._on_theme)
 
         root.addWidget(scroll)
         divider = QFrame()
@@ -528,10 +532,20 @@ class ImportView(QWidget):
         self.figure.clear()
         axes = self.figure.add_subplot(111)
         axes.text(0.5, 0.5, message, ha='center', va='center', fontsize=12,
-                  color='gray', transform=axes.transAxes)
+                  color=theming.current().muted, transform=axes.transAxes)
         axes.set_axis_off()
         self.canvas.draw()
 
+    def _on_theme(self, theme):
+        """Draw the figure again in the new theme.
+
+        Each draw clears the figure and builds fresh axes, which take their
+        colours from matplotlib's settings, so redrawing is the restyle. The
+        figure predates the change and needs its own background set first.
+        """
+        style_figure(self.figure, theme)
+        self._redraw()
+
     def _redraw(self):
         if self._flat is None:
             self._show_placeholder()
@@ -561,8 +575,7 @@ class ImportView(QWidget):
             props=dict(facecolor='crimson', edgecolor='crimson', alpha=0.25,
                        fill=True))
         image_ax.set_title(
-            f"{os.path.basename(self._filename)}: image flattening: "
-            f"{self.image_method_combo.currentText()}", fontsize=10)
+            f"Image flattening: {self.image_method_combo.currentText()}", fontsize=10)
 
         try:
             x_um, profile_nm = raw_data(self._flat, self._scan_size)