A community-maintained Python framework for creating mathematical animations.
remove unused opengl files (#2405)
citrusmunch0e972ff25143
diff --git a/manim/mobject/svg/opengl_tex_mobject.py b/manim/mobject/svg/opengl_tex_mobject.pydeleted file mode 100644index a8e8170ee..000000000--- a/manim/mobject/svg/opengl_tex_mobject.py+++ /dev/null@@ -1,596 +0,0 @@-r"""Mobjects representing text rendered using LaTeX.---The Tex mobject-+++++++++++++++-Just as you can use :class:`~.Text` to add text to your videos, you can use :class:`~.Tex` to insert LaTeX.--.. manim:: HelloLaTeX- :save_last_frame:-- class HelloLaTeX(Scene):- def construct(self):- tex = Tex(r'\LaTeX').scale(3)- self.add(tex)--Note that we are using a raw string (``r'---'``) instead of a regular string (``'---'``).-This is because TeX code uses a lot of special characters - like ``\`` for example --that have special meaning within a regular python string. An alternative would have-been to write ``\\`` as in ``Tex('\\LaTeX')``.--The MathTex mobject-+++++++++++++++++++-Anything enclosed in ``$`` signs is interpreted as maths-mode:--.. manim:: HelloTex- :save_last_frame:-- class HelloTex(Scene):- def construct(self):- tex = Tex(r'$\xrightarrow{x^2y^3}$ \LaTeX').scale(3)- self.add(tex)--Whereas in a :class:`~.MathTex` mobject everything is math-mode by default.--.. manim:: MovingBraces-- class MovingBraces(Scene):- def construct(self):- text=MathTex(- "\\frac{d}{dx}f(x)g(x)=", #0- "f(x)\\frac{d}{dx}g(x)", #1- "+", #2- "g(x)\\frac{d}{dx}f(x)" #3- )- self.play(Write(text))- brace1 = Brace(text[1], UP, buff=SMALL_BUFF)- brace2 = Brace(text[3], UP, buff=SMALL_BUFF)- t1 = brace1.get_text("$g'f$")- t2 = brace2.get_text("$f'g$")- self.play(- GrowFromCenter(brace1),- FadeIn(t1),- )- self.wait()- self.play(- ReplacementTransform(brace1,brace2),- ReplacementTransform(t1,t2)- )- self.wait()---LaTeX commands and keyword arguments-++++++++++++++++++++++++++++++++++++-We can use any standard LaTeX commands in the AMS maths packages. For example the ``mathtt`` math-text type, or the ``looparrowright`` arrow.--.. manim:: AMSLaTeX- :save_last_frame:-- class AMSLaTeX(Scene):- def construct(self):- tex = Tex(r'$\mathtt{H} \looparrowright$ \LaTeX').scale(3)- self.add(tex)--On the manim side, the :class:`~.Tex` class also accepts attributes to change the appearance of the output.-This is very similar to the :class:`~.Text` class. For example, the ``color`` keyword changes the color of the TeX mobject:--.. manim:: LaTeXAttributes- :save_last_frame:-- class LaTeXAttributes(Scene):- def construct(self):- tex = Tex(r'Hello \LaTeX', color=BLUE).scale(3)- self.add(tex)--Extra LaTeX Packages-++++++++++++++++++++-Some commands require special packages to be loaded into the TeX template. For example,-to use the ``mathscr`` script, we need to add the ``mathrsfs`` package. Since this package isn't loaded-into manim's tex template by default, we add it manually:--.. manim:: AddPackageLatex- :save_last_frame:-- class AddPackageLatex(Scene):- def construct(self):- myTemplate = TexTemplate()- myTemplate.add_to_preamble(r"\usepackage{mathrsfs}")- tex = Tex(r'$\mathscr{H} \rightarrow \mathbb{H}$}', tex_template=myTemplate).scale(3)- self.add(tex)--Substrings and parts-++++++++++++++++++++-The TeX mobject can accept multiple strings as arguments. Afterwards you can refer to the individual-parts either by their index (like ``tex[1]``), or you can look them up by (parts of) the tex code like-in this example where we set the color of the ``\bigstar`` using :func:`~.set_color_by_tex`:--.. manim:: LaTeXSubstrings- :save_last_frame:-- class LaTeXSubstrings(Scene):- def construct(self):- tex = Tex('Hello', r'$\bigstar$', r'\LaTeX').scale(3)- tex.set_color_by_tex('igsta', RED)- self.add(tex)--LaTeX Maths Fonts - The Template Library-++++++++++++++++++++++++++++++++++++++++-Changing fonts in LaTeX when typesetting mathematical formulae is a little bit more tricky than-with regular text. It requires changing the template that is used to compile the tex code.-Manim comes with a collection of :class:`~.TexFontTemplates` ready for you to use. These templates will all work-in maths mode:--.. manim:: LaTeXMathFonts- :save_last_frame:-- class LaTeXMathFonts(Scene):- def construct(self):- tex = Tex(r'$x^2 + y^2 = z^2$', tex_template=TexFontTemplates.french_cursive).scale(3)- self.add(tex)--Manim also has a :class:`~.TexTemplateLibrary` containing the TeX templates used by 3Blue1Brown. One example-is the ctex template, used for typesetting Chinese. For this to work, the ctex LaTeX package-must be installed on your system. Furthermore, if you are only typesetting Text, you probably do not-need :class:`~.Tex` at all, and should use :class:`~.Text` or :class:`~.PangoText` instead.--.. manim:: LaTeXTemplateLibrary- :save_last_frame:-- class LaTeXTemplateLibrary(Scene):- def construct(self):- tex = Tex('Hello 你好 \\LaTeX', tex_template=TexTemplateLibrary.ctex).scale(3)- self.add(tex)---Aligning formulae-+++++++++++++++++-A :class:`~.MathTex` mobject is typeset in the LaTeX ``align*`` environment. This means you can use the ``&`` alignment-character when typesetting multiline formulae:--.. manim:: LaTeXAlignEnvironment- :save_last_frame:-- class LaTeXAlignEnvironment(Scene):- def construct(self):- tex = MathTex(r'f(x) &= 3 + 2 + 1\\ &= 5 + 1 \\ &= 6').scale(2)- self.add(tex)-"""--__all__ = [- "OpenGLTexSymbol",- "OpenGLSingleStringMathTex",- "OpenGLMathTex",- "OpenGLTex",- "OpenGLBulletedList",- "OpenGLTitle",-]---import operator as op-from functools import reduce--from ... import config-from ...constants import *-from ...mobject.opengl_geometry import OpenGLLine-from ...mobject.svg.opengl_svg_mobject import OpenGLSVGMobject-from ...mobject.svg.opengl_svg_path import OpenGLSVGPathMobject-from ...mobject.svg.tex_mobject import MathTex, Tex-from ...mobject.types.opengl_vectorized_mobject import (- OpenGLVectorizedPoint,- OpenGLVGroup,-)-from ...utils.color import BLACK-from ...utils.strings import split_string_list_to_isolate_substrings-from ...utils.tex_file_writing import tex_to_svg_file-from .style_utils import parse_style--# from ...utils.tex import TexTemplate--TEX_MOB_SCALE_FACTOR = 0.05---class OpenGLTexSymbol(OpenGLSVGPathMobject):- """Purely a renaming of SVGPathMobject."""-- pass---class OpenGLSingleStringMathTex(OpenGLSVGMobject):- """Elementary building block for rendering text with LaTeX.-- Tests- ------ Check that creating a :class:`~.SingleStringMathTex` object works::-- >>> SingleStringMathTex('Test')- SingleStringMathTex('Test')- """-- def __init__(- self,- tex_string,- stroke_width=0,- fill_opacity=1.0,- background_stroke_width=0,- background_stroke_color=BLACK,- should_center=True,- height=None,- organize_left_to_right=False,- tex_environment="align*",- tex_template=None,- **kwargs,- ):- self.organize_left_to_right = organize_left_to_right- self.tex_environment = tex_environment- if tex_template is None:- tex_template = config["tex_template"]- self.tex_template = tex_template-- assert isinstance(tex_string, str)- self.tex_string = tex_string- file_name = tex_to_svg_file(- self.get_modified_expression(tex_string),- environment=self.tex_environment,- tex_template=self.tex_template,- )- super().__init__(- file_name=file_name,- should_center=should_center,- stroke_width=stroke_width,- height=height,- fill_opacity=fill_opacity,- background_stroke_width=background_stroke_width,- background_stroke_color=background_stroke_color,- should_subdivide_sharp_curves=True,- should_remove_null_curves=True,- **kwargs,- )- if height is None:- self.scale(TEX_MOB_SCALE_FACTOR)- if self.organize_left_to_right:- self.organize_submobjects_left_to_right()- for mob in self.submobjects:- mob.orientation = -1-- def __repr__(self):- return f"{type(self).__name__}({repr(self.tex_string)})"-- def get_modified_expression(self, tex_string):- result = tex_string- result = result.strip()- result = self.modify_special_strings(result)- return result-- def modify_special_strings(self, tex):- tex = self.remove_stray_braces(tex)- should_add_filler = reduce(- op.or_,- [- # Fraction line needs something to be over- tex == "\\over",- tex == "\\overline",- # Make sure sqrt has overbar- tex == "\\sqrt",- # Need to add blank subscript or superscript- tex.endswith("_"),- tex.endswith("^"),- tex.endswith("dot"),- ],- )- if should_add_filler:- filler = "{\\quad}"- tex += filler-- if tex == "\\substack":- tex = "\\quad"-- if tex == "":- tex = "\\quad"-- # To keep files from starting with a line break- if tex.startswith("\\\\"):- tex = tex.replace("\\\\", "\\quad\\\\")-- # Handle imbalanced \left and \right- num_lefts, num_rights = (- len([s for s in tex.split(substr)[1:] if s and s[0] in "(){}[]|.\\"])- for substr in ("\\left", "\\right")- )- if num_lefts != num_rights:- tex = tex.replace("\\left", "\\big")- tex = tex.replace("\\right", "\\big")-- for context in ["array"]:- begin_in = ("\\begin{%s}" % context) in tex- end_in = ("\\end{%s}" % context) in tex- if begin_in ^ end_in:- # Just turn this into a blank string,- # which means caller should leave a- # stray \\begin{...} with other symbols- tex = ""- return tex-- def remove_stray_braces(self, tex):- r"""- Makes :class:`~.MathTex` resilient to unmatched braces.-- This is important when the braces in the TeX code are spread over- multiple arguments as in, e.g., ``MathTex(r"e^{i", r"\tau} = 1")``.- """-- # "\{" does not count (it's a brace literal), but "\\{" counts (it's a new line and then brace)- num_lefts = tex.count("{") - tex.count("\\{") + tex.count("\\\\{")- num_rights = tex.count("}") - tex.count("\\}") + tex.count("\\\\}")- while num_rights > num_lefts:- tex = "{" + tex- num_lefts += 1- while num_lefts > num_rights:- tex = tex + "}"- num_rights += 1- return tex-- def get_tex_string(self):- return self.tex_string-- def path_string_to_mobject(self, path_string, style):- # Overwrite superclass default to use- # specialized path_string mobject- return OpenGLTexSymbol(- path_string, **self.path_string_config, **parse_style(style)- )-- def organize_submobjects_left_to_right(self):- self.sort(lambda p: p[0])- return self-- def init_colors(self, propagate_colors=True):- OpenGLSVGMobject.set_style(- self,- fill_color=self.fill_color or self.color,- fill_opacity=self.fill_opacity,- stroke_color=self.stroke_color or self.color,- stroke_width=self.stroke_width,- stroke_opacity=self.stroke_opacity,- recurse=propagate_colors,- )---class OpenGLMathTex(OpenGLSingleStringMathTex):- r"""A string compiled with LaTeX in math mode.-- Examples- --------- .. manim:: Formula- :save_last_frame:-- class Formula(Scene):- def construct(self):- t = MathTex(r"\int_a^b f'(x) dx = f(b)- f(a)")- self.add(t)-- Tests- ------ Check that creating a :class:`~.MathTex` works::-- >>> MathTex('a^2 + b^2 = c^2')- MathTex('a^2 + b^2 = c^2')-- """-- def __init__(- self,- *tex_strings,- arg_separator=" ",- substrings_to_isolate=None,- tex_to_color_map=None,- tex_environment="align*",- **kwargs,- ):- self.tex_template = kwargs.pop("tex_template", config["tex_template"])- self.arg_separator = arg_separator- self.substrings_to_isolate = (- [] if substrings_to_isolate is None else substrings_to_isolate- )- self.tex_to_color_map = tex_to_color_map- if self.tex_to_color_map is None:- self.tex_to_color_map = {}- self.tex_environment = tex_environment- tex_strings = self.break_up_tex_strings(tex_strings)- self.tex_strings = tex_strings- super().__init__(- self.arg_separator.join(tex_strings),- tex_environment=self.tex_environment,- tex_template=self.tex_template,- **kwargs,- )- self.break_up_by_substrings()- self.set_color_by_tex_to_color_map(self.tex_to_color_map)-- if self.organize_left_to_right:- self.organize_submobjects_left_to_right()-- def break_up_tex_strings(self, tex_strings):- substrings_to_isolate = op.add(- self.substrings_to_isolate,- list(self.tex_to_color_map.keys()),- )- split_list = split_string_list_to_isolate_substrings(- tex_strings, *substrings_to_isolate- )- if self.arg_separator == " ":- split_list = [str(x).strip() for x in split_list]- # split_list = list(map(str.strip, split_list))- split_list = [s for s in split_list if s != ""]- return split_list-- def break_up_by_substrings(self):- """- Reorganize existing submobjects one layer- deeper based on the structure of tex_strings (as a list- of tex_strings)- """- new_submobjects = []- curr_index = 0- for tex_string in self.tex_strings:- sub_tex_mob = OpenGLSingleStringMathTex(- tex_string,- tex_environment=self.tex_environment,- tex_template=self.tex_template,- )- num_submobs = len(sub_tex_mob.submobjects)- new_index = curr_index + num_submobs- if num_submobs == 0:- # For cases like empty tex_strings, we want the corresponding- # part of the whole MathTex to be a VectorizedPoint- # positioned in the right part of the MathTex- sub_tex_mob.submobjects = [OpenGLVectorizedPoint()]- sub_tex_mob.assemble_family()- last_submob_index = min(curr_index, len(self.submobjects) - 1)- sub_tex_mob.move_to(self.submobjects[last_submob_index], RIGHT)- else:- sub_tex_mob.submobjects = self.submobjects[curr_index:new_index]- sub_tex_mob.assemble_family()- new_submobjects.append(sub_tex_mob)- curr_index = new_index- self.submobjects = new_submobjects- self.assemble_family()- return self-- def get_parts_by_tex(self, tex, substring=True, case_sensitive=True):- def test(tex1, tex2):- if not case_sensitive:- tex1 = tex1.lower()- tex2 = tex2.lower()- if substring:- return tex1 in tex2- else:- return tex1 == tex2-- return OpenGLVGroup(- *(m for m in self.submobjects if test(tex, m.get_tex_string()))- )-- def get_part_by_tex(self, tex, **kwargs):- all_parts = self.get_parts_by_tex(tex, **kwargs)- return all_parts[0] if all_parts else None-- def set_color_by_tex(self, tex, color, **kwargs):- parts_to_color = self.get_parts_by_tex(tex, **kwargs)- for part in parts_to_color:- part.set_color(color)- return self-- def set_color_by_tex_to_color_map(self, texs_to_color_map, **kwargs):- for texs, color in list(texs_to_color_map.items()):- try:- # If the given key behaves like tex_strings- texs + ""- self.set_color_by_tex(texs, color, **kwargs)- except TypeError:- # If the given key is a tuple- for tex in texs:- self.set_color_by_tex(tex, color, **kwargs)- return self-- def index_of_part(self, part):- split_self = self.split()- if part not in split_self:- raise ValueError("Trying to get index of part not in MathTex")- return split_self.index(part)-- def index_of_part_by_tex(self, tex, **kwargs):- part = self.get_part_by_tex(tex, **kwargs)- return self.index_of_part(part)-- def sort_alphabetically(self):- self.submobjects.sort(key=lambda m: m.get_tex_string())---class OpenGLTex(OpenGLMathTex):- r"""A string compiled with LaTeX in normal mode.-- Tests- ------- Check whether writing a LaTeX string works::-- >>> Tex('The horse does not eat cucumber salad.')- Tex('The horse does not eat cucumber salad.')-- """-- def __init__(- self, *tex_strings, arg_separator="", tex_environment="center", **kwargs- ):- super().__init__(- *tex_strings,- arg_separator=arg_separator,- tex_environment=tex_environment,- **kwargs,- )---class OpenGLBulletedList(OpenGLTex):- def __init__(- self,- *items,- buff=MED_LARGE_BUFF,- dot_scale_factor=2,- tex_environment=None,- **kwargs,- ):- self.buff = buff- self.dot_scale_factor = dot_scale_factor- self.tex_environment = tex_environment- line_separated_items = [s + "\\\\" for s in items]- Tex.__init__(- self, *line_separated_items, tex_environment=tex_environment, **kwargs- )- for part in self:- dot = MathTex("\\cdot").scale(self.dot_scale_factor)- dot.next_to(part[0], LEFT, SMALL_BUFF)- part.add_to_back(dot)- self.arrange(DOWN, aligned_edge=LEFT, buff=self.buff)-- def fade_all_but(self, index_or_string, opacity=0.5):- arg = index_or_string- if isinstance(arg, str):- part = self.get_part_by_tex(arg)- elif isinstance(arg, int):- part = self.submobjects[arg]- else:- raise TypeError(f"Expected int or string, got {arg}")- for other_part in self.submobjects:- if other_part is part:- other_part.set_fill(opacity=1)- else:- other_part.set_fill(opacity=opacity)---class OpenGLTitle(OpenGLTex):- def __init__(- self,- *text_parts,- scale_factor=1,- include_underline=True,- match_underline_width_to_text=False,- underline_buff=MED_SMALL_BUFF,- **kwargs,- ):- self.scale_factor = scale_factor- self.include_underline = include_underline- self.match_underline_width_to_text = match_underline_width_to_text- self.underline_buff = underline_buff- Tex.__init__(self, *text_parts, **kwargs)- self.scale(self.scale_factor)- self.to_edge(UP)- if self.include_underline:- underline_width = config["frame_width"] - 2- underline = OpenGLLine(LEFT, RIGHT)- underline.next_to(self, DOWN, buff=self.underline_buff)- if self.match_underline_width_to_text:- underline.match_width(self)- else:- underline.width = underline_width- self.add(underline)- self.underline = underlinediff --git a/manim/mobject/svg/opengl_text_mobject.py b/manim/mobject/svg/opengl_text_mobject.pydeleted file mode 100644index 16e0d5e3e..000000000--- a/manim/mobject/svg/opengl_text_mobject.py+++ /dev/null@@ -1,1212 +0,0 @@-"""Mobjects used for displaying (non-LaTeX) text.--The simplest way to add text to your animations is to use the :class:`~.Text` class. It uses the Pango library to render text.-With Pango, you are also able to render non-English alphabets like `你好` or `こんにちは` or `안녕하세요` or `مرحبا بالعالم`.--Examples-----------.. manim:: HelloWorld- :save_last_frame:-- class HelloWorld(Scene):- def construct(self):- text = Text('Hello world').scale(3)- self.add(text)--.. manim:: TextAlignment- :save_last_frame:-- class TextAlignment(Scene):- def construct(self):- title = Text("K-means clustering and Logistic Regression", color=WHITE)- title.scale(0.75)- self.add(title.to_edge(UP))-- t1 = Text("1. Measuring").set_color(WHITE)- t1.next_to(ORIGIN, direction=RIGHT, aligned_edge=UP)-- t2 = Text("2. Clustering").set_color(WHITE)- t2.next_to(t1, direction=DOWN, aligned_edge=LEFT)-- t3 = Text("3. Regression").set_color(WHITE)- t3.next_to(t2, direction=DOWN, aligned_edge=LEFT)-- t4 = Text("4. Prediction").set_color(WHITE)- t4.next_to(t3, direction=DOWN, aligned_edge=LEFT)-- x = VGroup(t1, t2, t3, t4).scale(0.7)- x.set_opacity(0.5)- x.submobjects[1].set_opacity(1)- self.add(x)--"""--# __all__ = ["Text", "Paragraph", "CairoText", "MarkupText", "register_font"]---import copy-import hashlib-import os-import re-import typing-from contextlib import contextmanager-from pathlib import Path--import manimpango-from manimpango import MarkupUtils, PangoUtils, TextSetting--from ... import config, logger-from ...constants import *-from ...mobject.opengl_geometry import OpenGLDot-from ...mobject.svg.opengl_svg_mobject import OpenGLSVGMobject-from ...mobject.types.opengl_vectorized_mobject import OpenGLVGroup-from ...utils.color import WHITE, Colors--TEXT_MOB_SCALE_FACTOR = 0.05---def remove_invisible_chars(mobject):- """Function to remove unwanted invisible characters from some mobject-- Parameters- ----------- mobject : :class:`~.SVGMobject`- Any SVGMobject from which we want to remove unwanted invisible characters.-- Returns- -------- :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(mobject.__len__()):- mobject_without_dots.add(VGroup())- mobject_without_dots[i].add(*(k for k in mobject[i] if k.__class__ != Dot))- else:- mobject_without_dots.add(*(k for k in mobject if k.__class__ != Dot))- if iscode:- code.code = mobject_without_dots- return code- return mobject_without_dots---class OpenGLParagraph(OpenGLVGroup):- r"""Display a paragraph of text.-- For a given :class:`.Paragraph` ``par``, the attribute ``par.chars`` is a- :class:`.VGroup` containing all the lines. In this context, every line is- constructed as a :class:`.VGroup` of characters contained in the line.--- Parameters- ----------- line_spacing : :class:`int`, optional- Represents the spacing between lines. Default to -1, which means auto.- alignment : :class:`str`, optional- Defines the alignment of paragraph. Default to "left". Possible values are "left", "right", "center"-- Examples- --------- Normal usage::-- paragraph = Paragraph('this is a awesome', 'paragraph',- 'With \nNewlines', '\tWith Tabs',- ' With Spaces', 'With Alignments',- 'center', 'left', 'right')-- Remove unwanted invisible characters::-- self.play(Transform(remove_invisible_chars(paragraph.chars[0:2]),- remove_invisible_chars(paragraph.chars[3][0:3]))-- """-- def __init__(self, *text, line_spacing=-1, alignment=None, **config):- self.line_spacing = line_spacing- self.alignment = alignment-- lines_str = "\n".join(list(text))- self.lines_text = OpenGLText(lines_str, line_spacing=line_spacing, **config)- lines_str_list = lines_str.split("\n")- self.chars = self.gen_chars(lines_str_list)-- chars_lines_text_list = OpenGLVGroup()- char_index_counter = 0- for line_index in range(lines_str_list.__len__()):- chars_lines_text_list.add(- self.lines_text[- char_index_counter : char_index_counter- + lines_str_list[line_index].__len__()- + 1- ],- )- char_index_counter += lines_str_list[line_index].__len__() + 1- self.lines = []- self.lines.append([])- for line_no in range(chars_lines_text_list.__len__()):- self.lines[0].append(chars_lines_text_list[line_no])- self.lines_initial_positions = []- for line_no in range(self.lines[0].__len__()):- self.lines_initial_positions.append(self.lines[0][line_no].get_center())- self.lines.append([])- self.lines[1].extend(- [self.alignment for _ in range(chars_lines_text_list.__len__())],- )- super().__init__(- *(self.lines[0][i] for i in range(self.lines[0].__len__())), **config- )- self.move_to(np.array([0, 0, 0]))- if self.alignment:- self.set_all_lines_alignments(self.alignment)-- def gen_chars(self, lines_str_list):- """Function to convert plain string to 2d-VGroup of chars. 2d-VGroup mean "VGroup of VGroup".-- Parameters- ----------- lines_str_list : :class:`str`- Plain text string.-- Returns- -------- :class:`~.VGroup`- The generated 2d-VGroup of chars.- """- char_index_counter = 0- chars = OpenGLVGroup()- for line_no in range(lines_str_list.__len__()):- chars.add(OpenGLVGroup())- chars[line_no].add(- *self.lines_text.chars[- char_index_counter : char_index_counter- + lines_str_list[line_no].__len__()- + 1- ]- )- char_index_counter += lines_str_list[line_no].__len__() + 1- return chars-- def set_all_lines_alignments(self, alignment):- """Function to set all line's alignment to a specific value.-- Parameters- ----------- alignment : :class:`str`- Defines the alignment of paragraph. Possible values are "left", "right", "center".- """- for line_no in range(0, self.lines[0].__len__()):- self.change_alignment_for_a_line(alignment, line_no)- return self-- def set_line_alignment(self, alignment, line_no):- """Function to set one line's alignment to a specific value.-- Parameters- ----------- alignment : :class:`str`- Defines the alignment of paragraph. Possible values are "left", "right", "center".- line_no : :class:`int`- Defines the line number for which we want to set given alignment.- """- self.change_alignment_for_a_line(alignment, line_no)- return self-- def set_all_lines_to_initial_positions(self):- """Set all lines to their initial positions."""- self.lines[1] = [None for _ in range(self.lines[0].__len__())]- for line_no in range(0, self.lines[0].__len__()):- self[line_no].move_to(- self.get_center() + self.lines_initial_positions[line_no],- )- return self-- def set_line_to_initial_position(self, line_no):- """Function to set one line to initial positions.-- Parameters- ----------- line_no : :class:`int`- Defines the line number for which we want to set given alignment.- """- self.lines[1][line_no] = None- self[line_no].move_to(self.get_center() + self.lines_initial_positions[line_no])- return self-- def change_alignment_for_a_line(self, alignment, line_no):- """Function to change one line's alignment to a specific value.-- Parameters- ----------- alignment : :class:`str`- Defines the alignment of paragraph. Possible values are "left", "right", "center".- line_no : :class:`int`- Defines the line number for which we want to set given alignment.- """- self.lines[1][line_no] = alignment- if self.lines[1][line_no] == "center":- self[line_no].move_to(- np.array([self.get_center()[0], self[line_no].get_center()[1], 0]),- )- elif self.lines[1][line_no] == "right":- self[line_no].move_to(- np.array(- [- self.get_right()[0] - self[line_no].width / 2,- self[line_no].get_center()[1],- 0,- ],- ),- )- elif self.lines[1][line_no] == "left":- self[line_no].move_to(- np.array(- [- self.get_left()[0] + self[line_no].width / 2,- self[line_no].get_center()[1],- 0,- ],- ),- )---class OpenGLText(OpenGLSVGMobject):- r"""Display (non-LaTeX) text rendered using `Pango <https://pango.gnome.org/>`_.-- Text objects behave like a :class:`.VGroup`-like iterable of all characters- in the given text. In particular, slicing is possible.-- Parameters- ----------- text : :class:`str`- The text that need to created as mobject.-- Returns- -------- :class:`Text`- The mobject like :class:`.VGroup`.-- Examples- ----------- .. manim:: Example1Text- :save_last_frame:-- class Example1Text(Scene):- def construct(self):- text = Text('Hello world').scale(3)- self.add(text)-- .. manim:: TextColorExample- :save_last_frame:-- class TextColorExample(Scene):- def construct(self):- text1 = Text('Hello world', color=BLUE).scale(3)- text2 = Text('Hello world', gradient=(BLUE, GREEN)).scale(3).next_to(text1, DOWN)- self.add(text1, text2)-- .. manim:: TextItalicAndBoldExample- :save_last_frame:-- class TextItalicAndBoldExample(Scene):- def construct(self):- text0 = Text('Hello world', slant=ITALIC)- text1 = Text('Hello world', t2s={'world':ITALIC})- text2 = Text('Hello world', weight=BOLD)- text3 = Text('Hello world', t2w={'world':BOLD})- self.add(text0,text1, text2,text3)- for i,mobj in enumerate(self.mobjects):- mobj.shift(DOWN*(i-1))--- .. manim:: TextMoreCustomization- :save_last_frame:-- class TextMoreCustomization(Scene):- def construct(self):- text1 = Text(- 'Google',- t2c={'[:1]': '#3174f0', '[1:2]': '#e53125',- '[2:3]': '#fbb003', '[3:4]': '#3174f0',- '[4:5]': '#269a43', '[5:]': '#e53125'}, size=1.2).scale(3)- self.add(text1)-- As :class:`Text` uses Pango to render text, rendering non-English- characters is easily possible:-- .. manim:: MultipleFonts- :save_last_frame:-- class MultipleFonts(Scene):- def construct(self):- morning = Text("வணக்கம்", font="sans-serif")- japanese = Text(- "見 角 言 谷 辛 辰 辵 邑 酉 釆 里!", t2c={"見 角 言": BLUE}- ) # works same as ``Text``.- mess = Text("Multi-Language", style=BOLD)- russ = Text("Здравствуйте मस नम म ", font="sans-serif")- hin = Text("नमस्ते", font="sans-serif")- arb = Text(- "صباح الخير \n تشرفت بمقابلتك", font="sans-serif"- ) # don't mix RTL and LTR languages nothing shows up then ;-)- chinese = Text("臂猿「黛比」帶著孩子", font="sans-serif")- self.add(morning, japanese, mess, russ, hin, arb, chinese)- for i,mobj in enumerate(self.mobjects):- mobj.shift(DOWN*(i-3))--- .. manim:: PangoRender- :quality: low-- class PangoRender(Scene):- def construct(self):- morning = Text("வணக்கம்", font="sans-serif")- self.play(Write(morning))- self.wait(2)-- Tests- ------- Check that the creation of :class:`~.Text` works::-- >>> Text('The horse does not eat cucumber salad.')- Text('The horse does not eat cucumber salad.')-- """-- def __init__(- self,- text: str,- fill_opacity: float = 1.0,- stroke_width: int = 0,- color: str = WHITE,- size: int = 1,- line_spacing: int = -1,- font: str = "",- slant: str = NORMAL,- weight: str = NORMAL,- t2c: typing.Dict[str, str] = None,- t2f: typing.Dict[str, str] = None,- t2g: typing.Dict[str, tuple] = None,- t2s: typing.Dict[str, str] = None,- t2w: typing.Dict[str, str] = None,- gradient: tuple = None,- tab_width: int = 4,- # Mobject- height: int = None,- width: int = None,- should_center: bool = True,- unpack_groups: bool = True,- disable_ligatures: bool = False,- **kwargs,- ):- self.size = size- self.line_spacing = line_spacing- self.font = font- self.slant = slant- self.weight = weight- self.gradient = gradient- self.tab_width = tab_width- if t2c is None:- t2c = {}- if t2f is None:- t2f = {}- if t2g is None:- t2g = {}- if t2s is None:- t2s = {}- if t2w is None:- t2w = {}- # If long form arguments are present, they take precedence- t2c = kwargs.pop("text2color", t2c)- t2f = kwargs.pop("text2font", t2f)- 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-- self.original_text = text- self.disable_ligatures = disable_ligatures- text_without_tabs = text- if text.find("\t") != -1:- text_without_tabs = text.replace("\t", " " * self.tab_width)- self.text = text_without_tabs- if self.line_spacing == -1:- self.line_spacing = self.size + self.size * 0.3- else:- self.line_spacing = self.size + self.size * self.line_spacing- file_name = self.text2svg()- PangoUtils.remove_last_M(file_name)- super().__init__(- file_name,- color=color,- fill_opacity=fill_opacity,- stroke_width=stroke_width,- height=height,- width=width,- should_center=should_center,- unpack_groups=unpack_groups,- **kwargs,- )- self.text = text- if self.disable_ligatures:- self.submobjects = [*self.gen_chars()]- self.chars = OpenGLVGroup(*self.submobjects)- self.text = text_without_tabs.replace(" ", "").replace("\n", "")- if config["renderer"] == "opengl":- nppc = self.n_points_per_curve- else:- nppc = self.n_points_per_cubic_curve- for each in self:- if config["renderer"] == "opengl":- points = each.data["points"]- else:- nppc = each.points- if len(points) == 0:- continue- last = points[0]- each.clear_points()- for index, point in enumerate(points):- each.append_points([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)- if self.t2c:- self.set_color_by_t2c()- if self.gradient:- self.set_color_by_gradient(*self.gradient)- if self.t2g:- self.set_color_by_t2g()- # anti-aliasing- if height is None and width is None:- self.scale(TEXT_MOB_SCALE_FACTOR)-- def __repr__(self):- return f"Text({repr(self.original_text)})"-- def gen_chars(self):- chars = OpenGLVGroup()- submobjects_char_index = 0- for char_index in range(self.text.__len__()):- if self.text[char_index] in (" ", "\t", "\n"):- space = OpenGLDot(radius=0, fill_opacity=0, stroke_opacity=0)- if char_index == 0:- space.move_to(self.submobjects[submobjects_char_index].get_center())- else:- space.move_to(- self.submobjects[submobjects_char_index - 1].get_center(),- )- chars.add(space)- else:- chars.add(self.submobjects[submobjects_char_index])- submobjects_char_index += 1- return chars-- def find_indexes(self, word: str, text: str):- """Internally used function. Finds the indexes of ``text`` in ``word``."""- temp = re.match(r"\[([0-9\-]{0,}):([0-9\-]{0,})\]", word)- if temp:- start = int(temp.group(1)) if temp.group(1) != "" else 0- 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)]- indexes = []- index = text.find(word)- while index != -1:- indexes.append((index, index + len(word)))- index = text.find(word, index + len(word))- return indexes-- # def full2short(self, kwargs):- # """Internally used function. Formats some expansion to short forms.- # text2color -> t2c- # text2font -> t2f- # text2gradient -> t2g- # text2slant -> t2s- # text2weight -> t2w- # """- # if "text2color" in kwargs:- # self.t2c = kwargs.pop("text2color")- # if "text2font" in kwargs:- # self.t2f = kwargs.pop("text2font")- # if "text2gradient" in kwargs:- # self.t2g = kwargs.pop("text2gradient")- # if "text2slant" in kwargs:- # self.t2s = kwargs.pop("text2slant")- # if "text2weight" in kwargs:- # self.t2w = kwargs.pop("text2weight")-- def set_color_by_t2c(self, t2c=None):- """Internally used function. Sets colour 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.original_text):- self.chars[start:end].set_color(color)-- def set_color_by_t2g(self, t2g=None):- """Internally used. 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.original_text):- self.chars[start:end].set_color_by_gradient(*gradient)-- def text2hash(self):- """Internally used function.- Generates ``sha256`` hash for file name.- """- settings = (- "PANGO" + self.font + self.slant + self.weight- ) # to differentiate Text and CairoText- settings += str(self.t2f) + str(self.t2s) + str(self.t2w)- settings += str(self.line_spacing) + str(self.size)- settings += str(self.disable_ligatures)- id_str = self.text + settings- hasher = hashlib.sha256()- hasher.update(id_str.encode())- return hasher.hexdigest()[:16]-- def text2settings(self):- """Internally used function. Converts the texts and styles- to a setting for parsing."""- settings = []- t2x = [self.t2f, self.t2s, self.t2w]- for i in range(len(t2x)):- fsw = [self.font, self.slant, self.weight]- if t2x[i]:- for word, x in list(t2x[i].items()):- for start, end in self.find_indexes(word, self.text):- fsw[i] = x- settings.append(TextSetting(start, end, *fsw))- # Set all text settings (default font, slant, weight)- fsw = [self.font, self.slant, self.weight]- settings.sort(key=lambda setting: setting.start)- temp_settings = settings.copy()- start = 0- for setting in settings:- if setting.start != start:- temp_settings.append(TextSetting(start, setting.start, *fsw))- start = setting.end- if start != len(self.text):- temp_settings.append(TextSetting(start, len(self.text), *fsw))- settings = sorted(temp_settings, key=lambda setting: setting.start)-- if re.search(r"\n", self.text):- line_num = 0- for start, 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:- line_num += 1- new_setting = copy.copy(setting)- setting.end = end- new_setting.start = end- new_setting.line_num = line_num- settings.append(new_setting)- settings.sort(key=lambda setting: setting.start)- break- for setting in settings:- if setting.line_num == -1:- setting.line_num = 0- return settings-- def text2svg(self):- """Internally used function.- Convert the text to SVG using Pango- """- size = self.size * 10- line_spacing = self.line_spacing * 10- dir_name = config.get_dir("text_dir")- disable_liga = self.disable_ligatures- if not os.path.exists(dir_name):- os.makedirs(dir_name)- hash_name = self.text2hash()- file_name = os.path.join(dir_name, hash_name) + ".svg"- if os.path.exists(file_name):- return file_name- settings = self.text2settings()- width = 600- height = 400-- return manimpango.text2svg(- settings,- size,- line_spacing,- disable_liga,- file_name,- START_X,- START_Y,- width,- height,- self.text,- )-- def init_colors(self, propagate_colors=True):- OpenGLSVGMobject.set_style(- self,- fill_color=self.fill_color or self.color,- fill_opacity=self.fill_opacity,- stroke_color=self.stroke_color or self.color,- stroke_width=self.stroke_width,- stroke_opacity=self.stroke_opacity,- recurse=propagate_colors,- )---class OpenGLMarkupText(OpenGLSVGMobject):- r"""Display (non-LaTeX) text rendered using `Pango <https://pango.gnome.org/>`_.-- Text objects behave like a :class:`.VGroup`-like iterable of all characters- in the given text. In particular, slicing is possible. Text can be formatted- using different tags:-- - ``<b>bold</b>``, ``<i>italic</i>`` and ``<b><i>bold+italic</i></b>``- - ``<ul>underline</ul>`` 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>``- - ``<span underline="double" underline_color="green">double underline</span>``- - ``<span underline="error">error underline</span>``- - ``<span overline="single" overline_color="green">overline</span>``- - ``<span strikethrough="true" strikethrough_color="red">strikethrough</span>``- - ``<span font_family="sans">temporary change of font</span>``- - ``<span foreground="red">temporary change of color</span>``- - ``<span fgcolor="red">temporary change of color</span>``- - ``<gradient from="YELLOW" to="RED">temporary gradient</gradient>``-- For ``<span>`` markup, colors can be specified either as hex triples like ``#aabbcc`` or as named CSS colors like ``AliceBlue``.- The ``<gradient>`` tag being handled by Manim rather than Pango, supports hex triplets or Manim constants like ``RED`` or ``RED_A``.- If you want to use Manim constants like ``RED_A`` together with ``<span>``,- you will need to use Python's f-String syntax as follows:- ``f'<span foreground="{RED_A}">here you go</span>'``-- If your text contains ligatures, the :class:`MarkupText` class may incorrectly determine- the first and last letter when creating the gradient. This is due to the fact that e.g. ``fl``- are two characters, but might be set as one single glyph, a ligature. If your language does- not depend on ligatures, consider setting ``disable_ligatures=True``. If you cannot or do- not want to do without ligatures, the ``gradient`` tag supports an optional attribute ``offset``- which can be used to compensate for that error. Usage is as follows:-- - ``<gradient from="RED" to="YELLOW" offset="1">example</gradient>`` to *start* the gradient one letter earlier- - ``<gradient from="RED" to="YELLOW" offset=",1">example</gradient>`` to *end* the gradient one letter earlier- - ``<gradient from="RED" to="YELLOW" offset="2,1">example</gradient>`` to *start* the gradient two letters earlier and *end* it one letter earlier-- Specifying a second offset may be necessary if the text to be colored does- itself contain ligatures. The same can happen when using HTML entities for- special chars.-- When using ``underline``, ``overline`` or ``strikethrough`` together with ``<gradient>`` tags, you will also need to use the offset, because- underlines are additional paths in the final :class:`SVGMobject`, check out the corresponding example.-- Escaping of special characters: ``>`` *should* be written as ``>`` whereas ``<`` and- ``&`` *must* be written as ``<`` and ``&``.-- You can find more information about Pango markup formatting at the- corresponding documentation page:- `Pango Markup <https://developer.gnome.org/pango/1.46/pango-Markup.html>`_.- Please be aware that not all features are supported by this class and that- the ``<gradient>`` tag mentioned above is not supported by Pango.-- Parameters- ----------- text : :class:`str`- The text that need to created as mobject.- fill_opacity : :class:`int`- The fill opacity with 1 meaning opaque and 0 meaning transparent.- stroke_width : :class:`int`- Stroke width.- color : :class:`str`- Global color setting for the entire text. Local overrides are possible.- size : :class:`int`- Font size.- line_spacing : :class:`int`- Line spacing.- font : :class:`str`- Global font setting for the entire text. Local overrides are possible.- slant : :class:`str`- Global slant setting, e.g. `NORMAL` or `ITALIC`. Local overrides are possible.- weight : :class:`str`- Global weight setting, e.g. `NORMAL` or `BOLD`. Local overrides are possible.- gradient: :class:`tuple`- Global gradient setting. Local overrides are possible.--- Returns- -------- :class:`MarkupText`- The text displayed in form of a :class:`.VGroup`-like mobject.-- Examples- ----------- .. manim:: BasicMarkupExample- :save_last_frame:-- class BasicMarkupExample(Scene):- def construct(self):- text1 = MarkupText("<b>foo</b> <i>bar</i> <b><i>foobar</i></b>")- text2 = MarkupText("<s>foo</s> <u>bar</u> <big>big</big> <small>small</small>")- text3 = MarkupText("H<sub>2</sub>O and H<sub>3</sub>O<sup>+</sup>")- text4 = MarkupText("type <tt>help</tt> for help")- text5 = MarkupText(- '<span underline="double">foo</span> <span underline="error">bar</span>'- )- group = VGroup(text1, text2, text3, text4, text5).arrange(DOWN)- self.add(group)-- .. manim:: ColorExample- :save_last_frame:-- class ColorExample(Scene):- def construct(self):- text1 = MarkupText(- f'all in red <span fgcolor="{YELLOW}">except this</span>', color=RED- )- text2 = MarkupText("nice gradient", gradient=(BLUE, GREEN))- text3 = MarkupText(- 'nice <gradient from="RED" to="YELLOW">intermediate</gradient> gradient',- gradient=(BLUE, GREEN),- )- text4 = MarkupText(- 'fl ligature <gradient from="RED" to="YELLOW">causing trouble</gradient> here'- )- text5 = MarkupText(- 'fl ligature <gradient from="RED" to="YELLOW" offset="1">defeated</gradient> with offset'- )- text6 = MarkupText(- 'fl ligature <gradient from="RED" to="YELLOW" offset="1">floating</gradient> inside'- )- text7 = MarkupText(- 'fl ligature <gradient from="RED" to="YELLOW" offset="1,1">floating</gradient> inside'- )- group = VGroup(text1, text2, text3, text4, text5, text6, text7).arrange(DOWN)- self.add(group)-- .. manim:: UnderlineExample- :save_last_frame:-- class UnderlineExample(Scene):- def construct(self):- text1 = MarkupText(- '<span underline="double" underline_color="green">bla</span>'- )- text2 = MarkupText(- '<span underline="single" underline_color="green">xxx</span><gradient from="#ffff00" to="RED">aabb</gradient>y'- )- text3 = MarkupText(- '<span underline="single" underline_color="green">xxx</span><gradient from="#ffff00" to="RED" offset="-1">aabb</gradient>y'- )- text4 = MarkupText(- '<span underline="double" underline_color="green">xxx</span><gradient from="#ffff00" to="RED">aabb</gradient>y'- )- text5 = MarkupText(- '<span underline="double" underline_color="green">xxx</span><gradient from="#ffff00" to="RED" offset="-2">aabb</gradient>y'- )- group = VGroup(text1, text2, text3, text4, text5).arrange(DOWN)- self.add(group)-- .. manim:: FontExample- :save_last_frame:-- class FontExample(Scene):- def construct(self):- text1 = MarkupText(- 'all in sans <span font_family="serif">except this</span>', font="sans"- )- text2 = MarkupText(- '<span font_family="serif">mixing</span> <span font_family="sans">fonts</span> <span font_family="monospace">is ugly</span>'- )- text3 = MarkupText("special char > or >")- text4 = MarkupText("special char < and &")- group = VGroup(text1, text2, text3, text4).arrange(DOWN)- self.add(group)-- .. manim:: NewlineExample- :save_last_frame:-- class NewlineExample(Scene):- def construct(self):- text = MarkupText('foooo<span foreground="red">oo\nbaa</span>aar')- self.add(text)-- .. manim:: NoLigaturesExample- :save_last_frame:-- class NoLigaturesExample(Scene):- def construct(self):- text1 = MarkupText('fl<gradient from="RED" to="GREEN">oat</gradient>ing')- text2 = MarkupText('fl<gradient from="RED" to="GREEN">oat</gradient>ing', disable_ligatures=True)- group = VGroup(text1, text2).arrange(DOWN)- self.add(group)--- As :class:`MarkupText` uses Pango to render text, rendering non-English- characters is easily possible:-- .. manim:: MultiLanguage- :save_last_frame:-- class MultiLanguage(Scene):- def construct(self):- morning = MarkupText("வணக்கம்", font="sans-serif")- japanese = MarkupText(- '見 角 言 谷 辛 <span fgcolor="blue">辰 辵 邑</span> 酉 釆 里!'- ) # works as in ``Text``.- mess = MarkupText("Multi-Language", style=BOLD)- russ = MarkupText("Здравствуйте मस नम म ", font="sans-serif")- hin = MarkupText("नमस्ते", font="sans-serif")- chinese = MarkupText("臂猿「黛比」帶著孩子", font="sans-serif")- group = VGroup(morning, japanese, mess, russ, hin, chinese).arrange(DOWN)- self.add(group)--- Tests- ------- Check that the creation of :class:`~.MarkupText` works::-- >>> MarkupText('The horse does not eat cucumber salad.')- MarkupText('The horse does not eat cucumber salad.')-- """-- def __init__(- self,- text: str,- fill_opacity: int = 1,- stroke_width: int = 0,- color: str = WHITE,- size: int = 1,- line_spacing: int = -1,- font: str = "",- slant: str = NORMAL,- weight: str = NORMAL,- gradient: tuple = None,- tab_width: int = 4,- height: int = None,- width: int = None,- should_center: bool = True,- unpack_groups: bool = True,- disable_ligatures: bool = False,- **kwargs,- ):- self.text = text- self.color = color- self.size = size- self.line_spacing = line_spacing- self.font = font- self.slant = slant- self.weight = weight- self.gradient = gradient- self.tab_width = tab_width-- self.original_text = text- self.disable_ligatures = disable_ligatures- text_without_tabs = text- if "\t" in text:- text_without_tabs = text.replace("\t", " " * self.tab_width)-- colormap = self.extract_color_tags()- if len(colormap) > 0:- logger.warning(- 'Using <color> tags in MarkupText is deprecated. Please use <span foreground="..."> instead.',- )- gradientmap = self.extract_gradient_tags()-- if not MarkupUtils.validate(self.text):- raise ValueError(- f"Pango cannot parse your markup in {self.text}. "- "Please check for typos, unmatched tags or unescaped "- "special chars like < and &.",- )-- if self.line_spacing == -1:- self.line_spacing = self.size + self.size * 0.3- else:- self.line_spacing = self.size + self.size * self.line_spacing-- file_name = self.text2svg()- PangoUtils.remove_last_M(file_name)- super().__init__(- file_name,- fill_opacity=fill_opacity,- stroke_width=stroke_width,- height=height,- width=width,- should_center=should_center,- unpack_groups=unpack_groups,- **kwargs,- )- self.chars = OpenGLVGroup(*self.submobjects)- self.text = text_without_tabs.replace(" ", "").replace("\n", "")-- if config["renderer"] == "opengl":- nppc = self.n_points_per_curve- else:- nppc = self.n_points_per_cubic_curve- for each in self:- if config["renderer"] == "opengl":- points = each.data["points"]- else:- points = each.points- if len(points) == 0:- continue- last = points[0]- each.clear_points()- for index, point in enumerate(points):- each.append_points([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)-- 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_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_offset"]- - grad["end_offset"]- ].set_color_by_gradient(- *(self._parse_color(grad["from"]), self._parse_color(grad["to"]))- )- # anti-aliasing- if height is None and width is None:- self.scale(TEXT_MOB_SCALE_FACTOR)-- def text2hash(self):- """Generates ``sha256`` hash for file name."""- settings = (- "MARKUPPANGO" + self.font + self.slant + self.weight + self.color- ) # to differentiate from classical Pango Text- settings += str(self.line_spacing) + str(self.size)- settings += str(self.disable_ligatures)- id_str = self.text + settings- hasher = hashlib.sha256()- hasher.update(id_str.encode())- return hasher.hexdigest()[:16]-- def text2svg(self):- """Convert the text to SVG using Pango."""- size = self.size * 10- line_spacing = self.line_spacing * 10- dir_name = config.get_dir("text_dir")- disable_liga = self.disable_ligatures- if not os.path.exists(dir_name):- os.makedirs(dir_name)- hash_name = self.text2hash()- file_name = os.path.join(dir_name, hash_name) + ".svg"- if os.path.exists(file_name):- return file_name-- logger.debug(f"Setting Text {self.text}")- return MarkupUtils.text2svg(- f'<span foreground="{self.color}">{self.text}</span>',- self.font,- self.slant,- self.weight,- size,- line_spacing,- disable_liga,- file_name,- START_X,- START_Y,- 600, # width- 400, # height- )-- def _count_real_chars(self, s):- """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."""- count = 0- level = 0- # temporarily replace HTML entities by single char- s = re.sub("&[^;]+;", "x", s)- for c in s:- if c == "<":- level += 1- if c == ">" and level > 0:- level -= 1- elif c != " " and c != "\t" and level == 0:- count += 1- return count-- def extract_gradient_tags(self):- """Used to determine which parts (if any) of the string should be formatted- with a gradient.-- Removes the ``<gradient>`` tag, as it is not part of Pango's markup and would cause an error.- """- tags = re.finditer(- r'<gradient\s+from="([^"]+)"\s+to="([^"]+)"(\s+offset="([^"]+)")?>(.+?)</gradient>',- self.original_text,- re.S,- )- gradientmap = []- for tag in tags:- start = self._count_real_chars(self.original_text[: tag.start(0)])- end = start + self._count_real_chars(tag.group(5))- offsets = tag.group(4).split(",") if tag.group(4) else [0]- start_offset = int(offsets[0]) if offsets[0] else 0- end_offset = int(offsets[1]) if len(offsets) == 2 and offsets[1] else 0-- gradientmap.append(- {- "start": start,- "end": end,- "from": tag.group(1),- "to": tag.group(2),- "start_offset": start_offset,- "end_offset": end_offset,- },- )- self.text = re.sub("<gradient[^>]+>(.+?)</gradient>", r"\1", self.text, 0, re.S)- return gradientmap-- def _parse_color(self, col):- """Parse color given in ``<color>`` or ``<gradient>`` tags."""- if re.match("#[0-9a-f]{6}", col):- return col- else:- return Colors[col.lower()].value-- def extract_color_tags(self):- """Used to determine which parts (if any) of the string should be formatted- with a custom color.-- Removes the ``<color>`` tag, as it is not part of Pango's markup and would cause an error.-- Note: Using the ``<color>`` tags is deprecated. As soon as the legacy syntax is gone, this function- will be removed.- """- tags = re.finditer(- r'<color\s+col="([^"]+)"(\s+offset="([^"]+)")?>(.+?)</color>',- self.original_text,- re.S,- )-- colormap = []- for tag in tags:- start = self._count_real_chars(self.original_text[: tag.start(0)])- end = start + self._count_real_chars(tag.group(4))- offsets = tag.group(3).split(",") if tag.group(3) else [0]- start_offset = int(offsets[0]) if offsets[0] else 0- end_offset = int(offsets[1]) if len(offsets) == 2 and offsets[1] else 0-- colormap.append(- {- "start": start,- "end": end,- "color": tag.group(1),- "start_offset": start_offset,- "end_offset": end_offset,- },- )- self.text = re.sub("<color[^>]+>(.+?)</color>", r"\1", self.text, 0, re.S)- return colormap-- def __repr__(self):- return f"MarkupText({repr(self.original_text)})"---@contextmanager-def register_font(font_file: typing.Union[str, Path]):- """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.-- 1. Absolute path.- 2. In ``assets/fonts`` folder.- 3. In ``font/`` folder.- 4. In the same directory.-- Parameters- ----------- font_file :- The font file to add.-- Examples- --------- Use ``with register_font(...)`` to add a font file to search- path.-- .. code-block:: python-- with register_font("path/to/font_file.ttf"):- a = Text("Hello", font="Custom Font Name")-- Raises- ------- FileNotFoundError:- If the font doesn't exists.-- AttributeError:- If this method is used on macOS.-- Notes- ------ This method of adding font files also works with :class:`CairoText`.-- .. important ::-- 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),- input_folder / "assets/fonts" / font_file,- input_folder / "fonts" / font_file,- input_folder / font_file,- ]- for path in possible_paths:- path = path.resolve()- if path.exists():- file_path = path- logger.debug("Found file at %s", file_path.absolute())- break- else:- error = f"Can't find {font_file}." f"Tried these : {possible_paths}"- raise FileNotFoundError(error)-- try:- assert manimpango.register_font(str(file_path))- yield- finally:- manimpango.unregister_font(str(file_path))