devbox
你好赵伟
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

java实现电子发票中的发票税号等信息识别的几种可用方案_java 纳税人识别号校验码 csdn

作者：你好赵伟 | 2024-03-23 22:18:35

赞

踩

java 纳税人识别号校验码 csdn

先说一下背景：

今天领导突然说需要做一个电子发票中发票税号的识别，于是乎就开始去调研看有哪些方案，最先想到的就是OCR文字识别，自己去画框训练模型去识别税号等相关信息

话不多说开整思路：

思路一：百度AI平台去直接调用

思路二：自己基于模型训练

思路三：基于本地化代码识别票据中信息

这几种思路接下来我都会详细展开说，且每种方式的优缺点博主也会说清楚，仅供大家参考

思路一：百度AI平台去直接调用

  1. 百度OCR识别介绍

官网地址：OCR文字识别_免费试用_图片转文字-百度AI开放平台

你还别说，百度这几个模块想当成熟，模型训练的很好

  1. 使用方式

使用百度账号登录，创建应用，比较重要的是API KEY 和 SECRET KEY

服务与支持-自助服务-自助工具

3.代码调用：（java）

  • 加入依赖

  1.  
  2. <!--百度OCR-->
  3. <dependency>
  4.     <groupId>com.baidu.aip</groupId>
  5.     <artifactId>java-sdk</artifactId>
  6.     <version>4.16.5</version>
  7. </dependency>
  8.  
  9. <dependency>
  10.     <groupId>com.baidubce</groupId>
  11.     <artifactId>api-explorer-sdk</artifactId>
  12.     <version>1.0.3.1</version>
  13. </dependency>
  14. <dependency>
  15.     <groupId>com.squareup.okhttp3</groupId>
  16.     <artifactId>okhttp</artifactId>
  17.     <version>3.10.0</version>
  18. </dependency>

  • 创建工具类

FileUtil,Base64Util,HttpUtil,GsonUtils 工具类从下面链接下载

  1.  
  2. https://ai.baidu.com/file/658A35ABAB2D404FBF903F64D47C1F72
  3. https://ai.baidu.com/file/C8D81F3301E24D2892968F09AE1AD6E2
  4. https://ai.baidu.com/file/544D677F5D4E4F17B4122FBD60DB82B3
  5. https://ai.baidu.com/file/470B3ACCA3FE43788B5A963BF0B625F3

  • 获取 Token 类

  1.  
  2. import org.json.JSONObject;
  3.  
  4. import java.io.BufferedReader;
  5. import java.io.InputStreamReader;
  6. import java.net.HttpURLConnection;
  7. import java.net.URL;
  8. import java.util.List;
  9. import java.util.Map;
  10.  
  11. /**
  12.  * 获取token类
  13.  */
  14. public class AuthService {
  15.  
  16.     /**
  17.      * 获取权限token
  18.      * @return 返回示例：
  19.      * {
  20.      * "access_token": "24.46ad247221975.2592000.1491995545.282335-1234567",
  21.      * "expires_in": 2592000
  22.      * }
  23.      */
  24.     public static String getAuth() {
  25.         // 官网获取的 API Key 更新为你注册的
  26.         String clientId = "74AHm9bwIfrVU16EDF9uxXbO";
  27.         // 官网获取的 Secret Key 更新为你注册的
  28.         String clientSecret = "c1fzjB8jy8GmLfe8rzMzvDZYheklTZNh";
  29.         return getAuth(clientId, clientSecret);
  30.     }
  31.  
  32.     public static void main(String[] args) {
  33.         System.out.println(getAuth());
  34.     }
  35.  
  36.     /**
  37.      * 获取API访问token
  38.      * 该token有一定的有效期，需要自行管理，当失效时需重新获取.
  39.      * @param ak - 百度云官网获取的 API Key
  40.      * @param sk - 百度云官网获取的 Secret Key
  41.      * @return assess_token 示例：
  42.      * "24.460da4889caad24cccdb1fea17221975.2592000.1491995545.282335-1234567"
  43.      */
  44.     public static String getAuth(String ak, String sk) {
  45.         // 获取token地址
  46.         String authHost = "https://aip.baidubce.com/oauth/2.0/token?";
  47.         String getAccessTokenUrl = authHost
  48.                 // 1. grant_type为固定参数
  49.                 + "grant_type=client_credentials"
  50.                 // 2. 官网获取的 API Key
  51.                 + "&client_id=" + ak
  52.                 // 3. 官网获取的 Secret Key
  53.                 + "&client_secret=" + sk;
  54.         try {
  55.             URL realUrl = new URL(getAccessTokenUrl);
  56.             // 打开和URL之间的连接
  57.             HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
  58.             connection.setRequestMethod("GET");
  59.             connection.connect();
  60.             // 获取所有响应头字段
  61.             Map<String, List<String>> map = connection.getHeaderFields();
  62.             // 遍历所有的响应头字段
  63.             /*for (String key : map.keySet()) {
  64.                 System.err.println(key + "--->" + map.get(key));
  65.             }*/
  66.             // 定义 BufferedReader输入流来读取URL的响应
  67.             BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
  68.             String result = "";
  69.             String line;
  70.             while ((line = in.readLine()) != null) {
  71.                 result += line;
  72.             }
  73.             /**
  74.              * 返回结果示例
  75.              */
  76.             //System.err.println("result:" + result);
  77.             JSONObject jsonObject = new JSONObject(result);
  78.             String access_token = jsonObject.getString("access_token");
  79.             return access_token;
  80.         } catch (Exception e) {
  81.             System.err.printf("获取token失败！");
  82.             e.printStackTrace(System.err);
  83.         }
  84.         return null;
  85.     }
  86.  
  87. }

  • 图片/PDF 发票识别测试类

  1.  
  2. import okhttp3.*;
  3.  
  4. import java.io.*;
  5.  
  6. import java.nio.file.Files;
  7. import java.nio.file.Paths;
  8. import java.util.Base64;
  9.  
  10. class Sample {
  11.  
  12.     static final OkHttpClient HTTP_CLIENT = new OkHttpClient().newBuilder().build();
  13.  
  14.     public static void main(String[] args) throws IOException {
  15.         MediaType mediaType = MediaType.parse("application/x-www-form-urlencoded");
  16.         // image 可以通过 getFileContentAsBase64("C:\fakepath\下载.png") 方法获取
  17.         String path = "C:\\Users\\Desktop\\1.png";
  18.         String image = getFileContentAsBase64(path);
  19.         image = image.replaceAll("\\+","%2B");
  20.         image = image.replaceAll("\\/","%2F");
  21.  
  22.         // 官网获取的 API Key 更新为你注册的
  23.         String clientId = "74AHm9bwIfrVO";
  24.         // 官网获取的 Secret Key 更新为你注册的
  25.         String clientSecret = "c1fzjB8jy8GZNh";
  26.         String access_token = AuthService.getAuth(clientId, clientSecret);
  27.         //String access_token = "24.acd9426de6760aa.2592000.1678264-30210143";
  28.         RequestBody body = RequestBody.create(mediaType, "image="+image);
  29.         Request request = new Request.Builder()
  30.                 .url("https://aip.baidubce.com/rest/2.0/ocr/v1/vat_invoice?access_token="+access_token)
  31.                 .method("POST", body)
  32.                 .addHeader("Content-Type", "application/x-www-form-urlencoded")
  33.                 .addHeader("Accept", "application/json")
  34.                 .build();
  35.         Response response = HTTP_CLIENT.newCall(request).execute();
  36.         System.out.println(response.body().string());
  37.  
  38.     }
  39.  
  40.     /**
  41.      * 获取文件base64编码
  42.      *
  43.      * @param path 文件路径
  44.      * @return base64编码信息，不带文件头
  45.      * @throws IOException IO异常
  46.      */
  47.     static String getFileContentAsBase64(String path) throws IOException {
  48.         byte[] b = Files.readAllBytes(Paths.get(path));
  49.         return Base64.getEncoder().encodeToString(b);
  50.     }
  51.  
  52.  
  53. }

输出结果

4.使用注意点

这种目前是每月免费调用1000次，但是这个需要把信息上传到百度云上，有信息安全方面考虑的同学需要思考一下，私有部署需要付费，大概是299买一个sdk

百度OCR识别发票 Java 代码实现 | 言曌博客

思路二：自己基于模型训练

这种提供思路，需要自己训练模型，基于百度OCR自训练平台训练模型，使用方式如下，这块做个简单介绍，仅供参考

1.使用步骤

百度智能云-登录

根据步骤操作几个，提供数据标注训练

2.使用注意点

这种方式好处是比较自定义化，这种本地部署比较麻烦，需要额外付费用，需多多斟酌

思路三：识别二维码

这个思路是跟财务同事再三确认后，目前只识别电子发票信息，且发票中都一定会有二维码信息，这就好办了，我们可以识别二维码中的信息，这不就问题解决了，且这种方式只要有二维码，准确率达到100%

重点说说第三种

1.代码实现：

干搂代码开始：

加入maven依赖包：


<code class="language-plaintext hljs"><dependency>
    <groupId>org.apache.pdfbox</groupId>
    <artifactId>pdfbox</artifactId>
    <version>2.0.20</version>
</dependency><dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>core</artifactId>
    <version>3.1.0</version>
</dependency><dependency>
    <groupId>com.google.zxing</groupId>
    <artifactId>javase</artifactId>
    <version>3.1.0</version>
</dependency></code>

上代码：

  1.  
  2. import ch.qos.logback.classic.Level;
  3. import ch.qos.logback.classic.LoggerContext;
  4. import com.google.zxing.BinaryBitmap;
  5. import com.google.zxing.EncodeHintType;
  6. import com.google.zxing.MultiFormatReader;
  7. import com.google.zxing.Result;
  8. import com.google.zxing.client.j2se.BufferedImageLuminanceSource;
  9. import com.google.zxing.common.HybridBinarizer;
  10. import com.huatek.base.utils.LoggerUtil;
  11. import org.apache.commons.lang3.StringUtils;
  12. import org.apache.pdfbox.cos.COSName;
  13. import org.apache.pdfbox.pdmodel.PDDocument;
  14. import org.apache.pdfbox.pdmodel.PDPage;
  15. import org.apache.pdfbox.pdmodel.PDResources;
  16. import org.apache.pdfbox.pdmodel.graphics.image.PDImageXObject;
  17. import org.slf4j.Logger;
  18. import org.slf4j.LoggerFactory;
  19.  
  20. import java.awt.image.BufferedImage;
  21. import java.io.File;
  22. import java.util.ArrayList;
  23. import java.util.HashMap;
  24. import java.util.List;
  25. import java.util.Map;
  26.  
  27. public class InvoiceTest {
  28.  
  29.     //这块是为了避免log4j打印一些没必要的信息
  30.     static {
  31.         LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
  32.         List<ch.qos.logback.classic.Logger> loggerList = loggerContext.getLoggerList();
  33.         loggerList.forEach(logger -> {
  34.             logger.setLevel(Level.INFO);
  35.         });
  36.     }
  37.  
  38.     private Logger logger = LoggerUtil.getLogger();
  39.  
  40.     public static void main(String[] args) {
  41.         InvoiceTest fapiao1 = new InvoiceTest();
  42.         //填写你自己的路径即可
  43.         fapiao1.getInvoiceInfo("C:\\Users\\Desktop\\temp\\1.pdf");
  44.     }
  45.  
  46.     /**
  47.      * 获取电子发票pdf文件中的发票信息
  48.      *
  49.      * @param filePath 电子发票路径
  50.      * @return 发票信息
  51.      */
  52.     public Object getInvoiceInfo(String filePath) {
  53.         try {
  54.             List<BufferedImage> imageList = extractImage(new File(filePath));
  55.             if (imageList.isEmpty()) {
  56.                 logger.info("pdf中未解析出图片，返回空");
  57.                 return null;
  58.             }
  59.  
  60.             MultiFormatReader formatReader = new MultiFormatReader();
  61.             //正常解析出来有3张图片，第一张是二维码，其他两张图片是发票上盖的章
  62.             BinaryBitmap binaryBitmap = new BinaryBitmap(new HybridBinarizer(new BufferedImageLuminanceSource(imageList.get(0))));
  63.             Map hints = new HashMap<>();
  64.             hints.put(EncodeHintType.CHARACTER_SET, "utf-8");
  65.             Result result = formatReader.decode(binaryBitmap);
  66.             if (result == null || StringUtils.isEmpty(result.getText())) {
  67.                 logger.info("pdf中的第一张图片没有解析了字符串信息，直接返回空");
  68.                 return null;
  69.             }
  70.  
  71.             logger.info("从电子发票中识别出的信息为：{}", result.getText());
  72.  
  73.             // 读取到的信息为 ： 01，发票类型，发票代码，发票号码，发票金额，开票日期，校验码，随机产生的摘要信息
  74.             String[] infos = result.getText().split(",");
  75.             if (infos.length != 8) {
  76.                 logger.info("pdf中的第一张图片解析出的字符串数组长度不为8，返回空。");
  77.                 return null;
  78.             }
  79.  
  80.             //这里自己去定义对象，属性自己看着定义，仅供参考
  81.             /*Invoice invoice = new Invoice();
  82.             invoice.setInvoiceType(infos[1]); //发票类型
  83.             invoice.setInvoiceCode(infos[2]); //发票代码
  84.             invoice.setInvoiceNo(infos[3]); // 发票号码
  85.             invoice.setAmount(new BigDecimal(infos[4])); // 发票金额
  86.             invoice.setInvoiceDate(DateUtils.parseDate(infos[5], "yyyyMMdd")); //开票日期
  87.             invoice.setCheckCode(infos[6]); // 校验码*/
  88.  
  89.             //return invoice;
  90.             return null;
  91.         } catch (Exception e) {
  92.             logger.info("解析pdf中的二维码出现异常", e);
  93.             return null;
  94.         }
  95.     }
  96.  
  97.  
  98.     /**
  99.      * 提取电子发票里面的图片
  100.      *
  101.      * @param pdfFile 电子发票文件对象
  102.      * @return pdf中解析出的图片列表
  103.      * @throws Exception
  104.      */
  105.     private List<BufferedImage> extractImage(File pdfFile) throws Exception {
  106.         List<BufferedImage> imageList = new ArrayList<BufferedImage>();
  107.  
  108.         PDDocument document = PDDocument.load(pdfFile);
  109.         PDPage page = document.getPage(0); //电子发票只有一页
  110.         PDResources resources = page.getResources();
  111.  
  112.         for (COSName name : resources.getXObjectNames()) {
  113.             if (resources.isImageXObject(name)) {
  114.                 PDImageXObject obj = (PDImageXObject) resources.getXObject(name);
  115.                 imageList.add(obj.getImage());
  116.             }
  117.         }
  118.         document.close();
  119.         return imageList;
  120.     }
  121. }

至此代码完成，有的同学可能会说那如果传的是图片怎么办，别慌那就继续实现就完事儿了

依赖还是那些依赖，根据你自己的需求封装工具类和上面代码相互配合判断调用

  1.  
  2. import com.google.zxing.*;
  3. import com.google.zxing.client.j2se.BufferedImageLuminanceSource;
  4. import com.google.zxing.common.HybridBinarizer;
  5.  
  6. import javax.imageio.ImageIO;
  7. import java.awt.image.BufferedImage;
  8. import java.io.File;
  9. import java.io.IOException;
  10. import java.util.HashMap;
  11. import java.util.Map;
  12. /**
  13.  * 作用：二维码识别（图片）
  14.  * 类名：QRCodeUtils
  15.  **/
  16. public class QRCodeUtils {
  17.     /**
  18.      * 解析二维码,此方法解析一个路径的二维码图片
  19.      * path:图片路径
  20.      */
  21.     public static String deEncodeByPath(String path) {
  22.         String content = null;
  23.         BufferedImage image;
  24.         try {
  25.             image = ImageIO.read(new File(path));
  26.             LuminanceSource source = new BufferedImageLuminanceSource(image);
  27.             Binarizer binarizer = new HybridBinarizer(source);
  28.             BinaryBitmap binaryBitmap = new BinaryBitmap(binarizer);
  29.             Map<DecodeHintType, Object> hints = new HashMap<DecodeHintType, Object>();
  30.             hints.put(DecodeHintType.CHARACTER_SET, "UTF-8");
  31.             Result result = new MultiFormatReader().decode(binaryBitmap, hints);//解码
  32.             System.out.println("图片中内容：  ");
  33.             System.out.println("content： " + result.getText());
  34.             content = result.getText();
  35.         } catch (IOException e) {
  36.             e.printStackTrace();
  37.         } catch (NotFoundException e) {
  38.             //这里判断如果识别不了带LOGO的图片，重新添加上一个属性
  39.             try {
  40.                 image = ImageIO.read(new File(path));
  41.                 LuminanceSource source = new BufferedImageLuminanceSource(image);
  42.                 Binarizer binarizer = new HybridBinarizer(source);
  43.                 BinaryBitmap binaryBitmap = new BinaryBitmap(binarizer);
  44.                 Map<DecodeHintType, Object> hints = new HashMap<DecodeHintType, Object>();
  45.                 //设置编码格式
  46.                 hints.put(DecodeHintType.CHARACTER_SET, "UTF-8");
  47.                 //设置优化精度
  48.                 hints.put(DecodeHintType.TRY_HARDER, Boolean.TRUE);
  49.                 //设置复杂模式开启（我使用这种方式就可以识别微信的二维码了）
  50.                 hints.put(DecodeHintType.PURE_BARCODE,Boolean.TYPE);
  51.                 Result result = new MultiFormatReader().decode(binaryBitmap, hints);//解码
  52.                 System.out.println("图片中内容：  ");
  53.                 System.out.println("content： " + result.getText());
  54.                 content = result.getText();
  55.             } catch (IOException e1) {
  56.                 e1.printStackTrace();
  57.             } catch (NotFoundException e2) {
  58.                 e2.printStackTrace();
  59.             }
  60.         }
  61.         return content;
  62.     }
  63.  
  64.     public static void main(String [] args){
  65.         System.out.println(deEncodeByPath("C:\\Users\\Desktop\\3-1.jpg"));//二维码图片路径
  66.     }
  67. }

如果上述不能识别的话，那么就需要对图片处理一次，然后再进行识别，这里是个调优图片的工具类。

  1.  
  2. package com.face.ele.common.utils;
  3.  
  4. import javax.imageio.ImageIO;
  5. import java.awt.*;
  6. import java.awt.image.BufferedImage;
  7. import java.io.File;
  8. import java.io.IOException;
  9.  
  10. /*
  11.  * @description: 图片清晰处理
  12.  */
  13. public class ImageOptimizationUtil {
  14.  
  15.     // 阈值0-255
  16.     public static int YZ = 150;
  17.  
  18.     /**
  19.      * 图像二值化处理
  20.      *
  21.      * @param filePath 要处理的图片路径
  22.      * @param fileOutputPath 处理后的图片输出路径
  23.      */
  24.     public static void binarization(String filePath, String fileOutputPath) throws IOException {
  25.         File file = new File(filePath);
  26.         BufferedImage bi = ImageIO.read(file);
  27.         // 获取当前图片的高,宽,ARGB
  28.         int h = bi.getHeight();
  29.         int w = bi.getWidth();
  30.         int arr[][] = new int[w][h];
  31.  
  32.         // 获取图片每一像素点的灰度值
  33.         for (int i = 0; i < w; i++) {
  34.             for (int j = 0; j < h; j++) {
  35.                 // getRGB()返回默认的RGB颜色模型(十进制)
  36.                 arr[i][j] = getImageGray(bi.getRGB(i, j));// 该点的灰度值
  37.             }
  38.         }
  39.  
  40.         // 构造一个类型为预定义图像类型,BufferedImage
  41.         BufferedImage bufferedImage = new BufferedImage(w, h, BufferedImage.TYPE_BYTE_BINARY);
  42.  
  43.         // 和预先设置的阈值大小进行比较，大的就显示为255即白色，小的就显示为0即黑色
  44.         for (int i = 0; i < w; i++) {
  45.             for (int j = 0; j < h; j++) {
  46.                 if (getGray(arr, i, j, w, h) > YZ) {
  47.                     int white = new Color(255, 255, 255).getRGB();
  48.                     bufferedImage.setRGB(i, j, white);
  49.                 } else {
  50.                     int black = new Color(0, 0, 0).getRGB();
  51.                     bufferedImage.setRGB(i, j, black);
  52.                 }
  53.             }
  54.  
  55.         }
  56.         ImageIO.write(bufferedImage, "jpg", new File(fileOutputPath));
  57.     }
  58.  
  59.     /**
  60.      * 图像的灰度处理
  61.      * 利用浮点算法：Gray = R*0.3 + G*0.59 + B*0.11;
  62.      *
  63.      * @param rgb 该点的RGB值
  64.      * @return 返回处理后的灰度值
  65.      */
  66.     private static int getImageGray(int rgb) {
  67.         String argb = Integer.toHexString(rgb);// 将十进制的颜色值转为十六进制
  68.         // argb分别代表透明,红,绿,蓝 分别占16进制2位
  69.         int r = Integer.parseInt(argb.substring(2, 4), 16);// 后面参数为使用进制
  70.         int g = Integer.parseInt(argb.substring(4, 6), 16);
  71.         int b = Integer.parseInt(argb.substring(6, 8), 16);
  72.         int gray = (int) (r*0.28 + g*0.95 + b*0.11);
  73.         return gray;
  74.     }
  75.  
  76.     /**
  77.      * 自己加周围8个灰度值再除以9，算出其相对灰度值
  78.      *
  79.      * @param gray
  80.      * @param x 要计算灰度的点的横坐标
  81.      * @param y 要计算灰度的点的纵坐标
  82.      * @param w 图像的宽度
  83.      * @param h 图像的高度
  84.      * @return
  85.      */
  86.     public static int getGray(int gray[][], int x, int y, int w, int h) {
  87.         int rs = gray[x][y] + (x == 0 ? 255 : gray[x - 1][y]) + (x == 0 || y == 0 ? 255 : gray[x - 1][y - 1])
  88.                 + (x == 0 || y == h - 1 ? 255 : gray[x - 1][y + 1]) + (y == 0 ? 255 : gray[x][y - 1])
  89.                 + (y == h - 1 ? 255 : gray[x][y + 1]) + (x == w - 1 ? 255 : gray[x + 1][y])
  90.                 + (x == w - 1 || y == 0 ? 255 : gray[x + 1][y - 1])
  91.                 + (x == w - 1 || y == h - 1 ? 255 : gray[x + 1][y + 1]);
  92.         return rs / 9;
  93.     }
  94.  
  95.     /**
  96.      * 二值化后的图像的开运算：先腐蚀再膨胀（用于去除图像的小黑点）
  97.      *
  98.      * @param filePath 要处理的图片路径
  99.      * @param fileOutputPath 处理后的图片输出路径
  100.      * @throws IOException
  101.      */
  102.     public static void opening(String filePath, String fileOutputPath) throws IOException {
  103.         File file = new File(filePath);
  104.         BufferedImage bi = ImageIO.read(file);
  105.         // 获取当前图片的高,宽,ARGB
  106.         int h = bi.getHeight();
  107.         int w = bi.getWidth();
  108.         int arr[][] = new int[w][h];
  109.         // 获取图片每一像素点的灰度值
  110.         for (int i = 0; i < w; i++) {
  111.             for (int j = 0; j < h; j++) {
  112.                 // getRGB()返回默认的RGB颜色模型(十进制)
  113.                 arr[i][j] = getImageGray(bi.getRGB(i, j));// 该点的灰度值
  114.             }
  115.         }
  116.  
  117.         int black = new Color(0, 0, 0).getRGB();
  118.         int white = new Color(255, 255, 255).getRGB();
  119.         BufferedImage bufferedImage = new BufferedImage(w, h, BufferedImage.TYPE_BYTE_BINARY);
  120.         // 临时存储腐蚀后的各个点的亮度
  121.         int temp[][] = new int[w][h];
  122.         // 1.先进行腐蚀操作
  123.         for (int i = 0; i < w; i++) {
  124.             for (int j = 0; j < h; j++) {
  125.                 /*
  126.                  * 为0表示改点和周围8个点都是黑，则该点腐蚀操作后为黑
  127.                  * 由于公司图片态模糊，完全达到9个点全为黑的点太少，最后效果很差，故改为了小于30
  128.                  * （写30的原因是，当只有一个点为白，即总共255，调用getGray方法后得到255/9 = 28）
  129.                  */
  130.                 if (getGray(arr, i, j, w, h) < 30) {
  131.                     temp[i][j] = 0;
  132.                 } else{
  133.                     temp[i][j] = 255;
  134.                 }
  135.             }
  136.         }
  137.  
  138.         // 2.再进行膨胀操作
  139.         for (int i = 0; i < w; i++) {
  140.             for (int j = 0; j < h; j++) {
  141.                 bufferedImage.setRGB(i, j, white);
  142.             }
  143.         }
  144.         for (int i = 0; i < w; i++) {
  145.             for (int j = 0; j < h; j++) {
  146.                 // 为0表示改点和周围8个点都是黑，则该点腐蚀操作后为黑
  147.                 if (temp[i][j] == 0) {
  148.                     bufferedImage.setRGB(i, j, black);
  149.                     if(i > 0) {
  150.                         bufferedImage.setRGB(i-1, j, black);
  151.                     }
  152.                     if (j > 0) {
  153.                         bufferedImage.setRGB(i, j-1, black);
  154.                     }
  155.                     if (i > 0 && j > 0) {
  156.                         bufferedImage.setRGB(i-1, j-1, black);
  157.                     }
  158.                     if (j < h-1) {
  159.                         bufferedImage.setRGB(i, j+1, black);
  160.                     }
  161.                     if (i < w-1) {
  162.                         bufferedImage.setRGB(i+1, j, black);
  163.                     }
  164.                     if (i < w-1 && j > 0) {
  165.                         bufferedImage.setRGB(i+1, j-1, black);
  166.                     }
  167.                     if (i < w-1 && j < h-1) {
  168.                         bufferedImage.setRGB(i+1, j+1, black);
  169.                     }
  170.                     if (i > 0 && j < h-1) {
  171.                         bufferedImage.setRGB(i-1, j+1, black);
  172.                     }
  173.                 }
  174.             }
  175.         }
  176.  
  177.         ImageIO.write(bufferedImage, "jpg", new File(fileOutputPath));
  178.     }
  179.  
  180.     public static void main(String[] args) {
  181.         String fullPath="E:\\test\\img\\1.jpg";
  182.         String newPath="E:\\test\\img\\1new.jpg";
  183.         try {
  184.             ImageOptimizationUtil.binarization(fullPath,newPath);
  185.         } catch (IOException e) {
  186.             e.printStackTrace();
  187.         }
  188.     }
  189. }

可以手动测试，然后对改代码的部分进行调正对应的参数-- gray变量里的计算进行灰度调整

  1.  
  2. private static int getImageGray(int rgb) {
  3.     String argb = Integer.toHexString(rgb);// 将十进制的颜色值转为十六进制
  4.     // argb分别代表透明,红,绿,蓝 分别占16进制2位
  5.     int r = Integer.parseInt(argb.substring(2, 4), 16);// 后面参数为使用进制
  6.     int g = Integer.parseInt(argb.substring(4, 6), 16);
  7.     int b = Integer.parseInt(argb.substring(6, 8), 16);
  8.     int gray = (int) (r*0.28 + g*0.95 + b*0.11);
  9.     return gray;
  10. }

对图片进行调整之后，再对图片进行识别即可。

2.优点

可以直接识别二维码读取部分票面信息，然后用这部分信息作为参数，通过调用税务的接口获取全票面信息。只要是正常的电子发票，识别率差不多是100%，效率极高，准确率也极高

3.缺点

只能获取部分信息，如果需要更多的信息，那就不能获取了，但是大部分场景还是可以覆盖的

如何识别电子发票中的二维码（java实现） - 简书

java实现识别二维码图片功能_java_脚本之家

至此三种思路都已经说完了，用哪个各位同学自己定夺，我目前采用的思路三，暂时没什么问题，基本满足业务需求，后续有问题就得去模型库中自己训练了

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/你好赵伟/article/detail/298032
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号