Adding :class: ManimColor to manim and converting all types

manim/mobject/geometry/shape_matchers.py

@@ -10,7 +10,7 @@
 from manim.mobject.geometry.polygram import RoundedRectangle
 from manim.mobject.mobject import Mobject
 from manim.mobject.types.vectorized_mobject import VGroup
-from manim.utils.color import BLACK, RED, YELLOW, Color, Colors
+from manim.utils.color import BLACK, RED, YELLOW
 
 
 class SurroundingRectangle(RoundedRectangle):

manim/mobject/mobject.py

@@ -1,4 +1,5 @@
 """Base classes for objects that can be displayed."""
+
 from __future__ import annotations
 
 __all__ = ["Mobject", "Group", "override_animate"]
@@ -29,7 +30,6 @@
 )
 
 import numpy as np
-from colour import Color
 
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 
@@ -39,7 +39,8 @@
     BLACK,
     WHITE,
     YELLOW_C,
-    Colors,
+    ManimColor,
+    ParsableManimColor,
     color_gradient,
     interpolate_color,
 )
@@ -91,7 +92,9 @@ def __init_subclass__(cls, **kwargs):
         cls._add_intrinsic_animation_overrides()
         cls._original__init__ = cls.__init__
 
-    def __init__(self, color=WHITE, name=None, dim=3, target=None, z_index=0):
+    def __init__(
+        self, color: ManimColor = WHITE, name=None, dim=3, target=None, z_index=0
+    ):
         self.name = self.__class__.__name__ if name is None else name
         self.dim = dim
         self.target = target
@@ -100,7 +103,7 @@ def __init__(self, color=WHITE, name=None, dim=3, target=None, z_index=0):
         self.submobjects = []
         self.updaters = []
         self.updating_suspended = False
-        self.color = Color(color) if color else None
+        self.color: ManimColor = color
 
         self.reset_points()
         self.generate_points()
@@ -1684,7 +1687,7 @@ def put_start_and_end_on(self, start, end):
 
     # Background rectangle
     def add_background_rectangle(
-        self, color: Colors | None = None, opacity: float = 0.75, **kwargs
+        self, color: ParsableManimColor | None = None, opacity: float = 0.75, **kwargs
     ):
         """Add a BackgroundRectangle as submobject.
 
@@ -1736,7 +1739,7 @@ def add_background_rectangle_to_family_members_with_points(self, **kwargs):
 
     # Color functions
 
-    def set_color(self, color: Color = YELLOW_C, family: bool = True):
+    def set_color(self, color: ParsableManimColor = YELLOW_C, family: bool = True):
         """Condition is function which takes in one arguments, (x, y, z).
         Here it just recurses to submobjects, but in subclasses this
         should be further implemented based on the the inner workings
@@ -1745,19 +1748,19 @@ def set_color(self, color: Color = YELLOW_C, family: bool = True):
         if family:
             for submob in self.submobjects:
                 submob.set_color(color, family=family)
-        self.color = Color(color)
+        self.color = ManimColor.parse(color)
         return self
 
-    def set_color_by_gradient(self, *colors):
+    def set_color_by_gradient(self, *colors: Iterable[ParsableManimColor]):
         self.set_submobject_colors_by_gradient(*colors)
         return self
 
     def set_colors_by_radial_gradient(
         self,
         center=None,
-        radius=1,
-        inner_color=WHITE,
-        outer_color=BLACK,
+        radius: float = 1,
+        inner_color: ParsableManimColor = WHITE,
+        outer_color: ParsableManimColor = BLACK,
     ):
         self.set_submobject_colors_by_radial_gradient(
             center,
@@ -1767,7 +1770,7 @@ def set_colors_by_radial_gradient(
         )
         return self
 
-    def set_submobject_colors_by_gradient(self, *colors):
+    def set_submobject_colors_by_gradient(self, *colors: Iterable[ParsableManimColor]):
         if len(colors) == 0:
             raise ValueError("Need at least one color")
         elif len(colors) == 1:
@@ -1783,9 +1786,9 @@ def set_submobject_colors_by_gradient(self, *colors):
     def set_submobject_colors_by_radial_gradient(
         self,
         center=None,
-        radius=1,
-        inner_color=WHITE,
-        outer_color=BLACK,
+        radius: float = 1,
+        inner_color: ParsableManimColor = WHITE,
+        outer_color: ParsableManimColor = BLACK,
     ):
         if center is None:
             center = self.get_center()
@@ -1802,7 +1805,7 @@ def to_original_color(self):
         self.set_color(self.color)
         return self
 
-    def fade_to(self, color, alpha, family=True):
+    def fade_to(self, color: ParsableManimColor, alpha: float, family: bool = True):
         if self.get_num_points() > 0:
             new_color = interpolate_color(self.get_color(), color, alpha)
             self.set_color(new_color, family=False)
@@ -1811,13 +1814,13 @@ def fade_to(self, color, alpha, family=True):
                 submob.fade_to(color, alpha)
         return self
 
-    def fade(self, darkness=0.5, family=True):
+    def fade(self, darkness: float = 0.5, family: bool = True):
         if family:
             for submob in self.submobjects:
                 submob.fade(darkness, family)
         return self
 
-    def get_color(self):
+    def get_color(self) -> ManimColor:
         """Returns the color of the :class:`~.Mobject`"""
         return self.color
 

manim/mobject/opengl/opengl_mobject.py

@@ -16,7 +16,6 @@
 from manim.constants import *
 from manim.utils.bezier import integer_interpolate, interpolate
 from manim.utils.color import *
-from manim.utils.color import Colors
 from manim.utils.config_ops import _Data, _Uniforms
 
 # from ..utils.iterables import batch_by_property
@@ -2035,7 +2034,7 @@ def set_shadow(self, shadow, recurse=True):
     # Background rectangle
 
     def add_background_rectangle(
-        self, color: Colors | None = None, opacity: float = 0.75, **kwargs
+        self, color: ParsableManimColor | None = None, opacity: float = 0.75, **kwargs
     ):
         # TODO, this does not behave well when the mobject has points,
         # since it gets displayed on top
@@ -2069,7 +2068,7 @@ def add_background_rectangle(
         from manim.mobject.geometry.shape_matchers import BackgroundRectangle
 
         self.background_rectangle = BackgroundRectangle(
-            self, color=color, fill_opacity=opacity, **kwargs
+            self, color=ManimColor.parse(color), fill_opacity=opacity, **kwargs
         )
         self.add_to_back(self.background_rectangle)
         return self

manim/mobject/types/vectorized_mobject.py

@@ -16,7 +16,6 @@
 import typing
 from typing import Optional, Sequence, Union
 
-import colour
 import numpy as np
 from PIL.Image import Image
 
@@ -37,7 +36,7 @@
     partial_bezier_points,
     proportions_along_bezier_curve_for_point,
 )
-from ...utils.color import BLACK, WHITE, color_to_rgba
+from ...utils.color import BLACK, WHITE, ManimColor, ParsableManimColor, color_to_rgba
 from ...utils.deprecation import deprecated
 from ...utils.iterables import make_even, stretch_array_to_length, tuplify
 from ...utils.space_ops import rotate_vector, shoelace_direction
@@ -76,12 +75,12 @@ class VMobject(Mobject):
 
     def __init__(
         self,
-        fill_color=None,
+        fill_color: ParsableManimColor | None = None,
         fill_opacity=0.0,
-        stroke_color=None,
+        stroke_color: ParsableManimColor | None = None,
         stroke_opacity=1.0,
         stroke_width=DEFAULT_STROKE_WIDTH,
-        background_stroke_color=BLACK,
+        background_stroke_color: ParsableManimColor | None = BLACK,
         background_stroke_opacity=1.0,
         background_stroke_width=0,
         sheen_factor=0.0,
@@ -99,7 +98,10 @@ def __init__(
         self.fill_opacity = fill_opacity
         self.stroke_opacity = stroke_opacity
         self.stroke_width = stroke_width
-        self.background_stroke_color = background_stroke_color
+        if background_stroke_color is not None:
+            self.background_stroke_color: ManimColor = ManimColor.parse(
+                background_stroke_color
+            )
         self.background_stroke_opacity = background_stroke_opacity
         self.background_stroke_width = background_stroke_width
         self.sheen_factor = sheen_factor
@@ -114,11 +116,12 @@ def __init__(
         self.tolerance_for_point_equality = tolerance_for_point_equality
         self.n_points_per_cubic_curve = n_points_per_cubic_curve
         super().__init__(**kwargs)
+        self.submobjects: list[VMobject]
 
         if fill_color:
-            self.fill_color = fill_color
+            self.fill_color: ManimColor = ManimColor.parse(fill_color)
         if stroke_color:
-            self.stroke_color = stroke_color
+            self.stroke_color: ManimColor = ManimColor.parse(stroke_color)
 
     def get_group_class(self):
         return VGroup
@@ -158,7 +161,7 @@ def init_colors(self, propagate_colors=True):
 
         return self
 
-    def generate_rgbas_array(self, color, opacity):
+    def generate_rgbas_array(self, color: ManimColor | list[ManimColor], opacity):
         """
         First arg can be either a color, or a tuple/list of colors.
         Likewise, opacity can either be a float, or a tuple of floats.
@@ -169,7 +172,7 @@ def generate_rgbas_array(self, color, opacity):
         colors = [c if (c is not None) else BLACK for c in tuplify(color)]
         opacities = [o if (o is not None) else 0 for o in tuplify(opacity)]
         rgbas = np.array(
-            [color_to_rgba(c, o) for c, o in zip(*make_even(colors, opacities))],
+            [c.to_rgb_with_alpha(o) for c, o in zip(*make_even(colors, opacities))],
         )
 
         sheen_factor = self.get_sheen_factor()
@@ -180,7 +183,9 @@ def generate_rgbas_array(self, color, opacity):
             rgbas = np.append(rgbas, light_rgbas, axis=0)
         return rgbas
 
-    def update_rgbas_array(self, array_name, color=None, opacity=None):
+    def update_rgbas_array(
+        self, array_name, color: ManimColor | None = None, opacity=None
+    ):
         rgbas = self.generate_rgbas_array(color, opacity)
         if not hasattr(self, array_name):
             setattr(self, array_name, rgbas)
@@ -203,7 +208,7 @@ def update_rgbas_array(self, array_name, color=None, opacity=None):
 
     def set_fill(
         self,
-        color: Optional[str] = None,
+        color: ParsableManimColor = None,
         opacity: Optional[float] = None,
         family: bool = True,
     ):
@@ -252,7 +257,7 @@ def construct(self):
 
     def set_stroke(
         self,
-        color=None,
+        color: ParsableManimColor = None,
         width=None,
         opacity=None,
         background=False,
@@ -275,7 +280,7 @@ def set_stroke(
         if opacity is not None:
             setattr(self, opacity_name, opacity)
         if color is not None and background:
-            self.background_stroke_color = color
+            self.background_stroke_color = ManimColor.parse(color)
         return self
 
     def set_background_stroke(self, **kwargs):
@@ -285,12 +290,12 @@ def set_background_stroke(self, **kwargs):
 
     def set_style(
         self,
-        fill_color=None,
+        fill_color: ParsableManimColor = None,
         fill_opacity=None,
-        stroke_color=None,
+        stroke_color: ParsableManimColor = None,
         stroke_width=None,
         stroke_opacity=None,
-        background_stroke_color=None,
+        background_stroke_color: ParsableManimColor = None,
         background_stroke_width=None,
         background_stroke_opacity=None,
         sheen_factor=None,
@@ -327,10 +332,11 @@ def get_style(self, simple=False):
             "stroke_width": self.get_stroke_width(),
         }
 
+        # TODO: FIX COLORS HERE
         if simple:
-            ret["fill_color"] = colour.rgb2hex(self.get_fill_color().get_rgb())
+            ret["fill_color"] = self.get_fill_color().to_hex()
             ret["fill_opacity"] = self.get_fill_opacity()
-            ret["stroke_color"] = colour.rgb2hex(self.get_stroke_color().get_rgb())
+            ret["stroke_color"] = self.get_stroke_color().to_hex()
         else:
             ret["fill_color"] = self.get_fill_colors()
             ret["fill_opacity"] = self.get_fill_opacities()
@@ -359,7 +365,8 @@ def match_style(self, vmobject, family=True):
                 sm1.match_style(sm2)
         return self
 
-    def set_color(self, color, family=True):
+    def set_color(self, color: ParsableManimColor, family=True):
+        color = ManimColor.parse(color)
         self.set_fill(color, family=family)
         self.set_stroke(color, family=family)
         return self