经验首页 前端设计 程序设计 Java相关 移动开发 数据库/运维 软件/图像 大数据/云计算 其他经验
当前位置：技术经验 » Java相关 » Java » 查看文章
JavaCV的摄像头实战之十四：口罩检测
来源：cnblogs　　作者：程序员欣宸　　时间：2023/7/5 9:28:33　　对本文有异议

欢迎访问我的GitHub

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

本篇概览

  • 本文是《JavaCV的摄像头实战》系列的第十四篇，如标题所说，今天的功能是检测摄像头内的人是否带了口罩，把检测结果实时标注在预览窗口，如下图所示：
    在这里插入图片描述
  • 整个处理流程如下，实现口罩检测的关键是将图片提交到百度AI开放平台，然后根据平台返回的结果在本地预览窗口标识出人脸位置，以及此人是否带了口罩：
    在这里插入图片描述

问题提前告知

  • 依赖云平台处理业务的一个典型问题，就是处理速度受限
  • 首先，如果您在百度AI开放平台注册的账号是个人类型，那么免费的接口调用会被限制到一秒钟两次，如果是企业类型账号，该限制是十次
  • 其次，经过实测，一次人脸检测接口耗时300ms以上
  • 最终，实际上一秒钟只能处理两帧，这样的效果在预览窗口展现出来，就只能是幻灯片效果了（低于每秒十五帧就能感受到明显的卡顿）
  • 因此，本文只适合基本功能展示，无法作为实际场景的解决方案

关于百度AI开放平台

编码：添加依赖库

  1. <dependency>
  2. 	<groupId>com.squareup.okhttp3</groupId>
  3. 	<artifactId>okhttp</artifactId>
  4.     <version>3.10.0</version>
  5. </dependency>
  6. <dependency>
  7. 	<groupId>com.fasterxml.jackson.core</groupId>
  8.     <artifactId>jackson-databind</artifactId>
  9.     <version>2.11.0</version>
  10. </dependency>

编码：封装请求和响应百度AI开放平台的代码

  • 接下来要开发一个服务类，这个服务类封装了所有和百度AI开放平台相关的代码
  • 首先，定义web请求的request对象FaceDetectRequest.java：
  1. package com.bolingcavalry.grabpush.bean.request;
  3. import com.fasterxml.jackson.annotation.JsonProperty;
  4. import lombok.Data;
  6. /**
  7.  * @author willzhao
  8.  * @version 1.0
  9.  * @description 请求对象
  10.  * @date 2022/1/1 16:21
  11.  */
  12. @Data
  13. public class FaceDetectRequest {
  14.     // 图片信息(总数据大小应小于10M)，图片上传方式根据image_type来判断
  15.     String image;
  17.     // 图片类型
  18.     // BASE64:图片的base64值，base64编码后的图片数据，编码后的图片大小不超过2M；
  19.     // URL:图片的 URL地址( 可能由于网络等原因导致下载图片时间过长)；
  20.     // FACE_TOKEN: 人脸图片的唯一标识，调用人脸检测接口时，会为每个人脸图片赋予一个唯一的FACE_TOKEN，同一张图片多次检测得到的FACE_TOKEN是同一个。
  21.     @JsonProperty("image_type")
  22.     String imageType;
  24.     // 包括age,expression,face_shape,gender,glasses,landmark,landmark150,quality,eye_status,emotion,face_type,mask,spoofing信息
  25.     //逗号分隔. 默认只返回face_token、人脸框、概率和旋转角度
  26.     @JsonProperty("face_field")
  27.     String faceField;
  29.     // 最多处理人脸的数目，默认值为1，根据人脸检测排序类型检测图片中排序第一的人脸（默认为人脸面积最大的人脸），最大值120
  30.     @JsonProperty("max_face_num")
  31.     int maxFaceNum;
  33.     // 人脸的类型
  34.     // LIVE表示生活照：通常为手机、相机拍摄的人像图片、或从网络获取的人像图片等
  35.     // IDCARD表示身份证芯片照：二代身份证内置芯片中的人像照片
  36.     // WATERMARK表示带水印证件照：一般为带水印的小图，如公安网小图
  37.     // CERT表示证件照片：如拍摄的身份证、工卡、护照、学生证等证件图片
  38.     // 默认LIVE
  39.     @JsonProperty("face_type")
  40.     String faceType;
  42.     // 活体控制 检测结果中不符合要求的人脸会被过滤
  43.     // NONE: 不进行控制
  44.     // LOW:较低的活体要求(高通过率 低攻击拒绝率)
  45.     // NORMAL: 一般的活体要求(平衡的攻击拒绝率, 通过率)
  46.     // HIGH: 较高的活体要求(高攻击拒绝率 低通过率)
  47.     // 默认NONE
  48.     @JsonProperty("liveness_control")
  49.     String livenessControl;
  51.     // 人脸检测排序类型
  52.     // 0:代表检测出的人脸按照人脸面积从大到小排列
  53.     // 1:代表检测出的人脸按照距离图片中心从近到远排列
  54.     // 默认为0
  55.     @JsonProperty("face_sort_type")
  56.     int faceSortType;
  57. }
  • 其次，定义web响应对象FaceDetectResponse.java：
  1. package com.bolingcavalry.grabpush.bean.response;
  3. import com.fasterxml.jackson.annotation.JsonProperty;
  4. import lombok.Data;
  5. import lombok.ToString;
  6. import java.io.Serializable;
  7. import java.util.List;
  9. @Data
  10. @ToString
  11. public class FaceDetectResponse implements Serializable {
  12.     // 返回码
  13.     @JsonProperty("error_code")
  14.     String errorCode;
  15.     // 描述信息
  16.     @JsonProperty("error_msg")
  17.     String errorMsg;
  18.     // 返回的具体内容
  19.     Result result;
  21.     @Data
  22.     public static class Result {
  23.         // 人脸数量
  24.         @JsonProperty("face_num")
  25.         private int faceNum;
  26.         // 每个人脸的信息
  27.         @JsonProperty("face_list")
  28.         List<Face> faceList;
  30.         /**
  31.          * @author willzhao
  32.          * @version 1.0
  33.          * @description 检测出来的人脸对象
  34.          * @date 2022/1/1 16:03
  35.          */
  36.         @Data
  37.         public static class Face {
  38.             // 位置
  39.             Location location;
  40.             // 是人脸的置信度
  41.             @JsonProperty("face_probability")
  42.             double face_probability;
  43.             // 口罩
  44.             Mask mask;
  46.             /**
  47.              * @author willzhao
  48.              * @version 1.0
  49.              * @description 人脸在图片中的位置
  50.              * @date 2022/1/1 16:04
  51.              */
  52.             @Data
  53.             public static class Location {
  54.                 double left;
  55.                 double top;
  56.                 double width;
  57.                 double height;
  58.                 double rotation;
  59.             }
  61.             /**
  62.              * @author willzhao
  63.              * @version 1.0
  64.              * @description 口罩对象
  65.              * @date 2022/1/1 16:11
  66.              */
  67.             @Data
  68.             public static class Mask {
  69.                 int type;
  70.                 double probability;
  71.             }
  72.         }
  73.     }
  74. }
  • 然后是服务类BaiduCloudService.java，把请求和响应百度AI开放平台的逻辑全部集中在这里，可见其实很简单：根据图片的base64字符串构造请求对象、发POST请求（path是人脸检测服务）、收到响应后用Jackson反序列化成FaceDetectResponse对象：
  1. package com.bolingcavalry.grabpush.extend;
  3. import com.bolingcavalry.grabpush.bean.request.FaceDetectRequest;
  4. import com.bolingcavalry.grabpush.bean.response.FaceDetectResponse;
  5. import com.fasterxml.jackson.databind.DeserializationFeature;
  6. import com.fasterxml.jackson.databind.ObjectMapper;
  7. import okhttp3.*;
  8. import java.io.IOException;
  10. /**
  11.  * @author willzhao
  12.  * @version 1.0
  13.  * @description 百度云服务的调用
  14.  * @date 2022/1/1 11:06
  15.  */
  16. public class BaiduCloudService {
  18.     OkHttpClient client = new OkHttpClient();
  20.     static final MediaType JSON = MediaType.parse("application/json; charset=utf-8");
  22.     static final String URL_TEMPLATE = "https://aip.baidubce.com/rest/2.0/face/v3/detect?access_token=%s";
  24.     String token;
  26.     ObjectMapper mapper = new ObjectMapper();
  28.     public BaiduCloudService(String token) {
  29.         this.token = token;
  31.         // 重要：反序列化的时候，字符的字段如果比类的字段多，下面这个设置可以确保反序列化成功
  32.         mapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
  33.     }
  34.     
  35.     /**
  36.      * 检测指定的图片
  37.      * @param imageBase64
  38.      * @return
  39.      */
  40.     public FaceDetectResponse detect(String imageBase64) {
  41.         // 请求对象
  42.         FaceDetectRequest faceDetectRequest = new FaceDetectRequest();
  43.         faceDetectRequest.setImageType("BASE64");
  44.         faceDetectRequest.setFaceField("mask");
  45.         faceDetectRequest.setMaxFaceNum(6);
  46.         faceDetectRequest.setFaceType("LIVE");
  47.         faceDetectRequest.setLivenessControl("NONE");
  48.         faceDetectRequest.setFaceSortType(0);
  49.         faceDetectRequest.setImage(imageBase64);
  51.         FaceDetectResponse faceDetectResponse = null;
  53.         try {
  54.             // 用Jackson将请求对象序列化成字符串
  55.             String jsonContent = mapper.writeValueAsString(faceDetectRequest);
  57.             //
  58.             RequestBody requestBody = RequestBody.create(JSON, jsonContent);
  59.             Request request = new Request
  60.                     .Builder()
  61.                     .url(String.format(URL_TEMPLATE, token))
  62.                     .post(requestBody)
  63.                     .build();
  64.             Response response = client.newCall(request).execute();
  65.             String rawRlt = response.body().string();
  66.             faceDetectResponse = mapper.readValue(rawRlt, FaceDetectResponse.class);
  67.         } catch (IOException ioException) {
  68.             ioException.printStackTrace();
  69.         }
  71.         return faceDetectResponse;
  72.     }
  73. }
  • 服务类写完了，接下来是主程序把整个逻辑串起来

DetectService接口的实现

  • 熟悉《JavaCV的摄像头实战》系列的读者应该对DetectService接口不陌生了，为了在整个系列的诸多实战中以统一的风格实现抓取帧-->处理帧-->输出处理结果这样的流程，咱们定义了一个DetectService接口，每种不同帧处理业务按照自己的特点来实现此接口即可（例如人脸检测、年龄检测、性别检测等）
  • 先来回顾DetectService接口：
  1. package com.bolingcavalry.grabpush.extend;
  3. import org.bytedeco.javacv.Frame;
  4. import org.bytedeco.javacv.OpenCVFrameConverter;
  5. import org.bytedeco.opencv.opencv_core.*;
  6. 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_imgproc.*;
  11. /**
  12.  * @author willzhao
  13.  * @version 1.0
  14.  * @description 检测工具的通用接口
  15.  * @date 2021/12/5 10:57
  16.  */
  17. public interface DetectService {
  19.     /**
  20.      * 根据传入的MAT构造相同尺寸的MAT，存放灰度图片用于以后的检测
  21.      * @param src 原始图片的MAT对象
  22.      * @return 相同尺寸的灰度图片的MAT对象
  23.      */
  24.     static Mat buildGrayImage(Mat src) {
  25.         return new Mat(src.rows(), src.cols(), CV_8UC1);
  26.     }
  28.     /**
  29.      * 检测图片，将检测结果用矩形标注在原始图片上
  30.      * @param classifier 分类器
  31.      * @param converter Frame和mat的转换器
  32.      * @param rawFrame 原始视频帧
  33.      * @param grabbedImage 原始视频帧对应的mat
  34.      * @param grayImage 存放灰度图片的mat
  35.      * @return 标注了识别结果的视频帧
  36.      */
  37.     static Frame detect(CascadeClassifier classifier,
  38.                         OpenCVFrameConverter.ToMat converter,
  39.                         Frame rawFrame,
  40.                         Mat grabbedImage,
  41.                         Mat grayImage) {
  43.         // 当前图片转为灰度图片
  44.         cvtColor(grabbedImage, grayImage, CV_BGR2GRAY);
  46.         // 存放检测结果的容器
  47.         RectVector objects = new RectVector();
  49.         // 开始检测
  50.         classifier.detectMultiScale(grayImage, objects);
  52.         // 检测结果总数
  53.         long total = objects.size();
  55.         // 如果没有检测到结果，就用原始帧返回
  56.         if (total<1) {
  57.             return rawFrame;
  58.         }
  60.         // 如果有检测结果，就根据结果的数据构造矩形框，画在原图上
  61.         for (long i = 0; i < total; i++) {
  62.             Rect r = objects.get(i);
  63.             int x = r.x(), y = r.y(), w = r.width(), h = r.height();
  64.             rectangle(grabbedImage, new Point(x, y), new Point(x + w, y + h), Scalar.RED, 1, CV_AA, 0);
  65.         }
  67.         // 释放检测结果资源
  68.         objects.close();
  70.         // 将标注过的图片转为帧，返回
  71.         return converter.convert(grabbedImage);
  72.     }
  74.     /**
  75.      * 初始化操作，例如模型下载
  76.      * @throws Exception
  77.      */
  78.     void init() throws Exception;
  80.     /**
  81.      * 得到原始帧，做识别，添加框选
  82.      * @param frame
  83.      * @return
  84.      */
  85.     Frame convert(Frame frame);
  87.     /**
  88.      * 释放资源
  89.      */
  90.     void releaseOutputResource();
  91. }
  • 再来看看本次实战中DetectService接口的实现类BaiduCloudDetectService.java，有几处要注意的地方稍后会提到：
  1. package com.bolingcavalry.grabpush.extend;
  3. import com.bolingcavalry.grabpush.bean.response.FaceDetectResponse;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.bytedeco.javacpp.Loader;
  6. import org.bytedeco.javacv.Frame;
  7. import org.bytedeco.javacv.Java2DFrameConverter;
  8. import org.bytedeco.javacv.OpenCVFrameConverter;
  9. import org.bytedeco.opencv.opencv_core.Mat;
  10. import org.bytedeco.opencv.opencv_core.Point;
  11. import org.bytedeco.opencv.opencv_core.Rect;
  12. import org.bytedeco.opencv.opencv_core.Scalar;
  13. import org.bytedeco.opencv.opencv_objdetect.CascadeClassifier;
  14. import org.opencv.face.Face;
  15. import sun.misc.BASE64Encoder;
  16. import javax.imageio.ImageIO;
  17. import java.awt.image.BufferedImage;
  18. import java.io.ByteArrayOutputStream;
  19. import java.io.File;
  20. import java.io.IOException;
  21. import java.net.URL;
  22. import java.util.List;
  23. import static org.bytedeco.opencv.global.opencv_imgproc.*;
  24. import static org.bytedeco.opencv.global.opencv_imgproc.CV_AA;
  26. /**
  27.  * @author willzhao
  28.  * @version 1.0
  29.  * @description 音频相关的服务
  30.  * @date 2021/12/3 8:09
  31.  */
  32. @Slf4j
  33. public class BaiduCloudDetectService implements DetectService {
  35.     /**
  36.      * 每一帧原始图片的对象
  37.      */
  38.     private Mat grabbedImage = null;
  40.     /**
  41.      * 百度云的token
  42.      */
  43.     private String token;
  45.     /**
  46.      * 图片的base64字符串
  47.      */
  48.     private String base64Str;
  50.     /**
  51.      * 百度云服务
  52.      */
  53.     private BaiduCloudService baiduCloudService;
  55.     private OpenCVFrameConverter.ToMat openCVConverter = new OpenCVFrameConverter.ToMat();
  57.     private Java2DFrameConverter java2DConverter = new Java2DFrameConverter();
  59.     private OpenCVFrameConverter.ToMat converter = new OpenCVFrameConverter.ToMat();
  61.     private BASE64Encoder encoder = new BASE64Encoder();
  63.     /**
  64.      * 构造方法，在此指定模型文件的下载地址
  65.      * @param token
  66.      */
  67.     public BaiduCloudDetectService(String token) {
  68.         this.token = token;
  69.     }
  71.     /**
  72.      * 百度云服务对象的初始化
  73.      * @throws Exception
  74.      */
  75.     @Override
  76.     public void init() throws Exception {
  77.         baiduCloudService = new BaiduCloudService(token);
  78.     }
  80.     @Override
  81.     public Frame convert(Frame frame) {
  82.         // 将原始帧转成base64字符串
  83.         base64Str = frame2Base64(frame);
  85.         // 记录请求开始的时间
  86.         long startTime = System.currentTimeMillis();
  88.         // 交给百度云进行人脸和口罩检测
  89.         FaceDetectResponse faceDetectResponse = baiduCloudService.detect(base64Str);
  91.         // 如果检测失败，就提前返回了
  92.         if (null==faceDetectResponse
  93.          || null==faceDetectResponse.getErrorCode()
  94.          || !"0".equals(faceDetectResponse.getErrorCode())) {
  95.             String desc = "";
  96.             if (null!=faceDetectResponse) {
  97.                 desc = String.format("，错误码[%s]，错误信息[%s]", faceDetectResponse.getErrorCode(), faceDetectResponse.getErrorMsg());
  98.             }
  100.             log.error("检测人脸失败", desc);
  102.             // 提前返回
  103.             return frame;
  104.         }
  106.         log.info("检测耗时[{}]ms，结果：{}", (System.currentTimeMillis()-startTime), faceDetectResponse);
  108.         // 如果拿不到检测结果，就返回原始帧
  109.         if (null==faceDetectResponse.getResult()
  110.         || null==faceDetectResponse.getResult().getFaceList()) {
  111.             log.info("未检测到人脸");
  112.             return frame;
  113.         }
  115.         // 取出百度云的检测结果，后面会逐个处理
  116.         List<FaceDetectResponse.Result.Face> list = faceDetectResponse.getResult().getFaceList();
  117.         FaceDetectResponse.Result.Face face;
  118.         FaceDetectResponse.Result.Face.Location location;
  119.         String desc;
  120.         Scalar color;
  121.         int pos_x;
  122.         int pos_y;
  124.         // 如果有检测结果，就根据结果的数据构造矩形框，画在原图上
  125.         for (int i = 0; i < list.size(); i++) {
  126.             face = list.get(i);
  128.             // 每张人脸的位置
  129.             location = face.getLocation();
  131.             int x = (int)location.getLeft();
  132.             int y = (int)location.getHeight();
  133.             int w = (int)location.getWidth();
  134.             int h = (int)location.getHeight();
  136.             // 口罩字段的type等于1表示带口罩，0表示未带口罩
  137.             if (1==face.getMask().getType()) {
  138.                 desc = "Mask";
  139.                 color = Scalar.GREEN;
  140.             } else {
  141.                 desc = "No mask";
  142.                 color = Scalar.RED;
  143.             }
  145.             // 在图片上框出人脸
  146.             rectangle(grabbedImage, new Point(x, y), new Point(x + w, y + h), color, 1, CV_AA, 0);
  148.             // 人脸标注的横坐标
  149.             pos_x = Math.max(x-10, 0);
  150.             // 人脸标注的纵坐标
  151.             pos_y = Math.max(y-10, 0);
  153.             // 给人脸做标注，标注是否佩戴口罩
  154.              putText(grabbedImage, desc, new Point(pos_x, pos_y), FONT_HERSHEY_PLAIN, 1.5, color);
  155.         }
  157.         // 将标注过的图片转为帧，返回
  158.         return converter.convert(grabbedImage);
  159.     }
  161.     /**
  162.      * 程序结束前，释放人脸识别的资源
  163.      */
  164.     @Override
  165.     public void releaseOutputResource() {
  166.         if (null!=grabbedImage) {
  167.             grabbedImage.release();
  168.         }
  169.     }
  171.     private String frame2Base64(Frame frame) {
  172.         grabbedImage = converter.convert(frame);
  173.         BufferedImage bufferedImage = java2DConverter.convert(openCVConverter.convert(grabbedImage));
  174.         ByteArrayOutputStream bStream = new ByteArrayOutputStream();
  175.         try {
  176.             ImageIO.write(bufferedImage, "png", bStream);
  177.         } catch (IOException e) {
  178.             throw new RuntimeException("bugImg读取失败:"+e.getMessage(),e);
  179.         }
  181.         return encoder.encode(bStream.toByteArray());
  182.     }
  183. }
  • 上述代码有以下几点要注意：
  1. 整个BaiduCloudDetectService类，主要是对前面BaiduCloudService类的使用
  2. convert方法中，拿到frame实例后会转为base64字符串，用于提交到百度AI开放平台做人脸检测
  3. 百度AI开放平台的检测结果中有多个人脸检测结果，这里要逐个处理：取出每个人脸的位置，以此位置在原图画矩形框，然后根据是否戴口罩在人脸上做标记，戴口罩的是绿色标记（包括矩形框），不戴口罩的是红色矩形框

主程序

  • 最后是主程序了，还是《JavaCV的摄像头实战》系列的套路，咱们来看看主程序的服务类定义好的框架
  • 《JavaCV的摄像头实战之一：基础》创建的simple-grab-push工程中已经准备好了父类AbstractCameraApplication，所以本篇继续使用该工程，创建子类实现那些抽象方法即可
  • 编码前先回顾父类的基础结构，如下图，粗体是父类定义的各个方法，红色块都是需要子类来实现抽象方法，所以接下来，咱们以本地窗口预览为目标实现这三个红色方法即可：
    在这里插入图片描述
  • 新建文件PreviewCameraWithBaiduCloud.java，这是AbstractCameraApplication的子类，其代码很简单，接下来按上图顺序依次说明
  • 先定义CanvasFrame类型的成员变量previewCanvas，这是展示视频帧的本地窗口：
  1. protected CanvasFrame previewCanvas
  • 把前面创建的DetectService作为成员变量，后面检测的时候会用到：
  1.     /**
  2.      * 检测工具接口
  3.      */
  4.     private DetectService detectService;
  • PreviewCameraWithBaiduCloud的构造方法，接受DetectService的实例：
  1.     /**
  2.      * 不同的检测工具，可以通过构造方法传入
  3.      * @param detectService
  4.      */
  5.     public PreviewCameraWithBaiduCloud(DetectService detectService) {
  6.         this.detectService = detectService;
  7.     }
  • 然后是初始化操作，可见是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 0;
  4.     }
  • 至此，功能已开发完成，再写上main方法，代码如下，请注意token的值是前面在百度AI开放平台取得的access_token：
  1.     public static void main(String[] args) {
  2.         String token = "21.xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx.xxxxxxx.xxxxxxxxxx.xxxxxx-xxxxxxxx";
  3.         new PreviewCameraWithBaiduCloud(new BaiduCloudDetectService(token)).action(1000);
  4.     }
  • 至此，代码写完了，准备好摄像头开始验证，群众演员为了免费盒饭已经在寒风中等了很久啦

验证

  • 运行PreviewCameraWithBaiduCloud的main方法，请群众演员出现在摄像头前面，此时不戴口罩，可见人脸上是红色字体和矩形框：
    在这里插入图片描述

  • 让群众演员戴上口罩，再次出现在摄像头前面，这次检测到了口罩，显示了绿色标注和矩形框：
    在这里插入图片描述

  • 实际体验中，由于一秒钟最多只有两帧，在预览窗口展示时完全是幻灯片效果，惨不忍睹...

  • 本篇博客使用了群众演员两张照片，所以被他领走了两份盒饭，欣宸很心疼...

  • 至此，基于JavaCV和百度AI开放平台实现的口罩检测功能已完成，希望您继续关注《JavaCV的摄像头实战》系列，之后的实战更精彩

欢迎关注博客园：程序员欣宸

学习路上，你不孤单，欣宸原创一路相伴...

原文链接：https://www.cnblogs.com/bolingcavalry/p/17527084.html

 友情链接：直通硅谷 　点职佳 　北美留学生论坛

Java热门文章

  • 【IDEA】Application context not configured for this file
  • [IDEA] chapter_reader - idea看小说插件 idea阅读插件 idea摸鱼插件
  • thrift常见异常及原因分析
  • Java 调用 PaddleDetection 模型
  • JVM 详解，大白话带你认识 JVM
  • spring-boot-2.0.3不一样系列之番外篇 - @Configuration、Condition与@Conditional
  • Java Comparator.comparing比较导致空指针异常的解决
  • Java使用EasyExcel进行单元格合并的问题详解
  • 死磕 java集合之ArrayBlockingQueue源码分析
  • Java基础之集合Set详解

    • Java推荐文章

  • 面试场景题：一次关于线程池使用场景的讨论。
  • 前端黑科技：使用 JavaScript 实现网页扫码功能
  • 聊一聊 Netty 数据搬运工 ByteBuf 体系的设计与实现
  • 简单设计一个JAVA并行处理工具类
  • 【杂谈】JPA乐观锁改悲观锁遇到的一些问题与思考
  • 认识netty的基本组件
  • Jenkins如何使用CrumbIssuer防御CSRF攻击
  • 如何平稳地从nacos迁移到r-nacos？
  • 线程池遇到父子任务，有大坑，要注意！
  • Java JVM——12. 垃圾回收理论概述

    • 本站QQ群：前端 618073944 | Java 606181507 | Python 626812652 | C/C++ 612253063 | 微信 634508462 | 苹果 692586424 | C#/.net 182808419 | PHP 305140648 | 运维 608723728

    W3xue 的所有内容仅供测试，对任何法律问题及风险不承担任何责任。通过使用本站内容随之而来的风险与本站无关。
    关于我们  |  意见建议  |  捐助我们  |  报错有奖  |  广告合作、友情链接（目前9元/月）请联系QQ：27243702 沸活量
    皖ICP备17017327号-2　皖公网安备34020702000426号