#include <Leap.h>
Public Member Functions | |
| def | __eq__ |
| def | __init__ |
| def | __ne__ |
| def | __str__ |
| LEAP_EXPORT float | currentFramesPerSecond () const |
| def | deserialize |
| def | deserialize |
| void | deserialize (const std::string &str) |
| void | deserialize (const unsigned char *ptr, int length) |
| def | finger |
| LEAP_EXPORT Finger | finger (int32_t id) const |
| LEAP_EXPORT FingerList | fingers () const |
| Frame (FrameImplementation *) | |
| LEAP_EXPORT | Frame () |
| def | gesture |
| LEAP_EXPORT Gesture | gesture (int32_t id) const |
| def | gestures |
| LEAP_EXPORT GestureList | gestures () const |
| LEAP_EXPORT GestureList | gestures (const Frame &sinceFrame) const |
| def | hand |
| LEAP_EXPORT Hand | hand (int32_t id) const |
| LEAP_EXPORT HandList | hands () const |
| LEAP_EXPORT int64_t | id () const |
| LEAP_EXPORT ImageList | images () const |
| LEAP_EXPORT InteractionBox | interactionBox () const |
| LEAP_EXPORT bool | isValid () const |
| LEAP_EXPORT bool | operator!= (const Frame &) const |
| LEAP_EXPORT bool | operator== (const Frame &) const |
| def | pointable |
| LEAP_EXPORT Pointable | pointable (int32_t id) const |
| LEAP_EXPORT PointableList | pointables () const |
| def | rotation_angle |
| def | rotation_axis |
| def | rotation_matrix |
| def | rotation_probability |
| LEAP_EXPORT float | rotationAngle (const Frame &sinceFrame) const |
| LEAP_EXPORT float | rotationAngle (const Frame &sinceFrame, const Vector &axis) const |
| LEAP_EXPORT Vector | rotationAxis (const Frame &sinceFrame) const |
| LEAP_EXPORT Matrix | rotationMatrix (const Frame &sinceFrame) const |
| LEAP_EXPORT float | rotationProbability (const Frame &sinceFrame) const |
| def | scale_factor |
| def | scale_probability |
| LEAP_EXPORT float | scaleFactor (const Frame &sinceFrame) const |
| LEAP_EXPORT float | scaleProbability (const Frame &sinceFrame) const |
| def | serialize |
| def | serialize |
| std::string | serialize () const |
| void | serialize (unsigned char *ptr) const |
| int | serializeLength () const |
| LEAP_EXPORT int64_t | timestamp () const |
| def | tool |
| LEAP_EXPORT Tool | tool (int32_t id) const |
| LEAP_EXPORT ToolList | tools () const |
| std::string | toString () const |
| LEAP_EXPORT TrackedQuad | trackedQuad () const |
| def | translation |
| LEAP_EXPORT Vector | translation (const Frame &sinceFrame) const |
| def | translation_probability |
| LEAP_EXPORT float | translationProbability (const Frame &sinceFrame) const |
Static Public Member Functions | |
| static LEAP_EXPORT const Frame & | invalid () |
Public Attributes | |
| this | |
Static Public Attributes | |
| tuple | current_frames_per_second = _swig_property(LeapPython.Frame_current_frames_per_second_get) |
| tuple | fingers = _swig_property(LeapPython.Frame_fingers_get) |
| tuple | hands = _swig_property(LeapPython.Frame_hands_get) |
| tuple | id = _swig_property(LeapPython.Frame_id_get) |
| tuple | images = _swig_property(LeapPython.Frame_images_get) |
| tuple | interaction_box = _swig_property(LeapPython.Frame_interaction_box_get) |
| tuple | is_valid = _swig_property(LeapPython.Frame_is_valid_get) |
| tuple | pointables = _swig_property(LeapPython.Frame_pointables_get) |
| tuple | serialize_length = _swig_property(LeapPython.Frame_serialize_length_get) |
| tuple | timestamp = _swig_property(LeapPython.Frame_timestamp_get) |
| tuple | tools = _swig_property(LeapPython.Frame_tools_get) |
| tuple | tracked_quad = _swig_property(LeapPython.Frame_tracked_quad_get) |
Private Member Functions | |
| LEAP_EXPORT void | deserializeCString (const char *str, size_t length) |
| LEAP_EXPORT const char * | serializeCString (size_t &length) const |
| LEAP_EXPORT const char * | toCString () const |
Static Private Attributes | |
| tuple | __getattr__ = lambdaself,name:_swig_getattr(self, Frame, name) |
| __repr__ = _swig_repr | |
| tuple | __setattr__ = lambdaself,name,value:_swig_setattr(self, Frame, name, value) |
| __swig_destroy__ = LeapPython.delete_Frame | |
| dictionary | __swig_getmethods__ = {} |
| dictionary | __swig_setmethods__ = {} |
Friends | |
| LEAP_EXPORT friend std::ostream & | operator<< (std::ostream &, const Frame &) |
Detailed Description
The Frame class represents a set of hand and finger tracking data detected in a single frame.
The Leap Motion software detects hands, fingers and tools within the tracking area, reporting their positions, orientations, gestures, and motions in frames at the Leap Motion frame rate.
Access Frame objects through an instance of the Controller class:
Implement a Listener subclass to receive a callback event when a new Frame is available.
- Since:
- 1.0
Constructor & Destructor Documentation
| Leap::Frame::Frame | ( | FrameImplementation * | ) |
Constructs a Frame object.
Frame instances created with this constructor are invalid. Get valid Frame objects by calling the Controller::frame() function.
The only time you should use this constructor is before deserializing serialized frame data. Call ``Frame::deserialize(string)`` to recreate a saved Frame.
- Since:
- 1.0
| def Leap::Frame::__init__ | ( | self | ) |
Member Function Documentation
| def Leap::Frame::__eq__ | ( | self, | |
| arg2 | |||
| ) |
| def Leap::Frame::__ne__ | ( | self, | |
| arg2 | |||
| ) |
| def Leap::Frame::__str__ | ( | self | ) |
| LEAP_EXPORT float Leap::Frame::currentFramesPerSecond | ( | ) | const |
The instantaneous framerate.
The rate at which the Leap Motion software is providing frames of data (in frames per second). The framerate can fluctuate depending on available computing resources, activity within the device field of view, software tracking settings, and other factors.
- Returns:
- An estimate of frames per second of the Leap Motion Controller.
- Since:
- 1.0
| def Leap::Frame::deserialize | ( | self, | |
| ptr, | |||
| length | |||
| ) |
| def Leap::Frame::deserialize | ( | self, | |
| tup | |||
| ) |
| void Leap::Frame::deserialize | ( | const std::string & | str | ) | [inline] |
Decodes a byte string to replace the properties of this Frame.
A Controller object must be instantiated for this function to succeed, but it does not need to be connected. To extract gestures from the deserialized frame, you must enable the appropriate gestures first.
Any existing data in the frame is destroyed. If you have references to child objects (hands, fingers, etc.), these are preserved as long as the references remain in scope.
**Note:** The behavior when calling functions which take another Frame object as a parameter is undefined when either frame has been deserialized. For example, calling ``gestures(sinceFrame)`` on a deserialized frame or with a deserialized frame as parameter (or both) does not necessarily return all gestures that occurred between the two frames. Motion functions, like ``scaleFactor(startFrame)``, are more likely to return reasonable results, but could return anomalous values in some cases.
- Parameters:
-
str A std:string object containing the serialized bytes of a frame.
- Since:
- 2.1.0
| void Leap::Frame::deserialize | ( | const unsigned char * | ptr, |
| int | length | ||
| ) | [inline] |
| LEAP_EXPORT void Leap::Frame::deserializeCString | ( | const char * | str, |
| size_t | length | ||
| ) | [private] |
| def Leap::Frame::finger | ( | self, | |
| id | |||
| ) |
| LEAP_EXPORT Finger Leap::Frame::finger | ( | int32_t | id | ) | const |
The Finger object with the specified ID in this frame.
Use the Frame::finger() function to retrieve the Finger object from this frame using an ID value obtained from a previous frame. This function always returns a Finger object, but if no finger with the specified ID is present, an invalid Finger object is returned.
Note that ID values persist across frames, but only until tracking of a particular object is lost. If tracking of a finger is lost and subsequently regained, the new Finger object representing that physical finger may have a different ID than that representing the finger in an earlier frame.
- Parameters:
-
id The ID value of a Finger object from a previous frame.
- Returns:
- The Finger object with the matching ID if one exists in this frame; otherwise, an invalid Finger object is returned.
- Since:
- 1.0
| LEAP_EXPORT FingerList Leap::Frame::fingers | ( | ) | const |
The list of Finger objects detected in this frame, given in arbitrary order. The list can be empty if no fingers are detected.
Use PointableList::extended() to remove non-extended fingers from the list.
- Returns:
- The FingerList containing all Finger objects detected in this frame.
- Since:
- 1.0
| def Leap::Frame::gesture | ( | self, | |
| id | |||
| ) |
| LEAP_EXPORT Gesture Leap::Frame::gesture | ( | int32_t | id | ) | const |
The Gesture object with the specified ID in this frame.
Use the Frame::gesture() function to return a Gesture object in this frame using an ID obtained in an earlier frame. The function always returns a Gesture object, but if there was no update for the gesture in this frame, then an invalid Gesture object is returned.
All Gesture objects representing the same recognized movement share the same ID.
- Parameters:
-
id The ID of an Gesture object from a previous frame.
- Returns:
- The Gesture object in the frame with the specified ID if one exists; Otherwise, an Invalid Gesture object.
- Since:
- 1.0
| def Leap::Frame::gestures | ( | self, | |
| args | |||
| ) |
| LEAP_EXPORT GestureList Leap::Frame::gestures | ( | ) | const |
The gestures recognized or continuing in this frame.
Circle and swipe gestures are updated every frame. Tap gestures only appear in the list for a single frame.
- Returns:
- GestureList the list of gestures.
- Since:
- 1.0
| LEAP_EXPORT GestureList Leap::Frame::gestures | ( | const Frame & | sinceFrame | ) | const |
Returns a GestureList containing all gestures that have occurred since the specified frame.
- Parameters:
-
sinceFrame An earlier Frame object. The starting frame must still be in the frame history cache, which has a default length of 60 frames.
- Returns:
- GestureList The list of the Gesture objects that have occurred since the specified frame.
- Since:
- 1.0
| def Leap::Frame::hand | ( | self, | |
| id | |||
| ) |
| LEAP_EXPORT Hand Leap::Frame::hand | ( | int32_t | id | ) | const |
The Hand object with the specified ID in this frame.
Use the Frame::hand() function to retrieve the Hand object from this frame using an ID value obtained from a previous frame. This function always returns a Hand object, but if no hand with the specified ID is present, an invalid Hand object is returned.
Note that ID values persist across frames, but only until tracking of a particular object is lost. If tracking of a hand is lost and subsequently regained, the new Hand object representing that physical hand may have a different ID than that representing the physical hand in an earlier frame.
- Parameters:
-
id The ID value of a Hand object from a previous frame.
- Returns:
- The Hand object with the matching ID if one exists in this frame; otherwise, an invalid Hand object is returned.
- Since:
- 1.0
| LEAP_EXPORT HandList Leap::Frame::hands | ( | ) | const |
| LEAP_EXPORT int64_t Leap::Frame::id | ( | ) | const |
| LEAP_EXPORT ImageList Leap::Frame::images | ( | ) | const |
The current InteractionBox for the frame. See the InteractionBox class documentation for more details on how this class should be used.
- Returns:
- The current InteractionBox object.
- Since:
- 1.0
| static LEAP_EXPORT const Frame& Leap::Frame::invalid | ( | ) | [static] |
Returns an invalid Frame object.
You can use the instance returned by this function in comparisons testing whether a given Frame instance is valid or invalid. (You can also use the Frame::isValid() function.)
- Returns:
- The invalid Frame instance.
- Since:
- 1.0
| LEAP_EXPORT bool Leap::Frame::isValid | ( | ) | const |
Reports whether this Frame instance is valid.
A valid Frame is one generated by the Leap::Controller object that contains tracking data for all detected entities. An invalid Frame contains no actual tracking data, but you can call its functions without risk of a null pointer exception. The invalid Frame mechanism makes it more convenient to track individual data across the frame history. For example, you can invoke:
for an arbitrary Frame history value, "n", without first checking whether frame(n) returned a null object. (You should still check that the returned Finger instance is valid.)
- Returns:
- True, if this is a valid Frame object; false otherwise.
- Since:
- 1.0
| LEAP_EXPORT bool Leap::Frame::operator!= | ( | const Frame & | ) | const |
| LEAP_EXPORT bool Leap::Frame::operator== | ( | const Frame & | ) | const |
| def Leap::Frame::pointable | ( | self, | |
| id | |||
| ) |
| LEAP_EXPORT Pointable Leap::Frame::pointable | ( | int32_t | id | ) | const |
The Pointable object with the specified ID in this frame.
Use the Frame::pointable() function to retrieve the Pointable object from this frame using an ID value obtained from a previous frame. This function always returns a Pointable object, but if no finger or tool with the specified ID is present, an invalid Pointable object is returned.
Note that ID values persist across frames, but only until tracking of a particular object is lost. If tracking of a finger or tool is lost and subsequently regained, the new Pointable object representing that finger or tool may have a different ID than that representing the finger or tool in an earlier frame.
- Parameters:
-
id The ID value of a Pointable object from a previous frame.
- Returns:
- The Pointable object with the matching ID if one exists in this frame; otherwise, an invalid Pointable object is returned.
- Since:
- 1.0
| LEAP_EXPORT PointableList Leap::Frame::pointables | ( | ) | const |
The list of Pointable objects (fingers and tools) detected in this frame, given in arbitrary order. The list can be empty if no fingers or tools are detected.
Use PointableList::extended() to remove non-extended fingers from the list.
- Returns:
- The PointableList containing all Pointable objects detected in this frame.
- Since:
- 1.0
| def Leap::Frame::rotation_angle | ( | self, | |
| args | |||
| ) |
| def Leap::Frame::rotation_axis | ( | self, | |
| sinceFrame | |||
| ) |
| def Leap::Frame::rotation_matrix | ( | self, | |
| sinceFrame | |||
| ) |
| def Leap::Frame::rotation_probability | ( | self, | |
| sinceFrame | |||
| ) |
| LEAP_EXPORT float Leap::Frame::rotationAngle | ( | const Frame & | sinceFrame | ) | const |
The angle of rotation around the rotation axis derived from the overall rotational motion between the current frame and the specified frame.
The returned angle is expressed in radians measured clockwise around the rotation axis (using the right-hand rule) between the start and end frames. The value is always between 0 and pi radians (0 and 180 degrees).
The Leap Motion software derives frame rotation from the relative change in position and orientation of all objects detected in the field of view.
If either this frame or sinceFrame is an invalid Frame object, then the angle of rotation is zero.
- Parameters:
-
sinceFrame The starting frame for computing the relative rotation.
- Returns:
- A positive value containing the heuristically determined rotational change between the current frame and that specified in the sinceFrame parameter.
- Since:
- 1.0
| LEAP_EXPORT float Leap::Frame::rotationAngle | ( | const Frame & | sinceFrame, |
| const Vector & | axis | ||
| ) | const |
The angle of rotation around the specified axis derived from the overall rotational motion between the current frame and the specified frame.
The returned angle is expressed in radians measured clockwise around the rotation axis (using the right-hand rule) between the start and end frames. The value is always between -pi and pi radians (-180 and 180 degrees).
The Leap Motion software derives frame rotation from the relative change in position and orientation of all objects detected in the field of view.
If either this frame or sinceFrame is an invalid Frame object, then the angle of rotation is zero.
- Parameters:
-
sinceFrame The starting frame for computing the relative rotation. axis The axis to measure rotation around.
- Returns:
- A value containing the heuristically determined rotational change between the current frame and that specified in the sinceFrame parameter around the given axis.
- Since:
- 1.0
| LEAP_EXPORT Vector Leap::Frame::rotationAxis | ( | const Frame & | sinceFrame | ) | const |
The axis of rotation derived from the overall rotational motion between the current frame and the specified frame.
The returned direction vector is normalized.
The Leap Motion software derives frame rotation from the relative change in position and orientation of all objects detected in the field of view.
If either this frame or sinceFrame is an invalid Frame object, or if no rotation is detected between the two frames, a zero vector is returned.
- Parameters:
-
sinceFrame The starting frame for computing the relative rotation.
- Returns:
- A normalized direction Vector representing the axis of the heuristically determined rotational change between the current frame and that specified in the sinceFrame parameter.
- Since:
- 1.0
| LEAP_EXPORT Matrix Leap::Frame::rotationMatrix | ( | const Frame & | sinceFrame | ) | const |
The transform matrix expressing the rotation derived from the overall rotational motion between the current frame and the specified frame.
The Leap Motion software derives frame rotation from the relative change in position and orientation of all objects detected in the field of view.
If either this frame or sinceFrame is an invalid Frame object, then this method returns an identity matrix.
- Parameters:
-
sinceFrame The starting frame for computing the relative rotation.
- Returns:
- A transformation Matrix containing the heuristically determined rotational change between the current frame and that specified in the sinceFrame parameter.
- Since:
- 1.0
| LEAP_EXPORT float Leap::Frame::rotationProbability | ( | const Frame & | sinceFrame | ) | const |
The estimated probability that the overall motion between the current frame and the specified frame is intended to be a rotating motion.
If either this frame or sinceFrame is an invalid Frame object, then this method returns zero.
- Parameters:
-
sinceFrame The starting frame for computing the relative rotation.
- Returns:
- A value between 0 and 1 representing the estimated probability that the overall motion between the current frame and the specified frame is intended to be a rotating motion.
- Since:
- 1.0
| def Leap::Frame::scale_factor | ( | self, | |
| sinceFrame | |||
| ) |
| def Leap::Frame::scale_probability | ( | self, | |
| sinceFrame | |||
| ) |
| LEAP_EXPORT float Leap::Frame::scaleFactor | ( | const Frame & | sinceFrame | ) | const |
The scale factor derived from the overall motion between the current frame and the specified frame.
The scale factor is always positive. A value of 1.0 indicates no scaling took place. Values between 0.0 and 1.0 indicate contraction and values greater than 1.0 indicate expansion.
The Leap Motion software derives scaling from the relative inward or outward motion of all objects detected in the field of view (independent of translation and rotation).
If either this frame or sinceFrame is an invalid Frame object, then this method returns 1.0.
- Parameters:
-
sinceFrame The starting frame for computing the relative scaling.
- Returns:
- A positive value representing the heuristically determined scaling change ratio between the current frame and that specified in the sinceFrame parameter.
- Since:
- 1.0
| LEAP_EXPORT float Leap::Frame::scaleProbability | ( | const Frame & | sinceFrame | ) | const |
The estimated probability that the overall motion between the current frame and the specified frame is intended to be a scaling motion.
If either this frame or sinceFrame is an invalid Frame object, then this method returns zero.
- Parameters:
-
sinceFrame The starting frame for computing the relative scaling.
- Returns:
- A value between 0 and 1 representing the estimated probability that the overall motion between the current frame and the specified frame is intended to be a scaling motion.
- Since:
- 1.0
| def Leap::Frame::serialize | ( | self, | |
| ptr | |||
| ) |
| def Leap::Frame::serialize | ( | self | ) |
| std::string Leap::Frame::serialize | ( | ) | const [inline] |
| void Leap::Frame::serialize | ( | unsigned char * | ptr | ) | const [inline] |
| LEAP_EXPORT const char* Leap::Frame::serializeCString | ( | size_t & | length | ) | const [private] |
| int Leap::Frame::serializeLength | ( | ) | const [inline] |
| LEAP_EXPORT int64_t Leap::Frame::timestamp | ( | ) | const |
The frame capture time in microseconds elapsed since an arbitrary point in time in the past.
Use Controller::now() to calculate the age of the frame.
- Returns:
- The timestamp in microseconds.
- Since:
- 1.0
| LEAP_EXPORT const char* Leap::Frame::toCString | ( | ) | const [private] |
| def Leap::Frame::tool | ( | self, | |
| id | |||
| ) |
| LEAP_EXPORT Tool Leap::Frame::tool | ( | int32_t | id | ) | const |
The Tool object with the specified ID in this frame.
Use the Frame::tool() function to retrieve the Tool object from this frame using an ID value obtained from a previous frame. This function always returns a Tool object, but if no tool with the specified ID is present, an invalid Tool object is returned.
Note that ID values persist across frames, but only until tracking of a particular object is lost. If tracking of a tool is lost and subsequently regained, the new Tool object representing that tool may have a different ID than that representing the tool in an earlier frame.
- Parameters:
-
id The ID value of a Tool object from a previous frame.
- Returns:
- The Tool object with the matching ID if one exists in this frame; otherwise, an invalid Tool object is returned.
- Since:
- 1.0
| LEAP_EXPORT ToolList Leap::Frame::tools | ( | ) | const |
| std::string Leap::Frame::toString | ( | ) | const [inline] |
| LEAP_EXPORT TrackedQuad Leap::Frame::trackedQuad | ( | ) | const |
Note: This class is an experimental API for internal use only. It may be removed without warning.
Returns information about the currently detected quad in the scene.
If no quad is being tracked, then an invalid TrackedQuad is returned.
- Since:
- 2.2.6
| def Leap::Frame::translation | ( | self, | |
| sinceFrame | |||
| ) |
| LEAP_EXPORT Vector Leap::Frame::translation | ( | const Frame & | sinceFrame | ) | const |
The change of position derived from the overall linear motion between the current frame and the specified frame.
The returned translation vector provides the magnitude and direction of the movement in millimeters.
The Leap Motion software derives frame translation from the linear motion of all objects detected in the field of view.
If either this frame or sinceFrame is an invalid Frame object, then this method returns a zero vector.
- Parameters:
-
sinceFrame The starting frame for computing the relative translation.
- Returns:
- A Vector representing the heuristically determined change in position of all objects between the current frame and that specified in the sinceFrame parameter.
- Since:
- 1.0
| def Leap::Frame::translation_probability | ( | self, | |
| sinceFrame | |||
| ) |
| LEAP_EXPORT float Leap::Frame::translationProbability | ( | const Frame & | sinceFrame | ) | const |
The estimated probability that the overall motion between the current frame and the specified frame is intended to be a translating motion.
If either this frame or sinceFrame is an invalid Frame object, then this method returns zero.
- Parameters:
-
sinceFrame The starting frame for computing the translation.
- Returns:
- A value between 0 and 1 representing the estimated probability that the overall motion between the current frame and the specified frame is intended to be a translating motion.
- Since:
- 1.0
Friends And Related Function Documentation
| LEAP_EXPORT friend std::ostream& operator<< | ( | std::ostream & | , |
| const Frame & | |||
| ) | [friend] |
Member Data Documentation
tuple Leap::Frame::__getattr__ = lambdaself,name:_swig_getattr(self, Frame, name) [static, private] |
Reimplemented from Leap::Interface.
Leap::Frame::__repr__ = _swig_repr [static, private] |
tuple Leap::Frame::__setattr__ = lambdaself,name,value:_swig_setattr(self, Frame, name, value) [static, private] |
Reimplemented from Leap::Interface.
Leap::Frame::__swig_destroy__ = LeapPython.delete_Frame [static, private] |
dictionary Leap::Frame::__swig_getmethods__ = {} [static, private] |
Reimplemented from Leap::Interface.
dictionary Leap::Frame::__swig_setmethods__ = {} [static, private] |
Reimplemented from Leap::Interface.
tuple Leap::Frame::current_frames_per_second = _swig_property(LeapPython.Frame_current_frames_per_second_get) [static] |
tuple Leap::Frame::fingers = _swig_property(LeapPython.Frame_fingers_get) [static] |
tuple Leap::Frame::hands = _swig_property(LeapPython.Frame_hands_get) [static] |
tuple Leap::Frame::id = _swig_property(LeapPython.Frame_id_get) [static] |
tuple Leap::Frame::images = _swig_property(LeapPython.Frame_images_get) [static] |
tuple Leap::Frame::interaction_box = _swig_property(LeapPython.Frame_interaction_box_get) [static] |
tuple Leap::Frame::is_valid = _swig_property(LeapPython.Frame_is_valid_get) [static] |
tuple Leap::Frame::pointables = _swig_property(LeapPython.Frame_pointables_get) [static] |
tuple Leap::Frame::serialize_length = _swig_property(LeapPython.Frame_serialize_length_get) [static] |
tuple Leap::Frame::timestamp = _swig_property(LeapPython.Frame_timestamp_get) [static] |
tuple Leap::Frame::tools = _swig_property(LeapPython.Frame_tools_get) [static] |
tuple Leap::Frame::tracked_quad = _swig_property(LeapPython.Frame_tracked_quad_get) [static] |
The documentation for this class was generated from the following files: