updated README and link to README

README.md

@@ -1,5 +1,5 @@
 ---
-title: Sentiment Analyzer
+title: Computer Vision Playground
 emoji: 🦀
 colorFrom: indigo
 colorTo: blue
@@ -10,12 +10,198 @@ pinned: false
 license: mit
 ---
 
-# Facial Sentiment Analysis with Streamlit
+# Computer Vision Playground
 
-This Streamlit application streams video from the webcam, analyzes facial sentiment, and displays the results in real-time.
+This Streamlit application streams video from the webcam, analyzes facial sentiment, and displays the results in real-time. It serves as a playground for computer vision projects, with an example facial sentiment analysis demo.
 
 ## 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`
+3. Run the application: `streamlit run app.py`
+
+## Create Your Own Analysis Space
+
+Follow these steps to set up and modify the application for your own image analysis:
+
+### Step 1: Clone the Repository
+
+First, you need to clone the repository to your local machine. Open your terminal or command prompt and run:
+
+```sh
+git clone https://huggingface.co/spaces/eusholli/computer-vision-playground
+cd computer-vision-playground
+```
+
+
+### Step 2: Install Dependencies
+
+Make sure you have Python installed on your machine. You can download it from [python.org](https://www.python.org/).
+
+Next, install the required packages. In the terminal, navigate to the cloned repository directory and run:
+
+```sh
+pip install -r requirements.txt
+```
+
+This will install all the necessary libraries specified in the \`requirements.txt\` file.
+
+### Step 3: Run the Application
+
+To start the Streamlit application, run:
+
+```sh
+streamlit run app.py
+```
+
+This will open a new tab in your default web browser with the Streamlit interface.
+
+### Step 4: Using the Application
+
+#### Webcam Stream
+
+- Allow access to your webcam when prompted.
+- You will see the live stream from your webcam in the "Input Stream" section.
+- The application will analyze the video frames in real-time and display the sentiment results in the "Analysis" section.
+
+#### Uploading Images
+
+- In the "Input Stream" section, under "Upload an Image", click on the "Choose an image..." button.
+- Select an image file (jpg, jpeg, png) from your computer.
+- The application will analyze the uploaded image and display the sentiment results.
+
+#### Image URL
+
+- In the "Input Stream" section, under "Or Enter Image URL", paste an image URL and press Enter.
+- The application will download and analyze the image from the provided URL and display the sentiment results.
+
+#### Uploading Videos
+
+- In the "Input Stream" section, under "Upload a Video", click on the "Choose a video..." button.
+- Select a video file (mp4, avi, mov, mkv) from your computer.
+- The application will analyze the video frames and display the sentiment results.
+
+#### Video URL
+
+- In the "Input Stream" section, under "Or Enter Video Download URL", paste a video URL and press Enter.
+- The application will download and analyze the video from the provided URL and display the sentiment results.
+
+### Step 5: Customize the Analysis
+
+You can customize the analysis function to perform your own image analysis. The default function \`analyze_frame\` performs facial sentiment analysis. To use your own analysis:
+
+1. Replace the contents of the \`analyze_frame\` function in \`app.py\` with your custom analysis code.
+2. Update any necessary imports at the top of the \`app.py\` file.
+3. Adjust the \`ANALYSIS_TITLE\` variable to reflect your custom analysis.
+
+Example:
+
+```python
+ANALYSIS_TITLE = "Custom Analysis"
+
+def analyze_frame(frame: np.ndarray):
+    # Your custom analysis code here
+    ...
+```
+
+### Troubleshooting
+
+If you encounter any issues:
+
+- Ensure all dependencies are correctly installed.
+- Check that your webcam is working and accessible.
+- Verify the URLs you provide are correct and accessible.
+
+For more detailed information, refer to the comments in the \`app.py\` file.
+
+# How to Create a New Huggingface Space and Push Code to It
+
+## Step 1: Create a New Huggingface Space
+1. Log in to your [Huggingface](https://huggingface.co/) account.
+2. Go to the [Spaces](https://huggingface.co/spaces) section.
+3. Click on the **Create new Space** button.
+4. Fill in the details for your new Space:
+    - **Space name**: Choose a unique name for your Space.
+    - **Owner**: Ensure your username is selected.
+    - **Visibility**: Choose between Public or Private based on your preference.
+    - **SDK**: Select the SDK you will use (in this case`streamlit`).
+5. Click on the **Create Space** button to create your new Space.
+
+## Step 2: Change the Local Git Remote Repo Reference
+1. Open your terminal or command prompt.
+2. Navigate to your local project directory:
+    ```bash
+    cd /path/to/your/project
+    ```
+3. Remove the existing remote reference (if any):
+    ```bash
+    git remote remove origin
+    ```
+4. Add the new remote reference pointing to your newly created Huggingface Space. Replace `<your-username>` and `<your-space-name>` with your actual Huggingface username and Space name:
+    ```bash
+    git remote add origin https://huggingface.co/spaces/<your-username>/<your-space-name>.git
+    ```
+
+## Step 3: Add, Commit, and Push the Code to the New Space
+1. Stage all the changes in your local project directory:
+    ```bash
+    git add .
+    ```
+2. Commit the changes with a meaningful commit message:
+    ```bash
+    git commit -m "Initial commit to Huggingface Space"
+    ```
+3. Push the changes to the new Huggingface Space:
+    ```bash
+    git push origin main
+    ```
+
+> **Note**: If your default branch is not `main`, replace `main` with the appropriate branch name in the push command.
+
+## Conclusion
+You have now successfully created a new Huggingface Space, updated your local Git remote reference, and pushed your code to the new Space. You can verify that your code has been uploaded by visiting your Huggingface Space's URL.
+
+## Webcam STUN/TURN Server
+
+When running remotely on Huggingface, the code needs to access your remote webcam. It does this using the [streamlit-webrtc](https://github.com/whitphx/streamlit-webrtc) module but requires a Twilio account to be established and the credentials uploaded to the Huggingface space.
+
+### How to Create a Free Twilio Account and Add Credentials to Huggingface Space Settings
+
+#### Step 1: Create a Free Twilio Account
+1. Go to the [Twilio Sign-Up Page](https://www.twilio.com/try-twilio).
+2. Fill in your details to create a new account.
+3. Verify your email address and phone number.
+4. After verification, log in to your Twilio dashboard.
+
+#### Step 2: Obtain `TWILIO_ACCOUNT_SID` and `TWILIO_AUTH_TOKEN`
+1. In the Twilio dashboard, navigate to the **Console**.
+2. Look for the **Account Info** section on the dashboard.
+3. Here, you will find your `Account SID` (referred to as `TWILIO_ACCOUNT_SID`).
+4. To obtain your `Auth Token` (referred to as `TWILIO_AUTH_TOKEN`), click on the **Show** button next to the `Auth Token`.
+
+#### Step 3: Add Twilio Credentials to Huggingface Space Settings
+1. Log in to your [Huggingface](https://huggingface.co/) account.
+2. Navigate to your Huggingface Space where you need to add the credentials.
+3. Go to the **Settings** of your Space.
+4. In the **Variables and secrets** section:
+    - Click on the **New variable** button to add `TWILIO_ACCOUNT_SID`:
+        - Name: `TWILIO_ACCOUNT_SID`
+        - Value: Copy your `Account SID` from the Twilio dashboard and paste it here.
+    - Click on the **New secret** button to add `TWILIO_AUTH_TOKEN`:
+        - Name: `TWILIO_AUTH_TOKEN`
+        - Value: Copy your `Auth Token` from the Twilio dashboard and paste it here.
+
+5. Save the changes.
+
+You have now successfully added your Twilio credentials to the Huggingface Space settings. Your application should now be able to access and use the Twilio API for WebRTC functionality.
+
+
+
+
+### Contributing
+
+We welcome contributions! If you have suggestions or improvements, feel free to open an issue or submit a pull request.
+
+### License
+
+This project is licensed under the MIT License.

app.py

@@ -1,3 +1,5 @@
+import torch
+import tensorflow as tf
 import time
 import os
 import logging
@@ -38,12 +40,10 @@ result_queue: "queue.Queue[List[Detection]]" = queue.Queue()
 
 # Appropriate imports needed for analysis
 
-from mtcnn import MTCNN  # Import MTCNN for face detection
-from PIL import Image, ImageDraw  # Import PIL for image processing
-from transformers import pipeline  # Import Hugging Face transformers pipeline
 
 # Initialize the Hugging Face pipeline for facial emotion detection
-emotion_pipeline = pipeline("image-classification", model="trpakov/vit-face-expression")
+emotion_pipeline = pipeline("image-classification",
+                            model="trpakov/vit-face-expression")
 
 
 # Default title - "Facial Sentiment Analysis"
@@ -76,8 +76,9 @@ def analyze_frame(frame: np.ndarray):
     results = mtcnn.detect_faces(frame)  # Detect faces in the frame
     for result in results:
         x, y, w, h = result["box"]  # Get the bounding box of the detected face
-        face = frame[y : y + h, x : x + w]  # Extract the face from the frame
-        sentiment = analyze_sentiment(face)  # Analyze the sentiment of the face
+        face = frame[y: y + h, x: x + w]  # Extract the face from the frame
+        # Analyze the sentiment of the face
+        sentiment = analyze_sentiment(face)
         result["label"] = sentiment
         # Draw a rectangle around the face
         cv2.rectangle(frame, (x, y), (x + w, y + h), (0, 0, 255), LINE_SIZE)
@@ -89,7 +90,8 @@ def analyze_frame(frame: np.ndarray):
         background_tl = (text_x, text_y - text_size[1])
         background_br = (text_x + text_size[0], text_y + 5)
         # Draw a black background for the text
-        cv2.rectangle(frame, background_tl, background_br, (0, 0, 0), cv2.FILLED)
+        cv2.rectangle(frame, background_tl, background_br,
+                      (0, 0, 0), cv2.FILLED)
         # Put the sentiment text on the image
         cv2.putText(
             frame,
@@ -105,7 +107,8 @@ def analyze_frame(frame: np.ndarray):
     execution_time_ms = round(
         (end_time - start_time) * 1000, 2
     )  # Calculate execution time in milliseconds
-    img_container["analysis_time"] = execution_time_ms  # Store the execution time
+    # Store the execution time
+    img_container["analysis_time"] = execution_time_ms
 
     result_queue.put(results)  # Put the results in the result queue
     img_container["analyzed"] = frame  # Store the analyzed frame
@@ -118,7 +121,8 @@ def analyze_frame(frame: np.ndarray):
 # uses a pre-trained emotion detection model to get emotion predictions,
 # and finally returns the most dominant emotion detected.
 def analyze_sentiment(face):
-    rgb_face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)  # Convert face to RGB format
+    # Convert face to RGB format
+    rgb_face = cv2.cvtColor(face, cv2.COLOR_BGR2RGB)
     pil_image = Image.fromarray(rgb_face)  # Convert to PIL image
     results = emotion_pipeline(pil_image)  # Run emotion detection on the image
     dominant_emotion = max(results, key=lambda x: x["score"])[
@@ -137,13 +141,11 @@ def analyze_sentiment(face):
 os.environ["FFMPEG_LOG_LEVEL"] = "quiet"
 
 # Suppress TensorFlow or PyTorch progress bars
-import tensorflow as tf
 
 tf.get_logger().setLevel("ERROR")
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
 
 # Suppress PyTorch logs
-import torch
 
 logging.getLogger().setLevel(logging.WARNING)
 torch.set_num_threads(1)
@@ -167,7 +169,8 @@ logger = logging.getLogger(__name__)
 # It converts the frame to a numpy array in RGB format, analyzes the frame,
 # and returns the original frame.
 def video_frame_callback(frame: av.VideoFrame) -> av.VideoFrame:
-    img = frame.to_ndarray(format="rgb24")  # Convert frame to numpy array in RGB format
+    # Convert frame to numpy array in RGB format
+    img = frame.to_ndarray(format="rgb24")
     analyze_frame(img)  # Analyze the frame
     return frame  # Return the original frame
 
@@ -207,6 +210,18 @@ st.markdown(
 
 # Streamlit page title and subtitle
 st.title("Computer Vision Playground")
+
+# Add a link to the README file
+st.markdown(
+    """
+    <div style="text-align: left;">
+        <p>See the <a href="https://huggingface.co/spaces/eusholli/sentiment-analyzer/blob/main/README.md" 
+        target="_blank">README</a> to learn how to use this code to help you start your computer vision exploration.</p>
+    </div>
+    """,
+    unsafe_allow_html=True,
+)
+
 st.subheader(ANALYSIS_TITLE)
 
 # Columns for input and output streams
@@ -227,7 +242,8 @@ with col1:
 
     # File uploader for images
     st.subheader("Upload an Image")
-    uploaded_file = st.file_uploader("Choose an image...", type=["jpg", "jpeg", "png"])
+    uploaded_file = st.file_uploader(
+        "Choose an image...", type=["jpg", "jpeg", "png"])
 
     # Text input for image URL
     st.subheader("Or Enter Image URL")
@@ -283,12 +299,14 @@ def publish_frame():
     analyzed = img_container["analyzed"]
     if analyzed is None:
         return
-    output_placeholder.image(analyzed, channels="RGB")  # Display the analyzed frame
+    # Display the analyzed frame
+    output_placeholder.image(analyzed, channels="RGB")
 
     time = img_container["analysis_time"]
     if time is None:
         return
-    analysis_time.text(f"Analysis Time: {time} ms")  # Display the analysis time
+    # Display the analysis time
+    analysis_time.text(f"Analysis Time: {time} ms")
 
 
 # If the WebRTC streamer is playing, initialize and publish frames
@@ -308,7 +326,8 @@ if uploaded_file is not None or image_url:
         img = np.array(image.convert("RGB"))  # Convert the image to RGB format
     else:
         response = requests.get(image_url)  # Download the image from the URL
-        image = Image.open(BytesIO(response.content))  # Open the downloaded image
+        # Open the downloaded image
+        image = Image.open(BytesIO(response.content))
         img = np.array(image.convert("RGB"))  # Convert the image to RGB format
 
     analyze_frame(img)  # Analyze the image
@@ -325,7 +344,8 @@ def process_video(video_path):
         if not ret:
             break  # Exit the loop if no more frames are available
 
-        input_placeholder.image(frame)  # Display the current frame as the input frame
+        # Display the current frame as the input frame
+        input_placeholder.image(frame)
         analyze_frame(
             frame
         )  # Analyze the frame for face detection and sentiment analysis
@@ -348,8 +368,10 @@ if uploaded_video is not None or video_url:
     if uploaded_video is not None:
         video_path = uploaded_video.name  # Get the name of the uploaded video
         with open(video_path, "wb") as f:
-            f.write(uploaded_video.getbuffer())  # Save the uploaded video to a file
+            # Save the uploaded video to a file
+            f.write(uploaded_video.getbuffer())
     else:
-        video_path = download_file(video_url)  # Download the video from the URL
+        # Download the video from the URL
+        video_path = download_file(video_url)
 
     process_video(video_path)  # Process the video