update ui

Task1-2.zip

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

app-v1.py

@@ -0,0 +1,307 @@
+import os
+import zipfile
+import shutil
+import time
+from PIL import Image
+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
+
+def remove_background_rembg(input_path):
+    print(f"Removing background using rembg for image: {input_path}")
+    with open(input_path, 'rb') as i:
+        input_image = i.read()
+    output_image = remove(input_image)
+    img = Image.open(io.BytesIO(output_image)).convert("RGBA")
+    return img
+
+def remove_background_bria(input_path):
+    print(f"Removing background using bria for image: {input_path}")
+    pipe = pipeline("image-segmentation", model="briaai/RMBG-1.4", trust_remote_code=True, device=0)
+    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):
+    filename = os.path.basename(image_path)
+    try:
+        print(f"Processing image: {filename}")
+        if bg_method == 'rembg':
+            image_with_no_bg = remove_background_rembg(image_path)
+        elif bg_method == 'bria':
+            image_with_no_bg = remove_background_bria(image_path)
+            
+        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)
+
+        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)
+        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)
+
+        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')
+        else:
+            new_image.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)
+            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')
+            else:
+                new_image_with_watermark.save(output_path_with_watermark, format='PNG')
+            images_paths.append((output_path_with_watermark, image_path))
+
+        os.remove(temp_image_path)
+
+        print(f"Processed image paths: {images_paths}")
+        return images_paths
+
+    except Exception as e:
+        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()):
+    start_time = time.time()
+    
+    output_folder = "temp_output"
+    if os.path.exists(output_folder):
+        shutil.rmtree(output_folder)
+    os.makedirs(output_folder)
+    
+    processed_images = []
+    original_images = []
+    
+    if isinstance(input_files, str) and input_files.lower().endswith(('.zip', '.rar')):
+        input_folder = "temp_input"
+        if os.path.exists(input_folder):
+            shutil.rmtree(input_folder)
+        os.makedirs(input_folder)
+        
+        try:
+            with zipfile.ZipFile(input_files, 'r') as zip_ref:
+                zip_ref.extractall(input_folder)
+        except zipfile.BadZipFile as e:
+            print(f"Error extracting zip file: {e}")
+            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'))]
+    else:
+        image_files = [f.name for f in 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}
+        for idx, future in enumerate(future_to_image):
+            try:
+                start_time_image = time.time()
+                result = future.result()
+                end_time_image = time.time()
+                image_processing_time = end_time_image - start_time_image
+                
+                # Update average processing time
+                avg_processing_time = (avg_processing_time * idx + image_processing_time) / (idx + 1)
+                
+                if result:
+                    processed_images.extend(result)
+                    original_images.append(future_to_image[future])
+                
+                # Estimate remaining time
+                remaining_images = total_images - (idx + 1)
+                estimated_remaining_time = remaining_images * avg_processing_time
+                
+                progress((idx + 1) / total_images, f"{idx + 1}/{total_images} images processed. Estimated time remaining: {estimated_remaining_time:.2f} seconds")
+            except Exception as e:
+                print(f"Error processing image {future_to_image[future]}: {e}")
+
+    output_zip_path = "processed_images.zip"
+    with zipfile.ZipFile(output_zip_path, 'w') as zipf:
+        for file, _ in processed_images:
+            if "with_watermark" in file:
+                zipf.write(file, os.path.join("with_watermark", os.path.basename(file)))
+            else:
+                zipf.write(file, os.path.join("without_watermark", os.path.basename(file)))
+
+    end_time = time.time()
+    processing_time = end_time - start_time
+    print(f"Processing time: {processing_time} seconds")
+    
+    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):
+    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)
+    else:
+        return process_images(input_files, crop_mode, 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):
+    if isinstance(evt.value, dict) and 'caption' in evt.value:
+        input_path = evt.value['caption']
+        output_path = evt.value['image']['path']
+        input_path = input_path.split("Input: ")[-1]
+        
+        # Open the original and processed images
+        original_img = Image.open(input_path)
+        processed_img = Image.open(output_path)
+        
+        # Calculate the aspect ratios
+        original_ratio = f"{original_img.width}x{original_img.height}"
+        processed_ratio = f"{processed_img.width}x{processed_img.height}"
+        
+        return gr.update(value=input_path), gr.update(value=output_path), gr.update(value=original_ratio), gr.update(value=processed_ratio)
+    else:
+        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)
+    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"])
+    
+    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)
+
+    with gr.Row():
+        bg_method = gr.Radio(choices=["bria", "rembg"], label="Background Removal Method", value="bria")
+        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)
+
+    with gr.Row():
+        gallery_processed = gr.Gallery(label="Processed Images")
+    with gr.Row():
+        image_original = gr.Image(label="Original Images", interactive=False)
+        image_processed = gr.Image(label="Processed Images", interactive=False)
+    with gr.Row():
+        original_ratio = gr.Textbox(label="Original Ratio")
+        processed_ratio = gr.Textbox(label="Processed Ratio")
+    with gr.Row():
+        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])
+
+iface.launch()

app.py

@@ -75,7 +75,7 @@ def remove_background_rembg(input_path):
 
 def remove_background_bria(input_path):
     print(f"Removing background using bria for image: {input_path}")
-    pipe = pipeline("image-segmentation", model="briaai/RMBG-1.4", trust_remote_code=True)
+    pipe = pipeline("image-segmentation", model="briaai/RMBG-1.4", trust_remote_code=True, device=0)
     pillow_image = pipe(input_path)
     return pillow_image
 
@@ -125,7 +125,7 @@ def process_single_image(image_path, output_folder, crop_mode, bg_method, output
             new_image.convert('RGB').save(output_path_without_watermark, format='JPEG')
         else:
             new_image.save(output_path_without_watermark, format='PNG')
-        images_paths.append(output_path_without_watermark)
+        images_paths.append((output_path_without_watermark, image_path))
 
         if watermark_path:
             watermark = Image.open(watermark_path).convert("RGBA")
@@ -136,7 +136,7 @@ def process_single_image(image_path, output_folder, crop_mode, bg_method, output
                 new_image_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)
+            images_paths.append((output_path_with_watermark, image_path))
 
         os.remove(temp_image_path)
 
@@ -147,46 +147,65 @@ def process_single_image(image_path, output_folder, crop_mode, bg_method, output
         print(f"Error processing {filename}: {e}")
         return None
 
-def process_images(zip_file, 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, crop_mode='center', 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()
     
-    input_folder = "temp_input"
     output_folder = "temp_output"
-    if os.path.exists(input_folder):
-        shutil.rmtree(input_folder)
     if os.path.exists(output_folder):
         shutil.rmtree(output_folder)
-    os.makedirs(input_folder)
     os.makedirs(output_folder)
     
-    try:
-        with zipfile.ZipFile(zip_file, 'r') as zip_ref:
-            zip_ref.extractall(input_folder)
-    except zipfile.BadZipFile as e:
-        print(f"Error extracting zip file: {e}")
-        return [], None, 0
-    
     processed_images = []
     original_images = []
-    image_files = [os.path.join(input_folder, f) for f in os.listdir(input_folder) if f.lower().endswith(('.png', '.jpg', '.jpeg', '.bmp', '.gif'))]
+    
+    if isinstance(input_files, str) and input_files.lower().endswith(('.zip', '.rar')):
+        input_folder = "temp_input"
+        if os.path.exists(input_folder):
+            shutil.rmtree(input_folder)
+        os.makedirs(input_folder)
+        
+        try:
+            with zipfile.ZipFile(input_files, 'r') as zip_ref:
+                zip_ref.extractall(input_folder)
+        except zipfile.BadZipFile as e:
+            print(f"Error extracting zip file: {e}")
+            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'))]
+    else:
+        image_files = [f.name for f in 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}
         for idx, future in enumerate(future_to_image):
             try:
+                start_time_image = time.time()
                 result = future.result()
+                end_time_image = time.time()
+                image_processing_time = end_time_image - start_time_image
+                
+                # Update average processing time
+                avg_processing_time = (avg_processing_time * idx + image_processing_time) / (idx + 1)
+                
                 if result:
                     processed_images.extend(result)
                     original_images.append(future_to_image[future])
+                
+                # Estimate remaining time
+                remaining_images = total_images - (idx + 1)
+                estimated_remaining_time = remaining_images * avg_processing_time
+                
+                progress((idx + 1) / total_images, f"{idx + 1}/{total_images} images processed. Estimated time remaining: {estimated_remaining_time:.2f} seconds")
             except Exception as e:
                 print(f"Error processing image {future_to_image[future]}: {e}")
-            progress((idx + 1) / total_images, f"{idx + 1}/{total_images} images processed")
 
     output_zip_path = "processed_images.zip"
     with zipfile.ZipFile(output_zip_path, 'w') as zipf:
-        for file in processed_images:
+        for file, _ in processed_images:
             if "with_watermark" in file:
                 zipf.write(file, os.path.join("with_watermark", os.path.basename(file)))
             else:
@@ -198,48 +217,91 @@ def process_images(zip_file, crop_mode='center', bg_method='rembg', watermark_pa
     
     return original_images, processed_images, output_zip_path, processing_time
 
-def gradio_interface(zip_file, crop_mode, bg_method, watermark, output_format, bg_choice, custom_color, num_workers):
+def gradio_interface(input_type, input_files, crop_mode, bg_method, watermark, output_format, bg_choice, custom_color, num_workers):
     progress = gr.Progress()
     watermark_path = watermark.name if watermark else None
-    return process_images(zip_file.name, crop_mode, bg_method, watermark_path, output_format, bg_choice, custom_color, num_workers, progress)
+    
+    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)
+    else:
+        return process_images(input_files, crop_mode, 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):
+    if isinstance(evt.value, dict) and 'caption' in evt.value:
+        input_path = evt.value['caption']
+        output_path = evt.value['image']['path']
+        input_path = input_path.split("Input: ")[-1]
+        
+        # Open the original and processed images
+        original_img = Image.open(input_path)
+        processed_img = Image.open(output_path)
+        
+        # Calculate the aspect ratios
+        original_ratio = f"{original_img.width}x{original_img.height}"
+        processed_ratio = f"{processed_img.width}x{processed_img.height}"
+        
+        return gr.update(value=input_path), gr.update(value=output_path), gr.update(value=original_ratio), gr.update(value=processed_ratio)
+    else:
+        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)
+    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("Upload a ZIP or RAR file containing images, choose the crop mode, optionally upload a watermark image, and select the output format.")
+    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"])
-        watermark = gr.File(label="Upload Watermark Image (Optional)", file_types=[".png"])
+        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"])
     
     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="PNG")
-        num_workers = gr.Slider(minimum=1, maximum=16, step=1, label="Number of Workers", value=2)
+        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)
 
     with gr.Row():
         bg_method = gr.Radio(choices=["bria", "rembg"], label="Background Removal Method", value="bria")
-        bg_choice = gr.Radio(choices=["transparent", "white", "custom"], label="Background Choice", value="transparent")
+        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)
 
     with gr.Row():
-        gallery_original = gr.Gallery(label="Original Images")
         gallery_processed = gr.Gallery(label="Processed Images")
+    with gr.Row():
+        image_original = gr.Image(label="Original Images", interactive=False)
+        image_processed = gr.Image(label="Processed Images", interactive=False)
+    with gr.Row():
+        original_ratio = gr.Textbox(label="Original Ratio")
+        processed_ratio = gr.Textbox(label="Processed Ratio")
     with gr.Row():
         output_zip = gr.File(label="Download Processed Images as ZIP")
         processing_time = gr.Textbox(label="Processing Time (seconds)")
 
-    bg_choice.change(show_color_picker, inputs=bg_choice, outputs=custom_color)
+    input_type.change(update_input_type, inputs=input_type, outputs=[zip_file, multiple_images])
 
-    def process(zip_file, crop_mode, bg_method, watermark, output_format, bg_choice, custom_color, num_workers):
-        original_images, processed_images, zip_path, time_taken = gradio_interface(zip_file, crop_mode, bg_method, watermark, output_format, bg_choice, custom_color, num_workers)
-        return original_images, processed_images, zip_path, f"{time_taken:.2f} seconds"
+    bg_choice.change(show_color_picker, inputs=bg_choice, outputs=custom_color)
 
     process_button = gr.Button("Process Images")
-    process_button.click(process, inputs=[zip_file, crop_mode, bg_method, watermark, output_format, bg_choice, custom_color, num_workers], outputs=[gallery_original, gallery_processed, output_zip, processing_time])
+    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])
 
 iface.launch()

image_filenames.py

@@ -0,0 +1,27 @@
+import os
+import glob
+
+def get_image_filenames(folder_path, output_file):
+    # Define the image file extensions you want to include
+    image_extensions = ['*.jpg', '*.jpeg', '*.png', '*.gif', '*.bmp', '*.tiff']
+
+    # Create an empty list to store filenames
+    image_filenames = []
+
+    # Iterate over each extension and gather the filenames
+    for extension in image_extensions:
+        image_filenames.extend(glob.glob(os.path.join(folder_path, extension)))
+
+    # Write the filenames to the output file
+    with open(output_file, 'w') as file:
+        for filename in image_filenames:
+            file.write(os.path.basename(filename) + '\n')
+
+# Specify the folder containing images and the output text file
+folder_path = 'D:\Ardha\Kerja\AISensum\ROX\Input\Task 1'
+output_file = 'image_filenames.txt'
+
+# Call the function to get image filenames and save them to a text file
+get_image_filenames(folder_path, output_file)
+
+print(f"Image filenames have been saved to {output_file}")

image_filenames.txt

@@ -0,0 +1,120 @@
+1000416735_01.jpg
+1000416735_02.jpg
+1000416735_03.jpg
+1000416735_04.jpg
+1000448771_01.jpg
+1000448771_02.jpg
+1000448771_03.jpg
+1000485022_01.jpg
+1000485022_02.jpg
+1000485022_03.jpg
+1000485026_01.jpg
+1000485026_02.jpg
+1000485030_01.jpg
+1000485030_02.jpg
+1000485030_03.jpg
+1000485035_01.jpg
+1000485035_02.jpg
+1000485035_03.jpg
+1000485063_01.jpg
+1000485063_02.jpg
+1000485063_03.jpg
+1000485080_01.jpg
+1000485080_02.jpg
+1000485080_03.jpg
+1000485080_04.jpg
+1000485101_01.jpg
+1000485101_02.jpg
+1000485101_03.jpg
+1000485101_04.jpg
+1000485116_01.jpg
+1000485116_02.jpg
+1000485116_03.jpg
+1000485116_04.jpg
+1000485119_01.jpg
+1000485119_02.jpg
+1000485119_03.jpg
+1000485119_04.jpg
+1000485122_01.jpg
+1000485122_02.jpg
+1000485122_03.jpg
+1000485125_01.jpg
+1000485125_02.jpg
+1000485125_03.jpg
+1000485125_04.jpg
+1000485159_01.jpg
+1000485159_02.jpg
+1000485159_03.jpg
+1000485159_04.jpg
+1000485162_01.jpg
+1000485162_02.jpg
+1000485162_03.jpg
+1000485162_04.jpg
+1000485165_01.jpg
+1000485165_02.jpg
+1000485165_03.jpg
+1000485168_01.jpg
+1000485168_02.jpg
+1000485168_03.jpg
+1000485171_01.jpg
+1000485171_02.jpg
+1000485171_03.jpg
+1000485383_01.jpg
+1000485383_02.jpg
+1000485383_03.jpg
+1000485417_01.jpg
+1000485417_02.jpg
+1000485417_03.jpg
+1000485428_01.jpg
+1000485428_02.jpg
+1000485428_03.jpg
+1000485521_01.jpg
+1000485521_02.jpg
+1000485521_03.jpg
+1000485531_01.jpg
+1000485531_02.jpg
+1000485531_03.jpg
+1000485551_01.jpg
+1000485551_02.jpg
+1000485551_03.jpg
+1000485665_01.jpg
+1000485665_02.jpg
+1000485665_03.jpg
+1000485665_04.jpg
+1000485737_01.jpg
+1000485737_02.jpg
+1000485737_03.jpg
+1000485764_01.jpg
+1000485764_02.jpg
+1000485764_03.jpg
+1000485780_01.jpg
+1000485780_02.jpg
+1000485780_03.jpg
+1000485788_01.jpg
+1000485788_02.jpg
+1000485788_03.jpg
+1000485791_01.jpg
+1000485791_02.jpg
+1000485791_03.jpg
+1000485791_04.jpg
+1000485795_01.jpg
+1000485795_02.jpg
+1000485795_03.jpg
+1000485795_04.jpg
+1000485799_01.jpg
+1000485799_02.jpg
+1000485799_03.jpg
+1000485799_04.jpg
+1000485799_05.jpg
+1000485831_01.jpg
+1000485831_02.jpg
+1000485831_03.jpg
+1000485831_04.jpg
+1000485834_01.jpg
+1000485834_02.jpg
+1000485834_03.jpg
+1000485834_04.jpg
+1000485834_05.jpg
+1000485842_01.jpg
+1000485842_02.jpg
+1000485842_03.jpg

pixel_border.py

@@ -42,9 +42,9 @@ def process_images(input_folder, output_folder_same, output_folder_different, to
                 shutil.copy(image_path, os.path.join(output_folder_different, filename))
 
 # Example usage
-input_folder = 'D:\Ardha\Kerja\AISensum\ROX\Task 1'
-output_folder_same = 'D:\Ardha\Kerja\AISensum\ROX\Task 1\warna_sama'
-output_folder_different = 'D:\Ardha\Kerja\AISensum\ROX\Task 1\warna_berbeda'
+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)

requirements.txt

@@ -7,4 +7,5 @@ numpy==1.26.4
 typing==3.7.4.3
 scikit-image==0.24.0
 huggingface_hub==0.23.4
-transformers==4.42.4
+transformers==4.42.4
+gradio_imageslider==0.0.20

slider.py

@@ -0,0 +1,24 @@
+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

@@ -0,0 +1,43 @@
+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")