Upload folder using huggingface_hub

create_dataset.sh

@@ -26,10 +26,10 @@ main() {
         random_merge dataset/training/im dataset/training/gt &
         random_merge dataset/training/im dataset/training/gt &
         random_merge dataset/training/im dataset/training/gt &
-        random_merge dataset/training/im dataset/training/gt &
-        random_merge dataset/training/im dataset/training/gt &
-        random_merge dataset/training/im dataset/training/gt &
-        random_merge dataset/validation/im dataset/validation/g
+        random_merge dataset/training/im dataset/training/gt
+        random_merge dataset/training/im dataset/training/gt
+        random_merge dataset/training/im dataset/training/gt
+        random_merge dataset/validation/im dataset/validation/gt
     done
 }
 

util/merge_images.py

@@ -12,8 +12,8 @@ def apply_scale_and_move(image):
             A.HorizontalFlip(p=0.5),
             A.ShiftScaleRotate(
                 shift_limit_x=(-0.3, 0.3),
-                shift_limit_y=(0.0, 0.2),
-                scale_limit=(1.0, 1.5),
+                shift_limit_y=(-0.1, 0.6),
+                scale_limit=(1.0, 1.2),
                 border_mode=cv2.BORDER_CONSTANT,
                 rotate_limit=(-3, 3),
                 p=0.7,
@@ -23,7 +23,7 @@ def apply_scale_and_move(image):
     return transform(image=image)["image"]
 
 
-def apply_transform(image):
+def augment_overlay(image):
     has_alpha = image.shape[2] == 4
     if has_alpha:
         alpha_channel = image[:, :, 3]
@@ -59,7 +59,7 @@ def apply_transform(image):
     return final_image
 
 
-def apply_noise(image):
+def augment_result(image):
     transform = A.Compose(
         [
             A.MotionBlur(blur_limit=(5, 11), p=1.0),
@@ -97,85 +97,79 @@ def remove_alpha(image, alpha_threshold=200):
     return image
 
 
-def merge_images(
-    background_path, overlay_path, output_path, groundtruth_path, width, height
-):
+def merge_images(background_path, overlay_path, output_path, groundtruth_path):
     letters = string.ascii_lowercase
     random_string = "".join(random.choice(letters) for i in range(13))
     file_name = random_string + "_" + os.path.basename(overlay_path)
 
-    # Read the background image and resize it to the specified dimensions
     background = cv2.imread(background_path, cv2.IMREAD_COLOR)
-
     height, width = background.shape[:2]
 
-    height = int(1.5 * height)
-    width = int(1.5 * width)
-
-    resized_background = cv2.resize(
-        background, (width, height), interpolation=cv2.INTER_AREA
-    )
-
-    # Read the overlay image with alpha channel
     overlay = cv2.imread(overlay_path, cv2.IMREAD_UNCHANGED)
 
-    # Ensure overlay has an alpha channel
     if overlay.shape[2] < 4:
         raise Exception("Overlay image does not have an alpha channel.")
 
-    # Apply transformations to the overlay
     overlay = expand_image_borders_rgba(overlay, width, height)
     overlay = apply_scale_and_move(overlay)
 
     # store ground truth
-    extract_alpha_channel_as_bw(overlay, os.path.join(groundtruth_path, file_name))
+    store_ground_truth(overlay, os.path.join(groundtruth_path, file_name))
 
-    overlay = apply_transform(overlay)
+    overlay = augment_overlay(overlay)
 
-    # Overlay placement on the resized background
-    x_offset = (width - overlay.shape[1]) // 2
-    y_offset = (height - overlay.shape[0]) // 2
+    # Calculate the aspect ratio of the overlay
+    overlay_height, overlay_width = overlay.shape[:2]
+    aspect_ratio = overlay_width / overlay_height
 
-    # Preventing overlay from exceeding the background dimensions
-    x_offset = max(0, x_offset)
-    y_offset = max(0, y_offset)
+    # Calculate scaling factors, maintaining the aspect ratio
+    max_height = background.shape[0]
+    max_width = background.shape[1]
+    scale_width = max_width
+    scale_height = int(scale_width / aspect_ratio)
 
-    # Calculate the normalized alpha mask
-    alpha_overlay = overlay[..., 3] / 255.0
-    region_of_interest = resized_background[
-        y_offset : y_offset + overlay.shape[0],
-        x_offset : x_offset + overlay.shape[1],
-        :,
+    # Check if the scaled overlay height is too large
+    if scale_height > max_height:
+        scale_height = max_height
+        scale_width = int(scale_height * aspect_ratio)
+
+    # Resize the overlay image
+    overlay_resized = cv2.resize(overlay, (scale_width, scale_height))
+
+    # Calculate position for overlay (centered)
+    x_pos = (background.shape[1] - scale_width) // 2
+    y_pos = (background.shape[0] - scale_height) // 2
+
+    # Extract the alpha mask and the color channels of the overlay
+    alpha_mask = overlay_resized[:, :, 3] / 255.0
+    overlay_color = overlay_resized[:, :, :3]
+
+    # Use the mask to create the transparent effect in the background
+    background_part = (1 - alpha_mask)[:, :, None] * background[
+        y_pos : y_pos + scale_height, x_pos : x_pos + scale_width, :
     ]
+    overlay_part = alpha_mask[:, :, None] * overlay_color
 
-    # Blend the images
-    for c in range(0, 3):
-        region_of_interest[..., c] = (
-            alpha_overlay * overlay[..., c]
-            + (1 - alpha_overlay) * region_of_interest[..., c]
-        )
+    # Add the overlay part to the background part
+    merged = background_part + overlay_part
 
-    resized_background[
-        y_offset : y_offset + overlay.shape[0], x_offset : x_offset + overlay.shape[1]
-    ] = region_of_interest
+    # Put the merged image back into the background
+    background[y_pos : y_pos + scale_height, x_pos : x_pos + scale_width] = merged
 
-    resized_background = apply_noise(resized_background)
+    result = augment_result(background)
 
-    cv2.imwrite(os.path.join(output_path, file_name), resized_background)
+    cv2.imwrite(os.path.join(output_path, file_name), result)
 
 
 def expand_image_borders_rgba(
     image, final_width, final_height, border_color=(0, 0, 0, 0)
 ):
-    # Check if image has an alpha channel
-    if image.shape[2] < 4:
-        raise ValueError(
-            "Loaded image does not contain an alpha channel. Make sure the input image is RGBA."
-        )
-
-    # Current dimensions
     height, width = image.shape[:2]
 
+    # The background image might be smaller or bigger
+    final_height = max(height, final_height)
+    final_width = max(width, final_width)
+
     # Calculate padding needed
     top = bottom = (final_height - height) // 2
     left = right = (final_width - width) // 2
@@ -194,7 +188,7 @@ def expand_image_borders_rgba(
     return new_image
 
 
-def extract_alpha_channel_as_bw(image, output_path):
+def store_ground_truth(image, output_path):
     # Check if the image has an alpha channel
     if image.shape[2] < 4:
         raise ValueError(
@@ -225,18 +219,6 @@ def main():
         default="im",
         help="Path where the merged image will be saved",
     )
-    parser.add_argument(
-        "--width",
-        type=int,
-        default=1920,
-        help="Width to which the background image will be resized",
-    )
-    parser.add_argument(
-        "--height",
-        type=int,
-        default=1080,
-        help="Height to which the background image will be resized",
-    )
     parser.add_argument(
         "-gt",
         "--groundtruth-path",
@@ -256,8 +238,6 @@ def main():
         args.overlay,
         args.image_path,
         args.groundtruth_path,
-        args.width,
-        args.height,
     )