microeye 2.3.2__py3-none-any.whl

microEye/utils/micro_launcher.py

@@ -0,0 +1,245 @@
+import importlib
+import os
+import subprocess
+from collections.abc import Iterable
+
+import pkg_resources
+
+from microEye.qt import QApplication, Qt, QtCore, QtGui, QtSvg, QtWidgets
+from microEye.utils.start_gui import StartGUI
+
+
+def check_modules(modules):
+    availability = {}
+    for module in modules:
+        try:
+            imported_module = importlib.import_module(module)
+            try:
+                version = pkg_resources.get_distribution(module).version
+            except pkg_resources.DistributionNotFound:
+                version = 'Version not found'
+            availability[module] = version
+        except ImportError:
+            availability[module] = None
+    return availability
+
+
+class microLauncher(QtWidgets.QMainWindow):
+    def __init__(self):
+        super().__init__()
+
+        # Remove the title bar
+        self.setWindowFlags(Qt.WindowType.FramelessWindowHint)
+
+        # Set round corners, white border, and dark gray background
+        self.setStyleSheet('''
+            microLauncher {
+                border: 1px solid white !important;
+                padding: 0;
+            }
+            QPushButton#closeButton {
+                border: none;
+            }
+            QPushButton#minButton {
+                border: none;
+            }
+        ''')
+
+        self.dirname = os.path.dirname(os.path.abspath(__file__))
+
+        width = 160
+        height = 130
+
+        # Create a close button with SVG icon
+        self.close_button = QtWidgets.QPushButton()
+        self.close_button.setObjectName('closeButton')
+        self.close_button.setFixedSize(30, 30)
+        self.close_button.clicked.connect(self.close)
+
+        self.minimize_button = QtWidgets.QPushButton()
+        self.minimize_button.setObjectName('minButton')
+        self.minimize_button.setFixedSize(30, 30)
+        self.minimize_button.clicked.connect(lambda: self.showMinimized())
+
+        # Load SVG and set as icon
+        svg_renderer = QtSvg.QSvgRenderer(
+            os.path.join(self.dirname, '../icons/close.svg')
+        )
+        svg_renderer.setAspectRatioMode(Qt.AspectRatioMode.KeepAspectRatio)
+        svg_pixmap = QtGui.QPixmap(24, 24)
+        svg_pixmap.fill(QtCore.Qt.GlobalColor.transparent)
+        painter = QtGui.QPainter(svg_pixmap)
+        svg_renderer.render(painter)
+        painter.end()
+        self.close_button.setIcon(QtGui.QIcon(svg_pixmap))
+        self.close_button.setIconSize(QtCore.QSize(24, 24))
+
+        svg_renderer = QtSvg.QSvgRenderer(
+            os.path.join(self.dirname, '../icons/min.svg')
+        )
+        svg_renderer.setAspectRatioMode(Qt.AspectRatioMode.KeepAspectRatio)
+        svg_pixmap = QtGui.QPixmap(24, 24)
+        svg_pixmap.fill(QtCore.Qt.GlobalColor.transparent)
+        painter = QtGui.QPainter(svg_pixmap)
+        svg_renderer.render(painter)
+        painter.end()
+        self.minimize_button.setIcon(QtGui.QIcon(svg_pixmap))
+        self.minimize_button.setIconSize(QtCore.QSize(24, 24))
+
+        # Layout for close button
+        self.close_button_layout = QtWidgets.QHBoxLayout()
+        self.close_button_layout.addStretch()
+        self.close_button_layout.addWidget(self.minimize_button)
+        self.close_button_layout.addWidget(self.close_button)
+
+        # Set the main layout
+        self.main_layout = QtWidgets.QVBoxLayout()
+        self.main_layout.addLayout(self.close_button_layout)
+
+        # Create buttons with images
+        self.button1 = QtWidgets.QPushButton()
+        pixmap1 = QtGui.QPixmap(
+            os.path.join(self.dirname, '../icons/mieye.png')
+        ).scaled(
+            width,
+            height,
+            Qt.AspectRatioMode.KeepAspectRatio,
+            Qt.TransformationMode.SmoothTransformation,
+        )
+        self.button1.setIcon(QtGui.QIcon(pixmap1))
+        self.button1.setIconSize(QtCore.QSize(width, height))
+        self.button1.clicked.connect(lambda: self.launch_module())
+
+        self.button2 = QtWidgets.QPushButton()
+        pixmap2 = QtGui.QPixmap(
+            os.path.join(self.dirname, '../icons/viewer.png')
+        ).scaled(
+            width,
+            height,
+            Qt.AspectRatioMode.KeepAspectRatio,
+            Qt.TransformationMode.SmoothTransformation,
+        )
+        self.button2.setIcon(QtGui.QIcon(pixmap2))
+        self.button2.setIconSize(QtCore.QSize(width, height))
+        self.button2.clicked.connect(lambda: self.launch_module('viewer'))
+
+        # Create comboboxes
+        self.qt_api_combobox = QtWidgets.QComboBox()
+        self.populate_combobox(self.qt_api_combobox, ['PySide6', 'PyQt5', 'PyQt6'])
+
+        self.theme_combobox = QtWidgets.QComboBox()
+        self.populate_combobox(
+            self.theme_combobox, ['qdarktheme', 'qdarkstyle', 'None'], True
+        )
+
+        # Layout for buttons
+        self.buttons_layout = QtWidgets.QHBoxLayout()
+        self.buttons_layout.addWidget(self.button1)
+        self.buttons_layout.addWidget(self.button2)
+
+        # Add widgets to the main layout
+        self.main_layout.addLayout(self.buttons_layout)
+        self.main_layout.addWidget(self.qt_api_combobox)
+        self.main_layout.addWidget(self.theme_combobox)
+
+        # Set central widget
+        central_widget = QtWidgets.QWidget()
+        central_widget.setLayout(self.main_layout)
+        self.setCentralWidget(central_widget)
+
+        # Window size and title
+        self.setWindowTitle('microEye Launcher')
+        # self.resize(400, 300)
+        self.setContentsMargins(0, 0, 0, 0)
+
+        self.show()
+        self.center()
+
+    def launch_module(self, module='mieye'):
+        '''Launch the selected module'''
+        qt_api = self.qt_api_combobox.currentText()
+        miTheme = self.theme_combobox.currentText()
+
+        env = dict(os.environ, QT_API=qt_api, PYQTGRAPH_QT_LIB=qt_api, MITHEME=miTheme)
+
+        # Define the command and arguments
+        cmd = ['python', '-m', 'microEye.launcher', '--module', module]
+
+        # Get the current working directory
+        cwd = os.getcwd()
+
+        # Open a new terminal and run the command
+        if os.name == 'nt':  # Windows
+            flags = 0
+            flags |= subprocess.DETACHED_PROCESS
+            flags |= subprocess.CREATE_NEW_PROCESS_GROUP
+            flags |= subprocess.CREATE_BREAKAWAY_FROM_JOB
+            flags |= subprocess.CREATE_NO_WINDOW
+
+            pkwargs = {
+                'close_fds': True,  # close stdin/stdout/stderr on child
+                'creationflags': flags,
+            }
+            subprocess.Popen(
+                ['start', 'cmd', '/k'] + cmd, cwd=cwd, shell=True, env=env, **pkwargs
+            )
+            # self.close()
+        else:  # Unix-based systems (Linux, macOS, etc.)
+            subprocess.Popen(
+                ['setsid', 'gnome-terminal', '--working-directory=' + cwd, '--'] + cmd,
+                env=env,
+            )
+            self.close()
+
+    def center(self):
+        '''Centers the window within the screen.'''
+        qtRectangle = self.frameGeometry()
+        centerPoint = QApplication.primaryScreen().availableGeometry().center()
+        qtRectangle.moveCenter(centerPoint)
+        self.move(qtRectangle.topLeft())
+
+    def populate_combobox(self, combobox, items: Iterable[str], theme=False):
+        model = QtGui.QStandardItemModel()
+        availability = check_modules(items)
+        for item in items:
+            standard_item = QtGui.QStandardItem(item)
+            if availability[item] is None and item.lower() != 'none':
+                disabledColor = QtGui.QBrush(QtGui.QColor(Qt.GlobalColor.red))
+                standard_item.setData(
+                    disabledColor, QtCore.Qt.ItemDataRole.ForegroundRole
+                )
+                standard_item.setEnabled(False)
+                standard_item.setToolTip(f'{standard_item.text()} is not installed')
+            elif item.lower() != 'none':
+                prefix = (
+                    '' if availability[item] == 'Version not found' else 'Version: '
+                )
+                standard_item.setToolTip(f'{prefix}{availability[item]}')
+            model.appendRow(standard_item)
+
+        if theme:
+            for item in QtWidgets.QStyleFactory.keys():  # noqa: SIM118
+                standard_item = QtGui.QStandardItem(item)
+                model.appendRow(standard_item)
+        combobox.setModel(model)
+
+    def StartGUI():
+        '''
+        Initializes a new QApplication and microLauncher.
+
+        Parameters
+        ----------
+        path : str, optional
+            The path to a file to be loaded initially.
+
+        Returns
+        -------
+        tuple of QApplication and microLauncher
+            Returns a tuple with QApplication and microLauncher window.
+        '''
+        return StartGUI(microLauncher, theme=None)
+
+
+if __name__ == '__main__':
+    app, window = microLauncher.StartGUI()
+    app.exec()

microEye/utils/parameter_tree.py

@@ -0,0 +1,325 @@
+import json
+from enum import Enum
+from typing import Any, Optional, Union
+
+from pyqtgraph.parametertree import Parameter, ParameterTree
+from pyqtgraph.parametertree.parameterTypes import ActionParameter, GroupParameter
+
+from microEye.qt import QtWidgets, Signal, Slot, getOpenFileName, getSaveFileName
+
+
+class Tree(ParameterTree):
+    '''
+    Tree widget for editing parameters.
+
+    Attributes
+    ----------
+    paramsChanged : Signal
+        Signal for parameter changed event.
+    '''
+
+    PARAMS: type[Enum] = None
+
+    paramsChanged = Signal(Parameter, object)
+    '''Signal emitted when parameters are changed.
+
+    Parameters
+    ----------
+    GroupParameter
+        The group parameter that was changed.
+    list
+        A list of changes made to the parameter.
+    '''
+
+    def __init__(self, parent: Optional['QtWidgets.QWidget'] = None):
+        '''
+        Initialize the Tree.
+
+        Parameters
+        ----------
+        parent : QWidget, optional
+            The parent widget, by default None.
+        '''
+        super().__init__(parent=parent)
+
+        self.setMinimumWidth(50)
+        self.create_parameters()
+        self.setParameters(self.param_tree, showTop=False)
+
+    def create_parameters(self):
+        '''
+        Create the parameter tree structure.
+
+        Reimplement in child class.
+        '''
+        params = []
+
+        self.param_tree = Parameter.create(name='', type='group', children=params)
+        self.param_tree.sigTreeStateChanged.connect(self.change)
+        self.header().setSectionResizeMode(QtWidgets.QHeaderView.ResizeMode.Stretch)
+
+    def get_param(self, param: Union[Enum, str]) -> Union[Parameter, ActionParameter]:
+        '''Get a parameter by name.
+
+        Parameters
+        ----------
+        param : Enum
+            parameter.
+
+        Returns
+        -------
+        Union[Parameter, ActionParameter]
+            Retrieved parameter.
+        '''
+        try:
+            if isinstance(param, Enum):
+                return self.param_tree.param(*param.value.split('.'))
+            else:
+                return self.param_tree.param(*param.split('.'))
+        except KeyError:
+            return None
+
+    def get_param_value(self, param: Union[Enum, str]):
+        '''Get a parameter value by name.
+
+        Parameters
+        ----------
+        param : Enum
+            parameter.
+
+        Returns
+        -------
+        Any
+            The value of the parameter.
+        '''
+        try:
+            if isinstance(param, Enum):
+                return self.param_tree.param(*param.value.split('.')).value()
+            else:
+                return self.param_tree.param(*param.split('.')).value()
+        except KeyError:
+            return None
+
+    def set_param_value(
+        self, param: Enum, value, blockSignals: Union[Any, None] = None
+    ):
+        '''
+        Set a parameter value by name.
+
+        Parameters
+        ----------
+        param : Enum
+            parameter.
+        value : Any
+            The value to set.
+        blockSignals : Union[Any, None], optional
+            If provided, signals for parameter changes are blocked during the update.
+            The interpretation of the value is left to the implementation.
+
+        Returns
+        -------
+        bool
+            True if the value is set successfully, False otherwise.
+        '''
+        try:
+            parameter: Parameter = self.param_tree.param(*param.value.split('.'))
+            parameter.setValue(value, blockSignals)
+        except Exception:
+            import traceback
+
+            traceback.print_exc()
+            return False
+        else:
+            return True
+
+    def get_param_path(self, param: Parameter):
+        '''
+        Get the child path of a parameter in the parameter tree.
+
+        Parameters
+        ----------
+        param : Parameter
+            The parameter for which to retrieve the child path.
+
+        Returns
+        -------
+        list
+            The child path of the parameter.
+        '''
+        return self.param_tree.childPath(param)
+
+    def add_param_child(self, parent: Enum, value: dict):
+        """
+        Add a child parameter to the specified parent parameter.
+
+        Parameters
+        ----------
+        parent : Enum
+            The parent parameter to which the child will be added.
+        value : dict
+            A dictionary representing the child parameter. It should contain at
+            least the following key-value pairs:
+            - 'name': str, the name of the parameter.
+            - 'type': str, the type of the parameter (e.g., 'int', 'float', 'str').
+            - 'value': Any, the initial value of the parameter.
+            Additional optional keys can be included based on the desired configuration.
+
+        Returns
+        -------
+        None
+        """
+        parent = self.get_param(parent)
+        parent.addChild(value, autoIncrementName=True)
+
+    def get_children(self, param: Enum):
+        """
+        Get the values of all children of a specified parameter.
+
+        Parameters
+        ----------
+        param : Enum
+            The parameter whose children's values will be retrieved.
+
+        Returns
+        -------
+        list
+            List of values of all children of the specified parameter.
+        """
+        res = []
+        param = self.get_param(param)
+        if isinstance(param, GroupParameter):
+            for child in param.children():
+                res.append(child.value())
+        return res
+
+    def change(self, param: Parameter, changes: list):
+        '''
+        Handle parameter changes as needed.
+
+        Parameters
+        ----------
+        param : Parameter
+            The parameter that triggered the change.
+        changes : list
+            List of changes.
+
+        Returns
+        -------
+        None
+        '''
+        # Handle parameter changes as needed
+        pass
+
+    @Slot(object)
+    def export_json(self, action=None):
+        '''
+        Export parameters to a JSON file.
+
+        Returns
+        -------
+        None
+        '''
+        filename, _ = getSaveFileName(
+            None, 'Save Parameters', '', 'JSON Files (*.json);;All Files (*)'
+        )
+        if not filename:
+            return  # User canceled the operation
+
+        state = self.param_tree.saveState()
+        with open(filename, 'w', encoding='utf8') as file:
+            json.dump(state, file, indent=2)
+
+    def get_json(self):
+        '''
+        Export parameters to a JSON text.
+
+        Returns
+        -------
+        str
+            A string containing all parameters in JSON format.
+        '''
+        return self.param_tree.saveState()
+
+    # Load parameters from JSON
+    @Slot(object)
+    def load_json(self, action=None):
+        '''
+        Load parameters from a JSON file.
+
+        Returns
+        -------
+        None
+        '''
+        filename, _ = getOpenFileName(
+            None, 'Load Parameters', '', 'JSON Files (*.json);;All Files (*)'
+        )
+        if not filename:
+            return  # User canceled the operation
+
+        with open(filename, encoding='utf8') as file:
+            state = json.load(file)
+        self.param_tree.restoreState(
+            state, addChildren=False, removeChildren=False, blockSignals=False)
+
+    def get_param_paths(self) -> list[str]:
+        '''
+        Get a list of all parameter paths in the tree, excluding group parameters.
+
+        Returns
+        -------
+        list
+            A list of all parameter paths, excluding groups.
+        '''
+
+        def collect_paths(param, current_path=None):
+            paths = []
+            if current_path is None:
+                current_path = []
+            for child in param.children():
+                child_path = current_path + [child.name()]
+                if not child.hasChildren():  # This checks if parameter is not a group
+                    paths.append('.'.join(child_path))
+                else:
+                    paths.extend(collect_paths(child, child_path))
+            return paths
+
+        return collect_paths(self.param_tree)
+
+    def search_param(self, contains: str) -> Union[None, Parameter, ActionParameter]:
+        '''
+        Find parameter that contains the supplied string
+        in the tree and return it if found.
+
+        Parameters
+        ----------
+        contains : str
+            The string to search for in the parameter paths.
+
+        Returns
+        -------
+        object or None
+            The value of the first parameter that contains the supplied string,
+            or None if no match is found.
+        '''
+        path = [
+            path
+            for path in self.get_param_paths()
+            if contains.lower().strip() in path.lower().split('.')[-1]
+        ]
+        if path:
+            self.get_param(path[0])
+        else:
+            return None
+
+    def set_expanded(self, param: Union[Parameter, Enum, str], value: bool = False):
+        if isinstance(param, (Enum, str)):
+            param = self.get_param(param)
+
+        if not isinstance(param, Parameter):
+            return
+
+        if param:
+            for item in self.listAllItems():
+                if item.param == param:
+                    item.setExpanded(value)
+                    break