**Properties:**

**Methods:**

The

LeapVectorclass 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.0Public FunctionsThe angle between this vector and the specified vector in radians.

float angleInRadians = [[LeapVectorxAxis] angleTo:[LeapVectoryAxis]]; // 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.

Return- The angle between this vector and the specified vector in radians.
Since 1.0Parameters

vector-A

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

Return- The cross product of this vector and the specified vector.
Since 1.0Parameters

vector-A

LeapVectorobject.The distance between the point represented by this

LeapVectorobject and a point represented by the specifiedLeapVectorobject.LeapVector*aPoint = [[LeapVectoralloc] initWithX:10 y:0 z:0];LeapVector*origin = [LeapVectorzero]; float distance = [origin distanceTo:aPoint]; // distance = 10

Return- The distance from this point to the specified point.
Since 1.0Parameters

vector-A

LeapVectorobject.Divide this vector by a number.

LeapVector*quotient = [thisVector divide:2.5];

Return- The dividend of this
LeapVectordivided by a scalar.Since 1.0Parameters

scalar-The scalar divisor;

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.

Return- The dot product of this vector and the specified vector.
Since 1.0Parameters

vector-A

LeapVectorobject.Checks

LeapVectorequality.bool vectorsAreEqual = [thisVector equals:thatVector];Vectors are equal if each corresponding component is equal.

Return- YES, if the LeapVectors are equal.
Since 1.0Parameters

vector-The

LeapVectorto compare.Copies the specified

LeapVector.LeapVector*copiedVector = [[LeapVectoralloc] initWithVector:otherVector];

Since 1.0Parameters

vector-The

LeapVectorto copy.- (id)initWithX:(float) xy:(float) yz:(float) zCreates a new

LeapVectorwith the specified component values.LeapVector*newVector = [[LeapVectoralloc] initWithX:0.5 y:200.3 z:67];

Since 1.0Parameters

x-The horizontal component.

y-The vertical component.

z-The depth component.

Subtract a vector from this vector.

LeapVector*difference = [thisVector minus:thatVector];

Return- the difference between the two LeapVectors.
Since 1.0Parameters

vector-the

LeapVectorsubtrahend.Negate this vector.

LeapVector*negation = thisVector.negate;

Return- The negation of this
LeapVector.Since 1.0Adds two vectors.

LeapVector*sum = [thisVector plus:thatVector];

Return- The sum of the two LeapVectors.
Since 1.0Parameters

vector-The

LeapVectoraddend.Multiply this vector by a number.

LeapVector*product = [thisVector times:5.0];

Return- The product of this
LeapVectorand a scalar.Since 1.0Parameters

scalar-The scalar factor.

Property- (float)magnitudemagnitudeThe 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

LeapVectorobject.

Return- The length of this vector.
Since 1.0- (float)magnitudeSquaredmagnitudeSquaredThe square of the magnitude, or length, of this vector.

float lengthSquared = thisVector.magnitudeSquared;

Return- The square of the length of this vector.
Since 1.0

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

Return- A
LeapVectorobject with a length of one, pointing in the same direction as this Vector object.Since 1.0- (float)pitchpitchThe 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.

Return- The angle of this vector above or below the horizon (x-z plane).
Since 1.0- (float)rollrollThe 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.

Return- The angle of this vector to the right or left of the y-axis.
Since 1.0- (NSMutableData *)toFloatPointertoFloatPointerReturns an NSMutableData object containing the vector components as consecutive floating point values.

NSData *vectorData = thisVector.toFloatPointer; floatx,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 *)toNSArraytoNSArrayReturns an NSArray object containing the vector components in the order: x, y, z.

NSArray *vectorArray = thisVector.toNSArray;

Since 1.0- (float)xxThe horizontal component.

Since 1.0- (float)yyThe vertical component.

Since 1.0- (float)yawyawThe 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.

Return- The angle of this vector to the right or left of the negative z-axis.
Since 1.0- (float)zzThe depth component.

Since 1.0Public Static FunctionsThe unit vector pointing backward along the positive z-axis: (0, 0, 1).

LeapVector*backwardVector = [LeapVectorbackward];

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

LeapVector*downVector = [LeapVectordown];

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

LeapVector*forwardVector = [LeapVectorforward];

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

LeapVector*leftVector = [LeapVectorleft];

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

LeapVector*rightVector = [LeapVectorright];

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

LeapVector*upVector = [LeapVectorup];

Since 1.0