pymodaq 3.6.12__py3-none-any.whl → 4.0.1__py3-none-any.whl

pymodaq/utils/parameter/pymodaq_ptypes/pixmap.py

@@ -0,0 +1,161 @@
+import numpy as np
+from qtpy import QtWidgets, QtGui
+from qtpy.QtCore import QByteArray, QObject
+from pyqtgraph.parametertree.parameterTypes.basetypes import WidgetParameterItem, SimpleParameter
+from qtpy import QtWidgets, QtGui
+from qtpy.QtCore import QByteArray
+from pyqtgraph.parametertree.parameterTypes.basetypes import WidgetParameterItem
+
+
+class PixmapCheckData:
+    def __init__(self, data: np.ndarray, path: str = '', checked: bool = False, info: str = ''):
+        if data is not None:
+            data = data / np.max(data) * 255
+            data = data.astype(np.uint8)
+            self.data = data[:, :]
+        else:
+            self.data = []
+        self.path = path
+        self.checked = checked
+        self.info = info
+
+    def __eq__(self, other):
+        if other is None:
+            return False
+        else:
+            status = np.all(np.isclose(self.data, other.data))
+            status = status and self.checked == other.checked
+            status = status and self.path == other.path
+            return status
+
+
+class PixmapCheckWidget(QtWidgets.QWidget):
+    """ value of this parameter is a PixmapCheckData
+
+    See Also
+    --------
+    PixmapCheckedData
+    """
+
+    def __init__(self):
+
+        super().__init__()
+        self._data: PixmapCheckData = None
+        self.checkbox: QtWidgets.QCheckBox = None
+        self.label: QtWidgets.QLabel = None
+        self.info_label: QtWidgets.QLabel = None
+        self.initUI()
+
+    def initUI(self):
+        """
+            Init the User Interface.
+        """
+        self.setLayout(QtWidgets.QHBoxLayout())
+        self.layout().setContentsMargins(0, 0, 0, 0)
+        self.label = QtWidgets.QLabel()
+        self.label.setMaximumWidth(100)
+        self.label.setMinimumHeight(50)
+        self.label.setMaximumHeight(50)
+        self.layout().addWidget(self.label)
+
+        ver_widget = QtWidgets.QWidget()
+        ver_widget.setLayout(QtWidgets.QVBoxLayout())
+        self.checkbox = QtWidgets.QCheckBox('Show/Hide')
+        self.info_label = QtWidgets.QLabel()
+        # self.info.setReadOnly(True)
+        self.checkbox.setChecked(False)
+        ver_widget.layout().addWidget(self.info_label)
+        ver_widget.layout().addWidget(self.checkbox)
+        ver_widget.layout().setSpacing(0)
+        ver_widget.layout().setContentsMargins(0, 0, 0, 0)
+        self.layout().addWidget(ver_widget)
+
+    def setValue(self, data: PixmapCheckData):
+
+
+        im = QtGui.QImage(data.data, *data.data.shape, QtGui.QImage.Format_Indexed8)
+        a = QtGui.QPixmap.fromImage(im)
+
+        self.label.setPixmap(a)
+        self.checkbox.setChecked(data.checked)
+        self.info_label.setText(data.info)
+        self._data = data
+
+    def value(self):
+        return PixmapCheckData(data=self._data.data if self._data is not None else None,
+                               checked=self.checkbox.isChecked(),
+                               info=self._data.info if self._data is not None else '',
+                               path=self._data.path if self._data is not None else '')
+
+
+class PixmapParameterItem(WidgetParameterItem):
+    """Registered parameter type which displays a QPixmap in a QLabel"""
+
+    def makeWidget(self):
+        w = QtWidgets.QLabel()
+        w.sigChanged = None
+        w.value = w.pixmap
+        w.setValue = w.setPixmap
+        return w
+
+
+class PixmapCheckParameterItem(WidgetParameterItem):
+    """Registered parameter type which displays a PixmapCheckWidget custom widget"""
+
+    def makeWidget(self):
+        w = PixmapCheckWidget()
+        w.sigChanged = w.checkbox.clicked
+        w.value = w.value
+        w.setValue = w.setValue
+        self.hideWidget = False
+        return w
+
+
+def main_widget():
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    prog = PixmapCheckWidget()
+    prog.show()
+    data = np.arange(128 * 256).reshape((256, 128))
+    data = data / np.max(data) * 255
+    data = data.astype(np.uint8)
+    prog.setValue(PixmapCheckData(data=data,
+                                  checked=True,
+                                  info='this is an info'))
+
+    def print_toggled(status):
+        print(f"toggled: {status}")
+
+    prog.checkbox.toggled.connect(print_toggled)
+
+    sys.exit(app.exec_())
+
+
+def main_parameter():
+    from pymodaq.utils.managers.parameter_manager import ParameterManager
+    data = np.arange(128 * 256).reshape((256, 128))
+    data = data / np.max(data) * 255
+    data = data.astype(np.uint8)
+
+    class PixmapParameter(ParameterManager):
+        params = {'title': 'Overlays', 'name': 'overlays', 'type': 'group', 'children': [
+            {'name': f'Overlay{0:03.0f}', 'type': 'pixmap_check',
+             'value': PixmapCheckData(data=data, checked=False,
+                                      info=f'This is an info')},
+            {'name': 'other', 'type': 'bool_push', 'value': True},
+            {'name': 'otherp', 'type': 'led_push', 'value': True},
+        ]},
+
+        def value_changed(self, param):
+            print(f'Value changed for {param}: {param.value()}')
+
+    import sys
+    app = QtWidgets.QApplication(sys.argv)
+    prog = PixmapParameter()
+    prog.settings_tree.show()
+
+    sys.exit(app.exec_())
+
+
+if __name__ == '__main__':
+    main_parameter()

pymodaq/{daq_utils → utils}/parameter/pymodaq_ptypes/slide.py

@@ -1,7 +1,7 @@
 from qtpy import QtWidgets, QtCore
 from pyqtgraph.widgets.SpinBox import SpinBox
 from pyqtgraph.parametertree.parameterTypes.basetypes import WidgetParameterItem
-from pymodaq.daq_utils.daq_utils import scroll_log, scroll_linear
+from pymodaq.utils.parameter.utils import scroll_log, scroll_linear
 import numpy as np
 
 

pymodaq/{daq_utils → utils}/parameter/pymodaq_ptypes/table.py

@@ -54,7 +54,7 @@ class TableWidget(QtWidgets.QTableWidget):
                 item0 = QtWidgets.QTableWidgetItem(key)
                 item0.setFlags(item0.flags() ^ QtCore.Qt.ItemIsEditable)
                 if isinstance(value, float):
-                    item1 = QtWidgets.QTableWidgetItem('{:.6e}'.format(value))
+                    item1 = QtWidgets.QTableWidgetItem('{:.3e}'.format(value))
                 else:
                     item1 = QtWidgets.QTableWidgetItem(str(value))
                 item1.setFlags(item1.flags() ^ QtCore.Qt.ItemIsEditable)

pymodaq/utils/parameter/utils.py

@@ -1,15 +1,210 @@
-# -*- coding: utf-8 -*-
-"""
-Created the 27/10/2022
+from __future__ import annotations
 
-@author: Sebastien Weber
-"""
+from typing import TYPE_CHECKING
+import numpy as np
 
-from pymodaq.daq_utils.parameter import utils
+if TYPE_CHECKING:
+    from pymodaq.utils.parameter import Parameter
 
 
-def __getattr__(name):
-    if hasattr(utils, name):
-        return getattr(utils, name)
-    else:
-        raise AttributeError
+def get_widget_from_tree(parameter_tree, widget_instance):
+    widgets = []
+    for item in parameter_tree.listAllItems():
+        if hasattr(item, 'widget'):
+            if item.widget.__class__.__name__ == widget_instance.__name__:
+                widgets.append(item.widget)
+    return widgets
+
+
+def get_param_path(param):
+    """
+
+    Parameters
+    ----------
+    param
+
+    Returns
+    -------
+
+    """
+    path = [param.name()]
+    while param.parent() is not None:
+        path.append(param.parent().name())
+        param = param.parent()
+    return path[::-1]
+
+
+def iter_children(param, childlist=[]):
+    """Get a list of parameters name under a given Parameter
+        | Returns all childrens names.
+
+        =============== ================================= ====================================
+        **Parameters**   **Type**                           **Description**
+        *param*          instance of pyqtgraph parameter    the root node to be coursed
+        *childlist*      list                               the child list recetion structure
+        =============== ================================= ====================================
+
+        Returns
+        -------
+        childlist : parameter list
+            The list of the children from the given node.
+    """
+    for child in param.children():
+        childlist.append(child.name())
+        if 'group' in child.type():
+            childlist.extend(iter_children(child, []))
+    return childlist
+
+
+def iter_children_params(param, childlist=[]):
+    """Get a list of parameters under a given Parameter
+
+    """
+    for child in param.children():
+        childlist.append(child)
+        if 'group' in child.type():
+            childlist.extend(iter_children_params(child, []))
+    return childlist
+
+
+def get_param_from_name(parent, name) -> Parameter:
+    """Get Parameter under parent whose name is name
+
+    Parameters
+    ----------
+    parent: Parameter
+    name: str
+
+    Returns
+    -------
+    Parameter
+    """
+    for child in parent.children():
+        if child.name() == name:
+            return child
+        if 'group' in child.type():
+            ch = get_param_from_name(child, name)
+            if ch is not None:
+                return ch
+
+
+def is_name_in_dict(dict_tmp, name):
+    if 'name' in dict_tmp:
+        if dict_tmp['name'] == name:
+            return True
+    return False
+
+
+def get_param_dict_from_name(parent_list, name, pop=False):
+    """Get dict under parent whose name is name. The parent_list structure is the one used to init a Parameter object
+
+    Parameters
+    ----------
+    parent_list: (list of dicts) as defined to init Parameter object
+    name: (str) value to find for the key: name
+    pop: (bool) if True remove the matched dict from parent
+
+    Returns
+    -------
+    dict the matched dict
+    """
+    for index, parent_dict in enumerate(parent_list):
+        if is_name_in_dict(parent_dict, name):
+            if pop:
+                return parent_list.pop(index)
+            else:
+                return parent_dict
+
+        elif 'children' in parent_dict:
+            ch = get_param_dict_from_name(parent_dict['children'], name, pop)
+            if ch is not None:
+                return ch
+
+
+
+if __name__ == '__main__':              # pragma: no cover
+    parent = [
+        {'title': 'Spectro Settings:', 'name': 'spectro_settings', 'type': 'group', 'expanded': True,
+            'children': [
+                {'title': 'Home Wavelength (nm):', 'name': 'spectro_wl_home', 'type': 'float', 'value': 600, 'min': 0,
+                 'readonly': False},
+                {'title': 'Grating Settings:', 'name': 'grating_settings', 'type': 'group', 'expanded': True,
+                    'children': [
+                        {'title': 'Grating:', 'name': 'grating', 'type': 'list'},
+                        {'title': 'Lines (/mm):', 'name': 'lines', 'type': 'int', 'readonly': True},
+                        {'title': 'Blaze WL (nm):', 'name': 'blaze', 'type': 'str', 'readonly': True},
+                    ]},
+            ]
+         },
+    ]
+
+    d = get_param_dict_from_name(parent, 'lines')
+
+    d['readonly'] = False
+    print(parent[0]['children'][1]['children'])
+
+
+def set_param_from_param(param_old, param_new):
+    """
+        Walk through parameters children and set values using new parameter values.
+    """
+    for child_old in param_old.children():
+        # try:
+        path = param_old.childPath(child_old)
+        child_new = param_new.child(*path)
+        param_type = child_old.type()
+
+        if 'group' not in param_type:  # covers 'group', custom 'groupmove'...
+            # try:
+            if 'list' in param_type:  # check if the value is in the limits of the old params (limits are usually set at initialization)
+                if child_new.value() not in child_old.opts['limits']:
+                    child_old.opts['limits'].append(child_new.value())
+
+                child_old.setValue(child_new.value())
+            elif 'str' in param_type or 'browsepath' in param_type or 'text' in param_type:
+                if child_new.value() != "":  # to make sure one doesnt overwrite something
+                    child_old.setValue(child_new.value())
+            else:
+                child_old.setValue(child_new.value())
+            # except Exception as e:
+            #    print(str(e))
+        else:
+            set_param_from_param(child_old, child_new)
+        # except Exception as e:
+        #    print(str(e))
+
+
+def scroll_log(scroll_val, min_val, max_val):
+    """
+    Convert a scroll value [0-100] to a log scale between min_val and max_val
+    Parameters
+    ----------
+    scroll
+    min_val
+    max_val
+    Returns
+    -------
+
+    """
+    assert scroll_val >= 0
+    assert scroll_val <= 100
+    value = scroll_val * (np.log10(max_val) - np.log10(min_val)) / 100 + np.log10(min_val)
+    return 10 ** value
+
+
+def scroll_linear(scroll_val, min_val, max_val):
+    """
+    Convert a scroll value [0-100] to a linear scale between min_val and max_val
+    Parameters
+    ----------
+    scroll
+    min_val
+    max_val
+    Returns
+    -------
+
+    """
+    assert scroll_val >= 0
+    assert scroll_val <= 100
+    value = scroll_val * (max_val - min_val) / 100 + min_val
+    return value

pymodaq/utils/plotting/data_viewers/__init__.py

@@ -0,0 +1,6 @@
+from .viewer0D import Viewer0D
+from .viewer1D import Viewer1D
+from .viewer2D import Viewer2D
+from .viewerND import ViewerND
+
+DATA_TYPES = ['Data0D', 'Data1D', 'Data2D', 'DataND']