Update app.py

app.py

@@ -15,7 +15,7 @@ logger = logging.getLogger(__name__)
 # Model configuration
 MODEL_NAME = "abhilash88/face-emotion-detection"
 
-# Emotion labels mapping - update this based on your model's actual labels
+# Emotion labels mapping
 EMOTION_LABELS = {
     'LABEL_0': 'angry',
     'LABEL_1': 'disgust', 
@@ -76,11 +76,6 @@ def load_models():
         
         logger.info("Emotion detection model loaded successfully")
         
-        # Test model to get actual label mapping
-        test_image = Image.new('RGB', (224, 224), color='white')
-        test_results = emotion_classifier(test_image)
-        logger.info(f"Model test result format: {test_results}")
-        
         # Load OpenCV face cascade
         face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
         
@@ -96,21 +91,110 @@ def load_models():
         logger.error(f"Error loading models: {e}")
         return False
 
-def detect_faces(image: np.ndarray) -> List[Tuple[int, int, int, int]]:
-    """Detect faces in the image using OpenCV"""
+def detect_faces_improved(image: np.ndarray, min_face_size: int = 80) -> List[Tuple[int, int, int, int]]:
+    """
+    Improved face detection with better parameters to reduce false positives
+    and merge overlapping detections
+    """
     try:
         gray = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)
+        
+        # Use more strict parameters to reduce false positives
         faces = face_cascade.detectMultiScale(
             gray, 
-            scaleFactor=1.1, 
-            minNeighbors=5, 
-            minSize=(30, 30)
+            scaleFactor=1.05,        # Smaller scale factor for more careful detection
+            minNeighbors=8,          # Higher min neighbors to be more strict
+            minSize=(min_face_size, min_face_size),  # Larger minimum size
+            maxSize=(int(min(image.shape[:2]) * 0.8), int(min(image.shape[:2]) * 0.8)),  # Maximum size
+            flags=cv2.CASCADE_SCALE_IMAGE | cv2.CASCADE_DO_CANNY_PRUNING
         )
-        return faces.tolist()
+        
+        if len(faces) == 0:
+            return []
+        
+        # Convert to list and merge overlapping detections
+        faces_list = faces.tolist()
+        merged_faces = merge_overlapping_faces(faces_list)
+        
+        # Filter faces that are too small relative to image size
+        image_area = image.shape[0] * image.shape[1]
+        filtered_faces = []
+        
+        for (x, y, w, h) in merged_faces:
+            face_area = w * h
+            # Face should be at least 0.5% of image area but not more than 80%
+            if 0.005 < (face_area / image_area) < 0.8:
+                # Additional validation: check aspect ratio (faces are roughly square)
+                aspect_ratio = w / h
+                if 0.7 <= aspect_ratio <= 1.4:  # Allow some variance but not extreme rectangles
+                    filtered_faces.append((x, y, w, h))
+        
+        return filtered_faces
+        
     except Exception as e:
         logger.error(f"Error detecting faces: {e}")
         return []
 
+def merge_overlapping_faces(faces: List[Tuple[int, int, int, int]], overlap_threshold: float = 0.3) -> List[Tuple[int, int, int, int]]:
+    """
+    Merge overlapping face detections to avoid duplicates
+    """
+    if len(faces) <= 1:
+        return faces
+    
+    # Calculate IoU (Intersection over Union) for all pairs
+    merged = []
+    used = [False] * len(faces)
+    
+    for i in range(len(faces)):
+        if used[i]:
+            continue
+            
+        current_face = faces[i]
+        merged_face = list(current_face)
+        count = 1
+        used[i] = True
+        
+        for j in range(i + 1, len(faces)):
+            if used[j]:
+                continue
+                
+            if calculate_iou(current_face, faces[j]) > overlap_threshold:
+                # Merge by averaging coordinates
+                merged_face[0] = (merged_face[0] * count + faces[j][0]) // (count + 1)
+                merged_face[1] = (merged_face[1] * count + faces[j][1]) // (count + 1)
+                merged_face[2] = (merged_face[2] * count + faces[j][2]) // (count + 1)
+                merged_face[3] = (merged_face[3] * count + faces[j][3]) // (count + 1)
+                count += 1
+                used[j] = True
+        
+        merged.append(tuple(merged_face))
+    
+    return merged
+
+def calculate_iou(box1: Tuple[int, int, int, int], box2: Tuple[int, int, int, int]) -> float:
+    """Calculate Intersection over Union of two bounding boxes"""
+    x1, y1, w1, h1 = box1
+    x2, y2, w2, h2 = box2
+    
+    # Calculate intersection
+    x_left = max(x1, x2)
+    y_top = max(y1, y2)
+    x_right = min(x1 + w1, x2 + w2)
+    y_bottom = min(y1 + h1, y2 + h2)
+    
+    if x_right < x_left or y_bottom < y_top:
+        return 0.0
+    
+    intersection = (x_right - x_left) * (y_bottom - y_top)
+    
+    # Calculate union
+    area1 = w1 * h1
+    area2 = w2 * h2
+    union = area1 + area2 - intersection
+    
+    return intersection / union if union > 0 else 0.0
+
 def predict_emotion(face_image: Image.Image) -> List[Dict]:
     """Predict emotion for a single face"""
     try:
@@ -118,9 +202,8 @@ def predict_emotion(face_image: Image.Image) -> List[Dict]:
             logger.warning("Emotion classifier not loaded, returning neutral")
             return [{"label": "neutral", "score": 1.0}]
         
-        # Resize image if too large for better performance
-        if face_image.size[0] > 224 or face_image.size[1] > 224:
-            face_image = face_image.resize((224, 224))
+        # Resize image for better performance and consistency
+        face_image = face_image.resize((224, 224))
         
         # The pipeline returns results in different formats depending on configuration
         results = emotion_classifier(face_image)
@@ -154,54 +237,66 @@ def predict_emotion(face_image: Image.Image) -> List[Dict]:
         logger.error(f"Error predicting emotion: {e}")
         return [{"label": "neutral", "score": 1.0}]
 
-def draw_emotion_results(image: Image.Image, faces: List, emotions: List) -> Image.Image:
+def draw_emotion_results(image: Image.Image, faces: List, emotions: List, confidence_threshold: float = 0.5) -> Image.Image:
     """Draw bounding boxes and emotion labels on the image"""
     try:
         draw = ImageDraw.Draw(image)
         
         # Try to load a font, fallback to default if not available
         try:
-            font = ImageFont.truetype("arial.ttf", 16)
+            font = ImageFont.truetype("arial.ttf", 20)
         except:
-            font = ImageFont.load_default()
+            try:
+                font = ImageFont.truetype("DejaVuSans.ttf", 20)
+            except:
+                font = ImageFont.load_default()
         
         for i, (x, y, w, h) in enumerate(faces):
             if i < len(emotions):
-                # Get top emotion
-                top_emotion = max(emotions[i], key=lambda x: x['score'])
+                # Get top emotion above threshold
+                valid_emotions = [e for e in emotions[i] if e['score'] >= confidence_threshold]
+                if not valid_emotions:
+                    continue
+                    
+                top_emotion = max(valid_emotions, key=lambda x: x['score'])
                 emotion_label = top_emotion['label']
                 confidence = top_emotion['score']
                 
                 # Get color for this emotion
                 color = EMOTION_COLORS.get(emotion_label, '#FFFFFF')
                 
-                # Draw bounding box
-                draw.rectangle([(x, y), (x + w, y + h)], outline=color, width=3)
+                # Draw bounding box with thicker line
+                draw.rectangle([(x, y), (x + w, y + h)], outline=color, width=4)
                 
-                # Draw emotion label
-                label_text = f"{emotion_label}: {confidence:.2f}"
+                # Draw emotion label with better formatting
+                label_text = f"{emotion_label.upper()}"
+                confidence_text = f"{confidence:.1%}"
                 
                 # Calculate text size for background
-                bbox = draw.textbbox((0, 0), label_text, font=font)
-                text_width = bbox[2] - bbox[0]
-                text_height = bbox[3] - bbox[1]
+                bbox1 = draw.textbbox((0, 0), label_text, font=font)
+                bbox2 = draw.textbbox((0, 0), confidence_text, font=font)
+                text_width = max(bbox1[2] - bbox1[0], bbox2[2] - bbox2[0]) + 20
+                text_height = (bbox1[3] - bbox1[1]) + (bbox2[3] - bbox2[1]) + 15
                 
                 # Draw background for text
                 draw.rectangle(
-                    [(x, y - text_height - 5), (x + text_width + 10, y)],
+                    [(x, y - text_height - 10), (x + text_width, y)],
                     fill=color
                 )
                 
-                # Draw text
-                draw.text((x + 5, y - text_height - 2), label_text, fill='white', font=font)
+                # Draw emotion label
+                draw.text((x + 10, y - text_height - 5), label_text, fill='white', font=font)
+                
+                # Draw confidence
+                draw.text((x + 10, y - text_height + 20), confidence_text, fill='white', font=font)
         
         return image
     except Exception as e:
         logger.error(f"Error drawing results: {e}")
         return image
 
-def process_single_image(image: Image.Image) -> Tuple[Image.Image, str]:
-    """Process a single image for emotion detection"""
+def process_image(image: Image.Image, confidence_threshold: float = 0.5, min_face_size: int = 80) -> Tuple[Image.Image, str]:
+    """Process an image for emotion detection with improved face detection"""
     try:
         if image is None:
             return None, "No image provided"
@@ -209,80 +304,44 @@ def process_single_image(image: Image.Image) -> Tuple[Image.Image, str]:
         # Convert PIL to numpy array
         image_np = np.array(image)
         
-        # Detect faces
-        faces = detect_faces(image_np)
+        # Detect faces with improved method
+        faces = detect_faces_improved(image_np, min_face_size)
         
         if not faces:
-            return image, "No faces detected in the image"
-        
-        # Process each face
-        emotions_list = []
-        for (x, y, w, h) in faces:
-            # Extract face region
-            face_region = image.crop((x, y, x + w, y + h))
-            
-            # Predict emotion
-            emotions = predict_emotion(face_region)
-            emotions_list.append(emotions)
-        
-        # Draw results
-        result_image = draw_emotion_results(image.copy(), faces, emotions_list)
-        
-        # Create summary text
-        summary_lines = [f"Detected {len(faces)} face(s):"]
-        for i, emotions in enumerate(emotions_list):
-            top_emotion = max(emotions, key=lambda x: x['score'])
-            summary_lines.append(f"Face {i+1}: {top_emotion['label']} ({top_emotion['score']:.2f})")
-        
-        summary = "\n".join(summary_lines)
-        
-        return result_image, summary
-        
-    except Exception as e:
-        logger.error(f"Error processing image: {e}")
-        return image, f"Error processing image: {str(e)}"
-
-def process_webcam_frame(image: Image.Image, confidence_threshold: float = 0.5) -> Tuple[Image.Image, str]:
-    """Process webcam frame for emotion detection with confidence threshold"""
-    try:
-        if image is None:
-            return None, "📷 No image from camera"
-        
-        # Convert PIL to numpy array
-        image_np = np.array(image)
-        
-        # Detect faces
-        faces = detect_faces(image_np)
-        
-        if not faces:
-            return image, "👤 No faces detected in the camera feed"
+            return image, "❌ No faces detected in the image. Try adjusting the minimum face size or use an image with clearer faces."
         
         # Process each face
         emotions_list = []
         valid_faces = []
         
         for (x, y, w, h) in faces:
-            # Extract face region
-            face_region = image.crop((x, y, x + w, y + h))
+            # Extract face region with some padding
+            padding = max(10, min(w, h) // 10)
+            x_pad = max(0, x - padding)
+            y_pad = max(0, y - padding)
+            w_pad = min(image.width - x_pad, w + 2 * padding)
+            h_pad = min(image.height - y_pad, h + 2 * padding)
+            
+            face_region = image.crop((x_pad, y_pad, x_pad + w_pad, y_pad + h_pad))
             
             # Predict emotion
             emotions = predict_emotion(face_region)
             
-            # Filter by confidence threshold
-            filtered_emotions = [e for e in emotions if e['score'] >= confidence_threshold]
+            # Check if any emotion meets the confidence threshold
+            valid_emotions = [e for e in emotions if e['score'] >= confidence_threshold]
             
-            if filtered_emotions:
+            if valid_emotions:
                 emotions_list.append(emotions)
                 valid_faces.append((x, y, w, h))
         
         if not valid_faces:
-            return image, f"🎯 Faces detected but no emotions above {confidence_threshold:.1f} confidence threshold"
+            return image, f"⚠️ {len(faces)} face(s) detected but no emotions above {confidence_threshold:.1f} confidence threshold. Try lowering the threshold."
         
         # Draw results
-        result_image = draw_emotion_results(image.copy(), valid_faces, emotions_list)
+        result_image = draw_emotion_results(image.copy(), valid_faces, emotions_list, confidence_threshold)
         
-        # Create detailed summary text
-        summary_lines = [f"🎯 **Detected {len(valid_faces)} face(s) with high confidence:**\n"]
+        # Create summary text
+        summary_lines = [f"✅ **Successfully detected {len(valid_faces)} face(s) with confident emotion predictions:**\n"]
         
         for i, emotions in enumerate(emotions_list):
             # Sort emotions by confidence
@@ -295,14 +354,18 @@ def process_webcam_frame(image: Image.Image, confidence_threshold: float = 0.5)
                 'happy': '😊', 'sad': '😢', 'surprise': '😲', 'neutral': '😐'
             }.get(top_emotion['label'], '😐')
             
-            summary_lines.append(f"**Face {i+1}:** {emotion_emoji} {top_emotion['label'].title()} ({top_emotion['score']:.3f})")
+            summary_lines.append(f"**Face {i+1}:** {emotion_emoji} **{top_emotion['label'].title()}** ({top_emotion['score']:.1%} confidence)")
             
             # Add top 3 emotions for detailed analysis
             if len(sorted_emotions) > 1:
-                summary_lines.append("  📊 Other emotions:")
+                summary_lines.append("  📊 Other detected emotions:")
                 for emotion in sorted_emotions[1:4]:  # Top 3 others
                     if emotion['score'] >= confidence_threshold:
-                        summary_lines.append(f"     • {emotion['label'].title()}: {emotion['score']:.3f}")
+                        emoji = {
+                            'angry': '😠', 'disgust': '🤢', 'fear': '😨', 
+                            'happy': '😊', 'sad': '😢', 'surprise': '😲', 'neutral': '😐'
+                        }.get(emotion['label'], '😐')
+                        summary_lines.append(f"     • {emoji} {emotion['label'].title()}: {emotion['score']:.1%}")
             summary_lines.append("")
         
         summary = "\n".join(summary_lines)
@@ -310,8 +373,8 @@ def process_webcam_frame(image: Image.Image, confidence_threshold: float = 0.5)
         return result_image, summary
         
     except Exception as e:
-        logger.error(f"Error processing webcam frame: {e}")
-        return image, f"❌ Error processing frame: {str(e)}"
+        logger.error(f"Error processing image: {e}")
+        return image, f"❌ Error processing image: {str(e)}"
 
 def analyze_emotions_batch(files) -> str:
     """Analyze emotions in multiple uploaded files"""
@@ -329,11 +392,11 @@ def analyze_emotions_batch(files) -> str:
                 # Convert PIL to numpy array
                 image_np = np.array(image)
                 
-                # Detect faces
-                faces = detect_faces(image_np)
+                # Detect faces with improved method
+                faces = detect_faces_improved(image_np)
                 
                 if not faces:
-                    all_results.append(f"File {idx+1} ({file.name}): No faces detected")
+                    all_results.append(f"📁 File {idx+1} ({file.name}): No faces detected")
                     continue
                 
                 # Process each face
@@ -345,12 +408,12 @@ def analyze_emotions_batch(files) -> str:
                     # Predict emotion
                     emotions = predict_emotion(face_region)
                     top_emotion = max(emotions, key=lambda x: x['score'])
-                    image_emotions.append(f"{top_emotion['label']} ({top_emotion['score']:.2f})")
+                    image_emotions.append(f"{top_emotion['label']} ({top_emotion['score']:.1%})")
                 
-                all_results.append(f"File {idx+1} ({file.name}): {', '.join(image_emotions)}")
+                all_results.append(f"📁 File {idx+1} ({file.name}): {len(faces)} face(s) - {', '.join(image_emotions)}")
                 
             except Exception as e:
-                all_results.append(f"File {idx+1}: Error processing - {str(e)}")
+                all_results.append(f"📁 File {idx+1}: Error processing - {str(e)}")
         
         return "\n".join(all_results)
         
@@ -367,22 +430,31 @@ def get_emotion_statistics(image: Image.Image) -> str:
         # Convert PIL to numpy array
         image_np = np.array(image)
         
-        # Detect faces
-        faces = detect_faces(image_np)
+        # Detect faces with improved method
+        faces = detect_faces_improved(image_np)
         
         if not faces:
-            return "No faces detected"
+            return "❌ No faces detected in the image"
         
         # Collect all emotions
         all_emotions = {}
+        face_details = []
         
-        for (x, y, w, h) in faces:
+        for i, (x, y, w, h) in enumerate(faces):
             # Extract face region
             face_region = image.crop((x, y, x + w, y + h))
             
             # Predict emotion
             emotions = predict_emotion(face_region)
             
+            # Store face details
+            sorted_emotions = sorted(emotions, key=lambda x: x['score'], reverse=True)
+            face_details.append({
+                'face_num': i + 1,
+                'position': (x, y, w, h),
+                'emotions': sorted_emotions
+            })
+            
             for emotion_data in emotions:
                 emotion = emotion_data['label']
                 score = emotion_data['score']
@@ -392,51 +464,57 @@ def get_emotion_statistics(image: Image.Image) -> str:
                 all_emotions[emotion].append(score)
         
         # Calculate statistics
-        stats_lines = [f"**Emotion Analysis for {len(faces)} face(s):**\n"]
+        stats_lines = [f"📊 **Detailed Emotion Analysis for {len(faces)} face(s):**\n"]
         
-        for emotion, scores in all_emotions.items():
-            avg_score = np.mean(scores)
-            max_score = np.max(scores)
-            count = len(scores)
+        # Per-face breakdown
+        for face_detail in face_details:
+            stats_lines.append(f"### 👤 Face {face_detail['face_num']}:")
+            top_emotion = face_detail['emotions'][0]
+            stats_lines.append(f"**Primary emotion:** {top_emotion['label'].title()} ({top_emotion['score']:.1%})")
             
-            stats_lines.append(f"**{emotion.title()}:**")
-            stats_lines.append(f"  - Average confidence: {avg_score:.3f}")
-            stats_lines.append(f"  - Maximum confidence: {max_score:.3f}")
-            stats_lines.append(f"  - Detections: {count}")
+            stats_lines.append("**All emotions detected:**")
+            for emotion in face_detail['emotions']:
+                bar_length = int(emotion['score'] * 20)  # Scale to 20 chars
+                bar = "█" * bar_length + "░" * (20 - bar_length)
+                stats_lines.append(f"  {emotion['label'].title()}: {bar} {emotion['score']:.1%}")
             stats_lines.append("")
         
+        # Overall statistics
+        if len(faces) > 1:
+            stats_lines.append("### 📈 Overall Statistics:")
+            for emotion, scores in all_emotions.items():
+                avg_score = np.mean(scores)
+                max_score = np.max(scores)
+                count = len(scores)
+                
+                stats_lines.append(f"**{emotion.title()}:**")
+                stats_lines.append(f"  - Average confidence: {avg_score:.1%}")
+                stats_lines.append(f"  - Maximum confidence: {max_score:.1%}")
+                stats_lines.append(f"  - Faces showing this emotion: {count}/{len(faces)}")
+                stats_lines.append("")
+        
         return "\n".join(stats_lines)
         
     except Exception as e:
         logger.error(f"Error calculating statistics: {e}")
-        return f"Error calculating statistics: {str(e)}"
+        return f"❌ Error calculating statistics: {str(e)}"
 
-# Create Gradio interface
+# Create simplified Gradio interface
 def create_interface():
-    # Custom CSS for modern styling
     custom_css = """
     .main-header {
         text-align: center;
         color: #2563eb;
         margin-bottom: 2rem;
     }
-    .emotion-box {
-        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
-        color: white;
-        padding: 1rem;
-        border-radius: 0.5rem;
-        margin: 1rem 0;
-    }
-    .stats-box {
-        background: #f8fafc;
-        border: 1px solid #e2e8f0;
-        border-radius: 0.5rem;
-        padding: 1rem;
+    .gradio-container {
+        max-width: 1200px;
+        margin: auto;
     }
     """
     
     with gr.Blocks(
-        title="Live Face Emotion Detection",
+        title="Face Emotion Detection - Improved",
         theme=gr.themes.Soft(),
         css=custom_css
     ) as iface:
@@ -444,103 +522,70 @@ def create_interface():
         # Header
         gr.Markdown(
             """
-            # 😊 Live Face Emotion Detection
+            # 😊 Face Emotion Detection (Improved)
             
-            ### Real-time emotion recognition powered by deep learning
+            ### Accurate emotion recognition with enhanced face detection
             
-            This tool uses a fine-tuned model to detect and classify emotions in faces. It can identify 
-            7 different emotions: **angry**, **disgust**, **fear**, **happy**, **sad**, **surprise**, and **neutral**.
+            This improved version includes better face detection algorithms to reduce false positives 
+            and provides more accurate emotion classification for detected faces.
             """,
             elem_classes=["main-header"]
         )
         
-        with gr.Tab("📷 Single Image Analysis"):
+        with gr.Tab("🖼️ Single Image Analysis"):
             with gr.Row():
                 with gr.Column(scale=1):
-                    single_image_input = gr.Image(
+                    image_input = gr.Image(
                         label="Upload Image",
                         type="pil",
                         height=400
                     )
-                    analyze_single_btn = gr.Button("Analyze Emotions", variant="primary", size="lg")
-                
-                with gr.Column(scale=1):
-                    single_image_output = gr.Image(
-                        label="Emotion Detection Results",
-                        height=400
-                    )
-                    single_result_text = gr.Textbox(
-                        label="Detection Summary",
-                        lines=5,
-                        show_copy_button=True
-                    )
-        
-        with gr.Tab("🎥 Live Webcam Detection"):
-            gr.Markdown(
-                """
-                ### Real-time Emotion Detection
-                Use your camera for live emotion detection! The system will automatically process frames as you capture them.
-                """
-            )
-            
-            with gr.Row():
-                with gr.Column(scale=1):
-                    # Use Image component with webcam source for live detection
-                    webcam_input = gr.Image(
-                        label="📹 Live Camera Feed",
-                        type="pil",
-                        height=400,
-                        sources=["webcam"],
-                        streaming=False  # We'll handle updates manually
-                    )
                     
                     with gr.Row():
-                        start_detection_btn = gr.Button("🔴 Start Live Detection", variant="primary", size="lg")
-                        stop_detection_btn = gr.Button("⏹️ Stop Detection", variant="secondary", size="lg")
+                        confidence_slider = gr.Slider(
+                            minimum=0.1,
+                            maximum=1.0,
+                            value=0.5,
+                            step=0.1,
+                            label="🎯 Confidence Threshold",
+                            info="Minimum confidence to display emotions"
+                        )
+                        
+                        face_size_slider = gr.Slider(
+                            minimum=30,
+                            maximum=200,
+                            value=80,
+                            step=10,
+                            label="👤 Minimum Face Size",
+                            info="Minimum face size (pixels) to detect"
+                        )
                     
-                    # Auto-detection toggle
-                    auto_detect_checkbox = gr.Checkbox(
-                        label="🔄 Auto-detect on camera change",
-                        value=True,
-                        info="Automatically analyze when camera input changes"
-                    )
+                    analyze_btn = gr.Button("🔍 Analyze Emotions", variant="primary", size="lg")
                 
                 with gr.Column(scale=1):
-                    webcam_output = gr.Image(
-                        label="🎯 Emotion Detection Results",
+                    output_image = gr.Image(
+                        label="Emotion Detection Results",
                         height=400
                     )
-                    
-                    webcam_result_text = gr.Textbox(
-                        label="📊 Live Detection Results",
-                        lines=6,
-                        show_copy_button=True,
-                        placeholder="Start detection to see emotion analysis..."
-                    )
-                    
-                    # Confidence threshold slider
-                    confidence_threshold = gr.Slider(
-                        minimum=0.1,
-                        maximum=1.0,
-                        value=0.5,
-                        step=0.1,
-                        label="🎚️ Confidence Threshold",
-                        info="Minimum confidence to display emotions"
+                    result_text = gr.Textbox(
+                        label="Detection Results",
+                        lines=8,
+                        show_copy_button=True
                     )
         
         with gr.Tab("📊 Detailed Statistics"):
             with gr.Row():
                 with gr.Column(scale=1):
                     stats_image_input = gr.Image(
-                        label="Upload Image for Analysis",
+                        label="Upload Image for Statistical Analysis",
                         type="pil",
                         height=400
                     )
-                    analyze_stats_btn = gr.Button("Generate Statistics", variant="primary", size="lg")
+                    analyze_stats_btn = gr.Button("📈 Generate Detailed Statistics", variant="primary", size="lg")
                 
                 with gr.Column(scale=1):
                     stats_output = gr.Markdown(
-                        value="Upload an image and click 'Generate Statistics' to see detailed emotion analysis...",
+                        value="Upload an image and click 'Generate Detailed Statistics' to see comprehensive emotion analysis...",
                         label="Emotion Statistics"
                     )
         
@@ -551,169 +596,128 @@ def create_interface():
                     file_count="multiple",
                     file_types=["image"]
                 )
-                batch_process_btn = gr.Button("Process Batch", variant="primary", size="lg")
+                batch_process_btn = gr.Button("⚡ Process All Images", variant="primary", size="lg")
                 batch_results_output = gr.Textbox(
                     label="Batch Processing Results",
-                    lines=10,
+                    lines=15,
                     show_copy_button=True
                 )
         
-        with gr.Tab("📚 About & Model Info"):
+        with gr.Tab("ℹ️ About & Tips"):
             gr.Markdown(
                 """
-                ## About This Model
-                
-                This face emotion detection system uses a fine-tuned deep learning model specifically trained 
-                for emotion recognition. The model can detect 7 different emotional states with high accuracy.
+                ## 🔧 Improvements Made
                 
-                ### Supported Emotions
+                ### ✅ Enhanced Face Detection
+                - **Stricter parameters** to reduce false positives
+                - **Overlap detection** to merge duplicate face detections
+                - **Size filtering** to ignore unrealistic face sizes
+                - **Aspect ratio validation** to filter non-face rectangles
                 
-                - 😠 **Angry** - Expressions of anger, frustration, or annoyance
-                - 🤢 **Disgust** - Expressions of revulsion or distaste  
-                - 😨 **Fear** - Expressions of fear, anxiety, or worry
-                - 😊 **Happy** - Expressions of joy, contentment, or pleasure
-                - 😢 **Sad** - Expressions of sadness, sorrow, or melancholy
-                - 😲 **Surprise** - Expressions of surprise, shock, or amazement
-                - 😐 **Neutral** - Calm, neutral expressions with no strong emotion
+                ### 🎯 Better Accuracy
+                - **Confidence thresholds** to filter uncertain predictions
+                - **Improved preprocessing** for better emotion recognition
+                - **Face padding** for better context in emotion detection
                 
-                ### Technical Details
+                ### 🚀 Performance Optimizations
+                - **Removed problematic live camera** feature
+                - **Streamlined interface** for better user experience
+                - **Better error handling** and user feedback
                 
-                - **Model:** Fine-tuned emotion classification model
-                - **Architecture:** Deep convolutional neural network
-                - **Training:** Specialized dataset for facial emotion recognition
-                - **Face Detection:** OpenCV Haar Cascade classifier
-                - **Real-time Processing:** Optimized for live webcam inference
+                ## 📚 Supported Emotions
                 
-                ### Use Cases
-                
-                - **Human-Computer Interaction:** Emotion-aware interfaces
-                - **Market Research:** Analyze customer emotional responses
-                - **Healthcare:** Monitor patient emotional states
-                - **Education:** Assess student engagement and understanding
-                - **Entertainment:** Emotion-responsive gaming and media
-                - **Security:** Detect emotional distress or suspicious behavior
+                - 😠 **Angry** - Expressions of anger, frustration
+                - 🤢 **Disgust** - Expressions of revulsion or distaste  
+                - 😨 **Fear** - Expressions of fear, anxiety
+                - 😊 **Happy** - Expressions of joy, contentment
+                - 😢 **Sad** - Expressions of sadness, sorrow
+                - 😲 **Surprise** - Expressions of surprise, amazement
+                - 😐 **Neutral** - Calm, neutral expressions
                 
-                ### Privacy & Ethics
+                ## 💡 Tips for Best Results
                 
-                - All processing is done locally in your browser
-                - No images are stored or transmitted to external servers
-                - Use responsibly and respect privacy in all applications
-                - Consider bias and fairness in emotion detection systems
+                1. **Use clear, well-lit images** with visible faces
+                2. **Adjust confidence threshold** if you get too many/few results
+                3. **Modify minimum face size** based on your image resolution
+                4. **Frontal face views** work better than profile shots
+                5. **Avoid heavily shadowed or blurry faces**
                 
-                ### Performance Tips
+                ## 🔧 Troubleshooting
                 
-                - Ensure good lighting for best results
-                - Face should be clearly visible and unobstructed
-                - Works best with frontal face views
-                - Multiple faces in one image are supported
+                - **No faces detected?** Try lowering the minimum face size
+                - **Too many false detections?** Increase the minimum face size or confidence threshold
+                - **Missing obvious faces?** Lower the confidence threshold
+                - **Multiple boxes on same face?** The system should automatically merge them now
                 
                 ---
                 
-                **Model Repository:** [abhilash88/face-emotion-detection](https://huggingface.co/abhilash88/face-emotion-detection)
-                
-                Made with ❤️ for emotion AI research and applications
+                **Model:** [abhilash88/face-emotion-detection](https://huggingface.co/abhilash88/face-emotion-detection)
                 """
             )
         
         # Event handlers
-        analyze_single_btn.click(
-            fn=process_single_image,
-            inputs=single_image_input,
-            outputs=[single_image_output, single_result_text],
-            api_name="analyze_single_image"
-        )
-        
-        # Live webcam detection handlers
-        start_detection_btn.click(
-            fn=process_webcam_frame,
-            inputs=[webcam_input, confidence_threshold],
-            outputs=[webcam_output, webcam_result_text],
-            api_name="start_detection"
-        )
-        
-        # Auto-detection when camera input changes
-        webcam_input.change(
-            fn=lambda img, auto, threshold: process_webcam_frame(img, threshold) if auto and img is not None else (None, "Auto-detection disabled or no image"),
-            inputs=[webcam_input, auto_detect_checkbox, confidence_threshold],
-            outputs=[webcam_output, webcam_result_text]
-        )
-        
-        stop_detection_btn.click(
-            fn=lambda: (None, "🛑 Detection stopped"),
-            outputs=[webcam_output, webcam_result_text]
+        analyze_btn.click(
+            fn=process_image,
+            inputs=[image_input, confidence_slider, face_size_slider],
+            outputs=[output_image, result_text],
+            api_name="analyze_image"
         )
         
         analyze_stats_btn.click(
             fn=get_emotion_statistics,
             inputs=stats_image_input,
             outputs=stats_output,
-            api_name="get_emotion_statistics"
+            api_name="get_statistics"
+        )
+        
+        batch_process_btn.click(
+            fn=analyze_emotions_batch,
+            inputs=batch_images_input,
+            outputs=batch_results_output,
+            api_name="batch_process"
         )
         
-        # Example images - Add more diverse examples
+        # Example images
         gr.Examples(
             examples=[
-                ["https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&h=400&fit=crop&crop=face"],  # Happy person
-                ["https://images.unsplash.com/photo-1554151228-14d9def656e4?w=400&h=400&fit=crop&crop=face"],  # Smiling woman
-                ["https://images.unsplash.com/photo-1500648767791-00dcc994a43e?w=400&h=400&fit=crop&crop=face"],  # Serious man
-                ["https://images.unsplash.com/photo-1552374196-c4e7ffc6e126?w=400&h=400&fit=crop&crop=face"],  # Surprised expression
-                ["https://images.unsplash.com/photo-1619895862022-09114b41f16f?w=400&h=400&fit=crop&crop=face"],  # Neutral expression
-                ["https://images.unsplash.com/photo-1506794778202-cad84cf45f1d?w=400&h=400&fit=crop&crop=face"],  # Confident look
-                ["https://images.unsplash.com/photo-1438761681033-6461ffad8d80?w=400&h=400&fit=crop&crop=face"],  # Friendly smile
-                ["https://images.unsplash.com/photo-1472099645785-5658abf4ff4e?w=400&h=400&fit=crop&crop=face"],  # Professional headshot
+                "https://images.unsplash.com/photo-1507003211169-0a1dd7228f2d?w=400&h=400&fit=crop&crop=face",
+                "https://images.unsplash.com/photo-1554151228-14d9def656e4?w=400&h=400&fit=crop&crop=face",
+                "https://images.unsplash.com/photo-1472099645785-5658abf4ff4e?w=400&h=400&fit=crop&crop=face",
             ],
-            inputs=single_image_input,
-            label="🖼️ Try these example images to test different emotions",
-            cache_examples=False
+            inputs=image_input,
+            label="🖼️ Try these example images"
         )
     
     return iface
 
 # Initialize and launch
 if __name__ == "__main__":
-    # Load models
-    logger.info("Initializing Face Emotion Detection System...")
+    logger.info("Initializing Improved Face Emotion Detection System...")
     
     if load_models():
         logger.info("Models loaded successfully!")
         
-        # Test the model with a simple image
-        try:
-            # Create a test image
-            test_image = Image.new('RGB', (224, 224), color='white')
-            test_result = predict_emotion(test_image)
-            logger.info(f"Model test successful. Result format: {type(test_result)}")
-            logger.info(f"Test result: {test_result}")
-        except Exception as e:
-            logger.error(f"Model test failed: {e}")
-        
-        # Create interface
         iface = create_interface()
         
-        # Launch
         iface.launch(
             share=False,
             show_error=True,
             server_name="0.0.0.0",
             server_port=7860,
-            favicon_path=None,
             show_api=True
         )
     else:
         logger.error("Failed to load models. Please check your model configuration.")
-        # Create a simple interface to show the error
         with gr.Blocks() as error_iface:
             gr.Markdown(
                 """
                 # ⚠️ Model Loading Error
                 
-                The emotion detection model failed to load. This could be due to:
-                
-                1. Network connectivity issues
-                2. Model compatibility problems
-                3. Missing dependencies
+                The emotion detection model failed to load. Please check:
                 
-                Please check the logs for more details.
+                1. Network connectivity
+                2. Model dependencies
+                3. System logs for details
                 """
             )