pyAthina 0.0.1__tar.gz

pyathina-0.0.1/LICENSE

@@ -0,0 +1,24 @@
+Copyright (c) 2024 Evangelos Golias.
+Contact: evangelos.golias@gmail.com
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+------------------------------------------------------- 

pyathina-0.0.1/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: pyAthina
+Version: 0.0.1
+Summary: A photoelectron miroscpectroscopy/spectromicroscopy data analyis package
+Author-email: Evangelos Golias <evangelos.golias@gmail.com>
+Project-URL: Homepage, https://gitlab.com/evangelosgolias/athina
+Project-URL: Issues, https://gitlab.com/evangelosgolias/athina/-/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pyAthina
+
+A lightweight PyQt6 + pyqtgraph skeleton for PEEM-style image-stack workflows.
+
+## Install
+
+```bash
+pip install -r requirements.txt
+```
+
+## Run
+
+Any of these should work from the extracted project folder:
+
+```bash
+python -m pyAthina.main
+```
+
+```bash
+python -m pyAthina
+```
+
+```bash
+python run_pyAthina.py
+```
+
+If you `cd` into the `pyAthina/` subfolder itself, you can also run:
+
+```bash
+python main.py
+```

pyathina-0.0.1/README.md

@@ -0,0 +1,31 @@
+# pyAthina
+
+A lightweight PyQt6 + pyqtgraph skeleton for PEEM-style image-stack workflows.
+
+## Install
+
+```bash
+pip install -r requirements.txt
+```
+
+## Run
+
+Any of these should work from the extracted project folder:
+
+```bash
+python -m pyAthina.main
+```
+
+```bash
+python -m pyAthina
+```
+
+```bash
+python run_pyAthina.py
+```
+
+If you `cd` into the `pyAthina/` subfolder itself, you can also run:
+
+```bash
+python main.py
+```

pyathina-0.0.1/pyproject.toml

@@ -0,0 +1,21 @@
+[build-system]
+requires = ["PyQt6", "pyqtgraph>=0.13", "numpy", "scipy","scikit-image","h5py", "tifffile", "setuptools"]
+build-backend = "setuptools.build_meta"
+[project]
+name = "pyAthina"
+version = "0.0.1"
+authors = [
+  { name="Evangelos Golias", email="evangelos.golias@gmail.com" },
+]
+description = "A photoelectron miroscpectroscopy/spectromicroscopy data analyis package"
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+]
+
+[project.urls]
+Homepage = "https://gitlab.com/evangelosgolias/athina"
+Issues = "https://gitlab.com/evangelosgolias/athina/-/issues"

pyathina-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

pyathina-0.0.1/src/pyAthina/__init__.py

@@ -0,0 +1,10 @@
+__all__ = [
+    "app",
+    "io",
+    "main",
+    "models",
+    "processing",
+    "signals",
+    "viewer",
+    "workers",
+]

pyathina-0.0.1/src/pyAthina/__main__.py

@@ -0,0 +1,4 @@
+from .main import main
+
+if __name__ == "__main__":
+    main()

pyathina-0.0.1/src/pyAthina/app.py

@@ -0,0 +1,453 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional
+
+import numpy as np
+from PyQt6.QtCore import Qt
+from PyQt6.QtWidgets import (
+    QCheckBox,
+    QDockWidget,
+    QFileDialog,
+    QFormLayout,
+    QHBoxLayout,
+    QLabel,
+    QMainWindow,
+    QMessageBox,
+    QPushButton,
+    QProgressBar,
+    QSlider,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
+)
+
+from pyAthina.io import load_stack_auto, save_image_tiff
+from pyAthina.models import ImageStack
+from pyAthina.processing import average_stack, average_stack_in_roi
+from pyAthina.signals import PEEMSignals
+from pyAthina.viewer import PEEMImageView
+from pyAthina.workers import AlignmentWorker, create_alignment_thread
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("pyAthina")
+        self.resize(1450, 920)
+
+        self.signals = PEEMSignals()
+        self.stack: Optional[ImageStack] = None
+        self.current_index = 0
+        self.last_shifts: np.ndarray | None = None
+
+        self._alignment_thread = None
+        self._alignment_worker = None
+        self._alignment_running = False
+
+        self.viewer = PEEMImageView(self.signals)
+        self._build_central_panel()
+
+        self._build_left_panel()
+        self._build_right_panel()
+        self._connect_signals()
+        self._load_dummy_data()
+
+    def _build_central_panel(self) -> None:
+        central = QWidget()
+        layout = QVBoxLayout(central)
+        layout.setContentsMargins(6, 6, 6, 6)
+
+        self.frame_slider = QSlider(Qt.Orientation.Horizontal)
+        self.frame_slider.setMinimum(0)
+        self.frame_slider.setMaximum(0)
+        self.frame_slider.setSingleStep(1)
+        self.frame_slider.setPageStep(1)
+        self.frame_slider.setTickInterval(1)
+        self.frame_slider.setTracking(True)
+
+        slider_row = QHBoxLayout()
+        self.lbl_frame_min = QLabel("0")
+        self.lbl_frame_current = QLabel("Frame 0 / 0")
+        self.lbl_frame_max = QLabel("0")
+        slider_row.addWidget(self.lbl_frame_min)
+        slider_row.addWidget(self.frame_slider, stretch=1)
+        slider_row.addWidget(self.lbl_frame_max)
+
+        layout.addWidget(self.viewer, stretch=1)
+        layout.addLayout(slider_row)
+        layout.addWidget(self.lbl_frame_current)
+
+        self.setCentralWidget(central)
+
+    def _build_left_panel(self) -> None:
+        dock = QDockWidget("Controls", self)
+        dock.setFeatures(
+            QDockWidget.DockWidgetFeature.DockWidgetMovable
+            | QDockWidget.DockWidgetFeature.DockWidgetFloatable
+        )
+        panel = QWidget()
+        layout = QVBoxLayout(panel)
+
+        self.btn_load = QPushButton("Load stack")
+        self.btn_prev = QPushButton("Previous frame")
+        self.btn_next = QPushButton("Next frame")
+        self.btn_align = QPushButton("Align stack (threaded)")
+        self.btn_average_roi = QPushButton("Show ROI average")
+        self.btn_average_full = QPushButton("Show full-stack average")
+        self.btn_export_view = QPushButton("Export current view as TIFF")
+
+        self.spin_frame = QSpinBox()
+        self.spin_frame.setMinimum(0)
+        self.spin_frame.setMaximum(0)
+
+        self.spin_reference = QSpinBox()
+        self.spin_reference.setMinimum(0)
+        self.spin_reference.setMaximum(0)
+
+        self.spin_upsample = QSpinBox()
+        self.spin_upsample.setMinimum(1)
+        self.spin_upsample.setMaximum(100)
+        self.spin_upsample.setValue(10)
+
+        self.chk_roi = QCheckBox("Enable ROI")
+        self.chk_crosshair = QCheckBox("Enable crosshair")
+
+        self.progress_align = QProgressBar()
+        self.progress_align.setRange(0, 100)
+        self.progress_align.setValue(0)
+        self.progress_align.setFormat("Idle")
+
+        form = QFormLayout()
+        form.addRow("Frame", self.spin_frame)
+        form.addRow("Reference frame", self.spin_reference)
+        form.addRow("Upsample factor", self.spin_upsample)
+
+        layout.addWidget(self.btn_load)
+        layout.addLayout(form)
+        layout.addWidget(self.btn_prev)
+        layout.addWidget(self.btn_next)
+        layout.addWidget(self.chk_roi)
+        layout.addWidget(self.chk_crosshair)
+        layout.addWidget(self.btn_align)
+        layout.addWidget(self.progress_align)
+        layout.addWidget(self.btn_average_roi)
+        layout.addWidget(self.btn_average_full)
+        layout.addWidget(self.btn_export_view)
+        layout.addStretch()
+
+        dock.setWidget(panel)
+        self.addDockWidget(Qt.DockWidgetArea.LeftDockWidgetArea, dock)
+
+    def _build_right_panel(self) -> None:
+        dock = QDockWidget("Status", self)
+        dock.setFeatures(
+            QDockWidget.DockWidgetFeature.DockWidgetMovable
+            | QDockWidget.DockWidgetFeature.DockWidgetFloatable
+        )
+        panel = QWidget()
+        layout = QFormLayout(panel)
+
+        self.lbl_stack = QLabel("-")
+        self.lbl_shape = QLabel("-")
+        self.lbl_mouse = QLabel("x=-, y=-")
+        self.lbl_value = QLabel("-")
+        self.lbl_roi = QLabel("-")
+        self.lbl_crosshair = QLabel("-")
+        self.lbl_last_shift = QLabel("-")
+
+        layout.addRow("Stack", self.lbl_stack)
+        layout.addRow("Shape", self.lbl_shape)
+        layout.addRow("Mouse", self.lbl_mouse)
+        layout.addRow("Pixel value", self.lbl_value)
+        layout.addRow("ROI", self.lbl_roi)
+        layout.addRow("Crosshair", self.lbl_crosshair)
+        layout.addRow("Last shift", self.lbl_last_shift)
+
+        dock.setWidget(panel)
+        self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, dock)
+
+    def _connect_signals(self) -> None:
+        self.btn_load.clicked.connect(self.load_stack_dialog)
+        self.btn_prev.clicked.connect(self.prev_frame)
+        self.btn_next.clicked.connect(self.next_frame)
+        self.btn_align.clicked.connect(self.run_alignment_threaded)
+        self.btn_average_roi.clicked.connect(self.show_average_roi)
+        self.btn_average_full.clicked.connect(self.show_average_full)
+        self.btn_export_view.clicked.connect(self.export_current_view)
+        self.spin_frame.valueChanged.connect(self.set_frame)
+        self.frame_slider.valueChanged.connect(self.set_frame)
+        self.chk_roi.toggled.connect(self.viewer.show_roi)
+        self.chk_crosshair.toggled.connect(self.viewer.show_crosshair)
+
+        self.signals.mouse_moved.connect(self.on_mouse_moved)
+        self.signals.left_clicked.connect(self.on_left_clicked)
+        self.signals.right_clicked.connect(self.on_right_clicked)
+        self.signals.double_clicked.connect(self.on_double_clicked)
+        self.signals.roi_changed.connect(self.on_roi_changed)
+        self.signals.crosshair_moved.connect(self.on_crosshair_moved)
+        self.signals.frame_changed.connect(self.on_frame_changed)
+        self.signals.stack_loaded.connect(self.on_stack_loaded)
+
+    def _load_dummy_data(self) -> None:
+        self.set_stack(ImageStack.dummy())
+        self.viewer.set_roi(80, 80, 180, 180)
+
+    def load_stack_dialog(self) -> None:
+        path, _ = QFileDialog.getOpenFileName(
+            self,
+            "Open stack",
+            "",
+            "Stacks (*.npy *.h5 *.hdf5 *.hdf);;All files (*)",
+        )
+        if not path:
+            return
+
+        try:
+            stack = load_stack_auto(path)
+            self.set_stack(stack)
+        except Exception as exc:
+            QMessageBox.critical(self, "Load error", str(exc))
+
+    def set_stack(self, stack: ImageStack) -> None:
+        self.stack = stack
+        self.current_index = 0
+        self.last_shifts = None
+
+        self.spin_frame.blockSignals(True)
+        self.spin_reference.blockSignals(True)
+        self.frame_slider.blockSignals(True)
+        self.spin_frame.setMaximum(stack.n_images - 1)
+        self.spin_reference.setMaximum(stack.n_images - 1)
+        self.frame_slider.setMaximum(stack.n_images - 1)
+        self.spin_frame.setValue(0)
+        self.spin_reference.setValue(0)
+        self.frame_slider.setValue(0)
+        self.spin_frame.blockSignals(False)
+        self.spin_reference.blockSignals(False)
+        self.frame_slider.blockSignals(False)
+        self.lbl_frame_min.setText("0")
+        self.lbl_frame_max.setText(str(max(0, stack.n_images - 1)))
+        self._update_frame_indicator()
+
+        self._update_display()
+        n, (ny, nx) = stack.n_images, stack.shape2d
+        self.signals.stack_loaded.emit(stack.name, n, ny, nx)
+
+    def set_frame(self, index: int) -> None:
+        if self.stack is None:
+            return
+        index = max(0, min(index, self.stack.n_images - 1))
+        self.current_index = index
+
+        self.spin_frame.blockSignals(True)
+        self.frame_slider.blockSignals(True)
+        self.spin_frame.setValue(index)
+        self.frame_slider.setValue(index)
+        self.spin_frame.blockSignals(False)
+        self.frame_slider.blockSignals(False)
+
+        self._update_display()
+        self._update_frame_indicator()
+        self.signals.frame_changed.emit(index)
+
+    def prev_frame(self) -> None:
+        self.set_frame(self.current_index - 1)
+
+    def next_frame(self) -> None:
+        self.set_frame(self.current_index + 1)
+
+    def _update_display(self) -> None:
+        if self.stack is None:
+            return
+        self.viewer.set_image(self.stack.data[self.current_index])
+        self._update_frame_indicator()
+        if self.last_shifts is not None:
+            dy, dx = self.last_shifts[self.current_index]
+            self.lbl_last_shift.setText(f"dy={dy:.3f}, dx={dx:.3f}")
+        else:
+            self.lbl_last_shift.setText("-")
+
+    def _update_frame_indicator(self) -> None:
+        if self.stack is None or self.stack.n_images <= 0:
+            self.lbl_frame_current.setText("Frame 0 / 0")
+            return
+        self.lbl_frame_current.setText(
+            f"Frame {self.current_index} / {self.stack.n_images - 1}"
+        )
+
+    def _current_roi_or_none(self):
+        if self.chk_roi.isChecked():
+            return self.viewer.get_roi_bounds()
+        return None
+
+    def _set_controls_enabled(self, enabled: bool) -> None:
+        for widget in (
+            self.btn_load,
+            self.btn_prev,
+            self.btn_next,
+            self.btn_align,
+            self.btn_average_roi,
+            self.btn_average_full,
+            self.btn_export_view,
+            self.spin_frame,
+            self.frame_slider,
+            self.spin_reference,
+            self.spin_upsample,
+            self.chk_roi,
+            self.chk_crosshair,
+        ):
+            widget.setEnabled(enabled)
+
+    def run_alignment_threaded(self) -> None:
+        if self.stack is None:
+            return
+
+        if self._alignment_running:
+            QMessageBox.information(self, "Alignment running", "An alignment job is already running.")
+            return
+
+        self._alignment_running = True
+        self._set_controls_enabled(False)
+        self.progress_align.setValue(0)
+        self.progress_align.setFormat("Aligning... %p%")
+
+        reference_index = int(self.spin_reference.value())
+        roi = self._current_roi_or_none()
+        upsample_factor = int(self.spin_upsample.value())
+
+        self._alignment_worker = AlignmentWorker(
+            stack=self.stack.data,
+            reference_index=reference_index,
+            roi=roi,
+            upsample_factor=upsample_factor,
+        )
+        self._alignment_thread = create_alignment_thread(self._alignment_worker)
+
+        self._alignment_worker.progress.connect(self._on_alignment_progress)
+        self._alignment_worker.finished.connect(self._on_alignment_finished)
+        self._alignment_worker.failed.connect(self._on_alignment_failed)
+
+        self._alignment_worker.finished.connect(self._cleanup_alignment_thread)
+        self._alignment_worker.failed.connect(self._cleanup_alignment_thread)
+        self._alignment_thread.finished.connect(self._alignment_thread.deleteLater)
+
+        self._alignment_thread.start()
+        self.statusBar().showMessage("Alignment started in background thread")
+
+    def _on_alignment_progress(self, done: int, total: int) -> None:
+        if total <= 0:
+            self.progress_align.setValue(0)
+            return
+        percent = int(round(100 * done / total))
+        self.progress_align.setValue(percent)
+        self.statusBar().showMessage(f"Alignment progress: {done}/{total}")
+
+    def _on_alignment_finished(self, aligned_data, shifts) -> None:
+        assert self.stack is not None
+
+        self.stack = ImageStack(
+            data=np.asarray(aligned_data),
+            name=f"{self.stack.name} [aligned]",
+            source_path=self.stack.source_path,
+        )
+        self.last_shifts = np.asarray(shifts)
+        self._alignment_running = False
+        self._set_controls_enabled(True)
+        self.progress_align.setValue(100)
+        self.progress_align.setFormat("Done")
+
+        self.spin_frame.blockSignals(True)
+        self.frame_slider.blockSignals(True)
+        self.spin_frame.setMaximum(self.stack.n_images - 1)
+        self.frame_slider.setMaximum(self.stack.n_images - 1)
+        self.spin_frame.blockSignals(False)
+        self.frame_slider.blockSignals(False)
+        self.lbl_frame_max.setText(str(max(0, self.stack.n_images - 1)))
+
+        self._update_display()
+        self.statusBar().showMessage(f"Alignment finished for {self.stack.n_images} frames")
+
+    def _on_alignment_failed(self, message: str) -> None:
+        self._alignment_running = False
+        self._set_controls_enabled(True)
+        self.progress_align.setValue(0)
+        self.progress_align.setFormat("Failed")
+        QMessageBox.critical(self, "Alignment error", message)
+
+    def _cleanup_alignment_thread(self, *_) -> None:
+        if self._alignment_thread is not None:
+            self._alignment_thread.quit()
+            self._alignment_thread.wait()
+            self._alignment_thread = None
+        self._alignment_worker = None
+
+    def show_average_roi(self) -> None:
+        if self.stack is None:
+            return
+        roi = self._current_roi_or_none()
+        if roi is None:
+            QMessageBox.information(self, "ROI required", "Enable the ROI first.")
+            return
+
+        try:
+            avg = average_stack_in_roi(self.stack.data, roi)
+        except Exception as exc:
+            QMessageBox.critical(self, "ROI average error", str(exc))
+            return
+
+        self.viewer.set_image(avg)
+        self.statusBar().showMessage("Showing ROI average over the current stack")
+
+    def show_average_full(self) -> None:
+        if self.stack is None:
+            return
+        avg = average_stack(self.stack.data)
+        self.viewer.set_image(avg)
+        self.statusBar().showMessage("Showing full-stack average")
+
+    def export_current_view(self) -> None:
+        if self.viewer.current_image is None:
+            return
+
+        path, _ = QFileDialog.getSaveFileName(
+            self,
+            "Export current view as TIFF",
+            str(Path.home() / "pyAthina_export.tif"),
+            "TIFF (*.tif *.tiff)",
+        )
+        if not path:
+            return
+
+        try:
+            save_image_tiff(path, self.viewer.current_image)
+            self.statusBar().showMessage(f"Saved TIFF: {path}")
+        except Exception as exc:
+            QMessageBox.critical(self, "Export error", str(exc))
+
+    def on_mouse_moved(self, x: float, y: float, value: float) -> None:
+        self.lbl_mouse.setText(f"x={x:.1f}, y={y:.1f}")
+        self.lbl_value.setText("nan" if np.isnan(value) else f"{value:.5g}")
+
+    def on_left_clicked(self, x: float, y: float) -> None:
+        self.statusBar().showMessage(f"Left click at x={x:.1f}, y={y:.1f}")
+
+    def on_right_clicked(self, x: float, y: float) -> None:
+        self.statusBar().showMessage(f"Right click at x={x:.1f}, y={y:.1f}")
+
+    def on_double_clicked(self, x: float, y: float) -> None:
+        self.statusBar().showMessage(f"Double click at x={x:.1f}, y={y:.1f}")
+
+    def on_roi_changed(self, x: float, y: float, w: float, h: float) -> None:
+        self.lbl_roi.setText(f"x={x:.0f}, y={y:.0f}, w={w:.0f}, h={h:.0f}")
+
+    def on_crosshair_moved(self, x: float, y: float) -> None:
+        self.lbl_crosshair.setText(f"x={x:.1f}, y={y:.1f}")
+
+    def on_frame_changed(self, index: int) -> None:
+        self.statusBar().showMessage(f"Frame changed to {index}")
+
+    def on_stack_loaded(self, name: str, n: int, ny: int, nx: int) -> None:
+        self.lbl_stack.setText(name)
+        self.lbl_shape.setText(f"{n} × {ny} × {nx}")
+        self.statusBar().showMessage(f"Loaded stack: {name}")

pyathina-0.0.1/src/pyAthina/io.py

@@ -0,0 +1,88 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import List
+
+import h5py
+import numpy as np
+import tifffile
+
+from pyAthina.models import ImageStack
+
+
+_SUPPORTED_STACK_EXTENSIONS = {".npy", ".h5", ".hdf5", ".hdf"}
+
+
+def _is_numeric_3d_dataset(obj) -> bool:
+    return (
+        isinstance(obj, h5py.Dataset)
+        and obj.ndim == 3
+        and np.issubdtype(obj.dtype, np.number)
+    )
+
+
+def list_h5_3d_datasets(path: str | Path) -> List[str]:
+    """Return all numeric 3D dataset paths found in an HDF5 file."""
+    path = Path(path)
+    dataset_paths: List[str] = []
+    with h5py.File(path, "r") as h5:
+        def visitor(name, obj):
+            if _is_numeric_3d_dataset(obj):
+                dataset_paths.append(f"/{name}")
+
+        h5.visititems(visitor)
+    return dataset_paths
+
+
+def choose_h5_dataset(path: str | Path) -> str:
+    """Pick the largest numeric 3D dataset in the file."""
+    candidates = list_h5_3d_datasets(path)
+    if not candidates:
+        raise ValueError("No numeric 3D datasets were found in this HDF5 file")
+    if len(candidates) == 1:
+        return candidates[0]
+
+    with h5py.File(path, "r") as h5:
+        sizes = {name: int(np.prod(h5[name].shape)) for name in candidates}
+
+    return max(candidates, key=lambda name: sizes[name])
+
+
+def load_stack_from_h5(
+    path: str | Path,
+    dataset_path: str | None = None,
+    dtype=np.float32,
+) -> ImageStack:
+    path = Path(path)
+    chosen_dataset = dataset_path or choose_h5_dataset(path)
+
+    with h5py.File(path, "r") as h5:
+        data = np.asarray(h5[chosen_dataset], dtype=dtype)
+
+    return ImageStack(data=data, name=f"{path.name}:{chosen_dataset}", source_path=str(path))
+
+
+def load_stack_from_npy(path: str | Path, dtype=np.float32) -> ImageStack:
+    path = Path(path)
+    data = np.asarray(np.load(path), dtype=dtype)
+    return ImageStack(data=data, name=path.name, source_path=str(path))
+
+
+def load_stack_auto(path: str | Path, dataset_path: str | None = None, dtype=np.float32) -> ImageStack:
+    path = Path(path)
+    suffix = path.suffix.lower()
+
+    if suffix not in _SUPPORTED_STACK_EXTENSIONS:
+        raise ValueError(f"Unsupported file type: {suffix}")
+
+    if suffix == ".npy":
+        return load_stack_from_npy(path, dtype=dtype)
+    return load_stack_from_h5(path, dataset_path=dataset_path, dtype=dtype)
+
+
+def save_image_tiff(path: str | Path, image: np.ndarray) -> None:
+    tifffile.imwrite(str(path), np.asarray(image))
+
+
+def save_stack_tiff(path: str | Path, stack: np.ndarray) -> None:
+    tifffile.imwrite(str(path), np.asarray(stack))

pyathina-0.0.1/src/pyAthina/main.py

@@ -0,0 +1,28 @@
+import sys
+from pathlib import Path
+
+# Allow both:
+#   python -m pyAthina.main
+# and, if the user is inside the pyAthina package directory:
+#   python main.py
+package_dir = Path(__file__).resolve().parent
+project_root = package_dir.parent
+if str(project_root) not in sys.path:
+    sys.path.insert(0, str(project_root))
+
+import pyqtgraph as pg
+from PyQt6.QtWidgets import QApplication
+
+from pyAthina.app import MainWindow
+
+
+def main() -> None:
+    pg.setConfigOptions(imageAxisOrder="row-major")
+    app = QApplication(sys.argv)
+    win = MainWindow()
+    win.show()
+    sys.exit(app.exec())
+
+
+if __name__ == "__main__":
+    main()

pyathina-0.0.1/src/pyAthina/models.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Tuple
+
+import numpy as np
+
+
+@dataclass
+class ImageStack:
+    """Container for a 3D image stack with shape (n_images, ny, nx)."""
+
+    data: np.ndarray
+    name: str = "Untitled"
+    source_path: str | None = None
+
+    def __post_init__(self) -> None:
+        if self.data.ndim != 3:
+            raise ValueError("ImageStack.data must have shape (n_images, ny, nx)")
+        if not np.issubdtype(self.data.dtype, np.number):
+            raise TypeError("ImageStack.data must be numeric")
+
+    @property
+    def n_images(self) -> int:
+        return int(self.data.shape[0])
+
+    @property
+    def shape2d(self) -> Tuple[int, int]:
+        return int(self.data.shape[1]), int(self.data.shape[2])
+
+    @classmethod
+    def dummy(cls, n: int = 20, ny: int = 512, nx: int = 512) -> "ImageStack":
+        rng = np.random.default_rng(42)
+        x = np.linspace(-1, 1, nx)
+        y = np.linspace(-1, 1, ny)
+        xx, yy = np.meshgrid(x, y)
+
+        stack = []
+        for i in range(n):
+            shift_x = 0.15 * np.sin(i / 4)
+            shift_y = 0.10 * np.cos(i / 5)
+            img = np.exp(-(((xx - shift_x) * 2.5) ** 2 + ((yy - shift_y) * 2.5) ** 2))
+            img += 0.25 * np.exp(-(((xx + 0.35) * 7) ** 2 + ((yy - 0.2) * 7) ** 2))
+            img += 0.03 * rng.standard_normal((ny, nx))
+            stack.append(img.astype(np.float32))
+
+        return cls(np.stack(stack, axis=0), name="Dummy stack")

pyathina-0.0.1/src/pyAthina/processing.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from typing import Callable, Optional, Sequence, Tuple
+
+import numpy as np
+from scipy.ndimage import shift as nd_shift
+from skimage.registration import phase_cross_correlation
+
+
+ROI = Tuple[int, int, int, int]
+
+
+def clip_roi_to_shape(roi: ROI, shape: Sequence[int]) -> ROI:
+    """Clip an ROI (x, y, w, h) to image bounds."""
+    x, y, w, h = roi
+    ny, nx = int(shape[0]), int(shape[1])
+
+    x0 = max(0, min(int(x), nx))
+    y0 = max(0, min(int(y), ny))
+    x1 = max(x0, min(int(x + w), nx))
+    y1 = max(y0, min(int(y + h), ny))
+
+    return x0, y0, x1 - x0, y1 - y0
+
+
+def crop_to_roi(image: np.ndarray, roi: Optional[ROI]) -> np.ndarray:
+    if roi is None:
+        return image
+    x, y, w, h = clip_roi_to_shape(roi, image.shape)
+    if w <= 0 or h <= 0:
+        raise ValueError("ROI is empty after clipping to the image bounds")
+    return image[y:y + h, x:x + w]
+
+
+def bin_image(image: np.ndarray, bin_y: int, bin_x: Optional[int] = None) -> np.ndarray:
+    if bin_x is None:
+        bin_x = bin_y
+    if bin_y <= 0 or bin_x <= 0:
+        raise ValueError("Binning factors must be positive integers")
+
+    ny, nx = image.shape
+    ny2 = (ny // bin_y) * bin_y
+    nx2 = (nx // bin_x) * bin_x
+    cropped = image[:ny2, :nx2]
+    return cropped.reshape(ny2 // bin_y, bin_y, nx2 // bin_x, bin_x).mean(axis=(1, 3))
+
+
+def bin_stack(stack: np.ndarray, bin_y: int, bin_x: Optional[int] = None) -> np.ndarray:
+    return np.stack([bin_image(img, bin_y, bin_x) for img in stack], axis=0)
+
+
+def estimate_shift_phase_correlation(
+    reference: np.ndarray,
+    moving: np.ndarray,
+    roi: Optional[ROI] = None,
+    upsample_factor: int = 10,
+) -> Tuple[Tuple[float, float], float, float]:
+    ref = crop_to_roi(reference, roi)
+    mov = crop_to_roi(moving, roi)
+
+    shift_yx, error, phasediff = phase_cross_correlation(
+        ref,
+        mov,
+        upsample_factor=max(1, int(upsample_factor)),
+    )
+
+    dy, dx = float(shift_yx[0]), float(shift_yx[1])
+    return (dy, dx), float(error), float(phasediff)
+
+
+def apply_shift(
+    image: np.ndarray,
+    shift_yx: Tuple[float, float],
+    order: int = 1,
+    mode: str = "nearest",
+    cval: float = 0.0,
+) -> np.ndarray:
+    shifted = nd_shift(
+        image,
+        shift=shift_yx,
+        order=order,
+        mode=mode,
+        cval=cval,
+        prefilter=(order > 1),
+    )
+    return np.asarray(shifted, dtype=image.dtype)
+
+
+def align_stack_to_reference(
+    stack: np.ndarray,
+    reference_index: int = 0,
+    roi: Optional[ROI] = None,
+    upsample_factor: int = 10,
+    interpolation_order: int = 1,
+    mode: str = "nearest",
+    cval: float = 0.0,
+    progress_callback: Optional[Callable[[int, int], None]] = None,
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Align each image in a stack to a single reference image."""
+    if stack.ndim != 3:
+        raise ValueError("stack must have shape (n_images, ny, nx)")
+
+    n_images = stack.shape[0]
+    if not (0 <= reference_index < n_images):
+        raise ValueError("reference_index is out of range")
+
+    reference = stack[reference_index]
+    aligned = np.empty_like(stack)
+    shifts = np.zeros((n_images, 2), dtype=np.float64)
+
+    for i in range(n_images):
+        if i == reference_index:
+            aligned[i] = stack[i]
+            if progress_callback is not None:
+                progress_callback(i + 1, n_images)
+            continue
+
+        shift_yx, _, _ = estimate_shift_phase_correlation(
+            reference,
+            stack[i],
+            roi=roi,
+            upsample_factor=upsample_factor,
+        )
+        shifts[i] = shift_yx
+        aligned[i] = apply_shift(
+            stack[i],
+            shift_yx,
+            order=interpolation_order,
+            mode=mode,
+            cval=cval,
+        )
+
+        if progress_callback is not None:
+            progress_callback(i + 1, n_images)
+
+    return aligned, shifts
+
+
+def average_stack(stack: np.ndarray) -> np.ndarray:
+    if stack.ndim != 3:
+        raise ValueError("stack must have shape (n_images, ny, nx)")
+    return np.mean(stack, axis=0)
+
+
+def average_stack_in_roi(stack: np.ndarray, roi: ROI) -> np.ndarray:
+    cropped = crop_to_roi(stack[0], roi)
+    x, y, w, h = clip_roi_to_shape(roi, stack.shape[1:])
+    if cropped.size == 0:
+        raise ValueError("ROI is empty")
+    return np.mean(stack[:, y:y + h, x:x + w], axis=0)

pyathina-0.0.1/src/pyAthina/signals.py

@@ -0,0 +1,12 @@
+from PyQt6.QtCore import QObject, pyqtSignal
+
+
+class PEEMSignals(QObject):
+    mouse_moved = pyqtSignal(float, float, float)  # x, y, value
+    left_clicked = pyqtSignal(float, float)
+    right_clicked = pyqtSignal(float, float)
+    double_clicked = pyqtSignal(float, float)
+    roi_changed = pyqtSignal(float, float, float, float)  # x, y, w, h
+    crosshair_moved = pyqtSignal(float, float)
+    frame_changed = pyqtSignal(int)
+    stack_loaded = pyqtSignal(str, int, int, int)  # name, n, ny, nx

pyathina-0.0.1/src/pyAthina/viewer.py

@@ -0,0 +1,115 @@
+from __future__ import annotations
+
+from typing import Tuple
+
+import numpy as np
+import pyqtgraph as pg
+from PyQt6.QtCore import Qt
+
+
+class PEEMImageView(pg.GraphicsLayoutWidget):
+    """Central image viewer with histogram, ROI and crosshair overlays."""
+
+    def __init__(self, signals, parent=None):
+        super().__init__(parent)
+        self.signals = signals
+
+        self.plot = self.addPlot()
+        self.plot.setAspectLocked(True)
+        self.plot.invertY(True)
+        self.plot.setLabel("left", "y")
+        self.plot.setLabel("bottom", "x")
+
+        self.image_item = pg.ImageItem()
+        self.plot.addItem(self.image_item)
+
+        self.hist = pg.HistogramLUTItem()
+        self.hist.setImageItem(self.image_item)
+        self.addItem(self.hist)
+
+        self.roi = pg.ROI([50, 50], [120, 120], movable=True, resizable=True, rotatable=False)
+        self.roi.addScaleHandle([1, 1], [0, 0])
+        self.roi.addScaleHandle([0, 0], [1, 1])
+        self.plot.addItem(self.roi)
+        self.roi.hide()
+        self.roi.sigRegionChanged.connect(self._emit_roi_changed)
+
+        self.vline = pg.InfiniteLine(angle=90, movable=True, pen=pg.mkPen(width=1))
+        self.hline = pg.InfiniteLine(angle=0, movable=True, pen=pg.mkPen(width=1))
+        self.plot.addItem(self.vline)
+        self.plot.addItem(self.hline)
+        self.vline.hide()
+        self.hline.hide()
+        self.vline.sigPositionChanged.connect(self._crosshair_changed)
+        self.hline.sigPositionChanged.connect(self._crosshair_changed)
+
+        self.proxy = pg.SignalProxy(
+            self.plot.scene().sigMouseMoved,
+            rateLimit=60,
+            slot=self._mouse_moved,
+        )
+        self.plot.scene().sigMouseClicked.connect(self._mouse_clicked)
+
+        self.current_image: np.ndarray | None = None
+
+    def set_image(self, image: np.ndarray) -> None:
+        self.current_image = image
+        self.image_item.setImage(image, autoLevels=True)
+
+    def show_roi(self, visible: bool) -> None:
+        self.roi.setVisible(visible)
+        if visible:
+            self._emit_roi_changed()
+
+    def show_crosshair(self, visible: bool) -> None:
+        self.vline.setVisible(visible)
+        self.hline.setVisible(visible)
+        if visible and self.current_image is not None:
+            ny, nx = self.current_image.shape
+            self.vline.setPos(nx / 2)
+            self.hline.setPos(ny / 2)
+            self._crosshair_changed()
+
+    def set_roi(self, x: int, y: int, w: int, h: int) -> None:
+        self.roi.setPos([x, y])
+        self.roi.setSize([w, h])
+        self._emit_roi_changed()
+
+    def get_roi_bounds(self) -> Tuple[int, int, int, int]:
+        pos = self.roi.pos()
+        size = self.roi.size()
+        return int(pos.x()), int(pos.y()), int(size.x()), int(size.y())
+
+    def _emit_roi_changed(self) -> None:
+        x, y, w, h = self.get_roi_bounds()
+        self.signals.roi_changed.emit(x, y, w, h)
+
+    def _crosshair_changed(self) -> None:
+        self.signals.crosshair_moved.emit(float(self.vline.value()), float(self.hline.value()))
+
+    def _mouse_moved(self, evt) -> None:
+        pos = evt[0]
+        vb = self.plot.vb
+        mouse_point = vb.mapSceneToView(pos)
+        x = mouse_point.x()
+        y = mouse_point.y()
+        value = np.nan
+
+        if self.current_image is not None:
+            iy = int(round(y))
+            ix = int(round(x))
+            if 0 <= iy < self.current_image.shape[0] and 0 <= ix < self.current_image.shape[1]:
+                value = float(self.current_image[iy, ix])
+
+        self.signals.mouse_moved.emit(float(x), float(y), value)
+
+    def _mouse_clicked(self, event) -> None:
+        pos = self.plot.vb.mapSceneToView(event.scenePos())
+        x, y = float(pos.x()), float(pos.y())
+
+        if event.double():
+            self.signals.double_clicked.emit(x, y)
+        elif event.button() == Qt.MouseButton.LeftButton:
+            self.signals.left_clicked.emit(x, y)
+        elif event.button() == Qt.MouseButton.RightButton:
+            self.signals.right_clicked.emit(x, y)

pyathina-0.0.1/src/pyAthina/workers.py

@@ -0,0 +1,63 @@
+from __future__ import annotations
+
+from typing import Optional
+
+import numpy as np
+from PyQt6.QtCore import QObject, QThread, pyqtSignal
+
+from pyAthina.processing import ROI, align_stack_to_reference
+
+
+class AlignmentWorker(QObject):
+    """Run drift correction in a worker thread to keep the UI responsive."""
+
+    progress = pyqtSignal(int, int)
+    finished = pyqtSignal(object, object)  # aligned_stack, shifts
+    failed = pyqtSignal(str)
+
+    def __init__(
+        self,
+        stack: np.ndarray,
+        reference_index: int,
+        roi: Optional[ROI],
+        upsample_factor: int,
+        interpolation_order: int = 1,
+        mode: str = "nearest",
+        cval: float = 0.0,
+    ) -> None:
+        super().__init__()
+        self.stack = stack
+        self.reference_index = reference_index
+        self.roi = roi
+        self.upsample_factor = upsample_factor
+        self.interpolation_order = interpolation_order
+        self.mode = mode
+        self.cval = cval
+
+    def run(self) -> None:
+        try:
+            aligned, shifts = align_stack_to_reference(
+                self.stack,
+                reference_index=self.reference_index,
+                roi=self.roi,
+                upsample_factor=self.upsample_factor,
+                interpolation_order=self.interpolation_order,
+                mode=self.mode,
+                cval=self.cval,
+                progress_callback=self._emit_progress,
+            )
+        except Exception as exc:
+            self.failed.emit(str(exc))
+            return
+
+        self.finished.emit(aligned, shifts)
+
+    def _emit_progress(self, done: int, total: int) -> None:
+        self.progress.emit(done, total)
+
+
+def create_alignment_thread(worker: AlignmentWorker) -> QThread:
+    thread = QThread()
+    worker.moveToThread(thread)
+    thread.started.connect(worker.run)
+    return thread

pyathina-0.0.1/src/pyAthina.egg-info/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: pyAthina
+Version: 0.0.1
+Summary: A photoelectron miroscpectroscopy/spectromicroscopy data analyis package
+Author-email: Evangelos Golias <evangelos.golias@gmail.com>
+Project-URL: Homepage, https://gitlab.com/evangelosgolias/athina
+Project-URL: Issues, https://gitlab.com/evangelosgolias/athina/-/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# pyAthina
+
+A lightweight PyQt6 + pyqtgraph skeleton for PEEM-style image-stack workflows.
+
+## Install
+
+```bash
+pip install -r requirements.txt
+```
+
+## Run
+
+Any of these should work from the extracted project folder:
+
+```bash
+python -m pyAthina.main
+```
+
+```bash
+python -m pyAthina
+```
+
+```bash
+python run_pyAthina.py
+```
+
+If you `cd` into the `pyAthina/` subfolder itself, you can also run:
+
+```bash
+python main.py
+```

pyathina-0.0.1/src/pyAthina.egg-info/SOURCES.txt

@@ -0,0 +1,18 @@
+LICENSE
+README.md
+pyproject.toml
+src/run_pyAthina.py
+src/pyAthina/__init__.py
+src/pyAthina/__main__.py
+src/pyAthina/app.py
+src/pyAthina/io.py
+src/pyAthina/main.py
+src/pyAthina/models.py
+src/pyAthina/processing.py
+src/pyAthina/signals.py
+src/pyAthina/viewer.py
+src/pyAthina/workers.py
+src/pyAthina.egg-info/PKG-INFO
+src/pyAthina.egg-info/SOURCES.txt
+src/pyAthina.egg-info/dependency_links.txt
+src/pyAthina.egg-info/top_level.txt

pyathina-0.0.1/src/pyAthina.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pyathina-0.0.1/src/pyAthina.egg-info/top_level.txt

@@ -0,0 +1,2 @@
+pyAthina
+run_pyAthina

pyathina-0.0.1/src/run_pyAthina.py

@@ -0,0 +1,4 @@
+from pyAthina.main import main
+
+if __name__ == "__main__":
+    main()