manim 0.17.0__py3-none-any.whl → 0.19.1__py3-none-any.whl

manim/renderer/cairo_renderer.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
-import typing
-from typing import Any
+from collections.abc import Iterable
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 
@@ -9,28 +9,38 @@ from manim.utils.hashing import get_hash_from_play_call
 
 from .. import config, logger
 from ..camera.camera import Camera
-from ..mobject.mobject import Mobject
+from ..mobject.mobject import Mobject, _AnimationBuilder
 from ..scene.scene_file_writer import SceneFileWriter
 from ..utils.exceptions import EndSceneEarlyException
 from ..utils.iterables import list_update
 
-if typing.TYPE_CHECKING:
+if TYPE_CHECKING:
+    from manim.animation.animation import Animation
     from manim.scene.scene import Scene
 
+    from ..typing import PixelArray
+
+__all__ = ["CairoRenderer"]
+
 
 class CairoRenderer:
     """A renderer using Cairo.
 
-    num_plays : Number of play() functions in the scene.
-    time: time elapsed since initialisation of scene.
+    Attributes
+    ----------
+    num_plays : int
+        Number of play() functions in the scene.
+
+    time : float
+        Time elapsed since initialisation of scene.
     """
 
     def __init__(
         self,
-        file_writer_class=SceneFileWriter,
-        camera_class=None,
-        skip_animations=False,
-        **kwargs,
+        file_writer_class: type[SceneFileWriter] = SceneFileWriter,
+        camera_class: type[Camera] | None = None,
+        skip_animations: bool = False,
+        **kwargs: Any,
     ):
         # All of the following are set to EITHER the value passed via kwargs,
         # OR the value stored in the global config dict at the time of
@@ -40,18 +50,23 @@ class CairoRenderer:
         self.camera = camera_cls()
         self._original_skipping_status = skip_animations
         self.skip_animations = skip_animations
-        self.animations_hashes = []
+        self.animations_hashes: list[str | None] = []
         self.num_plays = 0
-        self.time = 0
-        self.static_image = None
+        self.time = 0.0
+        self.static_image: PixelArray | None = None
 
-    def init_scene(self, scene):
+    def init_scene(self, scene: Scene) -> None:
         self.file_writer: Any = self._file_writer_class(
             self,
             scene.__class__.__name__,
         )
 
-    def play(self, scene, *args, **kwargs):
+    def play(
+        self,
+        scene: Scene,
+        *args: Animation | Mobject | _AnimationBuilder,
+        **kwargs: Any,
+    ) -> None:
         # Reset skip_animations to the original state.
         # Needed when rendering only some animations, and skipping others.
         self.skip_animations = self._original_skipping_status
@@ -68,6 +83,7 @@ class CairoRenderer:
                 logger.info("Caching disabled.")
                 hash_current_animation = f"uncached_{self.num_plays:05}"
             else:
+                assert scene.animations is not None
                 hash_current_animation = get_hash_from_play_call(
                     scene,
                     self.camera,
@@ -108,12 +124,12 @@ class CairoRenderer:
 
     def update_frame(  # TODO Description in Docstring
         self,
-        scene,
-        mobjects: typing.Iterable[Mobject] | None = None,
+        scene: Scene,
+        mobjects: Iterable[Mobject] | None = None,
         include_submobjects: bool = True,
         ignore_skipping: bool = True,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> None:
         """Update the frame.
 
         Parameters
@@ -128,7 +144,6 @@ class CairoRenderer:
         ignore_skipping
 
         **kwargs
-
         """
         if self.skip_animations and not ignore_skipping:
             return
@@ -145,25 +160,28 @@ class CairoRenderer:
         kwargs["include_submobjects"] = include_submobjects
         self.camera.capture_mobjects(mobjects, **kwargs)
 
-    def render(self, scene, time, moving_mobjects):
+    def render(
+        self,
+        scene: Scene,
+        time: float,
+        moving_mobjects: Iterable[Mobject] | None = None,
+    ) -> None:
         self.update_frame(scene, moving_mobjects)
         self.add_frame(self.get_frame())
 
-    def get_frame(self):
-        """
-        Gets the current frame as NumPy array.
+    def get_frame(self) -> PixelArray:
+        """Gets the current frame as NumPy array.
 
         Returns
         -------
-        np.array
+        PixelArray
             NumPy array of pixel values of each pixel in screen.
-            The shape of the array is height x width x 3
+            The shape of the array is height x width x 3.
         """
         return np.array(self.camera.pixel_array)
 
-    def add_frame(self, frame: np.ndarray, num_frames: int = 1):
-        """
-        Adds a frame to the video_file_stream
+    def add_frame(self, frame: PixelArray, num_frames: int = 1) -> None:
+        """Adds a frame to the video_file_stream
 
         Parameters
         ----------
@@ -176,10 +194,9 @@ class CairoRenderer:
         if self.skip_animations:
             return
         self.time += num_frames * dt
-        for _ in range(num_frames):
-            self.file_writer.write_frame(frame)
+        self.file_writer.write_frame(frame, num_frames=num_frames)
 
-    def freeze_current_frame(self, duration: float):
+    def freeze_current_frame(self, duration: float) -> None:
         """Adds a static frame to the movie for a given duration. The static frame is the current frame.
 
         Parameters
@@ -193,19 +210,18 @@ class CairoRenderer:
             num_frames=int(duration / dt),
         )
 
-    def show_frame(self):
-        """
-        Opens the current frame in the Default Image Viewer
+    def show_frame(self, scene: Scene) -> None:
+        """Opens the current frame in the Default Image Viewer
         of your system.
         """
-        self.update_frame(ignore_skipping=True)
+        self.update_frame(scene, ignore_skipping=True)
         self.camera.get_image().show()
 
     def save_static_frame_data(
         self,
         scene: Scene,
-        static_mobjects: typing.Iterable[Mobject],
-    ) -> typing.Iterable[Mobject] | None:
+        static_mobjects: Iterable[Mobject],
+    ) -> PixelArray | None:
         """Compute and save the static frame, that will be reused at each frame
         to avoid unnecessarily computing static mobjects.
 
@@ -214,12 +230,12 @@ class CairoRenderer:
         scene
             The scene played.
         static_mobjects
-            Static mobjects of the scene. If None, self.static_image is set to None
+            Static mobjects of the scene. If None, self.static_image is set to None.
 
         Returns
         -------
-        typing.Iterable[Mobject]
-            The static image computed.
+        PixelArray | None
+            The static image computed. The return value is None if there are no static mobjects in the scene.
         """
         self.static_image = None
         if not static_mobjects:
@@ -228,9 +244,8 @@ class CairoRenderer:
         self.static_image = self.get_frame()
         return self.static_image
 
-    def update_skipping_status(self):
-        """
-        This method is used internally to check if the current
+    def update_skipping_status(self) -> None:
+        """This method is used internally to check if the current
         animation needs to be skipped or not. It also checks if
         the number of animations that were played correspond to
         the number of animations that need to be played, and
@@ -242,18 +257,18 @@ class CairoRenderer:
         if config["save_last_frame"]:
             self.skip_animations = True
         if (
-            config["from_animation_number"]
-            and self.num_plays < config["from_animation_number"]
+            config.from_animation_number > 0
+            and self.num_plays < config.from_animation_number
         ):
             self.skip_animations = True
         if (
-            config["upto_animation_number"]
-            and self.num_plays > config["upto_animation_number"]
+            config.upto_animation_number >= 0
+            and self.num_plays > config.upto_animation_number
         ):
             self.skip_animations = True
             raise EndSceneEarlyException()
 
-    def scene_finished(self, scene):
+    def scene_finished(self, scene: Scene) -> None:
         # If no animations in scene, render an image instead
         if self.num_plays:
             self.file_writer.finish()
@@ -267,4 +282,4 @@ class CairoRenderer:
         if config["save_last_frame"]:
             self.static_image = None
             self.update_frame(scene)
-            self.file_writer.save_final_image(self.camera.get_image())
+            self.file_writer.save_image(self.camera.get_image())

manim/renderer/opengl_renderer.py

@@ -1,21 +1,21 @@
 from __future__ import annotations
 
+import contextlib
 import itertools as it
-import sys
 import time
-from typing import Any
-
-if sys.version_info < (3, 8):
-    from backports.cached_property import cached_property
-else:
-    from functools import cached_property
+from functools import cached_property
+from typing import TYPE_CHECKING, Any
 
 import moderngl
 import numpy as np
 from PIL import Image
 
 from manim import config, logger
-from manim.mobject.opengl.opengl_mobject import OpenGLMobject, OpenGLPoint
+from manim.mobject.opengl.opengl_mobject import (
+    OpenGLMobject,
+    OpenGLPoint,
+    _AnimationBuilder,
+)
 from manim.mobject.opengl.opengl_vectorized_mobject import OpenGLVMobject
 from manim.utils.caching import handle_caching_play
 from manim.utils.color import color_to_rgba
@@ -39,6 +39,17 @@ from .vectorized_mobject_rendering import (
     render_opengl_vectorized_mobject_stroke,
 )
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from manim.animation.animation import Animation
+    from manim.mobject.mobject import Mobject
+    from manim.scene.scene import Scene
+    from manim.typing import Point3D
+
+
+__all__ = ["OpenGLCamera", "OpenGLRenderer"]
+
 
 class OpenGLCamera(OpenGLMobject):
     euler_angles = _Data()
@@ -65,12 +76,12 @@ class OpenGLCamera(OpenGLMobject):
         if self.orthographic:
             self.projection_matrix = opengl.orthographic_projection_matrix()
             self.unformatted_projection_matrix = opengl.orthographic_projection_matrix(
-                format=False,
+                format_=False,
             )
         else:
             self.projection_matrix = opengl.perspective_projection_matrix()
             self.unformatted_projection_matrix = opengl.perspective_projection_matrix(
-                format=False,
+                format_=False,
             )
 
         if frame_shape is None:
@@ -104,7 +115,7 @@ class OpenGLCamera(OpenGLMobject):
         self.euler_angles = euler_angles
         self.refresh_rotation_matrix()
 
-    def get_position(self):
+    def get_position(self) -> Point3D:
         return self.model_matrix[:, 3][:3]
 
     def set_position(self, position):
@@ -125,7 +136,7 @@ class OpenGLCamera(OpenGLMobject):
         self.set_height(self.frame_shape[1], stretch=True)
         self.move_to(self.center_point)
 
-    def to_default_state(self):
+    def to_default_state(self) -> Self:
         self.center()
         self.set_height(config["frame_height"])
         self.set_width(config["frame_width"])
@@ -168,28 +179,28 @@ class OpenGLCamera(OpenGLMobject):
         self.refresh_rotation_matrix()
         return self
 
-    def set_theta(self, theta):
+    def set_theta(self, theta: float) -> Self:
         return self.set_euler_angles(theta=theta)
 
-    def set_phi(self, phi):
+    def set_phi(self, phi: float) -> Self:
         return self.set_euler_angles(phi=phi)
 
-    def set_gamma(self, gamma):
+    def set_gamma(self, gamma: float) -> Self:
         return self.set_euler_angles(gamma=gamma)
 
-    def increment_theta(self, dtheta):
+    def increment_theta(self, dtheta: float) -> Self:
         self.euler_angles[0] += dtheta
         self.refresh_rotation_matrix()
         return self
 
-    def increment_phi(self, dphi):
+    def increment_phi(self, dphi: float) -> Self:
         phi = self.euler_angles[1]
         new_phi = clip(phi + dphi, -PI / 2, PI / 2)
         self.euler_angles[1] = new_phi
         self.refresh_rotation_matrix()
         return self
 
-    def increment_gamma(self, dgamma):
+    def increment_gamma(self, dgamma: float) -> Self:
         self.euler_angles[2] += dgamma
         self.refresh_rotation_matrix()
         return self
@@ -201,15 +212,15 @@ class OpenGLCamera(OpenGLMobject):
         # Assumes first point is at the center
         return self.points[0]
 
-    def get_width(self):
+    def get_width(self) -> float:
         points = self.points
         return points[2, 0] - points[1, 0]
 
-    def get_height(self):
+    def get_height(self) -> float:
         points = self.points
         return points[4, 1] - points[3, 1]
 
-    def get_focal_distance(self):
+    def get_focal_distance(self) -> float:
         return self.focal_distance * self.get_height()
 
     def interpolate(self, *args, **kwargs):
@@ -217,11 +228,12 @@ class OpenGLCamera(OpenGLMobject):
         self.refresh_rotation_matrix()
 
 
-points_per_curve = 3
-
-
 class OpenGLRenderer:
-    def __init__(self, file_writer_class=SceneFileWriter, skip_animations=False):
+    def __init__(
+        self,
+        file_writer_class: type[SceneFileWriter] = SceneFileWriter,
+        skip_animations: bool = False,
+    ) -> None:
         # Measured in pixel widths, used for vector graphics
         self.anti_alias_width = 1.5
         self._file_writer_class = file_writer_class
@@ -237,12 +249,14 @@ class OpenGLRenderer:
         self.camera = OpenGLCamera()
         self.pressed_keys = set()
 
+        self.window = None
+
         # Initialize texture map.
         self.path_to_texture_id = {}
 
         self.background_color = config["background_color"]
 
-    def init_scene(self, scene):
+    def init_scene(self, scene: Scene) -> None:
         self.partial_movie_files = []
         self.file_writer: Any = self._file_writer_class(
             self,
@@ -250,32 +264,31 @@ class OpenGLRenderer:
         )
         self.scene = scene
         self.background_color = config["background_color"]
-        if not hasattr(self, "window"):
-            if self.should_create_window():
-                from .opengl_renderer_window import Window
+        if self.should_create_window():
+            from .opengl_renderer_window import Window
 
-                self.window = Window(self)
-                self.context = self.window.ctx
-                self.frame_buffer_object = self.context.detect_framebuffer()
-            else:
-                self.window = None
-                try:
-                    self.context = moderngl.create_context(standalone=True)
-                except Exception:
-                    self.context = moderngl.create_context(
-                        standalone=True,
-                        backend="egl",
-                    )
-                self.frame_buffer_object = self.get_frame_buffer_object(self.context, 0)
-                self.frame_buffer_object.use()
-            self.context.enable(moderngl.BLEND)
-            self.context.wireframe = config["enable_wireframe"]
-            self.context.blend_func = (
-                moderngl.SRC_ALPHA,
-                moderngl.ONE_MINUS_SRC_ALPHA,
-                moderngl.ONE,
-                moderngl.ONE,
-            )
+            self.window = Window(self)
+            self.context = self.window.ctx
+            self.frame_buffer_object = self.context.detect_framebuffer()
+        else:
+            # self.window = None
+            try:
+                self.context = moderngl.create_context(standalone=True)
+            except Exception:
+                self.context = moderngl.create_context(
+                    standalone=True,
+                    backend="egl",
+                )
+            self.frame_buffer_object = self.get_frame_buffer_object(self.context, 0)
+            self.frame_buffer_object.use()
+        self.context.enable(moderngl.BLEND)
+        self.context.wireframe = config["enable_wireframe"]
+        self.context.blend_func = (
+            moderngl.SRC_ALPHA,
+            moderngl.ONE_MINUS_SRC_ALPHA,
+            moderngl.ONE,
+            moderngl.ONE,
+        )
 
     def should_create_window(self):
         if config["force_window"]:
@@ -342,10 +355,8 @@ class OpenGLRenderer:
                 shader_wrapper.uniforms.items(),
                 self.perspective_uniforms.items(),
             ):
-                try:
+                with contextlib.suppress(KeyError):
                     shader.set_uniform(name, value)
-                except KeyError:
-                    pass
             try:
                 shader.set_uniform(
                     "u_view_matrix", self.scene.camera.formatted_view_matrix
@@ -391,9 +402,8 @@ class OpenGLRenderer:
 
         return self.path_to_texture_id[repr(path)]
 
-    def update_skipping_status(self):
-        """
-        This method is used internally to check if the current
+    def update_skipping_status(self) -> None:
+        """This method is used internally to check if the current
         animation needs to be skipped or not. It also checks if
         the number of animations that were played correspond to
         the number of animations that need to be played, and
@@ -403,19 +413,24 @@ class OpenGLRenderer:
         if self.file_writer.sections[-1].skip_animations:
             self.skip_animations = True
         if (
-            config["from_animation_number"]
-            and self.num_plays < config["from_animation_number"]
+            config.from_animation_number > 0
+            and self.num_plays < config.from_animation_number
         ):
             self.skip_animations = True
         if (
-            config["upto_animation_number"]
-            and self.num_plays > config["upto_animation_number"]
+            config.upto_animation_number >= 0
+            and self.num_plays > config.upto_animation_number
         ):
             self.skip_animations = True
             raise EndSceneEarlyException()
 
     @handle_caching_play
-    def play(self, scene, *args, **kwargs):
+    def play(
+        self,
+        scene: Scene,
+        *args: Animation | Mobject | _AnimationBuilder,
+        **kwargs: Any,
+    ) -> None:
         # TODO: Handle data locking / unlocking.
         self.animation_start_time = time.time()
         self.file_writer.begin_animation(not self.skip_animations)
@@ -426,8 +441,9 @@ class OpenGLRenderer:
             self.update_frame(scene)
 
             if not self.skip_animations:
-                for _ in range(int(config.frame_rate * scene.duration)):
-                    self.file_writer.write_frame(self)
+                self.file_writer.write_frame(
+                    self, num_frames=int(config.frame_rate * scene.duration)
+                )
 
             if self.window is not None:
                 self.window.swap_buffers()
@@ -442,11 +458,13 @@ class OpenGLRenderer:
         self.time += scene.duration
         self.num_plays += 1
 
-    def clear_screen(self):
+    def clear_screen(self) -> None:
         self.frame_buffer_object.clear(*self.background_color)
         self.window.swap_buffers()
 
-    def render(self, scene, frame_offset, moving_mobjects):
+    def render(
+        self, scene: Scene, frame_offset, moving_mobjects: list[Mobject]
+    ) -> None:
         self.update_frame(scene)
 
         if self.skip_animations:
@@ -487,7 +505,7 @@ class OpenGLRenderer:
         if self.should_save_last_frame():
             config.save_last_frame = True
             self.update_frame(scene)
-            self.file_writer.save_final_image(self.get_image())
+            self.file_writer.save_image(self.get_image())
 
     def should_save_last_frame(self):
         if config["save_last_frame"]:
@@ -568,12 +586,14 @@ class OpenGLRenderer:
     # Returns offset from the bottom left corner in pixels.
     # top_left flag should be set to True when using a GUI framework
     # where the (0,0) is at the top left: e.g. PySide6
-    def pixel_coords_to_space_coords(self, px, py, relative=False, top_left=False):
+    def pixel_coords_to_space_coords(
+        self, px: float, py: float, relative: bool = False, top_left: bool = False
+    ) -> Point3D:
         pixel_shape = self.get_pixel_shape()
         if pixel_shape is None:
             return np.array([0, 0, 0])
         pw, ph = pixel_shape
-        fw, fh = config["frame_width"], config["frame_height"]
+        fh = config["frame_height"]
         fc = self.camera.get_center()
         if relative:
             return 2 * np.array([px / pw, py / ph, 0])