Merge branch 'master' of https://github.com/3b1b/manim

Author: TonyCrane

manimlib/mobject/numbers.py

@@ -2,6 +2,7 @@
 from manimlib.mobject.svg.tex_mobject import SingleStringTex
 from manimlib.mobject.svg.text_mobject import Text
 from manimlib.mobject.types.vectorized_mobject import VMobject
+from manimlib.utils.iterables import hash_obj
 
 
 string_to_mob_map = {}
@@ -20,23 +21,23 @@ class DecimalNumber(VMobject):
         "include_background_rectangle": False,
         "edge_to_fix": LEFT,
         "font_size": 48,
+        "text_config": {} # Do not pass in font_size here
     }
 
     def __init__(self, number=0, **kwargs):
         super().__init__(**kwargs)
         self.set_submobjects_from_number(number)
-        self.init_colors()
 
     def set_submobjects_from_number(self, number):
         self.number = number
         self.set_submobjects([])
-
+        string_to_mob_ = lambda s: self.string_to_mob(s, **self.text_config)
         num_string = self.get_num_string(number)
-        self.add(*map(self.string_to_mob, num_string))
+        self.add(*map(string_to_mob_, num_string))
 
         # Add non-numerical bits
         if self.show_ellipsis:
-            dots = self.string_to_mob("...")
+            dots = string_to_mob_("...")
             dots.arrange(RIGHT, buff=2 * dots[0].get_width())
             self.add(dots)
         if self.unit is not None:
@@ -85,10 +86,10 @@ def init_data(self):
     def get_font_size(self):
         return self.data["font_size"][0]
 
-    def string_to_mob(self, string, mob_class=Text):
-        if string not in string_to_mob_map:
-            string_to_mob_map[string] = mob_class(string, font_size=1)
-        mob = string_to_mob_map[string].copy()
+    def string_to_mob(self, string, mob_class=Text, **kwargs):
+        if (string, hash_obj(kwargs)) not in string_to_mob_map:
+            string_to_mob_map[(string, hash_obj(kwargs))] = mob_class(string, font_size=1, **kwargs)
+        mob = string_to_mob_map[(string, hash_obj(kwargs))].copy()
         mob.scale(self.get_font_size())
         return mob
 

manimlib/mobject/svg/drawings.py

@@ -318,9 +318,6 @@ def __init__(self, **kwargs):
         self.content = Mobject()
         self.refresh_triangulation()
 
-    def init_colors(self):
-        VMobject.init_colors(self)
-
     def get_tip(self):
         # TODO, find a better way
         return self.get_corner(DOWN + self.direction) - 0.6 * self.direction

manimlib/mobject/svg/mtex_mobject.py

@@ -2,11 +2,11 @@
 import re
 from types import MethodType
 
-from manimlib.constants import BLACK
+from manimlib.constants import WHITE
 from manimlib.mobject.svg.svg_mobject import SVGMobject
-from manimlib.mobject.types.vectorized_mobject import VMobject
 from manimlib.mobject.types.vectorized_mobject import VGroup
 from manimlib.utils.color import color_to_int_rgb
+from manimlib.utils.config_ops import digest_config
 from manimlib.utils.iterables import adjacent_pairs
 from manimlib.utils.iterables import remove_list_redundancies
 from manimlib.utils.tex_file_writing import tex_to_svg_file
@@ -18,25 +18,10 @@
 SCALE_FACTOR_PER_FONT_POINT = 0.001
 
 
-TEX_HASH_TO_MOB_MAP = {}
-
-
 def _get_neighbouring_pairs(iterable):
     return list(adjacent_pairs(iterable))[:-1]
 
 
-class _TexSVG(SVGMobject):
-    CONFIG = {
-        "color": BLACK,
-        "stroke_width": 0,
-        "height": None,
-        "path_string_config": {
-            "should_subdivide_sharp_curves": True,
-            "should_remove_null_curves": True,
-        },
-    }
-
-
 class _TexParser(object):
     def __init__(self, tex_string, additional_substrings):
         self.tex_string = tex_string
@@ -400,10 +385,21 @@ def get_isolated_substrings(self):
         ])
 
 
-class MTex(VMobject):
+class _TexSVG(SVGMobject):
     CONFIG = {
+        "height": None,
         "fill_opacity": 1.0,
         "stroke_width": 0,
+        "path_string_config": {
+            "should_subdivide_sharp_curves": True,
+            "should_remove_null_curves": True,
+        },
+    }
+
+
+class MTex(_TexSVG):
+    CONFIG = {
+        "color": WHITE,
         "font_size": 48,
         "alignment": "\\centering",
         "tex_environment": "align*",
@@ -413,65 +409,49 @@ class MTex(VMobject):
     }
 
     def __init__(self, tex_string, **kwargs):
-        super().__init__(**kwargs)
+        digest_config(self, kwargs)
         tex_string = tex_string.strip()
         # Prevent from passing an empty string.
         if not tex_string:
             tex_string = "\\quad"
         self.tex_string = tex_string
-
-        self.__parser = _TexParser(
+        self.parser = _TexParser(
             self.tex_string,
             [*self.tex_to_color_map.keys(), *self.isolate]
         )
-        mob = self.generate_mobject()
-        self.add(*mob.copy())
-        self.init_colors()
+        super().__init__(**kwargs)
+
         self.set_color_by_tex_to_color_map(self.tex_to_color_map)
         self.scale(SCALE_FACTOR_PER_FONT_POINT * self.font_size)
 
-    @staticmethod
-    def color_to_label(color):
-        r, g, b = color_to_int_rgb(color)
-        rg = r * 256 + g
-        return rg * 256 + b
-
-    def generate_mobject(self):
-        labelled_tex_string = self.__parser.get_labelled_tex_string()
-        labelled_tex_content = self.get_tex_file_content(labelled_tex_string)
-        hash_val = hash((labelled_tex_content, self.use_plain_tex))
+    @property
+    def hash_seed(self):
+        return (
+            self.__class__.__name__,
+            self.svg_default,
+            self.path_string_config,
+            self.tex_string,
+            self.parser.specified_substrings,
+            self.alignment,
+            self.tex_environment,
+            self.use_plain_tex
+        )
 
-        if hash_val in TEX_HASH_TO_MOB_MAP:
-            return TEX_HASH_TO_MOB_MAP[hash_val]
+    def get_file_path(self):
+        return self._get_file_path(self.use_plain_tex)
 
-        if not self.use_plain_tex:
-            with display_during_execution(f"Writing \"{self.tex_string}\""):
-                labelled_svg_glyphs = self.tex_content_to_glyphs(
-                    labelled_tex_content
-                )
-                glyph_labels = [
-                    self.color_to_label(labelled_glyph.get_fill_color())
-                    for labelled_glyph in labelled_svg_glyphs
-                ]
-                mob = self.build_mobject(labelled_svg_glyphs, glyph_labels)
-            TEX_HASH_TO_MOB_MAP[hash_val] = mob
-            return mob
+    def _get_file_path(self, use_plain_tex):
+        if use_plain_tex:
+            tex_string = self.tex_string
+        else:
+            tex_string = self.parser.get_labelled_tex_string()
 
+        full_tex = self.get_tex_file_body(tex_string)
         with display_during_execution(f"Writing \"{self.tex_string}\""):
-            labelled_svg_glyphs = self.tex_content_to_glyphs(
-                labelled_tex_content
-            )
-            tex_content = self.get_tex_file_content(self.tex_string)
-            svg_glyphs = self.tex_content_to_glyphs(tex_content)
-            glyph_labels = [
-                self.color_to_label(labelled_glyph.get_fill_color())
-                for labelled_glyph in labelled_svg_glyphs
-            ]
-            mob = self.build_mobject(svg_glyphs, glyph_labels)
-        TEX_HASH_TO_MOB_MAP[hash_val] = mob
-        return mob
+            file_path = self.tex_to_svg_file_path(full_tex)
+        return file_path
 
-    def get_tex_file_content(self, tex_string):
+    def get_tex_file_body(self, tex_string):
         if self.tex_environment:
             tex_string = "\n".join([
                 f"\\begin{{{self.tex_environment}}}",
@@ -480,17 +460,38 @@ def get_tex_file_content(self, tex_string):
             ])
         if self.alignment:
             tex_string = "\n".join([self.alignment, tex_string])
-        return tex_string
-
-    @staticmethod
-    def tex_content_to_glyphs(tex_content):
+        
         tex_config = get_tex_config()
-        full_tex = tex_config["tex_body"].replace(
+        return tex_config["tex_body"].replace(
             tex_config["text_to_replace"],
-            tex_content
+            tex_string
         )
-        filename = tex_to_svg_file(full_tex)
-        return _TexSVG(filename)
+
+    @staticmethod
+    def tex_to_svg_file_path(tex_file_content):
+        return tex_to_svg_file(tex_file_content)
+
+    def generate_mobject(self):
+        super().generate_mobject()
+
+        if not self.use_plain_tex:
+            labelled_svg_glyphs = self
+        else:
+            file_path = self._get_file_path(use_plain_tex=False)
+            labelled_svg_glyphs = _TexSVG(file_path)
+
+        glyph_labels = [
+            self.color_to_label(labelled_glyph.get_fill_color())
+            for labelled_glyph in labelled_svg_glyphs
+        ]
+        mob = self.build_mobject(self, glyph_labels)
+        self.set_submobjects(mob.submobjects)
+
+    @staticmethod
+    def color_to_label(color):
+        r, g, b = color_to_int_rgb(color)
+        rg = r * 256 + g
+        return rg * 256 + b
 
     def build_mobject(self, svg_glyphs, glyph_labels):
         if not svg_glyphs:
@@ -514,11 +515,11 @@ def build_mobject(self, svg_glyphs, glyph_labels):
         submob_labels.append(current_glyph_label)
         submobjects.append(submobject)
 
-        indices = self.__parser.get_sorted_submob_indices(submob_labels)
+        indices = self.parser.get_sorted_submob_indices(submob_labels)
         rearranged_submobjects = [submobjects[index] for index in indices]
         rearranged_labels = [submob_labels[index] for index in indices]
 
-        submob_tex_strings = self.__parser.get_submob_tex_strings(
+        submob_tex_strings = self.parser.get_submob_tex_strings(
             rearranged_labels
         )
         for submob, label, submob_tex in zip(
@@ -531,14 +532,14 @@ def build_mobject(self, svg_glyphs, glyph_labels):
         return VGroup(*rearranged_submobjects)
 
     def get_part_by_tex_spans(self, tex_spans):
-        labels = self.__parser.get_containing_labels_by_tex_spans(tex_spans)
+        labels = self.parser.get_containing_labels_by_tex_spans(tex_spans)
         return VGroup(*filter(
             lambda submob: submob.submob_label in labels,
             self.submobjects
         ))
 
     def get_part_by_custom_span(self, custom_span):
-        tex_spans = self.__parser.find_span_components_of_custom_span(
+        tex_spans = self.parser.find_span_components_of_custom_span(
             custom_span
         )
         if tex_spans is None:
@@ -590,10 +591,10 @@ def get_submob_tex(self):
         ]
 
     def get_specified_substrings(self):
-        return self.__parser.get_specified_substrings()
+        return self.parser.get_specified_substrings()
 
     def get_isolated_substrings(self):
-        return self.__parser.get_isolated_substrings()
+        return self.parser.get_isolated_substrings()
 
 
 class MTexText(MTex):