Matrix

Imath.M33f

class Imath.M33f

M33f() → M33f

M33f(M33f m) → M33f

M33f(M33d m) → M33f

M33f(float a) → M33f

M33f(float a, float b, float c, float d, float e, float f, float g, float h, float i) → M33f

M33f(table[9] t) → M33f

operator==(M33f m) const -> boolean

operator!=(M33f m) const -> boolean

operator+(M33f m) const -> M33f

operator-(M33f m) const -> M33f

operator-() const -> M33f

operator*(M33f m) const -> M33f

operator*(float s) const -> M33f

operator/(float s) const -> M33f

operator[](int idx) const -> float

operator[](int idx, float value)

makeIdentity()

equalWithAbsError(M33f m, float e) const -> boolean

equalWithRelError(M33f m, float e) const -> boolean

negate() → M33f&

multVecMatrix(V2f v) const -> V2f

multDirMatrix(V2f v) const -> V2f

transpose() → M33f&

transposed() const -> M33f

invert() → M33f&

invert(boolean singExc) → M33f&

inverse() const -> M33f

inverse(boolean singExc) const -> M33f

gjInvert() → M33f&

gjInvert(boolean singExc) → M33f&

gjInverse() const -> M33f

gjInverse(boolean singExc) const -> M33f

minorOf(int r, int c) const -> float

fastMinor(int r0, int r1, int c0, int c1) const -> float

determinant() const -> float

setRotation(float r) → M33f&

rotate(float r) → M33f&

setScale(float s) → M33f&

setScale(V2f s) → M33f&

scale(V2f s) → M33f&

setTranslation(V2f t) → M33f&

translation() const -> V2f

translate(V2f t) → M33f&

setShear(float h) → M33f&

setShear(V2f h) → M33f&

shear(float xy) → M33f&

shear(V2f h) → M33f&

extractScaling([boolean exc=true]) const -> V2f, boolean

sansScaling([boolean exc=true]) const -> M33f

removeScaling([boolean exc=true]) → boolean

extractScalingAndShear([boolean exc=true]) const -> V2f, float, boolean

sansScalingAndShear([boolean exc=true]) const -> M33f

removeScalingAndShear([boolean exc=true]) → boolean

extractAndRemoveScalingAndShear([boolean exc=true]) const -> V2f, float, boolean

extractEuler() const -> float

extractSHRT([boolean exc=true]) const -> V2f, float, float, V2f, boolean

toTable() const -> table[9]

static dimensions() → int

static baseTypeLowest() → float

static baseTypeMax() → float

static baseTypeSmallest() → float

static baseTypeEpsilon() → float

static checkForZeroScaleInRow(float scl, V2f row[, boolean exc=true]) → boolean

static outerProduct(V3f a, V3f b) → M33f

static extractEuler(M33f matrix, float outRot)

Imath.M33d

class Imath.M33d

M33d() → M33d

M33d(M33d m) → M33d

M33d(M33f m) → M33d

M33d(double a) → M33d

M33d(double a, double b, double c, double d, double e, double f, double g, double h, double i) → M33d

M33d(table[9] t) → M33d

operator==(M33d m) const -> boolean

operator!=(M33d m) const -> boolean

operator+(M33d m) const -> M33d

operator-(M33d m) const -> M33d

operator-() const -> M33d

operator*(M33d m) const -> M33d

operator*(double s) const -> M33d

operator/(double s) const -> M33d

operator[](int idx) const -> double

operator[](int idx, double value)

makeIdentity()

equalWithAbsError(M33d m, double e) const -> boolean

equalWithRelError(M33d m, double e) const -> boolean

negate() → M33d&

multVecMatrix(V2d v) const -> V2d

multDirMatrix(V2d v) const -> V2d

transpose() → M33d&

transposed() const -> M33d

invert() → M33d&

invert(boolean singExc) → M33d&

inverse() const -> M33d

inverse(boolean singExc) const -> M33d

gjInvert() → M33d&

gjInvert(boolean singExc) → M33d&

gjInverse() const -> M33d

gjInverse(boolean singExc) const -> M33d

minorOf(int r, int c) const -> double

fastMinor(int r0, int r1, int c0, int c1) const -> double

determinant() const -> double

setRotation(double r) → M33d&

rotate(double r) → M33d&

setScale(double s) → M33d&

setScale(V2d s) → M33d&

scale(V2d s) → M33d&

setTranslation(V2d t) → M33d&

translation() const -> V2d

translate(V2d t) → M33d&

setShear(double h) → M33d&

setShear(V2d h) → M33d&

shear(double xy) → M33d&

shear(V2d h) → M33d&

extractScaling([boolean exc=true]) const -> V2d, boolean

sansScaling([boolean exc=true]) const -> M33d

removeScaling([boolean exc=true]) → boolean

extractScalingAndShear([boolean exc=true]) const -> V2d, double, boolean

sansScalingAndShear([boolean exc=true]) const -> M33d

removeScalingAndShear([boolean exc=true]) → boolean

extractAndRemoveScalingAndShear([boolean exc=true]) const -> V2d, double, boolean

extractEuler() const -> double

extractSHRT([boolean exc=true]) const -> V2d, double, double, V2d, boolean

toTable() const -> table[9]

static dimensions() → int

static baseTypeLowest() → double

static baseTypeMax() → double

static baseTypeSmallest() → double

static baseTypeEpsilon() → double

static checkForZeroScaleInRow(double scl, V2f row[, boolean exc=true]) → boolean

static outerProduct(V3d a, V3d b) → M33d

static extractEuler(M33d matrix, double outRot)

Imath.M44f

class Imath.M44f

M44f() → M44f

M44f(M44f m) → M44f

M44f(M44d m) → M44f

M44f(M33f r, V3f t) → M44f

M44f(float a) → M44f

M44f(float a, float b, float c, float d, float e, float f, float g, float h, float i, float j, float k, float l, float m, float n, float o, float p) → M44f

M44f(table[16] t) → M44f

operator==(M44f m) const -> boolean

operator!=(M44f m) const -> boolean

operator+(M44f m) const -> M44f

operator-(M44f m) const -> M44f

operator-() const -> M44f

operator*(M44f m) const -> M44f

operator*(float s) const -> M44f

operator/(float s) const -> M44f

operator[](int idx) const -> float

operator[](int idx, float value)

makeIdentity()

equalWithAbsError(M44f m, float e) const -> boolean

equalWithRelError(M44f m, float e) const -> boolean

negate() → M44f&

multVecMatrix(V3f v) const -> V3f

multDirMatrix(V3f v) const -> V3f

transpose() → M44f&

transposed() const -> M44f

invert() → M44f&

invert(boolean singExc) → M44f&

inverse() const -> M44f

inverse(boolean singExc) const -> M44f

gjInvert() → M44f&

gjInvert(boolean singExc) → M44f&

gjInverse() const -> M44f

gjInverse(boolean singExc) const -> M44f

minorOf(int r, int c) const -> float

fastMinor(int r0, int r1, int r2 int c0, int c1, int c2) const -> float

determinant() const -> float

setEulerAngles(V3f r) → M44f&

setAxisAngle(V3f ax, float angle) → M44f&

rotate(V3f r) → M44f&

setScale(float s) → M44f&

setScale(V3f s) → M44f&

scale(V3f s) → M44f&

setTranslation(V3f t) → M44f&

translation() const -> V3f

translate(V3f t) → M44f&

setShear(V3f h) → M44f&

shear(V3f h) → M44f&

extractScaling([boolean exc=true]) const -> V3f, boolean

sansScaling([boolean exc=true]) const -> M44f

removeScaling([boolean exc=true]) → boolean

extractScalingAndShear([boolean exc=true]) const -> V3f, V3f, boolean

sansScalingAndShear([boolean exc=true]) const -> M44f

removeScalingAndShear([boolean exc=true]) → boolean

extractAndRemoveScalingAndShear([boolean exc=true]) const -> V3f, V3f, boolean

extractEulerXYZ() const -> V3f

extractEulerZYX() const -> V3f

extractQuat() const -> Quatf

extractSHRT(boolean exc, Eulerf.Order rOrder) const -> V3f, V3f, V3f, V3f, boolean

extractSHRT([boolean exc=true]) const -> V3f, V3f, V3f, V3f, boolean

extractSHRT(Eulerf e[, boolean exc=true]) const -> V3f, V3f, Eulerf, V3f, boolean

toTable() const -> table[16]

static multiply(M44f a, M44f b) → M44f

static multiply(M44f a, M44f b, M44f outMat)

static dimensions() → int

static baseTypeLowest() → float

static baseTypeMax() → float

static baseTypeSmallest() → float

static baseTypeEpsilon() → float

static checkForZeroScaleInRow(float scl, V3f row[, boolean exc=true]) → boolean

static outerProduct(V4f a, V4f b) → M44f

static rotationMatrix(V3f fromDirection, V3f toDirection) → M44f

static rotationMatrixWithUpDir(V3f fromDir, V3f toDir, V3f upDir) → M44f

static alignZAxisWithTargetDir(M44f& result, V3f targetDir, V3f upDir)

static alignZAxisWithTargetDir(V3f targetDir, V3f upDir) → M44f

static computeLocalFrame(V3f p, V3f xDir, V3f normal) → M44f

static addOffset(M44f inMat, V3f tOffset, V3f rOffset, V3f sOffset, M44f ref) → M44f

static computeRSMatrix(boolean keepRotateA, boolean keepScaleA, M44f A, M44f B) → M44f

Imath.M44d

class Imath.M44d

M44d() → M44d

M44d(M44d m) → M44d

M44d(M44f m) → M44d

M44d(M33d r, V3d t) → M44d

M44d(double a) → M44d

M44d(double a, double b, double c, double d, double e,

double f, double g, double h, double i, double j,

double k, double l, double m, double n, double o,

double p) -> M44d

M44d(table[16] t) → M44d

operator==(M44d m) const -> boolean

operator!=(M44d m) const -> boolean

operator+(M44d m) const -> M44d

operator-(M44d m) const -> M44d

operator-() const -> M44d

operator*(M44d m) const -> M44d

operator*(double s) const -> M44d

operator/(double s) const -> M44d

operator[](int idx) const -> double

operator[](int idx, double value)

makeIdentity()

equalWithAbsError(M44d m, double e) const -> boolean

equalWithRelError(M44d m, double e) const -> boolean

negate() → M44d&

multVecMatrix(V3d v) const -> V3d

multDirMatrix(V3d v) const -> V3d

transpose() → M44d&

transposed() const -> M44d

invert() → M44d&

invert(boolean singExc) → M44d&

inverse() const -> M44d

inverse(boolean singExc) const -> M44d

gjInvert() → M44d&

gjInvert(boolean singExc) → M44d&

gjInverse() const -> M44d

gjInverse(boolean singExc) const -> M44d

minorOf(int r, int c) const -> double

fastMinor(int r0, int r1, int r2 int c0, int c1, int c2) const -> double

determinant() const -> double

setEulerAngles(V3d r) → M44d&

setAxisAngle(V3d ax, double angle) → M44d&

rotate(V3d r) → M44d&

setScale(double s) → M44d&

setScale(V3d s) → M44d&

scale(V3d s) → M44d&

setTranslation(V3d t) → M44d&

translation() const -> V3d

translate(V3d t) → M44d&

setShear(V3d h) → M44d&

shear(V3d h) → M44d&

extractScaling([boolean exc=true]) const -> V3d, boolean

sansScaling([boolean exc=true]) const -> M44d

removeScaling([boolean exc=true]) → boolean

extractScalingAndShear([boolean exc=true]) const -> V3d, V3d, boolean

sansScalingAndShear([boolean exc=true]) const -> M44d

removeScalingAndShear([boolean exc=true]) → boolean

extractAndRemoveScalingAndShear([boolean exc=true]) const -> V3d, V3d, boolean

extractEulerXYZ() const -> V3d

extractEulerZYX() const -> V3d

extractQuat() const -> Quatd

extractSHRT(boolean exc, Eulerd.Order rOrder) const -> V3d, V3d, V3d, V3d, boolean

extractSHRT([boolean exc=true]) const -> V3d, V3d, V3d, V3d, boolean

extractSHRT(Eulerd e[, boolean exc=true]) const -> V3d, V3d, Eulerd, V3d, boolean

toTable() const -> table[16]

static multiply(M44d a, M44d b) → M44d

static multiply(M44d a, M44d b, M44d outMat)

static dimensions() → int

static baseTypeLowest() → double

static baseTypeMax() → double

static baseTypeSmallest() → double

static baseTypeEpsilon() → double

static checkForZeroScaleInRow(double scl, V3d row[, boolean exc=true]) → boolean

static outerProduct(V4d a, V4d b) → M44d

static rotationMatrix(V3d fromDirection, V3d toDirection) → M44d

static rotationMatrixWithUpDir(V3d fromDir, V3d toDir, V3d upDir) → M44d

static alignZAxisWithTargetDir(M44d& result, V3d targetDir, V3d upDir)

static alignZAxisWithTargetDir(V3d targetDir, V3d upDir) → M44d

static computeLocalFrame(V3d p, V3d xDir, V3d normal) → M44d

static addOffset(M44d inMat, V3d tOffset, V3d rOffset, V3d sOffset, M44d ref) → M44d

static computeRSMatrix(boolean keepRotateA, boolean keepScaleA, M44d A, M44d B) → M44d