position padding logic

.gitignore

@@ -1,4 +1,7 @@
 venv/
 temp_input/
 temp_output/
-processed_images.zip
+processed_images.zip
+test_input/
+test_output/
+bria_output/

Task1-2.zip

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:98299bfa9112b782fa4d66e06930e89e54930a8cd937ffd59e578909af2dde2e
-size 625294

app.py

@@ -2,68 +2,15 @@ import os
 import zipfile
 import shutil
 import time
-from PIL import Image
+from PIL import Image, ImageDraw
 import io
 from rembg import remove
 import gradio as gr
 from concurrent.futures import ThreadPoolExecutor
 from transformers import pipeline
-
-def colors_within_tolerance(color1, color2, tolerance):
-    return all(abs(c1 - c2) <= tolerance for c1, c2 in zip(color1, color2))
-
-def check_border_colors(image_path, tolerance):
-    image = Image.open(image_path)
-    pixels = image.load()
-    
-    width, height = image.size
-
-    left_border_color = pixels[0, 0]
-    right_border_color = pixels[width - 1, 0]
-
-    for y in range(height):
-        if not colors_within_tolerance(pixels[0, y], left_border_color, tolerance):
-            return False
-        if not colors_within_tolerance(pixels[width - 1, y], right_border_color, tolerance):
-            return False
-
-    return True
-
-def resize_and_crop_image(image_path, target_size=(1080, 1080), crop_mode='center'):
-    print(f"Resizing and cropping image: {image_path}")
-    with Image.open(image_path) as img:
-        width, height = img.size
-        print(f"Original image size: {width}x{height}")
-
-        scaling_factor = max(target_size[0] / width, target_size[1] / height)
-
-        new_size = (int(width * scaling_factor), int(height * scaling_factor))
-        resized_img = img.resize(new_size, Image.LANCZOS)
-        print(f"Resized image size: {new_size}")
-
-        if crop_mode == 'center':
-            left = (resized_img.width - target_size[0]) / 2
-            top = (resized_img.height - target_size[1]) / 2
-        elif crop_mode == 'top':
-            left = (resized_img.width - target_size[0]) / 2
-            top = 0
-        elif crop_mode == 'bottom':
-            left = (resized_img.width - target_size[0]) / 2
-            top = resized_img.height - target_size[1]
-        elif crop_mode == 'left':
-            left = 0
-            top = (resized_img.height - target_size[1]) / 2
-        elif crop_mode == 'right':
-            left = resized_img.width - target_size[0]
-            top = (resized_img.height - target_size[1]) / 2
-
-        right = left + target_size[0]
-        bottom = top + target_size[1]
-
-        cropped_img = resized_img.crop((left, top, right, bottom))
-        print(f"Cropped image size: {cropped_img.size}")
-
-        return cropped_img
+import numpy as np
+import json
+import os
 
 def remove_background_rembg(input_path):
     print(f"Removing background using rembg for image: {input_path}")
@@ -79,7 +26,266 @@ def remove_background_bria(input_path):
     pillow_image = pipe(input_path)
     return pillow_image
 
-def process_single_image(image_path, output_folder, crop_mode, bg_method, output_format, bg_choice, custom_color, watermark_path=None):
+def get_bounding_box_with_threshold(image, threshold):
+    # Convert image to numpy array
+    img_array = np.array(image)
+    
+    # Get alpha channel
+    alpha = img_array[:,:,3]
+    
+    # Find rows and columns where alpha > threshold
+    rows = np.any(alpha > threshold, axis=1)
+    cols = np.any(alpha > threshold, axis=0)
+    
+    # Find the bounding box
+    top, bottom = np.where(rows)[0][[0, -1]]
+    left, right = np.where(cols)[0][[0, -1]]
+    
+    if left < right and top < bottom:
+        return (left, top, right, bottom)
+    else:
+        return None
+
+def position_logic(image_path, use_threshold=True):
+    image = Image.open(image_path)
+    image = image.convert("RGBA")
+    
+    # Get the bounding box of the non-blank area with threshold
+    if use_threshold:
+        bbox = get_bounding_box_with_threshold(image, threshold=10)
+    else:
+        bbox = image.getbbox()
+    log = []
+
+    if bbox:
+        # Check 1 pixel around the image for non-transparent pixels
+        width, height = image.size
+        cropped_sides = []
+        
+        # Define tolerance for transparency
+        tolerance = 10  # Adjust this value as needed
+        
+        # Check top edge
+        if any(image.getpixel((x, 0))[3] > tolerance for x in range(width)):
+            cropped_sides.append("top")
+        
+        # Check bottom edge
+        if any(image.getpixel((x, height-1))[3] > tolerance for x in range(width)):
+            cropped_sides.append("bottom")
+        
+        # Check left edge
+        if any(image.getpixel((0, y))[3] > tolerance for y in range(height)):
+            cropped_sides.append("left")
+        
+        # Check right edge
+        if any(image.getpixel((width-1, y))[3] > tolerance for y in range(height)):
+            cropped_sides.append("right")
+        
+        if cropped_sides:
+            info_message = f"Info for {os.path.basename(image_path)}: The following sides of the image may contain cropped objects: {', '.join(cropped_sides)}"
+            print(info_message)
+            log.append({"info": info_message})
+        else:
+            info_message = f"Info for {os.path.basename(image_path)}: The image is not cropped."
+            print(info_message)
+            log.append({"info": info_message})
+        
+        # Crop the image to the bounding box
+        image = image.crop(bbox)
+        log.append({"action": "crop", "bbox": [str(bbox[0]), str(bbox[1]), str(bbox[2]), str(bbox[3])]})
+        
+        # Calculate the new size to expand the image
+        padding = 125
+        target_size = 1080
+        aspect_ratio = image.width / image.height
+        
+        if len(cropped_sides) == 4:
+            # If the image is cropped on all sides, center crop it to fit the canvas
+            if aspect_ratio > 1:  # Landscape
+                new_height = target_size
+                new_width = int(new_height * aspect_ratio)
+                left = (new_width - target_size) // 2
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                image = image.crop((left, 0, left + target_size, target_size))
+            else:  # Portrait or square
+                new_width = target_size
+                new_height = int(new_width / aspect_ratio)
+                top = (new_height - target_size) // 2
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                image = image.crop((0, top, target_size, top + target_size))
+            log.append({"action": "center_crop_resize", "new_size": f"{target_size}x{target_size}"})
+            x, y = 0, 0
+        elif not cropped_sides:
+            # If the image is not cropped, expand it from center until it touches the padding
+            new_height = 1080 - 2 * padding  # Ensure it touches top and bottom padding
+            new_width = int(new_height * aspect_ratio)
+            
+            if new_width > 1080 - 2 * padding:
+                # If width exceeds available space, adjust based on width
+                new_width = 1080 - 2 * padding
+                new_height = int(new_width / aspect_ratio)
+            
+            # Resize the image
+            image = image.resize((new_width, new_height), Image.LANCZOS)
+            log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+            
+            x = (1080 - new_width) // 2
+            y = 1080 - new_height - padding
+        else:
+            # New logic for handling cropped top and left, or top and right
+            if set(cropped_sides) == {"top", "left"} or set(cropped_sides) == {"top", "right"}:
+                new_height = target_size - padding  # Ensure bottom padding
+                new_width = int(new_height * aspect_ratio)
+                
+                # If new width exceeds canvas width, adjust based on width
+                if new_width > target_size:
+                    new_width = target_size
+                    new_height = int(new_width / aspect_ratio)
+                
+                # Resize the image
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+                
+                # Set position
+                if "left" in cropped_sides:
+                    x = 0
+                else:  # right in cropped_sides
+                    x = target_size - new_width
+                y = 0
+                
+                # If the resized image is taller than the canvas minus padding, crop from the bottom
+                if new_height > target_size - padding:
+                    crop_bottom = new_height - (target_size - padding)
+                    image = image.crop((0, 0, new_width, new_height - crop_bottom))
+                    new_height = target_size - padding
+                    log.append({"action": "crop_vertical", "bottom_pixels_removed": str(crop_bottom)})
+                
+                log.append({"action": "position", "x": str(x), "y": str(y)})
+            elif set(cropped_sides) == {"bottom", "left", "right"}:
+                # Expand the image from the center
+                new_width = target_size
+                new_height = int(new_width / aspect_ratio)
+                
+                if new_height < target_size:
+                    new_height = target_size
+                    new_width = int(new_height * aspect_ratio)
+                
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                
+                # Crop to fit the canvas
+                left = (new_width - target_size) // 2
+                top = 0
+                image = image.crop((left, top, left + target_size, top + target_size))
+                
+                log.append({"action": "expand_and_crop", "new_size": f"{target_size}x{target_size}"})
+                x, y = 0, 0
+            elif cropped_sides == ["top"]:
+                # New logic for handling only top-cropped images
+                if image.width > image.height:
+                    new_width = target_size
+                    new_height = int(target_size / aspect_ratio)
+                else:
+                    new_height = target_size - padding  # Ensure bottom padding
+                    new_width = int(new_height * aspect_ratio)
+                
+                # Resize the image
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+                
+                x = (1080 - new_width) // 2
+                y = 0  # Align to top
+                
+                # Apply padding only to non-cropped sides
+                x = max(padding, min(x, 1080 - new_width - padding))
+            elif cropped_sides in [["right"], ["left"]]:
+                # New logic for handling only right-cropped or left-cropped images
+                if image.width > image.height:
+                    new_width = target_size - padding  # Ensure padding on non-cropped side
+                    new_height = int(new_width / aspect_ratio)
+                else:
+                    new_height = target_size - padding  # Ensure bottom padding
+                    new_width = int(new_height * aspect_ratio)
+                
+                # Resize the image
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+                
+                if cropped_sides == ["right"]:
+                    x = 1080 - new_width  # Align to right
+                else:  # cropped_sides == ["left"]
+                    x = 0  # Align to left without padding
+                y = 1080 - new_height - padding  # Respect bottom padding
+            elif set(cropped_sides) == {"left", "right"}:
+                # Logic for handling images cropped on both left and right sides
+                new_width = 1080  # Expand to full width of canvas
+                
+                # Calculate the aspect ratio of the original image
+                aspect_ratio = image.width / image.height
+                
+                # Calculate the new height while maintaining aspect ratio
+                new_height = int(new_width / aspect_ratio)
+                
+                # Resize the image
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+                
+                # Set horizontal position (always 0 as it spans full width)
+                x = 0
+                
+                # Calculate vertical position to respect bottom padding
+                y = 1080 - new_height - padding
+                
+                # If the resized image is taller than the canvas, crop from the top only
+                if new_height > 1080 - padding:
+                    crop_top = new_height - (1080 - padding)
+                    image = image.crop((0, crop_top, new_width, new_height))
+                    new_height = 1080 - padding
+                    y = 0
+                    log.append({"action": "crop_vertical", "top_pixels_removed": str(crop_top)})
+                else:
+                    # Align the image to the bottom with padding
+                    y = 1080 - new_height - padding
+                
+                log.append({"action": "position", "x": str(x), "y": str(y)})
+            else:
+                # Use the original resizing logic for other partially cropped images
+                if image.width > image.height:
+                    new_width = target_size
+                    new_height = int(target_size / aspect_ratio)
+                else:
+                    new_height = target_size
+                    new_width = int(target_size * aspect_ratio)
+                
+                # Resize the image
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+                
+                # Center horizontally for all images
+                x = (1080 - new_width) // 2
+                y = 1080 - new_height - padding
+                
+                # Adjust positions for cropped sides
+                if "top" in cropped_sides:
+                    y = 0
+                elif "bottom" in cropped_sides:
+                    y = 1080 - new_height
+                if "left" in cropped_sides:
+                    x = 0
+                elif "right" in cropped_sides:
+                    x = 1080 - new_width
+                
+                # Apply padding only to non-cropped sides, but keep horizontal centering
+                if "left" not in cropped_sides and "right" not in cropped_sides:
+                    x = (1080 - new_width) // 2  # Always center horizontally
+                if "top" not in cropped_sides and "bottom" not in cropped_sides:
+                    y = max(padding, min(y, 1080 - new_height - padding))
+
+    return log, image, x, y
+
+def process_single_image(image_path, output_folder, bg_method, output_format, bg_choice, custom_color, watermark_path=None):
+    add_padding_line = False
+    padding = 125
+    
     filename = os.path.basename(image_path)
     try:
         print(f"Processing image: {filename}")
@@ -91,55 +297,53 @@ def process_single_image(image_path, output_folder, crop_mode, bg_method, output
         temp_image_path = os.path.join(output_folder, f"temp_{filename}")
         image_with_no_bg.save(temp_image_path, format='PNG')
 
-        if check_border_colors(temp_image_path, tolerance=50):
-            print(f"Border colors are the same for image: {filename}")
-            if bg_choice == 'transparent':
-                new_image = Image.new("RGBA", (1080, 1080), (255, 255, 255, 0))
-            else:
-                new_image = Image.new("RGBA", (1080, 1080), custom_color)
-
-            width, height = image_with_no_bg.size
-            scaling_factor = min(1080 / width, 1080 / height)
-            new_size = (int(width * scaling_factor), int(height * scaling_factor))
-            resized_img = image_with_no_bg.resize(new_size, Image.LANCZOS)
-            print(f"Resized image size: {new_size}")
-            new_image.paste(resized_img, ((1080 - resized_img.width) // 2, (1080 - resized_img.height) // 2))
-        else:
-            print(f"Border colors are different for image: {filename}")
-            new_image = resize_and_crop_image(temp_image_path, crop_mode=crop_mode)
+        log, new_image, x, y = position_logic(temp_image_path)
 
+        # Create a new 1080x1080 canvas with the appropriate background
         if bg_choice == 'white':
-            new_image = new_image.convert("RGBA")
-            white_bg = Image.new("RGBA", new_image.size, "WHITE")
-            new_image = Image.alpha_composite(white_bg, new_image)
+            canvas = Image.new("RGBA", (1080, 1080), "WHITE")
         elif bg_choice == 'custom':
-            new_image = new_image.convert("RGBA")
-            custom_bg = Image.new("RGBA", new_image.size, custom_color)
-            new_image = Image.alpha_composite(custom_bg, new_image)
+            canvas = Image.new("RGBA", (1080, 1080), custom_color)
+        else:  # transparent
+            canvas = Image.new("RGBA", (1080, 1080), (0, 0, 0, 0))
+
+        # Paste the resized image onto the canvas
+        canvas.paste(new_image, (x, y), new_image)
+        log.append({"action": "paste", "position": [str(x), str(y)]})
+
+        # Add visible black line for padding when background is not transparent
+        if add_padding_line:
+            draw = ImageDraw.Draw(canvas)
+            draw.rectangle([padding, padding, 1080 - padding, 1080 - padding], outline="black", width=5)
+            log.append({"action": "add_padding_line"})
 
         images_paths = []
 
         output_ext = 'jpg' if output_format == 'JPG' else 'png'
         output_path_without_watermark = os.path.join(output_folder, f"without_watermark_{os.path.splitext(filename)[0]}.{output_ext}")
         if output_format == 'JPG':
-            new_image.convert('RGB').save(output_path_without_watermark, format='JPEG')
+            canvas.convert('RGB').save(output_path_without_watermark, format='JPEG')
         else:
-            new_image.save(output_path_without_watermark, format='PNG')
+            canvas.save(output_path_without_watermark, format='PNG')
         images_paths.append((output_path_without_watermark, image_path))
 
         if watermark_path:
             watermark = Image.open(watermark_path).convert("RGBA")
-            new_image_with_watermark = new_image.copy()
-            new_image_with_watermark.paste(watermark, (0, 0), watermark)
+            canvas_with_watermark = canvas.copy()
+            canvas_with_watermark.paste(watermark, (0, 0), watermark)
             output_path_with_watermark = os.path.join(output_folder, f"with_watermark_{os.path.splitext(filename)[0]}.{output_ext}")
             if output_format == 'JPG':
-                new_image_with_watermark.convert('RGB').save(output_path_with_watermark, format='JPEG')
+                canvas_with_watermark.convert('RGB').save(output_path_with_watermark, format='JPEG')
             else:
-                new_image_with_watermark.save(output_path_with_watermark, format='PNG')
-            images_paths.append((output_path_with_watermark, image_path))
+                canvas_with_watermark.save(output_path_with_watermark, format='PNG')
+            images_paths.append((output_path_with_watermark, image_path))            
 
         os.remove(temp_image_path)
 
+        with open(os.path.join(output_folder, 'process_log.json'), 'w') as log_file:
+            json.dump(log, log_file, indent=4)
+        print("Log saved to", os.path.join(output_folder, 'process_log.json'))
+
         print(f"Processed image paths: {images_paths}")
         return images_paths
 
@@ -147,7 +351,7 @@ def process_single_image(image_path, output_folder, crop_mode, bg_method, output
         print(f"Error processing {filename}: {e}")
         return None
 
-def process_images(input_files, crop_mode='center', bg_method='rembg', watermark_path=None, output_format='PNG', bg_choice='transparent', custom_color="#ffffff", num_workers=4, progress=gr.Progress()):
+def process_images(input_files, bg_method='rembg', watermark_path=None, output_format='PNG', bg_choice='transparent', custom_color="#ffffff", num_workers=4, progress=gr.Progress()):
     start_time = time.time()
     
     output_folder = "temp_output"
@@ -159,6 +363,7 @@ def process_images(input_files, crop_mode='center', bg_method='rembg', watermark
     original_images = []
     
     if isinstance(input_files, str) and input_files.lower().endswith(('.zip', '.rar')):
+        # Handle zip file
         input_folder = "temp_input"
         if os.path.exists(input_folder):
             shutil.rmtree(input_folder)
@@ -172,15 +377,19 @@ def process_images(input_files, crop_mode='center', bg_method='rembg', watermark
             return [], None, 0
         
         image_files = [os.path.join(input_folder, f) for f in os.listdir(input_folder) if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif', '.webp'))]
+    elif isinstance(input_files, list):
+        # Handle multiple files
+        image_files = input_files
     else:
-        image_files = [f.name for f in input_files]
+        # Handle single file
+        image_files = [input_files]
     
     total_images = len(image_files)
     print(f"Total images to process: {total_images}")
 
     avg_processing_time = 0
     with ThreadPoolExecutor(max_workers=num_workers) as executor:
-        future_to_image = {executor.submit(process_single_image, image_path, output_folder, crop_mode, bg_method, output_format, bg_choice, custom_color, watermark_path): image_path for image_path in image_files}
+        future_to_image = {executor.submit(process_single_image, image_path, output_folder, bg_method, output_format, bg_choice, custom_color, watermark_path): image_path for image_path in image_files}
         for idx, future in enumerate(future_to_image):
             try:
                 start_time_image = time.time()
@@ -217,21 +426,24 @@ def process_images(input_files, crop_mode='center', bg_method='rembg', watermark
     
     return original_images, processed_images, output_zip_path, processing_time
 
-def gradio_interface(input_type, input_files, crop_mode, bg_method, watermark, output_format, bg_choice, custom_color, num_workers):
+def gradio_interface(input_files, bg_method, watermark, output_format, bg_choice, custom_color, num_workers):
     progress = gr.Progress()
     watermark_path = watermark.name if watermark else None
     
-    if input_type == "zip_rar":
-        return process_images(input_files.name, crop_mode, bg_method, watermark_path, output_format, bg_choice, custom_color, num_workers, progress)
+    # Check input_files, is it single image, list image, or zip/rar
+    if isinstance(input_files, str) and input_files.lower().endswith(('.zip', '.rar')):
+        return process_images(input_files, bg_method, watermark_path, output_format, bg_choice, custom_color, num_workers, progress)
+    elif isinstance(input_files, list):
+        return process_images(input_files, bg_method, watermark_path, output_format, bg_choice, custom_color, num_workers, progress)
     else:
-        return process_images(input_files, crop_mode, bg_method, watermark_path, output_format, bg_choice, custom_color, num_workers, progress)
+        return process_images(input_files.name, bg_method, watermark_path, output_format, bg_choice, custom_color, num_workers, progress)
 
 def show_color_picker(bg_choice):
     if bg_choice == 'custom':
         return gr.update(visible=True)
     return gr.update(visible=False)
 
-def update_slider(evt: gr.SelectData):
+def update_compare(evt: gr.SelectData):
     if isinstance(evt.value, dict) and 'caption' in evt.value:
         input_path = evt.value['caption']
         output_path = evt.value['image']['path']
@@ -250,31 +462,20 @@ def update_slider(evt: gr.SelectData):
         print("No caption found in selection")
         return gr.update(value=None), gr.update(value=None), gr.update(value=None), gr.update(value=None)
 
-def process(input_type, input_files, crop_mode, bg_method, watermark, output_format, bg_choice, custom_color, num_workers):
-    _, processed_images, zip_path, time_taken = gradio_interface(input_type, input_files, crop_mode, bg_method, watermark, output_format, bg_choice, custom_color, num_workers)
+def process(input_files, bg_method, watermark, output_format, bg_choice, custom_color, num_workers):
+    _, processed_images, zip_path, time_taken = gradio_interface(input_files, bg_method, watermark, output_format, bg_choice, custom_color, num_workers)
     processed_images_with_captions = [(img, f"Input: {caption}") for img, caption in processed_images]
     return processed_images_with_captions, zip_path, f"{time_taken:.2f} seconds"
 
-def update_input_type(choice):
-    if choice == "zip_rar":
-        return gr.update(visible=True), gr.update(visible=False)
-    else:
-        return gr.update(visible=False), gr.update(visible=True)
-
 with gr.Blocks() as iface:
     gr.Markdown("# Image Background Removal and Resizing with Optional Watermark")
     gr.Markdown("Choose to upload multiple images or a ZIP/RAR file, select the crop mode, optionally upload a watermark image, and choose the output format.")
-
-    input_type = gr.Radio(choices=["multiple_images", "zip_rar"], label="Input Type", value="multiple_images")
     
     with gr.Row():
-        zip_file = gr.File(label="Upload ZIP/RAR file of images", file_types=[".zip", ".rar"], visible=False)
-        multiple_images = gr.File(label="Upload multiple images", file_types=["image"], file_count="multiple")
-    
-    watermark = gr.File(label="Upload Watermark Image (Optional)", file_types=[".png"])
+        input_files = gr.File(label="Upload Image or ZIP/RAR file", file_types=[".zip", ".rar", "image"], interactive=True)
+        watermark = gr.File(label="Upload Watermark Image (Optional)", file_types=[".png"])
     
     with gr.Row():
-        crop_mode = gr.Radio(choices=["center", "top", "bottom", "left", "right"], label="Crop Mode", value="center")
         output_format = gr.Radio(choices=["PNG", "JPG"], label="Output Format", value="JPG")
         num_workers = gr.Slider(minimum=1, maximum=16, step=1, label="Number of Workers", value=5)
 
@@ -283,6 +484,8 @@ with gr.Blocks() as iface:
         bg_choice = gr.Radio(choices=["transparent", "white", "custom"], label="Background Choice", value="white")
         custom_color = gr.ColorPicker(label="Custom Background Color", value="#ffffff", visible=False)
 
+    process_button = gr.Button("Process Images")
+
     with gr.Row():
         gallery_processed = gr.Gallery(label="Processed Images")
     with gr.Row():
@@ -295,13 +498,8 @@ with gr.Blocks() as iface:
         output_zip = gr.File(label="Download Processed Images as ZIP")
         processing_time = gr.Textbox(label="Processing Time (seconds)")
 
-    input_type.change(update_input_type, inputs=input_type, outputs=[zip_file, multiple_images])
-
     bg_choice.change(show_color_picker, inputs=bg_choice, outputs=custom_color)
-
-    process_button = gr.Button("Process Images")
-    process_button.click(process, inputs=[input_type, multiple_images, crop_mode, bg_method, watermark, output_format, bg_choice, custom_color, num_workers], outputs=[gallery_processed, output_zip, processing_time])
-
-    gallery_processed.select(update_slider, outputs=[image_original, image_processed, original_ratio, processed_ratio])
+    process_button.click(process, inputs=[input_files, bg_method, watermark, output_format, bg_choice, custom_color, num_workers], outputs=[gallery_processed, output_zip, processing_time])
+    gallery_processed.select(update_compare, outputs=[image_original, image_processed, original_ratio, processed_ratio])
 
 iface.launch()

pixel_border.py

@@ -1,50 +0,0 @@
-import os
-import shutil
-from PIL import Image
-
-def colors_within_tolerance(color1, color2, tolerance):
-    return all(abs(c1 - c2) <= tolerance for c1, c2 in zip(color1, color2))
-
-def check_border_colors(image_path, tolerance):
-    # Open the image
-    image = Image.open(image_path)
-    pixels = image.load()
-    
-    width, height = image.size
-
-    # Get the color of the first pixel on the left and right borders
-    left_border_color = pixels[0, 0]
-    right_border_color = pixels[width - 1, 0]
-
-    # Check the left border
-    for y in range(height):
-        if not colors_within_tolerance(pixels[0, y], left_border_color, tolerance):
-            return False
-    
-    # Check the right border
-    for y in range(height):
-        if not colors_within_tolerance(pixels[width - 1, y], right_border_color, tolerance):
-            return False
-
-    return True
-
-def process_images(input_folder, output_folder_same, output_folder_different, tolerance):
-    # Ensure output directories exist
-    os.makedirs(output_folder_same, exist_ok=True)
-    os.makedirs(output_folder_different, exist_ok=True)
-
-    for filename in os.listdir(input_folder):
-        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif')):
-            image_path = os.path.join(input_folder, filename)
-            if check_border_colors(image_path, tolerance):
-                shutil.copy(image_path, os.path.join(output_folder_same, filename))
-            else:
-                shutil.copy(image_path, os.path.join(output_folder_different, filename))
-
-# Example usage
-input_folder = 'D:\Ardha\Kerja\AISensum\ROX\Input\Task 1'
-output_folder_same = 'D:\Ardha\Kerja\AISensum\ROX\Input\Task 1\warna_sama'
-output_folder_different = 'D:\Ardha\Kerja\AISensum\ROX\Input\Task 1\warna_berbeda'
-tolerance = 50  # Adjust the tolerance value as needed
-
-process_images(input_folder, output_folder_same, output_folder_different, tolerance)

slider.py

@@ -1,24 +0,0 @@
-import gradio as gr
-from gradio_imageslider import ImageSlider
-
-def compare_images(img1, img2):
-    if not img1 or not img2:
-        return None
-    return (img1, img2)
-
-with gr.Blocks() as demo:
-    with gr.Group():
-        with gr.Row():
-            image_input1 = gr.Image(label="Upload Image 1", type="pil")
-            image_input2 = gr.Image(label="Upload Image 2", type="pil")
-        
-        slider = ImageSlider(label="Compare Images", type="pil", slider_color="pink", width=600)
-    
-    def update_slider(img1, img2):
-        return gr.update(value=(img1, img2))
-    
-    image_input1.change(update_slider, inputs=[image_input1, image_input2], outputs=slider)
-    image_input2.change(update_slider, inputs=[image_input1, image_input2], outputs=slider)
-
-if __name__ == "__main__":
-    demo.launch()

test.py

@@ -1,43 +0,0 @@
-from PIL import Image
-
-def remove_blank_zone(image_path, output_path):
-    image = Image.open(image_path)
-    image = image.convert("RGBA")
-    
-    # Get the bounding box of the non-blank area
-    bbox = image.getbbox()
-    
-    if bbox:
-        # Crop the image to the bounding box
-        image = image.crop(bbox)
-        
-        # Calculate the new size to expand the image until one side touches the padding
-        padding = 125
-        target_size = 1080 - 2 * padding
-        aspect_ratio = image.width / image.height
-        
-        if image.width > image.height:
-            new_width = target_size
-            new_height = int(target_size / aspect_ratio)
-        else:
-            new_height = target_size
-            new_width = int(target_size * aspect_ratio)
-        
-        # Resize the image
-        image = image.resize((new_width, new_height), Image.LANCZOS)
-        
-        # Create a new 1080x1080 canvas with a white background
-        canvas = Image.new("RGBA", (1080, 1080), (255, 255, 255, 255))
-        
-        # Calculate the position to paste the resized image onto the canvas
-        x = (1080 - new_width) // 2
-        y = (1080 - new_height) // 2
-        
-        # Paste the resized image onto the canvas
-        canvas.paste(image, (x, y), image)
-        
-        # Save the final image
-        canvas.save(output_path)
-
-# Example usage
-remove_blank_zone("stample.png", "output.png")

test_bbox.py

@@ -0,0 +1,28 @@
+from PIL import Image, ImageDraw
+
+def draw_bounding_box(input_path, output_path):
+    # Open the image and convert to RGBA
+    image = Image.open(input_path).convert("RGBA")
+    
+    # Get the bounding box of the non-blank area
+    bbox = image.getbbox()
+    
+    if bbox:
+        # Create a copy of the image to draw on
+        draw_image = image.copy()
+        draw = ImageDraw.Draw(draw_image)
+        
+        # Draw the bounding box
+        draw.rectangle(bbox, outline="red", width=3)
+        
+        # Save the image with the bounding box
+        draw_image.save(output_path)
+        print(f"Processed image: Bounding box {bbox}")
+    else:
+        print("No non-blank area found in the image")
+
+# Example usage
+input_image = "bria_output/1000416735_02.png"
+output_image = "bbox_image.png"
+draw_bounding_box(input_image, output_image)
+

test_bbox_thres.py

@@ -0,0 +1,45 @@
+from PIL import Image, ImageDraw
+
+def draw_bounding_box_with_threshold(input_path, output_path, threshold=0):
+    # Open the image and convert to RGBA
+    image = Image.open(input_path).convert("RGBA")
+    
+    # Get the bounding box of the non-blank area with threshold
+    bbox = get_bounding_box_with_threshold(image, threshold)
+    
+    if bbox:
+        # Create a copy of the image to draw on
+        draw_image = image.copy()
+        draw = ImageDraw.Draw(draw_image)
+        
+        # Draw the bounding box
+        draw.rectangle(bbox, outline="red", width=3)
+        
+        # Save the image with the bounding box
+        draw_image.save(output_path)
+        print(f"Processed image: Bounding box {bbox}")
+    else:
+        print("No non-blank area found in the image")
+
+def get_bounding_box_with_threshold(image, threshold):
+    width, height = image.size
+    left, top, right, bottom = width, height, 0, 0
+
+    for y in range(height):
+        for x in range(width):
+            r, g, b, a = image.getpixel((x, y))
+            if a > threshold:
+                left = min(left, x)
+                top = min(top, y)
+                right = max(right, x)
+                bottom = max(bottom, y)
+
+    if left < right and top < bottom:
+        return (left, top, right, bottom)
+    else:
+        return None
+
+# Example usage
+input_image = "bria_output/1000485417_03.png"
+output_image = "bbox_image_thres.png"
+draw_bounding_box_with_threshold(input_image, output_image, threshold=10)

test_bria.py

@@ -0,0 +1,23 @@
+import os
+from transformers import pipeline
+
+def remove_background_with_bria(input_folder, output_folder):
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    pipe = pipeline("image-segmentation", model="briaai/RMBG-1.4", trust_remote_code=True)
+
+    for filename in os.listdir(input_folder):
+        if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp')):
+            input_path = os.path.join(input_folder, filename)
+            output_path = os.path.join(output_folder, os.path.splitext(filename)[0] + '.png')
+            
+            # Use pipeline to remove the background
+            pillow_image = pipe(input_path) # applies mask on input and returns a pillow image
+            pillow_image.save(output_path, format="PNG")
+            
+            # Print the filename of the processed image
+            print(f"Processed {filename}")
+
+# Example usage
+remove_background_with_bria("D:\Ardha\Kerja\AISensum\ROX\Task 1.2\Raw_PSD", "bria_output")

test_logic.py

@@ -0,0 +1,308 @@
+import os
+import json
+from PIL import Image, ImageDraw
+import concurrent.futures
+import numpy as np
+
+def remove_blank_zone(input_folder, output_folder):
+    if not os.path.exists(output_folder):
+        os.makedirs(output_folder)
+
+    log = []
+    try:
+        with concurrent.futures.ThreadPoolExecutor(max_workers=5) as executor:
+            futures = []
+            for filename in os.listdir(input_folder):
+                if filename.lower().endswith(('.png', '.jpg', '.jpeg', '.gif', '.bmp')):
+                    input_path = os.path.join(input_folder, filename)
+                    output_path = os.path.join(output_folder, filename)
+                    future = executor.submit(process_image, input_path, output_path)
+                    futures.append((filename, future))
+
+            for filename, future in futures:
+                image_log = future.result()
+                log.append({
+                    "image": filename,
+                    "actions": image_log
+                })
+
+        with open(os.path.join(output_folder, 'process_log.json'), 'w') as log_file:
+            json.dump(log, log_file, indent=4)
+        print("Log saved to", os.path.join(output_folder, 'process_log.json'))
+    except Exception as e:
+        print("Error:", e)
+
+def get_bounding_box_with_threshold(image, threshold):
+    # Convert image to numpy array
+    img_array = np.array(image)
+    
+    # Get alpha channel
+    alpha = img_array[:,:,3]
+    
+    # Find rows and columns where alpha > threshold
+    rows = np.any(alpha > threshold, axis=1)
+    cols = np.any(alpha > threshold, axis=0)
+    
+    # Find the bounding box
+    top, bottom = np.where(rows)[0][[0, -1]]
+    left, right = np.where(cols)[0][[0, -1]]
+    
+    if left < right and top < bottom:
+        return (left, top, right, bottom)
+    else:
+        return None
+
+def process_image(image_path, output_path, add_padding_line=False, use_threshold=True):
+    image = Image.open(image_path)
+    image = image.convert("RGBA")
+    
+    # Get the bounding box of the non-blank area with threshold
+    if use_threshold:
+        bbox = get_bounding_box_with_threshold(image, threshold=10)
+    else:
+        bbox = image.getbbox()
+    log = []
+
+    if bbox:
+        # Check 1 pixel around the image for non-transparent pixels
+        width, height = image.size
+        cropped_sides = []
+        
+        # Define tolerance for transparency
+        tolerance = 10  # Adjust this value as needed
+        
+        # Check top edge
+        if any(image.getpixel((x, 0))[3] > tolerance for x in range(width)):
+            cropped_sides.append("top")
+        
+        # Check bottom edge
+        if any(image.getpixel((x, height-1))[3] > tolerance for x in range(width)):
+            cropped_sides.append("bottom")
+        
+        # Check left edge
+        if any(image.getpixel((0, y))[3] > tolerance for y in range(height)):
+            cropped_sides.append("left")
+        
+        # Check right edge
+        if any(image.getpixel((width-1, y))[3] > tolerance for y in range(height)):
+            cropped_sides.append("right")
+        
+        if cropped_sides:
+            info_message = f"Info for {os.path.basename(image_path)}: The following sides of the image may contain cropped objects: {', '.join(cropped_sides)}"
+            print(info_message)
+            log.append({"info": info_message})
+        else:
+            info_message = f"Info for {os.path.basename(image_path)}: The image is not cropped."
+            print(info_message)
+            log.append({"info": info_message})
+        
+        # Crop the image to the bounding box
+        image = image.crop(bbox)
+        log.append({"action": "crop", "bbox": [str(bbox[0]), str(bbox[1]), str(bbox[2]), str(bbox[3])]})
+        
+        # Calculate the new size to expand the image
+        padding = 125
+        target_size = 1080
+        aspect_ratio = image.width / image.height
+        
+        if len(cropped_sides) == 4:
+            # If the image is cropped on all sides, center crop it to fit the canvas
+            if aspect_ratio > 1:  # Landscape
+                new_height = target_size
+                new_width = int(new_height * aspect_ratio)
+                left = (new_width - target_size) // 2
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                image = image.crop((left, 0, left + target_size, target_size))
+            else:  # Portrait or square
+                new_width = target_size
+                new_height = int(new_width / aspect_ratio)
+                top = (new_height - target_size) // 2
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                image = image.crop((0, top, target_size, top + target_size))
+            log.append({"action": "center_crop_resize", "new_size": f"{target_size}x{target_size}"})
+            x, y = 0, 0
+        elif not cropped_sides:
+            # If the image is not cropped, expand it from center until it touches the padding
+            new_height = 1080 - 2 * padding  # Ensure it touches top and bottom padding
+            new_width = int(new_height * aspect_ratio)
+            
+            if new_width > 1080 - 2 * padding:
+                # If width exceeds available space, adjust based on width
+                new_width = 1080 - 2 * padding
+                new_height = int(new_width / aspect_ratio)
+            
+            # Resize the image
+            image = image.resize((new_width, new_height), Image.LANCZOS)
+            log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+            
+            x = (1080 - new_width) // 2
+            y = 1080 - new_height - padding
+        else:
+            # New logic for handling cropped top and left, or top and right
+            if set(cropped_sides) == {"top", "left"} or set(cropped_sides) == {"top", "right"}:
+                new_height = target_size - padding  # Ensure bottom padding
+                new_width = int(new_height * aspect_ratio)
+                
+                # If new width exceeds canvas width, adjust based on width
+                if new_width > target_size:
+                    new_width = target_size
+                    new_height = int(new_width / aspect_ratio)
+                
+                # Resize the image
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+                
+                # Set position
+                if "left" in cropped_sides:
+                    x = 0
+                else:  # right in cropped_sides
+                    x = target_size - new_width
+                y = 0
+                
+                # If the resized image is taller than the canvas minus padding, crop from the bottom
+                if new_height > target_size - padding:
+                    crop_bottom = new_height - (target_size - padding)
+                    image = image.crop((0, 0, new_width, new_height - crop_bottom))
+                    new_height = target_size - padding
+                    log.append({"action": "crop_vertical", "bottom_pixels_removed": str(crop_bottom)})
+                
+                log.append({"action": "position", "x": str(x), "y": str(y)})
+            elif set(cropped_sides) == {"bottom", "left", "right"}:
+                # Expand the image from the center
+                new_width = target_size
+                new_height = int(new_width / aspect_ratio)
+                
+                if new_height < target_size:
+                    new_height = target_size
+                    new_width = int(new_height * aspect_ratio)
+                
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                
+                # Crop to fit the canvas
+                left = (new_width - target_size) // 2
+                top = 0
+                image = image.crop((left, top, left + target_size, top + target_size))
+                
+                log.append({"action": "expand_and_crop", "new_size": f"{target_size}x{target_size}"})
+                x, y = 0, 0
+            elif cropped_sides == ["top"]:
+                # New logic for handling only top-cropped images
+                if image.width > image.height:
+                    new_width = target_size
+                    new_height = int(target_size / aspect_ratio)
+                else:
+                    new_height = target_size - padding  # Ensure bottom padding
+                    new_width = int(new_height * aspect_ratio)
+                
+                # Resize the image
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+                
+                x = (1080 - new_width) // 2
+                y = 0  # Align to top
+                
+                # Apply padding only to non-cropped sides
+                x = max(padding, min(x, 1080 - new_width - padding))
+            elif cropped_sides in [["right"], ["left"]]:
+                # New logic for handling only right-cropped or left-cropped images
+                if image.width > image.height:
+                    new_width = target_size - padding  # Ensure padding on non-cropped side
+                    new_height = int(new_width / aspect_ratio)
+                else:
+                    new_height = target_size - padding  # Ensure bottom padding
+                    new_width = int(new_height * aspect_ratio)
+                
+                # Resize the image
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+                
+                if cropped_sides == ["right"]:
+                    x = 1080 - new_width  # Align to right
+                else:  # cropped_sides == ["left"]
+                    x = 0  # Align to left without padding
+                y = 1080 - new_height - padding  # Respect bottom padding
+            elif set(cropped_sides) == {"left", "right"}:
+                # Logic for handling images cropped on both left and right sides
+                new_width = 1080  # Expand to full width of canvas
+                
+                # Calculate the aspect ratio of the original image
+                aspect_ratio = image.width / image.height
+                
+                # Calculate the new height while maintaining aspect ratio
+                new_height = int(new_width / aspect_ratio)
+                
+                # Resize the image
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+                
+                # Set horizontal position (always 0 as it spans full width)
+                x = 0
+                
+                # Calculate vertical position to respect bottom padding
+                y = 1080 - new_height - padding
+                
+                # If the resized image is taller than the canvas, crop from the top only
+                if new_height > 1080 - padding:
+                    crop_top = new_height - (1080 - padding)
+                    image = image.crop((0, crop_top, new_width, new_height))
+                    new_height = 1080 - padding
+                    y = 0
+                    log.append({"action": "crop_vertical", "top_pixels_removed": str(crop_top)})
+                else:
+                    # Align the image to the bottom with padding
+                    y = 1080 - new_height - padding
+                
+                log.append({"action": "position", "x": str(x), "y": str(y)})
+            else:
+                # Use the original resizing logic for other partially cropped images
+                if image.width > image.height:
+                    new_width = target_size
+                    new_height = int(target_size / aspect_ratio)
+                else:
+                    new_height = target_size
+                    new_width = int(target_size * aspect_ratio)
+                
+                # Resize the image
+                image = image.resize((new_width, new_height), Image.LANCZOS)
+                log.append({"action": "resize", "new_width": str(new_width), "new_height": str(new_height)})
+                
+                # Center horizontally for all images
+                x = (1080 - new_width) // 2
+                y = 1080 - new_height - padding
+                
+                # Adjust positions for cropped sides
+                if "top" in cropped_sides:
+                    y = 0
+                elif "bottom" in cropped_sides:
+                    y = 1080 - new_height
+                if "left" in cropped_sides:
+                    x = 0
+                elif "right" in cropped_sides:
+                    x = 1080 - new_width
+                
+                # Apply padding only to non-cropped sides, but keep horizontal centering
+                if "left" not in cropped_sides and "right" not in cropped_sides:
+                    x = (1080 - new_width) // 2  # Always center horizontally
+                if "top" not in cropped_sides and "bottom" not in cropped_sides:
+                    y = max(padding, min(y, 1080 - new_height - padding))
+        # Create a new 1080x1080 canvas with a white background
+        canvas = Image.new("RGBA", (1080, 1080), (255, 255, 255, 255))
+        
+        # Paste the resized image onto the canvas
+        canvas.paste(image, (x, y), image)
+        log.append({"action": "paste", "position": [str(x), str(y)]})
+        
+        # Add visible black line for padding (for all images)
+        if add_padding_line:
+            draw = ImageDraw.Draw(canvas)
+            draw.rectangle([padding, padding, 1080 - padding, 1080 - padding], outline="black", width=5)
+            log.append({"action": "add_padding_line"})
+        
+        # Save the final image
+        canvas.save(output_path)
+        log.append({"action": "save", "output_path": output_path})
+
+    return log
+
+# Example usage
+remove_blank_zone("bria_output", "test_output")