manim 0.18.0.post0__py3-none-any.whl → 0.19.0__py3-none-any.whl

manim/mobject/text/numbers.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 
 __all__ = ["DecimalNumber", "Integer", "Variable"]
 
-from typing import Sequence
+from collections.abc import Sequence
+from typing import Any
 
 import numpy as np
 
@@ -18,9 +19,11 @@ from manim.mobject.value_tracker import ValueTracker
 
 string_to_mob_map = {}
 
+__all__ = ["DecimalNumber", "Integer", "Variable"]
+
 
 class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
-    """An mobject representing a decimal number.
+    r"""An mobject representing a decimal number.
 
     Parameters
     ----------
@@ -208,10 +211,7 @@ class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
 
         rounded_num = np.round(number, self.num_decimal_places)
         if num_string.startswith("-") and rounded_num == 0:
-            if self.include_sign:
-                num_string = "+" + num_string[1:]
-            else:
-                num_string = num_string[1:]
+            num_string = "+" + num_string[1:] if self.include_sign else num_string[1:]
 
         return num_string
 
@@ -328,7 +328,9 @@ class Integer(DecimalNumber):
                 self.add(Integer(number=6.28).set_x(-1.5).set_y(-2).set_color(YELLOW).scale(1.4))
     """
 
-    def __init__(self, number=0, num_decimal_places=0, **kwargs):
+    def __init__(
+        self, number: float = 0, num_decimal_places: int = 0, **kwargs: Any
+    ) -> None:
         super().__init__(number=number, num_decimal_places=num_decimal_places, **kwargs)
 
     def get_value(self):

manim/mobject/text/tex_mobject.py

@@ -12,7 +12,7 @@ r"""Mobjects representing text rendered using LaTeX.
 
 from __future__ import annotations
 
-from manim.utils.color import ManimColor
+from manim.utils.color import BLACK, ManimColor, ParsableManimColor
 
 __all__ = [
     "SingleStringMathTex",
@@ -26,15 +26,15 @@ __all__ = [
 import itertools as it
 import operator as op
 import re
+from collections.abc import Iterable
 from functools import reduce
 from textwrap import dedent
-from typing import Iterable
 
 from manim import config, logger
 from manim.constants import *
 from manim.mobject.geometry.line import Line
 from manim.mobject.svg.svg_mobject import SVGMobject
-from manim.mobject.types.vectorized_mobject import VectorizedPoint, VGroup, VMobject
+from manim.mobject.types.vectorized_mobject import VGroup, VMobject
 from manim.utils.tex import TexTemplate
 from manim.utils.tex_file_writing import tex_to_svg_file
 
@@ -62,12 +62,11 @@ class SingleStringMathTex(SVGMobject):
         tex_environment: str = "align*",
         tex_template: TexTemplate | None = None,
         font_size: float = DEFAULT_FONT_SIZE,
+        color: ParsableManimColor | None = None,
         **kwargs,
     ):
-        if kwargs.get("color") is None:
-            # makes it so that color isn't explicitly passed for these mobs,
-            # and can instead inherit from the parent
-            kwargs["color"] = VMobject().color
+        if color is None:
+            color = VMobject().color
 
         self._font_size = font_size
         self.organize_left_to_right = organize_left_to_right
@@ -88,6 +87,7 @@ class SingleStringMathTex(SVGMobject):
             should_center=should_center,
             stroke_width=stroke_width,
             height=height,
+            color=color,
             path_string_config={
                 "should_subdivide_sharp_curves": True,
                 "should_remove_null_curves": True,
@@ -175,8 +175,8 @@ class SingleStringMathTex(SVGMobject):
         tex = self._remove_stray_braces(tex)
 
         for context in ["array"]:
-            begin_in = ("\\begin{%s}" % context) in tex
-            end_in = ("\\end{%s}" % context) in tex
+            begin_in = ("\\begin{%s}" % context) in tex  # noqa: UP031
+            end_in = ("\\end{%s}" % context) in tex  # noqa: UP031
             if begin_in ^ end_in:
                 # Just turn this into a blank string,
                 # which means caller should leave a
@@ -191,7 +191,6 @@ class SingleStringMathTex(SVGMobject):
         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("\\\\}")
@@ -211,10 +210,16 @@ class SingleStringMathTex(SVGMobject):
         return self.tex_string
 
     def init_colors(self, propagate_colors=True):
-        if config.renderer == RendererType.OPENGL:
-            super().init_colors()
-        elif config.renderer == RendererType.CAIRO:
-            super().init_colors(propagate_colors=propagate_colors)
+        for submobject in self.submobjects:
+            # needed to preserve original (non-black)
+            # TeX colors of individual submobjects
+            if submobject.color != BLACK:
+                continue
+            submobject.color = self.color
+            if config.renderer == RendererType.OPENGL:
+                submobject.init_colors()
+            elif config.renderer == RendererType.CAIRO:
+                submobject.init_colors(propagate_colors=propagate_colors)
 
 
 class MathTex(SingleStringMathTex):
@@ -427,6 +432,10 @@ class MathTex(SingleStringMathTex):
 class Tex(MathTex):
     r"""A string compiled with LaTeX in normal mode.
 
+    The color can be set using
+    the ``color`` argument. Any parts of the ``tex_string`` that are colored by the
+    TeX commands ``\color`` or ``\textcolor`` will retain their original color.
+
     Tests
     -----
 

manim/mobject/text/text_mobject.py

@@ -49,17 +49,18 @@ Examples
 
 from __future__ import annotations
 
+import functools
+
 __all__ = ["Text", "Paragraph", "MarkupText", "register_font"]
 
 
 import copy
 import hashlib
-import os
 import re
+from collections.abc import Iterable, Sequence
 from contextlib import contextmanager
 from itertools import chain
 from pathlib import Path
-from typing import Iterable, Sequence
 
 import manimpango
 import numpy as np
@@ -77,6 +78,8 @@ TEXT_MOB_SCALE_FACTOR = 0.05
 DEFAULT_LINE_SPACING_SCALE = 0.3
 TEXT2SVG_ADJUSTMENT_FACTOR = 4.8
 
+__all__ = ["Text", "Paragraph", "MarkupText", "register_font"]
+
 
 def remove_invisible_chars(mobject: SVGMobject) -> SVGMobject:
     """Function to remove unwanted invisible characters from some mobjects.
@@ -131,10 +134,17 @@ class Paragraph(VGroup):
     --------
     Normal usage::
 
-        paragraph = Paragraph('this is a awesome', 'paragraph',
-                              'With \nNewlines', '\tWith Tabs',
-                              '  With Spaces', 'With Alignments',
-                              'center', 'left', 'right')
+        paragraph = Paragraph(
+            "this is a awesome",
+            "paragraph",
+            "With \nNewlines",
+            "\tWith Tabs",
+            "  With Spaces",
+            "With Alignments",
+            "center",
+            "left",
+            "right",
+        )
 
     Remove unwanted invisible characters::
 
@@ -350,7 +360,7 @@ class Text(SVGMobject):
                )
                 text6.scale(1.3).shift(DOWN)
                 self.add(text1, text2, text3, text4, text5 , text6)
-                Group(*self.mobjects).arrange(DOWN, buff=.8).set_height(config.frame_height-LARGE_BUFF)
+                Group(*self.mobjects).arrange(DOWN, buff=.8).set(height=config.frame_height-LARGE_BUFF)
 
     .. manim:: TextMoreCustomization
             :save_last_frame:
@@ -407,6 +417,11 @@ class Text(SVGMobject):
 
     """
 
+    @staticmethod
+    @functools.cache
+    def font_list() -> list[str]:
+        return manimpango.list_fonts()
+
     def __init__(
         self,
         text: str,
@@ -431,13 +446,25 @@ class Text(SVGMobject):
         width: float = None,
         should_center: bool = True,
         disable_ligatures: bool = False,
+        use_svg_cache: bool = False,
         **kwargs,
     ) -> None:
         self.line_spacing = line_spacing
         if font and warn_missing_font:
-            fonts_list = manimpango.list_fonts()
+            fonts_list = Text.font_list()
+            # handle special case of sans/sans-serif
+            if font.lower() == "sans-serif":
+                font = "sans"
             if font not in fonts_list:
-                logger.warning(f"Font {font} not in {fonts_list}.")
+                # check if the capitalized version is in the supported fonts
+                if font.capitalize() in fonts_list:
+                    font = font.capitalize()
+                elif font.lower() in fonts_list:
+                    font = font.lower()
+                elif font.title() in fonts_list:
+                    font = font.title()
+                else:
+                    logger.warning(f"Font {font} not in {fonts_list}.")
         self.font = font
         self._font_size = float(font_size)
         # needs to be a float or else size is inflated when font_size = 24
@@ -491,7 +518,7 @@ class Text(SVGMobject):
             height=height,
             width=width,
             should_center=should_center,
-            use_svg_cache=False,
+            use_svg_cache=use_svg_cache,
             **kwargs,
         )
         self.text = text
@@ -636,7 +663,8 @@ class Text(SVGMobject):
     )
     def _set_color_by_t2g(self, t2g=None):
         """Sets gradient colors for specified
-        strings. Behaves similarly to ``set_color_by_t2c``."""
+        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.text):
@@ -675,7 +703,7 @@ class Text(SVGMobject):
             default = default_args[arg]
             if left != default and getattr(right_setting, arg) != default:
                 raise ValueError(
-                    f"Ambiguous style for text '{self.text[right_setting.start:right_setting.end]}':"
+                    f"Ambiguous style for text '{self.text[right_setting.start : right_setting.end]}':"
                     + f"'{arg}' cannot be both '{left}' and '{right}'."
                 )
             setattr(right_setting, arg, left if left != default else right)
@@ -886,7 +914,7 @@ class MarkupText(SVGMobject):
     Here is a list of supported tags:
 
     - ``<b>bold</b>``, ``<i>italic</i>`` and ``<b><i>bold+italic</i></b>``
-    - ``<ul>underline</ul>`` and ``<s>strike through</s>``
+    - ``<u>underline</u>`` 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>``
@@ -1133,6 +1161,11 @@ class MarkupText(SVGMobject):
 
     """
 
+    @staticmethod
+    @functools.cache
+    def font_list() -> list[str]:
+        return manimpango.list_fonts()
+
     def __init__(
         self,
         text: str,
@@ -1157,9 +1190,20 @@ class MarkupText(SVGMobject):
         self.text = text
         self.line_spacing = line_spacing
         if font and warn_missing_font:
-            fonts_list = manimpango.list_fonts()
+            fonts_list = Text.font_list()
+            # handle special case of sans/sans-serif
+            if font.lower() == "sans-serif":
+                font = "sans"
             if font not in fonts_list:
-                logger.warning(f"Font {font} not in {fonts_list}.")
+                # check if the capitalized version is in the supported fonts
+                if font.capitalize() in fonts_list:
+                    font = font.capitalize()
+                elif font.lower() in fonts_list:
+                    font = font.lower()
+                elif font.title() in fonts_list:
+                    font = font.title()
+                else:
+                    logger.warning(f"Font {font} not in {fonts_list}.")
         self.font = font
         self._font_size = float(font_size)
         self.slant = slant
@@ -1268,15 +1312,13 @@ class MarkupText(SVGMobject):
             self.set_color_by_gradient(*self.gradient)
         for col in colormap:
             self.chars[
-                col["start"]
-                - col["start_offset"] : col["end"]
+                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"] - grad["start_offset"] : grad["end"]
                 - grad["start_offset"]
                 - grad["end_offset"]
             ].set_color_by_gradient(
@@ -1369,7 +1411,8 @@ class MarkupText(SVGMobject):
         """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."""
+        counts to the text's `len`, but has no corresponding character.
+        """
         count = 0
         level = 0
         # temporarily replace HTML entities by single char
@@ -1412,7 +1455,9 @@ class MarkupText(SVGMobject):
                     "end_offset": end_offset,
                 },
             )
-        self.text = re.sub("<gradient[^>]+>(.+?)</gradient>", r"\1", self.text, 0, re.S)
+        self.text = re.sub(
+            "<gradient[^>]+>(.+?)</gradient>", r"\1", self.text, count=0, flags=re.S
+        )
         return gradientmap
 
     def _parse_color(self, col):
@@ -1454,7 +1499,9 @@ class MarkupText(SVGMobject):
                     "end_offset": end_offset,
                 },
             )
-        self.text = re.sub("<color[^>]+>(.+?)</color>", r"\1", self.text, 0, re.S)
+        self.text = re.sub(
+            "<color[^>]+>(.+?)</color>", r"\1", self.text, count=0, flags=re.S
+        )
         return colormap
 
     def __repr__(self):
@@ -1500,7 +1547,6 @@ def register_font(font_file: str | Path):
         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),
@@ -1515,7 +1561,7 @@ def register_font(font_file: str | Path):
             logger.debug("Found file at %s", file_path.absolute())
             break
     else:
-        error = f"Can't find {font_file}." f"Tried these : {possible_paths}"
+        error = f"Can't find {font_file}.Tried these : {possible_paths}"
         raise FileNotFoundError(error)
 
     try:

manim/mobject/three_d/polyhedra.py

@@ -10,11 +10,20 @@ from manim.mobject.geometry.polygram import Polygon
 from manim.mobject.graph import Graph
 from manim.mobject.three_d.three_dimensions import Dot3D
 from manim.mobject.types.vectorized_mobject import VGroup
+from manim.utils.qhull import QuickHull
 
 if TYPE_CHECKING:
     from manim.mobject.mobject import Mobject
+    from manim.typing import Point3D
 
-__all__ = ["Polyhedron", "Tetrahedron", "Octahedron", "Icosahedron", "Dodecahedron"]
+__all__ = [
+    "Polyhedron",
+    "Tetrahedron",
+    "Octahedron",
+    "Icosahedron",
+    "Dodecahedron",
+    "ConvexHull3D",
+]
 
 
 class Polyhedron(VGroup):
@@ -361,3 +370,91 @@ class Dodecahedron(Polyhedron):
             ],
             **kwargs,
         )
+
+
+class ConvexHull3D(Polyhedron):
+    """A convex hull for a set of points
+
+    Parameters
+    ----------
+    points
+        The points to consider.
+    tolerance
+        The tolerance used for quickhull.
+    kwargs
+        Forwarded to the parent constructor.
+
+    Examples
+    --------
+    .. manim:: ConvexHull3DExample
+        :save_last_frame:
+        :quality: high
+
+        class ConvexHull3DExample(ThreeDScene):
+            def construct(self):
+                self.set_camera_orientation(phi=75 * DEGREES, theta=30 * DEGREES)
+                points = [
+                    [ 1.93192757,  0.44134585, -1.52407061],
+                    [-0.93302521,  1.23206983,  0.64117067],
+                    [-0.44350918, -0.61043677,  0.21723705],
+                    [-0.42640268, -1.05260843,  1.61266094],
+                    [-1.84449637,  0.91238739, -1.85172623],
+                    [ 1.72068132, -0.11880457,  0.51881751],
+                    [ 0.41904805,  0.44938012, -1.86440686],
+                    [ 0.83864666,  1.66653337,  1.88960123],
+                    [ 0.22240514, -0.80986286,  1.34249326],
+                    [-1.29585759,  1.01516189,  0.46187522],
+                    [ 1.7776499,  -1.59550796, -1.70240747],
+                    [ 0.80065226, -0.12530398,  1.70063977],
+                    [ 1.28960948, -1.44158255,  1.39938582],
+                    [-0.93538943,  1.33617705, -0.24852643],
+                    [-1.54868271,  1.7444399,  -0.46170734]
+                ]
+                hull = ConvexHull3D(
+                    *points,
+                    faces_config = {"stroke_opacity": 0},
+                    graph_config = {
+                        "vertex_type": Dot3D,
+                        "edge_config": {
+                            "stroke_color": BLUE,
+                            "stroke_width": 2,
+                            "stroke_opacity": 0.05,
+                        }
+                    }
+                )
+                dots = VGroup(*[Dot3D(point) for point in points])
+                self.add(hull)
+                self.add(dots)
+    """
+
+    def __init__(self, *points: Point3D, tolerance: float = 1e-5, **kwargs):
+        # Build Convex Hull
+        array = np.array(points)
+        hull = QuickHull(tolerance)
+        hull.build(array)
+
+        # Setup Lists
+        vertices = []
+        faces = []
+
+        # Extract Faces
+        c = 0
+        d = {}
+        facets = set(hull.facets) - hull.removed
+        for facet in facets:
+            tmp = set()
+            for subfacet in facet.subfacets:
+                for point in subfacet.points:
+                    if point not in d:
+                        vertices.append(point.coordinates)
+                        d[point] = c
+                        c += 1
+                    tmp.add(point)
+            faces.append([d[point] for point in tmp])
+
+        # Call Polyhedron
+        super().__init__(
+            vertex_coords=vertices,
+            faces_list=faces,
+            **kwargs,
+        )

manim/mobject/three_d/three_d_utils.py

@@ -22,7 +22,7 @@ from manim.constants import ORIGIN, UP
 from manim.utils.space_ops import get_unit_normal
 
 if TYPE_CHECKING:
-    from manim.typing import Point3D, Vector
+    from manim.typing import Point3D, Vector3D
 
 
 def get_3d_vmob_gradient_start_and_end_points(vmob) -> tuple[Point3D, Point3D]:
@@ -52,7 +52,7 @@ def get_3d_vmob_end_corner(vmob) -> Point3D:
     return vmob.points[get_3d_vmob_end_corner_index(vmob)]
 
 
-def get_3d_vmob_unit_normal(vmob, point_index: int) -> Vector:
+def get_3d_vmob_unit_normal(vmob, point_index: int) -> Vector3D:
     n_points = vmob.get_num_points()
     if len(vmob.get_anchors()) <= 2:
         return np.array(UP)
@@ -68,9 +68,9 @@ def get_3d_vmob_unit_normal(vmob, point_index: int) -> Vector:
     return unit_normal
 
 
-def get_3d_vmob_start_corner_unit_normal(vmob) -> Vector:
+def get_3d_vmob_start_corner_unit_normal(vmob) -> Vector3D:
     return get_3d_vmob_unit_normal(vmob, get_3d_vmob_start_corner_index(vmob))
 
 
-def get_3d_vmob_end_corner_unit_normal(vmob) -> Vector:
+def get_3d_vmob_end_corner_unit_normal(vmob) -> Vector3D:
     return get_3d_vmob_unit_normal(vmob, get_3d_vmob_end_corner_index(vmob))