Matrix¶

Imath.M33f¶

class Imath.M33f¶

M33f() → M33f¶

M33f(M33f 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 baseTypeMin() → 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¶

Imath.M33d¶

class Imath.M33d¶

M33d() → M33d¶

M33d(M33d 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 baseTypeMin() → 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¶

Imath.M44f¶

class Imath.M44f¶

M44f() → M44f¶

M44f(M44f 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 dimensions() → int¶

static baseTypeMin() → 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(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 dimensions() → int¶

static baseTypeMin() → 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¶