this works always (for me)

Author: jrief

finder/contrib/image/pil/models.py

@@ -45,9 +45,9 @@ def save(self, **kwargs):
 
     def get_thumbnail_url(self):
         thumbnail_path = self.get_thumbnail_path(self.thumbnail_size, self.thumbnail_size)
-        if str(self.id) == 'a118a297-0931-4ee9-95c7-925624d3b7a3' or not default_storage.exists(thumbnail_path):
+        if str(self.id) == '4d4d9ae9-3120-4f24-8d57-9d15fa6edfc4' or not default_storage.exists(thumbnail_path):
             try:
-                self.crop(thumbnail_path, self.thumbnail_size, self.thumbnail_size * 2.5)
+                self.crop(thumbnail_path, self.thumbnail_size, self.thumbnail_size * .5)
             except Exception:
                 # thumbnail image could not be created
                 return self.fallback_thumbnail_url
@@ -94,7 +94,6 @@ def crop(self, thumbnail_path, width, height):
                 crop_x = 0
                 crop_y = (image.height - image.width) / 2
                 crop_resize = crop_size = image.width
-            offset_x = offset_y = 0
         # elif width > height:
         #     if width > crop_size * aspect_ratio:
         #         # extend the crop size to prevent blurry images
@@ -106,89 +105,104 @@ def crop(self, thumbnail_path, width, height):
                 crop_resize = min(image.height, height)
             else:
                 crop_resize = crop_size
-            offset_y = crop_resize - crop_size
-            offset_x = offset_y * aspect_ratio
         else:
             if width > crop_size:
                 crop_resize = min(image.width, width)
             else:
                 crop_resize = crop_size
-            offset_x = crop_resize - crop_size
-            offset_y = offset_x / aspect_ratio
+
+        # calculate the cropped area in image coordinates
+        if aspect_ratio > 1:
+            if aspect_ratio > orig_aspect_ratio:
+                min_width = max(min(crop_size * aspect_ratio, image.width), width)
+                min_height = max(min_width / aspect_ratio, height)
+            else:
+                min_width = max(min(crop_size, image.height) * aspect_ratio, width)
+                min_height = max(min_width / aspect_ratio, height)
+        else:
+            if aspect_ratio < orig_aspect_ratio:
+                min_height = max(min(crop_size / aspect_ratio, image.height), height)
+                min_width = max(min_height * aspect_ratio, width)
+            else:
+                min_height = max(min(crop_size, image.width) / aspect_ratio, height)
+                min_width = max(min_height * aspect_ratio, width)
 
         # extend the horizontal crop size to prevent blurry images
         if gravity in ('e', 'ne', 'se'):
-            if crop_resize >= crop_size:
-                crop_x # += (width - crop_resize) / 2
-            elif aspect_ratio > 1:
-                if aspect_ratio > orig_aspect_ratio:
-                    crop_x = max(crop_x - crop_resize * (aspect_ratio - 1), 0)
-            else:
-                crop_x = max(crop_x + crop_size - image.height * aspect_ratio, 0)
+            # if crop_resize > crop_size:
+            #     crop_x # += (width - crop_resize) / 2
+            # elif aspect_ratio > 1:
+            #     if aspect_ratio > orig_aspect_ratio:
+            #         crop_x = max(crop_x - crop_resize * (aspect_ratio - 1), 0)
+            # if aspect_ratio < 1:
+            #     if aspect_ratio < orig_aspect_ratio:
+            #         crop_x = max(crop_x + crop_size - image.height * aspect_ratio, 0)
+            # else:
+            #     crop_x = max(crop_x + crop_resize - min_width, 0)
+            # minax = max if aspect_ratio > 1 else min
+            crop_x = max(crop_x + max(crop_resize - min_width, 0), 0)
         elif gravity in ('w', 'nw', 'sw'):
-            if crop_resize >= crop_size:
-                crop_x = max(crop_x + crop_size - width, 0)
-            elif aspect_ratio > 1:
-                crop_x = max(crop_x - crop_resize * (aspect_ratio - 1), 0)
+            # if crop_resize > crop_size:
+            #     crop_x = max(crop_x + crop_size - width, 0)
+            # elif aspect_ratio > 1:
+            crop_x = max(crop_x - max(min(min_width - crop_size, min_width), 0), 0)
         else:  # centered crop
-            if aspect_ratio < orig_aspect_ratio and crop_resize / aspect_ratio > image.height:
-                crop_x = max(crop_x + (crop_size - image.height * aspect_ratio) / 2, 0)
-            elif False and aspect_ratio > orig_aspect_ratio and crop_resize * aspect_ratio < image.width:
-                crop_x = max(crop_x - crop_resize * (aspect_ratio - 1) / 2, 0)
-            elif crop_resize > crop_size:
-                crop_x = max(crop_x - offset_x / 2, 0)
+            # if crop_resize > crop_size:
+            #     crop_x = max(crop_x - max(aspect_ratio, 1) * (crop_resize - crop_size) / 2, 0)
+            # else:
+            crop_x = max(crop_x - (min_width - crop_size) / 2, 0)
+
+            # if aspect_ratio < orig_aspect_ratio and crop_resize / aspect_ratio > image.height:
+            #     crop_x = max(crop_x + (crop_size - image.height * aspect_ratio) / 2, 0)
+            # elif False and aspect_ratio > orig_aspect_ratio and crop_resize * aspect_ratio < image.width:
+            #     crop_x = max(crop_x - crop_resize * (aspect_ratio - 1) / 2, 0)
+            # elif crop_resize > crop_size:
+            #     crop_x = max(crop_x - offset_x / 2, 0)
 
         # extend the vertical crop size to prevent blurry images
-        if gravity in ('n', 'ne', 'nw'):
-            if crop_resize >= crop_size:
-                crop_y = max(crop_y + crop_size - height, 0)
-            elif aspect_ratio < 1:
-                crop_y = max(crop_y + crop_size * (1 - 1 / aspect_ratio), 0)
-        elif gravity in ('s', 'se', 'sw'):
-            if crop_resize >= crop_size:
-                crop_y # += (height - crop_resize) / 2
-            elif aspect_ratio < 1:
-                if aspect_ratio < orig_aspect_ratio:
-                    crop_y = max(crop_y + crop_resize * (1 - 1 / aspect_ratio), 0)
-                else:
-                    crop_y
-            else:
-                crop_y = max(crop_y + (crop_size - image.width / aspect_ratio), 0)
+        if gravity in ('s', 'se', 'sw'):
+            # if aspect_ratio > 1:
+            #     if aspect_ratio > orig_aspect_ratio:
+            #         crop_y = max(crop_y + crop_size - image.width / aspect_ratio, 0)
+            # else:
+            #     crop_y = max(crop_y + min_height - crop_resize, 0)
+
+            # if crop_resize > crop_size:
+            #     crop_y = max(crop_y + crop_size - height, 0)
+            # elif aspect_ratio < 1:
+            #     crop_y = max(crop_y + crop_resize - min_height, 0)
+            crop_y = max(crop_y + max(crop_resize - min_height, 0), 0)
+        elif gravity in ('n', 'ne', 'nw'):
+            # if crop_resize >= crop_size:
+            #     crop_y # += (height - crop_resize) / 2
+            # elif aspect_ratio < 1:
+            #     if aspect_ratio < orig_aspect_ratio:
+            #         crop_y = max(crop_y + crop_resize * (1 - 1 / aspect_ratio), 0)
+            #     else:
+            #         crop_y
+            # else:
+            #     crop_y = max(crop_y + (crop_size - image.width / aspect_ratio), 0)
+            crop_y = max(crop_y - max(min(min_height - crop_size, min_height), 0), 0)
         else:  # centered crop
+            # if crop_resize > crop_size:
+            #     crop_y = max(crop_y - (crop_resize - crop_size) / min(aspect_ratio, 1) / 2, 0)
+            # else:
+            crop_y = max(crop_y - (min_height - crop_size) / 2, 0)
+
             # if aspect_ratio < orig_aspect_ratio and crop_resize / aspect_ratio > image.height:
             #     crop_x = max(crop_x + (crop_size - image.height * aspect_ratio) / 2, 0)
             # elif aspect_ratio > orig_aspect_ratio and crop_resize * aspect_ratio < image.width:
             #     crop_x = max(crop_x - crop_resize * (aspect_ratio - 1) / 2, 0)
-            if aspect_ratio > orig_aspect_ratio and crop_resize * aspect_ratio > image.width:
-                crop_y = max(crop_y + crop_resize * (1 - 1 / aspect_ratio) / 2, 0)
-            elif False and aspect_ratio < orig_aspect_ratio and crop_resize / aspect_ratio < image.height:
-                crop_y = max(crop_y + (crop_size - image.width / aspect_ratio) / 2, 0)
-            elif crop_resize > crop_size:
-                crop_y = max(crop_y - offset_y / 2, 0)
-
-
+            # if aspect_ratio > orig_aspect_ratio and crop_resize * aspect_ratio > image.width:
+            #     crop_y = max(crop_y + crop_resize * (1 - 1 / aspect_ratio) / 2, 0)
+            # elif False and aspect_ratio < orig_aspect_ratio and crop_resize / aspect_ratio < image.height:
+            #     crop_y = max(crop_y + (crop_size - image.width / aspect_ratio) / 2, 0)
+            # elif crop_resize > crop_size:
+            #     crop_y = max(crop_y - offset_y / 2, 0)
         crop_size = crop_resize
 
         print(f"Crop parameters: crop_x={crop_x}, crop_y={crop_y}, crop_size={crop_size}, gravity={gravity}")
 
-        if aspect_ratio > 1:
-            if aspect_ratio > orig_aspect_ratio:
-                min_width = max(min(crop_size * aspect_ratio, image.width), width)
-                min_height = max(min_width / aspect_ratio, height)
-            else:
-                min_width = max(min(crop_size, image.height * aspect_ratio), width)
-                min_height = max(min_width / aspect_ratio, height)
-        else:
-            if aspect_ratio < orig_aspect_ratio:
-                min_height = max(min(crop_size / aspect_ratio, image.height), height)
-                min_width = max(min_height * aspect_ratio, width)
-                # min_height = max(image.height, height)
-                # min_width = max(min_height * aspect_ratio, height)
-                # min_height = max(min(crop_size, image.width / aspect_ratio), height)
-                # min_width = max(min_height * aspect_ratio, width)
-            else:
-                min_width = max(min(crop_size, image.height * aspect_ratio), width)
-                min_height = max(min_width / aspect_ratio, height)
         if False:
             min_x = max(crop_x + (crop_size - min_width) / 2, 0)
         else:
@@ -281,6 +295,7 @@ def crop(self, thumbnail_path, width, height):
         image.thumbnail((width, height))
         (default_storage.base_location / thumbnail_path.parent).mkdir(parents=True, exist_ok=True)
         image.save(default_storage.open(thumbnail_path, 'wb'), image.format)
+        return image
 
     def crop_centered(self, image):
         width, height = image.size