使用虹软SDK实现离线人脸识别（局域网）

已于 2022-03-24 15:34:28 修改
阅读量3.8k 收藏 8
点赞数
分类专栏： java 文章标签： java
于 2022-03-24 15:29:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_38948287/article/details/123711857
版权

第一步，获取SDK
首先注册开发者账号，创建一个应用，得到两个东西，用于激活SDK引擎的，SDK key 和 AppID。

把SDK下载到本地，我这里选择的是java版本的， 文件夹中包括开发者文档、API文档、示例程序、jar包、引擎库dll文件。

第二步，写后台

把文件夹中的jar包复制到项目中的lib（自己创建的）文件夹下，

依赖这样写：

		<dependency>
			<groupId>com.arcsoft.face</groupId>
			<artifactId>arcsoft-sdk-face</artifactId>
			<version>3.0.0.0</version>
			<scope>system</scope>
			<systemPath>${basedir}/src/main/resources/lib/arcsoft-sdk-face-3.0.0.0.jar</systemPath>
		</dependency

 前端html以及js

       chooseBorrower:function(){
            var _this = this;
            layer.open({
                type: 2,
                offset: 'auto',
                skin: 'layui-layer-lan',
                title: "选择关键词",
                area: ['88%', '100%'],
                shade: 0.3,
                shadeClose: false,
                content: '../borrow/borrower_choose.html',
                btn: ['确定','取消'],//'确定',
                yes: function(index, layero){
                    var mkey = layero.find("iframe")[0].contentWindow.$("#ids").val();
                    var mkeyName = layero.find("iframe")[0].contentWindow.$("#names").val();
                    if(mkey && mkey!=""){
                        var faceshow=$("#faceshow").val();
                       if(faceshow){
                       //人脸识别步骤
                        _this.getSfz(mkey,mkeyName);
                       }else{
                       //非人脸步骤
                        _this.setNameword(mkey,mkeyName);
                       }
                      layer.closeAll();
                   }else{
                        layer.alert("请选择关键词");
                        return;
                    }
                }
            });
        },
        getSfz:function(mkey,mkeyName){
            var _this = this;
            var url ="face/analysis/getSfz";
            $.ajax({
                data:{id: mkey},
                type: "POST",
                url: baseURL + url,
                success: function (r) {
                    if(r.code==0) {
                        _this.sfz= r.msg;
                        layer.open({
                            type: 2,
                            offset: 'auto',
                            skin: 'layui-layer-lan',
                            title: "人脸识别",
                            area: ['460px', '380px'],
                            shade: 0.3,
                            shadeClose: false,
                            content: '../face/faceIndex.html',
                            end: function(){
                                _this.setNameword(mkey,mkeyName);
                            }
                        });
                    }else{
                        alert(r.msg);
                    }
                }
            });
        },

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>拍照上传</title>
    <#include "/header.html">
    <link rel="stylesheet" href="${request.contextPath}/statics/css/face.css">
</head>
<body>
<div class="index__tips" id="index__tips"></div>
<div class="index__video-panel">
    <!-- 显示摄像头拍摄到的视频 -->
    <video id="index__video" class="index__video"></video>
    <!-- 视频上的提示框 -->
    <svg width="200" height="200" class="index__video-over">
        <!-- 克莱因蓝 #002FA7 -->
        <polyline points="5,50 5,5 50,5" fill-opacity="0"
                  style="stroke:#002FA7;stroke-width:10"/>
        <polyline points="5,150 5,195 50,195" fill-opacity="0"
                  style="stroke:#002FA7;stroke-width:10"/>
        <polyline points="155,5 195,5 195,45" fill-opacity="0"
                  style="stroke:#002FA7;stroke-width:10"/>
        <polyline points="155,195 195,195 195,155" fill-opacity="0"
                  style="stroke:#002FA7;stroke-width:10"/>
    </svg>
</div>
<!-- 用于给video标签截图的画布 -->
<canvas id="index__canvas" style="display:none;"></canvas>
<div id="rrapp" v-cloak>
<input type="hidden" id="sfz" v-model="sfz"/>
</div>
<script src="${request.contextPath}/statics/libs/axios.min.js?_${.now?long}"></script>
<script type="text/javascript" src="${request.contextPath}/statics/js/modules/face/face.js?_${.now?long}"></script>
</body>
</html>
/**
 * 拍照上传图片
 */
var indexObj = {};

indexObj.tips = "没有检测到设备，请确保开启摄像头!";

debugger
//首次运行引导用户，信任域名
var first = window.localStorage.getItem('first');
if(first == null ){
    if (navigator.mediaDevices.getUserMedia || navigator.getUserMedia || navigator.webkitGetUserMedia || navigator.mozGetUserMedia) {
        //调用用户媒体设备, 访问摄像头
        getUserMedia({video: {width: 480, height: 320}}, success, error);
    } else {
        alert('不支持访问用户媒体');
    }
}


//访问用户媒体设备的兼容方法
function getUserMedia(constraints, success, error) {
    if (navigator.mediaDevices.getUserMedia) {
        //最新的标准API
        navigator.mediaDevices.getUserMedia(constraints).then(success).catch(error);
    } else if (navigator.webkitGetUserMedia) {
        //webkit核心浏览器
        navigator.webkitGetUserMedia(constraints, success, error)
    } else if (navigator.mozGetUserMedia) {
        //firfox浏览器
        navigator.mozGetUserMedia(constraints, success, error);
    } else if (navigator.getUserMedia) {
        //旧版API
        navigator.getUserMedia(constraints, success, error);
    }
}

var video = document.getElementById('index__video');

function success(stream) {
    //兼容webkit核心浏览器
    var CompatibleURL = window.URL || window.webkitURL;
    //将视频流设置为video元素的源
    video.srcObject = stream;
    // video.play();
    video.onloadedmetadata = function (e) {
        video.play();
    };
}

function error(error) {
    document.getElementById("index__tips").innerHTML = indexObj.tips;
}


// 列出摄像头和麦克风
var exArray = [];
navigator.mediaDevices.enumerateDevices().then(function (devices) {
    devices.forEach(function (device) {
        if (device.kind == "videoinput") {
            exArray.push(device.deviceId);
        }

    });
    var mediaOpts = {video: {deviceId: {exact: exArray[1]}}};
    //调用用户媒体设备, 访问摄像头
    getUserMedia(mediaOpts, success, error);

}).catch(function (err) {
    console.log(err.name + ": " + err.message);
});


/**
 * 拍照上传按钮的事件响应
 */

indexObj.uploadImg = function () {
    var canvas = document.getElementById("index__canvas");
    var video = document.getElementById("index__video");
    if (0 == video.videoWidth) {
        document.getElementById("index__tips").innerHTML = indexObj.tips;
        return;
    }
    // 让canvas和视频一样宽高。
    var w = video.videoWidth;
    var h = video.videoHeight;
    canvas.width = w;
    canvas.height = h;
    // 把video标签中的画面，画到canvas中。
    var ctx = canvas.getContext('2d');
    ctx.drawImage(video, 0, 0, w, h);
    // 把canvas中的图像转换成png图片文件的Base64字符串。
    var imgStr = canvas.toDataURL('image/png').split("base64,")[1];
    // 获得用户ID
    var sfz = document.getElementById("sfz").value;
    axios.post(baseURL+"face/analysis/upload", {"sfz": sfz, "imgStr": imgStr}).then(function (res) {
        var r=res.data;
        if(r.code==500){//人脸不匹配
            //alert(r.msg);
        } else{
            window.clearInterval(t1);
            parent.layer.closeAll();
            parent.alert("人脸匹配成功!");
        }
    }).catch(function (error) {
        console.error(error);
    })
}
var vm = new Vue({
    el:'#rrapp',
    data:{
        sfz:'',
    },
    created: function(){
        this.sfz=parent.getSfzParam();
    },
    methods: {
        getUrlKey:function(name){
            return decodeURIComponent((new RegExp('[?|&]'+name+'='+'([^&;]+?)(&|#|;|$)').exec(location.href)||[,""])[1].replace(/\+/g,'%20'))||null;
        },
    }
});
var t1=setInterval(indexObj.uploadImg, 1000 * 1);

Controller

package com.framework.modules.face.controller;

import com.arcsoft.face.*;
import com.arcsoft.face.enums.ErrorInfo;
import com.arcsoft.face.toolkit.ImageInfo;
import com.framework.common.config.FaceApiConfig;
import com.framework.common.config.SysBaseConfig;
import com.framework.common.utils.FaceUtils;
import com.framework.common.utils.FileUtils;
import com.framework.common.utils.R;
import com.framework.common.utils.StringUtils;
import com.framework.modules.borrow.entity.BorrowerEntity;
import com.framework.modules.borrow.service.BorrowerService;
import com.framework.modules.face.entity.ProfileUpload;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import java.util.UUID;

import static com.arcsoft.face.toolkit.ImageFactory.getRGBData;

@RestController
@RequestMapping("face/analysis")
public class AnalysisController {
        @Autowired
        private FaceApiConfig faceApiConfig;
        @Autowired
        private SysBaseConfig sysBaseConfig;
        @Autowired
        private BorrowerService borrowerService;

        /**
         * 获取身份证照片路径
         */
        @RequestMapping("/getSfz")
        public R getSfz(@RequestParam(value = "id") String id) throws IOException {
                //根据ID拿到身份证
                BorrowerEntity borrower = borrowerService.selectById(id);
                if (borrower == null) {
                        return R.error("无此借阅人相关信息!");
                }
                String sfz = borrower.getSfz();
                if (sfz == null || "".equals(sfz)) {
                        return R.error("此借阅人无相关证件照片");
                }
                return R.ok(sfz);
        }


        @RequestMapping("/upload")
        public R upload(@RequestBody ProfileUpload profileUpload){
                StringBuffer fileName = new StringBuffer();
                fileName.append(UUID.randomUUID().toString().replaceAll("-", ""));
                if (StringUtils.isBlank(profileUpload.getImgStr())) {
                      return R.error("无识别视频!");
                }

                try {
                        FileUtils.createFile(profileUpload.getImgStr(),new File(faceApiConfig.getMat() + "//face.png"));
                        float score = this.analysis(profileUpload.getSfz());//匹配分数
                        if (score > 0.82) {//匹配通过
                                return R.ok("人脸匹配通过");
                        } else {
                                if (score == 0) {//人脸不匹配
                                        return R.error("检测结果为非活体");
                                } else {
                                        if (score != -3.0) {
                                                return R.error("人脸识别有误，请重试!");
                                        }
                                }
                        }
                } catch (Exception e) {
                   e.printStackTrace();
                }
                return R.error("人脸识别有误，请重试!");
        }

        private float analysis(String sfz) throws IOException {
                FaceEngine faceEngine= FaceUtils.getFaceEngine(faceApiConfig.getAppId(),faceApiConfig.getSdkKey());
                if(faceEngine==null){return -4;}//引擎初始化异常
                //人脸检测
                ImageInfo imageInfo = getRGBData(new File(sysBaseConfig.getProfile()+sfz));
                List<FaceInfo> faceInfoList = new ArrayList<FaceInfo>();
                int errorCode = faceEngine.detectFaces(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), imageInfo.getImageFormat(), faceInfoList);

                //特征提取
                FaceFeature faceFeature = new FaceFeature();
                errorCode = faceEngine.extractFaceFeature(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), imageInfo.getImageFormat(), faceInfoList.get(0), faceFeature);
                errorCode = FaceUtils.unInit(faceEngine);//卸载引擎

                File f=new File(faceApiConfig.getMat()+"//face.png");
                if(f==null||!f.exists()){
                        return -3;
                }
                //人脸检测2
                ImageInfo imageInfo2 = getRGBData(f);
                faceEngine=FaceUtils.getFaceEngine(faceApiConfig.getAppId(),faceApiConfig.getSdkKey());
                List<FaceInfo> faceInfoList2 = new ArrayList<FaceInfo>();
                errorCode = faceEngine.detectFaces(imageInfo2.getImageData(), imageInfo2.getWidth(), imageInfo2.getHeight(),imageInfo2.getImageFormat(), faceInfoList2);

                //特征提取2
                FaceFeature faceFeature2 = new FaceFeature();
                errorCode = faceEngine.extractFaceFeature(imageInfo2.getImageData(), imageInfo2.getWidth(), imageInfo2.getHeight(), imageInfo2.getImageFormat(), faceInfoList2.get(0), faceFeature2);
                //特征比对
                FaceFeature targetFaceFeature = new FaceFeature();
                targetFaceFeature.setFeatureData(faceFeature.getFeatureData());
                FaceFeature sourceFaceFeature = new FaceFeature();
                sourceFaceFeature.setFeatureData(faceFeature2.getFeatureData());
                FaceSimilar faceSimilar = new FaceSimilar();
                errorCode = faceEngine.compareFaceFeature(targetFaceFeature, sourceFaceFeature, faceSimilar);

                //设置活体测试
                errorCode = faceEngine.setLivenessParam(0.5f, 0.7f);

                FunctionConfiguration configuration = new FunctionConfiguration();
                configuration.setSupportLiveness(true);
                configuration.setSupportFace3dAngle(true);
                errorCode = faceEngine.process(imageInfo2.getImageData(), imageInfo2.getWidth(), imageInfo2.getHeight(), imageInfo2.getImageFormat(), faceInfoList2, configuration);

                //3D信息检测
                List<Face3DAngle> face3DAngleList = new ArrayList<Face3DAngle>();
                errorCode = faceEngine.getFace3DAngle(face3DAngleList);
                if(face3DAngleList == null || face3DAngleList.size() == 0) {
                        return errorCode;
                }
                //活体检测
                List<LivenessInfo> livenessInfoList = new ArrayList<LivenessInfo>();
                int livecode = faceEngine.getLiveness(livenessInfoList);
                //引擎卸载
                errorCode =FaceUtils.unInit(faceEngine);
                if(livecode== ErrorInfo.MOK.getValue()&&livenessInfoList.size()>0){
                        if(livenessInfoList.get(0).getLiveness()==1){
                                return faceSimilar.getScore();
                        }else{
                                return livenessInfoList.get(0).getLiveness();
                        }
                }
                return livecode;
        }

}

秘钥配置

@Configuration
@ConfigurationProperties(prefix="face.api")
public class FaceApiConfig {
	private String appId;
	private String sdkKey;
	private String mat;
	public String getAppId() {
		return appId;
	}

	public void setAppId(String appId) {
		this.appId = appId;
	}

	public String getSdkKey() {
		return sdkKey;
	}

	public void setSdkKey(String sdkKey) {
		this.sdkKey = sdkKey;
	}

	public String getMat() {
		return mat;
	}

	public void setMat(String mat) {
		this.mat = mat;
	}
}

人脸识别 引擎配置FaceUtils 

package com.framework.common.utils;

import com.arcsoft.face.ActiveFileInfo;
import com.arcsoft.face.EngineConfiguration;
import com.arcsoft.face.FaceEngine;
import com.arcsoft.face.FunctionConfiguration;
import com.arcsoft.face.enums.DetectMode;
import com.arcsoft.face.enums.DetectOrient;
import com.arcsoft.face.enums.ErrorInfo;
import org.springframework.core.io.ClassPathResource;
import org.springframework.core.io.Resource;

import java.io.File;
public class FaceUtils {
    public static FaceEngine getFaceEngine (String appId,String sdkKey){
        try {
            Resource resource = new ClassPathResource("");
            File file = new File(resource.getFile().getAbsolutePath());
            String path = file.getAbsolutePath() +  "/dll/arcsoft_lib";
            com.arcsoft.face.FaceEngine faceEngine = new com.arcsoft.face.FaceEngine(path);
            //激活引擎
            int errorCode = faceEngine.activeOnline(appId, sdkKey);
            if (errorCode != ErrorInfo.MOK.getValue() && errorCode != ErrorInfo.MERR_ASF_ALREADY_ACTIVATED.getValue()) {
                System.out.println("引擎激活失败");
            }
            ActiveFileInfo activeFileInfo=new ActiveFileInfo();
            errorCode = faceEngine.getActiveFileInfo(activeFileInfo);
            if (errorCode != ErrorInfo.MOK.getValue() && errorCode != ErrorInfo.MERR_ASF_ALREADY_ACTIVATED.getValue()) {
                System.out.println("获取激活文件信息失败");
            }
            //引擎配置
            EngineConfiguration engineConfiguration = new EngineConfiguration();
            engineConfiguration.setDetectMode(DetectMode.ASF_DETECT_MODE_IMAGE);
            engineConfiguration.setDetectFaceOrientPriority(DetectOrient.ASF_OP_ALL_OUT);
            engineConfiguration.setDetectFaceMaxNum(10);
            engineConfiguration.setDetectFaceScaleVal(32);
            engineConfiguration.setFunctionConfiguration(functionConfiguration());
            //初始化引擎
            errorCode = faceEngine.init(engineConfiguration);
            if (errorCode != ErrorInfo.MOK.getValue()) {
                System.out.println("初始化引擎失败");
            }
            return faceEngine;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    public static int unInit(FaceEngine faceEngine){//卸载引擎
        return faceEngine.unInit();
    }

    public static FunctionConfiguration functionConfiguration() {
        FunctionConfiguration functionConfiguration=new FunctionConfiguration();
        functionConfiguration.setSupportFaceDetect(true);
        functionConfiguration.setSupportFaceRecognition(true);
        functionConfiguration.setSupportLiveness(true);
        functionConfiguration.setSupportIRLiveness(true);
        functionConfiguration.setSupportAge(true);
        functionConfiguration.setSupportFace3dAngle(true);
        functionConfiguration.setSupportGender(true);
        return functionConfiguration; //该对象为Jar包对象
    }
}

此文章只供参考

蓝影灵
关注
  • 0
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
专栏目录
利用虹软SDK开发人脸识别（客户端版）
03-17
利用虹软SDK开发人脸识别（客户端版）
使用虹软SDK实现离线人脸注册，人脸登录（H5-JS前端，java后台）
魑魅魍魉
10-30 5552
前言： 一开始找人脸识别的第三方接口，选择了百度，就是发请求给百度的接口，解析人家返回的数据。 但是这样的话，如果没有网络，或者没有外网。程序在局域网中使用的时候，自然就gg了。 人脸识别嘛，大家了解的最多的就是现在手机自带的人脸识别，这个肯定不会说在你没有网络的情况下用不了。 然后就找离线人脸识别吧，就发现虹软这个可以把算法下载到本地…… 第一步，获取SDK 首先注册开发者账号，创建...
基于虹软件离线人脸识别
06-03
基于虹软件离线人脸识别。人脸分析，用于解析图片存于模板，用于将当前图片与人脸库进行比对，用于实时追踪视频帧中的人脸。
开放API和SDK的离线人脸识别机研发完成
imlsq的博客
11-30 729
开放API接口协议和SDK二次开放的人脸识别摄像头 摄像头在中国是非常成熟的产品，整个行业趋于垄断和封闭的状态，要找到一款能方便整合到自己系统的摄像头是非常不容易的事情. OPCOL是一款AI智能的开放API接口和SDK二次开发的人脸识别摄像头。可以非常轻松的接入的已有的业务系统中。 它有如下特点： 开放API+SDK，API为全HTTP restful风格的极容易集成的接口方式，SDK方式为C/C++插件so动态库扩展方式 完全离线模式，不依赖任何第三方云服务器，数据不会传输到任何第三方服务器，
百度离线人脸识别SDK-WebAPI离线集成与调用方法，附源代码
Three_ST的博客
06-13 1790
Baidu人脸识别离线SDK 本文是在Baidu离线SDK版本上做的二次开发与集成，将原先的C#版本功能移植到Web平台，目前支持.NET Core和ASP.NET 和原生控制台的三个版本，同理可以集成进WInform等平台。 关于本SDK 在寻找可用的SDK这个过程中，在网上做了很多的尝试和搜罗，排除价格和效果等因素， 参考上一篇文章《人脸识别应用初探-微软人脸识别在线SDK使用》，由于微软在国内没有部署离线识别模型，因此就是做了web api调用 官方离线SDK文档地址：https://ai.baidu
人脸识别openV
12-08
人脸识别，是基于人的脸部特征信息进行身份识别的一种生物识别技术。用摄像机或摄像头采集含有人脸的图像或视频流，并自动在图像中检测和跟踪人脸，进而对检测到的人脸进行脸部识别的一系列相关技术，通常也叫做人像识别、面部识别。
Android基于虹软SDK实现离线人脸识别
lilihexiaoxiangege的博客
08-07 3168
Android端实现离线人脸识别功能，即对比两张人脸是否是同一个人。
虹软人脸识别SDK离线激活（RV1109开发板）
weixin_46116802的博客
11-02 2293
虹软人脸识别SDK离线激活（RV1109开发板）
用深度学习做的人脸识别离线采集sdk
GKQ670623743的博客
04-13 2653
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录前言 前言 提示：这里可以添加本文要记录的大概内容： 基于深度学习技术FaceID技术，研发出安全帽人脸识别、口罩人脸识别、单目活体检测、双目活体检测、人脸特征属性等。 提示：以下是本篇文章正文内容，下面案例可供参考 人脸识别的应用场景，核心可以分为三大类： **身份核验：**即1:1对比，判断两张脸的相似度，判断你是你，通常用于需要验证用户身份真实性的场景，如人证对比。 **身份识别：**即1:N识别，在一个人脸集合中找到.
SpringBoot整合百度人脸识别SDK离线版操作步骤，Windows发布打包SpringBoot百度人脸识别SDK项目，以及解决百度人脸识别SDK离线版遇到的问题
weixin_43992507的博客
02-27 2863
SpringBoot整合百度人脸识别SDK离线版操作步骤，Windows发布打包SpringBoot百度人脸识别SDK项目，以及解决百度人脸识别SDK离线版遇到的问题
java引用虹软sdk，实现完整人脸识别（demo）
09-11
## 开发环境准备： ###开发使用到的软件和工具： * Jdk8、mysql5.7、libarcsoft_face.dll(so)、libarcsoft_face_engine.dll(so)、libarcsoft_face_engine_jni.dll(so)、idea * 注：libarcsoft_face.dll(so)、libarcsoft_face_engine.dll(so)、libarcsoft_face_engine_jni.dll(so)、app-id、sdk-key可以到虹软官网 http://ai.arcsoft.com.cn/ 免费申请下载 * 本地配置：
通过虹软SDK进行人脸识别
05-28
基于虹软ArcFace(人脸认知引擎)实现人脸检测、人脸跟踪、人脸识别
C# 人脸识别Demo（基于虹软免费SDK）完整版
08-21
C# 人脸识别 虹软免费SDK 原版高清下载，完整版 基于虹软最新的免费SDK写的C# 人脸识别的Demo，包含人脸检测，人脸对比，人脸检索功能.有关此Demo的详细信息可以阅读博客 ...
虹软离线人脸识别Android版本
08-28
虹软离线人脸识别Android版本，可以直接下载进行性能体验和评估。 不需要编译编码。 可在以下地址下载源码版本： https://download.csdn.net/download/weixin_42541384/10630927
tomcat设置为开机自启动
蓝影灵的博客
07-21 5080
先在双击tomcat中的bin目录下的startup.bat运行tomcat后可以在浏览器端正常打开情况下，说明tomcat安装正常，双击shutdown.bat停掉tomcat。在此情况下按照以下步骤进行。 第一步：设置环境变量（在java环境变量配置完成的情况下） 计算机右键——》属性——》高级系统设置——》环境变量——》在用户变量中心新建CATALINA_HOME变量 编辑path变量，新增如下内容 第二步：windows+R，打开cmd，将tomcat的bin中的servic..
微信扫二维码跳转小程序指定页面带参数
蓝影灵的博客
11-25 3559
参考文档：扫码打开小程序接入指南；注意事项 http://sdapp.mynatapp.cc为外网映射到本地服务器 校验文件放在配置规则最后一层。外网可以访问。 @RequestMapping("P9g6KmHJcZ.txt") public void P9g6KmHJcZ(HttpServletResponse response){ response.setContentType("text/html"); try { .
Nacos在windows下安装步骤
蓝影灵的博客
03-25 2697
Nacos就是注册中心+配置中心，等价于SpringCloud的Eureka+Config+Bus。 1.Nacos下载 官网下载地址：https://github.com/alibaba/nacos/releases 选择一个最新的稳定版本。zip是Windows版本，tar.gz是Linux版本 2.Nacos安装 下载完成之后，解压，进入目录，如下： bin：可执行命令；conf：配置文件；target：nacos应用jar包。当nacos运行起来之后，还会有data、logs。dat
redis过期事件监听、可以做延时任务
蓝影灵的博客
04-08 1949
redis过期监听 不像mq有保证 不推荐用来弄需要有保证的业务。
虹软离线的人脸识别sdk下载
最新发布
10-30
要下载虹软离线的人脸识别SDK，首先需要前往虹软官方网站。在官网上，我们可以找到SDK的相关介绍和下载链接。 在下载页面上，会提供不同版本的SDK供选择，包括Windows、Linux、Android等。根据自己的需要，选择适合的版本进行下载。 下载SDK之前，通常需要进行注册和登录操作。注册需要提供一些基本的个人信息，而登录则需要输入注册时设定的用户名和密码。 在登录成功后，用户可以选择将SDK以压缩包的形式下载到本地。下载完成后，解压缩文件，即可得到SDK所需的相关文件和文档。 除了SDK的下载，还需要下载相应的API文档进行参考。文档中详细说明了SDK的使用方法和各个功能的调用方式。通过仔细阅读和学习文档，可以更好地掌握和使用SDK。 为了保证SDK的安全性和稳定性，建议在下载和使用SDK时，选择官方正版的SDK，并遵守相应的使用规范和协议。 总之，要下载虹软离线的人脸识别SDK，用户需要前往官方网站进行注册和登录，选择合适的版本进行下载，解压缩文件，并仔细阅读API文档，以便正确地使用SDK的各项功能。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值