manim 0.18.1__py3-none-any.whl → 0.19.0__py3-none-any.whl

manim/mobject/opengl/opengl_point_cloud_mobject.py

@@ -65,13 +65,11 @@ class OpenGLPMobject(OpenGLMobject):
         return self
 
     def thin_out(self, factor=5):
-        """
-        Removes all but every nth point for n = factor
-        """
+        """Removes all but every nth point for n = factor"""
         for mob in self.family_members_with_points():
             num_points = mob.get_num_points()
 
-            def thin_func():
+            def thin_func(num_points=num_points):
                 return np.arange(0, num_points, factor)
 
             if len(mob.points) == len(mob.rgbas):
@@ -126,9 +124,7 @@ class OpenGLPMobject(OpenGLMobject):
         return self
 
     def sort_points(self, function=lambda p: p[0]):
-        """
-        function is any map from R^3 to R
-        """
+        """function is any map from R^3 to R"""
         for mob in self.family_members_with_points():
             indices = np.argsort(np.apply_along_axis(function, 1, mob.points))
             for key in mob.data:

manim/mobject/opengl/opengl_surface.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
+from collections.abc import Iterable
 from pathlib import Path
-from typing import Iterable
 
 import moderngl
 import numpy as np
@@ -12,7 +12,6 @@ from manim.mobject.opengl.opengl_mobject import OpenGLMobject
 from manim.utils.bezier import integer_interpolate, interpolate
 from manim.utils.color import *
 from manim.utils.config_ops import _Data, _Uniforms
-from manim.utils.deprecation import deprecated
 from manim.utils.images import change_to_rgba_array, get_full_raster_image_path
 from manim.utils.iterables import listify
 from manim.utils.space_ops import normalize_along_axis

manim/mobject/opengl/opengl_vectorized_mobject.py

@@ -2,8 +2,9 @@ from __future__ import annotations
 
 import itertools as it
 import operator as op
+from collections.abc import Iterable, Sequence
 from functools import reduce, wraps
-from typing import Callable, Iterable, Sequence
+from typing import Callable
 
 import moderngl
 import numpy as np
@@ -14,17 +15,17 @@ from manim.mobject.opengl.opengl_mobject import OpenGLMobject, OpenGLPoint
 from manim.renderer.shader_wrapper import ShaderWrapper
 from manim.utils.bezier import (
     bezier,
+    bezier_remap,
     get_quadratic_approximation_of_cubic,
     get_smooth_cubic_bezier_handle_points,
     integer_interpolate,
     interpolate,
-    partial_quadratic_bezier_points,
+    partial_bezier_points,
     proportions_along_bezier_curve_for_point,
-    quadratic_bezier_remap,
 )
 from manim.utils.color import BLACK, WHITE, ManimColor, ParsableManimColor
 from manim.utils.config_ops import _Data
-from manim.utils.iterables import listify, make_even, resize_with_interpolation
+from manim.utils.iterables import make_even, resize_with_interpolation, tuplify
 from manim.utils.space_ops import (
     angle_between_vectors,
     cross2d,
@@ -160,6 +161,9 @@ class OpenGLVMobject(OpenGLMobject):
         if stroke_color is not None:
             self.stroke_color = ManimColor.parse(stroke_color)
 
+    def _assert_valid_submobjects(self, submobjects: Iterable[OpenGLVMobject]) -> Self:
+        return self._assert_valid_submobjects_internal(submobjects, OpenGLVMobject)
+
     def get_group_class(self):
         return OpenGLVGroup
 
@@ -265,7 +269,7 @@ class OpenGLVMobject(OpenGLMobject):
 
         if width is not None:
             for mob in self.get_family(recurse):
-                mob.stroke_width = np.array([[width] for width in listify(width)])
+                mob.stroke_width = np.array([[width] for width in tuplify(width)])
 
         if background is not None:
             for mob in self.get_family(recurse):
@@ -320,6 +324,7 @@ class OpenGLVMobject(OpenGLMobject):
         vmobject_style = vmobject.get_style()
         if config.renderer == RendererType.OPENGL:
             vmobject_style["stroke_width"] = vmobject_style["stroke_width"][0][0]
+            vmobject_style["fill_opacity"] = self.get_fill_opacity()
         self.set_style(**vmobject_style, recurse=False)
         if recurse:
             # Does its best to match up submobject lists, and
@@ -401,7 +406,7 @@ class OpenGLVMobject(OpenGLMobject):
         return self.get_stroke_opacities()[0]
 
     def get_color(self):
-        if self.has_stroke():
+        if not self.has_fill():
             return self.get_stroke_color()
         return self.get_fill_color()
 
@@ -467,9 +472,7 @@ class OpenGLVMobject(OpenGLMobject):
         self.append_points(new_points)
 
     def add_cubic_bezier_curve_to(self, handle1, handle2, anchor):
-        """
-        Add cubic bezier curve to the path.
-        """
+        """Add cubic bezier curve to the path."""
         self.throw_error_if_no_points()
         quadratic_approx = get_quadratic_approximation_of_cubic(
             self.get_last_point(),
@@ -554,7 +557,7 @@ class OpenGLVMobject(OpenGLMobject):
                     alphas = np.linspace(0, 1, n + 1)
                     new_points.extend(
                         [
-                            partial_quadratic_bezier_points(tup, a1, a2)
+                            partial_bezier_points(tup, a1, a2)
                             for a1, a2 in zip(alphas, alphas[1:])
                         ],
                     )
@@ -812,7 +815,6 @@ class OpenGLVMobject(OpenGLMobject):
         length : :class:`float`
             The length of the nth curve.
         """
-
         if sample_points is None:
             sample_points = 10
 
@@ -852,7 +854,6 @@ class OpenGLVMobject(OpenGLMobject):
         length : :class:`float`
             The length of the nth curve.
         """
-
         _, length = self.get_nth_curve_function_with_length(n, sample_points)
 
         return length
@@ -867,7 +868,6 @@ class OpenGLVMobject(OpenGLMobject):
         Iterable[Callable[[float], np.ndarray]]
             The functions for the curves.
         """
-
         num_curves = self.get_num_curves()
 
         for n in range(num_curves):
@@ -917,7 +917,6 @@ class OpenGLVMobject(OpenGLMobject):
         Iterable[Tuple[Callable[[float], np.ndarray], float]]
             The functions and lengths of the curves.
         """
-
         num_curves = self.get_num_curves()
 
         for n in range(num_curves):
@@ -943,7 +942,6 @@ class OpenGLVMobject(OpenGLMobject):
         :exc:`Exception`
             If the :class:`OpenGLVMobject` has no points.
         """
-
         if alpha < 0 or alpha > 1:
             raise ValueError(f"Alpha {alpha} not between 0 and 1.")
 
@@ -1098,7 +1096,6 @@ class OpenGLVMobject(OpenGLMobject):
         float
             The length of the :class:`OpenGLVMobject`.
         """
-
         return np.sum(
             length
             for _, length in self.get_curve_functions_with_lengths(
@@ -1219,8 +1216,8 @@ class OpenGLVMobject(OpenGLMobject):
             return path
 
         for n in range(n_subpaths):
-            sp1 = get_nth_subpath(subpaths1, n)
-            sp2 = get_nth_subpath(subpaths2, n)
+            sp1 = np.asarray(get_nth_subpath(subpaths1, n))
+            sp2 = np.asarray(get_nth_subpath(subpaths2, n))
             diff1 = max(0, (len(sp2) - len(sp1)) // nppc)
             diff2 = max(0, (len(sp1) - len(sp2)) // nppc)
             sp1 = self.insert_n_curves_to_point_list(diff1, sp1)
@@ -1274,33 +1271,12 @@ class OpenGLVMobject(OpenGLMobject):
         if len(points) == 1:
             return np.repeat(points, nppc * n, 0)
 
-        bezier_groups = self.get_bezier_tuples_from_points(points)
-        norms = np.array([np.linalg.norm(bg[nppc - 1] - bg[0]) for bg in bezier_groups])
-        total_norm = sum(norms)
-        # Calculate insertions per curve (ipc)
-        if total_norm < 1e-6:
-            ipc = [n] + [0] * (len(bezier_groups) - 1)
-        else:
-            ipc = np.round(n * norms / sum(norms)).astype(int)
-
-        diff = n - sum(ipc)
-        for _ in range(diff):
-            ipc[np.argmin(ipc)] += 1
-        for _ in range(-diff):
-            ipc[np.argmax(ipc)] -= 1
-
-        new_length = sum(x + 1 for x in ipc)
-        new_points = np.empty((new_length, nppc, 3))
-        i = 0
-        for group, n_inserts in zip(bezier_groups, ipc):
-            # What was once a single quadratic curve defined
-            # by "group" will now be broken into n_inserts + 1
-            # smaller quadratic curves
-            alphas = np.linspace(0, 1, n_inserts + 2)
-            for a1, a2 in zip(alphas, alphas[1:]):
-                new_points[i] = partial_quadratic_bezier_points(group, a1, a2)
-                i = i + 1
-        return np.vstack(new_points)
+        bezier_tuples = self.get_bezier_tuples_from_points(points)
+        current_number_of_curves = len(bezier_tuples)
+        new_number_of_curves = current_number_of_curves + n
+        new_bezier_tuples = bezier_remap(bezier_tuples, new_number_of_curves)
+        new_points = new_bezier_tuples.reshape(-1, 3)
+        return new_points
 
     def interpolate(self, mobject1, mobject2, alpha, *args, **kwargs):
         super().interpolate(mobject1, mobject2, alpha, *args, **kwargs)
@@ -1353,7 +1329,7 @@ class OpenGLVMobject(OpenGLMobject):
             return self
         if lower_index == upper_index:
             self.append_points(
-                partial_quadratic_bezier_points(
+                partial_bezier_points(
                     bezier_triplets[lower_index],
                     lower_residue,
                     upper_residue,
@@ -1361,24 +1337,18 @@ class OpenGLVMobject(OpenGLMobject):
             )
         else:
             self.append_points(
-                partial_quadratic_bezier_points(
-                    bezier_triplets[lower_index], lower_residue, 1
-                ),
+                partial_bezier_points(bezier_triplets[lower_index], lower_residue, 1),
             )
             inner_points = bezier_triplets[lower_index + 1 : upper_index]
             if len(inner_points) > 0:
                 if remap:
-                    new_triplets = quadratic_bezier_remap(
-                        inner_points, num_quadratics - 2
-                    )
+                    new_triplets = bezier_remap(inner_points, num_quadratics - 2)
                 else:
                     new_triplets = bezier_triplets
 
                 self.append_points(np.asarray(new_triplets).reshape(-1, 3))
             self.append_points(
-                partial_quadratic_bezier_points(
-                    bezier_triplets[upper_index], 0, upper_residue
-                ),
+                partial_bezier_points(bezier_triplets[upper_index], 0, upper_residue),
             )
         return self
 
@@ -1685,8 +1655,6 @@ class OpenGLVGroup(OpenGLVMobject):
     """
 
     def __init__(self, *vmobjects, **kwargs):
-        if not all(isinstance(m, OpenGLVMobject) for m in vmobjects):
-            raise Exception("All submobjects must be of type OpenGLVMobject")
         super().__init__(**kwargs)
         self.add(*vmobjects)
 
@@ -1752,8 +1720,6 @@ class OpenGLVGroup(OpenGLVMobject):
                         (gr-circle_red).animate.shift(RIGHT)
                     )
         """
-        if not all(isinstance(m, OpenGLVMobject) for m in vmobjects):
-            raise TypeError("All submobjects must be of type OpenGLVMobject")
         return super().add(*vmobjects)
 
     def __add__(self, vmobject):
@@ -1799,8 +1765,7 @@ class OpenGLVGroup(OpenGLVMobject):
 
             >>> config.renderer = original_renderer
         """
-        if not all(isinstance(m, OpenGLVMobject) for m in value):
-            raise TypeError("All submobjects must be of type OpenGLVMobject")
+        self._assert_valid_submobjects(tuplify(value))
         self.submobjects[key] = value
 
 
@@ -1901,10 +1866,7 @@ class OpenGLDashedVMobject(OpenGLVMobject):
         if num_dashes > 0:
             # Assuming total length is 1
             dash_len = r / n
-            if vmobject.is_closed():
-                void_len = (1 - r) / n
-            else:
-                void_len = (1 - r) / (n - 1)
+            void_len = (1 - r) / n if vmobject.is_closed() else (1 - r) / (n - 1)
 
             self.add(
                 *(

manim/mobject/svg/brace.py

@@ -4,7 +4,8 @@ from __future__ import annotations
 
 __all__ = ["Brace", "BraceLabel", "ArcBrace", "BraceText", "BraceBetweenPoints"]
 
-from typing import Sequence
+from collections.abc import Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
 import svgelements as se
@@ -24,6 +25,10 @@ from ...mobject.types.vectorized_mobject import VMobject
 from ...utils.color import BLACK
 from ..svg.svg_mobject import VMobjectFromSVGPath
 
+if TYPE_CHECKING:
+    from manim.typing import Point3DLike, Vector3D
+    from manim.utils.color.core import ParsableManimColor
+
 __all__ = ["Brace", "BraceBetweenPoints", "BraceLabel", "ArcBrace"]
 
 
@@ -65,13 +70,13 @@ class Brace(VMobjectFromSVGPath):
     def __init__(
         self,
         mobject: Mobject,
-        direction: Sequence[float] | None = DOWN,
-        buff=0.2,
-        sharpness=2,
-        stroke_width=0,
-        fill_opacity=1.0,
-        background_stroke_width=0,
-        background_stroke_color=BLACK,
+        direction: Vector3D | None = DOWN,
+        buff: float = 0.2,
+        sharpness: float = 2,
+        stroke_width: float = 0,
+        fill_opacity: float = 1.0,
+        background_stroke_width: float = 0,
+        background_stroke_color: ParsableManimColor = BLACK,
         **kwargs,
     ):
         path_string_template = (
@@ -125,7 +130,20 @@ class Brace(VMobjectFromSVGPath):
         for mob in mobject, self:
             mob.rotate(angle, about_point=ORIGIN)
 
-    def put_at_tip(self, mob, use_next_to=True, **kwargs):
+    def put_at_tip(self, mob: Mobject, use_next_to: bool = True, **kwargs):
+        """Puts the given mobject at the brace tip.
+
+        Parameters
+        ----------
+        mob
+            The mobject to be placed at the tip.
+        use_next_to
+            If true, then :meth:`next_to` is used to place the mobject at the
+            tip.
+        kwargs
+            Any additional keyword arguments are passed to :meth:`next_to` which
+            is used to put the mobject next to the brace tip.
+        """
         if use_next_to:
             mob.next_to(self.get_tip(), np.round(self.get_direction()), **kwargs)
         else:
@@ -136,16 +154,45 @@ class Brace(VMobjectFromSVGPath):
         return self
 
     def get_text(self, *text, **kwargs):
+        """Places the text at the brace tip.
+
+        Parameters
+        ----------
+        text
+            The text to be placed at the brace tip.
+        kwargs
+            Any additional keyword arguments are passed to :meth:`.put_at_tip` which
+            is used to position the text at the brace tip.
+
+        Returns
+        -------
+        :class:`~.Tex`
+        """
         text_mob = Tex(*text)
         self.put_at_tip(text_mob, **kwargs)
         return text_mob
 
     def get_tex(self, *tex, **kwargs):
+        """Places the tex at the brace tip.
+
+        Parameters
+        ----------
+        tex
+            The tex to be placed at the brace tip.
+        kwargs
+            Any further keyword arguments are passed to :meth:`.put_at_tip` which
+            is used to position the tex at the brace tip.
+
+        Returns
+        -------
+        :class:`~.MathTex`
+        """
         tex_mob = MathTex(*tex)
         self.put_at_tip(tex_mob, **kwargs)
         return tex_mob
 
     def get_tip(self):
+        """Returns the point at the brace tip."""
         # Returns the position of the seventh point in the path, which is the tip.
         if config["renderer"] == "opengl":
             return self.points[34]
@@ -153,6 +200,7 @@ class Brace(VMobjectFromSVGPath):
         return self.points[28]  # = 7*4
 
     def get_direction(self):
+        """Returns the direction from the center to the brace tip."""
         vect = self.get_tip() - self.get_center()
         return vect / np.linalg.norm(vect)
 
@@ -201,7 +249,7 @@ class BraceLabel(VMobject, metaclass=ConvertToOpenGL):
         self.brace = Brace(obj, brace_direction, buff, **brace_config)
 
         if isinstance(text, (tuple, list)):
-            self.label = self.label_constructor(font_size=font_size, *text, **kwargs)
+            self.label = self.label_constructor(*text, font_size=font_size, **kwargs)
         else:
             self.label = self.label_constructor(str(text), font_size=font_size)
 
@@ -269,9 +317,9 @@ class BraceBetweenPoints(Brace):
 
     def __init__(
         self,
-        point_1: Sequence[float] | None,
-        point_2: Sequence[float] | None,
-        direction: Sequence[float] | None = ORIGIN,
+        point_1: Point3DLike | None,
+        point_2: Point3DLike | None,
+        direction: Vector3D | None = ORIGIN,
         **kwargs,
     ):
         if all(direction == ORIGIN):

manim/mobject/svg/svg_mobject.py

@@ -264,7 +264,8 @@ class SVGMobject(VMobject, metaclass=ConvertToOpenGL):
         """
         result = []
         for shape in svg.elements():
-            if isinstance(shape, se.Group):
+            # can we combine the two continue cases into one?
+            if isinstance(shape, se.Group):  # noqa: SIM114
                 continue
             elif isinstance(shape, se.Path):
                 mob = self.path_to_mobject(shape)

manim/mobject/table.py

@@ -65,7 +65,8 @@ __all__ = [
 
 
 import itertools as it
-from typing import Callable, Iterable, Sequence
+from collections.abc import Iterable, Sequence
+from typing import Callable
 
 from manim.mobject.geometry.line import Line
 from manim.mobject.geometry.polygram import Polygon
@@ -84,7 +85,7 @@ from .utils import get_vectorized_mobject_class
 
 
 class Table(VGroup):
-    """A mobject that displays a table on the screen.
+    r"""A mobject that displays a table on the screen.
 
     Parameters
     ----------
@@ -682,7 +683,6 @@ class Table(VGroup):
                         item.set_color(random_bright_color())
                     self.add(table)
         """
-
         return VGroup(*self.row_labels)
 
     def get_col_labels(self) -> VGroup:
@@ -711,7 +711,6 @@ class Table(VGroup):
                         item.set_color(random_bright_color())
                     self.add(table)
         """
-
         return VGroup(*self.col_labels)
 
     def get_labels(self) -> VGroup:
@@ -1066,7 +1065,7 @@ class MobjectTable(Table):
 
 
 class IntegerTable(Table):
-    """A specialized :class:`~.Table` mobject for use with :class:`~.Integer`.
+    r"""A specialized :class:`~.Table` mobject for use with :class:`~.Integer`.
 
     Examples
     --------
@@ -1080,14 +1079,14 @@ class IntegerTable(Table):
                     [[0,30,45,60,90],
                     [90,60,45,30,0]],
                     col_labels=[
-                        MathTex("\\\\frac{\\sqrt{0}}{2}"),
-                        MathTex("\\\\frac{\\sqrt{1}}{2}"),
-                        MathTex("\\\\frac{\\sqrt{2}}{2}"),
-                        MathTex("\\\\frac{\\sqrt{3}}{2}"),
-                        MathTex("\\\\frac{\\sqrt{4}}{2}")],
-                    row_labels=[MathTex("\\sin"), MathTex("\\cos")],
+                        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": "^{\\circ}"})
+                    element_to_mobject_config={"unit": r"^{\circ}"})
                 self.add(t0)
     """