package com.basic.security.utils;
|
|
import android.content.ContextWrapper;
|
import android.graphics.Bitmap;
|
import android.graphics.BitmapFactory;
|
import android.text.TextUtils;
|
import android.util.DisplayMetrics;
|
|
import com.basic.security.activity.MainActivity;
|
import com.basic.security.base.BaseApplication;
|
import com.basic.security.manager.BaseSettingManager;
|
import com.basic.security.manager.DetectResultManager;
|
import com.basic.security.manager.FaceTitleAndTipsManager;
|
import com.basic.security.utils.socket.CameraYuvSocketServer;
|
|
import java.io.ByteArrayOutputStream;
|
import java.io.File;
|
import java.util.ArrayList;
|
import java.util.List;
|
|
public class ProcessImageAndDrawResults {
|
|
public static int shouldExtractFeatureFirstTimeInWaitFace = 2;
|
static List<DetectListener> detectListeners = new ArrayList<>();
|
public byte[] originalCameraData;
|
public int rgb_gray_camera;
|
public int mStopping;
|
public int mStopped;
|
public byte[] mYUVData;
|
public byte[] mRGBData;
|
public int mImageWidth, mImageHeight;
|
public boolean rotated;
|
public long lastTimeDetectedFace = 0;
|
public long lastTimeSuccessExtractedFeature = 0;
|
public DetectedResult previewDetectResult = new DetectedResult();
|
public byte[] bgrArrayCopyForFeature = null;
|
public byte[] nv21ArrayCopyForFeature = null;
|
public Object copyForFeatureLock = new Object();
|
BitmapHolder bitmapHolder = new BitmapHolder();
|
int shoudExractFeatureCount = 0;
|
int shouldExtractFeature = 0;
|
boolean shouldExtractFeatureThreadFinished = true;
|
|
public ProcessImageAndDrawResults(int rgb_gray_camera) {
|
this.rgb_gray_camera = rgb_gray_camera;
|
}
|
|
public static void addDetectedListener(DetectListener detectListener) {
|
detectListeners.add(detectListener);
|
}
|
|
public void setRgb_gray_camera(int rgb_gray_camera) {
|
this.rgb_gray_camera = rgb_gray_camera;
|
}
|
|
public void start(Bitmap frameBitmap, byte[] bgrArray, byte[] nv21Array) {
|
if (mRGBData == null) {
|
return;
|
}
|
if (rgb_gray_camera == Constants.RGB_CAMERA) {
|
BaseApplication.getApplication().detectLock.lock();
|
}
|
try {
|
detectFace(rgb_gray_camera, frameBitmap, bgrArray, nv21Array);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
if (rgb_gray_camera == Constants.RGB_CAMERA) {
|
BaseApplication.getApplication().detectLock.unlock();
|
}
|
}
|
|
public void start1(byte[] nv21Array) {
|
if (rgb_gray_camera == Constants.RGB_CAMERA) {
|
BaseApplication.getApplication().detectLock.lock();
|
}
|
try {
|
detectFace1(rgb_gray_camera, nv21Array);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
if (rgb_gray_camera == Constants.RGB_CAMERA) {
|
BaseApplication.getApplication().detectLock.unlock();
|
}
|
}
|
|
private byte[] cropImage(int x1, int y1, int x2, int y2, String frameJpgPath, Bitmap frameBitmap) {
|
float ratio = 0.8f;
|
int enlargeWidth = (int) (ratio * (x2 - x1));
|
int enlargeHeight = (int) (ratio * (y2 - y1));
|
x1 = x1 - enlargeWidth / 2;
|
x2 = x2 + enlargeWidth / 2;
|
y1 = y1 - enlargeHeight / 2;
|
y2 = y2 + enlargeHeight / 2;
|
if (x1 < 0) {
|
x1 = 0;
|
}
|
if (y1 < 0) {
|
y1 = 0;
|
}
|
if (x2 > mImageWidth) {
|
x2 = mImageWidth;
|
}
|
if (y2 > mImageHeight) {
|
y2 = mImageHeight;
|
}
|
int width = (x2 - x1);
|
int height = (y2 - y1);
|
if (width > mImageWidth) {
|
width = mImageWidth;
|
}
|
if (height > mImageHeight) {
|
height = mImageHeight;
|
}
|
Bitmap bitmap = null;
|
if (frameBitmap != null) {
|
bitmap = frameBitmap;
|
} else {
|
bitmap = BitmapFactory.decodeFile(frameJpgPath);
|
}
|
|
byte[] faceData = null;
|
if (bitmap != null) {
|
bitmapHolder.storeBitmap(bitmap);
|
bitmapHolder.cropBitmap(x1, y1, x2, y2);
|
Bitmap faceBitmap = bitmapHolder.getBitmapAndFree();
|
ByteArrayOutputStream stream = new ByteArrayOutputStream();
|
faceBitmap.compress(Bitmap.CompressFormat.JPEG, 100, stream);
|
faceData = stream.toByteArray();
|
|
if (faceBitmap != null && !faceBitmap.isRecycled()) {
|
faceBitmap.recycle();
|
}
|
faceBitmap = null;
|
bitmap = null;
|
}
|
|
return faceData;
|
}
|
|
private void setPosition(FacePosition facePosition, int x1, int y1, int x2, int y2) {
|
float ratio = 0.5f;
|
int enlargeWidth = (int) (ratio * (x2 - x1));
|
int enlargeHeight = (int) (ratio * (y2 - y1));
|
x1 = x1 - enlargeWidth / 2;
|
x2 = x2 + enlargeWidth / 2;
|
y1 = y1 - enlargeHeight / 2;
|
y2 = y2 + enlargeHeight / 2;
|
if (x1 < 0) {
|
x1 = 0;
|
}
|
if (y1 < 0) {
|
y1 = 0;
|
}
|
if (x2 > mImageWidth) {
|
x2 = mImageWidth;
|
}
|
if (y2 > mImageHeight) {
|
y2 = mImageHeight;
|
}
|
int width = (x2 - x1);
|
int height = (y2 - y1);
|
if (width > mImageWidth) {
|
width = mImageWidth;
|
}
|
if (height > mImageHeight) {
|
height = mImageHeight;
|
}
|
facePosition.x1 = x1;
|
facePosition.y1 = y1;
|
facePosition.x2 = x2;
|
facePosition.y2 = y2;
|
facePosition.faceRatio = (y2 - y1) * (x2 - x1) * 1.0 / (640 * 480);
|
}
|
|
public void addDetectedResult(DetectedResult detectedResult, int x1, int y1, int x2, int y2, float score, String frameJpgPath,
|
String faceJpgPath, long trackerId, boolean liveness, String resultText,
|
int featureId, String featureName,
|
int yaw,
|
int pitch,
|
int roll) {
|
try {
|
FacePosition facePosition = new FacePosition();
|
facePosition.detectedResult = detectedResult;
|
setPosition(facePosition, x1, y1, x2, y2);
|
facePosition.trackerId = trackerId;
|
facePosition.liveness = liveness;
|
facePosition.score = score;
|
facePosition.yaw = yaw;
|
facePosition.pitch = pitch;
|
facePosition.roll = roll;
|
facePosition.createTime = System.currentTimeMillis();
|
if (featureId != -1) {
|
facePosition.featureName = featureName;
|
}
|
detectedResult.facePositions.add(facePosition);
|
} catch (Exception e) {
|
e.printStackTrace();
|
}
|
}
|
|
private void detectFace(int rgbGrayCamera, Bitmap frameBitmap, byte[] bgrArray, byte[] nv21Array) throws Exception {
|
String outputFileName = "";
|
if (rgbGrayCamera == Constants.RGB_CAMERA) {
|
outputFileName = "rgb.jpg";
|
} else {
|
outputFileName = "gray.jpg";
|
}
|
String filesPath = new ContextWrapper(FaceId.activity).getFilesDir().getAbsolutePath();
|
File jpgFile = new File(filesPath, "image_" + outputFileName);
|
File featureFile = new File(filesPath, "feature");
|
File targetFile = new File(filesPath, outputFileName);
|
String resultsStr = "";
|
String resultText = "";
|
String[] results = null;
|
if (rgbGrayCamera == Constants.RGB_CAMERA) {
|
shoudExractFeatureCount++;
|
shouldExtractFeature = 0;
|
if (shoudExractFeatureCount % 4 == 0) {
|
shoudExractFeatureCount = 0;
|
}
|
if (Constants.useBgrArray) {
|
int shouldExtractFeatureInFirstDetect = 0;
|
if (System.currentTimeMillis() - lastTimeDetectedFace > 2 * 1000) {
|
shouldExtractFeatureInFirstDetect = 1;
|
}
|
//shouldExtractFeatureInFirstDetect = 1;
|
resultsStr = FaceId.instance.rgbDetectFace2(filesPath, targetFile.getAbsolutePath(),
|
mImageWidth, mImageHeight, featureFile.getAbsolutePath(),
|
shouldExtractFeatureInFirstDetect, Constants.USE_GRAY_CAMERA,
|
BaseSettingManager.allowMultipleFace() ? 20 : 1, bgrArray
|
);
|
|
long begin = System.currentTimeMillis();
|
final DetectedResult detectedResult1 = parseResult(resultsStr, rgbGrayCamera, nv21Array,
|
shouldExtractFeatureInFirstDetect > 0, shouldExtractFeatureInFirstDetect);
|
boolean needFaceTitle = false;
|
if (detectedResult1.facePositions.size() > 0) {
|
MainActivity mainActivity = BaseApplication.getApplication().activity;
|
if (mainActivity.currentFragment == mainActivity.fragment_su_auto_wait_face
|
|| mainActivity.currentFragment == mainActivity.fragment_door_access_result
|
) {
|
try {
|
FaceTitleAndTips faceTitleAndTips = FaceTitleAndTipsManager.getFaceTitleMap(detectedResult1.facePositions.get(0), true);
|
if ("".equals(faceTitleAndTips.faceTitle())) {
|
needFaceTitle = true;
|
}
|
} catch (Exception e) {
|
System.out.println("ProcessImageAndDrawResults.detectFace " + e.getMessage());
|
}
|
}
|
lastTimeDetectedFace = System.currentTimeMillis();
|
boolean extractedFeature = false;
|
for (FacePosition facePosition : detectedResult1.facePositions) {
|
if (!TextUtils.isEmpty(facePosition.featureName)) {
|
extractedFeature = true;
|
lastTimeSuccessExtractedFeature = System.currentTimeMillis();
|
break;
|
}
|
}
|
if (shouldExtractFeatureInFirstDetect > 0 && !extractedFeature) {
|
lastTimeDetectedFace = 0;
|
}
|
if (shouldExtractFeatureInFirstDetect > 0) {
|
}
|
} else {
|
BaseApplication.getApplication().activity.fragment_camera.hideAllFaceRects();
|
lastTimeDetectedFace = 0;
|
if (System.currentTimeMillis() - lastTimeDetectedFace > 2 * 1000) {
|
FaceTitleAndTipsManager.clearFaceTitle();
|
}
|
}
|
|
if (shouldExtractFeatureThreadFinished &&
|
shouldExtractFeatureInFirstDetect == 0 &&
|
resultsStr.length() > 0 &&
|
((shouldExtractFeatureFirstTimeInWaitFace > 0 || (shouldExtractFeature > 0)) ||
|
((System.currentTimeMillis() - lastTimeSuccessExtractedFeature) > 1000) ||
|
needFaceTitle)
|
) {
|
shouldExtractFeatureFirstTimeInWaitFace--;
|
if (bgrArrayCopyForFeature == null || bgrArrayCopyForFeature.length != bgrArray.length) {
|
bgrArrayCopyForFeature = new byte[bgrArray.length];
|
}
|
if (nv21ArrayCopyForFeature == null || nv21ArrayCopyForFeature.length != nv21Array.length) {
|
nv21ArrayCopyForFeature = new byte[nv21Array.length];
|
}
|
if (BaseApplication.getApplication().activity.needCopyCameraData()) {
|
synchronized (copyForFeatureLock) {
|
System.arraycopy(bgrArray, 0, bgrArrayCopyForFeature, 0, bgrArrayCopyForFeature.length);
|
System.arraycopy(nv21Array, 0, nv21ArrayCopyForFeature, 0, nv21ArrayCopyForFeature.length);
|
}
|
} else {
|
bgrArrayCopyForFeature = bgrArray;
|
nv21ArrayCopyForFeature = nv21Array;
|
}
|
if (BaseApplication.getApplication().activity.needCopyCameraData()) {
|
extractFeature(filesPath, targetFile, featureFile, rgbGrayCamera, detectedResult1);
|
} else {
|
BaseApplication.getApplication().executorService.execute(new Runnable() {
|
@Override
|
public void run() {
|
extractFeature(filesPath, targetFile, featureFile, rgbGrayCamera, detectedResult1);
|
}
|
});
|
}
|
|
}
|
shouldExtractFeature = 0;
|
} else {
|
resultsStr = FaceId.instance.rgbDetectFace(filesPath, targetFile.getAbsolutePath(),
|
mImageWidth, mImageHeight, featureFile.getAbsolutePath(),
|
shouldExtractFeature, Constants.USE_GRAY_CAMERA,
|
BaseSettingManager.allowMultipleFace() ? 20 : 1
|
);
|
}
|
|
} else {
|
resultsStr = FaceId.instance.grayDetectFace(filesPath, targetFile.getAbsolutePath(), mImageWidth, mImageHeight,
|
BaseSettingManager.allowMultipleFace() ? 20 : 1);
|
}
|
}
|
|
private void extractFeature(String filesPath, File targetFile, File featureFile, int rgbGrayCamera, DetectedResult detectedResult1) {
|
shouldExtractFeatureThreadFinished = false;
|
|
synchronized (copyForFeatureLock) {
|
String resultsStr = FaceId.instance.rgbDetectFace4(1, filesPath, targetFile.getAbsolutePath(),
|
mImageWidth, mImageHeight, featureFile.getAbsolutePath(),
|
1, Constants.USE_GRAY_CAMERA,
|
BaseSettingManager.allowMultipleFace() ? 20 : 1, bgrArrayCopyForFeature);
|
if (resultsStr.length() > 0) {
|
DetectedResult detectedResult2 = parseResult(resultsStr, rgbGrayCamera, nv21ArrayCopyForFeature, true, 1, detectedResult1);
|
for (FacePosition facePosition : detectedResult2.facePositions) {
|
if (!TextUtils.isEmpty(facePosition.featureName)) {
|
lastTimeSuccessExtractedFeature = System.currentTimeMillis();
|
break;
|
}
|
}
|
}
|
}
|
shouldExtractFeatureThreadFinished = true;
|
}
|
|
private void detectFace1(int rgbGrayCamera, byte[] nv21Array) throws Exception {
|
String outputFileName = "";
|
if (rgbGrayCamera == Constants.RGB_CAMERA) {
|
outputFileName = "rgb.jpg";
|
} else {
|
outputFileName = "gray.jpg";
|
}
|
String filesPath = new ContextWrapper(FaceId.activity).getFilesDir().getAbsolutePath();
|
File jpgFile = new File(filesPath, "image_" + outputFileName);
|
File featureFile = new File(filesPath, "feature");
|
File targetFile = new File(filesPath, outputFileName);
|
String resultsStr = "";
|
if (rgbGrayCamera == Constants.RGB_CAMERA) {
|
shoudExractFeatureCount++;
|
shouldExtractFeature = 0;
|
if (shoudExractFeatureCount % 4 == 0) {
|
shouldExtractFeature = 1;
|
shoudExractFeatureCount = 0;
|
}
|
shouldExtractFeature = 1;
|
resultsStr = FaceId.instance.rgbDetectFace3(0, filesPath,
|
mImageWidth, mImageHeight, featureFile.getAbsolutePath(),
|
shouldExtractFeature, Constants.USE_GRAY_CAMERA,
|
BaseSettingManager.allowMultipleFace() ? 20 : 1, nv21Array
|
);
|
if (shouldExtractFeature > 0) {
|
parseResult(resultsStr, rgbGrayCamera, nv21Array, false, shouldExtractFeature);
|
} else {
|
parseResult(resultsStr, rgbGrayCamera, nv21Array, false, shouldExtractFeature);
|
}
|
} else {
|
resultsStr = FaceId.instance.grayDetectFace(filesPath, targetFile.getAbsolutePath(), mImageWidth, mImageHeight,
|
BaseSettingManager.allowMultipleFace() ? 20 : 1);
|
}
|
|
}
|
|
public DetectedResult parseResult(String resultsStr, int rgbGrayCamera, byte[] nv21Array, boolean hasFeature, int shouldExtractFeature) {
|
return parseResult(resultsStr, rgbGrayCamera, nv21Array, hasFeature, shouldExtractFeature, null);
|
}
|
|
public DetectedResult parseResult(String resultsStr, int rgbGrayCamera, byte[] nv21Array, boolean hasFeature, int shouldExtractFeature, DetectedResult previewDetectResult1) {
|
String resultText = "";
|
String[] results = null;
|
results = resultsStr.split("\\|");
|
DisplayMetrics displayMetrics = new DisplayMetrics();
|
FaceId.activity.getWindowManager().getDefaultDisplay().getMetrics(displayMetrics);
|
DetectedResult detectedResult = null;
|
if (BaseApplication.getApplication().activity.needCopyCameraData()) {
|
detectedResult = DetectResultManager.getDetectResultFromCache(nv21Array);//new DetectedResult();
|
} else {
|
detectedResult = new DetectedResult();
|
detectedResult.nv21Array = nv21Array;
|
}
|
// detectedResult.nv21Array = nv21Array;
|
detectedResult.width = mImageWidth;
|
detectedResult.height = mImageHeight;
|
detectedResult.shouldExtractFeature = shouldExtractFeature > 0;
|
detectedResult.resultText = resultText;
|
|
for (String result : results) {
|
if (result.contains(",")) {
|
String elem[] = result.split(",", -1);
|
if (elem.length == 13) {
|
int left = Integer.parseInt(elem[0]);
|
int top = Integer.parseInt(elem[1]);
|
int right = Integer.parseInt(elem[2]);
|
int bottom = Integer.parseInt(elem[3]);
|
float score = Float.parseFloat(elem[4]);
|
long trackerId = Long.parseLong(elem[5]);
|
resultText += "" + elem[7] + "\r\n" + elem[5] + "\r\n" + elem[0] + "," + elem[1] + "," + elem[2] + "," + elem[3] + "\r\n" + elem[4] + "\r\n";
|
if (rgbGrayCamera == Constants.RGB_CAMERA) {
|
String faceJpgPath = new File(new ContextWrapper(FaceId.activity).getFilesDir().getAbsolutePath(), "image_rgb_face.jpg").getAbsolutePath();
|
int featureId = Integer.parseInt(elem[8]);
|
String featurePath = elem[9];
|
if (!"".equals(featurePath) && featurePath != null
|
&& featurePath.length() > 5 &&
|
featureId != -1) {
|
detectedResult.featureCount++;
|
}
|
int yaw = Integer.parseInt(elem[10]);
|
int pitch = Integer.parseInt(elem[11]);
|
int roll = Integer.parseInt(elem[12]);
|
addDetectedResult(detectedResult, left, top, right, bottom, score,
|
null, faceJpgPath, trackerId, elem[7].equals("活体"), resultText,
|
featureId,
|
featurePath,
|
yaw,
|
pitch,
|
roll
|
);
|
}
|
} else {
|
resultText += "[" + result.substring(0, result.lastIndexOf(',')) + "]="
|
+ result.substring(result.lastIndexOf(',') + 1) + "\r\n";
|
}
|
}
|
}
|
if (detectedResult.facePositions.size() > 0) {
|
MainActivity mainActivity = BaseApplication.getApplication().activity;
|
if (mainActivity.currentFragment == mainActivity.fragment_home) {
|
mainActivity.showFragment(mainActivity.fragment_su_auto_wait_face);
|
}
|
MainActivity.lastTimeDetectedFace = System.currentTimeMillis();
|
mainActivity.serialDeviceOpenLamp(20);
|
boolean isNewDetectResult = false;
|
if (detectedResult.facePositions.size() != previewDetectResult.facePositions.size()) {
|
isNewDetectResult = true;
|
} else {
|
for (int i = 0; i < detectedResult.facePositions.size(); i++) {
|
FacePosition facePosition = detectedResult.facePositions.get(i);
|
FacePosition previewFacePosition = previewDetectResult.facePositions.get(i);
|
if (facePosition.trackerId != previewFacePosition.trackerId) {
|
isNewDetectResult = true;
|
break;
|
}
|
}
|
}
|
detectedResult.originalCameraData = originalCameraData;
|
// detectedResult.originalCameraData = nv21Array;
|
if (isNewDetectResult) {
|
detectedResult.originalCameraDataChanged = true;
|
CameraYuvSocketServer.setDetectedResult(detectedResult);
|
previewDetectResult = detectedResult;
|
} else {
|
detectedResult.originalCameraDataChanged = false;
|
CameraYuvSocketServer.setDetectedResult(detectedResult);
|
}
|
}
|
if (previewDetectResult1 != null) {
|
for (int i = 0; i < previewDetectResult1.facePositions.size(); i++) {
|
if (i < detectedResult.facePositions.size()) {
|
detectedResult.facePositions.get(i).trackerId = previewDetectResult1.facePositions.get(i).trackerId;
|
}
|
}
|
}
|
for (DetectListener detectListener : detectListeners) {
|
detectListener.faceDetected(detectedResult);
|
}
|
return detectedResult;
|
}
|
|
}
|
