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

manim/mobject/geometry/arc.py

@@ -43,17 +43,16 @@ __all__ = [
 ]
 
 import itertools
-import math
 import warnings
-from typing import TYPE_CHECKING, Sequence
+from typing import TYPE_CHECKING
 
 import numpy as np
-from colour import Color
+from typing_extensions import Self
 
 from manim.constants import *
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
-from manim.mobject.types.vectorized_mobject import VMobject
-from manim.utils.color import *
+from manim.mobject.types.vectorized_mobject import VGroup, VMobject
+from manim.utils.color import BLACK, BLUE, RED, WHITE, ParsableManimColor
 from manim.utils.iterables import adjacent_pairs
 from manim.utils.space_ops import (
     angle_of_vector,
@@ -64,9 +63,11 @@ from manim.utils.space_ops import (
 )
 
 if TYPE_CHECKING:
+    import manim.mobject.geometry.tips as tips
     from manim.mobject.mobject import Mobject
     from manim.mobject.text.tex_mobject import SingleStringMathTex, Tex
     from manim.mobject.text.text_mobject import Text
+    from manim.typing import CubicBezierPoints, Point3D, QuadraticBezierPoints, Vector
 
 
 class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
@@ -89,21 +90,26 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
 
     def __init__(
         self,
-        tip_length=DEFAULT_ARROW_TIP_LENGTH,
-        normal_vector=OUT,
-        tip_style={},
+        tip_length: float = DEFAULT_ARROW_TIP_LENGTH,
+        normal_vector: Vector = OUT,
+        tip_style: dict = {},
         **kwargs,
-    ):
-        self.tip_length = tip_length
-        self.normal_vector = normal_vector
-        self.tip_style = tip_style
+    ) -> None:
+        self.tip_length: float = tip_length
+        self.normal_vector: Vector = normal_vector
+        self.tip_style: dict = tip_style
         super().__init__(**kwargs)
 
     # Adding, Creating, Modifying tips
 
     def add_tip(
-        self, tip=None, tip_shape=None, tip_length=None, tip_width=None, at_start=False
-    ):
+        self,
+        tip: tips.ArrowTip | None = None,
+        tip_shape: type[tips.ArrowTip] | None = None,
+        tip_length: float | None = None,
+        tip_width: float | None = None,
+        at_start: bool = False,
+    ) -> Self:
         """Adds a tip to the TipableVMobject instance, recognising
         that the endpoints might need to be switched if it's
         a 'starting tip' or not.
@@ -118,7 +124,11 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
         return self
 
     def create_tip(
-        self, tip_shape=None, tip_length=None, tip_width=None, at_start=False
+        self,
+        tip_shape: type[tips.ArrowTip] | None = None,
+        tip_length: float = None,
+        tip_width: float = None,
+        at_start: bool = False,
     ):
         """Stylises the tip, positions it spatially, and returns
         the newly instantiated tip to the caller.
@@ -127,7 +137,12 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
         self.position_tip(tip, at_start)
         return tip
 
-    def get_unpositioned_tip(self, tip_shape=None, tip_length=None, tip_width=None):
+    def get_unpositioned_tip(
+        self,
+        tip_shape: type[tips.ArrowTip] | None = None,
+        tip_length: float | None = None,
+        tip_width: float | None = None,
+    ):
         """Returns a tip that has been stylistically configured,
         but has not yet been given a position in space.
         """
@@ -151,7 +166,7 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
         tip = tip_shape(length=tip_length, **style)
         return tip
 
-    def position_tip(self, tip, at_start=False):
+    def position_tip(self, tip: tips.ArrowTip, at_start: bool = False):
         # Last two control points, defining both
         # the end, and the tangency direction
         if at_start:
@@ -178,7 +193,7 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
         tip.shift(anchor - tip.tip_point)
         return tip
 
-    def reset_endpoints_based_on_tip(self, tip, at_start):
+    def reset_endpoints_based_on_tip(self, tip: tips.ArrowTip, at_start: bool) -> Self:
         if self.get_length() == 0:
             # Zero length, put_start_and_end_on wouldn't work
             return self
@@ -189,7 +204,7 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
             self.put_start_and_end_on(self.get_start(), tip.base)
         return self
 
-    def asign_tip_attr(self, tip, at_start):
+    def asign_tip_attr(self, tip: tips.ArrowTip, at_start: bool) -> Self:
         if at_start:
             self.start_tip = tip
         else:
@@ -198,15 +213,15 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
 
     # Checking for tips
 
-    def has_tip(self):
+    def has_tip(self) -> bool:
         return hasattr(self, "tip") and self.tip in self
 
-    def has_start_tip(self):
+    def has_start_tip(self) -> bool:
         return hasattr(self, "start_tip") and self.start_tip in self
 
     # Getters
 
-    def pop_tips(self):
+    def pop_tips(self) -> VGroup:
         start, end = self.get_start_and_end()
         result = self.get_group_class()()
         if self.has_tip():
@@ -218,7 +233,7 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
         self.put_start_and_end_on(start, end)
         return result
 
-    def get_tips(self):
+    def get_tips(self) -> VGroup:
         """Returns a VGroup (collection of VMobjects) containing
         the TipableVMObject instance's tips.
         """
@@ -238,28 +253,28 @@ class TipableVMobject(VMobject, metaclass=ConvertToOpenGL):
         else:
             return tips[0]
 
-    def get_default_tip_length(self):
+    def get_default_tip_length(self) -> float:
         return self.tip_length
 
-    def get_first_handle(self):
+    def get_first_handle(self) -> Point3D:
         return self.points[1]
 
-    def get_last_handle(self):
+    def get_last_handle(self) -> Point3D:
         return self.points[-2]
 
-    def get_end(self):
+    def get_end(self) -> Point3D:
         if self.has_tip():
             return self.tip.get_start()
         else:
             return super().get_end()
 
-    def get_start(self):
+    def get_start(self) -> Point3D:
         if self.has_start_tip():
             return self.start_tip.get_start()
         else:
             return super().get_start()
 
-    def get_length(self):
+    def get_length(self) -> np.floating:
         start, end = self.get_start_and_end()
         return np.linalg.norm(start - end)
 
@@ -282,23 +297,23 @@ class Arc(TipableVMobject):
     def __init__(
         self,
         radius: float = 1.0,
-        start_angle=0,
-        angle=TAU / 4,
-        num_components=9,
-        arc_center=ORIGIN,
+        start_angle: float = 0,
+        angle: float = TAU / 4,
+        num_components: int = 9,
+        arc_center: Point3D = ORIGIN,
         **kwargs,
     ):
         if radius is None:  # apparently None is passed by ArcBetweenPoints
             radius = 1.0
         self.radius = radius
-        self.num_components = num_components
-        self.arc_center = arc_center
-        self.start_angle = start_angle
-        self.angle = angle
-        self._failed_to_get_center = False
+        self.num_components: int = num_components
+        self.arc_center: Point3D = arc_center
+        self.start_angle: float = start_angle
+        self.angle: float = angle
+        self._failed_to_get_center: bool = False
         super().__init__(**kwargs)
 
-    def generate_points(self):
+    def generate_points(self) -> None:
         self._set_pre_positioned_points()
         self.scale(self.radius, about_point=ORIGIN)
         self.shift(self.arc_center)
@@ -306,7 +321,7 @@ class Arc(TipableVMobject):
     # Points are set a bit differently when rendering via OpenGL.
     # TODO: refactor Arc so that only one strategy for setting points
     # has to be used.
-    def init_points(self):
+    def init_points(self) -> None:
         self.set_points(
             Arc._create_quadratic_bezier_points(
                 angle=self.angle,
@@ -318,7 +333,9 @@ class Arc(TipableVMobject):
         self.shift(self.arc_center)
 
     @staticmethod
-    def _create_quadratic_bezier_points(angle, start_angle=0, n_components=8):
+    def _create_quadratic_bezier_points(
+        angle: float, start_angle: float = 0, n_components: int = 8
+    ) -> QuadraticBezierPoints:
         samples = np.array(
             [
                 [np.cos(a), np.sin(a), 0]
@@ -338,7 +355,7 @@ class Arc(TipableVMobject):
         points[2::3] = samples[2::2]
         return points
 
-    def _set_pre_positioned_points(self):
+    def _set_pre_positioned_points(self) -> None:
         anchors = np.array(
             [
                 np.cos(a) * RIGHT + np.sin(a) * UP
@@ -361,7 +378,7 @@ class Arc(TipableVMobject):
         handles2 = anchors[1:] - (d_theta / 3) * tangent_vectors[1:]
         self.set_anchors_and_handles(anchors[:-1], handles1, handles2, anchors[1:])
 
-    def get_arc_center(self, warning=True):
+    def get_arc_center(self, warning: bool = True) -> Point3D:
         """Looks at the normals to the first two
         anchors, and finds their intersection points
         """
@@ -387,11 +404,11 @@ class Arc(TipableVMobject):
             self._failed_to_get_center = True
             return np.array(ORIGIN)
 
-    def move_arc_center_to(self, point):
+    def move_arc_center_to(self, point: Point3D) -> Self:
         self.shift(point - self.get_arc_center())
         return self
 
-    def stop_angle(self):
+    def stop_angle(self) -> float:
         return angle_of_vector(self.points[-1] - self.get_arc_center()) % TAU
 
 
@@ -414,7 +431,14 @@ class ArcBetweenPoints(Arc):
               self.play(Create(arc))
     """
 
-    def __init__(self, start, end, angle=TAU / 4, radius=None, **kwargs):
+    def __init__(
+        self,
+        start: Point3D,
+        end: Point3D,
+        angle: float = TAU / 4,
+        radius: float = None,
+        **kwargs,
+    ) -> None:
         if radius is not None:
             self.radius = radius
             if radius < 0:
@@ -428,8 +452,8 @@ class ArcBetweenPoints(Arc):
                     """ArcBetweenPoints called with a radius that is
                             smaller than half the distance between the points.""",
                 )
-            arc_height = radius - math.sqrt(radius**2 - halfdist**2)
-            angle = math.acos((radius - arc_height) / radius) * sign
+            arc_height = radius - np.sqrt(radius**2 - halfdist**2)
+            angle = np.arccos((radius - arc_height) / radius) * sign
 
         super().__init__(radius=radius, angle=angle, **kwargs)
         if angle == 0:
@@ -441,11 +465,11 @@ class ArcBetweenPoints(Arc):
             if not self._failed_to_get_center:
                 self.radius = np.linalg.norm(np.array(start) - np.array(center))
             else:
-                self.radius = math.inf
+                self.radius = np.inf
 
 
 class CurvedArrow(ArcBetweenPoints):
-    def __init__(self, start_point, end_point, **kwargs):
+    def __init__(self, start_point: Point3D, end_point: Point3D, **kwargs) -> None:
         from manim.mobject.geometry.tips import ArrowTriangleFilledTip
 
         tip_shape = kwargs.pop("tip_shape", ArrowTriangleFilledTip)
@@ -454,7 +478,7 @@ class CurvedArrow(ArcBetweenPoints):
 
 
 class CurvedDoubleArrow(CurvedArrow):
-    def __init__(self, start_point, end_point, **kwargs):
+    def __init__(self, start_point: Point3D, end_point: Point3D, **kwargs) -> None:
         if "tip_shape_end" in kwargs:
             kwargs["tip_shape"] = kwargs.pop("tip_shape_end")
         from manim.mobject.geometry.tips import ArrowTriangleFilledTip
@@ -492,9 +516,9 @@ class Circle(Arc):
     def __init__(
         self,
         radius: float | None = None,
-        color: Color | str = RED,
+        color: ParsableManimColor = RED,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(
             radius=radius,
             start_angle=0,
@@ -509,7 +533,7 @@ class Circle(Arc):
         dim_to_match: int = 0,
         stretch: bool = False,
         buffer_factor: float = 1.2,
-    ):
+    ) -> Self:
         """Modifies a circle so that it surrounds a given mobject.
 
         Parameters
@@ -556,7 +580,7 @@ class Circle(Arc):
         self.width = np.sqrt(mobject.width**2 + mobject.height**2)
         return self.scale(buffer_factor)
 
-    def point_at_angle(self, angle: float):
+    def point_at_angle(self, angle: float) -> Point3D:
         """Returns the position of a point on the circle.
 
         Parameters
@@ -588,13 +612,11 @@ class Circle(Arc):
 
         start_angle = angle_of_vector(self.points[0] - self.get_center())
         proportion = (angle - start_angle) / TAU
-        proportion -= math.floor(proportion)
+        proportion -= np.floor(proportion)
         return self.point_from_proportion(proportion)
 
     @staticmethod
-    def from_three_points(
-        p1: Sequence[float], p2: Sequence[float], p3: Sequence[float], **kwargs
-    ):
+    def from_three_points(p1: Point3D, p2: Point3D, p3: Point3D, **kwargs) -> Self:
         """Returns a circle passing through the specified
         three points.
 
@@ -654,13 +676,13 @@ class Dot(Circle):
 
     def __init__(
         self,
-        point: list | np.ndarray = ORIGIN,
+        point: Point3D = ORIGIN,
         radius: float = DEFAULT_DOT_RADIUS,
         stroke_width: float = 0,
         fill_opacity: float = 1.0,
-        color: Color | str = WHITE,
+        color: ParsableManimColor = WHITE,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(
             arc_center=point,
             radius=radius,
@@ -677,11 +699,11 @@ class AnnotationDot(Dot):
     def __init__(
         self,
         radius: float = DEFAULT_DOT_RADIUS * 1.3,
-        stroke_width=5,
-        stroke_color=WHITE,
-        fill_color=BLUE,
+        stroke_width: float = 5,
+        stroke_color: ParsableManimColor = WHITE,
+        fill_color: ParsableManimColor = BLUE,
         **kwargs,
-    ):
+    ) -> None:
         super().__init__(
             radius=radius,
             stroke_width=stroke_width,
@@ -770,14 +792,16 @@ class Ellipse(Circle):
                 self.add(ellipse_group)
     """
 
-    def __init__(self, width: float = 2, height: float = 1, **kwargs):
+    def __init__(self, width: float = 2, height: float = 1, **kwargs) -> None:
         super().__init__(**kwargs)
         self.stretch_to_fit_width(width)
         self.stretch_to_fit_height(height)
 
 
 class AnnularSector(Arc):
-    """
+    """A sector of an annulus.
+
+
     Parameters
     ----------
     inner_radius
@@ -822,15 +846,15 @@ class AnnularSector(Arc):
 
     def __init__(
         self,
-        inner_radius=1,
-        outer_radius=2,
-        angle=TAU / 4,
-        start_angle=0,
-        fill_opacity=1,
-        stroke_width=0,
-        color=WHITE,
+        inner_radius: float = 1,
+        outer_radius: float = 2,
+        angle: float = TAU / 4,
+        start_angle: float = 0,
+        fill_opacity: float = 1,
+        stroke_width: float = 0,
+        color: ParsableManimColor = WHITE,
         **kwargs,
-    ):
+    ) -> None:
         self.inner_radius = inner_radius
         self.outer_radius = outer_radius
         super().__init__(
@@ -842,7 +866,7 @@ class AnnularSector(Arc):
             **kwargs,
         )
 
-    def generate_points(self):
+    def generate_points(self) -> None:
         inner_arc, outer_arc = (
             Arc(
                 start_angle=self.start_angle,
@@ -862,7 +886,8 @@ class AnnularSector(Arc):
 
 
 class Sector(AnnularSector):
-    """
+    """A sector of a circle.
+
     Examples
     --------
     .. manim:: ExampleSector
@@ -877,7 +902,9 @@ class Sector(AnnularSector):
                 self.add(sector, sector2)
     """
 
-    def __init__(self, outer_radius=1, inner_radius=0, **kwargs):
+    def __init__(
+        self, outer_radius: float = 1, inner_radius: float = 0, **kwargs
+    ) -> None:
         super().__init__(inner_radius=inner_radius, outer_radius=outer_radius, **kwargs)
 
 
@@ -909,12 +936,12 @@ class Annulus(Circle):
         self,
         inner_radius: float | None = 1,
         outer_radius: float | None = 2,
-        fill_opacity=1,
-        stroke_width=0,
-        color=WHITE,
-        mark_paths_closed=False,
+        fill_opacity: float = 1,
+        stroke_width: float = 0,
+        color: ParsableManimColor = WHITE,
+        mark_paths_closed: bool = False,
         **kwargs,
-    ):
+    ) -> None:
         self.mark_paths_closed = mark_paths_closed  # is this even used?
         self.inner_radius = inner_radius
         self.outer_radius = outer_radius
@@ -922,7 +949,7 @@ class Annulus(Circle):
             fill_opacity=fill_opacity, stroke_width=stroke_width, color=color, **kwargs
         )
 
-    def generate_points(self):
+    def generate_points(self) -> None:
         self.radius = self.outer_radius
         outer_circle = Circle(radius=self.outer_radius)
         inner_circle = Circle(radius=self.inner_radius)
@@ -935,7 +962,8 @@ class Annulus(Circle):
 
 
 class CubicBezier(VMobject, metaclass=ConvertToOpenGL):
-    """
+    """A cubic Bézier curve.
+
     Example
     -------
     .. manim:: BezierSplineExample
@@ -956,7 +984,14 @@ class CubicBezier(VMobject, metaclass=ConvertToOpenGL):
 
     """
 
-    def __init__(self, start_anchor, start_handle, end_handle, end_anchor, **kwargs):
+    def __init__(
+        self,
+        start_anchor: CubicBezierPoints,
+        start_handle: CubicBezierPoints,
+        end_handle: CubicBezierPoints,
+        end_anchor: CubicBezierPoints,
+        **kwargs,
+    ) -> None:
         super().__init__(**kwargs)
         self.add_cubic_bezier_curve(start_anchor, start_handle, end_handle, end_anchor)
 
@@ -1042,12 +1077,12 @@ class ArcPolygon(VMobject, metaclass=ConvertToOpenGL):
 
     def __init__(
         self,
-        *vertices: list | np.ndarray,
+        *vertices: Point3D,
         angle: float = PI / 4,
         radius: float | None = None,
         arc_config: list[dict] | None = None,
         **kwargs,
-    ):
+    ) -> None:
         n = len(vertices)
         point_pairs = [(vertices[k], vertices[(k + 1) % n]) for k in range(n)]
 
@@ -1185,7 +1220,7 @@ class ArcPolygonFromArcs(VMobject, metaclass=ConvertToOpenGL):
                 self.wait(2)
     """
 
-    def __init__(self, *arcs: Arc | ArcBetweenPoints, **kwargs):
+    def __init__(self, *arcs: Arc | ArcBetweenPoints, **kwargs) -> None:
         if not all(isinstance(m, (Arc, ArcBetweenPoints)) for m in arcs):
             raise ValueError(
                 "All ArcPolygon submobjects must be of type Arc/ArcBetweenPoints",
@@ -1204,7 +1239,7 @@ class ArcPolygonFromArcs(VMobject, metaclass=ConvertToOpenGL):
             self.append_points(arc1.points)
             line = Line(arc1.get_end(), arc2.get_start())
             len_ratio = line.get_length() / arc1.get_arc_length()
-            if math.isnan(len_ratio) or math.isinf(len_ratio):
+            if np.isnan(len_ratio) or np.isinf(len_ratio):
                 continue
             line.insert_n_curves(int(arc1.get_num_curves() * len_ratio))
             self.append_points(line.points)

manim/mobject/geometry/boolean_ops.py

@@ -2,8 +2,6 @@
 
 from __future__ import annotations
 
-import typing
-
 import numpy as np
 from pathops import Path as SkiaPath
 from pathops import PathVerb, difference, intersection, union, xor
@@ -11,6 +9,7 @@ from pathops import PathVerb, difference, intersection, union, xor
 from manim import config
 from manim.mobject.opengl.opengl_compatibility import ConvertToOpenGL
 from manim.mobject.types.vectorized_mobject import VMobject
+from manim.typing import Point2D_Array
 
 from ...constants import RendererType
 
@@ -23,12 +22,9 @@ class _BooleanOps(VMobject, metaclass=ConvertToOpenGL):
     objects (:class:`~.VMobject`).
     """
 
-    def __init__(self, *args, **kwargs):
-        super().__init__(*args, **kwargs)
-
     def _convert_2d_to_3d_array(
         self,
-        points: typing.Iterable,
+        points: Point2D_Array,
         z_dim: float = 0.0,
     ) -> list[np.ndarray]:
         """Converts an iterable with coordinates in 2d to 3d by adding
@@ -43,7 +39,7 @@ class _BooleanOps(VMobject, metaclass=ConvertToOpenGL):
 
         Returns
         -------
-        typing.List[np.ndarray]
+        Point2D_Array
             A list of array converted to 3d.
 
         Example
@@ -216,7 +212,7 @@ class Difference(_BooleanOps):
 
     """
 
-    def __init__(self, subject, clip, **kwargs) -> None:
+    def __init__(self, subject: VMobject, clip: VMobject, **kwargs) -> None:
         super().__init__(**kwargs)
         outpen = SkiaPath()
         difference(
@@ -258,7 +254,7 @@ class Intersection(_BooleanOps):
 
     """
 
-    def __init__(self, *vmobjects, **kwargs) -> None:
+    def __init__(self, *vmobjects: VMobject, **kwargs) -> None:
         if len(vmobjects) < 2:
             raise ValueError("At least 2 mobjects needed for Intersection.")
 
@@ -311,7 +307,7 @@ class Exclusion(_BooleanOps):
 
     """
 
-    def __init__(self, subject, clip, **kwargs) -> None:
+    def __init__(self, subject: VMobject, clip: VMobject, **kwargs) -> None:
         super().__init__(**kwargs)
         outpen = SkiaPath()
         xor(