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

Update RecognizeVideoCharacter.

Browse Source
This commit is contained in:
sdk-team
2023-02-15 07:14:04 +00:00
parent aa2239005d
commit 2515aa4e65
32 changed files with 1 additions and 5016 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -44,12 +44,8 @@
#include "model/RecognizeDrivingLicenseResult.h"
#include "model/RecognizeIdentityCardRequest.h"
#include "model/RecognizeIdentityCardResult.h"
#include "model/RecognizeIndonesiaIdentityCardRequest.h"
#include "model/RecognizeIndonesiaIdentityCardResult.h"
#include "model/RecognizeLicensePlateRequest.h"
#include "model/RecognizeLicensePlateResult.h"
#include "model/RecognizeMalaysiaIdentityCardRequest.h"
#include "model/RecognizeMalaysiaIdentityCardResult.h"
#include "model/RecognizePassportMRZRequest.h"
#include "model/RecognizePassportMRZResult.h"
#include "model/RecognizePdfRequest.h"
@@ -60,8 +56,6 @@
#include "model/RecognizeQrCodeResult.h"
#include "model/RecognizeQuotaInvoiceRequest.h"
#include "model/RecognizeQuotaInvoiceResult.h"
#include "model/RecognizeRussiaIdentityCardRequest.h"
#include "model/RecognizeRussiaIdentityCardResult.h"
#include "model/RecognizeStampRequest.h"
#include "model/RecognizeStampResult.h"
#include "model/RecognizeTableRequest.h"
@@ -74,22 +68,14 @@
#include "model/RecognizeTicketInvoiceResult.h"
#include "model/RecognizeTrainTicketRequest.h"
#include "model/RecognizeTrainTicketResult.h"
#include "model/RecognizeTurkeyIdentityCardRequest.h"
#include "model/RecognizeTurkeyIdentityCardResult.h"
#include "model/RecognizeUkraineIdentityCardRequest.h"
#include "model/RecognizeUkraineIdentityCardResult.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/RecognizeVideoCastCrewListRequest.h"
#include "model/RecognizeVideoCastCrewListResult.h"
#include "model/RecognizeVideoCharacterRequest.h"
#include "model/RecognizeVideoCharacterResult.h"
#include "model/RecognizeVietnamIdentityCardRequest.h"
#include "model/RecognizeVietnamIdentityCardResult.h"
#include "model/TrimDocumentRequest.h"
#include "model/TrimDocumentResult.h"
@@ -134,15 +120,9 @@ namespace AlibabaCloud
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::RecognizeIndonesiaIdentityCardResult> RecognizeIndonesiaIdentityCardOutcome;
typedef std::future<RecognizeIndonesiaIdentityCardOutcome> RecognizeIndonesiaIdentityCardOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeIndonesiaIdentityCardRequest&, const RecognizeIndonesiaIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeIndonesiaIdentityCardAsyncHandler;
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::RecognizeMalaysiaIdentityCardResult> RecognizeMalaysiaIdentityCardOutcome;
typedef std::future<RecognizeMalaysiaIdentityCardOutcome> RecognizeMalaysiaIdentityCardOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeMalaysiaIdentityCardRequest&, const RecognizeMalaysiaIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeMalaysiaIdentityCardAsyncHandler;
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;
@@ -158,9 +138,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RecognizeQuotaInvoiceResult> RecognizeQuotaInvoiceOutcome;
typedef std::future<RecognizeQuotaInvoiceOutcome> RecognizeQuotaInvoiceOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeQuotaInvoiceRequest&, const RecognizeQuotaInvoiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeQuotaInvoiceAsyncHandler;
typedef Outcome<Error, Model::RecognizeRussiaIdentityCardResult> RecognizeRussiaIdentityCardOutcome;
typedef std::future<RecognizeRussiaIdentityCardOutcome> RecognizeRussiaIdentityCardOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeRussiaIdentityCardRequest&, const RecognizeRussiaIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeRussiaIdentityCardAsyncHandler;
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;
@@ -179,12 +156,6 @@ namespace AlibabaCloud
typedef Outcome<Error, Model::RecognizeTrainTicketResult> RecognizeTrainTicketOutcome;
typedef std::future<RecognizeTrainTicketOutcome> RecognizeTrainTicketOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeTrainTicketRequest&, const RecognizeTrainTicketOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeTrainTicketAsyncHandler;
typedef Outcome<Error, Model::RecognizeTurkeyIdentityCardResult> RecognizeTurkeyIdentityCardOutcome;
typedef std::future<RecognizeTurkeyIdentityCardOutcome> RecognizeTurkeyIdentityCardOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeTurkeyIdentityCardRequest&, const RecognizeTurkeyIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeTurkeyIdentityCardAsyncHandler;
typedef Outcome<Error, Model::RecognizeUkraineIdentityCardResult> RecognizeUkraineIdentityCardOutcome;
typedef std::future<RecognizeUkraineIdentityCardOutcome> RecognizeUkraineIdentityCardOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeUkraineIdentityCardRequest&, const RecognizeUkraineIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeUkraineIdentityCardAsyncHandler;
typedef Outcome<Error, Model::RecognizeVATInvoiceResult> RecognizeVATInvoiceOutcome;
typedef std::future<RecognizeVATInvoiceOutcome> RecognizeVATInvoiceOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeVATInvoiceRequest&, const RecognizeVATInvoiceOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVATInvoiceAsyncHandler;
@@ -194,15 +165,9 @@ namespace AlibabaCloud
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::RecognizeVideoCastCrewListResult> RecognizeVideoCastCrewListOutcome;
typedef std::future<RecognizeVideoCastCrewListOutcome> RecognizeVideoCastCrewListOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeVideoCastCrewListRequest&, const RecognizeVideoCastCrewListOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVideoCastCrewListAsyncHandler;
typedef Outcome<Error, Model::RecognizeVideoCharacterResult> RecognizeVideoCharacterOutcome;
typedef std::future<RecognizeVideoCharacterOutcome> RecognizeVideoCharacterOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeVideoCharacterRequest&, const RecognizeVideoCharacterOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVideoCharacterAsyncHandler;
typedef Outcome<Error, Model::RecognizeVietnamIdentityCardResult> RecognizeVietnamIdentityCardOutcome;
typedef std::future<RecognizeVietnamIdentityCardOutcome> RecognizeVietnamIdentityCardOutcomeCallable;
typedef std::function<void(const OcrClient*, const Model::RecognizeVietnamIdentityCardRequest&, const RecognizeVietnamIdentityCardOutcome&, const std::shared_ptr<const AsyncCallerContext>&)> RecognizeVietnamIdentityCardAsyncHandler;
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;
@@ -244,15 +209,9 @@ namespace AlibabaCloud
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;
RecognizeIndonesiaIdentityCardOutcome recognizeIndonesiaIdentityCard(const Model::RecognizeIndonesiaIdentityCardRequest &request)const;
void recognizeIndonesiaIdentityCardAsync(const Model::RecognizeIndonesiaIdentityCardRequest& request, const RecognizeIndonesiaIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeIndonesiaIdentityCardOutcomeCallable recognizeIndonesiaIdentityCardCallable(const Model::RecognizeIndonesiaIdentityCardRequest& 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;
RecognizeMalaysiaIdentityCardOutcome recognizeMalaysiaIdentityCard(const Model::RecognizeMalaysiaIdentityCardRequest &request)const;
void recognizeMalaysiaIdentityCardAsync(const Model::RecognizeMalaysiaIdentityCardRequest& request, const RecognizeMalaysiaIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeMalaysiaIdentityCardOutcomeCallable recognizeMalaysiaIdentityCardCallable(const Model::RecognizeMalaysiaIdentityCardRequest& 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;
@@ -268,9 +227,6 @@ namespace AlibabaCloud
RecognizeQuotaInvoiceOutcome recognizeQuotaInvoice(const Model::RecognizeQuotaInvoiceRequest &request)const;
void recognizeQuotaInvoiceAsync(const Model::RecognizeQuotaInvoiceRequest& request, const RecognizeQuotaInvoiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeQuotaInvoiceOutcomeCallable recognizeQuotaInvoiceCallable(const Model::RecognizeQuotaInvoiceRequest& request) const;
RecognizeRussiaIdentityCardOutcome recognizeRussiaIdentityCard(const Model::RecognizeRussiaIdentityCardRequest &request)const;
void recognizeRussiaIdentityCardAsync(const Model::RecognizeRussiaIdentityCardRequest& request, const RecognizeRussiaIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeRussiaIdentityCardOutcomeCallable recognizeRussiaIdentityCardCallable(const Model::RecognizeRussiaIdentityCardRequest& 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;
@@ -289,12 +245,6 @@ namespace AlibabaCloud
RecognizeTrainTicketOutcome recognizeTrainTicket(const Model::RecognizeTrainTicketRequest &request)const;
void recognizeTrainTicketAsync(const Model::RecognizeTrainTicketRequest& request, const RecognizeTrainTicketAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeTrainTicketOutcomeCallable recognizeTrainTicketCallable(const Model::RecognizeTrainTicketRequest& request) const;
RecognizeTurkeyIdentityCardOutcome recognizeTurkeyIdentityCard(const Model::RecognizeTurkeyIdentityCardRequest &request)const;
void recognizeTurkeyIdentityCardAsync(const Model::RecognizeTurkeyIdentityCardRequest& request, const RecognizeTurkeyIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeTurkeyIdentityCardOutcomeCallable recognizeTurkeyIdentityCardCallable(const Model::RecognizeTurkeyIdentityCardRequest& request) const;
RecognizeUkraineIdentityCardOutcome recognizeUkraineIdentityCard(const Model::RecognizeUkraineIdentityCardRequest &request)const;
void recognizeUkraineIdentityCardAsync(const Model::RecognizeUkraineIdentityCardRequest& request, const RecognizeUkraineIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeUkraineIdentityCardOutcomeCallable recognizeUkraineIdentityCardCallable(const Model::RecognizeUkraineIdentityCardRequest& request) const;
RecognizeVATInvoiceOutcome recognizeVATInvoice(const Model::RecognizeVATInvoiceRequest &request)const;
void recognizeVATInvoiceAsync(const Model::RecognizeVATInvoiceRequest& request, const RecognizeVATInvoiceAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVATInvoiceOutcomeCallable recognizeVATInvoiceCallable(const Model::RecognizeVATInvoiceRequest& request) const;
@@ -304,15 +254,9 @@ namespace AlibabaCloud
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;
RecognizeVideoCastCrewListOutcome recognizeVideoCastCrewList(const Model::RecognizeVideoCastCrewListRequest &request)const;
void recognizeVideoCastCrewListAsync(const Model::RecognizeVideoCastCrewListRequest& request, const RecognizeVideoCastCrewListAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVideoCastCrewListOutcomeCallable recognizeVideoCastCrewListCallable(const Model::RecognizeVideoCastCrewListRequest& request) const;
RecognizeVideoCharacterOutcome recognizeVideoCharacter(const Model::RecognizeVideoCharacterRequest &request)const;
void recognizeVideoCharacterAsync(const Model::RecognizeVideoCharacterRequest& request, const RecognizeVideoCharacterAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVideoCharacterOutcomeCallable recognizeVideoCharacterCallable(const Model::RecognizeVideoCharacterRequest& request) const;
RecognizeVietnamIdentityCardOutcome recognizeVietnamIdentityCard(const Model::RecognizeVietnamIdentityCardRequest &request)const;
void recognizeVietnamIdentityCardAsync(const Model::RecognizeVietnamIdentityCardRequest& request, const RecognizeVietnamIdentityCardAsyncHandler& handler, const std::shared_ptr<const AsyncCallerContext>& context = nullptr) const;
RecognizeVietnamIdentityCardOutcomeCallable recognizeVietnamIdentityCardCallable(const Model::RecognizeVietnamIdentityCardRequest& 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;

42
ocr/include/alibabacloud/ocr/model/RecognizeIndonesiaIdentityCardRequest.h
View File

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

322
ocr/include/alibabacloud/ocr/model/RecognizeIndonesiaIdentityCardResult.h
View File

@@ -1,322 +0,0 @@
/*
* 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_RECOGNIZEINDONESIAIDENTITYCARDRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEINDONESIAIDENTITYCARDRESULT_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 RecognizeIndonesiaIdentityCardResult : public ServiceResult
{
public:
struct Data
{
struct AddressFirstLine
{
struct KeyPointsItem
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem> keyPoints;
std::string text;
};
struct AddressSecondLine
{
struct KeyPointsItem2
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem2> keyPoints1;
std::string text;
};
struct AddressThirdLine
{
struct KeyPointsItem4
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem4> keyPoints3;
std::string text;
};
struct AddressFourthLine
{
struct KeyPointsItem6
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem6> keyPoints5;
std::string text;
};
struct AddressFifthLine
{
struct KeyPointsItem8
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem8> keyPoints7;
};
struct BirthDate
{
struct KeyPointsItem10
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem10> keyPoints9;
};
struct BirthPlace
{
struct KeyPointsItem12
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem12> keyPoints11;
std::string text;
};
struct CardBox
{
struct KeyPointsItem14
{
float x;
float y;
};
std::vector<KeyPointsItem14> keyPoints13;
std::string score;
std::string text;
};
struct ExpiryDate
{
struct KeyPointsItem16
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem16> keyPoints15;
std::string text;
};
struct Gender
{
struct KeyPointsItem18
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem18> keyPoints17;
};
struct Height
{
struct KeyPointsItem20
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem20> keyPoints19;
};
struct IdNumber
{
struct KeyPointsItem22
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem22> keyPoints21;
std::string text;
};
struct LicenseNumber
{
struct KeyPointsItem24
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem24> keyPoints23;
std::string text;
};
struct MaritalStatus
{
struct KeyPointsItem26
{
float x;
float y;
};
std::vector<KeyPointsItem26> keyPoints25;
std::string score;
std::string text;
};
struct NameFirstLine
{
struct KeyPointsItem28
{
float x;
float y;
};
std::vector<KeyPointsItem28> keyPoints27;
std::string score;
std::string text;
};
struct NameSecondLine
{
struct KeyPointsItem30
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem30> keyPoints29;
};
struct Nationality
{
struct KeyPointsItem32
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem32> keyPoints31;
std::string text;
};
struct Occupation
{
struct KeyPointsItem34
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem34> keyPoints33;
std::string text;
};
struct PortraitBox
{
struct KeyPointsItem36
{
float x;
float y;
};
std::vector<KeyPointsItem36> keyPoints35;
std::string score;
std::string text;
};
struct Province
{
struct KeyPointsItem38
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem38> keyPoints37;
std::string text;
};
struct Religion
{
struct KeyPointsItem40
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem40> keyPoints39;
};
struct Sex
{
struct KeyPointsItem42
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem42> keyPoints41;
std::string text;
};
ExpiryDate expiryDate;
BirthPlace birthPlace;
LicenseNumber licenseNumber;
IdNumber idNumber;
CardBox cardBox;
Sex sex;
NameFirstLine nameFirstLine;
Religion religion;
Gender gender;
PortraitBox portraitBox;
Nationality nationality;
Province province;
MaritalStatus maritalStatus;
Occupation occupation;
AddressThirdLine addressThirdLine;
AddressFourthLine addressFourthLine;
AddressFirstLine addressFirstLine;
Height height;
NameSecondLine nameSecondLine;
AddressSecondLine addressSecondLine;
AddressFifthLine addressFifthLine;
BirthDate birthDate;
};
RecognizeIndonesiaIdentityCardResult();
explicit RecognizeIndonesiaIdentityCardResult(const std::string &payload);
~RecognizeIndonesiaIdentityCardResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEINDONESIAIDENTITYCARDRESULT_H_

42
ocr/include/alibabacloud/ocr/model/RecognizeMalaysiaIdentityCardRequest.h
View File

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

238
ocr/include/alibabacloud/ocr/model/RecognizeMalaysiaIdentityCardResult.h
View File

@@ -1,238 +0,0 @@
/*
* 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_RECOGNIZEMALAYSIAIDENTITYCARDRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEMALAYSIAIDENTITYCARDRESULT_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 RecognizeMalaysiaIdentityCardResult : public ServiceResult
{
public:
struct Data
{
struct AddressFirstLine
{
struct KeyPointsItem
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem> keyPoints;
std::string text;
};
struct AddressSecondLine
{
struct KeyPointsItem2
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem2> keyPoints1;
std::string text;
};
struct AddressThirdLine
{
struct KeyPointsItem4
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem4> keyPoints3;
std::string text;
};
struct AddressFourthLine
{
struct KeyPointsItem6
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem6> keyPoints5;
std::string text;
};
struct AddressFifthLine
{
struct KeyPointsItem8
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem8> keyPoints7;
};
struct CardBox
{
struct KeyPointsItem10
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem10> keyPoints9;
};
struct DriveClass
{
struct KeyPointsItem12
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem12> keyPoints11;
std::string text;
};
struct ExpiryDate
{
struct KeyPointsItem14
{
float x;
float y;
};
std::vector<KeyPointsItem14> keyPoints13;
std::string score;
std::string text;
};
struct IdNumber
{
struct KeyPointsItem16
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem16> keyPoints15;
std::string text;
};
struct IssueDate
{
struct KeyPointsItem18
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem18> keyPoints17;
};
struct NameFirstLine
{
struct KeyPointsItem20
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem20> keyPoints19;
};
struct NameSecondLine
{
struct KeyPointsItem22
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem22> keyPoints21;
std::string text;
};
struct Nationality
{
struct KeyPointsItem24
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem24> keyPoints23;
std::string text;
};
struct PortraitBox
{
struct KeyPointsItem26
{
float x;
float y;
};
std::vector<KeyPointsItem26> keyPoints25;
std::string score;
std::string text;
};
struct Sex
{
struct KeyPointsItem28
{
float x;
float y;
};
std::vector<KeyPointsItem28> keyPoints27;
std::string score;
std::string text;
};
ExpiryDate expiryDate;
IdNumber idNumber;
CardBox cardBox;
Sex sex;
NameFirstLine nameFirstLine;
IssueDate issueDate;
PortraitBox portraitBox;
Nationality nationality;
AddressThirdLine addressThirdLine;
AddressFourthLine addressFourthLine;
AddressFirstLine addressFirstLine;
NameSecondLine nameSecondLine;
DriveClass driveClass;
AddressSecondLine addressSecondLine;
AddressFifthLine addressFifthLine;
};
RecognizeMalaysiaIdentityCardResult();
explicit RecognizeMalaysiaIdentityCardResult(const std::string &payload);
~RecognizeMalaysiaIdentityCardResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEMALAYSIAIDENTITYCARDRESULT_H_

42
ocr/include/alibabacloud/ocr/model/RecognizeRussiaIdentityCardRequest.h
View File

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

202
ocr/include/alibabacloud/ocr/model/RecognizeRussiaIdentityCardResult.h
View File

@@ -1,202 +0,0 @@
/*
* 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_RECOGNIZERUSSIAIDENTITYCARDRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZERUSSIAIDENTITYCARDRESULT_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 RecognizeRussiaIdentityCardResult : public ServiceResult
{
public:
struct Data
{
struct BirthDate
{
struct KeyPointsItem
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem> keyPoints;
std::string text;
};
struct BirthPlaceFirstLine
{
struct KeyPointsItem2
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem2> keyPoints1;
std::string text;
};
struct BirthPlaceSecondLine
{
struct KeyPointsItem4
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem4> keyPoints3;
std::string text;
};
struct BirthPlaceThirdLine
{
struct KeyPointsItem6
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem6> keyPoints5;
std::string text;
};
struct CardBox
{
struct KeyPointsItem8
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem8> keyPoints7;
};
struct GivenName
{
struct KeyPointsItem10
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem10> keyPoints9;
};
struct IdNumber
{
struct KeyPointsItem12
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem12> keyPoints11;
std::string text;
};
struct PaternalName
{
struct KeyPointsItem14
{
float x;
float y;
};
std::vector<KeyPointsItem14> keyPoints13;
std::string score;
std::string text;
};
struct PortraitBox
{
struct KeyPointsItem16
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem16> keyPoints15;
std::string text;
};
struct Sex
{
struct KeyPointsItem18
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem18> keyPoints17;
};
struct SurnameFirstLine
{
struct KeyPointsItem20
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem20> keyPoints19;
};
struct SurnameSecondLine
{
struct KeyPointsItem22
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem22> keyPoints21;
std::string text;
};
SurnameFirstLine surnameFirstLine;
BirthPlaceFirstLine birthPlaceFirstLine;
BirthPlaceSecondLine birthPlaceSecondLine;
IdNumber idNumber;
PaternalName paternalName;
CardBox cardBox;
Sex sex;
SurnameSecondLine surnameSecondLine;
GivenName givenName;
PortraitBox portraitBox;
BirthPlaceThirdLine birthPlaceThirdLine;
BirthDate birthDate;
};
RecognizeRussiaIdentityCardResult();
explicit RecognizeRussiaIdentityCardResult(const std::string &payload);
~RecognizeRussiaIdentityCardResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZERUSSIAIDENTITYCARDRESULT_H_

42
ocr/include/alibabacloud/ocr/model/RecognizeTurkeyIdentityCardRequest.h
View File

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

586
ocr/include/alibabacloud/ocr/model/RecognizeTurkeyIdentityCardResult.h
View File

@@ -1,586 +0,0 @@
/*
* 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_RECOGNIZETURKEYIDENTITYCARDRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZETURKEYIDENTITYCARDRESULT_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 RecognizeTurkeyIdentityCardResult : public ServiceResult
{
public:
struct Data
{
struct AuxiliaryTools
{
struct KeyPointsItem
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem> keyPoints;
std::string text;
};
struct BirthDate
{
struct KeyPointsItem2
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem2> keyPoints1;
std::string text;
};
struct BirthPlace
{
struct KeyPointsItem4
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem4> keyPoints3;
std::string text;
};
struct BloodType
{
struct KeyPointsItem6
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem6> keyPoints5;
std::string text;
};
struct CardBox
{
struct KeyPointsItem8
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem8> keyPoints7;
};
struct Cilt
{
struct KeyPointsItem10
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem10> keyPoints9;
};
struct DocumentNumber
{
struct KeyPointsItem12
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem12> keyPoints11;
std::string text;
};
struct DriveClass
{
struct KeyPointsItem14
{
float x;
float y;
};
std::vector<KeyPointsItem14> keyPoints13;
float score;
std::string text;
};
struct DueDate
{
struct KeyPointsItem16
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem16> keyPoints15;
std::string text;
};
struct Duzenleyen
{
struct KeyPointsItem18
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem18> keyPoints17;
};
struct EntryNumber
{
struct KeyPointsItem20
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem20> keyPoints19;
};
struct ExpiryDate
{
struct KeyPointsItem22
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem22> keyPoints21;
std::string text;
};
struct FatherName
{
struct KeyPointsItem24
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem24> keyPoints23;
std::string text;
};
struct ForeignersId
{
struct KeyPointsItem26
{
float x;
float y;
};
std::vector<KeyPointsItem26> keyPoints25;
float score;
std::string text;
};
struct Gender
{
struct KeyPointsItem28
{
float x;
float y;
};
std::vector<KeyPointsItem28> keyPoints27;
float score;
std::string text;
};
struct GivenName
{
struct KeyPointsItem30
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem30> keyPoints29;
};
struct IdNumber
{
struct KeyPointsItem32
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem32> keyPoints31;
std::string text;
};
struct IssueBy
{
struct KeyPointsItem34
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem34> keyPoints33;
std::string text;
};
struct IssueCounty
{
struct KeyPointsItem36
{
float x;
float y;
};
std::vector<KeyPointsItem36> keyPoints35;
float score;
std::string text;
};
struct IssueDate
{
struct KeyPointsItem38
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem38> keyPoints37;
std::string text;
};
struct IssuePlace
{
struct KeyPointsItem40
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem40> keyPoints39;
};
struct Kutuk
{
struct KeyPointsItem42
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem42> keyPoints41;
std::string text;
};
struct LicenseNumber
{
struct KeyPointsItem44
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem44> keyPoints43;
std::string text;
};
struct MaritalStatus
{
struct KeyPointsItem46
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem46> keyPoints45;
std::string text;
};
struct MotherName
{
struct KeyPointsItem48
{
float x;
float y;
};
std::vector<KeyPointsItem48> keyPoints47;
float score;
std::string text;
};
struct Name
{
struct KeyPointsItem50
{
float x;
float y;
};
std::vector<KeyPointsItem50> keyPoints49;
float score;
std::string text;
};
struct Nationality
{
struct KeyPointsItem52
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem52> keyPoints51;
};
struct NeighborhoodVillage
{
struct KeyPointsItem54
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem54> keyPoints53;
std::string text;
};
struct PageNumber
{
struct KeyPointsItem56
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem56> keyPoints55;
std::string text;
};
struct PassportNumber
{
struct KeyPointsItem58
{
float x;
float y;
};
std::vector<KeyPointsItem58> keyPoints57;
float score;
std::string text;
};
struct PortraitBox
{
struct KeyPointsItem60
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem60> keyPoints59;
std::string text;
};
struct Province
{
struct KeyPointsItem62
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem62> keyPoints61;
std::string text;
};
struct ProvinceOfResidence
{
struct KeyPointsItem64
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem64> keyPoints63;
std::string text;
};
struct ReasonOfIssue
{
struct KeyPointsItem66
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem66> keyPoints65;
std::string text;
};
struct RegisterNumber
{
struct KeyPointsItem68
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem68> keyPoints67;
std::string text;
};
struct Religion
{
struct KeyPointsItem70
{
float x;
float y;
};
std::vector<KeyPointsItem70> keyPoints69;
float score;
std::string text;
};
struct Sayfa
{
struct KeyPointsItem72
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem72> keyPoints71;
std::string text;
};
struct Seri
{
struct KeyPointsItem74
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem74> keyPoints73;
};
struct Surname
{
struct KeyPointsItem76
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem76> keyPoints75;
std::string text;
};
struct TypeOfResidencePermit
{
struct KeyPointsItem78
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem78> keyPoints77;
std::string text;
};
struct ValidUntil
{
struct KeyPointsItem80
{
float x;
float y;
};
std::vector<KeyPointsItem80> keyPoints79;
float score;
std::string text;
};
struct Village
{
struct KeyPointsItem82
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem82> keyPoints81;
};
struct VolumeNumber
{
struct KeyPointsItem84
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem84> keyPoints83;
std::string text;
};
struct Sex
{
struct KeyPointsItem86
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem86> keyPoints85;
std::string text;
};
ExpiryDate expiryDate;
BirthPlace birthPlace;
ForeignersId foreignersId;
LicenseNumber licenseNumber;
IdNumber idNumber;
CardBox cardBox;
Sex sex;
ReasonOfIssue reasonOfIssue;
GivenName givenName;
Gender gender;
NeighborhoodVillage neighborhoodVillage;
PortraitBox portraitBox;
IssuePlace issuePlace;
TypeOfResidencePermit typeOfResidencePermit;
Seri seri;
Name name;
PageNumber pageNumber;
MotherName motherName;
Kutuk kutuk;
DriveClass driveClass;
DueDate dueDate;
IssueBy issueBy;
Village village;
Religion religion;
IssueDate issueDate;
DocumentNumber documentNumber;
AuxiliaryTools auxiliaryTools;
Cilt cilt;
Nationality nationality;
Province province;
ValidUntil validUntil;
VolumeNumber volumeNumber;
EntryNumber entryNumber;
MaritalStatus maritalStatus;
RegisterNumber registerNumber;
Duzenleyen duzenleyen;
ProvinceOfResidence provinceOfResidence;
PassportNumber passportNumber;
Sayfa sayfa;
IssueCounty issueCounty;
Surname surname;
BloodType bloodType;
BirthDate birthDate;
FatherName fatherName;
};
RecognizeTurkeyIdentityCardResult();
explicit RecognizeTurkeyIdentityCardResult(const std::string &payload);
~RecognizeTurkeyIdentityCardResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZETURKEYIDENTITYCARDRESULT_H_

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

@@ -1,42 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeUkraineIdentityCardRequest : public RpcServiceRequest {
public:
RecognizeUkraineIdentityCardRequest();
~RecognizeUkraineIdentityCardRequest();
std::string getImageUrl() const;
void setImageUrl(const std::string &imageUrl);
private:
std::string imageUrl_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDREQUEST_H_

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

@@ -1,214 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/ocr/OcrExport.h>
namespace AlibabaCloud
{
namespace Ocr
{
namespace Model
{
class ALIBABACLOUD_OCR_EXPORT RecognizeUkraineIdentityCardResult : public ServiceResult
{
public:
struct Data
{
struct BirthDate
{
struct KeyPointsItem
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem> keyPoints;
std::string text;
};
struct CardBox
{
struct KeyPointsItem2
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem2> keyPoints1;
std::string text;
};
struct DocumentNumber
{
struct KeyPointsItem4
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem4> keyPoints3;
std::string text;
};
struct ExpiryDate
{
struct KeyPointsItem6
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem6> keyPoints5;
std::string text;
};
struct NameEnglish
{
struct KeyPointsItem8
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem8> keyPoints7;
};
struct NameUkraine
{
struct KeyPointsItem10
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem10> keyPoints9;
};
struct Nationality
{
struct KeyPointsItem12
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem12> keyPoints11;
std::string text;
};
struct Patronymic
{
struct KeyPointsItem14
{
float x;
float y;
};
std::vector<KeyPointsItem14> keyPoints13;
float score;
std::string text;
};
struct PortraitBox
{
struct KeyPointsItem16
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem16> keyPoints15;
std::string text;
};
struct RecordNumber
{
struct KeyPointsItem18
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem18> keyPoints17;
};
struct Sex
{
struct KeyPointsItem20
{
float x;
float y;
};
float score;
std::string text;
std::vector<KeyPointsItem20> keyPoints19;
};
struct SurnameEnglish
{
struct KeyPointsItem22
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem22> keyPoints21;
std::string text;
};
struct SurnameUkraine
{
struct KeyPointsItem24
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem24> keyPoints23;
std::string text;
};
ExpiryDate expiryDate;
CardBox cardBox;
Sex sex;
NameUkraine nameUkraine;
PortraitBox portraitBox;
DocumentNumber documentNumber;
SurnameEnglish surnameEnglish;
Nationality nationality;
SurnameUkraine surnameUkraine;
NameEnglish nameEnglish;
Patronymic patronymic;
RecordNumber recordNumber;
BirthDate birthDate;
};
RecognizeUkraineIdentityCardResult();
explicit RecognizeUkraineIdentityCardResult(const std::string &payload);
~RecognizeUkraineIdentityCardResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEUKRAINEIDENTITYCARDRESULT_H_

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

@@ -1,54 +0,0 @@
/*
* Copyright 2009-2017 Alibaba Cloud All rights reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_
#include <alibabacloud/ocr/OcrExport.h>
#include <alibabacloud/core/RpcServiceRequest.h>
#include <string>
#include <vector>
#include <map>
namespace AlibabaCloud {
namespace Ocr {
namespace Model {
class ALIBABACLOUD_OCR_EXPORT RecognizeVideoCastCrewListRequest : public RpcServiceRequest {
public:
struct Params {
std::string type;
};
RecognizeVideoCastCrewListRequest();
~RecognizeVideoCastCrewListRequest();
std::vector<Params> getParams() const;
void setParams(const std::vector<Params> &params);
bool getAsync() const;
void setAsync(bool async);
std::string getRegisterUrl() const;
void setRegisterUrl(const std::string &registerUrl);
std::string getVideoUrl() const;
void setVideoUrl(const std::string &videoUrl);
private:
std::vector<Params> params_;
bool async_;
std::string registerUrl_;
std::string videoUrl_;
};
} // namespace Model
} // namespace Ocr
} // namespace AlibabaCloud
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTREQUEST_H_

49
ocr/include/alibabacloud/ocr/model/RecognizeVideoCastCrewListResult.h
View File

@@ -1,49 +0,0 @@
/*
* 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_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_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 RecognizeVideoCastCrewListResult : public ServiceResult
{
public:
RecognizeVideoCastCrewListResult();
explicit RecognizeVideoCastCrewListResult(const std::string &payload);
~RecognizeVideoCastCrewListResult();
protected:
void parse(const std::string &payload);
private:
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIDEOCASTCREWLISTRESULT_H_

42
ocr/include/alibabacloud/ocr/model/RecognizeVietnamIdentityCardRequest.h
View File

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

238
ocr/include/alibabacloud/ocr/model/RecognizeVietnamIdentityCardResult.h
View File

@@ -1,238 +0,0 @@
/*
* 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_RECOGNIZEVIETNAMIDENTITYCARDRESULT_H_
#define ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIETNAMIDENTITYCARDRESULT_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 RecognizeVietnamIdentityCardResult : public ServiceResult
{
public:
struct Data
{
struct AddressFirstLine
{
struct KeyPointsItem
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem> keyPoints;
std::string text;
};
struct AddressSecondLine
{
struct KeyPointsItem2
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem2> keyPoints1;
std::string text;
};
struct BirthDate
{
struct KeyPointsItem4
{
float x;
float y;
};
float score;
std::vector<KeyPointsItem4> keyPoints3;
std::string text;
};
struct CardBox
{
struct KeyPointsItem6
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem6> keyPoints5;
std::string text;
};
struct DriveClass
{
struct KeyPointsItem8
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem8> keyPoints7;
};
struct ExpiryDate
{
struct KeyPointsItem10
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem10> keyPoints9;
};
struct FullName
{
struct KeyPointsItem12
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem12> keyPoints11;
std::string text;
};
struct IdNumber
{
struct KeyPointsItem14
{
float x;
float y;
};
std::vector<KeyPointsItem14> keyPoints13;
std::string score;
std::string text;
};
struct Nationality
{
struct KeyPointsItem16
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem16> keyPoints15;
std::string text;
};
struct OriginPlaceFirstLine
{
struct KeyPointsItem18
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem18> keyPoints17;
};
struct OriginPlaceSecondLine
{
struct KeyPointsItem20
{
float x;
float y;
};
std::string score;
std::string text;
std::vector<KeyPointsItem20> keyPoints19;
};
struct PortraitBox
{
struct KeyPointsItem22
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem22> keyPoints21;
std::string text;
};
struct ResidencePlaceFirstLine
{
struct KeyPointsItem24
{
float x;
float y;
};
std::string score;
std::vector<KeyPointsItem24> keyPoints23;
std::string text;
};
struct ResidencePlaceSecondLine
{
struct KeyPointsItem26
{
float x;
float y;
};
std::vector<KeyPointsItem26> keyPoints25;
std::string score;
std::string text;
};
struct Sex
{
struct KeyPointsItem28
{
float x;
float y;
};
std::vector<KeyPointsItem28> keyPoints27;
std::string score;
std::string text;
};
ExpiryDate expiryDate;
OriginPlaceFirstLine originPlaceFirstLine;
IdNumber idNumber;
CardBox cardBox;
Sex sex;
PortraitBox portraitBox;
ResidencePlaceSecondLine residencePlaceSecondLine;
Nationality nationality;
OriginPlaceSecondLine originPlaceSecondLine;
AddressFirstLine addressFirstLine;
FullName fullName;
DriveClass driveClass;
AddressSecondLine addressSecondLine;
BirthDate birthDate;
ResidencePlaceFirstLine residencePlaceFirstLine;
};
RecognizeVietnamIdentityCardResult();
explicit RecognizeVietnamIdentityCardResult(const std::string &payload);
~RecognizeVietnamIdentityCardResult();
std::string getMessage()const;
Data getData()const;
std::string getCode()const;
protected:
void parse(const std::string &payload);
private:
std::string message_;
Data data_;
std::string code_;
};
}
}
}
#endif // !ALIBABACLOUD_OCR_MODEL_RECOGNIZEVIETNAMIDENTITYCARDRESULT_H_