掌握生物识别技术：腾讯云神图人脸识别全揭秘 Face Recognition By Yangbuyi

CREATE TABLE `sys_user_face_info` (
  `id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '主键',
  `group_id` varchar(255) DEFAULT NULL COMMENT '分组id',
  `face_id` varchar(32) NOT NULL COMMENT '人脸唯一Id->对接用户ID',
  `name` varchar(63) DEFAULT NULL COMMENT '名字',
  `age` int(3) DEFAULT NULL COMMENT '年纪',
  `gender` smallint(1) DEFAULT NULL COMMENT '性别，1=男，2=女',
  `create_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `fpath` text DEFAULT NULL COMMENT '照片路径或者Base64',
  PRIMARY KEY (`id`) USING BTREE,
  KEY `GROUP_ID` (`group_id`) USING BTREE
) ENGINE=InnoDB AUTO_INCREMENT=1704902112020758531 DEFAULT CHARSET=utf8mb4 COMMENT='用户人脸识别';

        <!--腾讯云-->
        <dependency>
            <groupId>com.tencentcloudapi</groupId>
            <artifactId>tencentcloud-sdk-java</artifactId>
            <version>3.1.416</version>
        </dependency>
        <!-- 版本在maven生效需要时间，如获取不到对应的版本，可以调低版本号-->
        <dependency>
            <groupId>com.tencentcloudapi</groupId>
            <artifactId>tencentcloud-sdk-java-iai</artifactId>
            <version>3.1.416</version>
        </dependency>

package com.yby6.config;

import lombok.Data;
import lombok.Getter;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.stereotype.Component;

/**
 * 腾讯云yml配置
 *
 * @author Yang Buyi
 * Create By 2023/09/22
 * <p>
 */

@Data
@Component
@ConfigurationProperties(prefix = "tencent.cloud")
public class TencentConfig {
    public String appId;
    public String secretId;
    public String secretKey;
    public Face face;

    /**
     * 人脸相关
     */
    @Getter
    public static class Face {
        /**
         * 人员库名称
         */
        private String groupName;
        /**
         * 地域
         */
        private String region;

        public void setGroupName(String groupName) {
            this.groupName = groupName;
        }

        public void setRegion(String region) {
            this.region = region;
        }
    }

}

# 腾讯配置
tencent:
  cloud:
    appId: 获取APPID -》 访问管理
    secretId:  获取secretId -》 访问管理
    secretKey: 获取secretKey -》 访问管理
    face:
      groupName: 人员库名称
      region: ap-beijing

package com.yby6.controller.form;

import lombok.Data;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 人脸识别参数接收
 *
 * @author Yang Buyi
 * Create By 2023/9/22
 */
@Data
public class CreateFaceModelForm {

    /**
     * 小程序openId 或者 pcId
     */
    private String userId;

    /**
     * 人脸Base64
     */
    private String photo;

}

package com.yby6.utils;

import cn.hutool.json.JSONUtil;
import com.tencentcloudapi.common.Credential;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
import com.tencentcloudapi.iai.v20180301.IaiClient;
import com.tencentcloudapi.iai.v20180301.models.*;
import com.yby6.config.TencentConfig;
import com.yby6.controller.form.CreateFaceModelForm;
import com.yby6.domain.UserFaceInfo;
import com.yby6.mapper.UserFaceInfoMapper;
import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.UUID;


/**
 * 腾讯云服务工具
 *
 * @author Yang Buyi
 * Create By 2023/09/22
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class TencentUtils {
   private static TencentUtils tencentUtils;

    /**
     * 要在静态方法里面调用IOC容器的bean对象
     * PostConstruct 在构造函数执行之后执行。
     * 可以方便的把注入的bean对象给到静态属性
     * 源码： AutowiredAnnotationBeanPostProcessor 的 buildAutowiringMetadata 函数
     * isStatic 绕过了静态不进行注入
     */
    @PostConstruct
    public void postConstruct() {
        tencentUtils = this;
    }

    // 腾讯云配置
    private final TencentConfig tencentConfig;
  
  
  
    /**
     * 认证对象
     */
    private static IaiClient getIaiClient() {
        // 实例化一个认证对象
        Credential credential = new Credential(tencentUtils.tencentConfig.secretId, tencentUtils.tencentConfig.secretKey);
        // 实例化要请求产品的client对象,clientProfile是可选的
        return new IaiClient(credential, tencentUtils.tencentConfig.face.getRegion());
    }

  
  
}

    /**
     * 创建人脸识别库
     * 对应文档：<a href="https://console.cloud.tencent.com/api/explorer?Product=iai&Version=2020-03-03&Action=CreateGroup">...</a>
     */
    public static void CreateGroup() {
        try {
            IaiClient client = getIaiClient();
            // 实例化一个请求对象,每个接口都会对应一个request对象
            CreateGroupRequest req = new CreateGroupRequest();
            req.setGroupId("yangbuyiya");
            req.setGroupName("杨不易呀测试人脸识别");
            // 返回的resp是一个CreateGroupResponse的实例，与请求对象对应
            CreateGroupResponse resp = client.CreateGroup(req);
            // 输出json格式的字符串回包
            System.out.println(CreateGroupResponse.toJsonString(resp));
        } catch (TencentCloudSDKException e) {
            System.out.println(e.toString());
        }
    }

package com.yby6.utils;

import cn.hutool.core.util.BooleanUtil;
import cn.hutool.json.JSONUtil;
import com.tencentcloudapi.common.Credential;
import com.tencentcloudapi.common.exception.TencentCloudSDKException;
import com.tencentcloudapi.iai.v20180301.IaiClient;
import com.tencentcloudapi.iai.v20180301.models.*;
import com.yby6.config.TencentConfig;
import com.yby6.controller.form.CreateFaceModelForm;
import com.yby6.domain.UserFaceInfo;
import com.yby6.mapper.UserFaceInfoMapper;
import jakarta.annotation.PostConstruct;
import lombok.RequiredArgsConstructor;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;

import java.util.UUID;


/**
 * 腾讯云服务工具
 *
 * @author Yang Shuai
 * Create By 2023/09/21
 */
@Slf4j
@Component
@RequiredArgsConstructor
public class TencentUtils {
    private static TencentUtils tencentUtils;

    /**
     * 需求是 ： 要在静态方法里面调用IOC容器的bean对象
     * PostConstruct 在构造函数执行之后执行。
     * 可以方便的把注入的bean对象给到静态属性
     * 源码： AutowiredAnnotationBeanPostProcessor 的 buildAutowiringMetadata 函数
     * isStatic 绕过了静态不进行注入
     */
    @PostConstruct
    public void postConstruct() {
        tencentUtils = this;
    }

    private final TencentConfig tencentConfig;

    private final UserFaceInfoMapper userFaceInfoMapper;


    /**
     * 认证对象
     */
    private static IaiClient getIaiClient() {
        // 实例化一个认证对象
        Credential credential = new Credential(tencentUtils.tencentConfig.secretId, tencentUtils.tencentConfig.secretKey);
        // 实例化要请求产品的client对象,clientProfile是可选的
        return new IaiClient(credential, tencentUtils.tencentConfig.face.getRegion());
    }

    /**
     * 执行人员验证
     */
    public static VerifyPersonResponse verifyPersonRes(CreateFaceModelForm form) {
        IaiClient client = getIaiClient();
        // 创建人脸识别请求器
        VerifyPersonRequest request = new VerifyPersonRequest();
        request.setPersonId(String.valueOf(form.getUserId()));
        request.setImage(form.getPhoto());
        request.setQualityControl(4L);

        // 验证人员
        try {
            VerifyPersonResponse verifyPerson = client.VerifyPerson(request);
            log.info("人脸识别（人员）验证返回参数： {}", JSONUtil.toJsonStr(verifyPerson));
            // 进行活体检测 - 使用图片Base64转的会导致活体失败,到时候使用前端拍照即可
            // boolean liveFace = detectLiveFace(client, form.getPhoto());
            // verifyPerson.setIsMatch(verifyPerson.getIsMatch() && liveFace);
            return verifyPerson;
        } catch (TencentCloudSDKException e) {
            log.error("人脸验证失败：{0}", e);
            // 人员ID不存在 - 用于在新增人员的时候进行的校验 如果不存在则表示可以新增
            if (e.getErrorCode().equals("InvalidParameterValue.PersonIdNotExist")) {
                final VerifyPersonResponse response = new VerifyPersonResponse();
                response.setIsMatch(false);
                response.setScore(-0F);
                return response;
            }
            return null;
        }

    }

    /**
     * 执行人员识别验证
     */
    public static boolean verifyPerson(CreateFaceModelForm form) {
        // 验证人员
        VerifyPersonResponse verifyPerson = verifyPersonRes(form);
        if (null == verifyPerson) {
            throw new RuntimeException("未查询到该人脸信息!");
        }
        log.info("人脸识别（人员）验证返回参数： {}", JSONUtil.toJsonStr(verifyPerson));
        Boolean isMatch = verifyPerson.getIsMatch();
        if (BooleanUtil.isFalse(isMatch)) {
            return isMatch;
        }
        try {
            IaiClient client = getIaiClient();
            // 进行活体检测
            boolean liveFace = detectLiveFace(client, form.getPhoto());
            return isMatch && liveFace;
        } catch (TencentCloudSDKException e) {
            log.error("人脸验证失败：{0}", e);
            return false;
        }
    }

    /**
     * 执行人脸识别验证
     */
    public static VerifyFaceResponse verifyFaceRes(CreateFaceModelForm form) {
        try {
            VerifyFaceRequest request = new VerifyFaceRequest();
            request.setPersonId(String.valueOf(form.getUserId()));
            request.setImage(form.getPhoto());
            request.setQualityControl(4L);

            IaiClient client = getIaiClient();
            // 返回的resp是一个VerifyFaceResponse的实例，与请求对象对应
            VerifyFaceResponse verifyFace = client.VerifyFace(request);
            if (null == verifyFace) {
                throw new RuntimeException("未查询到该人脸信息!");
            }
            log.info("人脸识别（人脸）验证返回参数： {}", JSONUtil.toJsonStr(verifyFace));
            return verifyFace;
        } catch (TencentCloudSDKException e) {
            log.error("人脸验证失败：{0}", e);
            return null;
        }
    }


    /**
     * 执行人脸识别验证
     */
    public static boolean verifyFace(CreateFaceModelForm form) {
        try {
            // 返回的resp是一个VerifyFaceResponse的实例，与请求对象对应
            VerifyFaceResponse verifyFace = verifyFaceRes(form);
            if (null == verifyFace) {
                throw new RuntimeException("未查询到该人脸信息!");
            }
            log.info("人脸识别（人脸）验证返回参数： {}", JSONUtil.toJsonStr(verifyFace));
            Boolean isMatch = verifyFace.getIsMatch();
            if (BooleanUtil.isFalse(isMatch)) {
                return isMatch;
            }
            // 进行活体检测
            IaiClient client = getIaiClient();
            boolean liveFace = detectLiveFace(client, form.getPhoto());
            return isMatch && liveFace;
        } catch (TencentCloudSDKException e) {
            log.error("人脸验证失败：{0}", e);
            return false;
        }
    }


    /**
     * 活体检测
     */
    public static boolean detectLiveFace(IaiClient client, String image) throws TencentCloudSDKException {
        DetectLiveFaceRequest request = new DetectLiveFaceRequest();
        request.setImage(image);
        DetectLiveFaceResponse detectLiveFace = client.DetectLiveFace(request);
        log.info("活体验证（人脸）验证返回参数： {}", JSONUtil.toJsonStr(detectLiveFace));
        return detectLiveFace.getIsLiveness();
    }

    /**
     * 创建人员到腾讯云人脸识别（人员库）
     */
    public static void createPerson(CreateFaceModelForm form) {
        String userId = form.getUserId();
        String photo = form.getPhoto();
        // 实例化一个认证对象
        IaiClient client = getIaiClient();
        // 查询用户姓名和性别
        CreatePersonRequest request = new CreatePersonRequest();
        request.setGroupId(tencentUtils.tencentConfig.face.getGroupName());
        request.setPersonId(userId);
        try {
            DetectFaceRequest req = new DetectFaceRequest();
            req.setMaxFaceNum(1L);
            req.setImage(form.getPhoto());
            req.setNeedFaceAttributes(1L);
            req.setNeedQualityDetection(1L);
            // 返回的resp是一个DetectFaceResponse的实例，与请求对象对应
            DetectFaceResponse resp = client.DetectFace(req);
            final FaceInfo[] faceInfos = resp.getFaceInfos();
            final FaceAttributesInfo faceAttributesInfo = faceInfos[0].getFaceAttributesInfo();
            final short gender = faceAttributesInfo.getGender().shortValue();
            request.setGender((long) (gender > 2 ? 0 : gender)); // 1 男 2 女
            request.setQualityControl(4L);
            request.setPersonName(UUID.randomUUID().toString());
            request.setImage(photo);

            CreatePersonResponse response = client.CreatePerson(request);
            log.info("创建人脸模型返回参数:{}", JSONUtil.toJsonStr(response));

            // 新增到库当中
            tencentUtils.userFaceInfoMapper.insert(UserFaceInfo.builder()
                    .faceId(userId)
                    .age(faceAttributesInfo.getAge().intValue())
                    .gender(gender > 2 ? 0 : gender)
                    .groupId(tencentUtils.tencentConfig.face.getGroupName())
                    .build());

        } catch (TencentCloudSDKException e) {
            throw new RuntimeException(e.getMessage());
        }
    }

    /**
     * 创建人脸识别库
     * 对应文档：<a href="https://console.cloud.tencent.com/api/explorer?Product=iai&Version=2020-03-03&Action=CreateGroup">...</a>
     */
    public static void CreateGroup() {
        try {
            IaiClient client = getIaiClient();
            // 实例化一个请求对象,每个接口都会对应一个request对象
            CreateGroupRequest req = new CreateGroupRequest();
            req.setGroupId("yby6");
            req.setGroupName("杨不易呀测试人脸识别");
            // 返回的resp是一个CreateGroupResponse的实例，与请求对象对应
            CreateGroupResponse resp = client.CreateGroup(req);
            // 输出json格式的字符串回包
            System.out.println(CreateGroupResponse.toJsonString(resp));
        } catch (TencentCloudSDKException e) {
            System.out.println(e.toString());
        }
    }


    /**
     * 人脸验证
     */
    public static void VerifyFace() {
        try {
            IaiClient client = getIaiClient();
            // 实例化一个请求对象,每个接口都会对应一个request对象
            VerifyFaceRequest req = new VerifyFaceRequest();
            req.setPersonId("6");
            req.setUrl("https://sns-img-hw.xhscdn.com/627e45c8-b78a-d2a5-a262-b9fb1bbe15fc?imageView2/2/w/900/format/webp");
            req.setQualityControl(4L);
            // 返回的resp是一个VerifyFaceResponse的实例，与请求对象对应
            VerifyFaceResponse resp = client.VerifyFace(req);
            // 输出json格式的字符串回包
            System.out.println(VerifyFaceResponse.toJsonString(resp));
        } catch (TencentCloudSDKException e) {
            System.out.println(e.toString());
        }
    }


    /**
     * 人脸检测和分析
     */
    public static void DetectFace(CreateFaceModelForm form) {

        try {
            IaiClient client = getIaiClient();
            // 参数查看: https://console.cloud.tencent.com/api/explorer?Product=iai&Version=2018-03-01&Action=DetectFace
            // 实例化一个请求对象,每个接口都会对应一个request对象
            DetectFaceRequest req = new DetectFaceRequest();
            req.setMaxFaceNum(1L);
            req.setImage(form.getPhoto());
            req.setNeedFaceAttributes(1L);
            req.setNeedQualityDetection(1L);
            // 返回的resp是一个DetectFaceResponse的实例，与请求对象对应
            DetectFaceResponse resp = client.DetectFace(req);
            // 输出json格式的字符串回包
            System.out.println(DetectFaceResponse.toJsonString(resp));
        } catch (TencentCloudSDKException e) {
            System.out.println(e.toString());
        }

    }


}

    /**
     * 添加人脸模型记录
     */
    @Transactional
    public void createFaceModel(CreateFaceModelForm form) {
        // 人员ID搜索验证
        final VerifyPersonResponse verifyPersonResponse = TencentUtils.verifyPersonRes(form);
        // 表示没有存在人员库当中可以新建人员信息
        if (null != verifyPersonResponse && !verifyPersonResponse.getIsMatch()) {
            TencentUtils.createPerson(form);
            return;
        }

        // 纯人脸识别验证
        // 返回参数： {"Score":19.309923,"IsMatch":false,"FaceModelVersion":"3.0","RequestId":"ac4fbfcc-c928-4587-aeb1-af83f44ea765"}
//        final VerifyFaceResponse verifyFaceResponse = TencentUtils.verifyFaceRes(form);
//        // 如果相似度小于97则表示没有存在人员库当中可以新建人员信息
//        if (null != verifyFaceResponse && verifyFaceResponse.getScore() < 97) {
//            TencentUtils.createPerson(form);
//            return;
//        }

        throw new RuntimeException("人脸模型已经存在!");
    }

    /**
     * 验证人脸模型
     */
    @Transactional
    public VerifyPersonResponse verifyFaceModel(CreateFaceModelForm form) {
        // 人脸识别验证
        // TencentUtils.verifyFaceRes(form);

        // 人员ID搜索验证
        final VerifyPersonResponse verifyPersonResponse = TencentUtils.verifyPersonRes(form);
        // 如果只是单独的调用
        if (null != verifyPersonResponse && !verifyPersonResponse.getIsMatch()) {
            throw new RuntimeException("人脸模型不存在!");
        }
        return verifyPersonResponse;
    }

package com.yby6.controller;

import com.yby6.controller.form.CreateFaceModelForm;
import com.yby6.reponse.R;
import com.yby6.service.UserFaceInfoService;
import lombok.RequiredArgsConstructor;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 腾讯云 人脸识别 服务提供
 *
 * @author Yang Buyi
 * Create By 2023/9/22
 */
@RestController
@RequestMapping
@RequiredArgsConstructor
public class FaceAuthController {


    private final UserFaceInfoService userFaceInfoService;


    /**
     * 新增人脸模型
     */
    @PostMapping("/createFaceModel")
    public R<Object> createFaceModel(@RequestBody CreateFaceModelForm form) {
        userFaceInfoService.createFaceModel(form);
        return R.ok();
    }

    /**
     * 验证人脸是否正确并且写入人脸验证数据库
     */
    @PostMapping("/verifyFaceModel")
    public R<Object> verifyFaceModel(@RequestBody CreateFaceModelForm form) {
        return R.ok(userFaceInfoService.verifyFaceModel(form));
    }


}

<template>
  <view>
    <view class="face-container">
      <camera device-position="front" flash="off" class="camera" @error="error" v-if="showCamera">
        <cover-image :src="img.bg" class="bg"></cover-image>
      </camera>
      <view class="image-container" v-if="showImage">
        <image mode="widthFix" class="photo" :src="photoPath"></image>
        <view class="cover"></view>
      </view>
    </view>
    <view class="desc">
      <!--   验证人脸身份   -->
      <view v-if="mode == 'verificate'">
        <image :src="img.tips" mode="widthFix" @click="toggerMode('create')" class="tips"></image>
        <text>请把面部放在圆圈内</text>
        <text>拍摄脸部来确认身份</text>
      </view>
      <!--   保存人脸模型   -->
      <view v-if="mode == 'create'">
        <image :src="img.face" mode="widthFix"  @click="toggerMode('verificate')"  class="face"></image>
        <text>请把完整面部放在圆圈内</text>
        <text>拍摄脸部来保存身份识别数据</text>
      </view>
    </view>
    <button class="btn" @tap="confirmHandle">{{ mode == 'create' ? '录入面部信息' : '身份核实' }}</button>

    <!-- 菜单栏 -->
    <tabbar selected="3"></tabbar>
  </view>
</template>

<script setup>
import { createFaceModel, verifyFaceModel } from "@/api/face";
import tabbar from "../tabbar/tabbar.vue";
import { ref } from "vue";
import { onHide, onLoad, onShow } from '@dcloudio/uni-app'
import { toast } from "@/utils/common";

let img = ref({
  bg: `https://foruda.gitee.com/images/1695401819717946439/d54d604d_5151444.png`,
  tips: `https://foruda.gitee.com/images/1695401850177434378/28590240_5151444.png`,
  face: `https://foruda.gitee.com/images/1695401861767041335/b4f0ed58_5151444.png`
})

let voice = ref({
  voice_1: ``
})
// 请求模式
let mode = ref('verificate')
// 人脸Base64图
let photoPath = ref('')
// 是否显示照相机
let showCamera = ref(true)
// 是否显示人脸图片
let showImage = ref(false)
// 音频
let audio = ref(null)
// openId 这里你随便填吧
const storageSync = uni.getStorageSync('token');

// 点击图标切换新增人员或者验证人员
const toggerMode = (modeVal) => {
  mode.value = modeVal
}


// 人脸识别操作
const confirmHandle = () => {
  audio.value.stop()
  // 获取摄像头对象
  let cameraContext = uni.createCameraContext();
  // 拍摄图片
  cameraContext.takePhoto({
    quality: 'high',
    success: (resp) => {
      console.log(resp);
      // 照片在小程序上面的临时路径 （小程序关闭后会销毁）
      photoPath.value = resp.tempImagePath
      // 临时图片转换为base64
      uni.getFileSystemManager().readFile({
        filePath: photoPath.value,
        encoding: 'base64',
        success: (res) => {
          let base64 = 'data:image:/png;base64,' + res.data
          if (mode.value === "create") {
            // 创建面部模型
            createFaceModel({
              "userId": storageSync,
              "photo": base64
            }).then(res => {
              console.log(res)
              toast("人脸新增成功", 5)
              // 拍照成功隐藏摄像头
              showCamera.value = false
              // 在页面上显示拍摄的图片
              showImage.value = true
            }).catch(() => {
              showCamera.value = true
              showImage.value = false
              audio.value.play()
            })
          } else {
            // 验证人脸模型
            verifyFaceModel({
              "userId": storageSync,
              "photo": base64
            }).then(res => {
              console.log(res)
              if (res.data != null&&res.data.Score != -0) {
                toast("人脸验证成功", 5)
                // 拍照成功隐藏摄像头
                showCamera.value = false
                // 在页面上显示拍摄的图片
                showImage.value = true
              } else {
                toast("未检测到人脸!", 5)
                showCamera.value = true
                showImage.value = false
                audio.value.play()
              }
            }).catch(() => {
              showCamera.value = true
              showImage.value = false
            })
          }
        }
      })
    }
  })
}

// ============================== 生命周期 ===========================
onLoad((options) => {
  console.log(options);
  // 播放声音
  // 创建audio对象
  let audioContext = uni.createInnerAudioContext();
  audio.value = audioContext
  audioContext.src = voice.value.voice_1
  audioContext.play()
})
onHide(() => {
  // 当小程序挂到手机后台时候 接电话或者切换到其他app则立即停止播放mp3文件
  if (audio.value != null) {
    audio.value.stop()
  }
})
onShow(() => {
  console.log("onShow");
})
</script>

<style lang="less" scoped>
@import url('face_camera.less');
</style>