initial upload

.gitignore

@@ -0,0 +1,118 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+pip-wheel-metadata/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+.hypothesis/
+.pytest_cache/
+.coverage
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or tool, you might want to ignore these files since the code is intended to run in multiple environments; 
+#   otherwise, check in the pyenv configuration files, especially if you are in an isolated environment.
+.pyenv
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies 
+#   not cross-compatible, pipenv may install dependencies that are not in line with the rest of the team.
+Pipfile.lock
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow
+__pypackages__/
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# Pycharm
+.idea/
+
+# VS Code
+.vscode/
+
+# Streamlit static files
+.streamlit/
+
+# Local environment variables
+.env
+
+# Deepface models
+. deepface_weights/
+
+# MacOS specific
+.DS_Store

README.md

@@ -1,13 +1,9 @@
----
-title: Sentiment Analyzer
-emoji: 🦀
-colorFrom: indigo
-colorTo: blue
-sdk: streamlit
-sdk_version: 1.35.0
-app_file: app.py
-pinned: false
-license: mit
----
+# Facial Sentiment Analysis with Streamlit
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+This Streamlit application streams video from the webcam, analyzes facial sentiment, and displays the results in real-time.
+
+## How to Use
+
+1. Clone the repository.
+2. Ensure you have the necessary packages installed: `pip install -r requirements.txt`
+3. Run the application: `streamlit run app.py`

app.py

@@ -0,0 +1,146 @@
+import os
+os.environ['OPENCV_AVFOUNDATION_SKIP_AUTH'] = '1'
+
+import streamlit as st
+import cv2
+import numpy as np
+from transformers import pipeline
+from PIL import Image, ImageDraw
+from mtcnn import MTCNN
+
+# Initialize the Hugging Face pipeline for facial emotion detection
+emotion_pipeline = pipeline("image-classification", model="trpakov/vit-face-expression")
+
+# Initialize MTCNN for face detection
+mtcnn = MTCNN()
+
+# Function to analyze sentiment
+def analyze_sentiment(face):
+    # Convert face to RGB
+    rgb_face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
+    # Convert the face to a PIL image
+    pil_image = Image.fromarray(rgb_face)
+    # Analyze sentiment using the Hugging Face pipeline
+    results = emotion_pipeline(pil_image)
+    # Get the dominant emotion
+    dominant_emotion = max(results, key=lambda x: x['score'])['label']
+    return dominant_emotion
+
+TEXT_SIZE = 3
+
+# Function to detect faces, analyze sentiment, and draw a red box around them
+def detect_and_draw_faces(frame):
+    # Detect faces using MTCNN
+    results = mtcnn.detect_faces(frame)
+    
+    # Draw on the frame
+    for result in results:
+        x, y, w, h = result['box']
+        face = frame[y:y+h, x:x+w]
+        sentiment = analyze_sentiment(face)
+        cv2.rectangle(frame, (x, y), (x+w, y+h), (0, 0, 255), 10)  # Thicker red box
+        
+        # Calculate position for the text background and the text itself
+        text_size = cv2.getTextSize(sentiment, cv2.FONT_HERSHEY_SIMPLEX, TEXT_SIZE, 2)[0]
+        text_x = x
+        text_y = y - 10
+        background_tl = (text_x, text_y - text_size[1])
+        background_br = (text_x + text_size[0], text_y + 5)
+        
+        # Draw black rectangle as background
+        cv2.rectangle(frame, background_tl, background_br, (0, 0, 0), cv2.FILLED)
+        # Draw white text on top
+        cv2.putText(frame, sentiment, (text_x, text_y), cv2.FONT_HERSHEY_SIMPLEX, TEXT_SIZE, (255, 255, 255), 2)
+    
+    return frame
+
+# Function to capture video from webcam
+def video_stream():
+    video_capture = cv2.VideoCapture(0)
+    if not video_capture.isOpened():
+        st.error("Error: Could not open video capture device.")
+        return
+
+    while True:
+        ret, frame = video_capture.read()
+        if not ret:
+            st.error("Error: Failed to read frame from video capture device.")
+            break
+        yield frame
+
+    video_capture.release()
+
+# Streamlit UI
+st.markdown(
+    """
+    <style>
+        .main {
+            background-color: #FFFFFF;
+        }
+        .reportview-container .main .block-container{
+            padding-top: 2rem;
+        }
+        h1 {
+            color: #E60012;
+            font-family: 'Arial Black', Gadget, sans-serif;
+        }
+        h2 {
+            color: #E60012;
+            font-family: 'Arial', sans-serif;
+        }
+        h3 {
+            color: #333333;
+            font-family: 'Arial', sans-serif;
+        }
+        .stButton button {
+            background-color: #E60012;
+            color: white;
+            border-radius: 5px;
+            font-size: 16px;
+        }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+st.title("Computer Vision Test Lab")
+st.subheader("Facial Sentiment")
+
+# Columns for input and output streams
+col1, col2 = st.columns(2)
+
+with col1:
+    st.header("Input Stream")
+    st.subheader("Webcam")
+    video_placeholder = st.empty()
+
+with col2:
+    st.header("Output Stream")
+    st.subheader("Analysis")
+    output_placeholder = st.empty()
+
+sentiment_placeholder = st.empty()
+
+# Start video stream
+video_capture = cv2.VideoCapture(0)
+if not video_capture.isOpened():
+    st.error("Error: Could not open video capture device.")
+else:
+    while True:
+        ret, frame = video_capture.read()
+        if not ret:
+            st.error("Error: Failed to read frame from video capture device.")
+            break
+
+        # Display the input stream with the red box around the face
+        video_placeholder.image(frame, channels="BGR")
+        
+        # Detect faces, analyze sentiment, and draw red boxes with sentiment labels
+        frame_with_boxes = detect_and_draw_faces(frame)
+        
+        # Display the output stream (here it's the same as input, modify as needed)
+        output_placeholder.image(frame_with_boxes, channels="BGR")
+        
+        # Add a short delay to control the frame rate
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break

app.py.safe

@@ -0,0 +1,155 @@
+import os
+os.environ['OPENCV_AVFOUNDATION_SKIP_AUTH'] = '1'
+
+import streamlit as st
+import cv2
+import numpy as np
+from transformers import pipeline
+from PIL import Image, ImageDraw
+
+# Initialize the Hugging Face pipeline for facial emotion detection using the "trpakov/vit-face-expression" model
+emotion_pipeline = pipeline("image-classification", model="trpakov/vit-face-expression")
+
+# Function to analyze sentiment
+def analyze_sentiment(face):
+    # Convert face to RGB
+    rgb_face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
+    # Convert the face to a PIL image
+    pil_image = Image.fromarray(rgb_face)
+    # Analyze sentiment using the Hugging Face pipeline
+    results = emotion_pipeline(pil_image)
+    # Get the dominant emotion
+    dominant_emotion = max(results, key=lambda x: x['score'])['label']
+    return dominant_emotion
+
+TEXT_SIZE = 3
+
+# Function to detect faces, analyze sentiment, and draw a red box around them
+def detect_and_draw_faces(frame):
+    # Convert frame to RGB
+    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    # Convert the frame to a PIL image
+    pil_image = Image.fromarray(rgb_frame)
+    # Analyze sentiment using the Hugging Face pipeline
+    results = emotion_pipeline(pil_image)
+
+    # Print the results to understand the structure
+    print(results)
+    
+    # Draw on the PIL image
+    draw = ImageDraw.Draw(pil_image)
+    
+    # Iterate through detected faces
+    for result in results:
+        box = result['box']
+        sentiment = result['label']
+        
+        # Draw rectangle and text
+        x, y, w, h = box['left'], box['top'], box['width'], box['height']
+        draw.rectangle(((x, y), (x+w, y+h)), outline="red", width=3)
+        
+        # Calculate position for the text background and the text itself
+        text_size = draw.textsize(sentiment)
+        background_tl = (x, y - text_size[1] - 5)
+        background_br = (x + text_size[0], y)
+        
+        # Draw black rectangle as background
+        draw.rectangle([background_tl, background_br], fill="black")
+        # Draw white text on top
+        draw.text((x, y - text_size[1]), sentiment, fill="white")
+    
+    # Convert back to OpenCV format
+    frame_with_boxes = cv2.cvtColor(np.array(pil_image), cv2.COLOR_RGB2BGR)
+    
+    return frame_with_boxes
+
+# Function to capture video from webcam
+def video_stream():
+    video_capture = cv2.VideoCapture(0)
+    if not video_capture.isOpened():
+        st.error("Error: Could not open video capture device.")
+        return
+
+    while True:
+        ret, frame = video_capture.read()
+        if not ret:
+            st.error("Error: Failed to read frame from video capture device.")
+            break
+        yield frame
+
+    video_capture.release()
+
+# Streamlit UI
+st.markdown(
+    """
+    <style>
+        .main {
+            background-color: #FFFFFF;
+        }
+        .reportview-container .main .block-container{
+            padding-top: 2rem;
+        }
+        h1 {
+            color: #E60012;
+            font-family: 'Arial Black', Gadget, sans-serif;
+        }
+        h2 {
+            color: #E60012;
+            font-family: 'Arial', sans-serif;
+        }
+        h3 {
+            color: #333333;
+            font-family: 'Arial', sans-serif;
+        }
+        .stButton button {
+            background-color: #E60012;
+            color: white;
+            border-radius: 5px;
+            font-size: 16px;
+        }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+st.title("Computer Vision Test Lab")
+st.subheader("Facial Sentiment")
+
+# Columns for input and output streams
+col1, col2 = st.columns(2)
+
+with col1:
+    st.header("Input Stream")
+    st.subheader("Webcam")
+    video_placeholder = st.empty()
+
+with col2:
+    st.header("Output Stream")
+    st.subheader("Analysis")
+    output_placeholder = st.empty()
+
+sentiment_placeholder = st.empty()
+
+# Start video stream
+video_capture = cv2.VideoCapture(0)
+if not video_capture.isOpened():
+    st.error("Error: Could not open video capture device.")
+else:
+    while True:
+        ret, frame = video_capture.read()
+        if not ret:
+            st.error("Error: Failed to read frame from video capture device.")
+            break
+
+        # Detect faces, analyze sentiment, and draw red boxes with sentiment labels
+        frame_with_boxes = detect_and_draw_faces(frame)
+        
+        # Display the input stream with the red box around the face
+        video_placeholder.image(frame_with_boxes, channels="BGR")
+        
+        # Display the output stream (here it's the same as input, modify as needed)
+        output_placeholder.image(frame_with_boxes, channels="BGR")
+        
+        # Add a short delay to control the frame rate
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break

app.py.sentiment-one

@@ -0,0 +1,118 @@
+import os
+os.environ['OPENCV_AVFOUNDATION_SKIP_AUTH'] = '1'
+
+import streamlit as st
+import cv2
+from transformers import pipeline
+from PIL import Image
+
+# Initialize the Hugging Face pipeline for facial emotion detection
+emotion_pipeline = pipeline("image-classification", model="dima806/facial_emotions_image_detection")
+
+# Function to analyze sentiment
+def analyze_sentiment(frame):
+    # Convert frame to RGB
+    rgb_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
+    # Convert the frame to a PIL image
+    pil_image = Image.fromarray(rgb_frame)
+    # Analyze sentiment using the Hugging Face pipeline
+    results = emotion_pipeline(pil_image)    # Analyze sentiment using the Hugging Face pipeline
+    results = emotion_pipeline(pil_image)
+    # Get the dominant emotion
+    dominant_emotion = max(results, key=lambda x: x['score'])['label']
+    return dominant_emotion
+
+# Function to capture video from webcam
+def video_stream():
+    video_capture = cv2.VideoCapture(0)
+    if not video_capture.isOpened():
+        st.error("Error: Could not open video capture device.")
+        return
+
+    while True:
+        ret, frame = video_capture.read()
+        if not ret:
+            st.error("Error: Failed to read frame from video capture device.")
+            break
+        yield frame
+
+    video_capture.release()
+
+# Streamlit UI
+st.markdown(
+    """
+    <style>
+        .main {
+            background-color: #FFFFFF;
+        }
+        .reportview-container .main .block-container{
+            padding-top: 2rem;
+        }
+        h1 {
+            color: #E60012;
+            font-family: 'Arial Black', Gadget, sans-serif;
+        }
+        h2 {
+            color: #E60012;
+            font-family: 'Arial', sans-serif;
+        }
+        h3 {
+            color: #333333;
+            font-family: 'Arial', sans-serif;
+        }
+        .stButton button {
+            background-color: #E60012;
+            color: white;
+            border-radius: 5px;
+            font-size: 16px;
+        }
+    </style>
+    """,
+    unsafe_allow_html=True
+)
+
+st.title("Computer Vision Test Lab")
+st.subheader("Facial Sentiment")
+
+# Columns for input and output streams
+col1, col2 = st.columns(2)
+
+with col1:
+    st.header("Input Stream")
+    st.subheader("Webcam")
+    video_placeholder = st.empty()
+
+with col2:
+    st.header("Output Stream")
+    st.subheader("Analysis")
+    output_placeholder = st.empty()
+
+sentiment_placeholder = st.empty()
+
+# Start video stream
+video_capture = cv2.VideoCapture(0)
+if not video_capture.isOpened():
+    st.error("Error: Could not open video capture device.")
+else:
+    while True:
+        ret, frame = video_capture.read()
+        if not ret:
+            st.error("Error: Failed to read frame from video capture device.")
+            break
+
+        # Display the input stream
+        video_placeholder.image(frame, channels="BGR")
+        
+        # Analyze sentiment
+        sentiment = analyze_sentiment(frame)
+        
+        # Display the output stream (here it's the same as input, modify as needed)
+        output_placeholder.image(frame, channels="BGR")
+        
+        # Display sentiment
+        sentiment_placeholder.write(f"Sentiment: {sentiment}")
+
+        # Add a short delay to control the frame rate
+        if cv2.waitKey(1) & 0xFF == ord('q'):
+            break
+        

requirements.txt

@@ -0,0 +1,5 @@
+streamlit
+opencv-python-headless
+numpy
+transformers
+torch

run_streamlist.sh

@@ -0,0 +1,5 @@
+#!/bin/bash
+# Set Chrome as the default browser for this session
+export BROWSER="/Applications/Google Chrome.app/Contents/MacOS/Google Chrome"
+# Run Streamlit with the provided arguments
+streamlit run "$@"