AMS-BP 0.3.1__py3-none-any.whl → 0.4.0__py3-none-any.whl

AMS_BP/gui/widgets/output_config_widget.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+
+from PyQt6.QtWidgets import (
+    QFormLayout,
+    QLineEdit,
+    QSpinBox,
+    QWidget,
+)
+
+
+class OutputConfigWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        layout = QFormLayout()
+
+        self.output_path = QLineEdit()
+        self.output_path.setPlaceholderText("e.g., ./results/")
+        layout.addRow("Output Path:", self.output_path)
+
+        self.output_name = QLineEdit()
+        self.output_name.setPlaceholderText("e.g., simulation_output")
+        layout.addRow("Output Name:", self.output_name)
+
+        self.subsegment_type = QLineEdit()
+        self.subsegment_type.setPlaceholderText("Not implemented")
+        self.subsegment_type.setDisabled(True)
+        layout.addRow("Subsegment Type:", self.subsegment_type)
+
+        self.subsegment_number = QSpinBox()
+        self.subsegment_number.setMinimum(0)
+        self.subsegment_number.setMaximum(999)
+        self.subsegment_number.setDisabled(True)
+        layout.addRow("Subsegment Number:", self.subsegment_number)
+
+        self.setLayout(layout)
+
+    def is_valid(self):
+        return bool(self.output_path.text().strip()) and bool(
+            self.output_name.text().strip()
+        )
+
+    def get_data(self):
+        return {
+            "output_path": self.output_path.text(),
+            "output_name": self.output_name.text(),
+            "subsegment_type": self.subsegment_type.text(),  # Optional, disabled for now
+            "subsegment_number": self.subsegment_number.value(),  # Optional, disabled for now
+        }
+
+    def set_data(self, data: dict):
+        if "output_path" in data:
+            self.output_path.setText(data["output_path"])
+        if "output_name" in data:
+            self.output_name.setText(data["output_name"])
+        if "subsegment_type" in data:
+            self.subsegment_type.setText(data["subsegment_type"])
+        if "subsegment_number" in data:
+            self.subsegment_number.setValue(data["subsegment_number"])
+
+    def get_help_path(self) -> Path:
+        return Path(__file__).parent.parent / "help_docs" / "output_help.md"

AMS_BP/gui/widgets/psf_config_widget.py

@@ -0,0 +1,128 @@
+from pathlib import Path
+
+from pydantic import ValidationError
+from PyQt6.QtCore import pyqtSignal
+from PyQt6.QtWidgets import (
+    QCheckBox,
+    QComboBox,
+    QDoubleSpinBox,
+    QFormLayout,
+    QGroupBox,
+    QLabel,
+    QLineEdit,
+    QMessageBox,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class PSFConfigWidget(QWidget):
+    confocal_mode_changed = pyqtSignal(bool)
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+
+        layout = QVBoxLayout(self)
+
+        # PSF Type Group
+        self.psf_group = QGroupBox("Point Spread Function (PSF)")
+        psf_form = QFormLayout()
+
+        self.psf_type = QComboBox()
+        self.psf_type.addItems(["gaussian"])  # Future-proofing
+        psf_form.addRow("Type:", self.psf_type)
+
+        self.custom_path = QLineEdit()
+        self.custom_path.setPlaceholderText("Path to custom PSF (not supported)")
+        self.custom_path.setEnabled(False)
+        psf_form.addRow("Custom Path:", self.custom_path)
+
+        # Confocal toggle
+        self.confocal_checkbox = QCheckBox("Confocal (Enable pinhole)")
+        self.confocal_checkbox.toggled.connect(self.toggle_pinhole_visibility)
+        self.confocal_checkbox.toggled.connect(self._on_confocal_toggled)
+        psf_form.addRow(self.confocal_checkbox)
+
+        # PSF Parameters
+        self.numerical_aperture = QDoubleSpinBox()
+        self.numerical_aperture.setRange(0.1, 1.5)
+        self.numerical_aperture.setSingleStep(0.01)
+        psf_form.addRow("Numerical Aperture:", self.numerical_aperture)
+
+        self.refractive_index = QDoubleSpinBox()
+        self.refractive_index.setRange(1.0, 2.0)
+        self.refractive_index.setValue(1.0)
+        self.refractive_index.setSingleStep(0.01)
+        psf_form.addRow("Refractive Index:", self.refractive_index)
+
+        self.pinhole_diameter = QDoubleSpinBox()
+        self.pinhole_diameter.setRange(0.1, 100.0)
+        self.pinhole_diameter.setSuffix(" μm")
+        self.pinhole_diameter.setSingleStep(0.1)
+        self.pinhole_diameter.setVisible(False)  # Initially hidden
+        self.pinhole_label = QLabel("Pinhole Diameter:")
+        self.pinhole_label.setVisible(False)
+        psf_form.addRow(self.pinhole_label, self.pinhole_diameter)
+
+        self.psf_group.setLayout(psf_form)
+        layout.addWidget(self.psf_group)
+
+    def _on_confocal_toggled(self, enabled: bool):
+        self.toggle_pinhole_visibility(enabled)
+        self.confocal_mode_changed.emit(enabled)
+
+    def toggle_pinhole_visibility(self, enabled: bool):
+        self.pinhole_diameter.setVisible(enabled)
+        self.pinhole_label.setVisible(enabled)
+
+    def get_data(self):
+        """Return current PSF config as a dict."""
+        return_dict = {
+            "type": self.psf_type.currentText(),
+            "custom_path": self.custom_path.text(),
+            "parameters": {
+                "numerical_aperture": self.numerical_aperture.value(),
+                "refractive_index": self.refractive_index.value(),
+            },
+        }
+
+        if self.confocal_checkbox.isChecked():
+            return_dict["parameters"]["pinhole_diameter"] = (
+                self.pinhole_diameter.value()
+            )
+
+        return return_dict
+
+    def set_data(self, data):
+        """Populate fields from a given PSF config dict."""
+        self.psf_type.setCurrentText(data.get("type", "gaussian"))
+        self.custom_path.setText(data.get("custom_path", ""))
+
+        params = data.get("parameters", {})
+        self.numerical_aperture.setValue(params.get("numerical_aperture", 1.0))
+        self.refractive_index.setValue(params.get("refractive_index", 1.0))
+
+        pinhole = params.get("pinhole_diameter", None)
+        if pinhole is not None:
+            self.confocal_checkbox.setChecked(True)
+            self.pinhole_diameter.setValue(pinhole)
+        else:
+            self.confocal_checkbox.setChecked(False)
+
+    def validate(self) -> bool:
+        try:
+            data = self.get_data()
+            # validated = PSFParameters(**data["parameters"])
+            QMessageBox.information(
+                self, "Validation Successful", "PSF parameters are valid."
+            )
+            return True
+        except ValidationError as e:
+            QMessageBox.critical(self, "Validation Error", str(e))
+            return False
+        except ValueError as e:
+            QMessageBox.critical(self, "Validation Error", str(e))
+            return False
+
+    def get_help_path(self) -> Path:
+        return Path(__file__).parent.parent / "help_docs" / "psf_help.md"

AMS_BP/gui/widgets/utility_widgets/scinotation_widget.py

@@ -0,0 +1,21 @@
+from typing import Optional
+
+from PyQt6.QtGui import QDoubleValidator
+from PyQt6.QtWidgets import (
+    QLineEdit,
+)
+
+
+def scientific_input_field(
+    minimum: float = -1e100,
+    maximum: float = 1e100,
+    default: Optional[float] = None,
+    decimals: int = 10,
+) -> QLineEdit:
+    line = QLineEdit()
+    validator = QDoubleValidator(minimum, maximum, decimals)
+    validator.setNotation(QDoubleValidator.Notation.ScientificNotation)
+    line.setValidator(validator)
+    if default is not None:
+        line.setText(f"{default:.3e}")
+    return line

AMS_BP/gui/widgets/utility_widgets/spectrum_widget.py

@@ -0,0 +1,115 @@
+# spectrum_editor.py
+from matplotlib.backends.backend_qtagg import FigureCanvasQTAgg as FigureCanvas
+from matplotlib.figure import Figure
+from PyQt6.QtWidgets import (
+    QDialog,
+    QDialogButtonBox,
+    QHBoxLayout,
+    QMessageBox,
+    QPushButton,
+    QTableWidget,
+    QTableWidgetItem,
+    QVBoxLayout,
+)
+
+
+class SpectrumEditorDialog(QDialog):
+    def __init__(
+        self,
+        parent=None,
+        wavelengths=None,
+        intensities=None,
+        intensity_name="Intensity",
+    ):
+        super().__init__(parent)
+        self.setWindowTitle("Edit Spectrum")
+        self.resize(600, 400)
+        self.wavelengths = wavelengths or []
+        self.intensities = intensities or []
+        self.intensity_name = intensity_name
+
+        self.setup_ui()
+        self.populate_table()
+        self.update_plot()
+
+    def setup_ui(self):
+        layout = QVBoxLayout(self)
+
+        self.table = QTableWidget(0, 2)
+        self.table.setHorizontalHeaderLabels(["Wavelength (nm)", self.intensity_name])
+        self.table.cellChanged.connect(self.update_plot)
+        layout.addWidget(self.table)
+
+        btns = QHBoxLayout()
+        add_btn = QPushButton("Add Row")
+        remove_btn = QPushButton("Remove Selected")
+        btns.addWidget(add_btn)
+        btns.addWidget(remove_btn)
+        layout.addLayout(btns)
+
+        add_btn.clicked.connect(self.add_row)
+        remove_btn.clicked.connect(self.remove_selected_row)
+
+        # Spectrum preview
+        self.figure = Figure(figsize=(4, 2))
+        self.canvas = FigureCanvas(self.figure)
+        layout.addWidget(self.canvas)
+
+        # OK / Cancel
+        buttons = QDialogButtonBox(
+            QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel
+        )
+        buttons.accepted.connect(self.accept)
+        buttons.rejected.connect(self.reject)
+        layout.addWidget(buttons)
+
+    def populate_table(self):
+        for w, i in zip(self.wavelengths, self.intensities):
+            self.add_row(w, i)
+
+    def add_row(self, wavelength="", intensity=""):
+        row = self.table.rowCount()
+        self.table.insertRow(row)
+        self.table.setItem(row, 0, QTableWidgetItem(str(wavelength)))
+        self.table.setItem(row, 1, QTableWidgetItem(str(intensity)))
+
+    def remove_selected_row(self):
+        row = self.table.currentRow()
+        if row >= 0:
+            self.table.removeRow(row)
+            self.update_plot()
+
+    def get_spectrum(self):
+        wavelengths = []
+        intensities = []
+        for row in range(self.table.rowCount()):
+            try:
+                w = float(self.table.item(row, 0).text())
+                i = float(self.table.item(row, 1).text())
+                wavelengths.append(w)
+                intensities.append(i)
+            except (ValueError, AttributeError):
+                raise ValueError(f"Invalid entry at row {row + 1}")
+        return wavelengths, intensities
+
+    def update_plot(self):
+        try:
+            wavelengths, intensities = self.get_spectrum()
+        except ValueError:
+            return  # Avoid crashing on invalid input
+
+        self.figure.clear()
+        ax = self.figure.add_subplot(111)
+        ax.plot(wavelengths, intensities, marker="o", linestyle="-", color="blue")
+        ax.set_xlabel("Wavelength (nm)")
+        ax.set_ylabel(self.intensity_name)
+        ax.set_title("Spectrum Preview")
+        ax.grid(True)
+        self.canvas.draw()
+
+    def accept(self):
+        try:
+            self.wavelengths, self.intensities = self.get_spectrum()
+            super().accept()
+        except ValueError as e:
+            QMessageBox.critical(self, "Invalid Data", str(e))

AMS_BP/logging/logutil.py

@@ -0,0 +1,83 @@
+import shutil
+import sys
+
+# logutil.py (continued)
+import time
+from datetime import datetime
+from pathlib import Path
+
+from PyQt6.QtCore import QObject, pyqtSignal
+
+
+def cleanup_old_logs(log_dir: Path, max_age_days: int = 7):
+    """
+    Deletes entire `run_*` directories in `log_dir` if their `sim.log` is older than `max_age_days`.
+    """
+    if not log_dir.exists():
+        return
+
+    now = time.time()
+    max_age = max_age_days * 86400  # seconds in a day
+
+    for run_dir in log_dir.iterdir():
+        if run_dir.is_dir() and run_dir.name.startswith("run_"):
+            log_file = run_dir / "sim.log"
+            try:
+                if log_file.exists():
+                    file_age = now - log_file.stat().st_mtime
+                    if file_age > max_age:
+                        shutil.rmtree(run_dir)
+                        print(f"Deleted old run directory: {run_dir}")
+            except Exception as e:
+                print(f"Error while trying to delete {run_dir}: {e}")
+
+
+class LogEmitter(QObject):
+    """Qt signal emitter for log messages."""
+
+    message = pyqtSignal(str)
+
+
+class LoggerStream:
+    """Custom stream that writes to file and emits to GUI."""
+
+    def __init__(self, emitter: LogEmitter, log_file_path: Path):
+        self.emitter = emitter
+        self.log_file_path = log_file_path
+        self.log_file_path.parent.mkdir(parents=True, exist_ok=True)
+        self.file = open(self.log_file_path, "a", encoding="utf-8")
+
+    def write(self, text):
+        if text.strip():
+            timestamped = f"[{datetime.now().strftime('%H:%M:%S')}] {text.strip()}"
+            self.file.write(timestamped + "\n")
+            self.file.flush()
+            self.emitter.message.emit(timestamped)  # <-- This line is essential
+
+    def flush(self):
+        self.file.flush()
+
+    def close(self):
+        self.file.close()
+
+
+class LoggerManager:
+    """Manages stream redirection and GUI+file log capture."""
+
+    def __init__(self, log_path: Path):
+        self.emitter = LogEmitter()
+        self.stream = LoggerStream(self.emitter, log_path)
+        self._stdout = sys.stdout
+        self._stderr = sys.stderr
+
+    def start(self):
+        sys.stdout = self.stream
+        sys.stderr = self.stream
+
+    def stop(self):
+        sys.stdout = self._stdout
+        sys.stderr = self._stderr
+        self.stream.close()
+
+    def get_emitter(self) -> LogEmitter:
+        return self.emitter

AMS_BP/logging/setup_run_directory.py

@@ -0,0 +1,35 @@
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+
+def setup_run_directory(config_path: Path, base_dir: Path = None) -> dict:
+    """
+    Sets up a structured directory for a simulation run.
+
+    Returns a dictionary with paths:
+        {
+            'run_dir': Path,
+            'log_file': Path,
+            'copied_config': Path,
+        }
+    """
+    if base_dir is None:
+        base_dir = Path.home() / "AMS_runs"
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    run_dir = base_dir / f"run_{timestamp}"
+    run_dir.mkdir(parents=True, exist_ok=False)
+
+    # Copy config into run directory
+    copied_config = run_dir / "config.toml"
+    shutil.copy(config_path, copied_config)
+
+    # Define log file path
+    log_file = run_dir / "sim.log"
+
+    return {
+        "run_dir": run_dir,
+        "log_file": log_file,
+        "copied_config": copied_config,
+    }

AMS_BP/{run_cell_simulation.py → main_cli.py}

@@ -1,39 +1,42 @@
 """
-run_cell_simulation.py
+main_cli.py
 
 This file contains the command-line interface (CLI) for the AMS_BP package.
 
 The CLI is built using Typer and provides two main commands:
 1. 'config': Generates a sample configuration file.
 2. 'runsim': Runs the cell simulation using a provided configuration file.
+3. 'gui': starts the PyQT GUI
 
 Main Components:
 - typer_app_asms_bp: The main Typer application object.
 - cell_simulation(): Callback function that displays the version information.
 - generate_config(): Command to generate a sample configuration file.
 - run_cell_simulation(): Command to run the cell simulation using a configuration file.
+- run_gui(): runs the GUI
 
 Usage:
-- To generate a config file: python run_cell_simulation.py config [OPTIONS]
-- To run a simulation: python run_cell_simulation.py runsim [CONFIG_FILE]
+- To generate a config file: python main_cli.py config [OPTIONS]
+- To run a simulation: python main_cli.py runsim [CONFIG_FILE]
 
 The file uses Rich for enhanced console output and progress tracking.
 """
 
-import os
 import shutil
-import time
+import sys
 from pathlib import Path
 from typing import Optional
 
 import rich
 import typer
+from PyQt6.QtWidgets import QApplication
 from rich.progress import Progress, SpinnerColumn, TextColumn
 from typing_extensions import Annotated
 
 from . import __version__
-from .configio.convertconfig import ConfigLoader
-from .configio.saving import save_config_frames
+from .gui.main import MainWindow
+from .logging.logutil import cleanup_old_logs
+from .run_sim_util import run_simulation_from_file
 
 cli_help_doc = str(
     """
@@ -61,10 +64,23 @@ typer_app_asms_bp = typer.Typer(
 def cell_simulation():
     # print version
     # find version using the __version__ variable in the __init__.py file
+    cleanup_old_logs(Path.home() / "AMS_runs", max_age_days=7)
     out_string = f"AMS_BP version: [bold]{__version__}[/bold]"
     rich.print(out_string)
 
 
+@typer_app_asms_bp.command(name="gui")
+def run_gui() -> None:
+    """Start the PyQt GUI"""
+    # Clean old logs
+    log_dir = Path.home() / "AMS_runs"
+    cleanup_old_logs(log_dir, max_age_days=7)
+    app = QApplication(sys.argv)
+    editor = MainWindow()
+    editor.show()
+    sys.exit(app.exec())
+
+
 @typer_app_asms_bp.command(name="config")
 def generate_config(
     output_path: Annotated[
@@ -115,7 +131,9 @@ def generate_config(
         # find the parent dir
         project_directory = Path(__file__).parent
         # find the config file
-        config_file = project_directory / "sim_config.toml"
+        config_file = (
+            project_directory / "resources" / "template_configs" / "sim_config.toml"
+        )
         output_path = output_path / "sim_config.toml"
         # copy the config file to the output path
 
@@ -135,74 +153,11 @@ def generate_config(
         rich.print(f"Config file saved to {output_path.resolve()}")
 
 
-# second command to run the simulation using the config file path as argument
 @typer_app_asms_bp.command(name="runsim")
 def run_cell_simulation(
     config_file: Annotated[Path, typer.Argument(help="Path to the configuration file")],
 ) -> None:
-    """
-    Run the cell simulation using the configuration file provided.
-    """
-    from contextlib import contextmanager
-
-    @contextmanager
-    def progress_context():
-        progress = Progress(
-            SpinnerColumn(),
-            TextColumn("[progress.description]{task.description}"),
-            transient=True,
-        )
-        try:
-            with progress:
-                yield progress
-        finally:
-            progress.stop()
-
-    # Use in functions
-    with progress_context() as progress:
-        start_task_1 = time.time()
-        task_1 = progress.add_task(
-            description="Processing request to run the simulation ...", total=10
-        )
-
-        # check if the config file is a valid file
-        if not os.path.isfile(config_file):
-            rich.print("FileNotFoundError: Configuration file not found.")
-            raise typer.Abort()
-
-        config_inator = ConfigLoader(config_path=config_file)
-        # find the version flag in the config file
-        if "version" in config_inator.config:
-            version = config_inator.config["version"]
-            rich.print(f"Using config version: [bold]{version}[/bold]")
-
-        setup_config = config_inator.setup_microscope()
-        microscope = setup_config["microscope"]
-        configEXP = setup_config["experiment_config"]
-        functionEXP = setup_config["experiment_func"]
-
-        # complete last progress
-        progress.update(task_1, completed=10)
-        rich.print(
-            "Prep work done in {:.2f} seconds.".format(time.time() - start_task_1)
-        )
-
-        time_task_2 = time.time()
-        task_2 = progress.add_task(description="Running the simulation ...", total=None)
-
-        # run the simulation
-
-        frames, metadata = functionEXP(microscope=microscope, config=configEXP)
-
-        # save
-        save_config_frames(
-            metadata, frames, setup_config["base_config"].OutputParameter
-        )
-
-        progress.update(task_2, completed=None)
-        rich.print(
-            "Simulation completed in {:.2f} seconds.".format(time.time() - time_task_2)
-        )
+    run_simulation_from_file(config_file)
 
 
 def validate_config(config: dict) -> None:

AMS_BP/optics/filters/filters.py

@@ -6,6 +6,8 @@ from pydantic import BaseModel, Field, field_validator
 
 CustomNDarray: TypeAlias = NDArray[np.float64]
 
+FILTERS = ["bandpass", "allow_all"]
+
 
 class FilterSpectrum(BaseModel):
     """Represents the spectral characteristics of an optical filter"""

AMS_BP/resources/template_configs/metadata_configs.json

@@ -0,0 +1,20 @@
+{
+  "PAmCherry_EGFP_Widefield_Zstack_Fixed": {
+    "label": "PAmCherry with EGFP (Fixed)",
+    "description": "Two-Color Widefield Microscopy of a RodCell with PAmCherry and EGFP as molecules. Cell is fixed and the experiment protocol is a Z-Stack.",
+    "image": "palm_egfp.png",
+    "config": "twocolor_widefield_zstack_fixed.toml"
+  },
+  "PAmCherry_EGFP_Widefield_Zstack_Live": {
+    "label": "PAmCherry with EGFP (Live)",
+    "description": "Two-Color Widefield Microscopy of a RodCell with PAmCherry and EGFP as molecules. Cell is live (with motion described by bounded FBM models (differently for each molecule) and the experiment protocol is a Z-Stack.",
+    "image": "palm_egfp.png",
+    "config": "twocolor_widefield_zstack_live.toml"
+  },
+  "PAmCherry_EGFP_Widefield_Timeseries_Live": {
+    "label": "PAmCherry with EGFP (Live timeseries)",
+    "description": "Two-Color Widefield Microscopy of a RodCell with PAmCherry and EGFP as molecules. Cell is live (with motion described by bounded FBM models (differently for each molecule) and the experiment protocol is a time-series.",
+    "image": "palm_egfp.png",
+    "config": "twocolor_widefield_timeseries_live.toml"
+  }
+}