# Vector¶

Vector Struct Reference

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

## Public Member Functions

float angleTo (const Vector &other) const
The angle between this vector and the specified vector in radians. More...

Vector cross (const Vector &other) const
The cross product of this vector and the specified vector. More...

float distanceTo (const Vector &other) const
The distance between the point represented by this Vector object and a point represented by the specified Vector object. More...

float dot (const Vector &other) const
The dot product of this vector with another vector. More...

bool isValid () const
Returns true if all of the vector's components are finite. More...

float magnitude () const
The magnitude, or length, of this vector. More...

float magnitudeSquared () const
The square of the magnitude, or length, of this vector. More...

Vector normalized () const
A normalized copy of this vector. More...

bool operator!= (const Vector &other) const
Compare Vector inequality component-wise. More...

Vector operator* (float scalar) const
Multiply vector by a scalar. More...

Vectoroperator*= (float scalar)
Multiply vector by a scalar and assign the product. More...

Vector operator+ (const Vector &other) const

Vectoroperator+= (const Vector &other)
Add vectors component-wise and assign the sum. More...

Vector operator- () const
A copy of this vector pointing in the opposite direction. More...

Vector operator- (const Vector &other) const
Subtract vectors component-wise. More...

Vectoroperator-= (const Vector &other)
Subtract vectors component-wise and assign the difference. More...

Vector operator/ (float scalar) const
Divide vector by a scalar. More...

Vectoroperator/= (float scalar)
Divide vector by a scalar and assign the quotient. More...

bool operator== (const Vector &other) const
Compare Vector equality component-wise. More...

float operator[] (unsigned int index) const
Index vector components numerically. More...

float pitch () const
The pitch angle in radians. More...

float roll () const
The roll angle in radians. More...

const float * toFloatPointer () const
Cast the vector to a float array. More...

std::string toString () const
Returns a string containing this vector in a human readable format: (x, y, z). More...

template<typename Vector3Type >
const Vector3Type toVector3 () const
Convert a Leap::Vector to another 3-component Vector type. More...

template<typename Vector4Type >
const Vector4Type toVector4 (float w=0.0f) const
Convert a Leap::Vector to another 4-component Vector type. More...

Vector ()
Creates a new Vector with all components set to zero. More...

Vector (float _x, float _y, float _z)
Creates a new Vector with the specified component values. More...

Vector (const Vector &vector)
Copies the specified Vector. More...

float yaw () const
The yaw angle in radians. More...

## Static Public Member Functions

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

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

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

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

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

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

static const VectorxAxis ()
The x-axis unit vector: (1, 0, 0) More...

static const VectoryAxis ()
The y-axis unit vector: (0, 1, 0) More...

static const VectorzAxis ()
The z-axis unit vector: (0, 0, 1) More...

static const Vectorzero ()
The zero vector: (0, 0, 0) More...

## Public Attributes

float x
The horizontal component. More...

float y
The vertical component. More...

float z
The depth component. More...

## Friends

std::ostream & operator<< (std::ostream &out, const Vector &vector)
Writes the vector to the output stream using a human readable format: (x, y, z). More...

## Detailed Description

The Vector struct 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

## Constructor & Destructor Documentation

 Vector ( )
inline

Creates a new Vector with all components set to zero.

Since
1.0
 Vector ( float _x, float _y, float _z )
inline

Creates a new Vector with the specified component values.

Vector newVector = Vector(0.5, 200.3, 67);
Since
1.0
 Vector ( const Vector & vector )
inline

Copies the specified Vector.

Vector copiedVector = Vector(otherVector);
Since
1.0

## Member Function Documentation

 float angleTo ( const Vector & other ) const
inline

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. // angleInRadians is PI/2 (90 degrees) -- the angle between the x and y axes
Parameters
 other A Vector object.
Returns
The angle between this vector and the specified vector in radians.
Since
1.0
 static const Vector& backward ( )
inlinestatic

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

Vector backwardVector = Vector::backward();
Since
1.0
 Vector cross ( const Vector & other ) const
inline

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). Vector crossProduct = thisVector.cross(thatVector);
Parameters
 other A Vector object.
Returns
The cross product of this vector and the specified vector.
Since
1.0
 float distanceTo ( const Vector & other ) const
inline

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

Vector aPoint = Vector(10, 0, 0);
Vector origin = Vector::zero();
float distance = origin.distanceTo(aPoint); // distance = 10
Parameters
 other A Vector object.
Returns
The distance from this point to the specified point.
Since
1.0
 float dot ( const Vector & other ) const
inline

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);
Parameters
 other A Vector object.
Returns
The dot product of this vector and the specified vector.
Since
1.0
 static const Vector& down ( )
inlinestatic

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

Vector downVector = Vector::down();
Since
1.0
 static const Vector& forward ( )
inlinestatic

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

Vector forwardVector = Vector::forward();
Since
1.0
 bool isValid ( ) const
inline

Returns true if all of the vector's components are finite.

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

bool vectorIsValid = thisVector.isValid();
Since
1.0
 static const Vector& left ( )
inlinestatic

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

Vector leftVector = Vector::left();
Since
1.0
 float magnitude ( ) const
inline

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

float length = thisVector.magnitude();
Returns
The length of this vector.
Since
1.0
 float magnitudeSquared ( ) const
inline

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
 Vector normalized ( ) const
inline

A normalized copy of this vector.

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

Vector normalizedVector = otherVector.normalized();
Returns
A Vector object with a length of one, pointing in the same direction as this Vector object.
Since
1.0
 bool operator!= ( const Vector & other ) const
inline

Compare Vector inequality component-wise.

bool vectorsNotEqual = thisVector != thatVector;
Since
1.0
 Vector operator* ( float scalar ) const
inline

Multiply vector by a scalar.

Vector product = thisVector * 5.0;
Since
1.0
 Vector& operator*= ( float scalar )
inline

Multiply vector by a scalar and assign the product.

Since
1.0
 Vector operator+ ( const Vector & other ) const
inline

Vector sum = thisVector + thatVector;
Since
1.0
 Vector& operator+= ( const Vector & other )
inline

Add vectors component-wise and assign the sum.

Since
1.0
 Vector operator- ( ) const
inline

A copy of this vector pointing in the opposite direction.

Vector negation = -thisVector;
Returns
A Vector object with all components negated.
Since
1.0
 Vector operator- ( const Vector & other ) const
inline

Subtract vectors component-wise.

Vector difference = thisVector - thatVector;
Since
1.0
 Vector& operator-= ( const Vector & other )
inline

Subtract vectors component-wise and assign the difference.

Since
1.0
 Vector operator/ ( float scalar ) const
inline

Divide vector by a scalar.

Vector quotient = thisVector/2.5;
Since
1.0
 Vector& operator/= ( float scalar )
inline

Divide vector by a scalar and assign the quotient.

Since
1.0
 bool operator== ( const Vector & other ) const
inline

Compare Vector equality component-wise.

bool vectorsAreEqual = thisVector == thatVector;
Since
1.0
 float operator[] ( unsigned int index ) const
inline

Index vector components numerically.

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

Returns
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.
float x = thisVector;
float y = thisVector;
float z = thisVector;
Since
1.0
 float pitch ( ) const
inline

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
 static const Vector& right ( )
inlinestatic

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

Vector rightVector = Vector::right();
Since
1.0
 float roll ( ) const
inline

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
 const float* toFloatPointer ( ) const
inline

Cast the vector to a float array.

const float *vectorData = thisVector.toFloatPointer();
float x = *vectorData;
float y = *(++vectorData);
float z = *(++vectorData);
Since
1.0
 std::string toString ( ) const
inline

Returns a string containing this vector in a human readable format: (x, y, z).

Since
1.0
 const Vector3Type toVector3 ( ) const
inline

Convert a Leap::Vector to another 3-component Vector type.

The specified type must define a constructor that takes the x, y, and z components as separate parameters.

Since
1.0
 const Vector4Type toVector4 ( float w = 0.0f ) const
inline

Convert a Leap::Vector to another 4-component Vector type.

The specified type must define a constructor that takes the x, y, z, and w components as separate parameters. (The homogeneous coordinate, w, is set to zero by default, but you should typically set it to one for vectors representing a position.)

Since
1.0
 static const Vector& up ( )
inlinestatic

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

Vector upVector = Vector::up();
Since
1.0
 static const Vector& xAxis ( )
inlinestatic

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

Vector xAxisVector = Vector::xAxis();
Since
1.0
 float yaw ( ) const
inline

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
 static const Vector& yAxis ( )
inlinestatic

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

Vector yAxisVector = Vector::yAxis();
Since
1.0
 static const Vector& zAxis ( )
inlinestatic

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

Vector zAxisVector = Vector::zAxis();
Since
1.0
 static const Vector& zero ( )
inlinestatic

The zero vector: (0, 0, 0)

Vector zeroVector = Vector::zero();
Since
1.0

## Friends And Related Function Documentation

 std::ostream& operator<< ( std::ostream & out, const Vector & vector )
friend

Writes the vector to the output stream using a human readable format: (x, y, z).

Since
1.0

## Member Data Documentation

 float x

The horizontal component.

Since
1.0
 float y

The vertical component.

Since
1.0
 float z

The depth component.

Since
1.0