1-Hour Course: Face Recognition Attendance with PyQt GUI in Python using OpenCV and Computer Vision (2021)

Introduction

Welcome to this in-depth tutorial on developing a Face Recognition Attendance GUI using PyQt, OpenCV, and Python. By the end of this 1-hour course, you will have a fully functional application that can recognize faces and mark attendance in real-time.

Prerequisites
Before you begin this tutorial, make sure you have the following prerequisites:

• Basic knowledge of Python programming
• Understanding of OpenCV library
• Understanding of PyQt library
• Installed Python 3.x
• Installed OpenCV and PyQt libraries

If you are new to these technologies, I recommend going through some introductory tutorials to get familiar with them.

Setting up the Environment
First, let’s set up our environment by installing the required libraries. Open Terminal or Command Prompt and run the following commands:

pip install opencv-python
pip install PyQt5

Creating the GUI
Now, it’s time to create the Graphical User Interface (GUI) for our Face Recognition Attendance system using PyQt. Open your favorite code editor and start by importing the necessary libraries:

import sys
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton, QLabel, QGridLayout, QListWidget
from PyQt5.QtGui import QImage, QPixmap
from PyQt5.QtCore import QTimer
import cv2
import numpy as np

Next, create a class that will represent our Face Recognition Attendance GUI:

class FaceRecognitionAttendance(QWidget):
    def __init__(self):
        super().__init__()

        self.setWindowTitle("Face Recognition Attendance")
        self.setGeometry(100, 100, 800, 600)

        self.capture = cv2.VideoCapture(0)
        self.timer = QTimer(self)
        self.timer.timeout.connect(self.update_frame)
        self.timer.start(10)  # Update the frame every 10 milliseconds

        layout = QVBoxLayout()
        self.setLayout(layout)

        self.video_label = QLabel(self)
        layout.addWidget(self.video_label)

        self.names_list = QListWidget(self)
        layout.addWidget(self.names_list)

        self.names = []

        self.show()

In the __init__ method, we set the window title, geometry, and create a VideoCapture object to capture video from the default webcam. We also create a QTimer to update the video frame, set to trigger every 10 milliseconds.

Next, we create a QVBoxLayout to arrange our widgets vertically within the window. We add a QLabel to display the video feed and a QListWidget to show the names of the recognized faces.

Implementing the Face Recognition Algorithm
Now, let’s implement the face recognition algorithm using the OpenCV library. Add the following method to the FaceRecognitionAttendance class:

def update_frame(self):
        ret, frame = self.capture.read()

        if ret:
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            frame = cv2.flip(frame, 1)
            height, width, channel = frame.shape
            bytes_per_line = channel * width

            q_image = QImage(frame.data, width, height, bytes_per_line, QImage.Format_RGB888)
            pixmap = QPixmap.fromImage(q_image)
            self.video_label.setPixmap(pixmap)

In the update_frame method, we read a frame from the webcam, convert it to RGB format, and display it in the QLabel widget.

Adding Face Recognition Logic
Next, let’s add the face recognition logic to detect faces and mark attendance. Add the following method to the FaceRecognitionAttendance class:

def recognize_faces(self, frame):
        face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(gray, 1.3, 5)

        for (x, y, w, h) in faces:
            cv2.rectangle(frame, (x, y), (x+w, y+h), (255, 0, 0), 2)
            face_roi = frame[y:y+h, x:x+w]

            name = "Unknown"
            # Perform face recognition

            self.names_list.addItem(name)

In the recognize_faces method, we first load the Haar cascade classifier for face detection. We then detect faces in the frame, draw a rectangle around each face, and extract the face ROI (Region of Interest).

For now, we are assigning the name "Unknown" to each detected face. You can replace this with a face recognition algorithm like LBPH or Eigenfaces to accurately recognize faces.

Running the Application
To run the Face Recognition Attendance GUI, create an instance of the FaceRecognitionAttendance class and start the Qt application event loop:

if __name__ == "__main__":
    app = QApplication(sys.argv)
    window = FaceRecognitionAttendance()
    sys.exit(app.exec_())

Save your code as face_recognition_attendance.py and run it using the following command in Terminal or Command Prompt:

python face_recognition_attendance.py

Conclusion
Congratulations! You have successfully developed a Face Recognition Attendance GUI using PyQt, OpenCV, and Python. In this tutorial, you learned how to create a GUI, capture video from the webcam, implement face recognition logic, and mark attendance in real-time.

Feel free to customize the application further by adding features like database integration, automatic email notifications, or integrating with an attendance system. Keep experimenting and learning to enhance your skills in computer vision and application development. Thank you for following along with this tutorial!