Imath (Python)

Imath.clamp((float)arg1, (float)arg2, (float)arg3) → float

Other signatures:

clamp( (float)arg1, (float)arg2, (float)arg3) -> float
Imath.cmpt((float)arg1, (float)arg2, (float)arg3) → int
Imath.abs((float)arg1) → float
class Imath.Box2s

Bases: Boost.Python.instance

class Box2sIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
Box2s.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (V2s)arg2) -> None
__init__( (object)arg1, (V2s)arg2, (V2s)arg3) -> None
__init__( (object)arg1, (object)arg2) -> object
Box2s.center((Box2s)arg1) → V2s
Box2s.extendBy((Box2s)arg1, (V2s)arg2) → None

Other signatures:

extendBy( (Box2s)arg1, (Box2s)arg2) -> None
Box2s.hasVolume((Box2s)arg1) → bool
Box2s.intersects((Box2s)arg1, (V2s)arg2) → bool

Other signatures:

intersects( (Box2s)arg1, (Box2s)arg2) -> bool
Box2s.isEmpty((Box2s)arg1) → bool
Box2s.majorAxis((Box2s)arg1) → int
Box2s.makeEmpty((Box2s)arg1) → None
Box2s.max
Box2s.min
Box2s.size((Box2s)arg1) → V2s
class Imath.Frustumf

Bases: Boost.Python.instance

DepthToZ((Frustumf)arg1, (float)arg2, (int)arg3, (int)arg4) → int
ZToDepth((Frustumf)arg1, (int)arg2, (int)arg3, (int)arg4) → float
__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (Frustumf)arg2) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6 [, (float)arg7 [, (bool)arg8]]) -> None
aspect((Frustumf)arg1) → float
bottom((Frustumf)arg1) → float
farPlane((Frustumf)arg1) → float
fovx((Frustumf)arg1) → float
fovy((Frustumf)arg1) → float
left((Frustumf)arg1) → float
modifyNearAndFar((Frustumf)arg1, (float)arg2, (float)arg3) → None
nearPlane((Frustumf)arg1) → float
normalizedZToDepth((Frustumf)arg1, (float)arg2) → float
orthographic((Frustumf)arg1) → bool
projectPointToScreen((Frustumf)arg1, (V3f)arg2) → V2f
projectScreenToRay((Frustumf)arg1, (V2f)arg2) → object
projectionMatrix((Frustumf)arg1) → M44f
right((Frustumf)arg1) → float
screenRadius((Frustumf)arg1, (V3f)arg2, (float)arg3) → float
set((Frustumf)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6, (float)arg7[, (bool)arg8]) → None
setOrthographic((Frustumf)arg1, (bool)arg2) → None
top((Frustumf)arg1) → float
window((Frustumf)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) → Frustumf
worldRadius((Frustumf)arg1, (V3f)arg2, (float)arg3) → float
class Imath.Frustumd

Bases: Boost.Python.instance

DepthToZ((Frustumd)arg1, (float)arg2, (int)arg3, (int)arg4) → int
ZToDepth((Frustumd)arg1, (int)arg2, (int)arg3, (int)arg4) → float
__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (Frustumd)arg2) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6 [, (float)arg7 [, (bool)arg8]]) -> None
aspect((Frustumd)arg1) → float
bottom((Frustumd)arg1) → float
farPlane((Frustumd)arg1) → float
fovx((Frustumd)arg1) → float
fovy((Frustumd)arg1) → float
left((Frustumd)arg1) → float
modifyNearAndFar((Frustumd)arg1, (float)arg2, (float)arg3) → None
nearPlane((Frustumd)arg1) → float
normalizedZToDepth((Frustumd)arg1, (float)arg2) → float
orthographic((Frustumd)arg1) → bool
projectPointToScreen((Frustumd)arg1, (V3d)arg2) → V2d
projectScreenToRay((Frustumd)arg1, (V2d)arg2) → object
projectionMatrix((Frustumd)arg1) → M44d
right((Frustumd)arg1) → float
screenRadius((Frustumd)arg1, (V3d)arg2, (float)arg3) → float
set((Frustumd)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6, (float)arg7[, (bool)arg8]) → None
setOrthographic((Frustumd)arg1, (bool)arg2) → None
top((Frustumd)arg1) → float
window((Frustumd)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) → Frustumd
worldRadius((Frustumd)arg1, (V3d)arg2, (float)arg3) → float
class Imath.M33d

Bases: Boost.Python.instance

class M33dIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
M33d.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6, (float)arg7, (float)arg8, (float)arg9, (float)arg10) -> None
__init__( (object)arg1, (object)arg2, (object)arg3, (object)arg4) -> object
__init__( (object)arg1, (object)arg2) -> object
static M33d.baseTypeEpsilon() → float
static M33d.baseTypeMax() → float
static M33d.baseTypeMin() → float
static M33d.baseTypeSmallest() → float
M33d.equalWithAbsError((M33d)arg1, (M33d)arg2, (float)arg3) → bool
M33d.equalWithRelError((M33d)arg1, (M33d)arg2, (float)arg3) → bool
M33d.extractAndRemoveScalingAndShear((M33d)arg1, (V2d)arg2, (float)arg3) → bool
M33d.extractEuler((M33d)arg1, (float)arg2) → None

Assumes that the matrix does not include shear or non-uniform scaling, but does not examine the matrix to verify this assumption. Matrices with shear or non-uniform scaling are likely to produce meaningless results. Therefore, you should use the removeScalingAndShear() routine, if necessary, prior to calling extractEuler.

M33d.extractSHRT((M33d)arg1, (V2d)arg2, (float)arg3, (float)arg4, (V2d)arg5) → bool

Returns a tuple containing scale, shear, rotate, translate.

Other signatures:

extractSHRT( (M33d)self) -> tuple
M33d.extractScaling((M33d)arg1, (V2d)arg2) → bool
M33d.extractScalingAndShear((M33d)arg1, (V2d)arg2, (float)arg3) → bool
M33d.gjInverse((M33d)arg1) → M33d

Other signatures:

gjInverse( (M33d)arg1, (bool)arg2) -> M33d
M33d.gjInvert((M33d)arg1) → M33d

Other signatures:

gjInvert( (M33d)arg1, (bool)arg2) -> M33d
M33d.identity = M33d(1, 0, 0, 0, 1, 0, 0, 0, 1)
M33d.inverse((M33d)arg1) → M33d

Other signatures:

inverse( (M33d)arg1, (bool)arg2) -> M33d
M33d.invert((M33d)arg1) → M33d

Other signatures:

invert( (M33d)arg1, (bool)arg2) -> M33d
M33d.makeIdentity((M33d)arg1) → None
M33d.multDirMatrix((M33d)arg1, (V2d)arg2, (V2d)arg3) → None

Vector-times-matrix multiplication; see also the * operators

M33d.multVecMatrix((M33d)arg1, (V2d)arg2, (V2d)arg3) → None

Vector-times-matrix multiplication; see also the * operators

M33d.negate((M33d)arg1) → M33d
M33d.removeScaling((M33d)arg1) → bool
M33d.removeScalingAndShear((M33d)arg1) → bool
M33d.rotate((M33d)arg1, (float)arg2) → M33d

Rotate the given matrix by r

M33d.sansScaling((M33d)arg1) → M33d
M33d.sansScalingAndShear((M33d)arg1) → M33d
M33d.scale((M33d)arg1, (V2d)arg2) → M33d

Set matrix to scale by given vector

M33d.setRotation((M33d)arg1, (float)arg2) → M33d

Set matrix to rotation by r (in radians)

M33d.setScale((M33d)arg1, (float)arg2) → M33d

Set matrix to scale by given uniform factor Set matrix to scale by given uniform factor

Other signatures:

setScale( (M33d)arg1, (V2d)arg2) -> M33d
M33d.setShear((M33d)arg1, (float)arg2) → M33d

Set matrix to shear x for each y coord. by given factor xy Set matrix to shear x for each y coord. by given factor h[0] and to shear y for each x coord. by given factor h[1]

Other signatures:

setShear( (M33d)arg1, (V2d)arg2) -> M33d
M33d.setTranslation((M33d)arg1, (V2d)arg2) → M33d

Set matrix to translation by given vector

M33d.shear((M33d)arg1, (float)arg2) → M33d

Shear the matrix in x for each y coord. by given factor xy Shear the matrix in x for each y coord. by given factor xy and shear y for each x coord. by given factor yx

Other signatures:

shear( (M33d)arg1, (V2d)arg2) -> M33d
M33d.toMatrix44((M33d)arg1) → M44d
M33d.translate((M33d)arg1, (V2d)arg2) → M33d

Translate the matrix by t

M33d.translation((M33d)arg1) → V2d

Return translation component

M33d.transpose((M33d)arg1) → M33d
M33d.transposed((M33d)arg1) → M33d
class Imath.M33f

Bases: Boost.Python.instance

class M33fIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
M33f.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5, (float)arg6, (float)arg7, (float)arg8, (float)arg9, (float)arg10) -> None
__init__( (object)arg1, (object)arg2, (object)arg3, (object)arg4) -> object
__init__( (object)arg1, (object)arg2) -> object
static M33f.baseTypeEpsilon() → float
static M33f.baseTypeMax() → float
static M33f.baseTypeMin() → float
static M33f.baseTypeSmallest() → float
M33f.equalWithAbsError((M33f)arg1, (M33f)arg2, (float)arg3) → bool
M33f.equalWithRelError((M33f)arg1, (M33f)arg2, (float)arg3) → bool
M33f.extractAndRemoveScalingAndShear((M33f)arg1, (V2f)arg2, (float)arg3) → bool
M33f.extractEuler((M33f)arg1, (float)arg2) → None

Assumes that the matrix does not include shear or non-uniform scaling, but does not examine the matrix to verify this assumption. Matrices with shear or non-uniform scaling are likely to produce meaningless results. Therefore, you should use the removeScalingAndShear() routine, if necessary, prior to calling extractEuler.

M33f.extractSHRT((M33f)arg1, (V2f)arg2, (float)arg3, (float)arg4, (V2f)arg5) → bool

Returns a tuple containing scale, shear, rotate, translate.

Other signatures:

extractSHRT( (M33f)self) -> tuple
M33f.extractScaling((M33f)arg1, (V2f)arg2) → bool
M33f.extractScalingAndShear((M33f)arg1, (V2f)arg2, (float)arg3) → bool
M33f.gjInverse((M33f)arg1) → M33f

Other signatures:

gjInverse( (M33f)arg1, (bool)arg2) -> M33f
M33f.gjInvert((M33f)arg1) → M33f

Other signatures:

gjInvert( (M33f)arg1, (bool)arg2) -> M33f
M33f.identity = M33f(1, 0, 0, 0, 1, 0, 0, 0, 1)
M33f.inverse((M33f)arg1) → M33f

Other signatures:

inverse( (M33f)arg1, (bool)arg2) -> M33f
M33f.invert((M33f)arg1) → M33f

Other signatures:

invert( (M33f)arg1, (bool)arg2) -> M33f
M33f.makeIdentity((M33f)arg1) → None
M33f.multDirMatrix((M33f)arg1, (V2f)arg2, (V2f)arg3) → None

Vector-times-matrix multiplication; see also the * operators

M33f.multVecMatrix((M33f)arg1, (V2f)arg2, (V2f)arg3) → None

Vector-times-matrix multiplication; see also the * operators

M33f.negate((M33f)arg1) → M33f
M33f.removeScaling((M33f)arg1) → bool
M33f.removeScalingAndShear((M33f)arg1) → bool
M33f.rotate((M33f)arg1, (float)arg2) → M33f

Rotate the given matrix by r

M33f.sansScaling((M33f)arg1) → M33f
M33f.sansScalingAndShear((M33f)arg1) → M33f
M33f.scale((M33f)arg1, (V2f)arg2) → M33f

Set matrix to scale by given vector

M33f.setRotation((M33f)arg1, (float)arg2) → M33f

Set matrix to rotation by r (in radians)

M33f.setScale((M33f)arg1, (float)arg2) → M33f

Set matrix to scale by given uniform factor Set matrix to scale by given uniform factor

Other signatures:

setScale( (M33f)arg1, (V2f)arg2) -> M33f
M33f.setShear((M33f)arg1, (float)arg2) → M33f

Set matrix to shear x for each y coord. by given factor xy Set matrix to shear x for each y coord. by given factor h[0] and to shear y for each x coord. by given factor h[1]

Other signatures:

setShear( (M33f)arg1, (V2f)arg2) -> M33f
M33f.setTranslation((M33f)arg1, (V2f)arg2) → M33f

Set matrix to translation by given vector

M33f.shear((M33f)arg1, (float)arg2) → M33f

Shear the matrix in x for each y coord. by given factor xy Shear the matrix in x for each y coord. by given factor xy and shear y for each x coord. by given factor yx

Other signatures:

shear( (M33f)arg1, (V2f)arg2) -> M33f
M33f.toMatrix44((M33f)arg1) → M44f
M33f.translate((M33f)arg1, (V2f)arg2) → M33f

Translate the matrix by t

M33f.translation((M33f)arg1) → V2f

Return translation component

M33f.transpose((M33f)arg1) → M33f
M33f.transposed((M33f)arg1) → M33f
class Imath.Box2d

Bases: Boost.Python.instance

class Box2dIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
Box2d.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (V2d)arg2) -> None
__init__( (object)arg1, (V2d)arg2, (V2d)arg3) -> None
__init__( (object)arg1, (object)arg2) -> object
Box2d.center((Box2d)arg1) → V2d
Box2d.extendBy((Box2d)arg1, (V2d)arg2) → None

Other signatures:

extendBy( (Box2d)arg1, (Box2d)arg2) -> None
Box2d.hasVolume((Box2d)arg1) → bool
Box2d.intersects((Box2d)arg1, (V2d)arg2) → bool

Other signatures:

intersects( (Box2d)arg1, (Box2d)arg2) -> bool
Box2d.isEmpty((Box2d)arg1) → bool
Box2d.majorAxis((Box2d)arg1) → int
Box2d.makeEmpty((Box2d)arg1) → None
Box2d.max
Box2d.min
Box2d.size((Box2d)arg1) → V2d
Imath.iszero((float)arg1, (float)arg2) → bool
class Imath.Box2f

Bases: Boost.Python.instance

class Box2fIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
Box2f.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (V2f)arg2) -> None
__init__( (object)arg1, (V2f)arg2, (V2f)arg3) -> None
__init__( (object)arg1, (object)arg2) -> object
Box2f.center((Box2f)arg1) → V2f
Box2f.extendBy((Box2f)arg1, (V2f)arg2) → None

Other signatures:

extendBy( (Box2f)arg1, (Box2f)arg2) -> None
Box2f.hasVolume((Box2f)arg1) → bool
Box2f.intersects((Box2f)arg1, (V2f)arg2) → bool

Other signatures:

intersects( (Box2f)arg1, (Box2f)arg2) -> bool
Box2f.isEmpty((Box2f)arg1) → bool
Box2f.majorAxis((Box2f)arg1) → int
Box2f.makeEmpty((Box2f)arg1) → None
Box2f.max
Box2f.min
Box2f.size((Box2f)arg1) → V2f
Imath.finited((float)arg1) → bool

Return true if the number is not a NaN or Infinity.

Imath.finitef((float)arg1) → bool

Return true if the number is not a NaN or Infinity.

class Imath.C4c

Bases: Boost.Python.instance

class C4cIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
C4c.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> object
__init__( (object)arg1, (object)arg2) -> object
__init__( (object)arg1, (int)arg2, (int)arg3, (int)arg4, (int)arg5) -> None
C4c.a
C4c.b
static C4c.baseTypeEpsilon() → int
static C4c.baseTypeMax() → int
static C4c.baseTypeMin() → int
static C4c.baseTypeSmallest() → int
static C4c.dimensions() → int
C4c.g
static C4c.hsv2rgb((C4c)arg1) → C4c
C4c.negate((C4c)arg1) → C4c
static C4c.packed2rgb((int)arg1, (C4c)arg2) → None
C4c.r
static C4c.rgb2hsv((C4c)arg1) → C4c
static C4c.rgb2packed((C4c)arg1) → int
class Imath.C4h

Bases: Boost.Python.instance

class C4hIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
C4h.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> object
__init__( (object)arg1, (object)arg2) -> object
__init__( (object)arg1, (half)arg2, (half)arg3, (half)arg4, (half)arg5) -> None
C4h.a
C4h.b
static C4h.baseTypeEpsilon() → half
static C4h.baseTypeMax() → half
static C4h.baseTypeMin() → half
static C4h.baseTypeSmallest() → half
static C4h.dimensions() → int
C4h.g
static C4h.hsv2rgb((C4h)arg1) → C4h
C4h.negate((C4h)arg1) → C4h
static C4h.packed2rgb((int)arg1, (C4h)arg2) → None
C4h.r
static C4h.rgb2hsv((C4h)arg1) → C4h
static C4h.rgb2packed((C4h)arg1) → int
class Imath.Box2i

Bases: Boost.Python.instance

class Box2iIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
Box2i.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (V2i)arg2) -> None
__init__( (object)arg1, (V2i)arg2, (V2i)arg3) -> None
__init__( (object)arg1, (object)arg2) -> object
Box2i.center((Box2i)arg1) → V2i
Box2i.extendBy((Box2i)arg1, (V2i)arg2) → None

Other signatures:

extendBy( (Box2i)arg1, (Box2i)arg2) -> None
Box2i.hasVolume((Box2i)arg1) → bool
Box2i.intersects((Box2i)arg1, (V2i)arg2) → bool

Other signatures:

intersects( (Box2i)arg1, (Box2i)arg2) -> bool
Box2i.isEmpty((Box2i)arg1) → bool
Box2i.majorAxis((Box2i)arg1) → int
Box2i.makeEmpty((Box2i)arg1) → None
Box2i.max
Box2i.min
Box2i.size((Box2i)arg1) → V2i
class Imath.C3h

Bases: PyImath.V3h

class C3hIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
C3h.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> object
__init__( (object)arg1, (object)arg2) -> object
__init__( (object)arg1, (half)arg2, (half)arg3, (half)arg4) -> None
C3h.b
C3h.g
static C3h.hsv2rgb((V3h)arg1) → V3h
C3h.negate((C3h)arg1) → C3h
static C3h.packed2rgb((int)arg1, (V3h)arg2) → None
C3h.r
static C3h.rgb2hsv((V3h)arg1) → V3h
static C3h.rgb2packed((V3h)arg1) → int
class Imath.V3s

Bases: Boost.Python.instance

class V3sIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
V3s.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1, (int)arg2, (int)arg3, (int)arg4) -> None
__init__( (object)arg1, (int)arg2) -> None
__init__( (object)arg1 [, (object)arg2]) -> object
static V3s.baseTypeEpsilon() → int
static V3s.baseTypeMax() → int
static V3s.baseTypeMin() → int
static V3s.baseTypeSmallest() → int
V3s.closestVertex((V3s)v0, (V3s)v1, (V3s)v2, (V3s)p) → V3s

Find the vertex of triangle (v0, v1, v2), which is closest to point p

V3s.cross((V3s)arg1, (V3s)arg2) → V3s
static V3s.dimensions() → int
V3s.dot((V3s)arg1, (V3s)arg2) → int
V3s.equalWithAbsError((V3s)arg1, (V3s)arg2, (int)arg3) → bool
V3s.equalWithRelError((V3s)arg1, (V3s)arg2, (int)arg3) → bool
V3s.length((V3s)arg1) → int
V3s.length2((V3s)arg1) → int
V3s.negate((V3s)arg1) → V3s
V3s.normalize((V3s)arg1) → V3s
V3s.normalizeExc((V3s)arg1) → V3s
V3s.normalizeNonNull((V3s)arg1) → V3s
V3s.normalized((V3s)arg1) → V3s
V3s.normalizedExc((V3s)arg1) → V3s
V3s.normalizedNonNull((V3s)arg1) → V3s
V3s.orthogonal((V3s)self, (V3s)t) → V3s

Find a vector which is perpendicular to self and in the same plane as self and t

static V3s.project((V3s)s, (V3s)t) → V3s

Find the projection of vector t onto vector s

V3s.projection((V3s)arg1, (V3s)arg2) → V3s

Find the projection of self onto vector

V3s.reflect((V3s)self, (V3s)t) → V3s

Find the direction of self after reflection off a plane with normal t

V3s.x
V3s.y
V3s.z
class Imath.Quatf

Bases: Boost.Python.instance

class QuatfIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
Quatf.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) -> None
__init__( (object)arg1, (float)arg2, (V3f)arg3) -> None
__init__( (object)arg1, (object)arg2) -> object
Quatf.angle
Quatf.axis
Quatf.exp((Quatf)arg1) → Quatf
Quatf.identity = Quatf(1, 0, 0, 0)
Quatf.intermediate((Quatf)q0, (Quatf)q1, (Quatf)q2) → Quatf

From advanced Animation and Rendering Techniques by Watt and Watt, Page 366: computing the inner quadrangle points (qa and qb) to guarantee tangent continuity.

Quatf.inverse((Quatf)arg1) → Quatf
Quatf.invert((Quatf)arg1) → Quatf

self -> 1 / self

Quatf.length((Quatf)arg1) → float
Quatf.log((Quatf)arg1) → Quatf
Quatf.normalize((Quatf)arg1) → Quatf
Quatf.normalized((Quatf)arg1) → Quatf
Quatf.r
Quatf.setAxisAngle((Quatf)self, (V3f)axis, (float)radians) → Quatf
Quatf.setRotation((Quatf)arg1, (V3f)fromDirection, (V3f)toDirection) → Quatf
Quatf.slerp((Quatf)self, (Quatf)q2, (float)t) → Quatf

Spherical linear interpolation. NOTE: Assumes q1 and q2 are normalized and that 0 <= t <= 1. This method does not interpolate along the shortest arc between q1 and q2. If you desire interpolation along the shortest arc, then consider flipping the second quaternion explicitly before calling slerp. The implementation of squad() depends on a slerp() that interpolates as is, without the automatic flipping.

Quatf.spline((Quatf)q0, (Quatf)q1, (Quatf)q2, (Quatf)q3, (float)t) → Quatf

Spherical Cubic Spline Interpolation - from Advanced Animation and Rendering Techniques by Watt and Watt, Page 366: A spherical curve is constructed using three spherical linear interpolations of a quadrangle of unit quaternions: q1, qa, qb, q2. Given a set of quaternion keys: q0, q1, q2, q3, this routine does the interpolation between q1 and q2 by constructing two intermediate quaternions: qa and qb. The qa and qb are computed by the intermediate function to guarantee the continuity of tangents across adjacent cubic segments. The qa represents in-tangent for q1 and the qb represents the out-tangent for q2. The q1 q2 is the cubic segment being interpolated. The q0 is from the previous adjacent segment and q3 is from the next adjacent segment. The q0 and q3 are used in computing qa and qb.

Quatf.squad((Quatf)q1, (Quatf)qa, (Quatf)qb, (Quatf)q2, (float)t) → Quatf

Spherical Quadrangle Interpolation - from Advanced Animation and Rendering Techniques by Watt and Watt, Page 366: It constructs a spherical cubic interpolation as a series of three spherical linear interpolations of a quadrangle of unit quaternions.

Quatf.toMatrix33((Quatf)arg1) → M33f
Quatf.toMatrix44((Quatf)arg1) → M44f
Quatf.v
class Imath.Quatd

Bases: Boost.Python.instance

class QuatdIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
Quatd.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) -> None
__init__( (object)arg1, (float)arg2, (V3d)arg3) -> None
__init__( (object)arg1, (object)arg2) -> object
Quatd.angle
Quatd.axis
Quatd.exp((Quatd)arg1) → Quatd
Quatd.identity = Quatd(1, 0, 0, 0)
Quatd.intermediate((Quatd)q0, (Quatd)q1, (Quatd)q2) → Quatd

From advanced Animation and Rendering Techniques by Watt and Watt, Page 366: computing the inner quadrangle points (qa and qb) to guarantee tangent continuity.

Quatd.inverse((Quatd)arg1) → Quatd
Quatd.invert((Quatd)arg1) → Quatd

self -> 1 / self

Quatd.length((Quatd)arg1) → float
Quatd.log((Quatd)arg1) → Quatd
Quatd.normalize((Quatd)arg1) → Quatd
Quatd.normalized((Quatd)arg1) → Quatd
Quatd.r
Quatd.setAxisAngle((Quatd)self, (V3d)axis, (float)radians) → Quatd
Quatd.setRotation((Quatd)arg1, (V3d)fromDirection, (V3d)toDirection) → Quatd
Quatd.slerp((Quatd)self, (Quatd)q2, (float)t) → Quatd

Spherical linear interpolation. NOTE: Assumes q1 and q2 are normalized and that 0 <= t <= 1. This method does not interpolate along the shortest arc between q1 and q2. If you desire interpolation along the shortest arc, then consider flipping the second quaternion explicitly before calling slerp. The implementation of squad() depends on a slerp() that interpolates as is, without the automatic flipping.

Quatd.spline((Quatd)q0, (Quatd)q1, (Quatd)q2, (Quatd)q3, (float)t) → Quatd

Spherical Cubic Spline Interpolation - from Advanced Animation and Rendering Techniques by Watt and Watt, Page 366: A spherical curve is constructed using three spherical linear interpolations of a quadrangle of unit quaternions: q1, qa, qb, q2. Given a set of quaternion keys: q0, q1, q2, q3, this routine does the interpolation between q1 and q2 by constructing two intermediate quaternions: qa and qb. The qa and qb are computed by the intermediate function to guarantee the continuity of tangents across adjacent cubic segments. The qa represents in-tangent for q1 and the qb represents the out-tangent for q2. The q1 q2 is the cubic segment being interpolated. The q0 is from the previous adjacent segment and q3 is from the next adjacent segment. The q0 and q3 are used in computing qa and qb.

Quatd.squad((Quatd)q1, (Quatd)qa, (Quatd)qb, (Quatd)q2, (float)t) → Quatd

Spherical Quadrangle Interpolation - from Advanced Animation and Rendering Techniques by Watt and Watt, Page 366: It constructs a spherical cubic interpolation as a series of three spherical linear interpolations of a quadrangle of unit quaternions.

Quatd.toMatrix33((Quatd)arg1) → M33d
Quatd.toMatrix44((Quatd)arg1) → M44d
Quatd.v
Imath.floor((float)arg1) → int
Imath.lerp((float)arg1, (float)arg2, (float)arg3) → float

Other signatures:

lerp( (V3f)arg1, (V3f)arg2, (float)arg3) -> V3f
lerp( (V2f)arg1, (V2f)arg2, (float)arg3) -> V2f
lerp( (V3d)arg1, (V3d)arg2, (float)arg3) -> V3d
lerp( (V2d)arg1, (V2d)arg2, (float)arg3) -> V2d
lerp( (V3i)arg1, (V3i)arg2, (int)arg3) -> V3i
lerp( (V2i)arg1, (V2i)arg2, (int)arg3) -> V2i
lerp( (V3s)arg1, (V3s)arg2, (int)arg3) -> V3s
lerp( (V2s)arg1, (V2s)arg2, (int)arg3) -> V2s
lerp( (C4f)arg1, (C4f)arg2, (float)arg3) -> C4f
lerp( (C3f)arg1, (C3f)arg2, (float)arg3) -> C3f
lerp( (C4h)arg1, (C4h)arg2, (half)arg3) -> C4h
lerp( (C3h)arg1, (C3h)arg2, (half)arg3) -> C3h
lerp( (C4c)arg1, (C4c)arg2, (str)arg3) -> C4c
lerp( (C3c)arg1, (C3c)arg2, (str)arg3) -> C3c
Imath.equal((float)a, (float)b, (float)error) → bool

Equality function with an error value

class Imath.V3d

Bases: Boost.Python.instance

class V3dIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
V3d.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4) -> None
__init__( (object)arg1, (float)arg2) -> None
__init__( (object)arg1 [, (object)arg2]) -> object
static V3d.baseTypeEpsilon() → float
static V3d.baseTypeMax() → float
static V3d.baseTypeMin() → float
static V3d.baseTypeSmallest() → float
V3d.closestVertex((V3d)v0, (V3d)v1, (V3d)v2, (V3d)p) → V3d

Find the vertex of triangle (v0, v1, v2), which is closest to point p

V3d.cross((V3d)arg1, (V3d)arg2) → V3d
static V3d.dimensions() → int
V3d.dot((V3d)arg1, (V3d)arg2) → float
V3d.equalWithAbsError((V3d)arg1, (V3d)arg2, (float)arg3) → bool
V3d.equalWithRelError((V3d)arg1, (V3d)arg2, (float)arg3) → bool
V3d.length((V3d)arg1) → float
V3d.length2((V3d)arg1) → float
V3d.negate((V3d)arg1) → V3d
V3d.normalize((V3d)arg1) → V3d
V3d.normalizeExc((V3d)arg1) → V3d
V3d.normalizeNonNull((V3d)arg1) → V3d
V3d.normalized((V3d)arg1) → V3d
V3d.normalizedExc((V3d)arg1) → V3d
V3d.normalizedNonNull((V3d)arg1) → V3d
V3d.orthogonal((V3d)self, (V3d)t) → V3d

Find a vector which is perpendicular to self and in the same plane as self and t

static V3d.project((V3d)s, (V3d)t) → V3d

Find the projection of vector t onto vector s

V3d.projection((V3d)arg1, (V3d)arg2) → V3d

Find the projection of self onto vector

V3d.reflect((V3d)self, (V3d)t) → V3d

Find the direction of self after reflection off a plane with normal t

V3d.x
V3d.y
V3d.z
class Imath.V3f

Bases: Boost.Python.instance

class V3fIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
V3f.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4) -> None
__init__( (object)arg1, (float)arg2) -> None
__init__( (object)arg1 [, (object)arg2]) -> object
static V3f.baseTypeEpsilon() → float
static V3f.baseTypeMax() → float
static V3f.baseTypeMin() → float
static V3f.baseTypeSmallest() → float
V3f.closestVertex((V3f)v0, (V3f)v1, (V3f)v2, (V3f)p) → V3f

Find the vertex of triangle (v0, v1, v2), which is closest to point p

V3f.cross((V3f)arg1, (V3f)arg2) → V3f
static V3f.dimensions() → int
V3f.dot((V3f)arg1, (V3f)arg2) → float
V3f.equalWithAbsError((V3f)arg1, (V3f)arg2, (float)arg3) → bool
V3f.equalWithRelError((V3f)arg1, (V3f)arg2, (float)arg3) → bool
V3f.length((V3f)arg1) → float
V3f.length2((V3f)arg1) → float
V3f.negate((V3f)arg1) → V3f
V3f.normalize((V3f)arg1) → V3f
V3f.normalizeExc((V3f)arg1) → V3f
V3f.normalizeNonNull((V3f)arg1) → V3f
V3f.normalized((V3f)arg1) → V3f
V3f.normalizedExc((V3f)arg1) → V3f
V3f.normalizedNonNull((V3f)arg1) → V3f
V3f.orthogonal((V3f)self, (V3f)t) → V3f

Find a vector which is perpendicular to self and in the same plane as self and t

static V3f.project((V3f)s, (V3f)t) → V3f

Find the projection of vector t onto vector s

V3f.projection((V3f)arg1, (V3f)arg2) → V3f

Find the projection of self onto vector

V3f.reflect((V3f)self, (V3f)t) → V3f

Find the direction of self after reflection off a plane with normal t

V3f.x
V3f.y
V3f.z
class Imath.V3i

Bases: Boost.Python.instance

class V3iIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
V3i.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1, (int)arg2, (int)arg3, (int)arg4) -> None
__init__( (object)arg1, (int)arg2) -> None
__init__( (object)arg1 [, (object)arg2]) -> object
static V3i.baseTypeEpsilon() → int
static V3i.baseTypeMax() → int
static V3i.baseTypeMin() → int
static V3i.baseTypeSmallest() → int
V3i.closestVertex((V3i)v0, (V3i)v1, (V3i)v2, (V3i)p) → V3i

Find the vertex of triangle (v0, v1, v2), which is closest to point p

V3i.cross((V3i)arg1, (V3i)arg2) → V3i
static V3i.dimensions() → int
V3i.dot((V3i)arg1, (V3i)arg2) → int
V3i.equalWithAbsError((V3i)arg1, (V3i)arg2, (int)arg3) → bool
V3i.equalWithRelError((V3i)arg1, (V3i)arg2, (int)arg3) → bool
V3i.length((V3i)arg1) → int
V3i.length2((V3i)arg1) → int
V3i.negate((V3i)arg1) → V3i
V3i.normalize((V3i)arg1) → V3i
V3i.normalizeExc((V3i)arg1) → V3i
V3i.normalizeNonNull((V3i)arg1) → V3i
V3i.normalized((V3i)arg1) → V3i
V3i.normalizedExc((V3i)arg1) → V3i
V3i.normalizedNonNull((V3i)arg1) → V3i
V3i.orthogonal((V3i)self, (V3i)t) → V3i

Find a vector which is perpendicular to self and in the same plane as self and t

static V3i.project((V3i)s, (V3i)t) → V3i

Find the projection of vector t onto vector s

V3i.projection((V3i)arg1, (V3i)arg2) → V3i

Find the projection of self onto vector

V3i.reflect((V3i)self, (V3i)t) → V3i

Find the direction of self after reflection off a plane with normal t

V3i.x
V3i.y
V3i.z
Imath.divp((int)arg1, (int)arg2) → int

Integer division where the remainder of x/y is always positive:

Other signatures:

divp(x,y) == floor (double(x) / double(y
Imath.lerpfactor((float)arg1, (float)arg2, (float)arg3) → float
Imath.modp((int)arg1, (int)arg2) → int

Integer remainder where the remainder of x/y is always positive:

Other signatures:

modp(x,y) == x - y * divp(x,
class Imath.Box3i

Bases: Boost.Python.instance

class Box3iIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
Box3i.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (V3i)arg2) -> None
__init__( (object)arg1, (V3i)arg2, (V3i)arg3) -> None
__init__( (object)arg1, (object)arg2) -> object
Box3i.center((Box3i)arg1) → V3i
Box3i.extendBy((Box3i)arg1, (V3i)arg2) → None

Other signatures:

extendBy( (Box3i)arg1, (Box3i)arg2) -> None
Box3i.hasVolume((Box3i)arg1) → bool
Box3i.intersects((Box3i)arg1, (V3i)arg2) → bool

Other signatures:

intersects( (Box3i)arg1, (Box3i)arg2) -> bool
Box3i.isEmpty((Box3i)arg1) → bool
Box3i.majorAxis((Box3i)arg1) → int
Box3i.makeEmpty((Box3i)arg1) → None
Box3i.max
Box3i.min
Box3i.size((Box3i)arg1) → V3i
Imath.predf((float)arg1) → float

Returns float(f-e), where e is the smallest positive number such that float(f-e) != f. Exceptions: If the input value is an infinity or a nan, succf(), predf(), succd(), and predd() all return the input value without changing it.

class Imath.M44f

Bases: Boost.Python.instance

class M44fIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
M44f.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (M33f)arg2, (V3f)arg3) -> None
__init__( (object)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5) -> object
__init__( (object)arg1, (object)arg2) -> object
static M44f.alignZAxisWithTargetDir((V3f)arg1, (V3f)arg2) → M44f

Returns a matrix that rotates the z-axis so that it points towards “targetDir”. You must also specify that you want the up vector to be pointing in a certain direction “upDir”. Notes: The following degenerate cases are handled: (a) when the directions given by “toDir” and “upDir” are parallel or opposite; (the direction vectors must have a non-zero cross product) (b) when any of the given direction vectors have zero length

static M44f.baseTypeEpsilon() → float
static M44f.baseTypeMax() → float
static M44f.baseTypeMin() → float
static M44f.baseTypeSmallest() → float
M44f.equalWithAbsError((M44f)arg1, (M44f)arg2, (float)arg3) → bool
M44f.equalWithRelError((M44f)arg1, (M44f)arg2, (float)arg3) → bool
M44f.extractAndRemoveScalingAndShear((M44f)arg1, (V3f)arg2, (V3f)arg3) → bool
M44f.extractEulerXYZ((M44f)arg1, (V3f)arg2) → None

This function assumes that the matrix does not include shear or non-uniform scaling, but it does not examine the matrix to verify this assumption. Matrices with shear or non-uniform scaling are likely to produce meaningless results. Therefore, you should use the removeScalingAndShear() routine, if necessary, prior to calling extractEulerXYZ()

M44f.extractEulerZYX((M44f)arg1, (V3f)arg2) → None

As extractEulerXYZ but with reversed rotation order.

M44f.extractQuat((M44f)arg1) → Quatf
M44f.extractSHRT((M44f)self, (V3f)scale, (V3f)shear, (V3f)rotate, (V3f)translate, (Order)order) → bool

Returns a tuple containing scale, shear, rotate, translate. Returns a tuple containing scale, shear, rotate, translate.

Other signatures:

extractSHRT( (M44f)self, (V3f)scale, (V3f)shear, (Eulerf)rotate, (V3f)translate) -> bool
extractSHRT( (M44f)self) -> tuple
extractSHRT( (M44f)self, (Order)order) -> tuple
extractSHRT( (M44f)arg1, (V3f)scale, (V3f)shear, (V3f)rotate, (V3f)translate) -> bool
extractSHRT( (M44f)arg1, (V3f)scale, (V3f)shear, (Eulerf)rotate, (V3f)translate) -> bool
M44f.extractScaling((M44f)arg1, (V3f)arg2) → bool
M44f.extractScalingAndShear((M44f)arg1, (V3f)arg2, (V3f)arg3) → bool
M44f.gjInverse((M44f)arg1) → M44f

Other signatures:

gjInverse( (M44f)arg1, (bool)arg2) -> M44f
M44f.gjInvert((M44f)arg1) → M44f

Other signatures:

gjInvert( (M44f)arg1, (bool)arg2) -> M44f
M44f.identity = M44f(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
M44f.inverse((M44f)arg1) → M44f

Other signatures:

inverse( (M44f)arg1, (bool)arg2) -> M44f
M44f.invert((M44f)arg1) → M44f

Other signatures:

invert( (M44f)arg1, (bool)arg2) -> M44f
M44f.makeIdentity((M44f)arg1) → None
M44f.multDirMatrix((M44f)arg1, (V3f)arg2, (V3f)arg3) → None

Vector-times-matrix multiplication; see also the * operators

M44f.multVecMatrix((M44f)arg1, (V3f)arg2, (V3f)arg3) → None

Vector-times-matrix multiplication; see also the * operators

M44f.multiply((M44f)arg1, (M44f)arg2, (M44f)arg3) → None
M44f.negate((M44f)arg1) → M44f
M44f.removeScaling((M44f)arg1) → bool
M44f.removeScalingAndShear((M44f)arg1) → bool
M44f.rotate((M44f)arg1, (V3f)arg2) → M44f

Rotate the matrix by XYZ euler angles in r

static M44f.rotationMatrix((V3f)arg1, (V3f)arg2) → M44f

Returns a matrix that rotates “fromDirection” vector to “toDirection” vector.

static M44f.rotationMatrixWithUpDir((V3f)arg1, (V3f)arg2, (V3f)arg3) → M44f

Returns a matrix that rotates the “fromDir” vector so that it points towards “toDir”. You may also specify that you want the up vector to be pointing in a certain direction “upDir”.

M44f.sansScaling((M44f)arg1) → M44f
M44f.sansScalingAndShear((M44f)arg1) → M44f
M44f.scale((M44f)arg1, (V3f)arg2) → M44f

Set matrix to scale by given vector

M44f.setAxisAngle((M44f)arg1, (V3f)arg2, (float)arg3) → M44f

Set matrix to rotation around given axis by given angle

M44f.setEulerAngles((M44f)arg1, (V3f)arg2) → M44f

Set matrix to rotation by XYZ euler angles (in radians)

M44f.setScale((M44f)arg1, (float)arg2) → M44f

Set matrix to scale by given uniform factor Set matrix to scale by given uniform factor

Other signatures:

setScale( (M44f)arg1, (V3f)arg2) -> M44f
M44f.setShear((M44f)arg1, (V3f)arg2) → M44f

Set matrix to shear by given vector h. The resulting matrix will shear x for each y coord. by a factor of h[0]; will shear x for each z coord. by a factor of h[1]; will shear y for each z coord. by a factor of h[2].

M44f.setTranslation((M44f)arg1, (V3f)arg2) → M44f

Set matrix to translation by given vector

M44f.shear((M44f)arg1, (V3f)arg2) → M44f

Shear the matrix by given vector. The composed matrix will be <shear> * <self>, where the shear matrix ... will shear x for each y coord. by a factor of h[0]; will shear x for each z coord. by a factor of h[1]; will shear y for each z coord. by a factor of h[2].

M44f.toMatrix33((M44f)arg1) → M33f
M44f.translate((M44f)arg1, (V3f)arg2) → M44f

Translate the matrix by t

M44f.translation((M44f)arg1) → V3f

Return translation component

M44f.transpose((M44f)arg1) → M44f
M44f.transposed((M44f)arg1) → M44f
class Imath.M44d

Bases: Boost.Python.instance

class M44dIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
M44d.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (M33d)arg2, (V3d)arg3) -> None
__init__( (object)arg1, (object)arg2, (object)arg3, (object)arg4, (object)arg5) -> object
__init__( (object)arg1, (object)arg2) -> object
static M44d.alignZAxisWithTargetDir((V3d)arg1, (V3d)arg2) → M44d

Returns a matrix that rotates the z-axis so that it points towards “targetDir”. You must also specify that you want the up vector to be pointing in a certain direction “upDir”. Notes: The following degenerate cases are handled: (a) when the directions given by “toDir” and “upDir” are parallel or opposite; (the direction vectors must have a non-zero cross product) (b) when any of the given direction vectors have zero length

static M44d.baseTypeEpsilon() → float
static M44d.baseTypeMax() → float
static M44d.baseTypeMin() → float
static M44d.baseTypeSmallest() → float
M44d.equalWithAbsError((M44d)arg1, (M44d)arg2, (float)arg3) → bool
M44d.equalWithRelError((M44d)arg1, (M44d)arg2, (float)arg3) → bool
M44d.extractAndRemoveScalingAndShear((M44d)arg1, (V3d)arg2, (V3d)arg3) → bool
M44d.extractEulerXYZ((M44d)arg1, (V3d)arg2) → None

This function assumes that the matrix does not include shear or non-uniform scaling, but it does not examine the matrix to verify this assumption. Matrices with shear or non-uniform scaling are likely to produce meaningless results. Therefore, you should use the removeScalingAndShear() routine, if necessary, prior to calling extractEulerXYZ()

M44d.extractEulerZYX((M44d)arg1, (V3d)arg2) → None

As extractEulerXYZ but with reversed rotation order.

M44d.extractQuat((M44d)arg1) → Quatd
M44d.extractSHRT((M44d)self, (V3d)scale, (V3d)shear, (V3d)rotate, (V3d)translate, (Order)order) → bool

Returns a tuple containing scale, shear, rotate, translate. Returns a tuple containing scale, shear, rotate, translate.

Other signatures:

extractSHRT( (M44d)self, (V3d)scale, (V3d)shear, (Eulerd)rotate, (V3d)translate) -> bool
extractSHRT( (M44d)self) -> tuple
extractSHRT( (M44d)self, (Order)order) -> tuple
extractSHRT( (M44d)arg1, (V3d)scale, (V3d)shear, (V3d)rotate, (V3d)translate) -> bool
extractSHRT( (M44d)arg1, (V3d)scale, (V3d)shear, (Eulerd)rotate, (V3d)translate) -> bool
M44d.extractScaling((M44d)arg1, (V3d)arg2) → bool
M44d.extractScalingAndShear((M44d)arg1, (V3d)arg2, (V3d)arg3) → bool
M44d.gjInverse((M44d)arg1) → M44d

Other signatures:

gjInverse( (M44d)arg1, (bool)arg2) -> M44d
M44d.gjInvert((M44d)arg1) → M44d

Other signatures:

gjInvert( (M44d)arg1, (bool)arg2) -> M44d
M44d.identity = M44d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)
M44d.inverse((M44d)arg1) → M44d

Other signatures:

inverse( (M44d)arg1, (bool)arg2) -> M44d
M44d.invert((M44d)arg1) → M44d

Other signatures:

invert( (M44d)arg1, (bool)arg2) -> M44d
M44d.makeIdentity((M44d)arg1) → None
M44d.multDirMatrix((M44d)arg1, (V3d)arg2, (V3d)arg3) → None

Vector-times-matrix multiplication; see also the * operators

M44d.multVecMatrix((M44d)arg1, (V3d)arg2, (V3d)arg3) → None

Vector-times-matrix multiplication; see also the * operators

M44d.multiply((M44d)arg1, (M44d)arg2, (M44d)arg3) → None
M44d.negate((M44d)arg1) → M44d
M44d.removeScaling((M44d)arg1) → bool
M44d.removeScalingAndShear((M44d)arg1) → bool
M44d.rotate((M44d)arg1, (V3d)arg2) → M44d

Rotate the matrix by XYZ euler angles in r

static M44d.rotationMatrix((V3d)arg1, (V3d)arg2) → M44d

Returns a matrix that rotates “fromDirection” vector to “toDirection” vector.

static M44d.rotationMatrixWithUpDir((V3d)arg1, (V3d)arg2, (V3d)arg3) → M44d

Returns a matrix that rotates the “fromDir” vector so that it points towards “toDir”. You may also specify that you want the up vector to be pointing in a certain direction “upDir”.

M44d.sansScaling((M44d)arg1) → M44d
M44d.sansScalingAndShear((M44d)arg1) → M44d
M44d.scale((M44d)arg1, (V3d)arg2) → M44d

Set matrix to scale by given vector

M44d.setAxisAngle((M44d)arg1, (V3d)arg2, (float)arg3) → M44d

Set matrix to rotation around given axis by given angle

M44d.setEulerAngles((M44d)arg1, (V3d)arg2) → M44d

Set matrix to rotation by XYZ euler angles (in radians)

M44d.setScale((M44d)arg1, (float)arg2) → M44d

Set matrix to scale by given uniform factor Set matrix to scale by given uniform factor

Other signatures:

setScale( (M44d)arg1, (V3d)arg2) -> M44d
M44d.setShear((M44d)arg1, (V3d)arg2) → M44d

Set matrix to shear by given vector h. The resulting matrix will shear x for each y coord. by a factor of h[0]; will shear x for each z coord. by a factor of h[1]; will shear y for each z coord. by a factor of h[2].

M44d.setTranslation((M44d)arg1, (V3d)arg2) → M44d

Set matrix to translation by given vector

M44d.shear((M44d)arg1, (V3d)arg2) → M44d

Shear the matrix by given vector. The composed matrix will be <shear> * <self>, where the shear matrix ... will shear x for each y coord. by a factor of h[0]; will shear x for each z coord. by a factor of h[1]; will shear y for each z coord. by a factor of h[2].

M44d.toMatrix33((M44d)arg1) → M33d
M44d.translate((M44d)arg1, (V3d)arg2) → M44d

Translate the matrix by t

M44d.translation((M44d)arg1) → V3d

Return translation component

M44d.transpose((M44d)arg1) → M44d
M44d.transposed((M44d)arg1) → M44d
class Imath.C3f

Bases: PyImath.V3f

class C3fIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
C3f.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> object
__init__( (object)arg1, (object)arg2) -> object
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4) -> None
C3f.b
C3f.g
static C3f.hsv2rgb((V3f)arg1) → V3f
C3f.negate((C3f)arg1) → C3f
static C3f.packed2rgb((int)arg1, (V3f)arg2) → None
C3f.r
static C3f.rgb2hsv((V3f)arg1) → V3f
static C3f.rgb2packed((V3f)arg1) → int
class Imath.Box3f

Bases: Boost.Python.instance

class Box3fIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
Box3f.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (V3f)arg2) -> None
__init__( (object)arg1, (V3f)arg2, (V3f)arg3) -> None
__init__( (object)arg1, (object)arg2) -> object
Box3f.center((Box3f)arg1) → V3f
Box3f.extendBy((Box3f)arg1, (V3f)arg2) → None

Other signatures:

extendBy( (Box3f)arg1, (Box3f)arg2) -> None
Box3f.hasVolume((Box3f)arg1) → bool
Box3f.intersects((Box3f)arg1, (V3f)arg2) → bool

Other signatures:

intersects( (Box3f)arg1, (Box3f)arg2) -> bool
Box3f.isEmpty((Box3f)arg1) → bool
Box3f.majorAxis((Box3f)arg1) → int
Box3f.makeEmpty((Box3f)arg1) → None
Box3f.max
Box3f.min
Box3f.size((Box3f)arg1) → V3f
class Imath.C3c

Bases: PyImath.V3c

class C3cIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
C3c.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> object
__init__( (object)arg1, (object)arg2) -> object
__init__( (object)arg1, (int)arg2, (int)arg3, (int)arg4) -> None
C3c.b
C3c.g
static C3c.hsv2rgb((V3c)arg1) → V3c
C3c.negate((C3c)arg1) → C3c
static C3c.packed2rgb((int)arg1, (V3c)arg2) → None
C3c.r
static C3c.rgb2hsv((V3c)arg1) → V3c
static C3c.rgb2packed((V3c)arg1) → int
class Imath.Box3d

Bases: Boost.Python.instance

class Box3dIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
Box3d.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (V3d)arg2) -> None
__init__( (object)arg1, (V3d)arg2, (V3d)arg3) -> None
__init__( (object)arg1, (object)arg2) -> object
Box3d.center((Box3d)arg1) → V3d
Box3d.extendBy((Box3d)arg1, (V3d)arg2) → None

Other signatures:

extendBy( (Box3d)arg1, (Box3d)arg2) -> None
Box3d.hasVolume((Box3d)arg1) → bool
Box3d.intersects((Box3d)arg1, (V3d)arg2) → bool

Other signatures:

intersects( (Box3d)arg1, (Box3d)arg2) -> bool
Box3d.isEmpty((Box3d)arg1) → bool
Box3d.majorAxis((Box3d)arg1) → int
Box3d.makeEmpty((Box3d)arg1) → None
Box3d.max
Box3d.min
Box3d.size((Box3d)arg1) → V3d
Imath.succd((float)arg1) → float

Returns double(d+e), where e is the smallest positive number such that double(d+e) != d. Exceptions: If the input value is an infinity or a nan, succf(), predf(), succd(), and predd() all return the input value without changing it.

class Imath.half

Bases: Boost.Python.instance

__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> object
__init__( (object)arg1, (float)arg2) -> None
bits

Access to the internal representation.

isDenormalized((half)arg1) → bool

Returns true if h is a denormalized number.

isFinite((half)arg1) → bool

Returns true if h is a normalized number, a denormalized number or zero.

isInfinity((half)arg1) → bool

Returns true if h is a positive or a negative infinity.

isNan((half)arg1) → bool

Returns true if h is a NAN.

isNegative((half)arg1) → bool

Returns true if the sign bit of h is set (negative).

isNormalized((half)arg1) → bool

Returns true if h is a normalized number.

isZero((half)arg1) → bool

Returns true if h is zero.

static negInf() → half

Returns -infinity.

static posInf() → half

Returns +infinity.

static qNan() → half

Returns a NaN with the bit pattern 0111111111111111

round((half)arg1, (int)arg2) → half

Round to n-bit precision (n should be between 0 and 10). After rounding, the significand’s 10-n least significant bits will be zero.

static sNan() → half

Returns a NaN with the bit pattern 0111110111111111

class Imath.Box3s

Bases: Boost.Python.instance

class Box3sIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
Box3s.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> None
__init__( (object)arg1, (V3s)arg2) -> None
__init__( (object)arg1, (V3s)arg2, (V3s)arg3) -> None
__init__( (object)arg1, (object)arg2) -> object
Box3s.center((Box3s)arg1) → V3s
Box3s.extendBy((Box3s)arg1, (V3s)arg2) → None

Other signatures:

extendBy( (Box3s)arg1, (Box3s)arg2) -> None
Box3s.hasVolume((Box3s)arg1) → bool
Box3s.intersects((Box3s)arg1, (V3s)arg2) → bool

Other signatures:

intersects( (Box3s)arg1, (Box3s)arg2) -> bool
Box3s.isEmpty((Box3s)arg1) → bool
Box3s.majorAxis((Box3s)arg1) → int
Box3s.makeEmpty((Box3s)arg1) → None
Box3s.max
Box3s.min
Box3s.size((Box3s)arg1) → V3s
Imath.sign((float)arg1) → int
Imath.divs((int)arg1, (int)arg2) → int

Integer division where the remainder of x/y has the same sign as x:

Other signatures:

divs(x,y) == (abs(x) / abs(y)) * (sign(x) * sign(y
Imath.trunc((float)arg1) → int
class Imath.V2s

Bases: Boost.Python.instance

class V2sIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
V2s.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1, (int)arg2) -> None
__init__( (object)arg1 [, (object)arg2]) -> object
__init__( (object)arg1, (int)arg2, (int)arg3) -> None
static V2s.baseTypeEpsilon() → int
static V2s.baseTypeMax() → int
static V2s.baseTypeMin() → int
static V2s.baseTypeSmallest() → int
V2s.closestVertex((V2s)v0, (V2s)v1, (V2s)v2, (V2s)p) → V2s

Find the vertex of triangle (v0, v1, v2), which is closest to point p

V2s.cross((V2s)arg1, (V2s)arg2) → int
static V2s.dimensions() → int
V2s.dot((V2s)arg1, (V2s)arg2) → int
V2s.equalWithAbsError((V2s)arg1, (V2s)arg2, (int)arg3) → bool
V2s.equalWithRelError((V2s)arg1, (V2s)arg2, (int)arg3) → bool
V2s.length((V2s)arg1) → int
V2s.length2((V2s)arg1) → int
V2s.negate((V2s)arg1) → V2s
V2s.normalize((V2s)arg1) → V2s
V2s.normalizeExc((V2s)arg1) → V2s
V2s.normalizeNonNull((V2s)arg1) → V2s
V2s.normalized((V2s)arg1) → V2s
V2s.normalizedExc((V2s)arg1) → V2s
V2s.normalizedNonNull((V2s)arg1) → V2s
V2s.orthogonal((V2s)self, (V2s)t) → V2s

Find a vector which is perpendicular to self and in the same plane as self and t

static V2s.project((V2s)s, (V2s)t) → V2s

Find the projection of vector t onto vector s

V2s.projection((V2s)arg1, (V2s)arg2) → V2s

Find the projection of self onto vector

V2s.reflect((V2s)self, (V2s)t) → V2s

Find the direction of self after reflection off a plane with normal t

V2s.x
V2s.y
Imath.succf((float)arg1) → float

Returns float(f+e), where e is the smallest positive number such that float(f+e) != f. Exceptions: If the input value is an infinity or a nan, succf(), predf(), succd(), and predd() all return the input value without changing it.

Imath.mods((int)arg1, (int)arg2) → int

Integer remainder where the remainder of x/y has the same sign as x:

Other signatures:

mods(x,y) == x - y * divs(x,
Imath.predd((float)arg1) → float

Returns double(d-e), where e is the smallest positive number such that double(d-e) != d. Exceptions: If the input value is an infinity or a nan, succf(), predf(), succd(), and predd() all return the input value without changing it.

Imath.ulerp((float)arg1, (float)arg2, (float)arg3) → float
Imath.ceil((float)arg1) → int
class Imath.C4f

Bases: Boost.Python.instance

class C4fIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
C4f.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1) -> object
__init__( (object)arg1, (object)arg2) -> object
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (float)arg5) -> None
C4f.a
C4f.b
static C4f.baseTypeEpsilon() → float
static C4f.baseTypeMax() → float
static C4f.baseTypeMin() → float
static C4f.baseTypeSmallest() → float
static C4f.dimensions() → int
C4f.g
static C4f.hsv2rgb((C4f)arg1) → C4f
C4f.negate((C4f)arg1) → C4f
static C4f.packed2rgb((int)arg1, (C4f)arg2) → None
C4f.r
static C4f.rgb2hsv((C4f)arg1) → C4f
static C4f.rgb2packed((C4f)arg1) → int
class Imath.Eulerf

Bases: PyImath.V3f

class Axis

Bases: Boost.Python.enum

X = PyImath.Axis.X
Y = PyImath.Axis.Y
Z = PyImath.Axis.Z
names = {'Y': PyImath.Axis.Y, 'X': PyImath.Axis.X, 'Z': PyImath.Axis.Z}
values = {0: PyImath.Axis.X, 1: PyImath.Axis.Y, 2: PyImath.Axis.Z}
class Eulerf.InputLayout

Bases: Boost.Python.enum

IJKLayout = PyImath.InputLayout.IJKLayout
XYZLayout = PyImath.InputLayout.XYZLayout
names = {'XYZLayout': PyImath.InputLayout.XYZLayout, 'IJKLayout': PyImath.InputLayout.IJKLayout}
values = {0: PyImath.InputLayout.XYZLayout, 1: PyImath.InputLayout.IJKLayout}
class Eulerf.Order

Bases: Boost.Python.enum

Default = PyImath.Order.Default
Legal = PyImath.Order.Legal
Max = PyImath.Order.Max
Min = PyImath.Order.Min
XYX = PyImath.Order.XYX
XYXr = PyImath.Order.XYXr
XYZ = PyImath.Order.XYZ
XYZr = PyImath.Order.XYZr
XZX = PyImath.Order.XZX
XZXr = PyImath.Order.XZXr
XZY = PyImath.Order.XZY
XZYr = PyImath.Order.XZYr
YXY = PyImath.Order.YXY
YXYr = PyImath.Order.YXYr
YXZ = PyImath.Order.YXZ
YXZr = PyImath.Order.YXZr
YZX = PyImath.Order.YZX
YZXr = PyImath.Order.YZXr
YZY = PyImath.Order.YZY
YZYr = PyImath.Order.YZYr
ZXY = PyImath.Order.ZXY
ZXYr = PyImath.Order.ZXYr
ZXZ = PyImath.Order.ZXZ
ZXZr = PyImath.Order.ZXZr
ZYX = PyImath.Order.ZYX
ZYXr = PyImath.Order.ZYXr
ZYZ = PyImath.Order.ZYZ
ZYZr = PyImath.Order.ZYZr
names = {'Min': PyImath.Order.Min, 'YZYr': PyImath.Order.YZYr, 'XYZr': PyImath.Order.XYZr, 'Legal': PyImath.Order.Legal, 'Max': PyImath.Order.Max, 'YXYr': PyImath.Order.YXYr, 'ZYZ': PyImath.Order.ZYZ, 'ZYX': PyImath.Order.ZYX, 'YXZ': PyImath.Order.YXZ, 'YXY': PyImath.Order.YXY, 'ZXYr': PyImath.Order.ZXYr, 'YZX': PyImath.Order.YZX, 'YZY': PyImath.Order.YZY, 'XZY': PyImath.Order.XZY, 'XZX': PyImath.Order.XZX, 'YZXr': PyImath.Order.YZXr, 'XZYr': PyImath.Order.XZYr, 'Default': PyImath.Order.Default, 'ZXY': PyImath.Order.ZXY, 'ZXZ': PyImath.Order.ZXZ, 'YXZr': PyImath.Order.YXZr, 'ZYXr': PyImath.Order.ZYXr, 'XYX': PyImath.Order.XYX, 'XYZ': PyImath.Order.XYZ, 'ZYZr': PyImath.Order.ZYZr, 'XYXr': PyImath.Order.XYXr, 'XZXr': PyImath.Order.XZXr, 'ZXZr': PyImath.Order.ZXZr}
values = {8192: PyImath.Order.XYZr, 257: PyImath.Order.Default, 4112: PyImath.Order.YZYr, 8209: PyImath.Order.ZYZ, 4096: PyImath.Order.YZXr, 4097: PyImath.Order.YXZ, 8465: PyImath.Order.Max, 256: PyImath.Order.ZYXr, 8464: PyImath.Order.XZXr, 4369: PyImath.Order.YZY, 4113: PyImath.Order.YXY, 0: PyImath.Order.Min, 8193: PyImath.Order.ZYX, 272: PyImath.Order.ZYZr, 8449: PyImath.Order.ZXY, 1: PyImath.Order.XZY, 273: PyImath.Order.XYX, 12561: PyImath.Order.Legal, 4352: PyImath.Order.YXZr, 8448: PyImath.Order.XZYr, 4353: PyImath.Order.YZX, 8208: PyImath.Order.XYXr, 17: PyImath.Order.XZX, 4368: PyImath.Order.YXYr, 16: PyImath.Order.ZXZr}
Eulerf.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1, (Order)arg2) -> None
__init__( (object)arg1, (V3f)arg2, (Order)arg3) -> None
__init__( (object)arg1, (V3f)arg2, (Order)arg3, (InputLayout)arg4) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (Order)arg5) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (Order)arg5, (InputLayout)arg6) -> None
__init__( (object)arg1, (Eulerf)arg2, (Order)arg3) -> None
__init__( (object)arg1, (M33f)arg2) -> None
__init__( (object)arg1, (M33f)arg2, (Order)arg3) -> None
__init__( (object)arg1, (M44f)arg2) -> None
__init__( (object)arg1, (M44f)arg2, (Order)arg3) -> None
static Eulerf.angleMod((float)arg1) → float

Converts an angle to its equivalent in [-PI, PI]

Eulerf.angleOrder((Eulerf)arg1) → tuple

Use this function to unpack angles from ijk form Use this function to determine mapping from xyz to ijk - reshuffles the xyz to match the order

Other signatures:

angleOrder( (Eulerf)arg1) -> tuple
Eulerf.extract((Eulerf)arg1, (M33f)arg2) → None

Other signatures:

extract( (Eulerf)arg1, (M44f)arg2) -> None
extract( (Eulerf)arg1, (Quatf)arg2) -> None
Eulerf.frameStatic
Eulerf.initialAxis
Eulerf.initialRepeated
static Eulerf.legal((Order)arg1) → bool
Eulerf.makeNear((Eulerf)arg1, (Eulerf)arg2) → None
static Eulerf.nearestRotation((V3f)xyzRot, (V3f)targetXyzRot[, (Order)order=PyImath.Order.Default]) → None

Adjusts xyzRot so that its components differ from targetXyzRot by as little as possible. Note that xyz here really means ijk, because the order must be provided.

Eulerf.order
Eulerf.parityEven
Eulerf.set((Eulerf)arg1, (Axis)axis, (bool)relative, (bool)parityEven, (bool)firstRepeats) → None
Eulerf.setXYZVector((Eulerf)arg1, (V3f)arg2) → None

Set the euler value This does NOT convert the angles, but setXYZVector() does reorder the input vector.

static Eulerf.simpleXYZRotation((V3f)xyzRot, (V3f)targetXyzRot) → None

Adjusts xyzRot so that its components differ from targetXyzRot by no more than +-PI

Eulerf.toMatrix33((Eulerf)arg1) → M33f
Eulerf.toMatrix44((Eulerf)arg1) → M44f
Eulerf.toQuat((Eulerf)arg1) → Quatf
Eulerf.toXYZVector((Eulerf)arg1) → V3f

Reorders the angles so that the X rotation comes first, followed by the Y and Z. In cases like XYX ordering, the repeated angle will be in the “z” component

class Imath.Eulerd

Bases: PyImath.V3d

class Axis

Bases: Boost.Python.enum

X = PyImath.Axis.X
Y = PyImath.Axis.Y
Z = PyImath.Axis.Z
names = {'Y': PyImath.Axis.Y, 'X': PyImath.Axis.X, 'Z': PyImath.Axis.Z}
values = {0: PyImath.Axis.X, 1: PyImath.Axis.Y, 2: PyImath.Axis.Z}
class Eulerd.InputLayout

Bases: Boost.Python.enum

IJKLayout = PyImath.InputLayout.IJKLayout
XYZLayout = PyImath.InputLayout.XYZLayout
names = {'XYZLayout': PyImath.InputLayout.XYZLayout, 'IJKLayout': PyImath.InputLayout.IJKLayout}
values = {0: PyImath.InputLayout.XYZLayout, 1: PyImath.InputLayout.IJKLayout}
class Eulerd.Order

Bases: Boost.Python.enum

Default = PyImath.Order.Default
Legal = PyImath.Order.Legal
Max = PyImath.Order.Max
Min = PyImath.Order.Min
XYX = PyImath.Order.XYX
XYXr = PyImath.Order.XYXr
XYZ = PyImath.Order.XYZ
XYZr = PyImath.Order.XYZr
XZX = PyImath.Order.XZX
XZXr = PyImath.Order.XZXr
XZY = PyImath.Order.XZY
XZYr = PyImath.Order.XZYr
YXY = PyImath.Order.YXY
YXYr = PyImath.Order.YXYr
YXZ = PyImath.Order.YXZ
YXZr = PyImath.Order.YXZr
YZX = PyImath.Order.YZX
YZXr = PyImath.Order.YZXr
YZY = PyImath.Order.YZY
YZYr = PyImath.Order.YZYr
ZXY = PyImath.Order.ZXY
ZXYr = PyImath.Order.ZXYr
ZXZ = PyImath.Order.ZXZ
ZXZr = PyImath.Order.ZXZr
ZYX = PyImath.Order.ZYX
ZYXr = PyImath.Order.ZYXr
ZYZ = PyImath.Order.ZYZ
ZYZr = PyImath.Order.ZYZr
names = {'Min': PyImath.Order.Min, 'YZYr': PyImath.Order.YZYr, 'XYZr': PyImath.Order.XYZr, 'Legal': PyImath.Order.Legal, 'Max': PyImath.Order.Max, 'YXYr': PyImath.Order.YXYr, 'ZYZ': PyImath.Order.ZYZ, 'ZYX': PyImath.Order.ZYX, 'YXZ': PyImath.Order.YXZ, 'YXY': PyImath.Order.YXY, 'ZXYr': PyImath.Order.ZXYr, 'YZX': PyImath.Order.YZX, 'YZY': PyImath.Order.YZY, 'XZY': PyImath.Order.XZY, 'XZX': PyImath.Order.XZX, 'YZXr': PyImath.Order.YZXr, 'XZYr': PyImath.Order.XZYr, 'Default': PyImath.Order.Default, 'ZXY': PyImath.Order.ZXY, 'ZXZ': PyImath.Order.ZXZ, 'YXZr': PyImath.Order.YXZr, 'ZYXr': PyImath.Order.ZYXr, 'XYX': PyImath.Order.XYX, 'XYZ': PyImath.Order.XYZ, 'ZYZr': PyImath.Order.ZYZr, 'XYXr': PyImath.Order.XYXr, 'XZXr': PyImath.Order.XZXr, 'ZXZr': PyImath.Order.ZXZr}
values = {8192: PyImath.Order.XYZr, 257: PyImath.Order.Default, 4112: PyImath.Order.YZYr, 8209: PyImath.Order.ZYZ, 4096: PyImath.Order.YZXr, 4097: PyImath.Order.YXZ, 8465: PyImath.Order.Max, 256: PyImath.Order.ZYXr, 8464: PyImath.Order.XZXr, 4369: PyImath.Order.YZY, 4113: PyImath.Order.YXY, 0: PyImath.Order.Min, 8193: PyImath.Order.ZYX, 272: PyImath.Order.ZYZr, 8449: PyImath.Order.ZXY, 1: PyImath.Order.XZY, 273: PyImath.Order.XYX, 12561: PyImath.Order.Legal, 4352: PyImath.Order.YXZr, 8448: PyImath.Order.XZYr, 4353: PyImath.Order.YZX, 8208: PyImath.Order.XYXr, 17: PyImath.Order.XZX, 4368: PyImath.Order.YXYr, 16: PyImath.Order.ZXZr}
Eulerd.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1, (Order)arg2) -> None
__init__( (object)arg1, (V3d)arg2, (Order)arg3) -> None
__init__( (object)arg1, (V3d)arg2, (Order)arg3, (InputLayout)arg4) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (Order)arg5) -> None
__init__( (object)arg1, (float)arg2, (float)arg3, (float)arg4, (Order)arg5, (InputLayout)arg6) -> None
__init__( (object)arg1, (Eulerd)arg2, (Order)arg3) -> None
__init__( (object)arg1, (M33d)arg2) -> None
__init__( (object)arg1, (M33d)arg2, (Order)arg3) -> None
__init__( (object)arg1, (M44d)arg2) -> None
__init__( (object)arg1, (M44d)arg2, (Order)arg3) -> None
static Eulerd.angleMod((float)arg1) → float

Converts an angle to its equivalent in [-PI, PI]

Eulerd.angleOrder((Eulerd)arg1) → tuple

Use this function to unpack angles from ijk form Use this function to determine mapping from xyz to ijk - reshuffles the xyz to match the order

Other signatures:

angleOrder( (Eulerd)arg1) -> tuple
Eulerd.extract((Eulerd)arg1, (M33d)arg2) → None

Other signatures:

extract( (Eulerd)arg1, (M44d)arg2) -> None
extract( (Eulerd)arg1, (Quatd)arg2) -> None
Eulerd.frameStatic
Eulerd.initialAxis
Eulerd.initialRepeated
static Eulerd.legal((Order)arg1) → bool
Eulerd.makeNear((Eulerd)arg1, (Eulerd)arg2) → None
static Eulerd.nearestRotation((V3d)xyzRot, (V3d)targetXyzRot[, (Order)order=PyImath.Order.Default]) → None

Adjusts xyzRot so that its components differ from targetXyzRot by as little as possible. Note that xyz here really means ijk, because the order must be provided.

Eulerd.order
Eulerd.parityEven
Eulerd.set((Eulerd)arg1, (Axis)axis, (bool)relative, (bool)parityEven, (bool)firstRepeats) → None
Eulerd.setXYZVector((Eulerd)arg1, (V3d)arg2) → None

Set the euler value This does NOT convert the angles, but setXYZVector() does reorder the input vector.

static Eulerd.simpleXYZRotation((V3d)xyzRot, (V3d)targetXyzRot) → None

Adjusts xyzRot so that its components differ from targetXyzRot by no more than +-PI

Eulerd.toMatrix33((Eulerd)arg1) → M33d
Eulerd.toMatrix44((Eulerd)arg1) → M44d
Eulerd.toQuat((Eulerd)arg1) → Quatd
Eulerd.toXYZVector((Eulerd)arg1) → V3d

Reorders the angles so that the X rotation comes first, followed by the Y and Z. In cases like XYX ordering, the repeated angle will be in the “z” component

class Imath.V2f

Bases: Boost.Python.instance

class V2fIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
V2f.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1, (float)arg2) -> None
__init__( (object)arg1 [, (object)arg2]) -> object
__init__( (object)arg1, (float)arg2, (float)arg3) -> None
static V2f.baseTypeEpsilon() → float
static V2f.baseTypeMax() → float
static V2f.baseTypeMin() → float
static V2f.baseTypeSmallest() → float
V2f.closestVertex((V2f)v0, (V2f)v1, (V2f)v2, (V2f)p) → V2f

Find the vertex of triangle (v0, v1, v2), which is closest to point p

V2f.cross((V2f)arg1, (V2f)arg2) → float
static V2f.dimensions() → int
V2f.dot((V2f)arg1, (V2f)arg2) → float
V2f.equalWithAbsError((V2f)arg1, (V2f)arg2, (float)arg3) → bool
V2f.equalWithRelError((V2f)arg1, (V2f)arg2, (float)arg3) → bool
V2f.length((V2f)arg1) → float
V2f.length2((V2f)arg1) → float
V2f.negate((V2f)arg1) → V2f
V2f.normalize((V2f)arg1) → V2f
V2f.normalizeExc((V2f)arg1) → V2f
V2f.normalizeNonNull((V2f)arg1) → V2f
V2f.normalized((V2f)arg1) → V2f
V2f.normalizedExc((V2f)arg1) → V2f
V2f.normalizedNonNull((V2f)arg1) → V2f
V2f.orthogonal((V2f)self, (V2f)t) → V2f

Find a vector which is perpendicular to self and in the same plane as self and t

static V2f.project((V2f)s, (V2f)t) → V2f

Find the projection of vector t onto vector s

V2f.projection((V2f)arg1, (V2f)arg2) → V2f

Find the projection of self onto vector

V2f.reflect((V2f)self, (V2f)t) → V2f

Find the direction of self after reflection off a plane with normal t

V2f.x
V2f.y
class Imath.V2d

Bases: Boost.Python.instance

class V2dIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
V2d.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1, (float)arg2) -> None
__init__( (object)arg1 [, (object)arg2]) -> object
__init__( (object)arg1, (float)arg2, (float)arg3) -> None
static V2d.baseTypeEpsilon() → float
static V2d.baseTypeMax() → float
static V2d.baseTypeMin() → float
static V2d.baseTypeSmallest() → float
V2d.closestVertex((V2d)v0, (V2d)v1, (V2d)v2, (V2d)p) → V2d

Find the vertex of triangle (v0, v1, v2), which is closest to point p

V2d.cross((V2d)arg1, (V2d)arg2) → float
static V2d.dimensions() → int
V2d.dot((V2d)arg1, (V2d)arg2) → float
V2d.equalWithAbsError((V2d)arg1, (V2d)arg2, (float)arg3) → bool
V2d.equalWithRelError((V2d)arg1, (V2d)arg2, (float)arg3) → bool
V2d.length((V2d)arg1) → float
V2d.length2((V2d)arg1) → float
V2d.negate((V2d)arg1) → V2d
V2d.normalize((V2d)arg1) → V2d
V2d.normalizeExc((V2d)arg1) → V2d
V2d.normalizeNonNull((V2d)arg1) → V2d
V2d.normalized((V2d)arg1) → V2d
V2d.normalizedExc((V2d)arg1) → V2d
V2d.normalizedNonNull((V2d)arg1) → V2d
V2d.orthogonal((V2d)self, (V2d)t) → V2d

Find a vector which is perpendicular to self and in the same plane as self and t

static V2d.project((V2d)s, (V2d)t) → V2d

Find the projection of vector t onto vector s

V2d.projection((V2d)arg1, (V2d)arg2) → V2d

Find the projection of self onto vector

V2d.reflect((V2d)self, (V2d)t) → V2d

Find the direction of self after reflection off a plane with normal t

V2d.x
V2d.y
class Imath.V2i

Bases: Boost.Python.instance

class V2iIterator

Bases: object

Imath Iterator

__new__(S, ...) → a new object with type S, a subtype of T
next
V2i.__init__((object)arg1) → None

Other signatures:

__init__( (object)arg1, (int)arg2) -> None
__init__( (object)arg1 [, (object)arg2]) -> object
__init__( (object)arg1, (int)arg2, (int)arg3) -> None
static V2i.baseTypeEpsilon() → int
static V2i.baseTypeMax() → int
static V2i.baseTypeMin() → int
static V2i.baseTypeSmallest() → int
V2i.closestVertex((V2i)v0, (V2i)v1, (V2i)v2, (V2i)p) → V2i

Find the vertex of triangle (v0, v1, v2), which is closest to point p

V2i.cross((V2i)arg1, (V2i)arg2) → int
static V2i.dimensions() → int
V2i.dot((V2i)arg1, (V2i)arg2) → int
V2i.equalWithAbsError((V2i)arg1, (V2i)arg2, (int)arg3) → bool
V2i.equalWithRelError((V2i)arg1, (V2i)arg2, (int)arg3) → bool
V2i.length((V2i)arg1) → int
V2i.length2((V2i)arg1) → int
V2i.negate((V2i)arg1) → V2i
V2i.normalize((V2i)arg1) → V2i
V2i.normalizeExc((V2i)arg1) → V2i
V2i.normalizeNonNull((V2i)arg1) → V2i
V2i.normalized((V2i)arg1) → V2i
V2i.normalizedExc((V2i)arg1) → V2i
V2i.normalizedNonNull((V2i)arg1) → V2i
V2i.orthogonal((V2i)self, (V2i)t) → V2i

Find a vector which is perpendicular to self and in the same plane as self and t

static V2i.project((V2i)s, (V2i)t) → V2i

Find the projection of vector t onto vector s

V2i.projection((V2i)arg1, (V2i)arg2) → V2i

Find the projection of self onto vector

V2i.reflect((V2i)self, (V2i)t) → V2i

Find the direction of self after reflection off a plane with normal t

V2i.x
V2i.y
Imath.cmp((float)arg1, (float)arg2) → int