download in multiple file formats

gradio_imager.py

@@ -2,7 +2,8 @@ import gradio as gr
 from PIL import Image
 import tempfile
 import os
-from image_processor import process_image
+from image_processor import process_image, save_image_with_format
+import io
 
 
 def apply_standard_settings(setting):
@@ -15,12 +16,12 @@ def apply_standard_settings(setting):
         "M dark": (True, True, "480x480", 96, "#2A373D"),
         "L dark": (True, True, "960x960", 128, "#2A373D"),
     }
-    # Default to no special settings
     return settings_dict.get(setting, (None, None, None, None, None))
 
 
-def settings_description(crop, remove_bg, resize, padding, background):
-    """Generate an HTML text description of the current settings in a smaller font and list format."""
+# Update settings description for simpler UI
+def settings_description(crop, remove_bg, resize, padding, background, quality):
+    """Generate an HTML text description of the current settings."""
     description = f"""
     <ul style="font-size:small;">
         <li>Crop: {crop}</li>
@@ -28,79 +29,219 @@ def settings_description(crop, remove_bg, resize, padding, background):
         <li>Resize: {resize if resize else 'No resize'}</li>
         <li>Padding: {padding}</li>
         <li>Background: {background}</li>
+        <li>Quality: {quality}%</li>
     </ul>
     """
     return description
 
 
-def gradio_interface(image, standard_settings, crop=False, remove_bg=False, resize=None, padding=0, background="white"):
-    # Apply standard settings if selected and not "None"
+
+def get_image_info(image):
+    """Get image dimensions and file size in a formatted string."""
+    import os
+    import io
+    
+    if image is None:
+        return ""
+    
+    # Extract original filename
+    original_name = "image"  # Default fallback
+    if isinstance(image, dict):  # Check if image is a dictionary (Gradio type='file')
+        if 'name' in image:
+            original_name = os.path.splitext(os.path.basename(image['name']))[0]
+        image = image.get('image')  # Extract actual image object
+    elif hasattr(image, 'filename') and image.filename:  # Check for filename attribute
+        original_name = os.path.splitext(os.path.basename(image.filename))[0]
+    
+    # Validate the image object
+    if not hasattr(image, 'size'):
+        return f"<p>Invalid image object provided.</p>"
+    
+    # Get image dimensions
+    width, height = image.size
+
+    # Calculate file size
+    buffer = io.BytesIO()
+    image.save(buffer, format='PNG')
+    size_bytes = buffer.tell()
+    size_kb = size_bytes / 1024
+
+    return f"""<div style="text-align: left; padding: 5px;">
+        <p>Original Name: {original_name}</p>
+        <p>Size: {width}x{height}px ({size_kb:.1f} KB)</p>
+    </div>"""
+
+
+def get_formatted_filename(original_name, width, height, format):
+    """Generate formatted filename with size."""
+    # Remove extension from original name
+    base_name = os.path.splitext(os.path.basename(original_name))[0]
+    return f"{base_name}_{width}x{height}.{format}"
+
+
+
+def gradio_interface(image, standard_settings, crop=False, remove_bg=False, 
+                   resize=None, padding=0, background="white", 
+                   quality=90):
+    """Main interface function for the Gradio app."""
+    quality = int(quality)
+
     if image is None:
-        # Load the standard image from the specified path if no image is uploaded
         standard_image_path = './data/examples/supermario.png'
         image = Image.open(standard_image_path)
 
-    if standard_settings and standard_settings != "None":
-        crop, remove_bg, resize, padding, background = apply_standard_settings(
-            standard_settings)
+    # Get original filename without extension
+    if isinstance(image, dict) and 'name' in image:  # Check if image contains metadata
+        original_name = os.path.splitext(image['name'])[0]
+    elif hasattr(image, 'filename') and image.filename:
+        original_name = os.path.splitext(os.path.basename(image.filename))[0]
+    else:
+        original_name = "image"  # Default name if no filename available
 
-    # Generate settings description
-    applied_settings = settings_description(
-        crop, remove_bg, resize, padding, background)
+    print(f"Debug - Image info: {type(image)}")  # Debug line
+    if isinstance(image, dict):
+        print(f"Debug - Image dict: {image.keys()}")  # Debug line
+
+    if standard_settings and standard_settings != "None":
+        crop, remove_bg, resize, padding, background = apply_standard_settings(standard_settings)
 
-    # Convert resize string to tuple (if provided)
     resize_dimensions = None
     if resize:
         try:
             width, height = map(int, resize.split('x'))
             resize_dimensions = (width, height)
         except ValueError:
-            return "Invalid format for resize dimensions. Please use 'WxH'.", "original", applied_settings
-    # Process the image directly
+            return None, None, None, None, "Invalid format for resize dimensions. Please use 'WxH'."
+
+    # Process the image
     processed_image = process_image(
-        image, crop, remove_bg, resize_dimensions, padding, background)
+        image, 
+        crop=crop, 
+        remove_bg=remove_bg, 
+        resize=resize_dimensions, 
+        padding=padding, 
+        background=background
+    )
+
+    # Get temp directory for saving files
+    temp_dir = tempfile.gettempdir()
+
+    # Save in multiple formats
+    downloads = {}
+    # Save WebP
+    downloads['webp'] = save_image_with_format(
+        processed_image,
+        os.path.join(temp_dir, 'temp'),
+        format='webp',
+        quality=quality,
+        custom_filename=original_name
+    )
+
+    # Save PNG
+    downloads['png'] = save_image_with_format(
+        processed_image,
+        os.path.join(temp_dir, 'temp'),
+        format='png',
+        custom_filename=original_name
+    )
+
+    # Save JPG
+    downloads['jpg'] = save_image_with_format(
+        processed_image,
+        os.path.join(temp_dir, 'temp'),
+        format='jpg',
+        quality=quality,
+        custom_filename=original_name
+    )
 
     # Generate settings description
     applied_settings = settings_description(
-        crop, remove_bg, resize, padding, background)
+        crop, remove_bg, resize, padding, background, quality
+    )
 
-    return processed_image, applied_settings
+    return (processed_image, 
+            downloads['webp'], 
+            downloads['png'], 
+            downloads['jpg'], 
+            applied_settings)
 
 
+# Define example images first (update to remove output_format parameter)
 example_images = [
     [os.path.join("data", "examples", "supermario.png"),
-     "S light", True, True, "480x420", 10, "whitesmoke"],
+     "S light", True, True, "480x420", 10, "whitesmoke", 90],
     [os.path.join("data", "examples",
-                  "depositphotos_520707962-stock-photo-fujifilm-s10-body-black-fujifilm.jpg"), "None", True, True, "480x320", 48, "blue"],
+                  "depositphotos_520707962-stock-photo-fujifilm-s10-body-black-fujifilm.jpg"),
+     "None", True, True, "480x320", 48, "blue", 90],
     [os.path.join("data", "examples", "batman_b_c_320x280_bg.png"),
-     "None", True, True, "360x360", 48, "yellow"],
+     "None", True, True, "360x360", 48, "yellow", 90],
+]
 
 
-]
+with gr.Blocks(title="IMAGER ___ Image Processor") as interface:
+    gr.Markdown("Upload an image and select processing options or choose a standard setting. Supports crop, autoremove background, resize, add padding, and set the background color. Download in multiple formats.")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            # Input column
+            input_image = gr.Image(type="pil", label="Input Image")
+            input_info = gr.HTML(label="Input Image Information")  # For showing input image info
+            
+            # Update image info when image changes
+            input_image.change(
+                fn=get_image_info,
+                inputs=[input_image],
+                outputs=[input_info]
+            )
+            
+            settings = gr.Radio(
+                choices=["None", "S light", "M light", "L light", "S dark", "M dark", "L dark"],
+                label="Settings",
+                value="None"
+            )
+            crop = gr.Checkbox(label="Crop")
+            remove_bg = gr.Checkbox(label="Remove Background")
+            resize = gr.Textbox(label="Resize (WxH)", placeholder="Example: 100x100")
+            padding = gr.Slider(minimum=0, maximum=200, label="Padding")
+            background = gr.Textbox(label="Background", placeholder="Color name or hex code")
+            quality = gr.Slider(
+                minimum=1,
+                maximum=95,
+                value=85,
+                step=1,
+                label="Image Quality %"
+            )
+
+        with gr.Column(scale=1):
+            # Output column
+            output_image = gr.Image(type="pil", label="Preview")
+            webp_download = gr.File(label="Download WebP")
+            png_download = gr.File(label="Download PNG")
+            jpg_download = gr.File(label="Download JPG")
+            settings_info = gr.HTML(label="Applied Settings")
+
+    # Process button
+    process_btn = gr.Button("Process Image")
+    process_btn.click(
+        fn=gradio_interface,
+        inputs=[
+            input_image, settings, crop, remove_bg, resize, 
+            padding, background, quality
+        ],
+        outputs=[
+            output_image, webp_download, png_download, jpg_download, settings_info
+        ]
+    )
+
+    # Examples
+    gr.Examples(
+        examples=example_images,
+        inputs=[
+            input_image, settings, crop, remove_bg, resize, 
+            padding, background, quality
+        ]
+    )
 
-# Define the Gradio interface
-interface = gr.Interface(fn=gradio_interface,
-                         inputs=[
-                             gr.components.Image(
-                                 type="pil", label="Input Image"),
-                             gr.components.Radio(choices=[
-                                                 "None", "S light", "M light", "L light", "S dark", "M dark", "L dark"], label="Settings"),
-                             gr.components.Checkbox(label="Crop"),
-                             gr.components.Checkbox(label="Remove Background"),
-                             gr.components.Textbox(
-                                 label="Resize (WxH)", placeholder="Example: 100x100"),
-                             gr.components.Slider(
-                                 minimum=0, maximum=200, label="Padding"),
-                             gr.components.Textbox(
-                                 label="Background", placeholder="Color name or hex code")
-                         ],
-                         outputs=[
-                             gr.components.Image(type="pil"),
-                             gr.components.HTML(label="Applied Settings")
-                         ],
-                         examples=example_images,
-                         title="IMAGER ___ Image Processor",
-                         description="Upload an image and select processing options or choose a standard setting. Supports crop, autoremove background, resize, add padding, and set the background color.",)
 
 if __name__ == "__main__":
-    interface.launch()
+    interface.launch()

image_processor.py

@@ -84,7 +84,37 @@ def remove_bg_func(image):
     return result_image
 
 
-def process_image(image_data, crop=False, remove_bg=False, resize=None, padding=0, background=None):
+# Update the process_image function to include format selection
+def process_image(img, crop=False, remove_bg=False, resize=None, padding=0, background=None, output_format='webp'):
+    """
+    Processes a single image with the specified options and format.
+    
+    Args:
+    - img: Input image
+    - crop: Whether to autocrop
+    - remove_bg: Whether to remove background
+    - resize: Tuple of (width, height) for resizing
+    - padding: Padding to add
+    - background: Background color or image
+    - output_format: 'webp', 'png', or 'png-transparent'
+    """
+    # Existing processing code remains the same
+    if remove_bg:
+        img = remove_bg_func(img)
+    
+    if crop:
+        img = autocrop_image(img)
+        
+    if resize:
+        img = resize_and_pad_image(img, resize, padding)
+        
+    if background and output_format != 'png-transparent':
+        img = add_background(img, background)
+    
+    return img
+
+
+def process_image2(image_data, crop=False, remove_bg=False, resize=None, padding=0, background=None):
     """
     Processes a single image based on the provided options.
 
@@ -289,3 +319,143 @@ def process_images(input_dir="./input", output_dir="./output", crop=False, remov
             print(f"Error processing image {input_path}: {e}")
 
     print("All images have been processed.")
+
+
+
+def save_image_with_format(image, output_path, format='webp', quality=90, custom_filename=None):
+    """
+    Saves the image in the specified format with appropriate settings.
+    
+    Args:
+    - image (PIL.Image.Image): The image to save
+    - output_path (str): Base path for the output file (without extension)
+    - format (str): 'webp', 'png', 'png-transparent', or 'jpg'
+    - quality (int): Quality setting for compression (1-100)
+    - custom_filename (str): Optional custom filename for the output
+    """
+    # Get image dimensions for filename
+    width, height = image.size
+    
+    # Generate filename with schema: originalname_size.type
+    if custom_filename:
+        base_dir = os.path.dirname(output_path)
+        filename = f"{custom_filename}_{width}x{height}"
+        final_path = os.path.join(base_dir, filename)
+    else:
+        final_path = output_path
+
+    if format == 'webp':
+        final_path = f"{final_path}.webp"
+        image.save(final_path, 'webp', quality=quality)
+    elif format == 'png-transparent':
+        final_path = f"{final_path}.png"
+        image.save(final_path, 'PNG', optimize=True)
+    elif format == 'png':
+        final_path = f"{final_path}.png"
+        if image.mode in ('RGBA', 'LA'):
+            background = Image.new('RGB', image.size, 'white')
+            background.paste(image, mask=image.split()[-1])
+            background.save(final_path, 'PNG', optimize=True)
+        else:
+            image.save(final_path, 'PNG', optimize=True)
+    elif format == 'jpg':
+        final_path = f"{final_path}.jpg"
+        if image.mode in ('RGBA', 'LA'):
+            background = Image.new('RGB', image.size, 'white')
+            background.paste(image, mask=image.split()[-1])
+            background.save(final_path, 'JPEG', quality=quality, optimize=True)
+        else:
+            image.convert('RGB').save(final_path, 'JPEG', quality=quality, optimize=True)
+    else:
+        raise ValueError(f"Unsupported format: {format}")
+    
+    return final_path
+
+    """
+    Saves the image in the specified format with appropriate settings.
+    
+    Args:
+    - image (PIL.Image.Image): The image to save
+    - output_path (str): Base path for the output file (without extension)
+    - format (str): 'webp', 'png', 'png-transparent', or 'jpg'
+    - quality (int): Quality setting for compression (1-100)
+    - custom_filename (str): Optional custom filename for the output
+    """
+    # Get image dimensions for filename
+    width, height = image.size
+    
+    # Generate the complete filename with path
+    if custom_filename:
+        base_dir = os.path.dirname(output_path)
+        final_path = os.path.join(base_dir, f"{custom_filename}_{width}x{height}")
+    else:
+        final_path = output_path
+
+    if format == 'webp':
+        final_path = f"{final_path}.webp"
+        image.save(final_path, 'webp', quality=quality)
+    elif format == 'png-transparent':
+        final_path = f"{final_path}.png"
+        image.save(final_path, 'PNG', optimize=True)
+    elif format == 'png':
+        final_path = f"{final_path}.png"
+        if image.mode in ('RGBA', 'LA'):
+            background = Image.new('RGB', image.size, 'white')
+            background.paste(image, mask=image.split()[-1])
+            background.save(final_path, 'PNG', optimize=True)
+        else:
+            image.save(final_path, 'PNG', optimize=True)
+    elif format == 'jpg':
+        final_path = f"{final_path}.jpg"
+        if image.mode in ('RGBA', 'LA'):
+            background = Image.new('RGB', image.size, 'white')
+            background.paste(image, mask=image.split()[-1])
+            background.save(final_path, 'JPEG', quality=quality, optimize=True)
+        else:
+            image.convert('RGB').save(final_path, 'JPEG', quality=quality, optimize=True)
+    else:
+        raise ValueError(f"Unsupported format: {format}")
+    
+    return final_path
+
+    """
+    Saves the image in the specified format with appropriate settings.
+    
+    Args:
+    - image (PIL.Image.Image): The image to save
+    - output_path (str): Base path for the output file (without extension)
+    - format (str): 'webp', 'png', 'png-transparent', or 'jpg'
+    - quality (int): Quality setting for compression (1-100)
+    """
+    if format == 'webp':
+        # Save as WebP with specified quality
+        final_path = f"{output_path}.webp"
+        image.save(final_path, 'webp', quality=quality)
+    elif format == 'png-transparent':
+        # Save as PNG with transparency
+        final_path = f"{output_path}.png"
+        image.save(final_path, 'PNG', optimize=True)
+    elif format == 'png':
+        # Save as PNG without transparency, with white background
+        final_path = f"{output_path}.png"
+        if image.mode in ('RGBA', 'LA'):
+            background = Image.new('RGB', image.size, 'white')
+            background.paste(image, mask=image.split()[-1])
+            background.save(final_path, 'PNG', optimize=True)
+        else:
+            image.save(final_path, 'PNG', optimize=True)
+    elif format == 'jpg':
+        # Save as JPG with white background
+        final_path = f"{output_path}.jpg"
+        if image.mode in ('RGBA', 'LA'):
+            # Convert transparent background to white for JPG
+            background = Image.new('RGB', image.size, 'white')
+            background.paste(image, mask=image.split()[-1])
+            background.save(final_path, 'JPEG', quality=quality, optimize=True)
+        else:
+            # Save directly if no transparency
+            image.convert('RGB').save(final_path, 'JPEG', quality=quality, optimize=True)
+    else:
+        raise ValueError(f"Unsupported format: {format}")
+    
+    return final_path