1585346868/aliyun-openapi-cpp-sdk
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Release RecognizeUkraineIdentityCard.

Browse Source
This commit is contained in:
sdk-team
2022-05-05 10:22:24 +00:00
parent d175c6ad31
commit 278c4950d0
88 changed files with 2635 additions and 2470 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
ocr/CMakeLists.txt
View File

@@ -45,10 +45,10 @@ set(ocr_public_header_model
include/alibabacloud/ocr/model/RecognizeIdentityCardResult.h
include/alibabacloud/ocr/model/RecognizeLicensePlateRequest.h
include/alibabacloud/ocr/model/RecognizeLicensePlateResult.h
include/alibabacloud/ocr/model/RecognizePDFRequest.h
include/alibabacloud/ocr/model/RecognizePDFResult.h
include/alibabacloud/ocr/model/RecognizePassportMRZRequest.h
include/alibabacloud/ocr/model/RecognizePassportMRZResult.h
include/alibabacloud/ocr/model/RecognizePdfRequest.h
include/alibabacloud/ocr/model/RecognizePdfResult.h
include/alibabacloud/ocr/model/RecognizePoiNameRequest.h
include/alibabacloud/ocr/model/RecognizePoiNameResult.h
include/alibabacloud/ocr/model/RecognizeQrCodeRequest.h
@@ -67,6 +67,8 @@ set(ocr_public_header_model
include/alibabacloud/ocr/model/RecognizeTicketInvoiceResult.h
include/alibabacloud/ocr/model/RecognizeTrainTicketRequest.h
include/alibabacloud/ocr/model/RecognizeTrainTicketResult.h
include/alibabacloud/ocr/model/RecognizeUkraineIdentityCardRequest.h
include/alibabacloud/ocr/model/RecognizeUkraineIdentityCardResult.h
include/alibabacloud/ocr/model/RecognizeVATInvoiceRequest.h
include/alibabacloud/ocr/model/RecognizeVATInvoiceResult.h
include/alibabacloud/ocr/model/RecognizeVINCodeRequest.h
@@ -106,10 +108,10 @@ set(ocr_src
src/model/RecognizeIdentityCardResult.cc
src/model/RecognizeLicensePlateRequest.cc
src/model/RecognizeLicensePlateResult.cc
src/model/RecognizePDFRequest.cc
src/model/RecognizePDFResult.cc
src/model/RecognizePassportMRZRequest.cc
src/model/RecognizePassportMRZResult.cc
src/model/RecognizePdfRequest.cc
src/model/RecognizePdfResult.cc
src/model/RecognizePoiNameRequest.cc
src/model/RecognizePoiNameResult.cc
src/model/RecognizeQrCodeRequest.cc
@@ -128,6 +130,8 @@ set(ocr_src
src/model/RecognizeTicketInvoiceResult.cc
src/model/RecognizeTrainTicketRequest.cc
src/model/RecognizeTrainTicketResult.cc
src/model/RecognizeUkraineIdentityCardRequest.cc
src/model/RecognizeUkraineIdentityCardResult.cc
src/model/RecognizeVATInvoiceRequest.cc
src/model/RecognizeVATInvoiceResult.cc
src/model/RecognizeVINCodeRequest.cc

24
ocr/include/alibabacloud/ocr/OcrClient.h
View File

@@ -46,10 +46,10 @@
#include "model/RecognizeIdentityCardResult.h"
#include "model/RecognizeLicensePlateRequest.h"
#include "model/RecognizeLicensePlateResult.h"
#include "model/RecognizePDFRequest.h"
#include "model/RecognizePDFResult.h"
#include "model/RecognizePassportMRZRequest.h"
#include "model/RecognizePassportMRZResult.h"
#include "model/RecognizePdfRequest.h"
#include "model/RecognizePdfResult.h"
#include "model/RecognizePoiNameRequest.h"
#include "model/RecognizePoiNameResult.h"
#include "model/RecognizeQrCodeRequest.h"
@@ -68,6 +68,8 @@
#include "model/RecognizeTicketInvoiceResult.h"
#include "model/RecognizeTrainTicketRequest.h"
#include "model/RecognizeTrainTicketResult.h"
#include "model/RecognizeUkraineIdentityCardRequest.h"
#include "model/RecognizeUkraineIdentityCardResult.h"
#include "model/RecognizeVATInvoiceRequest.h"
#include "model/RecognizeVATInvoiceResult.h"
#include "model/RecognizeVINCodeRequest.h"
@@ -125,12 +127,12 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RecognizeLicensePlateResult> RecognizeLicensePlateOutcome;
typedef std::future<RecognizeLicensePlateOutcome> RecognizeLicensePlateOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeLicensePlateRequest&, const RecognizeLicensePlateOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeLicensePlateAsyncHandler;
typedef Outcome<Error, Model::RecognizePDFResult> RecognizePDFOutcome;
typedef std::future<RecognizePDFOutcome> RecognizePDFOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizePDFRequest&, const RecognizePDFOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizePDFAsyncHandler;
typedef Outcome<Error, Model::RecognizePassportMRZResult> RecognizePassportMRZOutcome;
typedef std::future<RecognizePassportMRZOutcome> RecognizePassportMRZOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizePassportMRZRequest&, const RecognizePassportMRZOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizePassportMRZAsyncHandler;
typedef Outcome<Error, Model::RecognizePdfResult> RecognizePdfOutcome;
typedef std::future<RecognizePdfOutcome> RecognizePdfOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizePdfRequest&, const RecognizePdfOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizePdfAsyncHandler;
typedef Outcome<Error, Model::RecognizePoiNameResult> RecognizePoiNameOutcome;
typedef std::future<RecognizePoiNameOutcome> RecognizePoiNameOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizePoiNameRequest&, const RecognizePoiNameOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizePoiNameAsyncHandler;
@@ -158,6 +160,9 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RecognizeTrainTicketResult> RecognizeTrainTicketOutcome;
typedef std::future<RecognizeTrainTicketOutcome> RecognizeTrainTicketOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeTrainTicketRequest&, const RecognizeTrainTicketOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeTrainTicketAsyncHandler;
typedef Outcome<Error, Model::RecognizeUkraineIdentityCardResult> RecognizeUkraineIdentityCardOutcome;
typedef std::future<RecognizeUkraineIdentityCardOutcome> RecognizeUkraineIdentityCardOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeUkraineIdentityCardRequest&, const RecognizeUkraineIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeUkraineIdentityCardAsyncHandler;
typedef Outcome<Error, Model::RecognizeVATInvoiceResult> RecognizeVATInvoiceOutcome;
typedef std::future<RecognizeVATInvoiceOutcome> RecognizeVATInvoiceOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeVATInvoiceRequest&, const RecognizeVATInvoiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVATInvoiceAsyncHandler;
@@ -217,12 +222,12 @@ namespace AlibabaCloud
RecognizeLicensePlateOutcome recognizeLicensePlate(const Model::RecognizeLicensePlateRequest &request)const;
void recognizeLicensePlateAsync(const Model::RecognizeLicensePlateRequest& request, const RecognizeLicensePlateAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeLicensePlateOutcomeCallable recognizeLicensePlateCallable(const Model::RecognizeLicensePlateRequest& request) const;
RecognizePDFOutcome recognizePDF(const Model::RecognizePDFRequest &request)const;
void recognizePDFAsync(const Model::RecognizePDFRequest& request, const RecognizePDFAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizePDFOutcomeCallable recognizePDFCallable(const Model::RecognizePDFRequest& request) const;
RecognizePassportMRZOutcome recognizePassportMRZ(const Model::RecognizePassportMRZRequest &request)const;
void recognizePassportMRZAsync(const Model::RecognizePassportMRZRequest& request, const RecognizePassportMRZAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizePassportMRZOutcomeCallable recognizePassportMRZCallable(const Model::RecognizePassportMRZRequest& request) const;
RecognizePdfOutcome recognizePdf(const Model::RecognizePdfRequest &request)const;
void recognizePdfAsync(const Model::RecognizePdfRequest& request, const RecognizePdfAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizePdfOutcomeCallable recognizePdfCallable(const Model::RecognizePdfRequest& request) const;
RecognizePoiNameOutcome recognizePoiName(const Model::RecognizePoiNameRequest &request)const;
void recognizePoiNameAsync(const Model::RecognizePoiNameRequest& request, const RecognizePoiNameAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizePoiNameOutcomeCallable recognizePoiNameCallable(const Model::RecognizePoiNameRequest& request) const;
@@ -250,6 +255,9 @@ namespace AlibabaCloud
RecognizeTrainTicketOutcome recognizeTrainTicket(const Model::RecognizeTrainTicketRequest &request)const;
void recognizeTrainTicketAsync(const Model::RecognizeTrainTicketRequest& request, const RecognizeTrainTicketAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeTrainTicketOutcomeCallable recognizeTrainTicketCallable(const Model::RecognizeTrainTicketRequest& request) const;
RecognizeUkraineIdentityCardOutcome recognizeUkraineIdentityCard(const Model::RecognizeUkraineIdentityCardRequest &request)const;
void recognizeUkraineIdentityCardAsync(const Model::RecognizeUkraineIdentityCardRequest& request, const RecognizeUkraineIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeUkraineIdentityCardOutcomeCallable recognizeUkraineIdentityCardCallable(const Model::RecognizeUkraineIdentityCardRequest& request) const;
RecognizeVATInvoiceOutcome recognizeVATInvoice(const Model::RecognizeVATInvoiceRequest &request)const;
void recognizeVATInvoiceAsync(const Model::RecognizeVATInvoiceRequest& request, const RecognizeVATInvoiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVATInvoiceOutcomeCallable recognizeVATInvoiceCallable(const Model::RecognizeVATInvoiceRequest& request) const;

68
ocr/include/alibabacloud/ocr/model/DetectCardScreenshotRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT DetectCardScreenshotRequest : public RpcServiceRequest
{
public:
DetectCardScreenshotRequest();
~DetectCardScreenshotRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT DetectCardScreenshotRequest : public RpcServiceRequest {
public:
DetectCardScreenshotRequest();
~DetectCardScreenshotRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_DETECTCARDSCREENSHOTREQUEST_H_

74
ocr/include/alibabacloud/ocr/model/GetAsyncJobResultRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest
{
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
bool getAsync()const;
void setAsync(bool async);
std::string getJobId()const;
void setJobId(const std::string& jobId);
private:
bool async_;
std::string jobId_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_GETASYNCJOBRESULTREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_GETASYNCJOBRESULTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_GETASYNCJOBRESULTREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT GetAsyncJobResultRequest : public RpcServiceRequest {
public:
GetAsyncJobResultRequest();
~GetAsyncJobResultRequest();
std::string getJobId() const;
void setJobId(const std::string &jobId);
bool getAsync() const;
void setAsync(bool async);
private:
std::string jobId_;
bool async_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_GETASYNCJOBRESULTREQUEST_H_

74
ocr/include/alibabacloud/ocr/model/RecognizeAccountPageRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEACCOUNTPAGEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEACCOUNTPAGEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeAccountPageRequest : public RpcServiceRequest
{
public:
RecognizeAccountPageRequest();
~RecognizeAccountPageRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEACCOUNTPAGEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEACCOUNTPAGEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEACCOUNTPAGEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeAccountPageRequest : public RpcServiceRequest {
public:
RecognizeAccountPageRequest();
~RecognizeAccountPageRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEACCOUNTPAGEREQUEST_H_

18
ocr/include/alibabacloud/ocr/model/RecognizeAccountPageResult.h
View File

@@ -41,7 +41,14 @@ namespace AlibabaCloud
int height;
int width;
};
struct InvalidStampArea
struct RegisterStampArea
{
int left;
int top;
int height;
int width;
};
struct OtherStampArea
{
int left;
int top;
@@ -55,14 +62,7 @@ namespace AlibabaCloud
int height;
int width;
};
struct RegisterStampArea
{
int left;
int top;
int height;
int width;
};
struct OtherStampArea
struct InvalidStampArea
{
int left;
int top;

74
ocr/include/alibabacloud/ocr/model/RecognizeBankCardRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEBANKCARDREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEBANKCARDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeBankCardRequest : public RpcServiceRequest
{
public:
RecognizeBankCardRequest();
~RecognizeBankCardRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEBANKCARDREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEBANKCARDREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEBANKCARDREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeBankCardRequest : public RpcServiceRequest {
public:
RecognizeBankCardRequest();
~RecognizeBankCardRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEBANKCARDREQUEST_H_

74
ocr/include/alibabacloud/ocr/model/RecognizeBusinessCardRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSCARDREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSCARDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeBusinessCardRequest : public RpcServiceRequest
{
public:
RecognizeBusinessCardRequest();
~RecognizeBusinessCardRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSCARDREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSCARDREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSCARDREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeBusinessCardRequest : public RpcServiceRequest {
public:
RecognizeBusinessCardRequest();
~RecognizeBusinessCardRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSCARDREQUEST_H_

74
ocr/include/alibabacloud/ocr/model/RecognizeBusinessLicenseRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSLICENSEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSLICENSEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeBusinessLicenseRequest : public RpcServiceRequest
{
public:
RecognizeBusinessLicenseRequest();
~RecognizeBusinessLicenseRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSLICENSEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSLICENSEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSLICENSEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeBusinessLicenseRequest : public RpcServiceRequest {
public:
RecognizeBusinessLicenseRequest();
~RecognizeBusinessLicenseRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSLICENSEREQUEST_H_

95
ocr/include/alibabacloud/ocr/model/RecognizeCharacterRequest.h
View File

@@ -1,66 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeCharacterRequest : public RpcServiceRequest
{
public:
RecognizeCharacterRequest();
~RecognizeCharacterRequest();
bool getFormatResultToJson()const;
void setFormatResultToJson(bool formatResultToJson);
int getMinHeight()const;
void setMinHeight(int minHeight);
std::string getOssFile()const;
void setOssFile(const std::string& ossFile);
int getImageType()const;
void setImageType(int imageType);
std::string getRequestProxyBy()const;
void setRequestProxyBy(const std::string& requestProxyBy);
bool getOutputProbability()const;
void setOutputProbability(bool outputProbability);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
bool formatResultToJson_;
int minHeight_;
std::string ossFile_;
int imageType_;
std::string requestProxyBy_;
bool outputProbability_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeCharacterRequest : public RpcServiceRequest {
public:
RecognizeCharacterRequest();
~RecognizeCharacterRequest();
int getMinHeight() const;
void setMinHeight(int minHeight);
int getImageType() const;
void setImageType(int imageType);
bool getOutputProbability() const;
void setOutputProbability(bool outputProbability);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int minHeight_;
int imageType_;
bool outputProbability_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_

68
ocr/include/alibabacloud/ocr/model/RecognizeChinapassportRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZECHINAPASSPORTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZECHINAPASSPORTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeChinapassportRequest : public RpcServiceRequest
{
public:
RecognizeChinapassportRequest();
~RecognizeChinapassportRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZECHINAPASSPORTREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZECHINAPASSPORTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZECHINAPASSPORTREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeChinapassportRequest : public RpcServiceRequest {
public:
RecognizeChinapassportRequest();
~RecognizeChinapassportRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZECHINAPASSPORTREQUEST_H_

4
ocr/include/alibabacloud/ocr/model/RecognizeChinapassportResult.h
View File

@@ -42,15 +42,15 @@ namespace AlibabaCloud
std::string authority;
std::string sex;
std::string issueDate;
std::string birthDay;
std::string lineZero;
std::string birthDay;
std::string issuePlace;
std::string expiryDay;
bool success;
std::string name;
std::string lineOne;
std::string nameChinese;
std::string type;
std::string nameChinese;
std::string personId;
std::string passportNo;
std::string birthPlaceRaw;

80
ocr/include/alibabacloud/ocr/model/RecognizeDriverLicenseRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeDriverLicenseRequest : public RpcServiceRequest
{
public:
RecognizeDriverLicenseRequest();
~RecognizeDriverLicenseRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getSide()const;
void setSide(const std::string& side);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeDriverLicenseRequest : public RpcServiceRequest {
public:
RecognizeDriverLicenseRequest();
~RecognizeDriverLicenseRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getSide() const;
void setSide(const std::string &side);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSEREQUEST_H_

80
ocr/include/alibabacloud/ocr/model/RecognizeDrivingLicenseRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeDrivingLicenseRequest : public RpcServiceRequest
{
public:
RecognizeDrivingLicenseRequest();
~RecognizeDrivingLicenseRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getSide()const;
void setSide(const std::string& side);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeDrivingLicenseRequest : public RpcServiceRequest {
public:
RecognizeDrivingLicenseRequest();
~RecognizeDrivingLicenseRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getSide() const;
void setSide(const std::string &side);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSEREQUEST_H_

80
ocr/include/alibabacloud/ocr/model/RecognizeIdentityCardRequest.h
View File

@@ -1,54 +1,48 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeIdentityCardRequest : public RpcServiceRequest
{
public:
RecognizeIdentityCardRequest();
~RecognizeIdentityCardRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getSide()const;
void setSide(const std::string& side);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeIdentityCardRequest : public RpcServiceRequest {
public:
RecognizeIdentityCardRequest();
~RecognizeIdentityCardRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getSide() const;
void setSide(const std::string &side);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string side_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDREQUEST_H_

74
ocr/include/alibabacloud/ocr/model/RecognizeLicensePlateRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZELICENSEPLATEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZELICENSEPLATEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeLicensePlateRequest : public RpcServiceRequest
{
public:
RecognizeLicensePlateRequest();
~RecognizeLicensePlateRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZELICENSEPLATEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZELICENSEPLATEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZELICENSEPLATEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeLicensePlateRequest : public RpcServiceRequest {
public:
RecognizeLicensePlateRequest();
~RecognizeLicensePlateRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZELICENSEPLATEREQUEST_H_

68
ocr/include/alibabacloud/ocr/model/RecognizePassportMRZRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEPASSPORTMRZREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEPASSPORTMRZREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizePassportMRZRequest : public RpcServiceRequest
{
public:
RecognizePassportMRZRequest();
~RecognizePassportMRZRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEPASSPORTMRZREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEPASSPORTMRZREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEPASSPORTMRZREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizePassportMRZRequest : public RpcServiceRequest {
public:
RecognizePassportMRZRequest();
~RecognizePassportMRZRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEPASSPORTMRZREQUEST_H_

2
ocr/include/alibabacloud/ocr/model/RecognizePassportMRZResult.h
View File

@@ -39,8 +39,8 @@ namespace AlibabaCloud
std::string content;
float recognitionScore;
std::vector<std::string> bandBoxes;
std::string name;
float detectionScore;
std::string name;
};
std::vector<Region> regions;
};

68
ocr/include/alibabacloud/ocr/model/RecognizePDFRequest.h → ocr/include/alibabacloud/ocr/model/RecognizePdfRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEPDFREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEPDFREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizePDFRequest : public RpcServiceRequest
{
public:
RecognizePDFRequest();
~RecognizePDFRequest();
std::string getFileURL()const;
void setFileURL(const std::string& fileURL);
private:
std::string fileURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEPDFREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEPDFREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEPDFREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizePdfRequest : public RpcServiceRequest {
public:
RecognizePdfRequest();
~RecognizePdfRequest();
std::string getFileURL() const;
void setFileURL(const std::string &fileURL);
private:
std::string fileURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEPDFREQUEST_H_

8
ocr/include/alibabacloud/ocr/model/RecognizePDFResult.h → ocr/include/alibabacloud/ocr/model/RecognizePdfResult.h
View File

@@ -29,7 +29,7 @@ namespace AlibabaCloud
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizePDFResult : public ServiceResult
class ALIBABACLOUD_OCR_EXPORT RecognizePdfResult : public ServiceResult
{
public:
struct Data
@@ -59,9 +59,9 @@ namespace AlibabaCloud
};
RecognizePDFResult();
explicit RecognizePDFResult(const std::string &payload);
~RecognizePDFResult();
RecognizePdfResult();
explicit RecognizePdfResult(const std::string &payload);
~RecognizePdfResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;

68
ocr/include/alibabacloud/ocr/model/RecognizePoiNameRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizePoiNameRequest : public RpcServiceRequest
{
public:
RecognizePoiNameRequest();
~RecognizePoiNameRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizePoiNameRequest : public RpcServiceRequest {
public:
RecognizePoiNameRequest();
~RecognizePoiNameRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEPOINAMEREQUEST_H_

2
ocr/include/alibabacloud/ocr/model/RecognizePoiNameResult.h
View File

@@ -43,8 +43,8 @@ namespace AlibabaCloud
{
struct TextsItem
{
float score;
std::string type;
float score;
std::vector<std::string> points;
std::string label;
std::string tag;

85
ocr/include/alibabacloud/ocr/model/RecognizeQrCodeRequest.h
View File

@@ -1,62 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeQrCodeRequest : public RpcServiceRequest
{
public:
struct Tasks
{
std::string imageURL;
};
public:
RecognizeQrCodeRequest();
~RecognizeQrCodeRequest();
bool getFormatResultToJson()const;
void setFormatResultToJson(bool formatResultToJson);
std::string getOssFile()const;
void setOssFile(const std::string& ossFile);
std::vector<Tasks> getTasks()const;
void setTasks(const std::vector<Tasks>& tasks);
std::string getRequestProxyBy()const;
void setRequestProxyBy(const std::string& requestProxyBy);
private:
bool formatResultToJson_;
std::string ossFile_;
std::vector<Tasks> tasks_;
std::string requestProxyBy_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeQrCodeRequest : public RpcServiceRequest {
public:
struct Tasks {
std::string imageURL;
};
RecognizeQrCodeRequest();
~RecognizeQrCodeRequest();
std::vector<Tasks> getTasks() const;
void setTasks(const std::vector<Tasks> &tasks);
private:
std::vector<Tasks> tasks_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_

68
ocr/include/alibabacloud/ocr/model/RecognizeQuotaInvoiceRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEQUOTAINVOICEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEQUOTAINVOICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeQuotaInvoiceRequest : public RpcServiceRequest
{
public:
RecognizeQuotaInvoiceRequest();
~RecognizeQuotaInvoiceRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEQUOTAINVOICEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEQUOTAINVOICEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEQUOTAINVOICEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeQuotaInvoiceRequest : public RpcServiceRequest {
public:
RecognizeQuotaInvoiceRequest();
~RecognizeQuotaInvoiceRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEQUOTAINVOICEREQUEST_H_

74
ocr/include/alibabacloud/ocr/model/RecognizeStampRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZESTAMPREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZESTAMPREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeStampRequest : public RpcServiceRequest
{
public:
RecognizeStampRequest();
~RecognizeStampRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZESTAMPREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZESTAMPREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZESTAMPREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeStampRequest : public RpcServiceRequest {
public:
RecognizeStampRequest();
~RecognizeStampRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZESTAMPREQUEST_H_

10
ocr/include/alibabacloud/ocr/model/RecognizeStampResult.h
View File

@@ -36,6 +36,11 @@ namespace AlibabaCloud
{
struct ResultsItem
{
struct Text
{
float confidence;
std::string content;
};
struct Roi
{
int left;
@@ -43,11 +48,6 @@ namespace AlibabaCloud
int height;
int width;
};
struct Text
{
float confidence;
std::string content;
};
struct GeneralTextItem
{
float confidence;

104
ocr/include/alibabacloud/ocr/model/RecognizeTableRequest.h
View File

@@ -1,66 +1,60 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeTableRequest : public RpcServiceRequest
{
public:
RecognizeTableRequest();
~RecognizeTableRequest();
int getImageType()const;
void setImageType(int imageType);
bool getUseFinanceModel()const;
void setUseFinanceModel(bool useFinanceModel);
bool getSkipDetection()const;
void setSkipDetection(bool skipDetection);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
std::string getOutputFormat()const;
void setOutputFormat(const std::string& outputFormat);
bool getAssureDirection()const;
void setAssureDirection(bool assureDirection);
bool getHasLine()const;
void setHasLine(bool hasLine);
private:
int imageType_;
bool useFinanceModel_;
bool skipDetection_;
std::string imageURL_;
std::string outputFormat_;
bool assureDirection_;
bool hasLine_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeTableRequest : public RpcServiceRequest {
public:
RecognizeTableRequest();
~RecognizeTableRequest();
bool getUseFinanceModel() const;
void setUseFinanceModel(bool useFinanceModel);
bool getSkipDetection() const;
void setSkipDetection(bool skipDetection);
std::string getOutputFormat() const;
void setOutputFormat(const std::string &outputFormat);
bool getAssureDirection() const;
void setAssureDirection(bool assureDirection);
bool getHasLine() const;
void setHasLine(bool hasLine);
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
bool useFinanceModel_;
bool skipDetection_;
std::string outputFormat_;
bool assureDirection_;
bool hasLine_;
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLEREQUEST_H_

68
ocr/include/alibabacloud/ocr/model/RecognizeTakeoutOrderRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETAKEOUTORDERREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETAKEOUTORDERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeTakeoutOrderRequest : public RpcServiceRequest
{
public:
RecognizeTakeoutOrderRequest();
~RecognizeTakeoutOrderRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETAKEOUTORDERREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETAKEOUTORDERREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETAKEOUTORDERREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeTakeoutOrderRequest : public RpcServiceRequest {
public:
RecognizeTakeoutOrderRequest();
~RecognizeTakeoutOrderRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETAKEOUTORDERREQUEST_H_

74
ocr/include/alibabacloud/ocr/model/RecognizeTaxiInvoiceRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETAXIINVOICEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETAXIINVOICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeTaxiInvoiceRequest : public RpcServiceRequest
{
public:
RecognizeTaxiInvoiceRequest();
~RecognizeTaxiInvoiceRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETAXIINVOICEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETAXIINVOICEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETAXIINVOICEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeTaxiInvoiceRequest : public RpcServiceRequest {
public:
RecognizeTaxiInvoiceRequest();
~RecognizeTaxiInvoiceRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETAXIINVOICEREQUEST_H_

10
ocr/include/alibabacloud/ocr/model/RecognizeTaxiInvoiceResult.h
View File

@@ -47,16 +47,16 @@ namespace AlibabaCloud
{
struct ItemRoi
{
struct Center
{
float x;
float y;
};
struct Size
{
float w;
float h;
};
struct Center
{
float x;
float y;
};
Center center;
float angle;
Size size;

68
ocr/include/alibabacloud/ocr/model/RecognizeTicketInvoiceRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETICKETINVOICEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETICKETINVOICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeTicketInvoiceRequest : public RpcServiceRequest
{
public:
RecognizeTicketInvoiceRequest();
~RecognizeTicketInvoiceRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETICKETINVOICEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETICKETINVOICEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETICKETINVOICEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeTicketInvoiceRequest : public RpcServiceRequest {
public:
RecognizeTicketInvoiceRequest();
~RecognizeTicketInvoiceRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETICKETINVOICEREQUEST_H_

74
ocr/include/alibabacloud/ocr/model/RecognizeTrainTicketRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETRAINTICKETREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETRAINTICKETREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeTrainTicketRequest : public RpcServiceRequest
{
public:
RecognizeTrainTicketRequest();
~RecognizeTrainTicketRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETRAINTICKETREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZETRAINTICKETREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETRAINTICKETREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeTrainTicketRequest : public RpcServiceRequest {
public:
RecognizeTrainTicketRequest();
~RecognizeTrainTicketRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETRAINTICKETREQUEST_H_

2
ocr/include/alibabacloud/ocr/model/RecognizeTrainTicketResult.h
View File

@@ -40,8 +40,8 @@ namespace AlibabaCloud
float price;
std::string level;
std::string date;
std::string name;
std::string departureStation;
std::string name;
};

42
ocr/include/alibabacloud/ocr/model/RecognizeUkraineIdentityCardRequest.h Normal file
View File

@@ -0,0 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeUkraineIdentityCardRequest : public RpcServiceRequest {
public:
RecognizeUkraineIdentityCardRequest();
~RecognizeUkraineIdentityCardRequest();
std::string getImageUrl() const;
void setImageUrl(const std::string &imageUrl);
private:
std::string imageUrl_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDREQUEST_H_

214
ocr/include/alibabacloud/ocr/model/RecognizeUkraineIdentityCardResult.h Normal file
View File

@@ -0,0 +1,214 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeUkraineIdentityCardResult : public ServiceResult
{
public:
struct Data
{
struct BirthDate
{
struct KeyPointsItem
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem> keyPoints;
std::string text;
};
struct CardBox
{
struct KeyPointsItem2
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem2> keyPoints1;
std::string text;
};
struct DocumentNumber
{
struct KeyPointsItem4
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem4> keyPoints3;
std::string text;
};
struct ExpiryDate
{
struct KeyPointsItem6
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem6> keyPoints5;
std::string text;
};
struct NameEnglish
{
struct KeyPointsItem8
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem8> keyPoints7;
};
struct NameUkraine
{
struct KeyPointsItem10
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem10> keyPoints9;
};
struct Nationality
{
struct KeyPointsItem12
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem12> keyPoints11;
std::string text;
};
struct Patronymic
{
struct KeyPointsItem14
{
float x;
float y;
};
std::vector<KeyPointsItem14> keyPoints13;
float score;
std::string text;
};
struct PortraitBox
{
struct KeyPointsItem16
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem16> keyPoints15;
std::string text;
};
struct RecordNumber
{
struct KeyPointsItem18
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem18> keyPoints17;
};
struct Sex
{
struct KeyPointsItem20
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem20> keyPoints19;
};
struct SurnameEnglish
{
struct KeyPointsItem22
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem22> keyPoints21;
std::string text;
};
struct SurnameUkraine
{
struct KeyPointsItem24
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem24> keyPoints23;
std::string text;
};
ExpiryDate expiryDate;
CardBox cardBox;
Sex sex;
NameUkraine nameUkraine;
PortraitBox portraitBox;
DocumentNumber documentNumber;
SurnameEnglish surnameEnglish;
Nationality nationality;
SurnameUkraine surnameUkraine;
NameEnglish nameEnglish;
Patronymic patronymic;
RecordNumber recordNumber;
BirthDate birthDate;
};
RecognizeUkraineIdentityCardResult();
explicit RecognizeUkraineIdentityCardResult(const std::string &payload);
~RecognizeUkraineIdentityCardResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDRESULT_H_

74
ocr/include/alibabacloud/ocr/model/RecognizeVATInvoiceRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVATINVOICEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVATINVOICEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeVATInvoiceRequest : public RpcServiceRequest
{
public:
RecognizeVATInvoiceRequest();
~RecognizeVATInvoiceRequest();
std::string getFileType()const;
void setFileType(const std::string& fileType);
std::string getFileURL()const;
void setFileURL(const std::string& fileURL);
private:
std::string fileType_;
std::string fileURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVATINVOICEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVATINVOICEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVATINVOICEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeVATInvoiceRequest : public RpcServiceRequest {
public:
RecognizeVATInvoiceRequest();
~RecognizeVATInvoiceRequest();
std::string getFileType() const;
void setFileType(const std::string &fileType);
std::string getFileURL() const;
void setFileURL(const std::string &fileURL);
private:
std::string fileType_;
std::string fileURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVATINVOICEREQUEST_H_

74
ocr/include/alibabacloud/ocr/model/RecognizeVINCodeRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVINCODEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVINCODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeVINCodeRequest : public RpcServiceRequest
{
public:
RecognizeVINCodeRequest();
~RecognizeVINCodeRequest();
int getImageType()const;
void setImageType(int imageType);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
int imageType_;
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVINCODEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVINCODEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVINCODEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeVINCodeRequest : public RpcServiceRequest {
public:
RecognizeVINCodeRequest();
~RecognizeVINCodeRequest();
int getImageType() const;
void setImageType(int imageType);
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
int imageType_;
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVINCODEREQUEST_H_

68
ocr/include/alibabacloud/ocr/model/RecognizeVerificationcodeRequest.h
View File

@@ -1,48 +1,42 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVERIFICATIONCODEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVERIFICATIONCODEREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeVerificationcodeRequest : public RpcServiceRequest
{
public:
RecognizeVerificationcodeRequest();
~RecognizeVerificationcodeRequest();
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
private:
std::string imageURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVERIFICATIONCODEREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVERIFICATIONCODEREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVERIFICATIONCODEREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeVerificationcodeRequest : public RpcServiceRequest {
public:
RecognizeVerificationcodeRequest();
~RecognizeVerificationcodeRequest();
std::string getImageURL() const;
void setImageURL(const std::string &imageURL);
private:
std::string imageURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVERIFICATIONCODEREQUEST_H_

89
ocr/include/alibabacloud/ocr/model/RecognizeVideoCastCrewListRequest.h
View File

@@ -1,57 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeVideoCastCrewListRequest : public RpcServiceRequest
{
public:
RecognizeVideoCastCrewListRequest();
~RecognizeVideoCastCrewListRequest();
Array getParams()const;
void setParams(const Array& params);
bool getAsync()const;
void setAsync(bool async);
std::string getRegisterUrl()const;
void setRegisterUrl(const std::string& registerUrl);
std::string getVideoUrl()const;
void setVideoUrl(const std::string& videoUrl);
private:
Array params_;
bool async_;
std::string registerUrl_;
std::string videoUrl_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeVideoCastCrewListRequest : public RpcServiceRequest {
public:
struct Params {
std::string type;
};
RecognizeVideoCastCrewListRequest();
~RecognizeVideoCastCrewListRequest();
std::vector<Params> getParams() const;
void setParams(const std::vector<Params> &params);
bool getAsync() const;
void setAsync(bool async);
std::string getRegisterUrl() const;
void setRegisterUrl(const std::string &registerUrl);
std::string getVideoUrl() const;
void setVideoUrl(const std::string &videoUrl);
private:
std::vector<Params> params_;
bool async_;
std::string registerUrl_;
std::string videoUrl_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_

74
ocr/include/alibabacloud/ocr/model/RecognizeVideoCharacterRequest.h
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCHARACTERREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCHARACTERREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeVideoCharacterRequest : public RpcServiceRequest
{
public:
RecognizeVideoCharacterRequest();
~RecognizeVideoCharacterRequest();
bool getAsync()const;
void setAsync(bool async);
std::string getVideoURL()const;
void setVideoURL(const std::string& videoURL);
private:
bool async_;
std::string videoURL_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCHARACTERREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCHARACTERREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCHARACTERREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeVideoCharacterRequest : public RpcServiceRequest {
public:
RecognizeVideoCharacterRequest();
~RecognizeVideoCharacterRequest();
bool getAsync() const;
void setAsync(bool async);
std::string getVideoURL() const;
void setVideoURL(const std::string &videoURL);
private:
bool async_;
std::string videoURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCHARACTERREQUEST_H_

86
ocr/include/alibabacloud/ocr/model/TrimDocumentRequest.h
View File

@@ -1,57 +1,51 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_
#include <string>
#include <vector>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT TrimDocumentRequest : public RpcServiceRequest
{
public:
TrimDocumentRequest();
~TrimDocumentRequest();
std::string getFileType()const;
void setFileType(const std::string& fileType);
bool getAsync()const;
void setAsync(bool async);
std::string getFileURL()const;
void setFileURL(const std::string& fileURL);
std::string getOutputType()const;
void setOutputType(const std::string& outputType);
private:
std::string fileType_;
bool async_;
std::string fileURL_;
std::string outputType_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_
*/
#ifndef ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT TrimDocumentRequest : public RpcServiceRequest {
public:
TrimDocumentRequest();
~TrimDocumentRequest();
std::string getFileType() const;
void setFileType(const std::string &fileType);
std::string getOutputType() const;
void setOutputType(const std::string &outputType);
bool getAsync() const;
void setAsync(bool async);
std::string getFileURL() const;
void setFileURL(const std::string &fileURL);
private:
std::string fileType_;
std::string outputType_;
bool async_;
std::string fileURL_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTREQUEST_H_

108
ocr/src/OcrClient.cc
View File

@@ -483,42 +483,6 @@ OcrClient::RecognizeLicensePlateOutcomeCallable OcrClient::recognizeLicensePlate
return task->get_future();
}
OcrClient::RecognizePDFOutcome OcrClient::recognizePDF(const RecognizePDFRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizePDFOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizePDFOutcome(RecognizePDFResult(outcome.result()));
else
return RecognizePDFOutcome(outcome.error());
}
void OcrClient::recognizePDFAsync(const RecognizePDFRequest& request, const RecognizePDFAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizePDF(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizePDFOutcomeCallable OcrClient::recognizePDFCallable(const RecognizePDFRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizePDFOutcome()>>(
[this, request]()
{
return this->recognizePDF(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizePassportMRZOutcome OcrClient::recognizePassportMRZ(const RecognizePassportMRZRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -555,6 +519,42 @@ OcrClient::RecognizePassportMRZOutcomeCallable OcrClient::recognizePassportMRZCa
return task->get_future();
}
OcrClient::RecognizePdfOutcome OcrClient::recognizePdf(const RecognizePdfRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizePdfOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizePdfOutcome(RecognizePdfResult(outcome.result()));
else
return RecognizePdfOutcome(outcome.error());
}
void OcrClient::recognizePdfAsync(const RecognizePdfRequest& request, const RecognizePdfAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizePdf(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizePdfOutcomeCallable OcrClient::recognizePdfCallable(const RecognizePdfRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizePdfOutcome()>>(
[this, request]()
{
return this->recognizePdf(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizePoiNameOutcome OcrClient::recognizePoiName(const RecognizePoiNameRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
@@ -879,6 +879,42 @@ OcrClient::RecognizeTrainTicketOutcomeCallable OcrClient::recognizeTrainTicketCa
return task->get_future();
}
OcrClient::RecognizeUkraineIdentityCardOutcome OcrClient::recognizeUkraineIdentityCard(const RecognizeUkraineIdentityCardRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();
if (!endpointOutcome.isSuccess())
return RecognizeUkraineIdentityCardOutcome(endpointOutcome.error());
auto outcome = makeRequest(endpointOutcome.result(), request);
if (outcome.isSuccess())
return RecognizeUkraineIdentityCardOutcome(RecognizeUkraineIdentityCardResult(outcome.result()));
else
return RecognizeUkraineIdentityCardOutcome(outcome.error());
}
void OcrClient::recognizeUkraineIdentityCardAsync(const RecognizeUkraineIdentityCardRequest& request, const RecognizeUkraineIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context) const
{
auto fn = [this, request, handler, context]()
{
handler(this, request, recognizeUkraineIdentityCard(request), context);
};
asyncExecute(new Runnable(fn));
}
OcrClient::RecognizeUkraineIdentityCardOutcomeCallable OcrClient::recognizeUkraineIdentityCardCallable(const RecognizeUkraineIdentityCardRequest &request) const
{
auto task = std::make_shared<std::packaged_task<RecognizeUkraineIdentityCardOutcome()>>(
[this, request]()
{
return this->recognizeUkraineIdentityCard(request);
});
asyncExecute(new Runnable([task]() { (*task)(); }));
return task->get_future();
}
OcrClient::RecognizeVATInvoiceOutcome OcrClient::recognizeVATInvoice(const RecognizeVATInvoiceRequest &request) const
{
auto endpointOutcome = endpointProvider_->getEndpoint();

46
ocr/src/model/DetectCardScreenshotRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/DetectCardScreenshotRequest.h>
using AlibabaCloud::Ocr::Model::DetectCardScreenshotRequest;
DetectCardScreenshotRequest::DetectCardScreenshotRequest() :
RpcServiceRequest("ocr", "2019-12-30", "DetectCardScreenshot")
{
setMethod(HttpRequest::Method::Post);
}
DetectCardScreenshotRequest::~DetectCardScreenshotRequest()
{}
std::string DetectCardScreenshotRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/ocr/model/DetectCardScreenshotRequest.h>
using AlibabaCloud::Ocr::Model::DetectCardScreenshotRequest;
DetectCardScreenshotRequest::DetectCardScreenshotRequest()
: RpcServiceRequest("ocr", "2019-12-30", "DetectCardScreenshot") {
setMethod(HttpRequest::Method::Post);
}
void DetectCardScreenshotRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
DetectCardScreenshotRequest::~DetectCardScreenshotRequest() {}
std::string DetectCardScreenshotRequest::getImageURL() const {
return imageURL_;
}
void DetectCardScreenshotRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

8
ocr/src/model/DetectCardScreenshotResult.cc
View File

@@ -40,18 +40,18 @@ void DetectCardScreenshotResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["IsCard"].isNull())
data_.isCard = dataNode["IsCard"].asString() == "true";
if(!dataNode["IsBlur"].isNull())
data_.isBlur = dataNode["IsBlur"].asString() == "true";
if(!dataNode["IsCard"].isNull())
data_.isCard = dataNode["IsCard"].asString() == "true";
auto spoofResultNode = dataNode["SpoofResult"];
if(!spoofResultNode["IsSpoof"].isNull())
data_.spoofResult.isSpoof = spoofResultNode["IsSpoof"].asString() == "true";
auto resultMapNode = spoofResultNode["ResultMap"];
if(!resultMapNode["ScreenScore"].isNull())
data_.spoofResult.resultMap.screenScore = std::stof(resultMapNode["ScreenScore"].asString());
if(!resultMapNode["ScreenThreshold"].isNull())
data_.spoofResult.resultMap.screenThreshold = std::stof(resultMapNode["ScreenThreshold"].asString());
if(!resultMapNode["ScreenScore"].isNull())
data_.spoofResult.resultMap.screenScore = std::stof(resultMapNode["ScreenScore"].asString());
}

58
ocr/src/model/GetAsyncJobResultRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/GetAsyncJobResultRequest.h>
using AlibabaCloud::Ocr::Model::GetAsyncJobResultRequest;
GetAsyncJobResultRequest::GetAsyncJobResultRequest() :
RpcServiceRequest("ocr", "2019-12-30", "GetAsyncJobResult")
{
setMethod(HttpRequest::Method::Post);
}
GetAsyncJobResultRequest::~GetAsyncJobResultRequest()
{}
bool GetAsyncJobResultRequest::getAsync()const
{
return async_;
*/
#include <alibabacloud/ocr/model/GetAsyncJobResultRequest.h>
using AlibabaCloud::Ocr::Model::GetAsyncJobResultRequest;
GetAsyncJobResultRequest::GetAsyncJobResultRequest()
: RpcServiceRequest("ocr", "2019-12-30", "GetAsyncJobResult") {
setMethod(HttpRequest::Method::Post);
}
void GetAsyncJobResultRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
GetAsyncJobResultRequest::~GetAsyncJobResultRequest() {}
std::string GetAsyncJobResultRequest::getJobId() const {
return jobId_;
}
std::string GetAsyncJobResultRequest::getJobId()const
{
return jobId_;
void GetAsyncJobResultRequest::setJobId(const std::string &jobId) {
jobId_ = jobId;
setBodyParameter(std::string("JobId"), jobId);
}
void GetAsyncJobResultRequest::setJobId(const std::string& jobId)
{
jobId_ = jobId;
setBodyParameter("JobId", jobId);
bool GetAsyncJobResultRequest::getAsync() const {
return async_;
}
void GetAsyncJobResultRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}

16
ocr/src/model/GetAsyncJobResultResult.cc
View File

@@ -40,16 +40,16 @@ void GetAsyncJobResultResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["ErrorCode"].isNull())
data_.errorCode = dataNode["ErrorCode"].asString();
if(!dataNode["ErrorMessage"].isNull())
data_.errorMessage = dataNode["ErrorMessage"].asString();
if(!dataNode["JobId"].isNull())
data_.jobId = dataNode["JobId"].asString();
if(!dataNode["Result"].isNull())
data_.result = dataNode["Result"].asString();
if(!dataNode["Status"].isNull())
data_.status = dataNode["Status"].asString();
if(!dataNode["ErrorMessage"].isNull())
data_.errorMessage = dataNode["ErrorMessage"].asString();
if(!dataNode["Result"].isNull())
data_.result = dataNode["Result"].asString();
if(!dataNode["ErrorCode"].isNull())
data_.errorCode = dataNode["ErrorCode"].asString();
if(!dataNode["JobId"].isNull())
data_.jobId = dataNode["JobId"].asString();
}

58
ocr/src/model/RecognizeAccountPageRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeAccountPageRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeAccountPageRequest;
RecognizeAccountPageRequest::RecognizeAccountPageRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeAccountPage")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeAccountPageRequest::~RecognizeAccountPageRequest()
{}
int RecognizeAccountPageRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeAccountPageRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeAccountPageRequest;
RecognizeAccountPageRequest::RecognizeAccountPageRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeAccountPage") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeAccountPageRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeAccountPageRequest::~RecognizeAccountPageRequest() {}
int RecognizeAccountPageRequest::getImageType() const {
return imageType_;
}
std::string RecognizeAccountPageRequest::getImageURL()const
{
return imageURL_;
void RecognizeAccountPageRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeAccountPageRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeAccountPageRequest::getImageURL() const {
return imageURL_;
}
void RecognizeAccountPageRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

100
ocr/src/model/RecognizeAccountPageResult.cc
View File

@@ -40,89 +40,89 @@ void RecognizeAccountPageResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Angle"].isNull())
data_.angle = std::stof(dataNode["Angle"].asString());
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["Gender"].isNull())
data_.gender = dataNode["Gender"].asString();
if(!dataNode["Relation"].isNull())
data_.relation = dataNode["Relation"].asString();
if(!dataNode["BirthPlace"].isNull())
data_.birthPlace = dataNode["BirthPlace"].asString();
if(!dataNode["Angle"].isNull())
data_.angle = std::stof(dataNode["Angle"].asString());
if(!dataNode["Nationality"].isNull())
data_.nationality = dataNode["Nationality"].asString();
if(!dataNode["NativePlace"].isNull())
data_.nativePlace = dataNode["NativePlace"].asString();
if(!dataNode["BirthPlace"].isNull())
data_.birthPlace = dataNode["BirthPlace"].asString();
if(!dataNode["BirthDate"].isNull())
data_.birthDate = dataNode["BirthDate"].asString();
if(!dataNode["Relation"].isNull())
data_.relation = dataNode["Relation"].asString();
if(!dataNode["NativePlace"].isNull())
data_.nativePlace = dataNode["NativePlace"].asString();
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["IDNumber"].isNull())
data_.iDNumber = dataNode["IDNumber"].asString();
auto allInvalidStampAreasNode = dataNode["InvalidStampAreas"]["InvalidStampArea"];
for (auto dataNodeInvalidStampAreasInvalidStampArea : allInvalidStampAreasNode)
{
Data::InvalidStampArea invalidStampAreaObject;
if(!dataNodeInvalidStampAreasInvalidStampArea["Left"].isNull())
invalidStampAreaObject.left = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Left"].asString());
if(!dataNodeInvalidStampAreasInvalidStampArea["Top"].isNull())
invalidStampAreaObject.top = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Top"].asString());
if(!dataNodeInvalidStampAreasInvalidStampArea["Height"].isNull())
invalidStampAreaObject.height = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Height"].asString());
if(!dataNodeInvalidStampAreasInvalidStampArea["Width"].isNull())
invalidStampAreaObject.width = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Width"].asString());
data_.invalidStampAreas.push_back(invalidStampAreaObject);
}
auto allUndertakeStampAreasNode = dataNode["UndertakeStampAreas"]["UndertakeStampArea"];
for (auto dataNodeUndertakeStampAreasUndertakeStampArea : allUndertakeStampAreasNode)
{
Data::UndertakeStampArea undertakeStampAreaObject;
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Left"].isNull())
undertakeStampAreaObject.left = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Left"].asString());
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Top"].isNull())
undertakeStampAreaObject.top = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Top"].asString());
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Height"].isNull())
undertakeStampAreaObject.height = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Height"].asString());
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Width"].isNull())
undertakeStampAreaObject.width = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Width"].asString());
data_.undertakeStampAreas.push_back(undertakeStampAreaObject);
}
auto allRegisterStampAreasNode = dataNode["RegisterStampAreas"]["RegisterStampArea"];
for (auto dataNodeRegisterStampAreasRegisterStampArea : allRegisterStampAreasNode)
{
Data::RegisterStampArea registerStampAreaObject;
if(!dataNodeRegisterStampAreasRegisterStampArea["Left"].isNull())
registerStampAreaObject.left = std::stoi(dataNodeRegisterStampAreasRegisterStampArea["Left"].asString());
if(!dataNodeRegisterStampAreasRegisterStampArea["Top"].isNull())
registerStampAreaObject.top = std::stoi(dataNodeRegisterStampAreasRegisterStampArea["Top"].asString());
if(!dataNodeRegisterStampAreasRegisterStampArea["Height"].isNull())
registerStampAreaObject.height = std::stoi(dataNodeRegisterStampAreasRegisterStampArea["Height"].asString());
if(!dataNodeRegisterStampAreasRegisterStampArea["Width"].isNull())
registerStampAreaObject.width = std::stoi(dataNodeRegisterStampAreasRegisterStampArea["Width"].asString());
if(!dataNodeRegisterStampAreasRegisterStampArea["Height"].isNull())
registerStampAreaObject.height = std::stoi(dataNodeRegisterStampAreasRegisterStampArea["Height"].asString());
if(!dataNodeRegisterStampAreasRegisterStampArea["Left"].isNull())
registerStampAreaObject.left = std::stoi(dataNodeRegisterStampAreasRegisterStampArea["Left"].asString());
data_.registerStampAreas.push_back(registerStampAreaObject);
}
auto allOtherStampAreasNode = dataNode["OtherStampAreas"]["OtherStampArea"];
for (auto dataNodeOtherStampAreasOtherStampArea : allOtherStampAreasNode)
{
Data::OtherStampArea otherStampAreaObject;
if(!dataNodeOtherStampAreasOtherStampArea["Left"].isNull())
otherStampAreaObject.left = std::stoi(dataNodeOtherStampAreasOtherStampArea["Left"].asString());
if(!dataNodeOtherStampAreasOtherStampArea["Top"].isNull())
otherStampAreaObject.top = std::stoi(dataNodeOtherStampAreasOtherStampArea["Top"].asString());
if(!dataNodeOtherStampAreasOtherStampArea["Height"].isNull())
otherStampAreaObject.height = std::stoi(dataNodeOtherStampAreasOtherStampArea["Height"].asString());
if(!dataNodeOtherStampAreasOtherStampArea["Width"].isNull())
otherStampAreaObject.width = std::stoi(dataNodeOtherStampAreasOtherStampArea["Width"].asString());
if(!dataNodeOtherStampAreasOtherStampArea["Height"].isNull())
otherStampAreaObject.height = std::stoi(dataNodeOtherStampAreasOtherStampArea["Height"].asString());
if(!dataNodeOtherStampAreasOtherStampArea["Left"].isNull())
otherStampAreaObject.left = std::stoi(dataNodeOtherStampAreasOtherStampArea["Left"].asString());
data_.otherStampAreas.push_back(otherStampAreaObject);
}
auto allUndertakeStampAreasNode = dataNode["UndertakeStampAreas"]["UndertakeStampArea"];
for (auto dataNodeUndertakeStampAreasUndertakeStampArea : allUndertakeStampAreasNode)
{
Data::UndertakeStampArea undertakeStampAreaObject;
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Top"].isNull())
undertakeStampAreaObject.top = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Top"].asString());
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Width"].isNull())
undertakeStampAreaObject.width = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Width"].asString());
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Height"].isNull())
undertakeStampAreaObject.height = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Height"].asString());
if(!dataNodeUndertakeStampAreasUndertakeStampArea["Left"].isNull())
undertakeStampAreaObject.left = std::stoi(dataNodeUndertakeStampAreasUndertakeStampArea["Left"].asString());
data_.undertakeStampAreas.push_back(undertakeStampAreaObject);
}
auto allInvalidStampAreasNode = dataNode["InvalidStampAreas"]["InvalidStampArea"];
for (auto dataNodeInvalidStampAreasInvalidStampArea : allInvalidStampAreasNode)
{
Data::InvalidStampArea invalidStampAreaObject;
if(!dataNodeInvalidStampAreasInvalidStampArea["Top"].isNull())
invalidStampAreaObject.top = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Top"].asString());
if(!dataNodeInvalidStampAreasInvalidStampArea["Width"].isNull())
invalidStampAreaObject.width = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Width"].asString());
if(!dataNodeInvalidStampAreasInvalidStampArea["Height"].isNull())
invalidStampAreaObject.height = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Height"].asString());
if(!dataNodeInvalidStampAreasInvalidStampArea["Left"].isNull())
invalidStampAreaObject.left = std::stoi(dataNodeInvalidStampAreasInvalidStampArea["Left"].asString());
data_.invalidStampAreas.push_back(invalidStampAreaObject);
}
auto titleAreaNode = dataNode["TitleArea"];
if(!titleAreaNode["Left"].isNull())
data_.titleArea.left = std::stoi(titleAreaNode["Left"].asString());
if(!titleAreaNode["Top"].isNull())
data_.titleArea.top = std::stoi(titleAreaNode["Top"].asString());
if(!titleAreaNode["Height"].isNull())
data_.titleArea.height = std::stoi(titleAreaNode["Height"].asString());
if(!titleAreaNode["Width"].isNull())
data_.titleArea.width = std::stoi(titleAreaNode["Width"].asString());
if(!titleAreaNode["Height"].isNull())
data_.titleArea.height = std::stoi(titleAreaNode["Height"].asString());
if(!titleAreaNode["Left"].isNull())
data_.titleArea.left = std::stoi(titleAreaNode["Left"].asString());
}

58
ocr/src/model/RecognizeBankCardRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeBankCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeBankCardRequest;
RecognizeBankCardRequest::RecognizeBankCardRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeBankCard")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeBankCardRequest::~RecognizeBankCardRequest()
{}
int RecognizeBankCardRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeBankCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeBankCardRequest;
RecognizeBankCardRequest::RecognizeBankCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeBankCard") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeBankCardRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeBankCardRequest::~RecognizeBankCardRequest() {}
int RecognizeBankCardRequest::getImageType() const {
return imageType_;
}
std::string RecognizeBankCardRequest::getImageURL()const
{
return imageURL_;
void RecognizeBankCardRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeBankCardRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeBankCardRequest::getImageURL() const {
return imageURL_;
}
void RecognizeBankCardRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

58
ocr/src/model/RecognizeBusinessCardRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeBusinessCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeBusinessCardRequest;
RecognizeBusinessCardRequest::RecognizeBusinessCardRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeBusinessCard")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeBusinessCardRequest::~RecognizeBusinessCardRequest()
{}
int RecognizeBusinessCardRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeBusinessCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeBusinessCardRequest;
RecognizeBusinessCardRequest::RecognizeBusinessCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeBusinessCard") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeBusinessCardRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeBusinessCardRequest::~RecognizeBusinessCardRequest() {}
int RecognizeBusinessCardRequest::getImageType() const {
return imageType_;
}
std::string RecognizeBusinessCardRequest::getImageURL()const
{
return imageURL_;
void RecognizeBusinessCardRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeBusinessCardRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeBusinessCardRequest::getImageURL() const {
return imageURL_;
}
void RecognizeBusinessCardRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

24
ocr/src/model/RecognizeBusinessCardResult.cc
View File

@@ -45,24 +45,24 @@ void RecognizeBusinessCardResult::parse(const std::string &payload)
auto allCompanies = dataNode["Companies"]["Company"];
for (auto value : allCompanies)
data_.companies.push_back(value.asString());
auto allDepartments = dataNode["Departments"]["Department"];
for (auto value : allDepartments)
data_.departments.push_back(value.asString());
auto allTitles = dataNode["Titles"]["Title"];
for (auto value : allTitles)
data_.titles.push_back(value.asString());
auto allCellPhoneNumbers = dataNode["CellPhoneNumbers"]["CellPhoneNumber"];
for (auto value : allCellPhoneNumbers)
data_.cellPhoneNumbers.push_back(value.asString());
auto allOfficePhoneNumbers = dataNode["OfficePhoneNumbers"]["OfficePhoneNumber"];
for (auto value : allOfficePhoneNumbers)
data_.officePhoneNumbers.push_back(value.asString());
auto allAddresses = dataNode["Addresses"]["Address"];
for (auto value : allAddresses)
data_.addresses.push_back(value.asString());
auto allEmails = dataNode["Emails"]["Email"];
for (auto value : allEmails)
data_.emails.push_back(value.asString());
auto allDepartments = dataNode["Departments"]["Department"];
for (auto value : allDepartments)
data_.departments.push_back(value.asString());
auto allOfficePhoneNumbers = dataNode["OfficePhoneNumbers"]["OfficePhoneNumber"];
for (auto value : allOfficePhoneNumbers)
data_.officePhoneNumbers.push_back(value.asString());
auto allCellPhoneNumbers = dataNode["CellPhoneNumbers"]["CellPhoneNumber"];
for (auto value : allCellPhoneNumbers)
data_.cellPhoneNumbers.push_back(value.asString());
auto allAddresses = dataNode["Addresses"]["Address"];
for (auto value : allAddresses)
data_.addresses.push_back(value.asString());
}

58
ocr/src/model/RecognizeBusinessLicenseRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeBusinessLicenseRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeBusinessLicenseRequest;
RecognizeBusinessLicenseRequest::RecognizeBusinessLicenseRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeBusinessLicense")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeBusinessLicenseRequest::~RecognizeBusinessLicenseRequest()
{}
int RecognizeBusinessLicenseRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeBusinessLicenseRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeBusinessLicenseRequest;
RecognizeBusinessLicenseRequest::RecognizeBusinessLicenseRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeBusinessLicense") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeBusinessLicenseRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeBusinessLicenseRequest::~RecognizeBusinessLicenseRequest() {}
int RecognizeBusinessLicenseRequest::getImageType() const {
return imageType_;
}
std::string RecognizeBusinessLicenseRequest::getImageURL()const
{
return imageURL_;
void RecognizeBusinessLicenseRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeBusinessLicenseRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeBusinessLicenseRequest::getImageURL() const {
return imageURL_;
}
void RecognizeBusinessLicenseRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

111
ocr/src/model/RecognizeCharacterRequest.cc
View File

@@ -1,106 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeCharacterRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeCharacterRequest;
RecognizeCharacterRequest::RecognizeCharacterRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeCharacter")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeCharacterRequest::~RecognizeCharacterRequest()
{}
bool RecognizeCharacterRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/ocr/model/RecognizeCharacterRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeCharacterRequest;
RecognizeCharacterRequest::RecognizeCharacterRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeCharacter") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeCharacterRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
RecognizeCharacterRequest::~RecognizeCharacterRequest() {}
int RecognizeCharacterRequest::getMinHeight() const {
return minHeight_;
}
int RecognizeCharacterRequest::getMinHeight()const
{
return minHeight_;
void RecognizeCharacterRequest::setMinHeight(int minHeight) {
minHeight_ = minHeight;
setBodyParameter(std::string("MinHeight"), std::to_string(minHeight));
}
void RecognizeCharacterRequest::setMinHeight(int minHeight)
{
minHeight_ = minHeight;
setBodyParameter("MinHeight", std::to_string(minHeight));
int RecognizeCharacterRequest::getImageType() const {
return imageType_;
}
std::string RecognizeCharacterRequest::getOssFile()const
{
return ossFile_;
void RecognizeCharacterRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeCharacterRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
bool RecognizeCharacterRequest::getOutputProbability() const {
return outputProbability_;
}
int RecognizeCharacterRequest::getImageType()const
{
return imageType_;
void RecognizeCharacterRequest::setOutputProbability(bool outputProbability) {
outputProbability_ = outputProbability;
setBodyParameter(std::string("OutputProbability"), outputProbability ? "true" : "false");
}
void RecognizeCharacterRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
std::string RecognizeCharacterRequest::getImageURL() const {
return imageURL_;
}
std::string RecognizeCharacterRequest::getRequestProxyBy()const
{
return requestProxyBy_;
}
void RecognizeCharacterRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
}
bool RecognizeCharacterRequest::getOutputProbability()const
{
return outputProbability_;
}
void RecognizeCharacterRequest::setOutputProbability(bool outputProbability)
{
outputProbability_ = outputProbability;
setBodyParameter("OutputProbability", outputProbability ? "true" : "false");
}
std::string RecognizeCharacterRequest::getImageURL()const
{
return imageURL_;
}
void RecognizeCharacterRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
void RecognizeCharacterRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

46
ocr/src/model/RecognizeChinapassportRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeChinapassportRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeChinapassportRequest;
RecognizeChinapassportRequest::RecognizeChinapassportRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeChinapassport")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeChinapassportRequest::~RecognizeChinapassportRequest()
{}
std::string RecognizeChinapassportRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/ocr/model/RecognizeChinapassportRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeChinapassportRequest;
RecognizeChinapassportRequest::RecognizeChinapassportRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeChinapassport") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeChinapassportRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
RecognizeChinapassportRequest::~RecognizeChinapassportRequest() {}
std::string RecognizeChinapassportRequest::getImageURL() const {
return imageURL_;
}
void RecognizeChinapassportRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

84
ocr/src/model/RecognizeChinapassportResult.cc
View File

@@ -40,50 +40,50 @@ void RecognizeChinapassportResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Authority"].isNull())
data_.authority = dataNode["Authority"].asString();
if(!dataNode["BirthDate"].isNull())
data_.birthDate = dataNode["BirthDate"].asString();
if(!dataNode["BirthDay"].isNull())
data_.birthDay = dataNode["BirthDay"].asString();
if(!dataNode["BirthPlace"].isNull())
data_.birthPlace = dataNode["BirthPlace"].asString();
if(!dataNode["BirthPlaceRaw"].isNull())
data_.birthPlaceRaw = dataNode["BirthPlaceRaw"].asString();
if(!dataNode["Country"].isNull())
data_.country = dataNode["Country"].asString();
if(!dataNode["ExpiryDate"].isNull())
data_.expiryDate = dataNode["ExpiryDate"].asString();
if(!dataNode["ExpiryDay"].isNull())
data_.expiryDay = dataNode["ExpiryDay"].asString();
if(!dataNode["IssueDate"].isNull())
data_.issueDate = dataNode["IssueDate"].asString();
if(!dataNode["IssuePlace"].isNull())
data_.issuePlace = dataNode["IssuePlace"].asString();
if(!dataNode["IssuePlaceRaw"].isNull())
data_.issuePlaceRaw = dataNode["IssuePlaceRaw"].asString();
if(!dataNode["LineZero"].isNull())
data_.lineZero = dataNode["LineZero"].asString();
if(!dataNode["LineOne"].isNull())
data_.lineOne = dataNode["LineOne"].asString();
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["NameChinese"].isNull())
data_.nameChinese = dataNode["NameChinese"].asString();
if(!dataNode["NameChineseRaw"].isNull())
data_.nameChineseRaw = dataNode["NameChineseRaw"].asString();
if(!dataNode["PassportNo"].isNull())
data_.passportNo = dataNode["PassportNo"].asString();
if(!dataNode["PersonId"].isNull())
data_.personId = dataNode["PersonId"].asString();
if(!dataNode["Sex"].isNull())
data_.sex = dataNode["Sex"].asString();
if(!dataNode["SourceCountry"].isNull())
data_.sourceCountry = dataNode["SourceCountry"].asString();
if(!dataNode["Success"].isNull())
data_.success = dataNode["Success"].asString() == "true";
if(!dataNode["Type"].isNull())
data_.type = dataNode["Type"].asString();
if(!dataNode["Sex"].isNull())
data_.sex = dataNode["Sex"].asString();
if(!dataNode["Authority"].isNull())
data_.authority = dataNode["Authority"].asString();
if(!dataNode["IssuePlaceRaw"].isNull())
data_.issuePlaceRaw = dataNode["IssuePlaceRaw"].asString();
if(!dataNode["Success"].isNull())
data_.success = dataNode["Success"].asString() == "true";
if(!dataNode["LineOne"].isNull())
data_.lineOne = dataNode["LineOne"].asString();
if(!dataNode["ExpiryDate"].isNull())
data_.expiryDate = dataNode["ExpiryDate"].asString();
if(!dataNode["BirthPlace"].isNull())
data_.birthPlace = dataNode["BirthPlace"].asString();
if(!dataNode["PassportNo"].isNull())
data_.passportNo = dataNode["PassportNo"].asString();
if(!dataNode["BirthPlaceRaw"].isNull())
data_.birthPlaceRaw = dataNode["BirthPlaceRaw"].asString();
if(!dataNode["IssueDate"].isNull())
data_.issueDate = dataNode["IssueDate"].asString();
if(!dataNode["SourceCountry"].isNull())
data_.sourceCountry = dataNode["SourceCountry"].asString();
if(!dataNode["BirthDate"].isNull())
data_.birthDate = dataNode["BirthDate"].asString();
if(!dataNode["NameChineseRaw"].isNull())
data_.nameChineseRaw = dataNode["NameChineseRaw"].asString();
if(!dataNode["IssuePlace"].isNull())
data_.issuePlace = dataNode["IssuePlace"].asString();
if(!dataNode["NameChinese"].isNull())
data_.nameChinese = dataNode["NameChinese"].asString();
if(!dataNode["LineZero"].isNull())
data_.lineZero = dataNode["LineZero"].asString();
if(!dataNode["Country"].isNull())
data_.country = dataNode["Country"].asString();
if(!dataNode["BirthDay"].isNull())
data_.birthDay = dataNode["BirthDay"].asString();
if(!dataNode["ExpiryDay"].isNull())
data_.expiryDay = dataNode["ExpiryDay"].asString();
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["PersonId"].isNull())
data_.personId = dataNode["PersonId"].asString();
}

70
ocr/src/model/RecognizeDriverLicenseRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeDriverLicenseRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeDriverLicenseRequest;
RecognizeDriverLicenseRequest::RecognizeDriverLicenseRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeDriverLicense")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeDriverLicenseRequest::~RecognizeDriverLicenseRequest()
{}
int RecognizeDriverLicenseRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeDriverLicenseRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeDriverLicenseRequest;
RecognizeDriverLicenseRequest::RecognizeDriverLicenseRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeDriverLicense") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeDriverLicenseRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeDriverLicenseRequest::~RecognizeDriverLicenseRequest() {}
int RecognizeDriverLicenseRequest::getImageType() const {
return imageType_;
}
std::string RecognizeDriverLicenseRequest::getSide()const
{
return side_;
void RecognizeDriverLicenseRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeDriverLicenseRequest::setSide(const std::string& side)
{
side_ = side;
setBodyParameter("Side", side);
std::string RecognizeDriverLicenseRequest::getSide() const {
return side_;
}
std::string RecognizeDriverLicenseRequest::getImageURL()const
{
return imageURL_;
void RecognizeDriverLicenseRequest::setSide(const std::string &side) {
side_ = side;
setBodyParameter(std::string("Side"), side);
}
void RecognizeDriverLicenseRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeDriverLicenseRequest::getImageURL() const {
return imageURL_;
}
void RecognizeDriverLicenseRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

70
ocr/src/model/RecognizeDrivingLicenseRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeDrivingLicenseRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeDrivingLicenseRequest;
RecognizeDrivingLicenseRequest::RecognizeDrivingLicenseRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeDrivingLicense")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeDrivingLicenseRequest::~RecognizeDrivingLicenseRequest()
{}
int RecognizeDrivingLicenseRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeDrivingLicenseRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeDrivingLicenseRequest;
RecognizeDrivingLicenseRequest::RecognizeDrivingLicenseRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeDrivingLicense") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeDrivingLicenseRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeDrivingLicenseRequest::~RecognizeDrivingLicenseRequest() {}
int RecognizeDrivingLicenseRequest::getImageType() const {
return imageType_;
}
std::string RecognizeDrivingLicenseRequest::getSide()const
{
return side_;
void RecognizeDrivingLicenseRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeDrivingLicenseRequest::setSide(const std::string& side)
{
side_ = side;
setBodyParameter("Side", side);
std::string RecognizeDrivingLicenseRequest::getSide() const {
return side_;
}
std::string RecognizeDrivingLicenseRequest::getImageURL()const
{
return imageURL_;
void RecognizeDrivingLicenseRequest::setSide(const std::string &side) {
side_ = side;
setBodyParameter(std::string("Side"), side);
}
void RecognizeDrivingLicenseRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeDrivingLicenseRequest::getImageURL() const {
return imageURL_;
}
void RecognizeDrivingLicenseRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

70
ocr/src/model/RecognizeIdentityCardRequest.cc
View File

@@ -1,62 +1,54 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeIdentityCardRequest;
RecognizeIdentityCardRequest::RecognizeIdentityCardRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeIdentityCard")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeIdentityCardRequest::~RecognizeIdentityCardRequest()
{}
int RecognizeIdentityCardRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeIdentityCardRequest;
RecognizeIdentityCardRequest::RecognizeIdentityCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeIdentityCard") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeIdentityCardRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeIdentityCardRequest::~RecognizeIdentityCardRequest() {}
int RecognizeIdentityCardRequest::getImageType() const {
return imageType_;
}
std::string RecognizeIdentityCardRequest::getSide()const
{
return side_;
void RecognizeIdentityCardRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeIdentityCardRequest::setSide(const std::string& side)
{
side_ = side;
setBodyParameter("Side", side);
std::string RecognizeIdentityCardRequest::getSide() const {
return side_;
}
std::string RecognizeIdentityCardRequest::getImageURL()const
{
return imageURL_;
void RecognizeIdentityCardRequest::setSide(const std::string &side) {
side_ = side;
setBodyParameter(std::string("Side"), side);
}
void RecognizeIdentityCardRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeIdentityCardRequest::getImageURL() const {
return imageURL_;
}
void RecognizeIdentityCardRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

58
ocr/src/model/RecognizeLicensePlateRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeLicensePlateRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeLicensePlateRequest;
RecognizeLicensePlateRequest::RecognizeLicensePlateRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeLicensePlate")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeLicensePlateRequest::~RecognizeLicensePlateRequest()
{}
int RecognizeLicensePlateRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeLicensePlateRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeLicensePlateRequest;
RecognizeLicensePlateRequest::RecognizeLicensePlateRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeLicensePlate") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeLicensePlateRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeLicensePlateRequest::~RecognizeLicensePlateRequest() {}
int RecognizeLicensePlateRequest::getImageType() const {
return imageType_;
}
std::string RecognizeLicensePlateRequest::getImageURL()const
{
return imageURL_;
void RecognizeLicensePlateRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeLicensePlateRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeLicensePlateRequest::getImageURL() const {
return imageURL_;
}
void RecognizeLicensePlateRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

46
ocr/src/model/RecognizePassportMRZRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizePassportMRZRequest.h>
using AlibabaCloud::Ocr::Model::RecognizePassportMRZRequest;
RecognizePassportMRZRequest::RecognizePassportMRZRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizePassportMRZ")
{
setMethod(HttpRequest::Method::Post);
}
RecognizePassportMRZRequest::~RecognizePassportMRZRequest()
{}
std::string RecognizePassportMRZRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/ocr/model/RecognizePassportMRZRequest.h>
using AlibabaCloud::Ocr::Model::RecognizePassportMRZRequest;
RecognizePassportMRZRequest::RecognizePassportMRZRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizePassportMRZ") {
setMethod(HttpRequest::Method::Post);
}
void RecognizePassportMRZRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
RecognizePassportMRZRequest::~RecognizePassportMRZRequest() {}
std::string RecognizePassportMRZRequest::getImageURL() const {
return imageURL_;
}
void RecognizePassportMRZRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

8
ocr/src/model/RecognizePassportMRZResult.cc
View File

@@ -44,14 +44,14 @@ void RecognizePassportMRZResult::parse(const std::string &payload)
for (auto dataNodeRegionsRegion : allRegionsNode)
{
Data::Region regionObject;
if(!dataNodeRegionsRegion["Name"].isNull())
regionObject.name = dataNodeRegionsRegion["Name"].asString();
if(!dataNodeRegionsRegion["RecognitionScore"].isNull())
regionObject.recognitionScore = std::stof(dataNodeRegionsRegion["RecognitionScore"].asString());
if(!dataNodeRegionsRegion["Content"].isNull())
regionObject.content = dataNodeRegionsRegion["Content"].asString();
if(!dataNodeRegionsRegion["DetectionScore"].isNull())
regionObject.detectionScore = std::stof(dataNodeRegionsRegion["DetectionScore"].asString());
if(!dataNodeRegionsRegion["Name"].isNull())
regionObject.name = dataNodeRegionsRegion["Name"].asString();
if(!dataNodeRegionsRegion["Content"].isNull())
regionObject.content = dataNodeRegionsRegion["Content"].asString();
auto allBandBoxes = value["BandBoxes"]["BandBox"];
for (auto value : allBandBoxes)
regionObject.bandBoxes.push_back(value.asString());

46
ocr/src/model/RecognizePDFRequest.cc → ocr/src/model/RecognizePdfRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizePDFRequest.h>
using AlibabaCloud::Ocr::Model::RecognizePDFRequest;
RecognizePDFRequest::RecognizePDFRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizePDF")
{
setMethod(HttpRequest::Method::Post);
}
RecognizePDFRequest::~RecognizePDFRequest()
{}
std::string RecognizePDFRequest::getFileURL()const
{
return fileURL_;
*/
#include <alibabacloud/ocr/model/RecognizePdfRequest.h>
using AlibabaCloud::Ocr::Model::RecognizePdfRequest;
RecognizePdfRequest::RecognizePdfRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizePdf") {
setMethod(HttpRequest::Method::Post);
}
void RecognizePDFRequest::setFileURL(const std::string& fileURL)
{
fileURL_ = fileURL;
setBodyParameter("FileURL", fileURL);
RecognizePdfRequest::~RecognizePdfRequest() {}
std::string RecognizePdfRequest::getFileURL() const {
return fileURL_;
}
void RecognizePdfRequest::setFileURL(const std::string &fileURL) {
fileURL_ = fileURL;
setBodyParameter(std::string("FileURL"), fileURL);
}

16
ocr/src/model/RecognizePDFResult.cc → ocr/src/model/RecognizePdfResult.cc
View File

@@ -14,26 +14,26 @@
* limitations under the License.
*/
#include <alibabacloud/ocr/model/RecognizePDFResult.h>
#include <alibabacloud/ocr/model/RecognizePdfResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ocr;
using namespace AlibabaCloud::Ocr::Model;
RecognizePDFResult::RecognizePDFResult() :
RecognizePdfResult::RecognizePdfResult() :
ServiceResult()
{}
RecognizePDFResult::RecognizePDFResult(const std::string &payload) :
RecognizePdfResult::RecognizePdfResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizePDFResult::~RecognizePDFResult()
RecognizePdfResult::~RecognizePdfResult()
{}
void RecognizePDFResult::parse(const std::string &payload)
void RecognizePdfResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
@@ -87,17 +87,17 @@ void RecognizePDFResult::parse(const std::string &payload)
}
std::string RecognizePDFResult::getMessage()const
std::string RecognizePdfResult::getMessage()const
{
return message_;
}
RecognizePDFResult::Data RecognizePDFResult::getData()const
RecognizePdfResult::Data RecognizePdfResult::getData()const
{
return data_;
}
std::string RecognizePDFResult::getCode()const
std::string RecognizePdfResult::getCode()const
{
return code_;
}

46
ocr/src/model/RecognizePoiNameRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizePoiNameRequest.h>
using AlibabaCloud::Ocr::Model::RecognizePoiNameRequest;
RecognizePoiNameRequest::RecognizePoiNameRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizePoiName")
{
setMethod(HttpRequest::Method::Post);
}
RecognizePoiNameRequest::~RecognizePoiNameRequest()
{}
std::string RecognizePoiNameRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/ocr/model/RecognizePoiNameRequest.h>
using AlibabaCloud::Ocr::Model::RecognizePoiNameRequest;
RecognizePoiNameRequest::RecognizePoiNameRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizePoiName") {
setMethod(HttpRequest::Method::Post);
}
void RecognizePoiNameRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
RecognizePoiNameRequest::~RecognizePoiNameRequest() {}
std::string RecognizePoiNameRequest::getImageURL() const {
return imageURL_;
}
void RecognizePoiNameRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

8
ocr/src/model/RecognizePoiNameResult.cc
View File

@@ -48,14 +48,14 @@ void RecognizePoiNameResult::parse(const std::string &payload)
for (auto dataNodeSignboardsSignboardsItemTextsTextsItem : allTextsNode)
{
Data::SignboardsItem::TextsItem textsObject;
if(!dataNodeSignboardsSignboardsItemTextsTextsItem["Label"].isNull())
textsObject.label = dataNodeSignboardsSignboardsItemTextsTextsItem["Label"].asString();
if(!dataNodeSignboardsSignboardsItemTextsTextsItem["Type"].isNull())
textsObject.type = dataNodeSignboardsSignboardsItemTextsTextsItem["Type"].asString();
if(!dataNodeSignboardsSignboardsItemTextsTextsItem["Score"].isNull())
textsObject.score = std::stof(dataNodeSignboardsSignboardsItemTextsTextsItem["Score"].asString());
if(!dataNodeSignboardsSignboardsItemTextsTextsItem["Tag"].isNull())
textsObject.tag = dataNodeSignboardsSignboardsItemTextsTextsItem["Tag"].asString();
if(!dataNodeSignboardsSignboardsItemTextsTextsItem["Type"].isNull())
textsObject.type = dataNodeSignboardsSignboardsItemTextsTextsItem["Type"].asString();
if(!dataNodeSignboardsSignboardsItemTextsTextsItem["Label"].isNull())
textsObject.label = dataNodeSignboardsSignboardsItemTextsTextsItem["Label"].asString();
auto allPoints = value["Points"]["Points"];
for (auto value : allPoints)
textsObject.points.push_back(value.asString());

83
ocr/src/model/RecognizeQrCodeRequest.cc
View File

@@ -1,77 +1,40 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeQrCodeRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeQrCodeRequest;
RecognizeQrCodeRequest::RecognizeQrCodeRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeQrCode")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeQrCodeRequest::~RecognizeQrCodeRequest()
{}
bool RecognizeQrCodeRequest::getFormatResultToJson()const
{
return formatResultToJson_;
*/
#include <alibabacloud/ocr/model/RecognizeQrCodeRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeQrCodeRequest;
RecognizeQrCodeRequest::RecognizeQrCodeRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeQrCode") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeQrCodeRequest::setFormatResultToJson(bool formatResultToJson)
{
formatResultToJson_ = formatResultToJson;
setParameter("FormatResultToJson", formatResultToJson ? "true" : "false");
RecognizeQrCodeRequest::~RecognizeQrCodeRequest() {}
std::vector<RecognizeQrCodeRequest::Tasks> RecognizeQrCodeRequest::getTasks() const {
return tasks_;
}
std::string RecognizeQrCodeRequest::getOssFile()const
{
return ossFile_;
}
void RecognizeQrCodeRequest::setOssFile(const std::string& ossFile)
{
ossFile_ = ossFile;
setParameter("OssFile", ossFile);
}
std::vector<RecognizeQrCodeRequest::Tasks> RecognizeQrCodeRequest::getTasks()const
{
return tasks_;
}
void RecognizeQrCodeRequest::setTasks(const std::vector<Tasks>& tasks)
{
tasks_ = tasks;
for(int dep1 = 0; dep1!= tasks.size(); dep1++) {
auto tasksObj = tasks.at(dep1);
std::string tasksObjStr = "Tasks." + std::to_string(dep1 + 1);
setParameter(tasksObjStr + ".ImageURL", tasksObj.imageURL);
}
}
std::string RecognizeQrCodeRequest::getRequestProxyBy()const
{
return requestProxyBy_;
}
void RecognizeQrCodeRequest::setRequestProxyBy(const std::string& requestProxyBy)
{
requestProxyBy_ = requestProxyBy;
setParameter("RequestProxyBy", requestProxyBy);
void RecognizeQrCodeRequest::setTasks(const std::vector<RecognizeQrCodeRequest::Tasks> &tasks) {
tasks_ = tasks;
for(int dep1 = 0; dep1 != tasks.size(); dep1++) {
auto tasksObj = tasks.at(dep1);
std::string tasksObjStr = std::string("Tasks") + "." + std::to_string(dep1 + 1);
setBodyParameter(tasksObjStr + ".ImageURL", tasksObj.imageURL);
}
}

46
ocr/src/model/RecognizeQuotaInvoiceRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeQuotaInvoiceRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeQuotaInvoiceRequest;
RecognizeQuotaInvoiceRequest::RecognizeQuotaInvoiceRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeQuotaInvoice")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeQuotaInvoiceRequest::~RecognizeQuotaInvoiceRequest()
{}
std::string RecognizeQuotaInvoiceRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/ocr/model/RecognizeQuotaInvoiceRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeQuotaInvoiceRequest;
RecognizeQuotaInvoiceRequest::RecognizeQuotaInvoiceRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeQuotaInvoice") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeQuotaInvoiceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
RecognizeQuotaInvoiceRequest::~RecognizeQuotaInvoiceRequest() {}
std::string RecognizeQuotaInvoiceRequest::getImageURL() const {
return imageURL_;
}
void RecognizeQuotaInvoiceRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

58
ocr/src/model/RecognizeStampRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeStampRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeStampRequest;
RecognizeStampRequest::RecognizeStampRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeStamp")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeStampRequest::~RecognizeStampRequest()
{}
int RecognizeStampRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeStampRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeStampRequest;
RecognizeStampRequest::RecognizeStampRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeStamp") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeStampRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeStampRequest::~RecognizeStampRequest() {}
int RecognizeStampRequest::getImageType() const {
return imageType_;
}
std::string RecognizeStampRequest::getImageURL()const
{
return imageURL_;
void RecognizeStampRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeStampRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeStampRequest::getImageURL() const {
return imageURL_;
}
void RecognizeStampRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

18
ocr/src/model/RecognizeStampResult.cc
View File

@@ -48,26 +48,26 @@ void RecognizeStampResult::parse(const std::string &payload)
for (auto dataNodeResultsResultsItemGeneralTextGeneralTextItem : allGeneralTextNode)
{
Data::ResultsItem::GeneralTextItem generalTextObject;
if(!dataNodeResultsResultsItemGeneralTextGeneralTextItem["Content"].isNull())
generalTextObject.content = dataNodeResultsResultsItemGeneralTextGeneralTextItem["Content"].asString();
if(!dataNodeResultsResultsItemGeneralTextGeneralTextItem["Confidence"].isNull())
generalTextObject.confidence = std::stof(dataNodeResultsResultsItemGeneralTextGeneralTextItem["Confidence"].asString());
if(!dataNodeResultsResultsItemGeneralTextGeneralTextItem["Content"].isNull())
generalTextObject.content = dataNodeResultsResultsItemGeneralTextGeneralTextItem["Content"].asString();
resultsItemObject.generalText.push_back(generalTextObject);
}
auto textNode = value["Text"];
if(!textNode["Confidence"].isNull())
resultsItemObject.text.confidence = std::stof(textNode["Confidence"].asString());
if(!textNode["Content"].isNull())
resultsItemObject.text.content = textNode["Content"].asString();
auto roiNode = value["Roi"];
if(!roiNode["Left"].isNull())
resultsItemObject.roi.left = std::stoi(roiNode["Left"].asString());
if(!roiNode["Top"].isNull())
resultsItemObject.roi.top = std::stoi(roiNode["Top"].asString());
if(!roiNode["Width"].isNull())
resultsItemObject.roi.width = std::stoi(roiNode["Width"].asString());
if(!roiNode["Height"].isNull())
resultsItemObject.roi.height = std::stoi(roiNode["Height"].asString());
auto textNode = value["Text"];
if(!textNode["Content"].isNull())
resultsItemObject.text.content = textNode["Content"].asString();
if(!textNode["Confidence"].isNull())
resultsItemObject.text.confidence = std::stof(textNode["Confidence"].asString());
if(!roiNode["Left"].isNull())
resultsItemObject.roi.left = std::stoi(roiNode["Left"].asString());
data_.results.push_back(resultsItemObject);
}

118
ocr/src/model/RecognizeTableRequest.cc
View File

@@ -1,106 +1,90 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeTableRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTableRequest;
RecognizeTableRequest::RecognizeTableRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeTable")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeTableRequest::~RecognizeTableRequest()
{}
int RecognizeTableRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeTableRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTableRequest;
RecognizeTableRequest::RecognizeTableRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeTable") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeTableRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeTableRequest::~RecognizeTableRequest() {}
bool RecognizeTableRequest::getUseFinanceModel() const {
return useFinanceModel_;
}
bool RecognizeTableRequest::getUseFinanceModel()const
{
return useFinanceModel_;
void RecognizeTableRequest::setUseFinanceModel(bool useFinanceModel) {
useFinanceModel_ = useFinanceModel;
setBodyParameter(std::string("UseFinanceModel"), useFinanceModel ? "true" : "false");
}
void RecognizeTableRequest::setUseFinanceModel(bool useFinanceModel)
{
useFinanceModel_ = useFinanceModel;
setBodyParameter("UseFinanceModel", useFinanceModel ? "true" : "false");
bool RecognizeTableRequest::getSkipDetection() const {
return skipDetection_;
}
bool RecognizeTableRequest::getSkipDetection()const
{
return skipDetection_;
void RecognizeTableRequest::setSkipDetection(bool skipDetection) {
skipDetection_ = skipDetection;
setBodyParameter(std::string("SkipDetection"), skipDetection ? "true" : "false");
}
void RecognizeTableRequest::setSkipDetection(bool skipDetection)
{
skipDetection_ = skipDetection;
setBodyParameter("SkipDetection", skipDetection ? "true" : "false");
std::string RecognizeTableRequest::getOutputFormat() const {
return outputFormat_;
}
std::string RecognizeTableRequest::getImageURL()const
{
return imageURL_;
void RecognizeTableRequest::setOutputFormat(const std::string &outputFormat) {
outputFormat_ = outputFormat;
setBodyParameter(std::string("OutputFormat"), outputFormat);
}
void RecognizeTableRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
bool RecognizeTableRequest::getAssureDirection() const {
return assureDirection_;
}
std::string RecognizeTableRequest::getOutputFormat()const
{
return outputFormat_;
void RecognizeTableRequest::setAssureDirection(bool assureDirection) {
assureDirection_ = assureDirection;
setBodyParameter(std::string("AssureDirection"), assureDirection ? "true" : "false");
}
void RecognizeTableRequest::setOutputFormat(const std::string& outputFormat)
{
outputFormat_ = outputFormat;
setBodyParameter("OutputFormat", outputFormat);
bool RecognizeTableRequest::getHasLine() const {
return hasLine_;
}
bool RecognizeTableRequest::getAssureDirection()const
{
return assureDirection_;
void RecognizeTableRequest::setHasLine(bool hasLine) {
hasLine_ = hasLine;
setBodyParameter(std::string("HasLine"), hasLine ? "true" : "false");
}
void RecognizeTableRequest::setAssureDirection(bool assureDirection)
{
assureDirection_ = assureDirection;
setBodyParameter("AssureDirection", assureDirection ? "true" : "false");
int RecognizeTableRequest::getImageType() const {
return imageType_;
}
bool RecognizeTableRequest::getHasLine()const
{
return hasLine_;
void RecognizeTableRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeTableRequest::setHasLine(bool hasLine)
{
hasLine_ = hasLine;
setBodyParameter("HasLine", hasLine ? "true" : "false");
std::string RecognizeTableRequest::getImageURL() const {
return imageURL_;
}
void RecognizeTableRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

16
ocr/src/model/RecognizeTableResult.cc
View File

@@ -54,18 +54,18 @@ void RecognizeTableResult::parse(const std::string &payload)
for (auto dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn : allTableColumnsNode)
{
Data::Table::TableRow::TableColumn tableColumnsObject;
if(!dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["StartColumn"].isNull())
tableColumnsObject.startColumn = std::stoi(dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["StartColumn"].asString());
if(!dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["StartRow"].isNull())
tableColumnsObject.startRow = std::stoi(dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["StartRow"].asString());
if(!dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["EndColumn"].isNull())
tableColumnsObject.endColumn = std::stoi(dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["EndColumn"].asString());
if(!dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["EndRow"].isNull())
tableColumnsObject.endRow = std::stoi(dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["EndRow"].asString());
if(!dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["Height"].isNull())
tableColumnsObject.height = std::stoi(dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["Height"].asString());
if(!dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["EndColumn"].isNull())
tableColumnsObject.endColumn = std::stoi(dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["EndColumn"].asString());
if(!dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["Width"].isNull())
tableColumnsObject.width = std::stoi(dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["Width"].asString());
if(!dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["Height"].isNull())
tableColumnsObject.height = std::stoi(dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["Height"].asString());
if(!dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["StartRow"].isNull())
tableColumnsObject.startRow = std::stoi(dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["StartRow"].asString());
if(!dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["StartColumn"].isNull())
tableColumnsObject.startColumn = std::stoi(dataNodeTablesTableTableRowsTableRowTableColumnsTableColumn["StartColumn"].asString());
auto allTexts = value["Texts"]["Text"];
for (auto value : allTexts)
tableColumnsObject.texts.push_back(value.asString());

46
ocr/src/model/RecognizeTakeoutOrderRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeTakeoutOrderRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTakeoutOrderRequest;
RecognizeTakeoutOrderRequest::RecognizeTakeoutOrderRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeTakeoutOrder")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeTakeoutOrderRequest::~RecognizeTakeoutOrderRequest()
{}
std::string RecognizeTakeoutOrderRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/ocr/model/RecognizeTakeoutOrderRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTakeoutOrderRequest;
RecognizeTakeoutOrderRequest::RecognizeTakeoutOrderRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeTakeoutOrder") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeTakeoutOrderRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
RecognizeTakeoutOrderRequest::~RecognizeTakeoutOrderRequest() {}
std::string RecognizeTakeoutOrderRequest::getImageURL() const {
return imageURL_;
}
void RecognizeTakeoutOrderRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

4
ocr/src/model/RecognizeTakeoutOrderResult.cc
View File

@@ -44,12 +44,12 @@ void RecognizeTakeoutOrderResult::parse(const std::string &payload)
for (auto dataNodeElementsElement : allElementsNode)
{
Data::Element elementObject;
if(!dataNodeElementsElement["Value"].isNull())
elementObject.value = dataNodeElementsElement["Value"].asString();
if(!dataNodeElementsElement["Score"].isNull())
elementObject.score = std::stof(dataNodeElementsElement["Score"].asString());
if(!dataNodeElementsElement["Name"].isNull())
elementObject.name = dataNodeElementsElement["Name"].asString();
if(!dataNodeElementsElement["Value"].isNull())
elementObject.value = dataNodeElementsElement["Value"].asString();
auto allBoxes = value["Boxes"]["Box"];
for (auto value : allBoxes)
elementObject.boxes.push_back(value.asString());

58
ocr/src/model/RecognizeTaxiInvoiceRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeTaxiInvoiceRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTaxiInvoiceRequest;
RecognizeTaxiInvoiceRequest::RecognizeTaxiInvoiceRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeTaxiInvoice")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeTaxiInvoiceRequest::~RecognizeTaxiInvoiceRequest()
{}
int RecognizeTaxiInvoiceRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeTaxiInvoiceRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTaxiInvoiceRequest;
RecognizeTaxiInvoiceRequest::RecognizeTaxiInvoiceRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeTaxiInvoice") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeTaxiInvoiceRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeTaxiInvoiceRequest::~RecognizeTaxiInvoiceRequest() {}
int RecognizeTaxiInvoiceRequest::getImageType() const {
return imageType_;
}
std::string RecognizeTaxiInvoiceRequest::getImageURL()const
{
return imageURL_;
void RecognizeTaxiInvoiceRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeTaxiInvoiceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeTaxiInvoiceRequest::getImageURL() const {
return imageURL_;
}
void RecognizeTaxiInvoiceRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

22
ocr/src/model/RecognizeTaxiInvoiceResult.cc
View File

@@ -55,27 +55,27 @@ void RecognizeTaxiInvoiceResult::parse(const std::string &payload)
auto itemRoiNode = value["ItemRoi"];
if(!itemRoiNode["Angle"].isNull())
itemsObject.itemRoi.angle = std::stof(itemRoiNode["Angle"].asString());
auto centerNode = itemRoiNode["Center"];
if(!centerNode["X"].isNull())
itemsObject.itemRoi.center.x = std::stof(centerNode["X"].asString());
if(!centerNode["Y"].isNull())
itemsObject.itemRoi.center.y = std::stof(centerNode["Y"].asString());
auto sizeNode = itemRoiNode["Size"];
if(!sizeNode["H"].isNull())
itemsObject.itemRoi.size.h = std::stof(sizeNode["H"].asString());
if(!sizeNode["W"].isNull())
itemsObject.itemRoi.size.w = std::stof(sizeNode["W"].asString());
if(!sizeNode["H"].isNull())
itemsObject.itemRoi.size.h = std::stof(sizeNode["H"].asString());
auto centerNode = itemRoiNode["Center"];
if(!centerNode["Y"].isNull())
itemsObject.itemRoi.center.y = std::stof(centerNode["Y"].asString());
if(!centerNode["X"].isNull())
itemsObject.itemRoi.center.x = std::stof(centerNode["X"].asString());
invoiceObject.items.push_back(itemsObject);
}
auto invoiceRoiNode = value["InvoiceRoi"];
if(!invoiceRoiNode["H"].isNull())
invoiceObject.invoiceRoi.h = std::stof(invoiceRoiNode["H"].asString());
if(!invoiceRoiNode["W"].isNull())
invoiceObject.invoiceRoi.w = std::stof(invoiceRoiNode["W"].asString());
if(!invoiceRoiNode["X"].isNull())
invoiceObject.invoiceRoi.x = std::stof(invoiceRoiNode["X"].asString());
if(!invoiceRoiNode["H"].isNull())
invoiceObject.invoiceRoi.h = std::stof(invoiceRoiNode["H"].asString());
if(!invoiceRoiNode["Y"].isNull())
invoiceObject.invoiceRoi.y = std::stof(invoiceRoiNode["Y"].asString());
if(!invoiceRoiNode["X"].isNull())
invoiceObject.invoiceRoi.x = std::stof(invoiceRoiNode["X"].asString());
data_.invoices.push_back(invoiceObject);
}

46
ocr/src/model/RecognizeTicketInvoiceRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeTicketInvoiceRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTicketInvoiceRequest;
RecognizeTicketInvoiceRequest::RecognizeTicketInvoiceRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeTicketInvoice")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeTicketInvoiceRequest::~RecognizeTicketInvoiceRequest()
{}
std::string RecognizeTicketInvoiceRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/ocr/model/RecognizeTicketInvoiceRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTicketInvoiceRequest;
RecognizeTicketInvoiceRequest::RecognizeTicketInvoiceRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeTicketInvoice") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeTicketInvoiceRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
RecognizeTicketInvoiceRequest::~RecognizeTicketInvoiceRequest() {}
std::string RecognizeTicketInvoiceRequest::getImageURL() const {
return imageURL_;
}
void RecognizeTicketInvoiceRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

58
ocr/src/model/RecognizeTrainTicketRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeTrainTicketRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTrainTicketRequest;
RecognizeTrainTicketRequest::RecognizeTrainTicketRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeTrainTicket")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeTrainTicketRequest::~RecognizeTrainTicketRequest()
{}
int RecognizeTrainTicketRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeTrainTicketRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeTrainTicketRequest;
RecognizeTrainTicketRequest::RecognizeTrainTicketRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeTrainTicket") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeTrainTicketRequest::setImageType(int imageType)
{
imageType_ = imageType;
setBodyParameter("ImageType", std::to_string(imageType));
RecognizeTrainTicketRequest::~RecognizeTrainTicketRequest() {}
int RecognizeTrainTicketRequest::getImageType() const {
return imageType_;
}
std::string RecognizeTrainTicketRequest::getImageURL()const
{
return imageURL_;
void RecognizeTrainTicketRequest::setImageType(int imageType) {
imageType_ = imageType;
setBodyParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeTrainTicketRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
std::string RecognizeTrainTicketRequest::getImageURL() const {
return imageURL_;
}
void RecognizeTrainTicketRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

28
ocr/src/model/RecognizeTrainTicketResult.cc
View File

@@ -40,22 +40,22 @@ void RecognizeTrainTicketResult::parse(const std::string &payload)
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
if(!dataNode["Date"].isNull())
data_.date = dataNode["Date"].asString();
if(!dataNode["Destination"].isNull())
data_.destination = dataNode["Destination"].asString();
if(!dataNode["Level"].isNull())
data_.level = dataNode["Level"].asString();
if(!dataNode["Number"].isNull())
data_.number = dataNode["Number"].asString();
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["DepartureStation"].isNull())
data_.departureStation = dataNode["DepartureStation"].asString();
if(!dataNode["Seat"].isNull())
data_.seat = dataNode["Seat"].asString();
if(!dataNode["Price"].isNull())
data_.price = std::stof(dataNode["Price"].asString());
if(!dataNode["Destination"].isNull())
data_.destination = dataNode["Destination"].asString();
if(!dataNode["DepartureStation"].isNull())
data_.departureStation = dataNode["DepartureStation"].asString();
if(!dataNode["Date"].isNull())
data_.date = dataNode["Date"].asString();
if(!dataNode["Number"].isNull())
data_.number = dataNode["Number"].asString();
if(!dataNode["Seat"].isNull())
data_.seat = dataNode["Seat"].asString();
if(!dataNode["Name"].isNull())
data_.name = dataNode["Name"].asString();
if(!dataNode["Level"].isNull())
data_.level = dataNode["Level"].asString();
}

36
ocr/src/model/RecognizeUkraineIdentityCardRequest.cc Normal file
View File

@@ -0,0 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeUkraineIdentityCardRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeUkraineIdentityCardRequest;
RecognizeUkraineIdentityCardRequest::RecognizeUkraineIdentityCardRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeUkraineIdentityCard") {
setMethod(HttpRequest::Method::Post);
}
RecognizeUkraineIdentityCardRequest::~RecognizeUkraineIdentityCardRequest() {}
std::string RecognizeUkraineIdentityCardRequest::getImageUrl() const {
return imageUrl_;
}
void RecognizeUkraineIdentityCardRequest::setImageUrl(const std::string &imageUrl) {
imageUrl_ = imageUrl;
setBodyParameter(std::string("ImageUrl"), imageUrl);
}

259
ocr/src/model/RecognizeUkraineIdentityCardResult.cc Normal file
View File

@@ -0,0 +1,259 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeUkraineIdentityCardResult.h>
#include <json/json.h>
using namespace AlibabaCloud::Ocr;
using namespace AlibabaCloud::Ocr::Model;
RecognizeUkraineIdentityCardResult::RecognizeUkraineIdentityCardResult() :
ServiceResult()
{}
RecognizeUkraineIdentityCardResult::RecognizeUkraineIdentityCardResult(const std::string &payload) :
ServiceResult()
{
parse(payload);
}
RecognizeUkraineIdentityCardResult::~RecognizeUkraineIdentityCardResult()
{}
void RecognizeUkraineIdentityCardResult::parse(const std::string &payload)
{
Json::Reader reader;
Json::Value value;
reader.parse(payload, value);
setRequestId(value["RequestId"].asString());
auto dataNode = value["Data"];
auto birthDateNode = dataNode["BirthDate"];
if(!birthDateNode["Text"].isNull())
data_.birthDate.text = birthDateNode["Text"].asString();
if(!birthDateNode["Score"].isNull())
data_.birthDate.score = std::stof(birthDateNode["Score"].asString());
auto allKeyPointsNode = birthDateNode["KeyPoints"]["keyPointsItem"];
for (auto birthDateNodeKeyPointskeyPointsItem : allKeyPointsNode)
{
Data::BirthDate::KeyPointsItem keyPointsItemObject;
if(!birthDateNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItemObject.x = std::stof(birthDateNodeKeyPointskeyPointsItem["X"].asString());
if(!birthDateNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItemObject.y = std::stof(birthDateNodeKeyPointskeyPointsItem["Y"].asString());
data_.birthDate.keyPoints.push_back(keyPointsItemObject);
}
auto cardBoxNode = dataNode["CardBox"];
if(!cardBoxNode["Text"].isNull())
data_.cardBox.text = cardBoxNode["Text"].asString();
if(!cardBoxNode["Score"].isNull())
data_.cardBox.score = std::stof(cardBoxNode["Score"].asString());
auto allKeyPoints1Node = cardBoxNode["KeyPoints"]["keyPointsItem"];
for (auto cardBoxNodeKeyPointskeyPointsItem : allKeyPoints1Node)
{
Data::CardBox::KeyPointsItem2 keyPointsItem2Object;
if(!cardBoxNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem2Object.x = std::stof(cardBoxNodeKeyPointskeyPointsItem["X"].asString());
if(!cardBoxNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem2Object.y = std::stof(cardBoxNodeKeyPointskeyPointsItem["Y"].asString());
data_.cardBox.keyPoints1.push_back(keyPointsItem2Object);
}
auto documentNumberNode = dataNode["DocumentNumber"];
if(!documentNumberNode["Text"].isNull())
data_.documentNumber.text = documentNumberNode["Text"].asString();
if(!documentNumberNode["Score"].isNull())
data_.documentNumber.score = std::stof(documentNumberNode["Score"].asString());
auto allKeyPoints3Node = documentNumberNode["KeyPoints"]["keyPointsItem"];
for (auto documentNumberNodeKeyPointskeyPointsItem : allKeyPoints3Node)
{
Data::DocumentNumber::KeyPointsItem4 keyPointsItem4Object;
if(!documentNumberNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem4Object.x = std::stof(documentNumberNodeKeyPointskeyPointsItem["X"].asString());
if(!documentNumberNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem4Object.y = std::stof(documentNumberNodeKeyPointskeyPointsItem["Y"].asString());
data_.documentNumber.keyPoints3.push_back(keyPointsItem4Object);
}
auto expiryDateNode = dataNode["ExpiryDate"];
if(!expiryDateNode["Text"].isNull())
data_.expiryDate.text = expiryDateNode["Text"].asString();
if(!expiryDateNode["Score"].isNull())
data_.expiryDate.score = std::stof(expiryDateNode["Score"].asString());
auto allKeyPoints5Node = expiryDateNode["KeyPoints"]["keyPointsItem"];
for (auto expiryDateNodeKeyPointskeyPointsItem : allKeyPoints5Node)
{
Data::ExpiryDate::KeyPointsItem6 keyPointsItem6Object;
if(!expiryDateNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem6Object.x = std::stof(expiryDateNodeKeyPointskeyPointsItem["X"].asString());
if(!expiryDateNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem6Object.y = std::stof(expiryDateNodeKeyPointskeyPointsItem["Y"].asString());
data_.expiryDate.keyPoints5.push_back(keyPointsItem6Object);
}
auto nameEnglishNode = dataNode["NameEnglish"];
if(!nameEnglishNode["Text"].isNull())
data_.nameEnglish.text = nameEnglishNode["Text"].asString();
if(!nameEnglishNode["Score"].isNull())
data_.nameEnglish.score = std::stof(nameEnglishNode["Score"].asString());
auto allKeyPoints7Node = nameEnglishNode["KeyPoints"]["keyPointsItem"];
for (auto nameEnglishNodeKeyPointskeyPointsItem : allKeyPoints7Node)
{
Data::NameEnglish::KeyPointsItem8 keyPointsItem8Object;
if(!nameEnglishNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem8Object.x = std::stof(nameEnglishNodeKeyPointskeyPointsItem["X"].asString());
if(!nameEnglishNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem8Object.y = std::stof(nameEnglishNodeKeyPointskeyPointsItem["Y"].asString());
data_.nameEnglish.keyPoints7.push_back(keyPointsItem8Object);
}
auto nameUkraineNode = dataNode["NameUkraine"];
if(!nameUkraineNode["Text"].isNull())
data_.nameUkraine.text = nameUkraineNode["Text"].asString();
if(!nameUkraineNode["Score"].isNull())
data_.nameUkraine.score = std::stof(nameUkraineNode["Score"].asString());
auto allKeyPoints9Node = nameUkraineNode["KeyPoints"]["keyPointsItem"];
for (auto nameUkraineNodeKeyPointskeyPointsItem : allKeyPoints9Node)
{
Data::NameUkraine::KeyPointsItem10 keyPointsItem10Object;
if(!nameUkraineNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem10Object.x = std::stof(nameUkraineNodeKeyPointskeyPointsItem["X"].asString());
if(!nameUkraineNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem10Object.y = std::stof(nameUkraineNodeKeyPointskeyPointsItem["Y"].asString());
data_.nameUkraine.keyPoints9.push_back(keyPointsItem10Object);
}
auto nationalityNode = dataNode["Nationality"];
if(!nationalityNode["Text"].isNull())
data_.nationality.text = nationalityNode["Text"].asString();
if(!nationalityNode["Score"].isNull())
data_.nationality.score = std::stof(nationalityNode["Score"].asString());
auto allKeyPoints11Node = nationalityNode["KeyPoints"]["keyPointsItem"];
for (auto nationalityNodeKeyPointskeyPointsItem : allKeyPoints11Node)
{
Data::Nationality::KeyPointsItem12 keyPointsItem12Object;
if(!nationalityNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem12Object.x = std::stof(nationalityNodeKeyPointskeyPointsItem["X"].asString());
if(!nationalityNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem12Object.y = std::stof(nationalityNodeKeyPointskeyPointsItem["Y"].asString());
data_.nationality.keyPoints11.push_back(keyPointsItem12Object);
}
auto patronymicNode = dataNode["Patronymic"];
if(!patronymicNode["Text"].isNull())
data_.patronymic.text = patronymicNode["Text"].asString();
if(!patronymicNode["Score"].isNull())
data_.patronymic.score = std::stof(patronymicNode["Score"].asString());
auto allKeyPoints13Node = patronymicNode["KeyPoints"]["keyPointsItem"];
for (auto patronymicNodeKeyPointskeyPointsItem : allKeyPoints13Node)
{
Data::Patronymic::KeyPointsItem14 keyPointsItem14Object;
if(!patronymicNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem14Object.x = std::stof(patronymicNodeKeyPointskeyPointsItem["X"].asString());
if(!patronymicNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem14Object.y = std::stof(patronymicNodeKeyPointskeyPointsItem["Y"].asString());
data_.patronymic.keyPoints13.push_back(keyPointsItem14Object);
}
auto portraitBoxNode = dataNode["PortraitBox"];
if(!portraitBoxNode["Text"].isNull())
data_.portraitBox.text = portraitBoxNode["Text"].asString();
if(!portraitBoxNode["Score"].isNull())
data_.portraitBox.score = std::stof(portraitBoxNode["Score"].asString());
auto allKeyPoints15Node = portraitBoxNode["KeyPoints"]["keyPointsItem"];
for (auto portraitBoxNodeKeyPointskeyPointsItem : allKeyPoints15Node)
{
Data::PortraitBox::KeyPointsItem16 keyPointsItem16Object;
if(!portraitBoxNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem16Object.x = std::stof(portraitBoxNodeKeyPointskeyPointsItem["X"].asString());
if(!portraitBoxNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem16Object.y = std::stof(portraitBoxNodeKeyPointskeyPointsItem["Y"].asString());
data_.portraitBox.keyPoints15.push_back(keyPointsItem16Object);
}
auto recordNumberNode = dataNode["RecordNumber"];
if(!recordNumberNode["Text"].isNull())
data_.recordNumber.text = recordNumberNode["Text"].asString();
if(!recordNumberNode["Score"].isNull())
data_.recordNumber.score = std::stof(recordNumberNode["Score"].asString());
auto allKeyPoints17Node = recordNumberNode["KeyPoints"]["keyPointsItem"];
for (auto recordNumberNodeKeyPointskeyPointsItem : allKeyPoints17Node)
{
Data::RecordNumber::KeyPointsItem18 keyPointsItem18Object;
if(!recordNumberNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem18Object.x = std::stof(recordNumberNodeKeyPointskeyPointsItem["X"].asString());
if(!recordNumberNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem18Object.y = std::stof(recordNumberNodeKeyPointskeyPointsItem["Y"].asString());
data_.recordNumber.keyPoints17.push_back(keyPointsItem18Object);
}
auto sexNode = dataNode["Sex"];
if(!sexNode["Text"].isNull())
data_.sex.text = sexNode["Text"].asString();
if(!sexNode["Score"].isNull())
data_.sex.score = std::stof(sexNode["Score"].asString());
auto allKeyPoints19Node = sexNode["KeyPoints"]["keyPointsItem"];
for (auto sexNodeKeyPointskeyPointsItem : allKeyPoints19Node)
{
Data::Sex::KeyPointsItem20 keyPointsItem20Object;
if(!sexNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem20Object.x = std::stof(sexNodeKeyPointskeyPointsItem["X"].asString());
if(!sexNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem20Object.y = std::stof(sexNodeKeyPointskeyPointsItem["Y"].asString());
data_.sex.keyPoints19.push_back(keyPointsItem20Object);
}
auto surnameEnglishNode = dataNode["SurnameEnglish"];
if(!surnameEnglishNode["Text"].isNull())
data_.surnameEnglish.text = surnameEnglishNode["Text"].asString();
if(!surnameEnglishNode["Score"].isNull())
data_.surnameEnglish.score = std::stof(surnameEnglishNode["Score"].asString());
auto allKeyPoints21Node = surnameEnglishNode["KeyPoints"]["keyPointsItem"];
for (auto surnameEnglishNodeKeyPointskeyPointsItem : allKeyPoints21Node)
{
Data::SurnameEnglish::KeyPointsItem22 keyPointsItem22Object;
if(!surnameEnglishNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem22Object.x = std::stof(surnameEnglishNodeKeyPointskeyPointsItem["X"].asString());
if(!surnameEnglishNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem22Object.y = std::stof(surnameEnglishNodeKeyPointskeyPointsItem["Y"].asString());
data_.surnameEnglish.keyPoints21.push_back(keyPointsItem22Object);
}
auto surnameUkraineNode = dataNode["SurnameUkraine"];
if(!surnameUkraineNode["Text"].isNull())
data_.surnameUkraine.text = surnameUkraineNode["Text"].asString();
if(!surnameUkraineNode["Score"].isNull())
data_.surnameUkraine.score = std::stof(surnameUkraineNode["Score"].asString());
auto allKeyPoints23Node = surnameUkraineNode["KeyPoints"]["keyPointsItem"];
for (auto surnameUkraineNodeKeyPointskeyPointsItem : allKeyPoints23Node)
{
Data::SurnameUkraine::KeyPointsItem24 keyPointsItem24Object;
if(!surnameUkraineNodeKeyPointskeyPointsItem["X"].isNull())
keyPointsItem24Object.x = std::stof(surnameUkraineNodeKeyPointskeyPointsItem["X"].asString());
if(!surnameUkraineNodeKeyPointskeyPointsItem["Y"].isNull())
keyPointsItem24Object.y = std::stof(surnameUkraineNodeKeyPointskeyPointsItem["Y"].asString());
data_.surnameUkraine.keyPoints23.push_back(keyPointsItem24Object);
}
if(!value["Code"].isNull())
code_ = value["Code"].asString();
if(!value["Message"].isNull())
message_ = value["Message"].asString();
}
std::string RecognizeUkraineIdentityCardResult::getMessage()const
{
return message_;
}
RecognizeUkraineIdentityCardResult::Data RecognizeUkraineIdentityCardResult::getData()const
{
return data_;
}
std::string RecognizeUkraineIdentityCardResult::getCode()const
{
return code_;
}

58
ocr/src/model/RecognizeVATInvoiceRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeVATInvoiceRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVATInvoiceRequest;
RecognizeVATInvoiceRequest::RecognizeVATInvoiceRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeVATInvoice")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVATInvoiceRequest::~RecognizeVATInvoiceRequest()
{}
std::string RecognizeVATInvoiceRequest::getFileType()const
{
return fileType_;
*/
#include <alibabacloud/ocr/model/RecognizeVATInvoiceRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVATInvoiceRequest;
RecognizeVATInvoiceRequest::RecognizeVATInvoiceRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeVATInvoice") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeVATInvoiceRequest::setFileType(const std::string& fileType)
{
fileType_ = fileType;
setBodyParameter("FileType", fileType);
RecognizeVATInvoiceRequest::~RecognizeVATInvoiceRequest() {}
std::string RecognizeVATInvoiceRequest::getFileType() const {
return fileType_;
}
std::string RecognizeVATInvoiceRequest::getFileURL()const
{
return fileURL_;
void RecognizeVATInvoiceRequest::setFileType(const std::string &fileType) {
fileType_ = fileType;
setBodyParameter(std::string("FileType"), fileType);
}
void RecognizeVATInvoiceRequest::setFileURL(const std::string& fileURL)
{
fileURL_ = fileURL;
setBodyParameter("FileURL", fileURL);
std::string RecognizeVATInvoiceRequest::getFileURL() const {
return fileURL_;
}
void RecognizeVATInvoiceRequest::setFileURL(const std::string &fileURL) {
fileURL_ = fileURL;
setBodyParameter(std::string("FileURL"), fileURL);
}

58
ocr/src/model/RecognizeVINCodeRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeVINCodeRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVINCodeRequest;
RecognizeVINCodeRequest::RecognizeVINCodeRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeVINCode")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVINCodeRequest::~RecognizeVINCodeRequest()
{}
int RecognizeVINCodeRequest::getImageType()const
{
return imageType_;
*/
#include <alibabacloud/ocr/model/RecognizeVINCodeRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVINCodeRequest;
RecognizeVINCodeRequest::RecognizeVINCodeRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeVINCode") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeVINCodeRequest::setImageType(int imageType)
{
imageType_ = imageType;
setParameter("ImageType", std::to_string(imageType));
RecognizeVINCodeRequest::~RecognizeVINCodeRequest() {}
int RecognizeVINCodeRequest::getImageType() const {
return imageType_;
}
std::string RecognizeVINCodeRequest::getImageURL()const
{
return imageURL_;
void RecognizeVINCodeRequest::setImageType(int imageType) {
imageType_ = imageType;
setParameter(std::string("ImageType"), std::to_string(imageType));
}
void RecognizeVINCodeRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setParameter("ImageURL", imageURL);
std::string RecognizeVINCodeRequest::getImageURL() const {
return imageURL_;
}
void RecognizeVINCodeRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setParameter(std::string("ImageURL"), imageURL);
}

46
ocr/src/model/RecognizeVerificationcodeRequest.cc
View File

@@ -1,40 +1,36 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeVerificationcodeRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVerificationcodeRequest;
RecognizeVerificationcodeRequest::RecognizeVerificationcodeRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeVerificationcode")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVerificationcodeRequest::~RecognizeVerificationcodeRequest()
{}
std::string RecognizeVerificationcodeRequest::getImageURL()const
{
return imageURL_;
*/
#include <alibabacloud/ocr/model/RecognizeVerificationcodeRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVerificationcodeRequest;
RecognizeVerificationcodeRequest::RecognizeVerificationcodeRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeVerificationcode") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeVerificationcodeRequest::setImageURL(const std::string& imageURL)
{
imageURL_ = imageURL;
setBodyParameter("ImageURL", imageURL);
RecognizeVerificationcodeRequest::~RecognizeVerificationcodeRequest() {}
std::string RecognizeVerificationcodeRequest::getImageURL() const {
return imageURL_;
}
void RecognizeVerificationcodeRequest::setImageURL(const std::string &imageURL) {
imageURL_ = imageURL;
setBodyParameter(std::string("ImageURL"), imageURL);
}

84
ocr/src/model/RecognizeVideoCastCrewListRequest.cc
View File

@@ -1,73 +1,65 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeVideoCastCrewListRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVideoCastCrewListRequest;
RecognizeVideoCastCrewListRequest::RecognizeVideoCastCrewListRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeVideoCastCrewList")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVideoCastCrewListRequest::~RecognizeVideoCastCrewListRequest()
{}
Array RecognizeVideoCastCrewListRequest::getParams()const
{
return params_;
*/
#include <alibabacloud/ocr/model/RecognizeVideoCastCrewListRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVideoCastCrewListRequest;
RecognizeVideoCastCrewListRequest::RecognizeVideoCastCrewListRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeVideoCastCrewList") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeVideoCastCrewListRequest::setParams(const Array& params)
{
params_ = params;
setBodyParameter("Params", std::to_string(params));
RecognizeVideoCastCrewListRequest::~RecognizeVideoCastCrewListRequest() {}
std::vector<RecognizeVideoCastCrewListRequest::Params> RecognizeVideoCastCrewListRequest::getParams() const {
return params_;
}
bool RecognizeVideoCastCrewListRequest::getAsync()const
{
return async_;
void RecognizeVideoCastCrewListRequest::setParams(const std::vector<RecognizeVideoCastCrewListRequest::Params> &params) {
params_ = params;
for(int dep1 = 0; dep1 != params.size(); dep1++) {
setBodyParameter(std::string("Params") + "." + std::to_string(dep1 + 1) + ".Type", params[dep1].type);
}
}
void RecognizeVideoCastCrewListRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
bool RecognizeVideoCastCrewListRequest::getAsync() const {
return async_;
}
std::string RecognizeVideoCastCrewListRequest::getRegisterUrl()const
{
return registerUrl_;
void RecognizeVideoCastCrewListRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void RecognizeVideoCastCrewListRequest::setRegisterUrl(const std::string& registerUrl)
{
registerUrl_ = registerUrl;
setBodyParameter("RegisterUrl", registerUrl);
std::string RecognizeVideoCastCrewListRequest::getRegisterUrl() const {
return registerUrl_;
}
std::string RecognizeVideoCastCrewListRequest::getVideoUrl()const
{
return videoUrl_;
void RecognizeVideoCastCrewListRequest::setRegisterUrl(const std::string &registerUrl) {
registerUrl_ = registerUrl;
setBodyParameter(std::string("RegisterUrl"), registerUrl);
}
void RecognizeVideoCastCrewListRequest::setVideoUrl(const std::string& videoUrl)
{
videoUrl_ = videoUrl;
setBodyParameter("VideoUrl", videoUrl);
std::string RecognizeVideoCastCrewListRequest::getVideoUrl() const {
return videoUrl_;
}
void RecognizeVideoCastCrewListRequest::setVideoUrl(const std::string &videoUrl) {
videoUrl_ = videoUrl;
setBodyParameter(std::string("VideoUrl"), videoUrl);
}

58
ocr/src/model/RecognizeVideoCharacterRequest.cc
View File

@@ -1,51 +1,45 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/RecognizeVideoCharacterRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVideoCharacterRequest;
RecognizeVideoCharacterRequest::RecognizeVideoCharacterRequest() :
RpcServiceRequest("ocr", "2019-12-30", "RecognizeVideoCharacter")
{
setMethod(HttpRequest::Method::Post);
}
RecognizeVideoCharacterRequest::~RecognizeVideoCharacterRequest()
{}
bool RecognizeVideoCharacterRequest::getAsync()const
{
return async_;
*/
#include <alibabacloud/ocr/model/RecognizeVideoCharacterRequest.h>
using AlibabaCloud::Ocr::Model::RecognizeVideoCharacterRequest;
RecognizeVideoCharacterRequest::RecognizeVideoCharacterRequest()
: RpcServiceRequest("ocr", "2019-12-30", "RecognizeVideoCharacter") {
setMethod(HttpRequest::Method::Post);
}
void RecognizeVideoCharacterRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
RecognizeVideoCharacterRequest::~RecognizeVideoCharacterRequest() {}
bool RecognizeVideoCharacterRequest::getAsync() const {
return async_;
}
std::string RecognizeVideoCharacterRequest::getVideoURL()const
{
return videoURL_;
void RecognizeVideoCharacterRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void RecognizeVideoCharacterRequest::setVideoURL(const std::string& videoURL)
{
videoURL_ = videoURL;
setBodyParameter("VideoURL", videoURL);
std::string RecognizeVideoCharacterRequest::getVideoURL() const {
return videoURL_;
}
void RecognizeVideoCharacterRequest::setVideoURL(const std::string &videoURL) {
videoURL_ = videoURL;
setBodyParameter(std::string("VideoURL"), videoURL);
}

82
ocr/src/model/TrimDocumentRequest.cc
View File

@@ -1,73 +1,63 @@
/*
* Copyright 2009-2017 Alibaba Cloud 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.
*/
#include <alibabacloud/ocr/model/TrimDocumentRequest.h>
using AlibabaCloud::Ocr::Model::TrimDocumentRequest;
TrimDocumentRequest::TrimDocumentRequest() :
RpcServiceRequest("ocr", "2019-12-30", "TrimDocument")
{
setMethod(HttpRequest::Method::Post);
}
TrimDocumentRequest::~TrimDocumentRequest()
{}
std::string TrimDocumentRequest::getFileType()const
{
return fileType_;
*/
#include <alibabacloud/ocr/model/TrimDocumentRequest.h>
using AlibabaCloud::Ocr::Model::TrimDocumentRequest;
TrimDocumentRequest::TrimDocumentRequest()
: RpcServiceRequest("ocr", "2019-12-30", "TrimDocument") {
setMethod(HttpRequest::Method::Post);
}
void TrimDocumentRequest::setFileType(const std::string& fileType)
{
fileType_ = fileType;
setBodyParameter("FileType", fileType);
TrimDocumentRequest::~TrimDocumentRequest() {}
std::string TrimDocumentRequest::getFileType() const {
return fileType_;
}
bool TrimDocumentRequest::getAsync()const
{
return async_;
void TrimDocumentRequest::setFileType(const std::string &fileType) {
fileType_ = fileType;
setBodyParameter(std::string("FileType"), fileType);
}
void TrimDocumentRequest::setAsync(bool async)
{
async_ = async;
setBodyParameter("Async", async ? "true" : "false");
std::string TrimDocumentRequest::getOutputType() const {
return outputType_;
}
std::string TrimDocumentRequest::getFileURL()const
{
return fileURL_;
void TrimDocumentRequest::setOutputType(const std::string &outputType) {
outputType_ = outputType;
setBodyParameter(std::string("OutputType"), outputType);
}
void TrimDocumentRequest::setFileURL(const std::string& fileURL)
{
fileURL_ = fileURL;
setBodyParameter("FileURL", fileURL);
bool TrimDocumentRequest::getAsync() const {
return async_;
}
std::string TrimDocumentRequest::getOutputType()const
{
return outputType_;
void TrimDocumentRequest::setAsync(bool async) {
async_ = async;
setBodyParameter(std::string("Async"), async ? "true" : "false");
}
void TrimDocumentRequest::setOutputType(const std::string& outputType)
{
outputType_ = outputType;
setBodyParameter("OutputType", outputType);
std::string TrimDocumentRequest::getFileURL() const {
return fileURL_;
}
void TrimDocumentRequest::setFileURL(const std::string &fileURL) {
fileURL_ = fileURL;
setBodyParameter(std::string("FileURL"), fileURL);
}