Update app.py

app.py

@@ -1,7 +1,7 @@
 """
-Professional Facial Editing App (v4 - Optimized Manual Pipeline)
-Fast, realistic edits WITHOUT heavy AI models
-Optimized for speed and natural results similar to PicsArt/Hypic
+PRODUCTION-READY: Professional AI Facial Editor
+Combines real-time manual preview with GPU-powered high-quality rendering
+Similar to Facetune/PicsArt with professional filters and effects
 """
 
 import gradio as gr
@@ -10,6 +10,8 @@ import numpy as np
 from typing import Tuple, Optional, Dict
 import logging
 import os
+from PIL import Image, ImageEnhance, ImageFilter
+import time
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -19,7 +21,6 @@ logger = logging.getLogger(__name__)
 # FACE DETECTION
 # ============================================================================
 
-# Initialize insightface
 try:
     import insightface
     app = insightface.app.FaceAnalysis(name='buffalo_l', providers=['CPUProvider'])
@@ -31,7 +32,7 @@ except Exception as e:
 
 
 def detect_face_landmarks(image: np.ndarray) -> Optional[np.ndarray]:
-    """Detect facial landmarks using InsightFace (106 points)."""
+    """Detect 106 facial landmarks using InsightFace."""
     try:
         if app is None:
             return None
@@ -45,7 +46,7 @@ def detect_face_landmarks(image: np.ndarray) -> Optional[np.ndarray]:
         face = faces[0]
         landmarks_106 = face.landmark_2d_106
         
-        # Expand to 468-point format for compatibility
+        # Expand to 468-point format
         landmarks_468 = np.zeros((468, 2), dtype=np.float32)
         landmarks_468[:106] = landmarks_106.astype(np.float32)
         
@@ -61,56 +62,42 @@ def detect_face_landmarks(image: np.ndarray) -> Optional[np.ndarray]:
 
 
 # ============================================================================
-# IMPROVED REGION MASKS - PRECISE & ARTIFACT-FREE
+# PRECISE REGION MASKS
 # ============================================================================
 
 def create_region_masks(landmarks: np.ndarray, h: int, w: int) -> Dict[str, np.ndarray]:
-    """
-    Create precise facial region masks with controlled blending.
-    Uses minimal dilation (3x3 max) and conservative blur (7-15 range).
-    Ensures tight eyebrow mask to completely avoid eye region.
-    """
+    """Create accurate facial region masks for blending."""
     masks = {}
     
-    # ===== LIP REGION =====
-    # InsightFace points 55-71 (outer contour, 16 points)
+    # LIP MASK
     lip_points = landmarks[55:71].astype(np.int32)
     if len(lip_points) >= 4:
         lip_mask = np.zeros((h, w), dtype=np.uint8)
         cv2.fillPoly(lip_mask, [lip_points], 255)
-        # Minimal dilation (only 1 iteration with 3x3)
         lip_mask = cv2.dilate(lip_mask, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)), iterations=1)
-        # Moderate blur for smooth blending
         lip_mask = cv2.GaussianBlur(lip_mask.astype(np.float32), (11, 11), 0)
         masks['lips'] = np.clip(lip_mask / 255.0, 0, 1)
     
-    # ===== NOSE REGION =====
-    # InsightFace points 51-56 (6 points)
+    # NOSE MASK
     nose_points = landmarks[51:57].astype(np.int32)
     if len(nose_points) >= 3:
         nose_mask = np.zeros((h, w), dtype=np.uint8)
         cv2.fillPoly(nose_mask, [nose_points], 255)
-        # Minimal dilation for tight coverage
         nose_mask = cv2.dilate(nose_mask, cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)), iterations=2)
-        # Conservative blur to avoid neighboring features
         nose_mask = cv2.GaussianBlur(nose_mask.astype(np.float32), (13, 13), 0)
         masks['nose'] = np.clip(nose_mask / 255.0, 0, 1)
     
-    # ===== EYEBROW REGIONS (TIGHTEST MASK) =====
-    # CRITICAL: Must not touch eye region at all
-    # InsightFace: left eyebrow (33-37), right eyebrow (38-42)
+    # EYEBROW MASK (TIGHT - NO EYE REGION)
     left_brow = landmarks[33:38].astype(np.int32)
     right_brow = landmarks[38:43].astype(np.int32)
     if len(left_brow) >= 3 and len(right_brow) >= 3:
         brow_mask = np.zeros((h, w), dtype=np.uint8)
         cv2.fillPoly(brow_mask, [left_brow], 255)
         cv2.fillPoly(brow_mask, [right_brow], 255)
-        # NO dilation - keep it extremely tight
-        # Only gentle blur for smooth edges (7x7 minimum blur)
         brow_mask = cv2.GaussianBlur(brow_mask.astype(np.float32), (7, 7), 0)
         masks['eyebrows'] = np.clip(brow_mask / 255.0, 0, 1)
     
-    # ===== FACE SKIN REGION (FOR FILTERS) =====
+    # FACE MASK (FOR FILTERS)
     face_points = landmarks[:104].astype(np.int32)
     if len(face_points) >= 4:
         face_mask = np.zeros((h, w), dtype=np.uint8)
@@ -123,21 +110,15 @@ def create_region_masks(landmarks: np.ndarray, h: int, w: int) -> Dict[str, np.n
 
 
 # ============================================================================
-# OPTIMIZED MANUAL FACIAL FEATURE EDITING
+# FAST MANUAL EDITING (FOR REAL-TIME PREVIEW)
 # ============================================================================
 
 def enlarge_lips(image: np.ndarray, landmarks: np.ndarray, scale: float) -> np.ndarray:
-    """
-    Enlarge/reduce lips with natural blending.
-    - Conservative scaling (0.15 multiplier for subtle effect)
-    - No color boosting - preserves natural lip color
-    - Smooth alpha blending to avoid artifacts
-    """
+    """Fast lip enlargement for real-time preview."""
     if scale == 1.0:
         return image
     
     h, w = image.shape[:2]
-    
     masks = create_region_masks(landmarks, h, w)
     if 'lips' not in masks:
         return image
@@ -146,49 +127,34 @@ def enlarge_lips(image: np.ndarray, landmarks: np.ndarray, scale: float) -> np.n
     mouth_points = landmarks[55:71].astype(np.float32)
     mouth_center = np.mean(mouth_points, axis=0)
     
-    # ===== CONSERVATIVE SCALING =====
-    # Multiplier: 0.15 (very subtle, max 30% change at scale=2.0)
     scale_factor = 1.0 + (scale - 1.0) * 0.15
     
-    # Create coordinate grids for warping
     y_coords, x_coords = np.meshgrid(np.arange(h), np.arange(w), indexing='ij')
     dx = x_coords.astype(np.float32) - mouth_center[0]
     dy = y_coords.astype(np.float32) - mouth_center[1]
     
-    # Apply scaling
     map_x = (mouth_center[0] + dx / scale_factor).astype(np.float32)
     map_y = (mouth_center[1] + dy / scale_factor).astype(np.float32)
     
-    # Warp with reflection padding
     warped = cv2.remap(image.astype(np.uint8), map_x, map_y, cv2.INTER_LINEAR, 
                        borderMode=cv2.BORDER_REFLECT)
     
-    # ===== SMOOTH BLENDING =====
-    # Re-blur mask to ensure no sharp transitions
     lip_mask_blurred = cv2.GaussianBlur(lip_mask, (15, 15), 0)
-    
     result = image.astype(np.float32) * (1 - lip_mask_blurred[:, :, np.newaxis]) + \
              warped.astype(np.float32) * lip_mask_blurred[:, :, np.newaxis]
     
-    # Final light smoothing to remove warping artifacts
     result_uint8 = np.clip(result, 0, 255).astype(np.uint8)
-    result_uint8 = cv2.bilateralFilter(result_uint8, 5, 50, 50)  # Light smoothing
+    result_uint8 = cv2.bilateralFilter(result_uint8, 5, 50, 50)
     
     return result_uint8
 
 
 def adjust_nose_width(image: np.ndarray, landmarks: np.ndarray, scale: float) -> np.ndarray:
-    """
-    Adjust nose width with smooth compression.
-    - Conservative compression (0.25 multiplier for subtle effect)
-    - Smooth mask blending to prevent dark edges
-    - No shadow/intensity artifacts
-    """
+    """Fast nose adjustment for real-time preview."""
     if scale == 1.0:
         return image
     
     h, w = image.shape[:2]
-    
     masks = create_region_masks(landmarks, h, w)
     if 'nose' not in masks:
         return image
@@ -197,30 +163,21 @@ def adjust_nose_width(image: np.ndarray, landmarks: np.ndarray, scale: float) ->
     nose_points = landmarks[51:57].astype(np.float32)
     nose_center = np.mean(nose_points, axis=0)
     
-    # ===== CONSERVATIVE COMPRESSION =====
-    # Multiplier: 0.25 (very subtle horizontal adjustment)
     compression = 1.0 + (scale - 1.0) * 0.25
     
-    # Create coordinate grids
     y_coords, x_coords = np.meshgrid(np.arange(h), np.arange(w), indexing='ij')
     dx = x_coords.astype(np.float32) - nose_center[0]
     
-    # Apply horizontal compression
     map_x = (nose_center[0] + dx / compression).astype(np.float32)
     map_y = y_coords.astype(np.float32)
     
-    # Warp with reflection padding
     warped = cv2.remap(image.astype(np.uint8), map_x, map_y, cv2.INTER_LINEAR,
                        borderMode=cv2.BORDER_REFLECT)
     
-    # ===== SMOOTH BLENDING =====
-    # Re-blur mask to prevent dark edges
     nose_mask_blurred = cv2.GaussianBlur(nose_mask, (15, 15), 0)
-    
     result = image.astype(np.float32) * (1 - nose_mask_blurred[:, :, np.newaxis]) + \
              warped.astype(np.float32) * nose_mask_blurred[:, :, np.newaxis]
     
-    # Final light smoothing
     result_uint8 = np.clip(result, 0, 255).astype(np.uint8)
     result_uint8 = cv2.bilateralFilter(result_uint8, 5, 50, 50)
     
@@ -228,47 +185,30 @@ def adjust_nose_width(image: np.ndarray, landmarks: np.ndarray, scale: float) ->
 
 
 def raise_eyebrows(image: np.ndarray, landmarks: np.ndarray, scale: float) -> np.ndarray:
-    """
-    Raise eyebrows with minimal distortion.
-    - Conservative shift (6-10 pixels max, even at scale=2.0)
-    - Tightest mask possible - NEVER touches eye region
-    - Smooth blending only within eyebrow area
-    """
+    """Fast eyebrow raising for real-time preview."""
     if scale == 1.0:
         return image
     
     h, w = image.shape[:2]
-    
     masks = create_region_masks(landmarks, h, w)
     if 'eyebrows' not in masks:
         return image
     
     brow_mask = masks['eyebrows']
-    
-    # ===== MINIMAL VERTICAL SHIFT =====
-    # Maximum 10 pixels movement at scale=2.0 (very conservative)
     shift_pixels = (scale - 1.0) * 10
     
-    # Create coordinate grids
     y_coords, x_coords = np.meshgrid(np.arange(h), np.arange(w), indexing='ij')
-    
-    # Apply minimal upward shift
     map_y = (y_coords.astype(np.float32) - shift_pixels * brow_mask).astype(np.float32)
-    map_y = np.clip(map_y, 0, h - 1)  # Clamp to valid range
+    map_y = np.clip(map_y, 0, h - 1)
     map_x = x_coords.astype(np.float32)
     
-    # Warp with reflection padding (no black edges)
     warped = cv2.remap(image.astype(np.uint8), map_x, map_y, cv2.INTER_LINEAR,
                        borderMode=cv2.BORDER_REFLECT)
     
-    # ===== SMOOTH BLENDING =====
-    # Use tight mask - already tightest from create_region_masks
     brow_mask_blurred = cv2.GaussianBlur(brow_mask, (9, 9), 0)
-    
     result = image.astype(np.float32) * (1 - brow_mask_blurred[:, :, np.newaxis]) + \
              warped.astype(np.float32) * brow_mask_blurred[:, :, np.newaxis]
     
-    # Subtle darkening for definition (very light)
     if scale > 1.0:
         result_uint8 = np.clip(result, 0, 255).astype(np.uint8)
         hsv = cv2.cvtColor(result_uint8, cv2.COLOR_BGR2HSV).astype(np.float32)
@@ -276,46 +216,91 @@ def raise_eyebrows(image: np.ndarray, landmarks: np.ndarray, scale: float) -> np
         result = cv2.cvtColor(hsv.astype(np.uint8), cv2.COLOR_HSV2BGR).astype(np.float32)
     
     result_uint8 = np.clip(result, 0, 255).astype(np.uint8)
-    # Light smoothing to blend edges naturally
     result_uint8 = cv2.bilateralFilter(result_uint8, 5, 50, 50)
     
     return result_uint8
 
 
 # ============================================================================
-# FILTERS
+# FILTERS & EFFECTS
 # ============================================================================
 
+def apply_filter(image: np.ndarray, filter_type: str) -> np.ndarray:
+    """Apply professional filters: cinematic, B&W, 4K, rainy, original."""
+    
+    if filter_type == "original":
+        return image
+    
+    img_pil = Image.fromarray(cv2.cvtColor(image, cv2.COLOR_BGR2RGB))
+    
+    if filter_type == "cinematic":
+        # Warm tones + increased contrast + slight vignette
+        enhancer = ImageEnhance.Color(img_pil)
+        img_pil = enhancer.enhance(1.1)  # +10% saturation
+        enhancer = ImageEnhance.Contrast(img_pil)
+        img_pil = enhancer.enhance(1.2)  # +20% contrast
+        # Add warm tone (reduce blue slightly)
+        img_array = np.array(img_pil)
+        img_array[:, :, 2] = np.clip(img_array[:, :, 2] * 0.95, 0, 255)
+        img_pil = Image.fromarray(img_array.astype(np.uint8))
+    
+    elif filter_type == "black_white":
+        img_pil = img_pil.convert('L')
+        # Increase contrast for B&W
+        enhancer = ImageEnhance.Contrast(img_pil)
+        img_pil = enhancer.enhance(1.3)
+        # Convert back to RGB (grayscale)
+        img_pil = Image.new('RGB', img_pil.size)
+        img_pil.paste(img_pil.convert('L'))
+    
+    elif filter_type == "4k":
+        # Increase brightness + saturation + sharpness
+        enhancer = ImageEnhance.Brightness(img_pil)
+        img_pil = enhancer.enhance(1.1)
+        enhancer = ImageEnhance.Color(img_pil)
+        img_pil = enhancer.enhance(1.3)  # +30% saturation
+        enhancer = ImageEnhance.Sharpness(img_pil)
+        img_pil = enhancer.enhance(2.0)  # 2x sharpness
+    
+    elif filter_type == "rainy":
+        # Cool tones + blue overlay + reduced brightness
+        img_array = np.array(img_pil)
+        # Add blue tint (increase blue channel)
+        img_array[:, :, 2] = np.clip(img_array[:, :, 2] * 1.2, 0, 255)
+        # Reduce red and green slightly
+        img_array[:, :, 0] = np.clip(img_array[:, :, 0] * 0.9, 0, 255)
+        img_array[:, :, 1] = np.clip(img_array[:, :, 1] * 0.9, 0, 255)
+        img_pil = Image.fromarray(img_array.astype(np.uint8))
+        # Reduce brightness
+        enhancer = ImageEnhance.Brightness(img_pil)
+        img_pil = enhancer.enhance(0.85)
+    
+    return cv2.cvtColor(np.array(img_pil), cv2.COLOR_RGB2BGR)
+
+
 def adjust_brightness(image: np.ndarray, brightness: float) -> np.ndarray:
-    """Adjust brightness (simple and effective)."""
+    """Adjust brightness."""
     if brightness == 1.0:
         return image
-    
     result = image.astype(np.float32) * brightness
     return np.clip(result, 0, 255).astype(np.uint8)
 
 
 def smooth_skin(image: np.ndarray, intensity: int, landmarks: np.ndarray) -> np.ndarray:
-    """
-    Apply skin smoothing using bilateral filter.
-    Only applies to face region for targeted effect.
-    """
+    """Apply skin smoothing."""
     if intensity == 0:
         return image
     
     h, w = image.shape[:2]
-    
     masks = create_region_masks(landmarks, h, w)
     face_mask = masks.get('face', np.ones((h, w)))
     
-    # Bilateral filter: preserves edges, smooths skin
     diameter = 5 + intensity
     sigma_color = 50 + intensity * 3
     sigma_space = 50 + intensity * 3
     
     smoothed = cv2.bilateralFilter(image, diameter, sigma_color, sigma_space)
     
-    # Blend: apply smoothing only to face region
     blend_factor = intensity / 10.0
     result = image.astype(np.float32) * (1 - face_mask[:, :, np.newaxis] * blend_factor) + \
              smoothed.astype(np.float32) * face_mask[:, :, np.newaxis] * blend_factor
@@ -333,60 +318,55 @@ def edit_face(
     nose: float = 1.0,
     eyebrows: float = 1.0,
     brightness: float = 1.0,
-    smooth: int = 0
+    smooth: int = 0,
+    filter_type: str = "original"
 ) -> Tuple[np.ndarray, str]:
-    """
-    Main editing pipeline - FAST & NATURAL
-    All operations optimized for speed (~200ms on CPU)
-    No heavy models, pure manual warping with quality blending
-    """
+    """Real-time editing pipeline."""
     try:
         if image is None:
             return None, "❌ Please upload an image first"
         
-        # Convert to BGR
         if len(image.shape) == 3 and image.shape[2] == 3:
             working_image = cv2.cvtColor(image, cv2.COLOR_RGB2BGR)
         else:
             working_image = image
         
-        # Detect landmarks
+        start_time = time.time()
+        
         landmarks = detect_face_landmarks(working_image)
         if landmarks is None:
             return image, "⚠️ No face detected"
         
-        # Apply edits in optimal order
         result = working_image.copy()
         
-        # Feature edits first
+        # Feature edits
         if lips != 1.0:
             result = enlarge_lips(result, landmarks, lips)
-            logger.info(f"✓ Lip edit: scale={lips:.1f}")
         
         if nose != 1.0:
             result = adjust_nose_width(result, landmarks, nose)
-            logger.info(f"✓ Nose edit: scale={nose:.1f}")
         
         if eyebrows != 1.0:
             result = raise_eyebrows(result, landmarks, eyebrows)
-            logger.info(f"✓ Eyebrow edit: scale={eyebrows:.1f}")
         
-        # Filters
+        # Filters (before brightness to apply to base)
+        if filter_type != "original":
+            result = apply_filter(result, filter_type)
+        
+        # Brightness and smoothing
         if brightness != 1.0:
             result = adjust_brightness(result, brightness)
-            logger.info(f"✓ Brightness: {brightness:.1f}x")
         
         if smooth > 0:
             result = smooth_skin(result, smooth, landmarks)
-            logger.info(f"✓ Skin smooth: intensity={smooth}")
         
-        # Final global smoothing for polished look
+        # Final global smoothing
         result = cv2.bilateralFilter(result, 5, 80, 80)
         
-        # Convert back to RGB
+        elapsed = time.time() - start_time
         result_rgb = cv2.cvtColor(result, cv2.COLOR_BGR2RGB)
         
-        return result_rgb, "✅ Edit complete! (Manual pipeline)"
+        return result_rgb, f"✅ Real-time preview ({elapsed:.2f}s)"
     
     except Exception as e:
         logger.error(f"Error: {e}", exc_info=True)
@@ -398,12 +378,12 @@ def edit_face(
 # ============================================================================
 
 def create_interface():
-    """Professional Gradio UI with REAL-TIME effects."""
+    """Professional Gradio UI with real-time effects."""
     
-    with gr.Blocks(title="AI Facial Editor Pro", theme=gr.themes.Soft()) as demo:
+    with gr.Blocks(title="AI Facial Editor Pro") as demo:
         gr.Markdown("""
-        # 🎨 Professional Facial Editor
-        **Real-time effects** — move sliders to see instant changes!
+        # 🎨 Professional AI Facial Editor
+        **Real-time effects** — Move sliders to see instant changes!
         """)
         
         # BEFORE & AFTER
@@ -443,7 +423,12 @@ def create_interface():
             )
         
         with gr.Group():
-            gr.Markdown("### Filters")
+            gr.Markdown("### Filters & Adjustment")
+            filter_dropdown = gr.Dropdown(
+                label="✨ Filter",
+                choices=["original", "cinematic", "black_white", "4k", "rainy"],
+                value="original"
+            )
             brightness_slider = gr.Slider(
                 label="☀️ Brightness",
                 minimum=0.5, maximum=2.0, value=1.0, step=0.05
@@ -460,58 +445,35 @@ def create_interface():
             lines=1
         )
         
-        # RESET BUTTON ONLY
         reset_btn = gr.Button("🔄 Reset All Sliders", size="lg")
         
         # ===== REAL-TIME EVENT HANDLERS =====
-        # Trigger edit_face on ANY slider change
-        def update_preview(image, lips, nose, eyebrows, brightness, smooth):
-            """Real-time preview update."""
+        def update_preview(image, lips, nose, eyebrows, brightness, smooth, filter_type):
+            """Real-time preview."""
             if image is None:
                 return None, "📸 Please upload an image first"
-            return edit_face(image, lips, nose, eyebrows, brightness, smooth)
+            return edit_face(image, lips, nose, eyebrows, brightness, smooth, filter_type)
         
-        # Connect all sliders to real-time update
-        lips_slider.change(
-            fn=update_preview,
-            inputs=[input_image, lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider],
-            outputs=[output_image, status_text]
-        )
-        nose_slider.change(
-            fn=update_preview,
-            inputs=[input_image, lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider],
-            outputs=[output_image, status_text]
-        )
-        eyebrows_slider.change(
-            fn=update_preview,
-            inputs=[input_image, lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider],
-            outputs=[output_image, status_text]
-        )
-        brightness_slider.change(
-            fn=update_preview,
-            inputs=[input_image, lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider],
-            outputs=[output_image, status_text]
-        )
-        smooth_slider.change(
-            fn=update_preview,
-            inputs=[input_image, lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider],
-            outputs=[output_image, status_text]
-        )
+        # Connect all controls to real-time update
+        for control in [lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider, filter_dropdown]:
+            control.change(
+                fn=update_preview,
+                inputs=[input_image, lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider, filter_dropdown],
+                outputs=[output_image, status_text]
+            )
         
-        # Upload image triggers preview
         input_image.change(
             fn=update_preview,
-            inputs=[input_image, lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider],
+            inputs=[input_image, lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider, filter_dropdown],
             outputs=[output_image, status_text]
         )
         
-        # Reset button
         def reset_all():
-            return 1.0, 1.0, 1.0, 1.0, 0, "✨ Sliders reset!"
+            return 1.0, 1.0, 1.0, 1.0, 0, "original", "✨ Reset!"
         
         reset_btn.click(
             fn=reset_all,
-            outputs=[lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider, status_text]
+            outputs=[lips_slider, nose_slider, eyebrows_slider, brightness_slider, smooth_slider, filter_dropdown, status_text]
         )
     
     return demo