LeapVectorΒΆ

LeapVector Class Reference

The LeapVector class represents a three-component mathematical vector or point such as a direction or position in three-dimensional space. More...

Inherits NSObject.

Instance Methods

(float) - angleTo:
 The angle between this vector and the specified vector in radians. More...
 
(LeapVector *) - cross:
 The cross product of this vector and the specified vector. More...
 
(float) - distanceTo:
 The distance between the point represented by this LeapVector object and a point represented by the specified LeapVector object. More...
 
(LeapVector *) - divide:
 Divide this vector by a number. More...
 
(float) - dot:
 The dot product of this vector with another vector. More...
 
(BOOL) - equals:
 Checks LeapVector equality. More...
 
(id) - initWithVector:
 Copies the specified LeapVector. More...
 
(id) - initWithX:y:z:
 Creates a new LeapVector with the specified component values. More...
 
(LeapVector *) - minus:
 Subtract a vector from this vector. More...
 
(LeapVector *) - negate
 Negate this vector. More...
 
(LeapVector *) - plus:
 Adds two vectors. More...
 
(LeapVector *) - times:
 Multiply this vector by a number. More...
 

Class Methods

(LeapVector *) + backward
 The unit vector pointing backward along the positive z-axis: (0, 0, 1). More...
 
(LeapVector *) + down
 The unit vector pointing down along the negative y-axis: (0, -1, 0). More...
 
(LeapVector *) + forward
 The unit vector pointing forward along the negative z-axis: (0, 0, -1). More...
 
(LeapVector *) + left
 The unit vector pointing left along the negative x-axis: (-1, 0, 0). More...
 
(LeapVector *) + right
 The unit vector pointing right along the positive x-axis: (1, 0, 0). More...
 
(LeapVector *) + up
 The unit vector pointing up along the positive y-axis: (0, 1, 0). More...
 
(LeapVector *) + xAxis
 The x-axis unit vector: (1, 0, 0). More...
 
(LeapVector *) + yAxis
 The y-axis unit vector: (0, 1, 0). More...
 
(LeapVector *) + zAxis
 The z-axis unit vector: (0, 0, 1). More...
 
(LeapVector *) + zero
 The zero vector: (0, 0, 0) More...
 

Properties

float magnitude
 The magnitude, or length, of this vector. More...
 
float magnitudeSquared
 The square of the magnitude, or length, of this vector. More...
 
LeapVectornormalized
 A normalized copy of this vector. More...
 
float pitch
 The pitch angle in radians. More...
 
float roll
 The roll angle in radians. More...
 
NSMutableData * toFloatPointer
 Returns an NSMutableData object containing the vector components as consecutive floating point values. More...
 
NSArray * toNSArray
 Returns an NSArray object containing the vector components in the order: x, y, z. More...
 
float x
 The horizontal component. More...
 
float y
 The vertical component. More...
 
float yaw
 The yaw angle in radians. More...
 
float z
 The depth component. More...
 

Detailed Description

The LeapVector class 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.

Since 1.0

Method Documentation

- (float) angleTo: (const LeapVector *)  vector

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

float angleInRadians = [[LeapVector xAxis] angleTo:[LeapVector yAxis]];
// angleInRadians = PI/2 (90 degrees)

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.

Parameters
vectorA LeapVector object.
Returns
The angle between this vector and the specified vector in radians.
Since 1.0
+ (LeapVector *) backward

The unit vector pointing backward along the positive z-axis: (0, 0, 1).

LeapVector *backwardVector = [LeapVector backward];
Since 1.0
- (LeapVector *) cross: (const LeapVector *)  vector

The cross product of this vector and the specified vector.

LeapVector *crossProduct = [thisVector cross:thatVector];

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 negate] cross:A].

Parameters
vectorA LeapVector object.
Returns
The cross product of this vector and the specified vector.
Since 1.0
- (float) distanceTo: (const LeapVector *)  vector

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

LeapVector *aPoint = [[LeapVector alloc] initWithX:10 y:0 z:0];
float distance = [origin distanceTo:aPoint]; // distance = 10
Parameters
vectorA LeapVector object.
Returns
The distance from this point to the specified point.
Since 1.0
- (LeapVector *) divide: (float)  scalar

Divide this vector by a number.

LeapVector *quotient = [thisVector divide:2.5];
Parameters
scalarThe scalar divisor;
Returns
The dividend of this LeapVector divided by a scalar.
Since 1.0
- (float) dot: (const LeapVector *)  vector

The dot product of this vector with another vector.

float dotProduct = [thisVector dot:thatVector];

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

Parameters
vectorA LeapVector object.
Returns
The dot product of this vector and the specified vector.
Since 1.0
+ (LeapVector *) down

The unit vector pointing down along the negative y-axis: (0, -1, 0).

LeapVector *downVector = [LeapVector down];
Since 1.0
- (BOOL) equals: (const LeapVector *)  vector

Checks LeapVector equality.

bool vectorsAreEqual = [thisVector equals:thatVector];

Vectors are equal if each corresponding component is equal.

Parameters
vectorThe LeapVector to compare.
Returns
YES, if the LeapVectors are equal.
Since 1.0
+ (LeapVector *) forward

The unit vector pointing forward along the negative z-axis: (0, 0, -1).

LeapVector *forwardVector = [LeapVector forward];
Since 1.0
- (id) initWithVector: (const LeapVector *)  vector

Copies the specified LeapVector.

LeapVector *copiedVector = [[LeapVector alloc] initWithVector:otherVector];
Parameters
vectorThe LeapVector to copy.
Since 1.0
- (id) initWithX: (float)  x
y: (float)  y
z: (float)  z 

Creates a new LeapVector with the specified component values.

LeapVector *newVector = [[LeapVector alloc] initWithX:0.5 y:200.3 z:67];
Parameters
xThe horizontal component.
yThe vertical component.
zThe depth component.
Since 1.0
+ (LeapVector *) left

The unit vector pointing left along the negative x-axis: (-1, 0, 0).

LeapVector *leftVector = [LeapVector left];
Since 1.0
- (LeapVector *) minus: (const LeapVector *)  vector

Subtract a vector from this vector.

LeapVector *difference = [thisVector minus:thatVector];
Parameters
vectorthe LeapVector subtrahend.
Returns
the difference between the two LeapVectors.
Since 1.0
- (LeapVector *) negate

Negate this vector.

LeapVector *negation = thisVector.negate;
Returns
The negation of this LeapVector.
Since 1.0
- (LeapVector *) plus: (const LeapVector *)  vector

Adds two vectors.

LeapVector *sum = [thisVector plus:thatVector];
Parameters
vectorThe LeapVector addend.
Returns
The sum of the two LeapVectors.
Since 1.0
+ (LeapVector *) right

The unit vector pointing right along the positive x-axis: (1, 0, 0).

LeapVector *rightVector = [LeapVector right];
Since 1.0
- (LeapVector *) times: (float)  scalar

Multiply this vector by a number.

LeapVector *product = [thisVector times:5.0];
Parameters
scalarThe scalar factor.
Returns
The product of this LeapVector and a scalar.
Since 1.0
+ (LeapVector *) up

The unit vector pointing up along the positive y-axis: (0, 1, 0).

LeapVector *upVector = [LeapVector up];
Since 1.0
+ (LeapVector *) xAxis

The x-axis unit vector: (1, 0, 0).

LeapVector *xAxisVector = [LeapVector xAxis];
Since 1.0
+ (LeapVector *) yAxis

The y-axis unit vector: (0, 1, 0).

LeapVector *yAxisVector = [LeapVector yAxis];
Since 1.0
+ (LeapVector *) zAxis

The z-axis unit vector: (0, 0, 1).

LeapVector *zAxisVector = [LeapVector zAxis];
Since 1.0
+ (LeapVector *) zero

The zero vector: (0, 0, 0)

LeapVector *zeroVector = [LeapVector zero];
Since 1.0

Property Documentation

- (float) magnitude
readnonatomicassign

The magnitude, or length, of this vector.

float length = thisVector.magnitude;

The magnitude is the L2 norm, or Euclidean distance between the origin and the point represented by the (x, y, z) components of this LeapVector object.

Returns
The length of this vector.
Since 1.0
- (float) magnitudeSquared
readnonatomicassign

The square of the magnitude, or length, of this vector.

float lengthSquared = thisVector.magnitudeSquared;
Returns
The square of the length of this vector.
Since 1.0
- (LeapVector*) normalized
readnonatomicassign

A normalized copy of this vector.

LeapVector *normalizedVector = otherVector.normalized;

A normalized vector has the same direction as the original vector, but with a length of one.

Returns
A LeapVector object with a length of one, pointing in the same direction as this Vector object.
Since 1.0
- (float) pitch
readnonatomicassign

The pitch angle in radians.

float pitchInRadians = thisVector.pitch;

Pitch is the angle between the negative z-axis and the projection of the vector onto the y-z plane. In other words, pitch represents rotation around the x-axis. If the vector points upward, the returned angle is between 0 and pi radians (180 degrees); if it points downward, the angle is between 0 and -pi radians.

Returns
The angle of this vector above or below the horizon (x-z plane).
Since 1.0
- (float) roll
readnonatomicassign

The roll angle in radians.

float rollInRadians = thatVector.roll;

Roll is the angle between the y-axis and the projection of the vector onto the x-y plane. In other words, roll represents rotation around the z-axis. If the vector points to the left of the y-axis, then the returned angle is between 0 and pi radians (180 degrees); if it points to the right, the angle is between 0 and -pi radians.

Use this function to get roll angle of the plane to which this vector is a normal. For example, if this vector represents the normal to the palm, then this function returns the tilt or roll of the palm plane compared to the horizontal (x-z) plane.

Returns
The angle of this vector to the right or left of the y-axis.
Since 1.0
- (NSMutableData*) toFloatPointer
readnonatomicassign

Returns an NSMutableData object containing the vector components as consecutive floating point values.

NSData *vectorData = thisVector.toFloatPointer;
float x, y, z;
[vectorData getBytes:&x length:sizeof(float)];
[vectorData getBytes:&y length:sizeof(float)];
[vectorData getBytes:&z length:sizeof(float)];
//Or access as an array of float:
float array[3];
[vectorData getBytes:&array length:sizeof(float) * 3];
x = array[0];
y = array[1];
z = array[2];
Since 1.0
- (NSArray*) toNSArray
readnonatomicassign

Returns an NSArray object containing the vector components in the order: x, y, z.

NSArray *vectorArray = thisVector.toNSArray;
Since 1.0
- (float) x
readwritenonatomicassign

The horizontal component.

Since 1.0
- (float) y
readwritenonatomicassign

The vertical component.

Since 1.0
- (float) yaw
readnonatomicassign

The yaw angle in radians.

float yawInRadians = thisVector.yaw;

Yaw is the angle between the negative z-axis and the projection of the vector onto the x-z plane. In other words, yaw represents rotation around the y-axis. If the vector points to the right of the negative z-axis, then the returned angle is between 0 and pi radians (180 degrees); if it points to the left, the angle is between 0 and -pi radians.

Returns
The angle of this vector to the right or left of the negative z-axis.
Since 1.0
- (float) z
readwritenonatomicassign

The depth component.

Since 1.0