Class: Hand

Leap. Hand

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

new Hand()

Constructs a Hand object.

An uninitialized hand is considered invalid. Get valid Hand objects from a Frame object.

Source:
  • hand.js, line 6

Members

<static> Invalid :Leap.Hand

An invalid Hand object.

You can use an invalid Hand object in comparisons testing whether a given Hand instance is valid or invalid. (You can also use the Hand valid property.)

Type:
Source:
  • hand.js, line 334

direction :Leap.Vector

The direction from the palm position toward the fingers.

The direction is expressed as a unit vector pointing in the same direction as the directed line from the palm position to the fingers.

Type:
Source:
  • hand.js, line 50

fingers[] :Leap.Pointable

The list of fingers detected in this frame that are attached to this hand, given in arbitrary order.

The list can be empty if no fingers attached to this hand are detected.

Type:
Source:
  • hand.js, line 127

id :String

A unique ID assigned to this Hand object, whose value remains the same across consecutive frames while the tracked hand remains visible. If tracking is lost (for example, when a hand is occluded by another hand or when it is withdrawn from or reaches the edge of the Leap field of view), the Leap may assign a new ID when it detects the hand in a future frame.

Use the ID value with the Frame.hand() function to find this Hand object in future frames.

Type:
  • String
Source:
  • hand.js, line 28

palmNormal :Leap.Vector

The normal vector to the palm. If your hand is flat, this vector will point downward, or "out" of the front surface of your palm.

Palm Vectors

The direction is expressed as a unit vector pointing in the same direction as the palm normal (that is, a vector orthogonal to the palm).

Type:
Source:
  • hand.js, line 69

palmPosition :Leap.Vector

The center position of the palm in millimeters from the Leap origin.

Type:
Source:
  • hand.js, line 43

palmVeclocity :Leap.Vector

The rate of change of the palm position in millimeters/second.

Type:
Source:
  • hand.js, line 61

pointables[] :Leap.Pointable

The list of Pointable objects (fingers and tools) detected in this frame that are associated with this hand, given in arbitrary order. The list can be empty if no fingers or tools associated with this hand are detected.

Use the Pointable tool property to determine whether or not an item in the list represents a tool or finger. You can also get only the tools using the Hand.tools[] list or only the fingers using the Hand.fingers[] list.

Type:
Source:
  • hand.js, line 112

sphereCenter :Leap.Vector

The center of a sphere fit to the curvature of this hand.

This sphere is placed roughly as if the hand were holding a ball.

Hand Ball

Type:
Source:
  • hand.js, line 82

sphereRadius :Number

The radius of a sphere fit to the curvature of this hand, in millimeters.

This sphere is placed roughly as if the hand were holding a ball. Thus the size of the sphere decreases as the fingers are curled into a fist.

Type:
  • Number
Source:
  • hand.js, line 93

tools[] :Leap.Pointable

The list of tools detected in this frame that are held by this hand, given in arbitrary order.

The list can be empty if no tools held by this hand are detected.

Type:
Source:
  • hand.js, line 138

valid :Boolean

Reports whether this is a valid Hand object.

Type:
  • Boolean
Source:
  • hand.js, line 104

Methods

finger(id) → {Leap.Pointable}

The finger with the specified ID attached to this hand.

Use this function to retrieve a Pointable object representing a finger attached to this hand using an ID value obtained from a previous frame. This function always returns a Pointable object, but if no finger with the specified ID is present, an invalid Pointable object is returned.

Note that the ID values assigned to fingers persist across frames, but only until tracking of a particular finger 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.

Parameters:
Name Type Description
id String

The ID value of a finger from a previous frame.

Source:
  • hand.js, line 154
Returns:

The Finger object with the matching ID if one exists for this hand in this frame; otherwise, an invalid Finger object is returned.

Type
Leap.Pointable

rotationAngle(sinceFrame, axis) → {Number}

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.

Parameters:
Name Type Argument Description
sinceFrame Leap.Frame

The starting frame for computing the relative rotation.

axis Leap.Vector <optional>

The axis to measure rotation around.

Source:
  • hand.js, line 180
Returns:

A positive value representing the heuristically determined rotational change of the hand between the current frame and that specified in the sinceFrame parameter.

Type
Number

rotationAxis(sinceFrame) → {Leap.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.

Parameters:
Name Type Description
sinceFrame Leap.Frame

The starting frame for computing the relative rotation.

Source:
  • hand.js, line 218
Returns:

A normalized direction Vector representing the axis of the heuristically determined rotational change of the hand between the current frame and that specified in the sinceFrame parameter.

Type
Leap.Vector

rotationMatrix(sinceFrame) → {Leap.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.

Parameters:
Name Type Description
sinceFrame Leap.Frame

The starting frame for computing the relative rotation.

Source:
  • hand.js, line 245
Returns:

A transformation Matrix containing the heuristically determined rotational change of the hand between the current frame and that specified in the sinceFrame parameter.

Type
Leap.Matrix

scaleFactor(sinceFrame) → {Number}

The scale factor derived from the 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.

Parameters:
Name Type Description
sinceFrame Leap.Frame

The starting frame for computing the relative scaling.

Source:
  • hand.js, line 272
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.

Type
Number

toString() → {String}

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

Source:
  • hand.js, line 324
Returns:

A description of the Hand as a string.

Type
String

translation(sinceFrame) → {Leap.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.

Parameters:
Name Type Description
sinceFrame Leap.Frame

The starting frame for computing the relative translation.

Source:
  • hand.js, line 298
Returns:

A Vector representing the heuristically determined change in hand position between the current frame and that specified in the sinceFrame parameter.

Type
Leap.Vector