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

manim/scene/vector_space_scene.py

@@ -4,11 +4,13 @@ from __future__ import annotations
 
 __all__ = ["VectorScene", "LinearTransformationScene"]
 
-from typing import Callable
+from collections.abc import Callable, Iterable
+from typing import TYPE_CHECKING, Any, cast
 
 import numpy as np
-from colour import Color
 
+from manim.animation.creation import DrawBorderThenFill, Group
+from manim.camera.camera import Camera
 from manim.mobject.geometry.arc import Dot
 from manim.mobject.geometry.line import Arrow, Line, Vector
 from manim.mobject.geometry.polygram import Rectangle
@@ -28,10 +30,33 @@ from ..mobject.matrix import Matrix
 from ..mobject.mobject import Mobject
 from ..mobject.types.vectorized_mobject import VGroup, VMobject
 from ..scene.scene import Scene
-from ..utils.color import BLUE_D, GREEN_C, GREY, RED_C, WHITE, YELLOW
+from ..utils.color import (
+    BLACK,
+    BLUE_D,
+    GREEN_C,
+    GREY,
+    RED_C,
+    WHITE,
+    YELLOW,
+    ManimColor,
+    ParsableManimColor,
+)
 from ..utils.rate_functions import rush_from, rush_into
 from ..utils.space_ops import angle_of_vector
 
+if TYPE_CHECKING:
+    from typing_extensions import Self
+
+    from manim.typing import (
+        MappingFunction,
+        Point3D,
+        Point3DLike,
+        Vector2DLike,
+        Vector3D,
+        Vector3DLike,
+    )
+
+
 X_COLOR = GREEN_C
 Y_COLOR = RED_C
 Z_COLOR = BLUE_D
@@ -44,11 +69,11 @@ Z_COLOR = BLUE_D
 # Also, methods I would have thought of as getters, like coords_to_vector, are
 # actually doing a lot of animating.
 class VectorScene(Scene):
-    def __init__(self, basis_vector_stroke_width=6, **kwargs):
+    def __init__(self, basis_vector_stroke_width: float = 6.0, **kwargs: Any) -> None:
         super().__init__(**kwargs)
         self.basis_vector_stroke_width = basis_vector_stroke_width
 
-    def add_plane(self, animate: bool = False, **kwargs):
+    def add_plane(self, animate: bool = False, **kwargs: Any) -> NumberPlane:
         """
         Adds a NumberPlane object to the background.
 
@@ -70,7 +95,11 @@ class VectorScene(Scene):
         self.add(plane)
         return plane
 
-    def add_axes(self, animate: bool = False, color: bool = WHITE, **kwargs):
+    def add_axes(
+        self,
+        animate: bool = False,
+        color: ParsableManimColor | Iterable[ParsableManimColor] = WHITE,
+    ) -> Axes:
         """
         Adds a pair of Axes to the Scene.
 
@@ -87,7 +116,9 @@ class VectorScene(Scene):
         self.add(axes)
         return axes
 
-    def lock_in_faded_grid(self, dimness: float = 0.7, axes_dimness: float = 0.5):
+    def lock_in_faded_grid(
+        self, dimness: float = 0.7, axes_dimness: float = 0.5
+    ) -> None:
         """
         This method freezes the NumberPlane and Axes that were already
         in the background, and adds new, manipulatable ones to the foreground.
@@ -107,11 +138,13 @@ class VectorScene(Scene):
         axes.fade(axes_dimness)
         self.add(axes)
 
-        self.renderer.update_frame()
+        # TODO
+        # error: Missing positional argument "scene" in call to "update_frame" of "CairoRenderer"  [call-arg]
+        self.renderer.update_frame()  # type: ignore[call-arg]
         self.renderer.camera = Camera(self.renderer.get_frame())
         self.clear()
 
-    def get_vector(self, numerical_vector: np.ndarray | list | tuple, **kwargs):
+    def get_vector(self, numerical_vector: Vector3DLike, **kwargs: Any) -> Arrow:
         """
         Returns an arrow on the Plane given an input numerical vector.
 
@@ -128,19 +161,21 @@ class VectorScene(Scene):
             The Arrow representing the Vector.
         """
         return Arrow(
-            self.plane.coords_to_point(0, 0),
-            self.plane.coords_to_point(*numerical_vector[:2]),
+            # TODO
+            # error: "VectorScene" has no attribute "plane"  [attr-defined]
+            self.plane.coords_to_point(0, 0),  # type: ignore[attr-defined]
+            self.plane.coords_to_point(*numerical_vector[:2]),  # type: ignore[attr-defined]
             buff=0,
             **kwargs,
         )
 
     def add_vector(
         self,
-        vector: Arrow | list | tuple | np.ndarray,
-        color: str = YELLOW,
+        vector: Arrow | Vector3DLike,
+        color: ParsableManimColor | Iterable[ParsableManimColor] = YELLOW,
         animate: bool = True,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> Arrow:
         """
         Returns the Vector after adding it to the Plane.
 
@@ -170,13 +205,13 @@ class VectorScene(Scene):
             The arrow representing the vector.
         """
         if not isinstance(vector, Arrow):
-            vector = Vector(vector, color=color, **kwargs)
+            vector = Vector(np.asarray(vector), color=color, **kwargs)
         if animate:
             self.play(GrowArrow(vector))
         self.add(vector)
         return vector
 
-    def write_vector_coordinates(self, vector: Arrow, **kwargs):
+    def write_vector_coordinates(self, vector: Vector, **kwargs: Any) -> Matrix:
         """
         Returns a column matrix indicating the vector coordinates,
         after writing them to the screen.
@@ -194,11 +229,15 @@ class VectorScene(Scene):
         :class:`.Matrix`
             The column matrix representing the vector.
         """
-        coords = vector.coordinate_label(**kwargs)
+        coords: Matrix = vector.coordinate_label(**kwargs)
         self.play(Write(coords))
         return coords
 
-    def get_basis_vectors(self, i_hat_color: str = X_COLOR, j_hat_color: str = Y_COLOR):
+    def get_basis_vectors(
+        self,
+        i_hat_color: ParsableManimColor | Iterable[ParsableManimColor] = X_COLOR,
+        j_hat_color: ParsableManimColor | Iterable[ParsableManimColor] = Y_COLOR,
+    ) -> VGroup:
         """
         Returns a VGroup of the Basis Vectors (1,0) and (0,1)
 
@@ -217,12 +256,16 @@ class VectorScene(Scene):
         """
         return VGroup(
             *(
-                Vector(vect, color=color, stroke_width=self.basis_vector_stroke_width)
+                Vector(
+                    np.asarray(vect),
+                    color=color,
+                    stroke_width=self.basis_vector_stroke_width,
+                )
                 for vect, color in [([1, 0], i_hat_color), ([0, 1], j_hat_color)]
             )
         )
 
-    def get_basis_vector_labels(self, **kwargs):
+    def get_basis_vector_labels(self, **kwargs: Any) -> VGroup:
         """
         Returns naming labels for the basis vectors.
 
@@ -254,13 +297,13 @@ class VectorScene(Scene):
     def get_vector_label(
         self,
         vector: Vector,
-        label,
+        label: MathTex | str,
         at_tip: bool = False,
         direction: str = "left",
         rotate: bool = False,
-        color: str | None = None,
+        color: ParsableManimColor | None = None,
         label_scale_factor: float = LARGE_BUFF - 0.2,
-    ):
+    ) -> MathTex:
         """
         Returns naming labels for the passed vector.
 
@@ -288,11 +331,14 @@ class VectorScene(Scene):
         """
         if not isinstance(label, MathTex):
             if len(label) == 1:
-                label = "\\vec{\\textbf{%s}}" % label
+                label = "\\vec{\\textbf{%s}}" % label  # noqa: UP031
             label = MathTex(label)
             if color is None:
-                color = vector.get_color()
-            label.set_color(color)
+                prepared_color: ParsableManimColor = vector.get_color()
+            else:
+                prepared_color = color
+            label.set_color(prepared_color)
+        assert isinstance(label, MathTex)
         label.scale(label_scale_factor)
         label.add_background_rectangle()
 
@@ -305,16 +351,18 @@ class VectorScene(Scene):
             if not rotate:
                 label.rotate(-angle, about_point=ORIGIN)
             if direction == "left":
-                label.shift(-label.get_bottom() + 0.1 * UP)
+                temp_shift_1: Vector3D = np.asarray(label.get_bottom())
+                label.shift(-temp_shift_1 + 0.1 * UP)
             else:
-                label.shift(-label.get_top() + 0.1 * DOWN)
+                temp_shift_2: Vector3D = np.asarray(label.get_top())
+                label.shift(-temp_shift_2 + 0.1 * DOWN)
             label.rotate(angle, about_point=ORIGIN)
             label.shift((vector.get_end() - vector.get_start()) / 2)
         return label
 
     def label_vector(
-        self, vector: Vector, label: MathTex | str, animate: bool = True, **kwargs
-    ):
+        self, vector: Vector, label: MathTex | str, animate: bool = True, **kwargs: Any
+    ) -> MathTex:
         """
         Shortcut method for creating, and animating the addition of
         a label for the vector.
@@ -338,38 +386,38 @@ class VectorScene(Scene):
         :class:`~.MathTex`
             The MathTex of the label.
         """
-        label = self.get_vector_label(vector, label, **kwargs)
+        mathtex_label = self.get_vector_label(vector, label, **kwargs)
         if animate:
-            self.play(Write(label, run_time=1))
-        self.add(label)
-        return label
+            self.play(Write(mathtex_label, run_time=1))
+        self.add(mathtex_label)
+        return mathtex_label
 
     def position_x_coordinate(
         self,
-        x_coord,
-        x_line,
-        vector,
-    ):  # TODO Write DocStrings for this.
+        x_coord: MathTex,
+        x_line: Line,
+        vector: Vector3DLike,
+    ) -> MathTex:  # TODO Write DocStrings for this.
         x_coord.next_to(x_line, -np.sign(vector[1]) * UP)
         x_coord.set_color(X_COLOR)
         return x_coord
 
     def position_y_coordinate(
         self,
-        y_coord,
-        y_line,
-        vector,
-    ):  # TODO Write DocStrings for this.
+        y_coord: MathTex,
+        y_line: Line,
+        vector: Vector3DLike,
+    ) -> MathTex:  # TODO Write DocStrings for this.
         y_coord.next_to(y_line, np.sign(vector[0]) * RIGHT)
         y_coord.set_color(Y_COLOR)
         return y_coord
 
     def coords_to_vector(
         self,
-        vector: np.ndarray | list | tuple,
-        coords_start: np.ndarray | list | tuple = 2 * RIGHT + 2 * UP,
+        vector: Vector2DLike,
+        coords_start: Point3DLike = 2 * RIGHT + 2 * UP,
         clean_up: bool = True,
-    ):
+    ) -> None:
         """
         This method writes the vector as a column matrix (henceforth called the label),
         takes the values in it one by one, and form the corresponding
@@ -400,26 +448,29 @@ class VectorScene(Scene):
         y_line = Line(x_line.get_end(), arrow.get_end())
         x_line.set_color(X_COLOR)
         y_line.set_color(Y_COLOR)
-        x_coord, y_coord = array.get_mob_matrix().flatten()
+        mob_matrix = array.get_mob_matrix()
+        x_coord = mob_matrix[0][0]
+        y_coord = mob_matrix[1][0]
 
         self.play(Write(array, run_time=1))
         self.wait()
         self.play(
             ApplyFunction(
-                lambda x: self.position_x_coordinate(x, x_line, vector),
+                lambda x: self.position_x_coordinate(x, x_line, vector),  # type: ignore[arg-type]
                 x_coord,
             ),
         )
         self.play(Create(x_line))
         animations = [
             ApplyFunction(
-                lambda y: self.position_y_coordinate(y, y_line, vector),
+                lambda y: self.position_y_coordinate(y, y_line, vector),  # type: ignore[arg-type]
                 y_coord,
             ),
             FadeOut(array.get_brackets()),
         ]
         self.play(*animations)
-        y_coord, _ = (anim.mobject for anim in animations)
+        # TODO: Can we delete the line below? I don't think it have any purpose.
+        # y_coord, _ = (anim.mobject for anim in animations)
         self.play(Create(y_line))
         self.play(Create(arrow))
         self.wait()
@@ -429,10 +480,10 @@ class VectorScene(Scene):
 
     def vector_to_coords(
         self,
-        vector: np.ndarray | list | tuple,
+        vector: Vector3DLike,
         integer_labels: bool = True,
         clean_up: bool = True,
-    ):
+    ) -> tuple[Matrix, Line, Line]:
         """
         This method displays vector as a Vector() based vector, and then shows
         the corresponding lines that make up the x and y components of the vector.
@@ -466,7 +517,7 @@ class VectorScene(Scene):
         y_line = Line(x_line.get_end(), arrow.get_end())
         x_line.set_color(X_COLOR)
         y_line.set_color(Y_COLOR)
-        x_coord, y_coord = array.get_entries()
+        x_coord, y_coord = cast(VGroup, array.get_entries())
         x_coord_start = self.position_x_coordinate(x_coord.copy(), x_line, vector)
         y_coord_start = self.position_y_coordinate(y_coord.copy(), y_line, vector)
         brackets = array.get_brackets()
@@ -490,7 +541,7 @@ class VectorScene(Scene):
             self.add(*starting_mobjects)
         return array, x_line, y_line
 
-    def show_ghost_movement(self, vector: Arrow | list | tuple | np.ndarray):
+    def show_ghost_movement(self, vector: Arrow | Vector2DLike | Vector3DLike) -> None:
         """
         This method plays an animation that partially shows the entire plane moving
         in the direction of a particular vector. This is useful when you wish to
@@ -504,20 +555,26 @@ class VectorScene(Scene):
         """
         if isinstance(vector, Arrow):
             vector = vector.get_end() - vector.get_start()
-        elif len(vector) == 2:
-            vector = np.append(np.array(vector), 0.0)
-        x_max = int(config["frame_x_radius"] + abs(vector[0]))
-        y_max = int(config["frame_y_radius"] + abs(vector[1]))
+        else:
+            vector = np.asarray(vector)
+            if len(vector) == 2:
+                vector = np.append(np.array(vector), 0.0)
+        vector_cleaned: Vector3D = vector
+
+        x_max = int(config["frame_x_radius"] + abs(vector_cleaned[0]))
+        y_max = int(config["frame_y_radius"] + abs(vector_cleaned[1]))
+        # TODO:
+        # I think that this should be a VGroup instead of a VMobject.
         dots = VMobject(
-            *(
+            *(  # type: ignore[arg-type]
                 Dot(x * RIGHT + y * UP)
                 for x in range(-x_max, x_max)
                 for y in range(-y_max, y_max)
             )
         )
         dots.set_fill(BLACK, opacity=0)
-        dots_halfway = dots.copy().shift(vector / 2).set_fill(WHITE, 1)
-        dots_end = dots.copy().shift(vector)
+        dots_halfway = dots.copy().shift(vector_cleaned / 2).set_fill(WHITE, 1)
+        dots_end = dots.copy().shift(vector_cleaned)
 
         self.play(Transform(dots, dots_halfway, rate_func=rush_into))
         self.play(Transform(dots, dots_end, rate_func=rush_from))
@@ -558,11 +615,12 @@ class LinearTransformationScene(VectorScene):
     .. manim:: LinearTransformationSceneExample
 
         class LinearTransformationSceneExample(LinearTransformationScene):
-            def __init__(self):
+            def __init__(self, **kwargs):
                 LinearTransformationScene.__init__(
                     self,
                     show_coordinates=True,
                     leave_ghost_vectors=True,
+                    **kwargs
                 )
 
             def construct(self):
@@ -575,17 +633,16 @@ class LinearTransformationScene(VectorScene):
         self,
         include_background_plane: bool = True,
         include_foreground_plane: bool = True,
-        background_plane_kwargs: dict | None = None,
-        foreground_plane_kwargs: dict | None = None,
+        background_plane_kwargs: dict[str, Any] | None = None,
+        foreground_plane_kwargs: dict[str, Any] | None = None,
         show_coordinates: bool = False,
         show_basis_vectors: bool = True,
         basis_vector_stroke_width: float = 6,
-        i_hat_color: Color = X_COLOR,
-        j_hat_color: Color = Y_COLOR,
+        i_hat_color: ParsableManimColor = X_COLOR,
+        j_hat_color: ParsableManimColor = Y_COLOR,
         leave_ghost_vectors: bool = False,
-        **kwargs,
-    ):
-
+        **kwargs: Any,
+    ) -> None:
         super().__init__(**kwargs)
 
         self.include_background_plane = include_background_plane
@@ -593,10 +650,10 @@ class LinearTransformationScene(VectorScene):
         self.show_coordinates = show_coordinates
         self.show_basis_vectors = show_basis_vectors
         self.basis_vector_stroke_width = basis_vector_stroke_width
-        self.i_hat_color = i_hat_color
-        self.j_hat_color = j_hat_color
+        self.i_hat_color = ManimColor(i_hat_color)
+        self.j_hat_color = ManimColor(j_hat_color)
         self.leave_ghost_vectors = leave_ghost_vectors
-        self.background_plane_kwargs = {
+        self.background_plane_kwargs: dict[str, Any] = {
             "color": GREY,
             "axis_config": {
                 "color": GREY,
@@ -607,7 +664,9 @@ class LinearTransformationScene(VectorScene):
             },
         }
 
-        self.foreground_plane_kwargs = {
+        self.ghost_vectors = VGroup()
+
+        self.foreground_plane_kwargs: dict[str, Any] = {
             "x_range": np.array([-config["frame_width"], config["frame_width"], 1.0]),
             "y_range": np.array([-config["frame_width"], config["frame_width"], 1.0]),
             "faded_line_ratio": 1,
@@ -619,22 +678,25 @@ class LinearTransformationScene(VectorScene):
         )
 
     @staticmethod
-    def update_default_configs(default_configs, passed_configs):
+    def update_default_configs(
+        default_configs: Iterable[dict[str, Any]],
+        passed_configs: Iterable[dict[str, Any] | None],
+    ) -> None:
         for default_config, passed_config in zip(default_configs, passed_configs):
             if passed_config is not None:
                 update_dict_recursively(default_config, passed_config)
 
-    def setup(self):
+    def setup(self) -> None:
         # The has_already_setup attr is to not break all the old Scenes
         if hasattr(self, "has_already_setup"):
             return
         self.has_already_setup = True
-        self.background_mobjects = []
-        self.foreground_mobjects = []
-        self.transformable_mobjects = []
-        self.moving_vectors = []
-        self.transformable_labels = []
-        self.moving_mobjects = []
+        self.background_mobjects: list[Mobject] = []
+        self.foreground_mobjects: list[Mobject] = []
+        self.transformable_mobjects: list[Mobject] = []
+        self.moving_vectors: list[Mobject] = []
+        self.transformable_labels: list[MathTex] = []
+        self.moving_mobjects: list[Mobject] = []
 
         self.background_plane = NumberPlane(**self.background_plane_kwargs)
 
@@ -654,7 +716,9 @@ class LinearTransformationScene(VectorScene):
             self.i_hat, self.j_hat = self.basis_vectors
             self.add(self.basis_vectors)
 
-    def add_special_mobjects(self, mob_list: list, *mobs_to_add: Mobject):
+    def add_special_mobjects(
+        self, mob_list: list[Mobject], *mobs_to_add: Mobject
+    ) -> None:
         """
         Adds mobjects to a separate list that can be tracked,
         if these mobjects have some extra importance.
@@ -674,7 +738,7 @@ class LinearTransformationScene(VectorScene):
                 mob_list.append(mobject)
                 self.add(mobject)
 
-    def add_background_mobject(self, *mobjects: Mobject):
+    def add_background_mobject(self, *mobjects: Mobject) -> None:
         """
         Adds the mobjects to the special list
         self.background_mobjects.
@@ -686,8 +750,9 @@ class LinearTransformationScene(VectorScene):
         """
         self.add_special_mobjects(self.background_mobjects, *mobjects)
 
-    # TODO, this conflicts with Scene.add_fore
-    def add_foreground_mobject(self, *mobjects: Mobject):
+    # TODO, this conflicts with Scene.add_foreground_mobject
+    # Please be aware that there is also the method Scene.add_foreground_mobjects.
+    def add_foreground_mobject(self, *mobjects: Mobject) -> None:  # type: ignore[override]
         """
         Adds the mobjects to the special list
         self.foreground_mobjects.
@@ -699,7 +764,7 @@ class LinearTransformationScene(VectorScene):
         """
         self.add_special_mobjects(self.foreground_mobjects, *mobjects)
 
-    def add_transformable_mobject(self, *mobjects: Mobject):
+    def add_transformable_mobject(self, *mobjects: Mobject) -> None:
         """
         Adds the mobjects to the special list
         self.transformable_mobjects.
@@ -713,7 +778,7 @@ class LinearTransformationScene(VectorScene):
 
     def add_moving_mobject(
         self, mobject: Mobject, target_mobject: Mobject | None = None
-    ):
+    ) -> None:
         """
         Adds the mobject to the special list
         self.moving_mobject, and adds a property
@@ -732,9 +797,19 @@ class LinearTransformationScene(VectorScene):
         mobject.target = target_mobject
         self.add_special_mobjects(self.moving_mobjects, mobject)
 
+    def get_ghost_vectors(self) -> VGroup:
+        """
+        Returns all ghost vectors ever added to ``self``. Each element is a ``VGroup`` of
+        two ghost vectors.
+        """
+        return self.ghost_vectors
+
     def get_unit_square(
-        self, color: str = YELLOW, opacity: float = 0.3, stroke_width: float = 3
-    ):
+        self,
+        color: ParsableManimColor | Iterable[ParsableManimColor] = YELLOW,
+        opacity: float = 0.3,
+        stroke_width: float = 3,
+    ) -> Rectangle:
         """
         Returns a unit square for the current NumberPlane.
 
@@ -765,7 +840,7 @@ class LinearTransformationScene(VectorScene):
         square.move_to(self.plane.coords_to_point(0, 0), DL)
         return square
 
-    def add_unit_square(self, animate: bool = False, **kwargs):
+    def add_unit_square(self, animate: bool = False, **kwargs: Any) -> Self:
         """
         Adds a unit square to the scene via
         self.get_unit_square.
@@ -796,8 +871,12 @@ class LinearTransformationScene(VectorScene):
         return self
 
     def add_vector(
-        self, vector: Arrow | list | tuple | np.ndarray, color: str = YELLOW, **kwargs
-    ):
+        self,
+        vector: Arrow | list | tuple | np.ndarray,
+        color: ParsableManimColor = YELLOW,
+        animate: bool = False,
+        **kwargs: Any,
+    ) -> Arrow:
         """
         Adds a vector to the scene, and puts it in the special
         list self.moving_vectors.
@@ -821,11 +900,11 @@ class LinearTransformationScene(VectorScene):
         Arrow
             The arrow representing the vector.
         """
-        vector = super().add_vector(vector, color=color, **kwargs)
+        vector = super().add_vector(vector, color=color, animate=animate, **kwargs)
         self.moving_vectors.append(vector)
         return vector
 
-    def write_vector_coordinates(self, vector: Arrow, **kwargs):
+    def write_vector_coordinates(self, vector: Vector, **kwargs: Any) -> Matrix:
         """
         Returns a column matrix indicating the vector coordinates,
         after writing them to the screen, and adding them to the
@@ -854,8 +933,8 @@ class LinearTransformationScene(VectorScene):
         label: MathTex | str,
         transformation_name: str | MathTex = "L",
         new_label: str | MathTex | None = None,
-        **kwargs,
-    ):
+        **kwargs: Any,
+    ) -> MathTex:
         """
         Method for creating, and animating the addition of
         a transformable label for the vector.
@@ -882,27 +961,27 @@ class LinearTransformationScene(VectorScene):
         :class:`~.MathTex`
             The MathTex of the label.
         """
+        # TODO: Clear up types in this function. This is currently a mess.
         label_mob = self.label_vector(vector, label, **kwargs)
         if new_label:
-            label_mob.target_text = new_label
+            label_mob.target_text = new_label  # type: ignore[attr-defined]
         else:
-            label_mob.target_text = "{}({})".format(
-                transformation_name,
-                label_mob.get_tex_string(),
+            label_mob.target_text = (  # type: ignore[attr-defined]
+                f"{transformation_name}({label_mob.get_tex_string()})"
             )
-        label_mob.vector = vector
-        label_mob.kwargs = kwargs
+        label_mob.vector = vector  # type: ignore[attr-defined]
+        label_mob.kwargs = kwargs  # type: ignore[attr-defined]
         if "animate" in label_mob.kwargs:
             label_mob.kwargs.pop("animate")
         self.transformable_labels.append(label_mob)
-        return label_mob
+        return cast(MathTex, label_mob)
 
     def add_title(
         self,
         title: str | MathTex | Tex,
         scale_factor: float = 1.5,
         animate: bool = False,
-    ):
+    ) -> Self:
         """
         Adds a title, after scaling it, adding a background rectangle,
         moving it to the top and adding it to foreground_mobjects adding
@@ -934,7 +1013,9 @@ class LinearTransformationScene(VectorScene):
         self.title = title
         return self
 
-    def get_matrix_transformation(self, matrix: np.ndarray | list | tuple):
+    def get_matrix_transformation(
+        self, matrix: np.ndarray | list | tuple
+    ) -> Callable[[Point3D], Point3D]:
         """
         Returns a function corresponding to the linear
         transformation represented by the matrix passed.
@@ -948,7 +1029,7 @@ class LinearTransformationScene(VectorScene):
 
     def get_transposed_matrix_transformation(
         self, transposed_matrix: np.ndarray | list | tuple
-    ):
+    ) -> Callable[[Point3D], Point3D]:
         """
         Returns a function corresponding to the linear
         transformation represented by the transposed
@@ -968,7 +1049,7 @@ class LinearTransformationScene(VectorScene):
             raise ValueError("Matrix has bad dimensions")
         return lambda point: np.dot(point, transposed_matrix)
 
-    def get_piece_movement(self, pieces: list | tuple | np.ndarray):
+    def get_piece_movement(self, pieces: Iterable[Mobject]) -> Transform:
         """
         This method returns an animation that moves an arbitrary
         mobject in "pieces" to its corresponding .target value.
@@ -985,13 +1066,18 @@ class LinearTransformationScene(VectorScene):
         Animation
             The animation of the movement.
         """
-        start = VGroup(*pieces)
-        target = VGroup(*(mob.target for mob in pieces))
-        if self.leave_ghost_vectors:
-            self.add(start.copy().fade(0.7))
+        v_pieces = [piece for piece in pieces if isinstance(piece, VMobject)]
+        start = VGroup(*v_pieces)
+        target = VGroup(*(mob.target for mob in v_pieces))
+
+        # don't add empty VGroups
+        if self.leave_ghost_vectors and start.submobjects:
+            # start.copy() gives a VGroup of Vectors
+            self.ghost_vectors.add(start.copy().fade(0.7))
+            self.add(self.ghost_vectors[-1])
         return Transform(start, target, lag_ratio=0)
 
-    def get_moving_mobject_movement(self, func: Callable[[np.ndarray], np.ndarray]):
+    def get_moving_mobject_movement(self, func: MappingFunction) -> Transform:
         """
         This method returns an animation that moves a mobject
         in "self.moving_mobjects"  to its corresponding .target value.
@@ -1012,11 +1098,12 @@ class LinearTransformationScene(VectorScene):
         for m in self.moving_mobjects:
             if m.target is None:
                 m.target = m.copy()
-            target_point = func(m.get_center())
+            temp: Point3D = m.get_center()
+            target_point = func(temp)
             m.target.move_to(target_point)
         return self.get_piece_movement(self.moving_mobjects)
 
-    def get_vector_movement(self, func: Callable[[np.ndarray], np.ndarray]):
+    def get_vector_movement(self, func: MappingFunction) -> Transform:
         """
         This method returns an animation that moves a mobject
         in "self.moving_vectors"  to its corresponding .target value.
@@ -1036,12 +1123,12 @@ class LinearTransformationScene(VectorScene):
         """
         for v in self.moving_vectors:
             v.target = Vector(func(v.get_end()), color=v.get_color())
-            norm = np.linalg.norm(v.target.get_end())
+            norm = float(np.linalg.norm(v.target.get_end()))
             if norm < 0.1:
                 v.target.get_tip().scale(norm)
         return self.get_piece_movement(self.moving_vectors)
 
-    def get_transformable_label_movement(self):
+    def get_transformable_label_movement(self) -> Transform:
         """
         This method returns an animation that moves all labels
         in "self.transformable_labels" to its corresponding .target .
@@ -1052,12 +1139,17 @@ class LinearTransformationScene(VectorScene):
             The animation of the movement.
         """
         for label in self.transformable_labels:
+            # TODO: This location and lines 933 and 335 are the only locations in
+            # the code where the target_text property is referenced.
+            target_text: MathTex | str = label.target_text  # type: ignore[assignment]
             label.target = self.get_vector_label(
-                label.vector.target, label.target_text, **label.kwargs
+                label.vector.target,  # type: ignore[attr-defined]
+                target_text,
+                **label.kwargs,  # type: ignore[arg-type]
             )
         return self.get_piece_movement(self.transformable_labels)
 
-    def apply_matrix(self, matrix: np.ndarray | list | tuple, **kwargs):
+    def apply_matrix(self, matrix: np.ndarray | list | tuple, **kwargs: Any) -> None:
         """
         Applies the transformation represented by the
         given matrix to the number plane, and each vector/similar
@@ -1072,7 +1164,7 @@ class LinearTransformationScene(VectorScene):
         """
         self.apply_transposed_matrix(np.array(matrix).T, **kwargs)
 
-    def apply_inverse(self, matrix: np.ndarray | list | tuple, **kwargs):
+    def apply_inverse(self, matrix: np.ndarray | list | tuple, **kwargs: Any) -> None:
         """
         This method applies the linear transformation
         represented by the inverse of the passed matrix
@@ -1088,8 +1180,8 @@ class LinearTransformationScene(VectorScene):
         self.apply_matrix(np.linalg.inv(matrix), **kwargs)
 
     def apply_transposed_matrix(
-        self, transposed_matrix: np.ndarray | list | tuple, **kwargs
-    ):
+        self, transposed_matrix: np.ndarray | list | tuple, **kwargs: Any
+    ) -> None:
         """
         Applies the transformation represented by the
         given transposed matrix to the number plane,
@@ -1110,7 +1202,9 @@ class LinearTransformationScene(VectorScene):
             kwargs["path_arc"] = net_rotation
         self.apply_function(func, **kwargs)
 
-    def apply_inverse_transpose(self, t_matrix: np.ndarray | list | tuple, **kwargs):
+    def apply_inverse_transpose(
+        self, t_matrix: np.ndarray | list | tuple, **kwargs: Any
+    ) -> None:
         """
         Applies the inverse of the transformation represented
         by the given transposed matrix to the number plane and each
@@ -1127,8 +1221,8 @@ class LinearTransformationScene(VectorScene):
         self.apply_transposed_matrix(t_inv, **kwargs)
 
     def apply_nonlinear_transformation(
-        self, function: Callable[[np.ndarray], np.ndarray], **kwargs
-    ):
+        self, function: Callable[[np.ndarray], np.ndarray], **kwargs: Any
+    ) -> None:
         """
         Applies the non-linear transformation represented
         by the given function to the number plane and each
@@ -1146,10 +1240,10 @@ class LinearTransformationScene(VectorScene):
 
     def apply_function(
         self,
-        function: Callable[[np.ndarray], np.ndarray],
-        added_anims: list = [],
-        **kwargs,
-    ):
+        function: MappingFunction,
+        added_anims: list[Animation] = [],
+        **kwargs: Any,
+    ) -> None:
         """
         Applies the given function to each of the mobjects in
         self.transformable_mobjects, and plays the animation showing
@@ -1172,7 +1266,7 @@ class LinearTransformationScene(VectorScene):
             kwargs["run_time"] = 3
         anims = (
             [
-                ApplyPointwiseFunction(function, t_mob)
+                ApplyPointwiseFunction(function, t_mob)  # type: ignore[arg-type]
                 for t_mob in self.transformable_mobjects
             ]
             + [