虹软人脸识别 - ArcFace Go应用套件接入说明

昨天看了虹软的发布会，得知应用套件要开源了，晚上看到在官网上线了，随后下载下来打算试一试。
但是运行工程的过程中，它报错了。。。查看错误信息，说的是缺少类（详细说明看下方）
咨询了下虹软小助手，表示这两个类确实是需要自己实现的
晚上加班把这个做出来了，不得不说虹软开放了应用套件，确实省去了很多研发时间，当天晚上就跑通了
下面把类实现分享在这里，给有需要的人做个参考。。

导航：
-- 获取ArcFaceGo包
-- 运行ArcFaceGo工程
-- 安装及使用
（这个编辑器不是很好用，不过勉强可以看）
一、获取ArcFaceGo包
进入虹软ArcFaceGo官方页面https://ai.arcsoft.com.cn/product/arcfacego.html，按照步骤获取`ArcFaceGo_Source_3.1.1.zip`，其中包含ArcFaceGo源码及相关文档信息。

二、运行ArcFaceGo工程
2.1 获取工程
解压`ArcFaceGo_Source_3.1.1.zip`，解压后进入`sourcecode`目录，解压其中的`ArcFaceGo.zip`获取工程

2.2 编译工程
2.2.1  查看编译报错
使用Android Studio打开工程，并执行`Build`，会提示报错，有两个类里有类不存在，需要自己实现：






2.2.2 实现Camera1Engine类

1. <font size="2">package com.arcsoft.arcfacesingle.libutil;
   
2. 
   
3. import android.graphics.ImageFormat;
   
4. import android.graphics.SurfaceTexture;
   
5. import android.hardware.Camera;
   
6. import android.util.Pair;
   
7. 
   
8. import com.arcsoft.asg.libcommon.contract.ICameraEngine;
   
9. 
   
10. import java.io.IOException;
    
11. import java.util.ArrayList;
    
12. import java.util.Collections;
    
13. import java.util.LinkedHashSet;
    
14. import java.util.List;
    
15. 
    
16. /**
    
17. * ICameraEngine的实现
    
18. */
    
19. public class Camera1Engine extends ICameraEngine {
    
20. 
    
21.     private static final int COUNT_CAMERA_ONE = 1;
    
22.     private static final int COUNT_CAMERA_TWO = 2;
    
23.     private Camera camera;
    
24.     private boolean usePreAlloc;
    
25. 
    
26.     @Override
    
27.     public void setUsePreAlloc(boolean usePreAlloc) {
    
28.         this.usePreAlloc = usePreAlloc;
    
29.     }
    
30. 
    
31.     @Override
    
32.     public void onPreviewFrame(byte[] data, Camera camera) {
    
33.         super.onPreviewFrame(data, camera);
    
34.         if (usePreAlloc) {
    
35.             camera.addCallbackBuffer(data);
    
36.         }
    
37.     }
    
38. 
    
39.     @Override
    
40.     public void startCamera(SurfaceTexture surfaceTexture, int cameraId, int previewRotation, int previewWidth,
    
41.                             int previewHeight, int bufferCount, int bufferSize) throws IOException {
    
42.         camera = Camera.open(cameraId);
    
43.         camera.setDisplayOrientation(previewRotation);
    
44.         Camera.Parameters parameters = camera.getParameters();
    
45.         parameters.setPreviewFormat(ImageFormat.NV21);
    
46.         parameters.setPreviewSize(previewWidth, previewHeight);
    
47.         List<String> supportedFocusModes = parameters.getSupportedFocusModes();
    
48.         if (supportedFocusModes != null && supportedFocusModes.size() > 0) {
    
49.             if (supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
    
50.                 parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE);
    
51.             } else if (supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
    
52.                 parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO);
    
53.             } else if (supportedFocusModes.contains(Camera.Parameters.FOCUS_MODE_AUTO)) {
    
54.                 parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);
    
55.             }
    
56.         }
    
57.         camera.setParameters(parameters);
    
58.         camera.setPreviewTexture(surfaceTexture);
    
59.         if (usePreAlloc) {
    
60.             for (int i = 0; i < bufferCount; i++) {
    
61.                 camera.addCallbackBuffer(new byte[bufferSize]);
    
62.             }
    
63.             camera.setPreviewCallbackWithBuffer(this);
    
64.         } else {
    
65.             camera.setPreviewCallback(this);
    
66.         }
    
67.         camera.startPreview();
    
68.     }
    
69. 
    
70.     @Override
    
71.     public void setPreviewTexture(SurfaceTexture surfaceTexture) {
    
72.         try {
    
73.             if (camera != null) {
    
74.                 camera.setPreviewTexture(surfaceTexture);
    
75.             }
    
76.         } catch (Exception e) {
    
77.             e.printStackTrace();
    
78.         }
    
79.     }
    
80. 
    
81.     @Override
    
82.     public void releaseCamera() {
    
83.         if (camera != null) {
    
84.             if (usePreAlloc) {
    
85.                 camera.setPreviewCallbackWithBuffer(null);
    
86.             } else {
    
87.                 camera.setPreviewCallback(null);
    
88.             }
    
89.             camera.stopPreview();
    
90.             camera.release();
    
91.             camera = null;
    
92.         }
    
93.     }
    
94. 
    
95.     @Override
    
96.     public List<Integer> getCameraPositionList() {
    
97.         List<Integer> cameraPosList = new ArrayList<>();
    
98.         int cameraPosBack = Camera.CameraInfo.CAMERA_FACING_BACK;
    
99.         int cameraPosFront = Camera.CameraInfo.CAMERA_FACING_FRONT;
    
100.         int cameraCount = Camera.getNumberOfCameras();
     
101.         if (cameraCount == COUNT_CAMERA_ONE) {
     
102.             cameraPosList.add(cameraPosBack);
     
103.         } else if (cameraCount >= COUNT_CAMERA_TWO) {
     
104.             cameraPosList.add(cameraPosBack);
     
105.             cameraPosList.add(cameraPosFront);
     
106.         }
     
107.         return cameraPosList;
     
108.     }
     
109. 
     
110.     @Override
     
111.     public List<Pair<Integer, Integer>> getCameraPreviewSizeList() {
     
112.         List<Camera.Size> commonSizeList = new ArrayList<>();
     
113.         int cameraPosBack = Camera.CameraInfo.CAMERA_FACING_BACK;
     
114.         int cameraPosFront = Camera.CameraInfo.CAMERA_FACING_FRONT;
     
115.         int cameraCount = Camera.getNumberOfCameras();
     
116.         if (cameraCount == COUNT_CAMERA_ONE) {
     
117.             try {
     
118.                 Camera backCamera = Camera.open(cameraPosBack);
     
119.                 commonSizeList = backCamera.getParameters().getSupportedPreviewSizes();
     
120.                 backCamera.release();
     
121.             } catch (Exception e) {
     
122.                 e.printStackTrace();
     
123.             }
     
124.         } else if (cameraCount >= COUNT_CAMERA_TWO) {
     
125.             List<Camera.Size> backSizeList;
     
126.             try {
     
127.                 Camera.CameraInfo cameraInfo2 = new Camera.CameraInfo();
     
128.                 Camera.getCameraInfo(cameraPosBack, cameraInfo2);
     
129.                 Camera backCamera = Camera.open(cameraPosBack);
     
130.                 backSizeList = backCamera.getParameters().getSupportedPreviewSizes();
     
131.                 backCamera.release();
     
132.             } catch (Exception e) {
     
133.                 backSizeList = new ArrayList<>();
     
134.             }
     
135.             List<Camera.Size> frontSizeList;
     
136.             try {
     
137.                 Camera.CameraInfo cameraInfo = new Camera.CameraInfo();
     
138.                 Camera.getCameraInfo(cameraPosFront, cameraInfo);
     
139.                 Camera frontCamera = Camera.open(cameraPosFront);
     
140.                 frontSizeList = frontCamera.getParameters().getSupportedPreviewSizes();
     
141.                 frontCamera.release();
     
142.             } catch (Exception e) {
     
143.                 frontSizeList = new ArrayList<>();
     
144.             }
     
145.             if (frontSizeList.size() > 0 && backSizeList.size() > 0) {
     
146.                 for (Camera.Size rgbPreviewSize : frontSizeList) {
     
147.                     for (Camera.Size irPreviewSize : backSizeList) {
     
148.                         if (irPreviewSize.width == rgbPreviewSize.width && irPreviewSize.height == rgbPreviewSize.height) {
     
149.                             commonSizeList.add(irPreviewSize);
     
150.                         }
     
151.                     }
     
152.                 }
     
153.             } else if (frontSizeList.size() > 0) {
     
154.                 commonSizeList = frontSizeList;
     
155.             } else if (backSizeList.size() > 0) {
     
156.                 commonSizeList = backSizeList;
     
157.             }
     
158.         }
     
159.         Collections.sort(commonSizeList, ((size, t1) -> {
     
160.             int leftWidth = size.width;
     
161.             int rightWidth = t1.width;
     
162.             return leftWidth - rightWidth;
     
163.         }));
     
164.         List<Camera.Size> sizeList = new ArrayList<>(new LinkedHashSet<>(commonSizeList));
     
165.         List<Pair<Integer, Integer>> cameraPairList = new ArrayList<>();
     
166.         if (sizeList.size() > 0) {
     
167.             for (Camera.Size size : sizeList) {
     
168.                 int sizeWidth = size.width;
     
169.                 int sizeHeight = size.height;
     
170.                 Pair<Integer, Integer> sizePair = new Pair<>(sizeWidth, sizeHeight);
     
171.                 cameraPairList.add(sizePair);
     
172.             }
     
173.         }
     
174.         return cameraPairList;
     
175.     }
     
176. }</font>

复制代码

2.2.3 实现ImageUtils类

1. <font size="2">package com.arcsoft.arcfacesingle.libutil;
   
2. 
   
3. import android.content.Context;
   
4. import android.graphics.Bitmap;
   
5. import android.graphics.BitmapFactory;
   
6. import android.graphics.Canvas;
   
7. import android.graphics.ImageFormat;
   
8. import android.graphics.Matrix;
   
9. import android.graphics.Rect;
   
10. import android.graphics.YuvImage;
    
11. import android.graphics.drawable.Drawable;
    
12. import android.text.TextUtils;
    
13. import android.util.Base64;
    
14. import android.util.Pair;
    
15. 
    
16. import androidx.annotation.DrawableRes;
    
17. import androidx.core.content.ContextCompat;
    
18. 
    
19. import java.io.BufferedOutputStream;
    
20. import java.io.ByteArrayOutputStream;
    
21. import java.io.File;
    
22. import java.io.FileInputStream;
    
23. import java.io.FileOutputStream;
    
24. import java.io.IOException;
    
25. import java.io.InputStream;
    
26. import java.io.OutputStream;
    
27. 
    
28. /**
    
29. * 图片管理工具类
    
30. */
    
31. public final class ImageUtils {
    
32.     private static final int FACE_DETECT_IMAGE_WIDTH_LIMIT = 4;
    
33.     private static final int FACE_DETECT_IMAGE_HEIGHT_LIMIT = 2;
    
34. 
    
35.     private ImageUtils() {
    
36.         throw new UnsupportedOperationException("无法初始化！");
    
37.     }
    
38. 
    
39.     /**
    
40.      * 判断bitmap是否为空
    
41.      *
    
42.      * @param src Bitmap对象
    
43.      * @return bitmap是否为空
    
44.      */
    
45.     private static boolean isEmptyBitmap(final Bitmap src) {
    
46.         return src == null || src.getWidth() == 0 || src.getHeight() == 0;
    
47.     }
    
48. 
    
49. 
    
50.     /**
    
51.      * 根据压缩格式将Bitmap转换为压缩后的图像数据
    
52.      *
    
53.      * @param bitmap Bitmap对象
    
54.      * @param format 压缩格式
    
55.      * @return 压缩后的图像数据
    
56.      */
    
57.     public static byte[] bitmap2Bytes(final Bitmap bitmap, final Bitmap.CompressFormat format) {
    
58.         if (bitmap == null) {
    
59.             return null;
    
60.         }
    
61.         ByteArrayOutputStream baos = new ByteArrayOutputStream();
    
62.         bitmap.compress(format, 100, baos);
    
63.         return baos.toByteArray();
    
64.     }
    
65. 
    
66.     /**
    
67.      * 将图片文件转换为Bitmap
    
68.      *
    
69.      * @param file 图片文件
    
70.      * @return Bitmap对象
    
71.      */
    
72.     public static Bitmap getBitmap(final File file) {
    
73.         if (file == null) {
    
74.             return null;
    
75.         }
    
76.         return BitmapFactory.decodeFile(file.getAbsolutePath());
    
77.     }
    
78. 
    
79.     /**
    
80.      * 根据最大宽高，将文件转换为Bitmap
    
81.      *
    
82.      * @param filePath  文件路径
    
83.      * @param maxWidth  最大宽度
    
84.      * @param maxHeight 最大高度
    
85.      * @return Bitmap对象
    
86.      */
    
87.     public static Bitmap getBitmap(final String filePath, int maxWidth, int maxHeight) {
    
88.         if (isSpace(filePath)) {
    
89.             return null;
    
90.         }
    
91.         BitmapFactory.Options options = new BitmapFactory.Options();
    
92.         options.inJustDecodeBounds = true;
    
93.         BitmapFactory.decodeFile(filePath, options);
    
94.         options.inSampleSize = calculateInSampleSize4(options, maxWidth, maxHeight);
    
95.         options.inJustDecodeBounds = false;
    
96.         return BitmapFactory.decodeFile(filePath, options);
    
97.     }
    
98. 
    
99.     /**
    
100.      * 根据最大宽高，将压缩图像数据转换为Bitmap
     
101.      *
     
102.      * @param imageBytes 压缩的图像数据，如jpeg/png等
     
103.      * @param maxWidth   最大宽度
     
104.      * @param maxHeight  最大高度
     
105.      * @return Bitmap对象
     
106.      */
     
107.     public static Bitmap getBitmap(final byte[] imageBytes, int maxWidth, int maxHeight) {
     
108.         if (imageBytes == null || imageBytes.length == 0) {
     
109.             return null;
     
110.         }
     
111.         BitmapFactory.Options options = new BitmapFactory.Options();
     
112.         options.inJustDecodeBounds = true;
     
113.         BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length, options);
     
114.         options.inSampleSize = calculateInSampleSize4(options, maxWidth, maxHeight);
     
115.         options.inJustDecodeBounds = false;
     
116.         return BitmapFactory.decodeByteArray(imageBytes, 0, imageBytes.length, options);
     
117.     }
     
118. 
     
119.     /**
     
120.      * 根据最大宽高，将图片文件转换为Bitmap
     
121.      *
     
122.      * @param filePath  图片文件路径
     
123.      * @param maxWidth  最大宽度
     
124.      * @param maxHeight 最大高度
     
125.      * @return Bitmap对象
     
126.      */
     
127.     public static Bitmap decodeFileWithThreshold(final String filePath, int maxWidth, int maxHeight) {
     
128.         Bitmap tempBitmap = getBitmap(filePath, maxWidth, maxHeight);
     
129.         if (tempBitmap != null) {
     
130.             if (tempBitmap.getWidth() > maxWidth || tempBitmap.getHeight() > maxHeight) {
     
131.                 Bitmap scaleBitmap = resizeImage(tempBitmap, maxWidth, maxHeight);
     
132.                 if (!tempBitmap.isRecycled()) {
     
133.                     tempBitmap.recycle();
     
134.                 }
     
135.                 return scaleBitmap;
     
136.             }
     
137.             return tempBitmap;
     
138.         }
     
139.         return null;
     
140.     }
     
141. 
     
142.     /**
     
143.      * 根据最大宽高，将图片数据转换为Bitmap
     
144.      *
     
145.      * @param imgBytes  图片数据，可以是JPEG/PNG等格式的压缩数据
     
146.      * @param maxWidth  最大宽度
     
147.      * @param maxHeight 最大高度
     
148.      * @return Bitmap对象
     
149.      */
     
150.     public static Bitmap decodeFileWithThreshold(byte[] imgBytes, int maxWidth, int maxHeight) {
     
151.         Bitmap tempBitmap = getBitmap(imgBytes, maxWidth, maxHeight);
     
152.         if (tempBitmap != null) {
     
153.             if (tempBitmap.getWidth() > maxWidth || tempBitmap.getHeight() > maxHeight) {
     
154.                 Bitmap scaleBitmap = resizeImage(tempBitmap, maxWidth, maxHeight);
     
155.                 if (!tempBitmap.isRecycled()) {
     
156.                     tempBitmap.recycle();
     
157.                 }
     
158.                 return scaleBitmap;
     
159.             }
     
160.             return tempBitmap;
     
161.         }
     
162.         return null;
     
163.     }
     
164. 
     
165.     /**
     
166.      * 根据资源ID获取Bitmap
     
167.      *
     
168.      * @param resId 资源ID
     
169.      * @return Bitmap对象
     
170.      */
     
171.     public static Bitmap getBitmap(@DrawableRes final int resId, Context context) {
     
172.         Drawable drawable = ContextCompat.getDrawable(context, resId);
     
173.         if (drawable == null) {
     
174.             return null;
     
175.         }
     
176.         Canvas canvas = new Canvas();
     
177.         Bitmap bitmap = Bitmap.createBitmap(drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight(), Bitmap.Config.ARGB_8888);
     
178.         canvas.setBitmap(bitmap);
     
179.         drawable.setBounds(0, 0, drawable.getIntrinsicWidth(), drawable.getIntrinsicHeight());
     
180.         drawable.draw(canvas);
     
181.         return bitmap;
     
182.     }
     
183. 
     
184.     public static int calculateInSampleSize4(BitmapFactory.Options options, int reqWidth, int reqHeight) {
     
185.         int sampleSize = 1;
     
186.         int picWidth = options.outWidth;
     
187.         int picHeight = options.outHeight;
     
188.         if (picWidth > reqWidth || picHeight > reqHeight) {
     
189.             final int widthRatio = picWidth / reqWidth;
     
190.             final int heightRatio = picHeight / reqHeight;
     
191.             sampleSize = Math.max(heightRatio, widthRatio);
     
192.         }
     
193.         return sampleSize;
     
194.     }
     
195. 
     
196. 
     
197.     /**
     
198.      * 保存图片
     
199.      *
     
200.      * @param src     Bitmap对象
     
201.      * @param file    要保存的file路径
     
202.      * @param format  图片格式
     
203.      * @param recycle 是否回收bitmap
     
204.      * @return 是否保存成功
     
205.      */
     
206.     public static boolean save(final Bitmap src, final File file, final Bitmap.CompressFormat format, final int quality, final boolean recycle) {
     
207.         if (isEmptyBitmap(src)) {
     
208.             return false;
     
209.         }
     
210.         if (!createFileByDeleteOldFile(file)) {
     
211.             if (recycle && !src.isRecycled()) {
     
212.                 src.recycle();
     
213.             }
     
214.             return false;
     
215.         }
     
216.         OutputStream os;
     
217.         FileOutputStream fileOutputStream = null;
     
218.         boolean ret = false;
     
219.         try {
     
220.             fileOutputStream = new FileOutputStream(file);
     
221.         } catch (Exception e) {
     
222.             e.printStackTrace();
     
223.         } finally {
     
224.             if (fileOutputStream != null) {
     
225.                 os = new BufferedOutputStream(fileOutputStream);
     
226.                 ret = src.compress(format, quality, os);
     
227.                 try {
     
228.                     os.flush();
     
229.                     os.close();
     
230.                 } catch (Exception e) {
     
231.                     e.printStackTrace();
     
232.                 }
     
233.                 try {
     
234.                     fileOutputStream.close();
     
235.                 } catch (Exception e) {
     
236.                     e.printStackTrace();
     
237.                 }
     
238.                 if (recycle && !src.isRecycled()) {
     
239.                     src.recycle();
     
240.                 }
     
241.             }
     
242.         }
     
243.         return ret;
     
244.     }
     
245. 
     
246.     public static boolean save(final Bitmap src, final File file, final Bitmap.CompressFormat format) {
     
247.         return save(src, file, format, 100, false);
     
248.     }
     
249. 
     
250.     public static boolean save(final Bitmap src, final File file, final int quality, final Bitmap.CompressFormat format) {
     
251.         return save(src, file, format, quality, true);
     
252.     }
     
253. 
     
254.     public static boolean save(final Bitmap src, final String filePath, final Bitmap.CompressFormat format, final boolean recycle) {
     
255.         return save(src, getFileByPath(filePath), format, 100, recycle);
     
256.     }
     
257. 
     
258.     public static boolean save(final Bitmap src, final String filePath, final Bitmap.CompressFormat format) {
     
259.         return save(src, getFileByPath(filePath), format, 100, false);
     
260.     }
     
261. 
     
262.     /**
     
263.      * 对文件进行base64编码，获取编码后的字符串信息
     
264.      *
     
265.      * @param path 文件路径
     
266.      * @return base64编码后的文件内容
     
267.      */
     
268.     public static String image2Base64(String path) {
     
269.         if (TextUtils.isEmpty(path)) {
     
270.             return null;
     
271.         }
     
272.         InputStream is = null;
     
273.         byte[] data;
     
274.         String result = null;
     
275.         try {
     
276.             is = new FileInputStream(path);
     
277.             data = new byte[is.available()];
     
278.             int ret = is.read(data);
     
279.             result = Base64.encodeToString(data, Base64.DEFAULT);
     
280.             data = null;
     
281.         } catch (IOException e) {
     
282.             e.printStackTrace();
     
283.         } finally {
     
284.             if (null != is) {
     
285.                 try {
     
286.                     is.close();
     
287.                 } catch (IOException e) {
     
288.                     e.printStackTrace();
     
289.                 }
     
290.             }
     
291. 
     
292.         }
     
293.         return result;
     
294.     }
     
295. 
     
296.     /**
     
297.      * 对Bitmap进行压缩，以30的质量压缩为jpeg格式数据，再进行base64编码，获取编码后的字符串信息
     
298.      *
     
299.      * @param bitmap Bitmap对象
     
300.      * @return base64编码后的文件内容
     
301.      */
     
302.     public static String bitmapToBase64(Bitmap bitmap) {
     
303.         // 要返回的字符串
     
304.         String reslut = null;
     
305.         ByteArrayOutputStream baos = null;
     
306.         try {
     
307.             if (bitmap != null) {
     
308.                 baos = new ByteArrayOutputStream();
     
309.                 //压缩只对保存有效果bitmap还是原来的大小
     
310.                 bitmap.compress(Bitmap.CompressFormat.JPEG, 30, baos);
     
311.                 baos.flush();
     
312.                 baos.close();
     
313.                 // 转换为字节数组
     
314.                 byte[] byteArray = baos.toByteArray();
     
315.                 // 转换为字符串
     
316.                 reslut = Base64.encodeToString(byteArray, Base64.DEFAULT);
     
317.             } else {
     
318.                 return null;
     
319.             }
     
320.         } catch (IOException e) {
     
321.             e.printStackTrace();
     
322.         } finally {
     
323.             try {
     
324.                 if (baos != null) {
     
325.                     baos.close();
     
326.                 }
     
327.             } catch (IOException e) {
     
328.                 e.printStackTrace();
     
329.             }
     
330.         }
     
331.         return reslut;
     
332.     }
     
333. 
     
334. 
     
335.     /**
     
336.      * 将base64编码的图像数据解码为Bitmap对象
     
337.      *
     
338.      * @param base64String base64编码的图像数据
     
339.      * @return Bitmap对象
     
340.      */
     
341.     public static Bitmap base64ToBitmap(String base64String) {
     
342.         Bitmap bitmap = null;
     
343.         byte[] decode = null;
     
344.         try {
     
345.             decode = Base64.decode(base64String, Base64.DEFAULT);
     
346.         } catch (Exception e) {
     
347.         }
     
348.         if (decode != null && decode.length != 0) {
     
349.             try {
     
350.                 bitmap = BitmapFactory.decodeByteArray(decode, 0, decode.length);
     
351.             } catch (Exception e) {
     
352.             }
     
353.         }
     
354. 
     
355.         return bitmap;
     
356.     }
     
357. 
     
358. 
     
359.     /**
     
360.      * 将nv21数据转Bitmap
     
361.      *
     
362.      * @param nv21   NV21数据
     
363.      * @param width  NV21图像宽度
     
364.      * @param height NV21图像高度
     
365.      * @return 转换后的bitmap对象
     
366.      */
     
367.     public static Bitmap nv21ToBitmap(byte[] nv21, int width, int height) {
     
368.         Bitmap bitmap = null;
     
369.         try {
     
370.             YuvImage image = new YuvImage(nv21, ImageFormat.NV21, width, height, null);
     
371.             ByteArrayOutputStream stream = new ByteArrayOutputStream();
     
372.             image.compressToJpeg(new Rect(0, 0, width, height), 100, stream);
     
373.             bitmap = BitmapFactory.decodeByteArray(stream.toByteArray(), 0, stream.size());
     
374.             stream.close();
     
375.         } catch (IOException e) {
     
376.             e.printStackTrace();
     
377.         }
     
378.         return bitmap;
     
379.     }
     
380. 
     
381.     /**
     
382.      * 根据旋转角度、是否镜像处理Bitmap
     
383.      *
     
384.      * @param b            bitmap对象
     
385.      * @param rotateDegree 旋转角度
     
386.      * @param mirror       是否镜像
     
387.      * @return 处理后的Bitmap对象
     
388.      */
     
389.     public static Bitmap getRotateBitmap(Bitmap b, float rotateDegree, boolean mirror) {
     
390.         Matrix matrix = new Matrix();
     
391.         if (mirror) {
     
392.             if (rotateDegree == 90 || rotateDegree == 270) {
     
393.                 matrix.postScale(1, -1);
     
394.             } else {
     
395.                 matrix.postScale(-1, 1);
     
396.             }
     
397.         }
     
398.         matrix.postRotate(rotateDegree);
     
399.         int width = b.getWidth();
     
400.         int height = b.getHeight();
     
401.         if (width % 4 != 0) {
     
402.             width = width >> 2 << 2;
     
403.         }
     
404.         if (height % 4 != 0) {
     
405.             height = height >> 2 << 2;
     
406.         }
     
407.         return Bitmap.createBitmap(b, 0, 0, width, height, matrix, true);
     
408.     }
     
409. 
     
410.     /**
     
411.      * 旋转Bitmap
     
412.      *
     
413.      * @param src     原bitmap
     
414.      * @param degrees 旋转角度
     
415.      * @param px      旋转中心点的x坐标
     
416.      * @param py      旋转中心点的y坐标
     
417.      * @return Bitmap对象
     
418.      */
     
419.     public static Bitmap rotate(final Bitmap src, final int degrees, final float px, final float py) {
     
420.         return rotate(src, degrees, px, py, false);
     
421.     }
     
422. 
     
423.     /**
     
424.      * 旋转Bitmap
     
425.      *
     
426.      * @param src     原bitmap
     
427.      * @param degrees 旋转角度
     
428.      * @param px      旋转中心点的x坐标
     
429.      * @param py      旋转中心点的y坐标
     
430.      * @param recycle 是否回收bitmap
     
431.      * @return 旋转后的bitmap
     
432.      */
     
433.     public static Bitmap rotate(final Bitmap src, final int degrees, final float px, final float py, final boolean recycle) {
     
434.         if (isEmptyBitmap(src)) {
     
435.             return null;
     
436.         }
     
437.         if (degrees == 0) {
     
438.             return src;
     
439.         }
     
440.         Matrix matrix = new Matrix();
     
441.         matrix.setRotate(degrees, px, py);
     
442.         Bitmap ret = Bitmap.createBitmap(src, 0, 0, src.getWidth(), src.getHeight(), matrix, false);
     
443.         if (recycle && !src.isRecycled() && ret != src) {
     
444.             src.recycle();
     
445.         }
     
446.         return ret;
     
447.     }
     
448. 
     
449.     /**
     
450.      * 将图片文件转换为Bitmap对象
     
451.      * TODO: 未理解size参数的概念，可自行理解ArcFaceGo再修改该函数
     
452.      *
     
453.      * @param srcPath 图片文件
     
454.      * @param size
     
455.      * @return Bitmap对象
     
456.      */
     
457.     public static Bitmap getImagePng(String srcPath, int size) {
     
458.         return BitmapFactory.decodeFile(srcPath);
     
459.     }
     
460. 
     
461.     /**
     
462.      * 根据最大宽高等比缩放Bitmap
     
463.      *
     
464.      * @param bitmap    原Bitmap
     
465.      * @param maxWidth  最大宽度
     
466.      * @param maxHeight 最大高度
     
467.      * @return 等比缩放后的Bitmap对象
     
468.      */
     
469.     public static Bitmap resizeImage(Bitmap bitmap, int maxWidth, int maxHeight) {
     
470.         int bitmapWidth = bitmap.getWidth();
     
471.         int bitmapHeight = bitmap.getHeight();
     
472.         float scale = Math.min((float) maxWidth / bitmapWidth, (float) maxHeight / bitmapHeight);
     
473.         Matrix matrix = new Matrix();
     
474.         matrix.postScale(scale, scale);
     
475.         return Bitmap.createBitmap(bitmap, 0, 0, bitmapWidth, bitmapHeight, matrix, false);
     
476.     }
     
477. 
     
478.     /**
     
479.      * 确保Bitmap宽度是4的倍数，并且高度是2的倍数
     
480.      *
     
481.      * @param bm Bitmap对象
     
482.      * @return 宽度是4的倍数，并且高度是2的倍数的Bitmap
     
483.      */
     
484.     public static Bitmap setBitmap4Align(Bitmap bm) {
     
485.         Bitmap newBitmap;
     
486.         int width = bm.getWidth();
     
487.         int height = bm.getHeight();
     
488.         int newWidth = width;
     
489.         int newHeight = height;
     
490.         if (newWidth % FACE_DETECT_IMAGE_WIDTH_LIMIT != 0) {
     
491.             newWidth = newWidth >> 2 << 2;
     
492.         }
     
493.         if (newHeight % FACE_DETECT_IMAGE_HEIGHT_LIMIT != 0) {
     
494.             newHeight = newHeight & ~1;
     
495.         }
     
496.         // 计算缩放比例.
     
497.         float scaleWidth = ((float) newWidth) / width;
     
498.         float scaleHeight = ((float) newHeight) / height;
     
499.         // 取得想要缩放的matrix参数.
     
500.         Matrix matrix = new Matrix();
     
501.         matrix.postScale(scaleWidth, scaleHeight);
     
502.         // 得到新的图片.
     
503.         newBitmap = Bitmap.createBitmap(bm, 0, 0, width, height, matrix, true);
     
504.         return newBitmap;
     
505.     }
     
506. 
     
507.     /**
     
508.      * 缩放Bitmap对象
     
509.      *
     
510.      * @param bitmap    Bitmap对象
     
511.      * @param newWidth  新的宽度
     
512.      * @param newHeight 新的高度
     
513.      * @return 缩放后的Bitmap对象
     
514.      */
     
515.     public static Bitmap zoomImg(Bitmap bitmap, int newWidth, int newHeight) {
     
516.         int width = bitmap.getWidth();
     
517.         int height = bitmap.getHeight();
     
518.         float scaleWidth = ((float) newWidth) / width;
     
519.         float scaleHeight = ((float) newHeight) / height;
     
520.         Matrix matrix = new Matrix();
     
521.         matrix.postScale(scaleWidth, scaleHeight);
     
522.         return Bitmap.createBitmap(bitmap, 0, 0, width, height, matrix, true);
     
523.     }
     
524. 
     
525.     /**
     
526.      * 获取图片宽高
     
527.      *
     
528.      * @param imgPath 图片文件路径
     
529.      * @return 图片宽高
     
530.      */
     
531.     public static Pair<Integer, Integer> getImageOption(String imgPath) {
     
532.         BitmapFactory.Options options = new BitmapFactory.Options();
     
533.         options.inJustDecodeBounds = true;
     
534.         BitmapFactory.decodeFile(imgPath, options);
     
535.         return new Pair<>(options.outWidth, options.outHeight);
     
536.     }
     
537. 
     
538.     /**
     
539.      * 判断字符串是否为空格类字符串
     
540.      *
     
541.      * @param str 待判断的字符串
     
542.      * @return 是否为空格类字符串
     
543.      */
     
544.     public static boolean isSpace(final String str) {
     
545.         if (str == null) {
     
546.             return true;
     
547.         }
     
548.         for (int i = 0, len = str.length(); i < len; ++i) {
     
549.             if (!Character.isWhitespace(str.charAt(i))) {
     
550.                 return false;
     
551.             }
     
552.         }
     
553.         return true;
     
554.     }
     
555. 
     
556.     /**
     
557.      * 创建文件
     
558.      *
     
559.      * @param file 文件
     
560.      * @return 是否创建成果
     
561.      */
     
562.     public static boolean createFileByDeleteOldFile(final File file) {
     
563.         if (file == null) {
     
564.             return false;
     
565.         }
     
566.         if (file.exists() && !file.delete()) {
     
567.             return false;
     
568.         }
     
569.         if (!createDirOrDirExist(file.getParentFile())) {
     
570.             return false;
     
571.         }
     
572.         try {
     
573.             return file.createNewFile();
     
574.         } catch (IOException e) {
     
575.             return false;
     
576.         }
     
577.     }
     
578. 
     
579.     /**
     
580.      * 查看文件夹是否存在，如果不存在，则创建文件夹
     
581.      *
     
582.      * @param file 文件夹对象
     
583.      * @return 最终是否存在
     
584.      */
     
585.     public static boolean createDirOrDirExist(final File file) {
     
586.         return file != null && (file.exists() ? file.isDirectory() : file.mkdirs());
     
587.     }
     
588. 
     
589.     /**
     
590.      * 将文件路径转换为文件对象
     
591.      *
     
592.      * @param path 文件路径
     
593.      * @return 文件对象
     
594.      */
     
595.     public static File getFileByPath(final String path) {
     
596.         return isSpace(path) ? null : new File(path);
     
597.     }
     
598. 
     
599.     /**
     
600.      * 将输入流转换为Bitmap对象
     
601.      *
     
602.      * @param inputStream 输入流
     
603.      * @param maxWidth    最大宽度
     
604.      * @param maxHeight   最大高度
     
605.      * @param chunkSize   临时buffer大小
     
606.      * @return Bitmap对象
     
607.      * @throws IOException 读取inputStream时可能出现的异常
     
608.      */
     
609.     public static Bitmap getBitmap(final InputStream inputStream, int maxWidth, int maxHeight, int chunkSize)
     
610.             throws IOException {
     
611.         if (inputStream == null) {
     
612.             return null;
     
613.         }
     
614.         BitmapFactory.Options options = new BitmapFactory.Options();
     
615.         options.inJustDecodeBounds = true;
     
616. 
     
617.         byte[] data = inputStream2ByteArr(inputStream, chunkSize);
     
618. 
     
619.         BitmapFactory.decodeByteArray(data, 0, data.length, options);
     
620. 
     
621.         options.inSampleSize = ImageUtils.calculateInSampleSize4(options, maxWidth, maxHeight);
     
622.         options.inJustDecodeBounds = false;
     
623. 
     
624.         return BitmapFactory.decodeByteArray(data, 0, data.length, options);
     
625.     }
     
626. 
     
627.     /**
     
628.      * 将输入流转换为字节数组
     
629.      *
     
630.      * @param inputStream 输入流
     
631.      * @param chunkSize   临时buffer的大小
     
632.      * @return 字节数组
     
633.      * @throws IOException 读取输入流时可能会产生的异常
     
634.      */
     
635.     private static byte[] inputStream2ByteArr(InputStream inputStream, int chunkSize) throws IOException {
     
636.         ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
     
637.         byte[] buff = new byte[chunkSize];
     
638.         int len;
     
639.         while ((len = inputStream.read(buff)) != -1) {
     
640.             outputStream.write(buff, 0, len);
     
641.         }
     
642.         outputStream.flush();
     
643.         outputStream.close();
     
644.         return outputStream.toByteArray();
     
645.     }
     
646. 
     
647.     /**
     
648.      * 按人脸检测结果截取bitmap
     
649.      *
     
650.      * @param rect   人脸位置
     
651.      * @param orient 人脸角度，详见ArcFace文档
     
652.      * @param bitmap 原bitmap
     
653.      * @return 裁剪后的bitmap
     
654.      */
     
655.     public static Bitmap getFaceRegisterCropBitmap(Rect rect, int orient, Bitmap bitmap) {
     
656.         if (rect == null || bitmap == null) {
     
657.             return null;
     
658.         }
     
659.         int length = Math.max(rect.width(), rect.height()) / 2;
     
660.         int wPadding = Math.min(Math.min(rect.left, bitmap.getWidth() - rect.right), length);
     
661.         int width = rect.width() + 2 * wPadding;
     
662.         int x = rect.left - wPadding;
     
663.         int tPadding = Math.min(rect.top, length);
     
664.         int y = rect.top - tPadding;
     
665.         int bPadding = Math.min(bitmap.getHeight() - rect.bottom, length);
     
666.         int height = rect.height() + tPadding + bPadding;
     
667.         if ((width & 0b11) != 0) {
     
668.             width &= ~0b11;
     
669.         }
     
670.         if ((height & 1) != 0) {
     
671.             height &= ~1;
     
672.         }
     
673.         Matrix matrix = new Matrix();
     
674.         if (orient == 2) {
     
675.             matrix.setRotate(90);
     
676.         } else if (orient == 4) {
     
677.             matrix.setRotate(180);
     
678.         } else if (orient == 3) {
     
679.             matrix.setRotate(270);
     
680.         }
     
681. 
     
682.         return Bitmap.createBitmap(bitmap, x, y, width, height, matrix, true);
     
683.     }
     
684. 
     
685.     /**
     
686.      * 将图像信息转换为Bitmap对象
     
687.      *
     
688.      * @param imgArray 图像数据，可以是JPG\PNG等格式
     
689.      * @return Bitmap对象
     
690.      */
     
691.     public static Bitmap getBitmap(byte[] imgArray) {
     
692.         return BitmapFactory.decodeByteArray(imgArray, 0, imgArray.length);
     
693.     }
     
694. 
     
695.     /**
     
696.      * 将输入流转换为Bitmap对象
     
697.      *
     
698.      * @param inputStream 输入流
     
699.      * @return Bitmap对象
     
700.      */
     
701.     public static Bitmap getBitmap(InputStream inputStream) {
     
702.         return BitmapFactory.decodeStream(inputStream);
     
703.     }
     
704. }</font>

复制代码

2.2.4 编译apk
将上述两个Java类存放到下方目录，

1. <font size="2">ArcFaceGo\libutil\src\main\java\com\arcsoft\arcfacesingle\libutil</font>

复制代码

下图红框即为刚刚存放好的Java类，

点击

1. <font size="2">Build -> Build bundle(s)/APK(s) -> Build APK(s)</font>

复制代码

即可编译APK

三、 安装及使用
3.1 安装
直接点击Android Studio的安装或使用adb install或者其他方式将apk安装到设备中

3.2 使用
将`APP_ID`等信息存放到

1. <font size="2">sdcard/com_arcsoft_arcfacesingle_charge/activeConfig/activeConfig.txt</font>

复制代码

格式如下（以下为示例数据，非真实数据）：

1. <font size="2">APP_ID:Abvyu5a4ds4vaBhyLSNcp49HW6tuPx3sqWog8i9S41Q7
   
2. SDK_KEY:EvvwadsFj7XjL1siCQgSD2qGcmeFsE2bCpgtMJpS4MW3
   
3. ACTIVE_KEY:8551-2136-J3HC-E5FH</font>

复制代码

首次打开ArcFaceGo App，会自动进入激活、配置等界面，配置完成后即可使用。
APK的具体使用说明详见压缩包中的`doc/操作指南_Android设备端.pdf`

感谢分享