#include <LeapMath.h>
Public Member Functions | |
| def | __add__ |
| def | __div__ |
| def | __eq__ |
| def | __getitem__ |
| def | __iadd__ |
| def | __idiv__ |
| def | __imul__ |
| def | __init__ |
| def | __isub__ |
| def | __mul__ |
| def | __ne__ |
| def | __neg__ |
| def | __str__ |
| def | __sub__ |
| def | angle_to |
| float | angleTo (const Vector &other) const |
| def | cross |
| Vector | cross (const Vector &other) const |
| def | distance_to |
| float | distanceTo (const Vector &other) const |
| def | dot |
| float | dot (const Vector &other) const |
| def | is_valid |
| bool | isValid () const |
| float | magnitude () const |
| float | magnitudeSquared () const |
| Vector | normalized () const |
| bool | operator!= (const Vector &other) const |
| Vector | operator* (float scalar) const |
| Vector & | operator*= (float scalar) |
| Vector | operator+ (const Vector &other) const |
| Vector & | operator+= (const Vector &other) |
| Vector | operator- () const |
| Vector | operator- (const Vector &other) const |
| Vector & | operator-= (const Vector &other) |
| Vector | operator/ (float scalar) const |
| Vector & | operator/= (float scalar) |
| bool | operator== (const Vector &other) const |
| float | operator[] (unsigned int index) const |
| float | pitch () const |
| float | roll () const |
| def | to_float_array |
| def | to_tuple |
| const float * | toFloatPointer () const |
| std::string | toString () const |
| template<typename Vector3Type > | |
| const Vector3Type | toVector3 () const |
| template<typename Vector4Type > | |
| const Vector4Type | toVector4 (float w=0.0f) const |
| Vector () | |
| Vector (float _x, float _y, float _z) | |
| Vector (const Vector &vector) | |
| float | yaw () const |
Static Public Member Functions | |
| static const Vector & | backward () |
| static const Vector & | down () |
| static const Vector & | forward () |
| static const Vector & | left () |
| static const Vector & | right () |
| static const Vector & | up () |
| static const Vector & | xAxis () |
| static const Vector & | yAxis () |
| static const Vector & | zAxis () |
| static const Vector & | zero () |
Public Attributes | |
| this | |
| float | x |
| float | y |
| float | z |
Static Public Attributes | |
| tuple | magnitude = _swig_property(LeapPython.Vector_magnitude_get) |
| tuple | magnitude_squared = _swig_property(LeapPython.Vector_magnitude_squared_get) |
| tuple | normalized = _swig_property(LeapPython.Vector_normalized_get) |
| tuple | pitch = _swig_property(LeapPython.Vector_pitch_get) |
| tuple | roll = _swig_property(LeapPython.Vector_roll_get) |
| tuple | x = _swig_property(LeapPython.Vector_x_get, LeapPython.Vector_x_set) |
| tuple | y = _swig_property(LeapPython.Vector_y_get, LeapPython.Vector_y_set) |
| tuple | yaw = _swig_property(LeapPython.Vector_yaw_get) |
| tuple | z = _swig_property(LeapPython.Vector_z_get, LeapPython.Vector_z_set) |
Static Private Attributes | |
| tuple | __getattr__ = lambdaself,name:_swig_getattr(self, Vector, name) |
| __repr__ = _swig_repr | |
| tuple | __setattr__ = lambdaself,name,value:_swig_setattr(self, Vector, name, value) |
| __swig_destroy__ = LeapPython.delete_Vector | |
| dictionary | __swig_getmethods__ = {} |
| dictionary | __swig_setmethods__ = {} |
Friends | |
| Vector | operator* (float scalar, const Vector &vector) |
| std::ostream & | operator<< (std::ostream &out, const Vector &vector) |
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
Definition at line 60 of file LeapMath.h.
Constructor & Destructor Documentation
| Leap::Vector::Vector | ( | ) | [inline] |
Creates a new Vector with all components set to zero.
- Since:
- 1.0
Definition at line 65 of file LeapMath.h.
| Leap::Vector::Vector | ( | float | _x, |
| float | _y, | ||
| float | _z | ||
| ) | [inline] |
Creates a new Vector with the specified component values.
- Since:
- 1.0
Definition at line 74 of file LeapMath.h.
| Leap::Vector::Vector | ( | const Vector & | vector | ) | [inline] |
| def Leap::Vector::__init__ | ( | self, | |
| args | |||
| ) |
Member Function Documentation
| def Leap::Vector::__add__ | ( | self, | |
| other | |||
| ) |
| def Leap::Vector::__div__ | ( | self, | |
| scalar | |||
| ) |
| def Leap::Vector::__eq__ | ( | self, | |
| other | |||
| ) |
| def Leap::Vector::__getitem__ | ( | self, | |
| index | |||
| ) |
| def Leap::Vector::__iadd__ | ( | self, | |
| other | |||
| ) |
| def Leap::Vector::__idiv__ | ( | self, | |
| scalar | |||
| ) |
| def Leap::Vector::__imul__ | ( | self, | |
| scalar | |||
| ) |
| def Leap::Vector::__isub__ | ( | self, | |
| other | |||
| ) |
| def Leap::Vector::__mul__ | ( | self, | |
| scalar | |||
| ) |
| def Leap::Vector::__ne__ | ( | self, | |
| other | |||
| ) |
| def Leap::Vector::__neg__ | ( | self | ) |
| def Leap::Vector::__str__ | ( | self | ) |
| def Leap::Vector::__sub__ | ( | self, | |
| other | |||
| ) |
| def Leap::Vector::angle_to | ( | self, | |
| other | |||
| ) |
| float Leap::Vector::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.
- Parameters:
-
other A Vector object.
- Returns:
- The angle between this vector and the specified vector in radians.
- Since:
- 1.0
Definition at line 247 of file LeapMath.h.
| static const Vector& Leap::Vector::backward | ( | ) | [inline, static] |
The unit vector pointing backward along the positive z-axis: (0, 0, 1)
- Since:
- 1.0
Definition at line 182 of file LeapMath.h.
| def Leap::Vector::cross | ( | self, | |
| other | |||
| ) |
| Vector Leap::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).
- Parameters:
-
other A Vector object.
- Returns:
- The cross product of this vector and the specified vector.
- Since:
- 1.0
Definition at line 360 of file LeapMath.h.
| def Leap::Vector::distance_to | ( | self, | |
| other | |||
| ) |
| float Leap::Vector::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.
- Parameters:
-
other A Vector object.
- Returns:
- The distance from this point to the specified point.
- Since:
- 1.0
Definition at line 223 of file LeapMath.h.
| def Leap::Vector::dot | ( | self, | |
| other | |||
| ) |
| float Leap::Vector::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.
- Parameters:
-
other A Vector object.
- Returns:
- The dot product of this vector and the specified vector.
- Since:
- 1.0
Definition at line 340 of file LeapMath.h.
| static const Vector& Leap::Vector::down | ( | ) | [inline, static] |
The unit vector pointing down along the negative y-axis: (0, -1, 0)
- Since:
- 1.0
Definition at line 153 of file LeapMath.h.
| static const Vector& Leap::Vector::forward | ( | ) | [inline, static] |
The unit vector pointing forward along the negative z-axis: (0, 0, -1)
- Since:
- 1.0
Definition at line 172 of file LeapMath.h.
| def Leap::Vector::is_valid | ( | self | ) |
| bool Leap::Vector::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.
- Since:
- 1.0
Definition at line 538 of file LeapMath.h.
| static const Vector& Leap::Vector::left | ( | ) | [inline, static] |
The unit vector pointing left along the negative x-axis: (-1, 0, 0)
- Since:
- 1.0
Definition at line 134 of file LeapMath.h.
| float Leap::Vector::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.
- Returns:
- The length of this vector.
- Since:
- 1.0
Definition at line 197 of file LeapMath.h.
| float Leap::Vector::magnitudeSquared | ( | ) | const [inline] |
The square of the magnitude, or length, of this vector.
- Returns:
- The square of the length of this vector.
- Since:
- 1.0
Definition at line 209 of file LeapMath.h.
| Vector Leap::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.
- Since:
- 1.0
Definition at line 378 of file LeapMath.h.
| bool Leap::Vector::operator!= | ( | const Vector & | other | ) | const [inline] |
| Vector Leap::Vector::operator* | ( | float | scalar | ) | const [inline] |
| Vector& Leap::Vector::operator*= | ( | float | scalar | ) | [inline] |
Multiply vector by a scalar and assign the product.
- Since:
- 1.0
Definition at line 477 of file LeapMath.h.
| Vector Leap::Vector::operator- | ( | ) | const [inline] |
A copy of this vector pointing in the opposite direction.
- Returns:
- A Vector object with all components negated.
- Since:
- 1.0
Definition at line 395 of file LeapMath.h.
Subtract vectors component-wise and assign the difference.
- Since:
- 1.0
Definition at line 466 of file LeapMath.h.
| Vector Leap::Vector::operator/ | ( | float | scalar | ) | const [inline] |
| Vector& Leap::Vector::operator/= | ( | float | scalar | ) | [inline] |
Divide vector by a scalar and assign the quotient.
- Since:
- 1.0
Definition at line 488 of file LeapMath.h.
| bool Leap::Vector::operator== | ( | const Vector & | other | ) | const [inline] |
| float Leap::Vector::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.
- Since:
- 1.0
Definition at line 553 of file LeapMath.h.
| float Leap::Vector::pitch | ( | ) | const [inline] |
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.
- Returns:
- The angle of this vector above or below the horizon (x-z plane).
- Since:
- 1.0
Definition at line 277 of file LeapMath.h.
| static const Vector& Leap::Vector::right | ( | ) | [inline, static] |
The unit vector pointing right along the positive x-axis: (1, 0, 0)
- Since:
- 1.0
Definition at line 144 of file LeapMath.h.
| float Leap::Vector::roll | ( | ) | const [inline] |
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.
- Returns:
- The angle of this vector to the right or left of the y-axis.
- Since:
- 1.0
Definition at line 322 of file LeapMath.h.
| def Leap::Vector::to_float_array | ( | self | ) |
| def Leap::Vector::to_tuple | ( | self | ) |
| const float* Leap::Vector::toFloatPointer | ( | ) | const [inline] |
| std::string Leap::Vector::toString | ( | ) | const [inline] |
Returns a string containing this vector in a human readable format: (x, y, z).
- Since:
- 1.0
Definition at line 499 of file LeapMath.h.
| const Vector3Type Leap::Vector::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
Definition at line 575 of file LeapMath.h.
| const Vector4Type Leap::Vector::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
Definition at line 589 of file LeapMath.h.
| static const Vector& Leap::Vector::up | ( | ) | [inline, static] |
The unit vector pointing up along the positive y-axis: (0, 1, 0)
- Since:
- 1.0
Definition at line 163 of file LeapMath.h.
| static const Vector& Leap::Vector::xAxis | ( | ) | [inline, static] |
| float Leap::Vector::yaw | ( | ) | const [inline] |
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.
- Returns:
- The angle of this vector to the right or left of the negative z-axis.
- Since:
- 1.0
Definition at line 297 of file LeapMath.h.
| static const Vector& Leap::Vector::yAxis | ( | ) | [inline, static] |
| static const Vector& Leap::Vector::zAxis | ( | ) | [inline, static] |
| static const Vector& Leap::Vector::zero | ( | ) | [inline, static] |
Friends And Related Function Documentation
Multiply vector by a scalar on the left-hand side (C++ only).
- Since:
- 1.0
Definition at line 446 of file LeapMath.h.
| 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
Definition at line 508 of file LeapMath.h.
Member Data Documentation
tuple Leap::Vector::__getattr__ = lambdaself,name:_swig_getattr(self, Vector, name) [static, private] |
Leap::Vector::__repr__ = _swig_repr [static, private] |
tuple Leap::Vector::__setattr__ = lambdaself,name,value:_swig_setattr(self, Vector, name, value) [static, private] |
Leap::Vector::__swig_destroy__ = LeapPython.delete_Vector [static, private] |
dictionary Leap::Vector::__swig_getmethods__ = {} [static, private] |
dictionary Leap::Vector::__swig_setmethods__ = {} [static, private] |
tuple Leap::Vector::magnitude = _swig_property(LeapPython.Vector_magnitude_get) [static] |
tuple Leap::Vector::magnitude_squared = _swig_property(LeapPython.Vector_magnitude_squared_get) [static] |
tuple Leap::Vector::normalized = _swig_property(LeapPython.Vector_normalized_get) [static] |
tuple Leap::Vector::pitch = _swig_property(LeapPython.Vector_pitch_get) [static] |
tuple Leap::Vector::roll = _swig_property(LeapPython.Vector_roll_get) [static] |
tuple Leap::Vector::x = _swig_property(LeapPython.Vector_x_get, LeapPython.Vector_x_set) [static] |
| float Leap::Vector::x |
tuple Leap::Vector::y = _swig_property(LeapPython.Vector_y_get, LeapPython.Vector_y_set) [static] |
| float Leap::Vector::y |
tuple Leap::Vector::yaw = _swig_property(LeapPython.Vector_yaw_get) [static] |
tuple Leap::Vector::z = _swig_property(LeapPython.Vector_z_get, LeapPython.Vector_z_set) [static] |
| float Leap::Vector::z |
The documentation for this class was generated from the following files: