Update app.py

app.py

@@ -212,11 +212,11 @@ def process_single_image(image: Image.Image) -> Tuple[Image.Image, str]:
         logger.error(f"Error processing image: {e}")
         return image, f"Error processing image: {str(e)}"
 
-def process_webcam_frame(image: Image.Image) -> Image.Image:
-    """Process webcam frame for real-time emotion detection"""
+def process_webcam_frame(image: Image.Image) -> Tuple[Image.Image, str]:
+    """Process webcam frame for emotion detection"""
     try:
         if image is None:
-            return None
+            return None, "No image provided"
         
         # Convert PIL to numpy array
         image_np = np.array(image)
@@ -225,7 +225,7 @@ def process_webcam_frame(image: Image.Image) -> Image.Image:
         faces = detect_faces(image_np)
         
         if not faces:
-            return image
+            return image, "No faces detected in the frame"
         
         # Process each face
         emotions_list = []
@@ -240,46 +240,58 @@ def process_webcam_frame(image: Image.Image) -> Image.Image:
         # Draw results
         result_image = draw_emotion_results(image.copy(), faces, emotions_list)
         
-        return result_image
+        # 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 webcam frame: {e}")
-        return image
+        return image, f"Error processing frame: {str(e)}"
 
-def analyze_emotions_batch(images: List[Image.Image]) -> str:
-    """Analyze emotions in multiple images"""
+def analyze_emotions_batch(files) -> str:
+    """Analyze emotions in multiple uploaded files"""
     try:
-        if not images:
-            return "No images provided"
+        if not files:
+            return "No files provided"
         
         all_results = []
         
-        for idx, image in enumerate(images):
-            if image is None:
-                continue
+        for idx, file in enumerate(files):
+            try:
+                # Open the image file
+                image = Image.open(file.name)
                 
-            # Convert PIL to numpy array
-            image_np = np.array(image)
-            
-            # Detect faces
-            faces = detect_faces(image_np)
-            
-            if not faces:
-                all_results.append(f"Image {idx+1}: No faces detected")
-                continue
-            
-            # Process each face
-            image_emotions = []
-            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)
-                top_emotion = max(emotions, key=lambda x: x['score'])
-                image_emotions.append(f"{top_emotion['label']} ({top_emotion['score']:.2f})")
-            
-            all_results.append(f"Image {idx+1}: {', '.join(image_emotions)}")
+                # Convert PIL to numpy array
+                image_np = np.array(image)
+                
+                # Detect faces
+                faces = detect_faces(image_np)
+                
+                if not faces:
+                    all_results.append(f"File {idx+1} ({file.name}): No faces detected")
+                    continue
+                
+                # Process each face
+                image_emotions = []
+                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)
+                    top_emotion = max(emotions, key=lambda x: x['score'])
+                    image_emotions.append(f"{top_emotion['label']} ({top_emotion['score']:.2f})")
+                
+                all_results.append(f"File {idx+1} ({file.name}): {', '.join(image_emotions)}")
+                
+            except Exception as e:
+                all_results.append(f"File {idx+1}: Error processing - {str(e)}")
         
         return "\n".join(all_results)
         
@@ -408,18 +420,33 @@ def create_interface():
             gr.Markdown(
                 """
                 ### Real-time Emotion Detection
-                Enable your webcam to see live emotion detection in action!
+                Upload images from your camera or device to see emotion detection results!
                 """
             )
             
-            webcam_interface = gr.Interface(
-                fn=process_webcam_frame,
-                inputs=gr.Image(source="webcam", streaming=True, type="pil"),
-                outputs=gr.Image(label="Live Emotion Detection"),
-                live=True,
-                title="",
-                description=""
-            )
+            with gr.Row():
+                with gr.Column(scale=1):
+                    webcam_input = gr.Image(
+                        label="Camera Input",
+                        type="pil",
+                        height=400,
+                        sources=["webcam", "upload"]
+                    )
+                    
+                    with gr.Row():
+                        process_webcam_btn = gr.Button("Analyze Frame", variant="primary", size="lg")
+                        clear_webcam_btn = gr.Button("Clear", variant="secondary")
+                
+                with gr.Column(scale=1):
+                    webcam_output = gr.Image(
+                        label="Emotion Detection Results",
+                        height=400
+                    )
+                    webcam_result_text = gr.Textbox(
+                        label="Detection Results",
+                        lines=5,
+                        show_copy_button=True
+                    )
         
         with gr.Tab("📊 Detailed Statistics"):
             with gr.Row():
@@ -516,6 +543,18 @@ def create_interface():
             api_name="analyze_single_image"
         )
         
+        process_webcam_btn.click(
+            fn=process_webcam_frame,
+            inputs=webcam_input,
+            outputs=[webcam_output, webcam_result_text],
+            api_name="process_webcam"
+        )
+        
+        clear_webcam_btn.click(
+            fn=lambda: (None, None, ""),
+            outputs=[webcam_input, webcam_output, webcam_result_text]
+        )
+        
         analyze_stats_btn.click(
             fn=get_emotion_statistics,
             inputs=stats_image_input,
@@ -545,6 +584,16 @@ if __name__ == "__main__":
     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()
         
@@ -558,4 +607,26 @@ if __name__ == "__main__":
             show_api=True
         )
     else:
-        logger.error("Failed to load models. Please check your model configuration.")
+        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
+                
+                Please check the logs for more details.
+                """
+            )
+        
+        error_iface.launch(
+            share=False,
+            show_error=True,
+            server_name="0.0.0.0",
+            server_port=7860
+        )