#include <Leap.h>
Public Types | |
| enum | State { STATE_INVALID = -1, STATE_START = 1, STATE_UPDATE = 2, STATE_STOP = 3 } |
| enum | Type { TYPE_INVALID = -1, TYPE_SWIPE = 1, TYPE_CIRCLE = 4, TYPE_SCREEN_TAP = 5, TYPE_KEY_TAP = 6 } |
Public Member Functions | |
| def | __eq__ |
| def | __init__ |
| def | __ne__ |
| def | __str__ |
| LEAP_EXPORT int64_t | duration () const |
| LEAP_EXPORT float | durationSeconds () const |
| LEAP_EXPORT Frame | frame () const |
| Gesture (GestureImplementation *) | |
| LEAP_EXPORT | Gesture () |
| LEAP_EXPORT | Gesture (const Gesture &rhs) |
| LEAP_EXPORT HandList | hands () const |
| LEAP_EXPORT int32_t | id () const |
| LEAP_EXPORT bool | isValid () const |
| LEAP_EXPORT bool | operator!= (const Gesture &rhs) const |
| LEAP_EXPORT bool | operator== (const Gesture &rhs) const |
| LEAP_EXPORT PointableList | pointables () const |
| LEAP_EXPORT State | state () const |
| std::string | toString () const |
| LEAP_EXPORT Type | type () const |
Static Public Member Functions | |
| static LEAP_EXPORT const Gesture & | invalid () |
Public Attributes | |
| this | |
Static Public Attributes | |
| tuple | duration = _swig_property(LeapPython.Gesture_duration_get) |
| tuple | duration_seconds = _swig_property(LeapPython.Gesture_duration_seconds_get) |
| tuple | frame = _swig_property(LeapPython.Gesture_frame_get) |
| tuple | hands = _swig_property(LeapPython.Gesture_hands_get) |
| tuple | id = _swig_property(LeapPython.Gesture_id_get) |
| tuple | is_valid = _swig_property(LeapPython.Gesture_is_valid_get) |
| tuple | pointables = _swig_property(LeapPython.Gesture_pointables_get) |
| tuple | state = _swig_property(LeapPython.Gesture_state_get) |
| STATE_INVALID = LeapPython.Gesture_STATE_INVALID | |
| STATE_START = LeapPython.Gesture_STATE_START | |
| STATE_STOP = LeapPython.Gesture_STATE_STOP | |
| STATE_UPDATE = LeapPython.Gesture_STATE_UPDATE | |
| tuple | type = _swig_property(LeapPython.Gesture_type_get) |
| TYPE_CIRCLE = LeapPython.Gesture_TYPE_CIRCLE | |
| TYPE_INVALID = LeapPython.Gesture_TYPE_INVALID | |
| TYPE_KEY_TAP = LeapPython.Gesture_TYPE_KEY_TAP | |
| TYPE_SCREEN_TAP = LeapPython.Gesture_TYPE_SCREEN_TAP | |
| TYPE_SWIPE = LeapPython.Gesture_TYPE_SWIPE | |
Private Member Functions | |
| LEAP_EXPORT const char * | toCString () const |
Static Private Attributes | |
| tuple | __getattr__ = lambdaself,name:_swig_getattr(self, Gesture, name) |
| __repr__ = _swig_repr | |
| tuple | __setattr__ = lambdaself,name,value:_swig_setattr(self, Gesture, name, value) |
| __swig_destroy__ = LeapPython.delete_Gesture | |
| dictionary | __swig_getmethods__ = {} |
| dictionary | __swig_setmethods__ = {} |
Detailed Description
The Gesture class represents a recognized movement by the user.
The Leap Motion Controller watches the activity within its field of view for certain movement patterns typical of a user gesture or command. For example, a movement from side to side with the hand can indicate a swipe gesture, while a finger poking forward can indicate a screen tap gesture.
When the Leap Motion software recognizes a gesture, it assigns an ID and adds a Gesture object to the frame gesture list. For continuous gestures, which occur over many frames, the Leap Motion software updates the gesture by adding a Gesture object having the same ID and updated properties in each subsequent frame.
**Important:** Recognition for each type of gesture must be enabled using the Controller::enableGesture() function; otherwise **no gestures are recognized or reported**.
Subclasses of Gesture define the properties for the specific movement patterns recognized by the Leap Motion software.
The Gesture subclasses include:
**CircleGesture** -- A circular movement by a finger.
**SwipeGesture** -- A straight line movement by the hand with fingers extended.
**ScreenTapGesture** -- A forward tapping movement by a finger.
**KeyTapGesture** -- A downward tapping movement by a finger.
Circle and swipe gestures are continuous and these objects can have a state of start, update, and stop.
The screen tap gesture is a discrete gesture. The Leap Motion software only creates a single ScreenTapGesture object for each tap and it always has a stop state.
Get valid Gesture instances from a Frame object. You can get a list of gestures with the Frame::gestures() method. You can get a list of gestures since a specified frame with the `Frame::gestures(const Frame&)` method. You can also use the `Frame::gesture()` method to find a gesture in the current frame using an ID value obtained in a previous frame.
Gesture objects can be invalid. For example, when you get a gesture by ID using `Frame::gesture()`, and there is no gesture with that ID in the current frame, then `gesture()` returns an Invalid Gesture object (rather than a null value). Always check object validity in situations where a gesture might be invalid.
The following keys can be used with the Config class to configure the gesture recognizer:
==================================== ========== ============= ======= Key string Value type Default value Units ==================================== ========== ============= ======= Gesture.Circle.MinRadius float 5.0 mm Gesture.Circle.MinArc float 1.5 * pi radians Gesture.Swipe.MinLength float 150 mm Gesture.Swipe.MinVelocity float 1000 mm/s Gesture.KeyTap.MinDownVelocity float 50 mm/s Gesture.KeyTap.HistorySeconds float 0.1 s Gesture.KeyTap.MinDistance float 3.0 mm Gesture.ScreenTap.MinForwardVelocity float 50 mm/s Gesture.ScreenTap.HistorySeconds float 0.1 s Gesture.ScreenTap.MinDistance float 5.0 mm ==================================== ========== ============= =======
- Since:
- 1.0
Member Enumeration Documentation
| enum Leap::Gesture::State |
The possible gesture states.
- Since:
- 1.0
| enum Leap::Gesture::Type |
The supported types of gestures.
- Since:
- 1.0
- Enumerator:
Constructor & Destructor Documentation
| Leap::Gesture::Gesture | ( | GestureImplementation * | ) |
| LEAP_EXPORT Leap::Gesture::Gesture | ( | const Gesture & | rhs | ) |
| def Leap::Gesture::__init__ | ( | self, | |
| args | |||
| ) |
Reimplemented in Leap::KeyTapGesture, Leap::ScreenTapGesture, Leap::CircleGesture, and Leap::SwipeGesture.
Member Function Documentation
| def Leap::Gesture::__eq__ | ( | self, | |
| rhs | |||
| ) |
| def Leap::Gesture::__ne__ | ( | self, | |
| rhs | |||
| ) |
| def Leap::Gesture::__str__ | ( | self | ) |
| LEAP_EXPORT int64_t Leap::Gesture::duration | ( | ) | const |
The elapsed duration of the recognized movement up to the frame containing this Gesture object, in microseconds.
The duration reported for the first Gesture in the sequence (with the STATE_START state) will typically be a small positive number since the movement must progress far enough for the Leap Motion software to recognize it as an intentional gesture.
- Returns:
- int64_t the elapsed duration in microseconds.
- Since:
- 1.0
| LEAP_EXPORT float Leap::Gesture::durationSeconds | ( | ) | const |
The elapsed duration in seconds.
- See also:
- duration()
- Returns:
- float the elapsed duration in seconds.
- Since:
- 1.0
| LEAP_EXPORT Frame Leap::Gesture::frame | ( | ) | const |
| LEAP_EXPORT HandList Leap::Gesture::hands | ( | ) | const |
| LEAP_EXPORT int32_t Leap::Gesture::id | ( | ) | const |
The gesture ID.
All Gesture objects belonging to the same recognized movement share the same ID value. Use the ID value with the Frame::gesture() method to find updates related to this Gesture object in subsequent frames.
- Returns:
- int32_t the ID of this Gesture.
- Since:
- 1.0
| static LEAP_EXPORT const Gesture& Leap::Gesture::invalid | ( | ) | [static] |
Returns an invalid Gesture object.
You can use the instance returned by this function in comparisons testing whether a given Gesture instance is valid or invalid. (You can also use the Gesture::isValid() function.)
- Returns:
- The invalid Gesture instance.
- Since:
- 1.0
| LEAP_EXPORT bool Leap::Gesture::isValid | ( | ) | const |
Reports whether this Gesture instance represents a valid Gesture.
An invalid Gesture object does not represent a snapshot of a recognized movement. Invalid Gesture objects are returned when a valid object cannot be provided. For example, when you get an gesture by ID using Frame::gesture(), and there is no gesture with that ID in the current frame, then gesture() returns an Invalid Gesture object (rather than a null value). Always check object validity in situations where an gesture might be invalid.
- Returns:
- bool True, if this is a valid Gesture instance; false, otherwise.
- Since:
- 1.0
| LEAP_EXPORT bool Leap::Gesture::operator!= | ( | const Gesture & | rhs | ) | const |
Compare Gesture object inequality.
Two Gestures are equal only if they represent the same snapshot of the same recognized movement.
- Since:
- 1.0
| LEAP_EXPORT bool Leap::Gesture::operator== | ( | const Gesture & | rhs | ) | const |
Compare Gesture object equality.
Two Gestures are equal if they represent the same snapshot of the same recognized movement.
- Since:
- 1.0
The list of fingers and tools associated with this Gesture, if any.
If no Pointable objects are related to this gesture, the list is empty.
- Returns:
- PointableList the list of related Pointable objects.
- Since:
- 1.0
| LEAP_EXPORT State Leap::Gesture::state | ( | ) | const |
The gesture state.
Recognized movements occur over time and have a beginning, a middle, and an end. The 'state()' attribute reports where in that sequence this Gesture object falls.
- Returns:
- Gesture::State A value from the Gesture::State enumeration.
- Since:
- 1.0
| LEAP_EXPORT const char* Leap::Gesture::toCString | ( | ) | const [private] |
| std::string Leap::Gesture::toString | ( | ) | const [inline] |
| LEAP_EXPORT Type Leap::Gesture::type | ( | ) | const |
Member Data Documentation
tuple Leap::Gesture::__getattr__ = lambdaself,name:_swig_getattr(self, Gesture, name) [static, private] |
Reimplemented from Leap::Interface.
Reimplemented in Leap::KeyTapGesture, Leap::ScreenTapGesture, Leap::CircleGesture, and Leap::SwipeGesture.
Leap::Gesture::__repr__ = _swig_repr [static, private] |
Reimplemented in Leap::KeyTapGesture, Leap::ScreenTapGesture, Leap::CircleGesture, and Leap::SwipeGesture.
tuple Leap::Gesture::__setattr__ = lambdaself,name,value:_swig_setattr(self, Gesture, name, value) [static, private] |
Reimplemented from Leap::Interface.
Reimplemented in Leap::KeyTapGesture, Leap::ScreenTapGesture, Leap::CircleGesture, and Leap::SwipeGesture.
Leap::Gesture::__swig_destroy__ = LeapPython.delete_Gesture [static, private] |
Reimplemented in Leap::KeyTapGesture, Leap::ScreenTapGesture, Leap::CircleGesture, and Leap::SwipeGesture.
dictionary Leap::Gesture::__swig_getmethods__ = {} [static, private] |
Reimplemented from Leap::Interface.
Reimplemented in Leap::KeyTapGesture, Leap::ScreenTapGesture, Leap::CircleGesture, and Leap::SwipeGesture.
dictionary Leap::Gesture::__swig_setmethods__ = {} [static, private] |
Reimplemented from Leap::Interface.
Reimplemented in Leap::KeyTapGesture, Leap::ScreenTapGesture, Leap::CircleGesture, and Leap::SwipeGesture.
tuple Leap::Gesture::duration = _swig_property(LeapPython.Gesture_duration_get) [static] |
tuple Leap::Gesture::duration_seconds = _swig_property(LeapPython.Gesture_duration_seconds_get) [static] |
tuple Leap::Gesture::frame = _swig_property(LeapPython.Gesture_frame_get) [static] |
tuple Leap::Gesture::hands = _swig_property(LeapPython.Gesture_hands_get) [static] |
tuple Leap::Gesture::id = _swig_property(LeapPython.Gesture_id_get) [static] |
tuple Leap::Gesture::is_valid = _swig_property(LeapPython.Gesture_is_valid_get) [static] |
tuple Leap::Gesture::pointables = _swig_property(LeapPython.Gesture_pointables_get) [static] |
tuple Leap::Gesture::state = _swig_property(LeapPython.Gesture_state_get) [static] |
Leap::Gesture::STATE_INVALID = LeapPython.Gesture_STATE_INVALID [static] |
Leap::Gesture::STATE_START = LeapPython.Gesture_STATE_START [static] |
Leap::Gesture::STATE_STOP = LeapPython.Gesture_STATE_STOP [static] |
Leap::Gesture::STATE_UPDATE = LeapPython.Gesture_STATE_UPDATE [static] |
Reimplemented in Leap::KeyTapGesture, Leap::ScreenTapGesture, Leap::CircleGesture, and Leap::SwipeGesture.
tuple Leap::Gesture::type = _swig_property(LeapPython.Gesture_type_get) [static] |
Leap::Gesture::TYPE_CIRCLE = LeapPython.Gesture_TYPE_CIRCLE [static] |
Leap::Gesture::TYPE_INVALID = LeapPython.Gesture_TYPE_INVALID [static] |
Leap::Gesture::TYPE_KEY_TAP = LeapPython.Gesture_TYPE_KEY_TAP [static] |
Leap::Gesture::TYPE_SCREEN_TAP = LeapPython.Gesture_TYPE_SCREEN_TAP [static] |
Leap::Gesture::TYPE_SWIPE = LeapPython.Gesture_TYPE_SWIPE [static] |
The documentation for this class was generated from the following files: