Leap
index
/Volumes/LEAP/docs-build/temp/python/Leap.py

# This file was automatically generated by SWIG (http://www.swig.org).
# Version 2.0.6
#
# Do not make changes to this file unless you know what you are doing--modify
# the SWIG interface file instead.


Modules
LeapPython
weakref


Classes
__builtin__.object
Interface
Config
Controller
Device
DeviceList
FingerList
Frame
Gesture
CircleGesture
KeyTapGesture
ScreenTapGesture
SwipeGesture
GestureList
Hand
HandList
InteractionBox
Pointable
Finger
Tool
PointableList
Screen
ScreenList
ToolList
Listener
Matrix
SwigPyIterator
Vector


class CircleGesture(Gesture)
The CircleGesture classes represents a circular finger movement.

A circle movement is recognized when the tip of a finger draws a circle
within the Leap field of view.


**Important:** To use circle gestures in your application, you must enable
recognition of the circle gesture. You can enable recognition with:

        controller.enable_gesture(Leap.Gesture.TYPE_CIRCLE);

Circle gestures are continuous. The CircleGesture objects for the gesture have
three possible states:

* State::STATE_START -- The circle gesture has just started. The movement has
progressed far enough for the recognizer to classify it as a circle.
* State::STATE_UPDATE -- The circle gesture is continuing.
* State::STATE_STOP -- The circle gesture is finished.

You can set the minimum radius and minimum arc length required for a movement
to be recognized as a circle using the config attribute of a connected
Controller object. Use the following keys to configure circle recognition:

Key string | Value type | Default value | Units
-----------|------------|---------------|------
Gesture.Circle.MinRadius | float | 5.0 | mm
Gesture.Circle.MinArc | float | 1.5*pi | radians

The following example demonstrates how to set the circle configuration
parameters:

        if(controller.config.set_float("Gesture.Circle.MinRadius", 10.0) 
           and controller.config.set_float("Gesture.Circle.MinArc", .5)):
            controller.config.save();
Method resolution order:
CircleGesture
Gesture
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__init__(self, *args)
__init__(Leap::CircleGesture self) -> CircleGesture
__init__(Leap::CircleGesture self, Gesture rhs) -> CircleGesture

Constructs a CircleGesture object from an instance of the Gesture class.

Arguments:
rhs (Leap::Gesture const &) -- The Gesture instance to specialize. This Gesture instance must
be a CircleGesture object.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value

Static methods defined here:
class_type()
class_type() -> Leap::Gesture::Type

The circle gesture type.

Returns: Type The type value designating a circle gesture.

Data descriptors defined here:
center
normal
pointable
progress
radius

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_CircleGesture>
__swig_getmethods__ = {'center': <built-in function CircleGesture_center_get>, 'class_type': <function <lambda>>, 'duration': <built-in function Gesture_duration_get>, 'duration_seconds': <built-in function Gesture_duration_seconds_get>, 'frame': <built-in function Gesture_frame_get>, 'hands': <built-in function Gesture_hands_get>, 'id': <built-in function Gesture_id_get>, 'is_valid': <built-in function Gesture_is_valid_get>, 'normal': <built-in function CircleGesture_normal_get>, 'pointable': <built-in function CircleGesture_pointable_get>, ...}
__swig_setmethods__ = {}

Methods inherited from Gesture:
__eq__(self, *args)
__eq__(Gesture self, Gesture rhs) -> bool

Compare Gesture object equality.

Two Gestures are equal if they represent the same snapshot of the same
recognized movement.
__ne__(self, *args)
__ne__(Gesture self, Gesture rhs) -> bool

Compare Gesture object inequality.

Two Gestures are equal only if they represent the same snapshot of the same
recognized movement.
__str__(self)
__str__(Gesture self) -> std::string

A string containing a brief, human-readable description of this
Gesture.

Data descriptors inherited from Gesture:
duration
duration_seconds
frame
hands
id
is_valid
pointables
state
type

Data and other attributes inherited from Gesture:
STATE_INVALID = -1
STATE_START = 1
STATE_STOP = 3
STATE_UPDATE = 2
TYPE_CIRCLE = 4
TYPE_INVALID = -1
TYPE_KEY_TAP = 6
TYPE_SCREEN_TAP = 5
TYPE_SWIPE = 1
invalid = <Leap.Gesture; proxy of <Swig Object of type 'Leap::Gesture *' at 0x10d58f150> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Config(Interface)
The Config class provides access to Leap system configuration information.

You can get and set gesture configuration parameters using the Config object
obtained from a connected Controller object. The key strings required to
identify a configuration parameter include:

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

After setting a configuration value, you must call the Config::save method
to commit the changes. The configuration value changes are not persistent;
your application needs to set the values everytime it runs.

See also: CircleGesture
See also: KeyTapGesture
See also: ScreenTapGesture
See also: SwipeGesture
Method resolution order:
Config
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__init__(self)
__init__(Leap::Config self) -> Config

Constructs a Config object.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
get(self, *args)
save(self)
save(Config self) -> bool

Saves the current state of the config.

Call ``save()`` after making a set of configuration changes. The
``save()`` function transfers the configuration changes to the Leap
application. The configuration value changes are not persistent; your
application needs to set the values everytime it runs.

Returns: true on success, false on failure.
set(self, *args)

Data and other attributes defined here:
TYPE_BOOLEAN = 1
TYPE_FLOAT = 6
TYPE_INT32 = 2
TYPE_STRING = 8
TYPE_UNKNOWN = 0
__swig_destroy__ = <built-in function delete_Config>
__swig_getmethods__ = {}
__swig_setmethods__ = {}

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Controller(Interface)
The Controller class is your main interface to the Leap Motion Controller.

Create an instance of this Controller class to access frames of tracking
data and configuration information. Frame data can be polled at any time
using the Controller::frame() function. Call frame() or frame(0) to get the
most recent frame. Set the history parameter to a positive integer to access
previous frames. A controller stores up to 60 frames in its frame history.

Polling is an appropriate strategy for applications which already have an
intrinsic update loop, such as a game. You can also add an instance of a
subclass of Leap::Listener to the controller to handle events as they occur.
The Leap dispatches events to the listener upon initialization and exiting,
on connection changes, and when a new frame of tracking data is available.
When these events occur, the controller object invokes the appropriate
callback function defined in your subclass of Listener.

To access frames of tracking data as they become available:

1. Implement a subclass of the Listener class and override the
Listener::onFrame() function.
2. In your Listener::onFrame() function, call the Controller::frame()
function to access the newest frame of tracking data.
3. To start receiving frames, create a Controller object and add an instance
of the Listener subclass to the Controller::addListener() function.

When an instance of a Listener subclass is added to a Controller object,
it calls the Listener::onInit() function when the listener is ready for use.
When a connection is established between the controller and the Leap, the
controller calls the Listener::onConnect() function. At this point, your
application will start receiving frames of data. The controller calls the
Listener::onFrame() function each time a new frame is available. If the
controller loses its connection with the Leap software or device for any
reason, it calls the Listener::onDisconnect() function. If the listener is
removed from the controller or the controller is destroyed, it calls the
Listener::onExit() function. At that point, unless the listener is added to
another controller again, it will no longer receive frames of tracking data.

The Controller object is multithreaded and calls the Listener functions on
its own thread, not on an application thread.
Method resolution order:
Controller
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__init__(self, *args)
__init__(Leap::Controller self) -> Controller
__init__(Leap::Controller self, Listener listener) -> Controller

Constructs a Controller object.

When creating a Controller object, you may optionally pass in a
reference to an instance of a subclass of Leap::Listener. Alternatively,
you may add a listener using the Controller::addListener() function.

Arguments:
listener (Leap::Listener &) -- An instance of Leap::Listener implementing the callback
functions for the Leap events you want to handle in your application.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
add_listener(self, *args)
add_listener(Controller self, Listener listener) -> bool

Adds a listener to this Controller.

The Controller dispatches Leap events to each associated listener. The
order in which listener callback functions are invoked is arbitrary. If
you pass a listener to the Controller's constructor function, it is
automatically added to the list and can be removed with the
Controller::removeListener() function.

Arguments:
listener (Leap::Listener &) -- A subclass of Leap::Listener implementing the callback
functions for the Leap events you want to handle in your application.
Returns: Whether or not the listener was successfully added to the list
of listeners.
enable_gesture(self, *args)
enable_gesture(Controller self, Leap::Gesture::Type type, bool enable=True)
enable_gesture(Controller self, Leap::Gesture::Type type)

Enables or disables reporting of a specified gesture type.

By default, all gesture types are disabled. When disabled, gestures of the
disabled type are never reported and will not appear in the frame
gesture list.

As a performance optimization, only enable recognition for the types
of movements that you use in your application.

Arguments:
type (Leap::Gesture::Type) -- The type of gesture to enable or disable. Must be a
member of the Gesture::Type enumeration.
enable (bool) -- True, to enable the specified gesture type; False,
to disable.
See also: Controller::isGestureEnabled()
frame(self, history=0)
frame(Controller self, int history=0) -> Frame
frame(Controller self) -> Frame

Returns a frame of tracking data from the Leap. Use the optional
history parameter to specify which frame to retrieve. Call frame() or
frame(0) to access the most recent frame; call frame(1) to access the
previous frame, and so on. If you use a history value greater than the
number of stored frames, then the controller returns an invalid frame.

Arguments:
history (int) -- The age of the frame to return, counting backwards from
the most recent frame (0) into the past and up to the maximum age (59).
Returns: The specified frame; or, if no history parameter is specified,
the newest frame. If a frame is not available at the specified history
position, an invalid Frame is returned.
is_gesture_enabled(self, *args)
is_gesture_enabled(Controller self, Leap::Gesture::Type type) -> bool

Reports whether the specified gesture type is enabled.

Return: True, if the specified type is enabled; false, otherwise.
See also: Controller::enableGesture()
remove_listener(self, *args)
remove_listener(Controller self, Listener listener) -> bool

Remove a listener from the list of listeners that will receive Leap
events. A listener must be removed if its lifetime is shorter than the
controller to which it is listening.

Arguments:
listener (Leap::Listener &) -- The listener to remove.
Returns: Whether or not the listener was successfully removed from the
list of listeners.
set_policy_flags(self, *args)
set_policy_flags(Controller self, Leap::Controller::PolicyFlag flags)

Requests a change in policy.

A request to change a policy is subject to user approval and a policy
can be changed by the user at any time (using the Leap settings window).
The desired policy flags must be set every time an application runs.

Policy changes are completed asynchronously and, because they are subject
to user approval, may not complete successfully. Call
Controller::policyFlags() after a suitable interval to test whether
the change was accepted.

Currently, the background frames policy is the only policy supported.
The background frames policy determines whether an application
receives frames of tracking data while in the background. By
default, the Leap only sends tracking data to the foreground application.
Only applications that need this ability should request the background
frames policy.

At this time, you can use the Leap applications Settings window to
globally enable or disable the background frames policy. However,
each application that needs tracking data while in the background
must also set the policy flag using this function.

This function can be called before the Controller object is connected,
but the request will be sent to the Leap after the Controller connects.

Arguments:
flags (Leap::Controller::PolicyFlag) -- A PolicyFlag value indicating the policies to request.

Data descriptors defined here:
calibrated_screens
config
devices
has_focus
is_connected
located_screens
policy_flags

Data and other attributes defined here:
POLICY_BACKGROUND_FRAMES = 1
POLICY_DEFAULT = 0
__swig_destroy__ = <built-in function delete_Controller>
__swig_getmethods__ = {'calibrated_screens': <built-in function Controller_calibrated_screens_get>, 'config': <built-in function Controller_config_get>, 'devices': <built-in function Controller_devices_get>, 'has_focus': <built-in function Controller_has_focus_get>, 'is_connected': <built-in function Controller_is_connected_get>, 'located_screens': <built-in function Controller_located_screens_get>, 'policy_flags': <built-in function Controller_policy_flags_get>}
__swig_setmethods__ = {}

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Device(Interface)
The Device class represents a physically connected device.

The Device class contains information related to a particular connected
device such as field of view, device id, and calibrated positions.

Note that Device objects can be invalid, which means that they do not contain
valid device information and do not correspond to a physical device.
Test for validity with the Device::isValid() function.
Method resolution order:
Device
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__eq__(self, *args)
__eq__(Device self, Device arg2) -> bool

Compare Device object equality.

Two Device objects are equal if and only if both Device objects represent the
exact same Device and both Devices are valid.
__getattr__ lambda self, name
__init__(self)
__init__(Leap::Device self) -> Device

Constructs a Device object.

An uninitialized device is considered invalid.
Get valid Device objects from a DeviceList object obtained using the
Controller::devices() method.
__ne__(self, *args)
__ne__(Device self, Device arg2) -> bool

Compare Device object inequality.

Two Device objects are equal if and only if both Device objects represent the
exact same Device and both Devices are valid.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(Device self) -> std::string

A string containing a brief, human readable description of the Device object.

Returns: A description of the Device as a string.
distance_to_boundary(self, *args)
distance_to_boundary(Device self, Vector position) -> float

The distance to the nearest edge of the Leap Motion controller's view volume.

The view volume is an axis-aligned, inverted pyramid centered on the device origin
and extending upward to the range limit. The walls of the pyramid are described
by the horizontalViewAngle and verticalViewAngle and the roof by the range.
This function estimates the distance between the specified input position and the
nearest wall or roof of the view volume.

Arguments:
position (Leap::Vector const &) -- The point to use for the distance calculation.
Returns: The distance in millimeters from the input position to the nearest boundary.

Data descriptors defined here:
horizontal_view_angle
is_valid
range
vertical_view_angle

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_Device>
__swig_getmethods__ = {'horizontal_view_angle': <built-in function Device_horizontal_view_angle_get>, 'is_valid': <built-in function Device_is_valid_get>, 'range': <built-in function Device_range_get>, 'vertical_view_angle': <built-in function Device_vertical_view_angle_get>}
__swig_setmethods__ = {}
invalid = <Leap.Device; proxy of <Swig Object of type 'Leap::Device *' at 0x10d58f1e0> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class DeviceList(Interface)
The DeviceList class represents a list of Device objects.

Get a DeviceList object by calling Controller::devices().
Method resolution order:
DeviceList
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__getitem__(self, *args)
__getitem__(DeviceList self, int index) -> Device

Access a list member by its position in the list.
Arguments:
index (int) -- The zero-based list position index.
Returns: The Device object at the specified index.
__init__(self)
__init__(Leap::DeviceList self) -> DeviceList

Constructs an empty list of devices.
__iter__(self)
__len__(self)
__len__(DeviceList self) -> int

Returns the number of devices in this list.
Returns: The number of devices in this list.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
append(self, *args)
append(DeviceList self, DeviceList other) -> DeviceList

Appends the members of the specifed DeviceList to this DeviceList.
Arguments:
other (Leap::DeviceList const &) -- A DeviceList object containing Device objects
to append to the end of this DeviceList.

Data descriptors defined here:
is_empty

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_DeviceList>
__swig_getmethods__ = {'is_empty': <built-in function DeviceList_is_empty_get>}
__swig_setmethods__ = {}

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Finger(Pointable)
The Finger class represents a tracked finger.

Fingers are Pointable objects that the Leap has classified as a finger.
Get valid Finger objects from a Frame or a Hand object.

Note that Finger objects can be invalid, which means that they do not contain
valid tracking data and do not correspond to a physical finger. Invalid Finger
objects can be the result of asking for a Finger object using an ID from an
earlier frame when no Finger objects with that ID exist in the current frame.
A Finger object created from the Finger constructor is also invalid.
Test for validity with the Finger::isValid() function.
Method resolution order:
Finger
Pointable
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__init__(self, *args)
__init__(Leap::Finger self) -> Finger
__init__(Leap::Finger self, Pointable arg2) -> Finger

If the specified Pointable object represents a finger, creates a copy
of it as a Finger object; otherwise, creates an invalid Finger object.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(Finger self) -> std::string

A string containing a brief, human readable description of the Finger object.

Returns: A description of the Finger object as a string.

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_Finger>
__swig_getmethods__ = {'direction': <built-in function Pointable_direction_get>, 'frame': <built-in function Pointable_frame_get>, 'hand': <built-in function Pointable_hand_get>, 'id': <built-in function Pointable_id_get>, 'is_finger': <built-in function Pointable_is_finger_get>, 'is_tool': <built-in function Pointable_is_tool_get>, 'is_valid': <built-in function Pointable_is_valid_get>, 'length': <built-in function Pointable_length_get>, 'stabilized_tip_position': <built-in function Pointable_stabilized_tip_position_get>, 'tip_position': <built-in function Pointable_tip_position_get>, ...}
__swig_setmethods__ = {}
invalid = <Leap.Finger; proxy of <Swig Object of type 'Leap::Finger *' at 0x10d58f090> >

Methods inherited from Pointable:
__eq__(self, *args)
__eq__(Pointable self, Pointable arg2) -> bool

Compare Pointable object equality.
Two Pointable objects are equal if and only if both Pointable objects represent the
exact same physical entities in the same frame and both Pointable objects are valid.
__ne__(self, *args)
__ne__(Pointable self, Pointable arg2) -> bool

Compare Pointable object inequality.
Two Pointable objects are equal if and only if both Pointable objects represent the
exact same physical entities in the same frame and both Pointable objects are valid.

Data descriptors inherited from Pointable:
direction
frame
hand
id
is_finger
is_tool
is_valid
length
stabilized_tip_position
tip_position
tip_velocity
touch_distance
touch_zone
width

Data and other attributes inherited from Pointable:
ZONE_HOVERING = 1
ZONE_NONE = 0
ZONE_TOUCHING = 2

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class FingerList(Interface)
The FingerList class represents a list of Finger objects.

Get a FingerList object by calling Frame::fingers().
Method resolution order:
FingerList
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__getitem__(self, *args)
__getitem__(FingerList self, int index) -> Finger

Access a list member by its position in the list.
Arguments:
index (int) -- The zero-based list position index.
Returns: The Finger object at the specified index.
__init__(self)
__init__(Leap::FingerList self) -> FingerList

Constructs an empty list of fingers.
__iter__(self)
__len__(self)
__len__(FingerList self) -> int

Returns the number of fingers in this list.
Returns: The number of fingers in this list.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
append(self, *args)
append(FingerList self, FingerList other) -> FingerList

Appends the members of the specifed FingerList to this FingerList.
Arguments:
other (Leap::FingerList const &) -- A FingerList object containing Finger objects
to append to the end of this FingerList.

Data descriptors defined here:
empty
frontmost
is_empty
leftmost
rightmost

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_FingerList>
__swig_getmethods__ = {'empty': <built-in function FingerList_empty_get>, 'frontmost': <built-in function FingerList_frontmost_get>, 'is_empty': <built-in function FingerList_is_empty_get>, 'leftmost': <built-in function FingerList_leftmost_get>, 'rightmost': <built-in function FingerList_rightmost_get>}
__swig_setmethods__ = {}

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Frame(Interface)
The Frame class represents a set of hand and finger tracking data detected
in a single frame.

The Leap detects hands, fingers and tools within the tracking area, reporting
their positions, orientations and motions in frames at the Leap frame rate.

Access Frame objects through an instance of a Leap Controller. Implement a
Listener subclass to receive a callback event when a new Frame is available.
Method resolution order:
Frame
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__eq__(self, *args)
__eq__(Frame self, Frame arg2) -> bool

Compare Frame object equality.
Two Frame objects are equal if and only if both Frame objects represent
the exact same frame of tracking data and both Frame objects are valid.
__getattr__ lambda self, name
__init__(self)
__init__(Leap::Frame self) -> Frame

Constructs a Frame object.

Frame instances created with this constructor are invalid.
Get valid Frame objects by calling the Controller::frame() function.
__ne__(self, *args)
__ne__(Frame self, Frame arg2) -> bool

Compare Frame object inequality.
Two Frame objects are equal if and only if both Frame objects represent
the exact same frame of tracking data and both Frame objects are valid.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(Frame self) -> std::string

A string containing a brief, human readable description of the Frame object.

Returns: A description of the Frame as a string.
finger(self, *args)
finger(Frame self, int32_t id) -> Finger

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.

Arguments:
id (int32_t) -- 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.
gesture(self, *args)
gesture(Frame self, int32_t id) -> Gesture

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.
Arguments:
id (int32_t) -- 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.
gestures(self, *args)
gestures(Frame self) -> GestureList
gestures(Frame self, Frame since_frame) -> GestureList

----------------------------------------------------------------
Overload 1:
----------------------------------------------------------------
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.

Return: GestureList the list of gestures.

----------------------------------------------------------------
Overload 2:
----------------------------------------------------------------
Returns a GestureList containing all gestures that have occured since
the specified frame.

Arguments:
sinceFrame (Leap::Frame const &) -- An earlier Frame object. The starting frame must
still be in the frame history cache, which has a default length of
60 frames.
Return: GestureList The list of the Gesture objects that have occured
since the specified frame.
hand(self, *args)
hand(Frame self, int32_t id) -> Hand

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.

Arguments:
id (int32_t) -- 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.
pointable(self, *args)
pointable(Frame self, int32_t id) -> Pointable

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.

Arguments:
id (int32_t) -- 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.
rotation_angle(self, *args)
rotation_angle(Frame self, Frame since_frame) -> float
rotation_angle(Frame self, Frame since_frame, Vector axis) -> float

----------------------------------------------------------------
Overload 1:
----------------------------------------------------------------
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 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.

Arguments:
sinceFrame (Leap::Frame const &) -- 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.

----------------------------------------------------------------
Overload 2:
----------------------------------------------------------------
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 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.

Arguments:
sinceFrame (Leap::Frame const &) -- The starting frame for computing the relative rotation.
axis (Leap::Vector const &) -- 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.
rotation_axis(self, *args)
rotation_axis(Frame self, Frame since_frame) -> Vector

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 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.

Arguments:
sinceFrame (Leap::Frame const &) -- 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.
rotation_matrix(self, *args)
rotation_matrix(Frame self, Frame since_frame) -> Matrix

The transform matrix expressing the rotation derived from the overall
rotational motion between the current frame and the specified frame.

The Leap 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.

Arguments:
sinceFrame (Leap::Frame const &) -- 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.
rotation_probability(self, *args)
rotation_probability(Frame self, Frame since_frame) -> float

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.

Arguments:
sinceFrame (Leap::Frame const &) -- 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.
scale_factor(self, *args)
scale_factor(Frame self, Frame since_frame) -> float

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 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.

Arguments:
sinceFrame (Leap::Frame const &) -- 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.
scale_probability(self, *args)
scale_probability(Frame self, Frame since_frame) -> float

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.

Arguments:
sinceFrame (Leap::Frame const &) -- 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.
tool(self, *args)
tool(Frame self, int32_t id) -> Tool

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.

Arguments:
id (int32_t) -- 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.
translation(self, *args)
translation(Frame self, Frame since_frame) -> Vector

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 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.

Arguments:
sinceFrame (Leap::Frame const &) -- 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.
translation_probability(self, *args)
translation_probability(Frame self, Frame since_frame) -> float

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.

Arguments:
sinceFrame (Leap::Frame const &) -- 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.

Data descriptors defined here:
fingers
hands
id
interaction_box
is_valid
pointables
timestamp
tools

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_Frame>
__swig_getmethods__ = {'fingers': <built-in function Frame_fingers_get>, 'hands': <built-in function Frame_hands_get>, 'id': <built-in function Frame_id_get>, 'interaction_box': <built-in function Frame_interaction_box_get>, 'is_valid': <built-in function Frame_is_valid_get>, 'pointables': <built-in function Frame_pointables_get>, 'timestamp': <built-in function Frame_timestamp_get>, 'tools': <built-in function Frame_tools_get>}
__swig_setmethods__ = {}
invalid = <Leap.Frame; proxy of <Swig Object of type 'Leap::Frame *' at 0x10d58f270> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Gesture(Interface)
The Gesture class represents a recognized movement by the user.

The Leap 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 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 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.

The Gesture subclasses for 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 only creates a single
ScreenTapGesture object appears 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 | 5.0 | mm
Gesture.ScreenTap.MinForwardVelocity | float | 50 | mm/s
Gesture.ScreenTap.HistorySeconds | float | 0.1 | s
Gesture.ScreenTap.MinDistance | float | 3.0 | mm
Method resolution order:
Gesture
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__eq__(self, *args)
__eq__(Gesture self, Gesture rhs) -> bool

Compare Gesture object equality.

Two Gestures are equal if they represent the same snapshot of the same
recognized movement.
__getattr__ lambda self, name
__init__(self, *args)
__init__(Leap::Gesture self) -> Gesture
__init__(Leap::Gesture self, Gesture rhs) -> Gesture

Constructs a new copy of an Gesture object.
__ne__(self, *args)
__ne__(Gesture self, Gesture rhs) -> bool

Compare Gesture object inequality.

Two Gestures are equal only if they represent the same snapshot of the same
recognized movement.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(Gesture self) -> std::string

A string containing a brief, human-readable description of this
Gesture.

Data descriptors defined here:
duration
duration_seconds
frame
hands
id
is_valid
pointables
state
type

Data and other attributes defined here:
STATE_INVALID = -1
STATE_START = 1
STATE_STOP = 3
STATE_UPDATE = 2
TYPE_CIRCLE = 4
TYPE_INVALID = -1
TYPE_KEY_TAP = 6
TYPE_SCREEN_TAP = 5
TYPE_SWIPE = 1
__swig_destroy__ = <built-in function delete_Gesture>
__swig_getmethods__ = {'duration': <built-in function Gesture_duration_get>, 'duration_seconds': <built-in function Gesture_duration_seconds_get>, 'frame': <built-in function Gesture_frame_get>, 'hands': <built-in function Gesture_hands_get>, 'id': <built-in function Gesture_id_get>, 'is_valid': <built-in function Gesture_is_valid_get>, 'pointables': <built-in function Gesture_pointables_get>, 'state': <built-in function Gesture_state_get>, 'type': <built-in function Gesture_type_get>}
__swig_setmethods__ = {}
invalid = <Leap.Gesture; proxy of <Swig Object of type 'Leap::Gesture *' at 0x10d58f150> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class GestureList(Interface)
The GestureList class represents a list of Gesture objects.

Get a GestureList object from a Frame object.
Method resolution order:
GestureList
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__getitem__(self, *args)
__getitem__(GestureList self, int index) -> Gesture

Access a list member by its position in the list.
Arguments:
index (int) -- The zero-based list position index.
Returns: The Gesture object at the specified index.
__init__(self)
__init__(Leap::GestureList self) -> GestureList

Constructs an empty gesture list.
__iter__(self)
__len__(self)
__len__(GestureList self) -> int

The length of this list.
Returns: The number of gestures in this list.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
append(self, *args)
append(GestureList self, GestureList other) -> GestureList

Appends the members of the specified GestureList to this GestureList.
Arguments:
other (Leap::GestureList const &) -- A GestureList object containing Gesture objects
to append to the end of this GestureList.

Data descriptors defined here:
empty
is_empty

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_GestureList>
__swig_getmethods__ = {'empty': <built-in function GestureList_empty_get>, 'is_empty': <built-in function GestureList_is_empty_get>}
__swig_setmethods__ = {}

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Hand(Interface)
The Hand class reports the physical characteristics of a detected hand.

Hand tracking data includes a palm position and velocity; vectors for
the palm normal and direction to the fingers; properties of a sphere fit
to the hand; and lists of the attached fingers and tools.

Note that Hand objects can be invalid, which means that they do not contain
valid tracking data and do not correspond to a physical entity. Invalid Hand
objects can be the result of asking for a Hand object using an ID from an
earlier frame when no Hand objects with that ID exist in the current frame.
A Hand object created from the Hand constructor is also invalid.
Test for validity with the Hand::isValid() function.
Method resolution order:
Hand
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__eq__(self, *args)
__eq__(Hand self, Hand arg2) -> bool

Compare Hand object equality.
Two Hand objects are equal if and only if both Hand objects represent the
exact same physical hand in the same frame and both Hand objects are valid.
__getattr__ lambda self, name
__init__(self)
__init__(Leap::Hand self) -> Hand

Constructs a Hand object.

An uninitialized hand is considered invalid.
Get valid Hand objects from a Frame object.
__ne__(self, *args)
__ne__(Hand self, Hand arg2) -> bool

Compare Hand object inequality.
Two Hand objects are equal if and only if both Hand objects represent the
exact same physical hand in the same frame and both Hand objects are valid.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(Hand self) -> std::string

A string containing a brief, human readable description of the Hand object.

Returns: A description of the Hand as a string.
finger(self, *args)
finger(Hand self, int32_t id) -> Finger

The Finger object with the specified ID attached to this hand.

Use the Hand::finger() function to retrieve a Finger object attached to
this hand 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 finger may have a
different ID than that representing the finger in an earlier frame.

Arguments:
id (int32_t) -- The ID value of a Finger object from a previous frame.
Returns: The Finger object with the matching ID if one exists for this
hand in this frame; otherwise, an invalid Finger object is returned.
pointable(self, *args)
pointable(Hand self, int32_t id) -> Pointable

The Pointable object with the specified ID associated with this hand.

Use the Hand::pointable() function to retrieve a Pointable object
associated with this hand 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.

Arguments:
id (int32_t) -- The ID value of a Pointable object from a previous frame.
Returns: The Pointable object with the matching ID if one exists for this
hand in this frame; otherwise, an invalid Pointable object is returned.
rotation_angle(self, *args)
rotation_angle(Hand self, Frame since_frame) -> float
rotation_angle(Hand self, Frame since_frame, Vector axis) -> float

----------------------------------------------------------------
Overload 1:
----------------------------------------------------------------
The angle of rotation around the rotation axis derived from the change
in orientation of this hand, and any associated fingers and tools,
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).

If a corresponding Hand object is not found in sinceFrame, or if either
this frame or sinceFrame are invalid Frame objects, then the angle of
rotation is zero.

Arguments:
sinceFrame (Leap::Frame const &) -- The starting frame for computing the relative rotation.
Returns: A positive value representing the heuristically determined
rotational change of the hand between the current frame and that
specified in the sinceFrame parameter.

----------------------------------------------------------------
Overload 2:
----------------------------------------------------------------
The angle of rotation around the specified axis derived from the change
in orientation of this hand, and any associated fingers and tools,
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).

If a corresponding Hand object is not found in sinceFrame, or if either
this frame or sinceFrame are invalid Frame objects, then the angle of
rotation is zero.

Arguments:
sinceFrame (Leap::Frame const &) -- The starting frame for computing the relative rotation.
axis (Leap::Vector const &) -- The axis to measure rotation around.
Returns: A value representing the heuristically determined rotational
change of the hand between the current frame and that specified in the
sinceFrame parameter around the specified axis.
rotation_axis(self, *args)
rotation_axis(Hand self, Frame since_frame) -> Vector

The axis of rotation derived from the change in orientation of this
hand, and any associated fingers and tools, between the current frame
and the specified frame.

The returned direction vector is normalized.

If a corresponding Hand object is not found in sinceFrame, or if either
this frame or sinceFrame are invalid Frame objects, then this method
returns a zero vector.

Arguments:
sinceFrame (Leap::Frame const &) -- The starting frame for computing the relative rotation.
Returns: A normalized direction Vector representing the heuristically
determined axis of rotational change of the hand between the current
frame and that specified in the sinceFrame parameter.
rotation_matrix(self, *args)
rotation_matrix(Hand self, Frame since_frame) -> Matrix

The transform matrix expressing the rotation derived from the change
in orientation of this hand, and any associated fingers and tools,
between the current frame and the specified frame.

If a corresponding Hand object is not found in sinceFrame, or if either
this frame or sinceFrame are invalid Frame objects, then this method
returns an identity matrix.

Arguments:
sinceFrame (Leap::Frame const &) -- The starting frame for computing the relative rotation.
Returns: A transformation Matrix representing the heuristically determined
rotational change of the hand between the current frame and that specified
in the sinceFrame parameter.
rotation_probability(self, *args)
rotation_probability(Hand self, Frame since_frame) -> float

The estimated probability that the hand motion between the current
frame and the specified frame is intended to be a rotating motion.

If a corresponding Hand object is not found in sinceFrame, or if either
this frame or sinceFrame are invalid Frame objects, then this method
returns zero.

Arguments:
sinceFrame (Leap::Frame const &) -- The starting frame for computing the relative rotation.
Returns: A value between 0 and 1 representing the estimated probability
that the hand motion between the current frame and the specified frame
is intended to be a rotating motion.
scale_factor(self, *args)
scale_factor(Hand self, Frame since_frame) -> float

The scale factor derived from this hand's 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 derives scaling from the relative inward or outward motion of
a hand and its associated fingers and tools (independent of translation
and rotation).

If a corresponding Hand object is not found in sinceFrame, or if either
this frame or sinceFrame are invalid Frame objects, then this method
returns 1.0.

Arguments:
sinceFrame (Leap::Frame const &) -- The starting frame for computing the relative scaling.
Returns: A positive value representing the heuristically determined
scaling change ratio of the hand between the current frame and that
specified in the sinceFrame parameter.
scale_probability(self, *args)
scale_probability(Hand self, Frame since_frame) -> float

The estimated probability that the hand motion between the current
frame and the specified frame is intended to be a scaling motion.

If a corresponding Hand object is not found in sinceFrame, or if either
this frame or sinceFrame are invalid Frame objects, then this method
returns zero.

Arguments:
sinceFrame (Leap::Frame const &) -- The starting frame for computing the relative scaling.
Returns: A value between 0 and 1 representing the estimated probability
that the hand motion between the current frame and the specified frame
is intended to be a scaling motion.
tool(self, *args)
tool(Hand self, int32_t id) -> Tool

The Tool object with the specified ID held by this hand.

Use the Hand::tool() function to retrieve a Tool object held by
this hand 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.

Arguments:
id (int32_t) -- The ID value of a Tool object from a previous frame.
Returns: The Tool object with the matching ID if one exists for this
hand in this frame; otherwise, an invalid Tool object is returned.
translation(self, *args)
translation(Hand self, Frame since_frame) -> Vector

The change of position of this hand between the current frame and
the specified frame.

The returned translation vector provides the magnitude and direction of
the movement in millimeters.

If a corresponding Hand object is not found in sinceFrame, or if either
this frame or sinceFrame are invalid Frame objects, then this method
returns a zero vector.

Arguments:
sinceFrame (Leap::Frame const &) -- The starting frame for computing the translation.
Returns: A Vector representing the heuristically determined change in
hand position between the current frame and that specified in the
sinceFrame parameter.
translation_probability(self, *args)
translation_probability(Hand self, Frame since_frame) -> float

The estimated probability that the hand motion between the current
frame and the specified frame is intended to be a translating motion.

If a corresponding Hand object is not found in sinceFrame, or if either
this frame or sinceFrame are invalid Frame objects, then this method
returns zero.

Arguments:
sinceFrame (Leap::Frame const &) -- The starting frame for computing the translation.
Returns: A value between 0 and 1 representing the estimated probability
that the hand motion between the current frame and the specified frame
is intended to be a translating motion.

Data descriptors defined here:
direction
fingers
frame
id
is_valid
palm_normal
palm_position
palm_velocity
pointables
sphere_center
sphere_radius
tools

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_Hand>
__swig_getmethods__ = {'direction': <built-in function Hand_direction_get>, 'fingers': <built-in function Hand_fingers_get>, 'frame': <built-in function Hand_frame_get>, 'id': <built-in function Hand_id_get>, 'is_valid': <built-in function Hand_is_valid_get>, 'palm_normal': <built-in function Hand_palm_normal_get>, 'palm_position': <built-in function Hand_palm_position_get>, 'palm_velocity': <built-in function Hand_palm_velocity_get>, 'pointables': <built-in function Hand_pointables_get>, 'sphere_center': <built-in function Hand_sphere_center_get>, ...}
__swig_setmethods__ = {}
invalid = <Leap.Hand; proxy of <Swig Object of type 'Leap::Hand *' at 0x10d58f120> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class HandList(Interface)
The HandList class represents a list of Hand objects.

Get a HandList object by calling Frame::hands().
Method resolution order:
HandList
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__getitem__(self, *args)
__getitem__(HandList self, int index) -> Hand

Access a list member by its position in the list.
Arguments:
index (int) -- The zero-based list position index.
Returns: The Hand object at the specified index.
__init__(self)
__init__(Leap::HandList self) -> HandList

Constructs an empty list of hands.
__iter__(self)
__len__(self)
__len__(HandList self) -> int

Returns the number of hands in this list.
Returns: The number of hands in this list.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
append(self, *args)
append(HandList self, HandList other) -> HandList

Appends the members of the specifed HandList to this HandList.
Arguments:
other (Leap::HandList const &) -- A HandList object containing Hand objects
to append to the end of this HandList.

Data descriptors defined here:
empty
frontmost
is_empty
leftmost
rightmost

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_HandList>
__swig_getmethods__ = {'empty': <built-in function HandList_empty_get>, 'frontmost': <built-in function HandList_frontmost_get>, 'is_empty': <built-in function HandList_is_empty_get>, 'leftmost': <built-in function HandList_leftmost_get>, 'rightmost': <built-in function HandList_rightmost_get>}
__swig_setmethods__ = {}

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class InteractionBox(Interface)
The InteractionBox class represents a box-shaped region completely
within the field of view of the Leap Motion controller.

The interaction box is an axis-aligned rectangular prism and provides normalized
coordinates for hands, fingers, and tools within this box. The InteractionBox class
can make it easier to map positions in the Leap Motion coordinate system to 2D or
3D coordinate systems used for application drawing.

The InteractionBox region is defined by a center and dimensions along the x, y,
and z axes.
Method resolution order:
InteractionBox
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__eq__(self, *args)
__eq__(InteractionBox self, InteractionBox arg2) -> bool

Compare InteractionBox object equality.
Two InteractionBox objects are equal if and only if both InteractionBox objects represent the
exact same InteractionBox and both InteractionBoxes are valid.
__getattr__ lambda self, name
__init__(self)
__init__(Leap::InteractionBox self) -> InteractionBox
__ne__(self, *args)
__ne__(InteractionBox self, InteractionBox arg2) -> bool

Compare InteractionBox object inequality.
Two InteractionBox objects are equal if and only if both InteractionBox objects represent the
exact same InteractionBox and both InteractionBoxes are valid.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(InteractionBox self) -> std::string

A string containing a brief, human readable description of the InteractionBox object.

Returns: A description of the InteractionBox as a string.
denormalize_point(self, *args)
denormalize_point(InteractionBox self, Vector normalized_position) -> Vector

Converts a position defined by normalized InteractionBox coordinates into device
coordinates in millimeters.

This function performs the inverse of normalizePoint().

Arguments:
normalizedPosition (Leap::Vector const &) -- The input position in InteractionBox coordinates.
Returns: The corresponding denormalized position in device coordinates.
normalize_point(self, *args)
normalize_point(InteractionBox self, Vector position, bool clamp=True) -> Vector
normalize_point(InteractionBox self, Vector position) -> Vector

Normalizes the coordinates of a point using the interaction box.

Coordinates from the Leap frame of reference (millimeters) are converted
to a range of [0..1] such that the minimum value of the InteractionBox maps to 0
and the maximum value of the InteractionBox maps to 1.

Arguments:
position (Leap::Vector const &) -- The input position in device coordinates.
clamp (bool) -- Whether or not to limit the output value to the range [0,1] when the
input position is outside the InteractionBox. Defaults to true.
Returns: The normalized position.

Data descriptors defined here:
center
depth
height
is_valid
width

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_InteractionBox>
__swig_getmethods__ = {'center': <built-in function InteractionBox_center_get>, 'depth': <built-in function InteractionBox_depth_get>, 'height': <built-in function InteractionBox_height_get>, 'is_valid': <built-in function InteractionBox_is_valid_get>, 'width': <built-in function InteractionBox_width_get>}
__swig_setmethods__ = {}
invalid = <Leap.Device; proxy of <Swig Object of type 'Leap::Device *' at 0x10d58f210> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Interface(__builtin__.object)
Methods defined here:
__getattr__ lambda self, name
__init__(self, *args, **kwargs)
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
__swig_getmethods__ = {}
__swig_setmethods__ = {}


class KeyTapGesture(Gesture)
The KeyTapGesture class represents a tapping gesture by a finger or tool.

A key tap gesture is recognized when the tip of a finger rotates down toward the
palm and then springs back to approximately the original postion, as if
tapping. The tapping finger must pause briefly before beginning the tap.


**Important:** To use key tap gestures in your application, you must enable
recognition of the key tap gesture. You can enable recognition with:

        controller.enable_gesture(Leap.Gesture.Type.TYPE_KEY_TAP);

Key tap gestures are discrete. The KeyTapGesture object representing a tap always
has the state, STATE_STOP. Only one KeyTapGesture object is created for each
key tap gesture recognized.

You can set the minimum finger movement and velocity required for a movement
to be recognized as a key tap as well as adjust the detection window for
evaluating the movement using the config attribute of a connected
Controller object. Use the following configuration keys to configure key tap
recognition:

Key string | Value type | Default value | Units
-----------|------------|---------------|------
Gesture.KeyTap.MinDownVelocity | float | 50 | mm/s
Gesture.KeyTap.HistorySeconds | float | 0.1 | s
Gesture.KeyTap.MinDistance | float | 5.0 | mm

The following example demonstrates how to set the key tap configuration
parameters:

        if(controller.config.set_float("Gesture.KeyTap.MinDownVelocity", 40.0)
           and controller.config.set_float("Gesture.KeyTap.HistorySeconds", .2)
           and controller.config.set_float("Gesture.KeyTap.MinDistance", 1.0)):
            controller.config.save();
Method resolution order:
KeyTapGesture
Gesture
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__init__(self, *args)
__init__(Leap::KeyTapGesture self) -> KeyTapGesture
__init__(Leap::KeyTapGesture self, Gesture rhs) -> KeyTapGesture

Constructs a KeyTapGesture object from an instance of the Gesture class.

Arguments:
rhs (Leap::Gesture const &) -- The Gesture instance to specialize. This Gesture instance must
be a KeyTapGesture object.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value

Static methods defined here:
class_type()
class_type() -> Leap::Gesture::Type

The key tap gesture type.

Returns: Type The type value designating a key tap gesture.

Data descriptors defined here:
direction
pointable
position
progress

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_KeyTapGesture>
__swig_getmethods__ = {'class_type': <function <lambda>>, 'direction': <built-in function KeyTapGesture_direction_get>, 'duration': <built-in function Gesture_duration_get>, 'duration_seconds': <built-in function Gesture_duration_seconds_get>, 'frame': <built-in function Gesture_frame_get>, 'hands': <built-in function Gesture_hands_get>, 'id': <built-in function Gesture_id_get>, 'is_valid': <built-in function Gesture_is_valid_get>, 'pointable': <built-in function KeyTapGesture_pointable_get>, 'pointables': <built-in function Gesture_pointables_get>, ...}
__swig_setmethods__ = {}

Methods inherited from Gesture:
__eq__(self, *args)
__eq__(Gesture self, Gesture rhs) -> bool

Compare Gesture object equality.

Two Gestures are equal if they represent the same snapshot of the same
recognized movement.
__ne__(self, *args)
__ne__(Gesture self, Gesture rhs) -> bool

Compare Gesture object inequality.

Two Gestures are equal only if they represent the same snapshot of the same
recognized movement.
__str__(self)
__str__(Gesture self) -> std::string

A string containing a brief, human-readable description of this
Gesture.

Data descriptors inherited from Gesture:
duration
duration_seconds
frame
hands
id
is_valid
pointables
state
type

Data and other attributes inherited from Gesture:
STATE_INVALID = -1
STATE_START = 1
STATE_STOP = 3
STATE_UPDATE = 2
TYPE_CIRCLE = 4
TYPE_INVALID = -1
TYPE_KEY_TAP = 6
TYPE_SCREEN_TAP = 5
TYPE_SWIPE = 1
invalid = <Leap.Gesture; proxy of <Swig Object of type 'Leap::Gesture *' at 0x10d58f150> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Listener(__builtin__.object)
The Listener class defines a set of callback functions that you can
override in a subclass to respond to events dispatched by the Leap.

To handle Leap events, create an instance of a Listener subclass and assign
it to the Controller instance. The Controller calls the relevant Listener
callback function when an event occurs, passing in a reference to itself.
You do not have to implement callbacks for events you do not want to handle.

The Controller object calls these Listener functions from a thread created
by the Leap library, not the thread used to create or set the Listener instance.
Methods defined here:
__del__ lambda self
__disown__(self)
__getattr__ lambda self, name
__init__(self)
__init__(Leap::Listener self) -> Listener

Constructs a Listener object.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
on_connect(self, *args)
on_connect(Listener self, Controller arg0)

Called when the Controller object connects to the Leap software, or when
this Listener object is added to a Controller that is already connected.

    def on_connect(self, controller):
        print "Connected"

Arguments:
controller (none) -- The Controller object invoking this callback function.
on_disconnect(self, *args)
on_disconnect(Listener self, Controller arg0)

Called when the Controller object disconnects from the Leap software.
The controller can disconnect when the Leap device is unplugged, the
user shuts the Leap software down, or the Leap software encounters an
unrecoverable error.

    def on_disconnect(self, controller):
        # Note: not dispatched when running in a debugger.
        print "Disconnected"

Note: When you launch a Leap-enabled application in a debugger, the
Leap library does not disconnect from the application. This is to allow
you to step through code without losing the connection because of time outs.

Arguments:
controller (none) -- The Controller object invoking this callback function.
on_exit(self, *args)
on_exit(Listener self, Controller arg0)

Called when this Listener object is removed from the Controller
or the Controller instance is destroyed.

    def on_exit(self, controller):
        print "Exited"

Arguments:
controller (none) -- The Controller object invoking this callback function.
on_focus_gained(self, *args)
on_focus_gained(Listener self, Controller arg0)

Called when this application becomes the foreground application.

Only the foreground application receives tracking data from the Leap
Motion Controller. This function is only called when the controller
object is in a connected state.

    def on_focus_gained(self, controller):
        print "Focused"

Arguments:
controller (none) -- The Controller object invoking this callback function.
on_focus_lost(self, *args)
on_focus_lost(Listener self, Controller arg0)

Called when this application loses the foreground focus.

Only the foreground application receives tracking data from the Leap
Motion Controller. This function is only called when the controller
object is in a connected state.

    def on_focus_lost(self, controller):
        print "Unfocused"

Arguments:
controller (none) -- The Controller object invoking this callback function.
on_frame(self, *args)
on_frame(Listener self, Controller arg0)

Called when a new frame of hand and finger tracking data is available.
Access the new frame data using the Controller::frame() function.

    def on_frame(self, controller):
        print "Frame available"

Note, the Controller skips any pending onFrame events while your
onFrame handler executes. If your implementation takes too long to return,
one or more frames can be skipped. The Controller still inserts the skipped
frames into the frame history. You can access recent frames by setting
the history parameter when calling the Controller::frame() function.
You can determine if any pending onFrame events were skipped by comparing
the ID of the most recent frame with the ID of the last received frame.

Arguments:
controller (none) -- The Controller object invoking this callback function.
on_init(self, *args)
on_init(Listener self, Controller arg0)

Called once, when this Listener object is newly added to a Controller.

    def on_init(self, controller):
        print "Initialized"

Arguments:
controller (none) -- The Controller object invoking this callback function.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_Listener>
__swig_getmethods__ = {}
__swig_setmethods__ = {}


class Matrix(__builtin__.object)
The Matrix struct represents a transformation matrix.

To use this struct to transform a Vector, construct a matrix containing the
desired transformation and then use the Matrix::transformPoint() or
Matrix::transformDirection() functions to apply the transform.

Transforms can be combined by multiplying two or more transform matrices using
the * operator.
Methods defined here:
__del__ lambda self
__eq__(self, *args)
__eq__(Matrix self, Matrix other) -> bool

Compare Matrix equality component-wise.
__getattr__ lambda self, name
__imul__(self, *args)
__imul__(Matrix self, Matrix other) -> Matrix

Multiply transform matrices and assign the product.
__init__(self, *args)
__init__(Leap::Matrix self) -> Matrix
__init__(Leap::Matrix self, Matrix other) -> Matrix
__init__(Leap::Matrix self, Vector _x_basis, Vector _y_basis, Vector _z_basis) -> Matrix
__init__(Leap::Matrix self, Vector _x_basis, Vector _y_basis, Vector _z_basis, Vector _origin) -> Matrix
__init__(Leap::Matrix self, Vector axis, float angle_radians) -> Matrix
__init__(Leap::Matrix self, Vector axis, float angle_radians, Vector translation) -> Matrix

Constructs a transformation matrix specifying a rotation around the specified vector
and a translation by the specified vector.

Arguments:
axis (Leap::Vector const &) -- A Vector specifying the axis of rotation.
angleRadians (float) -- The angle of rotation in radians.
translation (Leap::Vector const &) -- A Vector representing the translation part of the transform.
__mul__(self, *args)
__mul__(Matrix self, Matrix other) -> Matrix

Multiply transform matrices.

Combines two transformations into a single equivalent transformation.

Arguments:
other (Leap::Matrix const &) -- A Matrix to multiply on the right hand side.
Returns: A new Matrix representing the transformation equivalent to
applying the other transformation followed by this transformation.
__ne__(self, *args)
__ne__(Matrix self, Matrix other) -> bool

Compare Matrix inequality component-wise.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(Matrix self) -> std::string

Write the matrix to a string in a human readable format.
rigid_inverse(self)
rigid_inverse(Matrix self) -> Matrix

Performs a matrix inverse if the matrix consists entirely of rigid
transformations (translations and rotations). If the matrix is not rigid,
this operation will not represent an inverse.

Note that all matricies that are directly returned by the API are rigid.

Returns: The rigid inverse of the matrix.
set_rotation(self, *args)
set_rotation(Matrix self, Vector _axis, float angle_radians)

Sets this transformation matrix to represent a rotation around the specified vector.

This function erases any previous rotation and scale transforms applied
to this matrix, but does not affect translation.

Arguments:
_axis (Leap::Vector const &) -- A Vector specifying the axis of rotation.
angleRadians (float) -- The amount of rotation in radians.
to_array_3x3(self, output=None)
to_array_4x4(self, output=None)
transform_direction(self, *args)
transform_direction(Matrix self, Vector _in) -> Vector

Transforms a vector with this matrix by transforming its rotation and
scale only.

Arguments:
in (Leap::Vector const &) -- The Vector to transform.
Returns: A new Vector representing the transformed original.
transform_point(self, *args)
transform_point(Matrix self, Vector _in) -> Vector

Transforms a vector with this matrix by transforming its rotation,
scale, and translation.

Translation is applied after rotation and scale.

Arguments:
in (Leap::Vector const &) -- The Vector to transform.
Returns: A new Vector representing the transformed original.

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
origin
x_basis
y_basis
z_basis

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_Matrix>
__swig_getmethods__ = {'origin': <built-in function Matrix_origin_get>, 'x_basis': <built-in function Matrix_x_basis_get>, 'y_basis': <built-in function Matrix_y_basis_get>, 'z_basis': <built-in function Matrix_z_basis_get>}
__swig_setmethods__ = {'origin': <built-in function Matrix_origin_set>, 'x_basis': <built-in function Matrix_x_basis_set>, 'y_basis': <built-in function Matrix_y_basis_set>, 'z_basis': <built-in function Matrix_z_basis_set>}
identity = <Leap.Matrix; proxy of <Swig Object of type 'Leap::Matrix *' at 0x10d58bf90> >


class Pointable(Interface)
The Pointable class reports the physical characteristics of a detected finger or tool.

Both fingers and tools are classified as Pointable objects. Use the Pointable::isFinger()
function to determine whether a Pointable object represents a finger. Use the
Pointable::isTool() function to determine whether a Pointable object represents a tool.
The Leap classifies a detected entity as a tool when it is thinner, straighter, and longer
than a typical finger.

To provide touch emulation, the Leap Motion software associates a floating touch
plane that adapts to the user's finger movement and hand posture. The Leap Motion
interprets purposeful movements toward this plane as potential touch points. The
logic used by the Pointable class is the same as that used by the Leap Motion
software for OS-level touch and mouse input emulation. The Pointable class reports
touch state with the touchZone and touchDistance values.

Note that Pointable objects can be invalid, which means that they do not contain
valid tracking data and do not correspond to a physical entity. Invalid Pointable
objects can be the result of asking for a Pointable object using an ID from an
earlier frame when no Pointable objects with that ID exist in the current frame.
A Pointable object created from the Pointable constructor is also invalid.
Test for validity with the Pointable::isValid() function.
Method resolution order:
Pointable
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__eq__(self, *args)
__eq__(Pointable self, Pointable arg2) -> bool

Compare Pointable object equality.
Two Pointable objects are equal if and only if both Pointable objects represent the
exact same physical entities in the same frame and both Pointable objects are valid.
__getattr__ lambda self, name
__init__(self)
__init__(Leap::Pointable self) -> Pointable

Constructs a Pointable object.

An uninitialized pointable is considered invalid.
Get valid Pointable objects from a Frame or a Hand object.
__ne__(self, *args)
__ne__(Pointable self, Pointable arg2) -> bool

Compare Pointable object inequality.
Two Pointable objects are equal if and only if both Pointable objects represent the
exact same physical entities in the same frame and both Pointable objects are valid.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(Pointable self) -> std::string

A string containing a brief, human readable description of the Pointable object.

Returns: A description of the Pointable object as a string.

Data descriptors defined here:
direction
frame
hand
id
is_finger
is_tool
is_valid
length
stabilized_tip_position
tip_position
tip_velocity
touch_distance
touch_zone
width

Data and other attributes defined here:
ZONE_HOVERING = 1
ZONE_NONE = 0
ZONE_TOUCHING = 2
__swig_destroy__ = <built-in function delete_Pointable>
__swig_getmethods__ = {'direction': <built-in function Pointable_direction_get>, 'frame': <built-in function Pointable_frame_get>, 'hand': <built-in function Pointable_hand_get>, 'id': <built-in function Pointable_id_get>, 'is_finger': <built-in function Pointable_is_finger_get>, 'is_tool': <built-in function Pointable_is_tool_get>, 'is_valid': <built-in function Pointable_is_valid_get>, 'length': <built-in function Pointable_length_get>, 'stabilized_tip_position': <built-in function Pointable_stabilized_tip_position_get>, 'tip_position': <built-in function Pointable_tip_position_get>, ...}
__swig_setmethods__ = {}
invalid = <Leap.Pointable; proxy of <Swig Object of type 'Leap::Pointable *' at 0x10d58f060> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class PointableList(Interface)
The PointableList class represents a list of Pointable objects.

Pointable objects include entities that can be pointed, such as fingers and tools.

Get a PointableList object by calling Frame::pointables().
Method resolution order:
PointableList
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__getitem__(self, *args)
__getitem__(PointableList self, int index) -> Pointable

Access a list member by its position in the list.
Arguments:
index (int) -- The zero-based list position index.
Returns: The Pointable object at the specified index.
__init__(self)
__init__(Leap::PointableList self) -> PointableList

Constructs an empty list of pointable entities.
__iter__(self)
__len__(self)
__len__(PointableList self) -> int

Returns the number of pointable entities in this list.
Returns: The number of pointable entities in this list.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
append(self, *args)
append(PointableList self, PointableList other) -> PointableList
append(PointableList self, FingerList other) -> PointableList
append(PointableList self, ToolList other) -> PointableList

----------------------------------------------------------------
Overload 1:
----------------------------------------------------------------
Appends the members of the specifed PointableList to this PointableList.
Arguments:
other (Leap::PointableList const &) -- A PointableList object containing Pointable objects
to append to the end of this PointableList.

----------------------------------------------------------------
Overload 2:
----------------------------------------------------------------
Appends the members of the specifed FingerList to this PointableList.
Arguments:
other (Leap::FingerList const &) -- A FingerList object containing Finger objects
to append to the end of this PointableList.

----------------------------------------------------------------
Overload 3:
----------------------------------------------------------------
Appends the members of the specifed ToolList to this PointableList.
Arguments:
other (Leap::ToolList const &) -- A ToolList object containing Tool objects
to append to the end of this PointableList.

Data descriptors defined here:
empty
frontmost
is_empty
leftmost
rightmost

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_PointableList>
__swig_getmethods__ = {'empty': <built-in function PointableList_empty_get>, 'frontmost': <built-in function PointableList_frontmost_get>, 'is_empty': <built-in function PointableList_is_empty_get>, 'leftmost': <built-in function PointableList_leftmost_get>, 'rightmost': <built-in function PointableList_rightmost_get>}
__swig_setmethods__ = {}

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Screen(Interface)
The Screen class represents a computer monitor screen.

The Screen class reports characteristics describing the position and
orientation of the monitor screen within the Leap coordinate system. These
characteristics include the bottom-left corner position of the screen,
direction vectors for the horizontal and vertical axes of the screen, and
the screen's normal vector. The screen must be properly registered with the
Screen Locator for the Leap to report these characteristics accurately.
The Screen class also reports the size of the screen in pixels, using
information obtained from the operating system. (Run the Screen Locator
from the Leap Application Settings dialog, on the Screen page.)

You can get the point of intersection between the screen and a ray
projected from a Pointable object using the Screen::intersect() function.
Likewise, you can get the closest point on the screen to a point in space
using the Screen::project() function. Again, the screen location
must be registered with the Screen Locator for these functions to
return accurate values.

Note that Screen objects can be invalid, which means that they do not contain
valid screen coordinate data and do not correspond to a physical entity.
Test for validity with the Screen::isValid() function.
Method resolution order:
Screen
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__eq__(self, *args)
__eq__(Screen self, Screen arg2) -> bool

Compare Screen object equality.
Two Screen objects are equal if and only if both Screen objects represent the
exact same Screens and both Screens are valid.
__getattr__ lambda self, name
__init__(self)
__init__(Leap::Screen self) -> Screen

Constructs a Screen object.

An uninitialized screen is considered invalid.
Get valid Screen objects from a ScreenList object obtained using the
Controller::locatedScreens() method.
__ne__(self, *args)
__ne__(Screen self, Screen arg2) -> bool

Compare Screen object inequality.
Two Screen objects are equal if and only if both Screen objects represent the
exact same Screens and both Screens are valid.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(Screen self) -> std::string

A string containing a brief, human readable description of the Screen object.

Returns: A description of the Screen as a string.
distance_to_point(self, *args)
distance_to_point(Screen self, Vector point) -> float

The shortest distance from the specified point to the plane in which this
Screen lies.

Returns: The length of the perpendicular line segment extending from
the plane this Screen lies in to the specified point.
intersect(self, *args)
intersect(Screen self, Pointable pointable, bool normalize, float clamp_ratio=1.0) -> Vector
intersect(Screen self, Pointable pointable, bool normalize) -> Vector
intersect(Screen self, Vector position, Vector direction, bool normalize, float clamp_ratio=1.0) -> Vector
intersect(Screen self, Vector position, Vector direction, bool normalize) -> Vector

----------------------------------------------------------------
Overload 1:
----------------------------------------------------------------
Returns the intersection between this screen and a ray projecting from a
Pointable object.

The projected ray emanates from the Pointable tipPosition along the
Pointable's direction vector.

Set the normalize parameter to true to request the intersection point in
normalized screen coordinates. Normalized screen coordinates are usually
values between 0 and 1, where 0 represents the screen's origin at the
bottom-left corner and 1 represents the opposite edge (either top or
right). When you request normalized coordinates, the z-component of the
returned vector is zero. Multiply a normalized coordinate by the values
returned by Screen::widthPixels() or Screen::heightPixels() to calculate
the screen position in pixels (remembering that many other computer
graphics coordinate systems place the origin in the top-left corner).

Set the normalize parameter to false to request the intersection point
in Leap coordinates (millimeters from the Leap origin).

If the Pointable object points outside the screen's border (but still
intersects the plane in which the screen lies), the returned intersection
point is clamped to the nearest point on the edge of the screen.

You can use the clampRatio parameter to contract or expand the area in
which you can point. For example, if you set the clampRatio parameter to
0.5, then the positions reported for intersection points outside the
central 50% of the screen are moved to the border of this smaller area.
If, on the other hand, you expanded the area by setting clampRatio to
a value such as 3.0, then you could point well outside screen's physical
boundary before the intersection points would be clamped. The positions
for any points clamped would also be placed on this larger outer border.
The positions reported for any intersection points inside the clamping
border are unaffected by clamping.

        normalizedCoordinates = screen.intersect(pointable, True, 0.5)

If the Pointable object does not point toward the plane of the screen
(i.e. it is pointing parallel to or away from the screen), then the
components of the returned vector are all set to NaN (not-a-number).

Arguments:
pointable (Leap::Pointable const &) -- The Pointable object to check for screen intersection.

normalize (bool) -- If true, return normalized coordinates representing
the intersection point as a percentage of the screen's width and height.
If false, return Leap coordinates (millimeters from the Leap origin,
which is located at the center of the top surface of the Leap device).
If true and the clampRatio parameter is set to 1.0, coordinates will be
of the form (0..1, 0..1, 0). Setting the clampRatio to a different value
changes the range for normalized coordinates. For example, a clampRatio
of 5.0 changes the range of values to be of the form (-2..3, -2..3, 0).

clampRatio (float) -- Adjusts the clamping border around this screen.
By default this ratio is 1.0, and the border corresponds to the actual
boundaries of the screen. Setting clampRatio to 0.5 would reduce the
interaction area. Likewise, setting the ratio to 2.0 would increase the
interaction area, adding 50% around each edge of the physical monitor.
Intersection points outside the interaction area are repositioned to
the closest point on the clamping border before the vector is returned.

Returns: A Vector containing the coordinates of the intersection between
this screen and a ray projecting from the specified Pointable object.

----------------------------------------------------------------
Overload 2:
----------------------------------------------------------------
Returns the intersection between this screen and a ray projecting from
the specified position along the specified direction.

Set the normalize parameter to true to request the intersection point in
normalized screen coordinates. Normalized screen coordinates are usually
values between 0 and 1, where 0 represents the screen's origin at the
bottom-left corner and 1 represents the opposite edge (either top or
right). When you request normalized coordinates, the z-component of the
returned vector is zero. Multiply a normalized coordinate by the values
returned by Screen::widthPixels() or Screen::heightPixels() to calculate
the screen position in pixels (remembering that many other computer
graphics coordinate systems place the origin in the top-left corner).

Set the normalize parameter to false to request the intersection point
in Leap coordinates (millimeters from the Leap origin).

If the specified ray points outside the screen's border (but still
intersects the plane in which the screen lies), the returned intersection
point is clamped to the nearest point on the edge of the screen.

You can use the clampRatio parameter to contract or expand the area in
which you can point. For example, if you set the clampRatio parameter to
0.5, then the positions reported for intersection points outside the
central 50% of the screen are moved to the border of this smaller area.
If, on the other hand, you expanded the area by setting clampRatio to
a value such as 3.0, then you could point well outside screen's physical
boundary before the intersection points would be clamped. The positions
for any points clamped would also be placed on this larger outer border.
The positions reported for any intersection points inside the clamping
border are unaffected by clamping.

If the specified ray does not point toward the plane of the screen
(i.e. it is pointing parallel to or away from the screen), then the
components of the returned vector are all set to NaN (not-a-number).

Arguments:
position (Leap::Vector const &) -- The position from which to check for screen intersection.
direction (Leap::Vector const &) -- The direction in which to check for screen intersection.

normalize (bool) -- If true, return normalized coordinates representing
the intersection point as a percentage of the screen's width and height.
If false, return Leap coordinates (millimeters from the Leap origin,
which is located at the center of the top surface of the Leap device).
If true and the clampRatio parameter is set to 1.0, coordinates will be
of the form (0..1, 0..1, 0). Setting the clampRatio to a different value
changes the range for normalized coordinates. For example, a clampRatio
of 5.0 changes the range of values to be of the form (-2..3, -2..3, 0).

clampRatio (float) -- Adjusts the clamping border around this screen.
By default this ratio is 1.0, and the border corresponds to the actual
boundaries of the screen. Setting clampRatio to 0.5 would reduce the
interaction area. Likewise, setting the ratio to 2.0 would increase the
interaction area, adding 50% around each edge of the physical monitor.
Intersection points outside the interaction area are repositioned to
the closest point on the clamping border before the vector is returned.

Returns: A Vector containing the coordinates of the intersection between
this screen and a ray projecting from the specified position in the
specified direction.

----------------------------------------------------------------
Overload 3:
----------------------------------------------------------------
Returns the intersection between this screen and a ray projecting from
the specified position along the specified direction.

Set the normalize parameter to true to request the intersection point in
normalized screen coordinates. Normalized screen coordinates are usually
values between 0 and 1, where 0 represents the screen's origin at the
bottom-left corner and 1 represents the opposite edge (either top or
right). When you request normalized coordinates, the z-component of the
returned vector is zero. Multiply a normalized coordinate by the values
returned by Screen::widthPixels() or Screen::heightPixels() to calculate
the screen position in pixels (remembering that many other computer
graphics coordinate systems place the origin in the top-left corner).

Set the normalize parameter to false to request the intersection point
in Leap coordinates (millimeters from the Leap origin).

If the specified ray points outside the screen's border (but still
intersects the plane in which the screen lies), the returned intersection
point is clamped to the nearest point on the edge of the screen.

You can use the clampRatio parameter to contract or expand the area in
which you can point. For example, if you set the clampRatio parameter to
0.5, then the positions reported for intersection points outside the
central 50% of the screen are moved to the border of this smaller area.
If, on the other hand, you expanded the area by setting clampRatio to
a value such as 3.0, then you could point well outside screen's physical
boundary before the intersection points would be clamped. The positions
for any points clamped would also be placed on this larger outer border.
The positions reported for any intersection points inside the clamping
border are unaffected by clamping.

If the specified ray does not point toward the plane of the screen
(i.e. it is pointing parallel to or away from the screen), then the
components of the returned vector are all set to NaN (not-a-number).

Arguments:
position (Leap::Vector const &) -- The position from which to check for screen intersection.
direction (Leap::Vector const &) -- The direction in which to check for screen intersection.

normalize (bool) -- If true, return normalized coordinates representing
the intersection point as a percentage of the screen's width and height.
If false, return Leap coordinates (millimeters from the Leap origin,
which is located at the center of the top surface of the Leap device).
If true and the clampRatio parameter is set to 1.0, coordinates will be
of the form (0..1, 0..1, 0). Setting the clampRatio to a different value
changes the range for normalized coordinates. For example, a clampRatio
of 5.0 changes the range of values to be of the form (-2..3, -2..3, 0).

clampRatio (none) -- Adjusts the clamping border around this screen.
By default this ratio is 1.0, and the border corresponds to the actual
boundaries of the screen. Setting clampRatio to 0.5 would reduce the
interaction area. Likewise, setting the ratio to 2.0 would increase the
interaction area, adding 50% around each edge of the physical monitor.
Intersection points outside the interaction area are repositioned to
the closest point on the clamping border before the vector is returned.

Returns: A Vector containing the coordinates of the intersection between
this screen and a ray projecting from the specified position in the
specified direction.
normal(self)
normal(Screen self) -> Vector

A Vector normal to the plane in which this Screen lies.

The normal vector is a unit direction vector orthogonal to the screen's
surface plane. It points toward a viewer positioned for typical use of
the monitor.

Returns: A Vector representing this Screen's normal vector.
project(self, *args)
project(Screen self, Vector position, bool normalize, float clamp_ratio=1.0) -> Vector
project(Screen self, Vector position, bool normalize) -> Vector

Returns the projection from the specified position onto this screen.

Set the normalize parameter to true to request the projection point in
normalized screen coordinates. Normalized screen coordinates are usually
values between 0 and 1, where 0 represents the screen's origin at the
bottom-left corner and 1 represents the opposite edge (either top or
right). When you request normalized coordinates, the z-component of the
returned vector is zero. Multiply a normalized coordinate by the values
returned by Screen::widthPixels() or Screen::heightPixels() to calculate
the screen position in pixels (remembering that many other computer
graphics coordinate systems place the origin in the top-left corner).

Set the normalize parameter to false to request the projection point
in Leap coordinates (millimeters from the Leap origin).

If the specified point projects outside the screen's border, the returned
projection point is clamped to the nearest point on the edge of the screen.

You can use the clampRatio parameter to contract or expand the area in
which you can point. For example, if you set the clampRatio parameter to
0.5, then the positions reported for projection points outside the
central 50% of the screen are moved to the border of this smaller area.
If, on the other hand, you expanded the area by setting clampRatio to
a value such as 3.0, then you could point well outside screen's physical
boundary before the projection points would be clamped. The positions
for any points clamped would also be placed on this larger outer border.
The positions reported for any projection points inside the clamping
border are unaffected by clamping.

Arguments:
position (Leap::Vector const &) -- The position from which to project onto this screen.

normalize (bool) -- If true, return normalized coordinates representing
the projection point as a percentage of the screen's width and height.
If false, return Leap coordinates (millimeters from the Leap origin,
which is located at the center of the top surface of the Leap device).
If true and the clampRatio parameter is set to 1.0, coordinates will be
of the form (0..1, 0..1, 0). Setting the clampRatio to a different value
changes the range for normalized coordinates. For example, a clampRatio
of 5.0 changes the range of values to be of the form (-2..3, -2..3, 0).

clampRatio (float) -- Adjusts the clamping border around this screen.
By default this ratio is 1.0, and the border corresponds to the actual
boundaries of the screen. Setting clampRatio to 0.5 would reduce the
interaction area. Likewise, setting the ratio to 2.0 would increase the
interaction area, adding 50% around each edge of the physical monitor.
Projection points outside the interaction area are repositioned to
the closest point on the clamping border before the vector is returned.

Returns: A Vector containing the coordinates of the projection between
this screen and a ray projecting from the specified position onto the
screen along its normal vector.

Data descriptors defined here:
bottom_left_corner
height_pixels
horizontal_axis
id
is_valid
vertical_axis
width_pixels

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_Screen>
__swig_getmethods__ = {'bottom_left_corner': <built-in function Screen_bottom_left_corner_get>, 'height_pixels': <built-in function Screen_height_pixels_get>, 'horizontal_axis': <built-in function Screen_horizontal_axis_get>, 'id': <built-in function Screen_id_get>, 'is_valid': <built-in function Screen_is_valid_get>, 'vertical_axis': <built-in function Screen_vertical_axis_get>, 'width_pixels': <built-in function Screen_width_pixels_get>}
__swig_setmethods__ = {}
invalid = <Leap.Screen; proxy of <Swig Object of type 'Leap::Screen *' at 0x10d58f180> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class ScreenList(Interface)
The ScreenList class represents a list of Screen objects.

The list always contains at least one entry representing the default
screen. If the user has not registered the location of this default
screen, then the coordinates, directions, and other values reported by
the functions in its Screen object will not be accurate. Other monitor
screens only appear in the list if their positions have been registered
using the Leap Screen Locator.

Get a ScreenList object by calling Controller::locatedScreens().

        screens = self.controller.located_screens
Method resolution order:
ScreenList
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__getitem__(self, *args)
__getitem__(ScreenList self, int index) -> Screen

Access a list member by its position in the list.
Arguments:
index (int) -- The zero-based list position index.
Returns: The Screen object at the specified index.
__init__(self)
__init__(Leap::ScreenList self) -> ScreenList

Constructs an empty list of screens.
__iter__(self)
__len__(self)
__len__(ScreenList self) -> int

Returns the number of screens in this list.
Returns: The number of screens in this list.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
closest_screen(self, *args)
closest_screen(ScreenList self, Vector position) -> Screen

Gets the Screen closest to the specified position.

The specified position is projected along each screen's normal vector
onto the screen's plane. The screen whose projected point is closest to
the specified position is returned. Call Screen::project(position)
on the returned Screen object to find the projected point.

        frame = self.controller.frame()
        if not frame.pointables.empty:
            pointable = frame.pointables[0]
            screens = self.controller.located_screens
            screen = screens.closest_screen(pointable.tip_position)

Arguments:
position (Leap::Vector const &) -- The position from which to check for screen projection.
Returns: The closest Screen onto which the specified position is projected.
closest_screen_hit(self, *args)
closest_screen_hit(ScreenList self, Pointable pointable) -> Screen
closest_screen_hit(ScreenList self, Vector position, Vector direction) -> Screen

----------------------------------------------------------------
Overload 1:
----------------------------------------------------------------
Gets the closest Screen intercepting a ray projecting from the specified
Pointable object.

The projected ray emanates from the Pointable tipPosition along the
Pointable's direction vector. If the projected ray does not intersect
any screen surface directly, then the Leap checks for intersection with
the planes extending from the surfaces of the known screens
and returns the Screen with the closest intersection.

        frame = self.controller.frame()
        if not frame.pointables.empty:
            pointable = frame.pointables[0]
            screens = self.controller.located_screens
            screen = screens.closest_screen_hit(pointable)

If no intersections are found (i.e. the ray is directed parallel to or
away from all known screens), then an invalid Screen object is returned.

*Note:* Be sure to test whether the Screen object returned by this method
is valid. Attempting to use an invalid Screen object will lead to
incorrect results.

Arguments:
pointable (Leap::Pointable const &) -- The Pointable object to check for screen intersection.
Returns: The closest Screen toward which the specified Pointable object
is pointing, or, if the pointable is not pointing in the direction of
any known screen, an invalid Screen object.

----------------------------------------------------------------
Overload 2:
----------------------------------------------------------------
Gets the closest Screen intercepting a ray projecting from the specified
position in the specified direction.

The projected ray emanates from the position along the direction vector.
If the projected ray does not intersect any screen surface directly,
then the Leap checks for intersection with the planes extending from the
surfaces of the known screens and returns the Screen with the closest
intersection.

        frame = self.controller.frame()
        if not frame.pointables.empty:
            pointable = frame.pointables[0]
            screens = self.controller.located_screens
            screen = screens.closest_screen(pointable.tip_position)

If no intersections are found (i.e. the ray is directed parallel to or
away from all known screens), then an invalid Screen object is returned.

*Note:* Be sure to test whether the Screen object returned by this method
is valid. Attempting to use an invalid Screen object will lead to
incorrect results.

Arguments:
position (Leap::Vector const &) -- The position from which to check for screen intersection.
direction (Leap::Vector const &) -- The direction in which to check for screen intersection.
Returns: The closest Screen toward which the specified ray is pointing,
or, if the ray is not pointing in the direction of any known screen,
an invalid Screen object.

Data descriptors defined here:
empty
is_empty

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_ScreenList>
__swig_getmethods__ = {'empty': <built-in function ScreenList_empty_get>, 'is_empty': <built-in function ScreenList_is_empty_get>}
__swig_setmethods__ = {}

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class ScreenTapGesture(Gesture)
The ScreenTapGesture class represents a tapping gesture by a finger or tool.

A screen tap gesture is recognized when the tip of a finger pokes forward
and then springs back to approximately the original postion, as if
tapping a vertical screen. The tapping finger must pause briefly before beginning the tap.


**Important:** To use screen tap gestures in your application, you must enable
recognition of the screen tap gesture. You can enable recognition with:

        controller.enableGesture(Leap.Gesture.Type.TYPE_SCREEN_TAP);

ScreenTap gestures are discrete. The ScreenTapGesture object representing a tap always
has the state, STATE_STOP. Only one ScreenTapGesture object is created for each
screen tap gesture recognized.

You can set the minimum finger movement and velocity required for a movement
to be recognized as a screen tap as well as adjust the detection window for
evaluating the movement using the config attribute of a connected
Controller object. Use the following keys to configure screen tap recognition:

Key string | Value type | Default value | Units
-----------|------------|---------------|------
Gesture.ScreenTap.MinForwardVelocity | float | 50 | mm/s
Gesture.ScreenTap.HistorySeconds | float | 0.1 | s
Gesture.ScreenTap.MinDistance | float | 3.0 | mm

The following example demonstrates how to set the screen tap configuration
parameters:

        if(controller.config.set_float("Gesture.ScreenTap.MinForwardVelocity", 30.0)
            and controller.config.set_float("Gesture.ScreenTap.HistorySeconds", .5)
            and controller.config.set_float("Gesture.ScreenTap.MinDistance", 1.0)):
                controller.config.save();
Method resolution order:
ScreenTapGesture
Gesture
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__init__(self, *args)
__init__(Leap::ScreenTapGesture self) -> ScreenTapGesture
__init__(Leap::ScreenTapGesture self, Gesture rhs) -> ScreenTapGesture

Constructs a ScreenTapGesture object from an instance of the Gesture class.

Arguments:
rhs (Leap::Gesture const &) -- The Gesture instance to specialize. This Gesture instance must
be a ScreenTapGesture object.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value

Static methods defined here:
class_type()
class_type() -> Leap::Gesture::Type

The screen tap gesture type.

Returns: Type The type value designating a screen tap gesture.

Data descriptors defined here:
direction
pointable
position
progress

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_ScreenTapGesture>
__swig_getmethods__ = {'class_type': <function <lambda>>, 'direction': <built-in function ScreenTapGesture_direction_get>, 'duration': <built-in function Gesture_duration_get>, 'duration_seconds': <built-in function Gesture_duration_seconds_get>, 'frame': <built-in function Gesture_frame_get>, 'hands': <built-in function Gesture_hands_get>, 'id': <built-in function Gesture_id_get>, 'is_valid': <built-in function Gesture_is_valid_get>, 'pointable': <built-in function ScreenTapGesture_pointable_get>, 'pointables': <built-in function Gesture_pointables_get>, ...}
__swig_setmethods__ = {}

Methods inherited from Gesture:
__eq__(self, *args)
__eq__(Gesture self, Gesture rhs) -> bool

Compare Gesture object equality.

Two Gestures are equal if they represent the same snapshot of the same
recognized movement.
__ne__(self, *args)
__ne__(Gesture self, Gesture rhs) -> bool

Compare Gesture object inequality.

Two Gestures are equal only if they represent the same snapshot of the same
recognized movement.
__str__(self)
__str__(Gesture self) -> std::string

A string containing a brief, human-readable description of this
Gesture.

Data descriptors inherited from Gesture:
duration
duration_seconds
frame
hands
id
is_valid
pointables
state
type

Data and other attributes inherited from Gesture:
STATE_INVALID = -1
STATE_START = 1
STATE_STOP = 3
STATE_UPDATE = 2
TYPE_CIRCLE = 4
TYPE_INVALID = -1
TYPE_KEY_TAP = 6
TYPE_SCREEN_TAP = 5
TYPE_SWIPE = 1
invalid = <Leap.Gesture; proxy of <Swig Object of type 'Leap::Gesture *' at 0x10d58f150> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class SwigPyIterator(__builtin__.object)
Methods defined here:
__add__(self, *args)
__add__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
__del__ lambda self
__eq__(self, *args)
__eq__(SwigPyIterator self, SwigPyIterator x) -> bool
__getattr__ lambda self, name
__iadd__(self, *args)
__iadd__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
__init__(self, *args, **kwargs)
__isub__(self, *args)
__isub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
__iter__(self)
__ne__(self, *args)
__ne__(SwigPyIterator self, SwigPyIterator x) -> bool
__next__(self)
__next__(SwigPyIterator self) -> PyObject *
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__sub__(self, *args)
__sub__(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
__sub__(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
advance(self, *args)
advance(SwigPyIterator self, ptrdiff_t n) -> SwigPyIterator
copy(self)
copy(SwigPyIterator self) -> SwigPyIterator
decr(self, n=1)
decr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
decr(SwigPyIterator self) -> SwigPyIterator
distance(self, *args)
distance(SwigPyIterator self, SwigPyIterator x) -> ptrdiff_t
equal(self, *args)
equal(SwigPyIterator self, SwigPyIterator x) -> bool
incr(self, n=1)
incr(SwigPyIterator self, size_t n=1) -> SwigPyIterator
incr(SwigPyIterator self) -> SwigPyIterator
next(self)
next(SwigPyIterator self) -> PyObject *
previous(self)
previous(SwigPyIterator self) -> PyObject *
value(self)
value(SwigPyIterator self) -> PyObject *

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_SwigPyIterator>
__swig_getmethods__ = {}
__swig_setmethods__ = {}


class SwipeGesture(Gesture)
The SwipeGesture class represents a swiping motion of a finger or tool.


**Important:** To use swipe gestures in your application, you must enable
recognition of the swipe gesture. You can enable recognition with:

        controller.enable_gesture(Leap.Gesture.Type.TYPE_SWIPE);

Swipe gestures are continuous.

You can set the minimum length and velocity required for a movement
to be recognized as a swipe using the config attribute of a connected
Controller object. Use the following keys to configure swipe recognition:

Key string | Value type | Default value | Units
-----------|------------|---------------|------
Gesture.Swipe.MinLength | float | 150 | mm
Gesture.Swipe.MinVelocity | float | 1000 | mm/s

The following example demonstrates how to set the swipe configuration
parameters:

        if(controller.config.set_float("Gesture.Swipe.MinLength", 200.0)
          and controller.config.set_float("Gesture.Swipe.MinVelocity", 750)):
            controller.config().save();
Method resolution order:
SwipeGesture
Gesture
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__init__(self, *args)
__init__(Leap::SwipeGesture self) -> SwipeGesture
__init__(Leap::SwipeGesture self, Gesture rhs) -> SwipeGesture

Constructs a SwipeGesture object from an instance of the Gesture class.

Arguments:
rhs (Leap::Gesture const &) -- The Gesture instance to specialize. This Gesture instance must
be a SwipeGesture object.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value

Static methods defined here:
class_type()
class_type() -> Leap::Gesture::Type

The swipe gesture type.

Returns: Type The type value designating a swipe gesture.

Data descriptors defined here:
direction
pointable
position
speed
start_position

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_SwipeGesture>
__swig_getmethods__ = {'class_type': <function <lambda>>, 'direction': <built-in function SwipeGesture_direction_get>, 'duration': <built-in function Gesture_duration_get>, 'duration_seconds': <built-in function Gesture_duration_seconds_get>, 'frame': <built-in function Gesture_frame_get>, 'hands': <built-in function Gesture_hands_get>, 'id': <built-in function Gesture_id_get>, 'is_valid': <built-in function Gesture_is_valid_get>, 'pointable': <built-in function SwipeGesture_pointable_get>, 'pointables': <built-in function Gesture_pointables_get>, ...}
__swig_setmethods__ = {}

Methods inherited from Gesture:
__eq__(self, *args)
__eq__(Gesture self, Gesture rhs) -> bool

Compare Gesture object equality.

Two Gestures are equal if they represent the same snapshot of the same
recognized movement.
__ne__(self, *args)
__ne__(Gesture self, Gesture rhs) -> bool

Compare Gesture object inequality.

Two Gestures are equal only if they represent the same snapshot of the same
recognized movement.
__str__(self)
__str__(Gesture self) -> std::string

A string containing a brief, human-readable description of this
Gesture.

Data descriptors inherited from Gesture:
duration
duration_seconds
frame
hands
id
is_valid
pointables
state
type

Data and other attributes inherited from Gesture:
STATE_INVALID = -1
STATE_START = 1
STATE_STOP = 3
STATE_UPDATE = 2
TYPE_CIRCLE = 4
TYPE_INVALID = -1
TYPE_KEY_TAP = 6
TYPE_SCREEN_TAP = 5
TYPE_SWIPE = 1
invalid = <Leap.Gesture; proxy of <Swig Object of type 'Leap::Gesture *' at 0x10d58f150> >

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Tool(Pointable)
The Tool class represents a tracked tool.

Tools are Pointable objects that the Leap has classified as a tool.
Tools are longer, thinner, and straighter than a typical finger.
Get valid Tool objects from a Frame or a Hand object.


Note that Tool objects can be invalid, which means that they do not contain
valid tracking data and do not correspond to a physical tool. Invalid Tool
objects can be the result of asking for a Tool object using an ID from an
earlier frame when no Tool objects with that ID exist in the current frame.
A Tool object created from the Tool constructor is also invalid.
Test for validity with the Tool::isValid() function.
Method resolution order:
Tool
Pointable
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__init__(self, *args)
__init__(Leap::Tool self) -> Tool
__init__(Leap::Tool self, Pointable arg2) -> Tool

If the specified Pointable object represents a tool, creates a copy
of it as a Tool object; otherwise, creates an invalid Tool object.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(Tool self) -> std::string

A string containing a brief, human readable description of the Tool object.

Returns: A description of the Tool object as a string.

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_Tool>
__swig_getmethods__ = {'direction': <built-in function Pointable_direction_get>, 'frame': <built-in function Pointable_frame_get>, 'hand': <built-in function Pointable_hand_get>, 'id': <built-in function Pointable_id_get>, 'is_finger': <built-in function Pointable_is_finger_get>, 'is_tool': <built-in function Pointable_is_tool_get>, 'is_valid': <built-in function Pointable_is_valid_get>, 'length': <built-in function Pointable_length_get>, 'stabilized_tip_position': <built-in function Pointable_stabilized_tip_position_get>, 'tip_position': <built-in function Pointable_tip_position_get>, ...}
__swig_setmethods__ = {}
invalid = <Leap.Tool; proxy of <Swig Object of type 'Leap::Tool *' at 0x10d58f0f0> >

Methods inherited from Pointable:
__eq__(self, *args)
__eq__(Pointable self, Pointable arg2) -> bool

Compare Pointable object equality.
Two Pointable objects are equal if and only if both Pointable objects represent the
exact same physical entities in the same frame and both Pointable objects are valid.
__ne__(self, *args)
__ne__(Pointable self, Pointable arg2) -> bool

Compare Pointable object inequality.
Two Pointable objects are equal if and only if both Pointable objects represent the
exact same physical entities in the same frame and both Pointable objects are valid.

Data descriptors inherited from Pointable:
direction
frame
hand
id
is_finger
is_tool
is_valid
length
stabilized_tip_position
tip_position
tip_velocity
touch_distance
touch_zone
width

Data and other attributes inherited from Pointable:
ZONE_HOVERING = 1
ZONE_NONE = 0
ZONE_TOUCHING = 2

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class ToolList(Interface)
The ToolList class represents a list of Tool objects.

Get a ToolList object by calling Frame::tools().
Method resolution order:
ToolList
Interface
__builtin__.object

Methods defined here:
__del__ lambda self
__getattr__ lambda self, name
__getitem__(self, *args)
__getitem__(ToolList self, int index) -> Tool

Access a list member by its position in the list.
Arguments:
index (int) -- The zero-based list position index.
Returns: The Tool object at the specified index.
__init__(self)
__init__(Leap::ToolList self) -> ToolList

Constructs an empty list of tools.
__iter__(self)
__len__(self)
__len__(ToolList self) -> int

Returns the number of tools in this list.
Returns: The number of tools in this list.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
append(self, *args)
append(ToolList self, ToolList other) -> ToolList

Appends the members of the specifed ToolList to this ToolList.
Arguments:
other (Leap::ToolList const &) -- A ToolList object containing Tool objects
to append to the end of this ToolList.

Data descriptors defined here:
empty
frontmost
is_empty
leftmost
rightmost

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_ToolList>
__swig_getmethods__ = {'empty': <built-in function ToolList_empty_get>, 'frontmost': <built-in function ToolList_frontmost_get>, 'is_empty': <built-in function ToolList_is_empty_get>, 'leftmost': <built-in function ToolList_leftmost_get>, 'rightmost': <built-in function ToolList_rightmost_get>}
__swig_setmethods__ = {}

Data descriptors inherited from Interface:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)


class Vector(__builtin__.object)
The Vector struct represents a three-component mathematical vector or point
such as a direction or position in three-dimensional space.

The Leap software employs a right-handed Cartesian coordinate system.
Values given are in units of real-world millimeters. The origin is centered
at the center of the Leap device. The x- and z-axes lie in the horizontal
plane, with the x-axis running parallel to the long edge of the device.
The y-axis is vertical, with positive values increasing upwards (in contrast
to the downward orientation of most computer graphics coordinate systems).
The z-axis has positive values increasing away from the computer screen.

Methods defined here:
__add__(self, *args)
__add__(Vector self, Vector other) -> Vector

Add vectors component-wise.

    sum = thisVector.plus(thatVector);
__del__ lambda self
__div__(self, *args)
__div__(Vector self, float scalar) -> Vector

Divide vector by a scalar.

    quotient = thisVector.divide(2.5);
__eq__(self, *args)
__eq__(Vector self, Vector other) -> bool

Compare Vector equality component-wise.

    vectorsAreEqual = thisVector == thatVector;
__getattr__ lambda self, name
__getitem__(self, *args)
__getitem__(Vector self, unsigned int index) -> float

Index vector components numerically.
Index 0 is x, index 1 is y, and index 2 is z.
Returns: The x, y, or z component of this Vector, if the specified index
value is at least 0 and at most 2; otherwise, returns zero.

    x = thisVector.get(0);
    y = thisVector.get(1);
    z = thisVector.get(2);
__iadd__(self, *args)
__iadd__(Vector self, Vector other) -> Vector

Add vectors component-wise and assign the sum.
__idiv__(self, *args)
__idiv__(Vector self, float scalar) -> Vector

Divide vector by a scalar and assign the quotient.
__imul__(self, *args)
__imul__(Vector self, float scalar) -> Vector

Multiply vector by a scalar and assign the product.
__init__(self, *args)
__init__(Leap::Vector self) -> Vector
__init__(Leap::Vector self, float _x, float _y, float _z) -> Vector
__init__(Leap::Vector self, Vector vector) -> Vector

Copies the specified Vector.

    copiedVector = Leap.Vector(otherVector);
__isub__(self, *args)
__isub__(Vector self, Vector other) -> Vector

Subtract vectors component-wise and assign the difference.
__mul__(self, *args)
__mul__(Vector self, float scalar) -> Vector

Multiply vector by a scalar.

    product = thisVector.mul(5.0);
__ne__(self, *args)
__ne__(Vector self, Vector other) -> bool

Compare Vector inequality component-wise.

    vectorsNotEqual = thisVector != thatVector;
__neg__(self)
__neg__(Vector self) -> Vector

A copy of this vector pointing in the opposite direction.

    negation = thisVector.neg();

Returns: A Vector object with all components negated.
__repr__ = _swig_repr(self)
__setattr__ lambda self, name, value
__str__(self)
__str__(Vector self) -> std::string

Returns a string containing this vector in a human readable format: (x, y, z).
__sub__(self, *args)
__sub__(Vector self, Vector other) -> Vector

Subtract vectors component-wise.

    difference = thisVector.sub(thatVector);
angle_to(self, *args)
angle_to(Vector self, Vector other) -> float

The angle between this vector and the specified vector in radians.

The angle is measured in the plane formed by the two vectors. The
angle returned is always the smaller of the two conjugate angles.
Thus A.angleTo(B) == B.angleTo(A) and is always a positive
value less than or equal to pi radians (180 degrees).

If either vector has zero length, then this function returns zero.


    angleInRadians = Leap.Vector.xAxis().angleTo(Leap.Vector.yAxis());
    # angleInRadians = PI/2 (90 degrees)

Arguments:
other (Leap::Vector const &) -- A Vector object.
Returns: The angle between this vector and the specified vector in radians.
cross(self, *args)
cross(Vector self, Vector other) -> Vector

The cross product of this vector and the specified vector.

The cross product is a vector orthogonal to both original vectors.
It has a magnitude equal to the area of a parallelogram having the
two vectors as sides. The direction of the returned vector is
determined by the right-hand rule. Thus A.cross(B) == -B.cross(A).


    crossProduct = thisVector.cross(thatVector);

Arguments:
other (Leap::Vector const &) -- A Vector object.
Returns: The cross product of this vector and the specified vector.
distance_to(self, *args)
distance_to(Vector self, Vector other) -> float

The distance between the point represented by this Vector
object and a point represented by the specified Vector object.

    aPoint = Leap.Vector(10, 0, 0);
    origin = Leap.Vector.zero();
    distance = origin.distanceTo(aPoint); # distance = 10

Arguments:
other (Leap::Vector const &) -- A Vector object.
Returns: The distance from this point to the specified point.
dot(self, *args)
dot(Vector self, Vector other) -> float

The dot product of this vector with another vector.

The dot product is the magnitude of the projection of this vector
onto the specified vector.


    dotProduct = thisVector.dot(thatVector);

Arguments:
other (Leap::Vector const &) -- A Vector object.
Returns: The dot product of this vector and the specified vector.
is_valid(self)
is_valid(Vector self) -> bool

Returns true if all of the vector's components are finite. If any
component is NaN or infinite, then this returns false.

    vectorsIsValid = thisVector.isValid();
to_float_array(self)
to_tuple(self)

Data descriptors defined here:
__dict__
dictionary for instance variables (if defined)
__weakref__
list of weak references to the object (if defined)
magnitude
magnitude_squared
normalized
pitch
roll
x
y
yaw
z

Data and other attributes defined here:
__swig_destroy__ = <built-in function delete_Vector>
__swig_getmethods__ = {'magnitude': <built-in function Vector_magnitude_get>, 'magnitude_squared': <built-in function Vector_magnitude_squared_get>, 'normalized': <built-in function Vector_normalized_get>, 'pitch': <built-in function Vector_pitch_get>, 'roll': <built-in function Vector_roll_get>, 'x': <built-in function Vector_x_get>, 'y': <built-in function Vector_y_get>, 'yaw': <built-in function Vector_yaw_get>, 'z': <built-in function Vector_z_get>}
__swig_setmethods__ = {'x': <built-in function Vector_x_set>, 'y': <built-in function Vector_y_set>, 'z': <built-in function Vector_z_set>}
backward = <Leap.Vector; proxy of <Swig Object of type 'Leap::Vector *' at 0x10d58bd20> >
down = <Leap.Vector; proxy of <Swig Object of type 'Leap::Vector *' at 0x10d58bf60> >
forward = <Leap.Vector; proxy of <Swig Object of type 'Leap::Vector *' at 0x10d58bcc0> >
left = <Leap.Vector; proxy of <Swig Object of type 'Leap::Vector *' at 0x10d58bd80> >
right = <Leap.Vector; proxy of <Swig Object of type 'Leap::Vector *' at 0x10d58bdb0> >
up = <Leap.Vector; proxy of <Swig Object of type 'Leap::Vector *' at 0x10d58bde0> >
x_axis = <Leap.Vector; proxy of <Swig Object of type 'Leap::Vector *' at 0x10d58b6f0> >
y_axis = <Leap.Vector; proxy of <Swig Object of type 'Leap::Vector *' at 0x10d58b720> >
z_axis = <Leap.Vector; proxy of <Swig Object of type 'Leap::Vector *' at 0x10d58b870> >
zero = <Leap.Vector; proxy of <Swig Object of type 'Leap::Vector *' at 0x10d58b630> >


Functions
CircleGesture_class_type()
CircleGesture_class_type() -> Leap::Gesture::Type

The circle gesture type.

Returns: Type The type value designating a circle gesture.
CircleGesture_swigregister(...)
Config_swigregister(...)
Controller_swigregister(...)
DeviceList_swigregister(...)
Device_swigregister(...)
FingerList_swigregister(...)
Finger_swigregister(...)
Frame_swigregister(...)
GestureList_swigregister(...)
Gesture_swigregister(...)
HandList_swigregister(...)
Hand_swigregister(...)
InteractionBox_swigregister(...)
Interface_swigregister(...)
KeyTapGesture_class_type()
KeyTapGesture_class_type() -> Leap::Gesture::Type

The key tap gesture type.

Returns: Type The type value designating a key tap gesture.
KeyTapGesture_swigregister(...)
Listener_swigregister(...)
Matrix_swigregister(...)
PointableList_swigregister(...)
Pointable_swigregister(...)
ScreenList_swigregister(...)
ScreenTapGesture_class_type()
ScreenTapGesture_class_type() -> Leap::Gesture::Type

The screen tap gesture type.

Returns: Type The type value designating a screen tap gesture.
ScreenTapGesture_swigregister(...)
Screen_swigregister(...)
SwigPyIterator_swigregister(...)
SwipeGesture_class_type()
SwipeGesture_class_type() -> Leap::Gesture::Type

The swipe gesture type.

Returns: Type The type value designating a swipe gesture.
SwipeGesture_swigregister(...)
ToolList_swigregister(...)
Tool_swigregister(...)
Vector_swigregister(...)
weakref_proxy = proxy(...)
proxy(object[, callback]) -- create a proxy object that weakly
references 'object'. 'callback', if given, is called with a
reference to the proxy when 'object' is about to be finalized.


Data
DEG_TO_RAD = 0.01745329238474369
PI = 3.1415927410125732
RAD_TO_DEG = 57.295780181884766
cvar = <Swig global variables>