microeye 2.3.2__py3-none-any.whl

microEye/utils/hid/enums.py

@@ -0,0 +1,140 @@
+from enum import Enum
+
+import numpy as np
+
+
+class Buttons(Enum):
+    '''
+    Enum representing controller buttons.
+
+    Each enum member has a unique value representing its state in the report,
+    along with additional information like identifier, description, etc.
+
+    Attributes
+    ----------
+    A : Buttons
+        Represents the X/A button on the controller.
+    B : Buttons
+        Represents the O/B button on the controller.
+    X : Buttons
+        Represents the Sq/X button on the controller.
+    Y : Buttons
+        Represents the Tri/Y button on the controller.
+    L1 : Buttons
+        Represents the L1 button on the controller.
+    R1 : Buttons
+        Represents the R1 button on the controller.
+    Share : Buttons
+        Represents the Share button on the controller.
+    Options : Buttons
+        Represents the Options button on the controller.
+    L3 : Buttons
+        Represents the L3 button on the controller.
+    R3 : Buttons
+        Represents the R3 button on the controller.
+    UP : Buttons
+        Represents the D-Pad UP button on the controller.
+    RIGHT : Buttons
+        Represents the D-Pad RIGHT button on the controller.
+    DOWN : Buttons
+        Represents the D-Pad DOWN button on the controller.
+    LEFT : Buttons
+        Represents the D-Pad LEFT button on the controller.
+
+    Methods
+    -------
+    __str__()
+        String representation of the button.
+    from_string(s)
+        Get an enum member based on its string representation.
+    from_value(ch, id)
+        Get an enum member based on its channel and identifier.
+    strings()
+        Get an array of string representations of all enum members.
+    '''
+    A = (1, 0, 'X/A')
+    B = (2, 0, 'O/B')
+    X = (4, 0, 'Sq/X')
+    Y = (8, 0, 'Tri/Y')
+    L1 = (16, 0, 'L1')
+    R1 = (32, 0, 'R1')
+    Share = (64, 0, 'Share')
+    Options = (128, 0, 'Options')
+
+    L3 = (1, 1, 'L3')
+    R3 = (2, 1, 'R3')
+    UP = (4, 1, 'D-Pad UP')
+    RIGHT = (12, 1, 'D-Pad RIGHT')
+    DOWN = (20, 1, 'D-Pad DOWN')
+    LEFT = (28, 1, 'D-Pad LEFT')
+
+    def __str__(self):
+        '''String representation of the button.'''
+        return self.value[-1]
+
+    @classmethod
+    def from_string(cls, s):
+        '''Get an enum member based on its string representation.'''
+        for column in cls:
+            if column.value[-1] == s:
+                return column
+        raise ValueError(cls.__name__ + ' has no value matching "' + s + '"')
+
+    @classmethod
+    def from_value(cls, ch, id):
+        '''Get an enum member based on its channel and identifier.
+
+        Parameters
+        ----------
+        ch : int
+            The channel of the button.
+        id : int
+            The identifier of the button.
+
+        Returns
+        -------
+        Buttons
+            The enum member representing the button with the
+            given channel and identifier.
+
+        Raises
+        ------
+        ValueError
+            If no enum member is found with the given channel and identifier.
+        '''
+        for column in cls:
+            if column.value[0] == id and column.value[1] == ch:
+                return column
+        return None
+
+    @classmethod
+    def strings(cls):
+        '''Get an array of string representations of all enum members.'''
+        res = []
+        for column in cls:
+            res.append(column.value[-1])
+        return np.array(res)
+
+class hidParams(Enum):
+    '''
+    Enum class defining hidController parameters.
+    '''
+    TITLE = 'HID Controller'
+    DEVICE = 'Device'
+    REFRESH = 'Refresh'
+    OPEN = 'Open'
+    CLOSE = 'Close'
+
+    REMOVE = 'Remove Device'
+
+    def __str__(self):
+        '''
+        Return the last part of the enum value (Param name).
+        '''
+        return self.value.split('.')[-1]
+
+    def get_path(self):
+        '''
+        Return the full parameter path.
+        '''
+        return self.value.split('.')

microEye/utils/hid/utils.py

@@ -0,0 +1,58 @@
+import numpy as np
+
+
+def map_range(value, args):
+    '''
+    Map a value from one range to another.
+
+    ... (rest of the map_range function docstring)
+    '''
+    old_min, old_max, new_min, new_max = args
+    return (new_min +
+            (new_max - new_min) * (value - old_min) / (old_max - old_min))
+
+def dz_scaled_radial(stick_input, deadzone):
+    '''
+    Apply a scaled radial transformation with deadzone.
+
+    ... (rest of the dz_scaled_radial function docstring)
+    '''
+    input_magnitude = np.linalg.norm(stick_input)
+    if input_magnitude < deadzone:
+        return 0, 0
+    else:
+        input_normalized = stick_input / input_magnitude
+        retval = input_normalized * map_range(
+            input_magnitude, (deadzone, 1, 0, 1))
+        return retval[0], retval[1]
+
+def dz_sloped_scaled_axial(stick_input, deadzone, n=1):
+    '''
+    Apply a sloped scaled axial transformation with deadzone.
+
+    ... (rest of the dz_sloped_scaled_axial function docstring)
+    '''
+    x_val = 0
+    y_val = 0
+    deadzone_x = deadzone * np.power(abs(stick_input[1]), n)
+    deadzone_y = deadzone * np.power(abs(stick_input[0]), n)
+    sign = np.sign(stick_input)
+    if abs(stick_input[0]) > deadzone_x:
+        x_val = sign[0] * map_range(abs(stick_input[0]), (deadzone_x, 1, 0, 1))
+    if abs(stick_input[1]) > deadzone_y:
+        y_val = sign[1] * map_range(abs(stick_input[1]), (deadzone_y, 1, 0, 1))
+    return x_val, y_val
+
+def dz_hybrid(stick_input, deadzone):
+    '''
+    Apply a hybrid transformation with deadzone.
+
+    ... (rest of the dz_hybrid function docstring)
+    '''
+    input_magnitude = np.linalg.norm(stick_input)
+    if input_magnitude < deadzone:
+        return 0, 0
+
+    partial_output = dz_scaled_radial(stick_input, deadzone)
+
+    return partial_output

microEye/utils/labelled_slider.py

@@ -0,0 +1,134 @@
+from microEye.qt import Qt, QtWidgets, Signal
+
+
+class LabelledSlider(QtWidgets.QWidget):
+    '''
+    A custom widget representing a labeled slider with optional range labels.
+
+    Attributes:
+        finished (Signal): Signal emitted when editing is finished.
+        valueChanged (Signal): Signal emitted when value is changed.
+    '''
+
+    finished = Signal()
+    valueChanged = Signal(int)
+
+    def __init__(self, parent=None, show_range_labels=True, vrange=(0, 100), offset=1):
+        '''
+        Initialize the LabelledSlider widget.
+
+        Parameters
+        ----------
+        parent : QWidget, optional
+            Parent widget, by default None.
+        show_range_labels : bool, optional
+            Whether to show range labels, by default True.
+        '''
+        super().__init__(parent)
+        self._offset = offset
+        self.initUI(vrange)
+        self.showRangeLabels(show_range_labels)
+
+    def initUI(self, vrange: tuple[int, int]):
+        '''
+        Initialize the UI components of the widget.
+        '''
+        self.slider = QtWidgets.QSlider(
+            tickPosition=QtWidgets.QSlider.TickPosition.NoTicks,
+            orientation=Qt.Orientation.Horizontal,
+        )
+        self.slider.setMaximum(0)
+
+        self.label = QtWidgets.QSpinBox()
+        self.label.setSizePolicy(
+            QtWidgets.QSizePolicy.Policy.MinimumExpanding,
+            QtWidgets.QSizePolicy.Policy.Expanding,
+        )
+
+        self.label.valueChanged.connect(self.changeValue)
+        self.slider.valueChanged.connect(self.changeValue)
+        self.slider.sliderReleased.connect(lambda: self.finished.emit())
+        self.label.editingFinished.connect(lambda: self.finished.emit())
+
+        self.label_minimum = QtWidgets.QLabel()
+        self.label_maximum = QtWidgets.QLabel()
+
+        self.slider.rangeChanged.connect(
+            lambda min, max: self.label_minimum.setNum(vrange[0] + self._offset)
+        )
+        self.slider.rangeChanged.connect(
+            lambda min, max: self.label_maximum.setNum(vrange[1] + self._offset)
+        )
+
+        slider_hbox = QtWidgets.QHBoxLayout(self)
+        slider_hbox.setContentsMargins(0, 0, 0, 0)
+        slider_hbox.setSpacing(0)
+
+        slider_hbox.addWidget(self.label_minimum)
+        slider_hbox.addWidget(self.slider)
+        slider_hbox.addWidget(self.label_maximum)
+        slider_hbox.addWidget(self.label)
+
+        self.setRange(*vrange)
+
+    def setRange(self, min: int, max: int):
+        '''
+        Set the range for the slider.
+
+        Parameters
+        ----------
+        min : int
+            Minimum value of the range.
+        max : int
+            Maximum value of the range.
+        '''
+        self.label.setMinimum(min + self._offset)
+        self.label.setMaximum(max + self._offset)
+        self.slider.setMinimum(min)
+        self.slider.setMaximum(max)
+
+    def changeValue(self, value):
+        '''
+        Change the value of the slider.
+
+        Parameters
+        ----------
+        value : int
+            New value of the slider.
+        '''
+        self.label.blockSignals(True)
+        self.slider.blockSignals(True)
+
+        if self.sender() is self.slider:
+            self.label.setValue(value + self._offset)
+        else:
+            self.slider.setValue(value - self._offset)
+
+        self.label.blockSignals(False)
+        self.slider.blockSignals(False)
+
+        self.valueChanged.emit(value)
+
+    def showRangeLabels(self, show=True):
+        '''
+        Show or hide the range labels.
+
+        Parameters
+        ----------
+        show : bool, optional
+            Whether to show range labels, by default True.
+        '''
+        self.label_minimum.setVisible(show)
+        self.label_maximum.setVisible(show)
+
+    def value(self):
+        return self.slider.value()
+
+    def maximum(self):
+        return self.slider.maximum()
+
+    def minimum(self):
+        return self.slider.minimum()
+
+    def setValue(self, value: int):
+        return self.slider.setValue(value)