microeye 2.3.6__tar.gz → 2.3.7__tar.gz

{microeye-2.3.6/src/microeye.egg-info → microeye-2.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: microeye
-Version: 2.3.6
+Version: 2.3.7
 Summary: A python toolkit for fluorescence microscopy         that features hardware control, data analysis and vizualization         for super-resolution single-molecule localization microscopy and         single-partical tracking.
 Home-page: https://github.com/samhitech/microEye
 Author: Mohammad Nour Alsamsam
@@ -95,10 +95,10 @@ This toolkit is compatible with the [hardware](#hardware) used in our microscope
 ![GitHub Stars](https://img.shields.io/github/stars/samhitech/microEye.svg)
 
 ```bash
-   __  ____              ____                ___    ____  ____
-  /  |/  (_)__________  / __/_ _____   _  __|_  |  |_  / / __/
- / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __/_ _/_ <_/ _ \
-/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)____(_)___/
+   __  ____              ____                ___    ____ ____
+  /  |/  (_)__________  / __/_ _____   _  __|_  |  |_  //_  /
+ / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __/_ _/_ <_ / / 
+/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)____(_)_/  
                           /___/
 ```
 

{microeye-2.3.6 → microeye-2.3.7}/README.md

@@ -31,10 +31,10 @@ This toolkit is compatible with the [hardware](#hardware) used in our microscope
 ![GitHub Stars](https://img.shields.io/github/stars/samhitech/microEye.svg)
 
 ```bash
-   __  ____              ____                ___    ____  ____
-  /  |/  (_)__________  / __/_ _____   _  __|_  |  |_  / / __/
- / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __/_ _/_ <_/ _ \
-/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)____(_)___/
+   __  ____              ____                ___    ____ ____
+  /  |/  (_)__________  / __/_ _____   _  __|_  |  |_  //_  /
+ / /|_/ / / __/ __/ _ \/ _// // / -_) | |/ / __/_ _/_ <_ / / 
+/_/  /_/_/\__/_/  \___/___/\_, /\__/  |___/____(_)____(_)_/  
                           /___/
 ```
 

{microeye-2.3.6 → microeye-2.3.7}/src/microEye/__init__.py

@@ -40,8 +40,3 @@ def getArgs():
 
 
 ARGS = getArgs()
-
-import microEye.analysis.fitting.pyfit3Dcspline as pyfit3Dcspline  # noqa: E402
-from microEye.analysis import multi_viewer  # noqa: E402
-from microEye.hardware import miEye_module  # noqa: E402
-from microEye.qt import *  # noqa: I001, E402

{microeye-2.3.6 → microeye-2.3.7}/src/microEye/_version.py

@@ -1,2 +1,2 @@
-version_info = (2, 3, 6)
+version_info = (2, 3, 7)
 __version__ = '.'.join(map(str, version_info))

{microeye-2.3.6 → microeye-2.3.7}/src/microEye/hardware/cams/camera_options.py

@@ -1,10 +1,9 @@
 import os
 import sys
 from enum import Enum
-from typing import Any, Optional
+from typing import Optional
 
 from pyqtgraph.parametertree import Parameter
-from pyqtgraph.parametertree.parameterTypes import GroupParameter
 
 from microEye.qt import QApplication, QtWidgets, Signal
 from microEye.utils.parameter_tree import Tree
@@ -729,7 +728,7 @@ class CameraOptions(Tree):
         str
             The selected dual view colors.
         '''
-        # get the selected dual view colors from the parameter tree e.g. 'RG', 'GB', etc.
+        # get the selected dual view colors from the parameter tree e.g. 'RG', 'GB', etc
         scheme = self.get_param_value(CamParams.DUAL_VIEW_COLORS)
 
         indices = {'R': 0, 'G': 1, 'B': 2}

{microeye-2.3.6 → microeye-2.3.7}/src/microEye/hardware/cams/camera_panel.py

@@ -1,16 +1,11 @@
-import math
 import os
 import re
 import threading
-import time
 import traceback
-from functools import lru_cache
 from queue import Queue
-from typing import Optional, Union
+from typing import Union
 
-import cv2
 import numpy as np
-import pyqtgraph as pg
 
 from microEye.analysis.tools.roi_selectors import (
     MultiRectangularROISelector,
@@ -26,7 +21,6 @@ from microEye.hardware.cams.shortcuts import (
 )
 from microEye.qt import QDateTime, Qt, QtCore, QtWidgets, Signal, Slot
 from microEye.utils.display import DisplayManager, fast_autolevels_opencv
-from microEye.utils.expandable_groupbox import ExpandableGroupBox
 from microEye.utils.gui_helper import get_scaling_factor
 from microEye.utils.metadata_tree import MetadataEditorTree, MetaParams
 from microEye.utils.thread_worker import QThreadWorker
@@ -524,6 +518,21 @@ class Camera_Panel(QtWidgets.QGroupBox):
             except Exception:
                 traceback.print_exc()
 
+    def get_ROI(self) -> tuple[int, int, int, int]:
+        '''Gets the ROI for the selected camera.
+
+        Returns
+        -------
+        tuple[int, int, int, int]
+            The ROI as (x, y, width, height).
+        '''
+        x = self.camera_options.get_param_value(CamParams.ROI_X)
+        y = self.camera_options.get_param_value(CamParams.ROI_Y)
+        w = self.camera_options.get_param_value(CamParams.ROI_WIDTH)
+        h = self.camera_options.get_param_value(CamParams.ROI_HEIGHT)
+
+        return x, y, w, h
+
     def roi_shortcuts(self, fov: float, single: bool, software: bool):
         '''
         Sets the ROI for the camera using the selected FOV and mode.
@@ -560,6 +569,19 @@ class Camera_Panel(QtWidgets.QGroupBox):
             y = int((height - fov // pixel_size) / 2)
             h = int(fov // pixel_size)
 
+        if not software:
+            self.reset_ROI()
+            QtCore.QThread.msleep(250)  # wait for the camera to update the ROI
+
+            self.camera_options.set_param_value(CamParams.ROI_X, x)
+            self.camera_options.set_param_value(CamParams.ROI_Y, y)
+            self.camera_options.set_param_value(CamParams.ROI_WIDTH, w)
+            self.camera_options.set_param_value(CamParams.ROI_HEIGHT, h)
+
+            self.set_ROI()
+
+            x, y, w, h = self.get_ROI()
+
             rois = [
                 (x if software else 0, y if software else 0, h, h),
                 (h + 3 * x if software else h + 2 * x, y if software else 0, h, h),
@@ -576,18 +598,7 @@ class Camera_Panel(QtWidgets.QGroupBox):
                         'value': f'{roi[0]}, {roi[1]}, {roi[2]}, {roi[3]}',
                     },
                 )
-
-        if not software:
-            self.reset_ROI()
-            QtCore.QThread.msleep(250)  # wait for the camera to update the ROI
-
-            self.camera_options.set_param_value(CamParams.ROI_X, x)
-            self.camera_options.set_param_value(CamParams.ROI_Y, y)
-            self.camera_options.set_param_value(CamParams.ROI_WIDTH, w)
-            self.camera_options.set_param_value(CamParams.ROI_HEIGHT, h)
-
-            self.set_ROI()
-        elif single:
+        elif single and software:
             self.camera_options.add_param_child(
                 CamParams.EXPORTED_ROIS,
                 {
@@ -849,7 +860,8 @@ def display_frame(
         frame = frame._image
 
     thresholds, hist, cdf = fast_autolevels_opencv(
-        frame, levels=camp.camera_options.isAutostretch)
+        frame, levels=camp.camera_options.isAutostretch
+    )
 
     # cv2.imshow(name, frame)
     DisplayManager.instance().image_update_signal.emit(
@@ -895,7 +907,6 @@ def update_histogram_and_display(params: AcquisitionJob, camp: Camera_Panel):
         display_frame(camp, params.name, params.frame)
 
     elif camp.camera_options.isROIsView:
-
         overlaid = len(params.rois) == 2 and camp.camera_options.isOverlaidView
         flipped = camp.camera_options.isFlippedROIsView
 

{microeye-2.3.6 → microeye-2.3.7}/src/microEye/hardware/cams/line_profiler.py

@@ -1,10 +1,9 @@
 import numpy as np
 import pyqtgraph as pg
 import qdarkstyle
-from pyqtgraph.multiprocess import proxy
 
 from microEye.analysis.tools.kymograms import get_kymogram_row
-from microEye.qt import QApplication, QtWidgets, Signal, Slot
+from microEye.qt import QApplication, QtWidgets, Signal
 
 
 class LineProfiler(QtWidgets.QWidget):

{microeye-2.3.6 → microeye-2.3.7}/src/microEye/hardware/cams/shortcuts.py

@@ -2,7 +2,7 @@ from typing import Union
 
 from microEye.hardware.cams.camera_options import CamParams
 from microEye.hardware.cams.micam import miCamera
-from microEye.qt import QDateTime, Qt, QtCore, QtGui, QtWidgets, Signal, Slot
+from microEye.qt import Qt, QtCore, QtGui, QtWidgets, Signal
 from microEye.utils.gui_helper import debounceSlot
 
 DEFAULT_EXPOSURE_SHORTCUTS = [
@@ -399,9 +399,7 @@ class CameraShortcutsWidget(QtWidgets.QWidget):
         # Close all windows
         self.close_windows_button = QtWidgets.QPushButton('Close All Windows')
         self.close_windows_button.setToolTip('Close all windows')
-        self.close_windows_button.clicked.connect(
-            lambda: self.closeAllWindows.emit()
-        )
+        self.close_windows_button.clicked.connect(lambda: self.closeAllWindows.emit())
         self.display_windows_btns.addWidget(self.close_windows_button)
 
     def _display_mode_changed(self, index):

microeye-2.3.7/src/microEye/hardware/cams/vimba/__init__.py

@@ -0,0 +1 @@
+

microeye-2.3.7/src/microEye/hardware/lasers/__init__.py

@@ -0,0 +1 @@
+

{microeye-2.3.6 → microeye-2.3.7}/src/microEye/hardware/lasers/io_matchbox.py

@@ -1,3 +1,4 @@
+import threading
 import time
 from typing import Optional
 
@@ -6,7 +7,9 @@ from pyqtgraph.parametertree import Parameter
 
 from microEye.hardware.lasers.io_params import LaserState, MB_Params
 from microEye.qt import QtCore, QtSerialPort, QtWidgets, Signal
-from microEye.utils import StartGUI, Tree
+from microEye.utils.parameter_tree import Tree
+from microEye.utils.start_gui import StartGUI
+from microEye.utils.thread_worker import QThreadWorker
 
 
 class io_combiner(QtCore.QObject):
@@ -136,6 +139,8 @@ class io_combiner(QtCore.QObject):
             open=False,  # Start with the port closed
         )
 
+        self._lock = threading.Lock()  # Add this line
+
     def isOpen(self) -> bool:
         '''
         Checks if the serial port is open.
@@ -204,38 +209,42 @@ class io_combiner(QtCore.QObject):
             command to be sent, please check the constants
             implemented in the MatchBox class.
         '''
-        if self.isOpen():
-            try:
-                self.ser.reset_input_buffer()
-
-                start_time = time.time()
-                self.ser.write(command)
-
-                response = (
-                    self.ser.read_until(b'\r\n')
-                    .decode(errors='replace')
-                    .replace(b'\xff', b'')
-                    .strip()
-                )
-                elapsed_time = (
-                    time.time() - start_time
-                ) * 1000  # Convert to milliseconds
-                if log_print:
-                    print(
-                        f'Command: {command} | '
-                        f'Response: {response} | '
-                        f'Time: {elapsed_time:.1f} ms'
-                    )
-
-                self.DataReady.emit(response, command)
-
-                return response
-            except serial.SerialException as e:
-                print(f'Serial communication error: {e}')
-                return '<ERR>'
-            except Exception as e:
-                print(f'Unexpected error: {e}')
-                return '<ERR>'
+        with self._lock:
+            if self.isOpen():
+                try:
+                    self.ser.reset_input_buffer()
+
+                    start_time = time.time()
+                    self.ser.write(command)
+
+                    response = []
+                    for _ in range(5 if command == io_combiner.INFO else 1):
+                        response.append(
+                            self.ser.read_until(b'\r\n')
+                            .replace(b'\xff', b'')
+                            .decode(errors='replace')
+                            .strip()
+                        )
+                    elapsed_time = (
+                        time.time() - start_time
+                    ) * 1000  # Convert to milliseconds
+                    if log_print:
+                        rx = response[0] if len(response) == 1 else '...'
+                        print(
+                            f'Command: {command} | '
+                            f'Response: {rx} | '
+                            f'Time: {elapsed_time:.1f} ms'
+                        )
+
+                    self.DataReady.emit(response, command)
+
+                    return response[0] if len(response) == 1 else response
+                except serial.SerialException as e:
+                    print(f'Serial communication error: {e}')
+                    return '<ERR>'
+                except Exception as e:
+                    print(f'Unexpected error: {e}')
+                    return '<ERR>'
 
     def OpenCOM(self):
         '''Opens the serial port and initializes the combiner.'''
@@ -406,7 +415,7 @@ class io_combiner(QtCore.QObject):
             res = self.SendCommand(io_combiner.INFO, delay=50)
 
             if not ('<ERR>' in res or '<ACK>' in res):
-                info = res.split('\r\n')
+                info = res
 
                 self.Firmware = info[0]
                 self.Serial = info[1].split(':')[1]
@@ -495,6 +504,7 @@ class CombinerLaserWidget(Tree):
 
         # Statues Bar Timer
         self.timer = QtCore.QTimer()
+        self.timer.setSingleShot(True)
         self.timer.setInterval(500)
         self.timer.timeout.connect(self.update_stats)
         self.timer.start()
@@ -535,8 +545,7 @@ class CombinerLaserWidget(Tree):
                         'value': 115200,
                         'limits': [
                             baudrate
-                            for baudrate in
-                            QtSerialPort.QSerialPortInfo.standardBaudRates()
+                            for baudrate in QtSerialPort.QSerialPortInfo.standardBaudRates()  # noqa: E501
                         ],
                     },
                     {'name': str(MB_Params.SET_PORT), 'type': 'action'},
@@ -756,7 +765,7 @@ class CombinerLaserWidget(Tree):
             switch.SetCurrent(value)
 
     def update_stats(self):
-        """
+        '''
         Updates the statistics displayed in the MatchBox GUI.
 
         This method retrieves the current readings and settings from the device, and
@@ -764,42 +773,70 @@ class CombinerLaserWidget(Tree):
         sets the limits of the power parameter based on the maximum power that can be
         set for the laser diode.
 
-        If the laser is not connected, the method sets the 'Port State' parameter to
-        'closed'.
-        """
+        If the laser is not connected, the method sets the "Port State" parameter to
+        "closed".
+        '''
         if self.Laser.isOpen():
-            readings = self.Laser.GetReadings(False)
-            settings = self.Laser.GetSettings(False)
-            self.Laser.GetCurrent()
-
-            for key, value in readings.items():
-                if isinstance(value, (int, float)):
-                    self.set_param_value(key, f'{value:.2f}')
-                elif isinstance(value, str):
-                    self.set_param_value(key, value)
-
-            for key, value in settings.items():
-                if isinstance(value, (int, float)):
-                    self.set_param_value(key, f'{value:.2f}')
-                elif isinstance(value, str):
-                    self.set_param_value(key, value)
-
-            self.set_param_value(
-                MB_Params.LD_CURRENT,
-                '{:.2f} mA, {:.2f} mA, {:.2f} mA, {:.2f} mA'.format(
-                    *self.Laser.Current
-                ),
-            )
-            self.set_param_value(
-                MB_Params.LD_CURRENT_MAX,
-                '{:.2f} mA, {:.2f} mA, {:.2f} mA, {:.2f} mA'.format(*self.Laser.Max),
-            )
-            self.set_param_value(
-                MB_Params.LD_CURRENT_SET,
-                '{:.2f} mA, {:.2f} mA, {:.2f} mA, {:.2f} mA'.format(
-                    *self.Laser.Setting
-                ),
-            )
+
+            def fetch_stats():
+                '''
+                Fetches the current readings and settings from the laser device.
+                '''
+                try:
+                    if self.Laser.isOpen():
+                        readings = self.Laser.GetReadings(False)
+                        settings = self.Laser.GetSettings(False)
+                        self.Laser.GetCurrent()
+                        return readings, settings
+                except Exception as e:
+                    print(f'Error fetching stats: {e}')
+
+                return {}, {}
+
+            def done(readings: dict, settings: dict):
+                '''
+                Updates the parameter tree with the fetched readings and settings.
+                '''
+                if readings:
+                    for key, value in readings.items():
+                        if isinstance(value, (int, float)):
+                            self.set_param_value(key, f'{value:.2f}')
+                        elif isinstance(value, str):
+                            self.set_param_value(key, value)
+
+                if settings:
+                    for key, value in settings.items():
+                        if isinstance(value, (int, float)):
+                            self.set_param_value(key, f'{value:.2f}')
+                        elif isinstance(value, str):
+                            self.set_param_value(key, value)
+
+                self.set_param_value(
+                    MB_Params.LD_CURRENT,
+                    '{:.2f} mA, {:.2f} mA, {:.2f} mA, {:.2f} mA'.format(
+                        *self.Laser.Current
+                    ),
+                )
+                self.set_param_value(
+                    MB_Params.LD_CURRENT_MAX,
+                    '{:.2f} mA, {:.2f} mA, {:.2f} mA, {:.2f} mA'.format(
+                        *self.Laser.Max
+                    ),
+                )
+                self.set_param_value(
+                    MB_Params.LD_CURRENT_SET,
+                    '{:.2f} mA, {:.2f} mA, {:.2f} mA, {:.2f} mA'.format(
+                        *self.Laser.Setting
+                    ),
+                )
+
+            worker = QThreadWorker(fetch_stats)
+            worker.signals.result.connect(done)
+            worker.signals.finished.connect(
+                self.timer.start
+            )  # Restart the timer after fetching stats
+
+            QtCore.QThreadPool.globalInstance().start(worker)
 
             self.set_param_value(MB_Params.OPERATION_TIME, self.Laser.Operation_Time)
             self.set_param_value(MB_Params.ON_TIMES, self.Laser.ON_Times)
@@ -811,13 +848,13 @@ class CombinerLaserWidget(Tree):
         self.RefreshPorts()
 
     def RefreshPorts(self):
-        """
+        '''
         Refreshes the available serial ports list in the GUI.
 
         This method updates the list of available serial ports in the GUI by fetching
         the current list of available ports and setting it as the options for the
-        'Serial Port' parameter in the parameter tree.
-        """
+        `Serial Port` parameter in the parameter tree.
+        '''
         if not self.Laser.isOpen():
             self.get_param(MB_Params.PORT).setLimits(
                 [