Upload folder using huggingface_hub

README.md

@@ -23,12 +23,10 @@ I created more than 5.000 images with people and more than 5.000 diverse backgro
 
 # Examples
 
-![](./humans/example01.png)
-![](./humans/example02.png)
-![](./humans/example03.png)
-![](./backgrounds/background01.png)
-![](./backgrounds/background02.png)
-![](./backgrounds/background03.png)
+Here you can see an augmented image and the resulting ground truth:
+
+![](example_image.png)
+![](example_ground_truth.png)
 
 # Create Training Dataset
 

create_dataset.sh

@@ -1,35 +1,41 @@
 #!/bin/bash
 
-random_merge() {
+merge() {
     local backgrounds_dir="backgrounds"
-    local overlays_dir="humans"
-    
-    local image_path="$1"
-    local groundtruth_path="$2"
-    
+    local segmentations_dir="humans"
+
     background=$(find "$backgrounds_dir" -type f | shuf -n 1)
-    overlay=$(find "$overlays_dir" -type f | shuf -n 1)
-    echo "Processing iteration $i: $overlay + $background"
+    segmentation=$(find "$segmentations_dir" -type f | shuf -n 1)
+
+    echo "Iteration $i: $segmentation + $background"
+
     python3 "util/merge_images.py" \
-        -b "$background" -o "$overlay" \
-        -gt "$groundtruth_path" -im "$image_path"
+        -b "$background" -s "$segmentation" \
+        -im "$1" -gt "$2"
 }
 
 main() {
     local max_iterations=2000
+    local train_gt_path="dataset/training/gt"
+    local train_image_path="dataset/training/im"
+    local validation_gt_path="dataset/validation/gt"
+    local validation_image_path="dataset/validation/im"
     for ((i = 0 ; i <= $max_iterations ; i++)); do
         # For quicker creation some parallelization
-        # Notice: last iteration if for validation set
-        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/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
+        # Notice: last iteration is for validation set
+        {
+            merge "$train_image_path" "$train_gt_path" &
+            merge "$train_image_path" "$train_gt_path" &
+            merge "$train_image_path" "$train_gt_path" &
+            merge "$train_image_path" "$train_gt_path" &
+            merge "$train_image_path" "$train_gt_path" &
+            merge "$train_image_path" "$train_gt_path" &
+            merge "$train_image_path" "$train_gt_path" &
+            merge "$train_image_path" "$train_gt_path" &
+            merge "$train_image_path" "$train_gt_path" &
+            merge "$validation_image_path" "$validation_gt_path" &
+        }
+        wait
     done
 }
 

util/merge_images.py

@@ -6,66 +6,17 @@ import string
 import albumentations as A
 
 
-def apply_scale_and_move(image):
-    transform = A.Compose(
-        [
-            A.HorizontalFlip(p=0.5),
-            A.ShiftScaleRotate(
-                shift_limit_x=(-0.3, 0.3),
-                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,
-            ),
-        ]
-    )
-    return transform(image=image)["image"]
-
-
-def augment_overlay(image):
-    has_alpha = image.shape[2] == 4
-    if has_alpha:
-        alpha_channel = image[:, :, 3]
-        color_channels = image[:, :, :3]
-    else:
-        color_channels = image
-
-    # Define the transformation
-    transform = A.Compose(
-        [
-            A.RandomBrightnessContrast(
-                brightness_limit=(-0.1, 0.1), contrast_limit=(-0.4, 0), p=0.8
-            )
-        ]
-    )
-
-    # Apply the transformation only to the color channels
-    transformed = transform(image=color_channels)
-    transformed_image = transformed["image"]
-
-    # Merge the alpha channel back if it was separated
-    if has_alpha:
-        final_image = cv2.merge(
-            (
-                transformed_image[:, :, 0],
-                transformed_image[:, :, 1],
-                transformed_image[:, :, 2],
-                alpha_channel,
-            )
-        )
-    else:
-        final_image = transformed_image
-    return final_image
-
-
-def augment_result(image):
+def augment_final_image(image):
     transform = A.Compose(
         [
             A.MotionBlur(blur_limit=(5, 11), p=1.0),
             A.GaussNoise(var_limit=(10, 150), p=1.0),
-            A.RandomBrightnessContrast(
-                brightness_limit=(-0.1, 0.1), contrast_limit=(-0.1, 0.1), p=0.5
+            A.ColorJitter(
+                brightness=(0.6, 1.0),
+                contrast=(0.6, 1.0),
+                saturation=(0.3, 1),
+                hue=(0.0, 0.1),
+                p=0.5,
             ),
             A.RandomFog(
                 fog_coef_lower=0.05,
@@ -89,117 +40,133 @@ def augment_result(image):
     return transform(image=image)["image"]
 
 
-def remove_alpha(image, alpha_threshold=200):
-
+def remove_alpha_threshold(image, alpha_threshold=160):
+    # This function removes artifacts created by LayerDiffusion
     mask = image[:, :, 3] < alpha_threshold
     image[mask] = [0, 0, 0, 0]
-
     return image
 
 
-def merge_images(background_path, overlay_path, output_path, groundtruth_path):
+def create_ground_truth_mask(image):
+    image = remove_alpha_threshold(image.copy())
+    return image[:, :, 3]
+
+
+def create_random_filename_from_filepath(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)
+    return random_string + "_" + os.path.basename(path)
 
-    background = cv2.imread(background_path, cv2.IMREAD_COLOR)
-    height, width = background.shape[:2]
 
-    overlay = cv2.imread(overlay_path, cv2.IMREAD_UNCHANGED)
+def scale_image(image, factor=1.5):
+    width = int(image.shape[1] * factor)
+    height = int(image.shape[0] * factor)
+    return cv2.resize(image, (width, height), interpolation=cv2.INTER_LINEAR)
 
-    if overlay.shape[2] < 4:
-        raise Exception("Overlay image does not have an alpha channel.")
 
-    overlay = expand_image_borders_rgba(overlay, width, height)
-    overlay = apply_scale_and_move(overlay)
+def augment_and_match_size(image, target_width, target_height):
 
-    # store ground truth
-    store_ground_truth(overlay, os.path.join(groundtruth_path, file_name))
+    random_scale = random.uniform(1, 1.5)
+    image = scale_image(image, random_scale)
 
-    overlay = augment_overlay(overlay)
+    transform = A.Compose(
+        [
+            A.HorizontalFlip(p=0.5),
+            A.ShiftScaleRotate(
+                shift_limit_x=(-0.3, 0.3),
+                shift_limit_y=(0.0, 0.4),
+                scale_limit=(0, 0),
+                border_mode=cv2.BORDER_CONSTANT,
+                rotate_limit=(-5, 5),
+                p=0.7,
+            ),
+        ]
+    )
+    image = transform(image=image)["image"]
+
+    # Ensure the image matches the target dimensions
+    current_height, current_width = image.shape[:2]
+
+    # Crop if the image is larger than the target size
+    if current_height > target_height or current_width > target_width:
+        # Calculating the top-left point to crop the image
+        start_x = max(0, (current_width - target_width) // 2)
+        start_y = max(0, (current_height - target_height) // 2)
+        image = image[
+            start_y : start_y + target_height, start_x : start_x + target_width
+        ]
 
-    # Calculate the aspect ratio of the overlay
-    overlay_height, overlay_width = overlay.shape[:2]
-    aspect_ratio = overlay_width / overlay_height
+    # Pad if the image is smaller than the target size
+    if current_height < target_height or current_width < target_width:
+        delta_w = max(0, target_width - current_width)
+        delta_h = max(0, target_height - current_height)
+        top, bottom = delta_h // 2, delta_h - (delta_h // 2)
+        left, right = delta_w // 2, delta_w - (delta_w // 2)
+        color = [0, 0, 0, 0]
+        image = cv2.copyMakeBorder(
+            image, top, bottom, left, right, cv2.BORDER_CONSTANT, value=color
+        )
 
-    # 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)
+    return image
 
-    # 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))
+def merge_images(background, foreground, position=(0, 0)):
 
-    # Calculate position for overlay (centered)
-    x_pos = (background.shape[1] - scale_width) // 2
-    y_pos = (background.shape[0] - scale_height) // 2
+    x, y = position
 
-    # Extract the alpha mask and the color channels of the overlay
-    alpha_mask = overlay_resized[:, :, 3] / 255.0
-    overlay_color = overlay_resized[:, :, :3]
+    fh, fw = foreground.shape[:2]
 
-    # 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
+    if x + fw > background.shape[1]:
+        fw = background.shape[1] - x
+        foreground = foreground[:, :fw]
+    if y + fh > background.shape[0]:
+        fh = background.shape[0] - y
+        foreground = foreground[:fh, :]
 
-    # Add the overlay part to the background part
-    merged = background_part + overlay_part
+    # Region of Interest (ROI) in the background where the foreground will be placed
+    roi = background[y : y + fh, x : x + fw]
 
-    # Put the merged image back into the background
-    background[y_pos : y_pos + scale_height, x_pos : x_pos + scale_width] = merged
+    # Split the foreground image into its color and alpha channels
+    foreground_color = foreground[:, :, :3]
+    alpha = foreground[:, :, 3] / 255.0
 
-    result = augment_result(background)
+    # Blend the images based on the alpha channel
+    for c in range(0, 3):
+        roi[:, :, c] = (1.0 - alpha) * roi[:, :, c] + alpha * foreground_color[:, :, c]
 
-    cv2.imwrite(os.path.join(output_path, file_name), result)
+    # Place the modified ROI back into the original image
+    background[y : y + fh, x : x + fw] = roi
 
+    return background
 
-def expand_image_borders_rgba(
-    image, final_width, final_height, border_color=(0, 0, 0, 0)
-):
-    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)
+def create_training_data(
+    background_path, segmentation_path, image_path, ground_truth_path
+):
+    background = cv2.imread(background_path, cv2.IMREAD_COLOR)
+    segmentation = cv2.imread(segmentation_path, cv2.IMREAD_UNCHANGED)
 
-    # Calculate padding needed
-    top = bottom = (final_height - height) // 2
-    left = right = (final_width - width) // 2
+    if segmentation.shape[2] < 4:
+        raise Exception(f"Image does not have an alpha channel: {segmentation_path}")
 
-    # To handle cases where the new dimensions are odd and original dimensions are even (or vice versa)
-    if (final_height - height) % 2 != 0:
-        bottom += 1
-    if (final_width - width) % 2 != 0:
-        right += 1
+    file_name = create_random_filename_from_filepath(segmentation_path)
+    image_path = os.path.join(image_path, file_name)
+    ground_truth_path = os.path.join(ground_truth_path, file_name)
 
-    # Apply make border with an RGBA color
-    new_image = cv2.copyMakeBorder(
-        image, top, bottom, left, right, cv2.BORDER_CONSTANT, value=border_color
+    bg_height, bg_width = background.shape[:2]
+    segmentation = augment_and_match_size(
+        segmentation, target_height=bg_height, target_width=bg_width
     )
+    ground_truth = create_ground_truth_mask(segmentation)
 
-    return new_image
+    result = merge_images(background, segmentation)
+    result = augment_final_image(result)
 
+    assert ground_truth.shape[0] == result.shape[0]
+    assert ground_truth.shape[1] == result.shape[1]
 
-def store_ground_truth(image, output_path):
-    # Check if the 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 in PNG format with an alpha channel."
-        )
-
-    # Extract the alpha channel
-    image = remove_alpha(image.copy())
-    alpha_channel = image[:, :, 3]
-    # Save or display the alpha channel as a black and white image
-    cv2.imwrite(output_path, alpha_channel)
+    cv2.imwrite(ground_truth_path, ground_truth)
+    cv2.imwrite(image_path, result)
 
 
 def main():
@@ -210,7 +177,7 @@ def main():
         "-b", "--background", required=True, help="Path to the background image"
     )
     parser.add_argument(
-        "-o", "--overlay", required=True, help="Path to the overlay image"
+        "-s", "--segmentation", required=True, help="Path to the segmentation image"
     )
     parser.add_argument(
         "-im",
@@ -233,11 +200,11 @@ def main():
     if not os.path.exists(args.groundtruth_path):
         os.makedirs(args.groundtruth_path)
 
-    merge_images(
-        args.background,
-        args.overlay,
-        args.image_path,
-        args.groundtruth_path,
+    create_training_data(
+        background_path=args.background,
+        segmentation_path=args.segmentation,
+        image_path=args.image_path,
+        ground_truth_path=args.groundtruth_path,
     )
 
 

util/test.py

@@ -0,0 +1,8 @@
+import cv2
+from merge_images import augment_and_match_size
+
+
+if __name__ == "__main__":
+    image = cv2.imread("humans/example01.png", cv2.IMREAD_UNCHANGED)
+    result = augment_and_match_size(image, 600, 1000)
+    cv2.imwrite("dataset/test.png", result)