`Imath` (Python)¶

class Imath.Box2d¶

Bases: pybind11_builtins.pybind11_object

class Box2dIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

Box2d.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Box2d) -> None

Returns an empty box.

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

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

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

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

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

Returns a box using values from the given iterable.

Box2d.center() → PyImath.V2d¶: Returns the central point of this box.

Box2d.extendBy(*args, **kwargs)¶

Overloaded function.

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

Extends this box to include the given point.

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

Extends this box to include the given box.

Box2d.hasVolume() → bool¶: Returns True if this box has volume.

Box2d.intersects(*args, **kwargs)¶

Overloaded function.

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

Returns True if this box encompasses the given point.

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

Returns True if this box intersects the given box.

Box2d.isEmpty() → bool¶: Returns True if this box has no volume.

Box2d.majorAxis() → int¶: Returns the index of the longest axis of this box.

Box2d.makeEmpty() → None¶: Converts this box to an empty box.

Box2d.max¶: The maximum corner of this box.

Box2d.min¶: The minimum corner of this box.

Box2d.size() → PyImath.V2d¶: Returns the volume of this box.

class Imath.Box2f¶

Bases: pybind11_builtins.pybind11_object

class Box2fIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

Box2f.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Box2f) -> None

Returns an empty box.

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

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

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

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

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

Returns a box using values from the given iterable.

Box2f.center() → PyImath.V2f¶: Returns the central point of this box.

Box2f.extendBy(*args, **kwargs)¶

Overloaded function.

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

Extends this box to include the given point.

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

Extends this box to include the given box.

Box2f.hasVolume() → bool¶: Returns True if this box has volume.

Box2f.intersects(*args, **kwargs)¶

Overloaded function.

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

Returns True if this box encompasses the given point.

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

Returns True if this box intersects the given box.

Box2f.isEmpty() → bool¶: Returns True if this box has no volume.

Box2f.majorAxis() → int¶: Returns the index of the longest axis of this box.

Box2f.makeEmpty() → None¶: Converts this box to an empty box.

Box2f.max¶: The maximum corner of this box.

Box2f.min¶: The minimum corner of this box.

Box2f.size() → PyImath.V2f¶: Returns the volume of this box.

class Imath.Box2i¶

Bases: pybind11_builtins.pybind11_object

class Box2iIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

Box2i.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Box2i) -> None

Returns an empty box.

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

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

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

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

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

Returns a box using values from the given iterable.

Box2i.center() → PyImath.V2i¶: Returns the central point of this box.

Box2i.extendBy(*args, **kwargs)¶

Overloaded function.

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

Extends this box to include the given point.

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

Extends this box to include the given box.

Box2i.hasVolume() → bool¶: Returns True if this box has volume.

Box2i.intersects(*args, **kwargs)¶

Overloaded function.

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

Returns True if this box encompasses the given point.

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

Returns True if this box intersects the given box.

Box2i.isEmpty() → bool¶: Returns True if this box has no volume.

Box2i.majorAxis() → int¶: Returns the index of the longest axis of this box.

Box2i.makeEmpty() → None¶: Converts this box to an empty box.

Box2i.max¶: The maximum corner of this box.

Box2i.min¶: The minimum corner of this box.

Box2i.size() → PyImath.V2i¶: Returns the volume of this box.

class Imath.Box2s¶

Bases: pybind11_builtins.pybind11_object

class Box2sIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

Box2s.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Box2s) -> None

Returns an empty box.

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

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

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

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

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

Returns a box using values from the given iterable.

Box2s.center() → PyImath.V2s¶: Returns the central point of this box.

Box2s.extendBy(*args, **kwargs)¶

Overloaded function.

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

Extends this box to include the given point.

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

Extends this box to include the given box.

Box2s.hasVolume() → bool¶: Returns True if this box has volume.

Box2s.intersects(*args, **kwargs)¶

Overloaded function.

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

Returns True if this box encompasses the given point.

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

Returns True if this box intersects the given box.

Box2s.isEmpty() → bool¶: Returns True if this box has no volume.

Box2s.majorAxis() → int¶: Returns the index of the longest axis of this box.

Box2s.makeEmpty() → None¶: Converts this box to an empty box.

Box2s.max¶: The maximum corner of this box.

Box2s.min¶: The minimum corner of this box.

Box2s.size() → PyImath.V2s¶: Returns the volume of this box.

class Imath.Box3d¶

Bases: pybind11_builtins.pybind11_object

class Box3dIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

Box3d.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Box3d) -> None

Returns an empty box.

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

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

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

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

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

Returns a box using values from the given iterable.

Box3d.center() → PyImath.V3d¶: Returns the central point of this box.

Box3d.extendBy(*args, **kwargs)¶

Overloaded function.

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

Extends this box to include the given point.

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

Extends this box to include the given box.

Box3d.hasVolume() → bool¶: Returns True if this box has volume.

Box3d.intersects(*args, **kwargs)¶

Overloaded function.

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

Returns True if this box encompasses the given point.

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

Returns True if this box intersects the given box.

Box3d.isEmpty() → bool¶: Returns True if this box has no volume.

Box3d.majorAxis() → int¶: Returns the index of the longest axis of this box.

Box3d.makeEmpty() → None¶: Converts this box to an empty box.

Box3d.max¶: The maximum corner of this box.

Box3d.min¶: The minimum corner of this box.

Box3d.size() → PyImath.V3d¶: Returns the volume of this box.

class Imath.Box3f¶

Bases: pybind11_builtins.pybind11_object

class Box3fIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

Box3f.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Box3f) -> None

Returns an empty box.

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

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

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

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

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

Returns a box using values from the given iterable.

Box3f.center() → PyImath.V3f¶: Returns the central point of this box.

Box3f.extendBy(*args, **kwargs)¶

Overloaded function.

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

Extends this box to include the given point.

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

Extends this box to include the given box.

Box3f.hasVolume() → bool¶: Returns True if this box has volume.

Box3f.intersects(*args, **kwargs)¶

Overloaded function.

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

Returns True if this box encompasses the given point.

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

Returns True if this box intersects the given box.

Box3f.isEmpty() → bool¶: Returns True if this box has no volume.

Box3f.majorAxis() → int¶: Returns the index of the longest axis of this box.

Box3f.makeEmpty() → None¶: Converts this box to an empty box.

Box3f.max¶: The maximum corner of this box.

Box3f.min¶: The minimum corner of this box.

Box3f.size() → PyImath.V3f¶: Returns the volume of this box.

class Imath.Box3i¶

Bases: pybind11_builtins.pybind11_object

class Box3iIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

Box3i.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Box3i) -> None

Returns an empty box.

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

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

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

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

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

Returns a box using values from the given iterable.

Box3i.center() → PyImath.V3i¶: Returns the central point of this box.

Box3i.extendBy(*args, **kwargs)¶

Overloaded function.

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

Extends this box to include the given point.

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

Extends this box to include the given box.

Box3i.hasVolume() → bool¶: Returns True if this box has volume.

Box3i.intersects(*args, **kwargs)¶

Overloaded function.

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

Returns True if this box encompasses the given point.

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

Returns True if this box intersects the given box.

Box3i.isEmpty() → bool¶: Returns True if this box has no volume.

Box3i.majorAxis() → int¶: Returns the index of the longest axis of this box.

Box3i.makeEmpty() → None¶: Converts this box to an empty box.

Box3i.max¶: The maximum corner of this box.

Box3i.min¶: The minimum corner of this box.

Box3i.size() → PyImath.V3i¶: Returns the volume of this box.

class Imath.Box3s¶

Bases: pybind11_builtins.pybind11_object

class Box3sIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

Box3s.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Box3s) -> None

Returns an empty box.

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

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

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

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

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

Returns a box using values from the given iterable.

Box3s.center() → PyImath.V3s¶: Returns the central point of this box.

Box3s.extendBy(*args, **kwargs)¶

Overloaded function.

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

Extends this box to include the given point.

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

Extends this box to include the given box.

Box3s.hasVolume() → bool¶: Returns True if this box has volume.

Box3s.intersects(*args, **kwargs)¶

Overloaded function.

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

Returns True if this box encompasses the given point.

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

Returns True if this box intersects the given box.

Box3s.isEmpty() → bool¶: Returns True if this box has no volume.

Box3s.majorAxis() → int¶: Returns the index of the longest axis of this box.

Box3s.makeEmpty() → None¶: Converts this box to an empty box.

Box3s.max¶: The maximum corner of this box.

Box3s.min¶: The minimum corner of this box.

Box3s.size() → PyImath.V3s¶: Returns the volume of this box.

class Imath.C3c¶

Bases: PyImath.V3c

class C3cIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

C3c.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.C3c) -> None

Initializes a color with all channels zero.

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

Initializes a color from the given number of iterable.

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

Initializes a color from RGB values.

C3c.b¶: The blue channel of this color.

C3c.g¶: The green channel of this color.

static C3c.hsv2rgb(arg0: PyImath.V3c) → PyImath.V3c¶: Convert the given HSV color to RGB.

C3c.negate() → PyImath.C3c¶: Negates this color’s channels.

static C3c.packed2rgb(arg0: int, arg1: PyImath.V3c) → None¶: Convert the given packed color to RGB.

C3c.r¶: The red channel of this color.

static C3c.rgb2hsv(arg0: PyImath.V3c) → PyImath.V3c¶: Convert the given RGB color to HSV.

static C3c.rgb2packed(arg0: PyImath.V3c) → int¶: Convert the given RGB color to packed format.

class Imath.C3f¶

Bases: PyImath.V3f

class C3fIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

C3f.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.C3f) -> None

Initializes a color with all channels zero.

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

Initializes a color from the given number of iterable.

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

Initializes a color from RGB values.

C3f.b¶: The blue channel of this color.

C3f.g¶: The green channel of this color.

static C3f.hsv2rgb(arg0: PyImath.V3f) → PyImath.V3f¶: Convert the given HSV color to RGB.

C3f.negate() → PyImath.C3f¶: Negates this color’s channels.

static C3f.packed2rgb(arg0: int, arg1: PyImath.V3f) → None¶: Convert the given packed color to RGB.

C3f.r¶: The red channel of this color.

static C3f.rgb2hsv(arg0: PyImath.V3f) → PyImath.V3f¶: Convert the given RGB color to HSV.

static C3f.rgb2packed(arg0: PyImath.V3f) → int¶: Convert the given RGB color to packed format.

class Imath.C3h¶

Bases: PyImath.V3h

class C3hIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → half¶

C3h.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.C3h) -> None

Initializes a color with all channels zero.

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

Initializes a color from the given number of iterable.

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

Initializes a color from RGB values.

C3h.b¶: The blue channel of this color.

C3h.g¶: The green channel of this color.

static C3h.hsv2rgb(arg0: PyImath.V3h) → PyImath.V3h¶: Convert the given HSV color to RGB.

C3h.negate() → PyImath.C3h¶: Negates this color’s channels.

static C3h.packed2rgb(arg0: int, arg1: PyImath.V3h) → None¶: Convert the given packed color to RGB.

C3h.r¶: The red channel of this color.

static C3h.rgb2hsv(arg0: PyImath.V3h) → PyImath.V3h¶: Convert the given RGB color to HSV.

static C3h.rgb2packed(arg0: PyImath.V3h) → int¶: Convert the given RGB color to packed format.

class Imath.C4c¶

Bases: pybind11_builtins.pybind11_object

class C4cIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

C4c.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.C4c) -> None

Initializes a color with all channels zero.

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

Initializes a color from the given number of iterable.

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

Initializes a color from RGBA values.

C4c.a¶: The alpha channel of this color.

C4c.b¶: The blue channel of this color.

static C4c.baseTypeEpsilon() → int¶: Returns a suitable epsilon for comparing values of the underlying component type.

static C4c.baseTypeMax() → int¶: Returns the largest value of the underlying component type.

static C4c.baseTypeMin() → int¶: Returns the smallest value of the underlying component type.

static C4c.baseTypeSmallest() → int¶: Returns the smallest positive value of the underlying component type.

static C4c.dimensions() → int¶

C4c.g¶: The green channel of this color.

static C4c.hsv2rgb(arg0: PyImath.C4c) → PyImath.C4c¶: Convert the given HSV color to RGB.

C4c.negate() → PyImath.C4c¶: Negates this color’s channels.

static C4c.packed2rgb(arg0: int, arg1: PyImath.C4c) → None¶: Convert the given packed color to RGB.

C4c.r¶: The red channel of this color.

static C4c.rgb2hsv(arg0: PyImath.C4c) → PyImath.C4c¶: Convert the given RGB color to HSV.

static C4c.rgb2packed(arg0: PyImath.C4c) → int¶: Convert the given RGB color to packed format.

class Imath.C4f¶

Bases: pybind11_builtins.pybind11_object

class C4fIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

C4f.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.C4f) -> None

Initializes a color with all channels zero.

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

Initializes a color from the given number of iterable.

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

Initializes a color from RGBA values.

C4f.a¶: The alpha channel of this color.

C4f.b¶: The blue channel of this color.

static C4f.baseTypeEpsilon() → float¶: Returns a suitable epsilon for comparing values of the underlying component type.

static C4f.baseTypeMax() → float¶: Returns the largest value of the underlying component type.

static C4f.baseTypeMin() → float¶: Returns the smallest value of the underlying component type.

static C4f.baseTypeSmallest() → float¶: Returns the smallest positive value of the underlying component type.

static C4f.dimensions() → int¶

C4f.g¶: The green channel of this color.

static C4f.hsv2rgb(arg0: PyImath.C4f) → PyImath.C4f¶: Convert the given HSV color to RGB.

C4f.negate() → PyImath.C4f¶: Negates this color’s channels.

static C4f.packed2rgb(arg0: int, arg1: PyImath.C4f) → None¶: Convert the given packed color to RGB.

C4f.r¶: The red channel of this color.

static C4f.rgb2hsv(arg0: PyImath.C4f) → PyImath.C4f¶: Convert the given RGB color to HSV.

static C4f.rgb2packed(arg0: PyImath.C4f) → int¶: Convert the given RGB color to packed format.

class Imath.C4h¶

Bases: pybind11_builtins.pybind11_object

class C4hIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → half¶

C4h.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.C4h) -> None

Initializes a color with all channels zero.

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

Initializes a color from the given number of iterable.

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

Initializes a color from RGBA values.

C4h.a¶: The alpha channel of this color.

C4h.b¶: The blue channel of this color.

static C4h.baseTypeEpsilon() → half¶: Returns a suitable epsilon for comparing values of the underlying component type.

static C4h.baseTypeMax() → half¶: Returns the largest value of the underlying component type.

static C4h.baseTypeMin() → half¶: Returns the smallest value of the underlying component type.

static C4h.baseTypeSmallest() → half¶: Returns the smallest positive value of the underlying component type.

static C4h.dimensions() → int¶

C4h.g¶: The green channel of this color.

static C4h.hsv2rgb(arg0: PyImath.C4h) → PyImath.C4h¶: Convert the given HSV color to RGB.

C4h.negate() → PyImath.C4h¶: Negates this color’s channels.

static C4h.packed2rgb(arg0: int, arg1: PyImath.C4h) → None¶: Convert the given packed color to RGB.

C4h.r¶: The red channel of this color.

static C4h.rgb2hsv(arg0: PyImath.C4h) → PyImath.C4h¶: Convert the given RGB color to HSV.

static C4h.rgb2packed(arg0: PyImath.C4h) → int¶: Convert the given RGB color to packed format.

class Imath.Eulerd¶

Bases: PyImath.V3d

class Axis¶

Bases: pybind11_builtins.pybind11_object

Members:

Y

X

Z

X = Axis.X¶

Y = Axis.Y¶

Z = Axis.Z¶

__init__(arg0: int) → None¶

name¶: (self: handle) -> str

class Eulerd.InputLayout¶

Bases: pybind11_builtins.pybind11_object

Members:

XYZLayout

IJKLayout

IJKLayout = InputLayout.IJKLayout¶

XYZLayout = InputLayout.XYZLayout¶

__init__(arg0: int) → None¶

name¶: (self: handle) -> str

class Eulerd.Order¶

Bases: pybind11_builtins.pybind11_object

Members:

Min

YZYr

XYZr

Legal

Max

YXYr

ZYZ

ZYX

YXZ

YXY

ZXYr

YZX

YZY

XZY

XZX

YZXr

XZYr

Default

ZXY

ZXZ

YXZr

ZYXr

XYX

XYZ

ZYZr

XYXr

XZXr

ZXZr

Default = Order.Default¶

Legal = Order.Legal¶

Max = Order.Max¶

Min = Order.Min¶

XYX = Order.XYX¶

XYXr = Order.XYXr¶

XYZ = Order.Default¶

XYZr = Order.XYZr¶

XZX = Order.XZX¶

XZXr = Order.XZXr¶

XZY = Order.XZY¶

XZYr = Order.XZYr¶

YXY = Order.YXY¶

YXYr = Order.YXYr¶

YXZ = Order.YXZ¶

YXZr = Order.YXZr¶

YZX = Order.YZX¶

YZXr = Order.YZXr¶

YZY = Order.YZY¶

YZYr = Order.YZYr¶

ZXY = Order.ZXY¶

ZXYr = Order.Min¶

ZXZ = Order.Max¶

ZXZr = Order.ZXZr¶

ZYX = Order.ZYX¶

ZYXr = Order.ZYXr¶

ZYZ = Order.ZYZ¶

ZYZr = Order.ZYZr¶

__init__(arg0: int) → None¶

name¶: (self: handle) -> str

Eulerd.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Eulerd, order: PyImath.Eulerd.Order = Order.Default) -> None

Initializes Euler angles with zero values and given order.

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

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

__init__(self: PyImath.Eulerd, x: float, y: float, z: float, order: PyImath.Eulerd.Order = Order.Default, layout: PyImath.Eulerd.InputLayout = InputLayout.IJKLayout) -> None

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

__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.

__init__(self: PyImath.Eulerd, mat: PyImath.M33d, order: PyImath.Eulerd.Order = Order.Default) -> None

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

__init__(self: PyImath.Eulerd, mat: PyImath.M44d, order: PyImath.Eulerd.Order = Order.Default) -> None

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

static Eulerd.angleMod(arg0: float) → float¶: Converts an angle to its equivalent in [-pi, pi].

Eulerd.angleOrder() → Tuple[int, int, int]¶: Returns a 3-tuple of axis indices for this Euler object.

Eulerd.extract(*args, **kwargs)¶

Overloaded function.

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.

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.

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

Sets the Euler values from the given quaternion.

Eulerd.frameStatic¶: True if this Euler’s order is not a relative order.

Eulerd.initialAxis¶: The initial Axis of this Euler.

Eulerd.initialRepeated¶: True if this Euler’s order has a repeated axis.

static Eulerd.legal(order: PyImath.Eulerd.Order) → bool¶: Returns True if the given order is a legal permutation.

Eulerd.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 Eulerd.nearestRotation(xyzRot: PyImath.V3d, targetXyzRot: PyImath.V3d, order: PyImath.Eulerd.Order = Order.Default) → None¶: Adjusts xyzRot so that its components differ from targetXyzRot by as little as possible. Note that xyz here really means ijk, because the order must be provided.

Eulerd.order¶: The order of thie Euler object.

Eulerd.parityEven¶: True if this Euler’s order represents a right-handed coordinate system.

Eulerd.set(axis: PyImath.Eulerd.Axis, relative: bool, parityEven: bool, firstRepeats: bool) → None¶: Set the order of this Euler object.

Eulerd.setXYZVector(vec: PyImath.V3d) → None¶: Sets the values, reordering the input components if this Euler object is not XYZ-ordered.

static Eulerd.simpleXYZRotation(xyzRot: PyImath.V3d, targetXyzRot: PyImath.V3d) → None¶: Adjusts xyzRot so that its components differ from targetXyzRot by no more than +-pi.

Eulerd.toMatrix33() → PyImath.M33d¶: Converts this Euler object to a 3x3 matrix.

Eulerd.toMatrix44() → PyImath.M44d¶: Converts this Euler object to a 4x4 matrix.

Eulerd.toQuat() → Imath_2_4::Quat<double>¶: Converts this Euler object to a quaternion.

Eulerd.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: PyImath.V3f

class Axis¶

Bases: pybind11_builtins.pybind11_object

Members:

Y

X

Z

X = Axis.X¶

Y = Axis.Y¶

Z = Axis.Z¶

__init__(arg0: int) → None¶

name¶: (self: handle) -> str

class Eulerf.InputLayout¶

Bases: pybind11_builtins.pybind11_object

Members:

XYZLayout

IJKLayout

IJKLayout = InputLayout.IJKLayout¶

XYZLayout = InputLayout.XYZLayout¶

__init__(arg0: int) → None¶

name¶: (self: handle) -> str

class Eulerf.Order¶

Bases: pybind11_builtins.pybind11_object

Members:

Min

YZYr

XYZr

Legal

Max

YXYr

ZYZ

ZYX

YXZ

YXY

ZXYr

YZX

YZY

XZY

XZX

YZXr

XZYr

Default

ZXY

ZXZ

YXZr

ZYXr

XYX

XYZ

ZYZr

XYXr

XZXr

ZXZr

Default = Order.Default¶

Legal = Order.Legal¶

Max = Order.Max¶

Min = Order.Min¶

XYX = Order.XYX¶

XYXr = Order.XYXr¶

XYZ = Order.Default¶

XYZr = Order.XYZr¶

XZX = Order.XZX¶

XZXr = Order.XZXr¶

XZY = Order.XZY¶

XZYr = Order.XZYr¶

YXY = Order.YXY¶

YXYr = Order.YXYr¶

YXZ = Order.YXZ¶

YXZr = Order.YXZr¶

YZX = Order.YZX¶

YZXr = Order.YZXr¶

YZY = Order.YZY¶

YZYr = Order.YZYr¶

ZXY = Order.ZXY¶

ZXYr = Order.Min¶

ZXZ = Order.Max¶

ZXZr = Order.ZXZr¶

ZYX = Order.ZYX¶

ZYXr = Order.ZYXr¶

ZYZ = Order.ZYZ¶

ZYZr = Order.ZYZr¶

__init__(arg0: int) → None¶

name¶: (self: handle) -> str

Eulerf.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Eulerf, order: PyImath.Eulerf.Order = Order.Default) -> None

Initializes Euler angles with zero values and given order.

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

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

__init__(self: PyImath.Eulerf, x: float, y: float, z: float, order: PyImath.Eulerf.Order = Order.Default, layout: PyImath.Eulerf.InputLayout = InputLayout.IJKLayout) -> None

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

__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.

__init__(self: PyImath.Eulerf, mat: PyImath.M33f, order: PyImath.Eulerf.Order = Order.Default) -> None

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

__init__(self: PyImath.Eulerf, mat: PyImath.M44f, order: PyImath.Eulerf.Order = Order.Default) -> None

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

static Eulerf.angleMod(arg0: float) → float¶: Converts an angle to its equivalent in [-pi, pi].

Eulerf.angleOrder() → Tuple[int, int, int]¶: Returns a 3-tuple of axis indices for this Euler object.

Eulerf.extract(*args, **kwargs)¶

Overloaded function.

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.

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.

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

Sets the Euler values from the given quaternion.

Eulerf.frameStatic¶: True if this Euler’s order is not a relative order.

Eulerf.initialAxis¶: The initial Axis of this Euler.

Eulerf.initialRepeated¶: True if this Euler’s order has a repeated axis.

static Eulerf.legal(order: PyImath.Eulerf.Order) → bool¶: Returns True if the given order is a legal permutation.

Eulerf.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 Eulerf.nearestRotation(xyzRot: PyImath.V3f, targetXyzRot: PyImath.V3f, order: PyImath.Eulerf.Order = Order.Default) → None¶: Adjusts xyzRot so that its components differ from targetXyzRot by as little as possible. Note that xyz here really means ijk, because the order must be provided.

Eulerf.order¶: The order of thie Euler object.

Eulerf.parityEven¶: True if this Euler’s order represents a right-handed coordinate system.

Eulerf.set(axis: PyImath.Eulerf.Axis, relative: bool, parityEven: bool, firstRepeats: bool) → None¶: Set the order of this Euler object.

Eulerf.setXYZVector(vec: PyImath.V3f) → None¶: Sets the values, reordering the input components if this Euler object is not XYZ-ordered.

static Eulerf.simpleXYZRotation(xyzRot: PyImath.V3f, targetXyzRot: PyImath.V3f) → None¶: Adjusts xyzRot so that its components differ from targetXyzRot by no more than +-pi.

Eulerf.toMatrix33() → PyImath.M33f¶: Converts this Euler object to a 3x3 matrix.

Eulerf.toMatrix44() → PyImath.M44f¶: Converts this Euler object to a 4x4 matrix.

Eulerf.toQuat() → Imath_2_4::Quat<float>¶: Converts this Euler object to a quaternion.

Eulerf.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_builtins.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.

__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.

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

Initializes a Frustum by copying the given argument.

__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.

__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_builtins.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.

__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.

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

Initializes a Frustum by copying the given argument.

__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.

__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_builtins.pybind11_object

class M33dIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

M33d.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.M33d) -> None

Initializes an identity matrix.

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

static M33d.baseTypeEpsilon() → float¶: Returns a suitable epsilon value for comparing values of the underlying component type.

static M33d.baseTypeMax() → float¶: Returns the largest value that can be represented by the underling component type.

static M33d.baseTypeMin() → float¶: Returns the smallest value that can be represented by the underling component type.

static M33d.baseTypeSmallest() → float¶: Returns the smallest positive value that can be represented by the underlying component type.

M33d.equalWithAbsError(other: PyImath.M33d, error: float) → bool¶: Returns True if this matrix equals other up to the given absolute error.

M33d.equalWithRelError(other: PyImath.M33d, error: float) → bool¶: Returns True if this matrix equals other up to the given relative error.

M33d.extractAndRemoveScalingAndShear(*args, **kwargs)¶

Overloaded function.

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

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

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.

M33d.extractEuler(arg0: float) → None¶: Extract 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().

M33d.extractSHRT(*args, **kwargs)¶

Overloaded function.

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.

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

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

M33d.extractScaling(*args, **kwargs)¶

Overloaded function.

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

Returns the scaling component of this matrix.

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

Returns the scaling component of this matrix.

M33d.extractScalingAndShear(*args, **kwargs)¶

Overloaded function.

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

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

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

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

M33d.gjInverse(raise: bool = False) → PyImath.M33d¶: Returns the Gauss-Jordan inverse of this matrix, handling singular matrices as in gjInvert().

M33d.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.

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

M33d.inverse(raise: bool = False) → PyImath.M33d¶: Returns the inverse of this matrix, handling singular matrices as in invert().

M33d.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.

M33d.makeIdentity() → None¶: Sets this matrix to the identity.

M33d.multDirMatrix(*args, **kwargs)¶

Overloaded function.

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

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

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

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

M33d.multVecMatrix(*args, **kwargs)¶

Overloaded function.

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

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

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

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

M33d.negate() → PyImath.M33d¶: Negates this matrix.

M33d.removeScaling() → bool¶: Removes scaling from this matrix.

M33d.removeScalingAndShear() → bool¶: Removes scaling and shear from this matrix.

M33d.rotate(r: float) → PyImath.M33d¶: Cumulatively rotates this matrix by r (in radians).

M33d.sansScaling() → PyImath.M33d¶: Returns a copy of this matrix with scaling removed.

M33d.sansScalingAndShear() → PyImath.M33d¶: Returns a copy of this matrix with scaling and shear removed.

M33d.scale(s: PyImath.V2d) → PyImath.M33d¶: Sets this matrix to scale by the given vector.

M33d.setRotation(r: float) → PyImath.M33d¶: Sets the rotation component of this matrix to r (in radians).

M33d.setScale(*args, **kwargs)¶

Overloaded function.

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

Sets this matrix to scale by the given uniform factor.

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

Sets this matrix to scale by the given uniform factor

M33d.setShear(*args, **kwargs)¶

Overloaded function.

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

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

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].

M33d.setTranslation(t: PyImath.V2d) → PyImath.M33d¶: Sets this matrix to translate by the given vector.

M33d.shear(*args, **kwargs)¶

Overloaded function.

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

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

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].

M33d.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.

M33d.translate(t: PyImath.V2d) → PyImath.M33d¶: Cumulatively translates this matrix by the given vector.

M33d.translation() → PyImath.V2d¶: Returns the translation component of this matrix.

M33d.transpose() → PyImath.M33d¶: Transpose this matrix.

M33d.transposed() → PyImath.M33d¶: Returns the transpose of this matrix.

class Imath.M33f¶

Bases: pybind11_builtins.pybind11_object

class M33fIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

M33f.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.M33f) -> None

Initializes an identity matrix.

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

static M33f.baseTypeEpsilon() → float¶: Returns a suitable epsilon value for comparing values of the underlying component type.

static M33f.baseTypeMax() → float¶: Returns the largest value that can be represented by the underling component type.

static M33f.baseTypeMin() → float¶: Returns the smallest value that can be represented by the underling component type.

static M33f.baseTypeSmallest() → float¶: Returns the smallest positive value that can be represented by the underlying component type.

M33f.equalWithAbsError(other: PyImath.M33f, error: float) → bool¶: Returns True if this matrix equals other up to the given absolute error.

M33f.equalWithRelError(other: PyImath.M33f, error: float) → bool¶: Returns True if this matrix equals other up to the given relative error.

M33f.extractAndRemoveScalingAndShear(*args, **kwargs)¶

Overloaded function.

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

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

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.

M33f.extractEuler(arg0: float) → None¶: Extract 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().

M33f.extractSHRT(*args, **kwargs)¶

Overloaded function.

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.

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

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

M33f.extractScaling(*args, **kwargs)¶

Overloaded function.

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

Returns the scaling component of this matrix.

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

Returns the scaling component of this matrix.

M33f.extractScalingAndShear(*args, **kwargs)¶

Overloaded function.

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

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

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

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

M33f.gjInverse(raise: bool = False) → PyImath.M33f¶: Returns the Gauss-Jordan inverse of this matrix, handling singular matrices as in gjInvert().

M33f.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.

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

M33f.inverse(raise: bool = False) → PyImath.M33f¶: Returns the inverse of this matrix, handling singular matrices as in invert().

M33f.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.

M33f.makeIdentity() → None¶: Sets this matrix to the identity.

M33f.multDirMatrix(*args, **kwargs)¶

Overloaded function.

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

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

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

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

M33f.multVecMatrix(*args, **kwargs)¶

Overloaded function.

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

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

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

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

M33f.negate() → PyImath.M33f¶: Negates this matrix.

M33f.removeScaling() → bool¶: Removes scaling from this matrix.

M33f.removeScalingAndShear() → bool¶: Removes scaling and shear from this matrix.

M33f.rotate(r: float) → PyImath.M33f¶: Cumulatively rotates this matrix by r (in radians).

M33f.sansScaling() → PyImath.M33f¶: Returns a copy of this matrix with scaling removed.

M33f.sansScalingAndShear() → PyImath.M33f¶: Returns a copy of this matrix with scaling and shear removed.

M33f.scale(s: PyImath.V2f) → PyImath.M33f¶: Sets this matrix to scale by the given vector.

M33f.setRotation(r: float) → PyImath.M33f¶: Sets the rotation component of this matrix to r (in radians).

M33f.setScale(*args, **kwargs)¶

Overloaded function.

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

Sets this matrix to scale by the given uniform factor.

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

Sets this matrix to scale by the given uniform factor

M33f.setShear(*args, **kwargs)¶

Overloaded function.

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

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

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].

M33f.setTranslation(t: PyImath.V2f) → PyImath.M33f¶: Sets this matrix to translate by the given vector.

M33f.shear(*args, **kwargs)¶

Overloaded function.

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

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

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].

M33f.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.

M33f.translate(t: PyImath.V2f) → PyImath.M33f¶: Cumulatively translates this matrix by the given vector.

M33f.translation() → PyImath.V2f¶: Returns the translation component of this matrix.

M33f.transpose() → PyImath.M33f¶: Transpose this matrix.

M33f.transposed() → PyImath.M33f¶: Returns the transpose of this matrix.

class Imath.M44d¶

Bases: pybind11_builtins.pybind11_object

class M44dIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

M44d.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.M44d) -> None

Initializes an identity matrix.

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

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

__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
__init__(self: PyImath.M44d, col0: object, col1: object, col2: object, col3: object) -> None

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

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

Initializes a 4x4 matrix from an iterable.

static M44d.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 M44d.baseTypeEpsilon() → float¶: Returns a suitable epsilon value for comparing values of the underlying component type.

static M44d.baseTypeMax() → float¶: Returns the largest value that can be represented by the underling component type.

static M44d.baseTypeMin() → float¶: Returns the smallest value that can be represented by the underling component type.

static M44d.baseTypeSmallest() → float¶: Returns the smallest positive value that can be represented by the underlying component type.

M44d.equalWithAbsError(other: PyImath.M44d, error: float) → bool¶: Returns True if this matrix equals other up to the given absolute error.

M44d.equalWithRelError(other: PyImath.M44d, error: float) → bool¶: Returns True if this matrix equals other up to the given relative error.

M44d.extractAndRemoveScalingAndShear(*args, **kwargs)¶

Overloaded function.

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

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

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.

M44d.extractEulerXYZ(*args, **kwargs)¶

Overloaded function.

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().

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

Returns the XYZ Euler angles from this matrix.

M44d.extractEulerZYX(*args, **kwargs)¶

Overloaded function.

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

As extractEulerXYZ but with reversed rotation order.

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

As extractEulerXYZ but with reserved rotation order.

M44d.extractQuat() → Imath_2_4::Quat<double>¶: Returns a quaternion extracted from this matrix. See extractEulerXYZ() for assumptions.

M44d.extractSHRT(*args, **kwargs)¶

Overloaded function.

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

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

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

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

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

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

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

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

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.

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

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

M44d.extractScaling(*args, **kwargs)¶

Overloaded function.

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

Returns the scaling component of this matrix.

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

Returns the scaling component of this matrix.

M44d.extractScalingAndShear(*args, **kwargs)¶

Overloaded function.

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

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

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

M44d.gjInverse(raise: bool = False) → PyImath.M44d¶: Returns the Gauss-Jordan inverse of this matrix, handling singular matrices as in gjInvert().

M44d.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.

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

M44d.inverse(raise: bool = False) → PyImath.M44d¶: Returns the inverse of this matrix, handling singular matrices as in invert().

M44d.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.

M44d.makeIdentity() → None¶: Sets this matrix to the identity.

M44d.multDirMatrix(*args, **kwargs)¶

Overloaded function.

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

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

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

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

M44d.multVecMatrix(*args, **kwargs)¶

Overloaded function.

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

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

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

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

M44d.multiply(other: PyImath.M44d, out: PyImath.M44d) → None¶: Multiplies this matrix by other, storing the result in out. Prefer to use out = self * other instead.

M44d.negate() → PyImath.M44d¶: Negates this matrix.

M44d.removeScaling() → bool¶: Removes scaling from this matrix.

M44d.removeScalingAndShear() → bool¶: Removes scaling and shear from this matrix.

M44d.rotate(angles: PyImath.V3d) → PyImath.M44d¶: Cumulatively rotate this matrix by the given XYZ Euler angles (in radians).

static M44d.rotationMatrix(fromDir: PyImath.V3d, toDir: PyImath.V3d) → PyImath.M44d¶: Returns a matrix that rotates fromDir to toDir.

static M44d.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.

M44d.sansScaling() → PyImath.M44d¶: Returns a copy of this matrix with scaling removed.

M44d.sansScalingAndShear() → PyImath.M44d¶: Returns a copy of this matrix with scaling and shear removed.

M44d.scale(s: PyImath.V3d) → PyImath.M44d¶: Sets this matrix to scale by the given vector.

M44d.setAxisAngle(axis: PyImath.V3d, angle: float) → PyImath.M44d¶: Sets the rotation component of this matrix using the given axis and angle (in radians).

M44d.setEulerAngles(angles: PyImath.V3d) → PyImath.M44d¶: Sets the rotation component of this matrix to the given XYZ Euler angles (in radians).

M44d.setScale(*args, **kwargs)¶

Overloaded function.

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

Sets this matrix to scale by the given uniform factor.

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

Sets this matrix to scale by the given uniform factor

M44d.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].

M44d.setTranslation(t: PyImath.V3d) → PyImath.M44d¶: Sets this matrix to translate by the given vector.

M44d.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].

M44d.toMatrix33() → Imath_2_4::Matrix33<double>¶: Returns the upper-left 3x3 matrix.

M44d.translate(t: PyImath.V3d) → PyImath.M44d¶: Cumulatively translates this matrix by the given vector.

M44d.translation() → PyImath.V3d¶: Returns the translation component of this matrix.

M44d.transpose() → PyImath.M44d¶: Transpose this matrix.

M44d.transposed() → PyImath.M44d¶: Returns the transpose of this matrix.

class Imath.M44f¶

Bases: pybind11_builtins.pybind11_object

class M44fIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

M44f.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.M44f) -> None

Initializes an identity matrix.

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

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

__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
__init__(self: PyImath.M44f, col0: object, col1: object, col2: object, col3: object) -> None

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

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

Initializes a 4x4 matrix from an iterable.

static M44f.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 M44f.baseTypeEpsilon() → float¶: Returns a suitable epsilon value for comparing values of the underlying component type.

static M44f.baseTypeMax() → float¶: Returns the largest value that can be represented by the underling component type.

static M44f.baseTypeMin() → float¶: Returns the smallest value that can be represented by the underling component type.

static M44f.baseTypeSmallest() → float¶: Returns the smallest positive value that can be represented by the underlying component type.

M44f.equalWithAbsError(other: PyImath.M44f, error: float) → bool¶: Returns True if this matrix equals other up to the given absolute error.

M44f.equalWithRelError(other: PyImath.M44f, error: float) → bool¶: Returns True if this matrix equals other up to the given relative error.

M44f.extractAndRemoveScalingAndShear(*args, **kwargs)¶

Overloaded function.

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

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

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.

M44f.extractEulerXYZ(*args, **kwargs)¶

Overloaded function.

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().

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

Returns the XYZ Euler angles from this matrix.

M44f.extractEulerZYX(*args, **kwargs)¶

Overloaded function.

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

As extractEulerXYZ but with reversed rotation order.

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

As extractEulerXYZ but with reserved rotation order.

M44f.extractQuat() → Imath_2_4::Quat<float>¶: Returns a quaternion extracted from this matrix. See extractEulerXYZ() for assumptions.

M44f.extractSHRT(*args, **kwargs)¶

Overloaded function.

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

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

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

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

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

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

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

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

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.

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

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

M44f.extractScaling(*args, **kwargs)¶

Overloaded function.

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

Returns the scaling component of this matrix.

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

Returns the scaling component of this matrix.

M44f.extractScalingAndShear(*args, **kwargs)¶

Overloaded function.

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

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

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

M44f.gjInverse(raise: bool = False) → PyImath.M44f¶: Returns the Gauss-Jordan inverse of this matrix, handling singular matrices as in gjInvert().

M44f.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.

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

M44f.inverse(raise: bool = False) → PyImath.M44f¶: Returns the inverse of this matrix, handling singular matrices as in invert().

M44f.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.

M44f.makeIdentity() → None¶: Sets this matrix to the identity.

M44f.multDirMatrix(*args, **kwargs)¶

Overloaded function.

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

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

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

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

M44f.multVecMatrix(*args, **kwargs)¶

Overloaded function.

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

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

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

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

M44f.multiply(other: PyImath.M44f, out: PyImath.M44f) → None¶: Multiplies this matrix by other, storing the result in out. Prefer to use out = self * other instead.

M44f.negate() → PyImath.M44f¶: Negates this matrix.

M44f.removeScaling() → bool¶: Removes scaling from this matrix.

M44f.removeScalingAndShear() → bool¶: Removes scaling and shear from this matrix.

M44f.rotate(angles: PyImath.V3f) → PyImath.M44f¶: Cumulatively rotate this matrix by the given XYZ Euler angles (in radians).

static M44f.rotationMatrix(fromDir: PyImath.V3f, toDir: PyImath.V3f) → PyImath.M44f¶: Returns a matrix that rotates fromDir to toDir.

static M44f.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.

M44f.sansScaling() → PyImath.M44f¶: Returns a copy of this matrix with scaling removed.

M44f.sansScalingAndShear() → PyImath.M44f¶: Returns a copy of this matrix with scaling and shear removed.

M44f.scale(s: PyImath.V3f) → PyImath.M44f¶: Sets this matrix to scale by the given vector.

M44f.setAxisAngle(axis: PyImath.V3f, angle: float) → PyImath.M44f¶: Sets the rotation component of this matrix using the given axis and angle (in radians).

M44f.setEulerAngles(angles: PyImath.V3f) → PyImath.M44f¶: Sets the rotation component of this matrix to the given XYZ Euler angles (in radians).

M44f.setScale(*args, **kwargs)¶

Overloaded function.

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

Sets this matrix to scale by the given uniform factor.

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

Sets this matrix to scale by the given uniform factor

M44f.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].

M44f.setTranslation(t: PyImath.V3f) → PyImath.M44f¶: Sets this matrix to translate by the given vector.

M44f.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].

M44f.toMatrix33() → Imath_2_4::Matrix33<float>¶: Returns the upper-left 3x3 matrix.

M44f.translate(t: PyImath.V3f) → PyImath.M44f¶: Cumulatively translates this matrix by the given vector.

M44f.translation() → PyImath.V3f¶: Returns the translation component of this matrix.

M44f.transpose() → PyImath.M44f¶: Transpose this matrix.

M44f.transposed() → PyImath.M44f¶: Returns the transpose of this matrix.

class Imath.Quatd¶

Bases: pybind11_builtins.pybind11_object

class QuatdIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

Quatd.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Quatd) -> None

Initializes a quaternion to the real unit 1.0.

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

Initializes a quaternion from the given scalars.

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

Initializes a quaternion from a scalar and vector.

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

Initializes a quaternion from an iterable.

Quatd.angle¶

Quatd.axis¶

Quatd.exp() → PyImath.Quatd¶: Returns the exponential of this quaternion.

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

Quatd.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.

Quatd.inverse() → PyImath.Quatd¶: Returns the inverse of this quaternion.

Quatd.invert() → PyImath.Quatd¶: Invert this quaternion.

Quatd.length() → float¶: Returns the length of this quaternion.

Quatd.log() → PyImath.Quatd¶: Returns the logarithm of this quaternion.

Quatd.normalize() → PyImath.Quatd¶: Normalize thie quaternion.

Quatd.normalized() → PyImath.Quatd¶: Returns a copy of this quaternion that has been normalized.

Quatd.r¶: The real part of this quaternion.

Quatd.setAxisAngle(axis: PyImath.V3d, angle: float) → PyImath.Quatd¶: Sets this quaternion from the given axis and angle.

Quatd.setRotation(fromDir: PyImath.V3d, toDir: PyImath.V3d) → PyImath.Quatd¶: Sets this quaternion so that it rotates from fromDir to toDir.

Quatd.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.

Quatd.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.

Quatd.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.

Quatd.toMatrix33() → PyImath.M33d¶: Convert this quaternion to a 3x3 rotation matrix.

Quatd.toMatrix44() → PyImath.M44d¶: Convert this quaternion to a 4x4 rotation matrix.

Quatd.v¶: The imaginary part of this quaternion.

class Imath.Quatf¶

Bases: pybind11_builtins.pybind11_object

class QuatfIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

Quatf.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.Quatf) -> None

Initializes a quaternion to the real unit 1.0.

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

Initializes a quaternion from the given scalars.

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

Initializes a quaternion from a scalar and vector.

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

Initializes a quaternion from an iterable.

Quatf.angle¶

Quatf.axis¶

Quatf.exp() → PyImath.Quatf¶: Returns the exponential of this quaternion.

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

Quatf.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.

Quatf.inverse() → PyImath.Quatf¶: Returns the inverse of this quaternion.

Quatf.invert() → PyImath.Quatf¶: Invert this quaternion.

Quatf.length() → float¶: Returns the length of this quaternion.

Quatf.log() → PyImath.Quatf¶: Returns the logarithm of this quaternion.

Quatf.normalize() → PyImath.Quatf¶: Normalize thie quaternion.

Quatf.normalized() → PyImath.Quatf¶: Returns a copy of this quaternion that has been normalized.

Quatf.r¶: The real part of this quaternion.

Quatf.setAxisAngle(axis: PyImath.V3f, angle: float) → PyImath.Quatf¶: Sets this quaternion from the given axis and angle.

Quatf.setRotation(fromDir: PyImath.V3f, toDir: PyImath.V3f) → PyImath.Quatf¶: Sets this quaternion so that it rotates from fromDir to toDir.

Quatf.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.

Quatf.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.

Quatf.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.

Quatf.toMatrix33() → PyImath.M33f¶: Convert this quaternion to a 3x3 rotation matrix.

Quatf.toMatrix44() → PyImath.M44f¶: Convert this quaternion to a 4x4 rotation matrix.

Quatf.v¶: The imaginary part of this quaternion.

class Imath.V2d¶

Bases: pybind11_builtins.pybind11_object

class V2dIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

V2d.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.V2d) -> None

Initializes a vector with zero values.

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

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

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

Initializes a vector from an iterable.

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

Initializes a vector from the given x and y components.

static V2d.baseTypeEpsilon() → float¶: Returns an epsilon value suitable for comparing values of the underlying component type.

static V2d.baseTypeMax() → float¶: Returns the largest value that can be represented by the underlying component type.

static V2d.baseTypeMin() → float¶: Returns the smallest value that can be represented by the underlying component type.

static V2d.baseTypeSmallest() → float¶: Returns the smallest positive value that can be represented by the underlying component type.

V2d.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.

V2d.cross(other: PyImath.V2d) → float¶: Returns the cross product of this vector and other.

static V2d.dimensions() → int¶: Returns the number of components in this vector type.

V2d.dot(other: PyImath.V2d) → float¶: Returns the dot product of this vector and other.

V2d.equalWithAbsError(other: PyImath.V2d, error: float) → bool¶: Returns True if this vector equals other, up to the given absolute error.

V2d.equalWithRelError(other: PyImath.V2d, error: float) → bool¶: Returns True if this vector equals other, up to the given relative error.

V2d.length() → float¶: Computes the length of this vector.

V2d.length2() → float¶: Computes the squared length of this vector.

V2d.negate() → PyImath.V2d¶: Negate this vector.

V2d.normalize() → PyImath.V2d¶: Normalize this vector. Sets a null vector if length is zero.

V2d.normalizeExc() → PyImath.V2d¶: Normalize this vector, raising a RuntimeError if length is zero.

V2d.normalizeNonNull() → PyImath.V2d¶: Equivalent to self.normalize().

V2d.normalized() → PyImath.V2d¶: Returns a normalized version of this vector, or a null vector if length is zero.

V2d.normalizedExc() → PyImath.V2d¶: Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

V2d.normalizedNonNull() → PyImath.V2d¶: Equivalent to self.normalized().

V2d.orthogonal(t: PyImath.V2d) → PyImath.V2d¶: Returns a vector which is perpendicular to this vector and in the same plane as t.

static V2d.project(s: PyImath.V2d, t: PyImath.V2d) → PyImath.V2d¶: Returns the projection of the vector s onto the vector t.

V2d.projection(s: PyImath.V2d) → PyImath.V2d¶: Returns the projection of this vector onto s.

V2d.reflect(t: PyImath.V2d) → PyImath.V2d¶: Returns the result of reflecting this vector in the plane with normal t.

V2d.x¶: The x component of this vector.

V2d.y¶: The y component of this vector.

class Imath.V2f¶

Bases: pybind11_builtins.pybind11_object

class V2fIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

V2f.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.V2f) -> None

Initializes a vector with zero values.

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

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

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

Initializes a vector from an iterable.

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

Initializes a vector from the given x and y components.

static V2f.baseTypeEpsilon() → float¶: Returns an epsilon value suitable for comparing values of the underlying component type.

static V2f.baseTypeMax() → float¶: Returns the largest value that can be represented by the underlying component type.

static V2f.baseTypeMin() → float¶: Returns the smallest value that can be represented by the underlying component type.

static V2f.baseTypeSmallest() → float¶: Returns the smallest positive value that can be represented by the underlying component type.

V2f.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.

V2f.cross(other: PyImath.V2f) → float¶: Returns the cross product of this vector and other.

static V2f.dimensions() → int¶: Returns the number of components in this vector type.

V2f.dot(other: PyImath.V2f) → float¶: Returns the dot product of this vector and other.

V2f.equalWithAbsError(other: PyImath.V2f, error: float) → bool¶: Returns True if this vector equals other, up to the given absolute error.

V2f.equalWithRelError(other: PyImath.V2f, error: float) → bool¶: Returns True if this vector equals other, up to the given relative error.

V2f.length() → float¶: Computes the length of this vector.

V2f.length2() → float¶: Computes the squared length of this vector.

V2f.negate() → PyImath.V2f¶: Negate this vector.

V2f.normalize() → PyImath.V2f¶: Normalize this vector. Sets a null vector if length is zero.

V2f.normalizeExc() → PyImath.V2f¶: Normalize this vector, raising a RuntimeError if length is zero.

V2f.normalizeNonNull() → PyImath.V2f¶: Equivalent to self.normalize().

V2f.normalized() → PyImath.V2f¶: Returns a normalized version of this vector, or a null vector if length is zero.

V2f.normalizedExc() → PyImath.V2f¶: Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

V2f.normalizedNonNull() → PyImath.V2f¶: Equivalent to self.normalized().

V2f.orthogonal(t: PyImath.V2f) → PyImath.V2f¶: Returns a vector which is perpendicular to this vector and in the same plane as t.

static V2f.project(s: PyImath.V2f, t: PyImath.V2f) → PyImath.V2f¶: Returns the projection of the vector s onto the vector t.

V2f.projection(s: PyImath.V2f) → PyImath.V2f¶: Returns the projection of this vector onto s.

V2f.reflect(t: PyImath.V2f) → PyImath.V2f¶: Returns the result of reflecting this vector in the plane with normal t.

V2f.x¶: The x component of this vector.

V2f.y¶: The y component of this vector.

class Imath.V2i¶

Bases: pybind11_builtins.pybind11_object

class V2iIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

V2i.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.V2i) -> None

Initializes a vector with zero values.

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

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

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

Initializes a vector from an iterable.

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

Initializes a vector from the given x and y components.

static V2i.baseTypeEpsilon() → int¶: Returns an epsilon value suitable for comparing values of the underlying component type.

static V2i.baseTypeMax() → int¶: Returns the largest value that can be represented by the underlying component type.

static V2i.baseTypeMin() → int¶: Returns the smallest value that can be represented by the underlying component type.

static V2i.baseTypeSmallest() → int¶: Returns the smallest positive value that can be represented by the underlying component type.

V2i.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.

V2i.cross(other: PyImath.V2i) → int¶: Returns the cross product of this vector and other.

static V2i.dimensions() → int¶: Returns the number of components in this vector type.

V2i.dot(other: PyImath.V2i) → int¶: Returns the dot product of this vector and other.

V2i.equalWithAbsError(other: PyImath.V2i, error: int) → bool¶: Returns True if this vector equals other, up to the given absolute error.

V2i.equalWithRelError(other: PyImath.V2i, error: int) → bool¶: Returns True if this vector equals other, up to the given relative error.

V2i.length() → int¶: Computes the length of this vector.

V2i.length2() → int¶: Computes the squared length of this vector.

V2i.negate() → PyImath.V2i¶: Negate this vector.

V2i.normalize() → PyImath.V2i¶: Normalize this vector. Sets a null vector if length is zero.

V2i.normalizeExc() → PyImath.V2i¶: Normalize this vector, raising a RuntimeError if length is zero.

V2i.normalizeNonNull() → PyImath.V2i¶: Equivalent to self.normalize().

V2i.normalized() → PyImath.V2i¶: Returns a normalized version of this vector, or a null vector if length is zero.

V2i.normalizedExc() → PyImath.V2i¶: Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

V2i.normalizedNonNull() → PyImath.V2i¶: Equivalent to self.normalized().

V2i.orthogonal(t: PyImath.V2i) → PyImath.V2i¶: Returns a vector which is perpendicular to this vector and in the same plane as t.

static V2i.project(s: PyImath.V2i, t: PyImath.V2i) → PyImath.V2i¶: Returns the projection of the vector s onto the vector t.

V2i.projection(s: PyImath.V2i) → PyImath.V2i¶: Returns the projection of this vector onto s.

V2i.reflect(t: PyImath.V2i) → PyImath.V2i¶: Returns the result of reflecting this vector in the plane with normal t.

V2i.x¶: The x component of this vector.

V2i.y¶: The y component of this vector.

class Imath.V2s¶

Bases: pybind11_builtins.pybind11_object

class V2sIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

V2s.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.V2s) -> None

Initializes a vector with zero values.

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

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

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

Initializes a vector from an iterable.

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

Initializes a vector from the given x and y components.

static V2s.baseTypeEpsilon() → int¶: Returns an epsilon value suitable for comparing values of the underlying component type.

static V2s.baseTypeMax() → int¶: Returns the largest value that can be represented by the underlying component type.

static V2s.baseTypeMin() → int¶: Returns the smallest value that can be represented by the underlying component type.

static V2s.baseTypeSmallest() → int¶: Returns the smallest positive value that can be represented by the underlying component type.

V2s.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.

V2s.cross(other: PyImath.V2s) → int¶: Returns the cross product of this vector and other.

static V2s.dimensions() → int¶: Returns the number of components in this vector type.

V2s.dot(other: PyImath.V2s) → int¶: Returns the dot product of this vector and other.

V2s.equalWithAbsError(other: PyImath.V2s, error: int) → bool¶: Returns True if this vector equals other, up to the given absolute error.

V2s.equalWithRelError(other: PyImath.V2s, error: int) → bool¶: Returns True if this vector equals other, up to the given relative error.

V2s.length() → int¶: Computes the length of this vector.

V2s.length2() → int¶: Computes the squared length of this vector.

V2s.negate() → PyImath.V2s¶: Negate this vector.

V2s.normalize() → PyImath.V2s¶: Normalize this vector. Sets a null vector if length is zero.

V2s.normalizeExc() → PyImath.V2s¶: Normalize this vector, raising a RuntimeError if length is zero.

V2s.normalizeNonNull() → PyImath.V2s¶: Equivalent to self.normalize().

V2s.normalized() → PyImath.V2s¶: Returns a normalized version of this vector, or a null vector if length is zero.

V2s.normalizedExc() → PyImath.V2s¶: Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

V2s.normalizedNonNull() → PyImath.V2s¶: Equivalent to self.normalized().

V2s.orthogonal(t: PyImath.V2s) → PyImath.V2s¶: Returns a vector which is perpendicular to this vector and in the same plane as t.

static V2s.project(s: PyImath.V2s, t: PyImath.V2s) → PyImath.V2s¶: Returns the projection of the vector s onto the vector t.

V2s.projection(s: PyImath.V2s) → PyImath.V2s¶: Returns the projection of this vector onto s.

V2s.reflect(t: PyImath.V2s) → PyImath.V2s¶: Returns the result of reflecting this vector in the plane with normal t.

V2s.x¶: The x component of this vector.

V2s.y¶: The y component of this vector.

class Imath.V3c¶

Bases: pybind11_builtins.pybind11_object

class V3cIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

V3c.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.V3c) -> None

Initializes a vector with zero values.

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

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

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

Initializes a vector from an iterable.

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

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

static V3c.baseTypeEpsilon() → int¶: Returns an epsilon value suitable for comparing values of the underlying component type.

static V3c.baseTypeMax() → int¶: Returns the largest value that can be represented by the underlying component type.

static V3c.baseTypeMin() → int¶: Returns the smallest value that can be represented by the underlying component type.

static V3c.baseTypeSmallest() → int¶: Returns the smallest positive value that can be represented by the underlying component type.

V3c.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.

V3c.cross(other: PyImath.V3c) → PyImath.V3c¶: Returns the cross product of this vector and other.

static V3c.dimensions() → int¶: Returns the number of components in this vector type.

V3c.dot(other: PyImath.V3c) → int¶: Returns the dot product of this vector and other.

V3c.equalWithAbsError(other: PyImath.V3c, error: int) → bool¶: Returns True if this vector equals other, up to the given absolute error.

V3c.equalWithRelError(other: PyImath.V3c, error: int) → bool¶: Returns True if this vector equals other, up to the given relative error.

V3c.length() → int¶: Computes the length of this vector.

V3c.length2() → int¶: Computes the squared length of this vector.

V3c.negate() → PyImath.V3c¶: Negate this vector.

V3c.normalize() → PyImath.V3c¶: Normalize this vector. Sets a null vector if length is zero.

V3c.normalizeExc() → PyImath.V3c¶: Normalize this vector, raising a RuntimeError if length is zero.

V3c.normalizeNonNull() → PyImath.V3c¶: Equivalent to self.normalize().

V3c.normalized() → PyImath.V3c¶: Returns a normalized version of this vector, or a null vector if length is zero.

V3c.normalizedExc() → PyImath.V3c¶: Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

V3c.normalizedNonNull() → PyImath.V3c¶: Equivalent to self.normalized().

V3c.orthogonal(t: PyImath.V3c) → PyImath.V3c¶: Returns a vector which is perpendicular to this vector and in the same plane as t.

static V3c.project(s: PyImath.V3c, t: PyImath.V3c) → PyImath.V3c¶: Returns the projection of the vector s onto the vector t.

V3c.projection(s: PyImath.V3c) → PyImath.V3c¶: Returns the projection of this vector onto s.

V3c.reflect(t: PyImath.V3c) → PyImath.V3c¶: Returns the result of reflecting this vector in the plane with normal t.

V3c.x¶: The x component of this vector.

V3c.y¶: The y component of this vector.

V3c.z¶: The z component of this vector

class Imath.V3d¶

Bases: pybind11_builtins.pybind11_object

class V3dIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

V3d.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.V3d) -> None

Initializes a vector with zero values.

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

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

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

Initializes a vector from an iterable.

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

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

static V3d.baseTypeEpsilon() → float¶: Returns an epsilon value suitable for comparing values of the underlying component type.

static V3d.baseTypeMax() → float¶: Returns the largest value that can be represented by the underlying component type.

static V3d.baseTypeMin() → float¶: Returns the smallest value that can be represented by the underlying component type.

static V3d.baseTypeSmallest() → float¶: Returns the smallest positive value that can be represented by the underlying component type.

V3d.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.

V3d.cross(other: PyImath.V3d) → PyImath.V3d¶: Returns the cross product of this vector and other.

static V3d.dimensions() → int¶: Returns the number of components in this vector type.

V3d.dot(other: PyImath.V3d) → float¶: Returns the dot product of this vector and other.

V3d.equalWithAbsError(other: PyImath.V3d, error: float) → bool¶: Returns True if this vector equals other, up to the given absolute error.

V3d.equalWithRelError(other: PyImath.V3d, error: float) → bool¶: Returns True if this vector equals other, up to the given relative error.

V3d.length() → float¶: Computes the length of this vector.

V3d.length2() → float¶: Computes the squared length of this vector.

V3d.negate() → PyImath.V3d¶: Negate this vector.

V3d.normalize() → PyImath.V3d¶: Normalize this vector. Sets a null vector if length is zero.

V3d.normalizeExc() → PyImath.V3d¶: Normalize this vector, raising a RuntimeError if length is zero.

V3d.normalizeNonNull() → PyImath.V3d¶: Equivalent to self.normalize().

V3d.normalized() → PyImath.V3d¶: Returns a normalized version of this vector, or a null vector if length is zero.

V3d.normalizedExc() → PyImath.V3d¶: Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

V3d.normalizedNonNull() → PyImath.V3d¶: Equivalent to self.normalized().

V3d.orthogonal(t: PyImath.V3d) → PyImath.V3d¶: Returns a vector which is perpendicular to this vector and in the same plane as t.

static V3d.project(s: PyImath.V3d, t: PyImath.V3d) → PyImath.V3d¶: Returns the projection of the vector s onto the vector t.

V3d.projection(s: PyImath.V3d) → PyImath.V3d¶: Returns the projection of this vector onto s.

V3d.reflect(t: PyImath.V3d) → PyImath.V3d¶: Returns the result of reflecting this vector in the plane with normal t.

V3d.x¶: The x component of this vector.

V3d.y¶: The y component of this vector.

V3d.z¶: The z component of this vector

class Imath.V3f¶

Bases: pybind11_builtins.pybind11_object

class V3fIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → float¶

V3f.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.V3f) -> None

Initializes a vector with zero values.

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

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

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

Initializes a vector from an iterable.

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

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

static V3f.baseTypeEpsilon() → float¶: Returns an epsilon value suitable for comparing values of the underlying component type.

static V3f.baseTypeMax() → float¶: Returns the largest value that can be represented by the underlying component type.

static V3f.baseTypeMin() → float¶: Returns the smallest value that can be represented by the underlying component type.

static V3f.baseTypeSmallest() → float¶: Returns the smallest positive value that can be represented by the underlying component type.

V3f.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.

V3f.cross(other: PyImath.V3f) → PyImath.V3f¶: Returns the cross product of this vector and other.

static V3f.dimensions() → int¶: Returns the number of components in this vector type.

V3f.dot(other: PyImath.V3f) → float¶: Returns the dot product of this vector and other.

V3f.equalWithAbsError(other: PyImath.V3f, error: float) → bool¶: Returns True if this vector equals other, up to the given absolute error.

V3f.equalWithRelError(other: PyImath.V3f, error: float) → bool¶: Returns True if this vector equals other, up to the given relative error.

V3f.length() → float¶: Computes the length of this vector.

V3f.length2() → float¶: Computes the squared length of this vector.

V3f.negate() → PyImath.V3f¶: Negate this vector.

V3f.normalize() → PyImath.V3f¶: Normalize this vector. Sets a null vector if length is zero.

V3f.normalizeExc() → PyImath.V3f¶: Normalize this vector, raising a RuntimeError if length is zero.

V3f.normalizeNonNull() → PyImath.V3f¶: Equivalent to self.normalize().

V3f.normalized() → PyImath.V3f¶: Returns a normalized version of this vector, or a null vector if length is zero.

V3f.normalizedExc() → PyImath.V3f¶: Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

V3f.normalizedNonNull() → PyImath.V3f¶: Equivalent to self.normalized().

V3f.orthogonal(t: PyImath.V3f) → PyImath.V3f¶: Returns a vector which is perpendicular to this vector and in the same plane as t.

static V3f.project(s: PyImath.V3f, t: PyImath.V3f) → PyImath.V3f¶: Returns the projection of the vector s onto the vector t.

V3f.projection(s: PyImath.V3f) → PyImath.V3f¶: Returns the projection of this vector onto s.

V3f.reflect(t: PyImath.V3f) → PyImath.V3f¶: Returns the result of reflecting this vector in the plane with normal t.

V3f.x¶: The x component of this vector.

V3f.y¶: The y component of this vector.

V3f.z¶: The z component of this vector

class Imath.V3h¶

Bases: pybind11_builtins.pybind11_object

class V3hIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → half¶

V3h.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.V3h) -> None

Initializes a vector with zero values.

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

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

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

Initializes a vector from an iterable.

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

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

static V3h.baseTypeEpsilon() → half¶: Returns an epsilon value suitable for comparing values of the underlying component type.

static V3h.baseTypeMax() → half¶: Returns the largest value that can be represented by the underlying component type.

static V3h.baseTypeMin() → half¶: Returns the smallest value that can be represented by the underlying component type.

static V3h.baseTypeSmallest() → half¶: Returns the smallest positive value that can be represented by the underlying component type.

V3h.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.

V3h.cross(other: PyImath.V3h) → PyImath.V3h¶: Returns the cross product of this vector and other.

static V3h.dimensions() → int¶: Returns the number of components in this vector type.

V3h.dot(other: PyImath.V3h) → half¶: Returns the dot product of this vector and other.

V3h.equalWithAbsError(other: PyImath.V3h, error: half) → bool¶: Returns True if this vector equals other, up to the given absolute error.

V3h.equalWithRelError(other: PyImath.V3h, error: half) → bool¶: Returns True if this vector equals other, up to the given relative error.

V3h.length() → half¶: Computes the length of this vector.

V3h.length2() → half¶: Computes the squared length of this vector.

V3h.negate() → PyImath.V3h¶: Negate this vector.

V3h.normalize() → PyImath.V3h¶: Normalize this vector. Sets a null vector if length is zero.

V3h.normalizeExc() → PyImath.V3h¶: Normalize this vector, raising a RuntimeError if length is zero.

V3h.normalizeNonNull() → PyImath.V3h¶: Equivalent to self.normalize().

V3h.normalized() → PyImath.V3h¶: Returns a normalized version of this vector, or a null vector if length is zero.

V3h.normalizedExc() → PyImath.V3h¶: Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

V3h.normalizedNonNull() → PyImath.V3h¶: Equivalent to self.normalized().

V3h.orthogonal(t: PyImath.V3h) → PyImath.V3h¶: Returns a vector which is perpendicular to this vector and in the same plane as t.

static V3h.project(s: PyImath.V3h, t: PyImath.V3h) → PyImath.V3h¶: Returns the projection of the vector s onto the vector t.

V3h.projection(s: PyImath.V3h) → PyImath.V3h¶: Returns the projection of this vector onto s.

V3h.reflect(t: PyImath.V3h) → PyImath.V3h¶: Returns the result of reflecting this vector in the plane with normal t.

V3h.x¶: The x component of this vector.

V3h.y¶: The y component of this vector.

V3h.z¶: The z component of this vector

class Imath.V3i¶

Bases: pybind11_builtins.pybind11_object

class V3iIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

V3i.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.V3i) -> None

Initializes a vector with zero values.

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

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

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

Initializes a vector from an iterable.

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

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

static V3i.baseTypeEpsilon() → int¶: Returns an epsilon value suitable for comparing values of the underlying component type.

static V3i.baseTypeMax() → int¶: Returns the largest value that can be represented by the underlying component type.

static V3i.baseTypeMin() → int¶: Returns the smallest value that can be represented by the underlying component type.

static V3i.baseTypeSmallest() → int¶: Returns the smallest positive value that can be represented by the underlying component type.

V3i.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.

V3i.cross(other: PyImath.V3i) → PyImath.V3i¶: Returns the cross product of this vector and other.

static V3i.dimensions() → int¶: Returns the number of components in this vector type.

V3i.dot(other: PyImath.V3i) → int¶: Returns the dot product of this vector and other.

V3i.equalWithAbsError(other: PyImath.V3i, error: int) → bool¶: Returns True if this vector equals other, up to the given absolute error.

V3i.equalWithRelError(other: PyImath.V3i, error: int) → bool¶: Returns True if this vector equals other, up to the given relative error.

V3i.length() → int¶: Computes the length of this vector.

V3i.length2() → int¶: Computes the squared length of this vector.

V3i.negate() → PyImath.V3i¶: Negate this vector.

V3i.normalize() → PyImath.V3i¶: Normalize this vector. Sets a null vector if length is zero.

V3i.normalizeExc() → PyImath.V3i¶: Normalize this vector, raising a RuntimeError if length is zero.

V3i.normalizeNonNull() → PyImath.V3i¶: Equivalent to self.normalize().

V3i.normalized() → PyImath.V3i¶: Returns a normalized version of this vector, or a null vector if length is zero.

V3i.normalizedExc() → PyImath.V3i¶: Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

V3i.normalizedNonNull() → PyImath.V3i¶: Equivalent to self.normalized().

V3i.orthogonal(t: PyImath.V3i) → PyImath.V3i¶: Returns a vector which is perpendicular to this vector and in the same plane as t.

static V3i.project(s: PyImath.V3i, t: PyImath.V3i) → PyImath.V3i¶: Returns the projection of the vector s onto the vector t.

V3i.projection(s: PyImath.V3i) → PyImath.V3i¶: Returns the projection of this vector onto s.

V3i.reflect(t: PyImath.V3i) → PyImath.V3i¶: Returns the result of reflecting this vector in the plane with normal t.

V3i.x¶: The x component of this vector.

V3i.y¶: The y component of this vector.

V3i.z¶: The z component of this vector

class Imath.V3s¶

Bases: pybind11_builtins.pybind11_object

class V3sIterator¶

Bases: pybind11_builtins.pybind11_object

Imath Iterator

__init__¶: x.__init__(...) initializes x; see help(type(x)) for signature

next() → int¶

V3s.__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.V3s) -> None

Initializes a vector with zero values.

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

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

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

Initializes a vector from an iterable.

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

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

static V3s.baseTypeEpsilon() → int¶: Returns an epsilon value suitable for comparing values of the underlying component type.

static V3s.baseTypeMax() → int¶: Returns the largest value that can be represented by the underlying component type.

static V3s.baseTypeMin() → int¶: Returns the smallest value that can be represented by the underlying component type.

static V3s.baseTypeSmallest() → int¶: Returns the smallest positive value that can be represented by the underlying component type.

V3s.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.

V3s.cross(other: PyImath.V3s) → PyImath.V3s¶: Returns the cross product of this vector and other.

static V3s.dimensions() → int¶: Returns the number of components in this vector type.

V3s.dot(other: PyImath.V3s) → int¶: Returns the dot product of this vector and other.

V3s.equalWithAbsError(other: PyImath.V3s, error: int) → bool¶: Returns True if this vector equals other, up to the given absolute error.

V3s.equalWithRelError(other: PyImath.V3s, error: int) → bool¶: Returns True if this vector equals other, up to the given relative error.

V3s.length() → int¶: Computes the length of this vector.

V3s.length2() → int¶: Computes the squared length of this vector.

V3s.negate() → PyImath.V3s¶: Negate this vector.

V3s.normalize() → PyImath.V3s¶: Normalize this vector. Sets a null vector if length is zero.

V3s.normalizeExc() → PyImath.V3s¶: Normalize this vector, raising a RuntimeError if length is zero.

V3s.normalizeNonNull() → PyImath.V3s¶: Equivalent to self.normalize().

V3s.normalized() → PyImath.V3s¶: Returns a normalized version of this vector, or a null vector if length is zero.

V3s.normalizedExc() → PyImath.V3s¶: Returns a normalized version of this vector, or raises a RuntimeError if length is zero.

V3s.normalizedNonNull() → PyImath.V3s¶: Equivalent to self.normalized().

V3s.orthogonal(t: PyImath.V3s) → PyImath.V3s¶: Returns a vector which is perpendicular to this vector and in the same plane as t.

static V3s.project(s: PyImath.V3s, t: PyImath.V3s) → PyImath.V3s¶: Returns the projection of the vector s onto the vector t.

V3s.projection(s: PyImath.V3s) → PyImath.V3s¶: Returns the projection of this vector onto s.

V3s.reflect(t: PyImath.V3s) → PyImath.V3s¶: Returns the result of reflecting this vector in the plane with normal t.

V3s.x¶: The x component of this vector.

V3s.y¶: The y component of this vector.

V3s.z¶: The z component of this vector

Imath.abs(arg0: float) → float¶

Imath.ceil(arg0: float) → int¶

Imath.clamp(*args, **kwargs)¶

Overloaded function.

clamp(arg0: float, arg1: float, arg2: float) -> float
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_builtins.pybind11_object

__init__(*args, **kwargs)¶

Overloaded function.

__init__(self: PyImath.half) -> None

Initializes a half with zero value.

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

Initializes a half from the given float value.

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.

lerp(arg0: float, arg1: float, arg2: float) -> float
lerp(arg0: PyImath.V3f, arg1: PyImath.V3f, arg2: float) -> PyImath.V3f
lerp(arg0: PyImath.V2f, arg1: PyImath.V2f, arg2: float) -> PyImath.V2f
lerp(arg0: PyImath.V3d, arg1: PyImath.V3d, arg2: float) -> PyImath.V3d
lerp(arg0: PyImath.V2d, arg1: PyImath.V2d, arg2: float) -> PyImath.V2d
lerp(arg0: PyImath.V3i, arg1: PyImath.V3i, arg2: int) -> PyImath.V3i
lerp(arg0: PyImath.V2i, arg1: PyImath.V2i, arg2: int) -> PyImath.V2i
lerp(arg0: PyImath.V3s, arg1: PyImath.V3s, arg2: int) -> PyImath.V3s
lerp(arg0: PyImath.V2s, arg1: PyImath.V2s, arg2: int) -> PyImath.V2s
lerp(arg0: PyImath.C4f, arg1: PyImath.C4f, arg2: float) -> PyImath.C4f
lerp(arg0: PyImath.C3f, arg1: PyImath.C3f, arg2: float) -> PyImath.C3f
lerp(arg0: PyImath.C4h, arg1: PyImath.C4h, arg2: PyImath.half) -> PyImath.C4h
lerp(arg0: PyImath.C3h, arg1: PyImath.C3h, arg2: PyImath.half) -> PyImath.C3h
lerp(arg0: PyImath.C4c, arg1: PyImath.C4c, arg2: unicode) -> PyImath.C4c
lerp(arg0: PyImath.C3c, arg1: PyImath.C3c, arg2: unicode) -> 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¶

Imath (Python)¶

`Imath` (Python)¶