Vector¶

Imath.V2s¶

class Imath.V2s
short: None
short: None
V2s()V2s
V2s(V2s v)V2s
V2s(short a)V2s
V2s(short a, short b)V2s
V2s(table[2] t)V2s
operator==(V2s v) const -> boolean
operator!=(V2s v) const -> boolean
operator+(V2s v) const -> V2s
operator-(V2s v) const -> V2s
operator-() const -> V2s
operator*(V2s) const -> V2s
operator*(short s) const -> V2s
operator/(V2s v) const -> V2s
operator/(short s) const -> V2s
operator[](int idx) const -> short
operator[](int idx, short value)
equalWithAbsError(V2s v, short e) const -> boolean
equalWithRelError(V2s v, short e) const -> boolean
dot(V2s v)short
cross(V2s v) const -> short
negate()V2s&
length() const -> short
length2() const -> short
normalize()V2s&
normalizeExc()V2s&
normalizeNonNull()V2s&
normalized() const -> V2s
normalizedExc() const -> V2s
normalizedNonNull() const -> V2s
project(V2s v) const -> V2s
orthogonal(V2s v) const -> V2s
reflect(V2s v) const -> V2s
toTable() const -> table[2]
static dimensions()int
static baseTypeMin()short
static baseTypeMax()short
static baseTypeSmallest()short
static baseTypeEpsilon()short
static closestVertex(V2s v0, V2s v1, V2s v2, V2s p)V2s

Imath.V2i¶

class Imath.V2i
int: None
int: None
V2i()V2i
V2i(V2i v)V2i
V2i(int a)V2i
V2i(int a, int b)V2i
V2i(table[2] t)V2i
operator==(V2i v) const -> boolean
operator!=(V2i v) const -> boolean
operator+(V2i v) const -> V2i
operator-(V2i v) const -> V2i
operator-() const -> V2i
operator*(V2i) const -> V2i
operator*(int s) const -> V2i
operator/(V2i v) const -> V2i
operator/(int s) const -> V2i
operator[](int idx) const -> int
operator[](int idx, int value)
equalWithAbsError(V2i v, int e) const -> boolean
equalWithRelError(V2i v, int e) const -> boolean
dot(V2i v)int
cross(V2i v) const -> int
negate()V2i&
length() const -> int
length2() const -> int
normalize()V2i&
normalizeExc()V2i&
normalizeNonNull()V2i&
normalized() const -> V2i
normalizedExc() const -> V2i
normalizedNonNull() const -> V2i
project(V2i v) const -> V2i
orthogonal(V2i v) const -> V2i
reflect(V2i v) const -> V2i
toTable() const -> table[2]
static dimensions()int
static baseTypeMin()int
static baseTypeMax()int
static baseTypeSmallest()int
static baseTypeEpsilon()int
static closestVertex(V2i v0, V2i v1, V2i v2, V2i p)V2i

Imath.V2f¶

class Imath.V2f
float: None
float: None
V2f()V2f
V2f(V2f v)V2f
V2f(float a)V2f
V2f(float a, float b)V2f
V2f(table[2] t)V2f
operator==(V2f v) const -> boolean
operator!=(V2f v) const -> boolean
operator+(V2f v) const -> V2f
operator-(V2f v) const -> V2f
operator-() const -> V2f
operator*(V2f) const -> V2f
operator*(float s) const -> V2f
operator/(V2f v) const -> V2f
operator/(float s) const -> V2f
operator*(M33f m) const -> V2f
operator[](int idx) const -> float
operator[](int idx, float value)
equalWithAbsError(V2f v, float e) const -> boolean
equalWithRelError(V2f v, float e) const -> boolean
dot(V2f v)float
cross(V2f v) const -> float
negate()V2f&
length() const -> float
length2() const -> float
normalize()V2f&
normalizeExc()V2f&
normalizeNonNull()V2f&
normalized() const -> V2f
normalizedExc() const -> V2f
normalizedNonNull() const -> V2f
project(V2f v) const -> V2f
orthogonal(V2f v) const -> V2f
reflect(V2f v) const -> V2f
toTable() const -> table[2]
static dimensions()int
static baseTypeMin()float
static baseTypeMax()float
static baseTypeSmallest()float
static baseTypeEpsilon()float
static closestVertex(V2f v0, V2f v1, V2f v2, V2f p)V2f

Imath.V2d¶

class Imath.V2d
double: None
double: None
V2d()V2d
V2d(V2d v)V2d
V2d(double a)V2d
V2d(double a, double b)V2d
V2d(table[2] t)V2d
operator==(V2d v) const -> boolean
operator!=(V2d v) const -> boolean
operator+(V2d v) const -> V2d
operator-(V2d v) const -> V2d
operator-() const -> V2d
operator*(V2d) const -> V2d
operator*(double s) const -> V2d
operator/(V2d v) const -> V2d
operator/(double s) const -> V2d
operator*(M33d m) const -> V2d
operator[](int idx) const -> double
operator[](int idx, double value)
equalWithAbsError(V2d v, double e) const -> boolean
equalWithRelError(V2d v, double e) const -> boolean
dot(V2d v)double
cross(V2d v) const -> double
negate()V2d&
length() const -> double
length2() const -> double
normalize()V2d&
normalizeExc()V2d&
normalizeNonNull()V2d&
normalized() const -> V2d
normalizedExc() const -> V2d
normalizedNonNull() const -> V2d
project(V2d v) const -> V2d
orthogonal(V2d v) const -> V2d
reflect(V2d v) const -> V2d
toTable() const -> table[2]
static dimensions()int
static baseTypeMin()double
static baseTypeMax()double
static baseTypeSmallest()double
static baseTypeEpsilon()double
static closestVertex(V2d v0, V2d v1, V2d v2, V2d p)V2d

Imath.V3s¶

InfException: None

`INF_EXCEPTION`

class Imath.V3s
short: None
short: None
short: None
V3s()V3s
V3s(V3s v)V3s
V3s(short a)V3s
V3s(short a, short b, short c)V3s
V3s(table[3] t)V3s
V3s(V4s v)V3s
V3s(V4s v, InfException)V3s
operator==(V3s v) const -> boolean
operator!=(V3s v) const -> boolean
operator+(V3s v) const -> V3s
operator-(V3s v) const -> V3s
operator-() const -> V3s
operator*(V3s) const -> V3s
operator*(short s) const -> V3s
operator/(V3s v) const -> V3s
operator/(short s) const -> V3s
operator[](int idx) const -> short
operator[](int idx, short value)
equalWithAbsError(V3s v, short e) const -> boolean
equalWithRelError(V3s v, short e) const -> boolean
dot(V3s v)short
cross(V3s v) const -> V3s
negate()V3s&
length() const -> short
length2() const -> short
normalize()V3s&
normalizeExc()V3s&
normalizeNonNull()V3s&
normalized() const -> V3s
normalizedExc() const -> V3s
normalizedNonNull() const -> V3s
project(V3s v) const -> V3s
orthogonal(V3s v) const -> V3s
reflect(V3s v) const -> V3s
toTable() const -> table[3]
static dimensions()int
static baseTypeMin()short
static baseTypeMax()short
static baseTypeSmallest()short
static baseTypeEpsilon()short
static closestVertex(V3s v0, V3s v1, V3s v2, V3s p)V3s

Imath.V3i¶

class Imath.V3i
int: None
int: None
int: None
V3i()V3i
V3i(V3i v)V3i
V3i(int a)V3i
V3i(int a, int b, int c)V3i
V3i(table[3] t)V3i
V3i(V4i v)V3i
V3i(V4i v, InfException)V3i
operator==(V3i v) const -> boolean
operator!=(V3i v) const -> boolean
operator+(V3i v) const -> V3i
operator-(V3i v) const -> V3i
operator-() const -> V3i
operator*(V3i) const -> V3i
operator*(int s) const -> V3i
operator/(V3i v) const -> V3i
operator/(int s) const -> V3i
operator[](int idx) const -> int
operator[](int idx, int value)
equalWithAbsError(V3i v, int e) const -> boolean
equalWithRelError(V3i v, int e) const -> boolean
dot(V3i v)int
cross(V3i v) const -> V3i
negate()V3i&
length() const -> int
length2() const -> int
normalize()V3i&
normalizeExc()V3i&
normalizeNonNull()V3i&
normalized() const -> V3i
normalizedExc() const -> V3i
normalizedNonNull() const -> V3i
project(V3i v) const -> V3i
orthogonal(V3i v) const -> V3i
reflect(V3i v) const -> V3i
toTable() const -> table[3]
static dimensions()int
static baseTypeMin()int
static baseTypeMax()int
static baseTypeSmallest()int
static baseTypeEpsilon()int
static closestVertex(V3i v0, V3i v1, V3i v2, V3i p)V3i

Imath.V3f¶

class Imath.V3f
float: None
float: None
float: None
V3f()V3f
V3f(V3f v)V3f
V3f(float a)V3f
V3f(float a, float b, float c)V3f
V3f(table[3] t)V3f
V3f(V4f v)V3f
V3f(V4f v, InfException)V3f
operator==(V3f v) const -> boolean
operator!=(V3f v) const -> boolean
operator+(V3f v) const -> V3f
operator-(V3f v) const -> V3f
operator-() const -> V3f
operator*(V3f) const -> V3f
operator*(float s) const -> V3f
operator/(V3f v) const -> V3f
operator/(float s) const -> V3f
operator*(M33f m) const -> V3f
operator*(M44f m) const -> V3f
operator[](int idx) const -> float
operator[](int idx, float value)
equalWithAbsError(V3f v, float e) const -> boolean
equalWithRelError(V3f v, float e) const -> boolean
dot(V3f v)float
cross(V3f v) const -> V3f
negate()V3f&
length() const -> float
length2() const -> float
normalize()V3f&
normalizeExc()V3f&
normalizeNonNull()V3f&
normalized() const -> V3f
normalizedExc() const -> V3f
normalizedNonNull() const -> V3f
project(V3f v) const -> V3f
orthogonal(V3f v) const -> V3f
reflect(V3f v) const -> V3f
toTable() const -> table[3]
static dimensions()int
static baseTypeMin()float
static baseTypeMax()float
static baseTypeSmallest()float
static baseTypeEpsilon()float
static closestVertex(V3f v0, V3f v1, V3f v2, V3f p)V3f

Imath.V3d¶

class Imath.V3d
double: None
double: None
double: None
V3d()V3d
V3d(V3d v)V3d
V3d(double a)V3d
V3d(double a, double b, double c)V3d
V3d(table[3] t)V3d
V3d(V4d v)V3d
V3d(V4d v, InfException)V3d
operator==(V3d v) const -> boolean
operator!=(V3d v) const -> boolean
operator+(V3d v) const -> V3d
operator-(V3d v) const -> V3d
operator-() const -> V3d
operator*(V3d) const -> V3d
operator*(double s) const -> V3d
operator/(V3d v) const -> V3d
operator/(double s) const -> V3d
operator*(M33d m) const -> V3d
operator*(M44d m) const -> V3d
operator[](int idx) const -> double
operator[](int idx, double value)
equalWithAbsError(V3d v, double e) const -> boolean
equalWithRelError(V3d v, double e) const -> boolean
dot(V3d v)double
cross(V3d v) const -> V3d
negate()V3d&
length() const -> double
length2() const -> double
normalize()V3d&
normalizeExc()V3d&
normalizeNonNull()V3d&
normalized() const -> V3d
normalizedExc() const -> V3d
normalizedNonNull() const -> V3d
project(V3d v) const -> V3d
orthogonal(V3d v) const -> V3d
reflect(V3d v) const -> V3d
toTable() const -> table[3]
static dimensions()int
static baseTypeMin()double
static baseTypeMax()double
static baseTypeSmallest()double
static baseTypeEpsilon()double
static closestVertex(V3d v0, V3d v1, V3d v2, V3d p)V3d

Imath.V4s¶

class Imath.V4s
short: None
short: None
short: None
short: None
V4s()V4s
V4s(V4s v)V4s
V4s(short a)V4s
V4s(short a, short b, short c, short d)V4s
V4s(table[4] t)V4s
operator==(V4s v) const -> boolean
operator!=(V4s v) const -> boolean
operator+(V4s v) const -> V4s
operator-(V4s v) const -> V4s
operator-() const -> V4s
operator*(V4s) const -> V4s
operator*(short s) const -> V4s
operator/(V4s v) const -> V4s
operator/(short s) const -> V4s
operator[](int idx) const -> short
operator[](int idx, short value)
equalWithAbsError(V4s v, short e) const -> boolean
equalWithRelError(V4s v, short e) const -> boolean
dot(V4s v)short
cross(V4s v) const -> V4s
negate()V4s&
length() const -> short
length2() const -> short
normalize()V4s&
normalizeExc()V4s&
normalizeNonNull()V4s&
normalized() const -> V4s
normalizedExc() const -> V4s
normalizedNonNull() const -> V4s
project(V4s v) const -> V4s
orthogonal(V4s v) const -> V4s
reflect(V4s v) const -> V4s
toTable() const -> table[4]
static dimensions()int
static baseTypeMin()short
static baseTypeMax()short
static baseTypeSmallest()short
static baseTypeEpsilon()short
static closestVertex(V4s v0, V4s v1, V4s v2, V4s p)V4s

Imath.V4i¶

class Imath.V4i
int: None
int: None
int: None
int: None
V4i()V4i
V4i(V4i v)V4i
V4i(int a)V4i
V4i(int a, int b, int c, int d)V4i
V4i(table[4] t)V4i
operator==(V4i v) const -> boolean
operator!=(V4i v) const -> boolean
operator+(V4i v) const -> V4i
operator-(V4i v) const -> V4i
operator-() const -> V4i
operator*(V4i) const -> V4i
operator*(int s) const -> V4i
operator/(V4i v) const -> V4i
operator/(int s) const -> V4i
operator[](int idx) const -> int
operator[](int idx, int value)
equalWithAbsError(V4i v, int e) const -> boolean
equalWithRelError(V4i v, int e) const -> boolean
dot(V4i v)int
cross(V4i v) const -> V4i
negate()V4i&
length() const -> int
length2() const -> int
normalize()V4i&
normalizeExc()V4i&
normalizeNonNull()V4i&
normalized() const -> V4i
normalizedExc() const -> V4i
normalizedNonNull() const -> V4i
project(V4i v) const -> V4i
orthogonal(V4i v) const -> V4i
reflect(V4i v) const -> V4i
toTable() const -> table[4]
static dimensions()int
static baseTypeMin()int
static baseTypeMax()int
static baseTypeSmallest()int
static baseTypeEpsilon()int
static closestVertex(V4i v0, V4i v1, V4i v2, V4i p)V4i

Imath.V4f¶

class Imath.V4f
float: None
float: None
float: None
float: None
V4f()V4f
V4f(V4f v)V4f
V4f(float a)V4f
V4f(float a, float b, float c, float d)V4f
V4f(table[4] t)V4f
operator==(V4f v) const -> boolean
operator!=(V4f v) const -> boolean
operator+(V4f v) const -> V4f
operator-(V4f v) const -> V4f
operator-() const -> V4f
operator*(V4f) const -> V4f
operator*(float s) const -> V4f
operator/(V4f v) const -> V4f
operator/(float s) const -> V4f
operator*(M44f m) const -> V4f
operator[](int idx) const -> float
operator[](int idx, float value)
equalWithAbsError(V4f v, float e) const -> boolean
equalWithRelError(V4f v, float e) const -> boolean
dot(V4f v)float
cross(V4f v) const -> V4f
negate()V4f&
length() const -> float
length2() const -> float
normalize()V4f&
normalizeExc()V4f&
normalizeNonNull()V4f&
normalized() const -> V4f
normalizedExc() const -> V4f
normalizedNonNull() const -> V4f
project(V4f v) const -> V4f
orthogonal(V4f v) const -> V4f
reflect(V4f v) const -> V4f
toTable() const -> table[4]
static dimensions()int
static baseTypeMin()float
static baseTypeMax()float
static baseTypeSmallest()float
static baseTypeEpsilon()float
static closestVertex(V4f v0, V4f v1, V4f v2, V4f p)V4f

Imath.V4d¶

class Imath.V4d
double: None
double: None
double: None
double: None
V4d()V4d
V4d(V4d v)V4d
V4d(double a)V4d
V4d(double a, double b, double c, double d)V4d
V4d(table[4] t)V4d
operator==(V4d v) const -> boolean
operator!=(V4d v) const -> boolean
operator+(V4d v) const -> V4d
operator-(V4d v) const -> V4d
operator-() const -> V4d
operator*(V4d) const -> V4d
operator*(double s) const -> V4d
operator/(V4d v) const -> V4d
operator/(double s) const -> V4d
operator*(M44d m) const -> V4d
operator[](int idx) const -> double
operator[](int idx, double value)
equalWithAbsError(V4d v, double e) const -> boolean
equalWithRelError(V4d v, double e) const -> boolean
dot(V4d v)double
cross(V4d v) const -> V4d
negate()V4d&
length() const -> double
length2() const -> double
normalize()V4d&
normalizeExc()V4d&
normalizeNonNull()V4d&
normalized() const -> V4d
normalizedExc() const -> V4d
normalizedNonNull() const -> V4d
project(V4d v) const -> V4d
orthogonal(V4d v) const -> V4d
reflect(V4d v) const -> V4d
toTable() const -> table[4]
static dimensions()int
static baseTypeMin()double
static baseTypeMax()double
static baseTypeSmallest()double
static baseTypeEpsilon()double
static closestVertex(V4d v0, V4d v1, V4d v2, V4d p)V4d