Update app.py

app.py

@@ -2,8 +2,8 @@ import gradio as gr
 import cv2
 import numpy as np
 from PIL import Image, ImageFilter, ImageEnhance
-import io
-import os
+import warnings
+warnings.filterwarnings("ignore")
 
 class RefinedEnhancer:
     """Refined photo enhancer - natural colors and clarity focused"""
@@ -13,40 +13,44 @@ class RefinedEnhancer:
     
     def enhance_image(self, image, scale=None, enhance_colors=True, enhance_clarity=True):
         """Main enhancement function - natural and clear"""
+        if image is None:
+            return None
+            
         print(f"🎯 Enhancing image...")
-        if scale:
-            print(f"📏 Scale factor: {scale}x")
-        
-        # Convert to RGB if needed
-        if image.mode != 'RGB':
-            image = image.convert('RGB')
-        
-        print(f"📸 Original size: {image.size}")
-        
-        # Step 1: Gentle noise reduction (very minimal)
-        print("🔄 Step 1: Gentle cleanup...")
-        processed = self.gentle_cleanup(image)
         
-        # Step 2: Optional upscaling
-        if scale and scale > 1:
-            print(f"🔄 Step 2: Upscaling to {scale}x...")
-            new_size = (int(image.width * scale), int(image.height * scale))
-            processed = processed.resize(new_size, Image.LANCZOS)
-        else:
-            print("🔄 Step 2: Keeping original size...")
-        
-        # Step 3: Natural color enhancement
-        if enhance_colors:
-            print("🔄 Step 3: Natural color enhancement...")
-            processed = self.natural_color_enhancement(processed)
-        
-        # Step 4: Clarity improvement
-        if enhance_clarity:
-            print("🔄 Step 4: Clarity improvement...")
-            processed = self.clarity_improvement(processed)
-        
-        print(f"✅ Final size: {processed.size}")
-        return processed
+        try:
+            # Convert to RGB if needed
+            if image.mode != 'RGB':
+                image = image.convert('RGB')
+            
+            print(f"📸 Original size: {image.size}")
+            
+            # Step 1: Gentle noise reduction
+            print("🔄 Step 1: Gentle cleanup...")
+            processed = self.gentle_cleanup(image)
+            
+            # Step 2: Optional upscaling
+            if scale and scale > 1:
+                print(f"🔄 Step 2: Upscaling to {scale}x...")
+                new_size = (int(image.width * scale), int(image.height * scale))
+                processed = processed.resize(new_size, Image.LANCZOS)
+            
+            # Step 3: Natural color enhancement
+            if enhance_colors:
+                print("🔄 Step 3: Natural color enhancement...")
+                processed = self.natural_color_enhancement(processed)
+            
+            # Step 4: Clarity improvement
+            if enhance_clarity:
+                print("🔄 Step 4: Clarity improvement...")
+                processed = self.clarity_improvement(processed)
+            
+            print(f"✅ Final size: {processed.size}")
+            return processed
+            
+        except Exception as e:
+            print(f"Enhancement error: {e}")
+            return image  # Return original if processing fails
     
     def gentle_cleanup(self, image):
         """Very gentle cleanup - minimal noise reduction"""
@@ -54,268 +58,190 @@ class RefinedEnhancer:
             # Convert to OpenCV format
             cv_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
             
-            # Ultra-gentle noise reduction (very conservative)
-            denoised = cv2.fastNlMeansDenoisingColored(cv_image, None, 2, 2, 7, 21)
+            # Ultra-gentle noise reduction
+            denoised = cv2.fastNlMeansDenoisingColored(cv_image, None, 3, 3, 7, 21)
             
             # Convert back to PIL
             return Image.fromarray(cv2.cvtColor(denoised, cv2.COLOR_BGR2RGB))
-        except Exception as e:
-            print(f"Cleanup failed, using original: {e}")
+        except:
             return image
     
     def natural_color_enhancement(self, image):
         """Natural color enhancement - subtle but noticeable"""
         try:
-            # Convert to OpenCV for better color space control
+            # Convert to OpenCV format
             cv_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
             
             # Convert to HSV for better color control
             hsv = cv2.cvtColor(cv_image, cv2.COLOR_BGR2HSV)
             
-            # Enhance saturation naturally (only in mid-tones)
-            # This prevents over-saturation of already saturated colors
+            # Enhance saturation naturally
             saturation = hsv[:, :, 1].astype(np.float32)
-            
-            # Create a mask for mid-tone saturation (avoid already saturated areas)
             mask = (saturation > 30) & (saturation < 200)
-            
-            # Apply gentle saturation boost only to mid-tones
-            saturation[mask] = saturation[mask] * 1.08  # 8% increase only for mid-tones
+            saturation[mask] = saturation[mask] * 1.08
             saturation = np.clip(saturation, 0, 255).astype(np.uint8)
             hsv[:, :, 1] = saturation
             
-            # Convert back to BGR then RGB
+            # Convert back to BGR
             enhanced = cv2.cvtColor(hsv, cv2.COLOR_HSV2BGR)
             
-            # Subtle contrast enhancement using CLAHE (very gentle)
+            # Subtle contrast enhancement
             lab = cv2.cvtColor(enhanced, cv2.COLOR_BGR2LAB)
-            clahe = cv2.createCLAHE(clipLimit=1.1, tileGridSize=(8, 8))  # Even more gentle
+            clahe = cv2.createCLAHE(clipLimit=1.1, tileGridSize=(8, 8))
             lab[:, :, 0] = clahe.apply(lab[:, :, 0])
             enhanced = cv2.cvtColor(lab, cv2.COLOR_LAB2BGR)
             
             # Convert back to PIL
             return Image.fromarray(cv2.cvtColor(enhanced, cv2.COLOR_BGR2RGB))
-        except Exception as e:
-            print(f"Color enhancement failed, using original: {e}")
+        except:
             return image
     
     def clarity_improvement(self, image):
         """Improve clarity without over-smoothing"""
         try:
-            # Method 1: Gentle unsharp mask for edge enhancement
+            # Gentle unsharp mask
             sharpened = image.filter(ImageFilter.UnsharpMask(radius=0.8, percent=40, threshold=3))
             
-            # Method 2: Subtle detail enhancement
-            # Convert to OpenCV for more control
+            # Subtle detail enhancement
             cv_image = cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
-            
-            # Create a high-pass filter for detail enhancement
             gaussian = cv2.GaussianBlur(cv_image, (0, 0), 2.0)
             detail_enhanced = cv2.addWeighted(cv_image, 1.3, gaussian, -0.3, 0)
-            
-            # Convert back to PIL
             detail_enhanced_pil = Image.fromarray(cv2.cvtColor(detail_enhanced, cv2.COLOR_BGR2RGB))
             
-            # Blend the two methods gently
-            # 70% original sharpening, 30% detail enhancement
+            # Blend methods
             final = Image.blend(sharpened, detail_enhanced_pil, 0.3)
-            
-            # Final gentle blend with original to avoid over-processing
-            result = Image.blend(image, final, 0.6)  # 60% enhanced, 40% original
+            result = Image.blend(image, final, 0.6)
             
             return result
-        except Exception as e:
-            print(f"Clarity improvement failed, using original: {e}")
+        except:
             return image
 
-# Initialize the enhancer
+# Initialize enhancer
 enhancer = RefinedEnhancer()
 
-def smart_auto_enhance(image):
+def process_image_auto(image):
     """Auto enhancement with smart defaults"""
     if image is None:
         return None, "❌ No image provided"
     
     try:
-        # Check original image size and set smart defaults
-        original_width, original_height = image.size
-        total_pixels = original_width * original_height
+        # Get image info
+        w, h = image.size
+        total_pixels = w * h
         
-        # Smart upscaling decision
-        if total_pixels < 500000:  # Less than 0.5MP
+        # Smart scaling
+        if total_pixels < 500000:
             scale = 3
-            scale_info = "🚀 Auto-applying 3x upscaling (small image)"
-        elif total_pixels < 2000000:  # Less than 2MP
+            scale_info = "Applied 3x upscaling (small image)"
+        elif total_pixels < 2000000:
             scale = 2
-            scale_info = "🚀 Auto-applying 2x upscaling (medium image)"
+            scale_info = "Applied 2x upscaling (medium image)"
         else:
             scale = None
-            scale_info = "🚀 Keeping original size (large image)"
-        
-        # Default enhancements (always enabled)
-        enhance_colors = True
-        enhance_clarity = True
-        
-        # Enhance image
-        enhanced_image = enhancer.enhance_image(
-            image, 
-            scale=scale, 
-            enhance_colors=enhance_colors, 
-            enhance_clarity=enhance_clarity
-        )
+            scale_info = "Kept original size (large image)"
         
-        # Create info message
-        enhancements = []
-        if scale:
-            enhancements.append(f"{scale}x Upscaled")
-        if enhance_colors:
-            enhancements.append("Natural Colors")
-        if enhance_clarity:
-            enhancements.append("Clarity Improved")
-        
-        enhancement_text = " + ".join(enhancements) if enhancements else "No Enhancement"
+        # Enhance
+        enhanced = enhancer.enhance_image(image, scale=scale, enhance_colors=True, enhance_clarity=True)
         
-        info_message = f"""Enhancement Complete!
+        # Info message
+        info = f"""Enhancement Complete!
 
-Original: {original_width} × {original_height} pixels
-Enhanced: {enhanced_image.size[0]} × {enhanced_image.size[1]} pixels
+Original: {w} × {h} pixels
+Enhanced: {enhanced.size[0]} × {enhanced.size[1]} pixels
 
-Applied Enhancements:
-{enhancement_text}
-
-{scale_info}
-        """
+Enhancements Applied:
+• Natural color enhancement
+• Clarity improvement
+• {scale_info}
+"""
         
-        return enhanced_image, info_message
+        return enhanced, info
         
     except Exception as e:
-        return None, f"❌ Enhancement failed: {str(e)}"
+        return None, f"❌ Error: {str(e)}"
 
-def custom_enhance(image, upscale_factor, enhance_colors, enhance_clarity):
-    """Custom enhancement with user controls"""
+def process_image_custom(image, upscale, colors, clarity):
+    """Custom enhancement"""
     if image is None:
         return None, "❌ No image provided"
     
     try:
-        # Set scale based on upscale factor
-        scale = int(upscale_factor) if upscale_factor > 1 else None
-        
-        # Enhance image
-        enhanced_image = enhancer.enhance_image(
-            image, 
-            scale=scale, 
-            enhance_colors=enhance_colors, 
-            enhance_clarity=enhance_clarity
-        )
+        scale = int(upscale) if upscale > 1 else None
+        enhanced = enhancer.enhance_image(image, scale=scale, enhance_colors=colors, enhance_clarity=clarity)
         
-        # Create info message
         enhancements = []
         if scale:
-            enhancements.append(f"{scale}x Upscaled")
-        if enhance_colors:
-            enhancements.append("Natural Colors")
-        if enhance_clarity:
-            enhancements.append("Clarity Improved")
+            enhancements.append(f"{scale}x upscaling")
+        if colors:
+            enhancements.append("Natural colors")
+        if clarity:
+            enhancements.append("Clarity improvement")
         
-        enhancement_text = " + ".join(enhancements) if enhancements else "No Enhancement"
-        
-        info_message = f"""Custom Enhancement Complete!
+        info = f"""Custom Enhancement Complete!
 
 Original: {image.size[0]} × {image.size[1]} pixels
-Enhanced: {enhanced_image.size[0]} × {enhanced_image.size[1]} pixels
+Enhanced: {enhanced.size[0]} × {enhanced.size[1]} pixels
 
-Applied Enhancements:
-{enhancement_text}
-        """
+Applied: {', '.join(enhancements) if enhancements else 'No enhancements'}
+"""
         
-        return enhanced_image, info_message
+        return enhanced, info
         
     except Exception as e:
-        return None, f"❌ Enhancement failed: {str(e)}"
+        return None, f"❌ Error: {str(e)}"
 
-# Create Gradio interface with fixed configuration
-def create_interface():
-    with gr.Blocks(title="Refined Photo Enhancer", theme=gr.themes.Soft()) as demo:
-        gr.Markdown("""
-        # 🎨 Refined Photo Enhancer
-        ### Natural Colors & Clarity Enhancement
-        
-        Upload your photo and choose between **Smart Auto** mode or **Custom** controls!
-        """)
-        
+# Create interface - simplified version
+def create_app():
+    # Use basic Blocks without theme to avoid compatibility issues
+    with gr.Blocks() as app:
+        gr.Markdown("# 🎨 Refined Photo Enhancer")
+        gr.Markdown("### Natural Colors & Clarity Enhancement")
+        
+        # Auto tab
         with gr.Tab("🚀 Smart Auto"):
             with gr.Row():
                 with gr.Column():
-                    auto_input = gr.Image(label="Upload your photo", type="pil")
-                    auto_button = gr.Button("✨ Auto Enhance", variant="primary")
-                
+                    input1 = gr.Image(type="pil", label="Upload Photo")
+                    btn1 = gr.Button("✨ Auto Enhance")
                 with gr.Column():
-                    auto_output = gr.Image(label="Enhanced photo")
-                    auto_info = gr.Textbox(label="Enhancement info", lines=6)
+                    output1 = gr.Image(label="Enhanced Photo")
+                    info1 = gr.Textbox(label="Info", lines=8)
             
-            auto_button.click(
-                fn=smart_auto_enhance,
-                inputs=[auto_input],
-                outputs=[auto_output, auto_info]
-            )
+            btn1.click(process_image_auto, inputs=[input1], outputs=[output1, info1])
         
-        with gr.Tab("🎛️ Custom Controls"):
+        # Custom tab
+        with gr.Tab("🎛️ Custom"):
             with gr.Row():
                 with gr.Column():
-                    custom_input = gr.Image(label="Upload your photo", type="pil")
-                    upscale_factor = gr.Slider(
-                        minimum=1, maximum=4, value=2, step=1,
-                        label="Upscale Factor"
-                    )
-                    enhance_colors = gr.Checkbox(
-                        value=True, label="Natural Color Enhancement"
-                    )
-                    enhance_clarity = gr.Checkbox(
-                        value=True, label="Clarity Improvement"
-                    )
-                    custom_button = gr.Button("🎯 Custom Enhance", variant="primary")
-                
+                    input2 = gr.Image(type="pil", label="Upload Photo")
+                    upscale = gr.Slider(1, 4, value=2, step=1, label="Upscale Factor")
+                    colors = gr.Checkbox(value=True, label="Color Enhancement")
+                    clarity = gr.Checkbox(value=True, label="Clarity Enhancement")
+                    btn2 = gr.Button("🎯 Custom Enhance")
                 with gr.Column():
-                    custom_output = gr.Image(label="Enhanced photo")
-                    custom_info = gr.Textbox(label="Enhancement info", lines=6)
+                    output2 = gr.Image(label="Enhanced Photo")
+                    info2 = gr.Textbox(label="Info", lines=8)
             
-            custom_button.click(
-                fn=custom_enhance,
-                inputs=[custom_input, upscale_factor, enhance_colors, enhance_clarity],
-                outputs=[custom_output, custom_info]
-            )
+            btn2.click(process_image_custom, inputs=[input2, upscale, colors, clarity], outputs=[output2, info2])
         
         gr.Markdown("""
-        **💡 Tips:**
-        - Small images (< 800×600): Auto-upscaling recommended
-        - Medium images (800×600 to 1920×1080): Optional upscaling
-        - Large images (> 1920×1080): Usually no upscaling needed
-        - Best for: Natural photos, portraits, landscapes
-        """)
+**Tips:**
+- Small images: Auto-upscaling recommended
+- Large images: Usually no upscaling needed
+- Best for: Natural photos, portraits, landscapes
+""")
     
-    return demo
+    return app
 
-# Launch the app with proper configuration
+# Launch
 if __name__ == "__main__":
-    import warnings
-    warnings.filterwarnings("ignore", category=UserWarning)
+    print("🚀 Starting Refined Photo Enhancer...")
     
     try:
-        demo = create_interface()
-        print("🚀 Launching Refined Photo Enhancer...")
-        print("📡 Creating public link...")
-        
-        # Fixed launch configuration
-        demo.launch(
-            share=True,  # Enable sharing for cloud environments
-            server_name="0.0.0.0",  # Allow external access
-            server_port=7860,  # Standard port
-            debug=False,  # Disable debug mode for production
-            show_error=True,  # Show errors for debugging
-            quiet=True  # Suppress some warnings
-        )
+        app = create_app()
+        app.launch(share=True)
     except Exception as e:
-        print(f"❌ Failed to launch app: {e}")
-        print("🔄 Trying alternative launch configuration...")
-        demo = create_interface()
-        demo.launch(share=True, quiet=True)
+        print(f"Launch error: {e}")
+        print("Trying basic launch...")
+        app = create_app()
+        app.launch()