diff --git a/manimlib/mobject/svg/mtex_mobject.py b/manimlib/mobject/svg/mtex_mobject.py index 1a71783d..a14004e7 100644 --- a/manimlib/mobject/svg/mtex_mobject.py +++ b/manimlib/mobject/svg/mtex_mobject.py @@ -6,7 +6,7 @@ import itertools as it from types import MethodType from typing import Iterable, Union, Sequence -from manimlib.constants import WHITE +from manimlib.constants import BLACK, WHITE from manimlib.mobject.svg.svg_mobject import SVGMobject from manimlib.mobject.types.vectorized_mobject import VGroup from manimlib.utils.color import color_to_int_rgb @@ -32,6 +32,9 @@ SCALE_FACTOR_PER_FONT_POINT = 0.001 class _TexSVG(SVGMobject): CONFIG = { "height": None, + "svg_default": { + "fill_color": BLACK, + }, "stroke_width": 0, "stroke_color": WHITE, "path_string_config": { @@ -80,25 +83,11 @@ class MTex(_TexSVG): self.use_plain_tex ) - def get_file_path(self) -> str: - self.init_parser() - self.use_plain_file = any([ - self.use_plain_tex, - self.color_cmd_repl_items, - self.base_color != WHITE - ]) - return self.get_file_path_(use_plain_file=self.use_plain_file) - - def get_file_path_(self, use_plain_file: bool) -> str: + def get_file_path(self, use_plain_file: bool = False) -> str: if use_plain_file: - content = "".join([ - "{{", - self.get_color_command(self.color_to_int(self.base_color)), - self.string, - "}}" - ]) + content = self.plain_string else: - content = self.get_labelled_string() + content = self.labelled_string full_tex = self.get_tex_file_body(content) with display_during_execution(f"Writing \"{self.string}\""): @@ -128,27 +117,26 @@ class MTex(_TexSVG): def generate_mobject(self) -> None: super().generate_mobject() - glyphs = self.submobjects - if not glyphs: + if not self.submobjects: return - if self.use_plain_file: - file_path = self.get_file_path_(use_plain_file=False) - labelled_svg_glyphs = _TexSVG(file_path) - predefined_colors = [ - labelled_glyph.get_fill_color() - for labelled_glyph in self.submobjects - ] - else: - labelled_svg_glyphs = self - predefined_colors = [self.base_color] * len(glyphs) - glyph_labels = [ - self.color_to_label(labelled_glyph.get_fill_color()) - for labelled_glyph in labelled_svg_glyphs + self.color_to_label(glyph.get_fill_color()) + for glyph in self.submobjects ] - for glyph, glyph_color in zip(glyphs, predefined_colors): - glyph.set_fill(glyph_color) + + if any([ + self.use_plain_tex, + self.color_cmd_repl_items, + self.base_color in (BLACK, WHITE) + ]): + file_path = self.get_file_path(use_plain_file=True) + glyphs = _TexSVG(file_path).submobjects + for glyph, plain_glyph in zip(self.submobjects, glyphs): + glyph.set_fill(plain_glyph.get_fill_color()) + else: + glyphs = self.submobjects + self.set_fill(self.base_color) # Simply pack together adjacent mobjects with the same label. submob_labels, glyphs_lists = self.group_neighbours( @@ -171,20 +159,18 @@ class MTex(_TexSVG): ## Static methods @staticmethod - def color_to_int(color: ManimColor) -> int: + def color_to_label(color: ManimColor) -> int: r, g, b = color_to_int_rgb(color) rg = r * 256 + g - return rg * 256 + b - - @staticmethod - def color_to_label(color: ManimColor) -> int: - result = MTex.color_to_int(color) - if result == 16777215: # white + rgb = rg * 256 + b + if rgb == 16777215: # white return -1 - return result + return rgb @staticmethod def get_color_command(label: int) -> str: + if label == -1: + label = 16777215 # white rg, b = divmod(label, 256) r, g = divmod(rg, 256) return "".join([ @@ -223,40 +209,83 @@ class MTex(_TexSVG): groups.append(new_group) return group_labels, groups + @staticmethod + def find_region_index(val: int, seq: list[int]) -> int: + # Returns an integer in `range(len(seq) + 1)` satisfying + # `seq[result - 1] <= val < seq[result]` + if not seq: + return 0 + if val >= seq[-1]: + return len(seq) + result = 0 + while val >= seq[result]: + result += 1 + return result + + @staticmethod + def lstrip(index: int, skipped_spans: list[tuple[int, int]]) -> int: + index_seq = list(it.chain(*skipped_spans)) + region_index = MTex.find_region_index(index, index_seq) + if region_index % 2 == 1: + return index_seq[region_index] + return index + + @staticmethod + def rstrip(index: int, skipped_spans: list[tuple[int, int]]) -> int: + index_seq = list(it.chain(*skipped_spans)) + region_index = MTex.find_region_index(index - 1, index_seq) + if region_index % 2 == 1: + return index_seq[region_index - 1] + return index + + @staticmethod + def strip( + tex_span: tuple[int, int], skipped_spans: list[tuple[int, int]] + ) -> tuple[int, int] | None: + result = ( + MTex.lstrip(tex_span[0], skipped_spans), + MTex.rstrip(tex_span[1], skipped_spans) + ) + if result[0] >= result[1]: + return None + return result + + @staticmethod + def lslide(index: int, slid_spans: list[tuple[int, int]]) -> int: + slide_dict = dict(slid_spans) + while index in slide_dict.keys(): + index = slide_dict[index] + return index + + @staticmethod + def rslide(index: int, slid_spans: list[tuple[int, int]]) -> int: + slide_dict = dict([ + slide_span[::-1] for slide_span in slid_spans + ]) + while index in slide_dict.keys(): + index = slide_dict[index] + return index + + @staticmethod + def slide( + tex_span: tuple[int, int], slid_spans: list[tuple[int, int]] + ) -> tuple[int, int] | None: + result = ( + MTex.lslide(tex_span[0], slid_spans), + MTex.rslide(tex_span[1], slid_spans) + ) + if result[0] >= result[1]: + return None + return result + ## Parser - def init_parser(self) -> None: - self.additional_substrings = self.get_additional_substrings() - self.full_span = self.get_full_span() - self.backslash_indices = self.get_backslash_indices() - self.left_brace_indices, self.right_brace_indices = \ - self.get_left_and_right_indices() - self.script_char_spans = self.get_script_char_spans() - self.skipped_indices = self.get_skipped_indices() - self.script_spans = self.get_script_spans() - self.script_content_spans = self.get_script_content_spans() - self.double_braces_spans = self.get_double_braces_spans() - self.stripped_substrings = self.get_stripped_substrings() - self.specified_substrings = self.get_specified_substrings() - self.specified_spans, self.extended_specified_spans = \ - self.get_specified_spans() - self.tex_span_list = self.get_tex_span_list() - self.extended_tex_span_list = self.get_extended_tex_span_list() - self.isolated_substrings = self.get_isolated_substrings() - self.containing_labels_dict = self.get_containing_labels_dict() - self.color_cmd_repl_items = self.get_color_cmd_repl_items() - self.span_repl_dict = self.get_span_repl_dict() - - def get_additional_substrings(self) -> list[str]: - return list(it.chain( - self.tex_to_color_map.keys(), - self.isolate - )) - - def get_full_span(self) -> tuple[int, int]: + @property + def full_span(self) -> tuple[int, int]: return (0, len(self.string)) - def get_backslash_indices(self) -> list[int]: + @property + def backslash_indices(self) -> list[int]: # Newlines (`\\`) don't count. return [ match_obj.end() - 1 @@ -264,7 +293,9 @@ class MTex(_TexSVG): if len(match_obj.group()) % 2 == 1 ] - def get_left_and_right_indices(self) -> list[tuple[int, int]]: + def get_left_and_right_brace_indices( + self + ) -> tuple[list[tuple[int, int]], list[tuple[int, int]]]: string = self.string indices = list(filter( lambda index: index - 1 not in self.backslash_indices, @@ -287,60 +318,69 @@ class MTex(_TexSVG): right_brace_indices.append(index) if left_brace_indices_stack: raise ValueError("Missing '}' inserted") + # `right_brace_indices` is already sorted. return left_brace_indices, right_brace_indices - def get_script_char_spans(self) -> list[tuple[int, int]]: + @property + def left_brace_indices(self) -> list[tuple[int, int]]: + return self.get_left_and_right_brace_indices()[0] + + @property + def right_brace_indices(self) -> list[tuple[int, int]]: + return self.get_left_and_right_brace_indices()[1] + + @property + def skipped_spans(self) -> list[tuple[int, int]]: return [ match_obj.span() - for match_obj in re.finditer(r"(\s*)[_^]\s*", self.string) - if match_obj.group(1) - or match_obj.start() - 1 not in self.backslash_indices + for match_obj in re.finditer(r"\s*([_^])\s*|(\s+)", self.string) + if match_obj.group(2) is not None + or match_obj.start(1) - 1 not in self.backslash_indices ] - def get_skipped_indices(self) -> list[int]: - return sorted(remove_list_redundancies([ - match_obj.start() - for match_obj in re.finditer(r"\s", self.string) - ] + list(it.chain(*[ - range(*script_char_span) - for script_char_span in self.script_char_spans - ])))) + def lstrip_span(self, index: int) -> int: + return self.lstrip(index, self.skipped_spans) - def get_script_spans(self) -> list[tuple[int, int]]: - string = self.string + def rstrip_span(self, index: int) -> int: + return self.rstrip(index, self.skipped_spans) + + def strip_span(self, index: int) -> int: + return self.strip(index, self.skipped_spans) + + @property + def script_char_spans(self) -> list[tuple[int, int]]: + return list(filter( + lambda tex_span: self.string[slice(*tex_span)].strip(), + self.skipped_spans + )) + + @property + def script_content_spans(self) -> list[tuple[int, int]]: result = [] brace_indices_dict = dict(zip( self.left_brace_indices, self.right_brace_indices )) - for char_begin, span_begin in self.script_char_spans: + for _, span_begin in self.script_char_spans: if span_begin in brace_indices_dict.keys(): span_end = brace_indices_dict[span_begin] + 1 else: pattern = re.compile(r"[a-zA-Z0-9]|\\[a-zA-Z]+") - match_obj = pattern.match(string, pos=span_begin) + match_obj = pattern.match(self.string, pos=span_begin) if not match_obj: script_name = { "_": "subscript", "^": "superscript" }[script_char] - log.warning( + raise ValueError( f"Unclear {script_name} detected while parsing. " "Please use braces to clarify" ) - continue span_end = match_obj.end() - result.append((char_begin, span_end)) + result.append((span_begin, span_end)) return result - def get_script_content_spans(self) -> list[tuple[int, int]]: - return [ - (script_char_span[1], script_span[1]) - for script_char_span, script_span in zip( - self.script_char_spans, self.script_spans - ) - ] - - def get_double_braces_spans(self) -> list[tuple[int, int]]: + @property + def double_braces_spans(self) -> list[tuple[int, int]]: # Match paired double braces (`{{...}}`). result = [] reversed_brace_indices_dict = dict(zip( @@ -348,7 +388,7 @@ class MTex(_TexSVG): )) skip = False for prev_right_index, right_index in self.get_neighbouring_pairs( - sorted(reversed_brace_indices_dict.keys()) + self.right_brace_indices ): if skip: skip = False @@ -363,74 +403,64 @@ class MTex(_TexSVG): skip = True return result - def get_stripped_substrings(self) -> list[str]: - result = remove_list_redundancies([ - substr.strip() - for substr in self.additional_substrings - ]) + @property + def additional_substrings(self) -> list[str]: + result = remove_list_redundancies(list(it.chain( + self.tex_to_color_map.keys(), + self.isolate + ))) if "" in result: result.remove("") return result - def get_specified_substrings(self) -> list[str]: - return remove_list_redundancies([ - self.string[slice(*double_braces_span)] - for double_braces_span in self.double_braces_spans - ] + list(filter( - lambda s: s in self.string, - self.stripped_substrings - ))) - - def get_specified_spans( + def get_tex_span_lists( self ) -> tuple[list[tuple[int, int]], list[tuple[int, int]]]: - tex_spans = sorted(remove_list_redundancies([ - self.full_span, - *self.double_braces_spans, - *[ - match_obj.span() - for substr in self.stripped_substrings - for match_obj in re.finditer(re.escape(substr), self.string) - ] - ]), key=lambda t: (t[0], -t[1])) result = [] extended_result = [] - script_spans_dict = dict(self.script_spans) - reversed_script_spans_dict = dict([ - script_span[::-1] for script_span in self.script_spans + script_content_spans = self.script_content_spans + script_spans = [ + (script_char_span[0], script_content_span[1]) + for script_char_span, script_content_span in zip( + self.script_char_spans, script_content_spans + ) + ] + tex_spans = remove_list_redundancies([ + self.full_span, + *self.double_braces_spans, + *filter(lambda stripped_span: stripped_span is not None, [ + self.strip_span(match_obj.span()) + for substr in self.additional_substrings + for match_obj in re.finditer(re.escape(substr), self.string) + ]), + *script_content_spans ]) for tex_span in tex_spans: - if tex_span in self.script_content_spans: + if tex_span in script_content_spans: + result.append(tex_span) + extended_result.append(tex_span) continue span_begin, span_end = tex_span - extended_span_end = span_end - while span_end in reversed_script_spans_dict.keys(): - span_end = reversed_script_spans_dict[span_end] - while extended_span_end in script_spans_dict.keys(): - extended_span_end = script_spans_dict[extended_span_end] - specified_span = (span_begin, span_end) - extended_specified_span = (span_begin, extended_span_end) - if span_begin >= span_end: + shrinked_span = (span_begin, self.rslide(span_end, script_spans)) + extended_span = (span_begin, self.lslide(span_end, script_spans)) + if shrinked_span[0] >= shrinked_span[1]: continue - if extended_specified_span in result: + if shrinked_span in result: continue - result.append(specified_span) - extended_result.append(extended_specified_span) + result.append(shrinked_span) + extended_result.append(extended_span) return result, extended_result - def get_tex_span_list(self) -> list[tuple[int, int]]: - return self.specified_spans + self.script_content_spans + @property + def tex_span_list(self) -> list[tuple[int, int]]: + return self.get_tex_span_lists()[0] - def get_extended_tex_span_list(self) -> list[tuple[int, int]]: - return self.extended_specified_spans + self.script_content_spans + @property + def extended_tex_span_list(self) -> list[tuple[int, int]]: + return self.get_tex_span_lists()[1] - def get_isolated_substrings(self) -> list[str]: - return remove_list_redundancies([ - self.string[slice(*tex_span)] - for tex_span in self.tex_span_list - ]) - - def get_containing_labels_dict(self) -> dict[tuple[int, int], list[int]]: + @property + def containing_labels_dict(self) -> dict[tuple[int, int], list[int]]: tex_span_list = self.tex_span_list result = { tex_span: [] @@ -449,40 +479,46 @@ class MTex(_TexSVG): "Partially overlapping substrings detected: " f"'{string_0}' and '{string_1}'" ) - result[self.full_span] = list(range(len(tex_span_list))) + result[self.full_span] = list(range(-1, len(tex_span_list))) return result - def get_color_cmd_repl_items(self) -> list[tuple[tuple[int, int], str]]: - color_related_command_items = [ - ("color", 1, ""), - ("textcolor", 1, ""), - ("pagecolor", 1, "\\pagecolor{white}"), - ("colorbox", 1, "\\colorbox{white}"), - ("fcolorbox", 2, "\\fcolorbox{white}{white}"), - ] + @property + def color_cmd_repl_items(self) -> list[tuple[tuple[int, int], str]]: + color_related_command_dict = { + "color": (1, False), + "textcolor": (1, False), + "pagecolor": (1, True), + "colorbox": (1, True), + "fcolorbox": (2, True), + } result = [] - string = self.string backslash_indices = self.backslash_indices - left_indices = self.left_brace_indices - brace_indices_dict = dict(zip( - self.left_brace_indices, self.right_brace_indices - )) - for cmd_name, n_braces, repl_str in color_related_command_items: - pattern = cmd_name + r"(?![a-zA-Z])" - for match_obj in re.finditer(pattern, string): - span_begin, span_end = match_obj.span() - span_begin -= 1 - if span_begin not in backslash_indices: - continue - for _ in range(n_braces): - left_index = min(filter( - lambda index: index >= span_end, left_indices - )) - span_end = brace_indices_dict[left_index] + 1 - result.append(((span_begin, span_end), repl_str)) + right_brace_indices = self.right_brace_indices + pattern = "".join([ + r"\\", + "(", + "|".join(color_related_command_dict.keys()), + ")", + r"(?![a-zA-Z])" + ]) + for match_obj in re.finditer(pattern, self.string): + span_begin, cmd_end = match_obj.span() + if span_begin not in backslash_indices: + continue + cmd_name = match_obj.group(1) + n_braces, substitute_cmd = color_related_command_dict[cmd_name] + span_end = right_brace_indices[self.find_region_index( + cmd_end, right_brace_indices + ) + n_braces - 1] + 1 + if substitute_cmd: + repl_str = "\\" + cmd_name + n_braces * "{white}" + else: + repl_str = "" + result.append(((span_begin, span_end), repl_str)) return result - def get_span_repl_dict(self) -> dict[tuple[int, int], str]: + @property + def span_repl_dict(self) -> dict[tuple[int, int], str]: indices, _, _, cmd_strings = zip(*sorted([ ( tex_span[flag], @@ -490,7 +526,7 @@ class MTex(_TexSVG): -tex_span[1 - flag], ("{{" + self.get_color_command(label), "}}")[flag] ) - for label, tex_span in enumerate(self.tex_span_list) + for label, tex_span in enumerate(self.extended_tex_span_list) for flag in range(2) ])) result = { @@ -502,7 +538,17 @@ class MTex(_TexSVG): result.update(self.color_cmd_repl_items) return result - def get_labelled_string(self) -> str: + @property + def plain_string(self) -> str: + return "".join([ + "{{", + self.get_color_command(self.color_to_label(self.base_color)), + self.string, + "}}" + ]) + + @property + def labelled_string(self) -> str: if not self.span_repl_dict: return self.string @@ -545,7 +591,6 @@ class MTex(_TexSVG): ordered_containing_labels[1:], ordered_span_begins[1:] ) ] - string_span_begins.insert(0, ordered_span_begins[0]) string_span_ends = [ next_begin if next_label in containing_labels else curr_end for next_begin, next_label, containing_labels, curr_end in zip( @@ -553,49 +598,72 @@ class MTex(_TexSVG): ordered_containing_labels[:-1], ordered_span_ends[:-1] ) ] - string_span_ends.append(ordered_span_ends[-1]) + string_spans = list(zip( + (ordered_span_begins[0], *string_span_begins), + (*string_span_ends, ordered_span_ends[-1]) + )) string = self.string - left_indices = self.left_brace_indices - right_indices = self.right_brace_indices - skipped_indices = sorted(it.chain( - self.skipped_indices, - left_indices, - right_indices - )) + left_brace_indices = self.left_brace_indices + right_brace_indices = self.right_brace_indices + slid_spans = self.skipped_spans + [ + (index, index + 1) + for index in left_brace_indices + right_brace_indices + ] result = [] - for span_begin, span_end in zip(string_span_begins, string_span_ends): - while span_begin in skipped_indices: - span_begin += 1 - if span_begin >= span_end: - result.append("") + for str_span in string_spans: + str_span = self.strip_span(str_span) + if str_span is None: continue - while span_end - 1 in skipped_indices: - span_end -= 1 - unclosed_left_brace = 0 - unclosed_right_brace = 0 - for index in range(span_begin, span_end): - if index in left_indices: - unclosed_left_brace += 1 - elif index in right_indices: - if unclosed_left_brace == 0: - unclosed_right_brace += 1 + str_span = self.slide(str_span, slid_spans) + if str_span is None: + continue + unclosed_left_braces = 0 + unclosed_right_braces = 0 + for index in range(*str_span): + if index in left_brace_indices: + unclosed_left_braces += 1 + elif index in right_brace_indices: + if unclosed_left_braces == 0: + unclosed_right_braces += 1 else: - unclosed_left_brace -= 1 + unclosed_left_braces -= 1 result.append("".join([ - unclosed_right_brace * "{", - string[span_begin:span_end], - unclosed_left_brace * "}" + unclosed_right_braces * "{", + string[slice(*str_span)], + unclosed_left_braces * "}" ])) return result + @property + def specified_substrings(self) -> list[str]: + return remove_list_redundancies([ + self.string[slice(*double_braces_span)] + for double_braces_span in self.double_braces_spans + ] + list(filter( + lambda s: s in self.string, + self.additional_substrings + ))) + + def get_specified_substrings(self) -> list[str]: + return self.specified_substrings + + @property + def isolated_substrings(self) -> list[str]: + return remove_list_redundancies([ + self.string[slice(*tex_span)] + for tex_span in self.tex_span_list + ]) + + def get_isolated_substrings(self) -> list[str]: + return self.isolated_substrings + ## Selector def find_span_components_of_custom_span( self, custom_span: tuple[int, int] ) -> list[tuple[int, int]] | None: - skipped_indices = self.skipped_indices tex_span_choices = sorted(filter( lambda tex_span: all([ tex_span[0] >= custom_span[0], @@ -606,13 +674,13 @@ class MTex(_TexSVG): # Choose spans that reach the farthest. tex_span_choices_dict = dict(tex_span_choices) - span_begin, span_end = custom_span result = [] + span_begin, span_end = custom_span + span_begin = self.rstrip_span(span_begin) + span_end = self.rstrip_span(span_end) while span_begin != span_end: + span_begin = self.lstrip_span(span_begin) if span_begin not in tex_span_choices_dict.keys(): - if span_begin in skipped_indices: - span_begin += 1 - continue return None next_begin = tex_span_choices_dict[span_begin] result.append((span_begin, next_begin)) @@ -640,7 +708,7 @@ class MTex(_TexSVG): return VGroup(*[ self.get_part_by_custom_span(match_obj.span()) for match_obj in re.finditer( - re.escape(tex.strip()), self.string + re.escape(tex), self.string ) ])