ManimColor¶

Qualified name: manim.utils.color.core.ManimColor

class ManimColor(value, alpha=1.0)[source]¶

Bases: object

Internal representation of a color.

The ManimColor class is the main class for the representation of a color. Its internal representation is an array of 4 floats corresponding to a [r,g,b,a] value where r,g,b,a can be between 0.0 and 1.0.

This is done in order to reduce the amount of color inconsistencies by constantly casting between integers and floats which introduces errors.

The class can accept any value of type ParsableManimColor i.e.

ManimColor, int, str, RGB_Tuple_Int, RGB_Tuple_Float, RGBA_Tuple_Int, RGBA_Tuple_Float, RGB_Array_Int, RGB_Array_Float, RGBA_Array_Int, RGBA_Array_Float

ManimColor itself only accepts singular values and will directly interpret them into a single color if possible. Be careful when passing strings to ManimColor: it can create a big overhead for the color processing.

If you want to parse a list of colors, use the parse() method, which assumes that you’re going to pass a list of colors so that arrays will not be interpreted as a single color.

Warning

If you pass an array of numbers to parse(), it will interpret the r,g,b,a numbers in that array as colors: Instead of the expected singular color, you will get an array with 4 colors.

For conversion behaviors, see the _internal functions for further documentation.

You can create a ManimColor instance via its classmethods. See the respective methods for more info.

mycolor = ManimColor.from_rgb((0, 1, 0.4, 0.5))
myothercolor = ManimColor.from_rgb((153, 255, 255))

You can also convert between different color spaces:

mycolor_hex = mycolor.to_hex()
myoriginalcolor = ManimColor.from_hex(mycolor_hex).to_hsv()

Parameters:

value (ParsableManimColor | None) – Some representation of a color (e.g., a string or a suitable tuple). The default None is BLACK.
alpha (float) – The opacity of the color. By default, colors are fully opaque (value 1.0).

Methods

`contrasting`	Return one of two colors, light or dark (by default white or black), that contrasts with the current color (depending on its luminance).
`darker`	Return a new color that is darker than the current color, i.e. interpolated with `BLACK`.
`from_hex`	Create a `ManimColor` from a hex string.
`from_hsl`	Create a `ManimColor` from an HSL array.
`from_hsv`	Create a `ManimColor` from an HSV array.
`from_rgb`	Create a ManimColor from an RGB array.
`from_rgba`	Create a ManimColor from an RGBA Array.
`gradient`	This method is currently not implemented.
`interpolate`	Interpolate between the current and the given `ManimColor`, and return the result.
`into`	Convert the current color into a different colorspace given by `class_type`, without changing the `_internal_value`.
`invert`	Return a new, linearly inverted version of this `ManimColor` (no inplace changes).
`lighter`	Return a new color that is lighter than the current color, i.e. interpolated with `WHITE`.
`opacity`	Create a new `ManimColor` with the given opacity and the same color values as before.
`parse`	Parse one color as a `ManimColor` or a sequence of colors as a list of `ManimColor`'s.
`to_hex`	Convert the `ManimColor` to a hexadecimal representation of the color.
`to_hsl`	Convert the `ManimColor` to an HSL array.
`to_hsv`	Convert the `ManimColor` to an HSV array.
`to_int_rgb`	Convert the current `ManimColor` into an RGB array of integers.
`to_int_rgba`	Convert the current ManimColor into an RGBA array of integers.
`to_int_rgba_with_alpha`	Convert the current `ManimColor` into an RGBA array of integers.
`to_integer`	Convert the current `ManimColor` into an integer.
`to_rgb`	Convert the current `ManimColor` into an RGB array of floats.
`to_rgba`	Convert the current `ManimColor` into an RGBA array of floats.
`to_rgba_with_alpha`	Convert the current `ManimColor` into an RGBA array of floats.

classmethod _construct_from_space(_space)[source]¶

This function is used as a proxy for constructing a color with an internal value. This can be used by subclasses to hook into the construction of new objects using the internal value format.

Parameters:: _space (ndarray[tuple[Any, ...], dtype[TypeAliasForwardRef('~manim.typing.ManimFloat')]] | tuple[float, float, float] | tuple[float, float, float, float])
Return type:: Self

classmethod _from_internal(value)[source]¶

This method is intended to be overwritten by custom color space classes which are subtypes of ManimColor.

The method constructs a new object of the given class by transforming the value in the internal format [r,g,b,a] into a format which the constructor of the custom class can understand. Look at HSV for an example.

Parameters:: value (ManimColorInternal)
Return type:: Self

static _internal_from_hex_string(hex_, alpha)[source]¶

Internal function for converting a hex string into the internal representation of a ManimColor.

Warning

This does not accept any prefixes like # or similar in front of the hex string. This is just intended for the raw hex part.

For internal use only

Parameters:

hex – Hex string to be parsed.
alpha (float) – Alpha value used for the color, if the color is only 3 bytes long. Otherwise, if the color is 4 bytes long, this parameter will not be used.
hex_ (str)

Returns:

Internal color representation

Return type:

ManimColorInternal

static _internal_from_int_rgb(rgb, alpha=1.0)[source]¶

Internal function for converting an RGB tuple of integers into the internal representation of a ManimColor.

For internal use only

Parameters:

rgb (IntRGBLike) – Integer RGB tuple to be parsed
alpha (float) – Optional alpha value. Default is 1.0.

Returns:

Internal color representation.

Return type:

ManimColorInternal

static _internal_from_int_rgba(rgba)[source]¶

Internal function for converting an RGBA tuple of integers into the internal representation of a ManimColor.

For internal use only

Parameters:: rgba (IntRGBALike) – Int RGBA tuple to be parsed.
Returns:: Internal color representation.
Return type:: ManimColorInternal

static _internal_from_rgb(rgb, alpha=1.0)[source]¶

Internal function for converting a rgb tuple of floats into the internal representation of a ManimColor.

For internal use only

Parameters:

rgb (FloatRGBLike) – Float RGB tuple to be parsed.
alpha (float) – Optional alpha value. Default is 1.0.

Returns:

Internal color representation.

Return type:

ManimColorInternal

static _internal_from_rgba(rgba)[source]¶

Internal function for converting an RGBA tuple of floats into the internal representation of a ManimColor.

For internal use only

Parameters:: rgba (FloatRGBALike) – Int RGBA tuple to be parsed.
Returns:: Internal color representation.
Return type:: ManimColorInternal

static _internal_from_string(name, alpha)[source]¶

Internal function for converting a string into the internal representation of a ManimColor. This is not used for hex strings: please refer to _internal_from_hex() for this functionality.

For internal use only

Parameters:

name (str) – The color name to be parsed into a color. Refer to the different color modules in the documentation page to find the corresponding color names.
alpha (float)

Returns:

Internal color representation.

Return type:

ManimColorInternal

Raises:

ValueError – If the color name is not present in Manim.

property _internal_space: ndarray[tuple[Any, ...], dtype[TypeAliasForwardRef('~manim.typing.ManimFloat')]]¶: This is a readonly property which is a custom representation for color space operations. It is used for operators and can be used when implementing a custom color space.

property _internal_value: ManimColorInternal¶

Return the internal value of the current Manim color [r,g,b,a] float array.

Returns:: Internal color representation.
Return type:: ManimColorInternal

contrasting(threshold=0.5, light=None, dark=None)[source]¶

Return one of two colors, light or dark (by default white or black), that contrasts with the current color (depending on its luminance). This is typically used to set text in a contrasting color that ensures it is readable against a background of the current color.

Parameters:

threshold (float) – The luminance threshold which dictates whether the current color is considered light or dark (and thus whether to return the dark or light color, respectively). Default is 0.5.
light (Self | None) – The light color to return if the current color is considered dark. Default is None: in this case, pure WHITE will be returned.
dark (Self | None) – The dark color to return if the current color is considered light, Default is None: in this case, pure BLACK will be returned.

Returns:

The contrasting ManimColor.

Return type:

ManimColor

darker(blend=0.2)[source]¶

Return a new color that is darker than the current color, i.e. interpolated with BLACK. The opacity is unchanged.

Parameters:: blend (float) – The blend ratio for the interpolation, from 0.0 (the current color unchanged) to 1.0 (pure black). Default is 0.2, which results in a slightly darker color.
Returns:: The darker ManimColor.
Return type:: ManimColor