Remove lanczos, box and hamming resampling algorithms

Author: chopan050

manim/camera/camera.py

@@ -962,15 +962,15 @@ def display_multiple_image_mobjects(
 
     def display_image_mobject(
         self, image_mobject: AbstractImageMobject, pixel_array: np.ndarray
-    ):
-        """Displays an ImageMobject by changing the pixel_array suitably.
+    ) -> None:
+        """Displays an :class:`~.ImageMobject` by changing the ``pixel_array`` suitably.
 
         Parameters
         ----------
         image_mobject
-            The imageMobject to display
+            The :class:`~.ImageMobject` to display.
         pixel_array
-            The Pixel array to put the imagemobject in.
+            The pixel array to put the :class:`~.ImageMobject` in.
         """
         sub_image = Image.fromarray(image_mobject.get_pixel_array(), mode="RGBA")
         original_coords = np.array(
@@ -982,6 +982,9 @@ def display_image_mobject(
             ]
         )
         target_coords = self.points_to_pixel_coords(image_mobject, image_mobject.points)
+
+        # Temporarily translate target coords to upper left corner to calculate the
+        # smallest possible size for the target image.
         shift_vector = np.array(
             [
                 min(*[x for x, y in target_coords]),
@@ -994,27 +997,29 @@ def display_image_mobject(
             max(*[y for x, y in target_coords]),
         )
 
+        # Use PIL.Image.Image.transform() to apply a perspective transform to the image.
+        # The transform coefficients must be calculated. The following is adapted from
+        # https://stackoverflow.com/questions/14177744/how-does-perspective-transformation-work-in-pil
+        # and
+        # https://web.archive.org/web/20150222120106/xenia.media.mit.edu/~cwren/interpolator/
+
         homographic_matrix = []
-        for tc, oc in zip(target_coords, original_coords):
-            homographic_matrix.append(
-                [tc[0], tc[1], 1, 0, 0, 0, -oc[0] * tc[0], -oc[0] * tc[1]]
-            )
-            homographic_matrix.append(
-                [0, 0, 0, tc[0], tc[1], 1, -oc[1] * tc[0], -oc[1] * tc[1]]
-            )
+        for (x, y), (X, Y) in zip(target_coords, original_coords):
+            homographic_matrix.append([x, y, 1, 0, 0, 0, -X * x, -X * y])
+            homographic_matrix.append([0, 0, 0, x, y, 1, -Y * x, -Y * y])
 
         A = np.array(homographic_matrix, dtype=ManimFloat)
         b = original_coords.reshape(8).astype(ManimFloat)
         transform_coefficients = np.linalg.solve(A, b)
 
         sub_image = sub_image.transform(
-            size=target_size,  # Use the smallest possible size for speed
+            size=target_size,  # Use the smallest possible size for speed.
             method=Image.Transform.PERSPECTIVE,
             data=transform_coefficients,
             resample=image_mobject.resampling_algorithm,
         )
 
-        # Paste into an image as large as the camera's pixel array
+        # Paste into an image as large as the camera's pixel array.
         full_image = Image.fromarray(
             np.zeros((self.pixel_height, self.pixel_width)),
             mode="RGBA",
@@ -1028,7 +1033,7 @@ def display_image_mobject(
                 shift_vector[1] + target_size[1],
             ),
         )
-        # Paint on top of existing pixel array
+        # Paint on top of existing pixel array.
         self.overlay_PIL_image(pixel_array, full_image)
 
     def overlay_rgba_array(self, pixel_array: np.ndarray, new_array: np.ndarray):

manim/constants.py

@@ -111,14 +111,10 @@
 RESAMPLING_ALGORITHMS = {
     "nearest": Resampling.NEAREST,
     "none": Resampling.NEAREST,
-    "lanczos": Resampling.LANCZOS,
-    "antialias": Resampling.LANCZOS,
     "bilinear": Resampling.BILINEAR,
     "linear": Resampling.BILINEAR,
     "bicubic": Resampling.BICUBIC,
     "cubic": Resampling.BICUBIC,
-    "box": Resampling.BOX,
-    "hamming": Resampling.HAMMING,
 }
 
 # Geometry: directions

manim/mobject/types/image_mobject.py

@@ -85,15 +85,15 @@ def set_resampling_algorithm(self, resampling_algorithm: int) -> Self:
             * 'hamming'
             * 'lanczos' or 'antialias'
         """
-        if isinstance(resampling_algorithm, int):
-            self.resampling_algorithm = resampling_algorithm
-        else:
+        if resampling_algorithm not in RESAMPLING_ALGORITHMS.values():
             raise ValueError(
                 "resampling_algorithm has to be an int, one of the values defined in "
                 "RESAMPLING_ALGORITHMS or a Pillow resampling filter constant. "
-                "Available algorithms: 'bicubic', 'nearest', 'box', 'bilinear', "
-                "'hamming', 'lanczos'.",
+                "Available algorithms: 'bicubic' (or 'cubic'), 'nearest' (or 'none'), "
+                "'bilinear' (or 'linear').",
             )
+
+        self.resampling_algorithm = resampling_algorithm
         return self
 
     def reset_points(self) -> None:

tests/test_graphical_units/control_data/img_and_svg/ImageInterpolation.npz

@@ -269,20 +269,14 @@ def test_ImageInterpolation(scene):
         np.uint8([[63, 0, 0, 0], [0, 127, 0, 0], [0, 0, 191, 0], [0, 0, 0, 255]]),
     )
     img.height = 2
-    img1 = img.copy()
-    img2 = img.copy()
-    img3 = img.copy()
-    img4 = img.copy()
-    img5 = img.copy()
-
-    img1.set_resampling_algorithm(RESAMPLING_ALGORITHMS["nearest"])
-    img2.set_resampling_algorithm(RESAMPLING_ALGORITHMS["lanczos"])
-    img3.set_resampling_algorithm(RESAMPLING_ALGORITHMS["linear"])
-    img4.set_resampling_algorithm(RESAMPLING_ALGORITHMS["cubic"])
-    img5.set_resampling_algorithm(RESAMPLING_ALGORITHMS["box"])
-
-    scene.add(img1, img2, img3, img4, img5)
-    [s.shift(4 * LEFT + pos * 2 * RIGHT) for pos, s in enumerate(scene.mobjects)]
+
+    algorithms = ["nearest", "bilinear", "bicubic"]
+    for pos, algorithm in enumerate(algorithms):
+        algorithm = RESAMPLING_ALGORITHMS[algorithm]
+        img_copy = img.copy().set_resampling_algorithm(algorithm)
+        img_copy.shift((2 * pos - len(algorithms) + 1) * RIGHT)
+        scene.add(img_copy)
+
     scene.wait()