JavaCV人脸识别三部曲之三：识别和预览

转x33g5p2x  于2021-12-22 转载在 Java  
字(11.9k)|赞(0)|评价(0)|浏览(557)

欢迎访问我的GitHub

这里分类和汇总了欣宸的全部原创(含配套源码)：https://github.com/zq2599/blog_demos

《JavaCV人脸识别三部曲》链接

  1. 《视频中的人脸保存为图片》
  2. 《训练》
  3. 《识别和预览》

本篇概览

  • 作为《JavaCV人脸识别三部曲》的终篇，今天咱们要开发一个实用的功能：有人出现在摄像头中时，应用程序在预览窗口标注出此人的身份，效果如下图所示：

  • 简单来说，本篇要做的事情如下：
  1. 理解重点概念：confidence
  2. 理解重点概念：threshold
  3. 编码
  4. 验证
  • 今天编写的代码，主要功能如下图所示：

理解重点概念：confidence

  • confidence和threshold是OpenCV的人脸识别中非常重要的两个概念，咱们先把这两个概念搞清楚，再去编码就非常容易了
  • 假设，咱们用下面六张照片训练出包含两个类别的模型：

  • 用一张新的照片去训练好的模型中做识别，如下图，识别结果有两部分内容：label和confidence

  • 先说lable，这个好理解，与训练时的lable一致（回顾上一篇的代码，lable如下图红框所示），前面图中lable等于2，表示被判定为郭富城：

  • 按照上面的说法，lable等于2就能确定照片中的人像是郭富城吗？
  • **当然不能！！！**此时confidence字段就非常重要了，先看JavaCV源码中对confidence的解释，如下图红框所示，我的理解是：与lable值相关联的置信度，或者说这张脸是郭富城的可能性：

  • 如果理解为可能性，那么问题来了，这是个double型的值，这个值越大，表示可能性越大还是越小？
  • 上图并没有明说，但是那一句e.g. distance，让我想起了机器学习中的K-means，此时我脑海中的画面如下：

-若真如上图所示，那么显然confidence越小，是郭富城的可能性就越大了，接下来再去找一些权威的说法：

  • OpenCV的官方论坛有个帖子的说法如下图：代码中的confidence变量属于命名不当，其含义不是可信度，而是与模型中的类别的距离：

  • 再看第二个解释，如下图红框，说得很清楚了，值越小，与模型中类别的相似度越高，0表示完全匹配：

  • 至此，相信您对confidence已经足够理解了，lable等于2，confidence=30.01，意思是：被识别照片与郭富城最相似，距离为30.01，距离越小，是郭富城的可能性越大

理解重点概念：threshold

  • 在聊threshold之前，咱们先看一个场景，还是刘德华郭富城的模型，这次咱们拿喜洋洋的照片给模型识别，识别结果如下：

  • 显然，模型不会告诉你照片里是谁，只会告诉你：和郭富城的距离是3000.01
  • 看到这里，聪明的您可能会这么想：那我就写一段代码吧，识别结果的confidence如果太大（例如超过100），就判定用于识别的人不属于训练模型的任何一个类别
  • 上述功能，OpenCV已经帮咱们想到了，那就是：threshold，翻译过来即门限，如果咱们设置了threshold等于100，那么，一旦距离超过100，OpenCV的lable返回值就是**-1**
  • 理解了confidence和threshold，接下来可以写人脸识别的代码了，感谢咱们的充分准备，接下来是丝般顺滑的编码过程…

源码下载

  • 《JavaCV人脸识别三部曲》的完整源码可在GitHub下载到，地址和链接信息如下表所示(https://github.com/zq2599/blog_demos)：
名称链接备注
项目主页https://github.com/zq2599/blog_demos该项目在GitHub上的主页
git仓库地址(https)https://github.com/zq2599/blog_demos.git该项目源码的仓库地址，https协议
git仓库地址(ssh)git@github.com:zq2599/blog_demos.git该项目源码的仓库地址，ssh协议
  • 这个git项目中有多个文件夹，本篇的源码在javacv-tutorials文件夹下，如下图红框所示：

  • javacv-tutorials里面有多个子工程，《JavaCV人脸识别三部曲》系列的代码在simple-grab-push工程下：

编码：人脸识别服务

  • 开始正式编码，今天咱们不会新建工程，而是继续使用《JavaCV的摄像头实战之一：基础》中创建的simple-grab-push工程
  • 先定义一个Bean类PredictRlt.java，用来保存识别结果（lable和confidence字段）：
  1. package com.bolingcavalry.grabpush.extend;
  3. import lombok.Data;
  5. @Data
  6. public class PredictRlt {
  7.     private int lable;
  8.     private double confidence;
  9. }
  • 然后把人脸识别有关的服务集中在RecognizeService.java中，方便主程序使用，代码如下，有几处要注意的地方稍后提到：
  1. package com.bolingcavalry.grabpush.extend;
  3. import com.bolingcavalry.grabpush.Constants;
  4. import org.bytedeco.opencv.global.opencv_imgcodecs;
  5. import org.bytedeco.opencv.opencv_core.Mat;
  6. import org.bytedeco.opencv.opencv_core.Size;
  7. import org.bytedeco.opencv.opencv_face.FaceRecognizer;
  8. import org.bytedeco.opencv.opencv_face.FisherFaceRecognizer;
  9. import static org.bytedeco.opencv.global.opencv_imgcodecs.IMREAD_GRAYSCALE;
  10. import static org.bytedeco.opencv.global.opencv_imgproc.resize;
  12. /** * @author willzhao * @version 1.0 * @description 把人脸识别的服务集中在这里 * @date 2021/12/12 21:32 */
  13. public class RecognizeService {
  15.     private FaceRecognizer faceRecognizer;
  17.     // 推理结果的标签
  18.     private int[] plabel;
  20.     // 推理结果的置信度
  21.     private double[] pconfidence;
  23.     // 推理结果
  24.     private PredictRlt predictRlt;
  26.     // 用于推理的图片尺寸，要和训练时的尺寸保持一致
  27.     private Size size= new Size(Constants.RESIZE_WIDTH, Constants.RESIZE_HEIGHT);
  29.     public RecognizeService(String modelPath) {
  30.         plabel = new int[1];
  31.         pconfidence = new double[1];
  32.         predictRlt = new PredictRlt();
  33.         
  34.         // 识别类的实例化，与训练时相同
  35.         faceRecognizer = FisherFaceRecognizer.create();
  36.         // 加载的是训练时生成的模型
  37.         faceRecognizer.read(modelPath);
  38.         // 设置门限，这个可以根据您自身的情况不断调整
  39.         faceRecognizer.setThreshold(Constants.MAX_CONFIDENCE);
  40.     }
  42.     /** * 将Mat实例给模型去推理 * @param mat * @return */
  43.     public PredictRlt predict(Mat mat) {
  44.         // 调整到和训练一致的尺寸
  45.         resize(mat, mat, size);
  47.         boolean isFinish = false;
  49.         try {
  50.             // 推理(这一行可能抛出RuntimeException异常，因此要补货，否则会导致程序退出)
  51.             faceRecognizer.predict(mat, plabel, pconfidence);
  52.             isFinish = true;
  53.         } catch (RuntimeException runtimeException) {
  54.             runtimeException.printStackTrace();
  55.         }
  57.         // 如果发生过异常，就提前返回
  58.         if (!isFinish) {
  59.             return null;
  60.         }
  62.         // 将推理结果写入返回对象中
  63.         predictRlt.setLable(plabel[0]);
  64.         predictRlt.setConfidence(pconfidence[0]);
  66.         return predictRlt;
  67.     }
  68. }
  • 上述代码有以下几处需要注意：
  1. 构造方法中，通过faceRecognizer.setThreshold设置门限，我在实际使用中发现50比较合适，您可以根据自己的情况不断调整
  2. predict方法中，用于识别的图片要用resize方法调整大小，尺寸要和训练时的尺寸一致
  3. 实测发现，在一张照片中出现多个人脸时，faceRecognizer.predict可能抛出RuntimeException异常，因此这里要捕获异常，避免程序崩溃退出

编码：检测和识别

  • 检测有关的接口DetectService.java，如下，和《JavaCV人脸识别三部曲之一：视频中的人脸保存为图片》中的完全一致：
  1. package com.bolingcavalry.grabpush.extend;
  3. import com.bolingcavalry.grabpush.Constants;
  4. import org.bytedeco.javacv.Frame;
  5. import org.bytedeco.javacv.OpenCVFrameConverter;
  6. import org.bytedeco.opencv.opencv_core.*;
  7. import org.bytedeco.opencv.opencv_objdetect.CascadeClassifier;
  8. import static org.bytedeco.opencv.global.opencv_core.CV_8UC1;
  9. import static org.bytedeco.opencv.global.opencv_imgcodecs.imwrite;
  10. import static org.bytedeco.opencv.global.opencv_imgproc.*;
  12. /** * @author willzhao * @version 1.0 * @description 检测工具的通用接口 * @date 2021/12/5 10:57 */
  13. public interface DetectService {
  15.     /** * 根据传入的MAT构造相同尺寸的MAT，存放灰度图片用于以后的检测 * @param src 原始图片的MAT对象 * @return 相同尺寸的灰度图片的MAT对象 */
  16.     static Mat buildGrayImage(Mat src) {
  17.         return new Mat(src.rows(), src.cols(), CV_8UC1);
  18.     }
  19.     
  20.     /** * 初始化操作，例如模型下载 * @throws Exception */
  21.     void init() throws Exception;
  23.     /** * 得到原始帧，做识别，添加框选 * @param frame * @return */
  24.     Frame convert(Frame frame);
  26.     /** * 释放资源 */
  27.     void releaseOutputResource();
  28. }
  • 然后就是DetectService的实现类DetectAndRecognizeService .java，功能是用摄像头的一帧图片检测人脸，再拿检测到的人脸给RecognizeService做识别，完整代码如下，有几处要注意的地方稍后提到：
  1. package com.bolingcavalry.grabpush.extend;
  3. import lombok.extern.slf4j.Slf4j;
  4. import org.bytedeco.javacpp.Loader;
  5. import org.bytedeco.javacv.Frame;
  6. import org.bytedeco.javacv.OpenCVFrameConverter;
  7. import org.bytedeco.opencv.opencv_core.*;
  8. import org.bytedeco.opencv.opencv_objdetect.CascadeClassifier;
  10. import java.io.File;
  11. import java.net.URL;
  12. import java.util.Map;
  14. import static org.bytedeco.opencv.global.opencv_imgproc.*;
  16. /** * @author willzhao * @version 1.0 * @description 音频相关的服务 * @date 2021/12/3 8:09 */
  17. @Slf4j
  18. public class DetectAndRecognizeService implements DetectService {
  20.     /** * 每一帧原始图片的对象 */
  21.     private Mat grabbedImage = null;
  23.     /** * 原始图片对应的灰度图片对象 */
  24.     private Mat grayImage = null;
  26.     /** * 分类器 */
  27.     private CascadeClassifier classifier;
  29.     /** * 转换器 */
  30.     private OpenCVFrameConverter.ToMat converter = new OpenCVFrameConverter.ToMat();
  32.     /** * 检测模型文件的下载地址 */
  33.     private String detectModelFileUrl;
  35.     /** * 处理每一帧的服务 */
  36.     private RecognizeService recognizeService;
  38.     /** * 为了显示的时候更加友好，给每个分类对应一个名称 */
  39.     private Map<Integer, String> kindNameMap;
  41.     /** * 构造方法 * @param detectModelFileUrl * @param recognizeModelFilePath * @param kindNameMap */
  42.     public DetectAndRecognizeService(String detectModelFileUrl, String recognizeModelFilePath, Map<Integer, String> kindNameMap) {
  43.         this.detectModelFileUrl = detectModelFileUrl;
  44.         this.recognizeService = new RecognizeService(recognizeModelFilePath);
  45.         this.kindNameMap = kindNameMap;
  46.     }
  48.     /** * 音频采样对象的初始化 * @throws Exception */
  49.     @Override
  50.     public void init() throws Exception {
  51.         // 下载模型文件
  52.         URL url = new URL(detectModelFileUrl);
  54.         File file = Loader.cacheResource(url);
  56.         // 模型文件下载后的完整地址
  57.         String classifierName = file.getAbsolutePath();
  59.         // 根据模型文件实例化分类器
  60.         classifier = new CascadeClassifier(classifierName);
  62.         if (classifier == null) {
  63.             log.error("Error loading classifier file [{}]", classifierName);
  64.             System.exit(1);
  65.         }
  66.     }
  68.     @Override
  69.     public Frame convert(Frame frame) {
  70.         // 由帧转为Mat
  71.         grabbedImage = converter.convert(frame);
  73.         // 灰度Mat，用于检测
  74.         if (null==grayImage) {
  75.             grayImage = DetectService.buildGrayImage(grabbedImage);
  76.         }
  78.         // 进行人脸识别，根据结果做处理得到预览窗口显示的帧
  79.         return detectAndRecoginze(classifier, converter, frame, grabbedImage, grayImage, recognizeService, kindNameMap);
  80.     }
  82.     /** * 程序结束前，释放人脸识别的资源 */
  83.     @Override
  84.     public void releaseOutputResource() {
  85.         if (null!=grabbedImage) {
  86.             grabbedImage.release();
  87.         }
  89.         if (null!=grayImage) {
  90.             grayImage.release();
  91.         }
  93.         if (null==classifier) {
  94.             classifier.close();
  95.         }
  96.     }
  98.     /** * 检测图片，将检测结果用矩形标注在原始图片上 * @param classifier 分类器 * @param converter Frame和mat的转换器 * @param rawFrame 原始视频帧 * @param grabbedImage 原始视频帧对应的mat * @param grayImage 存放灰度图片的mat * @param kindNameMap 每个分类编号对应的名称 * @return 标注了识别结果的视频帧 */
  99.     static Frame detectAndRecoginze(CascadeClassifier classifier,
  100.                                     OpenCVFrameConverter.ToMat converter,
  101.                                     Frame rawFrame,
  102.                                     Mat grabbedImage,
  103.                                     Mat grayImage,
  104.                                     RecognizeService recognizeService,
  105.                                     Map<Integer, String> kindNameMap) {
  107.         // 当前图片转为灰度图片
  108.         cvtColor(grabbedImage, grayImage, CV_BGR2GRAY);
  110.         // 存放检测结果的容器
  111.         RectVector objects = new RectVector();
  113.         // 开始检测
  114.         classifier.detectMultiScale(grayImage, objects);
  116.         // 检测结果总数
  117.         long total = objects.size();
  119.         // 如果没有检测到结果，就用原始帧返回
  120.         if (total<1) {
  121.             return rawFrame;
  122.         }
  124.         PredictRlt predictRlt;
  125.         int pos_x;
  126.         int pos_y;
  127.         int lable;
  128.         double confidence;
  129.         String content;
  131.         // 如果有检测结果，就根据结果的数据构造矩形框，画在原图上
  132.         for (long i = 0; i < total; i++) {
  133.             Rect r = objects.get(i);
  134. 			
  135. 			// 核心代码，把检测到的人脸拿去识别 
  136.             predictRlt = recognizeService.predict(new Mat(grayImage, r));
  138.             // 如果返回为空，表示出现过异常，就执行下一个
  139.             if (null==predictRlt) {
  140.                 System.out.println("return null");
  141.                 continue;
  142.             }
  144.             // 分类的编号（训练时只有1和2，这里只有有三个值，1和2与训练的分类一致，还有个-1表示没有匹配上）
  145.             lable = predictRlt.getLable();
  146.             // 与模型中的分类的距离，值越小表示相似度越高
  147.             confidence = predictRlt.getConfidence();
  149.             // 得到分类编号后，从map中取得名字，用来显示
  150.             if (kindNameMap.containsKey(predictRlt.getLable())) {
  151.                 content = String.format("%s, confidence : %.4f", kindNameMap.get(lable), confidence);
  152.             } else {
  153.                 // 取不到名字的时候，就显示unknown
  154.                 content = "unknown(" + predictRlt.getLable() + ")";
  155.                 System.out.println(content);
  156.             }
  158.             int x = r.x(), y = r.y(), w = r.width(), h = r.height();
  159.             rectangle(grabbedImage, new Point(x, y), new Point(x + w, y + h), Scalar.RED, 1, CV_AA, 0);
  161.             pos_x = Math.max(r.tl().x()-10, 0);
  162.             pos_y = Math.max(r.tl().y()-10, 0);
  164.             putText(grabbedImage, content, new Point(pos_x, pos_y), FONT_HERSHEY_PLAIN, 1.5, new Scalar(0,255,0,2.0));
  165.         }
  167.         // 释放检测结果资源
  168.         objects.close();
  170.         // 将标注过的图片转为帧，返回
  171.         return converter.convert(grabbedImage);
  172.     }
  173. }
  • 上述代码有几处要注意：
  1. 重点关注detectAndRecoginze方法，这里面先调用classifier.detectMultiScale检测出当前照片所有的人脸，然后把每一张人脸交个recognizeService进行识别，
  2. 识别结果的lable是个int型的，看起来不够友好，因此从kindNameMap中根据lable找出对应的名称来
  3. 最终给每个头像添加矩形框，还在左上角添加识别结果，以及confidence的值
  4. 处理完毕后转为Frame对象返回，这样的帧显示在预览页面，效果就是视频中每个人被框选出来，并带有身份
  • 现在核心代码已经写完，需要再写一些代码来使用DetectAndRecognizeService

编码：运行框架

  • 《JavaCV的摄像头实战之一：基础》创建的simple-grab-push工程中已经准备好了父类AbstractCameraApplication，所以本篇继续使用该工程，创建子类实现那些抽象方法即可
  • 编码前先回顾父类的基础结构，如下图，粗体是父类定义的各个方法，红色块都是需要子类来实现抽象方法，所以接下来，咱们以本地窗口预览为目标实现这三个红色方法即可：

  • 新建文件PreviewCameraWithIdentify.java，这是AbstractCameraApplication的子类，其代码很简单，接下来按上图顺序依次说明
  • 先定义CanvasFrame类型的成员变量previewCanvas，这是展示视频帧的本地窗口：
  1. protected CanvasFrame previewCanvas
  • 把前面创建的DetectService作为成员变量，后面检测的时候会用到：
  1. /** * 检测工具接口 */
  2.     private DetectService detectService;
  • PreviewCameraWithIdentify的构造方法，接受DetectService的实例：
  1. /** * 不同的检测工具，可以通过构造方法传入 * @param detectService */
  2.     public PreviewCameraWithIdentify(DetectService detectService) {
  3.         this.detectService = detectService;
  4.     }
  • 然后是初始化操作，可见是previewCanvas的实例化和参数设置，还有检测、识别的初始化操作：
  1. @Override
  2.     protected void initOutput() throws Exception {
  3.         previewCanvas = new CanvasFrame("摄像头预览和身份识别", CanvasFrame.getDefaultGamma() / grabber.getGamma());
  4.         previewCanvas.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
  5.         previewCanvas.setAlwaysOnTop(true);
  7.         // 检测服务的初始化操作
  8.         detectService.init();
  9.     }
  • 接下来是output方法，定义了拿到每一帧视频数据后做什么事情，这里调用了detectService.convert检测人脸并保存图片，然后在本地窗口显示：
  1. @Override
  2.     protected void output(Frame frame) {
  3.         // 原始帧先交给检测服务处理，这个处理包括物体检测，再将检测结果标注在原始图片上，
  4.         // 然后转换为帧返回
  5.         Frame detectedFrame = detectService.convert(frame);
  6.         // 预览窗口上显示的帧是标注了检测结果的帧
  7.         previewCanvas.showImage(detectedFrame);
  8.     }
  • 最后是处理视频的循环结束后，程序退出前要做的事情，先关闭本地窗口，再释放检测服务的资源：
  1. @Override
  2.     protected void releaseOutputResource() {
  3.         if (null!= previewCanvas) {
  4.             previewCanvas.dispose();
  5.         }
  7.         // 检测工具也要释放资源
  8.         detectService.releaseOutputResource();
  9.     }
  • 由于检测有些耗时，所以两帧之间的间隔时间要低于普通预览：
  1. @Override
  2.     protected int getInterval() {
  3.         return super.getInterval()/8;
  4.     }
  • 至此，功能已开发完成，再写上main方法，代码如下，有几处要注意的地方稍后说明：
  1. public static void main(String[] args) {
  2.         String modelFileUrl = "https://raw.github.com/opencv/opencv/master/data/haarcascades/haarcascade_frontalface_alt.xml";
  3.         String recognizeModelFilePath = "E:\\temp\\202112\\18\\001\\faceRecognizer.xml";
  5.         // 这里分类编号的身份的对应关系，和之前训练时候的设定要保持一致
  6.         Map<Integer, String> kindNameMap = new HashMap();
  7.         kindNameMap.put(1, "Man");
  8.         kindNameMap.put(2, "Woman");
  10.         // 检测服务
  11.         DetectService detectService = new DetectAndRecognizeService(modelFileUrl,recognizeModelFilePath, kindNameMap);
  13.         // 开始检测
  14.         new PreviewCameraWithIdentify(detectService).action(1000);
  15.     }
  • 上述main方法中，有以下几处需要注意：
  1. kindNameMap是个HashMap，里面放这每个分类编号对应的名称，我训练的模型中包含了两位群众演员的头像，给他们分别起名Man和Woman
  2. modelFileUrl是人脸检测时用到的模型地址
  3. recognizeModelFilePath是人脸识别时用到的模型地址，这个模型是《JavaCV人脸识别三部曲之二：训练》一文中训练的模型
  • 至此，人脸识别的代码已经写完，运行main方法，请几位群众演员来到摄像头前面，验证效果吧

验证

  • 程序运行起来后，请名为Man的群众演员A站在摄像头前面，如下图，识别成功：

  • 接下来，请名为Woman的群众演员B过来，和群众演员A同框，如下图，同时识别成功，不过偶尔会识别错误，提示成unknown(-1)：

  • 再请一个没有参与训练的小群众演员过来，与A同框，此刻的识别也是准确的，小演员被标注为unknown(-1)：

  • 去看程序的控制台，发现FaceRecognizer.predict方法会抛出异常，幸好程序捕获了异常，不会把整个进程中断退出：

  • 至此，整个《JavaCV人脸识别三部曲》全部完成，如果您是位java程序员，正在寻找人脸识别相关的方案，希望本系列能给您一些参考
  • 另外《JavaCV人脸识别三部曲》是《JavaCV的摄像头实战》系列的分支，作为主干的《JavaCV的摄像头实战》依然在持续更新中，欣宸原创会继续与您一路相伴，学习、实战、提升

你不孤单，欣宸原创一路相伴

  1. Java系列
  2. Spring系列
  3. Docker系列
  4. kubernetes系列
  5. 数据库+中间件系列
  6. DevOps系列

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://blog.csdn.net/boling_cavalry/article/details/122021850

内容来源于网络，如有侵权，请联系作者删除！

opencvjavacv计算机视觉

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com