Fix 3D ImageMobject rotation

Author: chopan050

manim/camera/camera.py

@@ -15,19 +15,18 @@
 import cairo
 import numpy as np
 from PIL import Image
-from scipy.spatial.distance import pdist
-
-from .. import config, logger
-from ..constants import *
-from ..mobject.mobject import Mobject
-from ..mobject.types.image_mobject import AbstractImageMobject
-from ..mobject.types.point_cloud_mobject import PMobject
-from ..mobject.types.vectorized_mobject import VMobject
-from ..utils.color import ManimColor, ParsableManimColor, color_to_int_rgba
-from ..utils.family import extract_mobject_family_members
-from ..utils.images import get_full_raster_image_path
-from ..utils.iterables import list_difference_update
-from ..utils.space_ops import angle_of_vector
+
+from manim._config import config, logger
+from manim.constants import *
+from manim.mobject.mobject import Mobject
+from manim.mobject.types.image_mobject import AbstractImageMobject
+from manim.mobject.types.point_cloud_mobject import PMobject
+from manim.mobject.types.vectorized_mobject import VMobject
+from manim.typing import ManimFloat
+from manim.utils.color import ManimColor, ParsableManimColor, color_to_int_rgba
+from manim.utils.family import extract_mobject_family_members
+from manim.utils.images import get_full_raster_image_path
+from manim.utils.iterables import list_difference_update
 
 LINE_JOIN_MAP = {
     LineJointType.AUTO: None,  # TODO: this could be improved
@@ -973,48 +972,60 @@ def display_image_mobject(
         pixel_array
             The Pixel array to put the imagemobject in.
         """
-        corner_coords = self.points_to_pixel_coords(image_mobject, image_mobject.points)
-        ul_coords, ur_coords, dl_coords, _ = corner_coords
-        right_vect = ur_coords - ul_coords
-        down_vect = dl_coords - ul_coords
-        center_coords = ul_coords + (right_vect + down_vect) / 2
-
         sub_image = Image.fromarray(image_mobject.get_pixel_array(), mode="RGBA")
-
-        # Reshape
-        pixel_width = max(int(pdist([ul_coords, ur_coords]).item()), 1)
-        pixel_height = max(int(pdist([ul_coords, dl_coords]).item()), 1)
-        sub_image = sub_image.resize(
-            (pixel_width, pixel_height),
-            resample=image_mobject.resampling_algorithm,
+        original_coords = np.array(
+            [
+                [0, 0],
+                [sub_image.width, 0],
+                [0, sub_image.height],
+                [sub_image.width, sub_image.height],
+            ]
+        )
+        target_coords = self.points_to_pixel_coords(image_mobject, image_mobject.points)
+        shift_vector = np.array(
+            [
+                min(*[x for x, y in target_coords]),
+                min(*[y for x, y in target_coords]),
+            ]
+        )
+        target_coords -= shift_vector
+        target_size = (
+            max(*[x for x, y in target_coords]),
+            max(*[y for x, y in target_coords]),
         )
 
-        # 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_mobject.resampling_algorithm,
-                expand=1,
+        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]]
             )
 
-        # TODO, there is no accounting for a shear...
+        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
+            method=Image.Transform.PERSPECTIVE,
+            data=transform_coefficients,
+            resample=image_mobject.resampling_algorithm,
+        )
 
         # 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",
         )
-        new_ul_coords = center_coords - np.array(sub_image.size) / 2
-        new_ul_coords = new_ul_coords.astype(int)
         full_image.paste(
             sub_image,
             box=(
-                new_ul_coords[0],
-                new_ul_coords[1],
-                new_ul_coords[0] + sub_image.size[0],
-                new_ul_coords[1] + sub_image.size[1],
+                shift_vector[0],
+                shift_vector[1],
+                shift_vector[0] + target_size[0],
+                shift_vector[1] + target_size[1],
             ),
         )
         # Paint on top of existing pixel array