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

manim/mobject/geometry/polygram.py

@@ -13,6 +13,7 @@ __all__ = [
     "Square",
     "RoundedRectangle",
     "Cutout",
+    "ConvexHull",
 ]
 
 
@@ -27,12 +28,22 @@ from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.mobject.types.vectorized_mobject import VGroup, VMobject
 from manim.utils.color import BLUE, WHITE, ParsableManimColor
 from manim.utils.iterables import adjacent_n_tuples, adjacent_pairs
+from manim.utils.qhull import QuickHull
 from manim.utils.space_ops import angle_between_vectors, normalize, regular_vertices
 
 if TYPE_CHECKING:
+    from typing import Any, Literal
+
+    import numpy.typing as npt
     from typing_extensions import Self
 
-    from manim.typing import Point3D, Point3D_Array
+    from manim.typing import (
+        ManimFloat,
+        Point3D,
+        Point3D_Array,
+        Point3DLike,
+        Point3DLike_Array,
+    )
     from manim.utils.color import ParsableManimColor
 
 
@@ -72,11 +83,16 @@ class Polygram(VMobject, metaclass=ConvertToOpenGL):
     """
 
     def __init__(
-        self, *vertex_groups: Point3D, color: ParsableManimColor = BLUE, **kwargs
+        self,
+        *vertex_groups: Point3DLike_Array,
+        color: ParsableManimColor = BLUE,
+        **kwargs: Any,
     ):
         super().__init__(color=color, **kwargs)
 
         for vertices in vertex_groups:
+            # The inferred type for *vertices is Any, but it should be
+            # Point3D_Array
             first_vertex, *vertices = vertices
             first_vertex = np.array(first_vertex)
 
@@ -104,10 +120,9 @@ class Polygram(VMobject, metaclass=ConvertToOpenGL):
                    [-1., -1.,  0.],
                    [ 1., -1.,  0.]])
         """
-
         return self.get_start_anchors()
 
-    def get_vertex_groups(self) -> np.ndarray[Point3D_Array]:
+    def get_vertex_groups(self) -> npt.NDArray[ManimFloat]:
         """Gets the vertex groups of the :class:`Polygram`.
 
         Returns
@@ -129,7 +144,6 @@ class Polygram(VMobject, metaclass=ConvertToOpenGL):
                     [-1.,  1.,  0.],
                     [-2.,  0.,  0.]]])
         """
-
         vertex_groups = []
 
         group = []
@@ -204,11 +218,10 @@ class Polygram(VMobject, metaclass=ConvertToOpenGL):
                     shapes.arrange(RIGHT)
                     self.add(shapes)
         """
-
         if radius == 0:
             return self
 
-        new_points = []
+        new_points: list[Point3D] = []
 
         for vertices in self.get_vertex_groups():
             arcs = []
@@ -277,7 +290,7 @@ class Polygram(VMobject, metaclass=ConvertToOpenGL):
 
                 new_points.extend(line.points)
 
-        self.set_points(new_points)
+        self.set_points(np.array(new_points))
 
         return self
 
@@ -312,7 +325,7 @@ class Polygon(Polygram):
                 self.add(isosceles, square_and_triangles)
     """
 
-    def __init__(self, *vertices: Point3D, **kwargs) -> None:
+    def __init__(self, *vertices: Point3DLike, **kwargs: Any) -> None:
         super().__init__(vertices, **kwargs)
 
 
@@ -355,7 +368,7 @@ class RegularPolygram(Polygram):
         density: int = 2,
         radius: float = 1,
         start_angle: float | None = None,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         # Regular polygrams can be expressed by the number of their vertices
         # and their density. This relation can be expressed as its Schläfli
@@ -376,7 +389,7 @@ class RegularPolygram(Polygram):
 
         # Utility function for generating the individual
         # polygon vertices.
-        def gen_polygon_vertices(start_angle):
+        def gen_polygon_vertices(start_angle: float | None) -> tuple[list[Any], float]:
             reg_vertices, start_angle = regular_vertices(
                 num_vertices,
                 radius=radius,
@@ -432,7 +445,7 @@ class RegularPolygon(RegularPolygram):
                 self.add(poly_group)
     """
 
-    def __init__(self, n: int = 6, **kwargs) -> None:
+    def __init__(self, n: int = 6, **kwargs: Any) -> None:
         super().__init__(n, density=1, **kwargs)
 
 
@@ -472,7 +485,6 @@ class Star(Polygon):
     Examples
     --------
     .. manim:: StarExample
-        :save_as_gif:
 
         class StarExample(Scene):
             def construct(self):
@@ -503,7 +515,7 @@ class Star(Polygon):
         inner_radius: float | None = None,
         density: int = 2,
         start_angle: float | None = TAU / 4,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         inner_angle = TAU / (2 * n)
 
@@ -535,7 +547,7 @@ class Star(Polygon):
             start_angle=self.start_angle + inner_angle,
         )
 
-        vertices = []
+        vertices: list[npt.NDArray] = []
         for pair in zip(outer_vertices, inner_vertices):
             vertices.extend(pair)
 
@@ -563,7 +575,7 @@ class Triangle(RegularPolygon):
                 self.add(tri_group)
     """
 
-    def __init__(self, **kwargs) -> None:
+    def __init__(self, **kwargs: Any) -> None:
         super().__init__(n=3, **kwargs)
 
 
@@ -614,7 +626,7 @@ class Rectangle(Polygon):
         grid_ystep: float | None = None,
         mark_paths_closed: bool = True,
         close_new_points: bool = True,
-        **kwargs,
+        **kwargs: Any,
     ):
         super().__init__(UR, UL, DL, DR, color=color, **kwargs)
         self.stretch_to_fit_width(width)
@@ -685,10 +697,17 @@ class Square(Rectangle):
                 self.add(square_1, square_2, square_3)
     """
 
-    def __init__(self, side_length: float = 2.0, **kwargs) -> None:
-        self.side_length = side_length
+    def __init__(self, side_length: float = 2.0, **kwargs: Any) -> None:
         super().__init__(height=side_length, width=side_length, **kwargs)
 
+    @property
+    def side_length(self) -> float:
+        return float(np.linalg.norm(self.get_vertices()[0] - self.get_vertices()[1]))
+
+    @side_length.setter
+    def side_length(self, value: float) -> None:
+        self.scale(value / self.side_length)
+
 
 class RoundedRectangle(Rectangle):
     """A rectangle with rounded corners.
@@ -714,7 +733,7 @@ class RoundedRectangle(Rectangle):
                 self.add(rect_group)
     """
 
-    def __init__(self, corner_radius: float | list[float] = 0.5, **kwargs):
+    def __init__(self, corner_radius: float | list[float] = 0.5, **kwargs: Any):
         super().__init__(**kwargs)
         self.corner_radius = corner_radius
         self.round_corners(self.corner_radius)
@@ -755,12 +774,77 @@ class Cutout(VMobject, metaclass=ConvertToOpenGL):
                 self.wait()
     """
 
-    def __init__(self, main_shape: VMobject, *mobjects: VMobject, **kwargs) -> None:
+    def __init__(
+        self, main_shape: VMobject, *mobjects: VMobject, **kwargs: Any
+    ) -> None:
         super().__init__(**kwargs)
         self.append_points(main_shape.points)
-        if main_shape.get_direction() == "CW":
-            sub_direction = "CCW"
-        else:
-            sub_direction = "CW"
+        sub_direction: Literal["CCW", "CW"] = (
+            "CCW" if main_shape.get_direction() == "CW" else "CW"
+        )
         for mobject in mobjects:
             self.append_points(mobject.force_direction(sub_direction).points)
+
+
+class ConvexHull(Polygram):
+    """Constructs a convex hull for a set of points in no particular order.
+
+    Parameters
+    ----------
+    points
+        The points to consider.
+    tolerance
+        The tolerance used by quickhull.
+    kwargs
+        Forwarded to the parent constructor.
+
+    Examples
+    --------
+    .. manim:: ConvexHullExample
+        :save_last_frame:
+        :quality: high
+
+        class ConvexHullExample(Scene):
+            def construct(self):
+                points = [
+                    [-2.35, -2.25, 0],
+                    [1.65, -2.25, 0],
+                    [2.65, -0.25, 0],
+                    [1.65, 1.75, 0],
+                    [-0.35, 2.75, 0],
+                    [-2.35, 0.75, 0],
+                    [-0.35, -1.25, 0],
+                    [0.65, -0.25, 0],
+                    [-1.35, 0.25, 0],
+                    [0.15, 0.75, 0]
+                ]
+                hull = ConvexHull(*points, color=BLUE)
+                dots = VGroup(*[Dot(point) for point in points])
+                self.add(hull)
+                self.add(dots)
+    """
+
+    def __init__(
+        self, *points: Point3DLike, tolerance: float = 1e-5, **kwargs: Any
+    ) -> None:
+        # Build Convex Hull
+        array = np.array(points)[:, :2]
+        hull = QuickHull(tolerance)
+        hull.build(array)
+
+        # Extract Vertices
+        facets = set(hull.facets) - hull.removed
+        facet = facets.pop()
+        subfacets = list(facet.subfacets)
+        while len(subfacets) <= len(facets):
+            sf = subfacets[-1]
+            (facet,) = hull.neighbors[sf] - {facet}
+            (sf,) = facet.subfacets - {sf}
+            subfacets.append(sf)
+
+        # Setup Vertices as Point3D
+        coordinates = np.vstack([sf.coordinates for sf in subfacets])
+        vertices = np.hstack((coordinates, np.zeros((len(coordinates), 1))))
+
+        # Call Polygram
+        super().__init__(vertices, **kwargs)

manim/mobject/geometry/shape_matchers.py

@@ -8,8 +8,15 @@ from typing import Any
 
 from typing_extensions import Self
 
-from manim import config, logger
-from manim.constants import *
+from manim import logger
+from manim._config import config
+from manim.constants import (
+    DOWN,
+    LEFT,
+    RIGHT,
+    SMALL_BUFF,
+    UP,
+)
 from manim.mobject.geometry.line import Line
 from manim.mobject.geometry.polygram import RoundedRectangle
 from manim.mobject.mobject import Mobject
@@ -43,21 +50,29 @@ class SurroundingRectangle(RoundedRectangle):
 
     def __init__(
         self,
-        mobject: Mobject,
+        *mobjects: Mobject,
         color: ParsableManimColor = YELLOW,
         buff: float = SMALL_BUFF,
         corner_radius: float = 0.0,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
+        from manim.mobject.mobject import Group
+
+        if not all(isinstance(mob, Mobject) for mob in mobjects):
+            raise TypeError(
+                "Expected all inputs for parameter mobjects to be a Mobjects"
+            )
+
+        group = Group(*mobjects)
         super().__init__(
             color=color,
-            width=mobject.width + 2 * buff,
-            height=mobject.height + 2 * buff,
+            width=group.width + 2 * buff,
+            height=group.height + 2 * buff,
             corner_radius=corner_radius,
             **kwargs,
         )
         self.buff = buff
-        self.move_to(mobject)
+        self.move_to(group)
 
 
 class BackgroundRectangle(SurroundingRectangle):
@@ -87,19 +102,19 @@ class BackgroundRectangle(SurroundingRectangle):
 
     def __init__(
         self,
-        mobject: Mobject,
+        *mobjects: Mobject,
         color: ParsableManimColor | None = None,
         stroke_width: float = 0,
         stroke_opacity: float = 0,
         fill_opacity: float = 0.75,
         buff: float = 0,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> None:
         if color is None:
             color = config.background_color
 
         super().__init__(
-            mobject,
+            *mobjects,
             color=color,
             stroke_width=stroke_width,
             stroke_opacity=stroke_opacity,
@@ -113,7 +128,7 @@ class BackgroundRectangle(SurroundingRectangle):
         self.set_fill(opacity=b * self.original_fill_opacity)
         return self
 
-    def set_style(self, fill_opacity: float, **kwargs) -> Self:
+    def set_style(self, fill_opacity: float, **kwargs: Any) -> Self:  # type: ignore[override]
         # Unchangeable style, except for fill_opacity
         # All other style arguments are ignored
         super().set_style(
@@ -130,7 +145,10 @@ class BackgroundRectangle(SurroundingRectangle):
         return self
 
     def get_fill_color(self) -> ManimColor:
-        return self.color
+        # The type of the color property is set to Any using the property decorator
+        # vectorized_mobject.py#L571
+        temp_color: ManimColor = self.color
+        return temp_color
 
 
 class Cross(VGroup):
@@ -164,7 +182,7 @@ class Cross(VGroup):
         stroke_color: ParsableManimColor = RED,
         stroke_width: float = 6.0,
         scale_factor: float = 1.0,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         super().__init__(
             Line(UP + LEFT, DOWN + RIGHT), Line(UP + RIGHT, DOWN + LEFT), **kwargs
@@ -190,7 +208,9 @@ class Underline(Line):
                 self.add(man, ul)
     """
 
-    def __init__(self, mobject: Mobject, buff: float = SMALL_BUFF, **kwargs) -> None:
+    def __init__(
+        self, mobject: Mobject, buff: float = SMALL_BUFF, **kwargs: Any
+    ) -> None:
         super().__init__(LEFT, RIGHT, buff=buff, **kwargs)
         self.match_width(mobject)
         self.next_to(mobject, DOWN, buff=self.buff)

manim/mobject/geometry/tips.py

@@ -25,6 +25,8 @@ from manim.mobject.types.vectorized_mobject import VMobject
 from manim.utils.space_ops import angle_of_vector
 
 if TYPE_CHECKING:
+    from typing import Any
+
     from manim.typing import Point3D, Vector3D
 
 
@@ -60,8 +62,9 @@ class ArrowTip(VMobject, metaclass=ConvertToOpenGL):
         ...         RegularPolygon.__init__(self, n=5, **kwargs)
         ...         self.width = length
         ...         self.stretch_to_fit_height(length)
-        >>> arr = Arrow(np.array([-2, -2, 0]), np.array([2, 2, 0]),
-        ...             tip_shape=MyCustomArrowTip)
+        >>> arr = Arrow(
+        ...     np.array([-2, -2, 0]), np.array([2, 2, 0]), tip_shape=MyCustomArrowTip
+        ... )
         >>> isinstance(arr.tip, RegularPolygon)
         True
         >>> from manim import Scene, Create
@@ -111,7 +114,7 @@ class ArrowTip(VMobject, metaclass=ConvertToOpenGL):
                 self.add(*big_arrows, *small_arrows, *labels)
     """
 
-    def __init__(self, *args, **kwargs) -> None:
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
         raise NotImplementedError("Has to be implemented in inheriting subclasses.")
 
     @property
@@ -146,7 +149,11 @@ class ArrowTip(VMobject, metaclass=ConvertToOpenGL):
             array([2., 0., 0.])
 
         """
-        return self.points[0]
+        # Type inference of extracting an element from a list, is not
+        # supported by numpy, see this numpy issue
+        # https://github.com/numpy/numpy/issues/16544
+        tip_point: Point3D = self.points[0]
+        return tip_point
 
     @property
     def vector(self) -> Vector3D:
@@ -174,14 +181,14 @@ class ArrowTip(VMobject, metaclass=ConvertToOpenGL):
 
             >>> from manim import Arrow
             >>> arrow = Arrow(np.array([0, 0, 0]), np.array([1, 1, 0]), buff=0)
-            >>> round(arrow.tip.tip_angle, 5) == round(PI/4, 5)
+            >>> bool(round(arrow.tip.tip_angle, 5) == round(PI/4, 5))
             True
 
         """
         return angle_of_vector(self.vector)
 
     @property
-    def length(self) -> np.floating:
+    def length(self) -> float:
         r"""The length of the arrow tip.
 
         Examples
@@ -194,7 +201,7 @@ class ArrowTip(VMobject, metaclass=ConvertToOpenGL):
             0.35
 
         """
-        return np.linalg.norm(self.vector)
+        return float(np.linalg.norm(self.vector))
 
 
 class StealthTip(ArrowTip):
@@ -206,36 +213,38 @@ class StealthTip(ArrowTip):
 
     def __init__(
         self,
-        fill_opacity=1,
-        stroke_width=3,
-        length=DEFAULT_ARROW_TIP_LENGTH / 2,
-        start_angle=PI,
-        **kwargs,
+        fill_opacity: float = 1,
+        stroke_width: float = 3,
+        length: float = DEFAULT_ARROW_TIP_LENGTH / 2,
+        start_angle: float = PI,
+        **kwargs: Any,
     ):
         self.start_angle = start_angle
         VMobject.__init__(
             self, fill_opacity=fill_opacity, stroke_width=stroke_width, **kwargs
         )
         self.set_points_as_corners(
-            [
-                [2, 0, 0],  # tip
-                [-1.2, 1.6, 0],
-                [0, 0, 0],  # base
-                [-1.2, -1.6, 0],
-                [2, 0, 0],  # close path, back to tip
-            ]
+            np.array(
+                [
+                    [2, 0, 0],  # tip
+                    [-1.2, 1.6, 0],
+                    [0, 0, 0],  # base
+                    [-1.2, -1.6, 0],
+                    [2, 0, 0],  # close path, back to tip
+                ]
+            )
         )
         self.scale(length / self.length)
 
     @property
-    def length(self):
+    def length(self) -> float:
         """The length of the arrow tip.
 
         In this case, the length is computed as the height of
         the triangle encompassing the stealth tip (otherwise,
         the tip is scaled too large).
         """
-        return np.linalg.norm(self.vector) * 1.6
+        return float(np.linalg.norm(self.vector) * 1.6)
 
 
 class ArrowTriangleTip(ArrowTip, Triangle):
@@ -248,7 +257,7 @@ class ArrowTriangleTip(ArrowTip, Triangle):
         length: float = DEFAULT_ARROW_TIP_LENGTH,
         width: float = DEFAULT_ARROW_TIP_LENGTH,
         start_angle: float = PI,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         Triangle.__init__(
             self,
@@ -270,7 +279,7 @@ class ArrowTriangleFilledTip(ArrowTriangleTip):
     """
 
     def __init__(
-        self, fill_opacity: float = 1, stroke_width: float = 0, **kwargs
+        self, fill_opacity: float = 1, stroke_width: float = 0, **kwargs: Any
     ) -> None:
         super().__init__(fill_opacity=fill_opacity, stroke_width=stroke_width, **kwargs)
 
@@ -284,7 +293,7 @@ class ArrowCircleTip(ArrowTip, Circle):
         stroke_width: float = 3,
         length: float = DEFAULT_ARROW_TIP_LENGTH,
         start_angle: float = PI,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         self.start_angle = start_angle
         Circle.__init__(
@@ -298,7 +307,7 @@ class ArrowCircleFilledTip(ArrowCircleTip):
     r"""Circular arrow tip with filled tip."""
 
     def __init__(
-        self, fill_opacity: float = 1, stroke_width: float = 0, **kwargs
+        self, fill_opacity: float = 1, stroke_width: float = 0, **kwargs: Any
     ) -> None:
         super().__init__(fill_opacity=fill_opacity, stroke_width=stroke_width, **kwargs)
 
@@ -312,7 +321,7 @@ class ArrowSquareTip(ArrowTip, Square):
         stroke_width: float = 3,
         length: float = DEFAULT_ARROW_TIP_LENGTH,
         start_angle: float = PI,
-        **kwargs,
+        **kwargs: Any,
     ) -> None:
         self.start_angle = start_angle
         Square.__init__(
@@ -330,6 +339,6 @@ class ArrowSquareFilledTip(ArrowSquareTip):
     r"""Square arrow tip with filled tip."""
 
     def __init__(
-        self, fill_opacity: float = 1, stroke_width: float = 0, **kwargs
+        self, fill_opacity: float = 1, stroke_width: float = 0, **kwargs: Any
     ) -> None:
         super().__init__(fill_opacity=fill_opacity, stroke_width=stroke_width, **kwargs)