information community file
Technical capability
Voice technology
Character recognition
Face and Human Body
Image technology
Language and knowledge
video technique

Reading identification of instrument panel

Interface description

It is suitable for reading recognition of instrument panels of different brands and models, widely applicable to all kinds of blood glucose meters, blood pressure meters, gas meters, electricity meters, etc. It can recognize numbers, English, symbols on the dial, and support LCD, word wheel meters and other phenotypes.

Online debugging

You can visit Sample Code Center Debug the interface in , you can perform signature verification, view the request content and return results of online calls, and automatically generate sample code.

Request Description

Request Example

HTTP method: POST

Request URL: https://aip.baidubce.com/rest/2.0/ocr/v1/meter

URL parameter:

parameter value
access_token Access_token obtained through API Key and Secret Key, refer to“ Access Token acquisition

The headers are as follows:

parameter value
Content-Type application/x-www-form-urlencoded

Place the request parameters in the body. The details of the parameters are as follows:

Request Parameters

parameter Required type Optional value range explain
image Or url string - Image data, Urlencode is performed after base64 encoding. The size after base64 encoding and urlencode is required to be no more than 4M. The shortest side should be at least 15px, and the longest side should be at most 4096px. Support jpg/jpeg/png/bmp format Note: The base64 encoding of the image does not include the image header, such as (data: image/jpg; base64,)
url And image string - Picture full URL, The URL length does not exceed 1024 bytes, The base64 encoded image corresponding to the URL is no more than 4M in size, the shortest side is at least 15px, and the longest side is at most 4096px. It supports the jpg/jpeg/png/bmp format. When the image field exists, the url field is invalid
Please close the URL anti-theft chain
probability no string true/false Whether to return the confidence level of recognition results of each line. Default is false
poly_location no string true/false Location information return form, default: false
False: only the rectangular position information of the recognition result is given
True: In addition to the default position information of the rectangle where the text is located, the coordinate information of the four points of the smallest circumscribed rotation rectangle in the area where the text is located will also be given

Request Code Example

Prompt 1 : Before using the sample code, remember to replace the sample token, image address or Base64 information.

Prompt 2 : Some languages depend on classes or libraries. Please check the download address in the code comment.

 #Reading identification of instrument panel
 curl -i -k ' https://aip.baidubce.com/rest/2.0/ocr/v1/meter?access_token= [Call the token obtained from the authentication interface] ' --data 'image=[Picture Base64 encoding, UrlEncode required]' -H 'Content-Type:application/x-www-form-urlencoded'
 # encoding:utf-8

 import requests import base64 ''' Reading identification of instrument panel ''' request_url =  " https://aip.baidubce.com/rest/2.0/ocr/v1/meter "
 #Open picture file in binary mode f =  open ( '[Local file]' ,  'rb' ) img = base64 . b64encode ( f . read ( ) ) params =  { "image" : img } access_token =  '[Token obtained by calling the authentication interface]' request_url = request_url +  "? access_token="  + access_token headers =  { 'content-type' :  'application/x-www-form-urlencoded' } response = requests . post ( request_url , data = params , headers = headers )
 if response :
     print  ( response . json ( ) )
 package  com . baidu . ai . aip ;

 import  com . baidu . ai . aip . utils . Base64Util ;
 import  com . baidu . ai . aip . utils . FileUtil ;
 import  com . baidu . ai . aip . utils . HttpUtil ;

 import  java . net . URLEncoder ;

 /** *Reading identification of instrument panel */
 public  class  Meter  {

     /** *Tool class required in important tip code * FileUtil, Base64Util, HttpUtil, GsonUtils *  https://ai.baidu.com/file/658A35ABAB2D404FBF903F64D47C1F72 *  https://ai.baidu.com/file/C8D81F3301E24D2892968F09AE1AD6E2 *  https://ai.baidu.com/file/544D677F5D4E4F17B4122FBD60DB82B3 *  https://ai.baidu.com/file/470B3ACCA3FE43788B5A963BF0B625F3 *Download */
     public  static  String  meter ( )  {
         //Request url
         String url =  " https://aip.baidubce.com/rest/2.0/ocr/v1/meter " ;
         try  {
             //Local file path
             String filePath =  [Local file path] ;
             byte [ ] imgData =  FileUtil . readFileByBytes ( filePath ) ;
             String imgStr =  Base64Util . encode ( imgData ) ;
             String imgParam =  URLEncoder . encode ( imgStr ,  "UTF-8" ) ;

             String param =  "image="  + imgParam ;

             //Note that the purpose here is to simplify the encoding and obtain access_token for each request. The online environment access_token has an expiration time, and the client can cache it and retrieve it after expiration.
             String accessToken =  "[Token obtained by calling the authentication interface]" ;

             String result =  HttpUtil . post ( url , accessToken , param ) ;
             System . out . println ( result ) ;
             return result ;
         }  catch  ( Exception e )  { e . printStackTrace ( ) ;
         }
         return  null ;
     }

     public  static  void  main ( String [ ] args )  {
         Meter . meter ( ) ;
     }
 }
 # include  <iostream>
 # include  <curl/curl.h>

 //Download link of libcurl library: https://curl.haxx.se/download.html
 //Download link of jsoncpp library: https://github.com/open-source-parsers/jsoncpp/
 const  static std :: string request_url =  " https://aip.baidubce.com/rest/2.0/ocr/v1/meter " ;
 static std :: string meter_result ;
 /** *The curl sends the callback function called by the http request. The returned body in json format is parsed in the callback function, and the parsing result is stored in the global static variable *See the libcurl document for @ param parameter definitions *@ return See the libcurl document for the definition of the return value */
 static size_t callback ( void  * ptr , size_t size , size_t nmemb ,  void  * stream )  {
     //The obtained body is stored in ptr and converted to string format first meter_result = std :: string ( ( char  * ) ptr , size * nmemb ) ;
     return size * nmemb ;
 }
 /** *Reading identification of instrument panel *@ return If the call is successful, 0 will be returned. If an error occurs, other error codes will be returned */
 int  meter ( std :: string & json_result ,  const std :: string & access_token )  { std :: string url = request_url +  "? access_token="  + access_token ; CURL * curl =  NULL ; CURLcode result_code ;
     int is_success ; curl =  curl_easy_init ( ) ;
     if  ( curl )  {
         curl_easy_setopt ( curl , CURLOPT_URL , url . data ( ) ) ;
         curl_easy_setopt ( curl , CURLOPT_POST ,  one ) ; curl_httppost * post =  NULL ; curl_httppost * last =  NULL ;
         curl_formadd ( & post ,  & last , CURLFORM_COPYNAME ,  "image" , CURLFORM_COPYCONTENTS ,  "【base64_img】" , CURLFORM_END ) ;

         curl_easy_setopt ( curl , CURLOPT_HTTPPOST , post ) ;
         curl_easy_setopt ( curl , CURLOPT_WRITEFUNCTION , callback ) ; result_code =  curl_easy_perform ( curl ) ;
         if  ( result_code != CURLE_OK )  {
             fprintf ( stderr ,  "curl_easy_perform() failed: %s\n" ,
                     curl_easy_strerror ( result_code ) ) ; is_success =  one ;
             return is_success ;
         } json_result = meter_result ;
         curl_easy_cleanup ( curl ) ; is_success =  zero ;
     }  else  {
         fprintf ( stderr ,  "curl_easy_init() failed." ) ; is_success =  one ;
     }
     return is_success ;
 }
 <? php
 /** *Initiate http post requests (REST APIs) and obtain the results of REST requests * @param string $url * @param string $param * @return - http response body if succeeds,  else false. */
 function  request_post ( $url  =  '' ,  $param  =  '' )
 {
     if  ( empty ( $url )  ||  empty ( $param ) )  {
         return  false ;
     }

     $postUrl  =  $url ;
     $curlPost  =  $param ;
     //Initialize curl
     $curl  =  curl_init ( ) ;
     curl_setopt ( $curl ,  CURLOPT_URL ,  $postUrl ) ;
     curl_setopt ( $curl ,  CURLOPT_HEADER ,  zero ) ;
     //The result is required to be a string and output to the screen
     curl_setopt ( $curl ,  CURLOPT_RETURNTRANSFER ,  one ) ;
     curl_setopt ( $curl ,  CURLOPT_SSL_VERIFYPEER ,  false ) ;
     //Post submission method
     curl_setopt ( $curl ,  CURLOPT_POST ,  one ) ;
     curl_setopt ( $curl ,  CURLOPT_POSTFIELDS ,  $curlPost ) ;
     //Run curl
     $data  =  curl_exec ( $curl ) ;
     curl_close ( $curl ) ;

     return  $data ;
 }

 $token  =  '[Token obtained by calling the authentication interface]' ;
 $url  =  ' https://aip.baidubce.com/rest/2.0/ocr/v1/meter?access_token= '  .  $token ;
 $img  =  file_get_contents ( '[Local file path]' ) ;
 $img  =  base64_encode ( $img ) ;
 $bodys  =  array (
     'image'  = >  $img
 ) ;
 $res  =  request_post ( $url ,  $bodys ) ;

 var_dump ( $res ) ;
 using System ;
 using System . IO ;
 using System . Net ;
 using System . Text ;
 using System . Web ;

 namespace com . baidu . ai {
     public  class  Meter
     {
         //Reading identification of instrument panel
         public  static  string  meter ( )
         {
             string token =  "[Token obtained by calling the authentication interface]" ;
             string host =  " https://aip.baidubce.com/rest/2.0/ocr/v1/meter?access_token= "  + token ;
             Encoding encoding = Encoding . Default ;
             HttpWebRequest request =  ( HttpWebRequest ) WebRequest . Create ( host ) ; request . Method =  "post" ; request . KeepAlive =  true ;
             //Base64 encoding of pictures
             string base64 =  getFileBase64 ( [Local picture file] ) ;
             String str =  "image="  + HttpUtility . UrlEncode ( base64 ) ;
             byte [ ] buffer = encoding . GetBytes ( str ) ; request . ContentLength = buffer . Length ; request . GetRequestStream ( ) . Write ( buffer ,  zero , buffer . Length ) ;
             HttpWebResponse response =  ( HttpWebResponse ) request . GetResponse ( ) ;
             StreamReader reader =  new  StreamReader ( response . GetResponseStream ( ) , Encoding . Default ) ;
             string result = reader . ReadToEnd ( ) ; Console . WriteLine ( "Instrument panel reading identification:" ) ; Console . WriteLine ( result ) ;
             return result ;
         }

         public  static  String  getFileBase64 ( String fileName )  {
             FileStream filestream =  new  FileStream ( fileName , FileMode . Open ) ;
             byte [ ] arr =  new  byte [ filestream . Length ] ; filestream . Read ( arr ,  zero ,  ( int ) filestream . Length ) ;
             string baser64 = Convert . ToBase64String ( arr ) ; filestream . Close ( ) ;
             return baser64 ;
         }
     }
 }

Return description

Return parameters

field Required type explain
log_id yes uint64 Unique log ID for problem location
words_result yes array[] Identification result array
words_result_num yes uint32 The number of recognition results, representing the number of words_result elements
+ words yes string Identification result string
+ location yes array[] Rectangle position information of recognition result
++ left yes uint32 The horizontal coordinate of the top left vertex of the rectangle representing the positioning position
++ top yes uint32 The vertical coordinate of the top left vertex of the rectangle representing the positioning position
++ width yes uint32 The width of the rectangle representing the positioning position
++ height yes uint32 The height of the rectangle representing the positioning position
+ probability no string It exists when probability=true. The confidence value of each line in the recognition result, including average: average of line confidence, Variance: row confidence variance, Min: minimum value of row confidence
+ poly_location no array[] Exists when poly_location=true. Coordinate information of 4 points of the circumscribed quadrilateral in the text area

Return to Example

 {
     "log_id" :  "1392680790663364608" ,
	 "words_result_num" :  five
	 "words_result" :  [
		 {
			 "words" :  "5.8" ,
			 "location" :  {
				 "top" :  one hundred and fifty ,
				 "left" :  three hundred and seventy ,
				 "width" :  eighty-seven ,
				 "height" :  seventy-nine
			 }
		 } ,
		 {
			 "words" :  "mmol/L" ,
			 "location" :  {
				 "top" :  two hundred and forty-one ,
				 "left" :  four hundred and two ,
				 "width" :  fifty-two ,
				 "height" :  twelve
			 }
		 } ,
		 {
			 "words" :  "10:38" ,
			 "location" :  {
				 "top" :  one hundred and fifteen ,
				 "left" :  three hundred and forty-seven ,
				 "width" :  forty-two ,
				 "height" :  twenty-one
			 }
		 } ,
		 {
			 "words" :  "12-11" ,
			 "location" :  {
				 "top" :  one hundred and sixteen ,
				 "left" :  four hundred and ten ,
				 "width" :  thirty-six ,
				 "height" :  twenty
			 }
		 } ,
		 {
			 "words" :  "am" ,
			 "location" :  {
				 "top" :  one hundred and fifteen ,
				 "left" :  three hundred and ninety-one ,
				 "width" :  twelve ,
				 "height" :  five
			 }
		 }
	 ] ,
 }
Previous
Character recognition in educational scenes
Next
Door face character recognition