Part 3: Output System

This implementation demonstrates the creation of an Output System for the Virtual Hand Interface. It processes predictions (classification or regression) and communicates them to the visual interface.

Steps:

1. Step 1: Class Initialization and Validation

   • Ensures the correct visual interface is selected and initializes helper objects.

2. Step 2: Processing Predictions

   • Converts classification and regression predictions into an appropriate format.

3. Step 3: Sending Predictions

   • Sends processed predictions to the visual interface via output signals.

4. Step 4: Handling Close Events

   • Cleans up resources and handles the exit process gracefully.

Predefined Mapping for Classification Predictions

This dictionary maps classification labels to their respective predefined output strings for the Virtual Hand Interface.

PREDICTION2INTERFACE_MAP = {
    -1: "Rejected Sample",
    0: "[0, 0, 0, 0, 0, 0, 0, 0, 0]",
    1: "[0, 0, 1, 0, 0, 0, 0, 0, 0]",
    2: "[1, 0, 0, 0, 0, 0, 0, 0, 0]",
    3: "[0, 0, 0, 1, 0, 0, 0, 0, 0]",
    4: "[0, 0, 0, 0, 1, 0, 0, 0, 0]",
    5: "[0, 0, 0, 0, 0, 1, 0, 0, 0]",
    6: "[0.67, 1, 1, 1, 1, 1, 0, 0, 0]",
    7: "[0.45, 1, 0.6, 0, 0, 0, 0, 0, 0]",
    8: "[0.55, 1, 0.65, 0.65, 0, 0, 0, 0, 0]",
}

Step 1: Class Initialization

This step ensures that the selected visual interface is the Virtual Hand Interface. It also establishes the connection for outgoing signals using the main window.

Output System Initialization

from typing import Any

from myogestic.gui.widgets.logger import LoggerLevel
from myogestic.gui.widgets.templates.output_system import OutputSystemTemplate
from myogestic.gui.widgets.visual_interfaces.virtual_hand_interface.setup_interface import (
    VirtualHandInterface_SetupInterface,
)

PREDICTION2INTERFACE_MAP = {
    -1: "Rejected Sample",
    0: "[0, 0, 0, 0, 0, 0, 0, 0, 0]",
    1: "[0, 0, 1, 0, 0, 0, 0, 0, 0]",
    2: "[1, 0, 0, 0, 0, 0, 0, 0, 0]",
    3: "[0, 0, 0, 1, 0, 0, 0, 0, 0]",
    4: "[0, 0, 0, 0, 1, 0, 0, 0, 0]",
    5: "[0, 0, 0, 0, 0, 1, 0, 0, 0]",
    6: "[0.67, 1, 1, 1, 1, 1, 0, 0, 0]",
    7: "[0.45, 1, 0.6, 0, 0, 0, 0, 0, 0]",
    8: "[0.55, 1, 0.65, 0.65, 0, 0, 0, 0, 0]",
}


class VirtualHandInterface_OutputSystem(OutputSystemTemplate):
    """Output system for the Virtual Hand Interface.

    Parameters
    ----------
    main_window : MainWindow
        The main window object.
    prediction_is_classification : bool
        Whether the prediction is a classification or regression.
    """

    def __init__(self, main_window, prediction_is_classification: bool) -> None:
        super().__init__(main_window, prediction_is_classification)

        if self._main_window.selected_visual_interface is None:
            self._main_window.logger.print(
                "No visual interface selected.", level=LoggerLevel.ERROR
            )
            raise ValueError("No visual interface selected.")

        if not isinstance(
            self._main_window.selected_visual_interface.setup_interface_ui,
            VirtualHandInterface_SetupInterface,
        ):
            raise ValueError(
                "The virtual interface must be the Virtual Hand Interface."
                f"Got {type(self._main_window.selected_visual_interface)}."
            )

        self._outgoing_message_signal = (
            self._main_window.selected_visual_interface.outgoing_message_signal
        )

Step 2: Processing Predictions

This step defines how predictions (either classification or regression) are processed into the appropriate format that can be used by the Virtual Hand Interface.

Processing Classification Predictions - Convert classification predictions into the required format to send them to the visual interface.

    def _process_prediction__classification(self, prediction: Any) -> bytes:
        """Process the prediction for classification."""
        return PREDICTION2INTERFACE_MAP[prediction].encode("utf-8")

Processing Regression Predictions - Convert regression predictions into the required format to send them to the visual interface.

    def _process_prediction__regression(self, prediction: Any) -> bytes:
        """Process the prediction for regression."""
        return str(prediction).encode("utf-8")

Step 3: Sending Predictions

This step sends the processed predictions (after formatting them into bytes) to the connected visual interface via the outgoing signal.

Sending Predictions - Send the processed prediction to the visual interface.

    def send_prediction(self, prediction: Any) -> None:
        """Send the prediction to the visual interface."""
        self._outgoing_message_signal.emit(self.process_prediction(prediction))

Step 4: Handling Close Events

This step handles the cleanup process when the Output System is closed. It logs the closure and ensures that resources are properly released.

Handling Close Events - Clean up resources and handle the exit process gracefully. If needed, this method can be extended to include additional cleanup steps.

    def close_event(self, event):
        """Close the output system."""
        pass

Estimated memory usage: 528 MB