# Fingers¶

Fingers are represented by Pointable objects. In addition, a separate Finger class specializes the Pointable class to provide specific finger information.

## Getting Pointable Objects¶

You can get the fingers associated with a particular hand from the Hand object. You can also get all detected pointables (fingers) from a Frame object.

## Pointable Object Characteristics¶

Pointable objects have many attributes describing the characteristics of the represented finger.

• Tip position — the instantaneous position in mm from the Leap Motion origin.
• Tip velocity — the instantaneous velocity in mm/s.
• Stabilized tip position — the position filtered and stabilized using velocity and past positions.
• Direction — the current pointing direction vector.
• Length — the apparent length of the finger.
• Width — the average width.
• Touch distance — the normalized distance from the virtual touch plane. See Leap_Touch_Emulation.
• Touch zone — the pointable’s current relation to the virtual touch plane.

The following example illustrates how to get a pointable object from a frame and access its basic characteristics:

Leap::Pointable pointable = frame.pointables().frontmost();
Leap::Vector direction = pointable.direction();
float length = pointable.length();
float width = pointable.width();
Leap::Vector stabilizedPosition = pointable.stabilizedTipPosition();
Leap::Vector position = pointable.tipPosition();
Leap::Vector speed = pointable.tipVelocity();
float touchDistance = pointable.touchDistance();
Leap::Pointable::Zone zone = pointable.touchZone();


## Converting a Pointable Instance to a Finger Instance¶

To convert a Pointable object to its Finger subclass, use the Finger constructor (one of the few times that you should use the constructor for a Leap class).

if (pointable.isTool()) {
Leap::Tool tool = Leap::Tool(pointable);
} else {
Leap::Finger finger = Leap::Finger(pointable);
}


## Fingers¶

Finger objects extend Pointable to represent physical fingers. A finger has a type, a direction and a set of bones.

As of version 2.0 of the Leap Motion SDK, all five fingers are are always present in the list of fingers for a hand. The Leap Motion software estimates positions for fingers and bones that it cannot track clearly. Thus subtle movements of fingers against or behind the hand (as seen from the Leap Motion sensor’s point of view) may not be reflected in the data.

Fingers can be identified by type, e.g. the index, thumb, pinky. Finger IDs are assigned based on the hand ID. If a hand has an ID of “5”, then its fingers are assigned IDs 50 to 55, ordered from thumb to pinky.

## Pointable and Finger Lists¶

The PointableList and FingerList classes all have a similar structure. They are designed to act like vector-style arrays and support iterators. You cannot remove or alter the member objects of lists received from the Leap API, but you can combine lists of the same object type.

To use an iterator with one of these lists:

for(HandList::const_iterator hl = handList.begin(); hl != handList.end(); hl++)
std::cout << *hl << std::endl;


The PointableList and FingerList classes define additional functions for getting members of the list based on their relative position within the Leap coordinate system. These functions include leftmost(), rightmost(), and frontmost(). The following snippet illustrates a few ways to use these functions:

Leap::Finger farLeft = frame.fingers().leftmost();
Leap::Finger mostForwardOnHand = frame.hands()[0].fingers().frontmost();
Leap::Tool rightTool = frame.tools().rightmost();