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

AMS_BP/gui/widgets/camera_config_widget.py

@@ -0,0 +1,213 @@
+from pathlib import Path
+
+from pydantic import ValidationError
+from PyQt6.QtWidgets import (
+    QComboBox,
+    QDoubleSpinBox,
+    QFormLayout,
+    QHBoxLayout,
+    QMessageBox,
+    QPushButton,
+    QSpinBox,
+    QVBoxLayout,
+    QWidget,
+)
+
+from .utility_widgets.spectrum_widget import SpectrumEditorDialog
+
+
+class CameraConfigWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout()
+        form = QFormLayout()
+
+        self.validate_button = QPushButton("Validate")
+        self.validate_button.clicked.connect(self.validate)
+        layout.addWidget(self.validate_button)
+
+        # Camera type (Only "CMOS" is available)
+        self.camera_type = QComboBox()
+        self.camera_type.addItems(["CMOS"])
+        form.addRow("Camera Type:", self.camera_type)
+
+        # Pixel count (width and height)
+        self.pixel_width = QSpinBox()
+        self.pixel_width.setRange(1, 10000)
+        self.pixel_height = QSpinBox()
+        self.pixel_height.setRange(1, 10000)
+        form.addRow(
+            "Pixel Count (Width x Height):",
+            self._hbox([self.pixel_width, self.pixel_height]),
+        )
+
+        # Pixel detector size
+        self.pixel_detector_size = QDoubleSpinBox()
+        self.pixel_detector_size.setRange(0, 100)
+        form.addRow("Pixel Detector Size (µm):", self.pixel_detector_size)
+
+        # Magnification
+        self.magnification = QSpinBox()
+        self.magnification.setRange(1, 100)
+        form.addRow("Magnification:", self.magnification)
+
+        # Dark current
+        self.dark_current = QDoubleSpinBox()
+        self.dark_current.setRange(0, 1000)
+        form.addRow("Dark Current (electrons/pixel/sec):", self.dark_current)
+
+        # Readout noise
+        self.readout_noise = QDoubleSpinBox()
+        self.readout_noise.setRange(0, 1000)
+        form.addRow("Readout Noise (electrons RMS):", self.readout_noise)
+
+        # Bit depth
+        self.bit_depth = QSpinBox()
+        self.bit_depth.setRange(8, 16)
+        form.addRow("Bit Depth:", self.bit_depth)
+
+        # Sensitivity
+        self.sensitivity = QDoubleSpinBox()
+        self.sensitivity.setRange(0, 100)
+        form.addRow("Sensitivity (electrons/ADU):", self.sensitivity)
+
+        # Base ADU
+        self.base_adu = QSpinBox()
+        self.base_adu.setRange(0, 65535)
+        form.addRow("Base ADU:", self.base_adu)
+
+        # Binning size
+        self.binning_size = QSpinBox()
+        self.binning_size.setRange(1, 10)
+        form.addRow("Binning Size:", self.binning_size)
+
+        # Quantum efficiency
+        self.quantum_efficiency_button = QPushButton("Edit Quantum Efficiency")
+        self.quantum_efficiency_button.clicked.connect(self.edit_quantum_efficiency)
+        form.addRow("Quantum Efficiency:", self.quantum_efficiency_button)
+
+        layout.addLayout(form)
+        self.setLayout(layout)
+
+    def _hbox(self, widgets):
+        box = QHBoxLayout()
+        for w in widgets:
+            box.addWidget(w)
+        container = QWidget()
+        container.setLayout(box)
+        return container
+
+    def edit_quantum_efficiency(self):
+        # Open the SpectrumEditorDialog for editing quantum efficiency
+        dialog = SpectrumEditorDialog(
+            parent=self,
+            wavelengths=[],  # Pass an empty list or preloaded wavelengths
+            intensities=[],  # Pass an empty list or preloaded intensities
+            intensity_name="QE",
+        )
+
+        if dialog.exec():
+            # Handle the updated quantum efficiency data (wavelengths, intensities)
+            self.quantum_efficiency_data = {
+                "wavelengths": dialog.wavelengths,
+                "quantum_efficiency": dialog.intensities,
+            }
+            # You can now use this data wherever needed, e.g., saving or validation
+
+    def validate(self) -> bool:
+        from ...configio.convertconfig import create_quantum_efficiency_from_config
+        from ...optics.camera.detectors import (
+            CMOSDetector,
+        )
+
+        try:
+            data = self.get_data()
+
+            # Convert QE before passing
+            qe = create_quantum_efficiency_from_config(data["quantum_efficiency"])
+
+            # Prepare CMOS-specific parameters only (drop "type" and "quantum_efficiency")
+            camera_data = {
+                k: v for k, v in data.items() if k not in {"type", "quantum_efficiency"}
+            }
+            camera_data["pixel_size"] = (
+                camera_data["pixel_detector_size"] / camera_data["magnification"]
+            )
+
+            # Attempt to construct the detector
+            detector = CMOSDetector(**camera_data)
+
+            # If no exception, validation is successful
+            QMessageBox.information(
+                self, "Validation Successful", "Camera parameters are valid."
+            )
+            return True
+
+        except ValidationError as e:
+            QMessageBox.critical(self, "Validation Error", str(e))
+            return False
+        except Exception as e:
+            QMessageBox.critical(self, "Validation Error", str(e))
+            return False
+
+    def get_data(self):
+        camera_data = {
+            "type": self.camera_type.currentText(),
+            "pixel_count": [self.pixel_width.value(), self.pixel_height.value()],
+            "pixel_detector_size": self.pixel_detector_size.value(),
+            "magnification": self.magnification.value(),
+            "dark_current": self.dark_current.value(),
+            "readout_noise": self.readout_noise.value(),
+            "bit_depth": self.bit_depth.value(),
+            "sensitivity": self.sensitivity.value(),
+            "base_adu": self.base_adu.value(),
+            "binning_size": self.binning_size.value(),
+            "quantum_efficiency": convert_dict_to_2_list(
+                self.quantum_efficiency_data
+            ),  # Use edited data here
+        }
+        return camera_data
+
+    def set_data(self, data: dict):
+        # Camera type
+        camera_type = data.get("type", "CMOS")
+        idx = self.camera_type.findText(camera_type)
+        if idx >= 0:
+            self.camera_type.setCurrentIndex(idx)
+
+        # Pixel count
+        pixel_count = data.get("pixel_count", [512, 512])
+        if len(pixel_count) == 2:
+            self.pixel_width.setValue(pixel_count[0])
+            self.pixel_height.setValue(pixel_count[1])
+
+        self.pixel_detector_size.setValue(data.get("pixel_detector_size", 6.5))
+        self.magnification.setValue(data.get("magnification", 60))
+        self.dark_current.setValue(data.get("dark_current", 1.0))
+        self.readout_noise.setValue(data.get("readout_noise", 1.0))
+        self.bit_depth.setValue(data.get("bit_depth", 16))
+        self.sensitivity.setValue(data.get("sensitivity", 0.5))
+        self.base_adu.setValue(data.get("base_adu", 100))
+        self.binning_size.setValue(data.get("binning_size", 1))
+
+        # Quantum efficiency
+        raw_qe = data.get("quantum_efficiency", [])
+        wavelengths = [pair[0] for pair in raw_qe]
+        efficiencies = [pair[1] for pair in raw_qe]
+        self.quantum_efficiency_data = {
+            "wavelengths": wavelengths,
+            "quantum_efficiency": efficiencies,
+        }
+
+    def get_help_path(self) -> Path:
+        return Path(__file__).parent.parent / "help_docs" / "detector_help.md"
+
+
+def convert_dict_to_2_list(dict_c):
+    wl_qe = []
+    wl = dict_c["wavelengths"]
+    qe = dict_c["quantum_efficiency"]
+    for i in range(len(wl)):
+        lista = [wl[i], qe[i]]
+        wl_qe.append(lista)
+    return wl_qe

AMS_BP/gui/widgets/cell_config_widget.py

@@ -0,0 +1,225 @@
+from pathlib import Path
+
+from pydantic import ValidationError
+from PyQt6.QtWidgets import (
+    QComboBox,
+    QDoubleSpinBox,
+    QFormLayout,
+    QHBoxLayout,
+    QMessageBox,
+    QPushButton,
+    QStackedWidget,
+    QVBoxLayout,
+    QWidget,
+)
+
+
+class CellConfigWidget(QWidget):
+    def __init__(self):
+        super().__init__()
+        layout = QVBoxLayout()
+        form = QFormLayout()
+
+        self.validate_button = QPushButton("Validate")
+        self.validate_button.clicked.connect(self.validate)
+        layout.addWidget(self.validate_button)
+
+        self.cell_type = QComboBox()
+        self.cell_type.addItems(
+            ["SphericalCell", "RodCell", "RectangularCell", "OvoidCell"]
+        )
+        self.cell_type.currentIndexChanged.connect(self.update_params)
+        form.addRow("Cell Type:", self.cell_type)
+
+        self.param_stack = QStackedWidget()
+        self.param_widgets = {
+            "SphericalCell": self.make_spherical_widget(),
+            "RodCell": self.make_rod_widget(),
+            "RectangularCell": self.make_rect_widget(),
+            "OvoidCell": self.make_ovoid_widget(),
+        }
+
+        for widget in self.param_widgets.values():
+            self.param_stack.addWidget(widget)
+
+        layout.addLayout(form)
+        layout.addWidget(self.param_stack)
+        self.setLayout(layout)
+
+    def validate(self) -> bool:
+        from ...cells import create_cell
+        from ...configio.configmodels import CellParameters
+
+        try:
+            data = self.get_data()
+
+            # Validate the Pydantic model first
+            cell_params = CellParameters(**data)
+
+            # Try creating the cell with backend logic
+            create_cell(cell_params.cell_type, cell_params.params)
+
+            # Success
+            QMessageBox.information(
+                self, "Validation Successful", "Cell parameters are valid."
+            )
+            return True
+
+        except ValidationError as e:
+            QMessageBox.critical(self, "Validation Error", str(e))
+            return False
+        except Exception as e:
+            QMessageBox.critical(self, "Validation Error", str(e))
+            return False
+
+    def update_params(self, index):
+        self.param_stack.setCurrentIndex(index)
+
+    def make_spherical_widget(self):
+        widget = QWidget()
+        form = QFormLayout()
+        self.center_s = [QDoubleSpinBox() for _ in range(3)]
+        for c in self.center_s:
+            c.setRange(0, 1e5)
+        self.radius_s = QDoubleSpinBox()
+        self.radius_s.setRange(0, 1e4)
+        form.addRow("Center (x,y,z):", self._hbox(self.center_s))
+        form.addRow("Radius:", self.radius_s)
+        widget.setLayout(form)
+        return widget
+
+    def make_rod_widget(self):
+        widget = QWidget()
+        form = QFormLayout()
+        self.center_r = [QDoubleSpinBox() for _ in range(3)]
+        self.direction_r = [QDoubleSpinBox() for _ in range(3)]
+        self.height_r = QDoubleSpinBox()
+        self.radius_r = QDoubleSpinBox()
+        for w in self.center_r + self.direction_r:
+            w.setRange(0, 1e5)
+        form.addRow("Center:", self._hbox(self.center_r))
+        form.addRow("Direction:", self._hbox(self.direction_r))
+        form.addRow("Height:", self.height_r)
+        form.addRow("Radius:", self.radius_r)
+        widget.setLayout(form)
+        return widget
+
+    def make_rect_widget(self):
+        widget = QWidget()
+        form = QFormLayout()
+        self.bounds = [QDoubleSpinBox() for _ in range(6)]
+        for b in self.bounds:
+            b.setRange(0, 1e5)
+        form.addRow("Bounds [xmin,xmax,ymin,ymax,zmin,zmax]:", self._hbox(self.bounds))
+        widget.setLayout(form)
+        return widget
+
+    def make_ovoid_widget(self):
+        widget = QWidget()
+        form = QFormLayout()
+        self.center_o = [QDoubleSpinBox() for _ in range(3)]
+        self.xradius = QDoubleSpinBox()
+        self.yradius = QDoubleSpinBox()
+        self.zradius = QDoubleSpinBox()
+        for c in self.center_o:
+            c.setRange(0, 1e5)
+        form.addRow("Center:", self._hbox(self.center_o))
+        form.addRow("X Radius:", self.xradius)
+        form.addRow("Y Radius:", self.yradius)
+        form.addRow("Z Radius:", self.zradius)
+        widget.setLayout(form)
+        return widget
+
+    def _hbox(self, widgets):
+        box = QHBoxLayout()
+        for w in widgets:
+            box.addWidget(w)
+        container = QWidget()
+        container.setLayout(box)
+        return container
+
+    def get_data(self):
+        ctype = self.cell_type.currentText()
+        if ctype == "SphericalCell":
+            return {
+                "cell_type": ctype,
+                "params": {
+                    "center": [s.value() for s in self.center_s],
+                    "radius": self.radius_s.value(),
+                },
+            }
+        elif ctype == "RodCell":
+            return {
+                "cell_type": ctype,
+                "params": {
+                    "center": [s.value() for s in self.center_r],
+                    "direction": [s.value() for s in self.direction_r],
+                    "height": self.height_r.value(),
+                    "radius": self.radius_r.value(),
+                },
+            }
+        elif ctype == "RectangularCell":
+            return {
+                "cell_type": ctype,
+                "params": {"bounds": [b.value() for b in self.bounds]},
+            }
+        elif ctype == "OvoidCell":
+            return {
+                "cell_type": ctype,
+                "params": {
+                    "center": [s.value() for s in self.center_o],
+                    "xradius": self.xradius.value(),
+                    "yradius": self.yradius.value(),
+                    "zradius": self.zradius.value(),
+                },
+            }
+        else:
+            return {"cell_type": ctype, "params": {}}
+
+    def set_data(self, data: dict):
+        try:
+            cell_type = data.get("cell_type", "RodCell")
+            self.cell_type.setCurrentText(cell_type)
+
+            params = data.get("params", {})
+
+            if cell_type == "SphericalCell":
+                center = params.get("center", [0, 0, 0])
+                radius = params.get("radius", 1.0)
+                for i, val in enumerate(center):
+                    self.center_s[i].setValue(val)
+                self.radius_s.setValue(radius)
+
+            elif cell_type == "RodCell":
+                center = params.get("center", [0, 0, 0])
+                direction = params.get("direction", [1, 0, 0])
+                height = params.get("height", 1.0)
+                radius = params.get("radius", 0.5)
+                for i, val in enumerate(center):
+                    self.center_r[i].setValue(val)
+                for i, val in enumerate(direction):
+                    self.direction_r[i].setValue(val)
+                self.height_r.setValue(height)
+                self.radius_r.setValue(radius)
+
+            elif cell_type == "RectangularCell":
+                bounds = params.get("bounds", [0, 10, 0, 10, 0, 10])
+                for i, val in enumerate(bounds):
+                    self.bounds[i].setValue(val)
+
+            elif cell_type == "OvoidCell":
+                center = params.get("center", [0, 0, 0])
+                xr = params.get("xradius", 1.0)
+                yr = params.get("yradius", 1.0)
+                zr = params.get("zradius", 1.0)
+                for i, val in enumerate(center):
+                    self.center_o[i].setValue(val)
+                self.xradius.setValue(xr)
+                self.yradius.setValue(yr)
+                self.zradius.setValue(zr)
+
+        except Exception as e:
+            print(f"[CellConfigWidget] Failed to load data: {e}")
+
+    def get_help_path(self) -> Path:
+        return Path(__file__).parent.parent / "help_docs" / "cell_help.md"