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

manim/utils/color/manim_colors.py

@@ -0,0 +1,220 @@
+"""Colors included in the global name space.
+
+These colors form Manim's default color space.
+
+.. manim:: ColorsOverview
+    :save_last_frame:
+    :hide_source:
+
+    import manim.utils.color.manim_colors as Colors
+
+    class ColorsOverview(Scene):
+        def construct(self):
+            def color_group(color):
+                group = VGroup(
+                    *[
+                        Line(ORIGIN, RIGHT * 1.5, stroke_width=35, color=getattr(Colors, name.upper()))
+                        for name in subnames(color)
+                    ]
+                ).arrange_submobjects(buff=0.4, direction=DOWN)
+
+                name = Text(color).scale(0.6).next_to(group, UP, buff=0.3)
+                if any(decender in color for decender in "gjpqy"):
+                    name.shift(DOWN * 0.08)
+                group.add(name)
+                return group
+
+            def subnames(name):
+                return [name + "_" + char for char in "abcde"]
+
+            color_groups = VGroup(
+                *[
+                    color_group(color)
+                    for color in [
+                        "blue",
+                        "teal",
+                        "green",
+                        "yellow",
+                        "gold",
+                        "red",
+                        "maroon",
+                        "purple",
+                    ]
+                ]
+            ).arrange_submobjects(buff=0.2, aligned_edge=DOWN)
+
+            for line, char in zip(color_groups[0], "abcde"):
+                color_groups.add(Text(char).scale(0.6).next_to(line, LEFT, buff=0.2))
+
+            def named_lines_group(length, colors, names, text_colors, align_to_block):
+                lines = VGroup(
+                    *[
+                        Line(
+                            ORIGIN,
+                            RIGHT * length,
+                            stroke_width=55,
+                            color=getattr(Colors, color.upper()),
+                        )
+                        for color in colors
+                    ]
+                ).arrange_submobjects(buff=0.6, direction=DOWN)
+
+                for line, name, color in zip(lines, names, text_colors):
+                    line.add(Text(name, color=color).scale(0.6).move_to(line))
+                lines.next_to(color_groups, DOWN, buff=0.5).align_to(
+                    color_groups[align_to_block], LEFT
+                )
+                return lines
+
+            other_colors = (
+                "pink",
+                "light_pink",
+                "orange",
+                "light_brown",
+                "dark_brown",
+                "gray_brown",
+            )
+
+            other_lines = named_lines_group(
+                3.2,
+                other_colors,
+                other_colors,
+                [BLACK] * 4 + [WHITE] * 2,
+                0,
+            )
+
+            gray_lines = named_lines_group(
+                6.6,
+                ["white"] + subnames("gray") + ["black"],
+                [
+                    "white",
+                    "lighter_gray / gray_a",
+                    "light_gray / gray_b",
+                    "gray / gray_c",
+                    "dark_gray / gray_d",
+                    "darker_gray / gray_e",
+                    "black",
+                ],
+                [BLACK] * 3 + [WHITE] * 4,
+                2,
+            )
+
+            pure_colors = (
+                "pure_red",
+                "pure_green",
+                "pure_blue",
+            )
+
+            pure_lines = named_lines_group(
+                3.2,
+                pure_colors,
+                pure_colors,
+                [BLACK, BLACK, WHITE],
+                6,
+            )
+
+            self.add(color_groups, other_lines, gray_lines, pure_lines)
+
+            VGroup(*self.mobjects).move_to(ORIGIN)
+
+.. automanimcolormodule:: manim.utils.color.manim_colors
+
+"""
+
+from typing import List
+
+from .core import ManimColor
+
+WHITE = ManimColor("#FFFFFF")
+GRAY_A = ManimColor("#DDDDDD")
+GREY_A = ManimColor("#DDDDDD")
+GRAY_B = ManimColor("#BBBBBB")
+GREY_B = ManimColor("#BBBBBB")
+GRAY_C = ManimColor("#888888")
+GREY_C = ManimColor("#888888")
+GRAY_D = ManimColor("#444444")
+GREY_D = ManimColor("#444444")
+GRAY_E = ManimColor("#222222")
+GREY_E = ManimColor("#222222")
+BLACK = ManimColor("#000000")
+LIGHTER_GRAY = ManimColor("#DDDDDD")
+LIGHTER_GREY = ManimColor("#DDDDDD")
+LIGHT_GRAY = ManimColor("#BBBBBB")
+LIGHT_GREY = ManimColor("#BBBBBB")
+GRAY = ManimColor("#888888")
+GREY = ManimColor("#888888")
+DARK_GRAY = ManimColor("#444444")
+DARK_GREY = ManimColor("#444444")
+DARKER_GRAY = ManimColor("#222222")
+DARKER_GREY = ManimColor("#222222")
+BLUE_A = ManimColor("#C7E9F1")
+BLUE_B = ManimColor("#9CDCEB")
+BLUE_C = ManimColor("#58C4DD")
+BLUE_D = ManimColor("#29ABCA")
+BLUE_E = ManimColor("#236B8E")
+PURE_BLUE = ManimColor("#0000FF")
+BLUE = ManimColor("#58C4DD")
+DARK_BLUE = ManimColor("#236B8E")
+TEAL_A = ManimColor("#ACEAD7")
+TEAL_B = ManimColor("#76DDC0")
+TEAL_C = ManimColor("#5CD0B3")
+TEAL_D = ManimColor("#55C1A7")
+TEAL_E = ManimColor("#49A88F")
+TEAL = ManimColor("#5CD0B3")
+GREEN_A = ManimColor("#C9E2AE")
+GREEN_B = ManimColor("#A6CF8C")
+GREEN_C = ManimColor("#83C167")
+GREEN_D = ManimColor("#77B05D")
+GREEN_E = ManimColor("#699C52")
+PURE_GREEN = ManimColor("#00FF00")
+GREEN = ManimColor("#83C167")
+YELLOW_A = ManimColor("#FFF1B6")
+YELLOW_B = ManimColor("#FFEA94")
+YELLOW_C = ManimColor("#FFFF00")
+YELLOW_D = ManimColor("#F4D345")
+YELLOW_E = ManimColor("#E8C11C")
+YELLOW = ManimColor("#FFFF00")
+GOLD_A = ManimColor("#F7C797")
+GOLD_B = ManimColor("#F9B775")
+GOLD_C = ManimColor("#F0AC5F")
+GOLD_D = ManimColor("#E1A158")
+GOLD_E = ManimColor("#C78D46")
+GOLD = ManimColor("#F0AC5F")
+RED_A = ManimColor("#F7A1A3")
+RED_B = ManimColor("#FF8080")
+RED_C = ManimColor("#FC6255")
+RED_D = ManimColor("#E65A4C")
+RED_E = ManimColor("#CF5044")
+PURE_RED = ManimColor("#FF0000")
+RED = ManimColor("#FC6255")
+MAROON_A = ManimColor("#ECABC1")
+MAROON_B = ManimColor("#EC92AB")
+MAROON_C = ManimColor("#C55F73")
+MAROON_D = ManimColor("#A24D61")
+MAROON_E = ManimColor("#94424F")
+MAROON = ManimColor("#C55F73")
+PURPLE_A = ManimColor("#CAA3E8")
+PURPLE_B = ManimColor("#B189C6")
+PURPLE_C = ManimColor("#9A72AC")
+PURPLE_D = ManimColor("#715582")
+PURPLE_E = ManimColor("#644172")
+PURPLE = ManimColor("#9A72AC")
+PINK = ManimColor("#D147BD")
+LIGHT_PINK = ManimColor("#DC75CD")
+ORANGE = ManimColor("#FF862F")
+LIGHT_BROWN = ManimColor("#CD853F")
+DARK_BROWN = ManimColor("#8B4513")
+GRAY_BROWN = ManimColor("#736357")
+GREY_BROWN = ManimColor("#736357")
+
+# Colors used for Manim Community's logo and banner
+
+LOGO_WHITE = ManimColor("#ECE7E2")
+LOGO_GREEN = ManimColor("#87C2A5")
+LOGO_BLUE = ManimColor("#525893")
+LOGO_RED = ManimColor("#E07A5F")
+LOGO_BLACK = ManimColor("#343434")
+
+_all_manim_colors: List[ManimColor] = [
+    x for x in globals().values() if isinstance(x, ManimColor)
+]

manim/utils/docbuild/autocolor_directive.py

@@ -0,0 +1,92 @@
+from __future__ import annotations
+
+import inspect
+
+from docutils import nodes
+from docutils.parsers.rst import Directive
+from sphinx.application import Sphinx
+
+from manim import ManimColor
+
+
+def setup(app: Sphinx) -> None:
+    app.add_directive("automanimcolormodule", ManimColorModuleDocumenter)
+
+
+class ManimColorModuleDocumenter(Directive):
+    objtype = "automanimcolormodule"
+    required_arguments = 1
+    has_content = True
+
+    def add_directive_header(self, sig: str) -> None:
+        super().add_directive_header(sig)
+
+    def run(
+        self,
+    ) -> None:
+        module_name = self.arguments[0]
+        try:
+            import importlib
+
+            module = importlib.import_module(module_name)
+        except ImportError:
+            return [
+                nodes.error(
+                    None,
+                    nodes.paragraph(text="Failed to import module '%s'" % module_name),
+                )
+            ]
+
+        # Number of Colors displayed in one row
+        num_color_cols = 2
+        table = nodes.table(align="center")
+
+        tgroup = nodes.tgroup(cols=num_color_cols * 2)
+        table += tgroup
+        for _ in range(num_color_cols * 2):
+            tgroup += nodes.colspec(colwidth=1)
+
+        # Create header rows for the table
+        thead = nodes.thead()
+        row = nodes.row()
+        for _ in range(num_color_cols):
+            col1 = nodes.paragraph(text="Color Name")
+            col2 = nodes.paragraph(text="RGB Hex Code")
+            row += nodes.entry("", col1)
+            row += nodes.entry("", col2)
+        thead += row
+        tgroup += thead
+
+        color_elements = []
+        for member_name, member_obj in inspect.getmembers(module):
+            if isinstance(member_obj, ManimColor):
+                r, g, b = member_obj.to_rgb()
+                luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b
+
+                # Choose the font color based on the background luminance
+                if luminance > 0.5:
+                    font_color = "black"
+                else:
+                    font_color = "white"
+
+                color_elements.append((member_name, member_obj.to_hex(), font_color))
+
+        tbody = nodes.tbody()
+
+        for base_i in range(0, len(color_elements), num_color_cols):
+            row = nodes.row()
+            for member_name, hex_code, font_color in color_elements[
+                base_i : base_i + num_color_cols
+            ]:
+                col1 = nodes.literal(text=member_name)
+                col2 = nodes.raw(
+                    "",
+                    f'<div style="background-color:{hex_code};padding: 0.25rem 0;border-radius:8px;margin: 0.5rem 0.2rem"><code style="color:{font_color};">{hex_code}</code></div>',
+                    format="html",
+                )
+                row += nodes.entry("", col1)
+                row += nodes.entry("", col2)
+            tbody += row
+        tgroup += tbody
+
+        return [table]

manim/utils/docbuild/manim_directive.py

@@ -26,7 +26,7 @@ render scenes that are defined within doctests, for example::
         >>> from manim import Create, Dot, RED, Scene
         >>> dot = Dot(color=RED)
         >>> dot.color
-        <Color #fc6255>
+        ManimColor('#FC6255')
         >>> class DirectiveDoctestExample(Scene):
         ...     def construct(self):
         ...         self.play(Create(dot))
@@ -85,6 +85,7 @@ import os
 import re
 import shutil
 import sys
+import textwrap
 from pathlib import Path
 from timeit import timeit
 
@@ -94,6 +95,7 @@ from docutils.parsers.rst import Directive, directives  # type: ignore
 from docutils.statemachine import StringList
 
 from manim import QUALITIES
+from manim import __version__ as manim_version
 
 classnamedict = {}
 
@@ -168,16 +170,25 @@ class ManimDirective(Directive):
             or self.state.document.settings.env.app.builder.name == "gettext"
         )
         if should_skip:
+            clsname = self.arguments[0]
             node = SkipManimNode()
             self.state.nested_parse(
                 StringList(
                     [
-                        f"Placeholder block for ``{self.arguments[0]}``.",
+                        f"Placeholder block for ``{clsname}``.",
                         "",
                         ".. code-block:: python",
                         "",
                     ]
                     + ["    " + line for line in self.content]
+                    + [
+                        "",
+                        ".. raw:: html",
+                        "",
+                        f'    <pre data-manim-binder data-manim-classname="{clsname}">',
+                    ]
+                    + ["    " + line for line in self.content]
+                    + ["    </pre>"],
                 ),
                 self.content_offset,
                 node,
@@ -235,6 +246,13 @@ class ManimDirective(Directive):
             "",
             "    from manim import *\n",
             *("    " + line for line in self.content),
+            "",
+            ".. raw:: html",
+            "",
+            f'    <pre data-manim-binder data-manim-classname="{clsname}">',
+            *("    " + line for line in self.content),
+            "",
+            "    </pre>",
         ]
         source_block = "\n".join(source_block)
 
@@ -272,10 +290,13 @@ class ManimDirective(Directive):
             f"{clsname}().render()",
         ]
 
-        with tempconfig(example_config):
-            run_time = timeit(lambda: exec("\n".join(code), globals()), number=1)
-            video_dir = config.get_dir("video_dir")
-            images_dir = config.get_dir("images_dir")
+        try:
+            with tempconfig(example_config):
+                run_time = timeit(lambda: exec("\n".join(code), globals()), number=1)
+                video_dir = config.get_dir("video_dir")
+                images_dir = config.get_dir("images_dir")
+        except Exception as e:
+            raise RuntimeError(f"Error while rendering example {clsname}") from e
 
         _write_rendering_stats(
             clsname,
@@ -340,6 +361,9 @@ def _log_rendering_times(*args):
 
         print("\nRendering Summary\n-----------------\n")
 
+        # filter out empty lists caused by csv reader
+        data = [row for row in data if row]
+
         max_file_length = max(len(row[0]) for row in data)
         for key, group in it.groupby(data, key=lambda row: row[0]):
             key = key.ljust(max_file_length + 1, ".")
@@ -374,6 +398,16 @@ def setup(app):
     app.connect("builder-inited", _delete_rendering_times)
     app.connect("build-finished", _log_rendering_times)
 
+    app.add_js_file("manim-binder.min.js")
+    app.add_js_file(
+        None,
+        body=textwrap.dedent(
+            f"""\
+                window.initManimBinder({{branch: "v{manim_version}"}})
+            """
+        ).strip(),
+    )
+
     metadata = {"parallel_read_safe": False, "parallel_write_safe": True}
     return metadata
 

manim/utils/file_ops.py

@@ -183,7 +183,7 @@ def modify_atime(file_path: str) -> None:
     file_path
         The path of the file.
     """
-    os.utime(file_path, times=(time.time(), os.path.getmtime(file_path)))
+    os.utime(file_path, times=(time.time(), Path(file_path).stat().st_mtime))
 
 
 def open_file(file_path, in_browser=False):

manim/utils/hashing.py

@@ -207,7 +207,7 @@ class _CustomEncoder(json.JSONEncoder):
                     del cvardict[i]
             try:
                 code = inspect.getsource(obj)
-            except OSError:
+            except (OSError, TypeError):
                 # This happens when rendering videos included in the documentation
                 # within doctests and should be replaced by a solution avoiding
                 # hash collision (due to the same, empty, code strings) at some point.

manim/utils/iterables.py

@@ -65,7 +65,7 @@ def all_elements_are_instances(iterable: Iterable, Class) -> bool:
     """Returns ``True`` if all elements of iterable are instances of Class.
     False otherwise.
     """
-    return all([isinstance(e, Class) for e in iterable])
+    return all(isinstance(e, Class) for e in iterable)
 
 
 def batch_by_property(

manim/utils/rate_functions.py

@@ -89,6 +89,9 @@ from __future__ import annotations
 __all__ = [
     "linear",
     "smooth",
+    "smoothstep",
+    "smootherstep",
+    "smoothererstep",
     "rush_into",
     "rush_from",
     "slow_into",
@@ -155,6 +158,36 @@ def smooth(t: float, inflection: float = 10.0) -> float:
     )
 
 
+def smoothstep(t: float) -> float:
+    """Implementation of the 1st order SmoothStep sigmoid function.
+    The 1st derivative (speed) is zero at the endpoints.
+    https://en.wikipedia.org/wiki/Smoothstep
+    """
+    return 0 if t <= 0 else 3 * t**2 - 2 * t**3 if t < 1 else 1
+
+
+def smootherstep(t: float) -> float:
+    """Implementation of the 2nd order SmoothStep sigmoid function.
+    The 1st and 2nd derivatives (speed and acceleration) are zero at the endpoints.
+    https://en.wikipedia.org/wiki/Smoothstep
+    """
+    return 0 if t <= 0 else 6 * t**5 - 15 * t**4 + 10 * t**3 if t < 1 else 1
+
+
+def smoothererstep(t: float) -> float:
+    """Implementation of the 3rd order SmoothStep sigmoid function.
+    The 1st, 2nd and 3rd derivatives (speed, acceleration and jerk) are zero at the endpoints.
+    https://en.wikipedia.org/wiki/Smoothstep
+    """
+    return (
+        0
+        if t <= 0
+        else 35 * t**4 - 84 * t**5 + 70 * t**6 - 20 * t**7
+        if t < 1
+        else 1
+    )
+
+
 @unit_interval
 def rush_into(t: float, inflection: float = 10.0) -> float:
     return 2 * smooth(t / 2.0, inflection)

manim/utils/simple_functions.py

@@ -6,7 +6,6 @@ __all__ = [
     "binary_search",
     "choose",
     "clip",
-    "get_parameters",
     "sigmoid",
 ]
 
@@ -117,23 +116,6 @@ def clip(a, min_a, max_a):
     return a
 
 
-def get_parameters(function: Callable) -> MappingProxyType[str, inspect.Parameter]:
-    """Return the parameters of ``function`` as an ordered mapping of parameters'
-    names to their corresponding ``Parameter`` objects.
-
-    Examples
-    --------
-    ::
-
-        >>> get_parameters(get_parameters)
-        mappingproxy(OrderedDict([('function', <Parameter "function: 'Callable'">)]))
-
-        >>> tuple(get_parameters(choose))
-        ('n', 'k')
-    """
-    return inspect.signature(function).parameters
-
-
 def sigmoid(x: float) -> float:
     r"""Returns the output of the logistic function.
 

manim/utils/space_ops.py

@@ -2,6 +2,8 @@
 
 from __future__ import annotations
 
+from manim.typing import Point3D_Array, Vector
+
 __all__ = [
     "quaternion_mult",
     "quaternion_from_angle_axis",
@@ -37,14 +39,12 @@ __all__ = [
 
 
 import itertools as it
-import math
 from typing import Sequence
 
 import numpy as np
 from mapbox_earcut import triangulate_float32 as earcut
 from scipy.spatial.transform import Rotation
 
-from .. import config
 from ..constants import DOWN, OUT, PI, RIGHT, TAU, UP, RendererType
 from ..utils.iterables import adjacent_pairs
 
@@ -69,34 +69,19 @@ def quaternion_mult(
     Union[np.ndarray, List[Union[float, np.ndarray]]]
         Returns a list of product of two quaternions.
     """
-    if config.renderer == RendererType.OPENGL:
-        if len(quats) == 0:
-            return [1, 0, 0, 0]
-        result = quats[0]
-        for next_quat in quats[1:]:
-            w1, x1, y1, z1 = result
-            w2, x2, y2, z2 = next_quat
-            result = [
-                w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2,
-                w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2,
-                w1 * y2 + y1 * w2 + z1 * x2 - x1 * z2,
-                w1 * z2 + z1 * w2 + x1 * y2 - y1 * x2,
-            ]
-        return result
-    elif config.renderer == RendererType.CAIRO:
-        q1 = quats[0]
-        q2 = quats[1]
-
-        w1, x1, y1, z1 = q1
-        w2, x2, y2, z2 = q2
-        return np.array(
-            [
-                w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2,
-                w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2,
-                w1 * y2 + y1 * w2 + z1 * x2 - x1 * z2,
-                w1 * z2 + z1 * w2 + x1 * y2 - y1 * x2,
-            ],
-        )
+    if len(quats) == 0:
+        return [1, 0, 0, 0]
+    result = quats[0]
+    for next_quat in quats[1:]:
+        w1, x1, y1, z1 = result
+        w2, x2, y2, z2 = next_quat
+        result = [
+            w1 * w2 - x1 * x2 - y1 * y2 - z1 * z2,
+            w1 * x2 + x1 * w2 + y1 * z2 - z1 * y2,
+            w1 * y2 + y1 * w2 + z1 * x2 - x1 * z2,
+            w1 * z2 + z1 * w2 + x1 * y2 - y1 * x2,
+        ]
+    return result
 
 
 def quaternion_from_angle_axis(
@@ -122,12 +107,9 @@ def quaternion_from_angle_axis(
     List[float]
         Gives back a quaternion from the angle and axis
     """
-    if config.renderer == RendererType.OPENGL:
-        if not axis_normalized:
-            axis = normalize(axis)
-        return [math.cos(angle / 2), *(math.sin(angle / 2) * axis)]
-    elif config.renderer == RendererType.CAIRO:
-        return np.append(np.cos(angle / 2), np.sin(angle / 2) * normalize(axis))
+    if not axis_normalized:
+        axis = normalize(axis)
+    return [np.cos(angle / 2), *(np.sin(angle / 2) * axis)]
 
 
 def angle_axis_from_quaternion(quaternion: Sequence[float]) -> Sequence[float]:
@@ -275,7 +257,7 @@ def rotation_about_z(angle: float) -> np.ndarray:
     np.ndarray
         Gives back the rotated matrix.
     """
-    c, s = math.cos(angle), math.sin(angle)
+    c, s = np.cos(angle), np.sin(angle)
     return np.array(
         [
             [c, -s, 0],
@@ -559,10 +541,10 @@ def line_intersection(
 
 
 def find_intersection(
-    p0s: Sequence[np.ndarray],
-    v0s: Sequence[np.ndarray],
-    p1s: Sequence[np.ndarray],
-    v1s: Sequence[np.ndarray],
+    p0s: Sequence[np.ndarray] | Point3D_Array,
+    v0s: Sequence[np.ndarray] | Point3D_Array,
+    p1s: Sequence[np.ndarray] | Point3D_Array,
+    v1s: Sequence[np.ndarray] | Point3D_Array,
     threshold: float = 1e-5,
 ) -> Sequence[np.ndarray]:
     """
@@ -640,7 +622,38 @@ def shoelace_direction(x_y: np.ndarray) -> str:
     return "CW" if area > 0 else "CCW"
 
 
-def cross2d(a, b):
+def cross2d(
+    a: Sequence[Vector] | Vector, b: Sequence[Vector] | Vector
+) -> Sequence[float] | float:
+    """Compute the determinant(s) of the passed
+    vector (sequences).
+
+    Parameters
+    ----------
+    a
+        A vector or a sequence of vectors.
+    b
+        A vector or a sequence of vectors.
+
+    Returns
+    -------
+    Sequence[float] | float
+        The determinant or sequence of determinants
+        of the first two components of the specified
+        vectors.
+
+    Examples
+    --------
+    .. code-block:: pycon
+
+        >>> cross2d(np.array([1, 2]), np.array([3, 4]))
+        -2
+        >>> cross2d(
+        ...     np.array([[1, 2, 0], [1, 0, 0]]),
+        ...     np.array([[3, 4, 0], [0, 1, 0]]),
+        ... )
+        array([-2,  1])
+    """
     if len(a.shape) == 2:
         return a[:, 0] * b[:, 1] - a[:, 1] * b[:, 0]
     else: