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

LeapVector *	normalized
	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

vector A 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

vector A 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];
LeapVector *origin = [LeapVector zero];
float distance = [origin distanceTo:aPoint]; // distance = 10

Parameters

vector A 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

scalar The 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

vector A 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

vector The 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

vector The 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

x	The horizontal component.
y	The vertical component.
z	The 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

vector the 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

vector The 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

scalar The 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

LeapVector¶

Instance Methods

Class Methods

Properties

Detailed Description

Method Documentation

Property Documentation