**Methods:**

- Vector()
- Vector(float _x, float _y, float _z)
- Vector(Vector vector)
- angleTo(Vector other)
- backward()
- cross(Vector other)
- distanceTo(Vector other)
- divide(float scalar)
- dot(Vector other)
- down()
- equals(Vector other)
- forward()
- get(long index)
- getX()
- getY()
- getZ()
- isValid()
- left()
- magnitude()
- magnitudeSquared()
- minus(Vector other)
- normalized()
- opposite()
- pitch()
- plus(Vector other)
- right()
- roll()
- setX(float value)
- setY(float value)
- setZ(float value)
- times(float scalar)
- toString()
- up()
- xAxis()
- yAxis()
- yaw()
- zAxis()
- zero()

The

Vectorstruct represents a three-component mathematical vector or point such as a direction or position in three-dimensional space.The Leap Motion 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 Motion

Controller. 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
Public FunctionsfloatangleTo(Vectorother)The angle between this vector and the specified vector in radians.

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.

float angleInRadians =Vector.xAxis().angleTo(Vector.yAxis()); // angleInRadians = PI/2 (90 degrees)

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

other-A

Vectorobject.

The cross product of this vector and the specified vector.

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.cross(A).VectorcrossProduct = thisVector.cross(thatVector);

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

other-A

Vectorobject.floatdistanceTo(Vectorother)The distance between the point represented by this

Vectorobject and a point represented by the specifiedVectorobject.VectoraPoint = newVector(10f, 0f, 0f);Vectororigin =Vector.zero(); float distance = origin.distanceTo(aPoint); // distance = 10

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

other-A

Vectorobject.Vectordivide(float scalar)floatdot(Vectorother)The dot product of this vector with another vector.

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

float dotProduct = thisVector.dot(thatVector);

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

other-A

Vectorobject.booleanequals(Vectorother)Compare

Vectorequality component-wise.

boolean vectorsAreEqual = thisVector == thatVector;

Since- 1.0
floatget(long index)Index vector components numerically.

Index 0 is x, index 1 is y, and index 2 is z.

float x = thisVector.get(0); float y = thisVector.get(1); float z = thisVector.get(2);

Return- The x, y, or z component of this
Vector, if the specified index value is at least 0 and at most 2; otherwise, returns zero.Since- 1.0
floatgetX()The horizontal component.

Since- 1.0
floatgetY()The vertical component.

Since- 1.0
floatgetZ()The depth component.

Since- 1.0
booleanisValid()Returns true if all of the vector’s components are finite.

If any component is NaN or infinite, then this returns false.

boolean vectorsIsValid = thisVector.isValid();

Since- 1.0
floatmagnitude()The magnitude, or length, of this vector.

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

Vectorobject.float length = thisVector.magnitude();

Return- The length of this vector.
Since- 1.0
floatmagnitudeSquared()The 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

Vectornormalized()Vectoropposite()floatpitch()The pitch angle in radians.

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.

float pitchInRadians = thisVector.pitch();

Return- The angle of this vector above or below the horizon (x-z plane).
Since- 1.0

floatroll()The roll angle in radians.

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.

float rollInRadians = thatVector.roll();

Return- The angle of this vector to the right or left of the y-axis.
Since- 1.0
voidsetX(float value)The horizontal component.

Since- 1.0
voidsetY(float value)The vertical component.

Since- 1.0
voidsetZ(float value)The depth component.

Since- 1.0
Vectortimes(float scalar)StringtoString()Returns a string containing this vector in a human readable format: (x, y, z).

Since- 1.0
Vector()Creates a new

Vectorwith all components set to zero.

Since- 1.0
Vector(float _x, float _y, float _z)Vector(Vectorvector)floatyaw()The yaw angle in radians.

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.

float yawInRadians = thisVector.yaw();

Return- The angle of this vector to the right or left of the negative z-axis.
Since- 1.0
Public Static Functions