updating prj

app.py

@@ -1,49 +1,64 @@
+import streamlit as st
+from transformers import pipeline
+from PIL import Image
 import cv2
-import gradio as gr
 import numpy as np
-from fer import FER
-from moviepy.editor import VideoFileClip
-
-
-# Initialize the pre-trained detector once so you don't reinitialize on every function call.
-detector = FER(mtcnn=True)  # Optionally, you can set mtcnn to False to use a faster (but less accurate) cascade.
-
-def emotion_recognition(image):
-    """
-    Process the input image, detect emotions on faces,
-    and annotate the image with bounding boxes and emotion labels.
-    
-    Parameters:
-        image (numpy.ndarray): Input image (RGB).
-    
-    Returns:
-        numpy.ndarray: Annotated image with emotion labels.
-    """
-    # fer works with RGB images which is what Gradio provides by default.
-    results = detector.detect_emotions(image)
-    annotated_image = image.copy()
-    
-    # Loop through each detected face
-    for face in results:
-        (x, y, w, h) = face["box"]
-        # Get the dominant emotion for the detected face
-        dominant_emotion = max(face["emotions"].items(), key=lambda item: item[1])[0]
-        # Draw bounding box around face
-        cv2.rectangle(annotated_image, (x, y), (x + w, y + h), (0, 255, 0), 2)
-        # Put the emotion label above the bounding box
-        cv2.putText(annotated_image, dominant_emotion, (x, y - 10), 
-                    cv2.FONT_HERSHEY_SIMPLEX, 0.9, (36, 255, 12), 2)
-    return annotated_image
-
-# Create a Gradio Interface
-interface = gr.Interface(
-    fn=emotion_recognition,
-    inputs=gr.Image(type="numpy", label="Input Image"),
-    outputs=gr.Image(type="numpy", label="Annotated Image"),
-    title="Facial Emotion Recognition",
-    description="Upload an image and let the app detect and annotate facial emotions."
-)
-
-# Run the app locally
-if __name__ == "__main__":
-    interface.launch()
+
+# --- App Title and Description ---
+st.title("Real-Time Emotion Detection App")
+st.write("""
+This app uses a lightweight, pre-trained emotion detection model from Hugging Face to predict emotions 
+from faces in an image. You can either upload an image or use your webcam to capture an image.
+""")
+
+# --- Load the Emotion Detection Model ---
+# Cache the model loading so it isn’t reloaded on every app interaction.
+@st.cache_resource(show_spinner=False)
+def load_emotion_detector():
+    # Loads the Hugging Face image-classification pipeline with the specified model.
+    classifier = pipeline("image-classification", model="dima806/facial_emotions_image_detection")
+    return classifier
+
+classifier = load_emotion_detector()
+
+# --- Sidebar: Select Input Method ---
+st.sidebar.header("Select Input Method")
+input_method = st.sidebar.radio("Choose one:", ["Upload an Image", "Capture with Webcam"])
+
+# --- Process Image and Perform Inference ---
+def predict_emotion(image: Image.Image):
+    # Optionally, you can perform additional preprocessing (e.g., face detection or cropping) here.
+    results = classifier(image)
+    # The pipeline returns a list of dictionaries sorted by score.
+    top_prediction = results[0]
+    return top_prediction
+
+# --- Main Section: Handling Input Methods ---
+
+if input_method == "Upload an Image":
+    uploaded_file = st.file_uploader("Choose an image file", type=["jpg", "jpeg", "png"])
+    if uploaded_file is not None:
+        # Open the image file with PIL.
+        image = Image.open(uploaded_file).convert("RGB")
+        st.image(image, caption="Uploaded Image", use_column_width=True)
+        prediction = predict_emotion(image)
+        st.subheader("Prediction:")
+        st.write(f"**Emotion:** {prediction['label']}")
+        st.write(f"**Confidence:** {prediction['score']:.2f}")
+        
+elif input_method == "Capture with Webcam":
+    # st.camera_input returns an image file-like object when a picture is taken.
+    picture = st.camera_input("Capture an Image")
+    if picture is not None:
+        # Load image from the captured file.
+        image = Image.open(picture).convert("RGB")
+        st.image(image, caption="Captured Image", use_column_width=True)
+        prediction = predict_emotion(image)
+        st.subheader("Prediction:")
+        st.write(f"**Emotion:** {prediction['label']}")
+        st.write(f"**Confidence:** {prediction['score']:.2f}")
+
+# --- Optional: Additional Instructions ---
+st.write("""
+*Note: For best results in real-time detection, consider focusing the camera on your face or uploading a clear face image.*
+""")

requirements.txt

@@ -1,5 +1,4 @@
-gradio
+streamlit
+transformers
+pillow
 opencv-python
-fer
-numpy
-moviepy