Support for specifying the interpolation algorithms for individual ImageMobjects (#1122)

* Adds support for specifying the interpolation algorithms for individual ImageMobjects.

* Remove setup.py

* Added a proper unit test

* Code formatting

* Adds Doc string

* Test rewritten by  kolibril13

* Added control data to the test

* Replaces string resampling constants with Pillow integers; renames the constants into o 'resampling algorithms'

* Final 'nitpicks'

* ValueError update

* update example

* [pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Co-authored-by: kolibril13 <[email protected]>
Co-authored-by: pre-commit-ci[bot] <66853113+pre-commit-ci[bot]@users.noreply.github.com>

Author: 3 people

manim/camera/camera.py

@@ -890,7 +890,7 @@ def display_multiple_image_mobjects(self, image_mobjects, pixel_array):
         for image_mobject in image_mobjects:
             self.display_image_mobject(image_mobject, pixel_array)
 
-    def display_image_mobject(self, image_mobject, pixel_array):
+    def display_image_mobject(self, image_mobject: AbstractImageMobject, pixel_array):
         """Displays an ImageMobject by changing the pixel_array suitably.
 
         Parameters
@@ -912,15 +912,15 @@ def display_image_mobject(self, image_mobject, pixel_array):
         pixel_width = max(int(pdist([ul_coords, ur_coords])), 1)
         pixel_height = max(int(pdist([ul_coords, dl_coords])), 1)
         sub_image = sub_image.resize(
-            (pixel_width, pixel_height), resample=Image.BICUBIC
+            (pixel_width, pixel_height), resample=image_mobject.resampling_algorithm
         )
 
         # Rotate
         angle = angle_of_vector(right_vect)
         adjusted_angle = -int(360 * angle / TAU)
         if adjusted_angle != 0:
             sub_image = sub_image.rotate(
-                adjusted_angle, resample=Image.BICUBIC, expand=1
+                adjusted_angle, resample=image_mobject.resampling_algorithm, expand=1
             )
 
         # TODO, there is no accounting for a shear...

manim/constants.py

@@ -5,6 +5,7 @@
 import typing
 
 import numpy as np
+from PIL import Image
 
 # Messages
 NOT_SETTING_FONT_MSG: str = """
@@ -42,6 +43,18 @@
 HEAVY: str = "HEAVY"
 ULTRAHEAVY: str = "ULTRAHEAVY"
 
+RESAMPLING_ALGORITHMS = {
+    "nearest": Image.NEAREST,
+    "none": Image.NEAREST,
+    "lanczos": Image.LANCZOS,
+    "antialias": Image.LANCZOS,
+    "bilinear": Image.BILINEAR,
+    "linear": Image.BILINEAR,
+    "bicubic": Image.BICUBIC,
+    "cubic": Image.BICUBIC,
+    "box": Image.BOX,
+    "hamming": Image.HAMMING,
+}
 
 # Geometry: directions
 ORIGIN: np.ndarray = np.array((0.0, 0.0, 0.0))

manim/mobject/types/image_mobject.py

@@ -30,9 +30,16 @@ class AbstractImageMobject(Mobject):
         This is a custom parameter of ImageMobject so that rendering a scene with e.g. the ``--quality low`` or ``--quality medium`` flag for faster rendering won't effect the position of the image on the screen.
     """
 
-    def __init__(self, scale_to_resolution, pixel_array_dtype="uint8", **kwargs):
+    def __init__(
+        self,
+        scale_to_resolution,
+        pixel_array_dtype="uint8",
+        resampling_algorithm=Image.BICUBIC,
+        **kwargs,
+    ):
         self.pixel_array_dtype = pixel_array_dtype
         self.scale_to_resolution = scale_to_resolution
+        self.set_resampling_algorithm(resampling_algorithm)
         Mobject.__init__(self, **kwargs)
 
     def get_pixel_array(self):
@@ -42,6 +49,28 @@ def set_color(self):
         # Likely to be implemented in subclasses, but no obligation
         pass
 
+    def set_resampling_algorithm(self, resampling_algorithm):
+        """
+        Sets the interpolation method for upscaling the image. By default the image is interpolated using bicubic algorithm. This method lets you change it.
+        Interpolation is done internally using Pillow, and the function besides the string constants describing the algorithm accepts the Pillow integer constants.
+
+        Parameters
+        ----------
+        resampling_algorithm : :class:`int`, an integer constant described in the Pillow library, or one from the RESAMPLING_ALGORITHMS global dictionary, under the following keys:
+         * 'bicubic' or 'cubic'
+         * 'nearest' or 'none'
+         * 'box'
+         * 'bilinear' or 'linear'
+         * 'hamming'
+         * 'lanczos' or 'antialias'
+        """
+        if isinstance(resampling_algorithm, int):
+            self.resampling_algorithm = resampling_algorithm
+        else:
+            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'."
+            )
+
     def reset_points(self):
         # Corresponding corners of image are fixed to these 3 points
         self.points = np.array(
@@ -83,6 +112,41 @@ def construct(self):
                 image.height = 7
                 self.add(image)
 
+
+    Changing interpolation style:
+
+    .. manim:: ImageInterpolationEx
+        :save_last_frame:
+
+        class ImageInterpolationEx(Scene):
+            def construct(self):
+                img = ImageMobject(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"])
+                img1.add(Text("nearest").scale(0.5).next_to(img1,UP))
+                img2.add(Text("lanczos").scale(0.5).next_to(img2,UP))
+                img3.add(Text("linear").scale(0.5).next_to(img3,UP))
+                img4.add(Text("cubic").scale(0.5).next_to(img4,UP))
+                img5.add(Text("box").scale(0.5).next_to(img5,UP))
+
+                x= Group(img1,img2,img3,img4,img5)
+                x.arrange()
+                self.add(x)
     """
 
     def __init__(

tests/control_data/graphical_units_data/img_and_svg/ImageInterpolationTest.npz

@@ -232,6 +232,30 @@ def construct(self):
         self.wait(1)
 
 
+class ImageInterpolationTest(Scene):
+    def construct(self):
+        img = ImageMobject(
+            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"])
+
+        self.add(img1, img2, img3, img4, img5)
+        [s.shift(4 * LEFT + pos * 2 * RIGHT) for pos, s in enumerate(self.mobjects)]
+        self.wait()
+
+
 MODULE_NAME = "img_and_svg"