阿里通用OCR文字识别/图像识别/图片识别 对接（Java篇）

最新推荐文章于 2024-08-02 20:34:22 发布
最新推荐文章于 2024-08-02 20:34:22 发布
阅读量847 收藏 1
点赞数 4
文章标签： ocr
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/gs00125/article/details/140317113
版权

1：进入阿里云开通文字识别

现在1分钱可以购买500次识别

2：这里可以测试 放入自己的图片URL即可

3：进入 云市场-已购买的服务 找到刚才自己买的OCR 复制appcode

4：编写识别代码 img我这里是传入的URL链接

/**
     * OCR文字识别
     * @param img 图片地址
     */
    public static String aliyunAnalysisPic(String img){
        String host = "https://tysbgpu.market.alicloudapi.com";
        String path = "/api/predict/ocr_general";
        String method = "POST";
        //自己的appCode
        String appcode = "自己上面复制的appcode";
        Map<String, String> headers = new HashMap<String, String>();
        //最后在header中的格式(中间是英文空格)为Authorization:APPCODE ****************
        headers.put("Authorization", "APPCODE " + appcode);
        //根据API的要求，定义相对应的Content-Type
        headers.put("Content-Type", "application/json; charset=UTF-8");
        Map<String, String> querys = new HashMap<String, String>();
//        String bodys = "{\"img\":\"\",\"url\":\""+img+"\",\"prob\":false,\"charInfo\":false,\"rotate\":false,\"table\":false}";
        String bodys = "{\"image\":\""+img+"\",\"configure\":{\"output_prob\":true,\"output_keypoints\":false,\"skip_detection\":false,\"without_predicting_direction\":false,\"dir_assure\":false}}";
        try {
            HttpResponse response = HttpUtils.doPost(host, path, method, headers, querys, bodys);
            System.out.println(response.toString());
            //获取response的body
            String entity = EntityUtils.toString(response.getEntity());
            JSONObject jsonObject = new JSONObject(entity);
            String word = extractMaxProbWord(jsonObject);
//            String content = jsonObject.get("word").toString();
            System.out.println(word);
            return word;
        } catch (Exception e) {
            e.printStackTrace();
            return "";
        }
    }

 这个是识别是会返回多个结果 判断prob精度值最大的结果 返回

public static String extractMaxProbWord(JSONObject jsonResponse) throws Exception {
//        JSONObject jsonObject = new JSONObject(jsonResponse);
        JSONArray retArray = jsonResponse.getJSONArray("ret");
        double maxProb = -1;
        String maxProbWord = "";
        for (int i = 0; i < retArray.length(); i++) {
            JSONObject obj = retArray.getJSONObject(i);
            double prob = obj.getDouble("prob");
            String word = obj.getString("word");
            if (prob > maxProb) {
                maxProb = prob;
                maxProbWord = word;
            }
        }
        return maxProbWord;
    }

 5：HttpUtils 工具类

package edu.controllereTest.teacherTest;

import org.apache.commons.lang3.StringUtils;
import org.apache.http.HttpResponse;
import org.apache.http.NameValuePair;
import org.apache.http.client.HttpClient;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.client.methods.HttpDelete;
import org.apache.http.client.methods.HttpGet;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.methods.HttpPut;
import org.apache.http.conn.ClientConnectionManager;
import org.apache.http.conn.scheme.Scheme;
import org.apache.http.conn.scheme.SchemeRegistry;
import org.apache.http.conn.ssl.SSLSocketFactory;
import org.apache.http.entity.ByteArrayEntity;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.message.BasicNameValuePair;

import javax.net.ssl.SSLContext;
import javax.net.ssl.TrustManager;
import javax.net.ssl.X509TrustManager;
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.security.KeyManagementException;
import java.security.NoSuchAlgorithmException;
import java.security.cert.X509Certificate;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;

public class HttpUtils {

    /**
     * get
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doGet(String host, String path, String method,
                                     Map<String, String> headers,
                                     Map<String, String> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpGet request = new HttpGet(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        return httpClient.execute(request);
    }

    /**
     * post form
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param bodys
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      Map<String, String> bodys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (bodys != null) {
            List<NameValuePair> nameValuePairList = new ArrayList<NameValuePair>();

            for (String key : bodys.keySet()) {
                nameValuePairList.add(new BasicNameValuePair(key, bodys.get(key)));
            }
            UrlEncodedFormEntity formEntity = new UrlEncodedFormEntity(nameValuePairList, "utf-8");
            formEntity.setContentType("application/x-www-form-urlencoded; charset=UTF-8");
            request.setEntity(formEntity);
        }

        return httpClient.execute(request);
    }

    /**
     * Post String
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }

        return httpClient.execute(request);
    }

    /**
     * Post stream
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPost(String host, String path, String method,
                                      Map<String, String> headers,
                                      Map<String, String> querys,
                                      byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPost request = new HttpPost(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }

        return httpClient.execute(request);
    }

    /**
     * Put String
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                     Map<String, String> headers,
                                     Map<String, String> querys,
                                     String body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (StringUtils.isNotBlank(body)) {
            request.setEntity(new StringEntity(body, "utf-8"));
        }

        return httpClient.execute(request);
    }

    /**
     * Put stream
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @param body
     * @return
     * @throws Exception
     */
    public static HttpResponse doPut(String host, String path, String method,
                                     Map<String, String> headers,
                                     Map<String, String> querys,
                                     byte[] body)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpPut request = new HttpPut(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        if (body != null) {
            request.setEntity(new ByteArrayEntity(body));
        }

        return httpClient.execute(request);
    }

    /**
     * Delete
     *
     * @param host
     * @param path
     * @param method
     * @param headers
     * @param querys
     * @return
     * @throws Exception
     */
    public static HttpResponse doDelete(String host, String path, String method,
                                        Map<String, String> headers,
                                        Map<String, String> querys)
            throws Exception {
        HttpClient httpClient = wrapClient(host);

        HttpDelete request = new HttpDelete(buildUrl(host, path, querys));
        for (Map.Entry<String, String> e : headers.entrySet()) {
            request.addHeader(e.getKey(), e.getValue());
        }

        return httpClient.execute(request);
    }

    private static String buildUrl(String host, String path, Map<String, String> querys) throws UnsupportedEncodingException {
        StringBuilder sbUrl = new StringBuilder();
        sbUrl.append(host);
        if (!StringUtils.isBlank(path)) {
            sbUrl.append(path);
        }
        if (null != querys) {
            StringBuilder sbQuery = new StringBuilder();
            for (Map.Entry<String, String> query : querys.entrySet()) {
                if (0 < sbQuery.length()) {
                    sbQuery.append("&");
                }
                if (StringUtils.isBlank(query.getKey()) && !StringUtils.isBlank(query.getValue())) {
                    sbQuery.append(query.getValue());
                }
                if (!StringUtils.isBlank(query.getKey())) {
                    sbQuery.append(query.getKey());
                    if (!StringUtils.isBlank(query.getValue())) {
                        sbQuery.append("=");
                        sbQuery.append(URLEncoder.encode(query.getValue(), "utf-8"));
                    }
                }
            }
            if (0 < sbQuery.length()) {
                sbUrl.append("?").append(sbQuery);
            }
        }

        return sbUrl.toString();
    }

    private static HttpClient wrapClient(String host) {
        HttpClient httpClient = new DefaultHttpClient();
        if (host.startsWith("https://")) {
            sslClient(httpClient);
        }

        return httpClient;
    }

    private static void sslClient(HttpClient httpClient) {
        try {
            SSLContext ctx = SSLContext.getInstance("TLS");
            X509TrustManager tm = new X509TrustManager() {
                public X509Certificate[] getAcceptedIssuers() {
                    return null;
                }
                public void checkClientTrusted(X509Certificate[] xcs, String str) {

                }
                public void checkServerTrusted(X509Certificate[] xcs, String str) {

                }
            };
            ctx.init(null, new TrustManager[] { tm }, null);
            SSLSocketFactory ssf = new SSLSocketFactory(ctx);
            ssf.setHostnameVerifier(SSLSocketFactory.ALLOW_ALL_HOSTNAME_VERIFIER);
            ClientConnectionManager ccm = httpClient.getConnectionManager();
            SchemeRegistry registry = ccm.getSchemeRegistry();
            registry.register(new Scheme("https", 443, ssf));
        } catch (KeyManagementException ex) {
            throw new RuntimeException(ex);
        } catch (NoSuchAlgorithmException ex) {
            throw new RuntimeException(ex);
        }
    }

}

6：测试图片

 

7：识别结果

当然 你们可以 吧ret返回集合中的 结果全部拼接起来 

Bug制造者——
关注
阿里云OCR识别
赵云凤的脑公小伦吖
09-28 2762
阿里云ocr识别
阿里云OCR文字识别API接口使用实例--Java
weixin_52173254的博客
05-31 2584
阿里云官方接口：(
阿里云OCR识别SDK示例
09-24
包括c#、c++、nodejs、python(3.5)、go
OCR文字识别各大厂能力对比
最新发布
taogumo的专栏
08-02 517
文字识别大厂能力对比
体验一下阿里云文字识别OCR
qq_46556714的博客
06-29 3924
我体验的是阿里云文字识别OCR阿里云文字识别（Optical Character Recognition，OCR）可以将图片中的文字信息转换为可编辑文本，根据客户的业务场景和需求，将产品分为了通用文字识别、个人证照识别、票据凭证识别、教育场景识别、车辆物流识别、企业资质识别、小语种文字识别等，满足各种客户的图片识别需求。 通用文字识别：https://duguang.aliyun.com/experience?spm=a2c6h.27137474.J_4502519820.3.662f41ddSsEOkK页
阿里云OCR图片文字识别（精确识别）
weixin_45604963的博客
12-12 2616
阿里云OCR图片文字识别
Java调用aliyun OCR图文识别
weixin_42040201的博客
11-19 2148
1、获取AccessKey ID&Access Key Secret 调用阿里云sdk首先需要创建自己阿里云账号，取得AccessKey 和Access Key Secret的值，这两个参数都是sdk调用必须的。 2、开通内容安全服务 服务开通地址：https://www.aliyun.com/product/lvwang?spm=5176.10695662.8115314850.1.d5f3152eszkmjN aliyun OCR SDK参考：...
阿里云OCR卡识别
11-26
阿里云OCR卡识别工具类,根据注释替换key,包含SDK包,导入即可使用
Java图形验证码识别-阿里云OCR(精准率50%)
weixin_43652507的博客
08-07 1077
Java图形验证码识别-阿里云OCR(精准率50%)
我们支持与OCR对接啦！
03-11 207
OCR智能分析平台是一个快速收集数据的便捷工具。使用该工具，将获取到的图片数据，经由OCR智能分析，自动识别对应表单数据，成为字段级的数据进行存储，实现有效数据的快速收集。 ...
阿里云智能印刷文字识别OCR产品介绍.pdf
08-28
阿里云智能印刷文字识别OCR产品介绍.pdf
Android实现阿里OCR通用类文字识别Demo
10-22
Android实现拍照并返回图片，通过调用第三方接口，即使用阿里云的通用类文字识别ocr接口对图片进行文字识别。
阿里巴巴读光OCR.pdf
08-29
大数据上云特惠活动系列直播的阿里巴巴读光OCR的PPT
阿里开放平台接入——开放平台注册与API调用
kongpingyuansu的博客
06-09 5343
文章目录1.背景2.注册账户3.获取key4.能力列表5.开发文档6.获取SDK7.注意事项8.实在搞不定了点我 1.背景 目前对于大部分使用开放平台提供的技术开发应用的开发者而言，开始研发之前的注册，资质认证，应用创建，审核，环境测试等步骤说长不长，说短也不短，但繁琐的步骤无遗会消耗大量的精力，劳心劳力。 阿里云视觉智能开放平台开放了阿里内部应用使用的200+视觉AI能力，包括人脸识别，图像识别，文字识别OCR，分割抠图，目标检测，3D视觉，内容审核，视频处理，医疗辅助等领域等。用于开发人脸闸机，商品识别
一文带你了解阿里云RPA4.0背后的黑科技
阿里云技术
08-19 879
今年5月，Gartner发布了RPA全球竞争格局的调研报告，阿里云RPA名列其中。随着阿里云RPA产品和生态的不断发展、客户的认可与伙伴的倾情投入，阿里云RPA有了很大的突破，并围绕“更专业、更智能、深化集成”方向，全新升级到了4.0版本，除了品牌整体调整外，阿里云RPA还对可视化开发、录制和AI等多个方面进行了重大升级，进一步满足客户业务需求，为企业数字化转型提供高效、安全、智能的服务。 一、阿里云RPA4.0是什么？ 阿里云RPA（Robotic Process Automation，机器人流程自动化）
“真正的机器人测试” - 淘宝泛终端机器人自动化测试实践
m0_69745974的博客
05-04 1730
通过机器人对系统进行黑盒测试，类似的做法在国外Axiz机器人也有尝试。 ▐  为什么要UEE设备端到端自动化测试 E：满足深度用户体验评测的诉求（Experience） 更高精度：随着深度用户体验提升的需求日益增加，端侧的性能和体验优化会精确到ms级别，因此需要找到进一步提升用户体验指标度量精度的方法。 多设备间交互测量：随着多端交互的场景越来越多。不光是APP之间，设备层面APP和PC乃至IoT之间交互的场景也不断出现，需要度量多APP多设备之间的交互性能及用户体验，需要度量多设备多系
近期14个“AI产品经理”职位JD推荐（覆盖北京、上海、深圳、成都、重庆、杭州）
hanniman
12-13 3797
前言：行业内AI产品经理相关的headcount并不多，今天分享给大家的这些职位JD，都是比较不错的机会，感兴趣的AI产品经理朋友，可以查看文末的简历投递方式。----目录----14、...
阿里官方身份证OCR文字识别API 批量识别身份证信息到Excel表格
03-01 685
2、运行时若在pycharm中出现图片格式错误等原因，一般就是阿里官方身份证OCR文字识别API过期或次数用完了，试用是免费的，只有100次，每张照片计一次，可以用新支付宝首次 1分可以有500次。1、工程施工单位中经常要统计工人的身份信息，用于工人信息统计表、工资发放表。在网上查询了相关内容，经调试后可以运行。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值