印刷文字识别-身份证

公司要求作身份证识别,一开始在网上搜索java方面有Tesseract-OCR的开源技术识别率可以达到99.99%。但真正接触下来,是说这个技术识别率可以达到99.99%,但需要大量的训练数据,也就是人工智能那一套。搞了半天根本达不到理想要求。那有没有其他办法那,查找了下中国的3大巨头公司阿里,腾讯、百度都有提供身份证识别接口。那就走调用第三方的方法吧。我选择了阿里。

前提:

1、需要申请一个阿里账号,有淘宝号的用淘宝号登录也可以。

2、然后在云市场搜索“印刷文字识别-身份证”。

3、阿里免费提供500次识别。需要购买该产品。

4、产品购买成功后,获取appcode值,这个要放到header中去的。

5、就可调用用了。

需要的jar包:

Maven项目直接配置依赖就可以,非maven项目就需要导入jar包:

Commons-lang-2.4.jar、fastjson-1.2.7.jar、httpclient-4.5.6.jar、httpcode-4.4.10.jar、servlet-api.jar基本这几个就够用了。

官方文档:https://market.aliyun.com/products/57124001/cmapi010401.html?spm=5176.730005.productlist.d_cmapi010401.stMjsY#sku=yuncode440100000

其他的不说调用代码如下:

  1 import java.io.UnsupportedEncodingException;
  2 import java.net.URLEncoder;
  3 import java.security.KeyManagementException;
  4 import java.security.NoSuchAlgorithmException;
  5 import java.security.cert.X509Certificate;
  6 import java.util.ArrayList;
  7 import java.util.List;
  8 import java.util.Map;
  9
 10 import javax.net.ssl.SSLContext;
 11 import javax.net.ssl.TrustManager;
 12 import javax.net.ssl.X509TrustManager;
 13
 14 import org.apache.commons.lang.StringUtils;
 15 import org.apache.http.HttpResponse;
 16 import org.apache.http.NameValuePair;
 17 import org.apache.http.client.HttpClient;
 18 import org.apache.http.client.entity.UrlEncodedFormEntity;
 19 import org.apache.http.client.methods.HttpDelete;
 20 import org.apache.http.client.methods.HttpGet;
 21 import org.apache.http.client.methods.HttpPost;
 22 import org.apache.http.client.methods.HttpPut;
 23 import org.apache.http.conn.ClientConnectionManager;
 24 import org.apache.http.conn.scheme.Scheme;
 25 import org.apache.http.conn.scheme.SchemeRegistry;
 26 import org.apache.http.conn.ssl.SSLSocketFactory;
 27 import org.apache.http.entity.ByteArrayEntity;
 28 import org.apache.http.entity.StringEntity;
 29 import org.apache.http.impl.client.DefaultHttpClient;
 30 import org.apache.http.message.BasicNameValuePair;
 31
 32 public class HttpUtils {
 33
 34     /**
 35      * get
 36      *
 37      * @param host
 38      * @param path
 39      * @param method
 40      * @param headers
 41      * @param querys
 42      * @return
 43      * @throws Exception
 44      */
 45     public static HttpResponse doGet(String host, String path, String method,
 46                                      Map<String, String> headers,
 47                                      Map<String, String> querys)
 48             throws Exception {
 49         HttpClient httpClient = wrapClient(host);
 50
 51         HttpGet request = new HttpGet(buildUrl(host, path, querys));
 52         for (Map.Entry<String, String> e : headers.entrySet()) {
 53             request.addHeader(e.getKey(), e.getValue());
 54         }
 55
 56         return httpClient.execute(request);
 57     }
 58
 59     /**
 60      * post form
 61      *
 62      * @param host
 63      * @param path
 64      * @param method
 65      * @param headers
 66      * @param querys
 67      * @param bodys
 68      * @return
 69      * @throws Exception
 70      */
 71     public static HttpResponse doPost(String host, String path, String method,
 72                                       Map<String, String> headers,
 73                                       Map<String, String> querys,
 74                                       Map<String, String> bodys)
 75             throws Exception {
 76         HttpClient httpClient = wrapClient(host);
 77
 78         HttpPost request = new HttpPost(buildUrl(host, path, querys));
 79         for (Map.Entry<String, String> e : headers.entrySet()) {
 80             request.addHeader(e.getKey(), e.getValue());
 81         }
 82
 83         if (bodys != null) {
 84             List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();
 85
 86             for (String key : bodys.keySet()) {
 87                 nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
 88             }
 89             UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
 90             formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
 91             request.setEntity(formEntity);
 92         }
 93
 94         return httpClient.execute(request);
 95     }
 96
 97     /**
 98      * Post String
 99      *
100      * @param host
101      * @param path
102      * @param method
103      * @param headers
104      * @param querys
105      * @param body
106      * @return
107      * @throws Exception
108      */
109     public static HttpResponse doPost(String host, String path, String method,
110                                       Map<String, String> headers,
111                                       Map<String, String> querys,
112                                       String body)
113             throws Exception {
114         HttpClient httpClient = wrapClient(host);
115
116         HttpPost request = new HttpPost(buildUrl(host, path, querys));
117         for (Map.Entry<String, String> e : headers.entrySet()) {
118             request.addHeader(e.getKey(), e.getValue());
119         }
120
121         if (StringUtils.isNotBlank(body)) {
122             request.setEntity(new StringEntity(body, "utf-8"));
123         }
124
125         return httpClient.execute(request);
126     }
127
128     /**
129      * Post stream
130      *
131      * @param host
132      * @param path
133      * @param method
134      * @param headers
135      * @param querys
136      * @param body
137      * @return
138      * @throws Exception
139      */
140     public static HttpResponse doPost(String host, String path, String method,
141                                       Map<String, String> headers,
142                                       Map<String, String> querys,
143                                       byte[] body)
144             throws Exception {
145         HttpClient httpClient = wrapClient(host);
146
147         HttpPost request = new HttpPost(buildUrl(host, path, querys));
148         for (Map.Entry<String, String> e : headers.entrySet()) {
149             request.addHeader(e.getKey(), e.getValue());
150         }
151
152         if (body != null) {
153             request.setEntity(new ByteArrayEntity(body));
154         }
155
156         return httpClient.execute(request);
157     }
158
159     /**
160      * Put String
161      * @param host
162      * @param path
163      * @param method
164      * @param headers
165      * @param querys
166      * @param body
167      * @return
168      * @throws Exception
169      */
170     public static HttpResponse doPut(String host, String path, String method,
171                                      Map<String, String> headers,
172                                      Map<String, String> querys,
173                                      String body)
174             throws Exception {
175         HttpClient httpClient = wrapClient(host);
176
177         HttpPut request = new HttpPut(buildUrl(host, path, querys));
178         for (Map.Entry<String, String> e : headers.entrySet()) {
179             request.addHeader(e.getKey(), e.getValue());
180         }
181
182         if (StringUtils.isNotBlank(body)) {
183             request.setEntity(new StringEntity(body, "utf-8"));
184         }
185
186         return httpClient.execute(request);
187     }
188
189     /**
190      * Put stream
191      * @param host
192      * @param path
193      * @param method
194      * @param headers
195      * @param querys
196      * @param body
197      * @return
198      * @throws Exception
199      */
200     public static HttpResponse doPut(String host, String path, String method,
201                                      Map<String, String> headers,
202                                      Map<String, String> querys,
203                                      byte[] body)
204             throws Exception {
205         HttpClient httpClient = wrapClient(host);
206
207         HttpPut request = new HttpPut(buildUrl(host, path, querys));
208         for (Map.Entry<String, String> e : headers.entrySet()) {
209             request.addHeader(e.getKey(), e.getValue());
210         }
211
212         if (body != null) {
213             request.setEntity(new ByteArrayEntity(body));
214         }
215
216         return httpClient.execute(request);
217     }
218
219     /**
220      * Delete
221      *
222      * @param host
223      * @param path
224      * @param method
225      * @param headers
226      * @param querys
227      * @return
228      * @throws Exception
229      */
230     public static HttpResponse doDelete(String host, String path, String method,
231                                         Map<String, String> headers,
232                                         Map<String, String> querys)
233             throws Exception {
234         HttpClient httpClient = wrapClient(host);
235
236         HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
237         for (Map.Entry<String, String> e : headers.entrySet()) {
238             request.addHeader(e.getKey(), e.getValue());
239         }
240
241         return httpClient.execute(request);
242     }
243
244     private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
245         StringBuilder sbUrl = new StringBuilder();
246         sbUrl.append(host);
247         if (!StringUtils.isBlank(path)) {
248             sbUrl.append(path);
249         }
250         if (null != querys) {
251             StringBuilder sbQuery = new StringBuilder();
252             for (Map.Entry<String, String> query : querys.entrySet()) {
253                 if (0 < sbQuery.length()) {
254                     sbQuery.append("&");
255                 }
256                 if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
257                     sbQuery.append(query.getValue());
258                 }
259                 if (!StringUtils.isBlank(query.getKey())) {
260                     sbQuery.append(query.getKey());
261                     if (!StringUtils.isBlank(query.getValue())) {
262                         sbQuery.append("=");
263                         sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
264                     }
265                 }
266             }
267             if (0 < sbQuery.length()) {
268                 sbUrl.append("?").append(sbQuery);
269             }
270         }
271
272         return sbUrl.toString();
273     }
274
275     private static HttpClient wrapClient(String host) {
276         HttpClient httpClient = new DefaultHttpClient();
277         if (host.startsWith("https://")) {
278             sslClient(httpClient);
279         }
280
281         return httpClient;
282     }
283
284     private static void sslClient(HttpClient httpClient) {
285         try {
286             SSLContext ctx = SSLContext.getInstance("TLS");
287             X509TrustManager tm = new X509TrustManager() {
288                 public X509Certificate[] getAcceptedIssuers() {
289                     return null;
290                 }
291                 public void checkClientTrusted(X509Certificate[] xcs, String str) {
292
293                 }
294                 public void checkServerTrusted(X509Certificate[] xcs, String str) {
295
296                 }
297             };
298             ctx.init(null, new TrustManager[] { tm }, null);
299             SSLSocketFactory ssf = new SSLSocketFactory(ctx);
300             ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
301             ClientConnectionManager ccm = httpClient.getConnectionManager();
302             SchemeRegistry registry = ccm.getSchemeRegistry();
303             registry.register(new Scheme("https", 443, ssf));
304         } catch (KeyManagementException ex) {
305             throw new RuntimeException(ex);
306         } catch (NoSuchAlgorithmException ex) {
307             throw new RuntimeException(ex);
308         }
309     }
310 }

调用的工具累HttpUtils:

  1 import java.io.UnsupportedEncodingException;
  2 import java.net.URLEncoder;
  3 import java.security.KeyManagementException;
  4 import java.security.NoSuchAlgorithmException;
  5 import java.security.cert.X509Certificate;
  6 import java.util.ArrayList;
  7 import java.util.List;
  8 import java.util.Map;
  9
 10 import javax.net.ssl.SSLContext;
 11 import javax.net.ssl.TrustManager;
 12 import javax.net.ssl.X509TrustManager;
 13
 14 import org.apache.commons.lang.StringUtils;
 15 import org.apache.http.HttpResponse;
 16 import org.apache.http.NameValuePair;
 17 import org.apache.http.client.HttpClient;
 18 import org.apache.http.client.entity.UrlEncodedFormEntity;
 19 import org.apache.http.client.methods.HttpDelete;
 20 import org.apache.http.client.methods.HttpGet;
 21 import org.apache.http.client.methods.HttpPost;
 22 import org.apache.http.client.methods.HttpPut;
 23 import org.apache.http.conn.ClientConnectionManager;
 24 import org.apache.http.conn.scheme.Scheme;
 25 import org.apache.http.conn.scheme.SchemeRegistry;
 26 import org.apache.http.conn.ssl.SSLSocketFactory;
 27 import org.apache.http.entity.ByteArrayEntity;
 28 import org.apache.http.entity.StringEntity;
 29 import org.apache.http.impl.client.DefaultHttpClient;
 30 import org.apache.http.message.BasicNameValuePair;
 31
 32 public class HttpUtils {
 33
 34     /**
 35      * get
 36      *
 37      * @param host
 38      * @param path
 39      * @param method
 40      * @param headers
 41      * @param querys
 42      * @return
 43      * @throws Exception
 44      */
 45     public static HttpResponse doGet(String host, String path, String method,
 46                                      Map<String, String> headers,
 47                                      Map<String, String> querys)
 48             throws Exception {
 49         HttpClient httpClient = wrapClient(host);
 50
 51         HttpGet request = new HttpGet(buildUrl(host, path, querys));
 52         for (Map.Entry<String, String> e : headers.entrySet()) {
 53             request.addHeader(e.getKey(), e.getValue());
 54         }
 55
 56         return httpClient.execute(request);
 57     }
 58
 59     /**
 60      * post form
 61      *
 62      * @param host
 63      * @param path
 64      * @param method
 65      * @param headers
 66      * @param querys
 67      * @param bodys
 68      * @return
 69      * @throws Exception
 70      */
 71     public static HttpResponse doPost(String host, String path, String method,
 72                                       Map<String, String> headers,
 73                                       Map<String, String> querys,
 74                                       Map<String, String> bodys)
 75             throws Exception {
 76         HttpClient httpClient = wrapClient(host);
 77
 78         HttpPost request = new HttpPost(buildUrl(host, path, querys));
 79         for (Map.Entry<String, String> e : headers.entrySet()) {
 80             request.addHeader(e.getKey(), e.getValue());
 81         }
 82
 83         if (bodys != null) {
 84             List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();
 85
 86             for (String key : bodys.keySet()) {
 87                 nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
 88             }
 89             UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
 90             formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
 91             request.setEntity(formEntity);
 92         }
 93
 94         return httpClient.execute(request);
 95     }
 96
 97     /**
 98      * Post String
 99      *
100      * @param host
101      * @param path
102      * @param method
103      * @param headers
104      * @param querys
105      * @param body
106      * @return
107      * @throws Exception
108      */
109     public static HttpResponse doPost(String host, String path, String method,
110                                       Map<String, String> headers,
111                                       Map<String, String> querys,
112                                       String body)
113             throws Exception {
114         HttpClient httpClient = wrapClient(host);
115
116         HttpPost request = new HttpPost(buildUrl(host, path, querys));
117         for (Map.Entry<String, String> e : headers.entrySet()) {
118             request.addHeader(e.getKey(), e.getValue());
119         }
120
121         if (StringUtils.isNotBlank(body)) {
122             request.setEntity(new StringEntity(body, "utf-8"));
123         }
124
125         return httpClient.execute(request);
126     }
127
128     /**
129      * Post stream
130      *
131      * @param host
132      * @param path
133      * @param method
134      * @param headers
135      * @param querys
136      * @param body
137      * @return
138      * @throws Exception
139      */
140     public static HttpResponse doPost(String host, String path, String method,
141                                       Map<String, String> headers,
142                                       Map<String, String> querys,
143                                       byte[] body)
144             throws Exception {
145         HttpClient httpClient = wrapClient(host);
146
147         HttpPost request = new HttpPost(buildUrl(host, path, querys));
148         for (Map.Entry<String, String> e : headers.entrySet()) {
149             request.addHeader(e.getKey(), e.getValue());
150         }
151
152         if (body != null) {
153             request.setEntity(new ByteArrayEntity(body));
154         }
155
156         return httpClient.execute(request);
157     }
158
159     /**
160      * Put String
161      * @param host
162      * @param path
163      * @param method
164      * @param headers
165      * @param querys
166      * @param body
167      * @return
168      * @throws Exception
169      */
170     public static HttpResponse doPut(String host, String path, String method,
171                                      Map<String, String> headers,
172                                      Map<String, String> querys,
173                                      String body)
174             throws Exception {
175         HttpClient httpClient = wrapClient(host);
176
177         HttpPut request = new HttpPut(buildUrl(host, path, querys));
178         for (Map.Entry<String, String> e : headers.entrySet()) {
179             request.addHeader(e.getKey(), e.getValue());
180         }
181
182         if (StringUtils.isNotBlank(body)) {
183             request.setEntity(new StringEntity(body, "utf-8"));
184         }
185
186         return httpClient.execute(request);
187     }
188
189     /**
190      * Put stream
191      * @param host
192      * @param path
193      * @param method
194      * @param headers
195      * @param querys
196      * @param body
197      * @return
198      * @throws Exception
199      */
200     public static HttpResponse doPut(String host, String path, String method,
201                                      Map<String, String> headers,
202                                      Map<String, String> querys,
203                                      byte[] body)
204             throws Exception {
205         HttpClient httpClient = wrapClient(host);
206
207         HttpPut request = new HttpPut(buildUrl(host, path, querys));
208         for (Map.Entry<String, String> e : headers.entrySet()) {
209             request.addHeader(e.getKey(), e.getValue());
210         }
211
212         if (body != null) {
213             request.setEntity(new ByteArrayEntity(body));
214         }
215
216         return httpClient.execute(request);
217     }
218
219     /**
220      * Delete
221      *
222      * @param host
223      * @param path
224      * @param method
225      * @param headers
226      * @param querys
227      * @return
228      * @throws Exception
229      */
230     public static HttpResponse doDelete(String host, String path, String method,
231                                         Map<String, String> headers,
232                                         Map<String, String> querys)
233             throws Exception {
234         HttpClient httpClient = wrapClient(host);
235
236         HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
237         for (Map.Entry<String, String> e : headers.entrySet()) {
238             request.addHeader(e.getKey(), e.getValue());
239         }
240
241         return httpClient.execute(request);
242     }
243
244     private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
245         StringBuilder sbUrl = new StringBuilder();
246         sbUrl.append(host);
247         if (!StringUtils.isBlank(path)) {
248             sbUrl.append(path);
249         }
250         if (null != querys) {
251             StringBuilder sbQuery = new StringBuilder();
252             for (Map.Entry<String, String> query : querys.entrySet()) {
253                 if (0 < sbQuery.length()) {
254                     sbQuery.append("&");
255                 }
256                 if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
257                     sbQuery.append(query.getValue());
258                 }
259                 if (!StringUtils.isBlank(query.getKey())) {
260                     sbQuery.append(query.getKey());
261                     if (!StringUtils.isBlank(query.getValue())) {
262                         sbQuery.append("=");
263                         sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
264                     }
265                 }
266             }
267             if (0 < sbQuery.length()) {
268                 sbUrl.append("?").append(sbQuery);
269             }
270         }
271
272         return sbUrl.toString();
273     }
274
275     private static HttpClient wrapClient(String host) {
276         HttpClient httpClient = new DefaultHttpClient();
277         if (host.startsWith("https://")) {
278             sslClient(httpClient);
279         }
280
281         return httpClient;
282     }
283
284     private static void sslClient(HttpClient httpClient) {
285         try {
286             SSLContext ctx = SSLContext.getInstance("TLS");
287             X509TrustManager tm = new X509TrustManager() {
288                 public X509Certificate[] getAcceptedIssuers() {
289                     return null;
290                 }
291                 public void checkClientTrusted(X509Certificate[] xcs, String str) {
292
293                 }
294                 public void checkServerTrusted(X509Certificate[] xcs, String str) {
295
296                 }
297             };
298             ctx.init(null, new TrustManager[] { tm }, null);
299             SSLSocketFactory ssf = new SSLSocketFactory(ctx);
300             ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
301             ClientConnectionManager ccm = httpClient.getConnectionManager();
302             SchemeRegistry registry = ccm.getSchemeRegistry();
303             registry.register(new Scheme("https", 443, ssf));
304         } catch (KeyManagementException ex) {
305             throw new RuntimeException(ex);
306         } catch (NoSuchAlgorithmException ex) {
307             throw new RuntimeException(ex);
308         }
309     }
310 }

识别结果正确率已经达到可用。

{"sex":"男","num":"410527**********","birth":"1990**","request_id":"20180801150222_a325b5b8ea94c5c3ab2b7c98310252ef","nationality":"汉","address":"河南省******","name":"***","config_str":"{\"side\":\"face\"}","success":true,"face_rect":{"center":{"y":488,"x":1412},"angle":-90,"size":{"height":240,"width":208}}}

原文地址:https://www.cnblogs.com/gynbk/p/9401530.html

时间: 2024-11-05 22:54:18

印刷文字识别-身份证的相关文章

Delphi百度文字识别【支持通用文字识别、身份证识别、银行卡识别、驾驶证识别、行驶证识别、车牌识别等功能】

Delphi百度文字识别          百度api文档 [Delphi百度文字识别]支持 通用文字识别.通用文字识别(高精度版).通用文字识别(含位置信息版).通用文字识别(高精度含位置版).手写文字识别.身份证识别.银行卡识别.营业执照识别.护照识别.名片识别.户口本识别.出生医学证明识别.港澳通行证识别.台湾通行证识别.通用票据识别.表格文字识别.通用票据识别.增值税发票识别.火车票识别.出租车票识别.定额发票识别.驾驶证识别.行驶证识别.车牌识别.机动车销售发票识别.车辆合格证识别.V

文通移动文字识别采集终端(身份证识别,驾驶证识别,行驶证识别,护照识别,车牌识别)

产品背景: 随着智能终端(智能手机及平板电脑)及移动通信(3G)的发展,原来运行在PC上的信息系统(如邮件系统.即时通信.网页浏览.协同办公.网络购物.社交网站等)逐渐转移到智能终端设备上.可以预见未来几年60%以上的业务将会逐渐转移到智能终端系统上来.在这种背景下,北京文通推出基于Android 平台的快证通移动数据采集终端. 产品概述: 文通移动数据采集终端由平板电脑.拍摄支架.及文通OCR识别软件组成.他采用主流平板电脑配置Cortex-A9 双核CPU,1G RAM/8G ROM,And

深度学习文字识别

Blog:https://blog.csdn.net/implok/article/details/95041472 步骤: 文字识别是AI的一个重要应用场景,文字识别过程一般由图像输入.预处理.文本检测.文本识别.结果输出等环节组成. 分类:文字识别可根据待识别的文字特点采用不同的识别方法,一般分为定长文字.不定长文字两大类别. 定长文字(例如手写数字识别.验证码),由于字符数量固定,采用的网络结构相对简单,识别也比较容易: 不定长文字(例如印刷文字.广告牌文字等),由于字符数量是不固定的,因

手机扫描识别身份证,拍照识别身份证

手机扫描识别身份证,拍照识别身份证 关键词:手机扫描识别身份证,拍照识别身份证,身份证识别,身份证扫描识别,身份证识别SDK 自2013年后,随着智能手机的普及,越来越多的互联网金融公司都推出了自己的金融APP,这些APP都涉及到个人身份证信息的输入认证,如果手动去输入身份证号码和姓名,速度非常慢,且用户体验非常差.为了提高在移动终端上输入身份证信息的速度和准确性,文通科技开发出身份证识别SDK,以满足各行业应用需求,给用户带来更好的体验.金融APP将身份证识别SDK集成到APP中,就能用手机摄

OCR文字识别软件:数字信息化不可或缺的重要组成部分

OCR文字识别技术,是在国家"863"计划国家自然科学基金长期支持下,清华大学电子工程系智能图文信息处理研究室汉字识别研究工作的基础上开发完成的.该软件能够快速地将印刷的文档转化为可供阅读和可编辑的高质量电子文档,进而将电子文档应用到各类数据库.电子出版物.数字图书馆.网络资源等新型资源的建设和再版图书生产中,是行业数字信息化不可或缺的重要组成部分. 主要功能模块 OCR文字识别软件识别核心 OCR文字识别软件内置高性能文字识别引擎,中文识别率达99.8%以上.英文.日文.韩文的识别率

OCR文字识别技术的用处

图片文字识别软件ABBYY FineReader是现在办公室的必备软件,它可以识别JPG.GIF.PNG.BMP.TIF和PDF源文件.PDF扫描件,也就是说我们在日常工作中能够遇到的不能编辑的文字都可以通过ABBYY FineReader图片文字识别软件来识别,识别得到的文字可以自由的进行编辑.有很多人有这样的疑问,图片文字识别软件的技术原理是什么呢? 1.图文输入:是指通过输入设备将文档输入到计算机中,也就是实现原稿的数字化.现在用得比较普遍的设备是扫描仪.文档图像的扫描质量是OCR软件正确

安卓端OCR文字识别之番外篇

拍照识别------OCR如何在移动端大放异彩 大家好.我是文通晓伟.很高兴能和大家共同探讨一下OCR识别技术在安卓端的应用. 首先坦白交代,我不是技术流,我是销售狗. 每天有打不完的电话和做不完的表. 不过我唯一值得骄傲的,是我可以第一时间得到最终用户的反馈,或者需求. 近几年来,移动互联网生猛的占据了每个大街小巷.据说在杭州,连卖煎饼果子的大妈都在用移动支付. 想想也是醉了.我等985,211,毕业的大学生都没弄懂啥是移动互联网.简直惭愧啊. OCR行业也不例外.照样被冲击的面目全非. 原来

如何精准实现OCR文字识别?

欢迎大家前往腾讯云+社区,获取更多腾讯海量技术实践干货哦~ 本文由云计算基础发表于云+社区专栏 前言 2018年3月27日腾讯云云+社区联合腾讯云智能图像团队共同在客户群举办了腾讯云OCR文字识别--智能图像分享活动,活动举办期间用户耐心听分享嘉宾的介绍,并提出了相关的问题,智能图像团队的科学家和工程师也耐心解答可用户的疑问.以下就是活动分享的全部内容. 正文 在日常生活工作中,我们难免会遇到一些问题,比如自己辛辛苦苦写完的资料,好不容易打印出来却发现源文件丢了.难的收集了一些名片,却要很麻烦的

福昕扫描王:OCR文字识别一秒搞定文字摘录

图书是人类文明进步的阶梯,它蕴含了大量的天文地理各个方面的知识.需要需要摘出其中的精华,你的唯一的选择就是手写打印出来.当然这是最笨的办法,聪明的人会选择OCR文字识别,没听过不要紧,你只要记住一点,有文字的地方都可以应用到这个技术. 摘录书籍这个大家都知道,汽车进出停车场怎么识别车牌号?就是文字识别技术啦,还有比方说:身份证识别.表格识别.手写文字识别等等,可以快速提升你的效率,时间多么宝贵,不要再浪费时间了哇.既然福昕扫描王一秒就可以识别出文字,福昕扫描王到底是什么东西?一个文字识别手机Ap