| 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:
👉 ͳ8qXD}{M(
F5\;+ܜ\LBqƳ~N6_#U{ Ls|pr`; dKm R
[-.][\w.]+)?$"
)
def _parse_tag(tag: str) -> tuple[int, int, int, str]:
"""Return ``(major, minor, patch, pre)`` from ``vX.Y.Z[-preN]``."""
match = TAG_RE.match(tag)
if not match:
raise SystemExit(
f"Tag {tag!r} does not match the expected pattern vMAJOR.MINOR.PATCH[-preN]"
)
return (
int(match["major"]),
int(match["minor"]),
int(match["patch"]),
match["pre"] or "",
)
def _read_sigimax_version() -> str:
metadata = REPO_ROOT / "sigimax" / "_metadata.py"
text = metadata.read_text(encoding="utf-8")
match = re.search(r'^__version__\s*=\s*"([^"]+)"', text, re.MULTILINE)
if not match:
raise SystemExit(f"Could not find __version__ in {metadata}")
return match.group(1)
def cmd_check_tag(args: argparse.Namespace) -> int:
major, minor, patch, _pre = _parse_tag(args.tag)
tag_version = f"{major}.{minor}.{patch}"
code_version = _read_sigimax_version()
# Drop any local pre-release suffix in the code version for comparison.
code_base = re.split(r"[-+]", code_version, maxsplit=1)[0]
if tag_version != code_base:
print(
f"::error::Tag version {tag_version!r} does not match "
f"sigimax.__version__ {code_version!r}",
file=sys.stderr,
)
return 1
print(f"Tag {args.tag} matches sigimax.__version__={code_version}")
return 0
def _release_notes_path(major: int, minor: int) -> Path:
return RELEASE_NOTES_DIR / f"release_{major}.{minor:02d}.md"
def cmd_release_notes(args: argparse.Namespace) -> int:
major, minor, _patch, _pre = _parse_tag(args.tag)
path = _release_notes_path(major, minor)
if not path.is_file():
print(
f"::error::Release notes file not found: {path.relative_to(REPO_ROOT)}",
file=sys.stderr,
)
return 1
content = path.read_text(encoding="utf-8")
if args.output:
Path(args.output).write_text(content, encoding="utf-8")
print(f"Wrote {args.output}")
else:
# Force UTF-8 on stdout so the script works on Windows consoles too.
sys.stdout.buffer.write(content.encode("utf-8"))
return 0
def main(argv: list[str] | None = None) -> int:
parser = argparse.ArgumentParser(description=__doc__.splitlines()[1])
sub = parser.add_subparsers(dest="cmd", required=True)
p_check = sub.add_parser(
"check-tag", help="Validate tag against sigimax.__version__"
)
p_check.add_argument("tag", help="Release tag, e.g. v1.3.0 or v1.3.0-rc1")
p_check.set_defaults(func=cmd_check_tag)
p_notes = sub.add_parser(
"release-notes", help="Print release notes file for the given tag"
)
p_notes.add_argument("tag", help="Release tag, e.g. v1.3.0")
p_notes.add_argument(
"-o", "--output", help="Optional output file (default: stdout)"
)
p_notes.set_defaults(func=cmd_release_notes)
args = parser.parse_args(argv)
return args.func(args)
if __name__ == "__main__":
sys.exit(main())
DataLab-Platform-SigimaX-0182bf4/scripts/reinstall_dev.py 0000664 0000000 0000000 00000006667 15244251443 0023372 0 ustar 00root root 0000000 0000000 # script/reinstall_dev.py
"""
Reinstall multiple local libraries in editable mode for development.
Workflow:
1) Try to uninstall all target libraries in one command (ignore errors if some are not
installed).
2) Reinstall each library in editable mode from a sibling folder: ../.
This script uses the same Python interpreter that runs it (sys.executable),
so pip operations happen in the same environment (e.g., your active venv).
"""
from __future__ import annotations
import os
import shutil
import subprocess
import sys
import sysconfig
from typing import Iterable
# Absolute path to the Python executable that runs this script.
# Using sys.executable ensures pip targets the same environment (e.g., your venv).
PY = sys.executable
def run(cmd: list[str]) -> None:
"""
Echo and execute a subprocess command.
Raises:
subprocess.CalledProcessError: if the command returns a non-zero exit code.
"""
print("$", " ".join(cmd), flush=True)
subprocess.check_call(cmd)
def uninstall_many(packages: Iterable[str]) -> None:
"""
Attempt to uninstall multiple packages at once.
If uninstall fails (e.g., a package is not installed), we keep going.
Args:
packages: An iterable of package names (pip distribution names).
"""
pkgs = list(packages)
if not pkgs:
return
try:
run([PY, "-m", "pip", "uninstall", "-y", *pkgs])
except subprocess.CalledProcessError as e:
# Continue even if the uninstall step fails (for one or more packages)
print(f"[WARN] Uninstall returned {e.returncode} — continuing...", flush=True)
def install_editable_many(packages: Iterable[str]) -> None:
"""
Install each package in editable mode from ../.
Assumes your project layout has sibling folders one level up, e.g.:
../guidata
Args:
packages: An iterable of package names (also used as directory names).
"""
for pkg in packages:
run([PY, "-m", "pip", "install", "-e", f"../{pkg}"])
def remove_residual_dirs(packages: Iterable[str]) -> None:
"""
Force remove residual package directories from site-packages.
This mimics: rm -rf .venv/Lib/site-packages/
to ensure a clean slate before reinstalling.
"""
# Locates site-packages, e.g. .venv/Lib/site-packages
site_packages = sysconfig.get_path("purelib")
for pkg in packages:
target = os.path.join(site_packages, pkg)
if os.path.isdir(target):
print(f"Removing residual directory: {target}", flush=True)
try:
shutil.rmtree(target)
except OSError as e:
print(f"[WARN] Failed to remove {target}: {e}", flush=True)
def reinstall_packages(packages: list[str]) -> None:
"""
High-level orchestration for many packages:
- Uninstall all of them (ignore failures)
- Force remove residual directories from site-packages
- Install each in editable mode
"""
# 1) Uninstall (ignore if not installed)
uninstall_many(packages)
# 2) Force remove residual directories (essential for clean reinstall)
remove_residual_dirs(packages)
# 3) Editable installs
install_editable_many(packages)
if __name__ == "__main__":
# ⭐ Fixed, editable local libraries to manage (edit as needed)
PACKAGES = ["guidata", "plotpy", "sigima"]
print("🏃 Reinstalling editable packages:", ", ".join(PACKAGES))
reinstall_packages(PACKAGES)
DataLab-Platform-SigimaX-0182bf4/scripts/run_with_env.py 0000664 0000000 0000000 00000017045 15244251443 0023236 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""Run a command with environment variables loaded from a .env file.
This script automatically detects the best Python interpreter to use:
1. ``PYTHON`` variable in ``.env`` file (e.g. for WinPython distributions)
2. ``WINPYDIRBASE`` variable (legacy WinPython base directory)
3. ``VENV_DIR`` variable (explicit virtual environment directory)
4. A local virtual environment (``.venv*`` directory in the project root)
5. Falls back to ``sys.executable`` (the Python that launched this script)
This ensures that VS Code tasks always use the correct Python environment
regardless of which interpreter is configured globally or in VS Code.
"""
from __future__ import annotations
import glob
import os
import subprocess
import sys
from pathlib import Path
def _find_venv_python(project_root: Path) -> str | None:
"""Find a Python executable in a ``.venv*`` directory.
Searches for directories matching ``.venv*`` in the project root and
returns the first valid Python executable found.
Args:
project_root: The root directory of the project.
Returns:
Absolute path to the venv Python executable, or None if not found.
"""
# Sort to prefer ".venv" over ".venv-xyz" etc.
venv_dirs = sorted(glob.glob(str(project_root / ".venv*")))
for venv_dir in venv_dirs:
venv_path = Path(venv_dir)
if not venv_path.is_dir():
continue
result = _get_venv_python(venv_path)
if result:
return result
return None
def _get_venv_python(venv_dir: Path) -> str | None:
"""Get the Python executable from a specific venv directory.
Args:
venv_dir: Path to the virtual environment directory.
Returns:
Absolute path to the Python executable, or None if not found.
"""
if not venv_dir.is_dir():
return None
# Windows: Scripts/python.exe — Unix: bin/python
candidates = [
venv_dir / "Scripts" / "python.exe",
venv_dir / "bin" / "python",
]
for candidate in candidates:
if candidate.is_file():
# Keep the venv-local executable path without resolving symlinks:
# on Linux/WSL, ``bin/python`` is often a symlink to a global
# interpreter (e.g. /usr/bin/python3.x). Resolving it would lose
# venv context and site-packages selection.
return str(candidate.absolute())
return None
def resolve_python(project_root: Path) -> str:
"""Resolve the best Python interpreter for the project.
Priority order:
1. ``PYTHON`` environment variable (set in ``.env`` or externally)
2. ``WINPYDIRBASE`` environment variable (legacy WinPython base directory)
3. ``VENV_DIR`` environment variable (explicit venv directory)
4. ``.venv*`` directory in *project_root* (auto-discovery)
5. ``sys.executable`` (the interpreter running this script)
Args:
project_root: The root directory of the project.
Returns:
Absolute path to the Python executable to use.
"""
# 1. Explicit PYTHON variable (e.g. WinPython distribution)
python_env = os.environ.get("PYTHON")
if python_env:
python_path = Path(python_env)
if python_path.is_file():
# Do not resolve symlinks for the same reason as in
# ``_get_venv_python``.
resolved = str(python_path.absolute())
print(f" 🐍 Using PYTHON from .env: {resolved}")
return resolved
print(f" ⚠️ PYTHON variable set but not found: {python_env}")
# 2. Legacy WINPYDIRBASE variable (WinPython distribution)
winpy_base = os.environ.get("WINPYDIRBASE")
if winpy_base and Path(winpy_base).is_dir():
# Search for python.exe in the WinPython directory structure
# Patterns: python-3.11.5.amd64/python.exe (old) or python/python.exe (new)
for pattern in ("python-*/python.exe", "python/python.exe"):
for candidate in sorted(Path(winpy_base).glob(pattern)):
if candidate.is_file():
resolved = str(candidate.absolute())
print(f" 🐍 Using WINPYDIRBASE (legacy): {resolved}")
return resolved
# Also try direct python.exe in the base directory
direct = Path(winpy_base) / "python.exe"
if direct.is_file():
resolved = str(direct.absolute())
print(f" 🐍 Using WINPYDIRBASE (legacy): {resolved}")
return resolved
print(f" ⚠️ WINPYDIRBASE set but no Python found in: {winpy_base}")
# 3. Explicit VENV_DIR variable (e.g. for multiple local venvs)
venv_dir_env = os.environ.get("VENV_DIR")
if venv_dir_env:
venv_dir = Path(venv_dir_env)
if not venv_dir.is_absolute():
venv_dir = project_root / venv_dir
venv_python = _get_venv_python(venv_dir)
if venv_python:
print(f" 🐍 Using VENV_DIR from .env: {venv_python}")
return venv_python
print(f" ⚠️ VENV_DIR set but no Python found in: {venv_dir}")
# 4. Auto-discover local venv
venv_python = _find_venv_python(project_root)
if venv_python:
print(f" 🐍 Using venv Python: {venv_python}")
return venv_python
# 5. Fallback
print(f" 🐍 Using caller Python: {sys.executable}")
return sys.executable
def load_env_file(env_path: str | None = None) -> None:
"""Load environment variables from a .env file."""
if env_path is None:
env_path = Path.cwd() / ".env"
if not Path(env_path).is_file():
raise FileNotFoundError(f"Environment file not found: {env_path}")
print(f"Loading environment variables from: {env_path}")
with open(env_path, encoding="utf-8") as f:
for line in f:
line = line.strip()
if not line or line.startswith("#") or "=" not in line:
continue
key, value = line.split("=", 1)
value = value.strip().strip('"').strip("'")
os.environ[key.strip()] = value
print(f" Loaded variable: {key.strip()}={value}")
def execute_command(command: list[str], python_exe: str) -> int:
"""Execute a command, replacing ``python`` placeholders.
Any argument that is the bare word ``python`` or that points to a Python
executable (checked via filename) is replaced by *python_exe* so that the
subprocess uses the resolved interpreter rather than the global one.
Args:
command: The command and its arguments.
python_exe: The resolved Python interpreter path.
Returns:
The subprocess exit code.
"""
resolved: list[str] = []
for arg in command:
if arg.lower() == "python" or (
Path(arg).name.lower().startswith("python")
and Path(arg).is_file()
and arg.lower() != python_exe.lower()
):
resolved.append(python_exe)
else:
resolved.append(arg)
print("Executing command:")
print(" ".join(resolved))
print("")
result = subprocess.call(resolved)
print(f"Process exited with code {result}")
return result
def main() -> None:
"""Main function to load environment variables and execute a command."""
if len(sys.argv) < 2:
print("Usage: python run_with_env.py [args ...]")
sys.exit(1)
print("🏃 Running with environment variables")
project_root = Path.cwd()
load_env_file()
python_exe = resolve_python(project_root)
return execute_command(sys.argv[1:], python_exe)
if __name__ == "__main__":
main()
DataLab-Platform-SigimaX-0182bf4/sigimax/ 0000775 0000000 0000000 00000000000 15244251443 0020120 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/__init__.py 0000664 0000000 0000000 00000001766 15244251443 0022243 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
SigimaX
=======
SigimaX is a generic app components library based on Python
scientific libraries (such as NumPy, SciPy or scikit-image) and Qt graphical
user interfaces (thanks to `PlotPyStack`_ libraries).
It helps building scientific computing applications by providing a set of GUI modules.
.. _PlotPyStack: https://github.com/PlotPyStack
"""
__all__ = [
"SGMXMainWindow",
"create",
"run",
]
from sigimax._metadata import ( # noqa: F401
__docurl__,
__homeurl__,
__supporturl__,
__version__,
)
from sigimax.app import create, run
from sigimax.mainwindow import SGMXMainWindow
# --- Important note: DATAPATH and LOCALEPATH are used by guidata.configtools
# --- to retrieve data and translation files paths
#
# Dear (Debian, RPM, ...) package makers, please feel free to customize the
# following path to module's data (images) and translations:
DATAPATH = LOCALEPATH = ""
DataLab-Platform-SigimaX-0182bf4/sigimax/_metadata.py 0000664 0000000 0000000 00000002352 15244251443 0022413 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
SigimaX package metadata
=========================
This module centralizes package-level metadata (version, URLs) in a single
file that has **no internal imports**.
Why a separate module?
~~~~~~~~~~~~~~~~~~~~~~
SigimaX is a framework library whose ``__init__.py`` re-exports key symbols
(``SGMXMainWindow``, ``create``, ``run``) for convenience. Those re-exports
pull in heavy submodules (``sigimax.app``, ``sigimax.mainwindow``) which
eventually import ``sigimax.config``. If ``sigimax.config`` were to import
metadata back from ``sigimax.__init__``, a circular import chain would form::
sigimax → sigimax.mainwindow → sigimax.widgets.* → sigimax.config → sigimax
By placing the metadata here, both ``__init__.py`` and ``config.py`` can
import it without triggering the cycle. This is the same pattern used by
projects like Flask and setuptools-scm that need a rich ``__init__.py``
alongside internal access to version information.
"""
__version__ = "1.0.2"
__docurl__ = "https://sigimax.readthedocs.io/"
__homeurl__ = "https://github.com/DataLab-Platform/SigimaX"
__supporturl__ = "https://github.com/DataLab-Platform/SigimaX/issues/new/choose"
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/ 0000775 0000000 0000000 00000000000 15244251443 0023332 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/__init__.py 0000664 0000000 0000000 00000005226 15244251443 0025450 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
Adapters for PlotPy
===================
The :mod:`sigimax.adapters_plotpy` package provides adapters for
PlotPy to integrate with SigimaX's data model and GUI.
Each Sigima object (:class:`~sigima.objects.SignalObj`,
:class:`~sigima.objects.ImageObj`, ROI classes) is converted to/from PlotPy
plot items by a dedicated adapter class. :class:`PlotPyAdapterFactory`
resolves which adapter class to use for a given object; derived applications
subclass the factory to override or extend this resolution and install it
with :func:`set_adapter_factory`.
.. autoclass:: PlotPyAdapterFactory
:members:
.. autofunction:: get_adapter_factory
.. autofunction:: set_adapter_factory
.. autofunction:: reset_adapter_factory
.. autofunction:: create_adapter_from_object
.. autoclass:: SignalObjPlotPyAdapter
:members:
.. autoclass:: ImageObjPlotPyAdapter
:members:
.. autoclass:: SegmentROIPlotPyAdapter
:members:
.. autoclass:: SignalROIPlotPyAdapter
:members:
.. autoclass:: RectangularROIPlotPyAdapter
:members:
.. autoclass:: CircularROIPlotPyAdapter
:members:
.. autoclass:: PolygonalROIPlotPyAdapter
:members:
.. autofunction:: items_to_json
.. autofunction:: json_to_items
.. autofunction:: plotitem_to_singleroi
.. autofunction:: singleroi_to_plotitem
.. autofunction:: configure_roi_item
"""
from __future__ import annotations
from .base import items_to_json, json_to_items
from .converters import (
create_adapter_from_object,
plotitem_to_singleroi,
singleroi_to_plotitem,
)
from .factories import (
PlotPyAdapterFactory,
get_adapter_factory,
reset_adapter_factory,
set_adapter_factory,
)
from .objects.base import TypePlotItem
from .objects.image import (
ImageObjPlotPyAdapter,
)
from .objects.signal import CURVESTYLES, SignalObjPlotPyAdapter
from .roi.base import TypeROIItem, configure_roi_item
from .roi.image import (
CircularROIPlotPyAdapter,
PolygonalROIPlotPyAdapter,
RectangularROIPlotPyAdapter,
)
from .roi.signal import SegmentROIPlotPyAdapter, SignalROIPlotPyAdapter
__all__ = [
"CURVESTYLES",
"CircularROIPlotPyAdapter",
"ImageObjPlotPyAdapter",
"PlotPyAdapterFactory",
"PolygonalROIPlotPyAdapter",
"RectangularROIPlotPyAdapter",
"SegmentROIPlotPyAdapter",
"SignalObjPlotPyAdapter",
"SignalROIPlotPyAdapter",
"TypePlotItem",
"TypeROIItem",
"configure_roi_item",
"create_adapter_from_object",
"get_adapter_factory",
"items_to_json",
"json_to_items",
"plotitem_to_singleroi",
"reset_adapter_factory",
"set_adapter_factory",
"singleroi_to_plotitem",
]
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/annotations.py 0000664 0000000 0000000 00000007425 15244251443 0026251 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
Annotation Adapter for PlotPy Integration
-----------------------------------------
This module bridges Sigima's format-agnostic annotation storage with PlotPy's
plot item system. It handles bidirectional conversion between:
- Sigima: list[dict] (JSON-serializable)
- PlotPy: list[AnnotatedShape] (plot items)
"""
from __future__ import annotations
import json
from typing import TYPE_CHECKING
from guidata.io import JSONReader, JSONWriter
from plotpy.io import load_items, save_items
if TYPE_CHECKING:
from plotpy.items import AnnotatedShape
from sigima.objects.base import BaseObj
class PlotPyAnnotationAdapter:
"""Adapter for converting between Sigima annotations and PlotPy items.
This class provides the bridge between Sigima's generic annotation storage
(list of dicts) and PlotPy's specific plot item format.
Example:
>>> from sigima.objects.signal.creation import create_signal
>>> obj = create_signal("Test")
>>> adapter = PlotPyAnnotationAdapter(obj)
>>>
>>> # Add PlotPy items
>>> from plotpy.items import AnnotatedRectangle
>>> rect = AnnotatedRectangle(0, 0, 10, 10)
>>> adapter.add_items([rect])
>>>
>>> # Retrieve as PlotPy items
>>> items = adapter.get_items()
>>> len(items)
1
"""
def __init__(self, obj: BaseObj):
"""Initialize adapter with an object.
Args:
obj: Signal or image object with annotation support
"""
self.obj = obj
def get_items(self) -> list[AnnotatedShape]:
"""Get annotations as PlotPy items.
Returns:
List of PlotPy annotation items
Notes:
This method deserializes the JSON data stored in the object using
PlotPy's load_items() function.
"""
annotations = self.obj.get_annotations()
if not annotations:
return []
items = []
for ann_dict in annotations:
# Each annotation dict should contain PlotPy's JSON serialization
if "plotpy_json" in ann_dict:
try:
json_str = ann_dict["plotpy_json"]
for item in load_items(JSONReader(json_str)):
items.append(item)
except (json.JSONDecodeError, ValueError, KeyError):
# Skip invalid items
continue
return items
def set_items(self, items: list[AnnotatedShape]) -> None:
"""Set annotations from PlotPy items.
Args:
items: List of PlotPy annotation items
Notes:
This method serializes PlotPy items to JSON using PlotPy's
save_items() function and stores them in the Sigima format.
"""
if not items:
self.obj.clear_annotations()
return
# Convert PlotPy items to our annotation format
annotations = []
for item in items:
writer = JSONWriter(None)
save_items(writer, [item])
ann_dict = {
"type": "plotpy_item",
"item_class": item.__class__.__name__,
"plotpy_json": writer.get_json(),
}
annotations.append(ann_dict)
self.obj.set_annotations(annotations)
def add_items(self, items: list[AnnotatedShape]) -> None:
"""Add PlotPy items to existing annotations.
Args:
items: List of PlotPy annotation items to add
"""
current_items = self.get_items()
current_items.extend(items)
self.set_items(current_items)
def clear(self) -> None:
"""Clear all annotations."""
self.obj.clear_annotations()
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/base.py 0000664 0000000 0000000 00000005354 15244251443 0024625 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
PlotPy Adapter Base Module
--------------------------
"""
# pylint: disable=invalid-name # Allows short reference names like x, y, ...
from __future__ import annotations
import json
from typing import TYPE_CHECKING
from guidata.io import JSONReader, JSONWriter
from plotpy.io import load_items, save_items
from plotpy.items import (
AbstractLabelItem,
AnnotatedSegment,
AnnotatedShape,
)
if TYPE_CHECKING:
from plotpy.items import AbstractShape
from plotpy.styles import AnnotationParam
def config_annotated_shape(
item: AnnotatedShape,
fmt: str,
lbl: bool,
section: str | None = None,
option: str | None = None,
show_computations: bool | None = None,
):
"""Configurate annotated shape
Args:
item: Annotated shape item
fmt: Format string
lbl: Show label
section: Shape style section (e.g. "plot")
option: Shape style option (e.g. "shape/drag")
show_computations: Show computations
"""
param: AnnotationParam = item.annotationparam
param.format = fmt
param.show_label = lbl
if show_computations is not None:
param.show_computations = show_computations
if isinstance(item, AnnotatedSegment):
item.label.labelparam.anchor = "T"
item.label.labelparam.update_item(item.label)
param.update_item(item)
if section is not None and option is not None:
item.set_style(section, option)
# TODO: [P3] Move this function as a method of plot items in PlotPy
def set_plot_item_editable(
item: AbstractShape | AbstractLabelItem | AnnotatedShape, state
):
"""Set plot item editable state
Args:
item: Plot item
state: State
"""
item.set_movable(state)
item.set_resizable(state and not isinstance(item, AbstractLabelItem))
item.set_rotatable(state and not isinstance(item, AbstractLabelItem))
item.set_readonly(not state)
item.set_selectable(state)
def items_to_json(items: list) -> str | None:
"""Convert plot items to JSON string
Args:
items: list of plot items
Returns:
JSON string or None if items is empty
"""
if items:
writer = JSONWriter(None)
save_items(writer, items)
return writer.get_json(indent=4)
return None
def json_to_items(json_str: str | None) -> list:
"""Convert JSON string to plot items
Args:
json_str: JSON string or None
Returns:
List of plot items
"""
items = []
if json_str:
try:
for item in load_items(JSONReader(json_str)):
items.append(item)
except json.decoder.JSONDecodeError:
pass
return items
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/converters.py 0000664 0000000 0000000 00000003557 15244251443 0026110 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
PlotPy Adapter Converters
-------------------------
"""
# pylint: disable=invalid-name # Allows short reference names like x, y, ...
from __future__ import annotations
from typing import TYPE_CHECKING
from plotpy.items import (
AnnotatedCircle,
AnnotatedPolygon,
AnnotatedRectangle,
AnnotatedXRange,
)
from sigima.objects import (
CircularROI,
PolygonalROI,
RectangularROI,
SegmentROI,
)
from sigimax.adapters_plotpy.factories import (
create_adapter_from_object,
get_adapter_factory,
)
if TYPE_CHECKING:
from sigima.objects import ImageObj, SignalObj
def plotitem_to_singleroi(
plot_item: AnnotatedXRange
| AnnotatedRectangle
| AnnotatedCircle
| AnnotatedPolygon,
obj: SignalObj | ImageObj | None = None,
) -> SegmentROI | RectangularROI | CircularROI | PolygonalROI:
"""Create a single ROI from the given PlotPy item to integrate with SigimaX
Args:
plot_item: The PlotPy item for which to create a single ROI
obj: Optional signal or image object for coordinate rounding
Returns:
A single ROI instance
"""
adapter = get_adapter_factory().get_adapter_class_for_plot_item(plot_item)
return adapter.from_plot_item(plot_item, obj)
def singleroi_to_plotitem(
roi: SegmentROI | RectangularROI | CircularROI | PolygonalROI,
obj: SignalObj | ImageObj,
) -> AnnotatedXRange | AnnotatedRectangle | AnnotatedCircle | AnnotatedPolygon:
"""Create a PlotPy item from the given single ROI to integrate with SigimaX
Args:
roi: The single ROI for which to create a PlotPy item
obj: The object (signal or image) associated with the ROI
Returns:
A PlotPy item instance
"""
adapter = create_adapter_from_object(roi)
return adapter.to_plot_item(obj)
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/coordutils.py 0000664 0000000 0000000 00000013142 15244251443 0026074 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
ROI Coordinate Utilities
=========================
This module provides utility functions for rounding ROI coordinates to appropriate
precision based on the sampling characteristics of signals and images.
These functions are used when converting interactive PlotPy shapes to ROI objects
to ensure coordinates are displayed with reasonable precision.
"""
from __future__ import annotations
import numpy as np
from sigima.objects import ImageObj, ROI1DParam, ROI2DParam, SignalObj
def round_signal_coords(
obj: SignalObj, coords: list[float], precision_factor: float = 0.1
) -> list[float]:
"""Round signal coordinates to appropriate precision based on sampling period.
Rounds to a fraction of the median sampling period to avoid excessive decimal
places while maintaining reasonable precision.
Args:
obj: signal object
coords: coordinates to round
precision_factor: fraction of sampling period to use as rounding precision.
Default is 0.1 (1/10th of sampling period).
Returns:
Rounded coordinates
"""
if len(obj.x) < 2:
# Cannot compute sampling period, return coords as-is
return coords
# Compute median sampling period
sampling_period = float(np.median(np.diff(obj.x)))
if sampling_period == 0:
# Avoid division by zero for constant x arrays
return coords
# Round to specified fraction of sampling period
precision = sampling_period * precision_factor
# Determine number of decimal places
if precision > 0:
decimals = max(0, int(-np.floor(np.log10(precision))))
return [round(c, decimals) for c in coords]
return coords
def round_image_coords(
obj: ImageObj, coords: list[float], precision_factor: float = 0.1
) -> list[float]:
"""Round image coordinates to appropriate precision based on pixel spacing.
Rounds to a fraction of the pixel spacing to avoid excessive decimal places
while maintaining reasonable precision. Uses separate precision for X and Y.
Args:
obj: image object
coords: flat list of coordinates [x0, y0, x1, y1, ...] to round
precision_factor: fraction of pixel spacing to use as rounding precision.
Default is 0.1 (1/10th of pixel spacing).
Returns:
Rounded coordinates
Raises:
ValueError: if coords does not contain an even number of elements
"""
if len(coords) % 2 != 0:
raise ValueError("coords must contain an even number of elements (x, y pairs).")
if len(coords) == 0:
return coords
rounded = list(coords)
if obj.is_uniform_coords:
# Use dx, dy for uniform coordinates
precision_x = abs(obj.dx) * precision_factor
precision_y = abs(obj.dy) * precision_factor
else:
# Compute average spacing for non-uniform coordinates
if len(obj.xcoords) > 1:
avg_dx = float(np.mean(np.abs(np.diff(obj.xcoords))))
precision_x = avg_dx * precision_factor
else:
precision_x = 0
if len(obj.ycoords) > 1:
avg_dy = float(np.mean(np.abs(np.diff(obj.ycoords))))
precision_y = avg_dy * precision_factor
else:
precision_y = 0
# Round X coordinates (even indices)
if precision_x > 0:
decimals_x = max(0, int(-np.floor(np.log10(precision_x))))
for i in range(0, len(rounded), 2):
rounded[i] = round(rounded[i], decimals_x)
# Round Y coordinates (odd indices)
if precision_y > 0:
decimals_y = max(0, int(-np.floor(np.log10(precision_y))))
for i in range(1, len(rounded), 2):
rounded[i] = round(rounded[i], decimals_y)
return rounded
def round_signal_roi_param(
obj: SignalObj, param: ROI1DParam, precision_factor: float = 0.1
) -> None:
"""Round signal ROI parameter coordinates in-place.
Args:
obj: signal object
param: ROI parameter to round (modified in-place)
precision_factor: fraction of sampling period to use as rounding precision
"""
coords = round_signal_coords(obj, [param.xmin, param.xmax], precision_factor)
param.xmin, param.xmax = coords
def round_image_roi_param(
obj: ImageObj, param: ROI2DParam, precision_factor: float = 0.1
) -> None:
"""Round image ROI parameter coordinates in-place.
Args:
obj: image object
param: ROI parameter to round (modified in-place)
precision_factor: fraction of pixel spacing to use as rounding precision
"""
if param.geometry == "rectangle":
# Round x0, y0, dx, dy
x0, y0, x1, y1 = param.x0, param.y0, param.x0 + param.dx, param.y0 + param.dy
coords = round_image_coords(obj, [x0, y0, x1, y1], precision_factor)
param.x0, param.y0 = coords[0], coords[1]
# Round dx and dy to avoid floating-point errors in subtraction
dx_dy_rounded = round_image_coords(
obj, [coords[2] - coords[0], coords[3] - coords[1]], precision_factor
)
param.dx = dx_dy_rounded[0]
param.dy = dx_dy_rounded[1]
elif param.geometry == "circle":
# Round xc, yc, r
coords = round_image_coords(obj, [param.xc, param.yc], precision_factor)
param.xc, param.yc = coords
# Round radius using X precision
r_rounded = round_image_coords(obj, [param.r, 0], precision_factor)[0]
param.r = r_rounded
elif param.geometry == "polygon":
# Round polygon points
rounded = round_image_coords(obj, param.points.tolist(), precision_factor)
param.points = np.array(rounded)
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/factories.py 0000664 0000000 0000000 00000014432 15244251443 0025667 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
PlotPy Adapter Factories
------------------------
"""
# pylint: disable=invalid-name # Allows short reference names like x, y, ...
from __future__ import annotations
__all__ = [
"PlotPyAdapterFactory",
"create_adapter_from_object",
"get_adapter_factory",
"reset_adapter_factory",
"set_adapter_factory",
]
class PlotPyAdapterFactory:
"""Resolve the PlotPy adapter class associated with an object or plot item.
A derived application subclasses this factory to substitute its own
adapters or to support additional object types, then installs it with
:func:`set_adapter_factory` so that SigimaX components use it too.
"""
def get_adapter_class(self, object_to_adapt) -> type:
"""Return the adapter class for the given object.
Args:
object_to_adapt: The object to adapt (signal, image or ROI)
Returns:
The adapter class (instantiated with the object as sole argument)
Raises:
TypeError: If the object type is not supported
"""
# pylint: disable=import-outside-toplevel,cyclic-import
from sigima.objects import (
CircularROI,
ImageObj,
ImageROI,
PolygonalROI,
RectangularROI,
SegmentROI,
SignalObj,
SignalROI,
)
from sigimax.adapters_plotpy.objects.image import ImageObjPlotPyAdapter
from sigimax.adapters_plotpy.objects.signal import SignalObjPlotPyAdapter
from sigimax.adapters_plotpy.roi.image import (
CircularROIPlotPyAdapter,
ImageROIPlotPyAdapter,
PolygonalROIPlotPyAdapter,
RectangularROIPlotPyAdapter,
)
from sigimax.adapters_plotpy.roi.signal import (
SegmentROIPlotPyAdapter,
SignalROIPlotPyAdapter,
)
# Order matters: check more specific types (e.g. SegmentROI) before
# their more generic bases (e.g. SignalROI) where applicable.
type_to_adapter: tuple[tuple[type, type], ...] = (
(SignalObj, SignalObjPlotPyAdapter),
(SignalROI, SignalROIPlotPyAdapter),
(SegmentROI, SegmentROIPlotPyAdapter),
(ImageObj, ImageObjPlotPyAdapter),
(RectangularROI, RectangularROIPlotPyAdapter),
(CircularROI, CircularROIPlotPyAdapter),
(PolygonalROI, PolygonalROIPlotPyAdapter),
(ImageROI, ImageROIPlotPyAdapter),
)
for obj_type, adapter_class in type_to_adapter:
if isinstance(object_to_adapt, obj_type):
return adapter_class
raise TypeError(f"Unsupported object type: {type(object_to_adapt)}")
def get_adapter_class_for_plot_item(self, plot_item) -> type:
"""Return the single-ROI adapter class matching the given PlotPy item.
Args:
plot_item: The PlotPy item to convert back into a single ROI
Returns:
The single-ROI adapter class
Raises:
TypeError: If the plot item type is not supported
"""
# pylint: disable=import-outside-toplevel
from plotpy.items import (
AnnotatedCircle,
AnnotatedPolygon,
AnnotatedRectangle,
AnnotatedXRange,
)
from sigimax.adapters_plotpy.roi.image import (
CircularROIPlotPyAdapter,
PolygonalROIPlotPyAdapter,
RectangularROIPlotPyAdapter,
)
from sigimax.adapters_plotpy.roi.signal import SegmentROIPlotPyAdapter
if isinstance(plot_item, AnnotatedXRange):
return SegmentROIPlotPyAdapter
if isinstance(plot_item, AnnotatedRectangle):
return RectangularROIPlotPyAdapter
if isinstance(plot_item, AnnotatedCircle):
return CircularROIPlotPyAdapter
if isinstance(plot_item, AnnotatedPolygon):
return PolygonalROIPlotPyAdapter
raise TypeError(f"Unsupported PlotPy item type: {type(plot_item)}")
def create_adapter(self, object_to_adapt):
"""Create an adapter instance for the given object.
Args:
object_to_adapt: The object to adapt (signal, image or ROI)
Returns:
An adapter instance
"""
return self.get_adapter_class(object_to_adapt)(object_to_adapt)
#: The currently active adapter factory. Defaults to the SigimaX base factory;
#: a derived application installs its own via :func:`set_adapter_factory`. All
#: SigimaX modules resolve adapters through :func:`get_adapter_factory` (never
#: by binding the base factory directly), so that a derived application's
#: adapters are honoured transparently regardless of import order.
_active_factory: PlotPyAdapterFactory = PlotPyAdapterFactory()
def get_adapter_factory() -> PlotPyAdapterFactory:
"""Return the currently active adapter factory.
Returns:
The active factory (the SigimaX base by default, or the one installed
by a derived application via :func:`set_adapter_factory`).
"""
return _active_factory
def set_adapter_factory(factory: PlotPyAdapterFactory) -> None:
"""Install a derived application's adapter factory as the active one.
Args:
factory: The factory to activate (typically a subclass of
:class:`PlotPyAdapterFactory`).
Raises:
TypeError: If the factory is not a :class:`PlotPyAdapterFactory`.
"""
if not isinstance(factory, PlotPyAdapterFactory):
raise TypeError(
"Cannot install adapter factory: expected a PlotPyAdapterFactory "
f"instance, got {type(factory)}"
)
global _active_factory # pylint: disable=global-statement
_active_factory = factory
def reset_adapter_factory() -> None:
"""Restore the SigimaX base adapter factory as the active one."""
global _active_factory # pylint: disable=global-statement
_active_factory = PlotPyAdapterFactory()
def create_adapter_from_object(object_to_adapt):
"""Create an adapter for the given object to integrate with PlotPy
Args:
object_to_adapt: The object to adapt (signal, image, ROI, or scalar result)
Returns:
An adapter instance
"""
return get_adapter_factory().create_adapter(object_to_adapt)
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/objects/ 0000775 0000000 0000000 00000000000 15244251443 0024763 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/objects/__init__.py 0000664 0000000 0000000 00000000000 15244251443 0027062 0 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/objects/base.py 0000664 0000000 0000000 00000016261 15244251443 0026255 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
PlotPy Adapter Base Object Module
---------------------------------
"""
from __future__ import annotations
import abc
from typing import (
TYPE_CHECKING,
Any,
Generic,
TypeVar,
)
from guidata.dataset import update_dataset
from plotpy.items import (
AnnotatedShape,
)
from sigima.objects.base import (
ROI_KEY,
TypeObj,
)
from sigimax.adapters_plotpy.annotations import PlotPyAnnotationAdapter
from sigimax.adapters_plotpy.base import (
config_annotated_shape,
set_plot_item_editable,
)
from sigimax.config import get_conf
if TYPE_CHECKING:
from plotpy.items import CurveItem, MaskedXYImageItem
from sigima.config import OptionField
TypePlotItem = TypeVar("TypePlotItem", bound="CurveItem | MaskedXYImageItem")
class BaseObjPlotPyAdapter(Generic[TypeObj, TypePlotItem]):
"""Object (signal/image) plot item adapter class"""
DEFAULT_FMT = "s" # This is overriden in children classes
@property
def conf_format(self) -> OptionField:
"""Config option field holding the numeric format string.
Overridden in the image adapter to return the image-specific field.
Resolved at runtime via ``get_conf()`` so the active (possibly
derived-application) configuration is honoured.
"""
return get_conf().sig_format
def __init__(self, obj: TypeObj) -> None:
"""Initialize the adapter with the object.
Args:
obj: object (signal/image)
"""
self.obj = obj
# An empty format string in the configuration acts as a sentinel meaning
# "use the adapter's type-appropriate DEFAULT_FMT".
self.__default_options = {
"format": "%" + (self.conf_format.get() or self.DEFAULT_FMT),
"showlabel": get_conf().show_label.get(),
}
self.annotation_adapter = PlotPyAnnotationAdapter(obj)
def get_obj_option(self, name: str) -> Any:
"""Get object option value.
Args:
name: option name
Returns:
Option value
"""
default = self.__default_options[name]
return self.obj.get_metadata_option(name, default)
@abc.abstractmethod
def make_item(self, update_from: TypePlotItem | None = None) -> TypePlotItem:
"""Make plot item from data.
Args:
update_from: update
Returns:
Plot item
"""
@abc.abstractmethod
def update_item(self, item: TypePlotItem, data_changed: bool = True) -> None:
"""Update plot item from data.
Args:
item: plot item
data_changed: if True, data has changed
"""
def add_annotations_from_items(self, items: list) -> None:
"""Add object annotations (annotation plot items).
Args:
items: annotation plot items
"""
# Use the new annotation adapter
self.annotation_adapter.add_items(items)
def set_annotations_from_items(self, items: list) -> None:
"""Set object annotations (annotation plot items), replacing any existing ones.
Args:
items: annotation plot items
"""
# Use the new annotation adapter
self.annotation_adapter.set_items(items)
@abc.abstractmethod
def add_label_with_title(self, title: str | None = None) -> None:
"""Add label with title annotation
Args:
title: title (if None, use object title)
"""
def iterate_metadata_shape_items(
self, _key: str, _value: Any, _fmt: str, _lbl: bool
):
"""Hook: yield additional plot items for custom metadata entries.
Override in subclasses to handle application-specific metadata
(e.g., geometry results, table results). Called once for each metadata
entry whose key is not ``ROI_KEY``.
Args:
key: metadata key
value: metadata value
fmt: numeric format string (e.g. "%.3f")
lbl: whether to show labels
Yields:
Plot items for this metadata entry
"""
return
yield # noqa: RET504 -- make this a generator
def iterate_shape_items(self, editable: bool = False):
"""Iterate over shape items encoded in metadata (if any).
Args:
editable: if True, annotations are editable
Yields:
Plot item
"""
fmt = self.get_obj_option("format")
lbl = self.get_obj_option("showlabel")
for key, value in self.obj.metadata.items():
if key == ROI_KEY:
roi = self.obj.roi
if roi is not None:
# Delayed import to avoid circular dependency
# pylint: disable=import-outside-toplevel,cyclic-import
from sigimax.adapters_plotpy.roi.factory import create_roi_adapter
adapter = create_roi_adapter(roi)
yield from adapter.iterate_roi_items(
self.obj, fmt=fmt, lbl=lbl, editable=False
)
else:
yield from self.iterate_metadata_shape_items(key, value, fmt, lbl)
# Use the new annotation adapter to get items
if self.obj.has_annotations():
for item in self.annotation_adapter.get_items():
if isinstance(item, AnnotatedShape):
config_annotated_shape(item, fmt, lbl)
set_plot_item_editable(item, editable)
yield item
def update_plot_item_parameters(self, item: TypePlotItem) -> None:
"""Update plot item parameters from object data/metadata
Takes into account a subset of plot item parameters. Those parameters may
have been overriden by object metadata entries or other object data. The goal
is to update the plot item accordingly.
This is *almost* the inverse operation of `update_metadata_from_plot_item`.
Args:
item: plot item
"""
def_dict = get_conf().get_sigima_defaults(self.__class__.__name__[:3].lower())
self.obj.set_metadata_options_defaults(def_dict, overwrite=False)
# Subclasses have to override this method to update plot item parameters,
# then call this implementation of the method to update plot item.
update_dataset(item.param, self.obj.get_metadata_options())
item.param.update_item(item)
if item.selected:
item.select()
def update_metadata_from_plot_item(self, item: TypePlotItem) -> None:
"""Update metadata from plot item.
Takes into account a subset of plot item parameters. Those parameters may
have been modified by the user through the plot item GUI. The goal is to
update the metadata accordingly.
This is *almost* the inverse operation of `update_plot_item_parameters`.
Args:
item: plot item
"""
def_dict = get_conf().get_sigima_defaults(self.__class__.__name__[:3].lower())
for key in def_dict:
if hasattr(item.param, key): # In case the PlotPy version is not up-to-date
self.obj.set_metadata_option(key, getattr(item.param, key))
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/objects/image.py 0000664 0000000 0000000 00000013034 15244251443 0026420 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
PlotPy Adapter Image Module
---------------------------
"""
# 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.dataset import update_dataset
from plotpy.builder import make
from plotpy.items import MaskedXYImageItem
from sigima.objects import ImageObj
from sigimax.adapters_plotpy.objects.base import (
BaseObjPlotPyAdapter,
)
from sigimax.config import get_conf
if TYPE_CHECKING:
from sigima.config import OptionField
def get_obj_coords(obj: ImageObj) -> tuple[np.ndarray, np.ndarray]:
"""Get object coordinates
Args:
obj: image object
Returns:
x and y coordinates (pixel centers, not edges)
"""
if obj.is_uniform_coords:
shape = obj.data.shape
# Generate coordinates for pixel centers, not edges
# For N pixels: centers are at x0, x0+dx, x0+2*dx, ..., x0+(N-1)*dx
xcoords = np.linspace(obj.x0, obj.x0 + obj.dx * (shape[1] - 1), shape[1])
ycoords = np.linspace(obj.y0, obj.y0 + obj.dy * (shape[0] - 1), shape[0])
else:
xcoords, ycoords = obj.xcoords, obj.ycoords
return xcoords, ycoords
class ImageObjPlotPyAdapter(BaseObjPlotPyAdapter[ImageObj, MaskedXYImageItem]):
"""Image object plot item adapter class"""
DEFAULT_FMT = ".1f"
@property
def conf_format(self) -> OptionField:
"""Image numeric format option field (resolved at runtime)."""
return get_conf().ima_format
def update_plot_item_parameters(self, item: MaskedXYImageItem) -> None:
"""Update plot item parameters from object data/metadata
Takes into account a subset of plot item parameters. Those parameters may
have been overriden by object metadata entries or other object data. The goal
is to update the plot item accordingly.
This is *almost* the inverse operation of `update_metadata_from_plot_item`.
Args:
item: plot item
"""
o = self.obj
for axis in ("x", "y", "z"):
unit = getattr(o, axis + "unit")
fmt = r"%.1f"
if unit:
fmt = r"%.1f (" + unit + ")"
setattr(item.param, axis + "format", fmt)
item.set_xy(*get_obj_coords(o))
zmin, zmax = item.get_lut_range()
if o.zscalemin is not None or o.zscalemax is not None:
zmin = zmin if o.zscalemin is None else o.zscalemin
zmax = zmax if o.zscalemax is None else o.zscalemax
item.set_lut_range([zmin, zmax])
super().update_plot_item_parameters(item)
def update_metadata_from_plot_item(self, item: MaskedXYImageItem) -> None:
"""Update metadata from plot item.
Takes into account a subset of plot item parameters. Those parameters may
have been modified by the user through the plot item GUI. The goal is to
update the metadata accordingly.
This is *almost* the inverse operation of `update_plot_item_parameters`.
Args:
item: plot item
"""
super().update_metadata_from_plot_item(item)
o = self.obj
# Updating the LUT range:
o.zscalemin, o.zscalemax = item.get_lut_range()
def __viewable_data(self) -> np.ndarray:
"""Return viewable data"""
data = self.obj.data.real
if np.any(np.isnan(data)):
data = np.nan_to_num(data, posinf=0, neginf=0)
return data
def make_item(
self, update_from: MaskedXYImageItem | None = None
) -> MaskedXYImageItem:
"""Make plot item from data.
Args:
update_from: update from plot item
Returns:
Plot item
"""
data = self.__viewable_data()
item = make.maskedxyimage(
*get_obj_coords(self.obj),
data,
self.obj.maskdata,
title=self.obj.title,
colormap="viridis",
eliminate_outliers=get_conf().ima_eliminate_outliers.get(),
interpolation="nearest",
show_mask=True,
)
if update_from is None:
self.update_plot_item_parameters(item)
else:
update_dataset(item.param, update_from.param)
item.param.update_item(item)
return item
def update_item(self, item: MaskedXYImageItem, data_changed: bool = True) -> None:
"""Update plot item from data.
Args:
item: plot item
data_changed: if True, data has changed
"""
if data_changed:
# When data changes, let set_data() auto-calculate the LUT range from the
# new data (by not passing lut_range parameter). The subsequent call to
# update_plot_item_parameters() will override it if zscalemin/zscalemax
# are explicitly set in the object's metadata.
item.set_data(self.__viewable_data())
item.set_mask(self.obj.maskdata)
item.param.label = self.obj.title
self.update_plot_item_parameters(item)
item.plot().update_colormap_axis(item)
def add_label_with_title(self, title: str | None = None) -> None:
"""Add label with title annotation
Args:
title: title (if None, use image title)
"""
title = self.obj.title if title is None else title
if title:
label = make.label(title, (self.obj.x0, self.obj.y0), (10, 10), "TL")
self.add_annotations_from_items([label])
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/objects/signal.py 0000664 0000000 0000000 00000023100 15244251443 0026606 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
PlotPy Adapter Signal Module
----------------------------
"""
# pylint: disable=invalid-name # Allows short reference names like x, y, ...
from __future__ import annotations
from contextlib import contextmanager
from typing import Generator
import numpy as np
from guidata.dataset import restore_dataset, update_dataset
from plotpy.builder import make
from plotpy.items import CurveItem, ErrorBarCurveItem
from sigima.objects import SignalObj
from sigimax.adapters_plotpy.objects.base import (
BaseObjPlotPyAdapter,
)
from sigimax.config import get_conf
class CurveStyles:
"""Object to manage curve styles"""
#: Curve colors
COLORS = (
"#1f77b4", # muted blue
"#ff7f0e", # safety orange
"#2ca02c", # cooked asparagus green
"#d62728", # brick red
"#9467bd", # muted purple
"#8c564b", # chestnut brown
"#e377c2", # raspberry yogurt pink
"#7f7f7f", # gray
"#bcbd22", # curry yellow-green
"#17becf", # blue-teal
)
#: Curve line styles
LINESTYLES = ("SolidLine", "DashLine", "DashDotLine", "DashDotDotLine")
def __init__(self) -> None:
self.__suspend = False
self.curve_style = self.style_generator()
@staticmethod
def style_generator() -> Generator[tuple[str, str], None, None]:
"""Cycling through curve styles"""
while True:
for linestyle in CurveStyles.LINESTYLES:
for color in CurveStyles.COLORS:
yield (color, linestyle)
def apply_style(self, item: CurveItem) -> None:
"""Apply style to curve
Args:
item: curve item
"""
if self.__suspend:
# Suspend mode: always apply the first style
color, linestyle = CurveStyles.COLORS[0], CurveStyles.LINESTYLES[0]
else:
color, linestyle = next(self.curve_style)
item.param.line.color = color
item.param.line.style = linestyle
item.param.symbol.marker = "NoSymbol"
# Note: line width is set separately via apply_line_width()
# to ensure it's always recalculated based on current data size and settings
def reset_styles(self) -> None:
"""Reset styles"""
self.curve_style = self.style_generator()
@contextmanager
def alternative(
self, other_style_generator: Generator[tuple[str, str], None, None]
) -> Generator[None, None, None]:
"""Use an alternative style generator"""
old_style_generator = self.curve_style
self.curve_style = other_style_generator
yield
self.curve_style = old_style_generator
@contextmanager
def suspend(self) -> Generator[None, None, None]:
"""Suspend style generator"""
self.__suspend = True
yield
self.__suspend = False
CURVESTYLES = CurveStyles() # This is the unique instance of the CurveStyles class
def apply_line_width(item: CurveItem) -> None:
"""Apply line width to curve item with smart clamping for large datasets
Args:
item: curve item
"""
# Get data size
data_size = item.get_data()[0].size
# Get configured line width
line_width = get_conf().sig_linewidth.get()
# For large datasets, clamp linewidth to 1.0 for performance
# (thick lines cause ~10x rendering slowdown due to Qt raster engine)
threshold = get_conf().sig_linewidth_perfs_threshold.get()
if data_size > threshold and line_width > 1.0:
line_width = 1.0
# Apply the line width
item.param.line.width = line_width
def apply_downsampling(item: CurveItem, do_not_update: bool = False) -> None:
"""Apply downsampling to curve item
Args:
item: curve item
do_not_update: if True, do not update the item even if the downsampling
parameters have changed
"""
old_use_dsamp = item.param.use_dsamp
item.param.use_dsamp = False
if get_conf().sig_autodownsampling.get():
nbpoints = item.get_data()[0].size
maxpoints = get_conf().sig_autodownsampling_maxpoints.get()
if nbpoints > 5 * maxpoints:
item.param.use_dsamp = True
item.param.dsamp_factor = nbpoints // maxpoints
if not do_not_update and old_use_dsamp != item.param.use_dsamp:
item.update_data()
class SignalObjPlotPyAdapter(BaseObjPlotPyAdapter[SignalObj, CurveItem]):
"""Signal object plot item adapter class"""
DEFAULT_FMT = "g"
# conf_format is inherited from the base adapter (returns get_conf().sig_format)
def update_plot_item_parameters(self, item: CurveItem) -> None:
"""Update plot item parameters from object data/metadata
Takes into account a subset of plot item parameters. Those parameters may
have been overriden by object metadata entries or other object data. The goal
is to update the plot item accordingly.
This is *almost* the inverse operation of `update_metadata_from_plot_item`.
Args:
item: plot item
"""
update_dataset(item.param.line, self.obj.metadata)
update_dataset(item.param.symbol, self.obj.metadata)
super().update_plot_item_parameters(item)
def update_metadata_from_plot_item(self, item: CurveItem) -> None:
"""Update metadata from plot item.
Takes into account a subset of plot item parameters. Those parameters may
have been modified by the user through the plot item GUI. The goal is to
update the metadata accordingly.
This is *almost* the inverse operation of `update_plot_item_parameters`.
Args:
item: plot item
"""
super().update_metadata_from_plot_item(item)
restore_dataset(item.param.line, self.obj.metadata)
restore_dataset(item.param.symbol, self.obj.metadata)
def make_item(self, update_from: CurveItem | None = None) -> CurveItem:
"""Make plot item from data.
Args:
update_from: plot item to update from
Returns:
Plot item
"""
o = self.obj
if len(o.xydata) in (2, 4):
assert isinstance(o.xydata, np.ndarray)
if len(o.xydata) == 2: # x, y signal
x, y = o.xydata
item = make.mcurve(x.real, y.real, label=o.title)
else: # x, y, dx, dy error bar signal
x, y, dx, dy = o.xydata
if o.dx is None and o.dy is None: # x, y signal with no error
item = make.mcurve(x.real, y.real, label=o.title)
elif o.dx is None: # x, y, dy error bar signal with y error
item = make.merror(x.real, y.real, dy.real, label=o.title)
else: # x, y, dx, dy error bar signal with x error
dy = np.zeros_like(y) if dy is None else dy
item = make.merror(x.real, y.real, dx.real, dy.real, label=o.title)
# Apply style (without linewidth, will be set separately)
CURVESTYLES.apply_style(item)
apply_downsampling(item, do_not_update=True)
# Apply linewidth with smart clamping based on actual data size
apply_line_width(item)
else:
raise RuntimeError("data not supported")
if update_from is None:
self.update_plot_item_parameters(item)
else:
update_dataset(item.param, update_from.param)
item.update_params()
return item
def update_item(self, item: CurveItem, data_changed: bool = True) -> None:
"""Update plot item from data.
Args:
item: plot item
data_changed: if True, data has changed
"""
o = self.obj
if data_changed:
assert isinstance(o.xydata, np.ndarray)
if len(o.xydata) == 2: # x, y signal
x, y = o.xydata
assert isinstance(x, np.ndarray) and isinstance(y, np.ndarray)
item.set_data(x.real, y.real)
elif len(o.xydata) == 3: # x, y, dy error bar signal
x, y, dy = o.xydata
assert (
isinstance(x, np.ndarray)
and isinstance(y, np.ndarray)
and isinstance(dy, np.ndarray)
)
item.set_data(x.real, y.real, dy=dy.real)
elif len(o.xydata) == 4: # x, y, dx, dy error bar signal
x, y, dx, dy = o.xydata
assert (
isinstance(x, np.ndarray)
and isinstance(y, np.ndarray)
and isinstance(dx, np.ndarray)
and isinstance(dy, np.ndarray)
)
if isinstance(item, ErrorBarCurveItem):
item.set_data(x.real, y.real, dx.real, dy.real)
else:
# xydata has 4 rows but dx/dy are all NaN (no real
# error bars) — the plot item is a plain CurveItem
item.set_data(x.real, y.real)
item.param.label = o.title
apply_downsampling(item)
# Reapply linewidth with smart clamping (data size may have changed)
apply_line_width(item)
self.update_plot_item_parameters(item)
def add_label_with_title(self, title: str | None = None) -> None:
"""Add label with title annotation
Args:
title: title (if None, use signal title)
"""
title = self.obj.title if title is None else title
if title:
label = make.label(title, "TL", (0, 0), "TL")
self.add_annotations_from_items([label])
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/roi/ 0000775 0000000 0000000 00000000000 15244251443 0024123 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/roi/__init__.py 0000664 0000000 0000000 00000000000 15244251443 0026222 0 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/roi/base.py 0000664 0000000 0000000 00000007406 15244251443 0025416 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
PlotPy Adapter Base ROI Module
------------------------------
"""
import abc
from typing import TYPE_CHECKING, Generic, Iterator, Literal, TypeVar
from plotpy.items import AnnotatedShape
from sigima.objects.base import (
BaseROI,
TypeObj,
TypeROI,
TypeROIParam,
TypeSingleROI,
get_generic_roi_title,
)
from sigimax.adapters_plotpy.base import config_annotated_shape
if TYPE_CHECKING:
from plotpy.items import (
AnnotatedCircle,
AnnotatedPolygon,
AnnotatedRectangle,
AnnotatedXRange,
)
TypeROIItem = TypeVar(
"TypeROIItem",
bound="AnnotatedXRange | AnnotatedPolygon | AnnotatedRectangle | AnnotatedCircle",
)
class BaseSingleROIPlotPyAdapter(Generic[TypeSingleROI, TypeROIItem], abc.ABC):
"""Base class for single ROI plot item adapter
Args:
single_roi: single ROI object
"""
def __init__(self, single_roi: TypeSingleROI) -> None:
self.single_roi = single_roi
@abc.abstractmethod
def to_plot_item(self, obj: TypeObj) -> TypeROIItem:
"""Make ROI plot item from ROI.
Args:
obj: object (signal/image), for physical-indices coordinates conversion
Returns:
Plot item
"""
@classmethod
@abc.abstractmethod
def from_plot_item(cls, item: TypeROIItem) -> TypeSingleROI:
"""Create single ROI from plot item
Args:
item: plot item
Returns:
Single ROI
"""
def configure_roi_item(
item: TypeROIItem,
fmt: str,
lbl: bool,
editable: bool,
option: Literal["s", "i"],
):
"""Configure ROI plot item.
Args:
item: plot item
fmt: numeric format (e.g. "%.3f")
lbl: if True, show shape labels
editable: if True, make shape editable
option: shape style option ("s" for signal, "i" for image)
Returns:
Plot item
"""
option += "/" + ("editable" if editable else "readonly")
if not editable:
if isinstance(item, AnnotatedShape):
config_annotated_shape(
item, fmt, lbl, "roi", option, show_computations=editable
)
item.set_movable(False)
item.set_resizable(False)
item.set_readonly(True)
item.set_style("roi", option)
return item
class BaseROIPlotPyAdapter(Generic[TypeROI], abc.ABC):
"""ROI plot item adapter class
Args:
roi: ROI object
"""
def __init__(self, roi: BaseROI[TypeObj, TypeSingleROI, TypeROIParam]) -> None:
self.roi = roi
@abc.abstractmethod
def to_plot_item(self, single_roi: TypeSingleROI, obj: TypeObj) -> TypeROIItem:
"""Make ROI plot item from single ROI
Args:
single_roi: single ROI object
obj: object (signal/image), for physical-indices coordinates conversion
Returns:
Plot item
"""
def iterate_roi_items(
self, obj: TypeObj, fmt: str, lbl: bool, editable: bool = True
) -> Iterator[TypeROIItem]:
"""Iterate over ROI plot items associated to each single ROI composing
the object.
Args:
obj: object (signal/image), for physical-indices coordinates conversion
fmt: format string
lbl: if True, add label
editable: if True, ROI is editable
Yields:
Plot item
"""
for index, single_roi in enumerate(self.roi.single_rois):
roi_item = self.to_plot_item(single_roi, obj)
item = configure_roi_item(
roi_item, fmt, lbl, editable, option=self.roi.PREFIX
)
item.setTitle(single_roi.title or get_generic_roi_title(index))
yield item
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/roi/factory.py 0000664 0000000 0000000 00000002202 15244251443 0026140 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
ROI Adapter Factory
-------------------
Factory functions for creating ROI adapters without circular imports.
"""
from __future__ import annotations
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from sigima.objects.base import TypeObj
def create_roi_adapter(roi):
"""Create ROI adapter from ROI object
Args:
roi: ROI object
Returns:
ROI adapter instance
"""
# pylint: disable=import-outside-toplevel,cyclic-import
from sigimax.adapters_plotpy.factories import create_adapter_from_object
return create_adapter_from_object(roi)
def create_single_roi_plot_item(single_roi, obj: TypeObj):
"""Create plot item from single ROI
Args:
single_roi: single ROI object
obj: object (signal/image), for physical-indices coordinates conversion
Returns:
Plot item
"""
# pylint: disable=import-outside-toplevel,cyclic-import
from sigimax.adapters_plotpy.factories import create_adapter_from_object
return create_adapter_from_object(single_roi).to_plot_item(obj)
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/roi/image.py 0000664 0000000 0000000 00000017561 15244251443 0025571 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
PlotPy Adapter Image ROI Module
-------------------------------
"""
from __future__ import annotations
import numpy as np
from plotpy.builder import make
from plotpy.items import AnnotatedCircle, AnnotatedPolygon, AnnotatedRectangle
from sigima.objects import CircularROI, ImageObj, ImageROI, PolygonalROI, RectangularROI
from sigima.tools import coordinates
from sigimax.adapters_plotpy.coordutils import round_image_coords
from sigimax.adapters_plotpy.roi.base import (
BaseROIPlotPyAdapter,
BaseSingleROIPlotPyAdapter,
)
def _vs(var: str, sub: str = "") -> str:
"""Return variable name with subscript"""
txt = f"{var}"
if sub:
txt += f"{sub}"
return txt
class PolygonalROIPlotPyAdapter(
BaseSingleROIPlotPyAdapter[PolygonalROI, AnnotatedPolygon]
):
"""Polygonal ROI plot item adapter
Args:
single_roi: single ROI object
"""
def to_plot_item(self, obj: ImageObj) -> AnnotatedPolygon:
"""Make and return the annnotated polygon associated to ROI
Args:
obj: object (image), for physical-indices coordinates conversion
"""
def info_callback(item: AnnotatedPolygon) -> str:
"""Return info string for circular ROI"""
xc, yc = item.get_center()
if self.single_roi.indices:
xc, yc = obj.physical_to_indices([xc, yc])
return "
".join(
[
f"({_vs('x', 'c')}, {_vs('y', 'c')}) = ({xc:g}, {yc:g})",
]
)
coords = np.array(self.single_roi.get_physical_coords(obj))
points = coords.reshape(-1, 2)
item = AnnotatedPolygon(points)
item.set_info_callback(info_callback)
item.annotationparam.title = self.single_roi.title
item.annotationparam.update_item(item)
item.set_style("plot", "shape/drag")
return item
@classmethod
def from_plot_item(
cls, item: AnnotatedPolygon, obj: ImageObj | None = None
) -> PolygonalROI:
"""Create ROI from plot item
Args:
item: plot item
obj: image object for coordinate rounding (optional)
"""
coords = item.get_points().flatten().tolist()
# Round coordinates to appropriate precision
if obj is not None:
coords = round_image_coords(obj, coords)
title = str(item.title().text())
return PolygonalROI(coords, False, title)
class RectangularROIPlotPyAdapter(
BaseSingleROIPlotPyAdapter[RectangularROI, AnnotatedRectangle]
):
"""Rectangular ROI plot item adapter
Args:
single_roi: single ROI object
"""
def to_plot_item(self, obj: ImageObj) -> AnnotatedRectangle:
"""Make and return the annnotated rectangle associated to ROI
Args:
obj: object (image), for physical-indices coordinates conversion
"""
def info_callback(item: AnnotatedRectangle) -> str:
"""Return info string for rectangular ROI"""
x0, y0, x1, y1 = item.get_rect()
if self.single_roi.indices:
x0, y0, x1, y1 = obj.physical_to_indices([x0, y0, x1, y1])
x0, y0, dx, dy = self.single_roi.rect_to_coords(x0, y0, x1, y1)
return "
".join(
[
f"({_vs('x', '0')}, {_vs('y', '0')}) = ({x0:g}, {y0:g})",
f"{_vs('Δx')} × {_vs('Δy')} = {dx:g} × {dy:g}",
]
)
x0, y0, dx, dy = self.single_roi.get_physical_coords(obj)
x1, y1 = x0 + dx, y0 + dy
item: AnnotatedRectangle = make.annotated_rectangle(
x0, y0, x1, y1, title=self.single_roi.title
)
item.set_info_callback(info_callback)
param = item.label.labelparam
param.anchor = "BL"
param.xc, param.yc = 5, -5
param.update_item(item.label)
return item
@classmethod
def from_plot_item(
cls, item: AnnotatedRectangle, obj: ImageObj | None = None
) -> RectangularROI:
"""Create ROI from plot item
Args:
item: plot item
obj: image object for coordinate rounding (optional)
"""
rect = item.get_rect()
coords = RectangularROI.rect_to_coords(*rect)
# Round coordinates to appropriate precision
if obj is not None:
coords = round_image_coords(obj, coords)
title = str(item.title().text())
return RectangularROI(coords, False, title)
class CircularROIPlotPyAdapter(
BaseSingleROIPlotPyAdapter[CircularROI, AnnotatedCircle]
):
"""Circular ROI plot item adapter
Args:
single_roi: single ROI object
"""
def to_plot_item(self, obj: ImageObj) -> AnnotatedCircle:
"""Make and return the annnotated circle associated to ROI
Args:
obj: object (image), for physical-indices coordinates conversion
"""
def info_callback(item: AnnotatedCircle) -> str:
"""Return info string for circular ROI"""
x0, y0, x1, y1 = item.get_rect()
if self.single_roi.indices:
x0, y0, x1, y1 = obj.physical_to_indices([x0, y0, x1, y1])
xc, yc, r = self.single_roi.rect_to_coords(x0, y0, x1, y1)
return "
".join(
[
f"({_vs('x', 'c')}, {_vs('y', 'c')}) = ({xc:g}, {yc:g})",
f"{_vs('r')} = {r:g}",
]
)
xc, yc, r = self.single_roi.get_physical_coords(obj)
x0, y0, x1, y1 = coordinates.circle_to_diameter(xc, yc, r)
item = AnnotatedCircle(x0, y0, x1, y1)
item.set_info_callback(info_callback)
item.annotationparam.title = self.single_roi.title
item.annotationparam.update_item(item)
item.set_style("plot", "shape/drag")
return item
@classmethod
def from_plot_item(
cls, item: AnnotatedCircle, obj: ImageObj | None = None
) -> CircularROI:
"""Create ROI from plot item
Args:
item: plot item
obj: image object for coordinate rounding (optional)
"""
rect = item.get_rect()
coords = CircularROI.rect_to_coords(*rect)
# Round coordinates to appropriate precision
# For circular ROI: [xc, yc, r] - round center (xc, yc) as pair, then radius
if obj is not None:
xc, yc, r = coords
# Round center coordinates
xc_rounded, yc_rounded = round_image_coords(obj, [xc, yc])
# Round radius using average of X and Y precision
# For radius, we use the X precision (could also average X and Y)
r_rounded = round_image_coords(obj, [r, 0])[0]
coords = [xc_rounded, yc_rounded, r_rounded]
title = str(item.title().text())
return CircularROI(coords, False, title)
class ImageROIPlotPyAdapter(BaseROIPlotPyAdapter[ImageROI]):
"""Image ROI plot item adapter class
Args:
roi: ROI object
"""
def to_plot_item(
self,
single_roi: PolygonalROI | RectangularROI | CircularROI,
obj: ImageObj,
) -> AnnotatedCircle | AnnotatedRectangle | AnnotatedPolygon:
"""Make ROI plot item from single ROI
Args:
single_roi: single ROI object
obj: object (signal/image), for physical-indices coordinates conversion
Returns:
Plot item
"""
if isinstance(single_roi, PolygonalROI):
return PolygonalROIPlotPyAdapter(single_roi).to_plot_item(obj)
if isinstance(single_roi, RectangularROI):
return RectangularROIPlotPyAdapter(single_roi).to_plot_item(obj)
if isinstance(single_roi, CircularROI):
return CircularROIPlotPyAdapter(single_roi).to_plot_item(obj)
raise TypeError(f"Invalid ROI type {type(single_roi)}")
DataLab-Platform-SigimaX-0182bf4/sigimax/adapters_plotpy/roi/signal.py 0000664 0000000 0000000 00000031736 15244251443 0025764 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
PlotPy Adapter Signal ROI Module
--------------------------------
"""
from __future__ import annotations
import re
from typing import TYPE_CHECKING, Iterator
import numpy as np
from plotpy.items import AnnotatedXRange
from plotpy.items.shape.range import XRangeSelection
from qtpy import QtCore as QC
from qtpy import QtGui as QG
from sigima.objects import SegmentROI, SignalObj, SignalROI
from sigima.objects.base import GENERIC_ROI_TITLE_REGEXP, get_generic_roi_title
from sigimax.adapters_plotpy.coordutils import round_signal_coords
from sigimax.adapters_plotpy.roi.base import (
BaseROIPlotPyAdapter,
BaseSingleROIPlotPyAdapter,
configure_roi_item,
)
if TYPE_CHECKING:
import qwt.scale_map
from qtpy.QtCore import QRectF
from qtpy.QtGui import QPainter
# Color palette used to cycle through ROI fill colors when several ROIs are
# defined on the same signal. Inspired by the matplotlib ``tab10`` palette so
# that consecutive ROIs are easily distinguishable.
_ROI_FILL_COLORS: tuple[str, ...] = (
"#1f77b4", # blue
"#ff7f0e", # orange
"#2ca02c", # green
"#d62728", # red
"#9467bd", # purple
"#8c564b", # brown
"#e377c2", # pink
"#7f7f7f", # grey
"#bcbd22", # yellow-green
"#17becf", # cyan
)
# Alpha (0..255) used for the translucent fill of ROI rectangles
_ROI_FILL_ALPHA: int = 90
def roi_color_for_index(index: int) -> QG.QColor:
"""Return the ROI fill color for the given ROI index (cycles through the
predefined palette)."""
name = _ROI_FILL_COLORS[index % len(_ROI_FILL_COLORS)]
color = QG.QColor(name)
color.setAlpha(_ROI_FILL_ALPHA)
return color
class _CurveClippedXRangeSelection(XRangeSelection):
"""X-range selection whose translucent fill is clipped vertically to the
underlying signal curve (instead of filling the whole canvas height).
The fill color can additionally be overridden on a per-instance basis to
enable color cycling between sibling ROIs displayed on the same signal.
"""
def __init__(
self,
_min: float | None = None,
_max: float | None = None,
shapeparam=None,
) -> None:
super().__init__(_min, _max, shapeparam)
self._curve_x: np.ndarray | None = None
self._curve_y: np.ndarray | None = None
self._fill_color: QG.QColor | None = None
def set_signal_curve(self, x: np.ndarray, y: np.ndarray) -> None:
"""Attach the signal curve coordinates used to clip the fill area."""
self._curve_x = np.asarray(x, dtype=float)
self._curve_y = np.asarray(y, dtype=float)
def set_fill_color(self, color: QG.QColor) -> None:
"""Override the fill color for this ROI instance."""
self._fill_color = QG.QColor(color)
def _build_curve_polygon( # pylint: disable=too-many-return-statements
self,
xMap: qwt.scale_map.QwtScaleMap, # pylint: disable=invalid-name
yMap: qwt.scale_map.QwtScaleMap, # pylint: disable=invalid-name
rct: QRectF,
) -> QG.QPolygonF | None:
"""Build a polygon that follows the signal curve between ``self._min``
and ``self._max``, with a flat baseline at y=0 (clamped to the visible
canvas area when y=0 lies outside the current axis range, or fall back
to the canvas bottom when the y-axis uses a logarithmic scale).
"""
if self._curve_x is None or self._curve_y is None:
return None
x_arr = self._curve_x
y_arr = self._curve_y
if x_arr.size < 2:
return None
# Filter non-finite samples (NaN/Inf) which would produce invalid
# polygon vertices via ``np.interp``.
finite = np.isfinite(x_arr) & np.isfinite(y_arr)
if not finite.all():
x_arr = x_arr[finite]
y_arr = y_arr[finite]
if x_arr.size < 2:
return None
xmin, xmax = self._min, self._max
if xmin is None or xmax is None:
return None
if xmin > xmax:
xmin, xmax = xmax, xmin
# Make sure x_arr is sorted (required by np.interp at the boundaries)
if not np.all(np.diff(x_arr) >= 0):
order = np.argsort(x_arr)
x_arr = x_arr[order]
y_arr = y_arr[order]
# Restrict to the actual data extent to avoid drawing the polygon
# outside the signal definition domain.
x0 = max(xmin, float(x_arr[0]))
x1 = min(xmax, float(x_arr[-1]))
if x1 <= x0:
return None
mask = (x_arr >= x0) & (x_arr <= x1)
xs_in = x_arr[mask]
ys_in = y_arr[mask]
y_left = float(np.interp(x0, x_arr, y_arr))
y_right = float(np.interp(x1, x_arr, y_arr))
xs = np.concatenate(([x0], xs_in, [x1]))
ys = np.concatenate(([y_left], ys_in, [y_right]))
# Remove duplicate boundary samples if interpolation hit an existing
# data point exactly.
keep = np.concatenate(([True], np.diff(xs) > 0))
xs = xs[keep]
ys = ys[keep]
if xs.size < 2:
return None
# Baseline: y=0 in axis coordinates for linear scales, clamped to the
# visible canvas area. On a log scale, y=0 has no meaning, so fall
# back to the canvas bottom.
baseline_y = self._compute_baseline_y(yMap, rct)
if baseline_y is None:
return None
polygon = QG.QPolygonF()
polygon.append(QC.QPointF(xMap.transform(xs[0]), baseline_y))
for xv, yv in zip(xs, ys):
polygon.append(QC.QPointF(xMap.transform(xv), yMap.transform(yv)))
polygon.append(QC.QPointF(xMap.transform(xs[-1]), baseline_y))
return polygon
def _compute_baseline_y(
self,
yMap: qwt.scale_map.QwtScaleMap, # pylint: disable=invalid-name
rct: QRectF,
) -> float | None:
"""Return the canvas y-coordinate of the polygon baseline.
Uses y=0 when the y-axis is linear, falls back to the canvas bottom
when the axis is logarithmic (where y=0 is undefined).
"""
plot = self.plot()
is_log_y = plot is not None and plot.get_axis_scale(self.yAxis()) == "log"
if is_log_y:
return rct.bottom()
baseline_y = yMap.transform(0.0)
if not np.isfinite(baseline_y):
return rct.bottom()
return max(rct.top(), min(rct.bottom(), baseline_y))
def draw(
self,
painter: QPainter,
xMap: qwt.scale_map.QwtScaleMap,
yMap: qwt.scale_map.QwtScaleMap,
canvasRect: QRectF,
) -> None:
"""Draw the ROI: filled polygon clipped to the curve (or a fallback
rectangle if no curve information is available), surrounded by the
usual handle decoration (vertical edges and central dashed line)."""
plot = self.plot()
if not plot:
return
if self.selected:
pen = self.sel_pen
sym = self.sel_symbol
else:
pen = self.pen
sym = self.symbol
# Build the fallback rectangle covering the canvas height
rct = QC.QRectF(plot.canvas().contentsRect())
rct.setLeft(xMap.transform(self._min))
rct.setRight(xMap.transform(self._max))
# Choose the brush: per-instance color override has priority. The pen
# is preserved (so selection style — width/dash — keeps its visual
# role) and only its color is replaced to match the fill color.
if self._fill_color is not None:
brush = QG.QBrush(self._fill_color)
edge_color = QG.QColor(self._fill_color)
edge_color.setAlpha(255)
pen = QG.QPen(pen)
pen.setColor(edge_color)
else:
brush = self.brush
polygon = self._build_curve_polygon(xMap, yMap, rct)
painter.save()
painter.setPen(QC.Qt.NoPen)
painter.setBrush(brush)
if polygon is not None:
painter.drawPolygon(polygon)
else:
painter.fillRect(rct, brush)
painter.restore()
# Vertical edges at xmin and xmax (full canvas height)
painter.setPen(pen)
painter.drawLine(rct.topLeft(), rct.bottomLeft())
painter.drawLine(rct.topRight(), rct.bottomRight())
# Dashed central line
dash = QG.QPen(pen)
dash.setStyle(QC.Qt.DashLine)
dash.setWidth(1)
painter.setPen(dash)
cx = rct.center().x()
painter.drawLine(QC.QPointF(cx, rct.top()), QC.QPointF(cx, rct.bottom()))
if self.can_resize() and not self.is_readonly():
painter.setPen(pen)
x0, x1, y = self.get_handles_pos()
sym.drawSymbol(painter, QC.QPointF(x0, y))
sym.drawSymbol(painter, QC.QPointF(x1, y))
class _CurveClippedAnnotatedXRange(AnnotatedXRange): # pylint: disable=abstract-method
"""Annotated X-range selection whose underlying shape is a
:class:`_CurveClippedXRangeSelection` (curve-clipped fill + per-instance
color).
``get_tr_size`` is intentionally not overridden: ``AnnotatedXRange`` (from
PlotPy) does not override it either, so the abstract-method warning is a
false positive inherited from upstream."""
SHAPE_CLASS = _CurveClippedXRangeSelection
class SegmentROIPlotPyAdapter(BaseSingleROIPlotPyAdapter[SegmentROI, AnnotatedXRange]):
"""Segment ROI plot item adapter
Args:
coords: ROI coordinates (xmin, xmax)
title: ROI title
"""
def to_plot_item(
self,
obj: SignalObj,
fill_color: QG.QColor | None = None,
) -> AnnotatedXRange:
"""Make and return the annotated segment associated with the ROI
Args:
obj: object (signal), for physical-indices coordinates conversion
fill_color: optional fill color override (used for color cycling
between sibling ROIs)
"""
xmin, xmax = self.single_roi.get_physical_coords(obj)
item = _CurveClippedAnnotatedXRange(xmin, xmax)
item.setTitle(self.single_roi.title)
# Apply default range style so pen/brush/symbol attributes are set
item.shape.set_style("plot", "range")
# Provide curve coordinates for clipped rendering
x, y = obj.xydata
if x is not None and y is not None:
item.shape.set_signal_curve(x, y)
if fill_color is not None:
item.shape.set_fill_color(fill_color)
return item
@classmethod
def from_plot_item(
cls, item: AnnotatedXRange, obj: SignalObj | None = None
) -> SegmentROI:
"""Create ROI from plot item
Args:
item: plot item
obj: signal object for coordinate rounding (optional)
Returns:
ROI
"""
if not isinstance(item, AnnotatedXRange):
raise TypeError("Invalid plot item type")
coords = sorted(item.get_range())
# Round coordinates to appropriate precision
if obj is not None:
coords = round_signal_coords(obj, coords)
title = str(item.title().text())
return SegmentROI(coords, False, title)
class SignalROIPlotPyAdapter(BaseROIPlotPyAdapter[SignalROI]):
"""Signal ROI plot item adapter class
Args:
roi: ROI object
"""
def to_plot_item(
self,
single_roi: SegmentROI,
obj: SignalObj,
fill_color: QG.QColor | None = None,
) -> AnnotatedXRange:
"""Make ROI plot item from single ROI
Args:
single_roi: single ROI object
obj: object (signal/image), for physical-indices coordinates conversion
fill_color: optional fill color override (used for color cycling)
Returns:
Plot item
"""
return SegmentROIPlotPyAdapter(single_roi).to_plot_item(
obj, fill_color=fill_color
)
def iterate_roi_items(
self,
obj: SignalObj,
fmt: str,
lbl: bool,
editable: bool = True,
) -> Iterator[AnnotatedXRange]:
"""Iterate over ROI plot items, applying alternating fill colors so
that several ROIs displayed on the same signal can be visually
distinguished. The color cycling index is derived from the trailing
digits of the ROI title (``ROI``) when available, falling back to
the position of the ROI in the list otherwise; this keeps the
per-ROI color stable across deletions/reorderings.
"""
for index, single_roi in enumerate(self.roi.single_rois):
title = single_roi.title or get_generic_roi_title(index)
match = re.match(GENERIC_ROI_TITLE_REGEXP, title)
color_index = int(match.group(1)) if match is not None else index
color = roi_color_for_index(color_index)
roi_item = self.to_plot_item(single_roi, obj, fill_color=color)
item = configure_roi_item(
roi_item, fmt, lbl, editable, option=self.roi.PREFIX
)
item.setTitle(title)
yield item
DataLab-Platform-SigimaX-0182bf4/sigimax/app.py 0000664 0000000 0000000 00000011145 15244251443 0021254 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
Application launcher
====================
The :mod:`sigimax.app` module provides helper functions to create and run
SigimaX-derived applications with optional splash screen support.
Derived applications typically call :func:`create` (or :func:`run`) with
their own :class:`~sigimax.mainwindow.SGMXMainWindow` subclass and an
optional :class:`~sigimax.widgets.splashscreen.SplashScreenConfig`.
Basic usage::
from sigimax.app import run
from sigimax.widgets.splashscreen import SplashScreenConfig
from myapp.main import MyAppMainWindow
run(
window_class=MyAppMainWindow,
splash_config=SplashScreenConfig(
image_path="myapp/data/splash.png",
app_name="MyApp",
app_version="1.0.0",
),
)
.. autofunction:: create
.. autofunction:: run
"""
from __future__ import annotations
from typing import TypeVar
from qtpy import QtWidgets as QW
from sigimax.config import get_conf
from sigimax.env import execenv
from sigimax.mainwindow import SGMXMainWindow
from sigimax.utils.qthelpers import sigimax_app_context
from sigimax.widgets.splashscreen import SigimaXSplashScreen, SplashScreenConfig
_WindowT = TypeVar("_WindowT", bound=SGMXMainWindow)
def create(
window_class: type[_WindowT] = SGMXMainWindow,
splash: bool = True,
splash_config: SplashScreenConfig | None = None,
console: bool | None = None,
h5files: list[str] | None = None,
size: tuple[int, int] | None = None,
) -> _WindowT:
"""Create and show a SigimaX application window.
This is the recommended entry point for derived applications. It handles
the splash screen lifecycle around the (potentially heavy) window
initialization.
Args:
window_class: The main window class to instantiate. Defaults to
:class:`~sigimax.mainwindow.SGMXMainWindow`.
splash: If ``True``, show a splash screen during initialization.
splash_config: Explicit splash screen configuration. If ``None`` and
*splash* is ``True``, the configuration is built from
:data:`sigimax.config.CONF`.
console: If ``True``, enable the embedded console. ``None`` reads
from :data:`sigimax.config.CONF`.
h5files: Optional list of HDF5 file paths to open after startup.
size: Optional ``(width, height)`` tuple for the window size.
Returns:
The initialized and visible main window instance.
"""
splashscreen: SigimaXSplashScreen | None = None
if splash:
config = splash_config or SplashScreenConfig.from_conf()
if config.is_enabled:
splashscreen = SigimaXSplashScreen(config)
splashscreen.show()
splashscreen.show_message("Initializing...")
QW.QApplication.processEvents()
# --- Heavy initialization ---
window = window_class(console=console)
if splashscreen is not None:
splashscreen.show_message("Loading workspace...")
QW.QApplication.processEvents()
if size is not None:
width, height = size
window.resize(width, height)
if splashscreen is not None:
splashscreen.finish(window)
if get_conf().window_maximized.get():
window.showMaximized()
else:
window.showNormal()
if h5files is not None:
window.open_h5_files(h5files, import_all=True)
return window
def run(
window_class: type[_WindowT] = SGMXMainWindow,
splash: bool = True,
splash_config: SplashScreenConfig | None = None,
console: bool | None = None,
h5files: list[str] | None = None,
size: tuple[int, int] | None = None,
) -> None:
"""Create and run a SigimaX application with an event loop.
Convenience wrapper around :func:`create` that manages the
:func:`~sigimax.utils.qthelpers.sigimax_app_context` lifecycle.
Args:
window_class: The main window class to instantiate.
splash: If ``True``, show a splash screen during initialization.
splash_config: Explicit splash screen configuration.
console: If ``True``, enable the embedded console.
h5files: Optional list of HDF5 file paths to open.
size: Optional ``(width, height)`` tuple for the window size.
"""
execenv.parse_args()
with sigimax_app_context(exec_loop=True):
window = create(
window_class=window_class,
splash=splash,
splash_config=splash_config,
console=console,
h5files=h5files,
size=size,
)
QW.QApplication.processEvents()
window.execute_post_show_actions()
DataLab-Platform-SigimaX-0182bf4/sigimax/config.py 0000664 0000000 0000000 00000253363 15244251443 0021753 0 ustar 00root root 0000000 0000000 # Copyright (c) DataLab Platform Developers, BSD 3-Clause license, see LICENSE file.
"""
SigimaX Configuration Options System (:mod:`sigimax.config`)
------------------------------------------------------------
Sigima-style in-memory option system for SigimaX-based GUI applications.
This module provides a clean, extensible configuration system following the same
pattern as :mod:`sigima.config` (``OptionField`` with ``get``/``set``/``context``),
but tailored for GUI applications built on SigimaX.
Design principles:
- **Simple API**: Options are accessed via ``CONF.color_mode.get()`` and
``CONF.color_mode.set("dark")``.
- **Optional initialization defaults**: ``CONF.color_mode.get("auto")`` sets
and returns ``"auto"`` only when the option has not been explicitly
initialized or loaded.
- **Context managers**: Temporarily override options with
``with CONF.fft_shift_enabled.context(False): ...``.
- **Extensible via subclassing**: Derived applications (like DataLab) subclass
:class:`SigimaXOptions` to add their own options.
- **Optional JSON file persistence**: For GUI apps that need to persist user
preferences across sessions.
Typical usage:
.. code-block:: python
from sigimax.config import CONF as Conf
# Get an option value
colormap = Conf.ima_def_colormap.get()
# Set an option value
Conf.ima_def_colormap.set("gray")
# Temporarily override an option
with Conf.fft_shift_enabled.context(False):
# FFT shift is disabled in this block
...
# Save/load from JSON file (for GUI persistence)
Conf.save() # saves to default config path
Conf.load() # loads from default config path
Extending for a derived application:
.. code-block:: python
from sigimax.options import SigimaXOptions
class MyAppOptions(SigimaXOptions):
def __init__(self):
super().__init__()
self.my_custom_option = TypedOptionField(
self, "my_custom_option", default=42,
expected_type=int,
description="My custom option for MyApp",
)
options = MyAppOptions()
.. autoclass:: SigimaXOptions
:members:
.. autoclass:: AppOptionsContainer
:members:
.. autoclass:: OptionField
:members:
.. autoclass:: TypedOptionField
:members:
.. autoclass:: ImageIOOptionField
:members:
.. autoclass:: EnumOptionField
:members:
.. autoclass:: TupleOptionField
:members:
.. autoclass:: FontOptionField
:members:
.. autoclass:: ConfigPathOptionField
:members:
.. autoclass:: WorkingDirOptionField
:members:
.. autoclass:: FormatStringOptionField
:members:
.. autoclass:: DataSetOptionField
:members:
.. autofunction:: get_conf
.. autofunction:: set_conf
.. autofunction:: reset_conf
"""
from __future__ import annotations
import json
import os
import os.path as osp
import sys
from collections.abc import Generator
from contextlib import contextmanager
from pathlib import Path
from typing import TYPE_CHECKING, Any
import guidata.dataset as gds
from guidata import configtools
from plotpy import config as plotpy_config
from plotpy.config import CONF as PLOTPY_CONF
from sigima.config import OptionsContainer
from sigima.config import options as sigima_options
from sigima.proc.title_formatting import (
PlaceholderTitleFormatter,
set_default_title_formatter,
)
from sigimax.utils import conf as _conf_module # For config dir resolution
if TYPE_CHECKING:
from qtpy import QtGui as QG
# Module-level constants
MOD_TITLE = "SigimaX"
MOD_NAME = "sigimax"
# Configure Sigima to use placeholder title formatting
set_default_title_formatter(PlaceholderTitleFormatter())
# Configure guidata translation and icons paths for SigimaX
_ = configtools.get_translation(MOD_NAME)
configtools.add_image_module_path(MOD_NAME, osp.join("data", "icons"))
DATAPATH = configtools.get_module_data_path(MOD_NAME, "data")
# Other Module-level constants
MOD_DESC = _("""SigimaX is a GUI library working with Sigima and PlotPyStack.
It provides a App configuration system, a generic MainWindow class and a
set of widgets to build applications on top of Sigima and PlotPyStack.""")
DEBUG = os.environ.get("DEBUG", "").lower() in ("1", "true")
if DEBUG:
print("*** DEBUG mode *** [Reset configuration file, do not redirect std I/O]")
TEST_SEGFAULT_ERROR = len(os.environ.get("TEST_SEGFAULT_ERROR", "")) > 0
if TEST_SEGFAULT_ERROR:
print('*** TEST_SEGFAULT_ERROR mode *** [Enabling test action in "?" menu]')
# DATETIME_FORMAT = "%d/%m/%Y - %H:%M:%S"
def get_old_log_fname(fname):
"""Return old log fname from current log fname"""
return osp.splitext(fname)[0] + ".1.log"
def is_frozen(module_name: str) -> bool:
"""Test if module has been frozen (py2exe/cx_Freeze/pyinstaller)
Args:
module_name (str): module name
Returns:
bool: True if module has been frozen (py2exe/cx_Freeze/pyinstaller)
"""
datapath = configtools.get_module_path(module_name)
parentdir = osp.normpath(osp.join(datapath, osp.pardir))
return not osp.isfile(__file__) or osp.isfile(parentdir) # library.zip
IS_FROZEN = is_frozen(MOD_NAME)
def get_mod_source_dir() -> str | None:
"""Return module source directory
Returns:
str | None: module source directory, or None if not found
"""
if IS_FROZEN:
devdir = osp.abspath(osp.join(sys.prefix, os.pardir, os.pardir))
else:
devdir = osp.abspath(osp.join(osp.dirname(__file__), os.pardir))
if osp.isfile(osp.join(devdir, MOD_NAME, "__init__.py")):
return devdir
# Unhandled case (this should not happen, but just in case):
return None
# ---------------------------------------------------------------------------
# Custom OptionField subclasses for GUI application options
# ---------------------------------------------------------------------------
NO_DEFAULT = object()
class OptionField:
"""SigimaX option field supporting optional default initialization."""
#: Suffixes of the storage keys occupied by the field, for backends storing
#: one scalar per key (e.g. INI). Empty means a single key.
storage_suffixes: tuple[str, ...] = ()
#: Whether the serialized value must be escaped by format-string-sensitive
#: backends (e.g. ``%`` doubling for ConfigParser).
storage_escape: bool = False
def __init__(
self,
container: OptionsContainer,
name: str,
default: Any,
description: str = "",
category: str = "",
storage_key: str = "",
runtime: bool = False,
) -> None:
self._container = container
self.name = name
self.check(default)
self._value = default
self.description = description
self.category = category
#: Storage key overriding the one derived from the option name.
self.storage_key = storage_key
#: Value shared between processes through the storage backend: its owner
#: persists it individually, bulk saves must leave it untouched.
self.runtime = runtime
self._is_initialized = False
def check(self, value: Any) -> None: # pylint: disable=unused-argument
"""Validate the configured value in specialized fields."""
def get(self, default: Any = NO_DEFAULT) -> Any:
"""Return the value, initializing a missing option from ``default``.
Args:
default: Optional value used when the option is not initialized.
``None`` is returned without initializing the option.
Returns:
The exact supplied default after initialization, or the current value.
"""
is_initialized = getattr(
self._container, "is_option_initialized", lambda _name: self._is_initialized
)
if (
default is not NO_DEFAULT
and default is not None
and not is_initialized(self.name)
):
self.set(default)
return default
return self._value
def set(self, value: Any) -> None:
"""Set the value and mark the option as initialized."""
self.check(value)
self._value = value
self.mark_initialized()
self._container.option_changed(self.name)
def mark_initialized(self) -> None:
"""Mark a value assigned outside the standard setter as initialized."""
self._is_initialized = True
mark_initialized = getattr(self._container, "mark_option_initialized", None)
if mark_initialized is not None:
mark_initialized(self.name)
def to_storage(self) -> Any:
"""Return the value in a serialization-friendly form.
Fields whose :meth:`get` transforms the stored value must override this
(and :meth:`from_storage`) to avoid a lossy ``get``/``set`` round-trip.
Returns:
A JSON-compatible representation of the value. When
:attr:`storage_suffixes` is not empty, a sequence aligned with it.
"""
return self.get()
def from_storage(self, value: Any) -> None:
"""Restore the value from its serialized form.
Args:
value: The serialized value, as produced by :meth:`to_storage`.
"""
self.set(value)
def context(self, temp_value: Any) -> Generator[None, None, None]:
"""Temporarily override the value without changing initialization state."""
@contextmanager
def _ctx():
old_value = self._value
old_field_initialized = self._is_initialized
old_container_initialized = self._container.is_option_initialized(self.name)
snapshot_context = getattr(
self._container, "snapshot_option_context_state", None
)
context_state = (
snapshot_context(self.name) if snapshot_context is not None else None
)
self.set(temp_value)
try:
yield
finally:
self._value = old_value
self._is_initialized = old_field_initialized
if old_container_initialized:
self._container.mark_option_initialized(self.name)
else:
self._container.unmark_option_initialized(self.name)
self._container.option_changed(self.name)
restore_context = getattr(
self._container, "restore_option_context_state", None
)
if restore_context is not None:
restore_context(self.name, context_state)
return _ctx()
class TypedOptionField(OptionField):
"""Typed SigimaX option field with optional-default initialization."""
def __init__(
self,
container: OptionsContainer,
name: str,
default: Any,
expected_type: type,
description: str = "",
category: str = "",
storage_key: str = "",
runtime: bool = False,
) -> None:
self.expected_type = expected_type
OptionField.__init__(
self, container, name, default, description, category, storage_key, runtime
)
def check(self, value: Any) -> None:
"""Validate the configured value type."""
if not isinstance(value, self.expected_type):
raise ValueError(
f"Expected {self.expected_type.__name__}, got {type(value).__name__}"
)
class ImageIOOptionField(OptionField):
"""Image I/O option field with optional-default initialization."""
def check(self, value: Any) -> None:
"""Validate image I/O format and description pairs."""
if not isinstance(value, (tuple, list)) or not all(
isinstance(item, (tuple, list)) and len(item) == 2 for item in value
):
raise ValueError(
"Expected a tuple of tuples with two elements each "
"(format, description)"
)
for item in value:
if not isinstance(item[0], str) or not isinstance(item[1], str):
raise ValueError(
"Each item must be a tuple of (format, description) as strings"
)
def set(self, value: Any) -> None:
"""Set formats, mark initialization, and generate format classes."""
OptionField.set(self, value)
# pylint: disable=cyclic-import,import-outside-toplevel
from sigima.io.image import formats
formats.generate_imageio_format_classes(value)
class EnumOptionField(OptionField):
"""Option field constrained to a fixed set of valid string values.
Args:
container: Options container instance to which this option belongs.
name: Name of the option.
default: Default value (must be one of ``choices``).
choices: List of valid string values.
description: Description of the option.
"""
def __init__(
self,
container: AppOptionsContainer,
name: str,
default: str,
choices: list[str],
description: str = "",
category: str = "",
storage_key: str = "",
runtime: bool = False,
) -> None:
self.choices = choices
super().__init__(
container, name, default, description, category, storage_key, runtime
)
def check(self, value: Any) -> None:
"""Check if value is one of the allowed choices.
Args:
value: The value to check.
Raises:
ValueError: If the value is not one of the allowed choices.
"""
if value not in self.choices:
raise ValueError(
f"Option '{self.name}': expected one of {self.choices}, got {value!r}"
)
class TupleOptionField(OptionField):
"""Option field for tuple values (e.g., window position, size).
Handles JSON serialization where tuples become lists, automatically
converting back to tuples on load.
Args:
container: Options container instance to which this option belongs.
name: Name of the option.
default: Default value (tuple or None).
description: Description of the option.
"""
def check(self, value: Any) -> None:
"""Check if value is a tuple, list (from JSON), or None.
Args:
value: The value to check.
Raises:
ValueError: If the value is not a valid type.
"""
if value is not None and not isinstance(value, (tuple, list)):
raise ValueError(
f"Option '{self.name}': expected tuple, list, or None, "
f"got {type(value).__name__}"
)
def set(self, value: Any) -> None:
"""Set the value, converting lists to tuples.
Args:
value: The new value to assign.
"""
if isinstance(value, list):
value = tuple(value)
super().set(value)
class FontOptionField(OptionField):
"""Option field for font specifications.
Stores fonts as a tuple of (family: str | list[str], size: int, bold: bool).
A list of families is a list of *candidate* names, resolved to the first one
available on the system by :meth:`get_font`.
Args:
container: Options container instance to which this option belongs.
name: Name of the option.
default: Default value as (family, size, bold) tuple.
description: Description of the option.
"""
storage_suffixes = ("family", "size", "bold")
def check(self, value: Any) -> None:
"""Check if value is a valid font tuple.
Args:
value: The value to check.
Raises:
ValueError: If the value is not a valid font specification.
"""
if value is not None and (
not isinstance(value, (tuple, list))
or len(value) != 3
or not isinstance(value[0], (str, list, tuple))
):
raise ValueError(
f"Option '{self.name}': expected (family, size, bold) tuple, "
f"got {value!r}"
)
def set(self, value: Any) -> None:
"""Set the value, converting lists to tuples.
Args:
value: The new value to assign.
"""
if isinstance(value, list):
value = tuple(value)
super().set(value)
def get_font(self) -> QG.QFont:
"""Return the font as a ``QFont`` instance.
Returns:
The configured font as a ``QFont``.
"""
# Import here to avoid requiring a Qt application when only manipulating
# configuration files.
from qtpy import QtGui as QG # pylint: disable=import-outside-toplevel
family, size, bold = self.get()
if isinstance(family, (list, tuple)):
family = configtools.get_family(family)
return QG.QFont(family, size, QG.QFont.Bold if bold else QG.QFont.Normal)
class ConfigPathOptionField(OptionField):
"""Option field for a file stored in the configuration directory.
The raw stored value is a bare file *basename*. :meth:`get` validates the
basename and returns the absolute path inside the configuration directory.
Args:
container: Options container instance to which this option belongs.
name: Name of the option.
default: Default file basename (e.g. ``".MyApp_traceback.log"``).
description: Description of the option.
"""
def check(self, value: Any) -> None:
"""Check that the value is a string.
Args:
value: The value to check.
Raises:
ValueError: If the value is not a string.
"""
if not isinstance(value, str):
raise ValueError(f"Expected str, got {type(value).__name__}")
def get(self, default: Any = NO_DEFAULT) -> str:
"""Return the absolute path inside the configuration directory.
Args:
default: Optional basename used when the option is not initialized.
Returns:
The absolute path of the file inside the configuration directory.
Raises:
ValueError: If the stored value is not a bare basename.
"""
fname = super().get(default)
if osp.basename(fname) != fname:
raise ValueError(f"Invalid configuration file name {fname}")
return _conf_module.Configuration.get_path(osp.basename(fname))
def to_storage(self) -> str:
"""Return the raw stored basename (bypassing path resolution)."""
return self._value
def from_storage(self, value: str) -> None:
"""Set the raw stored basename without validation or env sync.
Args:
value: The raw basename to store.
"""
self._value = value
self.mark_initialized()
class WorkingDirOptionField(OptionField):
"""Option field for a working directory.
:meth:`set` validates the directory (falling back to its parent when a file
path is given) and raises when invalid. :meth:`get` returns an empty string
when the stored directory no longer exists.
Args:
container: Options container instance to which this option belongs.
name: Name of the option.
default: Default directory path (empty string by default).
description: Description of the option.
"""
def check(self, value: Any) -> None:
"""Check that the value is a string.
Args:
value: The value to check.
Raises:
ValueError: If the value is not a string.
"""
if not isinstance(value, str):
raise ValueError(f"Expected str, got {type(value).__name__}")
def get(self, default: Any = NO_DEFAULT) -> str:
"""Return the working directory, or an empty string if it is missing.
Args:
default: Optional path used when the option is not initialized.
Returns:
The stored directory if it exists, otherwise an empty string.
"""
path = super().get(default)
if osp.isdir(path):
return path
return ""
def set(self, value: str) -> None:
"""Set the working directory, validating that it exists.
Args:
value: The directory (or a file whose parent is used) to store.
Raises:
FileNotFoundError: If neither the value nor its parent is a directory.
"""
if not osp.isdir(value):
value = osp.dirname(value)
if not osp.isdir(value):
raise FileNotFoundError(f"Invalid working directory name {value}")
super().set(value)
def to_storage(self) -> str:
"""Return the raw stored directory (even if it no longer exists)."""
return self._value
def from_storage(self, value: str) -> None:
"""Set the raw stored directory without validation or env sync.
Args:
value: The raw directory path to store.
"""
self._value = value
self.mark_initialized()
class FormatStringOptionField(TypedOptionField):
"""Option field for a ``strftime``-style format string.
The value is kept in clean form in memory (e.g. ``%H:%M:%S``);
format-string-sensitive backends escape it through :attr:`storage_escape`.
Args:
container: Options container instance to which this option belongs.
name: Name of the option.
default: Default format string.
description: Description of the option.
category: Category of the option.
"""
storage_escape = True
def __init__(
self,
container: AppOptionsContainer,
name: str,
default: str,
description: str = "",
category: str = "",
storage_key: str = "",
runtime: bool = False,
) -> None:
super().__init__(
container, name, default, str, description, category, storage_key, runtime
)
class DataSetOptionField(OptionField):
"""Option field holding a :class:`guidata.dataset.DataSet` instance.
The default value is provided through a *default instance*, which may be set
lazily via :meth:`set_default_instance` (useful when the default depends on
PlotPy configuration that is not yet available at construction time).
JSON (de)serialization helpers (:meth:`to_json`, :meth:`from_json`) are used
by the storage backend. Percent-escaping required by ConfigParser is handled
by the backend through :attr:`storage_escape`, not here.
Args:
container: Options container instance to which this option belongs.
name: Name of the option.
default_instance: Default :class:`~guidata.dataset.DataSet` instance
(may be ``None`` and set later via :meth:`set_default_instance`).
description: Description of the option.
category: Category of the option.
"""
storage_escape = True
def __init__(
self,
container: AppOptionsContainer,
name: str,
default_instance: gds.DataSet | None = None,
description: str = "",
category: str = "",
storage_key: str = "",
runtime: bool = False,
) -> None:
self.default_instance = default_instance
self._serialized_value: str | None = None
# The actively-set value starts as None; get() falls back to the default
# instance until an explicit value is assigned.
super().__init__(
container,
name,
None,
description,
category,
storage_key,
runtime,
)
def check(self, value: Any) -> None:
"""Check that the value is a DataSet or None.
Args:
value: The value to check.
Raises:
ValueError: If the value is neither a DataSet nor None.
"""
if value is not None and not isinstance(value, gds.DataSet):
raise ValueError(
f"Option '{self.name}': expected a DataSet instance or None, "
f"got {type(value).__name__}"
)
def set_default_instance(self, default_instance: gds.DataSet) -> None:
"""Set the default instance (for lazy initialization).
Args:
default_instance: The default DataSet instance to use.
"""
self.default_instance = default_instance
def get(self, default: Any = NO_DEFAULT) -> gds.DataSet | None:
"""Return the current DataSet instance, or the default instance.
Args:
default: Optional DataSet used when the option is not initialized.
Returns:
The actively-set DataSet if any, otherwise the default instance.
"""
value = super().get(default)
if self._serialized_value is not None:
try:
value = gds.json_to_dataset(self._serialized_value)
except Exception: # pylint: disable=broad-except
value = (
default
if default is not NO_DEFAULT and default is not None
else self.default_instance
)
self._value = None
self._is_initialized = False
self._container.unmark_option_initialized(self.name)
else:
self._value = value
self._serialized_value = None
return value if value is not None else self.default_instance
def get_raw(self) -> gds.DataSet | None:
"""Return the raw actively-set DataSet (``None`` if never set)."""
return self._value
def set(self, value: gds.DataSet | None) -> None:
"""Set a DataSet instance and discard any pending serialized value."""
self._serialized_value = None
super().set(value)
def to_storage(self) -> str | None:
"""Return the actively-set DataSet as a JSON string (``None`` if unset)."""
return self.to_json()
def from_storage(self, value: str | None) -> None:
"""Restore the DataSet from a JSON string (``None`` clears the value).
The JSON is resolved immediately, so that an unusable value (e.g. a
DataSet class that no longer exists) is reported back to the caller by
:meth:`to_storage` returning ``None``.
Args:
value: The JSON string to deserialize, or ``None``.
"""
if value is None:
self._value = None
self._serialized_value = None
self.mark_initialized()
else:
self.from_json(value)
self.get()
def to_json(self) -> str | None:
"""Serialize the actively-set DataSet to a JSON string.
Returns:
The JSON string of the actively-set DataSet, or ``None`` when no
value has been explicitly set (so the default instance applies).
"""
if self._serialized_value is not None:
return self._serialized_value
if self._value is None:
return None
return gds.dataset_to_json(self._value)
def from_json(self, json_str: str) -> None:
"""Deserialize a DataSet from a JSON string and store it.
Args:
json_str: The JSON string to deserialize.
"""
self._value = None
self._serialized_value = json_str
self.mark_initialized()
# ---------------------------------------------------------------------------
# Base container with JSON file persistence
# ---------------------------------------------------------------------------
class AppOptionsContainer(OptionsContainer):
"""Base options container for SigimaX-based GUI applications.
Extends Sigima's :class:`OptionsContainer` with optional JSON file
persistence for GUI applications that need to save user preferences
across sessions.
Derived applications should subclass this (or :class:`SigimaXOptions`)
to add their own options as OptionField attributes in ``__init__``.
Class attributes:
APP_NAME: Application name used for default config directory.
This name can be overridden by derived applications to customize the config
path.
"""
APP_NAME = "SigimaX"
def __init__(self) -> None: # pylint: disable=super-init-not-called
# Intentionally NOT calling super().__init__() because
# OptionsContainer.__init__ creates Sigima-specific options.
# We start fresh with our own option fields.
self._initialized_options: set[str] = set()
def is_option_initialized(self, name: str) -> bool:
"""Return whether an option was explicitly set or externally loaded."""
return name in self._initialized_options
def mark_option_initialized(self, name: str) -> None:
"""Mark an option as explicitly initialized."""
self._initialized_options.add(name)
def unmark_option_initialized(self, name: str) -> None:
"""Mark an option as not explicitly initialized."""
self._initialized_options.discard(name)
def option_changed(self, name: str) -> None:
"""Handle an option value change.
Derived applications may override this hook to persist option values.
Args:
name: Name of the changed option.
"""
def generate_rst_doc(self) -> str:
"""Generate reStructuredText documentation for all options.
Returns:
A string containing the reStructuredText documentation.
"""
doc = """.. list-table::
:header-rows: 1
:align: left
* - Name
- Default Value
- Description
"""
for name in vars(self):
opt = getattr(self, name)
if isinstance(opt, OptionField):
description_lines = opt.description.strip().split("\n")
description = "\n".join(
[description_lines[0]]
+ [
" " + line.strip() if line.strip() else ""
for line in description_lines[1:]
]
)
value = repr(opt.get())
if len(value) > 200:
value = value[:197] + "..."
doc += f" * - ``{name}``\n"
doc += f" - ``{value}``\n"
doc += f" - {description}\n"
return doc
# -- Dictionary serialization --
def to_dict(self) -> dict[str, Any]:
"""Return all option values as a JSON-compatible dictionary.
Returns:
A dictionary with option names as keys and their serialized values.
"""
return {
name: getattr(self, name).to_storage()
for name in vars(self)
if isinstance(getattr(self, name), OptionField)
}
def from_dict(self, values: dict[str, Any]) -> None:
"""Set option values from a JSON-compatible dictionary.
Unknown keys are silently ignored, making this safe for loading
options from a newer or older version of the application.
Args:
values: A dictionary with option names as keys and their new values.
"""
for name, value in values.items():
if hasattr(self, name):
opt = getattr(self, name)
if isinstance(opt, OptionField):
try:
opt.from_storage(value)
except (ValueError, TypeError) as exc:
print(
f"[sigimax] Warning: invalid value for "
f"option '{name}': {exc}"
)
# -- JSON file persistence --
def _get_default_config_path(self) -> Path:
"""Return the default path for the JSON configuration file.
Uses the same config directory as the INI-based system for
backward compatibility.
Returns:
Path to the default JSON configuration file.
"""
# Use guidata's config directory resolution
try:
config_dir = Path(_conf_module.Configuration.get_path(""))
except Exception: # pylint: disable=broad-except
# Fallback to user home directory
config_dir = Path.home() / f".{self.APP_NAME}"
config_dir.mkdir(parents=True, exist_ok=True)
return config_dir / "options.json"
def save(self, path: str | Path | None = None) -> None:
"""Save current options to a JSON file.
Args:
path: Path to save to. If None, uses the default config path.
"""
filepath = Path(path) if path else self._get_default_config_path()
filepath.parent.mkdir(parents=True, exist_ok=True)
with open(filepath, "w", encoding="utf-8") as f:
json.dump(self.to_dict(), f, indent=2, ensure_ascii=False)
def load(self, path: str | Path | None = None) -> None:
"""Load options from a JSON file.
Missing keys are left at their current (default) values.
Unknown keys are silently ignored.
Args:
path: Path to load from. If None, uses the default config path.
"""
filepath = Path(path) if path else self._get_default_config_path()
if not filepath.exists():
return
try:
with open(filepath, encoding="utf-8") as f:
values = json.load(f)
self.from_dict(values)
except Exception as exc: # pylint: disable=broad-except
print(f"[sigimax] Warning: failed to load options from {filepath}: {exc}")
# -- Introspection --
def describe_all(self) -> None:
"""Print the name, value, and description of all options."""
for name in vars(self):
opt = getattr(self, name)
if isinstance(opt, OptionField):
print(f"{name} = {opt.get()} # {opt.description}")
def list_options(self) -> list[str]:
"""Return the sorted list of all option names.
Returns:
Sorted list of option attribute names.
"""
return sorted(
name for name in vars(self) if isinstance(getattr(self, name), OptionField)
)
# ---------------------------------------------------------------------------
# PlotPy theme color constants
# ---------------------------------------------------------------------------
#: ROI line color (default blue)
ROI_LINE_COLOR = "#5555ff"
#: ROI selected line color
ROI_SEL_LINE_COLOR = "#9393ff"
#: Marker line color (default dark red)
MARKER_LINE_COLOR = "#A11818"
#: Marker text color
MARKER_TEXT_COLOR = "#440909"
class SigimaXOptions(AppOptionsContainer):
"""Generic options for SigimaX-based GUI applications.
Contains all options that are useful for any derived application building
on SigimaX (window management, console, I/O, visualization defaults,
processing behavior).
At the end of initialization, PlotPy's INI-based configuration is
initialized with default styles for plots, results, and ROI shapes.
Subclasses can override :meth:`get_plotpy_defaults` to customize these.
Derived applications should subclass this to add app-specific options:
.. code-block:: python
class MyAppOptions(SigimaXOptions):
APP_NAME = "MyApp"
CONF_VERSION = "1.0.0"
def __init__(self):
super().__init__()
self.my_option = TypedOptionField(
self, "my_option", default=True,
expected_type=bool,
description="My app-specific option",
)
options = MyAppOptions()
"""
#: Configuration version string (override in subclass if needed)
CONF_VERSION = "1.0.0"
def __init__(self) -> None:
super().__init__()
# ===================================================================
# Derivated application info — Name, version, description, URLs
# ===================================================================
self.app_name = TypedOptionField(
self,
"app_name",
default=self.APP_NAME,
expected_type=str,
description="Application name.",
)
self.app_version = TypedOptionField(
self,
"app_version",
default="0.1.0",
expected_type=str,
description="Application version.",
)
self.app_logo_path = TypedOptionField(
self,
"app_logo_path",
default="",
expected_type=str,
description="Path to the application logo.",
)
self.app_desc = TypedOptionField(
self,
"app_desc",
default="",
expected_type=str,
description="Application description.",
)
self.app_local_doc_path = TypedOptionField(
self,
"app_local_doc_path",
default="",
expected_type=str,
description="Path pattern to a local PDF documentation file. "
"Use '{lang}' as a placeholder for the locale prefix "
"(e.g. 'data/doc/MyApp_{lang}.pdf'). "
"If empty, no local PDF menu item is shown.",
)
self.app_docurl = TypedOptionField(
self,
"app_docurl",
default="",
expected_type=str,
description="URL to the application documentation.",
)
self.app_homeurl = TypedOptionField(
self,
"app_homeurl",
default="",
expected_type=str,
description="URL to the application homepage.",
)
self.app_supporturl = TypedOptionField(
self,
"app_supporturl",
default="",
expected_type=str,
description="URL to the application support/contact page.",
)
self.app_developer = TypedOptionField(
self,
"app_developer",
default="",
expected_type=str,
description="Developer or organization name shown in the About dialog.",
)
self.app_copyright = TypedOptionField(
self,
"app_copyright",
default="",
expected_type=str,
description="Copyright notice shown in the About dialog "
"(e.g. '2023 My Organization').",
)
self.splash_image_path = TypedOptionField(
self,
"splash_image_path",
default="",
expected_type=str,
description="Path to the splash screen image (PNG, SVG, etc.). "
"If empty, no splash screen is shown.",
)
self.splash_show_progress = TypedOptionField(
self,
"splash_show_progress",
default=True,
expected_type=bool,
description="If True, display progress messages on the splash screen "
"during application startup.",
)
# ===================================================================
# Main options — Application-level settings
# ===================================================================
self.color_mode = EnumOptionField(
self,
"color_mode",
category="main",
default="auto",
choices=["auto", "dark", "light"],
description="Application color mode (auto, dark, or light).",
)
self.datetime_format = TypedOptionField(
self,
"datetime_format",
default="%d/%m/%Y - %H:%M:%S",
expected_type=str,
description="Application datetime format.",
)
# ===================================================================
# Log and Console state
# ===================================================================
self.traceback_log_path = ConfigPathOptionField(
self,
"traceback_log_path",
category="main",
default=f".{self.APP_NAME}_traceback.log",
description="Traceback log file basename (inside the config dir).",
)
self.traceback_log_available = TypedOptionField(
self,
"traceback_log_available",
category="main",
default=False,
expected_type=bool,
description="Whether a traceback log file is currently available.",
)
self.faulthandler_enabled = TypedOptionField(
self,
"faulthandler_enabled",
category="main",
default=True,
expected_type=bool,
description="If True, enable Python faulthandler for crash reporting.",
)
self.faulthandler_log_path = ConfigPathOptionField(
self,
"faulthandler_log_path",
category="main",
default=f".{self.APP_NAME}_faulthandler.log",
description="Faulthandler log file basename (inside the config dir).",
)
self.faulthandler_log_available = TypedOptionField(
self,
"faulthandler_log_available",
category="main",
default=False,
expected_type=bool,
description="Whether a faulthandler log file is currently available.",
)
# ===================================================================
# Other Application options
# ===================================================================
self.available_memory_threshold = TypedOptionField(
self,
"available_memory_threshold",
category="main",
default=500,
expected_type=int,
description=(
"Available memory threshold in MB. A warning is shown "
"when available memory drops below this value."
),
)
self.ignore_warnings = TypedOptionField(
self,
"ignore_warnings",
category="proc",
default=False,
expected_type=bool,
description=("If True, suppress Python warnings during computations."),
)
# ===================================================================
# Window state — Persisted UI geometry
# ===================================================================
self.window_maximized = TypedOptionField(
self,
"window_maximized",
category="main",
default=False,
expected_type=bool,
description="Whether the main window was maximized on last close.",
)
self.window_position = TupleOptionField(
self,
"window_position",
category="main",
default=None,
description="Main window position as (x, y) tuple, or None.",
)
self.window_size = TupleOptionField(
self,
"window_size",
category="main",
default=None,
description="Main window size as (width, height) tuple, or None.",
)
self.window_state = TypedOptionField(
self,
"window_state",
category="main",
default="",
expected_type=str,
description=(
"Main window state (hex-encoded QByteArray) for restoring "
"dock widget positions and toolbar layout."
),
)
self.base_dir = WorkingDirOptionField(
self,
"base_dir",
category="main",
default="",
description="Base working directory for file dialogs.",
)
# ===================================================================
# Console options — Embedded console settings
# ===================================================================
self.console_enabled = TypedOptionField(
self,
"console_enabled",
category="console",
default=True,
expected_type=bool,
description="If True, show the embedded Python console.",
)
self.show_console_on_error = TypedOptionField(
self,
"show_console_on_error",
category="console",
default=False,
expected_type=bool,
description=(
"If True, automatically show the console when an error occurs."
),
)
self.console_max_line_count = TypedOptionField(
self,
"console_max_line_count",
category="console",
default=5000,
expected_type=int,
storage_key="max_line_count",
description="Maximum number of lines to keep in the console output.",
)
self.external_editor_path = TypedOptionField(
self,
"external_editor_path",
category="console",
default="code",
expected_type=str,
description=(
"Path to the external editor executable (e.g., 'code' for VS Code)."
),
)
self.external_editor_args = TypedOptionField(
self,
"external_editor_args",
category="console",
default="-g {path}:{line_number}",
expected_type=str,
description=(
"Command-line arguments template for the external editor. "
"Supports {path} and {line_number} placeholders."
),
)
# ===================================================================
# I/O options — File import/export settings
# ===================================================================
self.h5_clear_workspace = TypedOptionField(
self,
"h5_clear_workspace",
category="io",
default=True,
expected_type=bool,
description=(
"If True, clear the workspace before loading an HDF5 file "
"(avoids UUID conflicts)."
),
)
self.h5_clear_workspace_ask = TypedOptionField(
self,
"h5_clear_workspace_ask",
category="io",
default=True,
expected_type=bool,
description=(
"If True, ask user for confirmation before clearing workspace "
"when loading an HDF5 file."
),
)
self.h5_fullpath_in_title = TypedOptionField(
self,
"h5_fullpath_in_title",
category="io",
default=False,
expected_type=bool,
description=(
"If True, use full HDF5 dataset path in signal/image title. "
"If False, use only the dataset name."
),
)
self.h5_fname_in_title = TypedOptionField(
self,
"h5_fname_in_title",
category="io",
default=True,
expected_type=bool,
description=("If True, include the HDF5 file name in signal/image title."),
)
self.imageio_formats = ImageIOOptionField(
self,
"imageio_formats",
category="io",
default=(),
description="Supported ImageIO file formats.",
)
# ===================================================================
# View options — Plot and visualization defaults
# ===================================================================
self.plot_toolbar_position = EnumOptionField(
self,
"plot_toolbar_position",
category="view",
default="left",
choices=["top", "bottom", "left", "right"],
description="Position of the plot toolbar.",
)
self.plot_dock_location = EnumOptionField(
self,
"plot_dock_location",
category="view",
default="right",
choices=["top", "bottom", "left", "right"],
description="Default dock area for plot widgets "
"(top, bottom, left, or right).",
)
self.watermark_image_path = TypedOptionField(
self,
"watermark_image_path",
category="view",
default="",
expected_type=str,
description="Path to the watermark image displayed on empty plots. "
"If empty, no watermark is shown.",
)
self.sig_format = TypedOptionField(
self,
"sig_format",
category="view",
default="",
expected_type=str,
description="Format string for signal shape legends.",
)
self.ima_format = TypedOptionField(
self,
"ima_format",
category="view",
default="",
expected_type=str,
description="Format string for image shape legends.",
)
self.show_label = TypedOptionField(
self,
"show_label",
category="view",
default=False,
expected_type=bool,
description="If True, show labels on plot items.",
)
self.sig_linewidth = TypedOptionField(
self,
"sig_linewidth",
category="view",
default=1.0,
expected_type=float,
description="Default line width for signal curves.",
)
self.sig_linewidth_perfs_threshold = TypedOptionField(
self,
"sig_linewidth_perfs_threshold",
category="view",
default=1000,
expected_type=int,
description=(
"Number of curves above which line width is forced to 1 "
"for performance reasons."
),
)
self.sig_autodownsampling = TypedOptionField(
self,
"sig_autodownsampling",
category="view",
default=True,
expected_type=bool,
description=(
"If True, automatically downsample signals with many points "
"for faster rendering."
),
)
self.sig_autodownsampling_maxpoints = TypedOptionField(
self,
"sig_autodownsampling_maxpoints",
category="view",
default=100000,
expected_type=int,
description="Maximum number of points before auto-downsampling kicks in.",
)
self.sig_autoscale_margin_percent = TypedOptionField(
self,
"sig_autoscale_margin_percent",
category="view",
default=2.0,
expected_type=float,
description="Margin percentage for signal plot autoscale.",
)
self.ima_autoscale_margin_percent = TypedOptionField(
self,
"ima_autoscale_margin_percent",
category="view",
default=1.0,
expected_type=float,
description="Margin percentage for image plot autoscale.",
)
self.ima_eliminate_outliers = TypedOptionField(
self,
"ima_eliminate_outliers",
category="view",
default=0.1,
expected_type=float,
description=(
"Percentage of outliers to eliminate from image LUT range "
"at item creation (0.0 to disable)."
),
)
# --- Signal visualization defaults (persisted in object metadata) ---
self.sig_def_shade = TypedOptionField(
self,
"sig_def_shade",
category="view",
default=0.0,
expected_type=float,
description="Default shade value for signal curves (0.0 = no shade).",
)
self.sig_def_curvestyle = TypedOptionField(
self,
"sig_def_curvestyle",
category="view",
default="Lines",
expected_type=str,
description=(
"Default curve style for signals "
"(e.g., 'Lines', 'Sticks', 'Steps', 'Dots')."
),
)
self.sig_def_baseline = TypedOptionField(
self,
"sig_def_baseline",
category="view",
default=0.0,
expected_type=float,
description="Default baseline value for signal curves.",
)
# --- Image visualization defaults (persisted in object metadata) ---
self.ima_def_colormap = TypedOptionField(
self,
"ima_def_colormap",
category="view",
default="viridis",
expected_type=str,
description="Default colormap for images (e.g., 'viridis', 'gray').",
)
self.ima_def_invert_colormap = TypedOptionField(
self,
"ima_def_invert_colormap",
category="view",
default=False,
expected_type=bool,
description="If True, invert the default colormap.",
)
self.ima_def_interpolation = TypedOptionField(
self,
"ima_def_interpolation",
category="view",
default=5,
expected_type=int,
description="Default interpolation mode for images (integer index).",
)
self.ima_def_alpha = TypedOptionField(
self,
"ima_def_alpha",
category="view",
default=1.0,
expected_type=float,
description="Default alpha (opacity) for images (0.0 to 1.0).",
)
self.ima_def_alpha_function = TypedOptionField(
self,
"ima_def_alpha_function",
category="view",
default=0,
expected_type=int,
description=(
"Default alpha function for images (LUTAlpha enum value). "
"0 = NONE (uniform alpha)."
),
)
self.ima_def_keep_lut_range = TypedOptionField(
self,
"ima_def_keep_lut_range",
category="view",
default=False,
expected_type=bool,
description=(
"If True, keep the LUT range when switching between images "
"instead of auto-scaling."
),
)
# ===================================================================
# Processing options — Computation behavior
# ===================================================================
self.operation_mode = EnumOptionField(
self,
"operation_mode",
category="proc",
default="single",
choices=["single", "pairwise"],
description=(
"Operation mode for multi-selection computations. "
"'single': one operand shared, 'pairwise': paired operations."
),
)
self.extract_roi_singleobj = TypedOptionField(
self,
"extract_roi_singleobj",
category="proc",
default=False,
expected_type=bool,
description=(
"If True, extract all ROIs into a single object. "
"If False, create one object per ROI."
),
)
self.keep_results = TypedOptionField(
self,
"keep_results",
category="proc",
default=False,
expected_type=bool,
description=(
"If True, keep analysis results after processing. "
"Warning: results may become invalid after transformations."
),
)
self.show_result_dialog = TypedOptionField(
self,
"show_result_dialog",
category="proc",
default=True,
expected_type=bool,
description=(
"If True, systematically show a result dialog after "
"analysis computations."
),
)
self.use_signal_bounds = TypedOptionField(
self,
"use_signal_bounds",
category="proc",
default=False,
expected_type=bool,
description=(
"If True, use xmin and xmax bounds from the current signal "
"when creating a new signal."
),
)
self.use_image_dims = TypedOptionField(
self,
"use_image_dims",
category="proc",
default=True,
expected_type=bool,
description=(
"If True, use dimensions from the current image when "
"creating a new image."
),
)
self.fft_shift_enabled = TypedOptionField(
self,
"fft_shift_enabled",
category="proc",
default=True,
expected_type=bool,
description=(
"If True, apply FFT shift to center the zero-frequency "
"component. Synced with sigima.config.options."
),
)
self.auto_normalize_kernel = TypedOptionField(
self,
"auto_normalize_kernel",
category="proc",
default=False,
expected_type=bool,
description=(
"If True, automatically normalize convolution kernels to "
"sum to 1.0 before convolution. "
"Synced with sigima.config.options."
),
)
self.xarray_compat_behavior = EnumOptionField(
self,
"xarray_compat_behavior",
category="proc",
default="ask",
choices=["ask", "interpolate"],
description=(
"Behavior when X-arrays are incompatible in multi-signal "
"operations. 'ask': prompt user, 'interpolate': auto-interpolate."
),
)
# ===================================================================
# Initialize PlotPy INI-based configuration
# ===================================================================
self.initialize_plotpy()
# ===================================================================
# Sync with sigima.config.options for shared settings (e.g., FFT shift, kernel
# normalization)
# ===================================================================
self.sync_with_sigima()
# ===================================================================
# Capture default values for reset_to_defaults()
# (Sigima's OptionField does not expose a .default attribute)
# # TODO: [P3] Refactor OptionField to store the default value explicitly,
# so we can simplify this logic in the future.
# ===================================================================
self._defaults = self.to_dict()
def reset_to_defaults(self) -> None:
"""Reset all options to their default values."""
self._initialized_options.clear()
self.from_dict(self._defaults)
for name in self._defaults:
field = getattr(self, name)
field._is_initialized = False # pylint: disable=protected-access
self._initialized_options.clear()
# -- Option categories (INI sections and settings-UI grouping) --
def get_option_categories(self) -> list[tuple[str, str]]:
"""Return ordered option categories as ``(id, label)`` pairs.
The ``id`` doubles as the INI section name for derived applications and
as the persistence/grouping key; the ``label`` is a human-readable,
translatable title suitable for a settings dialog tab.
Derived applications extend this by concatenating their own categories
to the result of ``super().get_option_categories()``.
Returns:
Ordered list of ``(category_id, label)`` pairs.
"""
return [
("main", _("General")),
("console", _("Console")),
("io", _("I/O")),
("proc", _("Processing")),
("view", _("Visualization")),
]
def get_field_category(self, name: str) -> str:
"""Return the category id of an option field (empty if uncategorized).
Args:
name: The option field name.
Returns:
The category id, or an empty string if the field is uncategorized
or unknown.
"""
field = getattr(self, name, None)
return getattr(field, "category", "") if field is not None else ""
def fields_by_category(self) -> dict[str, list[str]]:
"""Return option field names grouped by category id.
Categories are keyed in the order returned by
:meth:`get_option_categories`; uncategorized fields are omitted.
Returns:
Mapping ``category_id -> [option_field_name, ...]``.
"""
result: dict[str, list[str]] = {
cid: [] for cid, _label in self.get_option_categories()
}
for name in vars(self):
field = getattr(self, name)
if isinstance(field, OptionField):
category = getattr(field, "category", "")
if category:
result.setdefault(category, []).append(name)
return result
# -- PlotPy INI-based configuration integration --
def get_plotpy_defaults(self) -> dict[str, dict[str, Any]]:
"""Return default PlotPy configuration values.
Override this method in subclasses to customize the PlotPy styles
for plots, result annotations, ROI shapes, and labels.
The returned dict has top-level keys corresponding to PlotPy
configuration sections (``"plot"``, ``"results"``, ``"roi"``).
Returns:
Nested dictionary of PlotPy default settings.
"""
# Read at call time: `plotpy.config.set_plotpy_color_mode` rebinds these
# module globals when the color theme changes.
main_fg = plotpy_config.MAIN_FG_COLOR
main_bg = plotpy_config.MAIN_BG_COLOR
return {
"plot": {
# Overriding default plot settings from PlotPy
"title/font/size": 11,
"title/font/bold": False,
"selected_curve_symbol/marker": "Ellipse",
"selected_curve_symbol/edgecolor": "#a0a0a4",
"selected_curve_symbol/facecolor": main_fg,
"selected_curve_symbol/alpha": 0.3,
"selected_curve_symbol/size": 5,
"marker/curve/text/textcolor": "black",
# Cross marker style (shown when pressing Alt key on plot)
"marker/cross/symbol/marker": "Cross",
"marker/cross/symbol/edgecolor": main_fg,
"marker/cross/symbol/facecolor": "#ff0000",
"marker/cross/symbol/alpha": 1.0,
"marker/cross/symbol/size": 8,
"marker/cross/text/font/family": "default",
"marker/cross/text/font/size": 8,
"marker/cross/text/font/bold": False,
"marker/cross/text/font/italic": False,
"marker/cross/text/textcolor": "#000000",
"marker/cross/text/background_color": "#ffffff",
"marker/cross/text/background_alpha": 0.7,
"marker/cross/line/style": "DashLine",
"marker/cross/line/color": MARKER_LINE_COLOR,
"marker/cross/line/width": 1.0,
"marker/cross/markerstyle": "Cross",
"marker/cross/spacing": 7,
# Cursor line and symbol style
"marker/cursor/line/style": "SolidLine",
"marker/cursor/line/color": MARKER_LINE_COLOR,
"marker/cursor/line/width": 1.0,
"marker/cursor/symbol/marker": "NoSymbol",
"marker/cursor/symbol/size": 11,
"marker/cursor/symbol/edgecolor": main_bg,
"marker/cursor/symbol/facecolor": "#ff9393",
"marker/cursor/symbol/alpha": 1.0,
"marker/cursor/sel_line/style": "SolidLine",
"marker/cursor/sel_line/color": MARKER_LINE_COLOR,
"marker/cursor/sel_line/width": 2.0,
"marker/cursor/sel_symbol/marker": "NoSymbol",
"marker/cursor/sel_symbol/size": 11,
"marker/cursor/sel_symbol/edgecolor": main_bg,
"marker/cursor/sel_symbol/facecolor": MARKER_LINE_COLOR,
"marker/cursor/sel_symbol/alpha": 0.8,
"marker/cursor/text/font/size": 9,
"marker/cursor/text/font/family": "default",
"marker/cursor/text/font/bold": False,
"marker/cursor/text/font/italic": False,
"marker/cursor/text/textcolor": MARKER_TEXT_COLOR,
"marker/cursor/text/background_color": "#ffffff",
"marker/cursor/text/background_alpha": 0.7,
"marker/cursor/sel_text/font/size": 9,
"marker/cursor/sel_text/font/family": "default",
"marker/cursor/sel_text/font/bold": False,
"marker/cursor/sel_text/font/italic": False,
"marker/cursor/sel_text/textcolor": MARKER_TEXT_COLOR,
"marker/cursor/sel_text/background_color": "#ffffff",
"marker/cursor/sel_text/background_alpha": 0.7,
# Default annotation text style for segments
"shape/segment/line/style": "SolidLine",
"shape/segment/line/color": "#00ff55",
"shape/segment/line/width": 1.0,
"shape/segment/sel_line/style": "SolidLine",
"shape/segment/sel_line/color": "#00ff55",
"shape/segment/sel_line/width": 2.0,
"shape/segment/fill/style": "NoBrush",
"shape/segment/sel_fill/style": "NoBrush",
"shape/segment/symbol/marker": "XCross",
"shape/segment/symbol/size": 9,
"shape/segment/symbol/edgecolor": "#00ff55",
"shape/segment/symbol/facecolor": "#00ff55",
"shape/segment/symbol/alpha": 1.0,
"shape/segment/sel_symbol/marker": "XCross",
"shape/segment/sel_symbol/size": 12,
"shape/segment/sel_symbol/edgecolor": "#00ff55",
"shape/segment/sel_symbol/facecolor": "#00ff55",
"shape/segment/sel_symbol/alpha": 0.7,
# Default style for drag shapes (global annotations style)
"shape/drag/line/style": "SolidLine",
"shape/drag/line/color": "#00ff55",
"shape/drag/line/width": 1.0,
"shape/drag/fill/style": "SolidPattern",
"shape/drag/fill/color": main_bg,
"shape/drag/fill/alpha": 0.1,
"shape/drag/symbol/marker": "Rect",
"shape/drag/symbol/size": 3,
"shape/drag/symbol/edgecolor": "#00ff55",
"shape/drag/symbol/facecolor": "#00ff55",
"shape/drag/symbol/alpha": 1.0,
"shape/drag/sel_line/style": "SolidLine",
"shape/drag/sel_line/color": "#00ff55",
"shape/drag/sel_line/width": 2.0,
"shape/drag/sel_fill/style": "SolidPattern",
"shape/drag/sel_fill/color": main_bg,
"shape/drag/sel_fill/alpha": 0.1,
"shape/drag/sel_symbol/marker": "Rect",
"shape/drag/sel_symbol/size": 7,
"shape/drag/sel_symbol/edgecolor": "#00ff55",
"shape/drag/sel_symbol/facecolor": "#00ff00",
"shape/drag/sel_symbol/alpha": 0.7,
},
"results": {
# Annotated shape style for result shapes:
# Signals:
"s/annotation/line/style": "SolidLine",
"s/annotation/line/color": "#00aa00",
"s/annotation/line/width": 2,
"s/annotation/fill/style": "NoBrush",
"s/annotation/fill/color": main_bg,
"s/annotation/fill/alpha": 0.1,
"s/annotation/symbol/marker": "XCross",
"s/annotation/symbol/size": 7,
"s/annotation/symbol/edgecolor": "#00aa00",
"s/annotation/symbol/facecolor": "#00aa00",
"s/annotation/symbol/alpha": 1.0,
"s/annotation/sel_line/style": "DashLine",
"s/annotation/sel_line/color": "#00ff00",
"s/annotation/sel_line/width": 1,
"s/annotation/sel_fill/style": "SolidPattern",
"s/annotation/sel_fill/color": main_bg,
"s/annotation/sel_fill/alpha": 0.1,
"s/annotation/sel_symbol/marker": "Rect",
"s/annotation/sel_symbol/size": 9,
"s/annotation/sel_symbol/edgecolor": "#00aa00",
"s/annotation/sel_symbol/facecolor": "#00ff00",
"s/annotation/sel_symbol/alpha": 0.7,
# Images:
"i/annotation/line/style": "SolidLine",
"i/annotation/line/color": "#ffff00",
"i/annotation/line/width": 2,
"i/annotation/fill/style": "SolidPattern",
"i/annotation/fill/color": main_bg,
"i/annotation/fill/alpha": 0.1,
"i/annotation/symbol/marker": "Rect",
"i/annotation/symbol/size": 3,
"i/annotation/symbol/edgecolor": "#ffff00",
"i/annotation/symbol/facecolor": "#ffff00",
"i/annotation/symbol/alpha": 1.0,
"i/annotation/sel_line/style": "SolidLine",
"i/annotation/sel_line/color": "#00ff00",
"i/annotation/sel_line/width": 2,
"i/annotation/sel_fill/style": "SolidPattern",
"i/annotation/sel_fill/color": main_bg,
"i/annotation/sel_fill/alpha": 0.1,
"i/annotation/sel_symbol/marker": "Rect",
"i/annotation/sel_symbol/size": 9,
"i/annotation/sel_symbol/edgecolor": "#00aa00",
"i/annotation/sel_symbol/facecolor": "#00ff00",
"i/annotation/sel_symbol/alpha": 0.7,
# Marker styles for results:
# Signals:
"s/marker/cursor/line/style": "DashLine",
"s/marker/cursor/line/color": MARKER_LINE_COLOR,
"s/marker/cursor/line/width": 1.0,
"s/marker/cursor/symbol/marker": "Ellipse",
"s/marker/cursor/symbol/size": 11,
"s/marker/cursor/symbol/edgecolor": main_bg,
"s/marker/cursor/symbol/facecolor": MARKER_LINE_COLOR,
"s/marker/cursor/symbol/alpha": 0.7,
"s/marker/cursor/sel_line/style": "DashLine",
"s/marker/cursor/sel_line/color": MARKER_LINE_COLOR,
"s/marker/cursor/sel_line/width": 2.0,
"s/marker/cursor/sel_symbol/marker": "Ellipse",
"s/marker/cursor/sel_symbol/size": 11,
"s/marker/cursor/sel_symbol/edgecolor": MARKER_LINE_COLOR,
"s/marker/cursor/sel_symbol/facecolor": MARKER_LINE_COLOR,
"s/marker/cursor/sel_symbol/alpha": 0.7,
"s/marker/cursor/text/font/size": 9,
"s/marker/cursor/text/font/family": "default",
"s/marker/cursor/text/font/bold": False,
"s/marker/cursor/text/font/italic": False,
"s/marker/cursor/text/textcolor": MARKER_TEXT_COLOR,
"s/marker/cursor/text/background_color": "#ffffff",
"s/marker/cursor/text/background_alpha": 0.7,
"s/marker/cursor/sel_text/font/size": 9,
"s/marker/cursor/sel_text/font/family": "default",
"s/marker/cursor/sel_text/font/bold": False,
"s/marker/cursor/sel_text/font/italic": False,
"s/marker/cursor/sel_text/textcolor": MARKER_TEXT_COLOR,
"s/marker/cursor/sel_text/background_color": "#ffffff",
"s/marker/cursor/sel_text/background_alpha": 0.7,
"s/marker/cursor/markerstyle": "Cross",
# Images:
"i/marker/cursor/line/style": "DashLine",
"i/marker/cursor/line/color": MARKER_LINE_COLOR,
"i/marker/cursor/line/width": 1.0,
"i/marker/cursor/symbol/marker": "Diamond",
"i/marker/cursor/symbol/size": 11,
"i/marker/cursor/symbol/edgecolor": MARKER_LINE_COLOR,
"i/marker/cursor/symbol/facecolor": MARKER_LINE_COLOR,
"i/marker/cursor/symbol/alpha": 0.7,
"i/marker/cursor/sel_line/style": "DashLine",
"i/marker/cursor/sel_line/color": MARKER_LINE_COLOR,
"i/marker/cursor/sel_line/width": 2.0,
"i/marker/cursor/sel_symbol/marker": "Diamond",
"i/marker/cursor/sel_symbol/size": 11,
"i/marker/cursor/sel_symbol/edgecolor": MARKER_LINE_COLOR,
"i/marker/cursor/sel_symbol/facecolor": MARKER_LINE_COLOR,
"i/marker/cursor/sel_symbol/alpha": 0.7,
"i/marker/cursor/text/font/size": 9,
"i/marker/cursor/text/font/family": "default",
"i/marker/cursor/text/font/bold": False,
"i/marker/cursor/text/font/italic": False,
"i/marker/cursor/text/textcolor": MARKER_TEXT_COLOR,
"i/marker/cursor/text/background_color": "#ffffff",
"i/marker/cursor/text/background_alpha": 0.7,
"i/marker/cursor/sel_text/font/size": 9,
"i/marker/cursor/sel_text/font/family": "default",
"i/marker/cursor/sel_text/font/bold": False,
"i/marker/cursor/sel_text/font/italic": False,
"i/marker/cursor/sel_text/textcolor": MARKER_TEXT_COLOR,
"i/marker/cursor/sel_text/background_color": "#ffffff",
"i/marker/cursor/sel_text/background_alpha": 0.7,
"i/marker/cursor/markerstyle": "Cross",
# Style for labels:
"label/symbol/marker": "NoSymbol",
"label/symbol/size": 0,
"label/symbol/edgecolor": main_bg,
"label/symbol/facecolor": main_bg,
"label/border/style": "SolidLine",
"label/border/color": "#cbcbcb",
"label/border/width": 1,
"label/font/size": 8,
"label/font/family/nt": [
"Cascadia Code",
"Consolas",
"Courier New",
],
"label/font/family/posix": "Bitstream Vera Sans Mono",
"label/font/family/mac": "Monaco",
"label/font/bold": False,
"label/font/italic": False,
"label/color": main_fg,
"label/bgcolor": main_bg,
"label/bgalpha": 0.8,
"label/anchor": "TL",
"label/xc": 10,
"label/yc": 10,
"label/abspos": True,
"label/absg": "TL",
"label/xg": 0.0,
"label/yg": 0.0,
},
"roi": {
# Signals — Editable ROI (ROI editor):
"s/editable/fill": "#ffff00",
"s/editable/shade": 0.10,
"s/editable/line/style": "SolidLine",
"s/editable/line/color": "#ffff00",
"s/editable/line/width": 1,
"s/editable/fill/style": "SolidPattern",
"s/editable/fill/color": main_bg,
"s/editable/fill/alpha": 0.1,
"s/editable/symbol/marker": "Rect",
"s/editable/symbol/size": 3,
"s/editable/symbol/edgecolor": "#ffff00",
"s/editable/symbol/facecolor": "#ffff00",
"s/editable/symbol/alpha": 1.0,
"s/editable/sel_line/style": "SolidLine",
"s/editable/sel_line/color": "#00ff00",
"s/editable/sel_line/width": 1,
"s/editable/sel_fill/style": "SolidPattern",
"s/editable/sel_fill/color": main_bg,
"s/editable/sel_fill/alpha": 0.1,
"s/editable/sel_symbol/marker": "Rect",
"s/editable/sel_symbol/size": 9,
"s/editable/sel_symbol/edgecolor": "#00aa00",
"s/editable/sel_symbol/facecolor": "#00ff00",
"s/editable/sel_symbol/alpha": 0.7,
# Signals — Readonly ROI (plot):
"s/readonly/line/style": "SolidLine",
"s/readonly/line/color": ROI_LINE_COLOR,
"s/readonly/line/width": 1,
"s/readonly/sel_line/style": "SolidLine",
"s/readonly/sel_line/color": ROI_SEL_LINE_COLOR,
"s/readonly/sel_line/width": 2,
"s/readonly/fill": ROI_LINE_COLOR,
"s/readonly/shade": 0.10,
"s/readonly/symbol/marker": "Ellipse",
"s/readonly/symbol/size": 7,
"s/readonly/symbol/edgecolor": main_bg,
"s/readonly/symbol/facecolor": ROI_LINE_COLOR,
"s/readonly/symbol/alpha": 1.0,
"s/readonly/sel_symbol/marker": "Ellipse",
"s/readonly/sel_symbol/size": 9,
"s/readonly/sel_symbol/edgecolor": main_bg,
"s/readonly/sel_symbol/facecolor": ROI_SEL_LINE_COLOR,
"s/readonly/sel_symbol/alpha": 0.9,
"s/readonly/multi/color": "#806060",
# Images — Editable ROI (ROI editor):
"i/editable/line/style": "SolidLine",
"i/editable/line/color": "#ffff00",
"i/editable/line/width": 1,
"i/editable/fill/style": "SolidPattern",
"i/editable/fill/color": main_bg,
"i/editable/fill/alpha": 0.1,
"i/editable/symbol/marker": "Rect",
"i/editable/symbol/size": 3,
"i/editable/symbol/edgecolor": "#ffff00",
"i/editable/symbol/facecolor": "#ffff00",
"i/editable/symbol/alpha": 1.0,
"i/editable/sel_line/style": "SolidLine",
"i/editable/sel_line/color": "#00ff00",
"i/editable/sel_line/width": 1,
"i/editable/sel_fill/style": "SolidPattern",
"i/editable/sel_fill/color": main_bg,
"i/editable/sel_fill/alpha": 0.1,
"i/editable/sel_symbol/marker": "Rect",
"i/editable/sel_symbol/size": 9,
"i/editable/sel_symbol/edgecolor": "#00aa00",
"i/editable/sel_symbol/facecolor": "#00ff00",
"i/editable/sel_symbol/alpha": 0.7,
# Images — Readonly ROI (plot):
"i/readonly/line/style": "DotLine",
"i/readonly/line/color": ROI_LINE_COLOR,
"i/readonly/line/width": 1,
"i/readonly/fill/style": "SolidPattern",
"i/readonly/fill/color": main_bg,
"i/readonly/fill/alpha": 0.1,
"i/readonly/symbol/marker": "NoSymbol",
"i/readonly/symbol/size": 5,
"i/readonly/symbol/edgecolor": ROI_LINE_COLOR,
"i/readonly/symbol/facecolor": ROI_LINE_COLOR,
"i/readonly/symbol/alpha": 0.6,
"i/readonly/sel_line/style": "DotLine",
"i/readonly/sel_line/color": "#0000ff",
"i/readonly/sel_line/width": 1,
"i/readonly/sel_fill/style": "SolidPattern",
"i/readonly/sel_fill/color": main_bg,
"i/readonly/sel_fill/alpha": 0.1,
"i/readonly/sel_symbol/marker": "Rect",
"i/readonly/sel_symbol/size": 8,
"i/readonly/sel_symbol/edgecolor": "#0000aa",
"i/readonly/sel_symbol/facecolor": "#0000ff",
"i/readonly/sel_symbol/alpha": 0.7,
},
}
def apply_plotpy_defaults(self) -> None:
"""Apply the default PlotPy styles returned by :meth:`get_plotpy_defaults`.
This method is called automatically at the end of ``__init__``. It must
also be called again after each color theme change, since the defaults
depend on PlotPy's current foreground/background colors.
"""
PLOTPY_CONF.update_defaults(self.get_plotpy_defaults())
def set_plotpy_application(
self, config_app_name: str = "", load: bool = False
) -> None:
"""Set the application name used for PlotPy's INI file.
Args:
config_app_name: Application name for the PlotPy INI file
(e.g., ``"MyApp_v1"``). If empty, PlotPy uses its own default.
load: If True, load existing user settings from the INI file.
"""
PLOTPY_CONF.set_application(
osp.join(config_app_name, "plotpy") if config_app_name else "plotpy",
self.CONF_VERSION,
load=load,
)
def initialize_plotpy(self, config_app_name: str = "", load: bool = False) -> None:
"""Initialize PlotPy's INI-based configuration.
Convenience wrapper around :meth:`apply_plotpy_defaults` and
:meth:`set_plotpy_application`.
Args:
config_app_name: Application name for the PlotPy INI file
(e.g., ``"MyApp_v1"``). If empty, PlotPy uses its own default.
load: If True, load existing user settings from the INI file.
"""
self.apply_plotpy_defaults()
self.set_plotpy_application(config_app_name, load=load)
def sync_with_sigima(self) -> None:
"""Synchronize relevant options with Sigima's options container.
Call this after loading or modifying options that have Sigima counterparts
(``fft_shift_enabled``, ``auto_normalize_kernel``, ``imageio_formats``).
"""
sigima_options.fft_shift_enabled.set(self.fft_shift_enabled.get())
sigima_options.auto_normalize_kernel.set(self.auto_normalize_kernel.get())
sigima_options.imageio_formats.set(self.imageio_formats.get())
def get_sigima_defaults(self, category: str) -> dict:
"""Get default Sigima visualization settings as a dictionary.
Collects all options named ``{category}_def_*`` and returns them
as a dictionary with the ``{category}_def_`` prefix stripped.
Args:
category: 'sig' for signal defaults, 'ima' for image defaults.
Returns:
Dictionary of default visualization settings.
Example:
>>> options.get_sigima_defaults("ima")
{'colormap': 'viridis', 'alpha': 1.0, ...}
"""
assert category in ("ima", "sig"), f"Expected 'ima' or 'sig', got {category!r}"
prefix = f"{category}_def_"
result = {}
for name in vars(self):
if name.startswith(prefix):
opt = getattr(self, name)
if isinstance(opt, OptionField):
value = opt.get()
if value is not None:
result[name[len(prefix) :]] = value
return result
def set_sigima_defaults(self, category: str, defaults: dict) -> None:
"""Set default Sigima visualization settings from a dictionary.
Args:
category: 'sig' for signal defaults, 'ima' for image defaults.
defaults: Dictionary of setting names (without prefix) to values.
Example:
>>> options.set_sigima_defaults("ima", {"colormap": "gray"})
"""
assert category in ("ima", "sig"), f"Expected 'ima' or 'sig', got {category!r}"
prefix = f"{category}_def_"
for key, value in defaults.items():
attr_name = f"{prefix}{key}"
if hasattr(self, attr_name):
opt = getattr(self, attr_name)
if isinstance(opt, OptionField):
opt.set(value)
#: Global instance of SigimaX options.
#: Derived applications should create their own instance of their subclass.
CONF = SigimaXOptions()
#: Names of every option defined by the SigimaX base configuration. A derived
#: application may add options and override values, but it may **not** remove a
#: base option (doing so would break SigimaX modules that read it at runtime).
_BASE_OPTION_NAMES: frozenset[str] = frozenset(
name for name in vars(CONF) if isinstance(getattr(CONF, name), OptionField)
)
#: The currently active options container. Defaults to the SigimaX base
#: configuration; a derived application installs its own container via
#: :func:`set_conf`. All SigimaX modules read the active container through
#: :func:`get_conf` (never by binding ``CONF`` directly), so that a derived
#: application's configuration is honoured transparently regardless of import
#: order.
_active_conf: AppOptionsContainer = CONF
def get_conf() -> AppOptionsContainer:
"""Return the currently active options container.
SigimaX modules (and derived-application code) should call this at runtime
to read configuration options, e.g. ``get_conf().color_mode.get()``.
Returns:
The active options container (the SigimaX base by default, or the
container installed by a derived application via :func:`set_conf`).
"""
return _active_conf
def set_conf(container: AppOptionsContainer) -> None:
"""Install a derived application's options container as the active one.
The container must define **every** SigimaX base option (base options
cannot be removed) so that SigimaX modules never fail a runtime lookup. It
may freely add new options and override default values.
Args:
container: The options container to activate (typically a subclass of
:class:`SigimaXOptions`).
Raises:
ValueError: If the container is missing one or more base SigimaX options.
"""
container_names = {
name
for name in vars(container)
if isinstance(getattr(container, name), OptionField)
}
missing = _BASE_OPTION_NAMES - container_names
if missing:
raise ValueError(
"Cannot install options container: the following base SigimaX "
f"options are missing (base options cannot be removed): {sorted(missing)}"
)
global _active_conf # pylint: disable=global-statement
_active_conf = container
def reset_conf() -> None:
"""Restore the SigimaX base configuration as the active container.
Mainly useful for tests that install a derived container and need to revert.
"""
global _active_conf # pylint: disable=global-statement
_active_conf = CONF
DataLab-Platform-SigimaX-0182bf4/sigimax/data/ 0000775 0000000 0000000 00000000000 15244251443 0021031 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/ 0000775 0000000 0000000 00000000000 15244251443 0022144 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/analysis/ 0000775 0000000 0000000 00000000000 15244251443 0023767 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/analysis/show_results.svg 0000664 0000000 0000000 00000010621 15244251443 0027251 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/apply.svg 0000664 0000000 0000000 00000000725 15244251443 0024016 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/check_all.svg 0000664 0000000 0000000 00000010220 15244251443 0024565 0 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/collapse.svg 0000664 0000000 0000000 00000003173 15244251443 0024473 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/collapse_selection.svg 0000664 0000000 0000000 00000004257 15244251443 0026544 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/expand.svg 0000664 0000000 0000000 00000003213 15244251443 0024143 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/expand_selection.svg 0000664 0000000 0000000 00000004275 15244251443 0026221 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/h5/ 0000775 0000000 0000000 00000000000 15244251443 0022460 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/h5/h5attrs.svg 0000664 0000000 0000000 00000014402 15244251443 0024574 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/h5/h5browser.svg 0000664 0000000 0000000 00000011465 15244251443 0025130 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/h5/h5file.svg 0000664 0000000 0000000 00000005202 15244251443 0024354 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/h5/h5group.svg 0000664 0000000 0000000 00000013061 15244251443 0024573 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/help_pdf.svg 0000664 0000000 0000000 00000010107 15244251443 0024445 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/io/ 0000775 0000000 0000000 00000000000 15244251443 0022553 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/io/fileopen_h5.svg 0000664 0000000 0000000 00000007347 15244251443 0025504 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/io/filesave_h5.svg 0000664 0000000 0000000 00000010015 15244251443 0025463 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/libre-gui-about.svg 0000664 0000000 0000000 00000000541 15244251443 0025654 0 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/libre-gui-close.svg 0000664 0000000 0000000 00000003274 15244251443 0025655 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/libre-gui-globe.svg 0000664 0000000 0000000 00000012046 15244251443 0025635 0 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/libre-gui-help.svg 0000664 0000000 0000000 00000002361 15244251443 0025474 0 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/libre-gui-menu.svg 0000664 0000000 0000000 00000000426 15244251443 0025510 0 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/logs.svg 0000664 0000000 0000000 00000001441 15244251443 0023631 0 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/menu.svg 0000664 0000000 0000000 00000005364 15244251443 0023641 0 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/restore.svg 0000664 0000000 0000000 00000002461 15244251443 0024353 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/to_signal.svg 0000664 0000000 0000000 00000007420 15244251443 0024647 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/uncheck_all.svg 0000664 0000000 0000000 00000011740 15244251443 0025140 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/view/ 0000775 0000000 0000000 00000000000 15244251443 0023116 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/icons/view/refresh-auto.svg 0000664 0000000 0000000 00000005671 15244251443 0026254 0 ustar 00root root 0000000 0000000
DataLab-Platform-SigimaX-0182bf4/sigimax/data/tests/ 0000775 0000000 0000000 00000000000 15244251443 0022173 5 ustar 00root root 0000000 0000000 DataLab-Platform-SigimaX-0182bf4/sigimax/data/tests/empty.h5 0000664 0000000 0000000 00000001440 15244251443 0023566 0 ustar 00root root 0000000 0000000 HDF
` TREE HEAP X P DataLab-Platform-SigimaX-0182bf4/sigimax/data/tests/reordering_test.h5 0000664 0000000 0000000 00000341150 15244251443 0025634 0 ustar 00root root 0000000 0000000 HDF
h ` TREE 0 HEAP X ( DataLab_Version DataLab_Sig 0 SNOD x TREE ( h ` GCOL 1.0.0a1 lorentz(a=1,sigma=1,mu=0,ymin=0) $ 879dd279-5c97-4cc3-8c6a-4a183773e72b Lines %g
derivative(s001) $ 51839830-bb97-46b9-b96a-8ed0def5a2c5 Lines %g wiener(s002) $ 4f496e98-c8dd-40f8-a75b-bf08628b0235 Lines %g ! " # $ % & ' ( ) * derivative(g001)+ derivative(s001), $ 1cd96fc0-3053-4a52-bc27-c8325fa02651 - Lines . %g / 0 1 2 3 4 5 6 7 8 derivative(s002)9 $ 642cb4c3-7c77-4ce4-a7b1-6e2bc82ec40b : Lines ; %g < = > ? @ A B C D E derivative(s003)F $ 748934e3-8398-42de-a0dc-98f30008ea14 G Lines H %g I J K L M N O P Q R magnitude_spectrum(g002)S magnitude_spectrum(s004)T $ 25dd7970-e2ca-4c9e-adab-1a0dee022e44 U Lines V %g W X Frequency Y Z [ \ ] ^ _ ` magnitude_spectrum(s005)a $ 1d83959d-57d0-44d9-be4a-2218eae8b227 b Lines c %g d e Frequency f g h i j k l m magnitude_spectrum(s006)n $ 13d2e5d7-8802-47d4-a3c1-5d745105e85a o Lines p %g q r Frequency s t u v w x y P HEAP X H 0 g001: g002: derivative(g001) g003: magnitude_spectrum(g002) TREE @ HEAP X s001: lorentz(a1sigma1mu0ymin0) s002: derivative(s001) s003: wiener(s002) SNOD 8 ( 4 6 @ title ` TREE A HEAP X 0 xydata metadata 8 SNOD ( K K M @ Py xy { G @ title ( ? @ 4 4 @" @ x $hz#Q9#9o#s#I e#s߄#JZp#BE[#߄OG#!2#;ؾD #[ #P9"4͕"!2/"ϩ"-l$"[ "}Ļz"&-Ce"ΕQ"v}<" g("ϩ~"o8T!s! !hr+i!ۗ!Ce^!`ك! So!} !R {!wM3 s KZp( l$ +i De^ ay e^d =Z5P 6W҂; So& 5P x R \ϩ U ŀ &|:W Ntt. m f @l_" =X\ Qya 2In8 B
d ҂;DY #T4~N t%-C %8k ,.B ef# j <
W
Mt K H" R#5:o§ϩ~ۗU,i ,|:W ݫˁnw?l_Qya6`"V
K ŀ'AQya6gr+i8k @C
d\I U 4~NOGr @1I&8k w1ǔ*߿f#h7 S|S
ǔ*Z|:MttL i^]"T4=\I dԖ>53/
)ؾD gЩ~>!{qL ,fcpGc T4~Nwo§Fhzya6QJZp(8 S|KqپD g)=X\za6Q[2/F2(< k @1z&
x]I e(<aO_ۗ@1InكEѽ dJ_cJx4CH2jK [ wM3L*?
̼0ɨ
l_"V
w PGr` ^] G 4/F2j ѽ vt.
s
!
X\ u} gr+ ݫQyV ŀ'%8k U :k @1 )U`q*8Tu70ɨ- v}@R ŀ'AEhPHn8TR {Z5P $hX*߿ o§{x`wM3?l_"OG 2/FhTuJZ`?lHFm#` =] =pJr`p&|:Kq激) z7㿀'APῐ ݫ@p+i @9o@0VH@V
@ef@Lns%-@ˁB
@)=X\@hm@U @(AR@m@@DYH@@ @`q*?@ /@ ,.BE@|@~ؾD g@.
)@53@dԖ>@<\I @"T4@^]@J i@Mtt@|:@Z@
ǔ*@S@h7 S|@f#@Ɣ*߿@v1@$8k @ @1I@OGr@4~N@U @\I @@
d@8k @@gr+i@Pya6@ ŀ'A@K@`"V
@Qya6@?l_@lw@ ݫˁ@ @|:W@,i ,@ܗU@ϩ~@8o§@#5@R@H" @K @Mt @T
@<
@j @df# @ ,.B @%8k @t%-C @$T4~N @Ђ;DY @B
d @0In8 @Qya @=X\ @@l_" @f @m @Ltt. @&|:W @U ŀ @\ϩ @ @R @4P x @So& @6W҂; @ !@Ov1!@XHF!@}q?gq?r=ϐq?q4sq?pq?8B
r?퇽;r? gr?ݔr?=fbr?lWr?=d s?o#/Ns? s?v1s?!7s?a{t?ul#Gt?o{t?x\t?ht?y[u?>kQoRu?8%Zu?J.F!u?nߤ u?1]U7v?rv?U0v?wRv?n\c*w?|q (jw?d
\ zw?[w?P/>.x?7뻻qx? cSx?k x? 66By?|)y? ѩ6y?1 z??{mjz?SMsz?kn
{?PvU{?|x{?sBQ{?ꗣL|?O'=>|?H |? KQ}?6}?.k%~?hjid~?U _~?s$?*sh?
?~(?pKdž\?Q]!3?5؞ǀ?Ƃ?26?_Ko?(.?@n?G7"?f`?\
? XU߂? ?Q~u c?>
! ?ځ?@n4?m:y}?RDŽ?god?49`?:?WB6U ?nR?Z?8?
v<U?y7E?#W
?',h?A Ɉ?SWy+?@2*?+?ێ`?y;̊?B ?:?D ?l ??qLK?X茍?@ʟ ?vԌ?
_?|t?E@T?^?݂Kg?eT`?C?]?k?~;?Z-,?H{3;?)QMH?U?%3G$R?4vl?04Ӕ?=?t?F? ǭݎ? ??T?/bP?!; ?ff~?a(`#?vd?d 9P??[('W&?9?4E?e
j?pO=?JL? .Z ?%/f=;?iG?K)??ѥ1n7?aUhSj?7ѐU? s
?cy?He?\>%?}? K?T? Ox?{-a?wR?!(% K? h(J?
·O?/w;X?e?&
Yt?"=?;uEgH?ׂm9^?:$N?ߊ$#?(k@? &?~Ke?3wm?K?|#P?9Y+?94hL?Vw]?Vw]?:4hL?9Y+?|#P?K?3wm?~Ke? &?(k@?$#?:$N?ׂm9^?BuEgH?"=?&
Yt?e?=w;X?
·O? h(J?.(% K?%wR?{-a? Ox?T?)K?}?\>%?He?cy? s
??ѐU?pUhSj?ѥ1n7??Z)?uG?%/f=;? .Z ?UL?pO=?e
j?6>4E??2ǒ+?J~eH}?\ֲ?747?~
?\
?3#?ZȟF?/|nR?J#?ER ?H_
! ?T~u c? ? XU߂?]
?f`?J7"?An?(.?bKo?26?Ƃ?5؞ǀ?Q]!3?pKdž\?~(?
?*sh?s$?U _~?hjid~?.k%~?3}?KQ}?H |?T'=>|?헣L|?sBQ{?|x{?PvU{?kn
{?SMsz??{mjz?3 z? ѩ6y?|)y? 66By?k x?cSx?7뻻qx?P/>.x?[w?d
\ zw?|q (jw?m\c*w?zRv?U0v?rv?3]U7v?nߤ u?J.F!u?6%Zu?@kQoRu?y[u?ht?x\t?o{t?ul#Gt?a{t?!7s?v1s? s?q#/Ns?=d s?lWr?=fbr?ݔr?"gr?퇽;r?:B
r?pq?q4sq?r=ϐq?gq?
>q?6q?b p?kp?vqWlp?dRNa{p?0Up? Jl0p?4u !R {!wM3 s KZp( l$ +i De^ ay e^d =Z5P 6W҂; So& 5P x R \ϩ U ŀ &|:W Ntt. m f @l_" =X\ Qya 2In8 B
d ҂;DY #T4~N t%-C %8k ,.B ef# j <
W
Mt K H" R#5:o§ϩ~ۗU,i ,|:W ݫˁnw?l_Qya6`"V
K ŀ'AQya6gr+i8k @C
d\I U 4~NOGr @1I&8k w1ǔ*߿f#h7 S|S
ǔ*Z|:MttL i^]"T4=\I dԖ>53/
)ؾD gЩ~>!{qL ,fcpGc T4~Nwo§Fhzya6QJZp(8 S|KqپD g)=X\za6Q[2/F2(< k @1z&
x]I e(<aO_ۗ@1InكEѽ dJ_cJx4CH2jK [ wM3L*?
̼0ɨ
l_"V
w PGr` ^] G 4/F2j ѽ vt.
s
!
X\ u} gr+ ݫQyV ŀ'%8k U :k @1 )U`q*8Tu70ɨ- v}@R ŀ'AEhPHn8TR {Z5P $hX*߿ o§{x`wM3?l_"OG 2/FhTuJZ`?lHFm#` =] =pJr`p&|:Kq激) z7㿀'APῐ ݫ@p+i @9o@0VH@V
@ef@Lns%-@ˁB
@)=X\@hm@U @(AR@m@@DYH@@ @`q*?@ /@ ,.BE@|@~ؾD g@.
)@53@dԖ>@<\I @"T4@^]@J i@Mtt@|:@Z@
ǔ*@S@h7 S|@f#@Ɣ*߿@v1@$8k @ @1I@OGr@4~N@U @\I @@
d@8k @@gr+i@Pya6@ ŀ'A@K@`"V
@Qya6@?l_@lw@ ݫˁ@ @|:W@,i ,@ܗU@ϩ~@8o§@#5@R@H" @K @Mt @T
@<
@j @df# @ ,.B @%8k @t%-C @$T4~N @Ђ;DY @B
d @0In8 @Qya @=X\ @@l_" @f @m @Ltt. @&|:W @U ŀ @\ϩ @ @R @4P x @So& @6W҂; @ !@Ov1!@XHF!@}P?\]ZQ?=>?Q?ܣ~Q?*Q?"KQ? A=_BR?kR?ML R?ś{S?3˕7YS?ҶI[S?S?E8T?TnMT? T??2wa&U?;u6xU?SǵU?9e/k"V?AyV?yd$V?k~?.W?Q?W?ҋ/W?_!6 KX?zh X?U(+Y?-X,ezY?Y?iOZ?
PwZ?.[?qx[?fT\?HX\?Ӎ2 ]?1zs]?-^?NNԉ^?]x_?B _?fG`?uԁZ`?Ʀ`?v6 `?brM.