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

manim/mobject/three_d/three_dimensions.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from manim.typing import Point3D, Vector3
+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,14 +959,15 @@ 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,
-        direction: Vector3 = None,
+        mob_or_point: Mobject | Point3DLike,
+        direction: Vector3D = None,
     ) -> np.ndarray:
         """Gets a point representing the center of the :class:`Mobjects <.Mobject>`.
 
@@ -1001,7 +1015,7 @@ class Line3D(Cylinder):
     def parallel_to(
         cls,
         line: Line3D,
-        point: Vector3 = ORIGIN,
+        point: Vector3D = ORIGIN,
         length: float = 5,
         **kwargs,
     ) -> Line3D:
@@ -1049,7 +1063,7 @@ class Line3D(Cylinder):
     def perpendicular_to(
         cls,
         line: Line3D,
-        point: Vector3 = ORIGIN,
+        point: Vector3D = ORIGIN,
         length: float = 5,
         **kwargs,
     ) -> Line3D:
@@ -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.

manim/mobject/types/image_mobject.py

@@ -5,6 +5,7 @@ from __future__ import annotations
 __all__ = ["AbstractImageMobject", "ImageMobject", "ImageMobjectFromCamera"]
 
 import pathlib
+from typing import TYPE_CHECKING
 
 import numpy as np
 from PIL import Image
@@ -19,6 +20,16 @@ from ...utils.bezier import interpolate
 from ...utils.color import WHITE, ManimColor, color_to_int_rgb
 from ...utils.images import change_to_rgba_array, get_full_raster_image_path
 
+__all__ = ["ImageMobject", "ImageMobjectFromCamera"]
+
+if TYPE_CHECKING:
+    from typing import Any
+
+    import numpy.typing as npt
+    from typing_extensions import Self
+
+    from manim.typing import StrPath
+
 
 class AbstractImageMobject(Mobject):
     """
@@ -37,23 +48,23 @@ class AbstractImageMobject(Mobject):
     def __init__(
         self,
         scale_to_resolution: int,
-        pixel_array_dtype="uint8",
-        resampling_algorithm=Resampling.BICUBIC,
-        **kwargs,
-    ):
+        pixel_array_dtype: str = "uint8",
+        resampling_algorithm: Resampling = Resampling.BICUBIC,
+        **kwargs: Any,
+    ) -> None:
         self.pixel_array_dtype = pixel_array_dtype
         self.scale_to_resolution = scale_to_resolution
         self.set_resampling_algorithm(resampling_algorithm)
         super().__init__(**kwargs)
 
-    def get_pixel_array(self):
+    def get_pixel_array(self) -> None:
         raise NotImplementedError()
 
     def set_color(self, color, alpha=None, family=True):
         # Likely to be implemented in subclasses, but no obligation
         pass
 
-    def set_resampling_algorithm(self, resampling_algorithm: int):
+    def set_resampling_algorithm(self, resampling_algorithm: int) -> Self:
         """
         Sets the interpolation method for upscaling the image. By default the image is
         interpolated using bicubic algorithm. This method lets you change it.
@@ -85,7 +96,7 @@ class AbstractImageMobject(Mobject):
             )
         return self
 
-    def reset_points(self):
+    def reset_points(self) -> None:
         """Sets :attr:`points` to be the four image corners."""
         self.points = np.array(
             [
@@ -169,15 +180,15 @@ class ImageMobject(AbstractImageMobject):
 
     def __init__(
         self,
-        filename_or_array,
+        filename_or_array: StrPath | npt.NDArray,
         scale_to_resolution: int = QUALITIES[DEFAULT_QUALITY]["pixel_height"],
-        invert=False,
-        image_mode="RGBA",
-        **kwargs,
-    ):
-        self.fill_opacity = 1
-        self.stroke_opacity = 1
-        self.invert = invert
+        invert: bool = False,
+        image_mode: str = "RGBA",
+        **kwargs: Any,
+    ) -> None:
+        self.fill_opacity: float = 1
+        self.stroke_opacity: float = 1
+        self.invert_image = invert
         self.image_mode = image_mode
         if isinstance(filename_or_array, (str, pathlib.PurePath)):
             path = get_full_raster_image_path(filename_or_array)
@@ -190,8 +201,10 @@ class ImageMobject(AbstractImageMobject):
         self.pixel_array = change_to_rgba_array(
             self.pixel_array, self.pixel_array_dtype
         )
-        if self.invert:
-            self.pixel_array[:, :, :3] = 255 - self.pixel_array[:, :, :3]
+        if self.invert_image:
+            self.pixel_array[:, :, :3] = (
+                np.iinfo(self.pixel_array_dtype).max - self.pixel_array[:, :, :3]
+            )
         super().__init__(scale_to_resolution, **kwargs)
 
     def get_pixel_array(self):
@@ -208,7 +221,7 @@ class ImageMobject(AbstractImageMobject):
         self.color = color
         return self
 
-    def set_opacity(self, alpha: float):
+    def set_opacity(self, alpha: float) -> Self:
         """Sets the image's opacity.
 
         Parameters
@@ -222,7 +235,7 @@ class ImageMobject(AbstractImageMobject):
         self.stroke_opacity = alpha
         return self
 
-    def fade(self, darkness: float = 0.5, family: bool = True):
+    def fade(self, darkness: float = 0.5, family: bool = True) -> Self:
         """Sets the image's opacity using a 1 - alpha relationship.
 
         Parameters
@@ -239,7 +252,7 @@ class ImageMobject(AbstractImageMobject):
 
     def interpolate_color(
         self, mobject1: ImageMobject, mobject2: ImageMobject, alpha: float
-    ):
+    ) -> None:
         """Interpolates the array of pixel color values from one ImageMobject
         into an array of equal size in the target ImageMobject.
 
@@ -275,7 +288,7 @@ class ImageMobject(AbstractImageMobject):
             alpha,
         ).astype(self.pixel_array_dtype)
 
-    def get_style(self):
+    def get_style(self) -> dict[str, Any]:
         return {
             "fill_color": ManimColor(self.color.get_rgb()).to_hex(),
             "fill_opacity": self.fill_opacity,
@@ -288,7 +301,12 @@ class ImageMobject(AbstractImageMobject):
 
 
 class ImageMobjectFromCamera(AbstractImageMobject):
-    def __init__(self, camera, default_display_frame_config=None, **kwargs):
+    def __init__(
+        self,
+        camera,
+        default_display_frame_config: dict[str, Any] | None = None,
+        **kwargs: Any,
+    ) -> None:
         self.camera = camera
         if default_display_frame_config is None:
             default_display_frame_config = {
@@ -305,14 +323,14 @@ class ImageMobjectFromCamera(AbstractImageMobject):
         self.pixel_array = self.camera.pixel_array
         return self.pixel_array
 
-    def add_display_frame(self, **kwargs):
+    def add_display_frame(self, **kwargs: Any) -> Self:
         config = dict(self.default_display_frame_config)
         config.update(kwargs)
         self.display_frame = SurroundingRectangle(self, **config)
         self.add(self.display_frame)
         return self
 
-    def interpolate_color(self, mobject1, mobject2, alpha):
+    def interpolate_color(self, mobject1, mobject2, alpha) -> None:
         assert mobject1.pixel_array.shape == mobject2.pixel_array.shape, (
             f"Mobject pixel array shapes incompatible for interpolation.\n"
             f"Mobject 1 ({mobject1}) : {mobject1.pixel_array.shape}\n"