DEV Community: Allan To

Detect Human Faces Using Python ( Part 2 )

Allan To — Fri, 07 Apr 2023 08:44:14 +0000

Welcome my readers!

This post is a continuation from my previous post. This post is all about how to actually implement openCV and write a simple application to detect human faces in any given pictures

Quick re-cap

Face detection is a computer technology that enables machines to identify and locate human faces in digital images. The technique can be applied in various fields such as security systems, photo editing, entertainment, and social media. OpenCV is a popular open-source computer vision library that provides tools for face detection, image processing, and machine learning.

Ok. Before we are going to the coding part, here are some requirements that you need to install

Install Python (https://www.python.org/downloads/)
Install OpenCV
pip install opencv-python
Choose an image ( note the absolute path of the image for reference )

After you have installed all of the requirements, here is a complete application.

import cv2

face_cascade=cv2.CascadeClassifier(cv2.data.haarcascades + "haarcascade_frontalface_default.xml") #Note the change

img = cv2.imread("yourpathtoimage")

gray_img=cv2.cvtColor(img,cv2.COLOR_BGR2GRAY)

faces=face_cascade.detectMultiScale(gray_img, scaleFactor=1.05,minNeighbors=5)

for x, y, w, h in faces:
 img=cv2.rectangle(img,(x,y),(x+w,y+h),(0,255,0),3)

resized=cv2.resize(img,(int(img.shape[1]/3), int(img.shape[0]/3))) 

cv2.imshow("Deteced-face",resized)

cv2.waitKey(0)

cv2.destroyAllWindows()

It is the simplest application to detect human faces in python. Let's break this block of code down for further understanding.

Importing the Required Libraries:
Open a Python file and import the required libraries as shown below:

import cv2

Loading the Pre-Trained Face Detection Classifier:

OpenCV provides a pre-trained face detection classifier, which is a XML file containing features of the face. Download the classifier from the OpenCV website:

https://github.com/opencv/opencv/blob/master/data/haarcascades/haarcascade_frontalface_default.xml

Save the file in the same directory as your Python file. Now, load the classifier as shown below:

face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml')

Loading the Image:

Load the image you want to detect faces from using the cv2.imread() function as shown below:

img = cv2.imread('image.jpg')

Converting the Image to Grayscale:

Convert the loaded image to grayscale using the cv2.cvtColor() function as shown below:

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

Detecting Faces:

Now, we can detect faces in the grayscale image using the detectMultiScale() function of the face_cascade object as shown below:

faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

Here, the scaleFactor, minNeighbors, and minSize parameters are used to adjust the sensitivity and accuracy of the face detection algorithm. The detectMultiScale() function returns a list of rectangular coordinates (x, y, w, h) of each detected face.

Displaying the Image with Detected Faces

Finally, we need to display the original image with the detected faces. We can use thecv2.imshow()function to display the image and the cv2.waitKey() function to wait for a keyboard event before closing the window.

cv2.imshow('Detected Faces', img) cv2.waitKey(0) cv2.destroyAllWindows()

This code will display the original image with rectangles drawn around each detected face. The window will stay open until a key is pressed, after which it will close.

*Running that app and we will have this: *

Tips for fixing bugs as you go through

pip : the term 'pip' is not recognized as the name of a cmdlet, function, script file, or operable program. check the spelling of the name, or if a path was included, verify that the path is correct and try again.

_Follow this YT video and you can fix it: _https://www.youtube.com/watch?v=xdj0mGmuNjc

Python was not found; run without arguments to install from the Microsoft Store, or disable this shortcut from Settings > Manage App Execution Aliases.

Go to App Execution Aliases and turn off Python alias

SyntaxError: (unicode error) 'unicodeescape' codec can't decode bytes in position 2-3: truncated \UXXXXXXXX escape

This error occurs when you use the backslash instead of forward slash in the path for the image. So just use forward slash. :)

Hope you find something interesting here and thanks for your reading :)

Detect human faces using Python

Allan To — Mon, 27 Feb 2023 05:35:31 +0000

SOME GENERAL INSIGHTS ABOUT THIS POST
This post will cover all of the fundamental knowledge about AI in general as well as the library and language recommended to create a detect human faces application.

ARTIFICIAL INTELLIGENCE IN A NUTSHELL
Artificial intelligence has made significant advancements in computer vision, or the capacity of computers to comprehend and interpret images and movies, in recent years. Face detection, which is the act of identifying and locating human faces in an image or video, is one typical use of computer vision. This article will discuss how to utilize Python's artificial intelligence library to recognize human faces.

Let's first talk about the idea of artificial intelligence. Artificial intelligence is the capacity of machines to carry out operations that ordinarily require human intelligence, such as comprehending speech, recognize natural language, and forming judgements based on facts. Machine learning is a branch of artificial intelligence that deals with the process of teaching a computer system to make predictions based on data

Using a variety of algorithms, models, and methodologies, machine learning enables a computer to learn and enhance its performance over time. In order to find patterns in the data and create predictions based on those patterns, these algorithms employ statistical techniques.

Image and video analysis can be solved using machine learning, which is a potent technique. Machine learning techniques can be used to recognize faces, track motion, and identify objects in the field of computer vision.

SO WHAT IS HUMAN FACE DETECTION?

The detection of human faces in an image is a classic machine learning problem that may be solved using a number of well-liked algorithms. The Viola-Jones algorithm, which was created in 2001 by Paul Viola and Michael Jones, is one of the most frequently used algorithms. The eyes, nose, and mouth are among the traits that this programme looks for using a method known as Haar cascades.

WHAT IS OPENCV ( PYTHON LIBRARY ) AND WHY SHOULD WE USE IT

A well-liked open-source Python package for computer vision and image processing is called OpenCV (Open Source Computer Vision). It provides a variety of capabilities, including as face detection, for image and video analysis.

Pros:

Accuracy: OpenCV's face detection algorithm has been thoroughly tested on a wide range of images and is incredibly accurate.

Performance: For real-time applications, OpenCV offers quick speed thanks to its high level of optimization.

Simple and intuitive API provided by OpenCV makes it simple to use and comprehend.

Cross-platform: OpenCV can be used on Windows, macOS, and Linux as well as other operating systems because it is cross-platform.

Strong developer community: OpenCV has a sizable and active developer community, making it simple to obtain assistance and support.

Cons:

Training: Although OpenCV offers pre-trained models for face identification, it can be difficult to train your own models.

False positives: On occasion, the face identification algorithm in OpenCV may mistakenly recognise non-faces as faces.

Difficult configuration: Setting up OpenCV needs a process that can be challenging for beginners.

Restricted application: The face detection method in OpenCV is only effective on frontal faces; it may not be as effective on side profiles or other positions.

Problems with dependencies: OpenCV needs dependencies like NumPy and Matplotlib, which might complicate installation and configuration.

SO WHY PYTHON?

Python is a popular programming language used for various applications, including computer vision and image processing. Here are some reasons why Python is a good choice for detecting human faces:

Large number of libraries: Python has a large number of libraries and frameworks for computer vision and image processing, including OpenCV, Dlib, and TensorFlow, which can make it easier to detect human faces.

Easy to read and write: Python has a simple syntax and is easy to read and write, making it easier for developers to create and maintain code for detecting human faces.

Cross-platform compatibility: Python is cross-platform and can run on various operating systems, including Windows, macOS, and Linux, making it accessible for developers on different platforms.

Extensive community support: Python has a large and active community of developers, which means that you can find help and support easily.

Integration with other languages: Python can be integrated with other languages such as C++ and Java, which can help developers optimize performance and increase the speed of the face detection process.

Prototyping: Python is a great language for rapid prototyping, which is important when developing new face detection algorithms or improving existing ones.

Overall, Python is a powerful programming language for detecting human faces, with a large number of libraries, cross-platform compatibility, and a strong community support. These factors make it an excellent choice for developers who want to create robust and accurate face detection systems.

_OK. HERE IS HOW _

Install OpenCV: If you haven't already, install the OpenCV library by running the following command in your terminal: pip install opencv-python.

Load the image: Use the OpenCV imread() function to load the image into memory. For example: img = cv2.imread('image.jpg').

Convert the image to grayscale: Convert the image to grayscale using the OpenCVcvtColor() function. This is necessary because the Viola-Jones algorithm requires grayscale images. For example: gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY).

Load the face detection model: Use the OpenCV CascadeClassifier()function to load the pre-trained face detection model. For example: face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_default.xml').
Detect faces: Use the detectMultiScale() method of the face detection model to detect human faces in the grayscale image. This method returns a list of rectangles that represent the bounding boxes of the detected faces. For example: faces = face_cascade.detectMultiScale(gray, scaleFactor=1.1, minNeighbors=5).

Draw bounding boxes: Use the OpenCV rectangle() function to draw a bounding box around each detected face. For example:

for (x, y, w, h) in faces:
    cv2.rectangle(img, (x, y), (x + w, y + h), (0, 255, 0), 2)

Display the image: Use the OpenCV imshow()function

Other library implementation

Dlib:

import dlib
import cv2

detector = dlib.get_frontal_face_detector()
img = cv2.imread('test_image.jpg')

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

faces = detector(gray)

for face in faces:
    x, y, w, h = face.left(), face.top(), face.right(), face.bottom()
    cv2.rectangle(img, (x, y), (w, h), (255, 0, 0), 2)

cv2.imshow('img', img)
cv2.waitKey()

TensorFlow

import tensorflow as tf
import cv2

model = tf.keras.models.load_model('face_detection_model.h5')
img = cv2.imread('test_image.jpg')

input_data = cv2.resize(img, (224, 224))
input_data = input_data.reshape((1, 224, 224, 3))
input_data = input_data / 255.0

predictions = model.predict(input_data)

for box in predictions[0]:
    x, y, w, h = box
    x *= img.shape[1]
    y *= img.shape[0]
    w *= img.shape[1]
    h *= img.shape[0]
    cv2.rectangle(img, (int(x), int(y)), (int(w), int(h)), (255, 0, 0), 2)

cv2.imshow('img', img)
cv2.waitKey()

Helpful links for further study
Simple Application: https://www.youtube.com/watch?v=5cg_yggtkso
Deep Applicaton: https://www.youtube.com/watch?v=N_W4EYtsa10

Thanks for reading this post! Hope you find something interest here