[interface] pyqt5 and swing transformer for face recognition

be based on python, Use pyqt5 Module and swin transformer Detection algorithm for face recognition

Tools

Language ：
python
Main library ：
pyqt5
Test model ：
swin transformer

Core code

import time, cv2
from PyQt5 import QtCore, QtGui, QtWidgets
from PyQt5.QtCore import *
from PyQt5.QtGui import *
from PyQt5.QtWidgets import QFileDialog, QMainWindow
from PyQt5.QtCore import QTimer, QDateTime
from PyQt5.Qt import QThread, pyqtSignal, QMutex
import qimage2ndarray
from queue import Queue
from Project import Ui_Form
from infer import *

video_steam = Queue()

class Thread1(QThread):        #  Threads 1
    #  Use custom signals , Remember that signals are class variables , Must be defined in the class , Cannot define... In an instance method ,
    thread1_signal2 = pyqtSignal(object)   # Defining signals , Define the parameter as object type 

    def __init__(self):
        super(Thread1, self).__init__()
        self.t = 0
        self.Image_thread1 = None
        self.mutex = QMutex()            #  Create thread lock 
        self._isPause = False

    def run(self):
        while True:
            self.mutex.lock()            #  Lock 
            time.sleep(0.001)            #  Sleep 
            _, frame = cap.read()
            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            self.Image_thread1 = frame
            self.thread1_signal2.emit(self.Image_thread1)    #  Signal transmission 
            self.mutex.unlock()          #  Unlock 


class Thread2(QThread):         #  Threads 2
    thread1_signal3 = pyqtSignal(object)

    def __init__(self):
        super(Thread2, self).__init__()
        self.t = 0
        self.Image_thread1 = None
        self.mutex = QMutex()
        self._isPause = False
        self.video_flag = 0

    def run(self):
        while True:
            self.mutex.lock()
            time.sleep(0.001)
            # time.sleep(1 / self.a)  Change the frame rate here 
            _, frame = cap.read()
            config_file = 'mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_1x_coco.py'
            checkpoint_file = 'epoch_100.pth'
            classes = ['The color of silica gel is abnormal', 'The color of silica gel is normal', 'The door is open',
                       'The door is close', 'breakage', 'dirt', 'rust', 'foreign object', 'oil leakage', 'animal',
                       'hat', 'person']
            model = init_detector(config_file, checkpoint_file, device='cuda:0')
            frame, result_label = InferResult(frame, config_file, checkpoint_file, classes, model)

            frame = cv2.cvtColor(frame, cv2.COLOR_BGR2RGB)
            if self.video_flag == 0:
                video_steam.put(frame)
            self.Image_thread1 = frame
            self.thread1_signal3.emit(self.Image_thread1)
            self.mutex.unlock()


class PyQtMainEntry(QMainWindow, Ui_Form):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.mark = 0
        self.btnReadImage.clicked.connect(self.btnReadImage_Clicked)
        self.btnShowCamera.clicked.connect(self.btnOpenCamera_Clicked)
        self.btnStartLabel.clicked.connect(self.startRecognize)
        self.btnSaveResult.clicked.connect(self.resultsave)
        self.time()


    def btnReadImage_Clicked(self):
        self.mark = 0
        filename,  _ = QFileDialog.getOpenFileName(self, ' open ')
        if filename:
            self.captured = cv2.imread(str(filename))
            self.captured = cv2.cvtColor(self.captured, cv2.COLOR_BGR2RGB)
            rows, cols, channels = self.captured.shape
            bytesPerLine = channels * cols
            QImg = QImage(self.captured.data, cols, rows, bytesPerLine, QImage.Format_RGB888)
            self.Videolabel.setPixmap(QPixmap.fromImage(QImg).scaled(
            self.Videolabel.size(), Qt.KeepAspectRatio, Qt.SmoothTransformation))
            self.Videolabel.setScaledContents(True)

    def btnOpenCamera_Clicked(self):
        self.mark = 1
        self.process_thread = Thread2()
        self.process_thread.thread1_signal3.connect(self.thread2_work2)
        self.preview_thread = Thread1()
        self.preview_thread.thread1_signal2.connect(self.thread1_work2)
        self.preview_thread.start()

    def thread1_work2(self, img):
        self.Image = img
        qimg = qimage2ndarray.array2qimage(img)
        self.Videolabel.setPixmap(QPixmap(qimg))
        self.Videolabel.show()
        self.Videolabel.setScaledContents(True)

    def thread2_work2(self, img):
        self.Image = img
        qimg = qimage2ndarray.array2qimage(img)
        self.DetectImagelabel.setPixmap(QPixmap(qimg))
        self.DetectImagelabel.show()
        self.DetectImagelabel.setScaledContents(True)
        self.Videolabel_2.setPixmap(QPixmap(qimg))
        self.Videolabel_2.show()
        self.Videolabel_2.setScaledContents(True)

    def startRecognize(self):
        if self.mark == 0:
            img = self.captured
            config_file = 'mask_rcnn_swin_tiny_patch4_window7_mstrain_480-800_adamw_1x_coco.py'
            checkpoint_file = 'epoch_100.pth'
            classes = ['The color of silica gel is abnormal', 'The color of silica gel is normal', 'The door is open',
                       'The door is close', 'breakage', 'dirt', 'rust', 'foreign object', 'oil leakage', 'animal',
                       'hat', 'person']
            model = init_detector(config_file, checkpoint_file, device='cuda:0')
            draw_1, result_label = InferResult(img, config_file, checkpoint_file, classes, model)

            self.result = draw_1
            draw_2 = qimage2ndarray.array2qimage(draw_1)
            self.DetectImagelabel.setPixmap(QPixmap(draw_2))
            self.DetectImagelabel.setScaledContents(True)
            self.DetectImagelabel.show()
        else:
            self.process_thread.start()


    #  Display time 
    def showCurrentTime(self, timeLabel):
        time = QDateTime.currentDateTime()
        self.timeDisplay = time.toString('yyyy-MM-dd hh:mm:ss dddd')
        timeLabel.setText(self.timeDisplay)

    def time(self):
        self.timer = QTimer()
        self.timer.timeout.connect(lambda: self.showCurrentTime(self.label_2))
        self.timer.start()

    def resultsave(self):
        path_filename = QFileDialog.getExistingDirectory(self, ' Save the results ')
        if path_filename:
            self.saveImage = cv2.cvtColor(self.result, cv2.COLOR_RGB2BGR)
            cv2.imwrite(path_filename + '/' + self.timeDisplay[:10]
                       + '_' + str(10) + '.png', self.saveImage)
        #  According to the path 
        self.PathLineEdit.setText(path_filename)


if __name__ == "__main__":
    import sys
    app = QtWidgets.QApplication(sys.argv)
    cap = cv2.VideoCapture(0)
    window = PyQtMainEntry()
    window.show()
    sys.exit(app.exec_())

Running results

Source code

https://download.csdn.net/download/qq_44747572/85757863