RCAIDE-GUI 1.0.0__py3-none-any.whl

common_widgets/__init__.py

@@ -0,0 +1,6 @@
+from .color import Color
+from .unit_picker_widget import UnitPickerWidget
+from .data_entry_widget import DataEntryWidget
+from .image_widget import ImageWidget
+from .animated_toggle import AnimatedToggle
+

common_widgets/animated_toggle.py

@@ -0,0 +1,141 @@
+# RCAIDE_GUI/common_widgets/animated_toggle.py
+
+# PyQt imports
+from PyQt6.QtCore import (
+    Qt, QSize, QPoint, QPointF, QRectF,
+    QEasingCurve, QPropertyAnimation, QSequentialAnimationGroup,
+    pyqtSlot, pyqtProperty)
+from PyQt6.QtGui import QColor, QBrush, QPaintEvent, QPen, QPainter
+from PyQt6.QtWidgets import QCheckBox
+
+# ------------------------------------------------------------------------------
+# Animated Toggle Widget
+# ------------------------------------------------------------------------------
+class AnimatedToggle(QCheckBox):
+    _transparent_pen = QPen(Qt.GlobalColor.transparent)
+    _light_grey_pen = QPen(Qt.GlobalColor.lightGray)
+
+    def __init__(self,
+                 parent=None,
+                 bar_color=Qt.GlobalColor.gray,
+                 checked_color="#00B0FF",
+                 handle_color=Qt.GlobalColor.white,
+                 pulse_unchecked_color="#44999999",
+                 pulse_checked_color="#4400B0EE"
+                 ):
+        super().__init__(parent)
+
+        # Save our properties on the object via self, so we can access them later
+        # in the paintEvent.
+        self._bar_brush = QBrush(bar_color)
+        self._bar_checked_brush = QBrush(QColor(checked_color).lighter())
+
+        self._handle_brush = QBrush(handle_color)
+        self._handle_checked_brush = QBrush(QColor(checked_color))
+
+        self._pulse_unchecked_animation = QBrush(QColor(pulse_unchecked_color))
+        self._pulse_checked_animation = QBrush(QColor(pulse_checked_color))
+
+        # Setup the rest of the widget.
+        self.setContentsMargins(8, 0, 8, 0)
+        self._handle_position = 0
+
+        self._pulse_radius = 0
+
+        self.animation = QPropertyAnimation(self, b"handle_position", self)
+        self.animation.setEasingCurve(QEasingCurve.Type.InOutCubic)
+        self.animation.setDuration(200)  # time in ms
+
+        self.pulse_anim = QPropertyAnimation(self, b"pulse_radius", self)
+        self.pulse_anim.setDuration(350)  # time in ms
+        self.pulse_anim.setStartValue(10)
+        self.pulse_anim.setEndValue(20)
+
+        self.animations_group = QSequentialAnimationGroup()
+        self.animations_group.addAnimation(self.animation)
+        self.animations_group.addAnimation(self.pulse_anim)
+
+        self.stateChanged.connect(self.setup_animation)
+
+    def sizeHint(self):
+        return QSize(58, 45)
+
+    def hitButton(self, pos: QPoint):
+        return self.contentsRect().contains(pos)
+
+    @pyqtSlot(int)
+    def setup_animation(self, value):
+        self.animations_group.stop()
+        if value:
+            self.animation.setEndValue(1)
+        else:
+            self.animation.setEndValue(0)
+        self.animations_group.start()
+
+    def paintEvent(self, e: QPaintEvent):
+
+        contRect = self.contentsRect()
+        handleRadius = round(0.24 * contRect.height())
+
+        p = QPainter(self)
+        p.setRenderHint(QPainter.RenderHint.Antialiasing)
+
+        p.setPen(self._transparent_pen)
+        barRect = QRectF(
+            0, 0,
+            contRect.width() - handleRadius, 0.40 * contRect.height()
+        )
+        barRect.moveCenter(QPointF(contRect.center()))
+        rounding = barRect.height() / 2
+
+        # the handle will move along this line
+        trailLength = contRect.width() - 2 * handleRadius
+
+        xPos = contRect.x() + handleRadius + trailLength * self._handle_position
+
+        if self.pulse_anim.state() == QPropertyAnimation.State.Running:
+            p.setBrush(
+                self._pulse_checked_animation if
+                self.isChecked() else self._pulse_unchecked_animation)
+            p.drawEllipse(QPointF(xPos, barRect.center().y()),
+                          self._pulse_radius, self._pulse_radius)
+
+        if self.isChecked():
+            p.setBrush(self._bar_checked_brush)
+            p.drawRoundedRect(barRect, rounding, rounding)
+            p.setBrush(self._handle_checked_brush)
+
+        else:
+            p.setBrush(self._bar_brush)
+            p.drawRoundedRect(barRect, rounding, rounding)
+            p.setPen(self._light_grey_pen)
+            p.setBrush(self._handle_brush)
+
+        p.drawEllipse(
+            QPointF(xPos, barRect.center().y()),
+            handleRadius, handleRadius)
+
+        p.end()
+
+    @pyqtProperty(float)
+    def handle_position(self):
+        return self._handle_position
+
+    @handle_position.setter
+    def handle_position(self, pos):
+        """change the property
+        we need to trigger QWidget.update() method, either by:
+            1- calling it here [ what we doing ].
+            2- connecting the QPropertyAnimation.valueChanged() signal to it.
+        """
+        self._handle_position = pos
+        self.update()
+
+    @pyqtProperty(float)
+    def pulse_radius(self):
+        return self._pulse_radius
+
+    @pulse_radius.setter
+    def pulse_radius(self, pos):
+        self._pulse_radius = pos
+        self.update()

common_widgets/color.py

@@ -0,0 +1,17 @@
+# RCAIDE_GUI/tabs/visualize_geometry/features/axes_gizmo.py
+
+# Python imports
+from PyQt6.QtGui import QPalette, QColor
+from PyQt6.QtWidgets import QWidget
+
+# ------------------------------------------------------------------------------
+# Color Widget
+# ------------------------------------------------------------------------------
+class Color(QWidget):
+    def __init__(self, color):
+        super(Color, self).__init__()
+        self.setAutoFillBackground(True)
+
+        palette = self.palette()
+        palette.setColor(QPalette.ColorRole.Window, QColor(color))
+        self.setPalette(palette)

common_widgets/data_entry_widget.py

@@ -0,0 +1,337 @@
+# RCAIDE_GUI/tabs/visualize_geometry/features/axes_gizmo.py
+
+# Created: M Clarke, LEADS, 2024
+# Python imports
+import ast
+
+from PyQt6.QtCore import Qt, pyqtSignal
+from PyQt6.QtGui import QDoubleValidator
+from PyQt6.QtWidgets import QLineEdit, QLabel, QGridLayout, QWidget, QSizePolicy, QSpacerItem, QCheckBox, QHBoxLayout, \
+    QVBoxLayout
+
+from utilities import Units
+from common_widgets import UnitPickerWidget
+
+# ------------------------------------------------------------------------------
+# Data Entry Widget
+# ------------------------------------------------------------------------------
+class DataEntryWidget(QWidget):
+    # Emitted when the user finishes editing any field or changes a unit.
+    # Safe to connect to save_data — does NOT fire during programmatic load_data calls.
+    data_changed = pyqtSignal()
+
+    def __init__(self, data_units_labels, num_cols=2):
+        super(DataEntryWidget, self).__init__()
+        self.data_units_labels = data_units_labels
+        self.data_fields = {}
+
+        self.init_ui(num_cols)
+
+    def init_ui(self, num_cols):
+        grid_layout = QGridLayout()
+        row, col = 0, 0
+        for label in self.data_units_labels:
+            grid_layout.setColumnStretch(col * 4 + 1, 1)
+
+            if label[1] != Units.Heading:
+                grid_layout.addWidget(QLabel(label[0] + ":"), row, col * 4)
+            if label[1] == Units.Boolean:
+                check_box = QCheckBox(self)
+                check_box.setChecked(False)
+                check_box.stateChanged.connect(lambda _: self.data_changed.emit())
+                grid_layout.addWidget(check_box, row, col * 4 + 1, 1, 2)
+                self.data_fields[label[0]] = check_box
+            elif label[1] == Units.Position:
+                x_line_edit = QLineEdit(self)
+                y_line_edit = QLineEdit(self)
+                z_line_edit = QLineEdit(self)
+
+                x_line_edit.setValidator(QDoubleValidator())
+                y_line_edit.setValidator(QDoubleValidator())
+                z_line_edit.setValidator(QDoubleValidator())
+
+                unit_picker = UnitPickerWidget(Units.Length)
+                unit_picker.on_change_callback = self._make_unit_change_handler(
+                    unit_picker, x_line_edit, y_line_edit, z_line_edit
+                )
+                # Also emit data_changed when unit changes (fires only on user action,
+                # not during load_data, because UnitPickerWidget._suppress_callback guards it).
+                _conv_cb = unit_picker.on_change_callback
+                unit_picker.on_change_callback = lambda p, n, _cb=_conv_cb: (_cb(p, n), self.data_changed.emit())
+                unit_picker.setFixedWidth(80)
+
+                layout = QHBoxLayout()
+                layout.addWidget(x_line_edit)
+                layout.addWidget(y_line_edit)
+                layout.addWidget(z_line_edit)
+
+                x_line_edit.setMinimumSize(50, 0)
+                y_line_edit.setMinimumSize(50, 0)
+                z_line_edit.setMinimumSize(50, 0)
+
+                # editingFinished fires on Enter/Tab — not on programmatic setText.
+                x_line_edit.editingFinished.connect(self.data_changed)
+                y_line_edit.editingFinished.connect(self.data_changed)
+                z_line_edit.editingFinished.connect(self.data_changed)
+
+                grid_layout.addLayout(layout, row, col * 4 + 1, 1, 2)
+                grid_layout.addWidget(
+                    unit_picker, row, col * 4 + 3, alignment=Qt.AlignmentFlag.AlignLeft)
+
+                self.data_fields[label[0]] = (
+                    x_line_edit, y_line_edit, z_line_edit, unit_picker)
+            elif label[1] == Units.Heading:
+                row += 1 if col != 0 else 0
+                layout = QHBoxLayout()
+                heading_layout = QVBoxLayout()
+                heading_label = QLabel(label[0])
+                font = heading_label.font()
+                font.setBold(True)
+                font.setUnderline(True)
+                heading_label.setFont(font)
+                heading_layout.addWidget(heading_label)
+                layout.addLayout(heading_layout)
+                grid_layout.addLayout(layout, row, 0, 1, 4)
+                col = num_cols - 1
+                self.data_fields[label[0]] = ()
+            else:
+                line_edit = QLineEdit(self)
+                # Inertia tensors are entered as list/matrix text, not scalar floats.
+                if label[1] != Units.Intertia:
+                    line_edit.setValidator(QDoubleValidator())
+                line_edit.setMinimumWidth(150)
+
+                unit_picker = UnitPickerWidget(label[1])
+                unit_picker.on_change_callback = self._make_unit_change_handler(
+                    unit_picker, line_edit
+                )
+                _conv_cb = unit_picker.on_change_callback
+                unit_picker.on_change_callback = lambda p, n, _cb=_conv_cb: (_cb(p, n), self.data_changed.emit())
+                unit_picker.setFixedWidth(80)
+
+                line_edit.editingFinished.connect(self.data_changed)
+
+                grid_layout.addWidget(line_edit, row, col * 4 + 1, 1, 2)
+                grid_layout.addItem(QSpacerItem(0, 0, QSizePolicy.Policy.Expanding, QSizePolicy.Policy.Minimum), row,
+                                    col * 4 + 2)
+                grid_layout.addWidget(
+                    unit_picker, row, col * 4 + 3, alignment=Qt.AlignmentFlag.AlignLeft)
+
+                self.data_fields[label[0]] = (line_edit, unit_picker)
+
+            col = col + 1 if col < num_cols - 1 else 0
+            if col == 0:
+                row += 1
+                grid_layout.setRowStretch(row, 1)
+
+        grid_layout.setContentsMargins(0, 0, 0, 0)
+        self.setLayout(grid_layout)
+
+    @staticmethod
+    def _apply_unit_at(unit_picker, index, value):
+        return unit_picker.unit_list[index][1](value)
+
+    @staticmethod
+    def _display_value_from_si(unit_picker, index, si_value):
+        # Unit converters map display values into RCAIDE/base units; invert
+        # that linear conversion to show the same value in the selected unit.
+        converter = unit_picker.unit_list[index][1]
+        zero = converter(0.0)
+        one = converter(1.0)
+        scale = one - zero
+        if scale == 0:
+            return si_value
+        return (si_value - zero) / scale
+
+    @staticmethod
+    def _format_converted_value(value):
+        return f"{value:.15g}"
+
+    @staticmethod
+    def _parse_list_value(text):
+        # Use literal_eval so list-like fields become Python lists without eval.
+        value = ast.literal_eval(text)
+        if not isinstance(value, list):
+            raise ValueError(f"Expected a list value, got {type(value).__name__}")
+        return value
+
+    def _make_unit_change_handler(self, unit_picker, *line_edits):
+        def convert_display_values(previous_index, new_index):
+            for line_edit in line_edits:
+                text = line_edit.text()
+                if not text:
+                    continue
+
+                try:
+                    old_display_value = float(text)
+                except ValueError:
+                    continue
+
+                # Preserve the stored physical value while changing only how
+                # the current text is displayed, e.g. radians <-> degrees.
+                si_value = self._apply_unit_at(
+                    unit_picker, previous_index, old_display_value
+                )
+                new_display_value = self._display_value_from_si(
+                    unit_picker, new_index, si_value
+                )
+                line_edit.setText(self._format_converted_value(new_display_value))
+
+        return convert_display_values
+
+    def clear_values(self):
+        for i, key in enumerate(self.data_fields.keys()):
+            if self.data_units_labels[i][1] == Units.Boolean:
+                self.data_fields[key].setChecked(False)
+            elif self.data_units_labels[i][1] == Units.Position:
+                self.data_fields[key][0].setText("")
+                self.data_fields[key][1].setText("")
+                self.data_fields[key][2].setText("")
+                self.data_fields[key][3].set_index(0)
+            elif self.data_units_labels[i][1] == Units.Heading:
+                continue
+            else:
+                self.data_fields[key][0].setText("")
+                self.data_fields[key][1].set_index(0)
+
+    def get_values(self):
+        data = {}
+        for i, label in enumerate(self.data_fields.keys()):
+            # Find corresponding unit
+            if self.data_units_labels[i][1] == Units.Boolean:
+                data_field = self.data_fields[label]
+                data[label] = (data_field.isChecked(), 0)
+            elif self.data_units_labels[i][1] == Units.Position:
+                data_field = self.data_fields[label]
+                x_line_edit, y_line_edit, z_line_edit, unit_picker = data_field
+
+                x_value = float(x_line_edit.text()
+                                ) if x_line_edit.text() else 0.0
+                y_value = float(y_line_edit.text()
+                                ) if y_line_edit.text() else 0.0
+                z_value = float(z_line_edit.text()
+                                ) if z_line_edit.text() else 0.0
+
+                data[label] = [[x_value, y_value,
+                               z_value]], unit_picker.current_index
+            elif self.data_units_labels[i][1] == Units.Heading:
+                continue
+            elif self.data_units_labels[i][1] == Units.Count:
+                data_field = self.data_fields[label]
+                line_edit, unit_picker = data_field
+                text = line_edit.text()
+                # Count fields should remain integers for RCAIDE.
+                value = int(text) if text else 0
+                data[label] = value, unit_picker.current_index
+            elif self.data_units_labels[i][1] == Units.Intertia:
+                data_field = self.data_fields[label]
+                line_edit, unit_picker = data_field
+                text = line_edit.text()
+                # Inertia is stored as a tensor/list, not a single scalar.
+                value = self._parse_list_value(text) if text else None
+                data[label] = value, unit_picker.current_index
+            else:
+                data_field = self.data_fields[label]
+                line_edit, unit_picker = data_field
+                text = line_edit.text()
+                # Most fields are numeric, but some Unitless fields are text labels.
+                try:
+                    value = float(text) if text else None
+                except ValueError:
+                    value = text
+                data[label] = value, unit_picker.current_index
+        return data
+
+    def get_values_si(self):
+        data = {}
+        for i, label in enumerate(self.data_fields.keys()):
+            if self.data_units_labels[i][1] == Units.Boolean:
+                data_field = self.data_fields[label]
+                data[label] = (data_field.isChecked(), 0)
+            elif self.data_units_labels[i][1] == Units.Position:
+                data_field = self.data_fields[label]
+                x_line_edit, y_line_edit, z_line_edit, unit_picker = data_field
+
+                x_value = float(x_line_edit.text()
+                                ) if x_line_edit.text() else 0.0
+                y_value = float(y_line_edit.text()
+                                ) if y_line_edit.text() else 0.0
+                z_value = float(z_line_edit.text()
+                                ) if z_line_edit.text() else 0.0
+
+                x_value, y_value, z_value = unit_picker.apply_unit(
+                    x_value), unit_picker.apply_unit(y_value), unit_picker.apply_unit(z_value)
+
+                data[label] = [[x_value, y_value,
+                               z_value]], unit_picker.current_index
+            elif self.data_units_labels[i][1] == Units.Heading:
+                continue
+            elif self.data_units_labels[i][1] == Units.Count:
+                data_field = self.data_fields[label]
+                line_edit, unit_picker = data_field
+                text = line_edit.text()
+                # Count fields should remain integers for RCAIDE.
+                value = int(text) if text else 0
+                data[label] = value, unit_picker.current_index
+            elif self.data_units_labels[i][1] == Units.Intertia:
+                data_field = self.data_fields[label]
+                line_edit, unit_picker = data_field
+                text = line_edit.text()
+                # Inertia is stored as a tensor/list, not a single scalar.
+                value = self._parse_list_value(text) if text else None
+                data[label] = value, unit_picker.current_index
+            else:
+                data_field = self.data_fields[label]
+                line_edit, unit_picker = data_field
+                text = line_edit.text()
+                # Numeric fields are converted to SI; text fields are preserved.
+                try:
+                    value = unit_picker.apply_unit(float(text)) if text else None
+                except ValueError:
+                    value = text
+                data[label] = value, unit_picker.current_index
+        return data
+
+    def load_data(self, data):
+        # Loading saved data should not trigger auto-save.
+        old_block_state = self.blockSignals(True)
+        try:
+            # Load each field based on its input type.
+            for i, label in enumerate(self.data_fields.keys()):
+                if self.data_units_labels[i][1] == Units.Boolean:
+                    # Checkbox field.
+                    self.data_fields[label].setChecked(data[label][0])
+                elif self.data_units_labels[i][1] == Units.Position:
+                    # Three coordinate boxes and one unit picker.
+                    x_line_edit, y_line_edit, z_line_edit, unit_picker = self.data_fields[label]
+                    value, index = data[label]
+                    # Unwrap [[x, y, z]] if needed.
+                    if isinstance(value, list) and value and isinstance(value[0], list):
+                        value = value[0]
+                    # Use origin if the saved value is invalid.
+                    elif not isinstance(value, list):
+                        value = [0, 0, 0]
+                    x_line_edit.setText(str(value[0]))
+                    y_line_edit.setText(str(value[1]))
+                    z_line_edit.setText(str(value[2]))
+                    unit_picker.set_index(index)
+                elif self.data_units_labels[i][1] == Units.Heading:
+                    # Heading label only.
+                    pass
+                else:
+                    # Normal value field and unit picker.
+                    line_edit, unit_picker = self.data_fields[label]
+                    value, index = data[label]
+                    # Show None as an empty field.
+                    line_edit.setText("" if value is None else str(value))
+                    unit_picker.set_index(index)
+        finally:
+            # Restore signal behavior.
+            self.blockSignals(old_block_state)
+    
+    # TODO implement mark_save and changed_since_save
+    def mark_save(self):
+        pass
+    
+    def changed_since_save(self):
+        pass

common_widgets/image_widget.py

@@ -0,0 +1,21 @@
+from PyQt6.QtCore import Qt
+from PyQt6.QtGui import QPixmap
+from PyQt6.QtWidgets import QLabel, QVBoxLayout, QWidget
+
+class ImageWidget(QWidget):
+    def __init__(self, image_file, w=256, h=256):
+        super().__init__()
+        
+        layout = QVBoxLayout()
+        
+        pixmap = QPixmap(image_file)
+        pixmap_scaled = pixmap.scaled(w, h, Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.FastTransformation)
+        label = QLabel()
+        label.setPixmap(pixmap_scaled)
+        # label.setScaledContents(True)
+        
+        layout.addWidget(label)
+        layout.setContentsMargins(0, 0, 0, 0)
+        
+        self.setLayout(layout)        
+    

common_widgets/unit_picker_widget.py

@@ -0,0 +1,48 @@
+from PyQt6.QtWidgets import QWidget, QVBoxLayout, QComboBox
+
+class UnitPickerWidget(QWidget):
+    def __init__(self, unit_class):
+        super(UnitPickerWidget, self).__init__()
+
+        self.unit_class = unit_class()
+        self.unit_list = self.unit_class.unit_list
+        self.current_index = 0
+        self.on_change_callback = None
+        self._suppress_callback = False
+
+        self.unit_picker = QComboBox()
+
+        self.init_ui()
+
+    def init_ui(self):
+        main_layout = QVBoxLayout()
+        self.setLayout(main_layout)
+
+        unit_name_list = [unit[0] for unit in self.unit_list]
+        self.unit_picker.addItems(unit_name_list)
+        self.unit_picker.setCurrentIndex(self.current_index)
+        self.unit_picker.currentIndexChanged.connect(self.on_unit_change)
+
+        main_layout.addWidget(self.unit_picker)
+        main_layout.setContentsMargins(0, 0, 0, 0)
+
+    def on_unit_change(self, index):
+        previous_index = self.current_index
+        # Programmatic loads set the combo box without rewriting field values;
+        # user-initiated changes ask the owning widget to convert the display.
+        if (
+            not self._suppress_callback
+            and self.on_change_callback is not None
+            and previous_index != index
+        ):
+            self.on_change_callback(previous_index, index)
+        self.current_index = index
+
+    def apply_unit(self, value):
+        return self.unit_list[self.current_index][1](value)
+
+    def set_index(self, index):
+        self.current_index = index
+        self._suppress_callback = True
+        self.unit_picker.setCurrentIndex(index)
+        self._suppress_callback = False