Update app.py

app.py

@@ -1,30 +1,29 @@
 import gradio as gr
 import spaces
-from PIL import Image, ImageEnhance, ImageFilter
+from PIL import Image, ImageEnhance
 import numpy as np
 import logging
 import cv2
 from rembg import remove
-import io
 
 # Setup logging
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger(__name__)
 
-logger.info("🚀 Initializing Mirro Virtual Try-On Server...")
+logger.info("🚀 Mirro Virtual Try-On Server Starting...")
 
 def create_clothing_mask(image):
     """Create mask for upper body clothing area"""
     width, height = image.size
     mask = np.zeros((height, width), dtype=np.uint8)
     
-    # Define upper body region
+    # Upper body region
     y_start = int(height * 0.15)
     y_end = int(height * 0.70)
     x_start = int(width * 0.20)
     x_end = int(width * 0.80)
     
-    # Create elliptical mask for more natural look
+    # Elliptical mask
     center_x = (x_start + x_end) // 2
     center_y = (y_start + y_end) // 2
     radius_x = (x_end - x_start) // 2
@@ -41,22 +40,19 @@ def create_clothing_mask(image):
 
 def enhance_image(image):
     """Enhance image quality"""
-    # Increase sharpness
     enhancer = ImageEnhance.Sharpness(image)
     image = enhancer.enhance(1.3)
     
-    # Increase contrast slightly
     enhancer = ImageEnhance.Contrast(image)
     image = enhancer.enhance(1.1)
     
-    # Increase color saturation
     enhancer = ImageEnhance.Color(image)
     image = enhancer.enhance(1.1)
     
     return image
 
 def remove_garment_background(garment_img):
-    """Remove background from garment image"""
+    """Remove background from garment"""
     try:
         logger.info("Removing garment background...")
         output = remove(garment_img)
@@ -66,16 +62,13 @@ def remove_garment_background(garment_img):
         return garment_img
 
 def blend_images(person_img, garment_img, mask):
-    """Blend garment onto person with smooth transitions"""
-    # Convert to numpy arrays
+    """Blend garment onto person"""
     person_array = np.array(person_img).astype(float)
     garment_array = np.array(garment_img).astype(float)
     mask_array = np.array(mask).astype(float) / 255.0
     
-    # Expand mask to RGB
     mask_3ch = np.stack([mask_array] * 3, axis=2)
     
-    # Blend
     blended = (garment_array * mask_3ch + person_array * (1 - mask_3ch))
     
     return Image.fromarray(blended.astype(np.uint8))
@@ -86,14 +79,11 @@ def match_colors(person_img, garment_img, mask):
     garment_array = np.array(garment_img)
     mask_array = np.array(mask) / 255.0
     
-    # Calculate average color in non-masked region of person
     person_sample = person_array * (1 - mask_array[:, :, np.newaxis])
     person_mean = np.mean(person_sample[person_sample > 0])
     
-    # Calculate average color of garment
     garment_mean = np.mean(garment_array)
     
-    # Adjust garment brightness to match person
     if garment_mean > 0:
         adjustment = person_mean / garment_mean
         garment_adjusted = np.clip(garment_array * adjustment, 0, 255).astype(np.uint8)
@@ -103,58 +93,44 @@ def match_colors(person_img, garment_img, mask):
 
 @spaces.GPU(duration=60)
 def virtual_tryon(person_image, garment_image, progress=gr.Progress()):
-    """
-    Virtual try-on function
-    """
+    """Virtual try-on function"""
     try:
-        # Validation
         if person_image is None:
             raise gr.Error("❌ Please upload a person's photo!")
         
         if garment_image is None:
             raise gr.Error("❌ Please upload a garment photo!")
         
-        logger.info("=" * 50)
-        logger.info("🎯 Starting Virtual Try-On Process")
-        logger.info(f"Person: {person_image.size}, Garment: {garment_image.size}")
+        logger.info("🎯 Starting Virtual Try-On")
         
-        # Step 1: Preprocess
-        progress(0.1, desc="📸 Preprocessing images...")
+        progress(0.1, desc="📸 Preprocessing...")
         person_img = person_image.convert("RGB")
         garment_img = garment_image.convert("RGB")
         
-        # Resize to standard size
         target_size = (512, 768)
         person_img = person_img.resize(target_size, Image.Resampling.LANCZOS)
         garment_img = garment_img.resize(target_size, Image.Resampling.LANCZOS)
         
-        # Step 2: Remove garment background
         progress(0.3, desc="🎨 Processing garment...")
         garment_nobg = remove_garment_background(garment_img)
         
-        # Step 3: Enhance garment
-        progress(0.4, desc="✨ Enhancing garment...")
+        progress(0.4, desc="✨ Enhancing...")
         garment_enhanced = enhance_image(garment_nobg)
         
-        # Step 4: Create mask
-        progress(0.5, desc="🎯 Creating clothing mask...")
+        progress(0.5, desc="🎯 Creating mask...")
         mask = create_clothing_mask(person_img)
         
-        # Step 5: Match colors
         progress(0.6, desc="🎨 Matching colors...")
         garment_matched = match_colors(person_img, garment_enhanced, mask)
         
-        # Step 6: Blend
-        progress(0.8, desc="✨ Applying garment...")
+        progress(0.8, desc="✨ Blending...")
         result = blend_images(person_img, garment_matched, mask)
         
-        # Step 7: Final enhancement
         progress(0.9, desc="🎨 Final touches...")
         result = enhance_image(result)
         
         progress(1.0, desc="✅ Complete!")
-        logger.info("✅ Virtual try-on completed successfully!")
-        logger.info("=" * 50)
+        logger.info("✅ Try-on completed!")
         
         return result
         
@@ -162,293 +138,94 @@ def virtual_tryon(person_image, garment_image, progress=gr.Progress()):
         logger.error(f"❌ Error: {str(e)}")
         import traceback
         traceback.print_exc()
-        raise gr.Error(f"❌ Processing failed: {str(e)}")
+        raise gr.Error(f"❌ Failed: {str(e)}")
 
-# Custom CSS
-custom_css = """
-#col-container {
-    margin: 0 auto;
-    max-width: 1400px;
-}
-.gradio-container {
-    font-family: 'Inter', sans-serif;
-}
-.gr-button-primary {
+# UI
+css = """
+#container {max-width: 1400px; margin: auto;}
+.primary-btn {
     background: linear-gradient(135deg, #667eea 0%, #764ba2 100%) !important;
     border: none !important;
-    font-weight: 600 !important;
-}
-.gr-button-primary:hover {
-    transform: translateY(-2px);
-    box-shadow: 0 10px 20px rgba(0,0,0,0.2);
-    transition: all 0.3s;
 }
 footer {display: none !important;}
 """
 
-# Gradio Interface
-with gr.Blocks(css=custom_css, title="Mirro Virtual Try-On", theme=gr.themes.Soft()) as demo:
+with gr.Blocks(css=css, title="Mirro Virtual Try-On") as demo:
+    
+    gr.Markdown("""
+    # 👗 Mirro Virtual Try-On API
+    ### AI-Powered Virtual Clothing Try-On
+    
+    Upload person and garment photos for realistic try-on results.
+    """)
     
-    with gr.Column(elem_id="col-container"):
+    gr.Markdown("🟢 **Status:** Ready!")
+    
+    with gr.Row():
+        with gr.Column():
+            person_input = gr.Image(
+                label="👤 Person Photo",
+                type="pil",
+                sources=["upload", "clipboard"]
+            )
+            
+            garment_input = gr.Image(
+                label="👔 Garment Photo",
+                type="pil",
+                sources=["upload", "clipboard"]
+            )
+            
+            with gr.Row():
+                clear_btn = gr.ClearButton([person_input, garment_input], value="Clear")
+                submit_btn = gr.Button("✨ Generate Try-On", variant="primary")
         
-        # Header
+        with gr.Column():
+            output_image = gr.Image(label="🎯 Result", type="pil")
+    
+    with gr.Accordion("💡 Tips", open=False):
         gr.Markdown("""
-        # 👗 Mirro Virtual Try-On API
-        ### AI-Powered Virtual Clothing Try-On for iOS Apps
-        
-        Upload a person's photo and a garment image to generate realistic virtual try-on results.
-        Perfect for fashion e-commerce, styling apps, and virtual wardrobes!
+        - Use clear, well-lit photos
+        - Person facing forward
+        - Plain backgrounds work best
+        - Processing: 10-20 seconds
         """)
+    
+    with gr.Accordion("📱 API Documentation", open=False):
+        gr.Markdown("""
+        **Endpoint:** `POST https://gk2291-mirro-app-server.hf.space/api/predict`
         
-        gr.Markdown("🟢 **Status:** Ready to process images!")
-        
-        # Main Interface
-        with gr.Row():
-            # Left - Inputs
-            with gr.Column(scale=1):
-                gr.Markdown("### 📤 Upload Images")
-                
-                person_input = gr.Image(
-                    label="👤 Person Photo",
-                    type="pil",
-                    sources=["upload", "clipboard"],
-                    height=400
-                )
-                
-                garment_input = gr.Image(
-                    label="👔 Garment Photo",
-                    type="pil",
-                    sources=["upload", "clipboard"],
-                    height=400
-                )
-                
-                with gr.Row():
-                    clear_btn = gr.ClearButton(
-                        components=[person_input, garment_input],
-                        value="🗑️ Clear All",
-                        scale=1
-                    )
-                    submit_btn = gr.Button(
-                        "✨ Generate Try-On",
-                        variant="primary",
-                        scale=2,
-                        size="lg"
-                    )
-            
-            # Right - Output
-            with gr.Column(scale=1):
-                gr.Markdown("### 🎯 Try-On Result")
-                
-                output_image = gr.Image(
-                    label="Virtual Try-On Result",
-                    type="pil",
-                    height=850
-                )
-        
-        # Tips Section
-        with gr.Accordion("💡 Tips for Best Results", open=False):
-            gr.Markdown("""
-            ### Person Photo Tips:
-            - ✅ Use clear, well-lit photos
-            - ✅ Person should face forward
-            - ✅ Upper body should be fully visible
-            - ✅ Plain or simple backgrounds work best
-            - ✅ Avoid busy patterns on current clothing
-            
-            ### Garment Photo Tips:
-            - ✅ Clear photo of the garment (flat lay or on hanger)
-            - ✅ Good lighting showing fabric details
-            - ✅ Full garment visible
-            - ✅ Plain background preferred
-            - ✅ No models wearing the garment (for best results)
-            
-            ### Expected Results:
-            - ⏱️ Processing time: 10-20 seconds
-            - 📐 Output resolution: 512x768 pixels
-            - 🎨 Realistic blending with natural lighting
-            """)
-        
-        # API Documentation
-        with gr.Accordion("📱 iOS App Integration Guide", open=False):
-            gr.Markdown("""
-            ## REST API Endpoint
-```
-            POST https://gk2291-mirro-app-server.hf.space/api/predict
-```
-            
-            ### Request Format (JSON)
+        **Request:**
 ```json
-            {
-                "data": [
-                    "data:image/jpeg;base64,<person_image_base64>",
-                    "data:image/jpeg;base64,<garment_image_base64>"
-                ]
-            }
+        {
+            "data": [
+                "data:image/jpeg;base64,<person_base64>",
+                "data:image/jpeg;base64,<garment_base64>"
+            ]
+        }
 ```
-            
-            ### Response Format (JSON)
+        
+        **Response:**
 ```json
-            {
-                "data": ["data:image/png;base64,<result_image_base64>"],
-                "duration": 15.3
-            }
+        {
+            "data": ["data:image/png;base64,<result_base64>"]
+        }
 ```
-            
-            ### Swift Implementation
-```swift
-            import Foundation
-            import UIKit
-            
-            class MirroAPI {
-                static let shared = MirroAPI()
-                private let baseURL = "https://gk2291-mirro-app-server.hf.space"
-                
-                func virtualTryOn(personImage: UIImage, 
-                                 garmentImage: UIImage,
-                                 completion: @escaping (Result<UIImage, Error>) -> Void) {
-                    
-                    guard let url = URL(string: "\\(baseURL)/api/predict") else {
-                        completion(.failure(NSError(domain: "Invalid URL", code: -1)))
-                        return
-                    }
-                    
-                    var request = URLRequest(url: url)
-                    request.httpMethod = "POST"
-                    request.setValue("application/json", forHTTPHeaderField: "Content-Type")
-                    request.timeoutInterval = 120 // 2 minutes timeout
-                    
-                    // Convert images to base64
-                    guard let personData = personImage.jpegData(compressionQuality: 0.85),
-                          let garmentData = garmentImage.jpegData(compressionQuality: 0.85) else {
-                        completion(.failure(NSError(domain: "Image conversion failed", code: -1)))
-                        return
-                    }
-                    
-                    let personB64 = "data:image/jpeg;base64,\\(personData.base64EncodedString())"
-                    let garmentB64 = "data:image/jpeg;base64,\\(garmentData.base64EncodedString())"
-                    
-                    let payload: [String: Any] = [
-                        "data": [personB64, garmentB64]
-                    ]
-                    
-                    request.httpBody = try? JSONSerialization.data(withJSONObject: payload)
-                    
-                    URLSession.shared.dataTask(with: request) { data, response, error in
-                        if let error = error {
-                            completion(.failure(error))
-                            return
-                        }
-                        
-                        guard let data = data,
-                              let json = try? JSONSerialization.jsonObject(with: data) as? [String: Any],
-                              let dataArray = json["data"] as? [String],
-                              let imageBase64 = dataArray.first else {
-                            completion(.failure(NSError(domain: "Parse error", code: -1)))
-                            return
-                        }
-                        
-                        // Extract base64 string
-                        let base64String = imageBase64.components(separatedBy: ",").last ?? ""
-                        
-                        guard let imageData = Data(base64Encoded: base64String),
-                              let image = UIImage(data: imageData) else {
-                            completion(.failure(NSError(domain: "Image decode error", code: -1)))
-                            return
-                        }
-                        
-                        completion(.success(image))
-                    }.resume()
-                }
-            }
-            
-            // Usage Example
-            MirroAPI.shared.virtualTryOn(
-                personImage: selectedPersonImage,
-                garmentImage: selectedGarmentImage
-            ) { result in
-                DispatchQueue.main.async {
-                    switch result {
-                    case .success(let tryOnImage):
-                        self.resultImageView.image = tryOnImage
-                        print("✅ Try-on successful!")
-                    case .failure(let error):
-                        self.showError(error.localizedDescription)
-                        print("❌ Error: \\(error)")
-                    }
-                }
-            }
-```
-            
-            ### SwiftUI Example
-```swift
-            import SwiftUI
-            
-            struct TryOnView: View {
-                @State private var personImage: UIImage?
-                @State private var garmentImage: UIImage?
-                @State private var resultImage: UIImage?
-                @State private var isLoading = false
-                
-                var body: some View {
-                    VStack {
-                        HStack {
-                            ImagePicker(image: $personImage, title: "Person")
-                            ImagePicker(image: $garmentImage, title: "Garment")
-                        }
-                        
-                        Button("Try On") {
-                            guard let person = personImage, 
-                                  let garment = garmentImage else { return }
-                            
-                            isLoading = true
-                            MirroAPI.shared.virtualTryOn(
-                                personImage: person,
-                                garmentImage: garment
-                            ) { result in
-                                isLoading = false
-                                if case .success(let image) = result {
-                                    resultImage = image
-                                }
-                            }
-                        }
-                        .disabled(isLoading || personImage == nil || garmentImage == nil)
-                        
-                        if isLoading {
-                            ProgressView("Generating try-on...")
-                        } else if let result = resultImage {
-                            Image(uiImage: result)
-                                .resizable()
-                                .scaledToFit()
-                        }
-                    }
-                }
-            }
-```
-            """)
-        
-        # Event Handler
-        submit_btn.click(
-            fn=virtual_tryon,
-            inputs=[person_input, garment_input],
-            outputs=output_image,
-            api_name="predict"
-        )
-        
-        # Footer
-        gr.Markdown("""
-        ---
-        <div style="text-align: center; color: #666; padding: 20px;">
-            <p>⚡ Powered by HuggingFace Zero GPU | 🎨 AI Image Processing | 🚀 Optimized for Mobile Apps</p>
-            <p style="font-size: 0.9em;">Built with ❤️ for Mirro iOS App</p>
-        </div>
         """)
+    
+    submit_btn.click(
+        fn=virtual_tryon,
+        inputs=[person_input, garment_input],
+        outputs=output_image,
+        api_name="predict"
+    )
+    
+    gr.Markdown("""
+    ---
+    <div style="text-align: center; color: #666;">
+        <p>⚡ Powered by HuggingFace Zero GPU</p>
+    </div>
+    """)
 
-# Launch
 if __name__ == "__main__":
-    demo.queue(max_size=20, default_concurrency_limit=1)
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,
-        show_error=True
-    )
+    demo.queue(max_size=20)
+    demo.launch(server_name="0.0.0.0", server_port=7860)