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

Update RecognizeTable.

Browse Source
This commit is contained in:
sdk-team
2020-08-04 16:27:21 +08:00
parent 1cce84c75f
commit 67f50165c9
94 changed files with 6998 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

222
ocr/include/alibabacloud/ocr/OcrClient.h Normal file
View File

@@ -0,0 +1,222 @@
/*
* 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_OCRCLIENT_H_
#define ALIBABACLOUD_OCR_OCRCLIENT_H_
#include <future>
#include <alibabacloud/core/AsyncCallerContext.h>
#include <alibabacloud/core/EndpointProvider.h>
#include <alibabacloud/core/RpcServiceClient.h>
#include "OcrExport.h"
#include "model/GetAsyncJobResultRequest.h"
#include "model/GetAsyncJobResultResult.h"
#include "model/RecognizeAccountPageRequest.h"
#include "model/RecognizeAccountPageResult.h"
#include "model/RecognizeBankCardRequest.h"
#include "model/RecognizeBankCardResult.h"
#include "model/RecognizeBusinessCardRequest.h"
#include "model/RecognizeBusinessCardResult.h"
#include "model/RecognizeBusinessLicenseRequest.h"
#include "model/RecognizeBusinessLicenseResult.h"
#include "model/RecognizeCharacterRequest.h"
#include "model/RecognizeCharacterResult.h"
#include "model/RecognizeChinapassportRequest.h"
#include "model/RecognizeChinapassportResult.h"
#include "model/RecognizeDriverLicenseRequest.h"
#include "model/RecognizeDriverLicenseResult.h"
#include "model/RecognizeDrivingLicenseRequest.h"
#include "model/RecognizeDrivingLicenseResult.h"
#include "model/RecognizeIdentityCardRequest.h"
#include "model/RecognizeIdentityCardResult.h"
#include "model/RecognizeLicensePlateRequest.h"
#include "model/RecognizeLicensePlateResult.h"
#include "model/RecognizePassportMRZRequest.h"
#include "model/RecognizePassportMRZResult.h"
#include "model/RecognizeQrCodeRequest.h"
#include "model/RecognizeQrCodeResult.h"
#include "model/RecognizeStampRequest.h"
#include "model/RecognizeStampResult.h"
#include "model/RecognizeTableRequest.h"
#include "model/RecognizeTableResult.h"
#include "model/RecognizeTakeoutOrderRequest.h"
#include "model/RecognizeTakeoutOrderResult.h"
#include "model/RecognizeTaxiInvoiceRequest.h"
#include "model/RecognizeTaxiInvoiceResult.h"
#include "model/RecognizeTrainTicketRequest.h"
#include "model/RecognizeTrainTicketResult.h"
#include "model/RecognizeVATInvoiceRequest.h"
#include "model/RecognizeVATInvoiceResult.h"
#include "model/RecognizeVINCodeRequest.h"
#include "model/RecognizeVINCodeResult.h"
#include "model/RecognizeVerificationcodeRequest.h"
#include "model/RecognizeVerificationcodeResult.h"
#include "model/TrimDocumentRequest.h"
#include "model/TrimDocumentResult.h"
namespace AlibabaCloud
{
namespace Ocr
{
class ALIBABACLOUD_OCR_EXPORT OcrClient : public RpcServiceClient
{
public:
typedef Outcome<Error, Model::GetAsyncJobResultResult> GetAsyncJobResultOutcome;
typedef std::future<GetAsyncJobResultOutcome> GetAsyncJobResultOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::GetAsyncJobResultRequest&, const GetAsyncJobResultOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> GetAsyncJobResultAsyncHandler;
typedef Outcome<Error, Model::RecognizeAccountPageResult> RecognizeAccountPageOutcome;
typedef std::future<RecognizeAccountPageOutcome> RecognizeAccountPageOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeAccountPageRequest&, const RecognizeAccountPageOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeAccountPageAsyncHandler;
typedef Outcome<Error, Model::RecognizeBankCardResult> RecognizeBankCardOutcome;
typedef std::future<RecognizeBankCardOutcome> RecognizeBankCardOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeBankCardRequest&, const RecognizeBankCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeBankCardAsyncHandler;
typedef Outcome<Error, Model::RecognizeBusinessCardResult> RecognizeBusinessCardOutcome;
typedef std::future<RecognizeBusinessCardOutcome> RecognizeBusinessCardOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeBusinessCardRequest&, const RecognizeBusinessCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeBusinessCardAsyncHandler;
typedef Outcome<Error, Model::RecognizeBusinessLicenseResult> RecognizeBusinessLicenseOutcome;
typedef std::future<RecognizeBusinessLicenseOutcome> RecognizeBusinessLicenseOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeBusinessLicenseRequest&, const RecognizeBusinessLicenseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeBusinessLicenseAsyncHandler;
typedef Outcome<Error, Model::RecognizeCharacterResult> RecognizeCharacterOutcome;
typedef std::future<RecognizeCharacterOutcome> RecognizeCharacterOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeCharacterRequest&, const RecognizeCharacterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeCharacterAsyncHandler;
typedef Outcome<Error, Model::RecognizeChinapassportResult> RecognizeChinapassportOutcome;
typedef std::future<RecognizeChinapassportOutcome> RecognizeChinapassportOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeChinapassportRequest&, const RecognizeChinapassportOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeChinapassportAsyncHandler;
typedef Outcome<Error, Model::RecognizeDriverLicenseResult> RecognizeDriverLicenseOutcome;
typedef std::future<RecognizeDriverLicenseOutcome> RecognizeDriverLicenseOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeDriverLicenseRequest&, const RecognizeDriverLicenseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeDriverLicenseAsyncHandler;
typedef Outcome<Error, Model::RecognizeDrivingLicenseResult> RecognizeDrivingLicenseOutcome;
typedef std::future<RecognizeDrivingLicenseOutcome> RecognizeDrivingLicenseOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeDrivingLicenseRequest&, const RecognizeDrivingLicenseOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeDrivingLicenseAsyncHandler;
typedef Outcome<Error, Model::RecognizeIdentityCardResult> RecognizeIdentityCardOutcome;
typedef std::future<RecognizeIdentityCardOutcome> RecognizeIdentityCardOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeIdentityCardRequest&, const RecognizeIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeIdentityCardAsyncHandler;
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::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::RecognizeQrCodeResult> RecognizeQrCodeOutcome;
typedef std::future<RecognizeQrCodeOutcome> RecognizeQrCodeOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeQrCodeRequest&, const RecognizeQrCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeQrCodeAsyncHandler;
typedef Outcome<Error, Model::RecognizeStampResult> RecognizeStampOutcome;
typedef std::future<RecognizeStampOutcome> RecognizeStampOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeStampRequest&, const RecognizeStampOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeStampAsyncHandler;
typedef Outcome<Error, Model::RecognizeTableResult> RecognizeTableOutcome;
typedef std::future<RecognizeTableOutcome> RecognizeTableOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeTableRequest&, const RecognizeTableOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeTableAsyncHandler;
typedef Outcome<Error, Model::RecognizeTakeoutOrderResult> RecognizeTakeoutOrderOutcome;
typedef std::future<RecognizeTakeoutOrderOutcome> RecognizeTakeoutOrderOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeTakeoutOrderRequest&, const RecognizeTakeoutOrderOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeTakeoutOrderAsyncHandler;
typedef Outcome<Error, Model::RecognizeTaxiInvoiceResult> RecognizeTaxiInvoiceOutcome;
typedef std::future<RecognizeTaxiInvoiceOutcome> RecognizeTaxiInvoiceOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeTaxiInvoiceRequest&, const RecognizeTaxiInvoiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeTaxiInvoiceAsyncHandler;
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::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;
typedef Outcome<Error, Model::RecognizeVINCodeResult> RecognizeVINCodeOutcome;
typedef std::future<RecognizeVINCodeOutcome> RecognizeVINCodeOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeVINCodeRequest&, const RecognizeVINCodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVINCodeAsyncHandler;
typedef Outcome<Error, Model::RecognizeVerificationcodeResult> RecognizeVerificationcodeOutcome;
typedef std::future<RecognizeVerificationcodeOutcome> RecognizeVerificationcodeOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeVerificationcodeRequest&, const RecognizeVerificationcodeOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVerificationcodeAsyncHandler;
typedef Outcome<Error, Model::TrimDocumentResult> TrimDocumentOutcome;
typedef std::future<TrimDocumentOutcome> TrimDocumentOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::TrimDocumentRequest&, const TrimDocumentOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> TrimDocumentAsyncHandler;
OcrClient(const Credentials &credentials, const ClientConfiguration &configuration);
OcrClient(const std::shared_ptr<CredentialsProvider> &credentialsProvider, const ClientConfiguration &configuration);
OcrClient(const std::string &accessKeyId, const std::string &accessKeySecret, const ClientConfiguration &configuration);
~OcrClient();
GetAsyncJobResultOutcome getAsyncJobResult(const Model::GetAsyncJobResultRequest &request)const;
void getAsyncJobResultAsync(const Model::GetAsyncJobResultRequest& request, const GetAsyncJobResultAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
GetAsyncJobResultOutcomeCallable getAsyncJobResultCallable(const Model::GetAsyncJobResultRequest& request) const;
RecognizeAccountPageOutcome recognizeAccountPage(const Model::RecognizeAccountPageRequest &request)const;
void recognizeAccountPageAsync(const Model::RecognizeAccountPageRequest& request, const RecognizeAccountPageAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeAccountPageOutcomeCallable recognizeAccountPageCallable(const Model::RecognizeAccountPageRequest& request) const;
RecognizeBankCardOutcome recognizeBankCard(const Model::RecognizeBankCardRequest &request)const;
void recognizeBankCardAsync(const Model::RecognizeBankCardRequest& request, const RecognizeBankCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeBankCardOutcomeCallable recognizeBankCardCallable(const Model::RecognizeBankCardRequest& request) const;
RecognizeBusinessCardOutcome recognizeBusinessCard(const Model::RecognizeBusinessCardRequest &request)const;
void recognizeBusinessCardAsync(const Model::RecognizeBusinessCardRequest& request, const RecognizeBusinessCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeBusinessCardOutcomeCallable recognizeBusinessCardCallable(const Model::RecognizeBusinessCardRequest& request) const;
RecognizeBusinessLicenseOutcome recognizeBusinessLicense(const Model::RecognizeBusinessLicenseRequest &request)const;
void recognizeBusinessLicenseAsync(const Model::RecognizeBusinessLicenseRequest& request, const RecognizeBusinessLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeBusinessLicenseOutcomeCallable recognizeBusinessLicenseCallable(const Model::RecognizeBusinessLicenseRequest& request) const;
RecognizeCharacterOutcome recognizeCharacter(const Model::RecognizeCharacterRequest &request)const;
void recognizeCharacterAsync(const Model::RecognizeCharacterRequest& request, const RecognizeCharacterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeCharacterOutcomeCallable recognizeCharacterCallable(const Model::RecognizeCharacterRequest& request) const;
RecognizeChinapassportOutcome recognizeChinapassport(const Model::RecognizeChinapassportRequest &request)const;
void recognizeChinapassportAsync(const Model::RecognizeChinapassportRequest& request, const RecognizeChinapassportAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeChinapassportOutcomeCallable recognizeChinapassportCallable(const Model::RecognizeChinapassportRequest& request) const;
RecognizeDriverLicenseOutcome recognizeDriverLicense(const Model::RecognizeDriverLicenseRequest &request)const;
void recognizeDriverLicenseAsync(const Model::RecognizeDriverLicenseRequest& request, const RecognizeDriverLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeDriverLicenseOutcomeCallable recognizeDriverLicenseCallable(const Model::RecognizeDriverLicenseRequest& request) const;
RecognizeDrivingLicenseOutcome recognizeDrivingLicense(const Model::RecognizeDrivingLicenseRequest &request)const;
void recognizeDrivingLicenseAsync(const Model::RecognizeDrivingLicenseRequest& request, const RecognizeDrivingLicenseAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeDrivingLicenseOutcomeCallable recognizeDrivingLicenseCallable(const Model::RecognizeDrivingLicenseRequest& request) const;
RecognizeIdentityCardOutcome recognizeIdentityCard(const Model::RecognizeIdentityCardRequest &request)const;
void recognizeIdentityCardAsync(const Model::RecognizeIdentityCardRequest& request, const RecognizeIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeIdentityCardOutcomeCallable recognizeIdentityCardCallable(const Model::RecognizeIdentityCardRequest& request) const;
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;
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;
RecognizeQrCodeOutcome recognizeQrCode(const Model::RecognizeQrCodeRequest &request)const;
void recognizeQrCodeAsync(const Model::RecognizeQrCodeRequest& request, const RecognizeQrCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeQrCodeOutcomeCallable recognizeQrCodeCallable(const Model::RecognizeQrCodeRequest& request) const;
RecognizeStampOutcome recognizeStamp(const Model::RecognizeStampRequest &request)const;
void recognizeStampAsync(const Model::RecognizeStampRequest& request, const RecognizeStampAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeStampOutcomeCallable recognizeStampCallable(const Model::RecognizeStampRequest& request) const;
RecognizeTableOutcome recognizeTable(const Model::RecognizeTableRequest &request)const;
void recognizeTableAsync(const Model::RecognizeTableRequest& request, const RecognizeTableAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeTableOutcomeCallable recognizeTableCallable(const Model::RecognizeTableRequest& request) const;
RecognizeTakeoutOrderOutcome recognizeTakeoutOrder(const Model::RecognizeTakeoutOrderRequest &request)const;
void recognizeTakeoutOrderAsync(const Model::RecognizeTakeoutOrderRequest& request, const RecognizeTakeoutOrderAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeTakeoutOrderOutcomeCallable recognizeTakeoutOrderCallable(const Model::RecognizeTakeoutOrderRequest& request) const;
RecognizeTaxiInvoiceOutcome recognizeTaxiInvoice(const Model::RecognizeTaxiInvoiceRequest &request)const;
void recognizeTaxiInvoiceAsync(const Model::RecognizeTaxiInvoiceRequest& request, const RecognizeTaxiInvoiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeTaxiInvoiceOutcomeCallable recognizeTaxiInvoiceCallable(const Model::RecognizeTaxiInvoiceRequest& request) const;
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;
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;
RecognizeVINCodeOutcome recognizeVINCode(const Model::RecognizeVINCodeRequest &request)const;
void recognizeVINCodeAsync(const Model::RecognizeVINCodeRequest& request, const RecognizeVINCodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVINCodeOutcomeCallable recognizeVINCodeCallable(const Model::RecognizeVINCodeRequest& request) const;
RecognizeVerificationcodeOutcome recognizeVerificationcode(const Model::RecognizeVerificationcodeRequest &request)const;
void recognizeVerificationcodeAsync(const Model::RecognizeVerificationcodeRequest& request, const RecognizeVerificationcodeAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVerificationcodeOutcomeCallable recognizeVerificationcodeCallable(const Model::RecognizeVerificationcodeRequest& request) const;
TrimDocumentOutcome trimDocument(const Model::TrimDocumentRequest &request)const;
void trimDocumentAsync(const Model::TrimDocumentRequest& request, const TrimDocumentAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
TrimDocumentOutcomeCallable trimDocumentCallable(const Model::TrimDocumentRequest& request) const;
private:
std::shared_ptr<EndpointProvider> endpointProvider_;
};
}
}
#endif // !ALIBABACLOUD_OCR_OCRCLIENT_H_

32
ocr/include/alibabacloud/ocr/OcrExport.h Normal file
View File

@@ -0,0 +1,32 @@
/*
* 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_OCREXPORT_H_
#define ALIBABACLOUD_OCR_OCREXPORT_H_
#include <alibabacloud/core/Global.h>
#if defined(ALIBABACLOUD_SHARED)
# if defined(ALIBABACLOUD_OCR_LIBRARY)
# define ALIBABACLOUD_OCR_EXPORT ALIBABACLOUD_DECL_EXPORT
# else
# define ALIBABACLOUD_OCR_EXPORT ALIBABACLOUD_DECL_IMPORT
# endif
#else
# define ALIBABACLOUD_OCR_EXPORT
#endif
#endif // !ALIBABACLOUD_OCR_OCREXPORT_H_

51
ocr/include/alibabacloud/ocr/model/GetAsyncJobResultRequest.h Normal file
View File

@@ -0,0 +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_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_

59
ocr/include/alibabacloud/ocr/model/GetAsyncJobResultResult.h Normal file
View File

@@ -0,0 +1,59 @@
/*
* 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_GETASYNCJOBRESULTRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_GETASYNCJOBRESULTRESULT_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 GetAsyncJobResultResult : public ServiceResult
{
public:
struct Data
{
std::string status;
std::string errorCode;
std::string errorMessage;
std::string jobId;
std::string result;
};
GetAsyncJobResultResult();
explicit GetAsyncJobResultResult(const std::string &payload);
~GetAsyncJobResultResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_GETASYNCJOBRESULTRESULT_H_

51
ocr/include/alibabacloud/ocr/model/RecognizeAccountPageRequest.h Normal file
View File

@@ -0,0 +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_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_

103
ocr/include/alibabacloud/ocr/model/RecognizeAccountPageResult.h Normal file
View File

@@ -0,0 +1,103 @@
/*
* 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_RECOGNIZEACCOUNTPAGERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEACCOUNTPAGERESULT_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 RecognizeAccountPageResult : public ServiceResult
{
public:
struct Data
{
struct TitleArea
{
int left;
int top;
int height;
int width;
};
struct InvalidStampArea
{
int left;
int top;
int height;
int width;
};
struct UndertakeStampArea
{
int left;
int top;
int height;
int width;
};
struct RegisterStampArea
{
int left;
int top;
int height;
int width;
};
struct OtherStampArea
{
int left;
int top;
int height;
int width;
};
std::string nativePlace;
std::vector<OtherStampArea> otherStampAreas;
std::string birthPlace;
std::vector<RegisterStampArea> registerStampAreas;
std::string gender;
std::vector<InvalidStampArea> invalidStampAreas;
std::string nationality;
std::string name;
std::vector<UndertakeStampArea> undertakeStampAreas;
std::string relation;
float angle;
TitleArea titleArea;
std::string birthDate;
std::string iDNumber;
};
RecognizeAccountPageResult();
explicit RecognizeAccountPageResult(const std::string &payload);
~RecognizeAccountPageResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEACCOUNTPAGERESULT_H_

51
ocr/include/alibabacloud/ocr/model/RecognizeBankCardRequest.h Normal file
View File

@@ -0,0 +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_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_

57
ocr/include/alibabacloud/ocr/model/RecognizeBankCardResult.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* 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_RECOGNIZEBANKCARDRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEBANKCARDRESULT_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 RecognizeBankCardResult : public ServiceResult
{
public:
struct Data
{
std::string bankName;
std::string cardNumber;
std::string validDate;
};
RecognizeBankCardResult();
explicit RecognizeBankCardResult(const std::string &payload);
~RecognizeBankCardResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEBANKCARDRESULT_H_

51
ocr/include/alibabacloud/ocr/model/RecognizeBusinessCardRequest.h Normal file
View File

@@ -0,0 +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_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_

62
ocr/include/alibabacloud/ocr/model/RecognizeBusinessCardResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* 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_RECOGNIZEBUSINESSCARDRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSCARDRESULT_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 RecognizeBusinessCardResult : public ServiceResult
{
public:
struct Data
{
std::vector<std::string> addresses;
std::vector<std::string> departments;
std::vector<std::string> companies;
std::vector<std::string> emails;
std::vector<std::string> officePhoneNumbers;
std::vector<std::string> cellPhoneNumbers;
std::vector<std::string> titles;
std::string name;
};
RecognizeBusinessCardResult();
explicit RecognizeBusinessCardResult(const std::string &payload);
~RecognizeBusinessCardResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSCARDRESULT_H_

51
ocr/include/alibabacloud/ocr/model/RecognizeBusinessLicenseRequest.h Normal file
View File

@@ -0,0 +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_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_

96
ocr/include/alibabacloud/ocr/model/RecognizeBusinessLicenseResult.h Normal file
View File

@@ -0,0 +1,96 @@
/*
* 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_RECOGNIZEBUSINESSLICENSERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSLICENSERESULT_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 RecognizeBusinessLicenseResult : public ServiceResult
{
public:
struct Data
{
struct Emblem
{
int left;
int top;
int height;
int width;
};
struct Title
{
int left;
int top;
int height;
int width;
};
struct Stamp
{
int left;
int top;
int height;
int width;
};
struct QRCode
{
int left;
int top;
int height;
int width;
};
Stamp stamp;
std::string validPeriod;
std::string address;
Title title;
std::string capital;
std::string legalPerson;
std::string establishDate;
std::string name;
std::string registerNumber;
QRCode qRCode;
std::string type;
std::string angle;
Emblem emblem;
std::string business;
};
RecognizeBusinessLicenseResult();
explicit RecognizeBusinessLicenseResult(const std::string &payload);
~RecognizeBusinessLicenseResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEBUSINESSLICENSERESULT_H_

57
ocr/include/alibabacloud/ocr/model/RecognizeCharacterRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* 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();
int getImageType()const;
void setImageType(int imageType);
bool getOutputProbability()const;
void setOutputProbability(bool outputProbability);
std::string getImageURL()const;
void setImageURL(const std::string& imageURL);
int getMinHeight()const;
void setMinHeight(int minHeight);
private:
int imageType_;
bool outputProbability_;
std::string imageURL_;
int minHeight_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERREQUEST_H_

69
ocr/include/alibabacloud/ocr/model/RecognizeCharacterResult.h Normal file
View File

@@ -0,0 +1,69 @@
/*
* 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_RECOGNIZECHARACTERRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERRESULT_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 RecognizeCharacterResult : public ServiceResult
{
public:
struct Data
{
struct Result
{
struct TextRectangles
{
int left;
int angle;
int top;
int height;
int width;
};
TextRectangles textRectangles;
float probability;
std::string text;
};
std::vector<Result> results;
};
RecognizeCharacterResult();
explicit RecognizeCharacterResult(const std::string &payload);
~RecognizeCharacterResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZECHARACTERRESULT_H_

48
ocr/include/alibabacloud/ocr/model/RecognizeChinapassportRequest.h Normal file
View File

@@ -0,0 +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_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_

76
ocr/include/alibabacloud/ocr/model/RecognizeChinapassportResult.h Normal file
View File

@@ -0,0 +1,76 @@
/*
* 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_RECOGNIZECHINAPASSPORTRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZECHINAPASSPORTRESULT_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 RecognizeChinapassportResult : public ServiceResult
{
public:
struct Data
{
std::string expiryDate;
std::string sourceCountry;
std::string birthPlace;
std::string issuePlaceRaw;
std::string nameChineseRaw;
std::string authority;
std::string sex;
std::string issueDate;
std::string birthDay;
std::string lineZero;
std::string issuePlace;
std::string expiryDay;
bool success;
std::string name;
std::string lineOne;
std::string nameChinese;
std::string type;
std::string personId;
std::string passportNo;
std::string birthPlaceRaw;
std::string country;
std::string birthDate;
};
RecognizeChinapassportResult();
explicit RecognizeChinapassportResult(const std::string &payload);
~RecognizeChinapassportResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZECHINAPASSPORTRESULT_H_

54
ocr/include/alibabacloud/ocr/model/RecognizeDriverLicenseRequest.h Normal file
View File

@@ -0,0 +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_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_

71
ocr/include/alibabacloud/ocr/model/RecognizeDriverLicenseResult.h Normal file
View File

@@ -0,0 +1,71 @@
/*
* 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_RECOGNIZEDRIVERLICENSERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSERESULT_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 RecognizeDriverLicenseResult : public ServiceResult
{
public:
struct Data
{
struct FaceResult
{
std::string startDate;
std::string address;
std::string licenseNumber;
std::string vehicleType;
std::string issueDate;
std::string gender;
std::string endDate;
std::string name;
};
struct BackResult
{
std::string archiveNumber;
};
FaceResult faceResult;
BackResult backResult;
};
RecognizeDriverLicenseResult();
explicit RecognizeDriverLicenseResult(const std::string &payload);
~RecognizeDriverLicenseResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVERLICENSERESULT_H_

54
ocr/include/alibabacloud/ocr/model/RecognizeDrivingLicenseRequest.h Normal file
View File

@@ -0,0 +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_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_

82
ocr/include/alibabacloud/ocr/model/RecognizeDrivingLicenseResult.h Normal file
View File

@@ -0,0 +1,82 @@
/*
* 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_RECOGNIZEDRIVINGLICENSERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSERESULT_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 RecognizeDrivingLicenseResult : public ServiceResult
{
public:
struct Data
{
struct FaceResult
{
std::string plateNumber;
std::string owner;
std::string engineNumber;
std::string address;
std::string vehicleType;
std::string model;
std::string registerDate;
std::string issueDate;
std::string vin;
std::string useCharacter;
};
struct BackResult
{
std::string approvedPassengerCapacity;
std::string grossMass;
std::string plateNumber;
std::string energyType;
std::string tractionMass;
std::string approvedLoad;
std::string inspectionRecord;
std::string unladenMass;
std::string fileNumber;
std::string overallDimension;
};
FaceResult faceResult;
BackResult backResult;
};
RecognizeDrivingLicenseResult();
explicit RecognizeDrivingLicenseResult(const std::string &payload);
~RecognizeDrivingLicenseResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEDRIVINGLICENSERESULT_H_

54
ocr/include/alibabacloud/ocr/model/RecognizeIdentityCardRequest.h Normal file
View File

@@ -0,0 +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_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_

100
ocr/include/alibabacloud/ocr/model/RecognizeIdentityCardResult.h Normal file
View File

@@ -0,0 +1,100 @@
/*
* 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_RECOGNIZEIDENTITYCARDRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDRESULT_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 RecognizeIdentityCardResult : public ServiceResult
{
public:
struct Data
{
struct FrontResult
{
struct FaceRectangle
{
struct Center
{
float x;
float y;
};
struct Size
{
float height;
float width;
};
Center center;
float angle;
Size size;
};
struct CardArea
{
float x;
float y;
};
struct FaceRectVertice
{
float x;
float y;
};
std::string address;
FaceRectangle faceRectangle;
std::vector<FaceRectVertice> faceRectVertices;
std::vector<CardArea> cardAreas;
std::string gender;
std::string nationality;
std::string name;
std::string iDNumber;
std::string birthDate;
};
struct BackResult
{
std::string startDate;
std::string issue;
std::string endDate;
};
FrontResult frontResult;
BackResult backResult;
};
RecognizeIdentityCardResult();
explicit RecognizeIdentityCardResult(const std::string &payload);
~RecognizeIdentityCardResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEIDENTITYCARDRESULT_H_

51
ocr/include/alibabacloud/ocr/model/RecognizeLicensePlateRequest.h Normal file
View File

@@ -0,0 +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_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_

70
ocr/include/alibabacloud/ocr/model/RecognizeLicensePlateResult.h Normal file
View File

@@ -0,0 +1,70 @@
/*
* 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_RECOGNIZELICENSEPLATERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZELICENSEPLATERESULT_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 RecognizeLicensePlateResult : public ServiceResult
{
public:
struct Data
{
struct Plate
{
struct Roi
{
int w;
int h;
int x;
int y;
};
std::string plateNumber;
float confidence;
std::string plateType;
float plateTypeConfidence;
Roi roi;
};
std::vector<Plate> plates;
};
RecognizeLicensePlateResult();
explicit RecognizeLicensePlateResult(const std::string &payload);
~RecognizeLicensePlateResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZELICENSEPLATERESULT_H_

48
ocr/include/alibabacloud/ocr/model/RecognizePassportMRZRequest.h Normal file
View File

@@ -0,0 +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_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_

63
ocr/include/alibabacloud/ocr/model/RecognizePassportMRZResult.h Normal file
View File

@@ -0,0 +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.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEPASSPORTMRZRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEPASSPORTMRZRESULT_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 RecognizePassportMRZResult : public ServiceResult
{
public:
struct Data
{
struct Region
{
std::string content;
float recognitionScore;
std::vector<std::string> bandBoxes;
std::string name;
float detectionScore;
};
std::vector<Region> regions;
};
RecognizePassportMRZResult();
explicit RecognizePassportMRZResult(const std::string &payload);
~RecognizePassportMRZResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEPASSPORTMRZRESULT_H_

53
ocr/include/alibabacloud/ocr/model/RecognizeQrCodeRequest.h Normal file
View File

@@ -0,0 +1,53 @@
/*
* 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();
std::vector<Tasks> getTasks()const;
void setTasks(const std::vector<Tasks>& tasks);
private:
std::vector<Tasks> tasks_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODEREQUEST_H_

68
ocr/include/alibabacloud/ocr/model/RecognizeQrCodeResult.h Normal file
View File

@@ -0,0 +1,68 @@
/*
* 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_RECOGNIZEQRCODERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODERESULT_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 RecognizeQrCodeResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
struct Result
{
std::string suggestion;
float rate;
std::vector<std::string> qrCodesData;
std::string label;
};
std::string taskId;
std::vector<Element::Result> results;
std::string imageURL;
};
std::vector<Element> elements;
};
RecognizeQrCodeResult();
explicit RecognizeQrCodeResult(const std::string &payload);
~RecognizeQrCodeResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEQRCODERESULT_H_

51
ocr/include/alibabacloud/ocr/model/RecognizeStampRequest.h Normal file
View File

@@ -0,0 +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_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_

78
ocr/include/alibabacloud/ocr/model/RecognizeStampResult.h Normal file
View File

@@ -0,0 +1,78 @@
/*
* 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_RECOGNIZESTAMPRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZESTAMPRESULT_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 RecognizeStampResult : public ServiceResult
{
public:
struct Data
{
struct ResultsItem
{
struct Roi
{
int left;
int top;
int height;
int width;
};
struct Text
{
float confidence;
std::string content;
};
struct GeneralTextItem
{
float confidence;
std::string content;
};
Text text;
Roi roi;
std::vector<ResultsItem::GeneralTextItem> generalText;
};
std::vector<ResultsItem> results;
};
RecognizeStampResult();
explicit RecognizeStampResult(const std::string &payload);
~RecognizeStampResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZESTAMPRESULT_H_

66
ocr/include/alibabacloud/ocr/model/RecognizeTableRequest.h Normal file
View File

@@ -0,0 +1,66 @@
/*
* 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_

76
ocr/include/alibabacloud/ocr/model/RecognizeTableResult.h Normal file
View File

@@ -0,0 +1,76 @@
/*
* 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_RECOGNIZETABLERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLERESULT_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 RecognizeTableResult : public ServiceResult
{
public:
struct Data
{
struct Table
{
struct TableRow
{
struct TableColumn
{
int endRow;
int endColumn;
std::vector<std::string> texts;
int height;
int width;
int startRow;
int startColumn;
};
std::vector<TableRow::TableColumn> tableColumns;
};
std::vector<std::string> head;
std::vector<std::string> tail;
std::vector<Table::TableRow> tableRows;
};
std::string fileContent;
std::vector<Table> tables;
};
RecognizeTableResult();
explicit RecognizeTableResult(const std::string &payload);
~RecognizeTableResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETABLERESULT_H_

48
ocr/include/alibabacloud/ocr/model/RecognizeTakeoutOrderRequest.h Normal file
View File

@@ -0,0 +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_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_

62
ocr/include/alibabacloud/ocr/model/RecognizeTakeoutOrderResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* 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_RECOGNIZETAKEOUTORDERRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETAKEOUTORDERRESULT_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 RecognizeTakeoutOrderResult : public ServiceResult
{
public:
struct Data
{
struct Element
{
float score;
std::string value;
std::string name;
std::vector<std::string> boxes;
};
std::vector<Element> elements;
};
RecognizeTakeoutOrderResult();
explicit RecognizeTakeoutOrderResult(const std::string &payload);
~RecognizeTakeoutOrderResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETAKEOUTORDERRESULT_H_

51
ocr/include/alibabacloud/ocr/model/RecognizeTaxiInvoiceRequest.h Normal file
View File

@@ -0,0 +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_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_

89
ocr/include/alibabacloud/ocr/model/RecognizeTaxiInvoiceResult.h Normal file
View File

@@ -0,0 +1,89 @@
/*
* 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_RECOGNIZETAXIINVOICERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETAXIINVOICERESULT_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 RecognizeTaxiInvoiceResult : public ServiceResult
{
public:
struct Data
{
struct Invoice
{
struct InvoiceRoi
{
float w;
float h;
float x;
float y;
};
struct Item
{
struct ItemRoi
{
struct Center
{
float x;
float y;
};
struct Size
{
float w;
float h;
};
Center center;
float angle;
Size size;
};
ItemRoi itemRoi;
std::string text;
};
int rotateType;
InvoiceRoi invoiceRoi;
std::vector<Invoice::Item> items;
};
std::vector<Invoice> invoices;
};
RecognizeTaxiInvoiceResult();
explicit RecognizeTaxiInvoiceResult(const std::string &payload);
~RecognizeTaxiInvoiceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETAXIINVOICERESULT_H_

51
ocr/include/alibabacloud/ocr/model/RecognizeTrainTicketRequest.h Normal file
View File

@@ -0,0 +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_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_

62
ocr/include/alibabacloud/ocr/model/RecognizeTrainTicketResult.h Normal file
View File

@@ -0,0 +1,62 @@
/*
* 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_RECOGNIZETRAINTICKETRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETRAINTICKETRESULT_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 RecognizeTrainTicketResult : public ServiceResult
{
public:
struct Data
{
std::string destination;
std::string seat;
std::string number;
float price;
std::string level;
std::string date;
std::string name;
std::string departureStation;
};
RecognizeTrainTicketResult();
explicit RecognizeTrainTicketResult(const std::string &payload);
~RecognizeTrainTicketResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETRAINTICKETRESULT_H_

51
ocr/include/alibabacloud/ocr/model/RecognizeVATInvoiceRequest.h Normal file
View File

@@ -0,0 +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_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_

100
ocr/include/alibabacloud/ocr/model/RecognizeVATInvoiceResult.h Normal file
View File

@@ -0,0 +1,100 @@
/*
* 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_RECOGNIZEVATINVOICERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVATINVOICERESULT_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 RecognizeVATInvoiceResult : public ServiceResult
{
public:
struct Data
{
struct Content
{
std::string checker;
std::string payeeAddress;
std::string payeeName;
std::string payerAddress;
std::string antiFakeCode;
std::string payerBankName;
std::string invoiceNo;
std::string payerRegisterNo;
std::string payerName;
std::string withoutTaxAmount;
std::string invoiceAmount;
std::string taxAmount;
std::string payeeBankName;
std::string clerk;
std::string invoiceCode;
std::string payeeRegisterNo;
std::string invoiceDate;
std::string sumAmount;
std::string payee;
};
struct Box
{
std::vector<std::string> payerRegisterNoes;
std::vector<std::string> payerAddresses;
std::vector<std::string> invoiceAmounts;
std::vector<std::string> invoiceDates;
std::vector<std::string> payeeAddresses;
std::vector<std::string> clerks;
std::vector<std::string> withoutTaxAmounts;
std::vector<std::string> checkers;
std::vector<std::string> invoiceCodes;
std::vector<std::string> taxAmounts;
std::vector<std::string> sumAmounts;
std::vector<std::string> payerNames;
std::vector<std::string> invoiceFakeCodes;
std::vector<std::string> payeeNames;
std::vector<std::string> payeeBankNames;
std::vector<std::string> payees;
std::vector<std::string> invoiceNoes;
std::vector<std::string> payerBankNames;
std::vector<std::string> payeeRegisterNoes;
};
Content content;
Box box;
};
RecognizeVATInvoiceResult();
explicit RecognizeVATInvoiceResult(const std::string &payload);
~RecognizeVATInvoiceResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVATINVOICERESULT_H_

51
ocr/include/alibabacloud/ocr/model/RecognizeVINCodeRequest.h Normal file
View File

@@ -0,0 +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_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_

55
ocr/include/alibabacloud/ocr/model/RecognizeVINCodeResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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_RECOGNIZEVINCODERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVINCODERESULT_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 RecognizeVINCodeResult : public ServiceResult
{
public:
struct Data
{
std::string vinCode;
};
RecognizeVINCodeResult();
explicit RecognizeVINCodeResult(const std::string &payload);
~RecognizeVINCodeResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVINCODERESULT_H_

48
ocr/include/alibabacloud/ocr/model/RecognizeVerificationcodeRequest.h Normal file
View File

@@ -0,0 +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_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_

55
ocr/include/alibabacloud/ocr/model/RecognizeVerificationcodeResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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_RECOGNIZEVERIFICATIONCODERESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVERIFICATIONCODERESULT_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 RecognizeVerificationcodeResult : public ServiceResult
{
public:
struct Data
{
std::string content;
};
RecognizeVerificationcodeResult();
explicit RecognizeVerificationcodeResult(const std::string &payload);
~RecognizeVerificationcodeResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVERIFICATIONCODERESULT_H_

57
ocr/include/alibabacloud/ocr/model/TrimDocumentRequest.h Normal file
View File

@@ -0,0 +1,57 @@
/*
* 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_

55
ocr/include/alibabacloud/ocr/model/TrimDocumentResult.h Normal file
View File

@@ -0,0 +1,55 @@
/*
* 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_TRIMDOCUMENTRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTRESULT_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 TrimDocumentResult : public ServiceResult
{
public:
struct Data
{
std::string content;
};
TrimDocumentResult();
explicit TrimDocumentResult(const std::string &payload);
~TrimDocumentResult();
Data getData()const;
protected:
void parse(const std::string &payload);
private:
Data data_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_TRIMDOCUMENTRESULT_H_