Python OpenCV Real Time Smile Detection – Detect Smiles, Spread Joy

FREE Online Courses: Transform Your Career – Enroll for Free!

Real-time smile detection using OpenCV is an interesting technology that uses computer vision to identify and track human smiles in live video streams. It works by analyzing patterns and characteristics in the images or frames of the video using special algorithms that have been pre-trained to recognize smiles. This technology can have many uses, such as detecting emotions, improving the way we interact with social media and games, and enhancing security systems. As computer vision continues to develop, real-time smile detection using OpenCV is becoming more precise and effective, making it an exciting area for further research and development.

Background

Realtime smile detection using OpenCV is a technology that uses a camera to detect and highlight smiles in real time. It can be used in many applications, such as improving user experiences in mobile devices and social media apps, monitoring emotions in psychology research, and security facial recognition systems. To work effectively, the program needs to quickly and accurately process video frames captured by the camera, which requires a powerful computer and efficient algorithms. Overall, real-time smile detection using OpenCV is a fascinating technology with many potential uses in different fields.

Cascades in Smile Detection

Cascades are a type of machine learning algorithm used to detect objects in images or video frames. OpenCV has pre-trained cascade classifiers for detecting faces and smiles. To detect smiles in real-time, the program uses these classifiers to detect faces and then checks if they contain smile features. If a smile is detected, a rectangle is drawn around it, and the video frame is displayed. This process is repeated for each frame captured from the camera.

Accuracy Calculation

Accuracy = len(faces) / (len(faces) + 1e-6)

This expression calculates the accuracy by dividing the number of detected faces by the sum of the number of detected faces and a small value. The small value is added to avoid division by zero errors when there are no detected faces. By including this small value, even if no faces are detected, the accuracy will be a very small non-zero value close to zero.

Prerequisites for Real Time Smile Detection Project Using Python OpenCV

It is important to have a solid understanding of the Python programming language and the OpenCV library. Apart from this, you should have the following system requirements.

Python 3.7 (64-bit) and above
Any Python editor (VS code, Pycharm)

Download Python OpenCV Real Time Smile Detection Project

Please download the source code of Python OpenCV Real Time Smile Detection Project from the following link: Python OpenCV Real Time Smile Detection Project Code

Installation

Open Windows cmd as administrator

1. To install the opencv library, run the command from the cmd.

pip install opencv-python

Let’s Implement

To implement this, follow the below steps.

1. We need to import some libraries that will be used in our implementation.

import cv2

2. This code loads two pre-trained cascade classifiers in OpenCV for detecting faces and smiles. The first classifier detects faces in the image or video, and the second classifier detects smiles within the detected face regions.

cascade_face = cv2.CascadeClassifier("C:/Users/yoges/OneDrive/Desktop/dataflair/Harcascade/opencv-master/data/haarcascades/haarcascade_frontalface_default.xml")

cascade_smile = cv2.CascadeClassifier("C:/Users/yoges/OneDrive/Desktop/dataflair/Harcascade/opencv-master/data/haarcascades/haarcascade_smile.xml")

Output of this code

3. It Defines a function called “smile_detect”.

def smile_detect(frame):

4. This code converts a color image called “frame” to a grayscale image using OpenCV.

gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)

5. The code uses “cascade_face” to detect faces in the grayscale image “gray” with specific parameters and saves the detected faces in a numpy array called “faces”.

faces = cascade_face.detectMultiScale(gray, 1.3, 5)

6. The code processes each detected face to check if there are smiles. It does this by using the smile detection cascade on the grayscale region of interest within each face bounding box, and storing the coordinates of the detected smiles in a numpy array.

for (x,y,w,h) in faces:
        gray_roi = gray[y:y+h, x:x+w]
        color_roi = frame[y:y+h, x:x+w]
        smiles = cascade_smile.detectMultiScale(gray_roi, 1.7, 20)

7. This code draws a blue rectangle around the detected smile region on the color image.

for (sx, sy, sw, sh) in smiles:
            cv2.rectangle(color_roi, (sx, sy), (sx+sw, sy+sh), (255, 0, 0), 2)

Note:- You have to write this for loop under the 6th step for the loop

8. This code is to calculate the accuracy of a smile detection model.

accuracy = len(faces) / (len(faces) + 1e-6)  
print("Smile Detection Accuracy: ",accuracy*100, "%")

Smile Detection Accuracy: 99.99990000010001 %

9. This line of code displays the image or video frame with the detected smiles using the OpenCV imshow() function. The window title is set as “PythonGeeks”.

cv2.imshow('PythonGeeks', frame)

Note:- You have to write steps 4-8 under the function block of the 3rd step.

10. This opens the integrated camera of the laptop.

cap = cv2.VideoCapture(0)

11. This code captures video frames from the camera in a loop. For each frame, it calls the smile_detect function to detect faces and smiles. The loop continues until the user presses the ‘q’ key, at which point the program stops. The cv2.imshow function displays the video frames in a window named ‘PythonGeeks’.

while True:
    ret, frame = cap.read()
    smile_detect(frame)

    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

12. cap.release() frees the resources used to capture the video or camera stream, allowing them to be used by other applications. cv2.destroyAllWindows() closes all OpenCV windows, freeing system resources and ensuring the program ends cleanly.

cap.release()
cv2.destroyAllWindows()