Math Types & Utilities (mathutils)¶

This module provides access to math operations.

Note

Classes, methods and attributes that accept vectors also accept other numeric sequences, such as tuples, lists.

Submodules:

The mathutils module provides the following classes:

Color,
Euler,
Matrix,
Quaternion,
Vector,

import mathutils
from math import radians

vec = mathutils.Vector((1.0, 2.0, 3.0))

mat_rot = mathutils.Matrix.Rotation(radians(90.0), 4, 'X')
mat_trans = mathutils.Matrix.Translation(vec)

mat = mat_trans * mat_rot
mat.invert()

mat3 = mat.to_3x3()
quat1 = mat.to_quaternion()
quat2 = mat3.to_quaternion()

quat_diff = quat1.rotation_difference(quat2)

print(quat_diff.angle)

Color¶

class mathutils.Color(rgb)¶

This object gives access to Colors in Blender.

Parameters: rgb (3d vector) – (r, g, b) color values

import mathutils

# color values are represented as RGB values from 0 - 1, this is blue
col = mathutils.Color((0.0, 0.0, 1.0))

# as well as r/g/b attribute access you can adjust them by h/s/v
col.s *= 0.5

# you can access its components by attribute or index
print("Color R:", col.r)
print("Color G:", col[1])
print("Color B:", col[-1])
print("Color HSV: %.2f, %.2f, %.2f", col[:])


# components of an existing color can be set
col[:] = 0.0, 0.5, 1.0

# components of an existing color can use slice notation to get a tuple
print("Values: %f, %f, %f" % col[:])

# colors can be added and subtracted
col += mathutils.Color((0.25, 0.0, 0.0))

# Color can be multiplied, in this example color is scaled to 0-255
# can printed as integers
print("Color: %d, %d, %d" % (col * 255.0)[:])

# This example prints the color as hexidecimal
print("Hexidecimal: %.2x%.2x%.2x" % (col * 255.0)[:])

copy()¶

Returns a copy of this color.

Returns: A copy of the color.
Return type: Color

Note

use this to get a copy of a wrapped color with no reference to the original data.

freeze()¶

Make this object immutable.

After this the object can be hashed, used in dictionaries & sets.

Returns: An instance of this object.

b¶

Blue color channel.

Type: float

g¶

Green color channel.

Type: float

h¶

HSV Hue component in [0, 1].

Type: float

hsv¶

HSV Values in [0, 1].

Type: float triplet

is_frozen¶

True when this object has been frozen (read-only).

Type: boolean

is_wrapped¶

True when this object wraps external data (read-only).

Type: boolean

owner¶: The item this is wrapping or None (read-only).

r¶

Red color channel.

Type: float

s¶

HSV Saturation component in [0, 1].

Type: float

v¶

HSV Value component in [0, 1].

Type: float

Euler¶

class mathutils.Euler(angles, order='XYZ')¶

This object gives access to Eulers in Blender.

Parameters

angles (3d vector) – Three angles, in radians.
order (str) – Optional order of the angles, a permutation of XYZ.

import mathutils
import math

# create a new euler with default axis rotation order
eul = mathutils.Euler((0.0, math.radians(45.0), 0.0), 'XYZ')

# rotate the euler
eul.rotate_axis('Z', math.radians(10.0))

# you can access its components by attribute or index
print("Euler X", eul.x)
print("Euler Y", eul[1])
print("Euler Z", eul[-1])

# components of an existing euler can be set
eul[:] = 1.0, 2.0, 3.0

# components of an existing euler can use slice notation to get a tuple
print("Values: %f, %f, %f" % eul[:])

# the order can be set at any time too
eul.order = 'ZYX'

# eulers can be used to rotate vectors
vec = mathutils.Vector((0.0, 0.0, 1.0))
vec.rotate(eul)

# often its useful to convert the euler into a matrix so it can be used as
# transformations with more flexibility
mat_rot = eul.to_matrix()
mat_loc = mathutils.Matrix.Translation((2.0, 3.0, 4.0))
mat = mat_loc * mat_rot.to_4x4()

copy()¶

Returns a copy of this euler.

Returns: A copy of the euler.
Return type: Euler

Note

use this to get a copy of a wrapped euler with no reference to the original data.

freeze()¶

Make this object immutable.

After this the object can be hashed, used in dictionaries & sets.

Returns: An instance of this object.

make_compatible(other)¶: Make this euler compatible with another, so interpolating between them works as intended.

Note

the rotation order is not taken into account for this function.

rotate(other)¶

Rotates the euler by another mathutils value.

Parameters: other (Euler, Quaternion or Matrix) – rotation component of mathutils value

rotate_axis(axis, angle)¶

Rotates the euler a certain amount and returning a unique euler rotation (no 720 degree pitches).

Parameters

axis (string) – single character in [‘X, ‘Y’, ‘Z’].
angle (float) – angle in radians.

to_matrix()¶

Return a matrix representation of the euler.

Returns: A 3x3 roation matrix representation of the euler.
Return type: Matrix

to_quaternion()¶

Return a quaternion representation of the euler.

Returns: Quaternion representation of the euler.
Return type: Quaternion

zero()¶: Set all values to zero.

is_frozen¶

True when this object has been frozen (read-only).

Type: boolean

is_wrapped¶

True when this object wraps external data (read-only).

Type: boolean

order¶

Euler rotation order.

Type: string in [‘XYZ’, ‘XZY’, ‘YXZ’, ‘YZX’, ‘ZXY’, ‘ZYX’]

owner¶: The item this is wrapping or None (read-only).

x¶

Euler axis angle in radians.

Type: float

y¶

Euler axis angle in radians.

Type: float

z¶

Euler axis angle in radians.

Type: float

Matrix¶

class mathutils.Matrix([rows])¶

This object gives access to Matrices in Blender, supporting square and rectangular matrices from 2x2 up to 4x4.

Parameters: rows (2d number sequence) – Sequence of rows. When ommitted, a 4x4 identity matrix is constructed.

import mathutils
import math

# create a location matrix
mat_loc = mathutils.Matrix.Translation((2.0, 3.0, 4.0))

# create an identitiy matrix
mat_sca = mathutils.Matrix.Scale(0.5, 4, (0.0, 0.0, 1.0))

# create a rotation matrix
mat_rot = mathutils.Matrix.Rotation(math.radians(45.0), 4, 'X')

# combine transformations
mat_out = mat_loc * mat_rot * mat_sca
print(mat_out)

# extract components back out of the matrix
loc, rot, sca = mat_out.decompose()
print(loc, rot, sca)

# it can also be useful to access components of a matrix directly
mat = mathutils.Matrix()
mat[0][0], mat[1][0], mat[2][0] = 0.0, 1.0, 2.0

mat[0][0:3] = 0.0, 1.0, 2.0

# each item in a matrix is a vector so vector utility functions can be used
mat[0].xyz = 0.0, 1.0, 2.0

classmethod Identity(size)¶

Create an identity matrix.

Parameters: size (int) – The size of the identity matrix to construct [2, 4].
Returns: A new identity matrix.
Return type: Matrix

classmethod OrthoProjection(axis, size)¶

Create a matrix to represent an orthographic projection.

Parameters

axis (string or Vector) – Can be any of the following: [‘X’, ‘Y’, ‘XY’, ‘XZ’, ‘YZ’], where a single axis is for a 2D matrix. Or a vector for an arbitrary axis
size (int) – The size of the projection matrix to construct [2, 4].

Returns

A new projection matrix.

Return type

Matrix

classmethod Rotation(angle, size, axis)¶

Create a matrix representing a rotation.

Parameters

angle (float) – The angle of rotation desired, in radians.
size (int) – The size of the rotation matrix to construct [2, 4].
axis (string or Vector) – a string in [‘X’, ‘Y’, ‘Z’] or a 3D Vector Object (optional when size is 2).

Returns

A new rotation matrix.

Return type

Matrix

classmethod Scale(factor, size, axis)¶

Create a matrix representing a scaling.

Parameters

factor (float) – The factor of scaling to apply.
size (int) – The size of the scale matrix to construct [2, 4].
axis (Vector) – Direction to influence scale. (optional).

Returns

A new scale matrix.

Return type

Matrix

classmethod Shear(plane, size, factor)¶

Create a matrix to represent an shear transformation.

Parameters

plane (string) – Can be any of the following: [‘X’, ‘Y’, ‘XY’, ‘XZ’, ‘YZ’], where a single axis is for a 2D matrix only.
size (int) – The size of the shear matrix to construct [2, 4].
factor (float or float pair) – The factor of shear to apply. For a 3 or 4 size matrix pass a pair of floats corresponding with the plane axis.

Returns

A new shear matrix.

Return type

Matrix

classmethod Translation(vector)¶

Create a matrix representing a translation.

Parameters: vector (Vector) – The translation vector.
Returns: An identity matrix with a translation.
Return type: Matrix

adjugate()¶: Set the matrix to its adjugate.

Note

When the matrix cannot be adjugated a ValueError exception is raised.

See also

Adjugate matrix <https://en.wikipedia.org/wiki/Adjugate_matrix> on Wikipedia.

adjugated()¶

Return an adjugated copy of the matrix.

Returns: the adjugated matrix.
Return type: Matrix

Note

When the matrix cant be adjugated a ValueError exception is raised.

copy()¶

Returns a copy of this matrix.

Returns: an instance of itself
Return type: Matrix

decompose()¶

Return the translation, rotation and scale components of this matrix.

Returns: trans, rot, scale triple.
Return type: (Vector, Quaternion, Vector)

determinant()¶

Return the determinant of a matrix.

Returns: Return the determinant of a matrix.
Return type: float

Quaternion¶

class mathutils.Quaternion([seq[, angle]])¶

This object gives access to Quaternions in Blender.

Parameters

seq (Vector) – size 3 or 4
angle (float) – rotation angle, in radians

The constructor takes arguments in various forms:

(), no args: Create an identity quaternion
(wxyz): Create a quaternion from a (w, x, y, z) vector.
(exponential_map): Create a quaternion from a 3d exponential map vector.

See also

to_exponential_map()
(axis, angle): Create a quaternion representing a rotation of angle radians over axis.

See also

to_axis_angle()

import mathutils
import math

# a new rotation 90 degrees about the Y axis
quat_a = mathutils.Quaternion((0.7071068, 0.0, 0.7071068, 0.0))

# passing values to Quaternion's directly can be confusing so axis, angle
# is supported for initializing too
quat_b = mathutils.Quaternion((0.0, 1.0, 0.0), math.radians(90.0))

print("Check quaternions match", quat_a == quat_b)

# like matrices, quaternions can be multiplied to accumulate rotational values
quat_a = mathutils.Quaternion((0.0, 1.0, 0.0), math.radians(90.0))
quat_b = mathutils.Quaternion((0.0, 0.0, 1.0), math.radians(45.0))
quat_out = quat_a * quat_b

# print the quat, euler degrees for mear mortals and (axis, angle)
print("Final Rotation:")
print(quat_out)
print("%.2f, %.2f, %.2f" % tuple(math.degrees(a) for a in quat_out.to_euler()))
print("(%.2f, %.2f, %.2f), %.2f" % (quat_out.axis[:] +
                                    (math.degrees(quat_out.angle), )))

# multiple rotations can be interpolated using the exponential map
quat_c = mathutils.Quaternion((1.0, 0.0, 0.0), math.radians(15.0))
exp_avg = (quat_a.to_exponential_map() +
           quat_b.to_exponential_map() +
           quat_c.to_exponential_map()) / 3.0
quat_avg = mathutils.Quaternion(exp_avg)
print("Average rotation:")
print(quat_avg)

conjugate()¶: Set the quaternion to its conjugate (negate x, y, z).

conjugated()¶

Return a new conjugated quaternion.

Returns: a new quaternion.
Return type: Quaternion

copy()¶

Returns a copy of this quaternion.

Returns: A copy of the quaternion.
Return type: Quaternion

Note

use this to get a copy of a wrapped quaternion with no reference to the original data.

cross(other)¶

Return the cross product of this quaternion and another.

Parameters: other (Quaternion) – The other quaternion to perform the cross product with.
Returns: The cross product.
Return type: Quaternion

dot(other)¶

Return the dot product of this quaternion and another.

Parameters: other (Quaternion) – The other quaternion to perform the dot product with.
Returns: The dot product.
Return type: Quaternion

freeze()¶

Make this object immutable.

After this the object can be hashed, used in dictionaries & sets.

Returns: An instance of this object.

identity()¶

Set the quaternion to an identity quaternion.

Return type: Quaternion

invert()¶: Set the quaternion to its inverse.

inverted()¶

Return a new, inverted quaternion.

Returns: the inverted value.
Return type: Quaternion

negate()¶

Set the quaternion to its negative.

Return type: Quaternion

normalize()¶: Normalize the quaternion.

normalized()¶

Return a new normalized quaternion.

Returns: a normalized copy.
Return type: Quaternion

rotate(other)¶

Rotates the quaternion by another mathutils value.

Parameters: other (Euler, Quaternion or Matrix) – rotation component of mathutils value

rotation_difference(other)¶

Returns a quaternion representing the rotational difference.

Parameters: other (Quaternion) – second quaternion.
Returns: the rotational difference between the two quat rotations.
Return type: Quaternion

slerp(other, factor)¶

Returns the interpolation of two quaternions.

Parameters

other (Quaternion) – value to interpolate with.
factor (float) – The interpolation value in [0.0, 1.0].

Returns

The interpolated rotation.

Return type

Quaternion

to_axis_angle()¶

Return the axis, angle representation of the quaternion.

Returns: axis, angle.
Return type: (Vector, float) pair

to_euler(order, euler_compat)¶

Return Euler representation of the quaternion.

Parameters

order (string) – Optional rotation order argument in [‘XYZ’, ‘XZY’, ‘YXZ’, ‘YZX’, ‘ZXY’, ‘ZYX’].
euler_compat (Euler) – Optional euler argument the new euler will be made compatible with (no axis flipping between them). Useful for converting a series of matrices to animation curves.

Returns

Euler representation of the quaternion.

Return type

Euler

to_exponential_map()¶

Return the exponential map representation of the quaternion.

This representation consist of the rotation axis multiplied by the rotation angle. Such a representation is useful for interpolation between multiple orientations.

Returns: exponential map.
Return type: Vector of size 3

To convert back to a quaternion, pass it to the Quaternion constructor.

to_matrix()¶

Return a matrix representation of the quaternion.

Returns: A 3x3 rotation matrix representation of the quaternion.
Return type: Matrix

angle¶

Angle of the quaternion.

Type: float

axis¶

Quaternion axis as a vector.

Type: Vector

is_frozen¶

True when this object has been frozen (read-only).

Type: boolean

is_wrapped¶

True when this object wraps external data (read-only).

Type: boolean

magnitude¶

Size of the quaternion (read-only).

Type: float

owner¶: The item this is wrapping or None (read-only).

w¶

Quaternion axis value.

Type: float

x¶

Quaternion axis value.

Type: float

y¶

Quaternion axis value.

Type: float

z¶

Quaternion axis value.

Type: float

Vector¶

class mathutils.Vector(seq)¶

This object gives access to Vectors in Blender.

Parameters: seq (sequence of numbers) – Components of the vector, must be a sequence of at least two

import mathutils

# zero length vector
vec = mathutils.Vector((0.0, 0.0, 1.0))

# unit length vector
vec_a = vec.normalized()

vec_b = mathutils.Vector((0.0, 1.0, 2.0))

vec2d = mathutils.Vector((1.0, 2.0))
vec3d = mathutils.Vector((1.0, 0.0, 0.0))
vec4d = vec_a.to_4d()

# other mathutuls types
quat = mathutils.Quaternion()
matrix = mathutils.Matrix()

# Comparison operators can be done on Vector classes:

# (In)equality operators == and != test component values, e.g. 1,2,3 != 3,2,1
vec_a == vec_b
vec_a != vec_b

# Ordering operators >, >=, > and <= test vector length.
vec_a > vec_b
vec_a >= vec_b
vec_a < vec_b
vec_a <= vec_b


# Math can be performed on Vector classes
vec_a + vec_b
vec_a - vec_b
vec_a * vec_b
vec_a * 10.0
matrix * vec_a
quat * vec_a
vec_a * vec_b
-vec_a


# You can access a vector object like a sequence
x = vec_a[0]
len(vec)
vec_a[:] = vec_b
vec_a[:] = 1.0, 2.0, 3.0
vec2d[:] = vec3d[:2]


# Vectors support 'swizzle' operations
# See https://en.wikipedia.org/wiki/Swizzling_(computer_graphics)
vec.xyz = vec.zyx
vec.xy = vec4d.zw
vec.xyz = vec4d.wzz
vec4d.wxyz = vec.yxyx

classmethod Fill(size, fill=0.0)¶

Create a vector of length size with all values set to fill.

Parameters

size (int) – The length of the vector to be created.
fill (float) – The value used to fill the vector.

classmethod Linspace(start, stop, size)¶

Create a vector of the specified size which is filled with linearly spaced values between start and stop values.

Parameters

start (int) – The start of the range used to fill the vector.
stop (int) – The end of the range used to fill the vector.
size (int) – The size of the vector to be created.

classmethod Range(start=0, stop, step=1)¶

Create a filled with a range of values.

Parameters

start (int) – The start of the range used to fill the vector.
stop (int) – The end of the range used to fill the vector.
step (int) – The step between successive values in the vector.

classmethod Repeat(vector, size)¶

Create a vector by repeating the values in vector until the required size is reached.

Parameters

tuple (mathutils.Vector) – The vector to draw values from.
size (int) – The size of the vector to be created.

angle(other, fallback=None)¶

Return the angle between two vectors.

Parameters

other (Vector) – another vector to compare the angle with
fallback (any) – return this when the angle can’t be calculated (zero length vector), (instead of raising a ValueError).

Returns

angle in radians or fallback when given

Return type

float

angle_signed(other, fallback)¶

Return the signed angle between two 2D vectors (clockwise is positive).

Parameters

other (Vector) – another vector to compare the angle with
fallback (any) – return this when the angle can’t be calculated (zero length vector), (instead of raising a ValueError).

Returns

angle in radians or fallback when given

Return type

float

copy()¶

Returns a copy of this vector.

Returns: A copy of the vector.
Return type: Vector

Note

use this to get a copy of a wrapped vector with no reference to the original data.

cross(other)¶

Return the cross product of this vector and another.

Parameters: other (Vector) – The other vector to perform the cross product with.
Returns: The cross product.
Return type: Vector or float when 2D vectors are used

Note

both vectors must be 2D or 3D

dot(other)¶

Return the dot product of this vector and another.

Parameters: other (Vector) – The other vector to perform the dot product with.
Returns: The dot product.
Return type: Vector

freeze()¶

Make this object immutable.

After this the object can be hashed, used in dictionaries & sets.

Returns: An instance of this object.

lerp(other, factor)¶

Returns the interpolation of two vectors.

Parameters

other (Vector) – value to interpolate with.
factor (float) – The interpolation value in [0.0, 1.0].

Returns

The interpolated vector.

Return type

Vector

negate()¶: Set all values to their negative.

normalize()¶: Normalize the vector, making the length of the vector always 1.0.

Warning

Normalizing a vector where all values are zero has no effect.

Note

Normalize works for vectors of all sizes, however 4D Vectors w axis is left untouched.

normalized()¶

Return a new, normalized vector.

Returns: a normalized copy of the vector
Return type: Vector

orthogonal()¶

Return a perpendicular vector.

Returns: a new vector 90 degrees from this vector.
Return type: Vector

Note

the axis is undefined, only use when any orthogonal vector is acceptable.

project(other)¶

Return the projection of this vector onto the other.

Parameters: other (Vector) – second vector.
Returns: the parallel projection vector
Return type: Vector

reflect(mirror)¶

Return the reflection vector from the mirror argument.

Parameters: mirror (Vector) – This vector could be a normal from the reflecting surface.
Returns: The reflected vector matching the size of this vector.
Return type: Vector

resize(size=3)¶: Resize the vector to have size number of elements.

resize_2d()¶: Resize the vector to 2D (x, y).

resize_3d()¶: Resize the vector to 3D (x, y, z).

resize_4d()¶: Resize the vector to 4D (x, y, z, w).

resized(size=3)¶

Return a resized copy of the vector with size number of elements.

Returns: a new vector
Return type: Vector

rotate(other)¶

Rotate the vector by a rotation value.

Parameters: other (Euler, Quaternion or Matrix) – rotation component of mathutils value

rotation_difference(other)¶

Returns a quaternion representing the rotational difference between this vector and another.

Parameters: other (Vector) – second vector.
Returns: the rotational difference between the two vectors.
Return type: Quaternion

Note

2D vectors raise an AttributeError.

slerp(other, factor, fallback=None)¶

Returns the interpolation of two non-zero vectors (spherical coordinates).

Parameters

other (Vector) – value to interpolate with.
factor (float) – The interpolation value typically in [0.0, 1.0].
fallback (any) – return this when the vector can’t be calculated (zero length vector or direct opposites), (instead of raising a ValueError).

Returns

The interpolated vector.

Return type

Vector

to_2d()¶

Return a 2d copy of the vector.

Returns: a new vector
Return type: Vector

to_3d()¶

Return a 3d copy of the vector.

Returns: a new vector
Return type: Vector

to_4d()¶

Return a 4d copy of the vector.

Returns: a new vector
Return type: Vector

to_track_quat(track, up)¶

Return a quaternion rotation from the vector and the track and up axis.

Parameters

track (string) – Track axis in [‘X’, ‘Y’, ‘Z’, ‘-X’, ‘-Y’, ‘-Z’].
up (string) – Up axis in [‘X’, ‘Y’, ‘Z’].

Returns

rotation from the vector and the track and up axis.

Return type

Quaternion

to_tuple(precision=- 1)¶

Return this vector as a tuple with.

Parameters: precision (int) – The number to round the value to in [-1, 21].
Returns: the values of the vector rounded by precision
Return type: tuple

zero()¶: Set all values to zero.

is_frozen¶

True when this object has been frozen (read-only).

Type: boolean

is_wrapped¶

True when this object wraps external data (read-only).

Type: boolean

length¶

Vector Length.

Type: float

length_squared¶

Vector length squared (v.dot(v)).

Type: float

magnitude¶

Vector Length.

Type: float

owner¶: The item this is wrapping or None (read-only).

w¶

Vector W axis (4D Vectors only).

Type: float

ww¶: Undocumented

www¶: Undocumented

wwww¶: Undocumented

wwwx¶: Undocumented

wwwy¶: Undocumented

wwwz¶: Undocumented

wwx¶: Undocumented

wwxw¶: Undocumented

wwxx¶: Undocumented

wwxy¶: Undocumented

wwxz¶: Undocumented

wwy¶: Undocumented

wwyw¶: Undocumented

wwyx¶: Undocumented

wwyy¶: Undocumented

wwyz¶: Undocumented

wwz¶: Undocumented

wwzw¶: Undocumented

wwzx¶: Undocumented

wwzy¶: Undocumented

wwzz¶: Undocumented

wx¶: Undocumented

wxw¶: Undocumented

wxww¶: Undocumented

wxwx¶: Undocumented

wxwy¶: Undocumented

wxwz¶: Undocumented

wxx¶: Undocumented

wxxw¶: Undocumented

wxxx¶: Undocumented

wxxy¶: Undocumented

wxxz¶: Undocumented

wxy¶: Undocumented

wxyw¶: Undocumented

wxyx¶: Undocumented

wxyy¶: Undocumented

wxyz¶: Undocumented

wxz¶: Undocumented

wxzw¶: Undocumented

wxzx¶: Undocumented

wxzy¶: Undocumented

wxzz¶: Undocumented

wy¶: Undocumented

wyw¶: Undocumented

wyww¶: Undocumented

wywx¶: Undocumented

wywy¶: Undocumented

wywz¶: Undocumented

wyx¶: Undocumented

wyxw¶: Undocumented

wyxx¶: Undocumented

wyxy¶: Undocumented

wyxz¶: Undocumented

wyy¶: Undocumented

wyyw¶: Undocumented

wyyx¶: Undocumented

wyyy¶: Undocumented

wyyz¶: Undocumented

wyz¶: Undocumented

wyzw¶: Undocumented

wyzx¶: Undocumented

wyzy¶: Undocumented

wyzz¶: Undocumented

wz¶: Undocumented

wzw¶: Undocumented

wzww¶: Undocumented

wzwx¶: Undocumented

wzwy¶: Undocumented

wzwz¶: Undocumented

wzx¶: Undocumented

wzxw¶: Undocumented

wzxx¶: Undocumented

wzxy¶: Undocumented

wzxz¶: Undocumented

wzy¶: Undocumented

wzyw¶: Undocumented

wzyx¶: Undocumented

wzyy¶: Undocumented

wzyz¶: Undocumented

wzz¶: Undocumented

wzzw¶: Undocumented

wzzx¶: Undocumented

wzzy¶: Undocumented

wzzz¶: Undocumented

x¶

Vector X axis.

Type: float

xw¶: Undocumented

xww¶: Undocumented

xwww¶: Undocumented

xwwx¶: Undocumented

xwwy¶: Undocumented

xwwz¶: Undocumented

xwx¶: Undocumented

xwxw¶: Undocumented

xwxx¶: Undocumented

xwxy¶: Undocumented

xwxz¶: Undocumented

xwy¶: Undocumented

xwyw¶: Undocumented

xwyx¶: Undocumented

xwyy¶: Undocumented

xwyz¶: Undocumented

xwz¶: Undocumented

xwzw¶: Undocumented

xwzx¶: Undocumented

xwzy¶: Undocumented

xwzz¶: Undocumented

xx¶: Undocumented

xxw¶: Undocumented

xxww¶: Undocumented

xxwx¶: Undocumented

xxwy¶: Undocumented

xxwz¶: Undocumented

xxx¶: Undocumented

xxxw¶: Undocumented

xxxx¶: Undocumented

xxxy¶: Undocumented

xxxz¶: Undocumented

xxy¶: Undocumented

xxyw¶: Undocumented

xxyx¶: Undocumented

xxyy¶: Undocumented

xxyz¶: Undocumented

xxz¶: Undocumented

xxzw¶: Undocumented

xxzx¶: Undocumented

xxzy¶: Undocumented

xxzz¶: Undocumented

xy¶: Undocumented

xyw¶: Undocumented

xyww¶: Undocumented

xywx¶: Undocumented

xywy¶: Undocumented

xywz¶: Undocumented

xyx¶: Undocumented

xyxw¶: Undocumented

xyxx¶: Undocumented

xyxy¶: Undocumented

xyxz¶: Undocumented

xyy¶: Undocumented

xyyw¶: Undocumented

xyyx¶: Undocumented

xyyy¶: Undocumented

xyyz¶: Undocumented

xyz¶: Undocumented

xyzw¶: Undocumented

xyzx¶: Undocumented

xyzy¶: Undocumented

xyzz¶: Undocumented

xz¶: Undocumented

xzw¶: Undocumented

xzww¶: Undocumented

xzwx¶: Undocumented

xzwy¶: Undocumented

xzwz¶: Undocumented

xzx¶: Undocumented

xzxw¶: Undocumented

xzxx¶: Undocumented

xzxy¶: Undocumented

xzxz¶: Undocumented

xzy¶: Undocumented

xzyw¶: Undocumented

xzyx¶: Undocumented

xzyy¶: Undocumented

xzyz¶: Undocumented

xzz¶: Undocumented

xzzw¶: Undocumented

xzzx¶: Undocumented

xzzy¶: Undocumented

xzzz¶: Undocumented

y¶

Vector Y axis.

Type: float

yw¶: Undocumented

yww¶: Undocumented

ywww¶: Undocumented

ywwx¶: Undocumented

ywwy¶: Undocumented

ywwz¶: Undocumented

ywx¶: Undocumented

ywxw¶: Undocumented

ywxx¶: Undocumented

ywxy¶: Undocumented

ywxz¶: Undocumented

ywy¶: Undocumented

ywyw¶: Undocumented

ywyx¶: Undocumented

ywyy¶: Undocumented

ywyz¶: Undocumented

ywz¶: Undocumented

ywzw¶: Undocumented

ywzx¶: Undocumented

ywzy¶: Undocumented

ywzz¶: Undocumented

yx¶: Undocumented

yxw¶: Undocumented

yxww¶: Undocumented

yxwx¶: Undocumented

yxwy¶: Undocumented

yxwz¶: Undocumented

yxx¶: Undocumented

yxxw¶: Undocumented

yxxx¶: Undocumented

yxxy¶: Undocumented

yxxz¶: Undocumented

yxy¶: Undocumented

yxyw¶: Undocumented

yxyx¶: Undocumented

yxyy¶: Undocumented

yxyz¶: Undocumented

yxz¶: Undocumented

yxzw¶: Undocumented

yxzx¶: Undocumented

yxzy¶: Undocumented

yxzz¶: Undocumented

yy¶: Undocumented

yyw¶: Undocumented

yyww¶: Undocumented

yywx¶: Undocumented

yywy¶: Undocumented

yywz¶: Undocumented

yyx¶: Undocumented

yyxw¶: Undocumented

yyxx¶: Undocumented

yyxy¶: Undocumented

yyxz¶: Undocumented

yyy¶: Undocumented

yyyw¶: Undocumented

yyyx¶: Undocumented

yyyy¶: Undocumented

yyyz¶: Undocumented

yyz¶: Undocumented

yyzw¶: Undocumented

yyzx¶: Undocumented

yyzy¶: Undocumented

yyzz¶: Undocumented

yz¶: Undocumented

yzw¶: Undocumented

yzww¶: Undocumented

yzwx¶: Undocumented

yzwy¶: Undocumented

yzwz¶: Undocumented

yzx¶: Undocumented

yzxw¶: Undocumented

yzxx¶: Undocumented

yzxy¶: Undocumented

yzxz¶: Undocumented

yzy¶: Undocumented

yzyw¶: Undocumented

yzyx¶: Undocumented

yzyy¶: Undocumented

yzyz¶: Undocumented

yzz¶: Undocumented

yzzw¶: Undocumented

yzzx¶: Undocumented

yzzy¶: Undocumented

yzzz¶: Undocumented

z¶

Vector Z axis (3D Vectors only).

Type: float

zw¶: Undocumented

zww¶: Undocumented

zwww¶: Undocumented

zwwx¶: Undocumented

zwwy¶: Undocumented

zwwz¶: Undocumented

zwx¶: Undocumented

zwxw¶: Undocumented

zwxx¶: Undocumented

zwxy¶: Undocumented

zwxz¶: Undocumented

zwy¶: Undocumented

zwyw¶: Undocumented

zwyx¶: Undocumented

zwyy¶: Undocumented

zwyz¶: Undocumented

zwz¶: Undocumented

zwzw¶: Undocumented

zwzx¶: Undocumented

zwzy¶: Undocumented

zwzz¶: Undocumented

zx¶: Undocumented

zxw¶: Undocumented

zxww¶: Undocumented

zxwx¶: Undocumented

zxwy¶: Undocumented

zxwz¶: Undocumented

zxx¶: Undocumented

zxxw¶: Undocumented

zxxx¶: Undocumented

zxxy¶: Undocumented

zxxz¶: Undocumented

zxy¶: Undocumented

zxyw¶: Undocumented

zxyx¶: Undocumented

zxyy¶: Undocumented

zxyz¶: Undocumented

zxz¶: Undocumented

zxzw¶: Undocumented

zxzx¶: Undocumented

zxzy¶: Undocumented

zxzz¶: Undocumented

zy¶: Undocumented

zyw¶: Undocumented

zyww¶: Undocumented

zywx¶: Undocumented

zywy¶: Undocumented

zywz¶: Undocumented

zyx¶: Undocumented

zyxw¶: Undocumented

zyxx¶: Undocumented

zyxy¶: Undocumented

zyxz¶: Undocumented

zyy¶: Undocumented

zyyw¶: Undocumented

zyyx¶: Undocumented

zyyy¶: Undocumented

zyyz¶: Undocumented

zyz¶: Undocumented

zyzw¶: Undocumented

zyzx¶: Undocumented

zyzy¶: Undocumented

zyzz¶: Undocumented

zz¶: Undocumented

zzw¶: Undocumented

zzww¶: Undocumented

zzwx¶: Undocumented

zzwy¶: Undocumented

zzwz¶: Undocumented

zzx¶: Undocumented

zzxw¶: Undocumented

zzxx¶: Undocumented

zzxy¶: Undocumented

zzxz¶: Undocumented

zzy¶: Undocumented

zzyw¶: Undocumented

zzyx¶: Undocumented

zzyy¶: Undocumented

zzyz¶: Undocumented

zzz¶: Undocumented

zzzw¶: Undocumented

zzzx¶: Undocumented

zzzy¶: Undocumented

zzzz¶: Undocumented