Update compression method and add support for HEIF/HEIC inputs.

README.md

@@ -11,4 +11,4 @@ license: apache-2.0
 short_description: A lightweight lossless image compressor.
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This app is a lightweight lossless image compressor written in Gradio and Python. It uses Pillow (and pillow-heif to support HEIC/HEIF inputs) to compress the image by altering the PNG compression level.

app.py

@@ -1,94 +1,101 @@
 import gradio as gr
 from PIL import Image
-import tempfile
+import pillow_heif
 import os
+import shutil
 
-def compress_image(input_image):
-    """
-    Compresses a PIL image object into a lossless WebP format
-    and returns the file path.
-    """
-    if input_image is None:
-        raise gr.Error("No image uploaded. Please upload an image to compress.")
+# 1. Register HEIF opener with Pillow so it can handle .heic/.heif files
+pillow_heif.register_heif_opener()
+
+def format_bytes(size):
+    # Helper to make file sizes readable
+    power = 2**10
+    n = 0
+    power_labels = {0 : '', 1: 'KB', 2: 'MB', 3: 'GB', 4: 'TB'}
+    while size > power:
+        size /= power
+        n += 1
+    return f"{size:.2f} {power_labels[n]}"
+
+def compress_image(image_path):
+    if image_path is None:
+        return None, "No image uploaded."
 
     try:
-        # Create a temporary file to store the compressed image.
-        # We use delete=False so that Gradio can access the file
-        # after this function returns. Gradio will handle cleanup.
-        with tempfile.NamedTemporaryFile(suffix=".webp", delete=False) as temp_file:
-            
-            # Save the image using Pillow in lossless WebP format
-            # quality=100 is often recommended with lossless=True
-            input_image.save(temp_file.name, format="WEBP", lossless=True, quality=100)
+        # Get original file info
+        original_size = os.path.getsize(image_path)
+        filename = os.path.basename(image_path)
+        name_without_ext = os.path.splitext(filename)[0]
+        
+        # Define output path
+        output_filename = f"{name_without_ext}_compressed.png"
+        output_path = os.path.join(os.path.dirname(image_path), output_filename)
+
+        # Open the image
+        # pillow-heif handles the HEIC/HEIF format automatically here
+        with Image.open(image_path) as img:
             
-            output_filepath = temp_file.name
+            # Create a copy of the image to remove specific metadata that might 
+            # conflict with saving (though we keep pixel data lossless)
+            # We convert to RGBA if it supports transparency, or RGB otherwise
+            if img.mode in ('RGBA', 'LA') or (img.mode == 'P' and 'transparency' in img.info):
+                img = img.convert('RGBA')
+            else:
+                img = img.convert('RGB')
+
+            # SAVE AS PNG
+            # compress_level=9 is maximum compression (slowest, smallest size)
+            # optimize=True performs additional passes to reduce size
+            img.save(output_path, "PNG", compress_level=9, optimize=True)
+
+        # Get new file info
+        new_size = os.path.getsize(output_path)
         
-        # Get file sizes for comparison
-        # We need to get the size of the original PIL image.
-        # This is a bit tricky, so we'll just show the output size.
-        # A more complex app might take a file path input to compare.
-        output_size = os.path.getsize(output_filepath)
+        # Calculate stats
+        diff = new_size - original_size
+        status = "Reduced" if diff < 0 else "Increased"
+        percent = (abs(diff) / original_size) * 100
         
-        print(f"Image saved to: {output_filepath}")
-        print(f"Compressed file size: {output_size / 1024:.2f} KB")
+        info_text = (
+            f"Original Size: {format_bytes(original_size)}\n"
+            f"Compressed Size: {format_bytes(new_size)}\n"
+            f"Difference: {status} by {format_bytes(abs(diff))} ({percent:.1f}%)\n\n"
+            f"Note: Converting JPEGs/HEICs (lossy) to PNG (lossless) may increase file size "
+            f"because PNG preserves the exact pixel data without compression artifacts."
+        )
 
-        # Return the file path to the gr.File component
-        return output_filepath
+        return output_path, info_text
 
     except Exception as e:
-        print(f"Error compressing image: {e}")
-        raise gr.Error(f"Failed to compress image: {str(e)}")
-
-# --- Gradio App Interface ---
+        return None, f"Error processing image: {str(e)}"
 
-# Use gr.Blocks for a more custom layout
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+# 2. Create the Gradio Interface
+with gr.Blocks(title="Lossless PNG Compressor") as app:
+    gr.Markdown("## 🗜️ Lossless Image Compressor (Max PNG Level)")
     gr.Markdown(
-        """
-        # Lossless Image Compressor
-        Upload any image (PNG, JPG, BMP, etc.) to convert it into a **Lossless WebP** file.
-        This modern format significantly reduces file size without *any* loss in image quality.
-        """
+        "Upload any image (JPG, PNG, HEIC, WEBP). It will be converted to **PNG** "
+        "saved at **Compression Level 9** (Maximum). \n\n"
+        "*Note: This preserves pixel quality perfectly. However, converting a lossy photo (JPG/HEIC) "
+        "to lossless PNG often results in a larger file size.*"
     )
-    
-    with gr.Row(equal_height=True):
-        with gr.Column(scale=1):
-            image_input = gr.Image(
-                type="pil", 
-                label="Upload Your Image",
-                sources=["upload", "clipboard"]
-            )
-            compress_button = gr.Button("Compress Image", variant="primary")
+
+    with gr.Row():
+        with gr.Column():
+            # Input: Expects a file path
+            image_input = gr.Image(type="filepath", label="Upload Image")
+            submit_btn = gr.Button("Compress / Convert", variant="primary")
         
-        with gr.Column(scale=1):
-            file_output = gr.File(
-                label="Download Compressed WebP File",
-                interactive=False # User cannot upload to this component
-            )
-            
-    gr.Markdown("---")
-    gr.Markdown("### Examples")
-    
-    # Add examples for users to try
-    gr.Examples(
-        examples=[
-            # Using placeholder images as examples
-            "https://placehold.co/800x600/png?text=Sample+PNG+Image",
-            "https://placehold.co/800x600/jpg?text=Sample+JPG+Image",
-        ],
-        inputs=image_input,
-        outputs=file_output,
-        fn=compress_image,
-        cache_examples=True # Speeds up example loading
-    )
+        with gr.Column():
+            # Output: Returns a downloadable file and text stats
+            file_output = gr.File(label="Download PNG")
+            stats_output = gr.Textbox(label="Compression Stats")
 
-    # Connect the button to the function
-    compress_button.click(
-        fn=compress_image,
-        inputs=image_input,
-        outputs=file_output,
-        api_name="compress"
+    # Bind function
+    submit_btn.click(
+        fn=compress_image, 
+        inputs=image_input, 
+        outputs=[file_output, stats_output]
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    app.launch()

requirements.txt

@@ -1,2 +1,3 @@
 gradio
-pillow
+pillow
+pillow-heif