Merge remote-tracking branch 'upstream/main' into typing-logger-utils

Author: henrikmidtiby

manim/camera/camera.py

@@ -14,11 +14,19 @@
 
 import cairo
 import numpy as np
+import numpy.typing as npt
 from PIL import Image
 from scipy.spatial.distance import pdist
 from typing_extensions import Self
 
-from manim.typing import MatrixMN, PixelArray, Point3D, Point3D_Array
+from manim.typing import (
+    FloatRGBA_Array,
+    FloatRGBALike_Array,
+    ManimInt,
+    PixelArray,
+    Point3D,
+    Point3D_Array,
+)
 
 from .. import config, logger
 from ..constants import *
@@ -211,8 +219,8 @@ def type_or_raise(
             type[Mobject], Callable[[list[Mobject], PixelArray], Any]
         ] = {
             VMobject: self.display_multiple_vectorized_mobjects,  # type: ignore[dict-item]
-            PMobject: self.display_multiple_point_cloud_mobjects,
-            AbstractImageMobject: self.display_multiple_image_mobjects,
+            PMobject: self.display_multiple_point_cloud_mobjects,  # type: ignore[dict-item]
+            AbstractImageMobject: self.display_multiple_image_mobjects,  # type: ignore[dict-item]
             Mobject: lambda batch, pa: batch,  # Do nothing
         }
         # We have to check each type in turn because we are dealing with
@@ -723,7 +731,7 @@ def set_cairo_context_path(self, ctx: cairo.Context, vmobject: VMobject) -> Self
         return self
 
     def set_cairo_context_color(
-        self, ctx: cairo.Context, rgbas: MatrixMN, vmobject: VMobject
+        self, ctx: cairo.Context, rgbas: FloatRGBALike_Array, vmobject: VMobject
     ) -> Self:
         """Sets the color of the cairo context
 
@@ -818,7 +826,7 @@ def apply_stroke(
 
     def get_stroke_rgbas(
         self, vmobject: VMobject, background: bool = False
-    ) -> PixelArray:
+    ) -> FloatRGBA_Array:
         """Gets the RGBA array for the stroke of the passed
         VMobject.
 
@@ -837,7 +845,7 @@ def get_stroke_rgbas(
         """
         return vmobject.get_stroke_rgbas(background)
 
-    def get_fill_rgbas(self, vmobject: VMobject) -> PixelArray:
+    def get_fill_rgbas(self, vmobject: VMobject) -> FloatRGBA_Array:
         """Returns the RGBA array of the fill of the passed VMobject
 
         Parameters
@@ -898,7 +906,7 @@ def display_multiple_background_colored_vmobjects(
     # As a result, the other methods do not have as detailed docstrings as would be preferred.
 
     def display_multiple_point_cloud_mobjects(
-        self, pmobjects: list, pixel_array: PixelArray
+        self, pmobjects: Iterable[PMobject], pixel_array: PixelArray
     ) -> None:
         """Displays multiple PMobjects by modifying the passed pixel array.
 
@@ -921,8 +929,8 @@ def display_multiple_point_cloud_mobjects(
     def display_point_cloud(
         self,
         pmobject: PMobject,
-        points: list,
-        rgbas: np.ndarray,
+        points: Point3D_Array,
+        rgbas: FloatRGBA_Array,
         thickness: float,
         pixel_array: PixelArray,
     ) -> None:
@@ -972,7 +980,9 @@ def display_point_cloud(
         pixel_array[:, :] = new_pa.reshape((ph, pw, rgba_len))
 
     def display_multiple_image_mobjects(
-        self, image_mobjects: list, pixel_array: np.ndarray
+        self,
+        image_mobjects: Iterable[AbstractImageMobject],
+        pixel_array: PixelArray,
     ) -> None:
         """Displays multiple image mobjects by modifying the passed pixel_array.
 
@@ -1121,8 +1131,8 @@ def transform_points_pre_display(
     def points_to_pixel_coords(
         self,
         mobject: Mobject,
-        points: np.ndarray,
-    ) -> np.ndarray:  # TODO: Write more detailed docstrings for this method.
+        points: Point3D_Array,
+    ) -> npt.NDArray[ManimInt]:  # TODO: Write more detailed docstrings for this method.
         points = self.transform_points_pre_display(mobject, points)
         shifted_points = points - self.frame_center
 

manim/camera/moving_camera.py

@@ -12,7 +12,9 @@
 from collections.abc import Iterable
 from typing import Any
 
-import numpy as np
+from cairo import Context
+
+from manim.typing import PixelArray, Point3D, Point3DLike
 
 from .. import config
 from ..camera.camera import Camera
@@ -34,12 +36,12 @@ class MovingCamera(Camera):
 
     def __init__(
         self,
-        frame=None,
+        frame: Mobject | None = None,
         fixed_dimension: int = 0,  # width
         default_frame_stroke_color: ManimColor = WHITE,
         default_frame_stroke_width: int = 0,
         **kwargs: Any,
-    ) -> None:
+    ):
         """Frame is a Mobject, (should almost certainly be a rectangle)
         determining which region of space the camera displays
         """
@@ -57,7 +59,7 @@ def __init__(
 
     # TODO, make these work for a rotated frame
     @property
-    def frame_height(self):
+    def frame_height(self) -> float:
         """Returns the height of the frame.
 
         Returns
@@ -67,30 +69,8 @@ def frame_height(self):
         """
         return self.frame.height
 
-    @property
-    def frame_width(self):
-        """Returns the width of the frame
-
-        Returns
-        -------
-        float
-            The width of the frame.
-        """
-        return self.frame.width
-
-    @property
-    def frame_center(self):
-        """Returns the centerpoint of the frame in cartesian coordinates.
-
-        Returns
-        -------
-        np.array
-            The cartesian coordinates of the center of the frame.
-        """
-        return self.frame.get_center()
-
     @frame_height.setter
-    def frame_height(self, frame_height: float):
+    def frame_height(self, frame_height: float) -> None:
         """Sets the height of the frame in MUnits.
 
         Parameters
@@ -100,8 +80,19 @@ def frame_height(self, frame_height: float):
         """
         self.frame.stretch_to_fit_height(frame_height)
 
+    @property
+    def frame_width(self) -> float:
+        """Returns the width of the frame
+
+        Returns
+        -------
+        float
+            The width of the frame.
+        """
+        return self.frame.width
+
     @frame_width.setter
-    def frame_width(self, frame_width: float):
+    def frame_width(self, frame_width: float) -> None:
         """Sets the width of the frame in MUnits.
 
         Parameters
@@ -111,8 +102,19 @@ def frame_width(self, frame_width: float):
         """
         self.frame.stretch_to_fit_width(frame_width)
 
+    @property
+    def frame_center(self) -> Point3D:
+        """Returns the centerpoint of the frame in cartesian coordinates.
+
+        Returns
+        -------
+        np.array
+            The cartesian coordinates of the center of the frame.
+        """
+        return self.frame.get_center()
+
     @frame_center.setter
-    def frame_center(self, frame_center: np.ndarray | list | tuple | Mobject):
+    def frame_center(self, frame_center: Point3DLike | Mobject) -> None:
         """Sets the centerpoint of the frame.
 
         Parameters
@@ -129,17 +131,14 @@ def capture_mobjects(self, mobjects: Iterable[Mobject], **kwargs: Any) -> None:
         # self.realign_frame_shape()
         super().capture_mobjects(mobjects, **kwargs)
 
-    # Since the frame can be moving around, the cairo
-    # context used for updating should be regenerated
-    # at each frame.  So no caching.
-    def get_cached_cairo_context(self, pixel_array):
+    def get_cached_cairo_context(self, pixel_array: PixelArray) -> None:
         """Since the frame can be moving around, the cairo
         context used for updating should be regenerated
         at each frame.  So no caching.
         """
         return None
 
-    def cache_cairo_context(self, pixel_array, ctx):
+    def cache_cairo_context(self, pixel_array: PixelArray, ctx: Context) -> None:
         """Since the frame can be moving around, the cairo
         context used for updating should be regenerated
         at each frame.  So no caching.
@@ -157,23 +156,23 @@ def cache_cairo_context(self, pixel_array, ctx):
     #         self.frame_shape = (self.frame.height, width)
     #     self.resize_frame_shape(fixed_dimension=self.fixed_dimension)
 
-    def get_mobjects_indicating_movement(self):
+    def get_mobjects_indicating_movement(self) -> list[Mobject]:
         """Returns all mobjects whose movement implies that the camera
         should think of all other mobjects on the screen as moving
 
         Returns
         -------
-        list
+        list[Mobject]
         """
         return [self.frame]
 
     def auto_zoom(
         self,
-        mobjects: list[Mobject],
+        mobjects: Iterable[Mobject],
         margin: float = 0,
         only_mobjects_in_frame: bool = False,
         animate: bool = True,
-    ):
+    ) -> Mobject:
         """Zooms on to a given array of mobjects (or a singular mobject)
         and automatically resizes to frame all the mobjects.
 
@@ -203,10 +202,36 @@ def auto_zoom(
             or ScreenRectangle with position and size updated to zoomed position.
 
         """
-        scene_critical_x_left = None
-        scene_critical_x_right = None
-        scene_critical_y_up = None
-        scene_critical_y_down = None
+        (
+            scene_critical_x_left,
+            scene_critical_x_right,
+            scene_critical_y_up,
+            scene_critical_y_down,
+        ) = self._get_bounding_box(mobjects, only_mobjects_in_frame)
+
+        # calculate center x and y
+        x = (scene_critical_x_left + scene_critical_x_right) / 2
+        y = (scene_critical_y_up + scene_critical_y_down) / 2
+
+        # calculate proposed width and height of zoomed scene
+        new_width = abs(scene_critical_x_left - scene_critical_x_right)
+        new_height = abs(scene_critical_y_up - scene_critical_y_down)
+
+        m_target = self.frame.animate if animate else self.frame
+        # zoom to fit all mobjects along the side that has the largest size
+        if new_width / self.frame.width > new_height / self.frame.height:
+            return m_target.set_x(x).set_y(y).set(width=new_width + margin)
+        else:
+            return m_target.set_x(x).set_y(y).set(height=new_height + margin)
+
+    def _get_bounding_box(
+        self, mobjects: Iterable[Mobject], only_mobjects_in_frame: bool
+    ) -> tuple[float, float, float, float]:
+        bounding_box_located = False
+        scene_critical_x_left: float = 0
+        scene_critical_x_right: float = 1
+        scene_critical_y_up: float = 1
+        scene_critical_y_down: float = 0
 
         for m in mobjects:
             if (m == self.frame) or (
@@ -216,11 +241,12 @@ def auto_zoom(
                 continue
 
             # initialize scene critical points with first mobjects critical points
-            if scene_critical_x_left is None:
+            if not bounding_box_located:
                 scene_critical_x_left = m.get_critical_point(LEFT)[0]
                 scene_critical_x_right = m.get_critical_point(RIGHT)[0]
                 scene_critical_y_up = m.get_critical_point(UP)[1]
                 scene_critical_y_down = m.get_critical_point(DOWN)[1]
+                bounding_box_located = True
 
             else:
                 if m.get_critical_point(LEFT)[0] < scene_critical_x_left:
@@ -235,17 +261,14 @@ def auto_zoom(
                 if m.get_critical_point(DOWN)[1] < scene_critical_y_down:
                     scene_critical_y_down = m.get_critical_point(DOWN)[1]
 
-        # calculate center x and y
-        x = (scene_critical_x_left + scene_critical_x_right) / 2
-        y = (scene_critical_y_up + scene_critical_y_down) / 2
-
-        # calculate proposed width and height of zoomed scene
-        new_width = abs(scene_critical_x_left - scene_critical_x_right)
-        new_height = abs(scene_critical_y_up - scene_critical_y_down)
+        if not bounding_box_located:
+            raise Exception(
+                "Could not determine bounding box of the mobjects given to 'auto_zoom'."
+            )
 
-        m_target = self.frame.animate if animate else self.frame
-        # zoom to fit all mobjects along the side that has the largest size
-        if new_width / self.frame.width > new_height / self.frame.height:
-            return m_target.set_x(x).set_y(y).set(width=new_width + margin)
-        else:
-            return m_target.set_x(x).set_y(y).set(height=new_height + margin)
+        return (
+            scene_critical_x_left,
+            scene_critical_x_right,
+            scene_critical_y_up,
+            scene_critical_y_down,
+        )

manim/camera/three_d_camera.py

@@ -20,6 +20,7 @@
 from manim.mobject.types.vectorized_mobject import VMobject
 from manim.mobject.value_tracker import ValueTracker
 from manim.typing import (
+    FloatRGBA_Array,
     MatrixMN,
     Point3D,
     Point3D_Array,
@@ -109,7 +110,9 @@ def get_value_trackers(self) -> list[ValueTracker]:
             self.zoom_tracker,
         ]
 
-    def modified_rgbas(self, vmobject: VMobject, rgbas: MatrixMN) -> MatrixMN:
+    def modified_rgbas(
+        self, vmobject: VMobject, rgbas: FloatRGBA_Array
+    ) -> FloatRGBA_Array:
         if not self.should_apply_shading:
             return rgbas
         if vmobject.shade_in_3d and (vmobject.get_num_points() > 0):
@@ -137,12 +140,12 @@ def get_stroke_rgbas(
         self,
         vmobject: VMobject,
         background: bool = False,
-    ) -> MatrixMN:  # NOTE : DocStrings From parent
+    ) -> FloatRGBA_Array:  # NOTE : DocStrings From parent
         return self.modified_rgbas(vmobject, vmobject.get_stroke_rgbas(background))
 
     def get_fill_rgbas(
         self, vmobject: VMobject
-    ) -> MatrixMN:  # NOTE : DocStrings From parent
+    ) -> FloatRGBA_Array:  # NOTE : DocStrings From parent
         return self.modified_rgbas(vmobject, vmobject.get_fill_rgbas())
 
     def get_mobjects_to_display(

manim/mobject/graphing/probability.py

@@ -105,8 +105,6 @@ def get_division_along_dimension(
         p_list_complete = self.complete_p_list(p_list)
         colors_in_gradient = color_gradient(colors, len(p_list_complete))
 
-        assert isinstance(colors_in_gradient, list)
-
         last_point = self.get_edge_center(-vect)
         parts = VGroup()
         for factor, color in zip(p_list_complete, colors_in_gradient):

manim/mobject/mobject.py

@@ -2357,7 +2357,7 @@ def __getitem__(self, value):
     def __iter__(self):
         return iter(self.split())
 
-    def __len__(self):
+    def __len__(self) -> int:
         return len(self.split())
 
     def get_group_class(self) -> type[Group]: