Upload 2 files

app.py

@@ -0,0 +1,268 @@
+import gradio as gr
+import tempfile
+import os
+from pathlib import Path
+import zipfile
+import time
+from PIL import Image
+import numpy as np
+
+from utils.compressor import ImageCompressor
+from utils.ai_analyzer import ContentAnalyzer
+from utils.advanced import AdvancedFeatures
+
+# Initialize components
+compressor = ImageCompressor()
+analyzer = ContentAnalyzer()
+advanced = AdvancedFeatures()
+
+def compress_single_image(file, preset="auto", target_size=None):
+    """Compress a single image"""
+    if file is None:
+        return None, "No file uploaded", None
+    
+    try:
+        input_path = Path(file.name)
+        
+        # Apply preset
+        if preset == "auto":
+            # Let AI decide
+            content_type, strategy = analyzer.analyze(input_path)
+            method = strategy.get("method", "avif")
+            quality = strategy.get("quality", 75)
+        elif preset == "extreme":
+            method = "avif"
+            quality = 60
+        elif preset == "high_quality":
+            method = "avif"
+            quality = 90
+        elif preset == "web_optimized":
+            method = "webp"
+            quality = 80
+        elif preset == "lossless":
+            method = "webp_lossless"
+            quality = 100
+        else:
+            method = "avif"
+            quality = 75
+        
+        # Create output path
+        output_path = input_path.parent / f"compressed_{input_path.stem}"
+        
+        # Compress
+        start_time = time.time()
+        result_path, ratio = compressor.compress(
+            input_path, 
+            output_path, 
+            method=method,
+            quality=quality
+        )
+        compression_time = time.time() - start_time
+        
+        # Calculate metrics
+        original_size = input_path.stat().st_size / 1024  # KB
+        compressed_size = Path(result_path).stat().st_size / 1024
+        
+        # Calculate SSIM if both images exist
+        ssim_score = None
+        try:
+            ssim_score = advanced.calculate_ssim(input_path, result_path)
+        except:
+            pass
+        
+        info = f"""
+        ✅ Compression Complete!
+        
+        Original: {original_size:.1f} KB
+        Compressed: {compressed_size:.1f} KB
+        Saved: {ratio:.1f}%
+        Time: {compression_time:.2f}s
+        Method: {method}
+        Quality: {quality}
+        """
+        
+        if ssim_score:
+            info += f"\nSSIM Score: {ssim_score:.3f} (1.0 = identical)"
+        
+        return result_path, info, None
+        
+    except Exception as e:
+        return None, f"❌ Error: {str(e)}", None
+
+def compress_batch(files, preset="auto"):
+    """Compress multiple images and return ZIP"""
+    if not files:
+        return None, "No files uploaded"
+    
+    temp_dir = tempfile.mkdtemp()
+    compressed_files = []
+    total_saved = 0
+    
+    for file in files:
+        try:
+            input_path = Path(file.name)
+            output_path = Path(temp_dir) / f"compressed_{input_path.name}"
+            
+            _, ratio = compressor.compress(input_path, output_path, method="auto")
+            compressed_files.append(output_path)
+            total_saved += ratio
+            
+        except Exception as e:
+            print(f"Error compressing {file.name}: {e}")
+    
+    # Create ZIP
+    zip_path = Path(temp_dir) / "compressed_images.zip"
+    with zipfile.ZipFile(zip_path, 'w') as zipf:
+        for cf in compressed_files:
+            zipf.write(cf, cf.name)
+    
+    info = f"Compressed {len(compressed_files)} files\nAverage saving: {total_saved/len(compressed_files):.1f}%"
+    
+    return zip_path, info
+
+def compare_images(original, compressed):
+    """Create side-by-side comparison with slider"""
+    if original is None or compressed is None:
+        return None
+    
+    # Load images
+    orig_img = Image.open(original)
+    comp_img = Image.open(compressed)
+    
+    # Resize to same height for comparison
+    target_height = 400
+    ratio = target_height / orig_img.size[1]
+    new_width = int(orig_img.size[0] * ratio)
+    orig_img = orig_img.resize((new_width, target_height), Image.Resampling.LANCZOS)
+    comp_img = comp_img.resize((new_width, target_height), Image.Resampling.LANCZOS)
+    
+    # Create comparison image (side by side)
+    total_width = new_width * 2
+    comparison = Image.new('RGB', (total_width, target_height))
+    comparison.paste(orig_img, (0, 0))
+    comparison.paste(comp_img, (new_width, 0))
+    
+    return comparison
+
+# Create Gradio interface
+with gr.Blocks(title="AI Image Compressor", theme=gr.themes.Soft()) as demo:
+    gr.Markdown("""
+    # 🚀 AI-Powered Image Compressor
+    ### Better than imagecompressor.com - with AI analysis, AVIF support, and quality guarantees
+    
+    **Features:**
+    - 🤖 AI automatically detects image type (photo, screenshot, graphic)
+    - 📦 AVIF support (30% smaller than WebP)
+    - 📊 SSIM quality validation
+    - 🎯 Target file size optimization
+    - 🔄 Batch processing with ZIP download
+    - 💯 Lossless compression option
+    """)
+    
+    with gr.Tabs():
+        with gr.TabItem("📸 Single Image"):
+            with gr.Row():
+                with gr.Column():
+                    input_image = gr.File(label="Upload Image", file_types=["image"])
+                    preset = gr.Radio(
+                        choices=["auto", "extreme", "high_quality", "web_optimized", "lossless"],
+                        value="auto",
+                        label="Compression Preset",
+                        info="auto = AI chooses best method"
+                    )
+                    compress_btn = gr.Button("Compress!", variant="primary")
+                
+                with gr.Column():
+                    output_image = gr.File(label="Download Compressed Image")
+                    info_text = gr.Textbox(label="Compression Info", lines=8)
+            
+            with gr.Row():
+                compare_btn = gr.Button("Compare Original vs Compressed")
+                comparison = gr.Image(label="Side-by-Side Comparison")
+        
+        with gr.TabItem("📦 Batch Processing"):
+            batch_files = gr.File(label="Upload Multiple Images", file_types=["image"], file_count="multiple")
+            batch_preset = gr.Radio(
+                choices=["auto", "extreme", "high_quality", "web_optimized"],
+                value="auto",
+                label="Compression Preset"
+            )
+            batch_btn = gr.Button("Compress All", variant="primary")
+            batch_output = gr.File(label="Download ZIP with Compressed Images")
+            batch_info = gr.Textbox(label="Batch Info", lines=5)
+        
+        with gr.TabItem("📊 Quality Analysis"):
+            quality_img = gr.File(label="Upload Image", file_types=["image"])
+            analyze_btn = gr.Button("Analyze Image")
+            analysis_result = gr.JSON(label="Content Analysis")
+            ssim_result = gr.Textbox(label="Quality Metrics")
+    
+    # Connect functions
+    compress_btn.click(
+        compress_single_image,
+        inputs=[input_image, preset],
+        outputs=[output_image, info_text, comparison]
+    )
+    
+    compare_btn.click(
+        compare_images,
+        inputs=[input_image, output_image],
+        outputs=[comparison]
+    )
+    
+    batch_btn.click(
+        compress_batch,
+        inputs=[batch_files, batch_preset],
+        outputs=[batch_output, batch_info]
+    )
+    
+    def analyze_image(file):
+        if file is None:
+            return {"error": "No file"}, "No file uploaded"
+        
+        content_type, strategy = analyzer.analyze(Path(file.name))
+        
+        # Calculate additional metrics
+        img = Image.open(file.name)
+        width, height = img.size
+        format = img.format
+        mode = img.mode
+        
+        analysis = {
+            "Content Type": content_type,
+            "Recommended Strategy": strategy,
+            "Image Details": {
+                "Dimensions": f"{width}x{height}",
+                "Format": format,
+                "Color Mode": mode,
+                "Megapixels": f"{width*height/1e6:.2f} MP"
+            }
+        }
+        
+        # Estimate potential savings
+        if content_type == "screenshot_or_text":
+            savings = "80-95% with lossless WebP"
+        elif content_type == "graphic":
+            savings = "70-90% with PNG quantization"
+        else:
+            savings = "60-85% with AVIF"
+        
+        quality_text = f"""
+        📊 Analysis Complete
+        
+        Estimated Savings: {savings}
+        Best Format: {strategy.get('method', 'AVIF').upper()}
+        Recommended Quality: {strategy.get('quality', 75)}
+        """
+        
+        return analysis, quality_text
+    
+    analyze_btn.click(
+        analyze_image,
+        inputs=[quality_img],
+        outputs=[analysis_result, ssim_result]
+    )
+
+# Launch
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,12 @@
+gradio==4.16.0
+pillow
+opencv-python-headless==4.8.1.78
+numpy==1.24.3
+torch==2.1.0
+torchvision==0.16.0
+imageio==2.31.6
+imageio-ffmpeg==0.4.9
+scikit-image==0.22.0
+piexif==1.1.3
+pillow-heif==0.13.0
+cairosvg==2.7.0