A community-maintained Python framework for creating mathematical animations.
Add OpenGLText and related classes
Devin Neal0c7e98add535
diff --git a/manim/mobject/svg/opengl_text_mobject.py b/manim/mobject/svg/opengl_text_mobject.pynew file mode 100644index 000000000..9565d7b48--- /dev/null+++ b/manim/mobject/svg/opengl_text_mobject.py@@ -0,0 +1,1526 @@+"""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_in_place(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_in_place(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 sys+import typing+from contextlib import contextmanager+from pathlib import Path+from typing import Dict+from xml.sax.saxutils import escape++import cairo+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 OpenGLCairoText(OpenGLSVGMobject):+ """Display (non-LaTeX) text.++ Text objects behave like a :class:`.VGroup`-like iterable of all characters+ in the given text. In particular, slicing is possible.+++ Tests+ -----++ Check whether writing text works::++ >>> Text('The horse does not eat cucumber salad.')+ Text('The horse does not eat cucumber salad.')++ """++ def __init__(+ self,+ text,+ # Mobject+ color=WHITE,+ height=None,+ width=None,+ fill_opacity=1,+ stroke_width=0,+ should_center=True,+ unpack_groups=True,+ # Text+ font="",+ gradient=None,+ line_spacing=-1,+ size=1,+ slant: str = NORMAL,+ weight: str = NORMAL,+ t2c=None,+ t2f=None,+ t2g=None,+ t2s=None,+ t2w=None,+ tab_width=4,+ **kwargs,+ ):+ # self.full2short(config)+ 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.font = font+ self.gradient = gradient+ self.line_spacing = line_spacing+ self.size = size+ self.slant = slant+ self.weight = weight+ self.tab_width = tab_width+ self.original_text = text+ 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)+ OpenGLSVGMobject.__init__(+ self,+ file_name,+ height=height,+ width=width,+ unpack_groups=unpack_groups,+ color=color,+ fill_opacity=fill_opacity,+ stroke_width=stroke_width,+ should_center=should_center,+ **kwargs,+ )+ self.text = text+ self.submobjects = [*self.gen_chars()]+ self.chars = OpenGLVGroup(*self.submobjects)+ self.text = text_without_tabs.replace(" ", "").replace("\n", "")+ if config["use_opengl_renderer"]:+ nppc = self.n_points_per_curve+ else:+ nppc = self.n_points_per_cubic_curve+ for each in self:+ if config["use_opengl_renderer"]:+ 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.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] == " "+ or self.text[char_index] == "\t"+ or self.text[char_index] == "\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, text):+ m = re.match(r"\[([0-9\-]{0,}):([0-9\-]{0,})\]", word)+ if m:+ start = int(m.group(1)) if m.group(1) != "" else 0+ end = int(m.group(2)) if m.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, config_args):+ # for kwargs in [config_args]:+ # if kwargs.__contains__("text2color"):+ # kwargs["t2c"] = kwargs.pop("text2color")+ # if kwargs.__contains__("text2font"):+ # kwargs["t2f"] = kwargs.pop("text2font")+ # if kwargs.__contains__("text2gradient"):+ # kwargs["t2g"] = kwargs.pop("text2gradient")+ # if kwargs.__contains__("text2slant"):+ # kwargs["t2s"] = kwargs.pop("text2slant")+ # if kwargs.__contains__("text2weight"):+ # kwargs["t2w"] = kwargs.pop("text2weight")++ def set_color_by_t2c(self, t2c=None):+ 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):+ 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 str2slant(self, string):+ if string == NORMAL:+ return cairo.FontSlant.NORMAL+ if string == ITALIC:+ return cairo.FontSlant.ITALIC+ if string == OBLIQUE:+ return cairo.FontSlant.OBLIQUE++ def str2weight(self, string):+ if string == NORMAL:+ return cairo.FontWeight.NORMAL+ if string == BOLD:+ return cairo.FontWeight.BOLD++ def text2hash(self):+ settings = self.font + self.slant + self.weight+ settings += str(self.t2f) + str(self.t2s) + str(self.t2w)+ settings += str(self.line_spacing) + str(self.size)+ id_str = self.text + settings+ hasher = hashlib.sha256()+ hasher.update(id_str.encode())+ return hasher.hexdigest()[:16]++ def text2settings(self):+ 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):+ # anti-aliasing+ size = self.size * 10+ line_spacing = self.line_spacing * 10++ if self.font == "":+ if NOT_SETTING_FONT_MSG:+ logger.warning(NOT_SETTING_FONT_MSG)++ dir_name = config.get_dir("text_dir")+ 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+ surface = cairo.SVGSurface(file_name, 600, 400)+ context = cairo.Context(surface)+ context.set_font_size(size)+ context.move_to(START_X, START_Y)++ settings = self.text2settings()+ offset_x = 0+ last_line_num = 0+ for setting in settings:+ font = setting.font.decode("utf-8")+ slant = self.str2slant(setting.slant)+ weight = self.str2weight(setting.weight)+ text = self.text[setting.start : setting.end].replace("\n", " ")++ context.select_font_face(font, slant, weight)+ if setting.line_num != last_line_num:+ offset_x = 0+ last_line_num = setting.line_num+ context.move_to(+ START_X + offset_x, START_Y + line_spacing * setting.line_num+ )+ context.show_text(text)+ offset_x += context.text_extents(text)[4]+ surface.finish()+ return file_name+++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+ OpenGLVGroup.__init__(self, **config)++ 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__())]+ )+ OpenGLVGroup.__init__(+ self, *[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")+ chin = 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 ;-)+ japanese = Text("臂猿「黛比」帶著孩子", font="sans-serif")+ self.add(morning,chin,mess,russ,hin,arb,japanese)+ 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: 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,+ 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)+ OpenGLSVGMobject.__init__(+ self,+ 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["use_opengl_renderer"]:+ nppc = self.n_points_per_curve+ else:+ nppc = self.n_points_per_cubic_curve+ for each in self:+ if config["use_opengl_renderer"]:+ 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/stable/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")+ chin = 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")+ japanese = MarkupText("臂猿「黛比」帶著孩子", font="sans-serif")+ group = VGroup(morning, chin, mess, russ, hin, japanese).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)+ OpenGLSVGMobject.__init__(+ self,+ 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["use_opengl_renderer"]:+ nppc = self.n_points_per_curve+ else:+ nppc = self.n_points_per_cubic_curve+ for each in self:+ if config["use_opengl_renderer"]:+ 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))