基于OpenCV实现的人脸签到系统源代码

目录

• 效果图
• 目录文件
• 总结 

效果图

目录文件

camerathread.h 功能实现全写在.h里了

class CameraThread : public QThread
{
    Q_OBJECT
public:
    CameraThread()
    {
        //打开序号为0的摄像头
        m_cap.open(0);
        if (!m_cap.isOpened()) {
            qDebug() << "Error: Cannot open camera";
        }

        //判断是否有文件,人脸识别模型，检测和识别用的
        if(!m_cascada.load("D:/research/CV/Opencv/haarcascade_frontalface_alt2.XML"))
        {
            QMessageBox::information(NULL,"失败", "人脸识别模型装载失败");
        }
        //实例化定时器，子线程中数据传输到中线程并显示出来
        m_timer = new QTimer(this);
        //绑定时间信号及获取图像帧的图像
        connect(m_timer,SIGNAL(timeout()),this,SLOT(readFarme()));
        //大概每秒24帧
        //开始定时器
        m_timer->start(42);

        //打卡模块
        // 定义 FisherFaceRecognizer 模型，训练用的模型
        m_model = LBPHFaceRecognizer::create();
        // 加载训练好的模型，自己训练的模型
        m_model->read("MyFaceLBPHModel.xml");

        if (m_model.empty())
        {
            qDebug() << "Error: Failed to load model!";
        }
        else
        {
            qDebug() << "Model loaded successfully!";
        }

        //录入时候的定时器，录入大概几秒，获取二十张灰色图像并保存，等待训练
        //实例化定时器
        m_Very_timer = new QTimer(this);

        //数据库的初始化部分
        //链接数据库
        m_db = QSqlDatabase::addDatabase("Qmysql");
        m_db.setHostName("localhost");  // 主机名
        m_db.setDatabaseName("face");  // 数据库名
        m_db.setUserName("root");  // 用户名
        m_db.setPassword("31415926");  // 密码

    }
    ~CameraThread()
    {
        //释放摄像头
        m_cap.release();
    }
    void run() override
    {


    }


    //图像数据类型转换
    QImage MatImageToQt(const cv::Mat &src)
    {
        if(src.type() == CV_8UC1)
        {
            QImage qImage(src.cols,src.rows,QImage::Format_Indexed8);
            qImage.setColorCount(256);
            for(int i = 0; i < 256; i ++)
            {
                qImage.setColor(i,qRgb(i,i,i));
            }
            uchar *pSrc = src.data;
            for(int row = 0; row < src.rows; row ++)
            {
                uchar *pDest = qImage.scanLine(row);
                memcmp(pDest,pSrc,src.cols);
                pSrc += src.step;
            }
            return qImage;
        }
        else if(src.type() == CV_8UC3)
        {
            const uchar *pSrc = (const uchar*)src.data;
            QImage qImage(pSrc,src.cols,src.rows,src.step,QImage::Format_RGB888);
            return qImage.rgbSwapped();
        }
        else if(src.tyhttp://www.devze.compe() == CV_8UC4)
        {
            const uchar *pSrc = (const uchar*)src.data;
            QImage qImage(pSrc, src.cols, src.rows, src.step, QImage::Format_ARGB32);
            return qImage.copy();
        }
        else
        {
            return QImage();
        }
    }

    //人脸检测
    void Check(Mat &image, Mat &gray)
    {
        //直方图均匀化（改善图像的对比度和亮度）
        Mat equalizedImg;
        equalizeHist(gray,equalizedImg);
        int flags = CASCADE_SCALE_IMAGE; //检测多个人

        Size minFeatureSize(30,30);
        float searchScaleFactor = 1.1f; //默认1.1倍
        int minNeighbors = 4;

        m_cascada.detectMultiScale(equalizedImg,m_faces,searchScaleFactor,minNeighbors,flags,minFeatureSize);
        m_current_people = m_faces.size();
        //检测到的个数
        //qDebug() << "检测到人脸的个数：" << m_faces.size() << endl;
        QString str;
        str.setNum(m_faces.size());
        //qDebug() << m_current_people << endl;

//        //画矩形框
        Mat face;
//        for(int i = 0; i < m_faces.size(); javascripti++)
//        {
//            if(m_faces[i].height > 0 && m_faces[i].width >0 )
//            {
//                face = gray(m_faces[i]);
//                m_text_lb = Point(m_faces[i].x,m_faces[i].y);
//                rectangle(image, m_faces[i], Scalar(50, 50, 150), 2, 8, 0); //线太细了会导致在QLabel上面丢失线框


//            }
//            int iP = Predict(image);

//        }



        // 画矩形框和显示姓名
        for(int i = 0; i < m_faces.size(); i++)
        {
            string name; // 从数据库中获取姓名
            if(m_faces[i].height > 0 && m_faces[i].width >0 )
            {
                face = gray(m_faces[i]);
                m_text_lb = Point(m_faces[i].x,m_faces[i].y);
                rectangle(image, m_faces[i], Scalar(50, 50, 150), 2, 8, 0); // 画矩形框

                //灰度图
                Mat tImagGray;
                cvtColor(image, tImagGray, COLOR_BGR2GRAY);
                // 识别人脸
                int id = Predict(tImagGray);


                if (!m_db.open())
                {
                    qDebug() << "Failed to connect to database:" ;
                }

                // 执行查询语句
                QSqlQuery query;
                QString queryString = QString("SELECT name FROM staff_info WHERE num = %1").arg(id);
                if (!query.exec(queryString))
                {
                    qDebug() << "Failed to execute query:";
                    m_db.close();
                }

                // 处理查询结果
                if (query.next())
                {
                    name = query.value(0).toString().toUtf8().constData();
                    m_db.close();
                }
                else
                {
                    m_db.close();
                    name = "Unknown";
                }
            }
                qDebug() << name.data();
                // 在图像上显示姓名
                Point textPosition(m_faces[i].x, m_faces[i].y - 10); // 文本位置在矩形框上方一点
                putText(image, name.data(), textPosition, FONT_HERSHEY_SIMPLEX, 0.5, Scalar(255, 255, 255), 1, LINE_AA);


        }

        m_faces.clear();
    }



    // 裁剪出的脸部区域的图像
    cv::Mat cropFace(const cv::Mat& faceImg, const cv::Rect& faceRect) {
        // 不再进行颜色空间转换，直接使用输入的 faceImg
        cv::Mat frame_gray = faceImg;

        // 确保矩形区域在图像范围内
        if (faceRect.x >= 0 && faceRect.y >= 0 &&
            faceRect.x + faceRect.width <= frame_gray.cols &&
            faceRect.y + faceRect.height <= frame_gray.rows)
        {
            // 使用区域选择功能提取矩形区域
            cv::Mat faceROI = frame_gray(faceRect).clone(); // 使用 clone() 来复制图像区域
            return faceROI;
        }
        else
        {
            // 处理矩形区域超出图像范围的情况
            // 这里可以选择合适的处理方式，比如调整矩形区域的大小或者放弃处理该脸部区域
            return cv::Mat();
        }
    }



    // 在文本文件末尾添加数据
    void appendToTextFile(const QString& filename, const QString& data)
    {
        QFile file(filename);
        if (file.open(QIODevice::Append | QIODevice::Text))
        {
            QTextStream out(&file);
            out << data << "\n";
            file.close();
        }
        else
        {
            qDebug() << "Failed to open file for appending.";
        }
    }

    //预测功能，检测输入的图像中的人脸是否在训练集中
    int Predict(Mat src_image)
    {
        Mat face_test;
        int ispredict = 0;
        //截取的ROI人脸尺寸调整
        if (src_image.rows >= 120)
        {
            //改变图像大小，使用双线性差值
            resize(src_image, face_test, Size(92, 112));

        }
        //判断是否正确检测ROI
        if (!face_test.empty())
        {
            //测试图像应该是灰度图
            ispredict = m_model->predict(face_test);
        }
        //cout << ispredict << endl;
        return ispredict;
    }


signals:
    //向主线程传输图像
    void Set_image(QImage *image);
    //打卡之后设置ui部分和数据库部分
    void Send_Card_Data(QSqlDatabase *m_db,QString num);

public slots:
    //摄像头读取函数
    void readFarme()
    {
        //读取一帧图像
        m_cap.read(m_src_image) ;
        //处理一下数据，人脸检测
        //生成灰度图
        Mat dst_gray;
        cvtColor(m_src_image, dst_gray, COLOR_BGR2GRAY);
        Check(m_src_image, dst_gray);

        //转换图像数据类型
        QImage imag = MatImageToQt(m_src_image);

        //发送图像
        Set_image(&imag);
    }

    //执行二十次检测人脸并保存下来的功能
    void Verity()
    {
        //判断目前摄像头中的脸有几个
        if (!m_facenum.isEmpty())
        {
            //如果目前只有一个人
            if(m_current_people == 1)
            {
                qDebug() << m_executionCount;
                //裁剪出人脸区域
                Mat faceROI = cropFace(m_src_image, m_faces[0]);
                if (!faceROI.empty())
                {
                    // 调整裁剪后的脸部图像大小
                    cv::Mat resizedFace;
                    cv::resize(faceROI, resizedFace, cv::Size(92, 112));

                    // 将调整大小后的脸部图像存储在 m_src_image 中
                    m_src_image = resizedFace.clone();
                } else
                {
                    qDebug() << "裁剪后的脸部图像为空！ ";
                }

                //存储的地址
                QString dir_str = "D:\\research\\CV\\Opencv\\facedata\\" + m_facenum + "\\" + QString::number(m_executionCount) + ".jpg";
                //用来判断这个地址的文件夹是否存在
                QString is_dir = "D:\\research\\CV\\Opencv\\facedata\\" + m_facenum;
                qDebug() << dir_str;
                QDir dir(is_dirandroid);
                if (!dir.exists())
                {
                    if (!dir.mkpath("."))
                  编程客栈  {
                        qDebug() << "default ";
                    }
                }

                //扣的脸部的图像如果不为空
                if (!faceROI.empty())
                {
                    string filename = dir_str.toStdString();
                    // 将彩色图像转换为灰度图像
                    cv::Mat frame_gray;
                    cv::cvtColor(faceROI, frame_gray, cv::COLOR_BGR2GRAY);
                    //存储图像
                    imwrite(filename, frame_gray);
                    //在存储训练集需要的图片的地址的txt里也更新地址
                    QString csvsave = "D:/research/CV/Opencv/facedata/" + m_facenum + "/" + QString::number(m_executionCount) + ".jpg" + ";" + m_facenum ;
                    //存放要训练的模型的图片的地址的txt
                    QString csvfilename = "D:\\research\\CV\\Opencv\\at.txt";
                    //添加数据
                    appendToTextFile(csvfilename, csvsave);
                    m_executionCount++; // 每次执行计数器加一

                } else
                {
                    qDebug() << "脸部图像为空，无法写入文件！ ";
                }

                //存储20张之后
                if (m_executionCount >= 20)
                {
                    m_executionCount = 0;
                    m_Very_timer->stop();
                }

            }

        }
        else
        {
            QMessageBox::about(NULL, "提示", "请输入工号！");
            m_executionCount = 0;
            m_Very_timer->stop();
            //delete m_Very_timer;
        }
    }

    //录入脸
    void Set_Verity_face(QString facenum,QString facename)
    {
        m_facenum = facenum;
        m_facename = facename;
        qDebug()<< QSqlDatabase::drivers();
        //判断数据库是否开着
        if (!m_db.open())
        {
            qDebug() << "Failed to connect to database:" ;
        } else
        {
            qDebug() << "Connected to database!";
        }

        //查找全部，看数量以便添加id
        QSqlQuery countQuery("SELECT COUNT(*) FROM staff_info");

        if (countQuery.exec() && countQuery.next())
        {
            int rowCount = countQuery.value(0).toInt(); // 获取数据条数
            int newId = rowCount + 1; // 新的 ID 就是数据条数加一

            QSqlQuery query;
            query.prepare("INSERT INTO staff_info (num, id, name) VALUES (:facenum, :faceid, :facename)");
            query.bindValue(":facenum", m_facenum);
            query.bindValue(":faceid", newId); // 使用新的 ID
            query.bindValue(":facename", m_facename);

            if (query.exec())
            {
                qDebug() << "Data inserted into database successfully!";
            }
            else
            {
                qDebug() << "Failed to insert data into database:" ;
            }
        }
        else
        {
            qDebug() << "Failed to retrieve row count from database:" ;
        }


        //关闭数据库
        m_db.close();

        qDebug() << "开始录入\n";

        //绑定时间信号及获取图像帧的图像
        connect(m_Very_timer, SIGNAL(timeout()), this, SLOT(Verity()));
        //开始定时器
        m_Very_timer->start(200);
    }

    //设置打卡部分
    void Set_Card()
    {
        Mat gray;
        cvtColor(m_src_image, gray, CV_BGR2GRAY); // 将输入图像转换为灰度图像
        vector<Rect> faces; // 存放检测到的人脸矩形的向量容器

        // 使用级联分类器检测人脸
        m_cascada.detectMultiScale(gray, faces, 1.1, 4, 0, Size(30, 30), Size(500, 500));

        // 遍历检测到的每张人脸
        for (size_t i = 0; i < faces.size(); i++)
        {
            Rect faceRect = faces[i]; // 获取当前人脸的矩形框
            // 从灰度图像中提取当前人脸区域
            Mat faceROI = gray(faceRect);

            // 检查人脸区域是否为空
            if (!faceROI.empty())
            {
                // 调用 Predict 函数对人脸进行预测
                int temp = Predict(faceROI);
                qDebug() << "预测结果:" << temp;

                // 发送打卡数据，然后让主线程在数据库中查找
                Send_Card_Data(&m_db,QString::number(temp));

            }
        }
        faces.clear();


    }


private:
    //声明opencv的视频类
    cv::VideoCapture m_cap;
    //更新显示的定时器
    QTimer *m_timer;
    //录入的定时器
    QTimer *m_Very_timer;
    //声明Mat类图像变量，存储当前摄像头前的图像
    cv::Mat m_src_image;
    //检测的分类器
    CascadeClassifier m_cascada;

    //矩形框的点
    Point m_text_lb;
    //人脸个数
    vector<Rect> m_faces;
    // 声明一个录入计数器变量
    int m_executionCount = 0;
    //工号和姓名
    QString m_facenum;
    QString m_facename;
    //识别的模型
    Ptr<LBPHFaceRecognizer> m_model;
    //当前镜头前识别出的人数
    int m_current_people = 0;
    //数据库
    QSqlDatabase m_db;
};

#endif // CAMERATHREAD_H

faceverify.cpp

#include "faceverify.h"
#include "ui_faceverify.h"

#include <QDebug>
#include <QCamera>              //管理摄像头的大类
#include <QCameraInfo>          //管理摄像头的设备表
#include <QCameraViewfinder>    //管理摄像头显示区域
#include <QCameraImageCapture>  //管理图片
#include <QDateTime>            //管理时间
#include <QString>              //管理字符串
#include "verityface.h"

#pragma execution_character_set("utf-8")

FaceVerify::FaceVerify(QWidget *parent)
    : QWidget(parent)
    , ui(new Ui::FaceVerify)
{
    ui->setupUi(this);


}

FaceVerify::~FaceVerify()
{
    delete m_cthread;
    delete ui;
}

void FaceVerify::Get_image(QImage *image)
{
    //设置图片大小和label的长宽一致
    QImage timage = image->scaled(ui->Camera->width(), ui->Camera->height(),Qt::IgnoreASPectRatio, Qt::Smoo编程客栈thTransformation);
    ui->Camera->setPixmap(QPixmap::fromImage(timage));
}

//打开摄像头
void FaceVerify::on_pushButton_Open_Camera_clicked()
{
    if(ui->pushButton_Open_Camera->text() ==  "打开摄像头")
    {
        m_cthread = new CameraThread();
        connect(m_cthread, &CameraThread::Set_image, this, &FaceVerify::Get_image);
        ui->pushButton_Open_Camera->setText("关闭摄像头");
    }
    else
    {

        disconnect(m_cthread, &CameraThread::Set_image, this, &FaceVerify::Get_image);
        delete m_cthread;
        m_cthread = nullptr;
        ui->Camera->clear();
        ui->pushButton_Open_Camera->setText("打开摄像头");

    }
}

//打卡
void FaceVerify::on_pushButton_Card_clicked()
{
    // 先断开之前的连接
    disconnect(this, &FaceVerify::Send_Card, m_cthread, &CameraThread::Set_Card);
    disconnect(m_cthread, &CameraThread::Send_Card_Data, this, &FaceVerify::Show_Data);

    // 连接信号和槽
    connect(this, &FaceVerify::Send_Card, m_cthread, &CameraThread::Set_Card);
    connect(m_cthread, &CameraThread::Send_Card_Data, this, &FaceVerify::Show_Data);

    // 发送信号
    emit Send_Card();

}
//打卡数据显示
void FaceVerify::Show_Data(QSqlDatabase *m_db,QString num)
{
    if (!m_db->open())
    {
        qDebug() << "Failed to connect to database:";
    }
    else
    {
        qDebug() << "Connected to database!";

        // 执行检查并插入数据
        QSqlQuery query;
        query.prepare("SELECT * FROM record_info WHERE num = :facenum AND DATE(mtime) = CURDATE()");
        query.bindValue(":facenum", num);

        if (query.exec())
        {
            if (query.next())
            {
                // 如果有记录，表示今天已经签到
                QMessageBox::information(NULL, tr("提示 "), tr("今天已签到 "));

                // 读取数据库中的数据并显示在textEdit_data中
                QString data;
                QSqlRecord record = query.record();
                int numField = record.indexOf("num"); // 获取字段索引
                int timeField = record.indexOf("mtime");

                // 遍历查询结果
                do
                {
                    QString num = query.value(numField).toString(); // 获取编号
                    QString time = query.value(timeField).toDateTime().toString("yyyy-MM-dd hh:mm:ss"); // 获取时间
                    data += "编号: " + num + ", 时间: " + time + "\n";
                } while (query.next());

                // 将数据显示在textEdit_data中
                ui->textEdit_data->setText(data);

            }
            else
            {
                QDateTime currentDateTime = QDateTime::currentDateTime();
                QString currentTimeString = currentDateTime.toString("yyyy-MM-dd hh:mm:ss");

                qDebug() << "Current time:" << currentTimeString;
                // 如果没有记录，表示今天还未签到，执行插入操作
                query.prepare("INSERT INTO record_info (num, id, mtime) VALUES (:facenum, :faceid, :facemtime)");
                query.bindValue(":facenum", num);
                query.bindValue(":faceid", num); // 使用相同的 num 作为 id
                query.bindValue(":facemtime", currentTimeString);

                if (query.exec())
                {
                    QMessageBox::information(NULL, tr("提示 "), tr("签到成功 "));
                }
                else
                {
                    QMessageBox::critical(NULL, tr("错误 "), tr("签到失败： ") ); // 显示错误信息
                }
            }
        }
        else
        {
            QMessageBox::critical(NULL, tr("错误"), tr("查询数据失败： "));
        }

        // 关闭数据库连接
        m_db->close();
    }


}

//录入人脸
void FaceVerify::on_pushButton_face_clicked()
{
    //打开录入界面
    m_verifity = new VerityFace();
    connect(m_verifity, &VerityFace::Send_Face, this, &FaceVerify::GetFaceNum);
    m_verifity->show();
}

//训练模型
void FaceVerify::on_pushButton_Train_clicked()
{

    m_train = new train();
    connect(m_train, &train::finished, this, &FaceVerify::Train_Finish);
    m_train->run();

}
//模型训练完
void FaceVerify::Train_Finish()
{
    delete m_train;
    QMessageBox::information(NULL,"训练", "训练完成");
}

总结 

到此这篇关于基于OpenCV实现的人脸签到系统的文章就介绍到这了,更多相关OpenCV人脸签到系统内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！