Update app.py

app.py

@@ -73,7 +73,22 @@ def find_optimal_crop(image, mask, target_aspect_ratio):
     image_np = np.array(image)
     h, w = mask.shape
     
-    # Calculate target dimensions
+    # Find the bounding box of the important content
+    # First, find where the mask is non-zero (important content)
+    y_indices, x_indices = np.where(mask > 0)
+    
+    if len(y_indices) == 0 or len(x_indices) == 0:
+        # Fallback if no mask is found
+        content_box = (0, 0, w, h)
+    else:
+        # Get the bounding box of important content
+        min_x, max_x = np.min(x_indices), np.max(x_indices)
+        min_y, max_y = np.min(y_indices), np.max(y_indices)
+        content_width = max_x - min_x + 1
+        content_height = max_y - min_y + 1
+        content_box = (min_x, min_y, content_width, content_height)
+    
+    # Calculate target dimensions based on the original image
     if target_aspect_ratio > w / h:
         # Target is wider than original
         target_h = int(w / target_aspect_ratio)
@@ -83,24 +98,39 @@ def find_optimal_crop(image, mask, target_aspect_ratio):
         target_h = h
         target_w = int(h * target_aspect_ratio)
     
-    # Find the best crop position
-    best_score = -1
-    best_box = (0, 0, target_w, target_h)
+    # Calculate the center of the important content
+    content_center_x = content_box[0] + content_box[2] // 2
+    content_center_y = content_box[1] + content_box[3] // 2
     
-    # Step size for searching (can be adjusted for performance)
-    step = max(1, min(h, w) // 50)
+    # Try to center the crop on the important content
+    x = max(0, min(content_center_x - target_w // 2, w - target_w))
+    y = max(0, min(content_center_y - target_h // 2, h - target_h))
     
-    for y in range(0, h - target_h + 1, step):
-        for x in range(0, w - target_w + 1, step):
-            # Calculate how much of the mask is preserved in this crop
-            crop_mask = mask[y:y+target_h, x:x+target_w]
-            score = np.sum(crop_mask) / 255.0
-            
-            if score > best_score:
-                best_score = score
-                best_box = (x, y, x + target_w, y + target_h)
+    # Check if the important content fits within this crop
+    min_x, min_y, content_width, content_height = content_box
+    max_x = min_x + content_width
+    max_y = min_y + content_height
+    
+    # If the content doesn't fit in the crop, adjust the crop
+    if target_w >= content_width and target_h >= content_height:
+        # If the crop is large enough to include all content, center it
+        x = max(0, min(content_center_x - target_w // 2, w - target_w))
+        y = max(0, min(content_center_y - target_h // 2, h - target_h))
+    else:
+        # If crop isn't large enough for all content, maximize visible content
+        # and prioritize centering the crop on the content
+        x = max(0, min(min_x, w - target_w))
+        y = max(0, min(min_y, h - target_h))
+        
+        # If we still can't fit width, center the crop horizontally
+        if content_width > target_w:
+            x = max(0, min(content_center_x - target_w // 2, w - target_w))
+        
+        # If we still can't fit height, center the crop vertically
+        if content_height > target_h:
+            y = max(0, min(content_center_y - target_h // 2, h - target_h))
     
-    return best_box
+    return (x, y, x + target_w, y + target_h)
 
 def smart_crop(input_image, target_aspect_ratio, point_x=None, point_y=None):
     """