add: 9:16 layouts

crop_utils.py

@@ -79,7 +79,7 @@ def add_top_numbers(
     input_image,
     num_divisions=20,
     margin=90,
-    font_size=120,
+    font_size=70,
     dot_spacing=20,
 ):
     """
@@ -384,8 +384,8 @@ def find_persons_center(image):
 
 def create_layouts(image, left_division, right_division):
     """
-    Create different layout variations of the image using half, one-third, and two-thirds width.
-    All layout variations will be centered on detected persons, including 16:9 and 9:16 crops.
+    Create different layout variations of the image using specific aspect ratios.
+    All layout variations will be centered on detected persons.
 
     Args:
         image: PIL Image
@@ -393,7 +393,7 @@ def create_layouts(image, left_division, right_division):
         right_division: Right division index (1-20)
 
     Returns:
-        tuple: (list of layout variations, cutout_image, cutout_16_9, cutout_9_16)
+        tuple: (standard_crops, threehalfs_layouts, twothirdhalfs_layouts, twoequalhalfs_layouts, visualization_data)
     """
     # Convert PIL Image to cv2 format
     if isinstance(image, Image.Image):
@@ -476,8 +476,12 @@ def create_layouts(image, left_division, right_division):
         x_end = min(cutout_width, x_start + new_width)
         cutout_16_9 = cutout_image[:, x_start:x_end].copy()
 
-    # For 9:16 version (centered on person)
+    # For 9:16 version (centered on person, adjusted upward for face visibility)
     target_width_9_16 = int(cutout_height * aspect_9_16)
+
+    # Adjust center point upward by 20% of person height to ensure face is visible
+    adjusted_center_y = int(cutout_center_y - (person_height * 0.2))
+
     if target_width_9_16 <= cutout_width:
         # Center horizontally around person
         x_start = int(
@@ -490,56 +494,463 @@ def create_layouts(image, left_division, right_division):
             )
         )
         x_end = int(min(cutout_width, x_start + target_width_9_16))
-        cutout_9_16 = cutout_image[:, x_start:x_end].copy()
+
+        # Use adjusted center point for vertical positioning
+        y_start = int(
+            max(
+                0,
+                min(
+                    cutout_height - cutout_height,
+                    adjusted_center_y - cutout_height // 2,
+                ),
+            )
+        )
+        cutout_9_16 = cutout_image[y_start:, x_start:x_end].copy()
     else:
         # Handle rare case where we need to adjust height
         new_height = int(cutout_width / aspect_9_16)
+
+        # Use adjusted center point for vertical positioning
         y_start = int(
-            max(0, min(cutout_height - new_height, cutout_center_y - new_height // 2))
+            max(0, min(cutout_height - new_height, adjusted_center_y - new_height // 2))
         )
         y_end = int(min(cutout_height, y_start + new_height))
         cutout_9_16 = cutout_image[y_start:y_end, :].copy()
 
     # 4. Scale the center back to original image coordinates
     original_center_x = left_boundary + cutout_center_x
+    original_center_y = cutout_center_y
+    original_person_top = person_top
+
+    # Store visualization data for drawing
+    visualization_data = {
+        "original_center_x": original_center_x,
+        "original_center_y": original_center_y,
+        "original_person_top": original_person_top,
+        "original_person_height": person_height,
+        "cutout_bounds": (left_boundary, right_boundary),
+    }
+
+    # 5. Create new layout variations - each segment is independently centered on the subject
+
+    # ----- Create crops for threehalfs layout -----
+    # For 16:9 (three 5.3:9 segments, each independently centered)
+    aspect_5_3_9 = 5.3 / 9
+
+    # Calculate dimensions for each segment
+    segment_height_16_9 = cutout_height  # Use full height
+    segment_width_16_9 = int(segment_height_16_9 * aspect_5_3_9)
+
+    # Create three segments for 16:9 threehalfs - all centered on the person
+    threehalfs_16_9_segments = []
+    for i in range(3):
+        # Each segment is centered on the person
+        segment_x_start = int(
+            max(
+                0,
+                min(
+                    cutout_width - segment_width_16_9,
+                    cutout_center_x - segment_width_16_9 // 2,
+                ),
+            )
+        )
+        segment_x_end = int(min(cutout_width, segment_x_start + segment_width_16_9))
+
+        # Create the segment
+        segment = cutout_image[:, segment_x_start:segment_x_end].copy()
+
+        # Add a label for visualization
+        label = f"Part {i+1}"
+        cv2.putText(
+            segment,
+            label,
+            (10, 30),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.8,
+            (255, 255, 255),
+            2,
+            cv2.LINE_AA,
+        )
+
+        threehalfs_16_9_segments.append(segment)
+
+    # For 9:16 (three 9:5.3 segments, each independently centered)
+    aspect_9_5_3 = 9 / 5.3
+
+    # Calculate dimensions for each segment
+    segment_width_9_16 = cutout_9_16.shape[1]  # Use full width of 9:16 crop
+    segment_height_9_16 = int(segment_width_9_16 / aspect_9_5_3)
+
+    # Get adjusted center for 9:16 segments (move up by 20% of person height)
+    cutout_9_16_center_y = cutout_9_16.shape[0] // 2
+    adjusted_9_16_center_y = int(cutout_9_16_center_y - (person_height * 0.2))
+    cutout_9_16_height = cutout_9_16.shape[0]
+
+    # Create three segments for 9:16 threehalfs - all centered on the person
+    threehalfs_9_16_segments = []
+
+    for i in range(3):
+        # Each segment is centered on the person with adjusted center point
+        segment_y_start = int(
+            max(
+                0,
+                min(
+                    cutout_9_16_height - segment_height_9_16,
+                    adjusted_9_16_center_y - segment_height_9_16 // 2,
+                ),
+            )
+        )
+        segment_y_end = int(
+            min(cutout_9_16_height, segment_y_start + segment_height_9_16)
+        )
 
-    # 5. Create layout variations on the original image centered on persons
-    # Half width layout
-    half_width = width // 2
-    half_left_x = max(0, min(width - half_width, original_center_x - half_width // 2))
-    half_right_x = half_left_x + half_width
-    half_width_crop = image_cv[:, half_left_x:half_right_x].copy()
+        # Create the segment
+        segment = cutout_9_16[segment_y_start:segment_y_end, :].copy()
 
-    # Third width layout
-    third_width = width // 3
-    third_left_x = max(
-        0, min(width - third_width, original_center_x - third_width // 2)
+        # Add a label for visualization
+        label = f"Part {i+1}"
+        cv2.putText(
+            segment,
+            label,
+            (10, 30),
+            cv2.FONT_HERSHEY_SIMPLEX,
+            0.8,
+            (255, 255, 255),
+            2,
+            cv2.LINE_AA,
+        )
+
+        threehalfs_9_16_segments.append(segment)
+
+    # ----- Create crops for twothirdhalfs layout -----
+    # For 16:9 (two segments: 10.6:9 and 5.3:9 OR 5.3:9 and 10.6:9)
+    aspect_10_6_9 = 10.6 / 9
+
+    # Calculate dimensions for segments
+    segment1_height_16_9 = cutout_height  # Use full height
+    segment1_width_16_9 = int(segment1_height_16_9 * aspect_10_6_9)
+    segment2_height_16_9 = cutout_height  # Use full height
+    segment2_width_16_9 = int(segment2_height_16_9 * aspect_5_3_9)
+
+    # Create segments for 16:9 twothirdhalfs var1 (10.6:9 then 5.3:9)
+    # Both segments independently centered on the person
+
+    # First segment (10.6:9)
+    segment_x_start = int(
+        max(
+            0,
+            min(
+                cutout_width - segment1_width_16_9,
+                cutout_center_x - segment1_width_16_9 // 2,
+            ),
+        )
     )
-    third_right_x = third_left_x + third_width
-    third_width_crop = image_cv[:, third_left_x:third_right_x].copy()
+    segment_x_end = int(min(cutout_width, segment_x_start + segment1_width_16_9))
+    segment1 = cutout_image[:, segment_x_start:segment_x_end].copy()
 
-    # Two-thirds width layout
-    two_thirds_width = (width * 2) // 3
-    two_thirds_left_x = max(
-        0, min(width - two_thirds_width, original_center_x - two_thirds_width // 2)
+    # Add label
+    cv2.putText(
+        segment1,
+        "10.6:9",
+        (10, 30),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.8,
+        (255, 255, 255),
+        2,
+        cv2.LINE_AA,
     )
-    two_thirds_right_x = two_thirds_left_x + two_thirds_width
-    two_thirds_crop = image_cv[:, two_thirds_left_x:two_thirds_right_x].copy()
 
-    # Add labels to all crops
-    font = cv2.FONT_HERSHEY_SIMPLEX
-    label_settings = {
-        "fontScale": 1.0,
-        "fontFace": 1,
-        "thickness": 2,
-    }
+    # Second segment (5.3:9)
+    segment_x_start = int(
+        max(
+            0,
+            min(
+                cutout_width - segment2_width_16_9,
+                cutout_center_x - segment2_width_16_9 // 2,
+            ),
+        )
+    )
+    segment_x_end = int(min(cutout_width, segment_x_start + segment2_width_16_9))
+    segment2 = cutout_image[:, segment_x_start:segment_x_end].copy()
+
+    # Add label
+    cv2.putText(
+        segment2,
+        "5.3:9",
+        (10, 30),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.8,
+        (255, 255, 255),
+        2,
+        cv2.LINE_AA,
+    )
+
+    twothirdhalfs_16_9_var1_segments = [segment1, segment2]
+
+    # Create segments for 16:9 twothirdhalfs var2 (5.3:9 then 10.6:9)
+    # First segment (5.3:9) - reuse segment2 from var1
+    # Second segment (10.6:9) - reuse segment1 from var1
+    twothirdhalfs_16_9_var2_segments = [segment2.copy(), segment1.copy()]
+
+    # For 9:16 (two segments stacked: 9:10.6 and 9:5.3 OR 9:5.3 and 9:10.6)
+    aspect_9_10_6 = 9 / 10.6
+    aspect_9_5_3 = 9 / 5.3
+
+    # Calculate dimensions for segments
+    segment1_width_9_16 = cutout_9_16.shape[1]  # Use full width of 9:16 crop
+    segment1_height_9_16 = int(segment1_width_9_16 / aspect_9_10_6)
+    segment2_width_9_16 = cutout_9_16.shape[1]  # Use full width of 9:16 crop
+    segment2_height_9_16 = int(segment2_width_9_16 / aspect_9_5_3)
+
+    # Create segments for 9:16 twothirdhalfs var1 (9:10.6 then 9:5.3)
+    # Both segments independently centered on the person with adjusted center point
+
+    # First segment (9:10.6)
+    segment_y_start = int(
+        max(
+            0,
+            min(
+                cutout_9_16_height - segment1_height_9_16,
+                adjusted_9_16_center_y - segment1_height_9_16 // 2,
+            ),
+        )
+    )
+    segment_y_end = int(min(cutout_9_16_height, segment_y_start + segment1_height_9_16))
+    segment1 = cutout_9_16[segment_y_start:segment_y_end, :].copy()
 
-    # Draw label backgrounds for better visibility
+    # Add label
+    cv2.putText(
+        segment1,
+        "9:10.6",
+        (10, 30),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.8,
+        (255, 255, 255),
+        2,
+        cv2.LINE_AA,
+    )
+
+    # Second segment (9:5.3)
+    segment_y_start = int(
+        max(
+            0,
+            min(
+                cutout_9_16_height - segment2_height_9_16,
+                adjusted_9_16_center_y - segment2_height_9_16 // 2,
+            ),
+        )
+    )
+    segment_y_end = int(min(cutout_9_16_height, segment_y_start + segment2_height_9_16))
+    segment2 = cutout_9_16[segment_y_start:segment_y_end, :].copy()
+
+    # Add label
+    cv2.putText(
+        segment2,
+        "9:5.3",
+        (10, 30),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.8,
+        (255, 255, 255),
+        2,
+        cv2.LINE_AA,
+    )
+
+    twothirdhalfs_9_16_var1_segments = [segment1, segment2]
+
+    # Create segments for 9:16 twothirdhalfs var2 (9:5.3 then 9:10.6)
+    # First segment (9:5.3) - reuse segment2 from var1
+    # Second segment (9:10.6) - reuse segment1 from var1
+    twothirdhalfs_9_16_var2_segments = [segment2.copy(), segment1.copy()]
+
+    # ----- Create crops for twoequalhalfs layout -----
+    # For 16:9 (two 8:9 segments side by side)
+    aspect_8_9 = 8 / 9
+
+    # Calculate dimensions for segments
+    segment_height_16_9_equal = cutout_height  # Use full height
+    segment_width_16_9_equal = int(segment_height_16_9_equal * aspect_8_9)
+
+    # Create segments for 16:9 twoequalhalfs - both centered on the person
+    # First segment (8:9)
+    segment_x_start = int(
+        max(
+            0,
+            min(
+                cutout_width - segment_width_16_9_equal,
+                cutout_center_x - segment_width_16_9_equal // 2,
+            ),
+        )
+    )
+    segment_x_end = int(min(cutout_width, segment_x_start + segment_width_16_9_equal))
+    segment1 = cutout_image[:, segment_x_start:segment_x_end].copy()
+
+    # Add label
+    cv2.putText(
+        segment1,
+        "8:9 (1)",
+        (10, 30),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.8,
+        (255, 255, 255),
+        2,
+        cv2.LINE_AA,
+    )
+
+    # Second segment (identical to first for equal halfs)
+    segment2 = segment1.copy()
+
+    # Update label for segment 2
+    cv2.putText(
+        segment2,
+        "8:9 (2)",
+        (10, 30),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.8,
+        (255, 255, 255),
+        2,
+        cv2.LINE_AA,
+    )
+
+    twoequalhalfs_16_9_segments = [segment1, segment2]
+
+    # For 9:16 (two 9:8 segments stacked)
+    aspect_9_8 = 9 / 8
+
+    # Calculate dimensions for segments
+    segment_width_9_16_equal = cutout_9_16.shape[1]  # Use full width of 9:16 crop
+    segment_height_9_16_equal = int(segment_width_9_16_equal / aspect_9_8)
+
+    # Create segments for 9:16 twoequalhalfs - both centered on the person with adjusted center point
+    # First segment (9:8)
+    segment_y_start = int(
+        max(
+            0,
+            min(
+                cutout_9_16_height - segment_height_9_16_equal,
+                adjusted_9_16_center_y - segment_height_9_16_equal // 2,
+            ),
+        )
+    )
+    segment_y_end = int(
+        min(cutout_9_16_height, segment_y_start + segment_height_9_16_equal)
+    )
+    segment1 = cutout_9_16[segment_y_start:segment_y_end, :].copy()
+
+    # Add label
+    cv2.putText(
+        segment1,
+        "9:8 (1)",
+        (10, 30),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.8,
+        (255, 255, 255),
+        2,
+        cv2.LINE_AA,
+    )
+
+    # Second segment (identical to first for equal halfs)
+    segment2 = segment1.copy()
+
+    # Update label for segment 2
+    cv2.putText(
+        segment2,
+        "9:8 (2)",
+        (10, 30),
+        cv2.FONT_HERSHEY_SIMPLEX,
+        0.8,
+        (255, 255, 255),
+        2,
+        cv2.LINE_AA,
+    )
+
+    twoequalhalfs_9_16_segments = [segment1, segment2]
+
+    # 6. Create composite layouts by joining segments
+    # Function to create a composite image
+    def create_composite(segments, horizontal=True):
+        if not segments:
+            return None
+
+        if horizontal:
+            # Calculate the total width and max height
+            total_width = sum(segment.shape[1] for segment in segments)
+            max_height = max(segment.shape[0] for segment in segments)
+
+            # Create a canvas
+            composite = np.zeros((max_height, total_width, 3), dtype=np.uint8)
+
+            # Place segments side by side
+            x_offset = 0
+            for segment in segments:
+                h, w = segment.shape[:2]
+                composite[:h, x_offset : x_offset + w] = segment
+                x_offset += w
+
+        else:  # vertical stacking
+            # Calculate the max width and total height
+            max_width = max(segment.shape[1] for segment in segments)
+            total_height = sum(segment.shape[0] for segment in segments)
+
+            # Create a canvas
+            composite = np.zeros((total_height, max_width, 3), dtype=np.uint8)
+
+            # Place segments top to bottom
+            y_offset = 0
+            for segment in segments:
+                h, w = segment.shape[:2]
+                composite[y_offset : y_offset + h, :w] = segment
+                y_offset += h
+
+        return composite
+
+    # Create composite layouts
+    threehalfs_16_9_composite = create_composite(
+        threehalfs_16_9_segments, horizontal=True
+    )
+    threehalfs_9_16_composite = create_composite(
+        threehalfs_9_16_segments, horizontal=False
+    )
+
+    twothirdhalfs_16_9_var1_composite = create_composite(
+        twothirdhalfs_16_9_var1_segments, horizontal=True
+    )
+    twothirdhalfs_16_9_var2_composite = create_composite(
+        twothirdhalfs_16_9_var2_segments, horizontal=True
+    )
+    twothirdhalfs_9_16_var1_composite = create_composite(
+        twothirdhalfs_9_16_var1_segments, horizontal=False
+    )
+    twothirdhalfs_9_16_var2_composite = create_composite(
+        twothirdhalfs_9_16_var2_segments, horizontal=False
+    )
+
+    twoequalhalfs_16_9_composite = create_composite(
+        twoequalhalfs_16_9_segments, horizontal=True
+    )
+    twoequalhalfs_9_16_composite = create_composite(
+        twoequalhalfs_9_16_segments, horizontal=False
+    )
+
+    # Add labels to all composites
     def add_label(img, label):
+        if img is None:
+            return None
+
+        font = cv2.FONT_HERSHEY_SIMPLEX
+        label_settings = {
+            "fontScale": 1.0,
+            "fontFace": font,
+            "thickness": 2,
+        }
+
         # Draw background for text
         text_size = cv2.getTextSize(
-            label, **{k: v for k, v in label_settings.items() if k != "color"}
+            label,
+            fontFace=label_settings["fontFace"],
+            fontScale=label_settings["fontScale"],
+            thickness=label_settings["thickness"],
         )
+
         cv2.rectangle(
             img,
             (10, 10),
@@ -547,55 +958,108 @@ def create_layouts(image, left_division, right_division):
             (0, 0, 0),
             -1,
         )  # Black background
+
         # Draw text
         cv2.putText(
             img,
             label,
             (15, 15 + text_size[0][1]),
-            **label_settings,
+            fontFace=label_settings["fontFace"],
+            fontScale=label_settings["fontScale"],
+            thickness=label_settings["thickness"],
             color=(255, 255, 255),
             lineType=cv2.LINE_AA,
         )
         return img
 
-    cutout_image = add_label(cutout_image, "Cutout")
-    cutout_16_9 = add_label(cutout_16_9, "16:9")
-    cutout_9_16 = add_label(cutout_9_16, "9:16")
-    half_width_crop = add_label(half_width_crop, "Half Width")
-    third_width_crop = add_label(third_width_crop, "Third Width")
-    two_thirds_crop = add_label(two_thirds_crop, "Two-Thirds Width")
+    # Label the basic crops
+    cutout_image_labeled = add_label(cutout_image.copy(), "Cutout")
+    cutout_16_9_labeled = add_label(cutout_16_9.copy(), "16:9")
+    cutout_9_16_labeled = add_label(cutout_9_16.copy(), "9:16")
+
+    # Label the composite layouts
+    threehalfs_16_9_labeled = add_label(threehalfs_16_9_composite, "Three Halfs 16:9")
+    threehalfs_9_16_labeled = add_label(threehalfs_9_16_composite, "Three Halfs 9:16")
+
+    twothirdhalfs_16_9_var1_labeled = add_label(
+        twothirdhalfs_16_9_var1_composite, "Two Thirds Var1 16:9"
+    )
+    twothirdhalfs_16_9_var2_labeled = add_label(
+        twothirdhalfs_16_9_var2_composite, "Two Thirds Var2 16:9"
+    )
+    twothirdhalfs_9_16_var1_labeled = add_label(
+        twothirdhalfs_9_16_var1_composite, "Two Thirds Var1 9:16"
+    )
+    twothirdhalfs_9_16_var2_labeled = add_label(
+        twothirdhalfs_9_16_var2_composite, "Two Thirds Var2 9:16"
+    )
+
+    twoequalhalfs_16_9_labeled = add_label(
+        twoequalhalfs_16_9_composite, "Two Equal Halfs 16:9"
+    )
+    twoequalhalfs_9_16_labeled = add_label(
+        twoequalhalfs_9_16_composite, "Two Equal Halfs 9:16"
+    )
 
     # Convert all output images to PIL format
-    layout_crops = []
-    for layout, label in [
-        (half_width_crop, "Half Width"),
-        (third_width_crop, "Third Width"),
-        (two_thirds_crop, "Two-Thirds Width"),
-    ]:
-        pil_layout = Image.fromarray(cv2.cvtColor(layout, cv2.COLOR_BGR2RGB))
-        layout_crops.append(pil_layout)
+    def cv2_to_pil(img):
+        if img is None:
+            return None
+        return Image.fromarray(cv2.cvtColor(img, cv2.COLOR_BGR2RGB))
+
+    # Convert standard crops
+    standard_crops = {
+        "cutout": cv2_to_pil(cutout_image_labeled),
+        "16:9": cv2_to_pil(cutout_16_9_labeled),
+        "9:16": cv2_to_pil(cutout_9_16_labeled),
+    }
+
+    # Convert threehalfs layouts
+    threehalfs_layouts = {
+        "16:9": cv2_to_pil(threehalfs_16_9_labeled),
+        "9:16": cv2_to_pil(threehalfs_9_16_labeled),
+    }
+
+    # Convert twothirdhalfs layouts
+    twothirdhalfs_layouts = {
+        "16:9_var1": cv2_to_pil(twothirdhalfs_16_9_var1_labeled),
+        "16:9_var2": cv2_to_pil(twothirdhalfs_16_9_var2_labeled),
+        "9:16_var1": cv2_to_pil(twothirdhalfs_9_16_var1_labeled),
+        "9:16_var2": cv2_to_pil(twothirdhalfs_9_16_var2_labeled),
+    }
 
-    cutout_pil = Image.fromarray(cv2.cvtColor(cutout_image, cv2.COLOR_BGR2RGB))
-    cutout_16_9_pil = Image.fromarray(cv2.cvtColor(cutout_16_9, cv2.COLOR_BGR2RGB))
-    cutout_9_16_pil = Image.fromarray(cv2.cvtColor(cutout_9_16, cv2.COLOR_BGR2RGB))
+    # Convert twoequalhalfs layouts
+    twoequalhalfs_layouts = {
+        "16:9": cv2_to_pil(twoequalhalfs_16_9_labeled),
+        "9:16": cv2_to_pil(twoequalhalfs_9_16_labeled),
+    }
 
-    return layout_crops, cutout_pil, cutout_16_9_pil, cutout_9_16_pil
+    return (
+        standard_crops,
+        threehalfs_layouts,
+        twothirdhalfs_layouts,
+        twoequalhalfs_layouts,
+        visualization_data,
+    )
 
 
-def draw_crops_on_original(image, left_division, right_division, crop_types):
+def draw_layout_regions(
+    image, left_division, right_division, visualization_data, layout_type
+):
     """
-    Create a visualization showing selected crop regions overlaid on the original image.
-    Each crop region is outlined with a different color and labeled.
-    All crops are centered on the person's center point.
+    Create a visualization showing the layout regions overlaid on the original image.
+    Each region is independently centered on the subject, as in practice different videos
+    would be stacked in these layouts.
 
     Args:
         image: PIL Image
         left_division: Left division index (1-20)
         right_division: Right division index (1-20)
-        crop_types: List of crop types to include in visualization (e.g., ["16:9", "9:16"])
+        visualization_data: Dictionary with visualization data from create_layouts
+        layout_type: Type of layout to visualize (e.g., "standard", "threehalfs", "twothirdhalfs_var1", etc.)
 
     Returns:
-        PIL Image: Original image with selected crop regions visualized
+        PIL Image: Original image with layout regions visualized
     """
     # Convert PIL Image to cv2 format
     if isinstance(image, Image.Image):
@@ -609,62 +1073,30 @@ def draw_crops_on_original(image, left_division, right_division, crop_types):
     # Get image dimensions
     height, width = image_cv.shape[:2]
 
-    # Calculate division width and crop boundaries
-    division_width = width / 20  # Assuming 20 divisions
-    left_boundary = int((left_division - 1) * division_width)
-    right_boundary = int(right_division * division_width)
-
-    # Find person bounding box and center in cutout
-    cutout_image = image_cv[:, left_boundary:right_boundary].copy()
-
-    # Get YOLO detections for person bounding box
-    results = model(cutout_image, classes=[0], conf=0.6)
-
-    # Default values
-    cutout_center_x = cutout_image.shape[1] // 2
-    cutout_center_y = cutout_image.shape[0] // 2
-    person_top = 0.0
-    person_height = float(cutout_image.shape[0])
-
-    if results and len(results[0].boxes) > 0:
-        # Get person detection
-        boxes = results[0].boxes.xyxy.cpu().numpy()
-
-        if len(boxes) == 1:
-            # Single person
-            x1, y1, x2, y2 = boxes[0]
-            cutout_center_x = int((x1 + x2) // 2)
-            cutout_center_y = int((y1 + y2) // 2)
-            person_top = y1
-            person_height = y2 - y1
-        else:
-            # Multiple persons - merge bounding boxes
-            left_x = min(box[0] for box in boxes)
-            right_x = max(box[2] for box in boxes)
-            top_y = min(box[1] for box in boxes)  # Top of highest person
-            bottom_y = max(box[3] for box in boxes)  # Bottom of lowest person
-
-            cutout_center_x = int((left_x + right_x) // 2)
-            cutout_center_y = int((top_y + bottom_y) // 2)
-            person_top = top_y
-            person_height = bottom_y - top_y
-
-    # Scale back to original image
-    original_center_x = left_boundary + cutout_center_x
-    original_center_y = cutout_center_y
-    original_person_top = (
-        person_top  # Already in original image space since we didn't crop vertically
-    )
-    original_person_height = person_height  # Same in original space
+    # Extract visualization data
+    original_center_x = visualization_data["original_center_x"]
+    original_center_y = visualization_data["original_center_y"]
+    original_person_top = visualization_data["original_person_top"]
+    original_person_height = visualization_data["original_person_height"]
+    left_boundary, right_boundary = visualization_data["cutout_bounds"]
+    cutout_width = right_boundary - left_boundary
 
-    # Define colors for different crops (BGR format)
+    # Define colors for different layouts (BGR format)
     colors = {
-        "cutout": (0, 165, 255),  # Orange
-        "16:9": (0, 255, 0),  # Green
-        "9:16": (255, 0, 0),  # Blue
-        "half": (255, 255, 0),  # Cyan
-        "third": (255, 0, 255),  # Magenta
-        "two_thirds": (0, 255, 255),  # Yellow
+        "standard": {"16:9": (0, 255, 0), "9:16": (255, 0, 0)},  # Green, Blue
+        "threehalfs": {"16:9": (0, 165, 255), "9:16": (255, 255, 0)},  # Orange, Cyan
+        "twothirdhalfs_var1": {
+            "16:9": (255, 0, 255),
+            "9:16": (128, 0, 128),
+        },  # Magenta, Purple
+        "twothirdhalfs_var2": {
+            "16:9": (0, 255, 255),
+            "9:16": (128, 128, 0),
+        },  # Yellow, Teal
+        "twoequalhalfs": {
+            "16:9": (0, 128, 128),
+            "9:16": (255, 165, 0),
+        },  # Dark Cyan, Blue-Green
     }
 
     # Define line thickness and font
@@ -673,161 +1105,454 @@ def draw_crops_on_original(image, left_division, right_division, crop_types):
     font_scale = 0.8
     font_thickness = 2
 
-    # Draw cutout region (original divisions) if requested
-    if "cutout" in crop_types:
+    # Draw standard layouts (16:9 and 9:16)
+    if layout_type == "standard":
+        # Draw 16:9 crop
+        aspect_16_9 = 16 / 9
+        target_height_16_9 = int(cutout_width / aspect_16_9)
+
+        # Calculate 20% of person height for top margin
+        top_margin = int(original_person_height * 0.2)
+        y_start = int(max(0, original_person_top - top_margin))
+        if y_start + target_height_16_9 > height:
+            y_start = int(max(0, height - target_height_16_9))
+        y_end = int(min(height, y_start + target_height_16_9))
+
         cv2.rectangle(
             visualization,
-            (left_boundary, 0),
-            (right_boundary, height),
-            colors["cutout"],
+            (left_boundary, y_start),
+            (right_boundary, y_end),
+            colors["standard"]["16:9"],
             thickness,
         )
         cv2.putText(
             visualization,
-            "Cutout",
-            (left_boundary + 5, 30),
+            "16:9",
+            (left_boundary + 5, y_start + 30),
             font,
             font_scale,
-            colors["cutout"],
+            colors["standard"]["16:9"],
             font_thickness,
         )
 
-    # Create 16:9 version of the cutout if requested
-    if "16:9" in crop_types:
-        cutout_width = right_boundary - left_boundary
-        cutout_height = height
-        aspect_16_9 = 16 / 9
-        target_height_16_9 = int(cutout_width / aspect_16_9)
-
-        if target_height_16_9 <= height:
-            # Calculate 20% of person height for top margin
-            top_margin = int(original_person_height * 0.2)
+        # Draw 9:16 crop
+        aspect_9_16 = 9 / 16
+        target_width_9_16 = int(height * aspect_9_16)
 
-            # Start 20% above the person's top
-            y_start = int(max(0, original_person_top - top_margin))
+        x_start = max(
+            0,
+            min(width - target_width_9_16, original_center_x - target_width_9_16 // 2),
+        )
+        x_end = x_start + target_width_9_16
 
-            # If this would make the crop exceed the bottom, adjust y_start
-            if y_start + target_height_16_9 > height:
-                y_start = int(max(0, height - target_height_16_9))
+        cv2.rectangle(
+            visualization,
+            (x_start, 0),
+            (x_end, height),
+            colors["standard"]["9:16"],
+            thickness,
+        )
+        cv2.putText(
+            visualization,
+            "9:16",
+            (x_start + 5, 30),
+            font,
+            font_scale,
+            colors["standard"]["9:16"],
+            font_thickness,
+        )
 
-            y_end = int(min(height, y_start + target_height_16_9))
+    # Draw threehalfs layouts - each segment is centered on the subject
+    elif layout_type == "threehalfs":
+        # For 16:9 (three 5.3:9 segments side by side - visually only)
+        aspect_5_3_9 = 5.3 / 9
+        segment_height = height
+        segment_width = int(segment_height * aspect_5_3_9)
+
+        # Calculate total width for visualization purposes
+        total_width = segment_width * 3
+        start_x = max(0, original_center_x - total_width // 2)
+
+        for i in range(3):
+            # For visualization, we'll place them side by side
+            vis_segment_x_start = start_x + i * segment_width
+            vis_segment_x_end = vis_segment_x_start + segment_width
+
+            # But each segment would actually be centered on the subject independently
+            # Here we also draw the centered version more faintly
+            actual_segment_x_start = max(
+                0, min(width - segment_width, original_center_x - segment_width // 2)
+            )
+            actual_segment_x_end = min(width, actual_segment_x_start + segment_width)
 
+            # Draw the visualization placement (side by side)
             cv2.rectangle(
                 visualization,
-                (left_boundary, y_start),
-                (right_boundary, y_end),
-                colors["16:9"],
+                (vis_segment_x_start, 0),
+                (vis_segment_x_end, segment_height),
+                colors["threehalfs"]["16:9"],
                 thickness,
             )
+
+            # Draw the actual centered placement with dashed lines
+            if i > 0:  # Only draw centered versions for parts 2 and 3
+                for j in range(0, segment_height, 20):  # Dashed line effect
+                    if j % 40 < 20:  # Skip every other segment
+                        cv2.line(
+                            visualization,
+                            (actual_segment_x_start, j),
+                            (actual_segment_x_start, min(j + 20, segment_height)),
+                            colors["threehalfs"]["16:9"],
+                            1,
+                        )
+                        cv2.line(
+                            visualization,
+                            (actual_segment_x_end, j),
+                            (actual_segment_x_end, min(j + 20, segment_height)),
+                            colors["threehalfs"]["16:9"],
+                            1,
+                        )
+
             cv2.putText(
                 visualization,
-                "16:9",
-                (left_boundary + 5, y_start + 30),
+                f"16:9 Part {i+1}",
+                (vis_segment_x_start + 5, 30 + i * 30),
                 font,
                 font_scale,
-                colors["16:9"],
+                colors["threehalfs"]["16:9"],
                 font_thickness,
             )
 
-    # Create 9:16 version if requested
-    if "9:16" in crop_types:
-        cutout_width = right_boundary - left_boundary
-        cutout_height = height
+        # For 9:16 (three 9:5.3 segments stacked top to bottom - visually only)
         aspect_9_16 = 9 / 16
-        target_width_9_16 = int(cutout_height * aspect_9_16)
+        target_width_9_16 = int(height * aspect_9_16)
+        x_start = max(
+            0,
+            min(width - target_width_9_16, original_center_x - target_width_9_16 // 2),
+        )
+        x_end = x_start + target_width_9_16
+
+        aspect_9_5_3 = 9 / 5.3
+        segment_width_9_16 = target_width_9_16
+        segment_height_9_16 = int(segment_width_9_16 / aspect_9_5_3)
+
+        # Calculate total height for visualization purposes
+        total_height = segment_height_9_16 * 3
+        start_y = max(0, height // 2 - total_height // 2)
+
+        for i in range(3):
+            # For visualization, we'll place them stacked
+            vis_segment_y_start = start_y + i * segment_height_9_16
+            vis_segment_y_end = min(height, vis_segment_y_start + segment_height_9_16)
+
+            # But each segment would actually be centered on the subject independently
+            # Here we also draw the centered version more faintly
+            actual_segment_y_start = max(
+                0,
+                min(
+                    height - segment_height_9_16,
+                    original_center_y - segment_height_9_16 // 2,
+                ),
+            )
+            actual_segment_y_end = min(
+                height, actual_segment_y_start + segment_height_9_16
+            )
+
+            # Draw the visualization placement (stacked)
+            cv2.rectangle(
+                visualization,
+                (x_start, vis_segment_y_start),
+                (x_end, vis_segment_y_end),
+                colors["threehalfs"]["9:16"],
+                thickness,
+            )
+
+            # Draw the actual centered placement with dashed lines
+            if i > 0:  # Only draw centered versions for parts 2 and 3
+                for j in range(x_start, x_end, 20):  # Dashed line effect
+                    if j % 40 < 20:  # Skip every other segment
+                        cv2.line(
+                            visualization,
+                            (j, actual_segment_y_start),
+                            (min(j + 20, x_end), actual_segment_y_start),
+                            colors["threehalfs"]["9:16"],
+                            1,
+                        )
+                        cv2.line(
+                            visualization,
+                            (j, actual_segment_y_end),
+                            (min(j + 20, x_end), actual_segment_y_end),
+                            colors["threehalfs"]["9:16"],
+                            1,
+                        )
+
+            cv2.putText(
+                visualization,
+                f"9:16 Part {i+1}",
+                (x_start + 5, vis_segment_y_start + 30),
+                font,
+                font_scale,
+                colors["threehalfs"]["9:16"],
+                font_thickness,
+            )
+
+    # Draw twothirdhalfs layouts
+    elif layout_type == "twothirdhalfs_var1" or layout_type == "twothirdhalfs_var2":
+        aspect_key = "16:9" if layout_type.endswith("var1") else "9:16"
+        layout_color = colors[
+            (
+                "twothirdhalfs_var1"
+                if layout_type.endswith("var1")
+                else "twothirdhalfs_var2"
+            )
+        ][aspect_key]
+
+        if aspect_key == "16:9":
+            # For 16:9 (two segments side by side)
+            aspect_10_6_9 = 10.6 / 9
+            aspect_5_3_9 = 5.3 / 9
+
+            segment1_height = height
+            segment1_width = int(
+                segment1_height
+                * (aspect_10_6_9 if layout_type.endswith("var1") else aspect_5_3_9)
+            )
+            segment2_height = height
+            segment2_width = int(
+                segment2_height
+                * (aspect_5_3_9 if layout_type.endswith("var1") else aspect_10_6_9)
+            )
+
+            # First segment
+            segment_center_x = original_center_x - segment2_width // 4
+            segment_x_start = int(
+                max(
+                    0,
+                    min(width - segment1_width, segment_center_x - segment1_width // 2),
+                )
+            )
+            segment_x_end = int(min(width, segment_x_start + segment1_width))
+
+            cv2.rectangle(
+                visualization,
+                (segment_x_start, 0),
+                (segment_x_end, segment1_height),
+                layout_color,
+                thickness,
+            )
+            cv2.putText(
+                visualization,
+                f"16:9 Part 1",
+                (segment_x_start + 5, 30),
+                font,
+                font_scale,
+                layout_color,
+                font_thickness,
+            )
 
-        if target_width_9_16 <= cutout_width:
-            # Center horizontally around person
+            # Second segment
+            segment_center_x = original_center_x + segment1_width // 4
+            segment_x_start = int(
+                max(
+                    0,
+                    min(width - segment2_width, segment_center_x - segment2_width // 2),
+                )
+            )
+            segment_x_end = int(min(width, segment_x_start + segment2_width))
+
+            cv2.rectangle(
+                visualization,
+                (segment_x_start, 0),
+                (segment_x_end, segment2_height),
+                layout_color,
+                thickness,
+            )
+            cv2.putText(
+                visualization,
+                f"16:9 Part 2",
+                (segment_x_start + 5, 60),
+                font,
+                font_scale,
+                layout_color,
+                font_thickness,
+            )
+        else:  # aspect_key == "9:16"
+            # For 9:16 (two segments stacked)
+            aspect_9_16 = 9 / 16
+            target_width_9_16 = int(height * aspect_9_16)
             x_start = max(
                 0,
                 min(
-                    left_boundary + cutout_width - target_width_9_16,
+                    width - target_width_9_16,
                     original_center_x - target_width_9_16 // 2,
                 ),
             )
             x_end = x_start + target_width_9_16
+
+            aspect_9_10_6 = 9 / 10.6
+            aspect_9_5_3 = 9 / 5.3
+
+            segment1_width = target_width_9_16
+            segment1_height = int(
+                segment1_width
+                / (aspect_9_10_6 if layout_type.endswith("var1") else aspect_9_5_3)
+            )
+            segment2_width = target_width_9_16
+            segment2_height = int(
+                segment2_width
+                / (aspect_9_5_3 if layout_type.endswith("var1") else aspect_9_10_6)
+            )
+
+            # First segment (top)
+            segment_y_start = 0
+            segment_y_end = min(height, segment_y_start + segment1_height)
+
+            cv2.rectangle(
+                visualization,
+                (x_start, segment_y_start),
+                (x_end, segment_y_end),
+                layout_color,
+                thickness,
+            )
+            cv2.putText(
+                visualization,
+                f"9:16 Part 1",
+                (x_start + 5, segment_y_start + 30),
+                font,
+                font_scale,
+                layout_color,
+                font_thickness,
+            )
+
+            # Second segment (bottom)
+            segment_y_start = segment_y_end
+            segment_y_end = min(height, segment_y_start + segment2_height)
+
             cv2.rectangle(
-                visualization, (x_start, 0), (x_end, height), colors["9:16"], thickness
+                visualization,
+                (x_start, segment_y_start),
+                (x_end, segment_y_end),
+                layout_color,
+                thickness,
             )
             cv2.putText(
                 visualization,
-                "9:16",
-                (x_start + 5, 60),
+                f"9:16 Part 2",
+                (x_start + 5, segment_y_start + 30),
                 font,
                 font_scale,
-                colors["9:16"],
+                layout_color,
                 font_thickness,
             )
 
-    # Draw centered half width layout if requested
-    if "half" in crop_types:
-        half_width = width // 2
-        half_left_x = max(
-            0, min(width - half_width, original_center_x - half_width // 2)
+    # Draw twoequalhalfs layouts
+    elif layout_type == "twoequalhalfs":
+        # For 16:9 (two 8:9 segments side by side)
+        aspect_8_9 = 8 / 9
+
+        segment_height = height
+        segment_width = int(segment_height * aspect_8_9)
+
+        # First segment (left)
+        segment_center_x = original_center_x - segment_width // 2
+        segment_x_start = int(
+            max(0, min(width - segment_width, segment_center_x - segment_width // 2))
         )
-        half_right_x = half_left_x + half_width
+        segment_x_end = int(min(width, segment_x_start + segment_width))
+
         cv2.rectangle(
             visualization,
-            (half_left_x, 0),
-            (half_right_x, height),
-            colors["half"],
+            (segment_x_start, 0),
+            (segment_x_end, segment_height),
+            colors["twoequalhalfs"]["16:9"],
             thickness,
         )
         cv2.putText(
             visualization,
-            "Half Width",
-            (half_left_x + 5, 90),
+            f"16:9 Equal 1",
+            (segment_x_start + 5, 30),
             font,
             font_scale,
-            colors["half"],
+            colors["twoequalhalfs"]["16:9"],
             font_thickness,
         )
 
-    # Draw centered third width layout if requested
-    if "third" in crop_types:
-        third_width = width // 3
-        third_left_x = max(
-            0, min(width - third_width, original_center_x - third_width // 2)
+        # Second segment (right)
+        segment_center_x = original_center_x + segment_width // 2
+        segment_x_start = int(
+            max(0, min(width - segment_width, segment_center_x - segment_width // 2))
         )
-        third_right_x = third_left_x + third_width
+        segment_x_end = int(min(width, segment_x_start + segment_width))
+
         cv2.rectangle(
             visualization,
-            (third_left_x, 0),
-            (third_right_x, height),
-            colors["third"],
+            (segment_x_start, 0),
+            (segment_x_end, segment_height),
+            colors["twoequalhalfs"]["16:9"],
             thickness,
         )
         cv2.putText(
             visualization,
-            "Third Width",
-            (third_left_x + 5, 120),
+            f"16:9 Equal 2",
+            (segment_x_start + 5, 60),
             font,
             font_scale,
-            colors["third"],
+            colors["twoequalhalfs"]["16:9"],
             font_thickness,
         )
 
-    # Draw centered two-thirds width layout if requested
-    if "two_thirds" in crop_types:
-        two_thirds_width = (width * 2) // 3
-        two_thirds_left_x = max(
-            0, min(width - two_thirds_width, original_center_x - two_thirds_width // 2)
+        # For 9:16 (two 9:8 segments stacked)
+        aspect_9_16 = 9 / 16
+        target_width_9_16 = int(height * aspect_9_16)
+        x_start = max(
+            0,
+            min(width - target_width_9_16, original_center_x - target_width_9_16 // 2),
+        )
+        x_end = x_start + target_width_9_16
+
+        aspect_9_8 = 9 / 8
+        segment_width_9_16 = target_width_9_16
+        segment_height_9_16 = int(segment_width_9_16 / aspect_9_8)
+
+        # First segment (top)
+        segment_y_start = 0
+        segment_y_end = min(height, segment_y_start + segment_height_9_16)
+
+        cv2.rectangle(
+            visualization,
+            (x_start, segment_y_start),
+            (x_end, segment_y_end),
+            colors["twoequalhalfs"]["9:16"],
+            thickness,
         )
-        two_thirds_right_x = two_thirds_left_x + two_thirds_width
+        cv2.putText(
+            visualization,
+            f"9:16 Equal 1",
+            (x_start + 5, segment_y_start + 30),
+            font,
+            font_scale,
+            colors["twoequalhalfs"]["9:16"],
+            font_thickness,
+        )
+
+        # Second segment (bottom)
+        segment_y_start = segment_y_end
+        segment_y_end = min(height, segment_y_start + segment_height_9_16)
+
         cv2.rectangle(
             visualization,
-            (two_thirds_left_x, 0),
-            (two_thirds_right_x, height),
-            colors["two_thirds"],
+            (x_start, segment_y_start),
+            (x_end, segment_y_end),
+            colors["twoequalhalfs"]["9:16"],
             thickness,
         )
         cv2.putText(
             visualization,
-            "Two-Thirds Width",
-            (two_thirds_left_x + 5, 150),
+            f"9:16 Equal 2",
+            (x_start + 5, segment_y_start + 30),
             font,
             font_scale,
-            colors["two_thirds"],
+            colors["twoequalhalfs"]["9:16"],
             font_thickness,
         )
 
@@ -847,15 +1572,6 @@ def draw_crops_on_original(image, left_division, right_division, crop_types):
         (0, 0, 0),
         2,
     )
-    cv2.putText(
-        visualization,
-        "Person Center",
-        (original_center_x + 10, original_center_y),
-        font,
-        font_scale,
-        (255, 255, 255),
-        font_thickness,
-    )
 
     # Convert back to PIL format
     visualization_pil = Image.fromarray(cv2.cvtColor(visualization, cv2.COLOR_BGR2RGB))
@@ -865,7 +1581,7 @@ def draw_crops_on_original(image, left_division, right_division, crop_types):
 
 def get_image_crop(cid=None, rsid=None, uid=None):
     """
-    Function that returns both 16:9 and 9:16 crops and layout variations for visualization.
+    Function that returns both standard and layout variations for visualization.
 
     Returns:
         gr.Gallery: Gallery of all generated images
@@ -874,6 +1590,7 @@ def get_image_crop(cid=None, rsid=None, uid=None):
         image_paths = get_sprite_firebase(cid, rsid, uid)
     except Exception:
         image_paths = ["data/sprite1.jpg", "data/sprite2.jpg"]
+
     # Lists to store all images
     all_images = []
     all_captions = []
@@ -923,32 +1640,70 @@ def get_image_crop(cid=None, rsid=None, uid=None):
 
         print(f"Using divisions: left={left_division}, right={right_division}")
 
-        # Create layouts and cutouts
-        layouts, cutout_image, cutout_16_9, cutout_9_16 = create_layouts(
-            mid_image, left_division, right_division
+        # Create layouts and cutouts using the new function
+        (
+            standard_crops,
+            threehalfs_layouts,
+            twothirdhalfs_layouts,
+            twoequalhalfs_layouts,
+            visualization_data,
+        ) = create_layouts(mid_image, left_division, right_division)
+
+        # Create all the required visualizations
+        # 1. Standard aspect ratio visualization (16:9 and 9:16)
+        standard_visualization = draw_layout_regions(
+            mid_image, left_division, right_division, visualization_data, "standard"
+        )
+        all_images.append(standard_visualization)
+        all_captions.append(
+            f"Standard Aspect Ratios (16:9 & 9:16) {standard_visualization.size}"
         )
 
-        # Create the first visualization with 16:9 and 9:16 crops only
-        aspect_ratio_visualization = draw_crops_on_original(
-            mid_image, left_division, right_division, ["16:9", "9:16"]
+        # 2. Threehalfs visualization
+        threehalfs_visualization = draw_layout_regions(
+            mid_image, left_division, right_division, visualization_data, "threehalfs"
         )
+        all_images.append(threehalfs_visualization)
+        all_captions.append(f"Three Halfs Layout {threehalfs_visualization.size}")
 
-        # Create the second visualization with the remaining layouts
-        other_layouts_visualization = draw_crops_on_original(
+        # 3. Twothirdhalfs var1 visualization
+        twothirdhalfs_var1_visualization = draw_layout_regions(
             mid_image,
             left_division,
             right_division,
-            ["cutout", "half", "third", "two_thirds"],
+            visualization_data,
+            "twothirdhalfs_var1",
+        )
+        all_images.append(twothirdhalfs_var1_visualization)
+        all_captions.append(
+            f"Two-Thirds Halfs Var1 Layout {twothirdhalfs_var1_visualization.size}"
         )
 
-        # Add visualizations showing crops
-        all_images.append(aspect_ratio_visualization)
+        # 4. Twothirdhalfs var2 visualization
+        twothirdhalfs_var2_visualization = draw_layout_regions(
+            mid_image,
+            left_division,
+            right_division,
+            visualization_data,
+            "twothirdhalfs_var2",
+        )
+        all_images.append(twothirdhalfs_var2_visualization)
         all_captions.append(
-            f"Aspect Ratio Crops (16:9 & 9:16) {aspect_ratio_visualization.size}"
+            f"Two-Thirds Halfs Var2 Layout {twothirdhalfs_var2_visualization.size}"
         )
 
-        all_images.append(other_layouts_visualization)
-        all_captions.append(f"Other Layout Options {other_layouts_visualization.size}")
+        # 5. Twoequalhalfs visualization
+        twoequalhalfs_visualization = draw_layout_regions(
+            mid_image,
+            left_division,
+            right_division,
+            visualization_data,
+            "twoequalhalfs",
+        )
+        all_images.append(twoequalhalfs_visualization)
+        all_captions.append(
+            f"Two Equal Halfs Layout {twoequalhalfs_visualization.size}"
+        )
 
         # Add input and middle image to gallery
         all_images.append(input_image)
@@ -957,21 +1712,25 @@ def get_image_crop(cid=None, rsid=None, uid=None):
         all_images.append(mid_image)
         all_captions.append(f"Middle Thumbnail {mid_image.size}")
 
-        # Add cutout images to gallery
-        all_images.append(cutout_image)
-        all_captions.append(f"Cutout Image {cutout_image.size}")
+        # Add standard crops
+        for key, crop in standard_crops.items():
+            all_images.append(crop)
+            all_captions.append(f"{key} {crop.size}")
 
-        all_images.append(cutout_16_9)
-        all_captions.append(f"16:9 Crop {cutout_16_9.size}")
+        # Add threehalfs layouts
+        for key, layout in threehalfs_layouts.items():
+            all_images.append(layout)
+            all_captions.append(f"Three Halfs {key} {layout.size}")
 
-        all_images.append(cutout_9_16)
-        all_captions.append(f"9:16 Crop {cutout_9_16.size}")
+        # Add twothirdhalfs layouts
+        for key, layout in twothirdhalfs_layouts.items():
+            all_images.append(layout)
+            all_captions.append(f"Two-Thirds Halfs {key} {layout.size}")
 
-        # Add layout variations
-        for i, layout in enumerate(layouts):
-            label = ["Half Width", "Third Width", "Two-Thirds Width"][i]
+        # Add twoequalhalfs layouts
+        for key, layout in twoequalhalfs_layouts.items():
             all_images.append(layout)
-            all_captions.append(f"{label} {layout.size}")
+            all_captions.append(f"Two Equal Halfs {key} {layout.size}")
 
     # Return gallery with all images
     return gr.Gallery(value=list(zip(all_images, all_captions)))