diff --git a/day13/LPR/R-C.jpg b/day13/LPR/R-C.jpg
new file mode 100755
index 0000000..942955d
Binary files /dev/null and b/day13/LPR/R-C.jpg differ
diff --git a/day13/LPR/base/base.h b/day13/LPR/base/base.h
new file mode 100644
index 0000000..d7155ae
--- /dev/null
+++ b/day13/LPR/base/base.h
@@ -0,0 +1,264 @@
+/**
+ * Copyright (c) 2017 Baidu.com, Inc. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * @author baidu aip
+ */
+#ifndef __AIP_BASE_H__
+#define __AIP_BASE_H__
+
+#include <memory>
+#include <cstring>
+#include "http.h"
+#include "json/json.h"
+#include "base64.h"
+#include "curl/curl.h"
+#include "utils.h"
+
+namespace aip {
+    
+    static const char* AIP_SDK_VERSION = "0.3.3";
+    static const char* CURL_ERROR_CODE = "curl_error_code";
+    static const std::string ACCESS_TOKEN_URL = "https://aip.baidubce.com/oauth/2.0/token";
+    static const std::map<std::string, std::string> null;
+    
+    class AipBase
+    {
+    private:
+        std::string _app_id;
+        int _expired_time;
+        bool _is_bce;
+        bool _has_decide_type;
+        std::string _scope;
+        
+    protected:
+        std::string getAccessToken()
+        {
+            time_t now = time(NULL);
+            if (!access_token.empty())
+            {
+                return this->access_token;
+            }
+            
+            if (now < this->_expired_time - 60 * 60 * 24)
+            {
+                return this->access_token;
+            }
+            
+            std::string response;
+            std::map<std::string, std::string> params;
+            
+            params["grant_type"] = "client_credentials";
+            params["client_id"] = this->ak;
+            params["client_secret"] = this->sk;
+            int status_code = this->client.get(
+                                               ACCESS_TOKEN_URL,
+                                               &params,
+                                               nullptr,
+                                               &response
+                                               );
+            Json::Value obj;
+            if (status_code != CURLcode::CURLE_OK) {
+                obj[CURL_ERROR_CODE] = status_code;
+                return obj.toStyledString();
+            }
+            
+            std::string error;
+            std::unique_ptr<Json::CharReader> reader(crbuilder.newCharReader());
+            reader->parse(response.data(), response.data() + response.size(), &obj, &error);
+            this->access_token = obj["access_token"].asString();
+            this->_expired_time = obj["expires_in"].asInt() + (int) now;
+            this->_scope = obj["scope"].asString();
+            return this->access_token;
+        }
+        
+    public:
+        std::string ak;
+        std::string sk;
+        HttpClient client;
+        Json::CharReaderBuilder crbuilder;
+        std::string access_token;
+        AipBase(const std::string & app_id, const std::string & ak, const std::string & sk):
+        _app_id(app_id),
+        _is_bce(false),
+        _has_decide_type(false),
+        ak(ak),
+        sk(sk)
+        {
+            if (_app_id == "")
+            {
+            }
+        }
+        
+        void setConnectionTimeoutInMillis(int connect_timeout)
+        {
+            this->client.setConnectTimeout(connect_timeout);
+        }
+        
+        void setSocketTimeoutInMillis(int socket_timeout)
+        {
+            this->client.setSocketTimeout(socket_timeout);
+        }
+        
+        void setDebug(bool debug)
+        {
+            this->client.setDebug(debug);
+        }
+        
+        std::string getAk() {
+            return ak;
+        }
+        
+        Json::Value request(
+                            std::string url,
+                            std::map<std::string, std::string> const & params,
+                            std::string const & data,
+                            std::map<std::string, std::string> const & headers)
+        {
+            std::string response;
+            Json::Value obj;
+            std::string body;
+            auto headers_for_sign = headers;
+            
+            auto temp_params = params;
+            
+            temp_params["charset"] = "UTF-8";
+            
+            this->prepare_request(url, temp_params, headers_for_sign);
+            
+            int status_code = this->client.post(url, &temp_params, data, &headers_for_sign, &response);
+            
+            if (status_code != CURLcode::CURLE_OK) {
+                obj[CURL_ERROR_CODE] = status_code;
+                return obj;
+            }
+            
+            std::string error;
+            std::unique_ptr<Json::CharReader> reader(crbuilder.newCharReader());
+            reader->parse(response.data(), response.data() + response.size(), &obj, &error);
+            
+            return obj;
+        }
+        
+        Json::Value request(
+                            std::string url,
+                            std::map<std::string, std::string> const & params,
+                            std::map<std::string, std::string> const & data,
+                            std::map<std::string, std::string> const & headers)
+        {
+            std::string response;
+            Json::Value obj;
+            
+            auto headers_for_sign = headers;
+            auto temp_params = params;
+            
+            this->prepare_request(url, temp_params, headers_for_sign);
+            
+            int status_code = this->client.post(url, &temp_params, data, &headers_for_sign, &response);
+            
+            if (status_code != CURLcode::CURLE_OK) {
+                obj[CURL_ERROR_CODE] = status_code;
+                return obj;
+            }
+            
+            std::string error;
+            std::unique_ptr<Json::CharReader> reader(crbuilder.newCharReader());
+            reader->parse(response.data(), response.data() + response.size(), &obj, &error);
+            
+            return obj;
+        }
+        
+        void prepare_request(std::string url,
+                             std::map<std::string, std::string> & params,
+                             std::map<std::string, std::string> & headers)
+        {
+            
+            params["aipSdk"] = "C";
+            params["aipSdkVersion"] = AIP_SDK_VERSION;
+            
+            if (_has_decide_type) {
+                if (_is_bce) {
+                    std::string method = "POST";
+                    sign(method, url, params, headers, ak, sk);
+                } else {
+                    params["access_token"] = this->getAccessToken();
+                }
+                
+                return;
+            }
+            
+            if (getAccessToken() == "") {
+                _is_bce = true;
+                
+            } else {
+                
+                const char * t = std::strstr(this->_scope.c_str(), "brain_all_scope");
+                
+                if (t == NULL)
+                {
+                    _is_bce = true;
+                }
+            }
+            
+            _has_decide_type = true;
+            prepare_request(url, params, headers);
+        }
+     
+
+       Json::Value requestjson(
+                            std::string url,
+                            Json::Value & data,
+                            std::map<std::string, std::string> & params,
+                            std::map<std::string, std::string> const & headers)
+        {
+    
+            std::string response;
+            Json::Value obj;
+            auto headers_for_sign = headers;
+            auto temp_params = params;
+            this->prepare_request(url, temp_params, headers_for_sign);
+            int status_code = this->client.post(url, nullptr, data, nullptr, &response);
+            if (status_code != CURLcode::CURLE_OK) {
+                obj[aip::CURL_ERROR_CODE] = status_code;
+                return obj;
+            }
+
+            std::string error;
+            std::unique_ptr<Json::CharReader> reader(crbuilder.newCharReader());
+            reader->parse(response.data(), response.data() + response.size(), &obj, &error);
+
+            return obj;
+        }
+
+       Json::Value request_com(
+                                  std::string const & url,
+                                  Json::Value & data)
+        {
+            std::string response;
+            Json::Value obj;
+            int status_code = this->client.post(url, nullptr, data, nullptr, &response);
+            
+            if (status_code != CURLcode::CURLE_OK) {
+                obj[aip::CURL_ERROR_CODE] = status_code;
+                return obj;
+            }
+            std::string error;
+            std::unique_ptr<Json::CharReader> reader(crbuilder.newCharReader());
+            reader->parse(response.data(), response.data() + response.size(), &obj, &error);
+            
+            return obj;
+        }        
+        
+  
+    };
+    
+}
+#endif
diff --git a/day13/LPR/base/base64.h b/day13/LPR/base/base64.h
new file mode 100644
index 0000000..e0ab6ff
--- /dev/null
+++ b/day13/LPR/base/base64.h
@@ -0,0 +1,130 @@
+/**
+ * Copyright (c) 2017 Baidu.com, Inc. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * @author baidu aip
+ */
+#ifndef __AIP_BASE64_H__
+#define __AIP_BASE64_H__
+
+#include <iostream>
+#include <string>
+
+namespace aip {
+    
+    static const std::string base64_chars =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "abcdefghijklmnopqrstuvwxyz"
+    "0123456789+/";
+    
+    
+    static inline bool is_base64(const char c)
+    {
+        return (isalnum(c) || (c == '+') || (c == '/'));
+    }
+    
+    std::string base64_encode(const char * bytes_to_encode, unsigned int in_len)
+    {
+        std::string ret;
+        int i = 0;
+        int j = 0;
+        unsigned char char_array_3[3];
+        unsigned char char_array_4[4];
+        
+        while (in_len--)
+        {
+            char_array_3[i++] = *(bytes_to_encode++);
+            if(i == 3)
+            {
+                char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+                char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+                char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+                char_array_4[3] = char_array_3[2] & 0x3f;
+                
+                for(i = 0; (i <4) ; i++)
+                {
+                    ret += base64_chars[char_array_4[i]];
+                }
+                i = 0;
+            }
+        }
+        
+        if(i)
+        {
+            for(j = i; j < 3; j++)
+            {
+                char_array_3[j] = '\0';
+            }
+            
+            char_array_4[0] = (char_array_3[0] & 0xfc) >> 2;
+            char_array_4[1] = ((char_array_3[0] & 0x03) << 4) + ((char_array_3[1] & 0xf0) >> 4);
+            char_array_4[2] = ((char_array_3[1] & 0x0f) << 2) + ((char_array_3[2] & 0xc0) >> 6);
+            char_array_4[3] = char_array_3[2] & 0x3f;
+            
+            for(j = 0; (j < i + 1); j++)
+            {
+                ret += base64_chars[char_array_4[j]];
+            }
+            
+            while((i++ < 3))
+            {
+                ret += '=';
+            }
+            
+        }
+        
+        return ret;
+    }
+    
+    std::string base64_decode(std::string const & encoded_string)
+    {
+        int in_len = (int) encoded_string.size();
+        int i = 0;
+        int j = 0;
+        int in_ = 0;
+        unsigned char char_array_4[4], char_array_3[3];
+        std::string ret;
+        
+        while (in_len-- && ( encoded_string[in_] != '=') && is_base64(encoded_string[in_])) {
+            char_array_4[i++] = encoded_string[in_]; in_++;
+            if (i ==4) {
+                for (i = 0; i <4; i++)
+                    char_array_4[i] = base64_chars.find(char_array_4[i]);
+                
+                char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+                char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);
+                char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];
+                
+                for (i = 0; (i < 3); i++)
+                    ret += char_array_3[i];
+                i = 0;
+            }
+        }
+        
+        if (i) {
+            for (j = i; j <4; j++)
+                char_array_4[j] = 0;
+            
+            for (j = 0; j <4; j++)
+                char_array_4[j] = base64_chars.find(char_array_4[j]);
+            
+            char_array_3[0] = (char_array_4[0] << 2) + ((char_array_4[1] & 0x30) >> 4);
+            char_array_3[1] = ((char_array_4[1] & 0xf) << 4) + ((char_array_4[2] & 0x3c) >> 2);  
+            char_array_3[2] = ((char_array_4[2] & 0x3) << 6) + char_array_4[3];  
+            
+            for (j = 0; (j < i - 1); j++) ret += char_array_3[j];  
+        }  
+        
+        return ret;  
+    }
+    
+}
+#endif
diff --git a/day13/LPR/base/http.h b/day13/LPR/base/http.h
new file mode 100644
index 0000000..71b5ef5
--- /dev/null
+++ b/day13/LPR/base/http.h
@@ -0,0 +1,234 @@
+/**
+ * Copyright (c) 2017 Baidu.com, Inc. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * @author baidu aip
+ */
+#ifndef __AIP_HTTP_H__
+#define __AIP_HTTP_H__
+
+#include "curl/curl.h"
+
+#include <sstream>
+#include <string>
+#include <map>
+#include <json/json.h>
+
+namespace aip {
+    
+    inline size_t onWriteData(void * buffer, size_t size, size_t nmemb, void * userp)
+    {
+        std::string * str = dynamic_cast<std::string *>((std::string *)userp);
+        str->append((char *)buffer, size * nmemb);
+        return nmemb;
+    }
+    
+    class HttpClient
+    {
+    private:
+        bool debug = false;
+        int connect_timeout = 10000;
+        int socket_timeout = 10000;
+        
+        void makeUrlencodedForm(std::map<std::string, std::string> const & params, std::string * content) const
+        {
+            content->clear();
+            std::map<std::string, std::string>::const_iterator it;
+            for(it=params.begin(); it!=params.end(); it++)
+            {
+                char * key = curl_escape(it->first.c_str(), (int) it->first.size());
+                char * value = curl_escape(it->second.c_str(),(int) it->second.size());
+                *content += key;
+                *content += '=';
+                *content += value;
+                *content += '&';
+                curl_free(key);
+                curl_free(value);
+            }
+        }
+        
+        void appendUrlParams(std::map<std::string, std::string> const & params, std::string* url) const
+        {
+            if(params.empty()) {
+                return;
+            }
+            std::string content;
+            this->makeUrlencodedForm(params, &content);
+            bool url_has_param = false;
+            for (const auto& ch : *url) {
+                if (ch == '?') {
+                    url_has_param = true;
+                    break;
+                }
+            }
+            if (url_has_param) {
+                url->append("&");
+            } else {
+                url->append("?");
+            }
+            url->append(content);
+        }
+        
+        void appendHeaders(std::map<std::string, std::string> const & headers, curl_slist ** slist) const
+        {
+            std::ostringstream ostr;
+            std::map<std::string, std::string>::const_iterator it;
+            for(it=headers.begin(); it!=headers.end(); it++)
+            {
+                ostr << it->first << ":" << it->second;
+                *slist = curl_slist_append(*slist, ostr.str().c_str());
+                ostr.str("");
+            }
+        }
+        
+    public:
+        HttpClient() = default;
+        
+        HttpClient(const HttpClient &) = delete;
+        HttpClient & operator=(const HttpClient &) = delete;
+        
+        void setConnectTimeout(int connect_timeout)
+        {
+            this->connect_timeout = connect_timeout;
+        }
+        
+        void setSocketTimeout(int socket_timeout)
+        {
+            this->socket_timeout = socket_timeout;
+        }
+        
+        void setDebug(bool debug)
+        {
+            this->debug = debug;
+        }
+        
+        int get(
+                std::string url,
+                std::map<std::string, std::string> const * params,
+                std::map<std::string, std::string> const * headers,
+                std::string * response) const
+        {
+            CURL * curl = curl_easy_init();
+            struct curl_slist * slist = NULL;
+            if (headers) {
+                this->appendHeaders(*headers, &slist);
+            }
+            if (params) {
+                this->appendUrlParams(*params, &url);
+            }
+            
+            curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
+            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, onWriteData);
+            curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) response);
+            curl_easy_setopt(curl, CURLOPT_NOSIGNAL, true);
+            curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, this->connect_timeout);
+            curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, this->socket_timeout);
+            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
+            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, false);
+            curl_easy_setopt(curl, CURLOPT_VERBOSE, this->debug);
+            
+            int status_code = curl_easy_perform(curl);
+            
+            curl_easy_cleanup(curl);
+            curl_slist_free_all(slist);
+            
+            return status_code;
+        }
+        
+        int post(
+                 std::string url,
+                 std::map<std::string, std::string> const * params,
+                 const std::string & body,
+                 std::map<std::string, std::string> const * headers,
+                 std::string * response) const
+        {
+            struct curl_slist * slist = NULL;
+            CURL * curl = curl_easy_init();
+            if (headers) {
+                this->appendHeaders(*headers, &slist);
+            }
+            if (params) {
+                this->appendUrlParams(*params, &url);
+            }
+            
+            curl_easy_setopt(curl, CURLOPT_URL, url.c_str());
+            curl_easy_setopt(curl, CURLOPT_HTTPHEADER, slist);
+            curl_easy_setopt(curl, CURLOPT_POST, true);
+            curl_easy_setopt(curl, CURLOPT_POSTFIELDS, body.c_str());
+            curl_easy_setopt(curl, CURLOPT_POSTFIELDSIZE, body.size());
+            curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, onWriteData);
+            curl_easy_setopt(curl, CURLOPT_WRITEDATA, (void *) response);
+            curl_easy_setopt(curl, CURLOPT_NOSIGNAL, true);
+            curl_easy_setopt(curl, CURLOPT_CONNECTTIMEOUT_MS, this->connect_timeout);
+            curl_easy_setopt(curl, CURLOPT_TIMEOUT_MS, this->socket_timeout);
+            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, false);
+            curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, false);
+            curl_easy_setopt(curl, CURLOPT_VERBOSE, this->debug);
+            
+            int status_code = curl_easy_perform(curl);
+            
+            curl_easy_cleanup(curl);
+            curl_slist_free_all(slist);
+            
+            return status_code;
+        }
+        
+        int post(
+                 std::string url,
+                 std::map<std::string, std::string> const * params,
+                 std::map<std::string, std::string> const & data,
+                 std::map<std::string, std::string> const * headers,
+                 std::string * response) const
+        {
+            
+            std::string body;
+            this->makeUrlencodedForm(data, &body);
+            return this->post(std::move(url), params, body, headers, response);
+        }
+        
+        int post(
+                 std::string url,
+                 std::map<std::string, std::string> const * params,
+                 Json::Value const & data,
+                 std::map<std::string, std::string> const * headers,
+                 std::string * response) const
+        {
+            std::string body;
+            Json::StreamWriterBuilder swb;
+            std::unique_ptr<Json::StreamWriter> writer(swb.newStreamWriter());
+            std::ostringstream os;
+            writer->write(data, &os);
+            body = os.str();
+            std::map<std::string, std::string> temp_headers;
+            if (headers) {
+                std::map<std::string, std::string> temp_headers(*headers);
+            }
+            
+            temp_headers["Content-Type"] = "application/json";
+            return this->post(url.c_str(), params, body, &temp_headers, response);
+        }
+        
+        
+        int post(
+                 std::string url,
+                 std::map<std::string, std::string> const * params,
+                 std::map<std::string, std::string> const * headers,
+                 std::string * response) const
+        {
+            const static std::string EMPTY_STRING;
+            return this->post(std::move(url), params, EMPTY_STRING, headers, response);
+        }
+    };
+    
+}
+
+#endif
diff --git a/day13/LPR/base/utils.h b/day13/LPR/base/utils.h
new file mode 100644
index 0000000..700eb5c
--- /dev/null
+++ b/day13/LPR/base/utils.h
@@ -0,0 +1,283 @@
+/**
+ * Copyright (c) 2017 Baidu.com, Inc. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * @author baidu aip
+ */
+#ifndef __AIP_UTILS_H__
+#define __AIP_UTILS_H__
+
+#include <string>
+#include <fstream>
+#include <ctype.h>
+#include <openssl/evp.h>
+#include <openssl/hmac.h>
+#include <algorithm>
+#include <openssl/md5.h>
+
+const int __BCE_VERSION__ = 1;
+const int __BCE_EXPIRE__ = 1800;
+
+namespace aip {
+    
+    template<class CharT, class Traits, class Allocator>
+    std::basic_istream<CharT, Traits>& getall(std::basic_istream<CharT, Traits>& input,
+                                              std::basic_string<CharT, Traits, Allocator>& str) {
+        std::ostringstream oss;
+        oss << input.rdbuf();
+        str.assign(oss.str());
+        return input;
+    }
+    
+    inline int get_file_content(const char *filename, std::string* out) {
+        std::ifstream in(filename, std::ios::in | std::ios::binary);
+        if (in) {
+            getall(in, *out);
+            return 0;
+        } else {
+            return -1;
+        }
+    }
+    
+    inline std::string to_upper(std::string src)
+    {
+        std::transform(src.begin(), src.end(), src.begin(), toupper);
+        return src;
+    }
+    
+    
+    inline std::string to_lower(std::string src)
+    {
+        std::transform(src.begin(), src.end(), src.begin(), tolower);
+        return src;
+    }
+    
+    inline std::string to_hex(unsigned char c, bool lower = false)
+    {
+        const std::string hex = "0123456789ABCDEF";
+        
+        std::stringstream ss;
+        ss << hex[c >> 4] << hex[c & 0xf];
+        
+        return lower ? to_lower(ss.str()) : ss.str();
+    }
+    
+    inline time_t now()
+    {
+        return time(NULL);
+    }
+    
+    std::string utc_time(time_t timestamp)
+    {
+        struct tm result_tm;
+        char buffer[32];
+        
+#ifdef _WIN32
+        gmtime_s(&result_tm, &timestamp);
+#else
+        gmtime_r(&timestamp, &result_tm);
+#endif
+        
+        size_t size = strftime(buffer, 32, "%Y-%m-%dT%H:%M:%SZ", &result_tm);
+        
+        return std::string(buffer, size);
+    }
+    
+    void url_parse(
+                   const std::string & url,
+                   std::map<std::string, std::string> & params)
+    {
+        int pos = (int)url.find("?");
+        if (pos != -1)
+        {
+            int key_start = pos + 1,
+            key_len = 0,
+            val_start = 0;
+            for (int i = key_start; i <= (int)url.size(); ++i)
+            {
+                switch (url[i])
+                {
+                    case '=':
+                        key_len = i - key_start;
+                        val_start = i + 1;
+                        break;
+                    case '\0':
+                    case '&':
+                        if (key_len != 0)
+                        {
+                            params[url.substr(key_start, key_len)] = url.substr(val_start, i - val_start);
+                            key_start = i + 1;
+                            key_len = 0;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+    }
+    
+    std::string url_encode(const std::string & input, bool encode_slash=true)
+    {
+        std::stringstream ss;
+        const char *str = input.c_str();
+        
+        for (uint32_t i = 0; i < input.size(); i++)
+        {
+            unsigned char c = str[i];
+            if (isalnum(c) || c == '_' || c == '-' || c == '~' || c == '.' || (!encode_slash && c == '/'))
+            {
+                ss << c;
+            }
+            else
+            {
+                ss << "%" << to_hex(c);
+            }
+        }
+        
+        return ss.str();
+    }
+    
+    std::string canonicalize_params(std::map<std::string, std::string> & params)
+    {
+        std::vector<std::string> v;
+        v.reserve(params.size());
+        
+        for (auto & it : params) {
+            v.push_back(url_encode(it.first) + "=" + url_encode(it.second));
+        }
+        std::sort(v.begin(), v.end());
+        
+        std::string result;
+        for (auto & it : v)
+        {
+            result.append((result.empty() ? "" : "&") + it);
+        }
+        return result;
+    }
+    
+    std::string canonicalize_headers(std::map<std::string, std::string> & headers)
+    {
+        std::vector<std::string> v;
+        v.reserve(headers.size());
+        
+        for (auto & it : headers) {
+            v.push_back(url_encode(to_lower(it.first)) + ":" + url_encode(it.second));
+        }
+        std::sort(v.begin(), v.end());
+        
+        std::string result;
+        for (auto & it : v)
+        {
+            result.append((result.empty() ? "" : "\n") + it);
+        }
+        return result;
+    }
+    
+    std::string get_headers_keys(std::map<std::string, std::string> & headers)
+    {
+        std::vector<std::string> v;
+        v.reserve(headers.size());
+        
+        for (auto & it : headers) {
+            v.push_back(to_lower(it.first));
+        }
+        
+        std::string result;
+        for (auto & it : v)
+        {
+            result.append((result.empty() ? "" : ";") + it);
+        }
+        return result;
+    }
+    
+    std::string get_host(const std::string & url)
+    {
+        int pos = (int)url.find("://") + 3;
+        return url.substr(
+                          pos,
+                          url.find('/', pos) - pos
+                          );
+    }
+    
+    
+    std::string get_path(const std::string & url)
+    {
+        int path_start = (int)url.find('/', url.find("://") + 3);
+        int path_end = (int)url.find('?');
+        path_end = path_end == -1 ? (int)url.size() : path_end;
+        
+        return url.substr(path_start, path_end - path_start);
+    }
+    
+    std::string hmac_sha256(
+                            const std::string & src,
+                            const std::string & sk)
+    {
+        const EVP_MD *evp_md = EVP_sha256();
+        unsigned char md[EVP_MAX_MD_SIZE];
+        unsigned int md_len = 0;
+        
+        if (HMAC(evp_md,
+                 reinterpret_cast<const unsigned char *>(sk.data()), (int)sk.size(),
+                 reinterpret_cast<const unsigned char *>(src.data()), src.size(),
+                 md, &md_len) == NULL)
+        {
+            return "";
+        }
+        
+        std::stringstream ss;
+        for (int i = 0; i < (int)md_len; ++i)
+        {
+            ss << to_hex(md[i], true);
+        }
+        
+        return ss.str();
+    }
+    
+    void sign(
+              std::string method,
+              std::string & url,
+              std::map<std::string, std::string> & params,
+              std::map<std::string, std::string> & headers,
+              std::string & ak,
+              std::string & sk)
+    {
+        url_parse(url, params);
+        headers["Host"] = get_host(url);
+        std::string timestamp = utc_time(now());
+        headers["x-bce-date"] = timestamp;
+        
+        std::stringstream ss;
+        ss << "bce-auth-v" << __BCE_VERSION__ << "/" << ak << "/"
+        << timestamp  << "/" << __BCE_EXPIRE__;
+        
+        std::string val = ss.str();
+        std::string sign_key = hmac_sha256(val, sk);
+        
+        ss.str("");
+        ss << to_upper(method) << '\n' << url_encode(get_path(url), false)
+        << '\n' << canonicalize_params(params)
+        << '\n' << canonicalize_headers(headers);
+        
+        std::string signature = hmac_sha256(ss.str(), sign_key);
+        
+        ss.str("");
+        ss << "bce-auth-v" << __BCE_VERSION__ << "/" << ak << "/"
+        << timestamp  << "/" << __BCE_EXPIRE__ << "/"
+        << get_headers_keys(headers) << "/" << signature;
+        
+        headers["authorization"] = ss.str();
+    }
+    
+}
+
+#endif
diff --git a/day13/LPR/main.cpp b/day13/LPR/main.cpp
new file mode 100644
index 0000000..7b8e3a4
--- /dev/null
+++ b/day13/LPR/main.cpp
@@ -0,0 +1,38 @@
+#include <iostream>
+#include "ocr.h"   // 用于调用接口
+#include <string>  // 用于 string 的操作
+#include <codecvt> // 用于转码
+
+using namespace std;
+
+int main(int argc, char const *argv[]) // argc: 参数个数, argv: 参数列表
+{
+    if (argc < 2)
+    {
+        cout << "Usage: " << argv[0] << "车牌照片路径" << endl;
+        return -1;
+    }
+
+    string app_id = "35458273";                             // 你的 App ID
+    string api_key = "i45yQx4IaGoxxULLDVPl4iNj";            // 你的 Api Key
+    string secret_key = "jnt90aTbXCOp9L7gRB1xq1C3iT0bLuie"; // 你的 Secret Key
+
+    aip::Ocr client(app_id, api_key, secret_key); // 新建一个对象, 用于调用接口, 调用通用文字识别, 图片参数为本地图片
+    cout << "ok" << endl;
+
+    // 定义 json 格式的数据类型 Value, result 是 json 类型的 Value 类实例, 用于存储返回的结果
+    Json::Value result;
+    string image;
+
+    // 加载本地的车牌图片内容到 image 对象中, 用于调用车牌识别
+    // aip::get_file_content("R-C.jpg", &image);
+    aip::get_file_content(argv[1], &image);
+
+    // 客户端发送图片内容到百度服务器, 并返回结果到 result 对象中
+    result = client.license_plate(image, aip::null);
+    // cout << result << endl;
+    cout << "车牌颜色: " << result["words_result"]["color"] << endl;
+    cout << "车牌号码: " << result["words_result"]["number"].asString() << endl;
+
+    return 0;
+}
\ No newline at end of file
diff --git a/day13/LPR/ocr.h b/day13/LPR/ocr.h
new file mode 100755
index 0000000..7ced537
--- /dev/null
+++ b/day13/LPR/ocr.h
@@ -0,0 +1,1551 @@
+/**
+ * Copyright (c) 2017 Baidu.com, Inc. All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on
+ * an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations under the License.
+ *
+ * @author baidu aip
+ */
+
+#ifndef __AIP_OCR_H__
+#define __AIP_OCR_H__
+
+#include "base/base.h"
+
+namespace aip {
+
+    class Ocr: public AipBase
+    {
+    public:
+
+        std::string _medical_detail =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/medical_detail";
+
+        std::string _weight_note =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/weight_note";
+
+        std::string _online_taxi_itinerary =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/online_taxi_itinerary";
+        std::string _invoice =
+        "https://aip.baidubce.com/rest/2.0/ocr/v1/invoice";
+
+        std::string _passport =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/passport";
+
+        std::string _air_ticket =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/air_ticket";
+
+        std::string _household_register =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/household_register";
+
+        std::string _vehicle_certificate =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/vehicle_certificate";
+
+        std::string _vehicle_invoice =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/vehicle_invoice";
+
+        std::string _qrcode =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/qrcode";
+
+        std::string _doc_analysis_office =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/doc_analysis_office";
+
+        std::string _handwriting =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/handwriting";
+
+        std::string _doc_analysis =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/doc_analysis";
+
+        std::string _meter =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/meter";
+
+        std::string _webimage_loc =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/webimage_loc";
+
+        std::string _seal =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/seal";
+    
+        std::string _general_basic =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/general_basic";
+        
+        std::string _accurate_basic =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/accurate_basic";
+        
+        std::string _general =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/general";
+        
+        std::string _accurate =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/accurate";
+        
+        std::string _general_enhanced =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/general_enhanced";
+        
+        std::string _webimage =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/webimage";
+        
+        std::string _idcard =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/idcard";
+        
+        std::string _bankcard =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/bankcard";
+        
+        std::string _driving_license =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/driving_license";
+        
+        std::string _vehicle_license =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/vehicle_license";
+        
+        std::string _license_plate =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/license_plate";
+        
+        std::string _business_license =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/business_license";
+        
+        std::string _receipt =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/receipt";
+        
+        std::string _table_recognize =
+            "https://aip.baidubce.com/rest/2.0/solution/v1/form_ocr/request";
+        
+        std::string _table_result_get =
+            "https://aip.baidubce.com/rest/2.0/solution/v1/form_ocr/get_request_result";
+       
+        std::string _vat_invoice =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/vat_invoice";
+        
+        std::string _taxi_receipt =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/taxi_receipt";
+        
+        std::string _vin_code =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/vin_code";
+        
+        std::string _numbers =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/numbers";
+    
+        std::string _train_ticket =
+            "https://aip.baidubce.com/rest/2.0/ocr/v1/train_ticket";
+       
+        Ocr(const std::string & app_id, const std::string & ak, const std::string & sk): AipBase(app_id, ak, sk)
+        {
+        }
+        
+        /**
+         * general_basic
+         * 用户向服务请求识别某张图中的所有文字
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         * language_type 识别语言类型，默认为CHN_ENG。可选值包括：<br/>- CHN_ENG：中英文混合；<br/>- ENG：英文；<br/>- POR：葡萄牙语；<br/>- FRE：法语；<br/>- GER：德语；<br/>- ITA：意大利语；<br/>- SPA：西班牙语；<br/>- RUS：俄语；<br/>- JAP：日语；<br/>- KOR：韩语；
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * detect_language 是否检测语言，默认不检测。当前支持（中文、英语、日语、韩语）
+         * probability 是否返回识别结果中每一行的置信度
+         */
+        Json::Value general_basic(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_general_basic, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * general_basic_url
+         * 用户向服务请求识别某张图中的所有文字
+         * @param url 图片完整URL，URL长度不超过1024字节，URL对应的图片base64编码后大小不超过4M，最短边至少15px，最长边最大4096px,支持jpg/png/bmp格式，当image字段存在时url字段失效
+
+         * options 可选参数:
+         * language_type 识别语言类型，默认为CHN_ENG。可选值包括：<br/>- CHN_ENG：中英文混合；<br/>- ENG：英文；<br/>- POR：葡萄牙语；<br/>- FRE：法语；<br/>- GER：德语；<br/>- ITA：意大利语；<br/>- SPA：西班牙语；<br/>- RUS：俄语；<br/>- JAP：日语；<br/>- KOR：韩语；
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * detect_language 是否检测语言，默认不检测。当前支持（中文、英语、日语、韩语）
+         * probability 是否返回识别结果中每一行的置信度
+         */
+        Json::Value general_basic_url(
+            std::string const & url,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["url"] = url;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_general_basic, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * accurate_basic
+         * 用户向服务请求识别某张图中的所有文字，相对于通用文字识别该产品精度更高，但是没有免费额度，如果您需要使用该产品，您可以在产品页面点击合作咨询或加入文字识别的官网QQ群：631977213向管理员申请试用。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * probability 是否返回识别结果中每一行的置信度
+         */
+        Json::Value accurate_basic(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_accurate_basic, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * general
+         * 用户向服务请求识别某张图中的所有文字，并返回文字在图中的位置信息。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         * recognize_granularity 是否定位单字符位置，big：不定位单字符位置，默认值；small：定位单字符位置
+         * language_type 识别语言类型，默认为CHN_ENG。可选值包括：<br/>- CHN_ENG：中英文混合；<br/>- ENG：英文；<br/>- POR：葡萄牙语；<br/>- FRE：法语；<br/>- GER：德语；<br/>- ITA：意大利语；<br/>- SPA：西班牙语；<br/>- RUS：俄语；<br/>- JAP：日语；<br/>- KOR：韩语；
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * detect_language 是否检测语言，默认不检测。当前支持（中文、英语、日语、韩语）
+         * vertexes_location 是否返回文字外接多边形顶点位置，不支持单字位置。默认为false
+         * probability 是否返回识别结果中每一行的置信度
+         */
+        Json::Value general(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_general, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * general_url
+         * 用户向服务请求识别某张图中的所有文字，并返回文字在图中的位置信息。
+         * @param url 图片完整URL，URL长度不超过1024字节，URL对应的图片base64编码后大小不超过4M，最短边至少15px，最长边最大4096px,支持jpg/png/bmp格式，当image字段存在时url字段失效
+
+         * options 可选参数:
+         * recognize_granularity 是否定位单字符位置，big：不定位单字符位置，默认值；small：定位单字符位置
+         * language_type 识别语言类型，默认为CHN_ENG。可选值包括：<br/>- CHN_ENG：中英文混合；<br/>- ENG：英文；<br/>- POR：葡萄牙语；<br/>- FRE：法语；<br/>- GER：德语；<br/>- ITA：意大利语；<br/>- SPA：西班牙语；<br/>- RUS：俄语；<br/>- JAP：日语；<br/>- KOR：韩语；
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * detect_language 是否检测语言，默认不检测。当前支持（中文、英语、日语、韩语）
+         * vertexes_location 是否返回文字外接多边形顶点位置，不支持单字位置。默认为false
+         * probability 是否返回识别结果中每一行的置信度
+         */
+        Json::Value general_url(
+            std::string const & url,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["url"] = url;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_general, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * accurate
+         * 用户向服务请求识别某张图中的所有文字，相对于通用文字识别（含位置信息版）该产品精度更高，但是没有免费额度，如果您需要使用该产品，您可以在产品页面点击合作咨询或加入文字识别的官网QQ群：631977213向管理员申请试用。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         * recognize_granularity 是否定位单字符位置，big：不定位单字符位置，默认值；small：定位单字符位置
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * vertexes_location 是否返回文字外接多边形顶点位置，不支持单字位置。默认为false
+         * probability 是否返回识别结果中每一行的置信度
+         */
+        Json::Value accurate(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_accurate, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * general_enhanced
+         * 某些场景中，图片中的中文不光有常用字，还包含了生僻字，这时用户需要对该图进行文字识别，应使用通用文字识别（含生僻字版）。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         * language_type 识别语言类型，默认为CHN_ENG。可选值包括：<br/>- CHN_ENG：中英文混合；<br/>- ENG：英文；<br/>- POR：葡萄牙语；<br/>- FRE：法语；<br/>- GER：德语；<br/>- ITA：意大利语；<br/>- SPA：西班牙语；<br/>- RUS：俄语；<br/>- JAP：日语；<br/>- KOR：韩语；
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * detect_language 是否检测语言，默认不检测。当前支持（中文、英语、日语、韩语）
+         * probability 是否返回识别结果中每一行的置信度
+         */
+        Json::Value general_enhanced(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_general_enhanced, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * general_enhanced_url
+         * 某些场景中，图片中的中文不光有常用字，还包含了生僻字，这时用户需要对该图进行文字识别，应使用通用文字识别（含生僻字版）。
+         * @param url 图片完整URL，URL长度不超过1024字节，URL对应的图片base64编码后大小不超过4M，最短边至少15px，最长边最大4096px,支持jpg/png/bmp格式，当image字段存在时url字段失效
+
+         * options 可选参数:
+         * language_type 识别语言类型，默认为CHN_ENG。可选值包括：<br/>- CHN_ENG：中英文混合；<br/>- ENG：英文；<br/>- POR：葡萄牙语；<br/>- FRE：法语；<br/>- GER：德语；<br/>- ITA：意大利语；<br/>- SPA：西班牙语；<br/>- RUS：俄语；<br/>- JAP：日语；<br/>- KOR：韩语；
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * detect_language 是否检测语言，默认不检测。当前支持（中文、英语、日语、韩语）
+         * probability 是否返回识别结果中每一行的置信度
+         */
+        Json::Value general_enhanced_url(
+            std::string const & url,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["url"] = url;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_general_enhanced, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * webimage
+         * 用户向服务请求识别一些网络上背景复杂，特殊字体的文字。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * detect_language 是否检测语言，默认不检测。当前支持（中文、英语、日语、韩语）
+         */
+        Json::Value webimage(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_webimage, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * webimage_url
+         * 用户向服务请求识别一些网络上背景复杂，特殊字体的文字。
+         * @param url 图片完整URL，URL长度不超过1024字节，URL对应的图片base64编码后大小不超过4M，最短边至少15px，最长边最大4096px,支持jpg/png/bmp格式，当image字段存在时url字段失效
+
+         * options 可选参数:
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * detect_language 是否检测语言，默认不检测。当前支持（中文、英语、日语、韩语）
+         */
+        Json::Value webimage_url(
+            std::string const & url,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["url"] = url;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_webimage, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * idcard
+         * 用户向服务请求识别身份证，身份证识别包括正面和背面。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * @param id_card_side front：身份证正面；back：身份证背面
+         * options 可选参数:
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * detect_risk 是否开启身份证风险类型(身份证复印件、临时身份证、身份证翻拍、修改过的身份证)功能，默认不开启，即：false。可选值:true-开启；false-不开启
+         */
+        Json::Value idcard(
+            std::string const & image,
+            std::string const & id_card_side,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            data["id_card_side"] = id_card_side;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_idcard, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * bankcard
+         * 识别银行卡并返回卡号和发卡行。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         */
+        Json::Value bankcard(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_bankcard, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * driving_license
+         * 对机动车驾驶证所有关键字段进行识别
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         */
+        Json::Value driving_license(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_driving_license, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * vehicle_license
+         * 对机动车行驶证正本所有关键字段进行识别
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括:<br/>- true：检测朝向；<br/>- false：不检测朝向。
+         * accuracy normal 使用快速服务，1200ms左右时延；缺省或其它值使用高精度服务，1600ms左右时延
+         */
+        Json::Value vehicle_license(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_vehicle_license, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * license_plate
+         * 识别机动车车牌，并返回签发地和号牌。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         */
+        Json::Value license_plate(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_license_plate, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * business_license
+         * 识别营业执照，并返回关键字段的值，包括单位名称、法人、地址、有效期、证件编号、社会信用代码等。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         */
+        Json::Value business_license(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_business_license, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * receipt
+         * 用户向服务请求识别医疗票据、发票、的士票、保险保单等票据类图片中的所有文字，并返回文字在图中的位置信息。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         * recognize_granularity 是否定位单字符位置，big：不定位单字符位置，默认值；small：定位单字符位置
+         * probability 是否返回识别结果中每一行的置信度
+         * accuracy normal 使用快速服务，1200ms左右时延；缺省或其它值使用高精度服务，1600ms左右时延
+         */
+        Json::Value receipt(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_receipt, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * table_recognize
+         * 自动识别表格线及表格内容，结构化输出表头、表尾及每个单元格的文字内容。表格文字识别接口为异步接口，分为两个API：提交请求接口、获取结果接口。
+         * @param image 图像文件二进制内容，可以使用aip::get_file_content函数获取
+         * options 可选参数:
+         */
+        Json::Value table_recognize(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_table_recognize, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * table_result_get
+         * 获取表格文字识别结果
+         * @param request_id 发送表格文字识别请求时返回的request id
+         * options 可选参数:
+         * result_type 期望获取结果的类型，取值为“excel”时返回xls文件的地址，取值为“json”时返回json格式的字符串,默认为”excel”
+         */
+        Json::Value table_result_get(
+            std::string const & request_id,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["request_id"] = request_id;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_table_result_get, null, data, null);
+
+            return result;
+        }
+        
+        /**
+         * 
+         * 增值税发票识别
+         * @param image 图像二进制内容 
+         * options 可选参数:
+         */
+        Json::Value vatInvoice(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_vat_invoice, null, data, null);
+
+            return result;
+        }
+
+        /**
+         * 
+         * 增值税发票识别
+         * @param image 发票图像URL地址 
+         * options 可选参数:
+         */
+        Json::Value vatInvoiceUrl(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["url"] = image;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_vat_invoice, null, data, null);
+
+            return result;
+        }
+ 
+        /**
+         * 
+         * 增值税发票识别
+         * @param image 发票pdf文件二进制数据 
+         * options 可选参数:
+         */
+        Json::Value vatInvoicePdf(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["pdf_file"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_vat_invoice, null, data, null);
+
+            return result;
+        }
+ 
+         /**
+         * 
+         * 出租车发票识别
+         * @param image 图像二进制内容 
+         * options 可选参数:
+         */
+        Json::Value taxiReceipt(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_taxi_receipt, null, data, null);
+
+            return result;
+        }
+
+ 	    /**
+         * 
+         * 出租车票识别
+         * @param image 发票图像URL地址 
+         * options 可选参数:
+         */
+        Json::Value taxiReceiptUrl(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["url"] = image;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_taxi_receipt, null, data, null);
+
+            return result;
+        }
+ 
+         /**
+         * 
+         * vin码识别
+         * @param image 图像二进制内容 
+         * options 可选参数:
+         */
+        Json::Value vinCode(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_vin_code, null, data, null);
+
+            return result;
+        }
+
+ 	    /**
+         * 
+         * vin 码识别
+         * @param image 发票图像URL地址 
+         * options 可选参数:
+         */
+        Json::Value vinCodeUrl(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["url"] = image;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_vin_code, null, data, null);
+
+            return result;
+        }
+ 
+        /**
+         * 
+         * 火车票票识别
+         * @param image 图像二进制内容 
+         * options 可选参数:
+         */
+        Json::Value trainTicket(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_train_ticket, null, data, null);
+
+            return result;
+        }
+
+ 	    /**
+         * 
+         * 火车票票识别
+         * @param image 发票图像URL地址 
+         * options 可选参数:
+         */
+        Json::Value trainTicketUrl(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["url"] = image;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_train_ticket, null, data, null);
+
+            return result;
+        }
+        /**
+         * 
+         * 数字识别
+         * @param image 图像二进制内容 
+         * options 可选参数:
+         */
+        Json::Value numbers(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+            
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_numbers, null, data, null);
+
+            return result;
+        }
+
+
+        /**
+         * 印章识别
+         * 检测并识别合同文件或常用票据中的印章，输出文字内容、印章位置信息以及相关置信度，已支持圆形章、椭圆形章、方形章等常见印章检测与识别
+         * @param image 二进制图像数据
+         * options 可选参数:
+         */
+        Json::Value seal(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_seal, null, data, null);
+
+            return result;
+        }
+
+        /**
+         * 网络图片文字识别（含位置版）
+         * 支持识别艺术字体或背景复杂的文字内容，除文字信息外，还可返回每行文字的位置信息、行置信度，以及单字符内容和位置等。
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度
+         * probability 是否返回每行识别结果的置信度。默认为false
+         * poly_location 是否返回文字所在区域的外接四边形的4个点坐标信息。默认为false
+         * recognize_granularity 是否定位单字符位置，big：不定位单字符位置，默认值；small：定位单字符位置
+         */
+        Json::Value webimageloc(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_webimage_loc, null, data, null);
+
+            return result;
+        }
+
+        /**
+         * 网络图片文字识别（含位置版）
+         * 支持识别艺术字体或背景复杂的文字内容，除文字信息外，还可返回每行文字的位置信息、行置信度，以及单字符内容和位置等。
+         * @param url 图片完整URL
+         * options 可选参数:
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度
+         * probability 是否返回每行识别结果的置信度。默认为false
+         * poly_location 是否返回文字所在区域的外接四边形的4个点坐标信息。默认为false
+         * recognize_granularity 是否定位单字符位置，big：不定位单字符位置，默认值；small：定位单字符位置
+         */
+        Json::Value webimagelocurl(
+            std::string const & url,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+
+            data["url"] = url;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_webimage_loc, null, data, null);
+
+            return result;
+        }
+
+        /**
+         * 仪器仪表盘读数识别
+         * 适用于不同品牌、不同型号的仪器仪表盘读数识别，广泛适用于各类血糖仪、血压仪、燃气表、电表等，可识别表盘上的数字、英文、符号，支持液晶屏、字轮表等表型。
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * probability 是否返回每行识别结果的置信度。默认为false
+         * poly_location 位置信息返回形式，默认：false
+         */
+        Json::Value meter(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_meter, null, data, null);
+
+            return result;
+        }
+
+        /**
+         * 试卷分析与识别
+         * 可对文档版面进行分析，输出图、表、标题、文本的位置，并输出分版块内容的OCR识别结果，支持中、英两种语言，手写、印刷体混排多种场景
+         * @param url 图片url
+         * options 可选参数:
+         * language_type 识别语言类型，默认为CHN_ENG 可选值包括：CHN_ENG：中英文 ENG：英文
+         * result_type 返回识别结果是按单行结果返回，还是按单字结果返回，默认为big。
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度
+         * line_probability 是否返回每行识别结果的置信度。默认为false
+         * words_type 文字类型。默认：印刷文字识别
+         * layout_analysis 是否分析文档版面：包括图、表、标题、段落的分析输出
+         */
+        Json::Value docanalysisurl(
+            std::string const & url,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+
+            data["url"] = url;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_doc_analysis, null, data, null);
+
+            return result;
+        }
+
+        /**
+         * 手写文字识别
+         * 支持对图片中的手写中文、手写数字进行检测和识别，针对不规则的手写字体进行专项优化，识别准确率可达90%以上
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * recognize_granularity 是否定位单字符位置，big：不定位单字符位置，默认值；small：定位单字符位置
+         * probability 是否返回识别结果中每一行的置信度，默认为false，不返回置信度
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度。可选值包括
+         */
+        Json::Value handwriting(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_handwriting, null, data, null);
+
+            return result;
+        }
+
+        /**
+         * 办公文档识别
+         * 可对办公类文档版面进行分析，输出图、表、标题、文本的位置，并输出分版块内容的OCR识别结果，支持中、英两种语言，手写、印刷体混排多种场景。
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * language_type 识别语言类型，默认为CHN_ENG 可选值包括：CHN_ENG：中英文 ENG：英文
+         * result_type 返回识别结果是按单行结果返回，还是按单字结果返回，默认为big。
+         * detect_direction 是否检测图像朝向，默认不检测，即：false。朝向是指输入图像是正常方向、逆时针旋转90/180/270度
+         * line_probability 是否返回每行识别结果的置信度。默认为false
+         * words_type 文字类型。默认：印刷文字识别
+         * layout_analysis 是否分析文档版面：包括图、表、标题、段落的分析输出
+         * erase_seal 是否先擦除水印、印章后再识别文档
+         */
+        Json::Value docanalysisoffice(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_doc_analysis_office, null, data, null);
+
+            return result;
+        }
+
+        /**
+         * 二维码识别
+         * 对图片中的二维码、条形码进行检测和识别，返回存储的文字信息
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * recognize_granularity 是否定位单字符位置，big：不定位单字符位置，默认值；small：定位单字符位置&probability
+         */
+        Json::Value qrcode(
+            std::string const & image,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_qrcode, null, data, null);
+
+            return result;
+        }
+
+        /**
+         * 仪器仪表盘读数识别
+         * 适用于不同品牌、不同型号的仪器仪表盘读数识别，广泛适用于各类血糖仪、血压仪、燃气表、电表等，可识别表盘上的数字、英文、符号，支持液晶屏、字轮表等表型。
+         * @param url 图像url地址
+         * options 可选参数:
+         * probability 是否返回每行识别结果的置信度。默认为false
+         * poly_location 位置信息返回形式，默认：false
+         */
+        Json::Value meterurl(
+            std::string const & url,
+            const std::map<std::string, std::string> & options)
+        {
+            std::map<std::string, std::string> data;
+
+            data["url"] = url;
+
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+
+            Json::Value result =
+                this->request(_meter, null, data, null);
+
+            return result;
+        }
+
+        /**
+         * 二维码识别
+         * 对图片中的二维码、条形码进行检测和识别，返回存储的文字信息
+         * @param url 图片完整URL
+         * options 可选参数:
+
+         */
+        Json::Value qrcodeUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_qrcode, null, data, null);
+            return result;
+        }
+
+        /**
+         * 试卷分析与识别
+         * 支持对车辆合格证的23个关键字段进行结构化识别
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * multi_detect 控制是否开启多航班信息识别功能,默认值：false
+         */
+        Json::Value docAnalysis(
+            std::string  image,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_doc_analysis, null, data, null);
+            return result;
+        }
+
+        /**
+         * 试卷分析与识别
+         * 支持对车辆合格证的23个关键字段进行结构化识别
+         * @param url 图片完整URL
+         * options 可选参数:
+         * multi_detect 控制是否开启多航班信息识别功能,默认值：false
+         */
+        Json::Value docAnalysisUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_doc_analysis, null, data, null);
+            return result;
+        }
+
+        /**
+         * 机动车销售发票
+         * 支持对机动车销售发票的26个关键字段进行结构化识别，
+         * @param image 二进制图像数据
+         * options 可选参数:
+
+         */
+        Json::Value vehicleInvoice(
+            std::string  image,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_vehicle_invoice, null, data, null);
+            return result;
+        }
+
+        /**
+         * 机动车销售发票
+         * 支持对机动车销售发票的26个关键字段进行结构化识别，
+         * @param url 图片完整URL
+         * options 可选参数:
+
+         */
+        Json::Value vehicleInvoiceUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_vehicle_invoice, null, data, null);
+            return result;
+        }
+
+        /**
+         * 车辆合格证
+         * 支持对车辆合格证的23个关键字段进行结构化识别，包括合格证编号、发证日期、车辆制造企业名、车辆品牌、车辆名称、车辆型号、车架号、车身颜色、
+         发动机型号、发动机号、燃料种类、排量、功率、排放标准、轮胎数、轴距、轴数、转向形式、总质量、整备质量、驾驶室准乘人数、最高设计车速、车辆制造日期
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * language_type 识别语言类型，默认为CHN_ENG         * result_type 返回识别结果是按单行结果返回，还是按单字结果返回，默认为big         
+         * detect_direction 是否检测图像朝向，默认不检测，即：false         * line_probability 是否返回每行识别结果的置信度。默认为false        
+          * words_type 文字类型。
+         */
+        Json::Value vehicleCertificate(
+            std::string  image,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_vehicle_certificate, null, data, null);
+            return result;
+        }
+
+        /**
+         * 车辆合格证
+         * 支持对车辆合格证的23个关键字段进行结构化识别，包括合格证编号、发证日期、车辆制造企业名、车辆品牌、车辆名称、车辆型号、车架号、车身颜色、发动机型号
+         、发动机号、燃料种类、排量、功率、排放标准、轮胎数、轴距、轴数、转向形式、总质量、整备质量、驾驶室准乘人数、最高设计车速、车辆制造日期
+         * @param url 图片完整URL
+         * options 可选参数:
+         * language_type 识别语言类型，默认为CHN_ENG         * result_type 返回识别结果是按单行结果返回，还是按单字结果返回，默认为big         
+         * detect_direction 是否检测图像朝向，默认不检测，即：false         * line_probability 是否返回每行识别结果的置信度。默认为false        
+          * words_type 文字类型。
+         */
+        Json::Value vehicleCertificateUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_vehicle_certificate, null, data, null);
+            return result;
+        }
+
+        /**
+         * 户口本识别
+         * 支持对户口本内常住人口登记卡的全部 22 个字段进行结构化识别，
+         * @param image 二进制图像数据
+         * options 可选参数:
+
+         */
+        Json::Value householdRegister(
+            std::string  image,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_household_register, null, data, null);
+            return result;
+        }
+
+        /**
+         * 户口本识别
+         * 支持对户口本内常住人口登记卡的全部 22 个字段进行结构化识别，
+         * @param url 图片完整URL
+         * options 可选参数:
+
+         */
+        Json::Value householdRegisterUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_household_register, null, data, null);
+            return result;
+        }
+
+        /**
+         * 手写文字识别
+         * 支持对图片中的手写中文、手写数字进行检测和识别，
+         * @param url 图片完整URL
+         * options 可选参数:
+         * recognize_granularity 是否定位单字符位置，         * probability 是否返回识别结果中每一行的置信度，默认为false，不返回置信度         
+         * detect_direction 是否检测图像朝向，默认不检测，即：false
+         */
+        Json::Value handwritingUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_handwriting, null, data, null);
+            return result;
+        }
+
+        /**
+         * 飞机行程单识别
+         * 支持对飞机行程单的24个字段进行结构化识别，包括电子客票号、印刷序号、姓名、始发站、目的站、航班号、日期、时间、票价、身份证号、承运人、民航发展基金、
+         保险费、燃油附加费、其他税费、合计金额、填开日期、订票渠道、客票级别、座位等级、销售单位号、签注、免费行李、验证码。 同时，支持单张行程单上的多航班信息识别。
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * multi_detect 控制是否开启多航班信息识别功能,默认值：false
+         */
+        Json::Value airTicket(
+            std::string  image,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_air_ticket, null, data, null);
+            return result;
+        }
+
+        /**
+         * 飞机行程单识别
+         * 支持对飞机行程单的24个字段进行结构化识别，包括电子客票号、印刷序号、姓名、始发站、目的站、航班号、日期、时间、票价、身份证号、承运人、
+         民航发展基金、保险费、燃油附加费、其他税费、合计金额、填开日期、订票渠道、客票级别、座位等级、销售单位号、签注、免费行李、验证码。 同时，
+         支持单张行程单上的多航班信息识别。
+         * @param url 图片完整URL
+         * options 可选参数:
+         * multi_detect 控制是否开启多航班信息识别功能,默认值：false
+         */
+        Json::Value airTicketUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_air_ticket, null, data, null);
+            return result;
+        }
+
+        /**
+         * 通用机打发票
+         * 支持对图片中的手写中文、手写数字进行检测和识别，
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * location 是否输出位置信息，true：输出位置信息，false：不输出位置信息，默认false
+         */
+        Json::Value invoice(
+            std::string  image,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_invoice, null, data, null);
+            return result;
+        }
+
+        /**
+         * 通用机打发票
+         * 支持对图片中的手写中文、手写数字进行检测和识别，
+         * @param url 图片完整URL
+         * options 可选参数:
+         * location 是否输出位置信息，true：输出位置信息，false：不输出位置信息，默认false
+         */
+        Json::Value invoiceUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_invoice, null, data, null);
+            return result;
+        }
+
+        /**
+         * 护照识别
+         * 支持对图片中的手写中文、手写数字进行检测和识别，
+         * @param image 二进制图像数据
+         * options 可选参数:
+
+         */
+        Json::Value passport(
+            std::string  image,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_passport, null, data, null);
+            return result;
+        }
+
+        /**
+         * 护照识别
+         * 支持对图片中的手写中文、手写数字进行检测和识别，
+         * @param url 图片完整URL
+         * options 可选参数:
+
+         */
+        Json::Value passportUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_passport, null, data, null);
+            return result;
+        }
+
+        /**
+         * 网约车行程单识别
+         * 对各大主要服务商的网约车行程单进行结构化识别，包括滴滴打车、花小猪打车、高德地图、曹操出行、阳光出行，支持识别服务商、
+        行程开始时间、行程结束时间、车型、总金额等16 个关键字段。
+    
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * pdf_file_num 需要识别的PDF文件的对应页码，当 pdf_file 参数有效时，识别传入页码的对应页面内容，若不传入，则默认识别第 1 页
+         */
+        Json::Value onlineTaxiItinerary(
+            std::string  image)
+        {
+            std::map<std::string, std::string> data;
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            Json::Value result =
+                this->request(_online_taxi_itinerary, null, data, null);
+            return result;
+        }
+
+        /**
+         * 网约车行程单识别
+         * 对各大主要服务商的网约车行程单进行结构化识别，包括滴滴打车、花小猪打车、高德地图、曹操出行、阳光出行，支持识别服务商、
+        行程开始时间、行程结束时间、车型、总金额等16 个关键字段。
+    
+         * @param url 图片完整URL路径
+         * options 可选参数:
+         * pdf_file_num 需要识别的PDF文件的对应页码，当 pdf_file 参数有效时，识别传入页码的对应页面内容，若不传入，则默认识别第 1 页
+         */
+        Json::Value onlineTaxiItineraryUrl(
+            std::string  url)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            Json::Value result =
+                this->request(_online_taxi_itinerary, null, data, null);
+            return result;
+        }
+
+        /**
+         * 网约车行程单识别
+         * 对各大主要服务商的网约车行程单进行结构化识别，包括滴滴打车、花小猪打车、高德地图、曹操出行、阳光出行，支持识别服务商、
+        行程开始时间、行程结束时间、车型、总金额等16 个关键字段。
+    
+         * @param pdf_file pdf文件二进制数据
+         * options 可选参数:
+         * pdf_file_num 需要识别的PDF文件的对应页码，当 pdf_file 参数有效时，识别传入页码的对应页面内容，若不传入，则默认识别第 1 页
+         */
+        Json::Value onlineTaxiItineraryPdf(
+            std::string  pdf_file,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["pdf_file"] = base64_encode(pdf_file.c_str(), (int) pdf_file.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_online_taxi_itinerary, null, data, null);
+            return result;
+        }
+
+        /**
+         * 磅单识别
+         * 结构化识别磅单的车牌号、打印时间、毛重、皮重、净重、发货单位、收货单位、单号8个关键字段，现阶段仅支持识别印刷体磅单
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * pdf_file_num 需要识别的PDF文件的对应页码，当 pdf_file 参数有效时，识别传入页码的对应页面内容，若不传入，则默认识别第 1 页         * probability 是否返回字段识别结果的置信度，默认为 false，可缺省
+                - false：不返回字段识别结果的置信度
+                - true：返回字段识别结果的置信度，包括字段识别结果中各字符置信度的平均值（average）和最小值（min）
+            
+         */
+        Json::Value weightNote(
+            std::string  image,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_weight_note, null, data, null);
+            return result;
+        }
+
+        /**
+         * 磅单识别
+         * 结构化识别磅单的车牌号、打印时间、毛重、皮重、净重、发货单位、收货单位、单号8个关键字段，现阶段仅支持识别印刷体磅单
+         * @param url 图片完整URL路径
+         * options 可选参数:
+         * pdf_file_num 需要识别的PDF文件的对应页码，当 pdf_file 参数有效时，识别传入页码的对应页面内容，若不传入，则默认识别第 1 页         * probability 是否返回字段识别结果的置信度，默认为 false，可缺省
+                - false：不返回字段识别结果的置信度
+                - true：返回字段识别结果的置信度，包括字段识别结果中各字符置信度的平均值（average）和最小值（min）
+            
+         */
+        Json::Value weightNoteUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_weight_note, null, data, null);
+            return result;
+        }
+
+        /**
+         * 磅单识别
+         * 结构化识别磅单的车牌号、打印时间、毛重、皮重、净重、发货单位、收货单位、单号8个关键字段，现阶段仅支持识别印刷体磅单
+         * @param pdf_file 图片完整URL路径
+         * options 可选参数:
+         * pdf_file_num 需要识别的PDF文件的对应页码，当 pdf_file 参数有效时，识别传入页码的对应页面内容，若不传入，则默认识别第 1 页         * probability 是否返回字段识别结果的置信度，默认为 false，可缺省
+                - false：不返回字段识别结果的置信度
+                - true：返回字段识别结果的置信度，包括字段识别结果中各字符置信度的平均值（average）和最小值（min）
+            
+         */
+        Json::Value weightNotePdf(
+            std::string  pdf_file,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["pdf_file"] = base64_encode(pdf_file.c_str(), (int) pdf_file.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_weight_note, null, data, null);
+            return result;
+        }
+
+        /**
+         * 医疗费用明细识别
+         * 支持识别全国医疗费用明细的姓名、日期、病人ID、总金额等关键字段，支持识别费用明细项目清单，包含项目类型、项目名称、
+        单价、数量、规格、金额，其中北京地区识别效果最佳。
+    
+         * @param image 二进制图像数据
+         * options 可选参数:
+         * location 是否返回字段的位置信息，默认为 false，可缺省
+                - false：不返回字段位置信息
+                - true：返回字段的位置信息，包括上边距（top）、左边距（left）、宽度（width）、高度（height）
+                     * probability 是否返回字段识别结果的置信度，默认为 false，可缺省
+                - false：不返回字段识别结果的置信度
+                - true：返回字段识别结果的置信度，包括字段识别结果中各字符置信度的平均值（average）和最小值（min）
+            
+         */
+        Json::Value medicalDetail(
+            std::string  image,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["image"] = base64_encode(image.c_str(), (int) image.size());
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_medical_detail, null, data, null);
+            return result;
+        }
+
+        /**
+         * 医疗费用明细识别
+         * 支持识别全国医疗费用明细的姓名、日期、病人ID、总金额等关键字段，支持识别费用明细项目清单，包含项目类型、项目名称、
+        单价、数量、规格、金额，其中北京地区识别效果最佳。
+    
+         * @param url 图片完整URL路径
+         * options 可选参数:
+         * location 是否返回字段的位置信息，默认为 false，可缺省
+                - false：不返回字段位置信息
+                - true：返回字段的位置信息，包括上边距（top）、左边距（left）、宽度（width）、高度（height）
+                     * probability 是否返回字段识别结果的置信度，默认为 false，可缺省
+                - false：不返回字段识别结果的置信度
+                - true：返回字段识别结果的置信度，包括字段识别结果中各字符置信度的平均值（average）和最小值（min）
+            
+         */
+        Json::Value medicalDetailUrl(
+            std::string  url,
+            std::map<std::string, std::string>  options)
+        {
+            std::map<std::string, std::string> data;
+            data["url"] = url;
+            std::copy(options.begin(), options.end(), std::inserter(data, data.end()));
+            Json::Value result =
+                this->request(_medical_detail, null, data, null);
+            return result;
+        }
+    };
+}
+#endif