Gesture Recognition State Machine Segmentation
Find Innovative SolutionsGenerate Solutions
Solution Overview
Problem
Existing gesture recognition systems face difficulties in efficiently and reliably adding new gestures to existing code, particularly when dealing with multiple simultaneous touches, due to the complexity of state transitions and dependencies between different gestures.
Innovation Solution
A state machine approach is adopted for designing and writing gesture recognition algorithms, using linked state modules to process time series data from touch sensors, allowing for separate state machines to handle single and multi-touch gestures, thereby simplifying the addition of new gestures and improving reliability.
Engineering Contradictions & Design Principles
Engineering Contradiction Analysis
1Adaptability or versatility
If traditional gesture recognition code is used to handle multiple simultaneous touches, then gesture recognition capability is provided, but code complexity increases and reliability decreases when adding new gestures
Solution Approach 1:
The gesture recognition code is segmented into separate state machines, where each state machine handles a specific number of simultaneous touches (e.g., one state machine for single-touch gestures, another for multi-touch gestures). This segmentation isolates the complexity of different gesture types into independent modules, making the overall system more manageable and easier to extend with new gestures without increasing overall code complexity.
Solution Approach 2:
The patent introduces an intermediary layer (the state machine architecture) between the touch sensor input and the gesture recognition logic. This intermediary structure standardizes the processing of touch data through defined states and transitions, providing a uniform framework that simplifies the addition of new gestures while maintaining reliability across different gesture types.
2Adaptability or versatility
If traditional gesture recognition code is used to handle multiple simultaneous touches, then gesture recognition capability is provided, but reliability decreases when adding new gestures
Solution Approach 1:
By segmenting gesture recognition into separate state machines for different touch scenarios, each state machine can be independently tested and validated. This isolation ensures that adding new gestures to one state machine does not introduce errors into other gesture handling code, thereby maintaining or improving overall system reliability.
Solution Approach 2:
The state machine architecture provides a dynamic and flexible framework where new gestures can be added by defining new state transitions within existing state machines or by creating new state machines for new gesture types. This dynamic structure allows the system to adapt to new gestures in a controlled manner that preserves the reliability of existing gesture recognition functionality.
3Productivity
If separate state machines are used for single and multi-touch gestures, then code scalability is improved, but device complexity increases
Solution Approach 1:
The code is segmented into separate state machines for single-touch and multi-touch gestures, which initially appears to increase complexity. However, this segmentation dramatically improves scalability by allowing independent development, testing, and maintenance of each gesture type. The modular structure enables rapid addition of new gestures without requiring changes to the entire codebase, ultimately reducing the long-term complexity burden.
Solution Approach 2:
The state machine framework serves as a universal structure that can handle multiple types of gestures (single-touch, multi-touch, various gesture types) through a common architecture. This multi-functionality reduces the need for separate handling code for each gesture type, improving scalability while keeping the overall system structure manageable through code reuse and standardization.
Data Source
AI summary
A state machine gesture recognition algorithm for interpreting streams of coordinates received from a touch sensor. The gesture recognition code can be written in a high level language such as C and then compiled and embedded in a microcontroller chip, or CPU chip as desired. The gesture recognition code can be loaded into the same chip that interprets the touch signals from the touch sensor and generates the time series data, e.g. a microcontroller, or other programmable logic device such as a field programmable gate array.