基于深度卷积神经网络的人脸识别考勤系统-VGG-PYTHON-QT（2）QT相关

梦里梦外; 2022-10-12 00:45 37阅读 0赞

以下嘻嘻嘻x'x'x'x'x'x'x'x'x'x'x'x'x'x'x'x'x'x在

在这一篇中，我会对本系统的前端界面即QT部分的实现就行概述，主要分为以下几点：

1.  QT信号和槽机制
2.  QT堆叠式界面设计
3.  QT调用和显示摄像头画面/多线程程序设计
4.  QT实现tableview表格样式数据显示和操作
5.  QT实现将数据写入EXCEL

--------------------

## 1.QT信号和槽机制 ##

信号定义：信号一般用在子线程中，方便与主线程或其它线程就行数据传递和通信，在需要发出信号的类中，首先需要主动定义信号名（singoutMeg）和类型（int），类型必须对应，否则无法传递，类一般即int，string，qimage等，若为图片或结构体等即用object类型进行传递

class SaveThread(QThread):
        singoutMeg=pyqtSignal(int)
        。。。

信号发出：在线程中任何指定的时机向外发出信号，即调用前面定义好的信号传递值，在此时实际上只要考虑，什么时候发出和发出什么，不需要考虑谁接收，接收了干嘛，我觉得，这也是qt设计信号槽机制的初衷，实现前后端的显著分离，简化逻辑。

self.singoutMeg.emit(self.num)

信号绑定：在定义子线程时，就要对该线程中的信号进行事件绑定，即限定哪个或哪些方法会接收到这个信号。

self.savethread.singoutMeg.connect(self.ContinueSave)

响应信号：定义一个普通函数，传递的参数类型即为之前定义好的信号的类型，参数类型和参数数量都不能出错，变量名可以随缘修改，一旦对应的信号被发出，该函数即会立刻响应，执行对应的操作。

def ContinueSave(self,num):
        。。。

个人理解：qt信号就相当于手机号，任何人都可以通过拨号这样统一的方式，将自己这边的信息传递出去，而qt槽就是电话另一边任意一个接取该电话的人，通过电话获取具体的信息然后执行对应的操作。发信号与接信号各司其职，只通过信号这样的桥梁链接，方便逻辑设计。

--------------------

## 2.QT堆叠式界面设计 ##

QT中stackedWidget即定义了一个堆叠式的窗口，类似于浏览器的堆叠界面，虽然只显示其中一个界面，但实则多个界面都在独立运行中。

因为各个界面都可以独立运行，当然每个界面都需要独立定义和初始化，然后再将定义好的多个子界面丢入堆叠窗口中，通过self.stackedWidget.setCurrentWidget(self.stack\_edit)实现堆叠窗口中界面的切换。

class Main_window(QtWidgets.QMainWindow, Ui_MainWindow):
        def __init__(self):
            super(Main_window, self).__init__()
            self.setupUi(self)
            self.setFixedSize(self.width(),self.height())
            self.str='closed'
    
            self.stack_login=Login_Window()#定义子界面
            self.stack_login.loginSignal.connect(self.login)
            self.stack_edit=Edit_Window()#定义子界面
            self.stack_collect=Collect_Window()#定义子界面
            self.stack_collect.signout.connect(self.open_collect)
            self.stack_train=Train_Window()#定义子界面
            self.stack_train.signout.connect(self.open_train)
            self.stack_statistic=Statistic_Window()#定义子界面
    
            self.stackedWidget.addWidget(self.stack_login)#将各个界面添加到堆叠窗口
            self.stackedWidget.addWidget(self.stack_edit)
            self.stackedWidget.addWidget(self.stack_collect)
            self.stackedWidget.addWidget(self.stack_train)
            self.stackedWidget.addWidget(self.stack_statistic)
    
            self.bt_edit.clicked.connect(self.to_edit)
            self.bt_collect.clicked.connect(self.to_collect)
            self.bt_train.clicked.connect(self.to_train)
            self.bt_statistic.clicked.connect(self.to_statistic)
        def login(self, connect):
            if (connect == 'LoginSuccess'):
                self.bt_edit.setEnabled(True)
                self.bt_collect.setEnabled(True)
                self.bt_train.setEnabled(True)
                self.bt_statistic.setEnabled(True)
                self.stackedWidget.removeWidget(self.stack_login)
                self.stack_login.deleteLater()
                self.bt_login.setVisible(False)
        def to_edit(self):
            self.stackedWidget.setCurrentWidget(self.stack_edit)
        def to_collect(self):
            self.stackedWidget.setCurrentWidget(self.stack_collect)
        def to_train(self):
            self.stack_train.et_message.clear()
            self.stackedWidget.setCurrentWidget(self.stack_train)
        def to_statistic(self):
            self.stackedWidget.setCurrentWidget(self.stack_statistic)
            self.stack_statistic.load()
        def open_collect(self, str):
            self.str = str
            if str == 'opened':
                self.bt_train.setEnabled(False)
                self.bt_edit.setEnabled(False)
                self.bt_statistic.setEnabled(False)
            elif str == 'closed':
                self.bt_train.setEnabled(True)
                self.bt_edit.setEnabled(True)
                self.bt_statistic.setEnabled(True)
        def open_train(self, str):
            self.str = str
            if str == 'opened':
                self.bt_collect.setEnabled(False)
                self.bt_edit.setEnabled(False)
                self.bt_statistic.setEnabled(False)
            elif str == 'closed':
                self.bt_collect.setEnabled(True)
                self.bt_edit.setEnabled(True)
                self.bt_statistic.setEnabled(True)
        def closeEvent(self, event):
            quitMsgBox = QMessageBox()
            quitMsgBox.setWindowTitle('确认窗口')
            if(self.str=='opened'):
                quitMsgBox.setText('程序正在运行中，请先关闭程序！')
            else:
                quitMsgBox.setText('你确定退出本系统吗？')
            buttonY = QPushButton('确定')
            buttonN = QPushButton('取消')
            quitMsgBox.addButton(buttonY, QMessageBox.YesRole)
            quitMsgBox.addButton(buttonN, QMessageBox.NoRole)
            quitMsgBox.exec_()
            if quitMsgBox.clickedButton() == buttonY:
                if(self.str=='opened'):
                    event.ignore()
                else:
                    event.accept()
            else:
                event.ignore()
    if __name__ == '__main__':  # 测试
        app = QtWidgets.QApplication(sys.argv)
        main_window = Main_window()
        main_window.show()
        sys.exit(app.exec_())

--------------------

## 3.QT调用和显示摄像头画面 ##

QT主界面默认即为一个主进程，为了确保界面的稳定运行，不允许在主进程中执行耗时操作，所以各种耗时操作都需要被封装在子线程中，所以本系统为了实现摄像头画面的流畅显示，会在子线程中不断获取摄像头画面，再将其作为信号转递给主进程并刷新到界面上，同时也可以进行图像处理、保存等其它耗时操作。

首先，定义子线程，负责启动摄像头并获取摄像头画面，将其转变为qt特有的qimage类型后，再将其作为信号传递出去，以下代码中还包含图片保存的操作可以忽略。

class CvThread(QThread):
        singoutSource=pyqtSignal(QImage)
        singoutImage=pyqtSignal(object)
        def __init__(self):
            super(CvThread,self).__init__()
            self.cap = cv2.VideoCapture(0 + cv2.CAP_DSHOW)
            self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)  # 设置分辨率
            self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
        def run(self):
            self.ok=True
            self.startsave=False
            while self.cap.isOpened() and self.ok:
                ok,frame=self.cap.read()
                frame = cv2.flip(frame, 1)
                if self.startsave:
                    self.singoutImage.emit(frame)
                frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
                qimg = QImage(frame.data, frame.shape[1], frame.shape[0], QImage.Format_RGB888)
                self.singoutSource.emit(qimg)
                self.startsave=False
                cv2.waitKey(30)
        def start_save(self):
            self.startsave=True
        def end(self):
            self.ok=False
            self.cap.release()
            self.quit()

在主界面程序中，定义和初始化该子线程，即启动显示摄像头画面的子线程，并给对应信号绑定函数用以接收摄像头捕获的图像，一旦有信号发出，再接收该图像并显示到主界面上。

self.cvThread = CvThread()
    self.cvThread.singoutSource.connect(self.ShowCamera)
    self.cvThread.singoutImage.connect(self.SaveImage)
    self.cvThread.start()

def ShowCamera(self,qimg):
       self.page_camera.setPixmap(QPixmap.fromImage(qimg))

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg2Mzc0NA_size_16_color_FFFFFF_t_70][]

--------------------

以下代码包含了QT的上述主要知识点，实现了多线程的摄影图画面显示、图像保存、信息传递、进度条跟新等，可供参考。

import sys
    import os
    import cv2
    from PyQt5 import QtCore, QtGui, QtWidgets
    from PyQt5.QtCore import QThread, pyqtSignal, QTimer
    from PyQt5.QtGui import QImage, QPixmap
    from PyQt5.QtWidgets import QFileDialog, QMessageBox, QDockWidget, QListWidget, QProgressBar, QPushButton
    from docutils.nodes import classifier
    
    from db.SQL_connect import SQL
    from pyqt.pyqt_form_collect import Ui_CollectWindow
    IMAGE_NUM=100
    PATH = "E:\\PyCharm_workspace\\bishe\\TrainingData\\"
    classifier_z = cv2.CascadeClassifier('E:\\PyCharm_workspace\\bishe\haarcascades\\haarcascade_frontalface_default.xml')
    classifier_l = cv2.CascadeClassifier('E:\\PyCharm_workspace\\bishe\haarcascades\\haarcascade_profileface.xml')
    
    class SaveThread(QThread):
        singoutMeg=pyqtSignal(int)
        def __init__(self,image,num,id):
            super(SaveThread,self).__init__()
            self.image=image
            self.id=id
            self.num=num
        def run(self):
            self.path=PATH+self.id
            if not os.path.exists(self.path):
                os.mkdir(self.path)
            gray = cv2.cvtColor(self.image, cv2.COLOR_BGR2GRAY)  # 灰度化
            if self.num%5==0:
                faceRects = classifier_z.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=3, minSize=(128, 128))
            else:
                faceRects = classifier_l.detectMultiScale(gray, scaleFactor=1.2, minNeighbors=3, minSize=(128, 128))
            if len(faceRects) > 0:
                faceRect=faceRects[0]
                x,y,w,h = faceRect
                # 捕捉到的图片的名字，这里用到了格式化字符串的输出
                #image_name = '%s%d.jpg' % (path_name, num)
                image_name=self.path+'\\'+str(self.num)+'.jpg'
                image = self.image[y:y+h, x:x+w] # 将当前帧含人脸部分保存为图片，注意这里存的还是彩色图片，前面检测时灰度化是为了降低计算量；这里访问的是从y位开始到y+h-1位
                score=cv2.Laplacian(image,cv2.CV_64F).var()
                if score>120 and image.shape[0]>128:
                    cv2.imwrite(image_name, image)
                    self.singoutMeg.emit(self.num+1)
                else:
                    self.singoutMeg.emit(self.num)
            else:
                self.singoutMeg.emit(self.num)
    
    class CvThread(QThread):
        singoutSource=pyqtSignal(QImage)
        singoutImage=pyqtSignal(object)
        def __init__(self):
            super(CvThread,self).__init__()
            self.cap = cv2.VideoCapture(0 + cv2.CAP_DSHOW)
            self.cap.set(cv2.CAP_PROP_FRAME_WIDTH, 640)  # 设置分辨率
            self.cap.set(cv2.CAP_PROP_FRAME_HEIGHT, 480)
        def run(self):
            self.ok=True
            self.startsave=False
            while self.cap.isOpened() and self.ok:
                ok,frame=self.cap.read()
                frame = cv2.flip(frame, 1)
                if self.startsave:
                    self.singoutImage.emit(frame)
                frame = cv2.cvtColor(frame, cv2.COLOR_RGB2BGR)
                qimg = QImage(frame.data, frame.shape[1], frame.shape[0], QImage.Format_RGB888)
                self.singoutSource.emit(qimg)
                self.startsave=False
                cv2.waitKey(30)
        def start_save(self):
            self.startsave=True
        def end(self):
            self.ok=False
            self.cap.release()
            self.quit()
    class Collect_Window(QtWidgets.QMainWindow, Ui_CollectWindow):
        signout = pyqtSignal(str)
        def __init__(self):
            super(Collect_Window, self).__init__()
            self.setupUi(self)
            self.is_camera_opened=False
            self.bt_open.clicked.connect(self.Open_camera)
            self.bt_start.clicked.connect(self.Collect)
        def Open_camera(self):
            if self.is_camera_opened:
                self.is_camera_opened=~self.is_camera_opened
                self.bt_open.setText('打开摄像头')
                self.cvThread.end()
                self.page_camera.clear()
                self.mesage.setText('摄像头已关闭')
                self.bt_start.setEnabled(False)
                self.signout.emit('closed')
            else:
                if self.et_id.text() == '' or self.et_name.text()=='':
                    QMessageBox.warning(self, "警告", "ID和姓名不能为空，请输入！")
                    return
                elif SQL.is_exist_2(self.et_id.text(), self.et_name.text()):
                    self.is_camera_opened = ~self.is_camera_opened
                    self.signout.emit('opened')
                    self.bt_open.setText('关闭摄像头')
                    self.mesage.setText("摄像头已开启")
                    self.cvThread = CvThread()
                    self.cvThread.singoutSource.connect(self.ShowCamera)
                    self.cvThread.singoutImage.connect(self.SaveImage)
                    self.cvThread.start()
                    self.bt_start.setEnabled(True)
                else:
                    QMessageBox.warning(self, "警告", "用户信息有误，请重新输入！")
                    return
        def Collect(self):
            self.mesage.setText('开始采集')
            self.progressBar.setValue(0)
            self.num=0
            self.cvThread.start_save()
        def SaveImage(self,object):
            self.savethread=SaveThread(object,self.num,self.et_id.text())
            self.savethread.start()
            self.savethread.singoutMeg.connect(self.ContinueSave)
        def ContinueSave(self,num):
            if num<IMAGE_NUM:
                self.num=num
                self.cvThread.start_save()
                self.progressBar.setValue(self.num+1)
            else:
                self.is_camera_opened = ~self.is_camera_opened
                self.bt_open.setText('打开摄像头')
                self.cvThread.end()
                self.page_camera.clear()
                self.mesage.setText('采集完毕')
                self.bt_start.setEnabled(False)
                self.signout.emit('closed')
        def ShowCamera(self,qimg):
            self.page_camera.setPixmap(QPixmap.fromImage(qimg))
    if __name__ == '__main__':
        app = QtWidgets.QApplication(sys.argv)
        collect_window = Collect_Window()
        collect_window.show()
        sys.exit(app.exec_())

--------------------

## 4.QT实现tableview表格样式数据显示和操作 ##

self.model = QStandardItemModel()
    self.tableView.setModel(self.model)

self.model = QStandardItemModel()用于定义存放数据的模型
    self.tableView.setModel(self.model)将数据模型和tableview控件绑定

以下定义了一个函数，当数据改变后直接调用以下函数就会将数据写入tableview表格，首先从数据库获取数据的行、列、具体值等，再填充表头数据，在按行按列填入值

def load(self):
        self.listnames,self.rows,self.row,self.vol=SQL.show_statistic(self)
        self.model.setHorizontalHeaderLabels(self.listnames)
        for i in range(self.row):
            for j in range(self.vol):
                item=QStandardItem(self.rows[i][j])
                self.model.setItem(i,j,item)

以下是为表头单元格和内容单元格绑定双击事件

self.tableView.doubleClicked.connect(self.tableviewClicked)
    self.tableView.horizontalHeader().sectionDoubleClicked.connect(self.volClicked)

以下即双击单元格后触发的事件，用于筛选和标注数据，会对部分单元格就行背景色修改，实际效果如下：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg2Mzc0NA_size_16_color_FFFFFF_t_70 1][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg2Mzc0NA_size_16_color_FFFFFF_t_70 2][]

>     def tableviewClicked(self):
>             model = self.tableView.model()
>             row = self.tableView.currentIndex().row()
>             user_id=model.data(model.index(row,0))
>             user_name = model.data(model.index(row, 1))
>             self.et_id.setText(user_id)
>             self.et_name.setText(user_name)
>             self.model_2.clear()
>             self.model_2.setHorizontalHeaderLabels(['截至时间','签到时间'])
>             t=0
>             for i in range(2,self.vol):
>                 item1=QStandardItem(self.listnames[i])
>                 item2=QStandardItem(self.rows[row][i])
>                 if checktime(self.listnames[i],self.rows[row][i]):
>                     item1.setBackground(QColor(0,255,0))
>                     item2.setBackground(QColor(0,255,0))
>                     t=t+1
>                 self.model_2.setItem(i - 2, 0, item1)
>                 self.model_2.setItem(i - 2, 1, item2)
>             self.et_total.setText("累计签到%d次/%d次"%(t,self.vol-2))
>         def volClicked(self,index):
>             if(index==1 or index==0):
>                 return
>             self.et_name.clear()
>             self.et_id.setText(self.listnames[index])
>             self.model_2.clear()
>             self.model_2.setHorizontalHeaderLabels(['ID','用户名', '签到时间'])
>             t=0
>             for i in range(self.row):
>                 item1 = QStandardItem(self.rows[i][0])
>                 item2 = QStandardItem(self.rows[i][1])
>                 item3=QStandardItem(self.rows[i][index])
>                 if checktime(self.listnames[index], self.rows[i][index]):
>                     item1.setBackground(QColor(0, 255, 0))
>                     item2.setBackground(QColor(0, 255, 0))
>                     item3.setBackground(QColor(0, 255, 0))
>                     t=t+1
>                 self.model_2.setItem(i, 0, item1)
>                 self.model_2.setItem(i, 1, item2)
>                 self.model_2.setItem(i, 2, item3)
>             self.et_total.setText("累计签到%d人/%d人" % (t, self.row))

--------------------

5.QT实现将数据写入EXCEL

文件读存作为耗时操作，为了保证主进程的稳定运行，所以这部分的实现也要放在子线程中完成，主进程将表单数据传递给子线程，由子线程完成EXCEL的创建、输入和保存操作。

以下即为该子线程，在初始化定义时即要输入表格的行列和值信息，非常简洁，可以自行学习：

class ExcelThread(QThread):
        signout=pyqtSignal(str)
        def __init__(self,listnames,row,vol,rows):
            super(ExcelThread,self).__init__()
            self.listnames=listnames
            self.row=row
            self.vol=vol
            self.rows=rows
        def run(self):
            ex = xlwt.Workbook(encoding='utf-8')
            sheet1 = ex.add_sheet(u'考勤表', cell_overwrite_ok=True)
            for i in range(len(self.listnames)):
                sheet1.write(0,i,self.listnames[i])
                sheet1.col(i).width=11*256
            for i in range(self.row):
                for j in range(self.vol):
                    sheet1.write(i+1,j,self.rows[i][j])
            ex.save('C:\\Users\\cjl\\Desktop\\'+'考勤表.xls')
            self.signout.emit('导出成功,请返回桌面查看')

调用时只需要调用以下函数

def to_excel(self):
        self.bt_out.setText('正在导出。。。')
        self.bt_out.setEnabled(False)
        self.excelThread=ExcelThread(self.listnames,self.row,self.vol,self.rows)
        self.excelThread.signout.connect(self.finishout)
        self.excelThread.start()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg2Mzc0NA_size_16_color_FFFFFF_t_70]: /images/20221005/7077913bc437403f86632d83a02a2141.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg2Mzc0NA_size_16_color_FFFFFF_t_70 1]: /images/20221005/e5fc63f426cf42378ef5ffac431c8514.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80Mzg2Mzc0NA_size_16_color_FFFFFF_t_70 2]: /images/20221005/925d7936550248a091fe5c90692f5846.png