Imath (Python)

class Imath.Box2d

Bases: pybind11_object

class Box2dIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Box2d) -> None

Returns an empty box.

2. __init__(self: PyImath.Box2d, point: PyImath.V2d) -> None

Returns a box with min and max both set to the given point.

3. __init__(self: PyImath.Box2d, min: PyImath.V2d, max: PyImath.V2d) -> None

Returns a box with min and max points defined by the given points.

4. __init__(self: PyImath.Box2d, iterable: object) -> None

Returns a box using values from the given iterable.

center() → PyImath.V2d

Returns the central point of this box.

extendBy(*args, **kwargs)

Overloaded function.

1. extendBy(self: PyImath.Box2d, point: PyImath.V2d) -> None

Extends this box to include the given point.

2. extendBy(self: PyImath.Box2d, box: PyImath.Box2d) -> None

Extends this box to include the given box.

hasVolume() → bool

Returns True if this box has volume.

intersects(*args, **kwargs)

Overloaded function.

1. intersects(self: PyImath.Box2d, point: PyImath.V2d) -> bool

Returns True if this box encompasses the given point.

2. intersects(self: PyImath.Box2d, box: PyImath.Box2d) -> bool

Returns True if this box intersects the given box.

isEmpty() → bool

Returns True if this box has no volume.

majorAxis() → int

Returns the index of the longest axis of this box.

makeEmpty() → None

Converts this box to an empty box.

property max

The maximum corner of this box.

property min

The minimum corner of this box.

size() → PyImath.V2d

Returns the volume of this box.

class Imath.Box2f

Bases: pybind11_object

class Box2fIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Box2f) -> None

Returns an empty box.

2. __init__(self: PyImath.Box2f, point: PyImath.V2f) -> None

Returns a box with min and max both set to the given point.

3. __init__(self: PyImath.Box2f, min: PyImath.V2f, max: PyImath.V2f) -> None

Returns a box with min and max points defined by the given points.

4. __init__(self: PyImath.Box2f, iterable: object) -> None

Returns a box using values from the given iterable.

center() → PyImath.V2f

Returns the central point of this box.

extendBy(*args, **kwargs)

Overloaded function.

1. extendBy(self: PyImath.Box2f, point: PyImath.V2f) -> None

Extends this box to include the given point.

2. extendBy(self: PyImath.Box2f, box: PyImath.Box2f) -> None

Extends this box to include the given box.

hasVolume() → bool

Returns True if this box has volume.

intersects(*args, **kwargs)

Overloaded function.

1. intersects(self: PyImath.Box2f, point: PyImath.V2f) -> bool

Returns True if this box encompasses the given point.

2. intersects(self: PyImath.Box2f, box: PyImath.Box2f) -> bool

Returns True if this box intersects the given box.

isEmpty() → bool

Returns True if this box has no volume.

majorAxis() → int

Returns the index of the longest axis of this box.

makeEmpty() → None

Converts this box to an empty box.

property max

The maximum corner of this box.

property min

The minimum corner of this box.

size() → PyImath.V2f

Returns the volume of this box.

class Imath.Box2i

Bases: pybind11_object

class Box2iIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Box2i) -> None

Returns an empty box.

2. __init__(self: PyImath.Box2i, point: PyImath.V2i) -> None

Returns a box with min and max both set to the given point.

3. __init__(self: PyImath.Box2i, min: PyImath.V2i, max: PyImath.V2i) -> None

Returns a box with min and max points defined by the given points.

4. __init__(self: PyImath.Box2i, iterable: object) -> None

Returns a box using values from the given iterable.

center() → PyImath.V2i

Returns the central point of this box.

extendBy(*args, **kwargs)

Overloaded function.

1. extendBy(self: PyImath.Box2i, point: PyImath.V2i) -> None

Extends this box to include the given point.

2. extendBy(self: PyImath.Box2i, box: PyImath.Box2i) -> None

Extends this box to include the given box.

hasVolume() → bool

Returns True if this box has volume.

intersects(*args, **kwargs)

Overloaded function.

1. intersects(self: PyImath.Box2i, point: PyImath.V2i) -> bool

Returns True if this box encompasses the given point.

2. intersects(self: PyImath.Box2i, box: PyImath.Box2i) -> bool

Returns True if this box intersects the given box.

isEmpty() → bool

Returns True if this box has no volume.

majorAxis() → int

Returns the index of the longest axis of this box.

makeEmpty() → None

Converts this box to an empty box.

property max

The maximum corner of this box.

property min

The minimum corner of this box.

size() → PyImath.V2i

Returns the volume of this box.

class Imath.Box2s

Bases: pybind11_object

class Box2sIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Box2s) -> None

Returns an empty box.

2. __init__(self: PyImath.Box2s, point: PyImath.V2s) -> None

Returns a box with min and max both set to the given point.

3. __init__(self: PyImath.Box2s, min: PyImath.V2s, max: PyImath.V2s) -> None

Returns a box with min and max points defined by the given points.

4. __init__(self: PyImath.Box2s, iterable: object) -> None

Returns a box using values from the given iterable.

center() → PyImath.V2s

Returns the central point of this box.

extendBy(*args, **kwargs)

Overloaded function.

1. extendBy(self: PyImath.Box2s, point: PyImath.V2s) -> None

Extends this box to include the given point.

2. extendBy(self: PyImath.Box2s, box: PyImath.Box2s) -> None

Extends this box to include the given box.

hasVolume() → bool

Returns True if this box has volume.

intersects(*args, **kwargs)

Overloaded function.

1. intersects(self: PyImath.Box2s, point: PyImath.V2s) -> bool

Returns True if this box encompasses the given point.

2. intersects(self: PyImath.Box2s, box: PyImath.Box2s) -> bool

Returns True if this box intersects the given box.

isEmpty() → bool

Returns True if this box has no volume.

majorAxis() → int

Returns the index of the longest axis of this box.

makeEmpty() → None

Converts this box to an empty box.

property max

The maximum corner of this box.

property min

The minimum corner of this box.

size() → PyImath.V2s

Returns the volume of this box.

class Imath.Box3d

Bases: pybind11_object

class Box3dIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Box3d) -> None

Returns an empty box.

2. __init__(self: PyImath.Box3d, point: PyImath.V3d) -> None

Returns a box with min and max both set to the given point.

3. __init__(self: PyImath.Box3d, min: PyImath.V3d, max: PyImath.V3d) -> None

Returns a box with min and max points defined by the given points.

4. __init__(self: PyImath.Box3d, iterable: object) -> None

Returns a box using values from the given iterable.

center() → PyImath.V3d

Returns the central point of this box.

extendBy(*args, **kwargs)

Overloaded function.

1. extendBy(self: PyImath.Box3d, point: PyImath.V3d) -> None

Extends this box to include the given point.

2. extendBy(self: PyImath.Box3d, box: PyImath.Box3d) -> None

Extends this box to include the given box.

hasVolume() → bool

Returns True if this box has volume.

intersects(*args, **kwargs)

Overloaded function.

1. intersects(self: PyImath.Box3d, point: PyImath.V3d) -> bool

Returns True if this box encompasses the given point.

2. intersects(self: PyImath.Box3d, box: PyImath.Box3d) -> bool

Returns True if this box intersects the given box.

isEmpty() → bool

Returns True if this box has no volume.

majorAxis() → int

Returns the index of the longest axis of this box.

makeEmpty() → None

Converts this box to an empty box.

property max

The maximum corner of this box.

property min

The minimum corner of this box.

size() → PyImath.V3d

Returns the volume of this box.

class Imath.Box3f

Bases: pybind11_object

class Box3fIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Box3f) -> None

Returns an empty box.

2. __init__(self: PyImath.Box3f, point: PyImath.V3f) -> None

Returns a box with min and max both set to the given point.

3. __init__(self: PyImath.Box3f, min: PyImath.V3f, max: PyImath.V3f) -> None

Returns a box with min and max points defined by the given points.

4. __init__(self: PyImath.Box3f, iterable: object) -> None

Returns a box using values from the given iterable.

center() → PyImath.V3f

Returns the central point of this box.

extendBy(*args, **kwargs)

Overloaded function.

1. extendBy(self: PyImath.Box3f, point: PyImath.V3f) -> None

Extends this box to include the given point.

2. extendBy(self: PyImath.Box3f, box: PyImath.Box3f) -> None

Extends this box to include the given box.

hasVolume() → bool

Returns True if this box has volume.

intersects(*args, **kwargs)

Overloaded function.

1. intersects(self: PyImath.Box3f, point: PyImath.V3f) -> bool

Returns True if this box encompasses the given point.

2. intersects(self: PyImath.Box3f, box: PyImath.Box3f) -> bool

Returns True if this box intersects the given box.

isEmpty() → bool

Returns True if this box has no volume.

majorAxis() → int

Returns the index of the longest axis of this box.

makeEmpty() → None

Converts this box to an empty box.

property max

The maximum corner of this box.

property min

The minimum corner of this box.

size() → PyImath.V3f

Returns the volume of this box.

class Imath.Box3i

Bases: pybind11_object

class Box3iIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Box3i) -> None

Returns an empty box.

2. __init__(self: PyImath.Box3i, point: PyImath.V3i) -> None

Returns a box with min and max both set to the given point.

3. __init__(self: PyImath.Box3i, min: PyImath.V3i, max: PyImath.V3i) -> None

Returns a box with min and max points defined by the given points.

4. __init__(self: PyImath.Box3i, iterable: object) -> None

Returns a box using values from the given iterable.

center() → PyImath.V3i

Returns the central point of this box.

extendBy(*args, **kwargs)

Overloaded function.

1. extendBy(self: PyImath.Box3i, point: PyImath.V3i) -> None

Extends this box to include the given point.

2. extendBy(self: PyImath.Box3i, box: PyImath.Box3i) -> None

Extends this box to include the given box.

hasVolume() → bool

Returns True if this box has volume.

intersects(*args, **kwargs)

Overloaded function.

1. intersects(self: PyImath.Box3i, point: PyImath.V3i) -> bool

Returns True if this box encompasses the given point.

2. intersects(self: PyImath.Box3i, box: PyImath.Box3i) -> bool

Returns True if this box intersects the given box.

isEmpty() → bool

Returns True if this box has no volume.

majorAxis() → int

Returns the index of the longest axis of this box.

makeEmpty() → None

Converts this box to an empty box.

property max

The maximum corner of this box.

property min

The minimum corner of this box.

size() → PyImath.V3i

Returns the volume of this box.

class Imath.Box3s

Bases: pybind11_object

class Box3sIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Box3s) -> None

Returns an empty box.

2. __init__(self: PyImath.Box3s, point: PyImath.V3s) -> None

Returns a box with min and max both set to the given point.

3. __init__(self: PyImath.Box3s, min: PyImath.V3s, max: PyImath.V3s) -> None

Returns a box with min and max points defined by the given points.

4. __init__(self: PyImath.Box3s, iterable: object) -> None

Returns a box using values from the given iterable.

center() → PyImath.V3s

Returns the central point of this box.

extendBy(*args, **kwargs)

Overloaded function.

1. extendBy(self: PyImath.Box3s, point: PyImath.V3s) -> None

Extends this box to include the given point.

2. extendBy(self: PyImath.Box3s, box: PyImath.Box3s) -> None

Extends this box to include the given box.

hasVolume() → bool

Returns True if this box has volume.

intersects(*args, **kwargs)

Overloaded function.

1. intersects(self: PyImath.Box3s, point: PyImath.V3s) -> bool

Returns True if this box encompasses the given point.

2. intersects(self: PyImath.Box3s, box: PyImath.Box3s) -> bool

Returns True if this box intersects the given box.

isEmpty() → bool

Returns True if this box has no volume.

majorAxis() → int

Returns the index of the longest axis of this box.

makeEmpty() → None

Converts this box to an empty box.

property max

The maximum corner of this box.

property min

The minimum corner of this box.

size() → PyImath.V3s

Returns the volume of this box.

class Imath.C3c

Bases: V3c

class C3cIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.C3c) -> None

Initializes a color with all channels zero.

2. __init__(self: PyImath.C3c, value: object) -> None

Initializes a color from the given number of iterable.

3. __init__(self: PyImath.C3c, arg0: int, arg1: int, arg2: int) -> None

Initializes a color from RGB values.

property b

The blue channel of this color.

property g

The green channel of this color.

static hsv2rgb(arg0: PyImath.V3c) → PyImath.V3c

Convert the given HSV color to RGB.

negate() → PyImath.C3c

Negates this color’s channels.

static packed2rgb(arg0: int, arg1: PyImath.V3c) → None

Convert the given packed color to RGB.

property r

The red channel of this color.

static rgb2hsv(arg0: PyImath.V3c) → PyImath.V3c

Convert the given RGB color to HSV.

static rgb2packed(arg0: PyImath.V3c) → int

Convert the given RGB color to packed format.

class Imath.C3f

Bases: V3f

class C3fIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.C3f) -> None

Initializes a color with all channels zero.

2. __init__(self: PyImath.C3f, value: object) -> None

Initializes a color from the given number of iterable.

3. __init__(self: PyImath.C3f, arg0: float, arg1: float, arg2: float) -> None

Initializes a color from RGB values.

property b

The blue channel of this color.

property g

The green channel of this color.

static hsv2rgb(arg0: PyImath.V3f) → PyImath.V3f

Convert the given HSV color to RGB.

negate() → PyImath.C3f

Negates this color’s channels.

static packed2rgb(arg0: int, arg1: PyImath.V3f) → None

Convert the given packed color to RGB.

property r

The red channel of this color.

static rgb2hsv(arg0: PyImath.V3f) → PyImath.V3f

Convert the given RGB color to HSV.

static rgb2packed(arg0: PyImath.V3f) → int

Convert the given RGB color to packed format.

class Imath.C3h

Bases: V3h

class C3hIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.C3h) -> None

Initializes a color with all channels zero.

2. __init__(self: PyImath.C3h, value: object) -> None

Initializes a color from the given number of iterable.

3. __init__(self: PyImath.C3h, arg0: Imath_3_1::half, arg1: Imath_3_1::half, arg2: Imath_3_1::half) -> None

Initializes a color from RGB values.

property b

The blue channel of this color.

property g

The green channel of this color.

static hsv2rgb(arg0: PyImath.V3h) → PyImath.V3h

Convert the given HSV color to RGB.

negate() → PyImath.C3h

Negates this color’s channels.

static packed2rgb(arg0: int, arg1: PyImath.V3h) → None

Convert the given packed color to RGB.

property r

The red channel of this color.

static rgb2hsv(arg0: PyImath.V3h) → PyImath.V3h

Convert the given RGB color to HSV.

static rgb2packed(arg0: PyImath.V3h) → int

Convert the given RGB color to packed format.

class Imath.C4c

Bases: pybind11_object

class C4cIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.C4c) -> None

Initializes a color with all channels zero.

2. __init__(self: PyImath.C4c, value: object) -> None

Initializes a color from the given number of iterable.

3. __init__(self: PyImath.C4c, arg0: int, arg1: int, arg2: int, arg3: int) -> None

Initializes a color from RGBA values.

property a

The alpha channel of this color.

property b

The blue channel of this color.

static baseTypeEpsilon() → int

Returns a suitable epsilon for comparing values of the underlying component type.

static baseTypeLowest() → int

Returns the smallest value of the underlying component type.

static baseTypeMax() → int

Returns the largest value of the underlying component type.

static baseTypeSmallest() → int

Returns the smallest positive value of the underlying component type.

static dimensions() → int

property g

The green channel of this color.

static hsv2rgb(arg0: PyImath.C4c) → PyImath.C4c

Convert the given HSV color to RGB.

negate() → PyImath.C4c

Negates this color’s channels.

static packed2rgb(arg0: int, arg1: PyImath.C4c) → None

Convert the given packed color to RGB.

property r

The red channel of this color.

static rgb2hsv(arg0: PyImath.C4c) → PyImath.C4c

Convert the given RGB color to HSV.

static rgb2packed(arg0: PyImath.C4c) → int

Convert the given RGB color to packed format.

class Imath.C4f

Bases: pybind11_object

class C4fIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.C4f) -> None

Initializes a color with all channels zero.

2. __init__(self: PyImath.C4f, value: object) -> None

Initializes a color from the given number of iterable.

3. __init__(self: PyImath.C4f, arg0: float, arg1: float, arg2: float, arg3: float) -> None

Initializes a color from RGBA values.

property a

The alpha channel of this color.

property b

The blue channel of this color.

static baseTypeEpsilon() → float

Returns a suitable epsilon for comparing values of the underlying component type.

static baseTypeLowest() → float

Returns the smallest value of the underlying component type.

static baseTypeMax() → float

Returns the largest value of the underlying component type.

static baseTypeSmallest() → float

Returns the smallest positive value of the underlying component type.

static dimensions() → int

property g

The green channel of this color.

static hsv2rgb(arg0: PyImath.C4f) → PyImath.C4f

Convert the given HSV color to RGB.

negate() → PyImath.C4f

Negates this color’s channels.

static packed2rgb(arg0: int, arg1: PyImath.C4f) → None

Convert the given packed color to RGB.

property r

The red channel of this color.

static rgb2hsv(arg0: PyImath.C4f) → PyImath.C4f

Convert the given RGB color to HSV.

static rgb2packed(arg0: PyImath.C4f) → int

Convert the given RGB color to packed format.

class Imath.C4h

Bases: pybind11_object

class C4hIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.C4h) -> None

Initializes a color with all channels zero.

2. __init__(self: PyImath.C4h, value: object) -> None

Initializes a color from the given number of iterable.

3. __init__(self: PyImath.C4h, arg0: Imath_3_1::half, arg1: Imath_3_1::half, arg2: Imath_3_1::half, arg3: Imath_3_1::half) -> None

Initializes a color from RGBA values.

property a

The alpha channel of this color.

property b

The blue channel of this color.

static baseTypeEpsilon() → Imath_3_1::half

Returns a suitable epsilon for comparing values of the underlying component type.

static baseTypeLowest() → Imath_3_1::half

Returns the smallest value of the underlying component type.

static baseTypeMax() → Imath_3_1::half

Returns the largest value of the underlying component type.

static baseTypeSmallest() → Imath_3_1::half

Returns the smallest positive value of the underlying component type.

static dimensions() → int

property g

The green channel of this color.

static hsv2rgb(arg0: PyImath.C4h) → PyImath.C4h

Convert the given HSV color to RGB.

negate() → PyImath.C4h

Negates this color’s channels.

static packed2rgb(arg0: int, arg1: PyImath.C4h) → None

Convert the given packed color to RGB.

property r

The red channel of this color.

static rgb2hsv(arg0: PyImath.C4h) → PyImath.C4h

Convert the given RGB color to HSV.

static rgb2packed(arg0: PyImath.C4h) → int

Convert the given RGB color to packed format.

class Imath.Eulerd

Bases: V3d

class Axis

Bases: pybind11_object

Members:

X

Y

Z

X = <Axis.X: 0>

Y = <Axis.Y: 1>

Z = <Axis.Z: 2>

__init__(value: int) → None

property name

property value

class InputLayout

Bases: pybind11_object

Members:

XYZLayout

IJKLayout

IJKLayout = <InputLayout.IJKLayout: 1>

XYZLayout = <InputLayout.XYZLayout: 0>

__init__(value: int) → None

property name

property value

class Order

Bases: pybind11_object

Members:

XYZ

XZY

YZX

YXZ

ZXY

ZYX

XZX

XYX

YXY

YZY

ZYZ

ZXZ

XYZr

XZYr

YZXr

YXZr

ZXYr

ZYXr

XZXr

XYXr

YXYr

YZYr

ZYZr

ZXZr

Legal

Min

Max

Default

Default = <Order.XYZ: 257>

Legal = <Order.Legal: 12561>

Max = <Order.ZXZ: 8465>

Min = <Order.ZXYr: 0>

XYX = <Order.XYX: 273>

XYXr = <Order.XYXr: 8208>

XYZ = <Order.XYZ: 257>

XYZr = <Order.XYZr: 8192>

XZX = <Order.XZX: 17>

XZXr = <Order.XZXr: 8464>

XZY = <Order.XZY: 1>

XZYr = <Order.XZYr: 8448>

YXY = <Order.YXY: 4113>

YXYr = <Order.YXYr: 4368>

YXZ = <Order.YXZ: 4097>

YXZr = <Order.YXZr: 4352>

YZX = <Order.YZX: 4353>

YZXr = <Order.YZXr: 4096>

YZY = <Order.YZY: 4369>

YZYr = <Order.YZYr: 4112>

ZXY = <Order.ZXY: 8449>

ZXYr = <Order.ZXYr: 0>

ZXZ = <Order.ZXZ: 8465>

ZXZr = <Order.ZXZr: 16>

ZYX = <Order.ZYX: 8193>

ZYXr = <Order.ZYXr: 256>

ZYZ = <Order.ZYZ: 8209>

ZYZr = <Order.ZYZr: 272>

__init__(value: int) → None

property name

property value

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Eulerd, order: PyImath.Eulerd.Order = <Order.XYZ: 257>) -> None

Initializes Euler angles with zero values and given order.

2. __init__(self: PyImath.Eulerd, vec: PyImath.V3d, order: PyImath.Eulerd.Order, layout: PyImath.Eulerd.InputLayout = <InputLayout.IJKLayout: 1>) -> None

Initializes Euler angles from the given vector, order and input data layout.

3. __init__(self: PyImath.Eulerd, x: float, y: float, z: float, order: PyImath.Eulerd.Order = <Order.XYZ: 257>, layout: PyImath.Eulerd.InputLayout = <InputLayout.IJKLayout: 1>) -> None

Initializes Euler angles from the three given scalars, read using the given order and layout.

4. __init__(self: PyImath.Eulerd, other: PyImath.Eulerd, order: PyImath.Eulerd.Order) -> None

Initializes Euler angles from another Euler angles object, using converting to the given order.

5. __init__(self: PyImath.Eulerd, mat: PyImath.M33d, order: PyImath.Eulerd.Order = <Order.XYZ: 257>) -> None

Initializes Euler angles from the given 3x3 matrix and order.

6. __init__(self: PyImath.Eulerd, mat: PyImath.M44d, order: PyImath.Eulerd.Order = <Order.XYZ: 257>) -> None

Initializes Euler angles from the given 4x4 matrix and order.

static angleMod(arg0: float) → float

Converts an angle to its equivalent in [-pi, pi].

angleOrder() → Tuple[int, int, int]

Returns a 3-tuple of axis indices for this Euler object.

extract(*args, **kwargs)

Overloaded function.

1. extract(self: PyImath.Eulerd, mat: PyImath.M33d) -> None

Sets the Euler values from the given 3x3 matrix. The given matrix must not contain shear or non-uniform scaling.

2. extract(self: PyImath.Eulerd, mat: PyImath.M44d) -> None

Sets the Euler values from the given 4x4 matrix. The given matrix must not contain shear or non-uniform scaling.

3. extract(self: PyImath.Eulerd, quat: Imath_3_1::Quat<double>) -> None

Sets the Euler values from the given quaternion.

property frameStatic

True if this Euler’s order is not a relative order.

property initialAxis

The initial Axis of this Euler.

property initialRepeated

True if this Euler’s order has a repeated axis.

static legal(order: PyImath.Eulerd.Order) → bool

Returns True if the given order is a legal permutation.

makeNear(arg0: PyImath.Eulerd) → None

Adjusts this Euler object so that its components differ from target by as little as possible. This method may not work correctly for Eulers with different orders, or repeated axes or relative orders.

static nearestRotation(xyzRot: PyImath.V3d, targetXyzRot: PyImath.V3d, order: PyImath.Eulerd.Order = <Order.XYZ: 257>) → 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.

property order

The order of thie Euler object.

property parityEven

True if this Euler’s order represents a right-handed coordinate system.

set(axis: PyImath.Eulerd.Axis, relative: bool, parityEven: bool, firstRepeats: bool) → None

Set the order of this Euler object.

setXYZVector(vec: PyImath.V3d) → None

Sets the values, reordering the input components if this Euler object is not XYZ-ordered.

static simpleXYZRotation(xyzRot: PyImath.V3d, targetXyzRot: PyImath.V3d) → None

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

toMatrix33() → PyImath.M33d

Converts this Euler object to a 3x3 matrix.

toMatrix44() → PyImath.M44d

Converts this Euler object to a 4x4 matrix.

toQuat() → Imath_3_1::Quat<double>

Converts this Euler object to a quaternion.

toXYZVector() → PyImath.V3d

Converts this Euler object to a vector, reordering the angles so that the x rotation comes first, followed by y and z. In cases like XYX ordering, the repeated angle will be in the z component.

class Imath.Eulerf

Bases: V3f

class Axis

Bases: pybind11_object

Members:

X

Y

Z

X = <Axis.X: 0>

Y = <Axis.Y: 1>

Z = <Axis.Z: 2>

__init__(value: int) → None

property name

property value

class InputLayout

Bases: pybind11_object

Members:

XYZLayout

IJKLayout

IJKLayout = <InputLayout.IJKLayout: 1>

XYZLayout = <InputLayout.XYZLayout: 0>

__init__(value: int) → None

property name

property value

class Order

Bases: pybind11_object

Members:

XYZ

XZY

YZX

YXZ

ZXY

ZYX

XZX

XYX

YXY

YZY

ZYZ

ZXZ

XYZr

XZYr

YZXr

YXZr

ZXYr

ZYXr

XZXr

XYXr

YXYr

YZYr

ZYZr

ZXZr

Legal

Min

Max

Default

Default = <Order.XYZ: 257>

Legal = <Order.Legal: 12561>

Max = <Order.ZXZ: 8465>

Min = <Order.ZXYr: 0>

XYX = <Order.XYX: 273>

XYXr = <Order.XYXr: 8208>

XYZ = <Order.XYZ: 257>

XYZr = <Order.XYZr: 8192>

XZX = <Order.XZX: 17>

XZXr = <Order.XZXr: 8464>

XZY = <Order.XZY: 1>

XZYr = <Order.XZYr: 8448>

YXY = <Order.YXY: 4113>

YXYr = <Order.YXYr: 4368>

YXZ = <Order.YXZ: 4097>

YXZr = <Order.YXZr: 4352>

YZX = <Order.YZX: 4353>

YZXr = <Order.YZXr: 4096>

YZY = <Order.YZY: 4369>

YZYr = <Order.YZYr: 4112>

ZXY = <Order.ZXY: 8449>

ZXYr = <Order.ZXYr: 0>

ZXZ = <Order.ZXZ: 8465>

ZXZr = <Order.ZXZr: 16>

ZYX = <Order.ZYX: 8193>

ZYXr = <Order.ZYXr: 256>

ZYZ = <Order.ZYZ: 8209>

ZYZr = <Order.ZYZr: 272>

__init__(value: int) → None

property name

property value

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Eulerf, order: PyImath.Eulerf.Order = <Order.XYZ: 257>) -> None

Initializes Euler angles with zero values and given order.

2. __init__(self: PyImath.Eulerf, vec: PyImath.V3f, order: PyImath.Eulerf.Order, layout: PyImath.Eulerf.InputLayout = <InputLayout.IJKLayout: 1>) -> None

Initializes Euler angles from the given vector, order and input data layout.

3. __init__(self: PyImath.Eulerf, x: float, y: float, z: float, order: PyImath.Eulerf.Order = <Order.XYZ: 257>, layout: PyImath.Eulerf.InputLayout = <InputLayout.IJKLayout: 1>) -> None

Initializes Euler angles from the three given scalars, read using the given order and layout.

4. __init__(self: PyImath.Eulerf, other: PyImath.Eulerf, order: PyImath.Eulerf.Order) -> None

Initializes Euler angles from another Euler angles object, using converting to the given order.

5. __init__(self: PyImath.Eulerf, mat: PyImath.M33f, order: PyImath.Eulerf.Order = <Order.XYZ: 257>) -> None

Initializes Euler angles from the given 3x3 matrix and order.

6. __init__(self: PyImath.Eulerf, mat: PyImath.M44f, order: PyImath.Eulerf.Order = <Order.XYZ: 257>) -> None

Initializes Euler angles from the given 4x4 matrix and order.

static angleMod(arg0: float) → float

Converts an angle to its equivalent in [-pi, pi].

angleOrder() → Tuple[int, int, int]

Returns a 3-tuple of axis indices for this Euler object.

extract(*args, **kwargs)

Overloaded function.

1. extract(self: PyImath.Eulerf, mat: PyImath.M33f) -> None

Sets the Euler values from the given 3x3 matrix. The given matrix must not contain shear or non-uniform scaling.

2. extract(self: PyImath.Eulerf, mat: PyImath.M44f) -> None

Sets the Euler values from the given 4x4 matrix. The given matrix must not contain shear or non-uniform scaling.

3. extract(self: PyImath.Eulerf, quat: Imath_3_1::Quat<float>) -> None

Sets the Euler values from the given quaternion.

property frameStatic

True if this Euler’s order is not a relative order.

property initialAxis

The initial Axis of this Euler.

property initialRepeated

True if this Euler’s order has a repeated axis.

static legal(order: PyImath.Eulerf.Order) → bool

Returns True if the given order is a legal permutation.

makeNear(arg0: PyImath.Eulerf) → None

Adjusts this Euler object so that its components differ from target by as little as possible. This method may not work correctly for Eulers with different orders, or repeated axes or relative orders.

static nearestRotation(xyzRot: PyImath.V3f, targetXyzRot: PyImath.V3f, order: PyImath.Eulerf.Order = <Order.XYZ: 257>) → 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.

property order

The order of thie Euler object.

property parityEven

True if this Euler’s order represents a right-handed coordinate system.

set(axis: PyImath.Eulerf.Axis, relative: bool, parityEven: bool, firstRepeats: bool) → None

Set the order of this Euler object.

setXYZVector(vec: PyImath.V3f) → None

Sets the values, reordering the input components if this Euler object is not XYZ-ordered.

static simpleXYZRotation(xyzRot: PyImath.V3f, targetXyzRot: PyImath.V3f) → None

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

toMatrix33() → PyImath.M33f

Converts this Euler object to a 3x3 matrix.

toMatrix44() → PyImath.M44f

Converts this Euler object to a 4x4 matrix.

toQuat() → Imath_3_1::Quat<float>

Converts this Euler object to a quaternion.

toXYZVector() → PyImath.V3f

Converts this Euler object to a vector, reordering the angles so that the x rotation comes first, followed by y and z. In cases like XYX ordering, the repeated angle will be in the z component.

class Imath.Frustumd

Bases: pybind11_object

DepthToZ(depth: float, zmin: int, zmax: int) → int

Unprojects a depth value for this frustum to a world-space z-coordinate.

ZToDepth(z: int, min: int, max: int) → float

Returns the projection of a z-coordinate to depth for this frustum.

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Frustumd) -> None

Initializes a default non-orthographic frustum with clip planes at [0.1, 1000.0] and bounding planes at +-1.0.

2. __init__(self: PyImath.Frustumd, other: PyImath.Frustumd) -> None

Initializes a Frustum by copying the given argument.

3. __init__(self: PyImath.Frustumd, nearPlane: float, farPlane: float, left: float, right: float, top: float, bottom: float, ortho: bool = False) -> None

Initializes a Frustum from the given planes.

4. __init__(self: PyImath.Frustumd, nearPlane: float, farPlane: float, fovx: float, fovy: float, aspect: float) -> None

Initializes a Frustum from the given clip planes, field of view and aspect ratio. Exactly one of fovx and fovy must be non-zero.

aspect() → float

Returns the aspect ratio of this frustum.

bottom() → float

Returns the distance to the bottom plane of this frustum.

farPlane() → float

Returns the distance to the far clip plane of this frustum.

fovx() → float

Returns the horizontal field of view of this frustum.

fovy() → float

Returns the vertical field of view of this frustum.

left() → float

Returns the distance to the left plane of this frustum.

modifyNearAndFar(nearPlane: float, farPlane: float) → None

Set the near and far clip planes of this frustum.

nearPlane() → float

Returns the distance to the near clip plane of this frustum.

normalizedZToDepth(z: float) → float

Returns the projectedof the given normalized z-coordinate by this frustum.

orthographic() → bool

Returns True if this frustum is orthographic.

projectPointToScreen(point: PyImath.V3d) → PyImath.V2d

Returns the projection of a world-space point to the screen-space of this frustum.

projectionMatrix() → PyImath.M44d

Returns the projection matrix defined by this frustum. If ortho() returns True, this will be an orthographic matrix; otherwise it will be a perspective matrix.

right() → float

Returns the distance to the right plane of this frustum.

screenRadius(point: PyImath.V3d, radius: float) → float

Returns the screen-space radius of a sphere of given world-space radius when projected using this frustum.

set(near: float, far: float, left: float, right: float, top: float, bottom: float, ortho: bool = False) → None

Set the planes of this Frustum.

setOrthographic(ortho: bool) → None

Sets whether this frustum is orthographic.

top() → float

Returns the distance to the top plane of this frustum.

window(left: float, right: float, top: float, bottom: float) → PyImath.Frustumd

Given a rectangle in screen-space of this frustum, returns a new frustum whose near clip plane is that rectangle in local space.

worldRadius(point: PyImath.V3d, radius: float) → float

Returns the world-space radius of a sphere of given screen-space radius when unprojected using this frustum.

class Imath.Frustumf

Bases: pybind11_object

DepthToZ(depth: float, zmin: int, zmax: int) → int

Unprojects a depth value for this frustum to a world-space z-coordinate.

ZToDepth(z: int, min: int, max: int) → float

Returns the projection of a z-coordinate to depth for this frustum.

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Frustumf) -> None

Initializes a default non-orthographic frustum with clip planes at [0.1, 1000.0] and bounding planes at +-1.0.

2. __init__(self: PyImath.Frustumf, other: PyImath.Frustumf) -> None

Initializes a Frustum by copying the given argument.

3. __init__(self: PyImath.Frustumf, nearPlane: float, farPlane: float, left: float, right: float, top: float, bottom: float, ortho: bool = False) -> None

Initializes a Frustum from the given planes.

4. __init__(self: PyImath.Frustumf, nearPlane: float, farPlane: float, fovx: float, fovy: float, aspect: float) -> None

Initializes a Frustum from the given clip planes, field of view and aspect ratio. Exactly one of fovx and fovy must be non-zero.

aspect() → float

Returns the aspect ratio of this frustum.

bottom() → float

Returns the distance to the bottom plane of this frustum.

farPlane() → float

Returns the distance to the far clip plane of this frustum.

fovx() → float

Returns the horizontal field of view of this frustum.

fovy() → float

Returns the vertical field of view of this frustum.

left() → float

Returns the distance to the left plane of this frustum.

modifyNearAndFar(nearPlane: float, farPlane: float) → None

Set the near and far clip planes of this frustum.

nearPlane() → float

Returns the distance to the near clip plane of this frustum.

normalizedZToDepth(z: float) → float

Returns the projectedof the given normalized z-coordinate by this frustum.

orthographic() → bool

Returns True if this frustum is orthographic.

projectPointToScreen(point: PyImath.V3f) → PyImath.V2f

Returns the projection of a world-space point to the screen-space of this frustum.

projectionMatrix() → PyImath.M44f

Returns the projection matrix defined by this frustum. If ortho() returns True, this will be an orthographic matrix; otherwise it will be a perspective matrix.

right() → float

Returns the distance to the right plane of this frustum.

screenRadius(point: PyImath.V3f, radius: float) → float

Returns the screen-space radius of a sphere of given world-space radius when projected using this frustum.

set(near: float, far: float, left: float, right: float, top: float, bottom: float, ortho: bool = False) → None

Set the planes of this Frustum.

setOrthographic(ortho: bool) → None

Sets whether this frustum is orthographic.

top() → float

Returns the distance to the top plane of this frustum.

window(left: float, right: float, top: float, bottom: float) → PyImath.Frustumf

Given a rectangle in screen-space of this frustum, returns a new frustum whose near clip plane is that rectangle in local space.

worldRadius(point: PyImath.V3f, radius: float) → float

Returns the world-space radius of a sphere of given screen-space radius when unprojected using this frustum.

class Imath.M33d

Bases: pybind11_object

class M33dIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.M33d) -> None

Initializes an identity matrix.

2. __init__(self: PyImath.M33d, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: float, arg8: float) -> None

3. __init__(self: PyImath.M33d, arg0: PyImath.M33f) -> None

4. __init__(self: PyImath.M33d, arg0: PyImath.M33d) -> None

5. __init__(self: PyImath.M33d, arg0: object, arg1: object, arg2: object) -> None

6. __init__(self: PyImath.M33d, arg0: object) -> None

static baseTypeEpsilon() → float

Returns a suitable epsilon value for comparing values of the underlying component type.

static baseTypeLowest() → float

Returns the smallest value that can be represented by the underling component type.

static baseTypeMax() → float

Returns the largest value that can be represented by the underling component type.

static baseTypeSmallest() → float

Returns the smallest positive value that can be represented by the underlying component type.

equalWithAbsError(other: PyImath.M33d, error: float) → bool

Returns True if this matrix equals other up to the given absolute error.

equalWithRelError(other: PyImath.M33d, error: float) → bool

Returns True if this matrix equals other up to the given relative error.

extractAndRemoveScalingAndShear(*args, **kwargs)

Overloaded function.

1. extractAndRemoveScalingAndShear(self: PyImath.M33d) -> Tuple[PyImath.V2d, float]

Removes scaling and shear from this matrix, returning their values as a 2-tuple.

2. extractAndRemoveScalingAndShear(self: PyImath.M33d, outScale: PyImath.V2d, outShear: float) -> bool

Remove scaling and shear from this matrix, returning their values in the given out-parameters.

extractEuler() → float

Extract and return Euler angles from this matrix. This 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, if necessary you should first call removeScalingAndShear().

extractSHRT(*args, **kwargs)

Overloaded function.

1. extractSHRT(self: PyImath.M33d, outScale: PyImath.V2d, outShear: float, outRotate: float, outTranslate: PyImath.V2d) -> bool

Extracts scaling, shear, rotation vector and translation from this matrix, returning their values in the corresponding out-parameters.

2. extractSHRT(self: PyImath.M33d) -> Tuple[PyImath.V2d, float, float, PyImath.V2d]

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

extractScaling(*args, **kwargs)

Overloaded function.

1. extractScaling(self: PyImath.M33d) -> PyImath.V2d

Returns the scaling component of this matrix.

2. extractScaling(self: PyImath.M33d, arg0: PyImath.V2d) -> bool

Returns the scaling component of this matrix.

extractScalingAndShear(*args, **kwargs)

Overloaded function.

1. extractScalingAndShear(self: PyImath.M33d) -> Tuple[PyImath.V2d, float]

Returns a 2-tuple containing the scaling and shear of this matrix.

2. extractScalingAndShear(self: PyImath.M33d, outScale: PyImath.V2d, outShear: float) -> bool

Extract scaling and shear from this matrix, returning them in the given out-parameters.

gjInverse(raise: bool = False) → PyImath.M33d

Returns the Gauss-Jordan inverse of this matrix, handling singular matrices as in gjInvert().

gjInvert(raise: bool = False) → PyImath.M33d

Invert this matrix using the slower but more precise Gauss-Jordan method. If this matrix is singular and raise is True, a RuntimeError is raised; otherwise, if raise if False, an identity matrix is set.

identity = M33d(1, 0, 0, 0, 1, 0, 0, 0, 1)

inverse(raise: bool = False) → PyImath.M33d

Returns the inverse of this matrix, handling singular matrices as in invert().

invert(raise: bool = False) → PyImath.M33d

Invert this matrix using a faster but less precise method. If this matrix is singular and raise is True, a RuntimeError is raised; otherwise, if raise is False, an identity matrix is set.

makeIdentity() → None

Sets this matrix to the identity.

multDirMatrix(*args, **kwargs)

Overloaded function.

1. multDirMatrix(self: PyImath.M33d, v: PyImath.V2d, vOut: PyImath.V2d) -> None

Multiply the direction v by this matrix, storing the result in vOut.

2. multDirMatrix(self: PyImath.M33d, v: PyImath.V2d) -> PyImath.V2d

Returns the result of multiplying the direction v by this matrix.

multVecMatrix(*args, **kwargs)

Overloaded function.

1. multVecMatrix(self: PyImath.M33d, v: PyImath.V2d, vOut: PyImath.V2d) -> None

Multiply the point v by this matrix, storing the result in vOut.

2. multVecMatrix(self: PyImath.M33d, v: PyImath.V2d) -> PyImath.V2d

Returns the result of multiplying the point v by this matrix.

negate() → PyImath.M33d

Negates this matrix.

removeScaling() → bool

Removes scaling from this matrix.

removeScalingAndShear() → bool

Removes scaling and shear from this matrix.

rotate(r: float) → PyImath.M33d

Cumulatively rotates this matrix by r (in radians).

sansScaling() → PyImath.M33d

Returns a copy of this matrix with scaling removed.

sansScalingAndShear() → PyImath.M33d

Returns a copy of this matrix with scaling and shear removed.

scale(s: PyImath.V2d) → PyImath.M33d

Sets this matrix to scale by the given vector.

setRotation(r: float) → PyImath.M33d

Sets the rotation component of this matrix to r (in radians).

setScale(*args, **kwargs)

Overloaded function.

1. setScale(self: PyImath.M33d, s: float) -> PyImath.M33d

Sets this matrix to scale by the given uniform factor.

2. setScale(self: PyImath.M33d, s: PyImath.V2d) -> PyImath.M33d

Sets this matrix to scale by the given uniform factor

setShear(*args, **kwargs)

Overloaded function.

1. setShear(self: PyImath.M33d, xy: float) -> PyImath.M33d

Sets the shear component of this matrix to shear both x- and y-components by xy.

2. setShear(self: PyImath.M33d, h: PyImath.V2d) -> PyImath.M33d

Sets the shear component of this matrix to shear x for each y-coord by h[0], and to shear y for each x-coord by h[1].

setTranslation(t: PyImath.V2d) → PyImath.M33d

Sets this matrix to translate by the given vector.

shear(*args, **kwargs)

Overloaded function.

1. shear(self: PyImath.M33d, xy: float) -> PyImath.M33d

Cumulatively applies shear xy to this matrix in both x and y directions.

2. shear(self: PyImath.M33d, h: PyImath.V2d) -> PyImath.M33d

Cumulatively shear this matrix in x for each y coord by given factor s[0], and shear y for each x coord by s[1].

toMatrix44() → PyImath.M44d

Returns a 4x4 matrix with this matrix as its upper-left 3x3 block, and other values taken from the 4x4 identity matrix.

translate(t: PyImath.V2d) → PyImath.M33d

Cumulatively translates this matrix by the given vector.

translation() → PyImath.V2d

Returns the translation component of this matrix.

transpose() → PyImath.M33d

Transpose this matrix.

transposed() → PyImath.M33d

Returns the transpose of this matrix.

class Imath.M33f

Bases: pybind11_object

class M33fIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.M33f) -> None

Initializes an identity matrix.

2. __init__(self: PyImath.M33f, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: float, arg8: float) -> None

3. __init__(self: PyImath.M33f, arg0: PyImath.M33f) -> None

4. __init__(self: PyImath.M33f, arg0: Imath_3_1::Matrix33<double>) -> None

5. __init__(self: PyImath.M33f, arg0: object, arg1: object, arg2: object) -> None

6. __init__(self: PyImath.M33f, arg0: object) -> None

static baseTypeEpsilon() → float

Returns a suitable epsilon value for comparing values of the underlying component type.

static baseTypeLowest() → float

Returns the smallest value that can be represented by the underling component type.

static baseTypeMax() → float

Returns the largest value that can be represented by the underling component type.

static baseTypeSmallest() → float

Returns the smallest positive value that can be represented by the underlying component type.

equalWithAbsError(other: PyImath.M33f, error: float) → bool

Returns True if this matrix equals other up to the given absolute error.

equalWithRelError(other: PyImath.M33f, error: float) → bool

Returns True if this matrix equals other up to the given relative error.

extractAndRemoveScalingAndShear(*args, **kwargs)

Overloaded function.

1. extractAndRemoveScalingAndShear(self: PyImath.M33f) -> Tuple[PyImath.V2f, float]

Removes scaling and shear from this matrix, returning their values as a 2-tuple.

2. extractAndRemoveScalingAndShear(self: PyImath.M33f, outScale: PyImath.V2f, outShear: float) -> bool

Remove scaling and shear from this matrix, returning their values in the given out-parameters.

extractEuler() → float

Extract and return Euler angles from this matrix. This 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, if necessary you should first call removeScalingAndShear().

extractSHRT(*args, **kwargs)

Overloaded function.

1. extractSHRT(self: PyImath.M33f, outScale: PyImath.V2f, outShear: float, outRotate: float, outTranslate: PyImath.V2f) -> bool

Extracts scaling, shear, rotation vector and translation from this matrix, returning their values in the corresponding out-parameters.

2. extractSHRT(self: PyImath.M33f) -> Tuple[PyImath.V2f, float, float, PyImath.V2f]

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

extractScaling(*args, **kwargs)

Overloaded function.

1. extractScaling(self: PyImath.M33f) -> PyImath.V2f

Returns the scaling component of this matrix.

2. extractScaling(self: PyImath.M33f, arg0: PyImath.V2f) -> bool

Returns the scaling component of this matrix.

extractScalingAndShear(*args, **kwargs)

Overloaded function.

1. extractScalingAndShear(self: PyImath.M33f) -> Tuple[PyImath.V2f, float]

Returns a 2-tuple containing the scaling and shear of this matrix.

2. extractScalingAndShear(self: PyImath.M33f, outScale: PyImath.V2f, outShear: float) -> bool

Extract scaling and shear from this matrix, returning them in the given out-parameters.

gjInverse(raise: bool = False) → PyImath.M33f

Returns the Gauss-Jordan inverse of this matrix, handling singular matrices as in gjInvert().

gjInvert(raise: bool = False) → PyImath.M33f

Invert this matrix using the slower but more precise Gauss-Jordan method. If this matrix is singular and raise is True, a RuntimeError is raised; otherwise, if raise if False, an identity matrix is set.

identity = M33f(1, 0, 0, 0, 1, 0, 0, 0, 1)

inverse(raise: bool = False) → PyImath.M33f

Returns the inverse of this matrix, handling singular matrices as in invert().

invert(raise: bool = False) → PyImath.M33f

Invert this matrix using a faster but less precise method. If this matrix is singular and raise is True, a RuntimeError is raised; otherwise, if raise is False, an identity matrix is set.

makeIdentity() → None

Sets this matrix to the identity.

multDirMatrix(*args, **kwargs)

Overloaded function.

1. multDirMatrix(self: PyImath.M33f, v: PyImath.V2f, vOut: PyImath.V2f) -> None

Multiply the direction v by this matrix, storing the result in vOut.

2. multDirMatrix(self: PyImath.M33f, v: PyImath.V2f) -> PyImath.V2f

Returns the result of multiplying the direction v by this matrix.

multVecMatrix(*args, **kwargs)

Overloaded function.

1. multVecMatrix(self: PyImath.M33f, v: PyImath.V2f, vOut: PyImath.V2f) -> None

Multiply the point v by this matrix, storing the result in vOut.

2. multVecMatrix(self: PyImath.M33f, v: PyImath.V2f) -> PyImath.V2f

Returns the result of multiplying the point v by this matrix.

negate() → PyImath.M33f

Negates this matrix.

removeScaling() → bool

Removes scaling from this matrix.

removeScalingAndShear() → bool

Removes scaling and shear from this matrix.

rotate(r: float) → PyImath.M33f

Cumulatively rotates this matrix by r (in radians).

sansScaling() → PyImath.M33f

Returns a copy of this matrix with scaling removed.

sansScalingAndShear() → PyImath.M33f

Returns a copy of this matrix with scaling and shear removed.

scale(s: PyImath.V2f) → PyImath.M33f

Sets this matrix to scale by the given vector.

setRotation(r: float) → PyImath.M33f

Sets the rotation component of this matrix to r (in radians).

setScale(*args, **kwargs)

Overloaded function.

1. setScale(self: PyImath.M33f, s: float) -> PyImath.M33f

Sets this matrix to scale by the given uniform factor.

2. setScale(self: PyImath.M33f, s: PyImath.V2f) -> PyImath.M33f

Sets this matrix to scale by the given uniform factor

setShear(*args, **kwargs)

Overloaded function.

1. setShear(self: PyImath.M33f, xy: float) -> PyImath.M33f

Sets the shear component of this matrix to shear both x- and y-components by xy.

2. setShear(self: PyImath.M33f, h: PyImath.V2f) -> PyImath.M33f

Sets the shear component of this matrix to shear x for each y-coord by h[0], and to shear y for each x-coord by h[1].

setTranslation(t: PyImath.V2f) → PyImath.M33f

Sets this matrix to translate by the given vector.

shear(*args, **kwargs)

Overloaded function.

1. shear(self: PyImath.M33f, xy: float) -> PyImath.M33f

Cumulatively applies shear xy to this matrix in both x and y directions.

2. shear(self: PyImath.M33f, h: PyImath.V2f) -> PyImath.M33f

Cumulatively shear this matrix in x for each y coord by given factor s[0], and shear y for each x coord by s[1].

toMatrix44() → PyImath.M44f

Returns a 4x4 matrix with this matrix as its upper-left 3x3 block, and other values taken from the 4x4 identity matrix.

translate(t: PyImath.V2f) → PyImath.M33f

Cumulatively translates this matrix by the given vector.

translation() → PyImath.V2f

Returns the translation component of this matrix.

transpose() → PyImath.M33f

Transpose this matrix.

transposed() → PyImath.M33f

Returns the transpose of this matrix.

class Imath.M44d

Bases: pybind11_object

class M44dIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.M44d) -> None

Initializes an identity matrix.

2. __init__(self: PyImath.M44d, mat: Imath_3_1::Matrix33<double>, vec: PyImath.V3d) -> None

Initializes a 4x4 matrix from a 3x3 matrix and column vector.

3. __init__(self: PyImath.M44d, arg0: PyImath.M44f) -> None

4. __init__(self: PyImath.M44d, arg0: PyImath.M44d) -> None

5. __init__(self: PyImath.M44d, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: float, arg8: float, arg9: float, arg10: float, arg11: float, arg12: float, arg13: float, arg14: float, arg15: float) -> None

6. __init__(self: PyImath.M44d, col0: object, col1: object, col2: object, col3: object) -> None

Initializes a 4x4 from four iterables, viewed as column vectors.

7. __init__(self: PyImath.M44d, iter: object) -> None

Initializes a 4x4 matrix from an iterable.

static alignZAxisWithTargetDir(arg0: PyImath.V3d, arg1: PyImath.V3d) → PyImath.M44d

Returns a matrix that rotates the z-axis so that it points towards targetDir. You must also specify the up vector upDir.

The following degenerate cases are handled:

• when toDir and upDir are parallel or opposite;

• when any of the given vectors have zero length.

static baseTypeEpsilon() → float

Returns a suitable epsilon value for comparing values of the underlying component type.

static baseTypeLowest() → float

Returns the smallest value that can be represented by the underling component type.

static baseTypeMax() → float

Returns the largest value that can be represented by the underling component type.

static baseTypeSmallest() → float

Returns the smallest positive value that can be represented by the underlying component type.

equalWithAbsError(other: PyImath.M44d, error: float) → bool

Returns True if this matrix equals other up to the given absolute error.

equalWithRelError(other: PyImath.M44d, error: float) → bool

Returns True if this matrix equals other up to the given relative error.

extractAndRemoveScalingAndShear(*args, **kwargs)

Overloaded function.

1. extractAndRemoveScalingAndShear(self: PyImath.M44d) -> Tuple[PyImath.V3d, PyImath.V3d]

Removes scaling and shear from this matrix, returning their values as a 2-tuple.

2. extractAndRemoveScalingAndShear(self: PyImath.M44d, outScale: PyImath.V3d, outShear: PyImath.V3d) -> bool

Removes scaling and shear from this matrix, returning their values in out-parameters outScale and outShear.

extractEulerXYZ(*args, **kwargs)

Overloaded function.

1. extractEulerXYZ(self: PyImath.M44d, outAngles: PyImath.V3d) -> None

Extracts XYZ Euler angles from this matrix to outAngles. 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, if necessary you should first call removeScalingAndShear().

2. extractEulerXYZ(self: PyImath.M44d) -> PyImath.V3d

Returns the XYZ Euler angles from this matrix.

extractEulerZYX(*args, **kwargs)

Overloaded function.

1. extractEulerZYX(self: PyImath.M44d, outAngles: PyImath.V3d) -> None

As extractEulerXYZ but with reversed rotation order.

2. extractEulerZYX(self: PyImath.M44d) -> PyImath.V3d

As extractEulerXYZ but with reserved rotation order.

extractQuat() → Imath_3_1::Quat<double>

Returns a quaternion extracted from this matrix. See extractEulerXYZ() for assumptions.

extractSHRT(*args, **kwargs)

Overloaded function.

1. extractSHRT(self: PyImath.M44d, outScale: PyImath.V3d, outShear: PyImath.V3d, outRotate: PyImath.V3d, outTranslate: PyImath.V3d, order: Imath_3_1::Euler<double>::Order) -> bool

Extracts scaling, shearing, rotation vector, and translation to the corresponding out-parameters.

2. extractSHRT(self: PyImath.M44d) -> Tuple[PyImath.V3d, PyImath.V3d, Imath_3_1::Euler<double>, PyImath.V3d]

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

3. extractSHRT(self: PyImath.M44d, order: Imath_3_1::Euler<double>::Order) -> Tuple[PyImath.V3d, PyImath.V3d, PyImath.V3d, PyImath.V3d]

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

4. extractSHRT(self: PyImath.M44d, outScale: PyImath.V3d, outShear: PyImath.V3d, outRotate: PyImath.V3d, outTranslate: PyImath.V3d) -> bool

Extracts scaling, shearing, rotation vector and translation to the corresponding out-parameters.

5. extractSHRT(self: PyImath.M44d, outScale: PyImath.V3d, outShear: PyImath.V3d, outRotate: Imath_3_1::Euler<double>, outTranslate: PyImath.V3d) -> bool

Extracts scaling, shearing, Euler angles of default order, and translation to the corresponding out-parameters.

extractScaling(*args, **kwargs)

Overloaded function.

1. extractScaling(self: PyImath.M44d) -> PyImath.V3d

Returns the scaling component of this matrix.

2. extractScaling(self: PyImath.M44d, arg0: PyImath.V3d) -> bool

Returns the scaling component of this matrix.

extractScalingAndShear(*args, **kwargs)

Overloaded function.

1. extractScalingAndShear(self: PyImath.M44d) -> Tuple[PyImath.V3d, PyImath.V3d]

Returns a 2-tuple containing the scaling and shear of this matrix.

2. extractScalingAndShear(self: PyImath.M44d, outScale: PyImath.V3d, outShear: PyImath.V3d) -> bool

Returns the scaling and shear of this matrix in out-parameters outScale and outShear

gjInverse(raise: bool = False) → PyImath.M44d

Returns the Gauss-Jordan inverse of this matrix, handling singular matrices as in gjInvert().

gjInvert(raise: bool = False) → PyImath.M44d

Invert this matrix using the slower but more precise Gauss-Jordan method. If this matrix is singular and raise is True, a RuntimeError is raised; otherwise, if raise if False, an identity matrix is set.

identity = M44d(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)

inverse(raise: bool = False) → PyImath.M44d

Returns the inverse of this matrix, handling singular matrices as in invert().

invert(raise: bool = False) → PyImath.M44d

Invert this matrix using a faster but less precise method. If this matrix is singular and raise is True, a RuntimeError is raised; otherwise, if raise is False, an identity matrix is set.

makeIdentity() → None

Sets this matrix to the identity.

multDirMatrix(*args, **kwargs)

Overloaded function.

1. multDirMatrix(self: PyImath.M44d, v: PyImath.V3d, vOut: PyImath.V3d) -> None

Multiply the direction v by this matrix, storing the result in vOut.

2. multDirMatrix(self: PyImath.M44d, v: PyImath.V3d) -> PyImath.V3d

Returns the result of multiplying the direction v by this matrix.

multVecMatrix(*args, **kwargs)

Overloaded function.

1. multVecMatrix(self: PyImath.M44d, v: PyImath.V3d, vOut: PyImath.V3d) -> None

Multiply the point v by this matrix, storing the result in vOut.

2. multVecMatrix(self: PyImath.M44d, v: PyImath.V3d) -> PyImath.V3d

Returns the result of multiplying the point v by this matrix.

static multiply(*args, **kwargs)

Overloaded function.

1. multiply(a: PyImath.M44d, b: PyImath.M44d, out: PyImath.M44d) -> None

Multiplies matrix a by matrix b and stores the result in out.

2. multiply(a: PyImath.M44d, b: PyImath.M44d) -> PyImath.M44d

Multiplies matrix a with matrix b and returns the result.

negate() → PyImath.M44d

Negates this matrix.

removeScaling() → bool

Removes scaling from this matrix.

removeScalingAndShear() → bool

Removes scaling and shear from this matrix.

rotate(angles: PyImath.V3d) → PyImath.M44d

Cumulatively rotate this matrix by the given XYZ Euler angles (in radians).

static rotationMatrix(fromDir: PyImath.V3d, toDir: PyImath.V3d) → PyImath.M44d

Returns a matrix that rotates fromDir to toDir.

static rotationMatrixWithUpDir(fromDir: PyImath.V3d, toDir: PyImath.V3d, upDir: PyImath.V3d) → PyImath.M44d

Returns a matrix that rotates fromDir so that it points towards toDir, with a given upDir.

sansScaling() → PyImath.M44d

Returns a copy of this matrix with scaling removed.

sansScalingAndShear() → PyImath.M44d

Returns a copy of this matrix with scaling and shear removed.

scale(s: PyImath.V3d) → PyImath.M44d

Sets this matrix to scale by the given vector.

setAxisAngle(axis: PyImath.V3d, angle: float) → PyImath.M44d

Sets the rotation component of this matrix using the given axis and angle (in radians).

setEulerAngles(angles: PyImath.V3d) → PyImath.M44d

Sets the rotation component of this matrix to the given XYZ Euler angles (in radians).

setScale(*args, **kwargs)

Overloaded function.

1. setScale(self: PyImath.M44d, s: float) -> PyImath.M44d

Sets this matrix to scale by the given uniform factor.

2. setScale(self: PyImath.M44d, s: PyImath.V3d) -> PyImath.M44d

Sets this matrix to scale by the given uniform factor

setShear(h: PyImath.V3d) → PyImath.M44d

Sets the shear component of this matrix to the given vector. The resulting matrix will:

• shear x for each y-coord by a factor of h[0];

• shear x for each z-coord by a factor of h[1];

• shear y for each z-coord by a factor of h[2].

setTranslation(t: PyImath.V3d) → PyImath.M44d

Sets this matrix to translate by the given vector.

shear(arg0: PyImath.V3d) → PyImath.M44d

Precomposes this matrix with a shearing matrix that will:

• shear x for each y coord. by a factor of h[0];

• shear x for each z coord. by a factor of h[1];

• shear y for each z coord. by a factor of h[2].

toMatrix33() → Imath_3_1::Matrix33<double>

Returns the upper-left 3x3 matrix.

translate(t: PyImath.V3d) → PyImath.M44d

Cumulatively translates this matrix by the given vector.

translation() → PyImath.V3d

Returns the translation component of this matrix.

transpose() → PyImath.M44d

Transpose this matrix.

transposed() → PyImath.M44d

Returns the transpose of this matrix.

class Imath.M44f

Bases: pybind11_object

class M44fIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.M44f) -> None

Initializes an identity matrix.

2. __init__(self: PyImath.M44f, mat: Imath_3_1::Matrix33<float>, vec: PyImath.V3f) -> None

Initializes a 4x4 matrix from a 3x3 matrix and column vector.

3. __init__(self: PyImath.M44f, arg0: PyImath.M44f) -> None

4. __init__(self: PyImath.M44f, arg0: Imath_3_1::Matrix44<double>) -> None

5. __init__(self: PyImath.M44f, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float, arg7: float, arg8: float, arg9: float, arg10: float, arg11: float, arg12: float, arg13: float, arg14: float, arg15: float) -> None

6. __init__(self: PyImath.M44f, col0: object, col1: object, col2: object, col3: object) -> None

Initializes a 4x4 from four iterables, viewed as column vectors.

7. __init__(self: PyImath.M44f, iter: object) -> None

Initializes a 4x4 matrix from an iterable.

static alignZAxisWithTargetDir(arg0: PyImath.V3f, arg1: PyImath.V3f) → PyImath.M44f

Returns a matrix that rotates the z-axis so that it points towards targetDir. You must also specify the up vector upDir.

The following degenerate cases are handled:

• when toDir and upDir are parallel or opposite;

• when any of the given vectors have zero length.

static baseTypeEpsilon() → float

Returns a suitable epsilon value for comparing values of the underlying component type.

static baseTypeLowest() → float

Returns the smallest value that can be represented by the underling component type.

static baseTypeMax() → float

Returns the largest value that can be represented by the underling component type.

static baseTypeSmallest() → float

Returns the smallest positive value that can be represented by the underlying component type.

equalWithAbsError(other: PyImath.M44f, error: float) → bool

Returns True if this matrix equals other up to the given absolute error.

equalWithRelError(other: PyImath.M44f, error: float) → bool

Returns True if this matrix equals other up to the given relative error.

extractAndRemoveScalingAndShear(*args, **kwargs)

Overloaded function.

1. extractAndRemoveScalingAndShear(self: PyImath.M44f) -> Tuple[PyImath.V3f, PyImath.V3f]

Removes scaling and shear from this matrix, returning their values as a 2-tuple.

2. extractAndRemoveScalingAndShear(self: PyImath.M44f, outScale: PyImath.V3f, outShear: PyImath.V3f) -> bool

Removes scaling and shear from this matrix, returning their values in out-parameters outScale and outShear.

extractEulerXYZ(*args, **kwargs)

Overloaded function.

1. extractEulerXYZ(self: PyImath.M44f, outAngles: PyImath.V3f) -> None

Extracts XYZ Euler angles from this matrix to outAngles. 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, if necessary you should first call removeScalingAndShear().

2. extractEulerXYZ(self: PyImath.M44f) -> PyImath.V3f

Returns the XYZ Euler angles from this matrix.

extractEulerZYX(*args, **kwargs)

Overloaded function.

1. extractEulerZYX(self: PyImath.M44f, outAngles: PyImath.V3f) -> None

As extractEulerXYZ but with reversed rotation order.

2. extractEulerZYX(self: PyImath.M44f) -> PyImath.V3f

As extractEulerXYZ but with reserved rotation order.

extractQuat() → Imath_3_1::Quat<float>

Returns a quaternion extracted from this matrix. See extractEulerXYZ() for assumptions.

extractSHRT(*args, **kwargs)

Overloaded function.

1. extractSHRT(self: PyImath.M44f, outScale: PyImath.V3f, outShear: PyImath.V3f, outRotate: PyImath.V3f, outTranslate: PyImath.V3f, order: Imath_3_1::Euler<float>::Order) -> bool

Extracts scaling, shearing, rotation vector, and translation to the corresponding out-parameters.

2. extractSHRT(self: PyImath.M44f) -> Tuple[PyImath.V3f, PyImath.V3f, Imath_3_1::Euler<float>, PyImath.V3f]

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

3. extractSHRT(self: PyImath.M44f, order: Imath_3_1::Euler<float>::Order) -> Tuple[PyImath.V3f, PyImath.V3f, PyImath.V3f, PyImath.V3f]

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

4. extractSHRT(self: PyImath.M44f, outScale: PyImath.V3f, outShear: PyImath.V3f, outRotate: PyImath.V3f, outTranslate: PyImath.V3f) -> bool

Extracts scaling, shearing, rotation vector and translation to the corresponding out-parameters.

5. extractSHRT(self: PyImath.M44f, outScale: PyImath.V3f, outShear: PyImath.V3f, outRotate: Imath_3_1::Euler<float>, outTranslate: PyImath.V3f) -> bool

Extracts scaling, shearing, Euler angles of default order, and translation to the corresponding out-parameters.

extractScaling(*args, **kwargs)

Overloaded function.

1. extractScaling(self: PyImath.M44f) -> PyImath.V3f

Returns the scaling component of this matrix.

2. extractScaling(self: PyImath.M44f, arg0: PyImath.V3f) -> bool

Returns the scaling component of this matrix.

extractScalingAndShear(*args, **kwargs)

Overloaded function.

1. extractScalingAndShear(self: PyImath.M44f) -> Tuple[PyImath.V3f, PyImath.V3f]

Returns a 2-tuple containing the scaling and shear of this matrix.

2. extractScalingAndShear(self: PyImath.M44f, outScale: PyImath.V3f, outShear: PyImath.V3f) -> bool

Returns the scaling and shear of this matrix in out-parameters outScale and outShear

gjInverse(raise: bool = False) → PyImath.M44f

Returns the Gauss-Jordan inverse of this matrix, handling singular matrices as in gjInvert().

gjInvert(raise: bool = False) → PyImath.M44f

Invert this matrix using the slower but more precise Gauss-Jordan method. If this matrix is singular and raise is True, a RuntimeError is raised; otherwise, if raise if False, an identity matrix is set.

identity = M44f(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1)

inverse(raise: bool = False) → PyImath.M44f

Returns the inverse of this matrix, handling singular matrices as in invert().

invert(raise: bool = False) → PyImath.M44f

Invert this matrix using a faster but less precise method. If this matrix is singular and raise is True, a RuntimeError is raised; otherwise, if raise is False, an identity matrix is set.

makeIdentity() → None

Sets this matrix to the identity.

multDirMatrix(*args, **kwargs)

Overloaded function.

1. multDirMatrix(self: PyImath.M44f, v: PyImath.V3f, vOut: PyImath.V3f) -> None

Multiply the direction v by this matrix, storing the result in vOut.

2. multDirMatrix(self: PyImath.M44f, v: PyImath.V3f) -> PyImath.V3f

Returns the result of multiplying the direction v by this matrix.

multVecMatrix(*args, **kwargs)

Overloaded function.

1. multVecMatrix(self: PyImath.M44f, v: PyImath.V3f, vOut: PyImath.V3f) -> None

Multiply the point v by this matrix, storing the result in vOut.

2. multVecMatrix(self: PyImath.M44f, v: PyImath.V3f) -> PyImath.V3f

Returns the result of multiplying the point v by this matrix.

static multiply(*args, **kwargs)

Overloaded function.

1. multiply(a: PyImath.M44f, b: PyImath.M44f, out: PyImath.M44f) -> None

Multiplies matrix a by matrix b and stores the result in out.

2. multiply(a: PyImath.M44f, b: PyImath.M44f) -> PyImath.M44f

Multiplies matrix a with matrix b and returns the result.

negate() → PyImath.M44f

Negates this matrix.

removeScaling() → bool

Removes scaling from this matrix.

removeScalingAndShear() → bool

Removes scaling and shear from this matrix.

rotate(angles: PyImath.V3f) → PyImath.M44f

Cumulatively rotate this matrix by the given XYZ Euler angles (in radians).

static rotationMatrix(fromDir: PyImath.V3f, toDir: PyImath.V3f) → PyImath.M44f

Returns a matrix that rotates fromDir to toDir.

static rotationMatrixWithUpDir(fromDir: PyImath.V3f, toDir: PyImath.V3f, upDir: PyImath.V3f) → PyImath.M44f

Returns a matrix that rotates fromDir so that it points towards toDir, with a given upDir.

sansScaling() → PyImath.M44f

Returns a copy of this matrix with scaling removed.

sansScalingAndShear() → PyImath.M44f

Returns a copy of this matrix with scaling and shear removed.

scale(s: PyImath.V3f) → PyImath.M44f

Sets this matrix to scale by the given vector.

setAxisAngle(axis: PyImath.V3f, angle: float) → PyImath.M44f

Sets the rotation component of this matrix using the given axis and angle (in radians).

setEulerAngles(angles: PyImath.V3f) → PyImath.M44f

Sets the rotation component of this matrix to the given XYZ Euler angles (in radians).

setScale(*args, **kwargs)

Overloaded function.

1. setScale(self: PyImath.M44f, s: float) -> PyImath.M44f

Sets this matrix to scale by the given uniform factor.

2. setScale(self: PyImath.M44f, s: PyImath.V3f) -> PyImath.M44f

Sets this matrix to scale by the given uniform factor

setShear(h: PyImath.V3f) → PyImath.M44f

Sets the shear component of this matrix to the given vector. The resulting matrix will:

• shear x for each y-coord by a factor of h[0];

• shear x for each z-coord by a factor of h[1];

• shear y for each z-coord by a factor of h[2].

setTranslation(t: PyImath.V3f) → PyImath.M44f

Sets this matrix to translate by the given vector.

shear(arg0: PyImath.V3f) → PyImath.M44f

Precomposes this matrix with a shearing matrix that will:

• shear x for each y coord. by a factor of h[0];

• shear x for each z coord. by a factor of h[1];

• shear y for each z coord. by a factor of h[2].

toMatrix33() → Imath_3_1::Matrix33<float>

Returns the upper-left 3x3 matrix.

translate(t: PyImath.V3f) → PyImath.M44f

Cumulatively translates this matrix by the given vector.

translation() → PyImath.V3f

Returns the translation component of this matrix.

transpose() → PyImath.M44f

Transpose this matrix.

transposed() → PyImath.M44f

Returns the transpose of this matrix.

class Imath.Quatd

Bases: pybind11_object

class QuatdIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Quatd) -> None

Initializes a quaternion to the real unit 1.0.

2. __init__(self: PyImath.Quatd, r: float, vx: float, vy: float, vz: float) -> None

Initializes a quaternion from the given scalars.

3. __init__(self: PyImath.Quatd, r: float, v: PyImath.V3d) -> None

Initializes a quaternion from a scalar and vector.

4. __init__(self: PyImath.Quatd, iter: object) -> None

Initializes a quaternion from an iterable.

property angle

property axis

exp() → PyImath.Quatd

Returns the exponential of this quaternion.

identity = Quatd(1, 0, 0, 0)

intermediate(qa: PyImath.Quatd, qb: PyImath.Quatd) → PyImath.Quatd

Computes the intermediate of self with respect to qa and qb.

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

inverse() → PyImath.Quatd

Returns the inverse of this quaternion.

invert() → PyImath.Quatd

Invert this quaternion.

length() → float

Returns the length of this quaternion.

log() → PyImath.Quatd

Returns the logarithm of this quaternion.

normalize() → PyImath.Quatd

Normalize thie quaternion.

normalized() → PyImath.Quatd

Returns a copy of this quaternion that has been normalized.

property r

The real part of this quaternion.

setAxisAngle(axis: PyImath.V3d, angle: float) → PyImath.Quatd

Sets this quaternion from the given axis and angle.

setRotation(fromDir: PyImath.V3d, toDir: PyImath.V3d) → PyImath.Quatd

Sets this quaternion so that it rotates from fromDir to toDir.

slerp(q2: PyImath.Quatd, t: float) → PyImath.Quatd

Computes the spherical linear interpolation of this quaternion and q2 by factor t.

NOTE: Assumes self and q2 are normalized and that 0 <= t <= 1.

This method does not interpolate along the shortest arc between self 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.

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

Computes the spherical cubic spline iterpolation of self with respect to q1, q2 and q3 at parameter t.

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: self, 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 continuityof 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 self is from the previous adjacent segment and q3 is from the next adjacent segment. The self and q3 are used in computing qa and qb.

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

Computes the spherical quadrangle interpolation of self with respect to qa, qb and q2.

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.

toMatrix33() → PyImath.M33d

Convert this quaternion to a 3x3 rotation matrix.

toMatrix44() → PyImath.M44d

Convert this quaternion to a 4x4 rotation matrix.

property v

The imaginary part of this quaternion.

class Imath.Quatf

Bases: pybind11_object

class QuatfIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.Quatf) -> None

Initializes a quaternion to the real unit 1.0.

2. __init__(self: PyImath.Quatf, r: float, vx: float, vy: float, vz: float) -> None

Initializes a quaternion from the given scalars.

3. __init__(self: PyImath.Quatf, r: float, v: PyImath.V3f) -> None

Initializes a quaternion from a scalar and vector.

4. __init__(self: PyImath.Quatf, iter: object) -> None

Initializes a quaternion from an iterable.

property angle

property axis

exp() → PyImath.Quatf

Returns the exponential of this quaternion.

identity = Quatf(1, 0, 0, 0)

intermediate(qa: PyImath.Quatf, qb: PyImath.Quatf) → PyImath.Quatf

Computes the intermediate of self with respect to qa and qb.

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

inverse() → PyImath.Quatf

Returns the inverse of this quaternion.

invert() → PyImath.Quatf

Invert this quaternion.

length() → float

Returns the length of this quaternion.

log() → PyImath.Quatf

Returns the logarithm of this quaternion.

normalize() → PyImath.Quatf

Normalize thie quaternion.

normalized() → PyImath.Quatf

Returns a copy of this quaternion that has been normalized.

property r

The real part of this quaternion.

setAxisAngle(axis: PyImath.V3f, angle: float) → PyImath.Quatf

Sets this quaternion from the given axis and angle.

setRotation(fromDir: PyImath.V3f, toDir: PyImath.V3f) → PyImath.Quatf

Sets this quaternion so that it rotates from fromDir to toDir.

slerp(q2: PyImath.Quatf, t: float) → PyImath.Quatf

Computes the spherical linear interpolation of this quaternion and q2 by factor t.

NOTE: Assumes self and q2 are normalized and that 0 <= t <= 1.

This method does not interpolate along the shortest arc between self 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.

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

Computes the spherical cubic spline iterpolation of self with respect to q1, q2 and q3 at parameter t.

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: self, 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 continuityof 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 self is from the previous adjacent segment and q3 is from the next adjacent segment. The self and q3 are used in computing qa and qb.

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

Computes the spherical quadrangle interpolation of self with respect to qa, qb and q2.

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.

toMatrix33() → PyImath.M33f

Convert this quaternion to a 3x3 rotation matrix.

toMatrix44() → PyImath.M44f

Convert this quaternion to a 4x4 rotation matrix.

property v

The imaginary part of this quaternion.

class Imath.V2d

Bases: pybind11_object

class V2dIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.V2d) -> None

Initializes a vector with zero values.

2. __init__(self: PyImath.V2d, value: float) -> None

Initializes a vector with all components set to the given value.

3. __init__(self: PyImath.V2d, iter: object) -> None

Initializes a vector from an iterable.

4. __init__(self: PyImath.V2d, x: float, y: float) -> None

Initializes a vector from the given x and y components.

5. __init__(self: PyImath.V2d, arg0: PyImath.V2d) -> None

6. __init__(self: PyImath.V2d, arg0: Imath_3_1::Vec2<float>) -> None

7. __init__(self: PyImath.V2d, arg0: Imath_3_1::Vec2<int>) -> None

8. __init__(self: PyImath.V2d, arg0: Imath_3_1::Vec2<short>) -> None

static baseTypeEpsilon() → float

Returns an epsilon value suitable for comparing values of the underlying component type.

static baseTypeLowest() → float

Returns the smallest value that can be represented by the underlying component type.

static baseTypeMax() → float

Returns the largest value that can be represented by the underlying component type.

static baseTypeSmallest() → float

Returns the smallest positive value that can be represented by the underlying component type.

closestVertex(v1: PyImath.V2d, v2: PyImath.V2d, p: PyImath.V2d) → PyImath.V2d

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

cross(other: PyImath.V2d) → float

Returns the cross product of this vector and other.

static dimensions() → int

Returns the number of components in this vector type.

dot(other: PyImath.V2d) → float

Returns the dot product of this vector and other.

equalWithAbsError(other: PyImath.V2d, error: float) → bool

Returns True if this vector equals other, up to the given absolute error.

equalWithRelError(other: PyImath.V2d, error: float) → bool

Returns True if this vector equals other, up to the given relative error.

length() → float

Computes the length of this vector.

length2() → float

Computes the squared length of this vector.

negate() → PyImath.V2d

Negate this vector.

normalize() → PyImath.V2d

Normalize this vector. Sets a null vector if length is zero.

normalizeExc() → PyImath.V2d

Normalize this vector, raising a RuntimeError if length is zero.

normalizeNonNull() → PyImath.V2d

Equivalent to self.normalize().

normalized() → PyImath.V2d

Returns a normalized version of this vector, or a null vector if length is zero.

normalizedExc() → PyImath.V2d

Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

normalizedNonNull() → PyImath.V2d

Equivalent to self.normalized().

orthogonal(t: PyImath.V2d) → PyImath.V2d

Returns a vector which is perpendicular to this vector and in the same plane as t.

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

Returns the projection of the vector s onto the vector t.

projection(s: PyImath.V2d) → PyImath.V2d

Returns the projection of this vector onto s.

reflect(t: PyImath.V2d) → PyImath.V2d

Returns the result of reflecting this vector in the plane with normal t.

property x

The x component of this vector.

property y

The y component of this vector.

class Imath.V2f

Bases: pybind11_object

class V2fIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.V2f) -> None

Initializes a vector with zero values.

2. __init__(self: PyImath.V2f, value: float) -> None

Initializes a vector with all components set to the given value.

3. __init__(self: PyImath.V2f, iter: object) -> None

Initializes a vector from an iterable.

4. __init__(self: PyImath.V2f, x: float, y: float) -> None

Initializes a vector from the given x and y components.

5. __init__(self: PyImath.V2f, arg0: PyImath.V2d) -> None

6. __init__(self: PyImath.V2f, arg0: PyImath.V2f) -> None

7. __init__(self: PyImath.V2f, arg0: Imath_3_1::Vec2<int>) -> None

8. __init__(self: PyImath.V2f, arg0: Imath_3_1::Vec2<short>) -> None

static baseTypeEpsilon() → float

Returns an epsilon value suitable for comparing values of the underlying component type.

static baseTypeLowest() → float

Returns the smallest value that can be represented by the underlying component type.

static baseTypeMax() → float

Returns the largest value that can be represented by the underlying component type.

static baseTypeSmallest() → float

Returns the smallest positive value that can be represented by the underlying component type.

closestVertex(v1: PyImath.V2f, v2: PyImath.V2f, p: PyImath.V2f) → PyImath.V2f

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

cross(other: PyImath.V2f) → float

Returns the cross product of this vector and other.

static dimensions() → int

Returns the number of components in this vector type.

dot(other: PyImath.V2f) → float

Returns the dot product of this vector and other.

equalWithAbsError(other: PyImath.V2f, error: float) → bool

Returns True if this vector equals other, up to the given absolute error.

equalWithRelError(other: PyImath.V2f, error: float) → bool

Returns True if this vector equals other, up to the given relative error.

length() → float

Computes the length of this vector.

length2() → float

Computes the squared length of this vector.

negate() → PyImath.V2f

Negate this vector.

normalize() → PyImath.V2f

Normalize this vector. Sets a null vector if length is zero.

normalizeExc() → PyImath.V2f

Normalize this vector, raising a RuntimeError if length is zero.

normalizeNonNull() → PyImath.V2f

Equivalent to self.normalize().

normalized() → PyImath.V2f

Returns a normalized version of this vector, or a null vector if length is zero.

normalizedExc() → PyImath.V2f

Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

normalizedNonNull() → PyImath.V2f

Equivalent to self.normalized().

orthogonal(t: PyImath.V2f) → PyImath.V2f

Returns a vector which is perpendicular to this vector and in the same plane as t.

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

Returns the projection of the vector s onto the vector t.

projection(s: PyImath.V2f) → PyImath.V2f

Returns the projection of this vector onto s.

reflect(t: PyImath.V2f) → PyImath.V2f

Returns the result of reflecting this vector in the plane with normal t.

property x

The x component of this vector.

property y

The y component of this vector.

class Imath.V2i

Bases: pybind11_object

class V2iIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.V2i) -> None

Initializes a vector with zero values.

2. __init__(self: PyImath.V2i, value: int) -> None

Initializes a vector with all components set to the given value.

3. __init__(self: PyImath.V2i, iter: object) -> None

Initializes a vector from an iterable.

4. __init__(self: PyImath.V2i, x: int, y: int) -> None

Initializes a vector from the given x and y components.

5. __init__(self: PyImath.V2i, arg0: PyImath.V2d) -> None

6. __init__(self: PyImath.V2i, arg0: PyImath.V2f) -> None

7. __init__(self: PyImath.V2i, arg0: PyImath.V2i) -> None

8. __init__(self: PyImath.V2i, arg0: Imath_3_1::Vec2<short>) -> None

static baseTypeEpsilon() → int

Returns an epsilon value suitable for comparing values of the underlying component type.

static baseTypeLowest() → int

Returns the smallest value that can be represented by the underlying component type.

static baseTypeMax() → int

Returns the largest value that can be represented by the underlying component type.

static baseTypeSmallest() → int

Returns the smallest positive value that can be represented by the underlying component type.

closestVertex(v1: PyImath.V2i, v2: PyImath.V2i, p: PyImath.V2i) → PyImath.V2i

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

cross(other: PyImath.V2i) → int

Returns the cross product of this vector and other.

static dimensions() → int

Returns the number of components in this vector type.

dot(other: PyImath.V2i) → int

Returns the dot product of this vector and other.

equalWithAbsError(other: PyImath.V2i, error: int) → bool

Returns True if this vector equals other, up to the given absolute error.

equalWithRelError(other: PyImath.V2i, error: int) → bool

Returns True if this vector equals other, up to the given relative error.

negate() → PyImath.V2i

Negate this vector.

property x

The x component of this vector.

property y

The y component of this vector.

class Imath.V2s

Bases: pybind11_object

class V2sIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.V2s) -> None

Initializes a vector with zero values.

2. __init__(self: PyImath.V2s, value: int) -> None

Initializes a vector with all components set to the given value.

3. __init__(self: PyImath.V2s, iter: object) -> None

Initializes a vector from an iterable.

4. __init__(self: PyImath.V2s, x: int, y: int) -> None

Initializes a vector from the given x and y components.

5. __init__(self: PyImath.V2s, arg0: PyImath.V2d) -> None

6. __init__(self: PyImath.V2s, arg0: PyImath.V2f) -> None

7. __init__(self: PyImath.V2s, arg0: PyImath.V2i) -> None

8. __init__(self: PyImath.V2s, arg0: PyImath.V2s) -> None

static baseTypeEpsilon() → int

Returns an epsilon value suitable for comparing values of the underlying component type.

static baseTypeLowest() → int

Returns the smallest value that can be represented by the underlying component type.

static baseTypeMax() → int

Returns the largest value that can be represented by the underlying component type.

static baseTypeSmallest() → int

Returns the smallest positive value that can be represented by the underlying component type.

closestVertex(v1: PyImath.V2s, v2: PyImath.V2s, p: PyImath.V2s) → PyImath.V2s

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

cross(other: PyImath.V2s) → int

Returns the cross product of this vector and other.

static dimensions() → int

Returns the number of components in this vector type.

dot(other: PyImath.V2s) → int

Returns the dot product of this vector and other.

equalWithAbsError(other: PyImath.V2s, error: int) → bool

Returns True if this vector equals other, up to the given absolute error.

equalWithRelError(other: PyImath.V2s, error: int) → bool

Returns True if this vector equals other, up to the given relative error.

negate() → PyImath.V2s

Negate this vector.

property x

The x component of this vector.

property y

The y component of this vector.

class Imath.V3c

Bases: pybind11_object

class V3cIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.V3c) -> None

Initializes a vector with zero values.

2. __init__(self: PyImath.V3c, value: int) -> None

Initializes a vector with all components set to the given value.

3. __init__(self: PyImath.V3c, iter: object) -> None

Initializes a vector from an iterable.

4. __init__(self: PyImath.V3c, x: int, y: int, z: int) -> None

Initializes a vector from the given x, y and z components.

5. __init__(self: PyImath.V3c, arg0: PyImath.V3d) -> None

6. __init__(self: PyImath.V3c, arg0: PyImath.V3f) -> None

7. __init__(self: PyImath.V3c, arg0: PyImath.V3i) -> None

8. __init__(self: PyImath.V3c, arg0: PyImath.V3s) -> None

static baseTypeEpsilon() → int

Returns an epsilon value suitable for comparing values of the underlying component type.

static baseTypeLowest() → int

Returns the smallest value that can be represented by the underlying component type.

static baseTypeMax() → int

Returns the largest value that can be represented by the underlying component type.

static baseTypeSmallest() → int

Returns the smallest positive value that can be represented by the underlying component type.

closestVertex(v1: PyImath.V3c, v2: PyImath.V3c, p: PyImath.V3c) → PyImath.V3c

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

cross(other: PyImath.V3c) → PyImath.V3c

Returns the cross product of this vector and other.

static dimensions() → int

Returns the number of components in this vector type.

dot(other: PyImath.V3c) → int

Returns the dot product of this vector and other.

equalWithAbsError(other: PyImath.V3c, error: int) → bool

Returns True if this vector equals other, up to the given absolute error.

equalWithRelError(other: PyImath.V3c, error: int) → bool

Returns True if this vector equals other, up to the given relative error.

negate() → PyImath.V3c

Negate this vector.

property x

The x component of this vector.

property y

The y component of this vector.

property z

The z component of this vector

class Imath.V3d

Bases: pybind11_object

class V3dIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.V3d) -> None

Initializes a vector with zero values.

2. __init__(self: PyImath.V3d, value: float) -> None

Initializes a vector with all components set to the given value.

3. __init__(self: PyImath.V3d, iter: object) -> None

Initializes a vector from an iterable.

4. __init__(self: PyImath.V3d, x: float, y: float, z: float) -> None

Initializes a vector from the given x, y and z components.

5. __init__(self: PyImath.V3d, arg0: PyImath.V3d) -> None

6. __init__(self: PyImath.V3d, arg0: Imath_3_1::Vec3<float>) -> None

7. __init__(self: PyImath.V3d, arg0: Imath_3_1::Vec3<int>) -> None

8. __init__(self: PyImath.V3d, arg0: Imath_3_1::Vec3<short>) -> None

static baseTypeEpsilon() → float

Returns an epsilon value suitable for comparing values of the underlying component type.

static baseTypeLowest() → float

Returns the smallest value that can be represented by the underlying component type.

static baseTypeMax() → float

Returns the largest value that can be represented by the underlying component type.

static baseTypeSmallest() → float

Returns the smallest positive value that can be represented by the underlying component type.

closestVertex(v1: PyImath.V3d, v2: PyImath.V3d, p: PyImath.V3d) → PyImath.V3d

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

cross(other: PyImath.V3d) → PyImath.V3d

Returns the cross product of this vector and other.

static dimensions() → int

Returns the number of components in this vector type.

dot(other: PyImath.V3d) → float

Returns the dot product of this vector and other.

equalWithAbsError(other: PyImath.V3d, error: float) → bool

Returns True if this vector equals other, up to the given absolute error.

equalWithRelError(other: PyImath.V3d, error: float) → bool

Returns True if this vector equals other, up to the given relative error.

length() → float

Computes the length of this vector.

length2() → float

Computes the squared length of this vector.

negate() → PyImath.V3d

Negate this vector.

normalize() → PyImath.V3d

Normalize this vector. Sets a null vector if length is zero.

normalizeExc() → PyImath.V3d

Normalize this vector, raising a RuntimeError if length is zero.

normalizeNonNull() → PyImath.V3d

Equivalent to self.normalize().

normalized() → PyImath.V3d

Returns a normalized version of this vector, or a null vector if length is zero.

normalizedExc() → PyImath.V3d

Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

normalizedNonNull() → PyImath.V3d

Equivalent to self.normalized().

orthogonal(t: PyImath.V3d) → PyImath.V3d

Returns a vector which is perpendicular to this vector and in the same plane as t.

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

Returns the projection of the vector s onto the vector t.

projection(s: PyImath.V3d) → PyImath.V3d

Returns the projection of this vector onto s.

reflect(t: PyImath.V3d) → PyImath.V3d

Returns the result of reflecting this vector in the plane with normal t.

property x

The x component of this vector.

property y

The y component of this vector.

property z

The z component of this vector

class Imath.V3f

Bases: pybind11_object

class V3fIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.V3f) -> None

Initializes a vector with zero values.

2. __init__(self: PyImath.V3f, value: float) -> None

Initializes a vector with all components set to the given value.

3. __init__(self: PyImath.V3f, iter: object) -> None

Initializes a vector from an iterable.

4. __init__(self: PyImath.V3f, x: float, y: float, z: float) -> None

Initializes a vector from the given x, y and z components.

5. __init__(self: PyImath.V3f, arg0: PyImath.V3d) -> None

6. __init__(self: PyImath.V3f, arg0: PyImath.V3f) -> None

7. __init__(self: PyImath.V3f, arg0: Imath_3_1::Vec3<int>) -> None

8. __init__(self: PyImath.V3f, arg0: Imath_3_1::Vec3<short>) -> None

static baseTypeEpsilon() → float

Returns an epsilon value suitable for comparing values of the underlying component type.

static baseTypeLowest() → float

Returns the smallest value that can be represented by the underlying component type.

static baseTypeMax() → float

Returns the largest value that can be represented by the underlying component type.

static baseTypeSmallest() → float

Returns the smallest positive value that can be represented by the underlying component type.

closestVertex(v1: PyImath.V3f, v2: PyImath.V3f, p: PyImath.V3f) → PyImath.V3f

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

cross(other: PyImath.V3f) → PyImath.V3f

Returns the cross product of this vector and other.

static dimensions() → int

Returns the number of components in this vector type.

dot(other: PyImath.V3f) → float

Returns the dot product of this vector and other.

equalWithAbsError(other: PyImath.V3f, error: float) → bool

Returns True if this vector equals other, up to the given absolute error.

equalWithRelError(other: PyImath.V3f, error: float) → bool

Returns True if this vector equals other, up to the given relative error.

length() → float

Computes the length of this vector.

length2() → float

Computes the squared length of this vector.

negate() → PyImath.V3f

Negate this vector.

normalize() → PyImath.V3f

Normalize this vector. Sets a null vector if length is zero.

normalizeExc() → PyImath.V3f

Normalize this vector, raising a RuntimeError if length is zero.

normalizeNonNull() → PyImath.V3f

Equivalent to self.normalize().

normalized() → PyImath.V3f

Returns a normalized version of this vector, or a null vector if length is zero.

normalizedExc() → PyImath.V3f

Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

normalizedNonNull() → PyImath.V3f

Equivalent to self.normalized().

orthogonal(t: PyImath.V3f) → PyImath.V3f

Returns a vector which is perpendicular to this vector and in the same plane as t.

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

Returns the projection of the vector s onto the vector t.

projection(s: PyImath.V3f) → PyImath.V3f

Returns the projection of this vector onto s.

reflect(t: PyImath.V3f) → PyImath.V3f

Returns the result of reflecting this vector in the plane with normal t.

property x

The x component of this vector.

property y

The y component of this vector.

property z

The z component of this vector

class Imath.V3h

Bases: pybind11_object

class V3hIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.V3h) -> None

Initializes a vector with zero values.

2. __init__(self: PyImath.V3h, value: Imath_3_1::half) -> None

Initializes a vector with all components set to the given value.

3. __init__(self: PyImath.V3h, iter: object) -> None

Initializes a vector from an iterable.

4. __init__(self: PyImath.V3h, x: Imath_3_1::half, y: Imath_3_1::half, z: Imath_3_1::half) -> None

Initializes a vector from the given x, y and z components.

5. __init__(self: PyImath.V3h, arg0: PyImath.V3d) -> None

6. __init__(self: PyImath.V3h, arg0: PyImath.V3f) -> None

7. __init__(self: PyImath.V3h, arg0: PyImath.V3i) -> None

8. __init__(self: PyImath.V3h, arg0: PyImath.V3s) -> None

static baseTypeEpsilon() → Imath_3_1::half

Returns an epsilon value suitable for comparing values of the underlying component type.

static baseTypeLowest() → Imath_3_1::half

Returns the smallest value that can be represented by the underlying component type.

static baseTypeMax() → Imath_3_1::half

Returns the largest value that can be represented by the underlying component type.

static baseTypeSmallest() → Imath_3_1::half

Returns the smallest positive value that can be represented by the underlying component type.

closestVertex(v1: PyImath.V3h, v2: PyImath.V3h, p: PyImath.V3h) → PyImath.V3h

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

cross(other: PyImath.V3h) → PyImath.V3h

Returns the cross product of this vector and other.

static dimensions() → int

Returns the number of components in this vector type.

dot(other: PyImath.V3h) → Imath_3_1::half

Returns the dot product of this vector and other.

equalWithAbsError(other: PyImath.V3h, error: Imath_3_1::half) → bool

Returns True if this vector equals other, up to the given absolute error.

equalWithRelError(other: PyImath.V3h, error: Imath_3_1::half) → bool

Returns True if this vector equals other, up to the given relative error.

length() → Imath_3_1::half

Computes the length of this vector.

length2() → Imath_3_1::half

Computes the squared length of this vector.

negate() → PyImath.V3h

Negate this vector.

normalize() → PyImath.V3h

Normalize this vector. Sets a null vector if length is zero.

normalizeExc() → PyImath.V3h

Normalize this vector, raising a RuntimeError if length is zero.

normalizeNonNull() → PyImath.V3h

Equivalent to self.normalize().

normalized() → PyImath.V3h

Returns a normalized version of this vector, or a null vector if length is zero.

normalizedExc() → PyImath.V3h

Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

normalizedNonNull() → PyImath.V3h

Equivalent to self.normalized().

orthogonal(t: PyImath.V3h) → PyImath.V3h

Returns a vector which is perpendicular to this vector and in the same plane as t.

static project(s: PyImath.V3h, t: PyImath.V3h) → PyImath.V3h

Returns the projection of the vector s onto the vector t.

projection(s: PyImath.V3h) → PyImath.V3h

Returns the projection of this vector onto s.

reflect(t: PyImath.V3h) → PyImath.V3h

Returns the result of reflecting this vector in the plane with normal t.

property x

The x component of this vector.

property y

The y component of this vector.

property z

The z component of this vector

class Imath.V3i

Bases: pybind11_object

class V3iIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.V3i) -> None

Initializes a vector with zero values.

2. __init__(self: PyImath.V3i, value: int) -> None

Initializes a vector with all components set to the given value.

3. __init__(self: PyImath.V3i, iter: object) -> None

Initializes a vector from an iterable.

4. __init__(self: PyImath.V3i, x: int, y: int, z: int) -> None

Initializes a vector from the given x, y and z components.

5. __init__(self: PyImath.V3i, arg0: PyImath.V3d) -> None

6. __init__(self: PyImath.V3i, arg0: PyImath.V3f) -> None

7. __init__(self: PyImath.V3i, arg0: PyImath.V3i) -> None

8. __init__(self: PyImath.V3i, arg0: Imath_3_1::Vec3<short>) -> None

static baseTypeEpsilon() → int

Returns an epsilon value suitable for comparing values of the underlying component type.

static baseTypeLowest() → int

Returns the smallest value that can be represented by the underlying component type.

static baseTypeMax() → int

Returns the largest value that can be represented by the underlying component type.

static baseTypeSmallest() → int

Returns the smallest positive value that can be represented by the underlying component type.

closestVertex(v1: PyImath.V3i, v2: PyImath.V3i, p: PyImath.V3i) → PyImath.V3i

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

cross(other: PyImath.V3i) → PyImath.V3i

Returns the cross product of this vector and other.

static dimensions() → int

Returns the number of components in this vector type.

dot(other: PyImath.V3i) → int

Returns the dot product of this vector and other.

equalWithAbsError(other: PyImath.V3i, error: int) → bool

Returns True if this vector equals other, up to the given absolute error.

equalWithRelError(other: PyImath.V3i, error: int) → bool

Returns True if this vector equals other, up to the given relative error.

negate() → PyImath.V3i

Negate this vector.

property x

The x component of this vector.

property y

The y component of this vector.

property z

The z component of this vector

class Imath.V3s

Bases: pybind11_object

class V3sIterator

Bases: pybind11_object

Imath Iterator

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.V3s) -> None

Initializes a vector with zero values.

2. __init__(self: PyImath.V3s, value: int) -> None

Initializes a vector with all components set to the given value.

3. __init__(self: PyImath.V3s, iter: object) -> None

Initializes a vector from an iterable.

4. __init__(self: PyImath.V3s, x: int, y: int, z: int) -> None

Initializes a vector from the given x, y and z components.

5. __init__(self: PyImath.V3s, arg0: PyImath.V3d) -> None

6. __init__(self: PyImath.V3s, arg0: PyImath.V3f) -> None

7. __init__(self: PyImath.V3s, arg0: PyImath.V3i) -> None

8. __init__(self: PyImath.V3s, arg0: PyImath.V3s) -> None

static baseTypeEpsilon() → int

Returns an epsilon value suitable for comparing values of the underlying component type.

static baseTypeLowest() → int

Returns the smallest value that can be represented by the underlying component type.

static baseTypeMax() → int

Returns the largest value that can be represented by the underlying component type.

static baseTypeSmallest() → int

Returns the smallest positive value that can be represented by the underlying component type.

closestVertex(v1: PyImath.V3s, v2: PyImath.V3s, p: PyImath.V3s) → PyImath.V3s

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

cross(other: PyImath.V3s) → PyImath.V3s

Returns the cross product of this vector and other.

static dimensions() → int

Returns the number of components in this vector type.

dot(other: PyImath.V3s) → int

Returns the dot product of this vector and other.

equalWithAbsError(other: PyImath.V3s, error: int) → bool

Returns True if this vector equals other, up to the given absolute error.

equalWithRelError(other: PyImath.V3s, error: int) → bool

Returns True if this vector equals other, up to the given relative error.

negate() → PyImath.V3s

Negate this vector.

property x

The x component of this vector.

property y

The y component of this vector.

property z

The z component of this vector

Imath.abs(arg0: float) → float

Imath.ceil(arg0: float) → int

Imath.clamp(*args, **kwargs)

Overloaded function.

1. clamp(arg0: float, arg1: float, arg2: float) -> float

2. clamp(arg0: float, arg1: float, arg2: float) -> float

Imath.cmp(arg0: float, arg1: float) → int

Imath.cmpt(arg0: float, arg1: float, arg2: float) → int

Imath.divp(arg0: int, arg1: int) → int

Integer division where the remainder of x/y is always positive: divp(x,y) == floor (double(x) / double(y))

Imath.divs(arg0: int, arg1: int) → int

Integer division where the remainder of x/y has the same sign as x: divs(x,y) == (abs(x) / abs(y)) * (sign(x) * sign(y))

Imath.equal(a: float, b: float, error: float) → bool

Returns True if a and b are equal up to the given error.

Imath.finited(arg0: float) → bool

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

Imath.finitef(arg0: float) → bool

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

Imath.floor(arg0: float) → int

class Imath.half

Bases: pybind11_object

__init__(*args, **kwargs)

Overloaded function.

1. __init__(self: PyImath.half) -> None

Initializes a half with zero value.

2. __init__(self: PyImath.half, value: float) -> None

Initializes a half from the given float value.

property bits

The internal bit representation of this half.

isDenormalized() → bool

Returns True if this half is a denormalized number.

isFinite() → bool

Returns True if this half is a normalized number, a denormalized number or zero.

isInfinity() → bool

Returns True if this half is a positive or a negative infinity.

isNan() → bool

Returns True if this half is a NaN.

isNegative() → bool

Returns True if the sign bit of this half is set (negative).

isNormalized() → bool

Returns True if this half is a normalized number.

isZero() → bool

Returns True if this half is zero.

static negInf() → PyImath.half

Returns -infinity.

static posInf() → PyImath.half

Returns +infinity.

static qNan() → PyImath.half

Returns a NaN with the bit pattern 0111111111111111

round(n: int) → PyImath.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() → PyImath.half

Returns a NaN with the bit pattern 0111110111111111

Imath.iszero(arg0: float, arg1: float) → bool

Imath.lerp(*args, **kwargs)

Overloaded function.

1. lerp(arg0: float, arg1: float, arg2: float) -> float

2. lerp(arg0: PyImath.V3f, arg1: PyImath.V3f, arg2: float) -> PyImath.V3f

3. lerp(arg0: PyImath.V2f, arg1: PyImath.V2f, arg2: float) -> PyImath.V2f

4. lerp(arg0: PyImath.V3d, arg1: PyImath.V3d, arg2: float) -> PyImath.V3d

5. lerp(arg0: PyImath.V2d, arg1: PyImath.V2d, arg2: float) -> PyImath.V2d

6. lerp(arg0: PyImath.V3i, arg1: PyImath.V3i, arg2: int) -> PyImath.V3i

7. lerp(arg0: PyImath.V2i, arg1: PyImath.V2i, arg2: int) -> PyImath.V2i

8. lerp(arg0: PyImath.V3s, arg1: PyImath.V3s, arg2: int) -> PyImath.V3s

9. lerp(arg0: PyImath.V2s, arg1: PyImath.V2s, arg2: int) -> PyImath.V2s

10. lerp(arg0: PyImath.C4f, arg1: PyImath.C4f, arg2: float) -> PyImath.C4f

11. lerp(arg0: PyImath.C3f, arg1: PyImath.C3f, arg2: float) -> PyImath.C3f

12. lerp(arg0: PyImath.C4h, arg1: PyImath.C4h, arg2: PyImath.half) -> PyImath.C4h

13. lerp(arg0: PyImath.C3h, arg1: PyImath.C3h, arg2: PyImath.half) -> PyImath.C3h

14. lerp(arg0: PyImath.C4c, arg1: PyImath.C4c, arg2: str) -> PyImath.C4c

15. lerp(arg0: PyImath.C3c, arg1: PyImath.C3c, arg2: str) -> PyImath.C3c

Imath.lerpfactor(arg0: float, arg1: float, arg2: float) → float

Imath.modp(arg0: int, arg1: int) → int

Integer remainder where the remainder of x/y is always positive: modp(x,y) == x - y * divp(x,y)

Imath.mods(arg0: int, arg1: int) → int

Integer remainder where the remainder of x/y has the same sign as x: mods(x,y) == x - y * divs(x,y)

Imath.predd(arg0: float) → 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.predf(arg0: float) → 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.sign(arg0: float) → int

Imath.succd(arg0: float) → 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.succf(arg0: float) → 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.trunc(arg0: float) → int

Imath.ulerp(arg0: float, arg1: float, arg2: float) → float