腾讯API调用（以文字识别OCR为例）

最新推荐文章于 2024-05-11 17:28:42 发布
最新推荐文章于 2024-05-11 17:28:42 发布
阅读量1.8k 收藏 1
点赞数
文章标签： java 开发语言 腾讯云
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/feng_xiaofeng/article/details/128691933
版权

OcrDemo.java

腾讯API调用通过工具类，只要修改相应的参数即可。

public class OcrDemo {
    
    public static void main(String[] args) throws TencentCloudSDKException {

        //以文字识别为例
        String base64 = imgToBase64("https://xxxx.png");

        //修改Action,verstion等参数，这个接口是通用的
        JSONObject requestParams = new JSONObject();
        requestParams.put("RequestMethod", "POST");
        requestParams.put("Nonce", new Random().nextInt(java.lang.Integer.MAX_VALUE));
        requestParams.put("Timestamp", System.currentTimeMillis() / 1000);
        requestParams.put("Action", "GeneralBasicOCR");
        requestParams.put("Version", "2018-11-19");
        requestParams.put("Region", "ap-guangzhou");
        requestParams.put("ImageBase64", base64);
        TencentUtil tencentUtil = new TencentUtil();
        String result = tencentUtil.callTencentApi("ocr","GeneralBasicOCR",
                "ocr.tencentcloudapi.com","/","填入你的appid",
                "填入你的secret",
                requestParams);
        JSONObject jsonObject = JSONObject.parseObject(result);
        System.out.println(jsonObject.toJSONString());
    }

    /**
     * 服务器图片转换base64 path：服务器图片路径  返回 base64编码（String 类型）
     * @param path
     * @return
     */
    public static String imgToBase64(String path){
        byte[] data = null;
        InputStream in = null;
        ByteArrayOutputStream out = null;
        try{
            URL url = new URL(path);
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("GET");
            connection.setConnectTimeout(5000);
            connection.setReadTimeout(5000);
            in = connection.getInputStream();
            out = new ByteArrayOutputStream();
            byte[] b = new byte[1024];
            int len = 0;
            while((len =in.read(b)) != -1){
                out.write(b,0,len);
            }
        }catch (Exception e){
            e.printStackTrace();
        }finally {
            try{
                if(in != null ){
                    in.close();
                }
            }catch (IOException e){
                e.getStackTrace();
            }
        }
        System.out.println("转换后的图片大小："+out.toByteArray().length/1024);
        BASE64Encoder base = new BASE64Encoder();
        return base.encode(out.toByteArray());
    }

}
TencentUtil.java
@Component
public class TencentUtil {

    public String callTencentApi(String productCode, String action, String productDomain, String productDomainSuffix, String secretId, String secretKey, JSONObject requestParams) throws TencentCloudSDKException {
        String result = "";
        String url = "https://"+productDomain+productDomainSuffix;
        TreeMap<String, Object> treeMap = new TreeMap<>();
        treeMap.putAll(requestParams);
        String requestMethod = "";
        if(treeMap.get("RequestMethod")==null) {
            requestMethod = "GET";
        } else {
            requestMethod = treeMap.get("RequestMethod").toString();
        }
        if(StringUtils.isBlank(requestMethod)){
            requestMethod = "GET";
        }
        if (treeMap.containsKey("RequestMethod")) {
            treeMap.remove("RequestMethod");
        }
        if (!treeMap.containsKey("SecretId")) {
            treeMap.put("SecretId", secretId);
        }
        if (!treeMap.containsKey("Action")) {
            treeMap.put("Action", action);
        }
        if (!treeMap.containsKey("Nonce")) {
            treeMap.put("Nonce", new Random().nextInt(Integer.MAX_VALUE));
        }
        if (!treeMap.containsKey("Timestamp")) {
            treeMap.put("Timestamp", System.currentTimeMillis() / 1000L);
        }
        if("GET".equalsIgnoreCase(requestMethod)){
            //计算v1签名
            String signatureMethod = "HmacSHA1";
            if (treeMap.containsKey("SignatureMethod") && treeMap.get("SignatureMethod").toString().equals("HmacSHA256")) {
                signatureMethod = "HmacSHA256";
            }
            String plainText = Sign.makeSignPlainText(treeMap,"GET",productDomain,productDomainSuffix);
            try {
                treeMap.put("Signature", Sign.sign(plainText, secretKey, signatureMethod));
            } catch (NoSuchAlgorithmException e) {
                e.printStackTrace();
            } catch (InvalidKeyException e) {
                e.printStackTrace();
            }
            //调用腾讯接口
            result = sendTencentGet(url,treeMap,requestMethod);
        }else {
            //计算v3签名
            result = sendTencentPost(url,treeMap,requestMethod,productCode,productDomain,secretId,secretKey);
        }
        return result;
    }

    public static String sendTencentPost(String url, TreeMap<String, Object> requestParams,String requestMethod,String service,String host,String secretId,String secretKey) {
        String action = requestParams.get("Action").toString();
        String version = requestParams.get("Version").toString();
        String region = requestParams.get("Region").toString();
        String algorithm = "TC3-HMAC-SHA256";
        String timestamp = String.valueOf(System.currentTimeMillis() / 1000);
        SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd");
        // 注意时区，否则容易出错
        sdf.setTimeZone(TimeZone.getTimeZone("UTC"));
        String date = sdf.format(new Date(Long.valueOf(timestamp + "000")));
        // ************* 步骤 1：拼接规范请求串 *************
        String httpRequestMethod = "POST";
        String canonicalUri = "/";
        String canonicalQueryString = "";
        String canonicalHeaders = "content-type:application/json; charset=utf-8\n" + "host:" + host + "\n";
        String signedHeaders = "content-type;host";
        String payload = getBodyString(requestParams);
        String hashedRequestPayload = sha256Hex(payload);
        String canonicalRequest = httpRequestMethod + "\n" + canonicalUri + "\n" + canonicalQueryString + "\n"
                + canonicalHeaders + "\n" + signedHeaders + "\n" + hashedRequestPayload;

        // ************* 步骤 2：拼接待签名字符串 *************
        String credentialScope = date + "/" + service + "/" + "tc3_request";
        String hashedCanonicalRequest = sha256Hex(canonicalRequest);
        String stringToSign = algorithm + "\n" + timestamp + "\n" + credentialScope + "\n" + hashedCanonicalRequest;

        // ************* 步骤 3：计算签名 *************
        byte[] secretDate = hmac256(("TC3" + secretKey).getBytes(StandardCharsets.UTF_8), date);
        byte[] secretService = hmac256(secretDate, service);
        byte[] secretSigning = hmac256(secretService, "tc3_request");
        String signature = DatatypeConverter.printHexBinary(hmac256(secretSigning, stringToSign)).toLowerCase();

        // ************* 步骤 4：拼接 Authorization *************
        String authorization = algorithm + " " + "Credential=" + secretId + "/" + credentialScope + ", "
                + "SignedHeaders=" + signedHeaders + ", " + "Signature=" + signature;
        //调用腾讯接口
        StringBuffer stringBuffer =new StringBuffer();
        BufferedReader responseReader = null;
        InputStream in1 = null;
        // 创建url资源
        try {
            URL urlClient = new URL(url);
            // 建立http连接
            HttpsURLConnection conn = (HttpsURLConnection) urlClient.openConnection();
            // 设置不用缓存
            conn.setUseCaches(false);
            // 设置允许输出
            conn.setDoOutput(true);
            // 设置允许输入
            conn.setDoInput(true);
            conn.setInstanceFollowRedirects(true);
            // 设置传递方式
            conn.setRequestMethod(requestMethod);
            // 设置维持长连接
            conn.setRequestProperty("Connection", "Keep-Alive");
            // 设置文件字符集:
            conn.setRequestProperty("Charset", "UTF-8");
            // 设置文件类型:
            conn.setRequestProperty("Content-Type", "application/json; charset=utf-8");
            conn.setRequestProperty("Authorization", authorization);
            conn.setRequestProperty("Host", host);
            conn.setRequestProperty("X-TC-Action", action);
            conn.setRequestProperty("X-TC-Timestamp", timestamp);
            conn.setRequestProperty("X-TC-Version", version);
            conn.setRequestProperty("X-TC-Region", region);
            // 开始连接请求
            conn.connect();
            //一定要用BufferedReader 来接收响应， 使用字节来接收响应的方法是接收不到内容的
            // utf-8编码
            OutputStreamWriter out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
            out.append(payload);
            out.flush();
            out.close();
            // 请求返回的状态
            if (HttpURLConnection.HTTP_OK == conn.getResponseCode()) {
                System.out.println("连接成功");
                // 请求返回的数据
                in1 = conn.getInputStream();
                String readLine;
                responseReader = new BufferedReader(new InputStreamReader(in1,"UTF-8"));
                while((readLine=responseReader.readLine()) != null){
                    stringBuffer.append(readLine);
                }
            } else {
                System.out.println("error++");
            }
        } catch (MalformedURLException e) {
            e.printStackTrace();
        }catch (IOException e) {
            e.printStackTrace();
        }finally {
            try{
                if (null != responseReader){
                    responseReader.close();
                }
                if (null != in1){
                    in1.close();
                }
            }catch (IOException e){}
        }
        return stringBuffer.toString();
    }
        /**
         * 请求腾讯API
         * @param requestParams
         * @param requestMethod
         * @return
         */
    public static String sendTencentGet(String url, TreeMap<String, Object> requestParams,String requestMethod){
        final long t = System.currentTimeMillis();
        String result = "";
        BufferedReader in = null;
        String paramStr = "";
        final JSONObject log_info = new JSONObject();
        for (final String key : requestParams.keySet()) {
            if (!paramStr.isEmpty()) {
                paramStr += '&';
            }
            try {
                paramStr = paramStr + key + '=' + URLEncoder.encode(requestParams.get(key).toString(), "utf-8");
            } catch (UnsupportedEncodingException e) {
                result = "{\"code\":-2300,\"location\":\"com.qcloud.Common.Request:129\",\"message\":\"api sdk throw exception! "
                        + e.toString() + "\"}";
            } catch (NullPointerException ex) {
                out.println("NLL>>" + key);
            }
        }
        try {
            if (requestMethod.equals("GET")) {
                if (url.indexOf(63) > 0) {
                    url = url + '&' + paramStr;
                } else {
                    url = url + '?' + paramStr;
                }
            }
            log_info.fluentPut("param", requestParams).fluentPut("url", url);
            final String BOUNDARY = "---------------------------"
                    + MD5.stringToMD5(String.valueOf(System.currentTimeMillis())).substring(0, 15);
            final URL realUrl = new URL(url);
            URLConnection connection = null;
            if (url.toLowerCase().startsWith("https")) {
                final HttpsURLConnection httpsConn = (HttpsURLConnection) (connection = realUrl.openConnection());
            } else {
                connection = realUrl.openConnection();
            }
            connection.setRequestProperty("accept", "*/*");
            connection.setRequestProperty("connection", "Keep-Alive");
            connection.setRequestProperty("user-agent", "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
            connection.setConnectTimeout(1000);
            connection.connect();
            in = new BufferedReader(new InputStreamReader(connection.getInputStream(), "UTF-8"));
            String line;
            while ((line = in.readLine()) != null) {
                result += line;
            }
        } catch (Exception e2) {
            result = "{\"code\":-2700,\"location\":\"com.qcloud.Common.Request:225\",\"message\":\"api sdk throw exception! "
                    + e2.toString() + "\"}";
            try {
                if (in != null) {
                    in.close();
                }
            } catch (Exception e3) {
                result = "{\"code\":-2800,\"location\":\"com.qcloud.Common.Request:234\",\"message\":\"api sdk throw exception! "
                        + e3.toString() + "\"}";
            }
        } finally {
            try {
                if (in != null) {
                    in.close();
                }
            } catch (Exception e4) {
                result = "{\"code\":-2800,\"location\":\"com.qcloud.Common.Request:234\",\"message\":\"api sdk throw exception! "
                        + e4.toString() + "\"}";
            }
        }
        log_info.fluentPut("resp", JSON.parse(result)).fluentPut("spk", (System.currentTimeMillis() - t));
        System.out.println(log_info.toJSONString());
        return result;
    }

    public static String getBodyString(TreeMap<String, Object> requestParams){
        if (requestParams.containsKey("Action")) {
            requestParams.remove("Action");
        }
        if (requestParams.containsKey("Timestamp")) {
            requestParams.remove("Timestamp");
        }
        if (requestParams.containsKey("Version")) {
            requestParams.remove("Version");
        }
        if (requestParams.containsKey("Region")) {
            requestParams.remove("Region");
        }
        if (requestParams.containsKey("Nonce")) {
            requestParams.remove("Nonce");
        }
        if (requestParams.containsKey("SecretId")) {
            requestParams.remove("SecretId");
        }
        JSONObject jsonObject = new JSONObject(requestParams);
        return jsonObject.toJSONString();
    }
    public static String sha256Hex(String s) {
        MessageDigest md = null;
        try {
            md = MessageDigest.getInstance("SHA-256");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        byte[] d = md.digest(s.getBytes(StandardCharsets.UTF_8));
        return DatatypeConverter.printHexBinary(d).toLowerCase();
    }

    public static byte[] hmac256(byte[] key, String msg)  {
        Mac mac = null;
        try {
            mac = Mac.getInstance("HmacSHA256");
        } catch (NoSuchAlgorithmException e) {
            e.printStackTrace();
        }
        SecretKeySpec secretKeySpec = new SecretKeySpec(key, mac.getAlgorithm());
        try {
            mac.init(secretKeySpec);
        } catch (InvalidKeyException e) {
            e.printStackTrace();
        }
        return mac.doFinal(msg.getBytes(StandardCharsets.UTF_8));
    }


}

Base64.java
import java.io.UnsupportedEncodingException;
import java.nio.charset.StandardCharsets;

public class Base64 {
	private static final char[] base64EncodeChars;
	private static final byte[] base64DecodeChars;

	public static String encode(final byte[] data) {
		final StringBuilder sb = new StringBuilder();
		final int len = data.length;
		int i = 0;
		while (i < len) {
			final int b1 = data[i++] & 0xFF;
			if (i == len) {
				sb.append(Base64.base64EncodeChars[b1 >>> 2]);
				sb.append(Base64.base64EncodeChars[(b1 & 0x3) << 4]);
				sb.append("==");
				break;
			}
			final int b2 = data[i++] & 0xFF;
			if (i == len) {
				sb.append(Base64.base64EncodeChars[b1 >>> 2]);
				sb.append(Base64.base64EncodeChars[(b1 & 0x3) << 4 | (b2 & 0xF0) >>> 4]);
				sb.append(Base64.base64EncodeChars[(b2 & 0xF) << 2]);
				sb.append("=");
				break;
			}
			final int b3 = data[i++] & 0xFF;
			sb.append(Base64.base64EncodeChars[b1 >>> 2]);
			sb.append(Base64.base64EncodeChars[(b1 & 0x3) << 4 | (b2 & 0xF0) >>> 4]);
			sb.append(Base64.base64EncodeChars[(b2 & 0xF) << 2 | (b3 & 0xC0) >>> 6]);
			sb.append(Base64.base64EncodeChars[b3 & 0x3F]);
		}
		return sb.toString();
	}

	public static byte[] decode(final String str) throws UnsupportedEncodingException {
		final StringBuilder sb = new StringBuilder();
		final byte[] data = str.getBytes(StandardCharsets.US_ASCII);
		final int len = data.length;
		int i = 0;
		while (i < len) {
			int b1;
			do {
				b1 = Base64.base64DecodeChars[data[i++]];
			} while (i < len && b1 == -1);
			if (b1 == -1) {
				break;
			}
			int b2;
			do {
				b2 = Base64.base64DecodeChars[data[i++]];
			} while (i < len && b2 == -1);
			if (b2 == -1) {
				break;
			}
			sb.append((char) (b1 << 2 | (b2 & 0x30) >>> 4));
			int b3;
			do {
				b3 = data[i++];
				if (b3 == 61) {
					return sb.toString().getBytes(StandardCharsets.ISO_8859_1);
				}
				b3 = Base64.base64DecodeChars[b3];
			} while (i < len && b3 == -1);
			if (b3 == -1) {
				break;
			}
			sb.append((char) ((b2 & 0xF) << 4 | (b3 & 0x3C) >>> 2));
			int b4;
			do {
				b4 = data[i++];
				if (b4 == 61) {
					return sb.toString().getBytes(StandardCharsets.ISO_8859_1);
				}
				b4 = Base64.base64DecodeChars[b4];
			} while (i < len && b4 == -1);
			if (b4 == -1) {
				break;
			}
			sb.append((char) ((b3 & 0x3) << 6 | b4));
		}
		return sb.toString().getBytes(StandardCharsets.ISO_8859_1);
	}

	static {
		base64EncodeChars = new char[] { 'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
				'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k',
				'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5',
				'6', '7', '8', '9', '+', '/' };
		base64DecodeChars = new byte[] { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
				-1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 62, -1, -1,
				-1, 63, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, -1, -1, -1, -1, -1, -1, -1, 0, 1, 2, 3, 4, 5, 6, 7, 8,
				9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, -1, -1, -1, -1, -1, -1, 26, 27, 28,
				29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, -1, -1, -1,
				-1, -1 };
	}
}

MD5.java
import lombok.extern.slf4j.Slf4j;

import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;

@Slf4j
public class MD5 {
	public static String stringToMD5(final String str) {
		try {
			final byte[] strTemp = str.getBytes();
			final MessageDigest mdTemp = MessageDigest.getInstance("MD5");
			mdTemp.update(strTemp);
			return toHexString(mdTemp.digest());
		} catch (Exception e) {
			return null;
		}
	}

	public static String fileNameToMD5(final String fileName) {
		InputStream inputStream = null;
		try {
			inputStream = new FileInputStream(fileName);
			return streamToMD5(inputStream);
		} catch (Exception e2) {
			return null;
		} finally {
			if (inputStream != null) {
				try {
					inputStream.close();
				} catch (IOException e) {
					log.error(e.getMessage(),e);
				}
			}
		}
	}

	public static String streamToMD5(final InputStream inputStream) {
		try {
			final MessageDigest mdTemp = MessageDigest.getInstance("MD5");
			final byte[] buffer = new byte[1024];
			int numRead = 0;
			while ((numRead = inputStream.read(buffer)) > 0) {
				mdTemp.update(buffer, 0, numRead);
			}
			return toHexString(mdTemp.digest());
		} catch (Exception e) {
			return null;
		}
	}

	private static String toHexString(final byte[] md) {
		final char[] hexDigits = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
		final int j = md.length;
		final char[] str = new char[j * 2];
		for (int i = 0; i < j; ++i) {
			final byte byte0 = md[i];
			str[2 * i] = hexDigits[byte0 >>> 4 & 0xF];
			str[i * 2 + 1] = hexDigits[byte0 & 0xF];
		}
		return new String(str);
	}
}

Sign.java

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.util.TreeMap;

public class Sign {

	public static String sign(final String signStr, final String secret, final String signatureMethod)
			throws NoSuchAlgorithmException, InvalidKeyException {
		final Mac mac1 = Mac.getInstance("HmacSHA1");
		final Mac mac2 = Mac.getInstance("HmacSHA256");
		byte[] hash;
		if (signatureMethod.equals("HmacSHA256")) {
			final SecretKeySpec secretKey = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8),
					mac2.getAlgorithm());
			mac2.init(secretKey);
			hash = mac2.doFinal(signStr.getBytes(StandardCharsets.UTF_8));
		} else {
			final SecretKeySpec secretKey = new SecretKeySpec(secret.getBytes(StandardCharsets.UTF_8),
					mac1.getAlgorithm());
			mac1.init(secretKey);
			hash = mac1.doFinal(signStr.getBytes(StandardCharsets.UTF_8));
		}
		final String sig = Base64.encode(hash);
		return sig;
	}

	public static String makeSignPlainText(final TreeMap<String, Object> requestParams, final String requestMethod,
			final String productDomain,final String productDomainSuffix) {
		String retStr = "";
		retStr += requestMethod;
		retStr += productDomain;
		retStr += productDomainSuffix;
		retStr += buildParamStr(requestParams, requestMethod);
		return retStr;
	}


	protected static String buildParamStr(final TreeMap<String, Object> requestParams, final String requestMethod) {
		String retStr = "";
		for (final String key : requestParams.keySet()) {
			if(requestParams.get(key)==null) {
				continue;
			}
			final String xx = requestParams.get(key).toString();
			if ("POST".equals(requestMethod) && !xx.isEmpty() && xx.substring(0, 1).equals("@")) {
				continue;
			}
			if (retStr.length() == 0) {
				retStr += '?';
			} else {
				retStr += '&';
			}
			if (requestParams.get(key) == null) {
				retStr = retStr + key.replace("_", ".") + '=';
			} else {
				retStr = retStr + key.replace("_", ".") + '=' + requestParams.get(key).toString();
			}
		}
		return retStr;
	}
}

冯晓锋
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
腾讯云OCR简介和使用流程
tiancaijiben的博客
06-07 3029
腾讯云OCR（Optical Character Recognition）是一款基于腾讯云计算能力和深度学习技术，提供高精度、高效率、易集成的文字识别服务。支持多种类型的识别，包括身份证、银行卡、驾驶证、行驶证、车牌号、通用印刷体、手写体等。在人工智能、金融、教育、物流、医疗等行业中广泛应用，帮助用户快速、准确地完成数据录入、识别、处理和管理。
腾讯（表格OCR）API调用流程
weixin_48568323的博客
10-24 1948
腾讯（表格OCR）API调用流程
基于腾讯云ocr识别接口，提取图片自定义文字功能
最新发布
f374157531的博客
05-11 1180
实现对图片识别后自定义识别字段(key)，并获取对应的字段值(value)的整套功能。基于腾讯表格识别（V3）返回的数据中提取对应的识别字段。
腾讯云OCR（印刷体识别） API使用
braxuyu4的博客
11-28 922
腾讯云OCR（印刷体识别） API使用
python3识别图中的文字_Python3使用腾讯云文字识别(腾讯OCR)提取图片中的文字内容实例详解...
weixin_39784774的博客
11-28 349
百度OCR体验地址：腾讯OCR体验地址：测试结果是：腾讯的效果要比百度的好腾讯云目前额度是：每个接口 1,000次/月免费，有6个文字识别的接口，一共是6,000次/月百度接口调用之前写过文章使用步骤1、注册账号： https://cloud.tencent.com/2、开通服务：https://console.cloud.tencent.com/ocr/general3、申请访问秘钥：https...
分享一个免费的OCR图片文字识别接口
python_mopagunda的博客
01-30 4689
分享一个每天100次免费的OCR图片文字识别接口
分享几种常见的OCR图形识别API接口
tanshuapi的博客
01-26 1440
对机动车行驶证主页及副页进行结构化识别，包括号牌号码、车辆类型、所有人、品牌型号、车辆识别代码、发动机号码、核定载人数、质量、尺寸、检验记录等。2、调用响应的API接口，目前测试的是vin识别。把base64传入接口即可。自动提取及快速识别出图像中文字内容，适用于多场景图像文字识别。识别出该卡的银行卡号、所属银行、卡片类型以及银行邮编等信息。支持对车辆挡风玻璃处和行驶证车架号码进行识别。1、首先把准备好的图片转成base64格式。识别及提取身份证正反面所有字段信息。以vin识别为示例教程。
Python3使用腾讯云文字识别(腾讯OCR)提取图片中的文字内容实例详解
01-20
每个接口 1,000次/月免费，有6个文字识别的接口，一共是6,000次/月 百度接口调用之前写过文章 python实现百度OCR图片识别过程解析 使用步骤 1、注册账号： https://cloud.tencent.com/ 2、开通服务：...
VB.NET实现腾讯AI通用文字识别Ocr&TTS;
12-18
【VB.NET实现腾讯AI通用文字识别Ocr&TTS】是一个基于Visual Basic .NET的项目，主要功能是利用腾讯AI的API进行文字识别（OCR）和文本到语音转换（TTS）。这个项目对于开发者来说，是一个很好的实践案例，可以帮助...
OCR卡证文字识别
01-20
使用API为：腾讯云OCR识别API。主要用于识别身份证、银行卡、行驶证等证件信息。 接口支持两种方式识别，分别为：证件图片的在线外网路径、证件图片的base64码 支持在线调用测试 前置条件 使用者需要有账号密码和...
OCR:腾讯云OCR文字识别
05-16
在提供的`OCR-master`压缩包中，我们可以预见到包含的源代码是用PHP编程语言编写的，这使得开发者能够在PHP环境中调用腾讯云OCR API进行文字识别操作。PHP是一种广泛使用的服务器端脚本语言，尤其适合Web开发，因此...
基于腾讯云ocr识别接口做的识别工具（自动识别图片、证件、车牌、身份证等）
04-17
自动识别图片的文字内容、证件、车牌、身份证等 能直接对获取到的信息进行相关处理，直接调用就行。 使用的是java
tencentcloud-uniapp-plugin-ocr:【uni-app】腾讯云文字识别（OCR）插件
05-25
插件介绍标题名称中文名称腾讯云文字识别（OCR）插件英文名称tencentcloud-plugin-ocr最新版本v1.0.2 (2021.01.26)适用平台适用产品GitHub项目主创团队腾讯云中小企业产品中心（SMB Product Center of Tencent ...
利用百度api实现ocr识别发票
weixin_44219955的博客
06-13 1788
1、百度智能云申请一个文字识别的api里面每个月有1000次调用测试应该够用2、一个springboot项目。
利用腾讯云api实现手写字体识别
qq_38120778的博客
06-05 1109
文字识别
Python调用腾讯优图OCR通用API实现文字识别
Loong的博客
04-12 5991
API地址：https://ai.qq.com/doc/ocrgeneralocr.shtml 腾讯优图的API比较复杂的就是生成签名，不过不知道腾讯的服务器出什么问题了，调用的时候一直提示504，演示页面也是无法识别图片了。 # !/user/bin/env Python3 # -*- coding:utf-8 -*- """ file：qq_api.py create time:201...
腾讯云 接口验签 使用qcloud-java-sdk
xuzhicheng2014的博客
01-08 2388
腾讯云的接口鉴权java 的这边有两种方式： 1，对接口参数我们自己进行字典排序，然后使用 HMACSHA1进行加密，再者用base64生成签名signature； 这边以发起视频加密转码action = ProcessFile 接口为例子说明： /** * 点播服务id */ private static final String SECRET_ID = "...
使用腾讯优图SDK，实现人脸识别、身份证OCR识别
热门推荐
郭成的博客
06-05 1万+
由于公司业务需要对接身份证识别信息，然后在网上找了好久，发现云脉做OCR在国内做的还不错，但是由于是收费的，只能放弃。最后是找到了腾讯优图，目前的腾讯优图使用是免费的，也没有使用触发限制。   腾讯优图身份证识别主要是把图片上传云端，然后云端处理完结果，返回给我们处理完的结果。 腾讯优图SDK接入网址 http://open.youtu.qq.com/ 身份证OCRAPI文档 http:/...
php图像识别api,使用腾讯AI开放平台api进行图片OCR文字识别
weixin_28879085的博客
03-12 953
重要：本文最后更新于2019-05-20 08:46:46，某些文章具有时效性，若有错误或已失效，请在下方留言或联系代码狗。其实图片的文字识别其实还算简单，一般是根据特定字体制作出字码文件，然后分割图片比对字码，这种方式在易语言中比较常见，一般用来做游戏脚本。OpenCV也提供了OCR文字识别函数，并且还是跨平台的，不过一般人很少用。使用腾讯AI开放平台api进行图片OCR文字识别可以在不了解OC...
使用腾讯OCR进行文字识别
05-24
好的，使用腾讯OCR进行文字识别需要以下步骤： 1. 注册并登录腾讯云账号，在控制台中开通腾讯OCR服务，获取API密钥。 2. 在代码中引入腾讯OCR SDK，并使用API密钥进行身份验证。 3. 准备要识别的图片，并将其转换为Base64格式。 4. 调用腾讯OCR的API，传入图片数据并设置识别类型（如通用文字识别、身份证识别等）。 5. 解析API返回的识别结果，获取识别出的文字内容。 以下是一个Python示例代码，用于使用腾讯OCR进行通用文字识别： ``` import base64 import json import requests # 设置密钥和API地址 app_id = "your_app_id" app_key = "your_app_key" api_url = "https://recognition.image.myqcloud.com/ocr/general" # 准备图片数据 with open('image.jpg', 'rb') as f: image_data = f.read() image_base64 = str(base64.b64encode(image_data), 'utf-8') # 构造请求参数 params = { "appid": app_id, "image": image_base64, "nonce_str": "random_string", "time_stamp": str(int(time.time())), } # 生成签名 sign_str = "&".join([f"{key}={params[key]}" for key in sorted(params.keys())]) sign_str += f"&appkey={app_key}" sign = hashlib.md5(sign_str.encode('utf-8')).hexdigest().upper() # 发送POST请求 headers = {'Content-Type': 'application/json'} data = { "appid": app_id, "image": image_base64, "nonce_str": "random_string", "time_stamp": str(int(time.time())), "sign": sign, } response = requests.post(api_url, headers=headers, data=json.dumps(data)) # 解析结果 result = json.loads(response.text) if result.get("code") == 0: words_list = result.get("data").get("item_list") for words in words_list: print(words.get("itemstring")) else: print(result.get("message")) ``` 需要注意的是，使用腾讯OCR服务需要收取一定的费用，具体费用标准可以在腾讯云控制台中查看。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值