arcsoft人脸识别sdk使用方法2（java版本）

-这里是我刚学java时写的一个超级简单的demo，所以很多地方可以改进

-它可以实现显示视频人脸框，以及对比本地图片

首先我用了这几个包，除了虹软的sdk还有显示视频的工具

完了我看不下去自己写的代码了，终于找到java快挂科的原因了，那时候连监听都不会用，，，现在总之很感谢老师不杀之恩

代码先贴在这儿，反正丑是丑点，能跑能识别，有时间我一定改（哭泣）

package com.arcsoft;

import com.arcsoft.face.*;

import java.io.File;


public class FaceEngineTest extends javax.swing.JFrame{

    static boolean open = false;

    public static void main(String[] args){

        DisplayUtils faceDetectDemo = new DisplayUtils();//显示视频

        //初始化引擎
        myEngine faceEngine_data = new myEngine();
        faceEngine_data.setEngineModel(false);
        faceEngine_data.initEngine();

        CameraInfo camera = new CameraInfo();//获取照片线程

        int refuse_times = 0;
        final int refuse_times_max = 5;
        int lastFaceid = -2;
        int nowFaceid;

        while(CameraInfo.Camera_ready);//等设备准备好开始

        while(true) {
            FaceFeature faceFeature;
            if(camera.isLiveness()) {//有活体（并且检测到人脸）
                faceFeature = new FaceFeature(camera.returnFaceFeature());;//获得FaceFeature
                nowFaceid = camera.returnFaceId();

            }else {
                open = false;
                try
                {
                    Thread.currentThread().sleep(1000);
                }
                catch(Exception e){}
                continue;
            }

        if(nowFaceid==lastFaceid) {
            if (open == true) {//已经识别成功的同一张脸不再识别
                System.out.println("休眠");
                try
                {
                    Thread.currentThread().sleep(2000);
                }
                catch(Exception e){}
                continue;
            } else {//open==false
                if (refuse_times >= refuse_times_max) {//识别失败的同一张脸达到规定次数不再识别
                    System.out.println("休眠");
                    try
                    {
                        Thread.currentThread().sleep(2000);
                    }
                    catch(Exception e){}
                    continue;
                }
            }
        }
         lastFaceid=nowFaceid;

         if(nowFaceid!=lastFaceid) {//faceid改变时置refuse_times为0
             faceDetectDemo.open = false;
             open = false;
             refuse_times = 0;
         }

                File file = new File("src\\img");
                File[] items = file.listFiles();

                if(items==null||items.length == 0)
                {
                    System.out.println("数据库照片为空，无法比较！");
                    System.exit(0);
                }

                System.out.println("对比数据库中。。。。" );
                MyDB compareEngine = new MyDB();

                boolean flag = false;
                for (int i = 0; i < items.length; i++) {
                    if(compareEngine.compare(faceFeature,items[i].getName())==true) {
                        flag=true;
                        break;
                    }
                }

                if(flag == true) {
                    System.out.println("摄像头识别为:" + compareEngine.getInfo());
                    open = true;
                }
                else {
                    System.out.println("【识别为无权限人员】");
                    refuse_times ++;
                    System.out.println("refuse_times=" + refuse_times);
                    open = false;
                }

                System.out.println("-----------------------------------");

            }

    }


}

package com.arcsoft;

import com.arcsoft.face.*;
import java.util.ArrayList;
import java.util.List;

import com.github.sarxos.webcam.Webcam;
import com.github.sarxos.webcam.WebcamResolution;
import javax.swing.JFrame;
import com.github.sarxos.webcam.WebcamPanel;
import java.awt.image.BufferedImage;

import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Graphics2D;
import java.awt.Point;

public class DisplayUtils extends javax.swing.JFrame implements WebcamPanel.Painter {


    public int width = 0;
    public int height = 0;
    public boolean open = false;

    private final Webcam webcam;
    public final WebcamPanel panel;

    public DisplayUtils(){
        setTitle("Motion Detector Demo");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        webcam = Webcam.getDefault();
        webcam.setViewSize(WebcamResolution.VGA.getSize());
        webcam.open(true);

        panel = new WebcamPanel(webcam, false);
        panel.setPainter(this);
        panel.start();

        add(panel);

        pack();
        setVisible(true);
    }

    public void paintPanel(WebcamPanel panel, Graphics2D g2) {
        panel.getDefaultPainter().paintPanel(panel, g2);
    }

    public void paintImage(WebcamPanel panel, BufferedImage image, Graphics2D g2) {

        Graphics2D g = image.createGraphics();
        g.setStroke(new BasicStroke(2));

        if(CameraInfo.Camera_ready==true) {
            List<FaceInfo> faceInfoList = new ArrayList<FaceInfo>(CameraInfo.returnFaceInfoList());
            int max_j = CameraInfo.returnMax();
            open = FaceEngineTest.open;


            if (faceInfoList.size() <= 0) {
                Point cog = new Point(0, 0);
                width = 0;
                height = 0;
                g.drawRect(cog.x, cog.y, width, height);
            } else {
                for (int i = 0; i < faceInfoList.size(); i++) {
                    Rect area = new Rect(faceInfoList.get(i).getRect());
                    Point cog = new Point(area.getLeft(), area.getTop());
                    width = area.getRight() - area.getLeft();
                    height = area.getBottom() - area.getTop();
                    if (i == max_j) {
                        if (open == false)
                            g.setColor(Color.RED);
                        else
                            g.setColor(Color.GREEN);
                    } else
                        g.setColor(Color.GRAY);
                    g.drawRect(cog.x, cog.y, width, height);
                }
            }
        }
        g.dispose();

        panel.getDefaultPainter().paintImage(panel, image, g2);
    }

}

package com.arcsoft;

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;

public class myEngine extends FaceEngine {

    private static String appId = "我是官网申请的appId";
    private static String sdkKey = "我是官网申请的sdkKey";
    private boolean isVideoMode = false;

     public myEngine() {

        super("D:\\arcsoft_face_java_rect\\libs\\WIN64");

        //激活引擎
        int activeCode = this.activeOnline(appId, sdkKey);

        if (activeCode != ErrorInfo.MOK.getValue() && activeCode != ErrorInfo.MERR_ASF_ALREADY_ACTIVATED.getValue()) {
            System.out.println("引擎激活失败");
        }
    }

     public void setEngineModel(boolean isVideo){
         isVideoMode = isVideo;
     }

    public void initEngine(){
        //引擎配置
        EngineConfiguration engineConfiguration = new EngineConfiguration();
        if(isVideoMode)
            engineConfiguration.setDetectMode(DetectMode.ASF_DETECT_MODE_VIDEO);
        else
            engineConfiguration.setDetectMode(DetectMode.ASF_DETECT_MODE_IMAGE);

        engineConfiguration.setDetectFaceOrientPriority(DetectOrient.ASF_OP_0_ONLY);

        //功能配置
        FunctionConfiguration functionConfiguration = new FunctionConfiguration();
        functionConfiguration.setSupportAge(true);
        functionConfiguration.setSupportFace3dAngle(true);
        functionConfiguration.setSupportFaceDetect(true);
        functionConfiguration.setSupportFaceRecognition(true);
        functionConfiguration.setSupportGender(true);
        functionConfiguration.setSupportLiveness(true);
        functionConfiguration.setSupportIRLiveness(true);
        engineConfiguration.setFunctionConfiguration(functionConfiguration);

        //初始化引擎
        int initCode = this.init(engineConfiguration);

        if (initCode != ErrorInfo.MOK.getValue()) {
            System.out.println("初始化引擎失败");
        }
    }
}

package com.arcsoft;

import com.arcsoft.face.FaceFeature;
import com.arcsoft.face.FaceInfo;
import com.arcsoft.face.FaceSimilar;
import com.arcsoft.face.enums.ImageFormat;
import com.arcsoft.face.toolkit.ImageInfo;

import java.io.File;
import java.util.ArrayList;
import java.util.List;

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

public class MyDB {
    final double similarity = 0.6;
    private myEngine faceEngine;
    private String name;

    public MyDB(){
        faceEngine = new myEngine();
        faceEngine.setEngineModel(false);//image模式
        faceEngine.initEngine();
    }

    public boolean compare(FaceFeature faceFeature_camera,String fileName) {
        try {
            ImageInfo imageInfo = getRGBData(new File("src\\img\\" + fileName));
            List<FaceInfo> faceInfoList = new ArrayList<FaceInfo>();
            int detectCode = faceEngine.detectFaces(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), ImageFormat.CP_PAF_BGR24, faceInfoList);


            //特征提取
            FaceFeature faceFeature = new FaceFeature();
            int extractCode = faceEngine.extractFaceFeature(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), ImageFormat.CP_PAF_BGR24, faceInfoList.get(0), faceFeature);

            //特征比对
            FaceFeature targetFaceFeature = new FaceFeature();
            targetFaceFeature.setFeatureData(faceFeature.getFeatureData());
            FaceFeature sourceFaceFeature = new FaceFeature();
            sourceFaceFeature.setFeatureData(faceFeature_camera.getFeatureData());
            FaceSimilar faceSimilar = new FaceSimilar();
            int compareCode = faceEngine.compareFaceFeature(targetFaceFeature, sourceFaceFeature, faceSimilar);


            if (faceSimilar.getScore() > similarity) {
                name = fileName;
                return true;
            }
            else
                return false;
        } catch (IndexOutOfBoundsException e) {
            return false;
        }
    }

    public String getInfo(){//获取识别成功人员信息
        return name;
    }

}

package com.arcsoft;

import com.arcsoft.face.*;
import com.arcsoft.face.enums.ImageFormat;
import com.arcsoft.face.toolkit.ImageInfo;
import com.github.sarxos.webcam.Webcam;

import javax.imageio.ImageIO;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;

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

public class CameraInfo extends Thread{
    private static List<FaceInfo> faceInfoList;
    private static int max_j;//faceInfoList中最大脸编号
    private int maxFaceid;//上次活体检测时最大人脸Faceid
    private ImageInfo imageInfo;
    private List<LivenessInfo> livenessInfoList;
    private List<IrLivenessInfo> irLivenessInfo;
    private FaceFeature faceFeature;
    private FunctionConfiguration configuration;
    private myEngine faceEngine;
    public Webcam webcam;
    public static boolean Camera_ready = false;

    public CameraInfo(){
        webcam = Webcam.getDefault();
        faceInfoList = new ArrayList<FaceInfo>();
        livenessInfoList = new ArrayList<LivenessInfo>();
        irLivenessInfo = new ArrayList<IrLivenessInfo>();

        //初始化引擎
        faceFeature = new FaceFeature();
        faceEngine = new myEngine();
        faceEngine.setEngineModel(true);//video模式
        faceEngine.initEngine();

        this.start();

        //设置活体检测参数
        int paramCode = faceEngine.setLivenessParam(0.8f, 0.8f);

    }

    public void run(){
        while(true){
            try {
                List<FaceInfo> faceInfoList_now = new ArrayList<FaceInfo>();

                for(int i=0; i<6 ; i++) {//连拍6张，找能提取出脸的一张赋给faceInfoList，除非都没有人脸
                    //获取照片
                    try {
                        BufferedImage image = webcam.getImage();
                        ImageIO.write(image, "JPG", new File("src\\camera.jpg"));

                        //获取faceInfoList
                        imageInfo = getRGBData(new File("src\\camera.jpg"));
                        int detectCode2 = faceEngine.detectFaces(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), ImageFormat.CP_PAF_BGR24, faceInfoList_now);
                        if (faceInfoList_now.size() > 0)
                            break;
                    }catch(IllegalArgumentException e){

                    }
                }

                faceInfoList = new ArrayList<FaceInfo>(faceInfoList_now);

                Camera_ready = true;

                if(faceInfoList.size()>0) {
                    //System.out.println("!检测到人脸");
                    max_j = 0;
                    //找到最大人脸
                    double max_faceSize = 0;//最大人脸面积
                    int j;
                    for (j = 0; j < faceInfoList.size(); j++) {
                        double size = (faceInfoList.get(j).getRect().getRight() - faceInfoList.get(j).getRect().getLeft()) * (faceInfoList.get(j).getRect().getBottom() - faceInfoList.get(j).getRect().getTop());
                        if (size > max_faceSize) {
                            max_faceSize = size;
                            max_j = j;
                        }
                    }
                    /*
                    try {
                        //活体检测process
                        int processCode = faceEngine.process(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), ImageFormat.CP_PAF_BGR24, faceInfoList, configuration);
                    }catch(NullPointerException e){

                    }*/
                }
            }catch(IOException e){

            }
        }
    }

    public boolean isLiveness(){//返回是否活体

        if(faceInfoList.size()<=0) {//未检测到人脸
            System.out.println("未检测到人脸");
            return false;
        }

        //检测到人脸
        maxFaceid = faceInfoList.get(max_j).getFaceId();//最大脸faceid
        //特征提取
        int extractCode2 = faceEngine.extractFaceFeature(imageInfo.getImageData(), imageInfo.getWidth(), imageInfo.getHeight(), ImageFormat.CP_PAF_BGR24, faceInfoList.get(max_j), faceFeature);

        /*
        //RGB活体检测
        configuration = new FunctionConfiguration();
        configuration.setSupportLiveness(true);
        livenessInfoList = new ArrayList<LivenessInfo>();
        int livenessCode = faceEngine.getLiveness(livenessInfoList);

        //IR属性处理
        ImageInfo imageInfoGray = getGrayData(new File("src\\camera.jpg"));
        List<FaceInfo> faceInfoListGray = new ArrayList<FaceInfo>();
        int detectCodeGray = faceEngine.detectFaces(imageInfoGray.getImageData(), imageInfoGray.getWidth(), imageInfoGray.getHeight(), ImageFormat.CP_PAF_GRAY, faceInfoListGray);

        configuration = new FunctionConfiguration();
        configuration.setSupportIRLiveness(true);
        int processCode2 = faceEngine.processIr(imageInfoGray.getImageData(), imageInfoGray.getWidth(), imageInfoGray.getHeight(), ImageFormat.CP_PAF_GRAY, faceInfoListGray, configuration);

        //IR活体检测
        irLivenessInfo = new ArrayList<IrLivenessInfo>();
        int livenessIr = faceEngine.getLivenessIr(irLivenessInfo);

        //if(livenessInfoList.get(max_j).getLiveness()>0||irLivenessInfo.get(max_j).getLiveness()>0)*/
            return true;/*
        else{//未检测到活体
            System.out.println("未检测到活体");
            return false;
        }*/
    }

    public FaceFeature returnFaceFeature(){//返回最大脸的FaceFeature
        return faceFeature;
    }

    public int returnFaceId(){//返回上次活体检测最大脸的FaceId
        return maxFaceid;
    }//返回上次检测最大人脸faceid

    public static List<FaceInfo> returnFaceInfoList(){//返回实时faceInfoList
        return faceInfoList;
    }

    public static int returnMax(){//返回实时最大人脸编号
        return max_j;
    }
}