Java 实现人脸识别，手把手教你使用百度AI 实现 人脸识别、人脸对比

r囧r小猫 2021-10-18 15:22 1627阅读 0赞

Java后端 + 百度SDK实现人脸识别

  1. 人工智能越来越贴近我们的生活，相信大家也经常接触到人脸识别，手机付款、app注册验证、门禁等等。
  3. 如果要用Java后台使用这些功能，那么需要怎么做呢？请看完下面这篇文章，就能轻松、简单入门了！

手把手教你实现人脸识别、人脸对比

  1. 注册百度账号 https://ai.baidu.com/
    打开网站，注册百度账号并登录。然后按图1的提示进行操作。
    在图1中，选择 “人脸检测” 跳转到 图2。
    在图2中 点击 “立即使用” 然后跳转到 图3。
    在图3中 点击“创建应用” 然后跳转到 图4.
    在图4中 完成应用申请 然后就有了图5（我们最终需要的就是这个 刚创建应用的参数AppID等）

图1：在这里插入图片描述
图2:
在这里插入图片描述
图3：
在这里插入图片描述
图4：
在这里插入图片描述
图5：
在这里插入图片描述

  1. Java SDK 文档地址：https://ai.baidu.com/docs#/Face-Java-SDK/top
    这里有详细的API文档。
    在这里插入图片描述

  2. pom.xml 配置：


    com.baidu.aip
    java-sdk
    4.10.0

  3. 人脸识别java类
    下面的 APPID/AK/SK 改成你的，找2张人像图片在线生成Base64然后复制在下面就可以测试了。

    import com.baidu.aip.face.AipFace;
    import com.baidu.aip.face.MatchRequest;
    import org.apache.commons.codec.binary.Base64;
    import org.json.JSONObject;

    import java.util.ArrayList;
    import java.util.HashMap;

    public class FaceTest { 

    1.     //设置APPID/AK/SK
    2.     private static String APP_ID = "改成你的图5中的参数";
    3.     private static String API_KEY = "改成你的图5中的参数";
    4.     private static String SECRET_KEY = "改成你的图5中的参数";
    6.     public static void main(String[] args) { 
    7.         // 初始化一个AipFace
    8.         AipFace client = new AipFace(APP_ID, API_KEY, SECRET_KEY);
    10.         // 可选：设置网络连接参数
    11.         client.setConnectionTimeoutInMillis(2000);
    12.         client.setSocketTimeoutInMillis(60000);
    13.         // 可选：设置代理服务器地址, http和socket二选一，或者均不设置

    // client.setHttpProxy(“proxy_host”, proxy_port); // 设置http代理
    // client.setSocketProxy(“proxy_host”, proxy_port); // 设置socket代理

    1.         /** START 获取读取 图片Base64编码 **/
    2.         // 方法一：
    3.         String image1 = "找一张有人脸的图片，在线图片生成Base64编码 然后复制到这里";
    4.         String image2 = "找一张有人脸的图片，在线图片生成Base64编码 然后复制到这里";
    6.         // 方法二：
    7.         /* // 读本地图片 byte[] bytes = FileUtils.fileToBytes("D:\\Documents\\Pictures\\fc.jpg"); byte[] bytes2 = FileUtils.fileToBytes("D:\\Documents\\Pictures\\fj.jpg"); // 将字节转base64 String image1 = Base64.encodeBase64String(bytes); String image2 = Base64.encodeBase64String(bytes2); */
    8.         /** END 获取读取 图片Base64编码 **/
    10.         // 人脸对比
    11.         // image1/image2也可以为url或facetoken, 相应的imageType参数需要与之对应。
    12.         MatchRequest req1 = new MatchRequest(image1, "BASE64");
    13.         MatchRequest req2 = new MatchRequest(image2, "BASE64");
    14.         ArrayList<MatchRequest> requests = new ArrayList<MatchRequest>();
    15.         requests.add(req1);
    16.         requests.add(req2);
    18.         JSONObject res = client.match(requests);
    19.         System.out.println(res.toString(2));
    21.         // 人脸检测
    22.         // 传入可选参数调用接口
    23.         HashMap<String, String> options = new HashMap<String, String>();
    24.         options.put("face_field", "age");
    25.         options.put("max_face_num", "2");
    26.         options.put("face_type", "LIVE");
    27.         options.put("liveness_control", "LOW");
    28.         JSONObject res2 = client.detect(image1, "BASE64", options);
    29.         System.out.println(res2.toString(2));
    30.     }

    }

上面方法二中的相关类：

Base64.encodeBase64String(bytes) 来自 import org.apache.commons.codec.binary.Base64;
FileUtils.fileToBytes(“D:\Documents\Pictures\fc.jpg”);
FileUtils类 如下：

  1. package com.weixin.demo.utils;
  3. import org.slf4j.Logger;
  4. import org.slf4j.LoggerFactory;
  6. import java.io.*;
  8. public class FileUtils { 
  10.     protected static Logger logger = LoggerFactory.getLogger(FileUtils.class);
  12.     public static byte[] fileToBytes(String filePath) { 
  13.         byte[] buffer = null;
  14.         File file = new File(filePath);
  15.         FileInputStream fis = null;
  16.         ByteArrayOutputStream bos = null;
  17.         try { 
  18.             fis = new FileInputStream(file);
  19.             bos = new ByteArrayOutputStream();
  20.             byte[] b = new byte[1024];
  21.             int n;
  22.             while ((n = fis.read(b)) != -1) { 
  23.                 bos.write(b, 0, n);
  24.             }
  25.             buffer = bos.toByteArray();
  26.         } catch (FileNotFoundException ex) { 
  27.             ex.printStackTrace();
  28.             logger.error("", ex);
  29.         } catch (IOException ex) { 
  30.             ex.printStackTrace();
  31.             logger.error("", ex);
  32.         } finally { 
  33.             try { 
  34.                 if (null != bos) { 
  35.                     bos.close();
  36.                 }
  37.             } catch (IOException ex) { 
  38.                 ex.printStackTrace();
  39.                 logger.error("", ex);
  40.             } finally { 
  41.                 try { 
  42.                     if (null != fis) { 
  43.                         fis.close();
  44.                     }
  45.                 } catch (IOException ex) { 
  46.                     ex.printStackTrace();
  47.                     logger.error("", ex);
  48.                 }
  49.             }
  50.         }
  51.         return buffer;
  52.     }
  54.     public static void bytesToFile(byte[] buffer, final String filePath) { 
  55.         File file = new File(filePath);
  56.         OutputStream output = null;
  57.         BufferedOutputStream bufferedOutput = null;
  58.         try { 
  59.             output = new FileOutputStream(file);
  60.             bufferedOutput = new BufferedOutputStream(output);
  61.             bufferedOutput.write(buffer);
  62.         } catch (FileNotFoundException ex) { 
  63.             ex.printStackTrace();
  64.             logger.error("", ex);
  65.         } catch (IOException ex) { 
  66.             ex.printStackTrace();
  67.             logger.error("", ex);
  68.         } finally { 
  69.             if (null != bufferedOutput) { 
  70.                 try { 
  71.                     bufferedOutput.close();
  72.                 } catch (IOException ex) { 
  73.                     ex.printStackTrace();
  74.                     logger.error("", ex);
  75.                 }
  76.             }
  77.             if (null != output) { 
  78.                 try { 
  79.                     output.close();
  80.                 } catch (IOException ex) { 
  81.                     ex.printStackTrace();
  82.                     logger.error("", ex);
  83.                 }
  84.             }
  85.         }
  86.     }
  88.     public static void bytesToFile(byte[] buffer, File file) { 
  89.         OutputStream output = null;
  90.         BufferedOutputStream bufferedOutput = null;
  91.         try { 
  92.             output = new FileOutputStream(file);
  93.             bufferedOutput = new BufferedOutputStream(output);
  94.             bufferedOutput.write(buffer);
  95.         } catch (FileNotFoundException ex) { 
  96.             ex.printStackTrace();
  97.             logger.error("", ex);
  98.         } catch (IOException ex) { 
  99.             ex.printStackTrace();
  100.             logger.error("", ex);
  101.         } finally { 
  102.             if (null != bufferedOutput) { 
  103.                 try { 
  104.                     bufferedOutput.close();
  105.                 } catch (IOException ex) { 
  106.                     ex.printStackTrace();
  107.                     logger.error("", ex);
  108.                 }
  109.             }
  110.             if (null != output) { 
  111.                 try { 
  112.                     output.close();
  113.                 } catch (IOException ex) { 
  114.                     ex.printStackTrace();
  115.                     logger.error("", ex);
  116.                 }
  117.             }
  118.         }
  119.     }
  121.     /** * byte数组转换成16进制字符串 * * @param src * @return */
  122.     public static String bytesToHexString(byte[] src) { 
  123.         StringBuilder stringBuilder = new StringBuilder();
  124.         if (src == null || src.length <= 0) { 
  125.             return null;
  126.         }
  127.         for (int i = 0; i < src.length; i++) { 
  128.             int v = src[i] & 0xFF;
  129.             String hv = Integer.toHexString(v);
  130.             if (hv.length() < 2) { 
  131.                 stringBuilder.append(0);
  132.             }
  133.             stringBuilder.append(hv);
  134.         }
  135.         return stringBuilder.toString();
  136.     }
  138.     /** * 根据文件流读取图片文件真实类型 */
  139.     public static String getTypeByBytes(byte[] fileBytes) { 
  140.         byte[] b = new byte[4];
  141.         System.arraycopy(fileBytes, 0, b, 0, b.length);
  142.         String type = bytesToHexString(b).toUpperCase();
  143.         if (type.contains("FFD8FF")) { 
  144.             return "jpg";
  145.         } else if (type.contains("89504E47")) { 
  146.             return "png";
  147.         } else if (type.contains("47494638")) { 
  148.             return "gif";
  149.         } else if (type.contains("49492A00")) { 
  150.             return "tif";
  151.         } else if (type.contains("424D")) { 
  152.             return "bmp";
  153.         }
  154.         return type;
  155.     }
  157.     public static String getTypeByFile(File file) { 
  158.         String fileName = file.getName();
  159.         return fileName.substring(fileName.lastIndexOf(".") + 1);
  160.     }
  162.     public static String getTypeByFilePath(String filePath) { 
  163.         return filePath.substring(filePath.lastIndexOf(".") + 1);
  164.     }
  166.     public static byte[] toByteArray(InputStream input) throws IOException { 
  167.         ByteArrayOutputStream output = new ByteArrayOutputStream();
  168.         byte[] buffer = new byte[4096];
  169.         int n = 0;
  170.         while (-1 != (n = input.read(buffer))) { 
  171.             output.write(buffer, 0, n);
  172.         }
  173.         return output.toByteArray();
  174.     }
  176. }

“人脸对比” 测试结果：
主要看 score 参数，越高越匹配。满分100分。

  1. 0 [main] INFO com.baidu.aip.client.BaseClient  - get access_token success. current state: STATE_AIP_AUTH_OK
  2. 2 [main] DEBUG com.baidu.aip.client.BaseClient  - current state after check priviledge: STATE_TRUE_AIP_USER
  3. {
  4.   "result": {
  5.     "score": 90.39932251,
  6.     "face_list": [
  7.       {"face_token": "594b9857e1bc1a6f0bb6fa7183ca962d"},
  8.       {"face_token": "f552428debe38d54081dfbce5d6d6e1e"}
  9.     ]
  10.   },
  11.   "log_id": 1345050756015080031,
  12.   "error_msg": "SUCCESS",
  13.   "cached": 0,
  14.   "error_code": 0,
  15.   "timestamp": 1565601508
  16. }

“人脸检测” 测试结果：

  1. {
  2.   "result": {
  3.     "face_num": 1,
  4.     "face_list": [{
  5.       "liveness": {"livemapscore": 1},
  6.       "angle": {
  7.         "roll": -3.24,
  8.         "pitch": 13.22,
  9.         "yaw": 7.82
  10.       },
  11.       "face_token": "594b9857e1bc1a6f0bb6fa7183ca962d",
  12.       "location": {
  13.         "top": 570.86,
  14.         "left": 197.56,
  15.         "rotation": 1,
  16.         "width": 339,
  17.         "height": 325
  18.       },
  19.       "face_probability": 1,
  20.       "age": 23
  21.     }]
  22.   },
  23.   "log_id": 1368654456015085521,
  24.   "error_msg": "SUCCESS",
  25.   "cached": 0,
  26.   "error_code": 0,
  27.   "timestamp": 1565601508
  28. }

人脸检测 相关请求参数、返回参数解释。（详情请访问第2点的SDK地址：即 https://ai.baidu.com/docs#/Face-Java-SDK/top）
在这里插入图片描述
在这里插入图片描述
人脸对比 相关请求参数、返回参数解释。（详情请访问第2点的SDK地址：即 https://ai.baidu.com/docs#/Face-Java-SDK/top）
在这里插入图片描述

发表评论

表情：
评论列表 （有 0 条评论，1627人围观）

还没有评论，来说两句吧...

相关阅读