manim 0.18.1__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
 
@@ -22,7 +23,7 @@ __all__ = ["DecimalNumber", "Integer", "Variable"]
 
 
 class DecimalNumber(VMobject, metaclass=ConvertToOpenGL):
-    """An mobject representing a decimal number.
+    r"""An mobject representing a decimal number.
 
     Parameters
     ----------
@@ -210,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
 
@@ -330,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,9 +26,9 @@ __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 *
@@ -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

@@ -56,12 +56,11 @@ __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
@@ -135,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::
 
@@ -412,7 +418,7 @@ class Text(SVGMobject):
     """
 
     @staticmethod
-    @functools.lru_cache(maxsize=None)
+    @functools.cache
     def font_list() -> list[str]:
         return manimpango.list_fonts()
 
@@ -657,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):
@@ -696,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)
@@ -907,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>``
@@ -1155,7 +1162,7 @@ class MarkupText(SVGMobject):
     """
 
     @staticmethod
-    @functools.lru_cache(maxsize=None)
+    @functools.cache
     def font_list() -> list[str]:
         return manimpango.list_fonts()
 
@@ -1305,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(
@@ -1406,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
@@ -1449,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):
@@ -1491,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):
@@ -1537,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),
@@ -1552,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_dimensions.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from manim.typing import Point3D, Vector3D
+from manim.typing import Point3DLike, Vector3D
 from manim.utils.color import BLUE, BLUE_D, BLUE_E, LIGHT_GREY, WHITE, interpolate_color
 
 __all__ = [
@@ -19,7 +19,8 @@ __all__ = [
     "Torus",
 ]
 
-from typing import Any, Callable, Iterable, Sequence
+from collections.abc import Iterable, Sequence
+from typing import Any, Callable
 
 import numpy as np
 from typing_extensions import Self
@@ -31,16 +32,10 @@ from manim.mobject.geometry.polygram import Square
 from manim.mobject.mobject import *
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.mobject.opengl.opengl_mobject import OpenGLMobject
-from manim.mobject.types.vectorized_mobject import VGroup, VMobject
+from manim.mobject.types.vectorized_mobject import VectorizedPoint, VGroup, VMobject
 from manim.utils.color import (
-    BLUE,
-    BLUE_D,
-    BLUE_E,
-    LIGHT_GREY,
-    WHITE,
     ManimColor,
     ParsableManimColor,
-    interpolate_color,
 )
 from manim.utils.iterables import tuplify
 from manim.utils.space_ops import normalize, perpendicular_bisector, z_to_vector
@@ -378,7 +373,7 @@ class Sphere(Surface):
 
     def __init__(
         self,
-        center: Point3D = ORIGIN,
+        center: Point3DLike = ORIGIN,
         radius: float = 1,
         resolution: Sequence[int] | None = None,
         u_range: Sequence[float] = (0, TAU),
@@ -621,17 +616,18 @@ class Cone(Surface):
             **kwargs,
         )
         # used for rotations
+        self.new_height = height
         self._current_theta = 0
         self._current_phi = 0
-
+        self.base_circle = Circle(
+            radius=base_radius,
+            color=self.fill_color,
+            fill_opacity=self.fill_opacity,
+            stroke_width=0,
+        )
+        self.base_circle.shift(height * IN)
+        self._set_start_and_end_attributes(direction)
         if show_base:
-            self.base_circle = Circle(
-                radius=base_radius,
-                color=self.fill_color,
-                fill_opacity=self.fill_opacity,
-                stroke_width=0,
-            )
-            self.base_circle.shift(height * IN)
             self.add(self.base_circle)
 
         self._rotate_to_direction()
@@ -661,14 +657,17 @@ class Cone(Surface):
             ],
         )
 
+    def get_start(self) -> np.ndarray:
+        return self.start_point.get_center()
+
+    def get_end(self) -> np.ndarray:
+        return self.end_point.get_center()
+
     def _rotate_to_direction(self) -> None:
         x, y, z = self.direction
 
         r = np.sqrt(x**2 + y**2 + z**2)
-        if r > 0:
-            theta = np.arccos(z / r)
-        else:
-            theta = 0
+        theta = np.arccos(z / r) if r > 0 else 0
 
         if x == 0:
             if y == 0:  # along the z axis
@@ -715,6 +714,15 @@ class Cone(Surface):
         """
         return self.direction
 
+    def _set_start_and_end_attributes(self, direction):
+        normalized_direction = direction * np.linalg.norm(direction)
+
+        start = self.base_circle.get_center()
+        end = start + normalized_direction * self.new_height
+        self.start_point = VectorizedPoint(start)
+        self.end_point = VectorizedPoint(end)
+        self.add(self.start_point, self.end_point)
+
 
 class Cylinder(Surface):
     """A cylinder, defined by its height, radius and direction,
@@ -824,10 +832,7 @@ class Cylinder(Surface):
         x, y, z = self.direction
 
         r = np.sqrt(x**2 + y**2 + z**2)
-        if r > 0:
-            theta = np.arccos(z / r)
-        else:
-            theta = 0
+        theta = np.arccos(z / r) if r > 0 else 0
 
         if x == 0:
             if y == 0:  # along the z axis
@@ -890,6 +895,12 @@ class Line3D(Cylinder):
         The thickness of the line.
     color
         The color of the line.
+    resolution
+        The resolution of the line.
+        By default this value is the number of points the line will sampled at.
+        If you want the line to also come out checkered, use a tuple.
+        For example, for a line made of 24 points with 4 checker points on each
+        cylinder, pass the tuple (4, 24).
 
     Examples
     --------
@@ -910,9 +921,11 @@ class Line3D(Cylinder):
         end: np.ndarray = RIGHT,
         thickness: float = 0.02,
         color: ParsableManimColor | None = None,
+        resolution: int | Sequence[int] = 24,
         **kwargs,
     ):
         self.thickness = thickness
+        self.resolution = (2, resolution) if isinstance(resolution, int) else resolution
         self.set_start_and_end_attrs(start, end, **kwargs)
         if color is not None:
             self.set_color(color)
@@ -946,13 +959,14 @@ class Line3D(Cylinder):
             height=np.linalg.norm(self.vect),
             radius=self.thickness,
             direction=self.direction,
+            resolution=self.resolution,
             **kwargs,
         )
         self.shift((self.start + self.end) / 2)
 
     def pointify(
         self,
-        mob_or_point: Mobject | Point3D,
+        mob_or_point: Mobject | Point3DLike,
         direction: Vector3D = None,
     ) -> np.ndarray:
         """Gets a point representing the center of the :class:`Mobjects <.Mobject>`.
@@ -1117,6 +1131,8 @@ class Arrow3D(Line3D):
         The base radius of the conical tip.
     color
         The color of the arrow.
+    resolution
+        The resolution of the arrow line.
 
     Examples
     --------
@@ -1143,10 +1159,16 @@ class Arrow3D(Line3D):
         height: float = 0.3,
         base_radius: float = 0.08,
         color: ParsableManimColor = WHITE,
+        resolution: int | Sequence[int] = 24,
         **kwargs,
     ) -> None:
         super().__init__(
-            start=start, end=end, thickness=thickness, color=color, **kwargs
+            start=start,
+            end=end,
+            thickness=thickness,
+            color=color,
+            resolution=resolution,
+            **kwargs,
         )
 
         self.length = np.linalg.norm(self.vect)
@@ -1155,14 +1177,20 @@ class Arrow3D(Line3D):
             self.end - height * self.direction,
             **kwargs,
         )
-
         self.cone = Cone(
-            direction=self.direction, base_radius=base_radius, height=height, **kwargs
+            direction=self.direction,
+            base_radius=base_radius,
+            height=height,
+            **kwargs,
         )
         self.cone.shift(end)
-        self.add(self.cone)
+        self.end_point = VectorizedPoint(end)
+        self.add(self.end_point, self.cone)
         self.set_color(color)
 
+    def get_end(self) -> np.ndarray:
+        return self.end_point.get_center()
+
 
 class Torus(Surface):
     """A torus.