百度OCR如何白嫖的淋漓尽致

已于 2022-10-14 11:00:16 修改
阅读量875 收藏
点赞数 2
分类专栏： OCR 文章标签： 百度 java
于 2022-10-14 10:02:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37162041/article/details/127314644
版权

 场景：

    在图片中查找是否包含某个关键字

 解决方案：

     百度OCR可每月可使用2000次，包含（高精度识别，高精度含位置识别，标准识别，标准含位  置识别）以及 普通表格识别（每天200次）。利用限制次数，如果第一个接口使用完成，则使用第二个接口，按此逻辑依次调用。调用成功次数缓存redis，根据实际情况设置过期时间，如果次数已满则调用次数没满的接口。

package com.lanlinker.cloud.labor.util;

import com.alibaba.fastjson.JSONArray;
import com.alibaba.fastjson.JSONObject;
import com.lanlinker.cloud.labor.component.HttpRequestComponent;
import com.lanlinker.cloud.labor.config.ApplicationContextHelper;
import io.minio.MinioClient;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.RedisTemplate;

import java.io.*;
import java.net.URLEncoder;
import java.util.*;
import java.util.concurrent.TimeUnit;


@Slf4j
public class OCRUtil {

    private static HttpRequestComponent httpRequestComponent;

    public static HttpRequestComponent getHttpRequestComponent() {
        if(httpRequestComponent==null){
            httpRequestComponent = new HttpRequestComponent();
            return httpRequestComponent;
        }
        return httpRequestComponent;
    }

    //获取token
    private static String TOKEN_URL = "https://aip.baidubce.com/oauth/2.0/token";

    //高精度识别
    private static String HIGH_PRECISION_URL = "https://aip.baidubce.com/rest/2.0/ocr/v1/accurate_basic";

    //高精度含位置版
    private static String HIGH_PRECISION_SEAT_URL = "https://aip.baidubce.com/rest/2.0/ocr/v1/accurate";

    //标准版
    private static String STANDARD_URL = "https://aip.baidubce.com/rest/2.0/ocr/v1/general_basic";

    //标准含位置版
    private static String STANDARD_SEAT_URL = "https://aip.baidubce.com/rest/2.0/ocr/v1/general";

    //表格文字识别
    private static String FORM_URL = "https://aip.baidubce.com/rest/2.0/ocr/v1/form";

    private static final String CLIENT_ID = "";

    private static final String CLIENT_SECRET = "";

    public static  String BAIDU_TOKEN = "BAIDU_TOKEN";

    public static  String HIGH_PRECISION = "HIGH_PRECISION";

    public static  String HIGH_PRECISION_SEAT = "HIGH_PRECISION_SEAT";

    public static  String STANDARD = "STANDARD";

    public static  String STANDARD_SEAT = "STANDARD_SEAT";

    public static  String FORM = "FORM";

    private static volatile Integer index = 0;

    private static RedisTemplate redisTemplate;

    private static Set<String> set = new HashSet<>();

    public static RedisTemplate getRedisTemplate() {
        if(redisTemplate==null){
            redisTemplate = (RedisTemplate)ApplicationContextHelper.getBean("redisTemplate");
        }
        return redisTemplate;
    }

    private static String getToken() throws Exception{
        Object token = getRedisTemplate().opsForValue().get(BAIDU_TOKEN);
        if(token==null){
            TOKEN_URL = TOKEN_URL + "?grant_type=client_credentials&client_id="+CLIENT_ID+"&client_secret="+CLIENT_SECRET;
            String post = getHttpRequestComponent().execute("POST_FOR_URL",TOKEN_URL,null);
            // 返回结果格式为Json字符串
            JSONObject jsonObject = JSONObject.parseObject(post);
            String accessToken = jsonObject.getString("access_token");
            Integer expiresIn = jsonObject.getInteger("expires_in");
            getRedisTemplate().opsForValue().set(BAIDU_TOKEN,accessToken,expiresIn, TimeUnit.SECONDS);
            return accessToken;
        }else{
            return token.toString();
        }
    }

    //用于token失效试调用
    private static String getTokens() throws Exception{
        TOKEN_URL = TOKEN_URL + "?grant_type=client_credentials&client_id="+CLIENT_ID+"&client_secret="+CLIENT_SECRET;
        String post = getHttpRequestComponent().execute("POST_FOR_URL",TOKEN_URL,null);
        // 返回结果格式为Json字符串
        JSONObject jsonObject = JSONObject.parseObject(post);
        String accessToken = jsonObject.getString("access_token");
        Integer expiresIn = jsonObject.getInteger("expires_in");
        getRedisTemplate().opsForValue().set(BAIDU_TOKEN,accessToken,expiresIn, TimeUnit.SECONDS);
        return accessToken;

    }


    //高精度
    public static Set<String> getAccurateBasicText(List<String> images, String ENDPOINT, String ACCESS_KEY, String SECRET_KEY, String BUCKET_NAME){
        try {
            String token = getToken();
            HIGH_PRECISION_URL = HIGH_PRECISION_URL + "?access_token="+token;
            Integer value = 0 ;
            Iterator<String> iterator = images.iterator();
            while (iterator.hasNext()){
                String path = iterator.next();
                InputStream in = getInputStream(path,ENDPOINT,ACCESS_KEY,SECRET_KEY,BUCKET_NAME);
                byte[] fileByte = getFileBytes(in);// 获取图片字节数组
                String base64UrlencodedImg = base64Urlencode(fileByte);// 编码
                String post = getHttpRequestComponent().execute("POST_FOR_URL", HIGH_PRECISION_URL, base64UrlencodedImg);
                JSONObject resultsData = JSONObject.parseObject(post);
                Integer errorCode = resultsData.getInteger("error_code");
                //免费的用完了哦！赶紧去充钱。。。
                if(errorCode!=null){
                    log.error("errorCode===>"+errorCode);
                    if(errorCode==17||errorCode==19){
                        Long expire = getRedisTemplate().getExpire(HIGH_PRECISION, TimeUnit.SECONDS);
                        if (expire != null && expire >0) {
                            getRedisTemplate().opsForValue().set(HIGH_PRECISION,2000,expire,TimeUnit.SECONDS);
                        }
                        //想不到吧！免费的不止一个哟。。。
                        return getAccurateBasicSeatText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }else if(errorCode==18){
                        //想不到吧！免费的不止一个哟。。。
                        return getAccurateBasicSeatText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }else if(errorCode==100||errorCode==110||errorCode==111){
                        if (index==3) {
                            return new HashSet<>();
                        }
                        index++;
                        //token失效重新获取token
                        getTokens();
                        return getAccurateBasicText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }
                }
                JSONArray wordsResult = resultsData.getJSONArray("words_result");
                if (wordsResult==null) {
                    continue;
                }
                for (int j = 0; j < wordsResult.size(); j++) {
                    JSONObject jsonObject = wordsResult.getJSONObject(j);
                    set.add(jsonObject.getString("words").trim());
                }
                value++;
                iterator.remove();
            }
            /*for (int i = 0; i < images.size(); i++) {
                String path = images.get(i);
            }*/
            Object size = getRedisTemplate().opsForValue().get(HIGH_PRECISION);
            if (size!=null) {
                Integer integer = Integer.valueOf(size.toString());
                Long expire = getRedisTemplate().getExpire(HIGH_PRECISION, TimeUnit.SECONDS);
                if (expire != null && expire >0) {
                    getRedisTemplate().opsForValue().set(HIGH_PRECISION,integer+value,expire,TimeUnit.SECONDS);
                }
            }else{
                getRedisTemplate().opsForValue().set(HIGH_PRECISION,value,30,TimeUnit.DAYS);
            }
            return set;
        }catch (Exception e){
            e.printStackTrace();
            return  getAccurateBasicSeatText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
        }
    }


    //高精度含位置版
    public static Set<String> getAccurateBasicSeatText(List<String> images,String ENDPOINT,String ACCESS_KEY,String SECRET_KEY,String BUCKET_NAME){
        try {
            String token = getToken();
            HIGH_PRECISION_SEAT_URL = HIGH_PRECISION_SEAT_URL + "?access_token="+token;
            Integer value = 0;
            Iterator<String> iterator = images.iterator();
            while (iterator.hasNext()){
            //for (int i = 0; i < images.size(); i++) {
                String path = iterator.next();//images.get(i);
                InputStream in = getInputStream(path,ENDPOINT,ACCESS_KEY,SECRET_KEY,BUCKET_NAME);
                byte[] fileByte = getFileBytes(in);// 获取图片字节数组
                String base64UrlencodedImg = base64Urlencode(fileByte);// 编码
                String post = getHttpRequestComponent().execute("POST_FOR_URL", HIGH_PRECISION_SEAT_URL, base64UrlencodedImg);
                JSONObject resultsData = JSONObject.parseObject(post);
                Integer errorCode = resultsData.getInteger("error_code");
                //免费的用完了哦！赶紧去充钱。。。
                if(errorCode!=null){
                    log.error("errorCode===>"+errorCode);
                    if(errorCode==17||errorCode==19){
                        Long expire = getRedisTemplate().getExpire(HIGH_PRECISION_SEAT, TimeUnit.SECONDS);
                        if (expire != null && expire >0) {
                            getRedisTemplate().opsForValue().set(HIGH_PRECISION_SEAT,2000,expire,TimeUnit.SECONDS);
                        }
                        //想不到吧！免费的不止一个哟。。。
                        return getStandardText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }else if(errorCode==18){
                        //想不到吧！免费的不止一个哟。。。
                        return getStandardText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }else if(errorCode==100||errorCode==110||errorCode==111){
                        if (index==3) {
                            return new HashSet<>();
                        }
                        index++;
                        //token失效重新获取token
                        getTokens();
                        return getAccurateBasicSeatText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }
                }
                JSONArray wordsResult = resultsData.getJSONArray("words_result");
                if (wordsResult==null) {
                    continue;
                }
                for (int j = 0; j < wordsResult.size(); j++) {
                    JSONObject jsonObject = wordsResult.getJSONObject(j);
                    set.add(jsonObject.getString("words").trim());
                }
                value++;
                iterator.remove();
            }
            Object size = getRedisTemplate().opsForValue().get(HIGH_PRECISION_SEAT);
            if (size!=null) {
                Integer integer = Integer.valueOf(size.toString());
                Long expire = getRedisTemplate().getExpire(HIGH_PRECISION_SEAT, TimeUnit.SECONDS);
                if (expire != null && expire >0) {
                    getRedisTemplate().opsForValue().set(HIGH_PRECISION_SEAT,integer+value,expire,TimeUnit.SECONDS);
                }
            }else{
                getRedisTemplate().opsForValue().set(HIGH_PRECISION_SEAT,value,30,TimeUnit.DAYS);
            }
            return set;
        }catch (Exception e){
             e.printStackTrace();
            return getStandardText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
        }
    }


    //标准
    public static Set<String> getStandardText(List<String> images,String ENDPOINT,String ACCESS_KEY,String SECRET_KEY,String BUCKET_NAME){
        try {
            String token = getToken();
            STANDARD_URL = STANDARD_URL + "?access_token="+token;
            Integer value = 0;
            //for (int i = 0; i < images.size(); i++) {
            Iterator<String> iterator = images.iterator();
            while (iterator.hasNext()){
                String path = iterator.next();//images.get(i);
                InputStream in = getInputStream(path,ENDPOINT,ACCESS_KEY,SECRET_KEY,BUCKET_NAME);
                byte[] fileByte = getFileBytes(in);// 获取图片字节数组
                String base64UrlencodedImg = base64Urlencode(fileByte);// 编码
                String post = getHttpRequestComponent().execute("POST_FOR_URL", STANDARD_URL, base64UrlencodedImg);
                JSONObject resultsData = JSONObject.parseObject(post);
                Integer errorCode = resultsData.getInteger("error_code");
                //免费的用完了哦！赶紧去充钱。。。
                if(errorCode!=null){
                    log.error("errorCode===>"+errorCode);
                    if(errorCode==17||errorCode==19){
                        Long expire = getRedisTemplate().getExpire(STANDARD, TimeUnit.SECONDS);
                        if (expire != null && expire >0) {
                            getRedisTemplate().opsForValue().set(STANDARD,2000,expire,TimeUnit.SECONDS);
                        }
                        //想不到吧！免费的不止一个哟。。。
                        return getStandardSeatText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }else if(errorCode==18){
                        //想不到吧！免费的不止一个哟。。。
                        return getStandardSeatText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }else if(errorCode==100||errorCode==110||errorCode==111){
                        if (index==3) {
                            return new HashSet<>();
                        }
                        index++;
                        //token失效重新获取token
                        getTokens();
                        return getStandardText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }
                }
                JSONArray wordsResult = resultsData.getJSONArray("words_result");
                if (wordsResult==null) {
                    continue;
                }
                for (int j = 0; j < wordsResult.size(); j++) {
                    JSONObject jsonObject = wordsResult.getJSONObject(j);
                    set.add(jsonObject.getString("words").trim());
                }
                value++;
                iterator.remove();
            }

            Object size = getRedisTemplate().opsForValue().get(STANDARD);
            if (size!=null) {
                Integer integer = Integer.valueOf(size.toString());
                Long expire = getRedisTemplate().getExpire(STANDARD, TimeUnit.SECONDS);
                if (expire != null && expire > 0) {
                    getRedisTemplate().opsForValue().set(STANDARD,integer+value,expire,TimeUnit.SECONDS);
                }
            }else{
                getRedisTemplate().opsForValue().set(STANDARD,value,30,TimeUnit.DAYS);
            }
            return set;
        }catch (Exception e){
              e.printStackTrace();
            return getStandardSeatText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
        }
    }

    //标准含位置
    public static Set<String> getStandardSeatText(List<String> images,String ENDPOINT,String ACCESS_KEY,String SECRET_KEY,String BUCKET_NAME){
        try {
            String token = getToken();
            STANDARD_SEAT_URL = STANDARD_SEAT_URL + "?access_token="+token;
            Integer value = 0;
            //for (int i = 0; i < images.size(); i++) {
            Iterator<String> iterator = images.iterator();
            while (iterator.hasNext()){
                String path = iterator.next();//images.get(i);
                InputStream in = getInputStream(path,ENDPOINT,ACCESS_KEY,SECRET_KEY,BUCKET_NAME);
                byte[] fileByte = getFileBytes(in);// 获取图片字节数组
                String base64UrlencodedImg = base64Urlencode(fileByte);// 编码
                String post = getHttpRequestComponent().execute("POST_FOR_URL", STANDARD_SEAT_URL, base64UrlencodedImg);
                JSONObject resultsData = JSONObject.parseObject(post);
                Integer errorCode = resultsData.getInteger("error_code");
                //免费的用完了哦！赶紧去充钱。。。
                if(errorCode!=null){
                    log.error("errorCode===>"+errorCode);
                    if(errorCode==17||errorCode==19){
                        Long expire = getRedisTemplate().getExpire(STANDARD_SEAT, TimeUnit.SECONDS);
                        if (expire != null && expire >0) {
                            getRedisTemplate().opsForValue().set(STANDARD_SEAT,2000,expire,TimeUnit.SECONDS);
                        }
                        //想不到吧！免费的不止一个哟。。。
                        return getFromText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }else if(errorCode==18){
                        //想不到吧！免费的不止一个哟。。。
                        return getFromText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }else if(errorCode==100||errorCode==110||errorCode==111){
                        if (index==3) {
                            return new HashSet<>();
                        }
                        index++;
                        //token失效重新获取token
                        getTokens();
                        return getStandardSeatText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
                    }
                }
                JSONArray wordsResult = resultsData.getJSONArray("words_result");
                if (wordsResult==null) {
                    continue;
                }
                for (int j = 0; j < wordsResult.size(); j++) {
                    JSONObject jsonObject = wordsResult.getJSONObject(j);
                    set.add(jsonObject.getString("words").trim());
                }
                value++;
                iterator.remove();
            }
            Object size = getRedisTemplate().opsForValue().get(STANDARD_SEAT);
            if (size!=null) {
                Integer integer = Integer.valueOf(size.toString());
                Long expire = getRedisTemplate().getExpire(STANDARD_SEAT, TimeUnit.SECONDS);
                if (expire != null && expire >0) {
                    getRedisTemplate().opsForValue().set(STANDARD_SEAT,integer+value,expire,TimeUnit.SECONDS);
                }
            }else{
                getRedisTemplate().opsForValue().set(STANDARD_SEAT,value,30,TimeUnit.DAYS);
            }
            return set;
        }catch (Exception e){
            e.printStackTrace();
            return getFromText(images,ENDPOINT, ACCESS_KEY, SECRET_KEY,BUCKET_NAME);
        }
    }

    //表格
    public static Set<String> getFromText(List<String> images,String ENDPOINT,String ACCESS_KEY,String SECRET_KEY,String BUCKET_NAME){
        try {
            String token = getToken();
            FORM_URL = FORM_URL + "?access_token="+token;
            Integer value = 0;
            for (int i = 0; i < images.size(); i++) {
                String path = images.get(i);
                InputStream in = getInputStream(path,ENDPOINT,ACCESS_KEY,SECRET_KEY,BUCKET_NAME);
                byte[] fileByte = getFileBytes(in);// 获取图片字节数组
                String base64UrlencodedImg = base64Urlencode(fileByte);// 编码
                String post = getHttpRequestComponent().execute("POST_FOR_URL", FORM_URL, base64UrlencodedImg);
                JSONObject resultsData = JSONObject.parseObject(post);
                JSONArray formResult = resultsData.getJSONArray("forms_result");
                if (formResult==null) {
                    continue;
                }
                for (int j = 0; j < formResult.size(); j++) {
                    JSONObject jsonObject = formResult.getJSONObject(j);
                    JSONArray body = jsonObject.getJSONArray("body");
                    for (int y = 0; y < body.size(); y++) {
                        JSONObject words = body.getJSONObject(y);
                        set.add(words.getString("words").trim());
                    }
                    JSONArray footer = jsonObject.getJSONArray("footer");
                    for (int x = 0; x < footer.size(); x++) {
                        JSONObject words = footer.getJSONObject(x);
                        set.add(words.getString("words").trim());
                    }
                }
                value++;
            }
            Object size = getRedisTemplate().opsForValue().get(FORM);
            if (size!=null) {
                Integer integer = Integer.valueOf(size.toString());
                Long expire = getRedisTemplate().getExpire(FORM, TimeUnit.SECONDS);
                if (expire != null && expire > 0) {
                    getRedisTemplate().opsForValue().set(FORM,integer+value,expire,TimeUnit.SECONDS);
                }
            }else{
                getRedisTemplate().opsForValue().set(FORM,value,1,TimeUnit.DAYS);
            }
        }catch (Exception e){
            e.printStackTrace();
        }
        return set;
    }

    /**
     * 图片转字节数组
     * @param
     * @return 图片字节数组
     */
    private static byte[] getFileBytes(InputStream in){
        byte[] buffer = null;
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            byte[] b = new byte[1000];
            int n;
            while ((n = in.read(b)) != -1) {
                bos.write(b, 0, n);
            }
            in.close();
            bos.close();
            buffer = bos.toByteArray();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return buffer;
    }

    /**
     * 对字节数组进行base64编码与url编码
     * @param b
     * @return
     */
    private static String base64Urlencode(byte[] b) {
        byte[] base64Img = Base64.getEncoder().encode(b);
        try {
            String base64UrlencodedImg = URLEncoder.encode(new String(base64Img), "utf-8");
            return base64UrlencodedImg;
        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        }
        return null;
    }


//注意：这里我用的是MinIO附件服务器里拿附件获取文件流，可根据自己的需求来做更改
    private static InputStream getInputStream(String path,String ENDPOINT,String ACCESS_KEY,String SECRET_KEY,String BUCKET_NAME) throws Exception{
        MinioClient minioClient = new MinioClient(ENDPOINT, ACCESS_KEY, SECRET_KEY);
        String[] arr = path.split("/");
        String paths = "";
        for (int i = 4; i < arr.length; i++) {
            paths = paths+"/"+arr[i];
        }
        InputStream in  = minioClient.getObject(BUCKET_NAME, paths);
        return in;
    }
}


package com.lanlinker.cloud.labor.component;

import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpEntity;
import org.apache.http.HttpResponse;
import org.apache.http.HttpStatus;
import org.apache.http.ParseException;
import org.apache.http.client.config.RequestConfig;
import org.apache.http.client.methods.CloseableHttpResponse;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.entity.StringEntity;
import org.apache.http.impl.client.CloseableHttpClient;
import org.apache.http.impl.client.HttpClientBuilder;
import org.apache.http.impl.client.HttpClients;
import org.apache.http.util.EntityUtils;
import org.springframework.stereotype.Component;

import java.io.IOException;


@Slf4j
public class HttpRequestComponent {


    private static final String POST = "POST";

    private static final String POST_FOR_URL = "POST_FOR_URL";

    public String execute(String method, String url, String param) throws Exception {
        switch (method) {
            case POST:
                return post(param, url);
            case POST_FOR_URL:
                return postForUrl(param,url);
            default:
                return null;
        }
    }

    private static String postForUrl(String param,String url){
        String result = "";
        CloseableHttpClient httpClient = HttpClients.createDefault();
        HttpPost httpPost = new HttpPost(url);
        //每个接口的Content-Type可能不同
        httpPost.setHeader("Content-Type", "application/x-www-form-urlencoded;charset=UTF-8");
        try {
            if(param!=null){
                HttpEntity entity = new StringEntity("image=" + param);
                httpPost.setEntity(entity);
            }
            HttpResponse response = httpClient.execute(httpPost);
            result = EntityUtils.toString(response.getEntity());
            return result;
        }catch (Exception e){
            e.printStackTrace();
        }
        return null;
    }

    private String post(String param, String url) throws IOException {
        String entityStr;
        CloseableHttpClient httpClient = HttpClientBuilder.create().build();
        HttpPost httpPost = new HttpPost(url);
        CloseableHttpResponse response = null;
        try {
            httpPost.setHeader("Content-Type", "application/json");
            StringEntity stringEntity = new StringEntity(param, "UTF-8");
            httpPost.setEntity(stringEntity);
            httpPost.setConfig(getConfig());
            response = httpClient.execute(httpPost);
            int statusCode = response.getStatusLine().getStatusCode();
            HttpEntity entity = response.getEntity();
            entityStr = EntityUtils.toString(entity);

            if (statusCode != HttpStatus.SC_OK) {
                log.error("http请求失败, url:{}", url);
            }
            return entityStr;
        } catch (IOException | ParseException e) {
            throw new RuntimeException(e);
        } finally {
            if (httpClient != null) {
                httpClient.close();
            }
            if (response != null) {
                response.close();
            }
            httpPost.abort();
        }
    }

    /**
     * 获取请求配置
     *
     * @return config
     */
    private RequestConfig getConfig() {
        return RequestConfig.custom()
                .setConnectTimeout(60000)
                .setConnectionRequestTimeout(60000)
                .setSocketTimeout(60000).build();
    }

    private String get(String param, String url) {
        return null;
    }
}

F爪哇
关注
专栏目录
免费ocr 吊打百度收费ocr 摄像头直接图片识别文字，本地搭建ocr服务器
jxyk2007的专栏
10-26 1997
摄像头+TrWebOcr-开源的离线ocr，利用一台可以上网的电脑，安装好摄像头，对着内网屏幕，实现数据的统计。项目要求，内网环境，无法统计报表数据，人工每天统计麻烦了。上代码,部分代码来自网络。ocr百度要钱，启用。
百度ocr识别
10-25
依托业界领先的深度学习技术，提供了自然场景下整图文字检测、定位、识别等功能。文字识别的结果可以用于翻译、搜索、TTS等代替用户输入的场景
免费白嫖 OCR 工具(专业版+简易版) 你适合哪个呢？
tuonioooo
10-14 7025
OCR简介   OCR（optical character recognition）文字识别是指电子设备（例如扫描仪或数码相机）检查纸上打印的字符，然后用字符识别方法将形状翻译成计算机文字的过程；即，对文本资料进行扫描，然后对图像文件进行分析处理，获取文字及版面信息的过程。如何除错或利用辅助信息提高识别正确率，是OCR最重要的课题。衡量一个OCR系统性能好坏的主要指标有：拒识率、误识率、识别速度、用户界面的友好性，产品的稳定性，易用性及可行性等。OCR工具解压后，双击运行文件夹
【百度云】免费OCR文字识别第一次使用
03-25 3005
1、如何使用： a:下载api b:多多阅读接口文档 复制接口的代码，直接测试，查看结果
百度OCR代码（百度自己提供）
08-07
百度OCR代码,百度自己提供的范例。C++，供大家参考使用。
使用百度ocr接口
Mr__666的博客
04-01 634
目录前言一、准备工作二、使用步骤总结 前言 由于tesseract难以满足需求，尝试调用百度的api接口。 一、准备工作 只需要使用百度账号创建一个文字识别的应用，获取其API key和Secret key，在程序中调用即可。 二、使用步骤 注意要有一个鉴权的过程，获取到代表有合法性的access token后才能发起请求； 再写提取函数即可： def for_picture(in_path, out_path): url = 'https://aip.baidubce.com/oauth/2.
基于 Go 实现的百度OCR文字识别API
05-28
【作品名称】：基于 Go 实现的百度OCR文字识别API 【适用人群】：适用于希望学习不同技术领域的小白或进阶学习者。可作为毕设项目、课程设计、大作业、工程实训或初期项目立项。 【项目介绍】： 参数说明 //...
videoSubFinder辅助工具_百度ocr
01-13
【视频字幕辅助工具videoSubFinder与百度OCR的结合应用】 在数字媒体处理领域，字幕的自动识别和提取是一项重要的任务，特别是在处理大量视频内容时。videoSubFinder是一款专门用于辅助查找和提取视频字幕的工具，...
百度OCR-身份证图片识别源码
09-21
本篇将深入探讨“百度OCR-身份证图片识别源码”这一技术主题，它主要涉及百度OCR技术以及如何利用其进行身份证信息的自动识别。身份证识别在现代社会有着广泛的应用，例如线上实名认证、金融业务办理等，极大地提高...
百度OCR高精度文字识别利用php进行对接图片转换文字在线识别文字
08-26
百度OCR是百度公司提供的一个高精度的文字识别服务，它允许开发者通过API接口来实现图像中的文字识别功能。在本项目中，我们将探讨如何使用PHP语言对接百度OCR服务，实现在线文字识别和图片转文字的功能。 首先，...
百度OCR+翻译
10-25
支持更换百度api密钥 里面内附一个 调用的百度免费的OCR文字提取 +每月免费字符翻译<200万的免费接口
OCR.rar_c#程序_百度 OCR_百度AI_百度OCR_百度图像识别
09-21
总的来说，"OCR.rar_c#程序_百度 OCR_百度AI_百度OCR_百度图像识别"项目展示了如何结合C#和百度OCR API，实现高效、准确的图像文本识别功能。这不仅可以帮助开发者快速创建自己的文本识别应用，也能让他们了解和掌握...
百度OCR接口使用（java）
晴天小风的博客
03-12 2337
百度OCR文字识别接口使用代码：（需要新建百度的文字识别应用，每天免费使用50000次）【参考于官网文档】 1.通过网络图片地址进行解析获取文字 /** * 通过图片url获取解析的文字 * @param imgUrl * @return */ public static String getImgContent(String img...
Python配置免费的OCR识别(OCRSpace)每月25000次(保姆级教学)
weixin_42636075的博客
03-23 2114
Python配置免费的OCR识别(OCRSpace)每日25000次(保姆级教学) 免费的OCR识别 python配置免费的OCR识别
百度免费ocr和阿里付费的使用方法
weixin_45493422的博客
10-09 4804
因为以前公司有这个需求所以我有去了解实现这个功能 ocr即：图片文字识别功能。就是读取图片上的文件信息，展示出来。一开始为成本考虑我想自己实现这个功能。于是查阅资料整理dome，基于roc语言库，真就让我写了一个文字识别功能出来。但是效果就一言难尽了。总的来说就是只有正面的，图像清晰的图片才能识别出去除了格式的文字信息出来。自己用一用还行，但是想要用到产品上进行商用还行洗洗睡吧。 自己的不行，就用别人的。一番查找对比以后最终有两家平台可以使用（基于效果和成本考虑），一家是百度一家是阿里。如果减低要求使用，百
按键精灵使用百度文字识别（百度ocr）教程
热门推荐
sinat_22215253的博客
06-27 1万+
按键精灵通过实践，也可以接入百度的OCR，百度OCR免费额度为，每日50000次普通调用，对于日常应用已经足够，返回识别内容时间在1s以内（免费版有一秒内请求次数限制，不充钱也无法达到更短的时间）。 第一步：申请百度OCR服务 这一步非常简单，进入https://login.bce.baidu.com/，登入百度账号后，在产品应用里面选择文字识别服务 进入后，选择创建应用，相关参数选择默认的即可，最后会得到自己的APIKey 和SecretKey，这两个参数十分重要，把它们复制下来保存起来。 ..
文字识别云服务使用记录
sd2131512的专栏
01-07 862
最近，在做完OpenHarmony 3516开发板拍照的功能以后，下一步就需要研究一下目前又哪些AI云服务可用，可以实现从图片中识别文字，于是做了如下记录： 华为云: 文字识别服务的产品介绍：图解文字识别_文字识别 OCR_产品介绍_华为云 目前开通了一个一年的试用，每天有500次的免费调用。 尝试使用了通用文字识别，手写文字识别。试用方式：首先先在在线体验模拟调用https://apiexplorer.developer.huaweicloud.com/apiexplorer/sdk?prod
免费的图片识别接口，百度ocr的SDK使用java版
浪丶荡
04-09 2434
申请使用，个人完成认证可获得一定的免费使用场景，用来测试或者简单的场景足够了 百度智能云-登录https://console.bce.baidu.com/ai/?_=1649487753967&fromai=1#/ai/ocr/overview/index 创建应用，获得APP_ID、API_KEY和SECRET_KEY 参考文档进行测试 https://ai.baidu.com/ai-doc/OCR/Ikibizxqlhttps://ai.baidu.com/ai-d...
百度世界大会2024，当应用遇上AI，未来已来
最新发布
悟空码字的博客
11-13 934
科技更应该服务生活，期待AI技术在更多领域的应用和突破。无论是工作、生活还是娱乐，AI都将为我们带来更加便捷、高效和有趣的体验。
PHP调用百度OCR接口实现图片文字识别
- 百度OCR是一项基于人工智能技术的服务，能够自动识别图片中的文字，支持多种语言和场景，例如通用文字识别、身份证识别、名片识别等。 - 官方文档地址：https://ai.baidu.com/docs#/OCR-API-GeneralBasic/top，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值