manim 0.17.0__py3-none-any.whl → 0.19.1__py3-none-any.whl

manim/mobject/text/text_mobject.py

@@ -6,7 +6,7 @@
 
 .. important::
 
-   See the corresponding tutorial :ref:`rendering-with-latex`
+   See the corresponding tutorial :ref:`using-text-objects`, especially for information about fonts.
 
 
 The simplest way to add text to your animations is to use the :class:`~.Text` class. It uses the Pango library to render text.
@@ -49,21 +49,22 @@ Examples
 
 from __future__ import annotations
 
+import functools
+
 __all__ = ["Text", "Paragraph", "MarkupText", "register_font"]
 
 
 import copy
 import hashlib
-import os
 import re
+from collections.abc import Iterable, Iterator, Sequence
 from contextlib import contextmanager
 from itertools import chain
 from pathlib import Path
-from typing import Iterable, Sequence
+from typing import TYPE_CHECKING, Any
 
 import manimpango
 import numpy as np
-from colour import Color
 from manimpango import MarkupUtils, PangoUtils, TextSetting
 
 from manim import config, logger
@@ -71,15 +72,22 @@ from manim.constants import *
 from manim.mobject.geometry.arc import Dot
 from manim.mobject.svg.svg_mobject import SVGMobject
 from manim.mobject.types.vectorized_mobject import VGroup, VMobject
-from manim.utils.color import Colors, color_gradient
-from manim.utils.deprecation import deprecated
+from manim.typing import Point3D
+from manim.utils.color import ManimColor, ParsableManimColor, color_gradient
+
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from manim.typing import Point3D
 
 TEXT_MOB_SCALE_FACTOR = 0.05
 DEFAULT_LINE_SPACING_SCALE = 0.3
 TEXT2SVG_ADJUSTMENT_FACTOR = 4.8
 
+__all__ = ["Text", "Paragraph", "MarkupText", "register_font"]
+
 
-def remove_invisible_chars(mobject: SVGMobject) -> SVGMobject:
+def remove_invisible_chars(mobject: VMobject) -> VMobject:
     """Function to remove unwanted invisible characters from some mobjects.
 
     Parameters
@@ -92,24 +100,14 @@ def remove_invisible_chars(mobject: SVGMobject) -> SVGMobject:
     :class:`~.SVGMobject`
         The SVGMobject without unwanted invisible characters.
     """
-
-    iscode = False
-    if mobject.__class__.__name__ == "Text":
-        mobject = mobject[:]
-    elif mobject.__class__.__name__ == "Code":
-        iscode = True
-        code = mobject
-        mobject = mobject.code
     mobject_without_dots = VGroup()
-    if mobject[0].__class__ == VGroup:
-        for i in range(len(mobject)):
-            mobject_without_dots.add(VGroup())
-            mobject_without_dots[i].add(*(k for k in mobject[i] if k.__class__ != Dot))
+    if isinstance(mobject[0], VGroup):
+        for submob in mobject:
+            mobject_without_dots.add(
+                VGroup(k for k in submob if not isinstance(k, Dot))
+            )
     else:
-        mobject_without_dots.add(*(k for k in mobject if k.__class__ != Dot))
-    if iscode:
-        code.code = mobject_without_dots
-        return code
+        mobject_without_dots.add(*(k for k in mobject if not isinstance(k, Dot)))
     return mobject_without_dots
 
 
@@ -132,10 +130,17 @@ class Paragraph(VGroup):
     --------
     Normal usage::
 
-        paragraph = Paragraph('this is a awesome', 'paragraph',
-                              'With \nNewlines', '\tWith Tabs',
-                              '  With Spaces', 'With Alignments',
-                              'center', 'left', 'right')
+        paragraph = Paragraph(
+            "this is a awesome",
+            "paragraph",
+            "With \nNewlines",
+            "\tWith Tabs",
+            "  With Spaces",
+            "With Alignments",
+            "center",
+            "left",
+            "right",
+        )
 
     Remove unwanted invisible characters::
 
@@ -146,11 +151,11 @@ class Paragraph(VGroup):
 
     def __init__(
         self,
-        *text: Sequence[str],
+        *text: str,
         line_spacing: float = -1,
-        alignment: Optional[str] = None,
-        **kwargs,
-    ) -> None:
+        alignment: str | None = None,
+        **kwargs: Any,
+    ):
         self.line_spacing = line_spacing
         self.alignment = alignment
         self.consider_spaces_as_chars = kwargs.get("disable_ligatures", False)
@@ -292,7 +297,7 @@ class Paragraph(VGroup):
 
 
 class Text(SVGMobject):
-    r"""Display (non-LaTeX) text rendered using `Pango <https://pango.gnome.org/>`_.
+    r"""Display (non-LaTeX) text rendered using `Pango <https://pango.org/>`_.
 
     Text objects behave like a :class:`.VGroup`-like iterable of all characters
     in the given text. In particular, slicing is possible.
@@ -301,6 +306,13 @@ class Text(SVGMobject):
     ----------
     text
         The text that needs to be created as a mobject.
+    font
+        The font family to be used to render the text. This is either a system font or
+        one loaded with `register_font()`. Note that font family names may be different
+        across operating systems.
+    warn_missing_font
+        If True (default), Manim will issue a warning if the font does not exist in the
+        (case-sensitive) list of fonts returned from `manimpango.list_fonts()`.
 
     Returns
     -------
@@ -344,7 +356,7 @@ class Text(SVGMobject):
                )
                 text6.scale(1.3).shift(DOWN)
                 self.add(text1, text2, text3, text4, text5 , text6)
-                Group(*self.mobjects).arrange(DOWN, buff=.8).set_height(config.frame_height-LARGE_BUFF)
+                Group(*self.mobjects).arrange(DOWN, buff=.8).set(height=config.frame_height-LARGE_BUFF)
 
     .. manim:: TextMoreCustomization
             :save_last_frame:
@@ -401,33 +413,55 @@ class Text(SVGMobject):
 
     """
 
+    @staticmethod
+    @functools.cache
+    def font_list() -> list[str]:
+        value: list[str] = manimpango.list_fonts()
+        return value
+
     def __init__(
         self,
         text: str,
         fill_opacity: float = 1.0,
         stroke_width: float = 0,
-        color: Color | str | None = None,
+        color: ParsableManimColor | None = None,
         font_size: float = DEFAULT_FONT_SIZE,
         line_spacing: float = -1,
         font: str = "",
         slant: str = NORMAL,
         weight: str = NORMAL,
-        t2c: dict[str, str] = None,
-        t2f: dict[str, str] = None,
-        t2g: dict[str, tuple] = None,
-        t2s: dict[str, str] = None,
-        t2w: dict[str, str] = None,
-        gradient: tuple = None,
+        t2c: dict[str, str] | None = None,
+        t2f: dict[str, str] | None = None,
+        t2g: dict[str, Iterable[ParsableManimColor]] | None = None,
+        t2s: dict[str, str] | None = None,
+        t2w: dict[str, str] | None = None,
+        gradient: Iterable[ParsableManimColor] | None = None,
         tab_width: int = 4,
+        warn_missing_font: bool = True,
         # Mobject
-        height: float = None,
-        width: float = None,
+        height: float | None = None,
+        width: float | None = None,
         should_center: bool = True,
         disable_ligatures: bool = False,
-        **kwargs,
-    ) -> None:
-
+        use_svg_cache: bool = False,
+        **kwargs: Any,
+    ):
         self.line_spacing = line_spacing
+        if font and warn_missing_font:
+            fonts_list = Text.font_list()
+            # handle special case of sans/sans-serif
+            if font.lower() == "sans-serif":
+                font = "sans"
+            if font not in fonts_list:
+                # check if the capitalized version is in the supported fonts
+                if font.capitalize() in fonts_list:
+                    font = font.capitalize()
+                elif font.lower() in fonts_list:
+                    font = font.lower()
+                elif font.title() in fonts_list:
+                    font = font.title()
+                else:
+                    logger.warning(f"Font {font} not in {fonts_list}.")
         self.font = font
         self._font_size = float(font_size)
         # needs to be a float or else size is inflated when font_size = 24
@@ -452,11 +486,16 @@ class Text(SVGMobject):
         t2g = kwargs.pop("text2gradient", t2g)
         t2s = kwargs.pop("text2slant", t2s)
         t2w = kwargs.pop("text2weight", t2w)
-        self.t2c = t2c
-        self.t2f = t2f
-        self.t2g = t2g
-        self.t2s = t2s
-        self.t2w = t2w
+        assert t2c is not None
+        assert t2f is not None
+        assert t2g is not None
+        assert t2s is not None
+        assert t2w is not None
+        self.t2c: dict[str, str] = {k: ManimColor(v).to_hex() for k, v in t2c.items()}
+        self.t2f: dict[str, str] = t2f
+        self.t2g: dict[str, Iterable[ParsableManimColor]] = t2g
+        self.t2s: dict[str, str] = t2s
+        self.t2w: dict[str, str] = t2w
 
         self.original_text = text
         self.disable_ligatures = disable_ligatures
@@ -471,8 +510,8 @@ class Text(SVGMobject):
         else:
             self.line_spacing = self._font_size + self._font_size * self.line_spacing
 
-        color = Color(color) if color else VMobject().color
-        file_name = self._text2svg(color)
+        parsed_color: ManimColor = ManimColor(color) if color else VMobject().color
+        file_name = self._text2svg(parsed_color.to_hex())
         PangoUtils.remove_last_M(file_name)
         super().__init__(
             file_name,
@@ -481,6 +520,7 @@ class Text(SVGMobject):
             height=height,
             width=width,
             should_center=should_center,
+            use_svg_cache=use_svg_cache,
             **kwargs,
         )
         self.text = text
@@ -493,28 +533,68 @@ class Text(SVGMobject):
             if len(each.points) == 0:
                 continue
             points = each.points
-            last = points[0]
-            each.clear_points()
+            curve_start = points[0]
+            assert len(curve_start) == self.dim, curve_start
+            # Some of the glyphs in this text might not be closed,
+            # so we close them by identifying when one curve ends
+            # but it is not where the next curve starts.
+            # It is more efficient to temporarily create a list
+            # of points and add them one at a time, then turn them
+            # into a numpy array at the end, rather than creating
+            # new numpy arrays every time a point or fixing line
+            # is added (which is O(n^2) for numpy arrays).
+            closed_curve_points: list[Point3D] = []
+            # OpenGL has points be part of quadratic Bezier curves;
+            # Cairo uses cubic Bezier curves.
+            if nppc == 3:  # RendererType.OPENGL
+
+                def add_line_to(end: Point3D) -> None:
+                    nonlocal closed_curve_points
+                    start = closed_curve_points[-1]
+                    closed_curve_points += [
+                        start,
+                        (start + end) / 2,
+                        end,
+                    ]
+
+            else:  # RendererType.CAIRO
+
+                def add_line_to(end: Point3D) -> None:
+                    nonlocal closed_curve_points
+                    start = closed_curve_points[-1]
+                    closed_curve_points += [
+                        start,
+                        (start + start + end) / 3,
+                        (start + end + end) / 3,
+                        end,
+                    ]
+
             for index, point in enumerate(points):
-                each.append_points([point])
+                closed_curve_points.append(point)
                 if (
                     index != len(points) - 1
                     and (index + 1) % nppc == 0
                     and any(point != points[index + 1])
                 ):
-                    each.add_line_to(last)
-                    last = points[index + 1]
-            each.add_line_to(last)
+                    # Add straight line from last point on this curve to the
+                    # start point on the next curve. We represent the line
+                    # as a cubic bezier curve where the two control points
+                    # are half-way between the start and stop point.
+                    add_line_to(curve_start)
+                    curve_start = points[index + 1]
+            # Make sure last curve is closed
+            add_line_to(curve_start)
+            each.points = np.array(closed_curve_points, ndmin=2)
         # anti-aliasing
         if height is None and width is None:
             self.scale(TEXT_MOB_SCALE_FACTOR)
         self.initial_height = self.height
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"Text({repr(self.original_text)})"
 
     @property
-    def font_size(self):
+    def font_size(self) -> float:
         return (
             self.height
             / self.initial_height
@@ -525,14 +605,14 @@ class Text(SVGMobject):
         )
 
     @font_size.setter
-    def font_size(self, font_val):
+    def font_size(self, font_val: float) -> None:
         # TODO: use pango's font size scaling.
         if font_val <= 0:
             raise ValueError("font_size must be greater than 0.")
         else:
             self.scale(font_val / self.font_size)
 
-    def _gen_chars(self):
+    def _gen_chars(self) -> VGroup:
         chars = self.get_group_class()()
         submobjects_char_index = 0
         for char_index in range(len(self.text)):
@@ -550,7 +630,7 @@ class Text(SVGMobject):
                 submobjects_char_index += 1
         return chars
 
-    def _find_indexes(self, word: str, text: str):
+    def _find_indexes(self, word: str, text: str) -> list[tuple[int, int]]:
         """Finds the indexes of ``text`` in ``word``."""
         temp = re.match(r"\[([0-9\-]{0,}):([0-9\-]{0,})\]", word)
         if temp:
@@ -558,7 +638,9 @@ class Text(SVGMobject):
             end = int(temp.group(2)) if temp.group(2) != "" else len(text)
             start = len(text) + start if start < 0 else start
             end = len(text) + end if end < 0 else end
-            return [(start, end)]
+            return [
+                (start, end),
+            ]
         indexes = []
         index = text.find(word)
         while index != -1:
@@ -566,39 +648,15 @@ class Text(SVGMobject):
             index = text.find(word, index + len(word))
         return indexes
 
-    @deprecated(
-        since="v0.14.0",
-        until="v0.15.0",
-        message="This was internal function, you shouldn't be using it anyway.",
-    )
-    def _set_color_by_t2c(self, t2c=None):
-        """Sets color for specified strings."""
-        t2c = t2c if t2c else self.t2c
-        for word, color in list(t2c.items()):
-            for start, end in self._find_indexes(word, self.text):
-                self.chars[start:end].set_color(color)
-
-    @deprecated(
-        since="v0.14.0",
-        until="v0.15.0",
-        message="This was internal function, you shouldn't be using it anyway.",
-    )
-    def _set_color_by_t2g(self, t2g=None):
-        """Sets gradient colors for specified
-        strings. Behaves similarly to ``set_color_by_t2c``."""
-        t2g = t2g if t2g else self.t2g
-        for word, gradient in list(t2g.items()):
-            for start, end in self._find_indexes(word, self.text):
-                self.chars[start:end].set_color_by_gradient(*gradient)
-
-    def _text2hash(self, color: Color):
+    def _text2hash(self, color: ParsableManimColor) -> str:
         """Generates ``sha256`` hash for file name."""
         settings = (
-            "PANGO" + self.font + self.slant + self.weight + color.hex_l
+            "PANGO" + self.font + self.slant + self.weight + str(color)
         )  # to differentiate Text and CairoText
         settings += str(self.t2f) + str(self.t2s) + str(self.t2w) + str(self.t2c)
         settings += str(self.line_spacing) + str(self._font_size)
         settings += str(self.disable_ligatures)
+        settings += str(self.gradient)
         id_str = self.text + settings
         hasher = hashlib.sha256()
         hasher.update(id_str.encode())
@@ -624,7 +682,7 @@ class Text(SVGMobject):
             default = default_args[arg]
             if left != default and getattr(right_setting, arg) != default:
                 raise ValueError(
-                    f"Ambiguous style for text '{self.text[right_setting.start:right_setting.end]}':"
+                    f"Ambiguous style for text '{self.text[right_setting.start : right_setting.end]}':"
                     + f"'{arg}' cannot be both '{left}' and '{right}'."
                 )
             setattr(right_setting, arg, left if left != default else right)
@@ -634,12 +692,14 @@ class Text(SVGMobject):
         self,
         t2xs: Sequence[tuple[dict[str, str], str]],
         default_args: dict[str, Iterable[str]],
-    ) -> Sequence[TextSetting]:
+    ) -> list[TextSetting]:
         settings = []
         t2xwords = set(chain(*([*t2x.keys()] for t2x, _ in t2xs)))
         for word in t2xwords:
             setting_args = {
-                arg: t2x[word] if word in t2x else default_args[arg]
+                arg: str(t2x[word]) if word in t2x else default_args[arg]
+                # NOTE: when t2x[word] is a ManimColor, str will yield the
+                # hex representation
                 for t2x, arg in t2xs
             }
 
@@ -648,42 +708,36 @@ class Text(SVGMobject):
         return settings
 
     def _get_settings_from_gradient(
-        self, default_args: dict[str, Iterable[str]]
-    ) -> Sequence[TextSetting]:
+        self, default_args: dict[str, Any]
+    ) -> list[TextSetting]:
         settings = []
         args = copy.copy(default_args)
         if self.gradient:
-            colors = color_gradient(self.gradient, len(self.text))
+            colors: list[ManimColor] = color_gradient(self.gradient, len(self.text))
             for i in range(len(self.text)):
-                args["color"] = colors[i].hex
+                args["color"] = colors[i].to_hex()
                 settings.append(TextSetting(i, i + 1, **args))
 
         for word, gradient in self.t2g.items():
-            if isinstance(gradient, str) or len(gradient) == 1:
-                color = gradient if isinstance(gradient, str) else gradient[0]
-                gradient = [Color(color)]
-            colors = (
-                color_gradient(gradient, len(word))
-                if len(gradient) != 1
-                else len(word) * gradient
-            )
+            colors = color_gradient(gradient, len(word))
             for start, end in self._find_indexes(word, self.text):
                 for i in range(start, end):
-                    args["color"] = colors[i - start].hex
+                    args["color"] = colors[i - start].to_hex()
                     settings.append(TextSetting(i, i + 1, **args))
         return settings
 
-    def _text2settings(self, color: Color):
+    def _text2settings(self, color: ParsableManimColor) -> list[TextSetting]:
         """Converts the texts and styles to a setting for parsing."""
-        t2xs = [
+        t2xs: list[tuple[dict[str, str], str]] = [
             (self.t2f, "font"),
             (self.t2s, "slant"),
             (self.t2w, "weight"),
             (self.t2c, "color"),
         ]
         # setting_args requires values to be strings
-        default_args = {
-            arg: getattr(self, arg) if arg != "color" else str(color) for _, arg in t2xs
+
+        default_args: dict[str, Any] = {
+            arg: getattr(self, arg) if arg != "color" else color for _, arg in t2xs
         }
 
         settings = self._get_settings_from_t2xs(t2xs, default_args)
@@ -720,15 +774,15 @@ class Text(SVGMobject):
 
         line_num = 0
         if re.search(r"\n", self.text):
-            for start, end in self._find_indexes("\n", self.text):
+            for for_start, for_end in self._find_indexes("\n", self.text):
                 for setting in settings:
                     if setting.line_num == -1:
                         setting.line_num = line_num
-                    if start < setting.end:
+                    if for_start < setting.end:
                         line_num += 1
                         new_setting = copy.copy(setting)
-                        setting.end = end
-                        new_setting.start = end
+                        setting.end = for_end
+                        new_setting.start = for_end
                         new_setting.line_num = line_num
                         settings.append(new_setting)
                         settings.sort(key=lambda setting: setting.start)
@@ -739,7 +793,7 @@ class Text(SVGMobject):
 
         return settings
 
-    def _text2svg(self, color: Color):
+    def _text2svg(self, color: ParsableManimColor) -> str:
         """Convert the text to SVG using Pango."""
         size = self._font_size
         line_spacing = self.line_spacing
@@ -774,15 +828,16 @@ class Text(SVGMobject):
 
         return svg_file
 
-    def init_colors(self, propagate_colors=True):
+    def init_colors(self, propagate_colors: bool = True) -> Self:
         if config.renderer == RendererType.OPENGL:
             super().init_colors()
         elif config.renderer == RendererType.CAIRO:
             super().init_colors(propagate_colors=propagate_colors)
+        return self
 
 
 class MarkupText(SVGMobject):
-    r"""Display (non-LaTeX) text rendered using `Pango <https://pango.gnome.org/>`_.
+    r"""Display (non-LaTeX) text rendered using `Pango <https://pango.org/>`_.
 
     Text objects behave like a :class:`.VGroup`-like iterable of all characters
     in the given text. In particular, slicing is possible.
@@ -832,7 +887,7 @@ class MarkupText(SVGMobject):
     Here is a list of supported tags:
 
     - ``<b>bold</b>``, ``<i>italic</i>`` and ``<b><i>bold+italic</i></b>``
-    - ``<ul>underline</ul>`` and ``<s>strike through</s>``
+    - ``<u>underline</u>`` and ``<s>strike through</s>``
     - ``<tt>typewriter font</tt>``
     - ``<big>bigger font</big>`` and ``<small>smaller font</small>``
     - ``<sup>superscript</sup>`` and ``<sub>subscript</sub>``
@@ -911,7 +966,9 @@ class MarkupText(SVGMobject):
         Global weight setting, e.g. `NORMAL` or `BOLD`. Local overrides are possible.
     gradient
         Global gradient setting. Local overrides are possible.
-
+    warn_missing_font
+        If True (default), Manim will issue a warning if the font does not exist in the
+        (case-sensitive) list of fonts returned from `manimpango.list_fonts()`.
 
     Returns
     -------
@@ -1077,29 +1134,50 @@ class MarkupText(SVGMobject):
 
     """
 
+    @staticmethod
+    @functools.cache
+    def font_list() -> list[str]:
+        value: list[str] = manimpango.list_fonts()
+        return value
+
     def __init__(
         self,
         text: str,
         fill_opacity: float = 1,
         stroke_width: float = 0,
-        color: Color | None = None,
+        color: ParsableManimColor | None = None,
         font_size: float = DEFAULT_FONT_SIZE,
-        line_spacing: int = -1,
+        line_spacing: float = -1,
         font: str = "",
         slant: str = NORMAL,
         weight: str = NORMAL,
         justify: bool = False,
-        gradient: tuple = None,
+        gradient: Iterable[ParsableManimColor] | None = None,
         tab_width: int = 4,
-        height: int = None,
-        width: int = None,
+        height: int | None = None,
+        width: int | None = None,
         should_center: bool = True,
         disable_ligatures: bool = False,
-        **kwargs,
-    ) -> None:
-
+        warn_missing_font: bool = True,
+        **kwargs: Any,
+    ):
         self.text = text
-        self.line_spacing = line_spacing
+        self.line_spacing: float = line_spacing
+        if font and warn_missing_font:
+            fonts_list = Text.font_list()
+            # handle special case of sans/sans-serif
+            if font.lower() == "sans-serif":
+                font = "sans"
+            if font not in fonts_list:
+                # check if the capitalized version is in the supported fonts
+                if font.capitalize() in fonts_list:
+                    font = font.capitalize()
+                elif font.lower() in fonts_list:
+                    font = font.lower()
+                elif font.title() in fonts_list:
+                    font = font.title()
+                else:
+                    logger.warning(f"Font {font} not in {fonts_list}.")
         self.font = font
         self._font_size = float(font_size)
         self.slant = slant
@@ -1131,8 +1209,8 @@ class MarkupText(SVGMobject):
         else:
             self.line_spacing = self._font_size + self._font_size * self.line_spacing
 
-        color = Color(color) if color else VMobject().color
-        file_name = self._text2svg(color)
+        parsed_color: ManimColor = ManimColor(color) if color else VMobject().color
+        file_name = self._text2svg(parsed_color)
 
         PangoUtils.remove_last_M(file_name)
         super().__init__(
@@ -1153,32 +1231,68 @@ class MarkupText(SVGMobject):
             if len(each.points) == 0:
                 continue
             points = each.points
-            last = points[0]
-            each.clear_points()
+            curve_start = points[0]
+            assert len(curve_start) == self.dim, curve_start
+            # Some of the glyphs in this text might not be closed,
+            # so we close them by identifying when one curve ends
+            # but it is not where the next curve starts.
+            # It is more efficient to temporarily create a list
+            # of points and add them one at a time, then turn them
+            # into a numpy array at the end, rather than creating
+            # new numpy arrays every time a point or fixing line
+            # is added (which is O(n^2) for numpy arrays).
+            closed_curve_points: list[Point3D] = []
+            # OpenGL has points be part of quadratic Bezier curves;
+            # Cairo uses cubic Bezier curves.
+            if nppc == 3:  # RendererType.OPENGL
+
+                def add_line_to(end: Point3D) -> None:
+                    nonlocal closed_curve_points
+                    start = closed_curve_points[-1]
+                    closed_curve_points += [
+                        start,
+                        (start + end) / 2,
+                        end,
+                    ]
+
+            else:  # RendererType.CAIRO
+
+                def add_line_to(end: Point3D) -> None:
+                    nonlocal closed_curve_points
+                    start = closed_curve_points[-1]
+                    closed_curve_points += [
+                        start,
+                        (start + start + end) / 3,
+                        (start + end + end) / 3,
+                        end,
+                    ]
+
             for index, point in enumerate(points):
-                each.append_points([point])
+                closed_curve_points.append(point)
                 if (
                     index != len(points) - 1
                     and (index + 1) % nppc == 0
                     and any(point != points[index + 1])
                 ):
-                    each.add_line_to(last)
-                    last = points[index + 1]
-            each.add_line_to(last)
+                    # Add straight line from last point on this curve to the
+                    # start point on the next curve.
+                    add_line_to(curve_start)
+                    curve_start = points[index + 1]
+            # Make sure last curve is closed
+            add_line_to(curve_start)
+            each.points = np.array(closed_curve_points, ndmin=2)
 
         if self.gradient:
             self.set_color_by_gradient(*self.gradient)
         for col in colormap:
             self.chars[
-                col["start"]
-                - col["start_offset"] : col["end"]
+                col["start"] - col["start_offset"] : col["end"]
                 - col["start_offset"]
                 - col["end_offset"]
             ].set_color(self._parse_color(col["color"]))
         for grad in gradientmap:
             self.chars[
-                grad["start"]
-                - grad["start_offset"] : grad["end"]
+                grad["start"] - grad["start_offset"] : grad["end"]
                 - grad["start_offset"]
                 - grad["end_offset"]
             ].set_color_by_gradient(
@@ -1191,7 +1305,7 @@ class MarkupText(SVGMobject):
         self.initial_height = self.height
 
     @property
-    def font_size(self):
+    def font_size(self) -> float:
         return (
             self.height
             / self.initial_height
@@ -1202,17 +1316,21 @@ class MarkupText(SVGMobject):
         )
 
     @font_size.setter
-    def font_size(self, font_val):
+    def font_size(self, font_val: float) -> None:
         # TODO: use pango's font size scaling.
         if font_val <= 0:
             raise ValueError("font_size must be greater than 0.")
         else:
             self.scale(font_val / self.font_size)
 
-    def _text2hash(self, color: Color):
+    def _text2hash(self, color: ParsableManimColor) -> str:
         """Generates ``sha256`` hash for file name."""
         settings = (
-            "MARKUPPANGO" + self.font + self.slant + self.weight + color.hex_l
+            "MARKUPPANGO"
+            + self.font
+            + self.slant
+            + self.weight
+            + ManimColor(color).to_hex().lower()
         )  # to differentiate from classical Pango Text
         settings += str(self.line_spacing) + str(self._font_size)
         settings += str(self.disable_ligatures)
@@ -1222,23 +1340,25 @@ class MarkupText(SVGMobject):
         hasher.update(id_str.encode())
         return hasher.hexdigest()[:16]
 
-    def _text2svg(self, color: Color | None):
+    def _text2svg(self, color: ParsableManimColor | None) -> str:
         """Convert the text to SVG using Pango."""
+        color = ManimColor(color)
         size = self._font_size
-        line_spacing = self.line_spacing
+        line_spacing: float = self.line_spacing
         size /= TEXT2SVG_ADJUSTMENT_FACTOR
         line_spacing /= TEXT2SVG_ADJUSTMENT_FACTOR
 
         dir_name = config.get_dir("text_dir")
-        if not dir_name.exists():
+        if not dir_name.is_dir():
             dir_name.mkdir(parents=True)
         hash_name = self._text2hash(color)
         file_name = dir_name / (hash_name + ".svg")
+
         if file_name.exists():
-            svg_file = str(file_name.resolve())
+            svg_file: str = str(file_name.resolve())
         else:
             final_text = (
-                f'<span foreground="{color}">{self.text}</span>'
+                f'<span foreground="{color.to_hex()}">{self.text}</span>'
                 if color is not None
                 else self.text
             )
@@ -1261,11 +1381,12 @@ class MarkupText(SVGMobject):
             )
         return svg_file
 
-    def _count_real_chars(self, s):
+    def _count_real_chars(self, s: str) -> int:
         """Counts characters that will be displayed.
 
         This is needed for partial coloring or gradients, because space
-        counts to the text's `len`, but has no corresponding character."""
+        counts to the text's `len`, but has no corresponding character.
+        """
         count = 0
         level = 0
         # temporarily replace HTML entities by single char
@@ -1279,7 +1400,7 @@ class MarkupText(SVGMobject):
                 count += 1
         return count
 
-    def _extract_gradient_tags(self):
+    def _extract_gradient_tags(self) -> list[dict[str, Any]]:
         """Used to determine which parts (if any) of the string should be formatted
         with a gradient.
 
@@ -1290,7 +1411,7 @@ class MarkupText(SVGMobject):
             self.original_text,
             re.S,
         )
-        gradientmap = []
+        gradientmap: list[dict[str, Any]] = []
         for tag in tags:
             start = self._count_real_chars(self.original_text[: tag.start(0)])
             end = start + self._count_real_chars(tag.group(5))
@@ -1308,17 +1429,19 @@ class MarkupText(SVGMobject):
                     "end_offset": end_offset,
                 },
             )
-        self.text = re.sub("<gradient[^>]+>(.+?)</gradient>", r"\1", self.text, 0, re.S)
+        self.text = re.sub(
+            "<gradient[^>]+>(.+?)</gradient>", r"\1", self.text, count=0, flags=re.S
+        )
         return gradientmap
 
-    def _parse_color(self, col):
+    def _parse_color(self, col: str) -> str:
         """Parse color given in ``<color>`` or ``<gradient>`` tags."""
         if re.match("#[0-9a-f]{6}", col):
             return col
         else:
-            return Colors[col.lower()].value
+            return ManimColor(col).to_hex()
 
-    def _extract_color_tags(self):
+    def _extract_color_tags(self) -> list[dict[str, Any]]:
         """Used to determine which parts (if any) of the string should be formatted
         with a custom color.
 
@@ -1333,7 +1456,7 @@ class MarkupText(SVGMobject):
             re.S,
         )
 
-        colormap = []
+        colormap: list[dict[str, Any]] = []
         for tag in tags:
             start = self._count_real_chars(self.original_text[: tag.start(0)])
             end = start + self._count_real_chars(tag.group(4))
@@ -1350,15 +1473,17 @@ class MarkupText(SVGMobject):
                     "end_offset": end_offset,
                 },
             )
-        self.text = re.sub("<color[^>]+>(.+?)</color>", r"\1", self.text, 0, re.S)
+        self.text = re.sub(
+            "<color[^>]+>(.+?)</color>", r"\1", self.text, count=0, flags=re.S
+        )
         return colormap
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return f"MarkupText({repr(self.original_text)})"
 
 
 @contextmanager
-def register_font(font_file: str | Path):
+def register_font(font_file: str | Path) -> Iterator[None]:
     """Temporarily add a font file to Pango's search path.
 
     This searches for the font_file at various places. The order it searches it described below.
@@ -1396,7 +1521,6 @@ def register_font(font_file: str | Path):
         This method is available for macOS for ``ManimPango>=v0.2.3``. Using this
         method with previous releases will raise an :class:`AttributeError` on macOS.
     """
-
     input_folder = Path(config.input_file).parent.resolve()
     possible_paths = [
         Path(font_file),
@@ -1411,7 +1535,7 @@ def register_font(font_file: str | Path):
             logger.debug("Found file at %s", file_path.absolute())
             break
     else:
-        error = f"Can't find {font_file}." f"Tried these : {possible_paths}"
+        error = f"Can't find {font_file}. Checked paths: {possible_paths}"
         raise FileNotFoundError(error)
 
     try: