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

AMS_BP/gui/help_docs/psf_help.md

@@ -0,0 +1,51 @@
+# Point Spread Function (PSF) Configuration Help
+
+The PSF (Point Spread Function) models how light emitted from a point source is blurred by the microscope optics. This section defines the parameters of the optical model used for image formation.
+
+---
+
+## `type`
+- **Type**: String
+- **Allowed**: `"gaussian"` *(currently the only supported type)*
+- **Description**: Specifies the PSF model. A Gaussian PSF approximates diffraction-limited optics and is sufficient for many simulation scenarios.
+
+---
+
+## `custom_path`
+- **Type**: String
+- **Default**: Empty
+- **Description**: Placeholder for loading a custom PSF file. Currently not supported.
+
+---
+
+## `confocal`
+- **Type**: Boolean
+- **Description**: Enables confocal mode by introducing a pinhole before the detector to reject out-of-focus light. When enabled, additional parameters become relevant (e.g., pinhole diameter).
+
+---
+
+## `parameters`
+
+### `numerical_aperture`
+- **Type**: Float
+- **Typical Range**: 0.1 – 1.5
+- **Description**: The numerical aperture of the objective lens, which affects the resolution and depth of field of the microscope.
+
+### `refractive_index`
+- **Type**: Float
+- **Typical Range**: 1.0 – 2.0
+- **Description**: The refractive index of the imaging medium (e.g., air: 1.0, water: 1.33, immersion oil: ~1.5).
+
+### `pinhole_diameter`
+- **Type**: Float (optional)
+- **Units**: Micrometers (μm)
+- **Visible only when confocal mode is enabled**
+- **Description**: The diameter of the confocal pinhole that restricts the depth of detection, improving axial resolution by eliminating out-of-focus light.
+
+---
+
+## Notes
+
+- Confocal simulation is optional and intended for advanced users modeling high-resolution 3D optical sectioning.
+- You can adjust the `numerical_aperture` and `refractive_index` even in widefield mode to simulate different objective lens setups.
+

AMS_BP/gui/help_window.py

@@ -0,0 +1,26 @@
+from pathlib import Path
+
+from PyQt6.QtWidgets import QDialog, QDialogButtonBox, QTextBrowser, QVBoxLayout
+
+
+class HelpWindow(QDialog):
+    def __init__(self, help_path: Path, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Help")
+        self.resize(500, 400)
+
+        layout = QVBoxLayout()
+        browser = QTextBrowser()
+
+        try:
+            with open(help_path, "r", encoding="utf-8") as f:
+                browser.setMarkdown(f.read())
+        except Exception as e:
+            browser.setPlainText(f"Failed to load help: {e}")
+
+        buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Close)
+        buttons.rejected.connect(self.reject)
+
+        layout.addWidget(browser)
+        layout.addWidget(buttons)
+        self.setLayout(layout)

AMS_BP/gui/logging_window.py

@@ -0,0 +1,93 @@
+from PyQt6.QtCore import Qt, QTimer
+from PyQt6.QtWidgets import (
+    QDialog,
+    QHBoxLayout,
+    QPlainTextEdit,
+    QProgressBar,
+    QPushButton,
+    QVBoxLayout,
+)
+
+
+class LogWindow(QDialog):
+    cancel_requested = False  # Flag to check cancel request
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self.setWindowTitle("Simulation Log")
+        self.setMinimumSize(600, 300)
+
+        self.log_output = QPlainTextEdit()
+        self.log_output.setReadOnly(True)
+
+        # Progress bar (indeterminate)
+        self.progress = QProgressBar()
+        self.progress.setRange(0, 0)  # Infinite/indeterminate animation
+
+        # Cancel button
+        self.cancel_button = QPushButton("Cancel")
+        self.cancel_button.clicked.connect(self.on_cancel_clicked)
+
+        button_layout = QHBoxLayout()
+        button_layout.addStretch()
+        button_layout.addWidget(self.cancel_button)
+
+        layout = QVBoxLayout()
+        layout.addWidget(self.log_output)
+        layout.addWidget(self.progress)
+        layout.addLayout(button_layout)
+
+        self.setLayout(layout)
+
+    def append_text(self, text: str):
+        self.log_output.appendPlainText(text)
+        QTimer.singleShot(0, self.scroll_to_bottom)
+
+    def scroll_to_bottom(self):
+        self.log_output.verticalScrollBar().setValue(
+            self.log_output.verticalScrollBar().maximum()
+        )
+
+    def on_cancel_clicked(self):
+        self.cancel_requested = True
+        self.append_text("Cancellation requested by user...")
+
+    def mark_success(self):
+        self.progress.setRange(0, 1)
+        self.progress.setValue(1)
+        self.progress.setStyleSheet("""
+            QProgressBar {
+                border: 1px solid #555;
+                border-radius: 5px;
+                background-color: #2d2d2d;
+                text-align: center;
+                color: white;
+                font-weight: bold;
+                font-size: 14px;
+            }
+            QProgressBar::chunk {
+                background-color: #4CAF50;
+            }
+        """)
+        self.append_text("Simulation completed successfully.")
+
+    def mark_failure(self):
+        self.progress.setRange(0, 1)
+        self.progress.setValue(0)  # No fill
+        self.progress.setFormat("Failed, share logs with developer.")  # Custom text
+        self.progress.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.progress.setStyleSheet("""
+            QProgressBar {
+                border: 1px solid #800000;
+                border-radius: 5px;
+                background-color: #2d2d2d;
+                color: #e53935;
+                font-weight: bold;
+                font-size: 13px;
+                text-align: center;
+            }
+            QProgressBar::chunk {
+                background-color: transparent;  /* no fill */
+            }
+        """)
+        self.append_text("Simulation failed. Please send logs to the developer.")

AMS_BP/gui/main.py

@@ -0,0 +1,255 @@
+import webbrowser
+from pathlib import Path
+from zipfile import ZipFile
+
+import napari
+import tifffile
+from PyQt6.QtCore import Qt, QThread
+from PyQt6.QtGui import QPainter, QPixmap
+from PyQt6.QtSvg import QSvgRenderer
+from PyQt6.QtWidgets import (
+    QFileDialog,
+    QLabel,
+    QMainWindow,
+    QMessageBox,
+    QPushButton,
+    QVBoxLayout,
+    QWidget,
+)
+
+from ..logging.logutil import LoggerManager
+from ..logging.setup_run_directory import setup_run_directory
+from .logging_window import LogWindow
+from .sim_worker import SimulationWorker
+from .template_window_selection import TemplateSelectionWindow
+
+LOGO_PATH = str(Path(__file__).parent / "assets" / "drawing.svg")
+
+
+class MainWindow(QMainWindow):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Welcome to AMS!")
+
+        # Set up the main layout
+        layout = QVBoxLayout()
+
+        # Add logo as a placeholder (SVG format)
+        self.logo_label = QLabel()  # Label to hold the logo
+        self.set_svg_logo(LOGO_PATH)  # Set the SVG logo
+        layout.addWidget(self.logo_label, alignment=Qt.AlignmentFlag.AlignCenter)
+
+        # Add the maintainer's name under the image
+        self.maintainer_label = QLabel(
+            "Maintainer: Baljyot Parmar \n baljyotparmar@hotmail.com"
+        )
+        self.maintainer_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        layout.addWidget(self.maintainer_label)
+        self.lab_label = QLabel(
+            "Brought to you by: " + '<a href="https://weberlab.ca">The WeberLab</a>'
+        )
+        self.lab_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+        self.lab_label.setOpenExternalLinks(True)  # Enable external links
+        self.lab_label.linkActivated.connect(self.on_link_activated)
+        layout.addWidget(self.lab_label)
+
+        # Button to open the Configuration Creation window
+        self.config_button = QPushButton("Create Configuration File")
+        self.config_button.clicked.connect(self.open_config_editor)
+        layout.addWidget(self.config_button)
+
+        # Create a central widget and set the layout
+        central_widget = QWidget()
+        central_widget.setLayout(layout)
+        self.setCentralWidget(central_widget)
+
+        # Button to run simulation with a TOML config file
+        self.run_sim_button = QPushButton("Run Simulation from Config")
+        self.run_sim_button.clicked.connect(self.run_simulation_from_config)
+        layout.addWidget(self.run_sim_button)
+
+        # Button to open Napari viewer
+        self.view_button = QPushButton("Visualize Microscopy Data (Napari)")
+        self.view_button.clicked.connect(self.open_napari_viewer)
+        layout.addWidget(self.view_button)
+
+        self.package_logs_button = QPushButton("Package Logs for Sharing")
+        self.package_logs_button.clicked.connect(self.package_logs)
+        layout.addWidget(self.package_logs_button)
+
+    def package_logs(self):
+        log_dir = Path.home() / "AMS_runs"
+
+        # Step 1: Open dialog to select folders
+        folder_paths = QFileDialog.getExistingDirectory(
+            self,
+            "Select Folder Containing Run Logs",
+            str(log_dir),
+            QFileDialog.Option.ShowDirsOnly | QFileDialog.Option.DontResolveSymlinks,
+        )
+
+        if not folder_paths:
+            return
+
+        # QFileDialog.getExistingDirectory() returns a single path.
+        # For now, let's treat this as a single run_* folder being selected.
+
+        run_dir = Path(folder_paths)
+        if not run_dir.is_dir() or not run_dir.name.startswith("run_"):
+            QMessageBox.warning(
+                self, "Invalid Selection", "Please select a valid run_* folder."
+            )
+            return
+
+        # Step 2: Ask for destination .zip archive
+        zip_path_str, _ = QFileDialog.getSaveFileName(
+            self,
+            "Save Zipped Folder As",
+            str(log_dir / f"{run_dir.name}.zip"),
+            "Zip Archive (*.zip)",
+        )
+
+        if not zip_path_str:
+            return
+
+        zip_path = Path(zip_path_str)
+        if not zip_path.suffix == ".zip":
+            zip_path = zip_path.with_suffix(".zip")
+
+        try:
+            with ZipFile(zip_path, "w") as archive:
+                for path in run_dir.rglob("*"):
+                    archive.write(path, arcname=path.relative_to(run_dir.parent))
+
+            QMessageBox.information(
+                self,
+                "Logs Packaged",
+                f"Folder '{run_dir.name}' successfully packaged to:\n{zip_path}",
+            )
+
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Failed to package folder:\n{e}")
+
+    def run_simulation_from_config(self):
+        config_path_str, _ = QFileDialog.getOpenFileName(
+            self,
+            "Select Configuration File",
+            "",
+            "TOML Files (*.toml);;All Files (*)",
+        )
+
+        if config_path_str:
+            config_path = Path(config_path_str)
+
+            # Structured run dir setup
+            run_info = setup_run_directory(config_path)
+            log_path = run_info["log_file"]
+
+            # Create logger
+            self.logger_manager = LoggerManager(log_path)
+            self.logger_manager.start()
+
+            # Log window
+            self.log_window = LogWindow(self)
+            self.log_window.show()
+
+            # Connect logger to GUI window
+            # Get emitter from logger
+            emitter = self.logger_manager.get_emitter()
+
+            # Hook up emitter to the GUI
+            emitter.message.connect(self.log_window.append_text)
+
+            self.sim_worker = SimulationWorker(
+                config_path,
+                emitter,
+                cancel_callback=lambda: self.log_window.cancel_requested,
+            )
+
+            self.sim_thread = QThread()
+            self.sim_worker.moveToThread(self.sim_thread)
+
+            self.sim_thread.started.connect(self.sim_worker.run)
+            self.sim_worker.finished.connect(self.sim_thread.quit)
+            self.sim_worker.finished.connect(self.sim_worker.deleteLater)
+            self.sim_thread.finished.connect(self.sim_thread.deleteLater)
+
+            self.sim_worker.finished.connect(lambda: print("Simulation finished."))
+            self.sim_worker.finished.connect(self.logger_manager.stop)
+
+            def handle_finished():
+                if self.sim_worker.failed:
+                    self.log_window.mark_failure()
+                else:
+                    self.log_window.mark_success()
+
+                self.log_window.cancel_button.setText("Close")
+                self.log_window.cancel_button.clicked.disconnect()
+                self.log_window.cancel_button.clicked.connect(self.log_window.close)
+
+            self.sim_worker.finished.connect(handle_finished)
+            self.sim_worker.error_occurred.connect(emitter.message.emit)
+
+            self.sim_thread.start()
+
+    def open_napari_viewer(self):
+        """Open a file dialog to select a microscopy image and visualize it with Napari."""
+        # Allow user to select an image file
+        file_path, _ = QFileDialog.getOpenFileName(
+            self,
+            "Open Microscopy Image",
+            "",
+            "Image Files (*.tif *.tiff *.nd2 *.png *.jpg *.zarr);;All Files (*)",
+        )
+
+        if file_path:
+            try:
+                # Load the image (expand here if you want ND2 or Zarr support)
+                image = tifffile.imread(file_path)
+
+                # Open Napari viewer and display the image
+                viewer = napari.Viewer()
+                viewer.add_image(image, name=Path(file_path).stem)
+                napari.run()
+
+            except Exception as e:
+                print(f"Failed to open image: {e}")
+
+    def set_svg_logo(self, svg_path):
+        """Set an SVG logo to the QLabel, maintaining the aspect ratio."""
+        # Create a QSvgRenderer to render the SVG
+        renderer = QSvgRenderer(svg_path)
+        if renderer.isValid():
+            # Get the size of the SVG image
+            image_size = renderer.defaultSize()
+
+            # Create a QPixmap to hold the rendered SVG with the same size as the SVG image
+            pixmap = QPixmap(image_size * 2)
+            pixmap.fill(Qt.GlobalColor.transparent)  # Fill the pixmap with transparency
+
+            # Use QPainter to paint the SVG onto the pixmap
+            painter = QPainter(pixmap)
+            renderer.render(painter)
+            painter.end()
+
+            # Scale the pixmap to fit the desired size while maintaining the aspect ratio
+            scaled_pixmap = pixmap.scaled(
+                200,
+                200,
+                Qt.AspectRatioMode.KeepAspectRatio,
+                Qt.TransformationMode.SmoothTransformation,
+            )
+
+            # Set the scaled pixmap as the QLabel content
+            self.logo_label.setPixmap(scaled_pixmap)
+        else:
+            print("Failed to load SVG file.")
+
+    def open_config_editor(self):
+        """Launch template selection first, then open ConfigEditor."""
+        self.template_window = TemplateSelectionWindow()
+        self.template_window.show()
+
+    def on_link_activated(self, url):
+        """Handle the link activation (clicking the hyperlink)."""
+        webbrowser.open(url)  # Open the URL in the default web browser

AMS_BP/gui/sim_worker.py

@@ -0,0 +1,58 @@
+from pathlib import Path
+
+from PyQt6.QtCore import QObject, pyqtSignal
+
+from ..logging.logutil import LogEmitter
+
+
+class SimulationWorker(QObject):
+    finished = pyqtSignal()
+    error_occurred = pyqtSignal(str)
+
+    def __init__(self, config_path: Path, emitter: LogEmitter, cancel_callback=None):
+        super().__init__()
+        self.config_path = config_path
+        self.emitter = emitter
+        self.cancel_callback = cancel_callback or (lambda: False)
+        self.failed = False
+
+    def run(self):
+        try:
+            self.emitter.message.emit(f"Starting simulation for {self.config_path}")
+
+            from ..configio.convertconfig import load_config, setup_microscope
+            from ..configio.saving import save_config_frames
+
+            loadedconfig = load_config(self.config_path)
+
+            if "version" in loadedconfig:
+                version = loadedconfig["version"]
+                self.emitter.message.emit(f"Using config version: {version}")
+
+            setup_config = setup_microscope(loadedconfig)
+            microscope = setup_config["microscope"]
+            configEXP = setup_config["experiment_config"]
+            functionEXP = setup_config["experiment_func"]
+
+            if self.cancel_callback():
+                self.emitter.message.emit("Simulation canceled before execution.")
+                return
+
+            frames, metadata = functionEXP(microscope=microscope, config=configEXP)
+
+            if self.cancel_callback():
+                self.emitter.message.emit("Simulation canceled after run.")
+                return
+
+            save_config_frames(
+                metadata, frames, setup_config["base_config"].OutputParameter
+            )
+
+            self.emitter.message.emit("Simulation data saved successfully.")
+            self.finished.emit()
+
+        except Exception as e:
+            self.failed = True
+            self.error_occurred.emit(f"Simulation failed: {e}")
+        finally:
+            self.finished.emit()

AMS_BP/gui/template_window_selection.py

@@ -0,0 +1,100 @@
+import json
+from pathlib import Path
+
+import tomli
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QPixmap
+from PyQt6.QtWidgets import (
+    QGroupBox,
+    QHBoxLayout,
+    QLabel,
+    QMessageBox,
+    QPushButton,
+    QScrollArea,
+    QVBoxLayout,
+    QWidget,
+)
+
+from .configuration_window import ConfigEditor
+
+TEMPLATE_DIR = Path(__file__).parent.parent / "resources" / "template_configs"
+METADATA_PATH = TEMPLATE_DIR / "metadata_configs.json"
+
+
+class TemplateSelectionWindow(QWidget):
+    def __init__(self):
+        super().__init__()
+        self.setWindowTitle("Choose a Simulation Template")
+        self.setMinimumSize(700, 500)
+        layout = QVBoxLayout()
+        layout.addWidget(QLabel("<h2>Select a Template to Begin</h2>"))
+
+        scroll_area = QScrollArea()
+        scroll_area.setWidgetResizable(True)
+
+        content_widget = QWidget()
+        content_layout = QVBoxLayout(content_widget)
+
+        try:
+            with open(METADATA_PATH, "r", encoding="utf-8") as f:
+                metadata = json.load(f)
+
+            for key, entry in metadata.items():
+                card = self.create_template_card(entry)
+                content_layout.addWidget(card)
+        except Exception as e:
+            error_label = QLabel(f"Failed to load templates: {e}")
+            layout.addWidget(error_label)
+
+        scroll_area.setWidget(content_widget)
+        layout.addWidget(scroll_area)
+        self.setLayout(layout)
+
+    def create_template_card(self, entry: dict) -> QWidget:
+        group = QGroupBox(entry["label"])
+        layout = QHBoxLayout()
+
+        # Image
+        img_label = QLabel()
+        img_path = TEMPLATE_DIR / entry["image"]
+        if img_path.exists():
+            pixmap = QPixmap(str(img_path)).scaled(
+                200, 200, Qt.AspectRatioMode.KeepAspectRatio
+            )
+            img_label.setPixmap(pixmap)
+        else:
+            img_label.setText("[Missing image assets]")
+        layout.addWidget(img_label)
+
+        # Description + Button
+        vbox = QVBoxLayout()
+
+        description_label = QLabel(entry.get("description", ""))
+        description_label.setWordWrap(True)  # <--- this is the key!
+        vbox.addWidget(description_label)
+
+        btn = QPushButton("Use This Template")
+        btn.clicked.connect(
+            lambda _, config=entry["config"]: self.load_template(config)
+        )
+        vbox.addWidget(btn)
+        layout.addLayout(vbox)
+
+        group.setLayout(layout)
+        return group
+
+    def load_template(self, config_filename: str):
+        config_path = TEMPLATE_DIR / config_filename
+        try:
+            with open(config_path, "rb") as f:
+                config = tomli.load(f)
+
+            self.launch_config_editor(config)
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Failed to load template:\n{e}")
+
+    def launch_config_editor(self, config_dict: dict):
+        self.editor = ConfigEditor()
+        self.editor.set_data(config_dict)
+        self.editor.show()
+        self.close()