Rewrite MathTex to make it more robust regarding splitting

docs/source/guides/using_text.rst

@@ -424,7 +424,7 @@ may be expected. To color only ``x`` yellow, we have to do the following:
     class CorrectLaTeXSubstringColoring(Scene):
         def construct(self):
             equation = MathTex(
-                r"e^x = x^0 + x^1 + \frac{1}{2} x^2 + \frac{1}{6} x^3 + \cdots + \frac{1}{n!} x^n + \cdots",
+                r"e^{x} = x^0 + x^1 + \frac{1}{2} x^2 + \frac{1}{6} x^3 + \cdots + \frac{1}{n!} x^n + \cdots",
                 substrings_to_isolate="x"
             )
             equation.set_color_by_tex("x", YELLOW)
@@ -434,6 +434,8 @@ By setting ``substrings_to_isolate`` to ``x``, we split up the
 :class:`~.MathTex` into substrings automatically and isolate the ``x`` components
 into individual substrings. Only then can :meth:`~.set_color_by_tex` be used
 to achieve the desired result.
+If one of the ``substrings_to_isolate`` is in a sub or superscript, it needs
+to be enclosed by curly brackets.
 
 Note that Manim also supports a custom syntax that allows splitting
 a TeX string into substrings easily: simply enclose parts of your formula

manim/mobject/svg/svg_mobject.py

@@ -21,12 +21,12 @@
 from ..geometry.line import Line
 from ..geometry.polygram import Polygon, Rectangle, RoundedRectangle
 from ..opengl.opengl_compatibility import ConvertToOpenGL
-from ..types.vectorized_mobject import VMobject
+from ..types.vectorized_mobject import VGroup, VMobject
 
 __all__ = ["SVGMobject", "VMobjectFromSVGPath"]
 
 
-SVG_HASH_TO_MOB_MAP: dict[int, VMobject] = {}
+SVG_HASH_TO_MOB_MAP: dict[int, SVGMobject] = {}
 
 
 def _convert_point_to_3d(x: float, y: float) -> np.ndarray:
@@ -127,6 +127,7 @@ def __init__(
         self.stroke_color = stroke_color
         self.stroke_opacity = stroke_opacity  # type: ignore[assignment]
         self.stroke_width = stroke_width  # type: ignore[assignment]
+        self.id_to_vgroup_dict: dict[str, VGroup] = {}
         if self.stroke_width is None:
             self.stroke_width = 0
 
@@ -170,6 +171,7 @@ def init_svg_mobject(self, use_svg_cache: bool) -> None:
             if hash_val in SVG_HASH_TO_MOB_MAP:
                 mob = SVG_HASH_TO_MOB_MAP[hash_val].copy()
                 self.add(*mob)
+                self.id_to_vgroup_dict = mob.id_to_vgroup_dict
                 return
 
         self.generate_mobject()
@@ -203,8 +205,9 @@ def generate_mobject(self) -> None:
         svg = se.SVG.parse(modified_file_path)
         modified_file_path.unlink()
 
-        mobjects = self.get_mobjects_from(svg)
+        mobjects, mobject_dict = self.get_mobjects_from(svg)
         self.add(*mobjects)
+        self.id_to_vgroup_dict = mobject_dict
         self.flip(RIGHT)  # Flip y
 
     def get_file_path(self) -> Path:
@@ -258,7 +261,9 @@ def generate_config_style_dict(self) -> dict[str, str]:
                 result[svg_key] = str(svg_default_dict[style_key])
         return result
 
-    def get_mobjects_from(self, svg: se.SVG) -> list[VMobject]:
+    def get_mobjects_from(
+        self, svg: se.SVG
+    ) -> tuple[list[VMobject], dict[str, VGroup]]:
         """Convert the elements of the SVG to a list of mobjects.
 
         Parameters
@@ -267,36 +272,77 @@ def get_mobjects_from(self, svg: se.SVG) -> list[VMobject]:
             The parsed SVG file.
         """
         result: list[VMobject] = []
-        for shape in svg.elements():
-            # can we combine the two continue cases into one?
-            if isinstance(shape, se.Group):  # noqa: SIM114
-                continue
-            elif isinstance(shape, se.Path):
-                mob: VMobject = self.path_to_mobject(shape)
-            elif isinstance(shape, se.SimpleLine):
-                mob = self.line_to_mobject(shape)
-            elif isinstance(shape, se.Rect):
-                mob = self.rect_to_mobject(shape)
-            elif isinstance(shape, (se.Circle, se.Ellipse)):
-                mob = self.ellipse_to_mobject(shape)
-            elif isinstance(shape, se.Polygon):
-                mob = self.polygon_to_mobject(shape)
-            elif isinstance(shape, se.Polyline):
-                mob = self.polyline_to_mobject(shape)
-            elif isinstance(shape, se.Text):
-                mob = self.text_to_mobject(shape)
-            elif isinstance(shape, se.Use) or type(shape) is se.SVGElement:
-                continue
-            else:
-                logger.warning(f"Unsupported element type: {type(shape)}")
-                continue
-            if mob is None or not mob.has_points():
-                continue
-            self.apply_style_to_mobject(mob, shape)
-            if isinstance(shape, se.Transformable) and shape.apply:
-                self.handle_transform(mob, shape.transform)
-            result.append(mob)
-        return result
+        stack: list[tuple[se.SVGElement, int]] = []
+        stack.append((svg, 1))
+        group_id_number = 0
+        vgroup_stack: list[str] = ["root"]
+        vgroup_names: list[str] = ["root"]
+        vgroups: dict[str, VGroup] = {"root": VGroup()}
+        while len(stack) > 0:
+            element, depth = stack.pop()
+            # Reduce stack heights
+            vgroup_stack = vgroup_stack[0:(depth)]
+            try:
+                group_name = str(element.values["id"])
+            except Exception:
+                group_name = f"numbered_group_{group_id_number}"
+                group_id_number += 1
+            vg = VGroup()
+            vgroup_names.append(group_name)
+            vgroup_stack.append(group_name)
+            vgroups[group_name] = vg
+
+            if isinstance(element, (se.Group, se.Use)):
+                stack.extend((subelement, depth + 1) for subelement in element[::-1])
+            # Add element to the parent vgroup
+            try:
+                if isinstance(
+                    element,
+                    (
+                        se.Path,
+                        se.SimpleLine,
+                        se.Rect,
+                        se.Circle,
+                        se.Ellipse,
+                        se.Polygon,
+                        se.Polyline,
+                        se.Text,
+                    ),
+                ):
+                    mob = self.get_mob_from_shape_element(element)
+                    if mob is not None:
+                        result.append(mob)
+                        for parent_name in vgroup_stack[:-1]:
+                            vgroups[parent_name].add(mob)
+            except Exception as e:
+                print(e)
+
+        return result, vgroups
+
+    def get_mob_from_shape_element(self, shape: se.SVGElement) -> VMobject | None:
+        if isinstance(shape, se.Path):
+            mob: VMobject | None = self.path_to_mobject(shape)
+        elif isinstance(shape, se.SimpleLine):
+            mob = self.line_to_mobject(shape)
+        elif isinstance(shape, se.Rect):
+            mob = self.rect_to_mobject(shape)
+        elif isinstance(shape, (se.Circle, se.Ellipse)):
+            mob = self.ellipse_to_mobject(shape)
+        elif isinstance(shape, se.Polygon):
+            mob = self.polygon_to_mobject(shape)
+        elif isinstance(shape, se.Polyline):
+            mob = self.polyline_to_mobject(shape)
+        elif isinstance(shape, se.Text):
+            mob = self.text_to_mobject(shape)
+        else:
+            logger.warning(f"Unsupported element type: {type(shape)}")
+            mob = None
+        if mob is None or not mob.has_points():
+            return mob
+        self.apply_style_to_mobject(mob, shape)
+        if isinstance(shape, se.Transformable) and shape.apply:
+            self.handle_transform(mob, shape.transform)
+        return mob
 
     @staticmethod
     def handle_transform(mob: VMobject, matrix: se.Matrix) -> VMobject:

manim/mobject/table.py

@@ -1078,11 +1078,11 @@ def construct(self):
                     [[0,30,45,60,90],
                     [90,60,45,30,0]],
                     col_labels=[
-                        MathTex(r"\frac{\sqrt{0}}{2}"),
-                        MathTex(r"\frac{\sqrt{1}}{2}"),
-                        MathTex(r"\frac{\sqrt{2}}{2}"),
-                        MathTex(r"\frac{\sqrt{3}}{2}"),
-                        MathTex(r"\frac{\sqrt{4}}{2}")],
+                        MathTex(r"\frac{ \sqrt{0} }{2}"),
+                        MathTex(r"\frac{ \sqrt{1} }{2}"),
+                        MathTex(r"\frac{ \sqrt{2} }{2}"),
+                        MathTex(r"\frac{ \sqrt{3} }{2}"),
+                        MathTex(r"\frac{ \sqrt{4} }{2}")],
                     row_labels=[MathTex(r"\sin"), MathTex(r"\cos")],
                     h_buff=1,
                     element_to_mobject_config={"unit": r"^{\circ}"})