Android-人脸通行工程

FaceAuth faceAuth = new FaceAuth();
faceAuth.initLicenseOnLine(this, key, new AuthCallback() {
            @Override
            public void onResponse(final int code, final String response, String licenseKey) {
                if (code == 0) {
                    // 如果激活成功
                    // 初始化模型
                    FaceSDKManager.getInstance().initModel(mContext);
                    // 初始化数据库
                    DBManager.getInstance().init(getApplicationContext());
                    finish();
                } else {
                    ToastUtils.toast(mContext, code + "  " + response);
                }
            }
        });

public void initModel(final Context context) {
	// 加载人脸检测模型
    faceDetector.initModel(context, "enc_detect_vgg_anakin.lite.bin",
            "small_detect.model",
            "enc_net_deploy_stageI.anakin.bin", new FaceCallback() {
                @Override
                public void onResponse(int code, String response) {
                    ToastUtils.toast(context, code + "  " + response);
                }
            });
	// 设定人脸检测配置参数，该方法采取默认参数
    faceDetector.loadConfig(getFaceEnvironmentConfig());
	// 加载特征提取模型
    faceFeature.initModel(context, "enc_sphere_resnet34_128_580_pytorch_anakin.bin",
            "enc_fsp_fc128_160_pytorch_anakin.bin",
            "", new FaceCallback() {
                @Override
                public void onResponse(int code, String response) {
                    ToastUtils.toast(context, code + "  " + response);
                    ;
                }
            });
	// 加载活体检测模型
    faceLiveness.initModel(context, "enc_model_rgb_145_anakin.bin",
            "enc_nir_anakin.lite.bin",
            "enc_depth_anakin.lite.bin", new FaceCallback() {
                @Override
                public void onResponse(int code, String response) {
                    ToastUtils.toast(context, code + "  " + response);
                }
            });
}

FaceEnvironment	faceEnvironment = new FaceEnvironment();
faceEnvironment.setMinFaceSize(50);
faceEnvironment.setMaxFaceSize(-1);
faceEnvironment.setDetectInterval(200);      
faceEnvironment.setTrackInterval(500);
faceEnvironment.setNoFaceSize(0.5f);
faceEnvironment.setPitch(30);
faceEnvironment.setYaw(30);
faceEnvironment.setRoll(30);
faceEnvironment.setCheckBlur(true);
faceEnvironment.setOcclusion(true);
faceEnvironment.setIllumination(true);
faceEnvironment.setDetectMethodType(FaceDetect.DetectType.DETECT_VIS);

faceAuth.initLicenseOffLine(this, new AuthCallback() {
            @Override
            public void onResponse(final int code, final String response, String licenseKey) {
                if (code == 0) {
                    GlobalSet.FACE_AUTH_STATUS = 0;
                    // 初始化人脸
                    FaceSDKManager.getInstance().initModel(mContext);
                    // 初始化数据库
                    DBManager.getInstance().init(getApplicationContext());
                    finish();
                } else {
                    ToastUtils.toast(mContext, code + "  " + response);
                }
            }
        });

FaceInfo[] faceInfos = null;
    if (mRgbArray != null) {
		// 进行人脸检测
        faceInfos = FaceSDKManager.getInstance().getFaceDetector().trackMaxFace(mRgbArray, width, height);
    }
	// 保存相关图片信息
    LivenessModel livenessModel = new LivenessModel();
    livenessModel.setRgbDetectDuration(System.currentTimeMillis() - startTime);
    livenessModel.getImageFrame().setArgb(mRgbArray);
    livenessModel.getImageFrame().setWidth(width);
    livenessModel.getImageFrame().setHeight(height);
    livenessModel.setLiveType(type);

    if (faceInfos != null && faceInfos.length > 0) {
        livenessModel.setTrackFaceInfo(faceInfos);
        FaceInfo faceInfo = faceInfos[0];
        livenessModel.setFaceInfo(faceInfo);
        livenessModel.setLandmarks(faceInfo.landmarks);

        // 返回检测到人脸的信息，用于画人脸框
        if (faceDetectCallBack != null) {
            faceDetectCallBack.onFaceDetectCallback(true, (int) faceInfo.mWidth,
                    (int) faceInfo.mWidth, (int) faceInfo.mCenter_x, (int) faceInfo.mCenter_y,
                    width, height);
        }

        if (livenessCallBack != null) {
            livenessCallBack.onTip(1, "活体判断中");
        }

        Log.e("lth_id",""+curFaceID+"   "+livenessModel.getFaceInfo().face_id);

		// 活体检测，获取活体分值
        float rgbScore = 0;
        if ((type & MASK_RGB) == MASK_RGB) {
            startTime = System.currentTimeMillis();
            rgbScore = rgbLiveness(mRgbArray, width, height, faceInfos[0].landmarks);
            livenessModel.setRgbLivenessScore(rgbScore);
            livenessModel.setRgbLivenessDuration(System.currentTimeMillis() - startTime);
        }
        ......
    }

public void registFace(LivenessModel livenessModel) {
	// 人脸特征提取
    byte[] bytes = new byte[512];
    float length = FaceSDKManager.getInstance().getFaceFeature().extractFeature(
            livenessModel.getImageFrame().getArgb(),
            livenessModel.getImageFrame().getHeight(),
            livenessModel.getImageFrame().getWidth(),
            bytes,
            livenessModel.getLandmarks());
	// 如果特征值提取正常
    if (length == 128) {
        Feature feature = new Feature();
        feature.setCtime(System.currentTimeMillis());
        feature.setFeature(bytes);
        feature.setUserName(registNickName);
        final String uid = UUID.randomUUID().toString();
        feature.setUserId(uid);
        feature.setGroupId("0");
        
        int imgWidth = livenessModel.getImageFrame().getWidth();
        int imgHeight = livenessModel.getImageFrame().getHeight();
        Bitmap registBmp = registBmp = Bitmap.createBitmap(imgWidth,
                imgHeight, Bitmap.Config.ARGB_8888);
        registBmp.setPixels(livenessModel.getImageFrame().getArgb(), 0, imgWidth, 0, 0, imgWidth, imgHeight);
        
        // 保存图片到新目录中
        File facePicDir = FileUtils.getFacePicDirectory();
        // 保存抠图图片到新目录中
        File faceCropDir = FileUtils.getFaceCropPicDirectory();
        String picFile = "regist_" + uid + "_rgb.png";

        if (facePicDir != null) {
            File savePicPath = new File(facePicDir, picFile);
            if (FileUtils.saveFile(savePicPath, registBmp)) {
                Log.i(TAG, "图片保存成功");
                feature.setImageName(picFile);
            }
        }

        Bitmap cropBitmap = null;
        String cropImgName = null;
        // 人脸抠图
        FaceInfo faceInfo = livenessModel.getFaceInfo();
        if (faceInfo != null) {
            cropBitmap = ImageUtils.noBlackBoundImgCrop(faceInfo.landmarks,
                    livenessModel.getImageFrame().getHeight(), livenessModel.getImageFrame().getWidth(),
                    livenessModel.getImageFrame().getArgb());

            if (cropBitmap == null) {
                cropBitmap = registBmp;
            }

            cropImgName = "crop_" + picFile;
        }
        if (faceCropDir != null && cropBitmap != null) {
            File saveCropPath = new File(faceCropDir, cropImgName);
            if (FileUtils.saveFile(saveCropPath, cropBitmap)) {
                Log.i(TAG, "抠图图片保存成功");
                feature.setCropImageName(cropImgName);
            }
        }

		// 将人脸信息保存数据库
        if (FaceApi.getInstance().featureAdd(feature)) {
			// 注册成功，返回结果
            returnRegistResult(0, livenessModel, cropBitmap);
        }
        return;
    }
}

// 如果是NIR摄像头，则用BinocularView加载
if (GlobalSet.getLiveStatusValue() == GlobalSet.LIVE_STATUS.RGN_NIR) {
        mBinocularView = new BinocularView(mContext);
        mBinocularView.setImageView(mImageTrack);
        mBinocularView.setLivenessCallBack(this);
        mCameraView.addView(mBinocularView, layoutParams);
} else {  // 如果是RGB摄像头，则用MonocularView加载
        mMonocularView = new MonocularView(mContext);
        mMonocularView.setImageView(mImageTrack);
        mMonocularView.setLivenessCallBack(this);
        mCameraView.addView(mMonocularView, layoutParams);
}

// 开始调用人脸相关接口
private synchronized void checkData() {
    if (rgbData != null) {
        FaceSDKManager.getInstance().getFaceLiveness().setNirRgbInt(null);
        FaceSDKManager.getInstance().getFaceLiveness().setRgbInt(rgbData);
        FaceSDKManager.getInstance().getFaceLiveness().setIrData(null);
        FaceSDKManager.getInstance().getFaceLiveness().livenessCheck(mTrackImageWidth, mTrackImageHeight,
                GlobalSet.getLiveStatusValue() == GlobalSet.LIVE_STATUS.RGB ? 0X0001 : 0X0000);
        rgbData = null;
    }
}

// 实现人脸检测、活体检测
private boolean onLivenessCheck(int width, int height, int type) {
    boolean isLiveness = false;

    long startTime = System.currentTimeMillis();
    FaceInfo[] faceInfos = null;
    if (mRgbArray != null) {
		// 人脸检测，获取人脸信息
        faceInfos = FaceSDKManager.getInstance().getFaceDetector().trackMaxFace(mRgbArray, width, height);
    }
    LivenessModel livenessModel = new LivenessModel();
    livenessModel.setRgbDetectDuration(System.currentTimeMillis() - startTime);
    livenessModel.getImageFrame().setArgb(mRgbArray);
    livenessModel.getImageFrame().setWidth(width);
    livenessModel.getImageFrame().setHeight(height);
    livenessModel.setLiveType(type);

    if (faceInfos != null && faceInfos.length > 0
            && faceInfos[0].mConf >= GlobalSet.getDetectConfValue()) {
        livenessModel.setTrackFaceInfo(faceInfos);
        FaceInfo faceInfo = faceInfos[0];
        livenessModel.setFaceInfo(faceInfo);
        livenessModel.setLandmarks(faceInfo.landmarks);

        // 返回检测到人脸的事件
        if (faceDetectCallBack != null) {
            faceDetectCallBack.onFaceDetectCallback(true, (int) faceInfo.mWidth,
                    (int) faceInfo.mWidth, (int) faceInfo.mCenter_x, (int) faceInfo.mCenter_y,
                    width, height);
        }

        if (livenessCallBack != null) {
            livenessCallBack.onTip(1, "活体判断中");
        }

        if (currentTaskType == TASK_TYPE_ONETON && livenessModel.getFaceInfo().face_id == curFaceID) {
            return true;
        }

        float rgbScore = 0;
        if ((type & MASK_RGB) == MASK_RGB) {
            startTime = System.currentTimeMillis();
			// 活体检测
            rgbScore = rgbLiveness(mRgbArray, width, height, faceInfos[0].landmarks);
            livenessModel.setRgbLivenessScore(rgbScore);
            livenessModel.setRgbLivenessDuration(System.currentTimeMillis() - startTime);
        }
        
        if (livenessCallBack != null) {
            switch (currentTaskType) {
                case TASK_TYPE_ONETON:
                    filterFeature(livenessModel);
                    break;
                default:
                    break;
            }

        }
    } else {
        // 返回检测到人脸的事件
        if (faceDetectCallBack != null) {
            faceDetectCallBack.onFaceDetectCallback(false, 0,
                    0, 0, 0, 0, 0);
        }
        if (livenessCallBack != null) {
            livenessCallBack.onCallback(1, null);
            livenessCallBack.onTip(1, "未检测到人脸");
        }
    }
    livenessModel.setTrackFaceInfo(faceInfos);
    if (livenessCallBack != null) {
        livenessCallBack.onCanvasRectCallback(livenessModel);
    }
    return isLiveness;
}

// 特征值提取
public boolean onFeatureCheck(LivenessModel livenessModel) {
    if ((GlobalSet.getLiveStatusValue() == GlobalSet.LIVE_STATUS.NO) ||
            (GlobalSet.getLiveStatusValue() == GlobalSet.LIVE_STATUS.RGB
                    && livenessModel.getRgbLivenessScore() > GlobalSet.getLiveRgbValue())) {
        byte[] visFeature = new byte[512];
        long sTime = System.currentTimeMillis();
		// 特征值提取
        float length = FaceSDKManager.getInstance().getFaceFeature().extractFeature(
                livenessModel.getImageFrame().getArgb(),
                livenessModel.getImageFrame().getHeight(),
                livenessModel.getImageFrame().getWidth(),
                visFeature,
                livenessModel.getLandmarks());
        livenessModel.setFeatureDuration(System.currentTimeMillis() - sTime);
        if (length == 128) {
            livenessModel.setFeatureByte(visFeature);
            return true;
        }
    }
    return false;
}

// 将拿到的特征进行比对，并将结果返回
public void filterFeature(LivenessModel livenessModel) {
    if (onFeatureCheck(livenessModel)) {
        long sTime = System.currentTimeMillis();
		// 方法内部实现比对，并将结果存入数据库
        Feature feature = FaceSDKManager.getInstance().getFeature(
                FaceFeature.FeatureType.FEATURE_VIS, livenessModel.getFeatureByte(), livenessModel);
        livenessModel.setCheckDuration(System.currentTimeMillis() - sTime);
        Log.e("lth_sc", "" + livenessModel.getCheckDuration());
        if (feature != null) {
            curFaceID = livenessModel.getFaceInfo().face_id;
            livenessModel.setFeature(feature);
            livenessCallBack.onCallback(0, livenessModel);
            return;
        }
    }
    livenessCallBack.onCallback(1, livenessModel);
}

public void onResume() {
    if (mCameraNum == 0) {
        Toast.makeText(context, "未检测到摄像头", Toast.LENGTH_LONG).show();
        return;
	} else {
        try {
            Camera.CameraInfo info = new Camera.CameraInfo();
            int numCameras = Camera.getNumberOfCameras();
            for (int i = 0; i < numCameras; i++) {
				// 获取摄像头信息，判断是前置摄像头还是后置摄像头
                Camera.getCameraInfo(i, info);
                if (info.facing == Camera.CameraInfo.CAMERA_FACING_FRONT) {
                    mCamera = Camera.open(i);
                    break;
                }
            }
            // 如果没有前置摄像头，则打开默认的后置摄像头
            if (mCamera == null) {
                mCamera = Camera.open(0);
            }
            // 没有摄像头时，抛出异常
            if (mCamera == null) {
                throw new RuntimeException("Unable to open camera");
            }
			
			// 设置摄像头预览角度
            mCamera.setDisplayOrientation(previewAngle);
            mPreview.setCamera(mCamera, PREFER_WIDTH, PERFER_HEIGH);
            mCamera.setPreviewCallback(new Camera.PreviewCallback() {
                @Override
                public void onPreviewFrame(byte[] data, Camera camera) {
                    dealRgb(data);
                }
            });
        } catch (RuntimeException e) {
            // Log.e(TAG, e.getMessage());
        }
    }

    if (mTextureViewOne != null) {
        mTextureViewOne.setOpaque(false);
    }
}

// 搜索按钮
if (v == mImageSearch) {
    String searchContent = mEditContent.getText().toString().trim();
    // 根据关键字查找人脸库
    UserInfoManager.getInstance().getFeatureInfo(searchContent, mUserInfoListener);
}

// 检测人脸，提取人脸特征值
ret = FaceApi.getInstance().getFeature(argbImg, bytes,
        FaceFeature.FeatureType.FEATURE_VIS, environment, faceInfos);
FaceInfo faceInfo = faceInfos[0];
Log.e(TAG, "live_photo = " + ret);

// 获取导入图片目录 /sdcard/Import Faces/FacePictures
File batchPicDir = FileUtils.getBatchFacePicDirectory();
String[] picFiles = batchPicDir.list();
if (picFiles == null || picFiles.length == 0) {
    if (mImportListener != null) {
        mImportListener.showToastMessage("导入图片的文件夹没有图片");
    }
    return;
}

// 根据姓名查询数据库与文件中对应的姓名是否相等，如果相等，则直接过滤
List<Feature> listFeatures = DBManager.getInstance().queryFeatureByName(userName);
if (listFeatures != null && listFeatures.size() > 0) {
    String msg = "与之前图片对应的姓名相同";
    // 保存失败信息
    logBuilder.append(userName + "\t" + picFile + "\t"
            + "失败" + "\t" + msg + "\n");

Log.e(TAG, picFile + "未检测到人脸，可能原因：人脸太小");
String msg = "未检测到人脸，可能原因：人脸太小"
        + "（必须大于最小检测人脸minFaceSize），"
        + "或者人脸角度太大，人脸不是朝上";
logBuilder.append(userName + "\t" + picFile + "\t"
        + "失败" + "\t" + msg + "\n");

// 从数据库中删除
UserInfoManager.getInstance().batchRemoveFeatureInfo(mListFeatureInfo, mUserInfoListener,
        mSelectCount);

// 复制数据库到内存
public void copyDBFileToData() {
    String sqlPath = "/sdcard/bdface/import/bdface.db";
    String newPath = "/data/data/com.baidu.idl.face.demo/databases/bdface.db";
    if (FileUtils.copyFile(sqlPath, newPath)){
        if (mDBFileListener != null) {
            mDBFileListener.importDBSuccess();
        }
    } else {
        if (mDBFileListener != null) {
            mDBFileListener.showErrMsg();
        }
    }
}

// 复制数据库到SD卡
public void copyDBFileToSDCard() {
    String sqlPath = "/data/data/com.baidu.idl.face.demo/databases/bdface.db";
    String newPath = "/sdcard/bdface/output/bdface.db";
    if (FileUtils.copyFile(sqlPath, newPath)){
        if (mDBFileListener != null) {
            mDBFileListener.outputDBSuccess();
        }
    } else {
        if (mDBFileListener != null) {
            mDBFileListener.showErrMsg();
        }
    }
}

// 质量参数阈值类型
public static final String TYPE_BLURR_THRESHOLD = "TYPE_BLURR_THRESHOLD";
public static final String TYPE_OCCLUSION_THRESHOLD = "TYPE_OCCLUSION_THRESHOLD";
public static final String TYPE_ILLUMINATION_THRESHOLD = "TYPE_ILLUMINATION_THRESHOLD";

if (GlobalSet.getStructuredLightValue() == GlobalSet.STRUCTURED_LIGHT.OBI_ASTRA_PRO) {
    intent = new Intent(this, OrbbecProPassActivity.class);
} else if (GlobalSet.getStructuredLightValue() == GlobalSet.STRUCTURED_LIGHT.OBI_ASTRA_MINI) {
    intent = new Intent(this, OrbbecMiniPassActivity.class);
} else if (GlobalSet.getStructuredLightValue() == GlobalSet.STRUCTURED_LIGHT.HUAJIE_AMY_MINI) {
    intent = new Intent(this, IminectPassActivity.class);
}