| Open-source platform for scientific signal and image processing, built on SigimaX. |
+| 
| European non-profit supporting open-source and internet projects. SigimaX has received funding from NLnet for its development, through the DataLab project. |
+
+---
+
+## ✨ Highlights
+
+- **Extensible configuration system** — `OptionField`-based settings with `get()`/`set()`/`context()` API and JSON persistence
+- **Rich widget catalog** — 15 ready-to-use scientific widgets: curve fitting, peak detection, signal baseline, HDF5 browser, log viewer, wizard dialogs, and more
+- **Complete HDF5 infrastructure** — built-in file browser, importer, and workspace save/load
+- **Embedded Python console** — `DockableConsole` with error-to-console routing and configurable namespace
+- **Production-grade status bar** — memory usage monitoring with alarm threshold, console toggle
+- **PlotPy integration** — `DockablePlotWidget` and adapters for signal/image/ROI objects
+- **Derivation pattern** — subclass `SigimaXOptions` + `SGMXMainWindow` + call `run()` to build a full app in minutes
+
+---
+
+## 💡 Use Cases
+
+SigimaX is meant to be:
+
+- A **framework for building scientific desktop apps** with Qt
+- A **reusable main window** with menus, toolbars, docks, and HDF5 workspace management
+- A **widget library** for signal/image analysis dialogs (fitting, peak detection, baseline, cursor, delta-X)
+- A **configuration backbone** for apps that need persistent user preferences
+
+---
+
+## 📖 Design Philosophy
+
+SigimaX separates the **generic application skeleton** from **domain-specific logic**. Derived applications follow a three-step pattern:
+
+1. **Subclass `SigimaXOptions`** to add application-specific configuration fields
+2. **Subclass `SGMXMainWindow`** to customize menus, toolbars, and dock widgets
+3. **Call `sigimax.app.run()`** to launch the application with splash screen support
+
+This architecture is proven in production: [DataLab](https://datalab-platform.com/) is built entirely on this derivation pattern.
+
+### Position in the Stack
+
+```text
+End-user apps (DataLab, custom scientific apps)
+ ↓ subclass / configure
+ SigimaX ← THIS PROJECT (framework layer)
+ ↓ depends on
+ Sigima (computation) + PlotPy + guidata + PythonQwt
+ ↓
+ NumPy / SciPy / Qt
+```
+
+---
+
+## 🚀 Quick Start
+
+```python
+from sigimax.app import run
+from sigimax.config import CONF as Conf, SigimaXOptions, EnumOptionField, _
+from sigimax.mainwindow import SGMXMainWindow
+from sigimax.widgets.plotdock import DockablePlotWidget
+from sigimax.config import TypedOptionField
+from plotpy.constants import PlotType
+
+# A missing option may be initialized on first read:
+color_mode = Conf.color_mode.get("auto")
+
+
+# 1. Define custom options
+class MyAppOptions(SigimaXOptions):
+ def __init__(self):
+ super().__init__()
+ self.app_name.set("MyApp")
+ self.greeting = TypedOptionField(
+ self, "greeting", default="Hello!",
+ expected_type=str, description="Startup message",
+ )
+
+
+# 2. Customize the main window
+class MyAppMainWindow(SGMXMainWindow):
+ def __init__(self, console=None, hide_on_close=False):
+ Conf.app_name.set("MyApp")
+ super().__init__(console=console, hide_on_close=hide_on_close)
+ # Add a dockable curve plot
+ self.curve_dock = DockablePlotWidget(self, PlotType.CURVE)
+ dock, loc = self.curve_dock.create_dockwidget(_("Curve Viewer"))
+ self.addDockWidget(loc, dock)
+
+
+# 3. Launch
+run(window_class=MyAppMainWindow)
+```
+
+---
+
+## ⚙️ Architecture
+
+```text
+sigimax/
+├── app.py # Application launcher (create / run)
+├── config.py # Configuration system (SigimaXOptions, CONF singleton)
+├── env.py # Runtime environment (verbosity, unattended mode)
+├── mainwindow.py # SGMXMainWindow (generic main window)
+├── widgets/ # Reusable Qt widgets
+│ ├── plotdock.py # DockablePlotWidget
+│ ├── splashscreen.py # Configurable splash screen
+│ ├── h5browser.py # HDF5 file browser
+│ ├── logviewer.py # Log viewer dialog
+│ ├── status.py # Status bar widgets (memory, console)
+│ ├── fitdialog.py # Curve fitting dialogs
+│ ├── signalpeak.py # Signal peak detection
+│ ├── signalbaseline.py # Signal baseline selection
+│ ├── signalcursor.py # Signal cursor selection
+│ ├── signaldeltax.py # Signal delta-X measurement
+│ ├── wizard.py # Multi-page wizard dialog
+│ └── ... # File dialogs, warning/error boxes
+├── h5/ # HDF5 I/O (read/write/import)
+├── adapters_plotpy/ # Converters between PlotPy/guidata and Sigima objects
+├── utils/ # Qt helpers, config dir resolution
+├── data/ # Icons, resources
+└── locale/ # Translations (EN, FR)
+```
+
+---
+
+## 📦 Installation
+
+```bash
+pip install sigimax
+```
+
+Or in a development environment:
+
+```bash
+git clone https://github.com/DataLab-Platform/SigimaX.git
+cd SigimaX
+pip install -e .
+```
+
+---
+
+## 📚 Documentation
+
+📖 Full documentation (in progress) is available at:
+👉 {dev_by}")
+ if cprght:
+ about_parts.append(f"
Copyright © {cprght}")
+
+ # -- Application links
+ links = []
+ if app_homeurl:
+ links.append(f'{_("Home page")}')
+ if app_docurl:
+ links.append(f'{_("Documentation")}')
+ if app_supporturl:
+ links.append(f'{_("Support")}')
+ if links:
+ about_parts.append("
" + " | ".join(links)) + + # -- SigimaX credits + sgmx_dev_by = _("Developed and maintained by DataLab open-source project team") + sgmx_cprght = "2023 DataLab Platform Developers" + about_parts.extend( + [ + f'
Based on {MOD_TITLE} v{__version__}',
+ f"
{MOD_DESC}",
+ f"
{sgmx_dev_by}",
+ f"
Copyright © {sgmx_cprght}",
+ ]
+ )
+
+ QW.QMessageBox.about(
+ self,
+ _("About") + " " + app_name,
+ "".join(about_parts),
+ )
+
+ def _update_color_mode(self, startup: bool = False) -> None:
+ """Update color mode
+
+ Args:
+ startup: True if method is called during application startup (in that case,
+ color theme is applied only if mode != "auto")
+ """
+ mode = get_conf().color_mode.get()
+ if startup and mode == "auto":
+ guidata_qth.win32_fix_title_bar_background(self)
+ return
+
+ # Prevent Qt from refreshing the window when changing the color mode:
+ self.setUpdatesEnabled(False)
+
+ plotpy_config.set_plotpy_color_mode(mode)
+ get_conf().apply_plotpy_defaults()
+
+ if self.console is not None:
+ self.console.update_color_mode()
+
+ for dock in self.docks.values():
+ widget = dock.widget()
+ if isinstance(widget, DockablePlotWidget):
+ widget.update_color_mode()
+
+ self._update_extra_color_mode()
+
+ # Allow Qt to refresh the window:
+ self.setUpdatesEnabled(True)
+
+ def _update_extra_color_mode(self) -> None:
+ """Update the color mode of application-specific widgets.
+
+ Called with window updates disabled, after the console and the plot docks
+ have been updated. The base implementation is a no-op.
+ """
+
+ def _show_logviewer(self) -> None:
+ """Show error logs"""
+ logviewer.exec_sigimax_logviewer_dialog(self)
+
+ @staticmethod
+ def test_segfault_error() -> None:
+ """Generate errors (both fault and traceback)"""
+ import ctypes # pylint: disable=import-outside-toplevel
+
+ ctypes.string_at(0)
+ raise RuntimeError("!!! Testing RuntimeError !!!")
+
+ def show(self) -> None:
+ """Reimplement QMainWindow method"""
+ super().show()
+ if self.__old_size is not None:
+ self.resize(self.__old_size)
+
+ # ------Close window
+ def _get_save_before_quit_message(self) -> str:
+ """Return the confirmation message shown before closing modified data."""
+ return _(
+ "Do you want to save all signals and images "
+ "to an HDF5 file before quitting the application?"
+ )
+
+ def _close_managed_widgets(self) -> None:
+ """Close widgets owned by the generic application shell."""
+ if self.console is not None:
+ try:
+ self.console.close()
+ except RuntimeError:
+ # The Qt object may already be deleted when restarting a window
+ # in the same test process.
+ pass
+
+ def _cleanup_before_reset(self) -> None:
+ """Clean up derived services before resetting application data."""
+
+ def _cleanup_after_state_save(self) -> None:
+ """Finalize derived shutdown after saving the window state."""
+
+ def close_properly(self) -> bool:
+ """Close properly
+
+ Returns:
+ True if closed properly, False otherwise
+ """
+ if not execenv.unattended and self.is_modified():
+ answer = QW.QMessageBox.warning(
+ self,
+ _("Quit"),
+ self._get_save_before_quit_message(),
+ QW.QMessageBox.Yes | QW.QMessageBox.No | QW.QMessageBox.Cancel,
+ )
+ if answer == QW.QMessageBox.Yes:
+ self.save_to_h5_file()
+ if self.is_modified():
+ return False
+ elif answer == QW.QMessageBox.Cancel:
+ return False
+ self.hide() # Avoid showing individual widgets closing one after the other
+ self._close_managed_widgets()
+ self._cleanup_before_reset()
+ self.reset_all()
+ self._save_pos_size_and_state()
+ self._cleanup_after_state_save()
+
+ execenv.log(self, "closed properly")
+ return True
+
+ def closeEvent(self, event: QG.QCloseEvent) -> None:
+ """Reimplement QMainWindow method"""
+ if self.hide_on_close:
+ self.__old_size = self.size()
+ self.hide()
+ else:
+ if self.close_properly():
+ self.SIG_CLOSING.emit()
+ event.accept()
+ else:
+ event.ignore()
diff --git a/sigimax/tests/__init__.py b/sigimax/tests/__init__.py
new file mode 100644
index 0000000..be7f3df
--- /dev/null
+++ b/sigimax/tests/__init__.py
@@ -0,0 +1,92 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Tests (:mod:`sigimax.tests`)
+------------------------
+
+The SigimaX test suite is based on the `pytest
{str(msg)}"
+ )
+ finally:
+ pass
+
+
+# Used in SigimaX: mainwindow.py (screenshot capture)
+def grab_save_window(
+ widget: QW.QWidget, name: str | None = None, add_timestamp: bool = True
+) -> None: # pragma: no cover
+ """Grab window screenshot and save it.
+
+ Delegates to guidata's ``grab_save_window``, using
+ ``execenv.screenshot_path`` as the save directory (falls back to the
+ current working directory if not set).
+
+ The screenshot path can be configured by derived apps::
+
+ # Programmatically (e.g. in tests/__init__.py or app startup)
+ execenv.screenshot_path = "/path/to/screenshots"
+
+ # Or via environment variable
+ os.environ["GUIDATA_SCREENSHOT_PATH"] = "/path/to/screenshots"
+
+ # Or via CLI argument (parsed by SGMXExecEnv)
+ # --screenshot_path /path/to/screenshots
+
+ Args:
+ widget: Widget to grab
+ name: Screenshot name (if None, uses widget.objectName())
+ add_timestamp: Whether to add a timestamp to the screenshot name
+ """
+ guidata_grab_save_window(
+ widget=widget,
+ name=name,
+ save_dir=execenv.screenshot_path or None,
+ add_timestamp=add_timestamp,
+ )
+
+
+# Used in SigimaX: mainwindow.py (file dialogs)
+@contextmanager
+def save_restore_stds() -> Generator[None, None, None]:
+ """Save/restore standard I/O before/after doing some things
+ (e.g. calling Qt open/save dialogs)"""
+ saved_in, saved_out, saved_err = sys.stdin, sys.stdout, sys.stderr
+ sys.stdout = None
+ try:
+ yield
+ finally:
+ sys.stdin, sys.stdout, sys.stderr = saved_in, saved_out, saved_err
+
+
+# Used in SigimaX: widgets/h5browser.py, widgets/signalcursor.py
+@contextmanager
+def block_signals(
+ widget: QW.QWidget, enable: bool = True, children: bool = False
+) -> Generator[None, None, None]:
+ """Eventually block/unblock widget Qt signals before/after doing some things
+
+ Args:
+ widget: Widget to block/unblock signals
+ enable: Whether to block/unblock signals (default: True). This is useful
+ to avoid blocking signals when not needed without having to handle it by
+ adding an `if` statement which would require to duplicate the code that is
+ inside the `with` statement in the `else` branch.
+ children: Whether to block/unblock signals for child widgets (default: False).
+
+ Returns:
+ Context manager
+ """
+ if enable:
+ widget.blockSignals(True)
+ if children:
+ for child in widget.findChildren(QW.QWidget):
+ child.blockSignals(True)
+ try:
+ yield
+ finally:
+ if enable:
+ widget.blockSignals(False)
+ if children:
+ for child in widget.findChildren(QW.QWidget):
+ child.blockSignals(False)
+
+
+# Used in SigimaX: mainwindow.py (window management)
+def bring_to_front(window: QW.QWidget) -> None:
+ """Bring window to front
+
+ Args:
+ window: Window to bring to front
+ """
+ # Show window on top of others
+ eflags = window.windowFlags()
+ window.setWindowFlags(eflags | QC.Qt.WindowStaysOnTopHint)
+ window.show()
+ window.setWindowFlags(eflags)
+ window.show()
+ # If window is minimized, restore it
+ if window.isMinimized():
+ window.showNormal()
+
+
+# Used in SigimaX: mainwindow.py (file/view menus)
+def configure_menu_about_to_show(menu: QW.QMenu, slot: Callable) -> None:
+ """Configure menu about to show.
+ This method is only used to connect the "aboutToShow" signal of menus,
+ and more importantly to fix Issue #15 (Part 2) which is the fact that
+ dynamic menus are not supported on MacOS unless an action is added to
+ the menu before it is displayed.
+
+ Args:
+ menu: menu
+ slot: slot
+ """
+ # On MacOS, add an empty action to the menu before connecting the
+ # "aboutToShow" signal to the slot. This is required to fix Issue #15 (Part 2)
+ if sys.platform == "darwin":
+ menu.addAction(QW.QAction(menu))
+ menu.aboutToShow.connect(slot)
+
+
+# Used in SigimaX: widgets/signalpeak, signaldeltax, signalcursor,
+# signalbaseline, imagebackground
+def resize_widget_to_parent(
+ widget: QW.QWidget,
+ parent: QW.QWidget | None = None,
+ ratio: float = 0.95,
+ aspect_ratio: float = 1.0,
+ min_size: int = 500,
+) -> None:
+ """Resize widget based on parent widget's dimensions
+
+ Args:
+ widget: Widget to resize
+ parent: Parent widget (if None, uses widget.parentWidget())
+ ratio: Ratio of parent size to use (0.0 to 1.0, default: 0.95 for 95%).
+ This represents the percentage of the maximum dimension with respect
+ to the widget.
+ aspect_ratio: Width/height ratio (1.0 for square, >1.0 for landscape,
+ <1.0 for portrait, default: 1.0)
+ min_size: Minimum size in pixels (default: 500)
+ """
+ if parent is None:
+ parent = widget.parentWidget()
+
+ if parent is not None:
+ parent_size = parent.size()
+ parent_width = parent_size.width()
+ parent_height = parent_size.height()
+
+ # Calculate maximum available dimensions
+ max_width = parent_width * ratio
+ max_height = parent_height * ratio
+
+ # Determine which dimension is limiting based on aspect ratio
+ # For aspect_ratio = w/h, we have: w = aspect_ratio * h
+ # Check which constraint is more restrictive
+ width_from_height = max_height * aspect_ratio
+ height_from_width = max_width / aspect_ratio
+
+ if width_from_height <= max_width:
+ # Height is the limiting factor
+ height = int(max_height)
+ width = int(width_from_height)
+ else:
+ # Width is the limiting factor
+ width = int(max_width)
+ height = int(height_from_width)
+
+ # Ensure minimum size while preserving aspect ratio
+ if width < min_size or height < min_size:
+ if aspect_ratio >= 1.0:
+ # Landscape or square: scale up from minimum width
+ width = max(width, min_size)
+ height = max(height, int(min_size / aspect_ratio))
+ else:
+ # Portrait: scale up from minimum height
+ height = max(height, min_size)
+ width = max(width, int(min_size * aspect_ratio))
+
+ # Final check: ensure we don't exceed parent dimensions
+ width = min(width, parent_width)
+ height = min(height, parent_height)
+
+ widget.resize(width, height)
+ else:
+ # Fallback: use square with min_size if no parent
+ widget.resize(min_size, min_size)
+
+
+# Used in SigimaX: mainwindow.py (tab widget corner menu)
+def add_corner_menu(
+ tabwidget: QW.QTabWidget, corner: QC.Qt.Corner | None = None
+) -> QW.QMenu:
+ """Add menu as corner widget to tab widget
+
+ Args:
+ tabwidget: Tab widget
+ corner: Corner
+
+ Returns:
+ Menu
+ """
+ if corner is None:
+ corner = QC.Qt.TopRightCorner
+ menu = QW.QMenu(tabwidget)
+ btn = QW.QToolButton(tabwidget)
+ btn.setMenu(menu)
+ btn.setPopupMode(QW.QToolButton.InstantPopup)
+ btn.setIcon(get_icon("menu.svg"))
+ btn.setToolTip(_("Open tab menu"))
+ tabwidget.setCornerWidget(btn, corner)
+ return menu
diff --git a/sigimax/widgets/__init__.py b/sigimax/widgets/__init__.py
new file mode 100644
index 0000000..ed94117
--- /dev/null
+++ b/sigimax/widgets/__init__.py
@@ -0,0 +1,72 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+SigimaX widgets
+===============
+
+Reusable Qt widgets for SigimaX-derived applications.
+
+Convenience imports
+-------------------
+
+The most commonly used widgets are re-exported here for easy access::
+
+ from sigimax.widgets import H5Browser, Wizard, LogViewerWindow
+
+Specialized scientific dialogs (fit, peak detection, baseline, etc.) remain
+accessible via their submodule::
+
+ from sigimax.widgets.fitdialog import gaussian_fit
+ from sigimax.widgets.signalpeak import SignalPeakDetectionDialog
+
+Submodules
+----------
+
+.. autosummary::
+
+ plotdock
+ filedialog
+ fileviewer
+ fitdialog
+ h5browser
+ imagebackground
+ logviewer
+ signalbaseline
+ signalcursor
+ signaldeltax
+ signalpeak
+ splashscreen
+ status
+ warningerror
+ wizard
+"""
+
+from sigimax.widgets.h5browser import H5Browser, H5BrowserDialog
+from sigimax.widgets.logviewer import LogViewerWindow
+from sigimax.widgets.plotdock import (
+ CurveStatsToolFunctions,
+ DockablePlotWidget,
+ SigimaXPlotWidget,
+)
+from sigimax.widgets.splashscreen import SigimaXSplashScreen, SplashScreenConfig
+from sigimax.widgets.status import BaseStatus, ConsoleStatus, MemoryStatus
+from sigimax.widgets.warningerror import WarningErrorMessageBox, show_warning_error
+from sigimax.widgets.wizard import Wizard, WizardPage
+
+__all__ = [
+ "BaseStatus",
+ "ConsoleStatus",
+ "CurveStatsToolFunctions",
+ "DockablePlotWidget",
+ "H5Browser",
+ "H5BrowserDialog",
+ "LogViewerWindow",
+ "MemoryStatus",
+ "SigimaXPlotWidget",
+ "SigimaXSplashScreen",
+ "SplashScreenConfig",
+ "WarningErrorMessageBox",
+ "Wizard",
+ "WizardPage",
+ "show_warning_error",
+]
diff --git a/sigimax/widgets/filedialog.py b/sigimax/widgets/filedialog.py
new file mode 100644
index 0000000..9789d53
--- /dev/null
+++ b/sigimax/widgets/filedialog.py
@@ -0,0 +1,96 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Module providing a file dialog widget based on Qt's QFileDialog.getOpenFileNames
+but supporting multiple file preselection (Qt original dialog only supports single file
+selection).
+
+.. autofunction:: get_open_file_names
+"""
+
+from __future__ import annotations
+
+import os
+import os.path as osp
+
+from guidata.qthelpers import qt_app_context
+from qtpy.QtCore import QItemSelectionModel
+from qtpy.QtWidgets import QAbstractItemView, QFileDialog, QListView, QWidget
+
+__all__ = [
+ "get_open_file_names",
+]
+
+
+def get_open_file_names(
+ parent: QWidget | None = None,
+ caption: str = "",
+ basedir: str | list[str] = "",
+ filters: str = "",
+ selectedfilter: str = "",
+ options: QFileDialog.Options = None,
+) -> tuple[list[str], str]:
+ """Wrapper around QtGui.QFileDialog.getOpenFileNames static method
+ Returns a tuple (filenames, selectedfilter) -- when dialog box is canceled,
+ returns a tuple (empty list, empty string)
+
+ Args:
+ parent: Parent widget for the dialog.
+ caption: Dialog title.
+ basedir: Initial directory to open the dialog in, or preselected files
+ (single string or list of strings).
+ filters: File filters for the dialog.
+ selectedfilter: Default filter to be selected.
+ options: Additional options for the dialog.
+
+ Returns:
+ A tuple containing a list of selected filenames and the selected filter.
+ """
+ if isinstance(basedir, str):
+ if osp.isfile(basedir):
+ sel_files = [basedir]
+ basedir = osp.dirname(basedir)
+ else:
+ sel_files = []
+ else:
+ assert isinstance(basedir, list)
+ sel_files = basedir
+ basedir = osp.dirname(sel_files[0]) if sel_files else ""
+ dlg = QFileDialog(
+ parent, caption, basedir, filters, options=QFileDialog.DontUseNativeDialog
+ )
+ if options is not None:
+ dlg.setOptions(options | QFileDialog.DontUseNativeDialog)
+ file_view = dlg.findChild(QListView, "listView")
+ sel_model = file_view.selectionModel()
+ for fname in sel_files:
+ idx = sel_model.model().index(fname)
+ sel_model.select(idx, QItemSelectionModel.Select | QItemSelectionModel.Rows)
+ file_view.setSelectionMode(QAbstractItemView.ExtendedSelection)
+ file_view.setSelectionBehavior(QAbstractItemView.SelectRows)
+ if dlg.exec():
+ filenames = dlg.selectedFiles()
+ selectedfilter = dlg.selectedNameFilter()
+ else:
+ filenames = []
+ selectedfilter = ""
+ return filenames, selectedfilter
+
+
+def test_get_open_file_names():
+ """Test get_open_file_names function"""
+ widgets_path = osp.dirname(__file__)
+ sel_files = [
+ osp.join(widgets_path, fname) for fname in os.listdir(widgets_path)[:2]
+ ]
+ with qt_app_context():
+ filenames, selectedfilter = get_open_file_names(
+ filters="Python files (*.py);;All files (*)",
+ caption="Select Python files",
+ basedir=sel_files,
+ )
+ print(filenames, selectedfilter)
+
+
+if __name__ == "__main__":
+ test_get_open_file_names()
diff --git a/sigimax/widgets/fileviewer.py b/sigimax/widgets/fileviewer.py
new file mode 100644
index 0000000..114de18
--- /dev/null
+++ b/sigimax/widgets/fileviewer.py
@@ -0,0 +1,93 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Module providing a file viewer widget
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+
+from guidata.configtools import get_icon
+from guidata.widgets.codeeditor import CodeEditor
+from qtpy import QtWidgets as QW
+
+from sigimax.config import _, get_conf
+
+__all__ = [
+ "FileViewerWidget",
+ "get_title_contents",
+ "read_text_file",
+]
+
+
+def read_text_file(path: str) -> str:
+ """Read text file using multiple encodings
+
+ Args:
+ path (str): path to file
+
+ Raises:
+ UnicodeDecodeError: if unable to read file using any of the encodings
+
+ Returns:
+ str: file contents
+ """
+ encodings = ["utf-8", "latin1", "cp1252", "utf-16", "utf-32", "ascii"]
+ for encoding in encodings:
+ try:
+ with open(path, "r", encoding=encoding) as fdesc:
+ return fdesc.read()
+ except UnicodeDecodeError:
+ pass
+ raise UnicodeDecodeError(
+ f"Unable to read file using the following encodings: {encodings}"
+ )
+
+
+def get_title_contents(path: str) -> tuple[str, str]:
+ """Get title and contents for log filename
+
+ Args:
+ path (str): path to file
+
+ Returns:
+ tuple[str, str]: title and contents
+ """
+ contents = read_text_file(path)
+ pathobj = Path(path)
+ uri_path = pathobj.absolute().as_uri()
+ prefix = _("Contents of file")
+ text = f'{prefix} {path}:'
+ return text, contents
+
+
+class FileViewerWidget(QW.QWidget):
+ """File viewer widget
+
+ Args:
+ parent (QW.QWidget | None): parent widget. Defaults to None.
+ """
+
+ def __init__(self, language: str | None = None, parent: QW.QWidget = None) -> None:
+ super().__init__(parent)
+ if parent is None:
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ self.editor = CodeEditor(language=language)
+ self.editor.setReadOnly(True)
+ layout = QW.QVBoxLayout()
+ self.label = QW.QLabel("")
+ layout.addWidget(self.label)
+ layout.addWidget(self.editor)
+ self.setLayout(layout)
+
+ def set_data(self, text: str, contents: str) -> None:
+ """Set log data
+
+ Args:
+ text (str): text to display
+ contents (str): contents to display
+ """
+ self.label.setText(text)
+ self.label.setOpenExternalLinks(True)
+ self.editor.setPlainText(contents)
diff --git a/sigimax/widgets/fitdialog.py b/sigimax/widgets/fitdialog.py
new file mode 100644
index 0000000..6799d9b
--- /dev/null
+++ b/sigimax/widgets/fitdialog.py
@@ -0,0 +1,940 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Curve fitting dialog widgets
+
+.. autofunction:: guifit
+.. autofunction:: linear_fit
+.. autofunction:: polynomial_fit
+.. autofunction:: gaussian_fit
+.. autofunction:: lorentzian_fit
+.. autofunction:: voigt_fit
+.. autofunction:: multigaussian_fit
+.. autofunction:: multilorentzian_fit
+.. autofunction:: exponential_fit
+.. autofunction:: sinusoidal_fit
+.. autofunction:: cdf_fit
+.. autofunction:: planckian_fit
+.. autofunction:: twohalfgaussian_fit
+.. autofunction:: piecewiseexponential_fit
+"""
+
+# pylint: disable=invalid-name # Allows short reference names like x, y, ...
+
+import numpy as np
+from guidata.configtools import get_icon
+from guidata.qthelpers import exec_dialog
+from plotpy.plot import PlotOptions
+from plotpy.widgets.fit import FitDialog, FitParam
+from scipy.special import erf # pylint: disable=no-name-in-module
+from sigima.tools.checks import check_1d_arrays
+from sigima.tools.signal import fitting, fourier, pulse
+
+from sigimax.config import _, get_conf
+
+__all__ = [
+ "cdf_fit",
+ "exponential_fit",
+ "gaussian_fit",
+ "guifit",
+ "linear_fit",
+ "lorentzian_fit",
+ "multigaussian_fit",
+ "multilorentzian_fit",
+ "piecewiseexponential_fit",
+ "planckian_fit",
+ "polynomial_fit",
+ "sinusoidal_fit",
+ "twohalfgaussian_fit",
+ "voigt_fit",
+]
+
+DEFAULT_FORMAT = "%g"
+
+
+def create_interactive_fit_params(fit_type, values, y, y_fitted):
+ """Create canonical metadata for a fit committed from a dialog."""
+ residual_rms = np.sqrt(np.mean((y - y_fitted) ** 2))
+ return fitting.create_fit_params(
+ fit_type, values, residual_rms=residual_rms, interactive=True
+ )
+
+
+def guifit(
+ x,
+ y,
+ fitfunc,
+ fitparams,
+ fitargs=None,
+ fitkwargs=None,
+ wintitle=None,
+ title=None,
+ xlabel=None,
+ ylabel=None,
+ param_cols=1,
+ auto_fit=True,
+ winsize=None,
+ winpos=None,
+ parent=None,
+ name=None,
+): # pylint: disable=too-many-positional-arguments
+ """GUI-based curve fitting tool"""
+ win = FitDialog(
+ edit=True,
+ title=wintitle,
+ icon=None,
+ toolbar=True,
+ options=PlotOptions(
+ title=title,
+ xlabel=xlabel,
+ ylabel=ylabel,
+ curve_antialiasing=True,
+ show_axes_tab=False,
+ autoscale_margin_percent=get_conf().sig_autoscale_margin_percent.get(),
+ ),
+ parent=parent,
+ param_cols=param_cols,
+ auto_fit=auto_fit,
+ )
+ win.setObjectName(name)
+ win.set_data(x, y, fitfunc, fitparams, fitargs, fitkwargs)
+ try:
+ win.autofit() # TODO: [P3] make this optional
+ except ValueError:
+ pass
+ if parent is None:
+ win.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ if winsize is not None:
+ win.resize(*winsize)
+ if winpos is not None:
+ win.move(*winpos)
+ win.get_plot().do_autoscale()
+ if exec_dialog(win):
+ return win.get_values()
+ return None
+
+
+# --- Polynomial fitting curve -------------------------------------------------
+def polynomial_fit(x, y, degree, parent=None, name=None, fit_type="polynomial"):
+ """Compute polynomial fit
+
+ Returns (yfit, params, fit_params), where yfit is the fitted curve, params are
+ the fitting parameters and fit_params is the canonical metadata dictionary"""
+ computer = fitting.PolynomialFitComputer(x, y, degree)
+ ivals = np.polyfit(x, y, degree)
+
+ params = []
+ for index in range(degree + 1):
+ val = ivals[index]
+ vmax = max(1.0, np.abs(val))
+ param = FitParam(
+ f"c{(len(ivals) - index - 1):d}",
+ val,
+ -2 * vmax,
+ 2 * vmax,
+ format=DEFAULT_FORMAT,
+ )
+ params.append(param)
+
+ def fitfunc(x, params):
+ return np.polyval(params, x)
+
+ values = guifit(
+ x, y, fitfunc, params, parent=parent, wintitle=_("Polymomial fit"), name=name
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ # Both `np.polyfit` and `PolynomialFitComputer` order coefficients from
+ # the highest degree to the lowest, so a plain zip is correct here.
+ fit_values = dict(zip(computer.get_params_names(), values))
+ fit_params = create_interactive_fit_params(fit_type, fit_values, y, y_fitted)
+ return y_fitted, params, fit_params
+
+
+def linear_fit(x: np.ndarray, y: np.ndarray, parent=None, name=None):
+ """Compute linear fit using polynomialfit.
+
+ Returns (yfit, params, fit_params), where yfit is the fitted curve, params are
+ the fitting parameters and fit_params is the canonical metadata dictionary
+ """
+ # A first-degree polynomial and a linear fit share the same `(a, b)` parameter
+ # names, so only the stored fit type has to be overridden.
+ return polynomial_fit(x, y, 1, parent=parent, name=name, fit_type="linear")
+
+
+# --- Gaussian fitting curve ---------------------------------------------------
+def gaussian_fit(x, y, parent=None, name=None):
+ """Compute Gaussian fit
+
+ Returns (yfit, params), where yfit is the fitted curve and params are
+ the fitting parameters"""
+ # Get initial parameter estimates from Sigima GaussianFitComputer
+ computer = fitting.GaussianFitComputer(x, y)
+ initial_params = computer.compute_initial_params()
+ amplitude_guess = initial_params["amplitude"]
+ sigma_guess = initial_params["sigma"]
+ mu_guess = initial_params["x0"]
+ b_guess = initial_params["y0"]
+
+ dy = np.max(y) - np.min(y)
+ max_amplitude = max(2.0 * dy, 2.0 * abs(amplitude_guess))
+ amplitude = FitParam(
+ _("Amplitude"),
+ amplitude_guess,
+ -max_amplitude,
+ max_amplitude,
+ format=DEFAULT_FORMAT,
+ )
+ b = FitParam(
+ _("Base line"), b_guess, np.min(y) - 0.1 * dy, np.max(y), format=DEFAULT_FORMAT
+ )
+ sigma = FitParam(
+ _("Std-dev") + " (σ)",
+ sigma_guess,
+ sigma_guess * 0.1,
+ sigma_guess * 10,
+ format=DEFAULT_FORMAT,
+ )
+ mu = FitParam(
+ _("Mean") + " (μ)", mu_guess, np.min(x), np.max(x), format=DEFAULT_FORMAT
+ )
+
+ params = [amplitude, sigma, mu, b]
+
+ def fitfunc(x, params):
+ return pulse.GaussianModel.evaluate(x, *params)
+
+ values = guifit(
+ x, y, fitfunc, params, parent=parent, wintitle=_("Gaussian fit"), name=name
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ fit_params = create_interactive_fit_params(
+ "gaussian", dict(zip(computer.get_params_names(), values)), y, y_fitted
+ )
+ return y_fitted, params, fit_params
+
+
+# --- Lorentzian fitting curve -------------------------------------------------
+def lorentzian_fit(x, y, parent=None, name=None):
+ """Compute Lorentzian fit
+
+ Returns (yfit, params), where yfit is the fitted curve and params are
+ the fitting parameters"""
+ # Get initial parameter estimates from Sigima LorentzianFitComputer
+ computer = fitting.LorentzianFitComputer(x, y)
+ initial_params = computer.compute_initial_params()
+ amplitude_guess = initial_params["amplitude"]
+ sigma_guess = initial_params["sigma"]
+ mu_guess = initial_params["x0"]
+ b_guess = initial_params["y0"]
+
+ # Create parameter bounds
+ dy = np.max(y) - np.min(y)
+
+ max_amplitude = max(2.0 * dy, 2.0 * abs(amplitude_guess))
+ amplitude = FitParam(
+ _("Amplitude"),
+ amplitude_guess,
+ -max_amplitude,
+ max_amplitude,
+ format=DEFAULT_FORMAT,
+ )
+ b = FitParam(
+ _("Base line"), b_guess, np.min(y) - 0.1 * dy, np.max(y), format=DEFAULT_FORMAT
+ )
+ sigma = FitParam(
+ _("Std-dev") + " (σ)",
+ sigma_guess,
+ sigma_guess * 0.1,
+ sigma_guess * 10,
+ format=DEFAULT_FORMAT,
+ )
+ mu = FitParam(
+ _("Mean") + " (μ)", mu_guess, np.min(x), np.max(x), format=DEFAULT_FORMAT
+ )
+
+ params = [amplitude, sigma, mu, b]
+
+ def fitfunc(x, params):
+ return pulse.LorentzianModel.evaluate(x, *params)
+
+ values = guifit(
+ x, y, fitfunc, params, parent=parent, wintitle=_("Lorentzian fit"), name=name
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ fit_params = create_interactive_fit_params(
+ "lorentzian", dict(zip(computer.get_params_names(), values)), y, y_fitted
+ )
+ return y_fitted, params, fit_params
+
+
+# --- Voigt fitting curve ------------------------------------------------------
+def voigt_fit(x, y, parent=None, name=None):
+ """Compute Voigt fit
+
+ Returns (yfit, params), where yfit is the fitted curve and params are
+ the fitting parameters"""
+ # Get initial parameter estimates from Sigima VoigtFitComputer
+ computer = fitting.VoigtFitComputer(x, y)
+ initial_params = computer.compute_initial_params()
+ amplitude_guess = initial_params["amplitude"]
+ sigma_guess = initial_params["sigma"]
+ mu_guess = initial_params["x0"]
+ b_guess = initial_params["y0"]
+
+ # Create parameter bounds
+ dy = np.max(y) - np.min(y)
+
+ max_amplitude = max(2.0 * dy, 2.0 * abs(amplitude_guess))
+ amplitude = FitParam(
+ _("Amplitude"),
+ amplitude_guess,
+ -max_amplitude,
+ max_amplitude,
+ format=DEFAULT_FORMAT,
+ )
+ b = FitParam(
+ _("Base line"), b_guess, np.min(y) - 0.1 * dy, np.max(y), format=DEFAULT_FORMAT
+ )
+ sigma = FitParam(
+ _("Std-dev") + " (σ)",
+ sigma_guess,
+ sigma_guess * 0.1,
+ sigma_guess * 10,
+ format=DEFAULT_FORMAT,
+ )
+ mu = FitParam(
+ _("Mean") + " (μ)", mu_guess, np.min(x), np.max(x), format=DEFAULT_FORMAT
+ )
+
+ params = [amplitude, sigma, mu, b]
+
+ def fitfunc(x, params):
+ return pulse.VoigtModel.evaluate(x, *params)
+
+ values = guifit(
+ x, y, fitfunc, params, parent=parent, wintitle=_("Voigt fit"), name=name
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ fit_params = create_interactive_fit_params(
+ "voigt", dict(zip(computer.get_params_names(), values)), y, y_fitted
+ )
+ return y_fitted, params, fit_params
+
+
+# --- Multi-Gaussian fitting curve ---------------------------------------------
+def multigaussian(x, *values, **kwargs):
+ """Return a 1-dimensional multi-Gaussian function."""
+ amplitudes = values[0::2]
+ a_sigma = values[1::2]
+ y0 = values[-1]
+ a_x0 = kwargs["a_x0"]
+ y = np.zeros_like(x) + y0
+ for amplitude, sigma, x0 in zip(amplitudes, a_sigma, a_x0):
+ y += pulse.GaussianModel.evaluate(x, amplitude, sigma, x0, 0.0)
+ return y
+
+
+def multigaussian_fit(x, y, peak_indices, parent=None, name=None):
+ """Compute Multi-Gaussian fit
+
+ Returns (yfit, params), where yfit is the fitted curve and params are
+ the fitting parameters"""
+ # Get initial parameter estimates from Sigima MultiGaussianFitComputer
+ computer = fitting.MultiGaussianFitComputer(x, y, peak_indices)
+ initial_params = computer.compute_initial_params()
+ # Use Sigima parameters to populate SigimaX params
+ params = []
+ for index, i0 in enumerate(peak_indices):
+ stri = f"{index + 1:02d}"
+ amplitude_key = f"amplitude_{index + 1}"
+ sigma_key = f"sigma_{index + 1}"
+ amplitude_value = initial_params.get(amplitude_key, y[i0] - np.min(y))
+ sigma_val = (
+ initial_params[sigma_key]
+ if sigma_key in initial_params
+ else (x.max() - x.min()) / 100
+ )
+
+ # Calculate bounds based on local data
+ istart = 0
+ iend = len(x) - 1
+ if index > 0:
+ istart = (peak_indices[index - 1] + i0) // 2
+ if index < len(peak_indices) - 1:
+ iend = (peak_indices[index + 1] + i0) // 2
+ dx = 0.5 * (x[iend] - x[istart])
+ dy = np.max(y[istart:iend]) - np.min(y[istart:iend])
+ amplitude_range = max(dy * 2, abs(amplitude_value) * 2)
+
+ params += [
+ FitParam(
+ ("A") + stri,
+ amplitude_value,
+ -amplitude_range,
+ amplitude_range,
+ format=DEFAULT_FORMAT,
+ ),
+ FitParam("σ" + stri, sigma_val, dx / 100, dx, format=DEFAULT_FORMAT),
+ ]
+
+ y0_val = initial_params.get("y0", np.min(y))
+ params.append(
+ FitParam(
+ _("Y0"),
+ y0_val,
+ np.min(y) - 0.1 * (np.max(y) - np.min(y)),
+ np.max(y),
+ format=DEFAULT_FORMAT,
+ )
+ )
+
+ kwargs = {"a_x0": x[peak_indices]}
+
+ def fitfunc(xi, params):
+ return multigaussian(xi, *params, **kwargs)
+
+ param_cols = 1
+ if len(params) > 8:
+ param_cols = 4
+ values = guifit(
+ x,
+ y,
+ fitfunc,
+ params,
+ param_cols=param_cols,
+ winsize=(900, 600),
+ parent=parent,
+ name=name,
+ wintitle=_("Multi-Gaussian fit"),
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ fit_values = {"y0": values[-1]}
+ for index, (amplitude, sigma, x0) in enumerate(
+ zip(values[0::2], values[1::2], kwargs["a_x0"]), start=1
+ ):
+ fit_values[f"amplitude_{index}"] = amplitude
+ fit_values[f"sigma_{index}"] = abs(sigma)
+ fit_values[f"x0_{index}"] = x0
+ fit_params = create_interactive_fit_params(
+ "multigaussian", fit_values, y, y_fitted
+ )
+ return y_fitted, params, fit_params
+
+
+# --- Multi-Lorentzian fitting curve -------------------------------------------
+def multilorentzian(x, *values, **kwargs):
+ """Return a 1-dimensional multi-Lorentzian function."""
+ amplitudes = values[0::2]
+ a_sigma = values[1::2]
+ y0 = values[-1]
+ a_x0 = kwargs["a_x0"]
+ y = np.zeros_like(x) + y0
+ for amplitude, sigma, x0 in zip(amplitudes, a_sigma, a_x0):
+ y += pulse.LorentzianModel.evaluate(x, amplitude, sigma, x0, 0.0)
+ return y
+
+
+def multilorentzian_fit(
+ x: np.ndarray, y: np.ndarray, peak_indices, parent=None, name=None
+):
+ """Compute Multi-Lorentzian fit
+
+ Returns (yfit, params), where yfit is the fitted curve and params are
+ the fitting parameters"""
+ # Get initial parameter estimates from Sigima MultiLorentzianFitComputer
+ computer = fitting.MultiLorentzianFitComputer(x, y, peak_indices)
+ initial_params = computer.compute_initial_params()
+ # Use Sigima parameters to populate SigimaX params
+ params = []
+ dy = np.max(y) - np.min(y)
+ for index, i0 in enumerate(peak_indices):
+ stri = f"{index + 1:02d}"
+ amplitude_key = f"amplitude_{index + 1}"
+ sigma_key = f"sigma_{index + 1}"
+ amplitude_value = initial_params.get(amplitude_key, y[i0] - np.min(y))
+ sigma_val = (
+ initial_params[sigma_key]
+ if sigma_key in initial_params
+ else (x.max() - x.min()) / 100
+ )
+
+ params += [
+ FitParam(
+ ("A") + stri,
+ amplitude_value,
+ -max(abs(amplitude_value) * 2, dy * 2),
+ max(abs(amplitude_value) * 2, dy * 2),
+ format=DEFAULT_FORMAT,
+ ),
+ FitParam(
+ "σ" + stri,
+ sigma_val,
+ sigma_val * 0.2,
+ sigma_val * 10,
+ format=DEFAULT_FORMAT,
+ ),
+ ]
+
+ y0_val = initial_params.get("y0", np.min(y))
+ params.append(
+ FitParam(
+ _("Y0"),
+ y0_val,
+ np.min(y) - 0.1 * (np.max(y) - np.min(y)),
+ np.max(y),
+ format=DEFAULT_FORMAT,
+ )
+ )
+
+ kwargs = {"a_x0": x[peak_indices]}
+
+ def fitfunc(xi, params):
+ return multilorentzian(xi, *params, **kwargs)
+
+ param_cols = 1
+ if len(params) > 8:
+ param_cols = 4
+ values = guifit(
+ x,
+ y,
+ fitfunc,
+ params,
+ param_cols=param_cols,
+ winsize=(900, 600),
+ parent=parent,
+ name=name,
+ wintitle=_("Multi-Lorentzian fit"),
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ fit_values = {"y0": values[-1]}
+ for index, (amplitude, sigma, x0) in enumerate(
+ zip(values[0::2], values[1::2], kwargs["a_x0"]), start=1
+ ):
+ fit_values[f"amplitude_{index}"] = amplitude
+ fit_values[f"sigma_{index}"] = abs(sigma)
+ fit_values[f"x0_{index}"] = x0
+ fit_params = create_interactive_fit_params(
+ "multilorentzian", fit_values, y, y_fitted
+ )
+ return y_fitted, params, fit_params
+
+
+# --- Exponential fitting curve ------------------------------------------------
+
+
+def exponential_fit(x: np.ndarray, y: np.ndarray, parent=None, name=None):
+ """Compute exponential fit
+
+ Returns (yfit, params, fit_params), where yfit is the fitted curve, params are
+ the fitting parameters and fit_params is the canonical metadata dictionary"""
+ # Get initial parameter estimates from Sigima ExponentialFitComputer
+ computer = fitting.ExponentialFitComputer(x, y)
+ initial_params = computer.compute_initial_params()
+ oa = initial_params["a"]
+ ob = initial_params["b"]
+ oc = initial_params["y0"]
+
+ # Create parameter bounds
+ moa, mob, moc = np.maximum(1, [abs(oa), abs(ob), abs(oc)])
+ a_p = FitParam(
+ _("A coefficient"), oa, -2 * moa, 2 * moa, logscale=True, format=DEFAULT_FORMAT
+ )
+ # B must be free to change sign: a positive-only range makes every decaying
+ # exponential unreachable. Sigima uses (-10, 10) for the same parameter.
+ mob = max(10.0, 2 * mob)
+ b_p = FitParam(_("B coefficient"), ob, -mob, mob, format=DEFAULT_FORMAT)
+ c_p = FitParam(_("y0 constant"), oc, -2 * moc, 2 * moc, format=DEFAULT_FORMAT)
+
+ params = [a_p, b_p, c_p]
+
+ def modelfunc(x, a, b, c):
+ return a * np.exp(b * x) + c
+
+ def fitfunc(x, params):
+ return modelfunc(x, *params)
+
+ values = guifit(
+ x, y, fitfunc, params, parent=parent, wintitle=_("Exponential fit"), name=name
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ fit_params = create_interactive_fit_params(
+ "exponential", dict(zip(computer.get_params_names(), values)), y, y_fitted
+ )
+ return y_fitted, params, fit_params
+
+
+# --- Sinusoidal fitting curve ------------------------------------------------
+
+
+@check_1d_arrays(x_evenly_spaced=True)
+def dominant_frequency(x: np.ndarray, y: np.ndarray) -> np.floating:
+ """Find the dominant frequency.
+
+ Args:
+ x: 1-D x values.
+ y: 1-D y values.
+
+ Returns:
+ Dominant frequency.
+ """
+ f, spectrum = fourier.magnitude_spectrum(x, y)
+ return np.abs(f[np.argmax(spectrum)])
+
+
+def sinusoidal_fit(x: np.ndarray, y: np.ndarray, parent=None, name=None):
+ """Compute sinusoidal fit
+
+ Returns (yfit, params, fit_params), where yfit is the fitted curve, params are
+ the fitting parameters and fit_params is the canonical metadata dictionary"""
+ # Get initial parameter estimates from Sigima SinusoidalFitComputer
+ computer = fitting.SinusoidalFitComputer(x, y)
+ initial_params = computer.compute_initial_params()
+ guess_a = initial_params["amplitude"]
+ guess_f = initial_params["frequency"]
+ guess_ph = np.rad2deg(initial_params["phase"]) # Convert to degrees
+ guess_c = initial_params["offset"]
+
+ # Create parameter bounds
+ abs_values = [abs(guess_a), abs(guess_f), abs(guess_ph), abs(guess_c)]
+ moa, mof, _mop, moc = np.maximum(1, abs_values)
+ a_p = FitParam(_("Amplitude"), guess_a, -2 * moa, 2 * moa, format=DEFAULT_FORMAT)
+ f_p = FitParam(_("Frequency"), guess_f, 0, 2 * mof, format=DEFAULT_FORMAT)
+ p_p = FitParam(_("Phase"), guess_ph, -360, 360, format=DEFAULT_FORMAT)
+ c_p = FitParam(
+ _("Continuous component"), guess_c, -2 * moc, 2 * moc, format=DEFAULT_FORMAT
+ )
+
+ params = [a_p, f_p, p_p, c_p]
+
+ def modelfunc(x, a, f, p, c):
+ return a * np.sin(2 * np.pi * f * x + np.deg2rad(p)) + c
+
+ def fitfunc(x, params):
+ return modelfunc(x, *params)
+
+ values = guifit(
+ x, y, fitfunc, params, parent=parent, wintitle=_("Sinusoidal fit"), name=name
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ # The phase is edited in degrees but stored in radians, as expected by
+ # Sigima's sinusoidal model.
+ amplitude, frequency, phase, offset = values
+ fit_values = dict(
+ zip(
+ computer.get_params_names(),
+ (amplitude, frequency, np.deg2rad(phase), offset),
+ )
+ )
+ fit_params = create_interactive_fit_params(
+ "sinusoidal", fit_values, y, y_fitted
+ )
+ return y_fitted, params, fit_params
+
+
+# --- Cumulative distribution function fitting curve -----------------------------------
+
+
+def cdf_fit(x: np.ndarray, y: np.ndarray, parent=None, name=None):
+ """Compute Cumulative Distribution Function (CDF) fit
+
+ Returns (yfit, params, fit_params), where yfit is the fitted curve, params are
+ the fitting parameters and fit_params is the canonical metadata dictionary"""
+ # Get initial parameter estimates from Sigima CDFFitComputer
+ computer = fitting.CDFFitComputer(x, y)
+ initial_params = computer.compute_initial_params()
+ a_guess = initial_params["amplitude"]
+ mu_guess = initial_params["mu"]
+ sigma_guess = initial_params["sigma"]
+ b_guess = initial_params["baseline"]
+
+ # Create parameter bounds
+ dy = np.max(y) - np.min(y)
+ x_min, x_max = float(np.min(x)), float(np.max(x))
+ dx = x_max - x_min
+ iamp = max(1.0, abs(a_guess))
+ # Amplitude must be free to change sign, otherwise a descending transition
+ # cannot be fitted at all.
+ a = FitParam(
+ _("Amplitude"), a_guess, -iamp * 2.0, iamp * 2.0, format=DEFAULT_FORMAT
+ )
+ b = FitParam(
+ _("Base line"), b_guess, np.min(y) - 0.1 * dy, np.max(y), format=DEFAULT_FORMAT
+ )
+ # Bound sigma and mu to the abscissa range rather than to the magnitude of
+ # the initial guess, which excluded negative and near-zero means.
+ sigma = FitParam(
+ _("Std-dev") + " (σ)",
+ sigma_guess,
+ dx * 0.001,
+ dx,
+ format=DEFAULT_FORMAT,
+ )
+ mu = FitParam(_("Mean") + " (μ)", mu_guess, x_min, x_max, format=DEFAULT_FORMAT)
+
+ params = [a, mu, sigma, b]
+
+ def modelfunc(x, a, mu, sigma, b):
+ return a * erf((x - mu) / (sigma * np.sqrt(2))) + b
+
+ def fitfunc(x, params):
+ return modelfunc(x, *params)
+
+ values = guifit(
+ x,
+ y,
+ fitfunc,
+ params,
+ parent=parent,
+ wintitle=_("CDF fit"),
+ name=name,
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ fit_params = create_interactive_fit_params(
+ "cdf", dict(zip(computer.get_params_names(), values)), y, y_fitted
+ )
+ return y_fitted, params, fit_params
+
+
+# --- Planckian fitting curve --------------------------------------------------
+def planckian_fit(x: np.ndarray, y: np.ndarray, parent=None, name=None):
+ """Compute Planckian (blackbody radiation) fit
+
+ Returns (yfit, params, fit_params), where yfit is the fitted curve, params are
+ the fitting parameters and fit_params is the canonical metadata dictionary"""
+ # Get initial parameter estimates from Sigima PlanckianFitComputer
+ computer = fitting.PlanckianFitComputer(x, y)
+ initial_params = computer.compute_initial_params()
+ amp_guess = initial_params["amp"]
+ x0_guess = initial_params["x0"]
+ sigma_guess = initial_params["sigma"]
+ y0_guess = initial_params["y0"]
+
+ # Create parameter bounds
+ dy = np.max(y) - np.min(y)
+
+ # Parameter bounds with appropriate ranges for Planckian fitting
+ amp = FitParam(
+ _("Amplitude"),
+ amp_guess,
+ amp_guess * 0.01,
+ amp_guess * 100,
+ format=DEFAULT_FORMAT,
+ )
+ x0 = FitParam(
+ _("Scale factor"), x0_guess, np.min(x), np.max(x), format=DEFAULT_FORMAT
+ )
+ sigma = FitParam(_("Width factor"), sigma_guess, 0.1, 5.0, format=DEFAULT_FORMAT)
+ y0 = FitParam(
+ _("Base line"),
+ y0_guess,
+ y0_guess - 0.2 * dy,
+ y0_guess + 0.2 * dy,
+ format=DEFAULT_FORMAT,
+ )
+
+ params = [amp, x0, sigma, y0]
+
+ def fitfunc(x, params: list[float]) -> np.ndarray:
+ """Evaluate Planckian function with given parameters."""
+ return fitting.PlanckianFitComputer.evaluate(x, *params)
+
+ values = guifit(
+ x, y, fitfunc, params, parent=parent, wintitle=_("Planckian fit"), name=name
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ fit_params = create_interactive_fit_params(
+ "planckian", dict(zip(computer.get_params_names(), values)), y, y_fitted
+ )
+ return y_fitted, params, fit_params
+
+
+# --- Two half-Gaussian fitting curve ------------------------------------------
+def twohalfgaussian_fit(x: np.ndarray, y: np.ndarray, parent=None, name=None):
+ """Compute two half-Gaussian fit for asymmetric peaks
+
+ Returns (yfit, params, fit_params), where yfit is the fitted curve, params are
+ the fitting parameters and fit_params is the canonical metadata dictionary"""
+ # Get initial parameter estimates from Sigima TwoHalfGaussianFitComputer
+ computer = fitting.TwoHalfGaussianFitComputer(x, y)
+ initial_params = computer.compute_initial_params()
+ amp_left_guess = initial_params["amp_left"]
+ amp_right_guess = initial_params["amp_right"]
+ sigma_left_guess = initial_params["sigma_left"]
+ sigma_right_guess = initial_params["sigma_right"]
+ x0_guess = initial_params["x0"]
+ y0_left_guess = initial_params["y0_left"]
+ y0_right_guess = initial_params["y0_right"]
+
+ # Create parameter bounds
+ dx = np.max(x) - np.min(x)
+ dy = np.max(y) - np.min(y)
+
+ # Parameter bounds with better ranges
+ # New model signature: func(x, amp_left, amp_right, sigma_left,
+ # sigma_right, x0, y0_left, y0_right)
+ amp_left = FitParam(
+ _("Left amplitude"), amp_left_guess, dy * 0.1, dy * 3, format=DEFAULT_FORMAT
+ )
+ amp_right = FitParam(
+ _("Right amplitude"), amp_right_guess, dy * 0.1, dy * 3, format=DEFAULT_FORMAT
+ )
+ sigma_left = FitParam(
+ _("Left width") + " (σL)",
+ sigma_left_guess,
+ dx * 0.001, # Very small minimum
+ dx * 0.5, # Reasonable maximum
+ format=DEFAULT_FORMAT,
+ )
+ sigma_right = FitParam(
+ _("Right width") + " (σR)",
+ sigma_right_guess,
+ dx * 0.001, # Very small minimum
+ dx * 0.5, # Reasonable maximum
+ format=DEFAULT_FORMAT,
+ )
+ x0 = FitParam(
+ _("Center") + " (x₀)", x0_guess, np.min(x), np.max(x), format=DEFAULT_FORMAT
+ )
+ y0_left = FitParam(
+ _("Left baseline"),
+ y0_left_guess,
+ y0_left_guess - 0.2 * dy,
+ y0_left_guess + 0.2 * dy,
+ format=DEFAULT_FORMAT,
+ )
+ y0_right = FitParam(
+ _("Right baseline"),
+ y0_right_guess,
+ y0_right_guess - 0.2 * dy,
+ y0_right_guess + 0.2 * dy,
+ format=DEFAULT_FORMAT,
+ )
+
+ params = [amp_left, amp_right, sigma_left, sigma_right, x0, y0_left, y0_right]
+
+ def fitfunc(x, params):
+ return fitting.TwoHalfGaussianFitComputer.evaluate(x, *params)
+
+ values = guifit(
+ x,
+ y,
+ fitfunc,
+ params,
+ parent=parent,
+ wintitle=_("Two half-Gaussian fit"),
+ name=name,
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ fit_params = create_interactive_fit_params(
+ "twohalfgaussian",
+ dict(zip(computer.get_params_names(), values)),
+ y,
+ y_fitted,
+ )
+ return y_fitted, params, fit_params
+
+
+# --- Piecewise exponential (raise-decay) fitting curve ------------------------
+def piecewiseexponential_fit(x: np.ndarray, y: np.ndarray, parent=None, name=None):
+ """Compute piecewise exponential fit (raise-decay)
+
+ Returns (yfit, params, fit_params), where yfit is the fitted curve, params are
+ the fitting parameters and fit_params is the canonical metadata dictionary"""
+ # Get initial parameter estimates from Sigima DoubleExponentialFitComputer
+ computer = fitting.DoubleExponentialFitComputer(x, y)
+ initial_params = computer.compute_initial_params()
+ x_center_guess = initial_params["x_center"]
+ a_left_guess = initial_params["a_left"]
+ b_left_guess = initial_params["b_left"]
+ a_right_guess = initial_params["a_right"]
+ b_right_guess = initial_params["b_right"]
+ y0_guess = initial_params["y0"]
+
+ # Create parameter bounds
+ x_min, x_max = float(x.min()), float(x.max())
+ y_min, y_max = float(y.min()), float(y.max())
+ y_range = y_max - y_min
+ x_range = x_max - x_min
+
+ # Parameter bounds with more realistic ranges
+ # New model signature: func(x, x_center, a_left, b_left, a_right, b_right, y0)
+ # Amplitudes are bounded symmetrically: a `(0, guess * 10)` range silently
+ # inverts into an empty interval whenever the guess is negative.
+ amp_bound = max(abs(a_left_guess), abs(a_right_guess), y_range) * 10.0
+ # Rates are bounded symmetrically too: forcing b_left > 0 and b_right < 0
+ # assumes a rise-then-decay shape and makes the opposite shape unreachable.
+ rate_bound = 100.0 / x_range
+ x_center = FitParam(
+ _("Center position"), x_center_guess, x_min, x_max, format=DEFAULT_FORMAT
+ )
+ a_left = FitParam(
+ _("Left amplitude"),
+ a_left_guess,
+ -amp_bound,
+ amp_bound,
+ format=DEFAULT_FORMAT,
+ )
+ b_left = FitParam(
+ _("Left rate") + " (bL)",
+ b_left_guess, # Already in coefficient form
+ -rate_bound,
+ rate_bound,
+ format=DEFAULT_FORMAT,
+ )
+ a_right = FitParam(
+ _("Right amplitude"),
+ a_right_guess,
+ -amp_bound,
+ amp_bound,
+ format=DEFAULT_FORMAT,
+ )
+ b_right = FitParam(
+ _("Right rate") + " (bR)",
+ b_right_guess, # Already in coefficient form
+ -rate_bound,
+ rate_bound,
+ format=DEFAULT_FORMAT,
+ )
+ y0 = FitParam(
+ _("Base line"),
+ y0_guess,
+ y0_guess - 0.2 * y_range,
+ y0_guess + 0.2 * y_range,
+ format=DEFAULT_FORMAT,
+ )
+
+ params = [x_center, a_left, b_left, a_right, b_right, y0]
+
+ def fitfunc(x, params):
+ return fitting.DoubleExponentialFitComputer.evaluate(x, *params)
+
+ values = guifit(
+ x,
+ y,
+ fitfunc,
+ params,
+ parent=parent,
+ wintitle=_("Piecewise exponential (raise-decay) fit"),
+ name=name,
+ )
+ if values:
+ y_fitted = fitfunc(x, values)
+ # Sigima registers this model under "doubleexponential": the fit type is
+ # not derived from the dialog function name.
+ fit_params = create_interactive_fit_params(
+ "doubleexponential",
+ dict(zip(computer.get_params_names(), values)),
+ y,
+ y_fitted,
+ )
+ return y_fitted, params, fit_params
diff --git a/sigimax/widgets/h5browser.py b/sigimax/widgets/h5browser.py
new file mode 100644
index 0000000..d22f5b3
--- /dev/null
+++ b/sigimax/widgets/h5browser.py
@@ -0,0 +1,1061 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+SigimaX HDF5 browser module
+
+.. autoclass:: H5Browser
+ :members:
+.. autoclass:: H5BrowserDialog
+ :members:
+.. autoclass:: H5TreeWidget
+ :members:
+"""
+
+# pylint: disable=invalid-name # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+import abc
+import os
+import os.path as osp
+from typing import TYPE_CHECKING, Any, Callable
+
+from guidata.qthelpers import (
+ add_actions,
+ create_action,
+ create_toolbutton,
+ exec_dialog,
+ get_icon,
+ get_std_icon,
+ win32_fix_title_bar_background,
+)
+from guidata.utils.misc import to_string
+from guidata.widgets.arrayeditor import ArrayEditor
+from plotpy.builder import make
+from plotpy.plot import PlotOptions, PlotWidget
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+from qtpy.compat import getopenfilename
+from sigima import ImageObj, SignalObj
+
+from sigimax.adapters_plotpy import CURVESTYLES, create_adapter_from_object
+from sigimax.config import _, get_conf
+from sigimax.h5 import H5Importer
+from sigimax.utils.qthelpers import block_signals, qt_handle_error_message
+
+__all__ = [
+ "AbstractTreeWidget",
+ "H5Browser",
+ "H5BrowserDialog",
+ "H5FileSelector",
+ "H5TreeWidget",
+]
+
+if TYPE_CHECKING:
+ from plotpy.plot import BasePlot
+
+ from sigimax.h5.common import BaseNode
+
+
+class AbstractTreeWidgetMeta(type(QW.QTreeWidget), abc.ABCMeta):
+ """Mixed metaclass to avoid conflicts"""
+
+
+class AbstractTreeWidget(QW.QTreeWidget, metaclass=AbstractTreeWidgetMeta):
+ """One-column tree widget with context menu, ..."""
+
+ def __init__(self, parent: QW.QWidget) -> None:
+ super().__init__(parent)
+ self.setItemsExpandable(True)
+ self.itemActivated.connect(self.activated)
+ self.itemClicked.connect(self.clicked)
+ # Setup context menu
+ self.menu = QW.QMenu(self)
+ self.collapse_all_action = None
+ self.collapse_selection_action = None
+ self.expand_all_action = None
+ self.expand_selection_action = None
+ self.common_actions = self.setup_common_actions()
+
+ self.itemSelectionChanged.connect(self.item_selection_changed)
+ self.item_selection_changed()
+
+ @abc.abstractmethod
+ def activated(self, item: QW.QTreeWidgetItem) -> None:
+ """Double-click event"""
+
+ @abc.abstractmethod
+ def clicked(self, item: QW.QTreeWidgetItem) -> None:
+ """Item was clicked"""
+
+ @abc.abstractmethod
+ def get_actions_from_items(
+ self, items: list[QW.QTreeWidgetItem]
+ ) -> list[QW.QAction]:
+ """Get actions from item"""
+ # Right here: add other actions if necessary (reimplement this method)
+ return []
+
+ def setup_common_actions(self) -> list[QW.QAction]:
+ """Setup context menu common actions"""
+ self.collapse_all_action = create_action(
+ self,
+ _("Collapse all"),
+ icon=get_icon("collapse.svg"),
+ triggered=self.collapseAll,
+ )
+ self.expand_all_action = create_action(
+ self, _("Expand all"), icon=get_icon("expand.svg"), triggered=self.expandAll
+ )
+ self.restore_action = create_action(
+ self,
+ _("Restore"),
+ tip=_("Restore original tree layout"),
+ icon=get_icon("restore.svg"),
+ triggered=self.restore,
+ )
+ self.collapse_selection_action = create_action(
+ self,
+ _("Collapse selection"),
+ icon=get_icon("collapse_selection.svg"),
+ triggered=self.collapse_selection,
+ )
+ self.expand_selection_action = create_action(
+ self,
+ _("Expand selection"),
+ icon=get_icon("expand_selection.svg"),
+ triggered=self.expand_selection,
+ )
+ return [
+ self.collapse_all_action,
+ self.expand_all_action,
+ self.restore_action,
+ None,
+ self.collapse_selection_action,
+ self.expand_selection_action,
+ ]
+
+ def update_menu(self) -> None:
+ """Update context menu"""
+ self.menu.clear()
+ items = self.selectedItems()
+ actions = self.get_actions_from_items(items)
+ if actions:
+ actions.append(None)
+ actions += self.common_actions
+ add_actions(self.menu, actions)
+
+ def restore(self) -> None:
+ """Restore tree state"""
+ self.collapseAll()
+ for item in self.get_top_level_items():
+ self.expandItem(item)
+
+ def __expand_item(self, item: QW.QTreeWidgetItem) -> None: # pragma: no cover
+ """Expand item tree branch"""
+ self.expandItem(item)
+ for index in range(item.childCount()):
+ child = item.child(index)
+ self.__expand_item(child)
+
+ def expand_selection(self) -> None: # pragma: no cover
+ """Expand selection"""
+ items = self.selectedItems()
+ if not items:
+ items = self.get_top_level_items()
+ for item in items:
+ self.__expand_item(item)
+ if items:
+ self.scrollToItem(items[0])
+
+ def __collapse_item(self, item: QW.QTreeWidgetItem) -> None: # pragma: no cover
+ """Collapse item tree branch"""
+ self.collapseItem(item)
+ for index in range(item.childCount()):
+ child = item.child(index)
+ self.__collapse_item(child)
+
+ def collapse_selection(self) -> None: # pragma: no cover
+ """Collapse selection"""
+ items = self.selectedItems()
+ if not items:
+ items = self.get_top_level_items()
+ for item in items:
+ self.__collapse_item(item)
+ if items:
+ self.scrollToItem(items[0])
+
+ def item_selection_changed(self) -> None:
+ """Item selection has changed"""
+ is_selection = len(self.selectedItems()) > 0
+ self.expand_selection_action.setEnabled(is_selection)
+ self.collapse_selection_action.setEnabled(is_selection)
+
+ def get_top_level_items(self) -> list[QW.QTreeWidgetItem]:
+ """Iterate over top level items"""
+ return [self.topLevelItem(_i) for _i in range(self.topLevelItemCount())]
+
+ def find_all_items(self):
+ """Find all items"""
+ return self.findItems("", QC.Qt.MatchContains | QC.Qt.MatchRecursive)
+
+ def contextMenuEvent(self, event: QG.QContextMenuEvent) -> None:
+ """Override Qt method"""
+ self.update_menu()
+ self.menu.popup(event.globalPos())
+
+
+class H5TreeWidget(AbstractTreeWidget):
+ """HDF5 Browser Tree Widget
+
+ Args:
+ parent: Parent widget
+ """
+
+ SIG_SELECTED = QC.Signal(QW.QTreeWidgetItem)
+
+ def __init__(self, parent: QW.QWidget) -> None:
+ super().__init__(parent)
+ title = _("HDF5 Browser")
+ self.setColumnCount(4)
+ self.setWindowTitle(title)
+ self.setHeaderLabels([_("Name"), _("Size"), _("Type"), _("Value")])
+ self.header().setSectionResizeMode(0, QW.QHeaderView.Stretch)
+ self.header().setStretchLastSection(False)
+ self.fnames: list[str] = []
+ self.h5importers: list[H5Importer] = []
+
+ def add_root(self, fname: str) -> None:
+ """Add HDF5 root (new file)
+
+ Args:
+ fname: HDF5 file name
+ """
+ self.fnames.append(osp.abspath(fname))
+ importer = H5Importer(fname)
+ self.h5importers.append(importer)
+ self.add_root_to_tree(importer)
+ # Temporarily expand all items to calculate proper column widths
+ rootitem = self.topLevelItem(self.topLevelItemCount() - 1)
+ self.expand_all_children(rootitem)
+ for col in range(4):
+ self.resizeColumnToContents(col)
+ # Restore to default state (only root and its immediate children expanded)
+ for index in range(rootitem.childCount()):
+ child = rootitem.child(index)
+ self.collapseItem(child)
+
+ def remove_root(self, fname: str) -> None:
+ """Remove HDF5 root
+
+ Args:
+ fname: HDF5 file name
+ """
+ index = self.fnames.index(osp.abspath(fname))
+ self.fnames.pop(index)
+ importer = self.h5importers.pop(index)
+ importer.close()
+ # Remove root item associated with file
+ item = self.topLevelItem(index)
+ self.takeTopLevelItem(index)
+ del item
+
+ def cleanup(self) -> None:
+ """Clean up widget"""
+ for importer in self.h5importers:
+ importer.close()
+ self.fnames: list[str] = []
+ self.h5importers: list[H5Importer] = []
+ self.clear()
+
+ def __get_top_level_item(self, item: QW.QTreeWidgetItem) -> QW.QTreeWidgetItem:
+ """Get top level item associated to item
+
+ Args:
+ item: Tree item
+
+ Returns:
+ Top level item
+ """
+ while item.parent():
+ item = item.parent()
+ return item
+
+ def get_node(self, item: QW.QTreeWidgetItem) -> BaseNode:
+ """Get HDF5 dataset associated to item
+
+ Args:
+ item: Tree item
+
+ Returns:
+ HDF5 node
+ """
+ toplevel_item = self.__get_top_level_item(item)
+ toplevel_index = self.indexOfTopLevelItem(toplevel_item)
+ node_id = item.data(0, QC.Qt.UserRole)
+ if node_id:
+ importer = self.h5importers[toplevel_index]
+ return importer.get(node_id)
+ return None
+
+ def get_nodes(self, only_checked_items: bool = True) -> list[BaseNode]:
+ """Get all nodes associated to checked items
+
+ Args:
+ only_checked_items: If True, only checked items are returned
+
+ Returns:
+ List of HDF5 nodes
+ """
+ datasets = []
+ for item in self.find_all_items():
+ if item.flags() & QC.Qt.ItemIsUserCheckable:
+ if only_checked_items and item.checkState(0) == 0:
+ continue
+ if item is not self.topLevelItem(0):
+ node = self.get_node(item)
+ datasets.append(node)
+ return datasets
+
+ def activated(self, item: QW.QTreeWidgetItem) -> None:
+ """Double-click event"""
+ if item is not self.topLevelItem(0):
+ self.SIG_SELECTED.emit(item)
+
+ def clicked(self, item: QW.QTreeWidgetItem) -> None:
+ """Click event"""
+ self.activated(item)
+
+ def get_actions_from_items(self, items): # pylint: disable=W0613
+ """Get actions from item"""
+ return []
+
+ def is_empty(self) -> bool:
+ """Return True if tree is empty"""
+ return len(self.find_all_items()) == 1
+
+ def is_any_item_checked(self) -> bool:
+ """Return True if any item is checked"""
+ for item in self.find_all_items():
+ if item.checkState(0) > 0:
+ return True
+ return False
+
+ def select_all(self, state: bool) -> None:
+ """Select all items
+
+ Args:
+ state: If True, all items are selected
+ """
+ for item in self.find_all_items():
+ if item.flags() & QC.Qt.ItemIsUserCheckable:
+ item.setSelected(state)
+ if state:
+ self.clicked(item)
+
+ def toggle_all(self, state: bool) -> None:
+ """Toggle all item state from 'unchecked' to 'checked'
+ (or vice-versa)
+
+ Args:
+ state: If True, all items are checked
+ """
+ for item in self.find_all_items():
+ if item.flags() & QC.Qt.ItemIsUserCheckable:
+ item.setCheckState(0, QC.Qt.Checked if state else QC.Qt.Unchecked)
+
+ @staticmethod
+ def __create_node(node: BaseNode) -> QW.QTreeWidgetItem:
+ """Create tree node from HDF5 node
+
+ Args:
+ node: HDF5 node
+
+ Returns:
+ Tree widget node
+ """
+ text = to_string(node.text)
+ if len(text) > 30:
+ text = text[:30] + "..."
+ treeitem = QW.QTreeWidgetItem([node.name, node.shape_str, node.dtype_str, text])
+ treeitem.setData(0, QC.Qt.UserRole, node.id)
+ if node.description:
+ for col in range(treeitem.columnCount()):
+ treeitem.setToolTip(col, node.description)
+ return treeitem
+
+ @staticmethod
+ def __recursive_popfunc(parent_item: QW.QTreeWidgetItem, node: BaseNode) -> None:
+ """Recursive HDF5 analysis
+
+ Args:
+ parent_item: Parent tree item
+ node: HDF5 node
+ """
+ tree_item = H5TreeWidget.__create_node(node)
+ if node.is_supported():
+ tree_item.setCheckState(0, QC.Qt.Unchecked)
+ else:
+ tree_item.setFlags(QC.Qt.ItemIsEnabled)
+ tree_item.setIcon(0, get_icon(node.icon_name))
+ parent_item.addChild(tree_item)
+ for child in node.children:
+ H5TreeWidget.__recursive_popfunc(tree_item, child)
+
+ def expand_all_children(self, item: QW.QTreeWidgetItem) -> None:
+ """Expand all children (recursively)
+
+ Args:
+ item: Tree item
+ """
+ self.expandItem(item)
+ for index in range(item.childCount()):
+ child = item.child(index)
+ self.expand_all_children(child)
+
+ def add_root_to_tree(self, importer: H5Importer) -> None:
+ """Add root to tree
+
+ Args:
+ importer: HDF5 importer
+ """
+ root = importer.root
+ rootitem = QW.QTreeWidgetItem([root.name])
+ rootitem.setToolTip(0, root.description)
+ rootitem.setData(0, QC.Qt.UserRole, root.id)
+ rootitem.setFlags(QC.Qt.ItemIsEnabled)
+ rootitem.setIcon(0, get_icon(root.icon_name))
+ self.addTopLevelItem(rootitem)
+ for node in root.children:
+ self.__recursive_popfunc(rootitem, node)
+ self.expandItem(rootitem)
+
+ def toggle_show_only_checkable_items(self, state: bool) -> None:
+ """Show only checkable items
+
+ Args:
+ state: If True, only checkable items are shown
+ """
+ for item in self.find_all_items():
+ item.setHidden(state)
+ if state:
+ # Iterate over checkable items and show them (and their parents)
+ for item in self.find_all_items():
+ if item.flags() & QC.Qt.ItemIsUserCheckable:
+ item.setHidden(False)
+ parent = item.parent()
+ while parent:
+ parent.setHidden(False)
+ parent = parent.parent()
+
+ def toggle_show_values(self, state: bool) -> None:
+ """Show values
+
+ Args:
+ state: If True, values are shown
+ """
+ # Hide or show the "Value" column
+ self.setColumnHidden(3, not state)
+
+ def set_current_file(self, fname: str) -> None:
+ """Set current file
+
+ Args:
+ fname: HDF5 file name
+ """
+ index = self.fnames.index(osp.abspath(fname))
+ item = self.topLevelItem(index)
+ self.setCurrentItem(item)
+ self.scrollToItem(item, QW.QAbstractItemView.PositionAtTop)
+
+
+class PlotPreview(QW.QStackedWidget):
+ """Plot preview"""
+
+ def __init__(self, parent: QW.QWidget) -> None:
+ super().__init__(parent)
+ self.curvewidget = PlotWidget(
+ self,
+ options=PlotOptions(
+ type="curve",
+ curve_antialiasing=True,
+ show_axes_tab=False,
+ autoscale_margin_percent=get_conf().sig_autoscale_margin_percent.get(),
+ ),
+ )
+ self.addWidget(self.curvewidget)
+ self.imagewidget = PlotWidget(
+ self,
+ options=PlotOptions(
+ type="image",
+ show_contrast=True,
+ show_axes_tab=False,
+ autoscale_margin_percent=get_conf().ima_autoscale_margin_percent.get(),
+ ),
+ )
+ self.addWidget(self.imagewidget)
+
+ def cleanup(self) -> None:
+ """Clean up widget"""
+ for widget in (self.imagewidget, self.curvewidget):
+ widget.get_plot().del_all_items()
+
+ def update_plot_preview(self, node: BaseNode) -> None:
+ """Update plot preview widget"""
+ try:
+ obj = node.get_native_object()
+ except Exception as msg: # pylint: disable=broad-except
+ qt_handle_error_message(self, msg)
+ return
+ if obj is None:
+ # An error occurred while creating the object (invalid data, ...)
+ label = make.label(_("Unsupported data"), "C", (0, 0), "C")
+ plot: BasePlot = self.currentWidget().get_plot()
+ plot.del_all_items()
+ plot.add_item(label)
+ plot.replot()
+ return
+ if isinstance(obj, SignalObj):
+ obj: SignalObj
+ widget = self.curvewidget
+ else:
+ obj: ImageObj
+ widget = self.imagewidget
+ with CURVESTYLES.suspend():
+ item = create_adapter_from_object(obj).make_item()
+ plot = widget.get_plot()
+ plot.del_all_items()
+ plot.add_item(item)
+ plot.set_active_item(item)
+ item.unselect()
+ plot.do_autoscale()
+ self.setCurrentWidget(widget)
+
+
+class TablePreview(QW.QWidget):
+ """Table preview
+
+ Args:
+ title: Group title
+ parent: Parent widget
+ """
+
+ def __init__(self, parent: QW.QWidget) -> None:
+ super().__init__(parent)
+ self.setLayout(QW.QVBoxLayout())
+ self.table = QW.QTableWidget(self)
+ self.table.setEditTriggers(QW.QAbstractItemView.NoEditTriggers)
+ self.table.horizontalHeader().setStretchLastSection(True)
+ self.layout().addWidget(self.table)
+
+ def clear(self) -> None:
+ """Clear table"""
+ self.table.clear()
+
+ def update_table_preview(self, data: dict[str, Any]) -> None:
+ """Update table preview widget
+
+ Args:
+ node: HDF5 node
+ """
+ self.clear()
+ self.table.setRowCount(len(data))
+ self.table.setColumnCount(1)
+ self.table.setHorizontalHeaderLabels([_("Value")])
+ self.table.setVerticalHeaderLabels(list(data.keys()))
+ for row, value in enumerate(data.values()):
+ self.table.setItem(row, 0, QW.QTableWidgetItem(str(value)))
+ self.table.resizeRowsToContents()
+
+
+class GroupAndAttributes(QW.QTabWidget):
+ """Group and attributes
+
+ Args:
+ parent: Parent widget
+ show_array_callback: Callback to show array
+ """
+
+ def __init__(self, parent: QW.QWidget, show_array_callback: Callable) -> None:
+ super().__init__(parent)
+ self.group = TablePreview(self)
+ self.addTab(self.group, get_icon("h5group.svg"), _("Group"))
+ self.attrs = TablePreview(self)
+ self.addTab(self.attrs, get_icon("h5attrs.svg"), _("Attributes"))
+ # Add a button as corner widget to show the array (if any):
+ self.__show_array_btn = create_toolbutton(
+ self,
+ icon=get_icon("show_results.svg"),
+ text=_("Show array"),
+ autoraise=False,
+ triggered=show_array_callback,
+ )
+ self.__show_array_btn.setEnabled(False)
+ self.setCornerWidget(self.__show_array_btn, QC.Qt.TopRightCorner)
+
+ def cleanup(self) -> None:
+ """Clean up widget"""
+ self.group.clear()
+ self.attrs.clear()
+
+ def update_from_node(self, node: BaseNode) -> None:
+ """Update widget from node
+
+ Args:
+ node: HDF5 node
+ """
+ # Update group =================================================================
+ text = to_string(node.text)
+ if text:
+ lines = text.splitlines()[:5]
+ if len(lines) == 5:
+ lines += ["[...]"]
+ text = os.linesep.join(lines)
+ data = {
+ _("Path"): node.id,
+ _("Name"): node.name,
+ _("Description"): node.description,
+ _("Textual preview"): text,
+ # "Raw": repr(node.data),
+ }
+ self.group.update_table_preview(data)
+
+ # Update attributes ============================================================
+ self.attrs.update_table_preview(node.metadata)
+
+ # Update show array button =====================================================
+ self.__show_array_btn.setEnabled(node.IS_ARRAY)
+
+
+class H5FileSelector(QW.QWidget):
+ """HDF5 file selector
+
+ Args:
+ parent: Parent widget
+ """
+
+ SIG_ADD_FILENAME = QC.Signal(str)
+ SIG_REMOVE_FILENAME = QC.Signal(str)
+ SIG_CURRENT_CHANGED = QC.Signal(str)
+
+ def __init__(self, parent: QW.QWidget) -> None:
+ super().__init__(parent)
+ self.setLayout(QW.QHBoxLayout())
+ self.layout().setContentsMargins(0, 0, 0, 0)
+ self.combo = QW.QComboBox(self)
+ self.combo.currentTextChanged.connect(self.current_file_changed)
+ self.layout().addWidget(self.combo)
+ self.btn_add = create_toolbutton(
+ self,
+ icon=get_std_icon("DirOpenIcon"),
+ text=_("Open") + " ...",
+ autoraise=False,
+ triggered=lambda _checked=False: self.add_file(),
+ )
+ self.btn_add.setSizePolicy(QW.QSizePolicy.Fixed, QW.QSizePolicy.Fixed)
+ self.layout().addWidget(self.btn_add)
+ self.btn_rmv = create_toolbutton(
+ self,
+ icon=get_std_icon("DialogCloseButton"),
+ text=_("Close"),
+ autoraise=False,
+ triggered=self.remove_file,
+ )
+ self.btn_rmv.setSizePolicy(QW.QSizePolicy.Fixed, QW.QSizePolicy.Fixed)
+ self.layout().addWidget(self.btn_rmv)
+ self.btn_rmv.setEnabled(False)
+
+ def set_current_fname(self, fname: str) -> None:
+ """Set current file name
+
+ Args:
+ fname: HDF5 file name
+ """
+ index = self.combo.findText(fname)
+ if index >= 0:
+ self.combo.setCurrentIndex(index)
+
+ def get_current_fname(self) -> str:
+ """Return current file name
+
+ Returns:
+ HDF5 file name
+ """
+ return self.combo.currentText()
+
+ def current_file_changed(self, fname: str) -> None:
+ """Current file changed
+
+ Args:
+ fname: HDF5 file name
+ """
+ self.SIG_CURRENT_CHANGED.emit(fname)
+
+ def add_fname(self, fname: str) -> None:
+ """Add file name
+
+ Args:
+ fname: HDF5 file name
+ """
+ self.combo.addItem(get_icon("h5file.svg"), fname)
+ self.btn_rmv.setEnabled(True)
+
+ def remove_fname(self, fname: str) -> None:
+ """Remove file name
+
+ Args:
+ fname: HDF5 file name
+ """
+ index = self.combo.findText(fname)
+ if index >= 0:
+ self.combo.removeItem(index)
+ if self.combo.count() == 0:
+ self.btn_rmv.setEnabled(False)
+
+ def add_file(self, fname: str | None = None) -> None:
+ """Browse file
+
+ Args:
+ fname: HDF5 file name. Default is None.
+ (this is used for testing only)
+ """
+ if fname is None:
+ fname = getopenfilename(
+ self,
+ _("Select HDF5 file"),
+ "",
+ _("HDF5 files (*.h5 *.hdf5 *.hdf *.he5);;All files (*)"),
+ )[0]
+ if fname:
+ self.SIG_ADD_FILENAME.emit(osp.abspath(fname))
+
+ def remove_file(self, fname: str | None = None) -> None:
+ """Remove file name
+
+ Args:
+ fname: HDF5 file name
+ """
+ if fname is None:
+ fname = self.combo.currentText()
+ self.SIG_REMOVE_FILENAME.emit(fname)
+
+
+class H5Browser(QW.QSplitter):
+ """HDF5 Browser Widget
+
+ Args:
+ parent: Parent widget
+ """
+
+ SIG_SELECT_NEW_FILE = QC.Signal(str)
+ SIG_REMOVE_FILE = QC.Signal(str)
+
+ def __init__(self, parent: QW.QWidget | None = None) -> None:
+ super().__init__(parent)
+ if parent is None:
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ self.selector = H5FileSelector(self)
+ self.selector.SIG_ADD_FILENAME.connect(self.__add_new_file)
+ self.selector.SIG_REMOVE_FILENAME.connect(self.__remove_file)
+ self.selector.SIG_CURRENT_CHANGED.connect(self.__selector_current_file_changed)
+ self.tree = H5TreeWidget(self)
+ self.tree.SIG_SELECTED.connect(self.__item_selected_on_tree)
+ selectorandtree = QW.QFrame(self)
+ selectorandtree.setLayout(QW.QVBoxLayout())
+ selectorandtree.layout().addWidget(self.selector)
+ # Add toolbar with tree actions
+ toolbar = self.__create_toolbar()
+ selectorandtree.layout().addWidget(toolbar)
+ selectorandtree.layout().addWidget(self.tree)
+ selectorandtree.layout().setContentsMargins(0, 0, 0, 0)
+ self.addWidget(selectorandtree)
+ preview = QW.QSplitter(self)
+ preview.setOrientation(QC.Qt.Vertical)
+ self.addWidget(preview)
+ self.plotpreview = PlotPreview(self)
+ preview.addWidget(self.plotpreview)
+ self.groupandattrs = GroupAndAttributes(self, self.show_array)
+ preview.addWidget(self.groupandattrs)
+ preview.setSizes([int(self.size().height() / 2)] * 2)
+
+ def __create_toolbar(self) -> QW.QToolBar:
+ """Create toolbar with tree actions
+
+ Returns:
+ Toolbar widget
+ """
+ toolbar = QW.QToolBar(self)
+ toolbar.setToolButtonStyle(QC.Qt.ToolButtonTextBesideIcon)
+ toolbar.setIconSize(QC.QSize(16, 16))
+ toolbar.setStyleSheet("QToolBar { padding: 2px; spacing: 2px; }")
+ toolbar.addAction(self.tree.expand_all_action)
+ toolbar.addAction(self.tree.collapse_all_action)
+ toolbar.addAction(self.tree.restore_action)
+ toolbar.addSeparator()
+ toolbar.addAction(self.tree.expand_selection_action)
+ toolbar.addAction(self.tree.collapse_selection_action)
+ return toolbar
+
+ def open_file(self, fname: str) -> None:
+ """Open HDF5 file
+
+ Args:
+ fname: HDF5 file name
+ """
+ self.tree.add_root(fname)
+ self.selector.add_fname(fname)
+
+ def close_file(self, fname: str) -> None:
+ """Close HDF5 file
+
+ Args:
+ fname: HDF5 file name
+ """
+ self.tree.remove_root(fname)
+ self.selector.remove_fname(fname)
+
+ def __add_new_file(self, fname: str) -> None:
+ """Add new file
+
+ Args:
+ fname: HDF5 file name
+ """
+ self.open_file(fname)
+ self.selector.set_current_fname(fname)
+ self.SIG_SELECT_NEW_FILE.emit(fname)
+
+ def __remove_file(self, fname: str) -> None:
+ """Remove file
+
+ Args:
+ fname: HDF5 file name
+ """
+ self.close_file(fname)
+ self.SIG_REMOVE_FILE.emit(fname)
+
+ def cleanup(self) -> None:
+ """Clean up widget"""
+ self.tree.cleanup()
+ self.plotpreview.cleanup()
+
+ def get_node(self, item: QW.QTreeWidgetItem | None = None) -> BaseNode:
+ """Return (selected) dataset
+
+ Args:
+ item: Tree item
+
+ Returns:
+ HDF5 node
+ """
+ if item is None:
+ item = self.tree.currentItem()
+ return self.tree.get_node(item)
+
+ def __item_selected_on_tree(self, item: QW.QTreeWidgetItem) -> None:
+ """Item selected on tree
+
+ Args:
+ item: Tree item
+ """
+ # View the selected item
+ node = self.get_node(item)
+ if node.is_supported():
+ self.plotpreview.update_plot_preview(node)
+ self.groupandattrs.update_from_node(node)
+ # Update the file selector combo box
+ with block_signals(self.selector.combo):
+ # Avoid triggering current file changed signal, which would result in
+ # loosing the current selection on the tree (side effect: "Show array"
+ # button would still be enabled if the previous node was an array, except
+ # that now the current node is not an array, thus causing an error if
+ # the user clicks on the button).
+ self.selector.set_current_fname(node.h5file.filename)
+
+ def __selector_current_file_changed(self, fname: str) -> None:
+ """Selector current file changed
+
+ Args:
+ fname: HDF5 file name
+ """
+ if fname:
+ self.tree.set_current_file(fname)
+
+ def show_array(self) -> None:
+ """Show array"""
+ node = self.get_node()
+ assert node.IS_ARRAY
+ arrayeditor = ArrayEditor(self)
+ arrayeditor.setup_and_check(
+ node.data, title=node.name, readonly=True, add_title_suffix=False
+ )
+ exec_dialog(arrayeditor)
+
+
+class H5BrowserDialog(QW.QDialog):
+ """HDF5 Browser Dialog
+
+ Args:
+ parent: Parent widget
+ size: Dialog size
+ """
+
+ def __init__(
+ self, parent: QW.QWidget | None = None, size: tuple[int, int] = (1150, 700)
+ ) -> None:
+ super().__init__(parent)
+ self.setWindowFlags(QC.Qt.Window)
+ self.setObjectName("h5browser")
+ self.setWindowTitle(_("HDF5 Browser"))
+ self.setWindowIcon(get_icon("h5browser.svg"))
+ win32_fix_title_bar_background(self)
+ vlayout = QW.QVBoxLayout()
+ self.setLayout(vlayout)
+ self.button_layout: QW.QHBoxLayout | None = None
+ self.bbox: QW.QDialogButtonBox | None = None
+ self.nodes: list[BaseNode] = []
+ self.checkbox_show_only: QW.QCheckBox | None = None
+ self.checkbox_show_values: QW.QCheckBox | None = None
+
+ self.browser = H5Browser(self)
+ self.browser.SIG_SELECT_NEW_FILE.connect(self.select_new_file)
+ self.browser.SIG_REMOVE_FILE.connect(self.remove_file)
+ vlayout.addWidget(self.browser)
+
+ self.browser.tree.itemChanged.connect(lambda item: self.refresh_buttons())
+
+ self.install_button_layout()
+
+ self.setMinimumSize(QC.QSize(900, 500))
+ self.resize(QC.QSize(*size))
+ self.browser.setSizes([int(self.size().height() / 2)] * 2)
+ self.refresh_buttons()
+
+ def accept(self) -> None:
+ """Accept changes"""
+ self.nodes = self.browser.tree.get_nodes()
+ QW.QDialog.accept(self)
+
+ def is_empty(self) -> bool:
+ """Return True if tree is empty"""
+ return self.browser.tree.is_empty()
+
+ def cleanup(self) -> None:
+ """Cleanup dialog"""
+ self.browser.cleanup()
+
+ def refresh_buttons(self) -> None:
+ """Refresh buttons"""
+ state = self.browser.tree.is_any_item_checked()
+ self.bbox.button(QW.QDialogButtonBox.Ok).setEnabled(state)
+
+ def show_only_checkable_items(self, state: int) -> None:
+ """Show only checkable items
+
+ Args:
+ state: If True, only checkable items are shown
+ """
+ self.browser.tree.toggle_show_only_checkable_items(state)
+ fname = self.browser.selector.get_current_fname()
+ if fname:
+ self.browser.tree.set_current_file(fname)
+
+ def __finalize_setup(self) -> None:
+ """Finalize setup"""
+ tree = self.browser.tree
+ tree.toggle_show_only_checkable_items(self.checkbox_show_only.isChecked())
+ tree.toggle_show_values(self.checkbox_show_values.isChecked())
+
+ def open_file(self, fname: str) -> None:
+ """Open file
+
+ Args:
+ fname: HDF5 file name
+ """
+ self.browser.open_file(fname)
+ self.__finalize_setup()
+
+ def open_files(self, fnames: list[str]) -> None:
+ """Open files
+
+ Args:
+ fnames: HDF5 file names
+ """
+ for fname in fnames:
+ self.browser.open_file(fname)
+ self.__finalize_setup()
+
+ def select_new_file(self, fname: str) -> None: # pylint:disable=unused-argument
+ """Select new file
+
+ Args:
+ fname: HDF5 file name
+ """
+ self.__finalize_setup()
+ self.refresh_buttons()
+
+ def remove_file(self, fname: str) -> None: # pylint:disable=unused-argument
+ """Remove file
+
+ Args:
+ fname: HDF5 file name
+ """
+ self.refresh_buttons()
+
+ def get_all_nodes(self) -> list[BaseNode]:
+ """Return all supported datasets
+
+ Returns:
+ List of HDF5 nodes
+ """
+ return self.browser.tree.get_nodes(only_checked_items=False)
+
+ def get_nodes(self) -> list[BaseNode]:
+ """Return datasets
+
+ Returns:
+ List of HDF5 nodes
+ """
+ return self.nodes
+
+ def install_button_layout(self) -> None:
+ """Install button layout"""
+ bbox = QW.QDialogButtonBox(QW.QDialogButtonBox.Ok | QW.QDialogButtonBox.Cancel)
+ bbox.accepted.connect(self.accept)
+ bbox.rejected.connect(self.reject)
+
+ btn_check_all = create_toolbutton(
+ self,
+ icon=get_icon("check_all.svg"),
+ text=_("Check all"),
+ autoraise=False,
+ shortcut=QG.QKeySequence.SelectAll,
+ triggered=lambda checked=True: self.browser.tree.toggle_all(checked),
+ )
+ btn_uncheck_all = create_toolbutton(
+ self,
+ icon=get_icon("uncheck_all.svg"),
+ text=_("Uncheck all"),
+ autoraise=False,
+ triggered=lambda checked=False: self.browser.tree.toggle_all(checked),
+ )
+ self.checkbox_show_only = QW.QCheckBox(_("Show only supported data"))
+ self.checkbox_show_only.stateChanged.connect(self.show_only_checkable_items)
+ self.checkbox_show_values = QW.QCheckBox(_("Show values"))
+ self.checkbox_show_values.stateChanged.connect(
+ self.browser.tree.toggle_show_values
+ )
+
+ self.button_layout = QW.QHBoxLayout()
+ self.button_layout.addWidget(self.checkbox_show_only)
+ self.button_layout.addWidget(self.checkbox_show_values)
+ self.button_layout.addSpacing(10)
+ self.button_layout.addWidget(btn_check_all)
+ self.button_layout.addWidget(btn_uncheck_all)
+ self.button_layout.addStretch()
+ self.button_layout.addWidget(bbox)
+ self.bbox = bbox
+
+ vlayout: QW.QVBoxLayout = self.layout()
+ vlayout.addSpacing(10)
+ vlayout.addLayout(self.button_layout)
diff --git a/sigimax/widgets/imagebackground.py b/sigimax/widgets/imagebackground.py
new file mode 100644
index 0000000..19bab80
--- /dev/null
+++ b/sigimax/widgets/imagebackground.py
@@ -0,0 +1,128 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Image background selection dialog.
+
+.. autoclass:: ImageBackgroundDialog
+ :members:
+"""
+
+# pylint: disable=invalid-name # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+import numpy as np
+from guidata.configtools import get_icon
+from plotpy.builder import make
+from plotpy.plot import PlotDialog, PlotOptions
+
+from sigimax.adapters_plotpy import create_adapter_from_object
+from sigimax.config import _, get_conf
+from sigimax.utils.qthelpers import resize_widget_to_parent
+
+__all__ = [
+ "ImageBackgroundDialog",
+]
+
+if TYPE_CHECKING:
+ from plotpy.items import MaskedXYImageItem, RangeComputation2d, RectangleShape
+ from qtpy.QtWidgets import QWidget
+ from sigima.objects import ImageObj
+
+
+class ImageBackgroundDialog(PlotDialog):
+ """Image background selection dialog.
+
+ Args:
+ image: image object
+ parent: parent widget. Defaults to None.
+ options: plot options. Defaults to None.
+ """
+
+ def __init__(
+ self,
+ image: ImageObj,
+ parent: QWidget | None = None,
+ options: PlotOptions | dict[str, Any] | None = None,
+ ) -> None:
+ self.__background: float | None = None
+ self.__rect_coords: tuple[float, float, float, float] | None = None
+ self.imageitem: MaskedXYImageItem | None = None
+ self.rectarea: RectangleShape | None = None
+ self.comput2d: RangeComputation2d | None = None
+ super().__init__(
+ title=_("Image background selection"),
+ edit=True,
+ parent=parent,
+ options=options,
+ )
+ self.setObjectName("backgroundselection")
+ if parent is None:
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ else:
+ resize_widget_to_parent(self, aspect_ratio=1.0)
+ self.__image = image.copy()
+ self.__setup_dialog()
+
+ def test_compute_background(self) -> None:
+ """Method to test background computation."""
+ # Instead of waiting for Qt events, directly test the computation method
+ # by simulating what RangeComputation2d would do
+ x0, y0, x1, y1 = self.rectarea.get_rect()
+ x, y, z = self.imageitem.get_data(x0, y0, x1, y1)
+ self.__compute_background(x, y, z)
+
+ def __compute_background(
+ self,
+ x: np.ndarray, # pylint: disable=unused-argument
+ y: np.ndarray, # pylint: disable=unused-argument
+ z: np.ndarray,
+ ) -> float:
+ """Compute background value"""
+ self.__rect_coords = self.rectarea.get_rect()
+ self.__background = z.mean()
+ return self.__background
+
+ def __setup_dialog(self) -> None:
+ """Setup dialog box"""
+ obj = self.__image
+ self.imageitem = create_adapter_from_object(obj).make_item()
+ plot = self.get_plot()
+ if obj.is_uniform_coords:
+ x0, y0 = obj.x0, obj.y0
+ x1, y1 = obj.xc + obj.dx, obj.yc + obj.dy
+ else:
+ x0, y0 = obj.xcoords[0], obj.ycoords[0]
+ xc = (obj.xcoords[0] + obj.xcoords[-1]) / 2
+ yc = (obj.ycoords[0] + obj.ycoords[-1]) / 2
+ x1, y1 = xc, yc
+ self.rectarea = make.rectangle(x0, y0, x1, y1, _("Background area"))
+ self.comput2d = make.computation2d(
+ self.rectarea,
+ "TL",
+ _("Background value:") + " %g",
+ self.imageitem,
+ self.__compute_background,
+ )
+ for item in (self.imageitem, self.rectarea, self.comput2d):
+ plot.add_item(item)
+ plot.replot()
+ plot.set_active_item(self.rectarea)
+
+ def get_background(self) -> float:
+ """Get background value"""
+ return self.__background
+
+ def get_rect_coords(self) -> tuple[float, float, float, float]:
+ """Get rectangle coordinates
+
+ Returns:
+ tuple: rectangle coordinates (x0, y0, x1, y1)
+
+ Raises:
+ ValueError: if rectangle coordinates are not set
+ """
+ if self.__rect_coords is None:
+ raise ValueError("Rectangle coordinates not set")
+ return self.__rect_coords
diff --git a/sigimax/widgets/logviewer.py b/sigimax/widgets/logviewer.py
new file mode 100644
index 0000000..fd2978a
--- /dev/null
+++ b/sigimax/widgets/logviewer.py
@@ -0,0 +1,94 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Module providing a log viewer widget, a log viewer window and SigimaX's log viewer
+
+.. autoclass:: LogViewerWindow
+ :members:
+.. autofunction:: get_log_filenames
+.. autofunction:: get_log_prompt_message
+.. autofunction:: exec_sigimax_logviewer_dialog
+"""
+
+from __future__ import annotations
+
+import os.path as osp
+
+from guidata.configtools import get_icon
+from guidata.qthelpers import exec_dialog
+from qtpy import QtWidgets as QW
+
+from sigimax.config import _, get_conf, get_old_log_fname
+from sigimax.env import execenv
+from sigimax.widgets.fileviewer import FileViewerWidget, get_title_contents
+
+__all__ = [
+ "LogViewerWindow",
+ "exec_sigimax_logviewer_dialog",
+ "get_log_filenames",
+ "get_log_prompt_message",
+]
+
+
+class LogViewerWindow(QW.QDialog):
+ """Log viewer window"""
+
+ def __init__(self, fnames: list[str], parent: QW.QWidget | None = None) -> None:
+ super().__init__(parent)
+ self.setObjectName("logviewer")
+ self.setWindowTitle(get_conf().app_name.get() + " - " + _("Log files"))
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ self.tabs = QW.QTabWidget(self)
+ for fname in fnames:
+ if osp.isfile(fname):
+ title, contents = get_title_contents(fname)
+ if not contents.strip():
+ continue
+ viewer = FileViewerWidget(language="Python")
+ viewer.set_data(title, contents)
+ self.tabs.addTab(viewer, get_icon("logs.svg"), osp.basename(fname))
+ layout = QW.QVBoxLayout()
+ layout.addWidget(self.tabs)
+ self.setLayout(layout)
+ self.resize(900, 400)
+
+ @property
+ def is_empty(self) -> bool:
+ """Return True if there is no log available"""
+ return self.tabs.count() == 0
+
+
+def get_log_filenames() -> list[str]:
+ """Return log filenames"""
+ conf = get_conf()
+ return [
+ conf.traceback_log_path.get(),
+ conf.faulthandler_log_path.get(),
+ get_old_log_fname(conf.traceback_log_path.get()),
+ get_old_log_fname(conf.faulthandler_log_path.get()),
+ ]
+
+
+def get_log_prompt_message() -> str | None:
+ """Return prompt message for log files, i.e. a message informing the user
+ whether log files were generated during last session or current session."""
+ avail = [osp.isfile(fname) for fname in get_log_filenames()]
+ if avail[0] or avail[1]:
+ return _("Log files were generated during current session.")
+ if avail[2] or avail[3]:
+ return _("Log files were generated during last session.")
+ return None
+
+
+def exec_sigimax_logviewer_dialog(parent: QW.QWidget | None = None) -> None:
+ """View SigimaX logs"""
+ fnames = [osp.normpath(fname) for fname in get_log_filenames() if osp.isfile(fname)]
+ dlg = LogViewerWindow(fnames, parent=parent)
+ if dlg.is_empty:
+ if not execenv.unattended:
+ QW.QMessageBox.information(
+ dlg, get_conf().app_name.get(), _("Log files are currently empty.")
+ )
+ dlg.close()
+ else:
+ exec_dialog(dlg)
diff --git a/sigimax/widgets/plotdock.py b/sigimax/widgets/plotdock.py
new file mode 100644
index 0000000..fb68dd8
--- /dev/null
+++ b/sigimax/widgets/plotdock.py
@@ -0,0 +1,413 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Docks
+=====
+
+The :mod:`sigimax.widgets.plotdock` module provides the dockable plot widgets
+for the SigimaX main window.
+
+Plot widget
+-----------
+
+.. autoclass:: SigimaXPlotWidget
+
+Dockable plot widget
+--------------------
+
+.. autoclass:: DockablePlotWidget
+"""
+
+from __future__ import annotations
+
+__all__ = [
+ "CurveStatsToolFunctions",
+ "DockablePlotWidget",
+ "SigimaXPlotWidget",
+]
+
+import warnings
+from typing import TYPE_CHECKING
+
+import numpy as np
+from guidata.qthelpers import is_dark_theme
+from guidata.widgets.dockable import DockableWidget
+from plotpy.constants import PlotType
+from plotpy.plot import PlotOptions, PlotWidget
+from plotpy.tools import (
+ BasePlotMenuTool,
+ CurveStatsTool,
+ DeleteItemTool,
+ DisplayCoordsTool,
+ DoAutoscaleTool,
+ EditItemDataTool,
+ ExportItemDataTool,
+ ImageStatsTool,
+ ItemCenterTool,
+ RectangularSelectionTool,
+ RectZoomTool,
+ SelectTool,
+ YRangeCursorTool,
+)
+from plotpy.tools.image import get_stats as get_image_stats
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+from qtpy.QtWidgets import QApplication
+from sigima.tools.signal import pulse
+from skimage import measure
+
+from sigimax.config import get_conf
+
+if TYPE_CHECKING:
+ from plotpy.items.image.base import BaseImageItem
+ from plotpy.plot import BasePlot
+ from plotpy.styles import BaseImageParam
+
+
+class CurveStatsToolFunctions:
+ """Statistical functions for `CurveStatsTool` and `YRangeCursorTool`"""
+
+ @classmethod
+ def set_labelfuncs(cls, statstool: CurveStatsTool | YRangeCursorTool) -> None:
+ """Set label functions for the statistics tool"""
+ if isinstance(statstool, CurveStatsTool):
+ labelfuncs = list(CurveStatsTool.LABELFUNCS)
+ labelfuncs[-1] = (labelfuncs[-1][0] + "
", labelfuncs[-1][1])
+ labelfuncs.extend(
+ [
+ ("FWHM=%s", cls.fwhm_info),
+ ("∆xRISE 10-90=%s", cls.rise_time_info),
+ (
+ "∆xRISE 20-80=%s",
+ lambda x, y: cls.rise_time_info(x, y, 0.2, 0.8),
+ ),
+ ("∆xFALL 90-10=%s", cls.fall_time_info),
+ (
+ "∆xFALL 80-20=%s",
+ lambda x, y: cls.fall_time_info(x, y, 0.8, 0.2),
+ ),
+ ]
+ )
+ statstool.set_labelfuncs(tuple(labelfuncs))
+ else: # YRangeCursorTool - use PlotPy's defaults as-is
+ statstool.set_labelfuncs(YRangeCursorTool.LABELFUNCS)
+
+ @staticmethod
+ def fwhm_info(x, y):
+ """Return FWHM information string"""
+ try:
+ with warnings.catch_warnings(record=True) as w:
+ x0, _y0, x1, _y1 = pulse.fwhm(x, y, "zero-crossing")
+ wstr = " ⚠️" if w else ""
+ except (ValueError, ZeroDivisionError, pulse.InvalidSignalError):
+ return "🛑"
+ return f"{x1 - x0:g}{wstr}"
+
+ @staticmethod
+ def rise_time_info(x, y, start_ratio=0.1, end_ratio=0.9):
+ """Return rise time information string"""
+ try:
+ with warnings.catch_warnings(record=True) as w:
+ dt = pulse.get_rise_time(x, y, start_ratio, end_ratio)
+ wstr = " ⚠️" if w else ""
+ if dt is None:
+ return "🛑"
+ except (ValueError, ZeroDivisionError, pulse.InvalidSignalError):
+ return "🛑"
+ return f"{dt:g}{wstr}"
+
+ @staticmethod
+ def fall_time_info(x, y, start_ratio=0.9, end_ratio=0.1):
+ """Return fall time information string"""
+ try:
+ with warnings.catch_warnings(record=True) as w:
+ dt = pulse.get_fall_time(x, y, start_ratio, end_ratio)
+ wstr = " ⚠️" if w else ""
+ if dt is None:
+ return "🛑"
+ except (ValueError, ZeroDivisionError, pulse.InvalidSignalError):
+ return "🛑"
+ return f"{dt:g}{wstr}"
+
+
+def get_more_image_stats(
+ item: BaseImageItem,
+ x0: float,
+ y0: float,
+ x1: float,
+ y1: float,
+) -> str:
+ """Return formatted string with stats on image rectangular area
+ (output should be compatible with AnnotatedShape.get_info)
+
+ Args:
+ item: image item
+ x0: X0
+ y0: Y0
+ x1: X1
+ y1: Y1
+ """
+ with warnings.catch_warnings():
+ warnings.simplefilter("ignore", UserWarning)
+ info = get_image_stats(item, x0, y0, x1, y1)
+
+ ix0, iy0, ix1, iy1 = item.get_closest_index_rect(x0, y0, x1, y1)
+ data = item.data[iy0:iy1, ix0:ix1]
+ p: BaseImageParam = item.param
+ xunit, yunit, zunit = p.get_units()
+
+ integral = np.nansum(data)
+ integral_fmt = r"%.3e " + zunit
+ info += f"
∑ = {integral_fmt % integral}"
+
+ if xunit == yunit:
+ surfacefmt = p.xformat.split()[0] + " " + xunit
+ if xunit != "":
+ surfacefmt = surfacefmt + "²"
+ surface = abs((x1 - x0) * (y1 - y0))
+ info += f"
A = {surfacefmt % surface}"
+ if xunit is not None and zunit is not None:
+ if surface != 0:
+ density = integral / surface
+ densityfmt = r"%.3e"
+ if xunit and zunit:
+ densityfmt += " " + zunit + "/" + xunit + "²"
+ info = info + f"
ρ = {densityfmt % density}"
+ # Convert data (ndarray) to a simple array to compute centroid with the new
+ # einsum optimisation introduce in numpy 2.4.0 and scikit-image 0.26.0
+ c_i, c_j = measure.centroid(np.array(data))
+ c_x, c_y = item.get_plot_coordinates(c_j + ix0, c_i + iy0)
+ info += "
" + "
".join(
+ [
+ "C|x = " + p.xformat % c_x,
+ "C|y = " + p.yformat % c_y,
+ ]
+ )
+
+ return info
+
+
+class SigimaXPlotWidget(PlotWidget):
+ """SigimaX PlotWidget
+
+ This class is a subclass of `plotpy.plot.PlotWidget` that provides a
+ customized widget for SigimaX, with a specific set of tools and a
+ customized appearance.
+
+ Args:
+ plot_type: Plot type
+ """
+
+ def __init__(self, plot_type: PlotType) -> None:
+ # Get autoscale margin from configuration based on plot type
+ conf = get_conf()
+ if plot_type == PlotType.CURVE:
+ autoscale_margin = conf.sig_autoscale_margin_percent.get()
+ elif plot_type == PlotType.IMAGE:
+ autoscale_margin = conf.ima_autoscale_margin_percent.get()
+ else:
+ # For AUTO or MANUAL types, use signal margin as default
+ autoscale_margin = conf.sig_autoscale_margin_percent.get()
+
+ super().__init__(
+ options=PlotOptions(
+ type=plot_type,
+ show_axes_tab=False,
+ autoscale_margin_percent=autoscale_margin,
+ ),
+ toolbar=True,
+ )
+
+ def __register_standard_tools(self) -> None:
+ """Register standard tools
+
+ The only differences with the `manager.register_standard_tools` method are
+ the following:
+
+ 1. We don't register the `BasePlotMenuTool, "axes"` tool, because it is not
+ compatible with SigimaX's apps approach to axes management.
+ 2. We don't register the `ItemListPanelTool` tool (this intends to prevent
+ the user from accessing the item list panel, and thus, the parameters of all
+ the items - some of them are read-only and should not be modified, like the
+ annotations for example).
+ """
+ mgr = self.manager
+ select_tool = mgr.add_tool(SelectTool)
+ mgr.set_default_tool(select_tool)
+ mgr.add_tool(RectangularSelectionTool, intersect=False)
+ mgr.add_tool(RectZoomTool)
+ mgr.add_tool(DoAutoscaleTool)
+ mgr.add_tool(BasePlotMenuTool, "item")
+ mgr.add_tool(ExportItemDataTool)
+ mgr.add_tool(EditItemDataTool)
+ mgr.add_tool(ItemCenterTool)
+ mgr.add_tool(DeleteItemTool)
+ mgr.add_separator_tool()
+ mgr.add_tool(BasePlotMenuTool, "grid")
+ mgr.add_tool(DisplayCoordsTool)
+
+ def __register_other_tools(self) -> None:
+ """Register other tools"""
+ mgr = self.manager
+ mgr.add_separator_tool()
+ if self.options.type == PlotType.CURVE:
+ mgr.register_curve_tools()
+ xstatstool = mgr.get_tool(CurveStatsTool)
+ CurveStatsToolFunctions.set_labelfuncs(xstatstool)
+ ystatstool = mgr.get_tool(YRangeCursorTool)
+ CurveStatsToolFunctions.set_labelfuncs(ystatstool)
+ else:
+ mgr.register_image_tools()
+ # Customizing the ImageStatsTool
+ statstool = mgr.get_tool(ImageStatsTool)
+ statstool.set_stats_func(get_more_image_stats, replace=True)
+ self._customize_image_panels()
+
+ mgr.add_separator_tool()
+ mgr.register_other_tools()
+ mgr.add_separator_tool()
+ mgr.update_tools_status()
+ mgr.get_default_tool().activate()
+
+ def _customize_image_panels(self) -> None:
+ """Customize the X and Y cross section panels.
+
+ Called once the image tools are registered, so that the panels and their
+ toolbars exist. The base implementation is a no-op.
+ """
+
+ def register_tools(self) -> None:
+ """Register the plotting tools according to the plot type"""
+ self.__register_standard_tools()
+ self.__register_other_tools()
+
+
+# Mapping from config string to Qt dock area constant
+_DOCK_LOCATION_MAP: dict[str, QC.Qt.DockWidgetArea] = {
+ "top": QC.Qt.TopDockWidgetArea,
+ "bottom": QC.Qt.BottomDockWidgetArea,
+ "left": QC.Qt.LeftDockWidgetArea,
+ "right": QC.Qt.RightDockWidgetArea,
+}
+
+
+class DockablePlotWidget(DockableWidget):
+ """Docked plotting widget
+
+ Args:
+ parent: Parent widget
+ plot_type: Plot type
+ """
+
+ LOCATION = QC.Qt.RightDockWidgetArea
+
+ #: Plot widget class instantiated by this dock: override in subclasses to
+ #: provide an application-specific one.
+ PLOTWIDGET_CLASS: type[SigimaXPlotWidget] = SigimaXPlotWidget
+
+ def __init__(
+ self,
+ parent: QW.QWidget,
+ plot_type: PlotType,
+ ) -> None:
+ super().__init__(parent)
+ self._apply_dock_location()
+ self.plotwidget = self.PLOTWIDGET_CLASS(plot_type)
+ self.toolbar = self.plotwidget.get_toolbar()
+ self.watermark: QW.QLabel | None = None
+ self._setup_watermark()
+ self.setup_layout()
+ self.setup_plotwidget()
+
+ def _apply_dock_location(self) -> None:
+ """Set dock location from config."""
+ location_str = get_conf().plot_dock_location.get()
+ location = _DOCK_LOCATION_MAP.get(location_str, QC.Qt.RightDockWidgetArea)
+ self.setup_dockwidget(location=location)
+
+ def _setup_watermark(self) -> None:
+ """Create the watermark label from the configured image path.
+
+ If ``Conf.watermark_image_path`` is empty, no watermark is created.
+ """
+ path = get_conf().watermark_image_path.get()
+ if path:
+ self.watermark = QW.QLabel()
+ pixmap = QG.QPixmap(path)
+ self.watermark.setPixmap(pixmap)
+ else:
+ self.watermark = None
+
+ def __get_toolbar_row_col(self) -> tuple[int, int]:
+ """Return toolbar row and column"""
+ tb_pos = get_conf().plot_toolbar_position.get()
+ tb_col, tb_row = 1, 1
+ if tb_pos in ("left", "right"):
+ self.toolbar.setOrientation(QC.Qt.Vertical)
+ tb_col = 0 if tb_pos == "left" else 2
+ else:
+ self.toolbar.setOrientation(QC.Qt.Horizontal)
+ tb_row = 0 if tb_pos == "top" else 2
+ return tb_row, tb_col
+
+ def setup_layout(self) -> None:
+ """Setup layout"""
+ tb_row, tb_col = self.__get_toolbar_row_col()
+ layout = QW.QGridLayout()
+ layout.addWidget(self.toolbar, tb_row, tb_col)
+ layout.addWidget(self.plotwidget, 1, 1)
+ if self.watermark is not None:
+ layout.addWidget(self.watermark, 1, 1, QC.Qt.AlignCenter)
+ self.setLayout(layout)
+
+ def update_toolbar_position(self) -> None:
+ """Update toolbar position"""
+ tb_row, tb_col = self.__get_toolbar_row_col()
+ layout = self.layout()
+ layout.removeWidget(self.toolbar)
+ layout.addWidget(self.toolbar, tb_row, tb_col)
+
+ def setup_plotwidget(self) -> None:
+ """Setup plotting widget"""
+ title = self.toolbar.windowTitle()
+ self.plotwidget.get_manager().add_toolbar(self.toolbar, title)
+ # Customizing widget appearances
+ self.update_color_mode()
+ plot = self.plotwidget.get_plot()
+ canvas = plot.canvas()
+ canvas.setFrameStyle(canvas.Plain | canvas.NoFrame)
+ if self.watermark is not None:
+ plot.SIG_ITEMS_CHANGED.connect(self.update_watermark)
+
+ def update_color_mode(self) -> None:
+ """Update plot widget styles according to application color mode"""
+ if is_dark_theme():
+ palette = QApplication.instance().palette()
+ else:
+ palette = QG.QPalette(QC.Qt.white)
+ for widget in (self.plotwidget, self.plotwidget.get_plot(), self):
+ widget.setBackgroundRole(QG.QPalette.Window)
+ widget.setAutoFillBackground(True)
+ widget.setPalette(palette)
+
+ def get_plot(self) -> BasePlot:
+ """Return plot instance"""
+ return self.plotwidget.get_plot()
+
+ def update_watermark(self, plot: BasePlot) -> None:
+ """Update watermark visibility"""
+ if self.watermark is None:
+ return
+ items = plot.get_items()
+ if self.plotwidget.options.type == PlotType.IMAGE:
+ enabled = len(items) <= 1
+ else:
+ enabled = len(items) <= 2
+ self.watermark.setVisible(enabled)
+
+ # ------DockableWidget API
+ def visibility_changed(self, enable: bool) -> None:
+ """DockWidget visibility has changed"""
+ DockableWidget.visibility_changed(self, enable)
+ self.toolbar.setVisible(enable)
diff --git a/sigimax/widgets/signalbaseline.py b/sigimax/widgets/signalbaseline.py
new file mode 100644
index 0000000..7050622
--- /dev/null
+++ b/sigimax/widgets/signalbaseline.py
@@ -0,0 +1,98 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Signal base line selection dialog.
+
+.. autoclass:: SignalBaselineDialog
+ :members:
+"""
+
+# pylint: disable=invalid-name # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from guidata.configtools import get_icon
+from plotpy.builder import make
+from plotpy.plot import PlotDialog
+
+from sigimax.adapters_plotpy import CURVESTYLES, create_adapter_from_object
+from sigimax.config import _, get_conf
+from sigimax.utils.qthelpers import resize_widget_to_parent
+
+__all__ = [
+ "SignalBaselineDialog",
+]
+
+if TYPE_CHECKING:
+ from plotpy.items import CurveItem, Marker, XRangeSelection
+ from qtpy.QtWidgets import QWidget
+ from sigima.objects import SignalObj
+
+
+class SignalBaselineDialog(PlotDialog):
+ """Signal baseline selection dialog.
+
+ Args:
+ signal: signal object
+ parent: parent widget. Defaults to None.
+ """
+
+ def __init__(self, signal: SignalObj, parent: QWidget | None = None) -> None:
+ self.__curve_styles = CURVESTYLES.style_generator()
+ self.__baseline: float | None = None
+ self.__x_range: tuple[float, float] = [np.nan, np.nan]
+ self.curve: CurveItem | None = None
+ self.cursor: Marker | None = None
+ self.xrange: XRangeSelection | None = None
+ super().__init__(title=_("Signal baseline selection"), edit=True, parent=parent)
+ self.setObjectName("baselineselection")
+ if parent is None:
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ legend = make.legend("TR")
+ self.get_plot().add_item(legend)
+ self.__signal = signal.copy()
+ self.__setup_dialog()
+ resize_widget_to_parent(self, aspect_ratio=1.0)
+
+ def __setup_dialog(self) -> None:
+ """Setup dialog box"""
+ obj = self.__signal
+ with CURVESTYLES.alternative(self.__curve_styles):
+ self.curve = create_adapter_from_object(obj).make_item()
+ plot = self.get_plot()
+ plot.set_antialiasing(True)
+ plot.SIG_RANGE_CHANGED.connect(self.xrange_changed)
+ plot.SIG_MARKER_CHANGED.connect(self.cursor_changed)
+ self.cursor = make.hcursor(0.0, _("Base line") + " = %g")
+ self.cursor.set_movable(False)
+ self.xrange = make.xrange(obj.x[0], obj.x[int(0.2 * len(obj.x))])
+ for item in (self.curve, self.cursor, self.xrange):
+ plot.add_item(item)
+ plot.replot()
+ plot.set_active_item(self.xrange)
+ self.xrange_changed(self.xrange, *self.xrange.get_range())
+
+ # pylint: disable=unused-argument
+ def xrange_changed(self, item: XRangeSelection, xmin: float, xmax: float) -> None:
+ """X range changed"""
+ self.__x_range = sorted([xmin, xmax])
+ imin, imax = np.searchsorted(self.__signal.x, self.__x_range)
+ if imin == imax:
+ return
+ self.cursor.set_pos(0, np.mean(self.__signal.y[imin:imax]))
+ plot = self.get_plot()
+ plot.replot()
+
+ def cursor_changed(self, item: Marker) -> None:
+ """Cursor changed"""
+ _x, self.__baseline = item.get_pos()
+
+ def get_baseline(self) -> float:
+ """Get baseline"""
+ return self.__baseline
+
+ def get_x_range(self) -> tuple[float, float]:
+ """Get x range"""
+ return self.__x_range
diff --git a/sigimax/widgets/signalcursor.py b/sigimax/widgets/signalcursor.py
new file mode 100644
index 0000000..11b7dc0
--- /dev/null
+++ b/sigimax/widgets/signalcursor.py
@@ -0,0 +1,221 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Signal horizontal or vertical cursor selection dialog.
+
+.. autoclass:: SignalCursorDialog
+ :members:
+"""
+
+# pylint: disable=invalid-name # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Literal
+
+import numpy as np
+from guidata.configtools import get_icon
+from plotpy.builder import make
+from plotpy.plot import PlotDialog
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+from sigima.tools.signal.features import find_x_values_at_y
+
+from sigimax.adapters_plotpy import CURVESTYLES, create_adapter_from_object
+from sigimax.config import _, get_conf
+from sigimax.utils.qthelpers import block_signals, resize_widget_to_parent
+
+__all__ = [
+ "SignalCursorDialog",
+]
+
+if TYPE_CHECKING:
+ from plotpy.items import CurveItem, Marker
+ from qtpy.QtWidgets import QWidget
+ from sigima.objects import SignalObj
+
+
+class SignalCursorDialog(PlotDialog):
+ """Signal horizontal or vertical cursor selection dialog.
+
+ Args:
+ signal: signal object
+ parent: parent widget. Defaults to None.
+ """
+
+ def __init__(
+ self,
+ signal: SignalObj,
+ cursor_orientation: Literal["horizontal", "vertical"],
+ parent: QWidget | None = None,
+ ) -> None:
+ assert cursor_orientation in (
+ "horizontal",
+ "vertical",
+ ), "cursor_orientation must be 'horizontal' or 'vertical'"
+ self.__curve_styles = CURVESTYLES.style_generator()
+ self.__cursor_orientation = cursor_orientation
+ self.__signal = signal
+ self.__x_value: float | None = None
+ self.__y_value: float | None = None
+ self.curve: CurveItem | None = None
+ self.hcursor: Marker | None = None
+ self.vcursor: Marker | None = None
+ self.xlineedit: QW.QLineEdit | None = None
+ self.ylineedit: QW.QLineEdit | None = None
+ if cursor_orientation == "horizontal":
+ title = _("Select X value with cursor")
+ else:
+ title = _("Select Y value with cursor")
+ super().__init__(title=title, edit=True, parent=parent)
+ self.setObjectName("SignalCursorDialog")
+ if parent is None:
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ legend = make.legend("TR")
+ self.get_plot().add_item(legend)
+ self.__setup_dialog()
+ resize_widget_to_parent(self, aspect_ratio=1.0)
+
+ def __setup_dialog(self) -> None:
+ """Setup dialog box"""
+ apply_button = QW.QPushButton(_("Apply"))
+ apply_button.setIcon(get_icon("apply.svg"))
+ apply_button.setToolTip(_("Apply cursor position"))
+ xlabel = QW.QLabel("X=")
+ ylabel = QW.QLabel("Y=")
+ self.xlineedit = QW.QLineEdit()
+ self.xlineedit.editingFinished.connect(self.xlineedit_editing_finished)
+ x_validator = QG.QDoubleValidator()
+ x_validator.setLocale(QC.QLocale("C"))
+ self.xlineedit.setValidator(x_validator)
+ self.ylineedit = QW.QLineEdit()
+ self.ylineedit.editingFinished.connect(self.ylineedit_editing_finished)
+ y_validator = QG.QDoubleValidator()
+ y_validator.setLocale(QC.QLocale("C"))
+ self.ylineedit.setValidator(y_validator)
+ self.xlineedit.setReadOnly(self.__cursor_orientation == "horizontal")
+ self.xlineedit.setDisabled(self.__cursor_orientation == "horizontal")
+ self.ylineedit.setReadOnly(self.__cursor_orientation == "vertical")
+ self.ylineedit.setDisabled(self.__cursor_orientation == "vertical")
+ xygroup = QW.QGroupBox(_("Cursor position"))
+ xylayout = QW.QHBoxLayout()
+ xylayout.addWidget(xlabel)
+ xylayout.addWidget(self.xlineedit)
+ if self.__cursor_orientation == "vertical":
+ xylayout.addWidget(apply_button)
+ apply_button.clicked.connect(self.xlineedit_editing_finished)
+ xylayout.addStretch()
+ xylayout.addSpacing(10)
+ xylayout.addWidget(ylabel)
+ xylayout.addWidget(self.ylineedit)
+ if self.__cursor_orientation == "horizontal":
+ xylayout.addWidget(apply_button)
+ apply_button.clicked.connect(self.ylineedit_editing_finished)
+ xygroup.setLayout(xylayout)
+ self.button_layout.insertWidget(0, xygroup)
+
+ obj = self.__signal
+ with CURVESTYLES.alternative(self.__curve_styles):
+ self.curve = create_adapter_from_object(obj).make_item()
+ plot = self.get_plot()
+ plot.set_antialiasing(True)
+
+ xcursor = make.xcursor(np.mean(obj.x), np.mean(obj.y), "X = %g, Y = %g")
+ xcursor.set_selectable(False)
+ param = xcursor.markerparam
+ param.symbol.facecolor = "blue"
+ param.symbol.edgecolor = "cyan"
+ param.symbol.size = 9
+ param.line.style = "DotLine"
+ param.line.color = "blue"
+ param.line.width = 2.0
+ param.update_item(xcursor)
+
+ plot.SIG_MARKER_CHANGED.connect(self.cursor_changed)
+ if self.__cursor_orientation == "horizontal":
+ self.hcursor = make.hcursor(np.mean(obj.y), "Y = %g")
+ self.vcursor = xcursor
+ self.vcursor.setVisible(False)
+ else:
+ self.vcursor = make.vcursor(np.mean(obj.x), "X = %g")
+ self.hcursor = xcursor
+ self.hcursor.setVisible(False)
+ for item in (self.curve, self.vcursor, self.hcursor):
+ plot.add_item(item)
+ plot.replot()
+ if self.__cursor_orientation == "horizontal":
+ plot.set_active_item(self.hcursor)
+ self.cursor_changed(self.hcursor)
+ else:
+ plot.set_active_item(self.vcursor)
+ self.cursor_changed(self.vcursor)
+
+ def cursor_changed(self, item: Marker) -> None:
+ """Cursor changed"""
+ sig = self.__signal
+ plot = self.get_plot()
+ if self.__cursor_orientation == "horizontal" and item is self.hcursor:
+ _x, y = item.get_pos()
+ x = None
+ x_values = find_x_values_at_y(sig.x, sig.y, y)
+ if len(x_values) > 0:
+ x = x_values[0]
+ with block_signals(plot):
+ self.vcursor.set_pos(x, y)
+ self.vcursor.setVisible(x is not None)
+ self.button_box.button(QW.QDialogButtonBox.Ok).setEnabled(x is not None)
+ elif self.__cursor_orientation == "vertical" and item is self.vcursor:
+ x, _y = item.get_pos()
+ y_index = np.searchsorted(self.__signal.x, x)
+ if x < self.__signal.x[0] or y_index >= len(self.__signal.y):
+ y = None
+ else:
+ y = self.__signal.y[y_index]
+ with block_signals(plot):
+ self.hcursor.set_pos(x, y)
+ self.hcursor.setVisible(True)
+ self.hcursor.setVisible(y is not None)
+ self.button_box.button(QW.QDialogButtonBox.Ok).setEnabled(y is not None)
+ self.xlineedit.setText(f"{x:g}" if x is not None else "")
+ self.ylineedit.setText(f"{y:g}" if y is not None else "")
+ self.__x_value, self.__y_value = x, y
+
+ def xlineedit_editing_finished(self) -> None:
+ """X line edit editing finished"""
+ try:
+ x = float(self.xlineedit.text())
+ _x, y = self.vcursor.get_pos()
+ if self.__cursor_orientation == "horizontal":
+ self.hcursor.set_pos(x, y)
+ else:
+ self.vcursor.set_pos(x, y)
+ except ValueError:
+ pass
+ plot = self.get_plot()
+ plot.replot()
+
+ def ylineedit_editing_finished(self) -> None:
+ """Y line edit editing finished"""
+ try:
+ y = float(self.ylineedit.text())
+ x, _y = self.hcursor.get_pos()
+ if self.__cursor_orientation == "horizontal":
+ self.hcursor.set_pos(x, y)
+ else:
+ self.vcursor.set_pos(x, y)
+ except ValueError:
+ pass
+ plot = self.get_plot()
+ plot.replot()
+
+ def get_cursor_position(self) -> tuple[float, float]:
+ """Get cursor position"""
+ return self.__x_value, self.__y_value
+
+ def get_x_value(self) -> float:
+ """Get cursor x value"""
+ return self.__x_value
+
+ def get_y_value(self) -> float:
+ """Get cursor y value"""
+ return self.__y_value
diff --git a/sigimax/widgets/signaldeltax.py b/sigimax/widgets/signaldeltax.py
new file mode 100644
index 0000000..8e1b26d
--- /dev/null
+++ b/sigimax/widgets/signaldeltax.py
@@ -0,0 +1,161 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+GUI dialog for analyzing signals and calculating full width at Y.
+
+.. autoclass:: SignalDeltaXDialog
+ :members:
+"""
+
+# pylint: disable=invalid-name # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+import warnings
+from typing import TYPE_CHECKING
+
+import numpy as np
+from guidata.configtools import get_icon
+from plotpy.builder import make
+from plotpy.plot import PlotDialog
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+from sigima.tools.signal.pulse import full_width_at_y
+
+from sigimax.adapters_plotpy import CURVESTYLES, create_adapter_from_object
+from sigimax.config import _, get_conf
+from sigimax.utils.qthelpers import resize_widget_to_parent
+
+__all__ = [
+ "SignalDeltaXDialog",
+]
+
+if TYPE_CHECKING:
+ from plotpy.items import CurveItem, Marker, XRangeSelection
+ from qtpy.QtWidgets import QWidget
+ from sigima.objects import SignalObj
+
+
+class SignalDeltaXDialog(PlotDialog):
+ """Signal Delta X dialog.
+
+ Args:
+ signal: signal object
+ parent: parent widget. Defaults to None.
+ """
+
+ def __init__(self, signal: SignalObj, parent: QWidget | None = None) -> None:
+ self.__curve_styles = CURVESTYLES.style_generator()
+ self.__signal = signal
+ self.__coords: list[float, float, float, float] | None = None
+ self.curve: CurveItem | None = None
+ self.hcursor: Marker | None = None
+ self.delta_xrange: XRangeSelection | None = None
+ self.deltaxlineedit: QW.QLineEdit | None = None
+ self.ylineedit: QW.QLineEdit | None = None
+ title = _("Select Y value with cursor")
+ super().__init__(title=title, edit=True, parent=parent)
+ self.setObjectName("SignalCursorDialog")
+ if parent is None:
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ legend = make.legend("TR")
+ self.get_plot().add_item(legend)
+ self.__setup_dialog()
+ resize_widget_to_parent(self, aspect_ratio=1.0)
+
+ def __setup_dialog(self) -> None:
+ """Setup dialog box"""
+ apply_button = QW.QPushButton(_("Apply"))
+ apply_button.setIcon(get_icon("apply.svg"))
+ apply_button.setToolTip(_("Apply cursor position"))
+ xlabel = QW.QLabel("∆X=")
+ ylabel = QW.QLabel("Y=")
+ self.deltaxlineedit = QW.QLineEdit()
+ self.deltaxlineedit.setReadOnly(True)
+ self.deltaxlineedit.setDisabled(True)
+ self.ylineedit = QW.QLineEdit()
+ self.ylineedit.editingFinished.connect(self.ylineedit_editing_finished)
+ y_validator = QG.QDoubleValidator()
+ y_validator.setLocale(QC.QLocale("C"))
+ self.ylineedit.setValidator(y_validator)
+ xygroup = QW.QGroupBox(_("Cursor position"))
+ xylayout = QW.QHBoxLayout()
+ xylayout.addWidget(xlabel)
+ xylayout.addWidget(self.deltaxlineedit)
+ xylayout.addWidget(ylabel)
+ xylayout.addWidget(self.ylineedit)
+ xylayout.addWidget(apply_button)
+ vlayout = QW.QVBoxLayout()
+ vlayout.addLayout(xylayout)
+ self.warning_label = QW.QLabel()
+ vlayout.addWidget(self.warning_label)
+ apply_button.clicked.connect(self.ylineedit_editing_finished)
+ xygroup.setLayout(vlayout)
+ self.button_layout.insertWidget(0, xygroup)
+
+ obj = self.__signal
+ with CURVESTYLES.alternative(self.__curve_styles):
+ self.curve = create_adapter_from_object(obj).make_item()
+ plot = self.get_plot()
+ plot.set_antialiasing(True)
+
+ self.delta_xrange = make.xrange(0.0, 1.0)
+ self.delta_xrange.setVisible(False)
+ self.delta_xrange.set_style("roi", "s/readonly")
+ self.delta_xrange.set_selectable(False)
+
+ plot.SIG_MARKER_CHANGED.connect(self.cursor_changed)
+ self.hcursor = make.hcursor(np.mean(obj.y), "Y = %g")
+ for item in (self.curve, self.delta_xrange, self.hcursor):
+ plot.add_item(item)
+ plot.replot()
+ plot.set_active_item(self.hcursor)
+ self.cursor_changed(self.hcursor)
+
+ def cursor_changed(self, item: Marker) -> None:
+ """Cursor changed"""
+ sig = self.__signal
+ _x, y = item.get_pos()
+
+ try:
+ with warnings.catch_warnings(record=True) as w:
+ self.__coords = full_width_at_y(sig.x, sig.y, y)
+ if np.nan in self.__coords:
+ raise ValueError("Invalid coordinates")
+ delta_str = f"{self.__coords[2] - self.__coords[0]:g}"
+ ok = True
+ if len(w) > 0:
+ self.warning_label.setText("⚠️ " + str(w[-1].message))
+ else:
+ self.warning_label.setText("")
+ self.delta_xrange.setVisible(True)
+ self.delta_xrange.set_range(self.__coords[0], self.__coords[2])
+ except ValueError:
+ delta_str = ""
+ ok = False
+ self.delta_xrange.setVisible(False)
+
+ self.button_box.button(QW.QDialogButtonBox.Ok).setEnabled(ok)
+ self.deltaxlineedit.setText(delta_str)
+ self.ylineedit.setText(f"{y:g}" if y is not None else "")
+
+ def ylineedit_editing_finished(self) -> None:
+ """Y line edit editing finished"""
+ try:
+ y = float(self.ylineedit.text())
+ x, _y = self.hcursor.get_pos()
+ self.hcursor.set_pos(x, y)
+ except ValueError:
+ pass
+ plot = self.get_plot()
+ plot.replot()
+
+ def get_coords(self) -> tuple[float, float, float, float]:
+ """Return coordinates of segment associated to the width at Y"""
+ return self.__coords
+
+ def get_y_value(self) -> float:
+ """Get cursor y value"""
+ _x, y = self.hcursor.get_pos()
+ return y
diff --git a/sigimax/widgets/signalpeak.py b/sigimax/widgets/signalpeak.py
new file mode 100644
index 0000000..84cec42
--- /dev/null
+++ b/sigimax/widgets/signalpeak.py
@@ -0,0 +1,207 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""Signal peak detection feature
+
+.. autoclass:: SignalPeakDetectionDialog
+ :members:
+"""
+
+# pylint: disable=invalid-name # Allows short reference names like x, y, ...
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+import numpy as np
+from guidata.configtools import get_icon
+from plotpy.builder import make
+from plotpy.plot import PlotDialog
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+from sigima.tools.signal.peakdetection import peak_indices
+
+from sigimax.adapters_plotpy import CURVESTYLES, create_adapter_from_object
+from sigimax.config import _, get_conf
+from sigimax.utils.qthelpers import resize_widget_to_parent
+
+__all__ = [
+ "SignalPeakDetectionDialog",
+]
+
+if TYPE_CHECKING:
+ from plotpy.items import Marker
+ from qtpy.QtWidgets import QWidget
+ from sigima.objects import SignalObj
+
+
+class DistanceSlider(QW.QWidget):
+ """Minimum distance slider
+
+ Args:
+ parent: parent widget. Defaults to None.
+ """
+
+ TITLE = _("Minimum distance:")
+ SIG_VALUE_CHANGED = QC.Signal(int)
+
+ def __init__(self, parent: QWidget | None = None) -> None:
+ super().__init__(parent)
+ self.slider = QW.QSlider(QC.Qt.Horizontal)
+ self.label = QW.QLabel()
+ layout = QW.QHBoxLayout()
+ layout.addWidget(self.label)
+ layout.addWidget(self.slider)
+ self.setLayout(layout)
+
+ def value_changed(self, value: int) -> None:
+ """Slider value has changed
+
+ Args:
+ value: slider value
+ """
+ plural = "s" if value > 1 else ""
+ self.label.setText(f"{self.TITLE} {value} point{plural}")
+ self.SIG_VALUE_CHANGED.emit(value)
+
+ def setup_slider(self, value: int, maxval: int) -> None:
+ """Setup slider
+
+ Args:
+ value: initial value
+ maxval: maximum value
+ """
+ self.slider.setMinimum(1)
+ self.slider.setMaximum(maxval)
+ self.slider.setValue(value)
+ self.slider.setTickPosition(QW.QSlider.TicksBothSides)
+ self.value_changed(value)
+ self.slider.valueChanged.connect(self.value_changed)
+
+
+class SignalPeakDetectionDialog(PlotDialog):
+ """Signal Peak detection dialog
+
+ Args:
+ signal: signal object
+ parent: parent widget. Defaults to None.
+ """
+
+ def __init__(self, signal: SignalObj, parent: QWidget | None = None) -> None:
+ self.__curve_styles = CURVESTYLES.style_generator()
+ self.peaks = None
+ self.peak_indices = None
+ self.in_curve = None
+ self.in_threshold = None
+ self.in_threshold_cursor = None
+ self.co_results = None
+ self.co_positions = None
+ self.co_markers = None
+ self.min_distance = None
+ self.distance_slider: DistanceSlider | None = None
+ super().__init__(title=_("Signal peak detection"), edit=True, parent=parent)
+ self.setObjectName("peakdetection")
+ if parent is None:
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ legend = make.legend("TR")
+ self.get_plot().add_item(legend)
+ self.__signal = signal.copy()
+ self.__setup_dialog()
+ resize_widget_to_parent(self, parent, aspect_ratio=1.0)
+
+ def populate_plot_layout(self) -> None: # Reimplement PlotDialog method
+ """Populate the plot layout"""
+ super().populate_plot_layout()
+ self.distance_slider = DistanceSlider(self)
+ self.add_widget(self.distance_slider, 1, 0, 1, 1)
+
+ def __setup_dialog(self) -> None:
+ """Setup dialog box"""
+ obj = self.__signal
+ with CURVESTYLES.alternative(self.__curve_styles):
+ self.in_curve = create_adapter_from_object(obj).make_item()
+ plot = self.get_plot()
+ plot.set_antialiasing(True)
+ plot.add_item(self.in_curve)
+ self.in_threshold = 0.5 * (np.max(obj.y) - np.min(obj.y)) + np.min(obj.y)
+ cursor = make.hcursor(self.in_threshold)
+ self.in_threshold_cursor = cursor
+ plot.add_item(self.in_threshold_cursor)
+ self.co_results = make.label("", "TL", (0, 0), "TL")
+ plot.add_item(self.co_results)
+ plot.SIG_MARKER_CHANGED.connect(self.hcursor_changed)
+ self.min_distance = 1
+ self.distance_slider.setup_slider(self.min_distance, len(obj.y) // 4)
+ self.distance_slider.SIG_VALUE_CHANGED.connect(self.minimum_distance_changed)
+ self.compute_peaks()
+ # Replot, otherwise, it's not possible to set active item:
+ plot.replot()
+ plot.set_active_item(cursor)
+
+ def get_peaks(self) -> list[tuple[float, float]]:
+ """Return peaks coordinates"""
+ return self.peaks
+
+ def get_peak_indices(self) -> list[int]:
+ """Return peak indices"""
+ return self.peak_indices
+
+ def get_threshold(self) -> float:
+ """Return relative threshold"""
+ y = self.__signal.y
+ return (self.in_threshold - np.min(y)) / (np.max(y) - np.min(y))
+
+ def get_min_dist(self) -> int:
+ """Return minimum distance"""
+ return self.min_distance
+
+ def compute_peaks(self) -> None:
+ """Compute peak detection"""
+ x, y = self.__signal.xydata
+ plot = self.get_plot()
+ self.peak_indices = peak_indices(
+ y,
+ thres=self.in_threshold,
+ min_dist=self.min_distance,
+ thres_abs=True,
+ )
+ self.peaks = [(x[index], y[index]) for index in self.peak_indices]
+ markers = [
+ make.marker(
+ pos,
+ movable=False,
+ color="orange",
+ markerstyle="|",
+ linewidth=1,
+ marker="NoSymbol",
+ linestyle="DashLine",
+ )
+ for pos in self.peaks
+ ]
+ if self.co_markers is not None:
+ plot.del_items(self.co_markers)
+ self.co_markers = markers
+ for item in self.co_markers:
+ plot.add_item(item)
+ positions = [str(marker.get_pos()[0]) for marker in markers]
+ prefix = f"{_('Peaks:')}
"
+ self.co_results.set_text(prefix + "
".join(positions))
+
+ def hcursor_changed(self, marker: Marker) -> None:
+ """Horizontal cursor position has changed
+
+ Args:
+ marker: marker item
+ """
+ _x, y = marker.get_pos()
+ self.in_threshold = y
+ self.compute_peaks()
+
+ def minimum_distance_changed(self, value: int) -> None:
+ """Minimum distance changed
+
+ Args:
+ value: minimum distance value
+ """
+ self.min_distance = value
+ self.compute_peaks()
+ self.get_plot().replot()
diff --git a/sigimax/widgets/splashscreen.py b/sigimax/widgets/splashscreen.py
new file mode 100644
index 0000000..89767fa
--- /dev/null
+++ b/sigimax/widgets/splashscreen.py
@@ -0,0 +1,234 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Splash screen
+=============
+
+The :mod:`sigimax.widgets.splashscreen` module provides a configurable splash
+screen for SigimaX-derived applications.
+
+Derived applications can customize the splash screen by providing a
+:class:`SplashScreenConfig` instance, or by subclassing
+:class:`SigimaXSplashScreen` for advanced rendering.
+
+Basic usage::
+
+ from sigimax.widgets.splashscreen import SplashScreenConfig, SigimaXSplashScreen
+
+ config = SplashScreenConfig(
+ image_path="path/to/splash.png",
+ app_name="MyApp",
+ app_version="1.0.0",
+ tagline="Scientific Data Processing",
+ )
+ splash = SigimaXSplashScreen(config)
+ splash.show()
+ splash.show_message("Loading modules...")
+ # ... heavy initialization ...
+ splash.finish(main_window)
+
+Factory from global configuration::
+
+ splash = SigimaXSplashScreen.from_conf()
+ if splash is not None:
+ splash.show()
+ # ...
+ splash.finish(main_window)
+
+.. autoclass:: SplashScreenConfig
+.. autoclass:: SigimaXSplashScreen
+"""
+
+from __future__ import annotations
+
+import dataclasses
+from typing import TYPE_CHECKING
+
+from guidata.configtools import get_image_file_path
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+
+if TYPE_CHECKING:
+ pass
+
+__all__ = [
+ "SigimaXSplashScreen",
+ "SplashScreenConfig",
+]
+
+
+@dataclasses.dataclass
+class SplashScreenConfig:
+ """Configuration for a splash screen.
+
+ All fields are optional except *image_path*. When *image_path* is empty
+ or ``None``, no splash screen is shown.
+
+ Args:
+ image_path: Absolute or relative path to the splash image (PNG, SVG,
+ or any format supported by :class:`QPixmap`). If empty or ``None``,
+ the splash screen is disabled.
+ app_name: Application name overlaid on the splash image.
+ app_version: Application version overlaid on the splash image.
+ tagline: Optional subtitle displayed below the version.
+ show_progress: If ``True``, progress messages are displayed at the
+ bottom of the splash screen via :meth:`SigimaXSplashScreen.show_message`.
+ text_color: Color used for overlay text (default: white).
+ text_alignment: Qt alignment flags for overlay text
+ (default: bottom-left).
+ """
+
+ image_path: str | None = None
+ app_name: str = ""
+ app_version: str = ""
+ tagline: str = ""
+ show_progress: bool = True
+ text_color: QG.QColor = dataclasses.field(
+ default_factory=lambda: QG.QColor("white")
+ )
+ text_alignment: QC.Qt.AlignmentFlag = dataclasses.field(
+ default_factory=lambda: QC.Qt.AlignBottom | QC.Qt.AlignLeft
+ )
+
+ @property
+ def is_enabled(self) -> bool:
+ """Return ``True`` if the splash screen should be shown."""
+ return bool(self.image_path)
+
+ @classmethod
+ def from_conf(cls) -> SplashScreenConfig:
+ """Build a :class:`SplashScreenConfig` from the global
+ :data:`sigimax.config.CONF` options.
+
+ Returns:
+ Configuration instance populated from global options.
+ """
+ # Import here to avoid circular imports
+ from sigimax.config import get_conf # pylint: disable=import-outside-toplevel
+
+ conf = get_conf()
+
+ return cls(
+ image_path=conf.splash_image_path.get() or None,
+ app_name=conf.app_name.get(),
+ app_version=conf.app_version.get(),
+ tagline=conf.app_desc.get(),
+ show_progress=conf.splash_show_progress.get(),
+ )
+
+
+class SigimaXSplashScreen(QW.QSplashScreen):
+ """Configurable splash screen for SigimaX-derived applications.
+
+ Creates a :class:`QSplashScreen` from a :class:`SplashScreenConfig`.
+ If the configuration specifies an application name/version, they are
+ painted as overlay text on top of the splash image.
+
+ Args:
+ config: Splash screen configuration. If ``None``, a default
+ configuration is built from :data:`sigimax.config.CONF`.
+ """
+
+ def __init__(self, config: SplashScreenConfig | None = None) -> None:
+ self._config = config or SplashScreenConfig.from_conf()
+ pixmap = self._load_pixmap()
+ super().__init__(pixmap, QC.Qt.WindowStaysOnTopHint)
+
+ # ------------------------------------------------------------------
+ # Public API
+ # ------------------------------------------------------------------
+
+ def show_message(self, message: str) -> None:
+ """Display a progress message on the splash screen.
+
+ The message is shown only if :attr:`SplashScreenConfig.show_progress`
+ is ``True``.
+
+ Args:
+ message: The progress message to display.
+ """
+ if self._config.show_progress:
+ self.showMessage(
+ message,
+ int(self._config.text_alignment),
+ self._config.text_color,
+ )
+ # Process events so the message is actually painted
+ QW.QApplication.processEvents()
+
+ @classmethod
+ def from_conf(cls) -> SigimaXSplashScreen | None:
+ """Factory: build a splash screen from the global configuration.
+
+ Returns:
+ A :class:`SigimaXSplashScreen` instance, or ``None`` if the
+ configuration does not specify a splash image.
+ """
+ config = SplashScreenConfig.from_conf()
+ if not config.is_enabled:
+ return None
+ return cls(config)
+
+ # ------------------------------------------------------------------
+ # Internal helpers
+ # ------------------------------------------------------------------
+
+ def _load_pixmap(self) -> QG.QPixmap:
+ """Load the splash image as a :class:`QPixmap`.
+
+ Returns:
+ The loaded pixmap. If the image cannot be loaded, a minimal
+ fallback pixmap is generated.
+ """
+ path = self._config.image_path or ""
+ pixmap = QG.QPixmap(path)
+ if pixmap.isNull() and path:
+ try:
+ resolved_path = get_image_file_path(path, default=None)
+ except RuntimeError:
+ resolved_path = ""
+ pixmap = QG.QPixmap(resolved_path)
+ if pixmap.isNull():
+ pixmap = self._create_fallback_pixmap()
+ return pixmap
+
+ def _create_fallback_pixmap(self) -> QG.QPixmap:
+ """Create a minimal fallback pixmap when no image is available.
+
+ Returns:
+ A 480x280 pixmap with the application name drawn on a dark
+ background.
+ """
+ width, height = 480, 280
+ pixmap = QG.QPixmap(width, height)
+ pixmap.fill(QG.QColor(40, 40, 40))
+
+ painter = QG.QPainter(pixmap)
+ painter.setPen(self._config.text_color)
+
+ # Application name
+ font = painter.font()
+ font.setPointSize(24)
+ font.setBold(True)
+ painter.setFont(font)
+ name = self._config.app_name or "SigimaX"
+ painter.drawText(
+ QC.QRect(0, 0, width, height),
+ int(QC.Qt.AlignCenter),
+ name,
+ )
+
+ # Version
+ if self._config.app_version:
+ font.setPointSize(12)
+ font.setBold(False)
+ painter.setFont(font)
+ painter.drawText(
+ QC.QRect(0, height // 2 + 20, width, 40),
+ int(QC.Qt.AlignHCenter | QC.Qt.AlignTop),
+ f"v{self._config.app_version}",
+ )
+
+ painter.end()
+ return pixmap
diff --git a/sigimax/widgets/status.py b/sigimax/widgets/status.py
new file mode 100644
index 0000000..4a61f15
--- /dev/null
+++ b/sigimax/widgets/status.py
@@ -0,0 +1,205 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+SigimaX main window status bar widgets
+
+.. autoclass:: BaseStatus
+ :members:
+.. autoclass:: ConsoleStatus
+ :members:
+.. autoclass:: MemoryStatus
+ :members:
+"""
+
+from __future__ import annotations
+
+import os
+
+import psutil
+from guidata.configtools import get_icon
+from guidata.qthelpers import get_std_icon
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+
+from sigimax.config import DEBUG, _, get_conf
+from sigimax.env import execenv
+
+__all__ = [
+ "BaseStatus",
+ "ConsoleStatus",
+ "MemoryStatus",
+]
+
+
+class BaseStatus(QW.QWidget):
+ """Base status widget.
+
+ Args:
+ delay (int | None): update interval (s). If None, widget will not be updated.
+ parent (QWidget): parent widget
+ """
+
+ def __init__(
+ self, delay: int | None = None, parent: QW.QWidget | None = None
+ ) -> None:
+ super().__init__(parent)
+ if parent is None:
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ layout = QW.QHBoxLayout()
+ layout.setContentsMargins(0, 0, 0, 0)
+ self.setLayout(layout)
+ self.icon = QW.QLabel()
+ self.label = QW.QLabel()
+ layout.addWidget(self.icon)
+ layout.addWidget(self.label)
+ if delay is not None:
+ self.timer = QC.QTimer()
+ self.timer.timeout.connect(self.update_status)
+ self.timer.start(delay * 1000)
+
+ def set_icon(self, icon: QG.QIcon | str | None) -> None:
+ """Set icon.
+
+ Args:
+ icon (QIcon | None): icon
+ """
+ size = self.label.sizeHint().height()
+ if isinstance(icon, str):
+ icon = get_icon(icon)
+ pixmap = QG.QPixmap() if icon is None else icon.pixmap(size, size)
+ self.icon.setPixmap(pixmap)
+
+ def update_status(self) -> None:
+ """Update status widget"""
+ raise NotImplementedError
+
+
+class ConsoleStatus(BaseStatus):
+ """Console status widget.
+
+ Shows a message if an error or warning has been logged to the console.
+ Shows a button to show the console, only if the console is hidden.
+
+ Args:
+ parent (QWidget): parent widget
+ """
+
+ SIG_SHOW_CONSOLE = QC.Signal()
+
+ def __init__(self, parent: QW.QWidget | None = None) -> None:
+ super().__init__(None, parent)
+ self.label.setText(_("Internal console"))
+ self.label.setToolTip(
+ _(
+ "Click to show the internal console.\n"
+ "The icon will turn red if an error or warning is logged."
+ )
+ )
+ self.label.setCursor(QG.QCursor(QC.Qt.PointingHandCursor))
+ self.label.mouseReleaseEvent = self.on_click
+ self.ok_icon = get_std_icon("MessageBoxInformation")
+ self.ko_icon = get_std_icon("MessageBoxWarning")
+ self.has_errors = False
+ self.update_status()
+
+ def on_click(self, event: QG.QMouseEvent) -> None:
+ """Handle mouse click event on label.
+
+ Args:
+ event: mouse event
+ """
+ if event.button() == QC.Qt.LeftButton:
+ self.SIG_SHOW_CONSOLE.emit()
+
+ def console_visibility_changed(self, visible: bool) -> None:
+ """Handle console visibility changed event.
+
+ Args:
+ visible (bool): console visibility
+ """
+ if visible:
+ # Hide this status widget when console is visible
+ self.hide()
+ else:
+ self.show()
+ self.update_status()
+
+ def exception_occurred(self) -> None:
+ """Handle exception occurred event"""
+ self.has_errors = True
+ self.update_status()
+
+ def update_status(self) -> None:
+ """Update status widget"""
+ if self.has_errors:
+ self.set_icon(self.ko_icon)
+ self.label.setStyleSheet("color: red")
+ self.label.setToolTip(
+ _(
+ "Click to show the internal console.\n"
+ "An error or warning has been logged."
+ )
+ )
+ else:
+ self.set_icon(self.ok_icon)
+ self.label.setStyleSheet("")
+ self.label.setToolTip(
+ _(
+ "Click to show the internal console.\n"
+ "No error or warning has been logged."
+ )
+ )
+
+
+class MemoryStatus(BaseStatus):
+ """Memory status widget.
+
+ Args:
+ threshold (int): available memory thresold (MB)
+ delay (int): update interval (s)
+ parent (QWidget): parent widget
+ """
+
+ SIG_MEMORY_ALARM = QC.Signal(bool)
+
+ def __init__(
+ self, threshold: int = 500, delay: int = 2, parent: QW.QWidget | None = None
+ ) -> None:
+ super().__init__(delay, parent)
+ self.demo_mode = False
+ self.ko_icon = get_std_icon("MessageBoxWarning")
+ self.__threshold = threshold * (1024**2)
+ self.label.setMinimumWidth(self.label.fontMetrics().width("000%"))
+ self.update_status()
+
+ def set_demo_mode(self, state: bool) -> None:
+ """Set demo mode state (used when taking screenshots).
+ The demo mode allows to take screenshots which always look the same.
+ (this will set memory usage to a constant value).
+ If demo mode is set to False, memory usage will be set to actual value.
+
+ Args:
+ state (bool): demo mode state
+ """
+ self.demo_mode = state
+ self.update_status()
+
+ def update_status(self) -> None:
+ """Update status widget"""
+ mem = psutil.virtual_memory()
+ memok = mem.available > self.__threshold
+ self.SIG_MEMORY_ALARM.emit(not memok)
+ txtlist = [
+ f"%s {mem.available // (1024**2)} MB" % _("Memory available:"),
+ f"%s {mem.used // (1024**2)} MB" % _("Memory used:"),
+ f"%s {self.__threshold // (1024**2)} MB" % _("Alarm threshold:"),
+ ]
+ txt = os.linesep.join(txtlist)
+ self.setToolTip(txt)
+ if DEBUG and not memok:
+ execenv.log(self, txt)
+ self.label.setStyleSheet("" if memok else "color: red")
+ self.set_icon("libre-tech-ram.svg" if memok else self.ko_icon)
+ mem_percent = 65 if self.demo_mode else int(mem.percent)
+ self.label.setText(_("Memory:") + f" {mem_percent}%")
diff --git a/sigimax/widgets/warningerror.py b/sigimax/widgets/warningerror.py
new file mode 100644
index 0000000..2132a44
--- /dev/null
+++ b/sigimax/widgets/warningerror.py
@@ -0,0 +1,234 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+Module providing a warning/error message box
+
+.. autoclass:: WarningErrorMessageBox
+ :members:
+.. autofunction:: show_warning_error
+"""
+
+import os.path as osp
+import re
+import subprocess
+import traceback
+
+from guidata.config import CONF
+from guidata.configtools import get_font, get_icon
+from guidata.qthelpers import exec_dialog, get_std_icon
+from guidata.widgets.console.shell import PythonShellWidget
+from qtpy import QtCore as QC
+from qtpy import QtWidgets as QW
+
+from sigimax.config import _, get_conf, get_mod_source_dir
+
+__all__ = [
+ "WarningErrorMessageBox",
+ "go_to_error",
+ "show_warning_error",
+]
+
+
+def go_to_error(text: str) -> None:
+ """Go to error: open file with external editor, and go to line number
+
+ Args:
+ text (str): Error text
+ """
+ pattern = r'File "(.+)", line (\d+),'
+ match = re.search(pattern, text)
+ if match:
+ path = match.group(1)
+ line_number = match.group(2)
+ mod_src_dir = get_mod_source_dir()
+ if not osp.isfile(path) and mod_src_dir is not None:
+ otherpath = osp.join(mod_src_dir, path)
+ if not osp.isfile(otherpath):
+ # TODO: [P3] For frozen app, go to error is implemented only when the
+ # source code is available locally (development mode).
+ # How about using a web browser to open the source code on github?
+ return
+ path = otherpath
+ if not osp.isfile(path):
+ return # File not found (unhandled case)
+ fdict = {"path": path, "line_number": line_number}
+ args = get_conf().external_editor_args.get().format(**fdict).split(" ")
+ editor_path = get_conf().external_editor_path.get()
+ subprocess.run([editor_path] + args, shell=True, check=False)
+
+
+def insert_spaces(text: str, nbchars: int) -> str:
+ """
+ Inserts spaces regularly in a string, every nbchars characters, after certain
+ characters (",", ";", "-", "+", "*", ")"), and keeps searching until detecting
+ one of those characters.
+
+ Args:
+ text (str): The input string.
+ nbchars (int): The number of characters after which a space should be inserted.
+
+ Returns:
+ str: The modified string with spaces inserted.
+ """
+ special_chars = (",", ";", "-", "+", "*", ")", "_")
+ new_text = ""
+ index = 0
+ while index < len(text):
+ if (
+ index + nbchars < len(text)
+ and text[index + nbchars] not in special_chars
+ and not any(c in special_chars for c in text[index : index + nbchars + 1])
+ ):
+ new_text += text[index : index + nbchars] # Append characters
+ index += nbchars
+ else:
+ new_text += text[index : index + nbchars] + " " # Insert space
+ index += nbchars
+ return new_text
+
+
+class WarningErrorMessageBox(QW.QDialog):
+ """Warning/Error message box
+
+ Args:
+ parent (QW.QWidget): parent widget
+ category (str): message category ("error" or "warning")
+ context (str | None): context. Defaults to None.
+ message (str | None): message. Defaults to None.
+ tip (str | None): tip. Defaults to None.
+ """
+
+ def __init__(
+ self,
+ parent: QW.QWidget,
+ category: str,
+ context: str = None,
+ message: str = None,
+ tip: str = None,
+ ) -> None:
+ super().__init__(parent)
+ assert category in ("error", "warning")
+ self.setWindowTitle(parent.window().objectName())
+ if parent is None:
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ self.shell = PythonShellWidget(self, read_only=True)
+ self.shell.go_to_error.connect(go_to_error)
+ font = get_font(CONF, "console")
+ font.setPointSize(9)
+ self.shell.set_font(font)
+ message = traceback.format_exc() if message is None else message
+ self.shell.insert_text(message, at_end=True, error=True)
+
+ bbox = QW.QDialogButtonBox(QW.QDialogButtonBox.Ok)
+ bbox.accepted.connect(self.accept)
+ if category == "warning":
+ bbox.addButton(QW.QDialogButtonBox.Ignore).clicked.connect(self.ignore)
+
+ layout = QW.QVBoxLayout()
+
+ if category == "error":
+ width, height = 725, 400
+ icon = "MessageBoxCritical"
+ tb_title = _("Error message")
+ tb_text = _("The following traceback may help to understand the problem:")
+ else:
+ width, height = 725, 200
+ icon = "MessageBoxWarning"
+ tb_title = _("Warning message")
+ tb_text = _("Please take into account the following warning message:")
+
+ if context is not None:
+ context = insert_spaces(context, 80)
+ msgprefix = _("An error has occured during the following context:")
+ text = "
".join([msgprefix, f"{context}"])
+ ct_groupbox = QW.QGroupBox(_("Context"), self)
+ ct_layout = QW.QHBoxLayout()
+ ct_image_layout = QW.QVBoxLayout()
+ ct_image = QW.QLabel()
+ ct_image.setPixmap(get_std_icon(icon).pixmap(24, 24))
+ ct_image.setSizePolicy(QW.QSizePolicy.Fixed, QW.QSizePolicy.Fixed)
+ ct_image_layout.addWidget(ct_image)
+ ct_image_layout.addStretch()
+ ct_layout.addLayout(ct_image_layout)
+ ct_label = QW.QLabel(text)
+ ct_label.setWordWrap(True)
+ ct_label.setAlignment(QC.Qt.AlignLeft | QC.Qt.AlignTop)
+ ct_layout.addWidget(ct_label)
+ ct_groupbox.setLayout(ct_layout)
+ ct_groupbox.setSizePolicy(
+ QW.QSizePolicy.MinimumExpanding, QW.QSizePolicy.Fixed
+ )
+ layout.addWidget(ct_groupbox)
+
+ tb_groupbox = QW.QGroupBox(tb_title, self)
+ tb_layout = QW.QVBoxLayout()
+ tb_layout.addWidget(QW.QLabel(tb_text))
+ tb_layout.addWidget(self.shell)
+ tb_groupbox.setLayout(tb_layout)
+ layout.addWidget(tb_groupbox)
+
+ if tip is not None:
+ tip_groupbox = QW.QGroupBox(_("Tip"), self)
+ tip_layout = QW.QHBoxLayout()
+ tip_image_layout = QW.QVBoxLayout()
+ tip_image = QW.QLabel()
+ tip_image.setPixmap(get_std_icon("MessageBoxInformation").pixmap(24, 24))
+ tip_image.setSizePolicy(QW.QSizePolicy.Fixed, QW.QSizePolicy.Fixed)
+ tip_image_layout.addWidget(tip_image)
+ tip_image_layout.addStretch()
+ tip_layout.addLayout(tip_image_layout)
+ tip_label = QW.QLabel(tip)
+ tip_label.setWordWrap(True)
+ tip_label.setAlignment(QC.Qt.AlignLeft | QC.Qt.AlignTop)
+ tip_layout.addWidget(tip_label)
+ tip_groupbox.setLayout(tip_layout)
+ tip_groupbox.setSizePolicy(
+ QW.QSizePolicy.MinimumExpanding, QW.QSizePolicy.Fixed
+ )
+ layout.addWidget(tip_groupbox)
+
+ layout.addSpacing(10)
+ if category == "warning":
+ layout.addWidget(
+ QW.QLabel(
+ _(
+ "Please click on the 'Ignore' button to "
+ "ignore this warning next time."
+ )
+ )
+ )
+ layout.addSpacing(10)
+
+ layout.addWidget(bbox)
+
+ self.setLayout(layout)
+ self.resize(width, height)
+
+ bbox.button(QW.QDialogButtonBox.Ok).setFocus()
+
+ def ignore(self):
+ """Ignore warning next time"""
+ get_conf().ignore_warnings.set(True)
+ self.accept()
+
+
+def show_warning_error(
+ parent: QW.QWidget,
+ category: str,
+ context: str = None,
+ message: str = None,
+ tip: str = None,
+) -> None:
+ """Show error message
+
+ Args:
+ parent (QW.QWidget): parent widget
+ category (str): message category ("error" or "warning")
+ context (str | None): context. Defaults to None.
+ message (str | None): message. Defaults to None.
+ tip (str | None): tip. Defaults to None.
+ """
+ if category == "warning" and get_conf().ignore_warnings.get():
+ return
+ dlg = WarningErrorMessageBox(parent, category, context, message, tip)
+ exec_dialog(dlg)
diff --git a/sigimax/widgets/wizard.py b/sigimax/widgets/wizard.py
new file mode 100644
index 0000000..426e626
--- /dev/null
+++ b/sigimax/widgets/wizard.py
@@ -0,0 +1,319 @@
+# Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
+
+"""
+SigimaX Wizard Widget
+---------------------
+
+The SigimaX Wizard is a widget that guides the user through a series of steps
+to complete a task. It is implemented as a series of pages, each of which is
+a separate widget.
+
+The `Wizard` class is the main widget that contains the pages. The `WizardPage`
+class is the base class for the pages.
+
+This module is strongly inspired from Qt's `QWizard` and `QWizardPage` classes.
+
+.. note::
+
+ The only motivation for reimplementing the wizard widget is to
+ support complete styling with `QPalette` and `QStyle` (e.g. `guidata`'s
+ dark mode is not supported on Windows).
+
+.. autoclass:: Wizard
+ :members:
+.. autoclass:: WizardPage
+ :members:
+"""
+
+from __future__ import annotations
+
+from guidata.configtools import get_icon
+from qtpy import QtCore as QC
+from qtpy import QtGui as QG
+from qtpy import QtWidgets as QW
+from qtpy.compat import getopenfilename
+from qtpy.QtWidgets import QWidget
+
+from sigimax.config import _, get_conf
+
+__all__ = [
+ "Wizard",
+ "WizardPage",
+]
+
+
+class WizardPage(QW.QWidget):
+ """Wizard page base class
+
+ We create our own wizard page class instead of using QWizardPage because
+ the latter does not support complete styling with `QPalette` and `QStyle`
+ (e.g. `guidata`'s dark mode is not supported on Windows).
+
+ This class reimplements the `QWizardPage` features.
+
+ """
+
+ SIG_INITIALIZE_PAGE = QC.Signal()
+ SIG_VALID_STATE_CHANGED = QC.Signal()
+
+ def __init__(self, parent: QW.QWidget | None = None) -> None:
+ super().__init__(parent)
+ if parent is None:
+ self.setWindowIcon(get_icon(get_conf().app_logo_path.get()))
+ self.__is_valid: bool = True
+ self.wizard: Wizard | None = None
+ self._main_layout = QW.QVBoxLayout()
+ self._user_layout = QW.QVBoxLayout()
+ self._title_label = QW.QLabel("")
+ font = self._title_label.font()
+ font.setPointSize(font.pointSize() + 4)
+ font.setBold(True)
+ self._title_label.setFont(font)
+ self._title_label.setStyleSheet("color: #1E90FF")
+ horiz_line = QW.QFrame()
+ horiz_line.setFrameShape(QW.QFrame.HLine)
+ horiz_line.setFrameShadow(QW.QFrame.Sunken)
+ self._subtitle_label = QW.QLabel("")
+ self._main_layout.addWidget(self._title_label)
+ self._main_layout.addWidget(self._subtitle_label)
+ self._main_layout.addWidget(horiz_line)
+ self._main_layout.addLayout(self._user_layout)
+ self.setLayout(self._main_layout)
+
+ def set_wizard(self, wizard: Wizard) -> None:
+ """Set the wizard"""
+ self.wizard = wizard
+
+ def get_wizard(self) -> Wizard:
+ """Return the wizard"""
+ return self.wizard
+
+ def set_title(self, title: str) -> None:
+ """Set the title of the page"""
+ self._title_label.setText(title)
+
+ def set_subtitle(self, subtitle: str) -> None:
+ """Set the subtitle of the page"""
+ self._subtitle_label.setText(subtitle)
+
+ def set_valid(self, is_valid: bool) -> None:
+ """Set the page as valid"""
+ self.__is_valid = is_valid
+ self.SIG_VALID_STATE_CHANGED.emit()
+
+ def is_valid(self) -> bool:
+ """Return whether the page is valid"""
+ return self.__is_valid
+
+ def add_to_layout(self, layout: QW.QLayout | QW.QWidget) -> None:
+ """Add a layout to the user layout"""
+ if isinstance(layout, QW.QWidget):
+ self._user_layout.addWidget(layout)
+ else:
+ self._user_layout.addLayout(layout)
+
+ def add_stretch(self) -> None:
+ """Add a stretch to the user layout"""
+ self._user_layout.addStretch()
+
+ def initialize_page(self) -> None:
+ """Initialize the page"""
+ self.SIG_INITIALIZE_PAGE.emit()
+
+ def validate_page(self) -> bool:
+ """Validate the page"""
+ return self.is_valid()
+
+
+class Wizard(QW.QDialog):
+ """Wizard base class"""
+
+ def __init__(self, parent: QWidget | None = None) -> None:
+ super().__init__(parent)
+
+ _main_layout = QW.QVBoxLayout()
+ self.setLayout(_main_layout)
+
+ self._pages_widget = QW.QStackedWidget()
+ _main_layout.addWidget(self._pages_widget)
+
+ btn_layout = QW.QHBoxLayout()
+ self._back_btn = QW.QPushButton(_("Back"))
+ self._back_btn.clicked.connect(self.go_to_previous_page)
+ self._next_btn = QW.QPushButton(_("Next"))
+ self._next_btn.clicked.connect(self.go_to_next_page)
+ self._finish_btn = QW.QPushButton(_("Finish"))
+ self._finish_btn.clicked.connect(self.accept)
+ self._cancel_btn = QW.QPushButton(_("Cancel"))
+ self._cancel_btn.clicked.connect(self.reject)
+ btn_layout.addWidget(self._back_btn)
+ btn_layout.addWidget(self._next_btn)
+ btn_layout.addWidget(self._finish_btn)
+ btn_layout.addWidget(self._cancel_btn)
+ _main_layout.addLayout(btn_layout)
+
+ self.setSizePolicy(
+ QW.QSizePolicy(QW.QSizePolicy.Minimum, QW.QSizePolicy.Minimum)
+ )
+
+ def cleanup(self) -> None:
+ """Release page resources before the dialog is destroyed.
+
+ Pages that embed native-heavy widgets (e.g. a PlotPy plot) may expose a
+ ``cleanup`` method to tear those resources down deterministically. This
+ avoids a Qt/PlotPy native teardown race (access violation) when several
+ wizards are created and destroyed in sequence.
+ """
+ for index in range(self._pages_widget.count()):
+ page = self._pages_widget.widget(index)
+ page_cleanup = getattr(page, "cleanup", None)
+ if callable(page_cleanup):
+ page_cleanup()
+
+ def closeEvent(self, event: QG.QCloseEvent) -> None: # pylint: disable=invalid-name
+ """Release page resources when the dialog is closed"""
+ self.cleanup()
+ super().closeEvent(event)
+
+ def add_page(self, page: WizardPage, last_page: bool = False) -> None:
+ """Add a page to the wizard"""
+ page.set_wizard(self)
+ page.SIG_INITIALIZE_PAGE.connect(self.__update_button_states)
+ page.SIG_VALID_STATE_CHANGED.connect(self.__update_button_states)
+ self._pages_widget.addWidget(page)
+ if last_page:
+ self._pages_widget.widget(0).initialize_page()
+
+ def __update_button_states(self, index: int | None = None) -> None:
+ """Update button states"""
+ if index is None:
+ index = self._pages_widget.currentIndex()
+ self._back_btn.setEnabled(index > 0)
+ not_last_page = index < self._pages_widget.count() - 1
+ page_valid = self._pages_widget.currentWidget().is_valid()
+ self._next_btn.setEnabled(not_last_page and page_valid)
+ is_last_page = index == self._pages_widget.count() - 1
+ self._finish_btn.setEnabled(is_last_page and page_valid)
+
+ def go_to_previous_page(self) -> None:
+ """Go to the previous page"""
+ self._pages_widget.setCurrentIndex(self._pages_widget.currentIndex() - 1)
+ self.__update_button_states()
+
+ def go_to_next_page(self) -> None:
+ """Go to the next page"""
+ if self.validate_page():
+ self._pages_widget.setCurrentIndex(self._pages_widget.currentIndex() + 1)
+ self.initialize_page()
+
+ def initialize_page(self) -> None:
+ """Initialize the page"""
+ self._pages_widget.currentWidget().initialize_page()
+
+ def validate_page(self) -> bool:
+ """Validate the page"""
+ return self._pages_widget.currentWidget().validate_page()
+
+ def accept(self) -> None:
+ """Accept the wizard"""
+ if self.validate_page():
+ super().accept()
+
+
+class ExamplePage1(WizardPage):
+ """Example wizard page 1"""
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.set_title(_("Welcome to the Example Wizard"))
+ self.set_subtitle(
+ _("This wizard will guide you through the process of importing data.")
+ )
+
+ def initialize_page(self) -> None:
+ """Initialize the page"""
+ print("ExamplePage1 initialized")
+ super().initialize_page()
+
+ def validate_page(self) -> bool:
+ """Validate the page"""
+ print("ExamplePage1 validated")
+ return super().validate_page()
+
+
+class ExamplePage2(WizardPage):
+ """Example wizard page 2"""
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.set_title(_("Select the Source of the Data"))
+ self.set_subtitle(
+ _("Select the source of the data to be imported (clipboard or file).")
+ )
+ self._clipboard_rb = QW.QRadioButton(_("Clipboard"))
+ self._file_rb = QW.QRadioButton(_("File"))
+ self._file_rb.toggled.connect(self.file_rb_toggled)
+ self._file_le = QW.QLineEdit()
+ self._file_btn = QW.QPushButton(_("Browse..."))
+ self._file_btn.clicked.connect(self.browse_file)
+ self.add_to_layout(self._clipboard_rb)
+ self.add_to_layout(self._file_rb)
+ self.add_to_layout(self._file_le)
+ self.add_to_layout(self._file_btn)
+
+ def initialize_page(self) -> None:
+ """Initialize the page"""
+ print("ExamplePage2 initialized")
+ super().initialize_page()
+
+ def file_rb_toggled(self, checked: bool) -> None:
+ """File radio button toggled"""
+ self._file_le.setEnabled(checked)
+ self._file_btn.setEnabled(checked)
+
+ def browse_file(self) -> None:
+ """Browse file"""
+ file_name, _filt = getopenfilename(
+ self,
+ _("Select the File to Import"),
+ "",
+ _("CSV Files (*.csv);;Text Files (*.txt);;All Files (*)"),
+ )
+ if file_name:
+ self._file_le.setText(file_name)
+
+ def validate_page(self) -> bool:
+ """Validate the page"""
+ if self._file_rb.isChecked() and not self._file_le.text():
+ QW.QMessageBox.critical(
+ self,
+ _("Error"),
+ _("Please select the file to import."),
+ QW.QMessageBox.Ok,
+ )
+ return False
+ return True
+
+
+class ExampleWizard(Wizard):
+ """Example wizard widget"""
+
+ def __init__(self) -> None:
+ super().__init__()
+ self.setWindowTitle(_("Example Wizard"))
+ self.add_page(ExamplePage1())
+ self.add_page(ExamplePage2(), last_page=True)
+
+
+def test_example_wizard():
+ """Test the import wizard"""
+ # pylint: disable=import-outside-toplevel
+ from guidata.qthelpers import qt_app_context
+
+ with qt_app_context():
+ wizard = ExampleWizard()
+ wizard.exec()
+
+
+if __name__ == "__main__":
+ test_example_wizard()