devbox
从前慢现在也慢
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

静默活体检测+人脸检测+人脸识别结合在NCNN模型下的推理(Windows下的VS环境）_ncnn人脸识别

作者：从前慢现在也慢 | 2024-03-22 03:20:18

赞

踩

ncnn人脸识别

 前言：

涉及到三个模型  静默活体检测模型<2M，人脸检测模型<2M  ，人脸识别<5M(模型大小)

至于NCNN不必多说,全C++实现，不依赖第三方库实现，在第三方移动端CPU运行最快。

首先，这是三者结合的推理，这意味着从训练到转ncnn模型全部完成且作用效果的精度达到了不错的要求。

训练在此就省略了，复现的都是都是GitHub上的原项目，然后使用其最终模型进行C++上的推理。

实现的功能：

一个demo实现对单个人的识别。（因为未涉及C++的太多知识，比如通过序列化对象转储到文件并从文件中读取，或者是通过连接数据库进行数据的转储，所以测试的推理的整个流程针对单人。）

步骤:先进行静默活体检测->人脸检测->人脸识别。后面的步骤都是在前面的步骤上实现，识别完后进行静默活体检测开始循环反复。

main函数

  1.  
  2. #include <stdio.h>
  3. #include <algorithm>
  4. #include <vector>
  5.  
  6.  
  7. #include "platform.h"
  8. #include <opencv2/opencv.hpp>
  9. #include <opencv2/core/core.hpp>
  10. #include <opencv2/highgui/highgui.hpp>
  11. #include "iostream"
  12. #include<sstream>
  13. #include "net.h"
  14. #if NCNN_VULKAN
  15. #include "gpu.h"
  16. #endif // NCNN_VULKAN
  17. #define IMAGE_SIZE 80
  18. #define CV_RGB(r,g,b) cvScalar((b),(g),(r),0)
  19.  
  20. /*声明*/
  21. bool JudgeReal(cv::Mat bgr, ncnn::Extractor ex, ncnn::Net & SilentFaceSpoofing);
  22. cv::Mat GetMyMat(cv::Mat img, const std::string& s);//获取人脸特征
  23. cv::Mat GetMat(const  std::string & path);//获取人脸框
  24. cv::Mat GetMat(cv::Mat img);//重载
  25. float* getFeatByMobileFaceNetNCNN(cv::Mat img);//获取特征向量
  26. float CalcSimilarity_1(float* fc1,//比较出相识度
  27.     float* fc2,
  28.     long dim);
  29.  
  30.  
  31. std::string Convert(float Num)
  32. {
  33.    std:: ostringstream oss;
  34.     oss << Num;
  35.    std:: string str(oss.str());
  36.     return str;
  37. }
  38.  
  39.  
  40.  int main(){
  41.  
  42.     
  43.      /*
  44.      先加载一个人的图片及其特征向量
  45.      */
  46.      cv::Mat sample = GetMat("./pic/yzh1.jpg");
  47.      float *sam= getFeatByMobileFaceNetNCNN( sample);
  48.      
  49.      /*
  50.      加载活体检测模型
  51.      */
  52.     static ncnn::Net SilentFaceSpoofing;
  53.     SilentFaceSpoofing.load_param("./model/2.7_80x80_MiniFASNetV2_sim.param");
  54.     SilentFaceSpoofing.load_model("./model/2.7_80x80_MiniFASNetV2_sim.bin");
  55.     static ncnn::Extractor ex = SilentFaceSpoofing.create_extractor();
  56.  
  57.  
  58.  
  59.  
  60.     
  61.  
  62.   //打开摄像头
  63.     cv::VideoCapture capture(0);//创建VideoCapture对象
  64.  
  65.     if (!capture.isOpened())//判断是否打开摄像头，打开isOpened返回ture
  66.  
  67.         return 1;
  68.  
  69.     bool stop(false);//定义一个用来停止循环的变量
  70.  
  71.     cv::Mat frame;//用来存放读取的视频序列，承载每一帧的图像 ，Mat类是用于保存图像以及其他矩阵数据的数据结构
  72.     cv::namedWindow("Camera");//创建一个窗口，显示每一帧的窗口
  73.  
  74.      
  75.     while (!stop)
  76.     {
  77.         if (!capture.read(frame))//如果没有读取到就中断
  78.  
  79.         {
  80.  
  81.             break;
  82.  
  83.         }
  84.        
  85.         bool result;
  86.         result = JudgeReal(frame, ex, SilentFaceSpoofing);//判断真假脸
  87.         if (result) {//活体
  88.            
  89.             cv::Mat frame2= GetMat(frame);//获取人脸框
  90.             float * fr= getFeatByMobileFaceNetNCNN(frame2);
  91.            float res= CalcSimilarity_1(fr, sam, 112);
  92.            std::cout << "相识度:" << res << std::endl;
  93.            delete[]fr;
  94.            if (res > 0.3) { //认为是同一个人
  95.                std::string name = "yzh-sim:" + Convert(res);
  96.                cv::Mat imgs = GetMyMat(frame, name);
  97.                putText(imgs, "realface", cv::Point(0, 100), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(123, 0, 255), 4, 4);
  98.                cv::imshow("Camera", imgs);//正常显示，把获取的视频填充到窗口中
  99.            }
  100.            else
  101.            {
  102.                cv::Mat imgs = GetMyMat(frame, "unknow");
  103.                putText(imgs, "unkonwrealface", cv::Point(0, 100), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(123, 0, 255), 4, 4);
  104.                cv::imshow("Camera", imgs);//正常显示，把获取的视频填充到窗口中
  105.            }
  106.          }
  107.         else {
  108.             putText(frame,  "FalseFace", cv::Point(0, 100), cv::FONT_HERSHEY_SIMPLEX, 2, cv::Scalar(123, 0, 255), 4, 4);
  109.  
  110.             cv::imshow("Camera", frame);//正常显示，把获取的视频填充到窗口中
  111.  
  112.             std::cout << result << std::endl;
  113.  
  114.         }
  115.  
  116.         char c = cvWaitKey(33);
  117.  
  118.         if (c == 32)break; //使用空格键来停止ASCII 为32  关闭摄像头
  119.  
  120.     }
  121.     capture.release();//释放
  122.  
  123.     return 0;
  124. }
  125.  
  126.

获取人的特征向量以及比较人的相识度（mobilefacenet网络实现识别）

  1.  
  2. #include<iostream>
  3. #include "net.h"
  4. #include <opencv2/opencv.hpp>
  5. using namespace std;
  6.  
  7.  
  8. static int flag = 0;
  9.  
  10. //Mobilefacenet 初始化
  11.  
  12.  
  13.  
  14.  
  15.  
  16.  
  17.  
  18. float simd_dot_1(const float* x, const float* y, const long& len) {
  19. 	float inner_prod = 0.0f;
  20. 	__m128 X, Y; // 128-bit values
  21. 	__m128 acc = _mm_setzero_ps(); // set to (0, 0, 0, 0)
  22. 	float temp[4];
  23.  
  24. 	long i;
  25. 	for (i = 0; i + 4 < len; i += 4) {
  26. 		X = _mm_loadu_ps(x + i); // load chunk of 4 floats
  27. 		Y = _mm_loadu_ps(y + i);
  28. 		acc = _mm_add_ps(acc, _mm_mul_ps(X, Y));
  29. 	}
  30. 	_mm_storeu_ps(&temp[0], acc); // store acc into an array
  31. 	inner_prod = temp[0] + temp[1] + temp[2] + temp[3];
  32.  
  33. 	// add the remaining values
  34. 	for (; i < len; ++i) {
  35. 		inner_prod += x[i] * y[i];
  36. 	}
  37. 	return inner_prod;
  38. }
  39. float CalcSimilarity_1(  float* fc1,
  40. 	  float* fc2,
  41. 	long dim) {
  42.  
  43. 	return simd_dot_1(fc1, fc2, dim)
  44. 		/ (sqrt(simd_dot_1(fc1, fc1, dim))
  45. 			* sqrt(simd_dot_1(fc2, fc2, dim)));
  46. }
  47.  
  48.  
  49.  
  50. float* getFeatByMobileFaceNetNCNN(   cv::Mat img)
  51. {
  52. 		static ncnn::Net Recognet;
  53. 	 
  54. 		if (!flag) {
  55. 			Recognet.load_param("./model/mobilefacenet.param");
  56. 			Recognet.load_model("./model/mobilefacenet.bin");
  57. 		}
  58. 	 	  ncnn::Extractor ex= Recognet.create_extractor();
  59. 		ex.set_light_mode(true);
  60. 		ex.set_num_threads(4);
  61. 	 
  62. 	//cout << "getFeatByMobileFaceNetNCNN" << endl;
  63. 	float* feat = new float[512];
  64. 	ncnn::Mat in = ncnn::Mat::from_pixels_resize(img.data, ncnn::Mat::PIXEL_BGR, img.cols, img.rows, 112, 112);
  65. 	ex.input("data", in);
  66. 	ncnn::Mat out;
  67. 	ex.extract("fc1", out);
  68. 	//std::vector<float> cls_scores;
  69. 	for (int j = 0; j < out.w; j++)
  70. 	{
  71. 		feat[j] = out[j];
  72. 	}
  73. 	return feat;
  74. }

静默活体识别引用函数（实现预处理）

  1.  
  2. #include <stdio.h>
  3. #include <algorithm>
  4. #include <vector>
  5. #include <opencv2/core/core.hpp>
  6. #include <opencv2/highgui/highgui.hpp>
  7. #include "iostream"
  8. #include "platform.h"
  9. #include "net.h"
  10. #if NCNN_VULKAN
  11. #include "gpu.h"
  12. #endif // NCNN_VULKAN
  13. #define IMAGE_SIZE 80
  14.  
  15.  
  16. bool JudgeReal(cv::Mat bgr, ncnn::Extractor ex, ncnn::Net& SilentFaceSpoofing) {
  17.  
  18.  
  19.     std::vector<float> cls_scores;
  20.     ncnn::Mat in = ncnn::Mat::from_pixels_resize(bgr.data, ncnn::Mat::PIXEL_BGR, bgr.cols, bgr.rows, IMAGE_SIZE, IMAGE_SIZE);
  21.     fprintf(stderr, "input shape: %d %d %d %d\n", in.dims, in.h, in.w, in.c);
  22.     ex.input("input", in);//input 是 .param文件中输入节点名称
  23.  
  24.  
  25.     ncnn::Mat out;
  26.     ex.extract("output", out);
  27.  
  28.     {
  29.         ncnn::Layer* softmax = ncnn::create_layer("Softmax");
  30.         ncnn::ParamDict pb;
  31.         softmax->load_param(pb);
  32.         softmax->forward_inplace(out, SilentFaceSpoofing.opt);
  33.         delete softmax;
  34.     }
  35.     out = out.reshape(out.h * out.w * out.c);
  36.     fprintf(stderr, "output shape: %d %d %d %d\n", out.dims, out.h, out.w, out.c);
  37.  
  38.     cls_scores.resize(out.w);
  39.     for (int j = 0; j < out.w; j++)
  40.     {
  41.         cls_scores[j] = out[j];
  42.         printf("cls_scores[%d]=%f\n", j, cls_scores[j]);
  43.     }
  44.  
  45.     std::cout << std::endl;
  46.     auto itMax = max_element(cls_scores.begin(), cls_scores.end());
  47.     std::cout << "the max:" << *itMax << " the location:" << distance(cls_scores.begin(), itMax) << std::endl;
  48.     if (distance(cls_scores.begin(), itMax) == 1) {
  49.         std::cout << "Image " << distance(cls_scores.begin(), itMax) << "   is Real Face. Score:  " << *itMax << std::endl;
  50.         return true;
  51.     }
  52.  
  53.     else {
  54.         std::cout << "Image " << distance(cls_scores.begin(), itMax) << "   is Fake Face. Score:  " << *itMax << std::endl;
  55.         return false;
  56.     }
  57. }
  58.  
  59.

 获取图像中的人脸框及其特征点 （retinaface网络实现检测，这里的boxsize是图片中检测的人脸个数，由于本次demo只针对单人，所以返回的总是最后一个人的检测框）

  1. #include <stdio.h>
  2. #include <algorithm>
  3. #include <vector>
  4. #include <opencv2/core/core.hpp>
  5. #include <opencv2/highgui/highgui.hpp>
  6. #include <opencv2/opencv.hpp>
  7. #include <fstream>
  8.  
  9. #include "FaceDetector.h"
  10.  
  11. using namespace std;
  12.  
  13.  
  14. static bbox mybox;
  15.  //cv::Mat GetMat()
  16. /*
  17. 图像预处理
  18. 获取框选后的人脸图像
  19. */
  20. cv::Mat GetMat(const std::string & path)
  21. {
  22.  
  23.     string imgPath = path;
  24.     static string param = "./model/face.param";
  25.     static  string bin = "./model/face.bin";
  26.     static const int max_side = 320;
  27.  
  28.  
  29.    static Detector detector(param, bin, false);
  30.     // retinaface
  31.     // Detector detector(param, bin, true);
  32.     Timer timer;
  33.      
  34.  
  35.  
  36.         cv::Mat img = cv::imread(imgPath.c_str(), CV_LOAD_IMAGE_COLOR);
  37.  
  38.         // scale
  39.         float long_side =  max(img.cols, img.rows);
  40.         float scale = max_side/long_side;
  41.         cv::Mat img_scale;
  42.         cv::Size size = cv::Size(img.cols*scale, img.rows*scale);
  43.         cv::resize(img, img_scale, cv::Size(img.cols*scale, img.rows*scale));
  44.  
  45.         if (img.empty())
  46.         {
  47.             fprintf(stderr, "cv::imread %s failed\n", imgPath.c_str());  
  48.         }
  49.         std::vector<bbox> boxes;
  50.  
  51.         timer.tic();
  52.  
  53.         detector.Detect(img_scale, boxes);
  54.         timer.toc("----total timer:");
  55.  
  56.         if (!boxes.size()) {
  57.             cv::Mat temp;
  58.             cv::resize(img, temp, cv::Size(112, 112));
  59.            
  60.             return    temp;
  61.         }
  62.         cv::Mat temps;
  63.         // draw image 裁剪出图片中人脸框
  64.         for (int j = 0; j < boxes.size(); ++j) {
  65.             cv::Rect rect(boxes[j].x1 / scale, boxes[j].y1 / scale, boxes[j].x2 / scale - boxes[j].x1 / scale, boxes[j].y2 / scale - boxes[j].y1 / scale);
  66.             cv::rectangle(img, rect, cv::Scalar(0, 0, 255), 1, 8, 0);
  67.             // char test[80];
  68.             cv::Mat m = img(rect);
  69.             cv::resize(m, temps, cv::Size(112, 112));
  70.            
  71.             mybox = boxes[j];
  72.         }
  73.             
  74.         return temps;
  75.     
  76.      
  77. }
  78. cv::Mat GetMat(  cv::Mat img)
  79. {
  80.     static string param = "./model/face.param";
  81.     static  string bin = "./model/face.bin";
  82.     static const int max_side = 320;
  83.     static Detector detector(param, bin, false);
  84.     // retinaface
  85.     // Detector detector(param, bin, true);
  86.     Timer timer;
  87.     // scale
  88.     float long_side = max(img.cols, img.rows);
  89.     float scale = max_side / long_side;
  90.     cv::Mat img_scale;
  91.     cv::Size size = cv::Size(img.cols * scale, img.rows * scale);
  92.     cv::resize(img, img_scale, cv::Size(img.cols * scale, img.rows * scale));
  93.  
  94.     if (img.empty())
  95.     {
  96.         std::cout << "empty img" << std::endl;
  97.     }
  98.     std::vector<bbox> boxes;
  99.  
  100.     timer.tic();
  101.  
  102.     detector.Detect(img_scale, boxes);
  103.     timer.toc("----total timer:");
  104.  
  105.     if (!boxes.size()) {
  106.         cv::Mat temp;
  107.         cv::resize(img, temp, cv::Size(112, 112));
  108.  
  109.         return    temp;
  110.     }
  111.     cv::Mat temps;
  112.     // draw image 裁剪出图片中人脸框
  113.  
  114.  
  115.     for (int j = 0; j < boxes.size(); ++j) {
  116.         cv::Rect rect(boxes[j].x1 / scale, boxes[j].y1 / scale, boxes[j].x2 / scale - boxes[j].x1 / scale, boxes[j].y2 / scale - boxes[j].y1 / scale);
  117.         cv::rectangle(img, rect, cv::Scalar(0, 0, 255), 1, 8, 0);
  118.         // char test[80];
  119.         cv::Mat m = img(rect);
  120.         cv::resize(m, temps, cv::Size(112, 112));
  121.  
  122.         mybox = boxes[j];
  123.     }
  124.  
  125.     return temps;
  126. }
  127.  
  128. /*
  130. 获取图像框
  131. */
  132.  
  133. cv::Mat GetMyMat( cv::Mat img, const std::string  &s) {
  134.  
  135.     float long_side = max(img.cols, img.rows);
  136.     float scale = 320 / long_side;
  137.     cv::Rect rect(mybox.x1 / scale, mybox.y1 / scale, mybox.x2 / scale - mybox.x1 / scale, mybox.y2 / scale - mybox.y1 / scale);
  138.     cv::rectangle(img, rect, cv::Scalar(0, 0, 255), 3, 8, 0);
  139.  
  140.  
  141.     cv::putText(img, s, cv::Size((mybox.x1 / scale), mybox.y1 / scale), cv::FONT_HERSHEY_COMPLEX, 0.5, cv::Scalar(0, 255, 255));
  142.     cv::circle(img, cv::Point(mybox.point[0]._x / scale, mybox.point[0]._y / scale), 1, cv::Scalar(0, 0, 225), 4);
  143.     cv::circle(img, cv::Point(mybox.point[1]._x / scale, mybox.point[1]._y / scale), 1, cv::Scalar(0, 255, 225), 4);
  144.     cv::circle(img, cv::Point(mybox.point[2]._x / scale, mybox.point[2]._y / scale), 1, cv::Scalar(255, 0, 225), 4);
  145.     cv::circle(img, cv::Point(mybox.point[3]._x / scale, mybox.point[3]._y / scale), 1, cv::Scalar(0, 255, 0), 4);
  146.     cv::circle(img, cv::Point(mybox.point[4]._x / scale, mybox.point[4]._y / scale), 1, cv::Scalar(255, 0, 0), 4);
  147.  
  148.  
  149.     return img;
  150.  
  151. }
  152.  
  153.  

  1. #include <algorithm>
  2. //#include "omp.h"
  3. #include "FaceDetector.h"
  4. using namespace std;
  5. Detector::Detector():
  6.         _nms(0.4),
  7.         _threshold(0.6),
  8.         _mean_val{104.f, 117.f, 123.f},
  9.         _retinaface(false),
  10.         Net(new ncnn::Net())
  11. {
  12. }
  13.  
  14. inline void Detector::Release(){
  15.     if (Net != nullptr)
  16.     {
  17.         delete Net;
  18.         Net = nullptr;
  19.     }
  20. }
  21.  
  22. Detector::Detector(const std::string &model_param, const std::string &model_bin, bool retinaface):
  23.         _nms(0.4),
  24.         _threshold(0.6),
  25.         _mean_val{104.f, 117.f, 123.f},
  26.         _retinaface(retinaface),
  27.         Net(new ncnn::Net())
  28. {
  29.     Init(model_param, model_bin);
  30. }
  31.  
  32. void Detector::Init(const std::string &model_param, const std::string &model_bin)
  33. {
  34.     int ret = Net->load_param(model_param.c_str());
  35.     ret = Net->load_model(model_bin.c_str());
  36. }
  37.  
  38. void Detector::Detect(cv::Mat& bgr, std::vector<bbox>& boxes)
  39. {
  40.     Timer timer;
  41.     timer.tic();
  42.     ncnn::Mat in = ncnn::Mat::from_pixels_resize(bgr.data, ncnn::Mat::PIXEL_BGR, bgr.cols, bgr.rows, bgr.cols, bgr.rows);
  43.     in.substract_mean_normalize(_mean_val, 0);
  44.     timer.toc("precoss:");
  45.     timer.tic();
  46.     ncnn::Extractor ex = Net->create_extractor();
  47.     ex.set_light_mode(true);
  48.     ex.set_num_threads(4);
  49.     ex.input(0, in);
  50.     ncnn::Mat out, out1, out2;
  51.  
  52.     // loc
  53.     ex.extract("output0", out);
  54.  
  55.     // class
  56.     ex.extract("530", out1);
  57.  
  58.     //landmark
  59.     ex.extract("529", out2);
  60.  
  61.     timer.toc("det:");
  62.  
  63.     std::vector<box> anchor;
  64.     timer.tic();
  65.     if (_retinaface)
  66.         create_anchor_retinaface(anchor,  bgr.cols, bgr.rows);
  67.     else
  68.         create_anchor(anchor,  bgr.cols, bgr.rows);
  69.     timer.toc("anchor:");
  70.  
  71.     std::vector<bbox > total_box;
  72.     float *ptr = out.channel(0);
  73.     float *ptr1 = out1.channel(0);
  74.     float *landms = out2.channel(0);
  75.  
  76.     // #pragma omp parallel for num_threads(2)
  77.     for (int i = 0; i < anchor.size(); ++i)
  78.     {
  79.         if (*(ptr1+1) > _threshold)
  80.         {
  81.             box tmp = anchor[i];
  82.             box tmp1;
  83.             bbox result;
  84.  
  85.             // loc and conf
  86.             tmp1.cx = tmp.cx + *ptr * 0.1 * tmp.sx;
  87.             tmp1.cy = tmp.cy + *(ptr+1) * 0.1 * tmp.sy;
  88.             tmp1.sx = tmp.sx * exp(*(ptr+2) * 0.2);
  89.             tmp1.sy = tmp.sy * exp(*(ptr+3) * 0.2);
  90.  
  91.             result.x1 = (tmp1.cx - tmp1.sx/2) * in.w;
  92.             if (result.x1<0)
  93.                 result.x1 = 0;
  94.             result.y1 = (tmp1.cy - tmp1.sy/2) * in.h;
  95.             if (result.y1<0)
  96.                 result.y1 = 0;
  97.             result.x2 = (tmp1.cx + tmp1.sx/2) * in.w;
  98.             if (result.x2>in.w)
  99.                 result.x2 = in.w;
  100.             result.y2 = (tmp1.cy + tmp1.sy/2)* in.h;
  101.             if (result.y2>in.h)
  102.                 result.y2 = in.h;
  103.             result.s = *(ptr1 + 1);
  104.  
  105.             // landmark
  106.             for (int j = 0; j < 5; ++j)
  107.             {
  108.                 result.point[j]._x =( tmp.cx + *(landms + (j<<1)) * 0.1 * tmp.sx ) * in.w;
  109.                 result.point[j]._y =( tmp.cy + *(landms + (j<<1) + 1) * 0.1 * tmp.sy ) * in.h;
  110.             }
  111.  
  112.             total_box.push_back(result);
  113.         }
  114.         ptr += 4;
  115.         ptr1 += 2;
  116.         landms += 10;
  117.     }
  118.  
  119.     std::sort(total_box.begin(), total_box.end(), cmp);
  120.     nms(total_box, _nms);
  121.     printf("%d\n", (int)total_box.size());
  122.  
  123.     for (int j = 0; j < total_box.size(); ++j)
  124.     {
  125.         boxes.push_back(total_box[j]);
  126.     }
  127. }
  128.  
  129. inline bool Detector::cmp(bbox a, bbox b) {
  130.     if (a.s > b.s)
  131.         return true;
  132.     return false;
  133. }
  134.  
  135. inline void Detector::SetDefaultParams(){
  136.     _nms = 0.4;
  137.     _threshold = 0.6;
  138.     _mean_val[0] = 104;
  139.     _mean_val[1] = 117;
  140.     _mean_val[2] = 123;
  141.     Net = nullptr;
  142.  
  143. }
  144.  
  145. Detector::~Detector(){
  146.     Release();
  147. }
  148.  
  149. void Detector::create_anchor(std::vector<box> &anchor, int w, int h)
  150. {
  151. //    anchor.reserve(num_boxes);
  152.     anchor.clear();
  153.     std::vector<std::vector<int> > feature_map(4), min_sizes(4);
  154.     float steps[] = {8, 16, 32, 64};
  155.     for (int i = 0; i < feature_map.size(); ++i) {
  156.         feature_map[i].push_back(ceil(h/steps[i]));
  157.         feature_map[i].push_back(ceil(w/steps[i]));
  158.     }
  159.     std::vector<int> minsize1 = {10, 16, 24};
  160.     min_sizes[0] = minsize1;
  161.     std::vector<int> minsize2 = {32, 48};
  162.     min_sizes[1] = minsize2;
  163.     std::vector<int> minsize3 = {64, 96};
  164.     min_sizes[2] = minsize3;
  165.     std::vector<int> minsize4 = {128, 192, 256};
  166.     min_sizes[3] = minsize4;
  167.  
  168.  
  169.     for (int k = 0; k < feature_map.size(); ++k)
  170.     {
  171.         std::vector<int> min_size = min_sizes[k];
  172.         for (int i = 0; i < feature_map[k][0]; ++i)
  173.         {
  174.             for (int j = 0; j < feature_map[k][1]; ++j)
  175.             {
  176.                 for (int l = 0; l < min_size.size(); ++l)
  177.                 {
  178.                     float s_kx = min_size[l]*1.0/w;
  179.                     float s_ky = min_size[l]*1.0/h;
  180.                     float cx = (j + 0.5) * steps[k]/w;
  181.                     float cy = (i + 0.5) * steps[k]/h;
  182.                     box axil = {cx, cy, s_kx, s_ky};
  183.                     anchor.push_back(axil);
  184.                 }
  185.             }
  186.         }
  187.  
  188.     }
  189.  
  190. }
  191.  
  192. void Detector::create_anchor_retinaface(std::vector<box> &anchor, int w, int h)
  193. {
  194. //    anchor.reserve(num_boxes);
  195.     anchor.clear();
  196.     std::vector<std::vector<int> > feature_map(3), min_sizes(3);
  197.     float steps[] = {8, 16, 32};
  198.     for (int i = 0; i < feature_map.size(); ++i) {
  199.         feature_map[i].push_back(ceil(h/steps[i]));
  200.         feature_map[i].push_back(ceil(w/steps[i]));
  201.     }
  202.     std::vector<int> minsize1 = {10, 20};
  203.     min_sizes[0] = minsize1;
  204.     std::vector<int> minsize2 = {32, 64};
  205.     min_sizes[1] = minsize2;
  206.     std::vector<int> minsize3 = {128, 256};
  207.     min_sizes[2] = minsize3;
  208.  
  209.     for (int k = 0; k < feature_map.size(); ++k)
  210.     {
  211.         std::vector<int> min_size = min_sizes[k];
  212.         for (int i = 0; i < feature_map[k][0]; ++i)
  213.         {
  214.             for (int j = 0; j < feature_map[k][1]; ++j)
  215.             {
  216.                 for (int l = 0; l < min_size.size(); ++l)
  217.                 {
  218.                     float s_kx = min_size[l]*1.0/w;
  219.                     float s_ky = min_size[l]*1.0/h;
  220.                     float cx = (j + 0.5) * steps[k]/w;
  221.                     float cy = (i + 0.5) * steps[k]/h;
  222.                     box axil = {cx, cy, s_kx, s_ky};
  223.                     anchor.push_back(axil);
  224.                 }
  225.             }
  226.         }
  227.  
  228.     }
  229.  
  230. }
  231.  
  232. void Detector::nms(std::vector<bbox> &input_boxes, float NMS_THRESH)
  233. {
  234.     std::vector<float>vArea(input_boxes.size());
  235.     for (int i = 0; i < int(input_boxes.size()); ++i)
  236.     {
  237.         vArea[i] = (input_boxes.at(i).x2 - input_boxes.at(i).x1 + 1)
  238.                    * (input_boxes.at(i).y2 - input_boxes.at(i).y1 + 1);
  239.     }
  240.     for (int i = 0; i < int(input_boxes.size()); ++i)
  241.     {
  242.         for (int j = i + 1; j < int(input_boxes.size());)
  243.         {
  244.             float xx1 =  max(input_boxes[i].x1, input_boxes[j].x1);
  245.             float yy1 =  max(input_boxes[i].y1, input_boxes[j].y1);
  246.             float xx2 =  min(input_boxes[i].x2, input_boxes[j].x2);
  247.             float yy2 =  min(input_boxes[i].y2, input_boxes[j].y2);
  248.             float w =  max(float(0), xx2 - xx1 + 1);
  249.             float   h =   max(float(0), yy2 - yy1 + 1);
  250.             float   inter = w * h;
  251.             float ovr = inter / (vArea[i] + vArea[j] - inter);
  252.             if (ovr >= NMS_THRESH)
  253.             {
  254.                 input_boxes.erase(input_boxes.begin() + j);
  255.                 vArea.erase(vArea.begin() + j);
  256.             }
  257.             else
  258.             {
  259.                 j++;
  260.             }
  261.         }
  262.     }
  263. }

效果:

真脸

最后:

静默活体检测还存在一定误差。感谢各位大佬的开源，让作为菜鸟的我完成了缝合。

参考:

38、静默活体检测测试及ncnn、mnn部署_sxj731533730的博客-CSDN博客_ncnn和mnn

deepinsight/insightface: State-of-the-art 2D and 3D Face Analysis Project (github.com)

GitHub - biubug6/Pytorch_Retinaface: Retinaface get 80.99% in widerface hard val using mobilenet0.25.

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/从前慢现在也慢/article/detail/284947?site
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号